cmd/bnu/ulockf.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*  Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*    All Rights Reserved   */


#pragma ident   "%Z%%M% %I% %E% SMI"

#include "uucp.h"

#include <unistd.h>
/* #include <sys/types.h> */
/* #include <sys/stat.h> */

static struct stat _st_buf;
static char lockname[BUFSIZ];

#ifdef  V7
#define O_RDONLY    0
#endif

static void stlock();
static int  onelock();

/*
 * make a lock file with given 'name'
 * If one already exists, send a signal 0 to the process--if
 * it fails, then unlink it and make a new one.
 *
 * input:
 *  name - name of the lock file to make
 *
 * return:
 *  0   -> success
 *  FAIL    -> failure
 */

GLOBAL int
mklock(name)
register char *name;
{
    static  char pid[SIZEOFPID+2] = { '\0' }; /* +2 for '\n' and NULL */
    static char tempfile[MAXNAMESIZE];

#ifdef V8
    char *cp;
#endif

    if (pid[0] == '\0') {
        (void) sprintf(pid, "%*ld\n", SIZEOFPID, (long) getpid());
        (void) sprintf(tempfile, "%s/LTMP.%ld", X_LOCKDIR, (long) getpid());
    }

#ifdef V8   /* this wouldn't be a problem if we used lock directories */
        /* some day the truncation of system names will bite us */
    cp = rindex(name, '/');
    if (cp++ != CNULL)
        if (strlen(cp) > MAXBASENAME)
        *(cp+MAXBASENAME) = NULLCHAR;
#endif /* V8 */
    if (onelock(pid, tempfile, name) == -1) {
        (void) unlink(tempfile);
        if (cklock(name))
            return(FAIL);
        else {
            if (onelock(pid, tempfile, name)) {
            (void) unlink(tempfile);
            DEBUG(4,"ulockf failed in onelock()\n%s", "");
            return(FAIL);
            }
        }
    }

    stlock(name);
    return(0);
}

/*
 * check to see if the lock file exists and is still active
 * - use kill(pid,0)
 *
 * return:
 *  0   -> success (lock file removed - no longer active
 *  FAIL    -> lock file still active
 */
GLOBAL int
cklock(name)
register char *name;
{
    register int ret;
    pid_t lpid = -1;
    char alpid[SIZEOFPID+2];    /* +2 for '\n' and NULL */
    int fd;

    fd = open(name, O_RDONLY);
    DEBUG(4, "ulockf name %s\n", name);
    if (fd == -1) {
        if (errno == ENOENT)  /* file does not exist -- OK */
        return(0);
        DEBUG(4,"Lock File--can't read (errno %d) --remove it!\n", errno);
        goto unlk;
    }
    ret = read(fd, (char *) alpid, SIZEOFPID+1); /* +1 for '\n' */
    (void) close(fd);
    if (ret != (SIZEOFPID+1)) {

        DEBUG(4, "Lock File--bad format--remove it!\n%s", "");
        goto unlk;
    }
    lpid = (pid_t) strtol(alpid, (char **) NULL, 10);
    if ((ret=kill(lpid, 0)) == 0 || errno == EPERM) {
        DEBUG(4, "Lock File--process still active--not removed\n%s", "");
        return(FAIL);
    }
    else { /* process no longer active */
        DEBUG(4, "kill pid (%ld), ", (long) lpid);
        DEBUG(4, "returned %d", ret);
        DEBUG(4, "--ok to remove lock file (%s)\n", name);
    }
unlk:

    if (unlink(name) != 0) {
        DEBUG(4,"ulockf failed in unlink()\n%s", "");
        return(FAIL);
    }
    return(0);
}

#define MAXLOCKS 10 /* maximum number of lock files */
static char *Lockfile[MAXLOCKS];
GLOBAL int Nlocks = 0;

/*
 * put name in list of lock files
 * return:
 *  none
 */
static void
stlock(name)
char *name;
{
    register int i;
    char *p;

    for (i = 0; i < Nlocks; i++) {
        if (Lockfile[i] == NULL)
            break;
    }
    ASSERT(i < MAXLOCKS, "TOO MANY LOCKS", "", i);
    if (i >= Nlocks)
        i = Nlocks++;
    p = (char*) calloc((unsigned) strlen(name) + 1, sizeof (char));
    ASSERT(p != NULL, "CAN NOT ALLOCATE FOR", name, 0);
    (void) strcpy(p, name);
    Lockfile[i] = p;
    return;
}

