Increase FONT_MAXNO from 0x2f to 0x40, to ensure the fonts[] array
[u/mdw/putty] / telnet.c
index b8ce417..6a56da7 100644 (file)
--- a/telnet.c
+++ b/telnet.c
@@ -1,6 +1,10 @@
-#include <windows.h>
+/*
+ * Telnet backend.
+ */
+
 #include <stdio.h>
 #include <stdlib.h>
+#include <limits.h>
 
 #include "putty.h"
 
 #define TRUE 1
 #endif
 
-static Socket s = NULL;
-
-static void *frontend;
-static int telnet_term_width, telnet_term_height;
-
 #define        IAC     255                    /* interpret as command: */
 #define        DONT    254                    /* you are not to use option */
 #define        DO      253                    /* please, you use option */
@@ -38,47 +37,65 @@ static int telnet_term_width, telnet_term_height;
 #define SUSP    237                   /* Suspend process */
 #define xEOF    236                   /* End of file: EOF is already used... */
 
-#define TELOPT_BINARY  0              /* 8-bit data path */
-#define TELOPT_ECHO    1              /* echo */
-#define        TELOPT_RCP      2              /* prepare to reconnect */
-#define        TELOPT_SGA      3              /* suppress go ahead */
-#define        TELOPT_NAMS     4              /* approximate message size */
-#define        TELOPT_STATUS   5              /* give status */
-#define        TELOPT_TM       6              /* timing mark */
-#define        TELOPT_RCTE     7              /* remote controlled transmission and echo */
-#define TELOPT_NAOL    8              /* negotiate about output line width */
-#define TELOPT_NAOP    9              /* negotiate about output page size */
-#define TELOPT_NAOCRD  10             /* negotiate about CR disposition */
-#define TELOPT_NAOHTS  11             /* negotiate about horizontal tabstops */
-#define TELOPT_NAOHTD  12             /* negotiate about horizontal tab disposition */
-#define TELOPT_NAOFFD  13             /* negotiate about formfeed disposition */
-#define TELOPT_NAOVTS  14             /* negotiate about vertical tab stops */
-#define TELOPT_NAOVTD  15             /* negotiate about vertical tab disposition */
-#define TELOPT_NAOLFD  16             /* negotiate about output LF disposition */
-#define TELOPT_XASCII  17             /* extended ascic character set */
-#define        TELOPT_LOGOUT   18             /* force logout */
-#define        TELOPT_BM       19             /* byte macro */
-#define        TELOPT_DET      20             /* data entry terminal */
-#define        TELOPT_SUPDUP   21             /* supdup protocol */
-#define        TELOPT_SUPDUPOUTPUT 22         /* supdup output */
-#define        TELOPT_SNDLOC   23             /* send location */
-#define        TELOPT_TTYPE    24             /* terminal type */
-#define        TELOPT_EOR      25             /* end or record */
-#define        TELOPT_TUID     26             /* TACACS user identification */
-#define        TELOPT_OUTMRK   27             /* output marking */
-#define        TELOPT_TTYLOC   28             /* terminal location number */
-#define        TELOPT_3270REGIME 29           /* 3270 regime */
-#define        TELOPT_X3PAD    30             /* X.3 PAD */
-#define        TELOPT_NAWS     31             /* window size */
-#define        TELOPT_TSPEED   32             /* terminal speed */
-#define        TELOPT_LFLOW    33             /* remote flow control */
-#define TELOPT_LINEMODE        34             /* Linemode option */
-#define TELOPT_XDISPLOC        35             /* X Display Location */
-#define TELOPT_OLD_ENVIRON 36         /* Old - Environment variables */
-#define        TELOPT_AUTHENTICATION 37       /* Authenticate */
-#define        TELOPT_ENCRYPT  38             /* Encryption option */
-#define TELOPT_NEW_ENVIRON 39         /* New - Environment variables */
-#define        TELOPT_EXOPL    255            /* extended-options-list */
+#define TELOPTS(X) \
+    X(BINARY, 0)                       /* 8-bit data path */ \
+    X(ECHO, 1)                         /* echo */ \
+    X(RCP, 2)                          /* prepare to reconnect */ \
+    X(SGA, 3)                          /* suppress go ahead */ \
+    X(NAMS, 4)                         /* approximate message size */ \
+    X(STATUS, 5)                       /* give status */ \
+    X(TM, 6)                           /* timing mark */ \
+    X(RCTE, 7)                         /* remote controlled transmission and echo */ \
+    X(NAOL, 8)                         /* negotiate about output line width */ \
+    X(NAOP, 9)                         /* negotiate about output page size */ \
+    X(NAOCRD, 10)                      /* negotiate about CR disposition */ \
+    X(NAOHTS, 11)                      /* negotiate about horizontal tabstops */ \
+    X(NAOHTD, 12)                      /* negotiate about horizontal tab disposition */ \
+    X(NAOFFD, 13)                      /* negotiate about formfeed disposition */ \
+    X(NAOVTS, 14)                      /* negotiate about vertical tab stops */ \
+    X(NAOVTD, 15)                      /* negotiate about vertical tab disposition */ \
+    X(NAOLFD, 16)                      /* negotiate about output LF disposition */ \
+    X(XASCII, 17)                      /* extended ascic character set */ \
+    X(LOGOUT, 18)                      /* force logout */ \
+    X(BM, 19)                          /* byte macro */ \
+    X(DET, 20)                         /* data entry terminal */ \
+    X(SUPDUP, 21)                      /* supdup protocol */ \
+    X(SUPDUPOUTPUT, 22)                /* supdup output */ \
+    X(SNDLOC, 23)                      /* send location */ \
+    X(TTYPE, 24)                       /* terminal type */ \
+    X(EOR, 25)                         /* end or record */ \
+    X(TUID, 26)                        /* TACACS user identification */ \
+    X(OUTMRK, 27)                      /* output marking */ \
+    X(TTYLOC, 28)                      /* terminal location number */ \
+    X(3270REGIME, 29)                  /* 3270 regime */ \
+    X(X3PAD, 30)                       /* X.3 PAD */ \
+    X(NAWS, 31)                        /* window size */ \
+    X(TSPEED, 32)                      /* terminal speed */ \
+    X(LFLOW, 33)                       /* remote flow control */ \
+    X(LINEMODE, 34)                    /* Linemode option */ \
+    X(XDISPLOC, 35)                    /* X Display Location */ \
+    X(OLD_ENVIRON, 36)                 /* Old - Environment variables */ \
+    X(AUTHENTICATION, 37)              /* Authenticate */ \
+    X(ENCRYPT, 38)                     /* Encryption option */ \
+    X(NEW_ENVIRON, 39)                 /* New - Environment variables */ \
+    X(TN3270E, 40)                     /* TN3270 enhancements */ \
+    X(XAUTH, 41)                       \
+    X(CHARSET, 42)                     /* Character set */ \
+    X(RSP, 43)                         /* Remote serial port */ \
+    X(COM_PORT_OPTION, 44)             /* Com port control */ \
+    X(SLE, 45)                         /* Suppress local echo */ \
+    X(STARTTLS, 46)                    /* Start TLS */ \
+    X(KERMIT, 47)                      /* Automatic Kermit file transfer */ \
+    X(SEND_URL, 48)                    \
+    X(FORWARD_X, 49)                   \
+    X(PRAGMA_LOGON, 138)               \
+    X(SSPI_LOGON, 139)                 \
+    X(PRAGMA_HEARTBEAT, 140)           \
+    X(EXOPL, 255)                      /* extended-options-list */
+
+#define telnet_enum(x,y) TELOPT_##x = y,
+enum { TELOPTS(telnet_enum) dummy=0 };
+#undef telnet_enum
 
 #define        TELQUAL_IS      0              /* option is... */
 #define        TELQUAL_SEND    1              /* send option */
