19 #include <netinet/in.h>
22 #include <libmnl/libmnl.h>
23 #include <linux/netfilter/nfnetlink.h>
24 #include <linux/netfilter/nf_tables.h>
26 #include <libnftnl/table.h>
29 struct list_head head;
39 EXPORT_SYMBOL(nftnl_table_alloc);
45 EXPORT_SYMBOL(nftnl_table_free);
48 if (t->flags & (1 << NFTNL_TABLE_NAME))
54 EXPORT_SYMBOL(nftnl_table_is_set);
55 bool nftnl_table_is_set(
const struct nftnl_table *t, uint16_t attr)
57 return t->flags & (1 << attr);
60 EXPORT_SYMBOL(nftnl_table_unset);
61 void nftnl_table_unset(
struct nftnl_table *t, uint16_t attr)
63 if (!(t->flags & (1 << attr)))
67 case NFTNL_TABLE_NAME:
70 case NFTNL_TABLE_FLAGS:
71 case NFTNL_TABLE_HANDLE:
72 case NFTNL_TABLE_FAMILY:
77 t->flags &= ~(1 << attr);
80 static uint32_t nftnl_table_validate[NFTNL_TABLE_MAX + 1] = {
81 [NFTNL_TABLE_FLAGS] =
sizeof(uint32_t),
82 [NFTNL_TABLE_FAMILY] =
sizeof(uint32_t),
83 [NFTNL_TABLE_HANDLE] =
sizeof(uint64_t),
86 EXPORT_SYMBOL(nftnl_table_set_data);
87 int nftnl_table_set_data(
struct nftnl_table *t, uint16_t attr,
88 const void *data, uint32_t data_len)
90 nftnl_assert_attr_exists(attr, NFTNL_TABLE_MAX);
91 nftnl_assert_validate(data, nftnl_table_validate, attr, data_len);
94 case NFTNL_TABLE_NAME:
95 if (t->flags & (1 << NFTNL_TABLE_NAME))
98 t->name = strdup(data);
102 case NFTNL_TABLE_HANDLE:
103 memcpy(&t->handle, data,
sizeof(t->handle));
105 case NFTNL_TABLE_FLAGS:
106 memcpy(&t->table_flags, data,
sizeof(t->table_flags));
108 case NFTNL_TABLE_FAMILY:
109 memcpy(&t->family, data,
sizeof(t->family));
111 case NFTNL_TABLE_USE:
112 memcpy(&t->use, data,
sizeof(t->use));
115 t->flags |= (1 << attr);
119 void nftnl_table_set(
struct nftnl_table *t, uint16_t attr,
const void *data) __visible;
120 void nftnl_table_set(
struct nftnl_table *t, uint16_t attr,
const void *data)
122 nftnl_table_set_data(t, attr, data, nftnl_table_validate[attr]);
125 EXPORT_SYMBOL(nftnl_table_set_u32);
126 void nftnl_table_set_u32(
struct nftnl_table *t, uint16_t attr, uint32_t val)
128 nftnl_table_set_data(t, attr, &val,
sizeof(uint32_t));
131 EXPORT_SYMBOL(nftnl_table_set_u64);
132 void nftnl_table_set_u64(
struct nftnl_table *t, uint16_t attr, uint64_t val)
134 nftnl_table_set_data(t, attr, &val,
sizeof(uint64_t));
137 EXPORT_SYMBOL(nftnl_table_set_u8);
138 void nftnl_table_set_u8(
struct nftnl_table *t, uint16_t attr, uint8_t val)
140 nftnl_table_set_data(t, attr, &val,
sizeof(uint8_t));
143 EXPORT_SYMBOL(nftnl_table_set_str);
144 int nftnl_table_set_str(
struct nftnl_table *t, uint16_t attr,
const char *str)
146 return nftnl_table_set_data(t, attr, str, strlen(str) + 1);
149 EXPORT_SYMBOL(nftnl_table_get_data);
150 const void *nftnl_table_get_data(
const struct nftnl_table *t, uint16_t attr,
153 if (!(t->flags & (1 << attr)))
157 case NFTNL_TABLE_NAME:
158 *data_len = strlen(t->name) + 1;
160 case NFTNL_TABLE_HANDLE:
161 *data_len =
sizeof(uint64_t);
163 case NFTNL_TABLE_FLAGS:
164 *data_len =
sizeof(uint32_t);
165 return &t->table_flags;
166 case NFTNL_TABLE_FAMILY:
167 *data_len =
sizeof(uint32_t);
169 case NFTNL_TABLE_USE:
170 *data_len =
sizeof(uint32_t);
176 EXPORT_SYMBOL(nftnl_table_get);
177 const void *nftnl_table_get(
const struct nftnl_table *t, uint16_t attr)
180 return nftnl_table_get_data(t, attr, &data_len);
183 EXPORT_SYMBOL(nftnl_table_get_u32);
184 uint32_t nftnl_table_get_u32(
const struct nftnl_table *t, uint16_t attr)
186 const void *ret = nftnl_table_get(t, attr);
187 return ret == NULL ? 0 : *((uint32_t *)ret);
190 EXPORT_SYMBOL(nftnl_table_get_u64);
191 uint64_t nftnl_table_get_u64(
const struct nftnl_table *t, uint16_t attr)
193 const void *ret = nftnl_table_get(t, attr);
194 return ret == NULL ? 0 : *((uint64_t *)ret);
197 EXPORT_SYMBOL(nftnl_table_get_u8);
198 uint8_t nftnl_table_get_u8(
const struct nftnl_table *t, uint16_t attr)
200 const void *ret = nftnl_table_get(t, attr);
201 return ret == NULL ? 0 : *((uint8_t *)ret);
204 EXPORT_SYMBOL(nftnl_table_get_str);
205 const char *nftnl_table_get_str(
const struct nftnl_table *t, uint16_t attr)
207 return nftnl_table_get(t, attr);
210 EXPORT_SYMBOL(nftnl_table_nlmsg_build_payload);
211 void nftnl_table_nlmsg_build_payload(
struct nlmsghdr *nlh,
const struct nftnl_table *t)
213 if (t->flags & (1 << NFTNL_TABLE_NAME))
214 mnl_attr_put_strz(nlh, NFTA_TABLE_NAME, t->name);
215 if (t->flags & (1 << NFTNL_TABLE_HANDLE))
216 mnl_attr_put_u64(nlh, NFTA_TABLE_HANDLE, htobe64(t->handle));
217 if (t->flags & (1 << NFTNL_TABLE_FLAGS))
218 mnl_attr_put_u32(nlh, NFTA_TABLE_FLAGS, htonl(t->table_flags));
221 static int nftnl_table_parse_attr_cb(
const struct nlattr *attr,
void *data)
223 const struct nlattr **tb = data;
224 int type = mnl_attr_get_type(attr);
226 if (mnl_attr_type_valid(attr, NFTA_TABLE_MAX) < 0)
230 case NFTA_TABLE_NAME:
231 if (mnl_attr_validate(attr, MNL_TYPE_STRING) < 0)
234 case NFTA_TABLE_HANDLE:
235 if (mnl_attr_validate(attr, MNL_TYPE_U64) < 0)
238 case NFTA_TABLE_FLAGS:
240 if (mnl_attr_validate(attr, MNL_TYPE_U32) < 0)
249 EXPORT_SYMBOL(nftnl_table_nlmsg_parse);
250 int nftnl_table_nlmsg_parse(
const struct nlmsghdr *nlh,
struct nftnl_table *t)
252 struct nlattr *tb[NFTA_TABLE_MAX+1] = {};
253 struct nfgenmsg *nfg = mnl_nlmsg_get_payload(nlh);
255 if (mnl_attr_parse(nlh,
sizeof(*nfg), nftnl_table_parse_attr_cb, tb) < 0)
258 if (tb[NFTA_TABLE_NAME]) {
259 if (t->flags & (1 << NFTNL_TABLE_NAME))
261 t->name = strdup(mnl_attr_get_str(tb[NFTA_TABLE_NAME]));
264 t->flags |= (1 << NFTNL_TABLE_NAME);
266 if (tb[NFTA_TABLE_FLAGS]) {
267 t->table_flags = ntohl(mnl_attr_get_u32(tb[NFTA_TABLE_FLAGS]));
268 t->flags |= (1 << NFTNL_TABLE_FLAGS);
270 if (tb[NFTA_TABLE_USE]) {
271 t->use = ntohl(mnl_attr_get_u32(tb[NFTA_TABLE_USE]));
272 t->flags |= (1 << NFTNL_TABLE_USE);
274 if (tb[NFTA_TABLE_HANDLE]) {
275 t->handle = be64toh(mnl_attr_get_u64(tb[NFTA_TABLE_HANDLE]));
276 t->flags |= (1 << NFTNL_TABLE_HANDLE);
279 t->family = nfg->nfgen_family;
280 t->flags |= (1 << NFTNL_TABLE_FAMILY);
285 static int nftnl_table_do_parse(
struct nftnl_table *t,
enum nftnl_parse_type type,
286 const void *data,
struct nftnl_parse_err *err,
287 enum nftnl_parse_input input)
292 case NFTNL_PARSE_JSON:
293 case NFTNL_PARSE_XML:
303 EXPORT_SYMBOL(nftnl_table_parse);
304 int nftnl_table_parse(
struct nftnl_table *t,
enum nftnl_parse_type type,
305 const char *data,
struct nftnl_parse_err *err)
307 return nftnl_table_do_parse(t, type, data, err, NFTNL_PARSE_BUFFER);
310 EXPORT_SYMBOL(nftnl_table_parse_file);
311 int nftnl_table_parse_file(
struct nftnl_table *t,
enum nftnl_parse_type type,
312 FILE *fp,
struct nftnl_parse_err *err)
314 return nftnl_table_do_parse(t, type, fp, err, NFTNL_PARSE_FILE);
317 static int nftnl_table_snprintf_default(
char *buf,
size_t size,
320 return snprintf(buf, size,
"table %s %s flags %x use %d handle %llu",
321 t->name, nftnl_family2str(t->family),
322 t->table_flags, t->use, (
unsigned long long)t->handle);
325 static int nftnl_table_cmd_snprintf(
char *buf,
size_t size,
327 uint32_t type, uint32_t flags)
329 int ret, remain = size, offset = 0;
332 case NFTNL_OUTPUT_DEFAULT:
333 ret = nftnl_table_snprintf_default(buf + offset, remain, t);
334 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
336 case NFTNL_OUTPUT_XML:
337 case NFTNL_OUTPUT_JSON:
345 EXPORT_SYMBOL(nftnl_table_snprintf);
346 int nftnl_table_snprintf(
char *buf,
size_t size,
const struct nftnl_table *t,
347 uint32_t type, uint32_t flags)
352 return nftnl_table_cmd_snprintf(buf, size, t, nftnl_flag2cmd(flags), type,
356 static int nftnl_table_do_snprintf(
char *buf,
size_t size,
const void *t,
357 uint32_t cmd, uint32_t type, uint32_t flags)
359 return nftnl_table_snprintf(buf, size, t, type, flags);
362 EXPORT_SYMBOL(nftnl_table_fprintf);
363 int nftnl_table_fprintf(FILE *fp,
const struct nftnl_table *t, uint32_t type,
366 return nftnl_fprintf(fp, t, NFTNL_CMD_UNSPEC, type, flags,
367 nftnl_table_do_snprintf);
371 struct list_head list;
374 EXPORT_SYMBOL(nftnl_table_list_alloc);
383 INIT_LIST_HEAD(&list->list);
388 EXPORT_SYMBOL(nftnl_table_list_free);
393 list_for_each_entry_safe(r, tmp, &list->list, head) {
400 EXPORT_SYMBOL(nftnl_table_list_is_empty);
403 return list_empty(&list->list);
406 EXPORT_SYMBOL(nftnl_table_list_add);
409 list_add(&r->head, &list->list);
412 EXPORT_SYMBOL(nftnl_table_list_add_tail);
415 list_add_tail(&r->head, &list->list);
418 EXPORT_SYMBOL(nftnl_table_list_del);
424 EXPORT_SYMBOL(nftnl_table_list_foreach);
432 list_for_each_entry_safe(cur, tmp, &table_list->list, head) {
445 EXPORT_SYMBOL(nftnl_table_list_iter_create);
456 if (nftnl_table_list_is_empty(l))
459 iter->cur = list_entry(l->list.next,
struct nftnl_table, head);
464 EXPORT_SYMBOL(nftnl_table_list_iter_next);
473 iter->cur = list_entry(iter->cur->head.next,
struct nftnl_table, head);
474 if (&iter->cur->head == iter->list->list.next)
480 EXPORT_SYMBOL(nftnl_table_list_iter_destroy);