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