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.63 1999/03/19 04:23:40 paulus Exp $";
  22 #endif
  23
  24 #include <stdio.h>
  25 #include <ctype.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <unistd.h>
  29 #include <signal.h>
  30 #include <errno.h>
  31 #include <fcntl.h>
  32 #include <syslog.h>
  33 #include <netdb.h>
  34 #include <utmp.h>
  35 #include <pwd.h>
  36 #include <setjmp.h>
  37 #include <sys/param.h>
  38 #include <sys/types.h>
  39 #include <sys/wait.h>
  40 #include <sys/time.h>
  41 #include <sys/resource.h>
  42 #include <sys/stat.h>
  43 #include <sys/socket.h>
  44 #include <netinet/in.h>
  45
  46 #include "pppd.h"
  47 #include "magic.h"
  48 #include "fsm.h"
  49 #include "lcp.h"
  50 #include "ipcp.h"
  51 #include "upap.h"
  52 #include "chap.h"
  53 #include "ccp.h"
  54 #include "pathnames.h"
  55 #include "patchlevel.h"
  56
  57 #ifdef CBCP_SUPPORT
  58 #include "cbcp.h"
  59 #endif
  60
  61 #if defined(SUNOS4)
  62 extern char *strerror();
  63 #endif
  64
  65 #ifdef IPX_CHANGE
  66 #include "ipxcp.h"
  67 #endif /* IPX_CHANGE */
  68 #ifdef AT_CHANGE
  69 #include "atcp.h"
  70 #endif
  71
  72 /* interface vars */
  73 char ifname[32];                /* Interface name */
  74 int ifunit;                     /* Interface unit number */
  75
  76 char *progname;                 /* Name of this program */
  77 char hostname[MAXNAMELEN];      /* Our hostname */
  78 static char pidfilename[MAXPATHLEN];    /* name of pid file */
  79 static char default_devnam[MAXPATHLEN]; /* name of default device */
  80 static pid_t pid;               /* Our pid */
  81 static uid_t uid;               /* Our real user-id */
  82 static int conn_running;        /* we have a [dis]connector running */
  83
  84 int ttyfd = -1;                 /* Serial port file descriptor */
  85 mode_t tty_mode = -1;           /* Original access permissions to tty */
  86 int baud_rate;                  /* Actual bits/second for serial device */
  87 int hungup;                     /* terminal has been hung up */
  88 int privileged;                 /* we're running as real uid root */
  89 int need_holdoff;               /* need holdoff period before restarting */
  90 int detached;                   /* have detached from terminal */
  91 int log_to_fd;                  /* send log messages to this fd too */
  92
  93 static int fd_ppp;              /* fd for talking PPP */
  94 static int fd_loop;             /* fd for getting demand-dial packets */
  95
  96 int phase;                      /* where the link is at */
  97 int kill_link;
  98 int open_ccp_flag;
  99
 100 static int waiting;
 101 static sigjmp_buf sigjmp;
 102
 103 char **script_env;              /* Env. variable values for scripts */
 104 int s_env_nalloc;               /* # words avail at script_env */
 105
 106 u_char outpacket_buf[PPP_MRU+PPP_HDRLEN]; /* buffer for outgoing packet */
 107 u_char inpacket_buf[PPP_MRU+PPP_HDRLEN]; /* buffer for incoming packet */
 108
 109 static int n_children;          /* # child processes still running */
 110
 111 static int locked;              /* lock() has succeeded */
 112
 113 char *no_ppp_msg = "Sorry - this system lacks PPP kernel support\n";
 114
 115 GIDSET_TYPE groups[NGROUPS_MAX];/* groups the user is in */
 116 int ngroups;                    /* How many groups valid in groups */
 117
 118 static struct timeval start_time;       /* Time when link was started. */
 119
 120 struct ppp_stats link_stats;
 121 int link_stats_valid;
 122
 123 /* Prototypes for procedures local to this file. */
 124
 125 static void create_pidfile __P((void));
 126 static void cleanup __P((void));
 127 static void close_tty __P((void));
 128 static void hangup_modem __P((int));
 129 static void get_input __P((void));
 130 static void calltimeout __P((void));
 131 static struct timeval *timeleft __P((struct timeval *));
 132 static void kill_my_pg __P((int));
 133 static void hup __P((int));
 134 static void term __P((int));
 135 static void chld __P((int));
 136 static void toggle_debug __P((int));
 137 static void open_ccp __P((int));
 138 static void bad_signal __P((int));
 139 static void holdoff_end __P((void *));
 140 static int device_script __P((char *, int));
 141 static void reap_kids __P((void));
 142 static void pr_log __P((void *, char *, ...));
 143 static void logit __P((int, char *, va_list));
 144 static void vslp_printer __P((void *, char *, ...));
 145 static void format_packet __P((u_char *, int, void (*) (void *, char *, ...),
 146                                void *));
 147
 148 extern  char    *ttyname __P((int));
 149 extern  char    *getlogin __P((void));
 150 int main __P((int, char *[]));
 151
 152 #ifdef ultrix
 153 #undef  O_NONBLOCK
 154 #define O_NONBLOCK      O_NDELAY
 155 #endif
 156
 157 #ifdef ULTRIX
 158 #define setlogmask(x)
 159 #endif
 160
 161 /*
 162  * PPP Data Link Layer "protocol" table.
 163  * One entry per supported protocol.
 164  * The last entry must be NULL.
 165  */
 166 struct protent *protocols[] = {
 167     &lcp_protent,
 168     &pap_protent,
 169     &chap_protent,
 170 #ifdef CBCP_SUPPORT
 171     &cbcp_protent,
 172 #endif
 173     &ipcp_protent,
 174     &ccp_protent,
 175 #ifdef IPX_CHANGE
 176     &ipxcp_protent,
 177 #endif
 178 #ifdef AT_CHANGE
 179     &atcp_protent,
 180 #endif
 181     NULL
 182 };
 183
 184 int
 185 main(argc, argv)
 186     int argc;
 187     char *argv[];
 188 {
 189     int i, fdflags;
 190     struct sigaction sa;
 191     char *p;
 192     struct passwd *pw;
 193     struct timeval timo;
 194     sigset_t mask;
 195     struct protent *protp;
 196     struct stat statbuf;
 197     char numbuf[16];
 198     struct timeval now;
 199
 200     phase = PHASE_INITIALIZE;
 201     p = ttyname(0);
 202     if (p)
 203         strlcpy(devnam, p, sizeof(devnam));
 204     strlcpy(default_devnam, devnam, sizeof(default_devnam));
 205
 206     script_env = NULL;
 207
 208     /* Initialize syslog facilities */
 209 #ifdef ULTRIX
 210     openlog("pppd", LOG_PID);
 211 #else
 212     openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
 213     setlogmask(LOG_UPTO(LOG_INFO));
 214 #endif
 215
 216     if (gethostname(hostname, MAXNAMELEN) < 0 ) {
 217         option_error("Couldn't get hostname: %m");
 218         exit(1);
 219     }
 220     hostname[MAXNAMELEN-1] = 0;
 221
 222     uid = getuid();
 223     privileged = uid == 0;
 224     slprintf(numbuf, sizeof(numbuf), "%d", uid);
 225     script_setenv("ORIG_UID", numbuf);
 226
 227     ngroups = getgroups(NGROUPS_MAX, groups);
 228
 229     /*
 230      * Initialize to the standard option set, then parse, in order,
 231      * the system options file, the user's options file,
 232      * the tty's options file, and the command line arguments.
 233      */
 234     for (i = 0; (protp = protocols[i]) != NULL; ++i)
 235         (*protp->init)(0);
 236
 237     progname = *argv;
 238
 239     if (!options_from_file(_PATH_SYSOPTIONS, !privileged, 0, 1)
 240         || !options_from_user())
 241         exit(1);
 242     scan_args(argc-1, argv+1);  /* look for tty name on command line */
 243     if (!options_for_tty()
 244         || !parse_args(argc-1, argv+1))
 245         exit(1);
 246
 247     /*
 248      * Check that we are running as root.
 249      */
 250     if (geteuid() != 0) {
 251         option_error("must be root to run %s, since it is not setuid-root",
 252                      argv[0]);
 253         exit(1);
 254     }
 255
 256     if (!ppp_available()) {
 257         option_error(no_ppp_msg);
 258         exit(1);
 259     }
 260
 261     /*
 262      * Check that the options given are valid and consistent.
 263      */
 264     if (!sys_check_options())
 265         exit(1);
 266     auth_check_options();
 267     for (i = 0; (protp = protocols[i]) != NULL; ++i)
 268         if (protp->check_options != NULL)
 269             (*protp->check_options)();
 270     if (demand && connector == 0) {
 271         option_error("connect script is required for demand-dialling\n");
 272         exit(1);
 273     }
 274
 275     script_setenv("DEVICE", devnam);
 276     slprintf(numbuf, sizeof(numbuf), "%d", baud_rate);
 277     script_setenv("SPEED", numbuf);
 278
 279     /*
 280      * If the user has specified the default device name explicitly,
 281      * pretend they hadn't.
 282      */
 283     if (!default_device && strcmp(devnam, default_devnam) == 0)
 284         default_device = 1;
 285     if (default_device)
 286         nodetach = 1;
 287     log_to_fd = !default_device? 1: -1; /* default to stdout */
 288
 289     /*
 290      * Initialize system-dependent stuff and magic number package.
 291      */
 292     sys_init();
 293     magic_init();
 294     if (debug)
 295         setlogmask(LOG_UPTO(LOG_DEBUG));
 296
 297     /*
 298      * Detach ourselves from the terminal, if required,
 299      * and identify who is running us.
 300      */
 301     if (!nodetach && !updetach)
 302         detach();
 303     pid = getpid();
 304     p = getlogin();
 305     if (p == NULL) {
 306         pw = getpwuid(uid);
 307         if (pw != NULL && pw->pw_name != NULL)
 308             p = pw->pw_name;
 309         else
 310             p = "(unknown)";
 311     }
 312     syslog(LOG_NOTICE, "pppd %s.%d%s started by %s, uid %d",
 313            VERSION, PATCHLEVEL, IMPLEMENTATION, p, uid);
 314
 315     /*
 316      * Compute mask of all interesting signals and install signal handlers
 317      * for each.  Only one signal handler may be active at a time.  Therefore,
 318      * all other signals should be masked when any handler is executing.
 319      */
 320     sigemptyset(&mask);
 321     sigaddset(&mask, SIGHUP);
 322     sigaddset(&mask, SIGINT);
 323     sigaddset(&mask, SIGTERM);
 324     sigaddset(&mask, SIGCHLD);
 325     sigaddset(&mask, SIGUSR2);
 326
 327 #define SIGNAL(s, handler)      do { \
 328         sa.sa_handler = handler; \
 329         if (sigaction(s, &sa, NULL) < 0) \
 330             fatal("Couldn't establish signal handler (%d): %m", s); \
 331     } while (0)
 332
 333     sa.sa_mask = mask;
 334     sa.sa_flags = 0;
 335     SIGNAL(SIGHUP, hup);                /* Hangup */
 336     SIGNAL(SIGINT, term);               /* Interrupt */
 337     SIGNAL(SIGTERM, term);              /* Terminate */
 338     SIGNAL(SIGCHLD, chld);
 339
 340     SIGNAL(SIGUSR1, toggle_debug);      /* Toggle debug flag */
 341     SIGNAL(SIGUSR2, open_ccp);          /* Reopen CCP */
 342
 343     /*
 344      * Install a handler for other signals which would otherwise
 345      * cause pppd to exit without cleaning up.
 346      */
 347     SIGNAL(SIGABRT, bad_signal);
 348     SIGNAL(SIGALRM, bad_signal);
 349     SIGNAL(SIGFPE, bad_signal);
 350     SIGNAL(SIGILL, bad_signal);
 351     SIGNAL(SIGPIPE, bad_signal);
 352     SIGNAL(SIGQUIT, bad_signal);
 353     SIGNAL(SIGSEGV, bad_signal);
 354 #ifdef SIGBUS
 355     SIGNAL(SIGBUS, bad_signal);
 356 #endif
 357 #ifdef SIGEMT
 358     SIGNAL(SIGEMT, bad_signal);
 359 #endif
 360 #ifdef SIGPOLL
 361     SIGNAL(SIGPOLL, bad_signal);
 362 #endif
 363 #ifdef SIGPROF
 364     SIGNAL(SIGPROF, bad_signal);
 365 #endif
 366 #ifdef SIGSYS
 367     SIGNAL(SIGSYS, bad_signal);
 368 #endif
 369 #ifdef SIGTRAP
 370     SIGNAL(SIGTRAP, bad_signal);
 371 #endif
 372 #ifdef SIGVTALRM
 373     SIGNAL(SIGVTALRM, bad_signal);
 374 #endif
 375 #ifdef SIGXCPU
 376     SIGNAL(SIGXCPU, bad_signal);
 377 #endif
 378 #ifdef SIGXFSZ
 379     SIGNAL(SIGXFSZ, bad_signal);
 380 #endif
 381
 382     /*
 383      * Apparently we can get a SIGPIPE when we call syslog, if
 384      * syslogd has died and been restarted.  Ignoring it seems
 385      * be sufficient.
 386      */
 387     signal(SIGPIPE, SIG_IGN);
 388
 389     waiting = 0;
 390
 391     /*
 392      * If we're doing dial-on-demand, set up the interface now.
 393      */
 394     if (demand) {
 395         /*
 396          * Open the loopback channel and set it up to be the ppp interface.
 397          */
 398         fd_loop = open_ppp_loopback();
 399
 400         syslog(LOG_INFO, "Using interface ppp%d", ifunit);
 401         slprintf(ifname, sizeof(ifname), "ppp%d", ifunit);
 402         script_setenv("IFNAME", ifname);
 403
 404         create_pidfile();       /* write pid to file */
 405
 406         /*
 407          * Configure the interface and mark it up, etc.
 408          */
 409         demand_conf();
 410     }
 411
 412     for (;;) {
 413
 414         need_holdoff = 1;
 415
 416         if (demand) {
 417             /*
 418              * Don't do anything until we see some activity.
 419              */
 420             kill_link = 0;
 421             phase = PHASE_DORMANT;
 422             demand_unblock();
 423             add_fd(fd_loop);
 424             for (;;) {
 425                 if (sigsetjmp(sigjmp, 1) == 0) {
 426                     sigprocmask(SIG_BLOCK, &mask, NULL);
 427                     if (kill_link) {
 428                         sigprocmask(SIG_UNBLOCK, &mask, NULL);
 429                     } else {
 430                         waiting = 1;
 431                         sigprocmask(SIG_UNBLOCK, &mask, NULL);
 432                         wait_input(timeleft(&timo));
 433                     }
 434                 }
 435                 waiting = 0;
 436                 calltimeout();
 437                 if (kill_link) {
 438                     if (!persist)
 439                         break;
 440                     kill_link = 0;
 441                 }
 442                 if (get_loop_output())
 443                     break;
 444                 reap_kids();
 445             }
 446             remove_fd(fd_loop);
 447             if (kill_link && !persist)
 448                 break;
 449
 450             /*
 451              * Now we want to bring up the link.
 452              */
 453             demand_block();
 454             info("Starting link");
 455         }
 456
 457         /*
 458          * Lock the device if we've been asked to.
 459          */
 460         if (lockflag && !default_device) {
 461             if (lock(devnam) < 0)
 462                 goto fail;
 463             locked = 1;
 464         }
 465
 466         /*
 467          * Open the serial device and set it up to be the ppp interface.
 468          * First we open it in non-blocking mode so we can set the
 469          * various termios flags appropriately.  If we aren't dialling
 470          * out and we want to use the modem lines, we reopen it later
 471          * in order to wait for the carrier detect signal from the modem.
 472          */
 473         hungup = 0;
 474         kill_link = 0;
 475         for (;;) {
 476             /* If the user specified the device name, become the
 477                user before opening it. */
 478             if (!devnam_info.priv)
 479                 seteuid(uid);
 480             ttyfd = open(devnam, O_NONBLOCK | O_RDWR, 0);
 481             if (!devnam_info.priv)
 482                 seteuid(0);
 483             if (ttyfd >= 0)
 484                 break;
 485             if (errno != EINTR)
 486                 error("Failed to open %s: %m", devnam);
 487             if (!persist || errno != EINTR)
 488                 goto fail;
 489         }
 490         if ((fdflags = fcntl(ttyfd, F_GETFL)) == -1
 491             || fcntl(ttyfd, F_SETFL, fdflags & ~O_NONBLOCK) < 0)
 492             warn("Couldn't reset non-blocking mode on device: %m");
 493
 494         /*
 495          * Do the equivalent of `mesg n' to stop broadcast messages.
 496          */
 497         if (fstat(ttyfd, &statbuf) < 0
 498             || fchmod(ttyfd, statbuf.st_mode & ~(S_IWGRP | S_IWOTH)) < 0) {
 499             warn("Couldn't restrict write permissions to %s: %m", devnam);
 500         } else
 501             tty_mode = statbuf.st_mode;
 502
 503         /* run connection script */
 504         if (connector && connector[0]) {
 505             MAINDEBUG(("Connecting with <%s>", connector));
 506
 507             if (!default_device && modem) {
 508                 hangup_modem(ttyfd);    /* in case modem is off hook */
 509                 sleep(1);
 510             }
 511
 512             /*
 513              * Set line speed, flow control, etc.
 514              * On most systems we set CLOCAL for now so that we can talk
 515              * to the modem before carrier comes up.  But this has the
 516              * side effect that we might miss it if CD drops before we
 517              * get to clear CLOCAL below.  On systems where we can talk
 518              * successfully to the modem with CLOCAL clear and CD down,
 519              * we could clear CLOCAL at this point.
 520              */
 521             set_up_tty(ttyfd, 1);
 522
 523             if (device_script(connector, ttyfd) < 0) {
 524                 error("Connect script failed");
 525                 goto fail;
 526             }
 527
 528             info("Serial connection established.");
 529             sleep(1);           /* give it time to set up its terminal */
 530         }
 531
 532         /* set line speed, flow control, etc.; clear CLOCAL if modem option */
 533         set_up_tty(ttyfd, 0);
 534
 535         /* reopen tty if necessary to wait for carrier */
 536         if (connector == NULL && modem) {
 537             for (;;) {
 538                 if ((i = open(devnam, O_RDWR)) >= 0)
 539                     break;
 540                 if (errno != EINTR)
 541                     error("Failed to reopen %s: %m", devnam);
 542                 if (!persist || errno != EINTR || hungup || kill_link)
 543                     goto fail;
 544             }
 545             close(i);
 546         }
 547
 548         /* run welcome script, if any */
 549         if (welcomer && welcomer[0]) {
 550             if (device_script(welcomer, ttyfd) < 0)
 551                 warn("Welcome script failed");
 552         }
 553
 554         /* set up the serial device as a ppp interface */
 555         fd_ppp = establish_ppp(ttyfd);
 556
 557         if (!demand) {
 558
 559             info("Using interface ppp%d", ifunit);
 560             slprintf(ifname, sizeof(ifname), "ppp%d", ifunit);
 561             script_setenv("IFNAME", ifname);
 562
 563             create_pidfile();   /* write pid to file */
 564         }
 565
 566         /*
 567          * Start opening the connection and wait for
 568          * incoming events (reply, timeout, etc.).
 569          */
 570         notice("Connect: %s <--> %s", ifname, devnam);
 571         gettimeofday(&start_time, NULL);
 572         lcp_lowerup(0);
 573         lcp_open(0);            /* Start protocol */
 574         open_ccp_flag = 0;
 575         add_fd(fd_ppp);
 576         for (phase = PHASE_ESTABLISH; phase != PHASE_DEAD; ) {
 577             if (sigsetjmp(sigjmp, 1) == 0) {
 578                 sigprocmask(SIG_BLOCK, &mask, NULL);
 579                 if (kill_link || open_ccp_flag) {
 580                     sigprocmask(SIG_UNBLOCK, &mask, NULL);
 581                 } else {
 582                     waiting = 1;
 583                     sigprocmask(SIG_UNBLOCK, &mask, NULL);
 584                     wait_input(timeleft(&timo));
 585                 }
 586             }
 587             waiting = 0;
 588             calltimeout();
 589             get_input();
 590             if (kill_link) {
 591                 lcp_close(0, "User request");
 592                 kill_link = 0;
 593             }
 594             if (open_ccp_flag) {
 595                 if (phase == PHASE_NETWORK) {
 596                     ccp_fsm[0].flags = OPT_RESTART; /* clears OPT_SILENT */
 597                     (*ccp_protent.open)(0);
 598                 }
 599                 open_ccp_flag = 0;
 600             }
 601             reap_kids();        /* Don't leave dead kids lying around */
 602         }
 603
 604         /*
 605          * Print connect time and statistics.
 606          */
 607         if (gettimeofday(&now, NULL) >= 0) {
 608             int t = now.tv_sec - start_time.tv_sec;
 609             t = (t + 5) / 6;    /* now in 1/10ths of minutes */
 610             info("Connect time %d.%d minutes", t/10, t%10);
 611         }
 612         if (link_stats_valid) {
 613             info("Send %d bytes, received %d bytes",
 614                  link_stats.p.ppp_obytes, link_stats.p.ppp_ibytes);
 615         }
 616
 617         /*
 618          * If we may want to bring the link up again, transfer
 619          * the ppp unit back to the loopback.  Set the
 620          * real serial device back to its normal mode of operation.
 621          */
 622         remove_fd(fd_ppp);
 623         clean_check();
 624         if (demand)
 625             restore_loop();
 626         disestablish_ppp(ttyfd);
 627
 628         /*
 629          * Run disconnector script, if requested.
 630          * XXX we may not be able to do this if the line has hung up!
 631          */
 632         if (disconnector && !hungup) {
 633             set_up_tty(ttyfd, 1);
 634             if (device_script(disconnector, ttyfd) < 0) {
 635                 warn("disconnect script failed");
 636             } else {
 637                 info("Serial link disconnected.");
 638             }
 639         }
 640         if (!hungup)
 641             lcp_lowerdown(0);
 642
 643     fail:
 644         if (ttyfd >= 0)
 645             close_tty();
 646         if (locked) {
 647             unlock();
 648             locked = 0;
 649         }
 650
 651         if (!demand) {
 652             if (pidfilename[0] != 0
 653                 && unlink(pidfilename) < 0 && errno != ENOENT)
 654                 warn("unable to delete pid file: %m");
 655             pidfilename[0] = 0;
 656         }
 657
 658         if (!persist)
 659             break;
 660
 661         kill_link = 0;
 662         if (demand)
 663             demand_discard();
 664         if (holdoff > 0 && need_holdoff) {
 665             phase = PHASE_HOLDOFF;
 666             TIMEOUT(holdoff_end, NULL, holdoff);
 667             do {
 668                 if (sigsetjmp(sigjmp, 1) == 0) {
 669                     sigprocmask(SIG_BLOCK, &mask, NULL);
 670                     if (kill_link) {
 671                         sigprocmask(SIG_UNBLOCK, &mask, NULL);
 672                     } else {
 673                         waiting = 1;
 674                         sigprocmask(SIG_UNBLOCK, &mask, NULL);
 675                         wait_input(timeleft(&timo));
 676                     }
 677                 }
 678                 waiting = 0;
 679                 calltimeout();
 680                 if (kill_link) {
 681                     kill_link = 0;
 682                     phase = PHASE_DORMANT; /* allow signal to end holdoff */
 683                 }
 684                 reap_kids();
 685             } while (phase == PHASE_HOLDOFF);
 686             if (!persist)
 687                 break;
 688         }
 689     }
 690
 691     /* Wait for scripts to finish */
 692     while (n_children > 0)
 693         reap_kids();
 694
 695     die(0);
 696     return 0;
 697 }
 698
 699 /*
 700  * detach - detach us from the controlling terminal.
 701  */
 702 void
 703 detach()
 704 {
 705     if (detached)
 706         return;
 707     if (daemon(0, 0) < 0) {
 708         perror("Couldn't detach from controlling terminal");
 709         die(1);
 710     }
 711     detached = 1;
 712     log_to_fd = -1;
 713     pid = getpid();
 714     /* update pid file if it has been written already */
 715     if (pidfilename[0])
 716         create_pidfile();
 717 }
 718
 719 /*
 720  * Create a file containing our process ID.
 721  */
 722 static void
 723 create_pidfile()
 724 {
 725     FILE *pidfile;
 726     char numbuf[16];
 727
 728     slprintf(pidfilename, sizeof(pidfilename), "%s%s.pid",
 729              _PATH_VARRUN, ifname);
 730     if ((pidfile = fopen(pidfilename, "w")) != NULL) {
 731         fprintf(pidfile, "%d\n", pid);
 732         (void) fclose(pidfile);
 733     } else {
 734         error("Failed to create pid file %s: %m", pidfilename);
 735         pidfilename[0] = 0;
 736     }
 737     slprintf(numbuf, sizeof(numbuf), "%d", pid);
 738     script_setenv("PPPD_PID", numbuf);
 739 }
 740
 741 /*
 742  * holdoff_end - called via a timeout when the holdoff period ends.
 743  */
 744 static void
 745 holdoff_end(arg)
 746     void *arg;
 747 {
 748     phase = PHASE_DORMANT;
 749 }
 750
 751 /*
 752  * get_input - called when incoming data is available.
 753  */
 754 static void
 755 get_input()
 756 {
 757     int len, i;
 758     u_char *p;
 759     u_short protocol;
 760     struct protent *protp;
 761
 762     p = inpacket_buf;   /* point to beginning of packet buffer */
 763
 764     len = read_packet(inpacket_buf);
 765     if (len < 0)
 766         return;
 767
 768     if (len == 0) {
 769         notice("Modem hangup");
 770         hungup = 1;
 771         lcp_lowerdown(0);       /* serial link is no longer available */
 772         link_terminated(0);
 773         return;
 774     }
 775
 776     if (debug /*&& (debugflags & DBG_INPACKET)*/)
 777         dbglog("rcvd %P", p, len);
 778
 779     if (len < PPP_HDRLEN) {
 780         MAINDEBUG(("io(): Received short packet."));
 781         return;
 782     }
 783
 784     p += 2;                             /* Skip address and control */
 785     GETSHORT(protocol, p);
 786     len -= PPP_HDRLEN;
 787
 788     /*
 789      * Toss all non-LCP packets unless LCP is OPEN.
 790      */
 791     if (protocol != PPP_LCP && lcp_fsm[0].state != OPENED) {
 792         MAINDEBUG(("get_input: Received non-LCP packet when LCP not open."));
 793         return;
 794     }
 795
 796     /*
 797      * Until we get past the authentication phase, toss all packets
 798      * except LCP, LQR and authentication packets.
 799      */
 800     if (phase <= PHASE_AUTHENTICATE
 801         && !(protocol == PPP_LCP || protocol == PPP_LQR
 802              || protocol == PPP_PAP || protocol == PPP_CHAP)) {
 803         MAINDEBUG(("get_input: discarding proto 0x%x in phase %d",
 804                    protocol, phase));
 805         return;
 806     }
 807
 808     /*
 809      * Upcall the proper protocol input routine.
 810      */
 811     for (i = 0; (protp = protocols[i]) != NULL; ++i) {
 812         if (protp->protocol == protocol && protp->enabled_flag) {
 813             (*protp->input)(0, p, len);
 814             return;
 815         }
 816         if (protocol == (protp->protocol & ~0x8000) && protp->enabled_flag
 817             && protp->datainput != NULL) {
 818             (*protp->datainput)(0, p, len);
 819             return;
 820         }
 821     }
 822
 823     if (debug)
 824         warn("Unsupported protocol (0x%x) received", protocol);
 825     lcp_sprotrej(0, p - PPP_HDRLEN, len + PPP_HDRLEN);
 826 }
 827
 828
 829 /*
 830  * die - clean up state and exit with the specified status.
 831  */
 832 void
 833 die(status)
 834     int status;
 835 {
 836     cleanup();
 837     syslog(LOG_INFO, "Exit.");
 838     exit(status);
 839 }
 840
 841 /*
 842  * cleanup - restore anything which needs to be restored before we exit
 843  */
 844 /* ARGSUSED */
 845 static void
 846 cleanup()
 847 {
 848     sys_cleanup();
 849
 850     if (ttyfd >= 0)
 851         close_tty();
 852
 853     if (pidfilename[0] != 0 && unlink(pidfilename) < 0 && errno != ENOENT)
 854         warn("unable to delete pid file: %m");
 855     pidfilename[0] = 0;
 856
 857     if (locked)
 858         unlock();
 859 }
 860
 861 /*
 862  * close_tty - restore the terminal device and close it.
 863  */
 864 static void
 865 close_tty()
 866 {
 867     disestablish_ppp(ttyfd);
 868
 869     /* drop dtr to hang up */
 870     if (!default_device && modem) {
 871         hangup_modem(ttyfd);
 872         /*
 873          * This sleep is in case the serial port has CLOCAL set by default,
 874          * and consequently will reassert DTR when we close the device.
 875          */
 876         sleep(1);
 877     }
 878
 879     restore_tty(ttyfd);
 880
 881     if (tty_mode != (mode_t) -1) {
 882         if (fchmod(ttyfd, tty_mode) != 0) {
 883             /* XXX if devnam is a symlink, this will change the link */
 884             chmod(devnam, tty_mode);
 885         }
 886     }
 887
 888     close(ttyfd);
 889     ttyfd = -1;
 890 }
 891
 892 /*
 893  * hangup_modem - hang up the modem by clearing DTR.
 894  */
 895 static void
 896 hangup_modem(ttyfd)
 897     int ttyfd;
 898 {
 899     setdtr(ttyfd, 0);
 900 }
 901
 902
 903 struct  callout {
 904     struct timeval      c_time;         /* time at which to call routine */
 905     void                *c_arg;         /* argument to routine */
 906     void                (*c_func) __P((void *)); /* routine */
 907     struct              callout *c_next;
 908 };
 909
 910 static struct callout *callout = NULL;  /* Callout list */
 911 static struct timeval timenow;          /* Current time */
 912
 913 /*
 914  * timeout - Schedule a timeout.
 915  *
 916  * Note that this timeout takes the number of seconds, NOT hz (as in
 917  * the kernel).
 918  */
 919 void
 920 timeout(func, arg, time)
 921     void (*func) __P((void *));
 922     void *arg;
 923     int time;
 924 {
 925     struct callout *newp, *p, **pp;
 926
 927     MAINDEBUG(("Timeout %p:%p in %d seconds.", func, arg, time));
 928
 929     /*
 930      * Allocate timeout.
 931      */
 932     if ((newp = (struct callout *) malloc(sizeof(struct callout))) == NULL)
 933         fatal("Out of memory in timeout()!");
 934     newp->c_arg = arg;
 935     newp->c_func = func;
 936     gettimeofday(&timenow, NULL);
 937     newp->c_time.tv_sec = timenow.tv_sec + time;
 938     newp->c_time.tv_usec = timenow.tv_usec;
 939
 940     /*
 941      * Find correct place and link it in.
 942      */
 943     for (pp = &callout; (p = *pp); pp = &p->c_next)
 944         if (newp->c_time.tv_sec < p->c_time.tv_sec
 945             || (newp->c_time.tv_sec == p->c_time.tv_sec
 946                 && newp->c_time.tv_usec < p->c_time.tv_usec))
 947             break;
 948     newp->c_next = p;
 949     *pp = newp;
 950 }
 951
 952
 953 /*
 954  * untimeout - Unschedule a timeout.
 955  */
 956 void
 957 untimeout(func, arg)
 958     void (*func) __P((void *));
 959     void *arg;
 960 {
 961     struct callout **copp, *freep;
 962
 963     MAINDEBUG(("Untimeout %p:%p.", func, arg));
 964
 965     /*
 966      * Find first matching timeout and remove it from the list.
 967      */
 968     for (copp = &callout; (freep = *copp); copp = &freep->c_next)
 969         if (freep->c_func == func && freep->c_arg == arg) {
 970             *copp = freep->c_next;
 971             (void) free((char *) freep);
 972             break;
 973         }
 974 }
 975
 976
 977 /*
 978  * calltimeout - Call any timeout routines which are now due.
 979  */
 980 static void
 981 calltimeout()
 982 {
 983     struct callout *p;
 984
 985     while (callout != NULL) {
 986         p = callout;
 987
 988         if (gettimeofday(&timenow, NULL) < 0)
 989             fatal("Failed to get time of day: %m");
 990         if (!(p->c_time.tv_sec < timenow.tv_sec
 991               || (p->c_time.tv_sec == timenow.tv_sec
 992                   && p->c_time.tv_usec <= timenow.tv_usec)))
 993             break;              /* no, it's not time yet */
 994
 995         callout = p->c_next;
 996         (*p->c_func)(p->c_arg);
 997
 998         free((char *) p);
 999     }
1000 }
1001
1002
1003 /*
1004  * timeleft - return the length of time until the next timeout is due.
1005  */
1006 static struct timeval *
1007 timeleft(tvp)
1008     struct timeval *tvp;
1009 {
1010     if (callout == NULL)
1011         return NULL;
1012
1013     gettimeofday(&timenow, NULL);
1014     tvp->tv_sec = callout->c_time.tv_sec - timenow.tv_sec;
1015     tvp->tv_usec = callout->c_time.tv_usec - timenow.tv_usec;
1016     if (tvp->tv_usec < 0) {
1017         tvp->tv_usec += 1000000;
1018         tvp->tv_sec -= 1;
1019     }
1020     if (tvp->tv_sec < 0)
1021         tvp->tv_sec = tvp->tv_usec = 0;
1022
1023     return tvp;
1024 }
1025
1026
1027 /*
1028  * kill_my_pg - send a signal to our process group, and ignore it ourselves.
1029  */
1030 static void
1031 kill_my_pg(sig)
1032     int sig;
1033 {
1034     struct sigaction act, oldact;
1035
1036     act.sa_handler = SIG_IGN;
1037     act.sa_flags = 0;
1038     kill(0, sig);
1039     sigaction(sig, &act, &oldact);
1040     sigaction(sig, &oldact, NULL);
1041 }
1042
1043
1044 /*
1045  * hup - Catch SIGHUP signal.
1046  *
1047  * Indicates that the physical layer has been disconnected.
1048  * We don't rely on this indication; if the user has sent this
1049  * signal, we just take the link down.
1050  */
1051 static void
1052 hup(sig)
1053     int sig;
1054 {
1055     info("Hangup (SIGHUP)");
1056     kill_link = 1;
1057     if (conn_running)
1058         /* Send the signal to the [dis]connector process(es) also */
1059         kill_my_pg(sig);
1060     if (waiting)
1061         siglongjmp(sigjmp, 1);
1062 }
1063
1064
1065 /*
1066  * term - Catch SIGTERM signal and SIGINT signal (^C/del).
1067  *
1068  * Indicates that we should initiate a graceful disconnect and exit.
1069  */
1070 /*ARGSUSED*/
1071 static void
1072 term(sig)
1073     int sig;
1074 {
1075     info("Terminating on signal %d.", sig);
1076     persist = 0;                /* don't try to restart */
1077     kill_link = 1;
1078     if (conn_running)
1079         /* Send the signal to the [dis]connector process(es) also */
1080         kill_my_pg(sig);
1081     if (waiting)
1082         siglongjmp(sigjmp, 1);
1083 }
1084
1085
1086 /*
1087  * chld - Catch SIGCHLD signal.
1088  * Calls reap_kids to get status for any dead kids.
1089  */
1090 static void
1091 chld(sig)
1092     int sig;
1093 {
1094     if (waiting)
1095         siglongjmp(sigjmp, 1);
1096 }
1097
1098
1099 /*
1100  * toggle_debug - Catch SIGUSR1 signal.
1101  *
1102  * Toggle debug flag.
1103  */
1104 /*ARGSUSED*/
1105 static void
1106 toggle_debug(sig)
1107     int sig;
1108 {
1109     debug = !debug;
1110     if (debug) {
1111         setlogmask(LOG_UPTO(LOG_DEBUG));
1112     } else {
1113         setlogmask(LOG_UPTO(LOG_WARNING));
1114     }
1115 }
1116
1117
1118 /*
1119  * open_ccp - Catch SIGUSR2 signal.
1120  *
1121  * Try to (re)negotiate compression.
1122  */
1123 /*ARGSUSED*/
1124 static void
1125 open_ccp(sig)
1126     int sig;
1127 {
1128     open_ccp_flag = 1;
1129     if (waiting)
1130         siglongjmp(sigjmp, 1);
1131 }
1132
1133
1134 /*
1135  * bad_signal - We've caught a fatal signal.  Clean up state and exit.
1136  */
1137 static void
1138 bad_signal(sig)
1139     int sig;
1140 {
1141     static int crashed = 0;
1142
1143     if (crashed)
1144         _exit(127);
1145     crashed = 1;
1146     error("Fatal signal %d", sig);
1147     if (conn_running)
1148         kill_my_pg(SIGTERM);
1149     die(1);
1150 }
1151
1152
1153 /*
1154  * device_script - run a program to connect or disconnect the
1155  * serial device.
1156  */
1157 static int
1158 device_script(program, inout)
1159     char *program;
1160     int inout;
1161 {
1162     int pid;
1163     int status;
1164     int errfd;
1165
1166     conn_running = 1;
1167     pid = fork();
1168
1169     if (pid < 0) {
1170         conn_running = 0;
1171         fatal("Failed to create child process: %m");
1172     }
1173
1174     if (pid == 0) {
1175         sys_close();
1176         closelog();
1177         if (inout == 2) {
1178             /* aargh!!! */
1179             int newio = dup(inout);
1180             close(inout);
1181             inout = newio;
1182         }
1183         if (log_to_fd >= 0) {
1184             if (log_to_fd != 2)
1185                 dup2(log_to_fd, 2);
1186         } else {
1187             close(2);
1188             errfd = open(_PATH_CONNERRS, O_WRONLY | O_APPEND | O_CREAT, 0600);
1189             if (errfd >= 0 && errfd != 2) {
1190                 dup2(errfd, 2);
1191                 close(errfd);
1192             }
1193         }
1194         if (inout != 0) {
1195             dup2(inout, 0);
1196             close(inout);
1197         }
1198         dup2(0, 1);
1199         setuid(uid);
1200         if (getuid() != uid) {
1201             error("setuid failed");
1202             exit(1);
1203         }
1204         setgid(getgid());
1205         execl("/bin/sh", "sh", "-c", program, (char *)0);
1206         error("could not exec /bin/sh: %m");
1207         exit(99);
1208         /* NOTREACHED */
1209     }
1210
1211     while (waitpid(pid, &status, 0) < 0) {
1212         if (errno == EINTR)
1213             continue;
1214         fatal("error waiting for (dis)connection process: %m");
1215     }
1216     conn_running = 0;
1217
1218     return (status == 0 ? 0 : -1);
1219 }
1220
1221
1222 /*
1223  * We maintain a list of child process pids and
1224  * functions to call when they exit.
1225  */
1226 struct subprocess {
1227     pid_t       pid;
1228     char        *prog;
1229     void        (*done) __P((void *));
1230     void        *arg;
1231     struct subprocess *next;
1232 };
1233
1234 struct subprocess *children;
1235
1236 /*
1237  * run-program - execute a program with given arguments,
1238  * but don't wait for it.
1239  * If the program can't be executed, logs an error unless
1240  * must_exist is 0 and the program file doesn't exist.
1241  * Returns -1 if it couldn't fork, 0 if the file doesn't exist
1242  * or isn't an executable plain file, or the process ID of the child.
1243  * If done != NULL, (*done)(arg) will be called later (within
1244  * reap_kids) iff the return value is > 0.
1245  */
1246 pid_t
1247 run_program(prog, args, must_exist, done, arg)
1248     char *prog;
1249     char **args;
1250     int must_exist;
1251     void (*done) __P((void *));
1252     void *arg;
1253 {
1254     int pid;
1255     struct subprocess *chp;
1256     struct stat sbuf;
1257
1258     /*
1259      * First check if the file exists and is executable.
1260      * We don't use access() because that would use the
1261      * real user-id, which might not be root, and the script
1262      * might be accessible only to root.
1263      */
1264     errno = EINVAL;
1265     if (stat(prog, &sbuf) < 0 || !S_ISREG(sbuf.st_mode)
1266         || (sbuf.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH)) == 0) {
1267         if (must_exist || errno != ENOENT)
1268             warn("Can't execute %s: %m", prog);
1269         return 0;
1270     }
1271
1272     pid = fork();
1273     if (pid == -1)
1274         fatal("Failed to create child process for %s: %m", prog);
1275     if (pid == 0) {
1276         int new_fd;
1277
1278         /* Leave the current location */
1279         (void) setsid();        /* No controlling tty. */
1280         (void) umask (S_IRWXG|S_IRWXO);
1281         (void) chdir ("/");     /* no current directory. */
1282         setuid(0);              /* set real UID = root */
1283         setgid(getegid());
1284
1285         /* Ensure that nothing of our device environment is inherited. */
1286         sys_close();
1287         closelog();
1288         close (0);
1289         close (1);
1290         close (2);
1291         close (ttyfd);  /* tty interface to the ppp device */
1292
1293         /* Don't pass handles to the PPP device, even by accident. */
1294         new_fd = open (_PATH_DEVNULL, O_RDWR);
1295         if (new_fd >= 0) {
1296             if (new_fd != 0) {
1297                 dup2  (new_fd, 0); /* stdin <- /dev/null */
1298                 close (new_fd);
1299             }
1300             dup2 (0, 1); /* stdout -> /dev/null */
1301             dup2 (0, 2); /* stderr -> /dev/null */
1302         }
1303
1304 #ifdef BSD
1305         /* Force the priority back to zero if pppd is running higher. */
1306         if (setpriority (PRIO_PROCESS, 0, 0) < 0)
1307             warn("can't reset priority to 0: %m");
1308 #endif
1309
1310         /* SysV recommends a second fork at this point. */
1311
1312         /* run the program */
1313         execve(prog, args, script_env);
1314         if (must_exist || errno != ENOENT)
1315             warn("Can't execute %s: %m", prog);
1316         _exit(-1);
1317     }
1318
1319     if (debug)
1320         dbglog("Script %s started; pid = %d", prog, pid);
1321     ++n_children;
1322
1323     chp = (struct subprocess *) malloc(sizeof(struct subprocess));
1324     if (chp == NULL) {
1325         warn("losing track of %s process", prog);
1326     } else {
1327         chp->pid = pid;
1328         chp->prog = prog;
1329         chp->done = done;
1330         chp->arg = arg;
1331         chp->next = children;
1332         children = chp;
1333     }
1334
1335     return pid;
1336 }
1337
1338
1339 /*
1340  * reap_kids - get status from any dead child processes,
1341  * and log a message for abnormal terminations.
1342  */
1343 static void
1344 reap_kids()
1345 {
1346     int pid, status;
1347     struct subprocess *chp, **prevp;
1348
1349     if (n_children == 0)
1350         return;
1351     while ((pid = waitpid(-1, &status, WNOHANG)) != -1 && pid != 0) {
1352         --n_children;
1353         for (prevp = &children; (chp = *prevp) != NULL; prevp = &chp->next)
1354             if (chp->pid == pid)
1355                 break;
1356         if (debug)
1357             dbglog("process %d (%s) finished, status = 0x%x",
1358                    pid, (chp? chp->prog: "??"), status);
1359         if (WIFSIGNALED(status)) {
1360             warn("Child process %s (pid %d) terminated with signal %d",
1361                  (chp? chp->prog: "??"), pid, WTERMSIG(status));
1362         }
1363         if (chp && chp->done)
1364             (*chp->done)(chp->arg);
1365     }
1366     if (pid == -1 && errno != ECHILD)
1367         error("Error waiting for child process: %m");
1368 }
1369
1370
1371 /*
1372  * log_packet - format a packet and log it.
1373  */
1374
1375 char line[256];                 /* line to be logged accumulated here */
1376 char *linep;
1377
1378 void
1379 log_packet(p, len, prefix, level)
1380     u_char *p;
1381     int len;
1382     char *prefix;
1383     int level;
1384 {
1385     strlcpy(line, prefix, sizeof(line));
1386     linep = line + strlen(line);
1387     format_packet(p, len, pr_log, NULL);
1388     if (linep != line)
1389         syslog(level, "%s", line);
1390 }
1391
1392 /*
1393  * format_packet - make a readable representation of a packet,
1394  * calling `printer(arg, format, ...)' to output it.
1395  */
1396 static void
1397 format_packet(p, len, printer, arg)
1398     u_char *p;
1399     int len;
1400     void (*printer) __P((void *, char *, ...));
1401     void *arg;
1402 {
1403     int i, n;
1404     u_short proto;
1405     struct protent *protp;
1406
1407     if (len >= PPP_HDRLEN && p[0] == PPP_ALLSTATIONS && p[1] == PPP_UI) {
1408         p += 2;
1409         GETSHORT(proto, p);
1410         len -= PPP_HDRLEN;
1411         for (i = 0; (protp = protocols[i]) != NULL; ++i)
1412             if (proto == protp->protocol)
1413                 break;
1414         if (protp != NULL) {
1415             printer(arg, "[%s", protp->name);
1416             n = (*protp->printpkt)(p, len, printer, arg);
1417             printer(arg, "]");
1418             p += n;
1419             len -= n;
1420         } else {
1421             for (i = 0; (protp = protocols[i]) != NULL; ++i)
1422                 if (proto == (protp->protocol & ~0x8000))
1423                     break;
1424             if (protp != 0 && protp->data_name != 0) {
1425                 printer(arg, "[%s data]", protp->data_name);
1426                 if (len > 8)
1427                     printer(arg, "%.8B ...", p);
1428                 else
1429                     printer(arg, "%.*B", len, p);
1430                 len = 0;
1431             } else
1432                 printer(arg, "[proto=0x%x]", proto);
1433         }
1434     }
1435
1436     if (len > 32)
1437         printer(arg, "%.32B ...", p);
1438     else
1439         printer(arg, "%.*B", len, p);
1440 }
1441
1442 static void
1443 pr_log __V((void *arg, char *fmt, ...))
1444 {
1445     int n;
1446     va_list pvar;
1447     char buf[256];
1448
1449 #if __STDC__
1450     va_start(pvar, fmt);
1451 #else
1452     void *arg;
1453     char *fmt;
1454     va_start(pvar);
1455     arg = va_arg(pvar, void *);
1456     fmt = va_arg(pvar, char *);
1457 #endif
1458
1459     n = vslprintf(buf, sizeof(buf), fmt, pvar);
1460     va_end(pvar);
1461
1462     if (linep + n + 1 > line + sizeof(line)) {
1463         syslog(LOG_DEBUG, "%s", line);
1464         linep = line;
1465     }
1466     strlcpy(linep, buf, line + sizeof(line) - linep);
1467     linep += n;
1468 }
1469
1470 /*
1471  * vslp_printer - used in processing a %P format
1472  */
1473 struct buffer_info {
1474     char *ptr;
1475     int len;
1476 };
1477
1478 static void
1479 vslp_printer __V((void *arg, char *fmt, ...))
1480 {
1481     int n;
1482     va_list pvar;
1483     struct buffer_info *bi;
1484
1485 #if __STDC__
1486     va_start(pvar, fmt);
1487 #else
1488     void *arg;
1489     char *fmt;
1490     va_start(pvar);
1491     arg = va_arg(pvar, void *);
1492     fmt = va_arg(pvar, char *);
1493 #endif
1494
1495     bi = (struct buffer_info *) arg;
1496     n = vslprintf(bi->ptr, bi->len, fmt, pvar);
1497     va_end(pvar);
1498
1499     bi->ptr += n;
1500     bi->len -= n;
1501 }
1502
1503 /*
1504  * print_string - print a readable representation of a string using
1505  * printer.
1506  */
1507 void
1508 print_string(p, len, printer, arg)
1509     char *p;
1510     int len;
1511     void (*printer) __P((void *, char *, ...));
1512     void *arg;
1513 {
1514     int c;
1515
1516     printer(arg, "\"");
1517     for (; len > 0; --len) {
1518         c = *p++;
1519         if (' ' <= c && c <= '~') {
1520             if (c == '\\' || c == '"')
1521                 printer(arg, "\\");
1522             printer(arg, "%c", c);
1523         } else {
1524             switch (c) {
1525             case '\n':
1526                 printer(arg, "\\n");
1527                 break;
1528             case '\r':
1529                 printer(arg, "\\r");
1530                 break;
1531             case '\t':
1532                 printer(arg, "\\t");
1533                 break;
1534             default:
1535                 printer(arg, "\\%.3o", c);
1536             }
1537         }
1538     }
1539     printer(arg, "\"");
1540 }
1541
1542 /*
1543  * novm - log an error message saying we ran out of memory, and die.
1544  */
1545 void
1546 novm(msg)
1547     char *msg;
1548 {
1549     fatal("Virtual memory exhausted allocating %s\n", msg);
1550 }
1551
1552 /*
1553  * slprintf - format a message into a buffer.  Like sprintf except we
1554  * also specify the length of the output buffer, and we handle
1555  * %r (recursive format), %m (error message), %v (visible string),
1556  * %q (quoted string), %t (current time) and %I (IP address) formats.
1557  * Doesn't do floating-point formats.
1558  * Returns the number of chars put into buf.
1559  */
1560 int
1561 slprintf __V((char *buf, int buflen, char *fmt, ...))
1562 {
1563     va_list args;
1564     int n;
1565
1566 #if __STDC__
1567     va_start(args, fmt);
1568 #else
1569     char *buf;
1570     int buflen;
1571     char *fmt;
1572     va_start(args);
1573     buf = va_arg(args, char *);
1574     buflen = va_arg(args, int);
1575     fmt = va_arg(args, char *);
1576 #endif
1577     n = vslprintf(buf, buflen, fmt, args);
1578     va_end(args);
1579     return n;
1580 }
1581
1582 /*
1583  * vslprintf - like slprintf, takes a va_list instead of a list of args.
1584  */
1585 #define OUTCHAR(c)      (buflen > 0? (--buflen, *buf++ = (c)): 0)
1586
1587 int
1588 vslprintf(buf, buflen, fmt, args)
1589     char *buf;
1590     int buflen;
1591     char *fmt;
1592     va_list args;
1593 {
1594     int c, i, n;
1595     int width, prec, fillch;
1596     int base, len, neg, quoted;
1597     unsigned long val = 0;
1598     char *str, *f, *buf0;
1599     unsigned char *p;
1600     char num[32];
1601     time_t t;
1602     u_int32_t ip;
1603     static char hexchars[] = "0123456789abcdef";
1604     struct buffer_info bufinfo;
1605
1606     buf0 = buf;
1607     --buflen;
1608     while (buflen > 0) {
1609         for (f = fmt; *f != '%' && *f != 0; ++f)
1610             ;
1611         if (f > fmt) {
1612             len = f - fmt;
1613             if (len > buflen)
1614                 len = buflen;
1615             memcpy(buf, fmt, len);
1616             buf += len;
1617             buflen -= len;
1618             fmt = f;
1619         }
1620         if (*fmt == 0)
1621             break;
1622         c = *++fmt;
1623         width = prec = 0;
1624         fillch = ' ';
1625         if (c == '0') {
1626             fillch = '0';
1627             c = *++fmt;
1628         }
1629         if (c == '*') {
1630             width = va_arg(args, int);
1631             c = *++fmt;
1632         } else {
1633             while (isdigit(c)) {
1634                 width = width * 10 + c - '0';
1635                 c = *++fmt;
1636             }
1637         }
1638         if (c == '.') {
1639             c = *++fmt;
1640             if (c == '*') {
1641                 prec = va_arg(args, int);
1642                 c = *++fmt;
1643             } else {
1644                 while (isdigit(c)) {
1645                     prec = prec * 10 + c - '0';
1646                     c = *++fmt;
1647                 }
1648             }
1649         }
1650         str = 0;
1651         base = 0;
1652         neg = 0;
1653         ++fmt;
1654         switch (c) {
1655         case 'd':
1656             i = va_arg(args, int);
1657             if (i < 0) {
1658                 neg = 1;
1659                 val = -i;
1660             } else
1661                 val = i;
1662             base = 10;
1663             break;
1664         case 'o':
1665             val = va_arg(args, unsigned int);
1666             base = 8;
1667             break;
1668         case 'x':
1669         case 'X':
1670             val = va_arg(args, unsigned int);
1671             base = 16;
1672             break;
1673         case 'p':
1674             val = (unsigned long) va_arg(args, void *);
1675             base = 16;
1676             neg = 2;
1677             break;
1678         case 's':
1679             str = va_arg(args, char *);
1680             break;
1681         case 'c':
1682             num[0] = va_arg(args, int);
1683             num[1] = 0;
1684             str = num;
1685             break;
1686         case 'm':
1687             str = strerror(errno);
1688             break;
1689         case 'I':
1690             ip = va_arg(args, u_int32_t);
1691             ip = ntohl(ip);
1692             slprintf(num, sizeof(num), "%d.%d.%d.%d", (ip >> 24) & 0xff,
1693                      (ip >> 16) & 0xff, (ip >> 8) & 0xff, ip & 0xff);
1694             str = num;
1695             break;
1696         case 'r':
1697             f = va_arg(args, char *);
1698 #ifndef __powerpc__
1699             n = vslprintf(buf, buflen + 1, f, va_arg(args, va_list));
1700 #else
1701             /* On the powerpc, a va_list is an array of 1 structure */
1702             n = vslprintf(buf, buflen + 1, f, va_arg(args, void *));
1703 #endif
1704             buf += n;
1705             buflen -= n;
1706             continue;
1707         case 't':
1708             time(&t);
1709             str = ctime(&t);
1710             str += 4;           /* chop off the day name */
1711             str[15] = 0;        /* chop off year and newline */
1712             break;
1713         case 'v':               /* "visible" string */
1714         case 'q':               /* quoted string */
1715             quoted = c == 'q';
1716             p = va_arg(args, unsigned char *);
1717             if (fillch == '0' && prec > 0) {
1718                 n = prec;
1719             } else {
1720                 n = strlen((char *)p);
1721                 if (prec > 0 && prec < n)
1722                     n = prec;
1723             }
1724             while (n > 0 && buflen > 0) {
1725                 c = *p++;
1726                 --n;
1727                 if (!quoted && c >= 0x80) {
1728                     OUTCHAR('M');
1729                     OUTCHAR('-');
1730                     c -= 0x80;
1731                 }
1732                 if (quoted && (c == '"' || c == '\\'))
1733                     OUTCHAR('\\');
1734                 if (c < 0x20 || (0x7f <= c && c < 0xa0)) {
1735                     if (quoted) {
1736                         OUTCHAR('\\');
1737                         switch (c) {
1738                         case '\t':      OUTCHAR('t');   break;
1739                         case '\n':      OUTCHAR('n');   break;
1740                         case '\b':      OUTCHAR('b');   break;
1741                         case '\f':      OUTCHAR('f');   break;
1742                         default:
1743                             OUTCHAR('x');
1744                             OUTCHAR(hexchars[c >> 4]);
1745                             OUTCHAR(hexchars[c & 0xf]);
1746                         }
1747                     } else {
1748                         if (c == '\t')
1749                             OUTCHAR(c);
1750                         else {
1751                             OUTCHAR('^');
1752                             OUTCHAR(c ^ 0x40);
1753                         }
1754                     }
1755                 } else
1756                     OUTCHAR(c);
1757             }
1758             continue;
1759         case 'P':               /* print PPP packet */
1760             bufinfo.ptr = buf;
1761             bufinfo.len = buflen + 1;
1762             p = va_arg(args, unsigned char *);
1763             n = va_arg(args, int);
1764             format_packet(p, n, vslp_printer, &bufinfo);
1765             buf = bufinfo.ptr;
1766             buflen = bufinfo.len - 1;
1767             continue;
1768         case 'B':
1769             p = va_arg(args, unsigned char *);
1770             for (n = prec; n > 0; --n) {
1771                 c = *p++;
1772                 if (fillch == ' ')
1773                     OUTCHAR(' ');
1774                 OUTCHAR(hexchars[(c >> 4) & 0xf]);
1775                 OUTCHAR(hexchars[c & 0xf]);
1776             }
1777             continue;
1778         default:
1779             *buf++ = '%';
1780             if (c != '%')
1781                 --fmt;          /* so %z outputs %z etc. */
1782             --buflen;
1783             continue;
1784         }
1785         if (base != 0) {
1786             str = num + sizeof(num);
1787             *--str = 0;
1788             while (str > num + neg) {
1789                 *--str = hexchars[val % base];
1790                 val = val / base;
1791                 if (--prec <= 0 && val == 0)
1792                     break;
1793             }
1794             switch (neg) {
1795             case 1:
1796                 *--str = '-';
1797                 break;
1798             case 2:
1799                 *--str = 'x';
1800                 *--str = '0';
1801                 break;
1802             }
1803             len = num + sizeof(num) - 1 - str;
1804         } else {
1805             len = strlen(str);
1806             if (prec > 0 && len > prec)
1807                 len = prec;
1808         }
1809         if (width > 0) {
1810             if (width > buflen)
1811                 width = buflen;
1812             if ((n = width - len) > 0) {
1813                 buflen -= n;
1814                 for (; n > 0; --n)
1815                     *buf++ = fillch;
1816             }
1817         }
1818         if (len > buflen)
1819             len = buflen;
1820         memcpy(buf, str, len);
1821         buf += len;
1822         buflen -= len;
1823     }
1824     *buf = 0;
1825     return buf - buf0;
1826 }
1827
1828 /*
1829  * script_setenv - set an environment variable value to be used
1830  * for scripts that we run (e.g. ip-up, auth-up, etc.)
1831  */
1832 void
1833 script_setenv(var, value)
1834     char *var, *value;
1835 {
1836     size_t vl = strlen(var) + strlen(value) + 2;
1837     int i;
1838     char *p, *newstring;
1839
1840     newstring = (char *) malloc(vl);
1841     if (newstring == 0)
1842         return;
1843     slprintf(newstring, vl, "%s=%s", var, value);
1844
1845     /* check if this variable is already set */
1846     if (script_env != 0) {
1847         for (i = 0; (p = script_env[i]) != 0; ++i) {
1848             if (strncmp(p, var, vl) == 0 && p[vl] == '=') {
1849                 free(p);
1850                 script_env[i] = newstring;
1851                 return;
1852             }
1853         }
1854     } else {
1855         i = 0;
1856         script_env = (char **) malloc(16 * sizeof(char *));
1857         if (script_env == 0)
1858             return;
1859         s_env_nalloc = 16;
1860     }
1861
1862     /* reallocate script_env with more space if needed */
1863     if (i + 1 >= s_env_nalloc) {
1864         int new_n = i + 17;
1865         char **newenv = (char **) realloc((void *)script_env,
1866                                           new_n * sizeof(char *));
1867         if (newenv == 0)
1868             return;
1869         script_env = newenv;
1870         s_env_nalloc = new_n;
1871     }
1872
1873     script_env[i] = newstring;
1874     script_env[i+1] = 0;
1875 }
1876
1877 /*
1878  * script_unsetenv - remove a variable from the environment
1879  * for scripts.
1880  */
1881 void
1882 script_unsetenv(var)
1883     char *var;
1884 {
1885     int vl = strlen(var);
1886     int i;
1887     char *p;
1888
1889     if (script_env == 0)
1890         return;
1891     for (i = 0; (p = script_env[i]) != 0; ++i) {
1892         if (strncmp(p, var, vl) == 0 && p[vl] == '=') {
1893             free(p);
1894             while ((script_env[i] = script_env[i+1]) != 0)
1895                 ++i;
1896             break;
1897         }
1898     }
1899 }
1900
1901 /*
1902  * strlcpy - like strcpy/strncpy, doesn't overflow destination buffer,
1903  * always leaves destination null-terminated (for len > 0).
1904  */
1905 size_t
1906 strlcpy(dest, src, len)
1907     char *dest;
1908     const char *src;
1909     size_t len;
1910 {
1911     size_t ret = strlen(src);
1912
1913     if (len != 0) {
1914         if (ret < len)
1915             strcpy(dest, src);
1916         else {
1917             strncpy(dest, src, len - 1);
1918             dest[len-1] = 0;
1919         }
1920     }
1921     return ret;
1922 }
1923
1924 /*
1925  * strlcat - like strcat/strncat, doesn't overflow destination buffer,
1926  * always leaves destination null-terminated (for len > 0).
1927  */
1928 size_t
1929 strlcat(dest, src, len)
1930     char *dest;
1931     const char *src;
1932     size_t len;
1933 {
1934     size_t dlen = strlen(dest);
1935
1936     return dlen + strlcpy(dest + dlen, src, (len > dlen? len - dlen: 0));
1937 }
1938
1939 /*
1940  * logit - does the hard work for fatal et al.
1941  */
1942 static void
1943 logit(level, fmt, args)
1944     int level;
1945     char *fmt;
1946     va_list args;
1947 {
1948     int n;
1949     char buf[256];
1950
1951     n = vslprintf(buf, sizeof(buf), fmt, args);
1952     syslog(level, "%s", buf);
1953     if (log_to_fd >= 0 && (level != LOG_DEBUG || debug)) {
1954         if (buf[n-1] != '\n')
1955             buf[n++] = '\n';
1956         if (write(log_to_fd, buf, n) != n)
1957             log_to_fd = -1;
1958     }
1959 }
1960
1961 /*
1962  * fatal - log an error message and die horribly.
1963  */
1964 void
1965 fatal __V((char *fmt, ...))
1966 {
1967     va_list pvar;
1968
1969 #if __STDC__
1970     va_start(pvar, fmt);
1971 #else
1972     char *fmt;
1973     va_start(pvar);
1974     fmt = va_arg(pvar, char *);
1975 #endif
1976
1977     logit(LOG_ERR, fmt, pvar);
1978     va_end(pvar);
1979
1980     die(1);                     /* as promised */
1981 }
1982
1983 /*
1984  * error - log an error message.
1985  */
1986 void
1987 error __V((char *fmt, ...))
1988 {
1989     va_list pvar;
1990
1991 #if __STDC__
1992     va_start(pvar, fmt);
1993 #else
1994     char *fmt;
1995     va_start(pvar);
1996     fmt = va_arg(pvar, char *);
1997 #endif
1998
1999     logit(LOG_ERR, fmt, pvar);
2000     va_end(pvar);
2001 }
2002
2003 /*
2004  * warn - log a warning message.
2005  */
2006 void
2007 warn __V((char *fmt, ...))
2008 {
2009     va_list pvar;
2010
2011 #if __STDC__
2012     va_start(pvar, fmt);
2013 #else
2014     char *fmt;
2015     va_start(pvar);
2016     fmt = va_arg(pvar, char *);
2017 #endif
2018
2019     logit(LOG_WARNING, fmt, pvar);
2020     va_end(pvar);
2021 }
2022
2023 /*
2024  * notice - log a notice-level message.
2025  */
2026 void
2027 notice __V((char *fmt, ...))
2028 {
2029     va_list pvar;
2030
2031 #if __STDC__
2032     va_start(pvar, fmt);
2033 #else
2034     char *fmt;
2035     va_start(pvar);
2036     fmt = va_arg(pvar, char *);
2037 #endif
2038
2039     logit(LOG_NOTICE, fmt, pvar);
2040     va_end(pvar);
2041 }
2042
2043 /*
2044  * info - log an informational message.
2045  */
2046 void
2047 info __V((char *fmt, ...))
2048 {
2049     va_list pvar;
2050
2051 #if __STDC__
2052     va_start(pvar, fmt);
2053 #else
2054     char *fmt;
2055     va_start(pvar);
2056     fmt = va_arg(pvar, char *);
2057 #endif
2058
2059     logit(LOG_INFO, fmt, pvar);
2060     va_end(pvar);
2061 }
2062
2063 /*
2064  * dbglog - log a debug message.
2065  */
2066 void
2067 dbglog __V((char *fmt, ...))
2068 {
2069     va_list pvar;
2070
2071 #if __STDC__
2072     va_start(pvar, fmt);
2073 #else
2074     char *fmt;
2075     va_start(pvar);
2076     fmt = va_arg(pvar, char *);
2077 #endif
2078
2079     logit(LOG_DEBUG, fmt, pvar);
2080     va_end(pvar);
2081 }