src/src/exim_lock.c

   1 /* A program to lock a file exactly as Exim would, for investigation of
   2 interlocking problems.
   3
   4 Options:  -fcntl    use fcntl() lock
   5           -flock    use flock() lock
   6           -lockfile use lock file
   7           -mbx      use mbx locking rules, with either fcntl() or flock()
   8
   9 Default is -fcntl -lockfile.
  10
  11 Argument: the name of the lock file
  12
  13 Copyright (c) The Exim Maintainers 2016
  14 */
  15
  16 #include "os.h"
  17
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <signal.h>
  22 #include <errno.h>
  23 #include <time.h>
  24 #include <netdb.h>
  25 #include <fcntl.h>
  26 #include <unistd.h>
  27 #include <utime.h>
  28 #include <sys/utsname.h>
  29 #include <sys/stat.h>
  30 #include <sys/file.h>
  31 #include <pwd.h>
  32
  33 /* Not all systems have flock() available. Those that do must define LOCK_SH
  34 in sys/file.h. */
  35
  36 #ifndef LOCK_SH
  37 #define NO_FLOCK
  38 #endif
  39
  40
  41 typedef unsigned BOOL;
  42 #define FALSE 0
  43 #define TRUE  1
  44
  45
  46 /* Flag for timeout signal handler */
  47
  48 static int sigalrm_seen = FALSE;
  49
  50
  51 /* We need to pull in strerror() and os_non_restarting_signal() from the
  52 os.c source, if they are required for this OS. However, we don't need any of
  53 the other stuff in os.c, so force the other macros to omit it. */
  54
  55 #ifndef OS_RESTARTING_SIGNAL
  56   #define OS_RESTARTING_SIGNAL
  57 #endif
  58
  59 #ifndef OS_STRSIGNAL
  60   #define OS_STRSIGNAL
  61 #endif
  62
  63 #ifndef OS_STREXIT
  64   #define OS_STREXIT
  65 #endif
  66
  67 #ifndef OS_LOAD_AVERAGE
  68   #define OS_LOAD_AVERAGE
  69 #endif
  70
  71 #ifndef FIND_RUNNING_INTERFACES
  72   #define FIND_RUNNING_INTERFACES
  73 #endif
  74
  75 #ifndef OS_GET_DNS_RESOLVER_RES
  76   #define OS_GET_DNS_RESOLVER_RES
  77 #endif
  78
  79 #include "../src/os.c"
  80
  81
  82
  83 /*************************************************
  84 *             Timeout handler                    *
  85 *************************************************/
  86
  87 static void
  88 sigalrm_handler(int sig)
  89 {
  90 sigalrm_seen = TRUE;
  91 }
  92
  93
  94
  95 /*************************************************
  96 *           Give usage and die                   *
  97 *************************************************/
  98
  99 static void
 100 usage(void)
 101 {
 102 printf("usage: exim_lock [-v] [-q] [-lockfile] [-fcntl] [-flock] [-mbx]\n"
 103        "       [-retries <n>] [-interval <n>] [-timeout <n>] [-restore-times]\n"
 104        "       <file name> [command]\n");
 105 exit(1);
 106 }
 107
 108
 109
 110 /*************************************************
 111 *         Apply a lock to a file descriptor      *
 112 *************************************************/
 113
 114 static int
 115 apply_lock(int fd, int fcntltype, BOOL dofcntl, int fcntltime, BOOL doflock,
 116     int flocktime)
 117 {
 118 int yield = 0;
 119 int save_errno;
 120 struct flock lock_data;
 121 lock_data.l_type = fcntltype;
 122 lock_data.l_whence = lock_data.l_start = lock_data.l_len = 0;
 123
 124 sigalrm_seen = FALSE;
 125
 126 if (dofcntl)
 127   {
 128   if (fcntltime > 0)
 129     {
 130     os_non_restarting_signal(SIGALRM, sigalrm_handler);
 131     alarm(fcntltime);
 132     yield = fcntl(fd, F_SETLKW, &lock_data);
 133     save_errno = errno;
 134     alarm(0);
 135     errno = save_errno;
 136     }
 137   else yield = fcntl(fd, F_SETLK, &lock_data);
 138   if (yield < 0) printf("exim_lock: fcntl() failed: %s\n", strerror(errno));
 139   }
 140
 141 #ifndef NO_FLOCK
 142 if (doflock && (yield >= 0))
 143   {
 144   int flocktype = (fcntltype == F_WRLCK)? LOCK_EX : LOCK_SH;
 145   if (flocktime > 0)
 146     {
 147     os_non_restarting_signal(SIGALRM, sigalrm_handler);
 148     alarm(flocktime);
 149     yield = flock(fd, flocktype);
 150     save_errno = errno;
 151     alarm(0);
 152     errno = save_errno;
 153     }
 154   else yield = flock(fd, flocktype | LOCK_NB);
 155   if (yield < 0) printf("exim_lock: flock() failed: %s\n", strerror(errno));
 156   }
 157 #endif
 158
 159 return yield;
 160 }
 161
 162
 163
 164 /*************************************************
 165 *           The exim_lock program                *
 166 *************************************************/
 167
 168 int main(int argc, char **argv)
 169 {
 170 int  lock_retries = 10;
 171 int  lock_interval = 3;
 172 int  lock_fcntl_timeout = 0;
 173 int  lock_flock_timeout = 0;
 174 int  i, j, len;
 175 int  fd = -1;
 176 int  hd = -1;
 177 int  md = -1;
 178 int  yield = 0;
 179 time_t now = time(NULL);
 180 BOOL use_lockfile = FALSE;
 181 BOOL use_fcntl = FALSE;
 182 BOOL use_flock = FALSE;
 183 BOOL use_mbx = FALSE;
 184 BOOL verbose = FALSE;
 185 BOOL quiet = FALSE;
 186 BOOL restore_times = FALSE;
 187 char *filename;
 188 char *lockname = NULL, *hitchname = NULL;
 189 char *primary_hostname;
 190 const char *command;
 191 struct utsname s;
 192 char buffer[256];
 193 char tempname[256];
 194
 195 /* Decode options */
 196
 197 for (i = 1; i < argc; i++)
 198   {
 199   char *arg = argv[i];
 200   if (*arg != '-') break;
 201   if (strcmp(arg, "-fcntl") == 0) use_fcntl = TRUE;
 202   else if (strcmp(arg, "-flock") == 0) use_flock = TRUE;
 203   else if (strcmp(arg, "-lockfile") == 0) use_lockfile = TRUE;
 204   else if (strcmp(arg, "-mbx") == 0) use_mbx = TRUE;
 205   else if (strcmp(arg, "-v") == 0) verbose = TRUE;
 206   else if (strcmp(arg, "-q") == 0) quiet = TRUE;
 207   else if (strcmp(arg, "-restore-times") == 0) restore_times = TRUE;
 208   else if (++i < argc)
 209     {
 210     int value = atoi(argv[i]);
 211     if (strcmp(arg, "-retries") == 0) lock_retries = value;
 212     else if (strcmp(arg, "-interval") == 0) lock_interval = value;
 213     else if (strcmp(arg, "-timeout") == 0)
 214       lock_fcntl_timeout = lock_flock_timeout = value;
 215     else usage();
 216     }
 217   else usage();
 218   }
 219
 220 if (quiet) verbose = FALSE;
 221
 222 /* Can't use flock() if the OS doesn't provide it */
 223
 224 #ifdef NO_FLOCK
 225 if (use_flock)
 226   {
 227   printf("exim_lock: can't use flock() because it was not available in the\n"
 228          "           operating system when exim_lock was compiled\n");
 229   exit(1);
 230   }
 231 #endif
 232
 233 /* Default is to use lockfiles and fcntl(). */
 234
 235 if (!use_lockfile && !use_fcntl && !use_flock && !use_mbx)
 236   use_lockfile = use_fcntl = TRUE;
 237
 238 /* Default fcntl() for use with mbx */
 239
 240 if (use_mbx && !use_fcntl && !use_flock) use_fcntl = TRUE;
 241
 242 /* Unset unused timeouts */
 243
 244 if (!use_fcntl) lock_fcntl_timeout = 0;
 245 if (!use_flock) lock_flock_timeout = 0;
 246
 247 /* A file name is required */
 248
 249 if (i >= argc) usage();
 250
 251 filename = argv[i++];
 252
 253 /* Expand file names starting with ~ */
 254
 255 if (*filename == '~')
 256   {
 257   struct passwd *pw;
 258
 259   if (*(++filename) == '/')
 260     pw = getpwuid(getuid());
 261   else
 262     {
 263     char *s = buffer;
 264     while (*filename != 0 && *filename != '/')
 265       *s++ = *filename++;
 266     *s = 0;
 267     pw = getpwnam(buffer);
 268     }
 269
 270   if (pw == NULL)
 271     {
 272     printf("exim_lock: unable to expand file name %s\n", argv[i-1]);
 273     exit(1);
 274     }
 275
 276   if ((int)strlen(pw->pw_dir) + (int)strlen(filename) + 1 > sizeof(buffer))
 277     {
 278     printf("exim_lock: expanded file name %s%s is too long", pw->pw_dir,
 279       filename);
 280     exit(1);
 281     }
 282
 283   strcpy(buffer, pw->pw_dir);
 284   strcat(buffer, filename);
 285   filename = buffer;
 286   }
 287
 288 /* If using a lock file, prepare by creating the lock file name and
 289 the hitching post name. */
 290
 291 if (use_lockfile)
 292   {
 293   if (uname(&s) < 0)
 294     {
 295     printf("exim_lock: failed to find host name using uname()\n");
 296     exit(1);
 297     }
 298   primary_hostname = s.nodename;
 299
 300   len = (int)strlen(filename);
 301   lockname = malloc(len + 8);
 302   sprintf(lockname, "%s.lock", filename);
 303   hitchname = malloc(len + 32 + (int)strlen(primary_hostname));
 304
 305   /* Presumably, this must match appendfile.c */
 306   sprintf(hitchname, "%s.%s.%08x.%08x", lockname, primary_hostname,
 307     (unsigned int)now, (unsigned int)getpid());
 308
 309   if (verbose)
 310     printf("exim_lock: lockname =  %s\n           hitchname = %s\n", lockname,
 311       hitchname);
 312   }
 313
 314 /* Locking retry loop */
 315
 316 for (j = 0; j < lock_retries; j++)
 317   {
 318   int sleep_before_retry = TRUE;
 319   struct stat statbuf, ostatbuf, lstatbuf, statbuf2;
 320   int mbx_tmp_oflags;
 321
 322   /* Try to build a lock file if so configured */
 323
 324   if (use_lockfile)
 325     {
 326     int rc, rc2;
 327     if (verbose) printf("exim_lock: creating lock file\n");
 328     hd = open(hitchname, O_WRONLY | O_CREAT | O_EXCL, 0440);
 329     if (hd < 0)
 330       {
 331       printf("exim_lock: failed to create hitching post %s: %s\n", hitchname,
 332         strerror(errno));
 333       exit(1);
 334       }
 335
 336     /* Apply hitching post algorithm. */
 337
 338     if ((rc = link(hitchname, lockname)) != 0)
 339      rc2 = fstat(hd, &statbuf);
 340     (void)close(hd);
 341     unlink(hitchname);
 342
 343     if (rc != 0 && (rc2 != 0 || statbuf.st_nlink != 2))
 344       {
 345       printf("exim_lock: failed to link hitching post to lock file\n");
 346       hd = -1;
 347       goto RETRY;
 348       }
 349
 350     if (!quiet) printf("exim_lock: lock file successfully created\n");
 351     }
 352
 353   /* We are done if no other locking required. */
 354
 355   if (!use_fcntl && !use_flock && !use_mbx) break;
 356
 357   /* Open the file for writing. */
 358
 359   if ((fd = open(filename, O_RDWR + O_APPEND)) < 0)
 360     {
 361     printf("exim_lock: failed to open %s for writing: %s\n", filename,
 362       strerror(errno));
 363     yield = 1;
 364     goto CLEAN_UP;
 365     }
 366
 367   /* If there is a timeout, implying blocked locking, we don't want to
 368   sleep before any retries after this. */
 369
 370   if (lock_fcntl_timeout > 0 || lock_flock_timeout > 0)
 371     sleep_before_retry = FALSE;
 372
 373   /* Lock using fcntl. There are pros and cons to using a blocking call vs
 374   a non-blocking call and retries. Exim is non-blocking by default, but setting
 375   a timeout changes it to blocking. */
 376
 377   if (!use_mbx && (use_fcntl || use_flock))
 378     if (apply_lock(fd, F_WRLCK, use_fcntl, lock_fcntl_timeout, use_flock,
 379         lock_flock_timeout) >= 0)
 380       {
 381       if (!quiet)
 382         {
 383         if (use_fcntl) printf("exim_lock: fcntl() lock successfully applied\n");
 384         if (use_flock) printf("exim_lock: flock() lock successfully applied\n");
 385         }
 386       break;
 387       }
 388     else
 389       goto RETRY;   /* Message already output */
 390
 391   /* Lock using MBX rules. This is complicated and is documented with the
 392   source of the c-client library that goes with Pine and IMAP. What has to
 393   be done to interwork correctly is to take out a shared lock on the mailbox,
 394   and an exclusive lock on a /tmp file. */
 395
 396   else
 397     {
 398     if (apply_lock(fd, F_RDLCK, use_fcntl, lock_fcntl_timeout, use_flock,
 399         lock_flock_timeout) >= 0)
 400       {
 401       if (!quiet)
 402         {
 403         if (use_fcntl)
 404           printf("exim_lock: fcntl() read lock successfully applied\n");
 405         if (use_flock)
 406           printf("exim_lock: fcntl() read lock successfully applied\n");
 407         }
 408       }
 409     else goto RETRY;   /* Message already output */
 410
 411     if (fstat(fd, &statbuf) < 0)
 412       {
 413       printf("exim_lock: fstat() of %s failed: %s\n", filename,
 414         strerror(errno));
 415       yield = 1;
 416       goto CLEAN_UP;
 417       }
 418
 419     /* Set up file in /tmp and check its state if already existing. */
 420
 421     sprintf(tempname, "/tmp/.%lx.%lx", (long)statbuf.st_dev,
 422       (long)statbuf.st_ino);
 423
 424     if (lstat(tempname, &statbuf) >= 0)
 425       {
 426       if ((statbuf.st_mode & S_IFMT) == S_IFLNK)
 427         {
 428         printf("exim_lock: symbolic link on lock name %s\n", tempname);
 429         yield = 1;
 430         goto CLEAN_UP;
 431         }
 432       if (statbuf.st_nlink > 1)
 433         {
 434         printf("exim_lock: hard link to lock name %s\n", tempname);
 435         yield = 1;
 436         goto CLEAN_UP;
 437         }
 438       }
 439
 440     mbx_tmp_oflags = O_RDWR | O_CREAT;
 441 #ifdef O_NOFOLLOW
 442     mbx_tmp_oflags |= O_NOFOLLOW;
 443 #endif
 444     md = open(tempname, mbx_tmp_oflags, 0600);
 445     if (md < 0)
 446       {
 447       printf("exim_lock: failed to create mbx lock file %s: %s\n",
 448         tempname, strerror(errno));
 449       goto CLEAN_UP;
 450       }
 451
 452     /* security fixes from 2010-05 */
 453     if (lstat(tempname, &lstatbuf) < 0)
 454       {
 455       printf("exim_lock: failed to lstat(%s) after opening it: %s\n",
 456           tempname, strerror(errno));
 457       goto CLEAN_UP;
 458       }
 459     if (fstat(md, &statbuf2) < 0)
 460       {
 461       printf("exim_lock: failed to fstat() open fd of \"%s\": %s\n",
 462           tempname, strerror(errno));
 463       goto CLEAN_UP;
 464       }
 465     if ((statbuf2.st_nlink > 1) ||
 466         (lstatbuf.st_nlink > 1) ||
 467         (!S_ISREG(lstatbuf.st_mode)) ||
 468         (lstatbuf.st_dev != statbuf2.st_dev) ||
 469         (lstatbuf.st_ino != statbuf2.st_ino))
 470       {
 471       printf("exim_lock: race condition exploited against us when "
 472           "locking \"%s\"\n", tempname);
 473       goto CLEAN_UP;
 474       }
 475
 476     (void)chmod(tempname, 0600);
 477
 478     if (apply_lock(md, F_WRLCK, use_fcntl, lock_fcntl_timeout, use_flock,
 479         lock_flock_timeout) >= 0)
 480       {
 481       if (!quiet)
 482         {
 483         if (use_fcntl)
 484           printf("exim_lock: fcntl() lock successfully applied to mbx "
 485             "lock file %s\n", tempname);
 486         if (use_flock)
 487           printf("exim_lock: flock() lock successfully applied to mbx "
 488             "lock file %s\n", tempname);
 489         }
 490
 491       /* This test checks for a race condition */
 492
 493       if (lstat(tempname, &statbuf) != 0 ||
 494           fstat(md, &ostatbuf) != 0 ||
 495           statbuf.st_dev != ostatbuf.st_dev ||
 496           statbuf.st_ino != ostatbuf.st_ino)
 497        {
 498        if (!quiet) printf("exim_lock: mbx lock file %s changed between "
 499            "creation and locking\n", tempname);
 500        goto RETRY;
 501        }
 502       else break;
 503       }
 504     else goto RETRY;   /* Message already output */
 505     }
 506
 507   /* Clean up before retrying */
 508
 509   RETRY:
 510
 511   if (md >= 0)
 512     {
 513     if (close(md) < 0)
 514       printf("exim_lock: close %s failed: %s\n", tempname, strerror(errno));
 515     else
 516       if (!quiet) printf("exim_lock: %s closed\n", tempname);
 517     md = -1;
 518     }
 519
 520   if (fd >= 0)
 521     {
 522     if (close(fd) < 0)
 523       printf("exim_lock: close failed: %s\n", strerror(errno));
 524     else
 525       if (!quiet) printf("exim_lock: file closed\n");
 526     fd = -1;
 527     }
 528
 529   if (hd >= 0)
 530     {
 531     if (unlink(lockname) < 0)
 532       printf("exim_lock: unlink of %s failed: %s\n", lockname, strerror(errno));
 533     else
 534       if (!quiet) printf("exim_lock: lock file removed\n");
 535     hd = -1;
 536     }
 537
 538   /* If a blocking call timed out, break the retry loop if the total time
 539   so far is not less than than retries * interval. */
 540
 541   if (sigalrm_seen &&
 542       (j + 1) * ((lock_fcntl_timeout > lock_flock_timeout)?
 543         lock_fcntl_timeout : lock_flock_timeout) >=
 544           lock_retries * lock_interval)
 545     j = lock_retries;
 546
 547   /* Wait a bit before retrying, except when it was a blocked fcntl() that
 548   caused the problem. */
 549
 550   if (j < lock_retries && sleep_before_retry)
 551     {
 552     printf(" ... waiting\n");
 553     sleep(lock_interval);
 554     }
 555   }
 556
 557 if (j >= lock_retries)
 558   {
 559   printf("exim_lock: locking failed too many times\n");
 560   yield = 1;
 561   goto CLEAN_UP;
 562   }
 563
 564 if (!quiet) printf("exim_lock: locking %s succeeded: ", filename);
 565
 566 /* If there are no further arguments, run the user's shell; otherwise
 567 the next argument is a command to run. */
 568
 569 if (i >= argc)
 570   {
 571   command = getenv("SHELL");
 572   if (command == NULL || *command == 0) command = "/bin/sh";
 573   if (!quiet) printf("running %s ...\n", command);
 574   }
 575 else
 576   {
 577   command = argv[i];
 578   if (!quiet) printf("running the command ...\n");
 579   }
 580
 581 /* Run the command, saving and restoring the times if required. */
 582
 583 if (restore_times)
 584   {
 585   struct stat strestore;
 586 #ifdef EXIM_HAVE_FUTIMENS
 587   int fd = open(filename, O_RDWR); /* use fd for both get & restore */
 588   struct timespec tt[2];
 589
 590   if (fd < 0)
 591     {
 592     printf("open '%s': %s\n", filename, strerror(errno));
 593     yield = 1;
 594     goto CLEAN_UP;
 595     }
 596   if (fstat(fd, &strestore) != 0)
 597     {
 598     printf("fstat '%s': %s\n", filename, strerror(errno));
 599     yield = 1;
 600     close(fd);
 601     goto CLEAN_UP;
 602     }
 603   i = system(command);
 604   tt[0] = strestore.st_atim;
 605   tt[1] = strestore.st_mtim;
 606   (void) futimens(fd, tt);
 607   (void) close(fd);
 608 #else
 609   struct utimbuf ut;
 610
 611   stat(filename, &strestore);
 612   i = system(command);
 613   ut.actime = strestore.st_atime;
 614   ut.modtime = strestore.st_mtime;
 615   utime(filename, &ut);
 616 #endif
 617   }
 618 else i = system(command);
 619
 620 if(i && !quiet) printf("warning: nonzero status %d\n", i);
 621
 622 /* Remove the locks and exit. Unlink the /tmp file if we can get an exclusive
 623 lock on the mailbox. This should be a non-blocking lock call, as there is no
 624 point in waiting. */
 625
 626 CLEAN_UP:
 627
 628 if (md >= 0)
 629   {
 630   if (apply_lock(fd, F_WRLCK, use_fcntl, 0, use_flock, 0) >= 0)
 631     {
 632     if (!quiet) printf("exim_lock: %s unlinked - no sharers\n", tempname);
 633     unlink(tempname);
 634     }
 635   else if (!quiet)
 636     printf("exim_lock: %s not unlinked - unable to get exclusive mailbox lock\n",
 637       tempname);
 638   if (close(md) < 0)
 639     printf("exim_lock: close %s failed: %s\n", tempname, strerror(errno));
 640   else
 641     if (!quiet) printf("exim_lock: %s closed\n", tempname);
 642   }
 643
 644 if (fd >= 0)
 645   {
 646   if (close(fd) < 0)
 647     printf("exim_lock: close %s failed: %s\n", filename, strerror(errno));
 648   else
 649     if (!quiet) printf("exim_lock: %s closed\n", filename);
 650   }
 651
 652 if (hd >= 0)
 653   {
 654   if (unlink(lockname) < 0)
 655     printf("exim_lock: unlink %s failed: %s\n", lockname, strerror(errno));
 656   else
 657     if (!quiet) printf("exim_lock: lock file removed\n");
 658   }
 659
 660 return yield;
 661 }
 662
 663 /* End */