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