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