Merge pull request #19 from zamderax/fix/ipv4-loopback-byte-order

Fix IPv4Address.loopback byte order issue and modernize test suite

Author: colemancda

Package.swift

@@ -25,6 +25,10 @@ var package = Package(
         .package(
             url: "https://github.com/apple/swift-system",
             from: "1.5.0"
+        ),
+        .package(
+            url: "https://github.com/apple/swift-log.git",
+            from: "1.0.0"
         )
     ],
     targets: [
@@ -43,7 +47,13 @@ var package = Package(
         ),
         .testTarget(
             name: "SocketTests",
-            dependencies: ["Socket"]
+            dependencies: [
+                "Socket",
+                .product(
+                    name: "Logging",
+                    package: "swift-log"
+                )
+            ]
         )
     ]
 )

Sources/Socket/System/Constants.swift

@@ -174,7 +174,7 @@ internal var _INADDR_ANY: CInterop.IPv4Address { CInterop.IPv4Address(s_addr: nu
 #endif
 
 @_alwaysEmitIntoClient
-internal var _INADDR_LOOPBACK: CInterop.IPv4Address { CInterop.IPv4Address(s_addr: numericCast(INADDR_LOOPBACK)) }
+internal var _INADDR_LOOPBACK: CInterop.IPv4Address { CInterop.IPv4Address(s_addr: UInt32(networkOrder: numericCast(INADDR_LOOPBACK))) }
 
 @_alwaysEmitIntoClient
 internal var _INADDR6_ANY: CInterop.IPv6Address { in6addr_any }

Tests/SocketTests/SocketTests.swift

@@ -1,18 +1,27 @@
 import Foundation
-import XCTest
+import Testing
 import SystemPackage
+import Logging
 @testable import Socket
 
-final class SocketTests: XCTestCase {
+@Suite("Socket Tests")
+struct SocketTests {
+    
+    static let logger = Logger(label: "logger") { label in
+        var handler = StreamLogHandler.standardOutput(label: label)
+        // handler.logLevel = .debug
+        return handler
+    }
 
     #if os(Linux)
-    func _testUnixSocket() async throws {
+    @Test("Unix Socket Communication")
+    func testUnixSocket() async throws {
         let address = UnixSocketAddress(path: FilePath("/tmp/testsocket.sock"))
-        NSLog("Using path \(address.path.description)")
+        Self.logger.info("Using path \(address.path.description)")
         let socketA = try await Socket(
             UnixProtocol.raw
         )
-        NSLog("Created socket A")
+        Self.logger.info("Created socket A")
         let option: GenericSocketOption.ReuseAddress = true
         try socketA.fileDescriptor.setSocketOption(option)
         do { try socketA.fileDescriptor.bind(address) }
@@ -22,57 +31,58 @@ final class SocketTests: XCTestCase {
         let socketB = try await Socket(
             UnixProtocol.raw
         )
-        NSLog("Created socket B")
+        Self.logger.info("Created socket B")
         try socketB.fileDescriptor.setSocketOption(option)
         try socketB.fileDescriptor.bind(address)
         defer { Task { await socketB.close() } }
 
         let data = Data("Test \(UUID())".utf8)
 
         try await socketA.write(data)
-        NSLog("Socket A wrote data")
+        Self.logger.info("Socket A wrote data")
         let read = try await socketB.read(data.count)
-        NSLog("Socket B read data")
-        XCTAssertEqual(data, read)
+        Self.logger.info("Socket B read data")
+        #expect(data == read)
     }
     #endif
 
+    @Test("IPv4 TCP Socket Communication")
     func testIPv4TCPSocket() async throws {
         let port = UInt16.random(in: 8080 ..< .max)
-        print("Using port \(port)")
+        Self.logger.info("Using port \(port)")
         let address = IPv4SocketAddress(address: .any, port: port)
         let data = Data("Test \(UUID())".utf8)
         let server = try await Socket(
             IPv4Protocol.tcp,
             bind: address
         )
         let newConnectionTask = Task {
-            XCTAssertEqual(try server.fileDescriptor.address(IPv4SocketAddress.self), address)
-            NSLog("Server: Created server socket \(server.fileDescriptor)")
+            #expect(try server.fileDescriptor.address(IPv4SocketAddress.self) == address)
+            Self.logger.info("Server: Created server socket \(server.fileDescriptor)")
             try await server.listen()
 
-            NSLog("Server: Waiting on incoming connection")
+            Self.logger.info("Server: Waiting on incoming connection")
             let newConnection = try await server.accept()
-            NSLog("Server: Got incoming connection \(newConnection.fileDescriptor)")
-            XCTAssertEqual(try newConnection.fileDescriptor.address(IPv4SocketAddress.self).address.rawValue, "127.0.0.1")
+            Self.logger.info("Server: Got incoming connection \(newConnection.fileDescriptor)")
+            #expect(try newConnection.fileDescriptor.address(IPv4SocketAddress.self).address.rawValue == "127.0.0.1")
             let eventsTask = Task {
                 var events = [Socket.Event]()
                 for try await event in newConnection.event {
                     events.append(event)
-                    NSLog("Server Connection: \(event)")
+                    Self.logger.info("Server Connection: \(event)")
                 }
                 return events
             }
             try await Task.sleep(nanoseconds: 10_000_000)
             let _ = try await newConnection.write(data)
-            NSLog("Server: Wrote outgoing data")
+            Self.logger.info("Server: Wrote outgoing data")
             return try await eventsTask.value
         }
         let serverEventsTask = Task {
             var events = [Socket.Event]()
             for try await event in server.event {
                 events.append(event)
-                NSLog("Server: \(event)")
+                Self.logger.info("Server: \(event)")
             }
             return events
         }
@@ -84,39 +94,40 @@ final class SocketTests: XCTestCase {
             var events = [Socket.Event]()
             for try await event in client.event {
                 events.append(event)
-                NSLog("Client: \(event)")
+                Self.logger.info("Client: \(event)")
             }
             return events
         }
-        XCTAssertEqual(try client.fileDescriptor.address(IPv4SocketAddress.self).address, .any)
-        NSLog("Client: Created client socket \(client.fileDescriptor)")
+        #expect(try client.fileDescriptor.address(IPv4SocketAddress.self).address == .any)
+        Self.logger.info("Client: Created client socket \(client.fileDescriptor)")
 
-        NSLog("Client: Will connect to server")
+        Self.logger.info("Client: Will connect to server")
         do { try await client.connect(to: address) }
         catch Errno.socketIsConnected { }
-        NSLog("Client: Connected to server")
-        XCTAssertEqual(try client.fileDescriptor.address(IPv4SocketAddress.self).address.rawValue, "127.0.0.1")
-        XCTAssertEqual(try client.fileDescriptor.peerAddress(IPv4SocketAddress.self).address.rawValue, "127.0.0.1")
+        Self.logger.info("Client: Connected to server")
+        #expect(try client.fileDescriptor.address(IPv4SocketAddress.self).address.rawValue == "127.0.0.1")
+        #expect(try client.fileDescriptor.peerAddress(IPv4SocketAddress.self).address.rawValue == "127.0.0.1")
         let read = try await client.read(data.count)
-        NSLog("Client: Read incoming data")
-        XCTAssertEqual(data, read)
+        Self.logger.info("Client: Read incoming data")
+        #expect(data == read)
         try await Task.sleep(nanoseconds: 2_000_000_000)
         await client.close()
         let clientEvents = try await clientEventsTask.value
-        XCTAssertEqual(clientEvents.count, 4)
-        XCTAssertEqual("\(clientEvents)", "[Socket.Socket.Event.write, Socket.Socket.Event.read, Socket.Socket.Event.didRead(41), Socket.Socket.Event.close]")
+        #expect(clientEvents.count == 4)
+        #expect("\(clientEvents)" == "[Socket.Socket.Event.write, Socket.Socket.Event.read, Socket.Socket.Event.didRead(41), Socket.Socket.Event.close]")
         await server.close()
         let serverEvents = try await serverEventsTask.value
-        XCTAssertEqual(serverEvents.count, 2)
-        XCTAssertEqual("\(serverEvents)", "[Socket.Socket.Event.connection, Socket.Socket.Event.close]")
+        #expect(serverEvents.count == 2)
+        #expect("\(serverEvents)" == "[Socket.Socket.Event.connection, Socket.Socket.Event.close]")
         let newConnectionEvents = try await newConnectionTask.value
-        XCTAssertEqual(newConnectionEvents.count, 5)
-        XCTAssertEqual("\(newConnectionEvents)", "[Socket.Socket.Event.write, Socket.Socket.Event.didWrite(41), Socket.Socket.Event.write, Socket.Socket.Event.read, Socket.Socket.Event.close]")
+        #expect(newConnectionEvents.count == 5)
+        #expect("\(newConnectionEvents)" == "[Socket.Socket.Event.write, Socket.Socket.Event.didWrite(41), Socket.Socket.Event.write, Socket.Socket.Event.read, Socket.Socket.Event.close]")
     }
 
+    @Test("IPv4 UDP Socket Communication")
     func testIPv4UDPSocket() async throws {
         let port = UInt16.random(in: 8080 ..< .max)
-        print("Using port \(port)")
+        Self.logger.info("Using port \(port)")
         let address = IPv4SocketAddress(
             address: .any,
             port: port
@@ -129,78 +140,114 @@ final class SocketTests: XCTestCase {
                 bind: address
             )
             defer { Task { await server.close() } }
-            NSLog("Server: Created server socket \(server.fileDescriptor)")
+            Self.logger.info("Server: Created server socket \(server.fileDescriptor)")
 
             do {
-                NSLog("Server: Waiting to receive incoming message")
+                Self.logger.info("Server: Waiting to receive incoming message")
                 let (read, clientAddress) = try await server.receiveMessage(data.count, fromAddressOf: type(of: address))
-                NSLog("Server: Received incoming message")
-                XCTAssertEqual(data, read)
+                Self.logger.info("Server: Received incoming message")
+                #expect(data == read)
 
-                NSLog("Server: Waiting to send outgoing message")
+                Self.logger.info("Server: Waiting to send outgoing message")
                 try await server.sendMessage(data, to: clientAddress)
-                NSLog("Server: Sent outgoing message")
+                Self.logger.info("Server: Sent outgoing message")
             } catch {
-                print("Server:", error)
-                XCTFail("\(error)")
+                Self.logger.error("Server error: \(error)")
+                Issue.record("Server error: \(error)")
             }
         }
 
         let client = try await Socket(
             IPv4Protocol.udp
         )
         defer { Task { await client.close() } }
-        NSLog("Client: Created client socket \(client.fileDescriptor)")
+        Self.logger.info("Client: Created client socket \(client.fileDescriptor)")
 
-        NSLog("Client: Waiting to send outgoing message")
+        Self.logger.info("Client: Waiting to send outgoing message")
         try await client.sendMessage(data, to: address)
-        NSLog("Client: Sent outgoing message")
+        Self.logger.info("Client: Sent outgoing message")
 
-        NSLog("Client: Waiting to receive incoming message")
+        Self.logger.info("Client: Waiting to receive incoming message")
         let (read, _) = try await client.receiveMessage(data.count, fromAddressOf: type(of: address))
-        NSLog("Client: Received incoming message")
-        XCTAssertEqual(data, read)
+        Self.logger.info("Client: Received incoming message")
+        #expect(data == read)
     }
 
+    @Test("Network Interface IPv4 Enumeration")
     func testNetworkInterfaceIPv4() throws {
         let interfaces = try NetworkInterface<IPv4SocketAddress>.interfaces
         if !isRunningInCI {
-            XCTAssert(interfaces.isEmpty == false)
+            #expect(!interfaces.isEmpty)
         }
         for interface in interfaces {
-            print("\(interface.id.index). \(interface.id.name)")
-            print("\(interface.address.address) \(interface.address.port)")
+            Self.logger.info("\(interface.id.index). \(interface.id.name)")
+            Self.logger.info("\(interface.address.address) \(interface.address.port)")
             if let netmask = interface.netmask {
-                print("\(netmask.address) \(netmask.port)")
+                Self.logger.info("\(netmask.address) \(netmask.port)")
             }
         }
     }
 
+    @Test("Network Interface IPv6 Enumeration")
     func testNetworkInterfaceIPv6() throws {
         let interfaces = try NetworkInterface<IPv6SocketAddress>.interfaces
         if !isRunningInCI {
-            XCTAssert(interfaces.isEmpty == false)
+            #expect(!interfaces.isEmpty)
         }
         for interface in interfaces {
-            print("\(interface.id.index). \(interface.id.name)")
-            print("\(interface.address.address) \(interface.address.port)")
+            Self.logger.info("\(interface.id.index). \(interface.id.name)")
+            Self.logger.info("\(interface.address.address) \(interface.address.port)")
             if let netmask = interface.netmask {
-                print("\(netmask.address) \(netmask.port)")
+                Self.logger.info("\(netmask.address) \(netmask.port)")
             }
         }
     }
 
     #if canImport(Darwin) || os(Linux)
+    @Test("Network Interface Link Layer Enumeration")
     func testNetworkInterfaceLinkLayer() throws {
         let interfaces = try NetworkInterface<LinkLayerSocketAddress>.interfaces
         for interface in interfaces {
-            print("\(interface.id.index). \(interface.id.name)")
-            print(interface.address.address)
+            Self.logger.info("\(interface.id.index). \(interface.id.name)")
+            Self.logger.info("\(interface.address.address)")
             assert(interface.id.index == numericCast(interface.address.index))
         }
     }
     #endif
 
+    @Test("IPv4 Loopback Address Byte Order Fix", .tags(.bugfix))
+    func testIPv4LoopbackAddress() async throws {
+        // Test the loopback address byte order issue from GitHub issue #18
+        let loopback = IPv4Address.loopback
+        #expect(loopback.rawValue == "127.0.0.1", "IPv4Address.loopback should return '127.0.0.1', not '1.0.0.127'")
+        
+        // Test that loopback is equivalent to manually constructed 127.0.0.1
+        let manualLoopback = IPv4Address(127, 0, 0, 1)
+        #expect(loopback == manualLoopback, "IPv4Address.loopback should equal manually constructed IPv4Address(127, 0, 0, 1)")
+        
+        // Test that loopback is equivalent to string-constructed address
+        let stringLoopback = IPv4Address(rawValue: "127.0.0.1")!
+        #expect(loopback == stringLoopback, "IPv4Address.loopback should equal string-constructed address")
+        
+        // Test that we can actually bind to loopback for TCP
+        // This should not throw "Can't assign requested address" error
+        let tcpAddress = IPv4SocketAddress(address: .loopback, port: 0)
+        let tcpSocket = try await Socket(IPv4Protocol.tcp, bind: tcpAddress)
+        defer { Task { await tcpSocket.close() } }
+        
+        // Test that we can also bind to loopback for UDP
+        let udpAddress = IPv4SocketAddress(address: .loopback, port: 0)
+        let udpSocket = try await Socket(IPv4Protocol.udp, bind: udpAddress)
+        defer { Task { await udpSocket.close() } }
+        
+        // Verify the bound addresses are actually loopback
+        let boundTcpAddress = try tcpSocket.fileDescriptor.address(IPv4SocketAddress.self)
+        #expect(boundTcpAddress.address.rawValue == "127.0.0.1", "Bound TCP socket should be on loopback address")
+        
+        let boundUdpAddress = try udpSocket.fileDescriptor.address(IPv4SocketAddress.self)
+        #expect(boundUdpAddress.address.rawValue == "127.0.0.1", "Bound UDP socket should be on loopback address")
+    }
+  
     func testTCPNoDelay() async throws {
         // Create a TCP socket
         let socket = try await Socket(IPv4Protocol.tcp)
@@ -294,3 +341,7 @@ var isRunningInCI: Bool {
     }
     return false
 }
+
+extension Tag {
+    @Tag static var bugfix: Self
+}