1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License").  You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
23/*	  All Rights Reserved  	*/
24/*
25 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
26 * Use is subject to license terms.
27 */
28
29
30#pragma ident	"%Z%%M%	%I%	%E% SMI"
31
32#include "uucp.h"
33
34#include <unistd.h>
35/* #include <sys/types.h> */
36/* #include <sys/stat.h> */
37
38static struct stat _st_buf;
39static char lockname[BUFSIZ];
40
41#ifdef	V7
42#define O_RDONLY	0
43#endif
44
45static void	stlock();
46static int	onelock();
47
48/*
49 * make a lock file with given 'name'
50 * If one already exists, send a signal 0 to the process--if
51 * it fails, then unlink it and make a new one.
52 *
53 * input:
54 *	name - name of the lock file to make
55 *
56 * return:
57 *	0	-> success
58 *	FAIL	-> failure
59 */
60
61GLOBAL int
62mklock(name)
63register char *name;
64{
65	static	char pid[SIZEOFPID+2] = { '\0' }; /* +2 for '\n' and NULL */
66	static char tempfile[MAXNAMESIZE];
67
68#ifdef V8
69	char *cp;
70#endif
71
72	if (pid[0] == '\0') {
73		(void) sprintf(pid, "%*ld\n", SIZEOFPID, (long) getpid());
74		(void) sprintf(tempfile, "%s/LTMP.%ld", X_LOCKDIR, (long) getpid());
75	}
76
77#ifdef V8	/* this wouldn't be a problem if we used lock directories */
78		/* some day the truncation of system names will bite us */
79	cp = rindex(name, '/');
80	if (cp++ != CNULL)
81	    if (strlen(cp) > MAXBASENAME)
82		*(cp+MAXBASENAME) = NULLCHAR;
83#endif /* V8 */
84	if (onelock(pid, tempfile, name) == -1) {
85		(void) unlink(tempfile);
86		if (cklock(name))
87			return(FAIL);
88		else {
89		    if (onelock(pid, tempfile, name)) {
90			(void) unlink(tempfile);
91			DEBUG(4,"ulockf failed in onelock()\n%s", "");
92			return(FAIL);
93		    }
94		}
95	}
96
97	stlock(name);
98	return(0);
99}
100
101/*
102 * check to see if the lock file exists and is still active
103 * - use kill(pid,0)
104 *
105 * return:
106 *	0	-> success (lock file removed - no longer active
107 *	FAIL	-> lock file still active
108 */
109GLOBAL int
110cklock(name)
111register char *name;
112{
113	register int ret;
114	pid_t lpid = -1;
115	char alpid[SIZEOFPID+2];	/* +2 for '\n' and NULL */
116	int fd;
117
118	fd = open(name, O_RDONLY);
119	DEBUG(4, "ulockf name %s\n", name);
120	if (fd == -1) {
121	    if (errno == ENOENT)  /* file does not exist -- OK */
122		return(0);
123	    DEBUG(4,"Lock File--can't read (errno %d) --remove it!\n", errno);
124	    goto unlk;
125	}
126	ret = read(fd, (char *) alpid, SIZEOFPID+1); /* +1 for '\n' */
127	(void) close(fd);
128	if (ret != (SIZEOFPID+1)) {
129
130	    DEBUG(4, "Lock File--bad format--remove it!\n%s", "");
131	    goto unlk;
132	}
133	lpid = (pid_t) strtol(alpid, (char **) NULL, 10);
134	if ((ret=kill(lpid, 0)) == 0 || errno == EPERM) {
135	    DEBUG(4, "Lock File--process still active--not removed\n%s", "");
136	    return(FAIL);
137	}
138	else { /* process no longer active */
139	    DEBUG(4, "kill pid (%ld), ", (long) lpid);
140	    DEBUG(4, "returned %d", ret);
141	    DEBUG(4, "--ok to remove lock file (%s)\n", name);
142	}
143unlk:
144
145	if (unlink(name) != 0) {
146		DEBUG(4,"ulockf failed in unlink()\n%s", "");
147		return(FAIL);
148	}
149	return(0);
150}
151
152#define MAXLOCKS 10	/* maximum number of lock files */
153static char *Lockfile[MAXLOCKS];
154GLOBAL int Nlocks = 0;
155
156/*
157 * put name in list of lock files
158 * return:
159 *	none
160 */
161static void
162stlock(name)
163char *name;
164{
165	register int i;
166	char *p;
167
168	for (i = 0; i < Nlocks; i++) {
169		if (Lockfile[i] == NULL)
170			break;
171	}
172	ASSERT(i < MAXLOCKS, "TOO MANY LOCKS", "", i);
173	if (i >= Nlocks)
174		i = Nlocks++;
175	p = (char*) calloc((unsigned) strlen(name) + 1, sizeof (char));
176	ASSERT(p != NULL, "CAN NOT ALLOCATE FOR", name, 0);
177	(void) strcpy(p, name);
178	Lockfile[i] = p;
179	return;
180}
181
182/*
183 * remove the named lock. If named lock is NULL,
184 *	then remove all locks currently in list.
185 * return:
186 *	none
187 */
188GLOBAL void
189rmlock(name)
190register char *name;
191{
192	register int i;
193#ifdef V8
194	char *cp;
195
196	cp = rindex(name, '/');
197	if (cp++ != CNULL)
198	    if (strlen(cp) > MAXBASENAME)
199		*(cp+MAXBASENAME) = NULLCHAR;
200#endif /* V8 */
201
202
203	for (i = 0; i < Nlocks; i++) {
204		if (Lockfile[i] == NULL)
205			continue;
206		if (name == NULL || EQUALS(name, Lockfile[i])) {
207			(void) unlink(Lockfile[i]);
208			free(Lockfile[i]);
209			Lockfile[i] = NULL;
210		}
211	}
212	return;
213}
214
215
216
217/*
218 * remove a lock file
219 *
220 * Parameters:
221 *	pre -	Path and first part of file name of the lock file to be
222 *		removed.
223 *	s -	The suffix part of the lock file.  The name of the lock file
224 *		will be derrived by concatenating pre, a period, and s.
225 *
226 * return:
227 *	none
228 */
229GLOBAL void
230delock(pre, s)
231char * pre;
232char *s;
233{
234	char ln[MAXNAMESIZE];
235
236	(void) sprintf(ln, "%s.%s", pre, s);
237	BASENAME(ln, '/')[MAXBASENAME] = '\0';
238	rmlock(ln);
239	return;
240}
241
242
243/*
244 * create lock file
245 *
246 * Parameters:
247 *	pre -	Path and first part of file name of the lock file to be
248 *		created.
249 *	name -	The suffix part of the lock file.  The name of the lock file
250 *		will be derrived by concatenating pre, a period, and name.
251 *
252 * return:
253 *	0	-> success
254 *	FAIL	-> failure
255 */
256GLOBAL int
257mlock(pre, name)
258char * pre;
259char *name;
260{
261	char lname[MAXNAMESIZE];
262
263	/*
264	 * if name has a '/' in it, then it's a device name and it's
265	 * not in /dev (i.e., it's a remotely-mounted device or it's
266	 * in a subdirectory of /dev).  in either case, creating our normal
267	 * lockfile (/var/spool/locks/LCK..<dev>) is going to bomb if
268	 * <dev> is "/remote/dev/term/14" or "/dev/net/foo/clone", so never
269	 * mind.  since we're using advisory filelocks on the devices
270	 * themselves, it'll be safe.
271	 *
272	 * of course, programs and people who are used to looking at the
273	 * lockfiles to find out what's going on are going to be a trifle
274	 * misled.  we really need to re-consider the lockfile naming structure
275	 * to accomodate devices in directories other than /dev ... maybe in
276	 * the next release.
277	 */
278	if ( strchr(name, '/') != NULL )
279		return(0);
280	(void) sprintf(lname, "%s.%s", pre, BASENAME(name, '/'));
281	BASENAME(lname, '/')[MAXBASENAME] = '\0';
282	return(mklock(lname));
283}
284
285/*
286 * makes a lock on behalf of pid.
287 * input:
288 *	pid - process id
289 *	tempfile - name of a temporary in the same file system
290 *	name - lock file name (full path name)
291 * return:
292 *	-1 - failed
293 *	0  - lock made successfully
294 */
295static int
296onelock(pid,tempfile,name)
297char *pid;
298char *tempfile, *name;
299{
300	register int fd;
301	char	cb[100];
302
303	fd=creat(tempfile, (mode_t) 0444);
304	if(fd < 0){
305		(void) sprintf(cb, "%s %s %d",tempfile, name, errno);
306		logent("ULOCKC", cb);
307		if((errno == EMFILE) || (errno == ENFILE))
308			(void) unlink(tempfile);
309		return(-1);
310	}
311	/* +1 for '\n' */
312	if (write(fd, pid, SIZEOFPID+1) != (SIZEOFPID+1)) {
313		(void) sprintf(cb, "%s %s %d",tempfile, name, errno);
314		logent("ULOCKW", cb);
315		(void) unlink(tempfile);
316		return (-1);
317	}
318	(void) chmod(tempfile, (mode_t) 0444);
319	(void) chown(tempfile, UUCPUID, UUCPGID);
320	(void) close(fd);
321	if(link(tempfile,name)<0){
322		DEBUG(4, "%s: ", strerror(errno));
323		DEBUG(4, "link(%s, ", tempfile);
324		DEBUG(4, "%s)\n", name);
325		if(unlink(tempfile)< 0){
326			(void) sprintf(cb, "ULK err %s %d", tempfile,  errno);
327			logent("ULOCKLNK", cb);
328		}
329		return(-1);
330	}
331	if(unlink(tempfile)<0){
332		(void) sprintf(cb, "%s %d",tempfile,errno);
333		logent("ULOCKF", cb);
334	}
335	return(0);
336}
337
338/*
339 * fd_mklock(fd) - lock the device indicated by fd is possible
340 *
341 * return -
342 *	SUCCESS - this process now has the fd locked
343 *	FAIL - this process was not able to lock the fd
344 */
345
346GLOBAL int
347fd_mklock(fd)
348int fd;
349{
350    int tries = 0;
351
352    if ( fstat(fd, &_st_buf) != 0 )
353	return(FAIL);
354
355    (void) sprintf(lockname, "%s.%3.3lu.%3.3lu.%3.3lu", L_LOCK,
356        (unsigned long) major(_st_buf.st_dev),
357	(unsigned long) major(_st_buf.st_rdev),
358	(unsigned long) minor(_st_buf.st_rdev));
359
360    if ( mklock(lockname) == FAIL )
361	return(FAIL);
362
363    while ( lockf(fd, F_TLOCK, 0L) != 0 ) {
364	DEBUG(7, "fd_mklock: lockf returns %d\n", errno);
365	if ( (++tries >= MAX_LOCKTRY) || (errno != EAGAIN) ) {
366	    rmlock(lockname);
367	    logent("fd_mklock","lockf failed");
368	    return(FAIL);
369	}
370	(void)sleep(2);
371    }
372    DEBUG(7, "fd_mklock: ok\n%s", "");
373    return(SUCCESS);
374}
375
376/*
377 * fn_cklock(name) - determine if the device indicated by name is locked
378 *
379 * return -
380 *	SUCCESS - the name is not locked
381 *	FAIL - the name is locked by another process
382 */
383
384GLOBAL int
385fn_cklock(name)
386char *name;
387{
388    /* we temporarily use lockname to hold full path name */
389    (void) sprintf(lockname, "%s%s", (*name == '/' ? "" : "/dev/"), name);
390
391    if ( stat(lockname, &_st_buf) != 0 )
392	return(FAIL);
393
394    (void) sprintf(lockname, "%s.%3.3lu.%3.3lu.%3.3lu", L_LOCK,
395        (unsigned long) major(_st_buf.st_dev),
396	(unsigned long) major(_st_buf.st_rdev),
397	(unsigned long) minor(_st_buf.st_rdev));
398
399    return(cklock(lockname));
400}
401
402/*
403 * fd_cklock(fd) - determine if the device indicated by fd is locked
404 *
405 * return -
406 *	SUCCESS - the fd is not locked
407 *	FAIL - the fd is locked by another process
408 */
409
410GLOBAL int
411fd_cklock(fd)
412int fd;
413{
414    if ( fstat(fd, &_st_buf) != 0 )
415	return(FAIL);
416
417    (void) sprintf(lockname, "%s.%3.3lu.%3.3lu.%3.3lu", L_LOCK,
418        (unsigned long) major(_st_buf.st_dev),
419	(unsigned long) major(_st_buf.st_rdev),
420	(unsigned long) minor(_st_buf.st_rdev));
421
422    if ( cklock(lockname) == FAIL )
423	return(FAIL);
424    else
425	return( lockf(fd, F_TEST, 0L) );
426}
427
428/*
429 * remove the locks associated with the device file descriptor
430 *
431 * return -
432 *	SUCCESS - both BNU lock file and advisory locks removed
433 *	FAIL -
434 */
435
436GLOBAL void
437fd_rmlock(fd)
438int fd;
439{
440    if ( fstat(fd, &_st_buf) == 0 ) {
441        (void) sprintf(lockname, "%s.%3.3lu.%3.3lu.%3.3lu", L_LOCK,
442            (unsigned long) major(_st_buf.st_dev),
443	    (unsigned long) major(_st_buf.st_rdev),
444	    (unsigned long) minor(_st_buf.st_rdev));
445        rmlock(lockname);
446    }
447    (void) lockf(fd, F_ULOCK, 0L);
448    return;
449}
450