Switch to exclusively using global ctx

Drop the context parameter from the following functions (and all static
helpers used by them) and use the global context instead:

* cgit_print_http_headers()
* cgit_print_docstart()
* cgit_print_pageheader()

Remove context parameter from all commands

Drop the context parameter from the following functions (and all static
helpers used by them) and use the global context instead:

* cgit_get_cmd()
* All cgit command functions.
* cgit_clone_info()
* cgit_clone_objects()
* cgit_clone_head()
* cgit_print_plain()
* cgit_show_stats()

In initialization routines, use the global context variable instead of
passing a pointer around locally.

Remove callback data parameter for cache slots

This is no longer needed since the context is always read from the
global context variable.

Signed-off-by: Lukas Fleischer <cgit@cryptocrack.de>

19 files changed, 437 insertions, 442 deletions

diff --git a/cache.c b/cache.c
index fa83ddc..fcd461f 100644
--- a/cache.c
+++ b/cache.c
@@ -24,7 +24,6 @@ struct cache_slot {
         int keylen;
         int ttl;
         cache_fill_fn fn;
-        void *cbdata;
         int cache_fd;
         int lock_fd;
         const char *cache_name;
@@ -187,7 +186,7 @@ static int fill_slot(struct cache_slot *slot)
                 return errno;
 
         /* Generate cache content */
-        slot->fn(slot->cbdata);
+        slot->fn();
 
         /* Restore stdout */
         if (dup2(tmp, STDOUT_FILENO) == -1)
@@ -277,7 +276,7 @@ static int process_slot(struct cache_slot *slot)
         if ((err = lock_slot(slot)) != 0) {
                 cache_log("[cgit] Unable to lock slot %s: %s (%d)\n",
                           slot->lock_name, strerror(err), err);
-                slot->fn(slot->cbdata);
+                slot->fn();
                 return 0;
         }
 
@@ -286,7 +285,7 @@ static int process_slot(struct cache_slot *slot)
                           slot->lock_name, strerror(err), err);
                 unlock_slot(slot, 0);
                 close_lock(slot);
-                slot->fn(slot->cbdata);
+                slot->fn();
                 return 0;
         }
         // We've got a valid cache slot in the lock file, which
@@ -310,7 +309,7 @@ static int process_slot(struct cache_slot *slot)
 
 /* Print cached content to stdout, generate the content if necessary. */
 int cache_process(int size, const char *path, const char *key, int ttl,
-                  cache_fill_fn fn, void *cbdata)
+                  cache_fill_fn fn)
 {
         unsigned long hash;
         int i;
@@ -321,14 +320,14 @@ int cache_process(int size, const char *path, const char *key, int ttl,
 
         /* If the cache is disabled, just generate the content */
         if (size <= 0) {
-                fn(cbdata);
+                fn();
                 return 0;
         }
 
         /* Verify input, calculate filenames */
         if (!path) {
                 cache_log("[cgit] Cache path not specified, caching is disabled\n");
-                fn(cbdata);
+                fn();
                 return 0;
         }
         if (!key)
@@ -343,7 +342,6 @@ int cache_process(int size, const char *path, const char *key, int ttl,
         strbuf_addbuf(&lockname, &filename);
         strbuf_addstr(&lockname, ".lock");
         slot.fn = fn;
-        slot.cbdata = cbdata;
         slot.ttl = ttl;
         slot.cache_name = filename.buf;
         slot.lock_name = lockname.buf;
diff --git a/cache.h b/cache.h
index 5cfdb4f..9392836 100644
--- a/cache.h
+++ b/cache.h
@@ -6,7 +6,7 @@
 #ifndef CGIT_CACHE_H
 #define CGIT_CACHE_H
 
-typedef void (*cache_fill_fn)(void *cbdata);
+typedef void (*cache_fill_fn)(void);
 
 
 /* Print cached content to stdout, generate the content if necessary.
@@ -17,13 +17,12 @@ typedef void (*cache_fill_fn)(void *cbdata);
  *   key     the key used to lookup cache files
  *   ttl     max cache time in seconds for this key
  *   fn      content generator function for this key
- *   cbdata  user-supplied data to the content generator function
  *
  * Return value
  *   0 indicates success, everyting else is an error
  */
 extern int cache_process(int size, const char *path, const char *key, int ttl,
-                         cache_fill_fn fn, void *cbdata);
+                         cache_fill_fn fn);
 
 
 /* List info about all cache entries on stdout */
diff --git a/cgit.c b/cgit.c
index 994957f..ec8f69c 100644
--- a/cgit.c
+++ b/cgit.c
@@ -322,82 +322,82 @@ static void querystring_cb(const char *name, const char *value)
         }
 }
 
