tests: Add test where guest process connects to host using TCP (vsock)

Signed-off-by: Matej Hrica <[email protected]>

Author: mtjhrc

tests/test_cases/src/lib.rs

@@ -4,6 +4,9 @@ use test_vm_config::TestVmConfig;
 mod test_vsock_guest_connect;
 use test_vsock_guest_connect::TestVsockGuestConnect;
 
+mod test_tsi_tcp_guest_connect;
+use test_tsi_tcp_guest_connect::TestTsiTcpGuestConnect;
+
 pub fn test_cases() -> Vec<TestCase> {
     // Register your test here:
     vec![
@@ -22,6 +25,7 @@ pub fn test_cases() -> Vec<TestCase> {
             }),
         ),
         TestCase::new("vsock-guest-connect", Box::new(TestVsockGuestConnect)),
+        TestCase::new("tsi-tcp-guest-connect", Box::new(TestTsiTcpGuestConnect::new())),
     ]
 }
 
@@ -42,6 +46,7 @@ mod common;
 
 #[cfg(feature = "host")]
 mod krun;
+mod tcp_tester;
 
 #[host]
 #[derive(Clone, Debug)]

tests/test_cases/src/tcp_tester.rs

@@ -0,0 +1,62 @@
+use std::io::{ErrorKind, Read, Write};
+use std::mem;
+use std::net::{IpAddr, Ipv4Addr, SocketAddr, SocketAddrV4, TcpListener, TcpStream};
+use std::time::Duration;
+
+fn expect_msg(stream: &mut TcpStream, expected: &[u8]) {
+    let mut buf = vec![0; expected.len()];
+    stream.read_exact(&mut buf[..]).unwrap();
+    assert_eq!(&buf[..], expected);
+}
+
+fn expect_wouldblock(stream: &mut TcpStream) {
+    stream.set_nonblocking(true).unwrap();
+    let err = stream.read(&mut [0u8; 1]).unwrap_err();
+    stream.set_nonblocking(false).unwrap();
+    assert_eq!(err.kind(), ErrorKind::WouldBlock);
+}
+
+fn set_timeouts(stream: &mut TcpStream) {
+    stream
+        .set_read_timeout(Some(Duration::from_millis(500)))
+        .unwrap();
+    stream
+        .set_write_timeout(Some(Duration::from_millis(500)))
+        .unwrap();
+}
+
+#[derive(Debug, Copy, Clone)]
+pub struct TcpTester {
+    port: u16,
+}
+
+impl TcpTester {
+    pub const fn new(port: u16) -> Self {
+        Self { port }
+    }
+
+    pub fn create_server_socket(&self) -> TcpListener {
+        TcpListener::bind(SocketAddrV4::new(Ipv4Addr::new(0, 0, 0, 0), self.port)).unwrap()
+    }
+
+    pub fn run_server(&self, listener: TcpListener) {
+        let (mut stream, _addr) = listener.accept().unwrap();
+        set_timeouts(&mut stream);
+        stream.write_all(b"ping!").unwrap();
+        expect_msg(&mut stream, b"pong!");
+        expect_wouldblock(&mut stream);
+        stream.write_all(b"bye!").unwrap();
+        // We leak the file descriptor for now, since there is no easy way to close it on libkrun exit
+        mem::forget(listener);
+    }
+
+    pub fn run_client(&self) {
+        let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), self.port);
+        let mut stream = TcpStream::connect(&addr).unwrap();
+        set_timeouts(&mut stream);
+        expect_msg(&mut stream, b"ping!");
+        expect_wouldblock(&mut stream);
+        stream.write_all(b"pong!").unwrap();
+        expect_msg(&mut stream, b"bye!");
+    }
+}

tests/test_cases/src/test_tsi_tcp_guest_connect.rs

@@ -0,0 +1,53 @@
+use crate::tcp_tester::TcpTester;
+use macros::{guest, host};
+
+const PORT: u16 = 8000;
+
+pub struct TestTsiTcpGuestConnect {
+    tcp_tester: TcpTester,
+}
+
+impl TestTsiTcpGuestConnect {
+    pub fn new() -> TestTsiTcpGuestConnect {
+        Self {
+            tcp_tester: TcpTester::new(PORT),
+        }
+    }
+}
+
+#[host]
+mod host {
+    use super::*;
+
+    use crate::common::setup_fs_and_enter;
+    use crate::{krun_call, krun_call_u32};
+    use crate::{Test, TestSetup};
+    use krun_sys::*;
+    use std::thread;
+
+    impl Test for TestTsiTcpGuestConnect {
+        fn start_vm(self: Box<Self>, test_setup: TestSetup) -> anyhow::Result<()> {
+            let listener = self.tcp_tester.create_server_socket();
+            thread::spawn(move || self.tcp_tester.run_server(listener));
+            unsafe {
+                let ctx = krun_call_u32!(krun_create_ctx())?;
+                krun_call!(krun_set_vm_config(ctx, 1, 512))?;
+                setup_fs_and_enter(ctx, test_setup)?;
+            }
+            Ok(())
+        }
+    }
+}
+
+#[guest]
+mod guest {
+    use super::*;
+    use crate::Test;
+
+    impl Test for TestTsiTcpGuestConnect {
+        fn in_guest(self: Box<Self>) {
+            self.tcp_tester.run_client();
+            println!("OK");
+        }
+    }
+}