1#![doc = "NFSD configuration over generic netlink\\."]
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 = "nfsd";
17pub const PROTONAME_CSTR: &CStr = c"nfsd";
18#[derive(Clone)]
19pub enum RpcStatus<'a> {
20 Xid(u32),
21 Flags(u32),
22 Prog(u32),
23 Version(u8),
24 Proc(u32),
25 ServiceTime(i64),
26 Pad(&'a [u8]),
27 Saddr4(std::net::Ipv4Addr),
28 Daddr4(std::net::Ipv4Addr),
29 Saddr6(&'a [u8]),
30 Daddr6(&'a [u8]),
31 Sport(u16),
32 Dport(u16),
33 #[doc = "Attribute may repeat multiple times (treat it as array)"]
34 CompoundOps(u32),
35}
36impl<'a> IterableRpcStatus<'a> {
37 pub fn get_xid(&self) -> Result<u32, ErrorContext> {
38 let mut iter = self.clone();
39 iter.pos = 0;
40 for attr in iter {
41 if let RpcStatus::Xid(val) = attr? {
42 return Ok(val);
43 }
44 }
45 Err(ErrorContext::new_missing(
46 "RpcStatus",
47 "Xid",
48 self.orig_loc,
49 self.buf.as_ptr() as usize,
50 ))
51 }
52 pub fn get_flags(&self) -> Result<u32, ErrorContext> {
53 let mut iter = self.clone();
54 iter.pos = 0;
55 for attr in iter {
56 if let RpcStatus::Flags(val) = attr? {
57 return Ok(val);
58 }
59 }
60 Err(ErrorContext::new_missing(
61 "RpcStatus",
62 "Flags",
63 self.orig_loc,
64 self.buf.as_ptr() as usize,
65 ))
66 }
67 pub fn get_prog(&self) -> Result<u32, ErrorContext> {
68 let mut iter = self.clone();
69 iter.pos = 0;
70 for attr in iter {
71 if let RpcStatus::Prog(val) = attr? {
72 return Ok(val);
73 }
74 }
75 Err(ErrorContext::new_missing(
76 "RpcStatus",
77 "Prog",
78 self.orig_loc,
79 self.buf.as_ptr() as usize,
80 ))
81 }
82 pub fn get_version(&self) -> Result<u8, ErrorContext> {
83 let mut iter = self.clone();
84 iter.pos = 0;
85 for attr in iter {
86 if let RpcStatus::Version(val) = attr? {
87 return Ok(val);
88 }
89 }
90 Err(ErrorContext::new_missing(
91 "RpcStatus",
92 "Version",
93 self.orig_loc,
94 self.buf.as_ptr() as usize,
95 ))
96 }
97 pub fn get_proc(&self) -> Result<u32, ErrorContext> {
98 let mut iter = self.clone();
99 iter.pos = 0;
100 for attr in iter {
101 if let RpcStatus::Proc(val) = attr? {
102 return Ok(val);
103 }
104 }
105 Err(ErrorContext::new_missing(
106 "RpcStatus",
107 "Proc",
108 self.orig_loc,
109 self.buf.as_ptr() as usize,
110 ))
111 }
112 pub fn get_service_time(&self) -> Result<i64, ErrorContext> {
113 let mut iter = self.clone();
114 iter.pos = 0;
115 for attr in iter {
116 if let RpcStatus::ServiceTime(val) = attr? {
117 return Ok(val);
118 }
119 }
120 Err(ErrorContext::new_missing(
121 "RpcStatus",
122 "ServiceTime",
123 self.orig_loc,
124 self.buf.as_ptr() as usize,
125 ))
126 }
127 pub fn get_pad(&self) -> Result<&'a [u8], ErrorContext> {
128 let mut iter = self.clone();
129 iter.pos = 0;
130 for attr in iter {
131 if let RpcStatus::Pad(val) = attr? {
132 return Ok(val);
133 }
134 }
135 Err(ErrorContext::new_missing(
136 "RpcStatus",
137 "Pad",
138 self.orig_loc,
139 self.buf.as_ptr() as usize,
140 ))
141 }
142 pub fn get_saddr4(&self) -> Result<std::net::Ipv4Addr, ErrorContext> {
143 let mut iter = self.clone();
144 iter.pos = 0;
145 for attr in iter {
146 if let RpcStatus::Saddr4(val) = attr? {
147 return Ok(val);
148 }
149 }
150 Err(ErrorContext::new_missing(
151 "RpcStatus",
152 "Saddr4",
153 self.orig_loc,
154 self.buf.as_ptr() as usize,
155 ))
156 }
157 pub fn get_daddr4(&self) -> Result<std::net::Ipv4Addr, ErrorContext> {
158 let mut iter = self.clone();
159 iter.pos = 0;
160 for attr in iter {
161 if let RpcStatus::Daddr4(val) = attr? {
162 return Ok(val);
163 }
164 }
165 Err(ErrorContext::new_missing(
166 "RpcStatus",
167 "Daddr4",
168 self.orig_loc,
169 self.buf.as_ptr() as usize,
170 ))
171 }
172 pub fn get_saddr6(&self) -> Result<&'a [u8], ErrorContext> {
173 let mut iter = self.clone();
174 iter.pos = 0;
175 for attr in iter {
176 if let RpcStatus::Saddr6(val) = attr? {
177 return Ok(val);
178 }
179 }
180 Err(ErrorContext::new_missing(
181 "RpcStatus",
182 "Saddr6",
183 self.orig_loc,
184 self.buf.as_ptr() as usize,
185 ))
186 }
187 pub fn get_daddr6(&self) -> Result<&'a [u8], ErrorContext> {
188 let mut iter = self.clone();
189 iter.pos = 0;
190 for attr in iter {
191 if let RpcStatus::Daddr6(val) = attr? {
192 return Ok(val);
193 }
194 }
195 Err(ErrorContext::new_missing(
196 "RpcStatus",
197 "Daddr6",
198 self.orig_loc,
199 self.buf.as_ptr() as usize,
200 ))
201 }
202 pub fn get_sport(&self) -> Result<u16, ErrorContext> {
203 let mut iter = self.clone();
204 iter.pos = 0;
205 for attr in iter {
206 if let RpcStatus::Sport(val) = attr? {
207 return Ok(val);
208 }
209 }
210 Err(ErrorContext::new_missing(
211 "RpcStatus",
212 "Sport",
213 self.orig_loc,
214 self.buf.as_ptr() as usize,
215 ))
216 }
217 pub fn get_dport(&self) -> Result<u16, ErrorContext> {
218 let mut iter = self.clone();
219 iter.pos = 0;
220 for attr in iter {
221 if let RpcStatus::Dport(val) = attr? {
222 return Ok(val);
223 }
224 }
225 Err(ErrorContext::new_missing(
226 "RpcStatus",
227 "Dport",
228 self.orig_loc,
229 self.buf.as_ptr() as usize,
230 ))
231 }
232 #[doc = "Attribute may repeat multiple times (treat it as array)"]
233 pub fn get_compound_ops(&self) -> MultiAttrIterable<Self, RpcStatus<'a>, u32> {
234 MultiAttrIterable::new(self.clone(), |variant| {
235 if let RpcStatus::CompoundOps(val) = variant {
236 Some(val)
237 } else {
238 None
239 }
240 })
241 }
242}
243impl RpcStatus<'_> {
244 pub fn new<'a>(buf: &'a [u8]) -> IterableRpcStatus<'a> {
245 IterableRpcStatus::with_loc(buf, buf.as_ptr() as usize)
246 }
247 fn attr_from_type(r#type: u16) -> Option<&'static str> {
248 let res = match r#type {
249 1u16 => "Xid",
250 2u16 => "Flags",
251 3u16 => "Prog",
252 4u16 => "Version",
253 5u16 => "Proc",
254 6u16 => "ServiceTime",
255 7u16 => "Pad",
256 8u16 => "Saddr4",
257 9u16 => "Daddr4",
258 10u16 => "Saddr6",
259 11u16 => "Daddr6",
260 12u16 => "Sport",
261 13u16 => "Dport",
262 14u16 => "CompoundOps",
263 _ => return None,
264 };
265 Some(res)
266 }
267}
268#[derive(Clone, Copy, Default)]
269pub struct IterableRpcStatus<'a> {
270 buf: &'a [u8],
271 pos: usize,
272 orig_loc: usize,
273}
274impl<'a> IterableRpcStatus<'a> {
275 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
276 Self {
277 buf,
278 pos: 0,
279 orig_loc,
280 }
281 }
282 pub fn get_buf(&self) -> &'a [u8] {
283 self.buf
284 }
285}
286impl<'a> Iterator for IterableRpcStatus<'a> {
287 type Item = Result<RpcStatus<'a>, ErrorContext>;
288 fn next(&mut self) -> Option<Self::Item> {
289 let pos = self.pos;
290 let mut r#type;
291 loop {
292 r#type = None;
293 if self.buf.len() == self.pos {
294 return None;
295 }
296 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
297 break;
298 };
299 r#type = Some(header.r#type);
300 let res = match header.r#type {
301 1u16 => RpcStatus::Xid({
302 let res = parse_be_u32(next);
303 let Some(val) = res else { break };
304 val
305 }),
306 2u16 => RpcStatus::Flags({
307 let res = parse_u32(next);
308 let Some(val) = res else { break };
309 val
310 }),
311 3u16 => RpcStatus::Prog({
312 let res = parse_u32(next);
313 let Some(val) = res else { break };
314 val
315 }),
316 4u16 => RpcStatus::Version({
317 let res = parse_u8(next);
318 let Some(val) = res else { break };
319 val
320 }),
321 5u16 => RpcStatus::Proc({
322 let res = parse_u32(next);
323 let Some(val) = res else { break };
324 val
325 }),
326 6u16 => RpcStatus::ServiceTime({
327 let res = parse_i64(next);
328 let Some(val) = res else { break };
329 val
330 }),
331 7u16 => RpcStatus::Pad({
332 let res = Some(next);
333 let Some(val) = res else { break };
334 val
335 }),
336 8u16 => RpcStatus::Saddr4({
337 let res = parse_be_u32(next).map(Ipv4Addr::from_bits);
338 let Some(val) = res else { break };
339 val
340 }),
341 9u16 => RpcStatus::Daddr4({
342 let res = parse_be_u32(next).map(Ipv4Addr::from_bits);
343 let Some(val) = res else { break };
344 val
345 }),
346 10u16 => RpcStatus::Saddr6({
347 let res = Some(next);
348 let Some(val) = res else { break };
349 val
350 }),
351 11u16 => RpcStatus::Daddr6({
352 let res = Some(next);
353 let Some(val) = res else { break };
354 val
355 }),
356 12u16 => RpcStatus::Sport({
357 let res = parse_be_u16(next);
358 let Some(val) = res else { break };
359 val
360 }),
361 13u16 => RpcStatus::Dport({
362 let res = parse_be_u16(next);
363 let Some(val) = res else { break };
364 val
365 }),
366 14u16 => RpcStatus::CompoundOps({
367 let res = parse_u32(next);
368 let Some(val) = res else { break };
369 val
370 }),
371 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
372 n => continue,
373 };
374 return Some(Ok(res));
375 }
376 Some(Err(ErrorContext::new(
377 "RpcStatus",
378 r#type.and_then(|t| RpcStatus::attr_from_type(t)),
379 self.orig_loc,
380 self.buf.as_ptr().wrapping_add(pos) as usize,
381 )))
382 }
383}
384impl<'a> std::fmt::Debug for IterableRpcStatus<'_> {
385 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
386 let mut fmt = f.debug_struct("RpcStatus");
387 for attr in self.clone() {
388 let attr = match attr {
389 Ok(a) => a,
390 Err(err) => {
391 fmt.finish()?;
392 f.write_str("Err(")?;
393 err.fmt(f)?;
394 return f.write_str(")");
395 }
396 };
397 match attr {
398 RpcStatus::Xid(val) => fmt.field("Xid", &val),
399 RpcStatus::Flags(val) => fmt.field("Flags", &val),
400 RpcStatus::Prog(val) => fmt.field("Prog", &val),
401 RpcStatus::Version(val) => fmt.field("Version", &val),
402 RpcStatus::Proc(val) => fmt.field("Proc", &val),
403 RpcStatus::ServiceTime(val) => fmt.field("ServiceTime", &val),
404 RpcStatus::Pad(val) => fmt.field("Pad", &val),
405 RpcStatus::Saddr4(val) => fmt.field("Saddr4", &val),
406 RpcStatus::Daddr4(val) => fmt.field("Daddr4", &val),
407 RpcStatus::Saddr6(val) => fmt.field("Saddr6", &val),
408 RpcStatus::Daddr6(val) => fmt.field("Daddr6", &val),
409 RpcStatus::Sport(val) => fmt.field("Sport", &val),
410 RpcStatus::Dport(val) => fmt.field("Dport", &val),
411 RpcStatus::CompoundOps(val) => fmt.field("CompoundOps", &val),
412 };
413 }
414 fmt.finish()
415 }
416}
417impl IterableRpcStatus<'_> {
418 pub fn lookup_attr(
419 &self,
420 offset: usize,
421 missing_type: Option<u16>,
422 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
423 let mut stack = Vec::new();
424 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
425 if missing_type.is_some() && cur == offset {
426 stack.push(("RpcStatus", offset));
427 return (
428 stack,
429 missing_type.and_then(|t| RpcStatus::attr_from_type(t)),
430 );
431 }
432 if cur > offset || cur + self.buf.len() < offset {
433 return (stack, None);
434 }
435 let mut attrs = self.clone();
436 let mut last_off = cur + attrs.pos;
437 while let Some(attr) = attrs.next() {
438 let Ok(attr) = attr else { break };
439 match attr {
440 RpcStatus::Xid(val) => {
441 if last_off == offset {
442 stack.push(("Xid", last_off));
443 break;
444 }
445 }
446 RpcStatus::Flags(val) => {
447 if last_off == offset {
448 stack.push(("Flags", last_off));
449 break;
450 }
451 }
452 RpcStatus::Prog(val) => {
453 if last_off == offset {
454 stack.push(("Prog", last_off));
455 break;
456 }
457 }
458 RpcStatus::Version(val) => {
459 if last_off == offset {
460 stack.push(("Version", last_off));
461 break;
462 }
463 }
464 RpcStatus::Proc(val) => {
465 if last_off == offset {
466 stack.push(("Proc", last_off));
467 break;
468 }
469 }
470 RpcStatus::ServiceTime(val) => {
471 if last_off == offset {
472 stack.push(("ServiceTime", last_off));
473 break;
474 }
475 }
476 RpcStatus::Pad(val) => {
477 if last_off == offset {
478 stack.push(("Pad", last_off));
479 break;
480 }
481 }
482 RpcStatus::Saddr4(val) => {
483 if last_off == offset {
484 stack.push(("Saddr4", last_off));
485 break;
486 }
487 }
488 RpcStatus::Daddr4(val) => {
489 if last_off == offset {
490 stack.push(("Daddr4", last_off));
491 break;
492 }
493 }
494 RpcStatus::Saddr6(val) => {
495 if last_off == offset {
496 stack.push(("Saddr6", last_off));
497 break;
498 }
499 }
500 RpcStatus::Daddr6(val) => {
501 if last_off == offset {
502 stack.push(("Daddr6", last_off));
503 break;
504 }
505 }
506 RpcStatus::Sport(val) => {
507 if last_off == offset {
508 stack.push(("Sport", last_off));
509 break;
510 }
511 }
512 RpcStatus::Dport(val) => {
513 if last_off == offset {
514 stack.push(("Dport", last_off));
515 break;
516 }
517 }
518 RpcStatus::CompoundOps(val) => {
519 if last_off == offset {
520 stack.push(("CompoundOps", last_off));
521 break;
522 }
523 }
524 _ => {}
525 };
526 last_off = cur + attrs.pos;
527 }
528 if !stack.is_empty() {
529 stack.push(("RpcStatus", cur));
530 }
531 (stack, None)
532 }
533}
534#[derive(Clone)]
535pub enum Server<'a> {
536 #[doc = "Attribute may repeat multiple times (treat it as array)"]
537 Threads(u32),
538 Gracetime(u32),
539 Leasetime(u32),
540 Scope(&'a CStr),
541 MinThreads(u32),
542}
543impl<'a> IterableServer<'a> {
544 #[doc = "Attribute may repeat multiple times (treat it as array)"]
545 pub fn get_threads(&self) -> MultiAttrIterable<Self, Server<'a>, u32> {
546 MultiAttrIterable::new(self.clone(), |variant| {
547 if let Server::Threads(val) = variant {
548 Some(val)
549 } else {
550 None
551 }
552 })
553 }
554 pub fn get_gracetime(&self) -> Result<u32, ErrorContext> {
555 let mut iter = self.clone();
556 iter.pos = 0;
557 for attr in iter {
558 if let Server::Gracetime(val) = attr? {
559 return Ok(val);
560 }
561 }
562 Err(ErrorContext::new_missing(
563 "Server",
564 "Gracetime",
565 self.orig_loc,
566 self.buf.as_ptr() as usize,
567 ))
568 }
569 pub fn get_leasetime(&self) -> Result<u32, ErrorContext> {
570 let mut iter = self.clone();
571 iter.pos = 0;
572 for attr in iter {
573 if let Server::Leasetime(val) = attr? {
574 return Ok(val);
575 }
576 }
577 Err(ErrorContext::new_missing(
578 "Server",
579 "Leasetime",
580 self.orig_loc,
581 self.buf.as_ptr() as usize,
582 ))
583 }
584 pub fn get_scope(&self) -> Result<&'a CStr, ErrorContext> {
585 let mut iter = self.clone();
586 iter.pos = 0;
587 for attr in iter {
588 if let Server::Scope(val) = attr? {
589 return Ok(val);
590 }
591 }
592 Err(ErrorContext::new_missing(
593 "Server",
594 "Scope",
595 self.orig_loc,
596 self.buf.as_ptr() as usize,
597 ))
598 }
599 pub fn get_min_threads(&self) -> Result<u32, ErrorContext> {
600 let mut iter = self.clone();
601 iter.pos = 0;
602 for attr in iter {
603 if let Server::MinThreads(val) = attr? {
604 return Ok(val);
605 }
606 }
607 Err(ErrorContext::new_missing(
608 "Server",
609 "MinThreads",
610 self.orig_loc,
611 self.buf.as_ptr() as usize,
612 ))
613 }
614}
615impl Server<'_> {
616 pub fn new<'a>(buf: &'a [u8]) -> IterableServer<'a> {
617 IterableServer::with_loc(buf, buf.as_ptr() as usize)
618 }
619 fn attr_from_type(r#type: u16) -> Option<&'static str> {
620 let res = match r#type {
621 1u16 => "Threads",
622 2u16 => "Gracetime",
623 3u16 => "Leasetime",
624 4u16 => "Scope",
625 5u16 => "MinThreads",
626 _ => return None,
627 };
628 Some(res)
629 }
630}
631#[derive(Clone, Copy, Default)]
632pub struct IterableServer<'a> {
633 buf: &'a [u8],
634 pos: usize,
635 orig_loc: usize,
636}
637impl<'a> IterableServer<'a> {
638 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
639 Self {
640 buf,
641 pos: 0,
642 orig_loc,
643 }
644 }
645 pub fn get_buf(&self) -> &'a [u8] {
646 self.buf
647 }
648}
649impl<'a> Iterator for IterableServer<'a> {
650 type Item = Result<Server<'a>, ErrorContext>;
651 fn next(&mut self) -> Option<Self::Item> {
652 let pos = self.pos;
653 let mut r#type;
654 loop {
655 r#type = None;
656 if self.buf.len() == self.pos {
657 return None;
658 }
659 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
660 break;
661 };
662 r#type = Some(header.r#type);
663 let res = match header.r#type {
664 1u16 => Server::Threads({
665 let res = parse_u32(next);
666 let Some(val) = res else { break };
667 val
668 }),
669 2u16 => Server::Gracetime({
670 let res = parse_u32(next);
671 let Some(val) = res else { break };
672 val
673 }),
674 3u16 => Server::Leasetime({
675 let res = parse_u32(next);
676 let Some(val) = res else { break };
677 val
678 }),
679 4u16 => Server::Scope({
680 let res = CStr::from_bytes_with_nul(next).ok();
681 let Some(val) = res else { break };
682 val
683 }),
684 5u16 => Server::MinThreads({
685 let res = parse_u32(next);
686 let Some(val) = res else { break };
687 val
688 }),
689 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
690 n => continue,
691 };
692 return Some(Ok(res));
693 }
694 Some(Err(ErrorContext::new(
695 "Server",
696 r#type.and_then(|t| Server::attr_from_type(t)),
697 self.orig_loc,
698 self.buf.as_ptr().wrapping_add(pos) as usize,
699 )))
700 }
701}
702impl<'a> std::fmt::Debug for IterableServer<'_> {
703 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
704 let mut fmt = f.debug_struct("Server");
705 for attr in self.clone() {
706 let attr = match attr {
707 Ok(a) => a,
708 Err(err) => {
709 fmt.finish()?;
710 f.write_str("Err(")?;
711 err.fmt(f)?;
712 return f.write_str(")");
713 }
714 };
715 match attr {
716 Server::Threads(val) => fmt.field("Threads", &val),
717 Server::Gracetime(val) => fmt.field("Gracetime", &val),
718 Server::Leasetime(val) => fmt.field("Leasetime", &val),
719 Server::Scope(val) => fmt.field("Scope", &val),
720 Server::MinThreads(val) => fmt.field("MinThreads", &val),
721 };
722 }
723 fmt.finish()
724 }
725}
726impl IterableServer<'_> {
727 pub fn lookup_attr(
728 &self,
729 offset: usize,
730 missing_type: Option<u16>,
731 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
732 let mut stack = Vec::new();
733 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
734 if missing_type.is_some() && cur == offset {
735 stack.push(("Server", offset));
736 return (stack, missing_type.and_then(|t| Server::attr_from_type(t)));
737 }
738 if cur > offset || cur + self.buf.len() < offset {
739 return (stack, None);
740 }
741 let mut attrs = self.clone();
742 let mut last_off = cur + attrs.pos;
743 while let Some(attr) = attrs.next() {
744 let Ok(attr) = attr else { break };
745 match attr {
746 Server::Threads(val) => {
747 if last_off == offset {
748 stack.push(("Threads", last_off));
749 break;
750 }
751 }
752 Server::Gracetime(val) => {
753 if last_off == offset {
754 stack.push(("Gracetime", last_off));
755 break;
756 }
757 }
758 Server::Leasetime(val) => {
759 if last_off == offset {
760 stack.push(("Leasetime", last_off));
761 break;
762 }
763 }
764 Server::Scope(val) => {
765 if last_off == offset {
766 stack.push(("Scope", last_off));
767 break;
768 }
769 }
770 Server::MinThreads(val) => {
771 if last_off == offset {
772 stack.push(("MinThreads", last_off));
773 break;
774 }
775 }
776 _ => {}
777 };
778 last_off = cur + attrs.pos;
779 }
780 if !stack.is_empty() {
781 stack.push(("Server", cur));
782 }
783 (stack, None)
784 }
785}
786#[derive(Clone)]
787pub enum Version {
788 Major(u32),
789 Minor(u32),
790 Enabled(()),
791}
792impl<'a> IterableVersion<'a> {
793 pub fn get_major(&self) -> Result<u32, ErrorContext> {
794 let mut iter = self.clone();
795 iter.pos = 0;
796 for attr in iter {
797 if let Version::Major(val) = attr? {
798 return Ok(val);
799 }
800 }
801 Err(ErrorContext::new_missing(
802 "Version",
803 "Major",
804 self.orig_loc,
805 self.buf.as_ptr() as usize,
806 ))
807 }
808 pub fn get_minor(&self) -> Result<u32, ErrorContext> {
809 let mut iter = self.clone();
810 iter.pos = 0;
811 for attr in iter {
812 if let Version::Minor(val) = attr? {
813 return Ok(val);
814 }
815 }
816 Err(ErrorContext::new_missing(
817 "Version",
818 "Minor",
819 self.orig_loc,
820 self.buf.as_ptr() as usize,
821 ))
822 }
823 pub fn get_enabled(&self) -> Result<(), ErrorContext> {
824 let mut iter = self.clone();
825 iter.pos = 0;
826 for attr in iter {
827 if let Version::Enabled(val) = attr? {
828 return Ok(val);
829 }
830 }
831 Err(ErrorContext::new_missing(
832 "Version",
833 "Enabled",
834 self.orig_loc,
835 self.buf.as_ptr() as usize,
836 ))
837 }
838}
839impl Version {
840 pub fn new<'a>(buf: &'a [u8]) -> IterableVersion<'a> {
841 IterableVersion::with_loc(buf, buf.as_ptr() as usize)
842 }
843 fn attr_from_type(r#type: u16) -> Option<&'static str> {
844 let res = match r#type {
845 1u16 => "Major",
846 2u16 => "Minor",
847 3u16 => "Enabled",
848 _ => return None,
849 };
850 Some(res)
851 }
852}
853#[derive(Clone, Copy, Default)]
854pub struct IterableVersion<'a> {
855 buf: &'a [u8],
856 pos: usize,
857 orig_loc: usize,
858}
859impl<'a> IterableVersion<'a> {
860 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
861 Self {
862 buf,
863 pos: 0,
864 orig_loc,
865 }
866 }
867 pub fn get_buf(&self) -> &'a [u8] {
868 self.buf
869 }
870}
871impl<'a> Iterator for IterableVersion<'a> {
872 type Item = Result<Version, ErrorContext>;
873 fn next(&mut self) -> Option<Self::Item> {
874 let pos = self.pos;
875 let mut r#type;
876 loop {
877 r#type = None;
878 if self.buf.len() == self.pos {
879 return None;
880 }
881 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
882 break;
883 };
884 r#type = Some(header.r#type);
885 let res = match header.r#type {
886 1u16 => Version::Major({
887 let res = parse_u32(next);
888 let Some(val) = res else { break };
889 val
890 }),
891 2u16 => Version::Minor({
892 let res = parse_u32(next);
893 let Some(val) = res else { break };
894 val
895 }),
896 3u16 => Version::Enabled(()),
897 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
898 n => continue,
899 };
900 return Some(Ok(res));
901 }
902 Some(Err(ErrorContext::new(
903 "Version",
904 r#type.and_then(|t| Version::attr_from_type(t)),
905 self.orig_loc,
906 self.buf.as_ptr().wrapping_add(pos) as usize,
907 )))
908 }
909}
910impl std::fmt::Debug for IterableVersion<'_> {
911 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
912 let mut fmt = f.debug_struct("Version");
913 for attr in self.clone() {
914 let attr = match attr {
915 Ok(a) => a,
916 Err(err) => {
917 fmt.finish()?;
918 f.write_str("Err(")?;
919 err.fmt(f)?;
920 return f.write_str(")");
921 }
922 };
923 match attr {
924 Version::Major(val) => fmt.field("Major", &val),
925 Version::Minor(val) => fmt.field("Minor", &val),
926 Version::Enabled(val) => fmt.field("Enabled", &val),
927 };
928 }
929 fmt.finish()
930 }
931}
932impl IterableVersion<'_> {
933 pub fn lookup_attr(
934 &self,
935 offset: usize,
936 missing_type: Option<u16>,
937 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
938 let mut stack = Vec::new();
939 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
940 if missing_type.is_some() && cur == offset {
941 stack.push(("Version", offset));
942 return (stack, missing_type.and_then(|t| Version::attr_from_type(t)));
943 }
944 if cur > offset || cur + self.buf.len() < offset {
945 return (stack, None);
946 }
947 let mut attrs = self.clone();
948 let mut last_off = cur + attrs.pos;
949 while let Some(attr) = attrs.next() {
950 let Ok(attr) = attr else { break };
951 match attr {
952 Version::Major(val) => {
953 if last_off == offset {
954 stack.push(("Major", last_off));
955 break;
956 }
957 }
958 Version::Minor(val) => {
959 if last_off == offset {
960 stack.push(("Minor", last_off));
961 break;
962 }
963 }
964 Version::Enabled(val) => {
965 if last_off == offset {
966 stack.push(("Enabled", last_off));
967 break;
968 }
969 }
970 _ => {}
971 };
972 last_off = cur + attrs.pos;
973 }
974 if !stack.is_empty() {
975 stack.push(("Version", cur));
976 }
977 (stack, None)
978 }
979}
980#[derive(Clone)]
981pub enum ServerProto<'a> {
982 #[doc = "Attribute may repeat multiple times (treat it as array)"]
983 Version(IterableVersion<'a>),
984}
985impl<'a> IterableServerProto<'a> {
986 #[doc = "Attribute may repeat multiple times (treat it as array)"]
987 pub fn get_version(&self) -> MultiAttrIterable<Self, ServerProto<'a>, IterableVersion<'a>> {
988 MultiAttrIterable::new(self.clone(), |variant| {
989 if let ServerProto::Version(val) = variant {
990 Some(val)
991 } else {
992 None
993 }
994 })
995 }
996}
997impl ServerProto<'_> {
998 pub fn new<'a>(buf: &'a [u8]) -> IterableServerProto<'a> {
999 IterableServerProto::with_loc(buf, buf.as_ptr() as usize)
1000 }
1001 fn attr_from_type(r#type: u16) -> Option<&'static str> {
1002 let res = match r#type {
1003 1u16 => "Version",
1004 _ => return None,
1005 };
1006 Some(res)
1007 }
1008}
1009#[derive(Clone, Copy, Default)]
1010pub struct IterableServerProto<'a> {
1011 buf: &'a [u8],
1012 pos: usize,
1013 orig_loc: usize,
1014}
1015impl<'a> IterableServerProto<'a> {
1016 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
1017 Self {
1018 buf,
1019 pos: 0,
1020 orig_loc,
1021 }
1022 }
1023 pub fn get_buf(&self) -> &'a [u8] {
1024 self.buf
1025 }
1026}
1027impl<'a> Iterator for IterableServerProto<'a> {
1028 type Item = Result<ServerProto<'a>, ErrorContext>;
1029 fn next(&mut self) -> Option<Self::Item> {
1030 let pos = self.pos;
1031 let mut r#type;
1032 loop {
1033 r#type = None;
1034 if self.buf.len() == self.pos {
1035 return None;
1036 }
1037 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
1038 break;
1039 };
1040 r#type = Some(header.r#type);
1041 let res = match header.r#type {
1042 1u16 => ServerProto::Version({
1043 let res = Some(IterableVersion::with_loc(next, self.orig_loc));
1044 let Some(val) = res else { break };
1045 val
1046 }),
1047 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
1048 n => continue,
1049 };
1050 return Some(Ok(res));
1051 }
1052 Some(Err(ErrorContext::new(
1053 "ServerProto",
1054 r#type.and_then(|t| ServerProto::attr_from_type(t)),
1055 self.orig_loc,
1056 self.buf.as_ptr().wrapping_add(pos) as usize,
1057 )))
1058 }
1059}
1060impl<'a> std::fmt::Debug for IterableServerProto<'_> {
1061 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1062 let mut fmt = f.debug_struct("ServerProto");
1063 for attr in self.clone() {
1064 let attr = match attr {
1065 Ok(a) => a,
1066 Err(err) => {
1067 fmt.finish()?;
1068 f.write_str("Err(")?;
1069 err.fmt(f)?;
1070 return f.write_str(")");
1071 }
1072 };
1073 match attr {
1074 ServerProto::Version(val) => fmt.field("Version", &val),
1075 };
1076 }
1077 fmt.finish()
1078 }
1079}
1080impl IterableServerProto<'_> {
1081 pub fn lookup_attr(
1082 &self,
1083 offset: usize,
1084 missing_type: Option<u16>,
1085 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
1086 let mut stack = Vec::new();
1087 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
1088 if missing_type.is_some() && cur == offset {
1089 stack.push(("ServerProto", offset));
1090 return (
1091 stack,
1092 missing_type.and_then(|t| ServerProto::attr_from_type(t)),
1093 );
1094 }
1095 if cur > offset || cur + self.buf.len() < offset {
1096 return (stack, None);
1097 }
1098 let mut attrs = self.clone();
1099 let mut last_off = cur + attrs.pos;
1100 let mut missing = None;
1101 while let Some(attr) = attrs.next() {
1102 let Ok(attr) = attr else { break };
1103 match attr {
1104 ServerProto::Version(val) => {
1105 (stack, missing) = val.lookup_attr(offset, missing_type);
1106 if !stack.is_empty() {
1107 break;
1108 }
1109 }
1110 _ => {}
1111 };
1112 last_off = cur + attrs.pos;
1113 }
1114 if !stack.is_empty() {
1115 stack.push(("ServerProto", cur));
1116 }
1117 (stack, missing)
1118 }
1119}
1120#[derive(Clone)]
1121pub enum Sock<'a> {
1122 Addr(&'a [u8]),
1123 TransportName(&'a CStr),
1124}
1125impl<'a> IterableSock<'a> {
1126 pub fn get_addr(&self) -> Result<&'a [u8], ErrorContext> {
1127 let mut iter = self.clone();
1128 iter.pos = 0;
1129 for attr in iter {
1130 if let Sock::Addr(val) = attr? {
1131 return Ok(val);
1132 }
1133 }
1134 Err(ErrorContext::new_missing(
1135 "Sock",
1136 "Addr",
1137 self.orig_loc,
1138 self.buf.as_ptr() as usize,
1139 ))
1140 }
1141 pub fn get_transport_name(&self) -> Result<&'a CStr, ErrorContext> {
1142 let mut iter = self.clone();
1143 iter.pos = 0;
1144 for attr in iter {
1145 if let Sock::TransportName(val) = attr? {
1146 return Ok(val);
1147 }
1148 }
1149 Err(ErrorContext::new_missing(
1150 "Sock",
1151 "TransportName",
1152 self.orig_loc,
1153 self.buf.as_ptr() as usize,
1154 ))
1155 }
1156}
1157impl Sock<'_> {
1158 pub fn new<'a>(buf: &'a [u8]) -> IterableSock<'a> {
1159 IterableSock::with_loc(buf, buf.as_ptr() as usize)
1160 }
1161 fn attr_from_type(r#type: u16) -> Option<&'static str> {
1162 let res = match r#type {
1163 1u16 => "Addr",
1164 2u16 => "TransportName",
1165 _ => return None,
1166 };
1167 Some(res)
1168 }
1169}
1170#[derive(Clone, Copy, Default)]
1171pub struct IterableSock<'a> {
1172 buf: &'a [u8],
1173 pos: usize,
1174 orig_loc: usize,
1175}
1176impl<'a> IterableSock<'a> {
1177 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
1178 Self {
1179 buf,
1180 pos: 0,
1181 orig_loc,
1182 }
1183 }
1184 pub fn get_buf(&self) -> &'a [u8] {
1185 self.buf
1186 }
1187}
1188impl<'a> Iterator for IterableSock<'a> {
1189 type Item = Result<Sock<'a>, ErrorContext>;
1190 fn next(&mut self) -> Option<Self::Item> {
1191 let pos = self.pos;
1192 let mut r#type;
1193 loop {
1194 r#type = None;
1195 if self.buf.len() == self.pos {
1196 return None;
1197 }
1198 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
1199 break;
1200 };
1201 r#type = Some(header.r#type);
1202 let res = match header.r#type {
1203 1u16 => Sock::Addr({
1204 let res = Some(next);
1205 let Some(val) = res else { break };
1206 val
1207 }),
1208 2u16 => Sock::TransportName({
1209 let res = CStr::from_bytes_with_nul(next).ok();
1210 let Some(val) = res else { break };
1211 val
1212 }),
1213 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
1214 n => continue,
1215 };
1216 return Some(Ok(res));
1217 }
1218 Some(Err(ErrorContext::new(
1219 "Sock",
1220 r#type.and_then(|t| Sock::attr_from_type(t)),
1221 self.orig_loc,
1222 self.buf.as_ptr().wrapping_add(pos) as usize,
1223 )))
1224 }
1225}
1226impl<'a> std::fmt::Debug for IterableSock<'_> {
1227 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1228 let mut fmt = f.debug_struct("Sock");
1229 for attr in self.clone() {
1230 let attr = match attr {
1231 Ok(a) => a,
1232 Err(err) => {
1233 fmt.finish()?;
1234 f.write_str("Err(")?;
1235 err.fmt(f)?;
1236 return f.write_str(")");
1237 }
1238 };
1239 match attr {
1240 Sock::Addr(val) => fmt.field("Addr", &val),
1241 Sock::TransportName(val) => fmt.field("TransportName", &val),
1242 };
1243 }
1244 fmt.finish()
1245 }
1246}
1247impl IterableSock<'_> {
1248 pub fn lookup_attr(
1249 &self,
1250 offset: usize,
1251 missing_type: Option<u16>,
1252 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
1253 let mut stack = Vec::new();
1254 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
1255 if missing_type.is_some() && cur == offset {
1256 stack.push(("Sock", offset));
1257 return (stack, missing_type.and_then(|t| Sock::attr_from_type(t)));
1258 }
1259 if cur > offset || cur + self.buf.len() < offset {
1260 return (stack, None);
1261 }
1262 let mut attrs = self.clone();
1263 let mut last_off = cur + attrs.pos;
1264 while let Some(attr) = attrs.next() {
1265 let Ok(attr) = attr else { break };
1266 match attr {
1267 Sock::Addr(val) => {
1268 if last_off == offset {
1269 stack.push(("Addr", last_off));
1270 break;
1271 }
1272 }
1273 Sock::TransportName(val) => {
1274 if last_off == offset {
1275 stack.push(("TransportName", last_off));
1276 break;
1277 }
1278 }
1279 _ => {}
1280 };
1281 last_off = cur + attrs.pos;
1282 }
1283 if !stack.is_empty() {
1284 stack.push(("Sock", cur));
1285 }
1286 (stack, None)
1287 }
1288}
1289#[derive(Clone)]
1290pub enum ServerSock<'a> {
1291 #[doc = "Attribute may repeat multiple times (treat it as array)"]
1292 Addr(IterableSock<'a>),
1293}
1294impl<'a> IterableServerSock<'a> {
1295 #[doc = "Attribute may repeat multiple times (treat it as array)"]
1296 pub fn get_addr(&self) -> MultiAttrIterable<Self, ServerSock<'a>, IterableSock<'a>> {
1297 MultiAttrIterable::new(self.clone(), |variant| {
1298 if let ServerSock::Addr(val) = variant {
1299 Some(val)
1300 } else {
1301 None
1302 }
1303 })
1304 }
1305}
1306impl ServerSock<'_> {
1307 pub fn new<'a>(buf: &'a [u8]) -> IterableServerSock<'a> {
1308 IterableServerSock::with_loc(buf, buf.as_ptr() as usize)
1309 }
1310 fn attr_from_type(r#type: u16) -> Option<&'static str> {
1311 let res = match r#type {
1312 1u16 => "Addr",
1313 _ => return None,
1314 };
1315 Some(res)
1316 }
1317}
1318#[derive(Clone, Copy, Default)]
1319pub struct IterableServerSock<'a> {
1320 buf: &'a [u8],
1321 pos: usize,
1322 orig_loc: usize,
1323}
1324impl<'a> IterableServerSock<'a> {
1325 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
1326 Self {
1327 buf,
1328 pos: 0,
1329 orig_loc,
1330 }
1331 }
1332 pub fn get_buf(&self) -> &'a [u8] {
1333 self.buf
1334 }
1335}
1336impl<'a> Iterator for IterableServerSock<'a> {
1337 type Item = Result<ServerSock<'a>, ErrorContext>;
1338 fn next(&mut self) -> Option<Self::Item> {
1339 let pos = self.pos;
1340 let mut r#type;
1341 loop {
1342 r#type = None;
1343 if self.buf.len() == self.pos {
1344 return None;
1345 }
1346 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
1347 break;
1348 };
1349 r#type = Some(header.r#type);
1350 let res = match header.r#type {
1351 1u16 => ServerSock::Addr({
1352 let res = Some(IterableSock::with_loc(next, self.orig_loc));
1353 let Some(val) = res else { break };
1354 val
1355 }),
1356 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
1357 n => continue,
1358 };
1359 return Some(Ok(res));
1360 }
1361 Some(Err(ErrorContext::new(
1362 "ServerSock",
1363 r#type.and_then(|t| ServerSock::attr_from_type(t)),
1364 self.orig_loc,
1365 self.buf.as_ptr().wrapping_add(pos) as usize,
1366 )))
1367 }
1368}
1369impl<'a> std::fmt::Debug for IterableServerSock<'_> {
1370 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1371 let mut fmt = f.debug_struct("ServerSock");
1372 for attr in self.clone() {
1373 let attr = match attr {
1374 Ok(a) => a,
1375 Err(err) => {
1376 fmt.finish()?;
1377 f.write_str("Err(")?;
1378 err.fmt(f)?;
1379 return f.write_str(")");
1380 }
1381 };
1382 match attr {
1383 ServerSock::Addr(val) => fmt.field("Addr", &val),
1384 };
1385 }
1386 fmt.finish()
1387 }
1388}
1389impl IterableServerSock<'_> {
1390 pub fn lookup_attr(
1391 &self,
1392 offset: usize,
1393 missing_type: Option<u16>,
1394 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
1395 let mut stack = Vec::new();
1396 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
1397 if missing_type.is_some() && cur == offset {
1398 stack.push(("ServerSock", offset));
1399 return (
1400 stack,
1401 missing_type.and_then(|t| ServerSock::attr_from_type(t)),
1402 );
1403 }
1404 if cur > offset || cur + self.buf.len() < offset {
1405 return (stack, None);
1406 }
1407 let mut attrs = self.clone();
1408 let mut last_off = cur + attrs.pos;
1409 let mut missing = None;
1410 while let Some(attr) = attrs.next() {
1411 let Ok(attr) = attr else { break };
1412 match attr {
1413 ServerSock::Addr(val) => {
1414 (stack, missing) = val.lookup_attr(offset, missing_type);
1415 if !stack.is_empty() {
1416 break;
1417 }
1418 }
1419 _ => {}
1420 };
1421 last_off = cur + attrs.pos;
1422 }
1423 if !stack.is_empty() {
1424 stack.push(("ServerSock", cur));
1425 }
1426 (stack, missing)
1427 }
1428}
1429#[derive(Clone)]
1430pub enum PoolMode<'a> {
1431 Mode(&'a CStr),
1432 Npools(u32),
1433}
1434impl<'a> IterablePoolMode<'a> {
1435 pub fn get_mode(&self) -> Result<&'a CStr, ErrorContext> {
1436 let mut iter = self.clone();
1437 iter.pos = 0;
1438 for attr in iter {
1439 if let PoolMode::Mode(val) = attr? {
1440 return Ok(val);
1441 }
1442 }
1443 Err(ErrorContext::new_missing(
1444 "PoolMode",
1445 "Mode",
1446 self.orig_loc,
1447 self.buf.as_ptr() as usize,
1448 ))
1449 }
1450 pub fn get_npools(&self) -> Result<u32, ErrorContext> {
1451 let mut iter = self.clone();
1452 iter.pos = 0;
1453 for attr in iter {
1454 if let PoolMode::Npools(val) = attr? {
1455 return Ok(val);
1456 }
1457 }
1458 Err(ErrorContext::new_missing(
1459 "PoolMode",
1460 "Npools",
1461 self.orig_loc,
1462 self.buf.as_ptr() as usize,
1463 ))
1464 }
1465}
1466impl PoolMode<'_> {
1467 pub fn new<'a>(buf: &'a [u8]) -> IterablePoolMode<'a> {
1468 IterablePoolMode::with_loc(buf, buf.as_ptr() as usize)
1469 }
1470 fn attr_from_type(r#type: u16) -> Option<&'static str> {
1471 let res = match r#type {
1472 1u16 => "Mode",
1473 2u16 => "Npools",
1474 _ => return None,
1475 };
1476 Some(res)
1477 }
1478}
1479#[derive(Clone, Copy, Default)]
1480pub struct IterablePoolMode<'a> {
1481 buf: &'a [u8],
1482 pos: usize,
1483 orig_loc: usize,
1484}
1485impl<'a> IterablePoolMode<'a> {
1486 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
1487 Self {
1488 buf,
1489 pos: 0,
1490 orig_loc,
1491 }
1492 }
1493 pub fn get_buf(&self) -> &'a [u8] {
1494 self.buf
1495 }
1496}
1497impl<'a> Iterator for IterablePoolMode<'a> {
1498 type Item = Result<PoolMode<'a>, ErrorContext>;
1499 fn next(&mut self) -> Option<Self::Item> {
1500 let pos = self.pos;
1501 let mut r#type;
1502 loop {
1503 r#type = None;
1504 if self.buf.len() == self.pos {
1505 return None;
1506 }
1507 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
1508 break;
1509 };
1510 r#type = Some(header.r#type);
1511 let res = match header.r#type {
1512 1u16 => PoolMode::Mode({
1513 let res = CStr::from_bytes_with_nul(next).ok();
1514 let Some(val) = res else { break };
1515 val
1516 }),
1517 2u16 => PoolMode::Npools({
1518 let res = parse_u32(next);
1519 let Some(val) = res else { break };
1520 val
1521 }),
1522 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
1523 n => continue,
1524 };
1525 return Some(Ok(res));
1526 }
1527 Some(Err(ErrorContext::new(
1528 "PoolMode",
1529 r#type.and_then(|t| PoolMode::attr_from_type(t)),
1530 self.orig_loc,
1531 self.buf.as_ptr().wrapping_add(pos) as usize,
1532 )))
1533 }
1534}
1535impl<'a> std::fmt::Debug for IterablePoolMode<'_> {
1536 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1537 let mut fmt = f.debug_struct("PoolMode");
1538 for attr in self.clone() {
1539 let attr = match attr {
1540 Ok(a) => a,
1541 Err(err) => {
1542 fmt.finish()?;
1543 f.write_str("Err(")?;
1544 err.fmt(f)?;
1545 return f.write_str(")");
1546 }
1547 };
1548 match attr {
1549 PoolMode::Mode(val) => fmt.field("Mode", &val),
1550 PoolMode::Npools(val) => fmt.field("Npools", &val),
1551 };
1552 }
1553 fmt.finish()
1554 }
1555}
1556impl IterablePoolMode<'_> {
1557 pub fn lookup_attr(
1558 &self,
1559 offset: usize,
1560 missing_type: Option<u16>,
1561 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
1562 let mut stack = Vec::new();
1563 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
1564 if missing_type.is_some() && cur == offset {
1565 stack.push(("PoolMode", offset));
1566 return (
1567 stack,
1568 missing_type.and_then(|t| PoolMode::attr_from_type(t)),
1569 );
1570 }
1571 if cur > offset || cur + self.buf.len() < offset {
1572 return (stack, None);
1573 }
1574 let mut attrs = self.clone();
1575 let mut last_off = cur + attrs.pos;
1576 while let Some(attr) = attrs.next() {
1577 let Ok(attr) = attr else { break };
1578 match attr {
1579 PoolMode::Mode(val) => {
1580 if last_off == offset {
1581 stack.push(("Mode", last_off));
1582 break;
1583 }
1584 }
1585 PoolMode::Npools(val) => {
1586 if last_off == offset {
1587 stack.push(("Npools", last_off));
1588 break;
1589 }
1590 }
1591 _ => {}
1592 };
1593 last_off = cur + attrs.pos;
1594 }
1595 if !stack.is_empty() {
1596 stack.push(("PoolMode", cur));
1597 }
1598 (stack, None)
1599 }
1600}
1601pub struct PushRpcStatus<Prev: Rec> {
1602 pub(crate) prev: Option<Prev>,
1603 pub(crate) header_offset: Option<usize>,
1604}
1605impl<Prev: Rec> Rec for PushRpcStatus<Prev> {
1606 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
1607 self.prev.as_mut().unwrap().as_rec_mut()
1608 }
1609 fn as_rec(&self) -> &Vec<u8> {
1610 self.prev.as_ref().unwrap().as_rec()
1611 }
1612}
1613impl<Prev: Rec> PushRpcStatus<Prev> {
1614 pub fn new(prev: Prev) -> Self {
1615 Self {
1616 prev: Some(prev),
1617 header_offset: None,
1618 }
1619 }
1620 pub fn end_nested(mut self) -> Prev {
1621 let mut prev = self.prev.take().unwrap();
1622 if let Some(header_offset) = &self.header_offset {
1623 finalize_nested_header(prev.as_rec_mut(), *header_offset);
1624 }
1625 prev
1626 }
1627 pub fn push_xid(mut self, value: u32) -> Self {
1628 push_header(self.as_rec_mut(), 1u16, 4 as u16);
1629 self.as_rec_mut().extend(value.to_be_bytes());
1630 self
1631 }
1632 pub fn push_flags(mut self, value: u32) -> Self {
1633 push_header(self.as_rec_mut(), 2u16, 4 as u16);
1634 self.as_rec_mut().extend(value.to_ne_bytes());
1635 self
1636 }
1637 pub fn push_prog(mut self, value: u32) -> Self {
1638 push_header(self.as_rec_mut(), 3u16, 4 as u16);
1639 self.as_rec_mut().extend(value.to_ne_bytes());
1640 self
1641 }
1642 pub fn push_version(mut self, value: u8) -> Self {
1643 push_header(self.as_rec_mut(), 4u16, 1 as u16);
1644 self.as_rec_mut().extend(value.to_ne_bytes());
1645 self
1646 }
1647 pub fn push_proc(mut self, value: u32) -> Self {
1648 push_header(self.as_rec_mut(), 5u16, 4 as u16);
1649 self.as_rec_mut().extend(value.to_ne_bytes());
1650 self
1651 }
1652 pub fn push_service_time(mut self, value: i64) -> Self {
1653 push_header(self.as_rec_mut(), 6u16, 8 as u16);
1654 self.as_rec_mut().extend(value.to_ne_bytes());
1655 self
1656 }
1657 pub fn push_pad(mut self, value: &[u8]) -> Self {
1658 push_header(self.as_rec_mut(), 7u16, value.len() as u16);
1659 self.as_rec_mut().extend(value);
1660 self
1661 }
1662 pub fn push_saddr4(mut self, value: std::net::Ipv4Addr) -> Self {
1663 push_header(self.as_rec_mut(), 8u16, 4 as u16);
1664 self.as_rec_mut().extend(&value.to_bits().to_be_bytes());
1665 self
1666 }
1667 pub fn push_daddr4(mut self, value: std::net::Ipv4Addr) -> Self {
1668 push_header(self.as_rec_mut(), 9u16, 4 as u16);
1669 self.as_rec_mut().extend(&value.to_bits().to_be_bytes());
1670 self
1671 }
1672 pub fn push_saddr6(mut self, value: &[u8]) -> Self {
1673 push_header(self.as_rec_mut(), 10u16, value.len() as u16);
1674 self.as_rec_mut().extend(value);
1675 self
1676 }
1677 pub fn push_daddr6(mut self, value: &[u8]) -> Self {
1678 push_header(self.as_rec_mut(), 11u16, value.len() as u16);
1679 self.as_rec_mut().extend(value);
1680 self
1681 }
1682 pub fn push_sport(mut self, value: u16) -> Self {
1683 push_header(self.as_rec_mut(), 12u16, 2 as u16);
1684 self.as_rec_mut().extend(value.to_be_bytes());
1685 self
1686 }
1687 pub fn push_dport(mut self, value: u16) -> Self {
1688 push_header(self.as_rec_mut(), 13u16, 2 as u16);
1689 self.as_rec_mut().extend(value.to_be_bytes());
1690 self
1691 }
1692 #[doc = "Attribute may repeat multiple times (treat it as array)"]
1693 pub fn push_compound_ops(mut self, value: u32) -> Self {
1694 push_header(self.as_rec_mut(), 14u16, 4 as u16);
1695 self.as_rec_mut().extend(value.to_ne_bytes());
1696 self
1697 }
1698}
1699impl<Prev: Rec> Drop for PushRpcStatus<Prev> {
1700 fn drop(&mut self) {
1701 if let Some(prev) = &mut self.prev {
1702 if let Some(header_offset) = &self.header_offset {
1703 finalize_nested_header(prev.as_rec_mut(), *header_offset);
1704 }
1705 }
1706 }
1707}
1708pub struct PushServer<Prev: Rec> {
1709 pub(crate) prev: Option<Prev>,
1710 pub(crate) header_offset: Option<usize>,
1711}
1712impl<Prev: Rec> Rec for PushServer<Prev> {
1713 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
1714 self.prev.as_mut().unwrap().as_rec_mut()
1715 }
1716 fn as_rec(&self) -> &Vec<u8> {
1717 self.prev.as_ref().unwrap().as_rec()
1718 }
1719}
1720impl<Prev: Rec> PushServer<Prev> {
1721 pub fn new(prev: Prev) -> Self {
1722 Self {
1723 prev: Some(prev),
1724 header_offset: None,
1725 }
1726 }
1727 pub fn end_nested(mut self) -> Prev {
1728 let mut prev = self.prev.take().unwrap();
1729 if let Some(header_offset) = &self.header_offset {
1730 finalize_nested_header(prev.as_rec_mut(), *header_offset);
1731 }
1732 prev
1733 }
1734 #[doc = "Attribute may repeat multiple times (treat it as array)"]
1735 pub fn push_threads(mut self, value: u32) -> Self {
1736 push_header(self.as_rec_mut(), 1u16, 4 as u16);
1737 self.as_rec_mut().extend(value.to_ne_bytes());
1738 self
1739 }
1740 pub fn push_gracetime(mut self, value: u32) -> Self {
1741 push_header(self.as_rec_mut(), 2u16, 4 as u16);
1742 self.as_rec_mut().extend(value.to_ne_bytes());
1743 self
1744 }
1745 pub fn push_leasetime(mut self, value: u32) -> Self {
1746 push_header(self.as_rec_mut(), 3u16, 4 as u16);
1747 self.as_rec_mut().extend(value.to_ne_bytes());
1748 self
1749 }
1750 pub fn push_scope(mut self, value: &CStr) -> Self {
1751 push_header(
1752 self.as_rec_mut(),
1753 4u16,
1754 value.to_bytes_with_nul().len() as u16,
1755 );
1756 self.as_rec_mut().extend(value.to_bytes_with_nul());
1757 self
1758 }
1759 pub fn push_scope_bytes(mut self, value: &[u8]) -> Self {
1760 push_header(self.as_rec_mut(), 4u16, (value.len() + 1) as u16);
1761 self.as_rec_mut().extend(value);
1762 self.as_rec_mut().push(0);
1763 self
1764 }
1765 pub fn push_min_threads(mut self, value: u32) -> Self {
1766 push_header(self.as_rec_mut(), 5u16, 4 as u16);
1767 self.as_rec_mut().extend(value.to_ne_bytes());
1768 self
1769 }
1770}
1771impl<Prev: Rec> Drop for PushServer<Prev> {
1772 fn drop(&mut self) {
1773 if let Some(prev) = &mut self.prev {
1774 if let Some(header_offset) = &self.header_offset {
1775 finalize_nested_header(prev.as_rec_mut(), *header_offset);
1776 }
1777 }
1778 }
1779}
1780pub struct PushVersion<Prev: Rec> {
1781 pub(crate) prev: Option<Prev>,
1782 pub(crate) header_offset: Option<usize>,
1783}
1784impl<Prev: Rec> Rec for PushVersion<Prev> {
1785 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
1786 self.prev.as_mut().unwrap().as_rec_mut()
1787 }
1788 fn as_rec(&self) -> &Vec<u8> {
1789 self.prev.as_ref().unwrap().as_rec()
1790 }
1791}
1792impl<Prev: Rec> PushVersion<Prev> {
1793 pub fn new(prev: Prev) -> Self {
1794 Self {
1795 prev: Some(prev),
1796 header_offset: None,
1797 }
1798 }
1799 pub fn end_nested(mut self) -> Prev {
1800 let mut prev = self.prev.take().unwrap();
1801 if let Some(header_offset) = &self.header_offset {
1802 finalize_nested_header(prev.as_rec_mut(), *header_offset);
1803 }
1804 prev
1805 }
1806 pub fn push_major(mut self, value: u32) -> Self {
1807 push_header(self.as_rec_mut(), 1u16, 4 as u16);
1808 self.as_rec_mut().extend(value.to_ne_bytes());
1809 self
1810 }
1811 pub fn push_minor(mut self, value: u32) -> Self {
1812 push_header(self.as_rec_mut(), 2u16, 4 as u16);
1813 self.as_rec_mut().extend(value.to_ne_bytes());
1814 self
1815 }
1816 pub fn push_enabled(mut self, value: ()) -> Self {
1817 push_header(self.as_rec_mut(), 3u16, 0 as u16);
1818 self
1819 }
1820}
1821impl<Prev: Rec> Drop for PushVersion<Prev> {
1822 fn drop(&mut self) {
1823 if let Some(prev) = &mut self.prev {
1824 if let Some(header_offset) = &self.header_offset {
1825 finalize_nested_header(prev.as_rec_mut(), *header_offset);
1826 }
1827 }
1828 }
1829}
1830pub struct PushServerProto<Prev: Rec> {
1831 pub(crate) prev: Option<Prev>,
1832 pub(crate) header_offset: Option<usize>,
1833}
1834impl<Prev: Rec> Rec for PushServerProto<Prev> {
1835 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
1836 self.prev.as_mut().unwrap().as_rec_mut()
1837 }
1838 fn as_rec(&self) -> &Vec<u8> {
1839 self.prev.as_ref().unwrap().as_rec()
1840 }
1841}
1842impl<Prev: Rec> PushServerProto<Prev> {
1843 pub fn new(prev: Prev) -> Self {
1844 Self {
1845 prev: Some(prev),
1846 header_offset: None,
1847 }
1848 }
1849 pub fn end_nested(mut self) -> Prev {
1850 let mut prev = self.prev.take().unwrap();
1851 if let Some(header_offset) = &self.header_offset {
1852 finalize_nested_header(prev.as_rec_mut(), *header_offset);
1853 }
1854 prev
1855 }
1856 #[doc = "Attribute may repeat multiple times (treat it as array)"]
1857 pub fn nested_version(mut self) -> PushVersion<Self> {
1858 let header_offset = push_nested_header(self.as_rec_mut(), 1u16);
1859 PushVersion {
1860 prev: Some(self),
1861 header_offset: Some(header_offset),
1862 }
1863 }
1864}
1865impl<Prev: Rec> Drop for PushServerProto<Prev> {
1866 fn drop(&mut self) {
1867 if let Some(prev) = &mut self.prev {
1868 if let Some(header_offset) = &self.header_offset {
1869 finalize_nested_header(prev.as_rec_mut(), *header_offset);
1870 }
1871 }
1872 }
1873}
1874pub struct PushSock<Prev: Rec> {
1875 pub(crate) prev: Option<Prev>,
1876 pub(crate) header_offset: Option<usize>,
1877}
1878impl<Prev: Rec> Rec for PushSock<Prev> {
1879 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
1880 self.prev.as_mut().unwrap().as_rec_mut()
1881 }
1882 fn as_rec(&self) -> &Vec<u8> {
1883 self.prev.as_ref().unwrap().as_rec()
1884 }
1885}
1886impl<Prev: Rec> PushSock<Prev> {
1887 pub fn new(prev: Prev) -> Self {
1888 Self {
1889 prev: Some(prev),
1890 header_offset: None,
1891 }
1892 }
1893 pub fn end_nested(mut self) -> Prev {
1894 let mut prev = self.prev.take().unwrap();
1895 if let Some(header_offset) = &self.header_offset {
1896 finalize_nested_header(prev.as_rec_mut(), *header_offset);
1897 }
1898 prev
1899 }
1900 pub fn push_addr(mut self, value: &[u8]) -> Self {
1901 push_header(self.as_rec_mut(), 1u16, value.len() as u16);
1902 self.as_rec_mut().extend(value);
1903 self
1904 }
1905 pub fn push_transport_name(mut self, value: &CStr) -> Self {
1906 push_header(
1907 self.as_rec_mut(),
1908 2u16,
1909 value.to_bytes_with_nul().len() as u16,
1910 );
1911 self.as_rec_mut().extend(value.to_bytes_with_nul());
1912 self
1913 }
1914 pub fn push_transport_name_bytes(mut self, value: &[u8]) -> Self {
1915 push_header(self.as_rec_mut(), 2u16, (value.len() + 1) as u16);
1916 self.as_rec_mut().extend(value);
1917 self.as_rec_mut().push(0);
1918 self
1919 }
1920}
1921impl<Prev: Rec> Drop for PushSock<Prev> {
1922 fn drop(&mut self) {
1923 if let Some(prev) = &mut self.prev {
1924 if let Some(header_offset) = &self.header_offset {
1925 finalize_nested_header(prev.as_rec_mut(), *header_offset);
1926 }
1927 }
1928 }
1929}
1930pub struct PushServerSock<Prev: Rec> {
1931 pub(crate) prev: Option<Prev>,
1932 pub(crate) header_offset: Option<usize>,
1933}
1934impl<Prev: Rec> Rec for PushServerSock<Prev> {
1935 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
1936 self.prev.as_mut().unwrap().as_rec_mut()
1937 }
1938 fn as_rec(&self) -> &Vec<u8> {
1939 self.prev.as_ref().unwrap().as_rec()
1940 }
1941}
1942impl<Prev: Rec> PushServerSock<Prev> {
1943 pub fn new(prev: Prev) -> Self {
1944 Self {
1945 prev: Some(prev),
1946 header_offset: None,
1947 }
1948 }
1949 pub fn end_nested(mut self) -> Prev {
1950 let mut prev = self.prev.take().unwrap();
1951 if let Some(header_offset) = &self.header_offset {
1952 finalize_nested_header(prev.as_rec_mut(), *header_offset);
1953 }
1954 prev
1955 }
1956 #[doc = "Attribute may repeat multiple times (treat it as array)"]
1957 pub fn nested_addr(mut self) -> PushSock<Self> {
1958 let header_offset = push_nested_header(self.as_rec_mut(), 1u16);
1959 PushSock {
1960 prev: Some(self),
1961 header_offset: Some(header_offset),
1962 }
1963 }
1964}
1965impl<Prev: Rec> Drop for PushServerSock<Prev> {
1966 fn drop(&mut self) {
1967 if let Some(prev) = &mut self.prev {
1968 if let Some(header_offset) = &self.header_offset {
1969 finalize_nested_header(prev.as_rec_mut(), *header_offset);
1970 }
1971 }
1972 }
1973}
1974pub struct PushPoolMode<Prev: Rec> {
1975 pub(crate) prev: Option<Prev>,
1976 pub(crate) header_offset: Option<usize>,
1977}
1978impl<Prev: Rec> Rec for PushPoolMode<Prev> {
1979 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
1980 self.prev.as_mut().unwrap().as_rec_mut()
1981 }
1982 fn as_rec(&self) -> &Vec<u8> {
1983 self.prev.as_ref().unwrap().as_rec()
1984 }
1985}
1986impl<Prev: Rec> PushPoolMode<Prev> {
1987 pub fn new(prev: Prev) -> Self {
1988 Self {
1989 prev: Some(prev),
1990 header_offset: None,
1991 }
1992 }
1993 pub fn end_nested(mut self) -> Prev {
1994 let mut prev = self.prev.take().unwrap();
1995 if let Some(header_offset) = &self.header_offset {
1996 finalize_nested_header(prev.as_rec_mut(), *header_offset);
1997 }
1998 prev
1999 }
2000 pub fn push_mode(mut self, value: &CStr) -> Self {
2001 push_header(
2002 self.as_rec_mut(),
2003 1u16,
2004 value.to_bytes_with_nul().len() as u16,
2005 );
2006 self.as_rec_mut().extend(value.to_bytes_with_nul());
2007 self
2008 }
2009 pub fn push_mode_bytes(mut self, value: &[u8]) -> Self {
2010 push_header(self.as_rec_mut(), 1u16, (value.len() + 1) as u16);
2011 self.as_rec_mut().extend(value);
2012 self.as_rec_mut().push(0);
2013 self
2014 }
2015 pub fn push_npools(mut self, value: u32) -> Self {
2016 push_header(self.as_rec_mut(), 2u16, 4 as u16);
2017 self.as_rec_mut().extend(value.to_ne_bytes());
2018 self
2019 }
2020}
2021impl<Prev: Rec> Drop for PushPoolMode<Prev> {
2022 fn drop(&mut self) {
2023 if let Some(prev) = &mut self.prev {
2024 if let Some(header_offset) = &self.header_offset {
2025 finalize_nested_header(prev.as_rec_mut(), *header_offset);
2026 }
2027 }
2028 }
2029}
2030#[doc = "dump pending nfsd rpc\n\nReply attributes:\n- [.get_xid()](IterableRpcStatus::get_xid)\n- [.get_flags()](IterableRpcStatus::get_flags)\n- [.get_prog()](IterableRpcStatus::get_prog)\n- [.get_version()](IterableRpcStatus::get_version)\n- [.get_proc()](IterableRpcStatus::get_proc)\n- [.get_service_time()](IterableRpcStatus::get_service_time)\n- [.get_saddr4()](IterableRpcStatus::get_saddr4)\n- [.get_daddr4()](IterableRpcStatus::get_daddr4)\n- [.get_saddr6()](IterableRpcStatus::get_saddr6)\n- [.get_daddr6()](IterableRpcStatus::get_daddr6)\n- [.get_sport()](IterableRpcStatus::get_sport)\n- [.get_dport()](IterableRpcStatus::get_dport)\n- [.get_compound_ops()](IterableRpcStatus::get_compound_ops)\n"]
2031#[derive(Debug)]
2032pub struct OpRpcStatusGetDump<'r> {
2033 request: Request<'r>,
2034}
2035impl<'r> OpRpcStatusGetDump<'r> {
2036 pub fn new(mut request: Request<'r>) -> Self {
2037 Self::write_header(request.buf_mut());
2038 Self {
2039 request: request.set_dump(),
2040 }
2041 }
2042 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushRpcStatus<&'buf mut Vec<u8>> {
2043 Self::write_header(buf);
2044 PushRpcStatus::new(buf)
2045 }
2046 pub fn encode(&mut self) -> PushRpcStatus<&mut Vec<u8>> {
2047 PushRpcStatus::new(self.request.buf_mut())
2048 }
2049 pub fn into_encoder(self) -> PushRpcStatus<RequestBuf<'r>> {
2050 PushRpcStatus::new(self.request.buf)
2051 }
2052 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableRpcStatus<'a> {
2053 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
2054 IterableRpcStatus::with_loc(attrs, buf.as_ptr() as usize)
2055 }
2056 fn write_header<Prev: Rec>(prev: &mut Prev) {
2057 let mut header = BuiltinNfgenmsg::new();
2058 header.cmd = 1u8;
2059 header.version = 1u8;
2060 prev.as_rec_mut().extend(header.as_slice());
2061 }
2062}
2063impl NetlinkRequest for OpRpcStatusGetDump<'_> {
2064 fn protocol(&self) -> Protocol {
2065 Protocol::Generic("nfsd".as_bytes())
2066 }
2067 fn flags(&self) -> u16 {
2068 self.request.flags
2069 }
2070 fn payload(&self) -> &[u8] {
2071 self.request.buf()
2072 }
2073 type ReplyType<'buf> = IterableRpcStatus<'buf>;
2074 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
2075 Self::decode_request(buf)
2076 }
2077 fn lookup(
2078 buf: &[u8],
2079 offset: usize,
2080 missing_type: Option<u16>,
2081 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
2082 Self::decode_request(buf).lookup_attr(offset, missing_type)
2083 }
2084}
2085#[doc = "set the maximum number of running threads\nFlags: admin-perm\nRequest attributes:\n- [.push_threads()](PushServer::push_threads)\n- [.push_gracetime()](PushServer::push_gracetime)\n- [.push_leasetime()](PushServer::push_leasetime)\n- [.push_scope()](PushServer::push_scope)\n- [.push_min_threads()](PushServer::push_min_threads)\n"]
2086#[derive(Debug)]
2087pub struct OpThreadsSetDo<'r> {
2088 request: Request<'r>,
2089}
2090impl<'r> OpThreadsSetDo<'r> {
2091 pub fn new(mut request: Request<'r>) -> Self {
2092 Self::write_header(request.buf_mut());
2093 Self { request: request }
2094 }
2095 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushServer<&'buf mut Vec<u8>> {
2096 Self::write_header(buf);
2097 PushServer::new(buf)
2098 }
2099 pub fn encode(&mut self) -> PushServer<&mut Vec<u8>> {
2100 PushServer::new(self.request.buf_mut())
2101 }
2102 pub fn into_encoder(self) -> PushServer<RequestBuf<'r>> {
2103 PushServer::new(self.request.buf)
2104 }
2105 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableServer<'a> {
2106 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
2107 IterableServer::with_loc(attrs, buf.as_ptr() as usize)
2108 }
2109 fn write_header<Prev: Rec>(prev: &mut Prev) {
2110 let mut header = BuiltinNfgenmsg::new();
2111 header.cmd = 2u8;
2112 header.version = 1u8;
2113 prev.as_rec_mut().extend(header.as_slice());
2114 }
2115}
2116impl NetlinkRequest for OpThreadsSetDo<'_> {
2117 fn protocol(&self) -> Protocol {
2118 Protocol::Generic("nfsd".as_bytes())
2119 }
2120 fn flags(&self) -> u16 {
2121 self.request.flags
2122 }
2123 fn payload(&self) -> &[u8] {
2124 self.request.buf()
2125 }
2126 type ReplyType<'buf> = IterableServer<'buf>;
2127 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
2128 Self::decode_request(buf)
2129 }
2130 fn lookup(
2131 buf: &[u8],
2132 offset: usize,
2133 missing_type: Option<u16>,
2134 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
2135 Self::decode_request(buf).lookup_attr(offset, missing_type)
2136 }
2137}
2138#[doc = "get the maximum number of running threads\n\nReply attributes:\n- [.get_threads()](IterableServer::get_threads)\n- [.get_gracetime()](IterableServer::get_gracetime)\n- [.get_leasetime()](IterableServer::get_leasetime)\n- [.get_scope()](IterableServer::get_scope)\n- [.get_min_threads()](IterableServer::get_min_threads)\n"]
2139#[derive(Debug)]
2140pub struct OpThreadsGetDo<'r> {
2141 request: Request<'r>,
2142}
2143impl<'r> OpThreadsGetDo<'r> {
2144 pub fn new(mut request: Request<'r>) -> Self {
2145 Self::write_header(request.buf_mut());
2146 Self { request: request }
2147 }
2148 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushServer<&'buf mut Vec<u8>> {
2149 Self::write_header(buf);
2150 PushServer::new(buf)
2151 }
2152 pub fn encode(&mut self) -> PushServer<&mut Vec<u8>> {
2153 PushServer::new(self.request.buf_mut())
2154 }
2155 pub fn into_encoder(self) -> PushServer<RequestBuf<'r>> {
2156 PushServer::new(self.request.buf)
2157 }
2158 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableServer<'a> {
2159 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
2160 IterableServer::with_loc(attrs, buf.as_ptr() as usize)
2161 }
2162 fn write_header<Prev: Rec>(prev: &mut Prev) {
2163 let mut header = BuiltinNfgenmsg::new();
2164 header.cmd = 3u8;
2165 header.version = 1u8;
2166 prev.as_rec_mut().extend(header.as_slice());
2167 }
2168}
2169impl NetlinkRequest for OpThreadsGetDo<'_> {
2170 fn protocol(&self) -> Protocol {
2171 Protocol::Generic("nfsd".as_bytes())
2172 }
2173 fn flags(&self) -> u16 {
2174 self.request.flags
2175 }
2176 fn payload(&self) -> &[u8] {
2177 self.request.buf()
2178 }
2179 type ReplyType<'buf> = IterableServer<'buf>;
2180 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
2181 Self::decode_request(buf)
2182 }
2183 fn lookup(
2184 buf: &[u8],
2185 offset: usize,
2186 missing_type: Option<u16>,
2187 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
2188 Self::decode_request(buf).lookup_attr(offset, missing_type)
2189 }
2190}
2191#[doc = "set nfs enabled versions\nFlags: admin-perm\nRequest attributes:\n- [.nested_version()](PushServerProto::nested_version)\n"]
2192#[derive(Debug)]
2193pub struct OpVersionSetDo<'r> {
2194 request: Request<'r>,
2195}
2196impl<'r> OpVersionSetDo<'r> {
2197 pub fn new(mut request: Request<'r>) -> Self {
2198 Self::write_header(request.buf_mut());
2199 Self { request: request }
2200 }
2201 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushServerProto<&'buf mut Vec<u8>> {
2202 Self::write_header(buf);
2203 PushServerProto::new(buf)
2204 }
2205 pub fn encode(&mut self) -> PushServerProto<&mut Vec<u8>> {
2206 PushServerProto::new(self.request.buf_mut())
2207 }
2208 pub fn into_encoder(self) -> PushServerProto<RequestBuf<'r>> {
2209 PushServerProto::new(self.request.buf)
2210 }
2211 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableServerProto<'a> {
2212 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
2213 IterableServerProto::with_loc(attrs, buf.as_ptr() as usize)
2214 }
2215 fn write_header<Prev: Rec>(prev: &mut Prev) {
2216 let mut header = BuiltinNfgenmsg::new();
2217 header.cmd = 4u8;
2218 header.version = 1u8;
2219 prev.as_rec_mut().extend(header.as_slice());
2220 }
2221}
2222impl NetlinkRequest for OpVersionSetDo<'_> {
2223 fn protocol(&self) -> Protocol {
2224 Protocol::Generic("nfsd".as_bytes())
2225 }
2226 fn flags(&self) -> u16 {
2227 self.request.flags
2228 }
2229 fn payload(&self) -> &[u8] {
2230 self.request.buf()
2231 }
2232 type ReplyType<'buf> = IterableServerProto<'buf>;
2233 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
2234 Self::decode_request(buf)
2235 }
2236 fn lookup(
2237 buf: &[u8],
2238 offset: usize,
2239 missing_type: Option<u16>,
2240 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
2241 Self::decode_request(buf).lookup_attr(offset, missing_type)
2242 }
2243}
2244#[doc = "get nfs enabled versions\n\nReply attributes:\n- [.get_version()](IterableServerProto::get_version)\n"]
2245#[derive(Debug)]
2246pub struct OpVersionGetDo<'r> {
2247 request: Request<'r>,
2248}
2249impl<'r> OpVersionGetDo<'r> {
2250 pub fn new(mut request: Request<'r>) -> Self {
2251 Self::write_header(request.buf_mut());
2252 Self { request: request }
2253 }
2254 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushServerProto<&'buf mut Vec<u8>> {
2255 Self::write_header(buf);
2256 PushServerProto::new(buf)
2257 }
2258 pub fn encode(&mut self) -> PushServerProto<&mut Vec<u8>> {
2259 PushServerProto::new(self.request.buf_mut())
2260 }
2261 pub fn into_encoder(self) -> PushServerProto<RequestBuf<'r>> {
2262 PushServerProto::new(self.request.buf)
2263 }
2264 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableServerProto<'a> {
2265 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
2266 IterableServerProto::with_loc(attrs, buf.as_ptr() as usize)
2267 }
2268 fn write_header<Prev: Rec>(prev: &mut Prev) {
2269 let mut header = BuiltinNfgenmsg::new();
2270 header.cmd = 5u8;
2271 header.version = 1u8;
2272 prev.as_rec_mut().extend(header.as_slice());
2273 }
2274}
2275impl NetlinkRequest for OpVersionGetDo<'_> {
2276 fn protocol(&self) -> Protocol {
2277 Protocol::Generic("nfsd".as_bytes())
2278 }
2279 fn flags(&self) -> u16 {
2280 self.request.flags
2281 }
2282 fn payload(&self) -> &[u8] {
2283 self.request.buf()
2284 }
2285 type ReplyType<'buf> = IterableServerProto<'buf>;
2286 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
2287 Self::decode_request(buf)
2288 }
2289 fn lookup(
2290 buf: &[u8],
2291 offset: usize,
2292 missing_type: Option<u16>,
2293 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
2294 Self::decode_request(buf).lookup_attr(offset, missing_type)
2295 }
2296}
2297#[doc = "set nfs running sockets\nFlags: admin-perm\nRequest attributes:\n- [.nested_addr()](PushServerSock::nested_addr)\n"]
2298#[derive(Debug)]
2299pub struct OpListenerSetDo<'r> {
2300 request: Request<'r>,
2301}
2302impl<'r> OpListenerSetDo<'r> {
2303 pub fn new(mut request: Request<'r>) -> Self {
2304 Self::write_header(request.buf_mut());
2305 Self { request: request }
2306 }
2307 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushServerSock<&'buf mut Vec<u8>> {
2308 Self::write_header(buf);
2309 PushServerSock::new(buf)
2310 }
2311 pub fn encode(&mut self) -> PushServerSock<&mut Vec<u8>> {
2312 PushServerSock::new(self.request.buf_mut())
2313 }
2314 pub fn into_encoder(self) -> PushServerSock<RequestBuf<'r>> {
2315 PushServerSock::new(self.request.buf)
2316 }
2317 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableServerSock<'a> {
2318 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
2319 IterableServerSock::with_loc(attrs, buf.as_ptr() as usize)
2320 }
2321 fn write_header<Prev: Rec>(prev: &mut Prev) {
2322 let mut header = BuiltinNfgenmsg::new();
2323 header.cmd = 6u8;
2324 header.version = 1u8;
2325 prev.as_rec_mut().extend(header.as_slice());
2326 }
2327}
2328impl NetlinkRequest for OpListenerSetDo<'_> {
2329 fn protocol(&self) -> Protocol {
2330 Protocol::Generic("nfsd".as_bytes())
2331 }
2332 fn flags(&self) -> u16 {
2333 self.request.flags
2334 }
2335 fn payload(&self) -> &[u8] {
2336 self.request.buf()
2337 }
2338 type ReplyType<'buf> = IterableServerSock<'buf>;
2339 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
2340 Self::decode_request(buf)
2341 }
2342 fn lookup(
2343 buf: &[u8],
2344 offset: usize,
2345 missing_type: Option<u16>,
2346 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
2347 Self::decode_request(buf).lookup_attr(offset, missing_type)
2348 }
2349}
2350#[doc = "get nfs running listeners\n\nReply attributes:\n- [.get_addr()](IterableServerSock::get_addr)\n"]
2351#[derive(Debug)]
2352pub struct OpListenerGetDo<'r> {
2353 request: Request<'r>,
2354}
2355impl<'r> OpListenerGetDo<'r> {
2356 pub fn new(mut request: Request<'r>) -> Self {
2357 Self::write_header(request.buf_mut());
2358 Self { request: request }
2359 }
2360 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushServerSock<&'buf mut Vec<u8>> {
2361 Self::write_header(buf);
2362 PushServerSock::new(buf)
2363 }
2364 pub fn encode(&mut self) -> PushServerSock<&mut Vec<u8>> {
2365 PushServerSock::new(self.request.buf_mut())
2366 }
2367 pub fn into_encoder(self) -> PushServerSock<RequestBuf<'r>> {
2368 PushServerSock::new(self.request.buf)
2369 }
2370 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableServerSock<'a> {
2371 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
2372 IterableServerSock::with_loc(attrs, buf.as_ptr() as usize)
2373 }
2374 fn write_header<Prev: Rec>(prev: &mut Prev) {
2375 let mut header = BuiltinNfgenmsg::new();
2376 header.cmd = 7u8;
2377 header.version = 1u8;
2378 prev.as_rec_mut().extend(header.as_slice());
2379 }
2380}
2381impl NetlinkRequest for OpListenerGetDo<'_> {
2382 fn protocol(&self) -> Protocol {
2383 Protocol::Generic("nfsd".as_bytes())
2384 }
2385 fn flags(&self) -> u16 {
2386 self.request.flags
2387 }
2388 fn payload(&self) -> &[u8] {
2389 self.request.buf()
2390 }
2391 type ReplyType<'buf> = IterableServerSock<'buf>;
2392 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
2393 Self::decode_request(buf)
2394 }
2395 fn lookup(
2396 buf: &[u8],
2397 offset: usize,
2398 missing_type: Option<u16>,
2399 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
2400 Self::decode_request(buf).lookup_attr(offset, missing_type)
2401 }
2402}
2403#[doc = "set the current server pool\\-mode\nFlags: admin-perm\nRequest attributes:\n- [.push_mode()](PushPoolMode::push_mode)\n"]
2404#[derive(Debug)]
2405pub struct OpPoolModeSetDo<'r> {
2406 request: Request<'r>,
2407}
2408impl<'r> OpPoolModeSetDo<'r> {
2409 pub fn new(mut request: Request<'r>) -> Self {
2410 Self::write_header(request.buf_mut());
2411 Self { request: request }
2412 }
2413 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushPoolMode<&'buf mut Vec<u8>> {
2414 Self::write_header(buf);
2415 PushPoolMode::new(buf)
2416 }
2417 pub fn encode(&mut self) -> PushPoolMode<&mut Vec<u8>> {
2418 PushPoolMode::new(self.request.buf_mut())
2419 }
2420 pub fn into_encoder(self) -> PushPoolMode<RequestBuf<'r>> {
2421 PushPoolMode::new(self.request.buf)
2422 }
2423 pub fn decode_request<'a>(buf: &'a [u8]) -> IterablePoolMode<'a> {
2424 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
2425 IterablePoolMode::with_loc(attrs, buf.as_ptr() as usize)
2426 }
2427 fn write_header<Prev: Rec>(prev: &mut Prev) {
2428 let mut header = BuiltinNfgenmsg::new();
2429 header.cmd = 8u8;
2430 header.version = 1u8;
2431 prev.as_rec_mut().extend(header.as_slice());
2432 }
2433}
2434impl NetlinkRequest for OpPoolModeSetDo<'_> {
2435 fn protocol(&self) -> Protocol {
2436 Protocol::Generic("nfsd".as_bytes())
2437 }
2438 fn flags(&self) -> u16 {
2439 self.request.flags
2440 }
2441 fn payload(&self) -> &[u8] {
2442 self.request.buf()
2443 }
2444 type ReplyType<'buf> = IterablePoolMode<'buf>;
2445 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
2446 Self::decode_request(buf)
2447 }
2448 fn lookup(
2449 buf: &[u8],
2450 offset: usize,
2451 missing_type: Option<u16>,
2452 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
2453 Self::decode_request(buf).lookup_attr(offset, missing_type)
2454 }
2455}
2456#[doc = "get info about server pool\\-mode\n\nReply attributes:\n- [.get_mode()](IterablePoolMode::get_mode)\n- [.get_npools()](IterablePoolMode::get_npools)\n"]
2457#[derive(Debug)]
2458pub struct OpPoolModeGetDo<'r> {
2459 request: Request<'r>,
2460}
2461impl<'r> OpPoolModeGetDo<'r> {
2462 pub fn new(mut request: Request<'r>) -> Self {
2463 Self::write_header(request.buf_mut());
2464 Self { request: request }
2465 }
2466 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushPoolMode<&'buf mut Vec<u8>> {
2467 Self::write_header(buf);
2468 PushPoolMode::new(buf)
2469 }
2470 pub fn encode(&mut self) -> PushPoolMode<&mut Vec<u8>> {
2471 PushPoolMode::new(self.request.buf_mut())
2472 }
2473 pub fn into_encoder(self) -> PushPoolMode<RequestBuf<'r>> {
2474 PushPoolMode::new(self.request.buf)
2475 }
2476 pub fn decode_request<'a>(buf: &'a [u8]) -> IterablePoolMode<'a> {
2477 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
2478 IterablePoolMode::with_loc(attrs, buf.as_ptr() as usize)
2479 }
2480 fn write_header<Prev: Rec>(prev: &mut Prev) {
2481 let mut header = BuiltinNfgenmsg::new();
2482 header.cmd = 9u8;
2483 header.version = 1u8;
2484 prev.as_rec_mut().extend(header.as_slice());
2485 }
2486}
2487impl NetlinkRequest for OpPoolModeGetDo<'_> {
2488 fn protocol(&self) -> Protocol {
2489 Protocol::Generic("nfsd".as_bytes())
2490 }
2491 fn flags(&self) -> u16 {
2492 self.request.flags
2493 }
2494 fn payload(&self) -> &[u8] {
2495 self.request.buf()
2496 }
2497 type ReplyType<'buf> = IterablePoolMode<'buf>;
2498 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
2499 Self::decode_request(buf)
2500 }
2501 fn lookup(
2502 buf: &[u8],
2503 offset: usize,
2504 missing_type: Option<u16>,
2505 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
2506 Self::decode_request(buf).lookup_attr(offset, missing_type)
2507 }
2508}
2509use crate::traits::LookupFn;
2510use crate::utils::RequestBuf;
2511#[derive(Debug)]
2512pub struct Request<'buf> {
2513 buf: RequestBuf<'buf>,
2514 flags: u16,
2515 writeback: Option<&'buf mut Option<RequestInfo>>,
2516}
2517#[allow(unused)]
2518#[derive(Debug, Clone)]
2519pub struct RequestInfo {
2520 protocol: Protocol,
2521 flags: u16,
2522 name: &'static str,
2523 lookup: LookupFn,
2524}
2525impl Request<'static> {
2526 pub fn new() -> Self {
2527 Self::new_from_buf(Vec::new())
2528 }
2529 pub fn new_from_buf(buf: Vec<u8>) -> Self {
2530 Self {
2531 flags: 0,
2532 buf: RequestBuf::Own(buf),
2533 writeback: None,
2534 }
2535 }
2536 pub fn into_buf(self) -> Vec<u8> {
2537 match self.buf {
2538 RequestBuf::Own(buf) => buf,
2539 _ => unreachable!(),
2540 }
2541 }
2542}
2543impl<'buf> Request<'buf> {
2544 pub fn new_with_buf(buf: &'buf mut Vec<u8>) -> Self {
2545 buf.clear();
2546 Self::new_extend(buf)
2547 }
2548 pub fn new_extend(buf: &'buf mut Vec<u8>) -> Self {
2549 Self {
2550 flags: 0,
2551 buf: RequestBuf::Ref(buf),
2552 writeback: None,
2553 }
2554 }
2555 fn do_writeback(&mut self, protocol: Protocol, name: &'static str, lookup: LookupFn) {
2556 let Some(writeback) = &mut self.writeback else {
2557 return;
2558 };
2559 **writeback = Some(RequestInfo {
2560 protocol,
2561 flags: self.flags,
2562 name,
2563 lookup,
2564 })
2565 }
2566 pub fn buf(&self) -> &Vec<u8> {
2567 self.buf.buf()
2568 }
2569 pub fn buf_mut(&mut self) -> &mut Vec<u8> {
2570 self.buf.buf_mut()
2571 }
2572 #[doc = "Set `NLM_F_CREATE` flag"]
2573 pub fn set_create(mut self) -> Self {
2574 self.flags |= consts::NLM_F_CREATE as u16;
2575 self
2576 }
2577 #[doc = "Set `NLM_F_EXCL` flag"]
2578 pub fn set_excl(mut self) -> Self {
2579 self.flags |= consts::NLM_F_EXCL as u16;
2580 self
2581 }
2582 #[doc = "Set `NLM_F_REPLACE` flag"]
2583 pub fn set_replace(mut self) -> Self {
2584 self.flags |= consts::NLM_F_REPLACE as u16;
2585 self
2586 }
2587 #[doc = "Set `NLM_F_CREATE` and `NLM_F_REPLACE` flag"]
2588 pub fn set_change(self) -> Self {
2589 self.set_create().set_replace()
2590 }
2591 #[doc = "Set `NLM_F_APPEND` flag"]
2592 pub fn set_append(mut self) -> Self {
2593 self.flags |= consts::NLM_F_APPEND as u16;
2594 self
2595 }
2596 #[doc = "Set `self.flags |= flags`"]
2597 pub fn set_flags(mut self, flags: u16) -> Self {
2598 self.flags |= flags;
2599 self
2600 }
2601 #[doc = "Set `self.flags ^= self.flags & flags`"]
2602 pub fn unset_flags(mut self, flags: u16) -> Self {
2603 self.flags ^= self.flags & flags;
2604 self
2605 }
2606 #[doc = "Set `NLM_F_DUMP` flag"]
2607 fn set_dump(mut self) -> Self {
2608 self.flags |= consts::NLM_F_DUMP as u16;
2609 self
2610 }
2611 #[doc = "dump pending nfsd rpc\n\nReply attributes:\n- [.get_xid()](IterableRpcStatus::get_xid)\n- [.get_flags()](IterableRpcStatus::get_flags)\n- [.get_prog()](IterableRpcStatus::get_prog)\n- [.get_version()](IterableRpcStatus::get_version)\n- [.get_proc()](IterableRpcStatus::get_proc)\n- [.get_service_time()](IterableRpcStatus::get_service_time)\n- [.get_saddr4()](IterableRpcStatus::get_saddr4)\n- [.get_daddr4()](IterableRpcStatus::get_daddr4)\n- [.get_saddr6()](IterableRpcStatus::get_saddr6)\n- [.get_daddr6()](IterableRpcStatus::get_daddr6)\n- [.get_sport()](IterableRpcStatus::get_sport)\n- [.get_dport()](IterableRpcStatus::get_dport)\n- [.get_compound_ops()](IterableRpcStatus::get_compound_ops)\n"]
2612 pub fn op_rpc_status_get_dump(self) -> OpRpcStatusGetDump<'buf> {
2613 let mut res = OpRpcStatusGetDump::new(self);
2614 res.request.do_writeback(
2615 res.protocol(),
2616 "op-rpc-status-get-dump",
2617 OpRpcStatusGetDump::lookup,
2618 );
2619 res
2620 }
2621 #[doc = "set the maximum number of running threads\nFlags: admin-perm\nRequest attributes:\n- [.push_threads()](PushServer::push_threads)\n- [.push_gracetime()](PushServer::push_gracetime)\n- [.push_leasetime()](PushServer::push_leasetime)\n- [.push_scope()](PushServer::push_scope)\n- [.push_min_threads()](PushServer::push_min_threads)\n"]
2622 pub fn op_threads_set_do(self) -> OpThreadsSetDo<'buf> {
2623 let mut res = OpThreadsSetDo::new(self);
2624 res.request
2625 .do_writeback(res.protocol(), "op-threads-set-do", OpThreadsSetDo::lookup);
2626 res
2627 }
2628 #[doc = "get the maximum number of running threads\n\nReply attributes:\n- [.get_threads()](IterableServer::get_threads)\n- [.get_gracetime()](IterableServer::get_gracetime)\n- [.get_leasetime()](IterableServer::get_leasetime)\n- [.get_scope()](IterableServer::get_scope)\n- [.get_min_threads()](IterableServer::get_min_threads)\n"]
2629 pub fn op_threads_get_do(self) -> OpThreadsGetDo<'buf> {
2630 let mut res = OpThreadsGetDo::new(self);
2631 res.request
2632 .do_writeback(res.protocol(), "op-threads-get-do", OpThreadsGetDo::lookup);
2633 res
2634 }
2635 #[doc = "set nfs enabled versions\nFlags: admin-perm\nRequest attributes:\n- [.nested_version()](PushServerProto::nested_version)\n"]
2636 pub fn op_version_set_do(self) -> OpVersionSetDo<'buf> {
2637 let mut res = OpVersionSetDo::new(self);
2638 res.request
2639 .do_writeback(res.protocol(), "op-version-set-do", OpVersionSetDo::lookup);
2640 res
2641 }
2642 #[doc = "get nfs enabled versions\n\nReply attributes:\n- [.get_version()](IterableServerProto::get_version)\n"]
2643 pub fn op_version_get_do(self) -> OpVersionGetDo<'buf> {
2644 let mut res = OpVersionGetDo::new(self);
2645 res.request
2646 .do_writeback(res.protocol(), "op-version-get-do", OpVersionGetDo::lookup);
2647 res
2648 }
2649 #[doc = "set nfs running sockets\nFlags: admin-perm\nRequest attributes:\n- [.nested_addr()](PushServerSock::nested_addr)\n"]
2650 pub fn op_listener_set_do(self) -> OpListenerSetDo<'buf> {
2651 let mut res = OpListenerSetDo::new(self);
2652 res.request.do_writeback(
2653 res.protocol(),
2654 "op-listener-set-do",
2655 OpListenerSetDo::lookup,
2656 );
2657 res
2658 }
2659 #[doc = "get nfs running listeners\n\nReply attributes:\n- [.get_addr()](IterableServerSock::get_addr)\n"]
2660 pub fn op_listener_get_do(self) -> OpListenerGetDo<'buf> {
2661 let mut res = OpListenerGetDo::new(self);
2662 res.request.do_writeback(
2663 res.protocol(),
2664 "op-listener-get-do",
2665 OpListenerGetDo::lookup,
2666 );
2667 res
2668 }
2669 #[doc = "set the current server pool\\-mode\nFlags: admin-perm\nRequest attributes:\n- [.push_mode()](PushPoolMode::push_mode)\n"]
2670 pub fn op_pool_mode_set_do(self) -> OpPoolModeSetDo<'buf> {
2671 let mut res = OpPoolModeSetDo::new(self);
2672 res.request.do_writeback(
2673 res.protocol(),
2674 "op-pool-mode-set-do",
2675 OpPoolModeSetDo::lookup,
2676 );
2677 res
2678 }
2679 #[doc = "get info about server pool\\-mode\n\nReply attributes:\n- [.get_mode()](IterablePoolMode::get_mode)\n- [.get_npools()](IterablePoolMode::get_npools)\n"]
2680 pub fn op_pool_mode_get_do(self) -> OpPoolModeGetDo<'buf> {
2681 let mut res = OpPoolModeGetDo::new(self);
2682 res.request.do_writeback(
2683 res.protocol(),
2684 "op-pool-mode-get-do",
2685 OpPoolModeGetDo::lookup,
2686 );
2687 res
2688 }
2689}
2690#[cfg(test)]
2691mod generated_tests {
2692 use super::*;
2693 #[test]
2694 fn tests() {
2695 let _ = IterablePoolMode::get_mode;
2696 let _ = IterablePoolMode::get_npools;
2697 let _ = IterableRpcStatus::get_compound_ops;
2698 let _ = IterableRpcStatus::get_daddr4;
2699 let _ = IterableRpcStatus::get_daddr6;
2700 let _ = IterableRpcStatus::get_dport;
2701 let _ = IterableRpcStatus::get_flags;
2702 let _ = IterableRpcStatus::get_proc;
2703 let _ = IterableRpcStatus::get_prog;
2704 let _ = IterableRpcStatus::get_saddr4;
2705 let _ = IterableRpcStatus::get_saddr6;
2706 let _ = IterableRpcStatus::get_service_time;
2707 let _ = IterableRpcStatus::get_sport;
2708 let _ = IterableRpcStatus::get_version;
2709 let _ = IterableRpcStatus::get_xid;
2710 let _ = IterableServer::get_gracetime;
2711 let _ = IterableServer::get_leasetime;
2712 let _ = IterableServer::get_min_threads;
2713 let _ = IterableServer::get_scope;
2714 let _ = IterableServer::get_threads;
2715 let _ = IterableServerProto::get_version;
2716 let _ = IterableServerSock::get_addr;
2717 let _ = PushPoolMode::<&mut Vec<u8>>::push_mode;
2718 let _ = PushServer::<&mut Vec<u8>>::push_gracetime;
2719 let _ = PushServer::<&mut Vec<u8>>::push_leasetime;
2720 let _ = PushServer::<&mut Vec<u8>>::push_min_threads;
2721 let _ = PushServer::<&mut Vec<u8>>::push_scope;
2722 let _ = PushServer::<&mut Vec<u8>>::push_threads;
2723 let _ = PushServerProto::<&mut Vec<u8>>::nested_version;
2724 let _ = PushServerSock::<&mut Vec<u8>>::nested_addr;
2725 }
2726}