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