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