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>
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
46 static void rule_free_data(
struct nl_object *c)
48 struct rtnl_rule *rule = nl_object_priv(c);
53 nl_addr_put(rule->r_src);
54 nl_addr_put(rule->r_dst);
59 struct rtnl_rule *dst = nl_object_priv(_dst);
60 struct rtnl_rule *src = nl_object_priv(_src);
73 static struct nla_policy rule_policy[FRA_MAX+1] = {
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 },
84 static int rule_msg_parser(
struct nl_cache_ops *ops,
struct sockaddr_nl *who,
87 struct rtnl_rule *rule;
88 struct fib_rule_hdr *frh;
89 struct nlattr *tb[FRA_MAX+1];
92 rule = rtnl_rule_alloc();
98 rule->ce_msgtype = n->nlmsg_type;
101 err =
nlmsg_parse(n,
sizeof(*frh), tb, FRA_MAX, rule_policy);
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;
110 rule->ce_mask = (RULE_ATTR_FAMILY | RULE_ATTR_TABLE | RULE_ATTR_ACTION |
115 rule->r_dsfield = frh->tos;
116 rule->ce_mask |= RULE_ATTR_DSFIELD;
121 rule->ce_mask |= RULE_ATTR_TABLE;
124 if (tb[FRA_IIFNAME]) {
125 nla_strlcpy(rule->r_iifname, tb[FRA_IIFNAME], IFNAMSIZ);
126 rule->ce_mask |= RULE_ATTR_IIFNAME;
129 if (tb[FRA_OIFNAME]) {
130 nla_strlcpy(rule->r_oifname, tb[FRA_OIFNAME], IFNAMSIZ);
131 rule->ce_mask |= RULE_ATTR_OIFNAME;
134 if (tb[FRA_PRIORITY]) {
136 rule->ce_mask |= RULE_ATTR_PRIO;
139 if (tb[FRA_FWMARK]) {
141 rule->ce_mask |= RULE_ATTR_MARK;
144 if (tb[FRA_FWMASK]) {
146 rule->ce_mask |= RULE_ATTR_MASK;
151 rule->ce_mask |= RULE_ATTR_GOTO;
158 nl_addr_set_prefixlen(rule->r_src, frh->src_len);
159 rule->ce_mask |= RULE_ATTR_SRC;
165 nl_addr_set_prefixlen(rule->r_dst, frh->dst_len);
166 rule->ce_mask |= RULE_ATTR_DST;
172 rule->ce_mask |= RULE_ATTR_FLOW;
185 static int rule_request_update(
struct nl_cache *c,
struct nl_sock *h)
192 struct rtnl_rule *r = (
struct rtnl_rule *) o;
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)));
198 if (r->ce_mask & RULE_ATTR_SRC)
202 if (r->ce_mask & RULE_ATTR_DST)
206 if (r->ce_mask & RULE_ATTR_DSFIELD)
207 nl_dump(p,
"tos %u ", r->r_dsfield);
209 if (r->ce_mask & (RULE_ATTR_MARK | RULE_ATTR_MASK))
210 nl_dump(p,
"mark %#x/%#x", r->r_mark, r->r_mask);
212 if (r->ce_mask & RULE_ATTR_IIFNAME)
213 nl_dump(p,
"iif %s ", r->r_iifname);
215 if (r->ce_mask & RULE_ATTR_OIFNAME)
216 nl_dump(p,
"oif %s ", r->r_oifname);
218 if (r->ce_mask & RULE_ATTR_TABLE)
220 rtnl_route_table2str(r->r_table, buf,
sizeof(buf)));
222 if (r->ce_mask & RULE_ATTR_FLOW)
224 rtnl_realms2str(r->r_flow, buf,
sizeof(buf)));
226 if (r->ce_mask & RULE_ATTR_GOTO)
227 nl_dump(p,
"goto %u ", r->r_goto);
229 if (r->ce_mask & RULE_ATTR_ACTION)
231 nl_rtntype2str(r->r_action, buf,
sizeof(buf)));
238 rule_dump_line(obj, p);
243 rule_dump_details(obj, p);
246 #define RULE_ATTR_FLAGS 0x0008
249 uint32_t attrs,
int flags)
251 struct rtnl_rule *a = (
struct rtnl_rule *) _a;
252 struct rtnl_rule *b = (
struct rtnl_rule *) _b;
255 #define RULE_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, RULE_ATTR_##ATTR, a, b, EXPR)
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);
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)
292 static
char *rule_attrs2str(
int attrs,
char *buf,
size_t len)
294 return __flags2str(attrs, buf, len, rule_attrs,
295 ARRAY_SIZE(rule_attrs));
303 struct rtnl_rule *rtnl_rule_alloc(
void)
308 void rtnl_rule_put(
struct rtnl_rule *rule)
332 struct nl_cache **result)
334 struct nl_cache * cache;
340 cache->c_iarg1 = family;
358 static int build_rule_msg(
struct rtnl_rule *tmpl,
int cmd,
int flags,
359 struct nl_msg **result)
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,
370 if (!(tmpl->ce_mask & RULE_ATTR_FAMILY))
371 return -NLE_MISSING_ATTR;
377 if (tmpl->ce_mask & RULE_ATTR_SRC)
380 if (tmpl->ce_mask & RULE_ATTR_DST)
383 if (
nlmsg_append(msg, &frh,
sizeof(frh), NLMSG_ALIGNTO) < 0)
384 goto nla_put_failure;
386 if (tmpl->ce_mask & RULE_ATTR_SRC)
389 if (tmpl->ce_mask & RULE_ATTR_DST)
392 if (tmpl->ce_mask & RULE_ATTR_IIFNAME)
395 if (tmpl->ce_mask & RULE_ATTR_OIFNAME)
398 if (tmpl->ce_mask & RULE_ATTR_PRIO)
401 if (tmpl->ce_mask & RULE_ATTR_MARK)
404 if (tmpl->ce_mask & RULE_ATTR_MASK)
407 if (tmpl->ce_mask & RULE_ATTR_GOTO)
410 if (tmpl->ce_mask & RULE_ATTR_FLOW)
437 struct nl_msg **result)
439 return build_rule_msg(tmpl, RTM_NEWRULE, NLM_F_CREATE | flags,
463 err = nl_send_auto_complete(sk, msg);
468 return wait_for_ack(sk);
493 struct nl_msg **result)
495 return build_rule_msg(rule, RTM_DELRULE, flags, result);
518 err = nl_send_auto_complete(sk, msg);
523 return wait_for_ack(sk);
533 void rtnl_rule_set_family(
struct rtnl_rule *rule,
int family)
535 rule->r_family = family;
536 rule->ce_mask |= RULE_ATTR_FAMILY;
539 int rtnl_rule_get_family(
struct rtnl_rule *rule)
541 if (rule->ce_mask & RULE_ATTR_FAMILY)
542 return rule->r_family;
547 void rtnl_rule_set_prio(
struct rtnl_rule *rule, uint32_t prio)
550 rule->ce_mask |= RULE_ATTR_PRIO;
553 uint32_t rtnl_rule_get_prio(
struct rtnl_rule *rule)
558 void rtnl_rule_set_mark(
struct rtnl_rule *rule, uint32_t mark)
561 rule->ce_mask |= RULE_ATTR_MARK;
564 uint32_t rtnl_rule_get_mark(
struct rtnl_rule *rule)
569 void rtnl_rule_set_mask(
struct rtnl_rule *rule, uint32_t mask)
572 rule->ce_mask |= RULE_ATTR_MASK;
575 uint32_t rtnl_rule_get_mask(
struct rtnl_rule *rule)
580 void rtnl_rule_set_table(
struct rtnl_rule *rule, uint32_t table)
582 rule->r_table = table;
583 rule->ce_mask |= RULE_ATTR_TABLE;
586 uint32_t rtnl_rule_get_table(
struct rtnl_rule *rule)
588 return rule->r_table;
591 void rtnl_rule_set_dsfield(
struct rtnl_rule *rule, uint8_t dsfield)
593 rule->r_dsfield = dsfield;
594 rule->ce_mask |= RULE_ATTR_DSFIELD;
597 uint8_t rtnl_rule_get_dsfield(
struct rtnl_rule *rule)
599 return rule->r_dsfield;
602 static inline int __assign_addr(
struct rtnl_rule *rule,
struct nl_addr **pos,
603 struct nl_addr *
new,
int flag)
605 if (rule->ce_mask & RULE_ATTR_FAMILY) {
606 if (new->a_family != rule->r_family)
607 return -NLE_AF_MISMATCH;
609 rule->r_family =
new->a_family;
617 rule->ce_mask |= (flag | RULE_ATTR_FAMILY);
622 int rtnl_rule_set_src(
struct rtnl_rule *rule,
struct nl_addr *src)
624 return __assign_addr(rule, &rule->r_src, src, RULE_ATTR_SRC);
627 struct nl_addr *rtnl_rule_get_src(
struct rtnl_rule *rule)
632 int rtnl_rule_set_dst(
struct rtnl_rule *rule,
struct nl_addr *dst)
634 return __assign_addr(rule, &rule->r_dst, dst, RULE_ATTR_DST);
637 struct nl_addr *rtnl_rule_get_dst(
struct rtnl_rule *rule)
642 int rtnl_rule_set_iif(
struct rtnl_rule *rule,
const char *dev)
644 if (strlen(dev) > IFNAMSIZ-1)
647 strcpy(rule->r_iifname, dev);
648 rule->ce_mask |= RULE_ATTR_IIFNAME;
652 char *rtnl_rule_get_iif(
struct rtnl_rule *rule)
654 if (rule->ce_mask & RULE_ATTR_IIFNAME)
655 return rule->r_iifname;
660 int rtnl_rule_set_oif(
struct rtnl_rule *rule,
const char *dev)
662 if (strlen(dev) > IFNAMSIZ-1)
665 strcpy(rule->r_oifname, dev);
666 rule->ce_mask |= RULE_ATTR_OIFNAME;
670 char *rtnl_rule_get_oif(
struct rtnl_rule *rule)
672 if (rule->ce_mask & RULE_ATTR_OIFNAME)
673 return rule->r_oifname;
678 void rtnl_rule_set_action(
struct rtnl_rule *rule, uint8_t action)
680 rule->r_action = action;
681 rule->ce_mask |= RULE_ATTR_ACTION;
684 uint8_t rtnl_rule_get_action(
struct rtnl_rule *rule)
686 return rule->r_action;
689 void rtnl_rule_set_realms(
struct rtnl_rule *rule, uint32_t realms)
691 rule->r_flow = realms;
692 rule->ce_mask |= RULE_ATTR_FLOW;
695 uint32_t rtnl_rule_get_realms(
struct rtnl_rule *rule)
700 void rtnl_rule_set_goto(
struct rtnl_rule *rule, uint32_t ref)
703 rule->ce_mask |= RULE_ATTR_GOTO;
706 uint32_t rtnl_rule_get_goto(
struct rtnl_rule *rule)
715 .oo_size =
sizeof(
struct rtnl_rule),
716 .oo_free_data = rule_free_data,
717 .oo_clone = rule_clone,
723 .oo_compare = rule_compare,
724 .oo_attrs2str = rule_attrs2str,
730 .co_hdrsize =
sizeof(
struct fib_rule_hdr),
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,
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,
743 static void __init rule_init(
void)
748 static void __exit rule_exit(
void)