git.marmaro.de Git - mmh/blob - sbr/lock_file.c

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