[apple/shell_cmds.git] / shlock / shlock.c

/*	$NetBSD: shlock.c,v 1.10 2008/04/28 20:24:14 martin 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.10 2008/04/28 20:24:14 martin Exp $");
#endif

#include <sys/types.h>
#include <sys/file.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

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

#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. */
char	*xtmpfile(char *, pid_t, int);
int	p_exists(pid_t);
int	cklock(char *, int);
int	mklock(char *, pid_t, int);
void	bad_usage(void);
int	main(int, char **);

/*
** 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.
*/
char *
xtmpfile(char *file, pid_t pid, int uucpstyle)
{
	int	fd;
	int	len;
	char	*cp, buf[BUFSIZ];
	static char	tempname[BUFSIZ];

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

	sprintf(buf, "%ld\n", (u_long)pid);
	len = strlen(buf);
openloop:
	if ((fd = open(tempname, O_RDWR|O_CREAT|O_EXCL, 0644)) < 0) {
		switch(errno) {
		case EEXIST:
			dprintf("%s: file %s exists already.\n",
				Pname, tempname);
			if (unlink(tempname) < 0) {
				fprintf(stderr, E_unlk,
					Pname, tempname, strerror(errno));
				return((char *)NULL);
			}
			/*
			** Further profanity
			*/
			goto openloop;
		default:
			fprintf(stderr, E_open,
				Pname, tempname, strerror(errno));
			return((char *)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) < 0))
	{
		fprintf(stderr, "%s: write(%s,%ld): %s\n",
			Pname, tempname, (u_long)pid, strerror(errno));
		(void) close(fd);
		if (unlink(tempname) < 0) {
			fprintf(stderr, E_unlk,
				Pname, tempname, strerror(errno));
		}
		return((char *)NULL);
	}
	(void) close(fd);
	return(tempname);
}

/*
** Does the PID exist?
** Send null signal to find out.
*/
int
p_exists(pid_t pid)
{
	dprintf("%s: process %ld is ", Pname, (u_long)pid);
	if (pid <= 0) {
		dprintf("invalid\n");
		return(FALSE);
	}
	if (kill(pid, 0) < 0) {
		switch(errno) {
		case ESRCH:
			dprintf("dead\n");
			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.
**
*/
int
cklock(char *file, 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 < 0) {
		if (errno != ENOENT)
			fprintf(stderr, E_open, Pname, file, strerror(errno));
		return(TRUE);	/* might or might not; conservatism */
	}

	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)));
}

int
mklock(char *file, pid_t pid, int uucpstyle)
{
	char	*tmp;
	int	retcode = FALSE;

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

linkloop:
	if (link(tmp, file) < 0) {
		switch(errno) {
		case EEXIST:
			dprintf("%s: lock <%s> already exists\n", Pname, file);
			if (cklock(file, uucpstyle)) {
				dprintf("%s: extant lock is valid\n", Pname);
				break;
			} else {
				dprintf("%s: lock is invalid, removing\n",
					Pname);
				if (unlink(file) < 0) {
					fprintf(stderr, E_unlk,
						Pname, file, strerror(errno));
					break;
				}
			}
			/*
			** I hereby profane the god of structured programming,
			** Edsgar Dijkstra
			*/
			goto linkloop;
		default:
			fprintf(stderr, "%s: link(%s, %s): %s\n",
				Pname, tmp, file, strerror(errno));
			break;
		}
	} else {
		dprintf("%s: got lock <%s>\n", Pname, file);
		retcode = TRUE;
	}
	if (unlink(tmp) < 0) {
		fprintf(stderr, E_unlk, Pname, tmp, strerror(errno));
	}
	return(retcode);
}

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

