@braedonsaunders/appkit-desk 0.7.0 → 0.8.0

package/vz/Sources/DeskNet/Packets.swift

@@ -0,0 +1,355 @@
+/// Encoding and decoding of the frames that cross the virtual link: Ethernet,
+/// ARP, IPv4, TCP, UDP and ICMP. Everything here is pure and works on byte
+/// arrays, so it is tested without a guest.
+
+public enum EtherType {
+  public static let ipv4: UInt16 = 0x0800
+  public static let arp: UInt16 = 0x0806
+}
+
+public enum IPProtocol {
+  public static let icmp: UInt8 = 1
+  public static let tcp: UInt8 = 6
+  public static let udp: UInt8 = 17
+}
+
+@inline(__always) func be16(_ bytes: [UInt8], _ offset: Int) -> UInt16 {
+  UInt16(bytes[offset]) << 8 | UInt16(bytes[offset + 1])
+}
+
+@inline(__always) func be32(_ bytes: [UInt8], _ offset: Int) -> UInt32 {
+  UInt32(bytes[offset]) << 24 | UInt32(bytes[offset + 1]) << 16 | UInt32(bytes[offset + 2]) << 8
+    | UInt32(bytes[offset + 3])
+}
+
+@inline(__always) func put16(_ bytes: inout [UInt8], _ offset: Int, _ value: UInt16) {
+  bytes[offset] = UInt8(value >> 8)
+  bytes[offset + 1] = UInt8(value & 0xff)
+}
+
+@inline(__always) func put32(_ bytes: inout [UInt8], _ offset: Int, _ value: UInt32) {
+  bytes[offset] = UInt8(value >> 24)
+  bytes[offset + 1] = UInt8(value >> 16 & 0xff)
+  bytes[offset + 2] = UInt8(value >> 8 & 0xff)
+  bytes[offset + 3] = UInt8(value & 0xff)
+}
+
+/// The Internet checksum (RFC 1071) over `bytes`, folded and complemented.
+public func internetChecksum(_ bytes: [UInt8], initial: UInt32 = 0) -> UInt16 {
+  var sum = initial
+  var index = 0
+  let count = bytes.count
+  while index + 1 < count {
+    sum &+= UInt32(bytes[index]) << 8 | UInt32(bytes[index + 1])
+    index += 2
+  }
+  if index < count { sum &+= UInt32(bytes[index]) << 8 }
+  while sum >> 16 != 0 { sum = (sum & 0xffff) &+ (sum >> 16) }
+  return ~UInt16(sum & 0xffff)
+}
+
+func pseudoHeaderSum(source: IPv4, destination: IPv4, protocol proto: UInt8, length: Int) -> UInt32 {
+  var sum: UInt32 = 0
+  sum &+= source.value >> 16
+  sum &+= source.value & 0xffff
+  sum &+= destination.value >> 16
+  sum &+= destination.value & 0xffff
+  sum &+= UInt32(proto)
+  sum &+= UInt32(length)
+  return sum
+}
+
+// MARK: - Ethernet
+
+public struct EthernetFrame: Sendable {
+  public var destination: MAC
+  public var source: MAC
+  public var type: UInt16
+  public var payload: [UInt8]
+
+  public init(destination: MAC, source: MAC, type: UInt16, payload: [UInt8]) {
+    self.destination = destination
+    self.source = source
+    self.type = type
+    self.payload = payload
+  }
+
+  public init?(parsing bytes: [UInt8]) {
+    guard bytes.count >= 14 else { return nil }
+    destination = MAC(Array(bytes[0..<6]))
+    source = MAC(Array(bytes[6..<12]))
+    type = be16(bytes, 12)
+    payload = Array(bytes[14...])
+  }
+
+  public var encoded: [UInt8] {
+    var bytes = destination.bytes + source.bytes + [0, 0]
+    put16(&bytes, 12, type)
+    return bytes + payload
+  }
+}
+
+// MARK: - ARP
+
+public struct ARPPacket: Sendable, Equatable {
+  public static let request: UInt16 = 1
+  public static let reply: UInt16 = 2
+
+  public var operation: UInt16
+  public var senderMAC: MAC
+  public var senderIP: IPv4
+  public var targetMAC: MAC
+  public var targetIP: IPv4
+
+  public init(operation: UInt16, senderMAC: MAC, senderIP: IPv4, targetMAC: MAC, targetIP: IPv4) {
+    self.operation = operation
+    self.senderMAC = senderMAC
+    self.senderIP = senderIP
+    self.targetMAC = targetMAC
+    self.targetIP = targetIP
+  }
+
+  public init?(parsing bytes: [UInt8]) {
+    // Ethernet hardware (1), IPv4 protocol, 6-byte MACs, 4-byte addresses.
+    guard bytes.count >= 28, be16(bytes, 0) == 1, be16(bytes, 2) == EtherType.ipv4,
+      bytes[4] == 6, bytes[5] == 4
+    else { return nil }
+    operation = be16(bytes, 6)
+    senderMAC = MAC(Array(bytes[8..<14]))
+    senderIP = IPv4(bytes: bytes, at: 14)
+    targetMAC = MAC(Array(bytes[18..<24]))
+    targetIP = IPv4(bytes: bytes, at: 24)
+  }
+
+  public var encoded: [UInt8] {
+    var bytes: [UInt8] = [0, 1, 0x08, 0x00, 6, 4, 0, 0]
+    put16(&bytes, 6, operation)
+    return bytes + senderMAC.bytes + senderIP.bytes + targetMAC.bytes + targetIP.bytes
+  }
+}
+
+// MARK: - IPv4
+
+public struct IPv4Packet: Sendable {
+  public var source: IPv4
+  public var destination: IPv4
+  public var proto: UInt8
+  public var ttl: UInt8
+  public var identification: UInt16
+  /// True when this is any piece of a fragmented datagram.
+  public var isFragment: Bool
+  /// The header exactly as received, for quoting in ICMP errors.
+  public var header: [UInt8]
+  public var payload: [UInt8]
+
+  public init?(parsing bytes: [UInt8]) {
+    guard bytes.count >= 20, bytes[0] >> 4 == 4 else { return nil }
+    let headerLength = Int(bytes[0] & 0x0f) * 4
+    let totalLength = Int(be16(bytes, 2))
+    guard headerLength >= 20, totalLength >= headerLength, bytes.count >= totalLength else {
+      return nil
+    }
+    let flagsAndOffset = be16(bytes, 6)
+    isFragment = flagsAndOffset & 0x2000 != 0 || flagsAndOffset & 0x1fff != 0
+    identification = be16(bytes, 4)
+    ttl = bytes[8]
+    proto = bytes[9]
+    source = IPv4(bytes: bytes, at: 12)
+    destination = IPv4(bytes: bytes, at: 16)
+    header = Array(bytes[0..<headerLength])
+    payload = Array(bytes[headerLength..<totalLength])
+  }
+
+  /// Build a datagram with a correct header checksum and Don't Fragment set.
+  public static func encode(
+    source: IPv4, destination: IPv4, proto: UInt8, payload: [UInt8], identification: UInt16 = 0,
+    ttl: UInt8 = 64
+  ) -> [UInt8] {
+    var header = [UInt8](repeating: 0, count: 20)
+    header[0] = 0x45
+    put16(&header, 2, UInt16(20 + payload.count))
+    put16(&header, 4, identification)
+    put16(&header, 6, 0x4000)
+    header[8] = ttl
+    header[9] = proto
+    put32(&header, 12, source.value)
+    put32(&header, 16, destination.value)
+    put16(&header, 10, internetChecksum(header))
+    return header + payload
+  }
+}
+
+// MARK: - TCP
+
+public struct TCPFlags: OptionSet, Sendable, Hashable {
+  public let rawValue: UInt8
+  public init(rawValue: UInt8) { self.rawValue = rawValue }
+  public static let fin = TCPFlags(rawValue: 0x01)
+  public static let syn = TCPFlags(rawValue: 0x02)
+  public static let rst = TCPFlags(rawValue: 0x04)
+  public static let psh = TCPFlags(rawValue: 0x08)
+  public static let ack = TCPFlags(rawValue: 0x10)
+}
+
+public struct TCPSegment: Sendable {
+  public var sourcePort: UInt16
+  public var destinationPort: UInt16
+  public var sequence: UInt32
+  public var acknowledgement: UInt32
+  public var flags: TCPFlags
+  public var window: UInt16
+  /// The maximum segment size option, when the segment carries one.
+  public var mss: UInt16?
+  public var payload: [UInt8]
+
+  public init(
+    sourcePort: UInt16, destinationPort: UInt16, sequence: UInt32, acknowledgement: UInt32,
+    flags: TCPFlags, window: UInt16, mss: UInt16? = nil, payload: [UInt8] = []
+  ) {
+    self.sourcePort = sourcePort
+    self.destinationPort = destinationPort
+    self.sequence = sequence
+    self.acknowledgement = acknowledgement
+    self.flags = flags
+    self.window = window
+    self.mss = mss
+    self.payload = payload
+  }
+
+  public init?(parsing bytes: [UInt8]) {
+    guard bytes.count >= 20 else { return nil }
+    let dataOffset = Int(bytes[12] >> 4) * 4
+    guard dataOffset >= 20, bytes.count >= dataOffset else { return nil }
+    sourcePort = be16(bytes, 0)
+    destinationPort = be16(bytes, 2)
+    sequence = be32(bytes, 4)
+    acknowledgement = be32(bytes, 8)
+    flags = TCPFlags(rawValue: bytes[13] & 0x1f)
+    window = be16(bytes, 14)
+    mss = nil
+    var index = 20
+    while index < dataOffset {
+      let kind = bytes[index]
+      if kind == 0 { break }
+      if kind == 1 {
+        index += 1
+        continue
+      }
+      guard index + 1 < dataOffset else { break }
+      let length = Int(bytes[index + 1])
+      guard length >= 2, index + length <= dataOffset else { break }
+      if kind == 2, length == 4 { mss = be16(bytes, index + 2) }
+      index += length
+    }
+    payload = Array(bytes[dataOffset...])
+  }
+
+  /// The sequence space this segment occupies: its payload plus SYN and FIN.
+  public var sequenceLength: UInt32 {
+    UInt32(payload.count) + (flags.contains(.syn) ? 1 : 0) + (flags.contains(.fin) ? 1 : 0)
+  }
+
+  public func encoded(source: IPv4, destination: IPv4) -> [UInt8] {
+    let optionBytes: [UInt8] = mss.map { [2, 4, UInt8($0 >> 8), UInt8($0 & 0xff)] } ?? []
+    let headerLength = 20 + optionBytes.count
+    var bytes = [UInt8](repeating: 0, count: 20)
+    put16(&bytes, 0, sourcePort)
+    put16(&bytes, 2, destinationPort)
+    put32(&bytes, 4, sequence)
+    put32(&bytes, 8, acknowledgement)
+    bytes[12] = UInt8(headerLength / 4) << 4
+    bytes[13] = flags.rawValue
+    put16(&bytes, 14, window)
+    bytes += optionBytes
+    bytes += payload
+    let sum = pseudoHeaderSum(
+      source: source, destination: destination, protocol: IPProtocol.tcp, length: bytes.count)
+    put16(&bytes, 16, internetChecksum(bytes, initial: sum))
+    return bytes
+  }
+}
+
+// MARK: - UDP
+
+public struct UDPDatagram: Sendable {
+  public var sourcePort: UInt16
+  public var destinationPort: UInt16
+  public var payload: [UInt8]
+
+  public init(sourcePort: UInt16, destinationPort: UInt16, payload: [UInt8]) {
+    self.sourcePort = sourcePort
+    self.destinationPort = destinationPort
+    self.payload = payload
+  }
+
+  public init?(parsing bytes: [UInt8]) {
+    guard bytes.count >= 8 else { return nil }
+    let length = Int(be16(bytes, 4))
+    guard length >= 8, length <= bytes.count else { return nil }
+    sourcePort = be16(bytes, 0)
+    destinationPort = be16(bytes, 2)
+    payload = Array(bytes[8..<length])
+  }
+
+  public func encoded(source: IPv4, destination: IPv4) -> [UInt8] {
+    var bytes = [UInt8](repeating: 0, count: 8)
+    put16(&bytes, 0, sourcePort)
+    put16(&bytes, 2, destinationPort)
+    put16(&bytes, 4, UInt16(8 + payload.count))
+    bytes += payload
+    let sum = pseudoHeaderSum(
+      source: source, destination: destination, protocol: IPProtocol.udp, length: bytes.count)
+    var checksum = internetChecksum(bytes, initial: sum)
+    // A computed zero is sent as all ones; zero means "no checksum" in UDP.
+    if checksum == 0 { checksum = 0xffff }
+    put16(&bytes, 6, checksum)
+    return bytes
+  }
+}
+
+// MARK: - ICMP
+
+public struct ICMPMessage: Sendable {
+  public static let echoReply: UInt8 = 0
+  public static let destinationUnreachable: UInt8 = 3
+  public static let echoRequest: UInt8 = 8
+
+  /// Destination-unreachable codes the stack sends.
+  public static let hostUnreachable: UInt8 = 1
+  public static let portUnreachable: UInt8 = 3
+  public static let administrativelyProhibited: UInt8 = 13
+
+  public var type: UInt8
+  public var code: UInt8
+  /// The four bytes after the checksum: identifier and sequence for echo.
+  public var rest: UInt32
+  public var payload: [UInt8]
+
+  public init(type: UInt8, code: UInt8, rest: UInt32, payload: [UInt8]) {
+    self.type = type
+    self.code = code
+    self.rest = rest
+    self.payload = payload
+  }
+
+  public init?(parsing bytes: [UInt8]) {
+    guard bytes.count >= 8 else { return nil }
+    type = bytes[0]
+    code = bytes[1]
+    rest = be32(bytes, 4)
+    payload = Array(bytes[8...])
+  }
+
+  public var identifier: UInt16 { UInt16(rest >> 16) }
+  public var sequenceNumber: UInt16 { UInt16(rest & 0xffff) }
+
+  public var encoded: [UInt8] {
+    var bytes = [UInt8](repeating: 0, count: 8)
+    bytes[0] = type
+    bytes[1] = code
+    put32(&bytes, 4, rest)
+    bytes += payload
+    put16(&bytes, 2, internetChecksum(bytes))
+    return bytes
+  }
+}

