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:
+                break
+            }
+
+            // 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
@@ -289,97 +370,99 @@ extension NIONetworkDevice: Hashable {
     }
 }
 
-/// A representation of a single network interface on a system.
-@available(*, deprecated, renamed: "NIONetworkDevice")
-public final class NIONetworkInterface {
-    // This is a class because in almost all cases this will carry
-    // four structs that are backed by classes, and so will incur 4
-    // refcount operations each time it is copied.
+#if !os(Windows)
+    /// A representation of a single network interface on a system.
+    @available(*, deprecated, renamed: "NIONetworkDevice")
+    public final class NIONetworkInterface {
+        // This is a class because in almost all cases this will carry
+        // four structs that are backed by classes, and so will incur 4
+        // refcount operations each time it is copied.
 
-    /// The name of the network interface.
-    public let name: String
+        /// The name of the network interface.
+        public let name: String
 
-    /// The address associated with the given network interface.
-    public let address: SocketAddress
+        /// The address associated with the given network interface.
+        public let address: SocketAddress
 
-    /// The netmask associated with this address, if any.
-    public let netmask: SocketAddress?
+        /// The netmask associated with this address, if any.
+        public let netmask: SocketAddress?
 
-    /// The broadcast address associated with this socket interface, if it has one. Some
-    /// interfaces do not, especially those that have a `pointToPointDestinationAddress`.
-    public let broadcastAddress: SocketAddress?
+        /// The broadcast address associated with this socket interface, if it has one. Some
+        /// interfaces do not, especially those that have a `pointToPointDestinationAddress`.
+        public let broadcastAddress: SocketAddress?
 
-    /// The address of the peer on a point-to-point interface, if this is one. Some
-    /// interfaces do not have such an address: most of those have a `broadcastAddress`
-    /// instead.
-    public let pointToPointDestinationAddress: SocketAddress?
+        /// The address of the peer on a point-to-point interface, if this is one. Some
+        /// interfaces do not have such an address: most of those have a `broadcastAddress`
+        /// instead.
+        public let pointToPointDestinationAddress: SocketAddress?
 
-    /// If the Interface supports Multicast
-    public let multicastSupported: Bool
+        /// If the Interface supports Multicast
+        public let multicastSupported: Bool
 
-    /// The index of the interface, as provided by `if_nametoindex`.
-    public let interfaceIndex: Int
+        /// The index of the interface, as provided by `if_nametoindex`.
+        public let interfaceIndex: Int
 
-    /// Create a brand new network interface.
-    ///
-    /// 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.
-    internal init?(_ caddr: ifaddrs) {
-        self.name = String(cString: caddr.ifa_name)
-        guard let address = caddr.ifa_addr!.convert() else {
-            return nil
-        }
-        self.address = address
+        /// Create a brand new network interface.
+        ///
+        /// 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.
+        internal init?(_ caddr: ifaddrs) {
+            self.name = String(cString: caddr.ifa_name)
+            guard let address = caddr.ifa_addr!.convert() else {
+                return nil
+            }
+            self.address = address
 
-        if let netmask = caddr.ifa_netmask {
-            self.netmask = netmask.convert()
-        } else {
-            self.netmask = nil
-        }
+            if let netmask = caddr.ifa_netmask {
+                self.netmask = netmask.convert()
+            } else {
+                self.netmask = nil
+            }
 
-        if (caddr.ifa_flags & UInt32(IFF_BROADCAST)) != 0, let addr = caddr.broadaddr {
-            self.broadcastAddress = addr.convert()
-            self.pointToPointDestinationAddress = nil
-        } else if (caddr.ifa_flags & UInt32(IFF_POINTOPOINT)) != 0, let addr = caddr.dstaddr {
-            self.broadcastAddress = nil
-            self.pointToPointDestinationAddress = addr.convert()
-        } else {
-            self.broadcastAddress = nil
-            self.pointToPointDestinationAddress = nil
-        }
+            if (caddr.ifa_flags & UInt32(IFF_BROADCAST)) != 0, let addr = caddr.broadaddr {
+                self.broadcastAddress = addr.convert()
+                self.pointToPointDestinationAddress = nil
+            } else if (caddr.ifa_flags & UInt32(IFF_POINTOPOINT)) != 0, let addr = caddr.dstaddr {
+                self.broadcastAddress = nil
+                self.pointToPointDestinationAddress = addr.convert()
+            } else {
+                self.broadcastAddress = nil
+                self.pointToPointDestinationAddress = nil
+            }
 
-        if (caddr.ifa_flags & UInt32(IFF_MULTICAST)) != 0 {
-            self.multicastSupported = true
-        } else {
-            self.multicastSupported = false
-        }
+            if (caddr.ifa_flags & UInt32(IFF_MULTICAST)) != 0 {
+                self.multicastSupported = true
+            } else {
+                self.multicastSupported = false
+            }
 
-        do {
-            self.interfaceIndex = Int(try Posix.if_nametoindex(caddr.ifa_name))
-        } catch {
-            return nil
+            do {
+                self.interfaceIndex = Int(try Posix.if_nametoindex(caddr.ifa_name))
+            } catch {
+                return nil
+            }
         }
     }
-}
 
-@available(*, deprecated, renamed: "NIONetworkDevice")
-extension NIONetworkInterface: CustomDebugStringConvertible {
-    public var debugDescription: String {
-        let baseString = "Interface \(self.name): address \(self.address)"
-        let maskString = self.netmask != nil ? " netmask \(self.netmask!)" : ""
-        return baseString + maskString
+    @available(*, deprecated, renamed: "NIONetworkDevice")
+    extension NIONetworkInterface: CustomDebugStringConvertible {
+        public var debugDescription: String {
+            let baseString = "Interface \(self.name): address \(self.address)"
+            let maskString = self.netmask != nil ? " netmask \(self.netmask!)" : ""
+            return baseString + maskString
+        }
     }
-}
 
-@available(*, deprecated, renamed: "NIONetworkDevice")
-extension NIONetworkInterface: Equatable {
-    public static func ==(lhs: NIONetworkInterface, rhs: NIONetworkInterface) -> Bool {
-        return lhs.name == rhs.name &&
-               lhs.address == rhs.address &&
-               lhs.netmask == rhs.netmask &&
-               lhs.broadcastAddress == rhs.broadcastAddress &&
-               lhs.pointToPointDestinationAddress == rhs.pointToPointDestinationAddress &&
-               lhs.interfaceIndex == rhs.interfaceIndex
+    @available(*, deprecated, renamed: "NIONetworkDevice")
+    extension NIONetworkInterface: Equatable {
+        public static func ==(lhs: NIONetworkInterface, rhs: NIONetworkInterface) -> Bool {
+            return lhs.name == rhs.name &&
+                   lhs.address == rhs.address &&
+                   lhs.netmask == rhs.netmask &&
+                   lhs.broadcastAddress == rhs.broadcastAddress &&
+                   lhs.pointToPointDestinationAddress == rhs.pointToPointDestinationAddress &&
+                   lhs.interfaceIndex == rhs.interfaceIndex
+        }
     }
-}
+#endif

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)