unsigned sport, dport;
    char dhost[256];
};

struct Packet {
    long length;
    int type;

    unsigned char *data;
    unsigned char *body;
    long savedpos;
    long maxlen;

    /*
     * State associated with packet logging
     */
    int logmode;
    int nblanks;
    struct logblank_t *blanks;
};

static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen,
			  struct Packet *pktin);
static void ssh2_protocol(Ssh ssh, unsigned char *in, int inlen,
			  struct Packet *pktin);


static void ssh_size(void *handle, int width, int height);
static void ssh_special(void *handle, Telnet_Special);
static int ssh2_try_send(struct ssh_channel *c);
static void ssh2_add_channel_data(struct ssh_channel *c, char *buf, int len);
static void ssh_throttle_all(Ssh ssh, int enable, int bufsize);
static void ssh2_set_window(struct ssh_channel *c, unsigned newwin);
static int ssh_sendbuffer(void *handle);

struct rdpkt2_state_tag {
    long len, pad, payload, packetlen, maclen;
    int i;
    int cipherblk;
    unsigned long incoming_sequence;
    struct Packet *pktin;
};



struct ssh_tag {
    const struct plug_function_table *fn;
    /* the above field _must_ be first in the structure */

    SHA_State exhash, exhashbase;

    int v1_stdout_throttling;
    int v2_outgoing_sequence;

    int ssh1_rdpkt_crstate;
    int ssh2_rdpkt_crstate;
    int do_ssh_init_crstate;
    int ssh_gotdata_crstate;
    int ssh1_protocol_crstate;
    int do_ssh1_login_crstate;

    int do_ssh2_transport_crstate;
    int do_ssh2_authconn_crstate;

    void *do_ssh_init_state;
    void *do_ssh1_login_state;
    void *do_ssh2_transport_state;
    void *do_ssh2_authconn_state;

    struct rdpkt1_state_tag rdpkt1_state;
    struct rdpkt2_state_tag rdpkt2_state;




    void (*protocol) (Ssh ssh, unsigned char *in, int inlen,
		      struct Packet *pkt);
    struct Packet *(*s_rdpkt) (Ssh ssh, unsigned char **data, int *datalen);

    /*
     * We maintain a full _copy_ of a Config structure here, not
     * merely a pointer to it. That way, when we're passed a new
     * one for reconfiguration, we can check the differences and
     * potentially reconfigure port forwardings etc in mid-session.
     */
    Config cfg;

    /*
     * Used to transfer data back from async agent callbacks.
     */
    void *agent_response;
    int agent_response_len;






};

#define logevent(s) logevent(ssh->frontend, s)

