1#![doc = "Multipath TCP\\."]
2#![allow(clippy::all)]
3#![allow(unused_imports)]
4#![allow(unused_assignments)]
5#![allow(non_snake_case)]
6#![allow(unused_variables)]
7#![allow(irrefutable_let_patterns)]
8#![allow(unreachable_code)]
9#![allow(unreachable_patterns)]
10use crate::builtin::{BuiltinBitfield32, BuiltinNfgenmsg, Nlmsghdr, PushDummy};
11use crate::{
12 consts,
13 traits::{NetlinkRequest, Protocol},
14 utils::*,
15};
16pub const PROTONAME: &str = "mptcp_pm";
17pub const PROTONAME_CSTR: &CStr = c"mptcp_pm";
18#[doc = "Netlink MPTCP event types"]
19#[doc = "Enum - defines an integer enumeration, with values for each entry incrementing by 1, (e.g. 0, 1, 2, 3)"]
20#[derive(Debug, Clone, Copy)]
21pub enum EventType {
22 #[doc = "unused event"]
23 Unspec = 0,
24 #[doc = "A new MPTCP connection has been created\\. It is the good time to allocate memory and send ADD\\_ADDR if needed\\. Depending on the traffic\\-patterns it can take a long time until the MPTCP\\_EVENT\\_ESTABLISHED is sent\\. Attributes: token, family, saddr4 | saddr6, daddr4 | daddr6, sport, dport, \\[server\\-side\\], \\[flags\\]\\."]
25 Created = 1,
26 #[doc = "A MPTCP connection is established (can start new subflows)\\. Attributes: token, family, saddr4 | saddr6, daddr4 | daddr6, sport, dport, \\[server\\-side\\], \\[flags\\]\\."]
27 Established = 2,
28 #[doc = "A MPTCP connection has stopped\\. Attribute: token\\."]
29 Closed = 3,
30 #[doc = "A new address has been announced by the peer\\. Attributes: token, rem\\_id, family, daddr4 | daddr6 \\[, dport\\]\\."]
31 Announced = 6,
32 #[doc = "An address has been lost by the peer\\. Attributes: token, rem\\_id\\."]
33 Removed = 7,
34 #[doc = "A new subflow has been established\\. 'error' should not be set\\. Attributes: token, family, loc\\_id, rem\\_id, saddr4 | saddr6, daddr4 | daddr6, sport, dport, backup, if\\-idx \\[, error\\]\\."]
35 SubEstablished = 10,
36 #[doc = "A subflow has been closed\\. An error (copy of sk\\_err) could be set if an error has been detected for this subflow\\. Attributes: token, family, loc\\_id, rem\\_id, saddr4 | saddr6, daddr4 | daddr6, sport, dport, backup, if\\-idx \\[, error\\]\\."]
37 SubClosed = 11,
38 #[doc = "The priority of a subflow has changed\\. 'error' should not be set\\. Attributes: token, family, loc\\_id, rem\\_id, saddr4 | saddr6, daddr4 | daddr6, sport, dport, backup, if\\-idx \\[, error\\]\\."]
39 SubPriority = 13,
40 #[doc = "A new PM listener is created\\. Attributes: family, sport, saddr4 | saddr6\\."]
41 ListenerCreated = 15,
42 #[doc = "A PM listener is closed\\. Attributes: family, sport, saddr4 | saddr6\\."]
43 ListenerClosed = 16,
44}
45impl EventType {
46 pub fn from_value(value: u64) -> Option<Self> {
47 Some(match value {
48 0 => Self::Unspec,
49 1 => Self::Created,
50 2 => Self::Established,
51 3 => Self::Closed,
52 6 => Self::Announced,
53 7 => Self::Removed,
54 10 => Self::SubEstablished,
55 11 => Self::SubClosed,
56 13 => Self::SubPriority,
57 15 => Self::ListenerCreated,
58 16 => Self::ListenerClosed,
59 _ => return None,
60 })
61 }
62}
63#[derive(Clone)]
64pub enum Address<'a> {
65 Family(u16),
66 Id(u8),
67 Addr4(u32),
68 Addr6(&'a [u8]),
69 Port(u16),
70 Flags(u32),
71 IfIdx(i32),
72}
73impl<'a> IterableAddress<'a> {
74 pub fn get_family(&self) -> Result<u16, ErrorContext> {
75 let mut iter = self.clone();
76 iter.pos = 0;
77 for attr in iter {
78 if let Address::Family(val) = attr? {
79 return Ok(val);
80 }
81 }
82 Err(ErrorContext::new_missing(
83 "Address",
84 "Family",
85 self.orig_loc,
86 self.buf.as_ptr() as usize,
87 ))
88 }
89 pub fn get_id(&self) -> Result<u8, ErrorContext> {
90 let mut iter = self.clone();
91 iter.pos = 0;
92 for attr in iter {
93 if let Address::Id(val) = attr? {
94 return Ok(val);
95 }
96 }
97 Err(ErrorContext::new_missing(
98 "Address",
99 "Id",
100 self.orig_loc,
101 self.buf.as_ptr() as usize,
102 ))
103 }
104 pub fn get_addr4(&self) -> Result<u32, ErrorContext> {
105 let mut iter = self.clone();
106 iter.pos = 0;
107 for attr in iter {
108 if let Address::Addr4(val) = attr? {
109 return Ok(val);
110 }
111 }
112 Err(ErrorContext::new_missing(
113 "Address",
114 "Addr4",
115 self.orig_loc,
116 self.buf.as_ptr() as usize,
117 ))
118 }
119 pub fn get_addr6(&self) -> Result<&'a [u8], ErrorContext> {
120 let mut iter = self.clone();
121 iter.pos = 0;
122 for attr in iter {
123 if let Address::Addr6(val) = attr? {
124 return Ok(val);
125 }
126 }
127 Err(ErrorContext::new_missing(
128 "Address",
129 "Addr6",
130 self.orig_loc,
131 self.buf.as_ptr() as usize,
132 ))
133 }
134 pub fn get_port(&self) -> Result<u16, ErrorContext> {
135 let mut iter = self.clone();
136 iter.pos = 0;
137 for attr in iter {
138 if let Address::Port(val) = attr? {
139 return Ok(val);
140 }
141 }
142 Err(ErrorContext::new_missing(
143 "Address",
144 "Port",
145 self.orig_loc,
146 self.buf.as_ptr() as usize,
147 ))
148 }
149 pub fn get_flags(&self) -> Result<u32, ErrorContext> {
150 let mut iter = self.clone();
151 iter.pos = 0;
152 for attr in iter {
153 if let Address::Flags(val) = attr? {
154 return Ok(val);
155 }
156 }
157 Err(ErrorContext::new_missing(
158 "Address",
159 "Flags",
160 self.orig_loc,
161 self.buf.as_ptr() as usize,
162 ))
163 }
164 pub fn get_if_idx(&self) -> Result<i32, ErrorContext> {
165 let mut iter = self.clone();
166 iter.pos = 0;
167 for attr in iter {
168 if let Address::IfIdx(val) = attr? {
169 return Ok(val);
170 }
171 }
172 Err(ErrorContext::new_missing(
173 "Address",
174 "IfIdx",
175 self.orig_loc,
176 self.buf.as_ptr() as usize,
177 ))
178 }
179}
180impl Address<'_> {
181 pub fn new<'a>(buf: &'a [u8]) -> IterableAddress<'a> {
182 IterableAddress::with_loc(buf, buf.as_ptr() as usize)
183 }
184 fn attr_from_type(r#type: u16) -> Option<&'static str> {
185 let res = match r#type {
186 0u16 => "Unspec",
187 1u16 => "Family",
188 2u16 => "Id",
189 3u16 => "Addr4",
190 4u16 => "Addr6",
191 5u16 => "Port",
192 6u16 => "Flags",
193 7u16 => "IfIdx",
194 _ => return None,
195 };
196 Some(res)
197 }
198}
199#[derive(Clone, Copy, Default)]
200pub struct IterableAddress<'a> {
201 buf: &'a [u8],
202 pos: usize,
203 orig_loc: usize,
204}
205impl<'a> IterableAddress<'a> {
206 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
207 Self {
208 buf,
209 pos: 0,
210 orig_loc,
211 }
212 }
213 pub fn get_buf(&self) -> &'a [u8] {
214 self.buf
215 }
216}
217impl<'a> Iterator for IterableAddress<'a> {
218 type Item = Result<Address<'a>, ErrorContext>;
219 fn next(&mut self) -> Option<Self::Item> {
220 let pos = self.pos;
221 let mut r#type;
222 loop {
223 r#type = None;
224 if self.buf.len() == self.pos {
225 return None;
226 }
227 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
228 break;
229 };
230 r#type = Some(header.r#type);
231 let res = match header.r#type {
232 1u16 => Address::Family({
233 let res = parse_u16(next);
234 let Some(val) = res else { break };
235 val
236 }),
237 2u16 => Address::Id({
238 let res = parse_u8(next);
239 let Some(val) = res else { break };
240 val
241 }),
242 3u16 => Address::Addr4({
243 let res = parse_be_u32(next);
244 let Some(val) = res else { break };
245 val
246 }),
247 4u16 => Address::Addr6({
248 let res = Some(next);
249 let Some(val) = res else { break };
250 val
251 }),
252 5u16 => Address::Port({
253 let res = parse_u16(next);
254 let Some(val) = res else { break };
255 val
256 }),
257 6u16 => Address::Flags({
258 let res = parse_u32(next);
259 let Some(val) = res else { break };
260 val
261 }),
262 7u16 => Address::IfIdx({
263 let res = parse_i32(next);
264 let Some(val) = res else { break };
265 val
266 }),
267 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
268 n => continue,
269 };
270 return Some(Ok(res));
271 }
272 Some(Err(ErrorContext::new(
273 "Address",
274 r#type.and_then(|t| Address::attr_from_type(t)),
275 self.orig_loc,
276 self.buf.as_ptr().wrapping_add(pos) as usize,
277 )))
278 }
279}
280impl<'a> std::fmt::Debug for IterableAddress<'_> {
281 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
282 let mut fmt = f.debug_struct("Address");
283 for attr in self.clone() {
284 let attr = match attr {
285 Ok(a) => a,
286 Err(err) => {
287 fmt.finish()?;
288 f.write_str("Err(")?;
289 err.fmt(f)?;
290 return f.write_str(")");
291 }
292 };
293 match attr {
294 Address::Family(val) => fmt.field("Family", &val),
295 Address::Id(val) => fmt.field("Id", &val),
296 Address::Addr4(val) => fmt.field("Addr4", &val),
297 Address::Addr6(val) => fmt.field("Addr6", &val),
298 Address::Port(val) => fmt.field("Port", &val),
299 Address::Flags(val) => fmt.field("Flags", &val),
300 Address::IfIdx(val) => fmt.field("IfIdx", &val),
301 };
302 }
303 fmt.finish()
304 }
305}
306impl IterableAddress<'_> {
307 pub fn lookup_attr(
308 &self,
309 offset: usize,
310 missing_type: Option<u16>,
311 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
312 let mut stack = Vec::new();
313 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
314 if missing_type.is_some() && cur == offset {
315 stack.push(("Address", offset));
316 return (stack, missing_type.and_then(|t| Address::attr_from_type(t)));
317 }
318 if cur > offset || cur + self.buf.len() < offset {
319 return (stack, None);
320 }
321 let mut attrs = self.clone();
322 let mut last_off = cur + attrs.pos;
323 while let Some(attr) = attrs.next() {
324 let Ok(attr) = attr else { break };
325 match attr {
326 Address::Family(val) => {
327 if last_off == offset {
328 stack.push(("Family", last_off));
329 break;
330 }
331 }
332 Address::Id(val) => {
333 if last_off == offset {
334 stack.push(("Id", last_off));
335 break;
336 }
337 }
338 Address::Addr4(val) => {
339 if last_off == offset {
340 stack.push(("Addr4", last_off));
341 break;
342 }
343 }
344 Address::Addr6(val) => {
345 if last_off == offset {
346 stack.push(("Addr6", last_off));
347 break;
348 }
349 }
350 Address::Port(val) => {
351 if last_off == offset {
352 stack.push(("Port", last_off));
353 break;
354 }
355 }
356 Address::Flags(val) => {
357 if last_off == offset {
358 stack.push(("Flags", last_off));
359 break;
360 }
361 }
362 Address::IfIdx(val) => {
363 if last_off == offset {
364 stack.push(("IfIdx", last_off));
365 break;
366 }
367 }
368 _ => {}
369 };
370 last_off = cur + attrs.pos;
371 }
372 if !stack.is_empty() {
373 stack.push(("Address", cur));
374 }
375 (stack, None)
376 }
377}
378#[derive(Clone)]
379pub enum SubflowAttribute<'a> {
380 TokenRem(u32),
381 TokenLoc(u32),
382 RelwriteSeq(u32),
383 MapSeq(u64),
384 MapSfseq(u32),
385 SsnOffset(u32),
386 MapDatalen(u16),
387 Flags(u32),
388 IdRem(u8),
389 IdLoc(u8),
390 Pad(&'a [u8]),
391}
392impl<'a> IterableSubflowAttribute<'a> {
393 pub fn get_token_rem(&self) -> Result<u32, ErrorContext> {
394 let mut iter = self.clone();
395 iter.pos = 0;
396 for attr in iter {
397 if let SubflowAttribute::TokenRem(val) = attr? {
398 return Ok(val);
399 }
400 }
401 Err(ErrorContext::new_missing(
402 "SubflowAttribute",
403 "TokenRem",
404 self.orig_loc,
405 self.buf.as_ptr() as usize,
406 ))
407 }
408 pub fn get_token_loc(&self) -> Result<u32, ErrorContext> {
409 let mut iter = self.clone();
410 iter.pos = 0;
411 for attr in iter {
412 if let SubflowAttribute::TokenLoc(val) = attr? {
413 return Ok(val);
414 }
415 }
416 Err(ErrorContext::new_missing(
417 "SubflowAttribute",
418 "TokenLoc",
419 self.orig_loc,
420 self.buf.as_ptr() as usize,
421 ))
422 }
423 pub fn get_relwrite_seq(&self) -> Result<u32, ErrorContext> {
424 let mut iter = self.clone();
425 iter.pos = 0;
426 for attr in iter {
427 if let SubflowAttribute::RelwriteSeq(val) = attr? {
428 return Ok(val);
429 }
430 }
431 Err(ErrorContext::new_missing(
432 "SubflowAttribute",
433 "RelwriteSeq",
434 self.orig_loc,
435 self.buf.as_ptr() as usize,
436 ))
437 }
438 pub fn get_map_seq(&self) -> Result<u64, ErrorContext> {
439 let mut iter = self.clone();
440 iter.pos = 0;
441 for attr in iter {
442 if let SubflowAttribute::MapSeq(val) = attr? {
443 return Ok(val);
444 }
445 }
446 Err(ErrorContext::new_missing(
447 "SubflowAttribute",
448 "MapSeq",
449 self.orig_loc,
450 self.buf.as_ptr() as usize,
451 ))
452 }
453 pub fn get_map_sfseq(&self) -> Result<u32, ErrorContext> {
454 let mut iter = self.clone();
455 iter.pos = 0;
456 for attr in iter {
457 if let SubflowAttribute::MapSfseq(val) = attr? {
458 return Ok(val);
459 }
460 }
461 Err(ErrorContext::new_missing(
462 "SubflowAttribute",
463 "MapSfseq",
464 self.orig_loc,
465 self.buf.as_ptr() as usize,
466 ))
467 }
468 pub fn get_ssn_offset(&self) -> Result<u32, ErrorContext> {
469 let mut iter = self.clone();
470 iter.pos = 0;
471 for attr in iter {
472 if let SubflowAttribute::SsnOffset(val) = attr? {
473 return Ok(val);
474 }
475 }
476 Err(ErrorContext::new_missing(
477 "SubflowAttribute",
478 "SsnOffset",
479 self.orig_loc,
480 self.buf.as_ptr() as usize,
481 ))
482 }
483 pub fn get_map_datalen(&self) -> Result<u16, ErrorContext> {
484 let mut iter = self.clone();
485 iter.pos = 0;
486 for attr in iter {
487 if let SubflowAttribute::MapDatalen(val) = attr? {
488 return Ok(val);
489 }
490 }
491 Err(ErrorContext::new_missing(
492 "SubflowAttribute",
493 "MapDatalen",
494 self.orig_loc,
495 self.buf.as_ptr() as usize,
496 ))
497 }
498 pub fn get_flags(&self) -> Result<u32, ErrorContext> {
499 let mut iter = self.clone();
500 iter.pos = 0;
501 for attr in iter {
502 if let SubflowAttribute::Flags(val) = attr? {
503 return Ok(val);
504 }
505 }
506 Err(ErrorContext::new_missing(
507 "SubflowAttribute",
508 "Flags",
509 self.orig_loc,
510 self.buf.as_ptr() as usize,
511 ))
512 }
513 pub fn get_id_rem(&self) -> Result<u8, ErrorContext> {
514 let mut iter = self.clone();
515 iter.pos = 0;
516 for attr in iter {
517 if let SubflowAttribute::IdRem(val) = attr? {
518 return Ok(val);
519 }
520 }
521 Err(ErrorContext::new_missing(
522 "SubflowAttribute",
523 "IdRem",
524 self.orig_loc,
525 self.buf.as_ptr() as usize,
526 ))
527 }
528 pub fn get_id_loc(&self) -> Result<u8, ErrorContext> {
529 let mut iter = self.clone();
530 iter.pos = 0;
531 for attr in iter {
532 if let SubflowAttribute::IdLoc(val) = attr? {
533 return Ok(val);
534 }
535 }
536 Err(ErrorContext::new_missing(
537 "SubflowAttribute",
538 "IdLoc",
539 self.orig_loc,
540 self.buf.as_ptr() as usize,
541 ))
542 }
543 pub fn get_pad(&self) -> Result<&'a [u8], ErrorContext> {
544 let mut iter = self.clone();
545 iter.pos = 0;
546 for attr in iter {
547 if let SubflowAttribute::Pad(val) = attr? {
548 return Ok(val);
549 }
550 }
551 Err(ErrorContext::new_missing(
552 "SubflowAttribute",
553 "Pad",
554 self.orig_loc,
555 self.buf.as_ptr() as usize,
556 ))
557 }
558}
559impl SubflowAttribute<'_> {
560 pub fn new<'a>(buf: &'a [u8]) -> IterableSubflowAttribute<'a> {
561 IterableSubflowAttribute::with_loc(buf, buf.as_ptr() as usize)
562 }
563 fn attr_from_type(r#type: u16) -> Option<&'static str> {
564 let res = match r#type {
565 0u16 => "Unspec",
566 1u16 => "TokenRem",
567 2u16 => "TokenLoc",
568 3u16 => "RelwriteSeq",
569 4u16 => "MapSeq",
570 5u16 => "MapSfseq",
571 6u16 => "SsnOffset",
572 7u16 => "MapDatalen",
573 8u16 => "Flags",
574 9u16 => "IdRem",
575 10u16 => "IdLoc",
576 11u16 => "Pad",
577 _ => return None,
578 };
579 Some(res)
580 }
581}
582#[derive(Clone, Copy, Default)]
583pub struct IterableSubflowAttribute<'a> {
584 buf: &'a [u8],
585 pos: usize,
586 orig_loc: usize,
587}
588impl<'a> IterableSubflowAttribute<'a> {
589 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
590 Self {
591 buf,
592 pos: 0,
593 orig_loc,
594 }
595 }
596 pub fn get_buf(&self) -> &'a [u8] {
597 self.buf
598 }
599}
600impl<'a> Iterator for IterableSubflowAttribute<'a> {
601 type Item = Result<SubflowAttribute<'a>, ErrorContext>;
602 fn next(&mut self) -> Option<Self::Item> {
603 let pos = self.pos;
604 let mut r#type;
605 loop {
606 r#type = None;
607 if self.buf.len() == self.pos {
608 return None;
609 }
610 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
611 break;
612 };
613 r#type = Some(header.r#type);
614 let res = match header.r#type {
615 1u16 => SubflowAttribute::TokenRem({
616 let res = parse_u32(next);
617 let Some(val) = res else { break };
618 val
619 }),
620 2u16 => SubflowAttribute::TokenLoc({
621 let res = parse_u32(next);
622 let Some(val) = res else { break };
623 val
624 }),
625 3u16 => SubflowAttribute::RelwriteSeq({
626 let res = parse_u32(next);
627 let Some(val) = res else { break };
628 val
629 }),
630 4u16 => SubflowAttribute::MapSeq({
631 let res = parse_u64(next);
632 let Some(val) = res else { break };
633 val
634 }),
635 5u16 => SubflowAttribute::MapSfseq({
636 let res = parse_u32(next);
637 let Some(val) = res else { break };
638 val
639 }),
640 6u16 => SubflowAttribute::SsnOffset({
641 let res = parse_u32(next);
642 let Some(val) = res else { break };
643 val
644 }),
645 7u16 => SubflowAttribute::MapDatalen({
646 let res = parse_u16(next);
647 let Some(val) = res else { break };
648 val
649 }),
650 8u16 => SubflowAttribute::Flags({
651 let res = parse_u32(next);
652 let Some(val) = res else { break };
653 val
654 }),
655 9u16 => SubflowAttribute::IdRem({
656 let res = parse_u8(next);
657 let Some(val) = res else { break };
658 val
659 }),
660 10u16 => SubflowAttribute::IdLoc({
661 let res = parse_u8(next);
662 let Some(val) = res else { break };
663 val
664 }),
665 11u16 => SubflowAttribute::Pad({
666 let res = Some(next);
667 let Some(val) = res else { break };
668 val
669 }),
670 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
671 n => continue,
672 };
673 return Some(Ok(res));
674 }
675 Some(Err(ErrorContext::new(
676 "SubflowAttribute",
677 r#type.and_then(|t| SubflowAttribute::attr_from_type(t)),
678 self.orig_loc,
679 self.buf.as_ptr().wrapping_add(pos) as usize,
680 )))
681 }
682}
683impl<'a> std::fmt::Debug for IterableSubflowAttribute<'_> {
684 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
685 let mut fmt = f.debug_struct("SubflowAttribute");
686 for attr in self.clone() {
687 let attr = match attr {
688 Ok(a) => a,
689 Err(err) => {
690 fmt.finish()?;
691 f.write_str("Err(")?;
692 err.fmt(f)?;
693 return f.write_str(")");
694 }
695 };
696 match attr {
697 SubflowAttribute::TokenRem(val) => fmt.field("TokenRem", &val),
698 SubflowAttribute::TokenLoc(val) => fmt.field("TokenLoc", &val),
699 SubflowAttribute::RelwriteSeq(val) => fmt.field("RelwriteSeq", &val),
700 SubflowAttribute::MapSeq(val) => fmt.field("MapSeq", &val),
701 SubflowAttribute::MapSfseq(val) => fmt.field("MapSfseq", &val),
702 SubflowAttribute::SsnOffset(val) => fmt.field("SsnOffset", &val),
703 SubflowAttribute::MapDatalen(val) => fmt.field("MapDatalen", &val),
704 SubflowAttribute::Flags(val) => fmt.field("Flags", &val),
705 SubflowAttribute::IdRem(val) => fmt.field("IdRem", &val),
706 SubflowAttribute::IdLoc(val) => fmt.field("IdLoc", &val),
707 SubflowAttribute::Pad(val) => fmt.field("Pad", &val),
708 };
709 }
710 fmt.finish()
711 }
712}
713impl IterableSubflowAttribute<'_> {
714 pub fn lookup_attr(
715 &self,
716 offset: usize,
717 missing_type: Option<u16>,
718 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
719 let mut stack = Vec::new();
720 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
721 if missing_type.is_some() && cur == offset {
722 stack.push(("SubflowAttribute", offset));
723 return (
724 stack,
725 missing_type.and_then(|t| SubflowAttribute::attr_from_type(t)),
726 );
727 }
728 if cur > offset || cur + self.buf.len() < offset {
729 return (stack, None);
730 }
731 let mut attrs = self.clone();
732 let mut last_off = cur + attrs.pos;
733 while let Some(attr) = attrs.next() {
734 let Ok(attr) = attr else { break };
735 match attr {
736 SubflowAttribute::TokenRem(val) => {
737 if last_off == offset {
738 stack.push(("TokenRem", last_off));
739 break;
740 }
741 }
742 SubflowAttribute::TokenLoc(val) => {
743 if last_off == offset {
744 stack.push(("TokenLoc", last_off));
745 break;
746 }
747 }
748 SubflowAttribute::RelwriteSeq(val) => {
749 if last_off == offset {
750 stack.push(("RelwriteSeq", last_off));
751 break;
752 }
753 }
754 SubflowAttribute::MapSeq(val) => {
755 if last_off == offset {
756 stack.push(("MapSeq", last_off));
757 break;
758 }
759 }
760 SubflowAttribute::MapSfseq(val) => {
761 if last_off == offset {
762 stack.push(("MapSfseq", last_off));
763 break;
764 }
765 }
766 SubflowAttribute::SsnOffset(val) => {
767 if last_off == offset {
768 stack.push(("SsnOffset", last_off));
769 break;
770 }
771 }
772 SubflowAttribute::MapDatalen(val) => {
773 if last_off == offset {
774 stack.push(("MapDatalen", last_off));
775 break;
776 }
777 }
778 SubflowAttribute::Flags(val) => {
779 if last_off == offset {
780 stack.push(("Flags", last_off));
781 break;
782 }
783 }
784 SubflowAttribute::IdRem(val) => {
785 if last_off == offset {
786 stack.push(("IdRem", last_off));
787 break;
788 }
789 }
790 SubflowAttribute::IdLoc(val) => {
791 if last_off == offset {
792 stack.push(("IdLoc", last_off));
793 break;
794 }
795 }
796 SubflowAttribute::Pad(val) => {
797 if last_off == offset {
798 stack.push(("Pad", last_off));
799 break;
800 }
801 }
802 _ => {}
803 };
804 last_off = cur + attrs.pos;
805 }
806 if !stack.is_empty() {
807 stack.push(("SubflowAttribute", cur));
808 }
809 (stack, None)
810 }
811}
812#[derive(Clone)]
813pub enum Endpoint<'a> {
814 Addr(IterableAddress<'a>),
815}
816impl<'a> IterableEndpoint<'a> {
817 pub fn get_addr(&self) -> Result<IterableAddress<'a>, ErrorContext> {
818 let mut iter = self.clone();
819 iter.pos = 0;
820 for attr in iter {
821 if let Endpoint::Addr(val) = attr? {
822 return Ok(val);
823 }
824 }
825 Err(ErrorContext::new_missing(
826 "Endpoint",
827 "Addr",
828 self.orig_loc,
829 self.buf.as_ptr() as usize,
830 ))
831 }
832}
833impl Endpoint<'_> {
834 pub fn new<'a>(buf: &'a [u8]) -> IterableEndpoint<'a> {
835 IterableEndpoint::with_loc(buf, buf.as_ptr() as usize)
836 }
837 fn attr_from_type(r#type: u16) -> Option<&'static str> {
838 let res = match r#type {
839 1u16 => "Addr",
840 _ => return None,
841 };
842 Some(res)
843 }
844}
845#[derive(Clone, Copy, Default)]
846pub struct IterableEndpoint<'a> {
847 buf: &'a [u8],
848 pos: usize,
849 orig_loc: usize,
850}
851impl<'a> IterableEndpoint<'a> {
852 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
853 Self {
854 buf,
855 pos: 0,
856 orig_loc,
857 }
858 }
859 pub fn get_buf(&self) -> &'a [u8] {
860 self.buf
861 }
862}
863impl<'a> Iterator for IterableEndpoint<'a> {
864 type Item = Result<Endpoint<'a>, ErrorContext>;
865 fn next(&mut self) -> Option<Self::Item> {
866 let pos = self.pos;
867 let mut r#type;
868 loop {
869 r#type = None;
870 if self.buf.len() == self.pos {
871 return None;
872 }
873 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
874 break;
875 };
876 r#type = Some(header.r#type);
877 let res = match header.r#type {
878 1u16 => Endpoint::Addr({
879 let res = Some(IterableAddress::with_loc(next, self.orig_loc));
880 let Some(val) = res else { break };
881 val
882 }),
883 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
884 n => continue,
885 };
886 return Some(Ok(res));
887 }
888 Some(Err(ErrorContext::new(
889 "Endpoint",
890 r#type.and_then(|t| Endpoint::attr_from_type(t)),
891 self.orig_loc,
892 self.buf.as_ptr().wrapping_add(pos) as usize,
893 )))
894 }
895}
896impl<'a> std::fmt::Debug for IterableEndpoint<'_> {
897 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
898 let mut fmt = f.debug_struct("Endpoint");
899 for attr in self.clone() {
900 let attr = match attr {
901 Ok(a) => a,
902 Err(err) => {
903 fmt.finish()?;
904 f.write_str("Err(")?;
905 err.fmt(f)?;
906 return f.write_str(")");
907 }
908 };
909 match attr {
910 Endpoint::Addr(val) => fmt.field("Addr", &val),
911 };
912 }
913 fmt.finish()
914 }
915}
916impl IterableEndpoint<'_> {
917 pub fn lookup_attr(
918 &self,
919 offset: usize,
920 missing_type: Option<u16>,
921 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
922 let mut stack = Vec::new();
923 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
924 if missing_type.is_some() && cur == offset {
925 stack.push(("Endpoint", offset));
926 return (
927 stack,
928 missing_type.and_then(|t| Endpoint::attr_from_type(t)),
929 );
930 }
931 if cur > offset || cur + self.buf.len() < offset {
932 return (stack, None);
933 }
934 let mut attrs = self.clone();
935 let mut last_off = cur + attrs.pos;
936 let mut missing = None;
937 while let Some(attr) = attrs.next() {
938 let Ok(attr) = attr else { break };
939 match attr {
940 Endpoint::Addr(val) => {
941 (stack, missing) = val.lookup_attr(offset, missing_type);
942 if !stack.is_empty() {
943 break;
944 }
945 }
946 _ => {}
947 };
948 last_off = cur + attrs.pos;
949 }
950 if !stack.is_empty() {
951 stack.push(("Endpoint", cur));
952 }
953 (stack, missing)
954 }
955}
956#[derive(Clone)]
957pub enum Attr<'a> {
958 Addr(IterableAddress<'a>),
959 RcvAddAddrs(u32),
960 Subflows(u32),
961 Token(u32),
962 LocId(u8),
963 AddrRemote(IterableAddress<'a>),
964}
965impl<'a> IterableAttr<'a> {
966 pub fn get_addr(&self) -> Result<IterableAddress<'a>, ErrorContext> {
967 let mut iter = self.clone();
968 iter.pos = 0;
969 for attr in iter {
970 if let Attr::Addr(val) = attr? {
971 return Ok(val);
972 }
973 }
974 Err(ErrorContext::new_missing(
975 "Attr",
976 "Addr",
977 self.orig_loc,
978 self.buf.as_ptr() as usize,
979 ))
980 }
981 pub fn get_rcv_add_addrs(&self) -> Result<u32, ErrorContext> {
982 let mut iter = self.clone();
983 iter.pos = 0;
984 for attr in iter {
985 if let Attr::RcvAddAddrs(val) = attr? {
986 return Ok(val);
987 }
988 }
989 Err(ErrorContext::new_missing(
990 "Attr",
991 "RcvAddAddrs",
992 self.orig_loc,
993 self.buf.as_ptr() as usize,
994 ))
995 }
996 pub fn get_subflows(&self) -> Result<u32, ErrorContext> {
997 let mut iter = self.clone();
998 iter.pos = 0;
999 for attr in iter {
1000 if let Attr::Subflows(val) = attr? {
1001 return Ok(val);
1002 }
1003 }
1004 Err(ErrorContext::new_missing(
1005 "Attr",
1006 "Subflows",
1007 self.orig_loc,
1008 self.buf.as_ptr() as usize,
1009 ))
1010 }
1011 pub fn get_token(&self) -> Result<u32, ErrorContext> {
1012 let mut iter = self.clone();
1013 iter.pos = 0;
1014 for attr in iter {
1015 if let Attr::Token(val) = attr? {
1016 return Ok(val);
1017 }
1018 }
1019 Err(ErrorContext::new_missing(
1020 "Attr",
1021 "Token",
1022 self.orig_loc,
1023 self.buf.as_ptr() as usize,
1024 ))
1025 }
1026 pub fn get_loc_id(&self) -> Result<u8, ErrorContext> {
1027 let mut iter = self.clone();
1028 iter.pos = 0;
1029 for attr in iter {
1030 if let Attr::LocId(val) = attr? {
1031 return Ok(val);
1032 }
1033 }
1034 Err(ErrorContext::new_missing(
1035 "Attr",
1036 "LocId",
1037 self.orig_loc,
1038 self.buf.as_ptr() as usize,
1039 ))
1040 }
1041 pub fn get_addr_remote(&self) -> Result<IterableAddress<'a>, ErrorContext> {
1042 let mut iter = self.clone();
1043 iter.pos = 0;
1044 for attr in iter {
1045 if let Attr::AddrRemote(val) = attr? {
1046 return Ok(val);
1047 }
1048 }
1049 Err(ErrorContext::new_missing(
1050 "Attr",
1051 "AddrRemote",
1052 self.orig_loc,
1053 self.buf.as_ptr() as usize,
1054 ))
1055 }
1056}
1057impl Attr<'_> {
1058 pub fn new<'a>(buf: &'a [u8]) -> IterableAttr<'a> {
1059 IterableAttr::with_loc(buf, buf.as_ptr() as usize)
1060 }
1061 fn attr_from_type(r#type: u16) -> Option<&'static str> {
1062 let res = match r#type {
1063 0u16 => "Unspec",
1064 1u16 => "Addr",
1065 2u16 => "RcvAddAddrs",
1066 3u16 => "Subflows",
1067 4u16 => "Token",
1068 5u16 => "LocId",
1069 6u16 => "AddrRemote",
1070 _ => return None,
1071 };
1072 Some(res)
1073 }
1074}
1075#[derive(Clone, Copy, Default)]
1076pub struct IterableAttr<'a> {
1077 buf: &'a [u8],
1078 pos: usize,
1079 orig_loc: usize,
1080}
1081impl<'a> IterableAttr<'a> {
1082 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
1083 Self {
1084 buf,
1085 pos: 0,
1086 orig_loc,
1087 }
1088 }
1089 pub fn get_buf(&self) -> &'a [u8] {
1090 self.buf
1091 }
1092}
1093impl<'a> Iterator for IterableAttr<'a> {
1094 type Item = Result<Attr<'a>, ErrorContext>;
1095 fn next(&mut self) -> Option<Self::Item> {
1096 let pos = self.pos;
1097 let mut r#type;
1098 loop {
1099 r#type = None;
1100 if self.buf.len() == self.pos {
1101 return None;
1102 }
1103 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
1104 break;
1105 };
1106 r#type = Some(header.r#type);
1107 let res = match header.r#type {
1108 1u16 => Attr::Addr({
1109 let res = Some(IterableAddress::with_loc(next, self.orig_loc));
1110 let Some(val) = res else { break };
1111 val
1112 }),
1113 2u16 => Attr::RcvAddAddrs({
1114 let res = parse_u32(next);
1115 let Some(val) = res else { break };
1116 val
1117 }),
1118 3u16 => Attr::Subflows({
1119 let res = parse_u32(next);
1120 let Some(val) = res else { break };
1121 val
1122 }),
1123 4u16 => Attr::Token({
1124 let res = parse_u32(next);
1125 let Some(val) = res else { break };
1126 val
1127 }),
1128 5u16 => Attr::LocId({
1129 let res = parse_u8(next);
1130 let Some(val) = res else { break };
1131 val
1132 }),
1133 6u16 => Attr::AddrRemote({
1134 let res = Some(IterableAddress::with_loc(next, self.orig_loc));
1135 let Some(val) = res else { break };
1136 val
1137 }),
1138 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
1139 n => continue,
1140 };
1141 return Some(Ok(res));
1142 }
1143 Some(Err(ErrorContext::new(
1144 "Attr",
1145 r#type.and_then(|t| Attr::attr_from_type(t)),
1146 self.orig_loc,
1147 self.buf.as_ptr().wrapping_add(pos) as usize,
1148 )))
1149 }
1150}
1151impl<'a> std::fmt::Debug for IterableAttr<'_> {
1152 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1153 let mut fmt = f.debug_struct("Attr");
1154 for attr in self.clone() {
1155 let attr = match attr {
1156 Ok(a) => a,
1157 Err(err) => {
1158 fmt.finish()?;
1159 f.write_str("Err(")?;
1160 err.fmt(f)?;
1161 return f.write_str(")");
1162 }
1163 };
1164 match attr {
1165 Attr::Addr(val) => fmt.field("Addr", &val),
1166 Attr::RcvAddAddrs(val) => fmt.field("RcvAddAddrs", &val),
1167 Attr::Subflows(val) => fmt.field("Subflows", &val),
1168 Attr::Token(val) => fmt.field("Token", &val),
1169 Attr::LocId(val) => fmt.field("LocId", &val),
1170 Attr::AddrRemote(val) => fmt.field("AddrRemote", &val),
1171 };
1172 }
1173 fmt.finish()
1174 }
1175}
1176impl IterableAttr<'_> {
1177 pub fn lookup_attr(
1178 &self,
1179 offset: usize,
1180 missing_type: Option<u16>,
1181 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
1182 let mut stack = Vec::new();
1183 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
1184 if missing_type.is_some() && cur == offset {
1185 stack.push(("Attr", offset));
1186 return (stack, missing_type.and_then(|t| Attr::attr_from_type(t)));
1187 }
1188 if cur > offset || cur + self.buf.len() < offset {
1189 return (stack, None);
1190 }
1191 let mut attrs = self.clone();
1192 let mut last_off = cur + attrs.pos;
1193 let mut missing = None;
1194 while let Some(attr) = attrs.next() {
1195 let Ok(attr) = attr else { break };
1196 match attr {
1197 Attr::Addr(val) => {
1198 (stack, missing) = val.lookup_attr(offset, missing_type);
1199 if !stack.is_empty() {
1200 break;
1201 }
1202 }
1203 Attr::RcvAddAddrs(val) => {
1204 if last_off == offset {
1205 stack.push(("RcvAddAddrs", last_off));
1206 break;
1207 }
1208 }
1209 Attr::Subflows(val) => {
1210 if last_off == offset {
1211 stack.push(("Subflows", last_off));
1212 break;
1213 }
1214 }
1215 Attr::Token(val) => {
1216 if last_off == offset {
1217 stack.push(("Token", last_off));
1218 break;
1219 }
1220 }
1221 Attr::LocId(val) => {
1222 if last_off == offset {
1223 stack.push(("LocId", last_off));
1224 break;
1225 }
1226 }
1227 Attr::AddrRemote(val) => {
1228 (stack, missing) = val.lookup_attr(offset, missing_type);
1229 if !stack.is_empty() {
1230 break;
1231 }
1232 }
1233 _ => {}
1234 };
1235 last_off = cur + attrs.pos;
1236 }
1237 if !stack.is_empty() {
1238 stack.push(("Attr", cur));
1239 }
1240 (stack, missing)
1241 }
1242}
1243#[derive(Clone)]
1244pub enum EventAttr<'a> {
1245 Token(u32),
1246 Family(u16),
1247 LocId(u8),
1248 RemId(u8),
1249 Saddr4(u32),
1250 Saddr6(&'a [u8]),
1251 Daddr4(u32),
1252 Daddr6(&'a [u8]),
1253 Sport(u16),
1254 Dport(u16),
1255 Backup(u8),
1256 Error(u8),
1257 Flags(u16),
1258 Timeout(u32),
1259 IfIdx(i32),
1260 ResetReason(u32),
1261 ResetFlags(u32),
1262 #[doc = "Deprecated: use 'flags'"]
1263 ServerSide(u8),
1264}
1265impl<'a> IterableEventAttr<'a> {
1266 pub fn get_token(&self) -> Result<u32, ErrorContext> {
1267 let mut iter = self.clone();
1268 iter.pos = 0;
1269 for attr in iter {
1270 if let EventAttr::Token(val) = attr? {
1271 return Ok(val);
1272 }
1273 }
1274 Err(ErrorContext::new_missing(
1275 "EventAttr",
1276 "Token",
1277 self.orig_loc,
1278 self.buf.as_ptr() as usize,
1279 ))
1280 }
1281 pub fn get_family(&self) -> Result<u16, ErrorContext> {
1282 let mut iter = self.clone();
1283 iter.pos = 0;
1284 for attr in iter {
1285 if let EventAttr::Family(val) = attr? {
1286 return Ok(val);
1287 }
1288 }
1289 Err(ErrorContext::new_missing(
1290 "EventAttr",
1291 "Family",
1292 self.orig_loc,
1293 self.buf.as_ptr() as usize,
1294 ))
1295 }
1296 pub fn get_loc_id(&self) -> Result<u8, ErrorContext> {
1297 let mut iter = self.clone();
1298 iter.pos = 0;
1299 for attr in iter {
1300 if let EventAttr::LocId(val) = attr? {
1301 return Ok(val);
1302 }
1303 }
1304 Err(ErrorContext::new_missing(
1305 "EventAttr",
1306 "LocId",
1307 self.orig_loc,
1308 self.buf.as_ptr() as usize,
1309 ))
1310 }
1311 pub fn get_rem_id(&self) -> Result<u8, ErrorContext> {
1312 let mut iter = self.clone();
1313 iter.pos = 0;
1314 for attr in iter {
1315 if let EventAttr::RemId(val) = attr? {
1316 return Ok(val);
1317 }
1318 }
1319 Err(ErrorContext::new_missing(
1320 "EventAttr",
1321 "RemId",
1322 self.orig_loc,
1323 self.buf.as_ptr() as usize,
1324 ))
1325 }
1326 pub fn get_saddr4(&self) -> Result<u32, ErrorContext> {
1327 let mut iter = self.clone();
1328 iter.pos = 0;
1329 for attr in iter {
1330 if let EventAttr::Saddr4(val) = attr? {
1331 return Ok(val);
1332 }
1333 }
1334 Err(ErrorContext::new_missing(
1335 "EventAttr",
1336 "Saddr4",
1337 self.orig_loc,
1338 self.buf.as_ptr() as usize,
1339 ))
1340 }
1341 pub fn get_saddr6(&self) -> Result<&'a [u8], ErrorContext> {
1342 let mut iter = self.clone();
1343 iter.pos = 0;
1344 for attr in iter {
1345 if let EventAttr::Saddr6(val) = attr? {
1346 return Ok(val);
1347 }
1348 }
1349 Err(ErrorContext::new_missing(
1350 "EventAttr",
1351 "Saddr6",
1352 self.orig_loc,
1353 self.buf.as_ptr() as usize,
1354 ))
1355 }
1356 pub fn get_daddr4(&self) -> Result<u32, ErrorContext> {
1357 let mut iter = self.clone();
1358 iter.pos = 0;
1359 for attr in iter {
1360 if let EventAttr::Daddr4(val) = attr? {
1361 return Ok(val);
1362 }
1363 }
1364 Err(ErrorContext::new_missing(
1365 "EventAttr",
1366 "Daddr4",
1367 self.orig_loc,
1368 self.buf.as_ptr() as usize,
1369 ))
1370 }
1371 pub fn get_daddr6(&self) -> Result<&'a [u8], ErrorContext> {
1372 let mut iter = self.clone();
1373 iter.pos = 0;
1374 for attr in iter {
1375 if let EventAttr::Daddr6(val) = attr? {
1376 return Ok(val);
1377 }
1378 }
1379 Err(ErrorContext::new_missing(
1380 "EventAttr",
1381 "Daddr6",
1382 self.orig_loc,
1383 self.buf.as_ptr() as usize,
1384 ))
1385 }
1386 pub fn get_sport(&self) -> Result<u16, ErrorContext> {
1387 let mut iter = self.clone();
1388 iter.pos = 0;
1389 for attr in iter {
1390 if let EventAttr::Sport(val) = attr? {
1391 return Ok(val);
1392 }
1393 }
1394 Err(ErrorContext::new_missing(
1395 "EventAttr",
1396 "Sport",
1397 self.orig_loc,
1398 self.buf.as_ptr() as usize,
1399 ))
1400 }
1401 pub fn get_dport(&self) -> Result<u16, ErrorContext> {
1402 let mut iter = self.clone();
1403 iter.pos = 0;
1404 for attr in iter {
1405 if let EventAttr::Dport(val) = attr? {
1406 return Ok(val);
1407 }
1408 }
1409 Err(ErrorContext::new_missing(
1410 "EventAttr",
1411 "Dport",
1412 self.orig_loc,
1413 self.buf.as_ptr() as usize,
1414 ))
1415 }
1416 pub fn get_backup(&self) -> Result<u8, ErrorContext> {
1417 let mut iter = self.clone();
1418 iter.pos = 0;
1419 for attr in iter {
1420 if let EventAttr::Backup(val) = attr? {
1421 return Ok(val);
1422 }
1423 }
1424 Err(ErrorContext::new_missing(
1425 "EventAttr",
1426 "Backup",
1427 self.orig_loc,
1428 self.buf.as_ptr() as usize,
1429 ))
1430 }
1431 pub fn get_error(&self) -> Result<u8, ErrorContext> {
1432 let mut iter = self.clone();
1433 iter.pos = 0;
1434 for attr in iter {
1435 if let EventAttr::Error(val) = attr? {
1436 return Ok(val);
1437 }
1438 }
1439 Err(ErrorContext::new_missing(
1440 "EventAttr",
1441 "Error",
1442 self.orig_loc,
1443 self.buf.as_ptr() as usize,
1444 ))
1445 }
1446 pub fn get_flags(&self) -> Result<u16, ErrorContext> {
1447 let mut iter = self.clone();
1448 iter.pos = 0;
1449 for attr in iter {
1450 if let EventAttr::Flags(val) = attr? {
1451 return Ok(val);
1452 }
1453 }
1454 Err(ErrorContext::new_missing(
1455 "EventAttr",
1456 "Flags",
1457 self.orig_loc,
1458 self.buf.as_ptr() as usize,
1459 ))
1460 }
1461 pub fn get_timeout(&self) -> Result<u32, ErrorContext> {
1462 let mut iter = self.clone();
1463 iter.pos = 0;
1464 for attr in iter {
1465 if let EventAttr::Timeout(val) = attr? {
1466 return Ok(val);
1467 }
1468 }
1469 Err(ErrorContext::new_missing(
1470 "EventAttr",
1471 "Timeout",
1472 self.orig_loc,
1473 self.buf.as_ptr() as usize,
1474 ))
1475 }
1476 pub fn get_if_idx(&self) -> Result<i32, ErrorContext> {
1477 let mut iter = self.clone();
1478 iter.pos = 0;
1479 for attr in iter {
1480 if let EventAttr::IfIdx(val) = attr? {
1481 return Ok(val);
1482 }
1483 }
1484 Err(ErrorContext::new_missing(
1485 "EventAttr",
1486 "IfIdx",
1487 self.orig_loc,
1488 self.buf.as_ptr() as usize,
1489 ))
1490 }
1491 pub fn get_reset_reason(&self) -> Result<u32, ErrorContext> {
1492 let mut iter = self.clone();
1493 iter.pos = 0;
1494 for attr in iter {
1495 if let EventAttr::ResetReason(val) = attr? {
1496 return Ok(val);
1497 }
1498 }
1499 Err(ErrorContext::new_missing(
1500 "EventAttr",
1501 "ResetReason",
1502 self.orig_loc,
1503 self.buf.as_ptr() as usize,
1504 ))
1505 }
1506 pub fn get_reset_flags(&self) -> Result<u32, ErrorContext> {
1507 let mut iter = self.clone();
1508 iter.pos = 0;
1509 for attr in iter {
1510 if let EventAttr::ResetFlags(val) = attr? {
1511 return Ok(val);
1512 }
1513 }
1514 Err(ErrorContext::new_missing(
1515 "EventAttr",
1516 "ResetFlags",
1517 self.orig_loc,
1518 self.buf.as_ptr() as usize,
1519 ))
1520 }
1521 #[doc = "Deprecated: use 'flags'"]
1522 pub fn get_server_side(&self) -> Result<u8, ErrorContext> {
1523 let mut iter = self.clone();
1524 iter.pos = 0;
1525 for attr in iter {
1526 if let EventAttr::ServerSide(val) = attr? {
1527 return Ok(val);
1528 }
1529 }
1530 Err(ErrorContext::new_missing(
1531 "EventAttr",
1532 "ServerSide",
1533 self.orig_loc,
1534 self.buf.as_ptr() as usize,
1535 ))
1536 }
1537}
1538impl EventAttr<'_> {
1539 pub fn new<'a>(buf: &'a [u8]) -> IterableEventAttr<'a> {
1540 IterableEventAttr::with_loc(buf, buf.as_ptr() as usize)
1541 }
1542 fn attr_from_type(r#type: u16) -> Option<&'static str> {
1543 let res = match r#type {
1544 0u16 => "Unspec",
1545 1u16 => "Token",
1546 2u16 => "Family",
1547 3u16 => "LocId",
1548 4u16 => "RemId",
1549 5u16 => "Saddr4",
1550 6u16 => "Saddr6",
1551 7u16 => "Daddr4",
1552 8u16 => "Daddr6",
1553 9u16 => "Sport",
1554 10u16 => "Dport",
1555 11u16 => "Backup",
1556 12u16 => "Error",
1557 13u16 => "Flags",
1558 14u16 => "Timeout",
1559 15u16 => "IfIdx",
1560 16u16 => "ResetReason",
1561 17u16 => "ResetFlags",
1562 18u16 => "ServerSide",
1563 _ => return None,
1564 };
1565 Some(res)
1566 }
1567}
1568#[derive(Clone, Copy, Default)]
1569pub struct IterableEventAttr<'a> {
1570 buf: &'a [u8],
1571 pos: usize,
1572 orig_loc: usize,
1573}
1574impl<'a> IterableEventAttr<'a> {
1575 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
1576 Self {
1577 buf,
1578 pos: 0,
1579 orig_loc,
1580 }
1581 }
1582 pub fn get_buf(&self) -> &'a [u8] {
1583 self.buf
1584 }
1585}
1586impl<'a> Iterator for IterableEventAttr<'a> {
1587 type Item = Result<EventAttr<'a>, ErrorContext>;
1588 fn next(&mut self) -> Option<Self::Item> {
1589 let pos = self.pos;
1590 let mut r#type;
1591 loop {
1592 r#type = None;
1593 if self.buf.len() == self.pos {
1594 return None;
1595 }
1596 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
1597 break;
1598 };
1599 r#type = Some(header.r#type);
1600 let res = match header.r#type {
1601 1u16 => EventAttr::Token({
1602 let res = parse_u32(next);
1603 let Some(val) = res else { break };
1604 val
1605 }),
1606 2u16 => EventAttr::Family({
1607 let res = parse_u16(next);
1608 let Some(val) = res else { break };
1609 val
1610 }),
1611 3u16 => EventAttr::LocId({
1612 let res = parse_u8(next);
1613 let Some(val) = res else { break };
1614 val
1615 }),
1616 4u16 => EventAttr::RemId({
1617 let res = parse_u8(next);
1618 let Some(val) = res else { break };
1619 val
1620 }),
1621 5u16 => EventAttr::Saddr4({
1622 let res = parse_be_u32(next);
1623 let Some(val) = res else { break };
1624 val
1625 }),
1626 6u16 => EventAttr::Saddr6({
1627 let res = Some(next);
1628 let Some(val) = res else { break };
1629 val
1630 }),
1631 7u16 => EventAttr::Daddr4({
1632 let res = parse_be_u32(next);
1633 let Some(val) = res else { break };
1634 val
1635 }),
1636 8u16 => EventAttr::Daddr6({
1637 let res = Some(next);
1638 let Some(val) = res else { break };
1639 val
1640 }),
1641 9u16 => EventAttr::Sport({
1642 let res = parse_be_u16(next);
1643 let Some(val) = res else { break };
1644 val
1645 }),
1646 10u16 => EventAttr::Dport({
1647 let res = parse_be_u16(next);
1648 let Some(val) = res else { break };
1649 val
1650 }),
1651 11u16 => EventAttr::Backup({
1652 let res = parse_u8(next);
1653 let Some(val) = res else { break };
1654 val
1655 }),
1656 12u16 => EventAttr::Error({
1657 let res = parse_u8(next);
1658 let Some(val) = res else { break };
1659 val
1660 }),
1661 13u16 => EventAttr::Flags({
1662 let res = parse_u16(next);
1663 let Some(val) = res else { break };
1664 val
1665 }),
1666 14u16 => EventAttr::Timeout({
1667 let res = parse_u32(next);
1668 let Some(val) = res else { break };
1669 val
1670 }),
1671 15u16 => EventAttr::IfIdx({
1672 let res = parse_i32(next);
1673 let Some(val) = res else { break };
1674 val
1675 }),
1676 16u16 => EventAttr::ResetReason({
1677 let res = parse_u32(next);
1678 let Some(val) = res else { break };
1679 val
1680 }),
1681 17u16 => EventAttr::ResetFlags({
1682 let res = parse_u32(next);
1683 let Some(val) = res else { break };
1684 val
1685 }),
1686 18u16 => EventAttr::ServerSide({
1687 let res = parse_u8(next);
1688 let Some(val) = res else { break };
1689 val
1690 }),
1691 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
1692 n => continue,
1693 };
1694 return Some(Ok(res));
1695 }
1696 Some(Err(ErrorContext::new(
1697 "EventAttr",
1698 r#type.and_then(|t| EventAttr::attr_from_type(t)),
1699 self.orig_loc,
1700 self.buf.as_ptr().wrapping_add(pos) as usize,
1701 )))
1702 }
1703}
1704impl<'a> std::fmt::Debug for IterableEventAttr<'_> {
1705 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1706 let mut fmt = f.debug_struct("EventAttr");
1707 for attr in self.clone() {
1708 let attr = match attr {
1709 Ok(a) => a,
1710 Err(err) => {
1711 fmt.finish()?;
1712 f.write_str("Err(")?;
1713 err.fmt(f)?;
1714 return f.write_str(")");
1715 }
1716 };
1717 match attr {
1718 EventAttr::Token(val) => fmt.field("Token", &val),
1719 EventAttr::Family(val) => fmt.field("Family", &val),
1720 EventAttr::LocId(val) => fmt.field("LocId", &val),
1721 EventAttr::RemId(val) => fmt.field("RemId", &val),
1722 EventAttr::Saddr4(val) => fmt.field("Saddr4", &val),
1723 EventAttr::Saddr6(val) => fmt.field("Saddr6", &val),
1724 EventAttr::Daddr4(val) => fmt.field("Daddr4", &val),
1725 EventAttr::Daddr6(val) => fmt.field("Daddr6", &val),
1726 EventAttr::Sport(val) => fmt.field("Sport", &val),
1727 EventAttr::Dport(val) => fmt.field("Dport", &val),
1728 EventAttr::Backup(val) => fmt.field("Backup", &val),
1729 EventAttr::Error(val) => fmt.field("Error", &val),
1730 EventAttr::Flags(val) => fmt.field("Flags", &val),
1731 EventAttr::Timeout(val) => fmt.field("Timeout", &val),
1732 EventAttr::IfIdx(val) => fmt.field("IfIdx", &val),
1733 EventAttr::ResetReason(val) => fmt.field("ResetReason", &val),
1734 EventAttr::ResetFlags(val) => fmt.field("ResetFlags", &val),
1735 EventAttr::ServerSide(val) => fmt.field("ServerSide", &val),
1736 };
1737 }
1738 fmt.finish()
1739 }
1740}
1741impl IterableEventAttr<'_> {
1742 pub fn lookup_attr(
1743 &self,
1744 offset: usize,
1745 missing_type: Option<u16>,
1746 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
1747 let mut stack = Vec::new();
1748 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
1749 if missing_type.is_some() && cur == offset {
1750 stack.push(("EventAttr", offset));
1751 return (
1752 stack,
1753 missing_type.and_then(|t| EventAttr::attr_from_type(t)),
1754 );
1755 }
1756 if cur > offset || cur + self.buf.len() < offset {
1757 return (stack, None);
1758 }
1759 let mut attrs = self.clone();
1760 let mut last_off = cur + attrs.pos;
1761 while let Some(attr) = attrs.next() {
1762 let Ok(attr) = attr else { break };
1763 match attr {
1764 EventAttr::Token(val) => {
1765 if last_off == offset {
1766 stack.push(("Token", last_off));
1767 break;
1768 }
1769 }
1770 EventAttr::Family(val) => {
1771 if last_off == offset {
1772 stack.push(("Family", last_off));
1773 break;
1774 }
1775 }
1776 EventAttr::LocId(val) => {
1777 if last_off == offset {
1778 stack.push(("LocId", last_off));
1779 break;
1780 }
1781 }
1782 EventAttr::RemId(val) => {
1783 if last_off == offset {
1784 stack.push(("RemId", last_off));
1785 break;
1786 }
1787 }
1788 EventAttr::Saddr4(val) => {
1789 if last_off == offset {
1790 stack.push(("Saddr4", last_off));
1791 break;
1792 }
1793 }
1794 EventAttr::Saddr6(val) => {
1795 if last_off == offset {
1796 stack.push(("Saddr6", last_off));
1797 break;
1798 }
1799 }
1800 EventAttr::Daddr4(val) => {
1801 if last_off == offset {
1802 stack.push(("Daddr4", last_off));
1803 break;
1804 }
1805 }
1806 EventAttr::Daddr6(val) => {
1807 if last_off == offset {
1808 stack.push(("Daddr6", last_off));
1809 break;
1810 }
1811 }
1812 EventAttr::Sport(val) => {
1813 if last_off == offset {
1814 stack.push(("Sport", last_off));
1815 break;
1816 }
1817 }
1818 EventAttr::Dport(val) => {
1819 if last_off == offset {
1820 stack.push(("Dport", last_off));
1821 break;
1822 }
1823 }
1824 EventAttr::Backup(val) => {
1825 if last_off == offset {
1826 stack.push(("Backup", last_off));
1827 break;
1828 }
1829 }
1830 EventAttr::Error(val) => {
1831 if last_off == offset {
1832 stack.push(("Error", last_off));
1833 break;
1834 }
1835 }
1836 EventAttr::Flags(val) => {
1837 if last_off == offset {
1838 stack.push(("Flags", last_off));
1839 break;
1840 }
1841 }
1842 EventAttr::Timeout(val) => {
1843 if last_off == offset {
1844 stack.push(("Timeout", last_off));
1845 break;
1846 }
1847 }
1848 EventAttr::IfIdx(val) => {
1849 if last_off == offset {
1850 stack.push(("IfIdx", last_off));
1851 break;
1852 }
1853 }
1854 EventAttr::ResetReason(val) => {
1855 if last_off == offset {
1856 stack.push(("ResetReason", last_off));
1857 break;
1858 }
1859 }
1860 EventAttr::ResetFlags(val) => {
1861 if last_off == offset {
1862 stack.push(("ResetFlags", last_off));
1863 break;
1864 }
1865 }
1866 EventAttr::ServerSide(val) => {
1867 if last_off == offset {
1868 stack.push(("ServerSide", last_off));
1869 break;
1870 }
1871 }
1872 _ => {}
1873 };
1874 last_off = cur + attrs.pos;
1875 }
1876 if !stack.is_empty() {
1877 stack.push(("EventAttr", cur));
1878 }
1879 (stack, None)
1880 }
1881}
1882pub struct PushAddress<Prev: Rec> {
1883 pub(crate) prev: Option<Prev>,
1884 pub(crate) header_offset: Option<usize>,
1885}
1886impl<Prev: Rec> Rec for PushAddress<Prev> {
1887 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
1888 self.prev.as_mut().unwrap().as_rec_mut()
1889 }
1890 fn as_rec(&self) -> &Vec<u8> {
1891 self.prev.as_ref().unwrap().as_rec()
1892 }
1893}
1894impl<Prev: Rec> PushAddress<Prev> {
1895 pub fn new(prev: Prev) -> Self {
1896 Self {
1897 prev: Some(prev),
1898 header_offset: None,
1899 }
1900 }
1901 pub fn end_nested(mut self) -> Prev {
1902 let mut prev = self.prev.take().unwrap();
1903 if let Some(header_offset) = &self.header_offset {
1904 finalize_nested_header(prev.as_rec_mut(), *header_offset);
1905 }
1906 prev
1907 }
1908 pub fn push_family(mut self, value: u16) -> Self {
1909 push_header(self.as_rec_mut(), 1u16, 2 as u16);
1910 self.as_rec_mut().extend(value.to_ne_bytes());
1911 self
1912 }
1913 pub fn push_id(mut self, value: u8) -> Self {
1914 push_header(self.as_rec_mut(), 2u16, 1 as u16);
1915 self.as_rec_mut().extend(value.to_ne_bytes());
1916 self
1917 }
1918 pub fn push_addr4(mut self, value: u32) -> Self {
1919 push_header(self.as_rec_mut(), 3u16, 4 as u16);
1920 self.as_rec_mut().extend(value.to_be_bytes());
1921 self
1922 }
1923 pub fn push_addr6(mut self, value: &[u8]) -> Self {
1924 push_header(self.as_rec_mut(), 4u16, value.len() as u16);
1925 self.as_rec_mut().extend(value);
1926 self
1927 }
1928 pub fn push_port(mut self, value: u16) -> Self {
1929 push_header(self.as_rec_mut(), 5u16, 2 as u16);
1930 self.as_rec_mut().extend(value.to_ne_bytes());
1931 self
1932 }
1933 pub fn push_flags(mut self, value: u32) -> Self {
1934 push_header(self.as_rec_mut(), 6u16, 4 as u16);
1935 self.as_rec_mut().extend(value.to_ne_bytes());
1936 self
1937 }
1938 pub fn push_if_idx(mut self, value: i32) -> Self {
1939 push_header(self.as_rec_mut(), 7u16, 4 as u16);
1940 self.as_rec_mut().extend(value.to_ne_bytes());
1941 self
1942 }
1943}
1944impl<Prev: Rec> Drop for PushAddress<Prev> {
1945 fn drop(&mut self) {
1946 if let Some(prev) = &mut self.prev {
1947 if let Some(header_offset) = &self.header_offset {
1948 finalize_nested_header(prev.as_rec_mut(), *header_offset);
1949 }
1950 }
1951 }
1952}
1953pub struct PushSubflowAttribute<Prev: Rec> {
1954 pub(crate) prev: Option<Prev>,
1955 pub(crate) header_offset: Option<usize>,
1956}
1957impl<Prev: Rec> Rec for PushSubflowAttribute<Prev> {
1958 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
1959 self.prev.as_mut().unwrap().as_rec_mut()
1960 }
1961 fn as_rec(&self) -> &Vec<u8> {
1962 self.prev.as_ref().unwrap().as_rec()
1963 }
1964}
1965impl<Prev: Rec> PushSubflowAttribute<Prev> {
1966 pub fn new(prev: Prev) -> Self {
1967 Self {
1968 prev: Some(prev),
1969 header_offset: None,
1970 }
1971 }
1972 pub fn end_nested(mut self) -> Prev {
1973 let mut prev = self.prev.take().unwrap();
1974 if let Some(header_offset) = &self.header_offset {
1975 finalize_nested_header(prev.as_rec_mut(), *header_offset);
1976 }
1977 prev
1978 }
1979 pub fn push_token_rem(mut self, value: u32) -> Self {
1980 push_header(self.as_rec_mut(), 1u16, 4 as u16);
1981 self.as_rec_mut().extend(value.to_ne_bytes());
1982 self
1983 }
1984 pub fn push_token_loc(mut self, value: u32) -> Self {
1985 push_header(self.as_rec_mut(), 2u16, 4 as u16);
1986 self.as_rec_mut().extend(value.to_ne_bytes());
1987 self
1988 }
1989 pub fn push_relwrite_seq(mut self, value: u32) -> Self {
1990 push_header(self.as_rec_mut(), 3u16, 4 as u16);
1991 self.as_rec_mut().extend(value.to_ne_bytes());
1992 self
1993 }
1994 pub fn push_map_seq(mut self, value: u64) -> Self {
1995 push_header(self.as_rec_mut(), 4u16, 8 as u16);
1996 self.as_rec_mut().extend(value.to_ne_bytes());
1997 self
1998 }
1999 pub fn push_map_sfseq(mut self, value: u32) -> Self {
2000 push_header(self.as_rec_mut(), 5u16, 4 as u16);
2001 self.as_rec_mut().extend(value.to_ne_bytes());
2002 self
2003 }
2004 pub fn push_ssn_offset(mut self, value: u32) -> Self {
2005 push_header(self.as_rec_mut(), 6u16, 4 as u16);
2006 self.as_rec_mut().extend(value.to_ne_bytes());
2007 self
2008 }
2009 pub fn push_map_datalen(mut self, value: u16) -> Self {
2010 push_header(self.as_rec_mut(), 7u16, 2 as u16);
2011 self.as_rec_mut().extend(value.to_ne_bytes());
2012 self
2013 }
2014 pub fn push_flags(mut self, value: u32) -> Self {
2015 push_header(self.as_rec_mut(), 8u16, 4 as u16);
2016 self.as_rec_mut().extend(value.to_ne_bytes());
2017 self
2018 }
2019 pub fn push_id_rem(mut self, value: u8) -> Self {
2020 push_header(self.as_rec_mut(), 9u16, 1 as u16);
2021 self.as_rec_mut().extend(value.to_ne_bytes());
2022 self
2023 }
2024 pub fn push_id_loc(mut self, value: u8) -> Self {
2025 push_header(self.as_rec_mut(), 10u16, 1 as u16);
2026 self.as_rec_mut().extend(value.to_ne_bytes());
2027 self
2028 }
2029 pub fn push_pad(mut self, value: &[u8]) -> Self {
2030 push_header(self.as_rec_mut(), 11u16, value.len() as u16);
2031 self.as_rec_mut().extend(value);
2032 self
2033 }
2034}
2035impl<Prev: Rec> Drop for PushSubflowAttribute<Prev> {
2036 fn drop(&mut self) {
2037 if let Some(prev) = &mut self.prev {
2038 if let Some(header_offset) = &self.header_offset {
2039 finalize_nested_header(prev.as_rec_mut(), *header_offset);
2040 }
2041 }
2042 }
2043}
2044pub struct PushEndpoint<Prev: Rec> {
2045 pub(crate) prev: Option<Prev>,
2046 pub(crate) header_offset: Option<usize>,
2047}
2048impl<Prev: Rec> Rec for PushEndpoint<Prev> {
2049 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
2050 self.prev.as_mut().unwrap().as_rec_mut()
2051 }
2052 fn as_rec(&self) -> &Vec<u8> {
2053 self.prev.as_ref().unwrap().as_rec()
2054 }
2055}
2056impl<Prev: Rec> PushEndpoint<Prev> {
2057 pub fn new(prev: Prev) -> Self {
2058 Self {
2059 prev: Some(prev),
2060 header_offset: None,
2061 }
2062 }
2063 pub fn end_nested(mut self) -> Prev {
2064 let mut prev = self.prev.take().unwrap();
2065 if let Some(header_offset) = &self.header_offset {
2066 finalize_nested_header(prev.as_rec_mut(), *header_offset);
2067 }
2068 prev
2069 }
2070 pub fn nested_addr(mut self) -> PushAddress<Self> {
2071 let header_offset = push_nested_header(self.as_rec_mut(), 1u16);
2072 PushAddress {
2073 prev: Some(self),
2074 header_offset: Some(header_offset),
2075 }
2076 }
2077}
2078impl<Prev: Rec> Drop for PushEndpoint<Prev> {
2079 fn drop(&mut self) {
2080 if let Some(prev) = &mut self.prev {
2081 if let Some(header_offset) = &self.header_offset {
2082 finalize_nested_header(prev.as_rec_mut(), *header_offset);
2083 }
2084 }
2085 }
2086}
2087pub struct PushAttr<Prev: Rec> {
2088 pub(crate) prev: Option<Prev>,
2089 pub(crate) header_offset: Option<usize>,
2090}
2091impl<Prev: Rec> Rec for PushAttr<Prev> {
2092 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
2093 self.prev.as_mut().unwrap().as_rec_mut()
2094 }
2095 fn as_rec(&self) -> &Vec<u8> {
2096 self.prev.as_ref().unwrap().as_rec()
2097 }
2098}
2099impl<Prev: Rec> PushAttr<Prev> {
2100 pub fn new(prev: Prev) -> Self {
2101 Self {
2102 prev: Some(prev),
2103 header_offset: None,
2104 }
2105 }
2106 pub fn end_nested(mut self) -> Prev {
2107 let mut prev = self.prev.take().unwrap();
2108 if let Some(header_offset) = &self.header_offset {
2109 finalize_nested_header(prev.as_rec_mut(), *header_offset);
2110 }
2111 prev
2112 }
2113 pub fn nested_addr(mut self) -> PushAddress<Self> {
2114 let header_offset = push_nested_header(self.as_rec_mut(), 1u16);
2115 PushAddress {
2116 prev: Some(self),
2117 header_offset: Some(header_offset),
2118 }
2119 }
2120 pub fn push_rcv_add_addrs(mut self, value: u32) -> Self {
2121 push_header(self.as_rec_mut(), 2u16, 4 as u16);
2122 self.as_rec_mut().extend(value.to_ne_bytes());
2123 self
2124 }
2125 pub fn push_subflows(mut self, value: u32) -> Self {
2126 push_header(self.as_rec_mut(), 3u16, 4 as u16);
2127 self.as_rec_mut().extend(value.to_ne_bytes());
2128 self
2129 }
2130 pub fn push_token(mut self, value: u32) -> Self {
2131 push_header(self.as_rec_mut(), 4u16, 4 as u16);
2132 self.as_rec_mut().extend(value.to_ne_bytes());
2133 self
2134 }
2135 pub fn push_loc_id(mut self, value: u8) -> Self {
2136 push_header(self.as_rec_mut(), 5u16, 1 as u16);
2137 self.as_rec_mut().extend(value.to_ne_bytes());
2138 self
2139 }
2140 pub fn nested_addr_remote(mut self) -> PushAddress<Self> {
2141 let header_offset = push_nested_header(self.as_rec_mut(), 6u16);
2142 PushAddress {
2143 prev: Some(self),
2144 header_offset: Some(header_offset),
2145 }
2146 }
2147}
2148impl<Prev: Rec> Drop for PushAttr<Prev> {
2149 fn drop(&mut self) {
2150 if let Some(prev) = &mut self.prev {
2151 if let Some(header_offset) = &self.header_offset {
2152 finalize_nested_header(prev.as_rec_mut(), *header_offset);
2153 }
2154 }
2155 }
2156}
2157pub struct PushEventAttr<Prev: Rec> {
2158 pub(crate) prev: Option<Prev>,
2159 pub(crate) header_offset: Option<usize>,
2160}
2161impl<Prev: Rec> Rec for PushEventAttr<Prev> {
2162 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
2163 self.prev.as_mut().unwrap().as_rec_mut()
2164 }
2165 fn as_rec(&self) -> &Vec<u8> {
2166 self.prev.as_ref().unwrap().as_rec()
2167 }
2168}
2169impl<Prev: Rec> PushEventAttr<Prev> {
2170 pub fn new(prev: Prev) -> Self {
2171 Self {
2172 prev: Some(prev),
2173 header_offset: None,
2174 }
2175 }
2176 pub fn end_nested(mut self) -> Prev {
2177 let mut prev = self.prev.take().unwrap();
2178 if let Some(header_offset) = &self.header_offset {
2179 finalize_nested_header(prev.as_rec_mut(), *header_offset);
2180 }
2181 prev
2182 }
2183 pub fn push_token(mut self, value: u32) -> Self {
2184 push_header(self.as_rec_mut(), 1u16, 4 as u16);
2185 self.as_rec_mut().extend(value.to_ne_bytes());
2186 self
2187 }
2188 pub fn push_family(mut self, value: u16) -> Self {
2189 push_header(self.as_rec_mut(), 2u16, 2 as u16);
2190 self.as_rec_mut().extend(value.to_ne_bytes());
2191 self
2192 }
2193 pub fn push_loc_id(mut self, value: u8) -> Self {
2194 push_header(self.as_rec_mut(), 3u16, 1 as u16);
2195 self.as_rec_mut().extend(value.to_ne_bytes());
2196 self
2197 }
2198 pub fn push_rem_id(mut self, value: u8) -> Self {
2199 push_header(self.as_rec_mut(), 4u16, 1 as u16);
2200 self.as_rec_mut().extend(value.to_ne_bytes());
2201 self
2202 }
2203 pub fn push_saddr4(mut self, value: u32) -> Self {
2204 push_header(self.as_rec_mut(), 5u16, 4 as u16);
2205 self.as_rec_mut().extend(value.to_be_bytes());
2206 self
2207 }
2208 pub fn push_saddr6(mut self, value: &[u8]) -> Self {
2209 push_header(self.as_rec_mut(), 6u16, value.len() as u16);
2210 self.as_rec_mut().extend(value);
2211 self
2212 }
2213 pub fn push_daddr4(mut self, value: u32) -> Self {
2214 push_header(self.as_rec_mut(), 7u16, 4 as u16);
2215 self.as_rec_mut().extend(value.to_be_bytes());
2216 self
2217 }
2218 pub fn push_daddr6(mut self, value: &[u8]) -> Self {
2219 push_header(self.as_rec_mut(), 8u16, value.len() as u16);
2220 self.as_rec_mut().extend(value);
2221 self
2222 }
2223 pub fn push_sport(mut self, value: u16) -> Self {
2224 push_header(self.as_rec_mut(), 9u16, 2 as u16);
2225 self.as_rec_mut().extend(value.to_be_bytes());
2226 self
2227 }
2228 pub fn push_dport(mut self, value: u16) -> Self {
2229 push_header(self.as_rec_mut(), 10u16, 2 as u16);
2230 self.as_rec_mut().extend(value.to_be_bytes());
2231 self
2232 }
2233 pub fn push_backup(mut self, value: u8) -> Self {
2234 push_header(self.as_rec_mut(), 11u16, 1 as u16);
2235 self.as_rec_mut().extend(value.to_ne_bytes());
2236 self
2237 }
2238 pub fn push_error(mut self, value: u8) -> Self {
2239 push_header(self.as_rec_mut(), 12u16, 1 as u16);
2240 self.as_rec_mut().extend(value.to_ne_bytes());
2241 self
2242 }
2243 pub fn push_flags(mut self, value: u16) -> Self {
2244 push_header(self.as_rec_mut(), 13u16, 2 as u16);
2245 self.as_rec_mut().extend(value.to_ne_bytes());
2246 self
2247 }
2248 pub fn push_timeout(mut self, value: u32) -> Self {
2249 push_header(self.as_rec_mut(), 14u16, 4 as u16);
2250 self.as_rec_mut().extend(value.to_ne_bytes());
2251 self
2252 }
2253 pub fn push_if_idx(mut self, value: i32) -> Self {
2254 push_header(self.as_rec_mut(), 15u16, 4 as u16);
2255 self.as_rec_mut().extend(value.to_ne_bytes());
2256 self
2257 }
2258 pub fn push_reset_reason(mut self, value: u32) -> Self {
2259 push_header(self.as_rec_mut(), 16u16, 4 as u16);
2260 self.as_rec_mut().extend(value.to_ne_bytes());
2261 self
2262 }
2263 pub fn push_reset_flags(mut self, value: u32) -> Self {
2264 push_header(self.as_rec_mut(), 17u16, 4 as u16);
2265 self.as_rec_mut().extend(value.to_ne_bytes());
2266 self
2267 }
2268 #[doc = "Deprecated: use 'flags'"]
2269 pub fn push_server_side(mut self, value: u8) -> Self {
2270 push_header(self.as_rec_mut(), 18u16, 1 as u16);
2271 self.as_rec_mut().extend(value.to_ne_bytes());
2272 self
2273 }
2274}
2275impl<Prev: Rec> Drop for PushEventAttr<Prev> {
2276 fn drop(&mut self) {
2277 if let Some(prev) = &mut self.prev {
2278 if let Some(header_offset) = &self.header_offset {
2279 finalize_nested_header(prev.as_rec_mut(), *header_offset);
2280 }
2281 }
2282 }
2283}
2284#[doc = "Add endpoint\nFlags: uns-admin-perm\nRequest attributes:\n- [.nested_addr()](PushEndpoint::nested_addr)\n"]
2285#[derive(Debug)]
2286pub struct OpAddAddrDo<'r> {
2287 request: Request<'r>,
2288}
2289impl<'r> OpAddAddrDo<'r> {
2290 pub fn new(mut request: Request<'r>) -> Self {
2291 Self::write_header(request.buf_mut());
2292 Self { request: request }
2293 }
2294 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushEndpoint<&'buf mut Vec<u8>> {
2295 Self::write_header(buf);
2296 PushEndpoint::new(buf)
2297 }
2298 pub fn encode(&mut self) -> PushEndpoint<&mut Vec<u8>> {
2299 PushEndpoint::new(self.request.buf_mut())
2300 }
2301 pub fn into_encoder(self) -> PushEndpoint<RequestBuf<'r>> {
2302 PushEndpoint::new(self.request.buf)
2303 }
2304 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableEndpoint<'a> {
2305 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
2306 IterableEndpoint::with_loc(attrs, buf.as_ptr() as usize)
2307 }
2308 fn write_header<Prev: Rec>(prev: &mut Prev) {
2309 let mut header = BuiltinNfgenmsg::new();
2310 header.cmd = 1u8;
2311 header.version = 1u8;
2312 prev.as_rec_mut().extend(header.as_slice());
2313 }
2314}
2315impl NetlinkRequest for OpAddAddrDo<'_> {
2316 fn protocol(&self) -> Protocol {
2317 Protocol::Generic("mptcp_pm".as_bytes())
2318 }
2319 fn flags(&self) -> u16 {
2320 self.request.flags
2321 }
2322 fn payload(&self) -> &[u8] {
2323 self.request.buf()
2324 }
2325 type ReplyType<'buf> = IterableEndpoint<'buf>;
2326 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
2327 Self::decode_request(buf)
2328 }
2329 fn lookup(
2330 buf: &[u8],
2331 offset: usize,
2332 missing_type: Option<u16>,
2333 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
2334 Self::decode_request(buf).lookup_attr(offset, missing_type)
2335 }
2336}
2337#[doc = "Delete endpoint\nFlags: uns-admin-perm\nRequest attributes:\n- [.nested_addr()](PushEndpoint::nested_addr)\n"]
2338#[derive(Debug)]
2339pub struct OpDelAddrDo<'r> {
2340 request: Request<'r>,
2341}
2342impl<'r> OpDelAddrDo<'r> {
2343 pub fn new(mut request: Request<'r>) -> Self {
2344 Self::write_header(request.buf_mut());
2345 Self { request: request }
2346 }
2347 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushEndpoint<&'buf mut Vec<u8>> {
2348 Self::write_header(buf);
2349 PushEndpoint::new(buf)
2350 }
2351 pub fn encode(&mut self) -> PushEndpoint<&mut Vec<u8>> {
2352 PushEndpoint::new(self.request.buf_mut())
2353 }
2354 pub fn into_encoder(self) -> PushEndpoint<RequestBuf<'r>> {
2355 PushEndpoint::new(self.request.buf)
2356 }
2357 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableEndpoint<'a> {
2358 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
2359 IterableEndpoint::with_loc(attrs, buf.as_ptr() as usize)
2360 }
2361 fn write_header<Prev: Rec>(prev: &mut Prev) {
2362 let mut header = BuiltinNfgenmsg::new();
2363 header.cmd = 2u8;
2364 header.version = 1u8;
2365 prev.as_rec_mut().extend(header.as_slice());
2366 }
2367}
2368impl NetlinkRequest for OpDelAddrDo<'_> {
2369 fn protocol(&self) -> Protocol {
2370 Protocol::Generic("mptcp_pm".as_bytes())
2371 }
2372 fn flags(&self) -> u16 {
2373 self.request.flags
2374 }
2375 fn payload(&self) -> &[u8] {
2376 self.request.buf()
2377 }
2378 type ReplyType<'buf> = IterableEndpoint<'buf>;
2379 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
2380 Self::decode_request(buf)
2381 }
2382 fn lookup(
2383 buf: &[u8],
2384 offset: usize,
2385 missing_type: Option<u16>,
2386 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
2387 Self::decode_request(buf).lookup_attr(offset, missing_type)
2388 }
2389}
2390#[doc = "Get endpoint information\n\nReply attributes:\n- [.get_addr()](IterableAttr::get_addr)\n"]
2391#[derive(Debug)]
2392pub struct OpGetAddrDump<'r> {
2393 request: Request<'r>,
2394}
2395impl<'r> OpGetAddrDump<'r> {
2396 pub fn new(mut request: Request<'r>) -> Self {
2397 Self::write_header(request.buf_mut());
2398 Self {
2399 request: request.set_dump(),
2400 }
2401 }
2402 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushAttr<&'buf mut Vec<u8>> {
2403 Self::write_header(buf);
2404 PushAttr::new(buf)
2405 }
2406 pub fn encode(&mut self) -> PushAttr<&mut Vec<u8>> {
2407 PushAttr::new(self.request.buf_mut())
2408 }
2409 pub fn into_encoder(self) -> PushAttr<RequestBuf<'r>> {
2410 PushAttr::new(self.request.buf)
2411 }
2412 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableAttr<'a> {
2413 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
2414 IterableAttr::with_loc(attrs, buf.as_ptr() as usize)
2415 }
2416 fn write_header<Prev: Rec>(prev: &mut Prev) {
2417 let mut header = BuiltinNfgenmsg::new();
2418 header.cmd = 3u8;
2419 header.version = 1u8;
2420 prev.as_rec_mut().extend(header.as_slice());
2421 }
2422}
2423impl NetlinkRequest for OpGetAddrDump<'_> {
2424 fn protocol(&self) -> Protocol {
2425 Protocol::Generic("mptcp_pm".as_bytes())
2426 }
2427 fn flags(&self) -> u16 {
2428 self.request.flags
2429 }
2430 fn payload(&self) -> &[u8] {
2431 self.request.buf()
2432 }
2433 type ReplyType<'buf> = IterableAttr<'buf>;
2434 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
2435 Self::decode_request(buf)
2436 }
2437 fn lookup(
2438 buf: &[u8],
2439 offset: usize,
2440 missing_type: Option<u16>,
2441 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
2442 Self::decode_request(buf).lookup_attr(offset, missing_type)
2443 }
2444}
2445#[doc = "Get endpoint information\nRequest attributes:\n- [.nested_addr()](PushAttr::nested_addr)\n- [.push_token()](PushAttr::push_token)\n\nReply attributes:\n- [.get_addr()](IterableAttr::get_addr)\n"]
2446#[derive(Debug)]
2447pub struct OpGetAddrDo<'r> {
2448 request: Request<'r>,
2449}
2450impl<'r> OpGetAddrDo<'r> {
2451 pub fn new(mut request: Request<'r>) -> Self {
2452 Self::write_header(request.buf_mut());
2453 Self { request: request }
2454 }
2455 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushAttr<&'buf mut Vec<u8>> {
2456 Self::write_header(buf);
2457 PushAttr::new(buf)
2458 }
2459 pub fn encode(&mut self) -> PushAttr<&mut Vec<u8>> {
2460 PushAttr::new(self.request.buf_mut())
2461 }
2462 pub fn into_encoder(self) -> PushAttr<RequestBuf<'r>> {
2463 PushAttr::new(self.request.buf)
2464 }
2465 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableAttr<'a> {
2466 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
2467 IterableAttr::with_loc(attrs, buf.as_ptr() as usize)
2468 }
2469 fn write_header<Prev: Rec>(prev: &mut Prev) {
2470 let mut header = BuiltinNfgenmsg::new();
2471 header.cmd = 3u8;
2472 header.version = 1u8;
2473 prev.as_rec_mut().extend(header.as_slice());
2474 }
2475}
2476impl NetlinkRequest for OpGetAddrDo<'_> {
2477 fn protocol(&self) -> Protocol {
2478 Protocol::Generic("mptcp_pm".as_bytes())
2479 }
2480 fn flags(&self) -> u16 {
2481 self.request.flags
2482 }
2483 fn payload(&self) -> &[u8] {
2484 self.request.buf()
2485 }
2486 type ReplyType<'buf> = IterableAttr<'buf>;
2487 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
2488 Self::decode_request(buf)
2489 }
2490 fn lookup(
2491 buf: &[u8],
2492 offset: usize,
2493 missing_type: Option<u16>,
2494 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
2495 Self::decode_request(buf).lookup_attr(offset, missing_type)
2496 }
2497}
2498#[doc = "Flush addresses\nFlags: uns-admin-perm\nRequest attributes:\n- [.nested_addr()](PushEndpoint::nested_addr)\n"]
2499#[derive(Debug)]
2500pub struct OpFlushAddrsDo<'r> {
2501 request: Request<'r>,
2502}
2503impl<'r> OpFlushAddrsDo<'r> {
2504 pub fn new(mut request: Request<'r>) -> Self {
2505 Self::write_header(request.buf_mut());
2506 Self { request: request }
2507 }
2508 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushEndpoint<&'buf mut Vec<u8>> {
2509 Self::write_header(buf);
2510 PushEndpoint::new(buf)
2511 }
2512 pub fn encode(&mut self) -> PushEndpoint<&mut Vec<u8>> {
2513 PushEndpoint::new(self.request.buf_mut())
2514 }
2515 pub fn into_encoder(self) -> PushEndpoint<RequestBuf<'r>> {
2516 PushEndpoint::new(self.request.buf)
2517 }
2518 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableEndpoint<'a> {
2519 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
2520 IterableEndpoint::with_loc(attrs, buf.as_ptr() as usize)
2521 }
2522 fn write_header<Prev: Rec>(prev: &mut Prev) {
2523 let mut header = BuiltinNfgenmsg::new();
2524 header.cmd = 4u8;
2525 header.version = 1u8;
2526 prev.as_rec_mut().extend(header.as_slice());
2527 }
2528}
2529impl NetlinkRequest for OpFlushAddrsDo<'_> {
2530 fn protocol(&self) -> Protocol {
2531 Protocol::Generic("mptcp_pm".as_bytes())
2532 }
2533 fn flags(&self) -> u16 {
2534 self.request.flags
2535 }
2536 fn payload(&self) -> &[u8] {
2537 self.request.buf()
2538 }
2539 type ReplyType<'buf> = IterableEndpoint<'buf>;
2540 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
2541 Self::decode_request(buf)
2542 }
2543 fn lookup(
2544 buf: &[u8],
2545 offset: usize,
2546 missing_type: Option<u16>,
2547 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
2548 Self::decode_request(buf).lookup_attr(offset, missing_type)
2549 }
2550}
2551#[doc = "Set protocol limits\nFlags: uns-admin-perm\nRequest attributes:\n- [.push_rcv_add_addrs()](PushAttr::push_rcv_add_addrs)\n- [.push_subflows()](PushAttr::push_subflows)\n"]
2552#[derive(Debug)]
2553pub struct OpSetLimitsDo<'r> {
2554 request: Request<'r>,
2555}
2556impl<'r> OpSetLimitsDo<'r> {
2557 pub fn new(mut request: Request<'r>) -> Self {
2558 Self::write_header(request.buf_mut());
2559 Self { request: request }
2560 }
2561 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushAttr<&'buf mut Vec<u8>> {
2562 Self::write_header(buf);
2563 PushAttr::new(buf)
2564 }
2565 pub fn encode(&mut self) -> PushAttr<&mut Vec<u8>> {
2566 PushAttr::new(self.request.buf_mut())
2567 }
2568 pub fn into_encoder(self) -> PushAttr<RequestBuf<'r>> {
2569 PushAttr::new(self.request.buf)
2570 }
2571 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableAttr<'a> {
2572 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
2573 IterableAttr::with_loc(attrs, buf.as_ptr() as usize)
2574 }
2575 fn write_header<Prev: Rec>(prev: &mut Prev) {
2576 let mut header = BuiltinNfgenmsg::new();
2577 header.cmd = 5u8;
2578 header.version = 1u8;
2579 prev.as_rec_mut().extend(header.as_slice());
2580 }
2581}
2582impl NetlinkRequest for OpSetLimitsDo<'_> {
2583 fn protocol(&self) -> Protocol {
2584 Protocol::Generic("mptcp_pm".as_bytes())
2585 }
2586 fn flags(&self) -> u16 {
2587 self.request.flags
2588 }
2589 fn payload(&self) -> &[u8] {
2590 self.request.buf()
2591 }
2592 type ReplyType<'buf> = IterableAttr<'buf>;
2593 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
2594 Self::decode_request(buf)
2595 }
2596 fn lookup(
2597 buf: &[u8],
2598 offset: usize,
2599 missing_type: Option<u16>,
2600 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
2601 Self::decode_request(buf).lookup_attr(offset, missing_type)
2602 }
2603}
2604#[doc = "Get protocol limits\nRequest attributes:\n- [.push_rcv_add_addrs()](PushAttr::push_rcv_add_addrs)\n- [.push_subflows()](PushAttr::push_subflows)\n\nReply attributes:\n- [.get_rcv_add_addrs()](IterableAttr::get_rcv_add_addrs)\n- [.get_subflows()](IterableAttr::get_subflows)\n"]
2605#[derive(Debug)]
2606pub struct OpGetLimitsDo<'r> {
2607 request: Request<'r>,
2608}
2609impl<'r> OpGetLimitsDo<'r> {
2610 pub fn new(mut request: Request<'r>) -> Self {
2611 Self::write_header(request.buf_mut());
2612 Self { request: request }
2613 }
2614 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushAttr<&'buf mut Vec<u8>> {
2615 Self::write_header(buf);
2616 PushAttr::new(buf)
2617 }
2618 pub fn encode(&mut self) -> PushAttr<&mut Vec<u8>> {
2619 PushAttr::new(self.request.buf_mut())
2620 }
2621 pub fn into_encoder(self) -> PushAttr<RequestBuf<'r>> {
2622 PushAttr::new(self.request.buf)
2623 }
2624 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableAttr<'a> {
2625 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
2626 IterableAttr::with_loc(attrs, buf.as_ptr() as usize)
2627 }
2628 fn write_header<Prev: Rec>(prev: &mut Prev) {
2629 let mut header = BuiltinNfgenmsg::new();
2630 header.cmd = 6u8;
2631 header.version = 1u8;
2632 prev.as_rec_mut().extend(header.as_slice());
2633 }
2634}
2635impl NetlinkRequest for OpGetLimitsDo<'_> {
2636 fn protocol(&self) -> Protocol {
2637 Protocol::Generic("mptcp_pm".as_bytes())
2638 }
2639 fn flags(&self) -> u16 {
2640 self.request.flags
2641 }
2642 fn payload(&self) -> &[u8] {
2643 self.request.buf()
2644 }
2645 type ReplyType<'buf> = IterableAttr<'buf>;
2646 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
2647 Self::decode_request(buf)
2648 }
2649 fn lookup(
2650 buf: &[u8],
2651 offset: usize,
2652 missing_type: Option<u16>,
2653 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
2654 Self::decode_request(buf).lookup_attr(offset, missing_type)
2655 }
2656}
2657#[doc = "Change endpoint flags\nFlags: uns-admin-perm\nRequest attributes:\n- [.nested_addr()](PushAttr::nested_addr)\n- [.push_token()](PushAttr::push_token)\n- [.nested_addr_remote()](PushAttr::nested_addr_remote)\n"]
2658#[derive(Debug)]
2659pub struct OpSetFlagsDo<'r> {
2660 request: Request<'r>,
2661}
2662impl<'r> OpSetFlagsDo<'r> {
2663 pub fn new(mut request: Request<'r>) -> Self {
2664 Self::write_header(request.buf_mut());
2665 Self { request: request }
2666 }
2667 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushAttr<&'buf mut Vec<u8>> {
2668 Self::write_header(buf);
2669 PushAttr::new(buf)
2670 }
2671 pub fn encode(&mut self) -> PushAttr<&mut Vec<u8>> {
2672 PushAttr::new(self.request.buf_mut())
2673 }
2674 pub fn into_encoder(self) -> PushAttr<RequestBuf<'r>> {
2675 PushAttr::new(self.request.buf)
2676 }
2677 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableAttr<'a> {
2678 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
2679 IterableAttr::with_loc(attrs, buf.as_ptr() as usize)
2680 }
2681 fn write_header<Prev: Rec>(prev: &mut Prev) {
2682 let mut header = BuiltinNfgenmsg::new();
2683 header.cmd = 7u8;
2684 header.version = 1u8;
2685 prev.as_rec_mut().extend(header.as_slice());
2686 }
2687}
2688impl NetlinkRequest for OpSetFlagsDo<'_> {
2689 fn protocol(&self) -> Protocol {
2690 Protocol::Generic("mptcp_pm".as_bytes())
2691 }
2692 fn flags(&self) -> u16 {
2693 self.request.flags
2694 }
2695 fn payload(&self) -> &[u8] {
2696 self.request.buf()
2697 }
2698 type ReplyType<'buf> = IterableAttr<'buf>;
2699 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
2700 Self::decode_request(buf)
2701 }
2702 fn lookup(
2703 buf: &[u8],
2704 offset: usize,
2705 missing_type: Option<u16>,
2706 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
2707 Self::decode_request(buf).lookup_attr(offset, missing_type)
2708 }
2709}
2710#[doc = "Announce new address\nFlags: uns-admin-perm\nRequest attributes:\n- [.nested_addr()](PushAttr::nested_addr)\n- [.push_token()](PushAttr::push_token)\n"]
2711#[derive(Debug)]
2712pub struct OpAnnounceDo<'r> {
2713 request: Request<'r>,
2714}
2715impl<'r> OpAnnounceDo<'r> {
2716 pub fn new(mut request: Request<'r>) -> Self {
2717 Self::write_header(request.buf_mut());
2718 Self { request: request }
2719 }
2720 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushAttr<&'buf mut Vec<u8>> {
2721 Self::write_header(buf);
2722 PushAttr::new(buf)
2723 }
2724 pub fn encode(&mut self) -> PushAttr<&mut Vec<u8>> {
2725 PushAttr::new(self.request.buf_mut())
2726 }
2727 pub fn into_encoder(self) -> PushAttr<RequestBuf<'r>> {
2728 PushAttr::new(self.request.buf)
2729 }
2730 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableAttr<'a> {
2731 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
2732 IterableAttr::with_loc(attrs, buf.as_ptr() as usize)
2733 }
2734 fn write_header<Prev: Rec>(prev: &mut Prev) {
2735 let mut header = BuiltinNfgenmsg::new();
2736 header.cmd = 8u8;
2737 header.version = 1u8;
2738 prev.as_rec_mut().extend(header.as_slice());
2739 }
2740}
2741impl NetlinkRequest for OpAnnounceDo<'_> {
2742 fn protocol(&self) -> Protocol {
2743 Protocol::Generic("mptcp_pm".as_bytes())
2744 }
2745 fn flags(&self) -> u16 {
2746 self.request.flags
2747 }
2748 fn payload(&self) -> &[u8] {
2749 self.request.buf()
2750 }
2751 type ReplyType<'buf> = IterableAttr<'buf>;
2752 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
2753 Self::decode_request(buf)
2754 }
2755 fn lookup(
2756 buf: &[u8],
2757 offset: usize,
2758 missing_type: Option<u16>,
2759 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
2760 Self::decode_request(buf).lookup_attr(offset, missing_type)
2761 }
2762}
2763#[doc = "Announce removal\nFlags: uns-admin-perm\nRequest attributes:\n- [.push_token()](PushAttr::push_token)\n- [.push_loc_id()](PushAttr::push_loc_id)\n"]
2764#[derive(Debug)]
2765pub struct OpRemoveDo<'r> {
2766 request: Request<'r>,
2767}
2768impl<'r> OpRemoveDo<'r> {
2769 pub fn new(mut request: Request<'r>) -> Self {
2770 Self::write_header(request.buf_mut());
2771 Self { request: request }
2772 }
2773 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushAttr<&'buf mut Vec<u8>> {
2774 Self::write_header(buf);
2775 PushAttr::new(buf)
2776 }
2777 pub fn encode(&mut self) -> PushAttr<&mut Vec<u8>> {
2778 PushAttr::new(self.request.buf_mut())
2779 }
2780 pub fn into_encoder(self) -> PushAttr<RequestBuf<'r>> {
2781 PushAttr::new(self.request.buf)
2782 }
2783 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableAttr<'a> {
2784 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
2785 IterableAttr::with_loc(attrs, buf.as_ptr() as usize)
2786 }
2787 fn write_header<Prev: Rec>(prev: &mut Prev) {
2788 let mut header = BuiltinNfgenmsg::new();
2789 header.cmd = 9u8;
2790 header.version = 1u8;
2791 prev.as_rec_mut().extend(header.as_slice());
2792 }
2793}
2794impl NetlinkRequest for OpRemoveDo<'_> {
2795 fn protocol(&self) -> Protocol {
2796 Protocol::Generic("mptcp_pm".as_bytes())
2797 }
2798 fn flags(&self) -> u16 {
2799 self.request.flags
2800 }
2801 fn payload(&self) -> &[u8] {
2802 self.request.buf()
2803 }
2804 type ReplyType<'buf> = IterableAttr<'buf>;
2805 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
2806 Self::decode_request(buf)
2807 }
2808 fn lookup(
2809 buf: &[u8],
2810 offset: usize,
2811 missing_type: Option<u16>,
2812 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
2813 Self::decode_request(buf).lookup_attr(offset, missing_type)
2814 }
2815}
2816#[doc = "Create subflow\nFlags: uns-admin-perm\nRequest attributes:\n- [.nested_addr()](PushAttr::nested_addr)\n- [.push_token()](PushAttr::push_token)\n- [.nested_addr_remote()](PushAttr::nested_addr_remote)\n"]
2817#[derive(Debug)]
2818pub struct OpSubflowCreateDo<'r> {
2819 request: Request<'r>,
2820}
2821impl<'r> OpSubflowCreateDo<'r> {
2822 pub fn new(mut request: Request<'r>) -> Self {
2823 Self::write_header(request.buf_mut());
2824 Self { request: request }
2825 }
2826 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushAttr<&'buf mut Vec<u8>> {
2827 Self::write_header(buf);
2828 PushAttr::new(buf)
2829 }
2830 pub fn encode(&mut self) -> PushAttr<&mut Vec<u8>> {
2831 PushAttr::new(self.request.buf_mut())
2832 }
2833 pub fn into_encoder(self) -> PushAttr<RequestBuf<'r>> {
2834 PushAttr::new(self.request.buf)
2835 }
2836 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableAttr<'a> {
2837 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
2838 IterableAttr::with_loc(attrs, buf.as_ptr() as usize)
2839 }
2840 fn write_header<Prev: Rec>(prev: &mut Prev) {
2841 let mut header = BuiltinNfgenmsg::new();
2842 header.cmd = 10u8;
2843 header.version = 1u8;
2844 prev.as_rec_mut().extend(header.as_slice());
2845 }
2846}
2847impl NetlinkRequest for OpSubflowCreateDo<'_> {
2848 fn protocol(&self) -> Protocol {
2849 Protocol::Generic("mptcp_pm".as_bytes())
2850 }
2851 fn flags(&self) -> u16 {
2852 self.request.flags
2853 }
2854 fn payload(&self) -> &[u8] {
2855 self.request.buf()
2856 }
2857 type ReplyType<'buf> = IterableAttr<'buf>;
2858 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
2859 Self::decode_request(buf)
2860 }
2861 fn lookup(
2862 buf: &[u8],
2863 offset: usize,
2864 missing_type: Option<u16>,
2865 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
2866 Self::decode_request(buf).lookup_attr(offset, missing_type)
2867 }
2868}
2869#[doc = "Destroy subflow\nFlags: uns-admin-perm\nRequest attributes:\n- [.nested_addr()](PushAttr::nested_addr)\n- [.push_token()](PushAttr::push_token)\n- [.nested_addr_remote()](PushAttr::nested_addr_remote)\n"]
2870#[derive(Debug)]
2871pub struct OpSubflowDestroyDo<'r> {
2872 request: Request<'r>,
2873}
2874impl<'r> OpSubflowDestroyDo<'r> {
2875 pub fn new(mut request: Request<'r>) -> Self {
2876 Self::write_header(request.buf_mut());
2877 Self { request: request }
2878 }
2879 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushAttr<&'buf mut Vec<u8>> {
2880 Self::write_header(buf);
2881 PushAttr::new(buf)
2882 }
2883 pub fn encode(&mut self) -> PushAttr<&mut Vec<u8>> {
2884 PushAttr::new(self.request.buf_mut())
2885 }
2886 pub fn into_encoder(self) -> PushAttr<RequestBuf<'r>> {
2887 PushAttr::new(self.request.buf)
2888 }
2889 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableAttr<'a> {
2890 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
2891 IterableAttr::with_loc(attrs, buf.as_ptr() as usize)
2892 }
2893 fn write_header<Prev: Rec>(prev: &mut Prev) {
2894 let mut header = BuiltinNfgenmsg::new();
2895 header.cmd = 11u8;
2896 header.version = 1u8;
2897 prev.as_rec_mut().extend(header.as_slice());
2898 }
2899}
2900impl NetlinkRequest for OpSubflowDestroyDo<'_> {
2901 fn protocol(&self) -> Protocol {
2902 Protocol::Generic("mptcp_pm".as_bytes())
2903 }
2904 fn flags(&self) -> u16 {
2905 self.request.flags
2906 }
2907 fn payload(&self) -> &[u8] {
2908 self.request.buf()
2909 }
2910 type ReplyType<'buf> = IterableAttr<'buf>;
2911 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
2912 Self::decode_request(buf)
2913 }
2914 fn lookup(
2915 buf: &[u8],
2916 offset: usize,
2917 missing_type: Option<u16>,
2918 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
2919 Self::decode_request(buf).lookup_attr(offset, missing_type)
2920 }
2921}
2922use crate::traits::LookupFn;
2923use crate::utils::RequestBuf;
2924#[derive(Debug)]
2925pub struct Request<'buf> {
2926 buf: RequestBuf<'buf>,
2927 flags: u16,
2928 writeback: Option<&'buf mut Option<RequestInfo>>,
2929}
2930#[allow(unused)]
2931#[derive(Debug, Clone)]
2932pub struct RequestInfo {
2933 protocol: Protocol,
2934 flags: u16,
2935 name: &'static str,
2936 lookup: LookupFn,
2937}
2938impl Request<'static> {
2939 pub fn new() -> Self {
2940 Self::new_from_buf(Vec::new())
2941 }
2942 pub fn new_from_buf(buf: Vec<u8>) -> Self {
2943 Self {
2944 flags: 0,
2945 buf: RequestBuf::Own(buf),
2946 writeback: None,
2947 }
2948 }
2949 pub fn into_buf(self) -> Vec<u8> {
2950 match self.buf {
2951 RequestBuf::Own(buf) => buf,
2952 _ => unreachable!(),
2953 }
2954 }
2955}
2956impl<'buf> Request<'buf> {
2957 pub fn new_with_buf(buf: &'buf mut Vec<u8>) -> Self {
2958 buf.clear();
2959 Self::new_extend(buf)
2960 }
2961 pub fn new_extend(buf: &'buf mut Vec<u8>) -> Self {
2962 Self {
2963 flags: 0,
2964 buf: RequestBuf::Ref(buf),
2965 writeback: None,
2966 }
2967 }
2968 fn do_writeback(&mut self, protocol: Protocol, name: &'static str, lookup: LookupFn) {
2969 let Some(writeback) = &mut self.writeback else {
2970 return;
2971 };
2972 **writeback = Some(RequestInfo {
2973 protocol,
2974 flags: self.flags,
2975 name,
2976 lookup,
2977 })
2978 }
2979 pub fn buf(&self) -> &Vec<u8> {
2980 self.buf.buf()
2981 }
2982 pub fn buf_mut(&mut self) -> &mut Vec<u8> {
2983 self.buf.buf_mut()
2984 }
2985 #[doc = "Set `NLM_F_CREATE` flag"]
2986 pub fn set_create(mut self) -> Self {
2987 self.flags |= consts::NLM_F_CREATE as u16;
2988 self
2989 }
2990 #[doc = "Set `NLM_F_EXCL` flag"]
2991 pub fn set_excl(mut self) -> Self {
2992 self.flags |= consts::NLM_F_EXCL as u16;
2993 self
2994 }
2995 #[doc = "Set `NLM_F_REPLACE` flag"]
2996 pub fn set_replace(mut self) -> Self {
2997 self.flags |= consts::NLM_F_REPLACE as u16;
2998 self
2999 }
3000 #[doc = "Set `NLM_F_CREATE` and `NLM_F_REPLACE` flag"]
3001 pub fn set_change(self) -> Self {
3002 self.set_create().set_replace()
3003 }
3004 #[doc = "Set `NLM_F_APPEND` flag"]
3005 pub fn set_append(mut self) -> Self {
3006 self.flags |= consts::NLM_F_APPEND as u16;
3007 self
3008 }
3009 #[doc = "Set `self.flags |= flags`"]
3010 pub fn set_flags(mut self, flags: u16) -> Self {
3011 self.flags |= flags;
3012 self
3013 }
3014 #[doc = "Set `self.flags ^= self.flags & flags`"]
3015 pub fn unset_flags(mut self, flags: u16) -> Self {
3016 self.flags ^= self.flags & flags;
3017 self
3018 }
3019 #[doc = "Set `NLM_F_DUMP` flag"]
3020 fn set_dump(mut self) -> Self {
3021 self.flags |= consts::NLM_F_DUMP as u16;
3022 self
3023 }
3024 #[doc = "Add endpoint\nFlags: uns-admin-perm\nRequest attributes:\n- [.nested_addr()](PushEndpoint::nested_addr)\n"]
3025 pub fn op_add_addr_do(self) -> OpAddAddrDo<'buf> {
3026 let mut res = OpAddAddrDo::new(self);
3027 res.request
3028 .do_writeback(res.protocol(), "op-add-addr-do", OpAddAddrDo::lookup);
3029 res
3030 }
3031 #[doc = "Delete endpoint\nFlags: uns-admin-perm\nRequest attributes:\n- [.nested_addr()](PushEndpoint::nested_addr)\n"]
3032 pub fn op_del_addr_do(self) -> OpDelAddrDo<'buf> {
3033 let mut res = OpDelAddrDo::new(self);
3034 res.request
3035 .do_writeback(res.protocol(), "op-del-addr-do", OpDelAddrDo::lookup);
3036 res
3037 }
3038 #[doc = "Get endpoint information\n\nReply attributes:\n- [.get_addr()](IterableAttr::get_addr)\n"]
3039 pub fn op_get_addr_dump(self) -> OpGetAddrDump<'buf> {
3040 let mut res = OpGetAddrDump::new(self);
3041 res.request
3042 .do_writeback(res.protocol(), "op-get-addr-dump", OpGetAddrDump::lookup);
3043 res
3044 }
3045 #[doc = "Get endpoint information\nRequest attributes:\n- [.nested_addr()](PushAttr::nested_addr)\n- [.push_token()](PushAttr::push_token)\n\nReply attributes:\n- [.get_addr()](IterableAttr::get_addr)\n"]
3046 pub fn op_get_addr_do(self) -> OpGetAddrDo<'buf> {
3047 let mut res = OpGetAddrDo::new(self);
3048 res.request
3049 .do_writeback(res.protocol(), "op-get-addr-do", OpGetAddrDo::lookup);
3050 res
3051 }
3052 #[doc = "Flush addresses\nFlags: uns-admin-perm\nRequest attributes:\n- [.nested_addr()](PushEndpoint::nested_addr)\n"]
3053 pub fn op_flush_addrs_do(self) -> OpFlushAddrsDo<'buf> {
3054 let mut res = OpFlushAddrsDo::new(self);
3055 res.request
3056 .do_writeback(res.protocol(), "op-flush-addrs-do", OpFlushAddrsDo::lookup);
3057 res
3058 }
3059 #[doc = "Set protocol limits\nFlags: uns-admin-perm\nRequest attributes:\n- [.push_rcv_add_addrs()](PushAttr::push_rcv_add_addrs)\n- [.push_subflows()](PushAttr::push_subflows)\n"]
3060 pub fn op_set_limits_do(self) -> OpSetLimitsDo<'buf> {
3061 let mut res = OpSetLimitsDo::new(self);
3062 res.request
3063 .do_writeback(res.protocol(), "op-set-limits-do", OpSetLimitsDo::lookup);
3064 res
3065 }
3066 #[doc = "Get protocol limits\nRequest attributes:\n- [.push_rcv_add_addrs()](PushAttr::push_rcv_add_addrs)\n- [.push_subflows()](PushAttr::push_subflows)\n\nReply attributes:\n- [.get_rcv_add_addrs()](IterableAttr::get_rcv_add_addrs)\n- [.get_subflows()](IterableAttr::get_subflows)\n"]
3067 pub fn op_get_limits_do(self) -> OpGetLimitsDo<'buf> {
3068 let mut res = OpGetLimitsDo::new(self);
3069 res.request
3070 .do_writeback(res.protocol(), "op-get-limits-do", OpGetLimitsDo::lookup);
3071 res
3072 }
3073 #[doc = "Change endpoint flags\nFlags: uns-admin-perm\nRequest attributes:\n- [.nested_addr()](PushAttr::nested_addr)\n- [.push_token()](PushAttr::push_token)\n- [.nested_addr_remote()](PushAttr::nested_addr_remote)\n"]
3074 pub fn op_set_flags_do(self) -> OpSetFlagsDo<'buf> {
3075 let mut res = OpSetFlagsDo::new(self);
3076 res.request
3077 .do_writeback(res.protocol(), "op-set-flags-do", OpSetFlagsDo::lookup);
3078 res
3079 }
3080 #[doc = "Announce new address\nFlags: uns-admin-perm\nRequest attributes:\n- [.nested_addr()](PushAttr::nested_addr)\n- [.push_token()](PushAttr::push_token)\n"]
3081 pub fn op_announce_do(self) -> OpAnnounceDo<'buf> {
3082 let mut res = OpAnnounceDo::new(self);
3083 res.request
3084 .do_writeback(res.protocol(), "op-announce-do", OpAnnounceDo::lookup);
3085 res
3086 }
3087 #[doc = "Announce removal\nFlags: uns-admin-perm\nRequest attributes:\n- [.push_token()](PushAttr::push_token)\n- [.push_loc_id()](PushAttr::push_loc_id)\n"]
3088 pub fn op_remove_do(self) -> OpRemoveDo<'buf> {
3089 let mut res = OpRemoveDo::new(self);
3090 res.request
3091 .do_writeback(res.protocol(), "op-remove-do", OpRemoveDo::lookup);
3092 res
3093 }
3094 #[doc = "Create subflow\nFlags: uns-admin-perm\nRequest attributes:\n- [.nested_addr()](PushAttr::nested_addr)\n- [.push_token()](PushAttr::push_token)\n- [.nested_addr_remote()](PushAttr::nested_addr_remote)\n"]
3095 pub fn op_subflow_create_do(self) -> OpSubflowCreateDo<'buf> {
3096 let mut res = OpSubflowCreateDo::new(self);
3097 res.request.do_writeback(
3098 res.protocol(),
3099 "op-subflow-create-do",
3100 OpSubflowCreateDo::lookup,
3101 );
3102 res
3103 }
3104 #[doc = "Destroy subflow\nFlags: uns-admin-perm\nRequest attributes:\n- [.nested_addr()](PushAttr::nested_addr)\n- [.push_token()](PushAttr::push_token)\n- [.nested_addr_remote()](PushAttr::nested_addr_remote)\n"]
3105 pub fn op_subflow_destroy_do(self) -> OpSubflowDestroyDo<'buf> {
3106 let mut res = OpSubflowDestroyDo::new(self);
3107 res.request.do_writeback(
3108 res.protocol(),
3109 "op-subflow-destroy-do",
3110 OpSubflowDestroyDo::lookup,
3111 );
3112 res
3113 }
3114}
3115#[cfg(test)]
3116mod generated_tests {
3117 use super::*;
3118 #[test]
3119 fn tests() {
3120 let _ = IterableAttr::get_addr;
3121 let _ = IterableAttr::get_rcv_add_addrs;
3122 let _ = IterableAttr::get_subflows;
3123 let _ = PushAttr::<&mut Vec<u8>>::nested_addr;
3124 let _ = PushAttr::<&mut Vec<u8>>::nested_addr_remote;
3125 let _ = PushAttr::<&mut Vec<u8>>::push_loc_id;
3126 let _ = PushAttr::<&mut Vec<u8>>::push_rcv_add_addrs;
3127 let _ = PushAttr::<&mut Vec<u8>>::push_subflows;
3128 let _ = PushAttr::<&mut Vec<u8>>::push_token;
3129 let _ = PushEndpoint::<&mut Vec<u8>>::nested_addr;
3130 }
3131}