package/vz/Sources/DeskNet/Plumbing.swift

@@ -0,0 +1,312 @@
+import Darwin
+import Dispatch
+
+/// The helper's end of the datagram socket pair behind the guest NIC: one
+/// datagram is one Ethernet frame.
+@MainActor
+public final class DatagramLink {
+  public var onFrame: (([UInt8]) -> Void)?
+  private let socket: FDWatcher
+
+  /// The largest frame the link carries, with headroom for a guest that
+  /// offloads segmentation.
+  static let maximumFrame = 65_550
+
+  public init(fd: Int32) {
+    Socket.setNonBlocking(fd)
+    socket = FDWatcher(fd: fd)
+    socket.onReadable = { [weak self] in self?.readable() }
+    socket.wantRead(true)
+  }
+
+  /// Make a connected pair sized for bursts. Apple recommends the receiving
+  /// buffer be at least twice the sending one. Returns (helper end, VM end).
+  public static func makePair() throws -> (Int32, Int32) {
+    var fds: [Int32] = [0, 0]
+    guard socketpair(AF_UNIX, SOCK_DGRAM, 0, &fds) == 0 else { throw POSIXFailure("socketpair") }
+    for fd in fds {
+      Socket.setInt(fd, SOL_SOCKET, SO_SNDBUF, 1 << 20)
+      Socket.setInt(fd, SOL_SOCKET, SO_RCVBUF, 4 << 20)
+    }
+    return (fds[0], fds[1])
+  }
+
+  /// Send one frame. A full buffer drops it, as a wire would; TCP recovers.
+  public func send(_ frame: [UInt8]) {
+    guard !socket.isClosed else { return }
+    _ = frame.withUnsafeBytes { Darwin.send(socket.fd, $0.baseAddress, frame.count, 0) }
+  }
+
+  private func readable() {
+    var buffer = [UInt8](repeating: 0, count: Self.maximumFrame)
+    while true {
+      let count = buffer.withUnsafeMutableBytes { Darwin.recv(socket.fd, $0.baseAddress, $0.count, 0) }
+      if count <= 0 { return }
+      onFrame?(Array(buffer[0..<count]))
+      if socket.isClosed { return }
+    }
+  }
+
+  public func close() { socket.close() }
+}
+
+/// A Unix-socket listener speaking the Cloud Hypervisor hybrid-vsock preamble.
+///
+/// A client connects and writes `CONNECT <port>\n`. The listener hands the
+/// connection and the port to `onRequest`, which either completes it — writes
+/// `OK <number>\n` and carries the stream — or closes it with nothing written,
+/// which is how a refused port presents. Anything else on the first line, or
+/// no line within the deadline, closes the connection.
+@MainActor
+public final class HandshakeListener {
+  public typealias Request = (_ client: Int32, _ port: UInt32, _ early: [UInt8]) -> Void
+
+  public let path: String
+  private let listener: FDWatcher
+  private let onRequest: Request
+  private var pending: [ObjectIdentifier: PendingHandshake] = [:]
+
+  static let lineLimit = 128
+  static let deadlineSeconds = 10
+
+  public init(path: String, onRequest: @escaping Request) throws {
+    self.path = path
+    self.onRequest = onRequest
+    var address = sockaddr_un()
+    address.sun_family = sa_family_t(AF_UNIX)
+    let capacity = MemoryLayout.size(ofValue: address.sun_path)
+    let pathBytes = Array(path.utf8)
+    guard pathBytes.count < capacity else {
+      throw POSIXFailure("socket path \(path) is longer than \(capacity - 1) bytes", ENAMETOOLONG)
+    }
+    withUnsafeMutableBytes(of: &address.sun_path) { raw in
+      raw.copyBytes(from: pathBytes)
+      raw[pathBytes.count] = 0
+    }
+    address.sun_len = UInt8(MemoryLayout<sockaddr_un>.size)
+    let fd = Darwin.socket(AF_UNIX, SOCK_STREAM, 0)
+    guard fd >= 0 else { throw POSIXFailure("socket") }
+    unlink(path)
+    let bound = withUnsafePointer(to: &address) {
+      $0.withMemoryRebound(to: sockaddr.self, capacity: 1) {
+        Darwin.bind(fd, $0, socklen_t(MemoryLayout<sockaddr_un>.size))
+      }
+    }
+    guard bound == 0 else {
+      let failure = POSIXFailure("bind \(path)")
+      Darwin.close(fd)
+      throw failure
+    }
+    // Only this user may drive the guest through the socket.
+    chmod(path, 0o600)
+    guard Darwin.listen(fd, 64) == 0 else {
+      let failure = POSIXFailure("listen \(path)")
+      Darwin.close(fd)
+      throw failure
+    }
+    Socket.setNonBlocking(fd)
+    listener = FDWatcher(fd: fd)
+    listener.onReadable = { [weak self] in self?.accept() }
+    listener.wantRead(true)
+  }
+
+  private func accept() {
+    while true {
+      let client = Darwin.accept(listener.fd, nil, nil)
+      if client < 0 { return }
+      Socket.setNonBlocking(client)
+      Socket.setNoSigPipe(client)
+      let handshake = PendingHandshake(fd: client)
+      let id = ObjectIdentifier(handshake)
+      pending[id] = handshake
+      handshake.onComplete = { [weak self] port, early in
+        guard let self else { return }
+        self.pending.removeValue(forKey: id)
+        if let port, let early {
+          // Hand over a duplicate; the watcher closes the original.
+          let owned = dup(client)
+          handshake.finish()
+          if owned >= 0 { self.onRequest(owned, port, early) }
+        } else {
+          handshake.finish()
+        }
+      }
+      handshake.start()
+    }
+  }
+
+  public func close() {
+    listener.close()
+    for handshake in pending.values { handshake.finish() }
+    pending.removeAll()
+    unlink(path)
+  }
+}
+
+@MainActor
+final class PendingHandshake {
+  var onComplete: ((UInt32?, [UInt8]?) -> Void)?
+  private let socket: FDWatcher
+  private var buffer: [UInt8] = []
+  private var timer: DispatchSourceTimer?
+
+  init(fd: Int32) {
+    socket = FDWatcher(fd: fd)
+  }
+
+  func start() {
+    socket.onReadable = { [weak self] in self?.readable() }
+    socket.wantRead(true)
+    let timer = DispatchSource.makeTimerSource(queue: .main)
+    timer.schedule(deadline: .now() + .seconds(HandshakeListener.deadlineSeconds))
+    timer.setEventHandler { @Sendable [weak self] in Task { @MainActor in self?.complete(nil, nil) } }
+    timer.resume()
+    self.timer = timer
+  }
+
+  private func readable() {
+    let bytes: [UInt8]?
+    do {
+      bytes = try Socket.readAvailable(socket.fd, limit: HandshakeListener.lineLimit)
+    } catch {
+      return complete(nil, nil)
+    }
+    guard let bytes else { return }
+    if bytes.isEmpty { return complete(nil, nil) }
+    buffer += bytes
+    guard let newline = buffer.firstIndex(of: 0x0a) else {
+      if buffer.count > HandshakeListener.lineLimit { complete(nil, nil) }
+      return
+    }
+    let line = String(decoding: buffer[0..<newline], as: UTF8.self)
+    let early = Array(buffer[(newline + 1)...])
+    complete(Self.parse(line), early)
+  }
+
+  /// `CONNECT <port>`, exactly. A trailing carriage return is tolerated.
+  nonisolated static func parse(_ line: String) -> UInt32? {
+    var text = Substring(line)
+    if text.hasSuffix("\r") { text = text.dropLast() }
+    let parts = text.split(separator: " ", omittingEmptySubsequences: false)
+    guard parts.count == 2, parts[0] == "CONNECT", !parts[1].isEmpty,
+      parts[1].allSatisfy({ $0.isASCII && $0.isNumber })
+    else { return nil }
+    return UInt32(parts[1])
+  }
+
+  private func complete(_ port: UInt32?, _ early: [UInt8]?) {
+    guard let onComplete else { return }
+    self.onComplete = nil
+    socket.wantRead(false)
+    onComplete(port, port == nil ? nil : early)
+  }
+
+  func finish() {
+    timer?.cancel()
+    timer = nil
+    onComplete = nil
+    socket.close()
+  }
+}
+
+/// Two descriptors joined into one stream, with bounded buffering and
+/// half-close carried across in both directions.
+@MainActor
+public final class Relay {
+  private let left: FDWatcher
+  private let right: FDWatcher
+  private var leftToRight: [UInt8]
+  private var rightToLeft: [UInt8] = []
+  private var leftEOF = false
+  private var rightEOF = false
+  private var leftShut = false
+  private var rightShut = false
+  private var closed = false
+  private let onClose: () -> Void
+
+  static let capacity = 256 * 1024
+
+  /// `early` is data already read from `left` that must reach `right` first.
+  public init(left: Int32, right: Int32, early: [UInt8] = [], onClose: @escaping () -> Void = {}) {
+    for fd in [left, right] {
+      Socket.setNonBlocking(fd)
+      Socket.setNoSigPipe(fd)
+    }
+    self.left = FDWatcher(fd: left)
+    self.right = FDWatcher(fd: right)
+    leftToRight = early
+    self.onClose = onClose
+    self.left.onReadable = { [weak self] in self?.read(fromLeft: true) }
+    self.right.onReadable = { [weak self] in self?.read(fromLeft: false) }
+    self.left.onWritable = { [weak self] in self?.flush(toRight: false) }
+    self.right.onWritable = { [weak self] in self?.flush(toRight: true) }
+    flush(toRight: true)
+    updateInterest()
+  }
+
+  private func read(fromLeft: Bool) {
+    let source = fromLeft ? left : right
+    let buffered = fromLeft ? leftToRight.count : rightToLeft.count
+    let room = Relay.capacity - buffered
+    guard room > 0 else { return updateInterest() }
+    let bytes: [UInt8]?
+    do {
+      bytes = try Socket.readAvailable(source.fd, limit: min(room, 64 * 1024))
+    } catch {
+      return close()
+    }
+    guard let bytes else { return }
+    if bytes.isEmpty {
+      if fromLeft { leftEOF = true } else { rightEOF = true }
+    } else if fromLeft {
+      leftToRight += bytes
+    } else {
+      rightToLeft += bytes
+    }
+    flush(toRight: fromLeft)
+    updateInterest()
+  }
+
+  private func flush(toRight: Bool) {
+    guard !closed else { return }
+    let target = toRight ? right : left
+    var buffer = toRight ? leftToRight : rightToLeft
+    while !buffer.isEmpty {
+      let written: Int
+      do {
+        written = try Socket.writeSome(target.fd, buffer)
+      } catch {
+        return close()
+      }
+      if written == 0 { break }
+      buffer.removeFirst(written)
+    }
+    if toRight { leftToRight = buffer } else { rightToLeft = buffer }
+    target.wantWrite(!buffer.isEmpty)
+    if buffer.isEmpty {
+      if toRight && leftEOF && !rightShut {
+        rightShut = true
+        _ = Darwin.shutdown(right.fd, SHUT_WR)
+      } else if !toRight && rightEOF && !leftShut {
+        leftShut = true
+        _ = Darwin.shutdown(left.fd, SHUT_WR)
+      }
+    }
+    if leftShut && rightShut { close() }
+    updateInterest()
+  }
+
+  private func updateInterest() {
+    guard !closed else { return }
+    left.wantRead(!leftEOF && leftToRight.count < Relay.capacity)
+    right.wantRead(!rightEOF && rightToLeft.count < Relay.capacity)
+  }
+
+  public func close() {
+    guard !closed else { return }
+    closed = true
+    left.close()
+    right.close()
+    onClose()
+  }
+}