/* logevent, only printf-formatted. */
static void logeventf(Ssh ssh, const char *fmt, ...)
{

 */
static struct Packet *ssh1_rdpkt(Ssh ssh, unsigned char **data, int *datalen)
{
    struct rdpkt1_state_tag *st = &ssh->rdpkt1_state;

    crBegin(ssh->ssh1_rdpkt_crstate);

  next_packet:

    st->pktin = ssh_new_packet();

    st->pktin->type = 0;
    st->pktin->length = 0;

    for (st->i = st->len = 0; st->i < 4; st->i++) {
	while ((*datalen) == 0)

	log_packet(ssh->logctx,
		   PKT_INCOMING, st->pktin->type,
		   ssh1_pkt_type(st->pktin->type),
		   st->pktin->body, st->pktin->length,
		   nblanks, &blank);
    }

    if (st->pktin->type == SSH1_SMSG_STDOUT_DATA ||
	st->pktin->type == SSH1_SMSG_STDERR_DATA ||
	st->pktin->type == SSH1_MSG_DEBUG ||
	st->pktin->type == SSH1_SMSG_AUTH_TIS_CHALLENGE ||
	st->pktin->type == SSH1_SMSG_AUTH_CCARD_CHALLENGE) {
	long stringlen = GET_32BIT(st->pktin->body);
	if (stringlen + 4 != st->pktin->length) {
	    bombout(("Received data packet with bogus string length"));
	    ssh_free_packet(st->pktin);
	    crStop(NULL);
	}
    }

    if (st->pktin->type == SSH1_MSG_DEBUG) {
        char *buf, *msg;
        int msglen;

        ssh_pkt_getstring(st->pktin, &msg, &msglen);
        buf = dupprintf("Remote debug message: %.*s", msglen, msg);
	logevent(buf);
        sfree(buf);

	ssh_free_packet(st->pktin);
	goto next_packet;
    } else if (st->pktin->type == SSH1_MSG_IGNORE) {
	/* do nothing */
	ssh_free_packet(st->pktin);
	goto next_packet;
    }

    if (st->pktin->type == SSH1_MSG_DISCONNECT) {
	/* log reason code in disconnect message */
	char *msg;
	int msglen;

        ssh_pkt_getstring(st->pktin, &msg, &msglen);

	bombout(("Server sent disconnect message:\n\"%.*s\"", msglen, msg));
	ssh_free_packet(st->pktin);
	crStop(NULL);
    }

    crFinish(st->pktin);
}

static struct Packet *ssh2_rdpkt(Ssh ssh, unsigned char **data, int *datalen)
{
    struct rdpkt2_state_tag *st = &ssh->rdpkt2_state;

    crBegin(ssh->ssh2_rdpkt_crstate);

  next_packet:

    st->pktin = ssh_new_packet();

    st->pktin->type = 0;
    st->pktin->length = 0;
    if (ssh->sccipher)
	st->cipherblk = ssh->sccipher->blksize;
    else

    if (ssh->scmac
	&& !ssh->scmac->verify(ssh->sc_mac_ctx, st->pktin->data, st->len + 4,
			       st->incoming_sequence)) {
	bombout(("Incorrect MAC received on packet"));
	ssh_free_packet(st->pktin);
	crStop(NULL);
    }
    st->incoming_sequence++;	       /* whether or not we MACed */


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

	}
	log_packet(ssh->logctx, PKT_INCOMING, st->pktin->type,
		   ssh2_pkt_type(ssh->pkt_ctx, st->pktin->type),
		   st->pktin->data+6, st->pktin->length-6,
		   nblanks, &blank);
    }

    switch (st->pktin->type) {
        /*
         * These packets we must handle instantly.
         */
      case SSH2_MSG_DISCONNECT:
        {
            /* log reason code in disconnect message */
            char *buf, *msg;
            int nowlen, reason, msglen;

            reason = ssh_pkt_getuint32(st->pktin);
            ssh_pkt_getstring(st->pktin, &msg, &msglen);

            if (reason > 0 && reason < lenof(ssh2_disconnect_reasons)) {
                buf = dupprintf("Received disconnect message (%s)",
				ssh2_disconnect_reasons[reason]);
            } else {
                buf = dupprintf("Received disconnect message (unknown"
				" type %d)", reason);
            }
            logevent(buf);
	    sfree(buf);
            buf = dupprintf("Disconnection message text: %n%.*s",
			    &nowlen, msglen, msg);
            logevent(buf);
            bombout(("Server sent disconnect message\ntype %d (%s):\n\"%s\"",
                     reason,
                     (reason > 0 && reason < lenof(ssh2_disconnect_reasons)) ?
                     ssh2_disconnect_reasons[reason] : "unknown",
                     buf+nowlen));
	    sfree(buf);
	    ssh_free_packet(st->pktin);
            crStop(NULL);
        }
        break;
      case SSH2_MSG_IGNORE:
	ssh_free_packet(st->pktin);
	goto next_packet;
      case SSH2_MSG_DEBUG:
	{
	    /* log the debug message */
	    char *buf, *msg;
	    int msglen;
	    int always_display;

	    /* XXX maybe we should actually take notice of this */
            always_display = ssh2_pkt_getbool(st->pktin);
            ssh_pkt_getstring(st->pktin, &msg, &msglen);

            buf = dupprintf("Remote debug message: %.*s", msglen, msg);
	    logevent(buf);
            sfree(buf);
	}
	ssh_free_packet(st->pktin);
        goto next_packet;

        /*
         * These packets we need do nothing about here.
         */
      case SSH2_MSG_UNIMPLEMENTED:
      case SSH2_MSG_SERVICE_REQUEST:
      case SSH2_MSG_SERVICE_ACCEPT:
      case SSH2_MSG_KEXINIT:
      case SSH2_MSG_NEWKEYS:
      case SSH2_MSG_KEXDH_INIT:
      case SSH2_MSG_KEXDH_REPLY:
      /* case SSH2_MSG_KEX_DH_GEX_REQUEST: duplicate case value */
      /* case SSH2_MSG_KEX_DH_GEX_GROUP: duplicate case value */
      case SSH2_MSG_KEX_DH_GEX_INIT:
      case SSH2_MSG_KEX_DH_GEX_REPLY:
      case SSH2_MSG_USERAUTH_REQUEST:
      case SSH2_MSG_USERAUTH_FAILURE:
      case SSH2_MSG_USERAUTH_SUCCESS:
      case SSH2_MSG_USERAUTH_BANNER:
      case SSH2_MSG_USERAUTH_PK_OK:
      /* case SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ: duplicate case value */
      /* case SSH2_MSG_USERAUTH_INFO_REQUEST: duplicate case value */
      case SSH2_MSG_USERAUTH_INFO_RESPONSE:
      case SSH2_MSG_GLOBAL_REQUEST:
      case SSH2_MSG_REQUEST_SUCCESS:
      case SSH2_MSG_REQUEST_FAILURE:
      case SSH2_MSG_CHANNEL_OPEN:
      case SSH2_MSG_CHANNEL_OPEN_CONFIRMATION:
      case SSH2_MSG_CHANNEL_OPEN_FAILURE:
      case SSH2_MSG_CHANNEL_WINDOW_ADJUST:
      case SSH2_MSG_CHANNEL_DATA:
      case SSH2_MSG_CHANNEL_EXTENDED_DATA:
      case SSH2_MSG_CHANNEL_EOF:
      case SSH2_MSG_CHANNEL_CLOSE:
      case SSH2_MSG_CHANNEL_REQUEST:
      case SSH2_MSG_CHANNEL_SUCCESS:
      case SSH2_MSG_CHANNEL_FAILURE:
        break;

        /*
         * For anything else we send SSH2_MSG_UNIMPLEMENTED.
         */
      default:
	{
	    struct Packet *pktout;
	    pktout = ssh2_pkt_init(SSH2_MSG_UNIMPLEMENTED);
	    ssh2_pkt_adduint32(pktout, st->incoming_sequence - 1);
	    /* UNIMPLEMENTED messages MUST appear in the same order as
	     * the messages they respond to. Hence, never queue them. */
	    ssh2_pkt_send_noqueue(ssh, pktout);
	}
        break;
    }

    crFinish(st->pktin);
}

