long savedpos;
    long maxlen;
};

static struct Packet pktin = { 0, 0, NULL, NULL, 0 };
static struct Packet pktout = { 0, 0, NULL, NULL, 0 };

static int ssh_version;
static void (*ssh_protocol)(unsigned char *in, int inlen, int ispkt);
static void ssh1_protocol(unsigned char *in, int inlen, int ispkt);
static void ssh2_protocol(unsigned char *in, int inlen, int ispkt);
static void ssh_size(void);

static int (*s_rdpkt)(unsigned char **data, int *datalen);

        sha_string(&exhash, vstring, strcspn(vstring, "\r\n"));
        sprintf(vstring, "%s\n", verstring);
        sprintf(vlog, "We claim version: %s", verstring);
        logevent(vlog);
        logevent("Using SSH protocol version 2");
        s_write(vstring, strlen(vstring));
        ssh_protocol = ssh2_protocol;
        ssh_version = 2;
        s_rdpkt = ssh2_rdpkt;
    } else {
        /*
         * This is a v1 server. Begin v1 protocol.
         */
        sprintf(vstring, "SSH-%s-PuTTY\n",
                (ssh_versioncmp(version, "1.5") <= 0 ? version : "1.5"));
        sprintf(vlog, "We claim version: %s", vstring);
        vlog[strcspn(vlog, "\r\n")] = '\0';
        logevent(vlog);
        logevent("Using SSH protocol version 1");
        s_write(vstring, strlen(vstring));
        ssh_protocol = ssh1_protocol;
        ssh_version = 1;
        s_rdpkt = ssh1_rdpkt;
    }
    return 1;
}

/*
 * Handle the key exchange and user authentication phases.

            fatalbox("Protocol confusion");
        } else if (pktin.type == SSH1_SMSG_FAILURE) {
            c_write("Server refused to allocate pty\r\n", 32);
        }
	logevent("Allocated pty");
    }

    if (*cfg.remote_cmd)
        send_packet(SSH1_CMSG_EXEC_CMD, PKT_STR, cfg.remote_cmd, PKT_END);
    else
    send_packet(SSH1_CMSG_EXEC_SHELL, PKT_END);
        send_packet(SSH1_CMSG_EXEC_SHELL, PKT_END);
    logevent("Started session");

    ssh_state = SSH_STATE_SESSION;
    if (size_needed)
	ssh_size();

    while (1) {

        crReturn(1);
    } while (!(ispkt && pktin.type == SSH2_MSG_KEXINIT));
    goto begin_key_exchange;

    crFinish(1);
}

/*
 * SSH2: remote identifier for the main session channel.
 */
static unsigned long ssh_remote_channel;

/*
 * Handle the SSH2 userauth and connection layers.
 */
static void do_ssh2_authconn(unsigned char *in, int inlen, int ispkt)
{
    static unsigned long their_channel;
    static unsigned long remote_winsize;
    static unsigned long remote_maxpkt;

    crBegin;

    /*
     * Request userauth protocol, and await a response to it.

    if (pktin.type != SSH2_MSG_CHANNEL_OPEN_CONFIRMATION) {
        fatalbox("Server refused to open a session");
        /* FIXME: error data comes back in FAILURE packet */
    }
    if (ssh2_pkt_getuint32() != 100) {
        fatalbox("Server's channel confirmation cited wrong channel");
    }
    their_channel = ssh2_pkt_getuint32();
    ssh_remote_channel = ssh2_pkt_getuint32();
    remote_winsize = ssh2_pkt_getuint32();
    remote_maxpkt = ssh2_pkt_getuint32();
    logevent("Opened channel for session");

    /*
     * Now allocate a pty for the session.
     */
    ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
    ssh2_pkt_adduint32(their_channel); /* recipient channel */
    ssh2_pkt_adduint32(ssh_remote_channel); /* recipient channel */
    ssh2_pkt_addstring("pty-req");
    ssh2_pkt_addbool(1);               /* want reply */
    ssh2_pkt_addstring(cfg.termtype);
    ssh2_pkt_adduint32(cols);
    ssh2_pkt_adduint32(rows);
    ssh2_pkt_adduint32(0);             /* pixel width */
    ssh2_pkt_adduint32(0);             /* pixel height */

        logevent("Allocated pty");
    }

    /*
     * Start a shell.
     */
    ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
    ssh2_pkt_adduint32(their_channel); /* recipient channel */
    ssh2_pkt_adduint32(ssh_remote_channel); /* recipient channel */
    ssh2_pkt_addstring("shell");
    ssh2_pkt_addbool(1);               /* want reply */
    ssh2_pkt_send();
    do {                               /* FIXME: pay attention to these */
        crWaitUntilV(ispkt);
    } while (pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST);
    if (pktin.type != SSH2_MSG_CHANNEL_SUCCESS) {

                continue;              /* ignore for now (FIXME!) */
	    } else {
		fatalbox("Strange packet received: type %d", pktin.type);
	    }
	} else {
            /* FIXME: for now, ignore window size */
            ssh2_pkt_init(SSH2_MSG_CHANNEL_DATA);
            ssh2_pkt_adduint32(their_channel);
            ssh2_pkt_adduint32(ssh_remote_channel);
            ssh2_pkt_addstring_start();
            ssh2_pkt_addstring_data(in, inlen);
            ssh2_pkt_send();
	}
    }

    crFinishV;

	                PKT_INT, rows, PKT_INT, cols,
	                PKT_INT, 0, PKT_INT, 0, PKT_END);
        }
    }
}

/*
 * (Send Telnet special codes)
 * 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').
 */
static void ssh_special (Telnet_Special code) {
    if (code == TS_EOF) {
        if (ssh_version = 1) {
            send_packet(SSH1_CMSG_EOF, PKT_END);
        } else {
            ssh2_pkt_init(SSH2_MSG_CHANNEL_EOF);
            ssh2_pkt_adduint32(ssh_remote_channel);
            ssh2_pkt_send();
        }
    } else {
    /* do nothing */
        /* do nothing */
    }
}


/*
 * Read and decrypt one incoming SSH packet.
 * (only used by pSCP)
 */