lib/libutil/uucplock.c

   1 /*
   2  * Copyright (c) 1988, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  * $FreeBSD: src/lib/libutil/uucplock.c,v 1.12.2.1 2000/10/09 20:20:52 brian Exp $
  34  * $DragonFly: src/lib/libutil/uucplock.c,v 1.4 2005/03/04 06:06:57 cpressey Exp $
  35  *
  36  * @(#)uucplock.c       8.1 (Berkeley) 6/6/93
  37  */
  38
  39 #include <sys/types.h>
  40 #include <sys/file.h>
  41
  42 #include <dirent.h>
  43 #include <errno.h>
  44 #include <paths.h>
  45 #include <signal.h>
  46 #include <stdio.h>
  47 #include <stdlib.h>
  48 #include <string.h>
  49 #include <unistd.h>
  50
  51 #include "libutil.h"
  52
  53 #define MAXTRIES 5
  54
  55 #define LOCKTMP "LCKTMP..%d"
  56 #define LOCKFMT "LCK..%s"
  57
  58 #define GORET(level, val) { err = errno; uuerr = (val); \
  59                             goto __CONCAT(ret, level); }
  60
  61 /* Forward declarations */
  62 static int put_pid (int fd, pid_t pid);
  63 static pid_t get_pid (int fd,int *err);
  64
  65 /*
  66  * uucp style locking routines
  67  */
  68
  69 int
  70 uu_lock(const char *tty_name)
  71 {
  72         int fd, tmpfd, i;
  73         pid_t pid, pid_old;
  74         char lckname[sizeof(_PATH_UUCPLOCK) + MAXNAMLEN],
  75              lcktmpname[sizeof(_PATH_UUCPLOCK) + MAXNAMLEN];
  76         int err, uuerr;
  77
  78         pid = getpid();
  79         (void)snprintf(lcktmpname, sizeof(lcktmpname), _PATH_UUCPLOCK LOCKTMP,
  80                         pid);
  81         (void)snprintf(lckname, sizeof(lckname), _PATH_UUCPLOCK LOCKFMT,
  82                         tty_name);
  83         if ((tmpfd = creat(lcktmpname, 0664)) < 0)
  84                 GORET(0, UU_LOCK_CREAT_ERR);
  85
  86         for (i = 0; i < MAXTRIES; i++) {
  87                 if (link (lcktmpname, lckname) < 0) {
  88                         if (errno != EEXIST)
  89                                 GORET(1, UU_LOCK_LINK_ERR);
  90                         /*
  91                          * file is already locked
  92                          * check to see if the process holding the lock
  93                          * still exists
  94                          */
  95                         if ((fd = open(lckname, O_RDONLY)) < 0)
  96                                 GORET(1, UU_LOCK_OPEN_ERR);
  97
  98                         if ((pid_old = get_pid (fd, &err)) == -1)
  99                                 GORET(2, UU_LOCK_READ_ERR);
 100
 101                         close(fd);
 102
 103                         if (kill(pid_old, 0) == 0 || errno != ESRCH)
 104                                 GORET(1, UU_LOCK_INUSE);
 105                         /*
 106                          * The process that locked the file isn't running, so
 107                          * we'll lock it ourselves
 108                          */
 109                         (void)unlink(lckname);
 110                 } else {
 111                         if (!put_pid (tmpfd, pid))
 112                                 GORET(3, UU_LOCK_WRITE_ERR);
 113                         break;
 114                 }
 115         }
 116         GORET(1, (i >= MAXTRIES) ? UU_LOCK_TRY_ERR : UU_LOCK_OK);
 117
 118 ret3:
 119         (void)unlink(lckname);
 120         goto ret1;
 121 ret2:
 122         (void)close(fd);
 123 ret1:
 124         (void)close(tmpfd);
 125         (void)unlink(lcktmpname);
 126 ret0:
 127         errno = err;
 128         return uuerr;
 129 }
 130
 131 int
 132 uu_lock_txfr(const char *tty_name, pid_t pid)
 133 {
 134         int fd, err;
 135         char lckname[sizeof(_PATH_UUCPLOCK) + MAXNAMLEN];
 136
 137         snprintf(lckname, sizeof(lckname), _PATH_UUCPLOCK LOCKFMT, tty_name);
 138
 139         if ((fd = open(lckname, O_RDWR)) < 0)
 140                 return UU_LOCK_OWNER_ERR;
 141         if (get_pid(fd, &err) != getpid())
 142                 err = UU_LOCK_OWNER_ERR;
 143         else {
 144                 lseek(fd, 0, SEEK_SET);
 145                 err = put_pid(fd, pid) ? 0 : UU_LOCK_WRITE_ERR;
 146         }
 147         close(fd);
 148
 149         return err;
 150 }
 151
 152 int
 153 uu_unlock(const char *tty_name)
 154 {
 155         char tbuf[sizeof(_PATH_UUCPLOCK) + MAXNAMLEN];
 156
 157         (void)snprintf(tbuf, sizeof(tbuf), _PATH_UUCPLOCK LOCKFMT, tty_name);
 158         return unlink(tbuf);
 159 }
 160
 161 const char *
 162 uu_lockerr(int uu_lockresult)
 163 {
 164         static char errbuf[128];
 165         const char *fmt;
 166
 167         switch (uu_lockresult) {
 168                 case UU_LOCK_INUSE:
 169                         return "device in use";
 170                 case UU_LOCK_OK:
 171                         return "";
 172                 case UU_LOCK_OPEN_ERR:
 173                         fmt = "open error: %s";
 174                         break;
 175                 case UU_LOCK_READ_ERR:
 176                         fmt = "read error: %s";
 177                         break;
 178                 case UU_LOCK_CREAT_ERR:
 179                         fmt = "creat error: %s";
 180                         break;
 181                 case UU_LOCK_WRITE_ERR:
 182                         fmt = "write error: %s";
 183                         break;
 184                 case UU_LOCK_LINK_ERR:
 185                         fmt = "link error: %s";
 186                         break;
 187                 case UU_LOCK_TRY_ERR:
 188                         fmt = "too many tries: %s";
 189                         break;
 190                 case UU_LOCK_OWNER_ERR:
 191                         fmt = "not locking process: %s";
 192                         break;
 193                 default:
 194                         fmt = "undefined error: %s";
 195                         break;
 196         }
 197
 198         (void)snprintf(errbuf, sizeof(errbuf), fmt, strerror(errno));
 199         return errbuf;
 200 }
 201
 202 static int
 203 put_pid(int fd, pid_t pid)
 204 {
 205         char buf[32];
 206         int len;
 207
 208         len = sprintf (buf, "%10d\n", (int)pid);
 209         return write (fd, buf, len) == len;
 210 }
 211
 212 static pid_t
 213 get_pid(int fd, int *err)
 214 {
 215         int bytes_read;
 216         char buf[32];
 217         pid_t pid;
 218
 219         bytes_read = read (fd, buf, sizeof (buf) - 1);
 220         if (bytes_read > 0) {
 221                 buf[bytes_read] = '\0';
 222                 pid = strtol (buf, (char **) NULL, 10);
 223         } else {
 224                 pid = -1;
 225                 *err = bytes_read ? errno : EINVAL;
 226         }
 227         return pid;
 228 }
 229
 230 /* end of uucplock.c */