int
main(int ac, char **av)
{
	int	x;
	char	*file = (char *)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 == (char *)NULL || (!only_check && pid <= 0)) {
		bad_usage();
	}

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

	exit(mklock(file, pid, uucpstyle) ? LOCK_SET : LOCK_FAIL);
}
Commit	Line	Data
f14763b6 A	1	/* $NetBSD: shlock.c,v 1.10 2008/04/28 20:24:14 martin Exp $ */
	2
	3	/*-
	4	* Copyright (c) 2006 The NetBSD Foundation, Inc.
	5	* All rights reserved.
	6	*
	7	* This code is derived from software contributed to The NetBSD Foundation
	8	* by Erik E. Fair.
	9	*
	10	* Redistribution and use in source and binary forms, with or without
	11	* modification, are permitted provided that the following conditions
	12	* are met:
	13	* 1. Redistributions of source code must retain the above copyright
	14	* notice, this list of conditions and the following disclaimer.
	15	* 2. Redistributions in binary form must reproduce the above copyright
	16	* notice, this list of conditions and the following disclaimer in the
	17	* documentation and/or other materials provided with the distribution.
	18	*
	19	* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
	20	* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
	21	* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	22	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
	23	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	24	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	25	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	26	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	27	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	28	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	29	* POSSIBILITY OF SUCH DAMAGE.
	30	*/
44bd5ea7 A	31
	32	/*
	33	** Program to produce reliable locks for shell scripts.
	34	** Algorithm suggested by Peter Honeyman, January 1984,
	35	** in connection with HoneyDanBer UUCP.
	36	**
	37	** I tried extending this to handle shared locks in November 1987,
	38	** and ran into to some fundamental problems:
	39	**
	40	** Neither 4.3 BSD nor System V have an open(2) with locking,
	41	** so that you can open a file and have it locked as soon as
	42	** it's real; you have to make two system calls, and there's
	43	** a race...
	44	**
	45	** When removing dead process id's from a list in a file,
	46	** you need to truncate the file (you don't want to create a
	47	** new one; see above); unfortunately for the portability of
	48	** this program, only 4.3 BSD has ftruncate(2).
	49	**
	50	** Erik E. Fair <fair@ucbarpa.berkeley.edu>, November 8, 1987
	51	**
	52	** Extensions for UUCP style locks (i.e. pid is an int in the file,
	53	** rather than an ASCII string). Also fix long standing bug with
	54	** full file systems and temporary files.
	55	**
	56	** Erik E. Fair <fair@apple.com>, November 12, 1989
	57	**
	58	** ANSIfy the code somewhat to make gcc -Wall happy with the code.
	59	** Submit to NetBSD
	60	**
	61	** Erik E. Fair <fair@clock.org>, May 20, 1997
	62	*/
	63
f14763b6 A	64	#include <sys/cdefs.h>
	65
	66	#ifndef lint
	67	__RCSID("$NetBSD: shlock.c,v 1.10 2008/04/28 20:24:14 martin Exp $");
	68	#endif
	69
44bd5ea7 A	70	#include <sys/types.h>
	71	#include <sys/file.h>
	72	#include <fcntl.h> /* Needed on hpux */
	73	#include <stdio.h>
	74	#include <signal.h>
	75	#include <errno.h>
	76	#include <string.h>
	77	#include <unistd.h>
	78	#include <stdlib.h>
	79
	80	#define LOCK_SET 0
	81	#define LOCK_FAIL 1
	82
	83	#define LOCK_GOOD 0
	84	#define LOCK_BAD 1
	85
	86	#define FAIL (-1)
	87
	88	#define TRUE 1
	89	#define FALSE 0
	90
	91	int Debug = FALSE;
	92	char *Pname;
f14763b6 A	93	const char USAGE[] = "%s: USAGE: %s [-du] [-p PID] -f file\n";
	94	const char E_unlk[] = "%s: unlink(%s): %s\n";
	95	const char E_open[] = "%s: open(%s): %s\n";
44bd5ea7 A	96
	97	#define dprintf if (Debug) printf
	98
	99	/*
	100	** Prototypes to make the ANSI compilers happy
	101	** Didn't lint used to do type and argument checking?
	102	** (and wasn't that sufficient?)
	103	*/
	104
44bd5ea7	105	/* the following is in case you need to make the prototypes go away. */
f14763b6 A	106	char xtmpfile(char , pid_t, int);
	107	int p_exists(pid_t);
	108	int cklock(char *, int);
	109	int mklock(char *, pid_t, int);
	110	void bad_usage(void);
	111	int main(int, char **);
44bd5ea7 A	112
	113	/*
	114	** Create a temporary file, all ready to lock with.
	115	** The file arg is so we get the filename right, if he
	116	** gave us a full path, instead of using the current directory
	117	** which might not be in the same filesystem.
	118	*/
	119	char *
