Add coordinator-owned interactive session terminals

crates/lazaret-host-coordinator/src/sandbox_init.rs

@@ -1,6 +1,12 @@
 use std::ffi::{OsStr, OsString};
+use std::io;
+use std::os::unix::ffi::OsStrExt as _;
+
+use lazaret_linux::process::{TargetCommand, exec_target};
 
 pub const PRIVATE_SANDBOX_INIT_ROLE: &str = "--lazaret-private-sandbox-init-v1";
+pub const PRIVATE_SESSION_EXEC_ROLE: &str = "--lazaret-private-session-exec-v1";
+pub const PRIVATE_SESSION_IDENTITY_ROLE: &str = "--lazaret-private-session-identity-v1";
 
 #[must_use]
 pub fn is_private_sandbox_init_role(arguments: &[OsString]) -> bool {
@@ -8,13 +14,76 @@ pub fn is_private_sandbox_init_role(arguments: &[OsString]) -> bool {
 }
 
 #[must_use]
-pub fn dispatch_private_sandbox_init(arguments: &[OsString]) -> bool {
-    if !is_private_sandbox_init_role(arguments) {
-        return false;
+pub fn dispatch_private_sandbox_init(arguments: &[OsString]) -> Option<io::Result<()>> {
+    if is_private_sandbox_init_role(arguments) {
+        loop {
+            std::thread::park();
+        }
     }
-    loop {
-        std::thread::park();
+    if arguments
+        .first()
+        .is_some_and(|argument| argument == PRIVATE_SESSION_EXEC_ROLE)
+    {
+        return Some(run_session_exec(&arguments[1..]));
     }
+    if arguments
+        .first()
+        .is_some_and(|argument| argument == PRIVATE_SESSION_IDENTITY_ROLE)
+    {
+        return Some(report_session_identity(&arguments[1..]));
+    }
+    None
+}
+
+fn run_session_exec(arguments: &[OsString]) -> io::Result<()> {
+    let (separator, argv) = arguments
+        .split_first()
+        .filter(|(separator, argv)| {
+            separator == &OsStr::new("--")
+                && !argv.is_empty()
+                && !argv[0].is_empty()
+                && argv
+                    .iter()
+                    .all(|argument| !argument.as_bytes().contains(&0))
+        })
+        .ok_or_else(|| io::Error::other("session exec requires -- and a nonempty argv"))?;
+    let _ = separator;
+    rustix::process::setsid()?;
+    let target = argv[1..]
+        .iter()
+        .cloned()
+        .fold(TargetCommand::new(argv[0].clone()), TargetCommand::argument);
+    Err(exec_target(target))
+}
+
+fn report_session_identity(arguments: &[OsString]) -> io::Result<()> {
+    let pid = match arguments {
+        [pid] => pid
+            .to_str()
+            .and_then(|value| value.parse::<u32>().ok())
+            .filter(|pid| *pid > 0)
+            .ok_or_else(|| io::Error::other("session identity PID is invalid"))?,
+        _ => return Err(io::Error::other("session identity requires one PID")),
+    };
+    let stat = std::fs::read_to_string(format!("/proc/{pid}/stat"))?;
+    let close = stat
+        .rfind(')')
+        .ok_or_else(|| io::Error::other("guest process stat is malformed"))?;
+    let observed_pid = stat[..close]
+        .split_once(' ')
+        .and_then(|(pid, _)| pid.parse::<u32>().ok())
+        .ok_or_else(|| io::Error::other("guest process stat PID is malformed"))?;
+    let fields = stat[close + 1..].split_whitespace().collect::<Vec<_>>();
+    let group = fields
+        .get(2)
+        .and_then(|value| value.parse::<u32>().ok())
+        .ok_or_else(|| io::Error::other("guest process stat group is malformed"))?;
+    let start_ticks = fields
+        .get(19)
+        .and_then(|value| value.parse::<u64>().ok())
+        .ok_or_else(|| io::Error::other("guest process stat start is malformed"))?;
+    println!("{observed_pid} {start_ticks} {group}");
+    Ok(())
 }
 
 #[cfg(test)]
@@ -35,4 +104,25 @@ mod tests {
             "--private-sandbox-init"
         )]));
     }
+
+    #[test]
+    fn private_session_roles_are_shape_separated() {
+        assert!(dispatch_private_sandbox_init(&[]).is_none());
+        assert!(
+            dispatch_private_sandbox_init(&[
+                OsString::from(PRIVATE_SESSION_EXEC_ROLE),
+                OsString::from("missing-separator"),
+            ])
+            .unwrap()
+            .is_err()
+        );
+        assert!(
+            dispatch_private_sandbox_init(&[
+                OsString::from(PRIVATE_SESSION_IDENTITY_ROLE),
+                OsString::from("not-a-pid"),
+            ])
+            .unwrap()
+            .is_err()
+        );
+    }
 }