X-Git-Url: https://git.distorted.org.uk/u/mdw/putty/blobdiff_plain/968d2d92c0610def3d66009f8a59120a40892655..79bf227ba7ba02e32ac710621b672e2789f9ef50:/ssh.c

diff --git a/ssh.c b/ssh.c
index eae4cd53..6c94ba49 100644
--- a/ssh.c
+++ b/ssh.c
@@ -163,10 +163,11 @@ static const char *const ssh2_disconnect_reasons[] = {
 #define BUG_SSH2_RSA_PADDING	        	 16
 #define BUG_SSH2_DERIVEKEY                       32
 #define BUG_SSH2_DH_GEX                          64
+#define BUG_SSH2_PK_SESSIONID                   128
 
 #define translate(x) if (type == x) return #x
 #define translatec(x,ctx) if (type == x && (pkt_ctx & ctx)) return #x
-char *ssh1_pkt_type(int type)
+static char *ssh1_pkt_type(int type)
 {
     translate(SSH1_MSG_DISCONNECT);
     translate(SSH1_SMSG_PUBLIC_KEY);
@@ -211,7 +212,7 @@ char *ssh1_pkt_type(int type)
     translate(SSH1_CMSG_AUTH_CCARD_RESPONSE);
     return "unknown";
 }
-char *ssh2_pkt_type(int pkt_ctx, int type)
+static char *ssh2_pkt_type(int pkt_ctx, int type)
 {
     translate(SSH2_MSG_DISCONNECT);
     translate(SSH2_MSG_IGNORE);
@@ -268,11 +269,30 @@ char *ssh2_pkt_type(int pkt_ctx, int type)
 
 enum { PKT_END, PKT_INT, PKT_CHAR, PKT_DATA, PKT_STR, PKT_BIGNUM };
 
-/* Coroutine mechanics for the sillier bits of the code */
+/*
+ * Coroutine mechanics for the sillier bits of the code. If these
+ * macros look impenetrable to you, you might find it helpful to
+ * read
+ * 
+ *   http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html
+ * 
+ * which explains the theory behind these macros.
+ * 
+ * In particular, if you are getting `case expression not constant'
+ * errors when building with MS Visual Studio, this is because MS's
+ * Edit and Continue debugging feature causes their compiler to
+ * violate ANSI C. To disable Edit and Continue debugging:
+ * 
+ *  - right-click ssh.c in the FileView
+ *  - click Settings
+ *  - select the C/C++ tab and the General category
+ *  - under `Debug info:', select anything _other_ than `Program
+ *    Database for Edit and Continue'.
+ */
 #define crBegin(v)	{ int *crLine = &v; switch(v) { case 0:;
 #define crState(t) \
     struct t *s; \
-    if (!ssh->t) ssh->t = smalloc(sizeof(struct t)); \
+    if (!ssh->t) ssh->t = snew(struct t); \
     s = ssh->t;
 #define crFinish(z)	} *crLine = 0; return (z); }
 #define crFinishV	} *crLine = 0; return; }
@@ -291,22 +311,6 @@ enum { PKT_END, PKT_INT, PKT_CHAR, PKT_DATA, PKT_STR, PKT_BIGNUM };
 
 typedef struct ssh_tag *Ssh;
 
-extern char *x11_init(Socket *, char *, void *, void *);
-extern void x11_close(Socket);
-extern int x11_send(Socket, char *, int);
-extern void *x11_invent_auth(char *, int, char *, int);
-extern void x11_unthrottle(Socket s);
-extern void x11_override_throttle(Socket s, int enable);
-
-extern char *pfd_newconnect(Socket * s, char *hostname, int port, void *c);
-extern char *pfd_addforward(char *desthost, int destport, int port,
-			    void *backhandle);
-extern void pfd_close(Socket s);
-extern int pfd_send(Socket s, char *data, int len);
-extern void pfd_confirm(Socket s);
-extern void pfd_unthrottle(Socket s);
-extern void pfd_override_throttle(Socket s, int enable);
-
 static void ssh2_pkt_init(Ssh, int pkt_type);
 static void ssh2_pkt_addbool(Ssh, unsigned char value);
 static void ssh2_pkt_adduint32(Ssh, unsigned long value);
@@ -314,10 +318,12 @@ static void ssh2_pkt_addstring_start(Ssh);
 static void ssh2_pkt_addstring_str(Ssh, char *data);
 static void ssh2_pkt_addstring_data(Ssh, char *data, int len);
 static void ssh2_pkt_addstring(Ssh, char *data);
-static char *ssh2_mpint_fmt(Bignum b, int *len);
+static unsigned char *ssh2_mpint_fmt(Bignum b, int *len);
 static void ssh2_pkt_addmp(Ssh, Bignum b);
 static int ssh2_pkt_construct(Ssh);
 static void ssh2_pkt_send(Ssh);
+static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt);
+static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt);
 
 /*
  * Buffer management constants. There are several of these for
@@ -511,6 +517,7 @@ static void ssh2_add_channel_data(struct ssh_channel *c, char *buf, int len);
 static void ssh_throttle_all(Ssh ssh, int enable, int bufsize);
 static void ssh2_set_window(struct ssh_channel *c, unsigned newwin);
 static int ssh_sendbuffer(void *handle);
+static void ssh_do_close(Ssh ssh);
 
 struct rdpkt1_state_tag {
     long len, pad, biglen, to_read;
@@ -566,6 +573,7 @@ struct ssh_tag {
 
     void *frontend;
 
+    int ospeed, ispeed;		       /* temporaries */
     int term_width, term_height;
 
     tree234 *channels;		       /* indexed by local id */
@@ -636,27 +644,45 @@ struct ssh_tag {
 
     void (*protocol) (Ssh ssh, unsigned char *in, int inlen, int ispkt);
     int (*s_rdpkt) (Ssh ssh, unsigned char **data, int *datalen);
+
+    /*
+     * We maintain a full _copy_ of a Config structure here, not
+     * merely a pointer to it. That way, when we're passed a new
+     * one for reconfiguration, we can check the differences and
+     * potentially reconfigure port forwardings etc in mid-session.
+     */
+    Config cfg;
+
+    /*
+     * Used to transfer data back from async agent callbacks.
+     */
+    void *agent_response;
+    int agent_response_len;
 };
 
-#define logevent(s) { logevent(ssh->frontend, s); \
-                      if ((flags & FLAG_STDERR) && (flags & FLAG_VERBOSE)) \
-                      { fprintf(stderr, "%s\n", s); fflush(stderr); } }
+#define logevent(s) logevent(ssh->frontend, s)
 
 /* logevent, only printf-formatted. */
-void logeventf(Ssh ssh, char *fmt, ...)
+static void logeventf(Ssh ssh, const char *fmt, ...)
 {
     va_list ap;
-    char stuff[200];
+    char *buf;
 
     va_start(ap, fmt);
-    vsprintf(stuff, fmt, ap);
+    buf = dupvprintf(fmt, ap);
     va_end(ap);
-    logevent(stuff);
+    logevent(buf);
+    sfree(buf);
 }
 
-#define bombout(msg) ( ssh->state = SSH_STATE_CLOSED, \
-                          (ssh->s ? sk_close(ssh->s), ssh->s = NULL : 0), \
-                          logeventf msg, connection_fatal msg )
+#define bombout(msg) \
+    do { \
+        char *text = dupprintf msg; \
+	ssh_do_close(ssh); \
+        logevent(text); \
+        connection_fatal(ssh->frontend, "%s", text); \
+        sfree(text); \
+    } while (0)
 
 static int ssh_channelcmp(void *av, void *bv)
 {
@@ -743,7 +769,7 @@ static int alloc_channel_id(Ssh ssh)
     return low + 1 + CHANNEL_NUMBER_OFFSET;
 }
 
-static void c_write(Ssh ssh, char *buf, int len)
+static void c_write(Ssh ssh, const char *buf, int len)
 {
     if ((flags & FLAG_STDERR)) {
 	int i;
@@ -755,7 +781,7 @@ static void c_write(Ssh ssh, char *buf, int len)
     from_backend(ssh->frontend, 1, buf, len);
 }
 
-static void c_write_untrusted(Ssh ssh, char *buf, int len)
+static void c_write_untrusted(Ssh ssh, const char *buf, int len)
 {
     int i;
     for (i = 0; i < len; i++) {
@@ -766,7 +792,7 @@ static void c_write_untrusted(Ssh ssh, char *buf, int len)
     }
 }
 
-static void c_write_str(Ssh ssh, char *buf)
+static void c_write_str(Ssh ssh, const char *buf)
 {
     c_write(ssh, buf, strlen(buf));
 }
@@ -803,7 +829,8 @@ static int ssh1_rdpkt(Ssh ssh, unsigned char **data, int *datalen)
 
     if (ssh->pktin.maxlen < st->biglen) {
 	ssh->pktin.maxlen = st->biglen;
-	ssh->pktin.data = srealloc(ssh->pktin.data, st->biglen + APIEXTRA);
+	ssh->pktin.data = sresize(ssh->pktin.data, st->biglen + APIEXTRA,
+				  unsigned char);
     }
 
     st->to_read = st->biglen;
@@ -823,18 +850,18 @@ static int ssh1_rdpkt(Ssh ssh, unsigned char **data, int *datalen)
 
     if (ssh->cipher && detect_attack(ssh->crcda_ctx, ssh->pktin.data,
 				     st->biglen, NULL)) {
-        bombout((ssh,"Network attack (CRC compensation) detected!"));
-        crReturn(0);
+        bombout(("Network attack (CRC compensation) detected!"));
+        crStop(0);
     }
 
     if (ssh->cipher)
 	ssh->cipher->decrypt(ssh->v1_cipher_ctx, ssh->pktin.data, st->biglen);
 
-    st->realcrc = crc32(ssh->pktin.data, st->biglen - 4);
+    st->realcrc = crc32_compute(ssh->pktin.data, st->biglen - 4);
     st->gotcrc = GET_32BIT(ssh->pktin.data + st->biglen - 4);
     if (st->gotcrc != st->realcrc) {
-	bombout((ssh,"Incorrect CRC received on packet"));
-	crReturn(0);
+	bombout(("Incorrect CRC received on packet"));
+	crStop(0);
     }
 
     ssh->pktin.body = ssh->pktin.data + st->pad + 1;
@@ -842,14 +869,18 @@ static int ssh1_rdpkt(Ssh ssh, unsigned char **data, int *datalen)
     if (ssh->v1_compressing) {
 	unsigned char *decompblk;
 	int decomplen;
-	zlib_decompress_block(ssh->sc_comp_ctx,
-			      ssh->pktin.body - 1, ssh->pktin.length + 1,
-			      &decompblk, &decomplen);
+	if (!zlib_decompress_block(ssh->sc_comp_ctx,
+				   ssh->pktin.body - 1, ssh->pktin.length + 1,
+				   &decompblk, &decomplen)) {
+	    bombout(("Zlib decompression encountered invalid data"));
+	    crStop(0);
+	}
 
 	if (ssh->pktin.maxlen < st->pad + decomplen) {
 	    ssh->pktin.maxlen = st->pad + decomplen;
-	    ssh->pktin.data = srealloc(ssh->pktin.data,
-				       ssh->pktin.maxlen + APIEXTRA);
+	    ssh->pktin.data = sresize(ssh->pktin.data,
+				      ssh->pktin.maxlen + APIEXTRA,
+				      unsigned char);
 	    ssh->pktin.body = ssh->pktin.data + st->pad + 1;
 	}
 
@@ -873,8 +904,8 @@ static int ssh1_rdpkt(Ssh ssh, unsigned char **data, int *datalen)
 	ssh->pktin.type == SSH1_SMSG_AUTH_CCARD_CHALLENGE) {
 	long stringlen = GET_32BIT(ssh->pktin.body);
 	if (stringlen + 4 != ssh->pktin.length) {
-	    bombout((ssh,"Received data packet with bogus string length"));
-	    crReturn(0);
+	    bombout(("Received data packet with bogus string length"));
+	    crStop(0);
 	}
     }
 
@@ -906,8 +937,8 @@ static int ssh1_rdpkt(Ssh ssh, unsigned char **data, int *datalen)
 	memcpy(buf + nowlen, ssh->pktin.body + 4, msglen);
 	buf[nowlen + msglen] = '\0';
 	/* logevent(buf); (this is now done within the bombout macro) */
-	bombout((ssh,"Server sent disconnect message:\n\"%s\"", buf+nowlen));
-	crReturn(0);
+	bombout(("Server sent disconnect message:\n\"%s\"", buf+nowlen));
+	crStop(0);
     }
 
     crFinish(0);
@@ -931,7 +962,8 @@ static int ssh2_rdpkt(Ssh ssh, unsigned char **data, int *datalen)
 
     if (ssh->pktin.maxlen < st->cipherblk) {
 	ssh->pktin.maxlen = st->cipherblk;
-	ssh->pktin.data = srealloc(ssh->pktin.data, st->cipherblk + APIEXTRA);
+	ssh->pktin.data = sresize(ssh->pktin.data, st->cipherblk + APIEXTRA,
+				  unsigned char);
     }
 
     /*
@@ -960,8 +992,8 @@ static int ssh2_rdpkt(Ssh ssh, unsigned char **data, int *datalen)
      * do us any more damage.
      */
     if (st->len < 0 || st->pad < 0 || st->len + st->pad < 0) {
-	bombout((ssh,"Incoming packet was garbled on decryption"));
-	crReturn(0);
+	bombout(("Incoming packet was garbled on decryption"));
+	crStop(0);
     }
 
     /*
@@ -982,8 +1014,9 @@ static int ssh2_rdpkt(Ssh ssh, unsigned char **data, int *datalen)
      */
     if (ssh->pktin.maxlen < st->packetlen + st->maclen) {
 	ssh->pktin.maxlen = st->packetlen + st->maclen;
-	ssh->pktin.data = srealloc(ssh->pktin.data,
-				   ssh->pktin.maxlen + APIEXTRA);
+	ssh->pktin.data = sresize(ssh->pktin.data,
+				  ssh->pktin.maxlen + APIEXTRA,
+				  unsigned char);
     }
 
     /*
@@ -1008,8 +1041,8 @@ static int ssh2_rdpkt(Ssh ssh, unsigned char **data, int *datalen)
     if (ssh->scmac
 	&& !ssh->scmac->verify(ssh->sc_mac_ctx, ssh->pktin.data, st->len + 4,
 			       st->incoming_sequence)) {
-	bombout((ssh,"Incorrect MAC received on packet"));
-	crReturn(0);
+	bombout(("Incorrect MAC received on packet"));
+	crStop(0);
     }
     st->incoming_sequence++;	       /* whether or not we MACed */
 