@@ -92,171 +109,185 @@ static int telnet_term_width, telnet_term_height;
 #define LF 10
 #define NUL 0
 
-#define iswritable(x) ( (x) != IAC && (x) != CR )
+#define iswritable(x) \
+       ( (x) != IAC && \
+             (telnet->opt_states[o_we_bin.index] == ACTIVE || (x) != CR))
 
 static char *telopt(int opt)
 {
-#define i(x) if (opt == TELOPT_ ## x) return #x;
-    i(BINARY);
-    i(ECHO);
-    i(RCP);
-    i(SGA);
-    i(NAMS);
-    i(STATUS);
-    i(TM);
-    i(RCTE);
-    i(NAOL);
-    i(NAOP);
-    i(NAOCRD);
-    i(NAOHTS);
-    i(NAOHTD);
-    i(NAOFFD);
-    i(NAOVTS);
-    i(NAOVTD);
-    i(NAOLFD);
-    i(XASCII);
-    i(LOGOUT);
-    i(BM);
-    i(DET);
-    i(SUPDUP);
-    i(SUPDUPOUTPUT);
-    i(SNDLOC);
-    i(TTYPE);
-    i(EOR);
-    i(TUID);
-    i(OUTMRK);
-    i(TTYLOC);
-    i(X3PAD);
-    i(NAWS);
-    i(TSPEED);
-    i(LFLOW);
-    i(LINEMODE);
-    i(XDISPLOC);
-    i(OLD_ENVIRON);
-    i(AUTHENTICATION);
-    i(ENCRYPT);
-    i(NEW_ENVIRON);
-    i(EXOPL);
-#undef i
-    return "<unknown>";
+#define telnet_str(x,y) case TELOPT_##x: return #x;
+    switch (opt) {
+       TELOPTS(telnet_str)
+      default:
+       return "<unknown>";
+    }
+#undef telnet_str
 }
 
-static void telnet_size(void);
+static void telnet_size(void *handle, int width, int height);
 
 struct Opt {
     int send;                         /* what we initially send */
     int nsend;                        /* -ve send if requested to stop it */
     int ack, nak;                     /* +ve and -ve acknowledgements */
     int option;                               /* the option code */
+    int index;                        /* index into telnet->opt_states[] */
     enum {
        REQUESTED, ACTIVE, INACTIVE, REALLY_INACTIVE
-    } state;
+    } initial_state;
 };
 
