WIP: send/recv

Author: milseman

Sources/System/Internals/Syscalls.swift

@@ -136,3 +136,21 @@ internal func system_listen(_ socket: CInt, _ backlog: CInt) -> CInt {
   #endif
   return listen(socket, backlog)
 }
+
+internal func system_send(
+  _ socket: Int32, _ buffer: UnsafeRawPointer!, _ len: Int, _ flags: Int32
+) -> Int {
+  #if ENABLE_MOCKING
+  if mockingEnabled { return _mockInt(socket, buffer, len, flags) }
+  #endif
+  return send(socket, buffer, len, flags)
+}
+
+internal func system_recv(
+  _ socket: Int32, _ buffer: UnsafeMutableRawPointer!, _ len: Int, _ flags: Int32
+) -> Int {
+  #if ENABLE_MOCKING
+  if mockingEnabled { return _mockInt(socket, buffer, len, flags) }
+  #endif
+  return recv(socket, buffer, len, flags)
+}

Sources/System/Sockets/SocketDescriptor.swift

@@ -150,8 +150,7 @@ extension SocketDescriptor {
 
   // TODO: option flags (SO_DEBUG)?
 
-  // TODO: address families? Should we jus do INET and INET6?
-
+  // TODO:
   @frozen
   public struct MessageFlags: OptionSet {
     @_alwaysEmitIntoClient
@@ -163,6 +162,9 @@ extension SocketDescriptor {
     @_alwaysEmitIntoClient
     private init(_ raw: CInt) { self.init(rawValue: raw) }
 
+    @_alwaysEmitIntoClient
+    public static var none: MessageFlags { MessageFlags(0) }
+
     // MSG_OOB: process out-of-band data
     @_alwaysEmitIntoClient
     public static var outOfBand: MessageFlags { MessageFlags(_MSG_OOB) }
@@ -179,9 +181,7 @@ extension SocketDescriptor {
     @_alwaysEmitIntoClient
     public static var waitForAll: MessageFlags { MessageFlags(_MSG_WAITALL) }
 
-    // TODO: MSG_EOR MSG_TRUNC MSG_CTRUNC MSG_DONTWAIT MSG_EOF MSG_WAITSTREAM
-    // TODO: MSG_FLUSH MSG_HOLD MSG_SEND MSG_HAVEMORE MSG_RCVMORE MSG_NEEDSA
-    // TODO: MSG_NOSIGNAL
+    // TODO: any of the others? I'm going off of man pagees...
   }
 
   public struct ShutdownKind: RawRepresentable, Hashable, Codable {

Sources/System/Sockets/SocketOperations.swift

@@ -79,7 +79,69 @@ extension SocketDescriptor {
     nothingOrErrno(system_listen(self.rawValue, CInt(backlog)))
   }
 
+  /// Send a message from a socket
+  ///
+  /// - Parameters:
+  ///   - buffear: The region of memory that contains the data being sent.
+  ///   - flags: see `send(2)`
+  ///   - retryOnInterrupt: Whether to retry the send operation
+  ///     if it throws ``Errno/interrupted``.
+  ///     The default is `true`.
+  ///     Pass `false` to try only once and throw an error upon interruption.
+  /// - Returns: The number of bytes that were sent.
+  ///
+  /// The corresponding C function is `send`
+  public func send(
+    _ buffer: UnsafeRawBufferPointer,
+    flags: MessageFlags = .none,
+    retryOnInterrupt: Bool = true
+  ) throws -> Int {
+    try _send(buffer, flags: flags, retryOnInterrupt: retryOnInterrupt).get()
+  }
 
+  @usableFromInline
+  internal func _send(
+    _ buffer: UnsafeRawBufferPointer,
+    flags: MessageFlags,
+    retryOnInterrupt: Bool
+  ) -> Result<Int, Errno> {
+    valueOrErrno(retryOnInterrupt: retryOnInterrupt) {
+      system_send(self.rawValue, buffer.baseAddress!, buffer.count, flags.rawValue)
+    }
+  }
+
+  /// Receive a message from a socket
+  ///
+  /// - Parameters:
+  ///   - buffer: The region of memory to receive into.
+  ///   - flags: see `recv(2)`
+  ///   - retryOnInterrupt: Whether to retry the receive operation
+  ///     if it throws ``Errno/interrupted``.
+  ///     The default is `true`.
+  ///     Pass `false` to try only once and throw an error upon interruption.
+  /// - Returns: The number of bytes that were received.
+  ///
+  /// The corresponding C function is `recv`
+  public func receive(
+    into buffer: UnsafeMutableRawBufferPointer,
+    flags: MessageFlags = .none,
+    retryOnInterrupt: Bool = true
+  ) throws -> Int {
+    try _receive(
+      into: buffer, flags: flags, retryOnInterrupt: retryOnInterrupt
+    ).get()
+  }
+
+  @usableFromInline
+  internal func _receive(
+    into buffer: UnsafeMutableRawBufferPointer,
+    flags: MessageFlags,
+    retryOnInterrupt: Bool
+  ) -> Result<Int, Errno> {
+    valueOrErrno(retryOnInterrupt: retryOnInterrupt) {
+      system_recv(self.rawValue, buffer.baseAddress!, buffer.count, flags.rawValue)
+    }
+  }
 }
 
 // MARK: - Forward FileDescriptor methods

Tests/SystemTests/SocketTest.swift

@@ -22,6 +22,12 @@ final class SocketTest: XCTestCase {
 
     let socket = SocketDescriptor(rawValue: 3)
     let rawSocket = socket.rawValue
+    let rawBuf = UnsafeMutableRawBufferPointer.allocate(byteCount: 100, alignment: 4)
+    defer { rawBuf.deallocate() }
+    let bufAddr = rawBuf.baseAddress
+    let bufCount = rawBuf.count
+    let writeBuf = UnsafeRawBufferPointer(rawBuf)
+    let writeBufAddr = writeBuf.baseAddress
 
     let syscallTestCases: Array<MockTestCase> = [
       MockTestCase(name: "socket", PF_INET6, SOCK_STREAM, 0, interruptable: true) {
@@ -36,6 +42,21 @@ final class SocketTest: XCTestCase {
         retryOnInterrupt in
       _ = try socket.listen(backlog: 999)
       },
+      MockTestCase(
+        name: "recv", rawSocket, bufAddr, bufCount, MSG_PEEK, interruptable: true
+      ) {
+        retryOnInterrupt in
+      _ = try socket.receive(
+        into: rawBuf, flags: .peek, retryOnInterrupt: retryOnInterrupt)
+      },
+      MockTestCase(
+        name: "send", rawSocket, writeBufAddr, bufCount, MSG_DONTROUTE,
+        interruptable: true
+      ) {
+        retryOnInterrupt in
+      _ = try socket.send(
+        writeBuf, flags: .doNotRoute, retryOnInterrupt: retryOnInterrupt)
+      },
     ]
 
     syscallTestCases.forEach { $0.runAllTests() }