#define PUT_32BIT(cp, value) { \
    (cp)[0] = (unsigned char)((value) >> 24); \
    (cp)[1] = (unsigned char)((value) >> 16); \
    (cp)[2] = (unsigned char)((value) >> 8); \
    (cp)[3] = (unsigned char)(value); }

/* Enumeration values for fields in SSH-1 packets */
enum {
enum { PKT_END, PKT_INT, PKT_CHAR, PKT_DATA, PKT_STR, PKT_BIGNUM };
    PKT_END, PKT_INT, PKT_CHAR, PKT_DATA, PKT_STR, PKT_BIGNUM,
    /* These values are for communicating relevant semantics of
     * fields to the packet logging code. */
    PKTT_OTHER, PKTT_PASSWORD, PKTT_DATA
};

/*
 * 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

    int size_needed, eof_needed;

    struct Packet pktin;
    struct Packet pktout;
    unsigned char *deferred_send_data;
    int deferred_len, deferred_size;

    /*
     * State associated with packet logging
     */
    int pktout_logmode;
    int pktout_nblanks;
    struct logblank_t *pktout_blanks;

    /*
     * Gross hack: pscp will try to start SFTP but fall back to
     * scp1 if that fails. This variable is the means by which
     * scp.c can reach into the SSH code and find out which one it
     * got.
     */
    int fallback_cmd;

    do { \
        char *text = dupprintf msg; \
	ssh_do_close(ssh); \
        logevent(text); \
        connection_fatal(ssh->frontend, "%s", text); \
        sfree(text); \
    } while (0)

/* Functions to leave bits out of the SSH packet log file. */

static void dont_log_password(Ssh ssh, int blanktype)
{
    if (ssh->cfg.logomitpass)
	ssh->pktout_logmode = blanktype;
}

static void dont_log_data(Ssh ssh, int blanktype)
{
    if (ssh->cfg.logomitdata)
	ssh->pktout_logmode = blanktype;
}

static void end_log_omission(Ssh ssh)
{
    ssh->pktout_logmode = PKTLOG_EMIT;
}

