Implement getnameinfo.

Author: lorentey

Sources/Samples/Connect.swift

@@ -64,7 +64,7 @@ struct Connect: ParsableCommand {
   }
 
   func run() throws {
-    let addresses = try SocketAddress.resolve(
+    let addresses = try SocketAddress.resolveName(
       hostname: nil,
       service: service,
       family: ipv6 ? .ipv6 : .ipv4,

Sources/Samples/Listen.swift

@@ -76,7 +76,7 @@ struct Listen: ParsableCommand {
   }
 
   func run() throws {
-    let addresses = try SocketAddress.resolve(
+    let addresses = try SocketAddress.resolveName(
       hostname: nil,
       service: service,
       flags: .canonicalName,

Sources/Samples/Resolve.swift

@@ -15,6 +15,11 @@ import System
 #endif
 
 struct Resolve: ParsableCommand {
+  static var configuration = CommandConfiguration(
+    commandName: "resolve",
+    abstract: "Resolve a pair of hostname/servicename strings to a list of socket addresses."
+  )
+
   @Argument(help: "The hostname to resolve")
   var hostname: String?
 
@@ -39,8 +44,11 @@ struct Resolve: ParsableCommand {
   @Flag(help: "Resolve IPv6 addresses")
   var ipv6: Bool = false
 
+  @Flag(help: "Print the raw SocketAddress structures")
+  var raw: Bool = false
+
   func run() throws {
-    var flags: SocketAddress.ResolverFlags = [.default, .all]
+    var flags: SocketAddress.NameResolverFlags = [.default, .all]
     if canonicalName { flags.insert(.canonicalName) }
     if passive { flags.insert(.passive) }
     if numericHost { flags.insert(.numericHost) }
@@ -50,7 +58,7 @@ struct Resolve: ParsableCommand {
     if ipv4 { family = .ipv4 }
     if ipv6 { family = .ipv6 }
 
-    let results = try SocketAddress.resolve(
+    let results = try SocketAddress.resolveName(
       hostname: hostname, service: service,
       flags: flags,
       family: family
@@ -59,7 +67,11 @@ struct Resolve: ParsableCommand {
       print("No results found")
     } else {
       for entry in results {
-        print(entry)
+        if raw {
+          print(entry)
+        } else {
+          print(entry.niceDescription)
+        }
       }
     }
   }

Sources/Samples/ReverseResolve.swift

@@ -0,0 +1,77 @@
+/*
+ This source file is part of the Swift System open source project
+
+ Copyright (c) 2021 Apple Inc. and the Swift System project authors
+ Licensed under Apache License v2.0 with Runtime Library Exception
+
+ See https://swift.org/LICENSE.txt for license information
+*/
+
+import ArgumentParser
+#if SYSTEM_PACKAGE
+import SystemPackage
+#else
+import System
+#endif
+
+struct ReverseResolve: ParsableCommand {
+  static var configuration = CommandConfiguration(
+    commandName: "reverse",
+    abstract: "Resolve a numerical IP address and port number into a hostname/service string"
+  )
+
+  @Argument(help: "The IP address to resolve")
+  var address: String?
+
+  @Argument(help: "The port number to resolve")
+  var port: String?
+
+  @Flag(help: "No fully qualified domain for local addresses")
+  var nofqdn: Bool = false
+
+  @Flag(help: "Disable hostname resolution; hostname must be numeric address")
+  var numericHost: Bool = false
+
+  @Flag(help: "Disable service resolution; service name must be numeric")
+  var numericService: Bool = false
+
+  @Flag(help: "Look up a datagram service")
+  var datagram: Bool = false
+
+  @Flag(help: "Allow IPv6 scope identifiers")
+  var scopeid: Bool = false
+
+  func run() throws {
+    // First, we need to get a sockaddr, so things start with forward resolution.
+    let infos = try SocketAddress.resolveName(
+      hostname: address,
+      service: port,
+      flags: [.numericHost, .numericService])
+
+    var results: Set<String> = []
+    for info in infos {
+      // Now try a reverse lookup.
+      var flags: SocketAddress.AddressResolverFlags = []
+      if nofqdn {
+        flags.insert(.noFullyQualifiedDomain)
+      }
+      if numericHost {
+        flags.insert(.numericHost)
+      }
+      if numericService {
+        flags.insert(.numericService)
+      }
+      if datagram {
+        flags.insert(.datagram)
+      }
+      if scopeid {
+        flags.insert(.scopeIdentifier)
+      }
+      let (hostname, service) = try SocketAddress.resolveAddress(info.address, flags: flags)
+      results.insert("\(hostname) \(service)")
+    }
+    for r in results.sorted() {
+      print(r)
+    }
+  }
+}

Sources/Samples/Util.swift

@@ -40,6 +40,18 @@ internal func complain(_ message: String) {
   }
 }
 
+extension SocketAddress.Info {
+  var niceDescription: String {
+    var proto = ""
+    switch self.protocol {
+    case .udp: proto = "udp"
+    case .tcp: proto = "tcp"
+    default: proto = "\(self.protocol)"
+    }
+    return "\(address.niceDescription) (\(proto))"
+  }
+}
+
 extension SocketAddress {
   var niceDescription: String {
     if let ipv4 = self.ipv4 { return ipv4.description }

Sources/Samples/main.swift

@@ -6,6 +6,7 @@ internal struct SystemSamples: ParsableCommand {
     abstract: "A collection of little programs exercising some System features.",
     subcommands: [
       Resolve.self,
+      ReverseResolve.self,
       Connect.self,
       Listen.self,
     ])

Sources/System/Internals/Constants.swift

@@ -886,6 +886,30 @@ internal var _AI_DEFAULT: CInt { AI_DEFAULT }
 @_alwaysEmitIntoClient
 internal var _AI_UNUSABLE: CInt { AI_UNUSABLE }
 
+@_alwaysEmitIntoClient
+internal var _NI_NOFQDN: CInt { NI_NOFQDN }
+
+@_alwaysEmitIntoClient
+internal var _NI_NUMERICHOST: CInt { NI_NUMERICHOST }
+
+@_alwaysEmitIntoClient
+internal var _NI_NAMEREQD: CInt { NI_NAMEREQD }
+
+@_alwaysEmitIntoClient
+internal var _NI_NUMERICSERV: CInt { NI_NUMERICSERV }
+
+@_alwaysEmitIntoClient
+internal var _NI_DGRAM: CInt { NI_DGRAM }
+
+@_alwaysEmitIntoClient
+internal var _NI_WITHSCOPEID: CInt { NI_WITHSCOPEID }
+
+@_alwaysEmitIntoClient
+internal var _NI_MAXHOST: CInt { NI_MAXHOST }
+
+@_alwaysEmitIntoClient
+internal var _NI_MAXSERV: CInt { NI_MAXSERV }
+
 @_alwaysEmitIntoClient
 internal var _EAI_ADDRFAMILY: CInt { EAI_ADDRFAMILY }
 

Sources/System/Internals/Exports.swift

@@ -60,7 +60,10 @@ internal func system_strerror(_ __errnum: Int32) -> UnsafeMutablePointer<Int8>!
   strerror(__errnum)
 }
 
-internal func system_strlen(_ s: UnsafePointer<Int8>) -> Int {
+internal func system_strlen(_ s: UnsafePointer<CChar>) -> Int {
+  strlen(s)
+}
+internal func system_strlen(_ s: UnsafeMutablePointer<CChar>) -> Int {
   strlen(s)
 }
 

Sources/System/Internals/Syscalls.swift

@@ -307,6 +307,23 @@ internal func system_getaddrinfo(
   return getaddrinfo(hostname, servname, hints, res)
 }
 
+internal func system_getnameinfo(
+  _ sa: UnsafePointer<CInterop.SockAddr>?,
+  _ salen: CInterop.SockLen,
+  _ host: UnsafeMutablePointer<CChar>?,
+  _ hostlen: CInterop.SockLen,
+  _ serv: UnsafeMutablePointer<CChar>?,
+  _ servlen: CInterop.SockLen,
+  _ flags: CInt
+) -> CInt {
+  #if ENABLE_MOCKING
+  if mockingEnabled {
+    return _mock(sa, salen, host, hostlen, serv, servlen, flags)
+  }
+  #endif
+  return getnameinfo(sa, salen, host, hostlen, serv, servlen, flags)
+}
+
 internal func system_freeaddrinfo(
   _ addrinfo: UnsafeMutablePointer<CInterop.AddrInfo>?
 ) {