Rebase and update to top-of-main

Author: milseman

Sources/System/Sockets/SocketOperations.swift

@@ -82,10 +82,11 @@ extension SocketDescriptor {
 
   @usableFromInline
   internal func _bind(to address: SocketAddress) -> Result<(), Errno> {
-    let success = address.withUnsafeCInterop { addr, len in
-      system_bind(self.rawValue, addr, len)
+    nothingOrErrno(retryOnInterrupt: false) {
+      address.withUnsafeCInterop { addr, len in
+        system_bind(self.rawValue, addr, len)
+      }
     }
-    return nothingOrErrno(success)
   }
 
   /// Listen for connections on a socket.
@@ -103,7 +104,9 @@ extension SocketDescriptor {
 
   @usableFromInline
   internal func _listen(backlog: Int) -> Result<(), Errno> {
-    nothingOrErrno(system_listen(self.rawValue, CInt(backlog)))
+    nothingOrErrno(retryOnInterrupt: false) {
+      system_listen(self.rawValue, CInt(backlog))
+    }
   }
 
   /// Accept a connection on a socket.
@@ -189,10 +192,11 @@ extension SocketDescriptor {
 
   @usableFromInline
   internal func _connect(to address: SocketAddress) -> Result<(), Errno> {
-    let success = address.withUnsafeCInterop { addr, len in
-      system_connect(self.rawValue, addr, len)
+    nothingOrErrno(retryOnInterrupt: false) {
+      address.withUnsafeCInterop { addr, len in
+        system_connect(self.rawValue, addr, len)
+      }
     }
-    return nothingOrErrno(success)
   }
 
   /// Shutdown part of a full-duplex connection
@@ -205,7 +209,9 @@ extension SocketDescriptor {
 
   @usableFromInline
   internal func _shutdown(_ how: ShutdownKind) -> Result<(), Errno> {
-    nothingOrErrno(system_shutdown(self.rawValue, how.rawValue))
+    nothingOrErrno(retryOnInterrupt: false) {
+      system_shutdown(self.rawValue, how.rawValue)
+    }
   }
 
   // MARK: - Send and receive

Sources/System/Sockets/SocketOptions.swift

@@ -518,12 +518,13 @@ extension SocketDescriptor {
     into buffer: UnsafeMutableRawBufferPointer
   ) -> Result<Int, Errno> {
     var length = CInterop.SockLen(buffer.count)
-    let success = system_getsockopt(
-      self.rawValue,
-      level.rawValue,
-      option.rawValue,
-      buffer.baseAddress, &length)
-    return nothingOrErrno(success).map { _ in Int(length) }
+    return nothingOrErrno(retryOnInterrupt: false) {
+      system_getsockopt(
+        self.rawValue,
+        level.rawValue,
+        option.rawValue,
+        buffer.baseAddress, &length)
+    }.map { _ in Int(length) }
   }
 }
 
@@ -595,11 +596,12 @@ extension SocketDescriptor {
     _ option: Option,
     from buffer: UnsafeRawBufferPointer
   ) -> Result<Void, Errno> {
-    let success = system_setsockopt(
-      self.rawValue,
-      level.rawValue,
-      option.rawValue,
-      buffer.baseAddress, CInterop.SockLen(buffer.count))
-    return nothingOrErrno(success)
+    nothingOrErrno(retryOnInterrupt: false) {
+      system_setsockopt(
+        self.rawValue,
+        level.rawValue,
+        option.rawValue,
+        buffer.baseAddress, CInterop.SockLen(buffer.count))
+    }
   }
 }

Tests/SystemTests/SocketTest.swift

@@ -30,36 +30,34 @@ final class SocketTest: XCTestCase {
     let writeBufAddr = writeBuf.baseAddress
 
     let syscallTestCases: Array<MockTestCase> = [
-      MockTestCase(name: "socket", PF_INET6, SOCK_STREAM, 0, interruptable: true) {
+      MockTestCase(name: "socket", .interruptable, PF_INET6, SOCK_STREAM, 0) {
         retryOnInterrupt in
         _ = try SocketDescriptor.open(.ipv6, .stream, retryOnInterrupt: retryOnInterrupt)
       },
-      MockTestCase(name: "shutdown", rawSocket, SHUT_RD, interruptable: false) {
+      MockTestCase(name: "shutdown", .noInterrupt, rawSocket, SHUT_RD) {
         retryOnInterrupt in
         _ = try socket.shutdown(.read)
       },
-      MockTestCase(name: "listen", rawSocket, 999, interruptable: false) {
+      MockTestCase(name: "listen", .noInterrupt, rawSocket, 999) {
         retryOnInterrupt in
         _ = try socket.listen(backlog: 999)
       },
       MockTestCase(
-        name: "recv", rawSocket, bufAddr, bufCount, MSG_PEEK, interruptable: true
+        name: "recv", .interruptable, rawSocket, bufAddr, bufCount, MSG_PEEK
       ) {
         retryOnInterrupt in
         _ = try socket.receive(
           into: rawBuf, flags: .peek, retryOnInterrupt: retryOnInterrupt)
       },
       MockTestCase(
-        name: "send", rawSocket, writeBufAddr, bufCount, MSG_DONTROUTE,
-        interruptable: true
+        name: "send", .interruptable, rawSocket, writeBufAddr, bufCount, MSG_DONTROUTE
       ) {
         retryOnInterrupt in
         _ = try socket.send(
           writeBuf, flags: .doNotRoute, retryOnInterrupt: retryOnInterrupt)
       },
       MockTestCase(
-        name: "recvfrom", rawSocket, Wildcard(), Wildcard(), 42, Wildcard(), Wildcard(),
-        interruptable: true
+        name: "recvfrom", .interruptable, rawSocket, Wildcard(), Wildcard(), 42, Wildcard(), Wildcard()
       ) { retryOnInterrupt in
         var sender = SocketAddress()
         _ = try socket.receive(into: rawBuf,
@@ -68,8 +66,7 @@ final class SocketTest: XCTestCase {
                                retryOnInterrupt: retryOnInterrupt)
       },
       MockTestCase(
-        name: "sendto", rawSocket, Wildcard(), Wildcard(), 42, Wildcard(), Wildcard(),
-        interruptable: true
+        name: "sendto", .interruptable, rawSocket, Wildcard(), Wildcard(), 42, Wildcard(), Wildcard()
       ) { retryOnInterrupt in
         let recipient = SocketAddress(ipv4: .loopback, port: 123)
         _ = try socket.send(UnsafeRawBufferPointer(rawBuf),
@@ -78,8 +75,7 @@ final class SocketTest: XCTestCase {
                             retryOnInterrupt: retryOnInterrupt)
       },
       MockTestCase(
-        name: "recvmsg", rawSocket, Wildcard(), 42,
-        interruptable: true
+        name: "recvmsg", .interruptable, rawSocket, Wildcard(), 42
       ) { retryOnInterrupt in
         var sender = SocketAddress()
         var ancillary = SocketDescriptor.AncillaryMessageBuffer()
@@ -90,8 +86,7 @@ final class SocketTest: XCTestCase {
                                retryOnInterrupt: retryOnInterrupt)
       },
       MockTestCase(
-        name: "sendmsg", rawSocket, Wildcard(), 42,
-        interruptable: true
+        name: "sendmsg", .interruptable, rawSocket, Wildcard(), 42
       ) { retryOnInterrupt in
         let recipient = SocketAddress(ipv4: .loopback, port: 123)
         let ancillary = SocketDescriptor.AncillaryMessageBuffer()

Tests/SystemTests/TestingInfrastructure.swift

@@ -198,9 +198,9 @@ internal struct MockTestCase: TestCase {
       guard interruptBehavior != .noError else {
         do {
           try body(interruptable)
-          self.expectEqual(self.expected, mocking.trace.dequeue())
+          self.expectMatch(self.expected, mocking.trace.dequeue())
           try body(!interruptable)
-          self.expectEqual(self.expected, mocking.trace.dequeue())
+          self.expectMatch(self.expected, mocking.trace.dequeue())
         } catch {
           self.fail()
         }