/*      $NetBSD: shlock.c,v 1.16 2024/08/17 14:26:53 riastradh Exp $    */

/*-
 * Copyright (c) 2006 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Erik E. Fair.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/*
** Program to produce reliable locks for shell scripts.
** Algorithm suggested by Peter Honeyman, January 1984,
** in connection with HoneyDanBer UUCP.
**
** I tried extending this to handle shared locks in November 1987,
** and ran into to some fundamental problems:
**
**      Neither 4.3 BSD nor System V have an open(2) with locking,
**      so that you can open a file and have it locked as soon as
**      it's real; you have to make two system calls, and there's
**      a race...
**
**      When removing dead process id's from a list in a file,
**      you need to truncate the file (you don't want to create a
**      new one; see above); unfortunately for the portability of
**      this program, only 4.3 BSD has ftruncate(2).
**
** Erik E. Fair <fair@ucbarpa.berkeley.edu>, November 8, 1987
**
** Extensions for UUCP style locks (i.e. pid is an int in the file,
** rather than an ASCII string). Also fix long standing bug with
** full file systems and temporary files.
**
** Erik E. Fair <fair@apple.com>, November 12, 1989
**
** ANSIfy the code somewhat to make gcc -Wall happy with the code.
** Submit to NetBSD
**
** Erik E. Fair <fair@clock.org>, May 20, 1997
*/

#include <sys/cdefs.h>

#ifndef lint
__RCSID("$NetBSD: shlock.c,v 1.16 2024/08/17 14:26:53 riastradh Exp $");
#endif

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/file.h>
#include <err.h>
#include <fcntl.h>                      /* Needed on hpux */
#include <stdio.h>
#include <signal.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>

#define LOCK_SET        0
#define LOCK_FAIL       1

#define LOCK_GOOD       0
#define LOCK_BAD        1

#define FAIL            (-1)

#define TRUE    1
#define FALSE   0

static int      Debug = FALSE;
static char     *Pname;
static const char USAGE[] = "%s: USAGE: %s [-du] [-p PID] -f file\n";
static const char E_unlk[] = "unlink(%s)";
static const char E_link[] = "link(%s, %s)";
static const char E_open[] = "open(%s)";
static const char E_stat[] = "stat(%s)";

#define dprintf if (Debug) printf

/*
** Prototypes to make the ANSI compilers happy
** Didn't lint used to do type and argument checking?
** (and wasn't that sufficient?)
*/

/* the following is in case you need to make the prototypes go away. */
static char     *xtmpfile(const char *, pid_t, int);
static int      p_exists(pid_t);
static int      cklock(const char *, struct stat *, int);
static int      mklock(const char *, pid_t, int);
__dead static void      bad_usage(void);

/*
** Create a temporary file, all ready to lock with.
** The file arg is so we get the filename right, if he
** gave us a full path, instead of using the current directory
** which might not be in the same filesystem.
*/
static char *
xtmpfile(const char *file, pid_t pid, int uucpstyle)
{
        int     fd;
        size_t  len;
        char    *cp, buf[BUFSIZ];
        static char     tempname[BUFSIZ];

        snprintf(buf, sizeof(buf), "shlock%jd", (intmax_t)getpid());
        if ((cp = strrchr(strcpy(tempname, file), '/')) != NULL) {
                *++cp = '\0';
                (void) strcat(tempname, buf);
        } else
                (void) strcpy(tempname, buf);
        dprintf("%s: temporary filename: %s\n", Pname, tempname);

        snprintf(buf, sizeof(buf), "%jd\n", (intmax_t)pid);
        len = strlen(buf);
        while ((fd = open(tempname, O_RDWR|O_CREAT|O_TRUNC|O_SYNC|O_EXCL, 0644))
            == -1)
        {
                switch(errno) {
                case EEXIST:
                        if (unlink(tempname) == -1) {
                                warn(E_unlk, tempname);
                                return NULL;
                        }
                        break;
                default:
                        warn(E_open, tempname);
                        return NULL;
                }
        }

        /*
        ** Write the PID into the temporary file before attempting to link
        ** to the actual lock file. That way we have a valid lock the instant
        ** the link succeeds.
        */
        if (uucpstyle ?
                (write(fd, &pid, sizeof(pid)) != sizeof(pid)) :
                (write(fd, buf, len) != (ssize_t)len))
        {
                warn("write(%s,%jd)", tempname, (intmax_t)pid);
                (void) close(fd);
                if (unlink(tempname) == -1) {
                        warn(E_unlk, tempname);
                }
                return NULL;
        }
        (void) close(fd);
        return tempname;
}