-static void prepare_context(struct cgit_context *ctx)
+static void prepare_context(void)
 {
-        memset(ctx, 0, sizeof(*ctx));
-        ctx->cfg.agefile = "info/web/last-modified";
-        ctx->cfg.nocache = 0;
-        ctx->cfg.cache_size = 0;
-        ctx->cfg.cache_max_create_time = 5;
-        ctx->cfg.cache_root = CGIT_CACHE_ROOT;
-        ctx->cfg.cache_about_ttl = 15;
-        ctx->cfg.cache_repo_ttl = 5;
-        ctx->cfg.cache_root_ttl = 5;
-        ctx->cfg.cache_scanrc_ttl = 15;
-        ctx->cfg.cache_dynamic_ttl = 5;
-        ctx->cfg.cache_static_ttl = -1;
-        ctx->cfg.case_sensitive_sort = 1;
-        ctx->cfg.branch_sort = 0;
-        ctx->cfg.commit_sort = 0;
-        ctx->cfg.css = "/cgit.css";
-        ctx->cfg.logo = "/cgit.png";
-        ctx->cfg.favicon = "/favicon.ico";
-        ctx->cfg.local_time = 0;
-        ctx->cfg.enable_http_clone = 1;
-        ctx->cfg.enable_index_owner = 1;
-        ctx->cfg.enable_tree_linenumbers = 1;
-        ctx->cfg.enable_git_config = 0;
-        ctx->cfg.max_repo_count = 50;
-        ctx->cfg.max_commit_count = 50;
-        ctx->cfg.max_lock_attempts = 5;
-        ctx->cfg.max_msg_len = 80;
-        ctx->cfg.max_repodesc_len = 80;
-        ctx->cfg.max_blob_size = 0;
-        ctx->cfg.max_stats = 0;
-        ctx->cfg.project_list = NULL;
-        ctx->cfg.renamelimit = -1;
-        ctx->cfg.remove_suffix = 0;
-        ctx->cfg.robots = "index, nofollow";
-        ctx->cfg.root_title = "Git repository browser";
-        ctx->cfg.root_desc = "a fast webinterface for the git dscm";
-        ctx->cfg.scan_hidden_path = 0;
-        ctx->cfg.script_name = CGIT_SCRIPT_NAME;
-        ctx->cfg.section = "";
-        ctx->cfg.repository_sort = "name";
-        ctx->cfg.section_sort = 1;
-        ctx->cfg.summary_branches = 10;
-        ctx->cfg.summary_log = 10;
-        ctx->cfg.summary_tags = 10;
-        ctx->cfg.max_atom_items = 10;
-        ctx->cfg.ssdiff = 0;
-        ctx->env.cgit_config = getenv("CGIT_CONFIG");
-        ctx->env.http_host = getenv("HTTP_HOST");
-        ctx->env.https = getenv("HTTPS");
-        ctx->env.no_http = getenv("NO_HTTP");
-        ctx->env.path_info = getenv("PATH_INFO");
-        ctx->env.query_string = getenv("QUERY_STRING");
-        ctx->env.request_method = getenv("REQUEST_METHOD");
-        ctx->env.script_name = getenv("SCRIPT_NAME");
-        ctx->env.server_name = getenv("SERVER_NAME");
-        ctx->env.server_port = getenv("SERVER_PORT");
-        ctx->env.http_cookie = getenv("HTTP_COOKIE");
-        ctx->env.http_referer = getenv("HTTP_REFERER");
-        ctx->env.content_length = getenv("CONTENT_LENGTH") ? strtoul(getenv("CONTENT_LENGTH"), NULL, 10) : 0;
-        ctx->env.authenticated = 0;
-        ctx->page.mimetype = "text/html";
-        ctx->page.charset = PAGE_ENCODING;
-        ctx->page.filename = NULL;
-        ctx->page.size = 0;
-        ctx->page.modified = time(NULL);
-        ctx->page.expires = ctx->page.modified;
-        ctx->page.etag = NULL;
-        memset(&ctx->cfg.mimetypes, 0, sizeof(struct string_list));
-        if (ctx->env.script_name)
-                ctx->cfg.script_name = xstrdup(ctx->env.script_name);
-        if (ctx->env.query_string)
-                ctx->qry.raw = xstrdup(ctx->env.query_string);
-        if (!ctx->env.cgit_config)
-                ctx->env.cgit_config = CGIT_CONFIG;
+        memset(&ctx, 0, sizeof(ctx));
+        ctx.cfg.agefile = "info/web/last-modified";
+        ctx.cfg.nocache = 0;
+        ctx.cfg.cache_size = 0;
+        ctx.cfg.cache_max_create_time = 5;
+        ctx.cfg.cache_root = CGIT_CACHE_ROOT;
+        ctx.cfg.cache_about_ttl = 15;
+        ctx.cfg.cache_repo_ttl = 5;
+        ctx.cfg.cache_root_ttl = 5;
+        ctx.cfg.cache_scanrc_ttl = 15;
+        ctx.cfg.cache_dynamic_ttl = 5;
+        ctx.cfg.cache_static_ttl = -1;
+        ctx.cfg.case_sensitive_sort = 1;
+        ctx.cfg.branch_sort = 0;
+        ctx.cfg.commit_sort = 0;
+        ctx.cfg.css = "/cgit.css";
+        ctx.cfg.logo = "/cgit.png";
+        ctx.cfg.favicon = "/favicon.ico";
+        ctx.cfg.local_time = 0;
+        ctx.cfg.enable_http_clone = 1;
+        ctx.cfg.enable_index_owner = 1;
+        ctx.cfg.enable_tree_linenumbers = 1;
+        ctx.cfg.enable_git_config = 0;
+        ctx.cfg.max_repo_count = 50;
+        ctx.cfg.max_commit_count = 50;
+        ctx.cfg.max_lock_attempts = 5;
+        ctx.cfg.max_msg_len = 80;
+        ctx.cfg.max_repodesc_len = 80;
+        ctx.cfg.max_blob_size = 0;
+        ctx.cfg.max_stats = 0;
+        ctx.cfg.project_list = NULL;
+        ctx.cfg.renamelimit = -1;
+        ctx.cfg.remove_suffix = 0;
+        ctx.cfg.robots = "index, nofollow";
+        ctx.cfg.root_title = "Git repository browser";
+        ctx.cfg.root_desc = "a fast webinterface for the git dscm";
+        ctx.cfg.scan_hidden_path = 0;
+        ctx.cfg.script_name = CGIT_SCRIPT_NAME;
+        ctx.cfg.section = "";
+        ctx.cfg.repository_sort = "name";
+        ctx.cfg.section_sort = 1;
+        ctx.cfg.summary_branches = 10;
+        ctx.cfg.summary_log = 10;
+        ctx.cfg.summary_tags = 10;
+        ctx.cfg.max_atom_items = 10;
+        ctx.cfg.ssdiff = 0;
+        ctx.env.cgit_config = getenv("CGIT_CONFIG");
+        ctx.env.http_host = getenv("HTTP_HOST");
+        ctx.env.https = getenv("HTTPS");
+        ctx.env.no_http = getenv("NO_HTTP");
+        ctx.env.path_info = getenv("PATH_INFO");
+        ctx.env.query_string = getenv("QUERY_STRING");
+        ctx.env.request_method = getenv("REQUEST_METHOD");
+        ctx.env.script_name = getenv("SCRIPT_NAME");
+        ctx.env.server_name = getenv("SERVER_NAME");
+        ctx.env.server_port = getenv("SERVER_PORT");
+        ctx.env.http_cookie = getenv("HTTP_COOKIE");
+        ctx.env.http_referer = getenv("HTTP_REFERER");
+        ctx.env.content_length = getenv("CONTENT_LENGTH") ? strtoul(getenv("CONTENT_LENGTH"), NULL, 10) : 0;
+        ctx.env.authenticated = 0;
+        ctx.page.mimetype = "text/html";
+        ctx.page.charset = PAGE_ENCODING;
+        ctx.page.filename = NULL;
+        ctx.page.size = 0;
+        ctx.page.modified = time(NULL);
+        ctx.page.expires = ctx.page.modified;
+        ctx.page.etag = NULL;
+        memset(&ctx.cfg.mimetypes, 0, sizeof(struct string_list));
+        if (ctx.env.script_name)
+                ctx.cfg.script_name = xstrdup(ctx.env.script_name);
+        if (ctx.env.query_string)
+                ctx.qry.raw = xstrdup(ctx.env.query_string);
+        if (!ctx.env.cgit_config)
+                ctx.env.cgit_config = CGIT_CONFIG;
 }
 
 struct refmatch {
@@ -527,14 +527,14 @@ static void choose_readme(struct cgit_repo *repo)
                 string_list_append(&repo->readme, filename)->util = ref;
 }
 
