33b3e21535d671bda0fedb1e61e0c59bb1e295bb
[ppp.git] / pppd / main.c
1 /*
2  * main.c - Point-to-Point Protocol main module
3  *
4  * Copyright (c) 1989 Carnegie Mellon University.
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms are permitted
8  * provided that the above copyright notice and this paragraph are
9  * duplicated in all such forms and that any documentation,
10  * advertising materials, and other materials related to such
11  * distribution and use acknowledge that the software was developed
12  * by Carnegie Mellon University.  The name of the
13  * University may not be used to endorse or promote products derived
14  * from this software without specific prior written permission.
15  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
17  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18  */
19
20 #ifndef lint
21 static char rcsid[] = "$Id: main.c,v 1.8 1994/05/01 11:44:43 paulus Exp $";
22 #endif
23
24 #define SETSID
25
26 #include <stdio.h>
27 #include <signal.h>
28 #include <errno.h>
29 #include <fcntl.h>
30 #include <syslog.h>
31 #include <netdb.h>
32 #include <utmp.h>
33 #include <sys/wait.h>
34
35 /*
36  * If REQ_SYSOPTIONS is defined to 1, pppd will not run unless
37  * /etc/ppp/options exists.
38  */
39 #ifndef REQ_SYSOPTIONS
40 #define REQ_SYSOPTIONS  0
41 #endif
42
43 #ifdef STREAMS
44 #undef SGTTY
45 #endif
46
47 #ifdef SGTTY
48 #include <sgtty.h>
49 #else
50 #ifndef sun
51 #include <sys/ioctl.h>
52 #endif
53 #include <termios.h>
54 #endif
55
56 #include <sys/param.h>
57 #include <sys/types.h>
58 #include <sys/stat.h>
59 #include <sys/socket.h>
60 #include <sys/time.h>
61
62 #include "callout.h"
63
64 #include <net/if.h>
65 #include <net/if_ppp.h>
66
67 #include <string.h>
68
69 #ifndef BSD
70 #define BSD 43
71 #endif /*BSD*/
72
73 #include "ppp.h"
74 #include "magic.h"
75 #include "fsm.h"
76 #include "lcp.h"
77 #include "ipcp.h"
78 #include "upap.h"
79 #include "chap.h"
80
81 #include "pppd.h"
82 #include "pathnames.h"
83 #include "patchlevel.h"
84
85
86 #ifndef TRUE
87 #define TRUE (1)
88 #endif /*TRUE*/
89
90 #ifndef FALSE
91 #define FALSE (0)
92 #endif /*FALSE*/
93
94 #ifdef PIDPATH
95 static char *pidpath = PIDPATH; /* filename in which pid will be stored */
96 #else
97 static char *pidpath = _PATH_PIDFILE;
98 #endif /* PIDFILE */
99
100 /* interface vars */
101 char ifname[IFNAMSIZ];          /* Interface name */
102 int ifunit;                     /* Interface unit number */
103
104 char *progname;                 /* Name of this program */
105 char hostname[MAXNAMELEN];      /* Our hostname */
106 char our_name[MAXNAMELEN];
107 char remote_name[MAXNAMELEN];
108
109 static pid_t    pid;            /* Our pid */
110 static pid_t    pgrpid;         /* Process Group ID */
111 static char pidfilename[MAXPATHLEN];
112
113 char devname[MAXPATHLEN] = "/dev/tty";  /* Device name */
114 int default_device = TRUE;      /* use default device (stdin/out) */
115
116 int fd;                         /* Device file descriptor */
117 int s;                          /* Socket file descriptor */
118
119 int phase;                      /* where the link is at */
120
121 #ifdef SGTTY
122 static struct sgttyb initsgttyb;        /* Initial TTY sgttyb */
123 #else
124 static struct termios inittermios;      /* Initial TTY termios */
125 #endif
126
127 static int initfdflags = -1;    /* Initial file descriptor flags */
128
129 static int restore_term;        /* 1 => we've munged the terminal */
130
131 u_char outpacket_buf[MTU+DLLHEADERLEN]; /* buffer for outgoing packet */
132 static u_char inpacket_buf[MTU+DLLHEADERLEN]; /* buffer for incoming packet */
133
134 int hungup;                     /* terminal has been hung up */
135 static int n_children;          /* # child processes still running */
136
137 /* configured variables */
138
139 int debug = 0;                  /* Debug flag */
140 int kdebugflag = 0;             /* Kernel debugging flag */
141 char user[MAXNAMELEN];          /* username for PAP */
142 char passwd[MAXSECRETLEN];      /* password for PAP */
143 char *connector = NULL;         /* "connect" command */
144 char *disconnector = NULL;      /* "disconnect" command */
145 int inspeed = 0;                /* Input/Output speed requested */
146 int baud_rate;                  /* bits/sec currently used */
147 u_long netmask = 0;             /* netmask to use on ppp interface */
148 int crtscts = 0;                /* use h/w flow control */
149 int nodetach = 0;               /* don't fork */
150 int modem = 0;                  /* use modem control lines */
151 int auth_required = 0;          /* require peer to authenticate */
152 int defaultroute = 0;           /* assign default route through interface */
153 int proxyarp = 0;               /* set entry in arp table */
154 int persist = 0;                /* re-initiate on termination */
155 int answer = 0;                 /* wait for incoming call */
156 int uselogin = 0;               /* check PAP info against /etc/passwd */
157 int lockflag = 0;               /* lock the serial device */
158
159
160 /* prototypes */
161 static void hup __ARGS((int, int, struct sigcontext *, char *));
162 static void intr __ARGS((int, int, struct sigcontext *, char *));
163 static void term __ARGS((int, int, struct sigcontext *, char *));
164 static void alrm __ARGS((int, int, struct sigcontext *, char *));
165 static void io __ARGS((int, int, struct sigcontext *, char *));
166 static void incdebug __ARGS((int));
167 static void nodebug __ARGS((int));
168 void establish_ppp __ARGS((void));
169
170 void reap_kids __ARGS((void));
171 void cleanup __ARGS((int, caddr_t));
172 void die __ARGS((int));
173 void novm __ARGS((char *));
174
175 void log_packet __ARGS((u_char *, int, char *));
176 void format_packet __ARGS((u_char *, int,
177                            void (*) (void *, char *, ...), void *));
178 void pr_log __ARGS((void *, char *, ...));
179
180 #ifdef  STREAMS
181 extern  char    *ttyname __ARGS((int));
182 #endif
183 extern  char    *getlogin __ARGS((void));
184
185 /*
186  * PPP Data Link Layer "protocol" table.
187  * One entry per supported protocol.
188  */
189 static struct protent {
190     u_short protocol;
191     void (*init)();
192     void (*input)();
193     void (*protrej)();
194     int  (*printpkt)();
195     char *name;
196 } prottbl[] = {
197     { LCP, lcp_init, lcp_input, lcp_protrej, lcp_printpkt, "LCP" },
198     { IPCP, ipcp_init, ipcp_input, ipcp_protrej, ipcp_printpkt, "IPCP" },
199     { UPAP, upap_init, upap_input, upap_protrej, upap_printpkt, "PAP" },
200     { CHAP, ChapInit, ChapInput, ChapProtocolReject, ChapPrintPkt, "CHAP" },
201 };
202
203 #define N_PROTO         (sizeof(prottbl) / sizeof(prottbl[0]))
204
205 main(argc, argv)
206     int argc;
207     char *argv[];
208 {
209     int mask, i;
210     struct sigvec sv;
211     struct cmd *cmdp;
212     FILE *pidfile;
213     char *p;
214
215 #ifdef STREAMS
216     p = ttyname(fileno(stdin));
217     if (p)
218         strcpy(devname, p);
219 #endif
220   
221     if (gethostname(hostname, MAXNAMELEN) < 0 ) {
222         perror("couldn't get hostname");
223         die(1);
224     }
225     hostname[MAXNAMELEN-1] = 0;
226
227     pid = getpid();
228
229     if (!ppp_available()) {
230         fprintf(stderr, "Sorry - PPP is not available on this system\n");
231         exit(1);
232     }
233
234     /*
235      * Initialize to the standard option set, then parse, in order,
236      * the system options file, the user's options file, and the command
237      * line arguments.
238      */
239     for (i = 0; i < N_PROTO; i++)
240         (*prottbl[i].init)(0);
241   
242     progname = *argv;
243
244     if (!options_from_file(_PATH_SYSOPTIONS, REQ_SYSOPTIONS) ||
245         !options_from_user() ||
246         !parse_args(argc-1, argv+1))
247         die(1);
248     check_auth_options();
249     setipdefault();
250
251     if (lockflag && !default_device)
252         if (lock(devname) < 0)
253             die(1);
254
255     /*
256      * Initialize syslog system and magic number package.
257      */
258 #if (BSD >= 43 || defined(sun)) && !defined(ultrix)
259     openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
260     setlogmask(LOG_UPTO(LOG_INFO));
261 #else
262     openlog("pppd", LOG_PID);
263 #define LOG_UPTO(x) (x)
264 #define setlogmask(x) (x)
265 #endif
266     if (debug)
267         setlogmask(LOG_UPTO(LOG_DEBUG));
268
269     magic_init();
270
271     p = getlogin();
272     if (p == NULL)
273         p = "(unknown)";
274     syslog(LOG_NOTICE, "pppd %s.%d started by %s, uid %d",
275            VERSION, PATCHLEVEL, p, getuid());
276
277 #ifdef SETSID
278     /*
279      * Make sure we can set the serial device to be our controlling terminal.
280      */
281     if (default_device) {
282         /*
283          * No device name was specified:
284          * we are in the device's session already.
285          */
286         if ((pgrpid = getpgrp(0)) < 0) {
287             syslog(LOG_ERR, "getpgrp(0): %m");
288             die(1);
289         }
290
291     } else {
292         /*
293          * Not default device: make sure we're not a process group leader,
294          * then become session leader of a new session (so we can make
295          * our device its controlling terminal and thus get SIGHUPs).
296          */
297         if (!nodetach) {
298             /* fork so we're not a process group leader */
299             if (pid = fork()) {
300                 exit(0);        /* parent is finished */
301             }
302             if (pid < 0) {
303                 syslog(LOG_ERR, "fork: %m");
304                 die(1);
305             }
306             pid = getpid();     /* otherwise pid is 0 in child */
307         } else {
308             /*
309              * try to put ourself into our parent's process group,
310              * so we're not a process group leader
311              */
312             if (setpgrp(pid, getppid()) < 0)
313                 syslog(LOG_WARNING, "setpgrp: %m");
314         }
315
316         /* create new session */
317         if ((pgrpid = setsid()) < 0) {
318             syslog(LOG_ERR, "setsid(): %m");
319             die(1);
320         }
321     }
322 #endif
323
324     /* Get an internet socket for doing socket ioctl's on. */
325     if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
326         syslog(LOG_ERR, "socket : %m");
327         die(1);
328     }
329   
330     /*
331      * Compute mask of all interesting signals and install signal handlers
332      * for each.  Only one signal handler may be active at a time.  Therefore,
333      * all other signals should be masked when any handler is executing.
334      */
335     sigemptyset(&mask);
336     sigaddset(&mask, SIGHUP);
337     sigaddset(&mask, SIGINT);
338     sigaddset(&mask, SIGALRM);
339     sigaddset(&mask, SIGIO);
340 #ifdef  STREAMS
341     sigaddset(&mask, SIGPOLL);
342 #endif
343
344 #define SIGNAL(s, handler)      { \
345         sv.sv_handler = handler; \
346         if (sigvec(s, &sv, NULL) < 0) { \
347             syslog(LOG_ERR, "sigvec(%d): %m", s); \
348             die(1); \
349         } \
350     }
351
352     sv.sv_mask = mask;
353     sv.sv_flags = 0;
354     SIGNAL(SIGHUP, hup);                /* Hangup */
355     SIGNAL(SIGINT, intr);               /* Interrupt */
356     SIGNAL(SIGTERM, term);              /* Terminate */
357     SIGNAL(SIGALRM, alrm);              /* Timeout */
358     SIGNAL(SIGIO, io);                  /* Input available */
359 #ifdef  STREAMS
360     SIGNAL(SIGPOLL, io);                /* Input available */
361 #endif
362
363     signal(SIGUSR1, incdebug);          /* Increment debug flag */
364     signal(SIGUSR2, nodebug);           /* Reset debug flag */
365
366     /*
367      * Block SIGIOs and SIGPOLLs for now
368      */
369     sigemptyset(&mask);
370     sigaddset(&mask, SIGIO);
371 #ifdef  STREAMS
372     sigaddset(&mask, SIGPOLL);
373 #endif
374     sigprocmask(SIG_BLOCK, &mask, NULL);
375
376     /*
377      * Open the serial device and set it up to be the ppp interface.
378      */
379     if ((fd = open(devname, O_RDWR /*| O_NDELAY*/)) < 0) {
380         syslog(LOG_ERR, "open(%s): %m", devname);
381         die(1);
382     }
383     hungup = 0;
384
385 #ifdef TIOCSCTTY
386     /* set device to be controlling tty */
387     if (!default_device && ioctl(fd, TIOCSCTTY) < 0) {
388         syslog(LOG_ERR, "ioctl(TIOCSCTTY): %m");
389         die(1);
390     }
391 #endif /* TIOCSCTTY */
392
393     /* run connection script */
394     if (connector) {
395         MAINDEBUG((LOG_INFO, "Connecting with <%s>", connector));
396
397         /* set line speed, flow control, etc.; set CLOCAL for now */
398         set_up_tty(fd, 1);
399
400         /* drop dtr to hang up in case modem is off hook */
401         if (!default_device && modem) {
402             setdtr(fd, FALSE);
403             sleep(1);
404             setdtr(fd, TRUE);
405         }
406
407         if (device_script(connector, fd, fd) < 0) {
408             syslog(LOG_ERR, "could not set up connection");
409             setdtr(fd, FALSE);
410             die(1);
411         }
412
413         syslog(LOG_INFO, "Connected...");
414         sleep(1);               /* give it time to set up its terminal */
415     }
416   
417     /* set line speed, flow control, etc.; clear CLOCAL if modem option */
418     set_up_tty(fd, 0);
419
420     /* set up the serial device as a ppp interface */
421     establish_ppp();
422
423     syslog(LOG_INFO, "Using interface ppp%d", ifunit);
424     (void) sprintf(ifname, "ppp%d", ifunit);
425
426     /* write pid to file */
427     (void) sprintf(pidfilename, "%s/%s.pid", pidpath, ifname);
428     if ((pidfile = fopen(pidfilename, "w")) != NULL) {
429         fprintf(pidfile, "%d\n", pid);
430         (void) fclose(pidfile);
431     } else {
432         syslog(LOG_ERR, "unable to create pid file: %m");
433         pidfilename[0] = 0;
434     }
435
436     /*
437      * Set process group of device to our process group so we can get
438      * SIGIOs and SIGHUPs.
439      */
440 #ifdef SETSID
441     if (default_device) {
442         int id = tcgetpgrp(fd);
443         if (id != pgrpid) {
444             syslog(LOG_WARNING, "warning: not in tty's process group");
445         }
446     } else {
447         if (tcsetpgrp(fd, pgrpid) < 0) {
448             syslog(LOG_ERR, "tcsetpgrp(): %m");
449             die(1);
450         }
451     }
452 #else
453     /* set process group on tty so we get SIGIO's */
454     if (ioctl(fd, TIOCSPGRP, &pgrpid) < 0) {
455         syslog(LOG_ERR, "ioctl(TIOCSPGRP): %m");
456         die(1);
457     }
458 #endif
459
460     /*
461      * Record initial device flags, then set device to cause SIGIO
462      * signals to be generated.
463      */
464     if ((initfdflags = fcntl(fd, F_GETFL)) == -1) {
465         syslog(LOG_ERR, "fcntl(F_GETFL): %m");
466         die(1);
467     }
468     if (fcntl(fd, F_SETFL, FNDELAY | FASYNC) == -1) {
469         syslog(LOG_ERR, "fcntl(F_SETFL, FNDELAY | FASYNC): %m");
470         die(1);
471     }
472   
473     /*
474      * Block all signals, start opening the connection, and  wait for
475      * incoming signals (reply, timeout, etc.).
476      */
477     syslog(LOG_NOTICE, "Connect: %s <--> %s", ifname, devname);
478     sigprocmask(SIG_BLOCK, &mask, NULL); /* Block signals now */
479     lcp_lowerup(0);             /* XXX Well, sort of... */
480     lcp_open(0);                /* Start protocol */
481     for (phase = PHASE_ESTABLISH; phase != PHASE_DEAD; ) {
482         sigpause(0);            /* Wait for next signal */
483         reap_kids();            /* Don't leave dead kids lying around */
484     }
485
486     /*
487      * Run disconnector script, if requested
488      */
489     if (disconnector) {
490         if (device_script(disconnector, fd, fd) < 0) {
491             syslog(LOG_WARNING, "disconnect script failed");
492             die(1);
493         }
494
495         syslog(LOG_INFO, "Disconnected...");
496     }
497
498     quit();
499 }
500
501 #if B9600 == 9600
502 /*
503  * XXX assume speed_t values numerically equal bits per second
504  * (so we can ask for any speed).
505  */
506 #define translate_speed(bps)    (bps)
507 #define baud_rate_of(speed)     (speed)
508
509 #else
510 /*
511  * List of valid speeds.
512  */
513 struct speed {
514     int speed_int, speed_val;
515 } speeds[] = {
516 #ifdef B50
517     { 50, B50 },
518 #endif
519 #ifdef B75
520     { 75, B75 },
521 #endif
522 #ifdef B110
523     { 110, B110 },
524 #endif
525 #ifdef B134
526     { 134, B134 },
527 #endif
528 #ifdef B150
529     { 150, B150 },
530 #endif
531 #ifdef B200
532     { 200, B200 },
533 #endif
534 #ifdef B300
535     { 300, B300 },
536 #endif
537 #ifdef B600
538     { 600, B600 },
539 #endif
540 #ifdef B1200
541     { 1200, B1200 },
542 #endif
543 #ifdef B1800
544     { 1800, B1800 },
545 #endif
546 #ifdef B2000
547     { 2000, B2000 },
548 #endif
549 #ifdef B2400
550     { 2400, B2400 },
551 #endif
552 #ifdef B3600
553     { 3600, B3600 },
554 #endif
555 #ifdef B4800
556     { 4800, B4800 },
557 #endif
558 #ifdef B7200
559     { 7200, B7200 },
560 #endif
561 #ifdef B9600
562     { 9600, B9600 },
563 #endif
564 #ifdef B19200
565     { 19200, B19200 },
566 #endif
567 #ifdef B38400
568     { 38400, B38400 },
569 #endif
570 #ifdef EXTA
571     { 19200, EXTA },
572 #endif
573 #ifdef EXTB
574     { 38400, EXTB },
575 #endif
576 #ifdef B57600
577     { 57600, B57600 },
578 #endif
579 #ifdef B115200
580     { 115200, B115200 },
581 #endif
582     { 0, 0 }
583 };
584
585 /*
586  * Translate from bits/second to a speed_t.
587  */
588 int
589 translate_speed(bps)
590     int bps;
591 {
592     struct speed *speedp;
593
594     if (bps == 0)
595         return 0;
596     for (speedp = speeds; speedp->speed_int; speedp++)
597         if (bps == speedp->speed_int)
598             return speedp->speed_val;
599     syslog(LOG_WARNING, "speed %d not supported", bps);
600     return 0;
601 }
602
603 /*
604  * Translate from a speed_t to bits/second.
605  */
606 int
607 baud_rate_of(speed)
608     int speed;
609 {
610     struct speed *speedp;
611
612     if (speed == 0)
613         return 0;
614     for (speedp = speeds; speedp->speed_int; speedp++)
615         if (speed == speedp->speed_val)
616             return speedp->speed_int;
617     return 0;
618 }
619 #endif
620
621 /*
622  * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
623  * at the requested speed, etc.  If `local' is true, set CLOCAL
624  * regardless of whether the modem option was specified.
625  */
626 set_up_tty(fd, local)
627     int fd, local;
628 {
629 #ifndef SGTTY
630     int speed;
631     struct termios tios;
632
633     if (tcgetattr(fd, &tios) < 0) {
634         syslog(LOG_ERR, "tcgetattr: %m");
635         die(1);
636     }
637
638     if (!restore_term)
639         inittermios = tios;
640
641 #ifdef CRTSCTS
642     tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL | CRTSCTS);
643     if (crtscts)
644         tios.c_cflag |= CRTSCTS;
645 #else
646     tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
647 #endif  /* CRTSCTS */
648
649     tios.c_cflag |= CS8 | CREAD | HUPCL;
650     if (local || !modem)
651         tios.c_cflag |= CLOCAL;
652     tios.c_iflag = IGNBRK | IGNPAR;
653     tios.c_oflag = 0;
654     tios.c_lflag = 0;
655     tios.c_cc[VMIN] = 1;
656     tios.c_cc[VTIME] = 0;
657     speed = translate_speed(inspeed);
658     if (speed) {
659         cfsetospeed(&tios, speed);
660         cfsetispeed(&tios, speed);
661     } else {
662         speed = cfgetospeed(&tios);
663     }
664
665     if (tcsetattr(fd, TCSAFLUSH, &tios) < 0) {
666         syslog(LOG_ERR, "tcsetattr: %m");
667         die(1);
668     }
669
670 #else   /* SGTTY */
671     int speed;
672     struct sgttyb sgttyb;
673
674     /*
675      * Put the tty in raw mode.
676      */
677     if (ioctl(fd, TIOCGETP, &sgttyb) < 0) {
678         syslog(LOG_ERR, "ioctl(TIOCGETP): %m");
679         die(1);
680     }
681
682     if (!restore_term)
683         initsgttyb = sgttyb;
684
685     sgttyb.sg_flags = RAW | ANYP;
686     speed = translate_speed(inspeed);
687     if (speed)
688         sgttyb.sg_ispeed = speed;
689     else
690         speed = sgttyb.sg_ispeed;
691
692     if (ioctl(fd, TIOCSETP, &sgttyb) < 0) {
693         syslog(LOG_ERR, "ioctl(TIOCSETP): %m");
694         die(1);
695     }
696 #endif
697
698     baud_rate = baud_rate_of(speed);
699     restore_term = TRUE;
700 }
701
702 /*
703  * setdtr - control the DTR line on the serial port.
704  * This is called from die(), so it shouldn't call die().
705  */
706 setdtr(fd, on)
707 int fd, on;
708 {
709     int modembits = TIOCM_DTR;
710
711     ioctl(fd, (on? TIOCMBIS: TIOCMBIC), &modembits);
712 }
713
714
715 /*
716  * quit - Clean up state and exit.
717  */
718 void 
719 quit()
720 {
721     die(0);
722 }
723
724 /*
725  * die - like quit, except we can specify an exit status.
726  */
727 void
728 die(status)
729     int status;
730 {
731     cleanup(0, NULL);
732     syslog(LOG_INFO, "Exit.");
733     exit(status);
734 }
735
736 /*
737  * cleanup - restore anything which needs to be restored before we exit
738  */
739 /* ARGSUSED */
740 void
741 cleanup(status, arg)
742     int status;
743     caddr_t arg;
744 {
745     if (fd >= 0) {
746         /* drop dtr to hang up */
747         if (modem)
748             setdtr(fd, FALSE);
749
750         if (fcntl(fd, F_SETFL, initfdflags) < 0)
751             syslog(LOG_WARNING, "fcntl(F_SETFL, fdflags): %m");
752
753         disestablish_ppp();
754
755         if (restore_term) {
756 #ifndef SGTTY
757             if (tcsetattr(fd, TCSAFLUSH, &inittermios) < 0)
758                 syslog(LOG_WARNING, "tcsetattr: %m");
759 #else
760             if (ioctl(fd, TIOCSETP, &initsgttyb) < 0)
761                 syslog(LOG_WARNING, "ioctl(TIOCSETP): %m");
762 #endif
763         }
764
765         close(fd);
766         fd = 0;
767     }
768
769     if (pidfilename[0] != 0 && unlink(pidfilename) < 0) 
770         syslog(LOG_WARNING, "unable to unlink pid file: %m");
771     pidfilename[0] = 0;
772
773     if (lockflag && !default_device)
774         unlock();
775 }
776
777
778 static struct callout *callout = NULL;          /* Callout list */
779 static struct timeval schedtime;                /* Time last timeout was set */
780
781 /*
782  * timeout - Schedule a timeout.
783  *
784  * Note that this timeout takes the number of seconds, NOT hz (as in
785  * the kernel).
786  */
787 void
788 timeout(func, arg, time)
789     void (*func)();
790     caddr_t arg;
791     int time;
792 {
793     struct itimerval itv;
794     struct callout *newp, **oldpp;
795   
796     MAINDEBUG((LOG_DEBUG, "Timeout %x:%x in %d seconds.",
797                (int) func, (int) arg, time));
798   
799     /*
800      * Allocate timeout.
801      */
802     if ((newp = (struct callout *) malloc(sizeof(struct callout))) == NULL) {
803         syslog(LOG_ERR, "Out of memory in timeout()!");
804         die(1);
805     }
806     newp->c_arg = arg;
807     newp->c_func = func;
808   
809     /*
810      * Find correct place to link it in and decrement its time by the
811      * amount of time used by preceding timeouts.
812      */
813     for (oldpp = &callout;
814          *oldpp && (*oldpp)->c_time <= time;
815          oldpp = &(*oldpp)->c_next)
816         time -= (*oldpp)->c_time;
817     newp->c_time = time;
818     newp->c_next = *oldpp;
819     if (*oldpp)
820         (*oldpp)->c_time -= time;
821     *oldpp = newp;
822   
823     /*
824      * If this is now the first callout then we have to set a new
825      * itimer.
826      */
827     if (callout == newp) {
828         itv.it_interval.tv_sec = itv.it_interval.tv_usec =
829             itv.it_value.tv_usec = 0;
830         itv.it_value.tv_sec = callout->c_time;
831         MAINDEBUG((LOG_DEBUG, "Setting itimer for %d seconds in timeout.",
832                    itv.it_value.tv_sec));
833         if (setitimer(ITIMER_REAL, &itv, NULL)) {
834             syslog(LOG_ERR, "setitimer(ITIMER_REAL): %m");
835             die(1);
836         }
837         if (gettimeofday(&schedtime, NULL)) {
838             syslog(LOG_ERR, "gettimeofday: %m");
839             die(1);
840         }
841     }
842 }
843
844
845 /*
846  * untimeout - Unschedule a timeout.
847  */
848 void
849 untimeout(func, arg)
850     void (*func)();
851     caddr_t arg;
852 {
853     struct itimerval itv;
854     struct callout **copp, *freep;
855     int reschedule = 0;
856   
857     MAINDEBUG((LOG_DEBUG, "Untimeout %x:%x.", (int) func, (int) arg));
858   
859     /*
860      * If the first callout is unscheduled then we have to set a new
861      * itimer.
862      */
863     if (callout &&
864         callout->c_func == func &&
865         callout->c_arg == arg)
866         reschedule = 1;
867   
868     /*
869      * Find first matching timeout.  Add its time to the next timeouts
870      * time.
871      */
872     for (copp = &callout; *copp; copp = &(*copp)->c_next)
873         if ((*copp)->c_func == func &&
874             (*copp)->c_arg == arg) {
875             freep = *copp;
876             *copp = freep->c_next;
877             if (*copp)
878                 (*copp)->c_time += freep->c_time;
879             (void) free((char *) freep);
880             break;
881         }
882   
883     if (reschedule) {
884         itv.it_interval.tv_sec = itv.it_interval.tv_usec =
885             itv.it_value.tv_usec = 0;
886         itv.it_value.tv_sec = callout ? callout->c_time : 0;
887         MAINDEBUG((LOG_DEBUG, "Setting itimer for %d seconds in untimeout.",
888                    itv.it_value.tv_sec));
889         if (setitimer(ITIMER_REAL, &itv, NULL)) {
890             syslog(LOG_ERR, "setitimer(ITIMER_REAL): %m");
891             die(1);
892         }
893         if (gettimeofday(&schedtime, NULL)) {
894             syslog(LOG_ERR, "gettimeofday: %m");
895             die(1);
896         }
897     }
898 }
899
900
901 /*
902  * adjtimeout - Decrement the first timeout by the amount of time since
903  * it was scheduled.
904  */
905 void
906 adjtimeout()
907 {
908     struct timeval tv;
909     int timediff;
910   
911     if (callout == NULL)
912         return;
913     /*
914      * Make sure that the clock hasn't been warped dramatically.
915      * Account for recently expired, but blocked timer by adding
916      * small fudge factor.
917      */
918     if (gettimeofday(&tv, NULL)) {
919         syslog(LOG_ERR, "gettimeofday: %m");
920         die(1);
921     }
922     timediff = tv.tv_sec - schedtime.tv_sec;
923     if (timediff < 0 ||
924         timediff > callout->c_time + 1)
925         return;
926   
927     callout->c_time -= timediff;        /* OK, Adjust time */
928 }
929
930
931 /*
932  * hup - Catch SIGHUP signal.
933  *
934  * Indicates that the physical layer has been disconnected.
935  */
936 /*ARGSUSED*/
937 static void
938 hup(sig, code, scp, addr)
939     int sig, code;
940     struct sigcontext *scp;
941     char *addr;
942 {
943     syslog(LOG_INFO, "Hangup (SIGHUP)");
944
945     hungup = 1;                 /* they hung up on us! */
946     persist = 0;                /* don't try to restart */
947     adjtimeout();               /* Adjust timeouts */
948     lcp_lowerdown(0);           /* Reset connection */
949     quit();                     /* and die */
950 }
951
952
953 /*
954  * term - Catch SIGTERM signal.
955  *
956  * Indicates that we should initiate a graceful disconnect and exit.
957  */
958 /*ARGSUSED*/
959 static void
960 term(sig, code, scp, addr)
961     int sig, code;
962     struct sigcontext *scp;
963     char *addr;
964 {
965     syslog(LOG_INFO, "Terminating link.");
966     persist = 0;                /* don't try to restart */
967     adjtimeout();               /* Adjust timeouts */
968     lcp_close(0);               /* Close connection */
969 }
970
971
972 /*
973  * intr - Catch SIGINT signal (DEL/^C).
974  *
975  * Indicates that we should initiate a graceful disconnect and exit.
976  */
977 /*ARGSUSED*/
978 static void
979 intr(sig, code, scp, addr)
980     int sig, code;
981     struct sigcontext *scp;
982     char *addr;
983 {
984     syslog(LOG_INFO, "Interrupt received: terminating link");
985     persist = 0;                /* don't try to restart */
986     adjtimeout();               /* Adjust timeouts */
987     lcp_close(0);               /* Close connection */
988 }
989
990
991 /*
992  * alrm - Catch SIGALRM signal.
993  *
994  * Indicates a timeout.
995  */
996 /*ARGSUSED*/
997 static void
998 alrm(sig, code, scp, addr)
999     int sig, code;
1000     struct sigcontext *scp;
1001     char *addr;
1002 {
1003     struct itimerval itv;
1004     struct callout *freep, *list, *last;
1005
1006     MAINDEBUG((LOG_DEBUG, "Alarm"));
1007
1008     if (callout == NULL)
1009         return;
1010     /*
1011      * Get the first scheduled timeout and any that were scheduled
1012      * for the same time as a list, and remove them all from callout
1013      * list.
1014      */
1015     list = last = callout;
1016     while (last->c_next != NULL && last->c_next->c_time == 0)
1017         last = last->c_next;
1018     callout = last->c_next;
1019     last->c_next = NULL;
1020
1021     /*
1022      * Set a new itimer if there are more timeouts scheduled.
1023      */
1024     if (callout) {
1025         itv.it_interval.tv_sec = itv.it_interval.tv_usec = 0;
1026         itv.it_value.tv_usec = 0;
1027         itv.it_value.tv_sec = callout->c_time;
1028         MAINDEBUG((LOG_DEBUG, "Setting itimer for %d seconds in alrm.",
1029                    itv.it_value.tv_sec));
1030         if (setitimer(ITIMER_REAL, &itv, NULL)) {
1031             syslog(LOG_ERR, "setitimer(ITIMER_REAL): %m");
1032             die(1);
1033         }
1034         if (gettimeofday(&schedtime, NULL)) {
1035             syslog(LOG_ERR, "gettimeofday: %m");
1036             die(1);
1037         }
1038     }
1039
1040     /*
1041      * Now call all the timeout routines scheduled for this time.
1042      */
1043     while (list) {
1044         (*list->c_func)(list->c_arg);
1045         freep = list;
1046         list = list->c_next;
1047         (void) free((char *) freep);
1048     }
1049   
1050 }
1051
1052
1053 /*
1054  * io - Catch SIGIO signal.
1055  *
1056  * Indicates that incoming data is available.
1057  */
1058 /*ARGSUSED*/
1059 static void
1060 io(sig, code, scp, addr)
1061     int sig, code;
1062     struct sigcontext *scp;
1063     char *addr;
1064 {
1065     int len, i;
1066     u_char *p;
1067     u_short protocol;
1068     fd_set fdset;
1069     struct timeval notime;
1070     int ready;
1071
1072     MAINDEBUG((LOG_DEBUG, "IO signal received"));
1073     adjtimeout();               /* Adjust timeouts */
1074
1075     /* we do this to see if the SIGIO handler is being invoked for input */
1076     /* ready, or for the socket buffer hitting the low-water mark. */
1077
1078     notime.tv_sec = 0;
1079     notime.tv_usec = 0;
1080     FD_ZERO(&fdset);
1081     FD_SET(fd, &fdset);
1082   
1083     if ((ready = select(32, &fdset, (fd_set *) NULL, (fd_set *) NULL,
1084                       &notime)) == -1) {
1085         syslog(LOG_ERR, "Error in io() select: %m");
1086         die(1);
1087     }
1088     
1089     if (ready == 0) {
1090         MAINDEBUG((LOG_DEBUG, "IO non-input ready SIGIO occured."));
1091         return;
1092     }
1093
1094     /* Yup, this is for real */
1095     for (;;) {                  /* Read all available packets */
1096         p = inpacket_buf;       /* point to beginning of packet buffer */
1097
1098         len = read_packet(inpacket_buf);
1099         if (len < 0)
1100             return;
1101
1102         if (len == 0) {
1103             syslog(LOG_WARNING, "End of file on fd!");
1104             die(1);
1105         }
1106
1107         if (debug /*&& (debugflags & DBG_INPACKET)*/)
1108             log_packet(p, len, "rcvd ");
1109
1110         if (len < DLLHEADERLEN) {
1111             MAINDEBUG((LOG_INFO, "io(): Received short packet."));
1112             return;
1113         }
1114
1115         p += 2;                         /* Skip address and control */
1116         GETSHORT(protocol, p);
1117         len -= DLLHEADERLEN;
1118
1119         /*
1120          * Toss all non-LCP packets unless LCP is OPEN.
1121          */
1122         if (protocol != LCP && lcp_fsm[0].state != OPENED) {
1123             MAINDEBUG((LOG_INFO,
1124                        "io(): Received non-LCP packet when LCP not open."));
1125             return;
1126         }
1127
1128         /*
1129          * Upcall the proper protocol input routine.
1130          */
1131         for (i = 0; i < sizeof (prottbl) / sizeof (struct protent); i++)
1132             if (prottbl[i].protocol == protocol) {
1133                 (*prottbl[i].input)(0, p, len);
1134                 break;
1135             }
1136
1137         if (i == sizeof (prottbl) / sizeof (struct protent)) {
1138             syslog(LOG_WARNING, "input: Unknown protocol (%x) received!",
1139                    protocol);
1140             lcp_sprotrej(0, p - DLLHEADERLEN, len + DLLHEADERLEN);
1141         }
1142     }
1143 }
1144
1145 /*
1146  * demuxprotrej - Demultiplex a Protocol-Reject.
1147  */
1148 void
1149 demuxprotrej(unit, protocol)
1150     int unit;
1151     u_short protocol;
1152 {
1153     int i;
1154
1155     /*
1156      * Upcall the proper Protocol-Reject routine.
1157      */
1158     for (i = 0; i < sizeof (prottbl) / sizeof (struct protent); i++)
1159         if (prottbl[i].protocol == protocol) {
1160             (*prottbl[i].protrej)(unit);
1161             return;
1162         }
1163
1164     syslog(LOG_WARNING,
1165            "demuxprotrej: Unrecognized Protocol-Reject for protocol %d!",
1166            protocol);
1167 }
1168
1169
1170 /*
1171  * incdebug - Catch SIGUSR1 signal.
1172  *
1173  * Increment debug flag.
1174  */
1175 /*ARGSUSED*/
1176 static void
1177 incdebug(sig)
1178     int sig;
1179 {
1180     syslog(LOG_INFO, "Debug turned ON, Level %d", debug);
1181     setlogmask(LOG_UPTO(LOG_DEBUG));
1182     debug++;
1183 }
1184
1185
1186 /*
1187  * nodebug - Catch SIGUSR2 signal.
1188  *
1189  * Turn off debugging.
1190  */
1191 /*ARGSUSED*/
1192 static void
1193 nodebug(sig)
1194     int sig;
1195 {
1196     setlogmask(LOG_UPTO(LOG_WARNING));
1197     debug = 0;
1198 }
1199
1200
1201 /*
1202  * device_script - run a program to connect or disconnect the
1203  * serial device.
1204  */
1205 int
1206 device_script(program, in, out)
1207     char *program;
1208     int in, out;
1209 {
1210     int pid;
1211     int status;
1212     sigset_t mask;
1213
1214     sigemptyset(&mask);
1215     sigaddset(&mask, SIGINT);
1216     sigaddset(&mask, SIGHUP);
1217     sigprocmask(SIG_BLOCK, &mask, &mask);
1218
1219     pid = fork();
1220
1221     if (pid < 0) {
1222         syslog(LOG_ERR, "fork: %m");
1223         die(1);
1224     }
1225
1226     if (pid == 0) {
1227         setreuid(getuid(), getuid());
1228         setregid(getgid(), getgid());
1229         sigprocmask(SIG_SETMASK, &mask, NULL);
1230         dup2(in, 0);
1231         dup2(out, 1);
1232         execl("/bin/sh", "sh", "-c", program, (char *)0);
1233         syslog(LOG_ERR, "could not exec /bin/sh: %m");
1234         _exit(99);
1235         /* NOTREACHED */
1236     }
1237
1238     while (waitpid(pid, &status, 0) < 0) {
1239         if (errno == EINTR)
1240             continue;
1241         syslog(LOG_ERR, "waiting for (dis)connection process: %m");
1242         die(1);
1243     }
1244     sigprocmask(SIG_SETMASK, &mask, NULL);
1245
1246     return (status == 0 ? 0 : -1);
1247 }
1248
1249
1250 /*
1251  * run-program - execute a program with given arguments,
1252  * but don't wait for it.
1253  * If the program can't be executed, logs an error unless
1254  * must_exist is 0 and the program file doesn't exist.
1255  */
1256 int
1257 run_program(prog, args, must_exist)
1258     char *prog;
1259     char **args;
1260     int must_exist;
1261 {
1262     int pid;
1263
1264     pid = fork();
1265     if (pid == -1) {
1266         syslog(LOG_ERR, "can't fork to run %s: %m", prog);
1267         return -1;
1268     }
1269     if (pid == 0) {
1270         execv(prog, args);
1271         if (must_exist || errno != ENOENT)
1272             syslog(LOG_WARNING, "can't execute %s: %m", prog);
1273         _exit(-1);
1274     }
1275     MAINDEBUG((LOG_DEBUG, "Script %s started; pid = %d", prog, pid));
1276     ++n_children;
1277     return 0;
1278 }
1279
1280
1281 /*
1282  * reap_kids - get status from any dead child processes,
1283  * and log a message for abnormal terminations.
1284  */
1285 void
1286 reap_kids()
1287 {
1288     int pid, status;
1289
1290     if (n_children == 0)
1291         return;
1292     if ((pid = waitpid(-1, &status, WNOHANG)) == -1) {
1293         if (errno != ECHILD)
1294             syslog(LOG_ERR, "waitpid: %m");
1295         return;
1296     }
1297     if (pid > 0) {
1298         --n_children;
1299         if (WIFSIGNALED(status)) {
1300             syslog(LOG_WARNING, "child process %d terminated with signal %d",
1301                    pid, WTERMSIG(status));
1302         }
1303     }
1304 }
1305
1306
1307 /*
1308  * log_packet - format a packet and log it.
1309  */
1310
1311 char line[256];                 /* line to be logged accumulated here */
1312 char *linep;
1313
1314 void
1315 log_packet(p, len, prefix)
1316     u_char *p;
1317     int len;
1318     char *prefix;
1319 {
1320     strcpy(line, prefix);
1321     linep = line + strlen(line);
1322     format_packet(p, len, pr_log, NULL);
1323     if (linep != line)
1324         syslog(LOG_DEBUG, "%s", line);
1325 }
1326
1327 /*
1328  * format_packet - make a readable representation of a packet,
1329  * calling `printer(arg, format, ...)' to output it.
1330  */
1331 void
1332 format_packet(p, len, printer, arg)
1333     u_char *p;
1334     int len;
1335     void (*printer) __ARGS((void *, char *, ...));
1336     void *arg;
1337 {
1338     int i, n;
1339     u_short proto;
1340     u_char x;
1341
1342     if (len >= DLLHEADERLEN && p[0] == ALLSTATIONS && p[1] == UI) {
1343         p += 2;
1344         GETSHORT(proto, p);
1345         len -= DLLHEADERLEN;
1346         for (i = 0; i < N_PROTO; ++i)
1347             if (proto == prottbl[i].protocol)
1348                 break;
1349         if (i < N_PROTO) {
1350             printer(arg, "[%s", prottbl[i].name);
1351             n = (*prottbl[i].printpkt)(p, len, printer, arg);
1352             printer(arg, "]");
1353             p += n;
1354             len -= n;
1355         } else {
1356             printer(arg, "[proto=0x%x]", proto);
1357         }
1358     }
1359
1360     for (; len > 0; --len) {
1361         GETCHAR(x, p);
1362         printer(arg, " %.2x", x);
1363     }
1364 }
1365
1366 #ifdef __STDC__
1367 #include <stdarg.h>
1368
1369 void
1370 pr_log(void *arg, char *fmt, ...)
1371 {
1372     int n;
1373     va_list pvar;
1374     char buf[256];
1375
1376     va_start(pvar, fmt);
1377     vsprintf(buf, fmt, pvar);
1378     va_end(pvar);
1379
1380     n = strlen(buf);
1381     if (linep + n + 1 > line + sizeof(line)) {
1382         syslog(LOG_DEBUG, "%s", line);
1383         linep = line;
1384     }
1385     strcpy(linep, buf);
1386     linep += n;
1387 }
1388
1389 #else /* __STDC__ */
1390 #include <varargs.h>
1391
1392 void
1393 pr_log(arg, fmt, va_alist)
1394 void *arg;
1395 char *fmt;
1396 va_dcl
1397 {
1398     int n;
1399     va_list pvar;
1400     char buf[256];
1401
1402     va_start(pvar);
1403     vsprintf(buf, fmt, pvar);
1404     va_end(pvar);
1405
1406     n = strlen(buf);
1407     if (linep + n + 1 > line + sizeof(line)) {
1408         syslog(LOG_DEBUG, "%s", line);
1409         linep = line;
1410     }
1411     strcpy(linep, buf);
1412     linep += n;
1413 }
1414 #endif
1415
1416 /*
1417  * print_string - print a readable representation of a string using
1418  * printer.
1419  */
1420 void
1421 print_string(p, len, printer, arg)
1422     char *p;
1423     int len;
1424     void (*printer) __ARGS((void *, char *, ...));
1425     void *arg;
1426 {
1427     int c;
1428
1429     printer(arg, "\"");
1430     for (; len > 0; --len) {
1431         c = *p++;
1432         if (' ' <= c && c <= '~')
1433             printer(arg, "%c", c);
1434         else
1435             printer(arg, "\\%.3o", c);
1436     }
1437     printer(arg, "\"");
1438 }
1439
1440 /*
1441  * novm - log an error message saying we ran out of memory, and die.
1442  */
1443 void
1444 novm(msg)
1445     char *msg;
1446 {
1447     syslog(LOG_ERR, "Virtual memory exhausted allocating %s\n", msg);
1448     die(1);
1449 }