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