@@ -1025,8 +1058,9 @@ static int ssh2_rdpkt(Ssh ssh, unsigned char **data, int *datalen)
 				    &newpayload, &newlen)) {
 	    if (ssh->pktin.maxlen < newlen + 5) {
 		ssh->pktin.maxlen = newlen + 5;
-		ssh->pktin.data = srealloc(ssh->pktin.data,
-					   ssh->pktin.maxlen + APIEXTRA);
+		ssh->pktin.data = sresize(ssh->pktin.data,
+					  ssh->pktin.maxlen + APIEXTRA,
+					  unsigned char);
 	    }
 	    ssh->pktin.length = 5 + newlen;
 	    memcpy(ssh->pktin.data + 5, newpayload, newlen);
@@ -1049,31 +1083,30 @@ static int ssh2_rdpkt(Ssh ssh, unsigned char **data, int *datalen)
       case SSH2_MSG_DISCONNECT:
         {
             /* log reason code in disconnect message */
-            char buf[256];
+            char *buf;
+	    int nowlen;
             int reason = GET_32BIT(ssh->pktin.data + 6);
             unsigned msglen = GET_32BIT(ssh->pktin.data + 10);
-            unsigned nowlen;
+
             if (reason > 0 && reason < lenof(ssh2_disconnect_reasons)) {
-                sprintf(buf, "Received disconnect message (%s)",
-                        ssh2_disconnect_reasons[reason]);
+                buf = dupprintf("Received disconnect message (%s)",
+				ssh2_disconnect_reasons[reason]);
             } else {
-                sprintf(buf, "Received disconnect message (unknown type %d)",
-                        reason);
+                buf = dupprintf("Received disconnect message (unknown"
+				" type %d)", reason);
             }
             logevent(buf);
-            strcpy(buf, "Disconnection message text: ");
-            nowlen = strlen(buf);
-            if (msglen > sizeof(buf) - nowlen - 1)
-                msglen = sizeof(buf) - nowlen - 1;
-            memcpy(buf + nowlen, ssh->pktin.data + 14, msglen);
-            buf[nowlen + msglen] = '\0';
+	    sfree(buf);
+            buf = dupprintf("Disconnection message text: %n%.*s",
+			    &nowlen, msglen, ssh->pktin.data + 14);
             logevent(buf);
-            bombout((ssh,"Server sent disconnect message\ntype %d (%s):\n\"%s\"",
+            bombout(("Server sent disconnect message\ntype %d (%s):\n\"%s\"",
                      reason,
                      (reason > 0 && reason < lenof(ssh2_disconnect_reasons)) ?
                      ssh2_disconnect_reasons[reason] : "unknown",
                      buf+nowlen));
-            crReturn(0);
+	    sfree(buf);
+            crStop(0);
         }
         break;
       case SSH2_MSG_IGNORE:
@@ -1160,9 +1193,11 @@ static void ssh1_pktout_size(Ssh ssh, int len)
 #ifdef MSCRYPTOAPI
 	/* Allocate enough buffer space for extra block
 	 * for MS CryptEncrypt() */
-	ssh->pktout.data = srealloc(ssh->pktout.data, biglen + 12);
+	ssh->pktout.data = sresize(ssh->pktout.data, biglen + 12,
+				   unsigned char);
 #else
-	ssh->pktout.data = srealloc(ssh->pktout.data, biglen + 4);
+	ssh->pktout.data = sresize(ssh->pktout.data, biglen + 4,
+				   unsigned char);
 #endif
     }
     ssh->pktout.body = ssh->pktout.data + 4 + pad + 1;
@@ -1176,8 +1211,18 @@ static void s_wrpkt_start(Ssh ssh, int type, int len)
 
 static int s_wrpkt_prepare(Ssh ssh)
 {
-    int pad, len, biglen, i;
+    int pad, biglen, i;
     unsigned long crc;
+#ifdef __SC__
+    /*
+     * XXX various versions of SC (including 8.8.4) screw up the
+     * register allocation in this function and use the same register
+     * (D6) for len and as a temporary, with predictable results.  The
+     * following sledgehammer prevents this.
+     */
+    volatile
+#endif
+    int len;
 
     ssh->pktout.body[-1] = ssh->pktout.type;
 
@@ -1203,7 +1248,7 @@ static int s_wrpkt_prepare(Ssh ssh)
 
     for (i = 0; i < pad; i++)
 	ssh->pktout.data[i + 4] = random_byte();
-    crc = crc32(ssh->pktout.data + 4, biglen - 4);
+    crc = crc32_compute(ssh->pktout.data + 4, biglen - 4);
     PUT_32BIT(ssh->pktout.data + biglen, crc);
     PUT_32BIT(ssh->pktout.data, len);
 
@@ -1217,7 +1262,7 @@ static void s_wrpkt(Ssh ssh)
 {
     int len, backlog;
     len = s_wrpkt_prepare(ssh);
-    backlog = sk_write(ssh->s, ssh->pktout.data, len);
+    backlog = sk_write(ssh->s, (char *)ssh->pktout.data, len);
     if (backlog > SSH_MAX_BACKLOG)
 	ssh_throttle_all(ssh, 1, backlog);
 }
@@ -1228,8 +1273,9 @@ static void s_wrpkt_defer(Ssh ssh)
     len = s_wrpkt_prepare(ssh);
     if (ssh->deferred_len + len > ssh->deferred_size) {
 	ssh->deferred_size = ssh->deferred_len + len + 128;
-	ssh->deferred_send_data = srealloc(ssh->deferred_send_data,
-					   ssh->deferred_size);
+	ssh->deferred_send_data = sresize(ssh->deferred_send_data,
+					  ssh->deferred_size,
+					  unsigned char);
     }
     memcpy(ssh->deferred_send_data + ssh->deferred_len, ssh->pktout.data, len);
     ssh->deferred_len += len;
@@ -1263,7 +1309,7 @@ static void construct_packet(Ssh ssh, int pkttype, va_list ap1, va_list ap2)
 	    break;
 	  case PKT_STR:
 	    argp = va_arg(ap1, unsigned char *);
-	    arglen = strlen(argp);
+	    arglen = strlen((char *)argp);
 	    pktlen += 4 + arglen;
 	    break;
 	  case PKT_BIGNUM:
@@ -1298,7 +1344,7 @@ static void construct_packet(Ssh ssh, int pkttype, va_list ap1, va_list ap2)
 	    break;
 	  case PKT_STR:
 	    argp = va_arg(ap2, unsigned char *);
-	    arglen = strlen(argp);
+	    arglen = strlen((char *)argp);
 	    PUT_32BIT(p, arglen);
 	    memcpy(p + 4, argp, arglen);
 	    p += 4 + arglen;
@@ -1376,8 +1422,9 @@ static void ssh2_pkt_ensure(Ssh ssh, int length)
 {
     if (ssh->pktout.maxlen < length) {
 	ssh->pktout.maxlen = length + 256;
-	ssh->pktout.data = srealloc(ssh->pktout.data,
-				    ssh->pktout.maxlen + APIEXTRA);
+	ssh->pktout.data = sresize(ssh->pktout.data,
+				   ssh->pktout.maxlen + APIEXTRA,
+				   unsigned char);
 	if (!ssh->pktout.data)
 	    fatalbox("Out of memory");
     }
@@ -1429,11 +1476,11 @@ static void ssh2_pkt_addstring(Ssh ssh, char *data)
     ssh2_pkt_addstring_start(ssh);
     ssh2_pkt_addstring_str(ssh, data);
 }
-static char *ssh2_mpint_fmt(Bignum b, int *len)
+static unsigned char *ssh2_mpint_fmt(Bignum b, int *len)
 {
     unsigned char *p;
     int i, n = (bignum_bitcount(b) + 7) / 8;
-    p = smalloc(n + 1);
+    p = snewn(n + 1, unsigned char);
     if (!p)
 	fatalbox("out of memory");
     p[0] = 0;
@@ -1452,7 +1499,7 @@ static void ssh2_pkt_addmp(Ssh ssh, Bignum b)
     int len;
     p = ssh2_mpint_fmt(b, &len);
     ssh2_pkt_addstring_start(ssh);
-    ssh2_pkt_addstring_data(ssh, p, len);
+    ssh2_pkt_addstring_data(ssh, (char *)p, len);
     sfree(p);
 }
 
@@ -1523,7 +1570,7 @@ static void ssh2_pkt_send(Ssh ssh)
     int len;
     int backlog;
     len = ssh2_pkt_construct(ssh);
-    backlog = sk_write(ssh->s, ssh->pktout.data, len);
+    backlog = sk_write(ssh->s, (char *)ssh->pktout.data, len);
     if (backlog > SSH_MAX_BACKLOG)
 	ssh_throttle_all(ssh, 1, backlog);
 }
@@ -1544,8 +1591,9 @@ static void ssh2_pkt_defer(Ssh ssh)
     int len = ssh2_pkt_construct(ssh);
     if (ssh->deferred_len + len > ssh->deferred_size) {
 	ssh->deferred_size = ssh->deferred_len + len + 128;
-	ssh->deferred_send_data = srealloc(ssh->deferred_send_data,
-					   ssh->deferred_size);
+	ssh->deferred_send_data = sresize(ssh->deferred_send_data,
+					  ssh->deferred_size,
+					  unsigned char);
     }
     memcpy(ssh->deferred_send_data + ssh->deferred_len, ssh->pktout.data, len);
     ssh->deferred_len += len;
@@ -1558,7 +1606,8 @@ static void ssh2_pkt_defer(Ssh ssh)
 static void ssh_pkt_defersend(Ssh ssh)
 {
     int backlog;
-    backlog = sk_write(ssh->s, ssh->deferred_send_data, ssh->deferred_len);
+    backlog = sk_write(ssh->s, (char *)ssh->deferred_send_data,
+		       ssh->deferred_len);
     ssh->deferred_len = ssh->deferred_size = 0;
     sfree(ssh->deferred_send_data);
     ssh->deferred_send_data = NULL;
@@ -1612,15 +1661,19 @@ static int ssh2_pkt_getbool(Ssh ssh)
 }
 static void ssh2_pkt_getstring(Ssh ssh, char **p, int *length)
 {
+    int len;
     *p = NULL;
     *length = 0;
     if (ssh->pktin.length - ssh->pktin.savedpos < 4)
 	return;
-    *length = GET_32BIT(ssh->pktin.data + ssh->pktin.savedpos);
+    len = GET_32BIT(ssh->pktin.data + ssh->pktin.savedpos);
+    if (len < 0)
+	return;
+    *length = len;
     ssh->pktin.savedpos += 4;
     if (ssh->pktin.length - ssh->pktin.savedpos < *length)
 	return;
-    *p = ssh->pktin.data + ssh->pktin.savedpos;
+    *p = (char *)(ssh->pktin.data + ssh->pktin.savedpos);
     ssh->pktin.savedpos += *length;
 }
 static Bignum ssh2_pkt_getmp(Ssh ssh)
@@ -1633,10 +1686,10 @@ static Bignum ssh2_pkt_getmp(Ssh ssh)
     if (!p)
 	return NULL;
     if (p[0] & 0x80) {
-	bombout((ssh,"internal error: Can't handle negative mpints"));
+	bombout(("internal error: Can't handle negative mpints"));
 	return NULL;
     }
-    b = bignum_from_bytes(p, length);
+    b = bignum_from_bytes((unsigned char *)p, length);
     return b;
 }
 
@@ -1686,18 +1739,18 @@ static void ssh2_add_sigblob(Ssh ssh, void *pkblob_v, int pkblob_len,
 	if (len != siglen) {
 	    unsigned char newlen[4];
 	    ssh2_pkt_addstring_start(ssh);
-	    ssh2_pkt_addstring_data(ssh, sigblob, pos);
+	    ssh2_pkt_addstring_data(ssh, (char *)sigblob, pos);
 	    /* dmemdump(sigblob, pos); */
 	    pos += 4;		       /* point to start of actual sig */
 	    PUT_32BIT(newlen, len);
-	    ssh2_pkt_addstring_data(ssh, newlen, 4);
+	    ssh2_pkt_addstring_data(ssh, (char *)newlen, 4);
 	    /* dmemdump(newlen, 4); */
 	    newlen[0] = 0;
 	    while (len-- > siglen) {
-		ssh2_pkt_addstring_data(ssh, newlen, 1);
+		ssh2_pkt_addstring_data(ssh, (char *)newlen, 1);
 		/* dmemdump(newlen, 1); */
 	    }
-	    ssh2_pkt_addstring_data(ssh, sigblob+pos, siglen);
+	    ssh2_pkt_addstring_data(ssh, (char *)(sigblob+pos), siglen);
 	    /* dmemdump(sigblob+pos, siglen); */
 	    return;
 	}
@@ -1706,7 +1759,7 @@ static void ssh2_add_sigblob(Ssh ssh, void *pkblob_v, int pkblob_len,
     }
 
     ssh2_pkt_addstring_start(ssh);
-    ssh2_pkt_addstring_data(ssh, sigblob, sigblob_len);
+    ssh2_pkt_addstring_data(ssh, (char *)sigblob, sigblob_len);
 }
 
 /*
@@ -1724,11 +1777,12 @@ static void ssh_detect_bugs(Ssh ssh, char *vstring)
 
     ssh->remote_bugs = 0;
 
-    if (cfg.sshbug_ignore1 == BUG_ON ||
-	(cfg.sshbug_ignore1 == BUG_AUTO &&
+    if (ssh->cfg.sshbug_ignore1 == FORCE_ON ||
+	(ssh->cfg.sshbug_ignore1 == AUTO &&
 	 (!strcmp(imp, "1.2.18") || !strcmp(imp, "1.2.19") ||
 	  !strcmp(imp, "1.2.20") || !strcmp(imp, "1.2.21") ||
-	  !strcmp(imp, "1.2.22") || !strcmp(imp, "Cisco-1.25")))) {
+	  !strcmp(imp, "1.2.22") || !strcmp(imp, "Cisco-1.25") ||
+	  !strcmp(imp, "OSU_1.4alpha3")))) {
 	/*
 	 * These versions don't support SSH1_MSG_IGNORE, so we have
 	 * to use a different defence against password length
@@ -1738,9 +1792,9 @@ static void ssh_detect_bugs(Ssh ssh, char *vstring)
 	logevent("We believe remote version has SSH1 ignore bug");
     }
 
-    if (cfg.sshbug_plainpw1 == BUG_ON ||
-	(cfg.sshbug_plainpw1 == BUG_AUTO &&
-	 (!strcmp(imp, "Cisco-1.25")))) {
+    if (ssh->cfg.sshbug_plainpw1 == FORCE_ON ||
+	(ssh->cfg.sshbug_plainpw1 == AUTO &&
+	 (!strcmp(imp, "Cisco-1.25") || !strcmp(imp, "OSU_1.4alpha3")))) {
 	/*
 	 * These versions need a plain password sent; they can't
 	 * handle having a null and a random length of data after
@@ -1750,8 +1804,8 @@ static void ssh_detect_bugs(Ssh ssh, char *vstring)
 	logevent("We believe remote version needs a plain SSH1 password");
     }
 
-    if (cfg.sshbug_rsa1 == BUG_ON ||
-	(cfg.sshbug_rsa1 == BUG_AUTO &&
+    if (ssh->cfg.sshbug_rsa1 == FORCE_ON ||
+	(ssh->cfg.sshbug_rsa1 == AUTO &&
 	 (!strcmp(imp, "Cisco-1.25")))) {
 	/*
 	 * These versions apparently have no clue whatever about
@@ -1762,11 +1816,12 @@ static void ssh_detect_bugs(Ssh ssh, char *vstring)
 	logevent("We believe remote version can't handle RSA authentication");
     }
 
-    if (cfg.sshbug_hmac2 == BUG_ON ||
-	(cfg.sshbug_hmac2 == BUG_AUTO &&
-	 (!strncmp(imp, "2.1.0", 5) || !strncmp(imp, "2.0.", 4) ||
-	  !strncmp(imp, "2.2.0", 5) || !strncmp(imp, "2.3.0", 5) ||
-	  !strncmp(imp, "2.1 ", 4)))) {
+    if (ssh->cfg.sshbug_hmac2 == FORCE_ON ||
+	(ssh->cfg.sshbug_hmac2 == AUTO &&
+	 !wc_match("* VShell", imp) &&
+	 (wc_match("2.1.0*", imp) || wc_match("2.0.*", imp) ||
+	  wc_match("2.2.0*", imp) || wc_match("2.3.0*", imp) ||
+	  wc_match("2.1 *", imp)))) {
 	/*
 	 * These versions have the HMAC bug.
 	 */
@@ -1774,9 +1829,10 @@ static void ssh_detect_bugs(Ssh ssh, char *vstring)
 	logevent("We believe remote version has SSH2 HMAC bug");
     }
 
-    if (cfg.sshbug_derivekey2 == BUG_ON ||
-	(cfg.sshbug_derivekey2 == BUG_AUTO &&
-	 (!strncmp(imp, "2.0.", 4)))) {
+    if (ssh->cfg.sshbug_derivekey2 == FORCE_ON ||
+	(ssh->cfg.sshbug_derivekey2 == AUTO &&
+	 !wc_match("* VShell", imp) &&
+	 (wc_match("2.0.0*", imp) || wc_match("2.0.10*", imp) ))) {
 	/*
 	 * These versions have the key-derivation bug (failing to
 	 * include the literal shared secret in the hashes that
@@ -1786,10 +1842,10 @@ static void ssh_detect_bugs(Ssh ssh, char *vstring)
 	logevent("We believe remote version has SSH2 key-derivation bug");
     }
 
-    if (cfg.sshbug_rsapad2 == BUG_ON ||
-	(cfg.sshbug_rsapad2 == BUG_AUTO &&
-	 ((!strncmp(imp, "OpenSSH_2.", 10) && imp[10]>='5' && imp[10]<='9') ||
-	  (!strncmp(imp, "OpenSSH_3.", 10) && imp[10]>='0' && imp[10]<='2')))){
+    if (ssh->cfg.sshbug_rsapad2 == FORCE_ON ||
+	(ssh->cfg.sshbug_rsapad2 == AUTO &&
+	 (wc_match("OpenSSH_2.[5-9]*", imp) ||
+	  wc_match("OpenSSH_3.[0-2]*", imp)))) {
 	/*
 	 * These versions have the SSH2 RSA padding bug.
 	 */
@@ -1797,9 +1853,20 @@ static void ssh_detect_bugs(Ssh ssh, char *vstring)
 	logevent("We believe remote version has SSH2 RSA padding bug");
     }
 
-    if (cfg.sshbug_dhgex2 == BUG_ON) {
+    if (ssh->cfg.sshbug_pksessid2 == FORCE_ON ||
+	(ssh->cfg.sshbug_pksessid2 == AUTO &&
+	 wc_match("OpenSSH_2.[0-2]*", imp))) {
+	/*
+	 * These versions have the SSH2 session-ID bug in
+	 * public-key authentication.
+	 */
+	ssh->remote_bugs |= BUG_SSH2_PK_SESSIONID;
+	logevent("We believe remote version has SSH2 public-key-session-ID bug");
+    }
+
+    if (ssh->cfg.sshbug_dhgex2 == FORCE_ON) {
 	/*
-	 * These versions have the SSH2 DH GEX bug.
+	 * User specified the SSH2 DH GEX bug.
 	 */
 	ssh->remote_bugs |= BUG_SSH2_DH_GEX;
 	logevent("We believe remote version has SSH2 DH group exchange bug");
@@ -1840,7 +1907,7 @@ static int do_ssh_init(Ssh ssh, unsigned char c)
     }
 
     s->vstrsize = 16;
-    s->vstring = smalloc(s->vstrsize);
+    s->vstring = snewn(s->vstrsize, char);
     strcpy(s->vstring, "SSH-");
     s->vslen = 4;
     s->i = 0;
@@ -1848,7 +1915,7 @@ static int do_ssh_init(Ssh ssh, unsigned char c)
 	crReturn(1);		       /* get another char */
 	if (s->vslen >= s->vstrsize - 1) {
 	    s->vstrsize += 16;
-	    s->vstring = srealloc(s->vstring, s->vstrsize);
+	    s->vstring = sresize(s->vstring, s->vstrsize, char);
 	}
 	s->vstring[s->vslen++] = c;
 	if (s->i >= 0) {
@@ -1857,7 +1924,7 @@ static int do_ssh_init(Ssh ssh, unsigned char c)
 		s->i = -1;
 	    } else if (s->i < sizeof(s->version) - 1)
 		s->version[s->i++] = c;
-	} else if (c == '\n')
+	} else if (c == '\012')
 	    break;
     }
 