/*
** Does the PID exist?
** Send null signal to find out.
*/
static int
p_exists(pid_t pid)
{
        dprintf("%s: process %jd is ", Pname, (intmax_t)pid);
        if (pid <= 0) {
                dprintf("invalid\n");
                return FALSE;
        }
        if (kill(pid, 0) == -1) {
                switch(errno) {
                case ESRCH:
                        dprintf("dead %jd\n", (intmax_t)pid);
                        return FALSE;   /* pid does not exist */
                case EPERM:
                        dprintf("alive\n");
                        return TRUE;    /* pid exists */
                default:
                        dprintf("state unknown: %s\n", strerror(errno));
                        return TRUE;    /* be conservative */
                }
        }
        dprintf("alive\n");
        return TRUE;    /* pid exists */
}

/*
** Check the validity of an existing lock file.
**
**      Read the PID out of the lock
**      Send a null signal to determine whether that PID still exists
**      Existence (or not) determines the validity of the lock.
**
**      Two bigs wins to this algorithm:
**
**      o       Locks do not survive crashes of either the system or the
**                      application by any appreciable period of time.
**
**      o       No clean up to do if the system or application crashes.
**
*/
static int
cklock(const char *file, struct stat *st, int uucpstyle)
{
        int     fd = open(file, O_RDONLY);
        ssize_t len;
        pid_t   pid;
        char    buf[BUFSIZ];

        dprintf("%s: checking extant lock <%s>\n", Pname, file);
        if (fd == -1) {
                if (errno != ENOENT)
                        warn(E_open, file);
                return TRUE;    /* might or might not; conservatism */
        }

        if (st != NULL && fstat(fd, st) == -1) {
                warn(E_stat, file);
                close(fd);
                return TRUE;
        }

        if (uucpstyle ?
                ((len = read(fd, &pid, sizeof(pid))) != sizeof(pid)) :
                ((len = read(fd, buf, sizeof(buf))) <= 0))
        {
                close(fd);
                dprintf("%s: lock file format error\n", Pname);
                return FALSE;
        }
        close(fd);
        buf[len + 1] = '\0';
        return p_exists(uucpstyle ? pid : atoi(buf));
}

