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