mirror of
https://git.tartarus.org/simon/putty.git
synced 2025-01-09 09:27:59 +00:00
cd8a7181fd
The system for handling seat_get_userpass_input has always been structured differently between GUI PuTTY and CLI tools like Plink. In the CLI tools, password input is read directly from the OS terminal/console device by console_get_userpass_input; this means that you need to ensure the same terminal input data _hasn't_ already been consumed by the main event loop and sent on to the backend. This is achieved by the backend_sendok() method, which tells the event loop when the backend has finished issuing password prompts, and hence, when it's safe to start passing standard input to backend_send(). But in the GUI tools, input generated by the terminal window has always been sent straight to backend_send(), regardless of whether backend_sendok() says it wants it. So the terminal-based implementation of username and password prompts has to work by consuming input data that had _already_ been passed to the backend - hence, any backend that needs to do that must keep its input on a bufchain, and pass that bufchain to seat_get_userpass_input. It's awkward that these two totally different systems coexist in the first place. And now that SSH proxying needs to present interactive prompts of its own, it's clear which one should win: the CLI style is the Right Thing. So this change reworks the GUI side of the mechanism to be more similar: terminal data now goes into a queue in the Ldisc, and is not sent on to the backend until the backend says it's ready for it via backend_sendok(). So terminal-based userpass prompts can now consume data directly from that queue during the connection setup stage. As a result, the 'bufchain *' parameter has vanished from all the userpass_input functions (both the official implementations of the Seat trait method, and term_get_userpass_input() to which some of those implementations delegate). The only function that actually used that bufchain, namely term_get_userpass_input(), now instead reads from the ldisc's input queue via a couple of new Ldisc functions. (Not _trivial_ functions, since input buffered by Ldisc can be a mixture of raw bytes and session specials like SS_EOL! The input queue inside Ldisc is a bufchain containing a fiddly binary encoding that can represent an arbitrary interleaving of those things.) This greatly simplifies the calls to seat_get_userpass_input in backends, which now don't have to mess about with passing their own user_input bufchain around, or toggling their want_user_input flag back and forth to request data to put on to that bufchain. But the flip side is that now there has to be some _other_ method for notifying the terminal when there's more input to be consumed during an interactive prompt, and for notifying the backend when prompt input has finished so that it can proceed to the next stage of the protocol. This is done by a pair of extra callbacks: when more data is put on to Ldisc's input queue, it triggers a call to term_get_userpass_input, and when term_get_userpass_input finishes, it calls a callback function provided in the prompts_t. Therefore, any use of a prompts_t which *might* be asynchronous must fill in the latter callback when setting up the prompts_t. In SSH, the callback is centralised into a common PPL helper function, which reinvokes the same PPL's process_queue coroutine; in rlogin we have to set it up ourselves. I'm sorry for this large and sprawling patch: I tried fairly hard to break it up into individually comprehensible sub-patches, but I just couldn't tease out any part of it that would stand sensibly alone.
575 lines
20 KiB
C
575 lines
20 KiB
C
/*
|
|
* ldisc.c: PuTTY line discipline. Sits between the input coming
|
|
* from keypresses in the window, and the output channel leading to
|
|
* the back end. Implements echo and/or local line editing,
|
|
* depending on what's currently configured.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <ctype.h>
|
|
#include <assert.h>
|
|
|
|
#include "putty.h"
|
|
#include "terminal.h"
|
|
|
|
struct Ldisc_tag {
|
|
Terminal *term;
|
|
Backend *backend;
|
|
Seat *seat;
|
|
|
|
/*
|
|
* When the backend is not reporting true from sendok(), terminal
|
|
* input that comes here is stored in this bufchain instead. When
|
|
* the backend later decides it wants session input, we empty the
|
|
* queue in ldisc_check_sendok_callback(), passing its contents on
|
|
* to the backend. Before then, we also provide data from this
|
|
* queue to term_get_userpass_input() via ldisc_get_input_token(),
|
|
* to be interpreted as user responses to username and password
|
|
* prompts during authentication.
|
|
*
|
|
* Unfortunately, the data stored in this queue is not all of the
|
|
* same type: our output to the backend consists of both raw bytes
|
|
* sent to backend_send(), and also session specials such as
|
|
* SS_EOL and SS_EC. So we have to encode our queued data in a way
|
|
* that can represent both.
|
|
*
|
|
* The encoding is private to this source file, so we can change
|
|
* it if necessary and only have to worry about the encode and
|
|
* decode functions here. Currently, it is:
|
|
*
|
|
* - Bytes other than 0xFF are stored literally.
|
|
* - The byte 0xFF itself is stored as 0xFF 0xFF.
|
|
* - A session special (code, arg) is stored as 0xFF, followed by
|
|
* a big-endian 4-byte integer containing code, followed by
|
|
* another big-endian 4-byte integer containing arg.
|
|
*
|
|
* (This representation relies on session special codes being at
|
|
* most 0xFEFFFFFF when represented in 32 bits, so that the first
|
|
* byte of the 'code' integer can't be confused with the 0xFF
|
|
* followup byte indicating a literal 0xFF, But since session
|
|
* special codes are defined by an enum counting up from zero, and
|
|
* there are only a couple of dozen of them, that shouldn't be a
|
|
* problem! Even so, just in case, an assertion checks that at
|
|
* encode time.)
|
|
*/
|
|
bufchain input_queue;
|
|
|
|
IdempotentCallback input_queue_callback;
|
|
prompts_t *prompts;
|
|
|
|
/*
|
|
* Values cached out of conf.
|
|
*/
|
|
bool telnet_keyboard, telnet_newline;
|
|
int protocol, localecho, localedit;
|
|
|
|
char *buf;
|
|
size_t buflen, bufsiz;
|
|
bool quotenext;
|
|
};
|
|
|
|
#define ECHOING (ldisc->localecho == FORCE_ON || \
|
|
(ldisc->localecho == AUTO && \
|
|
(backend_ldisc_option_state(ldisc->backend, LD_ECHO))))
|
|
#define EDITING (ldisc->localedit == FORCE_ON || \
|
|
(ldisc->localedit == AUTO && \
|
|
(backend_ldisc_option_state(ldisc->backend, LD_EDIT))))
|
|
|
|
static void c_write(Ldisc *ldisc, const void *buf, int len)
|
|
{
|
|
seat_stdout(ldisc->seat, buf, len);
|
|
}
|
|
|
|
static int plen(Ldisc *ldisc, unsigned char c)
|
|
{
|
|
if ((c >= 32 && c <= 126) || (c >= 160 && !in_utf(ldisc->term)))
|
|
return 1;
|
|
else if (c < 128)
|
|
return 2; /* ^x for some x */
|
|
else if (in_utf(ldisc->term) && c >= 0xC0)
|
|
return 1; /* UTF-8 introducer character
|
|
* (FIXME: combining / wide chars) */
|
|
else if (in_utf(ldisc->term) && c >= 0x80 && c < 0xC0)
|
|
return 0; /* UTF-8 followup character */
|
|
else
|
|
return 4; /* <XY> hex representation */
|
|
}
|
|
|
|
static void pwrite(Ldisc *ldisc, unsigned char c)
|
|
{
|
|
if ((c >= 32 && c <= 126) ||
|
|
(!in_utf(ldisc->term) && c >= 0xA0) ||
|
|
(in_utf(ldisc->term) && c >= 0x80)) {
|
|
c_write(ldisc, &c, 1);
|
|
} else if (c < 128) {
|
|
char cc[2];
|
|
cc[1] = (c == 127 ? '?' : c + 0x40);
|
|
cc[0] = '^';
|
|
c_write(ldisc, cc, 2);
|
|
} else {
|
|
char cc[5];
|
|
sprintf(cc, "<%02X>", c);
|
|
c_write(ldisc, cc, 4);
|
|
}
|
|
}
|
|
|
|
static bool char_start(Ldisc *ldisc, unsigned char c)
|
|
{
|
|
if (in_utf(ldisc->term))
|
|
return (c < 0x80 || c >= 0xC0);
|
|
else
|
|
return true;
|
|
}
|
|
|
|
static void bsb(Ldisc *ldisc, int n)
|
|
{
|
|
while (n--)
|
|
c_write(ldisc, "\010 \010", 3);
|
|
}
|
|
|
|
static void ldisc_input_queue_callback(void *ctx);
|
|
|
|
#define CTRL(x) (x^'@')
|
|
#define KCTRL(x) ((x^'@') | 0x100)
|
|
|
|
Ldisc *ldisc_create(Conf *conf, Terminal *term, Backend *backend, Seat *seat)
|
|
{
|
|
Ldisc *ldisc = snew(Ldisc);
|
|
|
|
ldisc->buf = NULL;
|
|
ldisc->buflen = 0;
|
|
ldisc->bufsiz = 0;
|
|
ldisc->quotenext = false;
|
|
|
|
ldisc->backend = backend;
|
|
ldisc->term = term;
|
|
ldisc->seat = seat;
|
|
|
|
bufchain_init(&ldisc->input_queue);
|
|
|
|
ldisc->prompts = NULL;
|
|
ldisc->input_queue_callback.fn = ldisc_input_queue_callback;
|
|
ldisc->input_queue_callback.ctx = ldisc;
|
|
ldisc->input_queue_callback.queued = false;
|
|
bufchain_set_callback(&ldisc->input_queue, &ldisc->input_queue_callback);
|
|
|
|
ldisc_configure(ldisc, conf);
|
|
|
|
/* Link ourselves into the backend and the terminal */
|
|
if (term)
|
|
term->ldisc = ldisc;
|
|
if (backend)
|
|
backend_provide_ldisc(backend, ldisc);
|
|
|
|
return ldisc;
|
|
}
|
|
|
|
void ldisc_configure(Ldisc *ldisc, Conf *conf)
|
|
{
|
|
ldisc->telnet_keyboard = conf_get_bool(conf, CONF_telnet_keyboard);
|
|
ldisc->telnet_newline = conf_get_bool(conf, CONF_telnet_newline);
|
|
ldisc->protocol = conf_get_int(conf, CONF_protocol);
|
|
ldisc->localecho = conf_get_int(conf, CONF_localecho);
|
|
ldisc->localedit = conf_get_int(conf, CONF_localedit);
|
|
}
|
|
|
|
void ldisc_free(Ldisc *ldisc)
|
|
{
|
|
bufchain_clear(&ldisc->input_queue);
|
|
if (ldisc->term)
|
|
ldisc->term->ldisc = NULL;
|
|
if (ldisc->backend)
|
|
backend_provide_ldisc(ldisc->backend, NULL);
|
|
if (ldisc->buf)
|
|
sfree(ldisc->buf);
|
|
delete_callbacks_for_context(ldisc);
|
|
sfree(ldisc);
|
|
}
|
|
|
|
void ldisc_echoedit_update(Ldisc *ldisc)
|
|
{
|
|
seat_echoedit_update(ldisc->seat, ECHOING, EDITING);
|
|
}
|
|
|
|
void ldisc_enable_prompt_callback(Ldisc *ldisc, prompts_t *prompts)
|
|
{
|
|
/*
|
|
* Called by the terminal to indicate that there's a prompts_t
|
|
* currently in flight, or to indicate that one has just finished
|
|
* (by passing NULL). When ldisc->prompts is not null, we notify
|
|
* the terminal whenever new data arrives in our input queue, so
|
|
* that it can continue the interactive prompting process.
|
|
*/
|
|
ldisc->prompts = prompts;
|
|
}
|
|
|
|
static void ldisc_input_queue_callback(void *ctx)
|
|
{
|
|
/*
|
|
* Toplevel callback that is triggered whenever the input queue
|
|
* lengthens. If we're currently processing an interactive prompt,
|
|
* we call back the Terminal to tell it to do some more stuff with
|
|
* that prompt based on the new input.
|
|
*/
|
|
Ldisc *ldisc = (Ldisc *)ctx;
|
|
if (ldisc->term && ldisc->prompts) {
|
|
/*
|
|
* The integer return value from this call is discarded,
|
|
* because we have no channel to pass it on to the backend
|
|
* that originally wanted it. But that's OK, because if the
|
|
* return value is >= 0 (that is, the prompts are either
|
|
* completely filled in, or aborted by the user), then the
|
|
* terminal will notify the callback in the prompts_t, and
|
|
* when that calls term_get_userpass_input again, it will
|
|
* return the same answer again.
|
|
*/
|
|
term_get_userpass_input(ldisc->term, ldisc->prompts);
|
|
}
|
|
}
|
|
|
|
static void ldisc_to_backend_raw(
|
|
Ldisc *ldisc, const void *vbuf, size_t len)
|
|
{
|
|
if (backend_sendok(ldisc->backend)) {
|
|
backend_send(ldisc->backend, vbuf, len);
|
|
} else {
|
|
const char *buf = (const char *)vbuf;
|
|
while (len > 0) {
|
|
/*
|
|
* Encode raw data in input_queue, by storing large chunks
|
|
* as long as they don't include 0xFF, and pausing every
|
|
* time they do to escape it.
|
|
*/
|
|
const char *ff = memchr(buf, '\xFF', len);
|
|
size_t this_len = ff ? ff - buf : len;
|
|
if (this_len > 0) {
|
|
bufchain_add(&ldisc->input_queue, buf, len);
|
|
} else {
|
|
bufchain_add(&ldisc->input_queue, "\xFF\xFF", 2);
|
|
this_len = 1;
|
|
}
|
|
buf += this_len;
|
|
len -= this_len;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void ldisc_to_backend_special(
|
|
Ldisc *ldisc, SessionSpecialCode code, int arg)
|
|
{
|
|
if (backend_sendok(ldisc->backend)) {
|
|
backend_special(ldisc->backend, code, arg);
|
|
} else {
|
|
/*
|
|
* Encode a session special in input_queue.
|
|
*/
|
|
unsigned char data[9];
|
|
data[0] = 0xFF;
|
|
PUT_32BIT_MSB_FIRST(data+1, code);
|
|
PUT_32BIT_MSB_FIRST(data+5, arg);
|
|
assert(data[1] != 0xFF &&
|
|
"SessionSpecialCode encoding collides with FF FF escape");
|
|
bufchain_add(&ldisc->input_queue, data, 9);
|
|
}
|
|
}
|
|
|
|
bool ldisc_has_input_buffered(Ldisc *ldisc)
|
|
{
|
|
return bufchain_size(&ldisc->input_queue) > 0;
|
|
}
|
|
|
|
LdiscInputToken ldisc_get_input_token(Ldisc *ldisc)
|
|
{
|
|
assert(bufchain_size(&ldisc->input_queue) > 0 &&
|
|
"You're not supposed to call this unless there is buffered input!");
|
|
|
|
LdiscInputToken tok;
|
|
|
|
char c;
|
|
bufchain_fetch_consume(&ldisc->input_queue, &c, 1);
|
|
if (c != '\xFF') {
|
|
/* A literal non-FF byte */
|
|
tok.is_special = false;
|
|
tok.chr = c;
|
|
return tok;
|
|
} else {
|
|
char data[8];
|
|
|
|
/* See if the byte after the FF is also FF, indicating a literal FF */
|
|
bufchain_fetch_consume(&ldisc->input_queue, data, 1);
|
|
if (data[0] == '\xFF') {
|
|
tok.is_special = false;
|
|
tok.chr = '\xFF';
|
|
return tok;
|
|
}
|
|
|
|
/* If not, get the rest of an 8-byte chunk and decode a special */
|
|
bufchain_fetch_consume(&ldisc->input_queue, data+1, 7);
|
|
tok.is_special = true;
|
|
tok.code = GET_32BIT_MSB_FIRST(data);
|
|
tok.arg = toint(GET_32BIT_MSB_FIRST(data+4));
|
|
return tok;
|
|
}
|
|
}
|
|
|
|
static void ldisc_check_sendok_callback(void *ctx)
|
|
{
|
|
Ldisc *ldisc = (Ldisc *)ctx;
|
|
|
|
if (!(ldisc->backend && backend_sendok(ldisc->backend)))
|
|
return;
|
|
|
|
/*
|
|
* Flush the ldisc input queue into the backend, which is now
|
|
* willing to receive the data.
|
|
*/
|
|
while (bufchain_size(&ldisc->input_queue) > 0) {
|
|
/*
|
|
* Process either a chunk of non-special data, or an FF
|
|
* escape, depending on whether the first thing we see is an
|
|
* FF byte.
|
|
*/
|
|
ptrlen data = bufchain_prefix(&ldisc->input_queue);
|
|
const char *ff = memchr(data.ptr, '\xFF', data.len);
|
|
if (ff != data.ptr) {
|
|
/* Send a maximal block of data not containing any
|
|
* difficult bytes. */
|
|
if (ff)
|
|
data.len = ff - (const char *)data.ptr;
|
|
backend_send(ldisc->backend, data.ptr, data.len);
|
|
bufchain_consume(&ldisc->input_queue, data.len);
|
|
} else {
|
|
/* Decode either a special or an escaped FF byte. The
|
|
* easiest way to do this is to reuse the decoding code
|
|
* already in ldisc_get_input_token. */
|
|
LdiscInputToken tok = ldisc_get_input_token(ldisc);
|
|
if (tok.is_special)
|
|
backend_special(ldisc->backend, tok.code, tok.arg);
|
|
else
|
|
backend_send(ldisc->backend, &tok.chr, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ldisc_check_sendok(Ldisc *ldisc)
|
|
{
|
|
queue_toplevel_callback(ldisc_check_sendok_callback, ldisc);
|
|
}
|
|
|
|
void ldisc_send(Ldisc *ldisc, const void *vbuf, int len, bool interactive)
|
|
{
|
|
const char *buf = (const char *)vbuf;
|
|
int keyflag = 0;
|
|
|
|
assert(ldisc->term);
|
|
|
|
if (interactive) {
|
|
/*
|
|
* Interrupt a paste from the clipboard, if one was in
|
|
* progress when the user pressed a key. This is easier than
|
|
* buffering the current piece of data and saving it until the
|
|
* terminal has finished pasting, and has the potential side
|
|
* benefit of permitting a user to cancel an accidental huge
|
|
* paste.
|
|
*/
|
|
term_nopaste(ldisc->term);
|
|
}
|
|
|
|
/*
|
|
* Less than zero means null terminated special string.
|
|
*/
|
|
if (len < 0) {
|
|
len = strlen(buf);
|
|
keyflag = KCTRL('@');
|
|
}
|
|
/*
|
|
* Either perform local editing, or just send characters.
|
|
*/
|
|
if (EDITING) {
|
|
while (len--) {
|
|
int c;
|
|
c = (unsigned char)(*buf++) + keyflag;
|
|
if (!interactive && c == '\r')
|
|
c += KCTRL('@');
|
|
switch (ldisc->quotenext ? ' ' : c) {
|
|
/*
|
|
* ^h/^?: delete, and output BSBs, to return to
|
|
* last character boundary (in UTF-8 mode this may
|
|
* be more than one byte)
|
|
* ^w: delete, and output BSBs, to return to last
|
|
* space/nonspace boundary
|
|
* ^u: delete, and output BSBs, to return to BOL
|
|
* ^c: Do a ^u then send a telnet IP
|
|
* ^z: Do a ^u then send a telnet SUSP
|
|
* ^\: Do a ^u then send a telnet ABORT
|
|
* ^r: echo "^R\n" and redraw line
|
|
* ^v: quote next char
|
|
* ^d: if at BOL, end of file and close connection,
|
|
* else send line and reset to BOL
|
|
* ^m: send line-plus-\r\n and reset to BOL
|
|
*/
|
|
case KCTRL('H'):
|
|
case KCTRL('?'): /* backspace/delete */
|
|
if (ldisc->buflen > 0) {
|
|
do {
|
|
if (ECHOING)
|
|
bsb(ldisc, plen(ldisc, ldisc->buf[ldisc->buflen - 1]));
|
|
ldisc->buflen--;
|
|
} while (!char_start(ldisc, ldisc->buf[ldisc->buflen]));
|
|
}
|
|
break;
|
|
case CTRL('W'): /* delete word */
|
|
while (ldisc->buflen > 0) {
|
|
if (ECHOING)
|
|
bsb(ldisc, plen(ldisc, ldisc->buf[ldisc->buflen - 1]));
|
|
ldisc->buflen--;
|
|
if (ldisc->buflen > 0 &&
|
|
isspace((unsigned char)ldisc->buf[ldisc->buflen-1]) &&
|
|
!isspace((unsigned char)ldisc->buf[ldisc->buflen]))
|
|
break;
|
|
}
|
|
break;
|
|
case CTRL('U'): /* delete line */
|
|
case CTRL('C'): /* Send IP */
|
|
case CTRL('\\'): /* Quit */
|
|
case CTRL('Z'): /* Suspend */
|
|
while (ldisc->buflen > 0) {
|
|
if (ECHOING)
|
|
bsb(ldisc, plen(ldisc, ldisc->buf[ldisc->buflen - 1]));
|
|
ldisc->buflen--;
|
|
}
|
|
ldisc_to_backend_special(ldisc, SS_EL, 0);
|
|
/*
|
|
* We don't send IP, SUSP or ABORT if the user has
|
|
* configured telnet specials off! This breaks
|
|
* talkers otherwise.
|
|
*/
|
|
if (!ldisc->telnet_keyboard)
|
|
goto default_case;
|
|
if (c == CTRL('C'))
|
|
ldisc_to_backend_special(ldisc, SS_IP, 0);
|
|
if (c == CTRL('Z'))
|
|
ldisc_to_backend_special(ldisc, SS_SUSP, 0);
|
|
if (c == CTRL('\\'))
|
|
ldisc_to_backend_special(ldisc, SS_ABORT, 0);
|
|
break;
|
|
case CTRL('R'): /* redraw line */
|
|
if (ECHOING) {
|
|
int i;
|
|
c_write(ldisc, "^R\r\n", 4);
|
|
for (i = 0; i < ldisc->buflen; i++)
|
|
pwrite(ldisc, ldisc->buf[i]);
|
|
}
|
|
break;
|
|
case CTRL('V'): /* quote next char */
|
|
ldisc->quotenext = true;
|
|
break;
|
|
case CTRL('D'): /* logout or send */
|
|
if (ldisc->buflen == 0) {
|
|
ldisc_to_backend_special(ldisc, SS_EOF, 0);
|
|
} else {
|
|
ldisc_to_backend_raw(ldisc, ldisc->buf, ldisc->buflen);
|
|
ldisc->buflen = 0;
|
|
}
|
|
break;
|
|
/*
|
|
* This particularly hideous bit of code from RDB
|
|
* allows ordinary ^M^J to do the same thing as
|
|
* magic-^M when in Raw protocol. The line `case
|
|
* KCTRL('M'):' is _inside_ the if block. Thus:
|
|
*
|
|
* - receiving regular ^M goes straight to the
|
|
* default clause and inserts as a literal ^M.
|
|
* - receiving regular ^J _not_ directly after a
|
|
* literal ^M (or not in Raw protocol) fails the
|
|
* if condition, leaps to the bottom of the if,
|
|
* and falls through into the default clause
|
|
* again.
|
|
* - receiving regular ^J just after a literal ^M
|
|
* in Raw protocol passes the if condition,
|
|
* deletes the literal ^M, and falls through
|
|
* into the magic-^M code
|
|
* - receiving a magic-^M empties the line buffer,
|
|
* signals end-of-line in one of the various
|
|
* entertaining ways, and _doesn't_ fall out of
|
|
* the bottom of the if and through to the
|
|
* default clause because of the break.
|
|
*/
|
|
case CTRL('J'):
|
|
if (ldisc->protocol == PROT_RAW &&
|
|
ldisc->buflen > 0 && ldisc->buf[ldisc->buflen - 1] == '\r') {
|
|
if (ECHOING)
|
|
bsb(ldisc, plen(ldisc, ldisc->buf[ldisc->buflen - 1]));
|
|
ldisc->buflen--;
|
|
/* FALLTHROUGH */
|
|
case KCTRL('M'): /* send with newline */
|
|
if (ldisc->buflen > 0)
|
|
ldisc_to_backend_raw(ldisc, ldisc->buf, ldisc->buflen);
|
|
if (ldisc->protocol == PROT_RAW)
|
|
ldisc_to_backend_raw(ldisc, "\r\n", 2);
|
|
else if (ldisc->protocol == PROT_TELNET && ldisc->telnet_newline)
|
|
ldisc_to_backend_special(ldisc, SS_EOL, 0);
|
|
else
|
|
ldisc_to_backend_raw(ldisc, "\r", 1);
|
|
if (ECHOING)
|
|
c_write(ldisc, "\r\n", 2);
|
|
ldisc->buflen = 0;
|
|
break;
|
|
}
|
|
/* FALLTHROUGH */
|
|
default: /* get to this label from ^V handler */
|
|
default_case:
|
|
sgrowarray(ldisc->buf, ldisc->bufsiz, ldisc->buflen);
|
|
ldisc->buf[ldisc->buflen++] = c;
|
|
if (ECHOING)
|
|
pwrite(ldisc, (unsigned char) c);
|
|
ldisc->quotenext = false;
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
if (ldisc->buflen != 0) {
|
|
ldisc_to_backend_raw(ldisc, ldisc->buf, ldisc->buflen);
|
|
while (ldisc->buflen > 0) {
|
|
bsb(ldisc, plen(ldisc, ldisc->buf[ldisc->buflen - 1]));
|
|
ldisc->buflen--;
|
|
}
|
|
}
|
|
if (len > 0) {
|
|
if (ECHOING)
|
|
c_write(ldisc, buf, len);
|
|
if (keyflag && ldisc->protocol == PROT_TELNET && len == 1) {
|
|
switch (buf[0]) {
|
|
case CTRL('M'):
|
|
if (ldisc->protocol == PROT_TELNET && ldisc->telnet_newline)
|
|
ldisc_to_backend_special(ldisc, SS_EOL, 0);
|
|
else
|
|
ldisc_to_backend_raw(ldisc, "\r", 1);
|
|
break;
|
|
case CTRL('?'):
|
|
case CTRL('H'):
|
|
if (ldisc->telnet_keyboard) {
|
|
ldisc_to_backend_special(ldisc, SS_EC, 0);
|
|
break;
|
|
}
|
|
case CTRL('C'):
|
|
if (ldisc->telnet_keyboard) {
|
|
ldisc_to_backend_special(ldisc, SS_IP, 0);
|
|
break;
|
|
}
|
|
case CTRL('Z'):
|
|
if (ldisc->telnet_keyboard) {
|
|
ldisc_to_backend_special(ldisc, SS_SUSP, 0);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
ldisc_to_backend_raw(ldisc, buf, len);
|
|
break;
|
|
}
|
|
} else
|
|
ldisc_to_backend_raw(ldisc, buf, len);
|
|
}
|
|
}
|
|
}
|