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 #include <h/mts.h>
  22
  23 #ifdef HAVE_SYS_TIME_H
  24 # include <sys/time.h>
  25 #endif
  26 #include <time.h>
  27 #include <fcntl.h>
  28 #ifdef HAVE_FLOCK
  29 # include <sys/file.h>
  30 #endif
  31
  32 #if defined(HAVE_LIBLOCKFILE)
  33 # include <lockfile.h>
  34 #endif
  35
  36 #ifdef LOCKDIR
  37 char *lockdir = LOCKDIR;
  38 #endif
  39
  40 /* struct for getting name of lock file to create */
  41 struct lockinfo {
  42     char curlock[BUFSIZ];
  43 #if !defined(HAVE_LIBLOCKFILE)
  44     char tmplock[BUFSIZ];
  45 #endif
  46 };
  47
  48 /*
  49  * Number of tries to retry locking
  50  */
  51 #define LOCK_RETRIES 60
  52
  53 /*
  54  * Amount of time to wait before
  55  * updating ctime of lock file.
  56  */
  57 #define NSECS 20
  58
  59 #if !defined(HAVE_LIBLOCKFILE)
  60 /*
  61  * How old does a lock file need to be
  62  * before we remove it.
  63  */
  64 #define RSECS 180
  65 #endif /* HAVE_LIBLOCKFILE */
  66
  67 /* struct for recording and updating locks */
  68 struct lock {
  69     int l_fd;
  70     char *l_lock;
  71     struct lock *l_next;
  72 };
  73
  74 enum locktype { FCNTL_LOCKING, FLOCK_LOCKING, LOCKF_LOCKING, DOT_LOCKING };
  75
  76 /*
  77  * Flags to indicate whether we've initialized the lock types, and
  78  * our saved lock types
  79  */
  80 static int datalockinit = 0;
  81 static int spoollockinit = 0;
  82 static enum locktype datalocktype, spoollocktype;
  83
  84
  85 /* top of list containing all open locks */
  86 static struct lock *l_top = NULL;
  87
  88 static int lkopen(const char *, int, mode_t, enum locktype, int *);
  89 static int str2accbits(const char *);
  90
  91 static int lkopen_fcntl (const char *, int, mode_t, int *);
  92 #ifdef HAVE_LOCKF
  93 static int lkopen_lockf (const char *, int, mode_t, int *);
  94 #endif /* HAVE_LOCKF */
  95 #ifdef HAVE_FLOCK
  96 static int lkopen_flock (const char *, int, mode_t, int *);
  97 #endif /* HAVE_FLOCK */
  98
  99 static enum locktype init_locktype(const char *);
 100
 101 static int lkopen_dot (const char *, int, mode_t, int *);
 102 static void lkclose_dot (int, const char *);
 103 static void lockname (const char *, struct lockinfo *, int);
 104 static void timerON (char *, int);
 105 static void timerOFF (int);
 106 static void alrmser (int);
 107
 108 #if !defined(HAVE_LIBLOCKFILE)
 109 static int lockit (struct lockinfo *);
 110 #endif
 111
 112 /*
 113  * Base functions: determine the data type used to lock files and
 114  * call the underlying function.
 115  */
 116
 117 int
 118 lkopendata(const char *file, int access, mode_t mode, int *failed_to_lock)
 119 {
 120     if (! datalockinit) {
 121         char *cp = context_find("datalocking");
 122
 123         if (cp) {
 124             datalocktype = init_locktype(cp);
 125         } else {
 126             /* We default to fcntl locking for data files */
 127             datalocktype = FCNTL_LOCKING;
 128         }
 129
 130         datalockinit = 1;
 131     }
 132
 133     return lkopen(file, access, mode, datalocktype, failed_to_lock);
 134 }
 135
 136
 137 /*
 138  * Locking using the spool locking algorithm
 139  */
 140
 141 int lkopenspool(const char *file, int access, mode_t mode, int *failed_to_lock)
 142 {
 143     if (! spoollockinit) {
 144         spoollocktype = init_locktype(spoollocking);
 145
 146         spoollockinit = 1;
 147     }
 148
 149     return lkopen(file, access, mode, spoollocktype, failed_to_lock);
 150 }
 151
 152
 153 /*
 154  * Versions of lkopen that return a FILE *
 155  */
 156
 157 FILE *
 158 lkfopendata(const char *file, const char *mode, int *failed_to_lock)
 159 {
 160     FILE *fp;
 161     int oflags = str2accbits(mode);
 162     int fd;
 163
 164     if (oflags == -1) {
 165         errno = EINVAL;
 166         return NULL;
 167     }
 168
 169     if ((fd = lkopendata(file, oflags, 0666, failed_to_lock)) == -1)
 170         return NULL;
 171
 172     if ((fp = fdopen (fd, mode)) == NULL) {
 173         close (fd);
 174         return NULL;
 175     }
 176
 177     return fp;
 178 }
 179
 180 FILE *
 181 lkfopenspool(const char *file, const char *mode)
 182 {
 183     FILE *fp;
 184     int oflags = str2accbits(mode);
 185     int failed_to_lock = 0;
 186     int fd;
 187
 188     if (oflags == -1) {
 189         errno = EINVAL;
 190         return NULL;
 191     }
 192
 193     if ((fd = lkopenspool(file, oflags, 0666, &failed_to_lock)) == -1)
 194         return NULL;
 195
 196     if ((fp = fdopen (fd, mode)) == NULL) {
 197         close (fd);
 198         return NULL;
 199     }
 200
 201     return fp;
 202 }
 203
 204
 205 /*
 206  * Corresponding close functions.
 207  *
 208  * A note here: All of the kernel locking functions terminate the lock
 209  * when the descriptor is closed, so why write the code to explicitly
 210  * unlock the file?  We only need to do this in the dot-locking case.
 211  */
 212
 213 int
 214 lkclosedata(int fd, const char *name)
 215 {
 216     int rc = close(fd);
 217
 218     if (datalocktype == DOT_LOCKING)
 219         lkclose_dot(fd, name);
 220
 221     return rc;
 222 }
 223
 224 int
 225 lkfclosedata(FILE *f, const char *name)
 226 {
 227     int fd, rc;
 228
 229     if (f == NULL)
 230         return 0;
 231
 232     fd = fileno(f);
 233     rc = fclose(f);
 234
 235     if (datalocktype == DOT_LOCKING)
 236         lkclose_dot(fd, name);
 237
 238     return rc;
 239 }
 240
 241 int
 242 lkclosespool(int fd, const char *name)
 243 {
 244     int rc = close(fd);
 245
 246     if (spoollocktype == DOT_LOCKING)
 247         lkclose_dot(fd, name);
 248
 249     return rc;
 250 }
 251
 252 int
 253 lkfclosespool(FILE *f, const char *name)
 254 {
 255     int fd, rc;
 256
 257     if (f == NULL)
 258         return 0;
 259
 260     fd = fileno(f);
 261     rc = fclose(f);
 262
 263     if (spoollocktype == DOT_LOCKING)
 264         lkclose_dot(fd, name);
 265
 266     return rc;
 267 }
 268
 269
 270 /*
 271  * Convert fopen() mode argument to open() bits
 272  */
 273
 274 static int
 275 str2accbits(const char *mode)
 276 {
 277     if (strcmp (mode, "r") == 0)
 278         return O_RDONLY;
 279     else if (strcmp (mode, "r+") == 0)
 280         return O_RDWR;
 281     else if (strcmp (mode, "w") == 0)
 282         return O_WRONLY | O_CREAT | O_TRUNC;
 283     else if (strcmp (mode, "w+") == 0)
 284         return O_RDWR | O_CREAT | O_TRUNC;
 285     else if (strcmp (mode, "a") == 0)
 286         return O_WRONLY | O_CREAT | O_APPEND;
 287     else if (strcmp (mode, "a+") == 0)
 288         return O_RDWR | O_CREAT | O_APPEND;
 289     else {
 290         errno = EINVAL;
 291         return -1;
 292     }
 293 }
 294
 295 /*
 296  * Internal routine to switch between different locking types.
 297  */
 298
 299 static int
 300 lkopen (const char *file, int access, mode_t mode, enum locktype ltype,
 301         int *failed_to_lock)
 302 {
 303     switch (ltype) {
 304
 305     case FCNTL_LOCKING:
 306         return lkopen_fcntl(file, access, mode, failed_to_lock);
 307
 308     case DOT_LOCKING:
 309         return lkopen_dot(file, access, mode, failed_to_lock);
 310
 311 #ifdef HAVE_FLOCK
 312     case FLOCK_LOCKING:
 313         return lkopen_flock(file, access, mode, failed_to_lock);
 314 #endif /* HAVE_FLOCK */
 315
 316 #ifdef HAVE_LOCKF
 317     case LOCKF_LOCKING:
 318         return lkopen_lockf(file, access, mode, failed_to_lock);
 319 #endif /* HAVE_FLOCK */
 320
 321     default:
 322         adios(NULL, "Internal locking error: unsupported lock type used!");
 323     }
 324
 325     return -1;
 326 }
 327
 328
 329 /*
 330  * Routine to clean up the dot locking file
 331  */
 332
 333 static void
 334 lkclose_dot (int fd, const char *file)
 335 {
 336     struct lockinfo lkinfo;
 337
 338     lockname (file, &lkinfo, 0);        /* get name of lock file */
 339 #if !defined(HAVE_LIBLOCKFILE)
 340     (void) m_unlink (lkinfo.curlock);   /* remove lock file      */
 341 #else
 342     lockfile_remove(lkinfo.curlock);
 343 #endif /* HAVE_LIBLOCKFILE */
 344     timerOFF (fd);                      /* turn off lock timer   */
 345 }
 346
 347
 348 /*
 349  * Open and lock a file, using fcntl locking
 350  */
 351
 352 static int
 353 lkopen_fcntl(const char *file, int access, mode_t mode, int *failed_to_lock)
 354 {
 355     int fd, i, saved_errno;
 356     struct flock flk;
 357
 358     /*
 359      * The assumption here is that if you open the file for writing, you
 360      * need an exclusive lock.
 361      */
 362
 363     for (i = 0; i < LOCK_RETRIES; i++) {
 364         if ((fd = open(file, access, mode)) == -1)
 365             return -1;
 366
 367         flk.l_start = 0;
 368         flk.l_len = 0;
 369         flk.l_type = (access & O_ACCMODE) == O_RDONLY ? F_RDLCK : F_WRLCK;
 370         flk.l_whence = SEEK_SET;
 371
 372         if (fcntl(fd, F_SETLK, &flk) != -1)
 373             return fd;
 374
 375         saved_errno = errno;
 376         close(fd);
 377         sleep(1);
 378     }
 379
 380     *failed_to_lock = 1;
 381     errno = saved_errno;
 382     return -1;
 383 }
 384
 385
 386 #ifdef HAVE_FLOCK
 387 /*
 388  * Open and lock a file, using flock locking
 389  */
 390
 391 static int
 392 lkopen_flock(const char *file, int access, mode_t mode, int *failed_to_lock)
 393 {
 394     int fd, i, saved_errno, locktype;
 395
 396     /*
 397      * The assumption here is that if you open the file for writing, you
 398      * need an exclusive lock.
 399      */
 400
 401     locktype = (((access & O_ACCMODE) == O_RDONLY) ? LOCK_SH : LOCK_EX) |
 402                                                         LOCK_NB;
 403
 404     for (i = 0; i < LOCK_RETRIES; i++) {
 405         if ((fd = open(file, access, mode)) == -1)
 406             return -1;
 407
 408         if (flock(fd, locktype) != -1)
 409             return fd;
 410
 411         saved_errno = errno;
 412         close(fd);
 413         sleep(1);
 414     }
 415
 416     *failed_to_lock = 1;
 417     errno = saved_errno;
 418     return -1;
 419 }
 420 #endif /* HAVE_FLOCK */
 421
 422 /*
 423  * Open and lock a file, using lockf locking
 424  */
 425
 426 static int
 427 lkopen_lockf(const char *file, int access, mode_t mode, int *failed_to_lock)
 428 {
 429     int fd, i, saved_errno, saved_access;
 430
 431     /*
 432      * Two notes:
 433      *
 434      * Because lockf locks start from the current offset, mask off O_APPEND
 435      * and seek to the end of the file later if it was requested.
 436      *
 437      * lockf locks require write access to the file, so always add it
 438      * even if it wasn't requested.
 439      */
 440
 441     saved_access = access;
 442
 443     access &= ~O_APPEND;
 444
 445     if ((access & O_ACCMODE) == O_RDONLY) {
 446         access &= ~O_RDONLY;
 447         access |= O_RDWR;
 448     }
 449
 450     for (i = 0; i < LOCK_RETRIES; i++) {
 451         if ((fd = open(file, access, mode)) == -1)
 452             return -1;
 453
 454         if (lockf(fd, F_TLOCK, 0) != -1) {
 455             /*
 456              * Seek to end if requested
 457              */
 458             if (saved_access & O_APPEND) {
 459                 lseek(fd, 0, SEEK_END);
 460             }
 461             return fd;
 462         }
 463
 464         saved_errno = errno;
 465         close(fd);
 466         sleep(1);
 467     }
 468
 469     *failed_to_lock = 1;
 470     errno = saved_errno;
 471     return -1;
 472 }
 473
 474
 475 /*
 476  * open and lock a file, using dot locking
 477  */
 478
 479 static int
 480 lkopen_dot (const char *file, int access, mode_t mode, int *failed_to_lock)
 481 {
 482     int fd;
 483     struct lockinfo lkinfo;
 484
 485     /* open the file */
 486     if ((fd = open (file, access, mode)) == -1)
 487         return -1;
 488
 489     /*
 490      * Get the name of the eventual lock file, as well
 491      * as a name for a temporary lock file.
 492      */
 493     lockname (file, &lkinfo, 1);
 494
 495 #if !defined(HAVE_LIBLOCKFILE)
 496     {
 497         int i;
 498         for (i = 0; i < LOCK_RETRIES; ++i) {
 499             /* attempt to create lock file */
 500             if (lockit (&lkinfo) == 0) {
 501                 /* if successful, turn on timer and return */
 502                 timerON (lkinfo.curlock, fd);
 503                 return fd;
 504             } else {
 505                 /*
 506                  * Abort locking, if we fail to lock after 5 attempts
 507                  * and are never able to stat the lock file.  Or, if
 508                  * we can stat the lockfile but exceed LOCK_RETRIES
 509                  * seconds waiting for it (by falling out of the loop).
 510                  */
 511                 struct stat st;
 512                 if (stat (lkinfo.curlock, &st) == -1) {
 513                     if (i++ > 5) break;
 514                     sleep (1);
 515                 } else {
 516                     time_t curtime;
 517                     time (&curtime);
 518
 519                     /* check for stale lockfile, else sleep */
 520                     if (curtime > st.st_ctime + RSECS)
 521                         (void) m_unlink (lkinfo.curlock);
 522                     else
 523                         sleep (1);
 524                 }
 525                 lockname (file, &lkinfo, 1);
 526             }
 527         }
 528
 529         *failed_to_lock = 1;
 530         return -1;
 531     }
 532 #else
 533     if (lockfile_create(lkinfo.curlock, 5, 0) == L_SUCCESS) {
 534         timerON(lkinfo.curlock, fd);
 535         return fd;
 536     }
 537     else {
 538         close(fd);
 539         *failed_to_lock = 1;
 540         return -1;
 541     }
 542 #endif /* HAVE_LIBLOCKFILE */
 543 }
 544
 545 #if !defined(HAVE_LIBLOCKFILE)
 546 /*
 547  * Routine that actually tries to create
 548  * the lock file.
 549  */
 550
 551 static int
 552 lockit (struct lockinfo *li)
 553 {
 554     int fd;
 555     char *curlock, *tmpfile;
 556
 557 #if 0
 558     char buffer[128];
 559 #endif
 560
 561     curlock = li->curlock;
 562
 563     if ((tmpfile = m_mktemp(li->tmplock, &fd, NULL)) == NULL) {
 564         advise(NULL, "unable to create temporary file in %s", li->tmplock);
 565         return -1;
 566     }
 567
 568 #if 0
 569     /* write our process id into lock file */
 570     snprintf (buffer, sizeof(buffer), "nmh lock: pid %d\n", (int) getpid());
 571     write(fd, buffer, strlen(buffer) + 1);
 572 #endif
 573
 574     close (fd);
 575
 576     /*
 577      * Now try to create the real lock file
 578      * by linking to the temporary file.
 579      */
 580     fd = link(tmpfile, curlock);
 581     (void) m_unlink(tmpfile);
 582
 583     return (fd == -1 ? -1 : 0);
 584 }
 585 #endif /* HAVE_LIBLOCKFILE */
 586
 587 /*
 588  * Get name of lock file, and temporary lock file
 589  */
 590
 591 static void
 592 lockname (const char *file, struct lockinfo *li, int isnewlock)
 593 {
 594     int bplen, tmplen;
 595     char *bp;
 596     const char *cp;
 597
 598 #if 0
 599     struct stat st;
 600 #endif
 601
 602     if ((cp = strrchr (file, '/')) == NULL || *++cp == 0)
 603         cp = file;
 604
 605     bp = li->curlock;
 606     bplen = 0;
 607 #ifdef LOCKDIR
 608     snprintf (bp, sizeof(li->curlock), "%s/", lockdir);
 609     tmplen = strlen (bp);
 610     bp    += tmplen;
 611     bplen += tmplen;
 612 #else
 613     if (cp != file) {
 614         snprintf (bp, sizeof(li->curlock), "%.*s", (int)(cp - file), file);
 615         tmplen = strlen (bp);
 616         bp    += tmplen;
 617         bplen += tmplen;
 618     }
 619 #endif
 620
 621 #if 0
 622     /*
 623      * mmdf style dot locking.  Currently not supported.
 624      * If we start supporting mmdf style dot locking,
 625      * we will need to change the return value of lockname
 626      */
 627     if (stat (file, &st) == -1)
 628         return -1;
 629
 630     snprintf (bp, sizeof(li->curlock) - bplen, "LCK%05d.%05d",
 631         st.st_dev, st.st_ino);
 632 #endif
 633
 634     snprintf (bp, sizeof(li->curlock) - bplen, "%s.lock", cp);
 635
 636 #if !defined(HAVE_LIBLOCKFILE)
 637     /*
 638      * If this is for a new lock, create a name for
 639      * the temporary lock file for lockit()
 640      */
 641     if (isnewlock) {
 642         if ((cp = strrchr (li->curlock, '/')) == NULL || *++cp == 0)
 643             strncpy (li->tmplock, ",LCK.XXXXXX", sizeof(li->tmplock));
 644         else
 645             snprintf (li->tmplock, sizeof(li->tmplock), "%.*s,LCK.XXXXXX",
 646                      (int)(cp - li->curlock), li->curlock);
 647     }
 648 #endif
 649 }
 650
 651
 652 /*
 653  * Add new lockfile to the list of open lockfiles
 654  * and start the lock file timer.
 655  */
 656
 657 static void
 658 timerON (char *curlock, int fd)
 659 {
 660     struct lock *lp;
 661     size_t len;
 662
 663     lp = (struct lock *) mh_xmalloc (sizeof(*lp));
 664
 665     len = strlen(curlock) + 1;
 666     lp->l_fd = fd;
 667     lp->l_lock = mh_xmalloc (len);
 668     memcpy (lp->l_lock, curlock, len);
 669     lp->l_next = l_top;
 670
 671     if (!l_top) {
 672         /* perhaps SIGT{STP,TIN,TOU} ? */
 673         SIGNAL (SIGALRM, alrmser);
 674         alarm (NSECS);
 675     }
 676
 677     l_top = lp;
 678 }
 679
 680
 681 /*
 682  * Search through the list of lockfiles for the
 683  * current lockfile, and remove it from the list.
 684  */
 685
 686 static void
 687 timerOFF (int fd)
 688 {
 689     struct lock *pp, *lp;
 690
 691     alarm(0);
 692
 693     if (l_top) {
 694         for (pp = lp = l_top; lp; pp = lp, lp = lp->l_next) {
 695             if (lp->l_fd == fd)
 696                 break;
 697         }
 698         if (lp) {
 699             if (lp == l_top)
 700                 l_top = lp->l_next;
 701             else
 702                 pp->l_next = lp->l_next;
 703
 704             free (lp->l_lock);
 705             free (lp);
 706         }
 707     }
 708
 709     /* if there are locks left, restart timer */
 710     if (l_top)
 711         alarm (NSECS);
 712 }
 713
 714
 715 /*
 716  * If timer goes off, we update the ctime of all open
 717  * lockfiles, so another command doesn't remove them.
 718  */
 719
 720 static void
 721 alrmser (int sig)
 722 {
 723     char *lockfile;
 724     struct lock *lp;
 725     NMH_UNUSED (sig);
 726
 727     /* update the ctime of all the lock files */
 728     for (lp = l_top; lp; lp = lp->l_next) {
 729         lockfile = lp->l_lock;
 730 #if !defined(HAVE_LIBLOCKFILE)
 731         {
 732             int j;
 733             if (*lockfile && (j = creat (lockfile, 0600)) != -1)
 734                 close (j);
 735         }
 736 #else
 737     lockfile_touch(lockfile);
 738 #endif
 739     }
 740
 741     /* restart the alarm */
 742     alarm (NSECS);
 743 }
 744
 745
 746 /*
 747  * Return a locking algorithm based on the string name
 748  */
 749
 750 static enum locktype
 751 init_locktype(const char *lockname)
 752 {
 753     if (strcasecmp(lockname, "fcntl") == 0) {
 754         return FCNTL_LOCKING;
 755     } else if (strcasecmp(lockname, "lockf") == 0) {
 756 #ifdef HAVE_LOCKF
 757         return LOCKF_LOCKING;
 758 #else /* ! HAVE_LOCKF */
 759         adios(NULL, "lockf not supported on this system");
 760 #endif /* HAVE_LOCKF */
 761     } else if (strcasecmp(lockname, "flock") == 0) {
 762 #ifdef HAVE_FLOCK
 763         return FLOCK_LOCKING;
 764 #else /* ! HAVE_FLOCK */
 765         adios(NULL, "flock not supported on this system");
 766 #endif /* HAVE_FLOCK */
 767     } else if (strcasecmp(lockname, "dot") == 0) {
 768         return DOT_LOCKING;
 769     } else {
 770         adios(NULL, "Unknown lock type: \"%s\"", lockname);
 771         /* NOTREACHED */
 772         return 0;
 773     }
 774 }