static void ssh1_pktout_size(struct Packet *pkt, int len)
{
    int pad, biglen;

	sha_string(&ssh->exhashbase, s->vstring, strcspn(s->vstring, "\r\n"));
	sprintf(vlog, "We claim version: %s", verstring);
	logevent(vlog);
	strcat(verstring, "\012");
	logevent("Using SSH protocol version 2");
	sk_write(ssh->s, verstring, strlen(verstring));
	ssh->protocol = ssh2_protocol;

	ssh->version = 2;
	ssh->s_rdpkt = ssh2_rdpkt;
    } else {
	/*
	 * Use v1 protocol.
	 */
	char verstring[80], vlog[100];
	sprintf(verstring, "SSH-%s-%s",
		(ssh_versioncmp(s->version, "1.5") <= 0 ? s->version : "1.5"),
		sshver);
	sprintf(vlog, "We claim version: %s", verstring);
	logevent(vlog);
	strcat(verstring, "\012");

	logevent("Using SSH protocol version 1");
	sk_write(ssh->s, verstring, strlen(verstring));
	ssh->protocol = ssh1_protocol;

	ssh->version = 1;
	ssh->s_rdpkt = ssh1_rdpkt;
    }
    update_specials_menu(ssh->frontend);
    ssh->state = SSH_STATE_BEFORE_SIZE;

    sfree(s->vstring);

	Bignum challenge;
	char *commentp;
	int commentlen;
    };
    crState(do_ssh1_login_state);

    crBegin(ssh->do_ssh1_login_crstate);



    if (!pktin)
	crWaitUntil(pktin);

    if (pktin->type != SSH1_SMSG_PUBLIC_KEY) {
	bombout(("Public key packet not received"));
	crStop(0);

	    ssh1_throttle(ssh, -1);
	}
    } else {
	ssh2_set_window(c, OUR_V2_WINSIZE - bufsize);
    }
}

