pppd/tty.c

   1 /*
   2  * tty.c - code for handling serial ports in pppd.
   3  *
   4  * Copyright (C) 2000-2002 Paul Mackerras. All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  *
  18  * 3. The name(s) of the authors of this software must not be used to
  19  *    endorse or promote products derived from this software without
  20  *    prior written permission.
  21  *
  22  * 4. Redistributions of any form whatsoever must retain the following
  23  *    acknowledgment:
  24  *    "This product includes software developed by Paul Mackerras
  25  *     <paulus@samba.org>".
  26  *
  27  * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
  28  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  29  * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
  30  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  31  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
  32  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
  33  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  34  *
  35  * Portions derived from main.c, which is:
  36  *
  37  * Copyright (c) 1984-2000 Carnegie Mellon University. All rights reserved.
  38  *
  39  * Redistribution and use in source and binary forms, with or without
  40  * modification, are permitted provided that the following conditions
  41  * are met:
  42  *
  43  * 1. Redistributions of source code must retain the above copyright
  44  *    notice, this list of conditions and the following disclaimer.
  45  *
  46  * 2. Redistributions in binary form must reproduce the above copyright
  47  *    notice, this list of conditions and the following disclaimer in
  48  *    the documentation and/or other materials provided with the
  49  *    distribution.
  50  *
  51  * 3. The name "Carnegie Mellon University" must not be used to
  52  *    endorse or promote products derived from this software without
  53  *    prior written permission. For permission or any legal
  54  *    details, please contact
  55  *      Office of Technology Transfer
  56  *      Carnegie Mellon University
  57  *      5000 Forbes Avenue
  58  *      Pittsburgh, PA  15213-3890
  59  *      (412) 268-4387, fax: (412) 268-7395
  60  *      tech-transfer@andrew.cmu.edu
  61  *
  62  * 4. Redistributions of any form whatsoever must retain the following
  63  *    acknowledgment:
  64  *    "This product includes software developed by Computing Services
  65  *     at Carnegie Mellon University (http://www.cmu.edu/computing/)."
  66  *
  67  * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
  68  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  69  * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
  70  * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  71  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
  72  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
  73  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  74  */
  75
  76 #define RCSID   "$Id: tty.c,v 1.14 2004/01/17 05:47:55 carlsonj Exp $"
  77
  78 #include <stdio.h>
  79 #include <ctype.h>
  80 #include <stdlib.h>
  81 #include <string.h>
  82 #include <unistd.h>
  83 #include <signal.h>
  84 #include <errno.h>
  85 #include <fcntl.h>
  86 #include <syslog.h>
  87 #include <netdb.h>
  88 #include <utmp.h>
  89 #include <pwd.h>
  90 #include <setjmp.h>
  91 #include <sys/param.h>
  92 #include <sys/types.h>
  93 #include <sys/wait.h>
  94 #include <sys/time.h>
  95 #include <sys/resource.h>
  96 #include <sys/stat.h>
  97 #include <sys/socket.h>
  98 #include <netinet/in.h>
  99 #include <arpa/inet.h>
 100
 101 #include "pppd.h"
 102 #include "fsm.h"
 103 #include "lcp.h"
 104
 105 void tty_process_extra_options __P((void));
 106 void tty_check_options __P((void));
 107 int  connect_tty __P((void));
 108 void disconnect_tty __P((void));
 109 void tty_close_fds __P((void));
 110 void cleanup_tty __P((void));
 111 void tty_do_send_config __P((int, u_int32_t, int, int));
 112
 113 static int setdevname __P((char *, char **, int));
 114 static int setspeed __P((char *, char **, int));
 115 static int setxonxoff __P((char **));
 116 static int setescape __P((char **));
 117 static void printescape __P((option_t *, void (*)(void *, char *,...),void *));
 118 static void finish_tty __P((void));
 119 static int start_charshunt __P((int, int));
 120 static void stop_charshunt __P((void *, int));
 121 static void charshunt_done __P((void *));
 122 static void charshunt __P((int, int, char *));
 123 static int record_write __P((FILE *, int code, u_char *buf, int nb,
 124                              struct timeval *));
 125 static int open_socket __P((char *));
 126 static void maybe_relock __P((void *, int));
 127
 128 static int pty_master;          /* fd for master side of pty */
 129 static int pty_slave;           /* fd for slave side of pty */
 130 static int real_ttyfd;          /* fd for actual serial port (not pty) */
 131 static int ttyfd;               /* Serial port file descriptor */
 132 static char speed_str[16];      /* Serial port speed as string */
 133
 134 mode_t tty_mode = (mode_t)-1;   /* Original access permissions to tty */
 135 int baud_rate;                  /* Actual bits/second for serial device */
 136 char *callback_script;          /* script for doing callback */
 137 int charshunt_pid;              /* Process ID for charshunt */
 138 int locked;                     /* lock() has succeeded */
 139 struct stat devstat;            /* result of stat() on devnam */
 140
 141 /* option variables */
 142 int     crtscts = 0;            /* Use hardware flow control */
 143 bool    modem = 1;              /* Use modem control lines */
 144 int     inspeed = 0;            /* Input/Output speed requested */
 145 bool    lockflag = 0;           /* Create lock file to lock the serial dev */
 146 char    *initializer = NULL;    /* Script to initialize physical link */
 147 char    *connect_script = NULL; /* Script to establish physical link */
 148 char    *disconnect_script = NULL; /* Script to disestablish physical link */
 149 char    *welcomer = NULL;       /* Script to run after phys link estab. */
 150 char    *ptycommand = NULL;     /* Command to run on other side of pty */
 151 bool    notty = 0;              /* Stdin/out is not a tty */
 152 char    *record_file = NULL;    /* File to record chars sent/received */
 153 int     max_data_rate;          /* max bytes/sec through charshunt */
 154 bool    sync_serial = 0;        /* Device is synchronous serial device */
 155 char    *pty_socket = NULL;     /* Socket to connect to pty */
 156 int     using_pty = 0;          /* we're allocating a pty as the device */
 157
 158 extern uid_t uid;
 159 extern int kill_link;
 160
 161 /* XXX */
 162 extern int privopen;            /* don't lock, open device as root */
 163
 164 u_int32_t xmit_accm[8];         /* extended transmit ACCM */
 165
 166 /* option descriptors */
 167 option_t tty_options[] = {
 168     /* device name must be first, or change connect_tty() below! */
 169     { "device name", o_wild, (void *) &setdevname,
 170       "Serial port device name",
 171       OPT_DEVNAM | OPT_PRIVFIX | OPT_NOARG  | OPT_A2STRVAL | OPT_STATIC,
 172       devnam},
 173
 174     { "tty speed", o_wild, (void *) &setspeed,
 175       "Baud rate for serial port",
 176       OPT_PRIO | OPT_NOARG | OPT_A2STRVAL | OPT_STATIC, speed_str },
 177
 178     { "lock", o_bool, &lockflag,
 179       "Lock serial device with UUCP-style lock file", OPT_PRIO | 1 },
 180     { "nolock", o_bool, &lockflag,
 181       "Don't lock serial device", OPT_PRIOSUB | OPT_PRIV },
 182
 183     { "init", o_string, &initializer,
 184       "A program to initialize the device", OPT_PRIO | OPT_PRIVFIX },
 185
 186     { "connect", o_string, &connect_script,
 187       "A program to set up a connection", OPT_PRIO | OPT_PRIVFIX },
 188
 189     { "disconnect", o_string, &disconnect_script,
 190       "Program to disconnect serial device", OPT_PRIO | OPT_PRIVFIX },
 191
 192     { "welcome", o_string, &welcomer,
 193       "Script to welcome client", OPT_PRIO | OPT_PRIVFIX },
 194
 195     { "pty", o_string, &ptycommand,
 196       "Script to run on pseudo-tty master side",
 197       OPT_PRIO | OPT_PRIVFIX | OPT_DEVNAM },
 198
 199     { "notty", o_bool, &notty,
 200       "Input/output is not a tty", OPT_DEVNAM | 1 },
 201
 202     { "socket", o_string, &pty_socket,
 203       "Send and receive over socket, arg is host:port",
 204       OPT_PRIO | OPT_DEVNAM },
 205
 206     { "record", o_string, &record_file,
 207       "Record characters sent/received to file", OPT_PRIO },
 208
 209     { "crtscts", o_int, &crtscts,
 210       "Set hardware (RTS/CTS) flow control",
 211       OPT_PRIO | OPT_NOARG | OPT_VAL(1) },
 212     { "cdtrcts", o_int, &crtscts,
 213       "Set alternate hardware (DTR/CTS) flow control",
 214       OPT_PRIOSUB | OPT_NOARG | OPT_VAL(2) },
 215     { "nocrtscts", o_int, &crtscts,
 216       "Disable hardware flow control",
 217       OPT_PRIOSUB | OPT_NOARG | OPT_VAL(-1) },
 218     { "-crtscts", o_int, &crtscts,
 219       "Disable hardware flow control",
 220       OPT_PRIOSUB | OPT_ALIAS | OPT_NOARG | OPT_VAL(-1) },
 221     { "nocdtrcts", o_int, &crtscts,
 222       "Disable hardware flow control",
 223       OPT_PRIOSUB | OPT_ALIAS | OPT_NOARG | OPT_VAL(-1) },
 224     { "xonxoff", o_special_noarg, (void *)setxonxoff,
 225       "Set software (XON/XOFF) flow control", OPT_PRIOSUB },
 226
 227     { "modem", o_bool, &modem,
 228       "Use modem control lines", OPT_PRIO | 1 },
 229     { "local", o_bool, &modem,
 230       "Don't use modem control lines", OPT_PRIOSUB | 0 },
 231
 232     { "sync", o_bool, &sync_serial,
 233       "Use synchronous HDLC serial encoding", 1 },
 234
 235     { "datarate", o_int, &max_data_rate,
 236       "Maximum data rate in bytes/sec (with pty, notty or record option)",
 237       OPT_PRIO },
 238
 239     { "escape", o_special, (void *)setescape,
 240       "List of character codes to escape on transmission",
 241       OPT_A2PRINTER, (void *)printescape },
 242
 243     { NULL }
 244 };
 245
 246
 247 struct channel tty_channel = {
 248         tty_options,
 249         &tty_process_extra_options,
 250         &tty_check_options,
 251         &connect_tty,
 252         &disconnect_tty,
 253         &tty_establish_ppp,
 254         &tty_disestablish_ppp,
 255         &tty_do_send_config,
 256         &tty_recv_config,
 257         &cleanup_tty,
 258         &tty_close_fds
 259 };
 260
 261 /*
 262  * setspeed - Set the serial port baud rate.
 263  * If doit is 0, the call is to check whether this option is
 264  * potentially a speed value.
 265  */
 266 static int
 267 setspeed(arg, argv, doit)
 268     char *arg;
 269     char **argv;
 270     int doit;
 271 {
 272         char *ptr;
 273         int spd;
 274
 275         spd = strtol(arg, &ptr, 0);
 276         if (ptr == arg || *ptr != 0 || spd == 0)
 277                 return 0;
 278         if (doit) {
 279                 inspeed = spd;
 280                 slprintf(speed_str, sizeof(speed_str), "%d", spd);
 281         }
 282         return 1;
 283 }
 284
 285
 286 /*
 287  * setdevname - Set the device name.
 288  * If doit is 0, the call is to check whether this option is
 289  * potentially a device name.
 290  */
 291 static int
 292 setdevname(cp, argv, doit)
 293     char *cp;
 294     char **argv;
 295     int doit;
 296 {
 297         struct stat statbuf;
 298         char dev[MAXPATHLEN];
 299
 300         if (*cp == 0)
 301                 return 0;
 302
 303         if (strncmp("/dev/", cp, 5) != 0) {
 304                 strlcpy(dev, "/dev/", sizeof(dev));
 305                 strlcat(dev, cp, sizeof(dev));
 306                 cp = dev;
 307         }
 308
 309         /*
 310          * Check if there is a character device by this name.
 311          */
 312         if (stat(cp, &statbuf) < 0) {
 313                 if (!doit)
 314                         return errno != ENOENT;
 315                 option_error("Couldn't stat %s: %m", cp);
 316                 return 0;
 317         }
 318         if (!S_ISCHR(statbuf.st_mode)) {
 319                 if (doit)
 320                         option_error("%s is not a character device", cp);
 321                 return 0;
 322         }
 323
 324         if (doit) {
 325                 strlcpy(devnam, cp, sizeof(devnam));
 326                 devstat = statbuf;
 327                 default_device = 0;
 328         }
 329
 330         return 1;
 331 }
 332
 333 static int
 334 setxonxoff(argv)
 335     char **argv;
 336 {
 337         lcp_wantoptions[0].asyncmap |= 0x000A0000;      /* escape ^S and ^Q */
 338         lcp_wantoptions[0].neg_asyncmap = 1;
 339
 340         crtscts = -2;
 341         return 1;
 342 }
 343
 344 /*
 345  * setescape - add chars to the set we escape on transmission.
 346  */
 347 static int
 348 setescape(argv)
 349     char **argv;
 350 {
 351     int n, ret;
 352     char *p, *endp;
 353
 354     p = *argv;
 355     ret = 1;
 356     while (*p) {
 357         n = strtol(p, &endp, 16);
 358         if (p == endp) {
 359             option_error("escape parameter contains invalid hex number '%s'",
 360                          p);
 361             return 0;
 362         }
 363         p = endp;
 364         if (n < 0 || n == 0x5E || n > 0xFF) {
 365             option_error("can't escape character 0x%x", n);
 366             ret = 0;
 367         } else
 368             xmit_accm[n >> 5] |= 1 << (n & 0x1F);
 369         while (*p == ',' || *p == ' ')
 370             ++p;
 371     }
 372     lcp_allowoptions[0].asyncmap = xmit_accm[0];
 373     return ret;
 374 }
 375
 376 static void
 377 printescape(opt, printer, arg)
 378     option_t *opt;
 379     void (*printer) __P((void *, char *, ...));
 380     void *arg;
 381 {
 382         int n;
 383         int first = 1;
 384
 385         for (n = 0; n < 256; ++n) {
 386                 if (n == 0x7d)
 387                         n += 2;         /* skip 7d, 7e */
 388                 if (xmit_accm[n >> 5] & (1 << (n & 0x1f))) {
 389                         if (!first)
 390                                 printer(arg, ",");
 391                         else
 392                                 first = 0;
 393                         printer(arg, "%x", n);
 394                 }
 395         }
 396         if (first)
 397                 printer(arg, "oops # nothing escaped");
 398 }
 399
 400 /*
 401  * tty_init - do various tty-related initializations.
 402  */
 403 void tty_init()
 404 {
 405     add_notifier(&pidchange, maybe_relock, 0);
 406     the_channel = &tty_channel;
 407     xmit_accm[3] = 0x60000000;
 408 }
 409
 410 /*
 411  * tty_process_extra_options - work out which tty device we are using
 412  * and read its options file.
 413  */
 414 void tty_process_extra_options()
 415 {
 416         using_pty = notty || ptycommand != NULL || pty_socket != NULL;
 417         if (using_pty)
 418                 return;
 419         if (default_device) {
 420                 char *p;
 421                 if (!isatty(0) || (p = ttyname(0)) == NULL) {
 422                         option_error("no device specified and stdin is not a tty");
 423                         exit(EXIT_OPTION_ERROR);
 424                 }
 425                 strlcpy(devnam, p, sizeof(devnam));
 426                 if (stat(devnam, &devstat) < 0)
 427                         fatal("Couldn't stat default device %s: %m", devnam);
 428         }
 429
 430
 431         /*
 432          * Parse the tty options file.
 433          * The per-tty options file should not change
 434          * ptycommand, pty_socket, notty or devnam.
 435          * options_for_tty doesn't override options set on the command line,
 436          * except for some privileged options.
 437          */
 438         if (!options_for_tty())
 439                 exit(EXIT_OPTION_ERROR);
 440 }
 441
 442 /*
 443  * tty_check_options - do consistency checks on the options we were given.
 444  */
 445 void
 446 tty_check_options()
 447 {
 448         struct stat statbuf;
 449         int fdflags;
 450
 451         if (demand && connect_script == 0) {
 452                 option_error("connect script is required for demand-dialling\n");
 453                 exit(EXIT_OPTION_ERROR);
 454         }
 455         /* default holdoff to 0 if no connect script has been given */
 456         if (connect_script == 0 && !holdoff_specified)
 457                 holdoff = 0;
 458
 459         if (using_pty) {
 460                 if (!default_device) {
 461                         option_error("%s option precludes specifying device name",
 462                                      notty? "notty": "pty");
 463                         exit(EXIT_OPTION_ERROR);
 464                 }
 465                 if (ptycommand != NULL && notty) {
 466                         option_error("pty option is incompatible with notty option");
 467                         exit(EXIT_OPTION_ERROR);
 468                 }
 469                 if (pty_socket != NULL && (ptycommand != NULL || notty)) {
 470                         option_error("socket option is incompatible with pty and notty");
 471                         exit(EXIT_OPTION_ERROR);
 472                 }
 473                 default_device = notty;
 474                 lockflag = 0;
 475                 modem = 0;
 476                 if (notty && log_to_fd <= 1)
 477                         log_to_fd = -1;
 478         } else {
 479                 /*
 480                  * If the user has specified a device which is the same as
 481                  * the one on stdin, pretend they didn't specify any.
 482                  * If the device is already open read/write on stdin,
 483                  * we assume we don't need to lock it, and we can open it
 484                  * as root.
 485                  */
 486                 if (fstat(0, &statbuf) >= 0 && S_ISCHR(statbuf.st_mode)
 487                     && statbuf.st_rdev == devstat.st_rdev) {
 488                         default_device = 1;
 489                         fdflags = fcntl(0, F_GETFL);
 490                         if (fdflags != -1 && (fdflags & O_ACCMODE) == O_RDWR)
 491                                 privopen = 1;
 492                 }
 493         }
 494         if (default_device)
 495                 nodetach = 1;
 496
 497         /*
 498          * Don't send log messages to the serial port, it tends to
 499          * confuse the peer. :-)
 500          */
 501         if (log_to_fd >= 0 && fstat(log_to_fd, &statbuf) >= 0
 502             && S_ISCHR(statbuf.st_mode) && statbuf.st_rdev == devstat.st_rdev)
 503                 log_to_fd = -1;
 504 }
 505
 506 /*
 507  * connect_tty - get the serial port ready to start doing PPP.
 508  * That is, open the serial port, set its speed and mode, and run
 509  * the connector and/or welcomer.
 510  */
 511 int connect_tty()
 512 {
 513         char *connector;
 514         int fdflags;
 515 #ifndef __linux__
 516         struct stat statbuf;
 517 #endif
 518         char numbuf[16];
 519
 520         /*
 521          * Get a pty master/slave pair if the pty, notty, socket,
 522          * or record options were specified.
 523          */
 524         strlcpy(ppp_devnam, devnam, sizeof(ppp_devnam));
 525         pty_master = -1;
 526         pty_slave = -1;
 527         real_ttyfd = -1;
 528         if (using_pty || record_file != NULL) {
 529                 if (!get_pty(&pty_master, &pty_slave, ppp_devnam, uid)) {
 530                         error("Couldn't allocate pseudo-tty");
 531                         status = EXIT_FATAL_ERROR;
 532                         return -1;
 533                 }
 534                 set_up_tty(pty_slave, 1);
 535         }
 536
 537         /*
 538          * Lock the device if we've been asked to.
 539          */
 540         status = EXIT_LOCK_FAILED;
 541         if (lockflag && !privopen) {
 542                 if (lock(devnam) < 0)
 543                         return -1;
 544                 locked = 1;
 545         }
 546
 547         /*
 548          * Open the serial device and set it up to be the ppp interface.
 549          * First we open it in non-blocking mode so we can set the
 550          * various termios flags appropriately.  If we aren't dialling
 551          * out and we want to use the modem lines, we reopen it later
 552          * in order to wait for the carrier detect signal from the modem.
 553          */
 554         hungup = 0;
 555         kill_link = 0;
 556         connector = doing_callback? callback_script: connect_script;
 557         if (devnam[0] != 0) {
 558                 for (;;) {
 559                         /* If the user specified the device name, become the
 560                            user before opening it. */
 561                         int err, prio;
 562
 563                         prio = privopen? OPRIO_ROOT: tty_options[0].priority;
 564                         if (prio < OPRIO_ROOT)
 565                                 seteuid(uid);
 566                         ttyfd = open(devnam, O_NONBLOCK | O_RDWR, 0);
 567                         err = errno;
 568                         if (prio < OPRIO_ROOT)
 569                                 seteuid(0);
 570                         if (ttyfd >= 0)
 571                                 break;
 572                         errno = err;
 573                         if (err != EINTR) {
 574                                 error("Failed to open %s: %m", devnam);
 575                                 status = EXIT_OPEN_FAILED;
 576                         }
 577                         if (!persist || err != EINTR)
 578                                 return -1;
 579                 }
 580                 real_ttyfd = ttyfd;
 581                 if ((fdflags = fcntl(ttyfd, F_GETFL)) == -1
 582                     || fcntl(ttyfd, F_SETFL, fdflags & ~O_NONBLOCK) < 0)
 583                         warn("Couldn't reset non-blocking mode on device: %m");
 584
 585 #ifndef __linux__
 586                 /*
 587                  * Linux 2.4 and above blocks normal writes to the tty
 588                  * when it is in PPP line discipline, so this isn't needed.
 589                  */
 590                 /*
 591                  * Do the equivalent of `mesg n' to stop broadcast messages.
 592                  */
 593                 if (fstat(ttyfd, &statbuf) < 0
 594                     || fchmod(ttyfd, statbuf.st_mode & ~(S_IWGRP | S_IWOTH)) < 0) {
 595                         warn("Couldn't restrict write permissions to %s: %m", devnam);
 596                 } else
 597                         tty_mode = statbuf.st_mode;
 598 #endif /* __linux__ */
 599
 600                 /*
 601                  * Set line speed, flow control, etc.
 602                  * If we have a non-null connection or initializer script,
 603                  * on most systems we set CLOCAL for now so that we can talk
 604                  * to the modem before carrier comes up.  But this has the
 605                  * side effect that we might miss it if CD drops before we
 606                  * get to clear CLOCAL below.  On systems where we can talk
 607                  * successfully to the modem with CLOCAL clear and CD down,
 608                  * we could clear CLOCAL at this point.
 609                  */
 610                 set_up_tty(ttyfd, ((connector != NULL && connector[0] != 0)
 611                                    || initializer != NULL));
 612         }
 613
 614         /*
 615          * If the pty, socket, notty and/or record option was specified,
 616          * start up the character shunt now.
 617          */
 618         status = EXIT_PTYCMD_FAILED;
 619         if (ptycommand != NULL) {
 620                 if (record_file != NULL) {
 621                         int ipipe[2], opipe[2], ok;
 622
 623                         if (pipe(ipipe) < 0 || pipe(opipe) < 0)
 624                                 fatal("Couldn't create pipes for record option: %m");
 625
 626                         /* don't leak these to the ptycommand */
 627                         (void) fcntl(ipipe[0], F_SETFD, FD_CLOEXEC);
 628                         (void) fcntl(opipe[1], F_SETFD, FD_CLOEXEC);
 629
 630                         ok = device_script(ptycommand, opipe[0], ipipe[1], 1) == 0
 631                                 && start_charshunt(ipipe[0], opipe[1]);
 632                         close(ipipe[0]);
 633                         close(ipipe[1]);
 634                         close(opipe[0]);
 635                         close(opipe[1]);
 636                         if (!ok)
 637                                 return -1;
 638                 } else {
 639                         if (device_script(ptycommand, pty_master, pty_master, 1) < 0)
 640                                 return -1;
 641                         ttyfd = pty_slave;
 642                         close(pty_master);
 643                         pty_master = -1;
 644                 }
 645         } else if (pty_socket != NULL) {
 646                 int fd = open_socket(pty_socket);
 647                 if (fd < 0)
 648                         return -1;
 649                 if (!start_charshunt(fd, fd))
 650                         return -1;
 651         } else if (notty) {
 652                 if (!start_charshunt(0, 1))
 653                         return -1;
 654         } else if (record_file != NULL) {
 655                 if (!start_charshunt(ttyfd, ttyfd))
 656                         return -1;
 657         }
 658
 659         /* run connection script */
 660         if ((connector && connector[0]) || initializer) {
 661                 if (real_ttyfd != -1) {
 662                         /* XXX do this if doing_callback == CALLBACK_DIALIN? */
 663                         if (!default_device && modem) {
 664                                 setdtr(real_ttyfd, 0);  /* in case modem is off hook */
 665                                 sleep(1);
 666                                 setdtr(real_ttyfd, 1);
 667                         }
 668                 }
 669
 670                 if (initializer && initializer[0]) {
 671                         if (device_script(initializer, ttyfd, ttyfd, 0) < 0) {
 672                                 error("Initializer script failed");
 673                                 status = EXIT_INIT_FAILED;
 674                                 return -1;
 675                         }
 676                         if (kill_link) {
 677                                 disconnect_tty();
 678                                 return -1;
 679                         }
 680                         info("Serial port initialized.");
 681                 }
 682
 683                 if (connector && connector[0]) {
 684                         if (device_script(connector, ttyfd, ttyfd, 0) < 0) {
 685                                 error("Connect script failed");
 686                                 status = EXIT_CONNECT_FAILED;
 687                                 return -1;
 688                         }
 689                         if (kill_link) {
 690                                 disconnect_tty();
 691                                 return -1;
 692                         }
 693                         info("Serial connection established.");
 694                 }
 695
 696                 /* set line speed, flow control, etc.;
 697                    clear CLOCAL if modem option */
 698                 if (real_ttyfd != -1)
 699                         set_up_tty(real_ttyfd, 0);
 700
 701                 if (doing_callback == CALLBACK_DIALIN)
 702                         connector = NULL;
 703         }
 704
 705         /* reopen tty if necessary to wait for carrier */
 706         if (connector == NULL && modem && devnam[0] != 0) {
 707                 int i;
 708                 for (;;) {
 709                         if ((i = open(devnam, O_RDWR)) >= 0)
 710                                 break;
 711                         if (errno != EINTR) {
 712                                 error("Failed to reopen %s: %m", devnam);
 713                                 status = EXIT_OPEN_FAILED;
 714                         }
 715                         if (!persist || errno != EINTR || hungup || kill_link)
 716                                 return -1;
 717                 }
 718                 close(i);
 719         }
 720
 721         slprintf(numbuf, sizeof(numbuf), "%d", baud_rate);
 722         script_setenv("SPEED", numbuf, 0);
 723
 724         /* run welcome script, if any */
 725         if (welcomer && welcomer[0]) {
 726                 if (device_script(welcomer, ttyfd, ttyfd, 0) < 0)
 727                         warn("Welcome script failed");
 728         }
 729
 730         /*
 731          * If we are initiating this connection, wait for a short
 732          * time for something from the peer.  This can avoid bouncing
 733          * our packets off his tty before he has it set up.
 734          */
 735         if (connector != NULL || ptycommand != NULL)
 736                 listen_time = connect_delay;
 737
 738         return ttyfd;
 739 }
 740
 741
 742 void disconnect_tty()
 743 {
 744         if (disconnect_script == NULL || hungup)
 745                 return;
 746         if (real_ttyfd >= 0)
 747                 set_up_tty(real_ttyfd, 1);
 748         if (device_script(disconnect_script, ttyfd, ttyfd, 0) < 0) {
 749                 warn("disconnect script failed");
 750         } else {
 751                 info("Serial link disconnected.");
 752         }
 753 }
 754
 755 void tty_close_fds()
 756 {
 757         if (pty_master >= 0)
 758                 close(pty_master);
 759         if (pty_slave >= 0)
 760                 close(pty_slave);
 761         if (real_ttyfd >= 0) {
 762                 close(real_ttyfd);
 763                 real_ttyfd = -1;
 764         }
 765         /* N.B. ttyfd will == either pty_slave or real_ttyfd */
 766 }
 767
 768 void cleanup_tty()
 769 {
 770         if (real_ttyfd >= 0)
 771                 finish_tty();
 772         tty_close_fds();
 773         if (locked) {
 774                 unlock();
 775                 locked = 0;
 776         }
 777 }
 778
 779 /*
 780  * tty_do_send_config - set transmit-side PPP configuration.
 781  * We set the extended transmit ACCM here as well.
 782  */
 783 void
 784 tty_do_send_config(mtu, accm, pcomp, accomp)
 785     int mtu;
 786     u_int32_t accm;
 787     int pcomp, accomp;
 788 {
 789         tty_set_xaccm(xmit_accm);
 790         tty_send_config(mtu, accm, pcomp, accomp);
 791 }
 792
 793 /*
 794  * finish_tty - restore the terminal device to its original settings
 795  */
 796 static void
 797 finish_tty()
 798 {
 799         /* drop dtr to hang up */
 800         if (!default_device && modem) {
 801                 setdtr(real_ttyfd, 0);
 802                 /*
 803                  * This sleep is in case the serial port has CLOCAL set by default,
 804                  * and consequently will reassert DTR when we close the device.
 805                  */
 806                 sleep(1);
 807         }
 808
 809         restore_tty(real_ttyfd);
 810
 811 #ifndef __linux__
 812         if (tty_mode != (mode_t) -1) {
 813                 if (fchmod(real_ttyfd, tty_mode) != 0) {
 814                         /* XXX if devnam is a symlink, this will change the link */
 815                         chmod(devnam, tty_mode);
 816                 }
 817         }
 818 #endif /* __linux__ */
 819
 820         close(real_ttyfd);
 821         real_ttyfd = -1;
 822 }
 823
 824 /*
 825  * maybe_relock - our PID has changed, maybe update the lock file.
 826  */
 827 static void
 828 maybe_relock(arg, pid)
 829     void *arg;
 830     int pid;
 831 {
 832     if (locked)
 833         relock(pid);
 834 }
 835
 836 /*
 837  * open_socket - establish a stream socket connection to the nominated
 838  * host and port.
 839  */
 840 static int
 841 open_socket(dest)
 842     char *dest;
 843 {
 844     char *sep, *endp = NULL;
 845     int sock, port = -1;
 846     u_int32_t host;
 847     struct hostent *hent;
 848     struct sockaddr_in sad;
 849
 850     /* parse host:port and resolve host to an IP address */
 851     sep = strchr(dest, ':');
 852     if (sep != NULL)
 853         port = strtol(sep+1, &endp, 10);
 854     if (port < 0 || endp == sep+1 || sep == dest) {
 855         error("Can't parse host:port for socket destination");
 856         return -1;
 857     }
 858     *sep = 0;
 859     host = inet_addr(dest);
 860     if (host == (u_int32_t) -1) {
 861         hent = gethostbyname(dest);
 862         if (hent == NULL) {
 863             error("%s: unknown host in socket option", dest);
 864             *sep = ':';
 865             return -1;
 866         }
 867         host = *(u_int32_t *)(hent->h_addr_list[0]);
 868     }
 869     *sep = ':';
 870
 871     /* get a socket and connect it to the other end */
 872     sock = socket(PF_INET, SOCK_STREAM, 0);
 873     if (sock < 0) {
 874         error("Can't create socket: %m");
 875         return -1;
 876     }
 877     memset(&sad, 0, sizeof(sad));
 878     sad.sin_family = AF_INET;
 879     sad.sin_port = htons(port);
 880     sad.sin_addr.s_addr = host;
 881     if (connect(sock, (struct sockaddr *)&sad, sizeof(sad)) < 0) {
 882         error("Can't connect to %s: %m", dest);
 883         close(sock);
 884         return -1;
 885     }
 886
 887     return sock;
 888 }
 889
 890
 891 /*
 892  * start_charshunt - create a child process to run the character shunt.
 893  */
 894 static int
 895 start_charshunt(ifd, ofd)
 896     int ifd, ofd;
 897 {
 898     int cpid;
 899
 900     cpid = safe_fork();
 901     if (cpid == -1) {
 902         error("Can't fork process for character shunt: %m");
 903         return 0;
 904     }
 905     if (cpid == 0) {
 906         /* child */
 907         close(pty_slave);
 908         setuid(uid);
 909         if (getuid() != uid)
 910             fatal("setuid failed");
 911         setgid(getgid());
 912         if (!nodetach)
 913             log_to_fd = -1;
 914         charshunt(ifd, ofd, record_file);
 915         exit(0);
 916     }
 917     charshunt_pid = cpid;
 918     add_notifier(&sigreceived, stop_charshunt, 0);
 919     close(pty_master);
 920     pty_master = -1;
 921     ttyfd = pty_slave;
 922     record_child(cpid, "pppd (charshunt)", charshunt_done, NULL);
 923     return 1;
 924 }
 925
 926 static void
 927 charshunt_done(arg)
 928     void *arg;
 929 {
 930         charshunt_pid = 0;
 931 }
 932
 933 static void
 934 stop_charshunt(arg, sig)
 935     void *arg;
 936     int sig;
 937 {
 938         if (charshunt_pid)
 939                 kill(charshunt_pid, (sig == SIGINT? sig: SIGTERM));
 940 }
 941
 942 /*
 943  * charshunt - the character shunt, which passes characters between
 944  * the pty master side and the serial port (or stdin/stdout).
 945  * This runs as the user (not as root).
 946  * (We assume ofd >= ifd which is true the way this gets called. :-).
 947  */
 948 static void
 949 charshunt(ifd, ofd, record_file)
 950     int ifd, ofd;
 951     char *record_file;
 952 {
 953     int n, nfds;
 954     fd_set ready, writey;
 955     u_char *ibufp, *obufp;
 956     int nibuf, nobuf;
 957     int flags;
 958     int pty_readable, stdin_readable;
 959     struct timeval lasttime;
 960     FILE *recordf = NULL;
 961     int ilevel, olevel, max_level;
 962     struct timeval levelt, tout, *top;
 963     extern u_char inpacket_buf[];
 964
 965     /*
 966      * Reset signal handlers.
 967      */
 968     signal(SIGHUP, SIG_IGN);            /* Hangup */
 969     signal(SIGINT, SIG_DFL);            /* Interrupt */
 970     signal(SIGTERM, SIG_DFL);           /* Terminate */
 971     signal(SIGCHLD, SIG_DFL);
 972     signal(SIGUSR1, SIG_DFL);
 973     signal(SIGUSR2, SIG_DFL);
 974     signal(SIGABRT, SIG_DFL);
 975     signal(SIGALRM, SIG_DFL);
 976     signal(SIGFPE, SIG_DFL);
 977     signal(SIGILL, SIG_DFL);
 978     signal(SIGPIPE, SIG_DFL);
 979     signal(SIGQUIT, SIG_DFL);
 980     signal(SIGSEGV, SIG_DFL);
 981 #ifdef SIGBUS
 982     signal(SIGBUS, SIG_DFL);
 983 #endif
 984 #ifdef SIGEMT
 985     signal(SIGEMT, SIG_DFL);
 986 #endif
 987 #ifdef SIGPOLL
 988     signal(SIGPOLL, SIG_DFL);
 989 #endif
 990 #ifdef SIGPROF
 991     signal(SIGPROF, SIG_DFL);
 992 #endif
 993 #ifdef SIGSYS
 994     signal(SIGSYS, SIG_DFL);
 995 #endif
 996 #ifdef SIGTRAP
 997     signal(SIGTRAP, SIG_DFL);
 998 #endif
 999 #ifdef SIGVTALRM
1000     signal(SIGVTALRM, SIG_DFL);
1001 #endif
1002 #ifdef SIGXCPU
1003     signal(SIGXCPU, SIG_DFL);
1004 #endif
1005 #ifdef SIGXFSZ
1006     signal(SIGXFSZ, SIG_DFL);
1007 #endif
1008
1009     /*
1010      * Check that the fds won't overrun the fd_sets
1011      */
1012     if (ifd >= FD_SETSIZE || ofd >= FD_SETSIZE || pty_master >= FD_SETSIZE)
1013         fatal("internal error: file descriptor too large (%d, %d, %d)",
1014               ifd, ofd, pty_master);
1015
1016     /*
1017      * Open the record file if required.
1018      */
1019     if (record_file != NULL) {
1020         recordf = fopen(record_file, "a");
1021         if (recordf == NULL)
1022             error("Couldn't create record file %s: %m", record_file);
1023     }
1024
1025     /* set all the fds to non-blocking mode */
1026     flags = fcntl(pty_master, F_GETFL);
1027     if (flags == -1
1028         || fcntl(pty_master, F_SETFL, flags | O_NONBLOCK) == -1)
1029         warn("couldn't set pty master to nonblock: %m");
1030     flags = fcntl(ifd, F_GETFL);
1031     if (flags == -1
1032         || fcntl(ifd, F_SETFL, flags | O_NONBLOCK) == -1)
1033         warn("couldn't set %s to nonblock: %m", (ifd==0? "stdin": "tty"));
1034     if (ofd != ifd) {
1035         flags = fcntl(ofd, F_GETFL);
1036         if (flags == -1
1037             || fcntl(ofd, F_SETFL, flags | O_NONBLOCK) == -1)
1038             warn("couldn't set stdout to nonblock: %m");
1039     }
1040
1041     nibuf = nobuf = 0;
1042     ibufp = obufp = NULL;
1043     pty_readable = stdin_readable = 1;
1044
1045     ilevel = olevel = 0;
1046     gettimeofday(&levelt, NULL);
1047     if (max_data_rate) {
1048         max_level = max_data_rate / 10;
1049         if (max_level < 100)
1050             max_level = 100;
1051     } else
1052         max_level = PPP_MRU + PPP_HDRLEN + 1;
1053
1054     nfds = (ofd > pty_master? ofd: pty_master) + 1;
1055     if (recordf != NULL) {
1056         gettimeofday(&lasttime, NULL);
1057         putc(7, recordf);       /* put start marker */
1058         putc(lasttime.tv_sec >> 24, recordf);
1059         putc(lasttime.tv_sec >> 16, recordf);
1060         putc(lasttime.tv_sec >> 8, recordf);
1061         putc(lasttime.tv_sec, recordf);
1062         lasttime.tv_usec = 0;
1063     }
1064
1065     while (nibuf != 0 || nobuf != 0 || pty_readable || stdin_readable) {
1066         top = 0;
1067         tout.tv_sec = 0;
1068         tout.tv_usec = 10000;
1069         FD_ZERO(&ready);
1070         FD_ZERO(&writey);
1071         if (nibuf != 0) {
1072             if (ilevel >= max_level)
1073                 top = &tout;
1074             else
1075                 FD_SET(pty_master, &writey);
1076         } else if (stdin_readable)
1077             FD_SET(ifd, &ready);
1078         if (nobuf != 0) {
1079             if (olevel >= max_level)
1080                 top = &tout;
1081             else
1082                 FD_SET(ofd, &writey);
1083         } else if (pty_readable)
1084             FD_SET(pty_master, &ready);
1085         if (select(nfds, &ready, &writey, NULL, top) < 0) {
1086             if (errno != EINTR)
1087                 fatal("select");
1088             continue;
1089         }
1090         if (max_data_rate) {
1091             double dt;
1092             int nbt;
1093             struct timeval now;
1094
1095             gettimeofday(&now, NULL);
1096             dt = (now.tv_sec - levelt.tv_sec
1097                   + (now.tv_usec - levelt.tv_usec) / 1e6);
1098             nbt = (int)(dt * max_data_rate);
1099             ilevel = (nbt < 0 || nbt > ilevel)? 0: ilevel - nbt;
1100             olevel = (nbt < 0 || nbt > olevel)? 0: olevel - nbt;
1101             levelt = now;
1102         } else
1103             ilevel = olevel = 0;
1104         if (FD_ISSET(ifd, &ready)) {
1105             ibufp = inpacket_buf;
1106             nibuf = read(ifd, ibufp, PPP_MRU + PPP_HDRLEN);
1107             if (nibuf < 0 && errno == EIO)
1108                 nibuf = 0;
1109             if (nibuf < 0) {
1110                 if (!(errno == EINTR || errno == EAGAIN)) {
1111                     error("Error reading standard input: %m");
1112                     break;
1113                 }
1114                 nibuf = 0;
1115             } else if (nibuf == 0) {
1116                 /* end of file from stdin */
1117                 stdin_readable = 0;
1118                 /* do a 0-length write, hopefully this will generate
1119                    an EOF (hangup) on the slave side. */
1120                 write(pty_master, inpacket_buf, 0);
1121                 if (recordf)
1122                     if (!record_write(recordf, 4, NULL, 0, &lasttime))
1123                         recordf = NULL;
1124             } else {
1125                 FD_SET(pty_master, &writey);
1126                 if (recordf)
1127                     if (!record_write(recordf, 2, ibufp, nibuf, &lasttime))
1128                         recordf = NULL;
1129             }
1130         }
1131         if (FD_ISSET(pty_master, &ready)) {
1132             obufp = outpacket_buf;
1133             nobuf = read(pty_master, obufp, PPP_MRU + PPP_HDRLEN);
1134             if (nobuf < 0 && errno == EIO)
1135                 nobuf = 0;
1136             if (nobuf < 0) {
1137                 if (!(errno == EINTR || errno == EAGAIN)) {
1138                     error("Error reading pseudo-tty master: %m");
1139                     break;
1140                 }
1141                 nobuf = 0;
1142             } else if (nobuf == 0) {
1143                 /* end of file from the pty - slave side has closed */
1144                 pty_readable = 0;
1145                 stdin_readable = 0;     /* pty is not writable now */
1146                 nibuf = 0;
1147                 close(ofd);
1148                 if (recordf)
1149                     if (!record_write(recordf, 3, NULL, 0, &lasttime))
1150                         recordf = NULL;
1151             } else {
1152                 FD_SET(ofd, &writey);
1153                 if (recordf)
1154                     if (!record_write(recordf, 1, obufp, nobuf, &lasttime))
1155                         recordf = NULL;
1156             }
1157         }
1158         if (FD_ISSET(ofd, &writey)) {
1159             n = nobuf;
1160             if (olevel + n > max_level)
1161                 n = max_level - olevel;
1162             n = write(ofd, obufp, n);
1163             if (n < 0) {
1164                 if (errno == EIO) {
1165                     pty_readable = 0;
1166                     nobuf = 0;
1167                 } else if (errno != EAGAIN && errno != EINTR) {
1168                     error("Error writing standard output: %m");
1169                     break;
1170                 }
1171             } else {
1172                 obufp += n;
1173                 nobuf -= n;
1174                 olevel += n;
1175             }
1176         }
1177         if (FD_ISSET(pty_master, &writey)) {
1178             n = nibuf;
1179             if (ilevel + n > max_level)
1180                 n = max_level - ilevel;
1181             n = write(pty_master, ibufp, n);
1182             if (n < 0) {
1183                 if (errno == EIO) {
1184                     stdin_readable = 0;
1185                     nibuf = 0;
1186                 } else if (errno != EAGAIN && errno != EINTR) {
1187                     error("Error writing pseudo-tty master: %m");
1188                     break;
1189                 }
1190             } else {
1191                 ibufp += n;
1192                 nibuf -= n;
1193                 ilevel += n;
1194             }
1195         }
1196     }
1197     exit(0);
1198 }
1199
1200 static int
1201 record_write(f, code, buf, nb, tp)
1202     FILE *f;
1203     int code;
1204     u_char *buf;
1205     int nb;
1206     struct timeval *tp;
1207 {
1208     struct timeval now;
1209     int diff;
1210
1211     gettimeofday(&now, NULL);
1212     now.tv_usec /= 100000;      /* actually 1/10 s, not usec now */
1213     diff = (now.tv_sec - tp->tv_sec) * 10 + (now.tv_usec - tp->tv_usec);
1214     if (diff > 0) {
1215         if (diff > 255) {
1216             putc(5, f);
1217             putc(diff >> 24, f);
1218             putc(diff >> 16, f);
1219             putc(diff >> 8, f);
1220             putc(diff, f);
1221         } else {
1222             putc(6, f);
1223             putc(diff, f);
1224         }
1225         *tp = now;
1226     }
1227     putc(code, f);
1228     if (buf != NULL) {
1229         putc(nb >> 8, f);
1230         putc(nb, f);
1231         fwrite(buf, nb, 1, f);
1232     }
1233     fflush(f);
1234     if (ferror(f)) {
1235         error("Error writing record file: %m");
1236         return 0;
1237     }
1238     return 1;
1239 }