ocr->next = NULL;
    if (!c->v.v2.chanreq_head)
	c->v.v2.chanreq_head = ocr;
    else
	c->v.v2.chanreq_tail->next = ocr;
    c->v.v2.chanreq_tail = ocr;
}






















/*
 * Potentially enlarge the window on an SSH-2 channel.
 */
static void ssh2_handle_winadj_response(struct ssh_channel *, struct Packet *,
					void *);
static void ssh2_set_window(struct ssh_channel *c, int newwin)

	 *
	 * This is only necessary if we're opening the window wide.
	 * If we're not, then throughput is being constrained by
	 * something other than the maximum window size anyway.
	 */
	if (newwin == c->v.v2.locmaxwin &&
            !(ssh->remote_bugs & BUG_CHOKES_ON_WINADJ)) {
	    pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
	    ssh2_pkt_adduint32(pktout, c->remoteid);
	    ssh2_pkt_addstring(pktout, "winadj@putty.projects.tartarus.org");
	    ssh2_pkt_addbool(pktout, TRUE);
	    ssh2_pkt_send(ssh, pktout);

	    up = snew(unsigned);
	    *up = newwin - c->v.v2.locwindow;
	    ssh2_queue_chanreq_handler(c, ssh2_handle_winadj_response, up);
	    if (c->v.v2.throttle_state != UNTHROTTLED)
		c->v.v2.throttle_state = UNTHROTTLING;
	} else {
	    /* Pretend the WINDOW_ADJUST was acked immediately. */
	    c->v.v2.remlocwin = newwin;
	    c->v.v2.throttle_state = THROTTLED;
	}

    Ssh ssh = c->ssh;
    struct Packet *pktout;

    if ((c->closes & (CLOSES_SENT_EOF | CLOSES_RCVD_EOF | CLOSES_SENT_CLOSE))
        == (CLOSES_SENT_EOF | CLOSES_RCVD_EOF) && !c->v.v2.chanreq_head) {
        /*
         * We have both sent and received EOF, and we have no
         * outstanding winadj channel requests, which means the
         * channel is in final wind-up. But we haven't sent CLOSE, so
         * let's do so now.
         */
	pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_CLOSE);
	ssh2_pkt_adduint32(pktout, c->remoteid);
	ssh2_pkt_send(ssh, pktout);
        c->closes |= CLOSES_SENT_CLOSE;

    /*
     * Potentially enable X11 forwarding.
     */
    if (ssh->mainchan && !ssh->ncmode && conf_get_int(ssh->conf, CONF_x11_forward) &&
	(ssh->x11disp = x11_setup_display(conf_get_str(ssh->conf, CONF_x11_display),
					  conf_get_int(ssh->conf, CONF_x11_auth), ssh->conf))) {
	logevent("Requesting X11 forwarding");
	pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
	ssh2_pkt_adduint32(pktout, ssh->mainchan->remoteid);
	ssh2_pkt_addstring(pktout, "x11-req");
	ssh2_pkt_addbool(pktout, 1);	       /* want reply */
	ssh2_pkt_addbool(pktout, 0);	       /* many connections */
	ssh2_pkt_addstring(pktout, ssh->x11disp->remoteauthprotoname);
	/*
	 * Note that while we blank the X authentication data here, we don't
	 * take any special action to blank the start of an X11 channel,
	 * so using MIT-MAGIC-COOKIE-1 and actually opening an X connection
	 * without having session blanking enabled is likely to leak your
	 * cookie into the log.
	 */
	dont_log_password(ssh, pktout, PKTLOG_BLANK);
	ssh2_pkt_addstring(pktout, ssh->x11disp->remoteauthdatastring);
	end_log_omission(ssh, pktout);
	ssh2_pkt_adduint32(pktout, ssh->x11disp->screennum);
	ssh2_pkt_send(ssh, pktout);

	ssh2_queue_chanreq_handler(ssh->mainchan, ssh2_maybe_setup_x11, s);

	crWaitUntilV(pktin);

	if (pktin->type == SSH2_MSG_CHANNEL_SUCCESS) {
	    logevent("X11 forwarding enabled");
	    ssh->X11_fwd_enabled = TRUE;
	} else
	    logevent("X11 forwarding refused");

    struct Packet *pktout;
    crStateP(ssh2_maybe_setup_agent_state, ctx);

    crBeginState;

    if (ssh->mainchan && !ssh->ncmode && conf_get_int(ssh->conf, CONF_agentfwd) && agent_exists()) {
	logevent("Requesting OpenSSH-style agent forwarding");
	pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
	ssh2_pkt_adduint32(pktout, ssh->mainchan->remoteid);
	ssh2_pkt_addstring(pktout, "auth-agent-req@openssh.com");
	ssh2_pkt_addbool(pktout, 1);	       /* want reply */
	ssh2_pkt_send(ssh, pktout);

	ssh2_queue_chanreq_handler(ssh->mainchan, ssh2_maybe_setup_agent, s);

	crWaitUntilV(pktin);

	if (pktin->type == SSH2_MSG_CHANNEL_SUCCESS) {
	    logevent("Agent forwarding enabled");
	    ssh->agentfwd_enabled = TRUE;
	} else
	    logevent("Agent forwarding refused");

    if (ssh->mainchan && !ssh->ncmode && !conf_get_int(ssh->conf, CONF_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(conf_get_str(ssh->conf, CONF_termspeed), "%d,%d", &ssh->ospeed, &ssh->ispeed);
	/* Build the pty request. */
	pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
	ssh2_pkt_adduint32(pktout, ssh->mainchan->remoteid);	/* recipient channel */
	ssh2_pkt_addstring(pktout, "pty-req");
	ssh2_pkt_addbool(pktout, 1);	       /* want reply */
	ssh2_pkt_addstring(pktout, conf_get_str(ssh->conf, CONF_termtype));
	ssh2_pkt_adduint32(pktout, ssh->term_width);
	ssh2_pkt_adduint32(pktout, ssh->term_height);
	ssh2_pkt_adduint32(pktout, 0);	       /* pixel width */
	ssh2_pkt_adduint32(pktout, 0);	       /* pixel height */
	ssh2_pkt_addstring_start(pktout);
	parse_ttymodes(ssh, ssh2_send_ttymode, (void *)pktout);
	ssh2_pkt_addbyte(pktout, SSH2_TTY_OP_ISPEED);
	ssh2_pkt_adduint32(pktout, ssh->ispeed);
	ssh2_pkt_addbyte(pktout, SSH2_TTY_OP_OSPEED);
	ssh2_pkt_adduint32(pktout, ssh->ospeed);
	ssh2_pkt_addstring_data(pktout, "\0", 1); /* TTY_OP_END */
	ssh2_pkt_send(ssh, pktout);
	ssh->state = SSH_STATE_INTERMED;

	ssh2_queue_chanreq_handler(ssh->mainchan, ssh2_maybe_setup_pty, s);

	crWaitUntilV(pktin);

	if (pktin->type == SSH2_MSG_CHANNEL_SUCCESS) {
	    logeventf(ssh, "Allocated pty (ospeed %dbps, ispeed %dbps)",
		      ssh->ospeed, ssh->ispeed);
            ssh->got_pty = TRUE;
	} else {

    s->num_env = 0;
    if (ssh->mainchan && !ssh->ncmode) {
	char *key, *val;

	for (val = conf_get_str_strs(ssh->conf, CONF_environmt, NULL, &key);
	     val != NULL;
	     val = conf_get_str_strs(ssh->conf, CONF_environmt, key, &key)) {
	    pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
	    ssh2_pkt_adduint32(pktout, ssh->mainchan->remoteid);
	    ssh2_pkt_addstring(pktout, "env");
	    ssh2_pkt_addbool(pktout, 1);	       /* want reply */
	    ssh2_pkt_addstring(pktout, key);
	    ssh2_pkt_addstring(pktout, val);
	    ssh2_pkt_send(ssh, pktout);
	    ssh2_queue_chanreq_handler(ssh->mainchan, ssh2_setup_env, s);

	    s->num_env++;
	}
	if (s->num_env)
	    logeventf(ssh, "Sent %d environment variables", s->num_env);
    }

    if (ssh->mainchan && conf_get_int(ssh->conf, CONF_ssh_simple)) {
	/*
	 * This message indicates to the server that we promise
	 * not to try to run any other channel in parallel with
	 * this one, so it's safe for it to advertise a very large
	 * window and leave the flow control to TCP.
	 */
	s->pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
	ssh2_pkt_adduint32(s->pktout, ssh->mainchan->remoteid);
	ssh2_pkt_addstring(s->pktout, "simple@putty.projects.tartarus.org");
	ssh2_pkt_addbool(s->pktout, 0); /* no reply */

	ssh2_pkt_send(ssh, s->pktout);
    }

    /*
     * Enable port forwardings.
     */
    ssh_setup_portfwd(ssh, ssh->conf);

	    subsys = conf_get_int(ssh->conf, CONF_ssh_subsys2);
	    cmd = conf_get_str(ssh->conf, CONF_remote_cmd2);
	} else {
	    subsys = conf_get_int(ssh->conf, CONF_ssh_subsys);
	    cmd = conf_get_str(ssh->conf, CONF_remote_cmd);
	}

	s->pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
	ssh2_pkt_adduint32(s->pktout, ssh->mainchan->remoteid);	/* recipient channel */
	if (subsys) {
	    ssh2_pkt_addstring(s->pktout, "subsystem");
	    ssh2_pkt_addbool(s->pktout, 1);	       /* want reply */
	    ssh2_pkt_addstring(s->pktout, cmd);
	} else if (*cmd) {
	    ssh2_pkt_addstring(s->pktout, "exec");
	    ssh2_pkt_addbool(s->pktout, 1);	       /* want reply */
	    ssh2_pkt_addstring(s->pktout, cmd);
	} else {
	    ssh2_pkt_addstring(s->pktout, "shell");
	    ssh2_pkt_addbool(s->pktout, 1);	       /* want reply */
	}
	ssh2_pkt_send(ssh, s->pktout);
	ssh2_queue_chanreq_handler(ssh->mainchan, ssh2_response_authconn, NULL);

	crWaitUntilV(pktin);

	if (pktin->type != SSH2_MSG_CHANNEL_SUCCESS) {
	    if (pktin->type != SSH2_MSG_CHANNEL_FAILURE) {
		bombout(("Unexpected response to shell/command request:"
			 " packet type %d", pktin->type));

	if (!conf_get_int(ssh->conf, CONF_nopty)) {
	    if (ssh->version == 1) {
		send_packet(ssh, SSH1_CMSG_WINDOW_SIZE,
			    PKT_INT, ssh->term_height,
			    PKT_INT, ssh->term_width,
			    PKT_INT, 0, PKT_INT, 0, PKT_END);
	    } else if (ssh->mainchan) {
		pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
		ssh2_pkt_adduint32(pktout, ssh->mainchan->remoteid);
		ssh2_pkt_addstring(pktout, "window-change");
		ssh2_pkt_addbool(pktout, 0);
		ssh2_pkt_adduint32(pktout, ssh->term_width);
		ssh2_pkt_adduint32(pktout, ssh->term_height);
		ssh2_pkt_adduint32(pktout, 0);
		ssh2_pkt_adduint32(pktout, 0);
		ssh2_pkt_send(ssh, pktout);
	    }
	}

	}
    } 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 SSH-1");
	} else if (ssh->mainchan) {
	    pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
	    ssh2_pkt_adduint32(pktout, ssh->mainchan->remoteid);
	    ssh2_pkt_addstring(pktout, "break");
	    ssh2_pkt_addbool(pktout, 0);
	    ssh2_pkt_adduint32(pktout, 0);   /* default break length */
	    ssh2_pkt_send(ssh, pktout);
	}
    } else {
	/* Is is a POSIX signal? */
	char *signame = NULL;
	if (code == TS_SIGABRT) signame = "ABRT";

	if (code == TS_SIGUSR1) signame = "USR1";
	if (code == TS_SIGUSR2) signame = "USR2";
	/* The SSH-2 protocol does in principle support arbitrary named
	 * signals, including signame@domain, but we don't support those. */
	if (signame) {
	    /* It's a signal. */
	    if (ssh->version == 2 && ssh->mainchan) {
		pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
		ssh2_pkt_adduint32(pktout, ssh->mainchan->remoteid);
		ssh2_pkt_addstring(pktout, "signal");
		ssh2_pkt_addbool(pktout, 0);
		ssh2_pkt_addstring(pktout, signame);
		ssh2_pkt_send(ssh, pktout);
		logeventf(ssh, "Sent signal SIG%s", signame);
	    }
	} else {
	    /* Never heard of it. Do nothing */
	}