} while (0)
#define crStop(z)	do{ crLine = 0; return (z); }while(0)
#define crStopV		do{ crLine = 0; return; }while(0)
#define crWaitUntil(c)	do { crReturn(0); } while (!(c))
#define crWaitUntilV(c)	do { crReturnV; } while (!(c))

extern const struct ssh_cipher ssh_3des;
extern const struct ssh_cipher ssh_3des_ssh2;
extern const struct ssh2_ciphers ssh2_3des;
extern const struct ssh_cipher ssh_des;
extern const struct ssh_cipher ssh_aes128_ssh2;
extern const struct ssh2_ciphers ssh2_aes;
extern const struct ssh_cipher ssh_aes192_ssh2;
extern const struct ssh_cipher ssh_aes256_ssh2;
extern const struct ssh_cipher ssh_blowfish_ssh1;
extern const struct ssh_cipher ssh_blowfish_ssh2;
extern const struct ssh2_ciphers ssh2_blowfish;

extern char *x11_init (Socket *, char *, void *);
extern void x11_close (Socket);
extern void x11_send  (Socket , char *, int);
extern void x11_invent_auth(char *, int, char *, int);

/*
 * Ciphers for SSH2. We miss out single-DES because it isn't
 * supported; also 3DES and Blowfish are both done differently from
 * SSH1. (3DES uses outer chaining; Blowfish has the opposite
 * endianness and different-sized keys.)
 */
