nftables_json/
command.rs

1// Copyright (c) nftables-json Developers
2// SPDX-License-Identifier: MIT OR Apache-2.0
3
4//! Provides types related to inputting commands to `nft --json`
5
6use crate::expression::*;
7use crate::statement::*;
8
9#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
10#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
11#[serde(deny_unknown_fields)]
12pub struct AddChain {
13    pub family: String,
14    pub table: String,
15    pub name: String,
16    pub dev: Option<String>,
17    pub policy: Option<String>,
18    #[serde(rename = "type")]
19    pub r#type: Option<String>,
20    pub hook: Option<String>,
21    pub prio: Option<isize>,
22}
23
24#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
25#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
26#[serde(deny_unknown_fields)]
27pub struct AddCounter {
28    pub family: String,
29    pub table: String,
30    pub name: String,
31    pub comment: Option<String>,
32    pub packets: Option<isize>,
33    pub bytes: Option<isize>,
34}
35
36#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
37#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
38#[serde(deny_unknown_fields)]
39pub struct AddCtExpectation {
40    pub family: String,
41    pub table: String,
42    pub name: String,
43    pub comment: Option<String>,
44    pub protocol: Option<String>,
45    pub l3proto: Option<String>,
46    pub dport: Option<String>,
47    pub timeout: Option<isize>,
48    pub size: Option<String>,
49}
50
51#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
52#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
53#[serde(deny_unknown_fields)]
54pub struct AddCtHelper {
55    pub family: String,
56    pub table: String,
57    pub name: String,
58    pub comment: Option<String>,
59    #[serde(rename = "type")]
60    pub r#type: Option<String>,
61    pub protocol: Option<String>,
62    pub l3proto: Option<String>,
63}
64
65#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
66#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
67#[serde(deny_unknown_fields)]
68pub struct AddCtTimeout {
69    pub family: String,
70    pub table: String,
71    pub name: String,
72    pub comment: Option<String>,
73    pub protocol: Option<String>,
74    pub l3proto: Option<String>,
75    pub policy: Option<std::collections::HashMap<String, isize>>,
76}
77
78#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
79#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
80#[serde(deny_unknown_fields)]
81pub struct AddElement {
82    pub family: String,
83    pub table: String,
84    pub name: String,
85    #[serde(with = "serde_with::As::<Option<serde_with::OneOrMany<serde_with::Same>>>")]
86    pub elem: Option<Vec<Expression>>,
87}
88
89#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
90#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
91#[serde(deny_unknown_fields)]
92pub struct AddFlowtable {
93    pub family: String,
94    pub table: String,
95    pub name: String,
96    pub comment: Option<String>,
97    pub hook: Option<String>,
98    pub prio: Option<isize>,
99    #[serde(with = "serde_with::As::<Option<serde_with::OneOrMany<serde_with::Same>>>")]
100    pub dev: Option<Vec<String>>,
101}
102
103#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
104#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
105#[serde(deny_unknown_fields)]
106pub struct AddLimit {
107    pub family: String,
108    pub table: String,
109    pub name: String,
110    pub comment: Option<String>,
111    pub rate: Option<isize>,
112    pub rate_unit: Option<String>,
113    pub per: Option<String>,
114    pub burst: Option<isize>,
115    pub burst_unit: Option<String>,
116    pub inv: Option<bool>,
117}
118
119#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
120#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
121#[serde(deny_unknown_fields)]
122pub struct AddMap {
123    pub family: String,
124    pub table: String,
125    pub name: String,
126    pub comment: Option<String>,
127    pub map: Option<String>,
128    #[serde(rename = "type")]
129    pub r#type: Option<String>,
130    pub policy: Option<String>,
131    pub flags: Option<Vec<String>>,
132    pub size: Option<isize>,
133    pub timeout: Option<isize>,
134    #[serde(rename = "gc-interval")]
135    pub gc_interval: Option<isize>,
136    #[serde(with = "serde_with::As::<Option<serde_with::OneOrMany<serde_with::Same>>>")]
137    pub elem: Option<Vec<Expression>>,
138    pub stmt: Option<Vec<Statement>>,
139}
140
141#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
142#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
143#[serde(deny_unknown_fields)]
144pub struct AddQuota {
145    pub family: String,
146    pub table: String,
147    pub name: String,
148    pub comment: Option<String>,
149    pub bytes: Option<isize>,
150    pub used: Option<isize>,
151    pub inv: Option<bool>,
152}
153
154#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
155#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
156#[serde(deny_unknown_fields)]
157pub struct AddRule {
158    pub family: String,
159    pub table: String,
160    pub chain: String,
161    pub index: Option<isize>,
162    pub comment: Option<String>,
163    pub expr: Option<Vec<Statement>>,
164}
165
166#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
167#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
168#[serde(deny_unknown_fields)]
169pub struct AddSecmark {
170    pub family: String,
171    pub table: String,
172    pub name: String,
173    pub comment: Option<String>,
174    pub context: Option<String>,
175}
176
177#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
178#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
179#[serde(deny_unknown_fields)]
180pub struct AddSet {
181    pub family: String,
182    pub table: String,
183    pub name: String,
184    pub comment: Option<String>,
185    #[serde(rename = "type")]
186    pub r#type: Option<String>,
187    pub policy: Option<String>,
188    pub flags: Option<Vec<String>>,
189    pub size: Option<isize>,
190    pub timeout: Option<isize>,
191    #[serde(rename = "gc-interval")]
192    pub gc_interval: Option<isize>,
193    #[serde(with = "serde_with::As::<Option<serde_with::OneOrMany<serde_with::Same>>>")]
194    pub elem: Option<Vec<Expression>>,
195    pub stmt: Option<Vec<Statement>>,
196}
197
198#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
199#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
200#[serde(deny_unknown_fields)]
201pub struct AddSynproxy {
202    pub family: String,
203    pub table: String,
204    pub name: String,
205    pub comment: Option<String>,
206    pub mss: Option<isize>,
207    pub wscale: Option<isize>,
208    #[serde(with = "serde_with::As::<Option<serde_with::OneOrMany<serde_with::Same>>>")]
209    pub flags: Option<Vec<String>>,
210}
211
212#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
213#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
214#[serde(deny_unknown_fields)]
215pub struct AddTable {
216    pub family: String,
217    pub name: String,
218    pub flags: Option<Vec<String>>,
219}
220
221#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
222#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
223#[serde(deny_unknown_fields, rename_all = "kebab-case")]
224#[non_exhaustive]
225pub enum Add {
226    Table(AddTable),
227    Chain(AddChain),
228    Rule(AddRule),
229    Set(AddSet),
230    Map(AddMap),
231    Element(AddElement),
232    Flowtable(AddFlowtable),
233    Counter(AddCounter),
234    Quota(AddQuota),
235    #[serde(rename = "ct helper")]
236    CtHelper(AddCtHelper),
237    #[serde(rename = "ct timeout")]
238    CtTimeout(AddCtTimeout),
239    #[serde(rename = "ct expectation")]
240    CtExpectation(AddCtExpectation),
241    Limit(AddLimit),
242    Secmark(AddSecmark),
243    Synproxy(AddSynproxy),
244}
245
246pub type ReplaceRule = AddRule;
247
248#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
249#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
250#[serde(deny_unknown_fields, rename_all = "kebab-case")]
251#[non_exhaustive]
252pub enum Replace {
253    Rule(ReplaceRule),
254}
255
256pub type InsertRule = AddRule;
257
258#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
259#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
260#[serde(deny_unknown_fields, rename_all = "kebab-case")]
261#[non_exhaustive]
262pub enum Insert {
263    Rule(InsertRule),
264}
265
266#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
267#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
268#[serde(deny_unknown_fields)]
269pub struct DeleteTable {
270    pub family: String,
271    pub name: Option<String>,
272    pub handle: Option<isize>,
273}
274
275#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
276#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
277#[serde(deny_unknown_fields)]
278pub struct DeleteChain {
279    pub family: String,
280    pub table: String,
281    pub name: Option<String>,
282    pub handle: Option<isize>,
283}
284
285#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
286#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
287#[serde(deny_unknown_fields)]
288pub struct DeleteRule {
289    pub family: String,
290    pub table: String,
291    pub chain: String,
292    pub handle: isize,
293}
294
295#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
296#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
297#[serde(deny_unknown_fields)]
298pub struct DeleteSet {
299    pub family: String,
300    pub table: String,
301    pub name: Option<String>,
302    pub handle: Option<isize>,
303}
304
305#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
306#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
307#[serde(deny_unknown_fields)]
308pub struct DeleteMap {
309    pub family: String,
310    pub table: String,
311    pub name: Option<String>,
312    pub handle: Option<isize>,
313}
314
315pub type DeleteElement = AddElement;
316
317#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
318#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
319#[serde(deny_unknown_fields)]
320pub struct DeleteFlowtable {
321    pub family: String,
322    pub table: String,
323    pub name: Option<String>,
324    pub handle: Option<isize>,
325}
326
327#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
328#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
329#[serde(deny_unknown_fields)]
330pub struct DeleteCounter {
331    pub family: String,
332    pub table: String,
333    pub name: Option<String>,
334    pub handle: Option<isize>,
335}
336
337#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
338#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
339#[serde(deny_unknown_fields)]
340pub struct DeleteQuota {
341    pub family: String,
342    pub table: String,
343    pub name: Option<String>,
344    pub handle: Option<isize>,
345}
346
347#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
348#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
349#[serde(deny_unknown_fields)]
350pub struct DeleteCtHelper {
351    pub family: String,
352    pub table: String,
353    pub name: Option<String>,
354    pub handle: Option<isize>,
355}
356
357#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
358#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
359#[serde(deny_unknown_fields)]
360pub struct DeleteCtTimeout {
361    pub family: String,
362    pub table: String,
363    pub name: Option<String>,
364    pub handle: Option<isize>,
365}
366
367#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
368#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
369#[serde(deny_unknown_fields)]
370pub struct DeleteCtExpectation {
371    pub family: String,
372    pub table: String,
373    pub name: Option<String>,
374    pub handle: Option<isize>,
375}
376
377#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
378#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
379#[serde(deny_unknown_fields)]
380pub struct DeleteLimit {
381    pub family: String,
382    pub table: String,
383    pub name: Option<String>,
384    pub handle: Option<isize>,
385}
386
387#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
388#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
389#[serde(deny_unknown_fields)]
390pub struct DeleteSecmark {
391    pub family: String,
392    pub table: String,
393    pub name: Option<String>,
394    pub handle: Option<isize>,
395}
396
397#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
398#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
399#[serde(deny_unknown_fields, rename_all = "kebab-case")]
400#[non_exhaustive]
401pub enum Delete {
402    Table(DeleteTable),
403    Chain(DeleteChain),
404    Rule(DeleteRule),
405    Set(DeleteSet),
406    Map(DeleteMap),
407    Element(DeleteElement),
408    Flowtable(DeleteFlowtable),
409    Counter(DeleteCounter),
410    Quota(DeleteQuota),
411    #[serde(rename = "ct helper")]
412    CtHelper(DeleteCtHelper),
413    #[serde(rename = "ct timeout")]
414    CtTimeout(DeleteCtTimeout),
415    #[serde(rename = "ct expectation")]
416    CtExpectation(DeleteCtExpectation),
417    Limit(DeleteLimit),
418    Secmark(DeleteSecmark),
419}
420
421#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
422#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
423#[serde(deny_unknown_fields)]
424pub struct ListTable {
425    pub family: String,
426    pub name: String,
427}
428
429#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
430#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
431#[serde(deny_unknown_fields)]
432pub struct ListChain {
433    pub family: String,
434    pub table: String,
435    pub name: String,
436}
437
438#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
439#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
440#[serde(deny_unknown_fields)]
441pub struct ListSet {
442    pub family: String,
443    pub table: String,
444    pub name: String,
445}
446
447#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
448#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
449#[serde(deny_unknown_fields)]
450pub struct ListMap {
451    pub family: String,
452    pub table: String,
453    pub name: String,
454}
455
456#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
457#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
458#[serde(deny_unknown_fields)]
459pub struct ListCounter {
460    pub family: String,
461    pub table: String,
462    pub name: String,
463}
464
465#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
466#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
467#[serde(deny_unknown_fields)]
468pub struct ListQuota {
469    pub family: String,
470    pub table: String,
471    pub name: String,
472}
473
474#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
475#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
476#[serde(deny_unknown_fields)]
477pub struct ListCtHelper {
478    pub family: String,
479    pub table: String,
480    pub name: String,
481}
482
483#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
484#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
485#[serde(deny_unknown_fields)]
486pub struct ListCtTimeout {
487    pub family: String,
488    pub table: String,
489    pub name: String,
490}
491
492#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
493#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
494#[serde(deny_unknown_fields)]
495pub struct ListCtExpectation {
496    pub family: String,
497    pub table: String,
498    pub name: String,
499}
500
501#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
502#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
503#[serde(deny_unknown_fields)]
504pub struct ListLimit {
505    pub family: String,
506    pub table: String,
507    pub name: String,
508}
509
510#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
511#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
512#[serde(deny_unknown_fields)]
513pub struct ListMeter {
514    pub family: String,
515    pub table: String,
516    pub name: String,
517}
518
519#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
520#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
521#[serde(deny_unknown_fields)]
522pub struct ListFlowtable {
523    pub family: String,
524    pub table: String,
525    pub name: String,
526}
527
528#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
529#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
530#[serde(deny_unknown_fields)]
531pub struct ListSecmark {
532    pub family: String,
533    pub table: String,
534    pub name: String,
535}
536
537#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
538#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
539#[serde(deny_unknown_fields)]
540pub struct ListTables {
541    pub family: String,
542}
543
544#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
545#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
546#[serde(deny_unknown_fields)]
547pub struct ListChains {
548    pub family: String,
549}
550
551#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
552#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
553#[serde(deny_unknown_fields)]
554pub struct ListSets {
555    pub family: Option<String>,
556    pub table: String,
557}
558
559#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
560#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
561#[serde(deny_unknown_fields)]
562pub struct ListMaps {
563    pub family: String,
564}
565
566#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
567#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
568#[serde(deny_unknown_fields)]
569pub struct ListCounters {
570    pub family: Option<String>,
571    pub table: String,
572}
573
574#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
575#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
576#[serde(deny_unknown_fields)]
577pub struct ListQuotas {
578    pub family: String,
579}
580
581#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
582#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
583#[serde(deny_unknown_fields)]
584pub struct ListCtHelpers {
585    pub family: Option<String>,
586    pub table: String,
587}
588
589#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
590#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
591#[serde(deny_unknown_fields)]
592pub struct ListLimits {
593    pub family: String,
594}
595
596#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
597#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
598#[serde(deny_unknown_fields)]
599pub struct ListRuleset {
600    pub family: String,
601}
602
603#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
604#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
605#[serde(deny_unknown_fields)]
606pub struct ListMeters {
607    pub family: String,
608}
609
610#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
611#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
612#[serde(deny_unknown_fields)]
613pub struct ListFlowtables {
614    pub family: String,
615}
616
617#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
618#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
619#[serde(deny_unknown_fields)]
620pub struct ListSecmarks {
621    pub family: String,
622}
623
624#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
625#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
626#[serde(deny_unknown_fields, rename_all = "kebab-case")]
627#[non_exhaustive]
628pub enum List {
629    Table(ListTable),
630    Chain(ListChain),
631    Set(ListSet),
632    Map(ListMap),
633    Counter(ListCounter),
634    Quota(ListQuota),
635    #[serde(rename = "ct helper")]
636    CtHelper(ListCtHelper),
637    #[serde(rename = "ct timeout")]
638    CtTimeout(ListCtTimeout),
639    #[serde(rename = "ct expectation")]
640    CtExpectation(ListCtExpectation),
641    Limit(ListLimit),
642    Meter(ListMeter),
643    Flowtable(ListFlowtable),
644    Secmark(ListSecmark),
645    Tables(Option<ListTables>),
646    Chains(Option<ListChains>),
647    Sets(Option<ListSets>),
648    Maps(Option<ListMaps>),
649    Counters(Option<ListCounters>),
650    Quotas(Option<ListQuotas>),
651    #[serde(rename = "ct helpers")]
652    CtHelpers(Option<ListCtHelpers>),
653    Limits(Option<ListLimits>),
654    Ruleset(Option<ListRuleset>),
655    Meters(Option<ListMeters>),
656    Flowtables(Option<ListFlowtables>),
657    Secmarks(Option<ListSecmarks>),
658}
659
660#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
661#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
662#[serde(deny_unknown_fields)]
663pub struct ResetCounter {
664    pub family: String,
665    pub table: String,
666    pub name: String,
667}
668
669#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
670#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
671#[serde(deny_unknown_fields)]
672pub struct ResetCounters {
673    pub family: Option<String>,
674    pub table: String,
675}
676
677#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
678#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
679#[serde(deny_unknown_fields)]
680pub struct ResetQuota {
681    pub family: String,
682    pub table: String,
683    pub name: String,
684}
685
686#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
687#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
688#[serde(deny_unknown_fields)]
689pub struct ResetQuotas {
690    pub family: String,
691}
692
693#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
694#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
695#[serde(deny_unknown_fields, rename_all = "kebab-case")]
696#[non_exhaustive]
697pub enum Reset {
698    Counter(ResetCounter),
699    Counters(Option<ResetCounters>),
700    Quota(ResetQuota),
701    Quotas(Option<ResetQuotas>),
702}
703
704#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
705#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
706#[serde(deny_unknown_fields)]
707pub struct FlushTable {
708    pub family: String,
709    pub name: String,
710}
711
712#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
713#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
714#[serde(deny_unknown_fields)]
715pub struct FlushChain {
716    pub family: String,
717    pub table: String,
718    pub name: String,
719}
720
721#[serde_with::apply(Option => # [serde(default, skip_serializing_if = "Option::is_none")])]
722#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
723#[serde(deny_unknown_fields)]
724pub struct FlushSet {
725    pub family: String,
726    pub table: String,
727    pub name: String,
728}
729
730#[serde_with::apply(Option => # [serde(default, skip_serializing_if = "Option::is_none")])]
731#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
732#[serde(deny_unknown_fields)]
733pub struct FlushMap {
734    pub family: String,
735    pub table: String,
736    pub name: String,
737}
738
739#[serde_with::apply(Option => # [serde(default, skip_serializing_if = "Option::is_none")])]
740#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
741#[serde(deny_unknown_fields)]
742pub struct FlushMeter {
743    pub family: String,
744    pub table: String,
745    pub name: String,
746}
747
748#[serde_with::apply(Option => # [serde(default, skip_serializing_if = "Option::is_none")])]
749#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
750#[serde(deny_unknown_fields)]
751pub struct FlushRuleset {
752    pub family: String,
753}
754
755#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
756#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
757#[serde(deny_unknown_fields, rename_all = "kebab-case")]
758#[non_exhaustive]
759pub enum Flush {
760    Table(FlushTable),
761    Chain(FlushChain),
762    Set(FlushSet),
763    Map(FlushMap),
764    Meter(FlushMeter),
765    Ruleset(Option<FlushRuleset>),
766}
767
768#[serde_with::apply(Option => # [serde(default, skip_serializing_if = "Option::is_none")])]
769#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
770#[serde(deny_unknown_fields)]
771pub struct RenameChain {
772    pub family: String,
773    pub table: String,
774    pub name: String,
775    pub newname: String,
776}
777
778#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
779#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
780#[serde(deny_unknown_fields, rename_all = "kebab-case")]
781#[non_exhaustive]
782pub enum Rename {
783    Chain(RenameChain),
784}
785
786/// Represents a command to issue to the `nft` binary
787#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
788#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
789#[serde(deny_unknown_fields, rename_all = "kebab-case")]
790#[non_exhaustive]
791pub enum Command {
792    Metainfo { json_schema_version: isize },
793    Add(Add),
794    Replace(Replace),
795    Create(Add),
796    Insert(Insert),
797    Delete(Delete),
798    List(List),
799    Reset(Reset),
800    Flush(Flush),
801    Rename(Rename),
802}
803
804/// Represents a list of commands to issue to the `nft` binary
805#[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
806#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
807#[serde(deny_unknown_fields)]
808pub struct Commands {
809    #[serde(rename = "nftables")]
810    commands: Vec<Command>,
811}
812
813impl Commands {
814    pub fn new() -> Self {
815        Self::default()
816    }
817
818    pub fn from_value(value: serde_json::Value) -> serde_json::Result<Self> {
819        serde_json::from_value(value)
820    }
821
822    pub fn from_str(string: &str) -> serde_json::Result<Self> {
823        serde_json::from_str(string)
824    }
825
826    pub fn from_slice(slice: &[u8]) -> serde_json::Result<Self> {
827        serde_json::from_slice(slice)
828    }
829
830    pub fn from_reader<R: std::io::Read>(reader: R) -> serde_json::Result<Self> {
831        serde_json::from_reader(reader)
832    }
833
834    pub fn to_value(&self) -> serde_json::Result<serde_json::Value> {
835        serde_json::to_value(self)
836    }
837
838    pub fn to_string(&self) -> serde_json::Result<String> {
839        serde_json::to_string(self)
840    }
841}
842
843impl From<&[Command]> for Commands {
844    fn from(value: &[Command]) -> Self {
845        Self { commands: Vec::from(value) }
846    }
847}
848
849impl From<&mut [Command]> for Commands {
850    fn from(value: &mut [Command]) -> Self {
851        Self { commands: Vec::from(value) }
852    }
853}
854
855impl From<Box<[Command]>> for Commands {
856    fn from(value: Box<[Command]>) -> Self {
857        Self { commands: Vec::from(value) }
858    }
859}
860
861impl From<Vec<Command>> for Commands {
862    fn from(value: Vec<Command>) -> Self {
863        Self { commands: Vec::from(value) }
864    }
865}
866
867impl FromIterator<Command> for Commands {
868    fn from_iter<T: IntoIterator<Item = Command>>(iter: T) -> Self {
869        Self { commands: Vec::from_iter(iter) }
870    }
871}
872
873impl Extend<Command> for Commands {
874    fn extend<T: IntoIterator<Item = Command>>(&mut self, iter: T) {
875        self.commands.extend(iter.into_iter());
876    }
877}
878
879impl<'a> Extend<&'a Command> for Commands {
880    fn extend<T: IntoIterator<Item = &'a Command>>(&mut self, iter: T) {
881        self.commands.extend(iter.into_iter().map(|item| item.clone()));
882    }
883}
884
885impl std::ops::Deref for Commands {
886    type Target = [Command];
887
888    fn deref(&self) -> &Self::Target {
889        &self.commands
890    }
891}
892
893impl std::ops::DerefMut for Commands {
894    fn deref_mut(&mut self) -> &mut Self::Target {
895        &mut self.commands
896    }
897}
898
899impl std::fmt::Display for Commands {
900    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
901        f.write_str(&self.to_string().map_err(|_| std::fmt::Error::default())?)
902    }
903}
nftables_json/command.rs

nftables_json/
command.rs
