Loading...
1/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */
2
3/*
4 * NETLINK Netlink attributes
5 *
6 * Copyright (c) 2003-2013 Thomas Graf <tgraf@suug.ch>
7 */
8
9#ifndef __LIBBPF_NLATTR_H
10#define __LIBBPF_NLATTR_H
11
12#include <stdint.h>
13#include <string.h>
14#include <errno.h>
15#include <linux/netlink.h>
16#include <linux/rtnetlink.h>
17#include <linux/genetlink.h>
18
19/* avoid multiple definition of netlink features */
20#define __LINUX_NETLINK_H
21
22/**
23 * Standard attribute types to specify validation policy
24 */
25enum {
26 LIBBPF_NLA_UNSPEC, /**< Unspecified type, binary data chunk */
27 LIBBPF_NLA_U8, /**< 8 bit integer */
28 LIBBPF_NLA_U16, /**< 16 bit integer */
29 LIBBPF_NLA_U32, /**< 32 bit integer */
30 LIBBPF_NLA_U64, /**< 64 bit integer */
31 LIBBPF_NLA_STRING, /**< NUL terminated character string */
32 LIBBPF_NLA_FLAG, /**< Flag */
33 LIBBPF_NLA_MSECS, /**< Micro seconds (64bit) */
34 LIBBPF_NLA_NESTED, /**< Nested attributes */
35 __LIBBPF_NLA_TYPE_MAX,
36};
37
38#define LIBBPF_NLA_TYPE_MAX (__LIBBPF_NLA_TYPE_MAX - 1)
39
40/**
41 * @ingroup attr
42 * Attribute validation policy.
43 *
44 * See section @core_doc{core_attr_parse,Attribute Parsing} for more details.
45 */
46struct libbpf_nla_policy {
47 /** Type of attribute or LIBBPF_NLA_UNSPEC */
48 uint16_t type;
49
50 /** Minimal length of payload required */
51 uint16_t minlen;
52
53 /** Maximal length of payload allowed */
54 uint16_t maxlen;
55};
56
57struct libbpf_nla_req {
58 struct nlmsghdr nh;
59 union {
60 struct ifinfomsg ifinfo;
61 struct tcmsg tc;
62 struct genlmsghdr gnl;
63 };
64 char buf[128];
65};
66
67/**
68 * @ingroup attr
69 * Iterate over a stream of attributes
70 * @arg pos loop counter, set to current attribute
71 * @arg head head of attribute stream
72 * @arg len length of attribute stream
73 * @arg rem initialized to len, holds bytes currently remaining in stream
74 */
75#define libbpf_nla_for_each_attr(pos, head, len, rem) \
76 for (pos = head, rem = len; \
77 nla_ok(pos, rem); \
78 pos = nla_next(pos, &(rem)))
79
80/**
81 * libbpf_nla_data - head of payload
82 * @nla: netlink attribute
83 */
84static inline void *libbpf_nla_data(const struct nlattr *nla)
85{
86 return (void *)nla + NLA_HDRLEN;
87}
88
89static inline uint8_t libbpf_nla_getattr_u8(const struct nlattr *nla)
90{
91 return *(uint8_t *)libbpf_nla_data(nla);
92}
93
94static inline uint16_t libbpf_nla_getattr_u16(const struct nlattr *nla)
95{
96 return *(uint16_t *)libbpf_nla_data(nla);
97}
98
99static inline uint32_t libbpf_nla_getattr_u32(const struct nlattr *nla)
100{
101 return *(uint32_t *)libbpf_nla_data(nla);
102}
103
104static inline uint64_t libbpf_nla_getattr_u64(const struct nlattr *nla)
105{
106 return *(uint64_t *)libbpf_nla_data(nla);
107}
108
109static inline const char *libbpf_nla_getattr_str(const struct nlattr *nla)
110{
111 return (const char *)libbpf_nla_data(nla);
112}
113
114/**
115 * libbpf_nla_len - length of payload
116 * @nla: netlink attribute
117 */
118static inline int libbpf_nla_len(const struct nlattr *nla)
119{
120 return nla->nla_len - NLA_HDRLEN;
121}
122
123int libbpf_nla_parse(struct nlattr *tb[], int maxtype, struct nlattr *head,
124 int len, struct libbpf_nla_policy *policy);
125int libbpf_nla_parse_nested(struct nlattr *tb[], int maxtype,
126 struct nlattr *nla,
127 struct libbpf_nla_policy *policy);
128
129int libbpf_nla_dump_errormsg(struct nlmsghdr *nlh);
130
131static inline struct nlattr *nla_data(struct nlattr *nla)
132{
133 return (struct nlattr *)((void *)nla + NLA_HDRLEN);
134}
135
136static inline struct nlattr *req_tail(struct libbpf_nla_req *req)
137{
138 return (struct nlattr *)((void *)req + NLMSG_ALIGN(req->nh.nlmsg_len));
139}
140
141static inline int nlattr_add(struct libbpf_nla_req *req, int type,
142 const void *data, int len)
143{
144 struct nlattr *nla;
145
146 if (NLMSG_ALIGN(req->nh.nlmsg_len) + NLA_ALIGN(NLA_HDRLEN + len) > sizeof(*req))
147 return -EMSGSIZE;
148 if (!!data != !!len)
149 return -EINVAL;
150
151 nla = req_tail(req);
152 nla->nla_type = type;
153 nla->nla_len = NLA_HDRLEN + len;
154 if (data)
155 memcpy(nla_data(nla), data, len);
156 req->nh.nlmsg_len = NLMSG_ALIGN(req->nh.nlmsg_len) + NLA_ALIGN(nla->nla_len);
157 return 0;
158}
159
160static inline struct nlattr *nlattr_begin_nested(struct libbpf_nla_req *req, int type)
161{
162 struct nlattr *tail;
163
164 tail = req_tail(req);
165 if (nlattr_add(req, type | NLA_F_NESTED, NULL, 0))
166 return NULL;
167 return tail;
168}
169
170static inline void nlattr_end_nested(struct libbpf_nla_req *req,
171 struct nlattr *tail)
172{
173 tail->nla_len = (void *)req_tail(req) - (void *)tail;
174}
175
176#endif /* __LIBBPF_NLATTR_H */
1/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */
2
3/*
4 * NETLINK Netlink attributes
5 *
6 * Copyright (c) 2003-2013 Thomas Graf <tgraf@suug.ch>
7 */
8
9#ifndef __LIBBPF_NLATTR_H
10#define __LIBBPF_NLATTR_H
11
12#include <stdint.h>
13#include <string.h>
14#include <errno.h>
15#include <linux/netlink.h>
16#include <linux/rtnetlink.h>
17
18/* avoid multiple definition of netlink features */
19#define __LINUX_NETLINK_H
20
21/**
22 * Standard attribute types to specify validation policy
23 */
24enum {
25 LIBBPF_NLA_UNSPEC, /**< Unspecified type, binary data chunk */
26 LIBBPF_NLA_U8, /**< 8 bit integer */
27 LIBBPF_NLA_U16, /**< 16 bit integer */
28 LIBBPF_NLA_U32, /**< 32 bit integer */
29 LIBBPF_NLA_U64, /**< 64 bit integer */
30 LIBBPF_NLA_STRING, /**< NUL terminated character string */
31 LIBBPF_NLA_FLAG, /**< Flag */
32 LIBBPF_NLA_MSECS, /**< Micro seconds (64bit) */
33 LIBBPF_NLA_NESTED, /**< Nested attributes */
34 __LIBBPF_NLA_TYPE_MAX,
35};
36
37#define LIBBPF_NLA_TYPE_MAX (__LIBBPF_NLA_TYPE_MAX - 1)
38
39/**
40 * @ingroup attr
41 * Attribute validation policy.
42 *
43 * See section @core_doc{core_attr_parse,Attribute Parsing} for more details.
44 */
45struct libbpf_nla_policy {
46 /** Type of attribute or LIBBPF_NLA_UNSPEC */
47 uint16_t type;
48
49 /** Minimal length of payload required */
50 uint16_t minlen;
51
52 /** Maximal length of payload allowed */
53 uint16_t maxlen;
54};
55
56struct libbpf_nla_req {
57 struct nlmsghdr nh;
58 union {
59 struct ifinfomsg ifinfo;
60 struct tcmsg tc;
61 };
62 char buf[128];
63};
64
65/**
66 * @ingroup attr
67 * Iterate over a stream of attributes
68 * @arg pos loop counter, set to current attribute
69 * @arg head head of attribute stream
70 * @arg len length of attribute stream
71 * @arg rem initialized to len, holds bytes currently remaining in stream
72 */
73#define libbpf_nla_for_each_attr(pos, head, len, rem) \
74 for (pos = head, rem = len; \
75 nla_ok(pos, rem); \
76 pos = nla_next(pos, &(rem)))
77
78/**
79 * libbpf_nla_data - head of payload
80 * @nla: netlink attribute
81 */
82static inline void *libbpf_nla_data(const struct nlattr *nla)
83{
84 return (void *)nla + NLA_HDRLEN;
85}
86
87static inline uint8_t libbpf_nla_getattr_u8(const struct nlattr *nla)
88{
89 return *(uint8_t *)libbpf_nla_data(nla);
90}
91
92static inline uint32_t libbpf_nla_getattr_u32(const struct nlattr *nla)
93{
94 return *(uint32_t *)libbpf_nla_data(nla);
95}
96
97static inline const char *libbpf_nla_getattr_str(const struct nlattr *nla)
98{
99 return (const char *)libbpf_nla_data(nla);
100}
101
102/**
103 * libbpf_nla_len - length of payload
104 * @nla: netlink attribute
105 */
106static inline int libbpf_nla_len(const struct nlattr *nla)
107{
108 return nla->nla_len - NLA_HDRLEN;
109}
110
111int libbpf_nla_parse(struct nlattr *tb[], int maxtype, struct nlattr *head,
112 int len, struct libbpf_nla_policy *policy);
113int libbpf_nla_parse_nested(struct nlattr *tb[], int maxtype,
114 struct nlattr *nla,
115 struct libbpf_nla_policy *policy);
116
117int libbpf_nla_dump_errormsg(struct nlmsghdr *nlh);
118
119static inline struct nlattr *nla_data(struct nlattr *nla)
120{
121 return (struct nlattr *)((void *)nla + NLA_HDRLEN);
122}
123
124static inline struct nlattr *req_tail(struct libbpf_nla_req *req)
125{
126 return (struct nlattr *)((void *)req + NLMSG_ALIGN(req->nh.nlmsg_len));
127}
128
129static inline int nlattr_add(struct libbpf_nla_req *req, int type,
130 const void *data, int len)
131{
132 struct nlattr *nla;
133
134 if (NLMSG_ALIGN(req->nh.nlmsg_len) + NLA_ALIGN(NLA_HDRLEN + len) > sizeof(*req))
135 return -EMSGSIZE;
136 if (!!data != !!len)
137 return -EINVAL;
138
139 nla = req_tail(req);
140 nla->nla_type = type;
141 nla->nla_len = NLA_HDRLEN + len;
142 if (data)
143 memcpy(nla_data(nla), data, len);
144 req->nh.nlmsg_len = NLMSG_ALIGN(req->nh.nlmsg_len) + NLA_ALIGN(nla->nla_len);
145 return 0;
146}
147
148static inline struct nlattr *nlattr_begin_nested(struct libbpf_nla_req *req, int type)
149{
150 struct nlattr *tail;
151
152 tail = req_tail(req);
153 if (nlattr_add(req, type | NLA_F_NESTED, NULL, 0))
154 return NULL;
155 return tail;
156}
157
158static inline void nlattr_end_nested(struct libbpf_nla_req *req,
159 struct nlattr *tail)
160{
161 tail->nla_len = (void *)req_tail(req) - (void *)tail;
162}
163
164#endif /* __LIBBPF_NLATTR_H */