pppd/tty.c

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