f14763b6	120	xtmpfile(char *file, pid_t pid, int uucpstyle)
44bd5ea7 A	121	{
	122	int fd;
	123	int len;
	124	char *cp, buf[BUFSIZ];
	125	static char tempname[BUFSIZ];
	126
f14763b6	127	sprintf(buf, "shlock%ld", (u_long)getpid());
44bd5ea7 A	128	if ((cp = strrchr(strcpy(tempname, file), '/')) != (char *)NULL) {
	129	*++cp = '\0';
	130	(void) strcat(tempname, buf);
	131	} else
	132	(void) strcpy(tempname, buf);
	133	dprintf("%s: temporary filename: %s\n", Pname, tempname);
	134
f14763b6	135	sprintf(buf, "%ld\n", (u_long)pid);
44bd5ea7 A	136	len = strlen(buf);
	137	openloop:
	138	if ((fd = open(tempname, O_RDWR\|O_CREAT\|O_EXCL, 0644)) < 0) {
	139	switch(errno) {
	140	case EEXIST:
	141	dprintf("%s: file %s exists already.\n",
	142	Pname, tempname);
	143	if (unlink(tempname) < 0) {
	144	fprintf(stderr, E_unlk,
	145	Pname, tempname, strerror(errno));
	146	return((char *)NULL);
	147	}
	148	/*
	149	** Further profanity
	150	*/
	151	goto openloop;
	152	default:
	153	fprintf(stderr, E_open,
	154	Pname, tempname, strerror(errno));
	155	return((char *)NULL);
	156	}
	157	}
	158
	159	/*
	160	** Write the PID into the temporary file before attempting to link
	161	** to the actual lock file. That way we have a valid lock the instant
	162	** the link succeeds.
	163	*/
	164	if (uucpstyle ?
	165	(write(fd, &pid, sizeof(pid)) != sizeof(pid)) :
	166	(write(fd, buf, len) < 0))
	167	{
f14763b6 A	168	fprintf(stderr, "%s: write(%s,%ld): %s\n",
f14763b6 A	169	Pname, tempname, (u_long)pid, strerror(errno));
44bd5ea7 A	170	(void) close(fd);
	171	if (unlink(tempname) < 0) {
	172	fprintf(stderr, E_unlk,
	173	Pname, tempname, strerror(errno));
	174	}
	175	return((char *)NULL);
	176	}
	177	(void) close(fd);
	178	return(tempname);
	179	}
	180
	181	/*
	182	** Does the PID exist?
	183	** Send null signal to find out.
	184	*/
	185	int
f14763b6	186	p_exists(pid_t pid)
44bd5ea7	187	{
f14763b6	188	dprintf("%s: process %ld is ", Pname, (u_long)pid);
44bd5ea7 A	189	if (pid <= 0) {
	190	dprintf("invalid\n");
	191	return(FALSE);
	192	}
	193	if (kill(pid, 0) < 0) {
	194	switch(errno) {
	195	case ESRCH:
	196	dprintf("dead\n");
	197	return(FALSE); /* pid does not exist */
	198	case EPERM:
	199	dprintf("alive\n");
	200	return(TRUE); /* pid exists */
	201	default:
	202	dprintf("state unknown: %s\n", strerror(errno));
	203	return(TRUE); /* be conservative */
	204	}
	205	}
	206	dprintf("alive\n");
	207	return(TRUE); /* pid exists */
	208	}
	209
	210	/*
	211	** Check the validity of an existing lock file.
	212	**
	213	** Read the PID out of the lock
	214	** Send a null signal to determine whether that PID still exists
	215	** Existence (or not) determines the validity of the lock.
	216	**
	217	** Two bigs wins to this algorithm:
	218	**
	219	** o Locks do not survive crashes of either the system or the
	220	** application by any appreciable period of time.
	221	**
	222	** o No clean up to do if the system or application crashes.
	223	**
	224	*/
	225	int
f14763b6	226	cklock(char *file, int uucpstyle)
44bd5ea7 A	227	{
	228	int fd = open(file, O_RDONLY);
	229	ssize_t len;
	230	pid_t pid;
	231	char buf[BUFSIZ];
	232
	233	dprintf("%s: checking extant lock <%s>\n", Pname, file);
	234	if (fd < 0) {
	235	if (errno != ENOENT)
	236	fprintf(stderr, E_open, Pname, file, strerror(errno));
	237	return(TRUE); /* might or might not; conservatism */
	238	}
	239
	240	if (uucpstyle ?
	241	((len = read(fd, &pid, sizeof(pid))) != sizeof(pid)) :
	242	((len = read(fd, buf, sizeof(buf))) <= 0))
	243	{
	244	close(fd);
	245	dprintf("%s: lock file format error\n", Pname);
	246	return(FALSE);
	247	}
	248	close(fd);
	249	buf[len + 1] = '\0';
	250	return(p_exists(uucpstyle ? pid : atoi(buf)));
	251	}
	252
	253	int
