diff options
| author | bptato <nincsnevem662@gmail.com> | 2025-01-08 18:44:48 +0100 |
|---|---|---|
| committer | bptato <nincsnevem662@gmail.com> | 2025-01-08 21:05:44 +0100 |
| commit | b3e57e3726b3654794057119a3c553312d40426b (patch) | |
| tree | a45790656287934f99da2c6c7be7c0f923ba640c | |
| parent | 9a6512c608dc119d74bc3c57029bf3bf60bad891 (diff) | |
| download | chawan-b3e57e3726b3654794057119a3c553312d40426b.tar.gz | |
loader: use per-process control sockets
Previously, each message (load, resume, passFd, etc.) would open a new
connection to loader's UNIX socket, and assumed the loader was dead
when the loader did not respond (ECONNREFUSED).
As it turns out, this model was hopelessly broken: POSIX does not
specify when a UNIX socket can refuse connections, so while it happened
to work on Linux (which just blocks if it can't accept right now),
FreeBSD would randomly refuse connections whenever its listen queue was
full.
Instead, we now take a socketpair() from the loader in addClient, and
pass on one half to the client (the other half stays in loader); this is
the control stream, and all messages from the specific client are sent
through it. If a message includes a new stream (e.g. lcLoad), then it
sends a new socketpair through the control stream.
Aside from not being completely broken (and being marginally more
efficient), this arrangement has several other benefits: it removes the
need for authentication, almost removes the need for sockdir (now only
buffers use it), and will make it easier to add async message processing
in the future.
| -rw-r--r-- | doc/architecture.md | 10 | ||||
| -rw-r--r-- | src/io/bufreader.nim | 3 | ||||
| -rw-r--r-- | src/io/bufwriter.nim | 5 | ||||
| -rw-r--r-- | src/io/dynstream.nim | 13 | ||||
| -rw-r--r-- | src/local/client.nim | 9 | ||||
| -rw-r--r-- | src/local/container.nim | 2 | ||||
| -rw-r--r-- | src/local/pager.nim | 35 | ||||
| -rw-r--r-- | src/main.nim | 9 | ||||
| -rw-r--r-- | src/server/buffer.nim | 22 | ||||
| -rw-r--r-- | src/server/forkserver.nim | 107 | ||||
| -rw-r--r-- | src/server/loader.nim | 387 | ||||
| -rw-r--r-- | src/server/loaderiface.nim | 225 |
12 files changed, 415 insertions, 412 deletions
diff --git a/doc/architecture.md b/doc/architecture.md index 9153a290..e368addb 100644 --- a/doc/architecture.md +++ b/doc/architecture.md @@ -112,11 +112,11 @@ following steps: obviously, it's more efficient this way.) The loader process distinguishes between clients (i.e processes) through -client keys (session cookies). In theory this should help against rogue -clients, though in practice it is still trivial to crash the loader as -a client. It also helps us block further requests from buffers that have -been discarded by the pager, but still haven't found out yet that their -life time has ended. +their control stream (one end of a socketpair created by loader). In +theory this should help against rogue clients, though in practice it is +still trivial to crash the loader as a client. It also helps us block +further requests from buffers that have been discarded by the pager, but +still haven't found out yet that their life time has ended. ### Buffer diff --git a/src/io/bufreader.nim b/src/io/bufreader.nim index 5267d198..50341bbc 100644 --- a/src/io/bufreader.nim +++ b/src/io/bufreader.nim @@ -47,6 +47,9 @@ template withPacketReader*(stream: DynStream; r, body: untyped) = var r = stream.initPacketReader() body +proc empty*(reader: var BufferedReader): bool = + return reader.bufIdx == reader.buffer.len + proc readData*(reader: var BufferedReader; buffer: pointer; len: int) = assert reader.bufIdx + len <= reader.buffer.len copyMem(buffer, addr reader.buffer[reader.bufIdx], len) diff --git a/src/io/bufwriter.nim b/src/io/bufwriter.nim index 9c3d6c79..aa2d6dbd 100644 --- a/src/io/bufwriter.nim +++ b/src/io/bufwriter.nim @@ -65,9 +65,10 @@ proc deinit*(writer: var BufferedWriter) = writer.sendAux.setLen(0) template withPacketWriter*(stream: DynStream; w, body: untyped) = - block: - var w = stream.initWriter() + var w = stream.initWriter() + try: body + finally: w.flush() w.deinit() diff --git a/src/io/dynstream.nim b/src/io/dynstream.nim index 9c7f0013..668bbc32 100644 --- a/src/io/dynstream.nim +++ b/src/io/dynstream.nim @@ -398,9 +398,12 @@ proc getSocketName*(pid: int): string = proc getSocketPath*(socketDir: string; pid: int): string = socketDir / getSocketName(pid) +proc newSocketStream*(fd: cint): SocketStream = + return SocketStream(fd: fd, blocking: true) + proc connectSocketStream*(socketDir: string; baseFd, pid: int): SocketStream = let fd = cint(socket(AF_UNIX, SOCK_STREAM, IPPROTO_IP)) - let ss = SocketStream(fd: fd, blocking: true) + let ss = newSocketStream(fd) ss.setCloseOnExec() let path = getSocketPath(socketDir, pid) if baseFd == -1: @@ -548,14 +551,8 @@ proc newServerSocket*(sockDir: string; sockDirFd: cint; pid: int): ServerSocket raiseOSError(osLastError()) return ssock -proc close*(ssock: ServerSocket; unlink = true) = +proc close*(ssock: ServerSocket) = discard close(ssock.fd) - if unlink: - when defined(freebsd): - if ssock.dfd != -1: - discard unlinkat(ssock.dfd, cstring(ssock.path), 0) - return - discard tryRemoveFile(ssock.path) proc acceptSocketStream*(ssock: ServerSocket): SocketStream = let fd = cint(accept(SocketHandle(ssock.fd), nil, nil)) diff --git a/src/local/client.nim b/src/local/client.nim index 9d21a9f3..7f30e587 100644 --- a/src/local/client.nim +++ b/src/local/client.nim @@ -159,10 +159,13 @@ func getClient(client: Client): Client {.jsfget: "client".} = return client proc newClient*(config: Config; forkserver: ForkServer; loaderPid: int; - jsctx: JSContext; warnings: seq[string]; urandom: PosixStream): Client = + jsctx: JSContext; warnings: seq[string]; urandom: PosixStream; + loaderStream: SocketStream): Client = let jsrt = JS_GetRuntime(jsctx) - let loader = FileLoader(process: loaderPid, clientPid: getCurrentProcessId()) - loader.setSocketDir(config.external.sockdir) + let clientPid = getCurrentProcessId() + let sockDirFd = openSockDir(config.external.sockdir) + let loader = newFileLoader(loaderPid, clientPid, config.external.sockdir, + sockDirFd, loaderStream) let client = Client( jsrt: jsrt, jsctx: jsctx, diff --git a/src/local/container.nim b/src/local/container.nim index 62f2c564..dba32473 100644 --- a/src/local/container.nim +++ b/src/local/container.nim @@ -245,7 +245,7 @@ proc clone*(container: Container; newurl: URL; loader: FileLoader): let ssock = newServerSocket(loader.sockDir, loader.sockDirFd, loader.clientPid) SocketStream(container.iface.stream.source).sendFd(ssock.fd) - ssock.close(unlink = false) + ssock.close() return p.then(proc(pid: int): Container = if pid == -1: return nil diff --git a/src/local/pager.nim b/src/local/pager.nim index 0afc559c..9c912f3e 100644 --- a/src/local/pager.nim +++ b/src/local/pager.nim @@ -200,8 +200,6 @@ jsDestructor(Pager) # Forward declarations proc acceptBuffers(pager: Pager) proc addConsole(pager: Pager; interactive: bool): ConsoleWrapper -proc addLoaderClient(pager: Pager; pid: int; config: LoaderClientConfig; - clonedFrom = -1): ClientKey proc alert*(pager: Pager; msg: string) proc askMailcap(pager: Pager; container: Container; ostream: PosixStream; contentType: string; i: int; response: Response; sx: int) @@ -233,7 +231,7 @@ template attrs(pager: Pager): WindowAttributes = pager.term.attrs func loaderPid(pager: Pager): int {.jsfget.} = - return pager.loader.process + return pager.loader.loaderPid func getRoot(container: Container): Container = var c = container @@ -483,11 +481,13 @@ proc newPager*(config: Config; forkserver: ForkServer; ctx: JSContext; JS_SetModuleLoaderFunc(pager.jsrt, normalizeModuleName, clientLoadJSModule, nil) JS_SetInterruptHandler(pager.jsrt, interruptHandler, cast[pointer](pager)) - loader.key = pager.addLoaderClient(pager.loader.clientPid, LoaderClientConfig( + let clientConfig = LoaderClientConfig( defaultHeaders: newHeaders(pager.config.network.default_headers), proxy: pager.config.network.proxy, filter: newURLFilter(default = true), - )) + ) + discard pager.loader.addClient(pager.loader.clientPid, + clientConfig, -1, isPager = true) block history: let hist = newHistory(pager.config.external.history_size, getTime().toUnix()) let ps = newPosixStream(pager.config.external.history_file) @@ -821,18 +821,6 @@ proc input(pager: Pager): EmptyPromise = p = newResolvedPromise() return p -proc genClientKey(pager: Pager): ClientKey = - var key {.noinit.}: ClientKey - pager.urandom.recvDataLoop(key) - return key - -proc addLoaderClient(pager: Pager; pid: int; config: LoaderClientConfig; - clonedFrom = -1): ClientKey = - var key = pager.genClientKey() - while unlikely(not pager.loader.addClient(key, pid, config, clonedFrom)): - key = pager.genClientKey() - return key - proc run*(pager: Pager; pages: openArray[string]; contentType: Option[string]; cs: Charset; dump, history: bool) = var istream: PosixStream = nil @@ -3095,17 +3083,19 @@ proc acceptBuffers(pager: Pager) = pager.pollData.register(fd, POLLIN or POLLOUT) for item in pager.procmap: let container = item.container + # unlink here; on Linux we can't unlink from the buffer :/ + #TODO replace this with a socketpair + # (also, it seems better to just do this from connect2...) let stream = connectSocketStream(pager.config.external.sockdir, pager.loader.sockDirFd, container.process) - # unlink here; on Linux we can't unlink from the buffer :/ discard tryRemoveFile(getSocketPath(pager.config.external.sockdir, container.process)) if stream == nil: pager.alert("Error: failed to set up buffer") continue let loader = pager.loader - let key = pager.addLoaderClient(container.process, container.loaderConfig, - container.clonedFrom) + let cstream = pager.loader.addClient(container.process, + container.loaderConfig, container.clonedFrom) if item.istreamOutputId != -1: # new buffer if container.cacheId == -1: container.cacheId = loader.addCacheFile(item.istreamOutputId, @@ -3124,8 +3114,8 @@ proc acceptBuffers(pager: Pager) = outCacheId = loader.addCacheFile(item.ostreamOutputId, pid) loader.resume([item.istreamOutputId, item.ostreamOutputId]) stream.withPacketWriter w: - w.swrite(key) w.swrite(outCacheId) + w.sendAux.add(cstream.fd) # pass down ostream # must come after the previous block so the first packet is flushed stream.sendFd(item.ostream.fd) @@ -3133,13 +3123,14 @@ proc acceptBuffers(pager: Pager) = container.setStream(stream, registerFun) else: # cloned buffer stream.withPacketWriter w: - w.swrite(key) + w.sendAux.add(cstream.fd) # buffer is cloned, just share the parent's cached source loader.shareCachedItem(container.cacheId, container.process) # also add a reference here; it will be removed when the container is # deleted loader.shareCachedItem(container.cacheId, loader.clientPid) container.setCloneStream(stream, registerFun) + cstream.sclose() let fd = int(stream.fd) pager.loader.put(ContainerData(stream: stream, container: container)) pager.pollData.register(fd, POLLIN) diff --git a/src/main.nim b/src/main.nim index 1275f457..6fab185b 100644 --- a/src/main.nim +++ b/src/main.nim @@ -239,7 +239,12 @@ const libexecPath {.strdefine.} = "$CHA_BIN_DIR/../libexec/chawan" proc main() = putEnv("CHA_BIN_DIR", getAppFilename().untilLast('/')) putEnv("CHA_LIBEXEC_DIR", ChaPath(libexecPath).unquoteGet()) - let forkserver = newForkServer() + var sy {.noinit.}: array[2, cint] + if socketpair(AF_UNIX, SOCK_STREAM, IPPROTO_IP, sy) != 0: + stderr.writeLine("Failed to set up initial socket pair") + quit(1) + let forkserver = newForkServer(sy) + discard close(sy[1]) let urandom = newPosixStream("/dev/urandom", O_RDONLY, 0) urandom.setCloseOnExec() var ctx = ParamParseContext(params: commandLineParams(), i: 0) @@ -272,7 +277,7 @@ proc main() = let loaderPid = forkserver.loadConfig(config) setControlCHook(proc() {.noconv.} = quit(1)) let client = newClient(config, forkserver, loaderPid, jsctx, warnings, - urandom) + urandom, newSocketStream(sy[0])) try: client.pager.run(ctx.pages, ctx.contentType, ctx.charset, ctx.dump, history) except CatchableError: diff --git a/src/server/buffer.nim b/src/server/buffer.nim index a58be9f6..a7f9430e 100644 --- a/src/server/buffer.nim +++ b/src/server/buffer.nim @@ -1014,7 +1014,7 @@ proc clone*(buffer: Buffer; newurl: URL): int {.proxy.} = # We ignore errors; not much we can do with them here :/ discard buffer.rewind(buffer.bytesRead, unregister = false) buffer.pstream.sclose() - buffer.ssock.close(unlink = false) + buffer.ssock.close() let ssock = newServerSocket(sockFd, buffer.loader.sockDir, buffer.loader.sockDirFd, myPid) buffer.ssock = ssock @@ -1027,8 +1027,9 @@ proc clone*(buffer: Buffer; newurl: URL): int {.proxy.} = gpstream = buffer.pstream buffer.loader.clientPid = myPid # get key for new buffer - var r = buffer.pstream.initPacketReader() - r.sread(buffer.loader.key) + buffer.loader.controlStream.sclose() + buffer.pstream.withPacketReader r: + buffer.loader.controlStream = newSocketStream(r.recvAux.pop()) buffer.rfd = buffer.pstream.fd buffer.pollData.register(buffer.rfd, POLLIN) # must reconnect after the new client is set up, or the client pids get @@ -1942,14 +1943,18 @@ proc runBuffer(buffer: Buffer) = buffer.maybeReshape() proc cleanup(buffer: Buffer) = - buffer.pstream.sclose() + if gpstream != nil: + gpstream.sclose() + gpstream = nil + if gssock != nil: + gssock.close() + gssock = nil buffer.window.urandom.sclose() - # no unlink access on Linux, so just hope that the pager could clean it up - buffer.ssock.close(unlink = false) proc launchBuffer*(config: BufferConfig; url: URL; attrs: WindowAttributes; ishtml: bool; charsetStack: seq[Charset]; loader: FileLoader; - ssock: ServerSocket; pstream: SocketStream; urandom: PosixStream) = + ssock: ServerSocket; pstream: SocketStream; urandom: PosixStream; + cacheId: int) = let factory = newCAtomFactory() let confidence = if config.charsetOverride == CHARSET_UNKNOWN: ccTentative @@ -1990,9 +1995,6 @@ proc launchBuffer*(config: BufferConfig; url: URL; attrs: WindowAttributes; if buffer.config.scripting == smApp: buffer.window.maybeRestyle = proc() = buffer.maybeRestyle() buffer.charset = buffer.charsetStack.pop() - var r = pstream.initPacketReader() - r.sread(buffer.loader.key) - r.sread(buffer.cacheId) let fd = pstream.recvFd() buffer.fd = int(fd) buffer.istream = newPosixStream(fd) diff --git a/src/server/forkserver.nim b/src/server/forkserver.nim index a7d2d994..72584096 100644 --- a/src/server/forkserver.nim +++ b/src/server/forkserver.nim @@ -34,6 +34,7 @@ type loaderPid: int sockDirFd: cint sockDir: string + loaderStream: SocketStream proc loadConfig*(forkserver: ForkServer; config: Config): int = forkserver.ostream.withPacketWriter w: @@ -81,22 +82,19 @@ proc trapSIGINT() = setControlCHook(proc() {.noconv.} = discard) proc forkLoader(ctx: var ForkServerContext; config: LoaderConfig): int = - var pipefd {.noinit.}: array[2, cint] - if pipe(pipefd) == -1: - raise newException(Defect, "Failed to open pipe.") stdout.flushFile() stderr.flushFile() let pid = fork() if pid == 0: # child process trapSIGINT() + let loaderStream = ctx.loaderStream for i in 0 ..< ctx.children.len: ctx.children[i] = 0 ctx.children.setLen(0) zeroMem(addr ctx, sizeof(ctx)) - discard close(pipefd[0]) # close read try: setProcessTitle("cha loader") - runFileLoader(pipefd[1], config) + runFileLoader(config, loaderStream) except CatchableError: let e = getCurrentException() # taken from system/excpt.nim @@ -105,11 +103,8 @@ proc forkLoader(ctx: var ForkServerContext; config: LoaderConfig): int = stderr.write(msg) quit(1) doAssert false - let ps = newPosixStream(pipefd[0]) # get read - discard close(pipefd[1]) # close write - let c = ps.sreadChar() - assert c == '\0' - ps.sclose() + ctx.loaderStream.sclose() + ctx.loaderStream = nil return pid proc forkBuffer(ctx: var ForkServerContext; r: var BufferedReader): int = @@ -141,8 +136,6 @@ proc forkBuffer(ctx: var ForkServerContext; r: var BufferedReader): int = let sockDirFd = ctx.sockDirFd zeroMem(addr ctx, sizeof(ctx)) discard close(pipefd[0]) # close read - closeStdin() - closeStdout() setBufferProcessTitle(url) let pid = getCurrentProcessId() let ssock = newServerSocket(sockDir, sockDirFd, pid) @@ -151,24 +144,29 @@ proc forkBuffer(ctx: var ForkServerContext; r: var BufferedReader): int = ps.sclose() let urandom = newPosixStream("/dev/urandom", O_RDONLY, 0) let pstream = ssock.acceptSocketStream() + var cacheId: int + var loaderStream: SocketStream + pstream.withPacketReader r: + r.sread(cacheId) + loaderStream = newSocketStream(r.recvAux.pop()) + let loader = newFileLoader(loaderPid, pid, sockDir, sockDirFd, + loaderStream) gssock = ssock gpstream = pstream onSignal SIGTERM: discard sig - gpstream.sclose() - gssock.close(unlink = false) + if gpstream != nil: + gpstream.sclose() + gpstream = nil + if gssock != nil: + gssock.close() + gssock = nil exitnow(1) signal(SIGPIPE, SIG_DFL) enterBufferSandbox(sockDir) - let loader = FileLoader( - process: loaderPid, - clientPid: pid, - sockDir: sockDir, - sockDirFd: sockDirFd - ) try: launchBuffer(config, url, attrs, ishtml, charsetStack, loader, - ssock, pstream, urandom) + ssock, pstream, urandom, cacheId) except CatchableError: let e = getCurrentException() # taken from system/excpt.nim @@ -185,12 +183,13 @@ proc forkBuffer(ctx: var ForkServerContext; r: var BufferedReader): int = ctx.children.add(pid) return pid -proc runForkServer() = +proc runForkServer(ifd, ofd: cint; loaderStream: SocketStream) = setProcessTitle("cha forkserver") var ctx = ForkServerContext( - istream: newPosixStream(stdin.getFileHandle()), - ostream: newPosixStream(stdout.getFileHandle()), - sockDirFd: -1 + istream: newPosixStream(ifd), + ostream: newPosixStream(ofd), + sockDirFd: -1, + loaderStream: loaderStream ) signal(SIGCHLD, SIG_IGN) signal(SIGPIPE, SIG_IGN) @@ -206,8 +205,7 @@ proc runForkServer() = r.sread(isCJKAmbiguous) r.sread(config) ctx.sockDir = config.sockdir - when defined(freebsd): - ctx.sockDirFd = open(cstring(ctx.sockDir), O_DIRECTORY) + ctx.sockDirFd = openSockDir(ctx.sockDir) let pid = ctx.forkLoader(config) ctx.ostream.withPacketWriter w: w.swrite(pid) @@ -229,19 +227,20 @@ proc runForkServer() = ctx.istream.sclose() ctx.ostream.sclose() # Clean up when the main process crashed. + #TODO this seems like a bad idea; children may be out of sync here... for child in ctx.children: discard kill(cint(child), cint(SIGTERM)) quit(0) -proc newForkServer*(): ForkServer = - var pipefd_in: array[2, cint] # stdin in forkserver - var pipefd_out: array[2, cint] # stdout in forkserver - var pipefd_err: array[2, cint] # stderr in forkserver - if pipe(pipefd_in) == -1: +proc newForkServer*(sy: array[2, cint]): ForkServer = + var pipeFdIn {.noinit.}: array[2, cint] # stdin in forkserver + var pipeFdOut {.noinit.}: array[2, cint] # stdout in forkserver + var pipeFdErr {.noinit.}: array[2, cint] # stderr in forkserver + if pipe(pipeFdIn) == -1: raise newException(Defect, "Failed to open input pipe.") - if pipe(pipefd_out) == -1: + if pipe(pipeFdOut) == -1: raise newException(Defect, "Failed to open output pipe.") - if pipe(pipefd_err) == -1: + if pipe(pipeFdErr) == -1: raise newException(Defect, "Failed to open error pipe.") stdout.flushFile() stderr.flushFile() @@ -251,32 +250,24 @@ proc newForkServer*(): ForkServer = elif pid == 0: # child process trapSIGINT() - discard close(pipefd_in[1]) # close write - discard close(pipefd_out[0]) # close read - discard close(pipefd_err[0]) # close read - let readfd = pipefd_in[0] - let writefd = pipefd_out[1] - let errfd = pipefd_err[1] - discard dup2(readfd, stdin.getFileHandle()) - discard dup2(writefd, stdout.getFileHandle()) - discard dup2(errfd, stderr.getFileHandle()) - discard close(pipefd_in[0]) - discard close(pipefd_out[1]) - discard close(pipefd_err[1]) - runForkServer() + closeStdin() + closeStdout() + discard dup2(pipeFdErr[1], stderr.getFileHandle()) + discard close(pipeFdErr[1]) + discard close(pipeFdIn[1]) # close write + discard close(pipeFdOut[0]) # close read + discard close(pipeFdErr[0]) # close read + discard close(sy[0]) + runForkServer(pipeFdIn[0], pipeFdOut[1], newSocketStream(sy[1])) doAssert false else: - discard close(pipefd_in[0]) # close read - discard close(pipefd_out[1]) # close write - discard close(pipefd_err[1]) # close write - let ostream = newPosixStream(pipefd_in[1]) - let istream = newPosixStream(pipefd_out[0]) - let estream = newPosixStream(pipefd_err[0]) + discard close(pipeFdIn[0]) # close read + discard close(pipeFdOut[1]) # close write + discard close(pipeFdErr[1]) # close write + let ostream = newPosixStream(pipeFdIn[1]) + let istream = newPosixStream(pipeFdOut[0]) + let estream = newPosixStream(pipeFdErr[0]) estream.setBlocking(false) for it in [ostream, istream, estream]: it.setCloseOnExec() - return ForkServer( - ostream: ostream, - istream: istream, - estream: estream - ) + return ForkServer(ostream: ostream, istream: istream, estream: estream) diff --git a/src/server/loader.nim b/src/server/loader.nim index cfdb6111..f809905d 100644 --- a/src/server/loader.nim +++ b/src/server/loader.nim @@ -19,6 +19,9 @@ # passed, it will *not* be cleaned up until a `resume' command is # received. (This allows for passing outputIds to the pager for later # addCacheFile commands there.) +# +# Note 2: We also have a separate control socket that can receive +# various messages, of which "load" is just one. import std/deques import std/options @@ -99,6 +102,49 @@ type rsBeforeResult, rsAfterFailure, rsBeforeStatus, rsBeforeHeaders, rsAfterHeaders + AuthItem = ref object + origin: Origin + username: string + password: string + + ClientHandle = ref object of LoaderHandle + pid: int + # List of cached resources. + cacheMap: seq[CachedItem] + # List of file descriptors passed by the client. + passedFdMap: seq[tuple[name: string; fd: cint]] # host -> fd + config: LoaderClientConfig + # List of credentials the client has access to (same origin only). + authMap: seq[AuthItem] + + LoaderContext = ref object + pagerClient: ClientHandle + alive: bool + config: LoaderConfig + handleMap: seq[LoaderHandle] + pollData: PollData + # List of existing clients (buffer or pager) that may make requests. + clientMap: Table[int, ClientHandle] # pid -> data + # ID of next output. TODO: find a better allocation scheme + outputNum: int + # List of *all* credentials the loader knows of. + authMap: seq[AuthItem] + # Handles to unregister and close at the end of this iteration. + # This is needed so that we don't accidentally replace them with new + # streams in the same iteration as they got closed. + unregRead: seq[InputHandle] + unregWrite: seq[OutputHandle] + unregClient: seq[ClientHandle] + + LoaderConfig* = object + cgiDir*: seq[string] + uriMethodMap*: URIMethodMap + w3mCGICompat*: bool + tmpdir*: string + sockdir*: string + configdir*: string + bookmark*: string + proc `=destroy`(buffer: var LoaderBufferObj) = if buffer.page != nil: dealloc(buffer.page) @@ -243,47 +289,16 @@ proc close(handle: InputHandle) = if output.stream != nil: output.oclose() -type - AuthItem = ref object - origin: Origin - username: string - password: string - - ClientData = ref object - pid: int - key: ClientKey - # List of cached resources. - cacheMap: seq[CachedItem] - # List of file descriptors passed by the client. - passedFdMap: seq[tuple[name: string; fd: cint]] # host -> fd - config: LoaderClientConfig - # List of credentials the client has access to (same origin only). - authMap: seq[AuthItem] - - LoaderContext = ref object - pagerClient: ClientData - ssock: ServerSocket - alive: bool - config: LoaderConfig - handleMap: seq[LoaderHandle] - pollData: PollData - # List of existing clients (buffer or pager) that may make requests. - clientData: Table[int, ClientData] # pid -> data - # ID of next output. TODO: find a better allocation scheme - outputNum: int - # List of *all* credentials the loader knows of. - authMap: seq[AuthItem] - - LoaderConfig* = object - cgiDir*: seq[string] - uriMethodMap*: URIMethodMap - w3mCGICompat*: bool - tmpdir*: string - sockdir*: string - configdir*: string - bookmark*: string +proc close(client: ClientHandle) = + assert not client.registered + client.stream.sclose() + client.stream = nil + for it in client.cacheMap: + dec it.refc + if it.refc == 0: + discard unlink(cstring(it.path)) -func isPrivileged(ctx: LoaderContext; client: ClientData): bool = +func isPrivileged(ctx: LoaderContext; client: ClientHandle): bool = return ctx.pagerClient == client #TODO this may be too low if we want to use urimethodmap for everything @@ -311,7 +326,7 @@ iterator outputHandles(ctx: LoaderContext): OutputHandle {.inline.} = if it != nil and it of OutputHandle: yield OutputHandle(it) -func findOutput(ctx: LoaderContext; id: int; client: ClientData): OutputHandle = +func findOutput(ctx: LoaderContext; id: int; client: ClientHandle): OutputHandle = assert id != -1 for it in ctx.outputHandles: if it.outputId == id: @@ -356,6 +371,18 @@ proc unregister(ctx: LoaderContext; output: OutputHandle) = ctx.pollData.unregister(int(output.stream.fd)) output.registered = false +proc register(ctx: LoaderContext; client: ClientHandle) = + assert not client.registered + ctx.clientMap[client.pid] = client + ctx.pollData.register(client.stream.fd, cshort(POLLIN)) + client.registered = true + +proc unregister(ctx: LoaderContext; client: ClientHandle) = + assert client.registered + ctx.clientMap.del(client.pid) + ctx.pollData.unregister(int(client.stream.fd)) + client.registered = false + # Either write data to the target output, or append it to the list of buffers to # write and register the output in our selector. proc pushBuffer(ctx: LoaderContext; output: OutputHandle; buffer: LoaderBuffer; @@ -427,7 +454,7 @@ proc redirectToFile(ctx: LoaderContext; output: OutputHandle; output.parent.outputs[^1].url = output.parent.url return true -proc addCacheFile(ctx: LoaderContext; client: ClientData; output: OutputHandle): +proc addCacheFile(ctx: LoaderContext; client: ClientHandle; output: OutputHandle): int = if output.parent != nil and output.parent.cacheId != -1: # may happen e.g. if client tries to cache a `cache:' URL @@ -441,7 +468,7 @@ proc addCacheFile(ctx: LoaderContext; client: ClientData; output: OutputHandle): return cacheId return -1 -proc openCachedItem(client: ClientData; id: int): (PosixStream, int) = +proc openCachedItem(client: ClientHandle; id: int): (PosixStream, int) = let n = client.cacheMap.find(id) if n != -1: let item = client.cacheMap[n] @@ -710,7 +737,7 @@ proc findItem(authMap: seq[AuthItem]; origin: Origin): AuthItem = return it return nil -proc findAuth(client: ClientData; url: URL): AuthItem = +proc findAuth(client: ClientHandle; url: URL): AuthItem = if client.authMap.len > 0: return client.authMap.findItem(url.authOrigin) return nil @@ -802,7 +829,7 @@ proc parseCGIPath(ctx: LoaderContext; request: Request): CGIPath = break return cpath -proc loadCGI(ctx: LoaderContext; client: ClientData; handle: InputHandle; +proc loadCGI(ctx: LoaderContext; client: ClientHandle; handle: InputHandle; request: Request; prevURL: URL; config: LoaderClientConfig) = let cpath = ctx.parseCGIPath(request) if cpath.cmd == "" or cpath.basename in ["", ".", ".."] or @@ -944,13 +971,13 @@ proc loadCGI(ctx: LoaderContext; client: ClientData; handle: InputHandle; of rbtNone: discard -func findPassedFd(client: ClientData; name: string): int = +func findPassedFd(client: ClientHandle; name: string): int = for i in 0 ..< client.passedFdMap.len: if client.passedFdMap[i].name == name: return i return -1 -proc loadStream(ctx: LoaderContext; client: ClientData; handle: InputHandle; +proc loadStream(ctx: LoaderContext; client: ClientHandle; handle: InputHandle; request: Request) = let i = client.findPassedFd(request.url.pathname) if i == -1: @@ -972,7 +999,7 @@ proc loadStream(ctx: LoaderContext; client: ClientData; handle: InputHandle; # not loading from cache, so cachedHandle is nil ctx.loadStreamRegular(handle, nil) -proc loadFromCache(ctx: LoaderContext; client: ClientData; handle: InputHandle; +proc loadFromCache(ctx: LoaderContext; client: ClientHandle; handle: InputHandle; request: Request) = let id = parseInt32(request.url.pathname).get(-1) let startFrom = parseInt32(request.url.search.substr(1)).get(0) @@ -1044,7 +1071,7 @@ proc loadData(ctx: LoaderContext; handle: InputHandle; request: Request) = else: ctx.loadDataSend(handle, body, ct) -proc loadResource(ctx: LoaderContext; client: ClientData; +proc loadResource(ctx: LoaderContext; client: ClientHandle; config: LoaderClientConfig; request: Request; handle: InputHandle) = var redo = true var tries = 0 @@ -1106,28 +1133,40 @@ proc setupRequestDefaults(request: Request; config: LoaderClientConfig) = request.headers["Referer"] = r proc load(ctx: LoaderContext; stream: SocketStream; request: Request; - client: ClientData; config: LoaderClientConfig) = - let handle = newInputHandle(stream, ctx.getOutputId(), client.pid) - when defined(debug): - handle.url = request.url - handle.output.url = request.url - if not config.filter.match(request.url): - handle.rejectHandle(ceDisallowedURL) - else: - request.setupRequestDefaults(config) - ctx.loadResource(client, config, request, handle) + client: ClientHandle; config: LoaderClientConfig) = + var sy {.noinit.}: array[2, cint] + var fail = false + stream.withPacketWriter w: + if socketpair(AF_UNIX, SOCK_STREAM, IPPROTO_IP, sy) == 0: + w.swrite(true) + w.sendAux.add(sy[1]) + else: + fail = true + w.swrite(false) + if not fail: + discard close(sy[1]) + let stream = newSocketStream(sy[0]) + let handle = newInputHandle(stream, ctx.getOutputId(), client.pid) + when defined(debug): + handle.url = request.url + handle.output.url = request.url + if not config.filter.match(request.url): + handle.rejectHandle(ceDisallowedURL) + else: + request.setupRequestDefaults(config) + ctx.loadResource(client, config, request, handle) -proc load(ctx: LoaderContext; stream: SocketStream; client: ClientData; +proc load(ctx: LoaderContext; stream: SocketStream; client: ClientHandle; r: var BufferedReader) = var request: Request r.sread(request) ctx.load(stream, request, client, client.config) -proc loadConfig(ctx: LoaderContext; stream: SocketStream; client: ClientData; +proc loadConfig(ctx: LoaderContext; stream: SocketStream; client: ClientHandle; r: var BufferedReader) = var request: Request - r.sread(request) var config: LoaderClientConfig + r.sread(request) r.sread(config) ctx.load(stream, request, client, config) @@ -1137,7 +1176,7 @@ proc getCacheFile(ctx: LoaderContext; stream: SocketStream; var sourcePid: int r.sread(cacheId) r.sread(sourcePid) - let client = ctx.clientData.getOrDefault(sourcePid, nil) + let client = ctx.clientMap.getOrDefault(sourcePid, nil) let n = if client != nil: client.cacheMap.find(cacheId) else: -1 stream.withPacketWriter w: if n != -1: @@ -1147,22 +1186,22 @@ proc getCacheFile(ctx: LoaderContext; stream: SocketStream; proc addClient(ctx: LoaderContext; stream: SocketStream; r: var BufferedReader) = - var key: ClientKey var pid: int var config: LoaderClientConfig var clonedFrom: int - r.sread(key) r.sread(pid) r.sread(config) r.sread(clonedFrom) + assert pid notin ctx.clientMap + var sy {.noinit.}: array[2, cint] stream.withPacketWriter w: - if pid in ctx.clientData or key == ClientKey.default: - w.swrite(false) - else: - let client = ClientData(pid: pid, key: key, config: config) - ctx.clientData[pid] = client + if socketpair(AF_UNIX, SOCK_STREAM, IPPROTO_IP, sy) == 0: + let stream = newSocketStream(sy[0]) + let client = ClientHandle(stream: stream, pid: pid, config: config) + ctx.register(client) + ctx.put(client) if clonedFrom != -1: - let client2 = ctx.clientData[clonedFrom] + let client2 = ctx.clientMap[clonedFrom] for item in client2.cacheMap: inc item.refc client.cacheMap = client2.cacheMap @@ -1172,25 +1211,20 @@ proc addClient(ctx: LoaderContext; stream: SocketStream; if it.origin.isSameOrigin(origin): client.authMap.add(it) w.swrite(true) - stream.sclose() - -proc cleanup(client: ClientData) = - for it in client.cacheMap: - dec it.refc - if it.refc == 0: - discard unlink(cstring(it.path)) + w.sendAux.add(sy[1]) + else: + w.swrite(false) + discard close(sy[1]) proc removeClient(ctx: LoaderContext; stream: SocketStream; r: var BufferedReader) = var pid: int r.sread(pid) - if pid in ctx.clientData: - let client = ctx.clientData[pid] - client.cleanup() - ctx.clientData.del(pid) - stream.sclose() + if pid in ctx.clientMap: + let client = ctx.clientMap[pid] + ctx.unregClient.add(client) -proc addCacheFile(ctx: LoaderContext; stream: SocketStream; client: ClientData; +proc addCacheFile(ctx: LoaderContext; stream: SocketStream; client: ClientHandle; r: var BufferedReader) = var outputId: int var targetPid: int @@ -1200,11 +1234,10 @@ proc addCacheFile(ctx: LoaderContext; stream: SocketStream; client: ClientData; doAssert ctx.isPrivileged(client) or client.pid == targetPid let output = ctx.findOutput(outputId, client) assert output != nil - let targetClient = ctx.clientData[targetPid] + let targetClient = ctx.clientMap[targetPid] let id = ctx.addCacheFile(targetClient, output) stream.withPacketWriter w: w.swrite(id) - stream.sclose() proc redirectToFile(ctx: LoaderContext; stream: SocketStream; r: var BufferedReader) = @@ -1218,7 +1251,6 @@ proc redirectToFile(ctx: LoaderContext; stream: SocketStream; success = ctx.redirectToFile(output, targetPath) stream.withPacketWriter w: w.swrite(success) - stream.sclose() proc shareCachedItem(ctx: LoaderContext; stream: SocketStream; r: var BufferedReader) = @@ -1230,16 +1262,15 @@ proc shareCachedItem(ctx: LoaderContext; stream: SocketStream; r.sread(sourcePid) r.sread(targetPid) r.sread(id) - let sourceClient = ctx.clientData[sourcePid] - let targetClient = ctx.clientData[targetPid] + let sourceClient = ctx.clientMap[sourcePid] + let targetClient = ctx.clientMap[targetPid] let n = sourceClient.cacheMap.find(id) let item = sourceClient.cacheMap[n] inc item.refc targetClient.cacheMap.add(item) - stream.sclose() proc openCachedItem(ctx: LoaderContext; stream: SocketStream; - client: ClientData; r: var BufferedReader) = + client: ClientHandle; r: var BufferedReader) = # open a cached item var id: int r.sread(id) @@ -1250,18 +1281,16 @@ proc openCachedItem(ctx: LoaderContext; stream: SocketStream; w.sendAux.add(ps.fd) if ps != nil: ps.sclose() - stream.sclose() -proc passFd(ctx: LoaderContext; stream: SocketStream; client: ClientData; +proc passFd(ctx: LoaderContext; stream: SocketStream; client: ClientHandle; r: var BufferedReader) = var id: string r.sread(id) - let fd = stream.recvFd() + let fd = r.recvAux.pop() client.passedFdMap.add((id, fd)) - stream.sclose() proc removeCachedItem(ctx: LoaderContext; stream: SocketStream; - client: ClientData; r: var BufferedReader) = + client: ClientHandle; r: var BufferedReader) = var id: int r.sread(id) let n = client.cacheMap.find(id) @@ -1271,9 +1300,8 @@ proc removeCachedItem(ctx: LoaderContext; stream: SocketStream; dec item.refc if item.refc == 0: discard unlink(cstring(item.path)) - stream.sclose() -proc tee(ctx: LoaderContext; stream: SocketStream; client: ClientData; +proc tee(ctx: LoaderContext; stream: SocketStream; client: ClientHandle; r: var BufferedReader) = var sourceId: int var targetPid: int @@ -1282,15 +1310,21 @@ proc tee(ctx: LoaderContext; stream: SocketStream; client: ClientData; let outputIn = ctx.findOutput(sourceId, client) if outputIn != nil: let id = ctx.getOutputId() - let output = outputIn.tee(stream, id, targetPid) - ctx.put(output) + var sy {.noinit.}: array[2, cint] stream.withPacketWriter w: - w.swrite(id) - stream.setBlocking(false) + if socketpair(AF_UNIX, SOCK_STREAM, IPPROTO_IP, sy) == 0: + w.swrite(id) + w.sendAux.add(sy[1]) + else: + w.swrite(-1) + discard close(sy[1]) + let ostream = newSocketStream(sy[0]) + ostream.setBlocking(false) + let output = outputIn.tee(ostream, id, targetPid) + ctx.put(output) else: stream.withPacketWriter w: w.swrite(-1) - stream.sclose() proc addAuth(ctx: LoaderContext; stream: SocketStream; r: var BufferedReader) = var url: URL @@ -1309,7 +1343,7 @@ proc addAuth(ctx: LoaderContext; stream: SocketStream; r: var BufferedReader) = ctx.authMap.add(item) ctx.pagerClient.authMap.add(item) -proc suspend(ctx: LoaderContext; stream: SocketStream; client: ClientData; +proc suspend(ctx: LoaderContext; stream: SocketStream; client: ClientHandle; r: var BufferedReader) = var ids: seq[int] r.sread(ids) @@ -1320,9 +1354,8 @@ proc suspend(ctx: LoaderContext; stream: SocketStream; client: ClientData; if output.registered: # do not waste cycles trying to push into output ctx.unregister(output) - stream.sclose() -proc resume(ctx: LoaderContext; stream: SocketStream; client: ClientData; +proc resume(ctx: LoaderContext; stream: SocketStream; client: ClientHandle; r: var BufferedReader) = var ids: seq[int] r.sread(ids) @@ -1332,37 +1365,12 @@ proc resume(ctx: LoaderContext; stream: SocketStream; client: ClientData; output.suspended = false if not output.isEmpty or output.istreamAtEnd: ctx.register(output) - stream.sclose() - -proc equalsConstantTime(a, b: ClientKey): bool = - static: - doAssert a.len == b.len - {.push boundChecks:off, overflowChecks:off.} - var i {.volatile.} = 0 - var res {.volatile.} = 0u8 - while i < a.len: - res = res or (a[i] xor b[i]) - inc i - {.pop.} - return res == 0 - -proc acceptConnection(ctx: LoaderContext) = - let stream = ctx.ssock.acceptSocketStream() + +proc readCommand(ctx: LoaderContext; client: ClientHandle) = + let stream = SocketStream(client.stream) try: + assert not client.stream.isend stream.withPacketReader r: - var myPid: int - var key: ClientKey - r.sread(myPid) - r.sread(key) - if myPid notin ctx.clientData: - # possibly already removed - stream.sclose() - return - let client = ctx.clientData[myPid] - if not client.key.equalsConstantTime(key): - # ditto - stream.sclose() - return var cmd: LoaderCommand r.sread(cmd) template privileged_command = @@ -1406,65 +1414,46 @@ proc acceptConnection(ctx: LoaderContext) = ctx.suspend(stream, client, r) of lcResume: ctx.resume(stream, client, r) - except ErrorBrokenPipe: - # receiving end died while reading the file; give up. - assert stream.fd >= ctx.handleMap.len or ctx.handleMap[stream.fd] == nil - stream.sclose() + assert r.empty() + except ErrorBrokenPipe, EOFError: + # Receiving end died while reading, or sent less bytes than they + # promised. Give up. + ctx.unregClient.add(client) proc exitLoader(ctx: LoaderContext) = - ctx.ssock.close() - for client in ctx.clientData.values: - client.cleanup() + for it in ctx.handleMap: + if it of ClientHandle: + let client = ClientHandle(it) + for it in client.cacheMap: + dec it.refc + if it.refc <= 0: + discard unlink(cstring(it.path)) exitnow(1) var gctx: LoaderContext -proc initLoaderContext(fd: cint; config: LoaderConfig): LoaderContext = +proc initLoaderContext(config: LoaderConfig; stream: SocketStream): + LoaderContext = var ctx = LoaderContext(alive: true, config: config) gctx = ctx - let myPid = getCurrentProcessId() - # we don't capsicumize loader, so -1 is appropriate here - ctx.ssock = newServerSocket(config.sockdir, -1, myPid) - let sfd = int(ctx.ssock.fd) - ctx.pollData.register(sfd, POLLIN) - if sfd >= ctx.handleMap.len: - ctx.handleMap.setLen(sfd + 1) - ctx.handleMap[sfd] = LoaderHandle() # pseudo handle - # The server has been initialized, so the main process can resume execution. - let ps = newPosixStream(fd) - ps.write(char(0u8)) - ps.sclose() onSignal SIGTERM: discard sig gctx.exitLoader() for dir in ctx.config.cgiDir.mitems: if dir.len > 0 and dir[^1] != '/': dir &= '/' - # get pager's key - let stream = ctx.ssock.acceptSocketStream() stream.withPacketReader r: - block readNullKey: - var pid: int # ignore pid - r.sread(pid) - # pager's key is still null - var key: ClientKey - r.sread(key) - doAssert key == ClientKey.default var cmd: LoaderCommand r.sread(cmd) doAssert cmd == lcAddClient - var key: ClientKey var pid: int var config: LoaderClientConfig - r.sread(key) r.sread(pid) r.sread(config) stream.withPacketWriter w: w.swrite(true) - ctx.pagerClient = ClientData(key: key, pid: pid, config: config) - ctx.clientData[pid] = ctx.pagerClient - stream.sclose() - # unblock main socket - ctx.ssock.setBlocking(false) + ctx.pagerClient = ClientHandle(stream: stream, pid: pid, config: config) + ctx.register(ctx.pagerClient) + ctx.put(ctx.pagerClient) # for CGI putEnv("SERVER_SOFTWARE", "Chawan") putEnv("SERVER_PROTOCOL", "HTTP/1.0") @@ -1504,13 +1493,12 @@ proc handleWrite(ctx: LoaderContext; output: OutputHandle; # all buffers sent, no need to select on this output again for now ctx.unregister(output) -proc finishCycle(ctx: LoaderContext; unregRead: var seq[InputHandle]; - unregWrite: var seq[OutputHandle]) = +proc finishCycle(ctx: LoaderContext) = # Unregister handles queued for unregistration. # It is possible for both unregRead and unregWrite to contain duplicates. To # avoid double-close/double-unregister, we set the istream/ostream of # unregistered handles to nil. - for handle in unregRead: + for handle in ctx.unregRead: if handle.stream != nil: ctx.unregister(handle) ctx.unset(handle) @@ -1520,8 +1508,8 @@ proc finishCycle(ctx: LoaderContext; unregRead: var seq[InputHandle]; for output in handle.outputs: output.istreamAtEnd = true if output.isEmpty: - unregWrite.add(output) - for output in unregWrite: + ctx.unregWrite.add(output) + for output in ctx.unregWrite: if output.stream != nil: if output.registered: ctx.unregister(output) @@ -1538,33 +1526,46 @@ proc finishCycle(ctx: LoaderContext; unregRead: var seq[InputHandle]; if handle.parser != nil: handle.finishParse() handle.iclose() - -proc runFileLoader*(fd: cint; config: LoaderConfig) = - var ctx = initLoaderContext(fd, config) - let fd = int(ctx.ssock.fd) + for client in ctx.unregClient: + if client.stream != nil: + # Do it in this exact order, or the cleanup procedure will have + # trouble finding all clients if we got interrupted in this loop. + ctx.unregister(client) + let fd = int(client.stream.fd) + client.close() + if fd < ctx.handleMap.len: + ctx.handleMap[fd] = nil + ctx.unregRead.setLen(0) + ctx.unregWrite.setLen(0) + ctx.unregClient.setLen(0) + +proc runFileLoader*(config: LoaderConfig; controlStream: SocketStream) = + var ctx = initLoaderContext(config, controlStream) while ctx.alive: ctx.pollData.poll(-1) - var unregRead: seq[InputHandle] = @[] - var unregWrite: seq[OutputHandle] = @[] + #TODO move to ctx for event in ctx.pollData.events: let efd = int(event.fd) if (event.revents and POLLIN) != 0: - if efd == fd: # incoming connection - ctx.acceptConnection() + let handle = ctx.handleMap[efd] + if handle of ClientHandle: + ctx.readCommand(ClientHandle(handle)) else: - let handle = InputHandle(ctx.handleMap[efd]) - case ctx.handleRead(handle, unregWrite) + let handle = InputHandle(handle) + case ctx.handleRead(handle, ctx.unregWrite) of hrrDone: discard - of hrrUnregister, hrrBrokenPipe: unregRead.add(handle) + of hrrUnregister, hrrBrokenPipe: ctx.unregRead.add(handle) if (event.revents and POLLOUT) != 0: let handle = ctx.handleMap[efd] - ctx.handleWrite(OutputHandle(handle), unregWrite) + ctx.handleWrite(OutputHandle(handle), ctx.unregWrite) if (event.revents and POLLERR) != 0 or (event.revents and POLLHUP) != 0: - assert efd != fd let handle = ctx.handleMap[efd] if handle of InputHandle: # istream died - unregRead.add(InputHandle(handle)) - else: # ostream died - unregWrite.add(OutputHandle(handle)) - ctx.finishCycle(unregRead, unregWrite) + ctx.unregRead.add(InputHandle(handle)) + elif handle of OutputHandle: # ostream died + ctx.unregWrite.add(OutputHandle(handle)) + else: # client died + assert handle of ClientHandle + ctx.unregClient.add(ClientHandle(handle)) + ctx.finishCycle() ctx.exitLoader() diff --git a/src/server/loaderiface.nim b/src/server/loaderiface.nim index 204d0cc5..f21fbd7f 100644 --- a/src/server/loaderiface.nim +++ b/src/server/loaderiface.nim @@ -22,8 +22,7 @@ import types/url type FileLoader* = ref object - key*: ClientKey - process*: int + loaderPid*: int clientPid*: int map: seq[MapData] mapFds*: int # number of fds in map @@ -38,6 +37,9 @@ type # inside the events iterator. registerBlocked: bool registerQueue: seq[ConnectData] + # UNIX domain socket to the loader process. + # We send all messages through this. + controlStream*: PosixStream ConnectDataState = enum cdsBeforeResult, cdsBeforeStatus, cdsBeforeHeaders @@ -102,33 +104,59 @@ proc getRedirect*(response: Response; request: Request): Request = return newRequest(url.get, request.httpMethod, body = request.body) return nil -template withLoaderPacketWriter(stream: SocketStream; loader: FileLoader; - w, body: untyped) = - stream.withPacketWriter w: - w.swrite(loader.clientPid) - w.swrite(loader.key) +template withPacketWriter(loader: FileLoader; w, body: untyped) = + loader.controlStream.withPacketWriter w: body -proc connect(loader: FileLoader): SocketStream = - return connectSocketStream(loader.sockDir, loader.sockDirFd, loader.process) +# Sometimes, we can return a value even after the loader crashed. +# This improves reliability of the pager. +template withPacketWriter(loader: FileLoader; w, fallback, body: untyped) = + try: + loader.controlStream.withPacketWriter w: + body + except IOError: + return fallback + +template withPacketWriterFire(loader: FileLoader; w, body: untyped) = + try: + loader.controlStream.withPacketWriter w: + body + except IOError: + return + +template withPacketReader(loader: FileLoader; r, body: untyped) = + loader.controlStream.withPacketReader r: + body # Start a request. This should not block (not for a significant amount of time # anyway). +#TODO can we return PosixStream here? +#TODO2 actually, why don't just use a pipe in the first place? +#TODO3 this chokes if loader runs out of fds... proc startRequest(loader: FileLoader; request: Request): SocketStream = - let stream = loader.connect() - stream.withLoaderPacketWriter loader, w: + loader.withPacketWriter w: w.swrite(lcLoad) w.swrite(request) - return stream + var success: bool + var fd: cint + loader.withPacketReader r: + r.sread(success) + if success: + fd = r.recvAux.pop() + if success: + return newSocketStream(fd) + return nil proc startRequest*(loader: FileLoader; request: Request; config: LoaderClientConfig): SocketStream = - let stream = loader.connect() - stream.withLoaderPacketWriter loader, w: + loader.withPacketWriter w: w.swrite(lcLoadConfig) w.swrite(request) w.swrite(config) - return stream + var fd: cint + loader.withPacketReader r: + fd = r.recvAux.pop() + return newSocketStream(fd) iterator data*(loader: FileLoader): MapData {.inline.} = for it in loader.map: @@ -210,74 +238,59 @@ proc reconnect*(loader: FileLoader; data: ConnectData) = )) proc suspend*(loader: FileLoader; fds: seq[int]) = - let stream = loader.connect() - stream.withLoaderPacketWriter loader, w: + loader.withPacketWriter w: w.swrite(lcSuspend) w.swrite(fds) - stream.sclose() proc resume*(loader: FileLoader; fds: openArray[int]) = - let stream = loader.connect() - stream.withLoaderPacketWriter loader, w: + loader.withPacketWriter w: w.swrite(lcResume) w.swrite(fds) - stream.sclose() proc resume*(loader: FileLoader; fds: int) = loader.resume([fds]) proc tee*(loader: FileLoader; sourceId, targetPid: int): (SocketStream, int) = - let stream = loader.connect() - stream.withLoaderPacketWriter loader, w: + loader.withPacketWriter w: w.swrite(lcTee) w.swrite(sourceId) w.swrite(targetPid) var outputId: int - var r = stream.initPacketReader() - r.sread(outputId) - return (stream, outputId) + var fd: cint + loader.withPacketReader r: + r.sread(outputId) + fd = r.recvAux.pop() + return (newSocketStream(fd), outputId) proc addCacheFile*(loader: FileLoader; outputId, targetPid: int): int = - let stream = loader.connect() - if stream == nil: - return -1 - stream.withLoaderPacketWriter loader, w: + loader.withPacketWriter w, -1: w.swrite(lcAddCacheFile) w.swrite(outputId) w.swrite(targetPid) - var r = stream.initPacketReader() var outputId: int - r.sread(outputId) - stream.sclose() + loader.withPacketReader r: + r.sread(outputId) return outputId proc getCacheFile*(loader: FileLoader; cacheId, sourcePid: int): string = - let stream = loader.connect() - if stream == nil: - return "" - stream.withLoaderPacketWriter loader, w: + loader.withPacketWriter w, "": w.swrite(lcGetCacheFile) w.swrite(cacheId) w.swrite(sourcePid) - var r = stream.initPacketReader() + var r = loader.controlStream.initPacketReader() var s: string r.sread(s) - stream.sclose() return s proc redirectToFile*(loader: FileLoader; outputId: int; targetPath: string): bool = - let stream = loader.connect() - if stream == nil: - return false - stream.withLoaderPacketWriter loader, w: + loader.withPacketWriter w, false: w.swrite(lcRedirectToFile) w.swrite(outputId) w.swrite(targetPath) - var r = stream.initPacketReader() + var r = loader.controlStream.initPacketReader() var res: bool r.sread(res) - stream.sclose() return res proc onConnected(loader: FileLoader; connectData: ConnectData) = @@ -393,86 +406,82 @@ proc doRequest*(loader: FileLoader; request: Request): Response = return response proc shareCachedItem*(loader: FileLoader; id, targetPid: int; sourcePid = -1) = - let stream = loader.connect() - if stream != nil: - let sourcePid = if sourcePid != -1: sourcePid else: loader.clientPid - stream.withLoaderPacketWriter loader, w: - w.swrite(lcShareCachedItem) - w.swrite(sourcePid) - w.swrite(targetPid) - w.swrite(id) - stream.sclose() + let sourcePid = if sourcePid != -1: sourcePid else: loader.clientPid + loader.withPacketWriterFire w: + w.swrite(lcShareCachedItem) + w.swrite(sourcePid) + w.swrite(targetPid) + w.swrite(id) proc openCachedItem*(loader: FileLoader; cacheId: int): PosixStream = - let stream = loader.connect() - if stream != nil: - stream.withLoaderPacketWriter loader, w: - w.swrite(lcOpenCachedItem) - w.swrite(cacheId) - var fd = cint(-1) - stream.withPacketReader r: - var success: bool - r.sread(success) - if success: - fd = r.recvAux.pop() - stream.sclose() - if fd != -1: - return newPosixStream(fd) + loader.withPacketWriter w, nil: + w.swrite(lcOpenCachedItem) + w.swrite(cacheId) + var fd = cint(-1) + loader.withPacketReader r: + var success: bool + r.sread(success) + if success: + fd = r.recvAux.pop() + if fd != -1: + return newPosixStream(fd) return nil proc passFd*(loader: FileLoader; id: string; fd: cint) = - let stream = loader.connect() - if stream != nil: - stream.withLoaderPacketWriter loader, w: - w.swrite(lcPassFd) - w.swrite(id) - stream.sendFd(fd) - stream.sclose() + loader.withPacketWriterFire w: + w.swrite(lcPassFd) + w.swrite(id) + w.sendAux.add(fd) proc removeCachedItem*(loader: FileLoader; cacheId: int) = - let stream = loader.connect() - if stream != nil: - stream.withLoaderPacketWriter loader, w: - w.swrite(lcRemoveCachedItem) - w.swrite(cacheId) - stream.sclose() + loader.withPacketWriterFire w: + w.swrite(lcRemoveCachedItem) + w.swrite(cacheId) proc addAuth*(loader: FileLoader; url: URL) = - let stream = loader.connect() - if stream != nil: - stream.withLoaderPacketWriter loader, w: - w.swrite(lcAddAuth) - w.swrite(url) - -proc addClient*(loader: FileLoader; key: ClientKey; pid: int; - config: LoaderClientConfig; clonedFrom: int): bool = - let stream = loader.connect() - stream.withLoaderPacketWriter loader, w: + loader.withPacketWriterFire w: + w.swrite(lcAddAuth) + w.swrite(url) + +proc addClient*(loader: FileLoader; pid: int; config: LoaderClientConfig; + clonedFrom: int; isPager = false): SocketStream = + loader.withPacketWriter w: w.swrite(lcAddClient) - w.swrite(key) w.swrite(pid) w.swrite(config) w.swrite(clonedFrom) - var r = stream.initPacketReader() - var res: bool - r.sread(res) - stream.sclose() - return res + var success: bool + var fd: cint + loader.withPacketReader r: + r.sread(success) + if success and not isPager: + fd = r.recvAux.pop() + if success and not isPager: + return newSocketStream(fd) + return nil proc removeClient*(loader: FileLoader; pid: int) = - let stream = loader.connect() - if stream != nil: - stream.withLoaderPacketWriter loader, w: - w.swrite(lcRemoveClient) - w.swrite(pid) - stream.sclose() + loader.withPacketWriter w: + w.swrite(lcRemoveClient) + w.swrite(pid) when defined(freebsd): - let O_DIRECTORY* {.importc, header: "<fcntl.h>", noinit.}: cint + let O_DIRECTORY {.importc, header: "<fcntl.h>", noinit.}: cint -proc setSocketDir*(loader: FileLoader; path: string) = - loader.sockDir = path +# On Capsicum-capable systems, this opens path as a directory. +# On other systems, it returns -1. +proc openSockDir*(path: string): cint = when defined(freebsd): - loader.sockDirFd = newPosixStream(path, O_DIRECTORY, 0).fd + return newPosixStream(path, O_DIRECTORY, 0).fd else: - loader.sockDirFd = -1 + return -1 + +proc newFileLoader*(loaderPid, clientPid: int; sockDir: string; + sockDirFd: cint; controlStream: SocketStream): FileLoader = + return FileLoader( + loaderPid: loaderPid, + sockDir: sockDir, + sockDirFd: sockDirFd, + clientPid: clientPid, + controlStream: controlStream + ) |