X-Git-Url: https://git.distorted.org.uk/u/mdw/putty/blobdiff_plain/bb487ce20e2e8b2d0554ef1a394bf5a6dc6939ff..8df7a775f6f8b0f81f84eafe28cd0bb8d4c6d1f4:/ssh.c

diff --git a/ssh.c b/ssh.c
index 3b4fcb2a..744c86d3 100644
--- a/ssh.c
+++ b/ssh.c
@@ -1,19 +1,12 @@
+#include <windows.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <assert.h>
-#ifndef AUTO_WINSOCK
-#ifdef WINSOCK_TWO
-#include <winsock2.h>
-#else
-#include <winsock.h>
-#endif
-#endif
 
 #include "putty.h"
 #include "tree234.h"
 #include "ssh.h"
-#include "scp.h"
 
 #ifndef FALSE
 #define FALSE 0
@@ -26,8 +19,8 @@
                       if ((flags & FLAG_STDERR) && (flags & FLAG_VERBOSE)) \
                       fprintf(stderr, "%s\n", s); }
 
-#define bombout(msg) ( ssh_state == SSH_STATE_CLOSED, closesocket(s), \
-                       s = INVALID_SOCKET, connection_fatal msg )
+#define bombout(msg) ( ssh_state = SSH_STATE_CLOSED, sk_close(s), \
+                       s = NULL, connection_fatal msg )
 
 #define SSH1_MSG_DISCONNECT                       1    /* 0x1 */
 #define SSH1_SMSG_PUBLIC_KEY                      2    /* 0x2 */
@@ -148,63 +141,43 @@ enum { PKT_END, PKT_INT, PKT_CHAR, PKT_DATA, PKT_STR, PKT_BIGNUM };
 #define crWaitUntil(c)	do { crReturn(0); } while (!(c))
 #define crWaitUntilV(c)	do { crReturnV; } while (!(c))
 
-extern struct ssh_cipher ssh_3des;
-extern struct ssh_cipher ssh_3des_ssh2;
-extern struct ssh_cipher ssh_des;
-extern struct ssh_cipher ssh_blowfish_ssh1;
-extern struct ssh_cipher ssh_blowfish_ssh2;
+extern const struct ssh_cipher ssh_3des;
+extern const struct ssh_cipher ssh_3des_ssh2;
+extern const struct ssh_cipher ssh_des;
+extern const struct ssh_cipher ssh_blowfish_ssh1;
+extern const struct ssh_cipher ssh_blowfish_ssh2;
 
 /*
  * Ciphers for SSH2. We miss out single-DES because it isn't
  * supported; also 3DES and Blowfish are both done differently from
  * SSH1. (3DES uses outer chaining; Blowfish has the opposite
  * endianness and different-sized keys.)
- *
- * The first entry in this array is set up to be whatever the user
- * asks for as a cipher. Thereafter there is a fixed preference
- * order of fallback ciphers.
  */
-struct ssh_cipher *ciphers[] = { NULL, &ssh_blowfish_ssh2, &ssh_3des_ssh2 };
-
-extern struct ssh_kex ssh_diffiehellman;
-struct ssh_kex *kex_algs[] = { &ssh_diffiehellman };
+const static struct ssh_cipher *ciphers[] = { &ssh_blowfish_ssh2, &ssh_3des_ssh2 };
 
-extern struct ssh_hostkey ssh_dss;
-struct ssh_hostkey *hostkey_algs[] = { &ssh_dss };
+extern const struct ssh_kex ssh_diffiehellman;
+const static struct ssh_kex *kex_algs[] = { &ssh_diffiehellman };
 
-extern struct ssh_mac ssh_sha1;
+extern const struct ssh_hostkey ssh_dss;
+const static struct ssh_hostkey *hostkey_algs[] = { &ssh_dss };
 
-static SHA_State exhash;
+extern const struct ssh_mac ssh_md5, ssh_sha1, ssh_sha1_buggy;
 
 static void nullmac_key(unsigned char *key) { }
 static void nullmac_generate(unsigned char *blk, int len, unsigned long seq) { }
 static int nullmac_verify(unsigned char *blk, int len, unsigned long seq) { return 1; }