static void ssh1_protocol(Ssh ssh, unsigned char *in, int inlen,
			  struct Packet *pktin)
{
    crBegin(ssh->ssh1_protocol_crstate);

    random_init();

    while (!do_ssh1_login(ssh, in, inlen, pktin)) {
	crReturnV;
    }
    if (ssh->state == SSH_STATE_CLOSED)
	crReturnV;

    if (ssh->cfg.agentfwd && agent_exists()) {
	logevent("Requesting agent forwarding");
	send_packet(ssh, SSH1_CMSG_AGENT_REQUEST_FORWARDING, PKT_END);
	do {
	    crReturnV;
	} while (!pktin);

		inlen -= len;
	    }
	}
    }

    crFinishV;
}





































































/*
 * Utility routine for decoding comma-separated strings in KEXINIT.
 */
static int in_commasep_string(char *needle, char *haystack, int haylen)
{
    int needlen;

     * SSH2_MSG_NEWKEYS packet to the next layer, not because it
     * wants to see it but because it will need time to initialise
     * itself before it sees an actual packet. In subsequent key
     * exchange phases, we don't pass SSH2_MSG_NEWKEYS on, because
     * it would only confuse the layer above.
     */
    if (!s->first_kex) {
	crReturn(0);
    }
    s->first_kex = 0;

    /*
     * Now we're encrypting. Begin returning 1 to the protocol main
     * function so that other things can run on top of the
     * transport. If we ever see a KEXINIT, we must go back to the

	pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_WINDOW_ADJUST);
	ssh2_pkt_adduint32(pktout, c->remoteid);
	ssh2_pkt_adduint32(pktout, newwin - c->v.v2.locwindow);
	ssh2_pkt_send(ssh, pktout);
	c->v.v2.locwindow = newwin;
    }
}










/*
 * Handle the SSH2 userauth and connection layers.
 */
static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen,
			     struct Packet *pktin)
{

     * Now we're authenticated for the connection protocol. The
     * connection protocol will automatically have started at this
     * point; there's no need to send SERVICE_REQUEST.
     */

    ssh->channels = newtree234(ssh_channelcmp);








