[DRAFT] Initial socket support

Package.resolved

@@ -0,0 +1,16 @@
+{
+  "object": {
+    "pins": [
+      {
+        "package": "swift-argument-parser",
+        "repositoryURL": "https://github.com/apple/swift-argument-parser",
+        "state": {
+          "branch": null,
+          "revision": "9564d61b08a5335ae0a36f789a7d71493eacadfc",
+          "version": "0.3.2"
+        }
+      }
+    ]
+  },
+  "version": 1
+}

Package.swift

@@ -12,6 +12,10 @@
 
 import PackageDescription
 
+let settings: [SwiftSetting]? = [
+  .define("SYSTEM_PACKAGE")
+]
+
 let targets: [PackageDescription.Target] = [
   .target(
     name: "SystemPackage",
@@ -24,19 +28,43 @@ let targets: [PackageDescription.Target] = [
   .target(
     name: "CSystem",
     dependencies: []),
+
+  .target(
+    name: "SystemSockets",
+    dependencies: ["SystemPackage"]),
+
   .testTarget(
     name: "SystemTests",
     dependencies: ["SystemPackage"],
-    swiftSettings: [
-      .define("SYSTEM_PACKAGE")
-    ]),
+    swiftSettings: settings
+  ),
+
+  .testTarget(
+      name: "SystemSocketsTests",
+      dependencies: ["SystemSockets"],
+      swiftSettings: settings
+    ),
+
+  .target(
+    name: "Samples",
+    dependencies: [
+      "SystemPackage",
+      "SystemSockets",
+      .product(name: "ArgumentParser", package: "swift-argument-parser"),
+    ],
+    path: "Sources/Samples",
+    swiftSettings: settings
+  ),
 ]
 
 let package = Package(
     name: "swift-system",
     products: [
-        .library(name: "SystemPackage", targets: ["SystemPackage"]),
+      .library(name: "SystemPackage", targets: ["SystemPackage"]),
+      .executable(name: "system-samples", targets: ["Samples"]),
+    ],
+    dependencies: [
+      .package(url: "https://github.com/apple/swift-argument-parser", from: "0.3.0"),
     ],
-    dependencies: [],
     targets: targets
 )

Sources/Samples/Connect.swift

@@ -0,0 +1,113 @@
+/*
+ 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
+import SystemSockets
+#else
+import System
+#error("No socket support")
+#endif
+
+struct Connect: ParsableCommand {
+  static var configuration = CommandConfiguration(
+    commandName: "connect",
+    abstract: "Open a connection and send lines from stdin over it."
+  )
+
+  @Argument(help: "The hostname to connect to.")
+  var hostname: String
+
+  @Argument(help: "The port number (or service name) to connect to.")
+  var service: String
+
+  @Flag(help: "Use IPv4")
+  var ipv4: Bool = false
+
+  @Flag(help: "Use IPv6")
+  var ipv6: Bool = false
+
+  @Flag(help: "Use UDP")
+  var udp: Bool = false
+
+  @Flag(help: "Send data out-of-band")
+  var outOfBand: Bool = false
+
+  @Option(help: "TCP connection timeout, in seconds")
+  var connectionTimeout: CInt?
+
+  @Option(help: "Socket send timeout, in seconds")
+  var sendTimeout: CInt?
+
+  @Option(help: "Socket receive timeout, in seconds")
+  var receiveTimeout: CInt?
+
+  @Option(help: "TCP connection keepalive interval, in seconds")
+  var keepalive: CInt?
+
+  func connect(
+    to addresses: [SocketAddress.Info]
+  ) throws -> (SocketDescriptor, SocketAddress)? {
+    // Only try the first address for now
+    guard let addressinfo = addresses.first else { return nil }
+    print(addressinfo)
+    let socket = try SocketDescriptor.open(
+      addressinfo.domain,
+      addressinfo.type,
+      addressinfo.protocol)
+    do {
+      if let connectionTimeout = connectionTimeout {
+        try socket.setOption(.tcp, .tcpConnectionTimeout, to: connectionTimeout)
+      }
+      if let sendTimeout = sendTimeout {
+        try socket.setOption(.socketOption, .sendTimeout, to: sendTimeout)
+      }
+      if let receiveTimeout = receiveTimeout {
+        try socket.setOption(.socketOption, .receiveTimeout, to: receiveTimeout)
+      }
+      if let keepalive = keepalive {
+        try socket.setOption(.tcp, .tcpKeepAlive, to: keepalive)
+      }
+      try socket.connect(to: addressinfo.address)
+      return (socket, addressinfo.address)
+    }
+    catch {
+      try? socket.close()
+      throw error
+    }
+  }
+
+  func run() throws {
+    let addresses = try SocketAddress.resolveName(
+      hostname: hostname,
+      service: service,
+      family: ipv6 ? .ipv6 : .ipv4,
+      type: udp ? .datagram : .stream)
+
+    guard let (socket, address) = try connect(to: addresses) else {
+      complain("Can't connect to \(hostname)")
+      throw ExitCode.failure
+    }
+    complain("Connected to \(address.niceDescription)")
+
+    let flags: SocketDescriptor.MessageFlags = outOfBand ? .outOfBand : .none
+    try socket.closeAfter {
+      while var line = readLine(strippingNewline: false) {
+        try line.withUTF8 { buffer in
+          var buffer = UnsafeRawBufferPointer(buffer)
+          while !buffer.isEmpty {
+            let c = try socket.send(buffer, flags: flags)
+            buffer = .init(rebasing: buffer[c...])
+          }
+        }
+      }
+    }
+  }
+}

Sources/Samples/Listen.swift

@@ -0,0 +1,124 @@
+/*
+ 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
+import SystemSockets
+#else
+import System
+#error("No socket support")
+#endif
+
+struct Listen: ParsableCommand {
+  static var configuration = CommandConfiguration(
+    commandName: "listen",
+    abstract: "Listen for an incoming connection and print received text to stdout."
+  )
+
+  @Argument(help: "The port number (or service name) to listen on.")
+  var service: String
+
+  @Flag(help: "Use IPv4")
+  var ipv4: Bool = false
+
+  @Flag(help: "Use IPv6")
+  var ipv6: Bool = false
+
+  @Flag(help: "Use UDP")
+  var udp: Bool = false
+
+  func startServer(
+    on addresses: [SocketAddress.Info]
+  ) throws -> (SocketDescriptor, SocketAddress.Info)? {
+    for info in addresses {
+      do {
+        let socket = try SocketDescriptor.open(
+          info.domain,
+          info.type,
+          info.protocol)
+        do {
+          try socket.bind(to: info.address)
+          if !info.type.isConnectionless {
+            try socket.listen(backlog: 10)
+          }
+          return (socket, info)
+        }
+        catch {
+          try? socket.close()
+          throw error
+        }
+      }
+      catch {
+        continue
+      }
+    }
+    return nil
+  }
+
+  func prefix(
+    client: SocketAddress,
+    flags: SocketDescriptor.MessageFlags
+  ) -> String {
+    var prefix: [String] = []
+    if client.family != .unspecified {
+      prefix.append("client: \(client.niceDescription)")
+    }
+    if flags != .none {
+      prefix.append("flags: \(flags)")
+    }
+    guard !prefix.isEmpty else { return "" }
+    return "<\(prefix.joined(separator: ", "))> "
+  }
+
+  func run() throws {
+    let addresses = try SocketAddress.resolveName(
+      hostname: nil,
+      service: service,
+      flags: .canonicalName,
+      family: ipv6 ? .ipv6 : .ipv4,
+      type: udp ? .datagram : .stream)
+
+
+    guard let (socket, address) = try startServer(on: addresses) else {
+      complain("Can't listen on \(service)")
+      throw ExitCode.failure
+    }
+    complain("Listening on \(address.address.niceDescription)")
+
+    var client = SocketAddress()
+    let buffer = UnsafeMutableRawBufferPointer.allocate(byteCount: 1024, alignment: 1)
+    defer { buffer.deallocate() }
+
+    var ancillary = SocketDescriptor.AncillaryMessageBuffer()
+    try socket.closeAfter {
+      if udp {
+        while true {
+          let (count, flags) =
+            try socket.receive(into: buffer, sender: &client, ancillary: &ancillary)
+          print(prefix(client: client, flags: flags), terminator: "")
+          try FileDescriptor.standardOutput.writeAll(buffer[..<count])
+        }
+      } else {
+        let conn = try socket.accept(client: &client)
+        complain("Connection from \(client.niceDescription)")
+        try conn.closeAfter {
+          while true {
+            let (count, flags) =
+            try conn.receive(into: buffer, sender: &client, ancillary: &ancillary)
+            guard count > 0 else { break }
+            print(prefix(client: client, flags: flags), terminator: "")
+            try FileDescriptor.standardOutput.writeAll(buffer[..<count])
+          }
+        }
+      }
+    }
+  }
+}
+