libnftnl  1.0.6
set.c
1 /*
2  * (C) 2012-2013 by Pablo Neira Ayuso <pablo@netfilter.org>
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published
6  * by the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * This code has been sponsored by Sophos Astaro <http://www.sophos.com>
10  */
11 #include "internal.h"
12 
13 #include <time.h>
14 #include <endian.h>
15 #include <stdint.h>
16 #include <stdlib.h>
17 #include <string.h>
18 #include <inttypes.h>
19 #include <netinet/in.h>
20 #include <limits.h>
21 #include <errno.h>
22 
23 #include <libmnl/libmnl.h>
24 #include <linux/netfilter/nfnetlink.h>
25 #include <linux/netfilter/nf_tables.h>
26 
27 #include <libnftnl/set.h>
28 #include <libnftnl/expr.h>
29 
30 struct nftnl_set *nftnl_set_alloc(void)
31 {
32  struct nftnl_set *s;
33 
34  s = calloc(1, sizeof(struct nftnl_set));
35  if (s == NULL)
36  return NULL;
37 
38  INIT_LIST_HEAD(&s->element_list);
39  return s;
40 }
41 EXPORT_SYMBOL_ALIAS(nftnl_set_alloc, nft_set_alloc);
42 
43 void nftnl_set_free(const struct nftnl_set *s)
44 {
45  struct nftnl_set_elem *elem, *tmp;
46 
47  if (s->table != NULL)
48  xfree(s->table);
49  if (s->name != NULL)
50  xfree(s->name);
51 
52  list_for_each_entry_safe(elem, tmp, &s->element_list, head) {
53  list_del(&elem->head);
54  nftnl_set_elem_free(elem);
55  }
56  xfree(s);
57 }
58 EXPORT_SYMBOL_ALIAS(nftnl_set_free, nft_set_free);
59 
60 bool nftnl_set_is_set(const struct nftnl_set *s, uint16_t attr)
61 {
62  return s->flags & (1 << attr);
63 }
64 EXPORT_SYMBOL_ALIAS(nftnl_set_is_set, nft_set_attr_is_set);
65 
66 void nftnl_set_unset(struct nftnl_set *s, uint16_t attr)
67 {
68  switch (attr) {
69  case NFTNL_SET_TABLE:
70  if (s->flags & (1 << NFTNL_SET_TABLE))
71  if (s->table) {
72  xfree(s->table);
73  s->table = NULL;
74  }
75  break;
76  case NFTNL_SET_NAME:
77  if (s->flags & (1 << NFTNL_SET_NAME))
78  if (s->name) {
79  xfree(s->name);
80  s->name = NULL;
81  }
82  break;
83  case NFTNL_SET_FLAGS:
84  case NFTNL_SET_KEY_TYPE:
85  case NFTNL_SET_KEY_LEN:
86  case NFTNL_SET_DATA_TYPE:
87  case NFTNL_SET_DATA_LEN:
88  case NFTNL_SET_FAMILY:
89  case NFTNL_SET_ID:
90  case NFTNL_SET_POLICY:
91  case NFTNL_SET_DESC_SIZE:
92  case NFTNL_SET_TIMEOUT:
93  case NFTNL_SET_GC_INTERVAL:
94  break;
95  default:
96  return;
97  }
98 
99  s->flags &= ~(1 << attr);
100 }
101 EXPORT_SYMBOL_ALIAS(nftnl_set_unset, nft_set_attr_unset);
102 
103 static uint32_t nftnl_set_validate[NFTNL_SET_MAX + 1] = {
104  [NFTNL_SET_FLAGS] = sizeof(uint32_t),
105  [NFTNL_SET_KEY_TYPE] = sizeof(uint32_t),
106  [NFTNL_SET_KEY_LEN] = sizeof(uint32_t),
107  [NFTNL_SET_DATA_TYPE] = sizeof(uint32_t),
108  [NFTNL_SET_DATA_LEN] = sizeof(uint32_t),
109  [NFTNL_SET_FAMILY] = sizeof(uint32_t),
110  [NFTNL_SET_POLICY] = sizeof(uint32_t),
111  [NFTNL_SET_DESC_SIZE] = sizeof(uint32_t),
112  [NFTNL_SET_TIMEOUT] = sizeof(uint64_t),
113  [NFTNL_SET_GC_INTERVAL] = sizeof(uint32_t),
114 };
115 
116 void nftnl_set_set_data(struct nftnl_set *s, uint16_t attr, const void *data,
117  uint32_t data_len)
118 {
119  if (attr > NFTNL_SET_MAX)
120  return;
121 
122  nftnl_assert_validate(data, nftnl_set_validate, attr, data_len);
123 
124  switch(attr) {
125  case NFTNL_SET_TABLE:
126  if (s->table)
127  xfree(s->table);
128 
129  s->table = strdup(data);
130  break;
131  case NFTNL_SET_NAME:
132  if (s->name)
133  xfree(s->name);
134 
135  s->name = strdup(data);
136  break;
137  case NFTNL_SET_FLAGS:
138  s->set_flags = *((uint32_t *)data);
139  break;
140  case NFTNL_SET_KEY_TYPE:
141  s->key_type = *((uint32_t *)data);
142  break;
143  case NFTNL_SET_KEY_LEN:
144  s->key_len = *((uint32_t *)data);
145  break;
146  case NFTNL_SET_DATA_TYPE:
147  s->data_type = *((uint32_t *)data);
148  break;
149  case NFTNL_SET_DATA_LEN:
150  s->data_len = *((uint32_t *)data);
151  break;
152  case NFTNL_SET_FAMILY:
153  s->family = *((uint32_t *)data);
154  break;
155  case NFTNL_SET_ID:
156  s->id = *((uint32_t *)data);
157  break;
158  case NFTNL_SET_POLICY:
159  s->policy = *((uint32_t *)data);
160  break;
161  case NFTNL_SET_DESC_SIZE:
162  s->desc.size = *((uint32_t *)data);
163  break;
164  case NFTNL_SET_TIMEOUT:
165  s->timeout = *((uint64_t *)data);
166  break;
167  case NFTNL_SET_GC_INTERVAL:
168  s->gc_interval = *((uint32_t *)data);
169  break;
170  }
171  s->flags |= (1 << attr);
172 }
173 EXPORT_SYMBOL_ALIAS(nftnl_set_set_data, nft_set_attr_set_data);
174 
175 void nftnl_set_set(struct nftnl_set *s, uint16_t attr, const void *data)
176 {
177  nftnl_set_set_data(s, attr, data, nftnl_set_validate[attr]);
178 }
179 EXPORT_SYMBOL_ALIAS(nftnl_set_set, nft_set_attr_set);
180 
181 void nftnl_set_set_u32(struct nftnl_set *s, uint16_t attr, uint32_t val)
182 {
183  nftnl_set_set(s, attr, &val);
184 }
185 EXPORT_SYMBOL_ALIAS(nftnl_set_set_u32, nft_set_attr_set_u32);
186 
187 void nftnl_set_set_u64(struct nftnl_set *s, uint16_t attr, uint64_t val)
188 {
189  nftnl_set_set(s, attr, &val);
190 }
191 EXPORT_SYMBOL_ALIAS(nftnl_set_set_u64, nft_set_attr_set_u64);
192 
193 void nftnl_set_set_str(struct nftnl_set *s, uint16_t attr, const char *str)
194 {
195  nftnl_set_set(s, attr, str);
196 }
197 EXPORT_SYMBOL_ALIAS(nftnl_set_set_str, nft_set_attr_set_str);
198 
199 const void *nftnl_set_get_data(const struct nftnl_set *s, uint16_t attr,
200  uint32_t *data_len)
201 {
202  if (!(s->flags & (1 << attr)))
203  return NULL;
204 
205  switch(attr) {
206  case NFTNL_SET_TABLE:
207  return s->table;
208  case NFTNL_SET_NAME:
209  return s->name;
210  case NFTNL_SET_FLAGS:
211  *data_len = sizeof(uint32_t);
212  return &s->set_flags;
213  case NFTNL_SET_KEY_TYPE:
214  *data_len = sizeof(uint32_t);
215  return &s->key_type;
216  case NFTNL_SET_KEY_LEN:
217  *data_len = sizeof(uint32_t);
218  return &s->key_len;
219  case NFTNL_SET_DATA_TYPE:
220  *data_len = sizeof(uint32_t);
221  return &s->data_type;
222  case NFTNL_SET_DATA_LEN:
223  *data_len = sizeof(uint32_t);
224  return &s->data_len;
225  case NFTNL_SET_FAMILY:
226  *data_len = sizeof(uint32_t);
227  return &s->family;
228  case NFTNL_SET_ID:
229  *data_len = sizeof(uint32_t);
230  return &s->id;
231  case NFTNL_SET_POLICY:
232  *data_len = sizeof(uint32_t);
233  return &s->policy;
234  case NFTNL_SET_DESC_SIZE:
235  *data_len = sizeof(uint32_t);
236  return &s->desc.size;
237  case NFTNL_SET_TIMEOUT:
238  *data_len = sizeof(uint64_t);
239  return &s->timeout;
240  case NFTNL_SET_GC_INTERVAL:
241  *data_len = sizeof(uint32_t);
242  return &s->gc_interval;
243  }
244  return NULL;
245 }
246 EXPORT_SYMBOL_ALIAS(nftnl_set_get_data, nft_set_attr_get_data);
247 
248 const void *nftnl_set_get(const struct nftnl_set *s, uint16_t attr)
249 {
250  uint32_t data_len;
251  return nftnl_set_get_data(s, attr, &data_len);
252 }
253 EXPORT_SYMBOL_ALIAS(nftnl_set_get, nft_set_attr_get);
254 
255 const char *nftnl_set_get_str(const struct nftnl_set *s, uint16_t attr)
256 {
257  return nftnl_set_get(s, attr);
258 }
259 EXPORT_SYMBOL_ALIAS(nftnl_set_get_str, nft_set_attr_get_str);
260 
261 uint32_t nftnl_set_get_u32(const struct nftnl_set *s, uint16_t attr)
262 {
263  uint32_t data_len;
264  const uint32_t *val = nftnl_set_get_data(s, attr, &data_len);
265 
266  nftnl_assert(val, attr, data_len == sizeof(uint32_t));
267 
268  return val ? *val : 0;
269 }
270 EXPORT_SYMBOL_ALIAS(nftnl_set_get_u32, nft_set_attr_get_u32);
271 
272 uint64_t nftnl_set_get_u64(const struct nftnl_set *s, uint16_t attr)
273 {
274  uint32_t data_len;
275  const uint64_t *val = nftnl_set_get_data(s, attr, &data_len);
276 
277  nftnl_assert(val, attr, data_len == sizeof(uint64_t));
278 
279  return val ? *val : 0;
280 }
281 EXPORT_SYMBOL_ALIAS(nftnl_set_get_u64, nft_set_attr_get_u64);
282 
283 struct nftnl_set *nftnl_set_clone(const struct nftnl_set *set)
284 {
285  struct nftnl_set *newset;
286  struct nftnl_set_elem *elem, *newelem;
287 
288  newset = nftnl_set_alloc();
289  if (newset == NULL)
290  return NULL;
291 
292  memcpy(newset, set, sizeof(*set));
293 
294  if (set->flags & (1 << NFTNL_SET_TABLE))
295  newset->table = strdup(set->table);
296  if (set->flags & (1 << NFTNL_SET_NAME))
297  newset->name = strdup(set->name);
298 
299  INIT_LIST_HEAD(&newset->element_list);
300  list_for_each_entry(elem, &set->element_list, head) {
301  newelem = nftnl_set_elem_clone(elem);
302  if (newelem == NULL)
303  goto err;
304 
305  list_add_tail(&newelem->head, &newset->element_list);
306  }
307 
308  return newset;
309 err:
310  nftnl_set_free(newset);
311  return NULL;
312 }
313 
314 static void
315 nftnl_set_nlmsg_build_desc_payload(struct nlmsghdr *nlh, struct nftnl_set *s)
316 {
317  struct nlattr *nest;
318 
319  nest = mnl_attr_nest_start(nlh, NFTA_SET_DESC);
320  mnl_attr_put_u32(nlh, NFTA_SET_DESC_SIZE, htonl(s->desc.size));
321  mnl_attr_nest_end(nlh, nest);
322 }
323 
324 void nftnl_set_nlmsg_build_payload(struct nlmsghdr *nlh, struct nftnl_set *s)
325 {
326  if (s->flags & (1 << NFTNL_SET_TABLE))
327  mnl_attr_put_strz(nlh, NFTA_SET_TABLE, s->table);
328  if (s->flags & (1 << NFTNL_SET_NAME))
329  mnl_attr_put_strz(nlh, NFTA_SET_NAME, s->name);
330  if (s->flags & (1 << NFTNL_SET_FLAGS))
331  mnl_attr_put_u32(nlh, NFTA_SET_FLAGS, htonl(s->set_flags));
332  if (s->flags & (1 << NFTNL_SET_KEY_TYPE))
333  mnl_attr_put_u32(nlh, NFTA_SET_KEY_TYPE, htonl(s->key_type));
334  if (s->flags & (1 << NFTNL_SET_KEY_LEN))
335  mnl_attr_put_u32(nlh, NFTA_SET_KEY_LEN, htonl(s->key_len));
336  /* These are only used to map matching -> action (1:1) */
337  if (s->flags & (1 << NFTNL_SET_DATA_TYPE))
338  mnl_attr_put_u32(nlh, NFTA_SET_DATA_TYPE, htonl(s->data_type));
339  if (s->flags & (1 << NFTNL_SET_DATA_LEN))
340  mnl_attr_put_u32(nlh, NFTA_SET_DATA_LEN, htonl(s->data_len));
341  if (s->flags & (1 << NFTNL_SET_ID))
342  mnl_attr_put_u32(nlh, NFTA_SET_ID, htonl(s->id));
343  if (s->flags & (1 << NFTNL_SET_POLICY))
344  mnl_attr_put_u32(nlh, NFTA_SET_POLICY, htonl(s->policy));
345  if (s->flags & (1 << NFTNL_SET_DESC_SIZE))
346  nftnl_set_nlmsg_build_desc_payload(nlh, s);
347  if (s->flags & (1 << NFTNL_SET_TIMEOUT))
348  mnl_attr_put_u64(nlh, NFTA_SET_TIMEOUT, htobe64(s->timeout));
349  if (s->flags & (1 << NFTNL_SET_GC_INTERVAL))
350  mnl_attr_put_u32(nlh, NFTA_SET_GC_INTERVAL, htonl(s->gc_interval));
351 }
352 EXPORT_SYMBOL_ALIAS(nftnl_set_nlmsg_build_payload, nft_set_nlmsg_build_payload);
353 
354 static int nftnl_set_parse_attr_cb(const struct nlattr *attr, void *data)
355 {
356  const struct nlattr **tb = data;
357  int type = mnl_attr_get_type(attr);
358 
359  if (mnl_attr_type_valid(attr, NFTA_SET_MAX) < 0)
360  return MNL_CB_OK;
361 
362  switch(type) {
363  case NFTA_SET_TABLE:
364  case NFTA_SET_NAME:
365  if (mnl_attr_validate(attr, MNL_TYPE_STRING) < 0)
366  abi_breakage();
367  break;
368  case NFTA_SET_FLAGS:
369  case NFTA_SET_KEY_TYPE:
370  case NFTA_SET_KEY_LEN:
371  case NFTA_SET_DATA_TYPE:
372  case NFTA_SET_DATA_LEN:
373  case NFTA_SET_ID:
374  case NFTA_SET_POLICY:
375  case NFTA_SET_GC_INTERVAL:
376  if (mnl_attr_validate(attr, MNL_TYPE_U32) < 0)
377  abi_breakage();
378  break;
379  case NFTA_SET_TIMEOUT:
380  if (mnl_attr_validate(attr, MNL_TYPE_U64) < 0)
381  abi_breakage();
382  break;
383  case NFTA_SET_DESC:
384  if (mnl_attr_validate(attr, MNL_TYPE_NESTED) < 0)
385  abi_breakage();
386  break;
387  }
388 
389  tb[type] = attr;
390  return MNL_CB_OK;
391 }
392 
393 static int nftnl_set_desc_parse_attr_cb(const struct nlattr *attr, void *data)
394 {
395  const struct nlattr **tb = data;
396  int type = mnl_attr_get_type(attr);
397 
398  if (mnl_attr_type_valid(attr, NFTA_SET_MAX) < 0)
399  return MNL_CB_OK;
400 
401  switch (type) {
402  case NFTA_SET_DESC_SIZE:
403  if (mnl_attr_validate(attr, MNL_TYPE_U32) < 0)
404  abi_breakage();
405  break;
406  }
407 
408  tb[type] = attr;
409  return MNL_CB_OK;
410 }
411 
412 static int nftnl_set_desc_parse(struct nftnl_set *s,
413  const struct nlattr *attr)
414 {
415  struct nlattr *tb[NFTA_SET_DESC_MAX + 1] = {};
416 
417  if (mnl_attr_parse_nested(attr, nftnl_set_desc_parse_attr_cb, tb) < 0)
418  return -1;
419 
420  if (tb[NFTA_SET_DESC_SIZE]) {
421  s->desc.size = ntohl(mnl_attr_get_u32(tb[NFTA_SET_DESC_SIZE]));
422  s->flags |= (1 << NFTNL_SET_DESC_SIZE);
423  }
424 
425  return 0;
426 }
427 
428 int nftnl_set_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_set *s)
429 {
430  struct nlattr *tb[NFTA_SET_MAX+1] = {};
431  struct nfgenmsg *nfg = mnl_nlmsg_get_payload(nlh);
432  int ret = 0;
433 
434  if (mnl_attr_parse(nlh, sizeof(*nfg), nftnl_set_parse_attr_cb, tb) < 0)
435  return -1;
436 
437  if (tb[NFTA_SET_TABLE]) {
438  xfree(s->table);
439  s->table = strdup(mnl_attr_get_str(tb[NFTA_SET_TABLE]));
440  s->flags |= (1 << NFTNL_SET_TABLE);
441  }
442  if (tb[NFTA_SET_NAME]) {
443  xfree(s->name);
444  s->name = strdup(mnl_attr_get_str(tb[NFTA_SET_NAME]));
445  s->flags |= (1 << NFTNL_SET_NAME);
446  }
447  if (tb[NFTA_SET_FLAGS]) {
448  s->set_flags = ntohl(mnl_attr_get_u32(tb[NFTA_SET_FLAGS]));
449  s->flags |= (1 << NFTNL_SET_FLAGS);
450  }
451  if (tb[NFTA_SET_KEY_TYPE]) {
452  s->key_type = ntohl(mnl_attr_get_u32(tb[NFTA_SET_KEY_TYPE]));
453  s->flags |= (1 << NFTNL_SET_KEY_TYPE);
454  }
455  if (tb[NFTA_SET_KEY_LEN]) {
456  s->key_len = ntohl(mnl_attr_get_u32(tb[NFTA_SET_KEY_LEN]));
457  s->flags |= (1 << NFTNL_SET_KEY_LEN);
458  }
459  if (tb[NFTA_SET_DATA_TYPE]) {
460  s->data_type = ntohl(mnl_attr_get_u32(tb[NFTA_SET_DATA_TYPE]));
461  s->flags |= (1 << NFTNL_SET_DATA_TYPE);
462  }
463  if (tb[NFTA_SET_DATA_LEN]) {
464  s->data_len = ntohl(mnl_attr_get_u32(tb[NFTA_SET_DATA_LEN]));
465  s->flags |= (1 << NFTNL_SET_DATA_LEN);
466  }
467  if (tb[NFTA_SET_ID]) {
468  s->id = ntohl(mnl_attr_get_u32(tb[NFTA_SET_ID]));
469  s->flags |= (1 << NFTNL_SET_ID);
470  }
471  if (tb[NFTA_SET_POLICY]) {
472  s->policy = ntohl(mnl_attr_get_u32(tb[NFTA_SET_POLICY]));
473  s->flags |= (1 << NFTNL_SET_POLICY);
474  }
475  if (tb[NFTA_SET_TIMEOUT]) {
476  s->timeout = be64toh(mnl_attr_get_u64(tb[NFTA_SET_TIMEOUT]));
477  s->flags |= (1 << NFTNL_SET_TIMEOUT);
478  }
479  if (tb[NFTA_SET_GC_INTERVAL]) {
480  s->gc_interval = ntohl(mnl_attr_get_u32(tb[NFTA_SET_GC_INTERVAL]));
481  s->flags |= (1 << NFTNL_SET_GC_INTERVAL);
482  }
483  if (tb[NFTA_SET_DESC])
484  ret = nftnl_set_desc_parse(s, tb[NFTA_SET_DESC]);
485 
486  s->family = nfg->nfgen_family;
487  s->flags |= (1 << NFTNL_SET_FAMILY);
488 
489  return ret;
490 }
491 EXPORT_SYMBOL_ALIAS(nftnl_set_nlmsg_parse, nft_set_nlmsg_parse);
492 
493 #ifdef JSON_PARSING
494 static int nftnl_jansson_parse_set_info(struct nftnl_set *s, json_t *tree,
495  struct nftnl_parse_err *err)
496 {
497  json_t *root = tree, *array, *json_elem;
498  uint32_t flags, key_type, key_len, data_type, data_len, policy, size;
499  int family, i;
500  const char *name, *table;
501  struct nftnl_set_elem *elem;
502 
503  name = nftnl_jansson_parse_str(root, "name", err);
504  if (name == NULL)
505  return -1;
506 
507  nftnl_set_set_str(s, NFTNL_SET_NAME, name);
508 
509  table = nftnl_jansson_parse_str(root, "table", err);
510  if (table == NULL)
511  return -1;
512 
513  nftnl_set_set_str(s, NFTNL_SET_TABLE, table);
514 
515  if (nftnl_jansson_parse_family(root, &family, err) == 0)
516  nftnl_set_set_u32(s, NFTNL_SET_FAMILY, family);
517 
518  if (nftnl_jansson_parse_val(root, "flags", NFTNL_TYPE_U32, &flags, err) == 0)
519  nftnl_set_set_u32(s, NFTNL_SET_FLAGS, flags);
520 
521  if (nftnl_jansson_parse_val(root, "key_type", NFTNL_TYPE_U32, &key_type,
522  err) == 0)
523  nftnl_set_set_u32(s, NFTNL_SET_KEY_TYPE, key_type);
524 
525  if (nftnl_jansson_parse_val(root, "key_len", NFTNL_TYPE_U32, &key_len,
526  err) == 0)
527  nftnl_set_set_u32(s, NFTNL_SET_KEY_LEN, key_len);
528 
529  if (nftnl_jansson_node_exist(root, "data_type")) {
530  if (nftnl_jansson_parse_val(root, "data_type", NFTNL_TYPE_U32,
531  &data_type, err) < 0)
532  return -1;
533 
534  nftnl_set_set_u32(s, NFTNL_SET_DATA_TYPE, data_type);
535  }
536 
537  if (nftnl_jansson_node_exist(root, "data_len")) {
538  if (nftnl_jansson_parse_val(root, "data_len", NFTNL_TYPE_U32,
539  &data_len, err) < 0)
540  return -1;
541 
542  nftnl_set_set_u32(s, NFTNL_SET_DATA_LEN, data_len);
543  }
544 
545  if (nftnl_jansson_node_exist(root, "policy")) {
546  if (nftnl_jansson_parse_val(root, "policy", NFTNL_TYPE_U32,
547  &policy, err) < 0)
548  return -1;
549 
550  nftnl_set_set_u32(s, NFTNL_SET_POLICY, policy);
551  }
552 
553  if (nftnl_jansson_node_exist(root, "desc_size")) {
554  if (nftnl_jansson_parse_val(root, "desc_size", NFTNL_TYPE_U32,
555  &size, err) < 0)
556  return -1;
557 
558  nftnl_set_set_u32(s, NFTNL_SET_DESC_SIZE, size);
559  }
560 
561  if (nftnl_jansson_node_exist(root, "set_elem")) {
562  array = json_object_get(root, "set_elem");
563  for (i = 0; i < json_array_size(array); i++) {
564  elem = nftnl_set_elem_alloc();
565  if (elem == NULL)
566  return -1;
567 
568  json_elem = json_array_get(array, i);
569  if (json_elem == NULL)
570  return -1;
571 
572  if (nftnl_jansson_set_elem_parse(elem,
573  json_elem, err) < 0)
574  return -1;
575 
576  list_add_tail(&elem->head, &s->element_list);
577  }
578 
579  }
580 
581  return 0;
582 }
583 
584 int nftnl_jansson_parse_set(struct nftnl_set *s, json_t *tree,
585  struct nftnl_parse_err *err)
586 {
587  json_t *root;
588 
589  root = nftnl_jansson_get_node(tree, "set", err);
590  if (root == NULL)
591  return -1;
592 
593  return nftnl_jansson_parse_set_info(s, root, err);
594 }
595 
596 int nftnl_jansson_parse_elem(struct nftnl_set *s, json_t *tree,
597  struct nftnl_parse_err *err)
598 {
599  json_t *root;
600 
601  root = nftnl_jansson_get_node(tree, "element", err);
602  if (root == NULL)
603  return -1;
604 
605  return nftnl_jansson_parse_set_info(s, root, err);
606 }
607 #endif
608 
609 static int nftnl_set_json_parse(struct nftnl_set *s, const void *json,
610  struct nftnl_parse_err *err,
611  enum nftnl_parse_input input)
612 {
613 #ifdef JSON_PARSING
614  json_t *tree;
615  json_error_t error;
616  int ret;
617 
618  tree = nftnl_jansson_create_root(json, &error, err, input);
619  if (tree == NULL)
620  return -1;
621 
622  ret = nftnl_jansson_parse_set(s, tree, err);
623  nftnl_jansson_free_root(tree);
624 
625  return ret;
626 #else
627  errno = EOPNOTSUPP;
628  return -1;
629 #endif
630 }
631 
632 #ifdef XML_PARSING
633 int nftnl_mxml_set_parse(mxml_node_t *tree, struct nftnl_set *s,
634  struct nftnl_parse_err *err)
635 {
636  mxml_node_t *node = NULL;
637  struct nftnl_set_elem *elem;
638  const char *name, *table;
639  int family;
640  uint32_t set_flags, key_type, key_len;
641  uint32_t data_type, data_len, policy, size;
642 
643  name = nftnl_mxml_str_parse(tree, "name", MXML_DESCEND_FIRST,
644  NFTNL_XML_MAND, err);
645  if (name == NULL)
646  return -1;
647  nftnl_set_set_str(s, NFTNL_SET_NAME, name);
648 
649  table = nftnl_mxml_str_parse(tree, "table", MXML_DESCEND_FIRST,
650  NFTNL_XML_MAND, err);
651  if (table == NULL)
652  return -1;
653  nftnl_set_set_str(s, NFTNL_SET_TABLE, table);
654 
655  family = nftnl_mxml_family_parse(tree, "family", MXML_DESCEND_FIRST,
656  NFTNL_XML_MAND, err);
657  if (family >= 0)
658  nftnl_set_set_u32(s, NFTNL_SET_FAMILY, family);
659 
660  if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND_FIRST, BASE_DEC,
661  &set_flags, NFTNL_TYPE_U32, NFTNL_XML_MAND,
662  err) == 0)
663  nftnl_set_set_u32(s, NFTNL_SET_FLAGS, set_flags);
664 
665  if (nftnl_mxml_num_parse(tree, "key_type", MXML_DESCEND_FIRST, BASE_DEC,
666  &key_type, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0)
667  nftnl_set_set_u32(s, NFTNL_SET_KEY_TYPE, key_type);
668 
669  if (nftnl_mxml_num_parse(tree, "key_len", MXML_DESCEND_FIRST, BASE_DEC,
670  &key_len, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) < 0)
671  return -1;
672  nftnl_set_set_u32(s, NFTNL_SET_KEY_LEN, key_len);
673 
674  if (nftnl_mxml_num_parse(tree, "data_type", MXML_DESCEND_FIRST, BASE_DEC,
675  &data_type, NFTNL_TYPE_U32,
676  NFTNL_XML_OPT, err) == 0) {
677  nftnl_set_set_u32(s, NFTNL_SET_DATA_TYPE, data_type);
678 
679  if (nftnl_mxml_num_parse(tree, "data_len", MXML_DESCEND_FIRST,
680  BASE_DEC, &data_len, NFTNL_TYPE_U32,
681  NFTNL_XML_MAND, err) == 0)
682  nftnl_set_set_u32(s, NFTNL_SET_DATA_LEN, data_len);
683 
684  }
685 
686  if (nftnl_mxml_num_parse(tree, "policy", MXML_DESCEND_FIRST,
687  BASE_DEC, &policy, NFTNL_TYPE_U32,
688  NFTNL_XML_OPT, err) == 0)
689  nftnl_set_set_u32(s, NFTNL_SET_POLICY, policy);
690 
691  if (nftnl_mxml_num_parse(tree, "desc_size", MXML_DESCEND_FIRST,
692  BASE_DEC, &size, NFTNL_TYPE_U32,
693  NFTNL_XML_OPT, err) == 0)
694  nftnl_set_set_u32(s, NFTNL_SET_DESC_SIZE, policy);
695 
696  for (node = mxmlFindElement(tree, tree, "set_elem", NULL,
697  NULL, MXML_DESCEND);
698  node != NULL;
699  node = mxmlFindElement(node, tree, "set_elem", NULL,
700  NULL, MXML_DESCEND)) {
701 
702  elem = nftnl_set_elem_alloc();
703  if (elem == NULL)
704  return -1;
705 
706  if (nftnl_mxml_set_elem_parse(node, elem, err) < 0)
707  return -1;
708 
709  list_add_tail(&elem->head, &s->element_list);
710  }
711 
712  return 0;
713 }
714 #endif
715 
716 static int nftnl_set_xml_parse(struct nftnl_set *s, const void *xml,
717  struct nftnl_parse_err *err,
718  enum nftnl_parse_input input)
719 {
720 #ifdef XML_PARSING
721  int ret;
722  mxml_node_t *tree = nftnl_mxml_build_tree(xml, "set", err, input);
723  if (tree == NULL)
724  return -1;
725 
726  ret = nftnl_mxml_set_parse(tree, s, err);
727  mxmlDelete(tree);
728  return ret;
729 #else
730  errno = EOPNOTSUPP;
731  return -1;
732 #endif
733 }
734 
735 static int nftnl_set_do_parse(struct nftnl_set *s, enum nftnl_parse_type type,
736  const void *data, struct nftnl_parse_err *err,
737  enum nftnl_parse_input input)
738 {
739  int ret;
740  struct nftnl_parse_err perr;
741 
742  switch (type) {
743  case NFTNL_PARSE_XML:
744  ret = nftnl_set_xml_parse(s, data, &perr, input);
745  break;
746  case NFTNL_PARSE_JSON:
747  ret = nftnl_set_json_parse(s, data, &perr, input);
748  break;
749  default:
750  ret = -1;
751  errno = EOPNOTSUPP;
752  break;
753  }
754 
755  if (err != NULL)
756  *err = perr;
757 
758  return ret;
759 }
760 int nftnl_set_parse(struct nftnl_set *s, enum nftnl_parse_type type,
761  const char *data, struct nftnl_parse_err *err)
762 {
763  return nftnl_set_do_parse(s, type, data, err, NFTNL_PARSE_BUFFER);
764 }
765 EXPORT_SYMBOL_ALIAS(nftnl_set_parse, nft_set_parse);
766 
767 int nftnl_set_parse_file(struct nftnl_set *s, enum nftnl_parse_type type,
768  FILE *fp, struct nftnl_parse_err *err)
769 {
770  return nftnl_set_do_parse(s, type, fp, err, NFTNL_PARSE_FILE);
771 }
772 EXPORT_SYMBOL_ALIAS(nftnl_set_parse_file, nft_set_parse_file);
773 
774 static int nftnl_set_snprintf_json(char *buf, size_t size,
775  const struct nftnl_set *s,
776  uint32_t type, uint32_t flags)
777 {
778  int len = size, offset = 0, ret;
779  struct nftnl_set_elem *elem;
780 
781  ret = snprintf(buf, len, "{\"set\":{");
782  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
783 
784  if (s->flags & (1 << NFTNL_SET_NAME)) {
785  ret = snprintf(buf + offset, len, "\"name\":\"%s\"",
786  s->name);
787  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
788  }
789  if (s->flags & (1 << NFTNL_SET_TABLE)) {
790  ret = snprintf(buf + offset, len, ",\"table\":\"%s\"",
791  s->table);
792  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
793  }
794  if (s->flags & (1 << NFTNL_SET_FLAGS)) {
795  ret = snprintf(buf + offset, len, ",\"flags\":%u",
796  s->set_flags);
797  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
798  }
799  if (s->flags & (1 << NFTNL_SET_FAMILY)) {
800  ret = snprintf(buf + offset, len, ",\"family\":\"%s\"",
801  nftnl_family2str(s->family));
802  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
803  }
804  if (s->flags & (1 << NFTNL_SET_KEY_TYPE)) {
805  ret = snprintf(buf + offset, len, ",\"key_type\":%u",
806  s->key_type);
807  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
808  }
809  if (s->flags & (1 << NFTNL_SET_KEY_LEN)) {
810  ret = snprintf(buf + offset, len, ",\"key_len\":%u",
811  s->key_len);
812  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
813  }
814  if(s->flags & (1 << NFTNL_SET_DATA_TYPE)) {
815  ret = snprintf(buf + offset, len,
816  ",\"data_type\":%u", s->data_type);
817  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
818  }
819  if(s->flags & (1 << NFTNL_SET_DATA_LEN)) {
820  ret = snprintf(buf + offset, len, ",\"data_len\":%u", s->data_len);
821  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
822  }
823 
824  if (s->flags & (1 << NFTNL_SET_POLICY)) {
825  ret = snprintf(buf + offset, len, ",\"policy\":%u",
826  s->policy);
827  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
828  }
829 
830  if (s->flags & (1 << NFTNL_SET_DESC_SIZE)) {
831  ret = snprintf(buf + offset, len, ",\"desc_size\":%u",
832  s->desc.size);
833  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
834  }
835 
836  /* Empty set? Skip printinf of elements */
837  if (list_empty(&s->element_list)){
838  ret = snprintf(buf + offset, len, "}}");
839  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
840  return offset;
841  }
842 
843  ret = snprintf(buf + offset, len, ",\"set_elem\":[");
844  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
845 
846  list_for_each_entry(elem, &s->element_list, head) {
847  ret = snprintf(buf + offset, len, "{");
848  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
849 
850  ret = nftnl_set_elem_snprintf(buf + offset, len, elem, type,
851  flags);
852  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
853 
854  ret = snprintf(buf + offset, len, "},");
855  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
856  }
857  /* Overwrite trailing ", " from last set element */
858  offset --;
859 
860  ret = snprintf(buf + offset, len, "]}}");
861  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
862 
863  return offset;
864 }
865 
866 static int nftnl_set_snprintf_default(char *buf, size_t size,
867  const struct nftnl_set *s,
868  uint32_t type, uint32_t flags)
869 {
870  int ret;
871  int len = size, offset = 0;
872  struct nftnl_set_elem *elem;
873 
874  ret = snprintf(buf, len, "%s %s %x",
875  s->name, s->table, s->set_flags);
876  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
877 
878  if (s->flags & (1 << NFTNL_SET_TIMEOUT)) {
879  ret = snprintf(buf + offset, len, " timeout %"PRIu64"ms",
880  s->timeout);
881  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
882  }
883 
884  if (s->flags & (1 << NFTNL_SET_GC_INTERVAL)) {
885  ret = snprintf(buf + offset, len, " gc_interval %ums",
886  s->gc_interval);
887  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
888  }
889 
890  if (s->flags & (1 << NFTNL_SET_POLICY)) {
891  ret = snprintf(buf + offset, len, " policy %u", s->policy);
892  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
893  }
894 
895  if (s->flags & (1 << NFTNL_SET_DESC_SIZE)) {
896  ret = snprintf(buf + offset, len, " size %u", s->desc.size);
897  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
898  }
899 
900  /* Empty set? Skip printinf of elements */
901  if (list_empty(&s->element_list))
902  return offset;
903 
904  ret = snprintf(buf+offset, len, "\n");
905  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
906 
907  list_for_each_entry(elem, &s->element_list, head) {
908  ret = snprintf(buf+offset, len, "\t");
909  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
910 
911  ret = nftnl_set_elem_snprintf(buf+offset, len, elem, type, flags);
912  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
913  }
914 
915  return offset;
916 }
917 
918 static int nftnl_set_snprintf_xml(char *buf, size_t size,
919  const struct nftnl_set *s, uint32_t flags)
920 {
921  int ret;
922  int len = size, offset = 0;
923  struct nftnl_set_elem *elem;
924 
925  ret = snprintf(buf, len, "<set>");
926  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
927 
928  if (s->flags & (1 << NFTNL_SET_FAMILY)) {
929  ret = snprintf(buf + offset, len, "<family>%s</family>",
930  nftnl_family2str(s->family));
931  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
932  }
933 
934  if (s->flags & (1 << NFTNL_SET_TABLE)) {
935  ret = snprintf(buf + offset, len, "<table>%s</table>",
936  s->table);
937  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
938  }
939 
940  if (s->flags & (1 << NFTNL_SET_NAME)) {
941  ret = snprintf(buf + offset, len, "<name>%s</name>",
942  s->name);
943  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
944  }
945 
946  if (s->flags & (1 << NFTNL_SET_FLAGS)) {
947  ret = snprintf(buf + offset, len, "<flags>%u</flags>",
948  s->set_flags);
949  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
950  }
951  if (s->flags & (1 << NFTNL_SET_KEY_TYPE)) {
952  ret = snprintf(buf + offset, len, "<key_type>%u</key_type>",
953  s->key_type);
954  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
955  }
956  if (s->flags & (1 << NFTNL_SET_KEY_LEN)) {
957  ret = snprintf(buf + offset, len, "<key_len>%u</key_len>",
958  s->key_len);
959  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
960  }
961 
962  if (s->flags & (1 << NFTNL_SET_DATA_TYPE)) {
963  ret = snprintf(buf + offset, len, "<data_type>%u</data_type>",
964  s->data_type);
965  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
966  }
967  if (s->flags & (1 << NFTNL_SET_DATA_LEN)) {
968  ret = snprintf(buf + offset, len, "<data_len>%u</data_len>",
969  s->data_len);
970  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
971  }
972 
973  if (s->flags & (1 << NFTNL_SET_POLICY)) {
974  ret = snprintf(buf + offset, len, "<policy>%u</policy>",
975  s->policy);
976  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
977  }
978 
979  if (s->flags & (1 << NFTNL_SET_DESC_SIZE)) {
980  ret = snprintf(buf + offset, len, "<desc_size>%u</desc_size>",
981  s->desc.size);
982  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
983  }
984 
985  if (!list_empty(&s->element_list)) {
986  list_for_each_entry(elem, &s->element_list, head) {
987  ret = nftnl_set_elem_snprintf(buf + offset, len, elem,
988  NFTNL_OUTPUT_XML, flags);
989  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
990  }
991  }
992 
993  ret = snprintf(buf + offset, len, "</set>");
994  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
995 
996  return offset;
997 }
998 
999 static int nftnl_set_cmd_snprintf(char *buf, size_t size,
1000  const struct nftnl_set *s, uint32_t cmd,
1001  uint32_t type, uint32_t flags)
1002 {
1003  int ret, len = size, offset = 0;
1004  uint32_t inner_flags = flags;
1005 
1006  /* prevent set_elems to print as events */
1007  inner_flags &= ~NFTNL_OF_EVENT_ANY;
1008 
1009  ret = nftnl_cmd_header_snprintf(buf + offset, len, cmd, type, flags);
1010  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
1011 
1012  switch(type) {
1013  case NFTNL_OUTPUT_DEFAULT:
1014  ret = nftnl_set_snprintf_default(buf+offset, len, s, type,
1015  inner_flags);
1016  break;
1017  case NFTNL_OUTPUT_XML:
1018  ret = nftnl_set_snprintf_xml(buf+offset, len, s, inner_flags);
1019  break;
1020  case NFTNL_OUTPUT_JSON:
1021  ret = nftnl_set_snprintf_json(buf+offset, len, s, type,
1022  inner_flags);
1023  break;
1024  default:
1025  return -1;
1026  }
1027 
1028  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
1029 
1030  ret = nftnl_cmd_footer_snprintf(buf + offset, len, cmd, type, flags);
1031  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
1032 
1033  return offset;
1034 }
1035 
1036 int nftnl_set_snprintf(char *buf, size_t size, const struct nftnl_set *s,
1037  uint32_t type, uint32_t flags)
1038 {
1039  return nftnl_set_cmd_snprintf(buf, size, s, nftnl_flag2cmd(flags), type,
1040  flags);
1041 }
1042 EXPORT_SYMBOL_ALIAS(nftnl_set_snprintf, nft_set_snprintf);
1043 
1044 static int nftnl_set_do_snprintf(char *buf, size_t size, const void *s,
1045  uint32_t cmd, uint32_t type, uint32_t flags)
1046 {
1047  return nftnl_set_snprintf(buf, size, s, type, flags);
1048 }
1049 
1050 int nftnl_set_fprintf(FILE *fp, const struct nftnl_set *s, uint32_t type,
1051  uint32_t flags)
1052 {
1053  return nftnl_fprintf(fp, s, NFTNL_CMD_UNSPEC, type, flags,
1054  nftnl_set_do_snprintf);
1055 }
1056 EXPORT_SYMBOL_ALIAS(nftnl_set_fprintf, nft_set_fprintf);
1057 
1058 void nftnl_set_elem_add(struct nftnl_set *s, struct nftnl_set_elem *elem)
1059 {
1060  list_add_tail(&elem->head, &s->element_list);
1061 }
1062 EXPORT_SYMBOL_ALIAS(nftnl_set_elem_add, nft_set_elem_add);
1063 
1065  struct list_head list;
1066 };
1067 
1068 struct nftnl_set_list *nftnl_set_list_alloc(void)
1069 {
1070  struct nftnl_set_list *list;
1071 
1072  list = calloc(1, sizeof(struct nftnl_set_list));
1073  if (list == NULL)
1074  return NULL;
1075 
1076  INIT_LIST_HEAD(&list->list);
1077 
1078  return list;
1079 }
1080 EXPORT_SYMBOL_ALIAS(nftnl_set_list_alloc, nft_set_list_alloc);
1081 
1082 void nftnl_set_list_free(struct nftnl_set_list *list)
1083 {
1084  struct nftnl_set *s, *tmp;
1085 
1086  list_for_each_entry_safe(s, tmp, &list->list, head) {
1087  list_del(&s->head);
1088  nftnl_set_free(s);
1089  }
1090  xfree(list);
1091 }
1092 EXPORT_SYMBOL_ALIAS(nftnl_set_list_free, nft_set_list_free);
1093 
1094 int nftnl_set_list_is_empty(const struct nftnl_set_list *list)
1095 {
1096  return list_empty(&list->list);
1097 }
1098 EXPORT_SYMBOL_ALIAS(nftnl_set_list_is_empty, nft_set_list_is_empty);
1099 
1100 void nftnl_set_list_add(struct nftnl_set *s, struct nftnl_set_list *list)
1101 {
1102  list_add(&s->head, &list->list);
1103 }
1104 EXPORT_SYMBOL_ALIAS(nftnl_set_list_add, nft_set_list_add);
1105 
1106 void nftnl_set_list_add_tail(struct nftnl_set *s, struct nftnl_set_list *list)
1107 {
1108  list_add_tail(&s->head, &list->list);
1109 }
1110 EXPORT_SYMBOL_ALIAS(nftnl_set_list_add_tail, nft_set_list_add_tail);
1111 
1112 void nftnl_set_list_del(struct nftnl_set *s)
1113 {
1114  list_del(&s->head);
1115 }
1116 EXPORT_SYMBOL_ALIAS(nftnl_set_list_del, nft_set_list_del);
1117 
1118 int nftnl_set_list_foreach(struct nftnl_set_list *set_list,
1119  int (*cb)(struct nftnl_set *t, void *data), void *data)
1120 {
1121  struct nftnl_set *cur, *tmp;
1122  int ret;
1123 
1124  list_for_each_entry_safe(cur, tmp, &set_list->list, head) {
1125  ret = cb(cur, data);
1126  if (ret < 0)
1127  return ret;
1128  }
1129  return 0;
1130 }
1131 EXPORT_SYMBOL_ALIAS(nftnl_set_list_foreach, nft_set_list_foreach);
1132 
1134  struct nftnl_set_list *list;
1135  struct nftnl_set *cur;
1136 };
1137 
1138 struct nftnl_set_list_iter *nftnl_set_list_iter_create(struct nftnl_set_list *l)
1139 {
1140  struct nftnl_set_list_iter *iter;
1141 
1142  iter = calloc(1, sizeof(struct nftnl_set_list_iter));
1143  if (iter == NULL)
1144  return NULL;
1145 
1146  iter->list = l;
1147  if (nftnl_set_list_is_empty(l))
1148  iter->cur = NULL;
1149  else
1150  iter->cur = list_entry(l->list.next, struct nftnl_set, head);
1151 
1152  return iter;
1153 }
1154 EXPORT_SYMBOL_ALIAS(nftnl_set_list_iter_create, nft_set_list_iter_create);
1155 
1156 struct nftnl_set *nftnl_set_list_iter_cur(struct nftnl_set_list_iter *iter)
1157 {
1158  return iter->cur;
1159 }
1160 EXPORT_SYMBOL_ALIAS(nftnl_set_list_iter_cur, nft_set_list_iter_cur);
1161 
1162 struct nftnl_set *nftnl_set_list_iter_next(struct nftnl_set_list_iter *iter)
1163 {
1164  struct nftnl_set *s = iter->cur;
1165 
1166  if (s == NULL)
1167  return NULL;
1168 
1169  /* get next rule, if any */
1170  iter->cur = list_entry(iter->cur->head.next, struct nftnl_set, head);
1171  if (&iter->cur->head == iter->list->list.next)
1172  return NULL;
1173 
1174  return s;
1175 }
1176 EXPORT_SYMBOL_ALIAS(nftnl_set_list_iter_next, nft_set_list_iter_next);
1177 
1178 void nftnl_set_list_iter_destroy(const struct nftnl_set_list_iter *iter)
1179 {
1180  xfree(iter);
1181 }
1182 EXPORT_SYMBOL_ALIAS(nftnl_set_list_iter_destroy, nft_set_list_iter_destroy);
1183 
1184 static struct nftnl_set *nftnl_set_lookup(const char *this_set_name,
1185  struct nftnl_set_list *set_list)
1186 {
1187  struct nftnl_set_list_iter *iter;
1188  struct nftnl_set *s;
1189  const char *set_name;
1190 
1191  iter = nftnl_set_list_iter_create(set_list);
1192  if (iter == NULL)
1193  return NULL;
1194 
1195  s = nftnl_set_list_iter_cur(iter);
1196  while (s != NULL) {
1197  set_name = nftnl_set_get_str(s, NFTNL_SET_NAME);
1198  if (strcmp(this_set_name, set_name) == 0)
1199  break;
1200 
1201  s = nftnl_set_list_iter_next(iter);
1202  }
1203  nftnl_set_list_iter_destroy(iter);
1204 
1205  return s;
1206 }
1207 
1208 int nftnl_set_lookup_id(struct nftnl_expr *e,
1209  struct nftnl_set_list *set_list, uint32_t *set_id)
1210 {
1211  const char *set_name;
1212  struct nftnl_set *s;
1213 
1214  set_name = nftnl_expr_get_str(e, NFTNL_EXPR_LOOKUP_SET);
1215  if (set_name == NULL)
1216  return 0;
1217 
1218  s = nftnl_set_lookup(set_name, set_list);
1219  if (s == NULL)
1220  return 0;
1221 
1222  *set_id = nftnl_set_get_u32(s, NFTNL_SET_ID);
1223  return 1;
1224 }