upstream commit

remove compat20/compat13/compat15 variables

ok markus@

Upstream-ID: 43802c035ceb3fef6c50c400e4ecabf12354691c

1 files changed, 130 insertions, 393 deletions

diff --git a/channels.c b/channels.c
index d030fcdd9..5a7e56ed0 100644
--- a/channels.c
+++ b/channels.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: channels.c,v 1.357 2017/02/01 02:59:09 dtucker Exp $ */
+/* $OpenBSD: channels.c,v 1.358 2017/04/30 23:13:25 djm Exp $ */
 /*
  * Author: Tatu Ylonen <ylo@cs.hut.fi>
  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
@@ -571,14 +571,6 @@ channel_not_very_much_buffered_data(void)
         for (i = 0; i < channels_alloc; i++) {
                 c = channels[i];
                 if (c != NULL && c->type == SSH_CHANNEL_OPEN) {
-#if 0
-                        if (!compat20 &&
-                            buffer_len(&c->input) > packet_get_maxsize()) {
-                                debug2("channel %d: big input buffer %d",
-                                    c->self, buffer_len(&c->input));
-                                return 0;
-                        }
-#endif
                         if (buffer_len(&c->output) > packet_get_maxsize()) {
                                 debug2("channel %d: big output buffer %u > %u",
                                     c->self, buffer_len(&c->output),
@@ -616,8 +608,6 @@ channel_still_open(void)
                 case SSH_CHANNEL_RUNIX_LISTENER:
                         continue;
                 case SSH_CHANNEL_LARVAL:
-                        if (!compat20)
-                                fatal("cannot happen: SSH_CHANNEL_LARVAL");
                         continue;
                 case SSH_CHANNEL_OPENING:
                 case SSH_CHANNEL_OPEN:
@@ -627,11 +617,9 @@ channel_still_open(void)
                         return 1;
                 case SSH_CHANNEL_INPUT_DRAINING:
                 case SSH_CHANNEL_OUTPUT_DRAINING:
-                        if (!compat13)
-                                fatal("cannot happen: OUT_DRAIN");
-                        return 1;
+                        fatal("cannot happen: OUT_DRAIN");
                 default:
-                        fatal("channel_still_open: bad channel type %d", c->type);
+                        fatal("%s: bad channel type %d", __func__, c->type);
                         /* NOTREACHED */
                 }
         }
@@ -672,11 +660,9 @@ channel_find_open(void)
                         return i;
                 case SSH_CHANNEL_INPUT_DRAINING:
                 case SSH_CHANNEL_OUTPUT_DRAINING:
-                        if (!compat13)
-                                fatal("cannot happen: OUT_DRAIN");
-                        return i;
+                        fatal("cannot happen: OUT_DRAIN");
                 default:
-                        fatal("channel_find_open: bad channel type %d", c->type);
+                        fatal("%s: bad channel type %d", __func__, c->type);
                         /* NOTREACHED */
                 }
         }
@@ -896,22 +882,11 @@ channel_pre_connecting(Channel *c, fd_set *readset, fd_set *writeset)
 }
 
 static void
-channel_pre_open_13(Channel *c, fd_set *readset, fd_set *writeset)
-{
-        if (buffer_len(&c->input) < packet_get_maxsize())
-                FD_SET(c->sock, readset);
-        if (buffer_len(&c->output) > 0)
-                FD_SET(c->sock, writeset);
-}
-
-static void
 channel_pre_open(Channel *c, fd_set *readset, fd_set *writeset)
 {
-        u_int limit = compat20 ? c->remote_window : packet_get_maxsize();
-
         if (c->istate == CHAN_INPUT_OPEN &&
-            limit > 0 &&
-            buffer_len(&c->input) < limit &&
+            c->remote_window > 0 &&
+            buffer_len(&c->input) < c->remote_window &&
             buffer_check_alloc(&c->input, CHAN_RBUF))
                 FD_SET(c->rfd, readset);
         if (c->ostate == CHAN_OUTPUT_OPEN ||
@@ -927,8 +902,8 @@ channel_pre_open(Channel *c, fd_set *readset, fd_set *writeset)
                 }
         }
         /** XXX check close conditions, too */
