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