#ifndef FALSE
#define FALSE 0
#endif
#ifndef TRUE
#define TRUE 1
#endif

/* uncomment this for packet level debugging */
/* #define DUMP_PACKETS */

#define logevent(s) { logevent(s); \
                      if ((flags & FLAG_STDERR) && (flags & FLAG_VERBOSE)) \
                      { fprintf(stderr, "%s\n", s); fflush(stderr); } }

#define bombout(msg) ( ssh_state = SSH_STATE_CLOSED, \
                          (s ? sk_close(s), s = NULL : 0), \
                          connection_fatal msg )

#define SSH2_MSG_CHANNEL_EXTENDED_DATA            95	/* 0x5f */
#define SSH2_MSG_CHANNEL_EOF                      96	/* 0x60 */
#define SSH2_MSG_CHANNEL_CLOSE                    97	/* 0x61 */
#define SSH2_MSG_CHANNEL_REQUEST                  98	/* 0x62 */
#define SSH2_MSG_CHANNEL_SUCCESS                  99	/* 0x63 */
#define SSH2_MSG_CHANNEL_FAILURE                  100	/* 0x64 */

/*
 * Packet type contexts, so that ssh2_pkt_type can correctly decode
 * the ambiguous type numbers back into the correct type strings.
 */
#define SSH2_PKTCTX_DHGROUP1         0x0001
#define SSH2_PKTCTX_DHGEX            0x0002
#define SSH2_PKTCTX_PUBLICKEY        0x0010
#define SSH2_PKTCTX_PASSWORD         0x0020
#define SSH2_PKTCTX_KBDINTER         0x0040
#define SSH2_PKTCTX_AUTH_MASK        0x00F0

#define SSH2_DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECT 1	/* 0x1 */
#define SSH2_DISCONNECT_PROTOCOL_ERROR            2	/* 0x2 */
#define SSH2_DISCONNECT_KEY_EXCHANGE_FAILED       3	/* 0x3 */
#define SSH2_DISCONNECT_HOST_AUTHENTICATION_FAILED 4	/* 0x4 */
#define SSH2_DISCONNECT_MAC_ERROR                 5	/* 0x5 */
#define SSH2_DISCONNECT_COMPRESSION_ERROR         6	/* 0x6 */
#define SSH2_DISCONNECT_SERVICE_NOT_AVAILABLE     7	/* 0x7 */

/*
 * Various remote-bug flags.
 */
#define BUG_CHOKES_ON_SSH1_IGNORE                 1
#define BUG_SSH2_HMAC                             2
#define BUG_NEEDS_SSH1_PLAIN_PASSWORD        	  4

static int ssh_pkt_ctx = 0;

