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 43 static struct nl_cache_ops rtnl_rule_ops;
44 static struct nl_object_ops rule_obj_ops;
47 static void rule_free_data(
struct nl_object *c)
49 struct rtnl_rule *rule = nl_object_priv(c);
58 static int rule_clone(
struct nl_object *_dst,
struct nl_object *_src)
60 struct rtnl_rule *dst = nl_object_priv(_dst);
61 struct rtnl_rule *src = nl_object_priv(_src);
74 static struct nla_policy rule_policy[FRA_MAX+1] = {
76 [FRA_IIFNAME] = { .type =
NLA_STRING, .maxlen = IFNAMSIZ },
77 [FRA_OIFNAME] = { .type =
NLA_STRING, .maxlen = IFNAMSIZ },
78 [FRA_PRIORITY] = { .type =
NLA_U32 },
79 [FRA_FWMARK] = { .type =
NLA_U32 },
80 [FRA_FWMASK] = { .type =
NLA_U32 },
81 [FRA_GOTO] = { .type =
NLA_U32 },
82 [FRA_FLOW] = { .type =
NLA_U32 },
85 static int rule_msg_parser(
struct nl_cache_ops *ops,
struct sockaddr_nl *who,
86 struct nlmsghdr *n,
struct nl_parser_param *pp)
88 struct rtnl_rule *rule;
89 struct fib_rule_hdr *frh;
90 struct nlattr *tb[FRA_MAX+1];
93 rule = rtnl_rule_alloc();
99 rule->ce_msgtype = n->nlmsg_type;
102 err =
nlmsg_parse(n,
sizeof(*frh), tb, FRA_MAX, rule_policy);
106 rule->r_family = family = frh->family;
107 rule->r_table = frh->table;
108 rule->r_action = frh->action;
109 rule->r_flags = frh->flags;
111 rule->ce_mask = (RULE_ATTR_FAMILY | RULE_ATTR_TABLE | RULE_ATTR_ACTION |
116 rule->r_dsfield = frh->tos;
117 rule->ce_mask |= RULE_ATTR_DSFIELD;
122 rule->ce_mask |= RULE_ATTR_TABLE;
125 if (tb[FRA_IIFNAME]) {
126 nla_strlcpy(rule->r_iifname, tb[FRA_IIFNAME], IFNAMSIZ);
127 rule->ce_mask |= RULE_ATTR_IIFNAME;
130 if (tb[FRA_OIFNAME]) {
131 nla_strlcpy(rule->r_oifname, tb[FRA_OIFNAME], IFNAMSIZ);
132 rule->ce_mask |= RULE_ATTR_OIFNAME;
135 if (tb[FRA_PRIORITY]) {
137 rule->ce_mask |= RULE_ATTR_PRIO;
140 if (tb[FRA_FWMARK]) {
142 rule->ce_mask |= RULE_ATTR_MARK;
145 if (tb[FRA_FWMASK]) {
147 rule->ce_mask |= RULE_ATTR_MASK;
152 rule->ce_mask |= RULE_ATTR_GOTO;
160 rule->ce_mask |= RULE_ATTR_SRC;
167 rule->ce_mask |= RULE_ATTR_DST;
173 rule->ce_mask |= RULE_ATTR_FLOW;
176 err = pp->pp_cb((
struct nl_object *) rule, pp);
186 static int rule_request_update(
struct nl_cache *c,
struct nl_sock *h)
191 static void rule_dump_line(
struct nl_object *o,
struct nl_dump_params *p)
193 struct rtnl_rule *r = (
struct rtnl_rule *) o;
196 nl_dump_line(p,
"%8d ", (r->ce_mask & RULE_ATTR_PRIO) ? r->r_prio : 0);
197 nl_dump(p,
"%s ", nl_af2str(r->r_family, buf,
sizeof(buf)));
199 if (r->ce_mask & RULE_ATTR_SRC)
203 if (r->ce_mask & RULE_ATTR_DST)
207 if (r->ce_mask & RULE_ATTR_DSFIELD)
208 nl_dump(p,
"tos %u ", r->r_dsfield);
210 if (r->ce_mask & (RULE_ATTR_MARK | RULE_ATTR_MASK))
211 nl_dump(p,
"mark %#x/%#x", r->r_mark, r->r_mask);
213 if (r->ce_mask & RULE_ATTR_IIFNAME)
214 nl_dump(p,
"iif %s ", r->r_iifname);
216 if (r->ce_mask & RULE_ATTR_OIFNAME)
217 nl_dump(p,
"oif %s ", r->r_oifname);
219 if (r->ce_mask & RULE_ATTR_TABLE)
221 rtnl_route_table2str(r->r_table, buf,
sizeof(buf)));
223 if (r->ce_mask & RULE_ATTR_FLOW)
225 rtnl_realms2str(r->r_flow, buf,
sizeof(buf)));
227 if (r->ce_mask & RULE_ATTR_GOTO)
228 nl_dump(p,
"goto %u ", r->r_goto);
230 if (r->ce_mask & RULE_ATTR_ACTION)
232 nl_rtntype2str(r->r_action, buf,
sizeof(buf)));
237 static void rule_dump_details(
struct nl_object *obj,
struct nl_dump_params *p)
239 rule_dump_line(obj, p);
242 static void rule_dump_stats(
struct nl_object *obj,
struct nl_dump_params *p)
244 rule_dump_details(obj, p);
247 #define RULE_ATTR_FLAGS 0x0008 249 static uint64_t rule_compare(
struct nl_object *_a,
struct nl_object *_b,
250 uint64_t attrs,
int flags)
252 struct rtnl_rule *a = (
struct rtnl_rule *) _a;
253 struct rtnl_rule *b = (
struct rtnl_rule *) _b;
256 #define RULE_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, RULE_ATTR_##ATTR, a, b, EXPR) 258 diff |= RULE_DIFF(FAMILY, a->r_family != b->r_family);
259 diff |= RULE_DIFF(TABLE, a->r_table != b->r_table);
260 diff |= RULE_DIFF(ACTION, a->r_action != b->r_action);
261 diff |= RULE_DIFF(IIFNAME, strcmp(a->r_iifname, b->r_iifname));
262 diff |= RULE_DIFF(OIFNAME, strcmp(a->r_oifname, b->r_oifname));
263 diff |= RULE_DIFF(PRIO, a->r_prio != b->r_prio);
264 diff |= RULE_DIFF(MARK, a->r_mark != b->r_mark);
265 diff |= RULE_DIFF(MASK, a->r_mask != b->r_mask);
266 diff |= RULE_DIFF(GOTO, a->r_goto != b->r_goto);
267 diff |= RULE_DIFF(SRC,
nl_addr_cmp(a->r_src, b->r_src));
268 diff |= RULE_DIFF(DST,
nl_addr_cmp(a->r_dst, b->r_dst));
269 diff |= RULE_DIFF(DSFIELD, a->r_dsfield != b->r_dsfield);
270 diff |= RULE_DIFF(FLOW, a->r_flow != b->r_flow);
277 static const struct trans_tbl rule_attrs[] = {
278 __ADD(RULE_ATTR_FAMILY, family),
279 __ADD(RULE_ATTR_TABLE, table),
280 __ADD(RULE_ATTR_ACTION, action),
281 __ADD(RULE_ATTR_IIFNAME, iifname),
282 __ADD(RULE_ATTR_OIFNAME, oifname),
283 __ADD(RULE_ATTR_PRIO, prio),
284 __ADD(RULE_ATTR_MARK, mark),
285 __ADD(RULE_ATTR_MASK, mask),
286 __ADD(RULE_ATTR_GOTO,
goto),
287 __ADD(RULE_ATTR_SRC, src),
288 __ADD(RULE_ATTR_DST, dst),
289 __ADD(RULE_ATTR_DSFIELD, dsfield),
290 __ADD(RULE_ATTR_FLOW, flow),
293 static char *rule_attrs2str(
int attrs,
char *buf,
size_t len)
295 return __flags2str(attrs, buf, len, rule_attrs,
296 ARRAY_SIZE(rule_attrs));
304 struct rtnl_rule *rtnl_rule_alloc(
void)
309 void rtnl_rule_put(
struct rtnl_rule *rule)
333 struct nl_cache **result)
335 struct nl_cache * cache;
341 cache->c_iarg1 = family;
359 static int build_rule_msg(
struct rtnl_rule *tmpl,
int cmd,
int flags,
360 struct nl_msg **result)
363 struct fib_rule_hdr frh = {
364 .family = tmpl->r_family,
365 .table = tmpl->r_table,
366 .action = tmpl->r_action,
367 .flags = tmpl->r_flags,
368 .tos = tmpl->r_dsfield,
371 if (!(tmpl->ce_mask & RULE_ATTR_FAMILY))
372 return -NLE_MISSING_ATTR;
378 if (tmpl->ce_mask & RULE_ATTR_SRC)
381 if (tmpl->ce_mask & RULE_ATTR_DST)
384 if (
nlmsg_append(msg, &frh,
sizeof(frh), NLMSG_ALIGNTO) < 0)
385 goto nla_put_failure;
391 if (tmpl->ce_mask & RULE_ATTR_SRC)
394 if (tmpl->ce_mask & RULE_ATTR_DST)
397 if (tmpl->ce_mask & RULE_ATTR_IIFNAME)
400 if (tmpl->ce_mask & RULE_ATTR_OIFNAME)
403 if (tmpl->ce_mask & RULE_ATTR_PRIO)
406 if (tmpl->ce_mask & RULE_ATTR_MARK)
409 if (tmpl->ce_mask & RULE_ATTR_MASK)
412 if (tmpl->ce_mask & RULE_ATTR_GOTO)
415 if (tmpl->ce_mask & RULE_ATTR_FLOW)
442 struct nl_msg **result)
444 return build_rule_msg(tmpl, RTM_NEWRULE, NLM_F_CREATE | flags,
473 return wait_for_ack(sk);
498 struct nl_msg **result)
500 return build_rule_msg(rule, RTM_DELRULE, flags, result);
528 return wait_for_ack(sk);
538 void rtnl_rule_set_family(
struct rtnl_rule *rule,
int family)
540 rule->r_family = family;
541 rule->ce_mask |= RULE_ATTR_FAMILY;
544 int rtnl_rule_get_family(
struct rtnl_rule *rule)
546 if (rule->ce_mask & RULE_ATTR_FAMILY)
547 return rule->r_family;
552 void rtnl_rule_set_prio(
struct rtnl_rule *rule, uint32_t prio)
555 rule->ce_mask |= RULE_ATTR_PRIO;
558 uint32_t rtnl_rule_get_prio(
struct rtnl_rule *rule)
563 void rtnl_rule_set_mark(
struct rtnl_rule *rule, uint32_t mark)
566 rule->ce_mask |= RULE_ATTR_MARK;
569 uint32_t rtnl_rule_get_mark(
struct rtnl_rule *rule)
574 void rtnl_rule_set_mask(
struct rtnl_rule *rule, uint32_t mask)
577 rule->ce_mask |= RULE_ATTR_MASK;
580 uint32_t rtnl_rule_get_mask(
struct rtnl_rule *rule)
585 void rtnl_rule_set_table(
struct rtnl_rule *rule, uint32_t table)
587 rule->r_table = table;
588 rule->ce_mask |= RULE_ATTR_TABLE;
591 uint32_t rtnl_rule_get_table(
struct rtnl_rule *rule)
593 return rule->r_table;
596 void rtnl_rule_set_dsfield(
struct rtnl_rule *rule, uint8_t dsfield)
598 rule->r_dsfield = dsfield;
599 rule->ce_mask |= RULE_ATTR_DSFIELD;
602 uint8_t rtnl_rule_get_dsfield(
struct rtnl_rule *rule)
604 return rule->r_dsfield;
607 static inline int __assign_addr(
struct rtnl_rule *rule,
struct nl_addr **pos,
608 struct nl_addr *
new,
int flag)
610 if (rule->ce_mask & RULE_ATTR_FAMILY) {
611 if (new->a_family != rule->r_family)
612 return -NLE_AF_MISMATCH;
614 rule->r_family =
new->a_family;
622 rule->ce_mask |= (flag | RULE_ATTR_FAMILY);
627 int rtnl_rule_set_src(
struct rtnl_rule *rule,
struct nl_addr *src)
629 return __assign_addr(rule, &rule->r_src, src, RULE_ATTR_SRC);
632 struct nl_addr *rtnl_rule_get_src(
struct rtnl_rule *rule)
637 int rtnl_rule_set_dst(
struct rtnl_rule *rule,
struct nl_addr *dst)
639 return __assign_addr(rule, &rule->r_dst, dst, RULE_ATTR_DST);
642 struct nl_addr *rtnl_rule_get_dst(
struct rtnl_rule *rule)
647 int rtnl_rule_set_iif(
struct rtnl_rule *rule,
const char *dev)
649 if (strlen(dev) > IFNAMSIZ-1)
652 strcpy(rule->r_iifname, dev);
653 rule->ce_mask |= RULE_ATTR_IIFNAME;
657 char *rtnl_rule_get_iif(
struct rtnl_rule *rule)
659 if (rule->ce_mask & RULE_ATTR_IIFNAME)
660 return rule->r_iifname;
665 int rtnl_rule_set_oif(
struct rtnl_rule *rule,
const char *dev)
667 if (strlen(dev) > IFNAMSIZ-1)
670 strcpy(rule->r_oifname, dev);
671 rule->ce_mask |= RULE_ATTR_OIFNAME;
675 char *rtnl_rule_get_oif(
struct rtnl_rule *rule)
677 if (rule->ce_mask & RULE_ATTR_OIFNAME)
678 return rule->r_oifname;
683 void rtnl_rule_set_action(
struct rtnl_rule *rule, uint8_t action)
685 rule->r_action = action;
686 rule->ce_mask |= RULE_ATTR_ACTION;
689 uint8_t rtnl_rule_get_action(
struct rtnl_rule *rule)
691 return rule->r_action;
694 void rtnl_rule_set_realms(
struct rtnl_rule *rule, uint32_t realms)
696 rule->r_flow = realms;
697 rule->ce_mask |= RULE_ATTR_FLOW;
700 uint32_t rtnl_rule_get_realms(
struct rtnl_rule *rule)
705 void rtnl_rule_set_goto(
struct rtnl_rule *rule, uint32_t ref)
708 rule->ce_mask |= RULE_ATTR_GOTO;
711 uint32_t rtnl_rule_get_goto(
struct rtnl_rule *rule)
718 static struct nl_object_ops rule_obj_ops = {
719 .oo_name =
"route/rule",
720 .oo_size =
sizeof(
struct rtnl_rule),
721 .oo_free_data = rule_free_data,
722 .oo_clone = rule_clone,
728 .oo_compare = rule_compare,
729 .oo_attrs2str = rule_attrs2str,
733 static struct nl_cache_ops rtnl_rule_ops = {
734 .co_name =
"route/rule",
735 .co_hdrsize =
sizeof(
struct fib_rule_hdr),
737 { RTM_NEWRULE, NL_ACT_NEW,
"new" },
738 { RTM_DELRULE, NL_ACT_DEL,
"del" },
739 { RTM_GETRULE, NL_ACT_GET,
"get" },
740 END_OF_MSGTYPES_LIST,
742 .co_protocol = NETLINK_ROUTE,
743 .co_request_update = rule_request_update,
744 .co_msg_parser = rule_msg_parser,
745 .co_obj_ops = &rule_obj_ops,
748 static void __init rule_init(
void)
753 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.
uint32_t nla_get_u32(const struct nlattr *nla)
Return payload of 32 bit integer attribute.
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.
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.
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.