1use core::option::Option;
4use libc::{c_char, c_int, c_void, iovec, nlmsghdr, FILE};
5
6#[repr(C)]
7pub struct nftnl_batch(c_void);
8
9extern "C" {
10 pub fn nftnl_batch_alloc(pg_size: u32, pg_overrun_size: u32) -> *mut nftnl_batch;
11
12 pub fn nftnl_batch_update(batch: *mut nftnl_batch) -> c_int;
13
14 pub fn nftnl_batch_free(batch: *mut nftnl_batch);
15
16 pub fn nftnl_batch_buffer(batch: *mut nftnl_batch) -> *mut c_void;
17
18 pub fn nftnl_batch_buffer_len(batch: *mut nftnl_batch) -> u32;
19
20 pub fn nftnl_batch_iovec_len(batch: *mut nftnl_batch) -> c_int;
21
22 pub fn nftnl_batch_iovec(batch: *mut nftnl_batch, iov: *mut iovec, iovlen: u32);
23}
24pub const NFTNL_PARSE_EBADINPUT: u32 = 0;
25pub const NFTNL_PARSE_EMISSINGNODE: u32 = 1;
26pub const NFTNL_PARSE_EBADTYPE: u32 = 2;
27pub const NFTNL_PARSE_EOPNOTSUPP: u32 = 3;
28
29pub const NFTNL_OUTPUT_DEFAULT: nftnl_output_type = 0;
30pub const NFTNL_OUTPUT_XML: nftnl_output_type = 1;
31pub const NFTNL_OUTPUT_JSON: nftnl_output_type = 2;
32pub type nftnl_output_type = u32;
33pub const NFTNL_OF_EVENT_NEW: nftnl_output_flags = 1;
34pub const NFTNL_OF_EVENT_DEL: nftnl_output_flags = 2;
35pub const NFTNL_OF_EVENT_ANY: nftnl_output_flags = 3;
36pub type nftnl_output_flags = u32;
37pub const NFTNL_CMD_UNSPEC: nftnl_cmd_type = 0;
38pub const NFTNL_CMD_ADD: nftnl_cmd_type = 1;
39pub const NFTNL_CMD_INSERT: nftnl_cmd_type = 2;
40pub const NFTNL_CMD_DELETE: nftnl_cmd_type = 3;
41pub const NFTNL_CMD_REPLACE: nftnl_cmd_type = 4;
42pub const NFTNL_CMD_FLUSH: nftnl_cmd_type = 5;
43pub const NFTNL_CMD_MAX: nftnl_cmd_type = 6;
44pub type nftnl_cmd_type = u32;
45pub const NFTNL_PARSE_NONE: nftnl_parse_type = 0;
46pub const NFTNL_PARSE_XML: nftnl_parse_type = 1;
47pub const NFTNL_PARSE_JSON: nftnl_parse_type = 2;
48pub const NFTNL_PARSE_MAX: nftnl_parse_type = 3;
49pub type nftnl_parse_type = u32;
50#[repr(C)]
51pub struct nftnl_parse_err(c_void);
52
53extern "C" {
54 pub fn nftnl_nlmsg_build_hdr(
55 buf: *mut c_char,
56 cmd: u16,
57 family: u16,
58 type_: u16,
59 seq: u32,
60 ) -> *mut nlmsghdr;
61
62 pub fn nftnl_parse_err_alloc() -> *mut nftnl_parse_err;
63
64 pub fn nftnl_parse_err_free(arg1: *mut nftnl_parse_err);
65
66 pub fn nftnl_parse_perror(str: *const c_char, err: *mut nftnl_parse_err) -> c_int;
67
68 pub fn nftnl_batch_is_supported() -> c_int;
69
70 pub fn nftnl_batch_begin(buf: *mut c_char, seq: u32);
71
72 pub fn nftnl_batch_end(buf: *mut c_char, seq: u32);
73}
74#[repr(C)]
75pub struct nftnl_chain(c_void);
76
77extern "C" {
78 pub fn nftnl_chain_alloc() -> *mut nftnl_chain;
79
80 pub fn nftnl_chain_free(arg1: *const nftnl_chain);
81}
82pub const NFTNL_CHAIN_NAME: nftnl_chain_attr = 0;
83pub const NFTNL_CHAIN_FAMILY: nftnl_chain_attr = 1;
84pub const NFTNL_CHAIN_TABLE: nftnl_chain_attr = 2;
85pub const NFTNL_CHAIN_HOOKNUM: nftnl_chain_attr = 3;
86pub const NFTNL_CHAIN_PRIO: nftnl_chain_attr = 4;
87pub const NFTNL_CHAIN_POLICY: nftnl_chain_attr = 5;
88pub const NFTNL_CHAIN_USE: nftnl_chain_attr = 6;
89pub const NFTNL_CHAIN_BYTES: nftnl_chain_attr = 7;
90pub const NFTNL_CHAIN_PACKETS: nftnl_chain_attr = 8;
91pub const NFTNL_CHAIN_HANDLE: nftnl_chain_attr = 9;
92pub const NFTNL_CHAIN_TYPE: nftnl_chain_attr = 10;
93pub const NFTNL_CHAIN_DEV: nftnl_chain_attr = 11;
94pub const __NFTNL_CHAIN_MAX: nftnl_chain_attr = 12;
95pub type nftnl_chain_attr = u32;
96extern "C" {
97 pub fn nftnl_chain_is_set(c: *const nftnl_chain, attr: u16) -> bool;
98
99 pub fn nftnl_chain_unset(c: *mut nftnl_chain, attr: u16);
100
101 pub fn nftnl_chain_set(t: *mut nftnl_chain, attr: u16, data: *const c_void);
102
103 pub fn nftnl_chain_set_data(t: *mut nftnl_chain, attr: u16, data: *const c_void, data_len: u32);
104
105 pub fn nftnl_chain_set_u8(t: *mut nftnl_chain, attr: u16, data: u8);
106
107 pub fn nftnl_chain_set_u32(t: *mut nftnl_chain, attr: u16, data: u32);
108
109 pub fn nftnl_chain_set_s32(t: *mut nftnl_chain, attr: u16, data: i32);
110
111 pub fn nftnl_chain_set_u64(t: *mut nftnl_chain, attr: u16, data: u64);
112
113 pub fn nftnl_chain_set_str(t: *mut nftnl_chain, attr: u16, str: *const c_char);
114
115 pub fn nftnl_chain_get(c: *const nftnl_chain, attr: u16) -> *const c_void;
116
117 pub fn nftnl_chain_get_data(
118 c: *const nftnl_chain,
119 attr: u16,
120 data_len: *mut u32,
121 ) -> *const c_void;
122
123 pub fn nftnl_chain_get_str(c: *const nftnl_chain, attr: u16) -> *const c_char;
124
125 pub fn nftnl_chain_get_u8(c: *const nftnl_chain, attr: u16) -> u8;
126
127 pub fn nftnl_chain_get_u32(c: *const nftnl_chain, attr: u16) -> u32;
128
129 pub fn nftnl_chain_get_s32(c: *const nftnl_chain, attr: u16) -> i32;
130
131 pub fn nftnl_chain_get_u64(c: *const nftnl_chain, attr: u16) -> u64;
132
133 pub fn nftnl_chain_nlmsg_build_payload(nlh: *mut nlmsghdr, t: *const nftnl_chain);
134
135 pub fn nftnl_chain_parse(
136 c: *mut nftnl_chain,
137 type_: nftnl_parse_type,
138 data: *const c_char,
139 err: *mut nftnl_parse_err,
140 ) -> c_int;
141
142 pub fn nftnl_chain_parse_file(
143 c: *mut nftnl_chain,
144 type_: nftnl_parse_type,
145 fp: *mut FILE,
146 err: *mut nftnl_parse_err,
147 ) -> c_int;
148
149 pub fn nftnl_chain_snprintf(
150 buf: *mut c_char,
151 size: usize,
152 t: *const nftnl_chain,
153 type_: u32,
154 flags: u32,
155 ) -> c_int;
156
157 pub fn nftnl_chain_fprintf(
158 fp: *mut FILE,
159 c: *const nftnl_chain,
160 type_: u32,
161 flags: u32,
162 ) -> c_int;
163
164 pub fn nftnl_chain_nlmsg_parse(nlh: *const nlmsghdr, t: *mut nftnl_chain) -> c_int;
165}
166#[repr(C)]
167pub struct nftnl_chain_list(c_void);
168
169extern "C" {
170 pub fn nftnl_chain_list_alloc() -> *mut nftnl_chain_list;
171
172 pub fn nftnl_chain_list_free(list: *mut nftnl_chain_list);
173
174 pub fn nftnl_chain_list_is_empty(list: *const nftnl_chain_list) -> c_int;
175
176 pub fn nftnl_chain_list_foreach(
177 chain_list: *mut nftnl_chain_list,
178 cb: Option<unsafe extern "C" fn(t: *mut nftnl_chain, data: *mut c_void) -> c_int>,
179 data: *mut c_void,
180 ) -> c_int;
181
182 pub fn nftnl_chain_list_add(r: *mut nftnl_chain, list: *mut nftnl_chain_list);
183
184 pub fn nftnl_chain_list_add_tail(r: *mut nftnl_chain, list: *mut nftnl_chain_list);
185
186 pub fn nftnl_chain_list_del(c: *mut nftnl_chain);
187}
188#[repr(C)]
189pub struct nftnl_chain_list_iter(c_void);
190
191extern "C" {
192 pub fn nftnl_chain_list_iter_create(l: *mut nftnl_chain_list) -> *mut nftnl_chain_list_iter;
193
194 pub fn nftnl_chain_list_iter_next(iter: *mut nftnl_chain_list_iter) -> *mut nftnl_chain;
195
196 pub fn nftnl_chain_list_iter_destroy(iter: *mut nftnl_chain_list_iter);
197}
198#[repr(C)]
199pub struct nftnl_expr(c_void);
200
201pub const NFTNL_EXPR_NAME: u32 = 0;
202pub const NFTNL_EXPR_BASE: u32 = 1;
203
204extern "C" {
205 pub fn nftnl_expr_alloc(name: *const c_char) -> *mut nftnl_expr;
206
207 pub fn nftnl_expr_free(expr: *const nftnl_expr);
208
209 pub fn nftnl_expr_is_set(expr: *const nftnl_expr, type_: u16) -> bool;
210
211 pub fn nftnl_expr_set(expr: *mut nftnl_expr, type_: u16, data: *const c_void, data_len: u32);
212
213 pub fn nftnl_expr_set_u8(expr: *mut nftnl_expr, type_: u16, data: u8);
214
215 pub fn nftnl_expr_set_u16(expr: *mut nftnl_expr, type_: u16, data: u16);
216
217 pub fn nftnl_expr_set_u32(expr: *mut nftnl_expr, type_: u16, data: u32);
218
219 pub fn nftnl_expr_set_u64(expr: *mut nftnl_expr, type_: u16, data: u64);
220
221 pub fn nftnl_expr_set_str(expr: *mut nftnl_expr, type_: u16, str: *const c_char);
222
223 pub fn nftnl_expr_get(expr: *const nftnl_expr, type_: u16, data_len: *mut u32)
224 -> *const c_void;
225
226 pub fn nftnl_expr_get_u8(expr: *const nftnl_expr, type_: u16) -> u8;
227
228 pub fn nftnl_expr_get_u16(expr: *const nftnl_expr, type_: u16) -> u16;
229
230 pub fn nftnl_expr_get_u32(expr: *const nftnl_expr, type_: u16) -> u32;
231
232 pub fn nftnl_expr_get_u64(expr: *const nftnl_expr, type_: u16) -> u64;
233
234 pub fn nftnl_expr_get_str(expr: *const nftnl_expr, type_: u16) -> *const c_char;
235
236 pub fn nftnl_expr_snprintf(
237 buf: *mut c_char,
238 buflen: usize,
239 expr: *const nftnl_expr,
240 type_: u32,
241 flags: u32,
242 ) -> c_int;
243}
244pub const NFTNL_EXPR_PAYLOAD_DREG: u32 = 1;
245pub const NFTNL_EXPR_PAYLOAD_BASE: u32 = 2;
246pub const NFTNL_EXPR_PAYLOAD_OFFSET: u32 = 3;
247pub const NFTNL_EXPR_PAYLOAD_LEN: u32 = 4;
248pub const NFTNL_EXPR_PAYLOAD_SREG: u32 = 5;
249pub const NFTNL_EXPR_PAYLOAD_CSUM_TYPE: u32 = 6;
250pub const NFTNL_EXPR_PAYLOAD_CSUM_OFFSET: u32 = 7;
251
252pub const NFTNL_EXPR_META_KEY: u32 = 1;
253pub const NFTNL_EXPR_META_DREG: u32 = 2;
254pub const NFTNL_EXPR_META_SREG: u32 = 3;
255
256pub const NFTNL_EXPR_CMP_SREG: u32 = 1;
257pub const NFTNL_EXPR_CMP_OP: u32 = 2;
258pub const NFTNL_EXPR_CMP_DATA: u32 = 3;
259
260pub const NFTNL_EXPR_IMM_DREG: u32 = 1;
261pub const NFTNL_EXPR_IMM_DATA: u32 = 2;
262pub const NFTNL_EXPR_IMM_VERDICT: u32 = 3;
263pub const NFTNL_EXPR_IMM_CHAIN: u32 = 4;
264
265pub const NFTNL_EXPR_CTR_PACKETS: u32 = 1;
266pub const NFTNL_EXPR_CTR_BYTES: u32 = 2;
267
268pub const NFTNL_EXPR_BITWISE_SREG: u32 = 1;
269pub const NFTNL_EXPR_BITWISE_DREG: u32 = 2;
270pub const NFTNL_EXPR_BITWISE_LEN: u32 = 3;
271pub const NFTNL_EXPR_BITWISE_MASK: u32 = 4;
272pub const NFTNL_EXPR_BITWISE_XOR: u32 = 5;
273
274pub const NFTNL_EXPR_TG_NAME: u32 = 1;
275pub const NFTNL_EXPR_TG_REV: u32 = 2;
276pub const NFTNL_EXPR_TG_INFO: u32 = 3;
277
278pub const NFTNL_EXPR_MT_NAME: u32 = 1;
279pub const NFTNL_EXPR_MT_REV: u32 = 2;
280pub const NFTNL_EXPR_MT_INFO: u32 = 3;
281
282pub const NFTNL_EXPR_NAT_TYPE: u32 = 1;
283pub const NFTNL_EXPR_NAT_FAMILY: u32 = 2;
284pub const NFTNL_EXPR_NAT_REG_ADDR_MIN: u32 = 3;
285pub const NFTNL_EXPR_NAT_REG_ADDR_MAX: u32 = 4;
286pub const NFTNL_EXPR_NAT_REG_PROTO_MIN: u32 = 5;
287pub const NFTNL_EXPR_NAT_REG_PROTO_MAX: u32 = 6;
288pub const NFTNL_EXPR_NAT_FLAGS: u32 = 7;
289
290pub const NFTNL_EXPR_LOOKUP_SREG: u32 = 1;
291pub const NFTNL_EXPR_LOOKUP_DREG: u32 = 2;
292pub const NFTNL_EXPR_LOOKUP_SET: u32 = 3;
293pub const NFTNL_EXPR_LOOKUP_SET_ID: u32 = 4;
294
295pub const NFTNL_EXPR_DYNSET_SREG_KEY: u32 = 1;
296pub const NFTNL_EXPR_DYNSET_SREG_DATA: u32 = 2;
297pub const NFTNL_EXPR_DYNSET_OP: u32 = 3;
298pub const NFTNL_EXPR_DYNSET_TIMEOUT: u32 = 4;
299pub const NFTNL_EXPR_DYNSET_SET_NAME: u32 = 5;
300pub const NFTNL_EXPR_DYNSET_SET_ID: u32 = 6;
301pub const NFTNL_EXPR_DYNSET_EXPR: u32 = 7;
302
303pub const NFTNL_EXPR_LOG_PREFIX: u32 = 1;
304pub const NFTNL_EXPR_LOG_GROUP: u32 = 2;
305pub const NFTNL_EXPR_LOG_SNAPLEN: u32 = 3;
306pub const NFTNL_EXPR_LOG_QTHRESHOLD: u32 = 4;
307pub const NFTNL_EXPR_LOG_LEVEL: u32 = 5;
308pub const NFTNL_EXPR_LOG_FLAGS: u32 = 6;
309
310pub const NFTNL_EXPR_EXTHDR_DREG: u32 = 1;
311pub const NFTNL_EXPR_EXTHDR_TYPE: u32 = 2;
312pub const NFTNL_EXPR_EXTHDR_OFFSET: u32 = 3;
313pub const NFTNL_EXPR_EXTHDR_LEN: u32 = 4;
314
315pub const NFTNL_EXPR_CT_DREG: u32 = 1;
316pub const NFTNL_EXPR_CT_KEY: u32 = 2;
317pub const NFTNL_EXPR_CT_DIR: u32 = 3;
318pub const NFTNL_EXPR_CT_SREG: u32 = 4;
319
320pub const NFTNL_EXPR_BYTEORDER_DREG: u32 = 1;
321pub const NFTNL_EXPR_BYTEORDER_SREG: u32 = 2;
322pub const NFTNL_EXPR_BYTEORDER_OP: u32 = 3;
323pub const NFTNL_EXPR_BYTEORDER_LEN: u32 = 4;
324pub const NFTNL_EXPR_BYTEORDER_SIZE: u32 = 5;
325
326pub const NFTNL_EXPR_LIMIT_RATE: u32 = 1;
327pub const NFTNL_EXPR_LIMIT_UNIT: u32 = 2;
328pub const NFTNL_EXPR_LIMIT_BURST: u32 = 3;
329pub const NFTNL_EXPR_LIMIT_TYPE: u32 = 4;
330pub const NFTNL_EXPR_LIMIT_FLAGS: u32 = 5;
331
332pub const NFTNL_EXPR_REJECT_TYPE: u32 = 1;
333pub const NFTNL_EXPR_REJECT_CODE: u32 = 2;
334
335pub const NFTNL_EXPR_QUEUE_NUM: u32 = 1;
336pub const NFTNL_EXPR_QUEUE_TOTAL: u32 = 2;
337pub const NFTNL_EXPR_QUEUE_FLAGS: u32 = 3;
338
339pub const NFTNL_EXPR_MASQ_FLAGS: u32 = 1;
340pub const NFTNL_EXPR_MASQ_REG_PROTO_MIN: u32 = 2;
341pub const NFTNL_EXPR_MASQ_REG_PROTO_MAX: u32 = 3;
342
343pub const NFTNL_EXPR_REDIR_REG_PROTO_MIN: u32 = 1;
344pub const NFTNL_EXPR_REDIR_REG_PROTO_MAX: u32 = 2;
345pub const NFTNL_EXPR_REDIR_FLAGS: u32 = 3;
346
347pub const NFTNL_EXPR_DUP_SREG_ADDR: u32 = 1;
348pub const NFTNL_EXPR_DUP_SREG_DEV: u32 = 2;
349
350pub const NFTNL_EXPR_FWD_SREG_DEV: u32 = 1;
351
352#[repr(C)]
353pub struct nftnl_gen(c_void);
354
355extern "C" {
356 pub fn nftnl_gen_alloc() -> *mut nftnl_gen;
357
358 pub fn nftnl_gen_free(arg1: *const nftnl_gen);
359}
360pub const NFTNL_GEN_ID: u32 = 0;
361pub const __NFTNL_GEN_MAX: u32 = 1;
362
363extern "C" {
364 pub fn nftnl_gen_is_set(gen: *const nftnl_gen, attr: u16) -> bool;
365
366 pub fn nftnl_gen_unset(gen: *mut nftnl_gen, attr: u16);
367
368 pub fn nftnl_gen_set(gen: *mut nftnl_gen, attr: u16, data: *const c_void);
369
370 pub fn nftnl_gen_set_data(gen: *mut nftnl_gen, attr: u16, data: *const c_void, data_len: u32);
371
372 pub fn nftnl_gen_get(gen: *const nftnl_gen, attr: u16) -> *const c_void;
373
374 pub fn nftnl_gen_get_data(
375 gen: *const nftnl_gen,
376 attr: u16,
377 data_len: *mut u32,
378 ) -> *const c_void;
379
380 pub fn nftnl_gen_set_u32(gen: *mut nftnl_gen, attr: u16, data: u32);
381
382 pub fn nftnl_gen_get_u32(gen: *const nftnl_gen, attr: u16) -> u32;
383
384 pub fn nftnl_gen_nlmsg_parse(nlh: *const nlmsghdr, gen: *mut nftnl_gen) -> c_int;
385
386 pub fn nftnl_gen_snprintf(
387 buf: *mut c_char,
388 size: usize,
389 gen: *const nftnl_gen,
390 type_: u32,
391 flags: u32,
392 ) -> c_int;
393
394 pub fn nftnl_gen_fprintf(fp: *mut FILE, gen: *const nftnl_gen, type_: u32, flags: u32)
395 -> c_int;
396}
397#[repr(C)]
398pub struct nftnl_rule(c_void);
399
400extern "C" {
401 pub fn nftnl_rule_alloc() -> *mut nftnl_rule;
402
403 pub fn nftnl_rule_free(arg1: *const nftnl_rule);
404}
405pub const NFTNL_RULE_FAMILY: nftnl_rule_attr = 0;
406pub const NFTNL_RULE_TABLE: nftnl_rule_attr = 1;
407pub const NFTNL_RULE_CHAIN: nftnl_rule_attr = 2;
408pub const NFTNL_RULE_HANDLE: nftnl_rule_attr = 3;
409pub const NFTNL_RULE_COMPAT_PROTO: nftnl_rule_attr = 4;
410pub const NFTNL_RULE_COMPAT_FLAGS: nftnl_rule_attr = 5;
411pub const NFTNL_RULE_POSITION: nftnl_rule_attr = 6;
412pub const NFTNL_RULE_USERDATA: nftnl_rule_attr = 7;
413pub const __NFTNL_RULE_MAX: nftnl_rule_attr = 8;
414pub type nftnl_rule_attr = u32;
415extern "C" {
416 pub fn nftnl_rule_unset(r: *mut nftnl_rule, attr: u16);
417
418 pub fn nftnl_rule_is_set(r: *const nftnl_rule, attr: u16) -> bool;
419
420 pub fn nftnl_rule_set(r: *mut nftnl_rule, attr: u16, data: *const c_void);
421
422 pub fn nftnl_rule_set_data(r: *mut nftnl_rule, attr: u16, data: *const c_void, data_len: u32);
423
424 pub fn nftnl_rule_set_u32(r: *mut nftnl_rule, attr: u16, val: u32);
425
426 pub fn nftnl_rule_set_u64(r: *mut nftnl_rule, attr: u16, val: u64);
427
428 pub fn nftnl_rule_set_str(r: *mut nftnl_rule, attr: u16, str: *const c_char);
429
430 pub fn nftnl_rule_get(r: *const nftnl_rule, attr: u16) -> *const c_void;
431
432 pub fn nftnl_rule_get_data(
433 r: *const nftnl_rule,
434 attr: u16,
435 data_len: *mut u32,
436 ) -> *const c_void;
437
438 pub fn nftnl_rule_get_str(r: *const nftnl_rule, attr: u16) -> *const c_char;
439
440 pub fn nftnl_rule_get_u8(r: *const nftnl_rule, attr: u16) -> u8;
441
442 pub fn nftnl_rule_get_u32(r: *const nftnl_rule, attr: u16) -> u32;
443
444 pub fn nftnl_rule_get_u64(r: *const nftnl_rule, attr: u16) -> u64;
445
446 pub fn nftnl_rule_add_expr(r: *mut nftnl_rule, expr: *mut nftnl_expr);
447
448 pub fn nftnl_rule_nlmsg_build_payload(nlh: *mut nlmsghdr, t: *mut nftnl_rule);
449
450 pub fn nftnl_rule_parse(
451 r: *mut nftnl_rule,
452 type_: nftnl_parse_type,
453 data: *const c_char,
454 err: *mut nftnl_parse_err,
455 ) -> c_int;
456
457 pub fn nftnl_rule_parse_file(
458 r: *mut nftnl_rule,
459 type_: nftnl_parse_type,
460 fp: *mut FILE,
461 err: *mut nftnl_parse_err,
462 ) -> c_int;
463
464 pub fn nftnl_rule_snprintf(
465 buf: *mut c_char,
466 size: usize,
467 t: *const nftnl_rule,
468 type_: u32,
469 flags: u32,
470 ) -> c_int;
471
472 pub fn nftnl_rule_fprintf(fp: *mut FILE, r: *const nftnl_rule, type_: u32, flags: u32)
473 -> c_int;
474
475 pub fn nftnl_rule_nlmsg_parse(nlh: *const nlmsghdr, t: *mut nftnl_rule) -> c_int;
476
477 pub fn nftnl_expr_foreach(
478 r: *mut nftnl_rule,
479 cb: Option<unsafe extern "C" fn(e: *mut nftnl_expr, data: *mut c_void) -> c_int>,
480 data: *mut c_void,
481 ) -> c_int;
482}
483#[repr(C)]
484pub struct nftnl_expr_iter(c_void);
485
486extern "C" {
487 pub fn nftnl_expr_iter_create(r: *mut nftnl_rule) -> *mut nftnl_expr_iter;
488
489 pub fn nftnl_expr_iter_next(iter: *mut nftnl_expr_iter) -> *mut nftnl_expr;
490
491 pub fn nftnl_expr_iter_destroy(iter: *mut nftnl_expr_iter);
492}
493#[repr(C)]
494pub struct nftnl_rule_list(c_void);
495
496extern "C" {
497 pub fn nftnl_rule_list_alloc() -> *mut nftnl_rule_list;
498
499 pub fn nftnl_rule_list_free(list: *mut nftnl_rule_list);
500
501 pub fn nftnl_rule_list_is_empty(list: *const nftnl_rule_list) -> c_int;
502
503 pub fn nftnl_rule_list_add(r: *mut nftnl_rule, list: *mut nftnl_rule_list);
504
505 pub fn nftnl_rule_list_add_tail(r: *mut nftnl_rule, list: *mut nftnl_rule_list);
506
507 pub fn nftnl_rule_list_del(r: *mut nftnl_rule);
508
509 pub fn nftnl_rule_list_foreach(
510 rule_list: *mut nftnl_rule_list,
511 cb: Option<unsafe extern "C" fn(t: *mut nftnl_rule, data: *mut c_void) -> c_int>,
512 data: *mut c_void,
513 ) -> c_int;
514}
515#[repr(C)]
516pub struct nftnl_rule_list_iter(c_void);
517
518extern "C" {
519 pub fn nftnl_rule_list_iter_create(l: *mut nftnl_rule_list) -> *mut nftnl_rule_list_iter;
520
521 pub fn nftnl_rule_list_iter_cur(iter: *mut nftnl_rule_list_iter) -> *mut nftnl_rule;
522
523 pub fn nftnl_rule_list_iter_next(iter: *mut nftnl_rule_list_iter) -> *mut nftnl_rule;
524
525 pub fn nftnl_rule_list_iter_destroy(iter: *const nftnl_rule_list_iter);
526}
527#[repr(C)]
528pub struct nftnl_ruleset(c_void);
529
530extern "C" {
531 pub fn nftnl_ruleset_alloc() -> *mut nftnl_ruleset;
532
533 pub fn nftnl_ruleset_free(r: *const nftnl_ruleset);
534}
535pub const NFTNL_RULESET_TABLELIST: u32 = 0;
536pub const NFTNL_RULESET_CHAINLIST: u32 = 1;
537pub const NFTNL_RULESET_SETLIST: u32 = 2;
538pub const NFTNL_RULESET_RULELIST: u32 = 3;
539
540pub const NFTNL_RULESET_UNSPEC: nftnl_ruleset_type = 0;
541pub const NFTNL_RULESET_RULESET: nftnl_ruleset_type = 1;
542pub const NFTNL_RULESET_TABLE: nftnl_ruleset_type = 2;
543pub const NFTNL_RULESET_CHAIN: nftnl_ruleset_type = 3;
544pub const NFTNL_RULESET_RULE: nftnl_ruleset_type = 4;
545pub const NFTNL_RULESET_SET: nftnl_ruleset_type = 5;
546pub const NFTNL_RULESET_SET_ELEMS: nftnl_ruleset_type = 6;
547pub type nftnl_ruleset_type = u32;
548extern "C" {
549 pub fn nftnl_ruleset_is_set(r: *const nftnl_ruleset, attr: u16) -> bool;
550
551 pub fn nftnl_ruleset_unset(r: *mut nftnl_ruleset, attr: u16);
552
553 pub fn nftnl_ruleset_set(r: *mut nftnl_ruleset, attr: u16, data: *mut c_void);
554
555 pub fn nftnl_ruleset_get(r: *const nftnl_ruleset, attr: u16) -> *mut c_void;
556}
557pub const NFTNL_RULESET_CTX_CMD: u32 = 0;
558pub const NFTNL_RULESET_CTX_TYPE: u32 = 1;
559pub const NFTNL_RULESET_CTX_TABLE: u32 = 2;
560pub const NFTNL_RULESET_CTX_CHAIN: u32 = 3;
561pub const NFTNL_RULESET_CTX_RULE: u32 = 4;
562pub const NFTNL_RULESET_CTX_SET: u32 = 5;
563pub const NFTNL_RULESET_CTX_DATA: u32 = 6;
564
565#[repr(C)]
566pub struct nftnl_parse_ctx(c_void);
567
568extern "C" {
569 pub fn nftnl_ruleset_ctx_free(ctx: *const nftnl_parse_ctx);
570
571 pub fn nftnl_ruleset_ctx_is_set(ctx: *const nftnl_parse_ctx, attr: u16) -> bool;
572
573 pub fn nftnl_ruleset_ctx_get(ctx: *const nftnl_parse_ctx, attr: u16) -> *mut c_void;
574
575 pub fn nftnl_ruleset_ctx_get_u32(ctx: *const nftnl_parse_ctx, attr: u16) -> u32;
576
577 pub fn nftnl_ruleset_parse_file_cb(
578 type_: nftnl_parse_type,
579 fp: *mut FILE,
580 err: *mut nftnl_parse_err,
581 data: *mut c_void,
582 cb: Option<unsafe extern "C" fn(ctx: *const nftnl_parse_ctx) -> c_int>,
583 ) -> c_int;
584
585 pub fn nftnl_ruleset_parse_buffer_cb(
586 type_: nftnl_parse_type,
587 buffer: *const c_char,
588 err: *mut nftnl_parse_err,
589 data: *mut c_void,
590 cb: Option<unsafe extern "C" fn(ctx: *const nftnl_parse_ctx) -> c_int>,
591 ) -> c_int;
592
593 pub fn nftnl_ruleset_parse(
594 rs: *mut nftnl_ruleset,
595 type_: nftnl_parse_type,
596 data: *const c_char,
597 err: *mut nftnl_parse_err,
598 ) -> c_int;
599
600 pub fn nftnl_ruleset_parse_file(
601 rs: *mut nftnl_ruleset,
602 type_: nftnl_parse_type,
603 fp: *mut FILE,
604 err: *mut nftnl_parse_err,
605 ) -> c_int;
606
607 pub fn nftnl_ruleset_snprintf(
608 buf: *mut c_char,
609 size: usize,
610 rs: *const nftnl_ruleset,
611 type_: u32,
612 flags: u32,
613 ) -> c_int;
614
615 pub fn nftnl_ruleset_fprintf(
616 fp: *mut FILE,
617 rs: *const nftnl_ruleset,
618 type_: u32,
619 flags: u32,
620 ) -> c_int;
621}
622pub const NFTNL_SET_TABLE: nftnl_set_attr = 0;
623pub const NFTNL_SET_NAME: nftnl_set_attr = 1;
624pub const NFTNL_SET_FLAGS: nftnl_set_attr = 2;
625pub const NFTNL_SET_KEY_TYPE: nftnl_set_attr = 3;
626pub const NFTNL_SET_KEY_LEN: nftnl_set_attr = 4;
627pub const NFTNL_SET_DATA_TYPE: nftnl_set_attr = 5;
628pub const NFTNL_SET_DATA_LEN: nftnl_set_attr = 6;
629pub const NFTNL_SET_FAMILY: nftnl_set_attr = 7;
630pub const NFTNL_SET_ID: nftnl_set_attr = 8;
631pub const NFTNL_SET_POLICY: nftnl_set_attr = 9;
632pub const NFTNL_SET_DESC_SIZE: nftnl_set_attr = 10;
633pub const NFTNL_SET_TIMEOUT: nftnl_set_attr = 11;
634pub const NFTNL_SET_GC_INTERVAL: nftnl_set_attr = 12;
635pub const __NFTNL_SET_MAX: nftnl_set_attr = 13;
636pub type nftnl_set_attr = u32;
637#[repr(C)]
638pub struct nftnl_set(c_void);
639
640extern "C" {
641 pub fn nftnl_set_alloc() -> *mut nftnl_set;
642
643 pub fn nftnl_set_free(s: *const nftnl_set);
644
645 pub fn nftnl_set_clone(set: *const nftnl_set) -> *mut nftnl_set;
646
647 pub fn nftnl_set_is_set(s: *const nftnl_set, attr: u16) -> bool;
648
649 pub fn nftnl_set_unset(s: *mut nftnl_set, attr: u16);
650
651 pub fn nftnl_set_set(s: *mut nftnl_set, attr: u16, data: *const c_void);
652
653 pub fn nftnl_set_set_data(s: *mut nftnl_set, attr: u16, data: *const c_void, data_len: u32);
654
655 pub fn nftnl_set_set_u32(s: *mut nftnl_set, attr: u16, val: u32);
656
657 pub fn nftnl_set_set_u64(s: *mut nftnl_set, attr: u16, val: u64);
658
659 pub fn nftnl_set_set_str(s: *mut nftnl_set, attr: u16, str: *const c_char);
660
661 pub fn nftnl_set_get(s: *const nftnl_set, attr: u16) -> *const c_void;
662
663 pub fn nftnl_set_get_data(s: *const nftnl_set, attr: u16, data_len: *mut u32) -> *const c_void;
664
665 pub fn nftnl_set_get_str(s: *const nftnl_set, attr: u16) -> *const c_char;
666
667 pub fn nftnl_set_get_u32(s: *const nftnl_set, attr: u16) -> u32;
668
669 pub fn nftnl_set_get_u64(s: *const nftnl_set, attr: u16) -> u64;
670
671 pub fn nftnl_set_nlmsg_build_payload(nlh: *mut nlmsghdr, s: *mut nftnl_set);
672
673 pub fn nftnl_set_nlmsg_parse(nlh: *const nlmsghdr, s: *mut nftnl_set) -> c_int;
674
675 pub fn nftnl_set_elems_nlmsg_parse(nlh: *const nlmsghdr, s: *mut nftnl_set) -> c_int;
676
677 pub fn nftnl_set_snprintf(
678 buf: *mut c_char,
679 size: usize,
680 s: *const nftnl_set,
681 type_: u32,
682 flags: u32,
683 ) -> c_int;
684
685 pub fn nftnl_set_fprintf(fp: *mut FILE, s: *const nftnl_set, type_: u32, flags: u32) -> c_int;
686}
687#[repr(C)]
688pub struct nftnl_set_list(c_void);
689
690extern "C" {
691 pub fn nftnl_set_list_alloc() -> *mut nftnl_set_list;
692
693 pub fn nftnl_set_list_free(list: *mut nftnl_set_list);
694
695 pub fn nftnl_set_list_is_empty(list: *const nftnl_set_list) -> c_int;
696
697 pub fn nftnl_set_list_add(s: *mut nftnl_set, list: *mut nftnl_set_list);
698
699 pub fn nftnl_set_list_add_tail(s: *mut nftnl_set, list: *mut nftnl_set_list);
700
701 pub fn nftnl_set_list_del(s: *mut nftnl_set);
702
703 pub fn nftnl_set_list_foreach(
704 set_list: *mut nftnl_set_list,
705 cb: Option<unsafe extern "C" fn(t: *mut nftnl_set, data: *mut c_void) -> c_int>,
706 data: *mut c_void,
707 ) -> c_int;
708}
709#[repr(C)]
710pub struct nftnl_set_list_iter(c_void);
711
712extern "C" {
713 pub fn nftnl_set_list_iter_create(l: *mut nftnl_set_list) -> *mut nftnl_set_list_iter;
714
715 pub fn nftnl_set_list_iter_cur(iter: *mut nftnl_set_list_iter) -> *mut nftnl_set;
716
717 pub fn nftnl_set_list_iter_next(iter: *mut nftnl_set_list_iter) -> *mut nftnl_set;
718
719 pub fn nftnl_set_list_iter_destroy(iter: *const nftnl_set_list_iter);
720
721 pub fn nftnl_set_parse(
722 s: *mut nftnl_set,
723 type_: nftnl_parse_type,
724 data: *const c_char,
725 err: *mut nftnl_parse_err,
726 ) -> c_int;
727
728 pub fn nftnl_set_parse_file(
729 s: *mut nftnl_set,
730 type_: nftnl_parse_type,
731 fp: *mut FILE,
732 err: *mut nftnl_parse_err,
733 ) -> c_int;
734}
735pub const NFTNL_SET_ELEM_FLAGS: u32 = 0;
736pub const NFTNL_SET_ELEM_KEY: u32 = 1;
737pub const NFTNL_SET_ELEM_VERDICT: u32 = 2;
738pub const NFTNL_SET_ELEM_CHAIN: u32 = 3;
739pub const NFTNL_SET_ELEM_DATA: u32 = 4;
740pub const NFTNL_SET_ELEM_TIMEOUT: u32 = 5;
741pub const NFTNL_SET_ELEM_EXPIRATION: u32 = 6;
742pub const NFTNL_SET_ELEM_USERDATA: u32 = 7;
743pub const NFTNL_SET_ELEM_EXPR: u32 = 8;
744
745#[repr(C)]
746pub struct nftnl_set_elem(c_void);
747
748extern "C" {
749 pub fn nftnl_set_elem_alloc() -> *mut nftnl_set_elem;
750
751 pub fn nftnl_set_elem_free(s: *mut nftnl_set_elem);
752
753 pub fn nftnl_set_elem_clone(elem: *mut nftnl_set_elem) -> *mut nftnl_set_elem;
754
755 pub fn nftnl_set_elem_add(s: *mut nftnl_set, elem: *mut nftnl_set_elem);
756
757 pub fn nftnl_set_elem_unset(s: *mut nftnl_set_elem, attr: u16);
758
759 pub fn nftnl_set_elem_set(
760 s: *mut nftnl_set_elem,
761 attr: u16,
762 data: *const c_void,
763 data_len: u32,
764 );
765
766 pub fn nftnl_set_elem_set_u32(s: *mut nftnl_set_elem, attr: u16, val: u32);
767
768 pub fn nftnl_set_elem_set_u64(s: *mut nftnl_set_elem, attr: u16, val: u64);
769
770 pub fn nftnl_set_elem_set_str(s: *mut nftnl_set_elem, attr: u16, str: *const c_char);
771
772 pub fn nftnl_set_elem_get(
773 s: *mut nftnl_set_elem,
774 attr: u16,
775 data_len: *mut u32,
776 ) -> *const c_void;
777
778 pub fn nftnl_set_elem_get_str(s: *mut nftnl_set_elem, attr: u16) -> *const c_char;
779
780 pub fn nftnl_set_elem_get_u32(s: *mut nftnl_set_elem, attr: u16) -> u32;
781
782 pub fn nftnl_set_elem_get_u64(s: *mut nftnl_set_elem, attr: u16) -> u64;
783
784 pub fn nftnl_set_elem_is_set(s: *const nftnl_set_elem, attr: u16) -> bool;
785
786 pub fn nftnl_set_elems_nlmsg_build_payload(nlh: *mut nlmsghdr, s: *mut nftnl_set);
787
788 pub fn nftnl_set_elem_nlmsg_build_payload(nlh: *mut nlmsghdr, e: *mut nftnl_set_elem);
789
790 pub fn nftnl_set_elem_parse(
791 e: *mut nftnl_set_elem,
792 type_: nftnl_parse_type,
793 data: *const c_char,
794 err: *mut nftnl_parse_err,
795 ) -> c_int;
796
797 pub fn nftnl_set_elem_parse_file(
798 e: *mut nftnl_set_elem,
799 type_: nftnl_parse_type,
800 fp: *mut FILE,
801 err: *mut nftnl_parse_err,
802 ) -> c_int;
803
804 pub fn nftnl_set_elem_snprintf(
805 buf: *mut c_char,
806 size: usize,
807 s: *const nftnl_set_elem,
808 type_: u32,
809 flags: u32,
810 ) -> c_int;
811
812 pub fn nftnl_set_elem_fprintf(
813 fp: *mut FILE,
814 se: *mut nftnl_set_elem,
815 type_: u32,
816 flags: u32,
817 ) -> c_int;
818
819 pub fn nftnl_set_elem_foreach(
820 s: *mut nftnl_set,
821 cb: Option<unsafe extern "C" fn(e: *mut nftnl_set_elem, data: *mut c_void) -> c_int>,
822 data: *mut c_void,
823 ) -> c_int;
824}
825#[repr(C)]
826pub struct nftnl_set_elems_iter(c_void);
827
828extern "C" {
829 pub fn nftnl_set_elems_iter_create(s: *mut nftnl_set) -> *mut nftnl_set_elems_iter;
830
831 pub fn nftnl_set_elems_iter_cur(iter: *mut nftnl_set_elems_iter) -> *mut nftnl_set_elem;
832
833 pub fn nftnl_set_elems_iter_next(iter: *mut nftnl_set_elems_iter) -> *mut nftnl_set_elem;
834
835 pub fn nftnl_set_elems_iter_destroy(iter: *mut nftnl_set_elems_iter);
836
837 pub fn nftnl_set_elems_nlmsg_build_payload_iter(
838 nlh: *mut nlmsghdr,
839 iter: *mut nftnl_set_elems_iter,
840 ) -> c_int;
841}
842#[repr(C)]
843pub struct nftnl_table(c_void);
844
845extern "C" {
846 pub fn nftnl_table_alloc() -> *mut nftnl_table;
847
848 pub fn nftnl_table_free(arg1: *const nftnl_table);
849}
850pub const NFTNL_TABLE_NAME: nftnl_table_attr = 0;
851pub const NFTNL_TABLE_FAMILY: nftnl_table_attr = 1;
852pub const NFTNL_TABLE_FLAGS: nftnl_table_attr = 2;
853pub const NFTNL_TABLE_USE: nftnl_table_attr = 3;
854pub const __NFTNL_TABLE_MAX: nftnl_table_attr = 4;
855pub type nftnl_table_attr = u32;
856extern "C" {
857 pub fn nftnl_table_is_set(t: *const nftnl_table, attr: u16) -> bool;
858
859 pub fn nftnl_table_unset(t: *mut nftnl_table, attr: u16);
860
861 pub fn nftnl_table_set(t: *mut nftnl_table, attr: u16, data: *const c_void);
862
863 pub fn nftnl_table_set_data(t: *mut nftnl_table, attr: u16, data: *const c_void, data_len: u32);
864
865 pub fn nftnl_table_get(t: *const nftnl_table, attr: u16) -> *const c_void;
866
867 pub fn nftnl_table_get_data(
868 t: *const nftnl_table,
869 attr: u16,
870 data_len: *mut u32,
871 ) -> *const c_void;
872
873 pub fn nftnl_table_set_u8(t: *mut nftnl_table, attr: u16, data: u8);
874
875 pub fn nftnl_table_set_u32(t: *mut nftnl_table, attr: u16, data: u32);
876
877 pub fn nftnl_table_set_str(t: *mut nftnl_table, attr: u16, str: *const c_char);
878
879 pub fn nftnl_table_get_u8(t: *const nftnl_table, attr: u16) -> u8;
880
881 pub fn nftnl_table_get_u32(t: *const nftnl_table, attr: u16) -> u32;
882
883 pub fn nftnl_table_get_str(t: *const nftnl_table, attr: u16) -> *const c_char;
884
885 pub fn nftnl_table_nlmsg_build_payload(nlh: *mut nlmsghdr, t: *const nftnl_table);
886
887 pub fn nftnl_table_parse(
888 t: *mut nftnl_table,
889 type_: nftnl_parse_type,
890 data: *const c_char,
891 err: *mut nftnl_parse_err,
892 ) -> c_int;
893
894 pub fn nftnl_table_parse_file(
895 t: *mut nftnl_table,
896 type_: nftnl_parse_type,
897 fp: *mut FILE,
898 err: *mut nftnl_parse_err,
899 ) -> c_int;
900
901 pub fn nftnl_table_snprintf(
902 buf: *mut c_char,
903 size: usize,
904 t: *const nftnl_table,
905 type_: u32,
906 flags: u32,
907 ) -> c_int;
908
909 pub fn nftnl_table_fprintf(
910 fp: *mut FILE,
911 t: *const nftnl_table,
912 type_: u32,
913 flags: u32,
914 ) -> c_int;
915
916 pub fn nftnl_table_nlmsg_parse(nlh: *const nlmsghdr, t: *mut nftnl_table) -> c_int;
917}
918#[repr(C)]
919pub struct nftnl_table_list(c_void);
920
921extern "C" {
922 pub fn nftnl_table_list_alloc() -> *mut nftnl_table_list;
923
924 pub fn nftnl_table_list_free(list: *mut nftnl_table_list);
925
926 pub fn nftnl_table_list_is_empty(list: *const nftnl_table_list) -> c_int;
927
928 pub fn nftnl_table_list_foreach(
929 table_list: *mut nftnl_table_list,
930 cb: Option<unsafe extern "C" fn(t: *mut nftnl_table, data: *mut c_void) -> c_int>,
931 data: *mut c_void,
932 ) -> c_int;
933
934 pub fn nftnl_table_list_add(r: *mut nftnl_table, list: *mut nftnl_table_list);
935
936 pub fn nftnl_table_list_add_tail(r: *mut nftnl_table, list: *mut nftnl_table_list);
937
938 pub fn nftnl_table_list_del(r: *mut nftnl_table);
939}
940#[repr(C)]
941pub struct nftnl_table_list_iter(c_void);
942
943extern "C" {
944 pub fn nftnl_table_list_iter_create(l: *mut nftnl_table_list) -> *mut nftnl_table_list_iter;
945
946 pub fn nftnl_table_list_iter_next(iter: *mut nftnl_table_list_iter) -> *mut nftnl_table;
947
948 pub fn nftnl_table_list_iter_destroy(iter: *const nftnl_table_list_iter);
949}
950pub const NFTNL_TRACE_CHAIN: nftnl_trace_attr = 0;
951pub const NFTNL_TRACE_FAMILY: nftnl_trace_attr = 1;
952pub const NFTNL_TRACE_ID: nftnl_trace_attr = 2;
953pub const NFTNL_TRACE_IIF: nftnl_trace_attr = 3;
954pub const NFTNL_TRACE_IIFTYPE: nftnl_trace_attr = 4;
955pub const NFTNL_TRACE_JUMP_TARGET: nftnl_trace_attr = 5;
956pub const NFTNL_TRACE_OIF: nftnl_trace_attr = 6;
957pub const NFTNL_TRACE_OIFTYPE: nftnl_trace_attr = 7;
958pub const NFTNL_TRACE_MARK: nftnl_trace_attr = 8;
959pub const NFTNL_TRACE_LL_HEADER: nftnl_trace_attr = 9;
960pub const NFTNL_TRACE_NETWORK_HEADER: nftnl_trace_attr = 10;
961pub const NFTNL_TRACE_TRANSPORT_HEADER: nftnl_trace_attr = 11;
962pub const NFTNL_TRACE_TABLE: nftnl_trace_attr = 12;
963pub const NFTNL_TRACE_TYPE: nftnl_trace_attr = 13;
964pub const NFTNL_TRACE_RULE_HANDLE: nftnl_trace_attr = 14;
965pub const NFTNL_TRACE_VERDICT: nftnl_trace_attr = 15;
966pub const NFTNL_TRACE_NFPROTO: nftnl_trace_attr = 16;
967pub const NFTNL_TRACE_POLICY: nftnl_trace_attr = 17;
968pub const __NFTNL_TRACE_MAX: nftnl_trace_attr = 18;
969pub type nftnl_trace_attr = u32;
970#[repr(C)]
971pub struct nftnl_trace(c_void);
972
973extern "C" {
974 pub fn nftnl_trace_alloc() -> *mut nftnl_trace;
975
976 pub fn nftnl_trace_free(trace: *const nftnl_trace);
977
978 pub fn nftnl_trace_is_set(trace: *const nftnl_trace, type_: u16) -> bool;
979
980 pub fn nftnl_trace_get_data(
981 trace: *const nftnl_trace,
982 type_: u16,
983 data_len: *mut u32,
984 ) -> *const c_void;
985
986 pub fn nftnl_trace_get_u16(trace: *const nftnl_trace, type_: u16) -> u16;
987
988 pub fn nftnl_trace_get_u32(trace: *const nftnl_trace, type_: u16) -> u32;
989
990 pub fn nftnl_trace_get_u64(trace: *const nftnl_trace, type_: u16) -> u64;
991
992 pub fn nftnl_trace_get_str(trace: *const nftnl_trace, type_: u16) -> *const c_char;
993
994 pub fn nftnl_trace_nlmsg_parse(nlh: *const nlmsghdr, t: *mut nftnl_trace) -> c_int;
995}
996#[repr(C)]
997pub struct nftnl_udata(c_void);
998
999#[repr(C)]
1000pub struct nftnl_udata_buf(c_void);
1001
1002extern "C" {
1003 pub fn nftnl_udata_buf_alloc(data_size: u32) -> *mut nftnl_udata_buf;
1004
1005 pub fn nftnl_udata_buf_free(buf: *const nftnl_udata_buf);
1006
1007 pub fn nftnl_udata_buf_len(buf: *const nftnl_udata_buf) -> u32;
1008
1009 pub fn nftnl_udata_buf_data(buf: *const nftnl_udata_buf) -> *mut c_void;
1010
1011 pub fn nftnl_udata_buf_put(buf: *mut nftnl_udata_buf, data: *const c_void, len: u32);
1012
1013 pub fn nftnl_udata_start(buf: *const nftnl_udata_buf) -> *mut nftnl_udata;
1014
1015 pub fn nftnl_udata_end(buf: *const nftnl_udata_buf) -> *mut nftnl_udata;
1016
1017 pub fn nftnl_udata_put(
1018 buf: *mut nftnl_udata_buf,
1019 type_: u8,
1020 len: u32,
1021 value: *const c_void,
1022 ) -> bool;
1023
1024 pub fn nftnl_udata_put_strz(buf: *mut nftnl_udata_buf, type_: u8, strz: *const c_char) -> bool;
1025
1026 pub fn nftnl_udata_type(attr: *const nftnl_udata) -> u8;
1027
1028 pub fn nftnl_udata_len(attr: *const nftnl_udata) -> u8;
1029
1030 pub fn nftnl_udata_get(attr: *const nftnl_udata) -> *mut c_void;
1031
1032 pub fn nftnl_udata_next(attr: *const nftnl_udata) -> *mut nftnl_udata;
1033}
1034pub type nftnl_udata_cb_t =
1035 Option<unsafe extern "C" fn(attr: *const nftnl_udata, data: *mut c_void) -> c_int>;
1036extern "C" {
1037 pub fn nftnl_udata_parse(
1038 data: *const c_void,
1039 data_len: u32,
1040 cb: nftnl_udata_cb_t,
1041 cb_data: *mut c_void,
1042 ) -> c_int;
1043}