IMPORTANT If you haven’t yet read Calling BSD Sockets from Swift, do that first.
The biggest problem with calling BSD Sockets from Swift is how to represent an address. The C API works in terms of struct sockaddr *, which is a ‘base class’ with various ‘subclasses’, like struct sockaddr_in *. C lets you [1] freely cast between these, but that’s harder in Swift. My solution for this — and remember that one of my key goals is to create a wrapper that’s good for test projects — is to represent addresses as strings.
I start by defining a namespace for this stuff:
/// A namespace for helpers that work with BSD Sockets addresses.
///
/// These convert between IP address strings and the `sockaddr` pointers used by
/// the BSD Sockets API. For example, here’s how you can call `connect` with an
/// IP address and string.
///
/// ```swift
/// let success = try QSockAddr.withSockAddr(address: "1.2.3.4", port: 12345) { sa, saLen in
/// connect(fd, sa, saLen) >= 0
/// }
/// ```
///
/// This example calls ``withSockAddr(address:port:_:)``, which is what you use
/// when passing an address into BSD Sockets. There’s also
/// ``fromSockAddr(sa:saLen:)``, to use when getting an address back from BSD
/// Sockets.
///
/// > important: Representing addresses as strings is potentially very
/// inefficient. For example, if you were to wrap the BSD Sockets `sendto` call
/// in this way, you would end up doing a string-to-address conversion every
/// time you sent a datagram! However, it _is_ very convenient, making it perfect
/// for small test projects, wrapping weird low-level APIs, and so on.
///
/// Keep in mind that I rarely use BSD Sockets for _networking_ these days.
/// Apple platforms have better networking APIs; see TN3151 [Choosing the right
/// networking API][tn3151] for the details.
///
/// [tn3151]: <[TN3151: Choosing the right networking API | Apple Developer Documentation](https://developer.apple.com/documentation/technotes/tn3151-choosing-the-right-networking-api)>
public enum QSockAddr {
}
I then extend it with various helpers. The first is for calling a routine that takes a sockaddr input:
extension QSockAddr {
/// Calls a closure with a socket address and length.
///
/// Use this to pass an address in to a BSD Sockets call. For example:
///
/// ```swift
/// let success = try QSockAddr.withSockAddr(address: "1.2.3.4", port: 12345) { sa, saLen in
/// connect(fd, sa, saLen) >= 0
/// }
/// ```
///
/// - Parameters:
/// - address: The address as a string. This can be either an IPv4 or IPv6
/// address, in any format accepted by `getaddrinfo` when the
/// `AI_NUMERICHOST` flag is set.
/// - port: The port number.
/// - body: A closure to call with the corresponding `sockaddr` pointer
/// and length.
/// - Returns: The value returned by that closure.
public static func withSockAddr<ReturnType>(
address: String,
port: UInt16,
_ body: (_ sa: UnsafePointer<sockaddr>, _ saLen: socklen_t) throws -> ReturnType
) throws -> ReturnType {
var addrList: UnsafeMutablePointer<addrinfo>? = nil
var hints = addrinfo()
hints.ai_flags = AI_NUMERICHOST | AI_NUMERICSERV
let err = getaddrinfo(address, "\(port)", &hints, &addrList)
guard err == 0 else { throw QSockAddr.NetDBError(code: err) }
guard let addr = addrList else { throw QSockAddr.NetDBError(code: EAI_NODATA) }
defer { freeaddrinfo(addrList) }
return try body(addr.pointee.ai_addr, addr.pointee.ai_addrlen)
}
}
The second is for calling a routine that returns a sockaddr:
extension QSockAddr {
/// Creates an address by calling a closure to fill in a socket address and
/// length.
///
/// Use this to get an address back from a BSD Sockets call. For example:
///
/// ```swift
/// let peer = try QSockAddr.fromSockAddr() { sa, saLen in
/// getpeername(fd, sa, &saLen) >= 0
/// }
/// guard peer.result else { … something went wrong … }
/// … use peer.address and peer.port …
/// ```
///
/// - Parameter body: The closure to call. It passes this a mutable pointer
/// to a `sockaddr` and an `inout` length. The closure is expected to
/// populate that memory with an IPv4 or IPv6 address, or throw an error.
/// - Returns: A tuple containing the closure result, the address string,
/// and the port.
public static func fromSockAddr<ReturnType>(_ body: (_ sa: UnsafeMutablePointer<sockaddr>, _ saLen: inout socklen_t) throws -> ReturnType) throws -> (result: ReturnType, address: String, port: UInt16) {
var ss = sockaddr_storage()
var saLen = socklen_t(MemoryLayout<sockaddr_storage>.size)
return try withUnsafeMutablePointer(to: &ss) {
try $0.withMemoryRebound(to: sockaddr.self, capacity: 1) { sa in
let result = try body(sa, &saLen)
let (address, port) = try fromSockAddr(sa: sa, saLen: saLen)
return (result, address, port)
}
}
}
}
And the third is for when you start with a sockaddr pointer:
extension QSockAddr {
/// Creates an address from an address pointer and length.
///
/// Use this when you have an existing `sockaddr` pointer, for example, when
/// working with `getifaddrs`.
///
/// - Parameters:
/// - sa: The address pointer
/// - saLen: The address length.
/// - Returns: A tuple containing the address string, and the port.
public static func fromSockAddr(sa: UnsafeMutablePointer<sockaddr>, saLen: socklen_t) throws -> (address: String, port: UInt16) {
var host = [CChar](repeating: 0, count: Int(NI_MAXHOST))
var serv = [CChar](repeating: 0, count: Int(NI_MAXSERV))
let err = getnameinfo(sa, saLen, &host, socklen_t(host.count), &serv, socklen_t(serv.count), NI_NUMERICHOST | NI_NUMERICSERV)
guard err == 0 else { throw QSockAddr.NetDBError(code: err) }
guard let port = UInt16(String(cString: serv)) else { throw QSockAddr.NetDBError(code: EAI_SERVICE) }
return (String(cString: host), port)
}
}
Finally, these routines rely on this error type:
extension QSockAddr {
/// Wraps an error coming from the DNS subsytem.
///
/// The code values correspond to `EAI_***` in `<netdb.h>`.
struct NetDBError: Error {
var code: CInt
}
}
Share and Enjoy
—
Quinn “The Eskimo!” @ Developer Technical Support @ Apple
let myEmail = "eskimo" + "1" + "@" + "apple.com"
[1] Or does it? There’s some debate as to whether the BSD Sockets API is legal C (-:
