Files
VCCPlusOSS/platforms/macos/App/MCPTransport.swift
T

138 lines
6.4 KiB
Swift

// SPDX-License-Identifier: GPL-3.0-or-later
import Foundation
import Darwin
/// One request per connection. Peers cannot hold the main thread or the emulator queue.
final class MCPTransport {
typealias Handler = @Sendable (Data) async -> Data
let unixPath: String
let port: UInt16
private let directory: URL
private let queue = DispatchQueue(label: "vcc.mcp.accept")
private let slots = DispatchSemaphore(value: 8)
private var listeners: [DispatchSourceRead] = []
private static func checked(_ rc: Int32) throws -> Int32 {
guard rc >= 0 else { throw POSIXError(POSIXErrorCode(rawValue: errno) ?? .EIO) }
return rc
}
init(handler: @escaping Handler) throws {
directory = URL(fileURLWithPath: "/private/tmp/vcc-mcp-" + UUID().uuidString)
unixPath = directory.appendingPathComponent("host.sock").path
try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: false,
attributes: [.posixPermissions: 0o700])
var sockets: [Int32] = []
do {
let uds = try Self.checked(socket(AF_UNIX, SOCK_STREAM, 0))
sockets.append(uds)
var un = sockaddr_un()
un.sun_family = sa_family_t(AF_UNIX)
let path = Array(unixPath.utf8CString)
guard path.count <= MemoryLayout.size(ofValue: un.sun_path) else { throw POSIXError(.ENAMETOOLONG) }
withUnsafeMutableBytes(of: &un.sun_path) { dest in
path.withUnsafeBytes { dest.copyBytes(from: $0) }
}
un.sun_len = UInt8(MemoryLayout<sockaddr_un>.size)
try Self.bindSocket(uds, &un)
let tcp = try Self.checked(socket(AF_INET, SOCK_STREAM, 0))
sockets.append(tcp)
var addr = sockaddr_in()
addr.sin_family = sa_family_t(AF_INET)
addr.sin_len = UInt8(MemoryLayout<sockaddr_in>.size)
addr.sin_addr.s_addr = inet_addr("127.0.0.1")
try Self.bindSocket(tcp, &addr)
var size = socklen_t(MemoryLayout<sockaddr_in>.size)
_ = try Self.checked(withUnsafeMutablePointer(to: &addr) {
$0.withMemoryRebound(to: sockaddr.self, capacity: 1) { getsockname(tcp, $0, &size) }
})
port = UInt16(bigEndian: addr.sin_port)
for fd in sockets {
_ = try Self.checked(fcntl(fd, F_SETFL, O_NONBLOCK))
_ = try Self.checked(fcntl(fd, F_SETFD, FD_CLOEXEC))
_ = try Self.checked(listen(fd, 8))
}
for fd in sockets {
let source = DispatchSource.makeReadSource(fileDescriptor: fd, queue: queue)
source.setEventHandler { [slots] in
let peer = accept(fd, nil, nil)
guard peer >= 0 else { return }
guard slots.wait(timeout: .now()) == .success else { close(peer); return }
// Spawn a bounded worker; synchronous socket IO never runs on Swift's executor.
DispatchQueue.global(qos: .utility).async {
func finish() { close(peer); slots.signal() }
if fd == uds {
var uid: uid_t = 0, gid: gid_t = 0
guard getpeereid(peer, &uid, &gid) == 0, uid == geteuid() else { finish(); return }
}
var yes: Int32 = 1
var timeout = timeval(tv_sec: 3, tv_usec: 0)
guard fcntl(peer, F_SETFD, FD_CLOEXEC) == 0, fcntl(peer, F_SETFL, 0) == 0,
setsockopt(peer, SOL_SOCKET, SO_NOSIGPIPE, &yes, socklen_t(MemoryLayout.size(ofValue: yes))) == 0,
setsockopt(peer, SOL_SOCKET, SO_RCVTIMEO, &timeout, socklen_t(MemoryLayout.size(ofValue: timeout))) == 0,
setsockopt(peer, SOL_SOCKET, SO_SNDTIMEO, &timeout, socklen_t(MemoryLayout.size(ofValue: timeout))) == 0,
let request = Self.readLine(peer) else { finish(); return }
Task {
let response = await handler(request)
DispatchQueue.global(qos: .utility).async {
Self.writeResponse(response, to: peer)
finish()
}
}
}
}
source.setCancelHandler { close(fd) }
listeners.append(source)
source.resume()
}
} catch {
for fd in sockets { close(fd) }
try? FileManager.default.removeItem(at: directory)
throw error
}
}
private static func bindSocket<T>(_ fd: Int32, _ addr: inout T) throws {
_ = try checked(withUnsafePointer(to: &addr) {
$0.withMemoryRebound(to: sockaddr.self, capacity: 1) { bind(fd, $0, socklen_t(MemoryLayout<T>.size)) }
})
}
private static func readLine(_ fd: Int32) -> Data? {
let deadline = DispatchTime.now() + .seconds(5)
let limit = 48 * 1024
var data = Data(), buffer = [UInt8](repeating: 0, count: 1024)
while data.count < limit && DispatchTime.now() < deadline {
let size = recv(fd, &buffer, min(limit - data.count, buffer.count), 0)
guard size > 0 else { return nil }
let bytes = buffer.prefix(size)
if let lf = bytes.firstIndex(of: 10) {
data.append(contentsOf: bytes[..<lf])
return data
}
data.append(contentsOf: bytes)
}
return nil
}
private static func writeResponse(_ data: Data, to fd: Int32) {
let deadline = DispatchTime.now() + .seconds(5)
(data + Data([10])).withUnsafeBytes { bytes in
guard let base = bytes.baseAddress else { return }
var offset = 0
while offset < bytes.count && DispatchTime.now() < deadline {
let n = send(fd, base + offset, bytes.count - offset, 0)
guard n > 0 else { return }
offset += n
}
}
}
func stop() {
for listener in listeners { listener.cancel() }
listeners.removeAll()
try? FileManager.default.removeItem(at: directory)
}
deinit { stop() }
}