flockit.c

#include <dlfcn.h>
#include <errno.h>
#include <gnu/lib-names.h>   /* defines LIBC_SO */
#include <limits.h>
#include <stdatomic.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/file.h>
#include <unistd.h>

/* Wrap libc's open() to add locking via flock().

   If a file is opened for writing, we obtain an exclusive lock via
   flock() on the whole file before returning the file descriptor.

   If a file is opened only for reading, we obtain a shared lock.

   This only applies if the environment variable FLOCKIT_FILE_PREFIX
   is set, and it only applies to files whose names start with
   FLOCKIT_FILE_PREFIX. Other files are unaffected. If
   FLOCKIT_FILE_PREFIX is not set, no locking is done.
*/

typedef int (libc_open_t)(const char *, int, ...);

static _Atomic(libc_open_t*) libc_open;

void
flockit_setup(void) {
  void *libc_handle;

  if (!atomic_load_explicit(&libc_open, memory_order_relaxed)) {
    void *tmp;
    dlerror();                  /* clear any existing error */

    libc_handle = dlopen(LIBC_SO, RTLD_LAZY);
    if (!libc_handle) {
      fprintf(stderr, "flockit can't find libc: %s\n", dlerror());
      exit(1);
    }

    tmp = dlsym(libc_handle, "open");
    if (!tmp) {
      fprintf(stderr, "flockit can't find fopen in libc: %s\n", dlerror());
      exit(1);
    }
    atomic_store_explicit((_Atomic(void*)*)&libc_open, tmp, memory_order_relaxed);

    dlclose(libc_handle);
    dlerror();                  /* clear any existing error */
  }
}

static int open_inner(const char *file, int flags, mode_t mode) {
  int fd, flock_operation;
  char *flockit_file_prefix;
  libc_open_t* open;
  char pathbuf[PATH_MAX];

  flockit_setup();

  open = atomic_load_explicit(&libc_open, memory_order_relaxed);

  if (flags & O_CREAT) {
    fd = open(file, flags, mode);
  } else {
    fd = open(file, flags);
  }

  if (flags & O_WRONLY || flags & O_RDWR) {
    flock_operation = LOCK_EX;
  } else {
    flock_operation = LOCK_SH;
  }

  flockit_file_prefix = getenv("FLOCKIT_FILE_PREFIX");

  if (fd >= 0 && flockit_file_prefix) {
    pathbuf[0] = 0;
    if (!realpath(file, pathbuf)) {
      strncpy(pathbuf, file, PATH_MAX);
      pathbuf[PATH_MAX-1] = 0;
      errno = 0;
    }
    if (!strncmp(pathbuf, flockit_file_prefix, strlen(flockit_file_prefix))) {
      flock(fd, flock_operation);
    }
  }

  return fd;
}

int
open(const char *file, int flags, ...) {
  mode_t mode;
  va_list argp;

  va_start(argp, flags);

  if (flags & O_CREAT) {
    mode = va_arg(argp, mode_t);
  } else {
    mode = 0;
  }

  va_end(argp);

  return open_inner(file, flags, mode);
}

int
creat(const char *file, mode_t mode) {
  return open_inner(file, O_CREAT|O_WRONLY|O_TRUNC, mode);
}