Merge branch 'main' into asonix/jitterbug

src/net.rs

@@ -1,7 +1,7 @@
 use rustix::{
     fd::AsFd,
     io::OwnedFd,
-    net::{AddressFamily, Protocol, SocketFlags, SocketType},
+    net::{AcceptFlags, AddressFamily, Protocol, SocketFlags, SocketType},
 };
 use std::net::{IpAddr, SocketAddrV4, SocketAddrV6};
 
@@ -15,29 +15,59 @@ pub struct TcpStreamBuilder {
     inner: OwnedFd,
 }
 
-impl TcpStreamBuilder {
-    pub fn try_finish(self) -> rustix::io::Result<Result<TcpStream, TcpStreamBuilder>> {
-        let res = match self.ip {
-            IpAddr::V4(v4) => {
-                let sock_addr = SocketAddrV4::new(v4, self.port);
+pub struct TcpListener {
+    inner: OwnedFd,
+}
 
-                rustix::net::connect_v4(&self.inner, &sock_addr)
+pub struct TcpListenerBuilder {
+    ip: IpAddr,
+    port: u16,
+    inner: OwnedFd,
+}
+
+impl TcpListener {
+    pub fn try_accept(&self) -> rustix::io::Result<Option<TcpStream>> {
+        match rustix::net::accept_with(&self.inner, AcceptFlags::NONBLOCK) {
+            Ok(inner) => Ok(Some(TcpStream { inner })),
+            Err(e) if e == rustix::io::Error::WOULDBLOCK || e == rustix::io::Error::AGAIN => {
+                Ok(None)
             }
-            IpAddr::V6(v6) => {
-                let flowinfo = 0;
-                let scope_id = 0;
-                let sock_addr = SocketAddrV6::new(v6, self.port, flowinfo, scope_id);
-
-                rustix::net::connect_v6(&self.inner, &sock_addr)
-            }
-        };
-
-        match res {
-            Ok(()) => Ok(Ok(TcpStream { inner: self.inner })),
-            Err(e) if e == rustix::io::Error::INPROGRESS => Ok(Err(self)),
             Err(e) => Err(e),
         }
     }
+
+    pub fn bind(ip: IpAddr, port: u16) -> rustix::io::Result<TcpListenerBuilder> {
+        match ip {
+            IpAddr::V4(_) => {
+                let sock = rustix::net::socket_with(
+                    AddressFamily::INET,
+                    SocketType::STREAM,
+                    SocketFlags::NONBLOCK,
+                    Protocol::TCP,
+                )?;
+
+                Ok(TcpListenerBuilder {
+                    ip,
+                    port,
+                    inner: sock,
+                })
+            }
+            IpAddr::V6(_) => {
+                let sock = rustix::net::socket_with(
+                    AddressFamily::INET6,
+                    SocketType::STREAM,
+                    SocketFlags::NONBLOCK,
+                    Protocol::TCP,
+                )?;
+
+                Ok(TcpListenerBuilder {
+                    ip,
+                    port,
+                    inner: sock,
+                })
+            }
+        }
+    }
 }
 
 impl TcpStream {
@@ -75,14 +105,76 @@ impl TcpStream {
     }
 }
 
+impl TcpListenerBuilder {
+    pub fn try_finish(self) -> rustix::io::Result<Result<TcpListener, TcpListenerBuilder>> {
+        let res = match self.ip {
+            IpAddr::V4(v4) => {
+                let sock_addr = SocketAddrV4::new(v4, self.port);
+
+                rustix::net::bind_v4(&self.inner, &sock_addr)
+            }
+            IpAddr::V6(v6) => {
+                let flowinfo = 0;
+                let scope_id = 0;
+                let sock_addr = SocketAddrV6::new(v6, self.port, flowinfo, scope_id);
+
+                rustix::net::bind_v6(&self.inner, &sock_addr)
+            }
+        };
+
+        match res {
+            Ok(()) => Ok(Ok(TcpListener { inner: self.inner })),
+            Err(e) if e == rustix::io::Error::INPROGRESS => Ok(Err(self)),
+            Err(e) => Err(e),
+        }
+    }
+}
+
+impl TcpStreamBuilder {
+    pub fn try_finish(self) -> rustix::io::Result<Result<TcpStream, TcpStreamBuilder>> {
+        let res = match self.ip {
+            IpAddr::V4(v4) => {
+                let sock_addr = SocketAddrV4::new(v4, self.port);
+
+                rustix::net::connect_v4(&self.inner, &sock_addr)
+            }
+            IpAddr::V6(v6) => {
+                let flowinfo = 0;
+                let scope_id = 0;
+                let sock_addr = SocketAddrV6::new(v6, self.port, flowinfo, scope_id);
+
+                rustix::net::connect_v6(&self.inner, &sock_addr)
+            }
+        };
+
+        match res {
+            Ok(()) => Ok(Ok(TcpStream { inner: self.inner })),
+            Err(e) if e == rustix::io::Error::INPROGRESS => Ok(Err(self)),
+            Err(e) => Err(e),
+        }
+    }
+}
+
 impl AsFd for TcpStream {
     fn as_fd(&self) -> rustix::fd::BorrowedFd<'_> {
         self.inner.as_fd()
     }
 }
 
+impl AsFd for TcpListener {
+    fn as_fd(&self) -> rustix::fd::BorrowedFd<'_> {
+        self.inner.as_fd()
+    }
+}
+
 impl AsFd for TcpStreamBuilder {
     fn as_fd(&self) -> rustix::fd::BorrowedFd<'_> {
         self.inner.as_fd()
     }
 }
+
+impl AsFd for TcpListenerBuilder {
+    fn as_fd(&self) -> rustix::fd::BorrowedFd<'_> {
+        self.inner.as_fd()
+    }
+}