/*
 * remove the named lock. If named lock is NULL,
 *  then remove all locks currently in list.
 * return:
 *  none
 */
GLOBAL void
rmlock(name)
register char *name;
{
    register int i;
#ifdef V8
    char *cp;

    cp = rindex(name, '/');
    if (cp++ != CNULL)
        if (strlen(cp) > MAXBASENAME)
        *(cp+MAXBASENAME) = NULLCHAR;
#endif /* V8 */


    for (i = 0; i < Nlocks; i++) {
        if (Lockfile[i] == NULL)
            continue;
        if (name == NULL || EQUALS(name, Lockfile[i])) {
            (void) unlink(Lockfile[i]);
            free(Lockfile[i]);
            Lockfile[i] = NULL;
        }
    }
    return;
}


/*
 * remove a lock file
 *
 * Parameters:
 *  pre -   Path and first part of file name of the lock file to be
 *      removed.
 *  s - The suffix part of the lock file.  The name of the lock file
 *      will be derrived by concatenating pre, a period, and s.
 *
 * return:
 *  none
 */
GLOBAL void
delock(pre, s)
char * pre;
char *s;
{
    char ln[MAXNAMESIZE];

    (void) sprintf(ln, "%s.%s", pre, s);
    BASENAME(ln, '/')[MAXBASENAME] = '\0';
    rmlock(ln);
    return;
}


/*
 * create lock file
 *
 * Parameters:
 *  pre -   Path and first part of file name of the lock file to be
 *      created.
 *  name -  The suffix part of the lock file.  The name of the lock file
 *      will be derrived by concatenating pre, a period, and name.
 *
 * return:
 *  0   -> success
 *  FAIL    -> failure
 */
GLOBAL int
umlock(pre, name)
char * pre;
char *name;
{
    char lname[MAXNAMESIZE];

    /*
     * if name has a '/' in it, then it's a device name and it's
     * not in /dev (i.e., it's a remotely-mounted device or it's
     * in a subdirectory of /dev).  in either case, creating our normal
     * lockfile (/var/spool/locks/LCK..<dev>) is going to bomb if
     * <dev> is "/remote/dev/term/14" or "/dev/net/foo/clone", so never
     * mind.  since we're using advisory filelocks on the devices
     * themselves, it'll be safe.
     *
     * of course, programs and people who are used to looking at the
     * lockfiles to find out what's going on are going to be a trifle
     * misled.  we really need to re-consider the lockfile naming structure
     * to accomodate devices in directories other than /dev ... maybe in
     * the next release.
     */
    if ( strchr(name, '/') != NULL )
        return(0);
    (void) sprintf(lname, "%s.%s", pre, BASENAME(name, '/'));
    BASENAME(lname, '/')[MAXBASENAME] = '\0';
    return(mklock(lname));
}

/*
 * makes a lock on behalf of pid.
 * input:
 *  pid - process id
 *  tempfile - name of a temporary in the same file system
 *  name - lock file name (full path name)
 * return:
 *  -1 - failed
 *  0  - lock made successfully
 */
static int
onelock(pid,tempfile,name)
char *pid;
char *tempfile, *name;
{
    register int fd;
    char    cb[100];

    fd=creat(tempfile, (mode_t) 0444);
    if(fd < 0){
        (void) sprintf(cb, "%s %s %d",tempfile, name, errno);
        logent("ULOCKC", cb);
        if((errno == EMFILE) || (errno == ENFILE))
            (void) unlink(tempfile);
        return(-1);
    }
    /* +1 for '\n' */
    if (write(fd, pid, SIZEOFPID+1) != (SIZEOFPID+1)) {
        (void) sprintf(cb, "%s %s %d",tempfile, name, errno);
        logent("ULOCKW", cb);
        (void) unlink(tempfile);
        return (-1);
    }
    (void) chmod(tempfile, (mode_t) 0444);
    (void) chown(tempfile, UUCPUID, UUCPGID);
    (void) close(fd);
    if(link(tempfile,name)<0){
        DEBUG(4, "%s: ", strerror(errno));
        DEBUG(4, "link(%s, ", tempfile);
        DEBUG(4, "%s)\n", name);
        if(unlink(tempfile)< 0){
            (void) sprintf(cb, "ULK err %s %d", tempfile,  errno);
            logent("ULOCKLNK", cb);
        }
        return(-1);
    }
    if(unlink(tempfile)<0){
        (void) sprintf(cb, "%s %d",tempfile,errno);
        logent("ULOCKF", cb);
    }
    return(0);
}

