usr.bin/mail/dotlock.c

   1 /*      $NetBSD: dotlock.c,v 1.10 2009/04/10 13:08:24 christos Exp $    */
   2
   3 /*
   4  * Copyright (c) 1996 Christos Zoulas.  All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 #ifndef lint
  29 __RCSID("$NetBSD: dotlock.c,v 1.10 2009/04/10 13:08:24 christos Exp $");
  30 #endif
  31
  32 #include "rcv.h"
  33 #include "extern.h"
  34 #include "sig.h"
  35
  36 #ifndef O_SYNC
  37 #define O_SYNC  0
  38 #endif
  39
  40 static int create_exclusive(const char *);
  41 /*
  42  * Create a unique file. O_EXCL does not really work over NFS so we follow
  43  * the following trick: [Inspired by  S.R. van den Berg]
  44  *
  45  * - make a mostly unique filename and try to create it.
  46  * - link the unique filename to our target
  47  * - get the link count of the target
  48  * - unlink the mostly unique filename
  49  * - if the link count was 2, then we are ok; else we've failed.
  50  */
  51 static int
  52 create_exclusive(const char *fname)
  53 {
  54         char path[MAXPATHLEN], hostname[MAXHOSTNAMELEN + 1];
  55         const char *ptr;
  56         struct timeval tv;
  57         pid_t pid;
  58         size_t ntries, cookie;
  59         int fd, serrno;
  60         struct stat st;
  61
  62         (void)gettimeofday(&tv, NULL);
  63         (void)gethostname(hostname, sizeof(hostname));
  64         hostname[sizeof(hostname) - 1] = '\0';
  65         pid = getpid();
  66
  67         cookie = pid ^ tv.tv_usec;
  68
  69         /*
  70          * We generate a semi-unique filename, from hostname.(pid ^ usec)
  71          */
  72         if ((ptr = strrchr(fname, '/')) == NULL)
  73                 ptr = fname;
  74         else
  75                 ptr++;
  76
  77         (void)snprintf(path, sizeof(path), "%.*s.%s.%lx",
  78             (int)(ptr - fname), fname, hostname, (u_long)cookie);
  79
  80         /*
  81          * We try to create the unique filename.
  82          */
  83         for (ntries = 0; ntries < 5; ntries++) {
  84                 fd = open(path, O_WRONLY|O_CREAT|O_TRUNC|O_EXCL|O_SYNC, 0);
  85                 if (fd != -1) {
  86                         (void)close(fd);
  87                         break;
  88                 }
  89                 else if (errno == EEXIST)
  90                         continue;
  91                 else
  92                         return -1;
  93         }
  94
  95         /*
  96          * We link the path to the name
  97          */
  98         if (link(path, fname) == -1)
  99                 goto bad;
 100
 101         /*
 102          * Note that we stat our own exclusively created name, not the
 103          * destination, since the destination can be affected by others.
 104          */
 105         if (stat(path, &st) == -1)
 106                 goto bad;
 107
 108         (void)unlink(path);
 109
 110         /*
 111          * If the number of links was two (one for the unique file and one
 112          * for the lock), we've won the race
 113          */
 114         if (st.st_nlink != 2) {
 115                 errno = EEXIST;
 116                 return -1;
 117         }
 118         return 0;
 119
 120 bad:
 121         serrno = errno;
 122         (void)unlink(path);
 123         errno = serrno;
 124         return -1;
 125 }
 126
 127 /*
 128  * fname -- Pathname to lock
 129  * pollinterval -- Interval to check for lock, -1 return
 130  * fp -- File to print message
 131  * msg -- Message to print
 132  */
 133 PUBLIC int
 134 dot_lock(const char *fname, int pollinterval, FILE *fp, const char *msg)
 135 {
 136         char path[MAXPATHLEN];
 137         sigset_t nset, oset;
 138         int retval;
 139
 140         (void)sigemptyset(&nset);
 141         (void)sigaddset(&nset, SIGHUP);
 142         (void)sigaddset(&nset, SIGINT);
 143         (void)sigaddset(&nset, SIGQUIT);
 144         (void)sigaddset(&nset, SIGTERM);
 145         (void)sigaddset(&nset, SIGTTIN);
 146         (void)sigaddset(&nset, SIGTTOU);
 147         (void)sigaddset(&nset, SIGTSTP);
 148         (void)sigaddset(&nset, SIGCHLD);
 149
 150         (void)snprintf(path, sizeof(path), "%s.lock", fname);
 151
 152         retval = -1;
 153         for (;;) {
 154                 sig_check();
 155                 (void)sigprocmask(SIG_BLOCK, &nset, &oset);
 156                 if (create_exclusive(path) != -1) {
 157                         (void)sigprocmask(SIG_SETMASK, &oset, NULL);
 158                         retval = 0;
 159                         break;
 160                 }
 161                 else
 162                         (void)sigprocmask(SIG_SETMASK, &oset, NULL);
 163
 164                 if (errno != EEXIST)
 165                         break;
 166
 167                 if (fp && msg)
 168                     (void)fputs(msg, fp);
 169
 170                 if (pollinterval) {
 171                         if (pollinterval == -1) {
 172                                 errno = EEXIST;
 173                                 break;
 174                         }
 175                         (void)sleep((unsigned int)pollinterval);
 176                 }
 177         }
 178         sig_check();
 179         return retval;
 180 }
 181
 182 PUBLIC void
 183 dot_unlock(const char *fname)
 184 {
 185         char path[MAXPATHLEN];
 186
 187         (void)snprintf(path, sizeof(path), "%s.lock", fname);
 188         (void)unlink(path);
 189 }