1/*
2 * utils.c - various utility functions used in pppd.
3 *
4 * Copyright (c) 1999-2002 Paul Mackerras. All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 *
13 * 2. The name(s) of the authors of this software must not be used to
14 *    endorse or promote products derived from this software without
15 *    prior written permission.
16 *
17 * 3. Redistributions of any form whatsoever must retain the following
18 *    acknowledgment:
19 *    "This product includes software developed by Paul Mackerras
20 *     <paulus@samba.org>".
21 *
22 * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
23 * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
24 * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
25 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
26 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
27 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
28 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
29 */
30
31#include "netif/ppp/ppp_opts.h"
32#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */
33
34#if 0 /* UNUSED */
35#include <stdio.h>
36#include <ctype.h>
37#include <stdlib.h>
38#include <string.h>
39#include <unistd.h>
40#include <signal.h>
41#include <errno.h>
42#include <fcntl.h>
43#include <syslog.h>
44#include <netdb.h>
45#include <time.h>
46#include <utmp.h>
47#include <pwd.h>
48#include <sys/param.h>
49#include <sys/types.h>
50#include <sys/wait.h>
51#include <sys/time.h>
52#include <sys/resource.h>
53#include <sys/stat.h>
54#include <sys/socket.h>
55#include <netinet/in.h>
56#ifdef SVR4
57#include <sys/mkdev.h>
58#endif
59#endif /* UNUSED */
60
61#include <ctype.h>  /* isdigit() */
62
63#include "netif/ppp/ppp_impl.h"
64
65#include "netif/ppp/fsm.h"
66#include "netif/ppp/lcp.h"
67
68#if defined(SUNOS4)
69extern char *strerror();
70#endif
71
72static void ppp_logit(int level, const char *fmt, va_list args);
73static void ppp_log_write(int level, char *buf);
74#if PRINTPKT_SUPPORT
75static void ppp_vslp_printer(void *arg, const char *fmt, ...);
76static void ppp_format_packet(const u_char *p, int len,
77		void (*printer) (void *, const char *, ...), void *arg);
78
79struct buffer_info {
80    char *ptr;
81    int len;
82};
83#endif /* PRINTPKT_SUPPORT */
84
85/*
86 * ppp_strlcpy - like strcpy/strncpy, doesn't overflow destination buffer,
87 * always leaves destination null-terminated (for len > 0).
88 */
89size_t ppp_strlcpy(char *dest, const char *src, size_t len) {
90    size_t ret = strlen(src);
91
92    if (len != 0) {
93	if (ret < len)
94	    strcpy(dest, src);
95	else {
96	    strncpy(dest, src, len - 1);
97	    dest[len-1] = 0;
98	}
99    }
100    return ret;
101}
102
103/*
104 * ppp_strlcat - like strcat/strncat, doesn't overflow destination buffer,
105 * always leaves destination null-terminated (for len > 0).
106 */
107size_t ppp_strlcat(char *dest, const char *src, size_t len) {
108    size_t dlen = strlen(dest);
109
110    return dlen + ppp_strlcpy(dest + dlen, src, (len > dlen? len - dlen: 0));
111}
112
113
114/*
115 * ppp_slprintf - format a message into a buffer.  Like sprintf except we
116 * also specify the length of the output buffer, and we handle
117 * %m (error message), %v (visible string),
118 * %q (quoted string), %t (current time) and %I (IP address) formats.
119 * Doesn't do floating-point formats.
120 * Returns the number of chars put into buf.
121 */
122int ppp_slprintf(char *buf, int buflen, const char *fmt, ...) {
123    va_list args;
124    int n;
125
126    va_start(args, fmt);
127    n = ppp_vslprintf(buf, buflen, fmt, args);
128    va_end(args);
129    return n;
130}
131
132/*
133 * ppp_vslprintf - like ppp_slprintf, takes a va_list instead of a list of args.
134 */
135#define OUTCHAR(c)	(buflen > 0? (--buflen, *buf++ = (c)): 0)
136
137int ppp_vslprintf(char *buf, int buflen, const char *fmt, va_list args) {
138    int c, i, n;
139    int width, prec, fillch;
140    int base, len, neg, quoted;
141    unsigned long val = 0;
142    const char *f;
143    char *str, *buf0;
144    const unsigned char *p;
145    char num[32];
146#if 0 /* need port */
147    time_t t;
148#endif /* need port */
149    u32_t ip;
150    static char hexchars[] = "0123456789abcdef";
151#if PRINTPKT_SUPPORT
152    struct buffer_info bufinfo;
153#endif /* PRINTPKT_SUPPORT */
154
155    buf0 = buf;
156    --buflen;
157    while (buflen > 0) {
158	for (f = fmt; *f != '%' && *f != 0; ++f)
159	    ;
160	if (f > fmt) {
161	    len = f - fmt;
162	    if (len > buflen)
163		len = buflen;
164	    memcpy(buf, fmt, len);
165	    buf += len;
166	    buflen -= len;
167	    fmt = f;
168	}
169	if (*fmt == 0)
170	    break;
171	c = *++fmt;
172	width = 0;
173	prec = -1;
174	fillch = ' ';
175	if (c == '0') {
176	    fillch = '0';
177	    c = *++fmt;
178	}
179	if (c == '*') {
180	    width = va_arg(args, int);
181	    c = *++fmt;
182	} else {
183	    while (isdigit(c)) {
184		width = width * 10 + c - '0';
185		c = *++fmt;
186	    }
187	}
188	if (c == '.') {
189	    c = *++fmt;
190	    if (c == '*') {
191		prec = va_arg(args, int);
192		c = *++fmt;
193	    } else {
194		prec = 0;
195		while (isdigit(c)) {
196		    prec = prec * 10 + c - '0';
197		    c = *++fmt;
198		}
199	    }
200	}
201	str = 0;
202	base = 0;
203	neg = 0;
204	++fmt;
205	switch (c) {
206	case 'l':
207	    c = *fmt++;
208	    switch (c) {
209	    case 'd':
210		val = va_arg(args, long);
211		if ((long)val < 0) {
212		    neg = 1;
213		    val = (unsigned long)-(long)val;
214		}
215		base = 10;
216		break;
217	    case 'u':
218		val = va_arg(args, unsigned long);
219		base = 10;
220		break;
221	    default:
222		OUTCHAR('%');
223		OUTCHAR('l');
224		--fmt;		/* so %lz outputs %lz etc. */
225		continue;
226	    }
227	    break;
228	case 'd':
229	    i = va_arg(args, int);
230	    if (i < 0) {
231		neg = 1;
232		val = -i;
233	    } else
234		val = i;
235	    base = 10;
236	    break;
237	case 'u':
238	    val = va_arg(args, unsigned int);
239	    base = 10;
240	    break;
241	case 'o':
242	    val = va_arg(args, unsigned int);
243	    base = 8;
244	    break;
245	case 'x':
246	case 'X':
247	    val = va_arg(args, unsigned int);
248	    base = 16;
249	    break;
250#if 0 /* unused (and wrong on LLP64 systems) */
251	case 'p':
252	    val = (unsigned long) va_arg(args, void *);
253	    base = 16;
254	    neg = 2;
255	    break;
256#endif /* unused (and wrong on LLP64 systems) */
257	case 's':
258	    str = va_arg(args, char *);
259	    break;
260	case 'c':
261	    num[0] = va_arg(args, int);
262	    num[1] = 0;
263	    str = num;
264	    break;
265#if 0 /* do we always have strerror() in embedded ? */
266	case 'm':
267	    str = strerror(errno);
268	    break;
269#endif /* do we always have strerror() in embedded ? */
270	case 'I':
271	    ip = va_arg(args, u32_t);
272	    ip = lwip_ntohl(ip);
273	    ppp_slprintf(num, sizeof(num), "%d.%d.%d.%d", (ip >> 24) & 0xff,
274		     (ip >> 16) & 0xff, (ip >> 8) & 0xff, ip & 0xff);
275	    str = num;
276	    break;
277#if 0 /* need port */
278	case 't':
279	    time(&t);
280	    str = ctime(&t);
281	    str += 4;		/* chop off the day name */
282	    str[15] = 0;	/* chop off year and newline */
283	    break;
284#endif /* need port */
285	case 'v':		/* "visible" string */
286	case 'q':		/* quoted string */
287	    quoted = c == 'q';
288	    p = va_arg(args, unsigned char *);
289	    if (p == NULL)
290		p = (const unsigned char *)"<NULL>";
291	    if (fillch == '0' && prec >= 0) {
292		n = prec;
293	    } else {
294		n = strlen((const char *)p);
295		if (prec >= 0 && n > prec)
296		    n = prec;
297	    }
298	    while (n > 0 && buflen > 0) {
299		c = *p++;
300		--n;
301		if (!quoted && c >= 0x80) {
302		    OUTCHAR('M');
303		    OUTCHAR('-');
304		    c -= 0x80;
305		}
306		if (quoted && (c == '"' || c == '\\'))
307		    OUTCHAR('\\');
308		if (c < 0x20 || (0x7f <= c && c < 0xa0)) {
309		    if (quoted) {
310			OUTCHAR('\\');
311			switch (c) {
312			case '\t':	OUTCHAR('t');	break;
313			case '\n':	OUTCHAR('n');	break;
314			case '\b':	OUTCHAR('b');	break;
315			case '\f':	OUTCHAR('f');	break;
316			default:
317			    OUTCHAR('x');
318			    OUTCHAR(hexchars[c >> 4]);
319			    OUTCHAR(hexchars[c & 0xf]);
320			}
321		    } else {
322			if (c == '\t')
323			    OUTCHAR(c);
324			else {
325			    OUTCHAR('^');
326			    OUTCHAR(c ^ 0x40);
327			}
328		    }
329		} else
330		    OUTCHAR(c);
331	    }
332	    continue;
333#if PRINTPKT_SUPPORT
334	case 'P':		/* print PPP packet */
335	    bufinfo.ptr = buf;
336	    bufinfo.len = buflen + 1;
337	    p = va_arg(args, unsigned char *);
338	    n = va_arg(args, int);
339	    ppp_format_packet(p, n, ppp_vslp_printer, &bufinfo);
340	    buf = bufinfo.ptr;
341	    buflen = bufinfo.len - 1;
342	    continue;
343#endif /* PRINTPKT_SUPPORT */
344	case 'B':
345	    p = va_arg(args, unsigned char *);
346	    for (n = prec; n > 0; --n) {
347		c = *p++;
348		if (fillch == ' ')
349		    OUTCHAR(' ');
350		OUTCHAR(hexchars[(c >> 4) & 0xf]);
351		OUTCHAR(hexchars[c & 0xf]);
352	    }
353	    continue;
354	default:
355	    *buf++ = '%';
356	    if (c != '%')
357		--fmt;		/* so %z outputs %z etc. */
358	    --buflen;
359	    continue;
360	}
361	if (base != 0) {
362	    str = num + sizeof(num);
363	    *--str = 0;
364	    while (str > num + neg) {
365		*--str = hexchars[val % base];
366		val = val / base;
367		if (--prec <= 0 && val == 0)
368		    break;
369	    }
370	    switch (neg) {
371	    case 1:
372		*--str = '-';
373		break;
374	    case 2:
375		*--str = 'x';
376		*--str = '0';
377		break;
378	    default:
379		break;
380	    }
381	    len = num + sizeof(num) - 1 - str;
382	} else {
383	    len = strlen(str);
384	    if (prec >= 0 && len > prec)
385		len = prec;
386	}
387	if (width > 0) {
388	    if (width > buflen)
389		width = buflen;
390	    if ((n = width - len) > 0) {
391		buflen -= n;
392		for (; n > 0; --n)
393		    *buf++ = fillch;
394	    }
395	}
396	if (len > buflen)
397	    len = buflen;
398	memcpy(buf, str, len);
399	buf += len;
400	buflen -= len;
401    }
402    *buf = 0;
403    return buf - buf0;
404}
405
406#if PRINTPKT_SUPPORT
407/*
408 * vslp_printer - used in processing a %P format
409 */
410static void ppp_vslp_printer(void *arg, const char *fmt, ...) {
411    int n;
412    va_list pvar;
413    struct buffer_info *bi;
414
415    va_start(pvar, fmt);
416    bi = (struct buffer_info *) arg;
417    n = ppp_vslprintf(bi->ptr, bi->len, fmt, pvar);
418    va_end(pvar);
419
420    bi->ptr += n;
421    bi->len -= n;
422}
423#endif /* PRINTPKT_SUPPORT */
424
425#if 0 /* UNUSED */
426/*
427 * log_packet - format a packet and log it.
428 */
429
430void
431log_packet(p, len, prefix, level)
432    u_char *p;
433    int len;
434    char *prefix;
435    int level;
436{
437	init_pr_log(prefix, level);
438	ppp_format_packet(p, len, pr_log, &level);
439	end_pr_log();
440}
441#endif /* UNUSED */
442
443#if PRINTPKT_SUPPORT
444/*
445 * ppp_format_packet - make a readable representation of a packet,
446 * calling `printer(arg, format, ...)' to output it.
447 */
448static void ppp_format_packet(const u_char *p, int len,
449		void (*printer) (void *, const char *, ...), void *arg) {
450    int i, n;
451    u_short proto;
452    const struct protent *protp;
453
454    if (len >= 2) {
455	GETSHORT(proto, p);
456	len -= 2;
457	for (i = 0; (protp = protocols[i]) != NULL; ++i)
458	    if (proto == protp->protocol)
459		break;
460	if (protp != NULL) {
461	    printer(arg, "[%s", protp->name);
462	    n = (*protp->printpkt)(p, len, printer, arg);
463	    printer(arg, "]");
464	    p += n;
465	    len -= n;
466	} else {
467	    for (i = 0; (protp = protocols[i]) != NULL; ++i)
468		if (proto == (protp->protocol & ~0x8000))
469		    break;
470	    if (protp != 0 && protp->data_name != 0) {
471		printer(arg, "[%s data]", protp->data_name);
472		if (len > 8)
473		    printer(arg, "%.8B ...", p);
474		else
475		    printer(arg, "%.*B", len, p);
476		len = 0;
477	    } else
478		printer(arg, "[proto=0x%x]", proto);
479	}
480    }
481
482    if (len > 32)
483	printer(arg, "%.32B ...", p);
484    else
485	printer(arg, "%.*B", len, p);
486}
487#endif /* PRINTPKT_SUPPORT */
488
489#if 0 /* UNUSED */
490/*
491 * init_pr_log, end_pr_log - initialize and finish use of pr_log.
492 */
493
494static char line[256];		/* line to be logged accumulated here */
495static char *linep;		/* current pointer within line */
496static int llevel;		/* level for logging */
497
498void
499init_pr_log(prefix, level)
500     const char *prefix;
501     int level;
502{
503	linep = line;
504	if (prefix != NULL) {
505		ppp_strlcpy(line, prefix, sizeof(line));
506		linep = line + strlen(line);
507	}
508	llevel = level;
509}
510
511void
512end_pr_log()
513{
514	if (linep != line) {
515		*linep = 0;
516		ppp_log_write(llevel, line);
517	}
518}
519
520/*
521 * pr_log - printer routine for outputting to log
522 */
523void
524pr_log (void *arg, const char *fmt, ...)
525{
526	int l, n;
527	va_list pvar;
528	char *p, *eol;
529	char buf[256];
530
531	va_start(pvar, fmt);
532	n = ppp_vslprintf(buf, sizeof(buf), fmt, pvar);
533	va_end(pvar);
534
535	p = buf;
536	eol = strchr(buf, '\n');
537	if (linep != line) {
538		l = (eol == NULL)? n: eol - buf;
539		if (linep + l < line + sizeof(line)) {
540			if (l > 0) {
541				memcpy(linep, buf, l);
542				linep += l;
543			}
544			if (eol == NULL)
545				return;
546			p = eol + 1;
547			eol = strchr(p, '\n');
548		}
549		*linep = 0;
550		ppp_log_write(llevel, line);
551		linep = line;
552	}
553
554	while (eol != NULL) {
555		*eol = 0;
556		ppp_log_write(llevel, p);
557		p = eol + 1;
558		eol = strchr(p, '\n');
559	}
560
561	/* assumes sizeof(buf) <= sizeof(line) */
562	l = buf + n - p;
563	if (l > 0) {
564		memcpy(line, p, n);
565		linep = line + l;
566	}
567}
568#endif /* UNUSED */
569
570/*
571 * ppp_print_string - print a readable representation of a string using
572 * printer.
573 */
574void ppp_print_string(const u_char *p, int len, void (*printer) (void *, const char *, ...), void *arg) {
575    int c;
576
577    printer(arg, "\"");
578    for (; len > 0; --len) {
579	c = *p++;
580	if (' ' <= c && c <= '~') {
581	    if (c == '\\' || c == '"')
582		printer(arg, "\\");
583	    printer(arg, "%c", c);
584	} else {
585	    switch (c) {
586	    case '\n':
587		printer(arg, "\\n");
588		break;
589	    case '\r':
590		printer(arg, "\\r");
591		break;
592	    case '\t':
593		printer(arg, "\\t");
594		break;
595	    default:
596		printer(arg, "\\%.3o", (u8_t)c);
597		/* no break */
598	    }
599	}
600    }
601    printer(arg, "\"");
602}
603
604/*
605 * ppp_logit - does the hard work for fatal et al.
606 */
607static void ppp_logit(int level, const char *fmt, va_list args) {
608    char buf[1024];
609
610    ppp_vslprintf(buf, sizeof(buf), fmt, args);
611    ppp_log_write(level, buf);
612}
613
614static void ppp_log_write(int level, char *buf) {
615    LWIP_UNUSED_ARG(level); /* necessary if PPPDEBUG is defined to an empty function */
616    LWIP_UNUSED_ARG(buf);
617    PPPDEBUG(level, ("%s\n", buf) );
618#if 0
619    if (log_to_fd >= 0 && (level != LOG_DEBUG || debug)) {
620	int n = strlen(buf);
621
622	if (n > 0 && buf[n-1] == '\n')
623	    --n;
624	if (write(log_to_fd, buf, n) != n
625	    || write(log_to_fd, "\n", 1) != 1)
626	    log_to_fd = -1;
627    }
628#endif
629}
630
631/*
632 * ppp_fatal - log an error message and die horribly.
633 */
634void ppp_fatal(const char *fmt, ...) {
635    va_list pvar;
636
637    va_start(pvar, fmt);
638    ppp_logit(LOG_ERR, fmt, pvar);
639    va_end(pvar);
640
641    LWIP_ASSERT("ppp_fatal", 0);   /* as promised */
642}
643
644/*
645 * ppp_error - log an error message.
646 */
647void ppp_error(const char *fmt, ...) {
648    va_list pvar;
649
650    va_start(pvar, fmt);
651    ppp_logit(LOG_ERR, fmt, pvar);
652    va_end(pvar);
653#if 0 /* UNUSED */
654    ++error_count;
655#endif /* UNUSED */
656}
657
658/*
659 * ppp_warn - log a warning message.
660 */
661void ppp_warn(const char *fmt, ...) {
662    va_list pvar;
663
664    va_start(pvar, fmt);
665    ppp_logit(LOG_WARNING, fmt, pvar);
666    va_end(pvar);
667}
668
669/*
670 * ppp_notice - log a notice-level message.
671 */
672void ppp_notice(const char *fmt, ...) {
673    va_list pvar;
674
675    va_start(pvar, fmt);
676    ppp_logit(LOG_NOTICE, fmt, pvar);
677    va_end(pvar);
678}
679
680/*
681 * ppp_info - log an informational message.
682 */
683void ppp_info(const char *fmt, ...) {
684    va_list pvar;
685
686    va_start(pvar, fmt);
687    ppp_logit(LOG_INFO, fmt, pvar);
688    va_end(pvar);
689}
690
691/*
692 * ppp_dbglog - log a debug message.
693 */
694void ppp_dbglog(const char *fmt, ...) {
695    va_list pvar;
696
697    va_start(pvar, fmt);
698    ppp_logit(LOG_DEBUG, fmt, pvar);
699    va_end(pvar);
700}
701
702#if PRINTPKT_SUPPORT
703/*
704 * ppp_dump_packet - print out a packet in readable form if it is interesting.
705 * Assumes len >= PPP_HDRLEN.
706 */
707void ppp_dump_packet(ppp_pcb *pcb, const char *tag, unsigned char *p, int len) {
708    int proto;
709
710    /*
711     * don't print data packets, i.e. IPv4, IPv6, VJ, and compressed packets.
712     */
713    proto = (p[0] << 8) + p[1];
714    if (proto < 0xC000 && (proto & ~0x8000) == proto)
715	return;
716
717    /*
718     * don't print valid LCP echo request/reply packets if the link is up.
719     */
720    if (proto == PPP_LCP && pcb->phase == PPP_PHASE_RUNNING && len >= 2 + HEADERLEN) {
721	unsigned char *lcp = p + 2;
722	int l = (lcp[2] << 8) + lcp[3];
723
724	if ((lcp[0] == ECHOREQ || lcp[0] == ECHOREP)
725	    && l >= HEADERLEN && l <= len - 2)
726	    return;
727    }
728
729    ppp_dbglog("%s %P", tag, p, len);
730}
731#endif /* PRINTPKT_SUPPORT */
732
733#if 0 /* Unused */
734
735/*
736 * complete_read - read a full `count' bytes from fd,
737 * unless end-of-file or an error other than EINTR is encountered.
738 */
739ssize_t
740complete_read(int fd, void *buf, size_t count)
741{
742	size_t done;
743	ssize_t nb;
744	char *ptr = buf;
745
746	for (done = 0; done < count; ) {
747		nb = read(fd, ptr, count - done);
748		if (nb < 0) {
749			if (errno == EINTR)
750				continue;
751			return -1;
752		}
753		if (nb == 0)
754			break;
755		done += nb;
756		ptr += nb;
757	}
758	return done;
759}
760
761/* Procedures for locking the serial device using a lock file. */
762#ifndef LOCK_DIR
763#ifdef __linux__
764#define LOCK_DIR	"/var/lock"
765#else
766#ifdef SVR4
767#define LOCK_DIR	"/var/spool/locks"
768#else
769#define LOCK_DIR	"/var/spool/lock"
770#endif
771#endif
772#endif /* LOCK_DIR */
773
774static char lock_file[MAXPATHLEN];
775
776/*
777 * lock - create a lock file for the named device
778 */
779int
780lock(dev)
781    char *dev;
782{
783#ifdef LOCKLIB
784    int result;
785
786    result = mklock (dev, (void *) 0);
787    if (result == 0) {
788	ppp_strlcpy(lock_file, dev, sizeof(lock_file));
789	return 0;
790    }
791
792    if (result > 0)
793        ppp_notice("Device %s is locked by pid %d", dev, result);
794    else
795	ppp_error("Can't create lock file %s", lock_file);
796    return -1;
797
798#else /* LOCKLIB */
799
800    char lock_buffer[12];
801    int fd, pid, n;
802
803#ifdef SVR4
804    struct stat sbuf;
805
806    if (stat(dev, &sbuf) < 0) {
807	ppp_error("Can't get device number for %s: %m", dev);
808	return -1;
809    }
810    if ((sbuf.st_mode & S_IFMT) != S_IFCHR) {
811	ppp_error("Can't lock %s: not a character device", dev);
812	return -1;
813    }
814    ppp_slprintf(lock_file, sizeof(lock_file), "%s/LK.%03d.%03d.%03d",
815	     LOCK_DIR, major(sbuf.st_dev),
816	     major(sbuf.st_rdev), minor(sbuf.st_rdev));
817#else
818    char *p;
819    char lockdev[MAXPATHLEN];
820
821    if ((p = strstr(dev, "dev/")) != NULL) {
822	dev = p + 4;
823	strncpy(lockdev, dev, MAXPATHLEN-1);
824	lockdev[MAXPATHLEN-1] = 0;
825	while ((p = strrchr(lockdev, '/')) != NULL) {
826	    *p = '_';
827	}
828	dev = lockdev;
829    } else
830	if ((p = strrchr(dev, '/')) != NULL)
831	    dev = p + 1;
832
833    ppp_slprintf(lock_file, sizeof(lock_file), "%s/LCK..%s", LOCK_DIR, dev);
834#endif
835
836    while ((fd = open(lock_file, O_EXCL | O_CREAT | O_RDWR, 0644)) < 0) {
837	if (errno != EEXIST) {
838	    ppp_error("Can't create lock file %s: %m", lock_file);
839	    break;
840	}
841
842	/* Read the lock file to find out who has the device locked. */
843	fd = open(lock_file, O_RDONLY, 0);
844	if (fd < 0) {
845	    if (errno == ENOENT) /* This is just a timing problem. */
846		continue;
847	    ppp_error("Can't open existing lock file %s: %m", lock_file);
848	    break;
849	}
850#ifndef LOCK_BINARY
851	n = read(fd, lock_buffer, 11);
852#else
853	n = read(fd, &pid, sizeof(pid));
854#endif /* LOCK_BINARY */
855	close(fd);
856	fd = -1;
857	if (n <= 0) {
858	    ppp_error("Can't read pid from lock file %s", lock_file);
859	    break;
860	}
861
862	/* See if the process still exists. */
863#ifndef LOCK_BINARY
864	lock_buffer[n] = 0;
865	pid = atoi(lock_buffer);
866#endif /* LOCK_BINARY */
867	if (pid == getpid())
868	    return 1;		/* somebody else locked it for us */
869	if (pid == 0
870	    || (kill(pid, 0) == -1 && errno == ESRCH)) {
871	    if (unlink (lock_file) == 0) {
872		ppp_notice("Removed stale lock on %s (pid %d)", dev, pid);
873		continue;
874	    }
875	    ppp_warn("Couldn't remove stale lock on %s", dev);
876	} else
877	    ppp_notice("Device %s is locked by pid %d", dev, pid);
878	break;
879    }
880
881    if (fd < 0) {
882	lock_file[0] = 0;
883	return -1;
884    }
885
886    pid = getpid();
887#ifndef LOCK_BINARY
888    ppp_slprintf(lock_buffer, sizeof(lock_buffer), "%10d\n", pid);
889    write (fd, lock_buffer, 11);
890#else
891    write(fd, &pid, sizeof (pid));
892#endif
893    close(fd);
894    return 0;
895
896#endif
897}
898
899/*
900 * relock - called to update our lockfile when we are about to detach,
901 * thus changing our pid (we fork, the child carries on, and the parent dies).
902 * Note that this is called by the parent, with pid equal to the pid
903 * of the child.  This avoids a potential race which would exist if
904 * we had the child rewrite the lockfile (the parent might die first,
905 * and another process could think the lock was stale if it checked
906 * between when the parent died and the child rewrote the lockfile).
907 */
908int
909relock(pid)
910    int pid;
911{
912#ifdef LOCKLIB
913    /* XXX is there a way to do this? */
914    return -1;
915#else /* LOCKLIB */
916
917    int fd;
918    char lock_buffer[12];
919
920    if (lock_file[0] == 0)
921	return -1;
922    fd = open(lock_file, O_WRONLY, 0);
923    if (fd < 0) {
924	ppp_error("Couldn't reopen lock file %s: %m", lock_file);
925	lock_file[0] = 0;
926	return -1;
927    }
928
929#ifndef LOCK_BINARY
930    ppp_slprintf(lock_buffer, sizeof(lock_buffer), "%10d\n", pid);
931    write (fd, lock_buffer, 11);
932#else
933    write(fd, &pid, sizeof(pid));
934#endif /* LOCK_BINARY */
935    close(fd);
936    return 0;
937
938#endif /* LOCKLIB */
939}
940
941/*
942 * unlock - remove our lockfile
943 */
944void
945unlock()
946{
947    if (lock_file[0]) {
948#ifdef LOCKLIB
949	(void) rmlock(lock_file, (void *) 0);
950#else
951	unlink(lock_file);
952#endif
953	lock_file[0] = 0;
954    }
955}
956
957#endif /* Unused */
958
959#endif /* PPP_SUPPORT */
960