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