-        if (compat20 && c->efd != -1 && 
-            !(c->istate == CHAN_INPUT_CLOSED && c->ostate == CHAN_OUTPUT_CLOSED)) {
+        if (c->efd != -1 && !(c->istate == CHAN_INPUT_CLOSED &&
+            c->ostate == CHAN_OUTPUT_CLOSED)) {
                 if (c->extended_usage == CHAN_EXTENDED_WRITE &&
                     buffer_len(&c->extended) > 0)
                         FD_SET(c->efd, writeset);
@@ -941,29 +916,6 @@ channel_pre_open(Channel *c, fd_set *readset, fd_set *writeset)
         /* XXX: What about efd? races? */
 }
 
-/* ARGSUSED */
-static void
-channel_pre_input_draining(Channel *c, fd_set *readset, fd_set *writeset)
-{
-        if (buffer_len(&c->input) == 0) {
-                packet_start(SSH_MSG_CHANNEL_CLOSE);
-                packet_put_int(c->remote_id);
-                packet_send();
-                c->type = SSH_CHANNEL_CLOSED;
-                debug2("channel %d: closing after input drain.", c->self);
-        }
-}
-
-/* ARGSUSED */
-static void
-channel_pre_output_draining(Channel *c, fd_set *readset, fd_set *writeset)
-{
-        if (buffer_len(&c->output) == 0)
-                chan_mark_dead(c);
-        else
-                FD_SET(c->sock, writeset);
-}
-
 /*
  * This is a special state for X11 authentication spoofing.  An opened X11
  * connection (when authentication spoofing is being done) remains in this
@@ -1039,32 +991,6 @@ x11_open_helper(Buffer *b)
 }
 
 static void
-channel_pre_x11_open_13(Channel *c, fd_set *readset, fd_set *writeset)
-{
-        int ret = x11_open_helper(&c->output);
-
-        if (ret == 1) {
-                /* Start normal processing for the channel. */
-                c->type = SSH_CHANNEL_OPEN;
-                channel_pre_open_13(c, readset, writeset);
-        } else if (ret == -1) {
-                /*
-                 * We have received an X11 connection that has bad
-                 * authentication information.
-                 */
-                logit("X11 connection rejected because of wrong authentication.");
-                buffer_clear(&c->input);
-                buffer_clear(&c->output);
-                channel_close_fd(&c->sock);
-                c->sock = -1;
-                c->type = SSH_CHANNEL_CLOSED;
-                packet_start(SSH_MSG_CHANNEL_CLOSE);
-                packet_put_int(c->remote_id);
-                packet_send();
-        }
-}
-
-static void
 channel_pre_x11_open(Channel *c, fd_set *readset, fd_set *writeset)
 {
         int ret = x11_open_helper(&c->output);
@@ -1081,11 +1007,7 @@ channel_pre_x11_open(Channel *c, fd_set *readset, fd_set *writeset)
                 buffer_clear(&c->input);
                 chan_ibuf_empty(c);
                 buffer_clear(&c->output);
-                /* for proto v1, the peer will send an IEOF */
-                if (compat20)
-                        chan_write_failed(c);
-                else
-                        c->type = SSH_CHANNEL_OPEN;
+                chan_write_failed(c);
                 debug2("X11 closed %d i%d/o%d", c->self, c->istate, c->ostate);
         }
 }
@@ -1449,28 +1371,19 @@ channel_post_x11_listener(Channel *c, fd_set *readset, fd_set *writeset)
                 nc = channel_new("accepted x11 socket",
                     SSH_CHANNEL_OPENING, newsock, newsock, -1,
                     c->local_window_max, c->local_maxpacket, 0, buf, 1);
-                if (compat20) {
-                        packet_start(SSH2_MSG_CHANNEL_OPEN);
-                        packet_put_cstring("x11");
-                        packet_put_int(nc->self);
-                        packet_put_int(nc->local_window_max);
-                        packet_put_int(nc->local_maxpacket);
-                        /* originator ipaddr and port */
-                        packet_put_cstring(remote_ipaddr);
-                        if (datafellows & SSH_BUG_X11FWD) {
-                                debug2("ssh2 x11 bug compat mode");
-                        } else {
-                                packet_put_int(remote_port);
-                        }
-                        packet_send();
+                packet_start(SSH2_MSG_CHANNEL_OPEN);
+                packet_put_cstring("x11");
+                packet_put_int(nc->self);
+                packet_put_int(nc->local_window_max);
+                packet_put_int(nc->local_maxpacket);
+                /* originator ipaddr and port */
+                packet_put_cstring(remote_ipaddr);
+                if (datafellows & SSH_BUG_X11FWD) {
+                        debug2("ssh2 x11 bug compat mode");
                 } else {
-                        packet_start(SSH_SMSG_X11_OPEN);
-                        packet_put_int(nc->self);
-                        if (packet_get_protocol_flags() &
-                            SSH_PROTOFLAG_HOST_IN_FWD_OPEN)
-                                packet_put_cstring(buf);
-                        packet_send();
+                        packet_put_int(remote_port);
                 }
+                packet_send();
                 free(remote_ipaddr);
         }
 }