@@ -1868,7 +1935,7 @@ static int do_ssh_init(Ssh ssh, unsigned char c)
     s->vstring[strcspn(s->vstring, "\r\n")] = '\0';/* remove EOL chars */
     {
 	char *vlog;
-	vlog = smalloc(20 + s->vslen);
+	vlog = snewn(20 + s->vslen, char);
 	sprintf(vlog, "Server version: %s", s->vstring);
 	logevent(vlog);
 	sfree(vlog);
@@ -1884,16 +1951,16 @@ static int do_ssh_init(Ssh ssh, unsigned char c)
     /* Anything greater or equal to "1.99" means protocol 2 is supported. */
     s->proto2 = ssh_versioncmp(s->version, "1.99") >= 0;
 
-    if (cfg.sshprot == 0 && !s->proto1) {
-	bombout((ssh,"SSH protocol version 1 required by user but not provided by server"));
-	crReturn(0);
+    if (ssh->cfg.sshprot == 0 && !s->proto1) {
+	bombout(("SSH protocol version 1 required by user but not provided by server"));
+	crStop(0);
     }
-    if (cfg.sshprot == 3 && !s->proto2) {
-	bombout((ssh,"SSH protocol version 2 required by user but not provided by server"));
-	crReturn(0);
+    if (ssh->cfg.sshprot == 3 && !s->proto2) {
+	bombout(("SSH protocol version 2 required by user but not provided by server"));
+	crStop(0);
     }
 
-    if (s->proto2 && (cfg.sshprot >= 2 || !s->proto1)) {
+    if (s->proto2 && (ssh->cfg.sshprot >= 2 || !s->proto1)) {
 	/*
 	 * Use v2 protocol.
 	 */
@@ -1907,7 +1974,7 @@ static int do_ssh_init(Ssh ssh, unsigned char c)
 	sha_string(&ssh->exhashbase, s->vstring, strcspn(s->vstring, "\r\n"));
 	sprintf(vlog, "We claim version: %s", verstring);
 	logevent(vlog);
-	strcat(verstring, "\n");
+	strcat(verstring, "\012");
 	logevent("Using SSH protocol version 2");
 	sk_write(ssh->s, verstring, strlen(verstring));
 	ssh->protocol = ssh2_protocol;
@@ -1923,7 +1990,7 @@ static int do_ssh_init(Ssh ssh, unsigned char c)
 		sshver);
 	sprintf(vlog, "We claim version: %s", verstring);
 	logevent(vlog);
-	strcat(verstring, "\n");
+	strcat(verstring, "\012");
 
 	logevent("Using SSH protocol version 1");
 	sk_write(ssh->s, verstring, strlen(verstring));
@@ -1931,6 +1998,7 @@ static int do_ssh_init(Ssh ssh, unsigned char c)
 	ssh->version = 1;
 	ssh->s_rdpkt = ssh1_rdpkt;
     }
+    update_specials_menu(ssh->frontend);
     ssh->state = SSH_STATE_BEFORE_SIZE;
 
     sfree(s->vstring);
@@ -1984,19 +2052,47 @@ static void ssh_gotdata(Ssh ssh, unsigned char *data, int datalen)
     crFinishV;
 }
 
-static int ssh_closing(Plug plug, char *error_msg, int error_code,
-		       int calling_back)
+static void ssh_do_close(Ssh ssh)
 {
-    Ssh ssh = (Ssh) plug;
+    int i;
+    struct ssh_channel *c;
+
     ssh->state = SSH_STATE_CLOSED;
     if (ssh->s) {
         sk_close(ssh->s);
         ssh->s = NULL;
     }
+    /*
+     * Now we must shut down any port and X forwardings going
+     * through this connection.
+     */
+    if (ssh->channels) {
+	for (i = 0; NULL != (c = index234(ssh->channels, i)); i++) {
+	    switch (c->type) {
+	      case CHAN_X11:
+		x11_close(c->u.x11.s);
+		break;
+	      case CHAN_SOCKDATA:
+		pfd_close(c->u.pfd.s);
+		break;
+	    }
+	    del234(ssh->channels, c);
+	    if (ssh->version == 2)
+		bufchain_clear(&c->v.v2.outbuffer);
+	    sfree(c);
+	}
+    }
+}
+
+static int ssh_closing(Plug plug, const char *error_msg, int error_code,
+		       int calling_back)
+{
+    Ssh ssh = (Ssh) plug;
+    ssh_do_close(ssh);
     if (error_msg) {
 	/* A socket error has occurred. */
 	logevent(error_msg);
-	connection_fatal(ssh->frontend, error_msg);
+	connection_fatal(ssh->frontend, "%s", error_msg);
     } else {
 	/* Otherwise, the remote side closed the connection normally. */
     }
@@ -2006,12 +2102,9 @@ static int ssh_closing(Plug plug, char *error_msg, int error_code,
 static int ssh_receive(Plug plug, int urgent, char *data, int len)
 {
     Ssh ssh = (Ssh) plug;
-    ssh_gotdata(ssh, data, len);
+    ssh_gotdata(ssh, (unsigned char *)data, len);
     if (ssh->state == SSH_STATE_CLOSED) {
-	if (ssh->s) {
-	    sk_close(ssh->s);
-	    ssh->s = NULL;
-	}
+	ssh_do_close(ssh);
 	return 0;
     }
     return 1;
@@ -2034,8 +2127,8 @@ static void ssh_sent(Plug plug, int bufsize)
  * Also places the canonical host name into `realhost'. It must be
  * freed by the caller.
  */
-static char *connect_to_host(Ssh ssh, char *host, int port,
-			     char **realhost, int nodelay)
+static const char *connect_to_host(Ssh ssh, char *host, int port,
+				   char **realhost, int nodelay, int keepalive)
 {
     static const struct plug_function_table fn_table = {
 	ssh_closing,
@@ -2045,9 +2138,9 @@ static char *connect_to_host(Ssh ssh, char *host, int port,
     };
 
     SockAddr addr;
-    char *err;
+    const char *err;
 
-    ssh->savedhost = smalloc(1 + strlen(host));
+    ssh->savedhost = snewn(1 + strlen(host), char);
     if (!ssh->savedhost)
 	fatalbox("Out of memory");
     strcpy(ssh->savedhost, host);
@@ -2059,27 +2152,25 @@ static char *connect_to_host(Ssh ssh, char *host, int port,
     /*
      * Try to find host.
      */
-    {
-	char buf[200];
-	sprintf(buf, "Looking up host \"%.170s\"", host);
-	logevent(buf);
-    }
-    addr = sk_namelookup(host, realhost);
-    if ((err = sk_addr_error(addr)))
+    logeventf(ssh, "Looking up host \"%s\"", host);
+    addr = name_lookup(host, port, realhost, &ssh->cfg);
+    if ((err = sk_addr_error(addr)) != NULL) {
+	sk_addr_free(addr);
 	return err;
+    }
 
     /*
      * Open socket.
      */
     {
-	char buf[200], addrbuf[100];
+	char addrbuf[100];
 	sk_getaddr(addr, addrbuf, 100);
-	sprintf(buf, "Connecting to %.100s port %d", addrbuf, port);
-	logevent(buf);
+	logeventf(ssh, "Connecting to %s port %d", addrbuf, port);
     }
     ssh->fn = &fn_table;
-    ssh->s = new_connection(addr, *realhost, port, 0, 1, nodelay, (Plug) ssh);
-    if ((err = sk_socket_error(ssh->s))) {
+    ssh->s = new_connection(addr, *realhost, port,
+			    0, 1, nodelay, keepalive, (Plug) ssh, &ssh->cfg);
+    if ((err = sk_socket_error(ssh->s)) != NULL) {
 	ssh->s = NULL;
 	return err;
     }
@@ -2131,7 +2222,7 @@ static void ssh_throttle_all(Ssh ssh, int enable, int bufsize)
 	    /* Agent channels require no buffer management. */
 	    break;
 	  case CHAN_SOCKDATA:
-	    pfd_override_throttle(c->u.x11.s, enable);
+	    pfd_override_throttle(c->u.pfd.s, enable);
 	    break;
 	}
     }
@@ -2143,7 +2234,7 @@ static void ssh_throttle_all(Ssh ssh, int enable, int bufsize)
  */
 
 /* Set up a username or password input loop on a given buffer. */
-void setup_userpass_input(Ssh ssh, char *buffer, int buflen, int echo)
+static void setup_userpass_input(Ssh ssh, char *buffer, int buflen, int echo)
 {
     ssh->userpass_input_buffer = buffer;
     ssh->userpass_input_buflen = buflen;
@@ -2157,7 +2248,7 @@ void setup_userpass_input(Ssh ssh, char *buffer, int buflen, int echo)
  * buffer), <0 for failure (user hit ^C/^D, bomb out and exit), 0
  * for inconclusive (keep waiting for more input please).
  */
-int process_userpass_input(Ssh ssh, unsigned char *in, int inlen)
+static int process_userpass_input(Ssh ssh, unsigned char *in, int inlen)
 {
     char c;
 
@@ -2190,7 +2281,13 @@ int process_userpass_input(Ssh ssh, unsigned char *in, int inlen)
 	    return -1;
 	    break;
 	  default:
-	    if (((c >= ' ' && c <= '~') ||
+	    /*
+	     * This simplistic check for printability is disabled
+	     * when we're doing password input, because some people
+	     * have control characters in their passwords.o
+	     */
+	    if ((!ssh->userpass_input_echo ||
+		 (c >= ' ' && c <= '~') ||
 		 ((unsigned char) c >= 160))
 		&& ssh->userpass_input_bufpos < ssh->userpass_input_buflen-1) {
 		ssh->userpass_input_buffer[ssh->userpass_input_bufpos++] = c;
@@ -2203,6 +2300,44 @@ int process_userpass_input(Ssh ssh, unsigned char *in, int inlen)
     return 0;
 }
 
+static void ssh_agent_callback(void *sshv, void *reply, int replylen)
+{
+    Ssh ssh = (Ssh) sshv;
+
+    ssh->agent_response = reply;
+    ssh->agent_response_len = replylen;
+
+    if (ssh->version == 1)
+	do_ssh1_login(ssh, NULL, -1, 0);
+    else
+	do_ssh2_authconn(ssh, NULL, -1, 0);
+}
+
+static void ssh_agentf_callback(void *cv, void *reply, int replylen)
+{
+    struct ssh_channel *c = (struct ssh_channel *)cv;
+    Ssh ssh = c->ssh;
+    void *sentreply = reply;
+
+    if (!sentreply) {
+	/* Fake SSH_AGENT_FAILURE. */
+	sentreply = "\0\0\0\1\5";
+	replylen = 5;
+    }
+    if (ssh->version == 2) {
+	ssh2_add_channel_data(c, sentreply, replylen);
+	ssh2_try_send(c);
+    } else {
+	send_packet(ssh, SSH1_MSG_CHANNEL_DATA,
+		    PKT_INT, c->remoteid,
+		    PKT_INT, replylen,
+		    PKT_DATA, sentreply, replylen,
+		    PKT_END);
+    }
+    if (reply)
+	sfree(reply);
+}
+
 /*
  * Handle the key exchange and user authentication phases.
  */
@@ -2245,8 +2380,8 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	crWaitUntil(ispkt);
 
     if (ssh->pktin.type != SSH1_SMSG_PUBLIC_KEY) {
-	bombout((ssh,"Public key packet not received"));
-	crReturn(0);
+	bombout(("Public key packet not received"));
+	crStop(0);
     }
 
     logevent("Received public keys");
@@ -2288,7 +2423,7 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 
     s->len = (hostkey.bytes > servkey.bytes ? hostkey.bytes : servkey.bytes);
 
-    s->rsabuf = smalloc(s->len);
+    s->rsabuf = snewn(s->len, unsigned char);
     if (!s->rsabuf)
 	fatalbox("Out of memory");
 
@@ -2301,7 +2436,7 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	 */
 	int len = rsastr_len(&hostkey);
 	char fingerprint[100];
-	char *keystr = smalloc(len);
+	char *keystr = snewn(len, char);
 	if (!keystr)
 	    fatalbox("Out of memory");
 	rsastr_fmt(keystr, &hostkey);
@@ -2333,7 +2468,7 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	char *cipher_string = NULL;
 	int i;
 	for (i = 0; !cipher_chosen && i < CIPHER_MAX; i++) {
-	    int next_cipher = cfg.ssh_cipherlist[i];
+	    int next_cipher = ssh->cfg.ssh_cipherlist[i];
 	    if (next_cipher == CIPHER_WARN) {
 		/* If/when we choose a cipher, warn about it */
 		warn = 1;
@@ -2355,12 +2490,12 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	}
 	if (!cipher_chosen) {
 	    if ((s->supported_ciphers_mask & (1 << SSH_CIPHER_3DES)) == 0)
-		bombout((ssh,"Server violates SSH 1 protocol by not "
+		bombout(("Server violates SSH 1 protocol by not "
 			 "supporting 3DES encryption"));
 	    else
 		/* shouldn't happen */
-		bombout((ssh,"No supported ciphers found"));
-	    crReturn(0);
+		bombout(("No supported ciphers found"));
+	    crStop(0);
 	}
 
 	/* Warn about chosen cipher if necessary. */
@@ -2396,27 +2531,39 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		   &ssh_3des);
     ssh->v1_cipher_ctx = ssh->cipher->make_context();
     ssh->cipher->sesskey(ssh->v1_cipher_ctx, ssh->session_key);
-    {
-	char buf[256];
-	sprintf(buf, "Initialised %.200s encryption", ssh->cipher->text_name);
-	logevent(buf);
-    }
+    logeventf(ssh, "Initialised %s encryption", ssh->cipher->text_name);
 
     ssh->crcda_ctx = crcda_make_context();
     logevent("Installing CRC compensation attack detector");
 
+    if (servkey.modulus) {
+	sfree(servkey.modulus);
+	servkey.modulus = NULL;
+    }
+    if (servkey.exponent) {
+	sfree(servkey.exponent);
+	servkey.exponent = NULL;
+    }
+    if (hostkey.modulus) {
+	sfree(hostkey.modulus);
+	hostkey.modulus = NULL;
+    }
+    if (hostkey.exponent) {
+	sfree(hostkey.exponent);
+	hostkey.exponent = NULL;
+    }
     crWaitUntil(ispkt);
 
     if (ssh->pktin.type != SSH1_SMSG_SUCCESS) {
-	bombout((ssh,"Encryption not successfully enabled"));
-	crReturn(0);
+	bombout(("Encryption not successfully enabled"));
+	crStop(0);
     }
 
     logevent("Successfully started encryption");
 
     fflush(stdout);
     {
-	if ((flags & FLAG_INTERACTIVE) && !*cfg.username) {
+	if ((flags & FLAG_INTERACTIVE) && !*ssh->cfg.username) {
 	    if (ssh_get_line && !ssh_getline_pw_only) {
 		if (!ssh_get_line("login as: ",
 				  s->username, sizeof(s->username), FALSE)) {
@@ -2425,8 +2572,8 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		     * Terminate.
 		     */
 		    logevent("No username provided. Abandoning session.");
-		    ssh->state = SSH_STATE_CLOSED;
-		    crReturn(1);
+                    ssh_closing((Plug)ssh, NULL, 0, 0);
+		    crStop(1);
 		}
 	    } else {
 		int ret;	       /* need not be kept over crReturn */
@@ -2443,7 +2590,7 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		c_write_str(ssh, "\r\n");
 	    }
 	} else {
-	    strncpy(s->username, cfg.username, sizeof(s->username));
+	    strncpy(s->username, ssh->cfg.username, sizeof(s->username));
 	    s->username[sizeof(s->username)-1] = '\0';
 	}
 
@@ -2469,10 +2616,10 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	s->tried_publickey = s->tried_agent = 0;
     }
     s->tis_auth_refused = s->ccard_auth_refused = 0;
-    /* Load the public half of cfg.keyfile so we notice if it's in Pageant */
-    if (*cfg.keyfile) {
-	if (!rsakey_pubblob(cfg.keyfile,
-			    &s->publickey_blob, &s->publickey_bloblen))
+    /* Load the public half of ssh->cfg.keyfile so we notice if it's in Pageant */
+    if (!filename_is_null(ssh->cfg.keyfile)) {
+	if (!rsakey_pubblob(&ssh->cfg.keyfile,
+			    &s->publickey_blob, &s->publickey_bloblen, NULL))
 	    s->publickey_blob = NULL;
     } else
 	s->publickey_blob = NULL;
@@ -2493,7 +2640,19 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	    /* Request the keys held by the agent. */
 	    PUT_32BIT(s->request, 1);
 	    s->request[4] = SSH1_AGENTC_REQUEST_RSA_IDENTITIES;
-	    agent_query(s->request, 5, &r, &s->responselen);
+	    if (!agent_query(s->request, 5, &r, &s->responselen,
+			     ssh_agent_callback, ssh)) {
+		do {
+		    crReturn(0);
+		    if (ispkt) {
+			bombout(("Unexpected data from server while waiting"
+				 " for agent response"));
+			crStop(0);
+		    }
+		} while (ispkt || inlen > 0);
+		r = ssh->agent_response;
+		s->responselen = ssh->agent_response_len;
+	    }
 	    s->response = (unsigned char *) r;
 	    if (s->response && s->responselen >= 5 &&
 		s->response[4] == SSH1_AGENT_RSA_IDENTITIES_ANSWER) {
@@ -2522,7 +2681,7 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		    s->p += ssh1_read_bignum(s->p, &s->key.modulus);
 		    s->commentlen = GET_32BIT(s->p);
 		    s->p += 4;
-		    s->commentp = s->p;
+		    s->commentp = (char *)s->p;
 		    s->p += s->commentlen;
 		    send_packet(ssh, SSH1_CMSG_AUTH_RSA,
 				PKT_BIGNUM, s->key.modulus, PKT_END);
@@ -2543,7 +2702,7 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 			len += ssh1_bignum_length(s->challenge);
 			len += 16;     /* session id */
 			len += 4;      /* response format */
-			agentreq = smalloc(4 + len);
+			agentreq = snewn(4 + len, char);
 			PUT_32BIT(agentreq, len);
 			q = agentreq + 4;
 			*q++ = SSH1_AGENTC_RSA_CHALLENGE;
@@ -2555,9 +2714,23 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 			memcpy(q, s->session_id, 16);
 			q += 16;
 			PUT_32BIT(q, 1);	/* response format */
-			agent_query(agentreq, len + 4, &vret, &retlen);
+			if (!agent_query(agentreq, len + 4, &vret, &retlen,
+					 ssh_agent_callback, ssh)) {
+			    sfree(agentreq);
+			    do {
+				crReturn(0);
+				if (ispkt) {
+				    bombout(("Unexpected data from server"
+					     " while waiting for agent"
+					     " response"));
+				    crStop(0);
+				}
+			    } while (ispkt || inlen > 0);
+			    vret = ssh->agent_response;
+			    retlen = ssh->agent_response_len;
+			} else
+			    sfree(agentreq);
 			ret = vret;
-			sfree(agentreq);
 			if (ret) {
 			    if (ret[4] == SSH1_AGENT_RSA_RESPONSE) {
 				logevent("Sending Pageant's response");
@@ -2595,14 +2768,15 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		    if (s->authed)
 			break;
 		}
+		sfree(s->response);
 	    }
 	    if (s->authed)
 		break;
 	}
-	if (*cfg.keyfile && !s->tried_publickey)
+	if (!filename_is_null(ssh->cfg.keyfile) && !s->tried_publickey)
 	    s->pwpkt_type = SSH1_CMSG_AUTH_RSA;
 
-	if (cfg.try_tis_auth &&
+	if (ssh->cfg.try_tis_auth &&
 	    (s->supported_auths_mask & (1 << SSH1_AUTH_TIS)) &&
 	    !s->tis_auth_refused) {
 	    s->pwpkt_type = SSH1_CMSG_AUTH_TIS_RESPONSE;
@@ -2629,7 +2803,7 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		s->prompt[(sizeof s->prompt) - 1] = '\0';
 	    }
 	}
-	if (cfg.try_tis_auth &&
+	if (ssh->cfg.try_tis_auth &&
 	    (s->supported_auths_mask & (1 << SSH1_AUTH_CCARD)) &&
 	    !s->ccard_auth_refused) {
 	    s->pwpkt_type = SSH1_CMSG_AUTH_CCARD_RESPONSE;
@@ -2664,9 +2838,9 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	    char msgbuf[256];
 	    if (flags & FLAG_VERBOSE)
 		c_write_str(ssh, "Trying public key authentication.\r\n");
-	    sprintf(msgbuf, "Trying public key \"%.200s\"", cfg.keyfile);
-	    logevent(msgbuf);
-	    type = key_type(cfg.keyfile);
+	    logeventf(ssh, "Trying public key \"%s\"",
+		      filename_to_str(&ssh->cfg.keyfile));
+	    type = key_type(&ssh->cfg.keyfile);
 	    if (type != SSH_KEYTYPE_SSH1) {
 		sprintf(msgbuf, "Key is of wrong type (%s)",
 			key_type_to_str(type));
@@ -2676,7 +2850,7 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		s->tried_publickey = 1;
 		continue;
 	    }
-	    if (!rsakey_encrypted(cfg.keyfile, &comment)) {
+	    if (!rsakey_encrypted(&ssh->cfg.keyfile, &comment)) {
 		if (flags & FLAG_VERBOSE)
 		    c_write_str(ssh, "No passphrase required.\r\n");
 		goto tryauth;
@@ -2703,8 +2877,8 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 			    PKT_END);
 		logevent("Unable to authenticate");
 		connection_fatal(ssh->frontend, "Unable to authenticate");
-		ssh->state = SSH_STATE_CLOSED;
-		crReturn(1);
+                ssh_closing((Plug)ssh, NULL, 0, 0);
+		crStop(1);
 	    }
 	} else {
 	    /* Prompt may have come from server. We've munged it a bit, so
@@ -2732,11 +2906,15 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	    s->tried_publickey = 1;
 	    
 	    {
-		int ret = loadrsakey(cfg.keyfile, &s->key, s->password);
+		const char *error = NULL;
+		int ret = loadrsakey(&ssh->cfg.keyfile, &s->key, s->password,
+				     &error);
 		if (ret == 0) {
 		    c_write_str(ssh, "Couldn't load private key from ");
-		    c_write_str(ssh, cfg.keyfile);
-		    c_write_str(ssh, ".\r\n");
+		    c_write_str(ssh, filename_to_str(&ssh->cfg.keyfile));
+		    c_write_str(ssh, " (");
+		    c_write_str(ssh, error);
+		    c_write_str(ssh, ").\r\n");
 		    continue;	       /* go and try password */
 		}
 		if (ret == -1) {
@@ -2758,8 +2936,8 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		continue;	       /* go and try password */
 	    }
 	    if (ssh->pktin.type != SSH1_SMSG_AUTH_RSA_CHALLENGE) {
-		bombout((ssh,"Bizarre response to offer of public key"));
-		crReturn(0);
+		bombout(("Bizarre response to offer of public key"));
+		crStop(0);
 	    }
 
 	    {
@@ -2794,8 +2972,8 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 				" our public key.\r\n");
 		continue;	       /* go and try password */
 	    } else if (ssh->pktin.type != SSH1_SMSG_SUCCESS) {
-		bombout((ssh,"Bizarre response to RSA authentication response"));
-		crReturn(0);
+		bombout(("Bizarre response to RSA authentication response"));
+		crStop(0);
 	    }
 
 	    break;		       /* we're through! */
@@ -2858,7 +3036,7 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 
 		    assert(pwlen >= bottom && pwlen <= top);
 
-		    randomstr = smalloc(top + 1);
+		    randomstr = snewn(top + 1, char);
 
 		    for (i = bottom; i <= top; i++) {
 			if (i == pwlen)
@@ -2877,6 +3055,7 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		    }
 		    logevent("Sending password with camouflage packets");
 		    ssh_pkt_defersend(ssh);
+		    sfree(randomstr);
 		} 
 		else if (!(ssh->remote_bugs & BUG_NEEDS_SSH1_PLAIN_PASSWORD)) {
 		    /*
@@ -2927,8 +3106,8 @@ static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		c_write_str(ssh, "Access denied\r\n");
 	    logevent("Authentication refused");
 	} else if (ssh->pktin.type != SSH1_SMSG_SUCCESS) {
-	    bombout((ssh,"Strange packet received, type %d", ssh->pktin.type));
-	    crReturn(0);
+	    bombout(("Strange packet received, type %d", ssh->pktin.type));
+	    crStop(0);
 	}
     }
 
@@ -2941,6 +3120,11 @@ void sshfwd_close(struct ssh_channel *c)
 {
     Ssh ssh = c->ssh;
 
+    if (ssh->state != SSH_STATE_SESSION) {
+	assert(ssh->state == SSH_STATE_CLOSED);
+	return;
+    }
+
     if (c && !c->closes) {
 	/*
 	 * If the channel's remoteid is -1, we have sent
@@ -2975,6 +3159,11 @@ int sshfwd_write(struct ssh_channel *c, char *buf, int len)
 {
     Ssh ssh = c->ssh;
 
+    if (ssh->state != SSH_STATE_SESSION) {
+	assert(ssh->state == SSH_STATE_CLOSED);
+	return 0;
+    }
+
     if (ssh->version == 1) {
 	send_packet(ssh, SSH1_MSG_CHANNEL_DATA,
 		    PKT_INT, c->remoteid,
@@ -2997,6 +3186,11 @@ void sshfwd_unthrottle(struct ssh_channel *c, int bufsize)
 {
     Ssh ssh = c->ssh;
 
+    if (ssh->state != SSH_STATE_SESSION) {
+	assert(ssh->state == SSH_STATE_CLOSED);
+	return;
+    }
+
     if (ssh->version == 1) {
 	if (c->v.v1.throttling && bufsize < SSH1_BUFFER_LIMIT) {
 	    c->v.v1.throttling = 0;
@@ -3019,7 +3213,7 @@ static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen, int ispkt)
     if (ssh->state == SSH_STATE_CLOSED)
 	crReturnV;
 
-    if (cfg.agentfwd && agent_exists()) {
+    if (ssh->cfg.agentfwd && agent_exists()) {
 	logevent("Requesting agent forwarding");
 	send_packet(ssh, SSH1_CMSG_AGENT_REQUEST_FORWARDING, PKT_END);
 	do {
@@ -3027,8 +3221,8 @@ static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	} while (!ispkt);
 	if (ssh->pktin.type != SSH1_SMSG_SUCCESS
 	    && ssh->pktin.type != SSH1_SMSG_FAILURE) {
-	    bombout((ssh,"Protocol confusion"));
-	    crReturnV;
+	    bombout(("Protocol confusion"));
+	    crStopV;
 	} else if (ssh->pktin.type == SSH1_SMSG_FAILURE) {
 	    logevent("Agent forwarding refused");
 	} else {
@@ -3037,15 +3231,17 @@ static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	}
     }
 
-    if (cfg.x11_forward) {
+    if (ssh->cfg.x11_forward) {
 	char proto[20], data[64];
 	logevent("Requesting X11 forwarding");
 	ssh->x11auth = x11_invent_auth(proto, sizeof(proto),
-				       data, sizeof(data));
+				       data, sizeof(data), ssh->cfg.x11_auth);
+        x11_get_real_auth(ssh->x11auth, ssh->cfg.x11_display);
 	if (ssh->v1_local_protoflags & SSH1_PROTOFLAG_SCREEN_NUMBER) {
 	    send_packet(ssh, SSH1_CMSG_X11_REQUEST_FORWARDING,
 			PKT_STR, proto, PKT_STR, data,
-			PKT_INT, 0, PKT_END);
+			PKT_INT, x11_get_screen_number(ssh->cfg.x11_display),
+			PKT_END);
 	} else {
 	    send_packet(ssh, SSH1_CMSG_X11_REQUEST_FORWARDING,
 			PKT_STR, proto, PKT_STR, data, PKT_END);
@@ -3055,8 +3251,8 @@ static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	} while (!ispkt);
 	if (ssh->pktin.type != SSH1_SMSG_SUCCESS
 	    && ssh->pktin.type != SSH1_SMSG_FAILURE) {
-	    bombout((ssh,"Protocol confusion"));
-	    crReturnV;
+	    bombout(("Protocol confusion"));
+	    crStopV;
 	} else if (ssh->pktin.type == SSH1_SMSG_FAILURE) {
 	    logevent("X11 forwarding refused");
 	} else {
@@ -3069,42 +3265,63 @@ static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	char type;
 	int n;
 	int sport,dport,sserv,dserv;
-	char sports[256], dports[256], host[256];
-	char buf[1024];
+	char sports[256], dports[256], saddr[256], host[256];
 
 	ssh->rportfwds = newtree234(ssh_rportcmp_ssh1);
         /* Add port forwardings. */
-	ssh->portfwd_strptr = cfg.portfwd;
+	ssh->portfwd_strptr = ssh->cfg.portfwd;
 	while (*ssh->portfwd_strptr) {
 	    type = *ssh->portfwd_strptr++;
+	    saddr[0] = '\0';
 	    n = 0;
-	    while (*ssh->portfwd_strptr && *ssh->portfwd_strptr != '\t')
-		sports[n++] = *ssh->portfwd_strptr++;
+	    while (*ssh->portfwd_strptr && *ssh->portfwd_strptr != '\t') {
+		if (*ssh->portfwd_strptr == ':') {
+		    /*
+		     * We've seen a colon in the middle of the
+		     * source port number. This means that
+		     * everything we've seen until now is the
+		     * source _address_, so we'll move it into
+		     * saddr and start sports from the beginning
+		     * again.
+		     */
+		    ssh->portfwd_strptr++;
+		    sports[n] = '\0';
+		    strcpy(saddr, sports);
+		    n = 0;
+		}
+		if (n < 255) sports[n++] = *ssh->portfwd_strptr++;
+	    }
 	    sports[n] = 0;
-	    if (*ssh->portfwd_strptr == '\t')
-		ssh->portfwd_strptr++;
-	    n = 0;
-	    while (*ssh->portfwd_strptr && *ssh->portfwd_strptr != ':')
-		host[n++] = *ssh->portfwd_strptr++;
-	    host[n] = 0;
-	    if (*ssh->portfwd_strptr == ':')
+	    if (type != 'D') {
+		if (*ssh->portfwd_strptr == '\t')
+		    ssh->portfwd_strptr++;
+		n = 0;
+		while (*ssh->portfwd_strptr && *ssh->portfwd_strptr != ':') {
+		    if (n < 255) host[n++] = *ssh->portfwd_strptr++;
+		}
+		host[n] = 0;
+		if (*ssh->portfwd_strptr == ':')
+		    ssh->portfwd_strptr++;
+		n = 0;
+		while (*ssh->portfwd_strptr) {
+		    if (n < 255) dports[n++] = *ssh->portfwd_strptr++;
+		}
+		dports[n] = 0;
 		ssh->portfwd_strptr++;
-	    n = 0;
-	    while (*ssh->portfwd_strptr)
-		dports[n++] = *ssh->portfwd_strptr++;
-	    dports[n] = 0;
-	    ssh->portfwd_strptr++;
-	    dport = atoi(dports);
-	    dserv = 0;
-	    if (dport == 0) {
-		dserv = 1;
-		dport = net_service_lookup(dports);
-		if (!dport) {
-		    sprintf(buf,
-			    "Service lookup failed for destination port \"%s\"",
-			    dports);
-		    logevent(buf);
+		dport = atoi(dports);
+		dserv = 0;
+		if (dport == 0) {
+		    dserv = 1;
+		    dport = net_service_lookup(dports);
+		    if (!dport) {
+			logeventf(ssh, "Service lookup failed for"
+				  " destination port \"%s\"", dports);
+		    }
 		}
+	    } else {
+		while (*ssh->portfwd_strptr) ssh->portfwd_strptr++;
+		dport = dserv = -1;
+		ssh->portfwd_strptr++; /* eat the NUL and move to next one */
 	    }
 	    sport = atoi(sports);
 	    sserv = 0;
@@ -3112,43 +3329,55 @@ static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		sserv = 1;
 		sport = net_service_lookup(sports);
 		if (!sport) {
-		    sprintf(buf,
-			    "Service lookup failed for source port \"%s\"",
-			    sports);
-		    logevent(buf);
+		    logeventf(ssh, "Service lookup failed for source"
+			      " port \"%s\"", sports);
 		}
 	    }
 	    if (sport && dport) {
 		if (type == 'L') {
-		    pfd_addforward(host, dport, sport, ssh);
-		    sprintf(buf, "Local port %.*s%.*s%d%.*s forwarding to"
-			    " %s:%.*s%.*s%d%.*s",
-			    (int)(sserv ? strlen(sports) : 0), sports,
-			    sserv, "(", sport, sserv, ")",
-			    host,
-			    (int)(dserv ? strlen(dports) : 0), dports,
-			    dserv, "(", dport, dserv, ")");
-		    logevent(buf);
+		    pfd_addforward(host, dport, *saddr ? saddr : NULL,
+				   sport, ssh, &ssh->cfg);
+		    logeventf(ssh, "Local port %.*s%.*s%.*s%.*s%d%.*s"
+			      " forwarding to %s:%.*s%.*s%d%.*s",
+			      (int)(*saddr?strlen(saddr):0), *saddr?saddr:NULL,
+			      (int)(*saddr?1:0), ":",
+			      (int)(sserv ? strlen(sports) : 0), sports,
+			      sserv, "(", sport, sserv, ")",
+			      host,
+			      (int)(dserv ? strlen(dports) : 0), dports,
+			      dserv, "(", dport, dserv, ")");
+		} else if (type == 'D') {
+		    pfd_addforward(NULL, -1, *saddr ? saddr : NULL,
+				   sport, ssh, &ssh->cfg);
+		    logeventf(ssh, "Local port %.*s%.*s%.*s%.*s%d%.*s"
+			      " doing SOCKS dynamic forwarding",
+			      (int)(*saddr?strlen(saddr):0), *saddr?saddr:NULL,
+			      (int)(*saddr?1:0), ":",
+			      (int)(sserv ? strlen(sports) : 0), sports,
+			      sserv, "(", sport, sserv, ")");
 		} else {
 		    struct ssh_rportfwd *pf;
-		    pf = smalloc(sizeof(*pf));
+		    pf = snew(struct ssh_rportfwd);
 		    strcpy(pf->dhost, host);
 		    pf->dport = dport;
+		    if (saddr) {
+			logeventf(ssh,
+				  "SSH1 cannot handle source address spec \"%s:%d\"; ignoring",
+				  saddr, sport);
+		    }
 		    if (add234(ssh->rportfwds, pf) != pf) {
-			sprintf(buf, 
-				"Duplicate remote port forwarding to %s:%d",
-				host, dport);
-			logevent(buf);
+			logeventf(ssh, 
+				  "Duplicate remote port forwarding to %s:%d",
+				  host, dport);
 			sfree(pf);
 		    } else {
-			sprintf(buf, "Requesting remote port %.*s%.*s%d%.*s"
-				" forward to %s:%.*s%.*s%d%.*s",
-			    (int)(sserv ? strlen(sports) : 0), sports,
-			    sserv, "(", sport, sserv, ")",
-			    host,
-			    (int)(dserv ? strlen(dports) : 0), dports,
-			    dserv, "(", dport, dserv, ")");
-			logevent(buf);
+			logeventf(ssh, "Requesting remote port %.*s%.*s%d%.*s"
+				  " forward to %s:%.*s%.*s%d%.*s",
+				  (int)(sserv ? strlen(sports) : 0), sports,
+				  sserv, "(", sport, sserv, ")",
+				  host,
+				  (int)(dserv ? strlen(dports) : 0), dports,
+				  dserv, "(", dport, dserv, ")");
 			send_packet(ssh, SSH1_CMSG_PORT_FORWARD_REQUEST,
 				    PKT_INT, sport,
 				    PKT_STR, host,
@@ -3159,8 +3388,8 @@ static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 			} while (!ispkt);
 			if (ssh->pktin.type != SSH1_SMSG_SUCCESS
 			    && ssh->pktin.type != SSH1_SMSG_FAILURE) {
-			    bombout((ssh,"Protocol confusion"));
-			    crReturnV;
+			    bombout(("Protocol confusion"));
+			    crStopV;
 			} else if (ssh->pktin.type == SSH1_SMSG_FAILURE) {
 			    c_write_str(ssh, "Server refused port"
 					" forwarding\r\n");
@@ -3172,38 +3401,47 @@ static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	}
     }
 
-    if (!cfg.nopty) {
+    if (!ssh->cfg.nopty) {
+	/* Unpick the terminal-speed string. */
+	/* XXX perhaps we should allow no speeds to be sent. */
+	ssh->ospeed = 38400; ssh->ispeed = 38400; /* last-resort defaults */
+	sscanf(ssh->cfg.termspeed, "%d,%d", &ssh->ospeed, &ssh->ispeed);
+	/* Send the pty request. */
 	send_packet(ssh, SSH1_CMSG_REQUEST_PTY,
-		    PKT_STR, cfg.termtype,
+		    PKT_STR, ssh->cfg.termtype,
 		    PKT_INT, ssh->term_height,
 		    PKT_INT, ssh->term_width,
-		    PKT_INT, 0, PKT_INT, 0, PKT_CHAR, 0, PKT_END);
+		    PKT_INT, 0, PKT_INT, 0, /* width,height in pixels */
+		    PKT_CHAR, 192, PKT_INT, ssh->ispeed, /* TTY_OP_ISPEED */
+		    PKT_CHAR, 193, PKT_INT, ssh->ospeed, /* TTY_OP_OSPEED */
+		    PKT_CHAR, 0, PKT_END);
 	ssh->state = SSH_STATE_INTERMED;
 	do {
 	    crReturnV;
 	} while (!ispkt);
 	if (ssh->pktin.type != SSH1_SMSG_SUCCESS
 	    && ssh->pktin.type != SSH1_SMSG_FAILURE) {
-	    bombout((ssh,"Protocol confusion"));
-	    crReturnV;
+	    bombout(("Protocol confusion"));
+	    crStopV;
 	} else if (ssh->pktin.type == SSH1_SMSG_FAILURE) {
 	    c_write_str(ssh, "Server refused to allocate pty\r\n");
 	    ssh->editing = ssh->echoing = 1;
 	}
-	logevent("Allocated pty");
+	logeventf(ssh, "Allocated pty (ospeed %dbps, ispeed %dbps)",
+		  ssh->ospeed, ssh->ispeed);
     } else {
 	ssh->editing = ssh->echoing = 1;
     }
 
-    if (cfg.compression) {
+    if (ssh->cfg.compression) {
 	send_packet(ssh, SSH1_CMSG_REQUEST_COMPRESSION, PKT_INT, 6, PKT_END);
 	do {
 	    crReturnV;
 	} while (!ispkt);
 	if (ssh->pktin.type != SSH1_SMSG_SUCCESS
 	    && ssh->pktin.type != SSH1_SMSG_FAILURE) {
-	    bombout((ssh,"Protocol confusion"));
-	    crReturnV;
+	    bombout(("Protocol confusion"));
+	    crStopV;
 	} else if (ssh->pktin.type == SSH1_SMSG_FAILURE) {
 	    c_write_str(ssh, "Server refused to compress\r\n");
 	}
@@ -3223,10 +3461,10 @@ static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen, int ispkt)
      * exists, we fall straight back to that.
      */
     {
-	char *cmd = cfg.remote_cmd_ptr;
+	char *cmd = ssh->cfg.remote_cmd_ptr;
 	
-	if (cfg.ssh_subsys && cfg.remote_cmd_ptr2) {
-	    cmd = cfg.remote_cmd_ptr2;
+	if (ssh->cfg.ssh_subsys && ssh->cfg.remote_cmd_ptr2) {
+	    cmd = ssh->cfg.remote_cmd_ptr2;
 	    ssh->fallback_cmd = TRUE;
 	}
 	if (*cmd)
@@ -3255,15 +3493,15 @@ static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		int bufsize =
 		    from_backend(ssh->frontend,
 				 ssh->pktin.type == SSH1_SMSG_STDERR_DATA,
-				 ssh->pktin.body + 4, len);
+				 (char *)(ssh->pktin.body) + 4, len);
 		if (!ssh->v1_stdout_throttling && bufsize > SSH1_BUFFER_LIMIT) {
 		    ssh->v1_stdout_throttling = 1;
 		    ssh1_throttle(ssh, +1);
 		}
 	    } else if (ssh->pktin.type == SSH1_MSG_DISCONNECT) {
-		ssh->state = SSH_STATE_CLOSED;
+                ssh_closing((Plug)ssh, NULL, 0, 0);
 		logevent("Received disconnect request");
-		crReturnV;
+		crStopV;
 	    } else if (ssh->pktin.type == SSH1_SMSG_X11_OPEN) {
 		/* Remote side is trying to open a channel to talk to our
 		 * X-Server. Give them back a local channel number. */
@@ -3276,11 +3514,11 @@ static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 				PKT_INT, GET_32BIT(ssh->pktin.body), PKT_END);
 		    logevent("Rejected X11 connect request");
 		} else {
-		    c = smalloc(sizeof(struct ssh_channel));
+		    c = snew(struct ssh_channel);
 		    c->ssh = ssh;
 
-		    if (x11_init(&c->u.x11.s, cfg.x11_display, c,
-				 ssh->x11auth) != NULL) {
+		    if (x11_init(&c->u.x11.s, ssh->cfg.x11_display, c,
+				 ssh->x11auth, NULL, -1, &ssh->cfg) != NULL) {
 			logevent("opening X11 forward connection failed");
 			sfree(c);
 			send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
@@ -3311,7 +3549,7 @@ static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		    send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
 				PKT_INT, GET_32BIT(ssh->pktin.body), PKT_END);
 		} else {
-		    c = smalloc(sizeof(struct ssh_channel));
+		    c = snew(struct ssh_channel);
 		    c->ssh = ssh;
 		    c->remoteid = GET_32BIT(ssh->pktin.body);
 		    c->localid = alloc_channel_id(ssh);
@@ -3331,12 +3569,14 @@ static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		struct ssh_rportfwd pf;
 		int hostsize, port;
 		char host[256], buf[1024];
-		char *p, *h, *e;
-		c = smalloc(sizeof(struct ssh_channel));
+		char *p, *h;
+		const char *e;
+		c = snew(struct ssh_channel);
 		c->ssh = ssh;
 
 		hostsize = GET_32BIT(ssh->pktin.body+4);
-		for(h = host, p = ssh->pktin.body+8; hostsize != 0; hostsize--) {
+		for (h = host, p = (char *)(ssh->pktin.body+8);
+		     hostsize != 0; hostsize--) {
 		    if (h+1 < host+sizeof(host))
 			*h++ = *p;
 		    p++;
@@ -3357,7 +3597,7 @@ static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		    sprintf(buf, "Received remote port open request for %s:%d",
 			    host, port);
 		    logevent(buf);
-		    e = pfd_newconnect(&c->u.pfd.s, host, port, c);
+		    e = pfd_newconnect(&c->u.pfd.s, host, port, c, &ssh->cfg);
 		    if (e != NULL) {
 			char buf[256];
 			sprintf(buf, "Port open failed: %s", e);
@@ -3452,10 +3692,11 @@ static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 			sfree(c);
 		    }
 		} else {
-		    bombout((ssh,"Received CHANNEL_CLOSE%s for %s channel %d\n",
+		    bombout(("Received CHANNEL_CLOSE%s for %s channel %d\n",
 			     ssh->pktin.type == SSH1_MSG_CHANNEL_CLOSE ? "" :
 			     "_CONFIRMATION", c ? "half-open" : "nonexistent",
 			     i));
+		    crStopV;
 		}
 	    } else if (ssh->pktin.type == SSH1_MSG_CHANNEL_DATA) {
 		/* Data sent down one of our channels. */
@@ -3465,13 +3706,13 @@ static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		struct ssh_channel *c;
 		c = find234(ssh->channels, &i, ssh_channelfind);
 		if (c) {
-		    int bufsize;
+		    int bufsize = 0;
 		    switch (c->type) {
 		      case CHAN_X11:
-			bufsize = x11_send(c->u.x11.s, p, len);
+			bufsize = x11_send(c->u.x11.s, (char *)p, len);
 			break;
 		      case CHAN_SOCKDATA:
-			bufsize = pfd_send(c->u.pfd.s, p, len);
+			bufsize = pfd_send(c->u.pfd.s, (char *)p, len);
 			break;
 		      case CHAN_AGENT:
 			/* Data for an agent message. Buffer it. */
@@ -3487,7 +3728,8 @@ static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 			    if (c->u.a.lensofar == 4) {
 				c->u.a.totallen =
 				    4 + GET_32BIT(c->u.a.msglen);
-				c->u.a.message = smalloc(c->u.a.totallen);
+				c->u.a.message = snewn(c->u.a.totallen,
+						       unsigned char);
 				memcpy(c->u.a.message, c->u.a.msglen, 4);
 			    }
 			    if (c->u.a.lensofar >= 4 && len > 0) {
@@ -3501,25 +3743,13 @@ static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 				c->u.a.lensofar += l;
 			    }
 			    if (c->u.a.lensofar == c->u.a.totallen) {
-				void *reply, *sentreply;
+				void *reply;
 				int replylen;
-				agent_query(c->u.a.message,
-					    c->u.a.totallen, &reply,
-					    &replylen);
-				if (reply)
-				    sentreply = reply;
-				else {
-				    /* Fake SSH_AGENT_FAILURE. */
-				    sentreply = "\0\0\0\1\5";
-				    replylen = 5;
-				}
-				send_packet(ssh, SSH1_MSG_CHANNEL_DATA,
-					    PKT_INT, c->remoteid,
-					    PKT_INT, replylen,
-					    PKT_DATA, sentreply, replylen,
-					    PKT_END);
-				if (reply)
-				    sfree(reply);
+				if (agent_query(c->u.a.message,
+						c->u.a.totallen,
+						&reply, &replylen,
+						ssh_agentf_callback, c))
+				    ssh_agentf_callback(c, reply, replylen);
 				sfree(c->u.a.message);
 				c->u.a.lensofar = 0;
 			    }
@@ -3551,11 +3781,11 @@ static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen, int ispkt)
                  * encrypted packet, we close the session once
                  * we've sent EXIT_CONFIRMATION.
                  */
-                ssh->state = SSH_STATE_CLOSED;
-                crReturnV;
+                ssh_closing((Plug)ssh, NULL, 0, 0);
+                crStopV;
 	    } else {
-		bombout((ssh,"Strange packet received: type %d", ssh->pktin.type));
-		crReturnV;
+		bombout(("Strange packet received: type %d", ssh->pktin.type));
+		crStopV;
 	    }
 	} else {
 	    while (inlen > 0) {
@@ -3576,7 +3806,10 @@ static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen, int ispkt)
  */
 static int in_commasep_string(char *needle, char *haystack, int haylen)
 {
-    int needlen = strlen(needle);
+    int needlen;
+    if (!needle || !haystack)	       /* protect against null pointers */
+	return 0;
+    needlen = strlen(needle);
     while (1) {
 	/*
 	 * Is it at the start of the string?
@@ -3602,8 +3835,9 @@ static int in_commasep_string(char *needle, char *haystack, int haylen)
 /*
  * SSH2 key creation method.
  */
-static void ssh2_mkkey(Ssh ssh, Bignum K, char *H, char *sessid, char chr,
-		       char *keyspace)
+static void ssh2_mkkey(Ssh ssh, Bignum K, unsigned char *H,
+		       unsigned char *sessid, char chr,
+		       unsigned char *keyspace)
 {
     SHA_State s;
     /* First 20 bytes. */
@@ -3667,12 +3901,12 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	 */
 	s->n_preferred_ciphers = 0;
 	for (i = 0; i < CIPHER_MAX; i++) {
-	    switch (cfg.ssh_cipherlist[i]) {
+	    switch (ssh->cfg.ssh_cipherlist[i]) {
 	      case CIPHER_BLOWFISH:
 		s->preferred_ciphers[s->n_preferred_ciphers++] = &ssh2_blowfish;
 		break;
 	      case CIPHER_DES:
-		if (cfg.ssh2_des_cbc) {
+		if (ssh->cfg.ssh2_des_cbc) {
 		    s->preferred_ciphers[s->n_preferred_ciphers++] = &ssh2_des;
 		}
 		break;
@@ -3696,7 +3930,7 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, int ispkt)
     /*
      * Set up preferred compression.
      */
-    if (cfg.compression)
+    if (ssh->cfg.compression)
 	s->preferred_comp = &ssh_zlib;
     else
 	s->preferred_comp = &ssh_comp_none;
@@ -3811,7 +4045,8 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 
     if (!ispkt)
 	crWaitUntil(ispkt);
-    sha_string(&ssh->exhash, ssh->pktin.data + 5, ssh->pktin.length - 5);
+    if (ssh->pktin.length > 5)
+	sha_string(&ssh->exhash, ssh->pktin.data + 5, ssh->pktin.length - 5);
 
     /*
      * Now examine the other side's KEXINIT to see what we're up
@@ -3822,8 +4057,8 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	int i, j, len;
 
 	if (ssh->pktin.type != SSH2_MSG_KEXINIT) {
-	    bombout((ssh,"expected key exchange packet from server"));
-	    crReturn(0);
+	    bombout(("expected key exchange packet from server"));
+	    crStop(0);
 	}
 	ssh->kex = NULL;
 	ssh->hostkey = NULL;
@@ -3872,8 +4107,9 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	    }
 	}
 	if (!s->cscipher_tobe) {
-	    bombout((ssh,"Couldn't agree a client-to-server cipher (available: %s)", str));
-	    crReturn(0);
+	    bombout(("Couldn't agree a client-to-server cipher (available: %s)",
+		     str ? str : "(null)"));
+	    crStop(0);
 	}
 
 	ssh2_pkt_getstring(ssh, &str, &len);    /* server->client cipher */
@@ -3897,8 +4133,9 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	    }
 	}
 	if (!s->sccipher_tobe) {
-	    bombout((ssh,"Couldn't agree a server-to-client cipher (available: %s)", str));
-	    crReturn(0);
+	    bombout(("Couldn't agree a server-to-client cipher (available: %s)",
+		     str ? str : "(null)"));
+	    crStop(0);
 	}
 
 	ssh2_pkt_getstring(ssh, &str, &len);    /* client->server mac */
@@ -3970,8 +4207,8 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 
 	crWaitUntil(ispkt);
 	if (ssh->pktin.type != SSH2_MSG_KEX_DH_GEX_GROUP) {
-	    bombout((ssh,"expected key exchange group packet from server"));
-	    crReturn(0);
+	    bombout(("expected key exchange group packet from server"));
+	    crStop(0);
 	}
 	s->p = ssh2_pkt_getmp(ssh);
 	s->g = ssh2_pkt_getmp(ssh);
@@ -3996,8 +4233,8 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 
     crWaitUntil(ispkt);
     if (ssh->pktin.type != s->kex_reply_value) {
-	bombout((ssh,"expected key exchange reply packet from server"));
-	crReturn(0);
+	bombout(("expected key exchange reply packet from server"));
+	crStop(0);
     }
     ssh2_pkt_getstring(ssh, &s->hostkeydata, &s->hostkeylen);
     s->f = ssh2_pkt_getmp(ssh);
@@ -4017,6 +4254,7 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, int ispkt)
     SHA_Final(&ssh->exhash, s->exchange_hash);
 
     dh_cleanup(ssh->kex_ctx);
+    ssh->kex_ctx = NULL;
 
 #if 0
     debug(("Exchange hash is:\n"));
@@ -4026,9 +4264,9 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, int ispkt)
     s->hkey = ssh->hostkey->newkey(s->hostkeydata, s->hostkeylen);
     if (!s->hkey ||
 	!ssh->hostkey->verifysig(s->hkey, s->sigdata, s->siglen,
-				 s->exchange_hash, 20)) {
-	bombout((ssh,"Server's host key did not match the signature supplied"));
-	crReturn(0);
+				 (char *)s->exchange_hash, 20)) {
+	bombout(("Server's host key did not match the signature supplied"));
+	crStop(0);
     }
 
     /*
@@ -4059,8 +4297,8 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, int ispkt)
      */
     crWaitUntil(ispkt);
     if (ssh->pktin.type != SSH2_MSG_NEWKEYS) {
-	bombout((ssh,"expected new-keys packet from server"));
-	crReturn(0);
+	bombout(("expected new-keys packet from server"));
+	crStop(0);
     }
 
     /*
@@ -4118,27 +4356,23 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	ssh2_mkkey(ssh,s->K,s->exchange_hash,ssh->v2_session_id,'F',keyspace);
 	ssh->scmac->setkey(ssh->sc_mac_ctx, keyspace);
     }
-    {
-	char buf[256];
-	sprintf(buf, "Initialised %.200s client->server encryption",
-		ssh->cscipher->text_name);
-	logevent(buf);
-	sprintf(buf, "Initialised %.200s server->client encryption",
-		ssh->sccipher->text_name);
-	logevent(buf);
-	if (ssh->cscomp->text_name) {
-	    sprintf(buf, "Initialised %.200s compression",
-		    ssh->cscomp->text_name);
-	    logevent(buf);
-	}
-	if (ssh->sccomp->text_name) {
-	    sprintf(buf, "Initialised %.200s decompression",
-		    ssh->sccomp->text_name);
-	    logevent(buf);
-	}
+    logeventf(ssh, "Initialised %.200s client->server encryption",
+	      ssh->cscipher->text_name);
+    logeventf(ssh, "Initialised %.200s server->client encryption",
+	      ssh->sccipher->text_name);
+    if (ssh->cscomp->text_name)
+	logeventf(ssh, "Initialised %s compression",
+		  ssh->cscomp->text_name);
+    if (ssh->sccomp->text_name)
+	logeventf(ssh, "Initialised %s decompression",
+		  ssh->sccomp->text_name);
+    freebn(s->f);
+    freebn(s->K);
+    if (ssh->kex == &ssh_diffiehellman_gex) {
+	freebn(s->g);
+	freebn(s->p);
     }
 
-
     /*
      * If this is the first key exchange phase, we must pass the
      * SSH2_MSG_NEWKEYS packet to the next layer, not because it
@@ -4284,8 +4518,8 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
     ssh2_pkt_send(ssh);
     crWaitUntilV(ispkt);
     if (ssh->pktin.type != SSH2_MSG_SERVICE_ACCEPT) {
-	bombout((ssh,"Server refused user authentication protocol"));
-	crReturnV;
+	bombout(("Server refused user authentication protocol"));
+	crStopV;
     }
 
     /*
@@ -4318,13 +4552,13 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	/*
 	 * Get a username.
 	 */
-	if (s->got_username && !cfg.change_username) {
+	if (s->got_username && !ssh->cfg.change_username) {
 	    /*
 	     * We got a username last time round this loop, and
 	     * with change_username turned off we don't try to get
 	     * it again.
 	     */
-	} else if ((flags & FLAG_INTERACTIVE) && !*cfg.username) {
+	} else if ((flags & FLAG_INTERACTIVE) && !*ssh->cfg.username) {
 	    if (ssh_get_line && !ssh_getline_pw_only) {
 		if (!ssh_get_line("login as: ",
 				  s->username, sizeof(s->username), FALSE)) {
@@ -4333,8 +4567,8 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		     * Terminate.
 		     */
 		    logevent("No username provided. Abandoning session.");
-		    ssh->state = SSH_STATE_CLOSED;
-		    crReturnV;
+                    ssh_closing((Plug)ssh, NULL, 0, 0);
+		    crStopV;
 		}
 	    } else {
 		int ret;	       /* need not be saved across crReturn */
@@ -4351,12 +4585,13 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	    }
 	    s->username[strcspn(s->username, "\n\r")] = '\0';
 	} else {
-	    char stuff[200];
-	    strncpy(s->username, cfg.username, sizeof(s->username));
+	    char *stuff;
+	    strncpy(s->username, ssh->cfg.username, sizeof(s->username));
 	    s->username[sizeof(s->username)-1] = '\0';
 	    if ((flags & FLAG_VERBOSE) || (flags & FLAG_INTERACTIVE)) {
-		sprintf(stuff, "Using username \"%s\".\r\n", s->username);
+		stuff = dupprintf("Using username \"%s\".\r\n", s->username);
 		c_write_str(ssh, stuff);
+		sfree(stuff);
 	    }
 	}
 	s->got_username = TRUE;
@@ -4381,24 +4616,26 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	s->tried_agent = FALSE;
 	s->tried_keyb_inter = FALSE;
 	s->kbd_inter_running = FALSE;
-	/* Load the pub half of cfg.keyfile so we notice if it's in Pageant */
-	if (*cfg.keyfile) {
+	/* Load the pub half of ssh->cfg.keyfile so we notice if it's in Pageant */
+	if (!filename_is_null(ssh->cfg.keyfile)) {
 	    int keytype;
-	    logeventf(ssh->frontend,
-		      "Reading private key file \"%.150s\"", cfg.keyfile);
-	    keytype = key_type(cfg.keyfile);
+	    logeventf(ssh, "Reading private key file \"%.150s\"",
+		      filename_to_str(&ssh->cfg.keyfile));
+	    keytype = key_type(&ssh->cfg.keyfile);
 	    if (keytype == SSH_KEYTYPE_SSH2) {
 		s->publickey_blob =
-		    ssh2_userkey_loadpub(cfg.keyfile, NULL,
-					 &s->publickey_bloblen);
+		    ssh2_userkey_loadpub(&ssh->cfg.keyfile, NULL,
+					 &s->publickey_bloblen, NULL);
 	    } else {
-		char msgbuf[256];
-		logeventf(ssh->frontend,
-			  "Unable to use this key file (%s)",
+		char *msgbuf;
+		logeventf(ssh, "Unable to use this key file (%s)",
 			  key_type_to_str(keytype));
-		sprintf(msgbuf, "Unable to use key file \"%.150s\" (%s)\r\n",
-			cfg.keyfile, key_type_to_str(keytype));
+		msgbuf = dupprintf("Unable to use key file \"%.150s\""
+				   " (%s)\r\n",
+				   filename_to_str(&ssh->cfg.keyfile),
+				   key_type_to_str(keytype));
 		c_write_str(ssh, msgbuf);
+		sfree(msgbuf);
 		s->publickey_blob = NULL;
 	    }
 	} else
@@ -4446,9 +4683,9 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		if (!s->gotit)
 		    s->curr_prompt = 0;
 	    } else if (ssh->pktin.type != SSH2_MSG_USERAUTH_FAILURE) {
-		bombout((ssh,"Strange packet received during authentication: type %d",
+		bombout(("Strange packet received during authentication: type %d",
 			 ssh->pktin.type));
-		crReturnV;
+		crStopV;
 	    }
 
 	    s->gotit = FALSE;
@@ -4511,12 +4748,13 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		    in_commasep_string("publickey", methods, methlen);
 		s->can_passwd =
 		    in_commasep_string("password", methods, methlen);
-		s->can_keyb_inter = cfg.try_ki_auth &&
+		s->can_keyb_inter = ssh->cfg.try_ki_auth &&
 		    in_commasep_string("keyboard-interactive", methods, methlen);
 	    }
 
 	    s->method = 0;
 	    ssh->pkt_ctx &= ~SSH2_PKTCTX_AUTH_MASK;
+	    s->need_pw = FALSE;
 
 	    /*
 	     * Most password/passphrase prompts will be
@@ -4544,7 +4782,19 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		/* Request the keys held by the agent. */
 		PUT_32BIT(s->request, 1);
 		s->request[4] = SSH2_AGENTC_REQUEST_IDENTITIES;
-		agent_query(s->request, 5, &r, &s->responselen);
+		if (!agent_query(s->request, 5, &r, &s->responselen,
+				 ssh_agent_callback, ssh)) {
+		    do {
+			crReturnV;
+			if (ispkt) {
+			    bombout(("Unexpected data from server while"
+				     " waiting for agent response"));
+			    crStopV;
+			}
+		    } while (ispkt || inlen > 0);
+		    r = ssh->agent_response;
+		    s->responselen = ssh->agent_response_len;
+		}
 		s->response = (unsigned char *) r;
 		if (s->response && s->responselen >= 5 &&
 		    s->response[4] == SSH2_AGENT_IDENTITIES_ANSWER) {
@@ -4573,13 +4823,13 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 			    logevent("This key matches configured key file");
 			    s->tried_pubkey_config = 1;
 			}
-			s->pkblob = s->p;
+			s->pkblob = (char *)s->p;
 			s->p += s->pklen;
 			s->alglen = GET_32BIT(s->pkblob);
 			s->alg = s->pkblob + 4;
 			s->commentlen = GET_32BIT(s->p);
 			s->p += 4;
-			s->commentp = s->p;
+			s->commentp = (char *)s->p;
 			s->p += s->commentlen;
 			ssh2_pkt_init(ssh, SSH2_MSG_USERAUTH_REQUEST);
 			ssh2_pkt_addstring(ssh, s->username);
@@ -4620,11 +4870,13 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 			ssh2_pkt_addstring_data(ssh, s->pkblob, s->pklen);
 
 			s->siglen = ssh->pktout.length - 5 + 4 + 20;
+                        if (ssh->remote_bugs & BUG_SSH2_PK_SESSIONID)
+                            s->siglen -= 4;
 			s->len = 1;       /* message type */
 			s->len += 4 + s->pklen;	/* key blob */
 			s->len += 4 + s->siglen;	/* data to sign */
 			s->len += 4;      /* flags */
-			s->agentreq = smalloc(4 + s->len);
+			s->agentreq = snewn(4 + s->len, char);
 			PUT_32BIT(s->agentreq, s->len);
 			s->q = s->agentreq + 4;
 			*s->q++ = SSH2_AGENTC_SIGN_REQUEST;
@@ -4635,8 +4887,10 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 			PUT_32BIT(s->q, s->siglen);
 			s->q += 4;
 			/* Now the data to be signed... */
-			PUT_32BIT(s->q, 20);
-			s->q += 4;
+                        if (!(ssh->remote_bugs & BUG_SSH2_PK_SESSIONID)) {
+                            PUT_32BIT(s->q, 20);
+                            s->q += 4;
+                        }
 			memcpy(s->q, ssh->v2_session_id, 20);
 			s->q += 20;
 			memcpy(s->q, ssh->pktout.data + 5,
@@ -4644,7 +4898,21 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 			s->q += ssh->pktout.length - 5;
 			/* And finally the (zero) flags word. */
 			PUT_32BIT(s->q, 0);
-			agent_query(s->agentreq, s->len + 4, &vret, &s->retlen);
+			if (!agent_query(s->agentreq, s->len + 4,
+					 &vret, &s->retlen,
+					 ssh_agent_callback, ssh)) {
+			    do {
+				crReturnV;
+				if (ispkt) {
+				    bombout(("Unexpected data from server"
+					     " while waiting for agent"
+					     " response"));
+				    crStopV;
+				}
+			    } while (ispkt || inlen > 0);
+			    vret = ssh->agent_response;
+			    s->retlen = ssh->agent_response_len;
+			}
 			s->ret = vret;
 			sfree(s->agentreq);
 			if (s->ret) {
@@ -4666,6 +4934,7 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		    if (s->authed)
 			continue;
 		}
+		sfree(s->response);
 	    }
 
 	    if (!s->method && s->can_pubkey && s->publickey_blob
@@ -4685,8 +4954,11 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		 * First, offer the public blob to see if the server is
 		 * willing to accept it.
 		 */
-		pub_blob = ssh2_userkey_loadpub(cfg.keyfile, &algorithm,
-						&pub_blob_len);
+		pub_blob =
+		    (unsigned char *)ssh2_userkey_loadpub(&ssh->cfg.keyfile,
+							  &algorithm,
+							  &pub_blob_len,
+							  NULL);
 		if (pub_blob) {
 		    ssh2_pkt_init(ssh, SSH2_MSG_USERAUTH_REQUEST);
 		    ssh2_pkt_addstring(ssh, s->username);
@@ -4695,7 +4967,8 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		    ssh2_pkt_addbool(ssh, FALSE);	/* no signature included */
 		    ssh2_pkt_addstring(ssh, algorithm);
 		    ssh2_pkt_addstring_start(ssh);
-		    ssh2_pkt_addstring_data(ssh, pub_blob, pub_blob_len);
+		    ssh2_pkt_addstring_data(ssh, (char *)pub_blob,
+					    pub_blob_len);
 		    ssh2_pkt_send(ssh);
 		    logevent("Offered public key");	/* FIXME */
 
@@ -4711,7 +4984,7 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		     * Actually attempt a serious authentication using
 		     * the key.
 		     */
-		    if (ssh2_userkey_encrypted(cfg.keyfile, &comment)) {
+		    if (ssh2_userkey_encrypted(&ssh->cfg.keyfile, &comment)) {
 			sprintf(s->pwprompt,
 				"Passphrase for key \"%.100s\": ",
 				comment);
@@ -4719,9 +4992,11 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		    } else {
 			s->need_pw = FALSE;
 		    }
-		    c_write_str(ssh, "Authenticating with public key \"");
-		    c_write_str(ssh, comment);
-		    c_write_str(ssh, "\"\r\n");
+		    if (flags & FLAG_VERBOSE) {
+			c_write_str(ssh, "Authenticating with public key \"");
+			c_write_str(ssh, comment);
+			c_write_str(ssh, "\"\r\n");
+		    }
 		    s->method = AUTH_PUBLICKEY_FILE;
 		}
 	    }
@@ -4837,8 +5112,8 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 			logevent("Unable to authenticate");
 			connection_fatal(ssh->frontend,
 					 "Unable to authenticate");
-			ssh->state = SSH_STATE_CLOSED;
-			crReturnV;
+                        ssh_closing((Plug)ssh, NULL, 0, 0);
+			crStopV;
 		    }
 		} else {
 		    int ret;	       /* need not be saved across crReturn */
@@ -4862,14 +5137,18 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		 * We have our passphrase. Now try the actual authentication.
 		 */
 		struct ssh2_userkey *key;
+		const char *error = NULL;
 
-		key = ssh2_load_userkey(cfg.keyfile, s->password);
+		key = ssh2_load_userkey(&ssh->cfg.keyfile, s->password,
+					&error);
 		if (key == SSH2_WRONG_PASSPHRASE || key == NULL) {
 		    if (key == SSH2_WRONG_PASSPHRASE) {
 			c_write_str(ssh, "Wrong passphrase\r\n");
 			s->tried_pubkey_config = FALSE;
 		    } else {
-			c_write_str(ssh, "Unable to load private key\r\n");
+			c_write_str(ssh, "Unable to load private key (");
+			c_write_str(ssh, error);
+			c_write_str(ssh, ")\r\n");
 			s->tried_pubkey_config = TRUE;
 		    }
 		    /* Send a spurious AUTH_NONE to return to the top. */
@@ -4882,6 +5161,7 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		} else {
 		    unsigned char *pkblob, *sigblob, *sigdata;
 		    int pkblob_len, sigblob_len, sigdata_len;
+                    int p;
 
 		    /*
 		     * We have loaded the private key and the server
@@ -4896,7 +5176,7 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		    ssh2_pkt_addstring(ssh, key->alg->name);
 		    pkblob = key->alg->public_blob(key->data, &pkblob_len);
 		    ssh2_pkt_addstring_start(ssh);
-		    ssh2_pkt_addstring_data(ssh, pkblob, pkblob_len);
+		    ssh2_pkt_addstring_data(ssh, (char *)pkblob, pkblob_len);
 
 		    /*
 		     * The data to be signed is:
@@ -4907,12 +5187,20 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		     * outgoing packet.
 		     */
 		    sigdata_len = ssh->pktout.length - 5 + 4 + 20;
-		    sigdata = smalloc(sigdata_len);
-		    PUT_32BIT(sigdata, 20);
-		    memcpy(sigdata + 4, ssh->v2_session_id, 20);
-		    memcpy(sigdata + 24, ssh->pktout.data + 5,
+                    if (ssh->remote_bugs & BUG_SSH2_PK_SESSIONID)
+                        sigdata_len -= 4;
+		    sigdata = snewn(sigdata_len, unsigned char);
+                    p = 0;
+                    if (!(ssh->remote_bugs & BUG_SSH2_PK_SESSIONID)) {
+                        PUT_32BIT(sigdata+p, 20);
+                        p += 4;
+                    }
+		    memcpy(sigdata+p, ssh->v2_session_id, 20); p += 20;
+		    memcpy(sigdata+p, ssh->pktout.data + 5,
 			   ssh->pktout.length - 5);
-		    sigblob = key->alg->sign(key->data, sigdata,
+                    p += ssh->pktout.length - 5;
+                    assert(p == sigdata_len);
+		    sigblob = key->alg->sign(key->data, (char *)sigdata,
 					     sigdata_len, &sigblob_len);
 		    ssh2_add_sigblob(ssh, pkblob, pkblob_len,
 				     sigblob, sigblob_len);
@@ -4922,6 +5210,7 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 
 		    ssh2_pkt_send(ssh);
 		    s->type = AUTH_TYPE_PUBLICKEY;
+		    key->alg->freekey(key->data);
 		}
 	    } else if (s->method == AUTH_PASSWORD) {
 		/*
@@ -4944,6 +5233,7 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		ssh2_pkt_addstring(ssh, "password");
 		ssh2_pkt_addbool(ssh, FALSE);
 		ssh2_pkt_addstring(ssh, s->password);
+		memset(s->password, 0, sizeof(s->password));
 		ssh2_pkt_defer(ssh);
 		/*
 		 * We'll include a string that's an exact multiple of the
@@ -5016,8 +5306,8 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 				   " methods available");
 		ssh2_pkt_addstring(ssh, "en");	/* language tag */
 		ssh2_pkt_send(ssh);
-		ssh->state = SSH_STATE_CLOSED;
-		crReturnV;
+                ssh_closing((Plug)ssh, NULL, 0, 0);
+		crStopV;
 	    }
 	}
     } while (!s->we_are_in);
@@ -5032,7 +5322,7 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
      * So now create a channel with a session in it.
      */
     ssh->channels = newtree234(ssh_channelcmp);
-    ssh->mainchan = smalloc(sizeof(struct ssh_channel));
+    ssh->mainchan = snew(struct ssh_channel);
     ssh->mainchan->ssh = ssh;
     ssh->mainchan->localid = alloc_channel_id(ssh);
     ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_OPEN);
@@ -5044,13 +5334,13 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
     ssh2_pkt_send(ssh);
     crWaitUntilV(ispkt);
     if (ssh->pktin.type != SSH2_MSG_CHANNEL_OPEN_CONFIRMATION) {
-	bombout((ssh,"Server refused to open a session"));
-	crReturnV;
+	bombout(("Server refused to open a session"));
+	crStopV;
 	/* FIXME: error data comes back in FAILURE packet */
     }
     if (ssh2_pkt_getuint32(ssh) != ssh->mainchan->localid) {
-	bombout((ssh,"Server's channel confirmation cited wrong channel"));
-	crReturnV;
+	bombout(("Server's channel confirmation cited wrong channel"));
+	crStopV;
     }
     ssh->mainchan->remoteid = ssh2_pkt_getuint32(ssh);
     ssh->mainchan->type = CHAN_MAINSESSION;
@@ -5064,11 +5354,12 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
     /*
      * Potentially enable X11 forwarding.
      */
-    if (cfg.x11_forward) {
+    if (ssh->cfg.x11_forward) {
 	char proto[20], data[64];
 	logevent("Requesting X11 forwarding");
 	ssh->x11auth = x11_invent_auth(proto, sizeof(proto),
-				       data, sizeof(data));
+				       data, sizeof(data), ssh->cfg.x11_auth);
+        x11_get_real_auth(ssh->x11auth, ssh->cfg.x11_display);
 	ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_REQUEST);
 	ssh2_pkt_adduint32(ssh, ssh->mainchan->remoteid);
 	ssh2_pkt_addstring(ssh, "x11-req");
@@ -5076,7 +5367,7 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	ssh2_pkt_addbool(ssh, 0);	       /* many connections */
 	ssh2_pkt_addstring(ssh, proto);
 	ssh2_pkt_addstring(ssh, data);
-	ssh2_pkt_adduint32(ssh, 0);	       /* screen number */
+	ssh2_pkt_adduint32(ssh, x11_get_screen_number(ssh->cfg.x11_display));
 	ssh2_pkt_send(ssh);
 
 	do {
@@ -5093,9 +5384,9 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 
 	if (ssh->pktin.type != SSH2_MSG_CHANNEL_SUCCESS) {
 	    if (ssh->pktin.type != SSH2_MSG_CHANNEL_FAILURE) {
-		bombout((ssh,"Unexpected response to X11 forwarding request:"
+		bombout(("Unexpected response to X11 forwarding request:"
 			 " packet type %d", ssh->pktin.type));
-		crReturnV;
+		crStopV;
 	    }
 	    logevent("X11 forwarding refused");
 	} else {
@@ -5111,42 +5402,63 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	char type;
 	int n;
 	int sport,dport,sserv,dserv;
-	char sports[256], dports[256], host[256];
-	char buf[1024];
+	char sports[256], dports[256], saddr[256], host[256];
 
 	ssh->rportfwds = newtree234(ssh_rportcmp_ssh2);
         /* Add port forwardings. */
-	ssh->portfwd_strptr = cfg.portfwd;
+	ssh->portfwd_strptr = ssh->cfg.portfwd;
 	while (*ssh->portfwd_strptr) {
 	    type = *ssh->portfwd_strptr++;
+	    saddr[0] = '\0';
 	    n = 0;
-	    while (*ssh->portfwd_strptr && *ssh->portfwd_strptr != '\t')
-		sports[n++] = *ssh->portfwd_strptr++;
+	    while (*ssh->portfwd_strptr && *ssh->portfwd_strptr != '\t') {
+		if (*ssh->portfwd_strptr == ':') {
+		    /*
+		     * We've seen a colon in the middle of the
+		     * source port number. This means that
+		     * everything we've seen until now is the
+		     * source _address_, so we'll move it into
+		     * saddr and start sports from the beginning
+		     * again.
+		     */
+		    ssh->portfwd_strptr++;
+		    sports[n] = '\0';
+		    strcpy(saddr, sports);
+		    n = 0;
+		}
+		if (n < 255) sports[n++] = *ssh->portfwd_strptr++;
+	    }
 	    sports[n] = 0;
-	    if (*ssh->portfwd_strptr == '\t')
-		ssh->portfwd_strptr++;
-	    n = 0;
-	    while (*ssh->portfwd_strptr && *ssh->portfwd_strptr != ':')
-		host[n++] = *ssh->portfwd_strptr++;
-	    host[n] = 0;
-	    if (*ssh->portfwd_strptr == ':')
+	    if (type != 'D') {
+		if (*ssh->portfwd_strptr == '\t')
+		    ssh->portfwd_strptr++;
+		n = 0;
+		while (*ssh->portfwd_strptr && *ssh->portfwd_strptr != ':') {
+		    if (n < 255) host[n++] = *ssh->portfwd_strptr++;
+		}
+		host[n] = 0;
+		if (*ssh->portfwd_strptr == ':')
+		    ssh->portfwd_strptr++;
+		n = 0;
+		while (*ssh->portfwd_strptr) {
+		    if (n < 255) dports[n++] = *ssh->portfwd_strptr++;
+		}
+		dports[n] = 0;
 		ssh->portfwd_strptr++;
-	    n = 0;
-	    while (*ssh->portfwd_strptr)
-		dports[n++] = *ssh->portfwd_strptr++;
-	    dports[n] = 0;
-	    ssh->portfwd_strptr++;
-	    dport = atoi(dports);
-	    dserv = 0;
-	    if (dport == 0) {
-		dserv = 1;
-		dport = net_service_lookup(dports);
-		if (!dport) {
-		    sprintf(buf,
-			    "Service lookup failed for destination port \"%s\"",
-			    dports);
-		    logevent(buf);
+		dport = atoi(dports);
+		dserv = 0;
+		if (dport == 0) {
+		    dserv = 1;
+		    dport = net_service_lookup(dports);
+		    if (!dport) {
+			logeventf(ssh, "Service lookup failed for destination"
+				  " port \"%s\"", dports);
+		    }
 		}
+	    } else {
+		while (*ssh->portfwd_strptr) ssh->portfwd_strptr++;
+		dport = dserv = -1;
+		ssh->portfwd_strptr++; /* eat the NUL and move to next one */
 	    }
 	    sport = atoi(sports);
 	    sserv = 0;
@@ -5154,48 +5466,60 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		sserv = 1;
 		sport = net_service_lookup(sports);
 		if (!sport) {
-		    sprintf(buf,
-			    "Service lookup failed for source port \"%s\"",
-			    sports);
-		    logevent(buf);
+		    logeventf(ssh, "Service lookup failed for source"
+			      " port \"%s\"", sports);
 		}
 	    }
 	    if (sport && dport) {
 		if (type == 'L') {
-		    pfd_addforward(host, dport, sport, ssh);
-		    sprintf(buf, "Local port %.*s%.*s%d%.*s forwarding to"
-			    " %s:%.*s%.*s%d%.*s",
-			    (int)(sserv ? strlen(sports) : 0), sports,
-			    sserv, "(", sport, sserv, ")",
-			    host,
-			    (int)(dserv ? strlen(dports) : 0), dports,
-			    dserv, "(", dport, dserv, ")");
-		    logevent(buf);
+		    pfd_addforward(host, dport, *saddr ? saddr : NULL,
+				   sport, ssh, &ssh->cfg);
+		    logeventf(ssh, "Local port %.*s%.*s%.*s%.*s%d%.*s"
+			      " forwarding to %s:%.*s%.*s%d%.*s",
+			      (int)(*saddr?strlen(saddr):0), *saddr?saddr:NULL,
+			      (int)(*saddr?1:0), ":",
+			      (int)(sserv ? strlen(sports) : 0), sports,
+			      sserv, "(", sport, sserv, ")",
+			      host,
+			      (int)(dserv ? strlen(dports) : 0), dports,
+			      dserv, "(", dport, dserv, ")");
+		} else if (type == 'D') {
+		    pfd_addforward(NULL, -1, *saddr ? saddr : NULL,
+				   sport, ssh, &ssh->cfg);
+		    logeventf(ssh, "Local port %.*s%.*s%.*s%.*s%d%.*s"
+			      " doing SOCKS dynamic forwarding",
+			      (int)(*saddr?strlen(saddr):0), *saddr?saddr:NULL,
+			      (int)(*saddr?1:0), ":",
+			      (int)(sserv ? strlen(sports) : 0), sports,
+			      sserv, "(", sport, sserv, ")");
 		} else {
 		    struct ssh_rportfwd *pf;
-		    pf = smalloc(sizeof(*pf));
+		    pf = snew(struct ssh_rportfwd);
 		    strcpy(pf->dhost, host);
 		    pf->dport = dport;
 		    pf->sport = sport;
 		    if (add234(ssh->rportfwds, pf) != pf) {
-			sprintf(buf, 
-				"Duplicate remote port forwarding to %s:%d",
-				host, dport);
-			logevent(buf);
+			logeventf(ssh, "Duplicate remote port forwarding"
+				  " to %s:%d", host, dport);
 			sfree(pf);
 		    } else {
-			sprintf(buf, "Requesting remote port %.*s%.*s%d%.*s"
-				" forward to %s:%.*s%.*s%d%.*s",
-			    (int)(sserv ? strlen(sports) : 0), sports,
-			    sserv, "(", sport, sserv, ")",
-			    host,
-			    (int)(dserv ? strlen(dports) : 0), dports,
-			    dserv, "(", dport, dserv, ")");
-			logevent(buf);
+			logeventf(ssh, "Requesting remote port "
+				  "%.*s%.*s%.*s%.*s%d%.*s"
+				  " forward to %s:%.*s%.*s%d%.*s",
+				  (int)(*saddr?strlen(saddr):0),
+				  *saddr?saddr:NULL,
+				  (int)(*saddr?1:0), ":",
+				  (int)(sserv ? strlen(sports) : 0), sports,
+				  sserv, "(", sport, sserv, ")",
+				  host,
+				  (int)(dserv ? strlen(dports) : 0), dports,
+				  dserv, "(", dport, dserv, ")");
 			ssh2_pkt_init(ssh, SSH2_MSG_GLOBAL_REQUEST);
 			ssh2_pkt_addstring(ssh, "tcpip-forward");
 			ssh2_pkt_addbool(ssh, 1);/* want reply */
-			if (cfg.rport_acceptall)
+			if (*saddr)
+			    ssh2_pkt_addstring(ssh, saddr);
+			if (ssh->cfg.rport_acceptall)
 			    ssh2_pkt_addstring(ssh, "0.0.0.0");
 			else
 			    ssh2_pkt_addstring(ssh, "127.0.0.1");
@@ -5216,10 +5540,10 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 
 			if (ssh->pktin.type != SSH2_MSG_REQUEST_SUCCESS) {
 			    if (ssh->pktin.type != SSH2_MSG_REQUEST_FAILURE) {
-				bombout((ssh,"Unexpected response to port "
+				bombout(("Unexpected response to port "
 					 "forwarding request: packet type %d",
 					 ssh->pktin.type));
-				crReturnV;
+				crStopV;
 			    }
 			    logevent("Server refused this port forwarding");
 			} else {
@@ -5234,7 +5558,7 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
     /*
      * Potentially enable agent forwarding.
      */
-    if (cfg.agentfwd && agent_exists()) {
+    if (ssh->cfg.agentfwd && agent_exists()) {
 	logevent("Requesting OpenSSH-style agent forwarding");
 	ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_REQUEST);
 	ssh2_pkt_adduint32(ssh, ssh->mainchan->remoteid);
@@ -5256,9 +5580,9 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 
 	if (ssh->pktin.type != SSH2_MSG_CHANNEL_SUCCESS) {
 	    if (ssh->pktin.type != SSH2_MSG_CHANNEL_FAILURE) {
-		bombout((ssh,"Unexpected response to agent forwarding request:"
+		bombout(("Unexpected response to agent forwarding request:"
 			 " packet type %d", ssh->pktin.type));
-		crReturnV;
+		crStopV;
 	    }
 	    logevent("Agent forwarding refused");
 	} else {
@@ -5270,18 +5594,27 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
     /*
      * Now allocate a pty for the session.
      */
-    if (!cfg.nopty) {
+    if (!ssh->cfg.nopty) {
+	/* Unpick the terminal-speed string. */
+	/* XXX perhaps we should allow no speeds to be sent. */
+        ssh->ospeed = 38400; ssh->ispeed = 38400; /* last-resort defaults */
+	sscanf(ssh->cfg.termspeed, "%d,%d", &ssh->ospeed, &ssh->ispeed);
+	/* Build the pty request. */
 	ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_REQUEST);
 	ssh2_pkt_adduint32(ssh, ssh->mainchan->remoteid);	/* recipient channel */
 	ssh2_pkt_addstring(ssh, "pty-req");
 	ssh2_pkt_addbool(ssh, 1);	       /* want reply */
-	ssh2_pkt_addstring(ssh, cfg.termtype);
+	ssh2_pkt_addstring(ssh, ssh->cfg.termtype);
 	ssh2_pkt_adduint32(ssh, ssh->term_width);
 	ssh2_pkt_adduint32(ssh, ssh->term_height);
 	ssh2_pkt_adduint32(ssh, 0);	       /* pixel width */
 	ssh2_pkt_adduint32(ssh, 0);	       /* pixel height */
 	ssh2_pkt_addstring_start(ssh);
-	ssh2_pkt_addstring_data(ssh, "\0", 1);	/* TTY_OP_END, no special options */
+	ssh2_pkt_addbyte(ssh, 128);	       /* TTY_OP_ISPEED */
+	ssh2_pkt_adduint32(ssh, ssh->ispeed);
+	ssh2_pkt_addbyte(ssh, 129);	       /* TTY_OP_OSPEED */
+	ssh2_pkt_adduint32(ssh, ssh->ospeed);
+	ssh2_pkt_addstring_data(ssh, "\0", 1); /* TTY_OP_END */
 	ssh2_pkt_send(ssh);
 	ssh->state = SSH_STATE_INTERMED;
 
@@ -5299,14 +5632,15 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 
 	if (ssh->pktin.type != SSH2_MSG_CHANNEL_SUCCESS) {
 	    if (ssh->pktin.type != SSH2_MSG_CHANNEL_FAILURE) {
-		bombout((ssh,"Unexpected response to pty request:"
+		bombout(("Unexpected response to pty request:"
 			 " packet type %d", ssh->pktin.type));
-		crReturnV;
+		crStopV;
 	    }
 	    c_write_str(ssh, "Server refused to allocate pty\r\n");
 	    ssh->editing = ssh->echoing = 1;
 	} else {
-	    logevent("Allocated pty");
+	    logeventf(ssh, "Allocated pty (ospeed %dbps, ispeed %dbps)",
+		      ssh->ospeed, ssh->ispeed);
 	}
     } else {
 	ssh->editing = ssh->echoing = 1;
@@ -5322,11 +5656,11 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	char *cmd;
 
 	if (ssh->fallback_cmd) {
-	    subsys = cfg.ssh_subsys2;
-	    cmd = cfg.remote_cmd_ptr2;
+	    subsys = ssh->cfg.ssh_subsys2;
+	    cmd = ssh->cfg.remote_cmd_ptr2;
 	} else {
-	    subsys = cfg.ssh_subsys;
-	    cmd = cfg.remote_cmd_ptr;
+	    subsys = ssh->cfg.ssh_subsys;
+	    cmd = ssh->cfg.remote_cmd_ptr;
 	}
 
 	ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_REQUEST);
@@ -5357,9 +5691,9 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	} while (ssh->pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST);
 	if (ssh->pktin.type != SSH2_MSG_CHANNEL_SUCCESS) {
 	    if (ssh->pktin.type != SSH2_MSG_CHANNEL_FAILURE) {
-		bombout((ssh,"Unexpected response to shell/command request:"
+		bombout(("Unexpected response to shell/command request:"
 			 " packet type %d", ssh->pktin.type));
-		crReturnV;
+		crStopV;
 	    }
 	    /*
 	     * We failed to start the command. If this is the
@@ -5367,13 +5701,13 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	     * not, and if the fallback command exists, try falling
 	     * back to it before complaining.
 	     */
-	    if (!ssh->fallback_cmd && cfg.remote_cmd_ptr2 != NULL) {
+	    if (!ssh->fallback_cmd && ssh->cfg.remote_cmd_ptr2 != NULL) {
 		logevent("Primary command failed; attempting fallback");
 		ssh->fallback_cmd = TRUE;
 		continue;
 	    }
-	    bombout((ssh,"Server refused to start a shell/command"));
-	    crReturnV;
+	    bombout(("Server refused to start a shell/command"));
+	    crStopV;
 	} else {
 	    logevent("Started a shell/command");
 	}
@@ -5410,7 +5744,7 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		    continue;	       /* extended but not stderr */
 		ssh2_pkt_getstring(ssh, &data, &length);
 		if (data) {
-		    int bufsize;
+		    int bufsize = 0;
 		    c->v.v2.locwindow -= length;
 		    switch (c->type) {
 		      case CHAN_MAINSESSION:
@@ -5438,7 +5772,8 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 			    if (c->u.a.lensofar == 4) {
 				c->u.a.totallen =
 				    4 + GET_32BIT(c->u.a.msglen);
-				c->u.a.message = smalloc(c->u.a.totallen);
+				c->u.a.message = snewn(c->u.a.totallen,
+						       unsigned char);
 				memcpy(c->u.a.message, c->u.a.msglen, 4);
 			    }
 			    if (c->u.a.lensofar >= 4 && length > 0) {
@@ -5452,22 +5787,13 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 				c->u.a.lensofar += l;
 			    }
 			    if (c->u.a.lensofar == c->u.a.totallen) {
-				void *reply, *sentreply;
+				void *reply;
 				int replylen;
-				agent_query(c->u.a.message,
-					    c->u.a.totallen, &reply,
-					    &replylen);
-				if (reply)
-				    sentreply = reply;
-				else {
-				    /* Fake SSH_AGENT_FAILURE. */
-				    sentreply = "\0\0\0\1\5";
-				    replylen = 5;
-				}
-				ssh2_add_channel_data(c, sentreply, replylen);
-				s->try_send = TRUE;
-				if (reply)
-				    sfree(reply);
+				if (agent_query(c->u.a.message,
+						c->u.a.totallen,
+						&reply, &replylen,
+						ssh_agentf_callback, c))
+				    ssh_agentf_callback(c, reply, replylen);
 				sfree(c->u.a.message);
 				c->u.a.lensofar = 0;
 			    }
@@ -5509,8 +5835,9 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 
 		c = find234(ssh->channels, &i, ssh_channelfind);
 		if (!c || ((int)c->remoteid) == -1) {
-		    bombout((ssh,"Received CHANNEL_CLOSE for %s channel %d\n",
+		    bombout(("Received CHANNEL_CLOSE for %s channel %d\n",
 			     c ? "half-open" : "nonexistent", i));
+		    crStopV;
 		}
 		/* Do pre-close processing on the channel. */
 		switch (c->type) {
@@ -5543,6 +5870,7 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		 * See if that was the last channel left open.
 		 */
 		if (count234(ssh->channels) == 0) {
+		    logevent("All channels closed. Disconnecting");
 #if 0
                     /*
                      * We used to send SSH_MSG_DISCONNECT here,
@@ -5555,23 +5883,22 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
                      * this is more polite than sending a
                      * DISCONNECT. So now we don't.
                      */
-		    logevent("All channels closed. Disconnecting");
 		    ssh2_pkt_init(ssh, SSH2_MSG_DISCONNECT);
 		    ssh2_pkt_adduint32(ssh, SSH2_DISCONNECT_BY_APPLICATION);
 		    ssh2_pkt_addstring(ssh, "All open channels closed");
 		    ssh2_pkt_addstring(ssh, "en");	/* language tag */
 		    ssh2_pkt_send(ssh);
 #endif
-		    ssh->state = SSH_STATE_CLOSED;
-		    crReturnV;
+                    ssh_closing((Plug)ssh, NULL, 0, 0);
+		    crStopV;
 		}
 		continue;	       /* remote sends close; ignore (FIXME) */
 	    } else if (ssh->pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST) {
 		unsigned i = ssh2_pkt_getuint32(ssh);
 		struct ssh_channel *c;
 		c = find234(ssh->channels, &i, ssh_channelfind);
-		if (!c)
-		    continue;	       /* nonexistent channel */
+		if (!c || c->closes)
+		    continue;	       /* nonexistent or closing channel */
 		c->v.v2.remwindow += ssh2_pkt_getuint32(ssh);
 		s->try_send = TRUE;
 	    } else if (ssh->pktin.type == SSH2_MSG_CHANNEL_OPEN_CONFIRMATION) {
@@ -5639,9 +5966,9 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		    ssh2_pkt_addstring(ssh, buf);
 		    ssh2_pkt_addstring(ssh, "en");	/* language tag */
 		    ssh2_pkt_send(ssh);
-		    connection_fatal("%s", buf);
-		    ssh->state = SSH_STATE_CLOSED;
-		    crReturnV;
+		    connection_fatal(ssh->frontend, "%s", buf);
+                    ssh_closing((Plug)ssh, NULL, 0, 0);
+		    crStopV;
 		}
 
 		/*
@@ -5695,11 +6022,14 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	    } else if (ssh->pktin.type == SSH2_MSG_CHANNEL_OPEN) {
 		char *type;
 		int typelen;
+		char *peeraddr;
+		int peeraddrlen;
+		int peerport;
 		char *error = NULL;
 		struct ssh_channel *c;
 		unsigned remid, winsize, pktsize;
 		ssh2_pkt_getstring(ssh, &type, &typelen);
-		c = smalloc(sizeof(struct ssh_channel));
+		c = snew(struct ssh_channel);
 		c->ssh = ssh;
 
 		remid = ssh2_pkt_getuint32(ssh);
@@ -5707,14 +6037,25 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		pktsize = ssh2_pkt_getuint32(ssh);
 
 		if (typelen == 3 && !memcmp(type, "x11", 3)) {
+		    char *addrstr;
+
+                    ssh2_pkt_getstring(ssh, &peeraddr, &peeraddrlen);
+		    addrstr = snewn(peeraddrlen+1, char);
+		    memcpy(addrstr, peeraddr, peeraddrlen);
+		    peeraddr[peeraddrlen] = '\0';
+                    peerport = ssh2_pkt_getuint32(ssh);
+
 		    if (!ssh->X11_fwd_enabled)
 			error = "X11 forwarding is not enabled";
-		    else if (x11_init(&c->u.x11.s, cfg.x11_display, c,
-				      ssh->x11auth) != NULL) {
+		    else if (x11_init(&c->u.x11.s, ssh->cfg.x11_display, c,
+				      ssh->x11auth, addrstr, peerport,
+				      &ssh->cfg) != NULL) {
 			error = "Unable to open an X11 connection";
 		    } else {
 			c->type = CHAN_X11;
 		    }
+
+		    sfree(addrstr);
 		} else if (typelen == 15 &&
 			   !memcmp(type, "forwarded-tcpip", 15)) {
 		    struct ssh_rportfwd pf, *realpf;
@@ -5722,19 +6063,20 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		    int dummylen;
 		    ssh2_pkt_getstring(ssh, &dummy, &dummylen);/* skip address */
 		    pf.sport = ssh2_pkt_getuint32(ssh);
+                    ssh2_pkt_getstring(ssh, &peeraddr, &peeraddrlen);
+                    peerport = ssh2_pkt_getuint32(ssh);
 		    realpf = find234(ssh->rportfwds, &pf, NULL);
 		    if (realpf == NULL) {
 			error = "Remote port is not recognised";
 		    } else {
-			char *e = pfd_newconnect(&c->u.pfd.s, realpf->dhost,
-						 realpf->dport, c);
-			char buf[1024];
-			sprintf(buf, "Received remote port open request for %s:%d",
-				realpf->dhost, realpf->dport);
-			logevent(buf);
+			const char *e = pfd_newconnect(&c->u.pfd.s,
+						       realpf->dhost,
+						       realpf->dport, c,
+						       &ssh->cfg);
+			logeventf(ssh, "Received remote port open request"
+				  " for %s:%d", realpf->dhost, realpf->dport);
 			if (e != NULL) {
-			    sprintf(buf, "Port open failed: %s", e);
-			    logevent(buf);
+			    logeventf(ssh, "Port open failed: %s", e);
 			    error = "Port open failed";
 			} else {
 			    logevent("Forwarded port opened successfully");
@@ -5778,14 +6120,14 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 		    ssh2_pkt_send(ssh);
 		}
 	    } else {
-		bombout((ssh,"Strange packet received: type %d", ssh->pktin.type));
-		crReturnV;
+		bombout(("Strange packet received: type %d", ssh->pktin.type));
+		crStopV;
 	    }
 	} else {
 	    /*
 	     * We have spare data. Add it to the channel buffer.
 	     */
-	    ssh2_add_channel_data(ssh->mainchan, in, inlen);
+	    ssh2_add_channel_data(ssh->mainchan, (char *)in, inlen);
 	    s->try_send = TRUE;
 	}
 	if (s->try_send) {
@@ -5795,7 +6137,10 @@ static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen, int ispkt)
 	     * Try to send data on all channels if we can.
 	     */
 	    for (i = 0; NULL != (c = index234(ssh->channels, i)); i++) {
-		int bufsize = ssh2_try_send(c);
+		int bufsize;
+		if (c->closes)
+		    continue;	       /* don't send on closing channels */
+		bufsize = ssh2_try_send(c);
 		if (bufsize == 0) {
 		    switch (c->type) {
 		      case CHAN_MAINSESSION:
@@ -5836,13 +6181,17 @@ static void ssh2_protocol(Ssh ssh, unsigned char *in, int inlen, int ispkt)
  *
  * Returns an error message, or NULL on success.
  */
-static char *ssh_init(void *frontend_handle, void **backend_handle,
-		      char *host, int port, char **realhost, int nodelay)
+static const char *ssh_init(void *frontend_handle, void **backend_handle,
+			    Config *cfg,
+			    char *host, int port, char **realhost, int nodelay,
+			    int keepalive)
 {
-    char *p;
+    const char *p;
     Ssh ssh;
 
-    ssh = smalloc(sizeof(*ssh));
+    ssh = snew(struct ssh_tag);
+    ssh->cfg = *cfg;		       /* STRUCTURE COPY */
+    ssh->version = 0;		       /* when not ready yet */
     ssh->s = NULL;
     ssh->cipher = NULL;
     ssh->v1_cipher_ctx = NULL;
@@ -5860,6 +6209,7 @@ static char *ssh_init(void *frontend_handle, void **backend_handle,
     ssh->sccomp = NULL;
     ssh->sc_comp_ctx = NULL;
     ssh->kex = NULL;
+    ssh->kex_ctx = NULL;
     ssh->hostkey = NULL;
     ssh->exitcode = -1;
     ssh->state = SSH_STATE_PREPACKET;
@@ -5903,8 +6253,11 @@ static char *ssh_init(void *frontend_handle, void **backend_handle,
 #endif
 
     ssh->frontend = frontend_handle;
-    ssh->term_width = cfg.width;
-    ssh->term_height = cfg.height;
+    ssh->term_width = ssh->cfg.width;
+    ssh->term_height = ssh->cfg.height;
+
+    ssh->channels = NULL;
+    ssh->rportfwds = NULL;
 
     ssh->send_ok = 0;
     ssh->editing = 0;
@@ -5913,13 +6266,112 @@ static char *ssh_init(void *frontend_handle, void **backend_handle,
     ssh->overall_bufsize = 0;
     ssh->fallback_cmd = 0;
 
-    p = connect_to_host(ssh, host, port, realhost, nodelay);
+    ssh->protocol = NULL;
+
+    p = connect_to_host(ssh, host, port, realhost, nodelay, keepalive);
     if (p != NULL)
 	return p;
 
     return NULL;
 }
 
+static void ssh_free(void *handle)
+{
+    Ssh ssh = (Ssh) handle;
+    struct ssh_channel *c;
+    struct ssh_rportfwd *pf;
+
+    if (ssh->v1_cipher_ctx)
+	ssh->cipher->free_context(ssh->v1_cipher_ctx);
+    if (ssh->cs_cipher_ctx)
+	ssh->cscipher->free_context(ssh->cs_cipher_ctx);
+    if (ssh->sc_cipher_ctx)
+	ssh->sccipher->free_context(ssh->sc_cipher_ctx);
+    if (ssh->cs_mac_ctx)
+	ssh->csmac->free_context(ssh->cs_mac_ctx);
+    if (ssh->sc_mac_ctx)
+	ssh->scmac->free_context(ssh->sc_mac_ctx);
+    if (ssh->cs_comp_ctx) {
+	if (ssh->cscomp)
+	    ssh->cscomp->compress_cleanup(ssh->cs_comp_ctx);
+	else
+	    zlib_compress_cleanup(ssh->cs_comp_ctx);
+    }
+    if (ssh->sc_comp_ctx) {
+	if (ssh->sccomp)
+	    ssh->sccomp->decompress_cleanup(ssh->sc_comp_ctx);
+	else
+	    zlib_decompress_cleanup(ssh->sc_comp_ctx);
+    }
+    if (ssh->kex_ctx)
+	dh_cleanup(ssh->kex_ctx);
+    sfree(ssh->savedhost);
+
+    if (ssh->channels) {
+	while ((c = delpos234(ssh->channels, 0)) != NULL) {
+	    switch (c->type) {
+	      case CHAN_X11:
+		if (c->u.x11.s != NULL)
+		    x11_close(c->u.x11.s);
+		break;
+	      case CHAN_SOCKDATA:
+		if (c->u.pfd.s != NULL)
+		    pfd_close(c->u.pfd.s);
+		break;
+	    }
+	    sfree(c);
+	}
+	freetree234(ssh->channels);
+    }
+
+    if (ssh->rportfwds) {
+	while ((pf = delpos234(ssh->rportfwds, 0)) != NULL)
+	    sfree(pf);
+	freetree234(ssh->rportfwds);
+    }
+    sfree(ssh->deferred_send_data);
+    if (ssh->x11auth)
+	x11_free_auth(ssh->x11auth);
+    sfree(ssh->do_ssh_init_state);
+    sfree(ssh->do_ssh1_login_state);
+    sfree(ssh->do_ssh2_transport_state);
+    sfree(ssh->do_ssh2_authconn_state);
+    if (ssh->pktout.data) {
+	sfree(ssh->pktout.data);
+	ssh->pktout.data = NULL;
+    }
+    if (ssh->pktin.data) {
+	sfree(ssh->pktin.data);
+	ssh->pktin.data = NULL;
+    }
+    if (ssh->crcda_ctx) {
+	crcda_free_context(ssh->crcda_ctx);
+	ssh->crcda_ctx = NULL;
+    }
+    if (ssh->logctx) {
+	log_free(ssh->logctx);
+	ssh->logctx = NULL;
+    }
+    if (ssh->s)
+	ssh_do_close(ssh);
+    sfree(ssh);
+}
+
+/*
+ * Reconfigure the SSH backend.
+ * 
+ * Currently, this function does nothing very useful. In future,
+ * however, we could do some handy things with it. For example, we
+ * could make the port forwarding configurer active in the Change
+ * Settings box, and this routine could close down existing
+ * forwardings and open up new ones in response to changes.
+ */
+static void ssh_reconfig(void *handle, Config *cfg)
+{
+    Ssh ssh = (Ssh) handle;
+    ssh->cfg = *cfg;		       /* STRUCTURE COPY */
+}
+
 /*
  * Called to send data down the Telnet connection.
  */
@@ -5930,7 +6382,7 @@ static int ssh_send(void *handle, char *buf, int len)
     if (ssh == NULL || ssh->s == NULL || ssh->protocol == NULL)
 	return 0;
 
-    ssh->protocol(ssh, buf, len, 0);
+    ssh->protocol(ssh, (unsigned char *)buf, len, 0);
 
     return ssh_sendbuffer(ssh);
 }
@@ -5986,7 +6438,7 @@ static void ssh_size(void *handle, int width, int height)
 	ssh->size_needed = TRUE;       /* buffer for later */
 	break;
       case SSH_STATE_SESSION:
-	if (!cfg.nopty) {
+	if (!ssh->cfg.nopty) {
 	    if (ssh->version == 1) {
 		send_packet(ssh, SSH1_CMSG_WINDOW_SIZE,
 			    PKT_INT, ssh->term_height,
@@ -6009,6 +6461,31 @@ static void ssh_size(void *handle, int width, int height)
 }
 
 /*
+ * Return a list of the special codes that make sense in this
+ * protocol.
+ */
+static const struct telnet_special *ssh_get_specials(void *handle)
+{
+    Ssh ssh = (Ssh) handle;
+
+    if (ssh->version == 1) {
+	static const struct telnet_special ssh1_specials[] = {
+	    {"IGNORE message", TS_NOP},
+	    {NULL, 0}
+	};
+	return ssh1_specials;
+    } else if (ssh->version == 2) {
+	static const struct telnet_special ssh2_specials[] = {
+	    {"Break", TS_BRK},
+	    {"IGNORE message", TS_NOP},
+	    {NULL, 0}
+	};
+	return ssh2_specials;
+    } else
+	return NULL;
+}
+
+/*
  * Send Telnet special codes. TS_EOF is useful for `plink', so you
  * can send an EOF and collect resulting output (e.g. `plink
  * hostname sort').
@@ -6035,7 +6512,7 @@ static void ssh_special(void *handle, Telnet_Special code)
 	    ssh2_pkt_send(ssh);
 	}
 	logevent("Sent EOF message");
-    } else if (code == TS_PING) {
+    } else if (code == TS_PING || code == TS_NOP) {
 	if (ssh->state == SSH_STATE_CLOSED
 	    || ssh->state == SSH_STATE_PREPACKET) return;
 	if (ssh->version == 1) {
@@ -6046,6 +6523,19 @@ static void ssh_special(void *handle, Telnet_Special code)
 	    ssh2_pkt_addstring_start(ssh);
 	    ssh2_pkt_send(ssh);
 	}
+    } else if (code == TS_BRK) {
+	if (ssh->state == SSH_STATE_CLOSED
+	    || ssh->state == SSH_STATE_PREPACKET) return;
+	if (ssh->version == 1) {
+	    logevent("Unable to send BREAK signal in SSH1");
+	} else {
+	    ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_REQUEST);
+	    ssh2_pkt_adduint32(ssh, ssh->mainchan->remoteid);
+	    ssh2_pkt_addstring(ssh, "break");
+	    ssh2_pkt_addbool(ssh, 0);
+	    ssh2_pkt_adduint32(ssh, 0);   /* default break length */
+	    ssh2_pkt_send(ssh);
+	}
     } else {
 	/* do nothing */
     }
@@ -6055,7 +6545,7 @@ void *new_sock_channel(void *handle, Socket s)
 {
     Ssh ssh = (Ssh) handle;
     struct ssh_channel *c;
-    c = smalloc(sizeof(struct ssh_channel));
+    c = snew(struct ssh_channel);
     c->ssh = ssh;
 
     if (c) {
@@ -6074,7 +6564,7 @@ void *new_sock_channel(void *handle, Socket s)
  * This is called when stdout/stderr (the entity to which
  * from_backend sends data) manages to clear some backlog.
  */
-void ssh_unthrottle(void *handle, int bufsize)
+static void ssh_unthrottle(void *handle, int bufsize)
 {
     Ssh ssh = (Ssh) handle;
     if (ssh->version == 1) {
@@ -6092,10 +6582,8 @@ void ssh_send_port_open(void *channel, char *hostname, int port, char *org)
 {
     struct ssh_channel *c = (struct ssh_channel *)channel;
     Ssh ssh = c->ssh;
-    char buf[1024];
 
-    sprintf(buf, "Opening forwarded connection to %.512s:%d", hostname, port);
-    logevent(buf);
+    logeventf(ssh, "Opening forwarded connection to %s:%d", hostname, port);
 
     if (ssh->version == 1) {
 	send_packet(ssh, SSH1_MSG_PORT_OPEN,
@@ -6163,7 +6651,10 @@ static void ssh_provide_logctx(void *handle, void *logctx)
 static int ssh_return_exitcode(void *handle)
 {
     Ssh ssh = (Ssh) handle;
-    return ssh->exitcode;
+    if (ssh->s != NULL)
+        return -1;
+    else
+        return (ssh->exitcode >= 0 ? ssh->exitcode : 0);
 }
 
 /*
@@ -6179,10 +6670,13 @@ extern int ssh_fallback_cmd(void *handle)
 
 Backend ssh_backend = {
     ssh_init,
+    ssh_free,
+    ssh_reconfig,
     ssh_send,
     ssh_sendbuffer,
     ssh_size,
     ssh_special,
+    ssh_get_specials,
     ssh_socket,
     ssh_return_exitcode,
     ssh_sendok,