static bool_t getPage(EFSRepoRef const repo, HTTPConnectionRef const conn, HTTPMethod const method, strarg_t const URI) {
if(HTTP_GET != method) return false;
size_t pathlen = prefix("/", URI);
if(!pathlen) return false;
if(!pathterm(URI, (size_t)pathlen)) return false;
EFSSessionRef const session = auth(repo, conn, method, URI+pathlen);
if(!session) {
HTTPConnectionSendStatus(conn, 403);
return true;
}
// TODO: Parse querystring `q` parameter
EFSFilterRef const filter = EFSFilterCreate(EFSTypeFilter);
EFSFilterAddStringArg(filter, "text/html; charset=utf-8");
EFSFileInfo *const files = EFSSessionCreateFileInfoList(session, filter, RESULTS_MAX);
HTTPConnectionWriteResponse(conn, 200, "OK");
HTTPConnectionWriteHeader(conn, "Content-Type", "text/html; charset=utf-8");
HTTPConnectionWriteHeader(conn, "Transfer-Encoding", "chunked");
HTTPConnectionBeginBody(conn);
// TODO: Page header
uv_fs_t req = { .data = co_active(); }
for(index_t i = 0; i < files->count; ++i) {
uv_fs_open(loop, &req, path, O_RDONLY, 0400, async_fs_cb);
co_switch(yield);
uv_fs_req_cleanup(&req);
uv_file const file = req.result;
if(file < 0) continue;
HTTPConnectionWriteChunkLength(conn, files->items[i].size);
HTTPConnectionWriteFile(conn, file);
uv_fs_close(loop, &req, file, async_fs_cb);
co_switch(yield);
uv_fs_req_cleanup(&req);
HTTPConnectionWrite(conn, "\r\n", 2);
}
// TODO: Page trailer
HTTPConnectionWriteChunkLength(conn, 0);
HTTPConnectionWrite(conn, "\r\n", 2);
HTTPConnectionEnd(conn);
EFSFileInfoListFree(files);
return true;
}
int HTTPConnectionWriteChunkFile(HTTPConnectionRef const conn, strarg_t const path) {
bool worker = false;
uv_file file = -1;
byte_t *buf = NULL;
int rc;
async_pool_enter(NULL); worker = true;
rc = async_fs_open(path, O_RDONLY, 0000);
if(rc < 0) goto cleanup;
file = rc;
buf = malloc(BUFFER_SIZE);
if(!buf) rc = UV_ENOMEM;
if(rc < 0) goto cleanup;
uv_buf_t const chunk = uv_buf_init((char *)buf, BUFFER_SIZE);
ssize_t len = async_fs_readall_simple(file, &chunk);
if(len < 0) rc = len;
if(rc < 0) goto cleanup;
// Fast path for small files.
if(len < BUFFER_SIZE) {
str_t pfx[16];
int const pfxlen = snprintf(pfx, sizeof(pfx), "%llx\r\n", (unsigned long long)len);
if(pfxlen < 0) rc = UV_UNKNOWN;
if(rc < 0) goto cleanup;
uv_buf_t parts[] = {
uv_buf_init(pfx, pfxlen),
uv_buf_init((char *)buf, len),
uv_buf_init((char *)STR_LEN("\r\n")),
};
async_fs_close(file); file = -1;
async_pool_leave(NULL); worker = false;
rc = HTTPConnectionWritev(conn, parts, numberof(parts));
goto cleanup;
}
uv_fs_t req[1];
rc = async_fs_fstat(file, req);
if(rc < 0) goto cleanup;
if(0 == req->statbuf.st_size) goto cleanup;
async_pool_leave(NULL); worker = false;
// TODO: HACK, WriteFile continues from where we left off
rc = rc < 0 ? rc : HTTPConnectionWriteChunkLength(conn, req->statbuf.st_size);
rc = rc < 0 ? rc : HTTPConnectionWritev(conn, &chunk, 1);
rc = rc < 0 ? rc : HTTPConnectionWriteFile(conn, file);
rc = rc < 0 ? rc : HTTPConnectionWrite(conn, (byte_t const *)STR_LEN("\r\n"));
cleanup:
FREE(&buf);
if(file >= 0) { async_fs_close(file); file = -1; }
if(worker) { async_pool_leave(NULL); worker = false; }
assert(file < 0);
assert(!worker);
return rc;
}
int HTTPConnectionWriteChunkv(HTTPConnectionRef const conn, uv_buf_t const parts[], unsigned int const count) {
if(!conn) return 0;
uint64_t total = 0;
for(size_t i = 0; i < count; i++) total += parts[i].len;
if(total <= 0) return 0;
int rc = 0;
rc = rc < 0 ? rc : HTTPConnectionWriteChunkLength(conn, total);
rc = rc < 0 ? rc : async_write((uv_stream_t *)conn->stream, parts, count);
rc = rc < 0 ? rc : HTTPConnectionWrite(conn, (byte_t const *)STR_LEN("\r\n"));
return rc;
}
