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.16 1994/08/25 06:55:21 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/param.h>
  34 #include <sys/types.h>
  35 #include <sys/wait.h>
  36 #include <sys/time.h>
  37 #include <sys/resource.h>
  38 #include <sys/stat.h>
  39 #include <sys/socket.h>
  40 #include <net/if.h>
  41
  42 #include "ppp.h"
  43 #include "pppd.h"
  44 #include "magic.h"
  45 #include "fsm.h"
  46 #include "lcp.h"
  47 #include "ipcp.h"
  48 #include "upap.h"
  49 #include "chap.h"
  50 #include "ccp.h"
  51 #include "pathnames.h"
  52 #include "patchlevel.h"
  53
  54 /*
  55  * If REQ_SYSOPTIONS is defined to 1, pppd will not run unless
  56  * /etc/ppp/options exists.
  57  */
  58 #ifndef REQ_SYSOPTIONS
  59 #define REQ_SYSOPTIONS  1
  60 #endif
  61
  62 static char *pidpath = _PATH_PIDFILE;
  63
  64 /* interface vars */
  65 char ifname[IFNAMSIZ];          /* Interface name */
  66 int ifunit;                     /* Interface unit number */
  67
  68 char *progname;                 /* Name of this program */
  69 char hostname[MAXNAMELEN];      /* Our hostname */
  70 static char pidfilename[MAXPATHLEN];
  71
  72 static pid_t    pid;            /* Our pid */
  73 static pid_t    pgrpid;         /* Process Group ID */
  74 static uid_t uid;               /* Our real user-id */
  75
  76 int fd = -1;                    /* Device file descriptor */
  77 int s;                          /* Socket file descriptor */
  78
  79 int phase;                      /* where the link is at */
  80 int kill_link;
  81
  82 static int initfdflags = -1;    /* Initial file descriptor flags */
  83
  84 u_char outpacket_buf[MTU+DLLHEADERLEN]; /* buffer for outgoing packet */
  85 static u_char inpacket_buf[MTU+DLLHEADERLEN]; /* buffer for incoming packet */
  86
  87 int hungup;                     /* terminal has been hung up */
  88 static int n_children;          /* # child processes still running */
  89
  90 int baud_rate;
  91
  92 /* prototypes */
  93 static void hup __ARGS((int));
  94 static void term __ARGS((int));
  95 static void chld __ARGS((int));
  96 static void incdebug __ARGS((int));
  97 static void nodebug __ARGS((int));
  98
  99 static void get_input __ARGS((void));
 100 void establish_ppp __ARGS((void));
 101 void calltimeout __ARGS((void));
 102 struct timeval *timeleft __ARGS((struct timeval *));
 103 void reap_kids __ARGS((void));
 104 void cleanup __ARGS((int, caddr_t));
 105 void close_fd __ARGS((void));
 106 void die __ARGS((int));
 107 void novm __ARGS((char *));
 108
 109 void log_packet __ARGS((u_char *, int, char *));
 110 void format_packet __ARGS((u_char *, int,
 111                            void (*) (void *, char *, ...), void *));
 112 void pr_log __ARGS((void *, char *, ...));
 113
 114 extern  char    *ttyname __ARGS((int));
 115 extern  char    *getlogin __ARGS((void));
 116
 117 /*
 118  * PPP Data Link Layer "protocol" table.
 119  * One entry per supported protocol.
 120  */
 121 static struct protent {
 122     u_short protocol;
 123     void (*init)();
 124     void (*input)();
 125     void (*protrej)();
 126     int  (*printpkt)();
 127     void (*datainput)();
 128     char *name;
 129 } prottbl[] = {
 130     { LCP, lcp_init, lcp_input, lcp_protrej, lcp_printpkt, NULL, "LCP" },
 131     { IPCP, ipcp_init, ipcp_input, ipcp_protrej, ipcp_printpkt, NULL, "IPCP" },
 132     { UPAP, upap_init, upap_input, upap_protrej, upap_printpkt, NULL, "PAP" },
 133     { CHAP, ChapInit, ChapInput, ChapProtocolReject, ChapPrintPkt, NULL, "CHAP" },
 134     { CCP, ccp_init, ccp_input, ccp_protrej, ccp_printpkt, ccp_datainput, "CCP" },
 135 };
 136
 137 #define N_PROTO         (sizeof(prottbl) / sizeof(prottbl[0]))
 138
 139 main(argc, argv)
 140     int argc;
 141     char *argv[];
 142 {
 143     int mask, i, nonblock;
 144     struct sigaction sa;
 145     struct cmd *cmdp;
 146     FILE *pidfile;
 147     char *p;
 148     struct passwd *pw;
 149     struct timeval timo;
 150
 151     p = ttyname(0);
 152     if (p)
 153         strcpy(devnam, p);
 154
 155     if (gethostname(hostname, MAXNAMELEN) < 0 ) {
 156         perror("couldn't get hostname");
 157         die(1);
 158     }
 159     hostname[MAXNAMELEN-1] = 0;
 160
 161     uid = getuid();
 162
 163     if (!ppp_available()) {
 164         fprintf(stderr, "Sorry - PPP is not available on this system\n");
 165         exit(1);
 166     }
 167
 168     /*
 169      * Initialize to the standard option set, then parse, in order,
 170      * the system options file, the user's options file, and the command
 171      * line arguments.
 172      */
 173     for (i = 0; i < N_PROTO; i++)
 174         (*prottbl[i].init)(0);
 175
 176     progname = *argv;
 177
 178     if (!options_from_file(_PATH_SYSOPTIONS, REQ_SYSOPTIONS, 0) ||
 179         !options_from_user() ||
 180         !parse_args(argc-1, argv+1) ||
 181         !options_for_tty())
 182         die(1);
 183     check_auth_options();
 184     setipdefault();
 185
 186     /*
 187      * Initialize system-dependent stuff and magic number package.
 188      */
 189     sys_init();
 190     magic_init();
 191
 192     /*
 193      * Detach ourselves from the terminal, if required,
 194      * and identify who is running us.
 195      */
 196     if (!default_device && !nodetach && daemon(0, 0) < 0) {
 197         perror("Couldn't detach from controlling terminal");
 198         exit(1);
 199     }
 200     pid = getpid();
 201     p = getlogin();
 202     if (p == NULL) {
 203         pw = getpwuid(uid);
 204         if (pw != NULL && pw->pw_name != NULL)
 205             p = pw->pw_name;
 206         else
 207             p = "(unknown)";
 208     }
 209     syslog(LOG_NOTICE, "pppd %s.%d started by %s, uid %d",
 210            VERSION, PATCHLEVEL, p, uid);
 211
 212     /* Get an internet socket for doing socket ioctl's on. */
 213     if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
 214         syslog(LOG_ERR, "Couldn't create IP socket: %m");
 215         die(1);
 216     }
 217
 218     /*
 219      * Compute mask of all interesting signals and install signal handlers
 220      * for each.  Only one signal handler may be active at a time.  Therefore,
 221      * all other signals should be masked when any handler is executing.
 222      */
 223     sigemptyset(&mask);
 224     sigaddset(&mask, SIGHUP);
 225     sigaddset(&mask, SIGINT);
 226     sigaddset(&mask, SIGTERM);
 227     sigaddset(&mask, SIGCHLD);
 228
 229 #define SIGNAL(s, handler)      { \
 230         sa.sa_handler = handler; \
 231         if (sigaction(s, &sa, NULL) < 0) { \
 232             syslog(LOG_ERR, "Couldn't establish signal handler (%d): %m", s); \
 233             die(1); \
 234         } \
 235     }
 236
 237     sa.sa_mask = mask;
 238     sa.sa_flags = 0;
 239     SIGNAL(SIGHUP, hup);                /* Hangup */
 240     SIGNAL(SIGINT, term);               /* Interrupt */
 241     SIGNAL(SIGTERM, term);              /* Terminate */
 242     SIGNAL(SIGCHLD, chld);
 243
 244     signal(SIGUSR1, incdebug);          /* Increment debug flag */
 245     signal(SIGUSR2, nodebug);           /* Reset debug flag */
 246
 247     /*
 248      * Lock the device if we've been asked to.
 249      */
 250     if (lockflag && !default_device)
 251         if (lock(devnam) < 0)
 252             die(1);
 253
 254     do {
 255
 256         /*
 257          * Open the serial device and set it up to be the ppp interface.
 258          * If we're dialling out, or we don't want to use the modem lines,
 259          * we open it in non-blocking mode, but then we need to clear
 260          * the non-blocking I/O bit.
 261          */
 262         nonblock = (connector || !modem)? O_NONBLOCK: 0;
 263         if ((fd = open(devnam, nonblock | O_RDWR, 0)) < 0) {
 264             syslog(LOG_ERR, "Failed to open %s: %m", devnam);
 265             die(1);
 266         }
 267         if ((initfdflags = fcntl(fd, F_GETFL)) == -1) {
 268             syslog(LOG_ERR, "Couldn't get device fd flags: %m");
 269             die(1);
 270         }
 271         if (nonblock) {
 272             initfdflags &= ~O_NONBLOCK;
 273             fcntl(fd, F_SETFL, initfdflags);
 274         }
 275         hungup = 0;
 276         kill_link = 0;
 277
 278         /* run connection script */
 279         if (connector && connector[0]) {
 280             MAINDEBUG((LOG_INFO, "Connecting with <%s>", connector));
 281
 282             /* set line speed, flow control, etc.; set CLOCAL for now */
 283             set_up_tty(fd, 1);
 284
 285             /* drop dtr to hang up in case modem is off hook */
 286             if (!default_device && modem) {
 287                 setdtr(fd, FALSE);
 288                 sleep(1);
 289                 setdtr(fd, TRUE);
 290             }
 291
 292             if (device_script(connector, fd, fd) < 0) {
 293                 syslog(LOG_ERR, "Connect script failed");
 294                 setdtr(fd, FALSE);
 295                 die(1);
 296             }
 297
 298             syslog(LOG_INFO, "Connected...");
 299             sleep(1);           /* give it time to set up its terminal */
 300         }
 301
 302         /* set line speed, flow control, etc.; clear CLOCAL if modem option */
 303         set_up_tty(fd, 0);
 304
 305         /* set up the serial device as a ppp interface */
 306         establish_ppp();
 307
 308         syslog(LOG_INFO, "Using interface ppp%d", ifunit);
 309         (void) sprintf(ifname, "ppp%d", ifunit);
 310
 311         /* write pid to file */
 312         (void) sprintf(pidfilename, "%s/%s.pid", pidpath, ifname);
 313         if ((pidfile = fopen(pidfilename, "w")) != NULL) {
 314             fprintf(pidfile, "%d\n", pid);
 315             (void) fclose(pidfile);
 316         } else {
 317             syslog(LOG_ERR, "Failed to create pid file %s: %m", pidfilename);
 318             pidfilename[0] = 0;
 319         }
 320
 321         /*
 322          * Set device for non-blocking reads.
 323          */
 324         if (fcntl(fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
 325             syslog(LOG_ERR, "Couldn't set device to non-blocking mode: %m");
 326             die(1);
 327         }
 328
 329         /*
 330          * Block all signals, start opening the connection, and wait for
 331          * incoming events (reply, timeout, etc.).
 332          */
 333         syslog(LOG_NOTICE, "Connect: %s <--> %s", ifname, devnam);
 334         lcp_lowerup(0);
 335         lcp_open(0);            /* Start protocol */
 336         for (phase = PHASE_ESTABLISH; phase != PHASE_DEAD; ) {
 337             wait_input(timeleft(&timo));
 338             calltimeout();
 339             if (kill_link) {
 340                 lcp_close(0);
 341                 kill_link = 0;
 342             }
 343             get_input();
 344             reap_kids();        /* Don't leave dead kids lying around */
 345         }
 346
 347         /*
 348          * Run disconnector script, if requested
 349          */
 350         if (disconnector) {
 351             if (device_script(disconnector, fd, fd) < 0) {
 352                 syslog(LOG_WARNING, "disconnect script failed");
 353                 die(1);
 354             }
 355
 356             syslog(LOG_INFO, "Disconnected...");
 357         }
 358
 359         close_fd();
 360         if (unlink(pidfilename) < 0 && errno != ENOENT)
 361             syslog(LOG_WARNING, "unable to delete pid file: %m");
 362         pidfilename[0] = 0;
 363
 364     } while (persist);
 365
 366     if (lockflag && !default_device)
 367         unlock();
 368
 369     exit(0);
 370 }
 371
 372
 373 /*
 374  * get_input - called when incoming data is available.
 375  */
 376 static void
 377 get_input()
 378 {
 379     int len, i;
 380     u_char *p;
 381     u_short protocol;
 382
 383     for (;;) {                  /* Read all available packets */
 384         p = inpacket_buf;       /* point to beginning of packet buffer */
 385
 386         len = read_packet(inpacket_buf);
 387         if (len < 0)
 388             return;
 389
 390         if (len == 0) {
 391             MAINDEBUG((LOG_DEBUG, "End of file on fd!"));
 392             hungup = 1;
 393             lcp_lowerdown(0);   /* serial link is no longer available */
 394             phase = PHASE_DEAD;
 395             return;
 396         }
 397
 398         if (debug /*&& (debugflags & DBG_INPACKET)*/)
 399             log_packet(p, len, "rcvd ");
 400
 401         if (len < DLLHEADERLEN) {
 402             MAINDEBUG((LOG_INFO, "io(): Received short packet."));
 403             return;
 404         }
 405
 406         p += 2;                         /* Skip address and control */
 407         GETSHORT(protocol, p);
 408         len -= DLLHEADERLEN;
 409
 410         /*
 411          * Toss all non-LCP packets unless LCP is OPEN.
 412          */
 413         if (protocol != LCP && lcp_fsm[0].state != OPENED) {
 414             MAINDEBUG((LOG_INFO,
 415                        "io(): Received non-LCP packet when LCP not open."));
 416             return;
 417         }
 418
 419         /*
 420          * Upcall the proper protocol input routine.
 421          */
 422         for (i = 0; i < sizeof (prottbl) / sizeof (struct protent); i++)
 423             if (prottbl[i].protocol == protocol) {
 424                 (*prottbl[i].input)(0, p, len);
 425                 break;
 426             } else if (protocol == (prottbl[i].protocol & ~0x8000)
 427                        && prottbl[i].datainput != NULL) {
 428                 (*prottbl[i].datainput)(0, p, len);
 429                 break;
 430             }
 431
 432         if (i == sizeof (prottbl) / sizeof (struct protent)) {
 433             if (debug)
 434                 syslog(LOG_WARNING, "Unknown protocol (%x) received",
 435                        protocol);
 436             lcp_sprotrej(0, p - DLLHEADERLEN, len + DLLHEADERLEN);
 437         }
 438     }
 439 }
 440
 441
 442 /*
 443  * demuxprotrej - Demultiplex a Protocol-Reject.
 444  */
 445 void
 446 demuxprotrej(unit, protocol)
 447     int unit;
 448     u_short protocol;
 449 {
 450     int i;
 451
 452     /*
 453      * Upcall the proper Protocol-Reject routine.
 454      */
 455     for (i = 0; i < sizeof (prottbl) / sizeof (struct protent); i++)
 456         if (prottbl[i].protocol == protocol) {
 457             (*prottbl[i].protrej)(unit);
 458             return;
 459         }
 460
 461     syslog(LOG_WARNING,
 462            "demuxprotrej: Unrecognized Protocol-Reject for protocol 0x%x",
 463            protocol);
 464 }
 465
 466
 467 /*
 468  * quit - Clean up state and exit.
 469  */
 470 void
 471 quit()
 472 {
 473     die(0);
 474 }
 475
 476 /*
 477  * die - like quit, except we can specify an exit status.
 478  */
 479 void
 480 die(status)
 481     int status;
 482 {
 483     cleanup(0, NULL);
 484     syslog(LOG_INFO, "Exit.");
 485     exit(status);
 486 }
 487
 488 /*
 489  * cleanup - restore anything which needs to be restored before we exit
 490  */
 491 /* ARGSUSED */
 492 void
 493 cleanup(status, arg)
 494     int status;
 495     caddr_t arg;
 496 {
 497     if (fd >= 0)
 498         close_fd();
 499
 500     if (pidfilename[0] != 0 && unlink(pidfilename) < 0 && errno != ENOENT)
 501         syslog(LOG_WARNING, "unable to delete pid file: %m");
 502     pidfilename[0] = 0;
 503
 504     if (lockflag && !default_device)
 505         unlock();
 506 }
 507
 508 /*
 509  * close_fd - restore the terminal device and close it.
 510  */
 511 void
 512 close_fd()
 513 {
 514     /* drop dtr to hang up */
 515     if (modem)
 516         setdtr(fd, FALSE);
 517
 518     if (initfdflags != -1 && fcntl(fd, F_SETFL, initfdflags) < 0)
 519         syslog(LOG_WARNING, "Couldn't restore device fd flags: %m");
 520     initfdflags = -1;
 521
 522     disestablish_ppp();
 523
 524     restore_tty();
 525
 526     close(fd);
 527     fd = -1;
 528 }
 529
 530
 531 struct  callout {
 532     struct timeval      c_time;         /* time at which to call routine */
 533     caddr_t             c_arg;          /* argument to routine */
 534     void                (*c_func)();    /* routine */
 535     struct              callout *c_next;
 536 };
 537
 538 static struct callout *callout = NULL;  /* Callout list */
 539 static struct timeval timenow;          /* Current time */
 540
 541 /*
 542  * timeout - Schedule a timeout.
 543  *
 544  * Note that this timeout takes the number of seconds, NOT hz (as in
 545  * the kernel).
 546  */
 547 void
 548 timeout(func, arg, time)
 549     void (*func)();
 550     caddr_t arg;
 551     int time;
 552 {
 553     struct callout *newp, *p, **pp;
 554
 555     MAINDEBUG((LOG_DEBUG, "Timeout %x:%x in %d seconds.",
 556                (int) func, (int) arg, time));
 557
 558     /*
 559      * Allocate timeout.
 560      */
 561     if ((newp = (struct callout *) malloc(sizeof(struct callout))) == NULL) {
 562         syslog(LOG_ERR, "Out of memory in timeout()!");
 563         die(1);
 564     }
 565     newp->c_arg = arg;
 566     newp->c_func = func;
 567     gettimeofday(&timenow, NULL);
 568     newp->c_time.tv_sec = timenow.tv_sec + time;
 569     newp->c_time.tv_usec = timenow.tv_usec;
 570
 571     /*
 572      * Find correct place and link it in.
 573      */
 574     for (pp = &callout; (p = *pp); pp = &p->c_next)
 575         if (p->c_time.tv_sec < newp->c_time.tv_sec
 576             || (p->c_time.tv_sec == newp->c_time.tv_sec
 577                 && p->c_time.tv_usec <= newp->c_time.tv_sec))
 578             break;
 579     newp->c_next = p;
 580     *pp = newp;
 581 }
 582
 583
 584 /*
 585  * untimeout - Unschedule a timeout.
 586  */
 587 void
 588 untimeout(func, arg)
 589     void (*func)();
 590     caddr_t arg;
 591 {
 592     struct itimerval itv;
 593     struct callout **copp, *freep;
 594     int reschedule = 0;
 595
 596     MAINDEBUG((LOG_DEBUG, "Untimeout %x:%x.", (int) func, (int) arg));
 597
 598     /*
 599      * Find first matching timeout and remove it from the list.
 600      */
 601     for (copp = &callout; (freep = *copp); copp = &freep->c_next)
 602         if (freep->c_func == func && freep->c_arg == arg) {
 603             *copp = freep->c_next;
 604             (void) free((char *) freep);
 605             break;
 606         }
 607 }
 608
 609
 610 /*
 611  * calltimeout - Call any timeout routines which are now due.
 612  */
 613 void
 614 calltimeout()
 615 {
 616     struct callout *p;
 617
 618     while (callout != NULL) {
 619         p = callout;
 620
 621         if (gettimeofday(&timenow, NULL) < 0) {
 622             syslog(LOG_ERR, "Failed to get time of day: %m");
 623             die(1);
 624         }
 625         if (!(p->c_time.tv_sec < timenow.tv_sec
 626               || (p->c_time.tv_sec == timenow.tv_sec
 627                   && p->c_time.tv_usec <= timenow.tv_usec)))
 628             break;              /* no, it's not time yet */
 629
 630         callout = p->c_next;
 631         (*p->c_func)(p->c_arg);
 632
 633         free((char *) p);
 634     }
 635 }
 636
 637
 638 /*
 639  * timeleft - return the length of time until the next timeout is due.
 640  */
 641 struct timeval *
 642 timeleft(tvp)
 643     struct timeval *tvp;
 644 {
 645     if (callout == NULL)
 646         return NULL;
 647
 648     gettimeofday(&timenow, NULL);
 649     tvp->tv_sec = callout->c_time.tv_sec - timenow.tv_sec;
 650     tvp->tv_usec = callout->c_time.tv_usec - timenow.tv_usec;
 651     if (tvp->tv_usec < 0) {
 652         tvp->tv_usec += 1000000;
 653         tvp->tv_sec -= 1;
 654     }
 655     if (tvp->tv_sec < 0)
 656         tvp->tv_sec = tvp->tv_usec = 0;
 657
 658     return tvp;
 659 }
 660
 661
 662 /*
 663  * hup - Catch SIGHUP signal.
 664  *
 665  * Indicates that the physical layer has been disconnected.
 666  * We don't rely on this indication; if the user has sent this
 667  * signal, we just take the link down.
 668  */
 669 static void
 670 hup(sig)
 671     int sig;
 672 {
 673     syslog(LOG_INFO, "Hangup (SIGHUP)");
 674     kill_link = 1;
 675 }
 676
 677
 678 /*
 679  * term - Catch SIGTERM signal and SIGINT signal (^C/del).
 680  *
 681  * Indicates that we should initiate a graceful disconnect and exit.
 682  */
 683 /*ARGSUSED*/
 684 static void
 685 term(sig)
 686     int sig;
 687 {
 688     syslog(LOG_INFO, "Terminating on signal %d.", sig);
 689     persist = 0;                /* don't try to restart */
 690     kill_link = 1;
 691 }
 692
 693
 694 /*
 695  * chld - Catch SIGCHLD signal.
 696  * Calls reap_kids to get status for any dead kids.
 697  */
 698 static void
 699 chld(sig)
 700     int sig;
 701 {
 702     reap_kids();
 703 }
 704
 705
 706 /*
 707  * incdebug - Catch SIGUSR1 signal.
 708  *
 709  * Increment debug flag.
 710  */
 711 /*ARGSUSED*/
 712 static void
 713 incdebug(sig)
 714     int sig;
 715 {
 716     debug++;
 717     note_debug_level();
 718 }
 719
 720
 721 /*
 722  * nodebug - Catch SIGUSR2 signal.
 723  *
 724  * Turn off debugging.
 725  */
 726 /*ARGSUSED*/
 727 static void
 728 nodebug(sig)
 729     int sig;
 730 {
 731     debug = 0;
 732     note_debug_level();
 733 }
 734
 735
 736 /*
 737  * device_script - run a program to connect or disconnect the
 738  * serial device.
 739  */
 740 int
 741 device_script(program, in, out)
 742     char *program;
 743     int in, out;
 744 {
 745     int pid;
 746     int status;
 747     sigset_t mask;
 748
 749     sigemptyset(&mask);
 750     sigaddset(&mask, SIGINT);
 751     sigaddset(&mask, SIGHUP);
 752     sigprocmask(SIG_BLOCK, &mask, &mask);
 753
 754     pid = fork();
 755
 756     if (pid < 0) {
 757         syslog(LOG_ERR, "Failed to create child process: %m");
 758         die(1);
 759     }
 760
 761     if (pid == 0) {
 762         setreuid(getuid(), getuid());
 763         setregid(getgid(), getgid());
 764         sigprocmask(SIG_SETMASK, &mask, NULL);
 765         dup2(in, 0);
 766         dup2(out, 1);
 767         execl("/bin/sh", "sh", "-c", program, (char *)0);
 768         syslog(LOG_ERR, "could not exec /bin/sh: %m");
 769         _exit(99);
 770         /* NOTREACHED */
 771     }
 772
 773     while (waitpid(pid, &status, 0) < 0) {
 774         if (errno == EINTR)
 775             continue;
 776         syslog(LOG_ERR, "error waiting for (dis)connection process: %m");
 777         die(1);
 778     }
 779     sigprocmask(SIG_SETMASK, &mask, NULL);
 780
 781     return (status == 0 ? 0 : -1);
 782 }
 783
 784
 785 /*
 786  * run-program - execute a program with given arguments,
 787  * but don't wait for it.
 788  * If the program can't be executed, logs an error unless
 789  * must_exist is 0 and the program file doesn't exist.
 790  */
 791 int
 792 run_program(prog, args, must_exist)
 793     char *prog;
 794     char **args;
 795     int must_exist;
 796 {
 797     int pid;
 798
 799     pid = fork();
 800     if (pid == -1) {
 801         syslog(LOG_ERR, "Failed to create child process for %s: %m", prog);
 802         return -1;
 803     }
 804     if (pid == 0) {
 805         int new_fd;
 806
 807         /* Leave the current location */
 808         (void) setsid();    /* No controlling tty. */
 809         (void) umask (0);   /* no umask. Must change in script. */
 810         (void) chdir ("/"); /* no current directory. */
 811
 812         /* Ensure that nothing of our device environment is inherited. */
 813         close (0);
 814         close (1);
 815         close (2);
 816         close (s);   /* Socket interface to the ppp device */
 817         close (fd);  /* tty interface to the ppp device */
 818
 819         /* Don't pass handles to the PPP device, even by accident. */
 820         new_fd = open (_PATH_DEVNULL, O_RDWR);
 821         if (new_fd >= 0) {
 822             if (new_fd != 0) {
 823                 dup2  (new_fd, 0); /* stdin <- /dev/null */
 824                 close (new_fd);
 825             }
 826             dup2 (0, 1); /* stdout -> /dev/null */
 827             dup2 (0, 2); /* stderr -> /dev/null */
 828         }
 829
 830         /* Force the priority back to zero if pppd is running higher. */
 831         if (setpriority (PRIO_PROCESS, 0, 0) < 0)
 832             syslog (LOG_WARNING, "can't reset priority to 0: %m");
 833
 834         /* SysV recommends a second fork at this point. */
 835
 836         /* run the program */
 837         execv(prog, args);
 838         if (must_exist || errno != ENOENT)
 839             syslog(LOG_WARNING, "Can't execute %s: %m", prog);
 840         _exit(-1);
 841     }
 842     MAINDEBUG((LOG_DEBUG, "Script %s started; pid = %d", prog, pid));
 843     ++n_children;
 844     return 0;
 845 }
 846
 847
 848 /*
 849  * reap_kids - get status from any dead child processes,
 850  * and log a message for abnormal terminations.
 851  */
 852 void
 853 reap_kids()
 854 {
 855     int pid, status;
 856
 857     if (n_children == 0)
 858         return;
 859     if ((pid = waitpid(-1, &status, WNOHANG)) == -1) {
 860         if (errno != ECHILD)
 861             syslog(LOG_ERR, "Error waiting for child process: %m");
 862         return;
 863     }
 864     if (pid > 0) {
 865         --n_children;
 866         if (WIFSIGNALED(status)) {
 867             syslog(LOG_WARNING, "Child process %d terminated with signal %d",
 868                    pid, WTERMSIG(status));
 869         }
 870     }
 871 }
 872
 873
 874 /*
 875  * log_packet - format a packet and log it.
 876  */
 877
 878 char line[256];                 /* line to be logged accumulated here */
 879 char *linep;
 880
 881 void
 882 log_packet(p, len, prefix)
 883     u_char *p;
 884     int len;
 885     char *prefix;
 886 {
 887     strcpy(line, prefix);
 888     linep = line + strlen(line);
 889     format_packet(p, len, pr_log, NULL);
 890     if (linep != line)
 891         syslog(LOG_DEBUG, "%s", line);
 892 }
 893
 894 /*
 895  * format_packet - make a readable representation of a packet,
 896  * calling `printer(arg, format, ...)' to output it.
 897  */
 898 void
 899 format_packet(p, len, printer, arg)
 900     u_char *p;
 901     int len;
 902     void (*printer) __ARGS((void *, char *, ...));
 903     void *arg;
 904 {
 905     int i, n;
 906     u_short proto;
 907     u_char x;
 908
 909     if (len >= DLLHEADERLEN && p[0] == ALLSTATIONS && p[1] == UI) {
 910         p += 2;
 911         GETSHORT(proto, p);
 912         len -= DLLHEADERLEN;
 913         for (i = 0; i < N_PROTO; ++i)
 914             if (proto == prottbl[i].protocol)
 915                 break;
 916         if (i < N_PROTO) {
 917             printer(arg, "[%s", prottbl[i].name);
 918             n = (*prottbl[i].printpkt)(p, len, printer, arg);
 919             printer(arg, "]");
 920             p += n;
 921             len -= n;
 922         } else {
 923             printer(arg, "[proto=0x%x]", proto);
 924         }
 925     }
 926
 927     for (; len > 0; --len) {
 928         GETCHAR(x, p);
 929         printer(arg, " %.2x", x);
 930     }
 931 }
 932
 933 #ifdef __STDC__
 934 #include <stdarg.h>
 935
 936 void
 937 pr_log(void *arg, char *fmt, ...)
 938 {
 939     int n;
 940     va_list pvar;
 941     char buf[256];
 942
 943     va_start(pvar, fmt);
 944     vsprintf(buf, fmt, pvar);
 945     va_end(pvar);
 946
 947     n = strlen(buf);
 948     if (linep + n + 1 > line + sizeof(line)) {
 949         syslog(LOG_DEBUG, "%s", line);
 950         linep = line;
 951     }
 952     strcpy(linep, buf);
 953     linep += n;
 954 }
 955
 956 #else /* __STDC__ */
 957 #include <varargs.h>
 958
 959 void
 960 pr_log(arg, fmt, va_alist)
 961 void *arg;
 962 char *fmt;
 963 va_dcl
 964 {
 965     int n;
 966     va_list pvar;
 967     char buf[256];
 968
 969     va_start(pvar);
 970     vsprintf(buf, fmt, pvar);
 971     va_end(pvar);
 972
 973     n = strlen(buf);
 974     if (linep + n + 1 > line + sizeof(line)) {
 975         syslog(LOG_DEBUG, "%s", line);
 976         linep = line;
 977     }
 978     strcpy(linep, buf);
 979     linep += n;
 980 }
 981 #endif
 982
 983 /*
 984  * print_string - print a readable representation of a string using
 985  * printer.
 986  */
 987 void
 988 print_string(p, len, printer, arg)
 989     char *p;
 990     int len;
 991     void (*printer) __ARGS((void *, char *, ...));
 992     void *arg;
 993 {
 994     int c;
 995
 996     printer(arg, "\"");
 997     for (; len > 0; --len) {
 998         c = *p++;
 999         if (' ' <= c && c <= '~')
1000             printer(arg, "%c", c);
1001         else
1002             printer(arg, "\\%.3o", c);
1003     }
1004     printer(arg, "\"");
1005 }
1006
1007 /*
1008  * novm - log an error message saying we ran out of memory, and die.
1009  */
1010 void
1011 novm(msg)
1012     char *msg;
1013 {
1014     syslog(LOG_ERR, "Virtual memory exhausted allocating %s\n", msg);
1015     die(1);
1016 }