19 #include <netlink-private/netlink.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
42 static struct nl_cache_ops rtnl_rule_ops;
43 static struct nl_object_ops rule_obj_ops;
46 static void rule_free_data(
struct nl_object *c)
48 struct rtnl_rule *rule = nl_object_priv(c);
57 static int rule_clone(
struct nl_object *_dst,
struct nl_object *_src)
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,
85 struct nlmsghdr *n,
struct nl_parser_param *pp)
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;
159 rule->ce_mask |= RULE_ATTR_SRC;
166 rule->ce_mask |= RULE_ATTR_DST;
172 rule->ce_mask |= RULE_ATTR_FLOW;
175 err = pp->pp_cb((
struct nl_object *) rule, pp);
185 static int rule_request_update(
struct nl_cache *c,
struct nl_sock *h)
190 static void rule_dump_line(
struct nl_object *o,
struct nl_dump_params *p)
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)));
236 static void rule_dump_details(
struct nl_object *obj,
struct nl_dump_params *p)
238 rule_dump_line(obj, p);
241 static void rule_dump_stats(
struct nl_object *obj,
struct nl_dump_params *p)
243 rule_dump_details(obj, p);
246 #define RULE_ATTR_FLAGS 0x0008
248 static int rule_compare(
struct nl_object *_a,
struct nl_object *_b,
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;
390 if (tmpl->ce_mask & RULE_ATTR_SRC)
393 if (tmpl->ce_mask & RULE_ATTR_DST)
396 if (tmpl->ce_mask & RULE_ATTR_IIFNAME)
399 if (tmpl->ce_mask & RULE_ATTR_OIFNAME)
402 if (tmpl->ce_mask & RULE_ATTR_PRIO)
405 if (tmpl->ce_mask & RULE_ATTR_MARK)
408 if (tmpl->ce_mask & RULE_ATTR_MASK)
411 if (tmpl->ce_mask & RULE_ATTR_GOTO)
414 if (tmpl->ce_mask & RULE_ATTR_FLOW)
441 struct nl_msg **result)
443 return build_rule_msg(tmpl, RTM_NEWRULE, NLM_F_CREATE | flags,
472 return wait_for_ack(sk);
497 struct nl_msg **result)
499 return build_rule_msg(rule, RTM_DELRULE, flags, result);
527 return wait_for_ack(sk);
537 void rtnl_rule_set_family(
struct rtnl_rule *rule,
int family)
539 rule->r_family = family;
540 rule->ce_mask |= RULE_ATTR_FAMILY;
543 int rtnl_rule_get_family(
struct rtnl_rule *rule)
545 if (rule->ce_mask & RULE_ATTR_FAMILY)
546 return rule->r_family;
551 void rtnl_rule_set_prio(
struct rtnl_rule *rule, uint32_t prio)
554 rule->ce_mask |= RULE_ATTR_PRIO;
557 uint32_t rtnl_rule_get_prio(
struct rtnl_rule *rule)
562 void rtnl_rule_set_mark(
struct rtnl_rule *rule, uint32_t mark)
565 rule->ce_mask |= RULE_ATTR_MARK;
568 uint32_t rtnl_rule_get_mark(
struct rtnl_rule *rule)
573 void rtnl_rule_set_mask(
struct rtnl_rule *rule, uint32_t mask)
576 rule->ce_mask |= RULE_ATTR_MASK;
579 uint32_t rtnl_rule_get_mask(
struct rtnl_rule *rule)
584 void rtnl_rule_set_table(
struct rtnl_rule *rule, uint32_t table)
586 rule->r_table = table;
587 rule->ce_mask |= RULE_ATTR_TABLE;
590 uint32_t rtnl_rule_get_table(
struct rtnl_rule *rule)
592 return rule->r_table;
595 void rtnl_rule_set_dsfield(
struct rtnl_rule *rule, uint8_t dsfield)
597 rule->r_dsfield = dsfield;
598 rule->ce_mask |= RULE_ATTR_DSFIELD;
601 uint8_t rtnl_rule_get_dsfield(
struct rtnl_rule *rule)
603 return rule->r_dsfield;
606 static inline int __assign_addr(
struct rtnl_rule *rule,
struct nl_addr **pos,
607 struct nl_addr *
new,
int flag)
609 if (rule->ce_mask & RULE_ATTR_FAMILY) {
610 if (new->a_family != rule->r_family)
611 return -NLE_AF_MISMATCH;
613 rule->r_family =
new->a_family;
621 rule->ce_mask |= (flag | RULE_ATTR_FAMILY);
626 int rtnl_rule_set_src(
struct rtnl_rule *rule,
struct nl_addr *src)
628 return __assign_addr(rule, &rule->r_src, src, RULE_ATTR_SRC);
631 struct nl_addr *rtnl_rule_get_src(
struct rtnl_rule *rule)
636 int rtnl_rule_set_dst(
struct rtnl_rule *rule,
struct nl_addr *dst)
638 return __assign_addr(rule, &rule->r_dst, dst, RULE_ATTR_DST);
641 struct nl_addr *rtnl_rule_get_dst(
struct rtnl_rule *rule)
646 int rtnl_rule_set_iif(
struct rtnl_rule *rule,
const char *dev)
648 if (strlen(dev) > IFNAMSIZ-1)
651 strcpy(rule->r_iifname, dev);
652 rule->ce_mask |= RULE_ATTR_IIFNAME;
656 char *rtnl_rule_get_iif(
struct rtnl_rule *rule)
658 if (rule->ce_mask & RULE_ATTR_IIFNAME)
659 return rule->r_iifname;
664 int rtnl_rule_set_oif(
struct rtnl_rule *rule,
const char *dev)
666 if (strlen(dev) > IFNAMSIZ-1)
669 strcpy(rule->r_oifname, dev);
670 rule->ce_mask |= RULE_ATTR_OIFNAME;
674 char *rtnl_rule_get_oif(
struct rtnl_rule *rule)
676 if (rule->ce_mask & RULE_ATTR_OIFNAME)
677 return rule->r_oifname;
682 void rtnl_rule_set_action(
struct rtnl_rule *rule, uint8_t action)
684 rule->r_action = action;
685 rule->ce_mask |= RULE_ATTR_ACTION;
688 uint8_t rtnl_rule_get_action(
struct rtnl_rule *rule)
690 return rule->r_action;
693 void rtnl_rule_set_realms(
struct rtnl_rule *rule, uint32_t realms)
695 rule->r_flow = realms;
696 rule->ce_mask |= RULE_ATTR_FLOW;
699 uint32_t rtnl_rule_get_realms(
struct rtnl_rule *rule)
704 void rtnl_rule_set_goto(
struct rtnl_rule *rule, uint32_t ref)
707 rule->ce_mask |= RULE_ATTR_GOTO;
710 uint32_t rtnl_rule_get_goto(
struct rtnl_rule *rule)
717 static struct nl_object_ops rule_obj_ops = {
718 .oo_name =
"route/rule",
719 .oo_size =
sizeof(
struct rtnl_rule),
720 .oo_free_data = rule_free_data,
721 .oo_clone = rule_clone,
727 .oo_compare = rule_compare,
728 .oo_attrs2str = rule_attrs2str,
732 static struct nl_cache_ops rtnl_rule_ops = {
733 .co_name =
"route/rule",
734 .co_hdrsize =
sizeof(
struct fib_rule_hdr),
736 { RTM_NEWRULE, NL_ACT_NEW,
"new" },
737 { RTM_DELRULE, NL_ACT_DEL,
"del" },
738 { RTM_GETRULE, NL_ACT_GET,
"get" },
739 END_OF_MSGTYPES_LIST,
741 .co_protocol = NETLINK_ROUTE,
742 .co_request_update = rule_request_update,
743 .co_msg_parser = rule_msg_parser,
744 .co_obj_ops = &rule_obj_ops,
747 static void __init rule_init(
void)
752 static void __exit rule_exit(
void)