Merge branch 'busybox' into merge

52 files changed, 6426 insertions, 1740 deletions

diff --git a/archival/libarchive/get_header_tar.c b/archival/libarchive/get_header_tar.c
index 9beed93cf..b83523fb2 100644
--- a/archival/libarchive/get_header_tar.c
+++ b/archival/libarchive/get_header_tar.c
@@ -460,7 +460,7 @@ char FAST_FUNC get_header_tar(archive_handle_t *archive_handle)
 
         /* Everything up to and including last ".." component is stripped */
         strip_unsafe_prefix(file_header->name);
-        if (file_header->link_target) {
+        if (file_header->link_target && !S_ISLNK(file_header->mode)) {
                 /* GNU tar 1.34 examples:
                  * tar: Removing leading '/' from hard link targets
                  * tar: Removing leading '../' from hard link targets
diff --git a/coreutils/od_bloaty.c b/coreutils/od_bloaty.c
index 641d93503..b268368bf 100644
--- a/coreutils/od_bloaty.c
+++ b/coreutils/od_bloaty.c
@@ -1162,7 +1162,7 @@ dump_strings(off_t address, off_t end_offset)
    leading '+' return nonzero and set *OFFSET to the offset it denotes.  */
 
 static int
-parse_old_offset(const char *s, off_t *offset)
+parse_old_offset(char *s, off_t *offset)
 {
         static const struct suffix_mult Bb[] ALIGN_SUFFIX = {
                 { "B", 1024 },
@@ -1188,7 +1188,8 @@ parse_old_offset(const char *s, off_t *offset)
                 radix = 16;
 
         *offset = xstrtooff_sfx(s, radix, Bb);
-        if (p) p[0] = '.';
+        if (p)
+                p[0] = '.'; /* undo cheating */
 
         return (*offset >= 0);
 }
@@ -1241,7 +1242,7 @@ int od_main(int argc UNUSED_PARAM, char **argv)
                 static const uint8_t doxn_address_pad_len_char[] ALIGN1 = {
                         '7', '7', '6', /* '?' */
                 };
-                char *p;
+                const char *p;
                 int pos;
                 p = strchr(doxn, str_A[0]);
                 if (!p)
diff --git a/coreutils/paste.c b/coreutils/paste.c
index 78a5c2a14..363340e3d 100644
--- a/coreutils/paste.c
+++ b/coreutils/paste.c
@@ -34,23 +34,16 @@
 
 static void paste_files(FILE** files, int file_cnt, char* delims, int del_cnt)
 {
-#if ENABLE_PLATFORM_MINGW32
         char **line = xmalloc(file_cnt * sizeof(char *));
-#else
-        char *line;
-#endif
         char delim;
         int active_files = file_cnt;
         int i;
 
         while (active_files > 0) {
                 int del_idx = 0;
-#if ENABLE_PLATFORM_MINGW32
                 int got_line = FALSE;
-#endif
 
                 for (i = 0; i < file_cnt; ++i) {
-#if ENABLE_PLATFORM_MINGW32
                         if (files[i]) {
                                 line[i] = xmalloc_fgetline(files[i]);
                                 if (!line[i]) {
@@ -73,20 +66,6 @@ static void paste_files(FILE** files, int file_cnt, char* delims, int del_cnt)
                                 fputs_stdout(line[i]);
                                 free(line[i]);
                         }
-#else
-                        if (files[i] == NULL)
-                                continue;
-
-                        line = xmalloc_fgetline(files[i]);
-                        if (!line) {
-                                fclose_if_not_stdin(files[i]);
-                                files[i] = NULL;
-                                --active_files;
-                                continue;
-                        }
-                        fputs_stdout(line);
-                        free(line);
-#endif
                         delim = '\n';
                         if (i != file_cnt - 1) {
                                 delim = delims[del_idx++];
@@ -97,9 +76,7 @@ static void paste_files(FILE** files, int file_cnt, char* delims, int del_cnt)
                                 fputc(delim, stdout);
                 }
         }
-#if ENABLE_PLATFORM_MINGW32
         free(line);
-#endif
 }
 
 static void paste_files_separate(FILE** files, char* delims, int del_cnt)
diff --git a/coreutils/printf.c b/coreutils/printf.c
index 379c00cc6..0c2502f1b 100644
--- a/coreutils/printf.c
+++ b/coreutils/printf.c
@@ -419,7 +419,7 @@ static char **print_formatted(char *f, char **argv, int *conv_err)
                         /* Add "ll" if integer modifier, then print */
                         {
                                 static const char format_chars[] ALIGN1 = "diouxXfeEgGcs";
-                                char *p = strchr(format_chars, *f);
+                                char *p = (char*)strchr(format_chars, *f);
                                 /* needed - try "printf %" without it */
                                 if (p == NULL || *f == '\0') {
                                         bb_error_msg("%s: invalid format", direc_start);
diff --git a/editors/awk.c b/editors/awk.c
index b3ec99d3f..81d7005b3 100644
--- a/editors/awk.c
+++ b/editors/awk.c
@@ -2841,7 +2841,7 @@ static NOINLINE var *exec_builtin(node *op, var *res)
                 l = strlen(as[0]) - ll;
                 if (ll > 0 && l >= 0) {
                         if (!icase) {
-                                char *s = strstr(as[0], as[1]);
+                                const char *s = strstr(as[0], as[1]);
                                 if (s)
                                         n = (s - as[0]) + 1;
                         } else {
diff --git a/include/libbb.h b/include/libbb.h
index 6ce99abda..ee3a5b56a 100644
--- a/include/libbb.h
+++ b/include/libbb.h
@@ -501,6 +501,11 @@ void *mmap_anon(size_t size) FAST_FUNC;
 void *xmmap_anon(size_t size) FAST_FUNC;
 
 #if defined(__x86_64__) || defined(i386)
+/* 0x7f would be better, but it causes alignment problems */
+# define ARCH_GLOBAL_PTR_OFF 0x80
+#endif
+
+#if defined(__x86_64__) || defined(i386)
 # define BB_ARCH_FIXED_PAGESIZE 4096
 #elif defined(__arm__) /* only 32bit, 64bit ARM has variable page size */
 # define BB_ARCH_FIXED_PAGESIZE 4096
@@ -511,11 +516,6 @@ void *xmmap_anon(size_t size) FAST_FUNC;
 //sparc64,alpha,openrisc: fixed 8k pages
 #endif
 
-#if defined(__x86_64__) || defined(i386)
-/* 0x7f would be better, but it causes alignment problems */
-# define ARCH_GLOBAL_PTR_OFF 0x80
-#endif
-
 #if defined BB_ARCH_FIXED_PAGESIZE
 # define IF_VARIABLE_ARCH_PAGESIZE(...) /*nothing*/
 # define bb_getpagesize()     BB_ARCH_FIXED_PAGESIZE
@@ -780,6 +780,76 @@ struct fd_pair { int rd; int wr; };
 #define piped_pair(pair)  pipe(&((pair).rd))
 #define xpiped_pair(pair) xpipe(&((pair).rd))
 
+
+int parse_datestr(const char *date_str, struct tm *ptm) FAST_FUNC;
+time_t validate_tm_time(const char *date_str, struct tm *ptm) FAST_FUNC;
+char *strftime_HHMMSS(char *buf, unsigned len, time_t *tp) FAST_FUNC;
+char *strftime_YYYYMMDDHHMMSS(char *buf, unsigned len, time_t *tp) FAST_FUNC;
+void xgettimeofday(struct timeval *tv) FAST_FUNC;
+void xsettimeofday(const struct timeval *tv) FAST_FUNC;
+
+
+/* Generic I/O loop */
+struct connection;
+typedef struct ioloop_state {
+        struct connection *conns;
+        unsigned flags;
+        unsigned max_timeout;
+        unsigned current_iteration_timeout;
+        unsigned last_timeout;
+        int (*pre_poll_callback)(struct ioloop_state*);
+} ioloop_state_t;
+
+#define STRUCT_CONNECTION \
+        struct connection *next; \
+        ioloop_state_t *io; \
+        int read_fd; \
+        int write_fd; \
+        int (*have_buffer_to_read_into)(void *this); \
+        int (*have_data_to_write)(void *this); \
+        int (*read)(void *this); \
+        int (*write)(void *this); \
+
+typedef struct connection {
+        STRUCT_CONNECTION
+} connection_t;
+
+static ALWAYS_INLINE void free_connection(connection_t *conn)
+{
+        free(conn);
+}
+
+void FAST_FUNC conn_close_fds(connection_t *conn);
+void FAST_FUNC conn_close_fds_remove_and_free(connection_t *conn);
+static ALWAYS_INLINE ioloop_state_t *new_ioloop_state(void)
+{
+        ioloop_state_t *io = xzalloc(sizeof(*io));
+        return io;
+}
+static ALWAYS_INLINE void free_ioloop_state(ioloop_state_t *io)
+{
+        free(io);
+}
+static ALWAYS_INLINE void ioloop_decrease_current_timeout(ioloop_state_t *io, unsigned n)
+{
+        if (io->current_iteration_timeout > n)
+                io->current_iteration_timeout = n;
+}
+
+void FAST_FUNC ioloop_insert_conn(ioloop_state_t *io, connection_t *conn);
+void FAST_FUNC ioloop_remove_conn(ioloop_state_t *io, connection_t *conn);
+enum {
+        IOLOOP_FLAG_EXIT_IF_TIMEOUT = (1 << 0),
+        IOLOOP_FLAG_EXIT_IF_EINTR   = (1 << 1),
+        //IOLOOP_FLAG_EXIT_IF_ALL_NOT_READY = (1 << 1),
+        /* ioloop_run return values */
+        IOLOOP_NO_CONNS = 0,
+        IOLOOP_TIMEOUT  = 1,
+        IOLOOP_EINTR    = 2,
+};
+int FAST_FUNC ioloop_run(ioloop_state_t *io);
+
+
 /* Useful for having small structure members/global variables */
 typedef int8_t socktype_t;
 typedef int8_t family_t;
@@ -808,14 +878,6 @@ struct BUG_too_small {
 };
 
 
-int parse_datestr(const char *date_str, struct tm *ptm) FAST_FUNC;
-time_t validate_tm_time(const char *date_str, struct tm *ptm) FAST_FUNC;
-char *strftime_HHMMSS(char *buf, unsigned len, time_t *tp) FAST_FUNC;
-char *strftime_YYYYMMDDHHMMSS(char *buf, unsigned len, time_t *tp) FAST_FUNC;
-void xgettimeofday(struct timeval *tv) FAST_FUNC;
-void xsettimeofday(const struct timeval *tv) FAST_FUNC;
-
-
 int xsocket(int domain, int type, int protocol) FAST_FUNC;
 void xbind(int sockfd, struct sockaddr *my_addr, socklen_t addrlen) FAST_FUNC;
 void xlisten(int s, int backlog) FAST_FUNC;
@@ -926,6 +988,11 @@ char* xmalloc_sockaddr2hostonly_noport(const struct sockaddr *sa) FAST_FUNC RETU
 /* inet_[ap]ton on steroids */
 char* xmalloc_sockaddr2dotted(const struct sockaddr *sa) FAST_FUNC RETURNS_MALLOC;
 char* xmalloc_sockaddr2dotted_noport(const struct sockaddr *sa) FAST_FUNC RETURNS_MALLOC;
+// NB: unlike getservbyport, port parameter/retval are in host, NOT network order!
+#define getservbyport dont_use_getservbyport_uses_global_buffer
+char* bb_get_servname_by_port(char **p_etc_services, int port, const char *type) FAST_FUNC RETURNS_MALLOC;
+#define getservbyname dont_use_getservbyname_uses_global_buffer
+int bb_get_servport_by_name(char **p_etc_services, const char *name, const char *type) FAST_FUNC;
 // "old" (ipv4 only) API
 // users: traceroute.c hostname.c - use _list_ of all IPs
 struct hostent *xgethostbyname(const char *name) FAST_FUNC;
@@ -976,8 +1043,11 @@ typedef struct tls_state {
         int ofd;
         int ifd;
 
-        unsigned min_encrypted_len_on_read;
+#if ENABLE_SSL_SERVER // || ENABLE_FEATURE_HTTPD_SSL
+        smallint expecting_first_packet;
+#endif
         uint16_t cipher_id;
+        unsigned min_encrypted_len_on_read;
         unsigned MAC_size;
         unsigned key_size;
         unsigned IV_size;
@@ -1002,21 +1072,27 @@ typedef struct tls_state {
         /*uint64_t read_seq64_be;*/
         uint64_t write_seq64_be;
 
-        /*uint8_t *server_write_MAC_key;*/
-        uint8_t *client_write_key;
-        uint8_t *server_write_key;
-        uint8_t *client_write_IV;
-        uint8_t *server_write_IV;
-        uint8_t client_write_MAC_key[TLS_MAX_MAC_SIZE];
-        uint8_t server_write_MAC_k__[TLS_MAX_MAC_SIZE];
-        uint8_t client_write_k__[TLS_MAX_KEY_SIZE];
-        uint8_t server_write_k__[TLS_MAX_KEY_SIZE];
-        uint8_t client_write_I_[TLS_MAX_IV_SIZE];
-        uint8_t server_write_I_[TLS_MAX_IV_SIZE];
+        uint8_t *our_write_MAC_key;
+        uint8_t *peer_write_MAC_key;
+        uint8_t *our_write_key;
+        uint8_t *peer_write_key;
+        uint8_t *our_write_IV;
+        uint8_t *peer_write_IV;
+        uint8_t key_block[TLS_MAX_MAC_SIZE];
+        uint8_t key_block2[TLS_MAX_MAC_SIZE];
+        uint8_t key_block3[TLS_MAX_KEY_SIZE];
+        uint8_t key_block4[TLS_MAX_KEY_SIZE];
+        uint8_t key_block5[TLS_MAX_IV_SIZE];
+        uint8_t key_block6[TLS_MAX_IV_SIZE];
 
         struct tls_aes aes_encrypt;
         struct tls_aes aes_decrypt;
         uint8_t H[16]; //used by AES_GCM
+
+#if ENABLE_SSL_SERVER // || ENABLE_FEATURE_HTTPD_SSL
+        /* For ECDHE: server's ephemeral EC private key */
+        //uint8_t ecc_priv_key32[32];
+#endif
 } tls_state_t;
 #endif
 
@@ -1025,8 +1101,9 @@ static inline tls_state_t *new_tls_state(void)
         tls_state_t *tls = xzalloc(sizeof(*tls));
         return tls;
 }
-
-void tls_handshake(tls_state_t *tls, const char *sni) FAST_FUNC;
+void FAST_FUNC tls_handshake(tls_state_t *tls, const char *sni);
+void FAST_FUNC tls_handshake_as_server(tls_state_t *tls,
+        const char *pem_filename);
 #define TLSLOOP_EXIT_ON_LOCAL_EOF (1 << 0)
 void tls_run_copy_loop(tls_state_t *tls, unsigned flags) FAST_FUNC;
 
diff --git a/klibc-utils/resume.c b/klibc-utils/resume.c
index 179413627..cb8314c75 100644
--- a/klibc-utils/resume.c
+++ b/klibc-utils/resume.c
@@ -31,7 +31,7 @@
  * - /dev/ram (alias to /dev/ram0)
  * - /dev/mtd
  */
-static dev_t name_to_dev_t(const char *devname)
+static dev_t name_to_dev_t(char *devname)
 {
         char devfile[sizeof(int)*3 * 2 + 4];
         char *sysname;
diff --git a/libbb/bb_get_servname_by_port.c b/libbb/bb_get_servname_by_port.c
new file mode 100644
index 000000000..970a718fe
--- /dev/null
+++ b/libbb/bb_get_servname_by_port.c
@@ -0,0 +1,56 @@
+/*
+ * Utility routines.
+ *
+ * Copyright (C) 2026 Denys Vlasenko
+ *
+ * Licensed under GPLv2, see file LICENSE in this source tree.
+ */
+//kbuild:lib-$(CONFIG_NETSTAT) += bb_get_servname_by_port.o
+//kbuild:lib-$(CONFIG_PSCAN) += bb_get_servname_by_port.o
+#include "libbb.h"
+
+//Rationale for existing:
+//#define getservbyport dont_use_getservbyport_uses_global_buffer
+//(for example: -280 bytes on musl, x86-32)
+
+char* FAST_FUNC bb_get_servname_by_port(char **p_etc_services, int port, const char *type)
+{
+        char *sp;
+
+        sp = *p_etc_services;
+        if (!sp) {
+//TODO: we need mmap_entire_file() for this use case!
+                sp = xmalloc_open_read_close("/etc/services", NULL);
+                if (!sp)
+                        return NULL;
+                *p_etc_services = sp;
+        }
+        while (*sp) {
+                const char *pnstr, *sp_end;
+                char *end;
+                unsigned n;
+
+                sp = skip_whitespace(sp);
+                if (*sp == '#')
+                        goto next;
+                sp_end = skip_non_whitespace(sp);
+                pnstr = skip_whitespace(sp_end);
+                n = bb_strtou(pnstr, &end, 10);
+                if (n != port || *end != '/')
+                        goto next;
+                if (type) {
+                        end++;
+                        end = is_prefixed_with(end, type);
+                        if (!end
+                         || !(isspace(*end) || *end == '\0'
+                            || *end == '#') // glibc treats "http 80/tcp#COMMENT" (no space!) as valid
+                        ) {
+                                goto next;
+                        }
+                }
+                return auto_string(xstrndup(sp, sp_end - sp));
+ next:
+                sp = strchrnul(sp, '\n');
+        }
+        return NULL;
+}
diff --git a/libbb/bb_get_servport_by_name.c b/libbb/bb_get_servport_by_name.c
new file mode 100644
index 000000000..96580c900
--- /dev/null
+++ b/libbb/bb_get_servport_by_name.c
@@ -0,0 +1,129 @@
+/*
+ * Utility routines.
+ *
+ * Copyright (C) 2026 Denys Vlasenko
+ *
+ * Licensed under GPLv2, see file LICENSE in this source tree.
+ */
+//kbuild:lib-y += bb_get_servport_by_name.o
+//kbuild:lib-y += bb_get_servport_by_name.o
+#include "libbb.h"
+
+//Rationale for existing:
+//#define getservbyname dont_use_getservbyname_uses_global_buffer
+//(for example: -32 BSS bytes on musl, x86-32)
+
+int FAST_FUNC bb_get_servport_by_name(char **p_etc_services, const char *name, const char *proto)
+{
+        unsigned namelen;
+        char *sp;
+
+        if (!name[0]) // This can hang the search (strstr advances by 0 bytes)
+                return -1; // bad service name form: ""
+        // Any other bogosity to reject?
+        // Or just enforce isalnum_or_dash_or_slash(name[i])?
+        // Yes, service name like "cl/1" is allowed and _exists_.
+        //
+        // Protect against finding service "www#c" in "http 10/tcp www#c" line
+        //if (strchr(name, '#'))
+        //      return -1; // bad service name form
+        //^^^^ the main code already catches this possibility.
+        //
+        // Current code allows e.g. service names like "http 80/tcp"
+        // to map to port 80. Probably harmless?
+        //if (skip_non_whitespace(name)[0])
+        //      return -1; // bad service name form (has whitespace)
+
+        sp = *p_etc_services;
+        if (!sp) {
+//TODO: we need mmap_entire_file() for this use case!
+                sp = xmalloc_open_read_close("/etc/services", NULL);
+                if (!sp)
+                        return -1;
+                *p_etc_services = sp;
+        }
+        namelen = strlen(name);
+        while (*sp) {
+                const char *pnstr;
+                char *start, *end;
+                unsigned n;
+
+                // First, find a possible service name without regard for line separators (!)
+                start = strstr(sp, name);
+                if (!start)
+                        return -1;
+                sp = start + namelen;
+                if (start != *p_etc_services && !isspace(start[-1])) {
+                        // There is a char before it, and it's not whitespace
+                        continue;
+                }
+                if (!(isspace(*sp) || *sp == '\0' || *sp == '#'))
+                        // After it: not whitespace/EOF/comment
+                        continue;
+                // The found substring _is_ correctly delimited before and after
+
+                // Find beginning of the line we are on
+                while (start != *p_etc_services && start[-1] != '\n')
+                        start--;
+                start = skip_whitespace(start);
+                // Is there a comment char between start of line and "service name"?
+                if (memchr(start, '#', sp - start)) {
+                        // The "service name" we found is actually in comment / has comment in it.
+                        // Also rejects names with #:
+                        // service "www#c" won't be found even on "http 80/tcp www#c" line
+                        continue;
+                }
+                // Is the [start...sp) of the form "SERVNAME NUM/PROTO[ ALIAS[ ALIAS...][ ]]"?
+                pnstr = skip_whitespace(skip_non_whitespace(start)); // go to NUM...
+
+                // I've seen this line in /etc/services of a real-world machine:
+                //914c/g 211/tcp 914c-g
+                // Now consider just a bit more pathological example:
+                //914c/tcp 914/tcp 914/tcp
+                // If we search for service name "914/tcp",
+                // we'll find it at second word first, yet we must not reject this line
+                // because the THIRD word also matches, and it's a valid match (tested on glibc!).
+                // But in this case we must not match:
+                //914c/tcp 914/tcp something-else
+                if (sp - namelen == pnstr)
+                        continue; // the match is at NUM..., try matching further
+
+                n = bb_strtou(pnstr, &end, 10);
+                if (n > 0xffff || *end != '/')
+                        continue; // NUM... part is not a valid port#, or has no slash
+
+                if (proto) {
+                        end++; // points to PROTO
+                        end = is_prefixed_with(end, proto);
+                        if (!end
+                         || !(isspace(*end) || *end == '\0'
+                            || *end == '#') // glibc treats "http 80/tcp#COMMENT" (no space!) as valid
+                        ) {
+                                continue; // PROTO does not match
+                        }
+                }
+                // By now, either WORD or one of the ALIASes has to be the part
+                // which was found by strstr()!
+                return n;
+        }
+        return -1;
+}
+
+// Return port number for a service.
+// If "port" is a number use it as the port.
+// If "port" is a name it is looked up in /etc/services.
+// if NULL, return default_port
+unsigned FAST_FUNC bb_lookup_port(const char *port, const char *protocol, unsigned port_nr)
+{
+        if (port) {
+                port_nr = bb_strtou(port, NULL, 10);
+                if (errno || port_nr > 65535) {
+                        char *p_etc_services = NULL;
+                        port_nr = bb_get_servport_by_name(&p_etc_services, port, protocol);
+                        if (port_nr > 0xffff) // -1?
+                                bb_error_msg_and_die("bad port '%s'", port);
+                        free(p_etc_services);
+                }
+        }
+        return (uint16_t)port_nr;
+}
diff --git a/libbb/get_last_path_component.c b/libbb/get_last_path_component.c
index 46a87d7fc..9be813f80 100644
--- a/libbb/get_last_path_component.c
+++ b/libbb/get_last_path_component.c
@@ -48,20 +48,20 @@ char* FAST_FUNC bb_get_last_path_component_nostrip(const char *path)
 {
 #if ENABLE_PLATFORM_MINGW32
         const char *start = path + root_len(path);
-        char *slash = get_last_slash(path);
+        const char *slash = get_last_slash(path);
 
         if (!slash && has_dos_drive_prefix(path) && path[2] != '\0')
                 return (char *)path + 2;
         if (!slash || (slash == start && !slash[1]))
                 return (char*)path;
 #else
-        char *slash = strrchr(path, '/');
+        const char *slash = strrchr(path, '/');
 
         if (!slash || (slash == path && !slash[1]))
                 return (char*)path;
 #endif
 
-        return slash + 1;
+        return (char*)slash + 1;
 }
 
 /*
diff --git a/libbb/getpty.c b/libbb/getpty.c
index 9ec6265ad..2471812c6 100644
--- a/libbb/getpty.c
+++ b/libbb/getpty.c
@@ -9,35 +9,69 @@
 
 #define DEBUG 0
 
+// On modern systems (old ways were more kludgy with setuid "pt_chown" binary):
+// ptyfd = open("/dev/ptmx"):
+// Kernel creates slave /dev/pts/N with owner = real UID of opener,
+// group and mode as configured by /dev/pts mount options.
+// The mode is safe with standard mount options (gid=5,mode=620).
+//
+// grantpt(ptyfd) is now only a verification step. In glibc:
+// Calls ioctl(fd, TIOCGPTN, &minor) to confirm ptyfd is valid master pty.
+// If ioctl fails with ENOTTY, remaps to EINVAL (POSIX).
+// Otherwise returns 0. (No chown/chmod occurs.)
+//
+// unlockpt(ptyfd) is ioctl(TIOCSPTLCK, 0): clears optional protection flag
+// on slave. If flag was set, open(slave) fails with EIO for everyone (even root)
+// until unlocked. [Do modern kernels still set the lock in open("/dev/ptmx")?]
+// The lock historically prevented opening slave before grantpt() fixes perms
+// in misconfigured/old setups where kernel didn't set 0620 atomically.
+// Today it's mostly belt-and-suspenders + POSIX compatibility.
+//
+// The attack thwarted by the lock (assuming unprivileged adversary):
+// you open /dev/ptmx, kernel allocates /dev/pts/N with overly permissive mode.
+// Adversary manages to open /dev/pts/N before your grantpt() call
+// locks down permissions.
+// Typically, /dev/pts mount options are gid=5,mode=620, 5 = "tty" group,
+// system is set up with only trusted binaries and no users in "tty" group.
+// In this case, the locking mechanism is overkill (would be safe without it).
+// To fortify more, you can mount with gid=0,mode=600. Tools like "wall",
+// "mesg" would stop working.
+// Processes with my own UID can still race against me, but I probably
+// trust myself...
+//
+// ptsname(ptyfd), internally ioctl(TIOCGPTN): get index, build
+// "/dev/pts/NN" string which refers to the slave pty.
 int FAST_FUNC xgetpty(char *line)
 {
-        int p;
-
 #if ENABLE_FEATURE_DEVPTS
-        p = open("/dev/ptmx", O_RDWR);
-        if (p >= 0) {
-                grantpt(p); /* chmod+chown corresponding slave pty */
-                unlockpt(p); /* (what does this do?) */
+        int ptyfd;
+
+        ptyfd = open("/dev/ptmx", O_RDWR);
+        if (ptyfd < 0)
+                bb_simple_perror_msg_and_die("can't find free pty");
+        grantpt(ptyfd); /* chmod+chown corresponding slave pty */
+        unlockpt(ptyfd); /* allow open() on slave /dev node */
 # ifndef HAVE_PTSNAME_R
-                {
-                        const char *name;
-                        name = ptsname(p); /* find out the name of slave pty */
-                        if (!name) {
-                                bb_simple_perror_msg_and_die("ptsname error (is /dev/pts mounted?)");
-                        }
-                        safe_strncpy(line, name, GETPTY_BUFSIZE);
-                }
-# else
-                /* find out the name of slave pty */
-                if (ptsname_r(p, line, GETPTY_BUFSIZE-1) != 0) {
+        {
+                const char *name;
+                name = ptsname(ptyfd); /* find out the name of slave pty */
+                if (!name) {
                         bb_simple_perror_msg_and_die("ptsname error (is /dev/pts mounted?)");
                 }
-                line[GETPTY_BUFSIZE-1] = '\0';
-# endif
-                return p;
+                safe_strncpy(line, name, GETPTY_BUFSIZE);
         }
+# else
+        /* find out the name of slave pty */
+        if (ptsname_r(ptyfd, line, GETPTY_BUFSIZE-1) != 0) {
+                bb_simple_perror_msg_and_die("ptsname error (is /dev/pts mounted?)");
+        }
+        line[GETPTY_BUFSIZE-1] = '\0';
+# endif
+        return ptyfd;
+
 #else
         struct stat stb;
+        int ptyfd;
         int i;
         int j;
 
@@ -53,13 +87,13 @@ int FAST_FUNC xgetpty(char *line)
                         line[9] = j < 10 ? j + '0' : j - 10 + 'a';
                         if (DEBUG)
                                 fprintf(stderr, "Trying to open device: %s\n", line);
-                        p = open(line, O_RDWR | O_NOCTTY);
-                        if (p >= 0) {
+                        ptyfd = open(line, O_RDWR | O_NOCTTY);
+                        if (ptyfd >= 0) {
                                 line[5] = 't';
-                                return p;
+                                return ptyfd;
                         }
                 }
         }
-#endif /* FEATURE_DEVPTS */
         bb_simple_error_msg_and_die("can't find free pty");
+#endif /* FEATURE_DEVPTS */
 }
diff --git a/libbb/ioloop.c b/libbb/ioloop.c
new file mode 100644
index 000000000..cc9876487
--- /dev/null
+++ b/libbb/ioloop.c
@@ -0,0 +1,264 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Copyright (C) 2026 Denys Vlasenko <vda.linux@googlemail.com>
+ *
+ * Licensed under GPLv2, see file LICENSE in this source tree.
+ */
+//kbuild:lib-$(CONFIG_TELNETD) += ioloop.o
+
+#include "libbb.h"
+
+#define DEBUG 0
+
+#if DEBUG
+# define dbg(...) bb_error_msg(__VA_ARGS__)
+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);
+}
+#else
+# define dbg(...) ((void)0)
+#endif
+
+void FAST_FUNC ioloop_insert_conn(ioloop_state_t *io, connection_t *conn)
+{
+        conn->io = io;
+        conn->next = io->conns;
+        io->conns = conn;
+}
+
+void FAST_FUNC ioloop_remove_conn(ioloop_state_t *io, connection_t *conn)
+{
+        connection_t **pp = &io->conns;
+        while (*pp) {
+                if (*pp == conn) {
+                        *pp = conn->next;
+                        return;
+                }
+                pp = &(*pp)->next;
+        }
+}
+
+void FAST_FUNC conn_close_fds(connection_t *conn)
+{
+        if (conn->read_fd >= 0)
+                close(conn->read_fd);
+        if (conn->write_fd >= 0 && conn->write_fd != conn->read_fd)
+                close(conn->write_fd);
+        conn->write_fd = -1;
+        conn->read_fd = -1;
+}
+
+void FAST_FUNC conn_close_fds_remove_and_free(connection_t *conn)
+{
+        conn_close_fds(conn);
+        ioloop_remove_conn(conn->io, conn);
+        free_connection(conn);
+}
+
+#ifdef UNUSED
+void FAST_FUNC ioloop_close_fd_in_all_conns(ioloop_state_t *io, int fd)
+{
+        connection_t *conn;
+
+        close(fd);
+        conn = io->conns;
+        while (conn) {
+                if (conn->read_fd == fd)
+                        conn->read_fd = -1;
+                if (conn->write_fd == fd)
+                        conn->write_fd = -1;
+                conn = conn->next;
+        }
+}
+#endif
+
+// have_data_to_write() - Do we have data to write?
+// May return error if knows that write side is closed, even if it has free buffer space.
+// > 0: Has data to write (or can generate such data)
+//    In this case, write_fd must be valid! (it's a bug if it is < 0, can crash)
+// 0: No data to write currently
+// < 0: error, I probably freed myself (do not use my structure in this iteration,
+// on next iteration, if I indeed freed myself, you won't find me in the list).
+//
+// have_buffer_to_read_into() - Is there a buffer to read into?
+// May return error if knows that write side is closed, even if it has free buffer space.
+// > 0: Healthy, has buffer space, please poll read_fd
+//    In this case, read_fd must be valid! (it's a bug if it is < 0)
+// 0: One of:
+//    Buffer is full (hopefully write() will free some)
+//    Got error/EOF, want to drain write buffer first
+// < 0: Error/EOF, I probably freed myself (do not use my structure)
+//
+// Essentially: add your "this connection is dead, close+ioloop_remove_conn(this)+free(this)" code
+// to either of the above two functions.
+// Either would work equally well from ioloop POV.
+//
+// write() - Perform write
+// Even if poll shows that write_fd become ready, the method will not be called if conn->write_fd become < 0.
+// However, changing it to another fd >= 0 is a bug.
+// >= 0: No error (ioloop() does not handle 0 specially)
+// < 0: Error occurred, I probably freed myself (do not use my structure)
+//
+// Error returns from read() and write() will skip the opposite op.
+// (Which one happens first depends on ioloop_run() code, as I write this, write()
+// is done first - therefore read() can't skip write()).
+// IOW: if you "remove(this)" in either of them you MUST return < 0.
+//
+// Write function, if it performs some processing, needs to account for the possibility
+// that any "incomplete data, can't write, wait for more" logic should also check whether
+// "more" is even possible: your other code may know that the read side is at EOF,
+// and arrange for it to not be polled. Thus a hang: read not reading, write waits for more date.
+//
+// read() - Perform read
+// Will not be called if read_fd become < 0.
+// >= 0: No error (0 is EOF, ioloop() does not handle 0 specially)
+// < 0: Error occurred, I probably freed myself (do not use my structure)
+//
+// Putting "this connection is dead, close+remove+free" code into read function
+// is often inconvenient: if you got EOF/error on read, you still want to poll write side
+// and try to write out the buffered data to it. Which means read() can't "remove+free".
+// Instead, you can remember EOF/error and make future have_buffer_to_read_into() respond 0.
+// One way is to close (if possible) read_fd, set it to -1 and use as a flag.
+//
+// If need to support one-sided close, such as when HTTP/1.x client sends us
+// "GET / HTTP/1.1\r\n\r\n" and closes its writing side with shutdown(SHUT_WR),
+// the idiom is that when read() sees EOF, it sets conn->read_fd to -1
+// and subsequently have_buffer_to_read_into() always return 0 (no more attempts to read);
+// write() flushes all remaining data to conn->write_fd and then signals EOF
+// to write_fd: shutdown(SHUT_WR) for sockets, close() for pipes
+// (how to do this for ptys!?).
+// After this, have_data_to_write() can return 0 if fd has to stay open (socket)
+// or can return -1 and free itself if fd is closed.
+
+static ALWAYS_INLINE int have_data_to_write(connection_t *conn)
+{
+        return conn->have_data_to_write(conn);
+}
+static ALWAYS_INLINE int have_buffer_to_read_into(connection_t *conn)
+{
+        return conn->have_buffer_to_read_into(conn);
+}
+static ALWAYS_INLINE int write_from_buf(connection_t *conn)
+{
+        return conn->write(conn);
+}
+static ALWAYS_INLINE int read_to_buf(connection_t *conn)
+{
+        return conn->read(conn);
+}
+
+int FAST_FUNC ioloop_run(ioloop_state_t *io)
+{
+        connection_t *conn;
+        unsigned poll_timeout_us;
+        int maxfd;
+        int count;
+        struct timeval tv;
+        struct timeval *tv_ptr;
+        fd_set rdfdset, wrfdset;
+
+        io->current_iteration_timeout = io->max_timeout ? io->max_timeout : UINT_MAX;
+//bb_error_msg("io->current_iteration_timeout:%d", io->current_iteration_timeout);
+ again:
+        FD_ZERO(&rdfdset);
+        FD_ZERO(&wrfdset);
+
+        conn = io->conns;
+        if (!conn)
+                return IOLOOP_NO_CONNS;
+
+        maxfd = -1;
+        while (conn) {
+                connection_t *next;
+                int rcw, rcr;
+
+                next = conn->next; /* in case conn is freed */
+                rcw = have_data_to_write(conn);
+                if (rcw < 0) {
+                        /* often indicates that conn is gone (freed), do not use it anymore */
+                        goto next;
+                }
+                /* Do not add conn->write_fd to waiting set yet,
+                 * the *reader* may decide to abort (return rcr < 0)!
+                 * Check it first:
+                 */
+                rcr = have_buffer_to_read_into(conn);
+                if (rcr < 0)
+                        goto next;
+                if (rcw > 0) {
+                        FD_SET(conn->write_fd, &wrfdset);
+//FIXME: what if fd > 1023
+                        if (conn->write_fd > maxfd)
+                                maxfd = conn->write_fd;
+                }
+                if (rcr > 0) {
+                        FD_SET(conn->read_fd, &rdfdset);
+                        if (conn->read_fd > maxfd)
+                                maxfd = conn->read_fd;
+                }
+ next:
+                conn = next;
+        }
+        if (!io->conns)
+                return IOLOOP_NO_CONNS; /* all conns removed themselves before we reached polling */
+
+        poll_timeout_us = io->current_iteration_timeout;
+        /* May be useful to know after loop exit: */
+        io->last_timeout = poll_timeout_us;
+        dbg("poll_timeout_us:%d", poll_timeout_us);
+
+        tv_ptr = NULL; /* infinite timeout */
+        if (poll_timeout_us != UINT_MAX) {
+                tv.tv_sec = poll_timeout_us / 1000000;
+                tv.tv_usec = poll_timeout_us % 1000000;
+                tv_ptr = &tv;
+        }
+        maxfd++;
+        count = select(maxfd, maxfd ? &rdfdset : NULL, maxfd ? &wrfdset : NULL, NULL, tv_ptr);
+        dbg("select:%d", count);
+
+        /* Any function in the loop can change it, modifying next select() timeout */
+        io->current_iteration_timeout = io->max_timeout ? io->max_timeout : UINT_MAX;
+        dbg("io->current_iteration_timeout:%d", io->current_iteration_timeout);
+
+        if (count <= 0) {
+                /* 0: timeout */
+                if (count == 0 && (io->flags & IOLOOP_FLAG_EXIT_IF_TIMEOUT))
+                        return IOLOOP_TIMEOUT;
+                /* < 0: EINTR or ENOMEM */
+                if (count < 0 && (io->flags & IOLOOP_FLAG_EXIT_IF_EINTR) && errno == EINTR)
+                        return IOLOOP_EINTR;
+                goto again;
+        }
+
+        conn = io->conns;
+        while (conn) {
+                connection_t *next = conn->next; /* in case conn freed */
+                int rcw;
+
+                /* We do check for valid fd >=0: this means that conns
+                 * may prevent I/O of other conns by setting fds to -1.
+                 */
+                dbg("conn->write_fd:%d ?", conn->write_fd);
+                if (conn->write_fd >= 0 && FD_ISSET(conn->write_fd, &wrfdset)) {
+                        dbg("conn->write_fd:%d ready", conn->write_fd);
+                        rcw = write_from_buf(conn);
+                        if (rcw < 0) {
+                                /* often indicates that conn is gone (freed), do not use it anymore */
+                                goto next1;
+                        }
+                }
+                dbg("conn->read_fd:%d ?", conn->read_fd);
+                if (conn->read_fd >= 0 && FD_ISSET(conn->read_fd, &rdfdset)) {
+                        dbg("conn->read_fd:%d ready", conn->read_fd);
+                        read_to_buf(conn);
+                }
+ next1:
+                conn = next;
+        }
+        goto again;
+}
diff --git a/libbb/login.c b/libbb/login.c
index af860c277..ca0da70b4 100644
--- a/libbb/login.c
+++ b/libbb/login.c
@@ -28,8 +28,6 @@ void FAST_FUNC print_login_issue(const char *issue_file, const char *tty)
         time(&t);
         uname(&uts);
 
-        puts("\r");  /* start a new line */
-
         fp = fopen_for_read(issue_file);
         if (!fp)
                 return;
diff --git a/libbb/read_key.c b/libbb/read_key.c
index 2414105ee..07cf1af5a 100644
--- a/libbb/read_key.c
+++ b/libbb/read_key.c
@@ -26,7 +26,7 @@ int64_t FAST_FUNC read_key(int fd, char *buffer, int timeout)
                 'd'            |0x80,KEYCODE_ALT_D   ,
         /* lineedit mimics bash: Alt-f and Alt-b are forward/backward
          * word jumps. We cheat here and make them return ALT_LEFT/RIGHT
-         * keycodes. This way, lineedit need no special code to handle them.
+         * keycodes. This way, lineedit needs no special code to handle them.
          * If we'll need to distinguish them, introduce new ALT_F/B keycodes,
          * and update lineedit to react to them.
          */
@@ -40,12 +40,12 @@ int64_t FAST_FUNC read_key(int fd, char *buffer, int timeout)
                 'O','F'        |0x80,KEYCODE_END     ,
 #if 0
                 'O','P'        |0x80,KEYCODE_FUN1    ,
-                /* [ESC] ESC O [2] P - [Alt-][Shift-]F1 */
-                /* ESC [ O 1 ; 2 P - Shift-F1 */
-                /* ESC [ O 1 ; 3 P - Alt-F1 */
-                /* ESC [ O 1 ; 4 P - Alt-Shift-F1 */
-                /* ESC [ O 1 ; 5 P - Ctrl-F1 */
-                /* ESC [ O 1 ; 6 P - Ctrl-Shift-F1 */
+        //      [ESC] ESC O [2] P - [Alt-][Shift-]F1
+        //      ESC [ O 1 ; 2 P - Shift-F1
+        //      ESC [ O 1 ; 3 P - Alt-F1
+        //      ESC [ O 1 ; 4 P - Alt-Shift-F1
+        //      ESC [ O 1 ; 5 P - Ctrl-F1
+        //      ESC [ O 1 ; 6 P - Ctrl-Shift-F1
                 'O','Q'        |0x80,KEYCODE_FUN2    ,
                 'O','R'        |0x80,KEYCODE_FUN3    ,
                 'O','S'        |0x80,KEYCODE_FUN4    ,
@@ -54,29 +54,29 @@ int64_t FAST_FUNC read_key(int fd, char *buffer, int timeout)
                 '[','B'        |0x80,KEYCODE_DOWN    ,
                 '[','C'        |0x80,KEYCODE_RIGHT   ,
                 '[','D'        |0x80,KEYCODE_LEFT    ,
-                /* ESC [ 1 ; 2 x, where x = A/B/C/D: Shift-<arrow> */
-                /* ESC [ 1 ; 3 x, where x = A/B/C/D: Alt-<arrow> - implemented below */
-                /* ESC [ 1 ; 4 x, where x = A/B/C/D: Alt-Shift-<arrow> */
-                /* ESC [ 1 ; 5 x, where x = A/B/C/D: Ctrl-<arrow> - implemented below */
-                /* ESC [ 1 ; 6 x, where x = A/B/C/D: Ctrl-Shift-<arrow> */
-                /* ESC [ 1 ; 7 x, where x = A/B/C/D: Ctrl-Alt-<arrow> */
-                /* ESC [ 1 ; 8 x, where x = A/B/C/D: Ctrl-Alt-Shift-<arrow> */
+        //      ESC [ 1 ; 2 x, where x = A/B/C/D: Shift-<arrow>
+        //      ESC [ 1 ; 3 x, where x = A/B/C/D: Alt-<arrow> - implemented below
+        //      ESC [ 1 ; 4 x, where x = A/B/C/D: Alt-Shift-<arrow>
+        //      ESC [ 1 ; 5 x, where x = A/B/C/D: Ctrl-<arrow> - implemented below
+        //      ESC [ 1 ; 6 x, where x = A/B/C/D: Ctrl-Shift-<arrow>
+        //      ESC [ 1 ; 7 x, where x = A/B/C/D: Ctrl-Alt-<arrow>
+        //      ESC [ 1 ; 8 x, where x = A/B/C/D: Ctrl-Alt-Shift-<arrow>
                 '[','H'        |0x80,KEYCODE_HOME    , /* xterm */
                 '[','F'        |0x80,KEYCODE_END     , /* xterm */
-                /* [ESC] ESC [ [2] H - [Alt-][Shift-]Home (End similarly?) */
-                /* '[','Z'        |0x80,KEYCODE_SHIFT_TAB, */
+        //      [ESC] ESC [ [2] H - [Alt-][Shift-]Home (End similarly?)
+        //      '[','Z'        |0x80,KEYCODE_SHIFT_TAB,
                 '[','1','~'    |0x80,KEYCODE_HOME    , /* vt100? linux vt? or what? */
                 '[','2','~'    |0x80,KEYCODE_INSERT  ,
-                /* ESC [ 2 ; 3 ~ - Alt-Insert */
+        //      ESC [ 2 ; 3 ~ - Alt-Insert
                 '[','3','~'    |0x80,KEYCODE_DELETE  ,
-                /* [ESC] ESC [ 3 [;2] ~ - [Alt-][Shift-]Delete */
-                /* ESC [ 3 ; 3 ~ - Alt-Delete */
-                /* ESC [ 3 ; 5 ~ - Ctrl-Delete */
+        //      [ESC] ESC [ 3 [;2] ~ - [Alt-][Shift-]Delete
+        //      ESC [ 3 ; 3 ~ - Alt-Delete
+        //      ESC [ 3 ; 5 ~ - Ctrl-Delete
                 '[','4','~'    |0x80,KEYCODE_END     , /* vt100? linux vt? or what? */
                 '[','5','~'    |0x80,KEYCODE_PAGEUP  ,
-                /* ESC [ 5 ; 3 ~ - Alt-PgUp */
-                /* ESC [ 5 ; 5 ~ - Ctrl-PgUp */
-                /* ESC [ 5 ; 7 ~ - Ctrl-Alt-PgUp */
+        //      ESC [ 5 ; 3 ~ - Alt-PgUp
+        //      ESC [ 5 ; 5 ~ - Ctrl-PgUp
+        //      ESC [ 5 ; 7 ~ - Ctrl-Alt-PgUp
                 '[','6','~'    |0x80,KEYCODE_PAGEDOWN,
                 '[','7','~'    |0x80,KEYCODE_HOME    , /* vt100? linux vt? or what? */
                 '[','8','~'    |0x80,KEYCODE_END     , /* vt100? linux vt? or what? */
@@ -86,7 +86,7 @@ int64_t FAST_FUNC read_key(int fd, char *buffer, int timeout)
                 '[','1','3','~'|0x80,KEYCODE_FUN3    , /* old xterm... */
                 '[','1','4','~'|0x80,KEYCODE_FUN4    , /* old xterm... */
                 '[','1','5','~'|0x80,KEYCODE_FUN5    ,
-                /* [ESC] ESC [ 1 5 [;2] ~ - [Alt-][Shift-]F5 */
+        //      [ESC] ESC [ 1 5 [;2] ~ - [Alt-][Shift-]F5
                 '[','1','7','~'|0x80,KEYCODE_FUN6    ,
                 '[','1','8','~'|0x80,KEYCODE_FUN7    ,
                 '[','1','9','~'|0x80,KEYCODE_FUN8    ,
@@ -94,21 +94,21 @@ int64_t FAST_FUNC read_key(int fd, char *buffer, int timeout)
                 '[','2','1','~'|0x80,KEYCODE_FUN10   ,
                 '[','2','3','~'|0x80,KEYCODE_FUN11   ,
                 '[','2','4','~'|0x80,KEYCODE_FUN12   ,
-                /* ESC [ 2 4 ; 2 ~ - Shift-F12 */
-                /* ESC [ 2 4 ; 3 ~ - Alt-F12 */
-                /* ESC [ 2 4 ; 4 ~ - Alt-Shift-F12 */
-                /* ESC [ 2 4 ; 5 ~ - Ctrl-F12 */
-                /* ESC [ 2 4 ; 6 ~ - Ctrl-Shift-F12 */
+        //      ESC [ 2 4 ; 2 ~ - Shift-F12
+        //      ESC [ 2 4 ; 3 ~ - Alt-F12
+        //      ESC [ 2 4 ; 4 ~ - Alt-Shift-F12
+        //      ESC [ 2 4 ; 5 ~ - Ctrl-F12
+        //      ESC [ 2 4 ; 6 ~ - Ctrl-Shift-F12
 #endif
-                /* '[','1',';','5','A' |0x80,KEYCODE_CTRL_UP   , - unused */
-                /* '[','1',';','5','B' |0x80,KEYCODE_CTRL_DOWN , - unused */
-                '[','1',';','5','C' |0x80,KEYCODE_CTRL_RIGHT,
-                '[','1',';','5','D' |0x80,KEYCODE_CTRL_LEFT ,
-                /* '[','1',';','3','A' |0x80,KEYCODE_ALT_UP    , - unused */
-                /* '[','1',';','3','B' |0x80,KEYCODE_ALT_DOWN  , - unused */
+        //      '[','1',';','3','A' |0x80,KEYCODE_ALT_UP    , - unused
+        //      '[','1',';','3','B' |0x80,KEYCODE_ALT_DOWN  , - unused
                 '[','1',';','3','C' |0x80,KEYCODE_ALT_RIGHT,
                 '[','1',';','3','D' |0x80,KEYCODE_ALT_LEFT ,
-                /* '[','3',';','3','~' |0x80,KEYCODE_ALT_DELETE, - unused */
+        //      '[','1',';','5','A' |0x80,KEYCODE_CTRL_UP   , - unused
+        //      '[','1',';','5','B' |0x80,KEYCODE_CTRL_DOWN , - unused
+                '[','1',';','5','C' |0x80,KEYCODE_CTRL_RIGHT,
+                '[','1',';','5','D' |0x80,KEYCODE_CTRL_LEFT ,
+        //      '[','3',';','3','~' |0x80,KEYCODE_ALT_DELETE, - unused
                 0
         };
 
@@ -210,7 +210,7 @@ int64_t FAST_FUNC read_key(int fd, char *buffer, int timeout)
                                 /* Forward to last char */
                                 while (!(*seq & 0x80))
                                         seq++;
-                                /* Skip it and the keycode which follows */
+                                /* Skip seq terminating byte, and KEYCODE_xyz byte that follows */
                                 seq += 2;
                                 break;
                         }
@@ -222,6 +222,7 @@ int64_t FAST_FUNC read_key(int fd, char *buffer, int timeout)
                                  * but we never read ahead that much,
                                  * and n == i here. */
                                 buffer[-1] = 0;
+                                /* Return KEYCODE_xyz (always negative) */
                                 return (signed char)seq[i+1];
                         }
                         i++;
diff --git a/libbb/replace.c b/libbb/replace.c
index bc26b04cc..273330f8a 100644
--- a/libbb/replace.c
+++ b/libbb/replace.c
@@ -28,7 +28,8 @@ unsigned FAST_FUNC count_strstr(const char *str, const char *sub)
 
 char* FAST_FUNC xmalloc_substitute_string(const char *src, int count, const char *sub, const char *repl)
 {
-        char *buf, *dst, *end;
+        char *buf, *dst;
+        const char *end;
         size_t sub_len = strlen(sub);
         size_t repl_len = strlen(repl);
 
diff --git a/libbb/strrstr.c b/libbb/strrstr.c
index a173b034f..bea5d1773 100644
--- a/libbb/strrstr.c
+++ b/libbb/strrstr.c
@@ -19,10 +19,10 @@ char* FAST_FUNC strrstr(const char *haystack, const char *needle)
         if (!needle[0])
                 return (char*)haystack + strlen(haystack);
         while (1) {
-                char *p = strstr(haystack, needle);
+                const char *p = strstr(haystack, needle);
                 if (!p)
                         return r;
-                r = p;
+                r = (char *)p;
                 haystack = p + 1;
         }
 }
diff --git a/libbb/xconnect.c b/libbb/xconnect.c
index 65b1cb8de..c0ed94336 100644
--- a/libbb/xconnect.c
+++ b/libbb/xconnect.c
@@ -115,29 +115,8 @@ void FAST_FUNC xconnect(int s, const struct sockaddr *saddr, socklen_t addrlen)
         }
 }
 
-/* Return port number for a service.
- * If "port" is a number use it as the port.
- * If "port" is a name it is looked up in /etc/services.
- * if NULL, return default_port
- */
-unsigned FAST_FUNC bb_lookup_port(const char *port, const char *protocol, unsigned port_nr)
-{
-        if (port) {
-                port_nr = bb_strtou(port, NULL, 10);
-                if (errno || port_nr > 65535) {
-                        struct servent *tserv = getservbyname(port, protocol);
-                        if (!tserv)
-                                bb_error_msg_and_die("bad port '%s'", port);
-                        port_nr = ntohs(tserv->s_port);
-                }
-        }
-        return (uint16_t)port_nr;
-}
-
-
 /* "New" networking API */
 
-
 int FAST_FUNC get_nport(const struct sockaddr *sa)
 {
 #if ENABLE_FEATURE_IPV6
diff --git a/libbb/xfuncs_printf.c b/libbb/xfuncs_printf.c
index f4d1b913a..3eb30fd94 100644
--- a/libbb/xfuncs_printf.c
+++ b/libbb/xfuncs_printf.c
@@ -381,7 +381,7 @@ void FAST_FUNC bb_unsetenv(const char *var)
         char onstack[128 - 16]; /* smaller stack setup code on x86 */
         char *tp;
 
-        tp = strchr(var, '=');
+        tp = (char*)strchr(var, '=');
         if (tp) {
                 /* In case var was putenv'ed, we can't replace '='
                  * with NUL and unsetenv(var) - it won't work,
diff --git a/libpwdgrp/uidgid_get.c b/libpwdgrp/uidgid_get.c
index d76eb8298..2aa444416 100644
--- a/libpwdgrp/uidgid_get.c
+++ b/libpwdgrp/uidgid_get.c
@@ -32,7 +32,8 @@ int FAST_FUNC get_uidgid(struct bb_uidgid_t *u, const char *ug)
 {
         struct passwd *pwd;
         struct group *gr;
-        char *user, *group;
+        char *user;
+        const char *group;
         unsigned n;
 
         user = (char*)ug;
diff --git a/loginutils/getty.c b/loginutils/getty.c
index 67a08f487..232fa2b84 100644
--- a/loginutils/getty.c
+++ b/loginutils/getty.c
@@ -471,8 +471,10 @@ static char *get_logname(void)
         do {
                 /* Write issue file and prompt */
 #ifdef ISSUE
-                if (!(option_mask32 & F_NOISSUE))
+                if (!(option_mask32 & F_NOISSUE)) {
+                        puts("\r");  /* start a new line */
                         print_login_issue(G.issue, G.tty_name);
+                }
 #endif
                 print_login_prompt();
 
diff --git a/miscutils/bc.c b/miscutils/bc.c
index 31485ae9c..b855c111d 100644
--- a/miscutils/bc.c
+++ b/miscutils/bc.c
@@ -5528,7 +5528,7 @@ static void xc_program_printString(const char *str)
                 char c = *str++;
                 if (c == '\\') {
                         static const char esc[] ALIGN1 = "nabfrt""e\\";
-                        char *n;
+                        const char *n;
 
                         c = *str++;
                         n = strchr(esc, c); // note: if c is NUL, n = \0 at end of esc
diff --git a/miscutils/less.c b/miscutils/less.c
index 91403a252..6da1f88a7 100644
--- a/miscutils/less.c
+++ b/miscutils/less.c
@@ -205,9 +205,10 @@ struct globals {
 #if ENABLE_FEATURE_LESS_WINCH
         unsigned winch_counter;
 #endif
-        ssize_t eof_error; /* eof if 0, error if < 0 */
-        ssize_t readpos;
-        ssize_t readeof; /* must be signed */
+        smallint ndelay_set;
+        ssize_t eof_error_ok; /* eof if 0, error if < 0, > 0 if last read did not indicate either */
+        size_t readpos;
+        size_t read_size;
         const char **buffer;
         const char **flines;
         const char *empty_line_marker;
@@ -255,9 +256,8 @@ struct globals {
 #define winch_counter       (G.winch_counter     )
 /* This one is 100% not cached by compiler on read access */
 #define WINCH_COUNTER (*(volatile unsigned *)&winch_counter)
-#define eof_error           (G.eof_error         )
 #define readpos             (G.readpos           )
-#define readeof             (G.readeof           )
+#define read_size           (G.read_size         )
 #define buffer              (G.buffer            )
 #define flines              (G.flines            )
 #define empty_line_marker   (G.empty_line_marker )
@@ -285,7 +285,7 @@ struct globals {
         less_gets_pos = -1; \
         empty_line_marker = "~"; \
         current_file = 1; \
-        eof_error = 1; \
+        G.eof_error_ok = 1; \
         terminated = 1; \
         IF_FEATURE_LESS_REGEXP(wanted_match = -1;) \
 } while (0)
@@ -466,22 +466,21 @@ static int at_end(void)
  *      that it was seen])
  * max_lineno - last line's number, this one doesn't increment
  *      on line wrap, only on "real" new lines.
- * readbuf[0..readeof-1] - small preliminary buffer.
+ * readbuf[0..read_size-1] - small preliminary buffer.
  * readbuf[readpos] - next character to add to current line.
  * last_line_pos - screen line position of next char to be read
  *      (takes into account tabs and backspaces)
- * eof_error - < 0 error, == 0 EOF, > 0 not EOF/error
+ * G.eof_error_ok - < 0 error, == 0 EOF, > 0 not EOF/error
  *
  * "git log -p | less -m" on the kernel git tree is a good test for EAGAINs,
  * "/search on very long input" and "reaching max line count" corner cases.
  */
 static void read_lines(void)
 {
+        int ndelay_set, eagain, fdflags;
         char *current_line, *p;
         int w = width;
         char last_terminated = terminated;
-        time_t last_time = 0;
-        int retry_EAGAIN = 2;
 #if ENABLE_FEATURE_LESS_REGEXP
         unsigned old_max_fline = max_fline;
 #endif
@@ -507,36 +506,43 @@ static void read_lines(void)
                 last_line_pos = 0;
         }
 
+        // Consider these cases:
+        // "less FILE": can set O_NONBLOCK on open.
+        // "true | less": can't.
+        // " { less; cat; } <FILE": can't. And must not confuse cat.
+        ndelay_set = -1; // "don't know whether stdin is nonblocking"
+        eagain = 0;
+
         while (1) { /* read lines until we reach cur_fline or wanted_match */
                 *p = '\0';
                 terminated = 0;
                 while (1) { /* read chars until we have a line */
                         char c;
                         /* if no unprocessed chars left, eat more */
-                        if (readpos >= readeof) {
-                                int flags = ndelay_on(0);
-
-                                while (1) {
-                                        time_t t;
-
-                                        errno = 0;
-                                        eof_error = safe_read(STDIN_FILENO, readbuf, COMMON_BUFSIZE);
-                                        if (errno != EAGAIN)
-                                                break;
-                                        t = time(NULL);
-                                        if (t != last_time) {
-                                                last_time = t;
-                                                if (--retry_EAGAIN < 0)
-                                                        break;
-                                        }
-                                        sched_yield();
-                                }
-                                fcntl(0, F_SETFL, flags); /* ndelay_off(0) */
+                        if (readpos >= read_size) {
+                                // Read stdin, temporarily make it nonblocking (if it's not already)
+                                if (ndelay_set < 0) {
+                                        ndelay_set = G.ndelay_set; // can be only 0 or 1
+                                        if (ndelay_set == 0) {
+                                                fdflags = ndelay_on(STDIN_FILENO);
+                                                if (fdflags & O_NONBLOCK)
+                                                        ndelay_set = 2; // it _was_ nonblocking, do NOT restore later
+                                        } //else: G.ndelay_set=1: set nonblocking at open(FILE) time
+                                } //else: we were here already, stdin is already nonblocking
+
+                                // NB: we do NOT check last eof_error_ok before reading.
+                                // This has the effect that e.g. PageDown on a regular file
+                                // where we already reached EOF *will try reading anyway*,
+                                // if the file is a growing log file, less *will* show the new data.
                                 readpos = 0;
-                                readeof = eof_error;
-                                if (eof_error <= 0)
+                                G.eof_error_ok = safe_read(STDIN_FILENO, readbuf, COMMON_BUFSIZE);
+                                read_size = G.eof_error_ok;
+                                if (G.eof_error_ok <= 0) {
+                                        if (G.eof_error_ok < 0 && errno == EAGAIN)
+                                                eagain = 1;
+                                        read_size = 0; // -1 would be seen as UINT_MAX, prevent
                                         goto reached_eof;
-                                retry_EAGAIN = 1;
+                                }
                         }
                         c = readbuf[readpos];
                         /* backspace? [needed for manpages] */
@@ -619,7 +625,7 @@ static void read_lines(void)
                         max_lineno++;
 
                 if (max_fline >= MAXLINES) {
-                        eof_error = 0; /* Pretend we saw EOF */
+                        G.eof_error_ok = 0; /* Pretend we saw EOF */
                         break;
                 }
                 if (!at_end()) {
@@ -634,7 +640,11 @@ static void read_lines(void)
                                 break;
 #endif
                 }
-                if (eof_error <= 0) {
+                if (G.eof_error_ok <= 0) { /* EOF or error? */
+                        if (eagain) {
+                                G.eof_error_ok = 1; // "neither EOF nor error: stdin not ready"
+                                //^^^ needed to make main loop's poll() check stdin
+                        }
                         break;
                 }
                 max_fline++;
@@ -643,15 +653,16 @@ static void read_lines(void)
                 last_line_pos = 0;
         } /* end of "read lines until we reach cur_fline" loop */
 
-        if (eof_error < 0) {
-                if (errno == EAGAIN) {
-                        eof_error = 1;
-                } else {
-                        print_statusline(bb_msg_read_error);
-                }
-        }
+        if (ndelay_set == 0) // stdin was not nonblocking, restore that
+                fcntl(STDIN_FILENO, F_SETFL, fdflags);
+
+        // Will not be seen (overwritten immediately)
+        //if (G.eof_error_ok < 0) { // error?
+        //      print_statusline(bb_msg_read_error);
+        //      bb_error_msg("G.eof_error_ok:%d", G.eof_error_ok); sleep(5);
+        //} else
 #if ENABLE_FEATURE_LESS_FLAGS
-        else if (eof_error == 0)
+        if (G.eof_error_ok == 0) // EOF?
                 num_lines = max_lineno;
 #endif
 
@@ -731,17 +742,17 @@ static void m_status_print(void)
         clear_line();
         printf(HIGHLIGHT"%s", filename);
         if (num_files > 1)
-                printf(" (file %i of %i)", current_file, num_files);
+                printf(" (file %d of %d)", current_file, num_files);
 
         first = safe_lineno(cur_fline);
         last = (option_mask32 & FLAG_S)
                         ? MIN(first + max_displayed_line, max_lineno)
                         : safe_lineno(cur_fline + max_displayed_line);
-        printf(" lines %i-%i", first, last);
+        printf(" lines %d-%d", first, last);
 
         update_num_lines();
         if (num_lines >= 0)
-                printf("/%i", num_lines);
+                printf("/%d", num_lines);
 
         if (at_end()) {
                 printf(" (END)");
@@ -749,8 +760,11 @@ static void m_status_print(void)
                         printf(" - next: %s", files[current_file]);
         } else if (num_lines > 0) {
                 percent = (100 * last + num_lines/2) / num_lines;
-                printf(" %i%%", percent <= 100 ? percent : 100);
+                printf(" %d%%", percent <= 100 ? percent : 100);
         }
+        if (G.eof_error_ok < 0)
+                // Reproducer: strace -oLOG -e fault=read:error=EIO:when=2 less FILE
+                printf(" %s", bb_msg_read_error);
         printf(NORMAL);
 }
 #endif
@@ -780,6 +794,9 @@ static void status_print(void)
         p = "(END)";
         if (!cur_fline)
                 p = filename;
+        if (G.eof_error_ok < 0)
+                // Reproducer: strace -oLOG -e fault=read:error=EIO:when=2 less FILE
+                p = bb_msg_read_error;
         if (num_files > 1) {
                 printf(HIGHLIGHT"%s (file %i of %i)"NORMAL,
                                 p, current_file, num_files);
@@ -944,9 +961,9 @@ static void buffer_print(void)
                         print_ascii(buffer[i]);
         }
         if ((option_mask32 & (FLAG_E|FLAG_F))
-         && eof_error <= 0
+         && G.eof_error_ok <= 0
         ) {
-                i = option_mask32 & FLAG_F ? 0 : cur_fline;
+                i = (option_mask32 & FLAG_F) ? 0 : cur_fline;
                 if (max_fline - i <= max_displayed_line)
                         less_exit();
         }
@@ -999,7 +1016,7 @@ static void goto_lineno(int target)
                 while (LINENO(flines[cur_fline]) != target && cur_fline < max_fline)
                         ++cur_fline;
                 /* target not reached but more input is available */
-                if (LINENO(flines[cur_fline]) != target && eof_error > 0) {
+                if (LINENO(flines[cur_fline]) != target && G.eof_error_ok > 0) {
                         read_lines();
                         goto retry;
                 }
@@ -1082,8 +1099,11 @@ static void buffer_lineno(int lineno)
 
 static void open_file_and_read_lines(void)
 {
+        G.ndelay_set = 0;
         if (filename) {
                 xmove_fd(xopen(filename, O_RDONLY), STDIN_FILENO);
+                ndelay_on(STDIN_FILENO);
+                G.ndelay_set = 1;
 #if ENABLE_FEATURE_LESS_FLAGS
                 num_lines = REOPEN_AND_COUNT;
 #endif
@@ -1096,7 +1116,7 @@ static void open_file_and_read_lines(void)
 #endif
         }
         readpos = 0;
-        readeof = 0;
+        read_size = 0;
         last_line_pos = 0;
         terminated = 1;
         read_lines();
@@ -1128,13 +1148,17 @@ static void reinitialize(void)
         buffer_fill_and_print();
 }
 
+/* Poll stdin and keyboard.
+ * If stdin has more data, redraw and repeat.
+ * Return keycode when a key is pressed.
+ */
 #if ENABLE_PLATFORM_MINGW32
 static int64_t unix_getch_nowait(void)
 #else
 static int64_t getch_nowait(void)
 #endif
 {
-        int rd;
+        int dont_poll_stdin;
         int64_t key64;
         struct pollfd pfd[2];
 
@@ -1150,11 +1174,11 @@ static int64_t getch_nowait(void)
          * Even if select/poll says that input is available, read CAN block
          * (switch fd into O_NONBLOCK'ed mode to avoid it)
          */
-        rd = 1;
+        dont_poll_stdin = 1;
         /* Are we interested in stdin? */
         if (at_end()) {
-                if (eof_error > 0) /* did NOT reach eof yet */
-                        rd = 0; /* yes, we are interested in stdin */
+                if (G.eof_error_ok > 0) /* did NOT reach EOF/error yet */
+                        dont_poll_stdin = 0; /* yes, we are interested in stdin */
         }
         /* Position cursor if line input is done */
         if (less_gets_pos >= 0)
@@ -1166,21 +1190,24 @@ static int64_t getch_nowait(void)
                 while (1) {
                         int r;
                         /* NB: SIGWINCH interrupts poll() */
-                        r = poll(pfd + rd, 2 - rd, -1);
-                        if (/*r < 0 && errno == EINTR &&*/ winch_counter)
+                        r = poll(pfd + dont_poll_stdin, 2 - dont_poll_stdin, -1);
+                        if (/*r < 0 && errno == EINTR &&*/ winch_counter != 0)
                                 return '\\'; /* anything which has no defined function */
                         if (r) break;
                 }
 #else
-                safe_poll(pfd + rd, 2 - rd, -1);
+                safe_poll(pfd + dont_poll_stdin, 2 - dont_poll_stdin, -1);
 #endif
         }
 
+        if (pfd[1].revents == 0)
+                goto no_kbd_input;
         /* We have kbd_fd in O_NONBLOCK mode, read inside safe_read_key()
          * would not block even if there is no input available */
         key64 = safe_read_key(kbd_fd, kbd_input, /*do not poll:*/ -2);
         if ((int)key64 == -1) {
                 if (errno == EAGAIN) {
+ no_kbd_input:
                         /* No keyboard input available. Since poll() did return,
                          * we should have input on stdin */
                         read_lines();
@@ -1408,7 +1435,7 @@ static void goto_match(int match)
         if (match < 0)
                 match = 0;
         /* Try to find next match if eof isn't reached yet */
-        if (match >= num_matches && eof_error > 0) {
+        if (match >= num_matches && G.eof_error_ok > 0) {
                 wanted_match = match; /* "I want to read until I see N'th match" */
                 read_lines();
         }
@@ -2014,7 +2041,7 @@ int less_main(int argc, char **argv)
                 int64_t keypress;
 
 #if ENABLE_FEATURE_LESS_WINCH
-                while (WINCH_COUNTER) {
+                while (WINCH_COUNTER != 0) {
  again:
                         winch_counter--;
                         IF_FEATURE_LESS_ASK_TERMINAL(G.winsize_err =) get_terminal_width_height(kbd_fd, &width, &max_displayed_line);
diff --git a/networking/httpd.c b/networking/httpd.c
index 02507b8f0..ddb346f18 100644
--- a/networking/httpd.c
+++ b/networking/httpd.c
@@ -2006,7 +2006,7 @@ static void send_cgi_and_exit(
  */
 static NOINLINE void send_file_and_exit(const char *url, int what)
 {
-        char *suffix;
+        const char *suffix;
         int fd;
         ssize_t count;
 
diff --git a/networking/ifconfig.c b/networking/ifconfig.c
index 9ee232a66..32638e2a3 100644
--- a/networking/ifconfig.c
+++ b/networking/ifconfig.c
@@ -336,7 +336,7 @@ int ifconfig_main(int argc UNUSED_PARAM, char **argv)
 #endif
         char *p;
         /*char host[128];*/
-        const char *host = NULL; /* make gcc happy */
+        char *host = NULL; /* make gcc happy */
         IF_FEATURE_IFCONFIG_STATUS(char *show_all_param;)
 
         did_flags = 0;
diff --git a/networking/ifupdown.c b/networking/ifupdown.c
index bc2dca506..6832ee0d4 100644
--- a/networking/ifupdown.c
+++ b/networking/ifupdown.c
@@ -363,7 +363,7 @@ static char *parse(const char *command, struct interface_defn_t *ifd)
                         break;
                 case '%':
                         {
-                                char *nextpercent;
+                                const char *nextpercent;
                                 char *varvalue;
 
                                 command++;
diff --git a/networking/inetd.c b/networking/inetd.c
index e63edcd9d..6220a08e3 100644
--- a/networking/inetd.c
+++ b/networking/inetd.c
@@ -969,9 +969,8 @@ static void reread_config_file(int sig UNUSED_PARAM)
         servtab_t *sep, *cp, **sepp;
         len_and_sockaddr *lsa;
         sigset_t omask;
-        unsigned n;
-        uint16_t port;
         int save_errno = errno;
+        char *p_etc_services = NULL;
 
         if (!reopen_config_file())
                 goto ret;
@@ -1039,7 +1038,9 @@ static void reread_config_file(int sig UNUSED_PARAM)
                         break;
 
                 default: /* case AF_INET, case AF_INET6 */
-                        n = bb_strtou(sep->se_service, NULL, 10);
+                {
+                        unsigned portno;
+                        portno = bb_strtou(sep->se_service, NULL, 10);
 #if ENABLE_FEATURE_INETD_RPC
                         if (is_rpc_service(sep)) {
                                 sep->se_rpcprog = n;
@@ -1059,26 +1060,23 @@ static void reread_config_file(int sig UNUSED_PARAM)
                         }
 #endif
                         /* what port to listen on? */
-                        port = htons(n);
-                        if (errno || n > 0xffff) { /* se_service is not numeric */
+                        if (errno || portno > 0xffff) { /* se_service is not numeric */
                                 char protoname[4];
-                                struct servent *sp;
                                 /* can result only in "tcp" or "udp": */
                                 safe_strncpy(protoname, sep->se_proto, 4);
-                                sp = getservbyname(sep->se_service, protoname);
-                                if (sp == NULL) {
+                                portno = bb_get_servport_by_name(&p_etc_services, sep->se_service, protoname);
+                                if (portno > 0xffff) {
                                         bb_error_msg("%s/%s: unknown service",
                                                         sep->se_service, sep->se_proto);
                                         goto next_cp;
                                 }
-                                port = sp->s_port;
                         }
                         if (LONE_CHAR(sep->se_local_hostname, '*')) {
                                 lsa = xzalloc_lsa(sep->se_family);
-                                set_nport(&lsa->u.sa, port);
+                                set_nport(&lsa->u.sa, htons(portno));
                         } else {
                                 lsa = host_and_af2sockaddr(sep->se_local_hostname,
-                                                ntohs(port), sep->se_family);
+                                                portno, sep->se_family);
                                 if (!lsa) {
                                         bb_error_msg("%s/%s: unknown host '%s'",
                                                 sep->se_service, sep->se_proto,
@@ -1087,6 +1085,7 @@ static void reread_config_file(int sig UNUSED_PARAM)
                                 }
                         }
                         break;
+                }//default:
                 } /* end of "switch (sep->se_family)" */
 
                 /* did lsa change? Then close/open */
@@ -1134,6 +1133,7 @@ static void reread_config_file(int sig UNUSED_PARAM)
         }
         restore_sigmask(&omask);
  ret:
+        free(p_etc_services);
         errno = save_errno;
 }
 
diff --git a/networking/nbd-client.c b/networking/nbd-client.c
index 556fa8c97..4fda66125 100644
--- a/networking/nbd-client.c
+++ b/networking/nbd-client.c
@@ -260,7 +260,7 @@ int nbdclient_main(int argc, char **argv)
                 // needs some other process to sit in ioctl(nbd, NBD_DO_IT).
                 if (fork() == 0) {
                         /* child */
-                        char *s = strrchr(device, '/');
+                        const char *s = strrchr(device, '/');
                         sprintf(data, "/sys/block/%.32s/pid", s ? s + 1 : device);
                         // Is it up yet?
                         for (;;) {
diff --git a/networking/netstat.c b/networking/netstat.c
index d7afa8fdd..d31928957 100644
--- a/networking/netstat.c
+++ b/networking/netstat.c
@@ -176,6 +176,7 @@ struct globals {
         smallint prg_cache_loaded;
         struct prg_node *prg_hash[PRG_HASH_SIZE];
 #endif
+        char *p_etc_services;
 #if ENABLE_FEATURE_NETSTAT_PRG
         const char *progname_banner;
 #endif
@@ -378,15 +379,15 @@ static void build_ipv4_addr(char* local_addr, struct sockaddr_in* localaddr)
 
 static const char *get_sname(int port, const char *proto, int numeric)
 {
-        if (!port)
+        if (port == 0)
                 return "*";
         if (!numeric) {
-                struct servent *se = getservbyport(port, proto);
+                const char *se = bb_get_servname_by_port(&G.p_etc_services, port, proto);
                 if (se)
-                        return se->s_name;
+                        return se;
         }
         /* hummm, we may return static buffer here!! */
-        return itoa(ntohs(port));
+        return itoa(port);
 }
 
 static char *ip_port_str(struct sockaddr *addr, int port, const char *proto, int numeric)
@@ -402,7 +403,7 @@ static char *ip_port_str(struct sockaddr *addr, int port, const char *proto, int
         if (!host)
                 host = xmalloc_sockaddr2dotted_noport(addr);
 
-        xasprintf_inplace(host, "%s:%s", host, get_sname(htons(port), proto, numeric));
+        xasprintf_inplace(host, "%s:%s", host, get_sname(port, proto, numeric));
         return host;
 }
 
diff --git a/networking/pscan.c b/networking/pscan.c
index 13785deca..454dba3fb 100644
--- a/networking/pscan.c
+++ b/networking/pscan.c
@@ -37,13 +37,13 @@
 #define DERR(...) ((void)0)
 #endif
 
-static const char *port_name(unsigned port)
+static const char *port_name(char **p_etc_services, unsigned port)
 {
-        struct servent *server;
+        char *server;
 
-        server = getservbyport(htons(port), NULL);
+        server = bb_get_servname_by_port(p_etc_services, port, NULL);
         if (server)
-                return server->s_name;
+                return server;
         return "unknown";
 }
 
@@ -62,6 +62,7 @@ int pscan_main(int argc UNUSED_PARAM, char **argv)
          * Rule of thumb: with min_rtt of N msec, scanning 1000 ports
          * will take N seconds at absolute minimum */
         const char *opt_min_rtt = "5";          /* -T: default min rtt in msec */
+        char *p_etc_services = NULL;
         const char *result_str;
         len_and_sockaddr *lsap;
         int s;
@@ -152,7 +153,8 @@ int pscan_main(int argc UNUSED_PARAM, char **argv)
                 DMSG("out of loop @%u", diff);
                 if (result_str)
                         printf("%5u" "\t" "tcp" "\t" "%s" "\t" "%s" "\n",
-                                        port, result_str, port_name(port));
+                                port, result_str, port_name(&p_etc_services, port)
+                        );
 
                 /* Estimate new rtt - we don't want to wait entire timeout
                  * for each port. *4 allows for rise in net delay.
diff --git a/networking/route.c b/networking/route.c
index 6e2d30cfd..9d9b72416 100644
--- a/networking/route.c
+++ b/networking/route.c
@@ -179,7 +179,7 @@ static NOINLINE void INET_setroute(int action, char **args)
         memset(rt, 0, sizeof(*rt));
 
         {
-                const char *target = *args++;
+                char *target = *args++;
                 char *prefix;
 
                 /* recognize x.x.x.x/mask format. */
@@ -353,25 +353,25 @@ static NOINLINE void INET6_setroute(int action, char **args)
         int prefix_len, skfd;
         const char *devname;
 
-                /* We know args isn't NULL from the check in route_main. */
-                const char *target = *args++;
-
-                if (strcmp(target, "default") == 0) {
-                        prefix_len = 0;
-                        memset(&sa6, 0, sizeof(sa6));
+        /* We know args isn't NULL from the check in route_main. */
+        char *target = *args++;
+
+        if (strcmp(target, "default") == 0) {
+                prefix_len = 0;
+                memset(&sa6, 0, sizeof(sa6));
+        } else {
+                char *cp;
+                cp = strchr(target, '/'); /* Yes... const to non is ok. */
+                if (cp) {
+                        *cp = '\0';
+                        prefix_len = xatoul_range(cp + 1, 0, 128);
                 } else {
-                        char *cp;
-                        cp = strchr(target, '/'); /* Yes... const to non is ok. */
-                        if (cp) {
-                                *cp = '\0';
-                                prefix_len = xatoul_range(cp + 1, 0, 128);
-                        } else {
-                                prefix_len = 128;
-                        }
-                        if (INET6_resolve(target, (struct sockaddr_in6 *) &sa6) < 0) {
-                                bb_error_msg_and_die("resolving %s", target);
-                        }
+                        prefix_len = 128;
                 }
+                if (INET6_resolve(target, (struct sockaddr_in6 *) &sa6) < 0) {
+                        bb_error_msg_and_die("resolving %s", target);
+                }
+        }
 
         /* Clean out the RTREQ structure. */
         memset(&rt, 0, sizeof(rt));
diff --git a/networking/ssl_client.c b/networking/ssl_client.c
index 757745896..4d021a4ec 100644
--- a/networking/ssl_client.c
+++ b/networking/ssl_client.c
@@ -16,7 +16,7 @@
 
 //usage:#define ssl_client_trivial_usage
 //usage:    IF_NOT_PLATFORM_MINGW32(
-//usage:       "[-e] -s FD [-r FD] [-n SNI]"
+//usage:       "[-n SNI] { -s FD [-r FD] | HOST | -e PROG ARGS }"
 //usage:    )
 //usage:    IF_PLATFORM_MINGW32(
 //usage:       "[-e] -h handle [-n SNI]"
@@ -28,51 +28,104 @@
 int ssl_client_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int ssl_client_main(int argc UNUSED_PARAM, char **argv)
 {
+        int exit_if_stdin_closed;
         tls_state_t *tls;
         const char *sni = NULL;
         int opt;
 #if ENABLE_PLATFORM_MINGW32
         char *hstr = NULL;
         HANDLE h;
+        enum {
+                /* wrong name so exit_if_stdin_closed is set later */
+                OPT_s = (1 << 0),
+                OPT_h = (1 << 1),
+                OPT_n = (1 << 2),
+        };
+#else
+        enum {
+                OPT_s = (1 << 0),
+                OPT_r = (1 << 1),
+                OPT_n = (1 << 2),
+                OPT_e = (1 << 3),
+        };
 #endif
 
         // INIT_G();
-
         tls = new_tls_state();
-#if !ENABLE_PLATFORM_MINGW32
-        opt = getopt32(argv, "es:+r:+n:", &tls->ofd, &tls->ifd, &sni);
-        if (!(opt & (1<<2))) {
-                /* -r N defaults to -s N */
-                tls->ifd = tls->ofd;
-        }
-#else
+#if ENABLE_PLATFORM_MINGW32
         opt = getopt32(argv, "eh:n:", &hstr, &sni);
-#endif
 
-        if (!(opt & (3<<1))) {
-                if (!argv[1])
+        if (!hstr || sscanf(hstr, "%p", &h) != 1)
+                bb_error_msg_and_die("invalid handle");
+        init_winsock();
+        tls->ifd = tls->ofd = _open_osfhandle((intptr_t)h, _O_RDWR|_O_BINARY);
+#else
+        /* "+": stop on first non-option */
+        opt = getopt32(argv, "^+" "s:+r:+n:e" "\0"
+                "e--s:e--r:s--e:r--e", &tls->ofd, &tls->ifd, &sni
+        );
+        argv += optind;
+
+        if (opt & OPT_e) {
+                /* -e PROG: run PROG and talk TLS to its stdin/stdout */
+                // Talk to local HTTP server behind local TLS server:
+                // printf "GET / HTTP/1.1\r\n\r\n" | ssl_client -e ssl_server -d PRIVKEY.der -e httpd -i
+                struct fd_pair to_prog;
+                struct fd_pair from_prog;
+
+                pid_t pid;
+
+                if (!argv[0])
                         bb_show_usage();
-                /* Undocumented debug feature: without -s and -r, takes HOST arg and connects to it */
-                //
+
+                xpiped_pair(to_prog);
+                xpiped_pair(from_prog);
+
+                pid = xvfork();
+                if (pid == 0) {
+                        /* Child: run the program */
+
+                        /* NB: close _first_, then move fds! */
+                        close(to_prog.wr);
+                        close(from_prog.rd);
+                        xmove_fd(to_prog.rd, STDIN_FILENO);
+                        xmove_fd(from_prog.wr, STDOUT_FILENO);
+
+                        BB_EXECVP_or_die(argv);
+                }
+
+                /* Parent: close child ends of pipes */
+                close(to_prog.rd);
+                close(from_prog.wr);
+
+                tls->ofd = to_prog.wr;   /* write to program's stdin */
+                tls->ifd = from_prog.rd; /* read from program's stdout */
+
+        } else if (!(opt & (OPT_s|OPT_r))) {
+                /* Not -e/-s/-r: connect to HOST */
                 // Talk to kernel.org:
-                // printf "GET / HTTP/1.1\r\nHost: kernel.org\r\n\r\n" | busybox ssl_client kernel.org
+                // printf "GET / HTTP/1.1\r\nHost: kernel.org\r\n\r\n" | ssl_client kernel.org
+                if (!argv[0] || argv[1])
+                        bb_show_usage();
                 if (!sni)
-                        sni = argv[1];
-                tls->ifd = tls->ofd = create_and_connect_stream_or_die(argv[1], 443);
-        }
-#if ENABLE_PLATFORM_MINGW32
-        else {
-                if (!hstr || sscanf(hstr, "%p", &h) != 1)
-                        bb_error_msg_and_die("invalid handle");
-                init_winsock();
-                tls->ifd = tls->ofd = _open_osfhandle((intptr_t)h, _O_RDWR|_O_BINARY);
+                        sni = argv[0];
+                tls->ifd = tls->ofd = create_and_connect_stream_or_die(argv[0], 443);
+
+        } else {
+                /* -s FD [-r FD] */
+                if (!(opt & OPT_s) || argv[0])
+                        bb_show_usage();
+                if (!(opt & OPT_r)) {
+                        /* -r FD defaults to -s FD */
+                        tls->ifd = tls->ofd;
+                }
         }
 #endif
 
         tls_handshake(tls, sni);
 
-        BUILD_BUG_ON(TLSLOOP_EXIT_ON_LOCAL_EOF != 1);
-        tls_run_copy_loop(tls, /*flags*/ opt & 1);
+        exit_if_stdin_closed = (opt & OPT_s) ? TLSLOOP_EXIT_ON_LOCAL_EOF : 0;
+        tls_run_copy_loop(tls, /*flags*/ exit_if_stdin_closed);
 
         return EXIT_SUCCESS;
 }
diff --git a/networking/ssl_server.c b/networking/ssl_server.c
new file mode 100644
index 000000000..2a89dae6c
--- /dev/null
+++ b/networking/ssl_server.c
@@ -0,0 +1,121 @@
+/*
+ * Licensed under GPLv2, see file LICENSE in this source tree.
+ */
+//config:config SSL_SERVER
+//config:       bool "ssl_server (test TLS server)"
+//config:       default y
+//config:       select TLS
+//config:       help
+//config:       inetd-style TLS server. Stdin/stdout are already connected
+//config:       to an accepted TCP socket.
+
+//applet:IF_SSL_SERVER(APPLET(ssl_server, BB_DIR_USR_BIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_SSL_SERVER) += ssl_server.o
+
+//usage:#define ssl_server_trivial_usage
+//usage:       "-f PRIVKEY_CERT.pem PROG ARGS"
+//usage:#define ssl_server_full_usage ""
+//usage:       "Inetd-style TLS server\n"
+//usage:     "\n        -f PEMFILE      HAProxy-style CRT file"
+/*
+# Generate RSA key and certificate
+openssl req -x509 -newkey rsa:4096 \
+        -keyout $HOSTNAME-rsa.key \
+        -out $HOSTNAME-rsa.crt \
+        -sha256 -days 9999 -nodes \
+        -subj /CN=$HOSTNAME \
+        -addext "subjectAltName=DNS:$HOSTNAME"
+# Generate ECDSA key and certificate
+openssl genpkey -algorithm EC \
+        -pkeyopt ec_paramgen_curve:prime256v1 \
+        -out $HOSTNAME-ecdsa.key
+fopenssl req -new -x509 \
+        -key $HOSTNAME-ecdsa.key \
+        -out $HOSTNAME-ecdsa.crt \
+        -sha256 -days 9999 \
+        -subj "/CN=$HOSTNAME" \
+        -addext "subjectAltName=DNS:$HOSTNAME"
+# Concatenate all these files into PRIVKEY_CERT.pem
+{       cat $HOSTNAME-rsa.key
+        cat $HOSTNAME-rsa.crt
+        cat $HOSTNAME-ecdsa.key
+        cat $HOSTNAME-ecdsa.crt
+} >PRIVKEY_CERT.pem
+*/
+#include "libbb.h"
+
+/* TLS server applet.
+ *
+ * To generate a test RSA certificate and key:
+ * openssl req -x509 -newkey rsa:2048 -days 9999 -nodes \
+ *     -subj '/CN=localhost' \
+ *     -out cert.pem -keyout privkey.pem
+ * Convert to DER format:
+ * openssl x509 -in cert.pem -outform DER -out cert.der
+ * openssl rsa -in privkey.pem -outform DER -out privkey.der
+ *
+ * Run the server:
+ * tcpsvd 127.0.0.1 4433 ssl_server -p privkey.der -c cert.der -e echo 'Hello world'
+ *
+ * Test with:
+ * openssl s_client -connect localhost:4433
+ */
+int ssl_server_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int ssl_server_main(int argc UNUSED_PARAM, char **argv)
+{
+        struct fd_pair to_prog;
+        struct fd_pair from_prog;
+        pid_t pid;
+        tls_state_t *tls;
+        const char *pem_file;
+        unsigned opt;
+
+        tls = new_tls_state();
+
+        /* "+": stop on first non-option */
+        opt = getopt32(argv, "+""vf:",
+                &pem_file
+        );
+        argv += optind;
+        if (!argv[0] || !(opt & 2))
+                bb_show_usage();
+
+        /* In inetd mode, stdin/stdout are the socket.
+         * But tls_run_copy_loop() needs *non-TLS* fds on STDIN and STDOUT.
+         * Shuffle them.
+         */
+        xdup2(STDIN_FILENO, 3);
+        xdup2(STDOUT_FILENO, 4);
+        tls->ifd = 3;
+        tls->ofd = 4;
+
+        /* This can abort on errors */
+        tls_handshake_as_server(tls, pem_file);
+
+        /* Run PROG, wrap its data in TLS and I/O to socket */
+        xpiped_pair(to_prog);
+        xpiped_pair(from_prog);
+        pid = xvfork();
+        if (pid == 0) {
+                /* Child: run the program */
+
+                /* NB: close _first_, then move fds! */
+                close(to_prog.wr);
+                close(from_prog.rd);
+                xmove_fd(to_prog.rd, STDIN_FILENO);
+                xmove_fd(from_prog.wr, STDOUT_FILENO);
+
+                BB_EXECVP_or_die(argv);
+        }
+        /* Parent: close child ends of pipes */
+        close(to_prog.rd);
+        close(from_prog.wr);
+
+        /* tls_run_copy_loop() needs non-TLS fds on STDIN and STDOUT */
+        xmove_fd(from_prog.rd, STDIN_FILENO);
+        xmove_fd(to_prog.wr, STDOUT_FILENO);
+        tls_run_copy_loop(tls, /*flags*/ TLSLOOP_EXIT_ON_LOCAL_EOF);
+
+        return EXIT_SUCCESS;
+}
diff --git a/networking/telnet.c b/networking/telnet.c
index 7a0253525..a0eadc91b 100644
--- a/networking/telnet.c
+++ b/networking/telnet.c
@@ -11,13 +11,11 @@
  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  *
  * HISTORY
- * Revision 3.1  1994/04/17  11:31:54  too
- * initial revision
- * Modified 2000/06/13 for inclusion into BusyBox by Erik Andersen <andersen@codepoet.org>
- * Modified 2001/05/07 to add ability to pass TTYPE to remote host by Jim McQuillan
- * <jam@ltsp.org>
- * Modified 2004/02/11 to add ability to pass the USER variable to remote host
- * by Fernando Silveira <swrh@gmx.net>
+ * 1994/04/17 Initial revision
+ * 2000/06/13 for inclusion into BusyBox by Erik Andersen <andersen@codepoet.org>
+ * 2001/05/07 add ability to pass TTYPE to remote host by Jim McQuillan <jam@ltsp.org>
+ * 2004/02/11 add ability to pass the USER variable to remote host by Fernando Silveira <swrh@gmx.net>
+ * 2026/02/20 Almost total rewrite to use ioloop()
  */
 //config:config TELNET
 //config:       bool "telnet (8.8 kb)"
@@ -54,20 +52,14 @@
 
 //kbuild:lib-$(CONFIG_TELNET) += telnet.o
 
-//usage:#if ENABLE_FEATURE_TELNET_AUTOLOGIN
 //usage:#define telnet_trivial_usage
-//usage:       "[-a] [-l USER] HOST [PORT]"
-//usage:#define telnet_full_usage "\n\n"
-//usage:       "Connect to telnet server\n"
-//usage:     "\n        -a      Automatic login with $USER variable"
-//usage:     "\n        -l USER Automatic login as USER"
-//usage:
-//usage:#else
-//usage:#define telnet_trivial_usage
-//usage:       "HOST [PORT]"
+//usage:        IF_FEATURE_TELNET_AUTOLOGIN("[-a] [-l USER] ")"HOST [PORT]"
 //usage:#define telnet_full_usage "\n\n"
 //usage:       "Connect to telnet server"
-//usage:#endif
+//usage:        IF_FEATURE_TELNET_AUTOLOGIN("\n"
+//usage:     "\n        -a      Automatic login with $USER envvar"
+//usage:     "\n        -l USER Automatic login as USER"
+//usage:        )
 
 #include <arpa/telnet.h>
 #include <netinet/in.h>
@@ -80,285 +72,183 @@
 # define DONT        254  /* you are not to use option */
 # define DO          253  /* please, you use option */
 # define WONT        252  /* I won't use option */
-# define WILL        251  /* I will use option */
-# define SB          250  /* interpret as subnegotiation */
-# define SE          240  /* end sub negotiation */
+# define WILL        251  /* I will use option (if I see your "IAC DO <opt>" confirmation */
+# define SB          250  /* begin subnegotiation */
+# define SE          240  /* end subnegotiation */
 # define TELOPT_ECHO   1  /* echo */
 # define TELOPT_SGA    3  /* suppress go ahead */
 # define TELOPT_TTYPE 24  /* terminal type */
 # define TELOPT_NAWS  31  /* window size */
 #endif
 
-enum {
-        DATABUFSIZE = 128,
-        IACBUFSIZE  = 128,
+#define SUPPORT_FOR_LOCAL_OPTS (0 \
+        || ENABLE_FEATURE_TELNET_WIDTH \
+        || ENABLE_FEATURE_TELNET_TTYPE \
+        || ENABLE_FEATURE_TELNET_AUTOLOGIN \
+        )
+
+// -v option
+#define VERBOSE 0
+// lots of unconditional debug
+#define DEBUG   0
 
-        CHM_TRY = 0,
-        CHM_ON  = 1,
-        CHM_OFF = 2,
+#if DEBUG
+# define dbg(...) bb_error_msg(__VA_ARGS__)
+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);
+}
+#else
+# define dbg(...) ((void)0)
+#endif
 
-        UF_ECHO = 0x01,
-        UF_SGA  = 0x02,
+#if VERBOSE
+# define log1(...) do { if (G.verbose) bb_error_msg(__VA_ARGS__); } while (0)
+# define IF_VERBOSE(...) __VA_ARGS__
+#else
+# define log1(...) ((void)0)
+# define IF_VERBOSE(...) /* nothing */
+#endif
 
+enum {
         TS_NORMAL = 0,
-        TS_COPY = 1,
-        TS_IAC  = 2,
-        TS_OPT  = 3,
-        TS_SUB1 = 4,
-        TS_SUB2 = 5,
-        TS_CR   = 6,
+        TS_IAC  = 1,
+        TS_OPT  = 2,
+        TS_SUB1 = 3,
+        TS_SUB2 = 4,
+        TS_CR   = 5,
+
+        MAX_NAWS_SIZE = 13, // pathological 65535x65535 case needs full escaping
+
+        netfd   = 3,
 };
 
 typedef unsigned char byte;
 
-enum { netfd = 3 };
+typedef struct stdin_to_net {
+        STRUCT_CONNECTION
+        int rdidx, wridx, size;
+        //byte buf[BUFSIZE];
+} stdin_to_net_t;
+typedef struct net_to_stdout {
+        STRUCT_CONNECTION
+        int rdidx, wridx, size;
+        byte input_state;
+        byte negotiation_verb;
+        //byte buf[BUFSIZE];
+} net_to_stdout_t;
+#if DEBUG
+static void set_input_state(net_to_stdout_t *conn, int new_state, int c)
+{
+        if (conn->input_state != new_state) {
+                conn->input_state = new_state;
+                dbg("input_state=%d at char:0x%02x '%c'", new_state, c,
+                        c >= 32 && c < 127 ? c : '.');
+        }
+}
+# define SET_INPUT_STATE(conn, state, c) set_input_state(conn, state, c)
+#else
+# define SET_INPUT_STATE(conn, state, c) ((conn)->input_state = (state))
+#endif
 
 struct globals {
-        int     iaclen; /* could even use byte, but it's a loss on x86 */
-        byte    telstate; /* telnet negotiation state from network input */
-        byte    telwish;  /* DO, DONT, WILL, WONT */
-        byte    charmode;
-        byte    telflags;
-        byte    do_termios;
-#if ENABLE_FEATURE_TELNET_TTYPE
-        char    *ttype;
-#endif
-#if ENABLE_FEATURE_TELNET_AUTOLOGIN
-        const char *autologin;
-#endif
-#if ENABLE_FEATURE_TELNET_WIDTH
-        unsigned win_width, win_height;
-#endif
-        /* same buffer used both for network and console read/write */
-        char    buf[DATABUFSIZE];
-        /* buffer to handle telnet negotiations */
-        char    iacbuf[IACBUFSIZE];
-        struct termios termios_def;
-        struct termios termios_raw;
+        unsigned        flags;
+// Set when server agreed to use NAWS:
+#define FLAGS_NAWS_ON   (1 << 0)
+// SGA option seen and responded to, no longer look for it:
+#define FLAGS_SGA_SEEN  (1 << 1)
+// Seen telnet protocol from server and sent our WILLs:
+#define INITIAL_SENT    (1 << 2)
+#define DO_TERMIOS      (1 << 3)
+
+        byte                word_aligned_bytes[2];
+#define changes_seen        word_aligned_bytes[0]
+#define CHANGED_ECHO        (1 << 0)
+#define CHANGED_NAWS        (1 << 1)
+// These happen only once:
+#define CHANGED_SGA         (1 << 2)
+#define CHANGED_TTYPE       (1 << 3)
+#define CHANGED_NEW_ENVIRON (1 << 4)
+// The second byte is changed async, by signal handler:
+#define got_SIGWINCH        word_aligned_bytes[1]
+#define G_changes_or_WINCH  (*(uint16_t*)G.word_aligned_bytes)
+// The "shared word" trick is unsafe on only-word-store arches such as DEC Alpha or SHARC,
+// but Alpha retired in 2004 and SHARC does not run linux (it's a DSP).
+
+        byte            optstate_ECHO;
+// On program start:
+#define OPT_ECHO_UNKNOWN 0xff
+#define OPT_ECHO_OFF     0
+// We operate tty in rawmode only when echo ON (IOW: we saw server say that)
+#define OPT_ECHO_ON      1
+
+        byte            echo_sga_response_size;
+
+        IF_VERBOSE(                 unsigned verbose;)
+        IF_FEATURE_TELNET_TTYPE(    const char *ttype;)
+        IF_FEATURE_TELNET_AUTOLOGIN(const char *autologin;)
+        ioloop_state_t  io;
+        stdin_to_net_t  conn_stdin2net;
+        net_to_stdout_t conn_net2stdout;
+        struct termios  termios_def;
+        struct termios  termios_raw;
+// buf[] arrays in conn structs are conceptually cleaner, but they
+// make G.member offsets larger -> larger code
+#define BUF_TTY2NET     ((byte*)bb_common_bufsiz1)
+#define BUF_NET2TTY     G.buf2
+#define BUFSIZE         1024
+// Note: can't just increase BUFSIZE arbitrarily: common bufsiz1 is not guaranteed to be >1k!
+#define BUFMASK         (BUFSIZE - 1)
+        byte            buf2[BUFSIZE];
 } FIX_ALIASING;
-#define G (*(struct globals*)bb_common_bufsiz1)
+#define G (*ptr_to_globals)
 #define INIT_G() do { \
-        setup_common_bufsiz(); \
-        BUILD_BUG_ON(sizeof(G) > COMMON_BUFSIZE); \
+        SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
 } while (0)
 
-
-static void rawmode(void);
-static void cookmode(void);
-static void do_linemode(void);
-static void will_charmode(void);
-static void telopt(byte c);
-static void subneg(byte c);
-
-static void iac_flush(void)
+static int remaining_free_bytes(int n)
 {
-        if (G.iaclen != 0) {
-                full_write(netfd, G.iacbuf, G.iaclen);
-                G.iaclen = 0;
-        }
+        return BUFSIZE - n;
 }
 
-static void doexit(int ev) NORETURN;
-static void doexit(int ev)
+#if ENABLE_FEATURE_TELNET_WIDTH
+static void handle_SIGWINCH(int sig UNUSED_PARAM)
 {
-        cookmode();
-        exit(ev);
+        // Only if server said DO NAWS and seen our WILL NAWS:
+        if ((G.flags & (FLAGS_NAWS_ON|INITIAL_SENT)) == (FLAGS_NAWS_ON|INITIAL_SENT))
+                G.got_SIGWINCH = 1;
 }
+#endif
 
-static void con_escape(void)
+static void rawmode(void)
 {
-        char b;
-
-        if (bb_got_signal) /* came from line mode... go raw */
-                rawmode();
-
-        full_write1_str("\r\nConsole escape. Commands are:\r\n\n"
-                        " l     go to line mode\r\n"
-                        " c     go to character mode\r\n"
-                        " z     suspend telnet\r\n"
-                        " e     exit telnet\r\n");
-
-        if (read(STDIN_FILENO, &b, 1) <= 0)
-                doexit(EXIT_FAILURE);
-
-        switch (b) {
-        case 'l':
-                if (!bb_got_signal) {
-                        do_linemode();
-                        goto ret;
-                }
-                break;
-        case 'c':
-                if (bb_got_signal) {
-                        will_charmode();
-                        goto ret;
-                }
-                break;
-        case 'z':
-                cookmode();
-                kill(0, SIGTSTP);
-                rawmode();
-                break;
-        case 'e':
-                doexit(EXIT_SUCCESS);
-        }
-
-        full_write1_str("continuing...\r\n");
-
-        if (bb_got_signal)
-                cookmode();
- ret:
-        bb_got_signal = 0;
+        if (G.flags & DO_TERMIOS)
+                tcsetattr(0, TCSADRAIN, &G.termios_raw);
 }
 
-static void handle_net_output(int len)
+static void cookmode(void)
 {
-        byte outbuf[2 * DATABUFSIZE];
-        byte *dst = outbuf;
-        byte *src = (byte*)G.buf;
-        byte *end = src + len;
-
-        while (src < end) {
-                byte c = *src++;
-                if (c == 0x1d) {
-                        con_escape();
-                        return;
-                }
-                *dst = c;
-                if (c == IAC)
-                        *++dst = c; /* IAC -> IAC IAC */
-                else
-                if (c == '\r' || c == '\n') {
-                        /* Enter key sends '\r' in raw mode and '\n' in cooked one.
-                         *
-                         * See RFC 1123 3.3.1 Telnet End-of-Line Convention.
-                         * Using CR LF instead of other allowed possibilities
-                         * like CR NUL - easier to talk to HTTP/SMTP servers.
-                         */
-                        *dst = '\r'; /* Enter -> CR LF */
-                        *++dst = '\n';
-                }
-#if 0
-/* putty's "special commands" mode does this: */
-/* Korenix 3005 switch needs at least the backspace tweak */
-                if (c == 0x08 || c == 0x7f) { /* ctrl+h || backspace */
-                        *dst = IAC;
-                        *++dst = EC;
-                }
-                if (c == 0x03) { /* ctrl+c */
-                        *dst = IAC;
-                        *++dst = IP;
-                }
-#endif
-                dst++;
-        }
-        if (dst - outbuf != 0)
-                full_write(netfd, outbuf, dst - outbuf);
+        if (G.flags & DO_TERMIOS)
+                tcsetattr(0, TCSADRAIN, &G.termios_def);
 }
 
-static void handle_net_input(int len)
+static void doexit(int ev) NORETURN;
+static void doexit(int ev)
 {
-        byte c;
-        int i;
-        int cstart = 0;
-
-        i = 0;
-        //bb_error_msg("[%u,'%.*s']", G.telstate, len, G.buf);
-        if (G.telstate == TS_NORMAL) { /* most typical state */
-                while (i < len) {
-                        c = G.buf[i];
-                        i++;
-                        if (c == IAC) /* unlikely */
-                                goto got_IAC;
-                        if (c != '\r') /* likely */
-                                continue;
-                        G.telstate = TS_CR;
-                        cstart = i;
-                        goto got_special;
-                }
-                full_write(STDOUT_FILENO, G.buf, len);
-                return;
- got_IAC:
-                G.telstate = TS_IAC;
-                cstart = i - 1;
- got_special: ;
-        }
-
-        for (; i < len; i++) {
-                c = G.buf[i];
-
-                switch (G.telstate) {
-                case TS_CR:
-                        /* Prev char was CR. If cur one is NUL, ignore it.
-                         * See RFC 1123 section 3.3.1 for discussion of telnet EOL handling.
-                         */
-                        G.telstate = TS_COPY;
-                        if (c == '\0')
-                                break;
-                        /* else: fall through - need to handle CR IAC ... properly */
-
-                case TS_COPY: /* Prev char was ordinary */
-                        /* Similar to NORMAL, but in TS_COPY we need to copy bytes */
-                        if (c == IAC)
-                                G.telstate = TS_IAC;
-                        else {
-                                G.buf[cstart++] = c;
-                                if (c == '\r')
-                                        G.telstate = TS_CR;
-                        }
-                        break;
-
-                case TS_IAC: /* Prev char was IAC */
-                        switch (c) {
-                        case IAC: /* IAC IAC -> one IAC */
-                                G.buf[cstart++] = c;
-                                G.telstate = TS_COPY;
-                                break;
-                        case SB:
-                                G.telstate = TS_SUB1;
-                                break;
-                        case DO:
-                        case DONT:
-                        case WILL:
-                        case WONT:
-                                G.telwish = c;
-                                G.telstate = TS_OPT;
-                                break;
-                        /* DATA MARK must be added later */
-                        default:
-                                G.telstate = TS_COPY;
-                        }
-                        break;
-
-                case TS_OPT: /* Prev chars were IAC WILL/WONT/DO/DONT */
-                        telopt(c);
-                        G.telstate = TS_COPY;
-                        break;
-
-                case TS_SUB1: /* Subnegotiation */
-                case TS_SUB2: /* Subnegotiation */
-                        subneg(c); /* can change G.telstate */
-                        break;
-                }
-        }
-
-        /* We had some IACs, or CR */
-        iac_flush();
-        if (G.telstate == TS_COPY) /* we aren't in the middle of IAC */
-                G.telstate = TS_NORMAL;
-        if (cstart != 0)
-                full_write(STDOUT_FILENO, G.buf, cstart);
+        cookmode();
+        exit(ev);
 }
 
 static void put_iac(int c)
 {
-        int iaclen = G.iaclen;
-        if (iaclen >= IACBUFSIZE) {
-                iac_flush();
-                iaclen = 0;
-        }
-        G.iacbuf[iaclen] = c; /* "... & 0xff" is implicit */
-        G.iaclen = iaclen + 1;
+        stdin_to_net_t *conn = &G.conn_stdin2net;
+        /* Write directly to stdin2net buffer */
+        BUF_TTY2NET[conn->rdidx] = c; /* "... & 0xff" is implicit */
+        conn->rdidx = (conn->rdidx + 1) & BUFMASK;
+        conn->size++;
 }
 
 static void put_iac2_msb_lsb(unsigned x_y)
@@ -368,15 +258,23 @@ static void put_iac2_msb_lsb(unsigned x_y)
 }
 #define put_iac2_x_y(x,y) put_iac2_msb_lsb(((x)<<8) + (y))
 
-#if ENABLE_FEATURE_TELNET_WIDTH \
- || ENABLE_FEATURE_TELNET_TTYPE \
- || ENABLE_FEATURE_TELNET_AUTOLOGIN
+#if SUPPORT_FOR_LOCAL_OPTS
 static void put_iac4_msb_lsb(unsigned x_y_z_t)
 {
         put_iac2_msb_lsb(x_y_z_t >> 16);
         put_iac2_msb_lsb(x_y_z_t);  /* "... & 0xffff" is implicit */
 }
-#define put_iac4_x_y_z_t(x,y,z,t) put_iac4_msb_lsb(((x)<<24) + ((y)<<16) + ((z)<<8) + (t))
+#define put_iac4_x_y_z_t(x,y,z,t) \
+        put_iac4_msb_lsb(((x)<<24) + ((y)<<16) + ((z)<<8) + (t))
+
+/* Send a byte in subnegotiation, escaping IAC (0xFF) as IAC IAC */
+static void put_iac_byte_escaped(int c)
+{
+        c = (byte)c;
+        put_iac(c);
+        if (c == IAC)
+                put_iac(IAC);
+}
 #endif
 
 static void put_iac3_IAC_x_y_merged(unsigned wwdd_and_c)
@@ -384,237 +282,656 @@ static void put_iac3_IAC_x_y_merged(unsigned wwdd_and_c)
         put_iac(IAC);
         put_iac2_msb_lsb(wwdd_and_c);
 }
-#define put_iac3_IAC_x_y(wwdd,c) put_iac3_IAC_x_y_merged(((wwdd)<<8) + (c))
+#define put_iac3_IAC_x_y(wwdd,c) \
+        put_iac3_IAC_x_y_merged(((wwdd)<<8) + (c))
 
 #if ENABLE_FEATURE_TELNET_TTYPE
-static void put_iac_subopt(byte c, char *str)
+static void put_iac_subopt(byte c, const char *str)
 {
         put_iac4_x_y_z_t(IAC, SB, c, 0);
 
-        while (*str)
-                put_iac(*str++);
+        while (*str) {
+                put_iac_byte_escaped(*str);
+                str++;
+        }
 
         put_iac2_x_y(IAC, SE);
 }
 #endif
 
 #if ENABLE_FEATURE_TELNET_AUTOLOGIN
-static void put_iac_subopt_autologin(void)
+static void put_iac_subopt_autologin(const char *p)
 {
-        const char *p;
-
         put_iac4_x_y_z_t(IAC, SB, TELOPT_NEW_ENVIRON, TELQUAL_IS);
         put_iac4_x_y_z_t(NEW_ENV_VAR, 'U', 'S', 'E'); /* "USER" */
         put_iac2_x_y('R', NEW_ENV_VALUE);
 
-        p = G.autologin;
         while (*p)
-                put_iac(*p++);
+                put_iac_byte_escaped(*p++);
 
         put_iac2_x_y(IAC, SE);
 }
 #endif
 
 #if ENABLE_FEATURE_TELNET_WIDTH
-static void put_iac_naws(byte c, int x, int y)
+static void put_iac_naws(void)
 {
-        put_iac3_IAC_x_y(SB, c);
+        unsigned width, height;
 
-        put_iac4_msb_lsb((x << 16) + y);
+        put_iac3_IAC_x_y(SB, TELOPT_NAWS);
+
+        /* Send width and height as 16-bit big-endian, escaping IAC bytes */
+        get_terminal_width_height(0, &width, &height);
+        log1("C:SB NAWS %dx%d", width, height);
+        put_iac_byte_escaped(width >> 8);
+        put_iac_byte_escaped(width);
+        put_iac_byte_escaped(height >> 8);
+        put_iac_byte_escaped(height);
 
         put_iac2_x_y(IAC, SE);
 }
 #endif
 
-static void setConMode(void)
+// Telnet option handling strategy:
+//
+// We send nothing on startup on our own (think "telnet www.kernel.org 80").
+// As soon as we see any DO X or WILL X message known to us, we respond
+// to them: send DO/DONT ECHO, DO SGA if server talked about them, then send
+// WILL NAWS, WILL TTYPE, WILL NEW_ENVIRON
+// without waiting for server to advertise those options.
+// (Why? Some servers may decide to not advertise all 123 options they know).
+//
+// TELOPT_ECHO (1) - remote: server echoes our keystrokes back to us
+// - Server says: WILL ECHO or WONT ECHO
+// - If we don't see it, or see WONT: line mode (local terminal echoes), aka cooked mode
+// - When active: We're in character mode (server echoes), aka raw mode
+// - Response logic:
+// - Server says WILL ECHO: we send DO ECHO, enter raw mode
+//   (this is the most usual case for non-ancient servers)
+// - Server says WONT ECHO: we send DONT ECHO, enter cooked mode
+// - We mirror server's changes, we do allow it to change during session
+//   unlike one-shot options which are negotiated once during startup.
+// - If user changes mode from ^] menu, we send corresponding DO/DONT ECHO.
+//
+// TELOPT_SGA (3) - remote: "Suppress Go Ahead", full-duplex
+// - Server says: WILL SGA or WONT SGA
+// - Response logic: one-shot.
+// - We expect all sane servers to choose WILL SGA at startup.
+// - If that happens, we send DO SGA. After that, we never react to any
+//   further SGA messages (we expect them to not repeat in practice)
+//
+// TELOPT_NAWS (31) - Window Size - local: we send our window size
+// - If server says: DO NAWS, it understands NAWS. We require this before
+// - sending SB NAWS ...
+// - We send window size during initial handshake and on window resize
+//
+// TELOPT_TTYPE (24) - Terminal Type - local: we send our terminal type
+// - Response logic: one-shot.
+// - If server says DO TTYPE: send "IAC SB TTYPE 0 '$TERM' IAC SE"
+//
+// TELOPT_NEW_ENVIRON (39) - Environment (Autologin) - local: we send our username
+// - Response logic: one-shot.
+// - If server says DO NEW_ENVIRON: send "IAC SB NEW_ENVIRON IS VAR 'USER' VALUE 'name' IAC SE"
+//
+// Unknown options:
+// Response: NONE - just ignore them
+// By protocol definition, an option is not in effect until BOTH sides agree.
+// We don't respond to unknown options - they simply won't be in effect.
+//
+// Testing at discworld.atuin.net:23 reveal servers often do NOT negotiate ECHO/SGA
+// in initial handshake while supporting NAWS and TTYPE:
+//telnet: S:DO 24 <--TTYPE
+//telnet: TTYPE:'xterm-256color' setting CHANGED_TTYPE
+//LPmud version : DW OS v1.02 on port 4242.
+//telnet: changed:8 flags:8
+//telnet: C:SB TTYPE 'xterm-256color'
+//telnet: S:DO 31 <--NAWS
+//telnet: S:WILL 86
+//telnet: S:DO 91
+//telnet: S:WILL 70
+//telnet: S:WILL 93
+//telnet: S:DO 39
+//telnet: S:WILL 201
+//......text.....
+//telnet: changed:2 flags:8
+//telnet: C:SB NAWS 226x53
+//...text....
+//telnet: S:SB 24 <--TTYPE
+//...text....
+//Setting your network terminal type to "xterm-256color".
+//> cols
+//Columns currently set to 79.
+//> rows
+//Rows currently set to 24.
+//^^^ server understood TTYPE but not NAWS. ?!
+static void handle_changes_in_options(stdin_to_net_t *conn)
 {
-        if (G.telflags & UF_ECHO) {
-                if (G.charmode == CHM_TRY) {
-                        G.charmode = CHM_ON;
-                        printf("\r\nEntering %s mode"
-                                "\r\nEscape character is '^%c'.\r\n", "character", ']');
-                        rawmode();
+        int count;
+
+        log1("changed:%x flags:%x", G.changes_seen, G.flags);
+
+        count = remaining_free_bytes(conn->size);
+        // As soon as we see any DO/DONT/WILL/WONT known to us,
+        // we assume it *is* a telnet server
+        // (we are not in "telnet www.kernel.org 80" scenario),
+        // and we respond to them, also expressing our own
+        // wishes: WILL NAWS etc. We send our WILLs once, all of them.
+        // We send actual SB with option contents after WILLs
+        // only if that option was requested.
+        // We repeatedly send only NAWS (when our window changes).
+        // Repeated DO requests are ignored.
+        if (G.changes_seen
+         && (count >= G.echo_sga_response_size)
+        ) {
+                if (G.changes_seen & CHANGED_ECHO) {
+                        // Server said WILL/WONT ECHO - confirm every time
+                        log1("C:%s ECHO", G.optstate_ECHO ? "DO" : "DONT");
+                        put_iac3_IAC_x_y(G.optstate_ECHO ? DO : DONT, TELOPT_ECHO);
                 }
-        } else {
-                if (G.charmode != CHM_OFF) {
-                        G.charmode = CHM_OFF;
-                        printf("\r\nEntering %s mode"
-                                "\r\nEscape character is '^%c'.\r\n", "line", 'C');
-                        cookmode();
+                if (G.changes_seen & CHANGED_SGA) {
+                        // Server said WILL SGA - confirm once
+                        log1("C:DO SGA");
+                        put_iac3_IAC_x_y(DO, TELOPT_SGA);
+                        G.flags |= FLAGS_SGA_SEEN; // remember we did it
+                        G.changes_seen -= CHANGED_SGA;
                 }
+                G.changes_seen &= ~(CHANGED_ECHO|CHANGED_SGA);
+
+                if (!(G.flags & INITIAL_SENT)) {
+                        // From now on, we'll only do DO/DONT ECHO and maybe DO SGA
+                        // in the "if (G.changes_seen)" block.
+                        G.flags |= INITIAL_SENT;
+                        G.echo_sga_response_size = (G.flags & FLAGS_SGA_SEEN) ? 3 : 6;
+
+                        // Send initial IAC sequences for local options we want to advertise
+                        // (there may be servers which send DO X only after we say WILL X)
+#if ENABLE_FEATURE_TELNET_WIDTH
+                        log1("C:WILL %s", "NAWS");
+                        put_iac3_IAC_x_y(WILL, TELOPT_NAWS);
+#endif
+#if ENABLE_FEATURE_TELNET_TTYPE
+                        if (G.ttype) {
+                                log1("C:WILL %s", "TTYPE");
+                                put_iac3_IAC_x_y(WILL, TELOPT_TTYPE);
+                        }
+#endif
+#if ENABLE_FEATURE_TELNET_AUTOLOGIN
+                        if (G.autologin) {
+                                log1("C:WILL %s", "NEW_ENVIRON");
+                                put_iac3_IAC_x_y(WILL, TELOPT_NEW_ENVIRON);
+                        }
+#endif
+                }
+        }
+
+        // If any of the checks below are true, then we know we
+        // went through INITIAL_SENT code path above.
+        // Therefore we always send WILL X before SB X...
+#if ENABLE_FEATURE_TELNET_WIDTH
+        if (remaining_free_bytes(conn->size) > MAX_NAWS_SIZE) {
+                if (G.changes_seen & CHANGED_NAWS) {
+                        G.flags |= FLAGS_NAWS_ON; // remember we did it
+                        G.changes_seen -= CHANGED_NAWS;
+                        goto generate_naws;
+                }
+                // Handle window resize: send updated NAWS
+                if (G.got_SIGWINCH) {
+                        // we know that INITIAL_SENT is set, signal handler checks that
+ generate_naws:
+                        // Clear the flag before put_iac_naws() to avoid race
+                        G.got_SIGWINCH = 0;
+//log1("C:WILL %s", "NAWS, the second time, I'm telling you it's fine!");
+//put_iac3_IAC_x_y(WILL, TELOPT_NAWS);
+                        put_iac_naws();
+                }
+        }
+#endif
+#if ENABLE_FEATURE_TELNET_TTYPE
+        if ((G.changes_seen & CHANGED_TTYPE)
+         && remaining_free_bytes(conn->size) > 6 + 2 * strlen(G.ttype)
+        ) {
+                log1("C:SB %s '%s'", "TTYPE", G.ttype);
+                put_iac_subopt(TELOPT_TTYPE, G.ttype);
+                G.ttype = NULL; // remember we did it
+                G.changes_seen -= CHANGED_TTYPE;
+        }
+#endif
+#if ENABLE_FEATURE_TELNET_AUTOLOGIN
+        if ((G.changes_seen & CHANGED_NEW_ENVIRON)
+         && remaining_free_bytes(conn->size) > 12 + 2 * strlen(G.autologin)
+        ) {
+                log1("C:SB %s '%s'", "NEW_ENVIRON", G.autologin);
+                put_iac_subopt_autologin(G.autologin);
+                G.autologin = NULL; // remember we did it
+                G.changes_seen -= CHANGED_NEW_ENVIRON;
         }
+#endif
 }
 
-static void will_charmode(void)
+static void announce_rawmode(void)
 {
-        G.charmode = CHM_TRY;
-        G.telflags |= (UF_ECHO | UF_SGA);
-        setConMode();
-
-        put_iac3_IAC_x_y(DO, TELOPT_ECHO);
-        put_iac3_IAC_x_y(DO, TELOPT_SGA);
-        iac_flush();
+        printf("\r\nEntering %s mode"
+                "\r\nEscape character is '^%c'.\r\n", "character", ']'
+        );
+        rawmode();
 }
-
-static void do_linemode(void)
+static void announce_and_switch_to_rawmode(void)
 {
-        G.charmode = CHM_TRY;
-        G.telflags &= ~(UF_ECHO | UF_SGA);
-        setConMode();
-
-        put_iac3_IAC_x_y(DONT, TELOPT_ECHO);
-        put_iac3_IAC_x_y(DONT, TELOPT_SGA);
-        iac_flush();
+        announce_rawmode();
+        rawmode();
 }
-
-static void to_notsup(char c)
+static void announce_and_switch_to_cookmode(void)
 {
-        if (G.telwish == WILL)
-                put_iac3_IAC_x_y(DONT, c);
-        else if (G.telwish == DO)
-                put_iac3_IAC_x_y(WONT, c);
+        printf("\r\nEntering %s mode"
+                "\r\nEscape character is '^%c'.\r\n", "line", 'C'
+        );
+        cookmode();
 }
 
-static void to_echo(void)
+static void show_menu(void)
 {
-        /* if server requests ECHO, don't agree */
-        if (G.telwish == DO) {
-                put_iac3_IAC_x_y(WONT, TELOPT_ECHO);
-                return;
+        char b;
+
+        rawmode();
+
+        full_write1_str("\r\nConsole escape. Commands are:\r\n"
+                        "l      go to line mode\r\n"
+                        "c      go to character mode\r\n"
+                        "z      suspend telnet\r\n"
+                        "e      exit\r\n");
+        if (read(STDIN_FILENO, &b, 1) <= 0
+         || b == 'e'
+        ) {
+                doexit(EXIT_FAILURE);
         }
-        if (G.telwish == DONT)
-                return;
 
-        if (G.telflags & UF_ECHO) {
-                if (G.telwish == WILL)
+        switch (b) {
+        case 'l':
+                if (G.optstate_ECHO == OPT_ECHO_ON) { /* are we in rawmode? */
+                        G.optstate_ECHO = OPT_ECHO_OFF;
+                        announce_and_switch_to_cookmode();
+                        goto echo_changed;
+                }
+                break;
+        case 'c':
+                if (G.optstate_ECHO != OPT_ECHO_ON) { /* OFF or UNKNOWN? (both operate as linemode) */
+                        G.optstate_ECHO = OPT_ECHO_ON;
+                        announce_rawmode(); /* no "_and_switch_": we are already in rawmode */
+ echo_changed:
+                        if (G.flags & INITIAL_SENT)
+                                G.changes_seen |= CHANGED_ECHO; /* inform the server at next send */
                         return;
-        } else if (G.telwish == WONT)
-                return;
+                }
+                break;
+        case 'z':
+                cookmode();
+                kill(0, SIGTSTP);
+                rawmode();
+                break;
+        }
 
-        if (G.charmode != CHM_OFF)
-                G.telflags ^= UF_ECHO;
+        full_write1_str("continuing...\r\n");
 
-        if (G.telflags & UF_ECHO)
-                put_iac3_IAC_x_y(DO, TELOPT_ECHO);
-        else
-                put_iac3_IAC_x_y(DONT, TELOPT_ECHO);
+        if (G.optstate_ECHO != OPT_ECHO_ON)
+                cookmode();
+}
 
-        setConMode();
-        full_write1_str("\r\n");  /* sudden modec */
+static int have_buffer_to_read_from_stdin(void *this)
+{
+        stdin_to_net_t *conn = this;
+        if (conn->read_fd < 0)
+                return 0;
+        return conn->size < BUFSIZE;
 }
 
-static void to_sga(void)
+static int read_from_stdin(void *this)
 {
-        /* daemon always sends will/wont, client do/dont */
+        stdin_to_net_t *conn = this;
+        int count, rem, expand_count;
+        byte *start, *src, *end;
+        byte c;
 
-        if (G.telflags & UF_SGA) {
-                if (G.telwish == WILL)
-                        return;
-        } else if (G.telwish == WONT)
-                return;
-
-        G.telflags ^= UF_SGA; /* toggle */
-        if (G.telflags & UF_SGA)
-                put_iac3_IAC_x_y(DO, TELOPT_SGA);
-        else
-                put_iac3_IAC_x_y(DONT, TELOPT_SGA);
+        //if (conn->read_fd < 0)
+        //      return 0; /* Already stopped reading stdin */
+        //ioloop_run() guarantees it won't call us with fd < 0
+
+        count = BUFSIZE - conn->size;
+        count = MIN(BUFSIZE - conn->rdidx, count);
+        count /= 2; /* Reserve room for worst-case expansion */
+        if (count == 0)
+                return 0;
+
+        start = BUF_TTY2NET + conn->rdidx;
+        count = safe_read(conn->read_fd, start, count);
+        if (count <= 0) {
+                conn->read_fd = -1;
+                return 0; /* Error or EOF - didn't read anything */
+        }
+
+        /* First pass: scan forward counting characters that need expansion */
+        src = start;
+        expand_count = 0;
+        rem = count; /* Remaining bytes to scan */
+        do {
+                c = *src++;
+                if (c == 0x1d) {
+                        /* Escape character - process bytes before it, then handle escape */
+                        count -= rem; /* Drop the remaining tail */
+#define found_escape (rem != 0)
+                        break;
+                }
+                if (c == IAC) {
+                        expand_count++; /* IAC -> IAC IAC (one extra byte) */
+                } else if (c == '\r' || c == '\n') {
+                        expand_count++; /* \r or \n -> \r\n (one extra byte) */
+                }
+        } while (--rem != 0);
+
+        if (expand_count != 0) {
+                /* Slow path: expand in place working backwards */
+                src = start + count - 1; /* Last read byte */
+                end = src + expand_count; /* Last byte after expansion */
+
+                /* As soon as src == end, the remaining bytes do not need processing (think about it!) */
+                while (src < end) {
+                        c = *src--;
+                        if (c == IAC) {
+                                *end-- = IAC;
+                        } else if (c == '\r' || c == '\n') {
+                                *end-- = '\n';
+                                c = '\r';
+                        }
+                        *end-- = c;
+                }
+                count += expand_count;
+        }
+
+        conn->size += count;
+        conn->rdidx = (conn->rdidx + count) & BUFMASK;
+
+        if (found_escape)
+                show_menu();
+#undef found_escape
+
+        return count;
 }
 
-#if ENABLE_FEATURE_TELNET_TTYPE
-static void to_ttype(void)
+static int have_data_to_write_to_net(void *this)
 {
-        /* Tell server we will (or won't) do TTYPE */
-        if (G.ttype)
-                put_iac3_IAC_x_y(WILL, TELOPT_TTYPE);
-        else
-                put_iac3_IAC_x_y(WONT, TELOPT_TTYPE);
+        stdin_to_net_t *conn = this;
+        if (conn->size == 0 && conn->read_fd < 0) {
+                /* buffer drained and stdin EOF - signal EOF to server */
+                shutdown(conn->write_fd, SHUT_WR);
+                /* Remove this pipe */
+                ioloop_remove_conn(conn->io, (connection_t*)conn);
+                return -1;
+        }
+        return conn->size > 0 || G_changes_or_WINCH != 0;
 }
-#endif
 
-#if ENABLE_FEATURE_TELNET_AUTOLOGIN
-static void to_new_environ(void)
+static int write_to_net(void *this)
 {
-        /* Tell server we will (or will not) do AUTOLOGIN */
-        if (G.autologin)
-                put_iac3_IAC_x_y(WILL, TELOPT_NEW_ENVIRON);
-        else
-                put_iac3_IAC_x_y(WONT, TELOPT_NEW_ENVIRON);
+        stdin_to_net_t *conn = this;
+        int count;
+
+        /* Do we have option or NAWS changes to handle? */
+        if (G_changes_or_WINCH)
+                handle_changes_in_options(conn); /* yes */
+
+        count = MIN(BUFSIZE - conn->wridx, conn->size);
+        // can be zero due to handle_changes_in_options()
+        if (count == 0)
+                return 0;
+        count = safe_write(conn->write_fd, BUF_TTY2NET + conn->wridx, count);
+        if (count <= 0) {
+                if (count < 0 && errno == EAGAIN)
+                        return 0;
+                full_write1_str("Error writing to foreign host\r\n");
+                ioloop_remove_conn(conn->io, (connection_t*)conn);
+                return -1; /* "I'm gone" */
+        }
+
+        conn->wridx = (conn->wridx + count) & BUFMASK;
+        conn->size -= count;
+        if (conn->size == 0) {
+                conn->rdidx = 0;
+                conn->wridx = 0;
+        }
+        return count;
 }
-#endif
 
-#if ENABLE_FEATURE_TELNET_WIDTH
-static void to_naws(void)
+static int have_buffer_to_read_from_net(void *this)
 {
-        /* Tell server we will do NAWS */
-        put_iac3_IAC_x_y(WILL, TELOPT_NAWS);
+        net_to_stdout_t *conn = this;
+        if (conn->read_fd < 0)
+                return 0;
+        return conn->size < BUFSIZE;
 }
-#endif
 
-static void telopt(byte c)
+static int read_from_net(void *this)
 {
-        switch (c) {
-        case TELOPT_ECHO:
-                to_echo(); break;
-        case TELOPT_SGA:
-                to_sga(); break;
+        net_to_stdout_t *conn = this;
+        int count;
+        byte *src, *dst;
+        byte c;
+        byte oldstate_ECHO;
+
+        count = BUFSIZE - conn->size;
+        //if (count == 0)
+        //      return 0; /* buffer full */
+        //ioloop_run() ensures this does not happen
+        count = MIN(BUFSIZE - conn->rdidx, count); /* can't be zero */
+
+        /* Read directly into circular buffer's linear fragment */
+        dst = BUF_NET2TTY + conn->rdidx;
+        count = safe_read(conn->read_fd, dst, count);
+        dbg("read_from_net bytes:%d input_state:%d %s",
+                count, conn->input_state, bin_to_hex(dst, count > 0 ? count : 0));
+        if (count <= 0) {
+                if (count < 0 && errno == EAGAIN)
+                        return 0;
+                full_write1_str("EOF on read from foreign host\r\n");
+                conn->read_fd = -1;
+                /* Imagine scenario: "cat" is running in the server.
+                 * We connect and press ^D. Byte 0x04 is transmitted to "cat",
+                 * it sees that as EOF and exits.
+                 * We see EOF here (netfd read side is closed).
+                 * Our stdin is still open, but we have no buffered data to write to net.
+                 * ioloop_run() will not _poll_ the netfd for writing.
+                 * We will not realize that netfd write side is also closed (!!!)
+                 * until something is typed in our stdin and we poll netfd to write that data.
+                 */
+//FIXME: send a few IAC NOPs to see whether the peer can still receive?
+                /* This is a workaround: pretend that our stdin is also closed: */
+                G.conn_stdin2net.read_fd = -1;
+                /* Unlike just exiting, this will try to send any buffered data */
+
+                return 0;
+        }
+
+        /* Copy option states - will be updated during processing, then compared after */
+        oldstate_ECHO = G.optstate_ECHO;
+
+        /* Optimization: do not load/store-in-place if unnecessary */
+        if (conn->input_state == TS_NORMAL) {
+                while (count != 0 && *dst != IAC && *dst != '\r')
+                        count--, dst++;
+        }
+        /* Process IAC sequences in place:
+         * - Update option states (G.oldstate_XYZ)
+         * - Decode/remove IAC sequences, compacting the data
+         * - src = read pointer, dst = write pointer (for compaction)
+         */
+        src = dst;
+        while (--count >= 0) {
+                c = *src++;
+
+                switch (conn->input_state) {
+                        int will;
+                case TS_NORMAL:
+ normal:
+                        if (c == IAC) {
+                                SET_INPUT_STATE(conn, TS_IAC, c);
+                                continue;
+                        }
+                        if (c == '\r') {
+                                SET_INPUT_STATE(conn, TS_CR, c);
+                        }
+                        *dst++ = c;
+                        continue;
+
+                case TS_CR:
+                        SET_INPUT_STATE(conn, TS_NORMAL, c);
+                        if (c == '\0') /* Skip NUL after CR (telnet EOL: CR NUL) */
+                                continue;
+                        goto normal;
+
+                case TS_IAC:
+                        if (c == IAC) {
+                                /* IAC IAC -> single IAC */
+                                *dst++ = c;
+                                SET_INPUT_STATE(conn, TS_NORMAL, c);
+                        } else if (c == SB) {
+                                conn->negotiation_verb = 0xff; /* reuse as counter */
+                                SET_INPUT_STATE(conn, TS_SUB1, c);
+                                log1("S:SB %d", count ? *src : 0);
+                        } else if (c == WILL || c == WONT || c == DO || c == DONT) { /* 251-254 */
+                                conn->negotiation_verb = c;
+                                SET_INPUT_STATE(conn, TS_OPT, c);
+                        } else {
+                                /* Unknown IAC command, ignore */
+                                SET_INPUT_STATE(conn, TS_NORMAL, c);
+                        }
+                        break;
+
+                case TS_OPT:
+#if VERBOSE
+                        {
+                                static const char verbs[] ALIGN1 = "WILL\0""WONT\0""DO\0""DONT";
+                                log1("S:%s %d", nth_string(verbs, conn->negotiation_verb - WILL), c);
+                        }
+#endif
+                        /* Process option negotiation */
+                        will = (conn->negotiation_verb == WILL);
+                        if (will || conn->negotiation_verb == WONT) {
+                                switch (c) {
+                                case TELOPT_ECHO: /* Remote option: server echoes our typing */
+                                        G.optstate_ECHO = will;
+                                        break;
+                                case TELOPT_SGA: /* Remote option: "suppress go ahead" */
+                                        if (will && !(G.flags & FLAGS_SGA_SEEN))
+                                                G.changes_seen |= CHANGED_SGA;
+                                        break;
+                                }
+                        } else if (conn->negotiation_verb == DO) {
+                                switch (c) {
 #if ENABLE_FEATURE_TELNET_TTYPE
-        case TELOPT_TTYPE:
-                to_ttype(); break;
+                                case TELOPT_TTYPE: /* Local option: we send terminal type */
+                                        log1("TTYPE:'%s' %ssetting CHANGED_TTYPE", G.ttype, G.ttype ? "" : "not ");
+                                        if (G.ttype)
+                                                G.changes_seen |= CHANGED_TTYPE;
+                                        break;
 #endif
 #if ENABLE_FEATURE_TELNET_AUTOLOGIN
-        case TELOPT_NEW_ENVIRON:
-                to_new_environ(); break;
+                                case TELOPT_NEW_ENVIRON: /* Local option: we send username */
+                                        if (G.autologin)
+                                                G.changes_seen |= CHANGED_NEW_ENVIRON;
+                                        break;
 #endif
 #if ENABLE_FEATURE_TELNET_WIDTH
-        case TELOPT_NAWS:
-                to_naws();
-                put_iac_naws(c, G.win_width, G.win_height);
-                break;
+                                case TELOPT_NAWS: /* Local option: we send window size */
+                                        if (!(G.flags & FLAGS_NAWS_ON))
+                                                G.changes_seen |= CHANGED_NAWS;
+                                        break;
 #endif
-        default:
-                to_notsup(c);
-                break;
+                                }
+                        }
+                        /* else: "DONT <something>": ignore */
+                        SET_INPUT_STATE(conn, TS_NORMAL, c);
+                        break;
+
+                case TS_SUB1:
+                        /* Avoid being stuck in TS_SUB1 forever (with detours into TS_SUB2)
+                         * if IAC SE is never seen (buggy server response?).
+                         */
+                        if (--conn->negotiation_verb == 0) {
+                                log1("unterminated SB (server bug?)");
+                                SET_INPUT_STATE(conn, TS_NORMAL, c);
+                        } else
+                        /* Skip over subnegotiation bytes until we see IAC */
+                        if (c == IAC) {
+                                SET_INPUT_STATE(conn, TS_SUB2, c);
+                        }
+                        break;
+
+                case TS_SUB2:
+                        /* After IAC in subnegotiation, check for SE */
+                        if (c == SE) {
+                                /* End of subnegotiation */
+                                SET_INPUT_STATE(conn, TS_NORMAL, c);
+                        } else {
+                                /* IAC followed by something other than SE, back to SUB1 */
+                                SET_INPUT_STATE(conn, TS_SUB1, c);
+                        }
+                        break;
+                }
         }
-}
 
-/* subnegotiation -- ignore all (except TTYPE,NAWS) */
-static void subneg(byte c)
-{
-        switch (G.telstate) {
-        case TS_SUB1:
-                if (c == IAC)
-                        G.telstate = TS_SUB2;
-#if ENABLE_FEATURE_TELNET_TTYPE
+        if (oldstate_ECHO != G.optstate_ECHO) {
+                /* Tell net writer to generate a confirmation */
+                G.changes_seen |= CHANGED_ECHO;
+                /* Print the banner and set termios */
+                if (G.optstate_ECHO == OPT_ECHO_ON)
+                        announce_and_switch_to_rawmode();
                 else
-                if (c == TELOPT_TTYPE && G.ttype)
-                        put_iac_subopt(TELOPT_TTYPE, G.ttype);
-#endif
-#if ENABLE_FEATURE_TELNET_AUTOLOGIN
-                else
-                if (c == TELOPT_NEW_ENVIRON && G.autologin)
-                        put_iac_subopt_autologin();
-#endif
-                break;
-        case TS_SUB2:
-                if (c == SE) {
-                        G.telstate = TS_COPY;
-                        return;
-                }
-                G.telstate = TS_SUB1;
-                break;
+                        announce_and_switch_to_cookmode();
         }
+
+        /* Update circular buffer: only the compacted data */
+        count = dst - (BUF_NET2TTY + conn->rdidx);
+        conn->size += count;
+        conn->rdidx = (conn->rdidx + count) & BUFMASK;
+
+        dbg("read_from_net: user bytes:%d input_state:%d", count, conn->input_state);
+
+        return count;
 }
 
-static void rawmode(void)
+static int have_data_to_write_to_stdout(void *this)
 {
-        if (G.do_termios)
-                tcsetattr(0, TCSADRAIN, &G.termios_raw);
+        net_to_stdout_t *conn = this;
+        if (conn->size == 0 && conn->read_fd < 0) {
+                /* buffer drained and network read EOF */
+                /* Remove this pipe */
+                ioloop_remove_conn(conn->io, (connection_t*)conn);
+                return -1;
+        }
+        return conn->size > 0;
 }
 
-static void cookmode(void)
+static int write_to_stdout(void *this)
 {
-        if (G.do_termios)
-                tcsetattr(0, TCSADRAIN, &G.termios_def);
+        net_to_stdout_t *conn = this;
+        int wr = MIN(BUFSIZE - conn->wridx, conn->size);
+        ssize_t count;
+
+        dbg("write_to_stdout: wr:%d %s", wr, bin_to_hex(BUF_NET2TTY + conn->wridx, wr));
+        count = safe_write(conn->write_fd, BUF_NET2TTY + conn->wridx, wr);
+        if (count <= 0) {
+                if (count < 0 && errno == EAGAIN)
+                        return 0;
+                //full_write1_str("Error writing to stdout\r\n");
+                ioloop_remove_conn(conn->io, (connection_t*)conn);
+                return -1; /* "I'm gone" */
+        }
+
+        conn->wridx = (conn->wridx + count) & BUFMASK;
+        conn->size -= count;
+        if (conn->size == 0) {
+                conn->rdidx = 0;
+                conn->wridx = 0;
+        }
+        return count;
 }
 
 int telnet_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
@@ -622,81 +939,102 @@ int telnet_main(int argc UNUSED_PARAM, char **argv)
 {
         char *host;
         int port;
-        int len;
-        struct pollfd ufds[2];
+        int opts;
 
         INIT_G();
 
 #if ENABLE_FEATURE_TELNET_TTYPE
         G.ttype = getenv("TERM");
 #endif
-
-        if (tcgetattr(0, &G.termios_def) >= 0) {
-                G.do_termios = 1;
-                G.termios_raw = G.termios_def;
-                cfmakeraw(&G.termios_raw);
-        }
-
+        opts = getopt32(argv, ""IF_VERBOSE("^")
+                IF_FEATURE_TELNET_AUTOLOGIN("al:")IF_VERBOSE("v")
+                IF_VERBOSE("\0" "vv")
+                IF_FEATURE_TELNET_AUTOLOGIN(, &G.autologin)
+                IF_VERBOSE(, &G.verbose)
+        );
 #if ENABLE_FEATURE_TELNET_AUTOLOGIN
-        if (1 == getopt32(argv, "al:", &G.autologin)) {
-                /* Only -a without -l USER picks $USER from envvar */
+        if ((opts & 3) == 1) {
+                // -a without -l USER picks USER from envvar:
                 G.autologin = getenv("USER");
         }
-        argv += optind;
-#else
-        argv++;
 #endif
+        argv += optind;
         if (!*argv)
                 bb_show_usage();
         host = *argv++;
         port = *argv ? bb_lookup_port(*argv++, "tcp", 23)
                 : bb_lookup_std_port("telnet", "tcp", 23);
-        if (*argv) /* extra params?? */
+        if (*argv) // extra params??
                 bb_show_usage();
 
+        // Save our termios
+        if (tcgetattr(0, &G.termios_def) >= 0) {
+                G.flags |= DO_TERMIOS;
+                G.termios_raw = G.termios_def;
+                cfmakeraw(&G.termios_raw);
+        }
+
         xmove_fd(create_and_connect_stream_or_die(host, port), netfd);
         printf("Connected to %s\n", host);
 
         setsockopt_keepalive(netfd);
+        ndelay_on(netfd);
 
 #if ENABLE_FEATURE_TELNET_WIDTH
-        get_terminal_width_height(0, &G.win_width, &G.win_height);
-//TODO: support dynamic resize?
+        signal(SIGWINCH, handle_SIGWINCH);
 #endif
-
         signal(SIGINT, record_signo);
-
-        ufds[0].fd = STDIN_FILENO;
-        ufds[0].events = POLLIN;
-        ufds[1].fd = netfd;
-        ufds[1].events = POLLIN;
-
-        while (1) {
-                if (poll(ufds, 2, -1) < 0) {
-                        /* error, ignore and/or log something, bay go to loop */
-                        if (bb_got_signal)
-                                con_escape();
-                        else
-                                sleep1();
-                        continue;
+        // Without this, SIGPIPE was seen on loopback connections:
+        signal(SIGPIPE, SIG_IGN);
+
+        // Initialize connections
+        G.conn_stdin2net.have_buffer_to_read_into = have_buffer_to_read_from_stdin;
+        G.conn_stdin2net.have_data_to_write = have_data_to_write_to_net;
+        G.conn_stdin2net.read = read_from_stdin;
+        G.conn_stdin2net.write = write_to_net;
+        if (STDIN_FILENO != 0)
+                G.conn_stdin2net.read_fd = STDIN_FILENO;
+        G.conn_stdin2net.write_fd = netfd;
+
+        G.conn_net2stdout.have_buffer_to_read_into = have_buffer_to_read_from_net;
+        G.conn_net2stdout.have_data_to_write = have_data_to_write_to_stdout;
+        G.conn_net2stdout.read = read_from_net;
+        G.conn_net2stdout.write = write_to_stdout;
+        G.conn_net2stdout.read_fd = netfd;
+        G.conn_net2stdout.write_fd = STDOUT_FILENO;
+        if (TS_NORMAL != 0)
+                G.conn_net2stdout.input_state = TS_NORMAL;
+
+        ioloop_insert_conn(&G.io, (connection_t*)&G.conn_stdin2net);
+        ioloop_insert_conn(&G.io, (connection_t*)&G.conn_net2stdout);
+
+        G.echo_sga_response_size = 3 * (2
+                IF_FEATURE_TELNET_WIDTH( + 1)
+                IF_FEATURE_TELNET_TTYPE(+ !!G.ttype)
+                IF_FEATURE_TELNET_AUTOLOGIN(+ !!G.autologin)
+        );
+        // Make *any* ECHO negotiation from server, positive or negative,
+        // trigger "we have a change" logic:
+        G.optstate_ECHO = OPT_ECHO_UNKNOWN;
+#if DEBUG || VERBOSE
+        // Terminal can change to raw mode, fix line printing
+        msg_eol = "\r\n";
+#endif
+        // EINTR flag and looping is only needed to handle ^C
+        // in line mode, otherwise just a call to ioloop_run() would do.
+        // TODO: replace primitive line mode with read_line_input()!!!
+        G.io.flags |= IOLOOP_FLAG_EXIT_IF_EINTR;
+        for (;;) {
+                int rc = ioloop_run(&G.io);
+                if (rc == IOLOOP_NO_CONNS) {
+                        dbg("connection is closed");
+                        break;
                 }
-
-// FIXME: reads can block. Need full bidirectional buffering.
-
-                if (ufds[0].revents) {
-                        len = safe_read(STDIN_FILENO, G.buf, DATABUFSIZE);
-                        if (len <= 0)
-                                doexit(EXIT_SUCCESS);
-                        handle_net_output(len);
+                if (bb_got_signal /*&& rc == IOLOOP_EINTR*/) {
+                        bb_got_signal = 0;
+                        show_menu();
                 }
+        }
 
-                if (ufds[1].revents) {
-                        len = safe_read(netfd, G.buf, DATABUFSIZE);
-                        if (len <= 0) {
-                                full_write1_str("Connection closed by foreign host\r\n");
-                                doexit(EXIT_FAILURE);
-                        }
-                        handle_net_input(len);
-                }
-        } /* while (1) */
+        doexit(EXIT_SUCCESS);
 }
diff --git a/networking/telnet.c.OLD b/networking/telnet.c.OLD
new file mode 100644
index 000000000..7a0253525
--- /dev/null
+++ b/networking/telnet.c.OLD
@@ -0,0 +1,702 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * telnet implementation for busybox
+ *
+ * Author: Tomi Ollila <too@iki.fi>
+ * Copyright (C) 1994-2000 by Tomi Ollila
+ *
+ * Created: Thu Apr  7 13:29:41 1994 too
+ * Last modified: Fri Jun  9 14:34:24 2000 too
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
+ *
+ * HISTORY
+ * Revision 3.1  1994/04/17  11:31:54  too
+ * initial revision
+ * Modified 2000/06/13 for inclusion into BusyBox by Erik Andersen <andersen@codepoet.org>
+ * Modified 2001/05/07 to add ability to pass TTYPE to remote host by Jim McQuillan
+ * <jam@ltsp.org>
+ * Modified 2004/02/11 to add ability to pass the USER variable to remote host
+ * by Fernando Silveira <swrh@gmx.net>
+ */
+//config:config TELNET
+//config:       bool "telnet (8.8 kb)"
+//config:       default y
+//config:       help
+//config:       Telnet is an interface to the TELNET protocol, but is also commonly
+//config:       used to test other simple protocols.
+//config:
+//config:config FEATURE_TELNET_TTYPE
+//config:       bool "Pass TERM type to remote host"
+//config:       default y
+//config:       depends on TELNET
+//config:       help
+//config:       Setting this option will forward the TERM environment variable to the
+//config:       remote host you are connecting to. This is useful to make sure that
+//config:       things like ANSI colors and other control sequences behave.
+//config:
+//config:config FEATURE_TELNET_AUTOLOGIN
+//config:       bool "Pass USER type to remote host"
+//config:       default y
+//config:       depends on TELNET
+//config:       help
+//config:       Setting this option will forward the USER environment variable to the
+//config:       remote host you are connecting to. This is useful when you need to
+//config:       log into a machine without telling the username (autologin). This
+//config:       option enables '-a' and '-l USER' options.
+//config:
+//config:config FEATURE_TELNET_WIDTH
+//config:       bool "Enable window size autodetection"
+//config:       default y
+//config:       depends on TELNET
+
+//applet:IF_TELNET(APPLET(telnet, BB_DIR_USR_BIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_TELNET) += telnet.o
+
+//usage:#if ENABLE_FEATURE_TELNET_AUTOLOGIN
+//usage:#define telnet_trivial_usage
+//usage:       "[-a] [-l USER] HOST [PORT]"
+//usage:#define telnet_full_usage "\n\n"
+//usage:       "Connect to telnet server\n"
+//usage:     "\n        -a      Automatic login with $USER variable"
+//usage:     "\n        -l USER Automatic login as USER"
+//usage:
+//usage:#else
+//usage:#define telnet_trivial_usage
+//usage:       "HOST [PORT]"
+//usage:#define telnet_full_usage "\n\n"
+//usage:       "Connect to telnet server"
+//usage:#endif
+
+#include <arpa/telnet.h>
+#include <netinet/in.h>
+#include "libbb.h"
+#include "common_bufsiz.h"
+
+#ifdef __BIONIC__
+/* should be in arpa/telnet.h */
+# define IAC         255  /* interpret as command: */
+# define DONT        254  /* you are not to use option */
+# define DO          253  /* please, you use option */
+# define WONT        252  /* I won't use option */
+# define WILL        251  /* I will use option */
+# define SB          250  /* interpret as subnegotiation */
+# define SE          240  /* end sub negotiation */
+# define TELOPT_ECHO   1  /* echo */
+# define TELOPT_SGA    3  /* suppress go ahead */
+# define TELOPT_TTYPE 24  /* terminal type */
+# define TELOPT_NAWS  31  /* window size */
+#endif
+
+enum {
+        DATABUFSIZE = 128,
+        IACBUFSIZE  = 128,
+
+        CHM_TRY = 0,
+        CHM_ON  = 1,
+        CHM_OFF = 2,
+
+        UF_ECHO = 0x01,
+        UF_SGA  = 0x02,
+
+        TS_NORMAL = 0,
+        TS_COPY = 1,
+        TS_IAC  = 2,
+        TS_OPT  = 3,
+        TS_SUB1 = 4,
+        TS_SUB2 = 5,
+        TS_CR   = 6,
+};
+
+typedef unsigned char byte;
+
+enum { netfd = 3 };
+
+struct globals {
+        int     iaclen; /* could even use byte, but it's a loss on x86 */
+        byte    telstate; /* telnet negotiation state from network input */
+        byte    telwish;  /* DO, DONT, WILL, WONT */
+        byte    charmode;
+        byte    telflags;
+        byte    do_termios;
+#if ENABLE_FEATURE_TELNET_TTYPE
+        char    *ttype;
+#endif
+#if ENABLE_FEATURE_TELNET_AUTOLOGIN
+        const char *autologin;
+#endif
+#if ENABLE_FEATURE_TELNET_WIDTH
+        unsigned win_width, win_height;
+#endif
+        /* same buffer used both for network and console read/write */
+        char    buf[DATABUFSIZE];
+        /* buffer to handle telnet negotiations */
+        char    iacbuf[IACBUFSIZE];
+        struct termios termios_def;
+        struct termios termios_raw;
+} FIX_ALIASING;
+#define G (*(struct globals*)bb_common_bufsiz1)
+#define INIT_G() do { \
+        setup_common_bufsiz(); \
+        BUILD_BUG_ON(sizeof(G) > COMMON_BUFSIZE); \
+} while (0)
+
+
+static void rawmode(void);
+static void cookmode(void);
+static void do_linemode(void);
+static void will_charmode(void);
+static void telopt(byte c);
+static void subneg(byte c);
+
+static void iac_flush(void)
+{
+        if (G.iaclen != 0) {
+                full_write(netfd, G.iacbuf, G.iaclen);
+                G.iaclen = 0;
+        }
+}
+
+static void doexit(int ev) NORETURN;
+static void doexit(int ev)
+{
+        cookmode();
+        exit(ev);
+}
+
+static void con_escape(void)
+{
+        char b;
+
+        if (bb_got_signal) /* came from line mode... go raw */
+                rawmode();
+
+        full_write1_str("\r\nConsole escape. Commands are:\r\n\n"
+                        " l     go to line mode\r\n"
+                        " c     go to character mode\r\n"
+                        " z     suspend telnet\r\n"
+                        " e     exit telnet\r\n");
+
+        if (read(STDIN_FILENO, &b, 1) <= 0)
+                doexit(EXIT_FAILURE);
+
+        switch (b) {
+        case 'l':
+                if (!bb_got_signal) {
+                        do_linemode();
+                        goto ret;
+                }
+                break;
+        case 'c':
+                if (bb_got_signal) {
+                        will_charmode();
+                        goto ret;
+                }
+                break;
+        case 'z':
+                cookmode();
+                kill(0, SIGTSTP);
+                rawmode();
+                break;
+        case 'e':
+                doexit(EXIT_SUCCESS);
+        }
+
+        full_write1_str("continuing...\r\n");
+
+        if (bb_got_signal)
+                cookmode();
+ ret:
+        bb_got_signal = 0;
+}
+
+static void handle_net_output(int len)
+{
+        byte outbuf[2 * DATABUFSIZE];
+        byte *dst = outbuf;
+        byte *src = (byte*)G.buf;
+        byte *end = src + len;
+
+        while (src < end) {
+                byte c = *src++;
+                if (c == 0x1d) {
+                        con_escape();
+                        return;
+                }
+                *dst = c;
+                if (c == IAC)
+                        *++dst = c; /* IAC -> IAC IAC */
+                else
+                if (c == '\r' || c == '\n') {
+                        /* Enter key sends '\r' in raw mode and '\n' in cooked one.
+                         *
+                         * See RFC 1123 3.3.1 Telnet End-of-Line Convention.
+                         * Using CR LF instead of other allowed possibilities
+                         * like CR NUL - easier to talk to HTTP/SMTP servers.
+                         */
+                        *dst = '\r'; /* Enter -> CR LF */
+                        *++dst = '\n';
+                }
+#if 0
+/* putty's "special commands" mode does this: */
+/* Korenix 3005 switch needs at least the backspace tweak */
+                if (c == 0x08 || c == 0x7f) { /* ctrl+h || backspace */
+                        *dst = IAC;
+                        *++dst = EC;
+                }
+                if (c == 0x03) { /* ctrl+c */
+                        *dst = IAC;
+                        *++dst = IP;
+                }
+#endif
+                dst++;
+        }
+        if (dst - outbuf != 0)
+                full_write(netfd, outbuf, dst - outbuf);
+}
+
+static void handle_net_input(int len)
+{
+        byte c;
+        int i;
+        int cstart = 0;
+
+        i = 0;
+        //bb_error_msg("[%u,'%.*s']", G.telstate, len, G.buf);
+        if (G.telstate == TS_NORMAL) { /* most typical state */
+                while (i < len) {
+                        c = G.buf[i];
+                        i++;
+                        if (c == IAC) /* unlikely */
+                                goto got_IAC;
+                        if (c != '\r') /* likely */
+                                continue;
+                        G.telstate = TS_CR;
+                        cstart = i;
+                        goto got_special;
+                }
+                full_write(STDOUT_FILENO, G.buf, len);
+                return;
+ got_IAC:
+                G.telstate = TS_IAC;
+                cstart = i - 1;
+ got_special: ;
+        }
+
+        for (; i < len; i++) {
+                c = G.buf[i];
+
+                switch (G.telstate) {
+                case TS_CR:
+                        /* Prev char was CR. If cur one is NUL, ignore it.
+                         * See RFC 1123 section 3.3.1 for discussion of telnet EOL handling.
+                         */
+                        G.telstate = TS_COPY;
+                        if (c == '\0')
+                                break;
+                        /* else: fall through - need to handle CR IAC ... properly */
+
+                case TS_COPY: /* Prev char was ordinary */
+                        /* Similar to NORMAL, but in TS_COPY we need to copy bytes */
+                        if (c == IAC)
+                                G.telstate = TS_IAC;
+                        else {
+                                G.buf[cstart++] = c;
+                                if (c == '\r')
+                                        G.telstate = TS_CR;
+                        }
+                        break;
+
+                case TS_IAC: /* Prev char was IAC */
+                        switch (c) {
+                        case IAC: /* IAC IAC -> one IAC */
+                                G.buf[cstart++] = c;
+                                G.telstate = TS_COPY;
+                                break;
+                        case SB:
+                                G.telstate = TS_SUB1;
+                                break;
+                        case DO:
+                        case DONT:
+                        case WILL:
+                        case WONT:
+                                G.telwish = c;
+                                G.telstate = TS_OPT;
+                                break;
+                        /* DATA MARK must be added later */
+                        default:
+                                G.telstate = TS_COPY;
+                        }
+                        break;
+
+                case TS_OPT: /* Prev chars were IAC WILL/WONT/DO/DONT */
+                        telopt(c);
+                        G.telstate = TS_COPY;
+                        break;
+
+                case TS_SUB1: /* Subnegotiation */
+                case TS_SUB2: /* Subnegotiation */
+                        subneg(c); /* can change G.telstate */
+                        break;
+                }
+        }
+
+        /* We had some IACs, or CR */
+        iac_flush();
+        if (G.telstate == TS_COPY) /* we aren't in the middle of IAC */
+                G.telstate = TS_NORMAL;
+        if (cstart != 0)
+                full_write(STDOUT_FILENO, G.buf, cstart);
+}
+
+static void put_iac(int c)
+{
+        int iaclen = G.iaclen;
+        if (iaclen >= IACBUFSIZE) {
+                iac_flush();
+                iaclen = 0;
+        }
+        G.iacbuf[iaclen] = c; /* "... & 0xff" is implicit */
+        G.iaclen = iaclen + 1;
+}
+
+static void put_iac2_msb_lsb(unsigned x_y)
+{
+        put_iac(x_y >> 8);  /* "... & 0xff" is implicit */
+        put_iac(x_y);  /* "... & 0xff" is implicit */
+}
+#define put_iac2_x_y(x,y) put_iac2_msb_lsb(((x)<<8) + (y))
+
+#if ENABLE_FEATURE_TELNET_WIDTH \
+ || ENABLE_FEATURE_TELNET_TTYPE \
+ || ENABLE_FEATURE_TELNET_AUTOLOGIN
+static void put_iac4_msb_lsb(unsigned x_y_z_t)
+{
+        put_iac2_msb_lsb(x_y_z_t >> 16);
+        put_iac2_msb_lsb(x_y_z_t);  /* "... & 0xffff" is implicit */
+}
+#define put_iac4_x_y_z_t(x,y,z,t) put_iac4_msb_lsb(((x)<<24) + ((y)<<16) + ((z)<<8) + (t))
+#endif
+
+static void put_iac3_IAC_x_y_merged(unsigned wwdd_and_c)
+{
+        put_iac(IAC);
+        put_iac2_msb_lsb(wwdd_and_c);
+}
+#define put_iac3_IAC_x_y(wwdd,c) put_iac3_IAC_x_y_merged(((wwdd)<<8) + (c))
+
+#if ENABLE_FEATURE_TELNET_TTYPE
+static void put_iac_subopt(byte c, char *str)
+{
+        put_iac4_x_y_z_t(IAC, SB, c, 0);
+
+        while (*str)
+                put_iac(*str++);
+
+        put_iac2_x_y(IAC, SE);
+}
+#endif
+
+#if ENABLE_FEATURE_TELNET_AUTOLOGIN
+static void put_iac_subopt_autologin(void)
+{
+        const char *p;
+
+        put_iac4_x_y_z_t(IAC, SB, TELOPT_NEW_ENVIRON, TELQUAL_IS);
+        put_iac4_x_y_z_t(NEW_ENV_VAR, 'U', 'S', 'E'); /* "USER" */
+        put_iac2_x_y('R', NEW_ENV_VALUE);
+
+        p = G.autologin;
+        while (*p)
+                put_iac(*p++);
+
+        put_iac2_x_y(IAC, SE);
+}
+#endif
+
+#if ENABLE_FEATURE_TELNET_WIDTH
+static void put_iac_naws(byte c, int x, int y)
+{
+        put_iac3_IAC_x_y(SB, c);
+
+        put_iac4_msb_lsb((x << 16) + y);
+
+        put_iac2_x_y(IAC, SE);
+}
+#endif
+
+static void setConMode(void)
+{
+        if (G.telflags & UF_ECHO) {
+                if (G.charmode == CHM_TRY) {
+                        G.charmode = CHM_ON;
+                        printf("\r\nEntering %s mode"
+                                "\r\nEscape character is '^%c'.\r\n", "character", ']');
+                        rawmode();
+                }
+        } else {
+                if (G.charmode != CHM_OFF) {
+                        G.charmode = CHM_OFF;
+                        printf("\r\nEntering %s mode"
+                                "\r\nEscape character is '^%c'.\r\n", "line", 'C');
+                        cookmode();
+                }
+        }
+}
+
+static void will_charmode(void)
+{
+        G.charmode = CHM_TRY;
+        G.telflags |= (UF_ECHO | UF_SGA);
+        setConMode();
+
+        put_iac3_IAC_x_y(DO, TELOPT_ECHO);
+        put_iac3_IAC_x_y(DO, TELOPT_SGA);
+        iac_flush();
+}
+
+static void do_linemode(void)
+{
+        G.charmode = CHM_TRY;
+        G.telflags &= ~(UF_ECHO | UF_SGA);
+        setConMode();
+
+        put_iac3_IAC_x_y(DONT, TELOPT_ECHO);
+        put_iac3_IAC_x_y(DONT, TELOPT_SGA);
+        iac_flush();
+}
+
+static void to_notsup(char c)
+{
+        if (G.telwish == WILL)
+                put_iac3_IAC_x_y(DONT, c);
+        else if (G.telwish == DO)
+                put_iac3_IAC_x_y(WONT, c);
+}
+
+static void to_echo(void)
+{
+        /* if server requests ECHO, don't agree */
+        if (G.telwish == DO) {
+                put_iac3_IAC_x_y(WONT, TELOPT_ECHO);
+                return;
+        }
+        if (G.telwish == DONT)
+                return;
+
+        if (G.telflags & UF_ECHO) {
+                if (G.telwish == WILL)
+                        return;
+        } else if (G.telwish == WONT)
+                return;
+
+        if (G.charmode != CHM_OFF)
+                G.telflags ^= UF_ECHO;
+
+        if (G.telflags & UF_ECHO)
+                put_iac3_IAC_x_y(DO, TELOPT_ECHO);
+        else
+                put_iac3_IAC_x_y(DONT, TELOPT_ECHO);
+
+        setConMode();
+        full_write1_str("\r\n");  /* sudden modec */
+}
+
+static void to_sga(void)
+{
+        /* daemon always sends will/wont, client do/dont */
+
+        if (G.telflags & UF_SGA) {
+                if (G.telwish == WILL)
+                        return;
+        } else if (G.telwish == WONT)
+                return;
+
+        G.telflags ^= UF_SGA; /* toggle */
+        if (G.telflags & UF_SGA)
+                put_iac3_IAC_x_y(DO, TELOPT_SGA);
+        else
+                put_iac3_IAC_x_y(DONT, TELOPT_SGA);
+}
+
+#if ENABLE_FEATURE_TELNET_TTYPE
+static void to_ttype(void)
+{
+        /* Tell server we will (or won't) do TTYPE */
+        if (G.ttype)
+                put_iac3_IAC_x_y(WILL, TELOPT_TTYPE);
+        else
+                put_iac3_IAC_x_y(WONT, TELOPT_TTYPE);
+}
+#endif
+
+#if ENABLE_FEATURE_TELNET_AUTOLOGIN
+static void to_new_environ(void)
+{
+        /* Tell server we will (or will not) do AUTOLOGIN */
+        if (G.autologin)
+                put_iac3_IAC_x_y(WILL, TELOPT_NEW_ENVIRON);
+        else
+                put_iac3_IAC_x_y(WONT, TELOPT_NEW_ENVIRON);
+}
+#endif
+
+#if ENABLE_FEATURE_TELNET_WIDTH
+static void to_naws(void)
+{
+        /* Tell server we will do NAWS */
+        put_iac3_IAC_x_y(WILL, TELOPT_NAWS);
+}
+#endif
+
+static void telopt(byte c)
+{
+        switch (c) {
+        case TELOPT_ECHO:
+                to_echo(); break;
+        case TELOPT_SGA:
+                to_sga(); break;
+#if ENABLE_FEATURE_TELNET_TTYPE
+        case TELOPT_TTYPE:
+                to_ttype(); break;
+#endif
+#if ENABLE_FEATURE_TELNET_AUTOLOGIN
+        case TELOPT_NEW_ENVIRON:
+                to_new_environ(); break;
+#endif
+#if ENABLE_FEATURE_TELNET_WIDTH
+        case TELOPT_NAWS:
+                to_naws();
+                put_iac_naws(c, G.win_width, G.win_height);
+                break;
+#endif
+        default:
+                to_notsup(c);
+                break;
+        }
+}
+
+/* subnegotiation -- ignore all (except TTYPE,NAWS) */
+static void subneg(byte c)
+{
+        switch (G.telstate) {
+        case TS_SUB1:
+                if (c == IAC)
+                        G.telstate = TS_SUB2;
+#if ENABLE_FEATURE_TELNET_TTYPE
+                else
+                if (c == TELOPT_TTYPE && G.ttype)
+                        put_iac_subopt(TELOPT_TTYPE, G.ttype);
+#endif
+#if ENABLE_FEATURE_TELNET_AUTOLOGIN
+                else
+                if (c == TELOPT_NEW_ENVIRON && G.autologin)
+                        put_iac_subopt_autologin();
+#endif
+                break;
+        case TS_SUB2:
+                if (c == SE) {
+                        G.telstate = TS_COPY;
+                        return;
+                }
+                G.telstate = TS_SUB1;
+                break;
+        }
+}
+
+static void rawmode(void)
+{
+        if (G.do_termios)
+                tcsetattr(0, TCSADRAIN, &G.termios_raw);
+}
+
+static void cookmode(void)
+{
+        if (G.do_termios)
+                tcsetattr(0, TCSADRAIN, &G.termios_def);
+}
+
+int telnet_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int telnet_main(int argc UNUSED_PARAM, char **argv)
+{
+        char *host;
+        int port;
+        int len;
+        struct pollfd ufds[2];
+
+        INIT_G();
+
+#if ENABLE_FEATURE_TELNET_TTYPE
+        G.ttype = getenv("TERM");
+#endif
+
+        if (tcgetattr(0, &G.termios_def) >= 0) {
+                G.do_termios = 1;
+                G.termios_raw = G.termios_def;
+                cfmakeraw(&G.termios_raw);
+        }
+
+#if ENABLE_FEATURE_TELNET_AUTOLOGIN
+        if (1 == getopt32(argv, "al:", &G.autologin)) {
+                /* Only -a without -l USER picks $USER from envvar */
+                G.autologin = getenv("USER");
+        }
+        argv += optind;
+#else
+        argv++;
+#endif
+        if (!*argv)
+                bb_show_usage();
+        host = *argv++;
+        port = *argv ? bb_lookup_port(*argv++, "tcp", 23)
+                : bb_lookup_std_port("telnet", "tcp", 23);
+        if (*argv) /* extra params?? */
+                bb_show_usage();
+
+        xmove_fd(create_and_connect_stream_or_die(host, port), netfd);
+        printf("Connected to %s\n", host);
+
+        setsockopt_keepalive(netfd);
+
+#if ENABLE_FEATURE_TELNET_WIDTH
+        get_terminal_width_height(0, &G.win_width, &G.win_height);
+//TODO: support dynamic resize?
+#endif
+
+        signal(SIGINT, record_signo);
+
+        ufds[0].fd = STDIN_FILENO;
+        ufds[0].events = POLLIN;
+        ufds[1].fd = netfd;
+        ufds[1].events = POLLIN;
+
+        while (1) {
+                if (poll(ufds, 2, -1) < 0) {
+                        /* error, ignore and/or log something, bay go to loop */
+                        if (bb_got_signal)
+                                con_escape();
+                        else
+                                sleep1();
+                        continue;
+                }
+
+// FIXME: reads can block. Need full bidirectional buffering.
+
+                if (ufds[0].revents) {
+                        len = safe_read(STDIN_FILENO, G.buf, DATABUFSIZE);
+                        if (len <= 0)
+                                doexit(EXIT_SUCCESS);
+                        handle_net_output(len);
+                }
+
+                if (ufds[1].revents) {
+                        len = safe_read(netfd, G.buf, DATABUFSIZE);
+                        if (len <= 0) {
+                                full_write1_str("Connection closed by foreign host\r\n");
+                                doexit(EXIT_FAILURE);
+                        }
+                        handle_net_input(len);
+                }
+        } /* while (1) */
+}
diff --git a/networking/telnet.txt b/networking/telnet.txt
new file mode 100644
index 000000000..87b1d1aa6
--- /dev/null
+++ b/networking/telnet.txt
@@ -0,0 +1,53 @@
+// 2-byte sequences:
+// IAC SE (240) End of subnegotiation parameters
+// IAC NOP (241) No operation
+// IAC DM (242) Data Mark (used with TCP urgent pointer)
+// IAC BRK (243) Break (simulate serial line break) - perhaps tcsendbreak(master_ptyfd)? [untested]
+// IAC IP (244) Interrupt Process ("send SIGINT to foreground process group a-la ^C")
+// IAC AO (245) Abort Output
+// IAC AYT (246) Are You There
+// IAC EC (247) Erase Character
+// IAC EL (248) Erase Line
+// IAC GA (249) Go Ahead
+// IAC IAC (255) I'm sending literal byte 255
+// 3-byte sequences:
+// IAC WILL <option> (251) sender declares willingness to enable option
+// IAC WONT <option> (252) sender refuses / disables option
+// IAC DO <option> (253) sender requests peer to send option, or enable option on peer's side
+// IAC DONT <option> (254) sender requests peer to NOT send option, or disable option on peer's side
+// Example:
+// IAC DO 31 (request NAWS)
+// IAC WILL 24 (offer TERMINAL-TYPE)
+//
+// Variable length: subnegotiation (250)
+// IAC SB <option> <data...> IAC SE
+// option = single byte
+// data = zero or more bytes
+// Subnegotiation can not be nested, and can not have 2- and 3-byte commands inside.
+// Inside subnegotiation data, IAC IAC represents literal 255.
+// An IAC byte inside SB:
+//  IAC IAC: literal byte 255
+//  IAC SE: end of subnegotiation
+//  IAC <anything else>: protocol error
+// Common options that use subnegotiation:
+// TERMINAL-TYPE (24)
+//  IAC SB 24 SEND(1) IAC SE
+//  IAC SB 24 IS(0) "xterm-256color" IAC SE
+// NAWS - Negotiate About Window Size (31)
+//  IAC SB 31 <width_hi> <width_lo> <height_hi> <height_lo> IAC SE
+//  width and height are 16-bit big endian. HOWTO:
+//  Server: IAC DO NAWS
+//  Client: IAC WILL NAWS
+//  Client: IAC SB NAWS <w> <h> IAC SE
+//  ...sometime later: client's window is resized by user...
+//  Client: IAC SB NAWS <w> <h> IAC SE
+// TERMINAL-SPEED (32)
+//  IAC SB 32 IS(0) "rx,tx" IAC SE
+// REMOTE-FLOW-CONTROL (33)
+// LINEMODE (34)
+// X-DISPLAY-LOCATION (35)
+// ENVIRON (36)
+// AUTHENTICATION (37)
+// ENCRYPT (38)
+// NEW-ENVIRON (39)
+// COM-PORT-OPTION (44)
diff --git a/networking/telnetd.c b/networking/telnetd.c
index a5a783047..3eb9446a2 100644
--- a/networking/telnetd.c
+++ b/networking/telnetd.c
@@ -61,6 +61,14 @@
 //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
@@ -119,49 +127,54 @@
 //usage:     "\n        -S              Log to syslog (implied by -i or without -F and -w)"
 //usage:        )
 //usage:        )
-
-#define DEBUG 0
+//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 TELCMDS
-# define TELOPTS
+# 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
-#include <arpa/telnet.h>
 
+#define SELFTEST_VHANGUP 1
+#define SELFTEST_NET2PTY 1
+#define SELFTEST_PTY2NET 1
 
-struct tsession {
-        struct tsession *next;
-        pid_t shell_pid;
-        int sockfd_read;
-        int sockfd_write;
-        int ptyfd;
-        smallint buffered_IAC_for_pty;
-
-        /* two circular buffers */
-        /*char *buf1, *buf2;*/
-/*#define TS_BUF1(ts) ts->buf1*/
-/*#define TS_BUF2(ts) TS_BUF2(ts)*/
-#define TS_BUF1(ts) ((unsigned char*)(ts + 1))
-#define TS_BUF2(ts) (((unsigned char*)(ts + 1)) + BUFSIZE)
-        int rdidx1, wridx1, size1;
-        int rdidx2, wridx2, size2;
-};
+#define SAVE_NET2PTY_EXPECTED 0
+#define SAVE_NET2PTY_ACTUAL   0
 
-/* Two buffers are directly after tsession in malloced memory.
- * Make whole thing fit in 4k */
-enum { BUFSIZE = (4 * 1024 - sizeof(struct tsession)) / 2 };
+#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 {
-        struct tsession *sessions;
+        ioloop_state_t io;
         const char *loginpath;
         const char *issuefile;
-        int maxfd;
+        unsigned verbose;
+        IF_FEATURE_TELNETD_INETD_WAIT(unsigned sec_linger;)
 } FIX_ALIASING;
 #define G (*(struct globals*)bb_common_bufsiz1)
 #define INIT_G() do { \
@@ -170,303 +183,688 @@ struct globals {
         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;
 
-/* Write some buf1 data to pty, processing IACs.
- * Update wridx1 and size1. Return < 0 on error.
- * Buggy if IAC is present but incomplete: skips them.
+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 ssize_t
-safe_write_to_pty_decode_iac(struct tsession *ts)
+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::have_data_to_write
+// net_to_pty::have_buffer_to_read_into
+//  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__have_data_to_write(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;
 
-        buf = TS_BUF1(ts) + ts->wridx1;
-        wr = MIN(BUFSIZE - ts->wridx1, ts->size1);
-        /* wr is at least 1 here */
+        if (ts->write_fd < 0) /* did slave close its pty? */
+                return 0;
 
-        if (ts->buffered_IAC_for_pty) {
-                /* Last time we stopped on a "dangling" IAC byte.
-                 * We removed it from the buffer back then.
-                 * Now pretend it's still there, and jump to IAC processing.
-                 */
-                ts->buffered_IAC_for_pty = 0;
-                wr++;
-                ts->size1++;
-                buf--; /* Yes, this can point before the buffer. It's ok */
-                ts->wridx1--;
-                goto handle_iac;
-        }
+        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) {
-                /* There is a "prefix" of non-IAC chars.
-                 * Write only them, and return.
+        if (found == buf) {
+                /* The first char is IAC.
+                 * have_data_to_write() 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.
                  */
-                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.
-                 */
-                rc = wr;
-                found = memchr(buf, '\r', wr);
-                if (found)
-                        rc = found - buf + 1;
-                rc = safe_write(ts->ptyfd, buf, rc);
-                if (rc <= 0)
-                        return rc;
-                if (rc < wr /* don't look past available data */
-                 && buf[rc-1] == '\r' /* need this: imagine that write was _short_ */
-                 && (buf[rc] == '\n' || buf[rc] == '\0')
-                ) {
-                        rc++;
+//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;
                 }
-                goto update_and_return;
+                /* 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" */
         }
-
-        /* buf starts with IAC char. Process that sequence.
-         * Example: we get this from our own (bbox) telnet client:
-         * read(5, "\377\374\1""\377\373\37""\377\372\37\0\262\0@\377\360""\377\375\1""\377\375\3"):
-         * IAC WONT ECHO, IAC WILL NAWS, IAC SB NAWS <cols> <rows> IAC SE, IAC DO SGA
-         * Another example (telnet-0.17 from old-netkit):
-         * read(4, "\377\375\3""\377\373\30""\377\373\37""\377\373 ""\377\373!""\377\373\"""\377\373'"
-         * "\377\375\5""\377\373#""\377\374\1""\377\372\37\0\257\0I\377\360""\377\375\1"):
-         * IAC DO SGA, IAC WILL TTYPE, IAC WILL NAWS, IAC WILL TSPEED, IAC WILL LFLOW, IAC WILL LINEMODE, IAC WILL NEW_ENVIRON,
-         * IAC DO STATUS, IAC WILL XDISPLOC, IAC WONT ECHO, IAC SB NAWS <cols> <rows> IAC SE, IAC DO ECHO
+        /* No leading IACs: found != buf.
+         * IOW: there is a "prefix" of non-IAC chars.
+         * Write only them, and return.
          */
-        if (wr <= 1) {
-                /* Only the single IAC byte is in the buffer, eat it
-                 * and set a flag "process the rest of the sequence
-                 * next time we are here".
-                 */
-                //bb_error_msg("dangling IAC!");
-                ts->buffered_IAC_for_pty = 1;
-                rc = 1;
-                goto update_and_return;
-        }
-
- handle_iac:
-        /* 2-byte commands (240..250 and 255):
-         * IAC IAC (255) Literal 255. Supported.
-         * IAC SE  (240) End of subnegotiation. Treated as NOP.
-         * IAC NOP (241) NOP. Supported.
-         * 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 tp last newline.
-         * IAC GA  (249) Go ahead. For half-duplex lines: "now you talk".
-         *  Implemented only as part of NAWS:
-         * IAC SB  (250) Subnegotiation of an option follows.
+        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.
          */
-        if (buf[1] == IAC) {
-                /* Literal 255 (emacs M-DEL) */
-                //bb_error_msg("255!");
-                rc = safe_write(ts->ptyfd, &buf[1], 1);
-                /*
-                 * If we went through buffered_IAC_for_pty==1 path,
-                 * bailing out on error like below messes up the buffer.
-                 * EAGAIN is highly unlikely here, other errors will be
-                 * repeated on next write, let's just skip error check.
-                 */
-#if 0
-                if (rc <= 0)
-                        return rc;
-#endif
-                rc = 2;
-                goto update_and_return;
+        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;
         }
-        if (buf[1] == AYT) {
-                if (ts->size2 == 0) { /* if nothing buffered yet... */
-                        /* Send back evidence that AYT was seen */
-                        unsigned char *buf2 = TS_BUF2(ts);
-                        buf2[0] = IAC;
-                        buf2[1] = NOP;
-                        ts->wridx2 = 0;
-                        ts->rdidx2 = ts->size2 = 2;
+        return rc;
+}
+
+/* Check if buffer has space to read into */
+static int net_to_pty__have_buffer_to_read_into(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;
                 }
-                rc = 2;
-                goto update_and_return;
+                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 (buf[1] >= 240 && buf[1] <= 249) {
-                /* NOP (241). Ignore (putty keepalive, etc) */
-                /* All other 2-byte commands also treated as NOPs here */
-                rc = 2;
-                goto update_and_return;
+
+        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" */
         }
 
-        if (wr <= 2) {
-/* BUG: only 2 bytes of the IAC is in the buffer, we just eat them.
- * This is not a practical problem since >2 byte IACs are seen only
- * in initial negotiation, when buffer is empty
- */
-                rc = 2;
-                goto update_and_return;
+        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" */
         }
 
-        if (buf[1] == SB) {
-                if (buf[2] == TELOPT_NAWS) {
-                        /* IAC SB, TELOPT_NAWS, 4-byte, IAC SE */
-                        struct winsize ws;
-                        if (wr <= 6) {
-/* BUG: incomplete, can't process */
-                                rc = wr;
-                                goto update_and_return;
+        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->have_buffer_to_read_into = net_to_pty__have_buffer_to_read_into;
+        this->have_data_to_write       = net_to_pty__have_data_to_write;
+        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__have_buffer_to_read_into(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" */
                         }
-                        memset(&ws, 0, sizeof(ws)); /* pixel sizes are set to 0 */
-                        ws.ws_col = (buf[3] << 8) | buf[4];
-                        ws.ws_row = (buf[5] << 8) | buf[6];
-                        ioctl(ts->ptyfd, TIOCSWINSZ, (char *)&ws);
-                        rc = 7;
-                        /* trailing IAC SE will be eaten separately, as 2-byte NOP */
-                        goto update_and_return;
+                        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;
                 }
-                /* else: other subnegs not supported yet */
+                /* 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;
 
-        /* Assume it is a 3-byte WILL/WONT/DO/DONT 251..254 command and skip it */
-#if DEBUG
-        fprintf(stderr, "Ignoring IAC %s,%s\n",
-                        TELCMD(buf[1]), TELOPT(buf[2]));
-#endif
-        rc = 3;
-
- update_and_return:
-        ts->wridx1 += rc;
-        if (ts->wridx1 >= BUFSIZE) /* actually == BUFSIZE */
-                ts->wridx1 = 0;
-        ts->size1 -= rc;
-        /*
-         * Hack. We cannot process IACs which wrap around buffer's end.
-         * Since properly fixing it requires writing bigger code,
-         * we rely instead on this code making it virtually impossible
-         * to have wrapped IAC (people don't type at 2k/second).
-         * It also allows for bigger reads in common case.
-         */
-        if (ts->size1 == 0) { /* very typical */
-                //bb_error_msg("zero size1");
-                ts->rdidx1 = 0;
-                ts->wridx1 = 0;
-                return rc;
-        }
-        wr = ts->wridx1;
-        if (wr != 0 && wr < ts->rdidx1) {
-                /* Buffer is not wrapped yet.
-                 * We can easily move it to the beginning.
-                 */
-                //bb_error_msg("moved %d", wr);
-                memmove(TS_BUF1(ts), TS_BUF1(ts) + wr, ts->size1);
-                ts->rdidx1 -= wr;
-                ts->wridx1 = 0;
+        ts->size += count;
+        BUF2NET_INC(ts->rdidx, count);
+
+        return count;
+}
+
+static int pty_to_net__have_data_to_write(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 rc;
+        return ts->size > 0 || ts->respond_to_AYT || ts->extra_byte_to_write;
 }
 
-/*
- * Converting single IAC into double on output
- */
-static size_t safe_write_double_iac(int fd, const char *buf, size_t count)
+/* Write to socket from buffer, escaping IAC bytes */
+static int pty_to_net__write(void *this)
 {
-        const char *IACptr;
-        size_t wr, rc, total;
+        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;
+        }
 
-        total = 0;
-        while (1) {
-                if (count == 0)
-                        return total;
-                if (*buf == (char)IAC) {
-                        static const char IACIAC[] ALIGN1 = { IAC, IAC };
-                        rc = safe_write(fd, IACIAC, 2);
-/* BUG: if partial write was only 1 byte long, we end up emitting just one IAC */
-                        if (rc != 2)
-                                break;
-                        buf++;
-                        total++;
-                        count--;
-                        continue;
+        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;
                 }
-                /* count != 0, *buf != IAC */
-                IACptr = memchr(buf, IAC, count);
-                wr = count;
-                if (IACptr)
-                        wr = IACptr - buf;
-                rc = safe_write(fd, buf, wr);
-                if (rc != wr)
-                        break;
-                buf += rc;
-                total += rc;
-                count -= rc;
+                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;
         }
-        /* here: rc - result of last short write */
-        if ((ssize_t)rc < 0) { /* error? */
-                if (total == 0)
-                        return rc;
-                rc = 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;
         }
-        return total + rc;
+        dbg_close("%s:%d: remove_and_free_to_net:%p", __func__, __LINE__, ts);
+        remove_and_free_to_net(ts);
+        return -1; /* "I'm gone" */
 }
 
-/* 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 */
-};
+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->have_buffer_to_read_into = pty_to_net__have_buffer_to_read_into;
+        this->have_data_to_write       = pty_to_net__have_data_to_write;
+        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;
+}
 
-static struct tsession *
-make_new_session(
-                IF_FEATURE_TELNETD_STANDALONE(int sock)
-                IF_NOT_FEATURE_TELNETD_STANDALONE(void)
-) {
 #if !ENABLE_FEATURE_TELNETD_STANDALONE
-        enum { sock = 0 };
+#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 fd, pid;
+        int ptyfd, pid;
         char tty_name[GETPTY_BUFSIZE];
-        struct tsession *ts = xzalloc(sizeof(struct tsession) + BUFSIZE * 2);
 
-        /*ts->buf1 = (char *)(ts + 1);*/
-        /*ts->buf2 = ts->buf1 + BUFSIZE;*/
-
-        /* Got a new connection, set up a tty */
-        fd = xgetpty(tty_name);
-        if (fd > G.maxfd)
-                G.maxfd = fd;
-        ts->ptyfd = fd;
-        ndelay_on(fd);
-        close_on_exec_on(fd);
+        /* 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(sock);
-#if ENABLE_FEATURE_TELNETD_STANDALONE
-        ts->sockfd_read = sock;
-        ndelay_on(sock);
-        if (sock == 0) { /* We are called with fd 0 - we are in inetd mode */
-                sock++; /* so use fd 1 for output */
-                ndelay_on(sock);
-        }
-        ts->sockfd_write = sock;
-        if (sock > G.maxfd)
-                G.maxfd = sock;
-#else
-        /* ts->sockfd_read = 0; - done by xzalloc */
-        ts->sockfd_write = 1;
-        ndelay_on(0);
-        ndelay_on(1);
-#endif
+        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,
@@ -474,41 +872,48 @@ make_new_session(
          * stuff that requires char-by-char support. */
         {
                 static const char iacs_to_send[] ALIGN1 = {
-                        IAC, DO, TELOPT_ECHO,
-                        IAC, DO, TELOPT_NAWS,
-                        /* This requires telnetd.ctrlSQ.patch (incomplete) */
-                        /*IAC, DO, TELOPT_LFLOW,*/
-                        IAC, WILL, TELOPT_ECHO,
-                        IAC, WILL, TELOPT_SGA
+                        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,
                 };
-                /* This confuses safe_write_double_iac(), it will try to duplicate
-                 * each IAC... */
-                //memcpy(TS_BUF2(ts), iacs_to_send, sizeof(iacs_to_send));
-                //ts->rdidx2 = sizeof(iacs_to_send);
-                //ts->size2 = sizeof(iacs_to_send);
-                /* So just stuff it into TCP stream! (no error check...) */
-#if ENABLE_FEATURE_TELNETD_STANDALONE
-                safe_write(sock, iacs_to_send, sizeof(iacs_to_send));
-#else
-                safe_write(1, iacs_to_send, sizeof(iacs_to_send));
-#endif
-                /*ts->rdidx2 = 0; - xzalloc did it */
-                /*ts->size2 = 0;*/
+//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) {
-                free(ts);
-                close(fd);
-                /* sock will be closed by caller */
+                close(ptyfd);
+                close(sockrd);
                 bb_simple_perror_msg("vfork");
-                return NULL;
+                return;
         }
         if (pid > 0) {
                 /* Parent */
-                ts->shell_pid = pid;
-                return ts;
+                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 */
@@ -517,31 +922,30 @@ make_new_session(
         /* Restore default signal handling ASAP */
         bb_signals((1 << SIGCHLD) + (1 << SIGPIPE), SIG_DFL);
 
-        pid = getpid();
+        /* 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(sock);
+                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);
-                free(hostname);
+                IF_FEATURE_CLEAN_UP(free(hostname);)
         }
 
-        /* Make new session and process group */
-        setsid();
-
-        /* Open the child's side of the tty */
-        /* 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); /* becomes our ctty */
-        xdup2(0, 1);
-        xdup2(0, 2);
-        tcsetpgrp(0, pid); /* switch this tty's process group to us */
-
         /* 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);
@@ -565,8 +969,8 @@ make_new_session(
         login_argv[1] = NULL;
         /* exec busybox applet (if PREFER_APPLETS=y), if that fails,
          * exec external program.
-         * NB: sock is either 0 or has CLOEXEC set on it.
-         * fd has CLOEXEC set on it too. These two fds will be closed here.
+         * 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
@@ -574,123 +978,708 @@ make_new_session(
         _exit_FAILURE(); /*bb_perror_msg_and_die("execv %s", G.loginpath);*/
 }
 
+
 #if ENABLE_FEATURE_TELNETD_STANDALONE
+struct accept_conn {
+        TELNET_CONNECTION
+};
 
-static void
-free_session(struct tsession *ts)
+static int accept_conn__can_accept(void *this UNUSED_PARAM)
 {
-        struct tsession *t;
-
-        if (option_mask32 & OPT_INETD)
-                exit_SUCCESS();
+        return 1;
+}
 
-        /* Unlink this telnet session from the session list */
-        t = G.sessions;
-        if (t == ts)
-                G.sessions = ts->next;
-        else {
-                while (t->next != ts)
-                        t = t->next;
-                t->next = ts->next;
-        }
+static int accept_conn__accept(void *this)
+{
+        struct accept_conn *ts = this;
+        int fd;
 
-#if 0
-        /* It was said that "normal" telnetd just closes ptyfd,
-         * doesn't send SIGKILL. When we close ptyfd,
-         * kernel sends SIGHUP to processes having slave side opened. */
-        kill(ts->shell_pid, SIGKILL);
-        waitpid(ts->shell_pid, NULL, 0);
-#endif
-        close(ts->ptyfd);
-        close(ts->sockfd_read);
-        /* We do not need to close(ts->sockfd_write), it's the same
-         * as sockfd_read unless we are in inetd mode. But in inetd mode
-         * we do not reach this */
-        free(ts);
-
-        /* Scan all sessions and find new maxfd */
-        G.maxfd = 0;
-        ts = G.sessions;
-        while (ts) {
-                if (G.maxfd < ts->ptyfd)
-                        G.maxfd = ts->ptyfd;
-                if (G.maxfd < ts->sockfd_read)
-                        G.maxfd = ts->sockfd_read;
-#if 0
-                /* Again, sockfd_write == sockfd_read here */
-                if (G.maxfd < ts->sockfd_write)
-                        G.maxfd = ts->sockfd_write;
-#endif
-                ts = ts->next;
+        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;
 }
 
-#else /* !FEATURE_TELNETD_STANDALONE */
-
-/* Used in main() only, thus "return 0" actually is exit(EXIT_SUCCESS). */
-#define free_session(ts) 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->have_buffer_to_read_into = accept_conn__can_accept;
+        this->have_data_to_write       = 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)
 {
-        pid_t pid;
-        struct tsession *ts;
         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;
-                ts = G.sessions;
-                while (ts) {
-                        if (ts->shell_pid == pid) {
-                                ts->shell_pid = -1;
-                                update_utmp_DEAD_PROCESS(pid);
-                                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;
                         }
-                        ts = ts->next;
+                        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)
 {
-        fd_set rdfdset, wrfdset;
         unsigned opt;
-        int count;
-        struct tsession *ts;
 #if ENABLE_FEATURE_TELNETD_STANDALONE
 #define IS_INETD (opt & OPT_INETD)
-        int master_fd = master_fd; /* for compiler */
-        int sec_linger = sec_linger;
         char *opt_bindaddr = NULL;
         char *opt_portnbr;
 #else
-        enum {
-                IS_INETD = 1,
-                master_fd = -1,
-        };
+        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:+") /* -w NUM */
+                        IF_FEATURE_TELNETD_INETD_WAIT("Sw:+v") /* -w NUM */
                         "\0"
-                        /* -w implies -F. -w and -i don't mix */
-                        IF_FEATURE_TELNETD_INETD_WAIT("wF:i--w:w--i"),
-                        &G.issuefile, &G.loginpath
+                        /* -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(, &sec_linger)
+                        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 */
@@ -706,28 +1695,28 @@ int telnetd_main(int argc UNUSED_PARAM, char **argv)
                 openlog(applet_name, LOG_PID, LOG_DAEMON);
                 logmode = LOGMODE_SYSLOG;
         }
-#if ENABLE_FEATURE_TELNETD_STANDALONE
+
         if (IS_INETD) {
-                G.sessions = make_new_session(0);
-                if (!G.sessions) /* pty opening or vfork problem, exit */
-                        return 1; /* make_new_session printed error message */
-        } else {
-                master_fd = 0;
+                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));
         }
-#else
-        G.sessions = make_new_session();
-        if (!G.sessions) /* pty opening or vfork problem, exit */
-                return 1; /* make_new_session printed error message */
 #endif
-
         /* We don't want to die if just one session is broken */
         signal(SIGPIPE, SIG_IGN);
 
@@ -736,189 +1725,30 @@ int telnetd_main(int argc UNUSED_PARAM, char **argv)
         else /* prevent dead children from becoming zombies */
                 signal(SIGCHLD, SIG_IGN);
 
-/*
-   This is how the buffers are used. The arrows indicate data flow.
-
-   +-------+     wridx1++     +------+     rdidx1++     +----------+
-   |       | <--------------  | buf1 | <--------------  |          |
-   |       |     size1--      +------+     size1++      |          |
-   |  pty  |                                            |  socket  |
-   |       |     rdidx2++     +------+     wridx2++     |          |
-   |       |  --------------> | buf2 |  --------------> |          |
-   +-------+     size2++      +------+     size2--      +----------+
-
-   size1: "how many bytes are buffered for pty between rdidx1 and wridx1?"
-   size2: "how many bytes are buffered for socket between rdidx2 and wridx2?"
-
-   Each session has got two buffers. Buffers are circular. If sizeN == 0,
-   buffer is empty. If sizeN == BUFSIZE, buffer is full. In both these cases
-   rdidxN == wridxN.
-*/
- again:
-        FD_ZERO(&rdfdset);
-        FD_ZERO(&wrfdset);
-
-        /* Select on the master socket, all telnet sockets and their
-         * ptys if there is room in their session buffers.
-         * NB: scalability problem: we recalculate entire bitmap
-         * before each select. Can be a problem with 500+ connections. */
-        ts = G.sessions;
-        while (ts) {
-                struct tsession *next = ts->next; /* in case we free ts */
-                if (ts->shell_pid == -1) {
-                        /* Child died and we detected that */
-                        free_session(ts);
-                } else {
-                        if (ts->size1 > 0)       /* can write to pty */
-                                FD_SET(ts->ptyfd, &wrfdset);
-                        if (ts->size1 < BUFSIZE) /* can read from socket */
-                                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 */
-                                FD_SET(ts->ptyfd, &rdfdset);
-                }
-                ts = next;
-        }
-        if (!IS_INETD) {
-                FD_SET(master_fd, &rdfdset);
-                /* This is needed because free_session() does not
-                 * take master_fd into account when it finds new
-                 * maxfd among remaining fd's */
-                if (master_fd > G.maxfd)
-                        G.maxfd = master_fd;
-        }
-
-        {
-                struct timeval *tv_ptr = NULL;
 #if ENABLE_FEATURE_TELNETD_INETD_WAIT
-                struct timeval tv;
-                if ((opt & OPT_WAIT) && !G.sessions) {
-                        tv.tv_sec = sec_linger;
-                        tv.tv_usec = 0;
-                        tv_ptr = &tv;
-                }
+        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
-                count = select(G.maxfd + 1, &rdfdset, &wrfdset, NULL, tv_ptr);
-        }
-        if (count == 0) /* "telnetd -w SEC" timed out */
-                return 0;
-        if (count < 0)
-                goto again; /* EINTR or ENOMEM */
-
-#if ENABLE_FEATURE_TELNETD_STANDALONE
-        /* Check for and accept new sessions */
-        if (!IS_INETD && FD_ISSET(master_fd, &rdfdset)) {
-                int fd;
-                struct tsession *new_ts;
-
-                fd = accept(master_fd, NULL, NULL);
-                if (fd < 0)
-                        goto again;
-                close_on_exec_on(fd);
-
-                /* Create a new session and link it into active list */
-                new_ts = make_new_session(fd);
-                if (new_ts) {
-                        new_ts->next = G.sessions;
-                        G.sessions = new_ts;
-                } else {
-                        close(fd);
-                }
-        }
-#endif
-
-        /* Then check for data tunneling */
-        ts = G.sessions;
-        while (ts) { /* For all sessions... */
-                struct tsession *next = ts->next; /* in case we free ts */
-
-                if (/*ts->size1 &&*/ FD_ISSET(ts->ptyfd, &wrfdset)) {
-                        /* Write to pty from buffer 1 */
-                        count = safe_write_to_pty_decode_iac(ts);
-                        if (count < 0) {
-                                if (errno == EAGAIN)
-                                        goto skip1;
-                                goto kill_session;
-                        }
+        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;
                 }
- skip1:
-                if (/*ts->size2 &&*/ FD_ISSET(ts->sockfd_write, &wrfdset)) {
-                        /* Write to socket from buffer 2 */
-                        count = MIN(BUFSIZE - ts->wridx2, ts->size2);
-                        count = safe_write_double_iac(ts->sockfd_write, (void*)(TS_BUF2(ts) + ts->wridx2), count);
-                        if (count < 0) {
-                                if (errno == EAGAIN)
-                                        goto skip2;
-                                goto kill_session;
-                        }
-                        ts->wridx2 += count;
-                        if (ts->wridx2 >= BUFSIZE) /* actually == BUFSIZE */
-                                ts->wridx2 = 0;
-                        ts->size2 -= count;
-                        if (ts->size2 == 0) {
-                                ts->rdidx2 = 0;
-                                ts->wridx2 = 0;
-                        }
+                /* 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;
                 }
- skip2:
-
-                if (/*ts->size1 < BUFSIZE &&*/ FD_ISSET(ts->sockfd_read, &rdfdset)) {
-                        /* Read from socket to buffer 1 */
-                        count = MIN(BUFSIZE - ts->rdidx1, BUFSIZE - ts->size1);
-                        count = safe_read(ts->sockfd_read, TS_BUF1(ts) + ts->rdidx1, count);
-                        if (count <= 0) {
-                                if (count < 0 && errno == EAGAIN)
-                                        goto skip3;
-                                goto kill_session;
-                        }
-                        /* Ignore trailing NUL if it is there */
-                        if (!TS_BUF1(ts)[ts->rdidx1 + count - 1]) {
-                                --count;
-                        }
-                        ts->size1 += count;
-                        ts->rdidx1 += count;
-                        if (ts->rdidx1 >= BUFSIZE) /* actually == BUFSIZE */
-                                ts->rdidx1 = 0;
-                }
- skip3:
-                if (/*ts->size2 < BUFSIZE &&*/ FD_ISSET(ts->ptyfd, &rdfdset)) {
-                        /* Read from pty to buffer 2 */
-                        int eio = 0;
- read_pty:
-                        count = MIN(BUFSIZE - ts->rdidx2, BUFSIZE - ts->size2);
-                        count = safe_read(ts->ptyfd, TS_BUF2(ts) + ts->rdidx2, count);
-                        if (count <= 0) {
-                                if (count < 0) {
-                                        if (errno == EAGAIN)
-                                                goto skip4;
-                                        /* login process might call vhangup(),
-                                         * which causes intermittent EIOs on read above
-                                         * (observed on kernel 4.12.0). Try up to 10 ms.
-                                         */
-                                        if (errno == EIO && eio < 10) {
-                                                eio++;
-                                                //bb_error_msg("EIO pty %u", eio);
-                                                usleep(1000);
-                                                goto read_pty;
-                                        }
-                                }
-                                goto kill_session;
-                        }
-                        ts->size2 += count;
-                        ts->rdidx2 += count;
-                        if (ts->rdidx2 >= BUFSIZE) /* actually == BUFSIZE */
-                                ts->rdidx2 = 0;
-                }
- skip4:
-                ts = next;
-                continue;
- kill_session:
-                if (ts->shell_pid > 0)
-                        update_utmp_DEAD_PROCESS(ts->shell_pid);
-                free_session(ts);
-                ts = next;
-        }
-
-        goto again;
+#endif
+                dbg("timeout was due to temporary EIO: continue looping");
+        }
+        dbg_close("terminating");
+        return EXIT_SUCCESS;
 }
diff --git a/networking/telnetd.c.OLD b/networking/telnetd.c.OLD
new file mode 100644
index 000000000..a5a783047
--- /dev/null
+++ b/networking/telnetd.c.OLD
@@ -0,0 +1,924 @@
+/* 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_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:        )
+
+#define DEBUG 0
+
+#include "libbb.h"
+#include "common_bufsiz.h"
+#include <syslog.h>
+
+#if DEBUG
+# define TELCMDS
+# define TELOPTS
+#endif
+#include <arpa/telnet.h>
+
+
+struct tsession {
+        struct tsession *next;
+        pid_t shell_pid;
+        int sockfd_read;
+        int sockfd_write;
+        int ptyfd;
+        smallint buffered_IAC_for_pty;
+
+        /* two circular buffers */
+        /*char *buf1, *buf2;*/
+/*#define TS_BUF1(ts) ts->buf1*/
+/*#define TS_BUF2(ts) TS_BUF2(ts)*/
+#define TS_BUF1(ts) ((unsigned char*)(ts + 1))
+#define TS_BUF2(ts) (((unsigned char*)(ts + 1)) + BUFSIZE)
+        int rdidx1, wridx1, size1;
+        int rdidx2, wridx2, size2;
+};
+
+/* Two buffers are directly after tsession in malloced memory.
+ * Make whole thing fit in 4k */
+enum { BUFSIZE = (4 * 1024 - sizeof(struct tsession)) / 2 };
+
+
+/* Globals */
+struct globals {
+        struct tsession *sessions;
+        const char *loginpath;
+        const char *issuefile;
+        int maxfd;
+} 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)
+
+
+/* Write some buf1 data to pty, processing IACs.
+ * Update wridx1 and size1. Return < 0 on error.
+ * Buggy if IAC is present but incomplete: skips them.
+ */
+static ssize_t
+safe_write_to_pty_decode_iac(struct tsession *ts)
+{
+        unsigned wr;
+        ssize_t rc;
+        unsigned char *buf;
+        unsigned char *found;
+
+        buf = TS_BUF1(ts) + ts->wridx1;
+        wr = MIN(BUFSIZE - ts->wridx1, ts->size1);
+        /* wr is at least 1 here */
+
+        if (ts->buffered_IAC_for_pty) {
+                /* Last time we stopped on a "dangling" IAC byte.
+                 * We removed it from the buffer back then.
+                 * Now pretend it's still there, and jump to IAC processing.
+                 */
+                ts->buffered_IAC_for_pty = 0;
+                wr++;
+                ts->size1++;
+                buf--; /* Yes, this can point before the buffer. It's ok */
+                ts->wridx1--;
+                goto handle_iac;
+        }
+
+        found = memchr(buf, IAC, wr);
+        if (found != buf) {
+                /* 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.
+                 */
+                rc = wr;
+                found = memchr(buf, '\r', wr);
+                if (found)
+                        rc = found - buf + 1;
+                rc = safe_write(ts->ptyfd, buf, rc);
+                if (rc <= 0)
+                        return rc;
+                if (rc < wr /* don't look past available data */
+                 && buf[rc-1] == '\r' /* need this: imagine that write was _short_ */
+                 && (buf[rc] == '\n' || buf[rc] == '\0')
+                ) {
+                        rc++;
+                }
+                goto update_and_return;
+        }
+
+        /* buf starts with IAC char. Process that sequence.
+         * Example: we get this from our own (bbox) telnet client:
+         * read(5, "\377\374\1""\377\373\37""\377\372\37\0\262\0@\377\360""\377\375\1""\377\375\3"):
+         * IAC WONT ECHO, IAC WILL NAWS, IAC SB NAWS <cols> <rows> IAC SE, IAC DO SGA
+         * Another example (telnet-0.17 from old-netkit):
+         * read(4, "\377\375\3""\377\373\30""\377\373\37""\377\373 ""\377\373!""\377\373\"""\377\373'"
+         * "\377\375\5""\377\373#""\377\374\1""\377\372\37\0\257\0I\377\360""\377\375\1"):
+         * IAC DO SGA, IAC WILL TTYPE, IAC WILL NAWS, IAC WILL TSPEED, IAC WILL LFLOW, IAC WILL LINEMODE, IAC WILL NEW_ENVIRON,
+         * IAC DO STATUS, IAC WILL XDISPLOC, IAC WONT ECHO, IAC SB NAWS <cols> <rows> IAC SE, IAC DO ECHO
+         */
+        if (wr <= 1) {
+                /* Only the single IAC byte is in the buffer, eat it
+                 * and set a flag "process the rest of the sequence
+                 * next time we are here".
+                 */
+                //bb_error_msg("dangling IAC!");
+                ts->buffered_IAC_for_pty = 1;
+                rc = 1;
+                goto update_and_return;
+        }
+
+ handle_iac:
+        /* 2-byte commands (240..250 and 255):
+         * IAC IAC (255) Literal 255. Supported.
+         * IAC SE  (240) End of subnegotiation. Treated as NOP.
+         * IAC NOP (241) NOP. Supported.
+         * 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 tp last newline.
+         * IAC GA  (249) Go ahead. For half-duplex lines: "now you talk".
+         *  Implemented only as part of NAWS:
+         * IAC SB  (250) Subnegotiation of an option follows.
+         */
+        if (buf[1] == IAC) {
+                /* Literal 255 (emacs M-DEL) */
+                //bb_error_msg("255!");
+                rc = safe_write(ts->ptyfd, &buf[1], 1);
+                /*
+                 * If we went through buffered_IAC_for_pty==1 path,
+                 * bailing out on error like below messes up the buffer.
+                 * EAGAIN is highly unlikely here, other errors will be
+                 * repeated on next write, let's just skip error check.
+                 */
+#if 0
+                if (rc <= 0)
+                        return rc;
+#endif
+                rc = 2;
+                goto update_and_return;
+        }
+        if (buf[1] == AYT) {
+                if (ts->size2 == 0) { /* if nothing buffered yet... */
+                        /* Send back evidence that AYT was seen */
+                        unsigned char *buf2 = TS_BUF2(ts);
+                        buf2[0] = IAC;
+                        buf2[1] = NOP;
+                        ts->wridx2 = 0;
+                        ts->rdidx2 = ts->size2 = 2;
+                }
+                rc = 2;
+                goto update_and_return;
+        }
+        if (buf[1] >= 240 && buf[1] <= 249) {
+                /* NOP (241). Ignore (putty keepalive, etc) */
+                /* All other 2-byte commands also treated as NOPs here */
+                rc = 2;
+                goto update_and_return;
+        }
+
+        if (wr <= 2) {
+/* BUG: only 2 bytes of the IAC is in the buffer, we just eat them.
+ * This is not a practical problem since >2 byte IACs are seen only
+ * in initial negotiation, when buffer is empty
+ */
+                rc = 2;
+                goto update_and_return;
+        }
+
+        if (buf[1] == SB) {
+                if (buf[2] == TELOPT_NAWS) {
+                        /* IAC SB, TELOPT_NAWS, 4-byte, IAC SE */
+                        struct winsize ws;
+                        if (wr <= 6) {
+/* BUG: incomplete, can't process */
+                                rc = wr;
+                                goto update_and_return;
+                        }
+                        memset(&ws, 0, sizeof(ws)); /* pixel sizes are set to 0 */
+                        ws.ws_col = (buf[3] << 8) | buf[4];
+                        ws.ws_row = (buf[5] << 8) | buf[6];
+                        ioctl(ts->ptyfd, TIOCSWINSZ, (char *)&ws);
+                        rc = 7;
+                        /* trailing IAC SE will be eaten separately, as 2-byte NOP */
+                        goto update_and_return;
+                }
+                /* else: other subnegs not supported yet */
+        }
+
+        /* Assume it is a 3-byte WILL/WONT/DO/DONT 251..254 command and skip it */
+#if DEBUG
+        fprintf(stderr, "Ignoring IAC %s,%s\n",
+                        TELCMD(buf[1]), TELOPT(buf[2]));
+#endif
+        rc = 3;
+
+ update_and_return:
+        ts->wridx1 += rc;
+        if (ts->wridx1 >= BUFSIZE) /* actually == BUFSIZE */
+                ts->wridx1 = 0;
+        ts->size1 -= rc;
+        /*
+         * Hack. We cannot process IACs which wrap around buffer's end.
+         * Since properly fixing it requires writing bigger code,
+         * we rely instead on this code making it virtually impossible
+         * to have wrapped IAC (people don't type at 2k/second).
+         * It also allows for bigger reads in common case.
+         */
+        if (ts->size1 == 0) { /* very typical */
+                //bb_error_msg("zero size1");
+                ts->rdidx1 = 0;
+                ts->wridx1 = 0;
+                return rc;
+        }
+        wr = ts->wridx1;
+        if (wr != 0 && wr < ts->rdidx1) {
+                /* Buffer is not wrapped yet.
+                 * We can easily move it to the beginning.
+                 */
+                //bb_error_msg("moved %d", wr);
+                memmove(TS_BUF1(ts), TS_BUF1(ts) + wr, ts->size1);
+                ts->rdidx1 -= wr;
+                ts->wridx1 = 0;
+        }
+        return rc;
+}
+
+/*
+ * Converting single IAC into double on output
+ */
+static size_t safe_write_double_iac(int fd, const char *buf, size_t count)
+{
+        const char *IACptr;
+        size_t wr, rc, total;
+
+        total = 0;
+        while (1) {
+                if (count == 0)
+                        return total;
+                if (*buf == (char)IAC) {
+                        static const char IACIAC[] ALIGN1 = { IAC, IAC };
+                        rc = safe_write(fd, IACIAC, 2);
+/* BUG: if partial write was only 1 byte long, we end up emitting just one IAC */
+                        if (rc != 2)
+                                break;
+                        buf++;
+                        total++;
+                        count--;
+                        continue;
+                }
+                /* count != 0, *buf != IAC */
+                IACptr = memchr(buf, IAC, count);
+                wr = count;
+                if (IACptr)
+                        wr = IACptr - buf;
+                rc = safe_write(fd, buf, wr);
+                if (rc != wr)
+                        break;
+                buf += rc;
+                total += rc;
+                count -= rc;
+        }
+        /* here: rc - result of last short write */
+        if ((ssize_t)rc < 0) { /* error? */
+                if (total == 0)
+                        return rc;
+                rc = 0;
+        }
+        return total + rc;
+}
+
+/* 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 */
+};
+
+static struct tsession *
+make_new_session(
+                IF_FEATURE_TELNETD_STANDALONE(int sock)
+                IF_NOT_FEATURE_TELNETD_STANDALONE(void)
+) {
+#if !ENABLE_FEATURE_TELNETD_STANDALONE
+        enum { sock = 0 };
+#endif
+        const char *login_argv[2];
+        struct termios termbuf;
+        int fd, pid;
+        char tty_name[GETPTY_BUFSIZE];
+        struct tsession *ts = xzalloc(sizeof(struct tsession) + BUFSIZE * 2);
+
+        /*ts->buf1 = (char *)(ts + 1);*/
+        /*ts->buf2 = ts->buf1 + BUFSIZE;*/
+
+        /* Got a new connection, set up a tty */
+        fd = xgetpty(tty_name);
+        if (fd > G.maxfd)
+                G.maxfd = fd;
+        ts->ptyfd = fd;
+        ndelay_on(fd);
+        close_on_exec_on(fd);
+
+        /* SO_KEEPALIVE by popular demand */
+        setsockopt_keepalive(sock);
+#if ENABLE_FEATURE_TELNETD_STANDALONE
+        ts->sockfd_read = sock;
+        ndelay_on(sock);
+        if (sock == 0) { /* We are called with fd 0 - we are in inetd mode */
+                sock++; /* so use fd 1 for output */
+                ndelay_on(sock);
+        }
+        ts->sockfd_write = sock;
+        if (sock > G.maxfd)
+                G.maxfd = sock;
+#else
+        /* ts->sockfd_read = 0; - done by xzalloc */
+        ts->sockfd_write = 1;
+        ndelay_on(0);
+        ndelay_on(1);
+#endif
+
+        /* 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, DO, TELOPT_ECHO,
+                        IAC, DO, TELOPT_NAWS,
+                        /* This requires telnetd.ctrlSQ.patch (incomplete) */
+                        /*IAC, DO, TELOPT_LFLOW,*/
+                        IAC, WILL, TELOPT_ECHO,
+                        IAC, WILL, TELOPT_SGA
+                };
+                /* This confuses safe_write_double_iac(), it will try to duplicate
+                 * each IAC... */
+                //memcpy(TS_BUF2(ts), iacs_to_send, sizeof(iacs_to_send));
+                //ts->rdidx2 = sizeof(iacs_to_send);
+                //ts->size2 = sizeof(iacs_to_send);
+                /* So just stuff it into TCP stream! (no error check...) */
+#if ENABLE_FEATURE_TELNETD_STANDALONE
+                safe_write(sock, iacs_to_send, sizeof(iacs_to_send));
+#else
+                safe_write(1, iacs_to_send, sizeof(iacs_to_send));
+#endif
+                /*ts->rdidx2 = 0; - xzalloc did it */
+                /*ts->size2 = 0;*/
+        }
+
+        fflush_all();
+        pid = vfork(); /* NOMMU-friendly */
+        if (pid < 0) {
+                free(ts);
+                close(fd);
+                /* sock will be closed by caller */
+                bb_simple_perror_msg("vfork");
+                return NULL;
+        }
+        if (pid > 0) {
+                /* Parent */
+                ts->shell_pid = pid;
+                return ts;
+        }
+
+        /* Child */
+        /* Careful - we are after vfork! */
+
+        /* Restore default signal handling ASAP */
+        bb_signals((1 << SIGCHLD) + (1 << SIGPIPE), SIG_DFL);
+
+        pid = getpid();
+
+        if (ENABLE_FEATURE_UTMP) {
+                len_and_sockaddr *lsa = get_peer_lsa(sock);
+                char *hostname = NULL;
+                if (lsa) {
+                        hostname = xmalloc_sockaddr2dotted(&lsa->u.sa);
+                        free(lsa);
+                }
+                write_new_utmp(pid, LOGIN_PROCESS, tty_name, /*username:*/ "LOGIN", hostname);
+                free(hostname);
+        }
+
+        /* Make new session and process group */
+        setsid();
+
+        /* Open the child's side of the tty */
+        /* 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); /* becomes our ctty */
+        xdup2(0, 1);
+        xdup2(0, 2);
+        tcsetpgrp(0, pid); /* switch this tty's process group to us */
+
+        /* 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: sock is either 0 or has CLOEXEC set on it.
+         * fd 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
+
+static void
+free_session(struct tsession *ts)
+{
+        struct tsession *t;
+
+        if (option_mask32 & OPT_INETD)
+                exit_SUCCESS();
+
+        /* Unlink this telnet session from the session list */
+        t = G.sessions;
+        if (t == ts)
+                G.sessions = ts->next;
+        else {
+                while (t->next != ts)
+                        t = t->next;
+                t->next = ts->next;
+        }
+
+#if 0
+        /* It was said that "normal" telnetd just closes ptyfd,
+         * doesn't send SIGKILL. When we close ptyfd,
+         * kernel sends SIGHUP to processes having slave side opened. */
+        kill(ts->shell_pid, SIGKILL);
+        waitpid(ts->shell_pid, NULL, 0);
+#endif
+        close(ts->ptyfd);
+        close(ts->sockfd_read);
+        /* We do not need to close(ts->sockfd_write), it's the same
+         * as sockfd_read unless we are in inetd mode. But in inetd mode
+         * we do not reach this */
+        free(ts);
+
+        /* Scan all sessions and find new maxfd */
+        G.maxfd = 0;
+        ts = G.sessions;
+        while (ts) {
+                if (G.maxfd < ts->ptyfd)
+                        G.maxfd = ts->ptyfd;
+                if (G.maxfd < ts->sockfd_read)
+                        G.maxfd = ts->sockfd_read;
+#if 0
+                /* Again, sockfd_write == sockfd_read here */
+                if (G.maxfd < ts->sockfd_write)
+                        G.maxfd = ts->sockfd_write;
+#endif
+                ts = ts->next;
+        }
+}
+
+#else /* !FEATURE_TELNETD_STANDALONE */
+
+/* Used in main() only, thus "return 0" actually is exit(EXIT_SUCCESS). */
+#define free_session(ts) return 0
+
+#endif
+
+static void handle_sigchld(int sig UNUSED_PARAM)
+{
+        pid_t pid;
+        struct tsession *ts;
+        int save_errno = errno;
+
+        /* Looping: more than one child may have exited */
+        while (1) {
+                pid = wait_any_nohang(NULL);
+                if (pid <= 0)
+                        break;
+                ts = G.sessions;
+                while (ts) {
+                        if (ts->shell_pid == pid) {
+                                ts->shell_pid = -1;
+                                update_utmp_DEAD_PROCESS(pid);
+                                break;
+                        }
+                        ts = ts->next;
+                }
+        }
+
+        errno = save_errno;
+}
+
+int telnetd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int telnetd_main(int argc UNUSED_PARAM, char **argv)
+{
+        fd_set rdfdset, wrfdset;
+        unsigned opt;
+        int count;
+        struct tsession *ts;
+#if ENABLE_FEATURE_TELNETD_STANDALONE
+#define IS_INETD (opt & OPT_INETD)
+        int master_fd = master_fd; /* for compiler */
+        int sec_linger = sec_linger;
+        char *opt_bindaddr = NULL;
+        char *opt_portnbr;
+#else
+        enum {
+                IS_INETD = 1,
+                master_fd = -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, "^"
+                        "f:l:Ki"
+                        IF_FEATURE_TELNETD_STANDALONE("p:b:F")
+                        IF_FEATURE_TELNETD_INETD_WAIT("Sw:+") /* -w NUM */
+                        "\0"
+                        /* -w implies -F. -w and -i don't mix */
+                        IF_FEATURE_TELNETD_INETD_WAIT("wF:i--w:w--i"),
+                        &G.issuefile, &G.loginpath
+                        IF_FEATURE_TELNETD_STANDALONE(, &opt_portnbr, &opt_bindaddr)
+                        IF_FEATURE_TELNETD_INETD_WAIT(, &sec_linger)
+        );
+        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 ENABLE_FEATURE_TELNETD_STANDALONE
+        if (IS_INETD) {
+                G.sessions = make_new_session(0);
+                if (!G.sessions) /* pty opening or vfork problem, exit */
+                        return 1; /* make_new_session printed error message */
+        } else {
+                master_fd = 0;
+                if (!(opt & OPT_WAIT)) {
+                        unsigned portnbr = CONFIG_FEATURE_TELNETD_PORT_DEFAULT;
+                        if (opt & OPT_PORT)
+                                portnbr = xatou16(opt_portnbr);
+                        master_fd = create_and_bind_stream_or_die(opt_bindaddr, portnbr);
+                        xlisten(master_fd, 1);
+                }
+                close_on_exec_on(master_fd);
+        }
+#else
+        G.sessions = make_new_session();
+        if (!G.sessions) /* pty opening or vfork problem, exit */
+                return 1; /* make_new_session printed error message */
+#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);
+
+/*
+   This is how the buffers are used. The arrows indicate data flow.
+
+   +-------+     wridx1++     +------+     rdidx1++     +----------+
+   |       | <--------------  | buf1 | <--------------  |          |
+   |       |     size1--      +------+     size1++      |          |
+   |  pty  |                                            |  socket  |
+   |       |     rdidx2++     +------+     wridx2++     |          |
+   |       |  --------------> | buf2 |  --------------> |          |
+   +-------+     size2++      +------+     size2--      +----------+
+
+   size1: "how many bytes are buffered for pty between rdidx1 and wridx1?"
+   size2: "how many bytes are buffered for socket between rdidx2 and wridx2?"
+
+   Each session has got two buffers. Buffers are circular. If sizeN == 0,
+   buffer is empty. If sizeN == BUFSIZE, buffer is full. In both these cases
+   rdidxN == wridxN.
+*/
+ again:
+        FD_ZERO(&rdfdset);
+        FD_ZERO(&wrfdset);
+
+        /* Select on the master socket, all telnet sockets and their
+         * ptys if there is room in their session buffers.
+         * NB: scalability problem: we recalculate entire bitmap
+         * before each select. Can be a problem with 500+ connections. */
+        ts = G.sessions;
+        while (ts) {
+                struct tsession *next = ts->next; /* in case we free ts */
+                if (ts->shell_pid == -1) {
+                        /* Child died and we detected that */
+                        free_session(ts);
+                } else {
+                        if (ts->size1 > 0)       /* can write to pty */
+                                FD_SET(ts->ptyfd, &wrfdset);
+                        if (ts->size1 < BUFSIZE) /* can read from socket */
+                                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 */
+                                FD_SET(ts->ptyfd, &rdfdset);
+                }
+                ts = next;
+        }
+        if (!IS_INETD) {
+                FD_SET(master_fd, &rdfdset);
+                /* This is needed because free_session() does not
+                 * take master_fd into account when it finds new
+                 * maxfd among remaining fd's */
+                if (master_fd > G.maxfd)
+                        G.maxfd = master_fd;
+        }
+
+        {
+                struct timeval *tv_ptr = NULL;
+#if ENABLE_FEATURE_TELNETD_INETD_WAIT
+                struct timeval tv;
+                if ((opt & OPT_WAIT) && !G.sessions) {
+                        tv.tv_sec = sec_linger;
+                        tv.tv_usec = 0;
+                        tv_ptr = &tv;
+                }
+#endif
+                count = select(G.maxfd + 1, &rdfdset, &wrfdset, NULL, tv_ptr);
+        }
+        if (count == 0) /* "telnetd -w SEC" timed out */
+                return 0;
+        if (count < 0)
+                goto again; /* EINTR or ENOMEM */
+
+#if ENABLE_FEATURE_TELNETD_STANDALONE
+        /* Check for and accept new sessions */
+        if (!IS_INETD && FD_ISSET(master_fd, &rdfdset)) {
+                int fd;
+                struct tsession *new_ts;
+
+                fd = accept(master_fd, NULL, NULL);
+                if (fd < 0)
+                        goto again;
+                close_on_exec_on(fd);
+
+                /* Create a new session and link it into active list */
+                new_ts = make_new_session(fd);
+                if (new_ts) {
+                        new_ts->next = G.sessions;
+                        G.sessions = new_ts;
+                } else {
+                        close(fd);
+                }
+        }
+#endif
+
+        /* Then check for data tunneling */
+        ts = G.sessions;
+        while (ts) { /* For all sessions... */
+                struct tsession *next = ts->next; /* in case we free ts */
+
+                if (/*ts->size1 &&*/ FD_ISSET(ts->ptyfd, &wrfdset)) {
+                        /* Write to pty from buffer 1 */
+                        count = safe_write_to_pty_decode_iac(ts);
+                        if (count < 0) {
+                                if (errno == EAGAIN)
+                                        goto skip1;
+                                goto kill_session;
+                        }
+                }
+ skip1:
+                if (/*ts->size2 &&*/ FD_ISSET(ts->sockfd_write, &wrfdset)) {
+                        /* Write to socket from buffer 2 */
+                        count = MIN(BUFSIZE - ts->wridx2, ts->size2);
+                        count = safe_write_double_iac(ts->sockfd_write, (void*)(TS_BUF2(ts) + ts->wridx2), count);
+                        if (count < 0) {
+                                if (errno == EAGAIN)
+                                        goto skip2;
+                                goto kill_session;
+                        }
+                        ts->wridx2 += count;
+                        if (ts->wridx2 >= BUFSIZE) /* actually == BUFSIZE */
+                                ts->wridx2 = 0;
+                        ts->size2 -= count;
+                        if (ts->size2 == 0) {
+                                ts->rdidx2 = 0;
+                                ts->wridx2 = 0;
+                        }
+                }
+ skip2:
+
+                if (/*ts->size1 < BUFSIZE &&*/ FD_ISSET(ts->sockfd_read, &rdfdset)) {
+                        /* Read from socket to buffer 1 */
+                        count = MIN(BUFSIZE - ts->rdidx1, BUFSIZE - ts->size1);
+                        count = safe_read(ts->sockfd_read, TS_BUF1(ts) + ts->rdidx1, count);
+                        if (count <= 0) {
+                                if (count < 0 && errno == EAGAIN)
+                                        goto skip3;
+                                goto kill_session;
+                        }
+                        /* Ignore trailing NUL if it is there */
+                        if (!TS_BUF1(ts)[ts->rdidx1 + count - 1]) {
+                                --count;
+                        }
+                        ts->size1 += count;
+                        ts->rdidx1 += count;
+                        if (ts->rdidx1 >= BUFSIZE) /* actually == BUFSIZE */
+                                ts->rdidx1 = 0;
+                }
+ skip3:
+                if (/*ts->size2 < BUFSIZE &&*/ FD_ISSET(ts->ptyfd, &rdfdset)) {
+                        /* Read from pty to buffer 2 */
+                        int eio = 0;
+ read_pty:
+                        count = MIN(BUFSIZE - ts->rdidx2, BUFSIZE - ts->size2);
+                        count = safe_read(ts->ptyfd, TS_BUF2(ts) + ts->rdidx2, count);
+                        if (count <= 0) {
+                                if (count < 0) {
+                                        if (errno == EAGAIN)
+                                                goto skip4;
+                                        /* login process might call vhangup(),
+                                         * which causes intermittent EIOs on read above
+                                         * (observed on kernel 4.12.0). Try up to 10 ms.
+                                         */
+                                        if (errno == EIO && eio < 10) {
+                                                eio++;
+                                                //bb_error_msg("EIO pty %u", eio);
+                                                usleep(1000);
+                                                goto read_pty;
+                                        }
+                                }
+                                goto kill_session;
+                        }
+                        ts->size2 += count;
+                        ts->rdidx2 += count;
+                        if (ts->rdidx2 >= BUFSIZE) /* actually == BUFSIZE */
+                                ts->rdidx2 = 0;
+                }
+ skip4:
+                ts = next;
+                continue;
+ kill_session:
+                if (ts->shell_pid > 0)
+                        update_utmp_DEAD_PROCESS(ts->shell_pid);
+                free_session(ts);
+                ts = next;
+        }
+
+        goto again;
+}
diff --git a/networking/tls.c b/networking/tls.c
index 46bfd9b24..c7015e044 100644
--- a/networking/tls.c
+++ b/networking/tls.c
@@ -57,13 +57,15 @@
 #endif
 
 #if TLS_DEBUG
-# define dbg(...) fprintf(stderr, __VA_ARGS__)
+# define dbg(...)     bb_error_msg(__VA_ARGS__)
+# define dbgcont(...) fprintf(stderr, __VA_ARGS__)
 #else
-# define dbg(...) ((void)0)
+# define dbg(...)     ((void)0)
+# define dbgcont(...) ((void)0)
 #endif
 
 #if TLS_DEBUG_DER
-# define dbg_der(...) fprintf(stderr, __VA_ARGS__)
+# define dbg_der(...) bb_error_msg(__VA_ARGS__)
 #else
 # define dbg_der(...) ((void)0)
 #endif
@@ -188,6 +190,76 @@
 #define TLS_MAX_CRYPTBLOCK_SIZE 16
 #define TLS_MAX_OUTBUF          (1 << 14)
 
+/* Cipher suites we support, in preference order (best first) */
+#define NUM_CIPHERS (0 \
+        + 4 * ENABLE_FEATURE_TLS_SHA1 \
+        + ALLOW_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 \
+        + ALLOW_ECDHE_RSA_WITH_AES_128_CBC_SHA256 \
+        + ALLOW_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 \
+        + ALLOW_ECDHE_RSA_WITH_AES_128_GCM_SHA256 \
+        + 2 * ENABLE_FEATURE_TLS_SHA1 \
+        + ALLOW_RSA_WITH_AES_128_CBC_SHA256 \
+        + ALLOW_RSA_WITH_AES_256_CBC_SHA256 \
+        + ALLOW_RSA_WITH_AES_128_GCM_SHA256 \
+        + ALLOW_RSA_NULL_SHA256 \
+        )
+static const uint8_t client_hello_ciphers[] = {
+        0x00,2 * (1 + NUM_CIPHERS), //len16_be
+        0x00,0xFF, //not a cipher - TLS_EMPTY_RENEGOTIATION_INFO_SCSV
+        /* ^^^^^^ RFC 5746 Renegotiation Indication Extension - some servers will refuse to work with us otherwise */
+#if ENABLE_FEATURE_TLS_SHA1
+        0xC0,0x09, // 1 TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA - ok: wget https://is.gd/
+        0xC0,0x0A, // 2 TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA - ok: wget https://is.gd/
+        0xC0,0x13, // 3 TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA - ok: openssl s_server ... -cipher ECDHE-RSA-AES128-SHA
+        0xC0,0x14, // 4 TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA - ok: openssl s_server ... -cipher ECDHE-RSA-AES256-SHA (might fail with older openssl)
+//      0xC0,0x18, //   TLS_ECDH_anon_WITH_AES_128_CBC_SHA
+//      0xC0,0x19, //   TLS_ECDH_anon_WITH_AES_256_CBC_SHA
+#endif
+#if ALLOW_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256
+        0xC0,0x23, // 5 TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 - ok: wget https://is.gd/
+#endif
+//      0xC0,0x24, //   TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 - can't do SHA384 yet
+#if ALLOW_ECDHE_RSA_WITH_AES_128_CBC_SHA256
+        0xC0,0x27, // 6 TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 - ok: openssl s_server ... -cipher ECDHE-RSA-AES128-SHA256
+#endif
+//      0xC0,0x28, //   TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 - can't do SHA384 yet
+#if ALLOW_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
+        0xC0,0x2B, // 7 TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 - ok: wget https://is.gd/
+#endif
+//      0xC0,0x2C, //   TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 - wget https://is.gd/: "TLS error from peer (alert code 20): bad MAC"
+//TODO: GCM_SHA384 ciphers can be supported, only need sha384-based PRF?
+#if ALLOW_ECDHE_RSA_WITH_AES_128_GCM_SHA256
+        0xC0,0x2F, // 8 TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 - ok: openssl s_server ... -cipher ECDHE-RSA-AES128-GCM-SHA256
+#endif
+//      0xC0,0x30, //   TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 - openssl s_server ... -cipher ECDHE-RSA-AES256-GCM-SHA384: "decryption failed or bad record mac"
+//possibly these too:
+#if ENABLE_FEATURE_TLS_SHA1
+//      0xC0,0x35, //   TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA
+//      0xC0,0x36, //   TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA
+#endif
+//      0xC0,0x37, //   TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256
+//      0xC0,0x38, //   TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384 - can't do SHA384 yet
+#if ENABLE_FEATURE_TLS_SHA1
+        0x00,0x2F, // 9 TLS_RSA_WITH_AES_128_CBC_SHA - ok: openssl s_server ... -cipher AES128-SHA
+        0x00,0x35, //10 TLS_RSA_WITH_AES_256_CBC_SHA - ok: openssl s_server ... -cipher AES256-SHA
+#endif
+#if ALLOW_RSA_WITH_AES_128_CBC_SHA256
+        0x00,0x3C, //11 TLS_RSA_WITH_AES_128_CBC_SHA256 - ok: openssl s_server ... -cipher AES128-SHA256
+#endif
+#if ALLOW_RSA_WITH_AES_256_CBC_SHA256
+        0x00,0x3D, //12 TLS_RSA_WITH_AES_256_CBC_SHA256 - ok: openssl s_server ... -cipher AES256-SHA256
+#endif
+#if ALLOW_RSA_WITH_AES_128_GCM_SHA256
+        0x00,0x9C, //13 TLS_RSA_WITH_AES_128_GCM_SHA256 - ok: openssl s_server ... -cipher AES128-GCM-SHA256
+#endif
+//      0x00,0x9D, //   TLS_RSA_WITH_AES_256_GCM_SHA384 - openssl s_server ... -cipher AES256-GCM-SHA384: "decryption failed or bad record mac"
+#if ALLOW_RSA_NULL_SHA256
+        0x00,0x3B, //   TLS_RSA_WITH_NULL_SHA256
+#endif
+        0x01,0x00, //not a cipher - comprtypes_len, comprtype
+};
+#define supported_ciphers (client_hello_ciphers + 4)
+
 enum {
         AES128_KEYSIZE = 16,
         AES256_KEYSIZE = 32,
@@ -241,11 +313,75 @@ enum {
         GOT_CERT_RSA_KEY_ALG   = 1 << 1,
         GOT_CERT_ECDSA_KEY_ALG = 1 << 2, // so far unused
         GOT_EC_KEY             = 1 << 3,
-        GOT_EC_CURVE_X25519    = 1 << 4, // else P256
+        /* Client: server sent x25519 key in SERVER_KEY_EXCHANGE (else P256)
+         * Server: we chose x25519 based on client's supported_groups (else P256) */
+        USE_EC_CURVE_X25519    = 1 << 4,
         ENCRYPTION_AESGCM      = 1 << 5, // else AES-SHA (or NULL-SHA if ALLOW_RSA_NULL_SHA256=1)
-        ENCRYPT_ON_WRITE       = 1 << 6,
 };
 
+#if ENABLE_SSL_SERVER // || ENABLE_FEATURE_HTTPD_SSL
+/* Note: return value matches KEY_RSA (0) / KEY_ECDSA (1) enum values */
+static int is_cipher_ECDSA(const uint8_t *cipherid)
+{
+        uint8_t cipher_lo;
+        if (cipherid[0] != 0xC0)
+                return 0;
+        /* ECDHE cipher - check if ECDSA or RSA */
+        cipher_lo = cipherid[1];
+        return  (cipher_lo == 0x09 || cipher_lo == 0x0A
+                || cipher_lo == 0x23 || cipher_lo == 0x2B
+        );
+}
+#endif
+
+/* Set cipher parameters based on selected cipher_id */
+static void set_cipher_parameters(tls_state_t *tls, const uint8_t *cipherid)
+{
+        uint8_t cipherid1 = cipherid[1];
+
+        tls->cipher_id = 0x100 * cipherid[0] + cipherid1;
+
+        /* Set defaults for RSA with AES-256 */
+        tls->key_size = AES256_KEYSIZE;
+        tls->MAC_size = SHA256_OUTSIZE;
+        tls->IV_size = 0;
+
+        if (cipherid[0] == 0xC0) {
+                /* All C0xx are ECDHE */
+                tls->flags |= NEED_EC_KEY;
+                if (cipherid1 & 1) {
+                        /* Odd numbered C0xx use AES128 (even ones use AES256) */
+                        tls->key_size = AES128_KEYSIZE;
+                }
+                if (ENABLE_FEATURE_TLS_SHA1 && cipherid1 <= 0x19) {
+                        tls->MAC_size = SHA1_OUTSIZE;
+                } else
+                if (cipherid1 >= 0x2B && cipherid1 <= 0x30) {
+                        /* C02B,2C,2F,30 are AES-GCM */
+                        tls->flags |= ENCRYPTION_AESGCM;
+                        tls->MAC_size = 0;
+                        tls->IV_size = 4;
+                }
+        } else {
+                /* All 00xx are RSA */
+                if ((ENABLE_FEATURE_TLS_SHA1 && cipherid1 == 0x2F)
+                 || cipherid1 == 0x3C
+                 || cipherid1 == 0x9C
+                ) {
+                        tls->key_size = AES128_KEYSIZE;
+                }
+                if (ENABLE_FEATURE_TLS_SHA1 && cipherid1 <= 0x35) {
+                        tls->MAC_size = SHA1_OUTSIZE;
+                } else
+                if (cipherid1 == 0x9C /*|| cipherid1 == 0x9D*/) {
+                        /* 009C,9D are AES-GCM */
+                        tls->flags |= ENCRYPTION_AESGCM;
+                        tls->MAC_size = 0;
+                        tls->IV_size = 4;
+                }
+        }
+}
+
 struct record_hdr {
         uint8_t type;
         uint8_t proto_maj, proto_min;
@@ -271,14 +407,46 @@ struct tls_handshake_data {
 /* HANDSHAKE HASH: */
         //unsigned saved_client_hello_size;
         //uint8_t saved_client_hello[1];
-};
 
+#if ENABLE_SSL_SERVER // || ENABLE_FEATURE_HTTPD_SSL
+        smallint reneg_info_requested;
+        /* Server certificate and key data */
+        char *keys[2];
+        char *certs[2];
+        unsigned keysize[2];
+        unsigned certsize[2];
+        int key_type_chosen;
+        psRsaKey_t rsa_priv_key;
+
+        /* For ECDHE: server's ephemeral EC private key */
+        uint8_t ecc_priv_key32[32];
+#endif
+};
+enum {
+        KEY_RSA,
+        KEY_ECDSA,
+};
 
 static unsigned get24be(const uint8_t *p)
 {
         return 0x100*(0x100*p[0] + p[1]) + p[2];
 }
 
+#if ENABLE_SSL_SERVER // || ENABLE_FEATURE_HTTPD_SSL
+static int is_minor_version_valid(tls_state_t *tls, uint8_t minor_ver)
+{
+        if (tls->expecting_first_packet == 1) {
+                /* First packet: accept TLS 1.0 (3.1) through TLS 1.3 (3.4)
+                 * for compatibility with clients using other record versions */
+                return (minor_ver > 0 && minor_ver <= 4);
+        }
+        /* Subsequent packets: must match negotiated version exactly */
+        return minor_ver == TLS_MIN;
+}
+#else
+#define is_minor_version_valid(tls, minor_ver) ((minor_ver) == TLS_MIN)
+#endif
+
 #if TLS_DEBUG
 /* Nondestructively see the current hash value */
 # if TLS_DEBUG_HASH
@@ -295,7 +463,7 @@ static void dump_hex(const char *fmt, const void *vp, int len)
         const uint8_t *p = vp;
 
         bin2hex(hexbuf, (void*)p, len)[0] = '\0';
-        dbg(fmt, hexbuf);
+        bb_error_msg(fmt, hexbuf);
 }
 
 static void dump_tls_record(const void *vp, int len)
@@ -305,20 +473,20 @@ static void dump_tls_record(const void *vp, int len)
         while (len > 0) {
                 unsigned xhdr_len;
                 if (len < RECHDR_LEN) {
-                        dump_hex("< |%s|\n", p, len);
+                        dump_hex("< |%s|", p, len);
                         return;
                 }
                 xhdr_len = 0x100*p[3] + p[4];
-                dbg("< hdr_type:%u ver:%u.%u len:%u", p[0], p[1], p[2], xhdr_len);
+                dbgcont("%s: < hdr_type:%u ver:%u.%u len:%u", applet_name, p[0], p[1], p[2], xhdr_len);
                 p += RECHDR_LEN;
                 len -= RECHDR_LEN;
                 if (len >= 4 && p[-RECHDR_LEN] == RECORD_TYPE_HANDSHAKE) {
                         unsigned len24 = get24be(p + 1);
-                        dbg(" type:%u len24:%u", p[0], len24);
+                        dbgcont(" type:%u len24:%u", p[0], len24);
                 }
                 if (xhdr_len > len)
                         xhdr_len = len;
-                dump_hex(" |%s|\n", p, xhdr_len);
+                dump_hex(" |%s|", p, xhdr_len);
                 p += xhdr_len;
                 len -= xhdr_len;
         }
@@ -348,12 +516,12 @@ static void hash_handshake(tls_state_t *tls, const char *fmt, const void *buffer
                 dbg(" (%u bytes) ", (int)len);
                 len = sha_peek(&tls->hsd->handshake_hash_ctx, h);
                 if (ENABLE_FEATURE_TLS_SHA1 && len == SHA1_OUTSIZE)
-                        dump_hex("sha1:%s\n", h, len);
+                        dump_hex("sha1:%s", h, len);
                 else
                 if (len == SHA256_OUTSIZE)
-                        dump_hex("sha256:%s\n", h, len);
+                        dump_hex("sha256:%s", h, len);
                 else
-                        dump_hex("sha???:%s\n", h, len);
+                        dump_hex("sha???:%s", h, len);
         }
 #endif
 }
@@ -550,11 +718,11 @@ static void xwrite_encrypted_and_hmac_signed(tls_state_t *tls, unsigned size, un
         xhdr->proto_min = TLS_MIN;
         /* fake unencrypted record len for MAC calculation */
         xhdr->len16_hi = size >> 8;
-        xhdr->len16_lo = size & 0xff;
+        xhdr->len16_lo = size; // & 0xff implicit
 
         /* Calculate MAC signature */
         hmac_blocks(tls, buf + size, /* result */
-                tls->client_write_MAC_key, TLS_MAC_SIZE(tls),
+                tls->our_write_MAC_key, TLS_MAC_SIZE(tls),
                 &tls->write_seq64_be, sizeof(tls->write_seq64_be),
                 xhdr, RECHDR_LEN,
                 buf, size,
@@ -602,10 +770,10 @@ static void xwrite_encrypted_and_hmac_signed(tls_state_t *tls, unsigned size, un
         ) {
                 /* No encryption, only signing */
                 xhdr->len16_hi = size >> 8;
-                xhdr->len16_lo = size & 0xff;
-                dump_raw_out(">> %s\n", xhdr, RECHDR_LEN + size);
+                xhdr->len16_lo = size; // & 0xff implicit
+                dump_raw_out(">> %s", xhdr, RECHDR_LEN + size);
                 xwrite(tls->ofd, xhdr, RECHDR_LEN + size);
-                dbg("wrote %u bytes (NULL crypt, SHA256 hash)\n", size);
+                dbg("wrote %u bytes (NULL crypt, SHA256 hash)", size);
                 return;
         }
 
@@ -646,7 +814,7 @@ static void xwrite_encrypted_and_hmac_signed(tls_state_t *tls, unsigned size, un
         // AES_256_CBC   Block      32      16     16
 
         tls_get_random(buf - AES_BLOCK_SIZE, AES_BLOCK_SIZE); /* IV */
-        dbg("before crypt: 5 hdr + %u data + %u hash bytes\n",
+        dbg("before crypt: 5 hdr + %u data + %u hash bytes",
                         size - TLS_MAC_SIZE(tls), TLS_MAC_SIZE(tls));
 
         /* Fill IV and padding in outbuf */
@@ -679,14 +847,14 @@ static void xwrite_encrypted_and_hmac_signed(tls_state_t *tls, unsigned size, un
         );
 
         /* Write out */
-        dbg("writing 5 + %u IV + %u encrypted bytes, padding_length:0x%02x\n",
+        dbg("writing 5 + %u IV + %u encrypted bytes, padding_length:0x%02x",
                         AES_BLOCK_SIZE, size, padding_length);
         size += AES_BLOCK_SIZE;     /* + IV */
         xhdr->len16_hi = size >> 8;
-        xhdr->len16_lo = size & 0xff;
-        dump_raw_out(">> %s\n", xhdr, RECHDR_LEN + size);
+        xhdr->len16_lo = size; // & 0xff implicit
+        dump_raw_out(">> %s", xhdr, RECHDR_LEN + size);
         xwrite(tls->ofd, xhdr, RECHDR_LEN + size);
-        dbg("wrote %u bytes\n", (int)RECHDR_LEN + size);
+        dbg("wrote %u bytes", (int)RECHDR_LEN + size);
 }
 
 /* Example how GCM encryption combines nonce, aad, input and generates
@@ -714,7 +882,7 @@ static void xwrite_encrypted_aesgcm(tls_state_t *tls, unsigned size, unsigned ty
         uint64_t t64;
 
         buf = tls->outbuf + OUTBUF_PFX; /* see above for the byte it points to */
-        dump_hex("xwrite_encrypted_aesgcm plaintext:%s\n", buf, size);
+        dump_hex("xwrite_encrypted_aesgcm plaintext:%s", buf, size);
 
         xhdr = (void*)(buf - 8 - RECHDR_LEN);
         xhdr->type = type; /* do it here so that "type" param no longer used */
@@ -726,7 +894,7 @@ static void xwrite_encrypted_aesgcm(tls_state_t *tls, unsigned size, unsigned ty
         /* set aad[12], and clear aad[13..15] */
         COUNTER(aad) = SWAP_LE32(size & 0xff);
 
-        memcpy(nonce, tls->client_write_IV, 4);
+        memcpy(nonce, tls->our_write_IV, 4);
         t64 = tls->write_seq64_be;
         move_to_unaligned64(nonce + 4, t64);
         move_to_unaligned64(aad,       t64);
@@ -767,11 +935,11 @@ static void xwrite_encrypted_aesgcm(tls_state_t *tls, unsigned size, unsigned ty
         xhdr->proto_maj = TLS_MAJ;
         xhdr->proto_min = TLS_MIN;
         xhdr->len16_hi = size >> 8;
-        xhdr->len16_lo = size & 0xff;
+        xhdr->len16_lo = size; // & 0xff implicit
         size += RECHDR_LEN;
-        dump_raw_out(">> %s\n", xhdr, size);
+        dump_raw_out(">> %s", xhdr, size);
         xwrite(tls->ofd, xhdr, size);
-        dbg("wrote %u bytes\n", size);
+        dbg("wrote %u bytes", size);
 #undef COUNTER
 }
 
@@ -793,24 +961,19 @@ static void xwrite_handshake_record(tls_state_t *tls, unsigned size)
         xhdr->proto_maj = TLS_MAJ;
         xhdr->proto_min = TLS_MIN;
         xhdr->len16_hi = size >> 8;
-        xhdr->len16_lo = size & 0xff;
-        dump_raw_out(">> %s\n", xhdr, RECHDR_LEN + size);
+        xhdr->len16_lo = size; // & 0xff implicit
+        dump_raw_out(">> %s", xhdr, RECHDR_LEN + size);
         xwrite(tls->ofd, xhdr, RECHDR_LEN + size);
-        dbg("wrote %u bytes\n", (int)RECHDR_LEN + size);
+        dbg("wrote %u bytes", (int)RECHDR_LEN + size);
 }
 
 static void xwrite_and_update_handshake_hash(tls_state_t *tls, unsigned size)
 {
-        if (!(tls->flags & ENCRYPT_ON_WRITE)) {
-                uint8_t *buf;
-
-                xwrite_handshake_record(tls, size);
-                /* Handshake hash does not include record headers */
-                buf = tls->outbuf + OUTBUF_PFX;
-                hash_handshake(tls, ">> hash:%s", buf, size);
-                return;
-        }
-        xwrite_encrypted(tls, size, RECORD_TYPE_HANDSHAKE);
+        uint8_t *buf;
+        xwrite_handshake_record(tls, size);
+        /* Handshake hash does not include record headers */
+        buf = tls->outbuf + OUTBUF_PFX;
+        hash_handshake(tls, ">> hash:%s", buf, size);
 }
 
 static int tls_has_buffered_record(tls_state_t *tls)
@@ -894,7 +1057,7 @@ static void tls_aesgcm_decrypt(tls_state_t *tls, uint8_t *buf, int size)
         ///* set aad[12], and clear aad[13..15] */
         //COUNTER(aad) = SWAP_LE32(size & 0xff);
 
-        memcpy(nonce,     tls->server_write_IV, 4);
+        memcpy(nonce,     tls->peer_write_IV, 4);
         memcpy(nonce + 4, buf, 8);
 
         cnt = 1;
@@ -928,12 +1091,12 @@ static int tls_xread_record(tls_state_t *tls, const char *expected)
         int target;
 
  again:
-        dbg("ofs_to_buffered:%u buffered_size:%u\n", tls->ofs_to_buffered, tls->buffered_size);
+        dbg("ofs_to_buffered:%u buffered_size:%u", tls->ofs_to_buffered, tls->buffered_size);
         total = tls->buffered_size;
         if (total != 0) {
                 memmove(tls->inbuf, tls->inbuf + tls->ofs_to_buffered, total);
                 //dbg("<< remaining at %d [%d] ", tls->ofs_to_buffered, total);
-                //dump_raw_in("<< %s\n", tls->inbuf, total);
+                //dump_raw_in("<< %s", tls->inbuf, total);
         }
         errno = 0;
         target = MAX_INBUF;
@@ -946,12 +1109,12 @@ static int tls_xread_record(tls_state_t *tls, const char *expected)
 
                         if (target > MAX_INBUF /* malformed input (too long) */
                          || xhdr->proto_maj != TLS_MAJ
-                         || xhdr->proto_min != TLS_MIN
+                         || !is_minor_version_valid(tls, xhdr->proto_min)
                         ) {
                                 sz = total < target ? total : target;
                                 bad_record_die(tls, expected, sz);
                         }
-                        dbg("xhdr type:%d ver:%d.%d len:%d\n",
+                        dbg("xhdr type:%d ver:%d.%d len:%d",
                                 xhdr->type, xhdr->proto_maj, xhdr->proto_min,
                                 0x100 * xhdr->len16_hi + xhdr->len16_lo
                         );
@@ -965,7 +1128,7 @@ static int tls_xread_record(tls_state_t *tls, const char *expected)
                         tls->inbuf_size += MAX_INBUF / 8;
                         if (tls->inbuf_size > MAX_INBUF)
                                 tls->inbuf_size = MAX_INBUF;
-                        dbg("inbuf_size:%d\n", tls->inbuf_size);
+                        dbg("inbuf_size:%d", tls->inbuf_size);
                         rem = tls->inbuf_size - total;
                         tls->inbuf = xrealloc(tls->inbuf, tls->inbuf_size);
                 }
@@ -973,7 +1136,7 @@ static int tls_xread_record(tls_state_t *tls, const char *expected)
                 if (sz <= 0) {
                         if (sz == 0 && total == 0) {
                                 /* "Abrupt" EOF, no TLS shutdown (seen from kernel.org) */
-                                dbg("EOF (without TLS shutdown) from peer\n");
+                                dbg("EOF (without TLS shutdown) from peer");
                                 tls->buffered_size = 0;
                                 goto end;
                         }
@@ -982,13 +1145,13 @@ static int tls_xread_record(tls_state_t *tls, const char *expected)
                                 bb_perror_msg_and_die("%s header: got %d bytes", "truncated TLS record", total);
                         bb_perror_msg_and_die("%s: expected %d, got %d bytes", "truncated TLS record", target, total);
                 }
-                dump_raw_in("<< %s\n", tls->inbuf + total, sz);
+                dump_raw_in("<< %s", tls->inbuf + total, sz);
                 total += sz;
         }
         tls->buffered_size = total - target;
         tls->ofs_to_buffered = target;
         //dbg("<< stashing at %d [%d] ", tls->ofs_to_buffered, tls->buffered_size);
-        //dump_hex("<< %s\n", tls->inbuf + tls->ofs_to_buffered, tls->buffered_size);
+        //dump_hex("<< %s", tls->inbuf + tls->ofs_to_buffered, tls->buffered_size);
 
         sz = target - RECHDR_LEN;
 
@@ -1003,7 +1166,7 @@ static int tls_xread_record(tls_state_t *tls, const char *expected)
 
                         sz -= 8 + AES_BLOCK_SIZE; /* we will overwrite nonce, drop hash */
                         tls_aesgcm_decrypt(tls, p, sz);
-                        dbg("encrypted size:%u\n", sz);
+                        dbg("encrypted size:%u", sz);
                 } else
                 if (tls->min_encrypted_len_on_read > TLS_MAC_SIZE(tls)) {
                         /* AES+SHA */
@@ -1022,7 +1185,7 @@ static int tls_xread_record(tls_state_t *tls, const char *expected)
                                 p /* plaintext */
                         );
                         padding_len = p[sz - 1];
-                        dbg("encrypted size:%u type:0x%02x padding_length:0x%02x\n", sz, p[0], padding_len);
+                        dbg("encrypted size:%u type:0x%02x padding_length:0x%02x", sz, p[0], padding_len);
                         padding_len++;
                         sz -= TLS_MAC_SIZE(tls) + padding_len; /* drop MAC and padding */
                 } else {
@@ -1034,12 +1197,12 @@ static int tls_xread_record(tls_state_t *tls, const char *expected)
         if (sz < 0)
                 bb_simple_error_msg_and_die("encrypted data too short");
 
-        //dump_hex("<< %s\n", tls->inbuf, RECHDR_LEN + sz);
+        //dump_hex("<< %s", tls->inbuf, RECHDR_LEN + sz);
 
         xhdr = (void*)tls->inbuf;
         if (xhdr->type == RECORD_TYPE_ALERT && sz >= 2) {
                 uint8_t *p = tls->inbuf + RECHDR_LEN;
-                dbg("ALERT size:%d level:%d description:%d\n", sz, p[0], p[1]);
+                dbg("ALERT size:%d level:%d description:%d", sz, p[0], p[1]);
                 if (p[0] == 2) { /* fatal */
                         bb_error_msg_and_die("TLS %s from peer (alert code %d): %s",
                                 "error",
@@ -1048,7 +1211,7 @@ static int tls_xread_record(tls_state_t *tls, const char *expected)
                 }
                 if (p[0] == 1) { /* warning */
                         if (p[1] == 0) { /* "close_notify" warning: it's EOF */
-                                dbg("EOF (TLS encoded) from peer\n");
+                                dbg("EOF (TLS encoded) from peer");
                                 sz = 0;
                                 goto end;
                         }
@@ -1076,7 +1239,7 @@ static int tls_xread_record(tls_state_t *tls, const char *expected)
                 hash_handshake(tls, "<< hash:%s", tls->inbuf + RECHDR_LEN, sz);
         }
  end:
-        dbg("got block len:%u\n", sz);
+        dbg("got block len:%u", sz);
         return sz;
 }
 
@@ -1136,7 +1299,7 @@ static uint8_t *enter_der_item(uint8_t *der, uint8_t **endp)
 {
         uint8_t *new_der;
         unsigned len = get_der_len(&new_der, der, *endp);
-        dbg_der("entered der @%p:0x%02x len:%u inner_byte @%p:0x%02x\n", der, der[0], len, new_der, new_der[0]);
+        dbg_der("entered der @%p:0x%02x len:%u inner_byte @%p:0x%02x", der, der[0], len, new_der, new_der[0]);
         /* Move "end" position to cover only this item */
         *endp = new_der + len;
         return new_der;
@@ -1148,7 +1311,7 @@ static uint8_t *skip_der_item(uint8_t *der, uint8_t *end)
         unsigned len = get_der_len(&new_der, der, end);
         /* Skip body */
         new_der += len;
-        dbg_der("skipped der 0x%02x, next byte 0x%02x\n", der[0], new_der[0]);
+        dbg_der("skipped der 0x%02x, next byte 0x%02x", der[0], new_der[0]);
         return new_der;
 }
 
@@ -1157,7 +1320,7 @@ static void der_binary_to_pstm(pstm_int *pstm_n, uint8_t *der, uint8_t *end)
         uint8_t *bin_ptr;
         unsigned len = get_der_len(&bin_ptr, der, end);
 
-        dbg_der("binary bytes:%u, first:0x%02x\n", len, bin_ptr[0]);
+        dbg_der("binary bytes:%u, first:0x%02x", len, bin_ptr[0]);
         binary_to_pstm(pstm_n, bin_ptr, len);
 }
 
@@ -1304,11 +1467,11 @@ static void find_key_in_der_cert(tls_state_t *tls, uint8_t *der, int len)
                         //42.134.72.206.61.3.1.7 is curve_secp256r1
                 };
                 if (memcmp(der, OID_RSA_KEY_ALG, sizeof(OID_RSA_KEY_ALG)) == 0) {
-                        dbg("RSA key\n");
+                        dbg("RSA key");
                         tls->flags |= GOT_CERT_RSA_KEY_ALG;
                 } else
                 if (memcmp(der, OID_ECDSA_KEY_ALG, sizeof(OID_ECDSA_KEY_ALG)) == 0) {
-                        dbg("ECDSA key\n");
+                        dbg("ECDSA key");
                         //UNUSED: tls->flags |= GOT_CERT_ECDSA_KEY_ALG;
                 } else
                         bb_simple_error_msg_and_die("not RSA or ECDSA cert");
@@ -1323,7 +1486,7 @@ static void find_key_in_der_cert(tls_state_t *tls, uint8_t *der, int len)
                 //die_if_not_this_der_type(der, end, 0x03); /* must be BITSTRING */
                 der = enter_der_item(der, &end);
 
-                dbg("key bytes:%u, first:0x%02x\n", (int)(end - der), der[0]);
+                dbg("key bytes:%u, first:0x%02x", (int)(end - der), der[0]);
                 if (end - der < 14)
                         xfunc_die();
                 /* example format:
@@ -1341,7 +1504,7 @@ static void find_key_in_der_cert(tls_state_t *tls, uint8_t *der, int len)
                 der = skip_der_item(der, end);
                 der_binary_to_pstm(&tls->hsd->server_rsa_pub_key.e, der, end); /* exponent */
                 tls->hsd->server_rsa_pub_key.size = pstm_unsigned_bin_size(&tls->hsd->server_rsa_pub_key.N);
-                dbg("server_rsa_pub_key.size:%d\n", tls->hsd->server_rsa_pub_key.size);
+                dbg("server_rsa_pub_key.size:%d", tls->hsd->server_rsa_pub_key.size);
         }
         /* else: ECDSA key. It is not used for generating encryption keys,
          * it is used only to sign the EC public key (which comes in ServerKey message).
@@ -1364,7 +1527,7 @@ static int tls_xread_handshake_block(tls_state_t *tls, int min_len)
         ) {
                 bad_record_die(tls, "handshake record", len);
         }
-        dbg("got HANDSHAKE\n");
+        dbg("got HANDSHAKE");
         return len;
 }
 
@@ -1379,78 +1542,18 @@ static ALWAYS_INLINE void fill_handshake_record_hdr(void *buf, unsigned type, un
         h->type = type;
         h->len24_hi  = len >> 16;
         h->len24_mid = len >> 8;
-        h->len24_lo  = len & 0xff;
+        h->len24_lo  = len; // & 0xff implicit
+}
+
+static void *get_outbuf_fill_handshake_record(tls_state_t *tls, unsigned type, unsigned len)
+{
+        void *record = tls_get_zeroed_outbuf(tls, len);
+        fill_handshake_record_hdr(record, type, len);
+        return record;
 }
 
 static void send_client_hello_and_alloc_hsd(tls_state_t *tls, const char *sni)
 {
-#define NUM_CIPHERS (0 \
-        + 4 * ENABLE_FEATURE_TLS_SHA1 \
-        + ALLOW_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 \
-        + ALLOW_ECDHE_RSA_WITH_AES_128_CBC_SHA256 \
-        + ALLOW_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 \
-        + ALLOW_ECDHE_RSA_WITH_AES_128_GCM_SHA256 \
-        + 2 * ENABLE_FEATURE_TLS_SHA1 \
-        + ALLOW_RSA_WITH_AES_128_CBC_SHA256 \
-        + ALLOW_RSA_WITH_AES_256_CBC_SHA256 \
-        + ALLOW_RSA_WITH_AES_128_GCM_SHA256 \
-        + ALLOW_RSA_NULL_SHA256 \
-        )
-        static const uint8_t ciphers[] = {
-                0x00,2 * (1 + NUM_CIPHERS), //len16_be
-                0x00,0xFF, //not a cipher - TLS_EMPTY_RENEGOTIATION_INFO_SCSV
-                /* ^^^^^^ RFC 5746 Renegotiation Indication Extension - some servers will refuse to work with us otherwise */
-#if ENABLE_FEATURE_TLS_SHA1
-                0xC0,0x09, // 1 TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA - ok: wget https://is.gd/
-                0xC0,0x0A, // 2 TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA - ok: wget https://is.gd/
-                0xC0,0x13, // 3 TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA - ok: openssl s_server ... -cipher ECDHE-RSA-AES128-SHA
-                0xC0,0x14, // 4 TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA - ok: openssl s_server ... -cipher ECDHE-RSA-AES256-SHA (might fail with older openssl)
-        //      0xC0,0x18, //   TLS_ECDH_anon_WITH_AES_128_CBC_SHA
-        //      0xC0,0x19, //   TLS_ECDH_anon_WITH_AES_256_CBC_SHA
-#endif
-#if ALLOW_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256
-                0xC0,0x23, // 5 TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 - ok: wget https://is.gd/
-#endif
-        //      0xC0,0x24, //   TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 - can't do SHA384 yet
-#if ALLOW_ECDHE_RSA_WITH_AES_128_CBC_SHA256
-                0xC0,0x27, // 6 TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 - ok: openssl s_server ... -cipher ECDHE-RSA-AES128-SHA256
-#endif
-        //      0xC0,0x28, //   TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 - can't do SHA384 yet
-#if ALLOW_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
-                0xC0,0x2B, // 7 TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 - ok: wget https://is.gd/
-#endif
-        //      0xC0,0x2C, //   TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 - wget https://is.gd/: "TLS error from peer (alert code 20): bad MAC"
-//TODO: GCM_SHA384 ciphers can be supported, only need sha384-based PRF?
-#if ALLOW_ECDHE_RSA_WITH_AES_128_GCM_SHA256
-                0xC0,0x2F, // 8 TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 - ok: openssl s_server ... -cipher ECDHE-RSA-AES128-GCM-SHA256
-#endif
-        //      0xC0,0x30, //   TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 - openssl s_server ... -cipher ECDHE-RSA-AES256-GCM-SHA384: "decryption failed or bad record mac"
-        //possibly these too:
-#if ENABLE_FEATURE_TLS_SHA1
-        //      0xC0,0x35, //   TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA
-        //      0xC0,0x36, //   TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA
-#endif
-        //      0xC0,0x37, //   TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256
-        //      0xC0,0x38, //   TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384 - can't do SHA384 yet
-#if ENABLE_FEATURE_TLS_SHA1
-                0x00,0x2F, // 9 TLS_RSA_WITH_AES_128_CBC_SHA - ok: openssl s_server ... -cipher AES128-SHA
-                0x00,0x35, //10 TLS_RSA_WITH_AES_256_CBC_SHA - ok: openssl s_server ... -cipher AES256-SHA
-#endif
-#if ALLOW_RSA_WITH_AES_128_CBC_SHA256
-                0x00,0x3C, //11 TLS_RSA_WITH_AES_128_CBC_SHA256 - ok: openssl s_server ... -cipher AES128-SHA256
-#endif
-#if ALLOW_RSA_WITH_AES_256_CBC_SHA256
-                0x00,0x3D, //12 TLS_RSA_WITH_AES_256_CBC_SHA256 - ok: openssl s_server ... -cipher AES256-SHA256
-#endif
-#if ALLOW_RSA_WITH_AES_128_GCM_SHA256
-                0x00,0x9C, //13 TLS_RSA_WITH_AES_128_GCM_SHA256 - ok: openssl s_server ... -cipher AES128-GCM-SHA256
-#endif
-        //      0x00,0x9D, //   TLS_RSA_WITH_AES_256_GCM_SHA384 - openssl s_server ... -cipher AES256-GCM-SHA384: "decryption failed or bad record mac"
-#if ALLOW_RSA_NULL_SHA256
-                0x00,0x3B, //   TLS_RSA_WITH_NULL_SHA256
-#endif
-                0x01,0x00, //not a cipher - comprtypes_len, comprtype
-        };
         struct client_hello {
                 uint8_t type;
                 uint8_t len24_hi, len24_mid, len24_lo;
@@ -1528,9 +1631,8 @@ static void send_client_hello_and_alloc_hsd(tls_state_t *tls, const char *sni)
 
         /* +2 is for "len of all extensions" 2-byte field */
         len = sizeof(*record) + 2 + ext_len;
-        record = tls_get_zeroed_outbuf(tls, len);
+        record = get_outbuf_fill_handshake_record(tls, HANDSHAKE_CLIENT_HELLO, len);
 
-        fill_handshake_record_hdr(record, HANDSHAKE_CLIENT_HELLO, len);
         record->proto_maj = TLS_MAJ;    /* the "requested" version of the protocol, */
         record->proto_min = TLS_MIN;    /* can be higher than one in record headers */
         tls_get_random(record->rand32, sizeof(record->rand32));
@@ -1538,8 +1640,8 @@ static void send_client_hello_and_alloc_hsd(tls_state_t *tls, const char *sni)
                 memset(record->rand32, 0x11, sizeof(record->rand32));
         /* record->session_id_len = 0; - already is */
 
-        BUILD_BUG_ON(sizeof(ciphers) != 2 * (1 + 1 + NUM_CIPHERS + 1));
-        memcpy(&record->cipherid_len16_hi, ciphers, sizeof(ciphers));
+        BUILD_BUG_ON(sizeof(client_hello_ciphers) != 2 * (1 + 1 + NUM_CIPHERS + 1));
+        memcpy(&record->cipherid_len16_hi, client_hello_ciphers, sizeof(client_hello_ciphers));
 
         ptr = (void*)(record + 1);
         *ptr++ = ext_len >> 8;
@@ -1565,7 +1667,7 @@ static void send_client_hello_and_alloc_hsd(tls_state_t *tls, const char *sni)
         tls->hsd->saved_client_hello_size = len;
         memcpy(tls->hsd->saved_client_hello, record, len);
  */
-        dbg(">> CLIENT_HELLO\n");
+        dbg(">> CLIENT_HELLO");
         /* Can hash immediately only if we know which MAC hash to use.
          * So far we do know: it's sha256:
          */
@@ -1594,7 +1696,6 @@ static void get_server_hello(tls_state_t *tls)
 
         struct server_hello *hp;
         uint8_t *cipherid;
-        uint8_t cipherid1;
         int len, len24;
 
         len = tls_xread_handshake_block(tls, 74 - 32);
@@ -1629,80 +1730,13 @@ static void get_server_hello(tls_state_t *tls)
 
         if (len24 < 70)
                 bad_record_die(tls, "'server hello'", len);
-        dbg("<< SERVER_HELLO\n");
+        dbg("<< SERVER_HELLO");
 
         memcpy(tls->hsd->client_and_server_rand32 + 32, hp->rand32, sizeof(hp->rand32));
 
-        /* Set up encryption params based on selected cipher */
-#if 0
-                0xC0,0x09, // 1 TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA - ok: wget https://is.gd/
-                0xC0,0x0A, // 2 TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA - ok: wget https://is.gd/
-                0xC0,0x13, // 3 TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA - ok: openssl s_server ... -cipher ECDHE-RSA-AES128-SHA
-                0xC0,0x14, // 4 TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA - ok: openssl s_server ... -cipher ECDHE-RSA-AES256-SHA (might fail with older openssl)
-        //      0xC0,0x18, //   TLS_ECDH_anon_WITH_AES_128_CBC_SHA
-        //      0xC0,0x19, //   TLS_ECDH_anon_WITH_AES_256_CBC_SHA
-                0xC0,0x23, // 5 TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 - ok: wget https://is.gd/
-        //      0xC0,0x24, //   TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 - can't do SHA384 yet
-                0xC0,0x27, // 6 TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 - ok: openssl s_server ... -cipher ECDHE-RSA-AES128-SHA256
-        //      0xC0,0x28, //   TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 - can't do SHA384 yet
-                0xC0,0x2B, // 7 TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 - ok: wget https://is.gd/
-        //      0xC0,0x2C, //   TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 - wget https://is.gd/: "TLS error from peer (alert code 20): bad MAC"
-                0xC0,0x2F, // 8 TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 - ok: openssl s_server ... -cipher ECDHE-RSA-AES128-GCM-SHA256
-        //      0xC0,0x30, //   TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 - openssl s_server ... -cipher ECDHE-RSA-AES256-GCM-SHA384: "decryption failed or bad record mac"
-        //possibly these too:
-        //      0xC0,0x35, //   TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA
-        //      0xC0,0x36, //   TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA
-        //      0xC0,0x37, //   TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256
-        //      0xC0,0x38, //   TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384 - can't do SHA384 yet
-                0x00,0x2F, // 9 TLS_RSA_WITH_AES_128_CBC_SHA - ok: openssl s_server ... -cipher AES128-SHA
-                0x00,0x35, //10 TLS_RSA_WITH_AES_256_CBC_SHA - ok: openssl s_server ... -cipher AES256-SHA
-                0x00,0x3C, //11 TLS_RSA_WITH_AES_128_CBC_SHA256 - ok: openssl s_server ... -cipher AES128-SHA256
-                0x00,0x3D, //12 TLS_RSA_WITH_AES_256_CBC_SHA256 - ok: openssl s_server ... -cipher AES256-SHA256
-                0x00,0x9C, //13 TLS_RSA_WITH_AES_128_GCM_SHA256 - ok: openssl s_server ... -cipher AES128-GCM-SHA256
-        //      0x00,0x9D, //   TLS_RSA_WITH_AES_256_GCM_SHA384 - openssl s_server ... -cipher AES256-GCM-SHA384: "decryption failed or bad record mac"
-                0x00,0x3B, //   TLS_RSA_WITH_NULL_SHA256
-#endif
-        cipherid1 = cipherid[1];
-        tls->cipher_id = 0x100 * cipherid[0] + cipherid1;
-        tls->key_size = AES256_KEYSIZE;
-        tls->MAC_size = SHA256_OUTSIZE;
-        /*tls->IV_size = 0; - already is */
-        if (cipherid[0] == 0xC0) {
-                /* All C0xx are ECDHE */
-                tls->flags |= NEED_EC_KEY;
-                if (cipherid1 & 1) {
-                        /* Odd numbered C0xx use AES128 (even ones use AES256) */
-                        tls->key_size = AES128_KEYSIZE;
-                }
-                if (ENABLE_FEATURE_TLS_SHA1 && cipherid1 <= 0x19) {
-                        tls->MAC_size = SHA1_OUTSIZE;
-                } else
-                if (cipherid1 >= 0x2B && cipherid1 <= 0x30) {
-                        /* C02B,2C,2F,30 are AES-GCM */
-                        tls->flags |= ENCRYPTION_AESGCM;
-                        tls->MAC_size = 0;
-                        tls->IV_size = 4;
-                }
-        } else {
-                /* All 00xx are RSA */
-                if ((ENABLE_FEATURE_TLS_SHA1 && cipherid1 == 0x2F)
-                 || cipherid1 == 0x3C
-                 || cipherid1 == 0x9C
-                ) {
-                        tls->key_size = AES128_KEYSIZE;
-                }
-                if (ENABLE_FEATURE_TLS_SHA1 && cipherid1 <= 0x35) {
-                        tls->MAC_size = SHA1_OUTSIZE;
-                } else
-                if (cipherid1 == 0x9C /*|| cipherid1 == 0x9D*/) {
-                        /* 009C,9D are AES-GCM */
-                        tls->flags |= ENCRYPTION_AESGCM;
-                        tls->MAC_size = 0;
-                        tls->IV_size = 4;
-                }
-        }
-        dbg("server chose cipher %04x\n", tls->cipher_id);
-        dbg("key_size:%u MAC_size:%u IV_size:%u\n", tls->key_size, tls->MAC_size, tls->IV_size);
+        set_cipher_parameters(tls, cipherid);
+        dbg("server chose cipher %04x", tls->cipher_id);
+        dbg("key_size:%u MAC_size:%u IV_size:%u", tls->key_size, tls->MAC_size, tls->IV_size);
 
         /* Handshake hash eventually destined to FINISHED record
          * is sha256 regardless of cipher
@@ -1732,7 +1766,7 @@ static void get_server_cert(tls_state_t *tls)
         certbuf = (void*)(xhdr + 1);
         if (certbuf[0] != HANDSHAKE_CERTIFICATE)
                 bad_record_die(tls, "certificate", len);
-        dbg("<< CERTIFICATE\n");
+        dbg("<< CERTIFICATE");
         // 4392 bytes:
         // 0b  00|11|24 00|11|21 00|05|b0 30|82|05|ac|30|82|04|94|a0|03|02|01|02|02|11|00|9f|85|bf|66|4b|0c|dd|af|ca|50|86|79|50|1b|2b|e4|30|0d...
         //Cert len=4388 ChainLen CertLen^ DER encoded X509 starts here. openssl x509 -in FILE -inform DER -noout -text
@@ -1813,12 +1847,12 @@ static void process_server_key(tls_state_t *tls, int len)
         keybuf += 4;
         switch (t32) {
         case _0x03001d20: //curve_x25519
-                dbg("got x25519 eccPubKey\n");
-                tls->flags |= GOT_EC_CURVE_X25519;
+                dbg("got x25519 eccPubKey");
+                tls->flags |= USE_EC_CURVE_X25519;
                 memcpy(tls->hsd->ecc_pub_key32, keybuf, 32);
                 break;
         case _0x03001741: //curve_secp256r1 (aka P256)
-                dbg("got P256 eccPubKey\n");
+                dbg("got P256 eccPubKey");
                 /* P256 point can be transmitted odd- or even-compressed
                  * (first byte is 3 or 2) or uncompressed (4).
                  */
@@ -1842,19 +1876,89 @@ static void send_empty_client_cert(tls_state_t *tls)
         };
         struct client_empty_cert *record;
 
-        record = tls_get_zeroed_outbuf(tls, sizeof(*record));
-        //fill_handshake_record_hdr(record, HANDSHAKE_CERTIFICATE, sizeof(*record));
-        //record->cert_chain_len24_hi = 0;
-        //record->cert_chain_len24_mid = 0;
-        //record->cert_chain_len24_lo = 0;
-        // same as above:
-        record->type = HANDSHAKE_CERTIFICATE;
-        record->len24_lo = 3;
-
-        dbg(">> CERTIFICATE\n");
+        record = get_outbuf_fill_handshake_record(tls, HANDSHAKE_CERTIFICATE, sizeof(*record));
+        dbg(">> CERTIFICATE");
         xwrite_and_update_handshake_hash(tls, sizeof(*record));
 }
 
+static void derive_master_secret_and_keys(tls_state_t *tls, uint8_t *premaster, int premaster_size)
+{
+        uint8_t tmp64[64];
+        // RFC 5246
+        // For all key exchange methods, the same algorithm is used to convert
+        // the pre_master_secret into the master_secret.  The pre_master_secret
+        // should be deleted from memory once the master_secret has been
+        // computed.
+        //      master_secret = PRF(pre_master_secret, "master secret",
+        //                          ClientHello.random + ServerHello.random)
+        //                          [0..47];
+        // The master secret is always exactly 48 bytes in length.  The length
+        // of the premaster secret will vary depending on key exchange method.
+        prf_hmac_sha256(/*tls,*/
+                tls->hsd->master_secret, sizeof(tls->hsd->master_secret),
+                premaster, premaster_size,
+                "master secret",
+                tls->hsd->client_and_server_rand32, sizeof(tls->hsd->client_and_server_rand32)
+        );
+        dump_hex("master secret:%s", tls->hsd->master_secret, sizeof(tls->hsd->master_secret));
+
+        // RFC 5246
+        // 6.3.  Key Calculation
+        //
+        // The Record Protocol requires an algorithm to generate keys required
+        // by the current connection state (see Appendix A.6) from the security
+        // parameters provided by the handshake protocol.
+        //
+        // The master secret is expanded into a sequence of secure bytes, which
+        // is then split to a client write MAC key, a server write MAC key, a
+        // client write encryption key, and a server write encryption key.  Each
+        // of these is generated from the byte sequence in that order.  Unused
+        // values are empty.  Some AEAD ciphers may additionally require a
+        // client write IV and a server write IV (see Section 6.2.3.3).
+        //
+        // When keys and MAC keys are generated, the master secret is used as an
+        // entropy source.
+        //
+        // To generate the key material, compute
+        //
+        //    key_block = PRF(SecurityParameters.master_secret,
+        //                    "key expansion",
+        //                    SecurityParameters.server_random +
+        //                    SecurityParameters.client_random);
+        //
+        // until enough output has been generated.  Then, the key_block is
+        // partitioned as follows:
+        //
+        //    client_write_MAC_key[SecurityParameters.mac_key_length]
+        //    server_write_MAC_key[SecurityParameters.mac_key_length]
+        //    client_write_key[SecurityParameters.enc_key_length]
+        //    server_write_key[SecurityParameters.enc_key_length]
+        //    client_write_IV[SecurityParameters.fixed_iv_length]
+        //    server_write_IV[SecurityParameters.fixed_iv_length]
+
+        /* make "server_rand32 + client_rand32" */
+        memcpy(&tmp64[0] , &tls->hsd->client_and_server_rand32[32], 32);
+        memcpy(&tmp64[32], &tls->hsd->client_and_server_rand32[0] , 32);
+
+        prf_hmac_sha256(/*tls,*/
+                tls->key_block, 2 * (tls->MAC_size + tls->key_size + tls->IV_size),
+                tls->hsd->master_secret, sizeof(tls->hsd->master_secret),
+                "key expansion",
+                tmp64, 64
+        );
+}
+
+static void initialize_aes_keys(tls_state_t *tls)
+{
+        uint8_t iv[AES_BLOCK_SIZE];
+        aes_setkey(&tls->aes_decrypt, tls->peer_write_key, tls->key_size);
+        aes_setkey(&tls->aes_encrypt, tls->our_write_key, tls->key_size);
+        if (1) { //if AESGCM
+                memset(iv, 0, AES_BLOCK_SIZE);
+                aes_encrypt_one_block(&tls->aes_encrypt, iv, tls->H);
+        }
+}
+
 static void send_client_key_exchange(tls_state_t *tls)
 {
         struct client_key_exchange {
@@ -1863,11 +1967,13 @@ static void send_client_key_exchange(tls_state_t *tls)
                 uint8_t key[2 + 4 * 1024]; // size??
         };
 //FIXME: better size estimate
-        struct client_key_exchange *record = tls_get_zeroed_outbuf(tls, sizeof(*record));
+        struct client_key_exchange *record;
         uint8_t premaster[RSA_PREMASTER_SIZE > EC_CURVE_KEYSIZE ? RSA_PREMASTER_SIZE : EC_CURVE_KEYSIZE];
         int premaster_size;
         int len;
 
+        record = tls_get_zeroed_outbuf(tls, sizeof(*record));
+
         if (!(tls->flags & NEED_EC_KEY)) {
                 /* RSA */
                 if (!(tls->flags & GOT_CERT_RSA_KEY_ALG))
@@ -1882,7 +1988,7 @@ static void send_client_key_exchange(tls_state_t *tls)
                 // version negotiated for the connection."
                 premaster[0] = TLS_MAJ;
                 premaster[1] = TLS_MIN;
-                dump_hex("premaster:%s\n", premaster, sizeof(premaster));
+                dump_hex("premaster:%s", premaster, sizeof(premaster));
                 len = psRsaEncryptPub(/*pool:*/ NULL,
                         /* psRsaKey_t* */ &tls->hsd->server_rsa_pub_key,
                         premaster, /*inlen:*/ RSA_PREMASTER_SIZE,
@@ -1891,7 +1997,7 @@ static void send_client_key_exchange(tls_state_t *tls)
                 );
                 /* keylen16 exists for RSA (in TLS, not in SSL), but not for some other key types */
                 record->key[0] = len >> 8;
-                record->key[1] = len & 0xff;
+                record->key[1] = len; // & 0xff implicit
                 len += 2;
                 premaster_size = RSA_PREMASTER_SIZE;
         } else {
@@ -1899,9 +2005,9 @@ static void send_client_key_exchange(tls_state_t *tls)
                 if (!(tls->flags & GOT_EC_KEY))
                         bb_simple_error_msg_and_die("server did not provide EC key");
 
-                if (tls->flags & GOT_EC_CURVE_X25519) {
+                if (tls->flags & USE_EC_CURVE_X25519) {
                         /* ECDHE, curve x25519 */
-                        dbg("computing x25519_premaster\n");
+                        dbg("computing x25519_premaster");
                         curve_x25519_compute_pubkey_and_premaster(
                                         record->key + 1, premaster,
                                         /*point:*/ tls->hsd->ecc_pub_key32
@@ -1912,7 +2018,7 @@ static void send_client_key_exchange(tls_state_t *tls)
                         //premaster_size = CURVE25519_KEYSIZE;
                 } else {
                         /* ECDHE, curve P256 */
-                        dbg("computing P256_premaster\n");
+                        dbg("computing P256_premaster");
                         curve_P256_compute_pubkey_and_premaster(
                                         record->key + 2, premaster,
                                         /*point:*/ tls->hsd->ecc_pub_key32
@@ -1928,104 +2034,28 @@ static void send_client_key_exchange(tls_state_t *tls)
         record->type = HANDSHAKE_CLIENT_KEY_EXCHANGE;
         /* record->len24_hi = 0; - already is */
         record->len24_mid = len >> 8;
-        record->len24_lo  = len & 0xff;
+        record->len24_lo  = len;
         len += 4;
 
-        dbg(">> CLIENT_KEY_EXCHANGE\n");
+        dbg(">> CLIENT_KEY_EXCHANGE");
         xwrite_and_update_handshake_hash(tls, len);
 
-        // RFC 5246
-        // For all key exchange methods, the same algorithm is used to convert
-        // the pre_master_secret into the master_secret.  The pre_master_secret
-        // should be deleted from memory once the master_secret has been
-        // computed.
-        //      master_secret = PRF(pre_master_secret, "master secret",
-        //                          ClientHello.random + ServerHello.random)
-        //                          [0..47];
-        // The master secret is always exactly 48 bytes in length.  The length
-        // of the premaster secret will vary depending on key exchange method.
-        prf_hmac_sha256(/*tls,*/
-                tls->hsd->master_secret, sizeof(tls->hsd->master_secret),
-                premaster, premaster_size,
-                "master secret",
-                tls->hsd->client_and_server_rand32, sizeof(tls->hsd->client_and_server_rand32)
-        );
-        dump_hex("master secret:%s\n", tls->hsd->master_secret, sizeof(tls->hsd->master_secret));
-
-        // RFC 5246
-        // 6.3.  Key Calculation
-        //
-        // The Record Protocol requires an algorithm to generate keys required
-        // by the current connection state (see Appendix A.6) from the security
-        // parameters provided by the handshake protocol.
-        //
-        // The master secret is expanded into a sequence of secure bytes, which
-        // is then split to a client write MAC key, a server write MAC key, a
-        // client write encryption key, and a server write encryption key.  Each
-        // of these is generated from the byte sequence in that order.  Unused
-        // values are empty.  Some AEAD ciphers may additionally require a
-        // client write IV and a server write IV (see Section 6.2.3.3).
-        //
-        // When keys and MAC keys are generated, the master secret is used as an
-        // entropy source.
-        //
-        // To generate the key material, compute
-        //
-        //    key_block = PRF(SecurityParameters.master_secret,
-        //                    "key expansion",
-        //                    SecurityParameters.server_random +
-        //                    SecurityParameters.client_random);
-        //
-        // until enough output has been generated.  Then, the key_block is
-        // partitioned as follows:
-        //
-        //    client_write_MAC_key[SecurityParameters.mac_key_length]
-        //    server_write_MAC_key[SecurityParameters.mac_key_length]
-        //    client_write_key[SecurityParameters.enc_key_length]
-        //    server_write_key[SecurityParameters.enc_key_length]
-        //    client_write_IV[SecurityParameters.fixed_iv_length]
-        //    server_write_IV[SecurityParameters.fixed_iv_length]
-        {
-                uint8_t tmp64[64];
-
-                /* make "server_rand32 + client_rand32" */
-                memcpy(&tmp64[0] , &tls->hsd->client_and_server_rand32[32], 32);
-                memcpy(&tmp64[32], &tls->hsd->client_and_server_rand32[0] , 32);
-
-                prf_hmac_sha256(/*tls,*/
-                        tls->client_write_MAC_key, 2 * (tls->MAC_size + tls->key_size + tls->IV_size),
-                        // also fills:
-                        // server_write_MAC_key[]
-                        // client_write_key[]
-                        // server_write_key[]
-                        // client_write_IV[]
-                        // server_write_IV[]
-                        tls->hsd->master_secret, sizeof(tls->hsd->master_secret),
-                        "key expansion",
-                        tmp64, 64
-                );
-                tls->client_write_key = tls->client_write_MAC_key + (2 * tls->MAC_size);
-                tls->server_write_key = tls->client_write_key + tls->key_size;
-                tls->client_write_IV = tls->server_write_key + tls->key_size;
-                tls->server_write_IV = tls->client_write_IV + tls->IV_size;
-                dump_hex("client_write_MAC_key:%s\n",
-                        tls->client_write_MAC_key, tls->MAC_size
-                );
-                dump_hex("client_write_key:%s\n",
-                        tls->client_write_key, tls->key_size
-                );
-                dump_hex("client_write_IV:%s\n",
-                        tls->client_write_IV, tls->IV_size
-                );
-
-                aes_setkey(&tls->aes_decrypt, tls->server_write_key, tls->key_size);
-                aes_setkey(&tls->aes_encrypt, tls->client_write_key, tls->key_size);
-                {
-                        uint8_t iv[AES_BLOCK_SIZE];
-                        memset(iv, 0, AES_BLOCK_SIZE);
-                        aes_encrypt_one_block(&tls->aes_encrypt, iv, tls->H);
-                }
-        }
+        derive_master_secret_and_keys(tls, premaster, premaster_size);
+        // The key_block is partitioned as follows:
+        tls->our_write_MAC_key  = tls->key_block;                          // client_write_MAC_key[]
+        tls->peer_write_MAC_key = tls->key_block          + tls->MAC_size; // server_write_MAC_key[]
+        tls->our_write_key      = tls->peer_write_MAC_key + tls->MAC_size; // client_write_key[]
+        tls->peer_write_key     = tls->our_write_key      + tls->key_size; // server_write_key[]
+        tls->our_write_IV       = tls->peer_write_key     + tls->key_size; // client_write_IV[]
+        tls->peer_write_IV      = tls->our_write_IV       + tls->IV_size;  // server_write_IV[]
+        dump_hex("client write_MAC_key:%s", tls->our_write_MAC_key, tls->MAC_size);
+        dump_hex("client write_key:%s", tls->our_write_key, tls->key_size);
+        dump_hex("client write_IV:%s", tls->our_write_IV, tls->IV_size);
+        dump_hex("server write_MAC_key:%s", tls->peer_write_MAC_key, tls->MAC_size);
+        dump_hex("server write_key:%s", tls->peer_write_key, tls->key_size);
+        dump_hex("server write_IV:%s", tls->peer_write_IV, tls->IV_size);
+
+        initialize_aes_keys(tls);
 }
 
 static const uint8_t rec_CHANGE_CIPHER_SPEC[] ALIGN1 = {
@@ -2035,7 +2065,7 @@ static const uint8_t rec_CHANGE_CIPHER_SPEC[] ALIGN1 = {
 
 static void send_change_cipher_spec(tls_state_t *tls)
 {
-        dbg(">> CHANGE_CIPHER_SPEC\n");
+        dbg(">> CHANGE_CIPHER_SPEC");
         xwrite(tls->ofd, rec_CHANGE_CIPHER_SPEC, sizeof(rec_CHANGE_CIPHER_SPEC));
 }
 
@@ -2076,36 +2106,81 @@ static void send_change_cipher_spec(tls_state_t *tls)
 // suite.  Any cipher suite which does not explicitly specify
 // verify_data_length has a verify_data_length equal to 12.  This
 // includes all existing cipher suites.
-static void send_client_finished(tls_state_t *tls)
+static void send_finished(tls_state_t *tls, const char *msg_to_encrypt)
 {
         struct finished {
                 uint8_t type;
                 uint8_t len24_hi, len24_mid, len24_lo;
                 uint8_t prf_result[12];
         };
-        struct finished *record = tls_get_outbuf(tls, sizeof(*record));
+        struct finished *record;
         uint8_t handshake_hash[TLS_MAX_MAC_SIZE];
         unsigned len;
 
-        fill_handshake_record_hdr(record, HANDSHAKE_FINISHED, sizeof(*record));
+        record = get_outbuf_fill_handshake_record(tls, HANDSHAKE_FINISHED, sizeof(*record));
 
         len = sha_end(&tls->hsd->handshake_hash_ctx, handshake_hash);
 
         prf_hmac_sha256(/*tls,*/
                 record->prf_result, sizeof(record->prf_result),
                 tls->hsd->master_secret, sizeof(tls->hsd->master_secret),
-                "client finished",
+                msg_to_encrypt,
                 handshake_hash, len
         );
-        dump_hex("from secret: %s\n", tls->hsd->master_secret, sizeof(tls->hsd->master_secret));
-        dump_hex("from labelSeed: %s", "client finished", sizeof("client finished")-1);
-        dump_hex("%s\n", handshake_hash, sizeof(handshake_hash));
-        dump_hex("=> digest: %s\n", record->prf_result, sizeof(record->prf_result));
+        dump_hex("from secret: %s", tls->hsd->master_secret, sizeof(tls->hsd->master_secret));
+        dump_hex("from labelSeed: %s", msg_to_encrypt, strlen(msg_to_encrypt));
+        dump_hex("handshake_hash: %s", handshake_hash, sizeof(handshake_hash));
+        dump_hex("=> digest: %s", record->prf_result, sizeof(record->prf_result));
 
-        dbg(">> FINISHED\n");
+        dbg(">> FINISHED");
         xwrite_encrypted(tls, sizeof(*record), RECORD_TYPE_HANDSHAKE);
 }
 
+/* Receive and process ChangeCipherSpec */
+static void get_change_cipher_spec(tls_state_t *tls)
+{
+        int len;
+
+        /* Get CHANGE_CIPHER_SPEC */
+        len = tls_xread_record(tls, "switch to encrypted traffic");
+        if (len != 1 || memcmp(tls->inbuf, rec_CHANGE_CIPHER_SPEC, 6) != 0)
+                bad_record_die(tls, "switch to encrypted traffic", len);
+        dbg("<< CHANGE_CIPHER_SPEC");
+
+        /* Enable decryption for incoming packets */
+        if (ALLOW_RSA_NULL_SHA256
+         && tls->cipher_id == TLS_RSA_WITH_NULL_SHA256
+        ) {
+                tls->min_encrypted_len_on_read = tls->MAC_size;
+        } else
+        if (!(tls->flags & ENCRYPTION_AESGCM)) {
+                unsigned mac_blocks = (unsigned)(TLS_MAC_SIZE(tls) + AES_BLOCK_SIZE-1) / AES_BLOCK_SIZE;
+                /* all incoming packets now should be encrypted and have
+                 * at least IV + (MAC padded to blocksize):
+                 */
+                tls->min_encrypted_len_on_read = AES_BLOCK_SIZE + (mac_blocks * AES_BLOCK_SIZE);
+        } else {
+                tls->min_encrypted_len_on_read = 8 + AES_BLOCK_SIZE;
+        }
+        dbg("min_encrypted_len_on_read: %u", tls->min_encrypted_len_on_read);
+}
+
+/* Receive encrypted Finished message */
+static void get_finished(tls_state_t *tls, const char *expected)
+{
+        int len;
+
+        len = tls_xread_record(tls, expected);
+        if (len < 4 || tls->inbuf[RECHDR_LEN] != HANDSHAKE_FINISHED)
+                bad_record_die(tls, expected, len);
+        dbg("<< FINISHED");
+
+        /* TODO: Verify the Finished message contents */
+        /* The Finished message contains verify_data which is:
+         * PRF(master_secret, "client finished"/"server finished", SHA256(handshake_messages))
+         */
+}
+
 void FAST_FUNC tls_handshake(tls_state_t *tls, const char *sni)
 {
         // Client              RFC 5246                Server
@@ -2156,8 +2231,8 @@ void FAST_FUNC tls_handshake(tls_state_t *tls, const char *sni)
                 // This message is used to convey the server's ephemeral ECDH public key
                 // (and the corresponding elliptic curve domain parameters) to the
                 // client.
-                dbg("<< SERVER_KEY_EXCHANGE len:%u\n", len);
-                dump_raw_in("<< %s\n", tls->inbuf, RECHDR_LEN + len);
+                dbg("<< SERVER_KEY_EXCHANGE len:%u", len);
+                dump_raw_in("<< %s", tls->inbuf, RECHDR_LEN + len);
                 if (tls->flags & NEED_EC_KEY)
                         process_server_key(tls, len);
 
@@ -2167,7 +2242,7 @@ void FAST_FUNC tls_handshake(tls_state_t *tls, const char *sni)
 
         got_cert_req = (tls->inbuf[RECHDR_LEN] == HANDSHAKE_CERTIFICATE_REQUEST);
         if (got_cert_req) {
-                dbg("<< CERTIFICATE_REQUEST\n");
+                dbg("<< CERTIFICATE_REQUEST");
                 // RFC 5246: "If no suitable certificate is available,
                 // the client MUST send a certificate message containing no
                 // certificates.  That is, the certificate_list structure has a
@@ -2185,7 +2260,7 @@ void FAST_FUNC tls_handshake(tls_state_t *tls, const char *sni)
                 bad_record_die(tls, "'server hello done'", len);
         }
         // 0e 000000 (len:0)
-        dbg("<< SERVER_HELLO_DONE\n");
+        dbg("<< SERVER_HELLO_DONE");
 
         if (got_cert_req)
                 send_empty_client_cert(tls);
@@ -2193,39 +2268,16 @@ void FAST_FUNC tls_handshake(tls_state_t *tls, const char *sni)
         send_client_key_exchange(tls);
 
         send_change_cipher_spec(tls);
+
         /* from now on we should send encrypted */
-        /* tls->write_seq64_be = 0; - already is */
-        tls->flags |= ENCRYPT_ON_WRITE;
 
-        send_client_finished(tls);
+        send_finished(tls, "client finished");
 
-        /* Get CHANGE_CIPHER_SPEC */
-        len = tls_xread_record(tls, "switch to encrypted traffic");
-        if (len != 1 || memcmp(tls->inbuf, rec_CHANGE_CIPHER_SPEC, 6) != 0)
-                bad_record_die(tls, "switch to encrypted traffic", len);
-        dbg("<< CHANGE_CIPHER_SPEC\n");
-
-        if (ALLOW_RSA_NULL_SHA256
-         && tls->cipher_id == TLS_RSA_WITH_NULL_SHA256
-        ) {
-                tls->min_encrypted_len_on_read = tls->MAC_size;
-        } else
-        if (!(tls->flags & ENCRYPTION_AESGCM)) {
-                unsigned mac_blocks = (unsigned)(TLS_MAC_SIZE(tls) + AES_BLOCK_SIZE-1) / AES_BLOCK_SIZE;
-                /* all incoming packets now should be encrypted and have
-                 * at least IV + (MAC padded to blocksize):
-                 */
-                tls->min_encrypted_len_on_read = AES_BLOCK_SIZE + (mac_blocks * AES_BLOCK_SIZE);
-        } else {
-                tls->min_encrypted_len_on_read = 8 + AES_BLOCK_SIZE;
-        }
-        dbg("min_encrypted_len_on_read: %u\n", tls->min_encrypted_len_on_read);
+        get_change_cipher_spec(tls);
 
         /* Get (encrypted) FINISHED from the server */
-        len = tls_xread_record(tls, "'server finished'");
-        if (len < 4 || tls->inbuf[RECHDR_LEN] != HANDSHAKE_FINISHED)
-                bad_record_die(tls, "'server finished'", len);
-        dbg("<< FINISHED\n");
+        get_finished(tls, "'server finished'");
+
         /* application data can be sent/received */
 
         /* free handshake data */
@@ -2238,7 +2290,7 @@ void FAST_FUNC tls_handshake(tls_state_t *tls, const char *sni)
 
 static void tls_xwrite(tls_state_t *tls, int len)
 {
-        dbg(">> DATA\n");
+        dbg(">> DATA");
         xwrite_encrypted(tls, len, RECORD_TYPE_APPLICATION_DATA);
 }
 
@@ -2313,7 +2365,7 @@ void FAST_FUNC tls_run_copy_loop(tls_state_t *tls, unsigned flags)
                 if (pfds[0].revents) {
                         void *buf;
 
-                        dbg("STDIN HAS DATA\n");
+                        dbg("STDIN HAS DATA");
                         buf = tls_get_outbuf(tls, inbuf_size);
                         nread = safe_read(STDIN_FILENO, buf, inbuf_size);
                         if (nread < 1) {
@@ -2329,6 +2381,7 @@ void FAST_FUNC tls_run_copy_loop(tls_state_t *tls, unsigned flags)
                                 tls_free_outbuf(tls); /* mem usage optimization */
                                 if (flags & TLSLOOP_EXIT_ON_LOCAL_EOF)
                                         break;
+                                        //TODO: if (pfds[1].revents) network has data, do a last read from it before exiting.
                         } else {
                                 if (nread == inbuf_size) {
                                         /* TLS has per record overhead, if input comes fast,
@@ -2338,11 +2391,16 @@ void FAST_FUNC tls_run_copy_loop(tls_state_t *tls, unsigned flags)
                                         if (inbuf_size > TLS_MAX_OUTBUF)
                                                 inbuf_size = TLS_MAX_OUTBUF;
                                 }
+//BUG: in this example: printf '\n' | ssl_client -e ssl_server -OPTS echo 'Hi'
+//if ssl_client arrives here (if it sees stdin before it sees the server's "Hi" message),
+//it can be killed by SIGPIPE because server has already exited.
+//(If we disable SIGPIPE, it would die on write error).
+//Which means it won't get and won't print to stdout the server's response!
                                 tls_xwrite(tls, nread);
                         }
                 }
                 if (pfds[1].revents) {
-                        dbg("NETWORK HAS DATA\n");
+                        dbg("NETWORK HAS DATA");
  read_record:
                         nread = tls_xread_record(tls, "encrypted data");
                         if (nread < 1) {
@@ -2366,6 +2424,784 @@ void FAST_FUNC tls_run_copy_loop(tls_state_t *tls, unsigned flags)
                 }
         }
 }
+
+#if ENABLE_SSL_SERVER // || ENABLE_FEATURE_HTTPD_SSL
+
+/* =============== SERVER-SIDE CODE =============== */
+
+static void get_client_hello(tls_state_t *tls)
+{
+        struct client_hello {
+                uint8_t type;
+                uint8_t len24_hi, len24_mid, len24_lo;
+                uint8_t proto_maj, proto_min;
+                uint8_t rand32[32];
+                uint8_t session_id_len;
+                /* followed by session_id, cipher suites, compression methods, extensions */
+        };
+        unsigned i, j;
+        struct client_hello *hp;
+        uint8_t *p;
+        int cipher_list_len;
+        int extensions_len;
+        int len;
+
+        len = tls_xread_handshake_block(tls, sizeof(*hp));
+        /* NB: the recv'd block is already hashed by tls_xread_handshake_block() */
+        hp = (void*)(tls->inbuf + RECHDR_LEN);
+        if (hp->type != HANDSHAKE_CLIENT_HELLO
+         || len != get24be(&hp->len24_hi) + 4
+         || hp->proto_maj != TLS_MAJ
+         || !is_minor_version_valid(tls, hp->proto_min)
+        ) {
+                bad_record_die(tls, "'client hello'", len);
+        }
+        dbg("<< CLIENT_HELLO len:%d len24:%d", len, get24be(&len24_hi));
+
+        /* Save client random */
+        memcpy(tls->hsd->client_and_server_rand32, hp->rand32, 32);
+
+        /* Skip session ID and handshake header */
+        p = (uint8_t*)(hp + 1) + hp->session_id_len;
+        len -= (sizeof(*hp) + hp->session_id_len);
+
+        /* Parse cipher suites to select one we support */
+        if (len < 2) {
+                bb_simple_error_msg_and_die("malformed ClientHello");
+        }
+        cipher_list_len = (p[0] << 8) | p[1];
+        p += 2;
+        len -= 2;
+
+        if (len < cipher_list_len) {
+                bb_simple_error_msg_and_die("malformed ClientHello");
+        }
+
+        /* Check whether we have TLS_EMPTY_RENEGOTIATION_INFO_SCSV */
+        for (j = 0; j < cipher_list_len; j += 2) {
+                if (p[j] == TLS_EMPTY_RENEGOTIATION_INFO_SCSV >> 8
+                 && p[j + 1] == (uint8_t)TLS_EMPTY_RENEGOTIATION_INFO_SCSV
+                ) {
+                        dbg("got TLS_EMPTY_RENEGOTIATION_INFO_SCSV");
+                        tls->hsd->reneg_info_requested = 1;
+                        break;
+                }
+        }
+
+        /* Select cipher + cert pair from client's list, preferring our ciphers in order */
+        for (i = 0; i < NUM_CIPHERS*2; i += 2) {
+                const uint8_t *our_cipher = &supported_ciphers[i];
+                int key_type;
+
+                /* Determine required key type for this cipher */
+                key_type = is_cipher_ECDSA(our_cipher);
+                if (key_type == KEY_ECDSA) {
+                        if (!tls->hsd->keys[KEY_ECDSA])
+                                /* No ECDSA cert configured, can't choose this */
+                                continue;
+                        //TODO: ECDSA not supported yet at all
+                        continue;
+                } else {
+                        if (!tls->hsd->keys[KEY_RSA])
+                                /* No RSA cert configured, can't choose this */
+                                continue;
+                        /* We _can_ choose this! */
+                }
+
+                /* Check if this cipher is in client's list */
+                for (j = 0; j < cipher_list_len; j += 2) {
+                        if (p[j] == our_cipher[0] && p[j + 1] == our_cipher[1]) {
+                                /* Found a match! */
+                                set_cipher_parameters(tls, our_cipher);
+                                dbg("Selected cipher: %04x", tls->cipher_id);
+                                tls->hsd->key_type_chosen = key_type;
+                                goto cipher_selected;
+                        }
+                }
+                /* try our next cipherid */
+        }
+        bb_simple_error_msg_and_die("no common cipher suites");
+
+ cipher_selected:
+        /* Skip past cipher list */
+        p += cipher_list_len;
+        len -= cipher_list_len;
+
+        /* Skip compression methods */
+        len -= 1 + p[0];
+        p += 1 + p[0];
+
+        /* Parse extensions if present */
+        if (len < 2) {
+                dbg("No extensions");
+                return; /* no extensions */
+        }
+        extensions_len = (p[0] << 8) | p[1];
+        p += 2;
+        len -= 2;
+        dbg("Extensions total length: %u, remaining len: %d", extensions_len, len);
+
+        if (len < extensions_len) {
+                dbg("Malformed extensions length (len %d < extensions_len %u)", len, extensions_len);
+                return; /* malformed extensions, ignore */
+        }
+
+        /* Process extensions */
+        while (extensions_len >= 4) {
+                unsigned ext_type = (p[0] << 8) | p[1];
+                int ext_len = (p[2] << 8) | p[3];
+                dbg("Extension type: 0x%04x, len: %u", ext_type, ext_len);
+
+                p += 4;
+                extensions_len -= 4 + ext_len;
+                if (extensions_len < 0) {
+                        dbg("Extension length overflow");
+                        return; /* malformed */
+                }
+
+                if (ext_type == 0x000a) { /* supported_groups */
+                        /* Parse named curve list */
+                        int curve_list_len = (p[0] << 8) | p[1];
+                        dbg("Found supported_groups extension");
+                        p += 2;
+                        ext_len -= 2;
+                        if (ext_len != curve_list_len || (ext_len & 1))
+                                return; /* malformed */
+                        while (1) {
+                                unsigned curve;
+                                ext_len -= 2; /* skip (presumably existing) curve id */
+                                if (ext_len < 0)
+                                        break; /* oops, it didn't */
+                                curve = (p[0] << 8) | p[1];
+                                p += 2;
+                                if (curve == 0x001d) /* x25519 */
+                                        tls->flags |= USE_EC_CURVE_X25519;
+//                              if (curve == 0x0017) /* secp256r1 (P256) */
+//                                      /* We'll try P256 as fallback without checking client support */
+                        }
+                        dbg("Client supports:%s",
+                                (tls->flags & USE_EC_CURVE_X25519) ? " x25519" : " P256(assumed)");
+                        continue;
+                }
+
+                if (ext_type == 0xff01) {
+                        dbg("got reneg_info extension ff01");
+                        tls->hsd->reneg_info_requested = 1;
+                }
+                p += ext_len;
+        }
+}
+
+static void send_server_hello(tls_state_t *tls)
+{
+        struct server_hello {
+                uint8_t type;
+                uint8_t len24_hi, len24_mid, len24_lo;
+                uint8_t proto_maj, proto_min;
+                uint8_t rand32[32];
+                uint8_t session_id_len;
+                uint8_t cipherid_hi, cipherid_lo;
+                uint8_t comprtype;
+                uint8_t extensions_len_hi, extensions_len_lo;
+                /* extensions follow */
+                uint8_t ext_reneg_info[5];  /* ff 01 00 01 00 */
+        };
+        struct server_hello *record;
+        unsigned len = sizeof(*record);
+
+        if (!tls->hsd->reneg_info_requested)
+                len -= 7;
+
+        record = get_outbuf_fill_handshake_record(tls, HANDSHAKE_SERVER_HELLO, len);
+
+        record->proto_maj = TLS_MAJ;
+        record->proto_min = TLS_MIN;
+
+        /* Generate server random */
+        tls_get_random(record->rand32, sizeof(record->rand32));
+        memcpy(tls->hsd->client_and_server_rand32 + 32, record->rand32, 32);
+
+        /* No session ID */
+        //record->session_id_len = 0;
+
+        /* Selected cipher suite */
+        record->cipherid_hi = tls->cipher_id >> 8;
+        record->cipherid_lo = tls->cipher_id; // & 0xff implicit
+
+        /* No compression */
+        //record->comprtype = 0;
+
+        if (tls->hsd->reneg_info_requested) {
+                /* Extensions */
+                //record->extensions_len_hi = 0;
+                record->extensions_len_lo = 5; /* length of renegotiation_info extension */
+
+                /* Renegotiation info extension (RFC 5746) */
+                record->ext_reneg_info[0] = 0xff;
+                record->ext_reneg_info[1] = 0x01; /* extension type */
+                //record->ext_reneg_info[2] = 0x00;
+                record->ext_reneg_info[3] = 0x01; /* extension data length: 1 byte */
+                //record->ext_reneg_info[4] = 0x00; /* renegotiation info length: 0 (no previous connection) */
+        }
+
+        dbg(">> SERVER_HELLO");
+        xwrite_and_update_handshake_hash(tls, len);
+}
+
+static void send_server_certificate(tls_state_t *tls)
+{
+        void *record;
+        int n = tls->hsd->key_type_chosen;
+        int sz = tls->hsd->certsize[n];
+
+        record = tls_get_outbuf(tls, sz);
+        memcpy(record, tls->hsd->certs[n], sz);
+        dbg(">> CERTIFICATE");
+        xwrite_and_update_handshake_hash(tls, sz);
+}
+
+static void send_server_key_exchange(tls_state_t *tls)
+{
+        struct server_key_exchange {
+                uint8_t type;
+                uint8_t len24_hi, len24_mid, len24_lo;
+                uint8_t curve_type; /* 3 = named curve */
+                uint8_t curve_id_hi, curve_id_lo;
+                uint8_t pubkey_len;
+                uint8_t pubkey[1 + 2 * 32]; /* for P256: 04 + x(32) + y(32) */
+                /* Followed by signature: hash_alg(1) + sign_alg(1) + sig_len(2) + signature */
+        };
+        struct server_key_exchange *record;
+        uint8_t *p;
+        int pubkey_len;
+        int params_len;
+        int total_len;
+        uint8_t hash[32]; /* SHA256 hash */
+        sha256_ctx_t sha256_ctx;
+        int32 sig_len;
+
+        record = tls_get_zeroed_outbuf(tls, sizeof(*record) + 4 + 512); /* extra space for signature */
+
+        record->type = HANDSHAKE_SERVER_KEY_EXCHANGE;
+        record->curve_type = 3; /* named curve */
+
+        /* Determine which curve to use based on client's supported_groups extension.
+         * Prefer x25519 (faster) if client supports it, otherwise use P256.
+         * If client didn't send supported_groups, default to P256 (most widely supported).
+         */
+        if (tls->flags & USE_EC_CURVE_X25519) { /* Use x25519 */
+                //record->curve_id_hi = 0x00; /* already zero from tls_get_zeroed_outbuf() */
+                record->curve_id_lo = 0x1d; /* x25519 */
+
+                /* Generate ephemeral keypair directly into output buffer */
+                curve_x25519_generate_keypair(tls->hsd->ecc_priv_key32, record->pubkey);
+
+                pubkey_len = 32;
+                dbg("Using x25519 for ECDHE");
+        } else { /* Use P256 (default or if client advertised it) */
+                //record->curve_id_hi = 0x00; /* already zero from tls_get_zeroed_outbuf() */
+                record->curve_id_lo = 0x17; /* secp256r1 (P256) */
+
+                /* Generate ephemeral keypair directly into output buffer */
+                record->pubkey[0] = 0x04; /* uncompressed point */
+                curve_P256_generate_keypair(tls->hsd->ecc_priv_key32, record->pubkey + 1);
+
+                pubkey_len = 1 + 2 * 32;
+                /* P256 is the default, no need to set USE_EC_CURVE_X25519 flag */
+                dbg("Using P256 for ECDHE");
+        }
+
+        record->pubkey_len = pubkey_len;
+
+        /* ServerECDHParams length: curve_type(1) + curve_id(2) + pubkey_len(1) + pubkey */
+        params_len = 4 + pubkey_len;
+
+        /* Sign the parameters with our RSA private key:
+         * Signature is over SHA256(client_random + server_random + ServerECDHParams)
+         */
+        sha256_begin(&sha256_ctx);
+        sha256_hash(&sha256_ctx, tls->hsd->client_and_server_rand32, 2 * 32);
+        sha256_hash(&sha256_ctx, &record->curve_type, params_len);
+        sha256_end(&sha256_ctx, hash);
+
+        /* Pointer to where signature data goes (after ServerECDHParams) */
+        p = record->pubkey + pubkey_len;
+
+        /* SignatureAndHashAlgorithm: hash=SHA256(4), signature=RSA(1) */
+        *p++ = 4; /* SHA256 */
+        *p++ = 1; /* RSA */
+
+        /* Sign the hash */
+        sig_len = privRsaEncryptSignedElement(NULL, &tls->hsd->rsa_priv_key,
+                hash, 32, p + 2, 512, NULL);
+        if (sig_len < 0) {
+                bb_error_msg_and_die("RSA signature failed");
+        }
+
+        /* Signature length (2 bytes, big-endian) */
+        p[0] = sig_len >> 8;
+        p[1] = sig_len; // & 0xff implicit
+
+        /* Total handshake message length: params + hash_alg(1) + sign_alg(1) + sig_len(2) + signature */
+        total_len = params_len + 2 + 2 + sig_len;
+
+        //record->len24_hi = 0; /* already zero from tls_get_zeroed_outbuf() */
+        record->len24_mid = total_len >> 8;
+        record->len24_lo = total_len; // & 0xff implicit
+
+        /* Total wire length */
+        total_len += 4; /* type + len24 */
+
+        dbg(">> SERVER_KEY_EXCHANGE");
+        xwrite_and_update_handshake_hash(tls, total_len);
+}
+
+static void send_server_hello_done(tls_state_t *tls)
+{
+        struct server_hello_done {
+                uint8_t type;
+                uint8_t len24_hi, len24_mid, len24_lo;
+        };
+        struct server_hello_done *record;
+
+        record = get_outbuf_fill_handshake_record(tls, HANDSHAKE_SERVER_HELLO_DONE, sizeof(*record));
+
+        dbg(">> SERVER_HELLO_DONE");
+        xwrite_and_update_handshake_hash(tls, sizeof(*record));
+}
+
+/* Receive and process ClientKeyExchange */
+static void get_client_key_exchange(tls_state_t *tls)
+{
+        struct client_key_exchange {
+                uint8_t type;
+                uint8_t len24_hi, len24_mid, len24_lo;
+                uint8_t key[1]; /* Variable length: encrypted premaster (RSA) or EC point (ECDHE) */
+        };
+        struct client_key_exchange *record;
+        uint8_t premaster[RSA_PREMASTER_SIZE > EC_CURVE_KEYSIZE ? RSA_PREMASTER_SIZE : EC_CURVE_KEYSIZE];
+        int len, premaster_size;
+        uint8_t *key_data;
+
+        len = tls_xread_handshake_block(tls, sizeof(*record));
+        record = (void*)(tls->inbuf + RECHDR_LEN);
+
+        if (record->type != HANDSHAKE_CLIENT_KEY_EXCHANGE) {
+                bad_record_die(tls, "'client key exchange'", len);
+        }
+        dbg("<< CLIENT_KEY_EXCHANGE");
+
+        key_data = record->key;
+
+        if (!(tls->flags & NEED_EC_KEY)) {
+                /* RSA key exchange */
+                int enckey_len;
+
+                /* Get the length of the encrypted premaster secret */
+                enckey_len = (key_data[0] << 8) | key_data[1];
+                key_data += 2;
+                dbg("enckey_len:%d len:%d", enckey_len, len);
+
+                if (enckey_len < 128 || enckey_len > 512) {
+                        bb_simple_error_msg_and_die("bad encrypted premaster length");
+                }
+
+                /* Decrypt the premaster secret using server's private RSA key */
+                {
+                        int32 ret;
+                        uint32 plen;
+                        psRsaKey_t *key = &tls->hsd->rsa_priv_key;
+
+                        plen = RSA_PREMASTER_SIZE;
+                        ret = psRsaDecryptPriv(NULL, key,
+                                               key_data, enckey_len,
+                                               premaster, plen, NULL);
+
+                        if (ret != RSA_PREMASTER_SIZE) {
+                                bb_error_msg_and_die("RSA decrypt failed or wrong premaster size: %d", ret);
+                        }
+
+                        dbg("Decrypted premaster secret (%d bytes)", ret);
+
+                        /* Verify premaster format: should start with version 0x03 0x03 (TLS 1.2) */
+                        if (premaster[0] != 0x03 || premaster[1] != 0x03) {
+                                bb_simple_error_msg_and_die("bad premaster secret version");
+                        }
+                }
+                premaster_size = RSA_PREMASTER_SIZE;
+        } else {
+                /* ECDHE key exchange */
+                int pubkey_len;
+                uint8_t *client_pubkey;
+
+                /* Get client's ephemeral public key length */
+                pubkey_len = *key_data++;
+                client_pubkey = key_data;
+
+                dbg("ECDHE: client pubkey_len:%d", pubkey_len);
+
+                /* Compute shared secret using client's public key and our private key */
+                if (tls->flags & USE_EC_CURVE_X25519) {
+                        /* x25519 */
+                        if (pubkey_len != CURVE25519_KEYSIZE) {
+                                bb_simple_error_msg_and_die("bad x25519 public key length");
+                        }
+                        curve_x25519_compute_premaster(
+                                tls->hsd->ecc_priv_key32, client_pubkey,
+                                premaster
+                        );
+                        premaster_size = CURVE25519_KEYSIZE;
+                } else {
+                        /* P256 */
+                        if (pubkey_len != 1 + 2 * P256_KEYSIZE) {
+                                bb_simple_error_msg_and_die("bad P256 public key length");
+                        }
+                        if (*client_pubkey++ != 0x04) {
+                                bb_simple_error_msg_and_die("compressed EC points not supported");
+                        }
+                        curve_P256_compute_premaster(
+                                tls->hsd->ecc_priv_key32, client_pubkey,
+                                premaster
+                        );
+                        premaster_size = P256_KEYSIZE;
+                }
+
+                dbg("Computed ECDHE premaster secret (%d bytes)", premaster_size);
+        }
+
+        derive_master_secret_and_keys(tls, premaster, premaster_size);
+        // The key_block[] is partitioned as follows:
+        tls->peer_write_MAC_key = tls->key_block;                         // client_write_MAC_key[]
+        tls->our_write_MAC_key  = tls->key_block         + tls->MAC_size; // server_write_MAC_key[]
+        tls->peer_write_key     = tls->our_write_MAC_key + tls->MAC_size; // client_write_key[]
+        tls->our_write_key      = tls->peer_write_key    + tls->key_size; // server_write_key[]
+        tls->peer_write_IV      = tls->our_write_key     + tls->key_size; // client_write_IV[]
+        tls->our_write_IV       = tls->peer_write_IV     + tls->IV_size;  // server_write_IV[]
+        dump_hex("server write_MAC_key:%s", tls->our_write_MAC_key, tls->MAC_size);
+        dump_hex("server write_key:%s", tls->our_write_key, tls->key_size);
+        dump_hex("server write_IV:%s", tls->our_write_IV, tls->IV_size);
+        dump_hex("client write_MAC_key:%s", tls->peer_write_MAC_key, tls->MAC_size);
+        dump_hex("client write_key:%s", tls->peer_write_key, tls->key_size);
+        dump_hex("client write_IV:%s", tls->peer_write_IV, tls->IV_size);
+
+        initialize_aes_keys(tls);
+}
+
+/* Load RSA private key from DER file (supports PKCS#8 or PKCS#1)
+ * PKCS#8 PrivateKeyInfo ::= SEQUENCE {
+ *   version         INTEGER,
+ *   algorithm       AlgorithmIdentifier,
+ *   privateKey      OCTET STRING  -- contains PKCS#1 RSAPrivateKey
+ * }
+ * PKCS#1 RSAPrivateKey ::= SEQUENCE {
+ *   version           INTEGER,  -- 0
+ *   modulus           INTEGER,  -- N
+ *   publicExponent    INTEGER,  -- e
+ *   privateExponent   INTEGER,  -- d
+ *   prime1            INTEGER,  -- p
+ *   prime2            INTEGER,  -- q
+ *   exponent1         INTEGER,  -- dP (d mod (p-1))
+ *   exponent2         INTEGER,  -- dQ (d mod (q-1))
+ *   coefficient       INTEGER   -- qP ((inverse of q) mod p)
+ * }
+ */
+static NOINLINE /* don't inline - large stack use */
+void load_rsa_priv_key(psRsaKey_t *key, uint8_t *buf, ssize_t sz)
+{
+        uint8_t *der, *end;
+
+        der = buf;
+        end = der + sz;
+
+        /* Enter the outer SEQUENCE */
+        der = enter_der_item(der, &end);
+
+        /* Check if this is PKCS#8 or PKCS#1 format
+         * PKCS#8 starts with version 0 (02 01 00) followed by AlgorithmIdentifier (30 0d...)
+         * PKCS#1 starts with version 0 (02 01 00) followed by modulus (02 82...)
+         * We can distinguish by checking if the second element is a SEQUENCE (0x30) or INTEGER (0x02)
+         */
+        der = skip_der_item(der, end); /* Skip version */
+
+        if (*der == 0x30) {
+                /* PKCS#8 format - skip AlgorithmIdentifier and enter OCTET STRING */
+                der = skip_der_item(der, end); /* Skip AlgorithmIdentifier */
+                der = enter_der_item(der, &end); /* Enter OCTET STRING containing PKCS#1 key */
+                der = enter_der_item(der, &end); /* Enter the PKCS#1 SEQUENCE */
+                der = skip_der_item(der, end); /* Skip version again */
+        }
+        /* else: PKCS#1 format - we already skipped the version */
+
+        /* Read the key components */
+        der_binary_to_pstm(&key->N, der, end);    /* modulus */
+        der = skip_der_item(der, end);
+
+        der_binary_to_pstm(&key->e, der, end);    /* publicExponent */
+        der = skip_der_item(der, end);
+
+        der_binary_to_pstm(&key->d, der, end);    /* privateExponent */
+        der = skip_der_item(der, end);
+
+        der_binary_to_pstm(&key->p, der, end);    /* prime1 */
+        der = skip_der_item(der, end);
+
+        der_binary_to_pstm(&key->q, der, end);    /* prime2 */
+        der = skip_der_item(der, end);
+
+        der_binary_to_pstm(&key->dP, der, end);   /* exponent1 */
+        der = skip_der_item(der, end);
+
+        der_binary_to_pstm(&key->dQ, der, end);   /* exponent2 */
+        der = skip_der_item(der, end);
+
+        der_binary_to_pstm(&key->qP, der, end);   /* coefficient */
+
+        key->size = pstm_unsigned_bin_size(&key->N);
+        key->optimized = 1; /* We have CRT parameters */
+}
+
+static char *decode_base64_or_die(char *dst, const char *src)
+{
+        char *dst_end = decode_base64(dst, &src);
+        if (*src != '\0')
+                bb_error_msg_and_die("base64 decode error");
+        return dst_end;
+}
+
+/* Parse PEM file and extract key + cert chain pairs
+ * Returns number of pairs loaded
+ */
+static void load_pem_key_cert_pairs(tls_state_t *tls, const char *pem_filename)
+{
+        static const char BLOCK_NAMES[] ALIGN1 =
+                "EC PARAMETERS"  "\0"
+                "CERTIFICATE"    "\0"
+                "EC PRIVATE KEY" "\0"
+                "PRIVATE KEY"    "\0"
+                "RSA PRIVATE KEY""\0"
+        ;
+        enum {
+                str_EC_PARAMETERS = 0,
+                str_CERTIFICATE = 1,
+                str_EC_KEY = 2,
+        };
+        char *p;
+        char *pem_data;
+        size_t pem_size;
+        char *der_data;
+        unsigned der_size;
+        int keyidx;
+
+        /* Read PEM file */
+        pem_size = 64 * 1024; /* sanity limit */
+        pem_data = xmalloc_xopen_read_close(pem_filename, &pem_size);
+
+        der_data = NULL;
+        der_size = 0;
+        keyidx = -1; /* "we did not see any KEY yet" */
+
+        p = pem_data;
+        while (1) {
+                unsigned n;
+                char *block_end;
+                char *block_type_end;
+
+                /* Find next PEM block */
+                p = skip_whitespace(p);
+                if (*p == '\0')
+                        break; /* end of file */
+                p = is_prefixed_with(p, "-----BEGIN ");
+                if (!p)
+                        goto err;
+                block_type_end = strstr(p, "-----\n");
+                if (!block_type_end)
+                        goto err;
+                block_type_end += 5;
+                block_end = strstr(block_type_end, "\n-----END ");
+                if (!block_end)
+                        goto err;
+                *block_end = '\0';
+                block_end += 10;
+//-----BEGIN PRIVATE KEY-----\n
+//           ^p              ^block_type_end
+//BASE64HERE-BASE64HERE
+//-----END PRIVATE KEY-----
+//         ^block_end
+                /* The headers must match */
+                *block_type_end = '\0';
+                if (!is_prefixed_with(block_end, p))
+                        goto err;
+                /* Truncate trailing dashes from block type name */
+                block_type_end[-5] = '\0';
+
+                block_end += (block_type_end - p);
+                block_type_end++;
+//BASE64HERE-BASE64HERE
+//^block_type_end
+//-----END PRIVATE KEY-----
+//                         ^block_end
+                n = index_in_strings(BLOCK_NAMES, p);
+                if ((int)n < 0)
+                        bb_error_msg_and_die("'%s': unknown PEM block '%s'", pem_filename, p);
+
+                /* Note: may point to "\n" or even NUL */
+                p = block_end;
+
+                /* What block do we see? */
+
+                if (n == str_EC_PARAMETERS) {
+                        /* "openssl ecparam -genkey" generates these, skip silently */
+                        continue; /* skip */
+                }
+
+                if (n == str_CERTIFICATE) {
+                        struct certificate_msg {
+                                uint8_t type;
+                                uint8_t len24_hi, len24_mid, len24_lo;
+                                uint8_t cert_chain_len24_hi, cert_chain_len24_mid, cert_chain_len24_lo;
+                                uint8_t cert1_len24_hi, cert1_len24_mid, cert1_len24_lo;
+                                /* followed by certificate DER data */
+                                /* followed by cert2_len24, cert2 DER data, ... */
+                        };
+                        struct certificate_msg *cert_msg;
+                        unsigned start;
+
+                        if (keyidx < 0)
+                                bb_error_msg_and_die("'%s': certificate must be after key", pem_filename);
+
+                        /* We create or update a full HANDSHAKE_CERTIFICATE message */
+                        if (der_size == 0) {
+                                der_size = sizeof(*cert_msg);
+                                der_data = xzalloc(der_size);
+                                cert_msg = (void*)der_data;
+                                cert_msg->type = HANDSHAKE_CERTIFICATE;
+                        } else {
+                                /* We are here when we decode second or later cert */
+                                der_size += 3; /* for len24 */
+                        }
+
+                        /* Decode BASE64 */
+                        start = der_size;
+                        der_size += block_end - block_type_end; /* worst case size */
+                        der_data = xrealloc(der_data, der_size);
+                        der_size = decode_base64_or_die(der_data + start, block_type_end) - der_data;
+                        der_data = xrealloc(der_data, der_size);
+
+                        /* Fill last cert's len24 */
+                        n = der_size - start;
+                        der_data[start - 3] = n >> 16;
+                        der_data[start - 2] = n >> 8;
+                        der_data[start - 1] = n;
+                        /* Update sizes in header */
+                        cert_msg = (void*)der_data;
+                        n = der_size - 4;
+                        cert_msg->len24_hi  = n >> 16;
+                        cert_msg->len24_mid = n >> 8;
+                        cert_msg->len24_lo  = n;
+                        n -= 3;
+                        cert_msg->cert_chain_len24_hi  = n >> 16;
+                        cert_msg->cert_chain_len24_mid = n >> 8;
+                        cert_msg->cert_chain_len24_lo  = n;
+
+                        tls->hsd->certs[keyidx] = der_data;
+                        tls->hsd->certsize[keyidx] = der_size;
+                        continue;
+                }
+
+                /* We see a key */
+
+                /* Decode BASE64 */
+                der_size = block_end - block_type_end; /* worst case size */
+                der_data = xmalloc(der_size);
+                der_size = decode_base64_or_die(der_data, block_type_end) - der_data;
+                der_data = xrealloc(der_data, der_size);
+
+                keyidx = (n == str_EC_KEY) ? KEY_ECDSA : KEY_RSA;
+                if (tls->hsd->keys[keyidx])
+                        bb_error_msg_and_die("'%s': more than one key", pem_filename);
+                tls->hsd->keys[keyidx] = der_data;
+                tls->hsd->keysize[keyidx] = der_size;
+
+                der_data = NULL;
+                der_size = 0;
+        } /* while (parsing PEM) */
+        free(pem_data);
+
+        if (!tls->hsd->keys[KEY_RSA] && !tls->hsd->keys[KEY_ECDSA])
+                bb_error_msg_and_die("'%s': no private keys", pem_filename);
+
+        if (tls->hsd->keys[KEY_RSA]) {
+                if (!tls->hsd->certs[KEY_RSA])
+                        bb_error_msg_and_die("'%s': key with no cert", pem_filename);
+                /* Parse RSA key from DER */
+                load_rsa_priv_key(&tls->hsd->rsa_priv_key, (uint8_t*)tls->hsd->keys[KEY_RSA], tls->hsd->keysize[KEY_RSA]);
+        }
+        if (tls->hsd->keys[KEY_ECDSA]) {
+                if (!tls->hsd->certs[KEY_ECDSA])
+                        bb_error_msg_and_die("'%s': key with no cert", pem_filename);
+                bb_error_msg("'%s': ECDSA keys not supported", pem_filename);
+        }
+
+        return;
+ err:
+        bb_error_msg_and_die("malformed PEM file at '%.*s'", (int)(skip_whitespace(p) - p), p);
+}
+
+void FAST_FUNC tls_handshake_as_server(tls_state_t *tls,
+        const char *pem_filename)
+{
+        /* Allocate handshake data */
+        tls->hsd = xzalloc(sizeof(*tls->hsd));
+
+        /* Load server key(s) and certificate(s) from PEM file */
+        load_pem_key_cert_pairs(tls, pem_filename);
+
+        sha256_begin(&tls->hsd->handshake_hash_ctx);
+
+        /* Server handshake sequence:
+         * 1. Receive ClientHello
+         * 2. Send ServerHello
+         * 3. Send Certificate
+         * 4. [Send ServerKeyExchange] - only for DHE/ECDHE
+         * 5. [Send CertificateRequest] - optional, skip for now
+         * 6. Send ServerHelloDone
+         * 7. Receive ClientKeyExchange
+         * 8. Receive ChangeCipherSpec
+         * 9. Receive Finished (encrypted)
+         * 10. Send ChangeCipherSpec
+         * 11. Send Finished (encrypted)
+         */
+        tls->expecting_first_packet = 1;
+        get_client_hello(tls);
+        tls->expecting_first_packet = 0;
+        send_server_hello(tls);
+        send_server_certificate(tls);
+        if (tls->flags & NEED_EC_KEY)
+                send_server_key_exchange(tls);
+        send_server_hello_done(tls);
+
+        get_client_key_exchange(tls);
+        get_change_cipher_spec(tls);
+        /* Get (encrypted) FINISHED from the client */
+        get_finished(tls, "'cliend finished'");
+
+        send_change_cipher_spec(tls);
+        send_finished(tls, "server finished");
+
+        /* application data can be sent/received */
+
+        /* free handshake data */
+        psRsaKey_clear(&tls->hsd->rsa_priv_key);
+        free(tls->hsd->keys[0]);
+        free(tls->hsd->keys[1]);
+        free(tls->hsd->certs[0]);
+        free(tls->hsd->certs[1]);
+//      if (PARANOIA)
+//              memset(tls->hsd, 0, sizeof(*tls->hsd));
+        free(tls->hsd);
+        tls->hsd = NULL;
+}
+#endif
 #else
 #include <stdbool.h>
 
diff --git a/networking/tls.h b/networking/tls.h
index fde2e4d3d..0252b161f 100644
--- a/networking/tls.h
+++ b/networking/tls.h
@@ -49,6 +49,7 @@
 #define PS_PLATFORM_FAIL        -7      /* Failure as a result of system call error */
 #define PS_MEM_FAIL             -8      /* Failure to allocate requested memory */
 #define PS_LIMIT_FAIL           -9      /* Failure on sanity/limit tests */
+#define PS_UNSUPPORTED_FAIL     -10     /* Unsupported algorithm or operation */
 
 #define PS_TRUE         1
 #define PS_FALSE        0
@@ -90,6 +91,7 @@ void tls_get_random(void *buf, unsigned len) FAST_FUNC;
 
 #define matrixCryptoGetPrngData(buf, len, userPtr) (tls_get_random(buf, len), PS_SUCCESS)
 
+#define psMalloc(pool, size) xmalloc(size)
 #define psFree(p, pool)    free(p)
 #define psTraceCrypto(msg) bb_simple_error_msg_and_die(msg)
 
@@ -109,6 +111,22 @@ void tls_get_random(void *buf, unsigned len) FAST_FUNC;
 #define P256_KEYSIZE       32
 #define CURVE25519_KEYSIZE 32
 
+/* Separate keypair generation and premaster computation functions */
+void curve_x25519_generate_keypair(
+                uint8_t *privkey32, uint8_t *pubkey32) FAST_FUNC;
+void curve_x25519_compute_premaster(
+                const uint8_t *privkey32, const uint8_t *peerkey32,
+                uint8_t *premaster32) FAST_FUNC;
+
+#if ENABLE_SSL_SERVER
+void curve_P256_generate_keypair(
+                uint8_t *privkey32, uint8_t *pubkey2x32) FAST_FUNC;
+void curve_P256_compute_premaster(
+                const uint8_t *privkey32, const uint8_t *peerkey2x32,
+                uint8_t *premaster32) FAST_FUNC;
+#endif
+
+/* Combined operations (for client-side use) */
 void curve_x25519_compute_pubkey_and_premaster(
                 uint8_t *pubkey32, uint8_t *premaster32,
                 const uint8_t *peerkey32) FAST_FUNC;
diff --git a/networking/tls_fe.c b/networking/tls_fe.c
index e5580fbcf..479d0aaee 100644
--- a/networking/tls_fe.c
+++ b/networking/tls_fe.c
@@ -607,22 +607,47 @@ static void curve25519(byte *result, const byte *e, const byte *q)
         fe_normalize(result);
 }
 
-/* interface to bbox's TLS code: */
+/* interface to bbox's TLS code:
+ *
+ * Wire format for elliptic curve points differs between curves:
+ * - P256: point is (x,y) where each coordinate is a 256-bit (32-byte) big-endian integer.
+ *   Wire format: 64 bytes total (plus 0x04 prefix byte for "uncompressed point").
+ * - x25519: point is a single 256-bit (32-byte) little-endian integer.
+ *   Wire format: 32 bytes.
+ *
+ * The interface functions below accept and generate EC points in their respective
+ * wire formats. Internal calculations may use different representations, but all
+ * conversions are handled internally within these functions.
+ * (Note: x25519 implementation in this file uses wire format internally as well)
+ */
+
+/* Generate x25519 keypair: random private key + corresponding public key */
+void FAST_FUNC curve_x25519_generate_keypair(uint8_t *privkey32, uint8_t *pubkey32)
+{
+        /* Generate random private key, see RFC 7748 */
+        tls_get_random(privkey32, CURVE25519_KEYSIZE);
+        privkey32[0] &= 0xf8;
+        privkey32[CURVE25519_KEYSIZE-1] = ((privkey32[CURVE25519_KEYSIZE-1] & 0x7f) | 0x40);
+
+        /* Compute public key from private key */
+        curve25519(pubkey32, privkey32, NULL /* "use base point of x25519" */);
+}
+
+/* Compute shared secret (premaster) from our private key and peer's public key */
+void FAST_FUNC curve_x25519_compute_premaster(
+                const uint8_t *privkey32, const uint8_t *peerkey32,
+                uint8_t *premaster32)
+{
+        curve25519(premaster32, privkey32, peerkey32);
+}
 
+/* Combined operation: generate keypair and compute premaster in one call */
 void FAST_FUNC curve_x25519_compute_pubkey_and_premaster(
                 uint8_t *pubkey, uint8_t *premaster,
                 const uint8_t *peerkey32)
 {
         uint8_t privkey[CURVE25519_KEYSIZE]; //[32]
 
-        /* Generate random private key, see RFC 7748 */
-        tls_get_random(privkey, sizeof(privkey));
-        privkey[0] &= 0xf8;
-        privkey[CURVE25519_KEYSIZE-1] = ((privkey[CURVE25519_KEYSIZE-1] & 0x7f) | 0x40);
-
-        /* Compute public key */
-        curve25519(pubkey, privkey, NULL /* "use base point of x25519" */);
-
-        /* Compute premaster using peer's public key */
-        curve25519(premaster, privkey, peerkey32);
+        curve_x25519_generate_keypair(privkey, pubkey);
+        curve_x25519_compute_premaster(privkey, peerkey32, premaster);
 }
diff --git a/networking/tls_rsa.c b/networking/tls_rsa.c
index 2dd5a02f4..4dcbd3a4d 100644
--- a/networking/tls_rsa.c
+++ b/networking/tls_rsa.c
@@ -211,3 +211,176 @@ int32 FAST_FUNC psRsaEncryptPub(psPool_t *pool, psRsaKey_t *key,
         }
         return size;
 }
+
+#if ENABLE_SSL_SERVER // || ENABLE_FEATURE_HTTPD_SSL
+
+#define psRsaEncryptPriv(pool, key, in, inlen, out, outlen, data) \
+        psRsaEncryptPriv(      key, in, inlen, out, outlen)
+static //bbox
+int32 psRsaEncryptPriv(psPool_t *pool, psRsaKey_t *key,
+                                         unsigned char *in, uint32 inlen,
+                                         unsigned char *out, uint32 outlen, void *data)
+{
+        int32   err;
+        uint32  size;
+
+        size = key->size;
+        if (outlen < size) {
+                psTraceCrypto("Error on bad outlen parameter to psRsaEncryptPriv\n");
+                return PS_ARG_FAIL;
+        }
+        if ((err = pkcs1Pad(in, inlen, out, size, PUBKEY_TYPE, data)) < PS_SUCCESS){
+                psTraceCrypto("Error padding psRsaEncryptPriv. Likely data too long\n");
+                return err;
+        }
+        if ((err = psRsaCrypt(pool, out, size, out, (uint32*)&outlen, key,
+                        PRIVKEY_TYPE, data)) < PS_SUCCESS) {
+                psTraceCrypto("Error performing psRsaEncryptPriv\n");
+                return err;
+        }
+        if (outlen != size) {
+                psTraceCrypto("Encrypted size error in psRsaEncryptPriv\n");
+                return PS_FAILURE;
+        }
+        return size;
+}
+
+#define ASN_OVERHEAD_LEN_RSA_SHA2       19
+//#define ASN_OVERHEAD_LEN_RSA_SHA1     15
+
+/* ASN.1 DigestInfo wrappers for hash algorithms */
+static const unsigned char asn256dsWrap[] = {0x30, 0x31, 0x30, 0x0D, 0x06, 0x09, 0x60,
+        0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05, 0x00, 0x04, 0x20};
+//#ifdef USE_SHA384
+//static const unsigned char asn384dsWrap[] = {0x30, 0x41, 0x30, 0x0D, 0x06, 0x09, 0x60,
+//      0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05, 0x00, 0x04, 0x30};
+//#endif
+//static const unsigned char asn1dsWrap[] = {0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2B,
+//      0x0E, 0x03, 0x02, 0x1A, 0x05, 0x00, 0x04, 0x14};
+
+int32 FAST_FUNC privRsaEncryptSignedElement(psPool_t *pool, psRsaKey_t *key, //bbox: was psPubKey_t
+                unsigned char *in, uint32 inlen, unsigned char *out, uint32 outlen,
+                void *data)
+{
+        unsigned char   *c;
+        uint32                  inlenWithAsn;
+        int32                   rc;
+
+        if (inlen == 32) { //SHA256_HASH_SIZE
+                inlenWithAsn = inlen + ASN_OVERHEAD_LEN_RSA_SHA2;
+                c = psMalloc(pool, inlenWithAsn);
+                memcpy(c, asn256dsWrap, ASN_OVERHEAD_LEN_RSA_SHA2);
+                memcpy(c + ASN_OVERHEAD_LEN_RSA_SHA2, in, inlen);
+//      } else if (inlen == SHA1_HASH_SIZE) {
+//              inlenWithAsn = inlen + ASN_OVERHEAD_LEN_RSA_SHA1;
+//              c = psMalloc(pool, inlenWithAsn);
+//              memcpy(c, asn1dsWrap, ASN_OVERHEAD_LEN_RSA_SHA1);
+//              memcpy(c + ASN_OVERHEAD_LEN_RSA_SHA1, in, inlen);
+//#ifdef USE_SHA384
+//      } else if (inlen == SHA384_HASH_SIZE) {
+//              inlenWithAsn = inlen + ASN_OVERHEAD_LEN_RSA_SHA2;
+//              c = psMalloc(pool, inlenWithAsn);
+//              memcpy(c, asn384dsWrap, ASN_OVERHEAD_LEN_RSA_SHA2);
+//              memcpy(c + ASN_OVERHEAD_LEN_RSA_SHA2, in, inlen);
+//#endif
+        } else {
+                return PS_UNSUPPORTED_FAIL;
+        }
+
+        rc = psRsaEncryptPriv(pool, key, c, inlenWithAsn, //bbox: was (psRsaKey_t*)key->key
+                out, outlen, data);
+
+        psFree(c, pool);
+        return rc;
+}
+
+/* Remove PKCS#1 padding (Type 2) from decrypted data
+ * Format: 00 || 02 || PS || 00 || M
+ * Returns length of unpadded message, or negative on error
+ */
+#define pkcs1Unpad(in, inlen, out, outlen) \
+        pkcs1Unpad(in, inlen, out, outlen)
+static //bbox
+int32 pkcs1Unpad(unsigned char *in, uint32 inlen, unsigned char *out,
+                        uint32 outlen)
+{
+        unsigned char *c, *end;
+        uint32 msglen;
+
+        if (inlen < 11) {  /* Minimum: 00 02 [8 bytes PS] 00 */
+                psTraceCrypto("pkcs1Unpad: input too short\n");
+                return PS_FAILURE;
+        }
+
+        c = in;
+        end = in + inlen;
+
+        /* Check padding type byte */
+        if (*c++ != 0x00) {
+                psTraceCrypto("pkcs1Unpad: bad first byte\n");
+                return PS_FAILURE;
+        }
+        if (*c++ != 0x02) {
+                psTraceCrypto("pkcs1Unpad: bad padding type\n");
+                return PS_FAILURE;
+        }
+
+        /* Skip padding string (non-zero bytes) until we find 0x00 */
+        while (c < end && *c != 0x00) {
+                c++;
+        }
+
+        if (c >= end) {
+                psTraceCrypto("pkcs1Unpad: no 0x00 separator found\n");
+                return PS_FAILURE;
+        }
+
+        /* Skip the 0x00 separator */
+        c++;
+
+        /* Calculate message length */
+        msglen = (uint32)(end - c);
+
+        if (msglen > outlen) {
+                psTraceCrypto("pkcs1Unpad: output buffer too small\n");
+                return PS_FAILURE;
+        }
+
+        /* Copy message to output */
+        memcpy(out, c, msglen);
+
+        return msglen;
+}
+
+/* RSA private key decryption (PKCS#1 v1.5)
+ * Decrypts with private key and removes PKCS#1 padding
+ */
+#define psRsaDecryptPriv(pool, key, in, inlen, out, outlen, data) \
+        psRsaDecryptPriv(      key, in, inlen, out, outlen)
+int32 FAST_FUNC psRsaDecryptPriv(psPool_t *pool, psRsaKey_t *key,
+                                                unsigned char *in, uint32 inlen,
+                                                unsigned char *out, uint32 outlen, void *data)
+{
+        int32 err;
+        uint32 ptLen;
+
+        if (inlen != key->size) {
+                psTraceCrypto("Error on bad inlen parameter to psRsaDecryptPriv\n");
+                return PS_ARG_FAIL;
+        }
+        ptLen = inlen;
+        if ((err = psRsaCrypt(pool, in, inlen, in, &ptLen, key,
+                        PRIVKEY_TYPE, data)) < PS_SUCCESS) {
+                psTraceCrypto("Error performing psRsaDecryptPriv\n");
+                return err;
+        }
+        if (ptLen != inlen) {
+                psTraceCrypto("Decrypted size error in psRsaDecryptPriv\n");
+                return PS_FAILURE;
+        }
+        err = pkcs1Unpad(in, inlen, out, outlen);
+        memset(in, 0x0, inlen);
+        return err;
+}
+
+#endif /* server */
diff --git a/networking/tls_rsa.h b/networking/tls_rsa.h
index 82bea2a67..a8db73b9c 100644
--- a/networking/tls_rsa.h
+++ b/networking/tls_rsa.h
@@ -30,3 +30,15 @@ static ALWAYS_INLINE void psRsaKey_clear(psRsaKey_t *key)
 int32 psRsaEncryptPub(psPool_t *pool, psRsaKey_t *key,
                                                 unsigned char *in, uint32 inlen,
                                                 unsigned char *out, uint32 outlen, void *data) FAST_FUNC;
+
+#define psRsaDecryptPriv(pool, key, in, inlen, out, outlen, data) \
+        psRsaDecryptPriv(      key, in, inlen, out, outlen)
+int32 psRsaDecryptPriv(psPool_t *pool, psRsaKey_t *key,
+                                                unsigned char *in, uint32 inlen,
+                                                unsigned char *out, uint32 outlen, void *data) FAST_FUNC;
+
+#define privRsaEncryptSignedElement(pool, key, in, inlen, out, outlen, data) \
+        privRsaEncryptSignedElement(      key, in, inlen, out, outlen)
+int32 privRsaEncryptSignedElement(psPool_t *pool, psRsaKey_t *key,
+                                                unsigned char *in, uint32 inlen,
+                                                unsigned char *out, uint32 outlen, void *data) FAST_FUNC;
diff --git a/networking/tls_sp_c32.c b/networking/tls_sp_c32.c
index e493c436a..90ab61a56 100644
--- a/networking/tls_sp_c32.c
+++ b/networking/tls_sp_c32.c
@@ -1514,6 +1514,52 @@ static void sp_ecc_make_key_256(sp_digit privkey[8], uint8_t *pubkey)
         memset(point, 0, sizeof(point)); //paranoia
 }
 
+/* interface to bbox's TLS code:
+ *
+ * Wire format for elliptic curve points differs between curves:
+ * - P256: point is (x,y) where each coordinate is a 256-bit (32-byte) big-endian integer.
+ *   Wire format: 64 bytes total (plus 0x04 prefix byte for "uncompressed point").
+ * - x25519: point is a single 256-bit (32-byte) little-endian integer.
+ *   Wire format: 32 bytes.
+ *
+ * The interface functions below accept and generate EC points in their respective
+ * wire formats. Internal calculations may use different representations, but all
+ * conversions are handled internally within these functions.
+ */
+
+#if ENABLE_SSL_SERVER
+/* Generate P256 keypair: random private key + corresponding public key */
+void FAST_FUNC curve_P256_generate_keypair(uint8_t *privkey32, uint8_t *pubkey2x32)
+{
+        sp_digit privkey_sp[8];
+
+        /* Generate keypair using internal representation */
+        sp_ecc_make_key_256(privkey_sp, pubkey2x32);
+
+        /* Convert private key to binary format for storage */
+        sp_256_to_bin_8(privkey_sp, privkey32);
+
+        memset(privkey_sp, 0, sizeof(privkey_sp)); //paranoia
+}
+
+/* Compute shared secret (premaster) from our private key and peer's public key */
+void FAST_FUNC curve_P256_compute_premaster(
+                const uint8_t *privkey32, const uint8_t *peerkey2x32,
+                uint8_t *premaster32)
+{
+        sp_digit privkey_sp[8];
+
+        /* Convert binary private key to internal representation */
+        sp_256_from_bin_8(privkey_sp, privkey32);
+
+        /* Compute shared secret */
+        sp_ecc_secret_gen_256(privkey_sp, peerkey2x32, premaster32);
+
+        memset(privkey_sp, 0, sizeof(privkey_sp)); //paranoia
+}
+#endif
+
+/* Combined operation: generate keypair and compute premaster in one call */
 void FAST_FUNC curve_P256_compute_pubkey_and_premaster(
                 uint8_t *pubkey2x32, uint8_t *premaster32,
                 const uint8_t *peerkey2x32)
diff --git a/networking/udhcp/d6_socket.c b/networking/udhcp/d6_socket.c
index acf108367..83df4b396 100644
--- a/networking/udhcp/d6_socket.c
+++ b/networking/udhcp/d6_socket.c
@@ -116,7 +116,8 @@ int FAST_FUNC d6_listen_socket(int port, const char *inf)
                 bb_simple_perror_msg_and_die("SO_BROADCAST");
 
         /* SO_BINDTODEVICE doesn't work on ethernet aliases (ethN:M) */
-        colon = strrchr(inf, ':');
+        colon = (char*)strrchr(inf, ':');
+        /* NB: inf can really be a *const* string if it's a default, but defaults have no ':' */
         if (colon)
                 *colon = '\0';
 
diff --git a/networking/udhcp/socket.c b/networking/udhcp/socket.c
index 35e10688b..5d2283eaf 100644
--- a/networking/udhcp/socket.c
+++ b/networking/udhcp/socket.c
@@ -90,7 +90,8 @@ int FAST_FUNC udhcp_listen_socket(/*uint32_t ip,*/ int port, const char *inf)
                 bb_simple_perror_msg_and_die("SO_BROADCAST");
 
         /* SO_BINDTODEVICE doesn't work on ethernet aliases (ethN:M) */
-        colon = strrchr(inf, ':');
+        colon = (char*)strrchr(inf, ':');
+        /* NB: inf can really be a *const* string if it's a default, but defaults have no ':' */
         if (colon)
                 *colon = '\0';
 
diff --git a/printutils/lpr.c b/printutils/lpr.c
index 25b0f7235..464208c65 100644
--- a/printutils/lpr.c
+++ b/printutils/lpr.c
@@ -122,7 +122,7 @@ int lpqr_main(int argc UNUSED_PARAM, char **argv)
 
         {
                 // queue name is to the left of '@'
-                char *s = strchr(queue, '@');
+                char *s = (char *)strchr(queue, '@');
                 if (s) {
                         // server name is to the right of '@'
                         *s = '\0';
diff --git a/procps/nmeter.c b/procps/nmeter.c
index dca07eac6..fd8907aac 100644
--- a/procps/nmeter.c
+++ b/procps/nmeter.c
@@ -913,7 +913,8 @@ int nmeter_main(int argc UNUSED_PARAM, char **argv)
         // parameters as seen by e.g. ps. Making a copy...
         cur = xstrdup(argv[0]);
         while (1) {
-                char *param, *p;
+                char *param;
+                const char *p;
                 prev = cur;
  again:
                 cur = strchr(cur, '%');
@@ -929,7 +930,7 @@ int nmeter_main(int argc UNUSED_PARAM, char **argv)
                         // format: %[foptstring]
                         cur++;
                         p = strchr(options, cur[0]);
-                        param = cur+1;
+                        param = cur + 1;
                         while (cur[0] != ']') {
                                 if (!cur[0])
                                         bb_show_usage();
diff --git a/procps/powertop.c b/procps/powertop.c
index 6fe892540..a24748efc 100644
--- a/procps/powertop.c
+++ b/procps/powertop.c
@@ -238,7 +238,7 @@ static void save_line(const char *string, int count)
 #if ENABLE_FEATURE_POWERTOP_PROCIRQ
 static int is_hpet_irq(const char *name)
 {
-        char *p;
+        const char *p;
 # if BLOATY_HPET_IRQ_NUM_DETECTION
         long hpet_chan;
 
@@ -423,7 +423,8 @@ static NOINLINE int process_timer_stats(void)
 //     1,  2159 udisks-daemon    hrtimer_start_range_ns (hrtimer_wakeup)
 // 331 total events, 249.059 events/sec
                 while (fgets(buf, sizeof(buf), fp)) {
-                        const char *count, *process, *func;
+                        const char *process, *func;
+                        char *count;
                         char *p;
                         int idx;
                         unsigned cnt;
diff --git a/scripts/kconfig/confdata.c b/scripts/kconfig/confdata.c
index 2f7fa6618..777c27660 100644
--- a/scripts/kconfig/confdata.c
+++ b/scripts/kconfig/confdata.c
@@ -348,7 +348,7 @@ int conf_write(const char *name)
         dirname[0] = 0;
         if (name && name[0]) {
                 struct stat st;
-                char *slash;
+                const char *slash;
 
                 if (!stat(name, &st) && S_ISDIR(st.st_mode)) {
                         strcpy(dirname, name);
diff --git a/shell/ash.c b/shell/ash.c
index 7647a42cf..bf73d6bc2 100644
--- a/shell/ash.c
+++ b/shell/ash.c
@@ -6939,7 +6939,7 @@ tryexec_applet(int applet_no, int noexec, const char *cmd, char **argv, char **e
 #endif
 
 #if ENABLE_PLATFORM_MINGW32
-static struct builtincmd *find_builtin(const char *name);
+static const struct builtincmd *find_builtin(const char *name);
 static void
 tryexec(const char *cmd, const char *path, int noexec, char **argv, char **envp)
 {
@@ -9663,7 +9663,7 @@ test_exec(/*const char *fullname,*/ struct stat *statb)
 }
 
 /* Circular dep: find_command->find_builtin->builtintab[]->hashcmd->find_command */
-static struct builtincmd *find_builtin(const char *name);
+static const struct builtincmd *find_builtin(const char *name);
 #if ENABLE_ASH_BASH_NOT_FOUND_HOOK
 static int evalfun(struct funcnode *func, int argc, char **argv, int flags);
 #endif
@@ -9684,7 +9684,7 @@ find_command(char *name, struct cmdentry *entry, int act, const char *path)
         struct stat statb;
         int e;
         int updatetbl;
-        struct builtincmd *bcmd;
+        const struct builtincmd *bcmd;
         int len;
 
 #if !ENABLE_PLATFORM_MINGW32
@@ -10303,9 +10303,7 @@ static const uint8_t nodesize[N_NUMBER] ALIGN1 = {
 #endif
         [NCLOBBER ] = SHELL_ALIGN(sizeof(struct nfile)),
         [NFROM    ] = SHELL_ALIGN(sizeof(struct nfile)),
-#if ENABLE_PLATFORM_MINGW32
         [NFROMSTR ] = SHELL_ALIGN(sizeof(struct nfile)),
-#endif
         [NFROMTO  ] = SHELL_ALIGN(sizeof(struct nfile)),
         [NAPPEND  ] = SHELL_ALIGN(sizeof(struct nfile)),
         [NTOFD    ] = SHELL_ALIGN(sizeof(struct ndup)),
@@ -12074,10 +12072,10 @@ static const struct builtincmd builtintab[] = {
 /*
  * Search the table of builtin commands.
  */
-static struct builtincmd *
+static const struct builtincmd *
 find_builtin(const char *name)
 {
-        struct builtincmd *bp;
+        const struct builtincmd *bp;
 
         bp = bsearch(
                 name, builtintab, ARRAY_SIZE(builtintab), sizeof(builtintab[0]),
@@ -12093,11 +12091,7 @@ ash_command_name(int i)
         int n;
 
         if (/*i >= 0 &&*/ i < ARRAY_SIZE(builtintab))
-#if ENABLE_PLATFORM_MINGW32
                 return builtintab[i].name;
-#else
-                return builtintab[i].name + 1;
-#endif
         i -= ARRAY_SIZE(builtintab);
 
         for (n = 0; n < CMDTABLESIZE; n++) {
@@ -14316,12 +14310,12 @@ decode_dollar_squote(void)
 {
         static const char C_escapes[] ALIGN1 = "nrbtfav""x\\01234567";
         int c, cnt;
-        char *p;
         char buf[4];
 
         c = pgetc();
-        p = strchr(C_escapes, c);
-        if (p) {
+        if (strchr(C_escapes, c)) {
+                char *p;
+
                 buf[0] = c;
                 p = buf;
                 cnt = 3;
@@ -15815,11 +15809,7 @@ helpcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
                 "------------------\n");
         for (col = 0, i = 0; i < ARRAY_SIZE(builtintab); i++) {
                 col += out1fmt("%c%s", ((col == 0) ? '\t' : ' '),
-#if ENABLE_PLATFORM_MINGW32
                                         builtintab[i].name);
-#else
-                                        builtintab[i].name + 1);
-#endif
                 if (col > 60) {
                         out1fmt("\n");
                         col = 0;
diff --git a/util-linux/fdisk.c b/util-linux/fdisk.c
index 6611d3954..5ab350c74 100644
--- a/util-linux/fdisk.c
+++ b/util-linux/fdisk.c
@@ -93,7 +93,7 @@
 
 //usage:#define fdisk_trivial_usage
 //usage:       "[-ul" IF_FEATURE_FDISK_BLKSIZE("s") "] "
-//usage:       "[-C CYLINDERS] [-H HEADS] [-S SECTORS] [-b SSZ] DISK"
+//usage:       "[-C CYLINDERS] [-H HEADS] [-S SECTORS] [-b SSZ] [-t PARTTYPE] DISK"
 //usage:#define fdisk_full_usage "\n\n"
 //usage:       "Change partition table\n"
 //usage:     "\n        -u              Start and End are in sectors (instead of cylinders)"
@@ -104,6 +104,7 @@
 //but in fact, util-linux 2.41.1 shows the size in KILOBYTES!
 //usage:        )
 //usage:     "\n        -b 2048         (for certain MO disks) use 2048-byte sectors"
+//usage:     "\n        -T PARTTYPE     Force 'dos' partition if 'gpt' also present"
 //usage:     "\n        -C CYLINDERS    Set number of cylinders/heads/sectors"
 //usage:     "\n        -H HEADS        Typically 255"
 //usage:     "\n        -S SECTORS      Typically 63"
@@ -186,7 +187,8 @@ enum {
         OPT_l = 1 << 3,
         OPT_S = 1 << 4,
         OPT_u = 1 << 5,
-        OPT_s = (1 << 6) * ENABLE_FEATURE_FDISK_BLKSIZE,
+        OPT_t = 1 << 6,
+        OPT_s = (1 << 7) * ENABLE_FEATURE_FDISK_BLKSIZE,
 };
 #define USER_SET_SECTOR_SIZE (option_mask32 & OPT_b)
 #define NOWARN_OPT_ls        (!ENABLE_FEATURE_FDISK_WRITABLE || (option_mask32 & (OPT_l|OPT_s)))
@@ -464,6 +466,7 @@ struct globals {
         sector_t extended_offset;       /* offset of link pointers */
         sector_t total_number_of_sectors;
 
+        const char *opt_t;
 #if ENABLE_FEATURE_GPT_LABEL
         struct gpt_header *gpt_hdr;
         char *gpt_part_array;
@@ -1209,7 +1212,7 @@ static void
 warn_cylinders(void)
 {
         if (LABEL_IS_DOS && g_cylinders > 1024 && !NOWARN_OPT_ls)
-                printf("\n"
+                printf(
 "The number of cylinders for this disk is set to %u.\n"
 "There is nothing wrong with that, but this is larger than 1024,\n"
 "and could in certain setups cause problems with:\n"
@@ -3064,10 +3067,14 @@ int fdisk_main(int argc UNUSED_PARAM, char **argv)
 
         close_dev_fd(); /* needed: fd 3 must not stay closed */
 
-        opt = getopt32(argv, "^" "b:+C:+H:+lS:+u"IF_FEATURE_FDISK_BLKSIZE("s")"\0"
+        //G.opt_t = NULL;
+        opt = getopt32(argv, "^" "b:+C:+H:+lS:+ut:"IF_FEATURE_FDISK_BLKSIZE("s")"\0"
                 /* among -s and -l, the last one takes precedence */
                 IF_FEATURE_FDISK_BLKSIZE("s-l:l-s"),
-                &sector_size, &user_cylinders, &user_heads, &user_sectors);
+                &sector_size, // -b
+                &user_cylinders, &user_heads, &user_sectors, //-CHS
+                &G.opt_t
+        );
         argv += optind;
 
 #if ENABLE_FEATURE_FDISK_BLKSIZE
diff --git a/util-linux/fdisk_gpt.c b/util-linux/fdisk_gpt.c
index c085af79c..696b4937c 100644
--- a/util-linux/fdisk_gpt.c
+++ b/util-linux/fdisk_gpt.c
@@ -150,12 +150,13 @@ check_gpt_label(void)
         struct pte pe;
         uint32_t crc;
 
+        current_label_type = LABEL_DOS;
+
         /* LBA 0 contains the legacy MBR */
 
         if (!valid_part_table_flag(MBRbuffer)
          || first->sys_ind != LEGACY_GPT_TYPE
         ) {
-                current_label_type = LABEL_DOS;
                 return 0;
         }
 
@@ -165,7 +166,6 @@ check_gpt_label(void)
         G.gpt_hdr = (void *)pe.sectorbuffer;
 
         if (G.gpt_hdr->magic != SWAP_LE64(GPT_MAGIC)) {
-                current_label_type = LABEL_DOS;
                 return 0;
         }
 
@@ -188,7 +188,6 @@ check_gpt_label(void)
          || SWAP_LE32(G.gpt_hdr->hdr_size) > sector_size
         ) {
                 puts("\nwarning: can't parse GPT disklabel");
-                current_label_type = LABEL_DOS;
                 return 0;
         }
 
@@ -204,10 +203,15 @@ check_gpt_label(void)
                 puts("\nwarning: GPT array CRC is invalid");
         }
 
-        puts("Found valid GPT with protective MBR; using GPT");
+        fputs_stdout("Found valid GPT with protective MBR; ");
 
-        current_label_type = LABEL_GPT;
-        return 1;
+        if (!G.opt_t || strcasecmp(G.opt_t, "gpt") == 0) {
+                puts("using GPT (-t dos to override)");
+                current_label_type = LABEL_GPT;
+                return 1;
+        }
+        puts("NOT using it (-t specified)");
+        return 0;
 }
 
 #endif /* GPT_LABEL */