diplodocus.org Git - nmh/blob - sbr/lock_file.c

   1
   2 /*
   3  * lock.c -- routines to lock/unlock files
   4  *
   5  * This code is Copyright (c) 2002, by the authors of nmh.  See the
   6  * COPYRIGHT file in the root directory of the nmh distribution for
   7  * complete copyright information.
   8  */
   9
  10 /* Modified by Ruud de Rooij to support Miquel van Smoorenburg's liblockfile
  11  *
  12  * Since liblockfile locking shares most of its code with dot locking, it
  13  * is enabled by defining both DOT_LOCKING and HAVE_LIBLOCKFILE.
  14  *
  15  * Ruud de Rooij <ruud@debian.org>  Sun, 28 Mar 1999 15:34:03 +0200
  16  */
  17
  18 #include <h/mh.h>
  19 #include <h/signals.h>
  20 #include <h/utils.h>
  21
  22 #ifdef TIME_WITH_SYS_TIME
  23 # include <sys/time.h>
  24 # include <time.h>
  25 #else
  26 # ifdef TM_IN_SYS_TIME
  27 #  include <sys/time.h>
  28 # else
  29 #  include <time.h>
  30 # endif
  31 #endif
  32 #include <errno.h>
  33
  34 #ifdef HAVE_FCNTL_H
  35 # include <fcntl.h>
  36 #else
  37 # include <sys/file.h>
  38 #endif
  39
  40 #if defined(LOCKF_LOCKING) || defined(FLOCK_LOCKING)
  41 # include <sys/file.h>
  42 #endif
  43
  44 #include <signal.h>
  45
  46 #if defined(HAVE_LIBLOCKFILE)
  47 #include <lockfile.h>
  48 #endif
  49
  50 #ifdef LOCKDIR
  51 char *lockdir = LOCKDIR;
  52 #endif
  53
  54 /* Are we using any kernel locking? */
  55 #if defined (FLOCK_LOCKING) || defined(LOCKF_LOCKING) || defined(FCNTL_LOCKING)
  56 # define KERNEL_LOCKING
  57 #endif
  58
  59 #ifdef DOT_LOCKING
  60
  61 /* struct for getting name of lock file to create */
  62 struct lockinfo {
  63     char curlock[BUFSIZ];
  64 #if !defined(HAVE_LIBLOCKFILE)
  65     char tmplock[BUFSIZ];
  66 #endif
  67 };
  68
  69 /*
  70  * Amount of time to wait before
  71  * updating ctime of lock file.
  72  */
  73 #define NSECS 20
  74
  75 #if !defined(HAVE_LIBLOCKFILE)
  76 /*
  77  * How old does a lock file need to be
  78  * before we remove it.
  79  */
  80 #define RSECS 180
  81 #endif /* HAVE_LIBLOCKFILE */
  82
  83 /* struct for recording and updating locks */
  84 struct lock {
  85     int l_fd;
  86     char *l_lock;
  87     struct lock *l_next;
  88 };
  89
  90 /* top of list containing all open locks */
  91 static struct lock *l_top = NULL;
  92 #endif /* DOT_LOCKING */
  93
  94 /*
  95  * static prototypes
  96  */
  97 #ifdef KERNEL_LOCKING
  98 static int lkopen_kernel (char *, int, mode_t);
  99 #endif
 100
 101 #ifdef DOT_LOCKING
 102 static int lkopen_dot (char *, int, mode_t);
 103 static void lockname (char *, struct lockinfo *, int);
 104 static void timerON (char *, int);
 105 static void timerOFF (int);
 106 static RETSIGTYPE alrmser (int);
 107
 108 #if !defined(HAVE_LIBLOCKFILE)
 109 static int lockit (struct lockinfo *);
 110 #endif
 111 #endif
 112
 113 /*
 114  * Base routine to open and lock a file,
 115  * and return a file descriptor.
 116  */
 117
 118 int
 119 lkopen (char *file, int access, mode_t mode)
 120 {
 121 #ifdef KERNEL_LOCKING
 122     return lkopen_kernel(file, access, mode);
 123 #endif
 124
 125 #ifdef DOT_LOCKING
 126     return lkopen_dot(file, access, mode);
 127 #endif
 128 }
 129
 130
 131 /*
 132  * Base routine to close and unlock a file,
 133  * given a file descriptor.
 134  */
 135
 136 int
 137 lkclose (int fd, char *file)
 138 {
 139 #ifdef FCNTL_LOCKING
 140     struct flock buf;
 141 #endif
 142
 143 #ifdef DOT_LOCKING
 144     struct lockinfo lkinfo;
 145 #endif
 146
 147     if (fd == -1)
 148         return 0;
 149
 150 #ifdef FCNTL_LOCKING
 151     buf.l_type   = F_UNLCK;
 152     buf.l_whence = SEEK_SET;
 153     buf.l_start  = 0;
 154     buf.l_len    = 0;
 155     fcntl(fd, F_SETLK, &buf);
 156 #endif
 157
 158 #ifdef FLOCK_LOCKING
 159     flock (fd, LOCK_UN);
 160 #endif
 161
 162 #ifdef LOCKF_LOCKING
 163     /* make sure we unlock the whole thing */
 164     lseek (fd, (off_t) 0, SEEK_SET);
 165     lockf (fd, F_ULOCK, 0L);
 166 #endif
 167
 168 #ifdef DOT_LOCKING
 169     lockname (file, &lkinfo, 0);        /* get name of lock file */
 170 #if !defined(HAVE_LIBLOCKFILE)
 171     unlink (lkinfo.curlock);            /* remove lock file      */
 172 #else
 173     lockfile_remove(lkinfo.curlock);
 174 #endif /* HAVE_LIBLOCKFILE */
 175     timerOFF (fd);                      /* turn off lock timer   */
 176 #endif /* DOT_LOCKING */
 177
 178     return (close (fd));
 179 }
 180
 181
 182 /*
 183  * Base routine to open and lock a file,
 184  * and return a FILE pointer
 185  */
 186
 187 FILE *
 188 lkfopen (char *file, char *mode)
 189 {
 190     int fd, access;
 191     FILE *fp;
 192
 193     if (strcmp (mode, "r") == 0)
 194         access = O_RDONLY;
 195     else if (strcmp (mode, "r+") == 0)
 196         access = O_RDWR;
 197     else if (strcmp (mode, "w") == 0)
 198         access = O_WRONLY | O_CREAT | O_TRUNC;
 199     else if (strcmp (mode, "w+") == 0)
 200         access = O_RDWR | O_CREAT | O_TRUNC;
 201     else if (strcmp (mode, "a") == 0)
 202         access = O_WRONLY | O_CREAT | O_APPEND;
 203     else if (strcmp (mode, "a+") == 0)
 204         access = O_RDWR | O_CREAT | O_APPEND;
 205     else {
 206         errno = EINVAL;
 207         return NULL;
 208     }
 209
 210     if ((fd = lkopen (file, access, 0666)) == -1)
 211         return NULL;
 212
 213     if ((fp = fdopen (fd, mode)) == NULL) {
 214         close (fd);
 215         return NULL;
 216     }
 217
 218     return fp;
 219 }
 220
 221
 222 /*
 223  * Base routine to close and unlock a file,
 224  * given a FILE pointer
 225  */
 226
 227 int
 228 lkfclose (FILE *fp, char *file)
 229 {
 230 #ifdef FCNTL_LOCKING
 231     struct flock buf;
 232 #endif
 233
 234 #ifdef DOT_LOCKING
 235     struct lockinfo lkinfo;
 236 #endif
 237
 238     if (fp == NULL)
 239         return 0;
 240
 241 #ifdef FCNTL_LOCKING
 242     buf.l_type   = F_UNLCK;
 243     buf.l_whence = SEEK_SET;
 244     buf.l_start  = 0;
 245     buf.l_len    = 0;
 246     fcntl(fileno(fp), F_SETLK, &buf);
 247 #endif
 248
 249 #ifdef FLOCK_LOCKING
 250     flock (fileno(fp), LOCK_UN);
 251 #endif
 252
 253 #ifdef LOCKF_LOCKING
 254     /* make sure we unlock the whole thing */
 255     fseek (fp, 0L, SEEK_SET);
 256     lockf (fileno(fp), F_ULOCK, 0L);
 257 #endif
 258
 259 #ifdef DOT_LOCKING
 260     lockname (file, &lkinfo, 0);        /* get name of lock file */
 261 #if !defined(HAVE_LIBLOCKFILE)
 262     unlink (lkinfo.curlock);            /* remove lock file      */
 263 #else
 264     lockfile_remove(lkinfo.curlock);
 265 #endif /* HAVE_LIBLOCKFILE */
 266     timerOFF (fileno(fp));              /* turn off lock timer   */
 267 #endif /* DOT_LOCKING */
 268
 269     return (fclose (fp));
 270 }
 271
 272
 273 #ifdef KERNEL_LOCKING
 274
 275 /*
 276  * open and lock a file, using kernel locking
 277  */
 278
 279 static int
 280 lkopen_kernel (char *file, int access, mode_t mode)
 281 {
 282     int fd, i, j;
 283
 284 # ifdef FCNTL_LOCKING
 285     struct flock buf;
 286 # endif /* FCNTL_LOCKING */
 287
 288     for (i = 0; i < 5; i++) {
 289
 290 # if defined(LOCKF_LOCKING) || defined(FCNTL_LOCKING)
 291         /* remember the original mode */
 292         j = access;
 293
 294         /* make sure we open at the beginning */
 295         access &= ~O_APPEND;
 296
 297         /*
 298          * We MUST have write permission or
 299          * lockf/fcntl() won't work
 300          */
 301         if ((access & 03) == O_RDONLY) {
 302             access &= ~O_RDONLY;
 303             access |= O_RDWR;
 304         }
 305 # endif /* LOCKF_LOCKING || FCNTL_LOCKING */
 306
 307         if ((fd = open (file, access | O_NDELAY, mode)) == -1)
 308             return -1;
 309
 310 # ifdef FCNTL_LOCKING
 311         buf.l_type   = F_WRLCK;
 312         buf.l_whence = SEEK_SET;
 313         buf.l_start  = 0;
 314         buf.l_len    = 0;
 315         if (fcntl (fd, F_SETLK, &buf) != -1)
 316             return fd;
 317 # endif
 318
 319 # ifdef FLOCK_LOCKING
 320         if (flock (fd, (((access & 03) == O_RDONLY) ? LOCK_SH : LOCK_EX)
 321                    | LOCK_NB) != -1)
 322             return fd;
 323 # endif
 324
 325 # ifdef LOCKF_LOCKING
 326         if (lockf (fd, F_TLOCK, 0L) != -1) {
 327             /* see if we should be at the end */
 328             if (j & O_APPEND)
 329                 lseek (fd, (off_t) 0, SEEK_END);
 330             return fd;
 331         }
 332 # endif
 333
 334         j = errno;
 335         close (fd);
 336         sleep (5);
 337     }
 338
 339     close (fd);
 340     errno = j;
 341     return -1;
 342 }
 343
 344 #endif /* KERNEL_LOCKING */
 345
 346
 347 #ifdef DOT_LOCKING
 348
 349 /*
 350  * open and lock a file, using dot locking
 351  */
 352
 353 static int
 354 lkopen_dot (char *file, int access, mode_t mode)
 355 {
 356     int fd;
 357     struct lockinfo lkinfo;
 358
 359     /* open the file */
 360     if ((fd = open (file, access, mode)) == -1)
 361         return -1;
 362
 363     /*
 364      * Get the name of the eventual lock file, as well
 365      * as a name for a temporary lock file.
 366      */
 367     lockname (file, &lkinfo, 1);
 368
 369 #if !defined(HAVE_LIBLOCKFILE)
 370     {
 371         int i;
 372         for (i = 0;;) {
 373             /* attempt to create lock file */
 374             if (lockit (&lkinfo) == 0) {
 375                 /* if successful, turn on timer and return */
 376                 timerON (lkinfo.curlock, fd);
 377                 return fd;
 378             } else {
 379                 /*
 380                  * Abort locking, if we fail to lock after 5 attempts
 381                  * and are never able to stat the lock file.
 382                  */
 383                 struct stat st;
 384                 if (stat (lkinfo.curlock, &st) == -1) {
 385                     if (i++ > 5)
 386                         return -1;
 387                     sleep (5);
 388                 } else {
 389                     time_t curtime;
 390                     i = 0;
 391                     time (&curtime);
 392
 393                     /* check for stale lockfile, else sleep */
 394                     if (curtime > st.st_ctime + RSECS)
 395                         unlink (lkinfo.curlock);
 396                     else
 397                         sleep (5);
 398                 }
 399                 lockname (file, &lkinfo, 1);
 400             }
 401         }
 402     }
 403 #else
 404     if (lockfile_create(lkinfo.curlock, 5, 0) == L_SUCCESS) {
 405         timerON(lkinfo.curlock, fd);
 406         return fd;
 407     }
 408     else {
 409         close(fd);
 410         return -1;
 411     }
 412 #endif /* HAVE_LIBLOCKFILE */
 413 }
 414
 415 #if !defined(HAVE_LIBLOCKFILE)
 416 /*
 417  * Routine that actually tries to create
 418  * the lock file.
 419  */
 420
 421 static int
 422 lockit (struct lockinfo *li)
 423 {
 424     int fd;
 425     char *curlock, *tmplock;
 426
 427 #if 0
 428     char buffer[128];
 429 #endif
 430
 431     curlock = li->curlock;
 432     tmplock = li->tmplock;
 433
 434     if ((fd = mkstemp(tmplock)) == -1)
 435         return -1;
 436
 437 #if 0
 438     /* write our process id into lock file */
 439     snprintf (buffer, sizeof(buffer), "nmh lock: pid %d\n", (int) getpid());
 440     write(fd, buffer, strlen(buffer) + 1);
 441 #endif
 442
 443     close (fd);
 444
 445     /*
 446      * Now try to create the real lock file
 447      * by linking to the temporary file.
 448      */
 449     fd = link(tmplock, curlock);
 450     unlink(tmplock);
 451
 452     return (fd == -1 ? -1 : 0);
 453 }
 454 #endif /* HAVE_LIBLOCKFILE */
 455
 456 /*
 457  * Get name of lock file, and temporary lock file
 458  */
 459
 460 static void
 461 lockname (char *file, struct lockinfo *li, int isnewlock)
 462 {
 463     int bplen, tmplen;
 464     char *bp, *cp;
 465
 466 #if 0
 467     struct stat st;
 468 #endif
 469
 470     if ((cp = strrchr (file, '/')) == NULL || *++cp == 0)
 471         cp = file;
 472
 473     bp = li->curlock;
 474     bplen = 0;
 475 #ifdef LOCKDIR
 476     snprintf (bp, sizeof(li->curlock), "%s/", lockdir);
 477     tmplen = strlen (bp);
 478     bp    += tmplen;
 479     bplen += tmplen;
 480 #else
 481     if (cp != file) {
 482         snprintf (bp, sizeof(li->curlock), "%.*s", (int)(cp - file), file);
 483         tmplen = strlen (bp);
 484         bp    += tmplen;
 485         bplen += tmplen;
 486     }
 487 #endif
 488
 489 #if 0
 490     /*
 491      * mmdf style dot locking.  Currently not supported.
 492      * If we start supporting mmdf style dot locking,
 493      * we will need to change the return value of lockname
 494      */
 495     if (stat (file, &st) == -1)
 496         return -1;
 497
 498     snprintf (bp, sizeof(li->curlock) - bplen, "LCK%05d.%05d",
 499         st.st_dev, st.st_ino);
 500 #endif
 501
 502     snprintf (bp, sizeof(li->curlock) - bplen, "%s.lock", cp);
 503
 504 #if !defined(HAVE_LIBLOCKFILE)
 505     /*
 506      * If this is for a new lock, create a name for
 507      * the temporary lock file for lockit()
 508      */
 509     if (isnewlock) {
 510         if ((cp = strrchr (li->curlock, '/')) == NULL || *++cp == 0)
 511             strncpy (li->tmplock, ",LCK.XXXXXX", sizeof(li->tmplock));
 512         else
 513             snprintf (li->tmplock, sizeof(li->tmplock), "%.*s,LCK.XXXXXX",
 514                      (int)(cp - li->curlock), li->curlock);
 515     }
 516 #endif
 517 }
 518
 519
 520 /*
 521  * Add new lockfile to the list of open lockfiles
 522  * and start the lock file timer.
 523  */
 524
 525 static void
 526 timerON (char *curlock, int fd)
 527 {
 528     struct lock *lp;
 529     size_t len;
 530
 531     lp = (struct lock *) mh_xmalloc (sizeof(*lp));
 532
 533     len = strlen(curlock) + 1;
 534     lp->l_fd = fd;
 535     lp->l_lock = mh_xmalloc (len);
 536     memcpy (lp->l_lock, curlock, len);
 537     lp->l_next = l_top;
 538
 539     if (!l_top) {
 540         /* perhaps SIGT{STP,TIN,TOU} ? */
 541         SIGNAL (SIGALRM, alrmser);
 542         alarm (NSECS);
 543     }
 544
 545     l_top = lp;
 546 }
 547
 548
 549 /*
 550  * Search through the list of lockfiles for the
 551  * current lockfile, and remove it from the list.
 552  */
 553
 554 static void
 555 timerOFF (int fd)
 556 {
 557     struct lock *pp, *lp;
 558
 559     alarm(0);
 560
 561     if (l_top) {
 562         for (pp = lp = l_top; lp; pp = lp, lp = lp->l_next) {
 563             if (lp->l_fd == fd)
 564                 break;
 565         }
 566         if (lp) {
 567             if (lp == l_top)
 568                 l_top = lp->l_next;
 569             else
 570                 pp->l_next = lp->l_next;
 571
 572             free (lp->l_lock);
 573             free (lp);
 574         }
 575     }
 576
 577     /* if there are locks left, restart timer */
 578     if (l_top)
 579         alarm (NSECS);
 580 }
 581
 582
 583 /*
 584  * If timer goes off, we update the ctime of all open
 585  * lockfiles, so another command doesn't remove them.
 586  */
 587
 588 static RETSIGTYPE
 589 alrmser (int sig)
 590 {
 591     char *lockfile;
 592     struct lock *lp;
 593
 594 #ifndef RELIABLE_SIGNALS
 595     SIGNAL (SIGALRM, alrmser);
 596 #endif
 597
 598     /* update the ctime of all the lock files */
 599     for (lp = l_top; lp; lp = lp->l_next) {
 600         lockfile = lp->l_lock;
 601 #if !defined(HAVE_LIBLOCKFILE)
 602         {
 603             int j;
 604             if (*lockfile && (j = creat (lockfile, 0600)) != -1)
 605                 close (j);
 606         }
 607 #else
 608     lockfile_touch(lockfile);
 609 #endif
 610     }
 611
 612     /* restart the alarm */
 613     alarm (NSECS);
 614 }
 615
 616 #endif /* DOT_LOCKING */