13#include "nl-default.h"
15#include <linux/fib_rules.h>
17#include <netlink/netlink.h>
18#include <netlink/utils.h>
19#include <netlink/route/rtnl.h>
20#include <netlink/route/rule.h>
23#include "nl-priv-dynamic-core/nl-core.h"
24#include "nl-priv-dynamic-core/cache-api.h"
42 struct nl_addr *r_src;
43 struct nl_addr *r_dst;
44 char r_iifname[IFNAMSIZ];
45 char r_oifname[IFNAMSIZ];
47 struct fib_rule_port_range r_sport;
48 struct fib_rule_port_range r_dport;
51#define RULE_ATTR_FAMILY 0x000001
52#define RULE_ATTR_TABLE 0x000002
53#define RULE_ATTR_ACTION 0x000004
54#define RULE_ATTR_FLAGS 0x000008
55#define RULE_ATTR_IIFNAME 0x000010
56#define RULE_ATTR_OIFNAME 0x000020
57#define RULE_ATTR_PRIO 0x000040
58#define RULE_ATTR_MARK 0x000080
59#define RULE_ATTR_MASK 0x000100
60#define RULE_ATTR_GOTO 0x000200
61#define RULE_ATTR_SRC 0x000400
62#define RULE_ATTR_DST 0x000800
63#define RULE_ATTR_DSFIELD 0x001000
64#define RULE_ATTR_FLOW 0x002000
65#define RULE_ATTR_L3MDEV 0x004000
66#define RULE_ATTR_PROTOCOL 0x008000
67#define RULE_ATTR_IP_PROTO 0x010000
68#define RULE_ATTR_SPORT 0x020000
69#define RULE_ATTR_DPORT 0x040000
71static struct nl_cache_ops rtnl_rule_ops;
72static struct nl_object_ops rule_obj_ops;
75static void rule_free_data(
struct nl_object *c)
77 struct rtnl_rule *rule = nl_object_priv(c);
86static int rule_clone(
struct nl_object *_dst,
struct nl_object *_src)
88 struct rtnl_rule *dst = nl_object_priv(_dst);
89 struct rtnl_rule *src = nl_object_priv(_src);
105static struct nla_policy rule_policy[FRA_MAX+1] = {
107 [FRA_IIFNAME] = { .type =
NLA_STRING, .maxlen = IFNAMSIZ },
108 [FRA_OIFNAME] = { .type =
NLA_STRING, .maxlen = IFNAMSIZ },
109 [FRA_PRIORITY] = { .type =
NLA_U32 },
110 [FRA_FWMARK] = { .type =
NLA_U32 },
111 [FRA_FWMASK] = { .type =
NLA_U32 },
112 [FRA_GOTO] = { .type =
NLA_U32 },
113 [FRA_FLOW] = { .type =
NLA_U32 },
114 [FRA_L3MDEV] = { .type =
NLA_U8 },
115 [FRA_PROTOCOL] = { .type =
NLA_U8 },
116 [FRA_IP_PROTO] = { .type =
NLA_U8 },
117 [FRA_SPORT_RANGE] = { .minlen =
sizeof(
struct fib_rule_port_range),
118 .maxlen =
sizeof(
struct fib_rule_port_range) },
119 [FRA_DPORT_RANGE] = { .minlen =
sizeof(
struct fib_rule_port_range),
120 .maxlen =
sizeof(
struct fib_rule_port_range) },
123static int rule_msg_parser(
struct nl_cache_ops *ops,
struct sockaddr_nl *who,
124 struct nlmsghdr *n,
struct nl_parser_param *pp)
126 struct rtnl_rule *rule;
127 struct fib_rule_hdr *frh;
128 struct nlattr *tb[FRA_MAX+1];
131 rule = rtnl_rule_alloc();
137 rule->ce_msgtype = n->nlmsg_type;
140 err =
nlmsg_parse(n,
sizeof(*frh), tb, FRA_MAX, rule_policy);
144 rule->r_family = family = frh->family;
145 rule->r_table = frh->table;
146 rule->r_action = frh->action;
147 rule->r_flags = frh->flags;
149 rule->ce_mask = (RULE_ATTR_FAMILY | RULE_ATTR_ACTION | RULE_ATTR_FLAGS);
151 rule->ce_mask |= RULE_ATTR_TABLE;
155 rule->r_dsfield = frh->tos;
156 rule->ce_mask |= RULE_ATTR_DSFIELD;
162 rule->ce_mask |= RULE_ATTR_TABLE;
165 if (tb[FRA_IIFNAME]) {
166 nla_strlcpy(rule->r_iifname, tb[FRA_IIFNAME], IFNAMSIZ);
167 rule->ce_mask |= RULE_ATTR_IIFNAME;
170 if (tb[FRA_OIFNAME]) {
171 nla_strlcpy(rule->r_oifname, tb[FRA_OIFNAME], IFNAMSIZ);
172 rule->ce_mask |= RULE_ATTR_OIFNAME;
175 if (tb[FRA_PRIORITY]) {
177 rule->ce_mask |= RULE_ATTR_PRIO;
180 if (tb[FRA_FWMARK]) {
182 rule->ce_mask |= RULE_ATTR_MARK;
185 if (tb[FRA_FWMASK]) {
187 rule->ce_mask |= RULE_ATTR_MASK;
192 rule->ce_mask |= RULE_ATTR_GOTO;
200 rule->ce_mask |= RULE_ATTR_SRC;
207 rule->ce_mask |= RULE_ATTR_DST;
213 rule->ce_mask |= RULE_ATTR_FLOW;
216 if (tb[FRA_L3MDEV]) {
218 rule->ce_mask |= RULE_ATTR_L3MDEV;
221 if (tb[FRA_PROTOCOL]) {
222 rule->r_protocol =
nla_get_u8(tb[FRA_PROTOCOL]);
223 rule->ce_mask |= RULE_ATTR_PROTOCOL;
226 if (tb[FRA_IP_PROTO]) {
227 rule->r_ip_proto =
nla_get_u8(tb[FRA_IP_PROTO]);
228 rule->ce_mask |= RULE_ATTR_IP_PROTO;
231 if (tb[FRA_SPORT_RANGE]) {
232 struct fib_rule_port_range *pr;
236 rule->ce_mask |= RULE_ATTR_SPORT;
239 if (tb[FRA_DPORT_RANGE]) {
240 struct fib_rule_port_range *pr;
244 rule->ce_mask |= RULE_ATTR_DPORT;
247 err = pp->pp_cb((
struct nl_object *) rule, pp);
257static int rule_request_update(
struct nl_cache *c,
struct nl_sock *h)
262static void rule_dump_line(
struct nl_object *o,
struct nl_dump_params *p)
264 struct rtnl_rule *r = (
struct rtnl_rule *) o;
267 nl_dump_line(p,
"%8d ", (r->ce_mask & RULE_ATTR_PRIO) ? r->r_prio : 0);
268 nl_dump(p,
"%s ", nl_af2str(r->r_family, buf,
sizeof(buf)));
270 if (r->ce_mask & RULE_ATTR_SRC)
274 if (r->ce_mask & RULE_ATTR_DST)
278 if (r->ce_mask & RULE_ATTR_DSFIELD)
279 nl_dump(p,
"tos %u ", r->r_dsfield);
281 if (r->ce_mask & (RULE_ATTR_MARK | RULE_ATTR_MASK))
282 nl_dump(p,
"mark %#x/%#x", r->r_mark, r->r_mask);
284 if (r->ce_mask & RULE_ATTR_IIFNAME)
285 nl_dump(p,
"iif %s ", r->r_iifname);
287 if (r->ce_mask & RULE_ATTR_OIFNAME)
288 nl_dump(p,
"oif %s ", r->r_oifname);
290 if (r->ce_mask & RULE_ATTR_TABLE)
292 rtnl_route_table2str(r->r_table, buf,
sizeof(buf)));
294 if (r->ce_mask & RULE_ATTR_L3MDEV)
295 nl_dump(p,
"lookup [l3mdev-table] ");
297 if (r->ce_mask & RULE_ATTR_IP_PROTO)
299 nl_ip_proto2str(r->r_ip_proto, buf,
sizeof(buf)));
301 if (r->ce_mask & RULE_ATTR_SPORT) {
302 if (r->r_sport.start == r->r_sport.end)
303 nl_dump(p,
"sport %u ", r->r_sport.start);
306 r->r_sport.start, r->r_sport.end);
309 if (r->ce_mask & RULE_ATTR_DPORT) {
310 if (r->r_dport.start == r->r_dport.end)
311 nl_dump(p,
"dport %u ", r->r_dport.start);
314 r->r_dport.start, r->r_dport.end);
317 if (r->ce_mask & RULE_ATTR_PROTOCOL)
319 rtnl_route_proto2str(r->r_protocol, buf,
sizeof(buf)));
321 if (r->ce_mask & RULE_ATTR_FLOW)
323 rtnl_realms2str(r->r_flow, buf,
sizeof(buf)));
325 if (r->ce_mask & RULE_ATTR_GOTO)
326 nl_dump(p,
"goto %u ", r->r_goto);
328 if (r->ce_mask & RULE_ATTR_ACTION)
330 nl_rtntype2str(r->r_action, buf,
sizeof(buf)));
335static void rule_dump_details(
struct nl_object *obj,
struct nl_dump_params *p)
337 rule_dump_line(obj, p);
340static void rule_dump_stats(
struct nl_object *obj,
struct nl_dump_params *p)
342 rule_dump_details(obj, p);
345static uint64_t rule_compare(
struct nl_object *_a,
struct nl_object *_b,
346 uint64_t attrs,
int flags)
348 struct rtnl_rule *a = (
struct rtnl_rule *) _a;
349 struct rtnl_rule *b = (
struct rtnl_rule *) _b;
352#define _DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ATTR, a, b, EXPR)
353 diff |= _DIFF(RULE_ATTR_FAMILY, a->r_family != b->r_family);
354 diff |= _DIFF(RULE_ATTR_TABLE, a->r_table != b->r_table);
355 diff |= _DIFF(RULE_ATTR_ACTION, a->r_action != b->r_action);
356 diff |= _DIFF(RULE_ATTR_IIFNAME, strcmp(a->r_iifname, b->r_iifname));
357 diff |= _DIFF(RULE_ATTR_OIFNAME, strcmp(a->r_oifname, b->r_oifname));
358 diff |= _DIFF(RULE_ATTR_PRIO, a->r_prio != b->r_prio);
359 diff |= _DIFF(RULE_ATTR_MARK, a->r_mark != b->r_mark);
360 diff |= _DIFF(RULE_ATTR_MASK, a->r_mask != b->r_mask);
361 diff |= _DIFF(RULE_ATTR_GOTO, a->r_goto != b->r_goto);
362 diff |= _DIFF(RULE_ATTR_SRC,
nl_addr_cmp(a->r_src, b->r_src));
363 diff |= _DIFF(RULE_ATTR_DST,
nl_addr_cmp(a->r_dst, b->r_dst));
364 diff |= _DIFF(RULE_ATTR_DSFIELD, a->r_dsfield != b->r_dsfield);
365 diff |= _DIFF(RULE_ATTR_FLOW, a->r_flow != b->r_flow);
371static const struct trans_tbl rule_attrs[] = {
372 __ADD(RULE_ATTR_FAMILY, family),
373 __ADD(RULE_ATTR_TABLE, table),
374 __ADD(RULE_ATTR_ACTION, action),
375 __ADD(RULE_ATTR_IIFNAME, iifname),
376 __ADD(RULE_ATTR_OIFNAME, oifname),
377 __ADD(RULE_ATTR_PRIO, prio),
378 __ADD(RULE_ATTR_MARK, mark),
379 __ADD(RULE_ATTR_MASK, mask),
380 __ADD(RULE_ATTR_GOTO,
goto),
381 __ADD(RULE_ATTR_SRC, src),
382 __ADD(RULE_ATTR_DST, dst),
383 __ADD(RULE_ATTR_DSFIELD, dsfield),
384 __ADD(RULE_ATTR_FLOW, flow),
387static char *rule_attrs2str(
int attrs,
char *buf,
size_t len)
389 return __flags2str(attrs, buf, len, rule_attrs,
390 ARRAY_SIZE(rule_attrs));
398struct rtnl_rule *rtnl_rule_alloc(
void)
403void rtnl_rule_put(
struct rtnl_rule *rule)
427 struct nl_cache **result)
429 struct nl_cache * cache;
435 cache->c_iarg1 = family;
453static int build_rule_msg(
struct rtnl_rule *tmpl,
int cmd,
int flags,
454 struct nl_msg **result)
457 struct fib_rule_hdr frh = {
458 .family = tmpl->r_family,
459 .table = tmpl->r_table,
460 .action = tmpl->r_action,
461 .flags = tmpl->r_flags,
462 .tos = tmpl->r_dsfield,
465 if (!(tmpl->ce_mask & RULE_ATTR_FAMILY))
466 return -NLE_MISSING_ATTR;
472 if (tmpl->ce_mask & RULE_ATTR_SRC)
475 if (tmpl->ce_mask & RULE_ATTR_DST)
478 if (
nlmsg_append(msg, &frh,
sizeof(frh), NLMSG_ALIGNTO) < 0)
479 goto nla_put_failure;
485 if (tmpl->ce_mask & RULE_ATTR_SRC)
488 if (tmpl->ce_mask & RULE_ATTR_DST)
491 if (tmpl->ce_mask & RULE_ATTR_IIFNAME)
494 if (tmpl->ce_mask & RULE_ATTR_OIFNAME)
497 if (tmpl->ce_mask & RULE_ATTR_PRIO)
500 if (tmpl->ce_mask & RULE_ATTR_MARK)
503 if (tmpl->ce_mask & RULE_ATTR_MASK)
506 if (tmpl->ce_mask & RULE_ATTR_GOTO)
509 if (tmpl->ce_mask & RULE_ATTR_FLOW)
512 if (tmpl->ce_mask & RULE_ATTR_L3MDEV)
515 if (tmpl->ce_mask & RULE_ATTR_IP_PROTO)
516 NLA_PUT_U8(msg, FRA_IP_PROTO, tmpl->r_ip_proto);
518 if (tmpl->ce_mask & RULE_ATTR_SPORT)
519 NLA_PUT(msg, FRA_SPORT_RANGE,
sizeof(tmpl->r_sport),
522 if (tmpl->ce_mask & RULE_ATTR_DPORT)
523 NLA_PUT(msg, FRA_DPORT_RANGE,
sizeof(tmpl->r_dport),
526 if (tmpl->ce_mask & RULE_ATTR_PROTOCOL)
527 NLA_PUT_U8(msg, FRA_PROTOCOL, tmpl->r_protocol);
552 struct nl_msg **result)
554 return build_rule_msg(tmpl, RTM_NEWRULE, NLM_F_CREATE | flags,
583 return wait_for_ack(sk);
608 struct nl_msg **result)
610 return build_rule_msg(rule, RTM_DELRULE, flags, result);
638 return wait_for_ack(sk);
648void rtnl_rule_set_family(
struct rtnl_rule *rule,
int family)
650 rule->r_family = family;
651 rule->ce_mask |= RULE_ATTR_FAMILY;
654int rtnl_rule_get_family(
struct rtnl_rule *rule)
656 if (rule->ce_mask & RULE_ATTR_FAMILY)
657 return rule->r_family;
662void rtnl_rule_set_prio(
struct rtnl_rule *rule, uint32_t prio)
665 rule->ce_mask |= RULE_ATTR_PRIO;
668uint32_t rtnl_rule_get_prio(
struct rtnl_rule *rule)
673void rtnl_rule_set_mark(
struct rtnl_rule *rule, uint32_t mark)
676 rule->ce_mask |= RULE_ATTR_MARK;
679uint32_t rtnl_rule_get_mark(
struct rtnl_rule *rule)
684void rtnl_rule_set_mask(
struct rtnl_rule *rule, uint32_t mask)
687 rule->ce_mask |= RULE_ATTR_MASK;
690uint32_t rtnl_rule_get_mask(
struct rtnl_rule *rule)
695void rtnl_rule_set_table(
struct rtnl_rule *rule, uint32_t table)
697 rule->r_table = table;
698 rule->ce_mask |= RULE_ATTR_TABLE;
701uint32_t rtnl_rule_get_table(
struct rtnl_rule *rule)
703 return rule->r_table;
706void rtnl_rule_set_dsfield(
struct rtnl_rule *rule, uint8_t dsfield)
708 rule->r_dsfield = dsfield;
709 rule->ce_mask |= RULE_ATTR_DSFIELD;
712uint8_t rtnl_rule_get_dsfield(
struct rtnl_rule *rule)
714 return rule->r_dsfield;
717static inline int __assign_addr(
struct rtnl_rule *rule,
struct nl_addr **pos,
718 struct nl_addr *
new,
int flag)
720 if (rule->ce_mask & RULE_ATTR_FAMILY) {
721 if (new->a_family != rule->r_family)
722 return -NLE_AF_MISMATCH;
724 rule->r_family =
new->a_family;
732 rule->ce_mask |= (flag | RULE_ATTR_FAMILY);
737int rtnl_rule_set_src(
struct rtnl_rule *rule,
struct nl_addr *src)
739 return __assign_addr(rule, &rule->r_src, src, RULE_ATTR_SRC);
742struct nl_addr *rtnl_rule_get_src(
struct rtnl_rule *rule)
747int rtnl_rule_set_dst(
struct rtnl_rule *rule,
struct nl_addr *dst)
749 return __assign_addr(rule, &rule->r_dst, dst, RULE_ATTR_DST);
752struct nl_addr *rtnl_rule_get_dst(
struct rtnl_rule *rule)
757int rtnl_rule_set_iif(
struct rtnl_rule *rule,
const char *dev)
759 if (strlen(dev) > IFNAMSIZ-1)
762 strcpy(rule->r_iifname, dev);
763 rule->ce_mask |= RULE_ATTR_IIFNAME;
767char *rtnl_rule_get_iif(
struct rtnl_rule *rule)
769 if (rule->ce_mask & RULE_ATTR_IIFNAME)
770 return rule->r_iifname;
775int rtnl_rule_set_oif(
struct rtnl_rule *rule,
const char *dev)
777 if (strlen(dev) > IFNAMSIZ-1)
780 strcpy(rule->r_oifname, dev);
781 rule->ce_mask |= RULE_ATTR_OIFNAME;
785char *rtnl_rule_get_oif(
struct rtnl_rule *rule)
787 if (rule->ce_mask & RULE_ATTR_OIFNAME)
788 return rule->r_oifname;
793void rtnl_rule_set_action(
struct rtnl_rule *rule, uint8_t action)
795 rule->r_action = action;
796 rule->ce_mask |= RULE_ATTR_ACTION;
799uint8_t rtnl_rule_get_action(
struct rtnl_rule *rule)
801 return rule->r_action;
816 rule->r_l3mdev = (uint8_t) value;
817 rule->ce_mask |= RULE_ATTR_L3MDEV;
820 rule->ce_mask &= ~((uint32_t) RULE_ATTR_L3MDEV);
837 if (!(rule->ce_mask & RULE_ATTR_L3MDEV))
838 return -NLE_MISSING_ATTR;
839 return rule->r_l3mdev;
842int rtnl_rule_set_protocol(
struct rtnl_rule *rule, uint8_t protocol)
845 rule->r_protocol = protocol;
846 rule->ce_mask |= RULE_ATTR_PROTOCOL;
848 rule->r_protocol = 0;
849 rule->ce_mask &= ~((uint32_t) RULE_ATTR_PROTOCOL);
854int rtnl_rule_get_protocol(
struct rtnl_rule *rule, uint8_t *protocol)
856 if (!(rule->ce_mask & RULE_ATTR_PROTOCOL))
859 *protocol = rule->r_protocol;
863int rtnl_rule_set_ipproto(
struct rtnl_rule *rule, uint8_t ip_proto)
866 rule->r_ip_proto = ip_proto;
867 rule->ce_mask |= RULE_ATTR_IP_PROTO;
869 rule->r_ip_proto = 0;
870 rule->ce_mask &= ~((uint32_t) RULE_ATTR_IP_PROTO);
875int rtnl_rule_get_ipproto(
struct rtnl_rule *rule, uint8_t *ip_proto)
877 if (!(rule->ce_mask & RULE_ATTR_IP_PROTO))
880 *ip_proto = rule->r_ip_proto;
884static int __rtnl_rule_set_port(
struct fib_rule_port_range *prange,
885 uint16_t start, uint16_t end,
886 uint64_t attr, uint64_t *mask)
888 if ((start && end < start) || (end && !start))
892 prange->start = start;
904int rtnl_rule_set_sport(
struct rtnl_rule *rule, uint16_t sport)
906 return __rtnl_rule_set_port(&rule->r_sport, sport, sport,
907 RULE_ATTR_SPORT, &rule->ce_mask);
910int rtnl_rule_set_sport_range(
struct rtnl_rule *rule, uint16_t start,
913 return __rtnl_rule_set_port(&rule->r_sport, start, end,
914 RULE_ATTR_SPORT, &rule->ce_mask);
917int rtnl_rule_get_sport(
struct rtnl_rule *rule, uint16_t *start, uint16_t *end)
919 if (!(rule->ce_mask & RULE_ATTR_SPORT))
922 *start = rule->r_sport.start;
923 *end = rule->r_sport.end;
927int rtnl_rule_set_dport(
struct rtnl_rule *rule, uint16_t dport)
929 return __rtnl_rule_set_port(&rule->r_dport, dport, dport,
930 RULE_ATTR_DPORT, &rule->ce_mask);
933int rtnl_rule_set_dport_range(
struct rtnl_rule *rule, uint16_t start,
936 return __rtnl_rule_set_port(&rule->r_dport, start, end,
937 RULE_ATTR_DPORT, &rule->ce_mask);
940int rtnl_rule_get_dport(
struct rtnl_rule *rule, uint16_t *start, uint16_t *end)
942 if (!(rule->ce_mask & RULE_ATTR_DPORT))
945 *start = rule->r_dport.start;
946 *end = rule->r_dport.end;
950void rtnl_rule_set_realms(
struct rtnl_rule *rule, uint32_t realms)
952 rule->r_flow = realms;
953 rule->ce_mask |= RULE_ATTR_FLOW;
956uint32_t rtnl_rule_get_realms(
struct rtnl_rule *rule)
961void rtnl_rule_set_goto(
struct rtnl_rule *rule, uint32_t ref)
964 rule->ce_mask |= RULE_ATTR_GOTO;
967uint32_t rtnl_rule_get_goto(
struct rtnl_rule *rule)
974static struct nl_object_ops rule_obj_ops = {
975 .oo_name =
"route/rule",
976 .oo_size =
sizeof(
struct rtnl_rule),
977 .oo_free_data = rule_free_data,
978 .oo_clone = rule_clone,
984 .oo_compare = rule_compare,
985 .oo_attrs2str = rule_attrs2str,
989static struct nl_af_group rule_groups[] = {
990 { AF_INET, RTNLGRP_IPV4_RULE },
991 { AF_INET6, RTNLGRP_IPV6_RULE },
992 { END_OF_GROUP_LIST },
995static struct nl_cache_ops rtnl_rule_ops = {
996 .co_name =
"route/rule",
997 .co_hdrsize =
sizeof(
struct fib_rule_hdr),
999 { RTM_NEWRULE, NL_ACT_NEW,
"new" },
1000 { RTM_DELRULE, NL_ACT_DEL,
"del" },
1001 { RTM_GETRULE, NL_ACT_GET,
"get" },
1002 END_OF_MSGTYPES_LIST,
1004 .co_protocol = NETLINK_ROUTE,
1005 .co_request_update = rule_request_update,
1006 .co_msg_parser = rule_msg_parser,
1007 .co_obj_ops = &rule_obj_ops,
1008 .co_groups = rule_groups,
1011static void _nl_init rule_init(
void)
1016static void _nl_exit rule_exit(
void)
void nl_addr_set_prefixlen(struct nl_addr *addr, int prefixlen)
Set the prefix length of an abstract address.
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.
int nl_addr_cmp(const struct nl_addr *a, const struct nl_addr *b)
Compare abstract addresses.
struct nl_addr * nl_addr_clone(const struct nl_addr *addr)
Clone existing abstract address object.
char * nl_addr2str(const struct nl_addr *addr, char *buf, size_t size)
Convert abstract address object to character string.
unsigned int nl_addr_get_prefixlen(const struct nl_addr *addr)
Return prefix length of abstract address object.
void nl_addr_put(struct nl_addr *addr)
Decrease the reference counter of an abstract address.
uint32_t nla_get_u32(const struct nlattr *nla)
Return payload of 32 bit integer attribute.
#define NLA_PUT_U8(msg, attrtype, value)
Add 8 bit integer attribute to netlink message.
#define NLA_PUT_ADDR(msg, attrtype, addr)
Add address attribute to netlink message.
void * nla_data(const struct nlattr *nla)
Return pointer to the payload section.
#define NLA_PUT(msg, attrtype, attrlen, data)
Add unspecific attribute to netlink message.
#define NLA_PUT_U32(msg, attrtype, value)
Add 32 bit integer attribute to netlink message.
uint8_t nla_get_u8(const struct nlattr *nla)
Return value of 8 bit integer attribute.
size_t nla_strlcpy(char *dst, const struct nlattr *nla, size_t dstsize)
Copy string attribute payload to a buffer.
#define NLA_PUT_STRING(msg, attrtype, value)
Add string attribute to netlink message.
@ NLA_STRING
NUL terminated character string.
int nl_cache_mngt_unregister(struct nl_cache_ops *ops)
Unregister a set of cache operations.
int nl_cache_mngt_register(struct nl_cache_ops *ops)
Register a set of cache operations.
int nl_cache_refill(struct nl_sock *sk, struct nl_cache *cache)
(Re)fill a cache with the contents in the kernel.
struct nl_cache * nl_cache_alloc(struct nl_cache_ops *ops)
Allocate new cache.
struct nl_msg * nlmsg_alloc_simple(int nlmsgtype, int flags)
Allocate a new netlink message.
void * nlmsg_data(const struct nlmsghdr *nlh)
Return pointer to message payload.
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 nlmsg_append(struct nl_msg *n, void *data, size_t len, int pad)
Append data to tail of a netlink message.
void nl_object_put(struct nl_object *obj)
Release a reference from an 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_rtgen_request(struct nl_sock *sk, int type, int family, int flags)
Send routing netlink request message.
int rtnl_rule_delete(struct nl_sock *sk, struct rtnl_rule *rule, int flags)
Delete a rule.
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.
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 rtnl_rule_get_l3mdev(struct rtnl_rule *rule)
Get l3mdev value of the rule (FRA_L3MDEV)
void rtnl_rule_set_l3mdev(struct rtnl_rule *rule, int value)
Set l3mdev value of the rule (FRA_L3MDEV)
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 rtnl_rule_add(struct nl_sock *sk, struct rtnl_rule *tmpl, int flags)
Add a new rule.
int nl_send_auto_complete(struct nl_sock *sk, struct nl_msg *msg)
void nl_dump(struct nl_dump_params *params, const char *fmt,...)
Dump a formatted character string.
@ NL_DUMP_STATS
Dump all attributes including statistics.
@ NL_DUMP_LINE
Dump object briefly on one line.
@ NL_DUMP_DETAILS
Dump all attributes but no statistics.
Attribute validation policy.
uint16_t type
Type of attribute or NLA_UNSPEC.