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