@@ -1500,46 +1413,35 @@ port_open_helper(Channel *c, char *rtype)
         free(c->remote_name);
         c->remote_name = xstrdup(buf);
 
-        if (compat20) {
-                packet_start(SSH2_MSG_CHANNEL_OPEN);
-                packet_put_cstring(rtype);
-                packet_put_int(c->self);
-                packet_put_int(c->local_window_max);
-                packet_put_int(c->local_maxpacket);
-                if (strcmp(rtype, "direct-tcpip") == 0) {
-                        /* target host, port */
-                        packet_put_cstring(c->path);
-                        packet_put_int(c->host_port);
-                } else if (strcmp(rtype, "direct-streamlocal@openssh.com") == 0) {
-                        /* target path */
-                        packet_put_cstring(c->path);
-                } else if (strcmp(rtype, "forwarded-streamlocal@openssh.com") == 0) {
-                        /* listen path */
-                        packet_put_cstring(c->path);
-                } else {
-                        /* listen address, port */
-                        packet_put_cstring(c->path);
-                        packet_put_int(local_port);
-                }
-                if (strcmp(rtype, "forwarded-streamlocal@openssh.com") == 0) {
-                        /* reserved for future owner/mode info */
-                        packet_put_cstring("");
-                } else {
-                        /* originator host and port */
-                        packet_put_cstring(remote_ipaddr);
-                        packet_put_int((u_int)remote_port);
-                }
-                packet_send();
-        } else {
-                packet_start(SSH_MSG_PORT_OPEN);
-                packet_put_int(c->self);
+        packet_start(SSH2_MSG_CHANNEL_OPEN);
+        packet_put_cstring(rtype);
+        packet_put_int(c->self);
+        packet_put_int(c->local_window_max);
+        packet_put_int(c->local_maxpacket);
+        if (strcmp(rtype, "direct-tcpip") == 0) {
+                /* target host, port */
                 packet_put_cstring(c->path);
                 packet_put_int(c->host_port);
-                if (packet_get_protocol_flags() &
-                    SSH_PROTOFLAG_HOST_IN_FWD_OPEN)
-                        packet_put_cstring(c->remote_name);
-                packet_send();
+        } else if (strcmp(rtype, "direct-streamlocal@openssh.com") == 0) {
+                /* target path */
+                packet_put_cstring(c->path);
+        } else if (strcmp(rtype, "forwarded-streamlocal@openssh.com") == 0) {
+                /* listen path */
+                packet_put_cstring(c->path);
+        } else {
+                /* listen address, port */
+                packet_put_cstring(c->path);
+                packet_put_int(local_port);
+        }
+        if (strcmp(rtype, "forwarded-streamlocal@openssh.com") == 0) {
+                /* reserved for future owner/mode info */
+                packet_put_cstring("");
+        } else {
+                /* originator host and port */
+                packet_put_cstring(remote_ipaddr);
+                packet_put_int((u_int)remote_port);
         }
+        packet_send();
         free(remote_ipaddr);
         free(local_ipaddr);
 }
@@ -1649,16 +1551,11 @@ channel_post_auth_listener(Channel *c, fd_set *readset, fd_set *writeset)
                     SSH_CHANNEL_OPENING, newsock, newsock, -1,
                     c->local_window_max, c->local_maxpacket,
                     0, "accepted auth socket", 1);
-                if (compat20) {
-                        packet_start(SSH2_MSG_CHANNEL_OPEN);
-                        packet_put_cstring("auth-agent@openssh.com");
-                        packet_put_int(nc->self);
-                        packet_put_int(c->local_window_max);
-                        packet_put_int(c->local_maxpacket);
-                } else {
-                        packet_start(SSH_SMSG_AGENT_OPEN);
-                        packet_put_int(nc->self);
-                }
+                packet_start(SSH2_MSG_CHANNEL_OPEN);
+                packet_put_cstring("auth-agent@openssh.com");
+                packet_put_int(nc->self);
+                packet_put_int(c->local_window_max);
+                packet_put_int(c->local_maxpacket);
                 packet_send();
         }
 }
