From 1df979235a5b9c36f0c6bbd32d80c715325a4009 Mon Sep 17 00:00:00 2001
From: Jonas Maier <jonas@x77.dev>
Date: Mon, 9 Mar 2026 19:01:43 +0100
Subject: export fun client

---
 src/export_fun.rs    | 29 ++++++++++++++--------
 src/main.rs          |  1 +
 src/serialization.rs | 69 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 89 insertions(+), 10 deletions(-)
 create mode 100644 src/serialization.rs

diff --git a/src/export_fun.rs b/src/export_fun.rs
index 934b81c..006bec3 100644
--- a/src/export_fun.rs
+++ b/src/export_fun.rs
@@ -5,6 +5,7 @@ use std::env::current_exe;
 use std::ffi::OsStr;
 use std::fs;
 use std::io;
+use std::io::Read;
 use std::io::Write;
 use std::os::unix::ffi::OsStrExt;
 use std::os::unix::fs::symlink;
@@ -22,23 +23,31 @@ fn handle_server(session: Arc<Mutex<Session>>, stream: UnixStream) -> io::Result
     todo!()
 }
 
-fn handle_client(stream: UnixStream) -> io::Result<()> {
+fn handle_client(mut stream: UnixStream) -> io::Result<()> {
     println!("uhh hi");
-    todo!()
-}
-
-fn user_function_res(sock: &OsStr) -> io::Result<()> {
-    let sock = UnixStream::connect(sock)?;
 
+    // give up all my file descriptors descriptors
     let mut ancillary_buffer = [0; 128];
     let mut ancillary = SocketAncillary::new(&mut ancillary_buffer[..]);
     ancillary.add_fds(&[0, 1, 2]);
 
-    let buf = [0; 8];
-    let mut bufs = &mut [io::IoSlice::new(&buf[..])][..];
-    sock.send_vectored_with_ancillary(bufs, &mut ancillary)?;
+    // cli params
+    let buf = crate::serialization::serialize_cli_args();
+    let bufs = &mut [io::IoSlice::new(&buf[..])][..];
 
-    todo!()
+    // send
+    stream.send_vectored_with_ancillary(bufs, &mut ancillary)?;
+
+    // recv exit code
+    let mut exit_buf = [0; 4];
+    let res = stream.read_exact(&mut exit_buf);
+
+    let exit_code = match res {
+        Ok(_) => i32::from_le_bytes(exit_buf),
+        Err(_) => -2,
+    };
+
+    exit(exit_code)
 }
 
 pub fn maybe_run_defined_function() {
diff --git a/src/main.rs b/src/main.rs
index 7196f58..1d8806a 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -24,6 +24,7 @@ pub mod parse;
 pub mod raw;
 pub mod reload;
 pub mod run;
+pub mod serialization;
 
 use linebuf::LineBuf;
 use raw::*;
diff --git a/src/serialization.rs b/src/serialization.rs
new file mode 100644
index 0000000..8dc3d99
--- /dev/null
+++ b/src/serialization.rs
@@ -0,0 +1,69 @@
+use std::{env, os::unix::ffi::OsStrExt};
+
+use crate::BString;
+
+fn w_u32(out: &mut Vec<u8>, x: u32) {
+    for b in x.to_le_bytes() {
+        out.push(b);
+    }
+}
+
+fn w_u8s(out: &mut Vec<u8>, b: &[u8]) {
+    w_u32(out, b.len() as u32);
+    out.extend_from_slice(b);
+}
+
+fn w_u8ss(out: &mut Vec<u8>, b: &[&[u8]]) {
+    w_u32(out, b.len() as u32);
+    for c in b {
+        w_u8s(out, c);
+    }
+}
+
+pub enum Error {
+    Overrun,
+}
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+fn r_u32(buf: &mut &[u8]) -> Result<u32> {
+    if buf.len() < 4 {
+        Err(Error::Overrun)?;
+    }
+    let x = u32::from_le_bytes([buf[0], buf[1], buf[2], buf[3]]);
+    *buf = &buf[4..];
+    Ok(x)
+}
+
+fn r_u8s(buf: &mut &[u8]) -> Result<Vec<u8>> {
+    let len = r_u32(buf)? as usize;
+    if len > buf.len() {
+        Err(Error::Overrun)?;
+    }
+    let x = buf[..len].to_vec();
+    *buf = &buf[len..];
+    Ok(x)
+}
+
+fn r_u8ss(buf: &mut &[u8]) -> Result<Vec<Vec<u8>>> {
+    let len = r_u32(buf)? as usize;
+    let mut out = Vec::with_capacity(len);
+    for _ in 0..len {
+        out.push(r_u8s(buf)?);
+    }
+    Ok(out)
+}
+
+pub fn serialize_cli_args() -> Vec<u8> {
+    let args: Vec<Vec<u8>> = env::args_os()
+        .map(|a| a.as_os_str().as_bytes().to_vec())
+        .collect();
+    let args: Vec<&[u8]> = args.iter().map(|v| v.as_ref()).collect();
+    let mut out = Vec::new();
+    w_u8ss(&mut out, &args);
+    out
+}
+
+pub fn deserialize_cli_args(mut buf: &[u8]) -> Result<Vec<BString>> {
+    r_u8ss(&mut buf)
+}
-- 
cgit v1.2.3