use onc_rpc_client::RpcClient;
use onc_rpc_client::RpcError;
use onc_rpc_client::transport::io::{AsyncRead, AsyncWrite};
use onc_xdr::{List, Opaque, Pack, Unpack, Void};
use crate::types::PROGRAM;
const RPCBPROC_SET: u32 = 1;
const RPCBPROC_UNSET: u32 = 2;
const RPCBPROC_GETADDR: u32 = 3;
const RPCBPROC_DUMP: u32 = 4;
const RPCBPROC_CALLIT: u32 = 5;
const RPCBPROC_GETTIME: u32 = 6;
const RPCBPROC_UADDR2TADDR: u32 = 7;
const RPCBPROC_TADDR2UADDR: u32 = 8;
const RPCBPROC_GETVERSADDR: u32 = 9;
const RPCBPROC_INDIRECT: u32 = 10;
const RPCBPROC_GETADDRLIST: u32 = 11;
const RPCBPROC_GETSTAT: u32 = 12;
const RPCBIND_V3: u32 = 3;
const RPCBIND_V4: u32 = 4;
#[derive(Debug, Clone)]
pub struct RpcbindStatEntry {
pub rpcb_version: u32,
pub info: Vec<i32>,
pub setinfo: i32,
pub unsetinfo: i32,
}
#[derive(Debug)]
pub struct RpcbStatByvers(
pub Vec<RpcbindStatEntry>,
);
impl Unpack for RpcbStatByvers {
fn unpack(input: &mut impl std::io::Read) -> onc_xdr::Result<(Self, usize)> {
const RPCBVERS_STAT: usize = 3;
const RPCBSTAT_HIGHPROC: usize = 13;
let mut entries = Vec::with_capacity(RPCBVERS_STAT);
let mut total_bytes = 0usize;
for ver_idx in 0..RPCBVERS_STAT {
let mut info = Vec::with_capacity(RPCBSTAT_HIGHPROC);
for _ in 0..RPCBSTAT_HIGHPROC {
let (v, n) = i32::unpack(input)?;
info.push(v);
total_bytes += n;
}
let (setinfo, n) = i32::unpack(input)?;
total_bytes += n;
let (unsetinfo, n) = i32::unpack(input)?;
total_bytes += n;
loop {
let (disc, n) = u32::unpack(input)?;
total_bytes += n;
if disc == 0 {
break;
}
for _ in 0..4 {
let (_, n) = u32::unpack(input)?;
total_bytes += n;
}
let (netid, n) = onc_xdr::unpack_string(input)?;
total_bytes += n;
drop(netid);
}
loop {
let (disc, n) = u32::unpack(input)?;
total_bytes += n;
if disc == 0 {
break;
}
for _ in 0..6 {
let (_, n) = u32::unpack(input)?;
total_bytes += n;
}
let (netid, n) = onc_xdr::unpack_string(input)?;
total_bytes += n;
drop(netid);
}
entries.push(RpcbindStatEntry { rpcb_version: u32::try_from(ver_idx).unwrap_or(0) + 2, info, setinfo, unsetinfo });
}
Ok((Self(entries), total_bytes))
}
}
#[derive(Debug)]
#[expect(clippy::struct_field_names, reason = "r_ prefix matches the RFC 1833 XDR field names verbatim")]
struct Rpcb<'a> {
r_prog: u32,
r_vers: u32,
r_netid: &'a str,
r_addr: &'a str,
r_owner: &'a str,
}
impl Pack for Rpcb<'_> {
fn packed_size(&self) -> usize {
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)
}
fn pack(&self, out: &mut impl std::io::Write) -> onc_xdr::Result<usize> {
let mut n = self.r_prog.pack(out)?;
n += self.r_vers.pack(out)?;
n += onc_xdr::pack_string(self.r_netid, out)?;
n += onc_xdr::pack_string(self.r_addr, out)?;
n += onc_xdr::pack_string(self.r_owner, out)?;
Ok(n)
}
}
#[derive(Debug, Clone)]
pub struct RpcbEntry {
pub program: u32,
pub version: u32,
pub netid: String,
pub addr: String,
pub owner: String,
}
impl Pack for RpcbEntry {
fn packed_size(&self) -> usize {
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)
}
fn pack(&self, out: &mut impl std::io::Write) -> onc_xdr::Result<usize> {
let mut n = self.program.pack(out)?;
n += self.version.pack(out)?;
n += onc_xdr::pack_string(&self.netid, out)?;
n += onc_xdr::pack_string(&self.addr, out)?;
n += onc_xdr::pack_string(&self.owner, out)?;
Ok(n)
}
}
impl Unpack for RpcbEntry {
fn unpack(input: &mut impl std::io::Read) -> onc_xdr::Result<(Self, usize)> {
let mut n = 0;
let (program, b) = u32::unpack(input)?;
n += b;
let (version, b) = u32::unpack(input)?;
n += b;
let (netid, b) = onc_xdr::unpack_string(input)?;
n += b;
let (addr, b) = onc_xdr::unpack_string(input)?;
n += b;
let (owner, b) = onc_xdr::unpack_string(input)?;
n += b;
Ok((Self { program, version, netid, addr, owner }, n))
}
}
pub type RpcbList = List<RpcbEntry>;
#[derive(Debug, Clone)]
pub struct RpcbRmtCallArgs<'a> {
pub program: u32,
pub version: u32,
pub proc: u32,
pub args: Opaque<'a>,
}
impl Pack for RpcbRmtCallArgs<'_> {
fn packed_size(&self) -> usize {
self.program.packed_size() + self.version.packed_size() + self.proc.packed_size() + self.args.packed_size()
}
fn pack(&self, out: &mut impl std::io::Write) -> onc_xdr::Result<usize> {
let mut n = self.program.pack(out)?;
n += self.version.pack(out)?;
n += self.proc.pack(out)?;
n += self.args.pack(out)?;
Ok(n)
}
}
impl Unpack for RpcbRmtCallArgs<'static> {
fn unpack(input: &mut impl std::io::Read) -> onc_xdr::Result<(Self, usize)> {
let mut n = 0;
let (program, b) = u32::unpack(input)?;
n += b;
let (version, b) = u32::unpack(input)?;
n += b;
let (proc, b) = u32::unpack(input)?;
n += b;
let (args, b) = Opaque::unpack(input)?;
n += b;
Ok((Self { program, version, proc, args }, n))
}
}
#[derive(Debug, Clone)]
pub struct RpcbRmtCallRes {
pub addr: String,
pub results: Vec<u8>,
}
impl Pack for RpcbRmtCallRes {
fn packed_size(&self) -> usize {
onc_xdr::string_packed_size(&self.addr) + Opaque::borrowed(&self.results).packed_size()
}
fn pack(&self, out: &mut impl std::io::Write) -> onc_xdr::Result<usize> {
let mut n = onc_xdr::pack_string(&self.addr, out)?;
n += Opaque::borrowed(&self.results).pack(out)?;
Ok(n)
}
}
impl Unpack for RpcbRmtCallRes {
fn unpack(input: &mut impl std::io::Read) -> onc_xdr::Result<(Self, usize)> {
let mut n = 0;
let (addr, b) = onc_xdr::unpack_string(input)?;
n += b;
let (results, b) = Opaque::unpack(input)?;
n += b;
Ok((Self { addr, results: results.into_owned() }, n))
}
}
#[derive(Debug, Clone)]
pub struct Netbuf {
pub maxlen: u32,
pub buf: Vec<u8>,
}
impl Pack for Netbuf {
fn packed_size(&self) -> usize {
self.maxlen.packed_size() + Opaque::borrowed(&self.buf).packed_size()
}
fn pack(&self, out: &mut impl std::io::Write) -> onc_xdr::Result<usize> {
let mut n = self.maxlen.pack(out)?;
n += Opaque::borrowed(&self.buf).pack(out)?;
Ok(n)
}
}
impl Unpack for Netbuf {
fn unpack(input: &mut impl std::io::Read) -> onc_xdr::Result<(Self, usize)> {
let mut n = 0;
let (maxlen, b) = u32::unpack(input)?;
n += b;
let (buf, b) = Opaque::unpack(input)?;
n += b;
Ok((Self { maxlen, buf: buf.into_owned() }, n))
}
}
#[derive(Debug, Clone)]
pub struct RpcbAddrEntry {
pub maddr: String,
pub nc_netid: String,
pub nc_semantics: u32,
pub nc_protofmly: String,
pub nc_proto: String,
}
impl Pack for RpcbAddrEntry {
fn packed_size(&self) -> usize {
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)
}
fn pack(&self, out: &mut impl std::io::Write) -> onc_xdr::Result<usize> {
let mut n = onc_xdr::pack_string(&self.maddr, out)?;
n += onc_xdr::pack_string(&self.nc_netid, out)?;
n += self.nc_semantics.pack(out)?;
n += onc_xdr::pack_string(&self.nc_protofmly, out)?;
n += onc_xdr::pack_string(&self.nc_proto, out)?;
Ok(n)
}
}
impl Unpack for RpcbAddrEntry {
fn unpack(input: &mut impl std::io::Read) -> onc_xdr::Result<(Self, usize)> {
let mut n = 0;
let (maddr, b) = onc_xdr::unpack_string(input)?;
n += b;
let (nc_netid, b) = onc_xdr::unpack_string(input)?;
n += b;
let (nc_semantics, b) = u32::unpack(input)?;
n += b;
let (nc_protofmly, b) = onc_xdr::unpack_string(input)?;
n += b;
let (nc_proto, b) = onc_xdr::unpack_string(input)?;
n += b;
Ok((Self { maddr, nc_netid, nc_semantics, nc_protofmly, nc_proto }, n))
}
}
pub type RpcbAddrList = List<RpcbAddrEntry>;
#[derive(Debug)]
struct XdrString(String);
impl Unpack for XdrString {
fn unpack(input: &mut impl std::io::Read) -> onc_xdr::Result<(Self, usize)> {
let (s, n) = onc_xdr::unpack_string(input)?;
Ok((Self(s), n))
}
}
struct XdrPackString<'a>(&'a str);
impl Pack for XdrPackString<'_> {
fn packed_size(&self) -> usize {
onc_xdr::string_packed_size(self.0)
}
fn pack(&self, out: &mut impl std::io::Write) -> onc_xdr::Result<usize> {
onc_xdr::pack_string(self.0, out)
}
}
#[derive(Debug)]
pub struct RpcbindClient<IO> {
rpc: RpcClient<IO>,
}
impl<IO> RpcbindClient<IO>
where
IO: AsyncRead + AsyncWrite + Send,
{
pub fn new(io: IO) -> Self {
Self { rpc: RpcClient::new(io) }
}
pub async fn set(&mut self, program: u32, version: u32, netid: &str, addr: &str, owner: &str) -> Result<bool, RpcError> {
let args = Rpcb { r_prog: program, r_vers: version, r_netid: netid, r_addr: addr, r_owner: owner };
self.rpc.call(PROGRAM, RPCBIND_V3, RPCBPROC_SET, &args).await
}
pub async fn unset(&mut self, program: u32, version: u32, netid: &str, addr: &str, owner: &str) -> Result<bool, RpcError> {
let args = Rpcb { r_prog: program, r_vers: version, r_netid: netid, r_addr: addr, r_owner: owner };
self.rpc.call(PROGRAM, RPCBIND_V3, RPCBPROC_UNSET, &args).await
}
pub async fn getaddr(&mut self, program: u32, version: u32, netid: &str) -> Result<String, RpcError> {
let args = Rpcb { r_prog: program, r_vers: version, r_netid: netid, r_addr: "", r_owner: "" };
let result: XdrString = self.rpc.call(PROGRAM, RPCBIND_V3, RPCBPROC_GETADDR, &args).await?;
Ok(result.0)
}
pub async fn dump(&mut self) -> Result<Vec<RpcbEntry>, RpcError> {
let list: RpcbList = self.rpc.call(PROGRAM, RPCBIND_V3, RPCBPROC_DUMP, &Void).await?;
Ok(list.into_inner())
}
pub async fn callit(&mut self, program: u32, version: u32, proc: u32, args: &[u8]) -> Result<RpcbRmtCallRes, RpcError> {
let rmt_args = RpcbRmtCallArgs { program, version, proc, args: Opaque::borrowed(args) };
self.rpc.call(PROGRAM, RPCBIND_V3, RPCBPROC_CALLIT, &rmt_args).await
}
pub async fn gettime(&mut self) -> Result<u32, RpcError> {
self.rpc.call(PROGRAM, RPCBIND_V3, RPCBPROC_GETTIME, &Void).await
}
pub async fn uaddr2taddr(&mut self, uaddr: &str) -> Result<Netbuf, RpcError> {
let args = XdrPackString(uaddr);
self.rpc.call(PROGRAM, RPCBIND_V3, RPCBPROC_UADDR2TADDR, &args).await
}
pub async fn taddr2uaddr(&mut self, taddr: &Netbuf) -> Result<String, RpcError> {
let result: XdrString = self.rpc.call(PROGRAM, RPCBIND_V3, RPCBPROC_TADDR2UADDR, taddr).await?;
Ok(result.0)
}
pub async fn bcast(&mut self, program: u32, version: u32, proc: u32, args: &[u8]) -> Result<RpcbRmtCallRes, RpcError> {
let rmt_args = RpcbRmtCallArgs { program, version, proc, args: Opaque::borrowed(args) };
self.rpc.call(PROGRAM, RPCBIND_V4, RPCBPROC_CALLIT, &rmt_args).await
}
pub async fn getversaddr(&mut self, program: u32, version: u32, netid: &str) -> Result<String, RpcError> {
let args = Rpcb { r_prog: program, r_vers: version, r_netid: netid, r_addr: "", r_owner: "" };
let result: XdrString = self.rpc.call(PROGRAM, RPCBIND_V4, RPCBPROC_GETVERSADDR, &args).await?;
Ok(result.0)
}
pub async fn indirect(&mut self, program: u32, version: u32, proc: u32, args: &[u8]) -> Result<RpcbRmtCallRes, RpcError> {
let rmt_args = RpcbRmtCallArgs { program, version, proc, args: Opaque::borrowed(args) };
self.rpc.call(PROGRAM, RPCBIND_V4, RPCBPROC_INDIRECT, &rmt_args).await
}
pub async fn getaddrlist(&mut self, program: u32, version: u32, netid: &str) -> Result<Vec<RpcbAddrEntry>, RpcError> {
let args = Rpcb { r_prog: program, r_vers: version, r_netid: netid, r_addr: "", r_owner: "" };
let list: RpcbAddrList = self.rpc.call(PROGRAM, RPCBIND_V4, RPCBPROC_GETADDRLIST, &args).await?;
Ok(list.into_inner())
}
pub async fn getstat(&mut self) -> Result<RpcbStatByvers, RpcError> {
self.rpc.call(PROGRAM, RPCBIND_V4, RPCBPROC_GETSTAT, &Void).await
}
}