-struct ssh_mac ssh_mac_none = {
+const static struct ssh_mac ssh_mac_none = {
     nullmac_key, nullmac_key, nullmac_generate, nullmac_verify, "none", 0
 };
-struct ssh_mac *macs[] = { &ssh_sha1, &ssh_mac_none };
+const static struct ssh_mac *macs[] = {
+    &ssh_sha1, &ssh_md5, &ssh_mac_none };
+const static struct ssh_mac *buggymacs[] = {
+    &ssh_sha1_buggy, &ssh_md5, &ssh_mac_none };
 
-struct ssh_compress ssh_comp_none = {
+const static struct ssh_compress ssh_comp_none = {
     "none"
 };
-struct ssh_compress *compressions[] = { &ssh_comp_none };
-
-static SOCKET s = INVALID_SOCKET;
-
-static unsigned char session_key[32];
-static struct ssh_cipher *cipher = NULL;
-static struct ssh_cipher *cscipher = NULL;
-static struct ssh_cipher *sccipher = NULL;
-static struct ssh_mac *csmac = NULL;
-static struct ssh_mac *scmac = NULL;
-static struct ssh_compress *cscomp = NULL;
-static struct ssh_compress *sccomp = NULL;
-static struct ssh_kex *kex = NULL;
-static struct ssh_hostkey *hostkey = NULL;
-int (*ssh_get_password)(const char *prompt, char *str, int maxlen) = NULL;
-
-static char *savedhost;
-static int ssh_send_ok;
+const static struct ssh_compress *compressions[] = { &ssh_comp_none };
 
 /*
  * 2-3-4 tree storing channels.
@@ -226,7 +199,74 @@ struct ssh_channel {
         } v2;
     } u;
 };
+
+struct Packet {
+    long length;
+    int type;
+    unsigned char *data;
+    unsigned char *body;
+    long savedpos;
+    long maxlen;
+};
+
+static SHA_State exhash;
+
+static Socket s = NULL;
+
+static unsigned char session_key[32];
+static const struct ssh_cipher *cipher = NULL;
+static const struct ssh_cipher *cscipher = NULL;
+static const struct ssh_cipher *sccipher = NULL;
+static const struct ssh_mac *csmac = NULL;
+static const struct ssh_mac *scmac = NULL;
+static const struct ssh_compress *cscomp = NULL;
+static const struct ssh_compress *sccomp = NULL;
+static const struct ssh_kex *kex = NULL;
+static const struct ssh_hostkey *hostkey = NULL;
+int (*ssh_get_password)(const char *prompt, char *str, int maxlen) = NULL;
+
+static char *savedhost;
+static int savedport;
+static int ssh_send_ok;
+
 static tree234 *ssh_channels;           /* indexed by local id */
+static struct ssh_channel *mainchan;   /* primary session channel */
+
+static enum {
+    SSH_STATE_BEFORE_SIZE,
+    SSH_STATE_INTERMED,
+    SSH_STATE_SESSION,
+    SSH_STATE_CLOSED
+} ssh_state = SSH_STATE_BEFORE_SIZE;
+
+static int size_needed = FALSE;
+
+static struct Packet pktin = { 0, 0, NULL, NULL, 0 };
+static struct Packet pktout = { 0, 0, NULL, NULL, 0 };
+
+static int ssh_version;
+static void (*ssh_protocol)(unsigned char *in, int inlen, int ispkt);
+static void ssh1_protocol(unsigned char *in, int inlen, int ispkt);
+static void ssh2_protocol(unsigned char *in, int inlen, int ispkt);
+static void ssh_size(void);
+
+static int (*s_rdpkt)(unsigned char **data, int *datalen);
+
+static struct rdpkt1_state_tag {
+    long len, pad, biglen, to_read;
+    unsigned long realcrc, gotcrc;
+    unsigned char *p;
+    int i;
+    int chunk;
+} rdpkt1_state;
+
+static struct rdpkt2_state_tag {
+    long len, pad, payload, packetlen, maclen;
+    int i;
+    int cipherblk;
+    unsigned long incoming_sequence;
+} rdpkt2_state;
+
 static int ssh_channelcmp(void *av, void *bv) {
     struct ssh_channel *a = (struct ssh_channel *)av;
     struct ssh_channel *b = (struct ssh_channel *)bv;
@@ -242,43 +282,6 @@ static int ssh_channelfind(void *av, void *bv) {
     return 0;
 }
 
-static struct ssh_channel *mainchan;   /* primary session channel */
-
-static enum {
-    SSH_STATE_BEFORE_SIZE,
-    SSH_STATE_INTERMED,
-    SSH_STATE_SESSION,
-    SSH_STATE_CLOSED
-} ssh_state = SSH_STATE_BEFORE_SIZE;
-
-static int size_needed = FALSE;
-
-static void s_write (char *buf, int len) {
-    while (len > 0) {
-	int i = send (s, buf, len, 0);
-        noise_ultralight(i);
-        if (i <= 0) {
-            bombout(("Lost connection while sending"));
-            return;
-        }
-	if (i > 0)
-	    len -= i, buf += i;
-    }
-}
-
-static int s_read (char *buf, int len) {
-    int ret = 0;
-    while (len > 0) {
-	int i = recv (s, buf, len, 0);
-        noise_ultralight(i);
-	if (i > 0)
-	    len -= i, buf += i, ret += i;
-	else
-	    return i;
-    }
-    return ret;
-}
-
 static void c_write (char *buf, int len) {
     if ((flags & FLAG_STDERR)) {
         int i;
@@ -287,30 +290,9 @@ static void c_write (char *buf, int len) {
                 fputc(buf[i], stderr);
 	return;
     }
-    while (len--) 
-        c_write1(*buf++);
+    from_backend(1, buf, len);
 }
 
-struct Packet {
-    long length;
-    int type;
-    unsigned char *data;
-    unsigned char *body;
-    long savedpos;
-    long maxlen;
-};
-
-static struct Packet pktin = { 0, 0, NULL, NULL, 0 };
-static struct Packet pktout = { 0, 0, NULL, NULL, 0 };
-
-static int ssh_version;
-static void (*ssh_protocol)(unsigned char *in, int inlen, int ispkt);
-static void ssh1_protocol(unsigned char *in, int inlen, int ispkt);
-static void ssh2_protocol(unsigned char *in, int inlen, int ispkt);
-static void ssh_size(void);
-
-static int (*s_rdpkt)(unsigned char **data, int *datalen);
-
 /*
  * Collect incoming data in the incoming packet buffer.
  * Decipher and verify the packet when it is completely read.
@@ -321,10 +303,7 @@ static int (*s_rdpkt)(unsigned char **data, int *datalen);
  */
 static int ssh1_rdpkt(unsigned char **data, int *datalen)
 {
-    static long len, pad, biglen, to_read;
-    static unsigned long realcrc, gotcrc;
-    static unsigned char *p;
-    static int i;
+    struct rdpkt1_state_tag *st = &rdpkt1_state;
 
     crBegin;
 
@@ -333,56 +312,61 @@ next_packet:
     pktin.type = 0;
     pktin.length = 0;
 
-    for (i = len = 0; i < 4; i++) {
+    for (st->i = st->len = 0; st->i < 4; st->i++) {
 	while ((*datalen) == 0)
-	    crReturn(4-i);
-	len = (len << 8) + **data;
+	    crReturn(4-st->i);
+	st->len = (st->len << 8) + **data;
 	(*data)++, (*datalen)--;
     }
 
 #ifdef FWHACK
-    if (len == 0x52656d6f) {       /* "Remo"te server has closed ... */
-        len = 0x300;               /* big enough to carry to end */
+    if (st->len == 0x52656d6f) {        /* "Remo"te server has closed ... */
+        st->len = 0x300;                /* big enough to carry to end */
     }
 #endif
 
-    pad = 8 - (len % 8);
-    biglen = len + pad;
-    pktin.length = len - 5;
+    st->pad = 8 - (st->len % 8);
+    st->biglen = st->len + st->pad;
+    pktin.length = st->len - 5;
 
-    if (pktin.maxlen < biglen) {
-	pktin.maxlen = biglen;
-	pktin.data = (pktin.data == NULL ? malloc(biglen+APIEXTRA) :
-	              realloc(pktin.data, biglen+APIEXTRA));
+    if (pktin.maxlen < st->biglen) {
+	pktin.maxlen = st->biglen;
+	pktin.data = (pktin.data == NULL ? malloc(st->biglen+APIEXTRA) :
+	              realloc(pktin.data, st->biglen+APIEXTRA));
 	if (!pktin.data)
 	    fatalbox("Out of memory");
     }
 
-    to_read = biglen;
-    p = pktin.data;
-    while (to_read > 0) {
-	static int chunk;
-	chunk = to_read;
+    st->to_read = st->biglen;
+    st->p = pktin.data;
+    while (st->to_read > 0) {
+        st->chunk = st->to_read;
 	while ((*datalen) == 0)
-	    crReturn(to_read);
-	if (chunk > (*datalen))
-	    chunk = (*datalen);
-	memcpy(p, *data, chunk);
-	*data += chunk;
-	*datalen -= chunk;
-	p += chunk;
-	to_read -= chunk;
+	    crReturn(st->to_read);
+	if (st->chunk > (*datalen))
+	    st->chunk = (*datalen);
+	memcpy(st->p, *data, st->chunk);
+	*data += st->chunk;
+	*datalen -= st->chunk;
+	st->p += st->chunk;
+	st->to_read -= st->chunk;
     }
 
     if (cipher)
-	cipher->decrypt(pktin.data, biglen);
+	cipher->decrypt(pktin.data, st->biglen);
+#if 0
+    debug(("Got packet len=%d pad=%d\r\n", st->len, st->pad));
+    for (st->i = 0; st->i < st->biglen; st->i++)
+        debug(("  %02x", (unsigned char)pktin.data[st->i]));
+    debug(("\r\n"));
+#endif
 
-    pktin.type = pktin.data[pad];
-    pktin.body = pktin.data + pad + 1;
+    pktin.type = pktin.data[st->pad];
+    pktin.body = pktin.data + st->pad + 1;
 
-    realcrc = crc32(pktin.data, biglen-4);
-    gotcrc = GET_32BIT(pktin.data+biglen-4);
-    if (gotcrc != realcrc) {
+    st->realcrc = crc32(pktin.data, st->biglen-4);
+    st->gotcrc = GET_32BIT(pktin.data+st->biglen-4);
+    if (st->gotcrc != st->realcrc) {
 	bombout(("Incorrect CRC received on packet"));
         crReturn(0);
     }
@@ -419,29 +403,24 @@ next_packet:
 
 static int ssh2_rdpkt(unsigned char **data, int *datalen)
 {
-    static long len, pad, payload, packetlen, maclen;
-    static int i;
-    static int cipherblk;
-    static unsigned long incoming_sequence = 0;
+    struct rdpkt2_state_tag *st = &rdpkt2_state;
 
     crBegin;
 
 next_packet:
-
     pktin.type = 0;
     pktin.length = 0;
-
-    if (cipher)
-        cipherblk = cipher->blksize;
+    if (sccipher)
+        st->cipherblk = sccipher->blksize;
     else
-        cipherblk = 8;
-    if (cipherblk < 8)
-        cipherblk = 8;
-
-    if (pktin.maxlen < cipherblk) {
-	pktin.maxlen = cipherblk;
-	pktin.data = (pktin.data == NULL ? malloc(cipherblk+APIEXTRA) :
-	              realloc(pktin.data, cipherblk+APIEXTRA));
+        st->cipherblk = 8;
+    if (st->cipherblk < 8)
+        st->cipherblk = 8;
+
+    if (pktin.maxlen < st->cipherblk) {
+	pktin.maxlen = st->cipherblk;
+	pktin.data = (pktin.data == NULL ? malloc(st->cipherblk+APIEXTRA) :
+	              realloc(pktin.data, st->cipherblk+APIEXTRA));
 	if (!pktin.data)
 	    fatalbox("Out of memory");
     }
@@ -450,10 +429,10 @@ next_packet:
      * Acquire and decrypt the first block of the packet. This will
      * contain the length and padding details.
      */
-     for (i = len = 0; i < cipherblk; i++) {
+     for (st->i = st->len = 0; st->i < st->cipherblk; st->i++) {
 	while ((*datalen) == 0)
-	    crReturn(cipherblk-i);
-	pktin.data[i] = *(*data)++;
+	    crReturn(st->cipherblk-st->i);
+	pktin.data[st->i] = *(*data)++;
         (*datalen)--;
     }
 #ifdef FWHACK
@@ -462,32 +441,32 @@ next_packet:
     }
 #endif
     if (sccipher)
-        sccipher->decrypt(pktin.data, cipherblk);
+        sccipher->decrypt(pktin.data, st->cipherblk);
 
     /*
      * Now get the length and padding figures.
      */
-    len = GET_32BIT(pktin.data);
-    pad = pktin.data[4];
+    st->len = GET_32BIT(pktin.data);
+    st->pad = pktin.data[4];
 
     /*
      * This enables us to deduce the payload length.
      */
-    payload = len - pad - 1;
+    st->payload = st->len - st->pad - 1;
 
-    pktin.length = payload + 5;
+    pktin.length = st->payload + 5;
 
     /*
      * So now we can work out the total packet length.
      */
-    packetlen = len + 4;
-    maclen = scmac ? scmac->len : 0;
+    st->packetlen = st->len + 4;
+    st->maclen = scmac ? scmac->len : 0;
 
     /*
      * Adjust memory allocation if packet is too big.
      */
-    if (pktin.maxlen < packetlen+maclen) {
-	pktin.maxlen = packetlen+maclen;
+    if (pktin.maxlen < st->packetlen+st->maclen) {
+	pktin.maxlen = st->packetlen+st->maclen;
 	pktin.data = (pktin.data == NULL ? malloc(pktin.maxlen+APIEXTRA) :
 	              realloc(pktin.data, pktin.maxlen+APIEXTRA));
 	if (!pktin.data)
@@ -497,31 +476,32 @@ next_packet:
     /*
      * Read and decrypt the remainder of the packet.
      */
-    for (i = cipherblk; i < packetlen + maclen; i++) {
+    for (st->i = st->cipherblk; st->i < st->packetlen + st->maclen; st->i++) {
 	while ((*datalen) == 0)
-	    crReturn(packetlen + maclen - i);
-	pktin.data[i] = *(*data)++;
+	    crReturn(st->packetlen + st->maclen - st->i);
+	pktin.data[st->i] = *(*data)++;
         (*datalen)--;
     }
     /* Decrypt everything _except_ the MAC. */
     if (sccipher)
-        sccipher->decrypt(pktin.data + cipherblk, packetlen - cipherblk);
+        sccipher->decrypt(pktin.data + st->cipherblk,
+                          st->packetlen - st->cipherblk);
 
 #if 0
-    debug(("Got packet len=%d pad=%d\r\n", len, pad));
-    for (i = 0; i < packetlen; i++)
-        debug(("  %02x", (unsigned char)pktin.data[i]));
+    debug(("Got packet len=%d pad=%d\r\n", st->len, st->pad));
+    for (st->i = 0; st->i < st->packetlen; st->i++)
+        debug(("  %02x", (unsigned char)pktin.data[st->i]));
     debug(("\r\n"));
 #endif
 
     /*
      * Check the MAC.
      */
-    if (scmac && !scmac->verify(pktin.data, len+4, incoming_sequence)) {
+    if (scmac && !scmac->verify(pktin.data, st->len+4, st->incoming_sequence)) {
 	bombout(("Incorrect MAC received on packet"));
         crReturn(0);
     }
-    incoming_sequence++;               /* whether or not we MACed */
+    st->incoming_sequence++;               /* whether or not we MACed */
 
     pktin.savedpos = 6;
     pktin.type = pktin.data[5];
@@ -532,19 +512,6 @@ next_packet:
     crFinish(0);
 }
 
-static void ssh_gotdata(unsigned char *data, int datalen)
-{
-    while (datalen > 0) {
-	if ( s_rdpkt(&data, &datalen) == 0 ) {
-	    ssh_protocol(NULL, 0, 1);
-            if (ssh_state == SSH_STATE_CLOSED) {
-                return;
-            }
-        }
-    }
-}
-
-
 static void s_wrpkt_start(int type, int len) {
     int pad, biglen;
 
@@ -587,10 +554,16 @@ static void s_wrpkt(void) {
     PUT_32BIT(pktout.data+biglen, crc);
     PUT_32BIT(pktout.data, len);
 
+#if 0
+    debug(("Sending packet len=%d\r\n", biglen+4));
+    for (i = 0; i < biglen+4; i++)
+        debug(("  %02x", (unsigned char)pktout.data[i]));
+    debug(("\r\n"));
+#endif
     if (cipher)
 	cipher->encrypt(pktout.data+4, biglen);
 
-    s_write(pktout.data, biglen+4);
+    sk_write(s, pktout.data, biglen+4);
 }
 
 /*
@@ -677,108 +650,6 @@ static void send_packet(int pkttype, ...)
     s_wrpkt();
 }
 
-
-/*
- * Connect to specified host and port.
- * Returns an error message, or NULL on success.
- * Also places the canonical host name into `realhost'.
- */
-static char *connect_to_host(char *host, int port, char **realhost)
-{
-    SOCKADDR_IN addr;
-    struct hostent *h;
-    unsigned long a;
-#ifdef FWHACK
-    char *FWhost;
-    int FWport;
-#endif
-
-    savedhost = malloc(1+strlen(host));
-    if (!savedhost)
-	fatalbox("Out of memory");
-    strcpy(savedhost, host);
-
-    if (port < 0)
-	port = 22;		       /* default ssh port */
-
-#ifdef FWHACK
-    FWhost = host;
-    FWport = port;
-    host = FWSTR;
-    port = 23;
-#endif
-
-    /*
-     * Try to find host.
-     */
-    if ( (a = inet_addr(host)) == (unsigned long) INADDR_NONE) {
-	if ( (h = gethostbyname(host)) == NULL)
-	    switch (WSAGetLastError()) {
-	      case WSAENETDOWN: return "Network is down";
-	      case WSAHOST_NOT_FOUND: case WSANO_DATA:
-		return "Host does not exist";
-	      case WSATRY_AGAIN: return "Host not found";
-	      default: return "gethostbyname: unknown error";
-	    }
-	memcpy (&a, h->h_addr, sizeof(a));
-	*realhost = h->h_name;
-    } else
-	*realhost = host;
-#ifdef FWHACK
-    *realhost = FWhost;
-#endif
-    a = ntohl(a);
-
-    /*
-     * Open socket.
-     */
-    s = socket(AF_INET, SOCK_STREAM, 0);
-    if (s == INVALID_SOCKET)
-	switch (WSAGetLastError()) {
-	  case WSAENETDOWN: return "Network is down";
-	  case WSAEAFNOSUPPORT: return "TCP/IP support not present";
-	  default: return "socket(): unknown error";
-	}
-
-    /*
-     * Bind to local address.
-     */
-    addr.sin_family = AF_INET;
-    addr.sin_addr.s_addr = htonl(INADDR_ANY);
-    addr.sin_port = htons(0);
-    if (bind (s, (struct sockaddr *)&addr, sizeof(addr)) == SOCKET_ERROR)
-	switch (WSAGetLastError()) {
-	  case WSAENETDOWN: return "Network is down";
-	  default: return "bind(): unknown error";
-	}
-
-    /*
-     * Connect to remote address.
-     */
-    addr.sin_addr.s_addr = htonl(a);
-    addr.sin_port = htons((short)port);
-    if (connect (s, (struct sockaddr *)&addr, sizeof(addr)) == SOCKET_ERROR)
-	switch (WSAGetLastError()) {
-	  case WSAENETDOWN: return "Network is down";
-	  case WSAECONNREFUSED: return "Connection refused";
-	  case WSAENETUNREACH: return "Network is unreachable";
-	  case WSAEHOSTUNREACH: return "No route to host";
-	  default: return "connect(): unknown error";
-	}
-
-#ifdef FWHACK
-    send(s, "connect ", 8, 0);
-    send(s, FWhost, strlen(FWhost), 0);
-    {
-	char buf[20];
-	sprintf(buf, " %d\n", FWport);
-	send (s, buf, strlen(buf), 0);
-    }
-#endif
-
-    return NULL;
-}
-
 static int ssh_versioncmp(char *a, char *b) {
     char *ae, *be;
     unsigned long av, bv;
@@ -800,7 +671,7 @@ static int ssh_versioncmp(char *a, char *b) {
  * state.
  */
 #include <stdio.h>
-void sha_string(SHA_State *s, void *str, int len) {
+static void sha_string(SHA_State *s, void *str, int len) {
     unsigned char lenblk[4];
     PUT_32BIT(lenblk, len);
     SHA_Bytes(s, lenblk, 4);
@@ -810,7 +681,7 @@ void sha_string(SHA_State *s, void *str, int len) {
 /*
  * SSH2 packet construction functions.
  */
-void ssh2_pkt_adddata(void *data, int len) {
+static void ssh2_pkt_adddata(void *data, int len) {
     pktout.length += len;
     if (pktout.maxlen < pktout.length) {
         pktout.maxlen = pktout.length + 256;
@@ -821,40 +692,40 @@ void ssh2_pkt_adddata(void *data, int len) {
     }
     memcpy(pktout.data+pktout.length-len, data, len);
 }
-void ssh2_pkt_addbyte(unsigned char byte) {
+static void ssh2_pkt_addbyte(unsigned char byte) {
     ssh2_pkt_adddata(&byte, 1);
 }
-void ssh2_pkt_init(int pkt_type) {
+static void ssh2_pkt_init(int pkt_type) {
     pktout.length = 5;
     ssh2_pkt_addbyte((unsigned char)pkt_type);
 }
-void ssh2_pkt_addbool(unsigned char value) {
+static void ssh2_pkt_addbool(unsigned char value) {
     ssh2_pkt_adddata(&value, 1);
 }
-void ssh2_pkt_adduint32(unsigned long value) {
+static void ssh2_pkt_adduint32(unsigned long value) {
     unsigned char x[4];
     PUT_32BIT(x, value);
     ssh2_pkt_adddata(x, 4);
 }
-void ssh2_pkt_addstring_start(void) {
+static void ssh2_pkt_addstring_start(void) {
     ssh2_pkt_adduint32(0);
     pktout.savedpos = pktout.length;
 }
-void ssh2_pkt_addstring_str(char *data) {
+static void ssh2_pkt_addstring_str(char *data) {
     ssh2_pkt_adddata(data, strlen(data));
     PUT_32BIT(pktout.data + pktout.savedpos - 4,
               pktout.length - pktout.savedpos);
 }
-void ssh2_pkt_addstring_data(char *data, int len) {
+static void ssh2_pkt_addstring_data(char *data, int len) {
     ssh2_pkt_adddata(data, len);
     PUT_32BIT(pktout.data + pktout.savedpos - 4,
               pktout.length - pktout.savedpos);
 }
-void ssh2_pkt_addstring(char *data) {
+static void ssh2_pkt_addstring(char *data) {
     ssh2_pkt_addstring_start();
     ssh2_pkt_addstring_str(data);
 }
-char *ssh2_mpint_fmt(Bignum b, int *len) {
+static char *ssh2_mpint_fmt(Bignum b, int *len) {
     unsigned char *p;
     int i, n = b[0];
     p = malloc(n * 2 + 1);
@@ -872,7 +743,7 @@ char *ssh2_mpint_fmt(Bignum b, int *len) {
     *len = n*2+1-i;
     return p;
 }
-void ssh2_pkt_addmp(Bignum b) {
+static void ssh2_pkt_addmp(Bignum b) {
     unsigned char *p;
     int len;
     p = ssh2_mpint_fmt(b, &len);
@@ -880,7 +751,7 @@ void ssh2_pkt_addmp(Bignum b) {
     ssh2_pkt_addstring_data(p, len);
     free(p);
 }
-void ssh2_pkt_send(void) {
+static void ssh2_pkt_send(void) {
     int cipherblk, maclen, padding, i;
     static unsigned long outgoing_sequence = 0;
 
@@ -912,7 +783,7 @@ void ssh2_pkt_send(void) {
         cscipher->encrypt(pktout.data, pktout.length + padding);
     maclen = csmac ? csmac->len : 0;
 
-    s_write(pktout.data, pktout.length + padding + maclen);
+    sk_write(s, pktout.data, pktout.length + padding + maclen);
 }
 
 #if 0
@@ -928,7 +799,7 @@ void bndebug(char *string, Bignum b) {
 }
 #endif
 
-void sha_mpint(SHA_State *s, Bignum b) {
+static void sha_mpint(SHA_State *s, Bignum b) {
     unsigned char *p;
     int len;
     p = ssh2_mpint_fmt(b, &len);
@@ -939,7 +810,7 @@ void sha_mpint(SHA_State *s, Bignum b) {
 /*
  * SSH2 packet decode functions.
  */
-unsigned long ssh2_pkt_getuint32(void) {
+static unsigned long ssh2_pkt_getuint32(void) {
     unsigned long value;
     if (pktin.length - pktin.savedpos < 4)
         return 0;                      /* arrgh, no way to decline (FIXME?) */
@@ -947,7 +818,7 @@ unsigned long ssh2_pkt_getuint32(void) {
     pktin.savedpos += 4;
     return value;
 }
-void ssh2_pkt_getstring(char **p, int *length) {
+static void ssh2_pkt_getstring(char **p, int *length) {
     *p = NULL;
     if (pktin.length - pktin.savedpos < 4)
         return;
@@ -958,7 +829,7 @@ void ssh2_pkt_getstring(char **p, int *length) {
     *p = pktin.data+pktin.savedpos;
     pktin.savedpos += *length;
 }
-Bignum ssh2_pkt_getmp(void) {
+static Bignum ssh2_pkt_getmp(void) {
     char *p;
     int i, j, length;
     Bignum b;
@@ -981,33 +852,35 @@ Bignum ssh2_pkt_getmp(void) {
     return b;
 }
 
-static int do_ssh_init(void) {
-    char c, *vsp;
-    char version[10];
-    char vstring[80];
-    char vlog[sizeof(vstring)+20];
-    int i;
+static int do_ssh_init(unsigned char c) {
+    static char *vsp;
+    static char version[10];
+    static char vstring[80];
+    static char vlog[sizeof(vstring)+20];
+    static int i;
 
-#ifdef FWHACK
+    crBegin;
+
+    /* Search for the string "SSH-" in the input. */
     i = 0;
-    while (s_read(&c, 1) == 1) {
-	if (c == 'S' && i < 2) i++;
-	else if (c == 'S' && i == 2) i = 2;
-	else if (c == 'H' && i == 2) break;
+    while (1) {
+	static const int transS[] = { 1, 2, 2, 1 };
+	static const int transH[] = { 0, 0, 3, 0 };
+	static const int transminus[] = { 0, 0, 0, -1 };
+	if (c == 'S') i = transS[i];
+	else if (c == 'H') i = transH[i];
+	else if (c == '-') i = transminus[i];
 	else i = 0;
+	if (i < 0)
+	    break;
+	crReturn(1);		       /* get another character */
     }
-#else
-    if (s_read(&c,1) != 1 || c != 'S') return 0;
-    if (s_read(&c,1) != 1 || c != 'S') return 0;
-    if (s_read(&c,1) != 1 || c != 'H') return 0;
-#endif
+
     strcpy(vstring, "SSH-");
     vsp = vstring+4;
-    if (s_read(&c,1) != 1 || c != '-') return 0;
     i = 0;
     while (1) {
-	if (s_read(&c,1) != 1)
-	    return 0;
+	crReturn(1);		       /* get another char */
 	if (vsp < vstring+sizeof(vstring)-1)
 	    *vsp++ = c;
 	if (i >= 0) {
@@ -1021,6 +894,8 @@ static int do_ssh_init(void) {
 	    break;
     }
 
+    rdpkt2_state.incoming_sequence = 0;
+
     *vsp = 0;
     sprintf(vlog, "Server version: %s", vstring);
     vlog[strcspn(vlog, "\r\n")] = '\0';
@@ -1045,7 +920,7 @@ static int do_ssh_init(void) {
         sprintf(vlog, "We claim version: %s", verstring);
         logevent(vlog);
         logevent("Using SSH protocol version 2");
-        s_write(vstring, strlen(vstring));
+        sk_write(s, vstring, strlen(vstring));
         ssh_protocol = ssh2_protocol;
         ssh_version = 2;
         s_rdpkt = ssh2_rdpkt;
@@ -1059,16 +934,130 @@ static int do_ssh_init(void) {
         vlog[strcspn(vlog, "\r\n")] = '\0';
         logevent(vlog);
         logevent("Using SSH protocol version 1");
-        s_write(vstring, strlen(vstring));
+        sk_write(s, vstring, strlen(vstring));
         ssh_protocol = ssh1_protocol;
         ssh_version = 1;
         s_rdpkt = ssh1_rdpkt;
     }
-    ssh_send_ok = 0;
+
+    crFinish(0);
+}
+
+static void ssh_gotdata(unsigned char *data, int datalen)
+{
+    crBegin;
+
+    /*
+     * To begin with, feed the characters one by one to the
+     * protocol initialisation / selection function do_ssh_init().
+     * When that returns 0, we're done with the initial greeting
+     * exchange and can move on to packet discipline.
+     */
+    while (1) {
+	int ret;
+	if (datalen == 0)
+	    crReturnV;		       /* more data please */
+	ret = do_ssh_init(*data);
+	data++; datalen--;
+	if (ret == 0)
+	    break;
+    }
+
+    /*
+     * We emerge from that loop when the initial negotiation is
+     * over and we have selected an s_rdpkt function. Now pass
+     * everything to s_rdpkt, and then pass the resulting packets
+     * to the proper protocol handler.
+     */
+    if (datalen == 0)
+	crReturnV;
+    while (1) {
+	while (datalen > 0) {
+	    if ( s_rdpkt(&data, &datalen) == 0 ) {
+		ssh_protocol(NULL, 0, 1);
+		if (ssh_state == SSH_STATE_CLOSED) {
+		    return;
+		}
+	    }
+	}
+	crReturnV;
+    }
+    crFinishV;
+}
+
+static int ssh_receive(Socket s, int urgent, char *data, int len) {
+    if (!len) {
+	/* Connection has closed. */
+	sk_close(s);
+	s = NULL;
+	return 0;
+    }
+    ssh_gotdata (data, len);
     return 1;
 }
 
 /*
+ * Connect to specified host and port.
+ * Returns an error message, or NULL on success.
+ * Also places the canonical host name into `realhost'.
+ */
+static char *connect_to_host(char *host, int port, char **realhost)
+{
+    SockAddr addr;
+    char *err;
+#ifdef FWHACK
+    char *FWhost;
+    int FWport;
+#endif
+
+    savedhost = malloc(1+strlen(host));
+    if (!savedhost)
+	fatalbox("Out of memory");
+    strcpy(savedhost, host);
+
+    if (port < 0)
+	port = 22;		       /* default ssh port */
+    savedport = port;
+
+#ifdef FWHACK
+    FWhost = host;
+    FWport = port;
+    host = FWSTR;
+    port = 23;
+#endif
+
+    /*
+     * Try to find host.
+     */
+    addr = sk_namelookup(host, realhost);
+    if ( (err = sk_addr_error(addr)) )
+	return err;
+
+#ifdef FWHACK
+    *realhost = FWhost;
+#endif
+
+    /*
+     * Open socket.
+     */
+    s = sk_new(addr, port, ssh_receive);
+    if ( (err = sk_socket_error(s)) )
+	return err;
+
+#ifdef FWHACK
+    sk_write(s, "connect ", 8);
+    sk_write(s, FWhost, strlen(FWhost));
+    {
+	char buf[20];
+	sprintf(buf, " %d\n", FWport);
+	sk_write(s, buf, strlen(buf));
+    }
+#endif
+
+    return NULL;
+}
+
+/*
  * Handle the key exchange and user authentication phases.
  */
 static int do_ssh1_login(unsigned char *in, int inlen, int ispkt)
@@ -1082,6 +1071,7 @@ static int do_ssh1_login(unsigned char *in, int inlen, int ispkt)
     static int tried_publickey;
     static unsigned char session_id[16];
     int cipher_type;
+    static char username[100];
 
     crBegin;
 
@@ -1100,21 +1090,15 @@ static int do_ssh1_login(unsigned char *in, int inlen, int ispkt)
     j = makekey(pktin.body+8+i, &hostkey, &keystr2, 0);
 
     /*
-     * Hash the host key and print the hash in the log box. Just as
-     * a last resort in case the registry's host key checking is
-     * compromised, we'll allow the user some ability to verify
-     * host keys by eye.
+     * Log the host key fingerprint.
      */
-    MD5Init(&md5c);
-    MD5Update(&md5c, keystr2, hostkey.bytes);
-    MD5Final(session_id, &md5c);
     {
 	char logmsg[80];
-	int i;
-	logevent("Host key MD5 is:");
+	logevent("Host key fingerprint is:");
 	strcpy(logmsg, "      ");
-	for (i = 0; i < 16; i++)
-	    sprintf(logmsg+strlen(logmsg), "%02x", session_id[i]);
+        hostkey.comment = NULL;
+        rsa_fingerprint(logmsg+strlen(logmsg), sizeof(logmsg)-strlen(logmsg),
+                        &hostkey);
 	logevent(logmsg);
     }
 
@@ -1144,11 +1128,13 @@ static int do_ssh1_login(unsigned char *in, int inlen, int ispkt)
          * First format the key into a string.
          */
         int len = rsastr_len(&hostkey);
+        char fingerprint[100];
         char *keystr = malloc(len);
         if (!keystr)
             fatalbox("Out of memory");
         rsastr_fmt(keystr, &hostkey);
-        verify_ssh_host_key(savedhost, keystr);
+        rsa_fingerprint(fingerprint, sizeof(fingerprint), &hostkey);
+        verify_ssh_host_key(savedhost, savedport, "rsa", keystr, fingerprint);
         free(keystr);
     }
 
@@ -1209,7 +1195,6 @@ static int do_ssh1_login(unsigned char *in, int inlen, int ispkt)
 
     fflush(stdout);
     {
-	static char username[100];
 	static int pos = 0;
 	static char c;
 	if ((flags & FLAG_INTERACTIVE) && !*cfg.username) {
@@ -1437,7 +1422,7 @@ static int do_ssh1_login(unsigned char *in, int inlen, int ispkt)
         }
         if (pwpkt_type == SSH1_CMSG_AUTH_PASSWORD) {
             sprintf(prompt, "%.90s@%.90s's password: ",
-                    cfg.username, savedhost);
+                    username, savedhost);
         }
         if (pwpkt_type == SSH1_CMSG_AUTH_RSA) {
             char *comment = NULL;
@@ -1452,7 +1437,7 @@ static int do_ssh1_login(unsigned char *in, int inlen, int ispkt)
             free(comment);
         }
 
-	if (!(flags & FLAG_INTERACTIVE)) {
+	if (ssh_get_password) {
 	    if (!ssh_get_password(prompt, password, sizeof(password))) {
                 /*
                  * get_password failed to get a password (for
@@ -1508,7 +1493,7 @@ static int do_ssh1_login(unsigned char *in, int inlen, int ispkt)
             static unsigned char buffer[32];
 
             tried_publickey = 1;
-            i = loadrsakey(cfg.keyfile, &pubkey, password);
+            i = loadrsakey(cfg.keyfile, &pubkey, NULL, password);
             if (i == 0) {
                 c_write("Couldn't load public key from ", 30);
                 c_write(cfg.keyfile, strlen(cfg.keyfile));
@@ -1651,7 +1636,8 @@ static void ssh1_protocol(unsigned char *in, int inlen, int ispkt) {
 	    if (pktin.type == SSH1_SMSG_STDOUT_DATA ||
                 pktin.type == SSH1_SMSG_STDERR_DATA) {
 		long len = GET_32BIT(pktin.body);
-		c_write(pktin.body+4, len);
+		from_backend(pktin.type == SSH1_SMSG_STDERR_DATA,
+			     pktin.body+4, len);
 	    } else if (pktin.type == SSH1_MSG_DISCONNECT) {
                 ssh_state = SSH_STATE_CLOSED;
 		logevent("Received disconnect request");
@@ -1757,8 +1743,13 @@ static void ssh1_protocol(unsigned char *in, int inlen, int ispkt) {
                 crReturnV;
 	    }
 	} else {
-	    send_packet(SSH1_CMSG_STDIN_DATA,
-	                PKT_INT, inlen, PKT_DATA, in, inlen, PKT_END);
+	    while (inlen > 0) {
+		int len = min(inlen, 512);
+		send_packet(SSH1_CMSG_STDIN_DATA,
+			    PKT_INT, len, PKT_DATA, in, len, PKT_END);
+		in += len;
+		inlen -= len;
+	    }
 	}
     }
 
@@ -1768,7 +1759,7 @@ static void ssh1_protocol(unsigned char *in, int inlen, int ispkt) {
 /*
  * Utility routine for decoding comma-separated strings in KEXINIT.
  */
-int in_commasep_string(char *needle, char *haystack, int haylen) {
+static int in_commasep_string(char *needle, char *haystack, int haylen) {
     int needlen = strlen(needle);
     while (1) {
         /*
@@ -1795,7 +1786,7 @@ int in_commasep_string(char *needle, char *haystack, int haylen) {
 /*
  * SSH2 key creation method.
  */
-void ssh2_mkkey(Bignum K, char *H, char chr, char *keyspace) {
+static void ssh2_mkkey(Bignum K, char *H, char chr, char *keyspace) {
     SHA_State s;
     /* First 20 bytes. */
     SHA_Init(&s);
@@ -1820,16 +1811,19 @@ static int do_ssh2_transport(unsigned char *in, int inlen, int ispkt)
     static int i, len;
     static char *str;
     static Bignum e, f, K;
-    static struct ssh_cipher *cscipher_tobe = NULL;
-    static struct ssh_cipher *sccipher_tobe = NULL;
-    static struct ssh_mac *csmac_tobe = NULL;
-    static struct ssh_mac *scmac_tobe = NULL;
-    static struct ssh_compress *cscomp_tobe = NULL;
-    static struct ssh_compress *sccomp_tobe = NULL;
-    static char *hostkeydata, *sigdata, *keystr;
+    static const struct ssh_mac **maclist;
+    static int nmacs;
+    static const struct ssh_cipher *cscipher_tobe = NULL;
+    static const struct ssh_cipher *sccipher_tobe = NULL;
+    static const struct ssh_mac *csmac_tobe = NULL;
+    static const struct ssh_mac *scmac_tobe = NULL;
+    static const struct ssh_compress *cscomp_tobe = NULL;
+    static const struct ssh_compress *sccomp_tobe = NULL;
+    static char *hostkeydata, *sigdata, *keystr, *fingerprint;
     static int hostkeylen, siglen;
     static unsigned char exchange_hash[20];
     static unsigned char keyspace[40];
+    static const struct ssh_cipher *preferred_cipher;
 
     crBegin;
     random_init();
@@ -1838,17 +1832,25 @@ static int do_ssh2_transport(unsigned char *in, int inlen, int ispkt)
      * Set up the preferred cipher.
      */
     if (cfg.cipher == CIPHER_BLOWFISH) {
-        ciphers[0] = &ssh_blowfish_ssh2;
+        preferred_cipher = &ssh_blowfish_ssh2;
     } else if (cfg.cipher == CIPHER_DES) {
         logevent("Single DES not supported in SSH2; using 3DES");
-        ciphers[0] = &ssh_3des_ssh2;
+        preferred_cipher = &ssh_3des_ssh2;
     } else if (cfg.cipher == CIPHER_3DES) {
-        ciphers[0] = &ssh_3des_ssh2;
+        preferred_cipher = &ssh_3des_ssh2;
     } else {
         /* Shouldn't happen, but we do want to initialise to _something_. */
-        ciphers[0] = &ssh_3des_ssh2;
+        preferred_cipher = &ssh_3des_ssh2;
     }
 
+    /*
+     * Be prepared to work around the buggy MAC problem.
+     */
+    if (cfg.buggymac)
+        maclist = buggymacs, nmacs = lenof(buggymacs);
+    else
+        maclist = macs, nmacs = lenof(macs);
+
     begin_key_exchange:
     /*
      * Construct and send our key exchange packet.
@@ -1872,30 +1874,32 @@ static int do_ssh2_transport(unsigned char *in, int inlen, int ispkt)
     }
     /* List client->server encryption algorithms. */
     ssh2_pkt_addstring_start();
-    for (i = 0; i < lenof(ciphers); i++) {
-        ssh2_pkt_addstring_str(ciphers[i]->name);
-        if (i < lenof(ciphers)-1)
+    for (i = 0; i < lenof(ciphers)+1; i++) {
+        const struct ssh_cipher *c = i==0 ? preferred_cipher : ciphers[i-1];
+        ssh2_pkt_addstring_str(c->name);
+        if (i < lenof(ciphers))
             ssh2_pkt_addstring_str(",");
     }
     /* List server->client encryption algorithms. */
     ssh2_pkt_addstring_start();
-    for (i = 0; i < lenof(ciphers); i++) {
-        ssh2_pkt_addstring_str(ciphers[i]->name);
-        if (i < lenof(ciphers)-1)
+    for (i = 0; i < lenof(ciphers)+1; i++) {
+        const struct ssh_cipher *c = i==0 ? preferred_cipher : ciphers[i-1];
+        ssh2_pkt_addstring_str(c->name);
+        if (i < lenof(ciphers))
             ssh2_pkt_addstring_str(",");
     }
     /* List client->server MAC algorithms. */
     ssh2_pkt_addstring_start();
-    for (i = 0; i < lenof(macs); i++) {
-        ssh2_pkt_addstring_str(macs[i]->name);
-        if (i < lenof(macs)-1)
+    for (i = 0; i < nmacs; i++) {
+        ssh2_pkt_addstring_str(maclist[i]->name);
+        if (i < nmacs-1)
             ssh2_pkt_addstring_str(",");
     }
     /* List server->client MAC algorithms. */
     ssh2_pkt_addstring_start();
-    for (i = 0; i < lenof(macs); i++) {
-        ssh2_pkt_addstring_str(macs[i]->name);
-        if (i < lenof(macs)-1)
+    for (i = 0; i < nmacs; i++) {
+        ssh2_pkt_addstring_str(maclist[i]->name);
+        if (i < nmacs-1)
             ssh2_pkt_addstring_str(",");
     }
     /* List client->server compression algorithms. */
@@ -1952,30 +1956,32 @@ static int do_ssh2_transport(unsigned char *in, int inlen, int ispkt)
         }
     }
     ssh2_pkt_getstring(&str, &len);    /* client->server cipher */
-    for (i = 0; i < lenof(ciphers); i++) {
-        if (in_commasep_string(ciphers[i]->name, str, len)) {
-            cscipher_tobe = ciphers[i];
+    for (i = 0; i < lenof(ciphers)+1; i++) {
+        const struct ssh_cipher *c = i==0 ? preferred_cipher : ciphers[i-1];
+        if (in_commasep_string(c->name, str, len)) {
+            cscipher_tobe = c;
             break;
         }
     }
     ssh2_pkt_getstring(&str, &len);    /* server->client cipher */
-    for (i = 0; i < lenof(ciphers); i++) {
-        if (in_commasep_string(ciphers[i]->name, str, len)) {
-            sccipher_tobe = ciphers[i];
+    for (i = 0; i < lenof(ciphers)+1; i++) {
+        const struct ssh_cipher *c = i==0 ? preferred_cipher : ciphers[i-1];
+        if (in_commasep_string(c->name, str, len)) {
+            sccipher_tobe = c;
             break;
         }
     }
     ssh2_pkt_getstring(&str, &len);    /* client->server mac */
-    for (i = 0; i < lenof(macs); i++) {
-        if (in_commasep_string(macs[i]->name, str, len)) {
-            csmac_tobe = macs[i];
+    for (i = 0; i < nmacs; i++) {
+        if (in_commasep_string(maclist[i]->name, str, len)) {
+            csmac_tobe = maclist[i];
             break;
         }
     }
     ssh2_pkt_getstring(&str, &len);    /* server->client mac */
-    for (i = 0; i < lenof(macs); i++) {
-        if (in_commasep_string(macs[i]->name, str, len)) {
-            scmac_tobe = macs[i];
+    for (i = 0; i < nmacs; i++) {
+        if (in_commasep_string(maclist[i]->name, str, len)) {
+            scmac_tobe = maclist[i];
             break;
         }
     }
@@ -2055,7 +2061,12 @@ static int do_ssh2_transport(unsigned char *in, int inlen, int ispkt)
      * checked the signature of the exchange hash.)
      */
     keystr = hostkey->fmtkey();
-    verify_ssh_host_key(savedhost, keystr);
+    fingerprint = hostkey->fingerprint();
+    verify_ssh_host_key(savedhost, savedport, hostkey->keytype,
+                        keystr, fingerprint);
+    logevent("Host key fingerprint is:");
+    logevent(fingerprint);
+    free(fingerprint);
     free(keystr);
 
     /*
@@ -2180,9 +2191,9 @@ static void do_ssh2_authconn(unsigned char *in, int inlen, int ispkt)
 	    }
 	}
 
-	if (!(flags & FLAG_INTERACTIVE)) {
+	if (ssh_get_password) {
 	    char prompt[200];
-	    sprintf(prompt, "%s@%s's password: ", cfg.username, savedhost);
+	    sprintf(prompt, "%.90s@%.90s's password: ", username, savedhost);
 	    if (!ssh_get_password(prompt, password, sizeof(password))) {
                 /*
                  * get_password failed to get a password (for
@@ -2257,7 +2268,7 @@ static void do_ssh2_authconn(unsigned char *in, int inlen, int ispkt)
     ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN);
     ssh2_pkt_addstring("session");
     ssh2_pkt_adduint32(mainchan->localid);
-    ssh2_pkt_adduint32(0x7FFFFFFFUL);  /* our window size */
+    ssh2_pkt_adduint32(0x8000UL);  /* our window size */
     ssh2_pkt_adduint32(0x4000UL);  /* our max pkt size */
     ssh2_pkt_send();
     crWaitUntilV(ispkt);
@@ -2371,7 +2382,8 @@ static void do_ssh2_authconn(unsigned char *in, int inlen, int ispkt)
                     continue;          /* extended but not stderr */
                 ssh2_pkt_getstring(&data, &length);
                 if (data) {
-                    c_write(data, length);
+                    from_backend(pktin.type == SSH2_MSG_CHANNEL_EXTENDED_DATA,
+				 data, length);
                     /*
                      * Enlarge the window again at the remote side,
                      * just in case it ever runs down and they fail
@@ -2401,6 +2413,9 @@ static void do_ssh2_authconn(unsigned char *in, int inlen, int ispkt)
                     logevent("All channels closed. Disconnecting");
                     ssh2_pkt_init(SSH2_MSG_DISCONNECT);
                     ssh2_pkt_send();
+                    ssh_state = SSH_STATE_CLOSED;
+                    sk_close(s);
+                    s = NULL;
                 }
                 continue;              /* remote sends close; ignore (FIXME) */
 	    } else if (pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST) {
@@ -2468,13 +2483,11 @@ static void ssh2_protocol(unsigned char *in, int inlen, int ispkt)
 }
 
 /*
- * Called to set up the connection. Will arrange for WM_NETEVENT
- * messages to be passed to the specified window, whose window
- * procedure should then call telnet_msg().
+ * Called to set up the connection.
  *
  * Returns an error message, or NULL on success.
  */
-static char *ssh_init (HWND hwnd, char *host, int port, char **realhost) {
+static char *ssh_init (char *host, int port, char **realhost) {
     char *p;
 	
 #ifdef MSCRYPTOAPI
@@ -2482,77 +2495,20 @@ static char *ssh_init (HWND hwnd, char *host, int port, char **realhost) {
 	return "Microsoft high encryption pack not installed!";
 #endif
 
+    ssh_send_ok = 0;
+
     p = connect_to_host(host, port, realhost);
     if (p != NULL)
 	return p;
 
-    if (!do_ssh_init())
-	return "Protocol initialisation error";
-
-    if (hwnd && WSAAsyncSelect (s, hwnd, WM_NETEVENT, FD_READ | FD_CLOSE) == SOCKET_ERROR)
-	switch (WSAGetLastError()) {
-	  case WSAENETDOWN: return "Network is down";
-	  default: return "WSAAsyncSelect(): unknown error";
-	}
-
     return NULL;
 }
 
 /*
- * Process a WM_NETEVENT message. Will return 0 if the connection
- * has closed, or <0 for a socket error.
- */
-static int ssh_msg (WPARAM wParam, LPARAM lParam) {
-    int ret;
-    char buf[256];
-
-    /*
-     * Because reading less than the whole of the available pending
-     * data can generate an FD_READ event, we need to allow for the
-     * possibility that FD_READ may arrive with FD_CLOSE already in
-     * the queue; so it's possible that we can get here even with s
-     * invalid. If so, we return 1 and don't worry about it.
-     */
-    if (s == INVALID_SOCKET)
-	return 1;
-
-    if (WSAGETSELECTERROR(lParam) != 0) {
-        closesocket(s);
-        s = INVALID_SOCKET;
-	return -WSAGETSELECTERROR(lParam);
-    }
-
-    switch (WSAGETSELECTEVENT(lParam)) {
-      case FD_READ:
-      case FD_CLOSE:
-	ret = recv(s, buf, sizeof(buf), 0);
-	if (ret < 0 && WSAGetLastError() == WSAEWOULDBLOCK)
-	    return 1;
-	if (ret < 0) {		       /* any _other_ error */
-            closesocket(s);
-            s = INVALID_SOCKET;
-	    return -10000-WSAGetLastError();
-        }
-	if (ret == 0) {
-	    s = INVALID_SOCKET;
-	    return 0;
-	}
-	ssh_gotdata (buf, ret);
-        if (ssh_state == SSH_STATE_CLOSED) {
-            closesocket(s);
-            s = INVALID_SOCKET;
-            return 0;
-        }
-	return 1;
-    }
-    return 1;			       /* shouldn't happen, but WTF */
-}
-
-/*
  * Called to send data down the Telnet connection.
  */
 static void ssh_send (char *buf, int len) {
-    if (s == INVALID_SOCKET)
+    if (s == NULL)
 	return;
 
     ssh_protocol(buf, len, 0);
@@ -2593,186 +2549,29 @@ static void ssh_special (Telnet_Special code) {
             ssh2_pkt_send();
         }
         logevent("Sent EOF message");
+    } else if (code == TS_PING) {
+        if (ssh_version == 1) {
+            send_packet(SSH1_MSG_IGNORE, PKT_STR, "", PKT_END);
+        } else {
+            ssh2_pkt_init(SSH2_MSG_IGNORE);
+            ssh2_pkt_addstring_start();
+            ssh2_pkt_send();
+        }
     } else {
         /* do nothing */
     }
 }
 
-
-/*
- * Read and decrypt one incoming SSH packet.
- * (only used by pSCP)
- */
-static void get_packet(void)
-{
-    unsigned char buf[4096], *p;
-    long to_read;
-    int len;
-
-    p = NULL;
-    len = 0;
-
-    while ((to_read = s_rdpkt(&p, &len)) > 0) {
-	if (to_read > sizeof(buf)) to_read = sizeof(buf);
-	len = s_read(buf, to_read);
-	if (len != to_read) {
-	    closesocket(s);
-	    s = INVALID_SOCKET;
-	    return;
-	}
-	p = buf;
-    }
-
-    assert(len == 0);
-}
-
-/*
- * Receive a block of data over the SSH link. Block until
- * all data is available. Return nr of bytes read (0 if lost connection).
- * (only used by pSCP)
- */
-int ssh_scp_recv(unsigned char *buf, int len)
-{
-    static int pending_input_len = 0;
-    static unsigned char *pending_input_ptr;
-    int to_read = len;
-
-    if (pending_input_len >= to_read) {
-	memcpy(buf, pending_input_ptr, to_read);
-	pending_input_ptr += to_read;
-	pending_input_len -= to_read;
-	return len;
-    }
-    
-    if (pending_input_len > 0) {
-	memcpy(buf, pending_input_ptr, pending_input_len);
-	buf += pending_input_len;
-	to_read -= pending_input_len;
-	pending_input_len = 0;
-    }
-
-    if (s == INVALID_SOCKET)
-	return 0;
-    while (to_read > 0) {
-	get_packet();
-	if (s == INVALID_SOCKET)
-	    return 0;
-	if (pktin.type == SSH1_SMSG_STDOUT_DATA) {
-	    int plen = GET_32BIT(pktin.body);
-	    if (plen <= to_read) {
-		memcpy(buf, pktin.body + 4, plen);
-		buf += plen;
-		to_read -= plen;
-	    } else {
-		memcpy(buf, pktin.body + 4, to_read);
-		pending_input_len = plen - to_read;
-		pending_input_ptr = pktin.body + 4 + to_read;
-		to_read = 0;
-	    }
-	} else if (pktin.type == SSH1_SMSG_STDERR_DATA) {
-	    int plen = GET_32BIT(pktin.body);
-	    fwrite(pktin.body + 4, plen, 1, stderr);
-	} else if (pktin.type == SSH1_MSG_DISCONNECT) {
-		logevent("Received disconnect request");
-	} else if (pktin.type == SSH1_SMSG_SUCCESS ||
-	           pktin.type == SSH1_SMSG_FAILURE) {
-		/* ignore */
-	} else if (pktin.type == SSH1_SMSG_EXIT_STATUS) {
-	    char logbuf[100];
-	    sprintf(logbuf, "Remote exit status: %d", GET_32BIT(pktin.body));
-	    logevent(logbuf);
-	    send_packet(SSH1_CMSG_EXIT_CONFIRMATION, PKT_END);
-	    logevent("Closing connection");
-	    closesocket(s);
-	    s = INVALID_SOCKET;
-	} else {
-	    bombout(("Strange packet received: type %d", pktin.type));
-            return 0;
-	}
-    }
-
-    return len;
-}
-
-/*
- * Send a block of data over the SSH link.
- * Block until all data is sent.
- * (only used by pSCP)
- */
-void ssh_scp_send(unsigned char *buf, int len)
-{
-    if (s == INVALID_SOCKET)
-	return;
-    send_packet(SSH1_CMSG_STDIN_DATA,
-                PKT_INT, len, PKT_DATA, buf, len, PKT_END);
-}
-
-/*
- * Send an EOF notification to the server.
- * (only used by pSCP)
- */
-void ssh_scp_send_eof(void)
-{
-    if (s == INVALID_SOCKET)
-	return;
-    send_packet(SSH1_CMSG_EOF, PKT_END);
-}
-
-/*
- * Set up the connection, login on the remote host and
- * start execution of a command.
- * Returns an error message, or NULL on success.
- * (only used by pSCP)
- */
-char *ssh_scp_init(char *host, int port, char *cmd, char **realhost)
-{
-    char buf[160], *p;
-
-#ifdef MSCRYPTOAPI
-    if (crypto_startup() == 0)
-	return "Microsoft high encryption pack not installed!";
-#endif
-
-    p = connect_to_host(host, port, realhost);
-    if (p != NULL)
-	return p;
-
-    random_init();
-
-    if (!do_ssh_init())
-	return "Protocol initialisation error";
-
-    /* Exchange keys and login */
-    do {
-	get_packet();
-	if (s == INVALID_SOCKET)
-	    return "Connection closed by remote host";
-    } while (!do_ssh1_login(NULL, 0, 1));
-
-    if (ssh_state == SSH_STATE_CLOSED) {
-        closesocket(s);
-        s = INVALID_SOCKET;
-        return "Session initialisation error";
-    }
-
-    /* Execute command */
-    sprintf(buf, "Sending command: %.100s", cmd);
-    logevent(buf);
-    send_packet(SSH1_CMSG_EXEC_CMD, PKT_STR, cmd, PKT_END);
-
-    return NULL;
-}
-
-static SOCKET ssh_socket(void) { return s; }
+static Socket ssh_socket(void) { return s; }
 
 static int ssh_sendok(void) { return ssh_send_ok; }
 
 Backend ssh_backend = {
     ssh_init,
-    ssh_msg,
     ssh_send,
     ssh_size,
     ssh_special,
     ssh_socket,
-    ssh_sendok
+    ssh_sendok,
+    22
 };