@@ -1680,17 +1577,11 @@ channel_post_connecting(Channel *c, fd_set *readset, fd_set *writeset)
                             c->self, c->connect_ctx.host, c->connect_ctx.port);
                         channel_connect_ctx_free(&c->connect_ctx);
                         c->type = SSH_CHANNEL_OPEN;
-                        if (compat20) {
-                                packet_start(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION);
-                                packet_put_int(c->remote_id);
-                                packet_put_int(c->self);
-                                packet_put_int(c->local_window);
-                                packet_put_int(c->local_maxpacket);
-                        } else {
-                                packet_start(SSH_MSG_CHANNEL_OPEN_CONFIRMATION);
-                                packet_put_int(c->remote_id);
-                                packet_put_int(c->self);
-                        }
+                        packet_start(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION);
+                        packet_put_int(c->remote_id);
+                        packet_put_int(c->self);
+                        packet_put_int(c->local_window);
+                        packet_put_int(c->local_maxpacket);
                 } else {
                         debug("channel %d: connection failed: %s",
                             c->self, strerror(err));
@@ -1705,17 +1596,12 @@ channel_post_connecting(Channel *c, fd_set *readset, fd_set *writeset)
                         error("connect_to %.100s port %d: failed.",
                             c->connect_ctx.host, c->connect_ctx.port);
                         channel_connect_ctx_free(&c->connect_ctx);
-                        if (compat20) {
-                                packet_start(SSH2_MSG_CHANNEL_OPEN_FAILURE);
-                                packet_put_int(c->remote_id);
-                                packet_put_int(SSH2_OPEN_CONNECT_FAILED);
-                                if (!(datafellows & SSH_BUG_OPENFAILURE)) {
-                                        packet_put_cstring(strerror(err));
-                                        packet_put_cstring("");
-                                }
-                        } else {
-                                packet_start(SSH_MSG_CHANNEL_OPEN_FAILURE);
-                                packet_put_int(c->remote_id);
+                        packet_start(SSH2_MSG_CHANNEL_OPEN_FAILURE);
+                        packet_put_int(c->remote_id);
+                        packet_put_int(SSH2_OPEN_CONNECT_FAILED);
+                        if (!(datafellows & SSH_BUG_OPENFAILURE)) {
+                                packet_put_cstring(strerror(err));
+                                packet_put_cstring("");
                         }
                         chan_mark_dead(c);
                 }
@@ -1749,10 +1635,6 @@ channel_handle_rfd(Channel *c, fd_set *readset, fd_set *writeset)
                                 debug2("channel %d: not open", c->self);
                                 chan_mark_dead(c);
                                 return -1;
-                        } else if (compat13) {
-                                buffer_clear(&c->output);
-                                c->type = SSH_CHANNEL_INPUT_DRAINING;
-                                debug2("channel %d: input draining.", c->self);
                         } else {
                                 chan_read_failed(c);
                         }
@@ -1820,7 +1702,7 @@ channel_handle_wfd(Channel *c, fd_set *readset, fd_set *writeset)
                 }
 #ifdef _AIX
                 /* XXX: Later AIX versions can't push as much data to tty */
-                if (compat20 && c->wfd_isatty)
+                if (c->wfd_isatty)
                         dlen = MIN(dlen, 8*1024);
 #endif
 
@@ -1833,17 +1715,13 @@ channel_handle_wfd(Channel *c, fd_set *readset, fd_set *writeset)
                                 debug2("channel %d: not open", c->self);
                                 chan_mark_dead(c);
                                 return -1;
-                        } else if (compat13) {
-                                buffer_clear(&c->output);
-                                debug2("channel %d: input draining.", c->self);
-                                c->type = SSH_CHANNEL_INPUT_DRAINING;
                         } else {
                                 chan_write_failed(c);
                         }
                         return -1;
                 }
 #ifndef BROKEN_TCGETATTR_ICANON