static int ssh_channelcmp(void *av, void *bv)
{
    struct ssh_channel *a = (struct ssh_channel *) av;
    struct ssh_channel *b = (struct ssh_channel *) bv;
    if (a->localid < b->localid)
	return -1;

	memcpy(ssh->pktin.body - 1, decompblk, decomplen);
	sfree(decompblk);
	ssh->pktin.length = decomplen - 1;
    }

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

    /*
     * Log incoming packet, possibly omitting sensitive fields.
     */
    if (ssh->logctx)
    if (ssh->logctx) {
	int nblanks = 0;
	struct logblank_t blank;
	if (ssh->cfg.logomitdata) {
	    int do_blank = FALSE, blank_prefix = 0;
	    /* "Session data" packets - omit the data field */
	    if ((ssh->pktin.type == SSH1_SMSG_STDOUT_DATA) ||
		(ssh->pktin.type == SSH1_SMSG_STDERR_DATA)) {
		do_blank = TRUE; blank_prefix = 0;
	    } else if (ssh->pktin.type == SSH1_MSG_CHANNEL_DATA) {
		do_blank = TRUE; blank_prefix = 4;
	    }
	    if (do_blank) {
		blank.offset = blank_prefix;
		blank.len = ssh->pktin.length;
		blank.type = PKTLOG_OMIT;
		nblanks = 1;
	    }
	}
	log_packet(ssh->logctx,
		   PKT_INCOMING, ssh->pktin.type,
		   ssh1_pkt_type(ssh->pktin.type),
		   ssh->pktin.body, ssh->pktin.length);
		   ssh->pktin.body, ssh->pktin.length,
		   nblanks, &blank);
    }

    if (ssh->pktin.type == SSH1_SMSG_STDOUT_DATA ||
	ssh->pktin.type == SSH1_SMSG_STDERR_DATA ||
	ssh->pktin.type == SSH1_MSG_DEBUG ||
	ssh->pktin.type == SSH1_SMSG_AUTH_TIS_CHALLENGE ||
	ssh->pktin.type == SSH1_SMSG_AUTH_CCARD_CHALLENGE) {
	long stringlen = GET_32BIT(ssh->pktin.body);

	}
    }

    ssh->pktin.savedpos = 6;
    ssh->pktin.body = ssh->pktin.data;
    ssh->pktin.type = ssh->pktin.data[5];

    /*
     * Log incoming packet, possibly omitting sensitive fields.
     */
    if (ssh->logctx)
    if (ssh->logctx) {
	int nblanks = 0;
	struct logblank_t blank;
	if (ssh->cfg.logomitdata) {
	    int do_blank = FALSE, blank_prefix = 0;
	    /* "Session data" packets - omit the data field */
	    if (ssh->pktin.type == SSH2_MSG_CHANNEL_DATA) {
		do_blank = TRUE; blank_prefix = 4;
	    } else if (ssh->pktin.type == SSH2_MSG_CHANNEL_EXTENDED_DATA) {
		do_blank = TRUE; blank_prefix = 8;
	    }
	    if (do_blank) {
		blank.offset = blank_prefix;
		blank.len = (ssh->pktin.length-6) - blank_prefix;
		blank.type = PKTLOG_OMIT;
		nblanks = 1;
	    }
	}
	log_packet(ssh->logctx, PKT_INCOMING, ssh->pktin.type,
		   ssh2_pkt_type(ssh->pkt_ctx, ssh->pktin.type),
		   ssh->pktin.data+6, ssh->pktin.length-6);
		   ssh->pktin.data+6, ssh->pktin.length-6,
		   nblanks, &blank);
    }

    switch (ssh->pktin.type) {
        /*
         * These packets we must handle instantly.
         */
      case SSH2_MSG_DISCONNECT:
        {

    ssh->pktout.body = ssh->pktout.data + 4 + pad + 1;
}

static void s_wrpkt_start(Ssh ssh, int type, int len)
{
    ssh1_pktout_size(ssh, len);
    ssh->pktout.type = type;
    /* Initialise log omission state */
    ssh->pktout_nblanks = 0;
    ssh->pktout_blanks = NULL;
}

static int s_wrpkt_prepare(Ssh ssh)
{
    int pad, biglen, i;
    unsigned long crc;
#ifdef __SC__

    int len;

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

    if (ssh->logctx)
	log_packet(ssh->logctx, PKT_OUTGOING, ssh->pktout.type,
		   ssh1_pkt_type(ssh->pktout.type),
		   ssh->pktout.body, ssh->pktout.length);
		   ssh->pktout.body, ssh->pktout.length,
		   ssh->pktout_nblanks, ssh->pktout_blanks);
    sfree(ssh->pktout_blanks); ssh->pktout_blanks = NULL;
    ssh->pktout_nblanks = 0;

    if (ssh->v1_compressing) {
	unsigned char *compblk;
	int complen;
	zlib_compress_block(ssh->cs_comp_ctx,
			    ssh->pktout.body - 1, ssh->pktout.length + 1,
			    &compblk, &complen);

	    arglen = strlen((char *)argp);
	    pktlen += 4 + arglen;
	    break;
	  case PKT_BIGNUM:
	    bn = va_arg(ap1, Bignum);
	    pktlen += ssh1_bignum_length(bn);
	    break;
	  case PKTT_PASSWORD:
	  case PKTT_DATA:
	  case PKTT_OTHER:
	    /* ignore this pass */
	    break;
	  default:
	    assert(0);
	}
    }

    s_wrpkt_start(ssh, pkttype, pktlen);
    p = ssh->pktout.body;

    while ((argtype = va_arg(ap2, int)) != PKT_END) {
	int offset = p - ssh->pktout.body, len = 0;
	switch (argtype) {
	  /* Actual fields in the packet */
	  case PKT_INT:
	    argint = va_arg(ap2, int);
	    PUT_32BIT(p, argint);
	    p += 4;
	    len = 4;
	    break;
	  case PKT_CHAR:
	    argchar = (unsigned char) va_arg(ap2, int);
	    *p = argchar;
	    p++;
	    len = 1;
	    break;
	  case PKT_DATA:
	    argp = va_arg(ap2, unsigned char *);
	    arglen = va_arg(ap2, int);
	    memcpy(p, argp, arglen);
	    p += arglen;
	    len = arglen;
	    break;
	  case PKT_STR:
	    argp = va_arg(ap2, unsigned char *);
	    arglen = strlen((char *)argp);
	    PUT_32BIT(p, arglen);
	    memcpy(p + 4, argp, arglen);
	    p += 4 + arglen;
	    len = arglen + 4;
	    break;
	  case PKT_BIGNUM:
	    bn = va_arg(ap2, Bignum);
	    p += ssh1_write_bignum(p, bn);
	    len = ssh1_write_bignum(p, bn);
	    break;
	  /* Tokens for modifications to packet logging */
	  case PKTT_PASSWORD:
	    dont_log_password(ssh, PKTLOG_BLANK);
	    break;
	  case PKTT_DATA:
	    dont_log_data(ssh, PKTLOG_OMIT);
	    break;
	  case PKTT_OTHER:
	    end_log_omission(ssh);
	    break;
	}
	p += len;
	/* Deal with logfile omission, if required. */
	if (len && (ssh->pktout_logmode != PKTLOG_EMIT)) {
	    ssh->pktout_nblanks++;
	    ssh->pktout_blanks = sresize(ssh->pktout_blanks,
					 ssh->pktout_nblanks,
					 struct logblank_t);
	    ssh->pktout_blanks[ssh->pktout_nblanks-1].offset = offset;
	    ssh->pktout_blanks[ssh->pktout_nblanks-1].len    = len;
	    ssh->pktout_blanks[ssh->pktout_nblanks-1].type   =
		ssh->pktout_logmode;
	}
    }
}

