Changeset 46304a4547d3e7cd3b7e98eaa2b8653034cd1c6b

Timestamp:

02/08/08 05:29:46 (5 years ago)

Author:

Theo Schlossnagle <jesus@omniti.com>

git-committer:

Theo Schlossnagle <jesus@omniti.com> 1202448586 +0000

git-parent:

[30700011fc4916bef71870a2bae7739745a7a2bc]

git-author:

Theo Schlossnagle <jesus@omniti.com> 1202448586 +0000

Message:

add in linemode

Files:

• src/noit_console_telnet.c (modified) (30 diffs)
• src/noit_console_telnet.h (modified) (2 diffs)

src/noit_console_telnet.c

@@ -72 +72 @@
-#define terminalname ncct->telnet->_terminalname
-#define flowmode ncct->telnet->_flowmode
+#define linemode ncct->telnet->_linemode
+#define uselinemode ncct->telnet->_uselinemode
+#define alwayslinemode ncct->telnet->_alwayslinemode
-#define restartany ncct->telnet->_restartany
+#define _terminit ncct->telnet->__terminit
+#define turn_on_sga ncct->telnet->_turn_on_sga
+#define useeditmode ncct->telnet->_useeditmode
+#define editmode ncct->telnet->_editmode
+#define def_slcbuf ncct->telnet->_def_slcbuf
+#define def_slclen ncct->telnet->_def_slclen
+#define slcchange ncct->telnet->_slcchange
+#define slcptr ncct->telnet->_slcptr
+#define slcbuf ncct->telnet->_slcbuf
-#define def_tspeed ncct->telnet->_def_tspeed
-#define def_rspeed ncct->telnet->_def_rspeed
@@ -103 +115 @@
-  noit_console_continue_sending(ncct, &unused);
-}
+static void set_termbuf(noit_console_closure_t ncct);
+static void init_termbuf(noit_console_closure_t ncct);
+static void defer_terminit(noit_console_closure_t ncct);
+static void flowstat(noit_console_closure_t ncct);
+static int spcset(noit_console_closure_t ncct, int func, cc_t *valp, cc_t **valpp);
+static void suboption(noit_console_closure_t ncct);
+static void send_slc(noit_console_closure_t ncct);
+static void default_slc(noit_console_closure_t ncct);
+static void get_slc_defaults(noit_console_closure_t ncct);
+static void add_slc(noit_console_closure_t ncct, char func, char flag, cc_t val);
+static void start_slc(noit_console_closure_t ncct, int getit);
+static int end_slc(noit_console_closure_t ncct, unsigned char **bufp);
+static void process_slc(noit_console_closure_t ncct, unsigned char func, unsigned char flag, cc_t val);
+static void change_slc(noit_console_closure_t ncct, char func, char flag, cc_t val);
+static void check_slc(noit_console_closure_t ncct);
+static void do_opt_slc(noit_console_closure_t ncct, unsigned char *ptr, int len);
+
+#ifdef LINEMODE
-static void
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-void
@@ -142 +797 @@
-noit_console_telnet_tty_flowmode(noit_console_closure_t ncct)
-{
+#ifndef USE_TERMIO
+    return(((termbuf.tc.t_startc) > 0 && (termbuf.tc.t_stopc) > 0) ? 1 : 0);
+#else
-    return((termbuf.c_iflag & IXON) ? 1 : 0);
+#endif
-}
-
@@ -148 +807 @@
-noit_console_telnet_tty_binaryin(noit_console_closure_t ncct, int on)
-{
+#ifndef USE_TERMIO
+    if (on)
+        termbuf.lflags |= LPASS8;
+    else
+        termbuf.lflags &= ~LPASS8;
+#else
+    if (on)
+        termbuf.c_iflag &= ~ISTRIP;
+    else
+        termbuf.c_iflag |= ISTRIP;
+#endif
+}
+
+int
+noit_console_telnet_tty_isbinaryin(noit_console_closure_t ncct)
+{
+#ifndef USE_TERMIO
+        return(termbuf.lflags & LPASS8);
+#else
+        return(!(termbuf.c_iflag & ISTRIP));
+#endif
+}
+
+void
+noit_console_telnet_tty_binaryout(noit_console_closure_t ncct, int on)
+{
+#ifndef USE_TERMIO
+    if (on)
+        termbuf.lflags |= LLITOUT;
+    else
+        termbuf.lflags &= ~LLITOUT;
+#else
-    if (on) {
-
+
+
+
-    } else {
-
+
+
+
-    }
+#endif
+}
+
+int
+noit_console_telnet_tty_isbinaryout(noit_console_closure_t ncct)
+{
+#ifndef USE_TERMIO
+        return(termbuf.lflags & LLITOUT);
+#else
+        return(!(termbuf.c_oflag&OPOST));
+#endif
-}
-
@@ -158 +864 @@
-noit_console_telnet_tty_restartany(noit_console_closure_t ncct)
-{
+#ifndef USE_TERMIO
+# ifdef DECCTQ
+    return((termbuf.lflags & DECCTQ) ? 0 : 1);
+# else
+    return(-1);
+# endif
+#else
-    return((termbuf.c_iflag & IXANY) ? 1 : 0);
+#endif
+}
+
+int
+noit_console_telnet_tty_isecho(noit_console_closure_t ncct)
+{
+#ifndef USE_TERMIO
+        return (termbuf.sg.sg_flags & ECHO);
+#else
+        return (termbuf.c_lflag & ECHO);
+#endif
-}
-
@@ -182 +906 @@
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-init_termbuf(noit_console_closure_t ncct)
-{
@@ -223 +933 @@
-#endif  /* defined(LINEMODE) && defined(TIOCPKT_IOCTL) */
-
-
+static 
-set_termbuf(noit_console_closure_t ncct)
-{
@@ -247 +957 @@
-}
-
+#ifdef  LINEMODE
+/*
+ * localstat
+ *
+ * This function handles all management of linemode.
+ *
+ * Linemode allows the client to do the local editing of data
+ * and send only complete lines to the server.  Linemode state is
+ * based on the state of the pty driver.  If the pty is set for
+ * external processing, then we can use linemode.  Further, if we
+ * can use real linemode, then we can look at the edit control bits
+ * in the pty to determine what editing the client should do.
+ *
+ * Linemode support uses the following state flags to keep track of
+ * current and desired linemode state.
+ *      alwayslinemode : true if -l was specified on the telnetd
+ *      command line.  It means to have linemode on as much as
+ *      possible.
+ *
+ *      lmodetype: signifies whether the client can
+ *      handle real linemode, or if use of kludgeomatic linemode
+ *      is preferred.  It will be set to one of the following:
+ *              REAL_LINEMODE : use linemode option
+ *              NO_KLUDGE : don't initiate kludge linemode.
+ *              KLUDGE_LINEMODE : use kludge linemode
+ *              NO_LINEMODE : client is ignorant of linemode
+ *
+ *      linemode, uselinemode : linemode is true if linemode
+ *      is currently on, uselinemode is the state that we wish
+ *      to be in.  If another function wishes to turn linemode
+ *      on or off, it sets or clears uselinemode.
+ *
+ *      editmode, useeditmode : like linemode/uselinemode, but
+ *      these contain the edit mode states (edit and trapsig).
+ *
+ * The state variables correspond to some of the state information
+ * in the pty.
+ *      linemode:
+ *              In real linemode, this corresponds to whether the pty
+ *              expects external processing of incoming data.
+ *              In kludge linemode, this more closely corresponds to the
+ *              whether normal processing is on or not.  (ICANON in
+ *              system V, or COOKED mode in BSD.)
+ *              If the -l option was specified (alwayslinemode), then
+ *              an attempt is made to force external processing on at
+ *              all times.
+ *
+ * The following heuristics are applied to determine linemode
+ * handling within the server.
+ *      1) Early on in starting up the server, an attempt is made
+ *         to negotiate the linemode option.  If this succeeds
+ *         then lmodetype is set to REAL_LINEMODE and all linemode
+ *         processing occurs in the context of the linemode option.
+ *      2) If the attempt to negotiate the linemode option failed,
+ *         and the "-k" (don't initiate kludge linemode) isn't set,
+ *         then we try to use kludge linemode.  We test for this
+ *         capability by sending "do Timing Mark".  If a positive
+ *         response comes back, then we assume that the client
+ *         understands kludge linemode (ech!) and the
+ *         lmodetype flag is set to KLUDGE_LINEMODE.
+ *      3) Otherwise, linemode is not supported at all and
+ *         lmodetype remains set to NO_LINEMODE (which happens
+ *         to be 0 for convenience).
+ *      4) At any time a command arrives that implies a higher
+ *         state of linemode support in the client, we move to that
+ *         linemode support.
+ *
+ * A short explanation of kludge linemode is in order here.
+ *      1) The heuristic to determine support for kludge linemode
+ *         is to send a do timing mark.  We assume that a client
+ *         that supports timing marks also supports kludge linemode.
+ *         A risky proposition at best.
+ *      2) Further negotiation of linemode is done by changing the
+ *         the server's state regarding SGA.  If server will SGA,
+ *         then linemode is off, if server won't SGA, then linemode
+ *         is on.
+ */
+static void
+localstat(noit_console_closure_t ncct)
+{
+        int need_will_echo = 0;
+
+        /*
+         * Check for changes to flow control if client supports it.
+         */
+        flowstat(ncct);
+
+        /*
+         * Check linemode on/off state
+         */
+        uselinemode = noit_console_telnet_tty_linemode(ncct);
+
+        /*
+         * If alwayslinemode is on, and pty is changing to turn it off, then
+         * force linemode back on.
+         */
+        if (alwayslinemode && linemode && !uselinemode) {
+                uselinemode = 1;
+                noit_console_telnet_tty_setlinemode(ncct, uselinemode);
+        }
+
+        if (uselinemode) {
+                /*
+                 * Check for state of BINARY options.
+                 *
+                 * We only need to do the binary dance if we are actually going
+                 * to use linemode.  As this confuses some telnet clients
+                 * that don't support linemode, and doesn't gain us
+                 * anything, we don't do it unless we're doing linemode.
+                 * -Crh (henrich@msu.edu)
+                 */
+
+                if (noit_console_telnet_tty_isbinaryin(ncct)) {
+                        if (his_want_state_is_wont(TELOPT_BINARY))
+                                send_do(TELOPT_BINARY, 1);
+                } else {
+                        if (his_want_state_is_will(TELOPT_BINARY))
+                                send_dont(TELOPT_BINARY, 1);
+                }
+
+                if (noit_console_telnet_tty_isbinaryout(ncct)) {
+                        if (my_want_state_is_wont(TELOPT_BINARY))
+                                send_will(TELOPT_BINARY, 1);
+                } else {
+                        if (my_want_state_is_will(TELOPT_BINARY))
+                                send_wont(TELOPT_BINARY, 1);
+                }
+        }
+
+
+        /*
+         * Do echo mode handling as soon as we know what the
+         * linemode is going to be.
+         * If the pty has echo turned off, then tell the client that
+         * the server will echo.  If echo is on, then the server
+         * will echo if in character mode, but in linemode the
+         * client should do local echoing.  The state machine will
+         * not send anything if it is unnecessary, so don't worry
+         * about that here.
+         *
+         * If we need to send the WILL ECHO (because echo is off),
+         * then delay that until after we have changed the MODE.
+         * This way, when the user is turning off both editing
+         * and echo, the client will get editing turned off first.
+         * This keeps the client from going into encryption mode
+         * and then right back out if it is doing auto-encryption
+         * when passwords are being typed.
+         */
+        if (uselinemode) {
+                if (noit_console_telnet_tty_isecho(ncct))
+                        send_wont(TELOPT_ECHO, 1);
+                else
+                        need_will_echo = 1;
+#ifdef  KLUDGELINEMODE
+                if (lmodetype == KLUDGE_OK)
+                        lmodetype = KLUDGE_LINEMODE;
+#endif
+        }
+
+        /*
+         * If linemode is being turned off, send appropriate
+         * command and then we're all done.
+         */
+         if (!uselinemode && linemode) {
+# ifdef KLUDGELINEMODE
+                if (lmodetype == REAL_LINEMODE) {
+# endif /* KLUDGELINEMODE */
+                        send_dont(TELOPT_LINEMODE, 1);
+# ifdef KLUDGELINEMODE
+                } else if (lmodetype == KLUDGE_LINEMODE)
+                        send_will(TELOPT_SGA, 1);
+# endif /* KLUDGELINEMODE */
+                send_will(TELOPT_ECHO, 1);
+                linemode = uselinemode;
+                goto done;
+        }
+
+# ifdef KLUDGELINEMODE
+        /*
+         * If using real linemode check edit modes for possible later use.
+         * If we are in kludge linemode, do the SGA negotiation.
+         */
+        if (lmodetype == REAL_LINEMODE) {
+# endif /* KLUDGELINEMODE */
+                useeditmode = 0;
+                if (noit_console_telnet_tty_isediting(ncct))
+                        useeditmode |= MODE_EDIT;
+                if (noit_console_telnet_tty_istrapsig(ncct))
+                        useeditmode |= MODE_TRAPSIG;
+                if (noit_console_telnet_tty_issofttab(ncct))
+                        useeditmode |= MODE_SOFT_TAB;
+                if (noit_console_telnet_tty_islitecho(ncct))
+                        useeditmode |= MODE_LIT_ECHO;
+# ifdef KLUDGELINEMODE
+        } else if (lmodetype == KLUDGE_LINEMODE) {
+                if (noit_console_telnet_tty_isediting(ncct) && uselinemode)
+                        send_wont(TELOPT_SGA, 1);
+                else
+                        send_will(TELOPT_SGA, 1);
+        }
+# endif /* KLUDGELINEMODE */
+
+        /*
+         * Negotiate linemode on if pty state has changed to turn it on.
+         * Send appropriate command and send along edit mode, then all done.
+         */
+        if (uselinemode && !linemode) {
+# ifdef KLUDGELINEMODE
+                if (lmodetype == KLUDGE_LINEMODE) {
+                        send_wont(TELOPT_SGA, 1);
+                } else if (lmodetype == REAL_LINEMODE) {
+# endif /* KLUDGELINEMODE */
+                        send_do(TELOPT_LINEMODE, 1);
+                        /* send along edit modes */
+                        nc_printf(ncct, "%c%c%c%c%c%c%c", IAC, SB,
+                                TELOPT_LINEMODE, LM_MODE, useeditmode,
+                                IAC, SE);
+                        editmode = useeditmode;
+# ifdef KLUDGELINEMODE
+                }
+# endif /* KLUDGELINEMODE */
+                linemode = uselinemode;
+                goto done;
+        }
+
+# ifdef KLUDGELINEMODE
+        /*
+         * None of what follows is of any value if not using
+         * real linemode.
+         */
+        if (lmodetype < REAL_LINEMODE)
+                goto done;
+# endif /* KLUDGELINEMODE */
+
+        if (linemode && his_state_is_will(TELOPT_LINEMODE)) {
+                /*
+                 * If edit mode changed, send edit mode.
+                 */
+                 if (useeditmode != editmode) {
+                        /*
+                         * Send along appropriate edit mode mask.
+                         */
+                        nc_printf(ncct, "%c%c%c%c%c%c%c", IAC, SB,
+                                TELOPT_LINEMODE, LM_MODE, useeditmode,
+                                IAC, SE);
+                        editmode = useeditmode;
+                }
+
+
+                /*
+                 * Check for changes to special characters in use.
+                 */
+                start_slc(ncct, 0);
+                check_slc(ncct);
+                (void) end_slc(ncct, 0);
+        }
+
+done:
+        if (need_will_echo)
+                send_will(TELOPT_ECHO, 1);
+        /*
+         * Some things should be deferred until after the pty state has
+         * been set by the local process.  Do those things that have been
+         * deferred now.  This only happens once.
+         */
+        if (_terminit == 0) {
+                _terminit = 1;
+                defer_terminit(ncct);
+        }
+
+        netflush(ncct);
+        set_termbuf(ncct);
+        return;
+
+}  /* end of localstat */
+#endif  /* LINEMODE */
+
-/*
- * flowstat
@@ -252 +1239 @@
- * Check for changes to flow control
- */
-
+static 
-flowstat(noit_console_closure_t ncct)
-{
@@ -294 +1281 @@
-     */
-    switch (code) {
+#ifdef  LINEMODE
+        case TELOPT_LINEMODE:
+                /*
+                 * Don't do anything unless client is asking us to change
+                 * modes.
+                 */
+                uselinemode = (parm1 == WILL);
+                if (uselinemode != linemode) {
+# ifdef KLUDGELINEMODE
+                        /*
+                         * If using kludge linemode, make sure that
+                         * we can do what the client asks.
+                         * We can not turn off linemode if alwayslinemode
+                         * and the ICANON bit is set.
+                         */
+                        if (lmodetype == KLUDGE_LINEMODE) {
+                                if (alwayslinemode && noit_console_telnet_tty_isediting(ncct)) {
+                                        uselinemode = 1;
+                                }
+                        }
+
+                        /*
+                         * Quit now if we can't do it.
+                         */
+                        if (uselinemode == linemode)
+                                return;
+
+                        /*
+                         * If using real linemode and linemode is being
+                         * turned on, send along the edit mode mask.
+                         */
+                        if (lmodetype == REAL_LINEMODE && uselinemode)
+# else  /* KLUDGELINEMODE */
+                        if (uselinemode)
+# endif /* KLUDGELINEMODE */
+                        {
+                                useeditmode = 0;
+                                if (noit_console_telnet_tty_isediting(ncct))
+                                        useeditmode |= MODE_EDIT;
+                                if (noit_console_telnet_tty_istrapsig(ncct))
+                                        useeditmode |= MODE_TRAPSIG;
+                                if (noit_console_telnet_tty_issofttab(ncct))
+                                        useeditmode |= MODE_SOFT_TAB;
+                                if (noit_console_telnet_tty_islitecho(ncct))
+                                        useeditmode |= MODE_LIT_ECHO;
+                                nc_printf(ncct, "%c%c%c%c%c%c%c", IAC,
+                                        SB, TELOPT_LINEMODE, LM_MODE,
+                                                        useeditmode, IAC, SE);
+                                editmode = useeditmode;
+                        }
+
+
+                        noit_console_telnet_tty_setlinemode(ncct, uselinemode);
+
+                        linemode = uselinemode;
+
+                        if (!linemode)
+                                send_will(TELOPT_ECHO, 1);
+                }
+                break;
+
+        case LM_MODE:
+            {
+                int ack, changed;
+
+                /*
+                 * Client has sent along a mode mask.  If it agrees with
+                 * what we are currently doing, ignore it; if not, it could
+                 * be viewed as a request to change.  Note that the server
+                 * will change to the modes in an ack if it is different from
+                 * what we currently have, but we will not ack the ack.
+                 */
+                 useeditmode &= MODE_MASK;
+                 ack = (useeditmode & MODE_ACK);
+                 useeditmode &= ~MODE_ACK;
+
+                 if ((changed = (useeditmode ^ editmode))) {
+                        /*
+                         * This check is for a timing problem.  If the
+                         * state of the tty has changed (due to the user
+                         * application) we need to process that info
+                         * before we write in the state contained in the
+                         * ack!!!  This gets out the new MODE request,
+                         * and when the ack to that command comes back
+                         * we'll set it and be in the right mode.
+                         */
+                        if (ack)
+                                localstat(ncct);
+                        if (changed & MODE_EDIT)
+                                noit_console_telnet_tty_setedit(ncct, useeditmode & MODE_EDIT);
+
+                        if (changed & MODE_TRAPSIG)
+                                noit_console_telnet_tty_setsig(ncct, useeditmode & MODE_TRAPSIG);
+
+                        if (changed & MODE_SOFT_TAB)
+                                noit_console_telnet_tty_setsofttab(ncct, useeditmode & MODE_SOFT_TAB);
+
+                        if (changed & MODE_LIT_ECHO)
+                                noit_console_telnet_tty_setlitecho(ncct, useeditmode & MODE_LIT_ECHO);
+
+                        set_termbuf(ncct);
+
+                        if (!ack) {
+                                nc_printf(ncct, "%c%c%c%c%c%c%c", IAC,
+                                        SB, TELOPT_LINEMODE, LM_MODE,
+                                        useeditmode|MODE_ACK,
+                                        IAC, SE);
+                        }
+
+                        editmode = useeditmode;
+                }
+
+                break;
+
+            }  /* end of case LM_MODE */
+#endif  /* LINEMODE */
-    case TELOPT_NAWS:
-#ifdef  TIOCSWINSZ
@@ -340 +1443 @@
-}
-
+#ifdef  LINEMODE
+/*
+ * defer_terminit
+ *
+ * Some things should not be done until after the login process has started
+ * and all the pty modes are set to what they are supposed to be.  This
+ * function is called when the pty state has been processed for the first time.
+ * It calls other functions that do things that were deferred in each module.
+ */
+static void
+defer_terminit(noit_console_closure_t ncct)
+{
+
+        /*
+         * local stuff that got deferred.
+         */
+        if (def_tspeed != -1) {
+                clientstat(ncct, TELOPT_TSPEED, def_tspeed, def_rspeed);
+                def_tspeed = def_rspeed = 0;
+        }
+
+#ifdef  TIOCSWINSZ
+        if (def_col || def_row) {
+                struct winsize ws;
+
+                memset((char *)&ws, 0, sizeof(ws));
+                ws.ws_col = def_col;
+                ws.ws_row = def_row;
+                (void) ioctl(pty, TIOCSWINSZ, (char *)&ws);
+        }
+#endif
+
+        /*
+         * The only other module that currently defers anything.
+         */
+        deferslc(ncct);
+
+}  /* end of defer_terminit */
+#endif
+
-/*
- * spcset(func, valp, valpp)
@@ -352 +1495 @@
-
-#ifndef USE_TERMIO
-
+static 
-spcset(noit_console_closure_t ncct, int func, cc_t *valp, cc_t **valpp)
-{
@@ -627 +1770 @@
-
-#if     defined(LINEMODE) && defined(USE_TERMIO) && (VEOF == VMIN)
-
+ncct
-                extern char oldeofc;
-                pty_write(ncct, &oldeofc, 1);
@@ -640 +1783 @@
-noit_console_telnet_closure_t
-noit_console_telnet_alloc(noit_console_closure_t ncct) {
-i, 
+
-  noit_console_telnet_closure_t telnet, tmp;
+  static unsigned char ttytype_sbbuf[] = {
+    IAC, SB, TELOPT_TTYPE, TELQUAL_SEND, IAC, SE
+  };
-  tmp = ncct->telnet;
-
@@ -650 +1796 @@
-  def_tspeed = -1;
-  def_rspeed = -1;
-
-
-
-
-
-
+
-  if (my_state_is_wont(TELOPT_SGA))
-    send_will(TELOPT_SGA, 1);
@@ -670 +1811 @@
-    send_will(TELOPT_ECHO, 1);
-  on = 1;
+  init_termbuf(ncct);
+  localstat(ncct);
+  send_do(TELOPT_TTYPE, 1);
+  send_do(TELOPT_TSPEED, 1);
+  send_do(TELOPT_XDISPLOC, 1);
+  send_do(TELOPT_NEW_ENVIRON, 1);
+  send_do(TELOPT_OLD_ENVIRON, 1);
+  nc_write(ncct, ttytype_sbbuf, sizeof(ttytype_sbbuf));
-
-  telnet = ncct->telnet;
@@ -754 +1903 @@
-             */
-            if ((c == '\r') && his_state_is_wont(TELOPT_BINARY)) {
+                int nc = *netip;
-#ifdef ENCRYPTION
-                int nc = *netip;
-                if (decrypt_input)
-                    nc = (*decrypt_input)(nc & 0xff);
-#endif
+                if (linemode && (ncc > 0) && (('\n' == nc) ||
+                         ((0 == nc) && noit_console_telnet_tty_iscrnl(ncct))) ) {
+                        netip++; ncc--;
+                        c = '\n';
+                } else
-                {
-#ifdef ENCRYPTION
@@ -1093 +2247 @@
-
-            case TELOPT_TM:
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                break;
-
@@ -1119 +2298 @@
-                break;
-
+#ifdef  LINEMODE
+                case TELOPT_LINEMODE:
+# ifdef KLUDGELINEMODE
+                        /*
+                         * Note client's desire to use linemode.
+                         */
+                        lmodetype = REAL_LINEMODE;
+# endif /* KLUDGELINEMODE */
+                        func = noit_console_telnet_doclientstat;
+                        changeok++;
+                        break;
+#endif  /* LINEMODE */
-
-#ifdef  AUTHENTICATION
@@ -1175 +2366 @@
-                break;
-
+#ifdef  LINEMODE
+                case TELOPT_LINEMODE:
+# ifdef KLUDGELINEMODE
+                        /*
+                         * Note client's desire to use linemode.
+                         */
+                        lmodetype = REAL_LINEMODE;
+# endif /* KLUDGELINEMODE */
+                        func = noit_console_telnet_doclientstat;
+                        break;
+#endif  /* LINEMODE */
-#ifdef  AUTHENTICATION
-            case TELOPT_AUTHENTICATION:
@@ -1237 +2439 @@
-                break;
-
+#ifdef  LINEMODE
+            case TELOPT_LINEMODE:
+# ifdef KLUDGELINEMODE
+                /*
+                 * If real linemode is supported, then client is
+                 * asking to turn linemode off.
+                 */
+                if (lmodetype != REAL_LINEMODE)
+                        break;
+                lmodetype = KLUDGE_LINEMODE;
+# endif /* KLUDGELINEMODE */
+                clientstat(ncct, TELOPT_LINEMODE, WONT, 0);
+                break;
+#endif  /* LINEMODE */
+
-            case TELOPT_TM:
-                /*
@@ -1302 +2519 @@
-            switch (option) {
-            case TELOPT_TM:
+#if     defined(LINEMODE) && defined(KLUDGELINEMODE)
+                if (lmodetype < NO_AUTOKLUDGE) {
+                        lmodetype = NO_LINEMODE;
+                        clientstat(TELOPT_LINEMODE, WONT, 0);
+                        send_will(TELOPT_SGA, 1);
+                        send_will(TELOPT_ECHO, 1);
+                }
+#endif  /* defined(LINEMODE) && defined(KLUDGELINEMODE) */
-                break;
-
@@ -1331 +2556 @@
-}
-
-/*
- * When we get a DONT SGA, we will try once to turn it
- * back on.  If the other side responds DONT SGA, we
- * leave it at that.  This is so that when we talk to
- * clients that understand KLUDGELINEMODE but not LINEMODE,
- * we'll keep them in char-at-a-time mode.
- */
-int turn_on_sga = 0;
-
-void
-noit_console_telnet_dooption(noit_console_closure_t ncct, int option)
@@ -1357 +2573 @@
-        switch (option) {
-        case TELOPT_ECHO:
+#ifdef  LINEMODE
+# ifdef KLUDGELINEMODE
+            if (lmodetype == NO_LINEMODE)
+# else
+            if (his_state_is_wont(TELOPT_LINEMODE))
+# endif
+#endif
-            {
-                init_termbuf(ncct);
@@ -1373 +2596 @@
-
-        case TELOPT_SGA:
+#if     defined(LINEMODE) && defined(KLUDGELINEMODE)
+                /*
+                 * If kludge linemode is in use, then we must
+                 * process an incoming do SGA for linemode
+                 * purposes.
+                 */
+            if (lmodetype == KLUDGE_LINEMODE) {
+                /*
+                 * Receipt of "do SGA" in kludge
+                 * linemode is the peer asking us to
+                 * turn off linemode.  Make note of
+                 * the request.
+                 */
+                clientstat(TELOPT_LINEMODE, WONT, 0);
+                /*
+                 * If linemode did not get turned off
+                 * then don't tell peer that we did.
+                 * Breaking here forces a wont SGA to
+                 * be returned.
+                 */
+                if (linemode)
+                        break;
+            }
+#else
-            turn_on_sga = 0;
+#endif  /* defined(LINEMODE) && defined(KLUDGELINEMODE) */
-            changeok++;
-            break;
@@ -1469 +2717 @@
-
-        case TELOPT_ECHO:       /* we should stop echoing */
+#ifdef  LINEMODE
+# ifdef KLUDGELINEMODE
+            if ((lmodetype != REAL_LINEMODE) &&
+                    (lmodetype != KLUDGE_LINEMODE))
+# else
+            if (his_state_is_wont(TELOPT_LINEMODE))
+# endif
+#endif
-            {
-                init_termbuf(ncct);
@@ -1477 +2733 @@
-
-        case TELOPT_SGA:
+#if     defined(LINEMODE) && defined(KLUDGELINEMODE)
+                /*
+                 * If kludge linemode is in use, then we
+                 * must process an incoming do SGA for
+                 * linemode purposes.
+                 */
+            if ((lmodetype == KLUDGE_LINEMODE) ||
+                    (lmodetype == KLUDGE_OK)) {
+                /*
+                 * The client is asking us to turn
+                 * linemode on.
+                 */
+                lmodetype = KLUDGE_LINEMODE;
+                clientstat(TELOPT_LINEMODE, WILL, 0);
+                /*
+                 * If we did not turn line mode on,
+                 * then what do we say?  Will SGA?
+                 * This violates design of telnet.
+                 * Gross.  Very Gross.
+                 */
+            }
+            break;
+#else
-            set_my_want_state_wont(option);
-            if (my_state_is_will(option))
@@ -1484 +2763 @@
-                send_will(option, 1);
-            return;
+#endif  /* defined(LINEMODE) && defined(KLUDGELINEMODE) */
-
-        default:
@@ -1599 +2879 @@
-
-    }  /* end of case TELOPT_NAWS */
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    case TELOPT_STATUS: {
-        int mode;
@@ -1962 +3289 @@
-    }
-
+#ifdef  LINEMODE
+        if (his_want_state_is_will(TELOPT_LINEMODE)) {
+                unsigned char *cp, *cpe;
+                int len;
+
+                ADD(SB);
+                ADD(TELOPT_LINEMODE);
+                ADD(LM_MODE);
+                ADD_DATA(editmode);
+                ADD(SE);
+
+                ADD(SB);
+                ADD(TELOPT_LINEMODE);
+                ADD(LM_SLC);
+                start_slc(ncct, 0);
+                send_slc(ncct);
+                len = end_slc(ncct, &cp);
+                for (cpe = cp + len; cp < cpe; cp++)
+                        ADD_DATA(*cp);
+                ADD(SE);
+        }
+#endif  /* LINEMODE */
-
-    ADD(IAC);

src/noit_console_telnet.h

@@ -44 +44 @@
-#include <arpa/telnet.h>
-#include <sys/ioctl.h>
+#include <sys/ioctl_compat.h>
+#ifdef HAVE_TERMIOS_H
+#include <termios.h>
+#endif
-#ifdef HAVE_TERM_H
-#include <term.h>
-#define USE_TERMIO
-#endif
-
@@ -156 +159 @@
-  int            _flowmode;
-  int            _restartany;
+  int            __terminit;
+  int            _linemode;
+  int            _uselinemode;
+  int            _alwayslinemode;
+  int            _editmode;
+  int            _useeditmode;
+  unsigned char *_def_slcbuf;
+  int            _def_slclen;
+  int            _slcchange;    /* change to slc is requested */
+  unsigned char *_slcptr;       /* pointer into slc buffer */
+  unsigned char  _slcbuf[NSLC*6];       /* buffer for slc negotiation */
+
-  int            _def_tspeed; /* This one */
-  int            _def_rspeed; /* and this one, need init to -1 */
+#if     !defined(LINEMODE) || !defined(KLUDGELINEMODE)
+  int            _turn_on_sga;
+#endif
-#ifdef TIOCSWINSZ
-  int            _def_row;