cache.c: do not ignore errors from print_slot()

If print_slot() fails, the client will be served an inferior response.
This patch makes sure that such an error will be returned to main(), which
in turn will try to inform about the error in the response itself.

The error is also printed to the cache_log, i.e. stderr, which will make
the error message appear in error_log (atleast when httpd==apache).

Noticed-by: Jim Meyering <jim@meyering.net>
Signed-off-by: Lars Hjemli <hjemli@gmail.com>

2 files changed, 15 insertions, 5 deletions

diff --git a/cache.c b/cache.c
index a996109..aa97ae1 100644
--- a/cache.c
+++ b/cache.c
@@ -159,230 +159,240 @@ static int unlock_slot(struct cache_slot *slot, int replace_old_slot)
                 err = rename(slot->lock_name, slot->cache_name);
         else
                 err = unlink(slot->lock_name);
 
         if (err)
                 return errno;
 
         return 0;
 }
 
 /* Generate the content for the current cache slot by redirecting
  * stdout to the lock-fd and invoking the callback function
  */
 static int fill_slot(struct cache_slot *slot)
 {
         int tmp;
 
         /* Preserve stdout */
         tmp = dup(STDOUT_FILENO);
         if (tmp == -1)
                 return errno;
 
         /* Redirect stdout to lockfile */
         if (dup2(slot->lock_fd, STDOUT_FILENO) == -1)
                 return errno;
 
         /* Generate cache content */
         slot->fn(slot->cbdata);
 
         /* Restore stdout */
         if (dup2(tmp, STDOUT_FILENO) == -1)
                 return errno;
 
         /* Close the temporary filedescriptor */
         if (close(tmp))
                 return errno;
 
         return 0;
 }
 
 /* Crude implementation of 32-bit FNV-1 hash algorithm,
  * see http://www.isthe.com/chongo/tech/comp/fnv/ for details
  * about the magic numbers.
  */
 #define FNV_OFFSET 0x811c9dc5
 #define FNV_PRIME  0x01000193
 
 unsigned long hash_str(const char *str)
 {
         unsigned long h = FNV_OFFSET;
         unsigned char *s = (unsigned char *)str;
 
         if (!s)
                 return h;
 
         while(*s) {
                 h *= FNV_PRIME;
                 h ^= *s++;
         }
         return h;
 }
 
 static int process_slot(struct cache_slot *slot)
 {
         int err;
 
         err = open_slot(slot);
         if (!err && slot->match) {
                 if (is_expired(slot)) {
                         if (!lock_slot(slot)) {
                                 /* If the cachefile has been replaced between
                                  * `open_slot` and `lock_slot`, we'll just
                                  * serve the stale content from the original
                                  * cachefile. This way we avoid pruning the
                                  * newly generated slot. The same code-path
                                  * is chosen if fill_slot() fails for some
                                  * reason.
                                  *
                                  * TODO? check if the new slot contains the
                                  * same key as the old one, since we would
                                  * prefer to serve the newest content.
                                  * This will require us to open yet another
                                  * file-descriptor and read and compare the
                                  * key from the new file, so for now we're
                                  * lazy and just ignore the new file.
                                  */
                                 if (is_modified(slot) || fill_slot(slot)) {
                                         unlock_slot(slot, 0);
                                         close_lock(slot);
                                 } else {
                                         close_slot(slot);
                                         unlock_slot(slot, 1);
                                         slot->cache_fd = slot->lock_fd;
                                 }
                         }
                 }
-                print_slot(slot);
+                if ((err = print_slot(slot)) != 0) {
+                        cache_log("[cgit] error printing cache %s: %s (%d)\n",
+                                  slot->cache_name,
+                                  strerror(err),
+                                  err);
+                }
                 close_slot(slot);
-                return 0;
+                return err;
         }
 
         /* If the cache slot does not exist (or its key doesn't match the
          * current key), lets try to create a new cache slot for this
          * request. If this fails (for whatever reason), lets just generate
          * the content without caching it and fool the caller to belive
          * everything worked out (but print a warning on stdout).
          */
 
         close_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);
                 return 0;
         }
 
         if ((err = fill_slot(slot)) != 0) {
                 cache_log("[cgit] Unable to fill slot %s: %s (%d)\n",
                           slot->lock_name, strerror(err), err);
                 unlock_slot(slot, 0);
                 close_lock(slot);
                 slot->fn(slot->cbdata);
                 return 0;
         }
         // We've got a valid cache slot in the lock file, which
         // is about to replace the old cache slot. But if we
         // release the lockfile and then try to open the new cache
         // slot, we might get a race condition with a concurrent
         // writer for the same cache slot (with a different key).
         // Lets avoid such a race by just printing the content of
         // the lock file.
         slot->cache_fd = slot->lock_fd;
         unlock_slot(slot, 1);
