WIP: accept, connect, bind

Author: milseman

Sources/System/Internals/Syscalls.swift

@@ -147,7 +147,10 @@ internal func system_send(
 }
 
 internal func system_recv(
-  _ socket: Int32, _ buffer: UnsafeMutableRawPointer!, _ len: Int, _ flags: Int32
+  _ socket: Int32,
+  _ buffer: UnsafeMutableRawPointer!,
+  _ len: Int,
+  _ flags: Int32
 ) -> Int {
   #if ENABLE_MOCKING
   if mockingEnabled { return _mockInt(socket, buffer, len, flags) }
@@ -197,12 +200,41 @@ internal func system_inet_ntop(
 }
 
 internal func system_inet_pton(
-  _ af: CInt,
-  _ src: UnsafePointer<CChar>,
-  _ dst: UnsafeMutableRawPointer
+  _ af: CInt, _ src: UnsafePointer<CChar>, _ dst: UnsafeMutableRawPointer
 ) -> CInt {
   #if ENABLE_MOCKING
   if mockingEnabled { return _mock(af, src, dst) }
   #endif
   return inet_pton(af, src, dst)
 }
+
+internal func system_bind(
+  _ socket: CInt, _ addr: UnsafePointer<sockaddr>!, _ len: socklen_t
+) -> CInt {
+  #if ENABLE_MOCKING
+  if mockingEnabled { return _mock(socket, addr, len) }
+  #endif
+  return bind(socket, addr, len)
+}
+
+internal func system_connect(
+  _ socket: CInt, _ addr: UnsafePointer<sockaddr>!, _ len: socklen_t
+) -> CInt {
+  #if ENABLE_MOCKING
+  if mockingEnabled { return _mock(socket, addr, len) }
+  #endif
+  return connect(socket, addr, len)
+}
+
+internal func system_accept(
+  _ socket: CInt,
+  _ addr: UnsafeMutablePointer<sockaddr>!,
+  _ len: UnsafeMutablePointer<socklen_t>!
+) -> CInt {
+  #if ENABLE_MOCKING
+  if mockingEnabled { return _mock(socket, addr, len) }
+  #endif
+  return accept(socket, addr, len)
+}
+
+

Sources/System/Sockets/SocketOperations.swift

@@ -142,6 +142,60 @@ extension SocketDescriptor {
       system_recv(self.rawValue, buffer.baseAddress!, buffer.count, flags.rawValue)
     }
   }
+
+  /// Accept a connection on a socket
+  ///
+  /// The corresponding C function is `accept`
+  @_alwaysEmitIntoClient
+  public func accept(retryOnInterrupt: Bool = true) throws -> SocketDescriptor {
+    try _accept(retryOnInterrupt: retryOnInterrupt).get()
+  }
+
+  @usableFromInline
+  internal func _accept(
+    retryOnInterrupt: Bool = true
+  ) -> Result<SocketDescriptor, Errno> {
+    let fd = valueOrErrno(retryOnInterrupt: retryOnInterrupt) {
+      system_accept(self.rawValue, nil, nil)
+    }
+    return fd.map { SocketDescriptor(rawValue: $0) }
+  }
+
+  // TODO: acceptAndSockaddr or something that (tries to) returns the sockaddr
+  // at least, for sockaddrs up to some sane length
+
+  /// Bind a name to a socket
+  ///
+  /// The corresponding C function is `bind`
+  @_alwaysEmitIntoClient
+  public func bind(to address: SocketAddress) throws {
+    try _bind(to: address).get()
+  }
+
+  @usableFromInline
+  internal func _bind(to address: SocketAddress) -> Result<(), Errno> {
+    let success = address.withRawAddress { addr, len in
+      system_bind(self.rawValue, addr, len)
+    }
+    return nothingOrErrno(success)
+  }
+
+  /// Initiate a connection on a socket
+  ///
+  /// The corresponding C function is `connect`
+  @_alwaysEmitIntoClient
+  public func connect(to address: SocketAddress) throws {
+    try _connect(to: address).get()
+  }
+
+  @usableFromInline
+  internal func _connect(to address: SocketAddress) -> Result<(), Errno> {
+    let success = address.withRawAddress { addr, len in
+      system_connect(self.rawValue, addr, len)
+    }
+    return nothingOrErrno(success)
+  }
+
 }
 
 // MARK: - Forward FileDescriptor methods