-static struct Opt o_naws =
-    { WILL, WONT, DO, DONT, TELOPT_NAWS, REQUESTED };
-static struct Opt o_tspeed =
-    { WILL, WONT, DO, DONT, TELOPT_TSPEED, REQUESTED };
-static struct Opt o_ttype =
-    { WILL, WONT, DO, DONT, TELOPT_TTYPE, REQUESTED };
-static struct Opt o_oenv = { WILL, WONT, DO, DONT, TELOPT_OLD_ENVIRON,
-    INACTIVE
-};
-static struct Opt o_nenv = { WILL, WONT, DO, DONT, TELOPT_NEW_ENVIRON,
-    REQUESTED
+enum {
+    OPTINDEX_NAWS,
+    OPTINDEX_TSPEED,
+    OPTINDEX_TTYPE,
+    OPTINDEX_OENV,
+    OPTINDEX_NENV,
+    OPTINDEX_ECHO,
+    OPTINDEX_WE_SGA,
+    OPTINDEX_THEY_SGA,
+    OPTINDEX_WE_BIN,
+    OPTINDEX_THEY_BIN,
+    NUM_OPTS
 };
-static struct Opt o_echo =
-    { DO, DONT, WILL, WONT, TELOPT_ECHO, REQUESTED };
-static struct Opt o_we_sga =
-    { WILL, WONT, DO, DONT, TELOPT_SGA, REQUESTED };
-static struct Opt o_they_sga =
-    { DO, DONT, WILL, WONT, TELOPT_SGA, REQUESTED };
-
-static struct Opt *opts[] = {
+
+static const struct Opt o_naws =
+    { WILL, WONT, DO, DONT, TELOPT_NAWS, OPTINDEX_NAWS, REQUESTED };
+static const struct Opt o_tspeed =
+    { WILL, WONT, DO, DONT, TELOPT_TSPEED, OPTINDEX_TSPEED, REQUESTED };
+static const struct Opt o_ttype =
+    { WILL, WONT, DO, DONT, TELOPT_TTYPE, OPTINDEX_TTYPE, REQUESTED };
+static const struct Opt o_oenv =
+    { WILL, WONT, DO, DONT, TELOPT_OLD_ENVIRON, OPTINDEX_OENV, INACTIVE };
+static const struct Opt o_nenv =
+    { WILL, WONT, DO, DONT, TELOPT_NEW_ENVIRON, OPTINDEX_NENV, REQUESTED };
+static const struct Opt o_echo =
+    { DO, DONT, WILL, WONT, TELOPT_ECHO, OPTINDEX_ECHO, REQUESTED };
+static const struct Opt o_we_sga =
+    { WILL, WONT, DO, DONT, TELOPT_SGA, OPTINDEX_WE_SGA, REQUESTED };
+static const struct Opt o_they_sga =
+    { DO, DONT, WILL, WONT, TELOPT_SGA, OPTINDEX_THEY_SGA, REQUESTED };
+static const struct Opt o_we_bin =
+    { WILL, WONT, DO, DONT, TELOPT_BINARY, OPTINDEX_WE_BIN, INACTIVE };
+static const struct Opt o_they_bin =
+    { DO, DONT, WILL, WONT, TELOPT_BINARY, OPTINDEX_THEY_BIN, INACTIVE };
+
+static const struct Opt *const opts[] = {
     &o_naws, &o_tspeed, &o_ttype, &o_oenv, &o_nenv, &o_echo,
-    &o_we_sga, &o_they_sga, NULL
+    &o_we_sga, &o_they_sga, &o_we_bin, &o_they_bin, NULL
 };
 
+typedef struct telnet_tag {
+    const struct plug_function_table *fn;
+    /* the above field _must_ be first in the structure */
+
+    Socket s;
+    int closed_on_socket_error;
+
+    void *frontend;
+    void *ldisc;
+    int term_width, term_height;
+
+    int opt_states[NUM_OPTS];
+
+    int echoing, editing;
+    int activated;
+    int bufsize;
+    int in_synch;
+    int sb_opt, sb_len;
+    unsigned char *sb_buf;
+    int sb_size;
+
+    enum {
+       TOP_LEVEL, SEENIAC, SEENWILL, SEENWONT, SEENDO, SEENDONT,
+           SEENSB, SUBNEGOT, SUBNEG_IAC, SEENCR
+    } state;
+
+    Conf *conf;
+
+    Pinger pinger;
+} *Telnet;
+
 #define TELNET_MAX_BACKLOG 4096
 
-static int echoing = TRUE, editing = TRUE;
-static int activated = FALSE;
-static int telnet_bufsize;
-static int in_synch;
-static int sb_opt, sb_len;
-static char *sb_buf = NULL;
-static int sb_size = 0;
 #define SB_DELTA 1024
 
-static void c_write1(int c)
+static void c_write(Telnet telnet, char *buf, int len)
 {
     int backlog;
-    char cc = (char) c;
-    backlog = from_backend(frontend, 0, &cc, 1);
-    sk_set_frozen(s, backlog > TELNET_MAX_BACKLOG);
+    backlog = from_backend(telnet->frontend, 0, buf, len);
+    sk_set_frozen(telnet->s, backlog > TELNET_MAX_BACKLOG);
 }
 
-static void log_option(char *sender, int cmd, int option)
+static void log_option(Telnet telnet, char *sender, int cmd, int option)
 {
-    char buf[50];
-    sprintf(buf, "%s:\t%s %s", sender,
-           (cmd == WILL ? "WILL" : cmd == WONT ? "WONT" :
-            cmd == DO ? "DO" : cmd == DONT ? "DONT" : "<??>"),
-           telopt(option));
-    logevent(buf);
+    char *buf;
+    /*
+     * The strange-looking "<?""?>" below is there to avoid a
+     * trigraph - a double question mark followed by > maps to a
+     * closing brace character!
+     */
+    buf = dupprintf("%s:\t%s %s", sender,
+                   (cmd == WILL ? "WILL" : cmd == WONT ? "WONT" :
+                    cmd == DO ? "DO" : cmd == DONT ? "DONT" : "<?""?>"),
+                   telopt(option));
+    logevent(telnet->frontend, buf);
+    sfree(buf);
 }
 
-static void send_opt(int cmd, int option)
+static void send_opt(Telnet telnet, int cmd, int option)
 {
     unsigned char b[3];
 
     b[0] = IAC;
     b[1] = cmd;
     b[2] = option;
-    telnet_bufsize = sk_write(s, b, 3);
-    log_option("client", cmd, option);
+    telnet->bufsize = sk_write(telnet->s, (char *)b, 3);
+    log_option(telnet, "client", cmd, option);
 }
 
-static void deactivate_option(struct Opt *o)
+static void deactivate_option(Telnet telnet, const struct Opt *o)
 {
-    if (o->state == REQUESTED || o->state == ACTIVE)
-       send_opt(o->nsend, o->option);
-    o->state = REALLY_INACTIVE;
+    if (telnet->opt_states[o->index] == REQUESTED ||
+       telnet->opt_states[o->index] == ACTIVE)
+       send_opt(telnet, o->nsend, o->option);
+    telnet->opt_states[o->index] = REALLY_INACTIVE;
 }
 
 /*
  * Generate side effects of enabling or disabling an option.
  */
-static void option_side_effects(struct Opt *o, int enabled)
+static void option_side_effects(Telnet telnet, const struct Opt *o, int enabled)
 {
     if (o->option == TELOPT_ECHO && o->send == DO)
-       echoing = !enabled;
+       telnet->echoing = !enabled;
     else if (o->option == TELOPT_SGA && o->send == DO)
-       editing = !enabled;
-    ldisc_send(NULL, 0, 0);           /* cause ldisc to notice the change */
+       telnet->editing = !enabled;
+    if (telnet->ldisc)                /* cause ldisc to notice the change */
+       ldisc_send(telnet->ldisc, NULL, 0, 0);
 
     /* Ensure we get the minimum options */
-    if (!activated) {
-       if (o_echo.state == INACTIVE) {
-           o_echo.state = REQUESTED;
-           send_opt(o_echo.send, o_echo.option);
+    if (!telnet->activated) {
+       if (telnet->opt_states[o_echo.index] == INACTIVE) {
+           telnet->opt_states[o_echo.index] = REQUESTED;
+           send_opt(telnet, o_echo.send, o_echo.option);
        }
-       if (o_we_sga.state == INACTIVE) {
-           o_we_sga.state = REQUESTED;
-           send_opt(o_we_sga.send, o_we_sga.option);
+       if (telnet->opt_states[o_we_sga.index] == INACTIVE) {
+           telnet->opt_states[o_we_sga.index] = REQUESTED;
+           send_opt(telnet, o_we_sga.send, o_we_sga.option);
        }
-       if (o_they_sga.state == INACTIVE) {
-           o_they_sga.state = REQUESTED;
-           send_opt(o_they_sga.send, o_they_sga.option);
+       if (telnet->opt_states[o_they_sga.index] == INACTIVE) {
+           telnet->opt_states[o_they_sga.index] = REQUESTED;
+           send_opt(telnet, o_they_sga.send, o_they_sga.option);
        }
-       activated = TRUE;
+       telnet->activated = TRUE;
     }
 }
 
-static void activate_option(struct Opt *o)
+static void activate_option(Telnet telnet, const struct Opt *o)
 {
     if (o->send == WILL && o->option == TELOPT_NAWS)
-       telnet_size();
+       telnet_size(telnet, telnet->term_width, telnet->term_height);
     if (o->send == WILL &&
        (o->option == TELOPT_NEW_ENVIRON ||
         o->option == TELOPT_OLD_ENVIRON)) {
@@ -264,56 +295,56 @@ static void activate_option(struct Opt *o)
         * We may only have one kind of ENVIRON going at a time.
         * This is a hack, but who cares.
         */
-       deactivate_option(o->option ==
+       deactivate_option(telnet, o->option ==
                          TELOPT_NEW_ENVIRON ? &o_oenv : &o_nenv);
     }
-    option_side_effects(o, 1);
+    option_side_effects(telnet, o, 1);
 }
 
-static void refused_option(struct Opt *o)
+static void refused_option(Telnet telnet, const struct Opt *o)
 {
     if (o->send == WILL && o->option == TELOPT_NEW_ENVIRON &&
-       o_oenv.state == INACTIVE) {
-       send_opt(WILL, TELOPT_OLD_ENVIRON);
-       o_oenv.state = REQUESTED;
+       telnet->opt_states[o_oenv.index] == INACTIVE) {
+       send_opt(telnet, WILL, TELOPT_OLD_ENVIRON);
+       telnet->opt_states[o_oenv.index] = REQUESTED;
     }
-    option_side_effects(o, 0);
+    option_side_effects(telnet, o, 0);
 }
 
-static void proc_rec_opt(int cmd, int option)
+static void proc_rec_opt(Telnet telnet, int cmd, int option)
 {
-    struct Opt **o;
+    const struct Opt *const *o;
 
-    log_option("server", cmd, option);
+    log_option(telnet, "server", cmd, option);
     for (o = opts; *o; o++) {
        if ((*o)->option == option && (*o)->ack == cmd) {
-           switch ((*o)->state) {
+           switch (telnet->opt_states[(*o)->index]) {
              case REQUESTED:
-               (*o)->state = ACTIVE;
-               activate_option(*o);
+               telnet->opt_states[(*o)->index] = ACTIVE;
+               activate_option(telnet, *o);
                break;
              case ACTIVE:
                break;
              case INACTIVE:
-               (*o)->state = ACTIVE;
-               send_opt((*o)->send, option);
-               activate_option(*o);
+               telnet->opt_states[(*o)->index] = ACTIVE;
+               send_opt(telnet, (*o)->send, option);
+               activate_option(telnet, *o);
                break;
              case REALLY_INACTIVE:
-               send_opt((*o)->nsend, option);
+               send_opt(telnet, (*o)->nsend, option);
                break;
            }
            return;
        } else if ((*o)->option == option && (*o)->nak == cmd) {
-           switch ((*o)->state) {
+           switch (telnet->opt_states[(*o)->index]) {
              case REQUESTED:
-               (*o)->state = INACTIVE;
-               refused_option(*o);
+               telnet->opt_states[(*o)->index] = INACTIVE;
+               refused_option(telnet, *o);
                break;
              case ACTIVE:
-               (*o)->state = INACTIVE;
-               send_opt((*o)->nsend, option);
-               option_side_effects(*o, 0);
+               telnet->opt_states[(*o)->index] = INACTIVE;
+               send_opt(telnet, (*o)->nsend, option);
+               option_side_effects(telnet, *o, 0);
                break;
              case INACTIVE:
              case REALLY_INACTIVE:
@@ -324,69 +355,80 @@ static void proc_rec_opt(int cmd, int option)
     }
     /*
      * If we reach here, the option was one we weren't prepared to
-     * cope with. So send a negative ack.
+     * cope with. If the request was positive (WILL or DO), we send
+     * a negative ack to indicate refusal. If the request was
+     * negative (WONT / DONT), we must do nothing.
      */
-    send_opt((cmd == WILL ? DONT : WONT), option);
+    if (cmd == WILL || cmd == DO)
+        send_opt(telnet, (cmd == WILL ? DONT : WONT), option);
 }
 
-static void process_subneg(void)
+static void process_subneg(Telnet telnet)
 {
-    unsigned char b[2048], *p, *q;
-    int var, value, n;
-    char *e;
+    unsigned char *b, *p, *q;
+    int var, value, n, bsize;
+    char *e, *eval, *ekey, *user;
 
-    switch (sb_opt) {
+    switch (telnet->sb_opt) {
       case TELOPT_TSPEED:
-       if (sb_len == 1 && sb_buf[0] == TELQUAL_SEND) {
-           char logbuf[sizeof(cfg.termspeed) + 80];
+       if (telnet->sb_len == 1 && telnet->sb_buf[0] == TELQUAL_SEND) {
+           char *logbuf;
+           char *termspeed = conf_get_str(telnet->conf, CONF_termspeed);
+           b = snewn(20 + strlen(termspeed), unsigned char);
            b[0] = IAC;
            b[1] = SB;
            b[2] = TELOPT_TSPEED;
            b[3] = TELQUAL_IS;
-           strcpy(b + 4, cfg.termspeed);
-           n = 4 + strlen(cfg.termspeed);
+           strcpy((char *)(b + 4), termspeed);
+           n = 4 + strlen(termspeed);
            b[n] = IAC;
            b[n + 1] = SE;
-           telnet_bufsize = sk_write(s, b, n + 2);
-           logevent("server:\tSB TSPEED SEND");
-           sprintf(logbuf, "client:\tSB TSPEED IS %s", cfg.termspeed);
-           logevent(logbuf);
+           telnet->bufsize = sk_write(telnet->s, (char *)b, n + 2);
+           logevent(telnet->frontend, "server:\tSB TSPEED SEND");
+           logbuf = dupprintf("client:\tSB TSPEED IS %s", termspeed);
+           logevent(telnet->frontend, logbuf);
+           sfree(logbuf);
+           sfree(b);
        } else
-           logevent("server:\tSB TSPEED <something weird>");
+           logevent(telnet->frontend, "server:\tSB TSPEED <something weird>");
        break;
       case TELOPT_TTYPE:
-       if (sb_len == 1 && sb_buf[0] == TELQUAL_SEND) {
-           char logbuf[sizeof(cfg.termtype) + 80];
+       if (telnet->sb_len == 1 && telnet->sb_buf[0] == TELQUAL_SEND) {
+           char *logbuf;
+           char *termtype = conf_get_str(telnet->conf, CONF_termtype);
+           b = snewn(20 + strlen(termtype), unsigned char);
            b[0] = IAC;
            b[1] = SB;
            b[2] = TELOPT_TTYPE;
            b[3] = TELQUAL_IS;
-           for (n = 0; cfg.termtype[n]; n++)
-               b[n + 4] = (cfg.termtype[n] >= 'a'
-                           && cfg.termtype[n] <=
-                           'z' ? cfg.termtype[n] + 'A' -
-                           'a' : cfg.termtype[n]);
+           for (n = 0; termtype[n]; n++)
+               b[n + 4] = (termtype[n] >= 'a' && termtype[n] <= 'z' ?
+                           termtype[n] + 'A' - 'a' :
+                           termtype[n]);
            b[n + 4] = IAC;
            b[n + 5] = SE;
-           telnet_bufsize = sk_write(s, b, n + 6);
+           telnet->bufsize = sk_write(telnet->s, (char *)b, n + 6);
            b[n + 4] = 0;
-           logevent("server:\tSB TTYPE SEND");
-           sprintf(logbuf, "client:\tSB TTYPE IS %s", b + 4);
-           logevent(logbuf);
+           logevent(telnet->frontend, "server:\tSB TTYPE SEND");
+           logbuf = dupprintf("client:\tSB TTYPE IS %s", b + 4);
+           logevent(telnet->frontend, logbuf);
+           sfree(logbuf);
+           sfree(b);
        } else
-           logevent("server:\tSB TTYPE <something weird>\r\n");
+           logevent(telnet->frontend, "server:\tSB TTYPE <something weird>\r\n");
        break;
       case TELOPT_OLD_ENVIRON:
       case TELOPT_NEW_ENVIRON:
-       p = sb_buf;
-       q = p + sb_len;
+       p = telnet->sb_buf;
+       q = p + telnet->sb_len;
        if (p < q && *p == TELQUAL_SEND) {
-           char logbuf[50];
+           char *logbuf;
            p++;
-           sprintf(logbuf, "server:\tSB %s SEND", telopt(sb_opt));
-           logevent(logbuf);
-           if (sb_opt == TELOPT_OLD_ENVIRON) {
-               if (cfg.rfc_environ) {
+           logbuf = dupprintf("server:\tSB %s SEND", telopt(telnet->sb_opt));
+           logevent(telnet->frontend, logbuf);
+           sfree(logbuf);
+           if (telnet->sb_opt == TELOPT_OLD_ENVIRON) {
+               if (conf_get_int(telnet->conf, CONF_rfc_environ)) {
                    value = RFC_VALUE;
                    var = RFC_VAR;
                } else {
@@ -414,66 +456,106 @@ static void process_subneg(void)
                value = RFC_VALUE;
                var = RFC_VAR;
            }
+           bsize = 20;
+           for (eval = conf_get_str_strs(telnet->conf, CONF_environmt,
+                                        NULL, &ekey);
+                eval != NULL;
+                eval = conf_get_str_strs(telnet->conf, CONF_environmt,
+                                        ekey, &ekey))
+                bsize += strlen(ekey) + strlen(eval) + 2;
+           user = get_remote_username(telnet->conf);
+           if (user)
+               bsize += 6 + strlen(user);
+
+           b = snewn(bsize, unsigned char);
            b[0] = IAC;
            b[1] = SB;
-           b[2] = sb_opt;
+           b[2] = telnet->sb_opt;
            b[3] = TELQUAL_IS;
            n = 4;
-           e = cfg.environmt;
-           while (*e) {
+           for (eval = conf_get_str_strs(telnet->conf, CONF_environmt,
+                                        NULL, &ekey);
+                eval != NULL;
+                eval = conf_get_str_strs(telnet->conf, CONF_environmt,
+                                        ekey, &ekey)) {
                b[n++] = var;
-               while (*e && *e != '\t')
-                   b[n++] = *e++;
-               if (*e == '\t')
-                   e++;
+               for (e = ekey; *e; e++)
+                   b[n++] = *e;
                b[n++] = value;
-               while (*e)
-                   b[n++] = *e++;
-               e++;
+               for (e = eval; *e; e++)
+                   b[n++] = *e;
            }
-           if (*cfg.username) {
+           if (user) {
                b[n++] = var;
                b[n++] = 'U';
                b[n++] = 'S';
                b[n++] = 'E';
                b[n++] = 'R';
                b[n++] = value;
-               e = cfg.username;
-               while (*e)
-                   b[n++] = *e++;
+               for (e = user; *e; e++)
+                   b[n++] = *e;
            }
            b[n++] = IAC;
            b[n++] = SE;
-           telnet_bufsize = sk_write(s, b, n);
-           sprintf(logbuf, "client:\tSB %s IS %s", telopt(sb_opt),
-                   n == 6 ? "<nothing>" : "<stuff>");
-           logevent(logbuf);
+           telnet->bufsize = sk_write(telnet->s, (char *)b, n);
+           if (n == 6) {
+               logbuf = dupprintf("client:\tSB %s IS <nothing>",
+                                  telopt(telnet->sb_opt));
+               logevent(telnet->frontend, logbuf);
+               sfree(logbuf);
+           } else {
+               logbuf = dupprintf("client:\tSB %s IS:",
+                                  telopt(telnet->sb_opt));
+               logevent(telnet->frontend, logbuf);
+               sfree(logbuf);
+               for (eval = conf_get_str_strs(telnet->conf, CONF_environmt,
+                                            NULL, &ekey);
+                    eval != NULL;
+                    eval = conf_get_str_strs(telnet->conf, CONF_environmt,
+                                            ekey, &ekey)) {
+                   logbuf = dupprintf("\t%s=%s", ekey, eval);
+                   logevent(telnet->frontend, logbuf);
+                   sfree(logbuf);
+               }
+               if (user) {
+                   logbuf = dupprintf("\tUSER=%s", user);
+                   logevent(telnet->frontend, logbuf);
+                   sfree(logbuf);
+               }
+           }
+           sfree(b);
+           sfree(user);
        }
        break;
     }
 }
 
-static enum {
-    TOP_LEVEL, SEENIAC, SEENWILL, SEENWONT, SEENDO, SEENDONT,
-    SEENSB, SUBNEGOT, SUBNEG_IAC, SEENCR
-} telnet_state = TOP_LEVEL;
-
-static void do_telnet_read(char *buf, int len)
+static void do_telnet_read(Telnet telnet, char *buf, int len)
 {
+    char *outbuf = NULL;
+    int outbuflen = 0, outbufsize = 0;
+
+#define ADDTOBUF(c) do { \
+    if (outbuflen >= outbufsize) { \
+       outbufsize = outbuflen + 256; \
+        outbuf = sresize(outbuf, outbufsize, char); \
+    } \
+    outbuf[outbuflen++] = (c); \
+} while (0)
 
     while (len--) {
        int c = (unsigned char) *buf++;
 
-       switch (telnet_state) {
+       switch (telnet->state) {
          case TOP_LEVEL:
          case SEENCR:
-           if (c == NUL && telnet_state == SEENCR)
-               telnet_state = TOP_LEVEL;
+           if (c == NUL && telnet->state == SEENCR)
+               telnet->state = TOP_LEVEL;
            else if (c == IAC)
-               telnet_state = SEENIAC;
+               telnet->state = SEENIAC;
            else {
-               if (!in_synch)
-                   c_write1(c);
+               if (!telnet->in_synch)
+                   ADDTOBUF(c);
 
 #if 1
                /* I can't get the F***ing winsock to insert the urgent IAC
@@ -485,116 +567,143 @@ static void do_telnet_read(char *buf, int len)
                 * just stop hiding on the next 0xf2 and hope for the best.
                 */
                else if (c == DM)
-                   in_synch = 0;
+                   telnet->in_synch = 0;
 #endif
-               if (c == CR)
-                   telnet_state = SEENCR;
+               if (c == CR && telnet->opt_states[o_they_bin.index] != ACTIVE)
+                   telnet->state = SEENCR;
                else
-                   telnet_state = TOP_LEVEL;
+                   telnet->state = TOP_LEVEL;
            }
            break;
          case SEENIAC:
            if (c == DO)
-               telnet_state = SEENDO;
+               telnet->state = SEENDO;
            else if (c == DONT)
-               telnet_state = SEENDONT;
+               telnet->state = SEENDONT;
            else if (c == WILL)
-               telnet_state = SEENWILL;
+               telnet->state = SEENWILL;
            else if (c == WONT)
-               telnet_state = SEENWONT;
+               telnet->state = SEENWONT;
            else if (c == SB)
-               telnet_state = SEENSB;
+               telnet->state = SEENSB;
            else if (c == DM) {
-               in_synch = 0;
-               telnet_state = TOP_LEVEL;
+               telnet->in_synch = 0;
+               telnet->state = TOP_LEVEL;
            } else {
                /* ignore everything else; print it if it's IAC */
                if (c == IAC) {
-                   c_write1(c);
+                   ADDTOBUF(c);
                }
-               telnet_state = TOP_LEVEL;
+               telnet->state = TOP_LEVEL;
            }
            break;
          case SEENWILL:
-           proc_rec_opt(WILL, c);
-           telnet_state = TOP_LEVEL;
+           proc_rec_opt(telnet, WILL, c);
+           telnet->state = TOP_LEVEL;
            break;
          case SEENWONT:
-           proc_rec_opt(WONT, c);
-           telnet_state = TOP_LEVEL;
+           proc_rec_opt(telnet, WONT, c);
+           telnet->state = TOP_LEVEL;
            break;
          case SEENDO:
-           proc_rec_opt(DO, c);
-           telnet_state = TOP_LEVEL;
+           proc_rec_opt(telnet, DO, c);
+           telnet->state = TOP_LEVEL;
            break;
          case SEENDONT:
-           proc_rec_opt(DONT, c);
-           telnet_state = TOP_LEVEL;
+           proc_rec_opt(telnet, DONT, c);
+           telnet->state = TOP_LEVEL;
            break;
          case SEENSB:
-           sb_opt = c;
-           sb_len = 0;
-           telnet_state = SUBNEGOT;
+           telnet->sb_opt = c;
+           telnet->sb_len = 0;
+           telnet->state = SUBNEGOT;
            break;
          case SUBNEGOT:
            if (c == IAC)
-               telnet_state = SUBNEG_IAC;
+               telnet->state = SUBNEG_IAC;
            else {
              subneg_addchar:
-               if (sb_len >= sb_size) {
-                   char *newbuf;
-                   sb_size += SB_DELTA;
-                   newbuf = (sb_buf ?
-                             srealloc(sb_buf, sb_size) :
-                             smalloc(sb_size));
-                   if (newbuf)
-                       sb_buf = newbuf;
-                   else
-                       sb_size -= SB_DELTA;
+               if (telnet->sb_len >= telnet->sb_size) {
+                   telnet->sb_size += SB_DELTA;
+                   telnet->sb_buf = sresize(telnet->sb_buf, telnet->sb_size,
+                                            unsigned char);
                }
-               if (sb_len < sb_size)
-                   sb_buf[sb_len++] = c;
-               telnet_state = SUBNEGOT;        /* in case we came here by goto */
+               telnet->sb_buf[telnet->sb_len++] = c;
+               telnet->state = SUBNEGOT;       /* in case we came here by goto */
            }
            break;
          case SUBNEG_IAC:
            if (c != SE)
                goto subneg_addchar;   /* yes, it's a hack, I know, but... */
            else {
-               process_subneg();
-               telnet_state = TOP_LEVEL;
+               process_subneg(telnet);
+               telnet->state = TOP_LEVEL;
            }
            break;
        }
     }
+
+    if (outbuflen)
+       c_write(telnet, outbuf, outbuflen);
+    sfree(outbuf);
 }
 
-static int telnet_closing(Plug plug, char *error_msg, int error_code,
+static void telnet_log(Plug plug, int type, SockAddr addr, int port,
+                      const char *error_msg, int error_code)
+{
+    Telnet telnet = (Telnet) plug;
+    char addrbuf[256], *msg;
+
+    sk_getaddr(addr, addrbuf, lenof(addrbuf));
+
+    if (type == 0)
+       msg = dupprintf("Connecting to %s port %d", addrbuf, port);
+    else
+       msg = dupprintf("Failed to connect to %s: %s", addrbuf, error_msg);
+
+    logevent(telnet->frontend, msg);
+    sfree(msg);
+}
+
+static int telnet_closing(Plug plug, const char *error_msg, int error_code,
                          int calling_back)
 {
-    if (s) {
-        sk_close(s);
-        s = NULL;
+    Telnet telnet = (Telnet) plug;
+
+    /*
+     * We don't implement independent EOF in each direction for Telnet
+     * connections; as soon as we get word that the remote side has
+     * sent us EOF, we wind up the whole connection.
+     */
+
+    if (telnet->s) {
+        sk_close(telnet->s);
+        telnet->s = NULL;
+        if (error_msg)
+            telnet->closed_on_socket_error = TRUE;
+       notify_remote_exit(telnet->frontend);
     }
     if (error_msg) {
-       /* A socket error has occurred. */
-       logevent(error_msg);
-       connection_fatal("%s", error_msg);
-    }                                 /* Otherwise, the remote side closed the connection normally. */
+       logevent(telnet->frontend, error_msg);
+       connection_fatal(telnet->frontend, "%s", error_msg);
+    }
+    /* Otherwise, the remote side closed the connection normally. */
     return 0;
 }
 
 static int telnet_receive(Plug plug, int urgent, char *data, int len)
 {
+    Telnet telnet = (Telnet) plug;
     if (urgent)
-       in_synch = TRUE;
-    do_telnet_read(data, len);
+       telnet->in_synch = TRUE;
+    do_telnet_read(telnet, data, len);
     return 1;
 }
 
 static void telnet_sent(Plug plug, int bufsize)
 {
-    telnet_bufsize = bufsize;
+    Telnet telnet = (Telnet) plug;
+    telnet->bufsize = bufsize;
 }
 
 /*
@@ -605,33 +714,58 @@ static void telnet_sent(Plug plug, int bufsize)
  * Also places the canonical host name into `realhost'. It must be
  * freed by the caller.
  */
-static char *telnet_init(void *frontend_handle,
-                        char *host, int port, char **realhost, int nodelay)
+static const char *telnet_init(void *frontend_handle, void **backend_handle,
+                              Conf *conf, char *host, int port,
+                              char **realhost, int nodelay, int keepalive)
 {
-    static struct plug_function_table fn_table = {
+    static const struct plug_function_table fn_table = {
+       telnet_log,
        telnet_closing,
        telnet_receive,
        telnet_sent
-    }, *fn_table_ptr = &fn_table;
-
+    };
     SockAddr addr;
-    char *err;
-
-    frontend = frontend_handle;
-    telnet_term_width = cfg.width;
-    telnet_term_height = cfg.height;
+    const char *err;
+    Telnet telnet;
+    char *loghost;
+    int addressfamily;
+
+    telnet = snew(struct telnet_tag);
+    telnet->fn = &fn_table;
+    telnet->conf = conf_copy(conf);
+    telnet->s = NULL;
+    telnet->closed_on_socket_error = FALSE;
+    telnet->echoing = TRUE;
+    telnet->editing = TRUE;
+    telnet->activated = FALSE;
+    telnet->sb_buf = NULL;
+    telnet->sb_size = 0;
+    telnet->frontend = frontend_handle;
+    telnet->term_width = conf_get_int(telnet->conf, CONF_width);
+    telnet->term_height = conf_get_int(telnet->conf, CONF_height);
+    telnet->state = TOP_LEVEL;
+    telnet->ldisc = NULL;
+    telnet->pinger = NULL;
+    *backend_handle = telnet;
 
     /*
      * Try to find host.
      */
     {
-       char buf[200];
-       sprintf(buf, "Looking up host \"%.170s\"", host);
-       logevent(buf);
+       char *buf;
+       addressfamily = conf_get_int(telnet->conf, CONF_addressfamily);
+       buf = dupprintf("Looking up host \"%s\"%s", host,
+                       (addressfamily == ADDRTYPE_IPV4 ? " (IPv4)" :
+                        (addressfamily == ADDRTYPE_IPV6 ? " (IPv6)" :
+                         "")));
+       logevent(telnet->frontend, buf);
+       sfree(buf);
     }
-    addr = sk_namelookup(host, realhost);
-    if ((err = sk_addr_error(addr)))
+    addr = name_lookup(host, port, realhost, telnet->conf, addressfamily);
+    if ((err = sk_addr_error(addr)) != NULL) {
+       sk_addr_free(addr);
        return err;
+    }
 
     if (port < 0)
        port = 23;                     /* default telnet port */
@@ -639,243 +773,368 @@ static char *telnet_init(void *frontend_handle,
     /*
      * Open socket.
      */
-    {
-       char buf[200], addrbuf[100];
-       sk_getaddr(addr, addrbuf, 100);
-       sprintf(buf, "Connecting to %.100s port %d", addrbuf, port);
-       logevent(buf);
-    }
-    s = new_connection(addr, *realhost, port, 0, 1, nodelay, &fn_table_ptr);
-    if ((err = sk_socket_error(s)))
+    telnet->s = new_connection(addr, *realhost, port, 0, 1,
+                              nodelay, keepalive, (Plug) telnet, telnet->conf);
+    if ((err = sk_socket_error(telnet->s)) != NULL)
        return err;
 
-    sk_addr_free(addr);
+    telnet->pinger = pinger_new(telnet->conf, &telnet_backend, telnet);
 
     /*
      * Initialise option states.
      */
-    if (cfg.passive_telnet) {
-       struct Opt **o;
+    if (conf_get_int(telnet->conf, CONF_passive_telnet)) {
+       const struct Opt *const *o;
 
        for (o = opts; *o; o++)
-           if ((*o)->state == REQUESTED)
-               (*o)->state = INACTIVE;
+           telnet->opt_states[(*o)->index] = INACTIVE;
     } else {
-       struct Opt **o;
+       const struct Opt *const *o;
 
-       for (o = opts; *o; o++)
-           if ((*o)->state == REQUESTED)
-               send_opt((*o)->send, (*o)->option);
-       activated = TRUE;
+       for (o = opts; *o; o++) {
+           telnet->opt_states[(*o)->index] = (*o)->initial_state;
+           if (telnet->opt_states[(*o)->index] == REQUESTED)
+               send_opt(telnet, (*o)->send, (*o)->option);
+       }
+       telnet->activated = TRUE;
     }
 
     /*
      * Set up SYNCH state.
      */
-    in_synch = FALSE;
+    telnet->in_synch = FALSE;
+
+    /*
+     * We can send special commands from the start.
+     */
+    update_specials_menu(telnet->frontend);
+
+    /*
+     * loghost overrides realhost, if specified.
+     */
+    loghost = conf_get_str(telnet->conf, CONF_loghost);
+    if (*loghost) {
+       char *colon;
+
+       sfree(*realhost);
+       *realhost = dupstr(loghost);
+       colon = strrchr(*realhost, ':');
+       if (colon) {
+           /*
+            * FIXME: if we ever update this aspect of ssh.c for
+            * IPv6 literal management, this should change in line
+            * with it.
+            */
+           *colon++ = '\0';
+       }
+    }
 
     return NULL;
 }
 
+static void telnet_free(void *handle)
+{
+    Telnet telnet = (Telnet) handle;
+
+    sfree(telnet->sb_buf);
+    if (telnet->s)
+       sk_close(telnet->s);
+    if (telnet->pinger)
+       pinger_free(telnet->pinger);
+    conf_free(telnet->conf);
+    sfree(telnet);
+}
+/*
+ * Reconfigure the Telnet backend. There's no immediate action
+ * necessary, in this backend: we just save the fresh config for
+ * any subsequent negotiations.
+ */
+static void telnet_reconfig(void *handle, Conf *conf)
+{
+    Telnet telnet = (Telnet) handle;
+    pinger_reconfig(telnet->pinger, telnet->conf, conf);
+    conf_free(telnet->conf);
+    telnet->conf = conf_copy(conf);
+}
+
 /*
  * Called to send data down the Telnet connection.
  */
-static int telnet_send(char *buf, int len)
+static int telnet_send(void *handle, char *buf, int len)
 {
-    char *p;
-    static unsigned char iac[2] = { IAC, IAC };
-    static unsigned char cr[2] = { CR, NUL };
+    Telnet telnet = (Telnet) handle;
+    unsigned char *p, *end;
+    static const unsigned char iac[2] = { IAC, IAC };
+    static const unsigned char cr[2] = { CR, NUL };
 #if 0
-    static unsigned char nl[2] = { CR, LF };
+    static const unsigned char nl[2] = { CR, LF };
 #endif
 
-    if (s == NULL)
+    if (telnet->s == NULL)
        return 0;
 
-    p = buf;
-    while (p < buf + len) {
-       char *q = p;
+    p = (unsigned char *)buf;
+    end = (unsigned char *)(buf + len);
+    while (p < end) {
+       unsigned char *q = p;
 
-       while (iswritable((unsigned char) *p) && p < buf + len)
+       while (p < end && iswritable(*p))
            p++;
-       telnet_bufsize = sk_write(s, q, p - q);
+       telnet->bufsize = sk_write(telnet->s, (char *)q, p - q);
 
-       while (p < buf + len && !iswritable((unsigned char) *p)) {
-           telnet_bufsize = 
-               sk_write(s, (unsigned char) *p == IAC ? iac : cr, 2);
+       while (p < end && !iswritable(*p)) {
+           telnet->bufsize = 
+               sk_write(telnet->s, (char *)(*p == IAC ? iac : cr), 2);
            p++;
        }
     }
 
-    return telnet_bufsize;
+    return telnet->bufsize;
 }
 
 /*
  * Called to query the current socket sendability status.
  */
-static int telnet_sendbuffer(void)
+static int telnet_sendbuffer(void *handle)
 {
-    return telnet_bufsize;
+    Telnet telnet = (Telnet) handle;
+    return telnet->bufsize;
 }
 
 /*
  * Called to set the size of the window from Telnet's POV.
  */
-static void telnet_size(int width, int height)
+static void telnet_size(void *handle, int width, int height)
 {
-    unsigned char b[16];
-    char logbuf[50];
+    Telnet telnet = (Telnet) handle;
+    unsigned char b[24];
+    int n;
+    char *logbuf;
 
-    telnet_term_width = width;
-    telnet_term_height = height;
+    telnet->term_width = width;
+    telnet->term_height = height;
 
-    if (s == NULL || o_naws.state != ACTIVE)
+    if (telnet->s == NULL || telnet->opt_states[o_naws.index] != ACTIVE)
        return;
-    b[0] = IAC;
-    b[1] = SB;
-    b[2] = TELOPT_NAWS;
-    b[3] = telnet_term_width >> 8;
-    b[4] = telnet_term_width & 0xFF;
-    b[5] = telnet_term_height >> 8;
-    b[6] = telnet_term_height & 0xFF;
-    b[7] = IAC;
-    b[8] = SE;
-    telnet_bufsize = sk_write(s, b, 9);
-    sprintf(logbuf, "client:\tSB NAWS %d,%d",
-           ((unsigned char) b[3] << 8) + (unsigned char) b[4],
-           ((unsigned char) b[5] << 8) + (unsigned char) b[6]);
-    logevent(logbuf);
+    n = 0;
+    b[n++] = IAC;
+    b[n++] = SB;
+    b[n++] = TELOPT_NAWS;
+    b[n++] = telnet->term_width >> 8;
+    if (b[n-1] == IAC) b[n++] = IAC;   /* duplicate any IAC byte occurs */
+    b[n++] = telnet->term_width & 0xFF;
+    if (b[n-1] == IAC) b[n++] = IAC;   /* duplicate any IAC byte occurs */
+    b[n++] = telnet->term_height >> 8;
+    if (b[n-1] == IAC) b[n++] = IAC;   /* duplicate any IAC byte occurs */
+    b[n++] = telnet->term_height & 0xFF;
+    if (b[n-1] == IAC) b[n++] = IAC;   /* duplicate any IAC byte occurs */
+    b[n++] = IAC;
+    b[n++] = SE;
+    telnet->bufsize = sk_write(telnet->s, (char *)b, n);
+    logbuf = dupprintf("client:\tSB NAWS %d,%d",
+                      telnet->term_width, telnet->term_height);
+    logevent(telnet->frontend, logbuf);
+    sfree(logbuf);
 }
 
 /*
  * Send Telnet special codes.
  */
-static void telnet_special(Telnet_Special code)
+static void telnet_special(void *handle, Telnet_Special code)
 {
+    Telnet telnet = (Telnet) handle;
     unsigned char b[2];
 
-    if (s == NULL)
+    if (telnet->s == NULL)
        return;
 
     b[0] = IAC;
     switch (code) {
       case TS_AYT:
        b[1] = AYT;
-       telnet_bufsize = sk_write(s, b, 2);
+       telnet->bufsize = sk_write(telnet->s, (char *)b, 2);
        break;
       case TS_BRK:
        b[1] = BREAK;
-       telnet_bufsize = sk_write(s, b, 2);
+       telnet->bufsize = sk_write(telnet->s, (char *)b, 2);
        break;
       case TS_EC:
        b[1] = EC;
-       telnet_bufsize = sk_write(s, b, 2);
+       telnet->bufsize = sk_write(telnet->s, (char *)b, 2);
        break;
       case TS_EL:
        b[1] = EL;
-       telnet_bufsize = sk_write(s, b, 2);
+       telnet->bufsize = sk_write(telnet->s, (char *)b, 2);
        break;
       case TS_GA:
        b[1] = GA;
-       telnet_bufsize = sk_write(s, b, 2);
+       telnet->bufsize = sk_write(telnet->s, (char *)b, 2);
        break;
       case TS_NOP:
        b[1] = NOP;
-       telnet_bufsize = sk_write(s, b, 2);
+       telnet->bufsize = sk_write(telnet->s, (char *)b, 2);
        break;
       case TS_ABORT:
        b[1] = ABORT;
-       telnet_bufsize = sk_write(s, b, 2);
+       telnet->bufsize = sk_write(telnet->s, (char *)b, 2);
        break;
       case TS_AO:
        b[1] = AO;
-       telnet_bufsize = sk_write(s, b, 2);
+       telnet->bufsize = sk_write(telnet->s, (char *)b, 2);
        break;
       case TS_IP:
        b[1] = IP;
-       telnet_bufsize = sk_write(s, b, 2);
+       telnet->bufsize = sk_write(telnet->s, (char *)b, 2);
        break;
       case TS_SUSP:
        b[1] = SUSP;
-       telnet_bufsize = sk_write(s, b, 2);
+       telnet->bufsize = sk_write(telnet->s, (char *)b, 2);
        break;
       case TS_EOR:
        b[1] = EOR;
-       telnet_bufsize = sk_write(s, b, 2);
+       telnet->bufsize = sk_write(telnet->s, (char *)b, 2);
        break;
       case TS_EOF:
        b[1] = xEOF;
-       telnet_bufsize = sk_write(s, b, 2);
+       telnet->bufsize = sk_write(telnet->s, (char *)b, 2);
        break;
       case TS_EOL:
-       telnet_bufsize = sk_write(s, "\r\n", 2);
+       /* In BINARY mode, CR-LF becomes just CR -
+        * and without the NUL suffix too. */
+       if (telnet->opt_states[o_we_bin.index] == ACTIVE)
+           telnet->bufsize = sk_write(telnet->s, "\r", 1);
+       else
+           telnet->bufsize = sk_write(telnet->s, "\r\n", 2);
        break;
       case TS_SYNCH:
        b[1] = DM;
-       telnet_bufsize = sk_write(s, b, 1);
-       telnet_bufsize = sk_write_oob(s, b + 1, 1);
+       telnet->bufsize = sk_write(telnet->s, (char *)b, 1);
+       telnet->bufsize = sk_write_oob(telnet->s, (char *)(b + 1), 1);
        break;
       case TS_RECHO:
-       if (o_echo.state == INACTIVE || o_echo.state == REALLY_INACTIVE) {
-           o_echo.state = REQUESTED;
-           send_opt(o_echo.send, o_echo.option);
+       if (telnet->opt_states[o_echo.index] == INACTIVE ||
+           telnet->opt_states[o_echo.index] == REALLY_INACTIVE) {
+           telnet->opt_states[o_echo.index] = REQUESTED;
+           send_opt(telnet, o_echo.send, o_echo.option);
        }
        break;
       case TS_LECHO:
-       if (o_echo.state == ACTIVE) {
-           o_echo.state = REQUESTED;
-           send_opt(o_echo.nsend, o_echo.option);
+       if (telnet->opt_states[o_echo.index] == ACTIVE) {
+           telnet->opt_states[o_echo.index] = REQUESTED;
+           send_opt(telnet, o_echo.nsend, o_echo.option);
        }
        break;
       case TS_PING:
-       if (o_they_sga.state == ACTIVE) {
+       if (telnet->opt_states[o_they_sga.index] == ACTIVE) {
            b[1] = NOP;
-           telnet_bufsize = sk_write(s, b, 2);
+           telnet->bufsize = sk_write(telnet->s, (char *)b, 2);
        }
        break;
+      default:
+       break;  /* never heard of it */
     }
 }
 
-static Socket telnet_socket(void)
+static const struct telnet_special *telnet_get_specials(void *handle)
 {
-    return s;
+    static const struct telnet_special specials[] = {
+       {"Are You There", TS_AYT},
+       {"Break", TS_BRK},
+       {"Synch", TS_SYNCH},
+       {"Erase Character", TS_EC},
+       {"Erase Line", TS_EL},
+       {"Go Ahead", TS_GA},
+       {"No Operation", TS_NOP},
+       {NULL, TS_SEP},
+       {"Abort Process", TS_ABORT},
+       {"Abort Output", TS_AO},
+       {"Interrupt Process", TS_IP},
+       {"Suspend Process", TS_SUSP},
+       {NULL, TS_SEP},
+       {"End Of Record", TS_EOR},
+       {"End Of File", TS_EOF},
+       {NULL, TS_EXITMENU}
+    };
+    return specials;
 }
 
-static int telnet_sendok(void)
+static int telnet_connected(void *handle)
 {
+    Telnet telnet = (Telnet) handle;
+    return telnet->s != NULL;
+}
+
+static int telnet_sendok(void *handle)
+{
+    /* Telnet telnet = (Telnet) handle; */
     return 1;
 }
 
-static void telnet_unthrottle(int backlog)
+static void telnet_unthrottle(void *handle, int backlog)
 {
-    sk_set_frozen(s, backlog > TELNET_MAX_BACKLOG);
+    Telnet telnet = (Telnet) handle;
+    sk_set_frozen(telnet->s, backlog > TELNET_MAX_BACKLOG);
 }
 
-static int telnet_ldisc(int option)
+static int telnet_ldisc(void *handle, int option)
 {
+    Telnet telnet = (Telnet) handle;
     if (option == LD_ECHO)
-       return echoing;
+       return telnet->echoing;
     if (option == LD_EDIT)
-       return editing;
+       return telnet->editing;
     return FALSE;
 }
 
-static int telnet_exitcode(void)
+static void telnet_provide_ldisc(void *handle, void *ldisc)
+{
+    Telnet telnet = (Telnet) handle;
+    telnet->ldisc = ldisc;
+}
+
+static void telnet_provide_logctx(void *handle, void *logctx)
+{
+    /* This is a stub. */
+}
+
+static int telnet_exitcode(void *handle)
+{
+    Telnet telnet = (Telnet) handle;
+    if (telnet->s != NULL)
+        return -1;                     /* still connected */
+    else if (telnet->closed_on_socket_error)
+        return INT_MAX;     /* a socket error counts as an unclean exit */
+    else
+        /* Telnet doesn't transmit exit codes back to the client */
+        return 0;
+}
+
+/*
+ * cfg_info for Telnet does nothing at all.
+ */
+static int telnet_cfg_info(void *handle)
 {
-    /* Telnet doesn't transmit exit codes back to the client */
     return 0;
 }
 
 Backend telnet_backend = {
     telnet_init,
+    telnet_free,
+    telnet_reconfig,
     telnet_send,
     telnet_sendbuffer,
     telnet_size,
     telnet_special,
-    telnet_socket,
+    telnet_get_specials,
+    telnet_connected,
     telnet_exitcode,
     telnet_sendok,
     telnet_ldisc,
+    telnet_provide_ldisc,
+    telnet_provide_logctx,
     telnet_unthrottle,
+    telnet_cfg_info,
+    "telnet",
+    PROT_TELNET,
     23
 };