diff options
Diffstat (limited to 'ssh2connection.c')
| -rw-r--r-- | ssh2connection.c | 1745 |
1 files changed, 0 insertions, 1745 deletions
diff --git a/ssh2connection.c b/ssh2connection.c deleted file mode 100644 index ecb421ea..00000000 --- a/ssh2connection.c +++ /dev/null @@ -1,1745 +0,0 @@ -/* - * Packet protocol layer for the SSH-2 connection protocol (RFC 4254). - */ - -#include <assert.h> - -#include "putty.h" -#include "ssh.h" -#include "sshbpp.h" -#include "sshppl.h" -#include "sshchan.h" -#include "sshcr.h" -#include "ssh2connection.h" - -static void ssh2_connection_free(PacketProtocolLayer *); -static void ssh2_connection_process_queue(PacketProtocolLayer *); -static bool ssh2_connection_get_specials( - PacketProtocolLayer *ppl, add_special_fn_t add_special, void *ctx); -static void ssh2_connection_special_cmd(PacketProtocolLayer *ppl, - SessionSpecialCode code, int arg); -static bool ssh2_connection_want_user_input(PacketProtocolLayer *ppl); -static void ssh2_connection_got_user_input(PacketProtocolLayer *ppl); -static void ssh2_connection_reconfigure(PacketProtocolLayer *ppl, Conf *conf); - -static const PacketProtocolLayerVtable ssh2_connection_vtable = { - .free = ssh2_connection_free, - .process_queue = ssh2_connection_process_queue, - .get_specials = ssh2_connection_get_specials, - .special_cmd = ssh2_connection_special_cmd, - .want_user_input = ssh2_connection_want_user_input, - .got_user_input = ssh2_connection_got_user_input, - .reconfigure = ssh2_connection_reconfigure, - .queued_data_size = ssh_ppl_default_queued_data_size, - .name = "ssh-connection", -}; - -static SshChannel *ssh2_lportfwd_open( - ConnectionLayer *cl, const char *hostname, int port, - const char *description, const SocketPeerInfo *pi, Channel *chan); -static struct X11FakeAuth *ssh2_add_x11_display( - ConnectionLayer *cl, int authtype, struct X11Display *x11disp); -static struct X11FakeAuth *ssh2_add_sharing_x11_display( - ConnectionLayer *cl, int authtype, ssh_sharing_connstate *share_cs, - share_channel *share_chan); -static void ssh2_remove_sharing_x11_display(ConnectionLayer *cl, - struct X11FakeAuth *auth); -static void ssh2_send_packet_from_downstream( - ConnectionLayer *cl, unsigned id, int type, - const void *pkt, int pktlen, const char *additional_log_text); -static unsigned ssh2_alloc_sharing_channel( - ConnectionLayer *cl, ssh_sharing_connstate *connstate); -static void ssh2_delete_sharing_channel( - ConnectionLayer *cl, unsigned localid); -static void ssh2_sharing_queue_global_request( - ConnectionLayer *cl, ssh_sharing_connstate *share_ctx); -static void ssh2_sharing_no_more_downstreams(ConnectionLayer *cl); -static bool ssh2_agent_forwarding_permitted(ConnectionLayer *cl); -static void ssh2_terminal_size(ConnectionLayer *cl, int width, int height); -static void ssh2_stdout_unthrottle(ConnectionLayer *cl, size_t bufsize); -static size_t ssh2_stdin_backlog(ConnectionLayer *cl); -static void ssh2_throttle_all_channels(ConnectionLayer *cl, bool throttled); -static bool ssh2_ldisc_option(ConnectionLayer *cl, int option); -static void ssh2_set_ldisc_option(ConnectionLayer *cl, int option, bool value); -static void ssh2_enable_x_fwd(ConnectionLayer *cl); -static void ssh2_set_wants_user_input(ConnectionLayer *cl, bool wanted); - -static const ConnectionLayerVtable ssh2_connlayer_vtable = { - .rportfwd_alloc = ssh2_rportfwd_alloc, - .rportfwd_remove = ssh2_rportfwd_remove, - .lportfwd_open = ssh2_lportfwd_open, - .session_open = ssh2_session_open, - .serverside_x11_open = ssh2_serverside_x11_open, - .serverside_agent_open = ssh2_serverside_agent_open, - .add_x11_display = ssh2_add_x11_display, - .add_sharing_x11_display = ssh2_add_sharing_x11_display, - .remove_sharing_x11_display = ssh2_remove_sharing_x11_display, - .send_packet_from_downstream = ssh2_send_packet_from_downstream, - .alloc_sharing_channel = ssh2_alloc_sharing_channel, - .delete_sharing_channel = ssh2_delete_sharing_channel, - .sharing_queue_global_request = ssh2_sharing_queue_global_request, - .sharing_no_more_downstreams = ssh2_sharing_no_more_downstreams, - .agent_forwarding_permitted = ssh2_agent_forwarding_permitted, - .terminal_size = ssh2_terminal_size, - .stdout_unthrottle = ssh2_stdout_unthrottle, - .stdin_backlog = ssh2_stdin_backlog, - .throttle_all_channels = ssh2_throttle_all_channels, - .ldisc_option = ssh2_ldisc_option, - .set_ldisc_option = ssh2_set_ldisc_option, - .enable_x_fwd = ssh2_enable_x_fwd, - .set_wants_user_input = ssh2_set_wants_user_input, -}; - -static char *ssh2_channel_open_failure_error_text(PktIn *pktin) -{ - static const char *const reasons[] = { - NULL, - "Administratively prohibited", - "Connect failed", - "Unknown channel type", - "Resource shortage", - }; - unsigned reason_code; - const char *reason_code_string; - char reason_code_buf[256]; - ptrlen reason; - - reason_code = get_uint32(pktin); - if (reason_code < lenof(reasons) && reasons[reason_code]) { - reason_code_string = reasons[reason_code]; - } else { - reason_code_string = reason_code_buf; - sprintf(reason_code_buf, "unknown reason code %#x", reason_code); - } - - reason = get_string(pktin); - - return dupprintf("%s [%.*s]", reason_code_string, PTRLEN_PRINTF(reason)); -} - -static size_t ssh2channel_write( - SshChannel *c, bool is_stderr, const void *buf, size_t len); -static void ssh2channel_write_eof(SshChannel *c); -static void ssh2channel_initiate_close(SshChannel *c, const char *err); -static void ssh2channel_unthrottle(SshChannel *c, size_t bufsize); -static Conf *ssh2channel_get_conf(SshChannel *c); -static void ssh2channel_window_override_removed(SshChannel *c); -static void ssh2channel_x11_sharing_handover( - SshChannel *c, ssh_sharing_connstate *share_cs, share_channel *share_chan, - const char *peer_addr, int peer_port, int endian, - int protomajor, int protominor, const void *initial_data, int initial_len); -static void ssh2channel_hint_channel_is_simple(SshChannel *c); - -static const SshChannelVtable ssh2channel_vtable = { - .write = ssh2channel_write, - .write_eof = ssh2channel_write_eof, - .initiate_close = ssh2channel_initiate_close, - .unthrottle = ssh2channel_unthrottle, - .get_conf = ssh2channel_get_conf, - .window_override_removed = ssh2channel_window_override_removed, - .x11_sharing_handover = ssh2channel_x11_sharing_handover, - .send_exit_status = ssh2channel_send_exit_status, - .send_exit_signal = ssh2channel_send_exit_signal, - .send_exit_signal_numeric = ssh2channel_send_exit_signal_numeric, - .request_x11_forwarding = ssh2channel_request_x11_forwarding, - .request_agent_forwarding = ssh2channel_request_agent_forwarding, - .request_pty = ssh2channel_request_pty, - .send_env_var = ssh2channel_send_env_var, - .start_shell = ssh2channel_start_shell, - .start_command = ssh2channel_start_command, - .start_subsystem = ssh2channel_start_subsystem, - .send_serial_break = ssh2channel_send_serial_break, - .send_signal = ssh2channel_send_signal, - .send_terminal_size_change = ssh2channel_send_terminal_size_change, - .hint_channel_is_simple = ssh2channel_hint_channel_is_simple, -}; - -static void ssh2_channel_check_close(struct ssh2_channel *c); -static void ssh2_channel_try_eof(struct ssh2_channel *c); -static void ssh2_set_window(struct ssh2_channel *c, int newwin); -static size_t ssh2_try_send(struct ssh2_channel *c); -static void ssh2_try_send_and_unthrottle(struct ssh2_channel *c); -static void ssh2_channel_check_throttle(struct ssh2_channel *c); -static void ssh2_channel_close_local(struct ssh2_channel *c, - const char *reason); -static void ssh2_channel_destroy(struct ssh2_channel *c); - -static void ssh2_check_termination(struct ssh2_connection_state *s); - -struct outstanding_global_request { - gr_handler_fn_t handler; - void *ctx; - struct outstanding_global_request *next; -}; -void ssh2_queue_global_request_handler( - struct ssh2_connection_state *s, gr_handler_fn_t handler, void *ctx) -{ - struct outstanding_global_request *ogr = - snew(struct outstanding_global_request); - ogr->handler = handler; - ogr->ctx = ctx; - if (s->globreq_tail) - s->globreq_tail->next = ogr; - else - s->globreq_head = ogr; - s->globreq_tail = ogr; -} - -static int ssh2_channelcmp(void *av, void *bv) -{ - const struct ssh2_channel *a = (const struct ssh2_channel *) av; - const struct ssh2_channel *b = (const struct ssh2_channel *) bv; - if (a->localid < b->localid) - return -1; - if (a->localid > b->localid) - return +1; - return 0; -} - -static int ssh2_channelfind(void *av, void *bv) -{ - const unsigned *a = (const unsigned *) av; - const struct ssh2_channel *b = (const struct ssh2_channel *) bv; - if (*a < b->localid) - return -1; - if (*a > b->localid) - return +1; - return 0; -} - -/* - * Each channel has a queue of outstanding CHANNEL_REQUESTS and their - * handlers. - */ -struct outstanding_channel_request { - cr_handler_fn_t handler; - void *ctx; - struct outstanding_channel_request *next; -}; - -static void ssh2_channel_free(struct ssh2_channel *c) -{ - bufchain_clear(&c->outbuffer); - bufchain_clear(&c->errbuffer); - while (c->chanreq_head) { - struct outstanding_channel_request *chanreq = c->chanreq_head; - c->chanreq_head = c->chanreq_head->next; - sfree(chanreq); - } - if (c->chan) { - struct ssh2_connection_state *s = c->connlayer; - if (s->mainchan_sc == &c->sc) { - s->mainchan = NULL; - s->mainchan_sc = NULL; - } - chan_free(c->chan); - } - sfree(c); -} - -PacketProtocolLayer *ssh2_connection_new( - Ssh *ssh, ssh_sharing_state *connshare, bool is_simple, - Conf *conf, const char *peer_verstring, ConnectionLayer **cl_out) -{ - struct ssh2_connection_state *s = snew(struct ssh2_connection_state); - memset(s, 0, sizeof(*s)); - s->ppl.vt = &ssh2_connection_vtable; - - s->conf = conf_copy(conf); - - s->ssh_is_simple = is_simple; - - /* - * If the ssh_no_shell option is enabled, we disable the usual - * termination check, so that we persist even in the absence of - * any at all channels (because our purpose is probably to be a - * background port forwarder). - */ - s->persistent = conf_get_bool(s->conf, CONF_ssh_no_shell); - - s->connshare = connshare; - s->peer_verstring = dupstr(peer_verstring); - - s->channels = newtree234(ssh2_channelcmp); - - s->x11authtree = newtree234(x11_authcmp); - - /* Need to get the log context for s->cl now, because we won't be - * helpfully notified when a copy is written into s->ppl by our - * owner. */ - s->cl.vt = &ssh2_connlayer_vtable; - s->cl.logctx = ssh_get_logctx(ssh); - - s->portfwdmgr = portfwdmgr_new(&s->cl); - - *cl_out = &s->cl; - if (s->connshare) - ssh_connshare_provide_connlayer(s->connshare, &s->cl); - - return &s->ppl; -} - -static void ssh2_connection_free(PacketProtocolLayer *ppl) -{ - struct ssh2_connection_state *s = - container_of(ppl, struct ssh2_connection_state, ppl); - struct X11FakeAuth *auth; - struct ssh2_channel *c; - struct ssh_rportfwd *rpf; - - sfree(s->peer_verstring); - - conf_free(s->conf); - - while ((c = delpos234(s->channels, 0)) != NULL) - ssh2_channel_free(c); - freetree234(s->channels); - - while ((auth = delpos234(s->x11authtree, 0)) != NULL) { - if (auth->disp) - x11_free_display(auth->disp); - x11_free_fake_auth(auth); - } - freetree234(s->x11authtree); - - if (s->rportfwds) { - while ((rpf = delpos234(s->rportfwds, 0)) != NULL) - free_rportfwd(rpf); - freetree234(s->rportfwds); - } - portfwdmgr_free(s->portfwdmgr); - - if (s->antispoof_prompt) - free_prompts(s->antispoof_prompt); - - delete_callbacks_for_context(s); - - sfree(s); -} - -static bool ssh2_connection_filter_queue(struct ssh2_connection_state *s) -{ - PktIn *pktin; - PktOut *pktout; - ptrlen type, data; - struct ssh2_channel *c; - struct outstanding_channel_request *ocr; - unsigned localid, remid, winsize, pktsize, ext_type; - bool want_reply, reply_success, expect_halfopen; - ChanopenResult chanopen_result; - PacketProtocolLayer *ppl = &s->ppl; /* for ppl_logevent */ - - while (1) { - if (ssh2_common_filter_queue(&s->ppl)) - return true; - if ((pktin = pq_peek(s->ppl.in_pq)) == NULL) - return false; - - switch (pktin->type) { - case SSH2_MSG_GLOBAL_REQUEST: - type = get_string(pktin); - want_reply = get_bool(pktin); - - reply_success = ssh2_connection_parse_global_request( - s, type, pktin); - - if (want_reply) { - int type = (reply_success ? SSH2_MSG_REQUEST_SUCCESS : - SSH2_MSG_REQUEST_FAILURE); - pktout = ssh_bpp_new_pktout(s->ppl.bpp, type); - pq_push(s->ppl.out_pq, pktout); - } - pq_pop(s->ppl.in_pq); - break; - - case SSH2_MSG_REQUEST_SUCCESS: - case SSH2_MSG_REQUEST_FAILURE: - if (!s->globreq_head) { - ssh_proto_error( - s->ppl.ssh, - "Received %s with no outstanding global request", - ssh2_pkt_type(s->ppl.bpp->pls->kctx, s->ppl.bpp->pls->actx, - pktin->type)); - return true; - } - - s->globreq_head->handler(s, pktin, s->globreq_head->ctx); - { - struct outstanding_global_request *tmp = s->globreq_head; - s->globreq_head = s->globreq_head->next; - sfree(tmp); - } - - pq_pop(s->ppl.in_pq); - break; - - case SSH2_MSG_CHANNEL_OPEN: - type = get_string(pktin); - c = snew(struct ssh2_channel); - c->connlayer = s; - c->chan = NULL; - - remid = get_uint32(pktin); - winsize = get_uint32(pktin); - pktsize = get_uint32(pktin); - - chanopen_result = ssh2_connection_parse_channel_open( - s, type, pktin, &c->sc); - - if (chanopen_result.outcome == CHANOPEN_RESULT_DOWNSTREAM) { - /* - * This channel-open request needs to go to a - * connection-sharing downstream, so abandon our own - * channel-open procedure and just pass the message on - * to sshshare.c. - */ - share_got_pkt_from_server( - chanopen_result.u.downstream.share_ctx, pktin->type, - BinarySource_UPCAST(pktin)->data, - BinarySource_UPCAST(pktin)->len); - sfree(c); - break; - } - - c->remoteid = remid; - c->halfopen = false; - if (chanopen_result.outcome == CHANOPEN_RESULT_FAILURE) { - pktout = ssh_bpp_new_pktout( - s->ppl.bpp, SSH2_MSG_CHANNEL_OPEN_FAILURE); - put_uint32(pktout, c->remoteid); - put_uint32(pktout, chanopen_result.u.failure.reason_code); - put_stringz(pktout, chanopen_result.u.failure.wire_message); - put_stringz(pktout, "en"); /* language tag */ - pq_push(s->ppl.out_pq, pktout); - ppl_logevent("Rejected channel open: %s", - chanopen_result.u.failure.wire_message); - sfree(chanopen_result.u.failure.wire_message); - sfree(c); - } else { - c->chan = chanopen_result.u.success.channel; - ssh2_channel_init(c); - c->remwindow = winsize; - c->remmaxpkt = pktsize; - if (c->remmaxpkt > s->ppl.bpp->vt->packet_size_limit) - c->remmaxpkt = s->ppl.bpp->vt->packet_size_limit; - if (c->chan->initial_fixed_window_size) { - c->locwindow = c->locmaxwin = c->remlocwin = - c->chan->initial_fixed_window_size; - } - pktout = ssh_bpp_new_pktout( - s->ppl.bpp, SSH2_MSG_CHANNEL_OPEN_CONFIRMATION); - put_uint32(pktout, c->remoteid); - put_uint32(pktout, c->localid); - put_uint32(pktout, c->locwindow); - put_uint32(pktout, OUR_V2_MAXPKT); /* our max pkt size */ - pq_push(s->ppl.out_pq, pktout); - } - - pq_pop(s->ppl.in_pq); - break; - - case SSH2_MSG_CHANNEL_DATA: - case SSH2_MSG_CHANNEL_EXTENDED_DATA: - case SSH2_MSG_CHANNEL_WINDOW_ADJUST: - case SSH2_MSG_CHANNEL_REQUEST: - case SSH2_MSG_CHANNEL_EOF: - case SSH2_MSG_CHANNEL_CLOSE: - case SSH2_MSG_CHANNEL_OPEN_CONFIRMATION: - case SSH2_MSG_CHANNEL_OPEN_FAILURE: - case SSH2_MSG_CHANNEL_SUCCESS: - case SSH2_MSG_CHANNEL_FAILURE: - /* - * Common preliminary code for all the messages from the - * server that cite one of our channel ids: look up that - * channel id, check it exists, and if it's for a sharing - * downstream, pass it on. - */ - localid = get_uint32(pktin); - c = find234(s->channels, &localid, ssh2_channelfind); - - if (c && c->sharectx) { - share_got_pkt_from_server(c->sharectx, pktin->type, - BinarySource_UPCAST(pktin)->data, - BinarySource_UPCAST(pktin)->len); - pq_pop(s->ppl.in_pq); - break; - } - - expect_halfopen = ( - pktin->type == SSH2_MSG_CHANNEL_OPEN_CONFIRMATION || - pktin->type == SSH2_MSG_CHANNEL_OPEN_FAILURE); - - if (!c || c->halfopen != expect_halfopen) { - ssh_proto_error(s->ppl.ssh, - "Received %s for %s channel %u", - ssh2_pkt_type(s->ppl.bpp->pls->kctx, - s->ppl.bpp->pls->actx, - pktin->type), - (!c ? "nonexistent" : - c->halfopen ? "half-open" : "open"), - localid); - return true; - } - - switch (pktin->type) { - case SSH2_MSG_CHANNEL_OPEN_CONFIRMATION: - assert(c->halfopen); - c->remoteid = get_uint32(pktin); - c->halfopen = false; - c->remwindow = get_uint32(pktin); - c->remmaxpkt = get_uint32(pktin); - if (c->remmaxpkt > s->ppl.bpp->vt->packet_size_limit) - c->remmaxpkt = s->ppl.bpp->vt->packet_size_limit; - - chan_open_confirmation(c->chan); - - /* - * Now that the channel is fully open, it's possible - * in principle to immediately close it. Check whether - * it wants us to! - * - * This can occur if a local socket error occurred - * between us sending out CHANNEL_OPEN and receiving - * OPEN_CONFIRMATION. If that happens, all we can do - * is immediately initiate close proceedings now that - * we know the server's id to put in the close - * message. We'll have handled that in this code by - * having already turned c->chan into a zombie, so its - * want_close method (which ssh2_channel_check_close - * will consult) will already be returning true. - */ - ssh2_channel_check_close(c); - - if (c->pending_eof) - ssh2_channel_try_eof(c); /* in case we had a pending EOF */ - break; - - case SSH2_MSG_CHANNEL_OPEN_FAILURE: { - assert(c->halfopen); - - char *err = ssh2_channel_open_failure_error_text(pktin); - chan_open_failed(c->chan, err); - sfree(err); - - del234(s->channels, c); - ssh2_channel_free(c); - - break; - } - - case SSH2_MSG_CHANNEL_DATA: - case SSH2_MSG_CHANNEL_EXTENDED_DATA: - ext_type = (pktin->type == SSH2_MSG_CHANNEL_DATA ? 0 : - get_uint32(pktin)); - data = get_string(pktin); - if (!get_err(pktin)) { - int bufsize; - c->locwindow -= data.len; - c->remlocwin -= data.len; - if (ext_type != 0 && ext_type != SSH2_EXTENDED_DATA_STDERR) - data.len = 0; /* ignore unknown extended data */ - bufsize = chan_send( - c->chan, ext_type == SSH2_EXTENDED_DATA_STDERR, - data.ptr, data.len); - - /* - * The channel may have turned into a connection- - * shared one as a result of that chan_send, e.g. - * if the data we just provided completed the X11 - * auth phase and caused a callback to - * x11_sharing_handover. If so, do nothing - * further. - */ - if (c->sharectx) - break; - - /* - * If it looks like the remote end hit the end of - * its window, and we didn't want it to do that, - * think about using a larger window. - */ - if (c->remlocwin <= 0 && - c->throttle_state == UNTHROTTLED && - c->locmaxwin < 0x40000000) - c->locmaxwin += OUR_V2_WINSIZE; - - /* - * If we are not buffering too much data, enlarge - * the window again at the remote side. If we are - * buffering too much, we may still need to adjust - * the window if the server's sent excess data. - */ - if (bufsize < c->locmaxwin) - ssh2_set_window(c, c->locmaxwin - bufsize); - - /* - * If we're either buffering way too much data, or - * if we're buffering anything at all and we're in - * "simple" mode, throttle the whole channel. - */ - if ((bufsize > c->locmaxwin || - (s->ssh_is_simple && bufsize>0)) && - !c->throttling_conn) { - c->throttling_conn = true; - ssh_throttle_conn(s->ppl.ssh, +1); - } - } - break; - - case SSH2_MSG_CHANNEL_WINDOW_ADJUST: - if (!(c->closes & CLOSES_SENT_EOF)) { - c->remwindow += get_uint32(pktin); - ssh2_try_send_and_unthrottle(c); - } - break; - - case SSH2_MSG_CHANNEL_REQUEST: - type = get_string(pktin); - want_reply = get_bool(pktin); - - reply_success = false; - - if (c->closes & CLOSES_SENT_CLOSE) { - /* - * We don't reply to channel requests after we've - * sent CHANNEL_CLOSE for the channel, because our - * reply might cross in the network with the other - * side's CHANNEL_CLOSE and arrive after they have - * wound the channel up completely. - */ - want_reply = false; - } - - /* - * Try every channel request name we recognise, no - * matter what the channel, and see if the Channel - * instance will accept it. - */ - if (ptrlen_eq_string(type, "exit-status")) { - int exitcode = toint(get_uint32(pktin)); - reply_success = chan_rcvd_exit_status(c->chan, exitcode); - } else if (ptrlen_eq_string(type, "exit-signal")) { - ptrlen signame; - int signum; - bool core = false; - ptrlen errmsg; - int format; - - /* - * ICK: older versions of OpenSSH (e.g. 3.4p1) - * provide an `int' for the signal, despite its - * having been a `string' in the drafts of RFC - * 4254 since at least 2001. (Fixed in session.c - * 1.147.) Try to infer which we can safely parse - * it as. - */ - - size_t startpos = BinarySource_UPCAST(pktin)->pos; - - for (format = 0; format < 2; format++) { - BinarySource_UPCAST(pktin)->pos = startpos; - BinarySource_UPCAST(pktin)->err = BSE_NO_ERROR; - - /* placate compiler warnings about unin */ - signame = make_ptrlen(NULL, 0); - signum = 0; - - if (format == 0) /* standard string-based format */ - signame = get_string(pktin); - else /* nonstandard integer format */ - signum = toint(get_uint32(pktin)); - - core = get_bool(pktin); - errmsg = get_string(pktin); /* error message */ - get_string(pktin); /* language tag */ - - if (!get_err(pktin) && get_avail(pktin) == 0) - break; /* successful parse */ - } - - switch (format) { - case 0: - reply_success = chan_rcvd_exit_signal( - c->chan, signame, core, errmsg); - break; - case 1: - reply_success = chan_rcvd_exit_signal_numeric( - c->chan, signum, core, errmsg); - break; - default: - /* Couldn't parse this message in either format */ - reply_success = false; - break; - } - } else if (ptrlen_eq_string(type, "shell")) { - reply_success = chan_run_shell(c->chan); - } else if (ptrlen_eq_string(type, "exec")) { - ptrlen command = get_string(pktin); - reply_success = chan_run_command(c->chan, command); - } else if (ptrlen_eq_string(type, "subsystem")) { - ptrlen subsys = get_string(pktin); - reply_success = chan_run_subsystem(c->chan, subsys); - } else if (ptrlen_eq_string(type, "x11-req")) { - bool oneshot = get_bool(pktin); - ptrlen authproto = get_string(pktin); - ptrlen authdata = get_string(pktin); - unsigned screen_number = get_uint32(pktin); - reply_success = chan_enable_x11_forwarding( - c->chan, oneshot, authproto, authdata, screen_number); - } else if (ptrlen_eq_string(type, - "auth-agent-req@openssh.com")) { - reply_success = chan_enable_agent_forwarding(c->chan); - } else if (ptrlen_eq_string(type, "pty-req")) { - ptrlen termtype = get_string(pktin); - unsigned width = get_uint32(pktin); - unsigned height = get_uint32(pktin); - unsigned pixwidth = get_uint32(pktin); - unsigned pixheight = get_uint32(pktin); - ptrlen encoded_modes = get_string(pktin); - BinarySource bs_modes[1]; - struct ssh_ttymodes modes; - - BinarySource_BARE_INIT_PL(bs_modes, encoded_modes); - modes = read_ttymodes_from_packet(bs_modes, 2); - if (get_err(bs_modes) || get_avail(bs_modes) > 0) { - ppl_logevent("Unable to decode terminal mode string"); - reply_success = false; - } else { - reply_success = chan_allocate_pty( - c->chan, termtype, width, height, - pixwidth, pixheight, modes); - } - } else if (ptrlen_eq_string(type, "env")) { - ptrlen var = get_string(pktin); - ptrlen value = get_string(pktin); - - reply_success = chan_set_env(c->chan, var, value); - } else if (ptrlen_eq_string(type, "break")) { - unsigned length = get_uint32(pktin); - - reply_success = chan_send_break(c->chan, length); - } else if (ptrlen_eq_string(type, "signal")) { - ptrlen signame = get_string(pktin); - - reply_success = chan_send_signal(c->chan, signame); - } else if (ptrlen_eq_string(type, "window-change")) { - unsigned width = get_uint32(pktin); - unsigned height = get_uint32(pktin); - unsigned pixwidth = get_uint32(pktin); - unsigned pixheight = get_uint32(pktin); - reply_success = chan_change_window_size( - c->chan, width, height, pixwidth, pixheight); - } - if (want_reply) { - int type = (reply_success ? SSH2_MSG_CHANNEL_SUCCESS : - SSH2_MSG_CHANNEL_FAILURE); - pktout = ssh_bpp_new_pktout(s->ppl.bpp, type); - put_uint32(pktout, c->remoteid); - pq_push(s->ppl.out_pq, pktout); - } - break; - - case SSH2_MSG_CHANNEL_SUCCESS: - case SSH2_MSG_CHANNEL_FAILURE: - ocr = c->chanreq_head; - if (!ocr) { - ssh_proto_error( - s->ppl.ssh, - "Received %s for channel %d with no outstanding " - "channel request", - ssh2_pkt_type(s->ppl.bpp->pls->kctx, - s->ppl.bpp->pls->actx, pktin->type), - c->localid); - return true; - } - ocr->handler(c, pktin, ocr->ctx); - c->chanreq_head = ocr->next; - sfree(ocr); - /* - * We may now initiate channel-closing procedures, if - * that CHANNEL_REQUEST was the last thing outstanding - * before we send CHANNEL_CLOSE. - */ - ssh2_channel_check_close(c); - break; - - case SSH2_MSG_CHANNEL_EOF: - if (!(c->closes & CLOSES_RCVD_EOF)) { - c->closes |= CLOSES_RCVD_EOF; - chan_send_eof(c->chan); - ssh2_channel_check_close(c); - } - break; - - case SSH2_MSG_CHANNEL_CLOSE: - /* - * When we receive CLOSE on a channel, we assume it - * comes with an implied EOF if we haven't seen EOF - * yet. - */ - if (!(c->closes & CLOSES_RCVD_EOF)) { - c->closes |= CLOSES_RCVD_EOF; - chan_send_eof(c->chan); - } - - if (!(s->ppl.remote_bugs & BUG_SENDS_LATE_REQUEST_REPLY)) { - /* - * It also means we stop expecting to see replies - * to any outstanding channel requests, so clean - * those up too. (ssh_chanreq_init will enforce by - * assertion that we don't subsequently put - * anything back on this list.) - */ - while (c->chanreq_head) { - struct outstanding_channel_request *ocr = - c->chanreq_head; - ocr->handler(c, NULL, ocr->ctx); - c->chanreq_head = ocr->next; - sfree(ocr); - } - } - - /* - * And we also send an outgoing EOF, if we haven't - * already, on the assumption that CLOSE is a pretty - * forceful announcement that the remote side is doing - * away with the entire channel. (If it had wanted to - * send us EOF and continue receiving data from us, it - * would have just sent CHANNEL_EOF.) - */ - if (!(c->closes & CLOSES_SENT_EOF)) { - /* - * Abandon any buffered data we still wanted to - * send to this channel. Receiving a CHANNEL_CLOSE - * is an indication that the server really wants - * to get on and _destroy_ this channel, and it - * isn't going to send us any further - * WINDOW_ADJUSTs to permit us to send pending - * stuff. - */ - bufchain_clear(&c->outbuffer); - bufchain_clear(&c->errbuffer); - - /* - * Send outgoing EOF. - */ - sshfwd_write_eof(&c->sc); - - /* - * Make sure we don't read any more from whatever - * our local data source is for this channel. - * (This will pick up on the changes made by - * sshfwd_write_eof.) - */ - ssh2_channel_check_throttle(c); - } - - /* - * Now process the actual close. - */ - if (!(c->closes & CLOSES_RCVD_CLOSE)) { - c->closes |= CLOSES_RCVD_CLOSE; - ssh2_channel_check_close(c); - } - - break; - } - - pq_pop(s->ppl.in_pq); - break; - - default: - return false; - } - } -} - -static void ssh2_handle_winadj_response(struct ssh2_channel *c, - PktIn *pktin, void *ctx) -{ - unsigned *sizep = ctx; - - /* - * Winadj responses should always be failures. However, at least - * one server ("boks_sshd") is known to return SUCCESS for channel - * requests it's never heard of, such as "winadj@putty". Raised - * with foxt.com as bug 090916-090424, but for the sake of a quiet - * life, we don't worry about what kind of response we got. - */ - - c->remlocwin += *sizep; - sfree(sizep); - /* - * winadj messages are only sent when the window is fully open, so - * if we get an ack of one, we know any pending unthrottle is - * complete. - */ - if (c->throttle_state == UNTHROTTLING) - c->throttle_state = UNTHROTTLED; -} - -static void ssh2_set_window(struct ssh2_channel *c, int newwin) -{ - struct ssh2_connection_state *s = c->connlayer; - - /* - * Never send WINDOW_ADJUST for a channel that the remote side has - * already sent EOF on; there's no point, since it won't be - * sending any more data anyway. Ditto if _we've_ already sent - * CLOSE. - */ - if (c->closes & (CLOSES_RCVD_EOF | CLOSES_SENT_CLOSE)) - return; - - /* - * If the client-side Channel is in an initial setup phase with a - * fixed window size, e.g. for an X11 channel when we're still - * waiting to see its initial auth and may yet hand it off to a - * downstream, don't send any WINDOW_ADJUST either. - */ - if (c->chan->initial_fixed_window_size) - return; - - /* - * If the remote end has a habit of ignoring maxpkt, limit the - * window so that it has no choice (assuming it doesn't ignore the - * window as well). - */ - if ((s->ppl.remote_bugs & BUG_SSH2_MAXPKT) && newwin > OUR_V2_MAXPKT) - newwin = OUR_V2_MAXPKT; - - /* - * Only send a WINDOW_ADJUST if there's significantly more window - * available than the other end thinks there is. This saves us - * sending a WINDOW_ADJUST for every character in a shell session. - * - * "Significant" is arbitrarily defined as half the window size. - */ - if (newwin / 2 >= c->locwindow) { - PktOut *pktout; - unsigned *up; - - /* - * In order to keep track of how much window the client - * actually has available, we'd like it to acknowledge each - * WINDOW_ADJUST. We can't do that directly, so we accompany - * it with a CHANNEL_REQUEST that has to be acknowledged. - * - * This is only necessary if we're opening the window wide. - * If we're not, then throughput is being constrained by - * something other than the maximum window size anyway. - */ - if (newwin == c->locmaxwin && - !(s->ppl.remote_bugs & BUG_CHOKES_ON_WINADJ)) { - up = snew(unsigned); - *up = newwin - c->locwindow; - pktout = ssh2_chanreq_init(c, "winadj@putty.projects.tartarus.org", - ssh2_handle_winadj_response, up); - pq_push(s->ppl.out_pq, pktout); - - if (c->throttle_state != UNTHROTTLED) - c->throttle_state = UNTHROTTLING; - } else { - /* Pretend the WINDOW_ADJUST was acked immediately. */ - c->remlocwin = newwin; - c->throttle_state = THROTTLED; - } - pktout = ssh_bpp_new_pktout(s->ppl.bpp, SSH2_MSG_CHANNEL_WINDOW_ADJUST); - put_uint32(pktout, c->remoteid); - put_uint32(pktout, newwin - c->locwindow); - pq_push(s->ppl.out_pq, pktout); - c->locwindow = newwin; - } -} - -static PktIn *ssh2_connection_pop(struct ssh2_connection_state *s) -{ - ssh2_connection_filter_queue(s); - return pq_pop(s->ppl.in_pq); -} - -static void ssh2_connection_process_queue(PacketProtocolLayer *ppl) -{ - struct ssh2_connection_state *s = - container_of(ppl, struct ssh2_connection_state, ppl); - PktIn *pktin; - - if (ssh2_connection_filter_queue(s)) /* no matter why we were called */ - return; - - crBegin(s->crState); - - if (s->connshare) - share_activate(s->connshare, s->peer_verstring); - - /* - * Signal the seat that authentication is done, so that it can - * deploy spoofing defences. If it doesn't have any, deploy our - * own fallback one. - * - * We do this here rather than at the end of userauth, because we - * might not have gone through userauth at all (if we're a - * connection-sharing downstream). - */ - if (ssh2_connection_need_antispoof_prompt(s)) { - s->antispoof_prompt = new_prompts(); - s->antispoof_prompt->to_server = true; - s->antispoof_prompt->from_server = false; - s->antispoof_prompt->name = dupstr("Authentication successful"); - add_prompt( - s->antispoof_prompt, - dupstr("Access granted. Press Return to begin session. "), false); - s->antispoof_ret = seat_get_userpass_input( - s->ppl.seat, s->antispoof_prompt, NULL); - while (1) { - while (s->antispoof_ret < 0 && - bufchain_size(s->ppl.user_input) > 0) - s->antispoof_ret = seat_get_userpass_input( - s->ppl.seat, s->antispoof_prompt, s->ppl.user_input); - - if (s->antispoof_ret >= 0) - break; - - s->want_user_input = true; - crReturnV; - s->want_user_input = false; - } - free_prompts(s->antispoof_prompt); - s->antispoof_prompt = NULL; - } - - /* - * Enable port forwardings. - */ - portfwdmgr_config(s->portfwdmgr, s->conf); - s->portfwdmgr_configured = true; - - /* - * Create the main session channel, if any. - */ - s->mainchan = mainchan_new( - &s->ppl, &s->cl, s->conf, s->term_width, s->term_height, - s->ssh_is_simple, &s->mainchan_sc); - s->started = true; - - /* - * Transfer data! - */ - - while (1) { - if ((pktin = ssh2_connection_pop(s)) != NULL) { - - /* - * _All_ the connection-layer packets we expect to - * receive are now handled by the dispatch table. - * Anything that reaches here must be bogus. - */ - - ssh_proto_error(s->ppl.ssh, "Received unexpected connection-layer " - "packet, type %d (%s)", pktin->type, - ssh2_pkt_type(s->ppl.bpp->pls->kctx, - s->ppl.bpp->pls->actx, - pktin->type)); - return; - } - crReturnV; - } - - crFinishV; -} - -static void ssh2_channel_check_close(struct ssh2_channel *c) -{ - struct ssh2_connection_state *s = c->connlayer; - PktOut *pktout; - - if (c->halfopen) { - /* - * If we've sent out our own CHANNEL_OPEN but not yet seen - * either OPEN_CONFIRMATION or OPEN_FAILURE in response, then - * it's too early to be sending close messages of any kind. - */ - return; - } - - if (chan_want_close(c->chan, (c->closes & CLOSES_SENT_EOF), - (c->closes & CLOSES_RCVD_EOF)) && - !c->chanreq_head && - !(c->closes & CLOSES_SENT_CLOSE)) { - /* - * We have both sent and received EOF (or the channel is a - * zombie), and we have no outstanding channel requests, which - * means the channel is in final wind-up. But we haven't sent - * CLOSE, so let's do so now. - */ - pktout = ssh_bpp_new_pktout(s->ppl.bpp, SSH2_MSG_CHANNEL_CLOSE); - put_uint32(pktout, c->remoteid); - pq_push(s->ppl.out_pq, pktout); - c->closes |= CLOSES_SENT_EOF | CLOSES_SENT_CLOSE; - } - - if (!((CLOSES_SENT_CLOSE | CLOSES_RCVD_CLOSE) & ~c->closes)) { - assert(c->chanreq_head == NULL); - /* - * We have both sent and received CLOSE, which means we're - * completely done with the channel. - */ - ssh2_channel_destroy(c); - } -} - -static void ssh2_channel_try_eof(struct ssh2_channel *c) -{ - struct ssh2_connection_state *s = c->connlayer; - PktOut *pktout; - assert(c->pending_eof); /* precondition for calling us */ - if (c->halfopen) - return; /* can't close: not even opened yet */ - if (bufchain_size(&c->outbuffer) > 0 || bufchain_size(&c->errbuffer) > 0) - return; /* can't send EOF: pending outgoing data */ - - c->pending_eof = false; /* we're about to send it */ - - pktout = ssh_bpp_new_pktout(s->ppl.bpp, SSH2_MSG_CHANNEL_EOF); - put_uint32(pktout, c->remoteid); - pq_push(s->ppl.out_pq, pktout); - c->closes |= CLOSES_SENT_EOF; - ssh2_channel_check_close(c); -} - -/* - * Attempt to send data on an SSH-2 channel. - */ -static size_t ssh2_try_send(struct ssh2_channel *c) -{ - struct ssh2_connection_state *s = c->connlayer; - PktOut *pktout; - size_t bufsize; - - if (!c->halfopen) { - while (c->remwindow > 0 && - (bufchain_size(&c->outbuffer) > 0 || - bufchain_size(&c->errbuffer) > 0)) { - bufchain *buf = (bufchain_size(&c->errbuffer) > 0 ? - &c->errbuffer : &c->outbuffer); - - ptrlen data = bufchain_prefix(buf); - if (data.len > c->remwindow) - data.len = c->remwindow; - if (data.len > c->remmaxpkt) - data.len = c->remmaxpkt; - if (buf == &c->errbuffer) { - pktout = ssh_bpp_new_pktout( - s->ppl.bpp, SSH2_MSG_CHANNEL_EXTENDED_DATA); - put_uint32(pktout, c->remoteid); - put_uint32(pktout, SSH2_EXTENDED_DATA_STDERR); - } else { - pktout = ssh_bpp_new_pktout(s->ppl.bpp, SSH2_MSG_CHANNEL_DATA); - put_uint32(pktout, c->remoteid); - } - put_stringpl(pktout, data); - pq_push(s->ppl.out_pq, pktout); - bufchain_consume(buf, data.len); - c->remwindow -= data.len; - } - } - - /* - * After having sent as much data as we can, return the amount - * still buffered. - */ - bufsize = bufchain_size(&c->outbuffer) + bufchain_size(&c->errbuffer); - - /* - * And if there's no data pending but we need to send an EOF, send - * it. - */ - if (!bufsize && c->pending_eof) - ssh2_channel_try_eof(c); - - return bufsize; -} - -static void ssh2_try_send_and_unthrottle(struct ssh2_channel *c) -{ - int bufsize; - if (c->closes & CLOSES_SENT_EOF) - return; /* don't send on channels we've EOFed */ - bufsize = ssh2_try_send(c); - if (bufsize == 0) { - c->throttled_by_backlog = false; - ssh2_channel_check_throttle(c); - } -} - -static void ssh2_channel_check_throttle(struct ssh2_channel *c) -{ - /* - * We don't want this channel to read further input if this - * particular channel has a backed-up SSH window, or if the - * outgoing side of the whole SSH connection is currently - * throttled, or if this channel already has an outgoing EOF - * either sent or pending. - */ - chan_set_input_wanted(c->chan, - !c->throttled_by_backlog && - !c->connlayer->all_channels_throttled && - !c->pending_eof && - !(c->closes & CLOSES_SENT_EOF)); -} - -/* - * Close any local socket and free any local resources associated with - * a channel. This converts the channel into a zombie. - */ -static void ssh2_channel_close_local(struct ssh2_channel *c, - const char *reason) -{ - struct ssh2_connection_state *s = c->connlayer; - PacketProtocolLayer *ppl = &s->ppl; /* for ppl_logevent */ - char *msg = NULL; - - if (c->sharectx) - return; - - msg = chan_log_close_msg(c->chan); - - if (msg) - ppl_logevent("%s%s%s", msg, reason ? " " : "", reason ? reason : ""); - - sfree(msg); - - chan_free(c->chan); - c->chan = zombiechan_new(); -} - -static void ssh2_check_termination_callback(void *vctx) -{ - struct ssh2_connection_state *s = (struct ssh2_connection_state *)vctx; - ssh2_check_termination(s); -} - -static void ssh2_channel_destroy(struct ssh2_channel *c) -{ - struct ssh2_connection_state *s = c->connlayer; - - assert(c->chanreq_head == NULL); - - ssh2_channel_close_local(c, NULL); - del234(s->channels, c); - ssh2_channel_free(c); - - /* - * If that was the last channel left open, we might need to - * terminate. But we'll be a bit cautious, by doing that in a - * toplevel callback, just in case anything on the current call - * stack objects to this entire PPL being freed. - */ - queue_toplevel_callback(ssh2_check_termination_callback, s); -} - -static void ssh2_check_termination(struct ssh2_connection_state *s) -{ - /* - * Decide whether we should terminate the SSH connection now. - * Called after a channel or a downstream goes away. The general - * policy is that we terminate when none of either is left. - */ - - if (s->persistent) - return; /* persistent mode: never proactively terminate */ - - if (!s->started) { - /* At startup, we don't have any channels open because we - * haven't got round to opening the main one yet. In that - * situation, we don't want to terminate, even if a sharing - * connection opens and closes and causes a call to this - * function. */ - return; - } - - if (count234(s->channels) == 0 && - !(s->connshare && share_ndownstreams(s->connshare) > 0)) { - /* - * We used to send SSH_MSG_DISCONNECT here, because I'd - * believed that _every_ conforming SSH-2 connection had to - * end with a disconnect being sent by at least one side; - * apparently I was wrong and it's perfectly OK to - * unceremoniously slam the connection shut when you're done, - * and indeed OpenSSH feels this is more polite than sending a - * DISCONNECT. So now we don't. - */ - ssh_user_close(s->ppl.ssh, "All channels closed"); - return; - } -} - -/* - * Set up most of a new ssh2_channel. Nulls out sharectx, but leaves - * chan untouched (since it will sometimes have been filled in before - * calling this). - */ -void ssh2_channel_init(struct ssh2_channel *c) -{ - struct ssh2_connection_state *s = c->connlayer; - c->closes = 0; - c->pending_eof = false; - c->throttling_conn = false; - c->throttled_by_backlog = false; - c->sharectx = NULL; - c->locwindow = c->locmaxwin = c->remlocwin = - s->ssh_is_simple ? OUR_V2_BIGWIN : OUR_V2_WINSIZE; - c->chanreq_head = NULL; - c->throttle_state = UNTHROTTLED; - bufchain_init(&c->outbuffer); - bufchain_init(&c->errbuffer); - c->sc.vt = &ssh2channel_vtable; - c->sc.cl = &s->cl; - c->localid = alloc_channel_id(s->channels, struct ssh2_channel); - add234(s->channels, c); -} - -/* - * Construct the common parts of a CHANNEL_OPEN. - */ -PktOut *ssh2_chanopen_init(struct ssh2_channel *c, const char *type) -{ - struct ssh2_connection_state *s = c->connlayer; - PktOut *pktout; - - pktout = ssh_bpp_new_pktout(s->ppl.bpp, SSH2_MSG_CHANNEL_OPEN); - put_stringz(pktout, type); - put_uint32(pktout, c->localid); - put_uint32(pktout, c->locwindow); /* our window size */ - put_uint32(pktout, OUR_V2_MAXPKT); /* our max pkt size */ - return pktout; -} - -/* - * Construct the common parts of a CHANNEL_REQUEST. If handler is not - * NULL then a reply will be requested and the handler will be called - * when it arrives. The returned packet is ready to have any - * request-specific data added and be sent. Note that if a handler is - * provided, it's essential that the request actually be sent. - * - * The handler will usually be passed the response packet in pktin. If - * pktin is NULL, this means that no reply will ever be forthcoming - * (e.g. because the entire connection is being destroyed, or because - * the server initiated channel closure before we saw the response) - * and the handler should free any storage it's holding. - */ -PktOut *ssh2_chanreq_init(struct ssh2_channel *c, const char *type, - cr_handler_fn_t handler, void *ctx) -{ - struct ssh2_connection_state *s = c->connlayer; - PktOut *pktout; - - assert(!(c->closes & (CLOSES_SENT_CLOSE | CLOSES_RCVD_CLOSE))); - pktout = ssh_bpp_new_pktout(s->ppl.bpp, SSH2_MSG_CHANNEL_REQUEST); - put_uint32(pktout, c->remoteid); - put_stringz(pktout, type); - put_bool(pktout, handler != NULL); - if (handler != NULL) { - struct outstanding_channel_request *ocr = - snew(struct outstanding_channel_request); - - ocr->handler = handler; - ocr->ctx = ctx; - ocr->next = NULL; - if (!c->chanreq_head) - c->chanreq_head = ocr; - else - c->chanreq_tail->next = ocr; - c->chanreq_tail = ocr; - } - return pktout; -} - -static Conf *ssh2channel_get_conf(SshChannel *sc) -{ - struct ssh2_channel *c = container_of(sc, struct ssh2_channel, sc); - struct ssh2_connection_state *s = c->connlayer; - return s->conf; -} - -static void ssh2channel_write_eof(SshChannel *sc) -{ - struct ssh2_channel *c = container_of(sc, struct ssh2_channel, sc); - - if (c->closes & CLOSES_SENT_EOF) - return; - - c->pending_eof = true; - ssh2_channel_try_eof(c); -} - -static void ssh2channel_initiate_close(SshChannel *sc, const char *err) -{ - struct ssh2_channel *c = container_of(sc, struct ssh2_channel, sc); - char *reason; - - reason = err ? dupprintf("due to local error: %s", err) : NULL; - ssh2_channel_close_local(c, reason); - sfree(reason); - c->pending_eof = false; /* this will confuse a zombie channel */ - - ssh2_channel_check_close(c); -} - -static void ssh2channel_unthrottle(SshChannel *sc, size_t bufsize) -{ - struct ssh2_channel *c = container_of(sc, struct ssh2_channel, sc); - struct ssh2_connection_state *s = c->connlayer; - size_t buflimit; - - buflimit = s->ssh_is_simple ? 0 : c->locmaxwin; - if (bufsize < buflimit) - ssh2_set_window(c, buflimit - bufsize); - - if (c->throttling_conn && bufsize <= buflimit) { - c->throttling_conn = false; - ssh_throttle_conn(s->ppl.ssh, -1); - } -} - -static size_t ssh2channel_write( - SshChannel *sc, bool is_stderr, const void *buf, size_t len) -{ - struct ssh2_channel *c = container_of(sc, struct ssh2_channel, sc); - assert(!(c->closes & CLOSES_SENT_EOF)); - bufchain_add(is_stderr ? &c->errbuffer : &c->outbuffer, buf, len); - return ssh2_try_send(c); -} - -static void ssh2channel_x11_sharing_handover( - SshChannel *sc, ssh_sharing_connstate *share_cs, share_channel *share_chan, - const char *peer_addr, int peer_port, int endian, - int protomajor, int protominor, const void *initial_data, int initial_len) -{ - struct ssh2_channel *c = container_of(sc, struct ssh2_channel, sc); - /* - * This function is called when we've just discovered that an X - * forwarding channel on which we'd been handling the initial auth - * ourselves turns out to be destined for a connection-sharing - * downstream. So we turn the channel into a sharing one, meaning - * that we completely stop tracking windows and buffering data and - * just pass more or less unmodified SSH messages back and forth. - */ - c->sharectx = share_cs; - share_setup_x11_channel(share_cs, share_chan, - c->localid, c->remoteid, c->remwindow, - c->remmaxpkt, c->locwindow, - peer_addr, peer_port, endian, - protomajor, protominor, - initial_data, initial_len); - chan_free(c->chan); - c->chan = NULL; -} - -static void ssh2channel_window_override_removed(SshChannel *sc) -{ - struct ssh2_channel *c = container_of(sc, struct ssh2_channel, sc); - struct ssh2_connection_state *s = c->connlayer; - - /* - * This function is called when a client-side Channel has just - * stopped requiring an initial fixed-size window. - */ - assert(!c->chan->initial_fixed_window_size); - ssh2_set_window(c, s->ssh_is_simple ? OUR_V2_BIGWIN : OUR_V2_WINSIZE); -} - -static void ssh2channel_hint_channel_is_simple(SshChannel *sc) -{ - struct ssh2_channel *c = container_of(sc, struct ssh2_channel, sc); - struct ssh2_connection_state *s = c->connlayer; - - PktOut *pktout = ssh2_chanreq_init( - c, "simple@putty.projects.tartarus.org", NULL, NULL); - pq_push(s->ppl.out_pq, pktout); -} - -static SshChannel *ssh2_lportfwd_open( - ConnectionLayer *cl, const char *hostname, int port, - const char *description, const SocketPeerInfo *pi, Channel *chan) -{ - struct ssh2_connection_state *s = - container_of(cl, struct ssh2_connection_state, cl); - struct ssh2_channel *c = snew(struct ssh2_channel); - PktOut *pktout; - - c->connlayer = s; - ssh2_channel_init(c); - c->halfopen = true; - c->chan = chan; - - pktout = ssh2_portfwd_chanopen(s, c, hostname, port, description, pi); - pq_push(s->ppl.out_pq, pktout); - - return &c->sc; -} - -static void ssh2_sharing_globreq_response( - struct ssh2_connection_state *s, PktIn *pktin, void *ctx) -{ - ssh_sharing_connstate *cs = (ssh_sharing_connstate *)ctx; - share_got_pkt_from_server(cs, pktin->type, - BinarySource_UPCAST(pktin)->data, - BinarySource_UPCAST(pktin)->len); -} - -static void ssh2_sharing_queue_global_request( - ConnectionLayer *cl, ssh_sharing_connstate *cs) -{ - struct ssh2_connection_state *s = - container_of(cl, struct ssh2_connection_state, cl); - ssh2_queue_global_request_handler(s, ssh2_sharing_globreq_response, cs); -} - -static void ssh2_sharing_no_more_downstreams(ConnectionLayer *cl) -{ - struct ssh2_connection_state *s = - container_of(cl, struct ssh2_connection_state, cl); - queue_toplevel_callback(ssh2_check_termination_callback, s); -} - -static struct X11FakeAuth *ssh2_add_x11_display( - ConnectionLayer *cl, int authtype, struct X11Display *disp) -{ - struct ssh2_connection_state *s = - container_of(cl, struct ssh2_connection_state, cl); - struct X11FakeAuth *auth = x11_invent_fake_auth(s->x11authtree, authtype); - auth->disp = disp; - return auth; -} - -static struct X11FakeAuth *ssh2_add_sharing_x11_display( - ConnectionLayer *cl, int authtype, ssh_sharing_connstate *share_cs, - share_channel *share_chan) -{ - struct ssh2_connection_state *s = - container_of(cl, struct ssh2_connection_state, cl); - struct X11FakeAuth *auth; - - /* - * Make up a new set of fake X11 auth data, and add it to the tree - * of currently valid ones with an indication of the sharing - * context that it's relevant to. - */ - auth = x11_invent_fake_auth(s->x11authtree, authtype); - auth->share_cs = share_cs; - auth->share_chan = share_chan; - - return auth; -} - -static void ssh2_remove_sharing_x11_display( - ConnectionLayer *cl, struct X11FakeAuth *auth) -{ - struct ssh2_connection_state *s = - container_of(cl, struct ssh2_connection_state, cl); - del234(s->x11authtree, auth); - x11_free_fake_auth(auth); -} - -static unsigned ssh2_alloc_sharing_channel( - ConnectionLayer *cl, ssh_sharing_connstate *connstate) -{ - struct ssh2_connection_state *s = - container_of(cl, struct ssh2_connection_state, cl); - struct ssh2_channel *c = snew(struct ssh2_channel); - - c->connlayer = s; - ssh2_channel_init(c); - c->chan = NULL; - c->sharectx = connstate; - return c->localid; -} - -static void ssh2_delete_sharing_channel(ConnectionLayer *cl, unsigned localid) -{ - struct ssh2_connection_state *s = - container_of(cl, struct ssh2_connection_state, cl); - struct ssh2_channel *c = find234(s->channels, &localid, ssh2_channelfind); - if (c) - ssh2_channel_destroy(c); -} - -static void ssh2_send_packet_from_downstream( - ConnectionLayer *cl, unsigned id, int type, - const void *data, int datalen, const char *additional_log_text) -{ - struct ssh2_connection_state *s = - container_of(cl, struct ssh2_connection_state, cl); - PktOut *pkt = ssh_bpp_new_pktout(s->ppl.bpp, type); - pkt->downstream_id = id; - pkt->additional_log_text = additional_log_text; - put_data(pkt, data, datalen); - pq_push(s->ppl.out_pq, pkt); -} - -static bool ssh2_agent_forwarding_permitted(ConnectionLayer *cl) -{ - struct ssh2_connection_state *s = - container_of(cl, struct ssh2_connection_state, cl); - return conf_get_bool(s->conf, CONF_agentfwd) && agent_exists(); -} - -static bool ssh2_connection_get_specials( - PacketProtocolLayer *ppl, add_special_fn_t add_special, void *ctx) -{ - struct ssh2_connection_state *s = - container_of(ppl, struct ssh2_connection_state, ppl); - bool toret = false; - - if (s->mainchan) { - mainchan_get_specials(s->mainchan, add_special, ctx); - toret = true; - } - - /* - * Don't bother offering IGNORE if we've decided the remote - * won't cope with it, since we wouldn't bother sending it if - * asked anyway. - */ - if (!(s->ppl.remote_bugs & BUG_CHOKES_ON_SSH2_IGNORE)) { - if (toret) - add_special(ctx, NULL, SS_SEP, 0); - - add_special(ctx, "IGNORE message", SS_NOP, 0); - toret = true; - } - - return toret; -} - -static void ssh2_connection_special_cmd(PacketProtocolLayer *ppl, - SessionSpecialCode code, int arg) -{ - struct ssh2_connection_state *s = - container_of(ppl, struct ssh2_connection_state, ppl); - PktOut *pktout; - - if (code == SS_PING || code == SS_NOP) { - if (!(s->ppl.remote_bugs & BUG_CHOKES_ON_SSH2_IGNORE)) { - pktout = ssh_bpp_new_pktout(s->ppl.bpp, SSH2_MSG_IGNORE); - put_stringz(pktout, ""); - pq_push(s->ppl.out_pq, pktout); - } - } else if (s->mainchan) { - mainchan_special_cmd(s->mainchan, code, arg); - } -} - -static void ssh2_terminal_size(ConnectionLayer *cl, int width, int height) -{ - struct ssh2_connection_state *s = - container_of(cl, struct ssh2_connection_state, cl); - - s->term_width = width; - s->term_height = height; - if (s->mainchan) - mainchan_terminal_size(s->mainchan, width, height); -} - -static void ssh2_stdout_unthrottle(ConnectionLayer *cl, size_t bufsize) -{ - struct ssh2_connection_state *s = - container_of(cl, struct ssh2_connection_state, cl); - - if (s->mainchan) - sshfwd_unthrottle(s->mainchan_sc, bufsize); -} - -static size_t ssh2_stdin_backlog(ConnectionLayer *cl) -{ - struct ssh2_connection_state *s = - container_of(cl, struct ssh2_connection_state, cl); - struct ssh2_channel *c; - - if (!s->mainchan) - return 0; - c = container_of(s->mainchan_sc, struct ssh2_channel, sc); - return s->mainchan ? - bufchain_size(&c->outbuffer) + bufchain_size(&c->errbuffer) : 0; -} - -static void ssh2_throttle_all_channels(ConnectionLayer *cl, bool throttled) -{ - struct ssh2_connection_state *s = - container_of(cl, struct ssh2_connection_state, cl); - struct ssh2_channel *c; - int i; - - s->all_channels_throttled = throttled; - - for (i = 0; NULL != (c = index234(s->channels, i)); i++) - if (!c->sharectx) - ssh2_channel_check_throttle(c); -} - -static bool ssh2_ldisc_option(ConnectionLayer *cl, int option) -{ - struct ssh2_connection_state *s = - container_of(cl, struct ssh2_connection_state, cl); - - return s->ldisc_opts[option]; -} - -static void ssh2_set_ldisc_option(ConnectionLayer *cl, int option, bool value) -{ - struct ssh2_connection_state *s = - container_of(cl, struct ssh2_connection_state, cl); - - s->ldisc_opts[option] = value; -} - -static void ssh2_enable_x_fwd(ConnectionLayer *cl) -{ - struct ssh2_connection_state *s = - container_of(cl, struct ssh2_connection_state, cl); - - s->X11_fwd_enabled = true; -} - -static void ssh2_set_wants_user_input(ConnectionLayer *cl, bool wanted) -{ - struct ssh2_connection_state *s = - container_of(cl, struct ssh2_connection_state, cl); - - s->want_user_input = wanted; -} - -static bool ssh2_connection_want_user_input(PacketProtocolLayer *ppl) -{ - struct ssh2_connection_state *s = - container_of(ppl, struct ssh2_connection_state, ppl); - return s->want_user_input; -} - -static void ssh2_connection_got_user_input(PacketProtocolLayer *ppl) -{ - struct ssh2_connection_state *s = - container_of(ppl, struct ssh2_connection_state, ppl); - - while (s->mainchan && bufchain_size(s->ppl.user_input) > 0) { - /* - * Add user input to the main channel's buffer. - */ - ptrlen data = bufchain_prefix(s->ppl.user_input); - sshfwd_write(s->mainchan_sc, data.ptr, data.len); - bufchain_consume(s->ppl.user_input, data.len); - } -} - -static void ssh2_connection_reconfigure(PacketProtocolLayer *ppl, Conf *conf) -{ - struct ssh2_connection_state *s = - container_of(ppl, struct ssh2_connection_state, ppl); - - conf_free(s->conf); - s->conf = conf_copy(conf); - - if (s->portfwdmgr_configured) - portfwdmgr_config(s->portfwdmgr, s->conf); -} |