libnl  3.2.7
rule.c
1 /*
2  * lib/route/rule.c Routing Rules
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-2010 Thomas Graf <tgraf@suug.ch>
10  */
11 
12 /**
13  * @ingroup rtnl
14  * @defgroup rule Routing Rules
15  * @brief
16  * @{
17  */
18 
19 #include <netlink-local.h>
20 #include <netlink/netlink.h>
21 #include <netlink/utils.h>
22 #include <netlink/route/rtnl.h>
23 #include <netlink/route/rule.h>
24 #include <inttypes.h>
25 
26 /** @cond SKIP */
27 #define RULE_ATTR_FAMILY 0x0001
28 #define RULE_ATTR_TABLE 0x0002
29 #define RULE_ATTR_ACTION 0x0004
30 #define RULE_ATTR_FLAGS 0x0008
31 #define RULE_ATTR_IIFNAME 0x0010
32 #define RULE_ATTR_OIFNAME 0x0020
33 #define RULE_ATTR_PRIO 0x0040
34 #define RULE_ATTR_MARK 0x0080
35 #define RULE_ATTR_MASK 0x0100
36 #define RULE_ATTR_GOTO 0x0200
37 #define RULE_ATTR_SRC 0x0400
38 #define RULE_ATTR_DST 0x0800
39 #define RULE_ATTR_DSFIELD 0x1000
40 #define RULE_ATTR_FLOW 0x2000
41 
42 static struct nl_cache_ops rtnl_rule_ops;
43 static struct nl_object_ops rule_obj_ops;
44 /** @endcond */
45 
46 static void rule_free_data(struct nl_object *c)
47 {
48  struct rtnl_rule *rule = nl_object_priv(c);
49 
50  if (!rule)
51  return;
52 
53  nl_addr_put(rule->r_src);
54  nl_addr_put(rule->r_dst);
55 }
56 
57 static int rule_clone(struct nl_object *_dst, struct nl_object *_src)
58 {
59  struct rtnl_rule *dst = nl_object_priv(_dst);
60  struct rtnl_rule *src = nl_object_priv(_src);
61 
62  if (src->r_src)
63  if (!(dst->r_src = nl_addr_clone(src->r_src)))
64  return -NLE_NOMEM;
65 
66  if (src->r_dst)
67  if (!(dst->r_dst = nl_addr_clone(src->r_dst)))
68  return -NLE_NOMEM;
69 
70  return 0;
71 }
72 
73 static struct nla_policy rule_policy[FRA_MAX+1] = {
74  [FRA_TABLE] = { .type = NLA_U32 },
75  [FRA_IIFNAME] = { .type = NLA_STRING, .maxlen = IFNAMSIZ },
76  [FRA_OIFNAME] = { .type = NLA_STRING, .maxlen = IFNAMSIZ },
77  [FRA_PRIORITY] = { .type = NLA_U32 },
78  [FRA_FWMARK] = { .type = NLA_U32 },
79  [FRA_FWMASK] = { .type = NLA_U32 },
80  [FRA_GOTO] = { .type = NLA_U32 },
81  [FRA_FLOW] = { .type = NLA_U32 },
82 };
83 
84 static int rule_msg_parser(struct nl_cache_ops *ops, struct sockaddr_nl *who,
85  struct nlmsghdr *n, struct nl_parser_param *pp)
86 {
87  struct rtnl_rule *rule;
88  struct fib_rule_hdr *frh;
89  struct nlattr *tb[FRA_MAX+1];
90  int err = 1, family;
91 
92  rule = rtnl_rule_alloc();
93  if (!rule) {
94  err = -NLE_NOMEM;
95  goto errout;
96  }
97 
98  rule->ce_msgtype = n->nlmsg_type;
99  frh = nlmsg_data(n);
100 
101  err = nlmsg_parse(n, sizeof(*frh), tb, FRA_MAX, rule_policy);
102  if (err < 0)
103  goto errout;
104 
105  rule->r_family = family = frh->family;
106  rule->r_table = frh->table;
107  rule->r_action = frh->action;
108  rule->r_flags = frh->flags;
109 
110  rule->ce_mask = (RULE_ATTR_FAMILY | RULE_ATTR_TABLE | RULE_ATTR_ACTION |
111  RULE_ATTR_FLAGS);
112 
113  /* ipv4 only */
114  if (frh->tos) {
115  rule->r_dsfield = frh->tos;
116  rule->ce_mask |= RULE_ATTR_DSFIELD;
117  }
118 
119  if (tb[FRA_TABLE]) {
120  rule->r_table = nla_get_u32(tb[FRA_TABLE]);
121  rule->ce_mask |= RULE_ATTR_TABLE;
122  }
123 
124  if (tb[FRA_IIFNAME]) {
125  nla_strlcpy(rule->r_iifname, tb[FRA_IIFNAME], IFNAMSIZ);
126  rule->ce_mask |= RULE_ATTR_IIFNAME;
127  }
128 
129  if (tb[FRA_OIFNAME]) {
130  nla_strlcpy(rule->r_oifname, tb[FRA_OIFNAME], IFNAMSIZ);
131  rule->ce_mask |= RULE_ATTR_OIFNAME;
132  }
133 
134  if (tb[FRA_PRIORITY]) {
135  rule->r_prio = nla_get_u32(tb[FRA_PRIORITY]);
136  rule->ce_mask |= RULE_ATTR_PRIO;
137  }
138 
139  if (tb[FRA_FWMARK]) {
140  rule->r_mark = nla_get_u32(tb[FRA_FWMARK]);
141  rule->ce_mask |= RULE_ATTR_MARK;
142  }
143 
144  if (tb[FRA_FWMASK]) {
145  rule->r_mask = nla_get_u32(tb[FRA_FWMASK]);
146  rule->ce_mask |= RULE_ATTR_MASK;
147  }
148 
149  if (tb[FRA_GOTO]) {
150  rule->r_goto = nla_get_u32(tb[FRA_GOTO]);
151  rule->ce_mask |= RULE_ATTR_GOTO;
152  }
153 
154  if (tb[FRA_SRC]) {
155  if (!(rule->r_src = nl_addr_alloc_attr(tb[FRA_SRC], family)))
156  goto errout_enomem;
157 
158  nl_addr_set_prefixlen(rule->r_src, frh->src_len);
159  rule->ce_mask |= RULE_ATTR_SRC;
160  }
161 
162  if (tb[FRA_DST]) {
163  if (!(rule->r_dst = nl_addr_alloc_attr(tb[FRA_DST], family)))
164  goto errout_enomem;
165  nl_addr_set_prefixlen(rule->r_dst, frh->dst_len);
166  rule->ce_mask |= RULE_ATTR_DST;
167  }
168 
169  /* ipv4 only */
170  if (tb[FRA_FLOW]) {
171  rule->r_flow = nla_get_u32(tb[FRA_FLOW]);
172  rule->ce_mask |= RULE_ATTR_FLOW;
173  }
174 
175  err = pp->pp_cb((struct nl_object *) rule, pp);
176 errout:
177  rtnl_rule_put(rule);
178  return err;
179 
180 errout_enomem:
181  err = -NLE_NOMEM;
182  goto errout;
183 }
184 
185 static int rule_request_update(struct nl_cache *c, struct nl_sock *h)
186 {
187  return nl_rtgen_request(h, RTM_GETRULE, AF_UNSPEC, NLM_F_DUMP);
188 }
189 
190 static void rule_dump_line(struct nl_object *o, struct nl_dump_params *p)
191 {
192  struct rtnl_rule *r = (struct rtnl_rule *) o;
193  char buf[128];
194 
195  nl_dump_line(p, "%8d ", (r->ce_mask & RULE_ATTR_PRIO) ? r->r_prio : 0);
196  nl_dump(p, "%s ", nl_af2str(r->r_family, buf, sizeof(buf)));
197 
198  if (r->ce_mask & RULE_ATTR_SRC)
199  nl_dump(p, "from %s ",
200  nl_addr2str(r->r_src, buf, sizeof(buf)));
201 
202  if (r->ce_mask & RULE_ATTR_DST)
203  nl_dump(p, "to %s ",
204  nl_addr2str(r->r_dst, buf, sizeof(buf)));
205 
206  if (r->ce_mask & RULE_ATTR_DSFIELD)
207  nl_dump(p, "tos %u ", r->r_dsfield);
208 
209  if (r->ce_mask & (RULE_ATTR_MARK | RULE_ATTR_MASK))
210  nl_dump(p, "mark %#x/%#x", r->r_mark, r->r_mask);
211 
212  if (r->ce_mask & RULE_ATTR_IIFNAME)
213  nl_dump(p, "iif %s ", r->r_iifname);
214 
215  if (r->ce_mask & RULE_ATTR_OIFNAME)
216  nl_dump(p, "oif %s ", r->r_oifname);
217 
218  if (r->ce_mask & RULE_ATTR_TABLE)
219  nl_dump(p, "lookup %s ",
220  rtnl_route_table2str(r->r_table, buf, sizeof(buf)));
221 
222  if (r->ce_mask & RULE_ATTR_FLOW)
223  nl_dump(p, "flow %s ",
224  rtnl_realms2str(r->r_flow, buf, sizeof(buf)));
225 
226  if (r->ce_mask & RULE_ATTR_GOTO)
227  nl_dump(p, "goto %u ", r->r_goto);
228 
229  if (r->ce_mask & RULE_ATTR_ACTION)
230  nl_dump(p, "action %s",
231  nl_rtntype2str(r->r_action, buf, sizeof(buf)));
232 
233  nl_dump(p, "\n");
234 }
235 
236 static void rule_dump_details(struct nl_object *obj, struct nl_dump_params *p)
237 {
238  rule_dump_line(obj, p);
239 }
240 
241 static void rule_dump_stats(struct nl_object *obj, struct nl_dump_params *p)
242 {
243  rule_dump_details(obj, p);
244 }
245 
246 #define RULE_ATTR_FLAGS 0x0008
247 
248 static int rule_compare(struct nl_object *_a, struct nl_object *_b,
249  uint32_t attrs, int flags)
250 {
251  struct rtnl_rule *a = (struct rtnl_rule *) _a;
252  struct rtnl_rule *b = (struct rtnl_rule *) _b;
253  int diff = 0;
254 
255 #define RULE_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, RULE_ATTR_##ATTR, a, b, EXPR)
256 
257  diff |= RULE_DIFF(FAMILY, a->r_family != b->r_family);
258  diff |= RULE_DIFF(TABLE, a->r_table != b->r_table);
259  diff |= RULE_DIFF(ACTION, a->r_action != b->r_action);
260  diff |= RULE_DIFF(IIFNAME, strcmp(a->r_iifname, b->r_iifname));
261  diff |= RULE_DIFF(OIFNAME, strcmp(a->r_oifname, b->r_oifname));
262  diff |= RULE_DIFF(PRIO, a->r_prio != b->r_prio);
263  diff |= RULE_DIFF(MARK, a->r_mark != b->r_mark);
264  diff |= RULE_DIFF(MASK, a->r_mask != b->r_mask);
265  diff |= RULE_DIFF(GOTO, a->r_goto != b->r_goto);
266  diff |= RULE_DIFF(SRC, nl_addr_cmp(a->r_src, b->r_src));
267  diff |= RULE_DIFF(DST, nl_addr_cmp(a->r_dst, b->r_dst));
268  diff |= RULE_DIFF(DSFIELD, a->r_dsfield != b->r_dsfield);
269  diff |= RULE_DIFF(FLOW, a->r_flow != b->r_flow);
270 
271 #undef RULE_DIFF
272 
273  return diff;
274 }
275 
276 static const struct trans_tbl rule_attrs[] = {
277  __ADD(RULE_ATTR_FAMILY, family)
278  __ADD(RULE_ATTR_TABLE, table)
279  __ADD(RULE_ATTR_ACTION, action)
280  __ADD(RULE_ATTR_IIFNAME, iifname)
281  __ADD(RULE_ATTR_OIFNAME, oifname)
282  __ADD(RULE_ATTR_PRIO, prio)
283  __ADD(RULE_ATTR_MARK, mark)
284  __ADD(RULE_ATTR_MASK, mask)
285  __ADD(RULE_ATTR_GOTO, goto)
286  __ADD(RULE_ATTR_SRC, src)
287  __ADD(RULE_ATTR_DST, dst)
288  __ADD(RULE_ATTR_DSFIELD, dsfield)
289  __ADD(RULE_ATTR_FLOW, flow)
290 };
291 
292 static char *rule_attrs2str(int attrs, char *buf, size_t len)
293 {
294  return __flags2str(attrs, buf, len, rule_attrs,
295  ARRAY_SIZE(rule_attrs));
296 }
297 
298 /**
299  * @name Allocation/Freeing
300  * @{
301  */
302 
303 struct rtnl_rule *rtnl_rule_alloc(void)
304 {
305  return (struct rtnl_rule *) nl_object_alloc(&rule_obj_ops);
306 }
307 
308 void rtnl_rule_put(struct rtnl_rule *rule)
309 {
310  nl_object_put((struct nl_object *) rule);
311 }
312 
313 /** @} */
314 
315 /**
316  * @name Cache Management
317  * @{
318  */
319 
320 /**
321  * Build a rule cache including all rules currently configured in the kernel.
322  * @arg sock Netlink socket.
323  * @arg family Address family or AF_UNSPEC.
324  * @arg result Pointer to store resulting cache.
325  *
326  * Allocates a new rule cache, initializes it properly and updates it
327  * to include all rules currently configured in the kernel.
328  *
329  * @return 0 on success or a negative error code.
330  */
331 int rtnl_rule_alloc_cache(struct nl_sock *sock, int family,
332  struct nl_cache **result)
333 {
334  struct nl_cache * cache;
335  int err;
336 
337  if (!(cache = nl_cache_alloc(&rtnl_rule_ops)))
338  return -NLE_NOMEM;
339 
340  cache->c_iarg1 = family;
341 
342  if (sock && (err = nl_cache_refill(sock, cache)) < 0) {
343  free(cache);
344  return err;
345  }
346 
347  *result = cache;
348  return 0;
349 }
350 
351 /** @} */
352 
353 /**
354  * @name Rule Addition
355  * @{
356  */
357 
358 static int build_rule_msg(struct rtnl_rule *tmpl, int cmd, int flags,
359  struct nl_msg **result)
360 {
361  struct nl_msg *msg;
362  struct fib_rule_hdr frh = {
363  .family = tmpl->r_family,
364  .table = tmpl->r_table,
365  .action = tmpl->r_action,
366  .flags = tmpl->r_flags,
367  .tos = tmpl->r_dsfield,
368  };
369 
370  if (!(tmpl->ce_mask & RULE_ATTR_FAMILY))
371  return -NLE_MISSING_ATTR;
372 
373  msg = nlmsg_alloc_simple(cmd, flags);
374  if (!msg)
375  return -NLE_NOMEM;
376 
377  if (tmpl->ce_mask & RULE_ATTR_SRC)
378  frh.src_len = nl_addr_get_prefixlen(tmpl->r_src);
379 
380  if (tmpl->ce_mask & RULE_ATTR_DST)
381  frh.dst_len = nl_addr_get_prefixlen(tmpl->r_dst);
382 
383  if (nlmsg_append(msg, &frh, sizeof(frh), NLMSG_ALIGNTO) < 0)
384  goto nla_put_failure;
385 
386  if (tmpl->ce_mask & RULE_ATTR_SRC)
387  NLA_PUT_ADDR(msg, FRA_SRC, tmpl->r_src);
388 
389  if (tmpl->ce_mask & RULE_ATTR_DST)
390  NLA_PUT_ADDR(msg, FRA_DST, tmpl->r_dst);
391 
392  if (tmpl->ce_mask & RULE_ATTR_IIFNAME)
393  NLA_PUT_STRING(msg, FRA_IIFNAME, tmpl->r_iifname);
394 
395  if (tmpl->ce_mask & RULE_ATTR_OIFNAME)
396  NLA_PUT_STRING(msg, FRA_OIFNAME, tmpl->r_oifname);
397 
398  if (tmpl->ce_mask & RULE_ATTR_PRIO)
399  NLA_PUT_U32(msg, FRA_PRIORITY, tmpl->r_prio);
400 
401  if (tmpl->ce_mask & RULE_ATTR_MARK)
402  NLA_PUT_U32(msg, FRA_FWMARK, tmpl->r_mark);
403 
404  if (tmpl->ce_mask & RULE_ATTR_MASK)
405  NLA_PUT_U32(msg, FRA_FWMASK, tmpl->r_mask);
406 
407  if (tmpl->ce_mask & RULE_ATTR_GOTO)
408  NLA_PUT_U32(msg, FRA_GOTO, tmpl->r_goto);
409 
410  if (tmpl->ce_mask & RULE_ATTR_FLOW)
411  NLA_PUT_U32(msg, FRA_FLOW, tmpl->r_flow);
412 
413 
414  *result = msg;
415  return 0;
416 
417 nla_put_failure:
418  nlmsg_free(msg);
419  return -NLE_MSGSIZE;
420 }
421 
422 /**
423  * Build netlink request message to add a new rule
424  * @arg tmpl template with data of new rule
425  * @arg flags additional netlink message flags
426  * @arg result Result pointer
427  *
428  * Builds a new netlink message requesting a addition of a new
429  * rule. The netlink message header isn't fully equipped with
430  * all relevant fields and must thus be sent out via nl_send_auto_complete()
431  * or supplemented as needed. \a tmpl must contain the attributes of the new
432  * address set via \c rtnl_rule_set_* functions.
433  *
434  * @return 0 on success or a negative error code.
435  */
436 int rtnl_rule_build_add_request(struct rtnl_rule *tmpl, int flags,
437  struct nl_msg **result)
438 {
439  return build_rule_msg(tmpl, RTM_NEWRULE, NLM_F_CREATE | flags,
440  result);
441 }
442 
443 /**
444  * Add a new rule
445  * @arg sk Netlink socket.
446  * @arg tmpl template with requested changes
447  * @arg flags additional netlink message flags
448  *
449  * Builds a netlink message by calling rtnl_rule_build_add_request(),
450  * sends the request to the kernel and waits for the next ACK to be
451  * received and thus blocks until the request has been fullfilled.
452  *
453  * @return 0 on sucess or a negative error if an error occured.
454  */
455 int rtnl_rule_add(struct nl_sock *sk, struct rtnl_rule *tmpl, int flags)
456 {
457  struct nl_msg *msg;
458  int err;
459 
460  if ((err = rtnl_rule_build_add_request(tmpl, flags, &msg)) < 0)
461  return err;
462 
463  err = nl_send_auto_complete(sk, msg);
464  nlmsg_free(msg);
465  if (err < 0)
466  return err;
467 
468  return wait_for_ack(sk);
469 }
470 
471 /** @} */
472 
473 /**
474  * @name Rule Deletion
475  * @{
476  */
477 
478 /**
479  * Build a netlink request message to delete a rule
480  * @arg rule rule to delete
481  * @arg flags additional netlink message flags
482  * @arg result Result pointer
483  *
484  * Builds a new netlink message requesting a deletion of a rule.
485  * The netlink message header isn't fully equipped with all relevant
486  * fields and must thus be sent out via nl_send_auto_complete()
487  * or supplemented as needed. \a rule must point to an existing
488  * address.
489  *
490  * @return 0 on success or a negative error code.
491  */
492 int rtnl_rule_build_delete_request(struct rtnl_rule *rule, int flags,
493  struct nl_msg **result)
494 {
495  return build_rule_msg(rule, RTM_DELRULE, flags, result);
496 }
497 
498 /**
499  * Delete a rule
500  * @arg sk Netlink socket.
501  * @arg rule rule to delete
502  * @arg flags additional netlink message flags
503  *
504  * Builds a netlink message by calling rtnl_rule_build_delete_request(),
505  * sends the request to the kernel and waits for the next ACK to be
506  * received and thus blocks until the request has been fullfilled.
507  *
508  * @return 0 on sucess or a negative error if an error occured.
509  */
510 int rtnl_rule_delete(struct nl_sock *sk, struct rtnl_rule *rule, int flags)
511 {
512  struct nl_msg *msg;
513  int err;
514 
515  if ((err = rtnl_rule_build_delete_request(rule, flags, &msg)) < 0)
516  return err;
517 
518  err = nl_send_auto_complete(sk, msg);
519  nlmsg_free(msg);
520  if (err < 0)
521  return err;
522 
523  return wait_for_ack(sk);
524 }
525 
526 /** @} */
527 
528 /**
529  * @name Attribute Modification
530  * @{
531  */
532 
533 void rtnl_rule_set_family(struct rtnl_rule *rule, int family)
534 {
535  rule->r_family = family;
536  rule->ce_mask |= RULE_ATTR_FAMILY;
537 }
538 
539 int rtnl_rule_get_family(struct rtnl_rule *rule)
540 {
541  if (rule->ce_mask & RULE_ATTR_FAMILY)
542  return rule->r_family;
543  else
544  return AF_UNSPEC;
545 }
546 
547 void rtnl_rule_set_prio(struct rtnl_rule *rule, uint32_t prio)
548 {
549  rule->r_prio = prio;
550  rule->ce_mask |= RULE_ATTR_PRIO;
551 }
552 
553 uint32_t rtnl_rule_get_prio(struct rtnl_rule *rule)
554 {
555  return rule->r_prio;
556 }
557 
558 void rtnl_rule_set_mark(struct rtnl_rule *rule, uint32_t mark)
559 {
560  rule->r_mark = mark;
561  rule->ce_mask |= RULE_ATTR_MARK;
562 }
563 
564 uint32_t rtnl_rule_get_mark(struct rtnl_rule *rule)
565 {
566  return rule->r_mark;
567 }
568 
569 void rtnl_rule_set_mask(struct rtnl_rule *rule, uint32_t mask)
570 {
571  rule->r_mask = mask;
572  rule->ce_mask |= RULE_ATTR_MASK;
573 }
574 
575 uint32_t rtnl_rule_get_mask(struct rtnl_rule *rule)
576 {
577  return rule->r_mask;
578 }
579 
580 void rtnl_rule_set_table(struct rtnl_rule *rule, uint32_t table)
581 {
582  rule->r_table = table;
583  rule->ce_mask |= RULE_ATTR_TABLE;
584 }
585 
586 uint32_t rtnl_rule_get_table(struct rtnl_rule *rule)
587 {
588  return rule->r_table;
589 }
590 
591 void rtnl_rule_set_dsfield(struct rtnl_rule *rule, uint8_t dsfield)
592 {
593  rule->r_dsfield = dsfield;
594  rule->ce_mask |= RULE_ATTR_DSFIELD;
595 }
596 
597 uint8_t rtnl_rule_get_dsfield(struct rtnl_rule *rule)
598 {
599  return rule->r_dsfield;
600 }
601 
602 static inline int __assign_addr(struct rtnl_rule *rule, struct nl_addr **pos,
603  struct nl_addr *new, int flag)
604 {
605  if (rule->ce_mask & RULE_ATTR_FAMILY) {
606  if (new->a_family != rule->r_family)
607  return -NLE_AF_MISMATCH;
608  } else
609  rule->r_family = new->a_family;
610 
611  if (*pos)
612  nl_addr_put(*pos);
613 
614  nl_addr_get(new);
615  *pos = new;
616 
617  rule->ce_mask |= (flag | RULE_ATTR_FAMILY);
618 
619  return 0;
620 }
621 
622 int rtnl_rule_set_src(struct rtnl_rule *rule, struct nl_addr *src)
623 {
624  return __assign_addr(rule, &rule->r_src, src, RULE_ATTR_SRC);
625 }
626 
627 struct nl_addr *rtnl_rule_get_src(struct rtnl_rule *rule)
628 {
629  return rule->r_src;
630 }
631 
632 int rtnl_rule_set_dst(struct rtnl_rule *rule, struct nl_addr *dst)
633 {
634  return __assign_addr(rule, &rule->r_dst, dst, RULE_ATTR_DST);
635 }
636 
637 struct nl_addr *rtnl_rule_get_dst(struct rtnl_rule *rule)
638 {
639  return rule->r_dst;
640 }
641 
642 int rtnl_rule_set_iif(struct rtnl_rule *rule, const char *dev)
643 {
644  if (strlen(dev) > IFNAMSIZ-1)
645  return -NLE_RANGE;
646 
647  strcpy(rule->r_iifname, dev);
648  rule->ce_mask |= RULE_ATTR_IIFNAME;
649  return 0;
650 }
651 
652 char *rtnl_rule_get_iif(struct rtnl_rule *rule)
653 {
654  if (rule->ce_mask & RULE_ATTR_IIFNAME)
655  return rule->r_iifname;
656  else
657  return NULL;
658 }
659 
660 int rtnl_rule_set_oif(struct rtnl_rule *rule, const char *dev)
661 {
662  if (strlen(dev) > IFNAMSIZ-1)
663  return -NLE_RANGE;
664 
665  strcpy(rule->r_oifname, dev);
666  rule->ce_mask |= RULE_ATTR_OIFNAME;
667  return 0;
668 }
669 
670 char *rtnl_rule_get_oif(struct rtnl_rule *rule)
671 {
672  if (rule->ce_mask & RULE_ATTR_OIFNAME)
673  return rule->r_oifname;
674  else
675  return NULL;
676 }
677 
678 void rtnl_rule_set_action(struct rtnl_rule *rule, uint8_t action)
679 {
680  rule->r_action = action;
681  rule->ce_mask |= RULE_ATTR_ACTION;
682 }
683 
684 uint8_t rtnl_rule_get_action(struct rtnl_rule *rule)
685 {
686  return rule->r_action;
687 }
688 
689 void rtnl_rule_set_realms(struct rtnl_rule *rule, uint32_t realms)
690 {
691  rule->r_flow = realms;
692  rule->ce_mask |= RULE_ATTR_FLOW;
693 }
694 
695 uint32_t rtnl_rule_get_realms(struct rtnl_rule *rule)
696 {
697  return rule->r_flow;
698 }
699 
700 void rtnl_rule_set_goto(struct rtnl_rule *rule, uint32_t ref)
701 {
702  rule->r_goto = ref;
703  rule->ce_mask |= RULE_ATTR_GOTO;
704 }
705 
706 uint32_t rtnl_rule_get_goto(struct rtnl_rule *rule)
707 {
708  return rule->r_goto;
709 }
710 
711 /** @} */
712 
713 static struct nl_object_ops rule_obj_ops = {
714  .oo_name = "route/rule",
715  .oo_size = sizeof(struct rtnl_rule),
716  .oo_free_data = rule_free_data,
717  .oo_clone = rule_clone,
718  .oo_dump = {
719  [NL_DUMP_LINE] = rule_dump_line,
720  [NL_DUMP_DETAILS] = rule_dump_details,
721  [NL_DUMP_STATS] = rule_dump_stats,
722  },
723  .oo_compare = rule_compare,
724  .oo_attrs2str = rule_attrs2str,
725  .oo_id_attrs = ~0,
726 };
727 
728 static struct nl_cache_ops rtnl_rule_ops = {
729  .co_name = "route/rule",
730  .co_hdrsize = sizeof(struct fib_rule_hdr),
731  .co_msgtypes = {
732  { RTM_NEWRULE, NL_ACT_NEW, "new" },
733  { RTM_DELRULE, NL_ACT_DEL, "del" },
734  { RTM_GETRULE, NL_ACT_GET, "get" },
735  END_OF_MSGTYPES_LIST,
736  },
737  .co_protocol = NETLINK_ROUTE,
738  .co_request_update = rule_request_update,
739  .co_msg_parser = rule_msg_parser,
740  .co_obj_ops = &rule_obj_ops,
741 };
742 
743 static void __init rule_init(void)
744 {
745  nl_cache_mngt_register(&rtnl_rule_ops);
746 }
747 
748 static void __exit rule_exit(void)
749 {
750  nl_cache_mngt_unregister(&rtnl_rule_ops);
751 }
752 
753 /** @} */