1755 lines
52 KiB
C
1755 lines
52 KiB
C
/* vi: set sw=4 ts=4: */
|
|
/*
|
|
* Simple telnet server
|
|
* Bjorn Wesen, Axis Communications AB (bjornw@axis.com)
|
|
*
|
|
* Licensed under GPLv2 or later, see file LICENSE in this source tree.
|
|
*
|
|
* ---------------------------------------------------------------------------
|
|
* (C) Copyright 2000, Axis Communications AB, LUND, SWEDEN
|
|
****************************************************************************
|
|
*
|
|
* The telnetd manpage says it all:
|
|
*
|
|
* Telnetd operates by allocating a pseudo-terminal device (see pty(4)) for
|
|
* a client, then creating a login process which has the slave side of the
|
|
* pseudo-terminal as stdin, stdout, and stderr. Telnetd manipulates the
|
|
* master side of the pseudo-terminal, implementing the telnet protocol and
|
|
* passing characters between the remote client and the login process.
|
|
*
|
|
* Vladimir Oleynik <dzo@simtreas.ru> 2001
|
|
* Set process group corrections, initial busybox port
|
|
*/
|
|
//config:config TELNETD
|
|
//config: bool "telnetd (13 kb)"
|
|
//config: default y
|
|
//config: select FEATURE_SYSLOG
|
|
//config: help
|
|
//config: A daemon for the TELNET protocol, allowing you to log onto the host
|
|
//config: running the daemon. Please keep in mind that the TELNET protocol
|
|
//config: sends passwords in plain text. If you can't afford the space for an
|
|
//config: SSH daemon and you trust your network, you may say 'y' here. As a
|
|
//config: more secure alternative, you should seriously consider installing the
|
|
//config: very small Dropbear SSH daemon instead:
|
|
//config: http://matt.ucc.asn.au/dropbear/dropbear.html
|
|
//config:
|
|
//config: Note that for busybox telnetd to work you need several things:
|
|
//config: First of all, your kernel needs:
|
|
//config: CONFIG_UNIX98_PTYS=y
|
|
//config:
|
|
//config: Next, you need a /dev/pts directory on your root filesystem:
|
|
//config:
|
|
//config: $ ls -ld /dev/pts
|
|
//config: drwxr-xr-x 2 root root 0 Sep 23 13:21 /dev/pts/
|
|
//config:
|
|
//config: Next you need the pseudo terminal master multiplexer /dev/ptmx:
|
|
//config:
|
|
//config: $ ls -la /dev/ptmx
|
|
//config: crw-rw-rw- 1 root tty 5, 2 Sep 23 13:55 /dev/ptmx
|
|
//config:
|
|
//config: Any /dev/ttyp[0-9]* files you may have can be removed.
|
|
//config: Next, you need to mount the devpts filesystem on /dev/pts using:
|
|
//config:
|
|
//config: mount -t devpts devpts /dev/pts
|
|
//config:
|
|
//config: You need to be sure that busybox has LOGIN and
|
|
//config: FEATURE_SUID enabled. And finally, you should make
|
|
//config: certain that busybox has been installed setuid root:
|
|
//config:
|
|
//config: chown root.root /bin/busybox
|
|
//config: chmod 4755 /bin/busybox
|
|
//config:
|
|
//config: with all that done, telnetd _should_ work....
|
|
//config:
|
|
//config:config FEATURE_TELNETD_SELFTEST_DEBUG
|
|
//config: bool "Include self-test (telnetd -@)"
|
|
//config: default n
|
|
//config: depends on TELNETD
|
|
//config: help
|
|
//config: Include self-test code for pty/vhangup() behavior.
|
|
//config: Useful for development and validation on new platforms.
|
|
//config:
|
|
//config:config FEATURE_TELNETD_STANDALONE
|
|
//config: bool "Support standalone telnetd (not inetd only)"
|
|
//config: default y
|
|
//config: depends on TELNETD
|
|
//config: help
|
|
//config: Selecting this will make telnetd able to run standalone.
|
|
//config:
|
|
//config:config FEATURE_TELNETD_PORT_DEFAULT
|
|
//config: int "Default port"
|
|
//config: default 23
|
|
//config: range 1 65535
|
|
//config: depends on FEATURE_TELNETD_STANDALONE
|
|
//config:
|
|
//config:config FEATURE_TELNETD_INETD_WAIT
|
|
//config: bool "Support -w SEC option (inetd wait mode)"
|
|
//config: default y
|
|
//config: depends on FEATURE_TELNETD_STANDALONE
|
|
//config: help
|
|
//config: This option allows you to run telnetd in "inet wait" mode.
|
|
//config: Example inetd.conf line (note "wait", not usual "nowait"):
|
|
//config:
|
|
//config: telnet stream tcp wait root /bin/telnetd telnetd -w10
|
|
//config:
|
|
//config: In this example, inetd passes _listening_ socket_ as fd 0
|
|
//config: to telnetd when connection appears.
|
|
//config: telnetd will wait for connections until all existing
|
|
//config: connections are closed, and no new connections
|
|
//config: appear during 10 seconds. Then it exits, and inetd continues
|
|
//config: to listen for new connections.
|
|
//config:
|
|
//config: This option is rarely used. "tcp nowait" is much more usual
|
|
//config: way of running tcp services, including telnetd.
|
|
//config: You most probably want to say N here.
|
|
|
|
//applet:IF_TELNETD(APPLET(telnetd, BB_DIR_USR_SBIN, BB_SUID_DROP))
|
|
|
|
//kbuild:lib-$(CONFIG_TELNETD) += telnetd.o
|
|
|
|
//usage:#define telnetd_trivial_usage
|
|
//usage: "[OPTIONS]"
|
|
//usage:#define telnetd_full_usage "\n\n"
|
|
//usage: "Handle incoming telnet connections"
|
|
//usage: IF_NOT_FEATURE_TELNETD_STANDALONE(" via inetd") "\n"
|
|
//usage: "\n -l LOGIN Exec LOGIN on connect (default /bin/login)"
|
|
//usage: "\n -f ISSUE_FILE Display ISSUE_FILE instead of /etc/issue.net"
|
|
//usage: "\n -K Close connection as soon as login exits"
|
|
//usage: "\n (normally wait until all programs close slave pty)"
|
|
//usage: IF_FEATURE_TELNETD_STANDALONE(
|
|
//usage: "\n -p PORT Port to listen on. Default "STR(CONFIG_FEATURE_TELNETD_PORT_DEFAULT)
|
|
//usage: "\n -b ADDR[:PORT] Address to bind to"
|
|
//usage: "\n -F Run in foreground"
|
|
//usage: "\n -i Inetd mode"
|
|
//usage: IF_FEATURE_TELNETD_INETD_WAIT(
|
|
//usage: "\n -w SEC Inetd 'wait' mode, linger time SEC"
|
|
//usage: "\n inetd.conf line: 23 stream tcp wait root telnetd telnetd -w10"
|
|
//usage: "\n -S Log to syslog (implied by -i or without -F and -w)"
|
|
//usage: )
|
|
//usage: )
|
|
//usage: "\n -v Verbose"
|
|
|
|
#include "libbb.h"
|
|
#include "common_bufsiz.h"
|
|
#include <syslog.h>
|
|
#include <arpa/telnet.h>
|
|
|
|
#define DEBUG 0
|
|
#define DEBUG_CLOSING 0
|
|
|
|
#if DEBUG
|
|
# define dbg(...) bb_error_msg(__VA_ARGS__)
|
|
#else
|
|
# define dbg(...) ((void)0)
|
|
#endif
|
|
#if DEBUG_CLOSING
|
|
# define dbg_close(...) bb_error_msg(__VA_ARGS__)
|
|
#else
|
|
# define dbg_close(...) ((void)0)
|
|
#endif
|
|
|
|
#define SELFTEST_VHANGUP 1
|
|
#define SELFTEST_NET2PTY 1
|
|
#define SELFTEST_PTY2NET 1
|
|
|
|
#define SAVE_NET2PTY_EXPECTED 0
|
|
#define SAVE_NET2PTY_ACTUAL 0
|
|
|
|
#define SAVE_PTY2NET_EXPECTED 0
|
|
#define SAVE_PTY2NET_ACTUAL 0
|
|
|
|
/* Must match getopt32 string */
|
|
enum {
|
|
OPT_WATCHCHILD = (1 << 2), /* -K */
|
|
OPT_INETD = (1 << 3) * ENABLE_FEATURE_TELNETD_STANDALONE, /* -i */
|
|
OPT_PORT = (1 << 4) * ENABLE_FEATURE_TELNETD_STANDALONE, /* -p PORT */
|
|
OPT_FOREGROUND = (1 << 6) * ENABLE_FEATURE_TELNETD_STANDALONE, /* -F */
|
|
OPT_SYSLOG = (1 << 7) * ENABLE_FEATURE_TELNETD_INETD_WAIT, /* -S */
|
|
OPT_WAIT = (1 << 8) * ENABLE_FEATURE_TELNETD_INETD_WAIT, /* -w SEC */
|
|
};
|
|
|
|
/* Globals */
|
|
struct globals {
|
|
ioloop_state_t io;
|
|
const char *loginpath;
|
|
const char *issuefile;
|
|
unsigned verbose;
|
|
IF_FEATURE_TELNETD_INETD_WAIT(unsigned sec_linger;)
|
|
} FIX_ALIASING;
|
|
#define G (*(struct globals*)bb_common_bufsiz1)
|
|
#define INIT_G() do { \
|
|
setup_common_bufsiz(); \
|
|
G.loginpath = "/bin/login"; \
|
|
G.issuefile = "/etc/issue.net"; \
|
|
} while (0)
|
|
|
|
#define log1(...) do { if (G.verbose) bb_error_msg(__VA_ARGS__); } while (0)
|
|
|
|
static NOINLINE void fabricate_ctrl_D_on_pty(int fd)
|
|
{
|
|
struct termios tio;
|
|
// Master pty can see slave's termios - abuse that
|
|
if (tcgetattr(fd, &tio) != 0) {
|
|
dbg_close("%s: no termios(%d)", __func__, fd);
|
|
return;
|
|
}
|
|
dbg_close("%s: termios(%d) ICANON:%d,VEOF:%02x", __func__,
|
|
fd, !!(tio.c_lflag & ICANON), (uint8_t)tio.c_cc[VEOF]);
|
|
if ((tio.c_lflag & ICANON) && tio.c_cc[VEOF] != 0) {
|
|
// _Should_ look like EOF on input on the slave side...
|
|
write(fd, &tio.c_cc[VEOF], 1); // usually ^D
|
|
// One ^D often won't do. If a program was blocked on read already,
|
|
// ^D makes _that_ read return:
|
|
// read(0, "some data", 64) = 9
|
|
// but the program will likely read more
|
|
// (it did not interpret above as EOF), block, and die:
|
|
// read(0, 0x123456, 64) = ...<blocked>... -1 EIO
|
|
// +++ killed by SIGHUP +++
|
|
// Well, I'm not greedy...
|
|
write(fd, &tio.c_cc[VEOF], 1); // here is another EOF for you
|
|
// If this doesn't work, they can see 0x04 bytes. Tough cookies
|
|
}
|
|
}
|
|
|
|
#define TELNET_CONNECTION \
|
|
STRUCT_CONNECTION \
|
|
pid_t shell_pid;
|
|
|
|
typedef struct telnet_conn {
|
|
TELNET_CONNECTION
|
|
} telnet_conn_t;
|
|
|
|
struct net_to_pty;
|
|
|
|
typedef struct pty_to_net {
|
|
TELNET_CONNECTION
|
|
struct net_to_pty *sibling; /* must be directly after TELNET_CONNECTION */
|
|
int rdidx, wridx, size;
|
|
unsigned deadline_us;
|
|
unsigned eio_count;
|
|
//TODO: these two can be unified into one:
|
|
smallint respond_to_AYT;
|
|
char extra_byte_to_write;
|
|
/* circular buffer follows */
|
|
#define BUF2NET(ts) ((unsigned char*)(ts + 1))
|
|
} pty_to_net_t ALIGN8;
|
|
/* The buffer is directly after malloced memory, aligned to 64 bits */
|
|
enum { TO_NET_BUFSIZE = 2 * 1024 };
|
|
enum { TO_NET_BUFMASK = TO_NET_BUFSIZE - 1 };
|
|
#define BUF2NET_INC(n, inc) ((n) = ((n) + (inc)) & TO_NET_BUFMASK)
|
|
|
|
typedef struct net_to_pty {
|
|
TELNET_CONNECTION
|
|
pty_to_net_t *sibling; /* must be directly after TELNET_CONNECTION */
|
|
int rdidx, wridx, size;
|
|
unsigned deadline_us;
|
|
smallint skip_LF_or_NUL;
|
|
/* circular buffer follows */
|
|
#define BUF2PTY(ts) ((unsigned char*)(ts + 1))
|
|
} net_to_pty_t ALIGN8;
|
|
/* The buffer is directly after malloced memory, aligned to 64 bits */
|
|
enum { TO_PTY_BUFSIZE = 2 * 1024 };
|
|
enum { TO_PTY_BUFMASK = TO_PTY_BUFSIZE - 1 };
|
|
#define BUF2PTY_INC(n, inc) ((n) = ((n) + (inc)) & TO_PTY_BUFMASK)
|
|
#define BUF2PTY_DEC(n, dec) ((n) = ((n) - (dec)) & TO_PTY_BUFMASK)
|
|
|
|
/* The mutual pipes are linked by to_pty, to_net.
|
|
* The rules:
|
|
* = always test for !NULL before use.
|
|
* = if you are freeing one of the structs, set
|
|
* "me->sibling->sibling = NULL".
|
|
* Use one of these helpers:
|
|
*/
|
|
static void remove_and_free_to_pty(net_to_pty_t *ts)
|
|
{
|
|
dbg_close("remove_and_free:%p rd:%d wr:%d sibling:%p",
|
|
ts, ts->read_fd, ts->write_fd, ts->sibling);
|
|
if (ts->sibling) {
|
|
/* "you have no sibling now" */
|
|
ts->sibling->sibling = NULL;
|
|
}
|
|
conn_close_fds_remove_and_free((void*)ts);
|
|
}
|
|
static void ALWAYS_INLINE remove_and_free_to_net(pty_to_net_t *ts)
|
|
{
|
|
/* Works because ->sibling have the same offset */
|
|
remove_and_free_to_pty((void*)ts);
|
|
}
|
|
|
|
// Theory of operation
|
|
// (AKA "when should I close fds? when should I detach from ioloop?").
|
|
// The fds are named read_fd and write_fd, but for clarity let's call them netfd and ptyfd.
|
|
// net_to_pty::should_poll_write_fd
|
|
// net_to_pty::should_poll_read_fd
|
|
// if ptyfd < 0: //sibling told us ptyfd is down?
|
|
// if sibling && sibling->netfd >= 0: netfd = -1; //do not close netfd, sibling uses it (if sibling exists)!
|
|
// close_and_detach;
|
|
// if netfd < 0: return 0;
|
|
// net_to_pty::write
|
|
// if ptyfd write detects error (not EAGAIN):
|
|
// //if (sibling):
|
|
// // sibling->ptyfd = -1; // let sibling know ptyfd is closed
|
|
// // if sibling->netfd >= 0: netfd = -1; // do not close netfd, sibling uses it!
|
|
// //close_and_detach;
|
|
// let pty_to_net detect this (ignore the error)
|
|
// net_to_pty::read
|
|
// if netfd read detects EOF or error (there is no way to tell pty the difference):
|
|
// if no sibling: close(netfd);
|
|
// netfd = -1; //no longer try to read
|
|
// return 0; //but do not detach yet
|
|
|
|
static unsigned char read_byte_unescaping_IAC(int *iac_cnt, unsigned char **pp)
|
|
{
|
|
unsigned char c = *(*pp)++;
|
|
if (c == IAC && **pp == IAC) {
|
|
(*iac_cnt)++;
|
|
(*pp)++; /* Skip the second IAC in IAC IAC sequence */
|
|
}
|
|
return c;
|
|
}
|
|
|
|
static int net_to_pty__should_poll_write_fd(void *this)
|
|
{
|
|
//connection_t *conn = this;
|
|
net_to_pty_t *ts = this;
|
|
unsigned char *buf;
|
|
int size, increment;
|
|
|
|
if (ts->write_fd < 0) /* did slave close its pty? */
|
|
return 0;
|
|
again:
|
|
size = ts->size;
|
|
if (size == 0)
|
|
return 0;
|
|
|
|
buf = BUF2PTY(ts) + ts->wridx;
|
|
if (ts->skip_LF_or_NUL) {
|
|
/* last char we wrote was '\r' */
|
|
ts->skip_LF_or_NUL = 0;
|
|
/* we have the next one: examine */
|
|
if (buf[0] == '\n' || buf[0] == '\0') {
|
|
increment = 1; /* drop it now */
|
|
inc:
|
|
BUF2PTY_INC(ts->wridx, increment);
|
|
ts->size -= increment;
|
|
goto again;
|
|
}
|
|
/* else: not '\r\n' or '\rNUL' */
|
|
}
|
|
if (buf[0] != IAC) /* very likely */
|
|
return size;
|
|
if (size == 1) { /* we only have one char: IAC */
|
|
cant_write:
|
|
if (ts->read_fd < 0)
|
|
ts->size = 0; /* EOF was seen: ignore incomplete IAC, prevent infinite loop */
|
|
//bb_error_msg("cant_write");
|
|
return 0; /* "can't write" */
|
|
}
|
|
|
|
/* size is >= 2 and buf[0] is IAC */
|
|
//dbg_iac("size:%d %02x %02x", size, buf[0], buf[1]);
|
|
|
|
/* Cannot process IACs which wrap around buffer's end.
|
|
* Worst case: IAC SB NAWS with all bytes IAC-escaped = 13 bytes */
|
|
while (ts->wridx > TO_PTY_BUFSIZE - 14) {
|
|
uint64_t v64;
|
|
if (ts->wridx < ts->rdidx) {
|
|
/* |.......WRxRD.| */
|
|
/* Buffer is not wrapped */
|
|
break;
|
|
}
|
|
/* Possible situations: */
|
|
/* |xRD.......WRx| wrapped */
|
|
/* |xxxxxxxxRDWRx| wrapped and full! rdidx = wridx */
|
|
/* Rotate entire buffer 8 bytes back */
|
|
v64 = *(uint64_t*)BUF2PTY(ts);
|
|
memmove(BUF2PTY(ts), BUF2PTY(ts) + 8, TO_PTY_BUFSIZE - 8);
|
|
*(uint64_t*)(BUF2PTY(ts) + TO_PTY_BUFSIZE - 8) = v64;
|
|
ts->wridx -= 8; /* can't underflow */
|
|
buf -= 8;
|
|
BUF2PTY_DEC(ts->rdidx, 8); /* can underflow, use DEC() */
|
|
}
|
|
|
|
if (buf[1] == IAC) /* IAC-IAC: we have something to write */
|
|
return size;
|
|
|
|
if (buf[1] >= 240 && buf[1] <= 249) {
|
|
/* 2-byte commands (240..250 and 255):
|
|
* IAC IAC (255) Literal 255.
|
|
* IAC SE (240) End of subnegotiation. Treated as NOP.
|
|
* IAC NOP (241) NOP.
|
|
* IAC BRK (243) Break. Like serial line break. TODO via tcsendbreak()?
|
|
* IAC AYT (246) Are you there.
|
|
* These don't look useful:
|
|
* IAC DM (242) Data mark. What is this?
|
|
* IAC IP (244) Suspend, interrupt or abort the process. (Ancient cousin of ^C).
|
|
* IAC AO (245) Abort output. "You can continue running, but do not send me the output".
|
|
* IAC EC (247) Erase character. The receiver should delete the last received char.
|
|
* IAC EL (248) Erase line. The receiver should delete everything up to last newline.
|
|
* IAC GA (249) Go ahead. For half-duplex lines: "now you talk".
|
|
*/
|
|
if (buf[1] == AYT && ts->sibling) /* notify other pipe that AYT was seen */
|
|
ts->sibling->respond_to_AYT = 1;
|
|
/* NOP (241). Ignore (putty keepalive, etc) */
|
|
/* All other 2-byte commands also treated as NOPs here */
|
|
increment = 2;
|
|
goto inc;
|
|
}
|
|
if (size <= 2) {
|
|
/* only 2 bytes of the longer IAC is in the buffer */
|
|
goto cant_write; /* incomplete, can't process */
|
|
}
|
|
if (buf[1] == SB) {
|
|
if (buf[2] == TELOPT_NAWS) {
|
|
// IAC,SB,TELOPT_NAWS,<4 bytes possibly IAC-escaped>,IAC,SE
|
|
struct {
|
|
struct winsize ws;
|
|
int iac_cnt;
|
|
} s;
|
|
unsigned char *p;
|
|
unsigned char byte45, byte67, byte89;
|
|
|
|
// The usual: IAC,SB,TELOPT_NAWS,w,w,h,h (IAC,SE later): 7 + 2 = 9 bytes
|
|
// 255*HH: IAC,SB,TELOPT_NAWS,0,255,255,h,h: 8 bytes (10 with IAC,SE)
|
|
// The worst: IAC,SB,TELOPT_NAWS,w,w,w,w,h,h,h,h (four IACs): 11 bytes (not counting IAC,SE)
|
|
// We can't simply check for size < 11:
|
|
// will mishandle IAC,SB,TELOPT_NAWS,w,w,h,h,IAC,SE,'A' (10 bytes)
|
|
// the write of 'A' (ordinary visible char) can be delayed!
|
|
// Also mishandles 255*HH case (10 bytes) by delaying its processing
|
|
// until at least one more byte after it is received and size becomes >= 11.
|
|
if (size < 9) // postpone parsing until have 9+ bytes
|
|
goto cant_write;
|
|
memset(&s, 0, sizeof(s)); // pixel sizes are set to 0
|
|
//s.iac_cnt = 0; //done
|
|
p = buf + 3;
|
|
byte45 = read_byte_unescaping_IAC(&s.iac_cnt, &p);
|
|
byte67 = read_byte_unescaping_IAC(&s.iac_cnt, &p);
|
|
byte89 = read_byte_unescaping_IAC(&s.iac_cnt, &p); // fetches at most byte#9 - allowed by size
|
|
// If any one of these is IAC, the NAWS seq must be at least 10 bytes.
|
|
// IOW: it can't be case 'A' above. *Can* postpone if size == 10!
|
|
if (size < 9 + s.iac_cnt) // if IAC was seen: postpone parsing until have 10+ bytes
|
|
goto cant_write; // if 2+ IACs seen: postpone parsing until have 11+ bytes
|
|
s.ws.ws_col = (byte45 << 8) | byte67;
|
|
s.ws.ws_row = (byte89 << 8) | read_byte_unescaping_IAC(&s.iac_cnt, &p); // fetches _at most_ byte#11 (if four IACs)
|
|
|
|
if (s.ws.ws_col != 0 && s.ws.ws_row != 0) // don't provoke bugs elsewhere with "zero-sized screen"
|
|
ioctl(ts->write_fd, TIOCSWINSZ, (char *)&s.ws);
|
|
log1("pfd:%d window size:%dx%d", ts->write_fd, s.ws.ws_row, s.ws.ws_col);
|
|
increment = p - buf;
|
|
goto inc;
|
|
// trailing IAC,SE will be eaten separately, as 2-byte NOP
|
|
}
|
|
//fixme: skip them correctly
|
|
/* else: other subnegs not supported yet */
|
|
}
|
|
|
|
/* Assume it is a 3-byte WILL/WONT/DO/DONT 251..254 command and skip it */
|
|
dbg("ignoring IAC,%02x,%02x", buf[1], buf[2]);
|
|
increment = 3;
|
|
goto inc;
|
|
}
|
|
|
|
/* Write some buf data to pty, processing IACs.
|
|
* Update wridx and size. Return < 0 on error.
|
|
*/
|
|
static int net_to_pty__write(void *this)
|
|
{
|
|
//connection_t *conn = this;
|
|
net_to_pty_t *ts = this;
|
|
unsigned wr;
|
|
ssize_t rc;
|
|
unsigned char *buf;
|
|
unsigned char *found;
|
|
|
|
if (ts->write_fd < 0) /* did slave close its pty? */
|
|
return 0;
|
|
|
|
buf = BUF2PTY(ts) + ts->wridx;
|
|
wr = MIN(TO_PTY_BUFSIZE - ts->wridx, ts->size);
|
|
/* wr is at least 1 here */
|
|
|
|
found = memchr(buf, IAC, wr);
|
|
if (found == buf) {
|
|
/* The first char is IAC.
|
|
* should_poll_write_fd() ensures we are only called this way
|
|
* if there are two IACs.
|
|
* It also ensures the buffer is not wrapping within 7 chars.
|
|
* Write one IAC. If that works, skip both.
|
|
*/
|
|
//TODO: advance ptr by one, and memchr up to _next_ IAC (if any):
|
|
//this would write more data
|
|
rc = safe_write(ts->write_fd, buf, 1);
|
|
if (rc > 0) {
|
|
//dbg_iac("wrote: IAC");
|
|
ts->wridx += 2; /* this can't overflow */
|
|
ts->size -= 2;
|
|
}
|
|
/* Leave it to pty2net side to deal with closing pty on errors
|
|
* (it'll see them when it tries to read pty).
|
|
*/
|
|
return 0; /* "didn't write anything" */
|
|
}
|
|
/* No leading IACs: found != buf.
|
|
* IOW: there is a "prefix" of non-IAC chars.
|
|
* Write only them, and return.
|
|
*/
|
|
if (found)
|
|
wr = found - buf;
|
|
|
|
/* We map \r\n ==> \r for pragmatic reasons:
|
|
* many client implementations send \r\n when
|
|
* the user hits the CarriageReturn key.
|
|
* See RFC 1123 3.3.1 Telnet End-of-Line Convention.
|
|
*/
|
|
found = memchr(buf, '\r', wr);
|
|
if (found)
|
|
wr = found - buf + 1; /* write up to and including \r */
|
|
rc = safe_write(ts->write_fd, buf, wr);
|
|
if (rc <= 0)
|
|
return 0; /* "didn't write anything" */
|
|
//dbg_iac("wrote: %s", bin_to_hex(buf, rc));
|
|
/* check is needed: imagine that write was _short_ */
|
|
if (buf[rc - 1] == '\r') /* last written byte was CR? */
|
|
ts->skip_LF_or_NUL = 1;
|
|
|
|
BUF2PTY_INC(ts->wridx, rc);
|
|
ts->size -= rc;
|
|
if (ts->size == 0) { /* very typical */
|
|
/* Avoid buffer wrapping most of the time (-> have bigger writes) */
|
|
//dbg_buffer("zero size");
|
|
ts->rdidx = 0;
|
|
ts->wridx = 0;
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/* Check if buffer has space to read into */
|
|
static int net_to_pty__should_poll_read_fd(void *this)
|
|
{
|
|
//connection_t *conn = this;
|
|
net_to_pty_t *ts = this;
|
|
|
|
/* the sibling may have closed our ptyfd after getting 10 EIO's */
|
|
if (ts->write_fd < 0
|
|
|| ts->shell_pid < 0 /* -K option, and our pty's pid has exited */
|
|
) {
|
|
if (ts->sibling) {
|
|
/* do not close our netfd, it's in use by sibling */
|
|
ts->read_fd = -1;
|
|
}
|
|
dbg_close("%s:%d: remove_and_free_to_pty:%p wr:%d pid:%d",
|
|
__func__, __LINE__, ts, ts->write_fd, ts->shell_pid);
|
|
remove_and_free_to_pty(ts);
|
|
return -1; /* "don't use me anymore, I'm gone" */
|
|
}
|
|
|
|
if (ts->read_fd < 0) { /* we've seen EOF/error on netfd */
|
|
dbg_close("EOF on netfd was seen, ts->size:%d", ts->size);
|
|
if (ts->size == 0) { /* we wrote everything */
|
|
unsigned rem;
|
|
/* close ptyfd, but after a 20 ms pause */
|
|
|
|
/* pty has a design problem: close(master_ptyfd)
|
|
* is defined as causing hangup on slave pty.
|
|
* Which discards all currently buffered unread data
|
|
* (in our case, all data we just wrote).
|
|
* usleep(20000) is a crude solution.
|
|
* A better one (does not block other conns):
|
|
*/
|
|
dbg_close("going to close ptyfd:%d deadline_us:%u",
|
|
ts->write_fd, ts->deadline_us);
|
|
if (!ts->deadline_us) {
|
|
fabricate_ctrl_D_on_pty(ts->write_fd);
|
|
ts->deadline_us = (monotonic_us() + 20000) | 1;
|
|
rem = 20000;
|
|
} else {
|
|
rem = ts->deadline_us - monotonic_us();
|
|
}
|
|
dbg_close("until ptyfd_close:%d", rem);
|
|
if (rem <= 20000) {
|
|
ioloop_decrease_current_timeout(ts->io, rem);
|
|
return 0; /* "do not read" */
|
|
}
|
|
/* rem undeflowed (is "negative"): we waited at least 1000us */
|
|
dbg_close("EOF on netfd, closing ptyfd:%d", ts->write_fd);
|
|
if (ts->sibling)
|
|
ts->sibling->read_fd = -1;
|
|
remove_and_free_to_pty(ts); /* closes ts->write_fd (ptyfd) */
|
|
return -1; /* "don't use me anymore, I'm gone" */
|
|
}
|
|
return 0; /* "don't want to read" */
|
|
}
|
|
|
|
return ts->size < TO_PTY_BUFSIZE;
|
|
}
|
|
|
|
/* Read from socket to buffer, stripping trailing NUL if present */
|
|
static int net_to_pty__read(void *this)
|
|
{
|
|
net_to_pty_t *ts = this;
|
|
ssize_t count;
|
|
int avail;
|
|
|
|
/* Calculate available space and contiguous segment */
|
|
avail = TO_PTY_BUFSIZE - ts->size;
|
|
//if (avail <= 0)
|
|
// return 0; /* buffer full */
|
|
// ioloop logic ensures this is false
|
|
|
|
/* Read into contiguous segment from rdidx */
|
|
count = MIN(TO_PTY_BUFSIZE - ts->rdidx, avail);
|
|
count = safe_read(ts->read_fd, BUF2PTY(ts) + ts->rdidx, count);
|
|
if (count <= 0) {
|
|
dbg_close("EOF/error on netfd:%d sibling:%p", ts->read_fd, ts->sibling);
|
|
/* There is no way to signal to pty that input is in "error state",
|
|
* therefore treat both EOF and error the same.
|
|
*/
|
|
if (!ts->sibling)
|
|
close(ts->read_fd); /* close netfd if not in use by sibling */
|
|
ts->read_fd = -1;
|
|
return 0; /* "didn't read anything" */
|
|
}
|
|
|
|
ts->size += count;
|
|
BUF2PTY_INC(ts->rdidx, count);
|
|
|
|
return count;
|
|
}
|
|
|
|
static net_to_pty_t *new_net_to_pty(int from, int to)
|
|
{
|
|
net_to_pty_t *this = xzalloc(sizeof(*this) + TO_PTY_BUFSIZE);
|
|
this->should_poll_read_fd = net_to_pty__should_poll_read_fd;
|
|
this->should_poll_write_fd = net_to_pty__should_poll_write_fd;
|
|
this->read = net_to_pty__read;
|
|
this->write = net_to_pty__write;
|
|
this->read_fd = from;
|
|
this->write_fd = to;
|
|
/* indexes and size are all 0 */
|
|
return this;
|
|
}
|
|
|
|
static int pty_to_net__should_poll_read_fd(void *this)
|
|
{
|
|
//connection_t *conn = this;
|
|
pty_to_net_t *ts = this;
|
|
|
|
if (ts->read_fd < 0 /* we saw fatal read error before */
|
|
|| ts->shell_pid < 0 /* -K option, and our pty's pid has exited */
|
|
) {
|
|
if (ts->size == 0) { /* output flushed? */
|
|
remove_and_free_to_net(ts);
|
|
return -1; /* "don't use me anymore, I'm gone" */
|
|
}
|
|
return 0; /* "don't read" */
|
|
}
|
|
if (ts->eio_count != 0) {
|
|
unsigned rem;
|
|
|
|
//if (ts->eio_count >= 10)
|
|
// return 0; /* "do not read" */
|
|
//^^^ can't reach, caught by "ts->read_fd < 0" above.
|
|
|
|
/* last read was EIO. Still waiting before retry? */
|
|
rem = ts->deadline_us - monotonic_us();
|
|
if (rem <= 1000) {
|
|
/* tell io loop that poll timeout should now be "rem" us, not infinity */
|
|
ioloop_decrease_current_timeout(ts->io, rem);
|
|
return 0; /* "do not read me (yet)" */
|
|
}
|
|
/* else: rem underflowed: 1000us passed, can try reading again */
|
|
}
|
|
return ts->size < TO_NET_BUFSIZE;
|
|
}
|
|
|
|
/* Read from pty to buffer, handling vhangup() EIO retries */
|
|
static int pty_to_net__read(void *this)
|
|
{
|
|
//connection_t *conn = this;
|
|
pty_to_net_t *ts = this;
|
|
ssize_t count;
|
|
int avail;
|
|
|
|
/* Calculate available space and contiguous segment */
|
|
avail = TO_NET_BUFSIZE - ts->size;
|
|
//if (avail <= 0)
|
|
// return 0; /* buffer full */
|
|
// io loop logic ensures this is false
|
|
|
|
/* Read into contiguous segment from rdidx */
|
|
count = MIN(TO_NET_BUFSIZE - ts->rdidx, avail);
|
|
count = safe_read(ts->read_fd, BUF2NET(ts) + ts->rdidx, count);
|
|
if (count <= 0) {
|
|
if (count < 0) {
|
|
if (errno == EAGAIN)
|
|
return 0;
|
|
/* login process might call vhangup(),
|
|
* which causes intermittent EIOs on read above
|
|
* (observed on kernel 4.12.0, not seen on 5.18.0).
|
|
* Try up to 10*1000 us.
|
|
*/
|
|
if (errno == EIO) {
|
|
ts->eio_count++;
|
|
dbg_close("EIO ptyfd:%d ts->eio_count:%d %06u",
|
|
ts->read_fd, ts->eio_count,
|
|
(unsigned)(monotonic_us() % 1000000)
|
|
);
|
|
if (ts->eio_count >= 10)
|
|
goto close_ptyfd;
|
|
ts->deadline_us = monotonic_us() + 1000;
|
|
return 0; /* "read nothing" */
|
|
}
|
|
dbg_close("error on ptyfd:%d %m", ts->read_fd);
|
|
/* (what other read errors from pty are possible, apart from EIO?) */
|
|
ts->eio_count = 10; /* "fatally bad error" */
|
|
goto close_ptyfd;
|
|
}
|
|
/* EOF. (Doesn't happen with master ptys on Linux when slave closes - always EIO instead?) */
|
|
dbg_close("EOF on ptyfd:%d", ts->read_fd);
|
|
ts->eio_count = 0;
|
|
close_ptyfd:
|
|
dbg_close("closing ptyfd:%d", ts->read_fd);
|
|
close(ts->read_fd);
|
|
if (ts->sibling)
|
|
/* net2pty pipe needs to close (nowhere to write its data) */
|
|
ts->sibling->write_fd = -1;
|
|
ts->read_fd = -1;
|
|
/* Returning -1 here would mean "do not try writing to net", which is wrong */
|
|
return 0; /* EOF or error, but we do not prevent draining to net */
|
|
}
|
|
ts->eio_count = 0;
|
|
|
|
ts->size += count;
|
|
BUF2NET_INC(ts->rdidx, count);
|
|
|
|
return count;
|
|
}
|
|
|
|
static int pty_to_net__should_poll_write_fd(void *this)
|
|
{
|
|
pty_to_net_t *ts = this;
|
|
if (ts->size == 0) {
|
|
/* Wrote everything and pty is dead? */
|
|
if (ts->read_fd < 0) {
|
|
dbg_close("%s:%d: remove_and_free_to_net:%p rd:%d eio_count:%d",
|
|
__func__, __LINE__, ts, ts->read_fd, ts->eio_count);
|
|
if (ts->sibling)
|
|
ts->write_fd = -1;
|
|
remove_and_free_to_net(ts);
|
|
return -1; /* "I'm gone" */
|
|
}
|
|
}
|
|
return ts->size > 0 || ts->respond_to_AYT || ts->extra_byte_to_write;
|
|
}
|
|
|
|
/* Write to socket from buffer, escaping IAC bytes */
|
|
static int pty_to_net__write(void *this)
|
|
{
|
|
pty_to_net_t *ts = this;
|
|
ssize_t count;
|
|
unsigned char *buf;
|
|
unsigned char *iac_ptr;
|
|
size_t wr;
|
|
|
|
/* Did we fail to send a byte last time? */
|
|
if (ts->extra_byte_to_write) {
|
|
count = safe_write(ts->write_fd, &ts->extra_byte_to_write, 1);
|
|
if (count == 1)
|
|
ts->extra_byte_to_write = 0;
|
|
goto ret;
|
|
}
|
|
|
|
if (ts->size == 0) {
|
|
if (ts->respond_to_AYT) { /* other side pinged us? */
|
|
/* Send back evidence that AYT was seen: IAC NOP */
|
|
static const char ayt_response[2] = { IAC, NOP };
|
|
count = safe_write(ts->write_fd, ayt_response, 2);
|
|
if (count >= 1) {
|
|
if (count == 1) /* goddamit */
|
|
ts->extra_byte_to_write = NOP;
|
|
ts->respond_to_AYT = 0;
|
|
}
|
|
goto ret;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
buf = BUF2NET(ts) + ts->wridx;
|
|
wr = MIN(TO_NET_BUFSIZE - ts->wridx, ts->size);
|
|
dbg("rem:%d sz:%d ch:0x%02x", TO_NET_BUFSIZE - ts->wridx, ts->size, *buf);
|
|
|
|
if (*buf == IAC) {
|
|
static const char IACIAC[2] ALIGN1 = { IAC, IAC };
|
|
count = safe_write(ts->write_fd, IACIAC, 2);
|
|
if (count <= 1) {
|
|
if (count < 1) /* wrote nothing? */
|
|
goto ret;
|
|
/* Wrote only one byte of two. Amazing... */
|
|
ts->extra_byte_to_write = IAC;
|
|
}
|
|
/* Consume one byte from buffer */
|
|
count = 1;
|
|
} else {
|
|
/* Find next IAC or write up to end of segment */
|
|
iac_ptr = memchr(buf, IAC, wr);
|
|
if (iac_ptr)
|
|
wr = iac_ptr - buf;
|
|
count = safe_write(ts->write_fd, buf, wr);
|
|
if (count <= 0)
|
|
goto ret;
|
|
}
|
|
|
|
BUF2NET_INC(ts->wridx, count);
|
|
ts->size -= count;
|
|
if (ts->size == 0) { /* very typical */
|
|
/* Avoid buffer wrapping most of the time (-> have bigger writes) */
|
|
//dbg_buffer("zero size");
|
|
ts->rdidx = 0;
|
|
ts->wridx = 0;
|
|
}
|
|
ret:
|
|
if (count >= 0)
|
|
return count; /* "not error" */
|
|
if (errno == EAGAIN)
|
|
return 0; /* "not error" */
|
|
|
|
/* Assuming fatal write error */
|
|
/* If peer closes its read side with
|
|
* shutdown(SHUT_RD), we'll see EPIPE
|
|
* or ECONNRESET.
|
|
* (both were seen to occur in practice)
|
|
*/
|
|
if (ts->sibling) {
|
|
/* Sibling exists, don't close yet */
|
|
ts->read_fd = -1;
|
|
ts->write_fd = -1;
|
|
}
|
|
dbg_close("%s:%d: remove_and_free_to_net:%p", __func__, __LINE__, ts);
|
|
remove_and_free_to_net(ts);
|
|
return -1; /* "I'm gone" */
|
|
}
|
|
|
|
static pty_to_net_t *new_pty_to_net(int from, int to)
|
|
{
|
|
pty_to_net_t *this = xzalloc(sizeof(*this) + TO_NET_BUFSIZE);
|
|
this->should_poll_read_fd = pty_to_net__should_poll_read_fd;
|
|
this->should_poll_write_fd = pty_to_net__should_poll_write_fd;
|
|
this->read = pty_to_net__read;
|
|
this->write = pty_to_net__write;
|
|
this->read_fd = from;
|
|
this->write_fd = to;
|
|
/* indexes and size are all 0 */
|
|
return this;
|
|
}
|
|
|
|
#if !ENABLE_FEATURE_TELNETD_STANDALONE
|
|
#define make_new_session(io, sockrd) \
|
|
make_new_session(io)
|
|
#endif
|
|
static void make_new_session(ioloop_state_t *io, int sockrd)
|
|
{
|
|
IF_NOT_FEATURE_TELNETD_STANDALONE(enum { sockrd = 0 };)
|
|
const int sockwr = sockrd != 0 ? sockrd : 1;
|
|
const char *login_argv[2];
|
|
struct termios termbuf;
|
|
int ptyfd, pid;
|
|
char tty_name[GETPTY_BUFSIZE];
|
|
|
|
/* Got a new connection, set up a pty */
|
|
ptyfd = xgetpty(tty_name);
|
|
ndelay_on(ptyfd);
|
|
close_on_exec_on(ptyfd);
|
|
|
|
/* SO_KEEPALIVE by popular demand */
|
|
setsockopt_keepalive(sockrd);
|
|
ndelay_on(sockrd);
|
|
if (sockrd == 0) /* called with fd 0 (inetd mode?) */
|
|
ndelay_on(sockwr);
|
|
|
|
/* Make the telnet client understand we will echo characters so it
|
|
* should not do it locally. We don't tell the client to run linemode,
|
|
* because we want to handle line editing and tab completion and other
|
|
* stuff that requires char-by-char support. */
|
|
{
|
|
static const char iacs_to_send[] ALIGN1 = {
|
|
IAC, WILL, TELOPT_ECHO, // "I will echo your chars"
|
|
// (Not really, _we_ won't - our programs in pty usually
|
|
// handle that. In practice, this says: "do not echo
|
|
// your user's input chars back to him _on your side_".)
|
|
IAC, WILL, TELOPT_SGA, // "I assume full-duplex, won't send GA's"
|
|
//IAC, DO, TELOPT_ECHO, //WRONG: "can you echo my chars to me"??
|
|
IAC, DO, TELOPT_NAWS, // "can you send me terminal size data?"
|
|
// This requires telnetd.ctrlSQ.patch (incomplete):
|
|
//IAC, DO, TELOPT_LFLOW,
|
|
};
|
|
//Theoretically, our "WILL X" are requests and should only activate when client responds with "DO X".
|
|
//However, we do not wait/check for "DO"s. Why?
|
|
//There is nothing to "activate" on our side for TELOPT_ECHO.
|
|
//For TELOPT_SGA, we don't even have code to support sending/understanding GAs,
|
|
//so SGA is "always activated".
|
|
/* Just stuff it into TCP stream! (no error check...) */
|
|
safe_write(sockwr, iacs_to_send, sizeof(iacs_to_send));
|
|
}
|
|
|
|
fflush_all();
|
|
pid = vfork(); /* NOMMU-friendly */
|
|
if (pid < 0) {
|
|
close(ptyfd);
|
|
close(sockrd);
|
|
bb_simple_perror_msg("vfork");
|
|
return;
|
|
}
|
|
if (pid > 0) {
|
|
/* Parent */
|
|
pty_to_net_t *to_net;
|
|
net_to_pty_t *to_pty;
|
|
|
|
to_net = new_pty_to_net(ptyfd, sockwr);
|
|
to_pty = new_net_to_pty(sockrd, ptyfd);
|
|
dbg("to_net:%p to_pty:%p", to_net, to_pty);
|
|
to_pty->sibling = to_net;
|
|
to_net->sibling = to_pty;
|
|
to_net->shell_pid = pid;
|
|
to_pty->shell_pid = pid;
|
|
ioloop_insert_conn(io, (connection_t *)to_net);
|
|
ioloop_insert_conn(io, (connection_t *)to_pty);
|
|
return;
|
|
}
|
|
|
|
/* Child */
|
|
/* Careful - we are after vfork! */
|
|
|
|
/* Restore default signal handling ASAP */
|
|
bb_signals((1 << SIGCHLD) + (1 << SIGPIPE), SIG_DFL);
|
|
|
|
/* Make new session and process group */
|
|
//pid = getpid(); // redundant, setsid gives us our pid
|
|
pid = setsid();
|
|
|
|
/* Open the child's side of the pty */
|
|
/* NB: setsid() disconnects from any previous ctty's. Therefore
|
|
* we must open child's side of the tty AFTER setsid! */
|
|
close(0);
|
|
xopen(tty_name, O_RDWR); /* fd 0: becomes our ctty */
|
|
xdup2(0, 1);
|
|
xdup2(0, 2);
|
|
tcsetpgrp(0, pid); /* switch this tty's process group to us */
|
|
|
|
if (ENABLE_FEATURE_UTMP) {
|
|
len_and_sockaddr *lsa = get_peer_lsa(sockrd);
|
|
char *hostname = NULL;
|
|
if (lsa) {
|
|
hostname = xmalloc_sockaddr2dotted(&lsa->u.sa);
|
|
free(lsa);
|
|
}
|
|
write_new_utmp(pid, LOGIN_PROCESS, tty_name, /*username:*/ "LOGIN", hostname);
|
|
IF_FEATURE_CLEAN_UP(free(hostname);)
|
|
}
|
|
|
|
/* The pseudo-terminal allocated to the client is configured to operate
|
|
* in cooked mode, and with XTABS CRMOD enabled (see tty(4)) */
|
|
tcgetattr(0, &termbuf);
|
|
termbuf.c_lflag |= ECHO; /* if we use readline we dont want this */
|
|
termbuf.c_oflag |= ONLCR | XTABS;
|
|
termbuf.c_iflag |= ICRNL;
|
|
termbuf.c_iflag &= ~IXOFF;
|
|
/*termbuf.c_lflag &= ~ICANON;*/
|
|
tcsetattr_stdin_TCSANOW(&termbuf);
|
|
|
|
/* Uses FILE-based I/O to stdout, but does fflush_all(),
|
|
* so should be safe with vfork.
|
|
* I fear, though, that some users will have ridiculously big
|
|
* issue files, and they may block writing to fd 1,
|
|
* (parent is supposed to read it, but parent waits
|
|
* for vforked child to exec!) */
|
|
print_login_issue(G.issuefile, tty_name);
|
|
|
|
/* Exec shell / login / whatever */
|
|
login_argv[0] = G.loginpath;
|
|
login_argv[1] = NULL;
|
|
/* exec busybox applet (if PREFER_APPLETS=y), if that fails,
|
|
* exec external program.
|
|
* NB: sockrd is either 0 or has CLOEXEC set on it.
|
|
* ptyfd has CLOEXEC set on it too. These two fds will be closed here.
|
|
*/
|
|
BB_EXECVP(G.loginpath, (char **)login_argv);
|
|
/* _exit is safer with vfork, and we shouldn't send message
|
|
* to remote clients anyway */
|
|
_exit_FAILURE(); /*bb_perror_msg_and_die("execv %s", G.loginpath);*/
|
|
}
|
|
|
|
|
|
#if ENABLE_FEATURE_TELNETD_STANDALONE
|
|
struct accept_conn {
|
|
TELNET_CONNECTION
|
|
};
|
|
|
|
static int accept_conn__can_accept(void *this UNUSED_PARAM)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
static int accept_conn__accept(void *this)
|
|
{
|
|
struct accept_conn *ts = this;
|
|
int fd;
|
|
|
|
dbg("%s:%d", __func__, __LINE__);
|
|
fd = accept(ts->read_fd, NULL, NULL);
|
|
//TODO: accept4(SOCK_NONBLOCK) - can remove ndelay_on() in make_new_session
|
|
if (fd >= 0) {
|
|
close_on_exec_on(fd);
|
|
/* Create two new pipes and insert them into ioloop */
|
|
make_new_session(ts->io, fd);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int accept_conn__return_zero(void *this UNUSED_PARAM)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static struct accept_conn *new_accept_conn(int fd)
|
|
{
|
|
struct accept_conn *this = xzalloc(sizeof(*this));
|
|
this->should_poll_read_fd = accept_conn__can_accept;
|
|
this->should_poll_write_fd = accept_conn__return_zero;
|
|
this->read = accept_conn__accept;
|
|
//this->write = accept_conn__return_zero; //never called
|
|
this->read_fd = fd;
|
|
this->write_fd = -1;
|
|
return this;
|
|
}
|
|
#endif
|
|
|
|
static void handle_sigchld(int sig UNUSED_PARAM)
|
|
{
|
|
int save_errno = errno;
|
|
|
|
/* Looping: more than one child may have exited */
|
|
while (1) {
|
|
pid_t pid;
|
|
struct telnet_conn *conn;
|
|
|
|
pid = wait_any_nohang(NULL);
|
|
if (pid <= 0)
|
|
break;
|
|
update_utmp_DEAD_PROCESS(pid);
|
|
conn = (void*)G.io.conns;
|
|
while (conn) {
|
|
if (conn->shell_pid == pid) {
|
|
/* mark the conn to close soon */
|
|
conn->shell_pid = -1;
|
|
}
|
|
conn = (void*)conn->next;
|
|
}
|
|
}
|
|
|
|
errno = save_errno;
|
|
}
|
|
|
|
#if ENABLE_FEATURE_TELNETD_SELFTEST_DEBUG
|
|
|
|
static char *bin_to_hex(const void *hash_value, unsigned hash_length)
|
|
{
|
|
/* xzalloc zero-terminates */
|
|
char *hex_value = xzalloc((hash_length * 2) + 1);
|
|
bin2hex(hex_value, (char*)hash_value, hash_length);
|
|
return auto_string(hex_value);
|
|
}
|
|
|
|
static int test_vhangup(void)
|
|
{
|
|
char tty_name[GETPTY_BUFSIZE];
|
|
int master_fd;
|
|
int last_rc = 999;
|
|
int last_errno = 0;
|
|
unsigned long long last_change_ns, base_ns;
|
|
|
|
bb_simple_info_msg("selftest: pty vhangup() behavior");
|
|
|
|
master_fd = xgetpty(tty_name);
|
|
ndelay_on(master_fd);
|
|
|
|
fflush_all();
|
|
if (xfork() == 0) {
|
|
/* Child */
|
|
//int slave_fd;
|
|
int fd;
|
|
|
|
/* vhangup() sends SIGHUP to the session, ignore it */
|
|
signal(SIGHUP, SIG_IGN);
|
|
|
|
applet_name = "vhangup child";
|
|
|
|
close(master_fd);
|
|
setsid();
|
|
/*slave_fd =*/ xopen(tty_name, O_RDWR);
|
|
|
|
fd = open("/dev/tty", O_RDWR);
|
|
if (fd >= 0) {
|
|
bb_simple_info_msg("/dev/tty opened OK - we have a ctty");
|
|
close(fd);
|
|
} else {
|
|
bb_simple_perror_msg("/dev/tty");
|
|
}
|
|
|
|
bb_simple_info_msg("sleeping 0.2 sec before vhangup()");
|
|
usleep(200*1000);
|
|
|
|
bb_simple_info_msg("calling vhangup()");
|
|
vhangup();
|
|
|
|
fd = open("/dev/tty", O_RDWR);
|
|
if (fd >= 0) {
|
|
bb_simple_info_msg("/dev/tty opened OK - we still have a ctty");
|
|
close(fd);
|
|
} else {
|
|
bb_simple_perror_msg("/dev/tty");
|
|
}
|
|
|
|
bb_simple_info_msg("sleeping 0.2 sec after vhangup()");
|
|
usleep(200*1000);
|
|
|
|
bb_simple_error_msg_and_die("exiting");
|
|
}
|
|
|
|
/* Parent */
|
|
bb_simple_info_msg("nonblocking read() from pty master in a loop...");
|
|
last_change_ns = monotonic_ns();
|
|
|
|
base_ns = monotonic_ns();
|
|
for (;;) {
|
|
int rc;
|
|
char buf[1];
|
|
unsigned long long now_ns;
|
|
|
|
errno = 0;
|
|
rc = read(master_fd, buf, 1);
|
|
now_ns = monotonic_ns() - base_ns;
|
|
|
|
if (rc != last_rc || errno != last_errno) {
|
|
bb_error_msg("t=%lluns: read()=%d errno=%d(%s)",
|
|
now_ns,
|
|
rc, errno, strerror(errno));
|
|
last_rc = rc;
|
|
last_errno = errno;
|
|
last_change_ns = now_ns;
|
|
}
|
|
|
|
/* Exit if no change for a few seconds */
|
|
if ((now_ns - last_change_ns) > 1000*1000*1000) {
|
|
bb_simple_info_msg("no change for 1 second, loop stopped");
|
|
break;
|
|
}
|
|
|
|
usleep(100); /* 100us polling - fast enough to catch transitions */
|
|
}
|
|
|
|
close(master_fd);
|
|
waitpid(-1, NULL, 0);
|
|
|
|
bb_simple_error_msg("vhangup test completed");
|
|
return 0;
|
|
}
|
|
static int test_net_to_pty_data_integrity(void)
|
|
{
|
|
enum { TESTDATA_SIZE = 16 * 1024 * 1024 };
|
|
unsigned char *input_data;
|
|
unsigned char *expected_data;
|
|
int input_size;
|
|
int expected_size;
|
|
uint32_t randbits;
|
|
uint8_t expected_hash32[32];
|
|
uint8_t hash_in_pty32[32];
|
|
uint8_t dummy_byte;
|
|
int sock_pair[2];
|
|
char tty_name[GETPTY_BUFSIZE];
|
|
int ptyfd;
|
|
int i;
|
|
int waitstatus, exitcode;
|
|
|
|
bb_simple_info_msg("selftest: net_to_pty");
|
|
|
|
/* Allocate buffer with paranoia space */
|
|
input_data = xzalloc(TESTDATA_SIZE + 64);
|
|
|
|
/* Generate nightmare input data:
|
|
* - Mostly random bytes
|
|
* - IAC bytes sprinkled in (1 in 16 probability)
|
|
* - IAC IAC sequences (1 in 32)
|
|
* - IAC SB TELOPT_NAWS sequences(1 in 32)
|
|
* - All sorts of IAC commands with random parameters
|
|
* - Malformed sequences
|
|
*/
|
|
randbits = 0;
|
|
for (i = 0; i < TESTDATA_SIZE;) {
|
|
unsigned _32possibilities;
|
|
if (randbits == 0)
|
|
randbits = random();
|
|
_32possibilities = (randbits & 0x1f);
|
|
randbits >>= 5;
|
|
if (_32possibilities == 3 && (randbits & 0x7f) == 0) { /* 1 in 32*127=4*1k prob: long run of printables */
|
|
if (i < TESTDATA_SIZE - 4*1024) {
|
|
int end = i + ((4*1024 - 1) & random());
|
|
while (i < end)
|
|
input_data[i++] = (random() & 0x3f) + 0x20;
|
|
continue;
|
|
}
|
|
}
|
|
if (_32possibilities == 3) { /* CR,LF/NUL: 1 in 32 prob */
|
|
input_data[i++] = '\r';
|
|
input_data[i++] = randbits & 1 ? '\n' : '\0';
|
|
} else
|
|
if (_32possibilities == 2) { /* NAWS: 1 in 32 prob */
|
|
input_data[i++] = IAC;
|
|
input_data[i++] = SB;
|
|
input_data[i++] = TELOPT_NAWS;
|
|
} else
|
|
if (_32possibilities == 1) { /* IAC: 1 in 32 prob */
|
|
input_data[i++] = IAC;
|
|
if (random() & 1) /* IAC IAC: 1 in 64 prob */
|
|
input_data[i++] = IAC;
|
|
} else {
|
|
input_data[i++] = random();
|
|
}
|
|
}
|
|
input_size = TESTDATA_SIZE;
|
|
bb_error_msg("generated %d bytes of test data", input_size);
|
|
|
|
/* Allocate expected output buffer */
|
|
expected_data = xmalloc(TESTDATA_SIZE);
|
|
|
|
/* Process input_data simulating net_to_pty transformations:
|
|
* - IAC IAC -> single IAC
|
|
* - IAC SB TELOPT_NAWS [4 bytes] IAC SE -> stripped
|
|
* - Other IAC sequences -> stripped
|
|
* - \r\n -> \r (skip the \n)
|
|
* - \r\0 -> \r (skip the \0)
|
|
*/
|
|
memset(input_data + input_size, 0, 64);
|
|
expected_size = 0;
|
|
i = 0;
|
|
while (i < input_size) {
|
|
/* Tail of 64 extra zero bytes allows to safely read beyond the end */
|
|
if (input_data[i] == IAC) {
|
|
if (input_data[i + 1] == IAC) {
|
|
/* IAC IAC -> single IAC */
|
|
expected_data[expected_size++] = IAC;
|
|
i += 2;
|
|
continue;
|
|
}
|
|
if (input_data[i + 1] >= 240 && input_data[i + 1] <= 249) {
|
|
/* 2-byte IAC command (NOP, etc.) - skip */
|
|
i += 2;
|
|
continue;
|
|
}
|
|
if (input_data[i + 1] == SB) {
|
|
/* IAC SB ... skip subnegotiation */
|
|
if (input_data[i + 2] == TELOPT_NAWS) {
|
|
//TODO: simulate unusual NAWS
|
|
/* IAC SB TELOPT_NAWS [4 bytes] */
|
|
i += 3; /* skip IAC SB TELOPT_NAWS */
|
|
/* Skip 4 bytes of window size */
|
|
i += 4;
|
|
continue;
|
|
// } else {
|
|
//should do: /* Other subneg, skip to IAC SE */ but that's not what telnetd code is doing yet...
|
|
}
|
|
}
|
|
/* Assumed 3-byte IAC WILL/WONT/DO/DONT - skip */
|
|
i += 3;
|
|
continue;
|
|
}
|
|
if (input_data[i] == '\r') {
|
|
/* Write \r, check if followed by \n or \0 */
|
|
expected_data[expected_size++] = '\r';
|
|
i++;
|
|
if (input_data[i] == '\n' || input_data[i] == '\0')
|
|
i++; /* skip \n or \0 after \r */
|
|
continue;
|
|
}
|
|
/* Regular byte */
|
|
expected_data[expected_size++] = input_data[i++];
|
|
}
|
|
sha256_block(expected_data, expected_size, expected_hash32);
|
|
bb_error_msg("expected %d bytes after net_to_pty processing. hash:%s", expected_size, bin_to_hex(expected_hash32, 32));
|
|
#if SAVE_NET2PTY_EXPECTED
|
|
{
|
|
int fd = xopen("expected.bin", O_WRONLY | O_CREAT | O_TRUNC);
|
|
xwrite(fd, expected_data, expected_size);
|
|
close(fd);
|
|
bb_error_msg("wrote expected.bin");
|
|
}
|
|
#endif
|
|
free(expected_data);
|
|
expected_data = NULL; /* to catch use-after-free */
|
|
|
|
/* Create socketpair for network side */
|
|
if (socketpair(AF_UNIX, SOCK_STREAM, 0, sock_pair) < 0)
|
|
bb_simple_perror_msg_and_die("socketpair");
|
|
|
|
fflush_all();
|
|
if (xfork() == 0) {
|
|
/* Fork writer child: writes telnet data to socket in random chunks */
|
|
int written = 0;
|
|
close(sock_pair[0]); /* close read end */
|
|
|
|
applet_name = "tty input";
|
|
|
|
while (written < input_size) {
|
|
int chunk = (random() & 4095) + 1; /* 1 to 4096 bytes */
|
|
if (written + chunk > input_size)
|
|
chunk = input_size - written;
|
|
|
|
chunk = safe_write(sock_pair[1], input_data + written, chunk);
|
|
if (chunk > 0)
|
|
written += chunk;
|
|
|
|
/* Small random delay to vary timing */
|
|
if ((random() & 0xf) == 0)
|
|
usleep(random() & 0x3ff);
|
|
}
|
|
_exit(0);
|
|
}
|
|
close(sock_pair[1]); /* close write end */
|
|
|
|
free(input_data);
|
|
input_data = NULL; /* to catch use-after-free */
|
|
|
|
/* Create pty pair */
|
|
ptyfd = xgetpty(tty_name);
|
|
|
|
if (xfork() == 0) {
|
|
/* Fork reader child: reads from PTY slave */
|
|
int slave_fd;
|
|
int retry;
|
|
int n;
|
|
unsigned char read_buf[8192];
|
|
int total_read = 0;
|
|
struct termios termbuf;
|
|
sha256_ctx_t ctx;
|
|
#if SAVE_NET2PTY_ACTUAL
|
|
int out_fd = xopen("actual.bin", O_WRONLY | O_CREAT | O_TRUNC);
|
|
#endif
|
|
applet_name = "pty reader";
|
|
|
|
close(sock_pair[0]);
|
|
close(ptyfd);
|
|
|
|
slave_fd = xopen(tty_name, O_RDWR);
|
|
setsid(); /* this loses ctty (no tty signals ^C, ^Z, ^\; no SIGHUP on master close (probably?)) */
|
|
|
|
tcgetattr(slave_fd, &termbuf);
|
|
cfmakeraw(&termbuf);
|
|
tcsetattr(slave_fd, TCSANOW, &termbuf);
|
|
//bb_error_msg("tty_name:'%s'", tty_name);
|
|
|
|
/* Synchronize with master: "raw set, you can start writing" */
|
|
dummy_byte = '!';
|
|
safe_write(slave_fd, &dummy_byte, 1);
|
|
|
|
sha256_begin(&ctx);
|
|
/* Retry logic shows how master pty close looks on slave side:
|
|
* on kernel 5.18.0, I see EIO once, then (if I retry reads),
|
|
* I see EOFs (zero reads).
|
|
* What is not visible (but does happen) is that any
|
|
* unread-by-me buffered data is lost - something that
|
|
* wouldn't happen on pipes/socketpairs!
|
|
*/
|
|
retry = 0;
|
|
for (;;) {
|
|
n = safe_read(slave_fd, read_buf, sizeof(read_buf));
|
|
if (n == 0) {
|
|
retry++;
|
|
bb_error_msg("EOF on read(%d)", retry);
|
|
if (retry < 3) continue;
|
|
break; /* EOF (parent closed master) - expected */
|
|
}
|
|
if (n < 0) {
|
|
retry++;
|
|
bb_perror_msg("read(%d)", retry);
|
|
if (retry < 3) continue;
|
|
break; /* error (parent closed master) - expected */
|
|
}
|
|
/* If happens, probably kernel bug! */
|
|
if (retry != 0) bb_error_msg_and_die("READ DATA AFTER EOF/ERROR RETRY!!!");
|
|
#if SAVE_NET2PTY_ACTUAL
|
|
xwrite(out_fd, read_buf, n);
|
|
#endif
|
|
sha256_hash(&ctx, read_buf, n);
|
|
total_read += n;
|
|
// Test premature close on pty read side:
|
|
//if (total_read >= 128*1024) _exit(0);
|
|
}
|
|
|
|
sha256_end(&ctx, hash_in_pty32);
|
|
n = memcmp(hash_in_pty32, expected_hash32, 32);
|
|
bb_error_msg("received %d bytes, hash:%s%s", total_read, bin_to_hex(hash_in_pty32, 32), n ? " MISMATCH" : "");
|
|
_exit(!!n);
|
|
}
|
|
|
|
/* Parent: run the net_to_pty logic */
|
|
{
|
|
net_to_pty_t *conn;
|
|
ioloop_state_t *io;
|
|
int rc;
|
|
|
|
io = new_ioloop_state();
|
|
conn = new_net_to_pty(sock_pair[0], ptyfd);
|
|
ioloop_insert_conn(io, (void*)conn);
|
|
|
|
/* We must allow the pty child to change its tty to RAW
|
|
* before we start writing. Otherwise (it was observed),
|
|
* it can see a few \r -> \n remapped.
|
|
*/
|
|
safe_read(ptyfd, &dummy_byte, 1);
|
|
|
|
rc = ioloop_run(io);
|
|
bb_error_msg("ioloop_run:%d", rc);
|
|
|
|
/* This should be done inside ioloop. Check where possible: */
|
|
//free_connection(conn);
|
|
if (close(sock_pair[0]) == 0) /* should be EBADF */
|
|
bb_error_msg_and_die("BUG: net read side wasn't closed");
|
|
if (close(ptyfd) == 0)
|
|
bb_error_msg_and_die("BUG: pty write side wasn't closed");
|
|
|
|
free_ioloop_state(io);
|
|
}
|
|
|
|
/* Wait for all children */
|
|
exitcode = 0;
|
|
while (safe_waitpid(-1, &waitstatus, 0) > 0)
|
|
exitcode |= (waitstatus != 0);
|
|
|
|
bb_error_msg("pty_to_net test completed: %d", exitcode);
|
|
return exitcode;
|
|
}
|
|
|
|
static int test_pty_to_net_data_integrity(void)
|
|
{
|
|
enum { TESTDATA_SIZE = 16 * 1024 * 1024 };
|
|
unsigned char *input_data;
|
|
unsigned char *expected_data;
|
|
int input_size;
|
|
int expected_size;
|
|
uint32_t randbits;
|
|
uint8_t expected_hash32[32];
|
|
uint8_t hash_from_net32[32];
|
|
int sock_pair[2];
|
|
char tty_name[GETPTY_BUFSIZE];
|
|
int ptyfd;
|
|
int i;
|
|
int waitstatus, exitcode;
|
|
|
|
bb_simple_info_msg("selftest: pty_to_net");
|
|
|
|
/* Allocate buffer */
|
|
input_data = xzalloc(TESTDATA_SIZE);
|
|
|
|
/* Generate random data - this time we want lots of 0xFF (IAC) bytes
|
|
* to test IAC escaping (IAC -> IAC IAC)
|
|
*/
|
|
randbits = 0;
|
|
for (i = 0; i < TESTDATA_SIZE;) {
|
|
unsigned _32possibilities;
|
|
if (randbits == 0)
|
|
randbits = random();
|
|
_32possibilities = (randbits & 0x1f);
|
|
randbits >>= 5;
|
|
|
|
if (_32possibilities == 1 && (randbits & 0x7f) == 0) {
|
|
/* Long run of printables (1 in ~4k prob) */
|
|
if (i < TESTDATA_SIZE - 4*1024) {
|
|
int end = i + ((4*1024 - 1) & random());
|
|
while (i < end)
|
|
input_data[i++] = (random() & 0x3f) + 0x20;
|
|
continue;
|
|
}
|
|
}
|
|
if (_32possibilities == 1) {
|
|
/* IAC byte: 1 in 32 prob */
|
|
input_data[i++] = IAC;
|
|
} else {
|
|
input_data[i++] = random();
|
|
}
|
|
}
|
|
input_size = TESTDATA_SIZE;
|
|
bb_error_msg("generated %d bytes of test data", input_size);
|
|
|
|
/* Allocate expected output buffer (worst case: all IACs doubled) */
|
|
expected_data = xmalloc(TESTDATA_SIZE * 2);
|
|
|
|
/* Process input_data simulating pty_to_net transformations:
|
|
* - IAC (0xFF) -> IAC IAC (doubled)
|
|
* - All other bytes pass through unchanged
|
|
*/
|
|
expected_size = 0;
|
|
for (i = 0; i < input_size; i++) {
|
|
if (input_data[i] == IAC) {
|
|
expected_data[expected_size++] = IAC;
|
|
expected_data[expected_size++] = IAC;
|
|
} else {
|
|
expected_data[expected_size++] = input_data[i];
|
|
}
|
|
}
|
|
|
|
sha256_block(expected_data, expected_size, expected_hash32);
|
|
bb_error_msg("expected %d bytes after pty_to_net processing. hash:%s",
|
|
expected_size, bin_to_hex(expected_hash32, 32));
|
|
|
|
#if SAVE_PTY2NET_EXPECTED
|
|
{
|
|
int fd = xopen("expected.bin", O_WRONLY | O_CREAT | O_TRUNC);
|
|
xwrite(fd, expected_data, expected_size);
|
|
close(fd);
|
|
bb_error_msg("wrote expected.bin");
|
|
}
|
|
#endif
|
|
|
|
free(expected_data);
|
|
expected_data = NULL;
|
|
|
|
/* Create socketpair for network side */
|
|
if (socketpair(AF_UNIX, SOCK_STREAM, 0, sock_pair) < 0)
|
|
bb_simple_perror_msg_and_die("socketpair");
|
|
|
|
/* Create pty pair */
|
|
ptyfd = xgetpty(tty_name);
|
|
|
|
fflush_all();
|
|
if (xfork() == 0) {
|
|
/* Fork writer child: writes data to PTY slave */
|
|
int slave_fd;
|
|
int written = 0;
|
|
struct termios termbuf;
|
|
|
|
applet_name = "pty writer";
|
|
|
|
close(sock_pair[0]);
|
|
close(sock_pair[1]);
|
|
close(ptyfd);
|
|
|
|
slave_fd = xopen(tty_name, O_RDWR);
|
|
//setsid(); /* lose ctty */
|
|
|
|
/* Put PTY in raw mode */
|
|
tcgetattr(slave_fd, &termbuf);
|
|
cfmakeraw(&termbuf);
|
|
tcsetattr(slave_fd, TCSANOW, &termbuf);
|
|
|
|
while (written < input_size) {
|
|
int n = (random() & 4095) + 1; /* 1 to 4096 bytes */
|
|
if (n > input_size - written)
|
|
n = input_size - written;
|
|
n = safe_write(slave_fd, input_data + written, n);
|
|
if (n < 0)
|
|
bb_perror_msg_and_die("%s:%d: write error", __func__, __LINE__);
|
|
written += n;
|
|
/* Small random delay */
|
|
if ((random() & 0xf) == 0)
|
|
usleep(random() & 0x3ff);
|
|
}
|
|
_exit(0);
|
|
}
|
|
|
|
free(input_data);
|
|
input_data = NULL;
|
|
|
|
if (xfork() == 0) {
|
|
/* Fork reader child: reads from network socket */
|
|
int n;
|
|
unsigned char read_buf[8192];
|
|
int total_read = 0;
|
|
sha256_ctx_t ctx;
|
|
#if SAVE_PTY2NET_ACTUAL
|
|
int out_fd = xopen("actual.bin", O_WRONLY | O_CREAT | O_TRUNC);
|
|
#endif
|
|
applet_name = "net reader";
|
|
|
|
close(sock_pair[1]); /* close write end */
|
|
close(ptyfd);
|
|
|
|
sha256_begin(&ctx);
|
|
for (;;) {
|
|
n = safe_read(sock_pair[0], read_buf, sizeof(read_buf));
|
|
if (n <= 0) {
|
|
if (n < 0)
|
|
bb_simple_perror_msg("read");
|
|
break; /* EOF or error */
|
|
}
|
|
// To test what writer sees if we close read end:
|
|
//shutdown(sock_pair[0], SHUT_RD);
|
|
//sleep(2);
|
|
//_exit(1);
|
|
#if SAVE_PTY2NET_ACTUAL
|
|
xwrite(out_fd, read_buf, n);
|
|
#endif
|
|
sha256_hash(&ctx, read_buf, n);
|
|
total_read += n;
|
|
}
|
|
|
|
sha256_end(&ctx, hash_from_net32);
|
|
n = memcmp(hash_from_net32, expected_hash32, 32);
|
|
bb_error_msg("received %d bytes, hash:%s%s",
|
|
total_read, bin_to_hex(hash_from_net32, 32), n ? " MISMATCH" : "");
|
|
_exit(!!n);
|
|
}
|
|
|
|
close(sock_pair[0]); /* close read end */
|
|
|
|
/* Parent: run the pty_to_net logic */
|
|
{
|
|
pty_to_net_t *conn;
|
|
ioloop_state_t *io;
|
|
int rc;
|
|
|
|
io = new_ioloop_state();
|
|
|
|
conn = new_pty_to_net(ptyfd, sock_pair[1]);
|
|
ioloop_insert_conn(io, (void*)conn);
|
|
|
|
rc = ioloop_run(io);
|
|
bb_error_msg("ioloop_run:%d", rc);
|
|
|
|
/* This should be done inside ioloop. Check where possible: */
|
|
//free_connection(conn);
|
|
if (close(sock_pair[1]) == 0) /* should be EBADF */
|
|
bb_error_msg_and_die("BUG: net write side wasn't closed");
|
|
if (close(ptyfd) == 0)
|
|
bb_error_msg_and_die("BUG: pty read side wasn't closed");
|
|
|
|
free_ioloop_state(io);
|
|
}
|
|
|
|
/* Wait for all children */
|
|
exitcode = 0;
|
|
while (safe_waitpid(-1, &waitstatus, 0) > 0)
|
|
exitcode |= (waitstatus != 0);
|
|
|
|
bb_error_msg("pty_to_net test completed: %d", exitcode);
|
|
return exitcode;
|
|
}
|
|
|
|
static void selftest(void)
|
|
{
|
|
int exitcode = 0;
|
|
srandom(12345);
|
|
if (SELFTEST_VHANGUP) exitcode |= test_vhangup();
|
|
if (SELFTEST_NET2PTY) exitcode |= test_net_to_pty_data_integrity();
|
|
if (SELFTEST_PTY2NET) exitcode |= test_pty_to_net_data_integrity();
|
|
bb_error_msg("selftest completed: %d", exitcode);
|
|
_exit(exitcode);
|
|
}
|
|
#endif
|
|
|
|
int telnetd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
|
int telnetd_main(int argc UNUSED_PARAM, char **argv)
|
|
{
|
|
unsigned opt;
|
|
#if ENABLE_FEATURE_TELNETD_STANDALONE
|
|
#define IS_INETD (opt & OPT_INETD)
|
|
char *opt_bindaddr = NULL;
|
|
char *opt_portnbr;
|
|
#else
|
|
enum { IS_INETD = 1 };
|
|
#endif
|
|
INIT_G();
|
|
|
|
/* 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, "^"
|
|
IF_FEATURE_TELNETD_SELFTEST_DEBUG("@")
|
|
"f:l:Ki"
|
|
IF_FEATURE_TELNETD_STANDALONE("p:b:F")
|
|
IF_FEATURE_TELNETD_INETD_WAIT("Sw:+v") /* -w NUM */
|
|
"\0"
|
|
/* -w implies -F. -w and -i don't mix. -v counter */
|
|
IF_FEATURE_TELNETD_INETD_WAIT("wF:i--w:w--i:vv")
|
|
, &G.issuefile, &G.loginpath
|
|
IF_FEATURE_TELNETD_STANDALONE(, &opt_portnbr, &opt_bindaddr)
|
|
IF_FEATURE_TELNETD_INETD_WAIT(, &G.io.max_timeout)
|
|
, &G.verbose
|
|
);
|
|
|
|
#if ENABLE_FEATURE_TELNETD_SELFTEST_DEBUG
|
|
if (opt & 1) { /* -@ is first option */
|
|
selftest(); /* does not return */
|
|
}
|
|
opt >>= 1; /* Shift away the selftest bit */
|
|
#endif
|
|
if (!IS_INETD /*&& !re_execed*/) {
|
|
/* inform that we start in standalone mode?
|
|
* May be useful when people forget to give -i */
|
|
/*bb_error_msg("listening for connections");*/
|
|
if (!(opt & OPT_FOREGROUND)) {
|
|
/* DAEMON_CHDIR_ROOT was giving inconsistent
|
|
* behavior with/without -F, -i */
|
|
bb_daemonize_or_rexec(0 /*was DAEMON_CHDIR_ROOT*/, argv);
|
|
}
|
|
}
|
|
/* Redirect log to syslog early, if needed */
|
|
if (IS_INETD || (opt & OPT_SYSLOG) || !(opt & OPT_FOREGROUND)) {
|
|
openlog(applet_name, LOG_PID, LOG_DAEMON);
|
|
logmode = LOGMODE_SYSLOG;
|
|
}
|
|
|
|
if (IS_INETD) {
|
|
make_new_session(&G.io, 0);
|
|
}
|
|
#if ENABLE_FEATURE_TELNETD_STANDALONE
|
|
else {
|
|
int master_fd = 0;
|
|
/* For -w SEC, listening socket is 0. Otherwise: */
|
|
if (!(opt & OPT_WAIT)) {
|
|
unsigned portnbr = CONFIG_FEATURE_TELNETD_PORT_DEFAULT;
|
|
if (opt & OPT_PORT)
|
|
portnbr = xatou16(opt_portnbr);
|
|
/* If someone would run "telnetd 0>&-", we can get terribly confused. */
|
|
/* Nake sure master_fd, or accept() result fd, etc, cant become 0 or 1: */
|
|
bb_sanitize_stdio();
|
|
master_fd = create_and_bind_stream_or_die(opt_bindaddr, portnbr);
|
|
xlisten(master_fd, 1);
|
|
}
|
|
close_on_exec_on(master_fd);
|
|
ioloop_insert_conn(&G.io, (void *)new_accept_conn(master_fd));
|
|
}
|
|
#endif
|
|
/* We don't want to die if just one session is broken */
|
|
signal(SIGPIPE, SIG_IGN);
|
|
|
|
if (opt & OPT_WATCHCHILD)
|
|
signal(SIGCHLD, handle_sigchld);
|
|
else /* prevent dead children from becoming zombies */
|
|
signal(SIGCHLD, SIG_IGN);
|
|
|
|
#if ENABLE_FEATURE_TELNETD_INETD_WAIT
|
|
if (G.io.max_timeout > UINT_MAX / 1000000) /* -w TMOUT capped at 4294 sec */
|
|
G.io.max_timeout = (UINT_MAX / 1000000);
|
|
G.io.max_timeout *= 1000000;
|
|
#endif
|
|
G.io.flags |= IOLOOP_FLAG_EXIT_IF_TIMEOUT;
|
|
for (;;) {
|
|
int rc = ioloop_run(&G.io);
|
|
if (rc == IOLOOP_NO_CONNS) {
|
|
/* inetd mode (not -w), and it's closed now */
|
|
dbg_close("connection is closed");
|
|
break;
|
|
}
|
|
/* else: timeout */
|
|
#if ENABLE_FEATURE_TELNETD_INETD_WAIT
|
|
if (1 /* rc == IOLOOP_TIMEOUT */
|
|
&& (!G.io.conns || !G.io.conns->next) /* only accept conn exists */
|
|
) {
|
|
dbg_close("-w TIMEOUT:%dus", G.io.max_timeout);
|
|
break;
|
|
}
|
|
#endif
|
|
dbg("timeout was due to temporary EIO: continue looping");
|
|
}
|
|
dbg_close("terminating");
|
|
return EXIT_SUCCESS;
|
|
}
|