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