Compare commits

...
2 Commits
Author SHA1 Message Date
Michael Ilseman 81fded4dd9 [staging] Add Span-based file I/O APIs (#290)
* Add Span-based file I/O APIs

Implement read/write methods accepting RawSpan and OutputRawSpan,
with support for absolute offset operations and fill-until-complete
semantics. Refactor buffer handling into reusable helpers.

* wip: cleanup

* wip: cleanup
2026-01-23 15:15:19 -07:00
Michael Ilseman 774c7eb5a0 [staging] Sockets 2026 (#281)
Add socket APIs to swift-system (#281)

Port the long-standing sockets implementation from #30 to the new
staging branch. This adds comprehensive low-level Swift APIs for
POSIX socket programming.

Original Co-authored-by: Karoy Lorentey <karoly@apple.com>
2026-01-09 21:25:40 -07:00
34 changed files with 5545 additions and 25 deletions

No files matched your search

+1
View File
@@ -7,3 +7,4 @@ xcuserdata/
.*.sw?
/.swiftpm
.docc-build
Package.resolved
+25 -1
View File
@@ -120,8 +120,12 @@ let package = Package(
platforms: platforms,
products: [
.library(name: "SystemPackage", targets: ["SystemPackage"]),
.library(name: "SystemSockets", targets: ["SystemSockets"]),
.executable(name: "system-samples", targets: ["Samples"]),
],
dependencies: [
.package(url: "https://github.com/apple/swift-argument-parser", from: "1.3.0"),
],
dependencies: [],
targets: [
.target(
name: "CSystem",
@@ -141,6 +145,26 @@ let package = Package(
exclude: testsToExclude,
cSettings: cSettings,
swiftSettings: swiftSettings),
.target(
name: "SystemSockets",
dependencies: ["SystemPackage", "CSystem"],
path: "Sources/SystemSockets",
cSettings: cSettings,
swiftSettings: swiftSettings),
.testTarget(
name: "SystemSocketsTests",
dependencies: ["SystemSockets"],
cSettings: cSettings,
swiftSettings: swiftSettings),
.executableTarget(
name: "Samples",
dependencies: [
"SystemPackage",
"SystemSockets",
.product(name: "ArgumentParser", package: "swift-argument-parser"),
],
path: "Sources/Samples",
swiftSettings: swiftSettings),
],
swiftLanguageVersions: [.v5]
)
+71
View File
@@ -0,0 +1,71 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 - 2025 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
import SystemSockets
struct Connect: ParsableCommand {
static let configuration = CommandConfiguration(
abstract: "Connect to a TCP server and send/receive messages"
)
@Argument(help: "The host to connect to")
var host: String
@Argument(help: "The port to connect to")
var port: UInt16
@Option(name: .shortAndLong, help: "Message to send")
var message: String = "Hello from swift-system sockets!"
func run() throws {
print("Resolving \(host)...")
// Resolve the hostname
let hints = SocketAddress.ResolutionHints(family: .ipv4, socketType: .stream, protocol: .tcp)
let addresses = try SocketAddress.resolve(hostname: host, service: "\(port)", hints: hints)
guard let first = addresses.first else {
print("No addresses found for \(host)")
return
}
print("Connecting to \(first.address.ipv4?.description ?? "unknown")...")
// Create socket
let socket = try SocketDescriptor.open(first.family, first.socketType, protocol: first.protocol)
defer { try? socket.close() }
// Connect
try socket.connect(to: first.address)
print("Connected!")
// Send message
let messageBytes = Array(message.utf8)
let sent = try messageBytes.withUnsafeBytes { buffer in
try socket.send(UnsafeRawBufferPointer(buffer))
}
print("Sent \(sent) bytes: \(message)")
// Receive response
var buffer = [UInt8](repeating: 0, count: 4096)
let received = try buffer.withUnsafeMutableBytes { buffer in
try socket.receive(into: buffer)
}
if received > 0 {
let response = String(decoding: buffer.prefix(received), as: UTF8.self)
print("Received \(received) bytes: \(response)")
} else {
print("Connection closed by server")
}
print("Done!")
}
}
+80
View File
@@ -0,0 +1,80 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 - 2025 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
import SystemSockets
struct Listen: ParsableCommand {
static let configuration = CommandConfiguration(
abstract: "Run a simple TCP echo server"
)
@Option(name: .shortAndLong, help: "The port to listen on")
var port: UInt16 = 8080
@Option(name: .shortAndLong, help: "Maximum number of connections to accept (0 for unlimited)")
var maxConnections: Int = 0
func run() throws {
// Create socket
let server = try SocketDescriptor.open(.ipv4, .stream, protocol: .tcp)
defer { try? server.close() }
// Set reuse address
try server.setReuseAddress(true)
// Bind
let address = SocketAddress(ipv4: IPv4Address.any(port: port))
try server.bind(to: address)
// Listen
try server.listen(backlog: 5)
var localAddr = SocketAddress()
try server.getLocalAddress(into: &localAddr)
print("Listening on \(localAddr.ipv4?.description ?? "unknown")...")
var connectionCount = 0
while maxConnections == 0 || connectionCount < maxConnections {
print("Waiting for connection...")
var peerAddr = SocketAddress()
let client = try server.accept(client: &peerAddr)
connectionCount += 1
print("[\(connectionCount)] Connection from \(peerAddr.ipv4?.description ?? "unknown")")
// Handle client in a simple blocking manner
defer { try? client.close() }
var buffer = [UInt8](repeating: 0, count: 4096)
while true {
let received = try buffer.withUnsafeMutableBytes { buffer in
try client.receive(into: buffer)
}
if received == 0 {
print("[\(connectionCount)] Client disconnected")
break
}
let message = String(decoding: buffer.prefix(received), as: UTF8.self)
print("[\(connectionCount)] Received \(received) bytes: \(message)")
// Echo back
let sent = try buffer.prefix(received).withUnsafeBytes { buffer in
try client.send(UnsafeRawBufferPointer(buffer))
}
print("[\(connectionCount)] Echoed \(sent) bytes")
}
}
print("Server shutting down after \(connectionCount) connections")
}
}
+102
View File
@@ -0,0 +1,102 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 - 2025 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
import SystemSockets
struct Resolve: ParsableCommand {
static let configuration = CommandConfiguration(
abstract: "Resolve a hostname to IP addresses using getaddrinfo"
)
@Argument(help: "The hostname to resolve")
var hostname: String
@Option(name: .shortAndLong, help: "Service name or port number")
var service: String?
@Flag(name: .long, help: "Show only IPv4 addresses")
var ipv4Only: Bool = false
@Flag(name: .long, help: "Show only IPv6 addresses")
var ipv6Only: Bool = false
func run() throws {
let family: SocketDescriptor.Domain?
if ipv4Only {
family = .ipv4
} else if ipv6Only {
family = .ipv6
} else {
family = nil
}
let hints = SocketAddress.ResolutionHints(family: family)
print("Resolving \(hostname)...")
let addresses = try SocketAddress.resolve(
hostname: hostname,
service: service,
hints: hints
)
if addresses.isEmpty {
print("No addresses found")
return
}
print("Found \(addresses.count) address(es):\n")
for (index, info) in addresses.enumerated() {
print("[\(index + 1)] Family: \(familyName(info.family))")
print(" Type: \(typeName(info.socketType))")
print(" Protocol: \(protocolName(info.protocol))")
if let ipv4 = info.address.ipv4 {
print(" Address: \(ipv4.addressString):\(ipv4.port)")
} else if let ipv6 = info.address.ipv6 {
print(" Address: [\(ipv6.addressString)]:\(ipv6.port)")
}
if let canonName = info.canonicalName {
print(" Canonical: \(canonName)")
}
print()
}
}
private func familyName(_ domain: SocketDescriptor.Domain) -> String {
switch domain {
case .ipv4: return "IPv4"
case .ipv6: return "IPv6"
case .local: return "Unix"
default: return "Unknown (\(domain.rawValue))"
}
}
private func typeName(_ type: SocketDescriptor.ConnectionType) -> String {
switch type {
case .stream: return "Stream (TCP)"
case .datagram: return "Datagram (UDP)"
case .raw: return "Raw"
default: return "Unknown (\(type.rawValue))"
}
}
private func protocolName(_ proto: SocketDescriptor.ProtocolID) -> String {
switch proto {
case .tcp: return "TCP"
case .udp: return "UDP"
case .ip: return "IP"
default: return "Unknown (\(proto.rawValue))"
}
}
}
+84
View File
@@ -0,0 +1,84 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 - 2025 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
import SystemSockets
struct ReverseResolve: ParsableCommand {
static let configuration = CommandConfiguration(
abstract: "Reverse resolve an IP address to a hostname using getnameinfo"
)
@Argument(help: "The IP address to resolve (IPv4 or IPv6)")
var address: String
@Option(name: .shortAndLong, help: "Port number")
var port: UInt16 = 0
@Flag(name: .long, help: "Request numeric host (don't resolve)")
var numericHost: Bool = false
@Flag(name: .long, help: "Request numeric service (don't resolve)")
var numericService: Bool = false
func run() throws {
// Try to parse as IPv4
if let ipv4 = IPv4Address(address, port: port) {
let sockAddr = SocketAddress(ipv4: ipv4)
try resolve(sockAddr)
return
}
// Try to parse as IPv6
if let ipv6 = IPv6Address(address, port: port) {
let sockAddr = SocketAddress(ipv6: ipv6)
try resolve(sockAddr)
return
}
print("Error: '\(address)' is not a valid IPv4 or IPv6 address")
}
private func resolve(_ address: SocketAddress) throws {
var flags: SocketAddress.ReverseResolutionFlags = []
if numericHost {
flags.insert(.numericHost)
}
if numericService {
flags.insert(.numericService)
}
print("Resolving \(addressDescription(address))...")
let info = try address.reverseLookup(flags: flags)
print()
if let host = info.hostname {
print("Host: \(host)")
} else {
print("Host: (not resolved)")
}
if let service = info.service {
print("Service: \(service)")
} else {
print("Service: (not resolved)")
}
}
private func addressDescription(_ address: SocketAddress) -> String {
if let ipv4 = address.ipv4 {
return "\(ipv4.addressString):\(ipv4.port)"
} else if let ipv6 = address.ipv6 {
return "[\(ipv6.addressString)]:\(ipv6.port)"
} else {
return "(unknown address)"
}
}
}
+64
View File
@@ -0,0 +1,64 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 - 2025 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 SystemPackage
import SystemSockets
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#elseif canImport(Android)
import Android
#else
#error("Unsupported Platform")
#endif
/// Turn off libc's input/output buffering.
internal func disableBuffering() {
setbuf(stdin, nil)
setbuf(stdout, nil)
setbuf(stderr, nil)
}
internal func complain(_ message: String) {
var message = message + "\n"
message.withUTF8 { buffer in
_ = try? FileDescriptor.standardError.writeAll(buffer)
}
}
extension SocketAddress.ResolvedAddress {
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 }
if let ipv6 = self.ipv6 { return ipv6.description }
if let unix = self.unix { return unix.description }
return self.description
}
}
extension SocketDescriptor.ConnectionType {
var isConnectionless: Bool {
self == .datagram || self == .reliablyDeliveredMessage
}
}
+25
View File
@@ -0,0 +1,25 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 - 2025 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
struct SystemSamples: ParsableCommand {
static var configuration = CommandConfiguration(
commandName: "system-samples",
abstract: "A collection of little programs exercising some System features.",
subcommands: [
Resolve.self,
ReverseResolve.self,
Connect.self,
Listen.self,
])
}
disableBuffering()
SystemSamples.main()
+162 -24
View File
@@ -62,20 +62,27 @@ extension FileDescriptor {
_ sequence: S
) -> Result<Int, Errno> where S.Element == UInt8 {
sequence._withRawBufferPointer { buffer in
var idx = 0
while idx < buffer.count {
switch _write(
UnsafeRawBufferPointer(rebasing: buffer[idx...]), retryOnInterrupt: true
) {
case .success(let numBytes): idx += numBytes
case .failure(let err): return .failure(err)
}
}
assert(idx == buffer.count)
return .success(buffer.count)
_writeAllBuffer(buffer)
}
}
@_alwaysEmitIntoClient
internal func _writeAllBuffer(
_ buffer: UnsafeRawBufferPointer
) -> Result<Int, Errno> {
var idx = 0
while idx < buffer.count {
switch _write(
UnsafeRawBufferPointer(rebasing: buffer[idx...]), retryOnInterrupt: true
) {
case .success(let numBytes): idx += numBytes
case .failure(let err): return .failure(err)
}
}
assert(idx == buffer.count)
return .success(buffer.count)
}
/// Writes a sequence of bytes to the given offset.
///
/// - Parameters:
@@ -104,19 +111,150 @@ extension FileDescriptor {
toAbsoluteOffset offset: Int64, _ sequence: S
) -> Result<Int, Errno> where S.Element == UInt8 {
sequence._withRawBufferPointer { buffer in
var idx = 0
while idx < buffer.count {
switch _write(
toAbsoluteOffset: offset + Int64(idx),
UnsafeRawBufferPointer(rebasing: buffer[idx...]),
retryOnInterrupt: true
) {
case .success(let numBytes): idx += numBytes
case .failure(let err): return .failure(err)
}
}
assert(idx == buffer.count)
return .success(buffer.count)
_writeAllBuffer(toAbsoluteOffset: offset, buffer)
}
}
@_alwaysEmitIntoClient
internal func _writeAllBuffer(
toAbsoluteOffset offset: Int64, _ buffer: UnsafeRawBufferPointer
) -> Result<Int, Errno> {
var idx = 0
while idx < buffer.count {
switch _write(
toAbsoluteOffset: offset + Int64(idx),
UnsafeRawBufferPointer(rebasing: buffer[idx...]),
retryOnInterrupt: true
) {
case .success(let numBytes): idx += numBytes
case .failure(let err): return .failure(err)
}
}
assert(idx == buffer.count)
return .success(buffer.count)
}
/// Writes the entire contents of a buffer, retrying on partial writes.
///
/// - Parameters:
/// - data: The region of memory that contains the data being written.
/// - retryOnInterrupt: Whether to retry the write operation
/// if it throws ``Errno/interrupted``.
/// The default is `true`.
/// Pass `false` to try only once and throw an error upon interruption.
/// - Returns: The number of bytes that were written.
///
/// After writing,
/// this method increments the file's offset by the number of bytes written.
/// To change the file's offset,
/// call the ``seek(offset:from:)`` method.
///
/// The corresponding C function is `write`.
@available(macOS 15, iOS 18, watchOS 11, tvOS 18, visionOS 2, *)
@_alwaysEmitIntoClient
public func writeAll(
_ data: RawSpan,
retryOnInterrupt: Bool = true
) throws(Errno) -> Int {
try data.withUnsafeBytes { buffer throws(Errno) -> Int in
try _writeAllBuffer(buffer).get()
}
}
/// Writes the entire contents of a buffer at the specified offset,
/// retrying on partial writes.
///
/// - Parameters:
/// - offset: The file offset where writing begins.
/// - data: The region of memory that contains the data being written.
/// - retryOnInterrupt: Whether to retry the write operation
/// if it throws ``Errno/interrupted``.
/// The default is `true`.
/// Pass `false` to try only once and throw an error upon interruption.
/// - Returns: The number of bytes that were written.
///
/// Unlike ``writeAll(_:retryOnInterrupt:)``,
/// this method leaves the file's existing offset unchanged.
///
/// The corresponding C function is `pwrite`.
@available(macOS 15, iOS 18, watchOS 11, tvOS 18, visionOS 2, *)
@_alwaysEmitIntoClient
public func writeAll(
toAbsoluteOffset offset: Int64,
_ data: RawSpan,
retryOnInterrupt: Bool = true
) throws(Errno) -> Int {
try data.withUnsafeBytes { buffer throws(Errno) -> Int in
try _writeAllBuffer(toAbsoluteOffset: offset, buffer).get()
}
}
/// Reads bytes into a buffer, retrying until it is full.
///
/// - Parameters:
/// - buffer: The region of memory to read into.
/// - retryOnInterrupt: Whether to retry the read operation
/// if it throws ``Errno/interrupted``.
/// The default is `true`.
/// Pass `false` to try only once and throw an error upon interruption.
/// - Returns: The number of bytes that were read.
///
/// After reading,
/// this method increments the file's offset by the number of bytes read.
/// To change the file's offset,
/// call the ``seek(offset:from:)`` method.
///
/// The corresponding C function is `read`.
@available(macOS 15, iOS 18, watchOS 11, tvOS 18, visionOS 2, *)
@_alwaysEmitIntoClient
@discardableResult
public func read(
filling buffer: inout OutputRawSpan,
retryOnInterrupt: Bool = true
) throws(Errno) -> Int {
let originalCapacity = buffer.freeCapacity
while buffer.freeCapacity > 0 {
let bytesRead = try read(into: &buffer, retryOnInterrupt: retryOnInterrupt)
if bytesRead == 0 {
break // EOF
}
}
return originalCapacity - buffer.freeCapacity
}
/// Reads bytes at the specified offset into a buffer,
/// retrying until it is full.
///
/// - Parameters:
/// - offset: The file offset where reading begins.
/// - buffer: The region of memory to read into.
/// - retryOnInterrupt: Whether to retry the read operation
/// if it throws ``Errno/interrupted``.
/// The default is `true`.
/// Pass `false` to try only once and throw an error upon interruption.
/// - Returns: The number of bytes that were read.
///
/// Unlike ``read(filling:retryOnInterrupt:)``,
/// this method leaves the file's existing offset unchanged.
///
/// The corresponding C function is `pread`.
@available(macOS 15, iOS 18, watchOS 11, tvOS 18, visionOS 2, *)
@_alwaysEmitIntoClient
@discardableResult
public func read(
fromAbsoluteOffset offset: Int64,
filling buffer: inout OutputRawSpan,
retryOnInterrupt: Bool = true
) throws(Errno) -> Int {
let originalCapacity = buffer.freeCapacity
var currentOffset = offset
while buffer.freeCapacity > 0 {
let bytesRead = try read(fromAbsoluteOffset: currentOffset, into: &buffer, retryOnInterrupt: retryOnInterrupt)
if bytesRead == 0 {
break // EOF
}
currentOffset += Int64(bytesRead)
}
return originalCapacity - buffer.freeCapacity
}
}
+144
View File
@@ -365,6 +365,150 @@ extension FileDescriptor {
buffer,
retryOnInterrupt: retryOnInterrupt)
}
/// Writes the contents of a buffer at the current file offset.
///
/// - Parameters:
/// - data: The region of memory that contains the data being written.
/// - retryOnInterrupt: Whether to retry the write operation
/// if it throws ``Errno/interrupted``.
/// The default is `true`.
/// Pass `false` to try only once and throw an error upon interruption.
/// - Returns: The number of bytes that were written.
///
/// After writing,
/// this method increments the file's offset by the number of bytes written.
/// To change the file's offset,
/// call the ``seek(offset:from:)`` method.
///
/// The corresponding C function is `write`.
@available(macOS 15, iOS 18, watchOS 11, tvOS 18, visionOS 2, *)
@_alwaysEmitIntoClient
public func write(
_ data: RawSpan,
retryOnInterrupt: Bool = true
) throws(Errno) -> Int {
try data.withUnsafeBytes { bytes throws(Errno) -> Int in
try _write(bytes, retryOnInterrupt: retryOnInterrupt).get()
}
}
/// Writes the contents of a buffer at the specified offset.
///
/// - Parameters:
/// - offset: The file offset where writing begins.
/// - data: The region of memory that contains the data being written.
/// - retryOnInterrupt: Whether to retry the write operation
/// if it throws ``Errno/interrupted``.
/// The default is `true`.
/// Pass `false` to try only once and throw an error upon interruption.
/// - Returns: The number of bytes that were written.
///
/// Unlike ``write(_:retryOnInterrupt:)``,
/// this method leaves the file's existing offset unchanged.
///
/// The corresponding C function is `pwrite`.
@available(macOS 15, iOS 18, watchOS 11, tvOS 18, visionOS 2, *)
@_alwaysEmitIntoClient
public func write(
toAbsoluteOffset offset: Int64,
_ data: RawSpan,
retryOnInterrupt: Bool = true
) throws(Errno) -> Int {
try data.withUnsafeBytes { bytes throws(Errno) -> Int in
try _write(toAbsoluteOffset: offset, bytes, retryOnInterrupt: retryOnInterrupt).get()
}
}
@available(macOS 15, iOS 18, watchOS 11, tvOS 18, visionOS 2, *)
@_alwaysEmitIntoClient
internal func _readIntoOutputBuffer(
_ buffer: UnsafeMutableRawBufferPointer,
initializedCount: inout Int,
retryOnInterrupt: Bool
) -> Result<Int, Errno> {
// Read into the uninitialized portion (starting at offset 'initializedCount')
let uninitializedPortion = UnsafeMutableRawBufferPointer(
start: buffer.baseAddress?.advanced(by: initializedCount),
count: buffer.count - initializedCount
)
do {
let result = try _read(into: uninitializedPortion, retryOnInterrupt: retryOnInterrupt)
if case .success(let bytesRead) = result {
initializedCount += bytesRead // Add to existing count, don't replace it!
}
return result
} catch {
fatalError("Unexpected error from _read")
}
}
/// Reads bytes at the current file offset into a buffer.
///
/// - Parameters:
/// - buffer: The region of memory to read into.
/// - retryOnInterrupt: Whether to retry the read operation
/// if it throws ``Errno/interrupted``.
/// The default is `true`.
/// Pass `false` to try only once and throw an error upon interruption.
/// - Returns: The number of bytes that were read.
///
/// After reading,
/// this method increments the file's offset by the number of bytes read.
/// To change the file's offset,
/// call the ``seek(offset:from:)`` method.
///
/// The corresponding C function is `read`.
@available(macOS 15, iOS 18, watchOS 11, tvOS 18, visionOS 2, *)
@_alwaysEmitIntoClient
public func read(
into buffer: inout OutputRawSpan,
retryOnInterrupt: Bool = true
) throws(Errno) -> Int {
try buffer.withUnsafeMutableBytes { buf, count throws(Errno) -> Int in
try _readIntoOutputBuffer(buf, initializedCount: &count, retryOnInterrupt: retryOnInterrupt).get()
}
}
/// Reads bytes at the specified offset into a buffer.
///
/// - Parameters:
/// - offset: The file offset where reading begins.
/// - buffer: The region of memory to read into.
/// - retryOnInterrupt: Whether to retry the read operation
/// if it throws ``Errno/interrupted``.
/// The default is `true`.
/// Pass `false` to try only once and throw an error upon interruption.
/// - Returns: The number of bytes that were read.
///
/// Unlike ``read(into:retryOnInterrupt:)``,
/// this method leaves the file's existing offset unchanged.
///
/// The corresponding C function is `pread`.
@available(macOS 15, iOS 18, watchOS 11, tvOS 18, visionOS 2, *)
@_alwaysEmitIntoClient
public func read(
fromAbsoluteOffset offset: Int64,
into buffer: inout OutputRawSpan,
retryOnInterrupt: Bool = true
) throws(Errno) -> Int {
do {
return try buffer.withUnsafeMutableBytes { buf, count in
// Read into the uninitialized portion (starting at offset 'count')
let uninitializedPortion = UnsafeMutableRawBufferPointer(
start: buf.baseAddress?.advanced(by: count),
count: buf.count - count
)
let bytesRead = try read(fromAbsoluteOffset: offset, into: uninitializedPortion, retryOnInterrupt: retryOnInterrupt)
count += bytesRead // Add to existing count, don't replace it!
return bytesRead
}
} catch let error as Errno {
throw error
} catch {
fatalError("Unexpected error type")
}
}
}
#if !os(WASI)
+29
View File
@@ -0,0 +1,29 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 - 2025 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
*/
extension String {
internal init(
_unsafeUninitializedCapacity capacity: Int,
initializingUTF8With body: (UnsafeMutableBufferPointer<UInt8>) throws -> Int
) rethrows {
if #available(macOS 11, iOS 14.0, watchOS 7.0, tvOS 14.0, *) {
self = try String(
unsafeUninitializedCapacity: capacity,
initializingUTF8With: body)
return
}
let array = try Array<UInt8>(
unsafeUninitializedCapacity: capacity
) { buffer, count in
count = try body(buffer)
}
self = String(decoding: array, as: UTF8.self)
}
}
@@ -0,0 +1,100 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 - 2025 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
*/
// C interoperability types for socket operations
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif canImport(Glibc)
@_implementationOnly import CSystem
import Glibc
#elseif canImport(Musl)
@_implementationOnly import CSystem
import Musl
#elseif canImport(Android)
@_implementationOnly import CSystem
import Android
#else
#error("Unsupported Platform")
#endif
import SystemPackage
@available(System 99, *)
extension CInterop {
/// Socket address structure.
///
/// The corresponding C type is `sockaddr`.
public typealias SockAddr = sockaddr
/// Socket address length type.
///
/// The corresponding C type is `socklen_t`.
public typealias SockLen = socklen_t
/// Socket address family type.
///
/// The corresponding C type is `sa_family_t`.
public typealias SAFamily = sa_family_t
/// IPv4 socket address structure.
///
/// The corresponding C type is `sockaddr_in`.
public typealias SockAddrIn = sockaddr_in
/// IPv4 address structure.
///
/// The corresponding C type is `in_addr`.
public typealias InAddr = in_addr
/// IPv4 address type.
///
/// The corresponding C type is `in_addr_t`.
public typealias InAddrT = in_addr_t
/// IPv6 address structure.
///
/// The corresponding C type is `in6_addr`.
public typealias In6Addr = in6_addr
/// Port number type.
///
/// The corresponding C type is `in_port_t`.
public typealias InPort = in_port_t
/// IPv6 socket address structure.
///
/// The corresponding C type is `sockaddr_in6`.
public typealias SockAddrIn6 = sockaddr_in6
/// Unix domain socket address structure.
///
/// The corresponding C type is `sockaddr_un`.
public typealias SockAddrUn = sockaddr_un
/// I/O vector structure for scatter/gather I/O.
///
/// The corresponding C type is `iovec`.
public typealias IOVec = iovec
/// Message header structure for sendmsg/recvmsg.
///
/// The corresponding C type is `msghdr`.
public typealias MsgHdr = msghdr
/// Control message header structure.
///
/// The corresponding C type is `cmsghdr`.
public typealias CMsgHdr = cmsghdr
/// Address info structure for getaddrinfo.
///
/// The corresponding C type is `addrinfo`.
public typealias AddrInfo = addrinfo
}
@@ -0,0 +1,71 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 - 2025 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
*/
// Internal wrappers and typedefs for socket operations
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif canImport(Glibc)
@_implementationOnly import CSystem
import Glibc
#elseif canImport(Musl)
@_implementationOnly import CSystem
import Musl
#elseif canImport(Android)
@_implementationOnly import CSystem
import Android
#else
#error("Unsupported Platform")
#endif
import SystemPackage
// MARK: - errno access
#if SYSTEM_PACKAGE_DARWIN
internal var system_errno: CInt {
get { Darwin.errno }
set { Darwin.errno = newValue }
}
#elseif canImport(Glibc)
internal var system_errno: CInt {
get { Glibc.errno }
set { Glibc.errno = newValue }
}
#elseif canImport(Musl)
internal var system_errno: CInt {
get { Musl.errno }
set { Musl.errno = newValue }
}
#elseif canImport(Android)
internal var system_errno: CInt {
get { Android.errno }
set { Android.errno = newValue }
}
#endif
// MARK: - C stdlib functions
@usableFromInline
internal func system_strlen(_ s: UnsafePointer<CChar>) -> Int {
strlen(s)
}
@usableFromInline
internal func system_strlen(_ s: UnsafeMutablePointer<CChar>) -> Int {
strlen(s)
}
internal func system_memset(
_ buffer: UnsafeMutableRawBufferPointer,
to byte: UInt8
) {
guard buffer.count > 0 else { return }
memset(buffer.baseAddress!, CInt(byte), buffer.count)
}
@@ -0,0 +1,198 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 - 2025 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
*/
// Syscall mocking support for SystemSockets
//
// This mirrors the mocking infrastructure from SystemPackage for use in socket tests.
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#elseif canImport(Android)
import Android
#endif
import SystemPackage
#if ENABLE_MOCKING
internal struct Trace {
internal struct Entry {
internal var name: String
internal var arguments: [AnyHashable]
internal init(name: String, _ arguments: [AnyHashable]) {
self.name = name
self.arguments = arguments
}
}
private var entries: [Entry] = []
private var firstEntry: Int = 0
internal var isEmpty: Bool { firstEntry >= entries.count }
internal mutating func dequeue() -> Entry? {
guard !self.isEmpty else { return nil }
defer { firstEntry += 1 }
return entries[firstEntry]
}
fileprivate mutating func add(_ e: Entry) {
entries.append(e)
}
}
internal enum ForceErrno: Equatable {
case none
case always(errno: CInt)
case counted(errno: CInt, count: Int)
}
internal class MockingDriver {
internal var trace = Trace()
internal var forceErrno = ForceErrno.none
}
// TLS support
#if os(Windows)
internal typealias _PlatformTLSKey = DWORD
#else
internal typealias _PlatformTLSKey = pthread_key_t
#endif
private func makeTLSKey() -> _PlatformTLSKey {
#if os(Windows)
let raw: DWORD = FlsAlloc(nil)
if raw == FLS_OUT_OF_INDEXES {
fatalError("Unable to create key")
}
return raw
#else
var raw = pthread_key_t()
guard 0 == pthread_key_create(&raw, nil) else {
fatalError("Unable to create key")
}
return raw
#endif
}
private func setTLS(_ key: _PlatformTLSKey, _ p: UnsafeMutableRawPointer?) {
#if os(Windows)
guard FlsSetValue(key, p) else {
fatalError("Unable to set TLS")
}
#else
guard 0 == pthread_setspecific(key, p) else {
fatalError("Unable to set TLS")
}
#endif
}
private func getTLS(_ key: _PlatformTLSKey) -> UnsafeMutableRawPointer? {
#if os(Windows)
return FlsGetValue(key)
#else
return pthread_getspecific(key)
#endif
}
private let driverKey: _PlatformTLSKey = { makeTLSKey() }()
internal var currentMockingDriver: MockingDriver? {
guard let rawPtr = getTLS(driverKey) else { return nil }
return Unmanaged<MockingDriver>.fromOpaque(rawPtr).takeUnretainedValue()
}
extension MockingDriver {
internal static func withMockingEnabled(
_ f: (MockingDriver) throws -> ()
) rethrows {
let priorMocking = currentMockingDriver
let driver = MockingDriver()
defer {
if let object = priorMocking {
setTLS(driverKey, Unmanaged.passUnretained(object).toOpaque())
} else {
setTLS(driverKey, nil)
}
_fixLifetime(driver)
}
setTLS(driverKey, Unmanaged.passUnretained(driver).toOpaque())
return try f(driver)
}
}
@inline(never)
private var contextualMockingEnabled: Bool {
return currentMockingDriver != nil
}
extension MockingDriver {
internal static var enabled: Bool { mockingEnabled }
}
#endif // ENABLE_MOCKING
@inline(__always)
internal var mockingEnabled: Bool {
#if ENABLE_MOCKING
return contextualMockingEnabled
#else
return false
#endif
}
#if ENABLE_MOCKING
private func originalSyscallName(_ function: String) -> String {
precondition(function.starts(with: "system_"))
return String(function.dropFirst("system_".count).prefix { $0 != "(" })
}
private func mockImpl(
name: String,
_ args: [AnyHashable]
) -> CInt {
precondition(mockingEnabled)
let origName = originalSyscallName(name)
guard let driver = currentMockingDriver else {
fatalError("Mocking requested from non-mocking context")
}
driver.trace.add(Trace.Entry(name: origName, args))
switch driver.forceErrno {
case .none: break
case .always(let e):
system_errno = e
return -1
case .counted(let e, let count):
assert(count >= 1)
system_errno = e
driver.forceErrno = count > 1 ? .counted(errno: e, count: count - 1) : .none
return -1
}
return 0
}
internal func _mock(
name: String = #function, _ args: AnyHashable...
) -> CInt {
return mockImpl(name: name, args)
}
internal func _mockInt(
name: String = #function, _ args: AnyHashable...
) -> Int {
Int(mockImpl(name: name, args))
}
#endif // ENABLE_MOCKING
@@ -0,0 +1,102 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 - 2025 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
*/
// A copy-on-write fixed-size buffer of raw memory.
internal struct _RawBuffer {
internal var _storage: Storage?
internal init() {
self._storage = nil
}
internal init(minimumCapacity: Int) {
if minimumCapacity > 0 {
self._storage = Storage.create(minimumCapacity: minimumCapacity)
} else {
self._storage = nil
}
}
}
extension _RawBuffer {
internal var capacity: Int {
_storage?.header ?? 0 // Note: not capacity!
}
internal mutating func ensureUnique() {
guard _storage != nil else { return }
let unique = isKnownUniquelyReferenced(&_storage)
if !unique {
_storage = _copy(capacity: capacity)
}
}
internal func _grow(desired: Int) -> Int {
let next = Int(1.75 * Double(self.capacity))
return Swift.max(next, desired)
}
internal mutating func ensureUnique(capacity: Int) {
let unique = isKnownUniquelyReferenced(&_storage)
if !unique || self.capacity < capacity {
_storage = _copy(capacity: _grow(desired: capacity))
}
}
internal func withUnsafeBytes<R>(
_ body: (UnsafeRawBufferPointer) throws -> R
) rethrows -> R {
guard let storage = _storage else {
return try body(UnsafeRawBufferPointer(start: nil, count: 0))
}
return try storage.withUnsafeMutablePointers { count, bytes in
let buffer = UnsafeRawBufferPointer(start: bytes, count: count.pointee)
return try body(buffer)
}
}
internal mutating func withUnsafeMutableBytes<R>(
_ body: (UnsafeMutableRawBufferPointer) throws -> R
) rethrows -> R {
guard _storage != nil else {
return try body(UnsafeMutableRawBufferPointer(start: nil, count: 0))
}
ensureUnique()
return try _storage!.withUnsafeMutablePointers { count, bytes in
let buffer = UnsafeMutableRawBufferPointer(start: bytes, count: count.pointee)
return try body(buffer)
}
}
}
extension _RawBuffer {
internal class Storage: ManagedBuffer<Int, UInt8> {
internal static func create(minimumCapacity: Int) -> Storage {
Storage.create(
minimumCapacity: minimumCapacity,
makingHeaderWith: { $0.capacity }
) as! Storage
}
}
internal func _copy(capacity: Int) -> Storage {
let copy = Storage.create(minimumCapacity: capacity)
copy.withUnsafeMutablePointers { dstlen, dst in
self.withUnsafeBytes { src in
guard src.count > 0 else { return }
assert(src.count <= dstlen.pointee)
UnsafeMutableRawPointer(dst)
.copyMemory(
from: src.baseAddress!,
byteCount: Swift.min(src.count, dstlen.pointee))
}
}
return copy
}
}
@@ -0,0 +1,305 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 - 2025 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
*/
// System call wrappers for socket operations
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif canImport(Glibc)
@_implementationOnly import CSystem
import Glibc
#elseif canImport(Musl)
@_implementationOnly import CSystem
import Musl
#elseif canImport(Android)
@_implementationOnly import CSystem
import Android
#else
#error("Unsupported Platform")
#endif
import SystemPackage
// MARK: - Socket creation and management
internal func system_socket(_ domain: CInt, _ type: CInt, _ protocol: CInt) -> CInt {
#if ENABLE_MOCKING
if mockingEnabled { return _mock(domain, type, `protocol`) }
#endif
return socket(domain, type, `protocol`)
}
internal func system_shutdown(_ socket: CInt, _ how: CInt) -> CInt {
#if ENABLE_MOCKING
if mockingEnabled { return _mock(socket, how) }
#endif
return shutdown(socket, how)
}
internal func system_close(_ fd: CInt) -> CInt {
#if ENABLE_MOCKING
if mockingEnabled { return _mock(fd) }
#endif
return close(fd)
}
// MARK: - Connection operations
internal func system_bind(
_ socket: CInt,
_ addr: UnsafePointer<sockaddr>?,
_ len: socklen_t
) -> CInt {
#if ENABLE_MOCKING
if mockingEnabled { return _mock(socket, addr, len) }
#endif
return bind(socket, addr, len)
}
internal func system_listen(_ socket: CInt, _ backlog: CInt) -> CInt {
#if ENABLE_MOCKING
if mockingEnabled { return _mock(socket, backlog) }
#endif
return listen(socket, backlog)
}
internal func system_accept(
_ socket: CInt,
_ addr: UnsafeMutablePointer<sockaddr>?,
_ len: UnsafeMutablePointer<socklen_t>?
) -> CInt {
#if ENABLE_MOCKING
if mockingEnabled { return _mock(socket, addr, len) }
#endif
return accept(socket, addr, len)
}
internal func system_connect(
_ socket: CInt,
_ addr: UnsafePointer<sockaddr>?,
_ len: socklen_t
) -> CInt {
#if ENABLE_MOCKING
if mockingEnabled { return _mock(socket, addr, len) }
#endif
return connect(socket, addr, len)
}
// MARK: - Data transfer
internal func system_send(
_ socket: CInt,
_ buffer: UnsafeRawPointer?,
_ len: Int,
_ flags: CInt
) -> Int {
#if ENABLE_MOCKING
if mockingEnabled { return _mockInt(socket, buffer, len, flags) }
#endif
return send(socket, buffer, len, flags)
}
internal func system_recv(
_ socket: CInt,
_ buffer: UnsafeMutableRawPointer?,
_ len: Int,
_ flags: CInt
) -> Int {
#if ENABLE_MOCKING
if mockingEnabled { return _mockInt(socket, buffer, len, flags) }
#endif
return recv(socket, buffer, len, flags)
}
internal func system_sendto(
_ socket: CInt,
_ buffer: UnsafeRawPointer?,
_ length: Int,
_ flags: CInt,
_ dest_addr: UnsafePointer<sockaddr>?,
_ dest_len: socklen_t
) -> Int {
#if ENABLE_MOCKING
if mockingEnabled {
return _mockInt(socket, buffer, length, flags, dest_addr, dest_len)
}
#endif
return sendto(socket, buffer, length, flags, dest_addr, dest_len)
}
internal func system_recvfrom(
_ socket: CInt,
_ buffer: UnsafeMutableRawPointer?,
_ length: Int,
_ flags: CInt,
_ address: UnsafeMutablePointer<sockaddr>?,
_ address_len: UnsafeMutablePointer<socklen_t>?
) -> Int {
#if ENABLE_MOCKING
if mockingEnabled {
return _mockInt(socket, buffer, length, flags, address, address_len)
}
#endif
return recvfrom(socket, buffer, length, flags, address, address_len)
}
internal func system_sendmsg(
_ socket: CInt,
_ message: UnsafePointer<msghdr>?,
_ flags: CInt
) -> Int {
#if ENABLE_MOCKING
if mockingEnabled { return _mockInt(socket, message, flags) }
#endif
return sendmsg(socket, message, flags)
}
internal func system_recvmsg(
_ socket: CInt,
_ message: UnsafeMutablePointer<msghdr>?,
_ flags: CInt
) -> Int {
#if ENABLE_MOCKING
if mockingEnabled { return _mockInt(socket, message, flags) }
#endif
return recvmsg(socket, message, flags)
}
// MARK: - Socket options
internal func system_getsockopt(
_ socket: CInt,
_ level: CInt,
_ option: CInt,
_ value: UnsafeMutableRawPointer?,
_ length: UnsafeMutablePointer<socklen_t>?
) -> CInt {
#if ENABLE_MOCKING
if mockingEnabled { return _mock(socket, level, option, value, length) }
#endif
return getsockopt(socket, level, option, value, length)
}
internal func system_setsockopt(
_ socket: CInt,
_ level: CInt,
_ option: CInt,
_ value: UnsafeRawPointer?,
_ length: socklen_t
) -> CInt {
#if ENABLE_MOCKING
if mockingEnabled { return _mock(socket, level, option, value, length) }
#endif
return setsockopt(socket, level, option, value, length)
}
internal func system_getsockname(
_ socket: CInt,
_ addr: UnsafeMutablePointer<sockaddr>?,
_ len: UnsafeMutablePointer<socklen_t>?
) -> CInt {
#if ENABLE_MOCKING
if mockingEnabled { return _mock(socket, addr, len) }
#endif
return getsockname(socket, addr, len)
}
internal func system_getpeername(
_ socket: CInt,
_ addr: UnsafeMutablePointer<sockaddr>?,
_ len: UnsafeMutablePointer<socklen_t>?
) -> CInt {
#if ENABLE_MOCKING
if mockingEnabled { return _mock(socket, addr, len) }
#endif
return getpeername(socket, addr, len)
}
// MARK: - Address conversion
@usableFromInline
internal func system_inet_ntop(
_ af: CInt,
_ src: UnsafeRawPointer,
_ dst: UnsafeMutablePointer<CChar>,
_ size: socklen_t
) -> CInt {
#if ENABLE_MOCKING
if mockingEnabled { return _mock(af, src, dst, size) }
#endif
let res = inet_ntop(af, src, dst, size)
if Int(bitPattern: res) == 0 { return -1 }
return 0
}
@usableFromInline
internal func system_inet_pton(
_ af: CInt,
_ src: UnsafePointer<CChar>,
_ dst: UnsafeMutableRawPointer
) -> CInt {
#if ENABLE_MOCKING
if mockingEnabled { return _mock(af, src, dst) }
#endif
return inet_pton(af, src, dst)
}
// MARK: - Name resolution
internal func system_getaddrinfo(
_ hostname: UnsafePointer<CChar>?,
_ servname: UnsafePointer<CChar>?,
_ hints: UnsafePointer<addrinfo>?,
_ res: UnsafeMutablePointer<UnsafeMutablePointer<addrinfo>?>?
) -> CInt {
#if ENABLE_MOCKING
if mockingEnabled {
return _mock(
hostname.map { String(cString: $0) },
servname.map { String(cString: $0) },
hints,
res
)
}
#endif
return getaddrinfo(hostname, servname, hints, res)
}
internal func system_getnameinfo(
_ sa: UnsafePointer<sockaddr>?,
_ salen: socklen_t,
_ host: UnsafeMutablePointer<CChar>?,
_ hostlen: socklen_t,
_ serv: UnsafeMutablePointer<CChar>?,
_ servlen: socklen_t,
_ 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<addrinfo>?
) {
#if ENABLE_MOCKING
if mockingEnabled {
_ = _mock(addrinfo)
return
}
#endif
freeaddrinfo(addrinfo)
}
internal func system_gai_strerror(_ error: CInt) -> UnsafePointer<CChar> {
gai_strerror(error)
}
+22
View File
@@ -0,0 +1,22 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 - 2025 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
*/
extension FixedWidthInteger {
@_alwaysEmitIntoClient
@inline(__always)
internal var _networkOrder: Self {
bigEndian
}
@_alwaysEmitIntoClient
@inline(__always)
internal init(_networkOrder value: Self) {
self.init(bigEndian: value)
}
}
@@ -0,0 +1,110 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 - 2025 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
*/
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif canImport(Glibc)
@_implementationOnly import CSystem
import Glibc
#elseif canImport(Musl)
@_implementationOnly import CSystem
import Musl
#elseif canImport(Android)
@_implementationOnly import CSystem
import Android
#else
#error("Unsupported Platform")
#endif
import SystemPackage
@available(System 99, *)
extension SocketAddress {
@frozen
/// The address family identifier
public struct Family: RawRepresentable, Hashable {
public let rawValue: CInterop.SAFamily
@_alwaysEmitIntoClient
public init(rawValue: CInterop.SAFamily) { self.rawValue = rawValue }
@_alwaysEmitIntoClient
private init(_ rawValue: CInterop.SAFamily) { self.init(rawValue: rawValue) }
/// Unspecified address family.
///
/// The corresponding C constant is `AF_UNSPEC`.
@_alwaysEmitIntoClient
public static var unspecified: Family { Family(CInterop.SAFamily(AF_UNSPEC)) }
/// Local address family.
///
/// The corresponding C constant is `AF_LOCAL`.
@_alwaysEmitIntoClient
public static var local: Family { Family(CInterop.SAFamily(AF_LOCAL)) }
/// UNIX address family. (Renamed `local`.)
///
/// The corresponding C constant is `AF_UNIX`.
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "local")
public static var unix: Family { Family(CInterop.SAFamily(AF_UNIX)) }
/// IPv4 address family.
///
/// The corresponding C constant is `AF_INET`.
@_alwaysEmitIntoClient
public static var ipv4: Family { Family(CInterop.SAFamily(AF_INET)) }
/// Internal routing address family.
///
/// The corresponding C constant is `AF_ROUTE`.
@_alwaysEmitIntoClient
public static var routing: Family { Family(CInterop.SAFamily(AF_ROUTE)) }
/// IPv6 address family.
///
/// The corresponding C constant is `AF_INET6`.
@_alwaysEmitIntoClient
public static var ipv6: Family { Family(CInterop.SAFamily(AF_INET6)) }
#if SYSTEM_PACKAGE_DARWIN
/// System address family.
///
/// The corresponding C constant is `AF_SYSTEM`.
@_alwaysEmitIntoClient
public static var system: Family { Family(CInterop.SAFamily(AF_SYSTEM)) }
/// Raw network device address family.
///
/// The corresponding C constant is `AF_NDRV`
@_alwaysEmitIntoClient
public static var networkDevice: Family { Family(CInterop.SAFamily(AF_NDRV)) }
#endif
}
}
@available(System 99, *)
extension SocketAddress.Family: CustomStringConvertible {
public var description: String {
switch self {
case .unspecified: return "unspecified"
case .local: return "local"
case .ipv4: return "ipv4"
case .routing: return "routing"
case .ipv6: return "ipv6"
#if SYSTEM_PACKAGE_DARWIN
case .system: return "system"
case .networkDevice: return "networkDevice"
#endif
default:
return rawValue.description
}
}
}
@@ -0,0 +1,206 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 - 2025 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 SystemPackage
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#elseif canImport(Android)
import Android
#else
#error("Unsupported Platform")
#endif
/// An IPv4 socket address.
///
/// An IPv4 address consists of a 32-bit IP address and a 16-bit port number.
@frozen
@available(System 99, *)
public struct IPv4Address: Sendable, Equatable, Hashable {
/// The underlying C structure.
@usableFromInline
internal var _storage: sockaddr_in
/// Creates an IPv4 address from a raw sockaddr_in.
@_alwaysEmitIntoClient
public init(_ sockaddr: sockaddr_in) {
_storage = sockaddr
}
/// Creates an IPv4 address from an address string and port.
///
/// - Parameters:
/// - address: The IPv4 address string (e.g., "127.0.0.1").
/// - port: The port number in host byte order.
/// - Returns: `nil` if the address string is invalid.
@_alwaysEmitIntoClient
public init?(_ address: String, port: UInt16) {
var addr = sockaddr_in()
#if SYSTEM_PACKAGE_DARWIN
addr.sin_len = UInt8(MemoryLayout<sockaddr_in>.size)
#endif
addr.sin_family = sa_family_t(AF_INET)
addr.sin_port = port.bigEndian
let result = address.withCString { cString in
system_inet_pton(AF_INET, cString, &addr.sin_addr)
}
guard result == 1 else { return nil }
_storage = addr
}
/// Creates an IPv4 address representing any address (0.0.0.0).
///
/// - Parameter port: The port number in host byte order.
@_alwaysEmitIntoClient
public static func any(port: UInt16) -> IPv4Address {
var addr = sockaddr_in()
#if SYSTEM_PACKAGE_DARWIN
addr.sin_len = UInt8(MemoryLayout<sockaddr_in>.size)
#endif
addr.sin_family = sa_family_t(AF_INET)
addr.sin_port = port.bigEndian
addr.sin_addr.s_addr = INADDR_ANY.bigEndian
return IPv4Address(addr)
}
/// Creates an IPv4 address representing the loopback address (127.0.0.1).
///
/// - Parameter port: The port number in host byte order.
@_alwaysEmitIntoClient
public static func loopback(port: UInt16) -> IPv4Address {
var addr = sockaddr_in()
#if SYSTEM_PACKAGE_DARWIN
addr.sin_len = UInt8(MemoryLayout<sockaddr_in>.size)
#endif
addr.sin_family = sa_family_t(AF_INET)
addr.sin_port = port.bigEndian
addr.sin_addr.s_addr = INADDR_LOOPBACK.bigEndian
return IPv4Address(addr)
}
}
// MARK: - Properties
@available(System 99, *)
extension IPv4Address {
/// The port number in host byte order.
@_alwaysEmitIntoClient
public var port: UInt16 {
UInt16(bigEndian: _storage.sin_port)
}
/// The IP address as a string.
public var addressString: String {
var buffer = [CChar](repeating: 0, count: Int(INET_ADDRSTRLEN))
var addr = _storage.sin_addr
_ = Swift.withUnsafePointer(to: &addr) { ptr in
system_inet_ntop(AF_INET, ptr, &buffer, socklen_t(buffer.count))
}
return String(cString: buffer)
}
}
// MARK: - Pointer Access
@available(System 99, *)
extension IPv4Address {
/// Calls the given closure with a pointer to the underlying sockaddr.
@_alwaysEmitIntoClient
public func withUnsafePointer<R>(
_ body: (UnsafePointer<sockaddr>, CInterop.SockLen) throws -> R
) rethrows -> R {
try Swift.withUnsafePointer(to: _storage) { storage in
try storage.withMemoryRebound(to: sockaddr.self, capacity: 1) { sockaddr in
try body(sockaddr, CInterop.SockLen(MemoryLayout<sockaddr_in>.size))
}
}
}
}
// MARK: - CustomStringConvertible
@available(System 99, *)
extension IPv4Address: CustomStringConvertible {
public var description: String {
"\(addressString):\(port)"
}
}
// MARK: - ExpressibleByStringLiteral
@available(System 99, *)
extension IPv4Address: ExpressibleByStringLiteral {
/// Creates an IPv4 address from a string literal.
///
/// The format is "address:port" (e.g., "127.0.0.1:8080").
/// If no port is specified, port 0 is used.
public init(stringLiteral value: String) {
let parts = value.split(separator: ":", maxSplits: 1)
let address = String(parts[0])
let port: UInt16 = parts.count > 1 ? UInt16(parts[1]) ?? 0 : 0
guard let addr = IPv4Address(address, port: port) else {
fatalError("Invalid IPv4 address literal: \(value)")
}
self = addr
}
}
// MARK: - Equatable and Hashable
@available(System 99, *)
extension IPv4Address {
@_alwaysEmitIntoClient
public static func == (lhs: IPv4Address, rhs: IPv4Address) -> Bool {
lhs._storage.sin_family == rhs._storage.sin_family &&
lhs._storage.sin_port == rhs._storage.sin_port &&
lhs._storage.sin_addr.s_addr == rhs._storage.sin_addr.s_addr
}
@_alwaysEmitIntoClient
public func hash(into hasher: inout Hasher) {
hasher.combine(_storage.sin_family)
hasher.combine(_storage.sin_port)
hasher.combine(_storage.sin_addr.s_addr)
}
}
// MARK: - SocketAddress Integration
@available(System 99, *)
extension SocketAddress {
/// Creates a socket address from an IPv4 address.
@_alwaysEmitIntoClient
public init(ipv4: IPv4Address) {
self.init()
ipv4.withUnsafePointer { addr, len in
withUnsafeMutableBytes(of: &_storage) { dest in
dest.copyMemory(from: UnsafeRawBufferPointer(start: addr, count: Int(len)))
}
_length = len
}
}
/// The address as an IPv4 address, if applicable.
@_alwaysEmitIntoClient
public var ipv4: IPv4Address? {
guard family == .ipv4 else { return nil }
return Swift.withUnsafeBytes(of: _storage) { buffer in
buffer.baseAddress!.withMemoryRebound(to: sockaddr_in.self, capacity: 1) { ptr in
IPv4Address(ptr.pointee)
}
}
}
}
@@ -0,0 +1,234 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 - 2025 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 SystemPackage
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#elseif canImport(Android)
import Android
#else
#error("Unsupported Platform")
#endif
/// An IPv6 socket address.
///
/// An IPv6 address consists of a 128-bit IP address, a 16-bit port number,
/// a flow label, and a scope ID.
@frozen
@available(System 99, *)
public struct IPv6Address: Sendable, Hashable {
/// The underlying C structure.
@usableFromInline
internal var _storage: sockaddr_in6
/// Creates an IPv6 address from a raw sockaddr_in6.
@_alwaysEmitIntoClient
public init(_ sockaddr: sockaddr_in6) {
_storage = sockaddr
}
/// Creates an IPv6 address from an address string and port.
///
/// - Parameters:
/// - address: The IPv6 address string (e.g., "::1" or "2001:db8::1").
/// - port: The port number in host byte order.
/// - Returns: `nil` if the address string is invalid.
@_alwaysEmitIntoClient
public init?(_ address: String, port: UInt16) {
var addr = sockaddr_in6()
#if SYSTEM_PACKAGE_DARWIN
addr.sin6_len = UInt8(MemoryLayout<sockaddr_in6>.size)
#endif
addr.sin6_family = sa_family_t(AF_INET6)
addr.sin6_port = port.bigEndian
let result = address.withCString { cString in
system_inet_pton(AF_INET6, cString, &addr.sin6_addr)
}
guard result == 1 else { return nil }
_storage = addr
}
/// Creates an IPv6 address representing any address (::).
///
/// - Parameter port: The port number in host byte order.
@_alwaysEmitIntoClient
public static func any(port: UInt16) -> IPv6Address {
var addr = sockaddr_in6()
#if SYSTEM_PACKAGE_DARWIN
addr.sin6_len = UInt8(MemoryLayout<sockaddr_in6>.size)
#endif
addr.sin6_family = sa_family_t(AF_INET6)
addr.sin6_port = port.bigEndian
addr.sin6_addr = in6addr_any
return IPv6Address(addr)
}
/// Creates an IPv6 address representing the loopback address (::1).
///
/// - Parameter port: The port number in host byte order.
@_alwaysEmitIntoClient
public static func loopback(port: UInt16) -> IPv6Address {
var addr = sockaddr_in6()
#if SYSTEM_PACKAGE_DARWIN
addr.sin6_len = UInt8(MemoryLayout<sockaddr_in6>.size)
#endif
addr.sin6_family = sa_family_t(AF_INET6)
addr.sin6_port = port.bigEndian
addr.sin6_addr = in6addr_loopback
return IPv6Address(addr)
}
}
// MARK: - Properties
@available(System 99, *)
extension IPv6Address {
/// The port number in host byte order.
@_alwaysEmitIntoClient
public var port: UInt16 {
UInt16(bigEndian: _storage.sin6_port)
}
/// The flow label.
@_alwaysEmitIntoClient
public var flowLabel: UInt32 {
_storage.sin6_flowinfo
}
/// The scope ID.
@_alwaysEmitIntoClient
public var scopeID: UInt32 {
_storage.sin6_scope_id
}
/// The IP address as a string.
public var addressString: String {
var buffer = [CChar](repeating: 0, count: Int(INET6_ADDRSTRLEN))
var addr = _storage.sin6_addr
_ = Swift.withUnsafePointer(to: &addr) { ptr in
system_inet_ntop(AF_INET6, ptr, &buffer, socklen_t(buffer.count))
}
return String(cString: buffer)
}
}
// MARK: - Pointer Access
@available(System 99, *)
extension IPv6Address {
/// Calls the given closure with a pointer to the underlying sockaddr.
@_alwaysEmitIntoClient
public func withUnsafePointer<R>(
_ body: (UnsafePointer<sockaddr>, CInterop.SockLen) throws -> R
) rethrows -> R {
try Swift.withUnsafePointer(to: _storage) { storage in
try storage.withMemoryRebound(to: sockaddr.self, capacity: 1) { sockaddr in
try body(sockaddr, CInterop.SockLen(MemoryLayout<sockaddr_in6>.size))
}
}
}
}
// MARK: - CustomStringConvertible
@available(System 99, *)
extension IPv6Address: CustomStringConvertible {
public var description: String {
"[\(addressString)]:\(port)"
}
}
// MARK: - ExpressibleByStringLiteral
@available(System 99, *)
extension IPv6Address: ExpressibleByStringLiteral {
/// Creates an IPv6 address from a string literal.
///
/// The format is "[address]:port" (e.g., "[::1]:8080") or "address"
/// for port 0.
public init(stringLiteral value: String) {
var address = value
var port: UInt16 = 0
// Handle [address]:port format
if value.hasPrefix("[") {
if let closeBracket = value.lastIndex(of: "]") {
address = String(value[value.index(after: value.startIndex)..<closeBracket])
let afterBracket = value.index(after: closeBracket)
if afterBracket < value.endIndex && value[afterBracket] == ":" {
let portStart = value.index(after: afterBracket)
if let p = UInt16(value[portStart...]) {
port = p
}
}
}
}
guard let addr = IPv6Address(address, port: port) else {
fatalError("Invalid IPv6 address literal: \(value)")
}
self = addr
}
}
// MARK: - Equatable and Hashable
@available(System 99, *)
extension IPv6Address {
@_alwaysEmitIntoClient
public static func == (lhs: IPv6Address, rhs: IPv6Address) -> Bool {
Swift.withUnsafeBytes(of: lhs._storage) { lhsBytes in
Swift.withUnsafeBytes(of: rhs._storage) { rhsBytes in
lhsBytes.elementsEqual(rhsBytes)
}
}
}
@_alwaysEmitIntoClient
public func hash(into hasher: inout Hasher) {
Swift.withUnsafeBytes(of: _storage) { bytes in
hasher.combine(bytes: bytes)
}
}
}
// MARK: - SocketAddress Integration
@available(System 99, *)
extension SocketAddress {
/// Creates a socket address from an IPv6 address.
@_alwaysEmitIntoClient
public init(ipv6: IPv6Address) {
self.init()
ipv6.withUnsafePointer { addr, len in
withUnsafeMutableBytes(of: &_storage) { dest in
dest.copyMemory(from: UnsafeRawBufferPointer(start: addr, count: Int(len)))
}
_length = len
}
}
/// The address as an IPv6 address, if applicable.
@_alwaysEmitIntoClient
public var ipv6: IPv6Address? {
guard family == .ipv6 else { return nil }
return Swift.withUnsafeBytes(of: _storage) { buffer in
buffer.baseAddress!.withMemoryRebound(to: sockaddr_in6.self, capacity: 1) { ptr in
IPv6Address(ptr.pointee)
}
}
}
}
@@ -0,0 +1,346 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 - 2025 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 SystemPackage
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#elseif canImport(Android)
import Android
#else
#error("Unsupported Platform")
#endif
// MARK: - Address Resolution Error
/// An error returned by address resolution functions.
@frozen
@available(System 99, *)
public struct AddressResolutionError: Error, Hashable, Sendable {
/// The error code returned by getaddrinfo or getnameinfo.
public let code: CInt
@_alwaysEmitIntoClient
public init(code: CInt) {
self.code = code
}
/// A human-readable error message.
public var message: String {
String(cString: system_gai_strerror(code))
}
}
@available(System 99, *)
extension AddressResolutionError: CustomStringConvertible {
public var description: String {
"AddressResolutionError(\(code)): \(message)"
}
}
// MARK: - Resolution Hints
@available(System 99, *)
extension SocketAddress {
/// Hints for address resolution.
public struct ResolutionHints: Sendable {
/// The protocol family to search for.
public var family: SocketDescriptor.Domain?
/// The socket type to search for.
public var socketType: SocketDescriptor.ConnectionType?
/// The protocol to search for.
public var `protocol`: SocketDescriptor.ProtocolID?
/// Resolution flags.
public var flags: ResolutionFlags
/// Creates resolution hints with the given parameters.
public init(
family: SocketDescriptor.Domain? = nil,
socketType: SocketDescriptor.ConnectionType? = nil,
protocol: SocketDescriptor.ProtocolID? = nil,
flags: ResolutionFlags = []
) {
self.family = family
self.socketType = socketType
self.protocol = `protocol`
self.flags = flags
}
}
/// Flags for address resolution.
@frozen
public struct ResolutionFlags: OptionSet, Sendable {
public var rawValue: CInt
public init(rawValue: CInt) {
self.rawValue = rawValue
}
/// Use passive socket for binding.
///
/// The corresponding C constant is `AI_PASSIVE`.
public static var passive: ResolutionFlags { ResolutionFlags(rawValue: AI_PASSIVE) }
/// Return canonical name.
///
/// The corresponding C constant is `AI_CANONNAME`.
public static var canonicalName: ResolutionFlags { ResolutionFlags(rawValue: AI_CANONNAME) }
/// Address must be numeric.
///
/// The corresponding C constant is `AI_NUMERICHOST`.
public static var numericHost: ResolutionFlags { ResolutionFlags(rawValue: AI_NUMERICHOST) }
/// Service must be numeric.
///
/// The corresponding C constant is `AI_NUMERICSERV`.
public static var numericService: ResolutionFlags { ResolutionFlags(rawValue: AI_NUMERICSERV) }
/// Return IPv4-mapped IPv6 addresses.
///
/// The corresponding C constant is `AI_V4MAPPED`.
public static var v4Mapped: ResolutionFlags { ResolutionFlags(rawValue: AI_V4MAPPED) }
/// Return both IPv4 and IPv6 addresses.
///
/// The corresponding C constant is `AI_ALL`.
public static var all: ResolutionFlags { ResolutionFlags(rawValue: AI_ALL) }
/// Return addresses only if configured.
///
/// The corresponding C constant is `AI_ADDRCONFIG`.
public static var addressConfigured: ResolutionFlags { ResolutionFlags(rawValue: AI_ADDRCONFIG) }
}
}
// MARK: - Resolution Result
@available(System 99, *)
extension SocketAddress {
/// A result from address resolution.
public struct ResolvedAddress: Sendable {
/// The socket domain.
public let family: SocketDescriptor.Domain
/// The socket type.
public let socketType: SocketDescriptor.ConnectionType
/// The socket protocol.
public let `protocol`: SocketDescriptor.ProtocolID
/// The resolved socket address.
public let address: SocketAddress
/// The canonical name, if requested and available.
public let canonicalName: String?
internal init(
family: SocketDescriptor.Domain,
socketType: SocketDescriptor.ConnectionType,
protocol: SocketDescriptor.ProtocolID,
address: SocketAddress,
canonicalName: String?
) {
self.family = family
self.socketType = socketType
self.protocol = `protocol`
self.address = address
self.canonicalName = canonicalName
}
}
}
// MARK: - Address Resolution
@available(System 99, *)
extension SocketAddress {
/// Resolves a hostname and service to a list of socket addresses.
///
/// - Parameters:
/// - hostname: The hostname to resolve, or `nil` for the local host.
/// - service: The service name or port number, or `nil`.
/// - hints: Hints to narrow the search.
/// - Returns: An array of resolved addresses.
/// - Throws: `AddressResolutionError` if resolution fails.
///
/// The corresponding C function is `getaddrinfo`.
public static func resolve(
hostname: String? = nil,
service: String? = nil,
hints: ResolutionHints = ResolutionHints()
) throws -> [ResolvedAddress] {
var hintsStruct = addrinfo()
hintsStruct.ai_flags = hints.flags.rawValue
if let family = hints.family {
hintsStruct.ai_family = family.rawValue
}
if let socketType = hints.socketType {
hintsStruct.ai_socktype = socketType.rawValue
}
if let proto = hints.protocol {
hintsStruct.ai_protocol = proto.rawValue
}
var result: UnsafeMutablePointer<addrinfo>?
let errorCode: CInt = hostname._withOptionalCString { hostnamePtr in
service._withOptionalCString { servicePtr in
system_getaddrinfo(hostnamePtr, servicePtr, &hintsStruct, &result)
}
}
guard errorCode == 0 else {
throw AddressResolutionError(code: errorCode)
}
defer { system_freeaddrinfo(result) }
var addresses: [ResolvedAddress] = []
var current = result
while let info = current {
let family = SocketDescriptor.Domain(rawValue: info.pointee.ai_family)
let socketType = SocketDescriptor.ConnectionType(rawValue: info.pointee.ai_socktype)
let proto = SocketDescriptor.ProtocolID(rawValue: info.pointee.ai_protocol)
let address: SocketAddress
if let addr = info.pointee.ai_addr {
address = SocketAddress(
address: addr,
length: info.pointee.ai_addrlen
)
} else {
address = SocketAddress()
}
let canonicalName: String?
if let name = info.pointee.ai_canonname {
canonicalName = String(cString: name)
} else {
canonicalName = nil
}
addresses.append(ResolvedAddress(
family: family,
socketType: socketType,
protocol: proto,
address: address,
canonicalName: canonicalName
))
current = info.pointee.ai_next
}
return addresses
}
}
// MARK: - Reverse Resolution
@available(System 99, *)
extension SocketAddress {
/// Flags for reverse resolution.
@frozen
public struct ReverseResolutionFlags: OptionSet, Sendable {
public var rawValue: CInt
public init(rawValue: CInt) {
self.rawValue = rawValue
}
/// Return numeric host.
///
/// The corresponding C constant is `NI_NUMERICHOST`.
public static var numericHost: ReverseResolutionFlags { ReverseResolutionFlags(rawValue: NI_NUMERICHOST) }
/// Return numeric service.
///
/// The corresponding C constant is `NI_NUMERICSERV`.
public static var numericService: ReverseResolutionFlags { ReverseResolutionFlags(rawValue: NI_NUMERICSERV) }
/// Look up datagram service.
///
/// The corresponding C constant is `NI_DGRAM`.
public static var datagram: ReverseResolutionFlags { ReverseResolutionFlags(rawValue: NI_DGRAM) }
/// Return only the hostname part of FQDN.
///
/// The corresponding C constant is `NI_NOFQDN`.
public static var noFullyQualified: ReverseResolutionFlags { ReverseResolutionFlags(rawValue: NI_NOFQDN) }
/// Fail if name cannot be determined.
///
/// The corresponding C constant is `NI_NAMEREQD`.
public static var nameRequired: ReverseResolutionFlags { ReverseResolutionFlags(rawValue: NI_NAMEREQD) }
}
/// A result from reverse resolution.
public struct ReverseLookupResult: Sendable {
/// The hostname.
public let hostname: String?
/// The service name.
public let service: String?
}
/// Resolves this address to a hostname and service.
///
/// - Parameter flags: Flags controlling the resolution.
/// - Returns: The hostname and service.
/// - Throws: `AddressResolutionError` if resolution fails.
///
/// The corresponding C function is `getnameinfo`.
public func reverseLookup(
flags: ReverseResolutionFlags = []
) throws -> ReverseLookupResult {
var hostname = [CChar](repeating: 0, count: Int(NI_MAXHOST))
var service = [CChar](repeating: 0, count: Int(NI_MAXSERV))
let errorCode = withUnsafePointer { addr, len in
system_getnameinfo(
addr,
len,
&hostname,
socklen_t(hostname.count),
&service,
socklen_t(service.count),
flags.rawValue
)
}
guard errorCode == 0 else {
throw AddressResolutionError(code: errorCode)
}
let hostnameStr = hostname[0] != 0 ? String(cString: hostname) : nil
let serviceStr = service[0] != 0 ? String(cString: service) : nil
return ReverseLookupResult(hostname: hostnameStr, service: serviceStr)
}
}
// MARK: - Helpers
extension Optional where Wrapped == String {
func _withOptionalCString<R>(_ body: (UnsafePointer<CChar>?) throws -> R) rethrows -> R {
switch self {
case .none:
return try body(nil)
case .some(let string):
return try string.withCString(body)
}
}
}
@@ -0,0 +1,176 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 - 2025 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 SystemPackage
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#elseif canImport(Android)
import Android
#else
#error("Unsupported Platform")
#endif
/// A Unix domain socket address.
///
/// Unix domain socket addresses use a filesystem path to identify the socket.
@frozen
@available(System 99, *)
public struct UnixAddress: Sendable, Equatable, Hashable {
/// The underlying C structure.
@usableFromInline
internal var _storage: sockaddr_un
/// The length of the path (not including null terminator).
@usableFromInline
internal var _pathLength: Int
/// Creates a Unix address from a raw sockaddr_un.
@_alwaysEmitIntoClient
public init(_ sockaddr: sockaddr_un) {
_storage = sockaddr
// Calculate path length from the stored data
_pathLength = withUnsafeBytes(of: sockaddr.sun_path) { bytes in
bytes.prefix(while: { $0 != 0 }).count
}
}
/// Creates a Unix address from a path string.
///
/// - Parameter path: The filesystem path for the socket.
/// - Returns: `nil` if the path is too long.
@_alwaysEmitIntoClient
public init?(_ path: String) {
var addr = sockaddr_un()
#if SYSTEM_PACKAGE_DARWIN
addr.sun_len = UInt8(MemoryLayout<sockaddr_un>.size)
#endif
addr.sun_family = sa_family_t(AF_UNIX)
let maxPathLength = MemoryLayout.size(ofValue: addr.sun_path) - 1 // Leave room for null
let copied = path.withCString { cString in
let len = system_strlen(cString)
guard len <= maxPathLength else { return -1 }
withUnsafeMutableBytes(of: &addr.sun_path) { dest in
dest.copyMemory(from: UnsafeRawBufferPointer(start: cString, count: len + 1))
}
return len
}
guard copied >= 0 else { return nil }
_storage = addr
_pathLength = copied
}
}
// MARK: - Properties
@available(System 99, *)
extension UnixAddress {
/// The path as a string.
public var path: String {
withUnsafeBytes(of: _storage.sun_path) { bytes in
let pathBytes = bytes.prefix(_pathLength)
return pathBytes.withMemoryRebound(to: CChar.self) { chars in
String(cString: chars.baseAddress!)
}
}
}
}
// MARK: - Pointer Access
@available(System 99, *)
extension UnixAddress {
/// Calls the given closure with a pointer to the underlying sockaddr.
@_alwaysEmitIntoClient
public func withUnsafePointer<R>(
_ body: (UnsafePointer<sockaddr>, CInterop.SockLen) throws -> R
) rethrows -> R {
try Swift.withUnsafePointer(to: _storage) { storage in
try storage.withMemoryRebound(to: sockaddr.self, capacity: 1) { sockaddr in
// Length includes sun_family plus the path (including null terminator)
let length = MemoryLayout<sa_family_t>.size + _pathLength + 1
#if SYSTEM_PACKAGE_DARWIN
let actualLength = MemoryLayout<UInt8>.size + length // Include sun_len
#else
let actualLength = length
#endif
return try body(sockaddr, CInterop.SockLen(actualLength))
}
}
}
}
// MARK: - CustomStringConvertible
@available(System 99, *)
extension UnixAddress: CustomStringConvertible {
public var description: String {
path
}
}
// MARK: - Equatable and Hashable
@available(System 99, *)
extension UnixAddress {
@_alwaysEmitIntoClient
public static func == (lhs: UnixAddress, rhs: UnixAddress) -> Bool {
lhs._pathLength == rhs._pathLength &&
Swift.withUnsafeBytes(of: lhs._storage.sun_path) { lhsBytes in
Swift.withUnsafeBytes(of: rhs._storage.sun_path) { rhsBytes in
lhsBytes.prefix(lhs._pathLength).elementsEqual(rhsBytes.prefix(rhs._pathLength))
}
}
}
@_alwaysEmitIntoClient
public func hash(into hasher: inout Hasher) {
hasher.combine(_pathLength)
Swift.withUnsafeBytes(of: _storage.sun_path) { bytes in
hasher.combine(bytes: UnsafeRawBufferPointer(rebasing: bytes.prefix(_pathLength)))
}
}
}
// MARK: - SocketAddress Integration
@available(System 99, *)
extension SocketAddress {
/// Creates a socket address from a Unix address.
@_alwaysEmitIntoClient
public init(unix: UnixAddress) {
self.init()
unix.withUnsafePointer { addr, len in
withUnsafeMutableBytes(of: &_storage) { dest in
dest.copyMemory(from: UnsafeRawBufferPointer(start: addr, count: Int(len)))
}
_length = len
}
}
/// The address as a Unix address, if applicable.
@_alwaysEmitIntoClient
public var unix: UnixAddress? {
guard family == .local else { return nil }
return Swift.withUnsafeBytes(of: _storage) { buffer in
buffer.baseAddress!.withMemoryRebound(to: sockaddr_un.self, capacity: 1) { ptr in
UnixAddress(ptr.pointee)
}
}
}
}
@@ -0,0 +1,223 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 - 2025 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 SystemPackage
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#elseif canImport(Android)
import Android
#else
#error("Unsupported Platform")
#endif
/// An opaque type representing a socket address.
///
/// `SocketAddress` is a type-erased container that can hold any socket address,
/// including IPv4, IPv6, and Unix domain addresses. It provides a unified
/// interface for socket operations that work with different address families.
///
/// To create a socket address for a specific family, use one of the convenience
/// initializers:
///
/// ```swift
/// // IPv4 address
/// let ipv4 = SocketAddress(ipv4: IPv4Address("127.0.0.1", port: 8080)!)
///
/// // IPv6 address
/// let ipv6 = SocketAddress(ipv6: IPv6Address.loopback(port: 80))
///
/// // Unix domain socket
/// let local = SocketAddress(unix: UnixAddress("/tmp/socket.sock")!)
/// ```
///
/// `SocketAddress` uses `sockaddr_storage` internally, which is large enough
/// to hold any socket address type.
@frozen
@available(System 99, *)
public struct SocketAddress: Sendable {
/// The underlying storage using sockaddr_storage.
@usableFromInline
internal var _storage: sockaddr_storage
/// The actual length of the address data.
@usableFromInline
internal var _length: CInterop.SockLen
/// Creates an empty socket address with unspecified family.
@_alwaysEmitIntoClient
public init() {
_storage = sockaddr_storage()
_length = 0
}
/// Creates a socket address from raw bytes.
///
/// - Parameters:
/// - address: Pointer to the socket address.
/// - length: The length of the address.
@_alwaysEmitIntoClient
public init(
address: UnsafePointer<CInterop.SockAddr>,
length: CInterop.SockLen
) {
_storage = sockaddr_storage()
_length = min(length, CInterop.SockLen(MemoryLayout<sockaddr_storage>.size))
withUnsafeMutableBytes(of: &_storage) { dest in
dest.copyMemory(from: UnsafeRawBufferPointer(start: address, count: Int(_length)))
}
}
/// Creates a socket address from a raw buffer.
@_alwaysEmitIntoClient
public init(_ buffer: UnsafeRawBufferPointer) {
_storage = sockaddr_storage()
_length = CInterop.SockLen(min(buffer.count, MemoryLayout<sockaddr_storage>.size))
if buffer.count > 0 {
withUnsafeMutableBytes(of: &_storage) { dest in
dest.copyMemory(from: UnsafeRawBufferPointer(rebasing: buffer.prefix(Int(_length))))
}
}
}
}
// MARK: - Properties
@available(System 99, *)
extension SocketAddress {
/// The address family of this socket address.
@_alwaysEmitIntoClient
public var family: SocketDescriptor.Domain {
Swift.withUnsafeBytes(of: _storage) { buffer in
let sockaddr = buffer.baseAddress!.assumingMemoryBound(to: sockaddr.self)
return SocketDescriptor.Domain(rawValue: CInt(sockaddr.pointee.sa_family))
}
}
/// The length of this socket address in bytes.
@_alwaysEmitIntoClient
public var length: Int {
Int(_length)
}
/// Whether this address is empty (length is 0).
@_alwaysEmitIntoClient
public var isEmpty: Bool {
_length == 0
}
}
// MARK: - Accessing Raw Bytes
@available(System 99, *)
extension SocketAddress {
/// Calls the given closure with a pointer to the underlying socket address.
@_alwaysEmitIntoClient
public func withUnsafePointer<R>(
_ body: (UnsafePointer<sockaddr>, CInterop.SockLen) throws -> R
) rethrows -> R {
try Swift.withUnsafePointer(to: _storage) { storage in
try storage.withMemoryRebound(to: sockaddr.self, capacity: 1) { sockaddr in
try body(sockaddr, _length)
}
}
}
/// Calls the given closure with a mutable pointer to the underlying storage.
@_alwaysEmitIntoClient
public mutating func _withUnsafeMutablePointer<R>(
_ body: (UnsafeMutablePointer<sockaddr>, inout CInterop.SockLen) throws -> R
) rethrows -> R {
var len = CInterop.SockLen(MemoryLayout<sockaddr_storage>.size)
let result = try Swift.withUnsafeMutablePointer(to: &_storage) { storage in
try storage.withMemoryRebound(to: sockaddr.self, capacity: 1) { sockaddr in
try body(sockaddr, &len)
}
}
_length = len
return result
}
/// Accesses the raw bytes of the socket address.
@_alwaysEmitIntoClient
public func withUnsafeBytes<R>(
_ body: (UnsafeRawBufferPointer) throws -> R
) rethrows -> R {
try Swift.withUnsafeBytes(of: _storage) { buffer in
try body(UnsafeRawBufferPointer(rebasing: buffer.prefix(Int(_length))))
}
}
/// Resets this address to an empty state.
@_alwaysEmitIntoClient
public mutating func clear() {
_storage = sockaddr_storage()
_length = 0
}
}
// MARK: - Equatable and Hashable
@available(System 99, *)
extension SocketAddress: Equatable {
@_alwaysEmitIntoClient
public static func == (lhs: SocketAddress, rhs: SocketAddress) -> Bool {
guard lhs._length == rhs._length else { return false }
return lhs.withUnsafeBytes { lhsBytes in
rhs.withUnsafeBytes { rhsBytes in
lhsBytes.elementsEqual(rhsBytes)
}
}
}
}
@available(System 99, *)
extension SocketAddress: Hashable {
@_alwaysEmitIntoClient
public func hash(into hasher: inout Hasher) {
hasher.combine(_length)
withUnsafeBytes { buffer in
hasher.combine(bytes: buffer)
}
}
}
// MARK: - CustomStringConvertible
@available(System 99, *)
extension SocketAddress: CustomStringConvertible {
public var description: String {
if isEmpty {
return "SocketAddress(empty)"
}
switch family {
case .ipv4:
if let ipv4 = self.ipv4 {
return "SocketAddress(\(ipv4))"
}
case .ipv6:
if let ipv6 = self.ipv6 {
return "SocketAddress(\(ipv6))"
}
case .local:
if let unix = self.unix {
return "SocketAddress(\(unix))"
}
default:
break
}
return "SocketAddress(family: \(family), length: \(_length))"
}
}
@@ -0,0 +1,440 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 - 2025 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 SystemPackage
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#elseif canImport(Android)
import Android
#else
#error("Unsupported Platform")
#endif
/// A socket descriptor.
///
/// A `SocketDescriptor` is a type-safe wrapper around an operating system
/// socket handle. It provides a strongly-typed interface for socket operations.
///
/// Unlike `FileDescriptor`, a `SocketDescriptor` explicitly represents a
/// socket rather than a general file descriptor, enabling socket-specific
/// operations like `bind`, `listen`, `accept`, and `connect`.
@frozen
@available(System 99, *)
public struct SocketDescriptor: RawRepresentable, Hashable, Codable, Sendable {
/// The raw C socket handle.
@_alwaysEmitIntoClient
public let rawValue: CInt
/// Creates a strongly-typed socket descriptor from a raw C socket handle.
@_alwaysEmitIntoClient
public init(rawValue: CInt) { self.rawValue = rawValue }
}
@available(System 99, *)
extension SocketDescriptor {
/// The file descriptor for this socket.
///
/// On POSIX systems, sockets are file descriptors and can be used with
/// file descriptor operations like `read`, `write`, and `close`.
@_alwaysEmitIntoClient
public var fileDescriptor: FileDescriptor {
FileDescriptor(rawValue: rawValue)
}
/// Creates a socket descriptor from a file descriptor without verification.
///
/// This initializer does not verify that the file descriptor actually
/// refers to a socket. Use with caution.
@_alwaysEmitIntoClient
public init(unchecked fd: FileDescriptor) {
self.init(rawValue: fd.rawValue)
}
}
// MARK: - Domain (Protocol Family)
@available(System 99, *)
extension SocketDescriptor {
/// Communications domain, identifying the protocol family.
///
/// The domain specifies the protocol family to be used for communication.
/// Common domains include `.ipv4` for IPv4, `.ipv6` for IPv6, and `.local`
/// for Unix domain sockets.
@frozen
public struct Domain: RawRepresentable, Hashable, Sendable, CustomStringConvertible {
@_alwaysEmitIntoClient
public var rawValue: CInt
@_alwaysEmitIntoClient
public init(rawValue: CInt) { self.rawValue = rawValue }
@_alwaysEmitIntoClient
internal init(_ rawValue: CInt) { self.init(rawValue: rawValue) }
/// Unspecified protocol.
///
/// The corresponding C constant is `PF_UNSPEC`.
@_alwaysEmitIntoClient
public static var unspecified: Domain { Domain(PF_UNSPEC) }
/// Local (Unix domain) communication.
///
/// The corresponding C constant is `PF_LOCAL` (also known as `PF_UNIX`).
@_alwaysEmitIntoClient
public static var local: Domain { Domain(PF_LOCAL) }
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "local")
public static var unix: Domain { Domain(PF_UNIX) }
/// Internet Protocol version 4.
///
/// The corresponding C constant is `PF_INET`.
@_alwaysEmitIntoClient
public static var ipv4: Domain { Domain(PF_INET) }
/// Internet Protocol version 6.
///
/// The corresponding C constant is `PF_INET6`.
@_alwaysEmitIntoClient
public static var ipv6: Domain { Domain(PF_INET6) }
/// Internal routing protocol.
///
/// The corresponding C constant is `PF_ROUTE`.
@_alwaysEmitIntoClient
public static var routing: Domain { Domain(PF_ROUTE) }
/// Internal key-management function.
///
/// The corresponding C constant is `PF_KEY`.
@_alwaysEmitIntoClient
public static var keyManagement: Domain { Domain(PF_KEY) }
#if SYSTEM_PACKAGE_DARWIN
/// System domain.
///
/// The corresponding C constant is `PF_SYSTEM`.
@_alwaysEmitIntoClient
public static var system: Domain { Domain(PF_SYSTEM) }
/// Raw access to network device.
///
/// The corresponding C constant is `PF_NDRV`.
@_alwaysEmitIntoClient
public static var networkDevice: Domain { Domain(PF_NDRV) }
#endif
public var description: String {
switch self {
case .unspecified: return "unspecified"
case .local: return "local"
case .ipv4: return "ipv4"
case .ipv6: return "ipv6"
case .routing: return "routing"
case .keyManagement: return "keyManagement"
#if SYSTEM_PACKAGE_DARWIN
case .system: return "system"
case .networkDevice: return "networkDevice"
#endif
default: return "Domain(\(rawValue))"
}
}
}
}
// MARK: - Connection Type (Socket Type)
@available(System 99, *)
extension SocketDescriptor {
/// The socket type, specifying the semantics of communication.
///
/// The connection type determines how data is transmitted. Stream sockets
/// provide reliable, ordered byte streams, while datagram sockets provide
/// connectionless, unreliable messages.
@frozen
public struct ConnectionType: RawRepresentable, Hashable, Sendable, CustomStringConvertible {
@_alwaysEmitIntoClient
public var rawValue: CInt
@_alwaysEmitIntoClient
public init(rawValue: CInt) { self.rawValue = rawValue }
@_alwaysEmitIntoClient
internal init(_ rawValue: CInt) { self.init(rawValue: rawValue) }
/// Sequenced, reliable, two-way, connection-based byte streams.
///
/// The corresponding C constant is `SOCK_STREAM`.
@_alwaysEmitIntoClient
public static var stream: ConnectionType { ConnectionType(SOCK_STREAM) }
/// Connectionless, unreliable datagrams of a fixed maximum length.
///
/// The corresponding C constant is `SOCK_DGRAM`.
@_alwaysEmitIntoClient
public static var datagram: ConnectionType { ConnectionType(SOCK_DGRAM) }
/// Raw network protocol access.
///
/// The corresponding C constant is `SOCK_RAW`.
@_alwaysEmitIntoClient
public static var raw: ConnectionType { ConnectionType(SOCK_RAW) }
/// Reliably-delivered message.
///
/// The corresponding C constant is `SOCK_RDM`.
@_alwaysEmitIntoClient
public static var reliablyDeliveredMessage: ConnectionType {
ConnectionType(SOCK_RDM)
}
/// Sequenced packet stream.
///
/// The corresponding C constant is `SOCK_SEQPACKET`.
@_alwaysEmitIntoClient
public static var sequencedPacketStream: ConnectionType {
ConnectionType(SOCK_SEQPACKET)
}
public var description: String {
switch self {
case .stream: return "stream"
case .datagram: return "datagram"
case .raw: return "raw"
case .reliablyDeliveredMessage: return "rdm"
case .sequencedPacketStream: return "seqpacket"
default: return "ConnectionType(\(rawValue))"
}
}
}
}
// MARK: - Protocol ID
@available(System 99, *)
extension SocketDescriptor {
/// Identifies a particular protocol to use for communication.
///
/// Protocol numbers are specific to the communication domain. Some symbolic
/// names may have the same underlying value in different contexts.
@frozen
public struct ProtocolID: RawRepresentable, Hashable, Sendable, CustomStringConvertible {
@_alwaysEmitIntoClient
public var rawValue: CInt
@_alwaysEmitIntoClient
public init(rawValue: CInt) { self.rawValue = rawValue }
@_alwaysEmitIntoClient
internal init(_ rawValue: CInt) { self.init(rawValue: rawValue) }
/// Default protocol for the socket type.
@_alwaysEmitIntoClient
public static var `default`: ProtocolID { Self(0) }
/// Internet Protocol (IP).
///
/// The corresponding C constant is `IPPROTO_IP`.
@_alwaysEmitIntoClient
public static var ip: ProtocolID { Self(IPPROTO_IP) }
/// Transmission Control Protocol (TCP).
///
/// The corresponding C constant is `IPPROTO_TCP`.
@_alwaysEmitIntoClient
public static var tcp: ProtocolID { Self(IPPROTO_TCP) }
/// User Datagram Protocol (UDP).
///
/// The corresponding C constant is `IPPROTO_UDP`.
@_alwaysEmitIntoClient
public static var udp: ProtocolID { Self(IPPROTO_UDP) }
/// IPv4 encapsulation.
///
/// The corresponding C constant is `IPPROTO_IPV4`.
@_alwaysEmitIntoClient
public static var ipv4: ProtocolID { Self(IPPROTO_IPV4) }
/// IPv6 header.
///
/// The corresponding C constant is `IPPROTO_IPV6`.
@_alwaysEmitIntoClient
public static var ipv6: ProtocolID { Self(IPPROTO_IPV6) }
/// Raw IP packet.
///
/// The corresponding C constant is `IPPROTO_RAW`.
@_alwaysEmitIntoClient
public static var raw: ProtocolID { Self(IPPROTO_RAW) }
public var description: String {
rawValue.description
}
}
}
// MARK: - Message Flags
@available(System 99, *)
extension SocketDescriptor {
/// Flags for send and receive operations.
@frozen
public struct MessageFlags: OptionSet, Sendable, CustomStringConvertible {
@_alwaysEmitIntoClient
public var rawValue: CInt
@_alwaysEmitIntoClient
public init(rawValue: CInt) { self.rawValue = rawValue }
@_alwaysEmitIntoClient
private init(_ raw: CInt) { self.init(rawValue: raw) }
/// No flags.
@_alwaysEmitIntoClient
public static var none: MessageFlags { MessageFlags(0) }
/// Process out-of-band data.
///
/// The corresponding C constant is `MSG_OOB`.
@_alwaysEmitIntoClient
public static var outOfBand: MessageFlags { MessageFlags(MSG_OOB) }
/// Bypass routing, use direct interface.
///
/// The corresponding C constant is `MSG_DONTROUTE`.
@_alwaysEmitIntoClient
public static var doNotRoute: MessageFlags { MessageFlags(MSG_DONTROUTE) }
/// Peek at incoming message without removing it.
///
/// The corresponding C constant is `MSG_PEEK`.
@_alwaysEmitIntoClient
public static var peek: MessageFlags { MessageFlags(MSG_PEEK) }
/// Wait for full request or error.
///
/// The corresponding C constant is `MSG_WAITALL`.
@_alwaysEmitIntoClient
public static var waitForAll: MessageFlags { MessageFlags(MSG_WAITALL) }
/// End-of-record marker.
///
/// The corresponding C constant is `MSG_EOR`.
@_alwaysEmitIntoClient
public static var endOfRecord: MessageFlags { MessageFlags(MSG_EOR) }
/// Data was truncated.
///
/// The corresponding C constant is `MSG_TRUNC`.
@_alwaysEmitIntoClient
public static var dataTruncated: MessageFlags { MessageFlags(MSG_TRUNC) }
/// Control data was truncated.
///
/// The corresponding C constant is `MSG_CTRUNC`.
@_alwaysEmitIntoClient
public static var controlTruncated: MessageFlags { MessageFlags(MSG_CTRUNC) }
#if !SYSTEM_PACKAGE_DARWIN
/// Do not generate SIGPIPE on broken pipe.
///
/// The corresponding C constant is `MSG_NOSIGNAL`.
@_alwaysEmitIntoClient
public static var noSignal: MessageFlags { MessageFlags(MSG_NOSIGNAL) }
#endif
public var description: String {
var descriptions: [(Element, StaticString)] = [
(.outOfBand, ".outOfBand"),
(.doNotRoute, ".doNotRoute"),
(.peek, ".peek"),
(.waitForAll, ".waitForAll"),
(.endOfRecord, ".endOfRecord"),
(.dataTruncated, ".dataTruncated"),
(.controlTruncated, ".controlTruncated"),
]
#if !SYSTEM_PACKAGE_DARWIN
descriptions.append((.noSignal, ".noSignal"))
#endif
return _buildDescription(descriptions)
}
}
}
// MARK: - Shutdown Kind
@available(System 99, *)
extension SocketDescriptor {
/// Specifies which parts of a full-duplex connection to shut down.
@frozen
public struct ShutdownKind: RawRepresentable, Hashable, Sendable, CustomStringConvertible {
@_alwaysEmitIntoClient
public var rawValue: CInt
@_alwaysEmitIntoClient
public init(rawValue: CInt) { self.rawValue = rawValue }
/// Disallow further receives.
///
/// The corresponding C constant is `SHUT_RD`.
@_alwaysEmitIntoClient
public static var read: ShutdownKind { ShutdownKind(rawValue: SHUT_RD) }
/// Disallow further sends.
///
/// The corresponding C constant is `SHUT_WR`.
@_alwaysEmitIntoClient
public static var write: ShutdownKind { ShutdownKind(rawValue: SHUT_WR) }
/// Disallow further sends and receives.
///
/// The corresponding C constant is `SHUT_RDWR`.
@_alwaysEmitIntoClient
public static var readWrite: ShutdownKind { ShutdownKind(rawValue: SHUT_RDWR) }
public var description: String {
switch self {
case .read: return "read"
case .write: return "write"
case .readWrite: return "readWrite"
default: return "ShutdownKind(\(rawValue))"
}
}
}
}
// MARK: - Socket Option
@available(System 99, *)
extension SocketDescriptor {
/// A generic socket option identifier.
///
/// This type represents raw socket option constants that can be used
/// with ancillary messages or generic get/set socket option operations.
@frozen
public struct Option: RawRepresentable, Hashable, Sendable, CustomStringConvertible {
@_alwaysEmitIntoClient
public var rawValue: CInt
@_alwaysEmitIntoClient
public init(rawValue: CInt) { self.rawValue = rawValue }
@_alwaysEmitIntoClient
private init(_ rawValue: CInt) { self.init(rawValue: rawValue) }
public var description: String { "Option(\(rawValue))" }
}
}
@@ -0,0 +1,45 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 - 2025 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 SystemPackage
@available(System 99, *)
extension SocketDescriptor {
/// Writes a sequence of bytes to the socket
///
/// This is equivalent to calling `fileDescriptor.writeAll(_:)`
///
/// - Parameter sequence: The bytes to write.
/// - Returns: The number of bytes written, equal to the number of elements in `sequence`.
@_alwaysEmitIntoClient
@discardableResult
public func writeAll<S: Sequence>(
_ sequence: S
) throws -> Int where S.Element == UInt8 {
try fileDescriptor.writeAll(sequence)
}
/// Runs a closure and then closes the socket, even if an error occurs.
///
/// This is equivalent to calling `fileDescriptor.closeAfter(_:)`
///
/// - Parameter body: The closure to run.
/// If the closure throws an error,
/// this method closes the socket before it rethrows that error.
///
/// - Returns: The value returned by the closure.
///
/// If `body` throws an error
/// or an error occurs while closing the socket,
/// this method rethrows that error.
@_alwaysEmitIntoClient
public func closeAfter<R>(_ body: () throws -> R) throws -> R {
try fileDescriptor.closeAfter(body)
}
}
@@ -0,0 +1,324 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 - 2025 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 SystemPackage
@available(System 99, *)
extension SocketDescriptor {
/// A reusable collection of variable-sized ancillary messages
/// sent or received over a socket. These represent protocol control
/// related messages or other miscellaneous ancillary data.
///
/// Corresponds to a buffer of `struct cmsghdr` messages in C, as used
/// by `sendmsg` and `recmsg`.
public struct AncillaryMessageBuffer {
internal var _buffer: _RawBuffer
internal var _endOffset: Int
/// Initialize a new empty ancillary message buffer with no preallocated
/// storage.
public init() {
_buffer = _RawBuffer()
_endOffset = 0
}
/// Initialize a new empty ancillary message buffer of the
/// specified minimum capacity (in bytes).
internal init(minimumCapacity: Int) {
let headerSize = MemoryLayout<CInterop.CMsgHdr>.size
let capacity = Swift.max(headerSize + 1, minimumCapacity)
_buffer = _RawBuffer(minimumCapacity: capacity)
_endOffset = 0
}
internal var _headerSize: Int { MemoryLayout<CInterop.CMsgHdr>.size }
internal var _capacity: Int { _buffer.capacity }
/// Remove all messages currently in this buffer, preserving storage
/// capacity.
///
/// This invalidates all indices in the collection.
///
/// - Complexity: O(1). Does not reallocate the buffer.
public mutating func removeAll() {
_endOffset = 0
}
/// Reserve enough storage capacity to hold `minimumCapacity` bytes' worth
/// of messages without having to reallocate storage.
///
/// This does not invalidate any indices.
///
/// - Complexity: O(max(`minimumCapacity`, `capacity`)), where `capacity` is
/// the current storage capacity. This potentially needs to reallocate
/// the buffer and copy existing messages.
public mutating func reserveCapacity(_ minimumCapacity: Int) {
_buffer.ensureUnique(capacity: minimumCapacity)
}
/// Append a message with the specified data to the end of this buffer,
/// resizing it if necessary.
///
/// This does not invalidate any existing indices, but it updates `endIndex`.
///
/// - Complexity: Amortized O(`data.count`), when averaged over multiple
/// calls. This method reallocates the buffer if there isn't enough
/// capacity or if the storage is shared with another value.
public mutating func appendMessage(
level: SocketDescriptor.ProtocolID,
type: SocketDescriptor.Option,
bytes: UnsafeRawBufferPointer
) {
appendMessage(
level: level,
type: type,
unsafeUninitializedCapacity: bytes.count
) { buffer in
assert(buffer.count >= bytes.count)
if bytes.count > 0 {
buffer.baseAddress!.copyMemory(
from: bytes.baseAddress!,
byteCount: bytes.count)
}
return bytes.count
}
}
/// Append a message with the supplied data to the end of this buffer,
/// resizing it if necessary. The message payload is initialized with the
/// supplied closure, which needs to return the final message length.
///
/// This does not invalidate any existing indices, but it updates `endIndex`.
///
/// - Complexity: Amortized O(`data.count`), when averaged over multiple
/// calls. This method reallocates the buffer if there isn't enough
/// capacity or if the storage is shared with another value.
public mutating func appendMessage(
level: SocketDescriptor.ProtocolID,
type: SocketDescriptor.Option,
unsafeUninitializedCapacity capacity: Int,
initializingWith body: (UnsafeMutableRawBufferPointer) throws -> Int
) rethrows {
precondition(capacity >= 0)
let headerSize = _headerSize
let delta = _headerSize + capacity
_buffer.ensureUnique(capacity: _endOffset + delta)
let messageLength: Int = try _buffer.withUnsafeMutableBytes { buffer in
assert(buffer.count >= _endOffset + delta)
let p = buffer.baseAddress! + _endOffset
let header = p.bindMemory(to: CInterop.CMsgHdr.self, capacity: 1)
header.pointee = CInterop.CMsgHdr()
header.pointee.cmsg_level = level.rawValue
header.pointee.cmsg_type = type.rawValue
let length = try body(
UnsafeMutableRawBufferPointer(start: p + headerSize, count: capacity))
precondition(length >= 0 && length <= capacity)
header.pointee.cmsg_len = CInterop.SockLen(headerSize + length)
return headerSize + length
}
_endOffset += messageLength
}
internal func _withUnsafeBytes<R>(
_ body: (UnsafeRawBufferPointer) throws -> R
) rethrows -> R {
try _buffer.withUnsafeBytes { buffer in
assert(buffer.count >= _endOffset)
let buffer = UnsafeRawBufferPointer(rebasing: buffer.prefix(_endOffset))
return try body(buffer)
}
}
internal mutating func _withUnsafeMutableBytes<R>(
entireCapacity: Bool,
_ body: (UnsafeMutableRawBufferPointer) throws -> R
) rethrows -> R {
return try _buffer.withUnsafeMutableBytes { buffer in
assert(buffer.count >= _endOffset)
if entireCapacity {
return try body(buffer)
} else {
return try body(.init(rebasing: buffer.prefix(_endOffset)))
}
}
}
internal mutating func _withMutableCInterop<R>(
entireCapacity: Bool,
_ body: (UnsafeMutableRawPointer?, inout CInterop.SockLen) throws -> R
) rethrows -> R {
let (result, length): (R, Int) = try _withUnsafeMutableBytes(
entireCapacity: entireCapacity
) { buffer in
var length = CInterop.SockLen(buffer.count)
let result = try body(buffer.baseAddress, &length)
precondition(length >= 0 && length <= buffer.count)
return (result, Int(length))
}
_endOffset = length
return result
}
}
}
@available(System 99, *)
extension SocketDescriptor.AncillaryMessageBuffer: Collection {
/// The index type in an ancillary message buffer.
@frozen
public struct Index: Comparable, Hashable {
@usableFromInline
var _offset: Int
@inlinable
internal init(_offset: Int) {
self._offset = _offset
}
@inlinable
public static func == (left: Self, right: Self) -> Bool {
left._offset == right._offset
}
@inlinable
public static func < (left: Self, right: Self) -> Bool {
left._offset < right._offset
}
@inlinable
public func hash(into hasher: inout Hasher) {
hasher.combine(_offset)
}
}
/// An individual message inside an ancillary message buffer.
///
/// Note that this is merely a reference to a slice of the underlying buffer,
/// so it contains a shared copy of its entire storage. To prevent buffer
/// reallocations due to copy-on-write copies, do not save instances
/// of this type. Instead, immediately copy out any data you need to hold onto
/// into standalone buffers.
public struct Message {
internal var _base: SocketDescriptor.AncillaryMessageBuffer
internal var _offset: Int
internal init(_base: SocketDescriptor.AncillaryMessageBuffer, offset: Int) {
self._base = _base
self._offset = offset
}
}
/// The index of the first message in the collection, or `endIndex` if
/// the collection contains no messages.
///
/// This roughly corresponds to the C macro `CMSG_FIRSTHDR`.
public var startIndex: Index { Index(_offset: 0) }
/// The index after the last message in the collection.
public var endIndex: Index { Index(_offset: _endOffset) }
/// True if the collection contains no elements.
public var isEmpty: Bool { _endOffset == 0 }
/// Return the length (in bytes) of the message at the specified index, or
/// nil if the index isn't valid, or it addresses a corrupt message.
internal func _length(at i: Index) -> Int? {
_withUnsafeBytes { buffer in
guard i._offset >= 0 && i._offset + _headerSize <= buffer.count else {
return nil
}
let p = (buffer.baseAddress! + i._offset)
.assumingMemoryBound(to: CInterop.CMsgHdr.self)
let length = Int(p.pointee.cmsg_len)
// Cut the list short at the first sign of corrupt data.
// Messages must not be shorter than their header, and they must fit
// entirely in the buffer.
if length < _headerSize || i._offset + length > buffer.count {
return nil
}
return length
}
}
/// Returns the index immediately following `i` in the collection.
///
/// This roughly corresponds to the C macro `CMSG_NXTHDR`.
///
/// - Complexity: O(1)
public func index(after i: Index) -> Index {
precondition(i._offset != _endOffset, "Can't advance past endIndex")
precondition(i._offset >= 0 && i._offset + _headerSize <= _endOffset,
"Invalid index")
guard let length = _length(at: i) else { return endIndex }
return Index(_offset: i._offset + length)
}
/// Returns the message at the given position, which must be a valid index
/// in this collection.
///
/// The returned value merely refers to a slice of the entire buffer, so
/// it contains a shared regerence to it.
///
/// To reduce memory use and to prevent unnecessary copy-on-write copying, do
/// not save `Message` values -- instead, copy out the data you need to hold
/// on to into standalone storage.
public subscript(position: Index) -> Message {
guard let _ = _length(at: position) else {
preconditionFailure("Invalid index")
}
return Element(_base: self, offset: position._offset)
}
}
@available(System 99, *)
extension SocketDescriptor.AncillaryMessageBuffer.Message {
internal var _header: CInterop.CMsgHdr {
_base._withUnsafeBytes { buffer in
assert(_offset + _base._headerSize <= buffer.count)
let p = buffer.baseAddress! + _offset
let header = p.assumingMemoryBound(to: CInterop.CMsgHdr.self)
return header.pointee
}
}
/// The protocol level of the message. Socket-level command messages
/// use the special protocol value `SocketDescriptor.ProtocolID.socketOption`.
public var level: SocketDescriptor.ProtocolID {
.init(rawValue: _header.cmsg_level)
}
/// The protocol-specific type of the message.
public var type: SocketDescriptor.Option {
.init(rawValue: _header.cmsg_type)
}
/// Calls `body` with an unsafe raw buffer pointer containing the
/// message payload.
///
/// This roughly corresponds to the C macro `CMSG_DATA`.
///
/// - Note: The buffer passed to `body` does not include storage reserved
/// for holding the message header, such as the `level` and `type` values.
/// To access header information, you have to use the corresponding
/// properties.
public func withUnsafeBytes<R>(
_ body: (UnsafeRawBufferPointer) throws -> R
) rethrows -> R {
try _base._withUnsafeBytes { buffer in
let headerSize = _base._headerSize
assert(_offset + headerSize <= buffer.count)
let p = buffer.baseAddress! + _offset
let header = p.assumingMemoryBound(to: CInterop.CMsgHdr.self)
let data = p + headerSize
let count = Swift.min(Int(header.pointee.cmsg_len) - headerSize,
buffer.count)
return try body(UnsafeRawBufferPointer(start: data, count: count))
}
}
}
@@ -0,0 +1,389 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 - 2025 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 SystemPackage
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#elseif canImport(Android)
import Android
#else
#error("Unsupported Platform")
#endif
// MARK: - Socket Creation and Lifecycle
@available(System 99, *)
extension SocketDescriptor {
/// Creates an endpoint for communication.
///
/// - Parameters:
/// - domain: The protocol family for communication.
/// - type: The semantics of communication.
/// - protocol: The particular protocol to use. The default is `.default`,
/// which typically selects the appropriate protocol for the domain/type
/// combination (e.g., TCP for IPv4/stream).
/// - retryOnInterrupt: Whether to retry if interrupted. The default is `true`.
/// - Returns: A new socket descriptor.
///
/// The corresponding C function is `socket`.
@_alwaysEmitIntoClient
public static func open(
_ domain: Domain,
_ type: ConnectionType,
protocol: ProtocolID = .default,
retryOnInterrupt: Bool = true
) throws -> SocketDescriptor {
try _open(domain, type, protocol: `protocol`, retryOnInterrupt: retryOnInterrupt).get()
}
@usableFromInline
internal static func _open(
_ domain: Domain,
_ type: ConnectionType,
protocol: ProtocolID,
retryOnInterrupt: Bool
) -> Result<SocketDescriptor, Errno> {
valueOrErrno(retryOnInterrupt: retryOnInterrupt) {
system_socket(domain.rawValue, type.rawValue, `protocol`.rawValue)
}.map(SocketDescriptor.init(rawValue:))
}
/// Closes the socket.
///
/// The corresponding C function is `close`.
@_alwaysEmitIntoClient
public func close() throws {
try _close().get()
}
@usableFromInline
internal func _close() -> Result<(), Errno> {
nothingOrErrno(retryOnInterrupt: false) {
system_close(self.rawValue)
}
}
/// Shuts down part of a full-duplex connection.
///
/// - Parameter how: Which parts of the connection to shut down.
///
/// The corresponding C function is `shutdown`.
@_alwaysEmitIntoClient
public func shutdown(_ how: ShutdownKind) throws {
try _shutdown(how).get()
}
@usableFromInline
internal func _shutdown(_ how: ShutdownKind) -> Result<(), Errno> {
nothingOrErrno(retryOnInterrupt: false) {
system_shutdown(self.rawValue, how.rawValue)
}
}
}
// MARK: - Connection Operations
@available(System 99, *)
extension SocketDescriptor {
/// Binds a socket to an address.
///
/// - Parameter address: The socket address to bind to.
///
/// The corresponding C function is `bind`.
@_alwaysEmitIntoClient
public func bind(to address: SocketAddress) throws {
try _bind(to: address).get()
}
@usableFromInline
internal func _bind(to address: SocketAddress) -> Result<(), Errno> {
address.withUnsafePointer { addr, len in
nothingOrErrno(retryOnInterrupt: false) {
system_bind(self.rawValue, addr, len)
}
}
}
/// Listens for connections on the socket.
///
/// Only applies to sockets of type `.stream`.
///
/// - Parameter backlog: The maximum length of the pending connections queue.
///
/// The corresponding C function is `listen`.
@_alwaysEmitIntoClient
public func listen(backlog: Int) throws {
try _listen(backlog: backlog).get()
}
@usableFromInline
internal func _listen(backlog: Int) -> Result<(), Errno> {
nothingOrErrno(retryOnInterrupt: false) {
system_listen(self.rawValue, CInt(backlog))
}
}
/// Accepts a connection on the socket.
///
/// - Parameter retryOnInterrupt: Whether to retry if interrupted.
/// - Returns: A new socket descriptor for the accepted connection.
///
/// The corresponding C function is `accept`.
@_alwaysEmitIntoClient
public func accept(retryOnInterrupt: Bool = true) throws -> SocketDescriptor {
try _accept(retryOnInterrupt: retryOnInterrupt).get()
}
@usableFromInline
internal func _accept(retryOnInterrupt: Bool) -> Result<SocketDescriptor, Errno> {
valueOrErrno(retryOnInterrupt: retryOnInterrupt) {
system_accept(self.rawValue, nil, nil)
}.map(SocketDescriptor.init(rawValue:))
}
/// Accepts a connection and returns the client's address.
///
/// - Parameters:
/// - client: A socket address buffer to receive the client's address.
/// - retryOnInterrupt: Whether to retry if interrupted.
/// - Returns: A new socket descriptor for the accepted connection.
///
/// The corresponding C function is `accept`.
@_alwaysEmitIntoClient
public func accept(
client: inout SocketAddress,
retryOnInterrupt: Bool = true
) throws -> SocketDescriptor {
try _accept(client: &client, retryOnInterrupt: retryOnInterrupt).get()
}
@usableFromInline
internal func _accept(
client: inout SocketAddress,
retryOnInterrupt: Bool
) -> Result<SocketDescriptor, Errno> {
client._withUnsafeMutablePointer { addr, len in
valueOrErrno(retryOnInterrupt: retryOnInterrupt) {
system_accept(self.rawValue, addr, &len)
}.map(SocketDescriptor.init(rawValue:))
}
}
/// Initiates a connection on the socket.
///
/// - Parameter address: The address to connect to.
///
/// The corresponding C function is `connect`.
@_alwaysEmitIntoClient
public func connect(to address: SocketAddress) throws {
try _connect(to: address).get()
}
@usableFromInline
internal func _connect(to address: SocketAddress) -> Result<(), Errno> {
address.withUnsafePointer { addr, len in
nothingOrErrno(retryOnInterrupt: false) {
system_connect(self.rawValue, addr, len)
}
}
}
}
// MARK: - Send and Receive
@available(System 99, *)
extension SocketDescriptor {
/// Sends data on the socket.
///
/// - Parameters:
/// - buffer: The data to send.
/// - flags: Message flags.
/// - retryOnInterrupt: Whether to retry if interrupted.
/// - Returns: The number of bytes sent.
///
/// The corresponding C function is `send`.
@_alwaysEmitIntoClient
public func send(
_ buffer: UnsafeRawBufferPointer,
flags: MessageFlags = .none,
retryOnInterrupt: Bool = true
) throws -> Int {
try _send(buffer, flags: flags, retryOnInterrupt: retryOnInterrupt).get()
}
@usableFromInline
internal func _send(
_ buffer: UnsafeRawBufferPointer,
flags: MessageFlags,
retryOnInterrupt: Bool
) -> Result<Int, Errno> {
valueOrErrno(retryOnInterrupt: retryOnInterrupt) {
system_send(self.rawValue, buffer.baseAddress, buffer.count, flags.rawValue)
}
}
/// Receives data from the socket.
///
/// - Parameters:
/// - buffer: The buffer to receive data into.
/// - flags: Message flags.
/// - retryOnInterrupt: Whether to retry if interrupted.
/// - Returns: The number of bytes received.
///
/// The corresponding C function is `recv`.
@_alwaysEmitIntoClient
public func receive(
into buffer: UnsafeMutableRawBufferPointer,
flags: MessageFlags = .none,
retryOnInterrupt: Bool = true
) throws -> Int {
try _receive(into: buffer, flags: flags, retryOnInterrupt: retryOnInterrupt).get()
}
@usableFromInline
internal func _receive(
into buffer: UnsafeMutableRawBufferPointer,
flags: MessageFlags,
retryOnInterrupt: Bool
) -> Result<Int, Errno> {
valueOrErrno(retryOnInterrupt: retryOnInterrupt) {
system_recv(self.rawValue, buffer.baseAddress, buffer.count, flags.rawValue)
}
}
/// Sends data to a specific address.
///
/// - Parameters:
/// - buffer: The data to send.
/// - address: The destination address.
/// - flags: Message flags.
/// - retryOnInterrupt: Whether to retry if interrupted.
/// - Returns: The number of bytes sent.
///
/// The corresponding C function is `sendto`.
@_alwaysEmitIntoClient
public func send(
_ buffer: UnsafeRawBufferPointer,
to address: SocketAddress,
flags: MessageFlags = .none,
retryOnInterrupt: Bool = true
) throws -> Int {
try _send(buffer, to: address, flags: flags, retryOnInterrupt: retryOnInterrupt).get()
}
@usableFromInline
internal func _send(
_ buffer: UnsafeRawBufferPointer,
to address: SocketAddress,
flags: MessageFlags,
retryOnInterrupt: Bool
) -> Result<Int, Errno> {
address.withUnsafePointer { addr, addrlen in
valueOrErrno(retryOnInterrupt: retryOnInterrupt) {
system_sendto(
self.rawValue,
buffer.baseAddress,
buffer.count,
flags.rawValue,
addr,
addrlen
)
}
}
}
/// Receives data and returns the sender's address.
///
/// - Parameters:
/// - buffer: The buffer to receive data into.
/// - sender: A buffer to receive the sender's address.
/// - flags: Message flags.
/// - retryOnInterrupt: Whether to retry if interrupted.
/// - Returns: The number of bytes received.
///
/// The corresponding C function is `recvfrom`.
@_alwaysEmitIntoClient
public func receive(
into buffer: UnsafeMutableRawBufferPointer,
sender: inout SocketAddress,
flags: MessageFlags = .none,
retryOnInterrupt: Bool = true
) throws -> Int {
try _receive(into: buffer, sender: &sender, flags: flags, retryOnInterrupt: retryOnInterrupt).get()
}
@usableFromInline
internal func _receive(
into buffer: UnsafeMutableRawBufferPointer,
sender: inout SocketAddress,
flags: MessageFlags,
retryOnInterrupt: Bool
) -> Result<Int, Errno> {
sender._withUnsafeMutablePointer { addr, len in
valueOrErrno(retryOnInterrupt: retryOnInterrupt) {
system_recvfrom(
self.rawValue,
buffer.baseAddress,
buffer.count,
flags.rawValue,
addr,
&len
)
}
}
}
}
// MARK: - Socket Information
@available(System 99, *)
extension SocketDescriptor {
/// Gets the local address of the socket.
///
/// - Parameter address: A buffer to receive the local address.
///
/// The corresponding C function is `getsockname`.
@_alwaysEmitIntoClient
public func getLocalAddress(into address: inout SocketAddress) throws {
try _getLocalAddress(into: &address).get()
}
@usableFromInline
internal func _getLocalAddress(into address: inout SocketAddress) -> Result<(), Errno> {
address._withUnsafeMutablePointer { addr, len in
nothingOrErrno(retryOnInterrupt: false) {
system_getsockname(self.rawValue, addr, &len)
}
}
}
/// Gets the remote address of the socket.
///
/// - Parameter address: A buffer to receive the peer address.
///
/// The corresponding C function is `getpeername`.
@_alwaysEmitIntoClient
public func getPeerAddress(into address: inout SocketAddress) throws {
try _getPeerAddress(into: &address).get()
}
@usableFromInline
internal func _getPeerAddress(into address: inout SocketAddress) -> Result<(), Errno> {
address._withUnsafeMutablePointer { addr, len in
nothingOrErrno(retryOnInterrupt: false) {
system_getpeername(self.rawValue, addr, &len)
}
}
}
}
@@ -0,0 +1,352 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 - 2025 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 SystemPackage
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#elseif canImport(Android)
import Android
#else
#error("Unsupported Platform")
#endif
// MARK: - Option Level
@available(System 99, *)
extension SocketDescriptor {
/// Socket option levels.
@frozen
public struct OptionLevel: RawRepresentable, Hashable, Sendable {
@_alwaysEmitIntoClient
public var rawValue: CInt
@_alwaysEmitIntoClient
public init(rawValue: CInt) { self.rawValue = rawValue }
/// Socket-level options.
///
/// The corresponding C constant is `SOL_SOCKET`.
@_alwaysEmitIntoClient
public static var socket: OptionLevel { OptionLevel(rawValue: SOL_SOCKET) }
/// IPv4 protocol options.
///
/// The corresponding C constant is `IPPROTO_IP`.
@_alwaysEmitIntoClient
public static var ip: OptionLevel { OptionLevel(rawValue: IPPROTO_IP) }
/// IPv6 protocol options.
///
/// The corresponding C constant is `IPPROTO_IPV6`.
@_alwaysEmitIntoClient
public static var ipv6: OptionLevel { OptionLevel(rawValue: IPPROTO_IPV6) }
/// TCP protocol options.
///
/// The corresponding C constant is `IPPROTO_TCP`.
@_alwaysEmitIntoClient
public static var tcp: OptionLevel { OptionLevel(rawValue: IPPROTO_TCP) }
/// UDP protocol options.
///
/// The corresponding C constant is `IPPROTO_UDP`.
@_alwaysEmitIntoClient
public static var udp: OptionLevel { OptionLevel(rawValue: IPPROTO_UDP) }
}
}
// MARK: - Socket-Level Options
@available(System 99, *)
extension SocketDescriptor {
/// Socket-level options for use with `getOption` and `setOption`.
@frozen
public struct SocketOption: RawRepresentable, Hashable, Sendable {
@_alwaysEmitIntoClient
public var rawValue: CInt
@_alwaysEmitIntoClient
public init(rawValue: CInt) { self.rawValue = rawValue }
/// Enable debugging.
///
/// The corresponding C constant is `SO_DEBUG`.
@_alwaysEmitIntoClient
public static var debug: SocketOption { SocketOption(rawValue: SO_DEBUG) }
/// Allow local address reuse.
///
/// The corresponding C constant is `SO_REUSEADDR`.
@_alwaysEmitIntoClient
public static var reuseAddress: SocketOption { SocketOption(rawValue: SO_REUSEADDR) }
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(Linux)
/// Allow local port reuse.
///
/// The corresponding C constant is `SO_REUSEPORT`.
@_alwaysEmitIntoClient
public static var reusePort: SocketOption { SocketOption(rawValue: SO_REUSEPORT) }
#endif
/// Keep connections alive.
///
/// The corresponding C constant is `SO_KEEPALIVE`.
@_alwaysEmitIntoClient
public static var keepAlive: SocketOption { SocketOption(rawValue: SO_KEEPALIVE) }
/// Don't route, use direct interface.
///
/// The corresponding C constant is `SO_DONTROUTE`.
@_alwaysEmitIntoClient
public static var dontRoute: SocketOption { SocketOption(rawValue: SO_DONTROUTE) }
/// Linger on close if data present.
///
/// The corresponding C constant is `SO_LINGER`.
@_alwaysEmitIntoClient
public static var linger: SocketOption { SocketOption(rawValue: SO_LINGER) }
/// Permit sending of broadcast messages.
///
/// The corresponding C constant is `SO_BROADCAST`.
@_alwaysEmitIntoClient
public static var broadcast: SocketOption { SocketOption(rawValue: SO_BROADCAST) }
/// Send buffer size.
///
/// The corresponding C constant is `SO_SNDBUF`.
@_alwaysEmitIntoClient
public static var sendBufferSize: SocketOption { SocketOption(rawValue: SO_SNDBUF) }
/// Receive buffer size.
///
/// The corresponding C constant is `SO_RCVBUF`.
@_alwaysEmitIntoClient
public static var receiveBufferSize: SocketOption { SocketOption(rawValue: SO_RCVBUF) }
/// Send low water mark.
///
/// The corresponding C constant is `SO_SNDLOWAT`.
@_alwaysEmitIntoClient
public static var sendLowWaterMark: SocketOption { SocketOption(rawValue: SO_SNDLOWAT) }
/// Receive low water mark.
///
/// The corresponding C constant is `SO_RCVLOWAT`.
@_alwaysEmitIntoClient
public static var receiveLowWaterMark: SocketOption { SocketOption(rawValue: SO_RCVLOWAT) }
/// Get socket error.
///
/// The corresponding C constant is `SO_ERROR`.
@_alwaysEmitIntoClient
public static var error: SocketOption { SocketOption(rawValue: SO_ERROR) }
/// Get socket type.
///
/// The corresponding C constant is `SO_TYPE`.
@_alwaysEmitIntoClient
public static var type: SocketOption { SocketOption(rawValue: SO_TYPE) }
#if SYSTEM_PACKAGE_DARWIN
/// Don't generate SIGPIPE on broken pipe.
///
/// The corresponding C constant is `SO_NOSIGPIPE`.
@_alwaysEmitIntoClient
public static var noSigPipe: SocketOption { SocketOption(rawValue: SO_NOSIGPIPE) }
#endif
}
}
// MARK: - TCP Options
@available(System 99, *)
extension SocketDescriptor {
/// TCP-level options for use with `getOption` and `setOption`.
@frozen
public struct TCPOption: RawRepresentable, Hashable, Sendable {
@_alwaysEmitIntoClient
public var rawValue: CInt
@_alwaysEmitIntoClient
public init(rawValue: CInt) { self.rawValue = rawValue }
/// Disable Nagle algorithm.
///
/// The corresponding C constant is `TCP_NODELAY`.
@_alwaysEmitIntoClient
public static var noDelay: TCPOption { TCPOption(rawValue: TCP_NODELAY) }
/// Maximum segment size.
///
/// The corresponding C constant is `TCP_MAXSEG`.
@_alwaysEmitIntoClient
public static var maxSegmentSize: TCPOption { TCPOption(rawValue: TCP_MAXSEG) }
#if SYSTEM_PACKAGE_DARWIN || os(Linux)
/// Keep alive idle time.
///
/// The corresponding C constant is `TCP_KEEPIDLE` on Linux
/// or `TCP_KEEPALIVE` on Darwin.
@_alwaysEmitIntoClient
public static var keepAliveIdle: TCPOption {
#if SYSTEM_PACKAGE_DARWIN
TCPOption(rawValue: TCP_KEEPALIVE)
#else
TCPOption(rawValue: TCP_KEEPIDLE)
#endif
}
#endif
#if os(Linux)
/// Keep alive interval.
///
/// The corresponding C constant is `TCP_KEEPINTVL`.
@_alwaysEmitIntoClient
public static var keepAliveInterval: TCPOption { TCPOption(rawValue: TCP_KEEPINTVL) }
/// Keep alive probe count.
///
/// The corresponding C constant is `TCP_KEEPCNT`.
@_alwaysEmitIntoClient
public static var keepAliveCount: TCPOption { TCPOption(rawValue: TCP_KEEPCNT) }
#endif
}
}
// MARK: - Get and Set Options
@available(System 99, *)
extension SocketDescriptor {
/// Gets a socket option value.
///
/// - Parameters:
/// - level: The protocol level.
/// - option: The option to get.
/// - Returns: The option value.
///
/// The corresponding C function is `getsockopt`.
@_alwaysEmitIntoClient
public func getOption<T>(
_ level: OptionLevel,
_ option: CInt
) throws -> T {
try _getOption(level, option).get()
}
@usableFromInline
internal func _getOption<T>(
_ level: OptionLevel,
_ option: CInt
) -> Result<T, Errno> {
// Allocate zeroed storage for the option value
var storage = [UInt8](repeating: 0, count: MemoryLayout<T>.size)
var length = socklen_t(MemoryLayout<T>.size)
let result = storage.withUnsafeMutableBytes { buffer in
nothingOrErrno(retryOnInterrupt: false) {
system_getsockopt(
self.rawValue,
level.rawValue,
option,
buffer.baseAddress,
&length
)
}
}
return result.map {
storage.withUnsafeBytes { buffer in
buffer.load(as: T.self)
}
}
}
/// Sets a socket option value.
///
/// - Parameters:
/// - level: The protocol level.
/// - option: The option to set.
/// - value: The value to set.
///
/// The corresponding C function is `setsockopt`.
@_alwaysEmitIntoClient
public func setOption<T>(
_ level: OptionLevel,
_ option: CInt,
to value: T
) throws {
try _setOption(level, option, to: value).get()
}
@usableFromInline
internal func _setOption<T>(
_ level: OptionLevel,
_ option: CInt,
to value: T
) -> Result<(), Errno> {
withUnsafePointer(to: value) { valuePtr in
nothingOrErrno(retryOnInterrupt: false) {
system_setsockopt(
self.rawValue,
level.rawValue,
option,
valuePtr,
socklen_t(MemoryLayout<T>.size)
)
}
}
}
}
// MARK: - Convenience Methods
@available(System 99, *)
extension SocketDescriptor {
/// Gets a socket-level option as an integer.
@_alwaysEmitIntoClient
public func getSocketOption(_ option: SocketOption) throws -> CInt {
try getOption(.socket, option.rawValue)
}
/// Sets a socket-level option as an integer.
@_alwaysEmitIntoClient
public func setSocketOption(_ option: SocketOption, to value: CInt) throws {
try setOption(.socket, option.rawValue, to: value)
}
/// Gets a TCP-level option as an integer.
@_alwaysEmitIntoClient
public func getTCPOption(_ option: TCPOption) throws -> CInt {
try getOption(.tcp, option.rawValue)
}
/// Sets a TCP-level option as an integer.
@_alwaysEmitIntoClient
public func setTCPOption(_ option: TCPOption, to value: CInt) throws {
try setOption(.tcp, option.rawValue, to: value)
}
/// Enables reuse of local addresses.
@_alwaysEmitIntoClient
public func setReuseAddress(_ enabled: Bool = true) throws {
try setSocketOption(.reuseAddress, to: enabled ? 1 : 0)
}
/// Disables the Nagle algorithm.
@_alwaysEmitIntoClient
public func setNoDelay(_ enabled: Bool = true) throws {
try setTCPOption(.noDelay, to: enabled ? 1 : 0)
}
}
+101
View File
@@ -0,0 +1,101 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 - 2025 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
*/
// Utility functions for socket operations
import SystemPackage
extension Errno {
internal static var current: Errno {
get { Errno(rawValue: system_errno) }
set { system_errno = newValue.rawValue }
}
}
// Results in errno if i == -1
@available(System 0.0.1, *)
private func valueOrErrno<I: FixedWidthInteger>(
_ i: I
) -> Result<I, Errno> {
i == -1 ? .failure(Errno.current) : .success(i)
}
@available(System 0.0.1, *)
private func nothingOrErrno<I: FixedWidthInteger>(
_ i: I
) -> Result<(), Errno> {
valueOrErrno(i).map { _ in () }
}
@available(System 0.0.1, *)
internal func valueOrErrno<I: FixedWidthInteger>(
retryOnInterrupt: Bool, _ f: () -> I
) -> Result<I, Errno> {
repeat {
switch valueOrErrno(f()) {
case .success(let r): return .success(r)
case .failure(let err):
guard retryOnInterrupt && err == .interrupted else { return .failure(err) }
break
}
} while true
}
@available(System 0.0.1, *)
internal func nothingOrErrno<I: FixedWidthInteger>(
retryOnInterrupt: Bool, _ f: () -> I
) -> Result<(), Errno> {
valueOrErrno(retryOnInterrupt: retryOnInterrupt, f).map { _ in () }
}
// Run a precondition for debug client builds
internal func _debugPrecondition(
_ condition: @autoclosure () -> Bool,
_ message: StaticString = StaticString(),
file: StaticString = #file, line: UInt = #line
) {
if _slowPath(_isDebugAssertConfiguration()) {
precondition(
condition(), String(describing: message), file: file, line: line)
}
}
extension OptionSet {
@inline(never)
internal func _buildDescription(
_ descriptions: [(Element, StaticString)]
) -> String {
var copy = self
var result = "["
for (option, name) in descriptions {
if _slowPath(copy.contains(option)) {
result += name.description
copy.remove(option)
if !copy.isEmpty { result += ", " }
}
}
if _slowPath(!copy.isEmpty) {
result += "\(Self.self)(rawValue: \(copy.rawValue))"
}
result += "]"
return result
}
}
internal func _withOptionalUnsafePointerOrNull<T, R>(
to value: T?,
_ body: (UnsafePointer<T>?) throws -> R
) rethrows -> R {
guard let value = value else {
return try body(nil)
}
return try withUnsafePointer(to: value, body)
}
@@ -0,0 +1,43 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 - 2025 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 Testing
import SystemPackage
@testable import SystemSockets
@Suite("Ancillary Message Buffer")
struct AncillaryMessageBufferTests {
@Test("Append and iterate messages")
func testAppend() {
// Create a buffer of 100 messages, with varying payload lengths.
var buffer = SocketDescriptor.AncillaryMessageBuffer(minimumCapacity: 0)
for i in 0 ..< 100 {
let bytes = UnsafeMutableRawBufferPointer.allocate(byteCount: i, alignment: 1)
defer { bytes.deallocate() }
system_memset(bytes, to: UInt8(i))
buffer.appendMessage(level: .init(rawValue: CInt(100 * i)),
type: .init(rawValue: CInt(1000 * i)),
bytes: UnsafeRawBufferPointer(bytes))
}
// Check that we can access appended messages.
var i = 0
for message in buffer {
#expect(Int(message.level.rawValue) == 100 * i)
#expect(Int(message.type.rawValue) == 1000 * i)
message.withUnsafeBytes { buffer in
#expect(buffer.count == i)
for idx in buffer.indices {
#expect(buffer[idx] == UInt8(i), "byte #\(idx)")
}
}
i += 1
}
#expect(i == 100, "Too many messages in buffer")
}
}
@@ -0,0 +1,194 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 - 2025 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
*/
#if !os(Windows)
import Testing
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#elseif canImport(Android)
import Android
#else
#error("Unsupported Platform")
#endif
@testable import SystemSockets
import SystemPackage
@Suite("Socket Addresses")
private struct SocketAddressTests {
// MARK: - IPv4 Address Tests
@available(System 99, *)
@Test func ipv4BasicCreation() {
let addr = IPv4Address("127.0.0.1", port: 8080)
#expect(addr != nil)
#expect(addr?.port == 8080)
#expect(addr?.addressString == "127.0.0.1")
}
@available(System 99, *)
@Test func ipv4InvalidAddress() {
let addr = IPv4Address("not.an.ip.address", port: 8080)
#expect(addr == nil)
}
@available(System 99, *)
@Test func ipv4Any() {
let addr = IPv4Address.any(port: 0)
#expect(addr.port == 0)
#expect(addr.addressString == "0.0.0.0")
}
@available(System 99, *)
@Test func ipv4Loopback() {
let addr = IPv4Address.loopback(port: 80)
#expect(addr.port == 80)
#expect(addr.addressString == "127.0.0.1")
}
@available(System 99, *)
@Test func ipv4StringLiteral() {
let addr: IPv4Address = "192.168.1.1:443"
#expect(addr.port == 443)
#expect(addr.addressString == "192.168.1.1")
}
@available(System 99, *)
@Test func ipv4Equality() {
let addr1 = IPv4Address("10.0.0.1", port: 8080)!
let addr2 = IPv4Address("10.0.0.1", port: 8080)!
let addr3 = IPv4Address("10.0.0.2", port: 8080)!
let addr4 = IPv4Address("10.0.0.1", port: 9090)!
#expect(addr1 == addr2)
#expect(addr1 != addr3)
#expect(addr1 != addr4)
}
@available(System 99, *)
@Test func ipv4Description() {
let addr = IPv4Address("8.8.8.8", port: 53)!
#expect(addr.description == "8.8.8.8:53")
}
// MARK: - IPv6 Address Tests
@available(System 99, *)
@Test func ipv6BasicCreation() {
let addr = IPv6Address("::1", port: 8080)
#expect(addr != nil)
#expect(addr?.port == 8080)
#expect(addr?.addressString == "::1")
}
@available(System 99, *)
@Test func ipv6InvalidAddress() {
let addr = IPv6Address("not:an:ipv6:address", port: 8080)
#expect(addr == nil)
}
@available(System 99, *)
@Test func ipv6Any() {
let addr = IPv6Address.any(port: 0)
#expect(addr.port == 0)
#expect(addr.addressString == "::")
}
@available(System 99, *)
@Test func ipv6Loopback() {
let addr = IPv6Address.loopback(port: 80)
#expect(addr.port == 80)
#expect(addr.addressString == "::1")
}
@available(System 99, *)
@Test func ipv6Description() {
let addr = IPv6Address("2001:db8::1", port: 443)!
#expect(addr.description == "[2001:db8::1]:443")
}
@available(System 99, *)
@Test func ipv6StringLiteral() {
let addr: IPv6Address = "[::1]:8080"
#expect(addr.port == 8080)
#expect(addr.addressString == "::1")
}
// MARK: - Unix Address Tests
@available(System 99, *)
@Test func unixBasicCreation() {
let addr = UnixAddress("/tmp/test.sock")
#expect(addr != nil)
#expect(addr?.path == "/tmp/test.sock")
}
@available(System 99, *)
@Test func unixDescription() {
let addr = UnixAddress("/var/run/daemon.sock")!
#expect(addr.description == "/var/run/daemon.sock")
}
@available(System 99, *)
@Test func unixEquality() {
let addr1 = UnixAddress("/tmp/a.sock")!
let addr2 = UnixAddress("/tmp/a.sock")!
let addr3 = UnixAddress("/tmp/b.sock")!
#expect(addr1 == addr2)
#expect(addr1 != addr3)
}
// MARK: - SocketAddress Container Tests
@available(System 99, *)
@Test func socketAddressFromIPv4() {
let ipv4 = IPv4Address.loopback(port: 8080)
let sockAddr = SocketAddress(ipv4: ipv4)
#expect(sockAddr.family == SocketDescriptor.Domain.ipv4)
#expect(sockAddr.ipv4 != nil)
#expect(sockAddr.ipv4?.port == 8080)
#expect(sockAddr.ipv6 == nil)
#expect(sockAddr.unix == nil)
}
@available(System 99, *)
@Test func socketAddressFromIPv6() {
let ipv6 = IPv6Address.loopback(port: 443)
let sockAddr = SocketAddress(ipv6: ipv6)
#expect(sockAddr.family == SocketDescriptor.Domain.ipv6)
#expect(sockAddr.ipv6 != nil)
#expect(sockAddr.ipv6?.port == 443)
#expect(sockAddr.ipv4 == nil)
#expect(sockAddr.unix == nil)
}
@available(System 99, *)
@Test func socketAddressFromUnix() {
let unix = UnixAddress("/tmp/test.sock")!
let sockAddr = SocketAddress(unix: unix)
#expect(sockAddr.family == SocketDescriptor.Domain.local)
#expect(sockAddr.unix != nil)
#expect(sockAddr.unix?.path == "/tmp/test.sock")
#expect(sockAddr.ipv4 == nil)
#expect(sockAddr.ipv6 == nil)
}
}
#endif
@@ -0,0 +1,89 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 - 2025 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
*/
#if !os(Windows)
import Testing
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#elseif canImport(Android)
import Android
#else
#error("Unsupported Platform")
#endif
@testable import SystemSockets
import SystemPackage
@Suite("Socket Descriptor")
private struct SocketDescriptorTests {
// MARK: - Type Tests
@Test func domainValues() {
#expect(SocketDescriptor.Domain.ipv4.rawValue == AF_INET)
#expect(SocketDescriptor.Domain.ipv6.rawValue == AF_INET6)
#expect(SocketDescriptor.Domain.local.rawValue == AF_UNIX)
}
@Test func connectionTypeValues() {
#expect(SocketDescriptor.ConnectionType.stream.rawValue == SOCK_STREAM)
#expect(SocketDescriptor.ConnectionType.datagram.rawValue == SOCK_DGRAM)
}
@Test func protocolValues() {
#expect(SocketDescriptor.ProtocolID.tcp.rawValue == CInt(IPPROTO_TCP))
#expect(SocketDescriptor.ProtocolID.udp.rawValue == CInt(IPPROTO_UDP))
}
// MARK: - Socket Creation Tests
@available(System 99, *)
@Test func createTCPSocket() throws {
let socket = try SocketDescriptor.open(.ipv4, .stream, protocol: .tcp)
#expect(socket.rawValue >= 0)
try socket.close()
}
@available(System 99, *)
@Test func createUDPSocket() throws {
let socket = try SocketDescriptor.open(.ipv4, .datagram, protocol: .udp)
#expect(socket.rawValue >= 0)
try socket.close()
}
@available(System 99, *)
@Test func createIPv6TCPSocket() throws {
let socket = try SocketDescriptor.open(.ipv6, .stream, protocol: .tcp)
#expect(socket.rawValue >= 0)
try socket.close()
}
@available(System 99, *)
@Test func createUnixSocket() throws {
let socket = try SocketDescriptor.open(.local, .stream)
#expect(socket.rawValue >= 0)
try socket.close()
}
// MARK: - Shutdown Tests
@Test func shutdownKindValues() {
#expect(SocketDescriptor.ShutdownKind.read.rawValue == SHUT_RD)
#expect(SocketDescriptor.ShutdownKind.write.rawValue == SHUT_WR)
#expect(SocketDescriptor.ShutdownKind.readWrite.rawValue == SHUT_RDWR)
}
}
#endif
@@ -0,0 +1,225 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 - 2025 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
*/
#if !os(Windows)
import Testing
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#elseif canImport(Android)
import Android
#else
#error("Unsupported Platform")
#endif
@testable import SystemSockets
import SystemPackage
@Suite("Socket Operations")
private struct SocketOperationsTests {
// MARK: - Bind Tests
@available(System 99, *)
@Test func bindToAnyPort() throws {
let socket = try SocketDescriptor.open(.ipv4, .stream, protocol: .tcp)
defer { try? socket.close() }
let address = SocketAddress(ipv4: IPv4Address.any(port: 0))
try socket.bind(to: address)
// Verify we can get the local address after binding
var localAddr = SocketAddress()
try socket.getLocalAddress(into: &localAddr)
#expect(localAddr.family == SocketDescriptor.Domain.ipv4)
#expect(localAddr.ipv4?.port != 0) // Port should be assigned
}
@available(System 99, *)
@Test func bindToLoopback() throws {
let socket = try SocketDescriptor.open(.ipv4, .stream, protocol: .tcp)
defer { try? socket.close() }
let address = SocketAddress(ipv4: IPv4Address.loopback(port: 0))
try socket.bind(to: address)
var localAddr = SocketAddress()
try socket.getLocalAddress(into: &localAddr)
#expect(localAddr.ipv4?.addressString == "127.0.0.1")
}
// MARK: - Listen Tests
@available(System 99, *)
@Test func listenWithDefaultBacklog() throws {
let socket = try SocketDescriptor.open(.ipv4, .stream, protocol: .tcp)
defer { try? socket.close() }
let address = SocketAddress(ipv4: IPv4Address.loopback(port: 0))
try socket.bind(to: address)
try socket.listen(backlog: 5)
}
// MARK: - Connect and Accept Tests
@available(System 99, *)
@Test func tcpConnectAndAccept() throws {
// Create server socket
let server = try SocketDescriptor.open(.ipv4, .stream, protocol: .tcp)
defer { try? server.close() }
let serverAddr = SocketAddress(ipv4: IPv4Address.loopback(port: 0))
try server.bind(to: serverAddr)
try server.listen(backlog: 1)
// Get the actual port
var boundAddr = SocketAddress()
try server.getLocalAddress(into: &boundAddr)
let port = boundAddr.ipv4!.port
// Create client socket and connect
let client = try SocketDescriptor.open(.ipv4, .stream, protocol: .tcp)
defer { try? client.close() }
let connectAddr = SocketAddress(ipv4: IPv4Address.loopback(port: port))
try client.connect(to: connectAddr)
// Accept connection
var peerAddr = SocketAddress()
let acceptedSocket = try server.accept(client: &peerAddr)
defer { try? acceptedSocket.close() }
#expect(peerAddr.family == SocketDescriptor.Domain.ipv4)
#expect(peerAddr.ipv4?.addressString == "127.0.0.1")
}
// MARK: - Send and Receive Tests
@available(System 99, *)
@Test func tcpSendReceive() throws {
// Create server socket
let server = try SocketDescriptor.open(.ipv4, .stream, protocol: .tcp)
defer { try? server.close() }
let serverAddr = SocketAddress(ipv4: IPv4Address.loopback(port: 0))
try server.bind(to: serverAddr)
try server.listen(backlog: 1)
var boundAddr = SocketAddress()
try server.getLocalAddress(into: &boundAddr)
let port = boundAddr.ipv4!.port
// Create client socket and connect
let client = try SocketDescriptor.open(.ipv4, .stream, protocol: .tcp)
defer { try? client.close() }
let connectAddr = SocketAddress(ipv4: IPv4Address.loopback(port: port))
try client.connect(to: connectAddr)
// Accept connection
let acceptedSocket = try server.accept()
defer { try? acceptedSocket.close() }
// Send data from client
let message = "Hello, World!"
let messageBytes = Array(message.utf8)
let sent = try messageBytes.withUnsafeBytes { buffer in
try client.send(UnsafeRawBufferPointer(buffer))
}
#expect(sent == messageBytes.count)
// Receive data on server
var buffer = [UInt8](repeating: 0, count: 1024)
let received = try buffer.withUnsafeMutableBytes { buffer in
try acceptedSocket.receive(into: buffer)
}
#expect(received == messageBytes.count)
let receivedMessage = String(decoding: buffer.prefix(received), as: UTF8.self)
#expect(receivedMessage == message)
}
// MARK: - UDP Tests
@available(System 99, *)
@Test func udpSendReceive() throws {
// Create receiver socket
let receiver = try SocketDescriptor.open(.ipv4, .datagram, protocol: .udp)
defer { try? receiver.close() }
let receiverAddr = SocketAddress(ipv4: IPv4Address.loopback(port: 0))
try receiver.bind(to: receiverAddr)
var boundAddr = SocketAddress()
try receiver.getLocalAddress(into: &boundAddr)
let port = boundAddr.ipv4!.port
// Create sender socket
let sender = try SocketDescriptor.open(.ipv4, .datagram, protocol: .udp)
defer { try? sender.close() }
// Send datagram
let message = "UDP Message"
let messageBytes = Array(message.utf8)
let targetAddr = SocketAddress(ipv4: IPv4Address.loopback(port: port))
let sent = try messageBytes.withUnsafeBytes { buffer in
try sender.send(UnsafeRawBufferPointer(buffer), to: targetAddr)
}
#expect(sent == messageBytes.count)
// Receive datagram
var buffer = [UInt8](repeating: 0, count: 1024)
var fromAddr = SocketAddress()
let received = try buffer.withUnsafeMutableBytes { buffer in
try receiver.receive(into: buffer, sender: &fromAddr)
}
#expect(received == messageBytes.count)
#expect(fromAddr.family == SocketDescriptor.Domain.ipv4)
let receivedMessage = String(decoding: buffer.prefix(received), as: UTF8.self)
#expect(receivedMessage == message)
}
// MARK: - Socket Options Tests
@available(System 99, *)
@Test func setReuseAddress() throws {
let socket = try SocketDescriptor.open(.ipv4, .stream, protocol: .tcp)
defer { try? socket.close() }
try socket.setReuseAddress(true)
let value = try socket.getSocketOption(SocketDescriptor.SocketOption.reuseAddress)
#expect(value != 0)
}
@available(System 99, *)
@Test func getSendBufferSize() throws {
let socket = try SocketDescriptor.open(.ipv4, .stream, protocol: .tcp)
defer { try? socket.close() }
let size = try socket.getSocketOption(SocketDescriptor.SocketOption.sendBufferSize)
#expect(size > 0)
}
@available(System 99, *)
@Test func getReceiveBufferSize() throws {
let socket = try SocketDescriptor.open(.ipv4, .stream, protocol: .tcp)
defer { try? socket.close() }
let size = try socket.getSocketOption(SocketDescriptor.SocketOption.receiveBufferSize)
#expect(size > 0)
}
}
#endif
+463
View File
@@ -0,0 +1,463 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift System open source project
//
// Copyright (c) 2025 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 Testing
#if SYSTEM_PACKAGE
@testable import SystemPackage
#else
@testable import System
#endif
@Suite("Span-based File I/O")
private struct SpanFileIOTests {
// MARK: - Basic Functionality
@available(macOS 15, iOS 18, watchOS 11, tvOS 18, visionOS 2, *)
@Test func basicReadWriteOperations() async throws {
try withTemporaryFilePath(basename: "basicReadWriteOperations") { path in
let fd = try FileDescriptor.open(
path.appending("test.txt"), .readWrite,
options: [.create, .truncate],
permissions: .ownerReadWrite
)
try fd.closeAfter {
// Test write(_:)
let data1: [UInt8] = [0x61, 0x62, 0x63] // "abc"
let written1 = try data1.withUnsafeBytes { bytes in
try fd.write(RawSpan(_unsafeBytes: bytes))
}
#expect(written1 == 3)
// Test write(toAbsoluteOffset:_:)
let data2: [UInt8] = [0x64, 0x65, 0x66] // "def"
let written2 = try data2.withUnsafeBytes { bytes in
try fd.write(toAbsoluteOffset: 3, RawSpan(_unsafeBytes: bytes))
}
#expect(written2 == 3)
// Test writeAll(_:)
try fd.seek(offset: 6, from: .start)
let data3: [UInt8] = [0x67, 0x68, 0x69] // "ghi"
let written3 = try data3.withUnsafeBytes { bytes in
try fd.writeAll(RawSpan(_unsafeBytes: bytes))
}
#expect(written3 == 3)
// Test writeAll(toAbsoluteOffset:_:)
let data4: [UInt8] = [0x6A, 0x6B, 0x6C] // "jkl"
let written4 = try data4.withUnsafeBytes { bytes in
try fd.writeAll(toAbsoluteOffset: 9, RawSpan(_unsafeBytes: bytes))
}
#expect(written4 == 3)
// Test read(into:)
try fd.seek(offset: 0, from: .start)
let result1 = try [UInt8](unsafeUninitializedCapacity: 12) { buffer, count in
var output = OutputRawSpan(buffer: UnsafeMutableRawBufferPointer(buffer), initializedCount: 0)
_ = try fd.read(into: &output)
count = output.byteCount
}
#expect(result1.count <= 12) // May be partial
// Test read(filling:)
try fd.seek(offset: 0, from: .start)
let result2 = try [UInt8](unsafeUninitializedCapacity: 12) { buffer, count in
var output = OutputRawSpan(buffer: UnsafeMutableRawBufferPointer(buffer), initializedCount: 0)
count = try fd.read(filling: &output)
}
#expect(result2 == data1 + data2 + data3 + data4)
// Test read(fromAbsoluteOffset:into:)
let result3 = try [UInt8](unsafeUninitializedCapacity: 3) { buffer, count in
var output = OutputRawSpan(buffer: UnsafeMutableRawBufferPointer(buffer), initializedCount: 0)
_ = try fd.read(fromAbsoluteOffset: 3, into: &output)
count = output.byteCount
}
#expect(result3.count <= 3) // May be partial
// Test read(fromAbsoluteOffset:filling:)
let result4 = try [UInt8](unsafeUninitializedCapacity: 3) { buffer, count in
var output = OutputRawSpan(buffer: UnsafeMutableRawBufferPointer(buffer), initializedCount: 0)
count = try fd.read(fromAbsoluteOffset: 6, filling: &output)
}
#expect(result4 == data3)
}
}
}
@available(macOS 15, iOS 18, watchOS 11, tvOS 18, visionOS 2, *)
@Test func writeOperations() async throws {
try withTemporaryFilePath(basename: "writeOperations") { path in
let fd = try FileDescriptor.open(
path.appending("test.txt"), .readWrite,
options: [.create, .truncate],
permissions: .ownerReadWrite
)
try fd.closeAfter {
// Small write
let small: [UInt8] = [0x61, 0x62, 0x63]
_ = try small.withUnsafeBytes { bytes in
try fd.writeAll(RawSpan(_unsafeBytes: bytes))
}
// Large write
let large: [UInt8] = Array((0..<1024).map { UInt8($0 % 256) })
_ = try large.withUnsafeBytes { bytes in
try fd.writeAll(RawSpan(_unsafeBytes: bytes))
}
// Verify size
let size = try fd.seek(offset: 0, from: .end)
#expect(size == 3 + 1024)
// Verify content
try fd.seek(offset: 0, from: .start)
let readBack = try [UInt8](unsafeUninitializedCapacity: 3 + 1024) { buffer, count in
var output = OutputRawSpan(buffer: UnsafeMutableRawBufferPointer(buffer), initializedCount: 0)
count = try fd.read(filling: &output)
}
#expect(readBack == small + large)
}
}
}
@available(macOS 15, iOS 18, watchOS 11, tvOS 18, visionOS 2, *)
@Test func readOperations() async throws {
try withTemporaryFilePath(basename: "readOperations") { path in
let fd = try FileDescriptor.open(
path.appending("test.txt"), .readWrite,
options: [.create, .truncate],
permissions: .ownerReadWrite
)
try fd.closeAfter {
let data: [UInt8] = Array((0..<1024).map { UInt8($0 % 256) })
try fd.writeAll(data)
try fd.seek(offset: 0, from: .start)
// Small read
let small = try [UInt8](unsafeUninitializedCapacity: 10) { buffer, count in
var output = OutputRawSpan(buffer: UnsafeMutableRawBufferPointer(buffer), initializedCount: 0)
count = try fd.read(filling: &output)
}
#expect(small == Array(0..<10))
// Large read
try fd.seek(offset: 0, from: .start)
let large = try [UInt8](unsafeUninitializedCapacity: 1024) { buffer, count in
var output = OutputRawSpan(buffer: UnsafeMutableRawBufferPointer(buffer), initializedCount: 0)
count = try fd.read(filling: &output)
}
#expect(large == data)
}
}
}
@available(macOS 15, iOS 18, watchOS 11, tvOS 18, visionOS 2, *)
@Test func absoluteOffsetOperations() async throws {
try withTemporaryFilePath(basename: "absoluteOffsetOperations") { path in
let fd = try FileDescriptor.open(
path.appending("test.txt"), .readWrite,
options: [.create, .truncate],
permissions: .ownerReadWrite
)
try fd.closeAfter {
let data: [UInt8] = Array(0..<100)
try fd.writeAll(data)
// Write at absolute offset should not change file position
let initialOffset = try fd.seek(offset: 0, from: .current)
let patchData: [UInt8] = [0xFF, 0xFE]
_ = try patchData.withUnsafeBytes { bytes in
try fd.writeAll(toAbsoluteOffset: 50, RawSpan(_unsafeBytes: bytes))
}
let afterWriteOffset = try fd.seek(offset: 0, from: .current)
#expect(initialOffset == afterWriteOffset)
// Read at absolute offset should not change file position
try fd.seek(offset: 10, from: .start)
let readAtOffset = try [UInt8](unsafeUninitializedCapacity: 2) { buffer, count in
var output = OutputRawSpan(buffer: UnsafeMutableRawBufferPointer(buffer), initializedCount: 0)
count = try fd.read(fromAbsoluteOffset: 50, filling: &output)
}
#expect(readAtOffset == patchData)
let afterReadOffset = try fd.seek(offset: 0, from: .current)
#expect(afterReadOffset == 10) // Should still be at 10
}
}
}
// MARK: - Semantic Behavior
@available(macOS 15, iOS 18, watchOS 11, tvOS 18, visionOS 2, *)
@Test func partialReadBehavior() async throws {
try withTemporaryFilePath(basename: "partialReadBehavior") { path in
let fd = try FileDescriptor.open(
path.appending("test.txt"), .readWrite,
options: [.create, .truncate],
permissions: .ownerReadWrite
)
try fd.closeAfter {
let data: [UInt8] = Array(0..<100)
try fd.writeAll(data)
try fd.seek(offset: 0, from: .start)
// read(into:) may return partial data - this is valid behavior
let output = UnsafeMutableRawBufferPointer.allocate(byteCount: 100, alignment: 1)
defer { output.deallocate() }
var span = OutputRawSpan(buffer: output, initializedCount: 0)
var totalRead = 0
while span.freeCapacity > 0 {
let bytesRead = try fd.read(into: &span)
if bytesRead == 0 { break } // EOF
totalRead += bytesRead
#expect(bytesRead > 0)
#expect(bytesRead <= span.freeCapacity + bytesRead) // Can't read more than capacity
}
// Should eventually get all data with multiple reads
#expect(totalRead == 100)
#expect(span.byteCount == 100)
}
}
}
@available(macOS 15, iOS 18, watchOS 11, tvOS 18, visionOS 2, *)
@Test func readFillingBehavior() async throws {
try withTemporaryFilePath(basename: "readFillingBehavior") { path in
let fd = try FileDescriptor.open(
path.appending("test.txt"), .readWrite,
options: [.create, .truncate],
permissions: .ownerReadWrite
)
try fd.closeAfter {
// Test 1: read(filling:) fills buffer completely when data available
let fullData: [UInt8] = Array(0..<100)
try fd.writeAll(fullData)
try fd.seek(offset: 0, from: .start)
let result1 = try [UInt8](unsafeUninitializedCapacity: 100) { buffer, count in
var output = OutputRawSpan(buffer: UnsafeMutableRawBufferPointer(buffer), initializedCount: 0)
let bytesRead = try fd.read(filling: &output)
#expect(bytesRead == 100)
#expect(output.freeCapacity == 0) // Should be completely full
count = output.byteCount
}
#expect(result1 == fullData)
// Test 2: read(filling:) stops at EOF even if buffer not full
try fd.seek(offset: 0, from: .start)
let result2 = try [UInt8](unsafeUninitializedCapacity: 200) { buffer, count in
var output = OutputRawSpan(buffer: UnsafeMutableRawBufferPointer(buffer), initializedCount: 0)
let bytesRead = try fd.read(filling: &output)
#expect(bytesRead == 100) // Only 100 bytes available
#expect(output.freeCapacity == 100) // 100 bytes unfilled
count = output.byteCount
}
#expect(result2 == fullData)
}
}
}
// MARK: - Edge Cases
@available(macOS 15, iOS 18, watchOS 11, tvOS 18, visionOS 2, *)
@Test func emptyIO() async throws {
try withTemporaryFilePath(basename: "emptyIO") { path in
let fd = try FileDescriptor.open(
path.appending("test.txt"), .readWrite,
options: [.create, .truncate],
permissions: .ownerReadWrite
)
try fd.closeAfter {
// Empty write
let empty: [UInt8] = []
let written = try empty.withUnsafeBytes { bytes in
try fd.writeAll(RawSpan(_unsafeBytes: bytes))
}
#expect(written == 0)
// Empty read (from empty file)
let result1 = try [UInt8](unsafeUninitializedCapacity: 10) { buffer, count in
var output = OutputRawSpan(buffer: UnsafeMutableRawBufferPointer(buffer), initializedCount: 0)
count = try fd.read(into: &output)
}
#expect(result1.isEmpty)
// Zero-capacity buffer
let data: [UInt8] = [0x61, 0x62, 0x63]
try fd.writeAll(data)
try fd.seek(offset: 0, from: .start)
let result2 = try [UInt8](unsafeUninitializedCapacity: 0) { buffer, count in
var output = OutputRawSpan(buffer: UnsafeMutableRawBufferPointer(buffer), initializedCount: 0)
count = try fd.read(into: &output)
}
#expect(result2.isEmpty)
}
}
}
@available(macOS 15, iOS 18, watchOS 11, tvOS 18, visionOS 2, *)
@Test func eofBehavior() async throws {
try withTemporaryFilePath(basename: "eofBehavior") { path in
let fd = try FileDescriptor.open(
path.appending("test.txt"), .readWrite,
options: [.create, .truncate],
permissions: .ownerReadWrite
)
try fd.closeAfter {
let data: [UInt8] = [0x61, 0x62, 0x63]
try fd.writeAll(data)
try fd.seek(offset: 0, from: .start)
// Read all data
let result1 = try [UInt8](unsafeUninitializedCapacity: 3) { buffer, count in
var output = OutputRawSpan(buffer: UnsafeMutableRawBufferPointer(buffer), initializedCount: 0)
count = try fd.read(filling: &output)
}
#expect(result1 == data)
// Read at EOF returns 0
let result2 = try [UInt8](unsafeUninitializedCapacity: 10) { buffer, count in
var output = OutputRawSpan(buffer: UnsafeMutableRawBufferPointer(buffer), initializedCount: 0)
count = try fd.read(into: &output)
}
#expect(result2.isEmpty)
// read(filling:) with buffer larger than file stops at EOF
try fd.seek(offset: 0, from: .start)
let result3 = try [UInt8](unsafeUninitializedCapacity: 10) { buffer, count in
var output = OutputRawSpan(buffer: UnsafeMutableRawBufferPointer(buffer), initializedCount: 0)
let bytesRead = try fd.read(filling: &output)
#expect(bytesRead == 3) // Only 3 bytes available
count = bytesRead
}
#expect(result3 == data)
}
}
}
@available(macOS 15, iOS 18, watchOS 11, tvOS 18, visionOS 2, *)
@Test func preInitializedSpan() async throws {
try withTemporaryFilePath(basename: "preInitializedSpan") { path in
let fd = try FileDescriptor.open(
path.appending("test.txt"), .readWrite,
options: [.create, .truncate],
permissions: .ownerReadWrite
)
try fd.closeAfter {
let fileData: [UInt8] = [0x61, 0x62, 0x63] // "abc"
try fd.writeAll(fileData)
try fd.seek(offset: 0, from: .start)
// Create buffer with pre-existing initialized data
let result = try [UInt8](unsafeUninitializedCapacity: 10) { buffer, count in
// Pre-initialize first 2 bytes
buffer[0] = 0xFF
buffer[1] = 0xFE
// Create OutputRawSpan that knows about pre-initialized portion
var output = OutputRawSpan(buffer: UnsafeMutableRawBufferPointer(buffer), initializedCount: 2)
// Read more data - should append after pre-initialized data
let bytesRead = try fd.read(filling: &output)
#expect(bytesRead == 3) // Read "abc"
#expect(output.byteCount == 5) // 2 pre-initialized + 3 read = 5 total
count = output.byteCount
}
// Verify: first 2 bytes are pre-initialized, next 3 are from file
#expect(result == [0xFF, 0xFE, 0x61, 0x62, 0x63])
}
}
}
@available(macOS 15, iOS 18, watchOS 11, tvOS 18, visionOS 2, *)
@Test func errorHandling() throws {
// Test 1: Reading from closed FD
let fd1 = try FileDescriptor.open(FilePath("/dev/null"), .readOnly)
try fd1.close()
#expect(throws: Errno.badFileDescriptor) {
let buffer = UnsafeMutableRawBufferPointer.allocate(byteCount: 10, alignment: 1)
defer { buffer.deallocate() }
var output = OutputRawSpan(buffer: buffer, initializedCount: 0)
_ = try fd1.read(into: &output)
}
// Test 2: Writing to closed FD
let fd2 = try FileDescriptor.open(FilePath("/dev/null"), .writeOnly)
try fd2.close()
let data: [UInt8] = [0x61, 0x62, 0x63]
#expect(throws: Errno.badFileDescriptor) {
try data.withUnsafeBytes { bytes in
try fd2.write(RawSpan(_unsafeBytes: bytes))
}
}
// Test 3: Writing to read-only FD
try withTemporaryFilePath(basename: "errorHandling") { path in
// Create file first
let fdWrite = try FileDescriptor.open(
path.appending("test.txt"), .writeOnly,
options: [.create, .truncate],
permissions: .ownerReadWrite
)
_ = try fdWrite.closeAfter {
try fdWrite.writeAll(data)
}
// Open read-only and try to write
let fdRead = try FileDescriptor.open(
path.appending("test.txt"), .readOnly
)
_ = try fdRead.closeAfter {
#expect(throws: Errno.badFileDescriptor) {
try data.withUnsafeBytes { bytes in
try fdRead.write(RawSpan(_unsafeBytes: bytes))
}
}
}
}
}
// MARK: - Regression/Examples
@available(macOS 15, iOS 18, watchOS 11, tvOS 18, visionOS 2, *)
@Test func proposalExample() async throws {
// Example from the proposal
try withTemporaryFilePath(basename: "proposalExample") { path in
let fd = try FileDescriptor.open(
path.appending("test.txt"), .readWrite,
options: [.create, .truncate],
permissions: .ownerReadWrite
)
try fd.closeAfter {
let writeData: [UInt8] = Array(repeating: 42, count: 4096)
try fd.writeAll(writeData)
try fd.seek(offset: 0, from: .start)
let chunk = try [UInt8](unsafeUninitializedCapacity: 4096) { buffer, count in
var output = OutputRawSpan(buffer: UnsafeMutableRawBufferPointer(buffer), initializedCount: 0)
count = try fd.read(filling: &output, retryOnInterrupt: true)
}
#expect(chunk.count == 4096)
#expect(chunk == writeData)
}
}
}
}