1use onc_rpc_client::RpcClient;
11use onc_rpc_client::RpcError;
12use onc_rpc_client::transport::io::{AsyncRead, AsyncWrite};
13use onc_xdr::{List, Opaque, Pack, Unpack, Void};
14
15use crate::types::PROGRAM;
16
17const RPCBPROC_SET: u32 = 1;
21const RPCBPROC_UNSET: u32 = 2;
23const RPCBPROC_GETADDR: u32 = 3;
25const RPCBPROC_DUMP: u32 = 4;
27const RPCBPROC_CALLIT: u32 = 5;
29const RPCBPROC_GETTIME: u32 = 6;
31const RPCBPROC_UADDR2TADDR: u32 = 7;
33const RPCBPROC_TADDR2UADDR: u32 = 8;
35const RPCBPROC_GETVERSADDR: u32 = 9;
37const RPCBPROC_INDIRECT: u32 = 10;
39const RPCBPROC_GETADDRLIST: u32 = 11;
41const RPCBPROC_GETSTAT: u32 = 12;
43
44const RPCBIND_V3: u32 = 3;
46const RPCBIND_V4: u32 = 4;
48
49#[derive(Debug, Clone)]
55pub struct RpcbindStatEntry {
56 pub rpcb_version: u32,
58 pub info: Vec<i32>,
61 pub setinfo: i32,
63 pub unsetinfo: i32,
65}
66
67#[derive(Debug)]
72pub struct RpcbStatByvers(
73 pub Vec<RpcbindStatEntry>,
75);
76
77impl Unpack for RpcbStatByvers {
78 fn unpack(input: &mut impl std::io::Read) -> onc_xdr::Result<(Self, usize)> {
79 const RPCBVERS_STAT: usize = 3;
81 const RPCBSTAT_HIGHPROC: usize = 13;
83
84 let mut entries = Vec::with_capacity(RPCBVERS_STAT);
85 let mut total_bytes = 0usize;
86
87 for ver_idx in 0..RPCBVERS_STAT {
88 let mut info = Vec::with_capacity(RPCBSTAT_HIGHPROC);
90 for _ in 0..RPCBSTAT_HIGHPROC {
91 let (v, n) = i32::unpack(input)?;
92 info.push(v);
93 total_bytes += n;
94 }
95 let (setinfo, n) = i32::unpack(input)?;
97 total_bytes += n;
98 let (unsetinfo, n) = i32::unpack(input)?;
100 total_bytes += n;
101 loop {
103 let (disc, n) = u32::unpack(input)?;
104 total_bytes += n;
105 if disc == 0 {
106 break;
107 }
108 for _ in 0..4 {
110 let (_, n) = u32::unpack(input)?;
111 total_bytes += n;
112 }
113 let (netid, n) = onc_xdr::unpack_string(input)?;
114 total_bytes += n;
115 drop(netid);
116 }
117 loop {
119 let (disc, n) = u32::unpack(input)?;
120 total_bytes += n;
121 if disc == 0 {
122 break;
123 }
124 for _ in 0..6 {
126 let (_, n) = u32::unpack(input)?;
127 total_bytes += n;
128 }
129 let (netid, n) = onc_xdr::unpack_string(input)?;
130 total_bytes += n;
131 drop(netid);
132 }
133
134 entries.push(RpcbindStatEntry { rpcb_version: u32::try_from(ver_idx).unwrap_or(0) + 2, info, setinfo, unsetinfo });
135 }
136
137 Ok((Self(entries), total_bytes))
138 }
139}
140
141#[derive(Debug)]
150#[expect(clippy::struct_field_names, reason = "r_ prefix matches the RFC 1833 XDR field names verbatim")]
151struct Rpcb<'a> {
152 r_prog: u32,
153 r_vers: u32,
154 r_netid: &'a str,
155 r_addr: &'a str,
156 r_owner: &'a str,
157}
158
159impl Pack for Rpcb<'_> {
160 fn packed_size(&self) -> usize {
161 self.r_prog.packed_size() + self.r_vers.packed_size() + onc_xdr::string_packed_size(self.r_netid) + onc_xdr::string_packed_size(self.r_addr) + onc_xdr::string_packed_size(self.r_owner)
162 }
163
164 fn pack(&self, out: &mut impl std::io::Write) -> onc_xdr::Result<usize> {
165 let mut n = self.r_prog.pack(out)?;
166 n += self.r_vers.pack(out)?;
167 n += onc_xdr::pack_string(self.r_netid, out)?;
168 n += onc_xdr::pack_string(self.r_addr, out)?;
169 n += onc_xdr::pack_string(self.r_owner, out)?;
170 Ok(n)
171 }
172}
173
174#[derive(Debug, Clone)]
179pub struct RpcbEntry {
180 pub program: u32,
182 pub version: u32,
184 pub netid: String,
186 pub addr: String,
188 pub owner: String,
190}
191
192impl Pack for RpcbEntry {
193 fn packed_size(&self) -> usize {
194 self.program.packed_size() + self.version.packed_size() + onc_xdr::string_packed_size(&self.netid) + onc_xdr::string_packed_size(&self.addr) + onc_xdr::string_packed_size(&self.owner)
195 }
196
197 fn pack(&self, out: &mut impl std::io::Write) -> onc_xdr::Result<usize> {
198 let mut n = self.program.pack(out)?;
199 n += self.version.pack(out)?;
200 n += onc_xdr::pack_string(&self.netid, out)?;
201 n += onc_xdr::pack_string(&self.addr, out)?;
202 n += onc_xdr::pack_string(&self.owner, out)?;
203 Ok(n)
204 }
205}
206
207impl Unpack for RpcbEntry {
208 fn unpack(input: &mut impl std::io::Read) -> onc_xdr::Result<(Self, usize)> {
209 let mut n = 0;
210 let (program, b) = u32::unpack(input)?;
211 n += b;
212 let (version, b) = u32::unpack(input)?;
213 n += b;
214 let (netid, b) = onc_xdr::unpack_string(input)?;
215 n += b;
216 let (addr, b) = onc_xdr::unpack_string(input)?;
217 n += b;
218 let (owner, b) = onc_xdr::unpack_string(input)?;
219 n += b;
220 Ok((Self { program, version, netid, addr, owner }, n))
221 }
222}
223
224pub type RpcbList = List<RpcbEntry>;
226
227#[derive(Debug, Clone)]
230pub struct RpcbRmtCallArgs<'a> {
231 pub program: u32,
233 pub version: u32,
235 pub proc: u32,
237 pub args: Opaque<'a>,
239}
240
241impl Pack for RpcbRmtCallArgs<'_> {
242 fn packed_size(&self) -> usize {
243 self.program.packed_size() + self.version.packed_size() + self.proc.packed_size() + self.args.packed_size()
244 }
245
246 fn pack(&self, out: &mut impl std::io::Write) -> onc_xdr::Result<usize> {
247 let mut n = self.program.pack(out)?;
248 n += self.version.pack(out)?;
249 n += self.proc.pack(out)?;
250 n += self.args.pack(out)?;
251 Ok(n)
252 }
253}
254
255impl Unpack for RpcbRmtCallArgs<'static> {
256 fn unpack(input: &mut impl std::io::Read) -> onc_xdr::Result<(Self, usize)> {
257 let mut n = 0;
258 let (program, b) = u32::unpack(input)?;
259 n += b;
260 let (version, b) = u32::unpack(input)?;
261 n += b;
262 let (proc, b) = u32::unpack(input)?;
263 n += b;
264 let (args, b) = Opaque::unpack(input)?;
265 n += b;
266 Ok((Self { program, version, proc, args }, n))
267 }
268}
269
270#[derive(Debug, Clone)]
273pub struct RpcbRmtCallRes {
274 pub addr: String,
276 pub results: Vec<u8>,
278}
279
280impl Pack for RpcbRmtCallRes {
281 fn packed_size(&self) -> usize {
282 onc_xdr::string_packed_size(&self.addr) + Opaque::borrowed(&self.results).packed_size()
283 }
284
285 fn pack(&self, out: &mut impl std::io::Write) -> onc_xdr::Result<usize> {
286 let mut n = onc_xdr::pack_string(&self.addr, out)?;
287 n += Opaque::borrowed(&self.results).pack(out)?;
288 Ok(n)
289 }
290}
291
292impl Unpack for RpcbRmtCallRes {
293 fn unpack(input: &mut impl std::io::Read) -> onc_xdr::Result<(Self, usize)> {
294 let mut n = 0;
295 let (addr, b) = onc_xdr::unpack_string(input)?;
296 n += b;
297 let (results, b) = Opaque::unpack(input)?;
298 n += b;
299 Ok((Self { addr, results: results.into_owned() }, n))
300 }
301}
302
303#[derive(Debug, Clone)]
308pub struct Netbuf {
309 pub maxlen: u32,
311 pub buf: Vec<u8>,
313}
314
315impl Pack for Netbuf {
316 fn packed_size(&self) -> usize {
317 self.maxlen.packed_size() + Opaque::borrowed(&self.buf).packed_size()
318 }
319
320 fn pack(&self, out: &mut impl std::io::Write) -> onc_xdr::Result<usize> {
321 let mut n = self.maxlen.pack(out)?;
322 n += Opaque::borrowed(&self.buf).pack(out)?;
323 Ok(n)
324 }
325}
326
327impl Unpack for Netbuf {
328 fn unpack(input: &mut impl std::io::Read) -> onc_xdr::Result<(Self, usize)> {
329 let mut n = 0;
330 let (maxlen, b) = u32::unpack(input)?;
331 n += b;
332 let (buf, b) = Opaque::unpack(input)?;
333 n += b;
334 Ok((Self { maxlen, buf: buf.into_owned() }, n))
335 }
336}
337
338#[derive(Debug, Clone)]
340pub struct RpcbAddrEntry {
341 pub maddr: String,
343 pub nc_netid: String,
345 pub nc_semantics: u32,
347 pub nc_protofmly: String,
349 pub nc_proto: String,
351}
352
353impl Pack for RpcbAddrEntry {
354 fn packed_size(&self) -> usize {
355 onc_xdr::string_packed_size(&self.maddr) + onc_xdr::string_packed_size(&self.nc_netid) + self.nc_semantics.packed_size() + onc_xdr::string_packed_size(&self.nc_protofmly) + onc_xdr::string_packed_size(&self.nc_proto)
356 }
357
358 fn pack(&self, out: &mut impl std::io::Write) -> onc_xdr::Result<usize> {
359 let mut n = onc_xdr::pack_string(&self.maddr, out)?;
360 n += onc_xdr::pack_string(&self.nc_netid, out)?;
361 n += self.nc_semantics.pack(out)?;
362 n += onc_xdr::pack_string(&self.nc_protofmly, out)?;
363 n += onc_xdr::pack_string(&self.nc_proto, out)?;
364 Ok(n)
365 }
366}
367
368impl Unpack for RpcbAddrEntry {
369 fn unpack(input: &mut impl std::io::Read) -> onc_xdr::Result<(Self, usize)> {
370 let mut n = 0;
371 let (maddr, b) = onc_xdr::unpack_string(input)?;
372 n += b;
373 let (nc_netid, b) = onc_xdr::unpack_string(input)?;
374 n += b;
375 let (nc_semantics, b) = u32::unpack(input)?;
376 n += b;
377 let (nc_protofmly, b) = onc_xdr::unpack_string(input)?;
378 n += b;
379 let (nc_proto, b) = onc_xdr::unpack_string(input)?;
380 n += b;
381 Ok((Self { maddr, nc_netid, nc_semantics, nc_protofmly, nc_proto }, n))
382 }
383}
384
385pub type RpcbAddrList = List<RpcbAddrEntry>;
388
389#[derive(Debug)]
392struct XdrString(String);
393
394impl Unpack for XdrString {
395 fn unpack(input: &mut impl std::io::Read) -> onc_xdr::Result<(Self, usize)> {
396 let (s, n) = onc_xdr::unpack_string(input)?;
397 Ok((Self(s), n))
398 }
399}
400
401struct XdrPackString<'a>(&'a str);
403
404impl Pack for XdrPackString<'_> {
405 fn packed_size(&self) -> usize {
406 onc_xdr::string_packed_size(self.0)
407 }
408
409 fn pack(&self, out: &mut impl std::io::Write) -> onc_xdr::Result<usize> {
410 onc_xdr::pack_string(self.0, out)
411 }
412}
413
414#[derive(Debug)]
420pub struct RpcbindClient<IO> {
421 rpc: RpcClient<IO>,
422}
423
424impl<IO> RpcbindClient<IO>
425where
426 IO: AsyncRead + AsyncWrite + Send,
427{
428 pub fn new(io: IO) -> Self {
433 Self { rpc: RpcClient::new(io) }
434 }
435
436 pub async fn set(&mut self, program: u32, version: u32, netid: &str, addr: &str, owner: &str) -> Result<bool, RpcError> {
440 let args = Rpcb { r_prog: program, r_vers: version, r_netid: netid, r_addr: addr, r_owner: owner };
441 self.rpc.call(PROGRAM, RPCBIND_V3, RPCBPROC_SET, &args).await
442 }
443
444 pub async fn unset(&mut self, program: u32, version: u32, netid: &str, addr: &str, owner: &str) -> Result<bool, RpcError> {
446 let args = Rpcb { r_prog: program, r_vers: version, r_netid: netid, r_addr: addr, r_owner: owner };
447 self.rpc.call(PROGRAM, RPCBIND_V3, RPCBPROC_UNSET, &args).await
448 }
449
450 pub async fn getaddr(&mut self, program: u32, version: u32, netid: &str) -> Result<String, RpcError> {
453 let args = Rpcb { r_prog: program, r_vers: version, r_netid: netid, r_addr: "", r_owner: "" };
454 let result: XdrString = self.rpc.call(PROGRAM, RPCBIND_V3, RPCBPROC_GETADDR, &args).await?;
455 Ok(result.0)
456 }
457
458 pub async fn dump(&mut self) -> Result<Vec<RpcbEntry>, RpcError> {
460 let list: RpcbList = self.rpc.call(PROGRAM, RPCBIND_V3, RPCBPROC_DUMP, &Void).await?;
461 Ok(list.into_inner())
462 }
463
464 pub async fn callit(&mut self, program: u32, version: u32, proc: u32, args: &[u8]) -> Result<RpcbRmtCallRes, RpcError> {
466 let rmt_args = RpcbRmtCallArgs { program, version, proc, args: Opaque::borrowed(args) };
467 self.rpc.call(PROGRAM, RPCBIND_V3, RPCBPROC_CALLIT, &rmt_args).await
468 }
469
470 pub async fn gettime(&mut self) -> Result<u32, RpcError> {
473 self.rpc.call(PROGRAM, RPCBIND_V3, RPCBPROC_GETTIME, &Void).await
474 }
475
476 pub async fn uaddr2taddr(&mut self, uaddr: &str) -> Result<Netbuf, RpcError> {
479 let args = XdrPackString(uaddr);
480 self.rpc.call(PROGRAM, RPCBIND_V3, RPCBPROC_UADDR2TADDR, &args).await
481 }
482
483 pub async fn taddr2uaddr(&mut self, taddr: &Netbuf) -> Result<String, RpcError> {
486 let result: XdrString = self.rpc.call(PROGRAM, RPCBIND_V3, RPCBPROC_TADDR2UADDR, taddr).await?;
487 Ok(result.0)
488 }
489
490 pub async fn bcast(&mut self, program: u32, version: u32, proc: u32, args: &[u8]) -> Result<RpcbRmtCallRes, RpcError> {
497 let rmt_args = RpcbRmtCallArgs { program, version, proc, args: Opaque::borrowed(args) };
498 self.rpc.call(PROGRAM, RPCBIND_V4, RPCBPROC_CALLIT, &rmt_args).await
499 }
500
501 pub async fn getversaddr(&mut self, program: u32, version: u32, netid: &str) -> Result<String, RpcError> {
504 let args = Rpcb { r_prog: program, r_vers: version, r_netid: netid, r_addr: "", r_owner: "" };
505 let result: XdrString = self.rpc.call(PROGRAM, RPCBIND_V4, RPCBPROC_GETVERSADDR, &args).await?;
506 Ok(result.0)
507 }
508
509 pub async fn indirect(&mut self, program: u32, version: u32, proc: u32, args: &[u8]) -> Result<RpcbRmtCallRes, RpcError> {
512 let rmt_args = RpcbRmtCallArgs { program, version, proc, args: Opaque::borrowed(args) };
513 self.rpc.call(PROGRAM, RPCBIND_V4, RPCBPROC_INDIRECT, &rmt_args).await
514 }
515
516 pub async fn getaddrlist(&mut self, program: u32, version: u32, netid: &str) -> Result<Vec<RpcbAddrEntry>, RpcError> {
519 let args = Rpcb { r_prog: program, r_vers: version, r_netid: netid, r_addr: "", r_owner: "" };
520 let list: RpcbAddrList = self.rpc.call(PROGRAM, RPCBIND_V4, RPCBPROC_GETADDRLIST, &args).await?;
521 Ok(list.into_inner())
522 }
523
524 pub async fn getstat(&mut self) -> Result<RpcbStatByvers, RpcError> {
527 self.rpc.call(PROGRAM, RPCBIND_V4, RPCBPROC_GETSTAT, &Void).await
528 }
529}