pppd/tty.c

   1 /*
   2  * tty.c - code for handling serial ports in pppd.
   3  *
   4  * Copyright (C) 2000 Paul Mackerras.
   5  * All rights reserved.
   6  *
   7  * Portions Copyright (c) 1989 Carnegie Mellon University.
   8  * All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms are permitted
  11  * provided that the above copyright notice and this paragraph are
  12  * duplicated in all such forms and that any documentation,
  13  * advertising materials, and other materials related to such
  14  * distribution and use acknowledge that the software was developed
  15  * by Carnegie Mellon University.  The name of the
  16  * University may not be used to endorse or promote products derived
  17  * from this software without specific prior written permission.
  18  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  20  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  21  */
  22
  23 #define RCSID   "$Id: tty.c,v 1.1 2000/06/30 04:54:23 paulus Exp $"
  24
  25 #include <stdio.h>
  26 #include <ctype.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <unistd.h>
  30 #include <signal.h>
  31 #include <errno.h>
  32 #include <fcntl.h>
  33 #include <syslog.h>
  34 #include <netdb.h>
  35 #include <utmp.h>
  36 #include <pwd.h>
  37 #include <setjmp.h>
  38 #include <sys/param.h>
  39 #include <sys/types.h>
  40 #include <sys/wait.h>
  41 #include <sys/time.h>
  42 #include <sys/resource.h>
  43 #include <sys/stat.h>
  44 #include <sys/socket.h>
  45 #include <netinet/in.h>
  46 #include <arpa/inet.h>
  47
  48 #include "pppd.h"
  49 #include "fsm.h"
  50 #include "lcp.h"
  51
  52 static int setxonxoff __P((char **));
  53 static void finish_tty __P((void));
  54 static int start_charshunt __P((int, int));
  55 static void stop_charshunt __P((void *, int));
  56 static void charshunt_done __P((void *));
  57 static void charshunt __P((int, int, char *));
  58 static int record_write __P((FILE *, int code, u_char *buf, int nb,
  59                              struct timeval *));
  60 static int open_socket __P((char *));
  61 static void maybe_relock __P((void *, int));
  62
  63 static int pty_master;          /* fd for master side of pty */
  64 static int pty_slave;           /* fd for slave side of pty */
  65 static int real_ttyfd;          /* fd for actual serial port (not pty) */
  66 static int ttyfd;               /* Serial port file descriptor */
  67
  68 mode_t tty_mode = (mode_t)-1;   /* Original access permissions to tty */
  69 int baud_rate;                  /* Actual bits/second for serial device */
  70 char *callback_script;          /* script for doing callback */
  71 int charshunt_pid;              /* Process ID for charshunt */
  72 int locked;                     /* lock() has succeeded */
  73
  74 /* option variables */
  75 int     crtscts = 0;            /* Use hardware flow control */
  76 bool    modem = 1;              /* Use modem control lines */
  77 int     inspeed = 0;            /* Input/Output speed requested */
  78 bool    lockflag = 0;           /* Create lock file to lock the serial dev */
  79 char    *initializer = NULL;    /* Script to initialize physical link */
  80 char    *connect_script = NULL; /* Script to establish physical link */
  81 char    *disconnect_script = NULL; /* Script to disestablish physical link */
  82 char    *welcomer = NULL;       /* Script to run after phys link estab. */
  83 char    *ptycommand = NULL;     /* Command to run on other side of pty */
  84 bool    notty = 0;              /* Stdin/out is not a tty */
  85 char    *record_file = NULL;    /* File to record chars sent/received */
  86 int     max_data_rate;          /* max bytes/sec through charshunt */
  87 bool    sync_serial = 0;        /* Device is synchronous serial device */
  88 char    *pty_socket = NULL;     /* Socket to connect to pty */
  89 int     using_pty = 0;
  90
  91 extern uid_t uid;
  92 extern int kill_link;
  93
  94 /* XXX */
  95 extern int privopen;            /* don't lock, open device as root */
  96
  97 /* option descriptors */
  98 option_t tty_options[] = {
  99     { "lock", o_bool, &lockflag,
 100       "Lock serial device with UUCP-style lock file", 1 },
 101     { "nolock", o_bool, &lockflag,
 102       "Don't lock serial device", OPT_PRIV },
 103     { "init", o_string, &initializer,
 104       "A program to initialize the device",
 105       OPT_A2INFO | OPT_PRIVFIX, &initializer_info },
 106     { "connect", o_string, &connect_script,
 107       "A program to set up a connection",
 108       OPT_A2INFO | OPT_PRIVFIX, &connect_script_info },
 109     { "disconnect", o_string, &disconnect_script,
 110       "Program to disconnect serial device",
 111       OPT_A2INFO | OPT_PRIVFIX, &disconnect_script_info },
 112     { "welcome", o_string, &welcomer,
 113       "Script to welcome client",
 114       OPT_A2INFO | OPT_PRIVFIX, &welcomer_info },
 115     { "pty", o_string, &ptycommand,
 116       "Script to run on pseudo-tty master side",
 117       OPT_A2INFO | OPT_PRIVFIX | OPT_DEVNAM, &ptycommand_info },
 118     { "notty", o_bool, &notty,
 119       "Input/output is not a tty", OPT_DEVNAM | 1 },
 120     { "socket", o_string, &pty_socket,
 121       "Send and receive over socket, arg is host:port", OPT_DEVNAM },
 122     { "record", o_string, &record_file,
 123       "Record characters sent/received to file" },
 124     { "crtscts", o_int, &crtscts,
 125       "Set hardware (RTS/CTS) flow control", OPT_NOARG|OPT_VAL(1) },
 126     { "nocrtscts", o_int, &crtscts,
 127       "Disable hardware flow control", OPT_NOARG|OPT_VAL(-1) },
 128     { "-crtscts", o_int, &crtscts,
 129       "Disable hardware flow control", OPT_NOARG|OPT_VAL(-1) },
 130     { "cdtrcts", o_int, &crtscts,
 131       "Set alternate hardware (DTR/CTS) flow control", OPT_NOARG|OPT_VAL(2) },
 132     { "nocdtrcts", o_int, &crtscts,
 133       "Disable hardware flow control", OPT_NOARG|OPT_VAL(-1) },
 134     { "xonxoff", o_special_noarg, (void *)setxonxoff,
 135       "Set software (XON/XOFF) flow control" },
 136     { "modem", o_bool, &modem,
 137       "Use modem control lines", 1 },
 138     { "local", o_bool, &modem,
 139       "Don't use modem control lines" },
 140     { "sync", o_bool, &sync_serial,
 141       "Use synchronous HDLC serial encoding", 1 },
 142     { "datarate", o_int, &max_data_rate,
 143       "Maximum data rate in bytes/sec (with pty, notty or record option)" },
 144     { NULL }
 145 };
 146
 147 static int
 148 setxonxoff(argv)
 149     char **argv;
 150 {
 151         lcp_wantoptions[0].asyncmap |= 0x000A0000;      /* escape ^S and ^Q */
 152         lcp_wantoptions[0].neg_asyncmap = 1;
 153
 154         crtscts = -2;
 155         return 1;
 156 }
 157
 158 /*
 159  * tty_init - do various tty-related initializations.
 160  */
 161 void tty_init()
 162 {
 163     add_notifier(&pidchange, maybe_relock, 0);
 164     add_options(tty_options);
 165 }
 166
 167 /*
 168  * connect_tty - get the serial port ready to start doing PPP.
 169  * That is, open the serial port, set its speed and mode, and run
 170  * the connector and/or welcomer.
 171  */
 172 int connect_tty()
 173 {
 174         char *connector;
 175         int fdflags;
 176         struct stat statbuf;
 177         char numbuf[16];
 178
 179         /*
 180          * Get a pty master/slave pair if the pty, notty, socket,
 181          * or record options were specified.
 182          */
 183         strlcpy(ppp_devnam, devnam, sizeof(ppp_devnam));
 184         pty_master = -1;
 185         pty_slave = -1;
 186         real_ttyfd = -1;
 187         if (using_pty || record_file != NULL) {
 188                 if (!get_pty(&pty_master, &pty_slave, ppp_devnam, uid)) {
 189                         error("Couldn't allocate pseudo-tty");
 190                         status = EXIT_FATAL_ERROR;
 191                         return -1;
 192                 }
 193                 set_up_tty(pty_slave, 1);
 194         }
 195
 196         /*
 197          * Lock the device if we've been asked to.
 198          */
 199         status = EXIT_LOCK_FAILED;
 200         if (lockflag && !privopen) {
 201                 if (lock(devnam) < 0)
 202                         return -1;
 203                 locked = 1;
 204         }
 205
 206         /*
 207          * Open the serial device and set it up to be the ppp interface.
 208          * First we open it in non-blocking mode so we can set the
 209          * various termios flags appropriately.  If we aren't dialling
 210          * out and we want to use the modem lines, we reopen it later
 211          * in order to wait for the carrier detect signal from the modem.
 212          */
 213         hungup = 0;
 214         kill_link = 0;
 215         connector = doing_callback? callback_script: connect_script;
 216         if (devnam[0] != 0) {
 217                 for (;;) {
 218                         /* If the user specified the device name, become the
 219                            user before opening it. */
 220                         int err;
 221                         if (!devnam_info.priv && !privopen)
 222                                 seteuid(uid);
 223                         ttyfd = open(devnam, O_NONBLOCK | O_RDWR, 0);
 224                         err = errno;
 225                         if (!devnam_info.priv && !privopen)
 226                                 seteuid(0);
 227                         if (ttyfd >= 0)
 228                                 break;
 229                         errno = err;
 230                         if (err != EINTR) {
 231                                 error("Failed to open %s: %m", devnam);
 232                                 status = EXIT_OPEN_FAILED;
 233                         }
 234                         if (!persist || err != EINTR)
 235                                 return -1;
 236                 }
 237                 if ((fdflags = fcntl(ttyfd, F_GETFL)) == -1
 238                     || fcntl(ttyfd, F_SETFL, fdflags & ~O_NONBLOCK) < 0)
 239                         warn("Couldn't reset non-blocking mode on device: %m");
 240
 241                 /*
 242                  * Do the equivalent of `mesg n' to stop broadcast messages.
 243                  */
 244                 if (fstat(ttyfd, &statbuf) < 0
 245                     || fchmod(ttyfd, statbuf.st_mode & ~(S_IWGRP | S_IWOTH)) < 0) {
 246                         warn("Couldn't restrict write permissions to %s: %m", devnam);
 247                 } else
 248                         tty_mode = statbuf.st_mode;
 249
 250                 /*
 251                  * Set line speed, flow control, etc.
 252                  * If we have a non-null connection or initializer script,
 253                  * on most systems we set CLOCAL for now so that we can talk
 254                  * to the modem before carrier comes up.  But this has the
 255                  * side effect that we might miss it if CD drops before we
 256                  * get to clear CLOCAL below.  On systems where we can talk
 257                  * successfully to the modem with CLOCAL clear and CD down,
 258                  * we could clear CLOCAL at this point.
 259                  */
 260                 set_up_tty(ttyfd, ((connector != NULL && connector[0] != 0)
 261                                    || initializer != NULL));
 262                 real_ttyfd = ttyfd;
 263         }
 264
 265         /*
 266          * If the pty, socket, notty and/or record option was specified,
 267          * start up the character shunt now.
 268          */
 269         status = EXIT_PTYCMD_FAILED;
 270         if (ptycommand != NULL) {
 271                 if (record_file != NULL) {
 272                         int ipipe[2], opipe[2], ok;
 273
 274                         if (pipe(ipipe) < 0 || pipe(opipe) < 0)
 275                                 fatal("Couldn't create pipes for record option: %m");
 276                         ok = device_script(ptycommand, opipe[0], ipipe[1], 1) == 0
 277                                 && start_charshunt(ipipe[0], opipe[1]);
 278                         close(ipipe[0]);
 279                         close(ipipe[1]);
 280                         close(opipe[0]);
 281                         close(opipe[1]);
 282                         if (!ok)
 283                                 return -1;
 284                 } else {
 285                         if (device_script(ptycommand, pty_master, pty_master, 1) < 0)
 286                                 return -1;
 287                         ttyfd = pty_slave;
 288                         close(pty_master);
 289                         pty_master = -1;
 290                 }
 291         } else if (pty_socket != NULL) {
 292                 int fd = open_socket(pty_socket);
 293                 if (fd < 0)
 294                         return -1;
 295                 if (!start_charshunt(fd, fd))
 296                         return -1;
 297         } else if (notty) {
 298                 if (!start_charshunt(0, 1))
 299                         return -1;
 300         } else if (record_file != NULL) {
 301                 if (!start_charshunt(ttyfd, ttyfd))
 302                         return -1;
 303         }
 304
 305         /* run connection script */
 306         if ((connector && connector[0]) || initializer) {
 307                 if (real_ttyfd != -1) {
 308                         /* XXX do this if doing_callback == CALLBACK_DIALIN? */
 309                         if (!default_device && modem) {
 310                                 setdtr(real_ttyfd, 0);  /* in case modem is off hook */
 311                                 sleep(1);
 312                                 setdtr(real_ttyfd, 1);
 313                         }
 314                 }
 315
 316                 if (initializer && initializer[0]) {
 317                         if (device_script(initializer, ttyfd, ttyfd, 0) < 0) {
 318                                 error("Initializer script failed");
 319                                 status = EXIT_INIT_FAILED;
 320                                 return -1;
 321                         }
 322                         if (kill_link) {
 323                                 disconnect_tty();
 324                                 return -1;
 325                         }
 326                         info("Serial port initialized.");
 327                 }
 328
 329                 if (connector && connector[0]) {
 330                         if (device_script(connector, ttyfd, ttyfd, 0) < 0) {
 331                                 error("Connect script failed");
 332                                 status = EXIT_CONNECT_FAILED;
 333                                 return -1;
 334                         }
 335                         if (kill_link) {
 336                                 disconnect_tty();
 337                                 return -1;
 338                         }
 339                         info("Serial connection established.");
 340                 }
 341
 342                 /* set line speed, flow control, etc.;
 343                    clear CLOCAL if modem option */
 344                 if (real_ttyfd != -1)
 345                         set_up_tty(real_ttyfd, 0);
 346
 347                 if (doing_callback == CALLBACK_DIALIN)
 348                         connector = NULL;
 349         }
 350
 351         /* reopen tty if necessary to wait for carrier */
 352         if (connector == NULL && modem && devnam[0] != 0) {
 353                 int i;
 354                 for (;;) {
 355                         if ((i = open(devnam, O_RDWR)) >= 0)
 356                                 break;
 357                         if (errno != EINTR) {
 358                                 error("Failed to reopen %s: %m", devnam);
 359                                 status = EXIT_OPEN_FAILED;
 360                         }
 361                         if (!persist || errno != EINTR || hungup || kill_link)
 362                                 return -1;
 363                 }
 364                 close(i);
 365         }
 366
 367         slprintf(numbuf, sizeof(numbuf), "%d", baud_rate);
 368         script_setenv("SPEED", numbuf, 0);
 369
 370         /* run welcome script, if any */
 371         if (welcomer && welcomer[0]) {
 372                 if (device_script(welcomer, ttyfd, ttyfd, 0) < 0)
 373                         warn("Welcome script failed");
 374         }
 375
 376         return ttyfd;
 377 }
 378
 379
 380 void disconnect_tty()
 381 {
 382         if (disconnect_script == NULL || hungup)
 383                 return;
 384         if (real_ttyfd >= 0)
 385                 set_up_tty(real_ttyfd, 1);
 386         if (device_script(disconnect_script, ttyfd, ttyfd, 0) < 0) {
 387                 warn("disconnect script failed");
 388         } else {
 389                 info("Serial link disconnected.");
 390         }
 391 }
 392
 393 void tty_close_fds()
 394 {
 395         if (pty_master >= 0)
 396                 close(pty_master);
 397         if (pty_slave >= 0)
 398                 close(pty_slave);
 399         if (real_ttyfd >= 0) {
 400                 close(real_ttyfd);
 401                 real_ttyfd = -1;
 402         }
 403         /* N.B. ttyfd will == either pty_slave or real_ttyfd */
 404 }
 405
 406 void cleanup_tty()
 407 {
 408         if (real_ttyfd >= 0)
 409                 finish_tty();
 410         tty_close_fds();
 411         if (locked) {
 412                 unlock();
 413                 locked = 0;
 414         }
 415 }
 416
 417 /*
 418  * finish_tty - restore the terminal device to its original settings
 419  */
 420 static void
 421 finish_tty()
 422 {
 423         /* drop dtr to hang up */
 424         if (!default_device && modem) {
 425                 setdtr(real_ttyfd, 0);
 426                 /*
 427                  * This sleep is in case the serial port has CLOCAL set by default,
 428                  * and consequently will reassert DTR when we close the device.
 429                  */
 430                 sleep(1);
 431         }
 432
 433         restore_tty(real_ttyfd);
 434
 435         if (tty_mode != (mode_t) -1) {
 436                 if (fchmod(real_ttyfd, tty_mode) != 0) {
 437                         /* XXX if devnam is a symlink, this will change the link */
 438                         chmod(devnam, tty_mode);
 439                 }
 440         }
 441
 442         close(real_ttyfd);
 443         real_ttyfd = -1;
 444 }
 445
 446 /*
 447  * maybe_relock - our PID has changed, maybe update the lock file.
 448  */
 449 static void
 450 maybe_relock(arg, pid)
 451     void *arg;
 452     int pid;
 453 {
 454     if (locked)
 455         relock(pid);
 456 }
 457
 458 /*
 459  * open_socket - establish a stream socket connection to the nominated
 460  * host and port.
 461  */
 462 static int
 463 open_socket(dest)
 464     char *dest;
 465 {
 466     char *sep, *endp = NULL;
 467     int sock, port = -1;
 468     u_int32_t host;
 469     struct hostent *hent;
 470     struct sockaddr_in sad;
 471
 472     /* parse host:port and resolve host to an IP address */
 473     sep = strchr(dest, ':');
 474     if (sep != NULL)
 475         port = strtol(sep+1, &endp, 10);
 476     if (port < 0 || endp == sep+1 || sep == dest) {
 477         error("Can't parse host:port for socket destination");
 478         return -1;
 479     }
 480     *sep = 0;
 481     host = inet_addr(dest);
 482     if (host == (u_int32_t) -1) {
 483         hent = gethostbyname(dest);
 484         if (hent == NULL) {
 485             error("%s: unknown host in socket option", dest);
 486             *sep = ':';
 487             return -1;
 488         }
 489         host = *(u_int32_t *)(hent->h_addr_list[0]);
 490     }
 491     *sep = ':';
 492
 493     /* get a socket and connect it to the other end */
 494     sock = socket(PF_INET, SOCK_STREAM, 0);
 495     if (sock < 0) {
 496         error("Can't create socket: %m");
 497         return -1;
 498     }
 499     memset(&sad, 0, sizeof(sad));
 500     sad.sin_family = AF_INET;
 501     sad.sin_port = htons(port);
 502     sad.sin_addr.s_addr = host;
 503     if (connect(sock, (struct sockaddr *)&sad, sizeof(sad)) < 0) {
 504         error("Can't connect to %s: %m", dest);
 505         close(sock);
 506         return -1;
 507     }
 508
 509     return sock;
 510 }
 511
 512
 513 /*
 514  * start_charshunt - create a child process to run the character shunt.
 515  */
 516 static int
 517 start_charshunt(ifd, ofd)
 518     int ifd, ofd;
 519 {
 520     int cpid;
 521
 522     cpid = fork();
 523     if (cpid == -1) {
 524         error("Can't fork process for character shunt: %m");
 525         return 0;
 526     }
 527     if (cpid == 0) {
 528         /* child */
 529         close(pty_slave);
 530         setuid(uid);
 531         if (getuid() != uid)
 532             fatal("setuid failed");
 533         setgid(getgid());
 534         if (!nodetach)
 535             log_to_fd = -1;
 536         charshunt(ifd, ofd, record_file);
 537         exit(0);
 538     }
 539     charshunt_pid = cpid;
 540     add_notifier(&sigreceived, stop_charshunt, 0);
 541     close(pty_master);
 542     pty_master = -1;
 543     ttyfd = pty_slave;
 544     record_child(cpid, "pppd (charshunt)", charshunt_done, NULL);
 545     return 1;
 546 }
 547
 548 static void
 549 charshunt_done(arg)
 550     void *arg;
 551 {
 552         charshunt_pid = 0;
 553 }
 554
 555 static void
 556 stop_charshunt(arg, sig)
 557     void *arg;
 558     int sig;
 559 {
 560         if (charshunt_pid)
 561                 kill(charshunt_pid, (sig == SIGINT? sig: SIGTERM));
 562 }
 563
 564 /*
 565  * charshunt - the character shunt, which passes characters between
 566  * the pty master side and the serial port (or stdin/stdout).
 567  * This runs as the user (not as root).
 568  * (We assume ofd >= ifd which is true the way this gets called. :-).
 569  */
 570 static void
 571 charshunt(ifd, ofd, record_file)
 572     int ifd, ofd;
 573     char *record_file;
 574 {
 575     int n, nfds;
 576     fd_set ready, writey;
 577     u_char *ibufp, *obufp;
 578     int nibuf, nobuf;
 579     int flags;
 580     int pty_readable, stdin_readable;
 581     struct timeval lasttime;
 582     FILE *recordf = NULL;
 583     int ilevel, olevel, max_level;
 584     struct timeval levelt, tout, *top;
 585     extern u_char inpacket_buf[];
 586
 587     /*
 588      * Reset signal handlers.
 589      */
 590     signal(SIGHUP, SIG_IGN);            /* Hangup */
 591     signal(SIGINT, SIG_DFL);            /* Interrupt */
 592     signal(SIGTERM, SIG_DFL);           /* Terminate */
 593     signal(SIGCHLD, SIG_DFL);
 594     signal(SIGUSR1, SIG_DFL);
 595     signal(SIGUSR2, SIG_DFL);
 596     signal(SIGABRT, SIG_DFL);
 597     signal(SIGALRM, SIG_DFL);
 598     signal(SIGFPE, SIG_DFL);
 599     signal(SIGILL, SIG_DFL);
 600     signal(SIGPIPE, SIG_DFL);
 601     signal(SIGQUIT, SIG_DFL);
 602     signal(SIGSEGV, SIG_DFL);
 603 #ifdef SIGBUS
 604     signal(SIGBUS, SIG_DFL);
 605 #endif
 606 #ifdef SIGEMT
 607     signal(SIGEMT, SIG_DFL);
 608 #endif
 609 #ifdef SIGPOLL
 610     signal(SIGPOLL, SIG_DFL);
 611 #endif
 612 #ifdef SIGPROF
 613     signal(SIGPROF, SIG_DFL);
 614 #endif
 615 #ifdef SIGSYS
 616     signal(SIGSYS, SIG_DFL);
 617 #endif
 618 #ifdef SIGTRAP
 619     signal(SIGTRAP, SIG_DFL);
 620 #endif
 621 #ifdef SIGVTALRM
 622     signal(SIGVTALRM, SIG_DFL);
 623 #endif
 624 #ifdef SIGXCPU
 625     signal(SIGXCPU, SIG_DFL);
 626 #endif
 627 #ifdef SIGXFSZ
 628     signal(SIGXFSZ, SIG_DFL);
 629 #endif
 630
 631     /*
 632      * Open the record file if required.
 633      */
 634     if (record_file != NULL) {
 635         recordf = fopen(record_file, "a");
 636         if (recordf == NULL)
 637             error("Couldn't create record file %s: %m", record_file);
 638     }
 639
 640     /* set all the fds to non-blocking mode */
 641     flags = fcntl(pty_master, F_GETFL);
 642     if (flags == -1
 643         || fcntl(pty_master, F_SETFL, flags | O_NONBLOCK) == -1)
 644         warn("couldn't set pty master to nonblock: %m");
 645     flags = fcntl(ifd, F_GETFL);
 646     if (flags == -1
 647         || fcntl(ifd, F_SETFL, flags | O_NONBLOCK) == -1)
 648         warn("couldn't set %s to nonblock: %m", (ifd==0? "stdin": "tty"));
 649     if (ofd != ifd) {
 650         flags = fcntl(ofd, F_GETFL);
 651         if (flags == -1
 652             || fcntl(ofd, F_SETFL, flags | O_NONBLOCK) == -1)
 653             warn("couldn't set stdout to nonblock: %m");
 654     }
 655
 656     nibuf = nobuf = 0;
 657     ibufp = obufp = NULL;
 658     pty_readable = stdin_readable = 1;
 659
 660     ilevel = olevel = 0;
 661     gettimeofday(&levelt, NULL);
 662     if (max_data_rate) {
 663         max_level = max_data_rate / 10;
 664         if (max_level < 100)
 665             max_level = 100;
 666     } else
 667         max_level = PPP_MRU + PPP_HDRLEN + 1;
 668
 669     nfds = (ofd > pty_master? ofd: pty_master) + 1;
 670     if (recordf != NULL) {
 671         gettimeofday(&lasttime, NULL);
 672         putc(7, recordf);       /* put start marker */
 673         putc(lasttime.tv_sec >> 24, recordf);
 674         putc(lasttime.tv_sec >> 16, recordf);
 675         putc(lasttime.tv_sec >> 8, recordf);
 676         putc(lasttime.tv_sec, recordf);
 677         lasttime.tv_usec = 0;
 678     }
 679
 680     while (nibuf != 0 || nobuf != 0 || pty_readable || stdin_readable) {
 681         top = 0;
 682         tout.tv_sec = 0;
 683         tout.tv_usec = 10000;
 684         FD_ZERO(&ready);
 685         FD_ZERO(&writey);
 686         if (nibuf != 0) {
 687             if (ilevel >= max_level)
 688                 top = &tout;
 689             else
 690                 FD_SET(pty_master, &writey);
 691         } else if (stdin_readable)
 692             FD_SET(ifd, &ready);
 693         if (nobuf != 0) {
 694             if (olevel >= max_level)
 695                 top = &tout;
 696             else
 697                 FD_SET(ofd, &writey);
 698         } else if (pty_readable)
 699             FD_SET(pty_master, &ready);
 700         if (select(nfds, &ready, &writey, NULL, top) < 0) {
 701             if (errno != EINTR)
 702                 fatal("select");
 703             continue;
 704         }
 705         if (max_data_rate) {
 706             double dt;
 707             int nbt;
 708             struct timeval now;
 709
 710             gettimeofday(&now, NULL);
 711             dt = (now.tv_sec - levelt.tv_sec
 712                   + (now.tv_usec - levelt.tv_usec) / 1e6);
 713             nbt = (int)(dt * max_data_rate);
 714             ilevel = (nbt < 0 || nbt > ilevel)? 0: ilevel - nbt;
 715             olevel = (nbt < 0 || nbt > olevel)? 0: olevel - nbt;
 716             levelt = now;
 717         } else
 718             ilevel = olevel = 0;
 719         if (FD_ISSET(ifd, &ready)) {
 720             ibufp = inpacket_buf;
 721             nibuf = read(ifd, ibufp, PPP_MRU + PPP_HDRLEN);
 722             if (nibuf < 0 && errno == EIO)
 723                 nibuf = 0;
 724             if (nibuf < 0) {
 725                 if (!(errno == EINTR || errno == EAGAIN)) {
 726                     error("Error reading standard input: %m");
 727                     break;
 728                 }
 729                 nibuf = 0;
 730             } else if (nibuf == 0) {
 731                 /* end of file from stdin */
 732                 stdin_readable = 0;
 733                 /* do a 0-length write, hopefully this will generate
 734                    an EOF (hangup) on the slave side. */
 735                 write(pty_master, inpacket_buf, 0);
 736                 if (recordf)
 737                     if (!record_write(recordf, 4, NULL, 0, &lasttime))
 738                         recordf = NULL;
 739             } else {
 740                 FD_SET(pty_master, &writey);
 741                 if (recordf)
 742                     if (!record_write(recordf, 2, ibufp, nibuf, &lasttime))
 743                         recordf = NULL;
 744             }
 745         }
 746         if (FD_ISSET(pty_master, &ready)) {
 747             obufp = outpacket_buf;
 748             nobuf = read(pty_master, obufp, PPP_MRU + PPP_HDRLEN);
 749             if (nobuf < 0 && errno == EIO)
 750                 nobuf = 0;
 751             if (nobuf < 0) {
 752                 if (!(errno == EINTR || errno == EAGAIN)) {
 753                     error("Error reading pseudo-tty master: %m");
 754                     break;
 755                 }
 756                 nobuf = 0;
 757             } else if (nobuf == 0) {
 758                 /* end of file from the pty - slave side has closed */
 759                 pty_readable = 0;
 760                 stdin_readable = 0;     /* pty is not writable now */
 761                 nibuf = 0;
 762                 close(ofd);
 763                 if (recordf)
 764                     if (!record_write(recordf, 3, NULL, 0, &lasttime))
 765                         recordf = NULL;
 766             } else {
 767                 FD_SET(ofd, &writey);
 768                 if (recordf)
 769                     if (!record_write(recordf, 1, obufp, nobuf, &lasttime))
 770                         recordf = NULL;
 771             }
 772         }
 773         if (FD_ISSET(ofd, &writey)) {
 774             n = nobuf;
 775             if (olevel + n > max_level)
 776                 n = max_level - olevel;
 777             n = write(ofd, obufp, n);
 778             if (n < 0) {
 779                 if (errno == EIO) {
 780                     pty_readable = 0;
 781                     nobuf = 0;
 782                 } else if (errno != EAGAIN && errno != EINTR) {
 783                     error("Error writing standard output: %m");
 784                     break;
 785                 }
 786             } else {
 787                 obufp += n;
 788                 nobuf -= n;
 789                 olevel += n;
 790             }
 791         }
 792         if (FD_ISSET(pty_master, &writey)) {
 793             n = nibuf;
 794             if (ilevel + n > max_level)
 795                 n = max_level - ilevel;
 796             n = write(pty_master, ibufp, n);
 797             if (n < 0) {
 798                 if (errno == EIO) {
 799                     stdin_readable = 0;
 800                     nibuf = 0;
 801                 } else if (errno != EAGAIN && errno != EINTR) {
 802                     error("Error writing pseudo-tty master: %m");
 803                     break;
 804                 }
 805             } else {
 806                 ibufp += n;
 807                 nibuf -= n;
 808                 ilevel += n;
 809             }
 810         }
 811     }
 812     exit(0);
 813 }
 814
 815 static int
 816 record_write(f, code, buf, nb, tp)
 817     FILE *f;
 818     int code;
 819     u_char *buf;
 820     int nb;
 821     struct timeval *tp;
 822 {
 823     struct timeval now;
 824     int diff;
 825
 826     gettimeofday(&now, NULL);
 827     now.tv_usec /= 100000;      /* actually 1/10 s, not usec now */
 828     diff = (now.tv_sec - tp->tv_sec) * 10 + (now.tv_usec - tp->tv_usec);
 829     if (diff > 0) {
 830         if (diff > 255) {
 831             putc(5, f);
 832             putc(diff >> 24, f);
 833             putc(diff >> 16, f);
 834             putc(diff >> 8, f);
 835             putc(diff, f);
 836         } else {
 837             putc(6, f);
 838             putc(diff, f);
 839         }
 840         *tp = now;
 841     }
 842     putc(code, f);
 843     if (buf != NULL) {
 844         putc(nb >> 8, f);
 845         putc(nb, f);
 846         fwrite(buf, nb, 1, f);
 847     }
 848     fflush(f);
 849     if (ferror(f)) {
 850         error("Error writing record file: %m");
 851         return 0;
 852     }
 853     return 1;
 854 }