aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorbptato <nincsnevem662@gmail.com>2025-01-08 18:44:48 +0100
committerbptato <nincsnevem662@gmail.com>2025-01-08 21:05:44 +0100
commitb3e57e3726b3654794057119a3c553312d40426b (patch)
treea45790656287934f99da2c6c7be7c0f923ba640c
parent9a6512c608dc119d74bc3c57029bf3bf60bad891 (diff)
downloadchawan-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.md10
-rw-r--r--src/io/bufreader.nim3
-rw-r--r--src/io/bufwriter.nim5
-rw-r--r--src/io/dynstream.nim13
-rw-r--r--src/local/client.nim9
-rw-r--r--src/local/container.nim2
-rw-r--r--src/local/pager.nim35
-rw-r--r--src/main.nim9
-rw-r--r--src/server/buffer.nim22
-rw-r--r--src/server/forkserver.nim107
-rw-r--r--src/server/loader.nim387
-rw-r--r--src/server/loaderiface.nim225
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
+ )