-static int prepare_repo_cmd(struct cgit_context *ctx)
+static int prepare_repo_cmd(void)
 {
         unsigned char sha1[20];
         int nongit = 0;
         int rc;
 
         /* The path to the git repository. */
-        setenv("GIT_DIR", ctx->repo->path, 1);
+        setenv("GIT_DIR", ctx.repo->path, 1);
 
         /* Do not look in /etc/ for gitconfig and gitattributes. */
         setenv("GIT_CONFIG_NOSYSTEM", "1", 1);
@@ -549,69 +549,69 @@ static int prepare_repo_cmd(struct cgit_context *ctx)
         init_display_notes(NULL);
 
         if (nongit) {
-                const char *name = ctx->repo->name;
+                const char *name = ctx.repo->name;
                 rc = errno;
-                ctx->page.title = fmtalloc("%s - %s", ctx->cfg.root_title,
+                ctx.page.title = fmtalloc("%s - %s", ctx.cfg.root_title,
                                                 "config error");
-                ctx->repo = NULL;
-                cgit_print_http_headers(ctx);
-                cgit_print_docstart(ctx);
-                cgit_print_pageheader(ctx);
+                ctx.repo = NULL;
+                cgit_print_http_headers();
+                cgit_print_docstart();
+                cgit_print_pageheader();
                 cgit_print_error("Failed to open %s: %s", name,
                                  rc ? strerror(rc) : "Not a valid git repository");
                 cgit_print_docend();
                 return 1;
         }
-        ctx->page.title = fmtalloc("%s - %s", ctx->repo->name, ctx->repo->desc);
+        ctx.page.title = fmtalloc("%s - %s", ctx.repo->name, ctx.repo->desc);
 
-        if (!ctx->repo->defbranch)
-                ctx->repo->defbranch = guess_defbranch();
+        if (!ctx.repo->defbranch)
+                ctx.repo->defbranch = guess_defbranch();
 
-        if (!ctx->qry.head) {
-                ctx->qry.nohead = 1;
-                ctx->qry.head = find_default_branch(ctx->repo);
+        if (!ctx.qry.head) {
+                ctx.qry.nohead = 1;
+                ctx.qry.head = find_default_branch(ctx.repo);
         }
 
-        if (!ctx->qry.head) {
-                cgit_print_http_headers(ctx);
-                cgit_print_docstart(ctx);
-                cgit_print_pageheader(ctx);
+        if (!ctx.qry.head) {
+                cgit_print_http_headers();
+                cgit_print_docstart();
+                cgit_print_pageheader();
                 cgit_print_error("Repository seems to be empty");
                 cgit_print_docend();
                 return 1;
         }
 
-        if (get_sha1(ctx->qry.head, sha1)) {
-                char *tmp = xstrdup(ctx->qry.head);
-                ctx->qry.head = ctx->repo->defbranch;
-                ctx->page.status = 404;
-                ctx->page.statusmsg = "Not found";
-                cgit_print_http_headers(ctx);
-                cgit_print_docstart(ctx);
-                cgit_print_pageheader(ctx);
+        if (get_sha1(ctx.qry.head, sha1)) {
+                char *tmp = xstrdup(ctx.qry.head);
+                ctx.qry.head = ctx.repo->defbranch;
+                ctx.page.status = 404;
+                ctx.page.statusmsg = "Not found";
+                cgit_print_http_headers();
+                cgit_print_docstart();
+                cgit_print_pageheader();
                 cgit_print_error("Invalid branch: %s", tmp);
                 cgit_print_docend();
                 return 1;
         }
-        sort_string_list(&ctx->repo->submodules);
-        cgit_prepare_repo_env(ctx->repo);
-        choose_readme(ctx->repo);
+        sort_string_list(&ctx.repo->submodules);
+        cgit_prepare_repo_env(ctx.repo);
+        choose_readme(ctx.repo);
         return 0;
 }
 
-static inline void open_auth_filter(struct cgit_context *ctx, const char *function)
+static inline void open_auth_filter(const char *function)
 {
-        cgit_open_filter(ctx->cfg.auth_filter, function,
-                ctx->env.http_cookie ? ctx->env.http_cookie : "",
-                ctx->env.request_method ? ctx->env.request_method : "",
-                ctx->env.query_string ? ctx->env.query_string : "",
-                ctx->env.http_referer ? ctx->env.http_referer : "",
-                ctx->env.path_info ? ctx->env.path_info : "",
-                ctx->env.http_host ? ctx->env.http_host : "",
-                ctx->env.https ? ctx->env.https : "",
-                ctx->qry.repo ? ctx->qry.repo : "",
-                ctx->qry.page ? ctx->qry.page : "",
-                ctx->qry.url ? ctx->qry.url : "",
+        cgit_open_filter(ctx.cfg.auth_filter, function,
+                ctx.env.http_cookie ? ctx.env.http_cookie : "",
+                ctx.env.request_method ? ctx.env.request_method : "",
+                ctx.env.query_string ? ctx.env.query_string : "",
+                ctx.env.http_referer ? ctx.env.http_referer : "",
+                ctx.env.path_info ? ctx.env.path_info : "",
+                ctx.env.http_host ? ctx.env.http_host : "",
+                ctx.env.https ? ctx.env.https : "",
+                ctx.qry.repo ? ctx.qry.repo : "",
+                ctx.qry.page ? ctx.qry.page : "",
+                ctx.qry.url ? ctx.qry.url : "",
                 cgit_loginurl());
 }
 
@@ -622,107 +622,106 @@ static inline void open_auth_filter(struct cgit_context *ctx, const char *functi
  * will complain on the mailing list, and we'll increase it as needed. */
 #define MAX_AUTHENTICATION_POST_BYTES 4096
 /* The filter is expected to spit out "Status: " and all headers. */
-static inline void authenticate_post(struct cgit_context *ctx)
+static inline void authenticate_post(void)
 {
         char buffer[MAX_AUTHENTICATION_POST_BYTES];
         int len;
 
-        open_auth_filter(ctx, "authenticate-post");
-        len = ctx->env.content_length;
+        open_auth_filter("authenticate-post");
+        len = ctx.env.content_length;
         if (len > MAX_AUTHENTICATION_POST_BYTES)
                 len = MAX_AUTHENTICATION_POST_BYTES;
         if (read(STDIN_FILENO, buffer, len) < 0)
                 die_errno("Could not read POST from stdin");
         if (write(STDOUT_FILENO, buffer, len) < 0)
                 die_errno("Could not write POST to stdout");
-        cgit_close_filter(ctx->cfg.auth_filter);
+        cgit_close_filter(ctx.cfg.auth_filter);
         exit(0);
 }
 
-static inline void authenticate_cookie(struct cgit_context *ctx)
+static inline void authenticate_cookie(void)
 {
         /* If we don't have an auth_filter, consider all cookies valid, and thus return early. */
-        if (!ctx->cfg.auth_filter) {
-                ctx->env.authenticated = 1;
+        if (!ctx.cfg.auth_filter) {
+                ctx.env.authenticated = 1;
                 return;
         }
 
         /* If we're having something POST'd to /login, we're authenticating POST,
          * instead of the cookie, so call authenticate_post and bail out early.
          * This pattern here should match /?p=login with POST. */
-        if (ctx->env.request_method && ctx->qry.page && !ctx->repo && \
-            !strcmp(ctx->env.request_method, "POST") && !strcmp(ctx->qry.page, "login")) {
-                authenticate_post(ctx);
+        if (ctx.env.request_method && ctx.qry.page && !ctx.repo && \
+            !strcmp(ctx.env.request_method, "POST") && !strcmp(ctx.qry.page, "login")) {
+                authenticate_post();
                 return;
         }
 
         /* If we've made it this far, we're authenticating the cookie for real, so do that. */
-        open_auth_filter(ctx, "authenticate-cookie");
-        ctx->env.authenticated = cgit_close_filter(ctx->cfg.auth_filter);
+        open_auth_filter("authenticate-cookie");
+        ctx.env.authenticated = cgit_close_filter(ctx.cfg.auth_filter);
 }
 
-static void process_request(void *cbdata)
+static void process_request(void)
 {
-        struct cgit_context *ctx = cbdata;
         struct cgit_cmd *cmd;
 
         /* If we're not yet authenticated, no matter what page we're on,
          * display the authentication body from the auth_filter. This should
          * never be cached. */
-        if (!ctx->env.authenticated) {
-                ctx->page.title = "Authentication Required";
-                cgit_print_http_headers(ctx);
-                cgit_print_docstart(ctx);
-                cgit_print_pageheader(ctx);
-                open_auth_filter(ctx, "body");
-                cgit_close_filter(ctx->cfg.auth_filter);
+        if (!ctx.env.authenticated) {
+                ctx.page.title = "Authentication Required";
+                cgit_print_http_headers();
+                cgit_print_docstart();
+                cgit_print_pageheader();
+                open_auth_filter("body");
+                cgit_close_filter(ctx.cfg.auth_filter);
                 cgit_print_docend();
                 return;
         }
 
-        cmd = cgit_get_cmd(ctx);
+        cmd = cgit_get_cmd();
         if (!cmd) {
-                ctx->page.title = "cgit error";
-                ctx->page.status = 404;
-                ctx->page.statusmsg = "Not found";
-                cgit_print_http_headers(ctx);
-                cgit_print_docstart(ctx);
-                cgit_print_pageheader(ctx);
+                ctx.page.title = "cgit error";
+                ctx.page.status = 404;
+                ctx.page.statusmsg = "Not found";
+                cgit_print_http_headers();
+                cgit_print_docstart();
+                cgit_print_pageheader();
                 cgit_print_error("Invalid request");
                 cgit_print_docend();
                 return;
         }
 
-        if (!ctx->cfg.enable_http_clone && cmd->is_clone) {
+        if (!ctx.cfg.enable_http_clone && cmd->is_clone) {
                 html_status(404, "Not found", 0);
                 return;
         }
 
-        /* If cmd->want_vpath is set, assume ctx->qry.path contains a "virtual"
-         * in-project path limit to be made available at ctx->qry.vpath.
-         * Otherwise, no path limit is in effect (ctx->qry.vpath = NULL).
+        /* If cmd->want_vpath is set, assume ctx.qry.path contains a "virtual"
+         * in-project path limit to be made available at ctx.qry.vpath.
+         * Otherwise, no path limit is in effect (ctx.qry.vpath = NULL).
          */
-        ctx->qry.vpath = cmd->want_vpath ? ctx->qry.path : NULL;
+        ctx.qry.vpath = cmd->want_vpath ? ctx.qry.path : NULL;
 
-        if (cmd->want_repo && !ctx->repo) {
-                cgit_print_http_headers(ctx);
-                cgit_print_docstart(ctx);
-                cgit_print_pageheader(ctx);
+        if (cmd->want_repo && !ctx.repo) {
+                cgit_print_http_headers();
+                cgit_print_docstart();
+                cgit_print_pageheader();
                 cgit_print_error("No repository selected");
                 cgit_print_docend();
                 return;
         }
 
-        if (ctx->repo && prepare_repo_cmd(ctx))
+        if (ctx.repo && prepare_repo_cmd())
                 return;
 
         if (cmd->want_layout) {
-                cgit_print_http_headers(ctx);
-                cgit_print_docstart(ctx);
-                cgit_print_pageheader(ctx);
+                cgit_print_http_headers();
+                cgit_print_docstart();
+                cgit_print_pageheader();
         }
 
-        cmd->fn(ctx);
+        cmd->fn();
 
         if (cmd->want_layout)
                 cgit_print_docend();
@@ -995,7 +994,7 @@ int main(int argc, const char **argv)
         cgit_init_filters();
         atexit(cgit_cleanup_filters);
 
-        prepare_context(&ctx);
+        prepare_context();
         cgit_repolist.length = 0;
         cgit_repolist.count = 0;
         cgit_repolist.repos = NULL;
@@ -1034,7 +1033,7 @@ int main(int argc, const char **argv)
         /* Before we go any further, we set ctx.env.authenticated by checking to see
          * if the supplied cookie is valid. All cookies are valid if there is no
          * auth_filter. If there is an auth_filter, the filter decides. */
-        authenticate_cookie(&ctx);
+        authenticate_cookie();
 
         ttl = calc_ttl();
         if (ttl < 0)
@@ -1046,7 +1045,8 @@ int main(int argc, const char **argv)
         if (ctx.cfg.nocache)
                 ctx.cfg.cache_size = 0;
         err = cache_process(ctx.cfg.cache_size, ctx.cfg.cache_root,
-                            ctx.qry.raw, ttl, process_request, &ctx);
+                            ctx.qry.raw, ttl, process_request);
+        cgit_cleanup_filters();
         if (err)
                 cgit_print_error("Error processing page: %s (%d)",
                                  strerror(err), err);
diff --git a/cmd.c b/cmd.c
index 420b3b1..cbd235c 100644
--- a/cmd.c
+++ b/cmd.c
@@ -26,120 +26,120 @@
 #include "ui-tag.h"
 #include "ui-tree.h"
 
-static void HEAD_fn(struct cgit_context *ctx)
+static void HEAD_fn(void)
 {
-        cgit_clone_head(ctx);
+        cgit_clone_head();
 }
 
-static void atom_fn(struct cgit_context *ctx)
+static void atom_fn(void)
 {
-        cgit_print_atom(ctx->qry.head, ctx->qry.path, ctx->cfg.max_atom_items);
+        cgit_print_atom(ctx.qry.head, ctx.qry.path, ctx.cfg.max_atom_items);
 }
 
-static void about_fn(struct cgit_context *ctx)
+static void about_fn(void)
 {
-        if (ctx->repo)
-                cgit_print_repo_readme(ctx->qry.path);
+        if (ctx.repo)
+                cgit_print_repo_readme(ctx.qry.path);
         else
                 cgit_print_site_readme();
 }
 
-static void blob_fn(struct cgit_context *ctx)
+static void blob_fn(void)
 {
-        cgit_print_blob(ctx->qry.sha1, ctx->qry.path, ctx->qry.head, 0);
+        cgit_print_blob(ctx.qry.sha1, ctx.qry.path, ctx.qry.head, 0);
 }
 
-static void commit_fn(struct cgit_context *ctx)
+static void commit_fn(void)
 {
-        cgit_print_commit(ctx->qry.sha1, ctx->qry.path);
+        cgit_print_commit(ctx.qry.sha1, ctx.qry.path);
 }
 
-static void diff_fn(struct cgit_context *ctx)
+static void diff_fn(void)
 {
-        cgit_print_diff(ctx->qry.sha1, ctx->qry.sha2, ctx->qry.path, 1, 0);
+        cgit_print_diff(ctx.qry.sha1, ctx.qry.sha2, ctx.qry.path, 1, 0);
 }
 
-static void rawdiff_fn(struct cgit_context *ctx)
+static void rawdiff_fn(void)
 {
-        cgit_print_diff(ctx->qry.sha1, ctx->qry.sha2, ctx->qry.path, 1, 1);
+        cgit_print_diff(ctx.qry.sha1, ctx.qry.sha2, ctx.qry.path, 1, 1);
 }
 
-static void info_fn(struct cgit_context *ctx)
+static void info_fn(void)
 {
-        cgit_clone_info(ctx);
+        cgit_clone_info();
 }
 
-static void log_fn(struct cgit_context *ctx)
+static void log_fn(void)
 {
-        cgit_print_log(ctx->qry.sha1, ctx->qry.ofs, ctx->cfg.max_commit_count,
-                       ctx->qry.grep, ctx->qry.search, ctx->qry.path, 1,
-                       ctx->repo->enable_commit_graph,
-                       ctx->repo->commit_sort);
+        cgit_print_log(ctx.qry.sha1, ctx.qry.ofs, ctx.cfg.max_commit_count,
+                       ctx.qry.grep, ctx.qry.search, ctx.qry.path, 1,
+                       ctx.repo->enable_commit_graph,
+                       ctx.repo->commit_sort);
 }
 
-static void ls_cache_fn(struct cgit_context *ctx)
+static void ls_cache_fn(void)
 {
-        ctx->page.mimetype = "text/plain";
-        ctx->page.filename = "ls-cache.txt";
-        cgit_print_http_headers(ctx);
-        cache_ls(ctx->cfg.cache_root);
+        ctx.page.mimetype = "text/plain";
+        ctx.page.filename = "ls-cache.txt";
+        cgit_print_http_headers();
+        cache_ls(ctx.cfg.cache_root);
 }
 
-static void objects_fn(struct cgit_context *ctx)
+static void objects_fn(void)
 {
-        cgit_clone_objects(ctx);
+        cgit_clone_objects();
 }
 
-static void repolist_fn(struct cgit_context *ctx)
+static void repolist_fn(void)
 {
         cgit_print_repolist();
 }
 
-static void patch_fn(struct cgit_context *ctx)
+static void patch_fn(void)
 {
-        cgit_print_patch(ctx->qry.sha1, ctx->qry.sha2, ctx->qry.path);
+        cgit_print_patch(ctx.qry.sha1, ctx.qry.sha2, ctx.qry.path);
 }
 
-static void plain_fn(struct cgit_context *ctx)
+static void plain_fn(void)
 {
-        cgit_print_plain(ctx);
+        cgit_print_plain();
 }
 
-static void refs_fn(struct cgit_context *ctx)
+static void refs_fn(void)
 {
         cgit_print_refs();
 }
 
-static void snapshot_fn(struct cgit_context *ctx)
+static void snapshot_fn(void)
 {
-        cgit_print_snapshot(ctx->qry.head, ctx->qry.sha1, ctx->qry.path,
-                            ctx->repo->snapshots, ctx->qry.nohead);
+        cgit_print_snapshot(ctx.qry.head, ctx.qry.sha1, ctx.qry.path,
+                            ctx.repo->snapshots, ctx.qry.nohead);
 }
 
-static void stats_fn(struct cgit_context *ctx)
+static void stats_fn(void)
 {
-        cgit_show_stats(ctx);
+        cgit_show_stats();
 }
 
-static void summary_fn(struct cgit_context *ctx)
+static void summary_fn(void)
 {
         cgit_print_summary();
 }
 
-static void tag_fn(struct cgit_context *ctx)
+static void tag_fn(void)
 {
-        cgit_print_tag(ctx->qry.sha1);
+        cgit_print_tag(ctx.qry.sha1);
 }
 
-static void tree_fn(struct cgit_context *ctx)
+static void tree_fn(void)
 {
-        cgit_print_tree(ctx->qry.sha1, ctx->qry.path);
+        cgit_print_tree(ctx.qry.sha1, ctx.qry.path);
 }
 
 #define def_cmd(name, want_repo, want_layout, want_vpath, is_clone) \
         {#name, name##_fn, want_repo, want_layout, want_vpath, is_clone}
 
-struct cgit_cmd *cgit_get_cmd(struct cgit_context *ctx)
+struct cgit_cmd *cgit_get_cmd(void)
 {
         static struct cgit_cmd cmds[] = {
                 def_cmd(HEAD, 1, 0, 0, 1),
@@ -165,15 +165,15 @@ struct cgit_cmd *cgit_get_cmd(struct cgit_context *ctx)
         };
         int i;
 
-        if (ctx->qry.page == NULL) {
-                if (ctx->repo)
-                        ctx->qry.page = "summary";
+        if (ctx.qry.page == NULL) {
+                if (ctx.repo)
+                        ctx.qry.page = "summary";
                 else
-                        ctx->qry.page = "repolist";
+                        ctx.qry.page = "repolist";
         }
 
         for (i = 0; i < sizeof(cmds)/sizeof(*cmds); i++)
-                if (!strcmp(ctx->qry.page, cmds[i].name))
+                if (!strcmp(ctx.qry.page, cmds[i].name))
                         return &cmds[i];
         return NULL;
 }
diff --git a/cmd.h b/cmd.h
index eb5bc87..752f078 100644
--- a/cmd.h
+++ b/cmd.h
@@ -1,7 +1,7 @@
 #ifndef CMD_H
 #define CMD_H
 
-typedef void (*cgit_cmd_fn)(struct cgit_context *ctx);
+typedef void (*cgit_cmd_fn)(void);
 
 struct cgit_cmd {
         const char *name;
@@ -12,6 +12,6 @@ struct cgit_cmd {
                 is_clone:1;
 };
 
-extern struct cgit_cmd *cgit_get_cmd(struct cgit_context *ctx);
+extern struct cgit_cmd *cgit_get_cmd(void);
 
 #endif /* CMD_H */
diff --git a/ui-atom.c b/ui-atom.c
index 838f220..b22d745 100644
--- a/ui-atom.c
+++ b/ui-atom.c
@@ -108,7 +108,7 @@ void cgit_print_atom(char *tip, char *path, int max_count)
         host = cgit_hosturl();
         ctx.page.mimetype = "text/xml";
         ctx.page.charset = "utf-8";
-        cgit_print_http_headers(&ctx);
+        cgit_print_http_headers();
         html("<feed xmlns='http://www.w3.org/2005/Atom'>\n");
         html("<title>");
         html_txt(ctx.repo->name);
diff --git a/ui-blob.c b/ui-blob.c
index 608926e..9c99519 100644
--- a/ui-blob.c
+++ b/ui-blob.c
@@ -164,6 +164,6 @@ void cgit_print_blob(const char *hex, char *path, const char *head, int file_onl
                         ctx.page.mimetype = "text/plain";
         }
         ctx.page.filename = path;
-        cgit_print_http_headers(&ctx);
+        cgit_print_http_headers();
         html_raw(buf, size);
 }
diff --git a/ui-clone.c b/ui-clone.c
index 9d0d6ad..d25553b 100644
--- a/ui-clone.c
+++ b/ui-clone.c
@@ -29,22 +29,22 @@ static int print_ref_info(const char *refname, const unsigned char *sha1,
         return 0;
 }
 
-static void print_pack_info(struct cgit_context *ctx)
+static void print_pack_info(void)
 {
         struct packed_git *pack;
         int ofs;
 
-        ctx->page.mimetype = "text/plain";
-        ctx->page.filename = "objects/info/packs";
-        cgit_print_http_headers(ctx);
-        ofs = strlen(ctx->repo->path) + strlen("/objects/pack/");
+        ctx.page.mimetype = "text/plain";
+        ctx.page.filename = "objects/info/packs";
+        cgit_print_http_headers();
+        ofs = strlen(ctx.repo->path) + strlen("/objects/pack/");
         prepare_packed_git();
         for (pack = packed_git; pack; pack = pack->next)
                 if (pack->pack_local)
                         htmlf("P %s\n", pack->pack_name + ofs);
 }
 
-static void send_file(struct cgit_context *ctx, char *path)
+static void send_file(char *path)
 {
         struct stat st;
 
@@ -61,41 +61,41 @@ static void send_file(struct cgit_context *ctx, char *path)
                 }
                 return;
         }
-        ctx->page.mimetype = "application/octet-stream";
-        ctx->page.filename = path;
-        if (prefixcmp(ctx->repo->path, path))
-                ctx->page.filename += strlen(ctx->repo->path) + 1;
-        cgit_print_http_headers(ctx);
+        ctx.page.mimetype = "application/octet-stream";
+        ctx.page.filename = path;
+        if (prefixcmp(ctx.repo->path, path))
+                ctx.page.filename += strlen(ctx.repo->path) + 1;
+        cgit_print_http_headers();
         html_include(path);
 }
 
-void cgit_clone_info(struct cgit_context *ctx)
+void cgit_clone_info(void)
 {
-        if (!ctx->qry.path || strcmp(ctx->qry.path, "refs"))
+        if (!ctx.qry.path || strcmp(ctx.qry.path, "refs"))
                 return;
 
-        ctx->page.mimetype = "text/plain";
-        ctx->page.filename = "info/refs";
-        cgit_print_http_headers(ctx);
-        for_each_ref(print_ref_info, ctx);
+        ctx.page.mimetype = "text/plain";
+        ctx.page.filename = "info/refs";
+        cgit_print_http_headers();
+        for_each_ref(print_ref_info, NULL);
 }
 
-void cgit_clone_objects(struct cgit_context *ctx)
+void cgit_clone_objects(void)
 {
-        if (!ctx->qry.path) {
+        if (!ctx.qry.path) {
                 html_status(400, "Bad request", 0);
                 return;
         }
 
-        if (!strcmp(ctx->qry.path, "info/packs")) {
-                print_pack_info(ctx);
+        if (!strcmp(ctx.qry.path, "info/packs")) {
+                print_pack_info();
                 return;
         }
 
-        send_file(ctx, git_path("objects/%s", ctx->qry.path));
+        send_file(git_path("objects/%s", ctx.qry.path));
 }
 
-void cgit_clone_head(struct cgit_context *ctx)
+void cgit_clone_head(void)
 {
-        send_file(ctx, git_path("%s", "HEAD"));
+        send_file(git_path("%s", "HEAD"));
 }
diff --git a/ui-clone.h b/ui-clone.h
index 89cd4f1..3e460a3 100644
--- a/ui-clone.h
+++ b/ui-clone.h
@@ -1,8 +1,8 @@
 #ifndef UI_CLONE_H
 #define UI_CLONE_H
 
-void cgit_clone_info(struct cgit_context *ctx);
-void cgit_clone_objects(struct cgit_context *ctx);
-void cgit_clone_head(struct cgit_context *ctx);
+void cgit_clone_info(void);
+void cgit_clone_objects(void);
+void cgit_clone_head(void);
 
 #endif /* UI_CLONE_H */
diff --git a/ui-diff.c b/ui-diff.c
index 5ccd03e..71273aa 100644
--- a/ui-diff.c
+++ b/ui-diff.c
@@ -407,7 +407,7 @@ void cgit_print_diff(const char *new_rev, const char *old_rev,
                 diff_setup_done(&diffopt);
 
                 ctx.page.mimetype = "text/plain";
-                cgit_print_http_headers(&ctx);
+                cgit_print_http_headers();
                 if (old_tree_sha1) {
                         diff_tree_sha1(old_tree_sha1, new_tree_sha1, "",
                                        &diffopt);
diff --git a/ui-patch.c b/ui-patch.c
index 3086608..6878a46 100644
--- a/ui-patch.c
+++ b/ui-patch.c
@@ -59,7 +59,7 @@ void cgit_print_patch(const char *new_rev, const char *old_rev,
         patchname = fmt("%s.patch", rev_range);
         ctx.page.mimetype = "text/plain";
         ctx.page.filename = patchname;
-        cgit_print_http_headers(&ctx);
+        cgit_print_http_headers();
 
         if (ctx.cfg.noplainemail) {
                 rev_argv[2] = "--format=format:From %H Mon Sep 17 00:00:00 "
diff --git a/ui-plain.c b/ui-plain.c
index 68e0387..30fff89 100644
--- a/ui-plain.c
+++ b/ui-plain.c
@@ -103,7 +103,7 @@ static int print_object(const unsigned char *sha1, const char *path)
         ctx.page.filename = path;
         ctx.page.size = size;
         ctx.page.etag = sha1_to_hex(sha1);
-        cgit_print_http_headers(&ctx);
+        cgit_print_http_headers();
         html_raw(buf, size);
         /* If we allocated this, then casting away const is safe. */
         if (freemime)
@@ -128,7 +128,7 @@ static void print_dir(const unsigned char *sha1, const char *base,
         fullpath = buildpath(base, baselen, path);
         slash = (fullpath[0] == '/' ? "" : "/");
         ctx.page.etag = sha1_to_hex(sha1);
-        cgit_print_http_headers(&ctx);
+        cgit_print_http_headers();
         htmlf("<html><head><title>%s", slash);
         html_txt(fullpath);
         htmlf("</title></head>\n<body>\n<h2>%s", slash);