20 #include <netlink-private/netlink.h> 21 #include <netlink/netlink.h> 22 #include <netlink/utils.h> 23 #include <netlink/route/rtnl.h> 24 #include <netlink/route/rule.h> 26 #include <linux/fib_rules.h> 29 #define RULE_ATTR_FAMILY 0x000001 30 #define RULE_ATTR_TABLE 0x000002 31 #define RULE_ATTR_ACTION 0x000004 32 #define RULE_ATTR_FLAGS 0x000008 33 #define RULE_ATTR_IIFNAME 0x000010 34 #define RULE_ATTR_OIFNAME 0x000020 35 #define RULE_ATTR_PRIO 0x000040 36 #define RULE_ATTR_MARK 0x000080 37 #define RULE_ATTR_MASK 0x000100 38 #define RULE_ATTR_GOTO 0x000200 39 #define RULE_ATTR_SRC 0x000400 40 #define RULE_ATTR_DST 0x000800 41 #define RULE_ATTR_DSFIELD 0x001000 42 #define RULE_ATTR_FLOW 0x002000 43 #define RULE_ATTR_L3MDEV 0x004000 44 #define RULE_ATTR_PROTOCOL 0x008000 45 #define RULE_ATTR_IP_PROTO 0x010000 46 #define RULE_ATTR_SPORT 0x020000 47 #define RULE_ATTR_DPORT 0x040000 49 static struct nl_cache_ops rtnl_rule_ops;
50 static struct nl_object_ops rule_obj_ops;
53 static void rule_free_data(
struct nl_object *c)
55 struct rtnl_rule *rule = nl_object_priv(c);
64 static int rule_clone(
struct nl_object *_dst,
struct nl_object *_src)
66 struct rtnl_rule *dst = nl_object_priv(_dst);
67 struct rtnl_rule *src = nl_object_priv(_src);
80 static struct nla_policy rule_policy[FRA_MAX+1] = {
82 [FRA_IIFNAME] = { .type =
NLA_STRING, .maxlen = IFNAMSIZ },
83 [FRA_OIFNAME] = { .type =
NLA_STRING, .maxlen = IFNAMSIZ },
84 [FRA_PRIORITY] = { .type =
NLA_U32 },
85 [FRA_FWMARK] = { .type =
NLA_U32 },
86 [FRA_FWMASK] = { .type =
NLA_U32 },
87 [FRA_GOTO] = { .type =
NLA_U32 },
88 [FRA_FLOW] = { .type =
NLA_U32 },
89 [FRA_L3MDEV] = { .type =
NLA_U8 },
90 [FRA_PROTOCOL] = { .type =
NLA_U8 },
91 [FRA_IP_PROTO] = { .type =
NLA_U8 },
92 [FRA_SPORT_RANGE] = { .minlen =
sizeof(
struct fib_rule_port_range),
93 .maxlen =
sizeof(
struct fib_rule_port_range) },
94 [FRA_DPORT_RANGE] = { .minlen =
sizeof(
struct fib_rule_port_range),
95 .maxlen =
sizeof(
struct fib_rule_port_range) },
98 static int rule_msg_parser(
struct nl_cache_ops *ops,
struct sockaddr_nl *who,
99 struct nlmsghdr *n,
struct nl_parser_param *pp)
101 struct rtnl_rule *rule;
102 struct fib_rule_hdr *frh;
103 struct nlattr *tb[FRA_MAX+1];
106 rule = rtnl_rule_alloc();
112 rule->ce_msgtype = n->nlmsg_type;
115 err =
nlmsg_parse(n,
sizeof(*frh), tb, FRA_MAX, rule_policy);
119 rule->r_family = family = frh->family;
120 rule->r_table = frh->table;
121 rule->r_action = frh->action;
122 rule->r_flags = frh->flags;
124 rule->ce_mask = (RULE_ATTR_FAMILY | RULE_ATTR_ACTION | RULE_ATTR_FLAGS);
126 rule->ce_mask |= RULE_ATTR_TABLE;
130 rule->r_dsfield = frh->tos;
131 rule->ce_mask |= RULE_ATTR_DSFIELD;
137 rule->ce_mask |= RULE_ATTR_TABLE;
140 if (tb[FRA_IIFNAME]) {
141 nla_strlcpy(rule->r_iifname, tb[FRA_IIFNAME], IFNAMSIZ);
142 rule->ce_mask |= RULE_ATTR_IIFNAME;
145 if (tb[FRA_OIFNAME]) {
146 nla_strlcpy(rule->r_oifname, tb[FRA_OIFNAME], IFNAMSIZ);
147 rule->ce_mask |= RULE_ATTR_OIFNAME;
150 if (tb[FRA_PRIORITY]) {
152 rule->ce_mask |= RULE_ATTR_PRIO;
155 if (tb[FRA_FWMARK]) {
157 rule->ce_mask |= RULE_ATTR_MARK;
160 if (tb[FRA_FWMASK]) {
162 rule->ce_mask |= RULE_ATTR_MASK;
167 rule->ce_mask |= RULE_ATTR_GOTO;
175 rule->ce_mask |= RULE_ATTR_SRC;
182 rule->ce_mask |= RULE_ATTR_DST;
188 rule->ce_mask |= RULE_ATTR_FLOW;
191 if (tb[FRA_L3MDEV]) {
193 rule->ce_mask |= RULE_ATTR_L3MDEV;
196 if (tb[FRA_PROTOCOL]) {
197 rule->r_protocol =
nla_get_u8(tb[FRA_PROTOCOL]);
198 rule->ce_mask |= RULE_ATTR_PROTOCOL;
201 if (tb[FRA_IP_PROTO]) {
202 rule->r_ip_proto =
nla_get_u8(tb[FRA_IP_PROTO]);
203 rule->ce_mask |= RULE_ATTR_IP_PROTO;
206 if (tb[FRA_SPORT_RANGE]) {
207 struct fib_rule_port_range *pr;
211 rule->ce_mask |= RULE_ATTR_SPORT;
214 if (tb[FRA_DPORT_RANGE]) {
215 struct fib_rule_port_range *pr;
219 rule->ce_mask |= RULE_ATTR_DPORT;
222 err = pp->pp_cb((
struct nl_object *) rule, pp);
232 static int rule_request_update(
struct nl_cache *c,
struct nl_sock *h)
237 static void rule_dump_line(
struct nl_object *o,
struct nl_dump_params *p)
239 struct rtnl_rule *r = (
struct rtnl_rule *) o;
242 nl_dump_line(p,
"%8d ", (r->ce_mask & RULE_ATTR_PRIO) ? r->r_prio : 0);
243 nl_dump(p,
"%s ", nl_af2str(r->r_family, buf,
sizeof(buf)));
245 if (r->ce_mask & RULE_ATTR_SRC)
249 if (r->ce_mask & RULE_ATTR_DST)
253 if (r->ce_mask & RULE_ATTR_DSFIELD)
254 nl_dump(p,
"tos %u ", r->r_dsfield);
256 if (r->ce_mask & (RULE_ATTR_MARK | RULE_ATTR_MASK))
257 nl_dump(p,
"mark %#x/%#x", r->r_mark, r->r_mask);
259 if (r->ce_mask & RULE_ATTR_IIFNAME)
260 nl_dump(p,
"iif %s ", r->r_iifname);
262 if (r->ce_mask & RULE_ATTR_OIFNAME)
263 nl_dump(p,
"oif %s ", r->r_oifname);
265 if (r->ce_mask & RULE_ATTR_TABLE)
267 rtnl_route_table2str(r->r_table, buf,
sizeof(buf)));
269 if (r->ce_mask & RULE_ATTR_L3MDEV)
270 nl_dump(p,
"lookup [l3mdev-table] ");
272 if (r->ce_mask & RULE_ATTR_IP_PROTO)
274 nl_ip_proto2str(r->r_ip_proto, buf,
sizeof(buf)));
276 if (r->ce_mask & RULE_ATTR_SPORT) {
277 if (r->r_sport.start == r->r_sport.end)
278 nl_dump(p,
"sport %u ", r->r_sport.start);
281 r->r_sport.start, r->r_sport.end);
284 if (r->ce_mask & RULE_ATTR_DPORT) {
285 if (r->r_dport.start == r->r_dport.end)
286 nl_dump(p,
"dport %u ", r->r_dport.start);
289 r->r_dport.start, r->r_dport.end);
292 if (r->ce_mask & RULE_ATTR_PROTOCOL)
294 rtnl_route_proto2str(r->r_protocol, buf,
sizeof(buf)));
296 if (r->ce_mask & RULE_ATTR_FLOW)
298 rtnl_realms2str(r->r_flow, buf,
sizeof(buf)));
300 if (r->ce_mask & RULE_ATTR_GOTO)
301 nl_dump(p,
"goto %u ", r->r_goto);
303 if (r->ce_mask & RULE_ATTR_ACTION)
305 nl_rtntype2str(r->r_action, buf,
sizeof(buf)));
310 static void rule_dump_details(
struct nl_object *obj,
struct nl_dump_params *p)
312 rule_dump_line(obj, p);
315 static void rule_dump_stats(
struct nl_object *obj,
struct nl_dump_params *p)
317 rule_dump_details(obj, p);
320 static uint64_t rule_compare(
struct nl_object *_a,
struct nl_object *_b,
321 uint64_t attrs,
int flags)
323 struct rtnl_rule *a = (
struct rtnl_rule *) _a;
324 struct rtnl_rule *b = (
struct rtnl_rule *) _b;
327 #define RULE_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, RULE_ATTR_##ATTR, a, b, EXPR) 329 diff |= RULE_DIFF(FAMILY, a->r_family != b->r_family);
330 diff |= RULE_DIFF(TABLE, a->r_table != b->r_table);
331 diff |= RULE_DIFF(ACTION, a->r_action != b->r_action);
332 diff |= RULE_DIFF(IIFNAME, strcmp(a->r_iifname, b->r_iifname));
333 diff |= RULE_DIFF(OIFNAME, strcmp(a->r_oifname, b->r_oifname));
334 diff |= RULE_DIFF(PRIO, a->r_prio != b->r_prio);
335 diff |= RULE_DIFF(MARK, a->r_mark != b->r_mark);
336 diff |= RULE_DIFF(MASK, a->r_mask != b->r_mask);
337 diff |= RULE_DIFF(GOTO, a->r_goto != b->r_goto);
338 diff |= RULE_DIFF(SRC,
nl_addr_cmp(a->r_src, b->r_src));
339 diff |= RULE_DIFF(DST,
nl_addr_cmp(a->r_dst, b->r_dst));
340 diff |= RULE_DIFF(DSFIELD, a->r_dsfield != b->r_dsfield);
341 diff |= RULE_DIFF(FLOW, a->r_flow != b->r_flow);
348 static const struct trans_tbl rule_attrs[] = {
349 __ADD(RULE_ATTR_FAMILY, family),
350 __ADD(RULE_ATTR_TABLE, table),
351 __ADD(RULE_ATTR_ACTION, action),
352 __ADD(RULE_ATTR_IIFNAME, iifname),
353 __ADD(RULE_ATTR_OIFNAME, oifname),
354 __ADD(RULE_ATTR_PRIO, prio),
355 __ADD(RULE_ATTR_MARK, mark),
356 __ADD(RULE_ATTR_MASK, mask),
357 __ADD(RULE_ATTR_GOTO,
goto),
358 __ADD(RULE_ATTR_SRC, src),
359 __ADD(RULE_ATTR_DST, dst),
360 __ADD(RULE_ATTR_DSFIELD, dsfield),
361 __ADD(RULE_ATTR_FLOW, flow),
364 static char *rule_attrs2str(
int attrs,
char *buf,
size_t len)
366 return __flags2str(attrs, buf, len, rule_attrs,
367 ARRAY_SIZE(rule_attrs));
375 struct rtnl_rule *rtnl_rule_alloc(
void)
380 void rtnl_rule_put(
struct rtnl_rule *rule)
404 struct nl_cache **result)
406 struct nl_cache * cache;
412 cache->c_iarg1 = family;
430 static int build_rule_msg(
struct rtnl_rule *tmpl,
int cmd,
int flags,
431 struct nl_msg **result)
434 struct fib_rule_hdr frh = {
435 .family = tmpl->r_family,
436 .table = tmpl->r_table,
437 .action = tmpl->r_action,
438 .flags = tmpl->r_flags,
439 .tos = tmpl->r_dsfield,
442 if (!(tmpl->ce_mask & RULE_ATTR_FAMILY))
443 return -NLE_MISSING_ATTR;
449 if (tmpl->ce_mask & RULE_ATTR_SRC)
452 if (tmpl->ce_mask & RULE_ATTR_DST)
455 if (
nlmsg_append(msg, &frh,
sizeof(frh), NLMSG_ALIGNTO) < 0)
456 goto nla_put_failure;
462 if (tmpl->ce_mask & RULE_ATTR_SRC)
465 if (tmpl->ce_mask & RULE_ATTR_DST)
468 if (tmpl->ce_mask & RULE_ATTR_IIFNAME)
471 if (tmpl->ce_mask & RULE_ATTR_OIFNAME)
474 if (tmpl->ce_mask & RULE_ATTR_PRIO)
477 if (tmpl->ce_mask & RULE_ATTR_MARK)
480 if (tmpl->ce_mask & RULE_ATTR_MASK)
483 if (tmpl->ce_mask & RULE_ATTR_GOTO)
486 if (tmpl->ce_mask & RULE_ATTR_FLOW)
489 if (tmpl->ce_mask & RULE_ATTR_L3MDEV)
492 if (tmpl->ce_mask & RULE_ATTR_IP_PROTO)
493 NLA_PUT_U8(msg, FRA_IP_PROTO, tmpl->r_ip_proto);
495 if (tmpl->ce_mask & RULE_ATTR_SPORT)
496 NLA_PUT(msg, FRA_SPORT_RANGE,
sizeof(tmpl->r_sport),
499 if (tmpl->ce_mask & RULE_ATTR_DPORT)
500 NLA_PUT(msg, FRA_DPORT_RANGE,
sizeof(tmpl->r_dport),
503 if (tmpl->ce_mask & RULE_ATTR_PROTOCOL)
504 NLA_PUT_U8(msg, FRA_PROTOCOL, tmpl->r_protocol);
529 struct nl_msg **result)
531 return build_rule_msg(tmpl, RTM_NEWRULE, NLM_F_CREATE | flags,
560 return wait_for_ack(sk);
585 struct nl_msg **result)
587 return build_rule_msg(rule, RTM_DELRULE, flags, result);
615 return wait_for_ack(sk);
625 void rtnl_rule_set_family(
struct rtnl_rule *rule,
int family)
627 rule->r_family = family;
628 rule->ce_mask |= RULE_ATTR_FAMILY;
631 int rtnl_rule_get_family(
struct rtnl_rule *rule)
633 if (rule->ce_mask & RULE_ATTR_FAMILY)
634 return rule->r_family;
639 void rtnl_rule_set_prio(
struct rtnl_rule *rule, uint32_t prio)
642 rule->ce_mask |= RULE_ATTR_PRIO;
645 uint32_t rtnl_rule_get_prio(
struct rtnl_rule *rule)
650 void rtnl_rule_set_mark(
struct rtnl_rule *rule, uint32_t mark)
653 rule->ce_mask |= RULE_ATTR_MARK;
656 uint32_t rtnl_rule_get_mark(
struct rtnl_rule *rule)
661 void rtnl_rule_set_mask(
struct rtnl_rule *rule, uint32_t mask)
664 rule->ce_mask |= RULE_ATTR_MASK;
667 uint32_t rtnl_rule_get_mask(
struct rtnl_rule *rule)
672 void rtnl_rule_set_table(
struct rtnl_rule *rule, uint32_t table)
674 rule->r_table = table;
675 rule->ce_mask |= RULE_ATTR_TABLE;
678 uint32_t rtnl_rule_get_table(
struct rtnl_rule *rule)
680 return rule->r_table;
683 void rtnl_rule_set_dsfield(
struct rtnl_rule *rule, uint8_t dsfield)
685 rule->r_dsfield = dsfield;
686 rule->ce_mask |= RULE_ATTR_DSFIELD;
689 uint8_t rtnl_rule_get_dsfield(
struct rtnl_rule *rule)
691 return rule->r_dsfield;
694 static inline int __assign_addr(
struct rtnl_rule *rule,
struct nl_addr **pos,
695 struct nl_addr *
new,
int flag)
697 if (rule->ce_mask & RULE_ATTR_FAMILY) {
698 if (new->a_family != rule->r_family)
699 return -NLE_AF_MISMATCH;
701 rule->r_family =
new->a_family;
709 rule->ce_mask |= (flag | RULE_ATTR_FAMILY);
714 int rtnl_rule_set_src(
struct rtnl_rule *rule,
struct nl_addr *src)
716 return __assign_addr(rule, &rule->r_src, src, RULE_ATTR_SRC);
719 struct nl_addr *rtnl_rule_get_src(
struct rtnl_rule *rule)
724 int rtnl_rule_set_dst(
struct rtnl_rule *rule,
struct nl_addr *dst)
726 return __assign_addr(rule, &rule->r_dst, dst, RULE_ATTR_DST);
729 struct nl_addr *rtnl_rule_get_dst(
struct rtnl_rule *rule)
734 int rtnl_rule_set_iif(
struct rtnl_rule *rule,
const char *dev)
736 if (strlen(dev) > IFNAMSIZ-1)
739 strcpy(rule->r_iifname, dev);
740 rule->ce_mask |= RULE_ATTR_IIFNAME;
744 char *rtnl_rule_get_iif(
struct rtnl_rule *rule)
746 if (rule->ce_mask & RULE_ATTR_IIFNAME)
747 return rule->r_iifname;
752 int rtnl_rule_set_oif(
struct rtnl_rule *rule,
const char *dev)
754 if (strlen(dev) > IFNAMSIZ-1)
757 strcpy(rule->r_oifname, dev);
758 rule->ce_mask |= RULE_ATTR_OIFNAME;
762 char *rtnl_rule_get_oif(
struct rtnl_rule *rule)
764 if (rule->ce_mask & RULE_ATTR_OIFNAME)
765 return rule->r_oifname;
770 void rtnl_rule_set_action(
struct rtnl_rule *rule, uint8_t action)
772 rule->r_action = action;
773 rule->ce_mask |= RULE_ATTR_ACTION;
776 uint8_t rtnl_rule_get_action(
struct rtnl_rule *rule)
778 return rule->r_action;
793 rule->r_l3mdev = (uint8_t) value;
794 rule->ce_mask |= RULE_ATTR_L3MDEV;
797 rule->ce_mask &= ~((uint32_t) RULE_ATTR_L3MDEV);
814 if (!(rule->ce_mask & RULE_ATTR_L3MDEV))
815 return -NLE_MISSING_ATTR;
816 return rule->r_l3mdev;
819 int rtnl_rule_set_protocol(
struct rtnl_rule *rule, uint8_t protocol)
822 rule->r_protocol = protocol;
823 rule->ce_mask |= RULE_ATTR_PROTOCOL;
825 rule->r_protocol = 0;
826 rule->ce_mask &= ~((uint32_t) RULE_ATTR_PROTOCOL);
831 int rtnl_rule_get_protocol(
struct rtnl_rule *rule, uint8_t *protocol)
833 if (!(rule->ce_mask & RULE_ATTR_PROTOCOL))
836 *protocol = rule->r_protocol;
840 int rtnl_rule_set_ipproto(
struct rtnl_rule *rule, uint8_t ip_proto)
843 rule->r_ip_proto = ip_proto;
844 rule->ce_mask |= RULE_ATTR_IP_PROTO;
846 rule->r_ip_proto = 0;
847 rule->ce_mask &= ~((uint32_t) RULE_ATTR_IP_PROTO);
852 int rtnl_rule_get_ipproto(
struct rtnl_rule *rule, uint8_t *ip_proto)
854 if (!(rule->ce_mask & RULE_ATTR_IP_PROTO))
857 *ip_proto = rule->r_ip_proto;
861 static int __rtnl_rule_set_port(
struct fib_rule_port_range *prange,
862 uint16_t start, uint16_t end,
863 uint64_t attr, uint64_t *mask)
865 if ((start && end < start) || (end && !start))
869 prange->start = start;
881 int rtnl_rule_set_sport(
struct rtnl_rule *rule, uint16_t sport)
883 return __rtnl_rule_set_port(&rule->r_sport, sport, sport,
884 RULE_ATTR_SPORT, &rule->ce_mask);
887 int rtnl_rule_set_sport_range(
struct rtnl_rule *rule, uint16_t start,
890 return __rtnl_rule_set_port(&rule->r_sport, start, end,
891 RULE_ATTR_SPORT, &rule->ce_mask);
894 int rtnl_rule_get_sport(
struct rtnl_rule *rule, uint16_t *start, uint16_t *end)
896 if (!(rule->ce_mask & RULE_ATTR_SPORT))
899 *start = rule->r_sport.start;
900 *end = rule->r_sport.end;
904 int rtnl_rule_set_dport(
struct rtnl_rule *rule, uint16_t dport)
906 return __rtnl_rule_set_port(&rule->r_dport, dport, dport,
907 RULE_ATTR_DPORT, &rule->ce_mask);
910 int rtnl_rule_set_dport_range(
struct rtnl_rule *rule, uint16_t start,
913 return __rtnl_rule_set_port(&rule->r_dport, start, end,
914 RULE_ATTR_DPORT, &rule->ce_mask);
917 int rtnl_rule_get_dport(
struct rtnl_rule *rule, uint16_t *start, uint16_t *end)
919 if (!(rule->ce_mask & RULE_ATTR_DPORT))
922 *start = rule->r_dport.start;
923 *end = rule->r_dport.end;
927 void rtnl_rule_set_realms(
struct rtnl_rule *rule, uint32_t realms)
929 rule->r_flow = realms;
930 rule->ce_mask |= RULE_ATTR_FLOW;
933 uint32_t rtnl_rule_get_realms(
struct rtnl_rule *rule)
938 void rtnl_rule_set_goto(
struct rtnl_rule *rule, uint32_t ref)
941 rule->ce_mask |= RULE_ATTR_GOTO;
944 uint32_t rtnl_rule_get_goto(
struct rtnl_rule *rule)
951 static struct nl_object_ops rule_obj_ops = {
952 .oo_name =
"route/rule",
953 .oo_size =
sizeof(
struct rtnl_rule),
954 .oo_free_data = rule_free_data,
955 .oo_clone = rule_clone,
961 .oo_compare = rule_compare,
962 .oo_attrs2str = rule_attrs2str,
966 static struct nl_af_group rule_groups[] = {
967 { AF_INET, RTNLGRP_IPV4_RULE },
968 { AF_INET6, RTNLGRP_IPV6_RULE },
969 { END_OF_GROUP_LIST },
972 static struct nl_cache_ops rtnl_rule_ops = {
973 .co_name =
"route/rule",
974 .co_hdrsize =
sizeof(
struct fib_rule_hdr),
976 { RTM_NEWRULE, NL_ACT_NEW,
"new" },
977 { RTM_DELRULE, NL_ACT_DEL,
"del" },
978 { RTM_GETRULE, NL_ACT_GET,
"get" },
979 END_OF_MSGTYPES_LIST,
981 .co_protocol = NETLINK_ROUTE,
982 .co_request_update = rule_request_update,
983 .co_msg_parser = rule_msg_parser,
984 .co_obj_ops = &rule_obj_ops,
985 .co_groups = rule_groups,
988 static void __init rule_init(
void)
993 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 nlmsg_parse(struct nlmsghdr *nlh, int hdrlen, struct nlattr *tb[], int maxtype, const struct nla_policy *policy)
parse attributes of a 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)
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(msg, attrtype, attrlen, data)
Add unspecific attribute to netlink message.
void * nla_data(const struct nlattr *nla)
Return pointer to the payload section.
#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.