f14763b6	254	mklock(char *file, pid_t pid, int uucpstyle)
44bd5ea7 A	255	{
	256	char *tmp;
	257	int retcode = FALSE;
	258
f14763b6 A	259	dprintf("%s: trying lock <%s> for process %ld\n", Pname, file,
f14763b6 A	260	(u_long)pid);
44bd5ea7 A	261	if ((tmp = xtmpfile(file, pid, uucpstyle)) == (char *)NULL)
	262	return(FALSE);
	263
	264	linkloop:
	265	if (link(tmp, file) < 0) {
	266	switch(errno) {
	267	case EEXIST:
	268	dprintf("%s: lock <%s> already exists\n", Pname, file);
	269	if (cklock(file, uucpstyle)) {
	270	dprintf("%s: extant lock is valid\n", Pname);
	271	break;
	272	} else {
	273	dprintf("%s: lock is invalid, removing\n",
	274	Pname);
	275	if (unlink(file) < 0) {
	276	fprintf(stderr, E_unlk,
	277	Pname, file, strerror(errno));
	278	break;
	279	}
	280	}
	281	/*
	282	** I hereby profane the god of structured programming,
	283	** Edsgar Dijkstra
	284	*/
	285	goto linkloop;
	286	default:
	287	fprintf(stderr, "%s: link(%s, %s): %s\n",
	288	Pname, tmp, file, strerror(errno));
	289	break;
	290	}
	291	} else {
	292	dprintf("%s: got lock <%s>\n", Pname, file);
	293	retcode = TRUE;
	294	}
	295	if (unlink(tmp) < 0) {
	296	fprintf(stderr, E_unlk, Pname, tmp, strerror(errno));
	297	}
	298	return(retcode);
	299	}
	300
	301	void
f14763b6	302	bad_usage(void)
44bd5ea7	303	{
f14763b6	304	fprintf(stderr, USAGE, Pname, Pname);
44bd5ea7 A	305	exit(LOCK_FAIL);
	306	}
	307
	308	int
f14763b6	309	main(int ac, char **av)
44bd5ea7 A	310	{
	311	int x;
	312	char file = (char )NULL;
	313	pid_t pid = 0;
	314	int uucpstyle = FALSE; /* indicating UUCP style locks */
	315	int only_check = TRUE; /* don't make a lock */
	316
	317	Pname = ((Pname = strrchr(av[0], '/')) ? Pname + 1 : av[0]);
	318
	319	for(x = 1; x < ac; x++) {
	320	if (av[x][0] == '-') {
	321	switch(av[x][1]) {
	322	case 'u':
	323	uucpstyle = TRUE;
	324	break;
	325	case 'd':
	326	Debug = TRUE;
	327	break;
	328	case 'p':
	329	if (strlen(av[x]) > 2) {
	330	pid = atoi(&av[x][2]);
	331	} else {
	332	if (++x >= ac) {
	333	bad_usage();
	334	}
	335	pid = atoi(av[x]);
	336	}
	337	only_check = FALSE; /* wants one */
	338	break;
	339	case 'f':
	340	if (strlen(av[x]) > 2) {
	341	file = &av[x][2];
	342	} else {
	343	if (++x >= ac) {
	344	bad_usage();
	345	}
	346	file = av[x];
	347	}
	348	break;
	349	default:
f14763b6	350	bad_usage();
44bd5ea7 A	351	}
	352	}
	353	}
	354
	355	if (file == (char *)NULL \|\| (!only_check && pid <= 0)) {
	356	bad_usage();
	357	}
	358
	359	if (only_check) {
	360	exit(cklock(file, uucpstyle) ? LOCK_GOOD : LOCK_BAD);
	361	}
	362
	363	exit(mklock(file, pid, uucpstyle) ? LOCK_SET : LOCK_FAIL);
	364	}