2 * tty.c - code for handling serial ports in pppd.
4 * Copyright (C) 2000-2004 Paul Mackerras. All rights reserved.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
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.
17 * 3. Redistributions of any form whatsoever must retain the following
19 * "This product includes software developed by Paul Mackerras
20 * <paulus@samba.org>".
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.
30 * Portions derived from main.c, which is:
32 * Copyright (c) 1984-2000 Carnegie Mellon University. All rights reserved.
34 * Redistribution and use in source and binary forms, with or without
35 * modification, are permitted provided that the following conditions
38 * 1. Redistributions of source code must retain the above copyright
39 * notice, this list of conditions and the following disclaimer.
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
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
53 * Pittsburgh, PA 15213-3890
54 * (412) 268-4387, fax: (412) 268-7395
55 * tech-transfer@andrew.cmu.edu
57 * 4. Redistributions of any form whatsoever must retain the following
59 * "This product includes software developed by Computing Services
60 * at Carnegie Mellon University (http://www.cmu.edu/computing/)."
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.
88 #include <sys/param.h>
89 #include <sys/types.h>
92 #include <sys/resource.h>
94 #include <sys/socket.h>
95 #include <netinet/in.h>
96 #include <arpa/inet.h>
102 void tty_process_extra_options(void);
103 void tty_check_options(void);
104 int connect_tty(void);
105 void disconnect_tty(void);
106 void tty_close_fds(void);
107 void cleanup_tty(void);
108 void tty_do_send_config(int, u_int32_t, int, int);
110 static int setdevname(char *, char **, int);
111 static int setspeed(char *, char **, int);
112 static int setxonxoff(char **);
113 static int setescape(char **);
114 static void printescape(option_t *, void (*)(void *, char *,...),void *);
115 static void finish_tty(void);
116 static int start_charshunt(int, int);
117 static void stop_charshunt(void *, int);
118 static void charshunt_done(void *);
119 static void charshunt(int, int, char *);
120 static int record_write(FILE *, int code, u_char *buf, int nb,
122 static int open_socket(char *);
123 static void maybe_relock(void *, int);
125 static int pty_master; /* fd for master side of pty */
126 static int pty_slave; /* fd for slave side of pty */
127 static int real_ttyfd; /* fd for actual serial port (not pty) */
128 static int ttyfd; /* Serial port file descriptor */
129 static char speed_str[16]; /* Serial port speed as string */
131 mode_t tty_mode = (mode_t)-1; /* Original access permissions to tty */
132 int baud_rate; /* Actual bits/second for serial device */
133 char *callback_script; /* script for doing callback */
134 int charshunt_pid; /* Process ID for charshunt */
135 int locked; /* lock() has succeeded */
136 struct stat devstat; /* result of stat() on devnam */
138 /* option variables */
139 int crtscts = 0; /* Use hardware flow control */
140 int stop_bits = 1; /* Number of serial port stop bits */
141 bool modem = 1; /* Use modem control lines */
142 int inspeed = 0; /* Input/Output speed requested */
143 bool lockflag = 0; /* Create lock file to lock the serial dev */
144 char *initializer = NULL; /* Script to initialize physical link */
145 char *connect_script = NULL; /* Script to establish physical link */
146 char *disconnect_script = NULL; /* Script to disestablish physical link */
147 char *welcomer = NULL; /* Script to run after phys link estab. */
148 char *ptycommand = NULL; /* Command to run on other side of pty */
149 bool notty = 0; /* Stdin/out is not a tty */
150 char *record_file = NULL; /* File to record chars sent/received */
151 int max_data_rate; /* max bytes/sec through charshunt */
152 bool sync_serial = 0; /* Device is synchronous serial device */
153 char *pty_socket = NULL; /* Socket to connect to pty */
154 int using_pty = 0; /* we're allocating a pty as the device */
157 extern int kill_link;
158 extern int asked_to_quit;
159 extern int got_sigterm;
162 extern int privopen; /* don't lock, open device as root */
164 u_int32_t xmit_accm[8]; /* extended transmit ACCM */
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,
174 { "tty speed", o_wild, (void *) &setspeed,
175 "Baud rate for serial port",
176 OPT_PRIO | OPT_NOARG | OPT_A2STRVAL | OPT_STATIC, speed_str },
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 },
183 { "init", o_string, &initializer,
184 "A program to initialize the device", OPT_PRIO | OPT_PRIVFIX },
186 { "connect", o_string, &connect_script,
187 "A program to set up a connection", OPT_PRIO | OPT_PRIVFIX },
189 { "disconnect", o_string, &disconnect_script,
190 "Program to disconnect serial device", OPT_PRIO | OPT_PRIVFIX },
192 { "welcome", o_string, &welcomer,
193 "Script to welcome client", OPT_PRIO | OPT_PRIVFIX },
195 { "pty", o_string, &ptycommand,
196 "Script to run on pseudo-tty master side",
197 OPT_PRIO | OPT_PRIVFIX | OPT_DEVNAM },
199 { "notty", o_bool, ¬ty,
200 "Input/output is not a tty", OPT_DEVNAM | 1 },
202 { "socket", o_string, &pty_socket,
203 "Send and receive over socket, arg is host:port",
204 OPT_PRIO | OPT_DEVNAM },
206 { "record", o_string, &record_file,
207 "Record characters sent/received to file", OPT_PRIO },
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 { "stop-bits", o_int, &stop_bits,
227 "Number of stop bits in serial port",
228 OPT_PRIO | OPT_PRIVFIX | OPT_LIMITS, NULL, 2, 1 },
230 { "modem", o_bool, &modem,
231 "Use modem control lines", OPT_PRIO | 1 },
232 { "local", o_bool, &modem,
233 "Don't use modem control lines", OPT_PRIOSUB | 0 },
235 { "sync", o_bool, &sync_serial,
236 "Use synchronous HDLC serial encoding", 1 },
238 { "datarate", o_int, &max_data_rate,
239 "Maximum data rate in bytes/sec (with pty, notty or record option)",
242 { "escape", o_special, (void *)setescape,
243 "List of character codes to escape on transmission",
244 OPT_A2PRINTER, (void *)printescape },
250 struct channel tty_channel = {
252 &tty_process_extra_options,
257 &tty_disestablish_ppp,
265 * setspeed - Set the serial port baud rate.
266 * If doit is 0, the call is to check whether this option is
267 * potentially a speed value.
270 setspeed(char *arg, char **argv, int doit)
275 spd = strtol(arg, &ptr, 0);
276 if (ptr == arg || *ptr != 0 || spd == 0)
280 slprintf(speed_str, sizeof(speed_str), "%d", spd);
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.
292 setdevname(char *cp, char **argv, int doit)
295 char dev[MAXPATHLEN];
301 strlcpy(dev, "/dev/", sizeof(dev));
302 strlcat(dev, cp, sizeof(dev));
307 * Check if there is a character device by this name.
309 if (stat(cp, &statbuf) < 0) {
311 return errno != ENOENT;
312 option_error("Couldn't stat %s: %m", cp);
315 if (!S_ISCHR(statbuf.st_mode)) {
317 option_error("%s is not a character device", cp);
322 strlcpy(devnam, cp, MAXPATHLEN);
331 setxonxoff(char **argv)
333 lcp_wantoptions[0].asyncmap |= 0x000A0000; /* escape ^S and ^Q */
334 lcp_wantoptions[0].neg_asyncmap = 1;
341 * setescape - add chars to the set we escape on transmission.
344 setescape(char **argv)
352 n = strtol(p, &endp, 16);
354 option_error("escape parameter contains invalid hex number '%s'",
359 if (n < 0 || n == 0x5E || n > 0xFF) {
360 option_error("can't escape character 0x%x", n);
363 xmit_accm[n >> 5] |= 1 << (n & 0x1F);
364 while (*p == ',' || *p == ' ')
367 lcp_allowoptions[0].asyncmap = xmit_accm[0];
372 printescape(option_t *opt, void (*printer)(void *, char *, ...), void *arg)
377 for (n = 0; n < 256; ++n) {
379 n += 2; /* skip 7d, 7e */
380 if (xmit_accm[n >> 5] & (1 << (n & 0x1f))) {
385 printer(arg, "%x", n);
389 printer(arg, "oops # nothing escaped");
393 * tty_init - do various tty-related initializations.
397 add_notifier(&pidchange, maybe_relock, 0);
398 the_channel = &tty_channel;
399 xmit_accm[3] = 0x60000000;
403 * tty_process_extra_options - work out which tty device we are using
404 * and read its options file.
406 void tty_process_extra_options(void)
408 using_pty = notty || ptycommand != NULL || pty_socket != NULL;
411 if (default_device) {
413 if (!isatty(0) || (p = ttyname(0)) == NULL) {
414 option_error("no device specified and stdin is not a tty");
415 exit(EXIT_OPTION_ERROR);
417 strlcpy(devnam, p, MAXPATHLEN);
418 if (stat(devnam, &devstat) < 0)
419 fatal("Couldn't stat default device %s: %m", devnam);
424 * Parse the tty options file.
425 * The per-tty options file should not change
426 * ptycommand, pty_socket, notty or devnam.
427 * options_for_tty doesn't override options set on the command line,
428 * except for some privileged options.
430 if (!options_for_tty())
431 exit(EXIT_OPTION_ERROR);
435 * tty_check_options - do consistency checks on the options we were given.
438 tty_check_options(void)
443 if (demand && notty) {
444 option_error("demand-dialling is incompatible with notty");
445 exit(EXIT_OPTION_ERROR);
447 if (demand && connect_script == 0 && ptycommand == NULL
448 && pty_socket == NULL) {
449 option_error("connect script is required for demand-dialling\n");
450 exit(EXIT_OPTION_ERROR);
452 /* default holdoff to 0 if no connect script has been given */
453 if (connect_script == 0 && !holdoff_specified)
457 if (!default_device) {
458 option_error("%s option precludes specifying device name",
459 pty_socket? "socket": notty? "notty": "pty");
460 exit(EXIT_OPTION_ERROR);
462 if (ptycommand != NULL && notty) {
463 option_error("pty option is incompatible with notty option");
464 exit(EXIT_OPTION_ERROR);
466 if (pty_socket != NULL && (ptycommand != NULL || notty)) {
467 option_error("socket option is incompatible with pty and notty");
468 exit(EXIT_OPTION_ERROR);
470 default_device = notty;
473 if (notty && log_to_fd <= 1)
477 * If the user has specified a device which is the same as
478 * the one on stdin, pretend they didn't specify any.
479 * If the device is already open read/write on stdin,
480 * we assume we don't need to lock it, and we can open it
483 if (fstat(0, &statbuf) >= 0 && S_ISCHR(statbuf.st_mode)
484 && statbuf.st_rdev == devstat.st_rdev) {
486 fdflags = fcntl(0, F_GETFL);
487 if (fdflags != -1 && (fdflags & O_ACCMODE) == O_RDWR)
495 * Don't send log messages to the serial port, it tends to
496 * confuse the peer. :-)
498 if (log_to_fd >= 0 && fstat(log_to_fd, &statbuf) >= 0
499 && S_ISCHR(statbuf.st_mode) && statbuf.st_rdev == devstat.st_rdev)
504 * connect_tty - get the serial port ready to start doing PPP.
505 * That is, open the serial port, set its speed and mode, and run
506 * the connector and/or welcomer.
508 int connect_tty(void)
518 * Get a pty master/slave pair if the pty, notty, socket,
519 * or record options were specified.
521 strlcpy(ppp_devnam, devnam, MAXPATHLEN);
525 if (using_pty || record_file != NULL) {
526 if (!get_pty(&pty_master, &pty_slave, ppp_devnam, uid)) {
527 error("Couldn't allocate pseudo-tty");
528 status = EXIT_FATAL_ERROR;
531 set_up_tty(pty_slave, 1);
535 * Lock the device if we've been asked to.
537 status = EXIT_LOCK_FAILED;
538 if (lockflag && !privopen) {
539 if (lock(devnam) < 0)
545 * Open the serial device and set it up to be the ppp interface.
546 * First we open it in non-blocking mode so we can set the
547 * various termios flags appropriately. If we aren't dialling
548 * out and we want to use the modem lines, we reopen it later
549 * in order to wait for the carrier detect signal from the modem.
552 connector = doing_callback? callback_script: connect_script;
553 if (devnam[0] != 0) {
555 /* If the user specified the device name, become the
556 user before opening it. */
559 prio = privopen? OPRIO_ROOT: tty_options[0].priority;
560 if (prio < OPRIO_ROOT && seteuid(uid) == -1) {
561 error("Unable to drop privileges before opening %s: %m\n",
563 status = EXIT_OPEN_FAILED;
566 real_ttyfd = open(devnam, O_NONBLOCK | O_RDWR, 0);
568 if (prio < OPRIO_ROOT && seteuid(0) == -1)
569 fatal("Unable to regain privileges");
574 error("Failed to open %s: %m", devnam);
575 status = EXIT_OPEN_FAILED;
577 if (!persist || err != EINTR)
581 if ((fdflags = fcntl(ttyfd, F_GETFL)) == -1
582 || fcntl(ttyfd, F_SETFL, fdflags & ~O_NONBLOCK) < 0)
583 warn("Couldn't reset non-blocking mode on device: %m");
587 * Linux 2.4 and above blocks normal writes to the tty
588 * when it is in PPP line discipline, so this isn't needed.
591 * Do the equivalent of `mesg n' to stop broadcast messages.
593 if (fstat(ttyfd, &statbuf) < 0
594 || fchmod(ttyfd, statbuf.st_mode & ~(S_IWGRP | S_IWOTH)) < 0) {
595 warn("Couldn't restrict write permissions to %s: %m", devnam);
597 tty_mode = statbuf.st_mode;
598 #endif /* __linux__ */
601 * Set line speed, flow control, etc.
602 * If we have a non-null connection or initializer script,
603 * on most systems we set CLOCAL for now so that we can talk
604 * to the modem before carrier comes up. But this has the
605 * side effect that we might miss it if CD drops before we
606 * get to clear CLOCAL below. On systems where we can talk
607 * successfully to the modem with CLOCAL clear and CD down,
608 * we could clear CLOCAL at this point.
610 set_up_tty(ttyfd, ((connector != NULL && connector[0] != 0)
611 || initializer != NULL));
615 * If the pty, socket, notty and/or record option was specified,
616 * start up the character shunt now.
618 status = EXIT_PTYCMD_FAILED;
619 if (ptycommand != NULL) {
620 if (record_file != NULL) {
621 int ipipe[2], opipe[2], ok;
623 if (pipe(ipipe) < 0 || pipe(opipe) < 0)
624 fatal("Couldn't create pipes for record option: %m");
626 /* don't leak these to the ptycommand */
627 (void) fcntl(ipipe[0], F_SETFD, FD_CLOEXEC);
628 (void) fcntl(opipe[1], F_SETFD, FD_CLOEXEC);
630 ok = device_script(ptycommand, opipe[0], ipipe[1], 1) == 0
631 && start_charshunt(ipipe[0], opipe[1]);
639 if (device_script(ptycommand, pty_master, pty_master, 1) < 0)
642 } else if (pty_socket != NULL) {
643 int fd = open_socket(pty_socket);
646 if (!start_charshunt(fd, fd))
650 if (!start_charshunt(0, 1))
658 } else if (record_file != NULL) {
660 if (!start_charshunt(fd, fd))
664 if (using_pty || record_file != NULL) {
670 /* run connection script */
671 if ((connector && connector[0]) || initializer) {
672 if (real_ttyfd != -1) {
673 /* XXX do this if doing_callback == CALLBACK_DIALIN? */
674 if (!default_device && modem) {
675 setdtr(real_ttyfd, 0); /* in case modem is off hook */
677 setdtr(real_ttyfd, 1);
681 if (initializer && initializer[0]) {
682 if (device_script(initializer, ttyfd, ttyfd, 0) < 0) {
683 error("Initializer script failed");
684 status = EXIT_INIT_FAILED;
691 info("Serial port initialized.");
694 if (connector && connector[0]) {
695 if (device_script(connector, ttyfd, ttyfd, 0) < 0) {
696 error("Connect script failed");
697 status = EXIT_CONNECT_FAILED;
704 info("Serial connection established.");
707 /* set line speed, flow control, etc.;
708 clear CLOCAL if modem option */
709 if (real_ttyfd != -1)
710 set_up_tty(real_ttyfd, 0);
712 if (doing_callback == CALLBACK_DIALIN)
716 /* reopen tty if necessary to wait for carrier */
717 if (connector == NULL && modem && devnam[0] != 0) {
720 if ((i = open(devnam, O_RDWR)) >= 0)
722 if (errno != EINTR) {
723 error("Failed to reopen %s: %m", devnam);
724 status = EXIT_OPEN_FAILED;
726 if (!persist || errno != EINTR || hungup || got_sigterm)
732 slprintf(numbuf, sizeof(numbuf), "%d", baud_rate);
733 script_setenv("SPEED", numbuf, 0);
735 /* run welcome script, if any */
736 if (welcomer && welcomer[0]) {
737 if (device_script(welcomer, ttyfd, ttyfd, 0) < 0)
738 warn("Welcome script failed");
742 * If we are initiating this connection, wait for a short
743 * time for something from the peer. This can avoid bouncing
744 * our packets off his tty before he has it set up.
746 if (connector != NULL || ptycommand != NULL || pty_socket != NULL)
747 listen_time = connect_delay;
753 tcflush(real_ttyfd, TCIOFLUSH);
755 if (pty_master >= 0) {
766 void disconnect_tty(void)
768 if (disconnect_script == NULL || hungup)
771 set_up_tty(real_ttyfd, 1);
772 if (device_script(disconnect_script, ttyfd, ttyfd, 0) < 0) {
773 warn("disconnect script failed");
775 info("Serial link disconnected.");
777 stop_charshunt(NULL, 0);
780 void tty_close_fds(void)
784 if (real_ttyfd >= 0) {
788 /* N.B. ttyfd will == either pty_slave or real_ttyfd */
791 void cleanup_tty(void)
803 * tty_do_send_config - set transmit-side PPP configuration.
804 * We set the extended transmit ACCM here as well.
807 tty_do_send_config(int mtu, u_int32_t accm, int pcomp, int accomp)
809 tty_set_xaccm(xmit_accm);
810 tty_send_config(mtu, accm, pcomp, accomp);
814 * finish_tty - restore the terminal device to its original settings
819 /* drop dtr to hang up */
820 if (!default_device && modem) {
821 setdtr(real_ttyfd, 0);
823 * This sleep is in case the serial port has CLOCAL set by default,
824 * and consequently will reassert DTR when we close the device.
829 restore_tty(real_ttyfd);
832 if (tty_mode != (mode_t) -1) {
833 if (fchmod(real_ttyfd, tty_mode) != 0)
834 error("Couldn't restore tty permissions");
836 #endif /* __linux__ */
843 * maybe_relock - our PID has changed, maybe update the lock file.
846 maybe_relock(void *arg, int pid)
853 * open_socket - establish a stream socket connection to the nominated
857 open_socket(char *dest)
859 char *sep, *endp = NULL;
862 struct hostent *hent;
863 struct sockaddr_in sad;
865 /* parse host:port and resolve host to an IP address */
866 sep = strchr(dest, ':');
868 port = strtol(sep+1, &endp, 10);
869 if (port < 0 || endp == sep+1 || sep == dest) {
870 error("Can't parse host:port for socket destination");
874 host = inet_addr(dest);
875 if (host == (u_int32_t) -1) {
876 hent = gethostbyname(dest);
878 error("%s: unknown host in socket option", dest);
882 host = *(u_int32_t *)(hent->h_addr_list[0]);
886 /* get a socket and connect it to the other end */
887 sock = socket(PF_INET, SOCK_STREAM, 0);
889 error("Can't create socket: %m");
892 memset(&sad, 0, sizeof(sad));
893 sad.sin_family = AF_INET;
894 sad.sin_port = htons(port);
895 sad.sin_addr.s_addr = host;
896 if (connect(sock, (struct sockaddr *)&sad, sizeof(sad)) < 0) {
897 error("Can't connect to %s: %m", dest);
907 * start_charshunt - create a child process to run the character shunt.
910 start_charshunt(int ifd, int ofd)
914 cpid = safe_fork(ifd, ofd, (log_to_fd >= 0? log_to_fd: 2));
916 error("Can't fork process for character shunt: %m");
924 else if (log_to_fd >= 0)
926 ret = setgid(getgid());
928 fatal("setgid failed, %m");
931 if (ret != 0 || getuid() != uid) {
932 fatal("setuid failed, %m");
934 charshunt(0, 1, record_file);
937 charshunt_pid = cpid;
938 record_child(cpid, "pppd (charshunt)", charshunt_done, NULL, 1);
943 charshunt_done(void *arg)
949 stop_charshunt(void *arg, int sig)
952 kill(charshunt_pid, (sig == SIGINT? sig: SIGTERM));
956 * charshunt - the character shunt, which passes characters between
957 * the pty master side and the serial port (or stdin/stdout).
958 * This runs as the user (not as root).
959 * (We assume ofd >= ifd which is true the way this gets called. :-).
962 charshunt(int ifd, int ofd, char *record_file)
965 fd_set ready, writey;
966 u_char *ibufp, *obufp;
969 int pty_readable, stdin_readable;
970 struct timeval lasttime;
971 FILE *recordf = NULL;
972 int ilevel, olevel, max_level;
973 struct timeval levelt, tout, *top;
974 extern u_char inpacket_buf[];
977 * Reset signal handlers.
979 signal(SIGHUP, SIG_IGN); /* Hangup */
980 signal(SIGINT, SIG_DFL); /* Interrupt */
981 signal(SIGTERM, SIG_DFL); /* Terminate */
982 signal(SIGCHLD, SIG_DFL);
983 signal(SIGUSR1, SIG_DFL);
984 signal(SIGUSR2, SIG_DFL);
985 signal(SIGABRT, SIG_DFL);
986 signal(SIGALRM, SIG_DFL);
987 signal(SIGFPE, SIG_DFL);
988 signal(SIGILL, SIG_DFL);
989 signal(SIGPIPE, SIG_DFL);
990 signal(SIGQUIT, SIG_DFL);
991 signal(SIGSEGV, SIG_DFL);
993 signal(SIGBUS, SIG_DFL);
996 signal(SIGEMT, SIG_DFL);
999 signal(SIGPOLL, SIG_DFL);
1002 signal(SIGPROF, SIG_DFL);
1005 signal(SIGSYS, SIG_DFL);
1008 signal(SIGTRAP, SIG_DFL);
1011 signal(SIGVTALRM, SIG_DFL);
1014 signal(SIGXCPU, SIG_DFL);
1017 signal(SIGXFSZ, SIG_DFL);
1021 * Check that the fds won't overrun the fd_sets
1023 if (ifd >= FD_SETSIZE || ofd >= FD_SETSIZE || pty_master >= FD_SETSIZE)
1024 fatal("internal error: file descriptor too large (%d, %d, %d)",
1025 ifd, ofd, pty_master);
1028 * Open the record file if required.
1030 if (record_file != NULL) {
1031 recordf = fopen(record_file, "a");
1032 if (recordf == NULL)
1033 error("Couldn't create record file %s: %m", record_file);
1036 /* set all the fds to non-blocking mode */
1037 flags = fcntl(pty_master, F_GETFL);
1039 || fcntl(pty_master, F_SETFL, flags | O_NONBLOCK) == -1)
1040 warn("couldn't set pty master to nonblock: %m");
1041 flags = fcntl(ifd, F_GETFL);
1043 || fcntl(ifd, F_SETFL, flags | O_NONBLOCK) == -1)
1044 warn("couldn't set %s to nonblock: %m", (ifd==0? "stdin": "tty"));
1046 flags = fcntl(ofd, F_GETFL);
1048 || fcntl(ofd, F_SETFL, flags | O_NONBLOCK) == -1)
1049 warn("couldn't set stdout to nonblock: %m");
1053 ibufp = obufp = NULL;
1054 pty_readable = stdin_readable = 1;
1056 ilevel = olevel = 0;
1058 if (max_data_rate) {
1059 max_level = max_data_rate / 10;
1060 if (max_level < 100)
1063 max_level = PPP_MRU + PPP_HDRLEN + 1;
1065 nfds = (ofd > pty_master? ofd: pty_master) + 1;
1066 if (recordf != NULL) {
1067 gettimeofday(&lasttime, NULL);
1068 putc(7, recordf); /* put start marker */
1069 putc(lasttime.tv_sec >> 24, recordf);
1070 putc(lasttime.tv_sec >> 16, recordf);
1071 putc(lasttime.tv_sec >> 8, recordf);
1072 putc(lasttime.tv_sec, recordf);
1073 lasttime.tv_usec = 0;
1076 while (nibuf != 0 || nobuf != 0 || pty_readable || stdin_readable) {
1079 tout.tv_usec = 10000;
1083 if (ilevel >= max_level)
1086 FD_SET(pty_master, &writey);
1087 } else if (stdin_readable)
1088 FD_SET(ifd, &ready);
1090 if (olevel >= max_level)
1093 FD_SET(ofd, &writey);
1094 } else if (pty_readable)
1095 FD_SET(pty_master, &ready);
1096 if (select(nfds, &ready, &writey, NULL, top) < 0) {
1101 if (max_data_rate) {
1107 dt = (now.tv_sec - levelt.tv_sec
1108 + (now.tv_usec - levelt.tv_usec) / 1e6);
1109 nbt = (int)(dt * max_data_rate);
1110 ilevel = (nbt < 0 || nbt > ilevel)? 0: ilevel - nbt;
1111 olevel = (nbt < 0 || nbt > olevel)? 0: olevel - nbt;
1114 ilevel = olevel = 0;
1115 if (FD_ISSET(ifd, &ready)) {
1116 ibufp = inpacket_buf;
1117 nibuf = read(ifd, ibufp, PPP_MRU + PPP_HDRLEN);
1118 if (nibuf < 0 && errno == EIO)
1121 if (!(errno == EINTR || errno == EAGAIN)) {
1122 error("Error reading standard input: %m");
1126 } else if (nibuf == 0) {
1127 /* end of file from stdin */
1130 if (!record_write(recordf, 4, NULL, 0, &lasttime))
1133 FD_SET(pty_master, &writey);
1135 if (!record_write(recordf, 2, ibufp, nibuf, &lasttime))
1139 if (FD_ISSET(pty_master, &ready)) {
1140 obufp = outpacket_buf;
1141 nobuf = read(pty_master, obufp, PPP_MRU + PPP_HDRLEN);
1142 if (nobuf < 0 && errno == EIO)
1145 if (!(errno == EINTR || errno == EAGAIN)) {
1146 error("Error reading pseudo-tty master: %m");
1150 } else if (nobuf == 0) {
1151 /* end of file from the pty - slave side has closed */
1153 stdin_readable = 0; /* pty is not writable now */
1157 if (!record_write(recordf, 3, NULL, 0, &lasttime))
1160 FD_SET(ofd, &writey);
1162 if (!record_write(recordf, 1, obufp, nobuf, &lasttime))
1165 } else if (!stdin_readable)
1167 if (FD_ISSET(ofd, &writey)) {
1169 if (olevel + n > max_level)
1170 n = max_level - olevel;
1171 n = write(ofd, obufp, n);
1176 } else if (errno != EAGAIN && errno != EINTR) {
1177 error("Error writing standard output: %m");
1186 if (FD_ISSET(pty_master, &writey)) {
1188 if (ilevel + n > max_level)
1189 n = max_level - ilevel;
1190 n = write(pty_master, ibufp, n);
1195 } else if (errno != EAGAIN && errno != EINTR) {
1196 error("Error writing pseudo-tty master: %m");
1210 record_write(FILE *f, int code, u_char *buf, int nb, struct timeval *tp)
1215 gettimeofday(&now, NULL);
1216 now.tv_usec /= 100000; /* actually 1/10 s, not usec now */
1217 diff = (now.tv_sec - tp->tv_sec) * 10 + (now.tv_usec - tp->tv_usec);
1221 putc(diff >> 24, f);
1222 putc(diff >> 16, f);
1235 fwrite(buf, nb, 1, f);
1239 error("Error writing record file: %m");