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