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