/*
 * fd_mklock(fd) - lock the device indicated by fd if possible
 *
 * return -
 *  SUCCESS - this process now has the fd locked
 *  FAIL - this process was not able to lock the fd
 */

GLOBAL int
fd_mklock(fd)
int fd;
{
    int tries = 0;

    if ( fstat(fd, &_st_buf) != 0 )
    return(FAIL);

    (void) sprintf(lockname, "%s.%3.3lu.%3.3lu.%3.3lu", L_LOCK,
        (unsigned long) major(_st_buf.st_dev),
    (unsigned long) major(_st_buf.st_rdev),
    (unsigned long) minor(_st_buf.st_rdev));

    if ( mklock(lockname) == FAIL )
    return(FAIL);

    while ( lockf(fd, F_TLOCK, 0L) != 0 ) {
    DEBUG(7, "fd_mklock: lockf returns %d\n", errno);
    if ( (++tries >= MAX_LOCKTRY) || (errno != EAGAIN) ) {
        rmlock(lockname);
        logent("fd_mklock","lockf failed");
        return(FAIL);
    }
    sleep(2);
    }
    DEBUG(7, "fd_mklock: ok\n%s", "");
    return(SUCCESS);
}

/*
 * fn_cklock(name) - determine if the device indicated by name is locked
 *
 * return -
 *  SUCCESS - the name is not locked
 *  FAIL - the name is locked by another process
 */

GLOBAL int
fn_cklock(name)
char *name;
{
    /* we temporarily use lockname to hold full path name */
    (void) sprintf(lockname, "%s%s", (*name == '/' ? "" : "/dev/"), name);

    if ( stat(lockname, &_st_buf) != 0 )
    return(FAIL);

    (void) sprintf(lockname, "%s.%3.3lu.%3.3lu.%3.3lu", L_LOCK,
        (unsigned long) major(_st_buf.st_dev),
    (unsigned long) major(_st_buf.st_rdev),
    (unsigned long) minor(_st_buf.st_rdev));

    return(cklock(lockname));
}

/*
 * fd_cklock(fd) - determine if the device indicated by fd is locked
 *
 * return -
 *  SUCCESS - the fd is not locked
 *  FAIL - the fd is locked by another process
 */

GLOBAL int
fd_cklock(fd)
int fd;
{
    if ( fstat(fd, &_st_buf) != 0 )
    return(FAIL);

    (void) sprintf(lockname, "%s.%3.3lu.%3.3lu.%3.3lu", L_LOCK,
        (unsigned long) major(_st_buf.st_dev),
    (unsigned long) major(_st_buf.st_rdev),
    (unsigned long) minor(_st_buf.st_rdev));

    if ( cklock(lockname) == FAIL )
    return(FAIL);
    else
    return( lockf(fd, F_TEST, 0L) );
}

/*
 * remove the locks associated with the device file descriptor
 *
 * return -
 *  SUCCESS - both BNU lock file and advisory locks removed
 *  FAIL -
 */

GLOBAL void
fd_rmlock(fd)
int fd;
{
    if ( fstat(fd, &_st_buf) == 0 ) {
        (void) sprintf(lockname, "%s.%3.3lu.%3.3lu.%3.3lu", L_LOCK,
            (unsigned long) major(_st_buf.st_dev),
        (unsigned long) major(_st_buf.st_rdev),
        (unsigned long) minor(_st_buf.st_rdev));
        rmlock(lockname);
    }
    (void) lockf(fd, F_ULOCK, 0L);
    return;
}

#ifdef BSD4_2
#include <sys/file.h>

static int
lockf(fd, cmd, size)
    int fd, cmd;
    long size;
{
    int ret;

    if (size != 0) {
        errno = EINVAL;
        return (-1);
    }
    switch (cmd) {
    case F_LOCK:
        cmd = LOCK_EX;
        break;
    case F_TLOCK:
        cmd = LOCK_EX|LOCK_NB;
        break;
    case F_ULOCK:
        cmd = LOCK_UN;
        break;
    case F_TEST:
        if (flock(fd, LOCK_EX|LOCK_NB) == 0 && flock(fd, LOCK_UN) == 0)
            return (0);
        errno = EAGAIN;
        return (-1);
    default:
        errno = EINVAL;
        return (-1);
    }
    ret = flock(fd, cmd);
    if (ret < 0 && errno == EWOULDBLOCK)
        errno = EAGAIN;
}
#endif /* BSD4_2 */