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