static void send_packet(Ssh ssh, int pkttype, ...)
{
    va_list ap1, ap2;
    va_start(ap1, pkttype);

				   unsigned char);
	if (!ssh->pktout.data)
	    fatalbox("Out of memory");
    }
}
static void ssh2_pkt_adddata(Ssh ssh, void *data, int len)
{
    if (ssh->pktout_logmode != PKTLOG_EMIT) {
	ssh->pktout_nblanks++;
	ssh->pktout_blanks = sresize(ssh->pktout_blanks, ssh->pktout_nblanks,
				     struct logblank_t);
	ssh->pktout_blanks[ssh->pktout_nblanks-1].offset =
	    ssh->pktout.length - 6;
	ssh->pktout_blanks[ssh->pktout_nblanks-1].len = len;
	ssh->pktout_blanks[ssh->pktout_nblanks-1].type = ssh->pktout_logmode;
    }
    ssh->pktout.length += len;
    ssh2_pkt_ensure(ssh, ssh->pktout.length);
    memcpy(ssh->pktout.data + ssh->pktout.length - len, data, len);
}
static void ssh2_pkt_addbyte(Ssh ssh, unsigned char byte)
{
    ssh2_pkt_adddata(ssh, &byte, 1);
}
static void ssh2_pkt_init(Ssh ssh, int pkt_type)
{
    ssh->pktout.length = 5;
    ssh->pktout_nblanks = 0; ssh->pktout_blanks = NULL;
    ssh2_pkt_addbyte(ssh, (unsigned char) pkt_type);
}
static void ssh2_pkt_addbool(Ssh ssh, unsigned char value)
{
    ssh2_pkt_adddata(ssh, &value, 1);
}
static void ssh2_pkt_adduint32(Ssh ssh, unsigned long value)

