NIO: implement network interface enumeration for Windows

Partially implement network interface enumeration.  This is sufficient
to build up the structures for basic operations.  Although the interface
information is incomplete, this provides enough structure to continue
porting the rest of the NIO interfaces.

Author: compnerd

Sources/NIO/Channel.swift

@@ -338,9 +338,11 @@ public enum ChannelError: Error {
     /// address.
     case illegalMulticastAddress(SocketAddress)
 
+#if !os(Windows)
     /// Multicast is not supported on Interface
     @available(*, deprecated, renamed: "NIOMulticastNotSupportedError")
     case multicastNotSupported(NIONetworkInterface)
+#endif
 
     /// An operation that was inappropriate given the current `Channel` state was attempted.
     case inappropriateOperationForState

Sources/NIO/Interfaces.swift

@@ -20,6 +20,21 @@
 
 import CNIOLinux
 
+#if os(Windows)
+import let WinSDK.AF_INET
+import let WinSDK.AF_INET6
+
+import let WinSDK.INET_ADDRSTRLEN
+import let WinSDK.INET6_ADDRSTRLEN
+
+import struct WinSDK.ADDRESS_FAMILY
+import struct WinSDK.IP_ADAPTER_ADDRESSES
+import struct WinSDK.IP_ADAPTER_UNICAST_ADDRESS
+
+import typealias WinSDK.UINT8
+#endif
+
+#if !os(Windows)
 private extension ifaddrs {
     var dstaddr: UnsafeMutablePointer<sockaddr>? {
         #if os(Linux)
@@ -37,6 +52,7 @@ private extension ifaddrs {
         #endif
     }
 }
+#endif
 
 /// A representation of a single network device on a system.
 public struct NIONetworkDevice {
@@ -127,14 +143,25 @@ public struct NIONetworkDevice {
     /// This constructor will fail if NIO does not understand the format of the underlying
     /// socket address family. This is quite common: for example, Linux will return AF_PACKET
     /// addressed interfaces on most platforms, which NIO does not currently understand.
+#if os(Windows)
+    internal init?(_ pAdapter: UnsafeMutablePointer<IP_ADAPTER_ADDRESSES>,
+                   _ pAddress: UnsafeMutablePointer<IP_ADAPTER_UNICAST_ADDRESS>) {
+        guard let backing = Backing(pAdapter, pAddress) else {
+            return nil
+        }
+        self.backing = backing
+    }
+#else
     internal init?(_ caddr: ifaddrs) {
         guard let backing = Backing(caddr) else {
             return nil
         }
 
         self.backing = backing
     }
+#endif
 
+#if !os(Windows)
     /// Convert a `NIONetworkInterface` to a `NIONetworkDevice`. As `NIONetworkDevice`s are a superset of `NIONetworkInterface`s,
     /// it is always possible to perform this conversion.
     @available(*, deprecated, message: "This is a compatibility helper, and will be removed in a future release")
@@ -149,6 +176,7 @@ public struct NIONetworkDevice {
             interfaceIndex: interface.interfaceIndex
         )
     }
+#endif
 
     public init(name: String,
                 address: SocketAddress?,
@@ -206,6 +234,58 @@ extension NIONetworkDevice {
         /// This constructor will fail if NIO does not understand the format of the underlying
         /// socket address family. This is quite common: for example, Linux will return AF_PACKET
         /// addressed interfaces on most platforms, which NIO does not currently understand.
+#if os(Windows)
+        internal init?(_ pAdapter: UnsafeMutablePointer<IP_ADAPTER_ADDRESSES>,
+                       _ pAddress: UnsafeMutablePointer<IP_ADAPTER_UNICAST_ADDRESS>) {
+            self.name = String(decodingCString: pAdapter.pointee.FriendlyName,
+                               as: UTF16.self)
+            self.address = pAddress.pointee.Address.lpSockaddr.convert()
+
+            // TODO: convert the prefix length to the mask itself
+            let v4mask: (UINT8) -> SocketAddress? = { _ in
+                var buffer: [CChar] =
+                    Array<CChar>(repeating: 0, count: Int(INET_ADDRSTRLEN))
+                var mask: sockaddr_in = sockaddr_in()
+                mask.sin_family = ADDRESS_FAMILY(AF_INET)
+                _ = buffer.withUnsafeMutableBufferPointer {
+                    try! NIOBSDSocket.inet_ntop(af: .inet, src: &mask,
+                                                dst: $0.baseAddress!,
+                                                size: INET_ADDRSTRLEN)
+                }
+                return SocketAddress(mask, host: mask.addressDescription())
+            }
+            let v6mask: (UINT8) -> SocketAddress? = { _ in
+                var buffer: [CChar] =
+                    Array<CChar>(repeating: 0, count: Int(INET6_ADDRSTRLEN))
+                var mask: sockaddr_in6 = sockaddr_in6()
+                mask.sin6_family = ADDRESS_FAMILY(AF_INET6)
+                _ = buffer.withUnsafeMutableBufferPointer {
+                    try! NIOBSDSocket.inet_ntop(af: .inet6, src: &mask,
+                                                dst: $0.baseAddress!,
+                                                size: INET6_ADDRSTRLEN)
+                }
+                return SocketAddress(mask, host: mask.addressDescription())
+            }
+
+            switch pAddress.pointee.Address.lpSockaddr.pointee.sa_family {
+            case ADDRESS_FAMILY(AF_INET):
+                self.netmask = v4mask(pAddress.pointee.OnLinkPrefixLength)
+                self.interfaceIndex = Int(pAdapter.pointee.IfIndex)
+                break
+            case ADDRESS_FAMILY(AF_INET6):
+                self.netmask = v6mask(pAddress.pointee.OnLinkPrefixLength)
+                self.interfaceIndex = Int(pAdapter.pointee.Ipv6IfIndex)
+                break
+            default:
+              return nil
+            }
+
+            // TODO(compnerd) handle broadcast/ppp/multicast information
+            self.broadcastAddress = nil
+            self.pointToPointDestinationAddress = nil
+            self.multicastSupported = false
+        }
+#else
         internal init?(_ caddr: ifaddrs) {
             self.name = String(cString: caddr.ifa_name)
             self.address = caddr.ifa_addr.flatMap { $0.convert() }
@@ -229,6 +309,7 @@ extension NIONetworkDevice {
                 return nil
             }
         }
+#endif
 
         init(copying original: Backing) {
             self.name = original.name
@@ -325,6 +406,60 @@ public final class NIONetworkInterface {
     /// This constructor will fail if NIO does not understand the format of the underlying
     /// socket address family. This is quite common: for example, Linux will return AF_PACKET
     /// addressed interfaces on most platforms, which NIO does not currently understand.
+#if os(Windows)
+    internal init?(_ pAdapter: UnsafeMutablePointer<IP_ADAPTER_ADDRESSES>,
+                   _ pAddress: UnsafeMutablePointer<IP_ADAPTER_UNICAST_ADDRESS>) {
+        self.name = String(decodingCString: pAdapter.pointee.FriendlyName,
+                           as: UTF16.self)
+
+        guard let address = pAddress.pointee.Address.lpSockaddr.convert() else {
+          return nil
+        }
+        self.address = address
+
+        // TODO: convert the prefix length to the mask itself
+        let v4mask: (UINT8) -> SocketAddress? = { _ in
+            var buffer: [CChar] =
+                Array<CChar>(repeating: 0, count: Int(INET_ADDRSTRLEN))
+            var mask: sockaddr_in = sockaddr_in()
+            mask.sin_family = ADDRESS_FAMILY(AF_INET)
+            _ = buffer.withUnsafeMutableBufferPointer {
+                try! NIOBSDSocket.inet_ntop(af: .inet, src: &mask,
+                                            dst: $0.baseAddress!,
+                                            size: INET_ADDRSTRLEN)
+            }
+            return SocketAddress(mask, host: mask.addressDescription())
+        }
+        let v6mask: (UINT8) -> SocketAddress? = { _ in
+            var buffer: [CChar] =
+                Array<CChar>(repeating: 0, count: Int(INET6_ADDRSTRLEN))
+            var mask: sockaddr_in6 = sockaddr_in6()
+            mask.sin6_family = ADDRESS_FAMILY(AF_INET6)
+            _ = buffer.withUnsafeMutableBufferPointer {
+                try! NIOBSDSocket.inet_ntop(af: .inet6, src: &mask,
+                                            dst: $0.baseAddress!,
+                                            size: INET6_ADDRSTRLEN)
+            }
+            return SocketAddress(mask, host: mask.addressDescription())
+        }
+
+        switch pAddress.pointee.Address.lpSockaddr.pointee.sa_family {
+        case ADDRESS_FAMILY(AF_INET):
+            self.netmask = v4mask(pAddress.pointee.OnLinkPrefixLength)
+            self.interfaceIndex = Int(pAdapter.pointee.IfIndex)
+        case ADDRESS_FAMILY(AF_INET6):
+            self.netmask = v6mask(pAddress.pointee.OnLinkPrefixLength)
+            self.interfaceIndex = Int(pAdapter.pointee.Ipv6IfIndex)
+        default:
+            return nil
+        }
+
+        // TODO(compnerd) handle broadcast/ppp/multicast information
+        self.broadcastAddress = nil
+        self.pointToPointDestinationAddress = nil
+        self.multicastSupported = false
+    }
+#else
     internal init?(_ caddr: ifaddrs) {
         self.name = String(cString: caddr.ifa_name)
         guard let address = caddr.ifa_addr!.convert() else {
@@ -361,6 +496,7 @@ public final class NIONetworkInterface {
             return nil
         }
     }
+#endif
 }
 
 @available(*, deprecated, renamed: "NIONetworkDevice")

Sources/NIO/MulticastChannel.swift

@@ -25,6 +25,7 @@ public protocol MulticastChannel: Channel {
     ///         `nil` if you are not interested in the result of the operation.
     func joinGroup(_ group: SocketAddress, promise: EventLoopPromise<Void>?)
 
+#if !os(Windows)
     /// Request that the `MulticastChannel` join the multicast group given by `group` on the interface
     /// given by `interface`.
     ///
@@ -35,6 +36,7 @@ public protocol MulticastChannel: Channel {
     ///         `nil` if you are not interested in the result of the operation.
     @available(*, deprecated, renamed: "joinGroup(_:device:promise:)")
     func joinGroup(_ group: SocketAddress, interface: NIONetworkInterface?, promise: EventLoopPromise<Void>?)
+#endif
 
     /// Request that the `MulticastChannel` join the multicast group given by `group` on the device
     /// given by `device`.
@@ -54,6 +56,7 @@ public protocol MulticastChannel: Channel {
     ///         `nil` if you are not interested in the result of the operation.
     func leaveGroup(_ group: SocketAddress, promise: EventLoopPromise<Void>?)
 
+#if !os(Windows)
     /// Request that the `MulticastChannel` leave the multicast group given by `group` on the interface
     /// given by `interface`.
     ///
@@ -64,6 +67,7 @@ public protocol MulticastChannel: Channel {
     ///         `nil` if you are not interested in the result of the operation.
     @available(*, deprecated, renamed: "leaveGroup(_:device:promise:)")
     func leaveGroup(_ group: SocketAddress, interface: NIONetworkInterface?, promise: EventLoopPromise<Void>?)
+#endif
 
     /// Request that the `MulticastChannel` leave the multicast group given by `group` on the device
     /// given by `device`.
@@ -89,12 +93,14 @@ extension MulticastChannel {
         return promise.futureResult
     }
 
+#if !os(Windows)
     @available(*, deprecated, renamed: "joinGroup(_:device:)")
     public func joinGroup(_ group: SocketAddress, interface: NIONetworkInterface?) -> EventLoopFuture<Void> {
         let promise = self.eventLoop.makePromise(of: Void.self)
         self.joinGroup(group, interface: interface, promise: promise)
         return promise.futureResult
     }
+#endif
 
     public func joinGroup(_ group: SocketAddress, device: NIONetworkDevice?) -> EventLoopFuture<Void> {
         let promise = self.eventLoop.makePromise(of: Void.self)
@@ -112,12 +118,14 @@ extension MulticastChannel {
         return promise.futureResult
     }
 
+#if !os(Windows)
     @available(*, deprecated, renamed: "leaveGroup(_:device:)")
     public func leaveGroup(_ group: SocketAddress, interface: NIONetworkInterface?) -> EventLoopFuture<Void> {
         let promise = self.eventLoop.makePromise(of: Void.self)
         self.leaveGroup(group, interface: interface, promise: promise)
         return promise.futureResult
     }
+#endif
 
     public func leaveGroup(_ group: SocketAddress, device: NIONetworkDevice?) -> EventLoopFuture<Void> {
         let promise = self.eventLoop.makePromise(of: Void.self)

Sources/NIO/SocketChannel.swift

@@ -12,6 +12,15 @@
 //
 //===----------------------------------------------------------------------===//
 
+#if os(Windows)
+import let WinSDK.ECONNABORTED
+import let WinSDK.ECONNREFUSED
+import let WinSDK.EMFILE
+import let WinSDK.ENFILE
+import let WinSDK.ENOBUFS
+import let WinSDK.ENOMEM
+#endif
+
 extension ByteBuffer {
     mutating func withMutableWritePointer(body: (UnsafeMutableRawBufferPointer) throws -> IOResult<Int>) rethrows -> IOResult<Int> {
         var singleResult: IOResult<Int>!
@@ -755,6 +764,7 @@ extension DatagramChannel: MulticastChannel {
         }
     }
 
+#if !os(Windows)
     @available(*, deprecated, renamed: "joinGroup(_:device:promise:)")
     func joinGroup(_ group: SocketAddress, interface: NIONetworkInterface?, promise: EventLoopPromise<Void>?) {
         if eventLoop.inEventLoop {
@@ -776,6 +786,7 @@ extension DatagramChannel: MulticastChannel {
             }
         }
     }
+#endif
 
     func joinGroup(_ group: SocketAddress, device: NIONetworkDevice?, promise: EventLoopPromise<Void>?) {
         if eventLoop.inEventLoop {