libnftnl  1.0.5
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(nftnl_set_alloc, nft_set_alloc);
42 
43 void nftnl_set_free(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(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(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(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(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(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(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(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(nftnl_set_set_str, nft_set_attr_set_str);
198 
199 const void *nftnl_set_get_data(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(nftnl_set_get_data, nft_set_attr_get_data);
247 
248 const void *nftnl_set_get(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(nftnl_set_get, nft_set_attr_get);
254 
255 const char *nftnl_set_get_str(struct nftnl_set *s, uint16_t attr)
256 {
257  return nftnl_set_get(s, attr);
258 }
259 EXPORT_SYMBOL(nftnl_set_get_str, nft_set_attr_get_str);
260 
261 uint32_t nftnl_set_get_u32(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(nftnl_set_get_u32, nft_set_attr_get_u32);
271 
272 uint64_t nftnl_set_get_u64(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(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(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(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(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(nftnl_set_parse_file, nft_set_parse_file);
773 
774 static int nftnl_set_snprintf_json(char *buf, size_t size, struct nftnl_set *s,
775  uint32_t type, uint32_t flags)
776 {
777  int len = size, offset = 0, ret;
778  struct nftnl_set_elem *elem;
779 
780  ret = snprintf(buf, len, "{\"set\":{");
781  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
782 
783  if (s->flags & (1 << NFTNL_SET_NAME)) {
784  ret = snprintf(buf + offset, len, "\"name\":\"%s\"",
785  s->name);
786  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
787  }
788  if (s->flags & (1 << NFTNL_SET_TABLE)) {
789  ret = snprintf(buf + offset, len, ",\"table\":\"%s\"",
790  s->table);
791  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
792  }
793  if (s->flags & (1 << NFTNL_SET_FLAGS)) {
794  ret = snprintf(buf + offset, len, ",\"flags\":%u",
795  s->set_flags);
796  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
797  }
798  if (s->flags & (1 << NFTNL_SET_FAMILY)) {
799  ret = snprintf(buf + offset, len, ",\"family\":\"%s\"",
800  nftnl_family2str(s->family));
801  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
802  }
803  if (s->flags & (1 << NFTNL_SET_KEY_TYPE)) {
804  ret = snprintf(buf + offset, len, ",\"key_type\":%u",
805  s->key_type);
806  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
807  }
808  if (s->flags & (1 << NFTNL_SET_KEY_LEN)) {
809  ret = snprintf(buf + offset, len, ",\"key_len\":%u",
810  s->key_len);
811  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
812  }
813  if(s->flags & (1 << NFTNL_SET_DATA_TYPE)) {
814  ret = snprintf(buf + offset, len,
815  ",\"data_type\":%u", s->data_type);
816  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
817  }
818  if(s->flags & (1 << NFTNL_SET_DATA_LEN)) {
819  ret = snprintf(buf + offset, len, ",\"data_len\":%u", s->data_len);
820  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
821  }
822 
823  if (s->flags & (1 << NFTNL_SET_POLICY)) {
824  ret = snprintf(buf + offset, len, ",\"policy\":%u",
825  s->policy);
826  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
827  }
828 
829  if (s->flags & (1 << NFTNL_SET_DESC_SIZE)) {
830  ret = snprintf(buf + offset, len, ",\"desc_size\":%u",
831  s->desc.size);
832  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
833  }
834 
835  /* Empty set? Skip printinf of elements */
836  if (list_empty(&s->element_list)){
837  ret = snprintf(buf + offset, len, "}}");
838  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
839  return offset;
840  }
841 
842  ret = snprintf(buf + offset, len, ",\"set_elem\":[");
843  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
844 
845  list_for_each_entry(elem, &s->element_list, head) {
846  ret = snprintf(buf + offset, len, "{");
847  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
848 
849  ret = nftnl_set_elem_snprintf(buf + offset, len, elem, type,
850  flags);
851  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
852 
853  ret = snprintf(buf + offset, len, "},");
854  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
855  }
856  /* Overwrite trailing ", " from last set element */
857  offset --;
858 
859  ret = snprintf(buf + offset, len, "]}}");
860  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
861 
862  return offset;
863 }
864 
865 static int nftnl_set_snprintf_default(char *buf, size_t size, struct nftnl_set *s,
866  uint32_t type, uint32_t flags)
867 {
868  int ret;
869  int len = size, offset = 0;
870  struct nftnl_set_elem *elem;
871 
872  ret = snprintf(buf, len, "%s %s %x",
873  s->name, s->table, s->set_flags);
874  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
875 
876  if (s->flags & (1 << NFTNL_SET_TIMEOUT)) {
877  ret = snprintf(buf + offset, len, " timeout %"PRIu64"ms",
878  s->timeout);
879  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
880  }
881 
882  if (s->flags & (1 << NFTNL_SET_GC_INTERVAL)) {
883  ret = snprintf(buf + offset, len, " gc_interval %ums",
884  s->gc_interval);
885  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
886  }
887 
888  if (s->flags & (1 << NFTNL_SET_POLICY)) {
889  ret = snprintf(buf + offset, len, " policy %u", s->policy);
890  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
891  }
892 
893  if (s->flags & (1 << NFTNL_SET_DESC_SIZE)) {
894  ret = snprintf(buf + offset, len, " size %u", s->desc.size);
895  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
896  }
897 
898  /* Empty set? Skip printinf of elements */
899  if (list_empty(&s->element_list))
900  return offset;
901 
902  ret = snprintf(buf+offset, len, "\n");
903  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
904 
905  list_for_each_entry(elem, &s->element_list, head) {
906  ret = snprintf(buf+offset, len, "\t");
907  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
908 
909  ret = nftnl_set_elem_snprintf(buf+offset, len, elem, type, flags);
910  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
911  }
912 
913  return offset;
914 }
915 
916 static int nftnl_set_snprintf_xml(char *buf, size_t size, struct nftnl_set *s,
917  uint32_t flags)
918 {
919  int ret;
920  int len = size, offset = 0;
921  struct nftnl_set_elem *elem;
922 
923  ret = snprintf(buf, len, "<set>");
924  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
925 
926  if (s->flags & (1 << NFTNL_SET_FAMILY)) {
927  ret = snprintf(buf + offset, len, "<family>%s</family>",
928  nftnl_family2str(s->family));
929  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
930  }
931 
932  if (s->flags & (1 << NFTNL_SET_TABLE)) {
933  ret = snprintf(buf + offset, len, "<table>%s</table>",
934  s->table);
935  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
936  }
937 
938  if (s->flags & (1 << NFTNL_SET_NAME)) {
939  ret = snprintf(buf + offset, len, "<name>%s</name>",
940  s->name);
941  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
942  }
943 
944  if (s->flags & (1 << NFTNL_SET_FLAGS)) {
945  ret = snprintf(buf + offset, len, "<flags>%u</flags>",
946  s->set_flags);
947  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
948  }
949  if (s->flags & (1 << NFTNL_SET_KEY_TYPE)) {
950  ret = snprintf(buf + offset, len, "<key_type>%u</key_type>",
951  s->key_type);
952  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
953  }
954  if (s->flags & (1 << NFTNL_SET_KEY_LEN)) {
955  ret = snprintf(buf + offset, len, "<key_len>%u</key_len>",
956  s->key_len);
957  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
958  }
959 
960  if (s->flags & (1 << NFTNL_SET_DATA_TYPE)) {
961  ret = snprintf(buf + offset, len, "<data_type>%u</data_type>",
962  s->data_type);
963  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
964  }
965  if (s->flags & (1 << NFTNL_SET_DATA_LEN)) {
966  ret = snprintf(buf + offset, len, "<data_len>%u</data_len>",
967  s->data_len);
968  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
969  }
970 
971  if (s->flags & (1 << NFTNL_SET_POLICY)) {
972  ret = snprintf(buf + offset, len, "<policy>%u</policy>",
973  s->policy);
974  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
975  }
976 
977  if (s->flags & (1 << NFTNL_SET_DESC_SIZE)) {
978  ret = snprintf(buf + offset, len, "<desc_size>%u</desc_size>",
979  s->desc.size);
980  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
981  }
982 
983  if (!list_empty(&s->element_list)) {
984  list_for_each_entry(elem, &s->element_list, head) {
985  ret = nftnl_set_elem_snprintf(buf + offset, len, elem,
986  NFTNL_OUTPUT_XML, flags);
987  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
988  }
989  }
990 
991  ret = snprintf(buf + offset, len, "</set>");
992  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
993 
994  return offset;
995 }
996 
997 static int nftnl_set_cmd_snprintf(char *buf, size_t size, struct nftnl_set *s,
998  uint32_t cmd, uint32_t type, uint32_t flags)
999 {
1000  int ret, len = size, offset = 0;
1001  uint32_t inner_flags = flags;
1002 
1003  /* prevent set_elems to print as events */
1004  inner_flags &= ~NFTNL_OF_EVENT_ANY;
1005 
1006  ret = nftnl_cmd_header_snprintf(buf + offset, len, cmd, type, flags);
1007  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
1008 
1009  switch(type) {
1010  case NFTNL_OUTPUT_DEFAULT:
1011  ret = nftnl_set_snprintf_default(buf+offset, len, s, type,
1012  inner_flags);
1013  break;
1014  case NFTNL_OUTPUT_XML:
1015  ret = nftnl_set_snprintf_xml(buf+offset, len, s, inner_flags);
1016  break;
1017  case NFTNL_OUTPUT_JSON:
1018  ret = nftnl_set_snprintf_json(buf+offset, len, s, type,
1019  inner_flags);
1020  break;
1021  default:
1022  return -1;
1023  }
1024 
1025  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
1026 
1027  ret = nftnl_cmd_footer_snprintf(buf + offset, len, cmd, type, flags);
1028  SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
1029 
1030  return offset;
1031 }
1032 
1033 int nftnl_set_snprintf(char *buf, size_t size, struct nftnl_set *s,
1034  uint32_t type, uint32_t flags)
1035 {
1036  return nftnl_set_cmd_snprintf(buf, size, s, nftnl_flag2cmd(flags), type,
1037  flags);
1038 }
1039 EXPORT_SYMBOL(nftnl_set_snprintf, nft_set_snprintf);
1040 
1041 static inline int nftnl_set_do_snprintf(char *buf, size_t size, void *s,
1042  uint32_t cmd, uint32_t type,
1043  uint32_t flags)
1044 {
1045  return nftnl_set_snprintf(buf, size, s, type, flags);
1046 }
1047 
1048 int nftnl_set_fprintf(FILE *fp, struct nftnl_set *s, uint32_t type,
1049  uint32_t flags)
1050 {
1051  return nftnl_fprintf(fp, s, NFTNL_CMD_UNSPEC, type, flags,
1052  nftnl_set_do_snprintf);
1053 }
1054 EXPORT_SYMBOL(nftnl_set_fprintf, nft_set_fprintf);
1055 
1056 void nftnl_set_elem_add(struct nftnl_set *s, struct nftnl_set_elem *elem)
1057 {
1058  list_add_tail(&elem->head, &s->element_list);
1059 }
1060 EXPORT_SYMBOL(nftnl_set_elem_add, nft_set_elem_add);
1061 
1063  struct list_head list;
1064 };
1065 
1066 struct nftnl_set_list *nftnl_set_list_alloc(void)
1067 {
1068  struct nftnl_set_list *list;
1069 
1070  list = calloc(1, sizeof(struct nftnl_set_list));
1071  if (list == NULL)
1072  return NULL;
1073 
1074  INIT_LIST_HEAD(&list->list);
1075 
1076  return list;
1077 }
1078 EXPORT_SYMBOL(nftnl_set_list_alloc, nft_set_list_alloc);
1079 
1080 void nftnl_set_list_free(struct nftnl_set_list *list)
1081 {
1082  struct nftnl_set *s, *tmp;
1083 
1084  list_for_each_entry_safe(s, tmp, &list->list, head) {
1085  list_del(&s->head);
1086  nftnl_set_free(s);
1087  }
1088  xfree(list);
1089 }
1090 EXPORT_SYMBOL(nftnl_set_list_free, nft_set_list_free);
1091 
1092 int nftnl_set_list_is_empty(struct nftnl_set_list *list)
1093 {
1094  return list_empty(&list->list);
1095 }
1096 EXPORT_SYMBOL(nftnl_set_list_is_empty, nft_set_list_is_empty);
1097 
1098 void nftnl_set_list_add(struct nftnl_set *s, struct nftnl_set_list *list)
1099 {
1100  list_add(&s->head, &list->list);
1101 }
1102 EXPORT_SYMBOL(nftnl_set_list_add, nft_set_list_add);
1103 
1104 void nftnl_set_list_add_tail(struct nftnl_set *s, struct nftnl_set_list *list)
1105 {
1106  list_add_tail(&s->head, &list->list);
1107 }
1108 EXPORT_SYMBOL(nftnl_set_list_add_tail, nft_set_list_add_tail);
1109 
1110 void nftnl_set_list_del(struct nftnl_set *s)
1111 {
1112  list_del(&s->head);
1113 }
1114 EXPORT_SYMBOL(nftnl_set_list_del, nft_set_list_del);
1115 
1116 int nftnl_set_list_foreach(struct nftnl_set_list *set_list,
1117  int (*cb)(struct nftnl_set *t, void *data), void *data)
1118 {
1119  struct nftnl_set *cur, *tmp;
1120  int ret;
1121 
1122  list_for_each_entry_safe(cur, tmp, &set_list->list, head) {
1123  ret = cb(cur, data);
1124  if (ret < 0)
1125  return ret;
1126  }
1127  return 0;
1128 }
1129 EXPORT_SYMBOL(nftnl_set_list_foreach, nft_set_list_foreach);
1130 
1132  struct nftnl_set_list *list;
1133  struct nftnl_set *cur;
1134 };
1135 
1136 struct nftnl_set_list_iter *nftnl_set_list_iter_create(struct nftnl_set_list *l)
1137 {
1138  struct nftnl_set_list_iter *iter;
1139 
1140  iter = calloc(1, sizeof(struct nftnl_set_list_iter));
1141  if (iter == NULL)
1142  return NULL;
1143 
1144  iter->list = l;
1145  if (nftnl_set_list_is_empty(l))
1146  iter->cur = NULL;
1147  else
1148  iter->cur = list_entry(l->list.next, struct nftnl_set, head);
1149 
1150  return iter;
1151 }
1152 EXPORT_SYMBOL(nftnl_set_list_iter_create, nft_set_list_iter_create);
1153 
1154 struct nftnl_set *nftnl_set_list_iter_cur(struct nftnl_set_list_iter *iter)
1155 {
1156  return iter->cur;
1157 }
1158 EXPORT_SYMBOL(nftnl_set_list_iter_cur, nft_set_list_iter_cur);
1159 
1160 struct nftnl_set *nftnl_set_list_iter_next(struct nftnl_set_list_iter *iter)
1161 {
1162  struct nftnl_set *s = iter->cur;
1163 
1164  if (s == NULL)
1165  return NULL;
1166 
1167  /* get next rule, if any */
1168  iter->cur = list_entry(iter->cur->head.next, struct nftnl_set, head);
1169  if (&iter->cur->head == iter->list->list.next)
1170  return NULL;
1171 
1172  return s;
1173 }
1174 EXPORT_SYMBOL(nftnl_set_list_iter_next, nft_set_list_iter_next);
1175 
1176 void nftnl_set_list_iter_destroy(struct nftnl_set_list_iter *iter)
1177 {
1178  xfree(iter);
1179 }
1180 EXPORT_SYMBOL(nftnl_set_list_iter_destroy, nft_set_list_iter_destroy);
1181 
1182 static struct nftnl_set *nftnl_set_lookup(const char *this_set_name,
1183  struct nftnl_set_list *set_list)
1184 {
1185  struct nftnl_set_list_iter *iter;
1186  struct nftnl_set *s;
1187  const char *set_name;
1188 
1189  iter = nftnl_set_list_iter_create(set_list);
1190  if (iter == NULL)
1191  return NULL;
1192 
1193  s = nftnl_set_list_iter_cur(iter);
1194  while (s != NULL) {
1195  set_name = nftnl_set_get_str(s, NFTNL_SET_NAME);
1196  if (strcmp(this_set_name, set_name) == 0)
1197  break;
1198 
1199  s = nftnl_set_list_iter_next(iter);
1200  }
1201  nftnl_set_list_iter_destroy(iter);
1202 
1203  return s;
1204 }
1205 
1206 int nftnl_set_lookup_id(struct nftnl_expr *e,
1207  struct nftnl_set_list *set_list, uint32_t *set_id)
1208 {
1209  const char *set_name;
1210  struct nftnl_set *s;
1211 
1212  set_name = nftnl_expr_get_str(e, NFTNL_EXPR_LOOKUP_SET);
1213  if (set_name == NULL)
1214  return 0;
1215 
1216  s = nftnl_set_lookup(set_name, set_list);
1217  if (s == NULL)
1218  return 0;
1219 
1220  *set_id = nftnl_set_get_u32(s, NFTNL_SET_ID);
1221  return 1;
1222 }