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> 25 #include <linux/fib_rules.h> 28 #define RULE_ATTR_FAMILY 0x0001 29 #define RULE_ATTR_TABLE 0x0002 30 #define RULE_ATTR_ACTION 0x0004 31 #define RULE_ATTR_FLAGS 0x0008 32 #define RULE_ATTR_IIFNAME 0x0010 33 #define RULE_ATTR_OIFNAME 0x0020 34 #define RULE_ATTR_PRIO 0x0040 35 #define RULE_ATTR_MARK 0x0080 36 #define RULE_ATTR_MASK 0x0100 37 #define RULE_ATTR_GOTO 0x0200 38 #define RULE_ATTR_SRC 0x0400 39 #define RULE_ATTR_DST 0x0800 40 #define RULE_ATTR_DSFIELD 0x1000 41 #define RULE_ATTR_FLOW 0x2000 42 #define RULE_ATTR_L3MDEV 0x4000 44 static struct nl_cache_ops rtnl_rule_ops;
45 static struct nl_object_ops rule_obj_ops;
48 static void rule_free_data(
struct nl_object *c)
50 struct rtnl_rule *rule = nl_object_priv(c);
59 static int rule_clone(
struct nl_object *_dst,
struct nl_object *_src)
61 struct rtnl_rule *dst = nl_object_priv(_dst);
62 struct rtnl_rule *src = nl_object_priv(_src);
75 static struct nla_policy rule_policy[FRA_MAX+1] = {
77 [FRA_IIFNAME] = { .type =
NLA_STRING, .maxlen = IFNAMSIZ },
78 [FRA_OIFNAME] = { .type =
NLA_STRING, .maxlen = IFNAMSIZ },
79 [FRA_PRIORITY] = { .type =
NLA_U32 },
80 [FRA_FWMARK] = { .type =
NLA_U32 },
81 [FRA_FWMASK] = { .type =
NLA_U32 },
82 [FRA_GOTO] = { .type =
NLA_U32 },
83 [FRA_FLOW] = { .type =
NLA_U32 },
84 [FRA_L3MDEV] = { .type =
NLA_U8 },
87 static int rule_msg_parser(
struct nl_cache_ops *ops,
struct sockaddr_nl *who,
88 struct nlmsghdr *n,
struct nl_parser_param *pp)
90 struct rtnl_rule *rule;
91 struct fib_rule_hdr *frh;
92 struct nlattr *tb[FRA_MAX+1];
95 rule = rtnl_rule_alloc();
101 rule->ce_msgtype = n->nlmsg_type;
104 err =
nlmsg_parse(n,
sizeof(*frh), tb, FRA_MAX, rule_policy);
108 rule->r_family = family = frh->family;
109 rule->r_table = frh->table;
110 rule->r_action = frh->action;
111 rule->r_flags = frh->flags;
113 rule->ce_mask = (RULE_ATTR_FAMILY | RULE_ATTR_ACTION | RULE_ATTR_FLAGS);
115 rule->ce_mask |= RULE_ATTR_TABLE;
119 rule->r_dsfield = frh->tos;
120 rule->ce_mask |= RULE_ATTR_DSFIELD;
126 rule->ce_mask |= RULE_ATTR_TABLE;
129 if (tb[FRA_IIFNAME]) {
130 nla_strlcpy(rule->r_iifname, tb[FRA_IIFNAME], IFNAMSIZ);
131 rule->ce_mask |= RULE_ATTR_IIFNAME;
134 if (tb[FRA_OIFNAME]) {
135 nla_strlcpy(rule->r_oifname, tb[FRA_OIFNAME], IFNAMSIZ);
136 rule->ce_mask |= RULE_ATTR_OIFNAME;
139 if (tb[FRA_PRIORITY]) {
141 rule->ce_mask |= RULE_ATTR_PRIO;
144 if (tb[FRA_FWMARK]) {
146 rule->ce_mask |= RULE_ATTR_MARK;
149 if (tb[FRA_FWMASK]) {
151 rule->ce_mask |= RULE_ATTR_MASK;
156 rule->ce_mask |= RULE_ATTR_GOTO;
164 rule->ce_mask |= RULE_ATTR_SRC;
171 rule->ce_mask |= RULE_ATTR_DST;
177 rule->ce_mask |= RULE_ATTR_FLOW;
180 if (tb[FRA_L3MDEV]) {
182 rule->ce_mask |= RULE_ATTR_L3MDEV;
185 err = pp->pp_cb((
struct nl_object *) rule, pp);
195 static int rule_request_update(
struct nl_cache *c,
struct nl_sock *h)
200 static void rule_dump_line(
struct nl_object *o,
struct nl_dump_params *p)
202 struct rtnl_rule *r = (
struct rtnl_rule *) o;
205 nl_dump_line(p,
"%8d ", (r->ce_mask & RULE_ATTR_PRIO) ? r->r_prio : 0);
206 nl_dump(p,
"%s ", nl_af2str(r->r_family, buf,
sizeof(buf)));
208 if (r->ce_mask & RULE_ATTR_SRC)
212 if (r->ce_mask & RULE_ATTR_DST)
216 if (r->ce_mask & RULE_ATTR_DSFIELD)
217 nl_dump(p,
"tos %u ", r->r_dsfield);
219 if (r->ce_mask & (RULE_ATTR_MARK | RULE_ATTR_MASK))
220 nl_dump(p,
"mark %#x/%#x", r->r_mark, r->r_mask);
222 if (r->ce_mask & RULE_ATTR_IIFNAME)
223 nl_dump(p,
"iif %s ", r->r_iifname);
225 if (r->ce_mask & RULE_ATTR_OIFNAME)
226 nl_dump(p,
"oif %s ", r->r_oifname);
228 if (r->ce_mask & RULE_ATTR_TABLE)
230 rtnl_route_table2str(r->r_table, buf,
sizeof(buf)));
232 if (r->ce_mask & RULE_ATTR_L3MDEV)
233 nl_dump(p,
"lookup [l3mdev-table] ");
235 if (r->ce_mask & RULE_ATTR_FLOW)
237 rtnl_realms2str(r->r_flow, buf,
sizeof(buf)));
239 if (r->ce_mask & RULE_ATTR_GOTO)
240 nl_dump(p,
"goto %u ", r->r_goto);
242 if (r->ce_mask & RULE_ATTR_ACTION)
244 nl_rtntype2str(r->r_action, buf,
sizeof(buf)));
249 static void rule_dump_details(
struct nl_object *obj,
struct nl_dump_params *p)
251 rule_dump_line(obj, p);
254 static void rule_dump_stats(
struct nl_object *obj,
struct nl_dump_params *p)
256 rule_dump_details(obj, p);
259 #define RULE_ATTR_FLAGS 0x0008 261 static uint64_t rule_compare(
struct nl_object *_a,
struct nl_object *_b,
262 uint64_t attrs,
int flags)
264 struct rtnl_rule *a = (
struct rtnl_rule *) _a;
265 struct rtnl_rule *b = (
struct rtnl_rule *) _b;
268 #define RULE_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, RULE_ATTR_##ATTR, a, b, EXPR) 270 diff |= RULE_DIFF(FAMILY, a->r_family != b->r_family);
271 diff |= RULE_DIFF(TABLE, a->r_table != b->r_table);
272 diff |= RULE_DIFF(ACTION, a->r_action != b->r_action);
273 diff |= RULE_DIFF(IIFNAME, strcmp(a->r_iifname, b->r_iifname));
274 diff |= RULE_DIFF(OIFNAME, strcmp(a->r_oifname, b->r_oifname));
275 diff |= RULE_DIFF(PRIO, a->r_prio != b->r_prio);
276 diff |= RULE_DIFF(MARK, a->r_mark != b->r_mark);
277 diff |= RULE_DIFF(MASK, a->r_mask != b->r_mask);
278 diff |= RULE_DIFF(GOTO, a->r_goto != b->r_goto);
279 diff |= RULE_DIFF(SRC,
nl_addr_cmp(a->r_src, b->r_src));
280 diff |= RULE_DIFF(DST,
nl_addr_cmp(a->r_dst, b->r_dst));
281 diff |= RULE_DIFF(DSFIELD, a->r_dsfield != b->r_dsfield);
282 diff |= RULE_DIFF(FLOW, a->r_flow != b->r_flow);
289 static const struct trans_tbl rule_attrs[] = {
290 __ADD(RULE_ATTR_FAMILY, family),
291 __ADD(RULE_ATTR_TABLE, table),
292 __ADD(RULE_ATTR_ACTION, action),
293 __ADD(RULE_ATTR_IIFNAME, iifname),
294 __ADD(RULE_ATTR_OIFNAME, oifname),
295 __ADD(RULE_ATTR_PRIO, prio),
296 __ADD(RULE_ATTR_MARK, mark),
297 __ADD(RULE_ATTR_MASK, mask),
298 __ADD(RULE_ATTR_GOTO,
goto),
299 __ADD(RULE_ATTR_SRC, src),
300 __ADD(RULE_ATTR_DST, dst),
301 __ADD(RULE_ATTR_DSFIELD, dsfield),
302 __ADD(RULE_ATTR_FLOW, flow),
305 static char *rule_attrs2str(
int attrs,
char *buf,
size_t len)
307 return __flags2str(attrs, buf, len, rule_attrs,
308 ARRAY_SIZE(rule_attrs));
316 struct rtnl_rule *rtnl_rule_alloc(
void)
321 void rtnl_rule_put(
struct rtnl_rule *rule)
345 struct nl_cache **result)
347 struct nl_cache * cache;
353 cache->c_iarg1 = family;
371 static int build_rule_msg(
struct rtnl_rule *tmpl,
int cmd,
int flags,
372 struct nl_msg **result)
375 struct fib_rule_hdr frh = {
376 .family = tmpl->r_family,
377 .table = tmpl->r_table,
378 .action = tmpl->r_action,
379 .flags = tmpl->r_flags,
380 .tos = tmpl->r_dsfield,
383 if (!(tmpl->ce_mask & RULE_ATTR_FAMILY))
384 return -NLE_MISSING_ATTR;
390 if (tmpl->ce_mask & RULE_ATTR_SRC)
393 if (tmpl->ce_mask & RULE_ATTR_DST)
396 if (
nlmsg_append(msg, &frh,
sizeof(frh), NLMSG_ALIGNTO) < 0)
397 goto nla_put_failure;
403 if (tmpl->ce_mask & RULE_ATTR_SRC)
406 if (tmpl->ce_mask & RULE_ATTR_DST)
409 if (tmpl->ce_mask & RULE_ATTR_IIFNAME)
412 if (tmpl->ce_mask & RULE_ATTR_OIFNAME)
415 if (tmpl->ce_mask & RULE_ATTR_PRIO)
418 if (tmpl->ce_mask & RULE_ATTR_MARK)
421 if (tmpl->ce_mask & RULE_ATTR_MASK)
424 if (tmpl->ce_mask & RULE_ATTR_GOTO)
427 if (tmpl->ce_mask & RULE_ATTR_FLOW)
430 if (tmpl->ce_mask & RULE_ATTR_L3MDEV)
457 struct nl_msg **result)
459 return build_rule_msg(tmpl, RTM_NEWRULE, NLM_F_CREATE | flags,
488 return wait_for_ack(sk);
513 struct nl_msg **result)
515 return build_rule_msg(rule, RTM_DELRULE, flags, result);
543 return wait_for_ack(sk);
553 void rtnl_rule_set_family(
struct rtnl_rule *rule,
int family)
555 rule->r_family = family;
556 rule->ce_mask |= RULE_ATTR_FAMILY;
559 int rtnl_rule_get_family(
struct rtnl_rule *rule)
561 if (rule->ce_mask & RULE_ATTR_FAMILY)
562 return rule->r_family;
567 void rtnl_rule_set_prio(
struct rtnl_rule *rule, uint32_t prio)
570 rule->ce_mask |= RULE_ATTR_PRIO;
573 uint32_t rtnl_rule_get_prio(
struct rtnl_rule *rule)
578 void rtnl_rule_set_mark(
struct rtnl_rule *rule, uint32_t mark)
581 rule->ce_mask |= RULE_ATTR_MARK;
584 uint32_t rtnl_rule_get_mark(
struct rtnl_rule *rule)
589 void rtnl_rule_set_mask(
struct rtnl_rule *rule, uint32_t mask)
592 rule->ce_mask |= RULE_ATTR_MASK;
595 uint32_t rtnl_rule_get_mask(
struct rtnl_rule *rule)
600 void rtnl_rule_set_table(
struct rtnl_rule *rule, uint32_t table)
602 rule->r_table = table;
603 rule->ce_mask |= RULE_ATTR_TABLE;
606 uint32_t rtnl_rule_get_table(
struct rtnl_rule *rule)
608 return rule->r_table;
611 void rtnl_rule_set_dsfield(
struct rtnl_rule *rule, uint8_t dsfield)
613 rule->r_dsfield = dsfield;
614 rule->ce_mask |= RULE_ATTR_DSFIELD;
617 uint8_t rtnl_rule_get_dsfield(
struct rtnl_rule *rule)
619 return rule->r_dsfield;
622 static inline int __assign_addr(
struct rtnl_rule *rule,
struct nl_addr **pos,
623 struct nl_addr *
new,
int flag)
625 if (rule->ce_mask & RULE_ATTR_FAMILY) {
626 if (new->a_family != rule->r_family)
627 return -NLE_AF_MISMATCH;
629 rule->r_family =
new->a_family;
637 rule->ce_mask |= (flag | RULE_ATTR_FAMILY);
642 int rtnl_rule_set_src(
struct rtnl_rule *rule,
struct nl_addr *src)
644 return __assign_addr(rule, &rule->r_src, src, RULE_ATTR_SRC);
647 struct nl_addr *rtnl_rule_get_src(
struct rtnl_rule *rule)
652 int rtnl_rule_set_dst(
struct rtnl_rule *rule,
struct nl_addr *dst)
654 return __assign_addr(rule, &rule->r_dst, dst, RULE_ATTR_DST);
657 struct nl_addr *rtnl_rule_get_dst(
struct rtnl_rule *rule)
662 int rtnl_rule_set_iif(
struct rtnl_rule *rule,
const char *dev)
664 if (strlen(dev) > IFNAMSIZ-1)
667 strcpy(rule->r_iifname, dev);
668 rule->ce_mask |= RULE_ATTR_IIFNAME;
672 char *rtnl_rule_get_iif(
struct rtnl_rule *rule)
674 if (rule->ce_mask & RULE_ATTR_IIFNAME)
675 return rule->r_iifname;
680 int rtnl_rule_set_oif(
struct rtnl_rule *rule,
const char *dev)
682 if (strlen(dev) > IFNAMSIZ-1)
685 strcpy(rule->r_oifname, dev);
686 rule->ce_mask |= RULE_ATTR_OIFNAME;
690 char *rtnl_rule_get_oif(
struct rtnl_rule *rule)
692 if (rule->ce_mask & RULE_ATTR_OIFNAME)
693 return rule->r_oifname;
698 void rtnl_rule_set_action(
struct rtnl_rule *rule, uint8_t action)
700 rule->r_action = action;
701 rule->ce_mask |= RULE_ATTR_ACTION;
704 uint8_t rtnl_rule_get_action(
struct rtnl_rule *rule)
706 return rule->r_action;
721 rule->r_l3mdev = (uint8_t) value;
722 rule->ce_mask |= RULE_ATTR_L3MDEV;
725 rule->ce_mask &= ~((uint32_t) RULE_ATTR_L3MDEV);
742 if (!(rule->ce_mask & RULE_ATTR_L3MDEV))
743 return -NLE_MISSING_ATTR;
744 return rule->r_l3mdev;
747 void rtnl_rule_set_realms(
struct rtnl_rule *rule, uint32_t realms)
749 rule->r_flow = realms;
750 rule->ce_mask |= RULE_ATTR_FLOW;
753 uint32_t rtnl_rule_get_realms(
struct rtnl_rule *rule)
758 void rtnl_rule_set_goto(
struct rtnl_rule *rule, uint32_t ref)
761 rule->ce_mask |= RULE_ATTR_GOTO;
764 uint32_t rtnl_rule_get_goto(
struct rtnl_rule *rule)
771 static struct nl_object_ops rule_obj_ops = {
772 .oo_name =
"route/rule",
773 .oo_size =
sizeof(
struct rtnl_rule),
774 .oo_free_data = rule_free_data,
775 .oo_clone = rule_clone,
781 .oo_compare = rule_compare,
782 .oo_attrs2str = rule_attrs2str,
786 static struct nl_cache_ops rtnl_rule_ops = {
787 .co_name =
"route/rule",
788 .co_hdrsize =
sizeof(
struct fib_rule_hdr),
790 { RTM_NEWRULE, NL_ACT_NEW,
"new" },
791 { RTM_DELRULE, NL_ACT_DEL,
"del" },
792 { RTM_GETRULE, NL_ACT_GET,
"get" },
793 END_OF_MSGTYPES_LIST,
795 .co_protocol = NETLINK_ROUTE,
796 .co_request_update = rule_request_update,
797 .co_msg_parser = rule_msg_parser,
798 .co_obj_ops = &rule_obj_ops,
801 static void __init rule_init(
void)
806 static void __exit rule_exit(
void)
int rtnl_rule_alloc_cache(struct nl_sock *sock, int family, struct nl_cache **result)
Build a rule cache including all rules currently configured in the kernel.
int nl_send_auto_complete(struct nl_sock *sk, struct nl_msg *msg)
struct nl_addr * nl_addr_clone(const struct nl_addr *addr)
Clone existing abstract address object.
Dump object briefly on one line.
int rtnl_rule_build_delete_request(struct rtnl_rule *rule, int flags, struct nl_msg **result)
Build a netlink request message to delete a rule.
void nl_addr_set_prefixlen(struct nl_addr *addr, int prefixlen)
Set the prefix length of an abstract address.
void nlmsg_free(struct nl_msg *msg)
Release a reference from an netlink message.
int nl_addr_cmp(const struct nl_addr *a, const struct nl_addr *b)
Compare abstract addresses.
void * nlmsg_data(const struct nlmsghdr *nlh)
Return pointer to message payload.
#define NLA_PUT_ADDR(msg, attrtype, addr)
Add address attribute to netlink message.
unsigned int nl_addr_get_prefixlen(const struct nl_addr *addr)
Return prefix length of abstract address object.
struct nl_object * nl_object_alloc(struct nl_object_ops *ops)
Allocate a new object of kind specified by the operations handle.
int nl_cache_mngt_unregister(struct nl_cache_ops *ops)
Unregister a set of cache operations.
Attribute validation policy.
uint8_t nla_get_u8(const struct nlattr *nla)
Return value of 8 bit integer attribute.
uint32_t nla_get_u32(const struct nlattr *nla)
Return payload of 32 bit integer attribute.
int rtnl_rule_get_l3mdev(struct rtnl_rule *rule)
Get l3mdev value of the rule (FRA_L3MDEV)
int nlmsg_parse(struct nlmsghdr *nlh, int hdrlen, struct nlattr *tb[], int maxtype, struct nla_policy *policy)
parse attributes of a netlink message
struct nl_addr * nl_addr_get(struct nl_addr *addr)
Increase the reference counter of an abstract address.
struct nl_addr * nl_addr_alloc_attr(const struct nlattr *nla, int family)
Allocate abstract address based on Netlink attribute.
#define NLA_PUT_U8(msg, attrtype, value)
Add 8 bit integer attribute to netlink message.
NUL terminated character string.
Dump all attributes but no statistics.
int nl_cache_mngt_register(struct nl_cache_ops *ops)
Register a set of cache operations.
int rtnl_rule_build_add_request(struct rtnl_rule *tmpl, int flags, struct nl_msg **result)
Build netlink request message to add a new rule.
int nl_rtgen_request(struct nl_sock *sk, int type, int family, int flags)
Send routing netlink request message.
#define NLA_PUT_U32(msg, attrtype, value)
Add 32 bit integer attribute to netlink message.
void rtnl_rule_set_l3mdev(struct rtnl_rule *rule, int value)
Set l3mdev value of the rule (FRA_L3MDEV)
int nlmsg_append(struct nl_msg *n, void *data, size_t len, int pad)
Append data to tail of a netlink message.
int nl_cache_refill(struct nl_sock *sk, struct nl_cache *cache)
(Re)fill a cache with the contents in the kernel.
void nl_object_put(struct nl_object *obj)
Release a reference from an object.
#define NLA_PUT_STRING(msg, attrtype, value)
Add string attribute to netlink message.
int rtnl_rule_delete(struct nl_sock *sk, struct rtnl_rule *rule, int flags)
Delete a rule.
void nl_addr_put(struct nl_addr *addr)
Decrease the reference counter of an abstract address.
uint16_t type
Type of attribute or NLA_UNSPEC.
struct nl_msg * nlmsg_alloc_simple(int nlmsgtype, int flags)
Allocate a new netlink message.
void nl_dump(struct nl_dump_params *params, const char *fmt,...)
Dump a formatted character string.
int rtnl_rule_add(struct nl_sock *sk, struct rtnl_rule *tmpl, int flags)
Add a new rule.
Dump all attributes including statistics.
size_t nla_strlcpy(char *dst, const struct nlattr *nla, size_t dstsize)
Copy string attribute payload to a buffer.
struct nl_cache * nl_cache_alloc(struct nl_cache_ops *ops)
Allocate new cache.
char * nl_addr2str(const struct nl_addr *addr, char *buf, size_t size)
Convert abstract address object to character string.