mirrors/cgit
0
0
Fork 0
mirror of https://git.zx2c4.com/cgit synced 2024-11-22 08:28:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

cache: close race window when unlocking slots

Browse Source 
We use POSIX advisory record locks to control access to cache slots, but
these have an unhelpful behaviour in that they are released when any
file descriptor referencing the file is closed by this process.

Mostly this is okay, since we know we won't be opening the lock file
anywhere else, but there is one place that it does matter: when we
restore stdout we dup2() over a file descriptor referring to the file,
thus closing that descriptor.

Since we restore stdout before unlocking the slot, this creates a window
during which the slot content can be overwritten.  The fix is reasonably
straightforward: simply restore stdout after unlocking the slot, but the
diff is a bit bigger because this requires us to move the temporary
stdout FD into struct cache_slot.

Signed-off-by: John Keeping <john@keeping.me.uk>
Reviewed-by: Christian Hesse <mail@eworm.de>
This commit is contained in:
John Keeping 2018-06-20 07:29:14 +02:00 committed by Jason A. Donenfeld
parent 255b78ff52
commit b31e99887b
1 changed files with 14 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
cache.c
View File

@ -29,6 +29,7 @@ struct cache_slot {
cache_fill_fn fn; cache_fill_fn fn;
int cache_fd; int cache_fd;
int lock_fd; int lock_fd;
int stdout_fd;
const char *cache_name; const char *cache_name;
const char *lock_name; const char *lock_name;
int match; int match;
@ -197,6 +198,13 @@ static int unlock_slot(struct cache_slot *slot, int replace_old_slot)
else else
err = unlink(slot->lock_name); err = unlink(slot->lock_name);
/* Restore stdout and close the temporary FD. */
if (slot->stdout_fd >= 0) {
dup2(slot->stdout_fd, STDOUT_FILENO);
close(slot->stdout_fd);
slot->stdout_fd = -1;
}
if (err) if (err)
return errno; return errno;
@ -208,42 +216,24 @@ static int unlock_slot(struct cache_slot *slot, int replace_old_slot)
*/ */
static int fill_slot(struct cache_slot *slot) static int fill_slot(struct cache_slot *slot)
{ {
int tmp;
/* Preserve stdout */ /* Preserve stdout */
tmp = dup(STDOUT_FILENO); slot->stdout_fd = dup(STDOUT_FILENO);
if (tmp == -1) if (slot->stdout_fd == -1)
return errno; return errno;
/* Redirect stdout to lockfile */ /* Redirect stdout to lockfile */
if (dup2(slot->lock_fd, STDOUT_FILENO) == -1) { if (dup2(slot->lock_fd, STDOUT_FILENO) == -1)
close(tmp);
return errno; return errno;
}
/* Generate cache content */ /* Generate cache content */
slot->fn(); slot->fn();
/* Make sure any buffered data is flushed to the file */ /* Make sure any buffered data is flushed to the file */
if (fflush(stdout)) { if (fflush(stdout))
close(tmp);
return errno; return errno;
}
/* update stat info */ /* update stat info */
if (fstat(slot->lock_fd, &slot->cache_st)) { if (fstat(slot->lock_fd, &slot->cache_st))
close(tmp);
return errno;
}
/* Restore stdout */
if (dup2(tmp, STDOUT_FILENO) == -1) {
close(tmp);
return errno;
}
/* Close the temporary filedescriptor */
if (close(tmp))
return errno; return errno;
return 0; return 0;
@ -393,6 +383,7 @@ int cache_process(int size, const char *path, const char *key, int ttl,
strbuf_addstr(&lockname, ".lock"); strbuf_addstr(&lockname, ".lock");
slot.fn = fn; slot.fn = fn;
slot.ttl = ttl; slot.ttl = ttl;
slot.stdout_fd = -1;
slot.cache_name = filename.buf; slot.cache_name = filename.buf;
slot.lock_name = lockname.buf; slot.lock_name = lockname.buf;
slot.key = key; slot.key = key;