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