#define translate(x) if (type == x) return #x
#define translatec(x,ctx) if (type == x && (ssh_pkt_ctx & ctx)) return #x
char *ssh1_pkt_type(int type)
{
    translate(SSH1_MSG_DISCONNECT);
    translate(SSH1_SMSG_PUBLIC_KEY);
    translate(SSH1_CMSG_SESSION_KEY);
    translate(SSH1_CMSG_USER);
    translate(SSH1_CMSG_AUTH_RSA);
    translate(SSH1_SMSG_AUTH_RSA_CHALLENGE);
    translate(SSH1_CMSG_AUTH_RSA_RESPONSE);
    translate(SSH1_CMSG_AUTH_PASSWORD);
    translate(SSH1_CMSG_REQUEST_PTY);
    translate(SSH1_CMSG_WINDOW_SIZE);
    translate(SSH1_CMSG_EXEC_SHELL);
    translate(SSH1_CMSG_EXEC_CMD);
    translate(SSH1_SMSG_SUCCESS);
    translate(SSH1_SMSG_FAILURE);
    translate(SSH1_CMSG_STDIN_DATA);
    translate(SSH1_SMSG_STDOUT_DATA);
    translate(SSH1_SMSG_STDERR_DATA);
    translate(SSH1_CMSG_EOF);
    translate(SSH1_SMSG_EXIT_STATUS);
    translate(SSH1_MSG_CHANNEL_OPEN_CONFIRMATION);
    translate(SSH1_MSG_CHANNEL_OPEN_FAILURE);
    translate(SSH1_MSG_CHANNEL_DATA);
    translate(SSH1_MSG_CHANNEL_CLOSE);
    translate(SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION);
    translate(SSH1_SMSG_X11_OPEN);
    translate(SSH1_CMSG_PORT_FORWARD_REQUEST);
    translate(SSH1_MSG_PORT_OPEN);
    translate(SSH1_CMSG_AGENT_REQUEST_FORWARDING);
    translate(SSH1_SMSG_AGENT_OPEN);
    translate(SSH1_MSG_IGNORE);
    translate(SSH1_CMSG_EXIT_CONFIRMATION);
    translate(SSH1_CMSG_X11_REQUEST_FORWARDING);
    translate(SSH1_CMSG_AUTH_RHOSTS_RSA);
    translate(SSH1_MSG_DEBUG);
    translate(SSH1_CMSG_REQUEST_COMPRESSION);
    translate(SSH1_CMSG_AUTH_TIS);
    translate(SSH1_SMSG_AUTH_TIS_CHALLENGE);
    translate(SSH1_CMSG_AUTH_TIS_RESPONSE);
    translate(SSH1_CMSG_AUTH_CCARD);
    translate(SSH1_SMSG_AUTH_CCARD_CHALLENGE);
    translate(SSH1_CMSG_AUTH_CCARD_RESPONSE);
    return "unknown";
}
char *ssh2_pkt_type(int type)
{
    translate(SSH2_MSG_DISCONNECT);
    translate(SSH2_MSG_IGNORE);
    translate(SSH2_MSG_UNIMPLEMENTED);
    translate(SSH2_MSG_DEBUG);
    translate(SSH2_MSG_SERVICE_REQUEST);
    translate(SSH2_MSG_SERVICE_ACCEPT);
    translate(SSH2_MSG_KEXINIT);
    translate(SSH2_MSG_NEWKEYS);
    translatec(SSH2_MSG_KEXDH_INIT, SSH2_PKTCTX_DHGROUP1);
    translatec(SSH2_MSG_KEXDH_REPLY, SSH2_PKTCTX_DHGROUP1);
    translatec(SSH2_MSG_KEX_DH_GEX_REQUEST, SSH2_PKTCTX_DHGEX);
    translatec(SSH2_MSG_KEX_DH_GEX_GROUP, SSH2_PKTCTX_DHGEX);
    translatec(SSH2_MSG_KEX_DH_GEX_INIT, SSH2_PKTCTX_DHGEX);
    translatec(SSH2_MSG_KEX_DH_GEX_REPLY, SSH2_PKTCTX_DHGEX);
    translate(SSH2_MSG_USERAUTH_REQUEST);
    translate(SSH2_MSG_USERAUTH_FAILURE);
    translate(SSH2_MSG_USERAUTH_SUCCESS);
    translate(SSH2_MSG_USERAUTH_BANNER);
    translatec(SSH2_MSG_USERAUTH_PK_OK, SSH2_PKTCTX_PUBLICKEY);
    translatec(SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ, SSH2_PKTCTX_PASSWORD);
    translatec(SSH2_MSG_USERAUTH_INFO_REQUEST, SSH2_PKTCTX_KBDINTER);
    translatec(SSH2_MSG_USERAUTH_INFO_RESPONSE, SSH2_PKTCTX_KBDINTER);
    translate(SSH2_MSG_GLOBAL_REQUEST);
    translate(SSH2_MSG_REQUEST_SUCCESS);
    translate(SSH2_MSG_REQUEST_FAILURE);
    translate(SSH2_MSG_CHANNEL_OPEN);
    translate(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION);
    translate(SSH2_MSG_CHANNEL_OPEN_FAILURE);
    translate(SSH2_MSG_CHANNEL_WINDOW_ADJUST);
    translate(SSH2_MSG_CHANNEL_DATA);
    translate(SSH2_MSG_CHANNEL_EXTENDED_DATA);
    translate(SSH2_MSG_CHANNEL_EOF);
    translate(SSH2_MSG_CHANNEL_CLOSE);
    translate(SSH2_MSG_CHANNEL_REQUEST);
    translate(SSH2_MSG_CHANNEL_SUCCESS);
    translate(SSH2_MSG_CHANNEL_FAILURE);
    return "unknown";
}
#undef translate
#undef translatec