static int
mklock(const char *file, pid_t pid, int uucpstyle)
{
        char    *tmp, tmp2[BUFSIZ + 2];
        int     retcode = FALSE;
        struct stat stlock, sttmp, stlock2;

        dprintf("%s: trying lock <%s> for process %jd\n", Pname, file,
            (intmax_t)pid);
        if ((tmp = xtmpfile(file, pid, uucpstyle)) == NULL)
                return FALSE;

        while (link(tmp, file) == -1) {
                switch(errno) {
                case EEXIST:
                        dprintf("%s: lock <%s> already exists\n", Pname, file);
                        if (cklock(file, &stlock, uucpstyle)) {
                                dprintf("%s: extant lock is valid\n", Pname);
                                goto out;
                        }
                        if (stat(tmp, &sttmp) == -1) {
                                warn(E_stat, tmp);
                                goto out;
                        }
                        /*
                         * We need to take another lock against the lock
                         * file to protect it against multiple removals
                         */
                        snprintf(tmp2, sizeof(tmp2), "%s-2", tmp);
                        if (unlink(tmp2) == -1 && errno != ENOENT) {
                                warn(E_unlk, tmp2);
                                goto out;
                        }
                        if (stlock.st_ctime >= sttmp.st_ctime) {
                                dprintf("%s: lock time changed %jd >= %jd\n",
                                    Pname, (intmax_t)stlock.st_ctime,
                                    (intmax_t)stlock2.st_ctime);
                                goto out;
                        }
                        if (stlock.st_nlink != 1) {
                                dprintf("%s: someone else linked to it %d\n",
                                    Pname, stlock.st_nlink);
                                goto out;
                        }
                        if (link(file, tmp2) == -1) {
                                /* someone took our temp name! */
                                warn(E_link, file, tmp2);
                                goto out2;
                        }
                        if (stat(file, &stlock2) == -1) {
                                warn(E_stat, file);
                                goto out2;
                        }
                        if (stlock.st_ino != stlock2.st_ino) {
                                dprintf("%s: lock inode changed %jd != %jd\n",
                                    Pname, (intmax_t)stlock.st_ino,
                                    (intmax_t)stlock2.st_ino);
                                goto out2;
                        }
                        if (stlock2.st_nlink != 2) {
                                dprintf("%s: someone else linked to it %d\n",
                                    Pname, stlock2.st_nlink);
                                goto out2;
                        }

                        dprintf("%s: lock is invalid, removing\n", Pname);
                        if (unlink(file) == -1) {
                                warn(E_unlk, file);
                                goto out2;
                        }
                        if (unlink(tmp2) == -1)
                                goto out2;
                        break;
                default:
                        warn(E_link, tmp, file);
                        goto out;
                }
        }

        if (stat(tmp, &sttmp) == -1) {
                warn(E_stat, tmp);
                goto out;
        }

        if (sttmp.st_nlink == 2) {
                dprintf("%s: got lock <%s>\n", Pname, file);
                retcode = TRUE;
                goto out;

        }

out2:
        if (unlink(tmp2) == -1) {
                warn(E_unlk, tmp2);
        }
out:
        if (unlink(tmp) == -1) {
                warn(E_unlk, tmp);
        }

        return retcode;
}

static void
bad_usage(void)
{
        fprintf(stderr, USAGE, Pname, Pname);
        exit(LOCK_FAIL);
}

int
main(int ac, char **av)
{
        int     x;
        char    *file = NULL;
        pid_t   pid = 0;
        int     uucpstyle = FALSE;      /* indicating UUCP style locks */
        int     only_check = TRUE;      /* don't make a lock */

        Pname = ((Pname = strrchr(av[0], '/')) ? Pname + 1 : av[0]);

        for(x = 1; x < ac; x++) {
                if (av[x][0] == '-') {
                        switch(av[x][1]) {
                        case 'u':
                                uucpstyle = TRUE;
                                break;
                        case 'd':
                                Debug = TRUE;
                                break;
                        case 'p':
                                if (strlen(av[x]) > 2) {
                                        pid = atoi(&av[x][2]);
                                } else {
                                        if (++x >= ac) {
                                                bad_usage();
                                        }
                                        pid = atoi(av[x]);
                                }
                                only_check = FALSE;     /* wants one */
                                break;
                        case 'f':
                                if (strlen(av[x]) > 2) {
                                        file = &av[x][2];
                                } else {
                                        if (++x >= ac) {
                                                bad_usage();
                                        }
                                        file = av[x];
                                }
                                break;
                        default:
                                bad_usage();
                        }
                }
        }

        if (file == NULL || (!only_check && pid <= 0)) {
                bad_usage();
        }

        if (only_check) {
                exit(cklock(file, NULL, uucpstyle) ? LOCK_GOOD : LOCK_BAD);
        }

        exit(mklock(file, pid, uucpstyle) ? LOCK_SET : LOCK_FAIL);
}