1 /*
2 * lib/route/route_obj.c Route Object
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation version 2.1
7 * of the License.
8 *
9 * Copyright (c) 2003-2008 Thomas Graf <tgraf@suug.ch>
10 */
11
12 /**
13 * @ingroup route
14 * @defgroup route_obj Route Object
15 *
16 * @par Attributes
17 * @code
18 * Name Default
19 * -------------------------------------------------------------
20 * routing table RT_TABLE_MAIN
21 * scope RT_SCOPE_NOWHERE
22 * tos 0
23 * protocol RTPROT_STATIC
24 * prio 0
25 * family AF_UNSPEC
26 * type RTN_UNICAST
27 * iif NULL
28 * @endcode
29 *
30 * @{
31 */
32
33 #include <netlink-private/netlink.h>
34 #include <netlink/netlink.h>
35 #include <netlink/cache.h>
36 #include <netlink/utils.h>
37 #include <netlink/data.h>
38 #include <netlink/hashtable.h>
39 #include <netlink/route/rtnl.h>
40 #include <netlink/route/route.h>
41 #include <netlink/route/link.h>
42 #include <netlink/route/nexthop.h>
43
44 /** @cond SKIP */
45 #define ROUTE_ATTR_FAMILY 0x000001
46 #define ROUTE_ATTR_TOS 0x000002
47 #define ROUTE_ATTR_TABLE 0x000004
48 #define ROUTE_ATTR_PROTOCOL 0x000008
49 #define ROUTE_ATTR_SCOPE 0x000010
50 #define ROUTE_ATTR_TYPE 0x000020
51 #define ROUTE_ATTR_FLAGS 0x000040
52 #define ROUTE_ATTR_DST 0x000080
53 #define ROUTE_ATTR_SRC 0x000100
54 #define ROUTE_ATTR_IIF 0x000200
55 #define ROUTE_ATTR_OIF 0x000400
56 #define ROUTE_ATTR_GATEWAY 0x000800
57 #define ROUTE_ATTR_PRIO 0x001000
58 #define ROUTE_ATTR_PREF_SRC 0x002000
59 #define ROUTE_ATTR_METRICS 0x004000
60 #define ROUTE_ATTR_MULTIPATH 0x008000
61 #define ROUTE_ATTR_REALMS 0x010000
62 #define ROUTE_ATTR_CACHEINFO 0x020000
63 /** @endcond */
64
route_constructor(struct nl_object * c)65 static void route_constructor(struct nl_object *c)
66 {
67 struct rtnl_route *r = (struct rtnl_route *) c;
68
69 r->rt_family = AF_UNSPEC;
70 r->rt_scope = RT_SCOPE_NOWHERE;
71 r->rt_table = RT_TABLE_MAIN;
72 r->rt_protocol = RTPROT_STATIC;
73 r->rt_type = RTN_UNICAST;
74 r->rt_prio = 0;
75
76 nl_init_list_head(&r->rt_nexthops);
77 }
78
route_free_data(struct nl_object * c)79 static void route_free_data(struct nl_object *c)
80 {
81 struct rtnl_route *r = (struct rtnl_route *) c;
82 struct rtnl_nexthop *nh, *tmp;
83
84 if (r == NULL)
85 return;
86
87 nl_addr_put(r->rt_dst);
88 nl_addr_put(r->rt_src);
89 nl_addr_put(r->rt_pref_src);
90
91 nl_list_for_each_entry_safe(nh, tmp, &r->rt_nexthops, rtnh_list) {
92 rtnl_route_remove_nexthop(r, nh);
93 rtnl_route_nh_free(nh);
94 }
95 }
96
route_clone(struct nl_object * _dst,struct nl_object * _src)97 static int route_clone(struct nl_object *_dst, struct nl_object *_src)
98 {
99 struct rtnl_route *dst = (struct rtnl_route *) _dst;
100 struct rtnl_route *src = (struct rtnl_route *) _src;
101 struct rtnl_nexthop *nh, *new;
102
103 if (src->rt_dst)
104 if (!(dst->rt_dst = nl_addr_clone(src->rt_dst)))
105 return -NLE_NOMEM;
106
107 if (src->rt_src)
108 if (!(dst->rt_src = nl_addr_clone(src->rt_src)))
109 return -NLE_NOMEM;
110
111 if (src->rt_pref_src)
112 if (!(dst->rt_pref_src = nl_addr_clone(src->rt_pref_src)))
113 return -NLE_NOMEM;
114
115 /* Will be inc'ed again while adding the nexthops of the source */
116 dst->rt_nr_nh = 0;
117
118 nl_init_list_head(&dst->rt_nexthops);
119 nl_list_for_each_entry(nh, &src->rt_nexthops, rtnh_list) {
120 new = rtnl_route_nh_clone(nh);
121 if (!new)
122 return -NLE_NOMEM;
123
124 rtnl_route_add_nexthop(dst, new);
125 }
126
127 return 0;
128 }
129
route_dump_line(struct nl_object * a,struct nl_dump_params * p)130 static void route_dump_line(struct nl_object *a, struct nl_dump_params *p)
131 {
132 struct rtnl_route *r = (struct rtnl_route *) a;
133 int cache = 0, flags;
134 char buf[64];
135
136 if (r->rt_flags & RTM_F_CLONED)
137 cache = 1;
138
139 nl_dump_line(p, "%s ", nl_af2str(r->rt_family, buf, sizeof(buf)));
140
141 if (cache)
142 nl_dump(p, "cache ");
143
144 if (!(r->ce_mask & ROUTE_ATTR_DST) ||
145 nl_addr_get_len(r->rt_dst) == 0)
146 nl_dump(p, "default ");
147 else
148 nl_dump(p, "%s ", nl_addr2str(r->rt_dst, buf, sizeof(buf)));
149
150 if (r->ce_mask & ROUTE_ATTR_TABLE && !cache)
151 nl_dump(p, "table %s ",
152 rtnl_route_table2str(r->rt_table, buf, sizeof(buf)));
153
154 if (r->ce_mask & ROUTE_ATTR_TYPE)
155 nl_dump(p, "type %s ",
156 nl_rtntype2str(r->rt_type, buf, sizeof(buf)));
157
158 if (r->ce_mask & ROUTE_ATTR_TOS && r->rt_tos != 0)
159 nl_dump(p, "tos %#x ", r->rt_tos);
160
161 if (r->ce_mask & ROUTE_ATTR_MULTIPATH) {
162 struct rtnl_nexthop *nh;
163
164 nl_list_for_each_entry(nh, &r->rt_nexthops, rtnh_list) {
165 p->dp_ivar = NH_DUMP_FROM_ONELINE;
166 rtnl_route_nh_dump(nh, p);
167 }
168 }
169
170 flags = r->rt_flags & ~(RTM_F_CLONED);
171 if (r->ce_mask & ROUTE_ATTR_FLAGS && flags) {
172
173 nl_dump(p, "<");
174
175 #define PRINT_FLAG(f) if (flags & RTNH_F_##f) { \
176 flags &= ~RTNH_F_##f; nl_dump(p, #f "%s", flags ? "," : ""); }
177 PRINT_FLAG(DEAD);
178 PRINT_FLAG(ONLINK);
179 PRINT_FLAG(PERVASIVE);
180 #undef PRINT_FLAG
181
182 #define PRINT_FLAG(f) if (flags & RTM_F_##f) { \
183 flags &= ~RTM_F_##f; nl_dump(p, #f "%s", flags ? "," : ""); }
184 PRINT_FLAG(NOTIFY);
185 PRINT_FLAG(EQUALIZE);
186 PRINT_FLAG(PREFIX);
187 #undef PRINT_FLAG
188
189 #define PRINT_FLAG(f) if (flags & RTCF_##f) { \
190 flags &= ~RTCF_##f; nl_dump(p, #f "%s", flags ? "," : ""); }
191 PRINT_FLAG(NOTIFY);
192 PRINT_FLAG(REDIRECTED);
193 PRINT_FLAG(DOREDIRECT);
194 PRINT_FLAG(DIRECTSRC);
195 PRINT_FLAG(DNAT);
196 PRINT_FLAG(BROADCAST);
197 PRINT_FLAG(MULTICAST);
198 PRINT_FLAG(LOCAL);
199 #undef PRINT_FLAG
200
201 nl_dump(p, ">");
202 }
203
204 nl_dump(p, "\n");
205 }
206
route_dump_details(struct nl_object * a,struct nl_dump_params * p)207 static void route_dump_details(struct nl_object *a, struct nl_dump_params *p)
208 {
209 struct rtnl_route *r = (struct rtnl_route *) a;
210 struct nl_cache *link_cache;
211 char buf[256];
212 int i;
213
214 link_cache = nl_cache_mngt_require_safe("route/link");
215
216 route_dump_line(a, p);
217 nl_dump_line(p, " ");
218
219 if (r->ce_mask & ROUTE_ATTR_PREF_SRC)
220 nl_dump(p, "preferred-src %s ",
221 nl_addr2str(r->rt_pref_src, buf, sizeof(buf)));
222
223 if (r->ce_mask & ROUTE_ATTR_SCOPE && r->rt_scope != RT_SCOPE_NOWHERE)
224 nl_dump(p, "scope %s ",
225 rtnl_scope2str(r->rt_scope, buf, sizeof(buf)));
226
227 if (r->ce_mask & ROUTE_ATTR_PRIO)
228 nl_dump(p, "priority %#x ", r->rt_prio);
229
230 if (r->ce_mask & ROUTE_ATTR_PROTOCOL)
231 nl_dump(p, "protocol %s ",
232 rtnl_route_proto2str(r->rt_protocol, buf, sizeof(buf)));
233
234 if (r->ce_mask & ROUTE_ATTR_IIF) {
235 if (link_cache) {
236 nl_dump(p, "iif %s ",
237 rtnl_link_i2name(link_cache, r->rt_iif,
238 buf, sizeof(buf)));
239 } else
240 nl_dump(p, "iif %d ", r->rt_iif);
241 }
242
243 if (r->ce_mask & ROUTE_ATTR_SRC)
244 nl_dump(p, "src %s ", nl_addr2str(r->rt_src, buf, sizeof(buf)));
245
246 nl_dump(p, "\n");
247
248 if (r->ce_mask & ROUTE_ATTR_MULTIPATH) {
249 struct rtnl_nexthop *nh;
250
251 nl_list_for_each_entry(nh, &r->rt_nexthops, rtnh_list) {
252 nl_dump_line(p, " ");
253 p->dp_ivar = NH_DUMP_FROM_DETAILS;
254 rtnl_route_nh_dump(nh, p);
255 nl_dump(p, "\n");
256 }
257 }
258
259 if ((r->ce_mask & ROUTE_ATTR_CACHEINFO) && r->rt_cacheinfo.rtci_error) {
260 nl_dump_line(p, " cacheinfo error %d (%s)\n",
261 r->rt_cacheinfo.rtci_error,
262 strerror_r(-r->rt_cacheinfo.rtci_error, buf, sizeof(buf)));
263 }
264
265 if (r->ce_mask & ROUTE_ATTR_METRICS) {
266 nl_dump_line(p, " metrics [");
267 for (i = 0; i < RTAX_MAX; i++)
268 if (r->rt_metrics_mask & (1 << i))
269 nl_dump(p, "%s %u ",
270 rtnl_route_metric2str(i+1,
271 buf, sizeof(buf)),
272 r->rt_metrics[i]);
273 nl_dump(p, "]\n");
274 }
275
276 if (link_cache)
277 nl_cache_put(link_cache);
278 }
279
route_dump_stats(struct nl_object * obj,struct nl_dump_params * p)280 static void route_dump_stats(struct nl_object *obj, struct nl_dump_params *p)
281 {
282 struct rtnl_route *route = (struct rtnl_route *) obj;
283
284 route_dump_details(obj, p);
285
286 if (route->ce_mask & ROUTE_ATTR_CACHEINFO) {
287 struct rtnl_rtcacheinfo *ci = &route->rt_cacheinfo;
288
289 nl_dump_line(p, " used %u refcnt %u last-use %us "
290 "expires %us\n",
291 ci->rtci_used, ci->rtci_clntref,
292 ci->rtci_last_use / nl_get_user_hz(),
293 ci->rtci_expires / nl_get_user_hz());
294 }
295 }
296
route_keygen(struct nl_object * obj,uint32_t * hashkey,uint32_t table_sz)297 static void route_keygen(struct nl_object *obj, uint32_t *hashkey,
298 uint32_t table_sz)
299 {
300 struct rtnl_route *route = (struct rtnl_route *) obj;
301 unsigned int rkey_sz;
302 struct nl_addr *addr = NULL;
303 struct route_hash_key {
304 uint8_t rt_family;
305 uint8_t rt_tos;
306 uint32_t rt_table;
307 uint32_t rt_prio;
308 char rt_addr[0];
309 } __attribute__((packed)) *rkey;
310 #ifdef NL_DEBUG
311 char buf[INET6_ADDRSTRLEN+5];
312 #endif
313
314 if (route->rt_dst)
315 addr = route->rt_dst;
316
317 rkey_sz = sizeof(*rkey);
318 if (addr)
319 rkey_sz += nl_addr_get_len(addr);
320 rkey = calloc(1, rkey_sz);
321 if (!rkey) {
322 NL_DBG(2, "Warning: calloc failed for %d bytes...\n", rkey_sz);
323 *hashkey = 0;
324 return;
325 }
326 rkey->rt_family = route->rt_family;
327 rkey->rt_tos = route->rt_tos;
328 rkey->rt_table = route->rt_table;
329 rkey->rt_prio = route->rt_prio;
330 if (addr)
331 memcpy(rkey->rt_addr, nl_addr_get_binary_addr(addr),
332 nl_addr_get_len(addr));
333
334 *hashkey = nl_hash(rkey, rkey_sz, 0) % table_sz;
335
336 NL_DBG(5, "route %p key (fam %d tos %d table %d addr %s) keysz %d "
337 "hash 0x%x\n", route, rkey->rt_family, rkey->rt_tos,
338 rkey->rt_table, nl_addr2str(addr, buf, sizeof(buf)),
339 rkey_sz, *hashkey);
340
341 free(rkey);
342
343 return;
344 }
345
route_compare(struct nl_object * _a,struct nl_object * _b,uint32_t attrs,int flags)346 static int route_compare(struct nl_object *_a, struct nl_object *_b,
347 uint32_t attrs, int flags)
348 {
349 struct rtnl_route *a = (struct rtnl_route *) _a;
350 struct rtnl_route *b = (struct rtnl_route *) _b;
351 struct rtnl_nexthop *nh_a, *nh_b;
352 int i, diff = 0, found;
353
354 #define ROUTE_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ROUTE_ATTR_##ATTR, a, b, EXPR)
355
356 diff |= ROUTE_DIFF(FAMILY, a->rt_family != b->rt_family);
357 diff |= ROUTE_DIFF(TOS, a->rt_tos != b->rt_tos);
358 diff |= ROUTE_DIFF(TABLE, a->rt_table != b->rt_table);
359 diff |= ROUTE_DIFF(PROTOCOL, a->rt_protocol != b->rt_protocol);
360 diff |= ROUTE_DIFF(SCOPE, a->rt_scope != b->rt_scope);
361 diff |= ROUTE_DIFF(TYPE, a->rt_type != b->rt_type);
362 diff |= ROUTE_DIFF(PRIO, a->rt_prio != b->rt_prio);
363 diff |= ROUTE_DIFF(DST, nl_addr_cmp(a->rt_dst, b->rt_dst));
364 diff |= ROUTE_DIFF(SRC, nl_addr_cmp(a->rt_src, b->rt_src));
365 diff |= ROUTE_DIFF(IIF, a->rt_iif != b->rt_iif);
366 diff |= ROUTE_DIFF(PREF_SRC, nl_addr_cmp(a->rt_pref_src,
367 b->rt_pref_src));
368
369 if (flags & LOOSE_COMPARISON) {
370 nl_list_for_each_entry(nh_b, &b->rt_nexthops, rtnh_list) {
371 found = 0;
372 nl_list_for_each_entry(nh_a, &a->rt_nexthops,
373 rtnh_list) {
374 if (!rtnl_route_nh_compare(nh_a, nh_b,
375 nh_b->ce_mask, 1)) {
376 found = 1;
377 break;
378 }
379 }
380
381 if (!found)
382 goto nh_mismatch;
383 }
384
385 for (i = 0; i < RTAX_MAX - 1; i++) {
386 if (a->rt_metrics_mask & (1 << i) &&
387 (!(b->rt_metrics_mask & (1 << i)) ||
388 a->rt_metrics[i] != b->rt_metrics[i]))
389 diff |= ROUTE_DIFF(METRICS, 1);
390 }
391
392 diff |= ROUTE_DIFF(FLAGS,
393 (a->rt_flags ^ b->rt_flags) & b->rt_flag_mask);
394 } else {
395 if (a->rt_nr_nh != b->rt_nr_nh)
396 goto nh_mismatch;
397
398 /* search for a dup in each nh of a */
399 nl_list_for_each_entry(nh_a, &a->rt_nexthops, rtnh_list) {
400 found = 0;
401 nl_list_for_each_entry(nh_b, &b->rt_nexthops,
402 rtnh_list) {
403 if (!rtnl_route_nh_compare(nh_a, nh_b, ~0, 0)) {
404 found = 1;
405 break;
406 }
407 }
408 if (!found)
409 goto nh_mismatch;
410 }
411
412 /* search for a dup in each nh of b, covers case where a has
413 * dupes itself */
414 nl_list_for_each_entry(nh_b, &b->rt_nexthops, rtnh_list) {
415 found = 0;
416 nl_list_for_each_entry(nh_a, &a->rt_nexthops,
417 rtnh_list) {
418 if (!rtnl_route_nh_compare(nh_a, nh_b, ~0, 0)) {
419 found = 1;
420 break;
421 }
422 }
423 if (!found)
424 goto nh_mismatch;
425 }
426
427 for (i = 0; i < RTAX_MAX - 1; i++) {
428 if ((a->rt_metrics_mask & (1 << i)) ^
429 (b->rt_metrics_mask & (1 << i)))
430 diff |= ROUTE_DIFF(METRICS, 1);
431 else
432 diff |= ROUTE_DIFF(METRICS,
433 a->rt_metrics[i] != b->rt_metrics[i]);
434 }
435
436 diff |= ROUTE_DIFF(FLAGS, a->rt_flags != b->rt_flags);
437 }
438
439 out:
440 return diff;
441
442 nh_mismatch:
443 diff |= ROUTE_DIFF(MULTIPATH, 1);
444 goto out;
445
446 #undef ROUTE_DIFF
447 }
448
route_update(struct nl_object * old_obj,struct nl_object * new_obj)449 static int route_update(struct nl_object *old_obj, struct nl_object *new_obj)
450 {
451 struct rtnl_route *new_route = (struct rtnl_route *) new_obj;
452 struct rtnl_route *old_route = (struct rtnl_route *) old_obj;
453 struct rtnl_nexthop *new_nh;
454 int action = new_obj->ce_msgtype;
455 #ifdef NL_DEBUG
456 char buf[INET6_ADDRSTRLEN+5];
457 #endif
458
459 /*
460 * ipv6 ECMP route notifications from the kernel come as
461 * separate notifications, one for every nexthop. This update
462 * function collapses such route msgs into a single
463 * route with multiple nexthops. The resulting object looks
464 * similar to a ipv4 ECMP route
465 */
466 if (new_route->rt_family != AF_INET6 ||
467 new_route->rt_table == RT_TABLE_LOCAL)
468 return -NLE_OPNOTSUPP;
469
470 /*
471 * For routes that are already multipath,
472 * or dont have a nexthop dont do anything
473 */
474 if (rtnl_route_get_nnexthops(new_route) != 1)
475 return -NLE_OPNOTSUPP;
476
477 /*
478 * Get the only nexthop entry from the new route. For
479 * IPv6 we always get a route with a 0th NH
480 * filled or nothing at all
481 */
482 new_nh = rtnl_route_nexthop_n(new_route, 0);
483 if (!new_nh || !rtnl_route_nh_get_gateway(new_nh))
484 return -NLE_OPNOTSUPP;
485
486 switch(action) {
487 case RTM_NEWROUTE : {
488 struct rtnl_nexthop *cloned_nh;
489
490 /*
491 * Add the nexthop to old route
492 */
493 cloned_nh = rtnl_route_nh_clone(new_nh);
494 if (!cloned_nh)
495 return -NLE_NOMEM;
496 rtnl_route_add_nexthop(old_route, cloned_nh);
497
498 NL_DBG(2, "Route obj %p updated. Added "
499 "nexthop %p via %s\n", old_route, cloned_nh,
500 nl_addr2str(cloned_nh->rtnh_gateway, buf,
501 sizeof(buf)));
502 }
503 break;
504 case RTM_DELROUTE : {
505 struct rtnl_nexthop *old_nh;
506
507 /*
508 * Only take care of nexthop deletes and not
509 * route deletes. So, if there is only one nexthop
510 * quite likely we did not update it. So dont do
511 * anything and return
512 */
513 if (rtnl_route_get_nnexthops(old_route) <= 1)
514 return -NLE_OPNOTSUPP;
515
516 /*
517 * Find the next hop in old route and delete it
518 */
519 nl_list_for_each_entry(old_nh, &old_route->rt_nexthops,
520 rtnh_list) {
521 if (!rtnl_route_nh_compare(old_nh, new_nh, ~0, 0)) {
522
523 rtnl_route_remove_nexthop(old_route, old_nh);
524
525 NL_DBG(2, "Route obj %p updated. Removed "
526 "nexthop %p via %s\n", old_route,
527 old_nh,
528 nl_addr2str(old_nh->rtnh_gateway, buf,
529 sizeof(buf)));
530
531 rtnl_route_nh_free(old_nh);
532 break;
533 }
534 }
535 }
536 break;
537 default:
538 NL_DBG(2, "Unknown action associated "
539 "to object %p during route update\n", new_obj);
540 return -NLE_OPNOTSUPP;
541 }
542
543 return NLE_SUCCESS;
544 }
545
546 static const struct trans_tbl route_attrs[] = {
547 __ADD(ROUTE_ATTR_FAMILY, family)
548 __ADD(ROUTE_ATTR_TOS, tos)
549 __ADD(ROUTE_ATTR_TABLE, table)
550 __ADD(ROUTE_ATTR_PROTOCOL, protocol)
551 __ADD(ROUTE_ATTR_SCOPE, scope)
552 __ADD(ROUTE_ATTR_TYPE, type)
553 __ADD(ROUTE_ATTR_FLAGS, flags)
554 __ADD(ROUTE_ATTR_DST, dst)
555 __ADD(ROUTE_ATTR_SRC, src)
556 __ADD(ROUTE_ATTR_IIF, iif)
557 __ADD(ROUTE_ATTR_OIF, oif)
558 __ADD(ROUTE_ATTR_GATEWAY, gateway)
559 __ADD(ROUTE_ATTR_PRIO, prio)
560 __ADD(ROUTE_ATTR_PREF_SRC, pref_src)
561 __ADD(ROUTE_ATTR_METRICS, metrics)
562 __ADD(ROUTE_ATTR_MULTIPATH, multipath)
563 __ADD(ROUTE_ATTR_REALMS, realms)
564 __ADD(ROUTE_ATTR_CACHEINFO, cacheinfo)
565 };
566
route_attrs2str(int attrs,char * buf,size_t len)567 static char *route_attrs2str(int attrs, char *buf, size_t len)
568 {
569 return __flags2str(attrs, buf, len, route_attrs,
570 ARRAY_SIZE(route_attrs));
571 }
572
573 /**
574 * @name Allocation/Freeing
575 * @{
576 */
577
rtnl_route_alloc(void)578 struct rtnl_route *rtnl_route_alloc(void)
579 {
580 return (struct rtnl_route *) nl_object_alloc(&route_obj_ops);
581 }
582
rtnl_route_get(struct rtnl_route * route)583 void rtnl_route_get(struct rtnl_route *route)
584 {
585 nl_object_get((struct nl_object *) route);
586 }
587
rtnl_route_put(struct rtnl_route * route)588 void rtnl_route_put(struct rtnl_route *route)
589 {
590 nl_object_put((struct nl_object *) route);
591 }
592
593 /** @} */
594
595 /**
596 * @name Attributes
597 * @{
598 */
599
rtnl_route_set_table(struct rtnl_route * route,uint32_t table)600 void rtnl_route_set_table(struct rtnl_route *route, uint32_t table)
601 {
602 route->rt_table = table;
603 route->ce_mask |= ROUTE_ATTR_TABLE;
604 }
605
rtnl_route_get_table(struct rtnl_route * route)606 uint32_t rtnl_route_get_table(struct rtnl_route *route)
607 {
608 return route->rt_table;
609 }
610
rtnl_route_set_scope(struct rtnl_route * route,uint8_t scope)611 void rtnl_route_set_scope(struct rtnl_route *route, uint8_t scope)
612 {
613 route->rt_scope = scope;
614 route->ce_mask |= ROUTE_ATTR_SCOPE;
615 }
616
rtnl_route_get_scope(struct rtnl_route * route)617 uint8_t rtnl_route_get_scope(struct rtnl_route *route)
618 {
619 return route->rt_scope;
620 }
621
rtnl_route_set_tos(struct rtnl_route * route,uint8_t tos)622 void rtnl_route_set_tos(struct rtnl_route *route, uint8_t tos)
623 {
624 route->rt_tos = tos;
625 route->ce_mask |= ROUTE_ATTR_TOS;
626 }
627
rtnl_route_get_tos(struct rtnl_route * route)628 uint8_t rtnl_route_get_tos(struct rtnl_route *route)
629 {
630 return route->rt_tos;
631 }
632
rtnl_route_set_protocol(struct rtnl_route * route,uint8_t protocol)633 void rtnl_route_set_protocol(struct rtnl_route *route, uint8_t protocol)
634 {
635 route->rt_protocol = protocol;
636 route->ce_mask |= ROUTE_ATTR_PROTOCOL;
637 }
638
rtnl_route_get_protocol(struct rtnl_route * route)639 uint8_t rtnl_route_get_protocol(struct rtnl_route *route)
640 {
641 return route->rt_protocol;
642 }
643
rtnl_route_set_priority(struct rtnl_route * route,uint32_t prio)644 void rtnl_route_set_priority(struct rtnl_route *route, uint32_t prio)
645 {
646 route->rt_prio = prio;
647 route->ce_mask |= ROUTE_ATTR_PRIO;
648 }
649
rtnl_route_get_priority(struct rtnl_route * route)650 uint32_t rtnl_route_get_priority(struct rtnl_route *route)
651 {
652 return route->rt_prio;
653 }
654
rtnl_route_set_family(struct rtnl_route * route,uint8_t family)655 int rtnl_route_set_family(struct rtnl_route *route, uint8_t family)
656 {
657 if (family != AF_INET && family != AF_INET6 && family != AF_DECnet)
658 return -NLE_AF_NOSUPPORT;
659
660 route->rt_family = family;
661 route->ce_mask |= ROUTE_ATTR_FAMILY;
662
663 return 0;
664 }
665
rtnl_route_get_family(struct rtnl_route * route)666 uint8_t rtnl_route_get_family(struct rtnl_route *route)
667 {
668 return route->rt_family;
669 }
670
rtnl_route_set_dst(struct rtnl_route * route,struct nl_addr * addr)671 int rtnl_route_set_dst(struct rtnl_route *route, struct nl_addr *addr)
672 {
673 if (route->ce_mask & ROUTE_ATTR_FAMILY) {
674 if (addr->a_family != route->rt_family)
675 return -NLE_AF_MISMATCH;
676 } else
677 route->rt_family = addr->a_family;
678
679 if (route->rt_dst)
680 nl_addr_put(route->rt_dst);
681
682 nl_addr_get(addr);
683 route->rt_dst = addr;
684
685 route->ce_mask |= (ROUTE_ATTR_DST | ROUTE_ATTR_FAMILY);
686
687 return 0;
688 }
689
rtnl_route_get_dst(struct rtnl_route * route)690 struct nl_addr *rtnl_route_get_dst(struct rtnl_route *route)
691 {
692 return route->rt_dst;
693 }
694
rtnl_route_set_src(struct rtnl_route * route,struct nl_addr * addr)695 int rtnl_route_set_src(struct rtnl_route *route, struct nl_addr *addr)
696 {
697 if (addr->a_family == AF_INET)
698 return -NLE_SRCRT_NOSUPPORT;
699
700 if (route->ce_mask & ROUTE_ATTR_FAMILY) {
701 if (addr->a_family != route->rt_family)
702 return -NLE_AF_MISMATCH;
703 } else
704 route->rt_family = addr->a_family;
705
706 if (route->rt_src)
707 nl_addr_put(route->rt_src);
708
709 nl_addr_get(addr);
710 route->rt_src = addr;
711 route->ce_mask |= (ROUTE_ATTR_SRC | ROUTE_ATTR_FAMILY);
712
713 return 0;
714 }
715
rtnl_route_get_src(struct rtnl_route * route)716 struct nl_addr *rtnl_route_get_src(struct rtnl_route *route)
717 {
718 return route->rt_src;
719 }
720
rtnl_route_set_type(struct rtnl_route * route,uint8_t type)721 int rtnl_route_set_type(struct rtnl_route *route, uint8_t type)
722 {
723 if (type > RTN_MAX)
724 return -NLE_RANGE;
725
726 route->rt_type = type;
727 route->ce_mask |= ROUTE_ATTR_TYPE;
728
729 return 0;
730 }
731
rtnl_route_get_type(struct rtnl_route * route)732 uint8_t rtnl_route_get_type(struct rtnl_route *route)
733 {
734 return route->rt_type;
735 }
736
rtnl_route_set_flags(struct rtnl_route * route,uint32_t flags)737 void rtnl_route_set_flags(struct rtnl_route *route, uint32_t flags)
738 {
739 route->rt_flag_mask |= flags;
740 route->rt_flags |= flags;
741 route->ce_mask |= ROUTE_ATTR_FLAGS;
742 }
743
rtnl_route_unset_flags(struct rtnl_route * route,uint32_t flags)744 void rtnl_route_unset_flags(struct rtnl_route *route, uint32_t flags)
745 {
746 route->rt_flag_mask |= flags;
747 route->rt_flags &= ~flags;
748 route->ce_mask |= ROUTE_ATTR_FLAGS;
749 }
750
rtnl_route_get_flags(struct rtnl_route * route)751 uint32_t rtnl_route_get_flags(struct rtnl_route *route)
752 {
753 return route->rt_flags;
754 }
755
rtnl_route_set_metric(struct rtnl_route * route,int metric,uint32_t value)756 int rtnl_route_set_metric(struct rtnl_route *route, int metric, uint32_t value)
757 {
758 if (metric > RTAX_MAX || metric < 1)
759 return -NLE_RANGE;
760
761 route->rt_metrics[metric - 1] = value;
762
763 if (!(route->rt_metrics_mask & (1 << (metric - 1)))) {
764 route->rt_nmetrics++;
765 route->rt_metrics_mask |= (1 << (metric - 1));
766 }
767
768 route->ce_mask |= ROUTE_ATTR_METRICS;
769
770 return 0;
771 }
772
rtnl_route_unset_metric(struct rtnl_route * route,int metric)773 int rtnl_route_unset_metric(struct rtnl_route *route, int metric)
774 {
775 if (metric > RTAX_MAX || metric < 1)
776 return -NLE_RANGE;
777
778 if (route->rt_metrics_mask & (1 << (metric - 1))) {
779 route->rt_nmetrics--;
780 route->rt_metrics_mask &= ~(1 << (metric - 1));
781 }
782
783 return 0;
784 }
785
rtnl_route_get_metric(struct rtnl_route * route,int metric,uint32_t * value)786 int rtnl_route_get_metric(struct rtnl_route *route, int metric, uint32_t *value)
787 {
788 if (metric > RTAX_MAX || metric < 1)
789 return -NLE_RANGE;
790
791 if (!(route->rt_metrics_mask & (1 << (metric - 1))))
792 return -NLE_OBJ_NOTFOUND;
793
794 if (value)
795 *value = route->rt_metrics[metric - 1];
796
797 return 0;
798 }
799
rtnl_route_set_pref_src(struct rtnl_route * route,struct nl_addr * addr)800 int rtnl_route_set_pref_src(struct rtnl_route *route, struct nl_addr *addr)
801 {
802 if (route->ce_mask & ROUTE_ATTR_FAMILY) {
803 if (addr->a_family != route->rt_family)
804 return -NLE_AF_MISMATCH;
805 } else
806 route->rt_family = addr->a_family;
807
808 if (route->rt_pref_src)
809 nl_addr_put(route->rt_pref_src);
810
811 nl_addr_get(addr);
812 route->rt_pref_src = addr;
813 route->ce_mask |= (ROUTE_ATTR_PREF_SRC | ROUTE_ATTR_FAMILY);
814
815 return 0;
816 }
817
rtnl_route_get_pref_src(struct rtnl_route * route)818 struct nl_addr *rtnl_route_get_pref_src(struct rtnl_route *route)
819 {
820 return route->rt_pref_src;
821 }
822
rtnl_route_set_iif(struct rtnl_route * route,int ifindex)823 void rtnl_route_set_iif(struct rtnl_route *route, int ifindex)
824 {
825 route->rt_iif = ifindex;
826 route->ce_mask |= ROUTE_ATTR_IIF;
827 }
828
rtnl_route_get_iif(struct rtnl_route * route)829 int rtnl_route_get_iif(struct rtnl_route *route)
830 {
831 return route->rt_iif;
832 }
833
rtnl_route_add_nexthop(struct rtnl_route * route,struct rtnl_nexthop * nh)834 void rtnl_route_add_nexthop(struct rtnl_route *route, struct rtnl_nexthop *nh)
835 {
836 nl_list_add_tail(&nh->rtnh_list, &route->rt_nexthops);
837 route->rt_nr_nh++;
838 route->ce_mask |= ROUTE_ATTR_MULTIPATH;
839 }
840
rtnl_route_remove_nexthop(struct rtnl_route * route,struct rtnl_nexthop * nh)841 void rtnl_route_remove_nexthop(struct rtnl_route *route, struct rtnl_nexthop *nh)
842 {
843 if (route->ce_mask & ROUTE_ATTR_MULTIPATH) {
844 route->rt_nr_nh--;
845 nl_list_del(&nh->rtnh_list);
846 }
847 }
848
rtnl_route_get_nexthops(struct rtnl_route * route)849 struct nl_list_head *rtnl_route_get_nexthops(struct rtnl_route *route)
850 {
851 if (route->ce_mask & ROUTE_ATTR_MULTIPATH)
852 return &route->rt_nexthops;
853
854 return NULL;
855 }
856
rtnl_route_get_nnexthops(struct rtnl_route * route)857 int rtnl_route_get_nnexthops(struct rtnl_route *route)
858 {
859 if (route->ce_mask & ROUTE_ATTR_MULTIPATH)
860 return route->rt_nr_nh;
861
862 return 0;
863 }
864
rtnl_route_foreach_nexthop(struct rtnl_route * r,void (* cb)(struct rtnl_nexthop *,void *),void * arg)865 void rtnl_route_foreach_nexthop(struct rtnl_route *r,
866 void (*cb)(struct rtnl_nexthop *, void *),
867 void *arg)
868 {
869 struct rtnl_nexthop *nh;
870
871 if (r->ce_mask & ROUTE_ATTR_MULTIPATH) {
872 nl_list_for_each_entry(nh, &r->rt_nexthops, rtnh_list) {
873 cb(nh, arg);
874 }
875 }
876 }
877
rtnl_route_nexthop_n(struct rtnl_route * r,int n)878 struct rtnl_nexthop *rtnl_route_nexthop_n(struct rtnl_route *r, int n)
879 {
880 struct rtnl_nexthop *nh;
881 uint32_t i;
882
883 if (r->ce_mask & ROUTE_ATTR_MULTIPATH && r->rt_nr_nh > n) {
884 i = 0;
885 nl_list_for_each_entry(nh, &r->rt_nexthops, rtnh_list) {
886 if (i == n) return nh;
887 i++;
888 }
889 }
890 return NULL;
891 }
892
893 /** @} */
894
895 /**
896 * @name Utilities
897 * @{
898 */
899
900 /**
901 * Guess scope of a route object.
902 * @arg route Route object.
903 *
904 * Guesses the scope of a route object, based on the following rules:
905 * @code
906 * 1) Local route -> local scope
907 * 2) At least one nexthop not directly connected -> universe scope
908 * 3) All others -> link scope
909 * @endcode
910 *
911 * @return Scope value.
912 */
rtnl_route_guess_scope(struct rtnl_route * route)913 int rtnl_route_guess_scope(struct rtnl_route *route)
914 {
915 if (route->rt_type == RTN_LOCAL)
916 return RT_SCOPE_HOST;
917
918 if (!nl_list_empty(&route->rt_nexthops)) {
919 struct rtnl_nexthop *nh;
920
921 /*
922 * Use scope uiniverse if there is at least one nexthop which
923 * is not directly connected
924 */
925 nl_list_for_each_entry(nh, &route->rt_nexthops, rtnh_list) {
926 if (nh->rtnh_gateway)
927 return RT_SCOPE_UNIVERSE;
928 }
929 }
930
931 return RT_SCOPE_LINK;
932 }
933
934 /** @} */
935
936 static struct nla_policy route_policy[RTA_MAX+1] = {
937 [RTA_IIF] = { .type = NLA_U32 },
938 [RTA_OIF] = { .type = NLA_U32 },
939 [RTA_PRIORITY] = { .type = NLA_U32 },
940 [RTA_FLOW] = { .type = NLA_U32 },
941 [RTA_CACHEINFO] = { .minlen = sizeof(struct rta_cacheinfo) },
942 [RTA_METRICS] = { .type = NLA_NESTED },
943 [RTA_MULTIPATH] = { .type = NLA_NESTED },
944 };
945
parse_multipath(struct rtnl_route * route,struct nlattr * attr)946 static int parse_multipath(struct rtnl_route *route, struct nlattr *attr)
947 {
948 struct rtnl_nexthop *nh = NULL;
949 struct rtnexthop *rtnh = nla_data(attr);
950 size_t tlen = nla_len(attr);
951 int err;
952
953 while (tlen >= sizeof(*rtnh) && tlen >= rtnh->rtnh_len) {
954 nh = rtnl_route_nh_alloc();
955 if (!nh)
956 return -NLE_NOMEM;
957
958 rtnl_route_nh_set_weight(nh, rtnh->rtnh_hops);
959 rtnl_route_nh_set_ifindex(nh, rtnh->rtnh_ifindex);
960 rtnl_route_nh_set_flags(nh, rtnh->rtnh_flags);
961
962 if (rtnh->rtnh_len > sizeof(*rtnh)) {
963 struct nlattr *ntb[RTA_MAX + 1];
964
965 err = nla_parse(ntb, RTA_MAX, (struct nlattr *)
966 RTNH_DATA(rtnh),
967 rtnh->rtnh_len - sizeof(*rtnh),
968 route_policy);
969 if (err < 0)
970 goto errout;
971
972 if (ntb[RTA_GATEWAY]) {
973 struct nl_addr *addr;
974
975 addr = nl_addr_alloc_attr(ntb[RTA_GATEWAY],
976 route->rt_family);
977 if (!addr) {
978 err = -NLE_NOMEM;
979 goto errout;
980 }
981
982 rtnl_route_nh_set_gateway(nh, addr);
983 nl_addr_put(addr);
984 }
985
986 if (ntb[RTA_FLOW]) {
987 uint32_t realms;
988
989 realms = nla_get_u32(ntb[RTA_FLOW]);
990 rtnl_route_nh_set_realms(nh, realms);
991 }
992 }
993
994 rtnl_route_add_nexthop(route, nh);
995 tlen -= RTNH_ALIGN(rtnh->rtnh_len);
996 rtnh = RTNH_NEXT(rtnh);
997 }
998
999 err = 0;
1000 errout:
1001 if (err && nh)
1002 rtnl_route_nh_free(nh);
1003
1004 return err;
1005 }
1006
rtnl_route_parse(struct nlmsghdr * nlh,struct rtnl_route ** result)1007 int rtnl_route_parse(struct nlmsghdr *nlh, struct rtnl_route **result)
1008 {
1009 struct rtmsg *rtm;
1010 struct rtnl_route *route;
1011 struct nlattr *tb[RTA_MAX + 1];
1012 struct nl_addr *src = NULL, *dst = NULL, *addr;
1013 struct rtnl_nexthop *old_nh = NULL;
1014 int err, family;
1015
1016 route = rtnl_route_alloc();
1017 if (!route) {
1018 err = -NLE_NOMEM;
1019 goto errout;
1020 }
1021
1022 route->ce_msgtype = nlh->nlmsg_type;
1023
1024 err = nlmsg_parse(nlh, sizeof(struct rtmsg), tb, RTA_MAX, route_policy);
1025 if (err < 0)
1026 goto errout;
1027
1028 rtm = nlmsg_data(nlh);
1029 route->rt_family = family = rtm->rtm_family;
1030 route->rt_tos = rtm->rtm_tos;
1031 route->rt_table = rtm->rtm_table;
1032 route->rt_type = rtm->rtm_type;
1033 route->rt_scope = rtm->rtm_scope;
1034 route->rt_protocol = rtm->rtm_protocol;
1035 route->rt_flags = rtm->rtm_flags;
1036 route->rt_prio = 0;
1037
1038 route->ce_mask |= ROUTE_ATTR_FAMILY | ROUTE_ATTR_TOS |
1039 ROUTE_ATTR_TABLE | ROUTE_ATTR_TYPE |
1040 ROUTE_ATTR_SCOPE | ROUTE_ATTR_PROTOCOL |
1041 ROUTE_ATTR_FLAGS | ROUTE_ATTR_PRIO;
1042
1043 if (tb[RTA_DST]) {
1044 if (!(dst = nl_addr_alloc_attr(tb[RTA_DST], family)))
1045 goto errout_nomem;
1046 } else {
1047 if (!(dst = nl_addr_alloc(0)))
1048 goto errout_nomem;
1049 nl_addr_set_family(dst, rtm->rtm_family);
1050 }
1051
1052 nl_addr_set_prefixlen(dst, rtm->rtm_dst_len);
1053 err = rtnl_route_set_dst(route, dst);
1054 if (err < 0)
1055 goto errout;
1056
1057 nl_addr_put(dst);
1058
1059 if (tb[RTA_SRC]) {
1060 if (!(src = nl_addr_alloc_attr(tb[RTA_SRC], family)))
1061 goto errout_nomem;
1062 } else if (rtm->rtm_src_len)
1063 if (!(src = nl_addr_alloc(0)))
1064 goto errout_nomem;
1065
1066 if (src) {
1067 nl_addr_set_prefixlen(src, rtm->rtm_src_len);
1068 rtnl_route_set_src(route, src);
1069 nl_addr_put(src);
1070 }
1071
1072 if (tb[RTA_TABLE])
1073 rtnl_route_set_table(route, nla_get_u32(tb[RTA_TABLE]));
1074
1075 if (tb[RTA_IIF])
1076 rtnl_route_set_iif(route, nla_get_u32(tb[RTA_IIF]));
1077
1078 if (tb[RTA_PRIORITY])
1079 rtnl_route_set_priority(route, nla_get_u32(tb[RTA_PRIORITY]));
1080
1081 if (tb[RTA_PREFSRC]) {
1082 if (!(addr = nl_addr_alloc_attr(tb[RTA_PREFSRC], family)))
1083 goto errout_nomem;
1084 rtnl_route_set_pref_src(route, addr);
1085 nl_addr_put(addr);
1086 }
1087
1088 if (tb[RTA_METRICS]) {
1089 struct nlattr *mtb[RTAX_MAX + 1];
1090 int i;
1091
1092 err = nla_parse_nested(mtb, RTAX_MAX, tb[RTA_METRICS], NULL);
1093 if (err < 0)
1094 goto errout;
1095
1096 for (i = 1; i <= RTAX_MAX; i++) {
1097 if (mtb[i] && nla_len(mtb[i]) >= sizeof(uint32_t)) {
1098 uint32_t m = nla_get_u32(mtb[i]);
1099 if (rtnl_route_set_metric(route, i, m) < 0)
1100 goto errout;
1101 }
1102 }
1103 }
1104
1105 if (tb[RTA_MULTIPATH])
1106 if ((err = parse_multipath(route, tb[RTA_MULTIPATH])) < 0)
1107 goto errout;
1108
1109 if (tb[RTA_CACHEINFO]) {
1110 nla_memcpy(&route->rt_cacheinfo, tb[RTA_CACHEINFO],
1111 sizeof(route->rt_cacheinfo));
1112 route->ce_mask |= ROUTE_ATTR_CACHEINFO;
1113 }
1114
1115 if (tb[RTA_OIF]) {
1116 if (!old_nh && !(old_nh = rtnl_route_nh_alloc()))
1117 goto errout;
1118
1119 rtnl_route_nh_set_ifindex(old_nh, nla_get_u32(tb[RTA_OIF]));
1120 }
1121
1122 if (tb[RTA_GATEWAY]) {
1123 if (!old_nh && !(old_nh = rtnl_route_nh_alloc()))
1124 goto errout;
1125
1126 if (!(addr = nl_addr_alloc_attr(tb[RTA_GATEWAY], family)))
1127 goto errout_nomem;
1128
1129 rtnl_route_nh_set_gateway(old_nh, addr);
1130 nl_addr_put(addr);
1131 }
1132
1133 if (tb[RTA_FLOW]) {
1134 if (!old_nh && !(old_nh = rtnl_route_nh_alloc()))
1135 goto errout;
1136
1137 rtnl_route_nh_set_realms(old_nh, nla_get_u32(tb[RTA_FLOW]));
1138 }
1139
1140 if (old_nh) {
1141 rtnl_route_nh_set_flags(old_nh, rtm->rtm_flags & 0xff);
1142 if (route->rt_nr_nh == 0) {
1143 /* If no nexthops have been provided via RTA_MULTIPATH
1144 * we add it as regular nexthop to maintain backwards
1145 * compatibility */
1146 rtnl_route_add_nexthop(route, old_nh);
1147 } else {
1148 /* Kernel supports new style nexthop configuration,
1149 * verify that it is a duplicate and discard nexthop. */
1150 struct rtnl_nexthop *first;
1151
1152 first = nl_list_first_entry(&route->rt_nexthops,
1153 struct rtnl_nexthop,
1154 rtnh_list);
1155 if (!first)
1156 BUG();
1157
1158 if (rtnl_route_nh_compare(old_nh, first,
1159 old_nh->ce_mask, 0)) {
1160 err = -NLE_INVAL;
1161 goto errout;
1162 }
1163
1164 rtnl_route_nh_free(old_nh);
1165 }
1166 }
1167
1168 *result = route;
1169 return 0;
1170
1171 errout:
1172 rtnl_route_put(route);
1173 return err;
1174
1175 errout_nomem:
1176 err = -NLE_NOMEM;
1177 goto errout;
1178 }
1179
rtnl_route_build_msg(struct nl_msg * msg,struct rtnl_route * route)1180 int rtnl_route_build_msg(struct nl_msg *msg, struct rtnl_route *route)
1181 {
1182 int i;
1183 struct nlattr *metrics;
1184 struct rtmsg rtmsg = {
1185 .rtm_family = route->rt_family,
1186 .rtm_tos = route->rt_tos,
1187 .rtm_table = route->rt_table,
1188 .rtm_protocol = route->rt_protocol,
1189 .rtm_scope = route->rt_scope,
1190 .rtm_type = route->rt_type,
1191 .rtm_flags = route->rt_flags,
1192 };
1193
1194 if (route->rt_dst == NULL)
1195 return -NLE_MISSING_ATTR;
1196
1197 rtmsg.rtm_dst_len = nl_addr_get_prefixlen(route->rt_dst);
1198 if (route->rt_src)
1199 rtmsg.rtm_src_len = nl_addr_get_prefixlen(route->rt_src);
1200
1201 if (!(route->ce_mask & ROUTE_ATTR_SCOPE))
1202 rtmsg.rtm_scope = rtnl_route_guess_scope(route);
1203
1204 if (rtnl_route_get_nnexthops(route) == 1) {
1205 struct rtnl_nexthop *nh;
1206 nh = rtnl_route_nexthop_n(route, 0);
1207 rtmsg.rtm_flags |= nh->rtnh_flags;
1208 }
1209
1210 if (nlmsg_append(msg, &rtmsg, sizeof(rtmsg), NLMSG_ALIGNTO) < 0)
1211 goto nla_put_failure;
1212
1213 /* Additional table attribute replacing the 8bit in the header, was
1214 * required to allow more than 256 tables. */
1215 NLA_PUT_U32(msg, RTA_TABLE, route->rt_table);
1216
1217 if (nl_addr_get_len(route->rt_dst))
1218 NLA_PUT_ADDR(msg, RTA_DST, route->rt_dst);
1219 NLA_PUT_U32(msg, RTA_PRIORITY, route->rt_prio);
1220
1221 if (route->ce_mask & ROUTE_ATTR_SRC)
1222 NLA_PUT_ADDR(msg, RTA_SRC, route->rt_src);
1223
1224 if (route->ce_mask & ROUTE_ATTR_PREF_SRC)
1225 NLA_PUT_ADDR(msg, RTA_PREFSRC, route->rt_pref_src);
1226
1227 if (route->ce_mask & ROUTE_ATTR_IIF)
1228 NLA_PUT_U32(msg, RTA_IIF, route->rt_iif);
1229
1230 if (route->rt_nmetrics > 0) {
1231 uint32_t val;
1232
1233 metrics = nla_nest_start(msg, RTA_METRICS);
1234 if (metrics == NULL)
1235 goto nla_put_failure;
1236
1237 for (i = 1; i <= RTAX_MAX; i++) {
1238 if (!rtnl_route_get_metric(route, i, &val))
1239 NLA_PUT_U32(msg, i, val);
1240 }
1241
1242 nla_nest_end(msg, metrics);
1243 }
1244
1245 if (rtnl_route_get_nnexthops(route) == 1) {
1246 struct rtnl_nexthop *nh;
1247
1248 nh = rtnl_route_nexthop_n(route, 0);
1249 if (nh->rtnh_gateway)
1250 NLA_PUT_ADDR(msg, RTA_GATEWAY, nh->rtnh_gateway);
1251 if (nh->rtnh_ifindex)
1252 NLA_PUT_U32(msg, RTA_OIF, nh->rtnh_ifindex);
1253 if (nh->rtnh_realms)
1254 NLA_PUT_U32(msg, RTA_FLOW, nh->rtnh_realms);
1255 } else if (rtnl_route_get_nnexthops(route) > 1) {
1256 struct nlattr *multipath;
1257 struct rtnl_nexthop *nh;
1258
1259 if (!(multipath = nla_nest_start(msg, RTA_MULTIPATH)))
1260 goto nla_put_failure;
1261
1262 nl_list_for_each_entry(nh, &route->rt_nexthops, rtnh_list) {
1263 struct rtnexthop *rtnh;
1264
1265 rtnh = nlmsg_reserve(msg, sizeof(*rtnh), NLMSG_ALIGNTO);
1266 if (!rtnh)
1267 goto nla_put_failure;
1268
1269 rtnh->rtnh_flags = nh->rtnh_flags;
1270 rtnh->rtnh_hops = nh->rtnh_weight;
1271 rtnh->rtnh_ifindex = nh->rtnh_ifindex;
1272
1273 if (nh->rtnh_gateway)
1274 NLA_PUT_ADDR(msg, RTA_GATEWAY,
1275 nh->rtnh_gateway);
1276
1277 if (nh->rtnh_realms)
1278 NLA_PUT_U32(msg, RTA_FLOW, nh->rtnh_realms);
1279
1280 rtnh->rtnh_len = nlmsg_tail(msg->nm_nlh) -
1281 (void *) rtnh;
1282 }
1283
1284 nla_nest_end(msg, multipath);
1285 }
1286
1287 return 0;
1288
1289 nla_put_failure:
1290 return -NLE_MSGSIZE;
1291 }
1292
1293 /** @cond SKIP */
1294 struct nl_object_ops route_obj_ops = {
1295 .oo_name = "route/route",
1296 .oo_size = sizeof(struct rtnl_route),
1297 .oo_constructor = route_constructor,
1298 .oo_free_data = route_free_data,
1299 .oo_clone = route_clone,
1300 .oo_dump = {
1301 [NL_DUMP_LINE] = route_dump_line,
1302 [NL_DUMP_DETAILS] = route_dump_details,
1303 [NL_DUMP_STATS] = route_dump_stats,
1304 },
1305 .oo_compare = route_compare,
1306 .oo_keygen = route_keygen,
1307 .oo_update = route_update,
1308 .oo_attrs2str = route_attrs2str,
1309 .oo_id_attrs = (ROUTE_ATTR_FAMILY | ROUTE_ATTR_TOS |
1310 ROUTE_ATTR_TABLE | ROUTE_ATTR_DST |
1311 ROUTE_ATTR_PRIO),
1312 };
1313 /** @endcond */
1314
1315 /** @} */
1316