    /*
     * Create the main session channel.
     */
    if (!ssh->cfg.ssh_no_shell) {
	ssh->mainchan = snew(struct ssh_channel);
	ssh->mainchan->ssh = ssh;
	ssh->mainchan->localid = alloc_channel_id(ssh);

	ssh2_pkt_addbool(s->pktout, 1);	       /* want reply */
	ssh2_pkt_addbool(s->pktout, 0);	       /* many connections */
	ssh2_pkt_addstring(s->pktout, proto);
	ssh2_pkt_addstring(s->pktout, data);
	ssh2_pkt_adduint32(s->pktout, x11_get_screen_number(ssh->cfg.x11_display));
	ssh2_pkt_send(ssh, s->pktout);

	do {
	    crWaitUntilV(pktin);
	    if (pktin->type == SSH2_MSG_CHANNEL_WINDOW_ADJUST) {
		unsigned i = ssh_pkt_getuint32(pktin);
		struct ssh_channel *c;
		c = find234(ssh->channels, &i, ssh_channelfind);
		if (!c)
		    continue;	       /* nonexistent channel */
		c->v.v2.remwindow += ssh_pkt_getuint32(pktin);
	    }
	} while (pktin->type == SSH2_MSG_CHANNEL_WINDOW_ADJUST);

	if (pktin->type != SSH2_MSG_CHANNEL_SUCCESS) {
	    if (pktin->type != SSH2_MSG_CHANNEL_FAILURE) {
		bombout(("Unexpected response to X11 forwarding request:"
			 " packet type %d", pktin->type));
		crStopV;
	    }

			    ssh2_pkt_addstring(s->pktout, "0.0.0.0");
			} else {
			    ssh2_pkt_addstring(s->pktout, "127.0.0.1");
			}
			ssh2_pkt_adduint32(s->pktout, sport);
			ssh2_pkt_send(ssh, s->pktout);

			do {
			    crWaitUntilV(pktin);
			    if (pktin->type == SSH2_MSG_CHANNEL_WINDOW_ADJUST) {
				unsigned i = ssh_pkt_getuint32(pktin);
				struct ssh_channel *c;
				c = find234(ssh->channels, &i, ssh_channelfind);
				if (!c)
				    continue;/* nonexistent channel */
				c->v.v2.remwindow += ssh_pkt_getuint32(pktin);
			    }
			} while (pktin->type == SSH2_MSG_CHANNEL_WINDOW_ADJUST);

			if (pktin->type != SSH2_MSG_REQUEST_SUCCESS) {
			    if (pktin->type != SSH2_MSG_REQUEST_FAILURE) {
				bombout(("Unexpected response to port "
					 "forwarding request: packet type %d",
					 pktin->type));
				crStopV;

	logevent("Requesting OpenSSH-style agent forwarding");
	s->pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
	ssh2_pkt_adduint32(s->pktout, ssh->mainchan->remoteid);
	ssh2_pkt_addstring(s->pktout, "auth-agent-req@openssh.com");
	ssh2_pkt_addbool(s->pktout, 1);	       /* want reply */
	ssh2_pkt_send(ssh, s->pktout);

	do {
	    crWaitUntilV(pktin);
	    if (pktin->type == SSH2_MSG_CHANNEL_WINDOW_ADJUST) {
		unsigned i = ssh_pkt_getuint32(pktin);
		struct ssh_channel *c;
		c = find234(ssh->channels, &i, ssh_channelfind);
		if (!c)
		    continue;	       /* nonexistent channel */
		c->v.v2.remwindow += ssh_pkt_getuint32(pktin);
	    }
	} while (pktin->type == SSH2_MSG_CHANNEL_WINDOW_ADJUST);

	if (pktin->type != SSH2_MSG_CHANNEL_SUCCESS) {
	    if (pktin->type != SSH2_MSG_CHANNEL_FAILURE) {
		bombout(("Unexpected response to agent forwarding request:"
			 " packet type %d", pktin->type));
		crStopV;
	    }

	ssh2_pkt_adduint32(s->pktout, ssh->ispeed);
	ssh2_pkt_addbyte(s->pktout, 129);	       /* TTY_OP_OSPEED */
	ssh2_pkt_adduint32(s->pktout, ssh->ospeed);
	ssh2_pkt_addstring_data(s->pktout, "\0", 1); /* TTY_OP_END */
	ssh2_pkt_send(ssh, s->pktout);
	ssh->state = SSH_STATE_INTERMED;

	do {
	    crWaitUntilV(pktin);
	    if (pktin->type == SSH2_MSG_CHANNEL_WINDOW_ADJUST) {
		unsigned i = ssh_pkt_getuint32(pktin);
		struct ssh_channel *c;
		c = find234(ssh->channels, &i, ssh_channelfind);
		if (!c)
		    continue;	       /* nonexistent channel */
		c->v.v2.remwindow += ssh_pkt_getuint32(pktin);
	    }
	} while (pktin->type == SSH2_MSG_CHANNEL_WINDOW_ADJUST);

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

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

	s->env_ok = 0;
	s->env_left = s->num_env;

	while (s->env_left > 0) {
	    do {
		crWaitUntilV(pktin);
		if (pktin->type == SSH2_MSG_CHANNEL_WINDOW_ADJUST) {
		    unsigned i = ssh_pkt_getuint32(pktin);
		    struct ssh_channel *c;
		    c = find234(ssh->channels, &i, ssh_channelfind);
		    if (!c)
			continue;	       /* nonexistent channel */
		    c->v.v2.remwindow += ssh_pkt_getuint32(pktin);
		}
	    } while (pktin->type == SSH2_MSG_CHANNEL_WINDOW_ADJUST);

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

	    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);
	do {
	    crWaitUntilV(pktin);
	    if (pktin->type == SSH2_MSG_CHANNEL_WINDOW_ADJUST) {
		unsigned i = ssh_pkt_getuint32(pktin);
		struct ssh_channel *c;
		c = find234(ssh->channels, &i, ssh_channelfind);
		if (!c)
		    continue;	       /* nonexistent channel */
		c->v.v2.remwindow += ssh_pkt_getuint32(pktin);
	    }
	} while (pktin->type == SSH2_MSG_CHANNEL_WINDOW_ADJUST);
	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));
		crStopV;
	    }
	    /*

		    ssh2_pkt_addstring(s->pktout, "en");	/* language tag */
		    ssh2_pkt_send_noqueue(ssh, s->pktout);
#endif
                    ssh_closing((Plug)ssh, NULL, 0, 0);
		    crStopV;
		}
		continue;	       /* remote sends close; ignore (FIXME) */
	    } else if (pktin->type == SSH2_MSG_CHANNEL_WINDOW_ADJUST) {
		unsigned i = ssh_pkt_getuint32(pktin);
		struct ssh_channel *c;
		c = find234(ssh->channels, &i, ssh_channelfind);
		if (!c || c->closes)
		    continue;	       /* nonexistent or closing channel */
		c->v.v2.remwindow += ssh_pkt_getuint32(pktin);
		s->try_send = TRUE;
	    } else if (pktin->type == SSH2_MSG_CHANNEL_OPEN_CONFIRMATION) {
		unsigned i = ssh_pkt_getuint32(pktin);
		struct ssh_channel *c;
		c = find234(ssh->channels, &i, ssh_channelfind);
		if (!c)
		    continue;	       /* nonexistent channel */
		if (c->type != CHAN_SOCKDATA_DORMANT)

		}
	    }
	}
    }

    crFinishV;
}

