#include <h/mh.h>
#include <h/signals.h>
#include <h/utils.h>
+#include <h/mts.h>
#ifdef HAVE_SYS_TIME_H
# include <sys/time.h>
#endif
};
+/*
+ * Number of tries to retry locking
+ */
+#define LOCK_RETRIES 5
+
/*
* Amount of time to wait before
* updating ctime of lock file.
*/
static int datalockinit = 0;
static int spoollockinit = 0;
-enum locktype datalocking, spoollocking;
+static enum locktype datalocktype, spoollocktype;
/* top of list containing all open locks */
static struct lock *l_top = NULL;
-static int lkopen(char *, int, mode_t, enum locktype, int);
-static FILE *lkfopen(char *, const char *, mode_t, int);
+static int lkopen(const char *, int, mode_t, enum locktype);
+static int str2accbits(const char *);
-static int lkopen_fcntl (char *, int, mode_t, int);
+static int lkopen_fcntl (const char *, int, mode_t);
#ifdef HAVE_LOCKF
-static int lkopen_lockf (char *, int, mode_t, int);
+static int lkopen_lockf (const char *, int, mode_t);
#endif /* HAVE_LOCKF */
+#ifdef HAVE_FLOCK
+static int lkopen_flock (const char *, int, mode_t);
+#endif /* HAVE_FLOCK */
static enum locktype init_locktype(const char *);
-static int lkopen_dot (char *, int, mode_t);
-static void lockname (char *, struct lockinfo *, int);
+static int lkopen_dot (const char *, int, mode_t);
+static void lkclose_dot (int, const char *);
+static void lockname (const char *, struct lockinfo *, int);
static void timerON (char *, int);
static void timerOFF (int);
static void alrmser (int);
#endif
/*
- * Base function: determine the data type used to lock files and
+ * Base functions: determine the data type used to lock files and
* call the underlying function.
*/
int
-lkopendata(char *file, int access, mode_t mode, int exclusive)
+lkopendata(const char *file, int access, mode_t mode)
{
if (! datalockinit) {
char *cp = context_find("datalocking");
if (cp) {
- datalocking = init_locktype(cp);
+ datalocktype = init_locktype(cp);
} else {
/* We default to fcntl locking for data files */
- datalocking = FCNTL_LOCKING;
+ datalocktype = FCNTL_LOCKING;
}
datalockinit = 1;
}
- return lkopen(file, access, mode, datalocking, exclusive);
+ return lkopen(file, access, mode, datalocktype);
+}
+
+
+/*
+ * Locking using the spool locking algorithm
+ */
+
+int lkopenspool(const char *file, int access, mode_t mode)
+{
+ if (! spoollockinit) {
+ spoollocktype = init_locktype(spoollocking);
+
+ spoollockinit = 1;
+ }
+
+ return lkopen(file, access, mode, spoollocktype);
+}
+
+
+/*
+ * Versions of lkopen that return a FILE *
+ */
+
+FILE *
+lkfopendata(const char *file, const char *mode)
+{
+ FILE *fp;
+ int oflags = str2accbits(mode);
+ int fd;
+
+ if (oflags == -1) {
+ errno = EINVAL;
+ return NULL;
+ }
+
+ if ((fd = lkopendata(file, oflags, 0666)) == -1)
+ return NULL;
+
+ if ((fp = fdopen (fd, mode)) == NULL) {
+ close (fd);
+ return NULL;
+ }
+
+ return fp;
+}
+
+FILE *
+lkfopenspool(const char *file, const char *mode)
+{
+ FILE *fp;
+ int oflags = str2accbits(mode);
+ int fd;
+
+ if (oflags == -1) {
+ errno = EINVAL;
+ return NULL;
+ }
+
+ if ((fd = lkopenspool(file, oflags, 0666)) == -1)
+ return NULL;
+
+ if ((fp = fdopen (fd, mode)) == NULL) {
+ close (fd);
+ return NULL;
+ }
+
+ return fp;
+}
+
+
+/*
+ * Corresponding close functions.
+ *
+ * A note here: All of the kernel locking functions terminate the lock
+ * when the descriptor is closed, so why write the code to explicitly
+ * unlock the file? We only need to do this in the dot-locking case.
+ */
+
+int
+lkclosedata(int fd, const char *name)
+{
+ int rc = close(fd);
+
+ if (datalocktype == DOT_LOCKING)
+ lkclose_dot(fd, name);
+
+ return rc;
+}
+
+int
+lkfclosedata(FILE *f, const char *name)
+{
+ int fd = fileno(f);
+ int rc = fclose(f);
+
+ if (datalocktype == DOT_LOCKING)
+ lkclose_dot(fd, name);
+
+ return rc;
+}
+
+int
+lkclosespool(int fd, const char *name)
+{
+ int rc = close(fd);
+
+ if (spoollocktype == DOT_LOCKING)
+ lkclose_dot(fd, name);
+
+ return rc;
+}
+
+int
+lkfclosespool(FILE *f, const char *name)
+{
+ int fd = fileno(f);
+ int rc = fclose(f);
+
+ if (spoollocktype == DOT_LOCKING)
+ lkclose_dot(fd, name);
+
+ return rc;
+}
+
+
+/*
+ * Convert fopen() mode argument to open() bits
+ */
+
+static int
+str2accbits(const char *mode)
+{
+ if (strcmp (mode, "r") == 0)
+ return O_RDONLY;
+ else if (strcmp (mode, "r+") == 0)
+ return O_RDWR;
+ else if (strcmp (mode, "w") == 0)
+ return O_WRONLY | O_CREAT | O_TRUNC;
+ else if (strcmp (mode, "w+") == 0)
+ return O_RDWR | O_CREAT | O_TRUNC;
+ else if (strcmp (mode, "a") == 0)
+ return O_WRONLY | O_CREAT | O_APPEND;
+ else if (strcmp (mode, "a+") == 0)
+ return O_RDWR | O_CREAT | O_APPEND;
+ else {
+ errno = EINVAL;
+ return -1;
+ }
}
/*
*/
static int
-lkopen (char *file, int access, mode_t mode, enum locktype ltype,
- int exclusive)
+lkopen (const char *file, int access, mode_t mode, enum locktype ltype)
{
switch (ltype) {
case FCNTL_LOCKING:
- return lkopen_fcntl(file, access, mode, exclusive);
+ return lkopen_fcntl(file, access, mode);
case DOT_LOCKING:
- return lkopen_dot(file, access, mode, exclusive);
+ return lkopen_dot(file, access, mode);
#ifdef HAVE_FLOCK
case FLOCK_LOCKING:
- return lkopen_flock(file, access, mode, exclusive);
+ return lkopen_flock(file, access, mode);
#endif /* HAVE_FLOCK */
#ifdef HAVE_LOCKF
case LOCKF_LOCKING:
- return lkopen_lockf(file, access, mode, exclusive);
+ return lkopen_lockf(file, access, mode);
#endif /* HAVE_FLOCK */
default:
/*
- * Base routine to close and unlock a file,
- * given a file descriptor.
+ * Routine to clean up the dot locking file
*/
-int
-lkclose (int fd, char *file)
+static void
+lkclose_dot (int fd, const char *file)
{
-#ifdef FCNTL_LOCKING
- struct flock buf;
-#endif
-
-#ifdef DOT_LOCKING
struct lockinfo lkinfo;
-#endif
-
- if (fd == -1)
- return 0;
-
-#ifdef FCNTL_LOCKING
- buf.l_type = F_UNLCK;
- buf.l_whence = SEEK_SET;
- buf.l_start = 0;
- buf.l_len = 0;
- fcntl(fd, F_SETLK, &buf);
-#endif
-#ifdef FLOCK_LOCKING
- flock (fd, LOCK_UN);
-#endif
-
-#ifdef LOCKF_LOCKING
- /* make sure we unlock the whole thing */
- lseek (fd, (off_t) 0, SEEK_SET);
- lockf (fd, F_ULOCK, 0L);
-#endif
-
-#ifdef DOT_LOCKING
lockname (file, &lkinfo, 0); /* get name of lock file */
#if !defined(HAVE_LIBLOCKFILE)
unlink (lkinfo.curlock); /* remove lock file */
lockfile_remove(lkinfo.curlock);
#endif /* HAVE_LIBLOCKFILE */
timerOFF (fd); /* turn off lock timer */
-#else /* DOT_LOCKING */
- NMH_UNUSED (file);
-#endif /* DOT_LOCKING */
-
- return (close (fd));
}
/*
- * Base routine to open and lock a file,
- * and return a FILE pointer
+ * Open and lock a file, using fcntl locking
*/
-FILE *
-lkfopen (char *file, char *mode, int exclusive)
+static int
+lkopen_fcntl(const char *file, int access, mode_t mode)
{
- int fd, access;
- FILE *fp;
+ int fd, i, saved_errno;
+ struct flock flk;
- if (strcmp (mode, "r") == 0)
- access = O_RDONLY;
- else if (strcmp (mode, "r+") == 0)
- access = O_RDWR;
- else if (strcmp (mode, "w") == 0)
- access = O_WRONLY | O_CREAT | O_TRUNC;
- else if (strcmp (mode, "w+") == 0)
- access = O_RDWR | O_CREAT | O_TRUNC;
- else if (strcmp (mode, "a") == 0)
- access = O_WRONLY | O_CREAT | O_APPEND;
- else if (strcmp (mode, "a+") == 0)
- access = O_RDWR | O_CREAT | O_APPEND;
- else {
- errno = EINVAL;
- return NULL;
- }
+ /*
+ * The assumption here is that if you open the file for writing, you
+ * need an exclusive lock.
+ */
- if ((fd = lkopen (file, access, 0666, exclusive)) == -1)
- return NULL;
+ for (i = 0; i < LOCK_RETRIES; i++) {
+ if ((fd = open(file, access, mode)) == -1)
+ return -1;
- if ((fp = fdopen (fd, mode)) == NULL) {
- close (fd);
- return NULL;
+ flk.l_start = 0;
+ flk.l_len = 0;
+ flk.l_type = (access & O_ACCMODE) == O_RDONLY ? F_RDLCK : F_WRLCK;
+ flk.l_whence = SEEK_SET;
+
+ if (fcntl(fd, F_SETLK, &flk) != -1)
+ return fd;
+
+ saved_errno = errno;
+ close(fd);
+ sleep(1);
}
- return fp;
+ errno = saved_errno;
+ return -1;
}
/*
- * Base routine to close and unlock a file,
- * given a FILE pointer
+ * Open and lock a file, using flock locking
*/
-int
-lkfclose (FILE *fp, char *file)
+static int
+lkopen_flock(const char *file, int access, mode_t mode)
{
-#ifdef FCNTL_LOCKING
- struct flock buf;
-#endif
-
-#ifdef DOT_LOCKING
- struct lockinfo lkinfo;
-#endif
+ int fd, i, saved_errno, locktype;
- if (fp == NULL)
- return 0;
+ /*
+ * The assumption here is that if you open the file for writing, you
+ * need an exclusive lock.
+ */
-#ifdef FCNTL_LOCKING
- buf.l_type = F_UNLCK;
- buf.l_whence = SEEK_SET;
- buf.l_start = 0;
- buf.l_len = 0;
- fcntl(fileno(fp), F_SETLK, &buf);
-#endif
+ locktype = (((access & O_ACCMODE) == O_RDONLY) ? LOCK_SH : LOCK_EX) |
+ LOCK_NB;
-#ifdef FLOCK_LOCKING
- flock (fileno(fp), LOCK_UN);
-#endif
+ for (i = 0; i < LOCK_RETRIES; i++) {
+ if ((fd = open(file, access, mode)) == -1)
+ return -1;
-#ifdef LOCKF_LOCKING
- /* make sure we unlock the whole thing */
- fseek (fp, 0L, SEEK_SET);
- lockf (fileno(fp), F_ULOCK, 0L);
-#endif
+ if (flock(fd, locktype) != -1)
+ return fd;
-#ifdef DOT_LOCKING
- lockname (file, &lkinfo, 0); /* get name of lock file */
-#if !defined(HAVE_LIBLOCKFILE)
- unlink (lkinfo.curlock); /* remove lock file */
-#else
- lockfile_remove(lkinfo.curlock);
-#endif /* HAVE_LIBLOCKFILE */
- timerOFF (fileno(fp)); /* turn off lock timer */
-#else /* DOT_LOCKING */
- NMH_UNUSED (file);
-#endif /* DOT_LOCKING */
+ saved_errno = errno;
+ close(fd);
+ sleep(1);
+ }
- return (fclose (fp));
+ errno = saved_errno;
+ return -1;
}
-#ifdef KERNEL_LOCKING
-
/*
- * open and lock a file, using kernel locking
+ * Open and lock a file, using lockf locking
*/
static int
-lkopen_kernel (char *file, int access, mode_t mode)
+lkopen_lockf(const char *file, int access, mode_t mode)
{
- int fd, i, j;
-
-# ifdef FCNTL_LOCKING
- struct flock buf;
-# endif /* FCNTL_LOCKING */
+ int fd, i, saved_errno, saved_access;
- for (i = 0; i < 5; i++) {
+ /*
+ * Two notes:
+ *
+ * Because lockf locks start from the current offset, mask off O_APPEND
+ * and seek to the end of the file later if it was requested.
+ *
+ * lockf locks require write access to the file, so always add it
+ * even if it wasn't requested.
+ */
-# if defined(LOCKF_LOCKING) || defined(FCNTL_LOCKING)
- /* remember the original mode */
- j = access;
+ saved_access = access;
- /* make sure we open at the beginning */
- access &= ~O_APPEND;
+ access &= ~O_APPEND;
- /*
- * We MUST have write permission or
- * lockf/fcntl() won't work
- */
- if ((access & 03) == O_RDONLY) {
- access &= ~O_RDONLY;
- access |= O_RDWR;
- }
-# endif /* LOCKF_LOCKING || FCNTL_LOCKING */
+ if ((access & O_ACCMODE) == O_RDONLY) {
+ access &= ~O_RDONLY;
+ access |= O_RDWR;
+ }
- if ((fd = open (file, access | O_NDELAY, mode)) == -1)
+ for (i = 0; i < LOCK_RETRIES; i++) {
+ if ((fd = open(file, access, mode)) == -1)
return -1;
-# ifdef FCNTL_LOCKING
- buf.l_type = F_WRLCK;
- buf.l_whence = SEEK_SET;
- buf.l_start = 0;
- buf.l_len = 0;
- if (fcntl (fd, F_SETLK, &buf) != -1)
- return fd;
-# endif
-
-# ifdef FLOCK_LOCKING
- if (flock (fd, (((access & 03) == O_RDONLY) ? LOCK_SH : LOCK_EX)
- | LOCK_NB) != -1)
- return fd;
-# endif
-
-# ifdef LOCKF_LOCKING
- if (lockf (fd, F_TLOCK, 0L) != -1) {
- /* see if we should be at the end */
- if (j & O_APPEND)
- lseek (fd, (off_t) 0, SEEK_END);
+ if (lockf(fd, F_TLOCK, 0) != -1) {
+ /*
+ * Seek to end if requested
+ */
+ if (saved_access & O_APPEND) {
+ lseek(fd, 0, SEEK_END);
+ }
return fd;
}
-# endif
- j = errno;
- close (fd);
- sleep (5);
+ saved_errno = errno;
+ close(fd);
+ sleep(1);
}
- close (fd);
- errno = j;
+ errno = saved_errno;
return -1;
}
-#endif /* KERNEL_LOCKING */
-
-
-#ifdef DOT_LOCKING
/*
* open and lock a file, using dot locking
*/
static int
-lkopen_dot (char *file, int access, mode_t mode)
+lkopen_dot (const char *file, int access, mode_t mode)
{
int fd;
struct lockinfo lkinfo;
*/
static void
-lockname (char *file, struct lockinfo *li, int isnewlock)
+lockname (const char *file, struct lockinfo *li, int isnewlock)
{
int bplen, tmplen;
- char *bp, *cp;
+ char *bp;
+ const char *cp;
#if 0
struct stat st;
alarm (NSECS);
}
-#endif /* DOT_LOCKING */
/*
* Return a locking algorithm based on the string name
projects / nmh / commitdiff