const static struct ssh_cipher *ciphers[] = {
    &ssh_aes256_ssh2,
const static struct ssh2_ciphers *ciphers[] = {
    &ssh2_aes,
    &ssh_aes192_ssh2,
    &ssh_aes128_ssh2,
    &ssh_blowfish_ssh2,
    &ssh_3des_ssh2
    &ssh2_blowfish,
    &ssh2_3des,
};

extern const struct ssh_kex ssh_diffiehellman;
extern const struct ssh_kex ssh_diffiehellman_gex;
const static struct ssh_kex *kex_algs[] = {
#ifdef DO_DIFFIE_HELLMAN_GEX
    &ssh_diffiehellman_gex,

static Socket s = NULL;

static unsigned char session_key[32];
static int ssh1_compressing;
static int ssh_agentfwd_enabled;
static int ssh_X11_fwd_enabled;
static const struct ssh_cipher *cipher = NULL;
static const struct ssh_cipher *cscipher = NULL;
static const struct ssh_cipher *sccipher = NULL;
static const struct ssh2_cipher *cscipher = NULL;
static const struct ssh2_cipher *sccipher = NULL;
static const struct ssh_mac *csmac = NULL;
static const struct ssh_mac *scmac = NULL;
static const struct ssh_compress *cscomp = NULL;
static const struct ssh_compress *sccomp = NULL;
static const struct ssh_kex *kex = NULL;
static const struct ssh_signkey *hostkey = NULL;
int (*ssh_get_password)(const char *prompt, char *str, int maxlen) = NULL;

    } else {
	rsaencrypt(rsabuf, 32, &hostkey);
	rsaencrypt(rsabuf, hostkey.bytes, &servkey);
    }

    logevent("Encrypted session key");

    switch (cfg.cipher) {
    cipher_type = cfg.cipher == CIPHER_BLOWFISH ? SSH_CIPHER_BLOWFISH :
                  cfg.cipher == CIPHER_DES ? SSH_CIPHER_DES : 
                  SSH_CIPHER_3DES;
      case CIPHER_BLOWFISH: cipher_type = SSH_CIPHER_BLOWFISH; break;
      case CIPHER_DES:      cipher_type = SSH_CIPHER_DES;      break;
      case CIPHER_3DES:     cipher_type = SSH_CIPHER_3DES;     break;
      case CIPHER_AES:
        c_write("AES not supported in SSH1, falling back to 3DES\r\n", 49);
        cipher_type = SSH_CIPHER_3DES;
        break;
    }
    if ((supported_ciphers_mask & (1 << cipher_type)) == 0) {
	c_write("Selected cipher not supported, falling back to 3DES\r\n", 53);
	cipher_type = SSH_CIPHER_3DES;
    }
    switch (cipher_type) {
      case SSH_CIPHER_3DES: logevent("Using 3DES encryption"); break;
      case SSH_CIPHER_DES: logevent("Using single-DES encryption"); break;

}

/*
 * Handle the SSH2 transport layer.
 */
static int do_ssh2_transport(unsigned char *in, int inlen, int ispkt)
{
    static int i, len, nbits;
    static int i, j, len, nbits;
    static char *str;
    static Bignum p, g, e, f, K;
    static int kex_init_value, kex_reply_value;
    static const struct ssh_mac **maclist;
    static int nmacs;
    static const struct ssh_cipher *cscipher_tobe = NULL;
    static const struct ssh_cipher *sccipher_tobe = NULL;
    static const struct ssh2_cipher *cscipher_tobe = NULL;
    static const struct ssh2_cipher *sccipher_tobe = NULL;
    static const struct ssh_mac *csmac_tobe = NULL;
    static const struct ssh_mac *scmac_tobe = NULL;
    static const struct ssh_compress *cscomp_tobe = NULL;
    static const struct ssh_compress *sccomp_tobe = NULL;
    static char *hostkeydata, *sigdata, *keystr, *fingerprint;
    static int hostkeylen, siglen;
    static void *hkey;		       /* actual host key */
    static unsigned char exchange_hash[20];
    static unsigned char first_exchange_hash[20];
    static unsigned char keyspace[40];
    static const struct ssh_cipher *preferred_cipher;
    static const struct ssh2_ciphers *preferred_cipher;
    static const struct ssh_compress *preferred_comp;
    static int first_kex;

    crBegin;
    random_init();
    first_kex = 1;

    /*
     * Set up the preferred cipher and compression.
     */
    if (cfg.cipher == CIPHER_BLOWFISH) {
        preferred_cipher = &ssh_blowfish_ssh2;
        preferred_cipher = &ssh2_blowfish;
    } else if (cfg.cipher == CIPHER_DES) {
        logevent("Single DES not supported in SSH2; using 3DES");
        preferred_cipher = &ssh_3des_ssh2;
        preferred_cipher = &ssh2_3des;
    } else if (cfg.cipher == CIPHER_3DES) {
        preferred_cipher = &ssh_3des_ssh2;
        preferred_cipher = &ssh2_3des;
    } else if (cfg.cipher == CIPHER_AES) {
        preferred_cipher = &ssh2_aes;
    } else {
        /* Shouldn't happen, but we do want to initialise to _something_. */
        preferred_cipher = &ssh_3des_ssh2;
        preferred_cipher = &ssh2_3des;
    }
    if (cfg.compression)
	preferred_comp = &ssh_zlib;
    else
	preferred_comp = &ssh_comp_none;

    /*

        ssh2_pkt_addstring_str(hostkey_algs[i]->name);
        if (i < lenof(hostkey_algs)-1)
            ssh2_pkt_addstring_str(",");
    }
    /* List client->server encryption algorithms. */
    ssh2_pkt_addstring_start();
    for (i = 0; i < lenof(ciphers)+1; i++) {
        const struct ssh_cipher *c = i==0 ? preferred_cipher : ciphers[i-1];
        ssh2_pkt_addstring_str(c->name);
        if (i < lenof(ciphers))
            ssh2_pkt_addstring_str(",");
        const struct ssh2_ciphers *c = i==0 ? preferred_cipher : ciphers[i-1];
        for (j = 0; j < c->nciphers; j++) {
            ssh2_pkt_addstring_str(c->list[j]->name);
            if (i < lenof(ciphers) || j < c->nciphers-1)
                ssh2_pkt_addstring_str(",");
        }
    }
    /* List server->client encryption algorithms. */
    ssh2_pkt_addstring_start();
    for (i = 0; i < lenof(ciphers)+1; i++) {
        const struct ssh_cipher *c = i==0 ? preferred_cipher : ciphers[i-1];
        ssh2_pkt_addstring_str(c->name);
        if (i < lenof(ciphers))
            ssh2_pkt_addstring_str(",");
        const struct ssh2_ciphers *c = i==0 ? preferred_cipher : ciphers[i-1];
        for (j = 0; j < c->nciphers; j++) {
            ssh2_pkt_addstring_str(c->list[j]->name);
            if (i < lenof(ciphers) || j < c->nciphers-1)
                ssh2_pkt_addstring_str(",");
        }
    }
    /* List client->server MAC algorithms. */
    ssh2_pkt_addstring_start();
    for (i = 0; i < nmacs; i++) {
        ssh2_pkt_addstring_str(maclist[i]->name);
        if (i < nmacs-1)
            ssh2_pkt_addstring_str(",");

        if (in_commasep_string(hostkey_algs[i]->name, str, len)) {
            hostkey = hostkey_algs[i];
            break;
        }
    }
    ssh2_pkt_getstring(&str, &len);    /* client->server cipher */
    for (i = 0; i < lenof(ciphers)+1; i++) {
        const struct ssh_cipher *c = i==0 ? preferred_cipher : ciphers[i-1];
        if (in_commasep_string(c->name, str, len)) {
            cscipher_tobe = c;
            break;
        }
        const struct ssh2_ciphers *c = i==0 ? preferred_cipher : ciphers[i-1];
        for (j = 0; j < c->nciphers; j++) {
            if (in_commasep_string(c->list[j]->name, str, len)) {
                cscipher_tobe = c->list[j];
                break;
            }
        }
        if (cscipher_tobe)
            break;
    }
    ssh2_pkt_getstring(&str, &len);    /* server->client cipher */
    for (i = 0; i < lenof(ciphers)+1; i++) {
        const struct ssh_cipher *c = i==0 ? preferred_cipher : ciphers[i-1];
        if (in_commasep_string(c->name, str, len)) {
            sccipher_tobe = c;
            break;
        }
        const struct ssh2_ciphers *c = i==0 ? preferred_cipher : ciphers[i-1];
        for (j = 0; j < c->nciphers; j++) {
            if (in_commasep_string(c->list[j]->name, str, len)) {
                sccipher_tobe = c->list[j];
                break;
            }
        }
        if (sccipher_tobe)
            break;
    }
    ssh2_pkt_getstring(&str, &len);    /* client->server mac */
    for (i = 0; i < nmacs; i++) {
        if (in_commasep_string(maclist[i]->name, str, len)) {
            csmac_tobe = maclist[i];
            break;
        }