static int ssh2_pkt_construct(Ssh ssh)
{
    int cipherblk, maclen, padding, i;

    if (ssh->logctx)
	log_packet(ssh->logctx, PKT_OUTGOING, ssh->pktout.data[5],
		   ssh2_pkt_type(ssh->pkt_ctx, ssh->pktout.data[5]),
		   ssh->pktout.data + 6, ssh->pktout.length - 6);
		   ssh->pktout.data + 6, ssh->pktout.length - 6,
		   ssh->pktout_nblanks, ssh->pktout_blanks);
    sfree(ssh->pktout_blanks); ssh->pktout_blanks = NULL;
    ssh->pktout_nblanks = 0;

    /*
     * Compress packet payload.
     */
    {
	unsigned char *newpayload;
	int newlen;

    }
    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,
		    PKTT_DATA,
		    PKT_INT, replylen,
		    PKT_DATA, sentreply, replylen,
		    PKTT_OTHER,
		    PKT_END);
    }
    if (reply)
	sfree(reply);
}

/*

		    }

		    assert(pwlen >= bottom && pwlen <= top);

		    randomstr = snewn(top + 1, char);

		    for (i = bottom; i <= top; i++) {
			if (i == pwlen)
			if (i == pwlen) {
			    defer_packet(ssh, s->pwpkt_type,
					 PKTT_PASSWORD, PKT_STR, s->password,
					 PKT_STR, s->password, PKT_END);
			else {
					 PKTT_OTHER, PKT_END);
			} else {
			    for (j = 0; j < i; j++) {
				do {
				    randomstr[j] = random_byte();
				} while (randomstr[j] == '\0');
			    }
			    randomstr[i] = '\0';
			    defer_packet(ssh, SSH1_MSG_IGNORE,

			while (len < sizeof(string)) {
			    string[len++] = (char) random_byte();
			}
		    } else {
			ss = s->password;
		    }
		    logevent("Sending length-padded password");
		    send_packet(ssh, s->pwpkt_type, PKT_INT, len,
				PKT_DATA, ss, len, PKT_END);
		    send_packet(ssh, s->pwpkt_type, PKTT_PASSWORD,
				PKT_INT, len, PKT_DATA, ss, len,
			       	PKTT_OTHER, PKT_END);
		} else {
		    /*
		     * The server has _both_
		     * BUG_CHOKES_ON_SSH1_IGNORE and
		     * BUG_NEEDS_SSH1_PLAIN_PASSWORD. There is
		     * therefore nothing we can do.
		     */
		    int len;
		    len = strlen(s->password);
		    logevent("Sending unpadded password");
		    send_packet(ssh, s->pwpkt_type, PKT_INT, len,
				PKT_DATA, s->password, len, PKT_END);
		    send_packet(ssh, s->pwpkt_type,
				PKTT_PASSWORD, PKT_INT, len,
				PKT_DATA, s->password, len,
				PKTT_OTHER, PKT_END);
		}
	    } else {
		send_packet(ssh, s->pwpkt_type, PKT_STR, s->password, PKT_END);
		send_packet(ssh, s->pwpkt_type, PKTT_PASSWORD,
			    PKT_STR, s->password, PKTT_OTHER, PKT_END);
	    }
	}
	logevent("Sent password");
	memset(s->password, 0, strlen(s->password));
	crWaitUntil(ispkt);
	if (ssh->pktin.type == SSH1_SMSG_FAILURE) {
	    if (flags & FLAG_VERBOSE)

	assert(ssh->state == SSH_STATE_CLOSED);
	return 0;
    }

    if (ssh->version == 1) {
	send_packet(ssh, SSH1_MSG_CHANNEL_DATA,
		    PKT_INT, c->remoteid,
		    PKTT_DATA,
		    PKT_INT, len, PKT_DATA, buf, len, PKT_END);
		    PKT_INT, len, PKT_DATA, buf, len,
		    PKTT_OTHER, PKT_END);
	/*
	 * In SSH1 we can return 0 here - implying that forwarded
	 * connections are never individually throttled - because
	 * the only circumstance that can cause throttling will be
	 * the whole SSH connection backing up, in which case
	 * _everything_ will be throttled as a whole.
	 */

	    } else {
		bombout(("Strange packet received: type %d", ssh->pktin.type));
		crStopV;
	    }
	} else {
	    while (inlen > 0) {
		int len = min(inlen, 512);
		send_packet(ssh, SSH1_CMSG_STDIN_DATA,
			    PKT_INT, len, PKT_DATA, in, len, PKT_END);
		send_packet(ssh, SSH1_CMSG_STDIN_DATA, PKTT_DATA,
			    PKT_INT, len, PKT_DATA, in, len,
			    PKTT_OTHER, PKT_END);
		in += len;
		inlen -= len;
	    }
	}
    }

    crFinishV;

	bufchain_prefix(&c->v.v2.outbuffer, &data, &len);
	if ((unsigned)len > c->v.v2.remwindow)
	    len = c->v.v2.remwindow;
	if ((unsigned)len > c->v.v2.remmaxpkt)
	    len = c->v.v2.remmaxpkt;
	ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_DATA);
	ssh2_pkt_adduint32(ssh, c->remoteid);
	dont_log_data(ssh, PKTLOG_OMIT);
	ssh2_pkt_addstring_start(ssh);
	ssh2_pkt_addstring_data(ssh, data, len);
	end_log_omission(ssh);
	ssh2_pkt_send(ssh);
	bufchain_consume(&c->v.v2.outbuffer, len);
	c->v.v2.remwindow -= len;
    }

    /*
     * After having sent as much data as we can, return the amount

		 * people who find out how long their password is!
		 */
		ssh2_pkt_init(ssh, SSH2_MSG_USERAUTH_REQUEST);
		ssh2_pkt_addstring(ssh, s->username);
		ssh2_pkt_addstring(ssh, "ssh-connection");	/* service requested */
		ssh2_pkt_addstring(ssh, "password");
		ssh2_pkt_addbool(ssh, FALSE);
		dont_log_password(ssh, PKTLOG_BLANK);
		ssh2_pkt_addstring(ssh, s->password);
		memset(s->password, 0, sizeof(s->password));
		end_log_omission(ssh);
		ssh2_pkt_defer(ssh);
		/*
		 * We'll include a string that's an exact multiple of the
		 * cipher block size. If the cipher is NULL for some
		 * reason, we don't do this trick at all because we gain
		 * nothing by it.
		 */

		s->type = AUTH_TYPE_PASSWORD;
	    } else if (s->method == AUTH_KEYBOARD_INTERACTIVE) {
		if (s->curr_prompt == 0) {
		    ssh2_pkt_init(ssh, SSH2_MSG_USERAUTH_INFO_RESPONSE);
		    ssh2_pkt_adduint32(ssh, s->num_prompts);
		}
		if (s->need_pw) {      /* only add pw if we just got one! */
		    dont_log_password(ssh, PKTLOG_BLANK);
		    ssh2_pkt_addstring(ssh, s->password);
		    memset(s->password, 0, sizeof(s->password));
		    end_log_omission(ssh);
		    s->curr_prompt++;
		}
		if (s->curr_prompt >= s->num_prompts) {
		    ssh2_pkt_send(ssh);
		} else {
		    /*
		     * If there are prompts remaining, we set

    {
	static const struct Packet empty = { 0, 0, NULL, NULL, 0 };
	ssh->pktin = ssh->pktout = empty;
    }
    ssh->deferred_send_data = NULL;
    ssh->deferred_len = 0;
    ssh->deferred_size = 0;
    ssh->pktout_logmode = PKTLOG_EMIT;
    ssh->pktout_nblanks = 0;
    ssh->pktout_blanks = NULL;
    ssh->fallback_cmd = 0;
    ssh->pkt_ctx = 0;
    ssh->x11auth = NULL;
    ssh->v1_compressing = FALSE;
    ssh->v2_outgoing_sequence = 0;
    ssh->ssh1_rdpkt_crstate = 0;
    ssh->ssh2_rdpkt_crstate = 0;