rpcbind: add client and server implementations of SET

Author: bertschinger

rpc_protocol/src/client.rs

@@ -11,8 +11,8 @@ use crate::*;
 ///
 /// This blocks the calling thread until the procedure returns a result. It returns either that
 /// result as a byte vector (which the caller can decode), or an error.
-pub fn do_rpc_call(
-    stream: &mut TcpStream,
+pub fn do_rpc_call<S: Read + Write>(
+    stream: &mut S,
     prog: u32,
     vers: u32,
     proc: u32,
@@ -45,7 +45,10 @@ pub fn do_rpc_call(
     read_reply_from_stream(xid, stream)
 }
 
-fn read_reply_from_stream(xid: u32, stream: &mut TcpStream) -> Result<Vec<u8>, crate::Error> {
+fn read_reply_from_stream<S: Read + Write>(
+    xid: u32,
+    stream: &mut S,
+) -> Result<Vec<u8>, crate::Error> {
     let message_length = decode_record_mark(stream)?;
 
     let mut buf = vec![0; message_length as usize];

rpc_protocol/src/lib.rs

@@ -91,7 +91,7 @@ fn update_record_mark(buf: &mut Vec<u8>) {
 /// implementation does not yet support record fragments.
 ///
 /// Otherwise, returns the length of the message.
-fn decode_record_mark(stream: &mut std::net::TcpStream) -> Result<u32, crate::Error> {
+fn decode_record_mark<S: Read + Write>(stream: &mut S) -> Result<u32, crate::Error> {
     let mut record_mark_bytes: [u8; 4] = [0; 4];
 
     stream.read_exact(&mut record_mark_bytes).inspect_err(|e| {

rpc_protocol/src/rpcbind/client.rs

@@ -1,2 +1,59 @@
 // SPDX-License-Identifier: BSD-3-Clause
 // Copyright 2025. Triad National Security, LLC.
+
+use log::*;
+
+use std::io::{Read, Write};
+use std::net::TcpStream;
+use std::os::unix::net::UnixStream;
+
+use crate::client::*;
+
+use super::rpcbind;
+use super::rpcbind::procedures::*;
+
+/// An RPCBIND Server tends to listen both on a Unix socket and a TCP socket.
+pub enum RpcbindServerAddress {
+    Unix(String),
+    Tcp(String),
+}
+
+/// Try to call the SET RPC for the RPCBIND server listening at `address`, to add `new_service` to
+/// its service list.
+pub fn set(
+    new_service: rpcbind::RpcService,
+    server_address: RpcbindServerAddress,
+) -> Result<bool, crate::Error> {
+    debug!("performing RPCBIND Set call");
+
+    match server_address {
+        RpcbindServerAddress::Unix(addr) => {
+            let stream = UnixStream::connect(addr)?;
+            set_using_stream(new_service, stream)
+        }
+        RpcbindServerAddress::Tcp(addr) => {
+            let stream = TcpStream::connect(addr)?;
+            set_using_stream(new_service, stream)
+        }
+    }
+}
+
+fn set_using_stream<S: Read + Write>(
+    new_service: rpcbind::RpcService,
+    mut stream: S,
+) -> Result<bool, crate::Error> {
+    let arg = new_service.serialize_alloc();
+
+    let res = do_rpc_call(
+        &mut stream,
+        RPCBPROG,
+        RPCBVERS::VERSION,
+        RPCBVERS::RPCBPROC_SET,
+        arg.as_slice(),
+    )?;
+
+    match res.as_slice() {
+        &[0, 0, 0, 0] => Ok(false),
+        _ => Ok(true),
+    }
+}

rpc_protocol/src/rpcbind/server.rs

@@ -3,6 +3,8 @@
 
 #![allow(non_camel_case_types)]
 
+use log::*;
+
 use std::ffi::OsString;
 use std::net::TcpListener;
 
@@ -15,13 +17,8 @@ use super::rpcbind::procedures::*;
 pub fn main() {
     let service_list = default_service_list();
 
-    let procedures: Vec<Option<RpcProcedure<rpcbind::RpcbindList>>> = vec![
-        None,
-        None, // set()
-        None, // unset()
-        Some(getaddr),
-        Some(dump),
-    ];
+    let procedures: Vec<Option<RpcProcedure<rpcbind::RpcbindList>>> =
+        vec![None, Some(set), Some(unset), Some(getaddr), Some(dump)];
     let mut server = RpcService::new(RPCBPROG, RPCBVERS::VERSION, procedures, service_list);
 
     let listener = TcpListener::bind("0.0.0.0:111").unwrap();
@@ -34,26 +31,14 @@ pub fn main() {
 fn getaddr(_call: &CallBody, mut arg: &[u8], service_list: &mut rpcbind::RpcbindList) -> RpcResult {
     let mut requested = rpcbind::RpcService::default();
     rpcbind::RpcService::deserialize(&mut requested, &mut arg).unwrap();
-    eprintln!("{:?}", requested);
-
-    for service in service_list.items.iter() {
-        let service = &service.rpcb_map;
-
-        if requested.prog != service.prog {
-            continue;
-        }
-
-        if requested.vers != service.vers {
-            continue;
-        }
+    debug!("GETADDR Call: {requested:?}");
 
+    if let Some(service) = get_service(requested.prog, requested.vers, service_list) {
         let address = rpcbind::RpcbString {
             contents: service.addr.clone(),
         };
 
-        let bytes = rpcbind::RpcbString::serialize_alloc(&address);
-
-        return RpcResult::Success(bytes);
+        return RpcResult::Success(rpcbind::RpcbString::serialize_alloc(&address));
     }
 
     let empty = rpcbind::RpcbString {
@@ -63,6 +48,37 @@ fn getaddr(_call: &CallBody, mut arg: &[u8], service_list: &mut rpcbind::Rpcbind
     RpcResult::Success(empty.serialize_alloc())
 }
 
+/// Implementation of the set RPC. This adds a service to the list.
+fn set(_call: &CallBody, arg: &[u8], service_list: &mut rpcbind::RpcbindList) -> RpcResult {
+    let mut new_service = rpcbind::RpcService::default();
+    let mut arg = arg;
+    if let Err(_) = new_service.deserialize(&mut arg) {
+        return RpcResult::GarbageArgs;
+    }
+
+    // Make sure that this service is not already registered:
+    if get_service(new_service.prog, new_service.vers, service_list).is_some() {
+        // If it is, return False to the caller:
+        return RpcResult::Success(vec![0, 0, 0, 0]);
+    }
+
+    if new_service.netid.is_empty() || new_service.addr.is_empty() {
+        // According to the RFC, empty netid and address are not allowed.
+        return RpcResult::Success(vec![0, 0, 0, 0]);
+    }
+
+    service_list.items.push(rpcbind::RpcbindItem {
+        rpcb_map: new_service,
+    });
+
+    RpcResult::Success(vec![0, 0, 0, 1])
+}
+
+/// Implementation of the unset RPC. This removes a service from the list.
+fn unset(_call: &CallBody, _arg: &[u8], service_list: &mut rpcbind::RpcbindList) -> RpcResult {
+    todo!()
+}
+
 /// Implementation of the dump RPC. This returns the entire known `service_list`.
 fn dump(_call: &CallBody, _arg: &[u8], service_list: &mut rpcbind::RpcbindList) -> RpcResult {
     let data = service_list.serialize_alloc();
@@ -83,3 +99,27 @@ fn default_service_list() -> rpcbind::RpcbindList {
 
     rpcbind::RpcbindList { items: vec![item] }
 }
+
+/// Returns the service specified by `program` and `version` from the `service_list`, or none if
+/// there is no match.
+fn get_service(
+    program: u32,
+    version: u32,
+    service_list: &rpcbind::RpcbindList,
+) -> Option<&rpcbind::RpcService> {
+    for service in &service_list.items {
+        let service = &service.rpcb_map;
+
+        if program != service.prog {
+            continue;
+        }
+
+        if version != service.vers {
+            continue;
+        }
+
+        return Some(service);
+    }
+
+    return None;
+}