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