#define GET_32BIT(cp) \
    (((unsigned long)(unsigned char)(cp)[0] << 24) | \
    ((unsigned long)(unsigned char)(cp)[1] << 16) | \
    ((unsigned long)(unsigned char)(cp)[2] << 8) | \
    ((unsigned long)(unsigned char)(cp)[3]))

	*datalen -= st->chunk;
	st->p += st->chunk;
	st->to_read -= st->chunk;
    }

    if (cipher)
	cipher->decrypt(pktin.data, st->biglen);
#ifdef DUMP_PACKETS
    debug(("Got packet len=%d pad=%d\n", st->len, st->pad));
    dmemdump(pktin.data, st->biglen);
#endif

    st->realcrc = crc32(pktin.data, st->biglen - 4);
    st->gotcrc = GET_32BIT(pktin.data + st->biglen - 4);
    if (st->gotcrc != st->realcrc) {
	bombout(("Incorrect CRC received on packet"));
	crReturn(0);
    }

    pktin.body = pktin.data + st->pad + 1;

    if (ssh1_compressing) {
	unsigned char *decompblk;
	int decomplen;
#ifdef DUMP_PACKETS
	debug(("Packet payload pre-decompression:\n"));
	dmemdump(pktin.body - 1, pktin.length + 1);
#endif
	zlib_decompress_block(pktin.body - 1, pktin.length + 1,
			      &decompblk, &decomplen);

	if (pktin.maxlen < st->pad + decomplen) {
	    pktin.maxlen = st->pad + decomplen;
	    pktin.data = srealloc(pktin.data, pktin.maxlen + APIEXTRA);
	    pktin.body = pktin.data + st->pad + 1;
	    if (!pktin.data)
		fatalbox("Out of memory");
	}

	memcpy(pktin.body - 1, decompblk, decomplen);
	sfree(decompblk);
	pktin.length = decomplen - 1;
    }
#ifdef DUMP_PACKETS

	debug(("Packet payload post-decompression:\n"));
	dmemdump(pktin.body - 1, pktin.length + 1);
    pktin.type = pktin.body[-1];
#endif
    }

    log_packet(PKT_INCOMING, pktin.type, ssh1_pkt_type(pktin.type),
	       pktin.body, pktin.length);

    if (pktin.type == SSH1_SMSG_STDOUT_DATA ||
	pktin.type == SSH1_SMSG_STDERR_DATA ||
	pktin.type == SSH1_MSG_DEBUG ||
	pktin.type == SSH1_SMSG_AUTH_TIS_CHALLENGE ||
	pktin.type == SSH1_SMSG_AUTH_CCARD_CHALLENGE) {
	long strlen = GET_32BIT(pktin.body);
	if (strlen + 4 != pktin.length) {
	    bombout(("Received data packet with bogus string length"));
	    crReturn(0);
	}
    }

    pktin.type = pktin.body[-1];

    if (pktin.type == SSH1_MSG_DEBUG) {
	/* log debug message */
	char buf[80];
	int strlen = GET_32BIT(pktin.body);
	strcpy(buf, "Remote: ");
	if (strlen > 70)
	    strlen = 70;

	(*datalen)--;
    }
    /* Decrypt everything _except_ the MAC. */
    if (sccipher)
	sccipher->decrypt(pktin.data + st->cipherblk,
			  st->packetlen - st->cipherblk);

#ifdef DUMP_PACKETS
    debug(("Got packet len=%d pad=%d\n", st->len, st->pad));
    dmemdump(pktin.data, st->packetlen);
#endif

    /*
     * Check the MAC.
     */
    if (scmac
	&& !scmac->verify(pktin.data, st->len + 4,
			  st->incoming_sequence)) {
	bombout(("Incorrect MAC received on packet"));

							 pktin.maxlen +
							 APIEXTRA));
		if (!pktin.data)
		    fatalbox("Out of memory");
	    }
	    pktin.length = 5 + newlen;
	    memcpy(pktin.data + 5, newpayload, newlen);
#ifdef DUMP_PACKETS
	    debug(("Post-decompression payload:\n"));
	    dmemdump(pktin.data + 5, newlen);
