15 #include <netinet/in.h>
18 #include <libmnl/libmnl.h>
19 #include <linux/netfilter/nfnetlink.h>
20 #include <linux/netfilter/nf_tables.h>
22 #include <libnftnl/table.h>
25 struct list_head head;
40 EXPORT_SYMBOL(nftnl_table_alloc);
46 EXPORT_SYMBOL(nftnl_table_free);
49 if (t->flags & (1 << NFTNL_TABLE_NAME))
51 if (t->flags & (1 << NFTNL_TABLE_USERDATA))
57 EXPORT_SYMBOL(nftnl_table_is_set);
58 bool nftnl_table_is_set(
const struct nftnl_table *t, uint16_t attr)
60 return t->flags & (1 << attr);
63 EXPORT_SYMBOL(nftnl_table_unset);
64 void nftnl_table_unset(
struct nftnl_table *t, uint16_t attr)
66 if (!(t->flags & (1 << attr)))
70 case NFTNL_TABLE_NAME:
73 case NFTNL_TABLE_USERDATA:
76 case NFTNL_TABLE_FLAGS:
77 case NFTNL_TABLE_HANDLE:
78 case NFTNL_TABLE_FAMILY:
80 case NFTNL_TABLE_OWNER:
83 t->flags &= ~(1 << attr);
86 static uint32_t nftnl_table_validate[NFTNL_TABLE_MAX + 1] = {
87 [NFTNL_TABLE_FLAGS] =
sizeof(uint32_t),
88 [NFTNL_TABLE_FAMILY] =
sizeof(uint32_t),
89 [NFTNL_TABLE_HANDLE] =
sizeof(uint64_t),
90 [NFTNL_TABLE_USE] =
sizeof(uint32_t),
91 [NFTNL_TABLE_OWNER] =
sizeof(uint32_t),
94 EXPORT_SYMBOL(nftnl_table_set_data);
95 int nftnl_table_set_data(
struct nftnl_table *t, uint16_t attr,
96 const void *data, uint32_t data_len)
98 nftnl_assert_attr_exists(attr, NFTNL_TABLE_MAX);
99 nftnl_assert_validate(data, nftnl_table_validate, attr, data_len);
102 case NFTNL_TABLE_NAME:
103 return nftnl_set_str_attr(&t->name, &t->flags,
104 attr, data, data_len);
105 case NFTNL_TABLE_HANDLE:
106 memcpy(&t->handle, data,
sizeof(t->handle));
108 case NFTNL_TABLE_FLAGS:
109 memcpy(&t->table_flags, data,
sizeof(t->table_flags));
111 case NFTNL_TABLE_FAMILY:
112 memcpy(&t->family, data,
sizeof(t->family));
114 case NFTNL_TABLE_USE:
115 memcpy(&t->use, data,
sizeof(t->use));
117 case NFTNL_TABLE_USERDATA:
118 if (t->flags & (1 << NFTNL_TABLE_USERDATA))
121 t->user.data = malloc(data_len);
124 memcpy(t->user.data, data, data_len);
125 t->user.len = data_len;
127 case NFTNL_TABLE_OWNER:
128 memcpy(&t->owner, data,
sizeof(t->owner));
131 t->flags |= (1 << attr);
135 void nftnl_table_set(
struct nftnl_table *t, uint16_t attr,
const void *data) __visible;
136 void nftnl_table_set(
struct nftnl_table *t, uint16_t attr,
const void *data)
138 nftnl_table_set_data(t, attr, data, nftnl_table_validate[attr]);
141 EXPORT_SYMBOL(nftnl_table_set_u32);
142 void nftnl_table_set_u32(
struct nftnl_table *t, uint16_t attr, uint32_t val)
144 nftnl_table_set_data(t, attr, &val,
sizeof(uint32_t));
147 EXPORT_SYMBOL(nftnl_table_set_u64);
148 void nftnl_table_set_u64(
struct nftnl_table *t, uint16_t attr, uint64_t val)
150 nftnl_table_set_data(t, attr, &val,
sizeof(uint64_t));
153 EXPORT_SYMBOL(nftnl_table_set_u8);
154 void nftnl_table_set_u8(
struct nftnl_table *t, uint16_t attr, uint8_t val)
156 nftnl_table_set_data(t, attr, &val,
sizeof(uint8_t));
159 EXPORT_SYMBOL(nftnl_table_set_str);
160 int nftnl_table_set_str(
struct nftnl_table *t, uint16_t attr,
const char *str)
162 return nftnl_table_set_data(t, attr, str, strlen(str) + 1);
165 EXPORT_SYMBOL(nftnl_table_get_data);
166 const void *nftnl_table_get_data(
const struct nftnl_table *t, uint16_t attr,
169 if (!(t->flags & (1 << attr)))
173 case NFTNL_TABLE_NAME:
174 *data_len = strlen(t->name) + 1;
176 case NFTNL_TABLE_HANDLE:
177 *data_len =
sizeof(uint64_t);
179 case NFTNL_TABLE_FLAGS:
180 *data_len =
sizeof(uint32_t);
181 return &t->table_flags;
182 case NFTNL_TABLE_FAMILY:
183 *data_len =
sizeof(uint32_t);
185 case NFTNL_TABLE_USE:
186 *data_len =
sizeof(uint32_t);
188 case NFTNL_TABLE_USERDATA:
189 *data_len = t->user.len;
191 case NFTNL_TABLE_OWNER:
192 *data_len =
sizeof(uint32_t);
198 EXPORT_SYMBOL(nftnl_table_get);
199 const void *nftnl_table_get(
const struct nftnl_table *t, uint16_t attr)
202 return nftnl_table_get_data(t, attr, &data_len);
205 EXPORT_SYMBOL(nftnl_table_get_u32);
206 uint32_t nftnl_table_get_u32(
const struct nftnl_table *t, uint16_t attr)
208 const void *ret = nftnl_table_get(t, attr);
209 return ret == NULL ? 0 : *((uint32_t *)ret);
212 EXPORT_SYMBOL(nftnl_table_get_u64);
213 uint64_t nftnl_table_get_u64(
const struct nftnl_table *t, uint16_t attr)
215 const void *ret = nftnl_table_get(t, attr);
216 return ret == NULL ? 0 : *((uint64_t *)ret);
219 EXPORT_SYMBOL(nftnl_table_get_u8);
220 uint8_t nftnl_table_get_u8(
const struct nftnl_table *t, uint16_t attr)
222 const void *ret = nftnl_table_get(t, attr);
223 return ret == NULL ? 0 : *((uint8_t *)ret);
226 EXPORT_SYMBOL(nftnl_table_get_str);
227 const char *nftnl_table_get_str(
const struct nftnl_table *t, uint16_t attr)
229 return nftnl_table_get(t, attr);
232 EXPORT_SYMBOL(nftnl_table_nlmsg_build_payload);
233 void nftnl_table_nlmsg_build_payload(
struct nlmsghdr *nlh,
const struct nftnl_table *t)
235 if (t->flags & (1 << NFTNL_TABLE_NAME))
236 mnl_attr_put_strz(nlh, NFTA_TABLE_NAME, t->name);
237 if (t->flags & (1 << NFTNL_TABLE_HANDLE))
238 mnl_attr_put_u64(nlh, NFTA_TABLE_HANDLE, htobe64(t->handle));
239 if (t->flags & (1 << NFTNL_TABLE_FLAGS))
240 mnl_attr_put_u32(nlh, NFTA_TABLE_FLAGS, htonl(t->table_flags));
241 if (t->flags & (1 << NFTNL_TABLE_USERDATA))
242 mnl_attr_put(nlh, NFTA_TABLE_USERDATA, t->user.len, t->user.data);
245 static int nftnl_table_parse_attr_cb(
const struct nlattr *attr,
void *data)
247 const struct nlattr **tb = data;
248 int type = mnl_attr_get_type(attr);
250 if (mnl_attr_type_valid(attr, NFTA_TABLE_MAX) < 0)
254 case NFTA_TABLE_NAME:
255 if (mnl_attr_validate(attr, MNL_TYPE_STRING) < 0)
258 case NFTA_TABLE_HANDLE:
259 if (mnl_attr_validate(attr, MNL_TYPE_U64) < 0)
262 case NFTA_TABLE_FLAGS:
264 case NFTA_TABLE_OWNER:
265 if (mnl_attr_validate(attr, MNL_TYPE_U32) < 0)
268 case NFTA_TABLE_USERDATA:
269 if (mnl_attr_validate(attr, MNL_TYPE_BINARY) < 0)
278 EXPORT_SYMBOL(nftnl_table_nlmsg_parse);
279 int nftnl_table_nlmsg_parse(
const struct nlmsghdr *nlh,
struct nftnl_table *t)
281 struct nlattr *tb[NFTA_TABLE_MAX+1] = {};
282 struct nfgenmsg *nfg = mnl_nlmsg_get_payload(nlh);
285 if (mnl_attr_parse(nlh,
sizeof(*nfg), nftnl_table_parse_attr_cb, tb) < 0)
288 if (tb[NFTA_TABLE_NAME]) {
289 if (t->flags & (1 << NFTNL_TABLE_NAME))
291 t->name = strdup(mnl_attr_get_str(tb[NFTA_TABLE_NAME]));
294 t->flags |= (1 << NFTNL_TABLE_NAME);
296 if (tb[NFTA_TABLE_FLAGS]) {
297 t->table_flags = ntohl(mnl_attr_get_u32(tb[NFTA_TABLE_FLAGS]));
298 t->flags |= (1 << NFTNL_TABLE_FLAGS);
300 if (tb[NFTA_TABLE_USE]) {
301 t->use = ntohl(mnl_attr_get_u32(tb[NFTA_TABLE_USE]));
302 t->flags |= (1 << NFTNL_TABLE_USE);
304 if (tb[NFTA_TABLE_HANDLE]) {
305 t->handle = be64toh(mnl_attr_get_u64(tb[NFTA_TABLE_HANDLE]));
306 t->flags |= (1 << NFTNL_TABLE_HANDLE);
308 if (tb[NFTA_TABLE_USERDATA]) {
309 ret = nftnl_table_set_data(t, NFTNL_TABLE_USERDATA,
310 mnl_attr_get_payload(tb[NFTA_TABLE_USERDATA]),
311 mnl_attr_get_payload_len(tb[NFTA_TABLE_USERDATA]));
315 if (tb[NFTA_TABLE_OWNER]) {
316 t->owner = ntohl(mnl_attr_get_u32(tb[NFTA_TABLE_OWNER]));
317 t->flags |= (1 << NFTNL_TABLE_OWNER);
320 t->family = nfg->nfgen_family;
321 t->flags |= (1 << NFTNL_TABLE_FAMILY);
326 EXPORT_SYMBOL(nftnl_table_parse);
327 int nftnl_table_parse(
struct nftnl_table *t,
enum nftnl_parse_type type,
328 const char *data,
struct nftnl_parse_err *err)
335 EXPORT_SYMBOL(nftnl_table_parse_file);
336 int nftnl_table_parse_file(
struct nftnl_table *t,
enum nftnl_parse_type type,
337 FILE *fp,
struct nftnl_parse_err *err)
344 static int nftnl_table_snprintf_default(
char *buf,
size_t size,
347 return snprintf(buf, size,
"table %s %s flags %x use %d handle %llu",
348 t->name, nftnl_family2str(t->family),
349 t->table_flags, t->use, (
unsigned long long)t->handle);
352 static int nftnl_table_cmd_snprintf(
char *buf,
size_t remain,
354 uint32_t type, uint32_t flags)
358 if (type != NFTNL_OUTPUT_DEFAULT)
361 ret = nftnl_table_snprintf_default(buf + offset, remain, t);
362 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
366 EXPORT_SYMBOL(nftnl_table_snprintf);
367 int nftnl_table_snprintf(
char *buf,
size_t size,
const struct nftnl_table *t,
368 uint32_t type, uint32_t flags)
373 return nftnl_table_cmd_snprintf(buf, size, t, nftnl_flag2cmd(flags), type,
377 static int nftnl_table_do_snprintf(
char *buf,
size_t size,
const void *t,
378 uint32_t cmd, uint32_t type, uint32_t flags)
380 return nftnl_table_snprintf(buf, size, t, type, flags);
383 EXPORT_SYMBOL(nftnl_table_fprintf);
384 int nftnl_table_fprintf(FILE *fp,
const struct nftnl_table *t, uint32_t type,
387 return nftnl_fprintf(fp, t, NFTNL_CMD_UNSPEC, type, flags,
388 nftnl_table_do_snprintf);
392 struct list_head list;
395 EXPORT_SYMBOL(nftnl_table_list_alloc);
404 INIT_LIST_HEAD(&list->list);
409 EXPORT_SYMBOL(nftnl_table_list_free);
414 list_for_each_entry_safe(r, tmp, &list->list, head) {
421 EXPORT_SYMBOL(nftnl_table_list_is_empty);
424 return list_empty(&list->list);
427 EXPORT_SYMBOL(nftnl_table_list_add);
430 list_add(&r->head, &list->list);
433 EXPORT_SYMBOL(nftnl_table_list_add_tail);
436 list_add_tail(&r->head, &list->list);
439 EXPORT_SYMBOL(nftnl_table_list_del);
445 EXPORT_SYMBOL(nftnl_table_list_foreach);
453 list_for_each_entry_safe(cur, tmp, &table_list->list, head) {
466 EXPORT_SYMBOL(nftnl_table_list_iter_create);
477 if (nftnl_table_list_is_empty(l))
480 iter->cur = list_entry(l->list.next,
struct nftnl_table, head);
485 EXPORT_SYMBOL(nftnl_table_list_iter_next);
494 iter->cur = list_entry(iter->cur->head.next,
struct nftnl_table, head);
495 if (&iter->cur->head == iter->list->list.next)
501 EXPORT_SYMBOL(nftnl_table_list_iter_destroy);