diff options
Diffstat (limited to 'networking/telnetd.ctrlSQ.patch')
| -rw-r--r-- | networking/telnetd.ctrlSQ.patch | 175 |
1 files changed, 175 insertions, 0 deletions
diff --git a/networking/telnetd.ctrlSQ.patch b/networking/telnetd.ctrlSQ.patch new file mode 100644 index 0000000..885e105 --- /dev/null +++ b/networking/telnetd.ctrlSQ.patch @@ -0,0 +1,175 @@ +From: "Doug Graham" <dgraham@nortel.com> +Date: 2009-01-22 07:20 + +Hello, + +Busybox's telnetd does not disable local (client-side) flow control +properly. It does not put the pty into packet mode and then notify the +client whenever flow control is disabled by an application running under +its control. The result is that ^S/^Q are not passed through to the +application, which is painful when the application is an emacs variant. + +I suppose that support for this might be considered bloat, but the +included patch only adds about 200 bytes of text to x86 busybox and 300 +bytes to mipsel busybox. Please consider applying. + +============================= + +NB: the patch doesn't work as-is because we now have iac_safe_write() +which quotes IACs on output. + +============================= +Docs: + +The following ioctl(2) calls apply only to pseudo terminals: + +TIOCSTOP Stops output to a terminal (e.g. like typing ^S). Takes no parameter. + +TIOCSTART Restarts output (stopped by TIOCSTOP or by typing ^S). Takes no parameter. + +TIOCPKT Enable/disable packet mode. When applied to the master side of a pseudo terminal, each +subsequent read(2) from the terminal will return data written on the slave part of the pseudo terminal preceded by a +zero byte (symbolically defined as TIOCPKT_DATA), or a single byte reflecting control status information. +In the latter case, the byte is an inclusive-or of zero or more of the bits: + +TIOCPKT_FLUSHREAD whenever the read queue for the terminal is flushed. +TIOCPKT_FLUSHWRITE whenever the write queue for the terminal is flushed. +TIOCPKT_STOP whenever output to the terminal is stopped a la ^S. +TIOCPKT_START whenever output to the terminal is restarted. +TIOCPKT_DOSTOP whenever t_stopc is ^S and t_startc is ^Q. +TIOCPKT_NOSTOP whenever the start and stop characters are not ^S/^Q. + +While this mode is in use, the presence of control status information to be read from the master side may be detected +by a select(2) for exceptional conditions. + +This mode is used by rlogin(1) and rlogind(8) to implement a remote-echoed, locally ^S/^Q flow-controlled remote login +with proper back-flushing of output; it can be used by other similar programs. + +TIOCUCNTL Enable/disable a mode that allows a small number of simple user ioctl(2) commands to be passed through +the pseudo-terminal, using a protocol similar to that of TIOCPKT. The TIOCUCNTL and TIOCPKT modes are mutually +exclusive. This mode is enabled from the master side of a pseudo terminal. Each subsequent read(2) from the master side +will return data written on the slave part of the pseudo terminal preceded by a zero byte, or a single byte reflecting a +user control operation on the slave side. A user control command consists of a special ioctl(2) operation with no data; +the command is given as UIOCCMD (n), where n is a number in the range 1-255. The operation value n will be received as +a single byte on the next read(2) from the master side. The ioctl(2) UIOCCMD (0) is a no-op that may be used to probe +for the existence of this facility. As with TIOCPKT mode, command operations may be detected with a select(2) for +exceptional conditions. + +--- busybox-1.13.2/networking/telnetd.c 2009/01/21 20:02:39 1.1 ++++ busybox-1.13.2/networking/telnetd.c 2009/01/22 00:35:28 +@@ -38,6 +38,9 @@ + int sockfd_read, sockfd_write, ptyfd; + int shell_pid; + ++#ifdef TIOCPKT ++ int flowstate; ++#endif + /* two circular buffers */ + /*char *buf1, *buf2;*/ + /*#define TS_BUF1 ts->buf1*/ +@@ -170,6 +173,9 @@ + int fd, pid; + char tty_name[GETPTY_BUFSIZE]; + struct tsession *ts = xzalloc(sizeof(struct tsession) + BUFSIZE * 2); ++#ifdef TIOCPKT ++ int on = 1; ++#endif + + /*ts->buf1 = (char *)(ts + 1);*/ + /*ts->buf2 = ts->buf1 + BUFSIZE;*/ +@@ -180,6 +186,10 @@ + maxfd = fd; + ts->ptyfd = fd; + ndelay_on(fd); ++#ifdef TIOCPKT ++ ioctl(fd, TIOCPKT, &on); ++ ts->flowstate = TIOCPKT_DOSTOP; ++#endif + #if ENABLE_FEATURE_TELNETD_STANDALONE + ts->sockfd_read = sock; + /* SO_KEEPALIVE by popular demand */ +@@ -385,6 +395,16 @@ + portnbr = 23, + }; + #endif ++#ifdef TIOCPKT ++ int control; ++ static const char lflow_on[] = ++ {IAC, SB, TELOPT_LFLOW, LFLOW_ON, IAC, SE}; ++ static const char lflow_off[] = ++ {IAC, SB, TELOPT_LFLOW, LFLOW_OFF, IAC, SE}; ++# define RESERVED sizeof(lflow_on) ++#else ++# define RESERVED 0 ++#endif + /* Even if !STANDALONE, we accept (and ignore) -i, thus people + * don't need to guess whether it's ok to pass -i to us */ + opt = getopt32(argv, "f:l:Ki" USE_FEATURE_TELNETD_STANDALONE("p:b:F"), +@@ -475,7 +495,7 @@ + FD_SET(ts->sockfd_read, &rdfdset); + if (ts->size2 > 0) /* can write to socket */ + FD_SET(ts->sockfd_write, &wrfdset); +- if (ts->size2 < BUFSIZE) /* can read from pty */ ++ if (ts->size2 < (BUFSIZE - RESERVED)) /* can read from pty */ + FD_SET(ts->ptyfd, &rdfdset); + } + ts = next; +@@ -593,6 +613,52 @@ + goto skip4; + goto kill_session; + } ++#ifdef TIOCPKT ++ control = TS_BUF2[ts->rdidx2]; ++ if (--count > 0 && control == TIOCPKT_DATA) { ++ /* ++ * If we are in packet mode, and we have ++ * just read a chunk of actual data from ++ * the pty, then there is the TIOCPKT_DATA ++ * byte (zero) that we have got to remove ++ * somehow. If there were no chars in ++ * TS_BUF2 before we did this read, then ++ * we can optimize by just advancing wridx2. ++ * Otherwise we have to copy the new data down ++ * to close the gap (Could use readv() instead). ++ */ ++ if (ts->size2 == 0) ++ ts->wridx2++; ++ else { ++ memmove(TS_BUF2 + ts->rdidx2, ++ TS_BUF2 + ts->rdidx2 + 1, count); ++ } ++ } ++ ++ /* ++ * If the flow control state changed, notify ++ * the client. If "control" is not TIOCPKT_DATA, ++ * then there are no data bytes to worry about. ++ */ ++ if ((control & (TIOCPKT_DOSTOP|TIOCPKT_NOSTOP)) != 0 ++ && ts->flowstate != (control & TIOCPKT_DOSTOP)) { ++ const char *p = ts->flowstate ? lflow_off : lflow_on; ++ ++ /* ++ * We know we have enough free slots available ++ * (see RESERVED) but they are not necessarily ++ * contiguous; we may have to wrap. ++ */ ++ for (count = sizeof(lflow_on); count > 0; count--) { ++ TS_BUF2[ts->rdidx2++] = *p++; ++ if (ts->rdidx2 >= BUFSIZE) ++ ts->rdidx2 = 0; ++ ts->size2++; ++ } ++ ++ ts->flowstate = control & TIOCPKT_DOSTOP; ++ } ++#endif /* TIOCPKT */ + ts->size2 += count; + ts->rdidx2 += count; + if (ts->rdidx2 >= BUFSIZE) /* actually == BUFSIZE */ + +--Doug +_______________________________________________ +busybox mailing list +busybox@busybox.net +http://lists.busybox.net/mailman/listinfo/busybox |