/*




























































 * Handle the top-level SSH2 protocol.
 */
























































static void ssh2_protocol(Ssh ssh, unsigned char *in, int inlen,
			  struct Packet *pktin)
{


    if (do_ssh2_transport(ssh, in, inlen, pktin) == 0)


	return;













    do_ssh2_authconn(ssh, in, inlen, pktin);

}

/*
 * Called to set up the connection.
 *
 * Returns an error message, or NULL on success.
 */

    ssh->x11auth = NULL;
    ssh->v1_compressing = FALSE;
    ssh->v2_outgoing_sequence = 0;
    ssh->ssh1_rdpkt_crstate = 0;
    ssh->ssh2_rdpkt_crstate = 0;
    ssh->do_ssh_init_crstate = 0;
    ssh->ssh_gotdata_crstate = 0;
    ssh->ssh1_protocol_crstate = 0;
    ssh->do_ssh1_login_crstate = 0;
    ssh->do_ssh2_transport_crstate = 0;
    ssh->do_ssh2_authconn_crstate = 0;
    ssh->do_ssh_init_state = NULL;
    ssh->do_ssh1_login_state = NULL;
    ssh->do_ssh2_transport_state = NULL;
    ssh->do_ssh2_authconn_state = NULL;

    ssh->editing = 0;
    ssh->echoing = 0;
    ssh->v1_throttle_count = 0;
    ssh->overall_bufsize = 0;
    ssh->fallback_cmd = 0;

    ssh->protocol = NULL;



    p = connect_to_host(ssh, host, port, realhost, nodelay, keepalive);
    if (p != NULL)
	return p;

    return NULL;
}