-        err = print_slot(slot);
+        if ((err = print_slot(slot)) != 0) {
+                cache_log("[cgit] error printing cache %s: %s (%d)\n",
+                          slot->cache_name,
+                          strerror(err),
+                          err);
+        }
         close_slot(slot);
         return err;
 }
 
 /* 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)
 {
         unsigned long hash;
         int len, i;
         char filename[1024];
         char lockname[1024 + 5];  /* 5 = ".lock" */
         struct cache_slot slot;
 
         /* If the cache is disabled, just generate the content */
         if (size <= 0) {
                 fn(cbdata);
                 return 0;
         }
 
         /* Verify input, calculate filenames */
         if (!path) {
                 cache_log("[cgit] Cache path not specified, caching is disabled\n");
                 fn(cbdata);
                 return 0;
         }
         len = strlen(path);
         if (len > sizeof(filename) - 10) { /* 10 = "/01234567\0" */
                 cache_log("[cgit] Cache path too long, caching is disabled: %s\n",
                           path);
                 fn(cbdata);
                 return 0;
         }
         if (!key)
                 key = "";
         hash = hash_str(key) % size;
         strcpy(filename, path);
         if (filename[len - 1] != '/')
                 filename[len++] = '/';
         for(i = 0; i < 8; i++) {
                 sprintf(filename + len++, "%x",
                         (unsigned char)(hash & 0xf));
                 hash >>= 4;
         }
         filename[len] = '\0';
         strcpy(lockname, filename);
         strcpy(lockname + len, ".lock");
         slot.fn = fn;
         slot.cbdata = cbdata;
         slot.ttl = ttl;
         slot.cache_name = filename;
         slot.lock_name = lockname;
         slot.key = key;
         slot.keylen = strlen(key);
         return process_slot(&slot);
 }
 
 /* Return a strftime formatted date/time
  * NB: the result from this function is to shared memory
  */
 char *sprintftime(const char *format, time_t time)
 {
         static char buf[64];
         struct tm *tm;
 
         if (!time)
                 return NULL;
         tm = gmtime(&time);
         strftime(buf, sizeof(buf)-1, format, tm);
         return buf;
 }
 
 int cache_ls(const char *path)
 {
         DIR *dir;
         struct dirent *ent;
         int err = 0;
         struct cache_slot slot;
         char fullname[1024];
         char *name;
 
         if (!path) {
                 cache_log("[cgit] cache path not specified\n");
                 return -1;
         }
         if (strlen(path) > 1024 - 10) {
                 cache_log("[cgit] cache path too long: %s\n",
                           path);
                 return -1;
         }
         dir = opendir(path);
         if (!dir) {
                 err = errno;
                 cache_log("[cgit] unable to open path %s: %s (%d)\n",
                           path, strerror(err), err);
                 return err;
diff --git a/cgit.c b/cgit.c
index 2036ceb..ac882c3 100644
--- a/cgit.c
+++ b/cgit.c
@@ -287,100 +287,100 @@ static void process_request(void *cbdata)
                 return;
         }
 
         if (ctx->repo && prepare_repo_cmd(ctx))
                 return;
 
         if (cmd->want_layout) {
                 cgit_print_http_headers(ctx);
                 cgit_print_docstart(ctx);
                 cgit_print_pageheader(ctx);
         }
 
         cmd->fn(ctx);
 
         if (cmd->want_layout)
                 cgit_print_docend();
 }
 
 static void cgit_parse_args(int argc, const char **argv)
 {
         int i;
 
         for (i = 1; i < argc; i++) {
                 if (!strncmp(argv[i], "--cache=", 8)) {
                         ctx.cfg.cache_root = xstrdup(argv[i]+8);
                 }
                 if (!strcmp(argv[i], "--nocache")) {
                         ctx.cfg.nocache = 1;
                 }
                 if (!strncmp(argv[i], "--query=", 8)) {
                         ctx.qry.raw = xstrdup(argv[i]+8);
                 }
                 if (!strncmp(argv[i], "--repo=", 7)) {
                         ctx.qry.repo = xstrdup(argv[i]+7);
                 }
                 if (!strncmp(argv[i], "--page=", 7)) {
                         ctx.qry.page = xstrdup(argv[i]+7);
                 }
                 if (!strncmp(argv[i], "--head=", 7)) {
                         ctx.qry.head = xstrdup(argv[i]+7);
                         ctx.qry.has_symref = 1;
                 }
                 if (!strncmp(argv[i], "--sha1=", 7)) {
                         ctx.qry.sha1 = xstrdup(argv[i]+7);
                         ctx.qry.has_sha1 = 1;
                 }
                 if (!strncmp(argv[i], "--ofs=", 6)) {
                         ctx.qry.ofs = atoi(argv[i]+6);
                 }
         }
 }
 
 static int calc_ttl()
 {
         if (!ctx.repo)
                 return ctx.cfg.cache_root_ttl;
 
         if (!ctx.qry.page)
                 return ctx.cfg.cache_repo_ttl;
 
         if (ctx.qry.has_symref)
                 return ctx.cfg.cache_dynamic_ttl;
 
         if (ctx.qry.has_sha1)
                 return ctx.cfg.cache_static_ttl;
 
         return ctx.cfg.cache_repo_ttl;
 }
 
 int main(int argc, const char **argv)
 {
         const char *cgit_config_env = getenv("CGIT_CONFIG");
         int err, ttl;
 
         prepare_context(&ctx);
         cgit_repolist.length = 0;
         cgit_repolist.count = 0;
         cgit_repolist.repos = NULL;
 
         parse_configfile(cgit_config_env ? cgit_config_env : CGIT_CONFIG,
                          config_cb);
         ctx.repo = NULL;
         if (getenv("SCRIPT_NAME"))
                 ctx.cfg.script_name = xstrdup(getenv("SCRIPT_NAME"));
         if (getenv("QUERY_STRING"))
                 ctx.qry.raw = xstrdup(getenv("QUERY_STRING"));
         cgit_parse_args(argc, argv);
         http_parse_querystring(ctx.qry.raw, querystring_cb);
 
         ttl = calc_ttl();
         ctx.page.expires += ttl*60;
         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);
         if (err)
-                cache_log("[cgit] error %d - %s\n",
-                          err, strerror(err));
+                cgit_print_error(fmt("Error processing page: %s (%d)",
+                                     strerror(err), err));
         return err;
 }