#endif

	    sfree(newpayload);
	}
    }

    pktin.savedpos = 6;
    pktin.type = pktin.data[5];

    log_packet(PKT_INCOMING, pktin.type, ssh2_pkt_type(pktin.type),
	       pktin.data+6, pktin.length-6);

    if (pktin.type == SSH2_MSG_IGNORE || pktin.type == SSH2_MSG_DEBUG)
	goto next_packet;	       /* FIXME: print DEBUG message */

    if (pktin.type == SSH2_MSG_DISCONNECT) {
	/* log reason code in disconnect message */
	char buf[256];

static int s_wrpkt_prepare(void)
{
    int pad, len, biglen, i;
    unsigned long crc;

    pktout.body[-1] = pktout.type;

    log_packet(PKT_OUTGOING, pktout.type, ssh1_pkt_type(pktout.type),
	       pktout.body, pktout.length);

    if (ssh1_compressing) {
	unsigned char *compblk;
	int complen;
#ifdef DUMP_PACKETS
	debug(("Packet payload pre-compression:\n"));
	dmemdump(pktout.body - 1, pktout.length + 1);
#endif
	zlib_compress_block(pktout.body - 1, pktout.length + 1,
			    &compblk, &complen);
	ssh1_pktout_size(complen - 1);
	memcpy(pktout.body - 1, compblk, complen);
	sfree(compblk);
    }

    len = pktout.length + 5;	       /* type and CRC */
    pad = 8 - (len % 8);
    biglen = len + pad;

    for (i = 0; i < pad; i++)
	pktout.data[i + 4] = random_byte();
    crc = crc32(pktout.data + 4, biglen - 4);
    PUT_32BIT(pktout.data + biglen, crc);
    PUT_32BIT(pktout.data, len);

#ifdef DUMP_PACKETS
    debug(("Sending packet len=%d\n", biglen + 4));
    dmemdump(pktout.data, biglen + 4);
#endif
    if (cipher)
	cipher->encrypt(pktout.data + 4, biglen);

    return biglen + 4;
}

static void s_wrpkt(void)

 * pktout.data. Total length is returned.
 */
static int ssh2_pkt_construct(void)
{
    int cipherblk, maclen, padding, i;
    static unsigned long outgoing_sequence = 0;

    log_packet(PKT_OUTGOING, pktout.data[5], ssh2_pkt_type(pktout.data[5]),
	       pktout.data + 6, pktout.length - 6);

    /*
     * Compress packet payload.
     */
    {
	unsigned char *newpayload;
	int newlen;
#ifdef DUMP_PACKETS
	if (cscomp && cscomp != &ssh_comp_none) {
	    debug(("Pre-compression payload:\n"));
	    dmemdump(pktout.data + 5, pktout.length - 5);
	}
#endif
	if (cscomp && cscomp->compress(pktout.data + 5, pktout.length - 5,
				       &newpayload, &newlen)) {
	    pktout.length = 5;
	    ssh2_pkt_adddata(newpayload, newlen);
	    sfree(newpayload);
	}
    }

	pktout.data[pktout.length + i] = random_byte();
    PUT_32BIT(pktout.data, pktout.length + padding - 4);
    if (csmac)
	csmac->generate(pktout.data, pktout.length + padding,
			outgoing_sequence);
    outgoing_sequence++;	       /* whether or not we MACed */

#ifdef DUMP_PACKETS
    debug(("Sending packet len=%d\n", pktout.length + padding));
    dmemdump(pktout.data, pktout.length + padding);
#endif

    if (cscipher)
	cscipher->encrypt(pktout.data, pktout.length + padding);

    /* Ready-to-send packet starts at pktout.data. We return length. */
    return pktout.length + padding + maclen;
}

    /*
     * If we're doing Diffie-Hellman group exchange, start by
     * requesting a group.
     */
    if (kex == &ssh_diffiehellman_gex) {
	logevent("Doing Diffie-Hellman group exchange");
	ssh_pkt_ctx |= SSH2_PKTCTX_DHGEX;
	/*
	 * Work out how big a DH group we will need to allow that
	 * much data.
	 */
	pbits = 512 << ((nbits - 1) / 64);
	ssh2_pkt_init(SSH2_MSG_KEX_DH_GEX_REQUEST);
	ssh2_pkt_adduint32(pbits);
	ssh2_pkt_send();

	crWaitUntil(ispkt);
	if (pktin.type != SSH2_MSG_KEX_DH_GEX_GROUP) {
	    bombout(("expected key exchange group packet from server"));
	    crReturn(0);
	}
	p = ssh2_pkt_getmp();
	g = ssh2_pkt_getmp();
	dh_setup_group(p, g);
	kex_init_value = SSH2_MSG_KEX_DH_GEX_INIT;
	kex_reply_value = SSH2_MSG_KEX_DH_GEX_REPLY;
    } else {
	ssh_pkt_ctx |= SSH2_PKTCTX_DHGROUP1;
	dh_setup_group1();
	kex_init_value = SSH2_MSG_KEXDH_INIT;
	kex_reply_value = SSH2_MSG_KEXDH_REPLY;
    }

    logevent("Doing Diffie-Hellman key exchange");
    /*

	}

	/*
	 * Send an authentication request using method "none": (a)
	 * just in case it succeeds, and (b) so that we know what
	 * authentication methods we can usefully try next.
	 */
	ssh_pkt_ctx &= ~SSH2_PKTCTX_AUTH_MASK;

	ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
	ssh2_pkt_addstring(username);
	ssh2_pkt_addstring("ssh-connection");	/* service requested */
	ssh2_pkt_addstring("none");    /* method */
	ssh2_pkt_send();
	type = AUTH_TYPE_NONE;
	gotit = FALSE;

		can_passwd =
		    in_commasep_string("password", methods, methlen);
		can_keyb_inter = cfg.try_ki_auth &&
		    in_commasep_string("keyboard-interactive", methods, methlen);
	    }

	    method = 0;
	    ssh_pkt_ctx &= ~SSH2_PKTCTX_AUTH_MASK;

	    if (!method && can_pubkey && agent_exists() && !tried_agent) {
		/*
		 * Attempt public-key authentication using Pageant.
		 */
		static unsigned char request[5], *response, *p;
		static int responselen;
		static int i, nkeys;
		static int authed = FALSE;
		void *r;

		ssh_pkt_ctx |= SSH2_PKTCTX_PUBLICKEY;

		tried_agent = TRUE;

		logevent("Pageant is running. Requesting keys.");

		/* Request the keys held by the agent. */
		PUT_32BIT(request, 1);

		&& !tried_pubkey_config) {
		unsigned char *pub_blob;
		char *algorithm, *comment;
		int pub_blob_len;

		tried_pubkey_config = TRUE;

		ssh_pkt_ctx |= SSH2_PKTCTX_PUBLICKEY;

		/*
		 * Try the public key supplied in the configuration.
		 *
		 * First, offer the public blob to see if the server is
		 * willing to accept it.
		 */
		pub_blob = ssh2_userkey_loadpub(cfg.keyfile, &algorithm,

		}
	    }

	    if (!method && can_keyb_inter && !tried_keyb_inter) {
		method = AUTH_KEYBOARD_INTERACTIVE;
		type = AUTH_TYPE_KEYBOARD_INTERACTIVE;
		tried_keyb_inter = TRUE;

		ssh_pkt_ctx |= SSH2_PKTCTX_KBDINTER;

		ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
		ssh2_pkt_addstring(username);
		ssh2_pkt_addstring("ssh-connection");	/* service requested */
		ssh2_pkt_addstring("keyboard-interactive");	/* method */
		ssh2_pkt_addstring(""); /* lang */
		ssh2_pkt_addstring("");

		kbd_inter_running = TRUE;
	    }

	    if (kbd_inter_running) {
		method = AUTH_KEYBOARD_INTERACTIVE;
		type = AUTH_TYPE_KEYBOARD_INTERACTIVE;
		tried_keyb_inter = TRUE;

		ssh_pkt_ctx |= SSH2_PKTCTX_KBDINTER;

		/* We've got packet with that "interactive" info
		   dump banners, and set its prompt as ours */
		{
		    char *name, *inst, *lang, *prompt;
		    int name_len, inst_len, lang_len, prompt_len;
		    ssh2_pkt_getstring(&name, &name_len);

		    echo = ssh2_pkt_getbool();
		}
	    }

	    if (!method && can_passwd) {
		method = AUTH_PASSWORD;
		ssh_pkt_ctx |= SSH2_PKTCTX_PASSWORD;
		sprintf(pwprompt, "%.90s@%.90s's password: ", username,
			savedhost);
		need_pw = TRUE;
	    }

	    if (need_pw) {
		if (ssh_get_line) {