-                if (compat20 && c->isatty && dlen >= 1 && buf[0] != '\r') {
+                if (c->isatty && dlen >= 1 && buf[0] != '\r') {
                         if (tcgetattr(c->wfd, &tio) == 0 &&
                             !(tio.c_lflag & ECHO) && (tio.c_lflag & ICANON)) {
                                 /*
@@ -1860,7 +1738,7 @@ channel_handle_wfd(Channel *c, fd_set *readset, fd_set *writeset)
                 buffer_consume(&c->output, len);
         }
  out:
-        if (compat20 && olen > 0)
+        if (olen > 0)
                 c->local_consumed += olen - buffer_len(&c->output);
         return 1;
 }
@@ -1944,8 +1822,6 @@ channel_post_open(Channel *c, fd_set *readset, fd_set *writeset)
 {
         channel_handle_rfd(c, readset, writeset);
         channel_handle_wfd(c, readset, writeset);
-        if (!compat20)
-                return;
         channel_handle_efd(c, readset, writeset);
         channel_check_window(c);
 }
@@ -1979,9 +1855,6 @@ channel_post_mux_client(Channel *c, fd_set *readset, fd_set *writeset)
         u_int need;
         ssize_t len;
 
-        if (!compat20)
-                fatal("%s: entered with !compat20", __func__);
-
         if (c->rfd != -1 && !c->mux_pause && FD_ISSET(c->rfd, readset) &&
             (c->istate == CHAN_INPUT_OPEN ||
             c->istate == CHAN_INPUT_WAIT_DRAIN)) {
@@ -2074,26 +1947,15 @@ channel_post_mux_listener(Channel *c, fd_set *readset, fd_set *writeset)
         nc->flags |= CHAN_LOCAL;
 }
 
-/* ARGSUSED */
 static void
-channel_post_output_drain_13(Channel *c, fd_set *readset, fd_set *writeset)
+channel_handler_init(void)
 {
-        int len;
+        int i;
 
-        /* Send buffered output data to the socket. */
-        if (FD_ISSET(c->sock, writeset) && buffer_len(&c->output) > 0) {
-                len = write(c->sock, buffer_ptr(&c->output),
-                            buffer_len(&c->output));
-                if (len <= 0)
-                        buffer_clear(&c->output);
-                else
-                        buffer_consume(&c->output, len);
+        for (i = 0; i < SSH_CHANNEL_MAX_TYPE; i++) {
+                channel_pre[i] = NULL;
+                channel_post[i] = NULL;
         }
-}
-
-static void
-channel_handler_init_20(void)
-{
         channel_pre[SSH_CHANNEL_OPEN] =                 &channel_pre_open;
         channel_pre[SSH_CHANNEL_X11_OPEN] =             &channel_pre_x11_open;
         channel_pre[SSH_CHANNEL_PORT_LISTENER] =        &channel_pre_listener;
@@ -2120,64 +1982,6 @@ channel_handler_init_20(void)
         channel_post[SSH_CHANNEL_MUX_CLIENT] =          &channel_post_mux_client;
 }
 
-static void
-channel_handler_init_13(void)
-{
-        channel_pre[SSH_CHANNEL_OPEN] =                 &channel_pre_open_13;
-        channel_pre[SSH_CHANNEL_X11_OPEN] =             &channel_pre_x11_open_13;
-        channel_pre[SSH_CHANNEL_X11_LISTENER] =         &channel_pre_listener;
-        channel_pre[SSH_CHANNEL_PORT_LISTENER] =        &channel_pre_listener;
-        channel_pre[SSH_CHANNEL_AUTH_SOCKET] =          &channel_pre_listener;
-        channel_pre[SSH_CHANNEL_INPUT_DRAINING] =       &channel_pre_input_draining;
-        channel_pre[SSH_CHANNEL_OUTPUT_DRAINING] =      &channel_pre_output_draining;
-        channel_pre[SSH_CHANNEL_CONNECTING] =           &channel_pre_connecting;
-        channel_pre[SSH_CHANNEL_DYNAMIC] =              &channel_pre_dynamic;
-
-        channel_post[SSH_CHANNEL_OPEN] =                &channel_post_open;
-        channel_post[SSH_CHANNEL_X11_LISTENER] =        &channel_post_x11_listener;
-        channel_post[SSH_CHANNEL_PORT_LISTENER] =       &channel_post_port_listener;
-        channel_post[SSH_CHANNEL_AUTH_SOCKET] =         &channel_post_auth_listener;
-        channel_post[SSH_CHANNEL_OUTPUT_DRAINING] =     &channel_post_output_drain_13;
-        channel_post[SSH_CHANNEL_CONNECTING] =          &channel_post_connecting;
-        channel_post[SSH_CHANNEL_DYNAMIC] =             &channel_post_open;
-}
-
-static void
-channel_handler_init_15(void)
-{
-        channel_pre[SSH_CHANNEL_OPEN] =                 &channel_pre_open;
-        channel_pre[SSH_CHANNEL_X11_OPEN] =             &channel_pre_x11_open;
-        channel_pre[SSH_CHANNEL_X11_LISTENER] =         &channel_pre_listener;
-        channel_pre[SSH_CHANNEL_PORT_LISTENER] =        &channel_pre_listener;
-        channel_pre[SSH_CHANNEL_AUTH_SOCKET] =          &channel_pre_listener;
-        channel_pre[SSH_CHANNEL_CONNECTING] =           &channel_pre_connecting;
-        channel_pre[SSH_CHANNEL_DYNAMIC] =              &channel_pre_dynamic;
-
-        channel_post[SSH_CHANNEL_X11_LISTENER] =        &channel_post_x11_listener;
-        channel_post[SSH_CHANNEL_PORT_LISTENER] =       &channel_post_port_listener;
-        channel_post[SSH_CHANNEL_AUTH_SOCKET] =         &channel_post_auth_listener;
-        channel_post[SSH_CHANNEL_OPEN] =                &channel_post_open;
-        channel_post[SSH_CHANNEL_CONNECTING] =          &channel_post_connecting;
-        channel_post[SSH_CHANNEL_DYNAMIC] =             &channel_post_open;
-}
-
-static void
-channel_handler_init(void)
-{
-        int i;
-
-        for (i = 0; i < SSH_CHANNEL_MAX_TYPE; i++) {
-                channel_pre[i] = NULL;
-                channel_post[i] = NULL;
-        }
-        if (compat20)
-                channel_handler_init_20();
-        else if (compat13)
-                channel_handler_init_13();
-        else
-                channel_handler_init_15();
-}
-
 /* gc dead channels */
 static void
 channel_garbage_collect(Channel *c)
@@ -2312,16 +2116,9 @@ channel_output_poll(void)
                  * We are only interested in channels that can have buffered
                  * incoming data.
                  */
-                if (compat13) {
-                        if (c->type != SSH_CHANNEL_OPEN &&
-                            c->type != SSH_CHANNEL_INPUT_DRAINING)
-                                continue;
-                } else {
-                        if (c->type != SSH_CHANNEL_OPEN)
-                                continue;
-                }
-                if (compat20 &&
-                    (c->flags & (CHAN_CLOSE_SENT|CHAN_CLOSE_RCVD))) {
+                if (c->type != SSH_CHANNEL_OPEN)
+                        continue;
+                if ((c->flags & (CHAN_CLOSE_SENT|CHAN_CLOSE_RCVD))) {
                         /* XXX is this true? */
                         debug3("channel %d: will not send data after close", c->self);
                         continue;
@@ -2359,24 +2156,12 @@ channel_output_poll(void)
                          * Send some data for the other side over the secure
                          * connection.
                          */
-                        if (compat20) {
-                                if (len > c->remote_window)
-                                        len = c->remote_window;
-                                if (len > c->remote_maxpacket)
-                                        len = c->remote_maxpacket;
-                        } else {
-                                if (packet_is_interactive()) {
-                                        if (len > 1024)
-                                                len = 512;
-                                } else {
-                                        /* Keep the packets at reasonable size. */
-                                        if (len > packet_get_maxsize()/2)
-                                                len = packet_get_maxsize()/2;
-                                }
-                        }
+                        if (len > c->remote_window)
+                                len = c->remote_window;
+                        if (len > c->remote_maxpacket)
+                                len = c->remote_maxpacket;
                         if (len > 0) {
-                                packet_start(compat20 ?
-                                    SSH2_MSG_CHANNEL_DATA : SSH_MSG_CHANNEL_DATA);
+                                packet_start(SSH2_MSG_CHANNEL_DATA);
                                 packet_put_int(c->remote_id);
                                 packet_put_string(buffer_ptr(&c->input), len);
                                 packet_send();
@@ -2384,8 +2169,6 @@ channel_output_poll(void)
                                 c->remote_window -= len;
                         }
                 } else if (c->istate == CHAN_INPUT_WAIT_DRAIN) {
-                        if (compat13)
-                                fatal("cannot happen: istate == INPUT_WAIT_DRAIN for proto 1.3");
                         /*
                          * input-buffer is empty and read-socket shutdown:
                          * tell peer, that we will not send more data: send IEOF.
@@ -2398,8 +2181,7 @@ channel_output_poll(void)
                                 chan_ibuf_empty(c);
                 }
                 /* Send extended data, i.e. stderr */
-                if (compat20 &&
-                    !(c->flags & CHAN_EOF_SENT) &&
+                if (!(c->flags & CHAN_EOF_SENT) &&
                     c->remote_window > 0 &&
                     (len = buffer_len(&c->extended)) > 0 &&
                     c->extended_usage == CHAN_EXTENDED_READ) {
@@ -2738,26 +2520,23 @@ channel_input_data(int type, u_int32_t seq, void *ctxt)
          * that window updates are sent back.  Otherwise the connection might
          * deadlock.
          */
-        if (!compat13 && c->ostate != CHAN_OUTPUT_OPEN) {
-                if (compat20) {
-                        c->local_window -= win_len;
-                        c->local_consumed += win_len;
-                }
+        if (c->ostate != CHAN_OUTPUT_OPEN) {
+                c->local_window -= win_len;
+                c->local_consumed += win_len;
                 return 0;
         }
 
-        if (compat20) {
-                if (win_len > c->local_maxpacket) {
-                        logit("channel %d: rcvd big packet %d, maxpack %d",
-                            c->self, win_len, c->local_maxpacket);
-                }
-                if (win_len > c->local_window) {
-                        logit("channel %d: rcvd too much data %d, win %d",
-                            c->self, win_len, c->local_window);
-                        return 0;
-                }
-                c->local_window -= win_len;
+        if (win_len > c->local_maxpacket) {
+                logit("channel %d: rcvd big packet %d, maxpack %d",
+                    c->self, win_len, c->local_maxpacket);
+        }
+        if (win_len > c->local_window) {
+                logit("channel %d: rcvd too much data %d, win %d",
+                    c->self, win_len, c->local_window);
+                return 0;
         }
+        c->local_window -= win_len;
+
         if (c->datagram)
                 buffer_put_string(&c->output, data, data_len);
         else
@@ -2942,17 +2721,15 @@ channel_input_open_confirmation(int type, u_int32_t seq, void *ctxt)
         c->remote_id = remote_id;
         c->type = SSH_CHANNEL_OPEN;
 
-        if (compat20) {
-                c->remote_window = packet_get_int();
-                c->remote_maxpacket = packet_get_int();
-                if (c->open_confirm) {
-                        debug2("callback start");
-                        c->open_confirm(c->self, 1, c->open_confirm_ctx);
-                        debug2("callback done");
-                }
-                debug2("channel %d: open confirm rwindow %u rmax %u", c->self,
-                    c->remote_window, c->remote_maxpacket);
+        c->remote_window = packet_get_int();
+        c->remote_maxpacket = packet_get_int();
+        if (c->open_confirm) {
+                debug2("callback start");
+                c->open_confirm(c->self, 1, c->open_confirm_ctx);
+                debug2("callback done");
         }
+        debug2("channel %d: open confirm rwindow %u rmax %u", c->self,
+            c->remote_window, c->remote_maxpacket);
         packet_check_eom();
         return 0;
 }
@@ -2992,21 +2769,19 @@ channel_input_open_failure(int type, u_int32_t seq, void *ctxt)
         if (c->type != SSH_CHANNEL_OPENING)
                 packet_disconnect("Received open failure for "
                     "non-opening channel %d.", id);
-        if (compat20) {
-                reason = packet_get_int();
-                if (!(datafellows & SSH_BUG_OPENFAILURE)) {
-                        msg  = packet_get_string(NULL);
-                        lang = packet_get_string(NULL);
-                }
-                logit("channel %d: open failed: %s%s%s", id,
-                    reason2txt(reason), msg ? ": ": "", msg ? msg : "");
-                free(msg);
-                free(lang);
-                if (c->open_confirm) {
-                        debug2("callback start");
-                        c->open_confirm(c->self, 0, c->open_confirm_ctx);
-                        debug2("callback done");
-                }
+        reason = packet_get_int();
+        if (!(datafellows & SSH_BUG_OPENFAILURE)) {
+                msg  = packet_get_string(NULL);
+                lang = packet_get_string(NULL);
+        }
+        logit("channel %d: open failed: %s%s%s", id,
+            reason2txt(reason), msg ? ": ": "", msg ? msg : "");
+        free(msg);
+        free(lang);
+        if (c->open_confirm) {
+                debug2("callback start");
+                c->open_confirm(c->self, 0, c->open_confirm_ctx);
+                debug2("callback done");
         }
         packet_check_eom();
         /* Schedule the channel for cleanup/deletion. */
@@ -3022,9 +2797,6 @@ channel_input_window_adjust(int type, u_int32_t seq, void *ctxt)
         int id;
         u_int adjust, tmp;
 
-        if (!compat20)
-                return 0;
-
         /* Get the channel number and verify it. */
         id = packet_get_int();
         c = channel_lookup(id);
@@ -3581,49 +3353,24 @@ channel_rfwd_bind_host(const char *listen_host)
 int
 channel_request_remote_forwarding(struct Forward *fwd)
 {
-        int type, success = 0, idx = -1;
+        int success = 0, idx = -1;
 
         /* Send the forward request to the remote side. */
-        if (compat20) {
-                packet_start(SSH2_MSG_GLOBAL_REQUEST);
-                if (fwd->listen_path != NULL) {
-                    packet_put_cstring("streamlocal-forward@openssh.com");
-                    packet_put_char(1);         /* boolean: want reply */
-                    packet_put_cstring(fwd->listen_path);
-                } else {
-                    packet_put_cstring("tcpip-forward");
-                    packet_put_char(1);         /* boolean: want reply */
-                    packet_put_cstring(channel_rfwd_bind_host(fwd->listen_host));
-                    packet_put_int(fwd->listen_port);
-                }
-                packet_send();
-                packet_write_wait();
-                /* Assume that server accepts the request */
-                success = 1;
-        } else if (fwd->listen_path == NULL) {
-                packet_start(SSH_CMSG_PORT_FORWARD_REQUEST);
-                packet_put_int(fwd->listen_port);
-                packet_put_cstring(fwd->connect_host);
-                packet_put_int(fwd->connect_port);
-                packet_send();
-                packet_write_wait();
-
-                /* Wait for response from the remote side. */
-                type = packet_read();
-                switch (type) {
-                case SSH_SMSG_SUCCESS:
-                        success = 1;
-                        break;
-                case SSH_SMSG_FAILURE:
-                        break;
-                default:
-                        /* Unknown packet */
-                        packet_disconnect("Protocol error for port forward request:"
-                            "received packet type %d.", type);
-                }
+        packet_start(SSH2_MSG_GLOBAL_REQUEST);
+        if (fwd->listen_path != NULL) {
+            packet_put_cstring("streamlocal-forward@openssh.com");
+            packet_put_char(1);         /* boolean: want reply */
+            packet_put_cstring(fwd->listen_path);
         } else {
-                logit("Warning: Server does not support remote stream local forwarding.");
+            packet_put_cstring("tcpip-forward");
+            packet_put_char(1);         /* boolean: want reply */
+            packet_put_cstring(channel_rfwd_bind_host(fwd->listen_host));
+            packet_put_int(fwd->listen_port);
         }
+        packet_send();
+        packet_write_wait();
+        /* Assume that server accepts the request */
+        success = 1;
         if (success) {
                 /* Record that connection to this host/port is permitted. */
                 permitted_opens = xreallocarray(permitted_opens,
@@ -3722,9 +3469,6 @@ channel_request_rforward_cancel_tcpip(const char *host, u_short port)
 {
         int i;
 
-        if (!compat20)
-                return -1;
-
         for (i = 0; i < num_permitted_opens; i++) {
                 if (open_listen_match_tcpip(&permitted_opens[i], host, port, 0))
                         break;
@@ -3761,9 +3505,6 @@ channel_request_rforward_cancel_streamlocal(const char *path)
 {
         int i;
 
-        if (!compat20)
-                return -1;
-
         for (i = 0; i < num_permitted_opens; i++) {
                 if (open_listen_match_streamlocal(&permitted_opens[i], path))
                         break;
@@ -4644,12 +4385,8 @@ x11_request_forwarding_with_spoofing(int client_session_id, const char *disp,
         new_data = tohex(x11_fake_data, data_len);
 
         /* Send the request packet. */
-        if (compat20) {
-                channel_request_start(client_session_id, "x11-req", want_reply);
-                packet_put_char(0);     /* XXX bool single connection */
-        } else {
-                packet_start(SSH_CMSG_X11_REQUEST_FORWARDING);
-        }
+        channel_request_start(client_session_id, "x11-req", want_reply);
+        packet_put_char(0);     /* XXX bool single connection */
         packet_put_cstring(proto);
         packet_put_cstring(new_data);
         packet_put_int(screen_number);