*/
struct ssh_portfwd {
    int keep;
    int type;
    unsigned sport, dport;
    char *saddr, *daddr;
    struct ssh_rportfwd *remote;
    int addressfamily;
    void *local;
};
#define free_portfwd(pf) ( \
    ((pf) ? (sfree((pf)->saddr), sfree((pf)->daddr)) : (void)0 ), sfree(pf) )

struct Packet {
    long length;

    if (port < 0)
	port = 22;		       /* default ssh port */
    ssh->savedport = port;

    /*
     * Try to find host.
     */
    logeventf(ssh, "Looking up host \"%s\"", host);
    addr = name_lookup(host, port, realhost, &ssh->cfg);
    logeventf(ssh, "Looking up host \"%s\"%s", host,
	      (ssh->cfg.addressfamily == ADDRTYPE_IPV4 ? " (IPv4)" :
	       (ssh->cfg.addressfamily == ADDRTYPE_IPV6 ? " (IPv6)" : "")));
    addr = name_lookup(host, port, realhost, &ssh->cfg,
		       ssh->cfg.addressfamily);
    if ((err = sk_addr_error(addr)) != NULL) {
	sk_addr_free(addr);
	return err;
    }

    /*
     * Open socket.

	assert(rpf == pf);
	free_rportfwd(pf);
    }
}

static void ssh_setup_portfwd(Ssh ssh, const Config *cfg)
{
    char type;
    char address_family, type;
    int n;
    int sport,dport,sserv,dserv;
    char sports[256], dports[256], saddr[256], host[256];
    const char *portfwd_strptr;

    portfwd_strptr = cfg->portfwd;

	struct ssh_portfwd *epf;
	int i;
	for (i = 0; (epf = index234(ssh->portfwds, i)) != NULL; i++)
	    epf->keep = FALSE;
    }

    while (*portfwd_strptr) {
	address_family = 'A';
	type = 'L';
	while (*portfwd_strptr && *portfwd_strptr != '\t') {
	    if (*portfwd_strptr == 'A' ||
		*portfwd_strptr == '4' ||
		*portfwd_strptr == '6')
		address_family = *portfwd_strptr;
	    else if (*portfwd_strptr == 'L' ||
		*portfwd_strptr == 'R' ||
		*portfwd_strptr == 'D')
	type = *portfwd_strptr++;
		type = *portfwd_strptr;
	    portfwd_strptr++;
	}

	saddr[0] = '\0';

	n = 0;
	while (*portfwd_strptr && *portfwd_strptr != '\t') {
	    if (*portfwd_strptr == ':') {
		/*
		 * We've seen a colon in the middle of the
		 * source port number. This means that
		 * everything we've seen until now is the

	    pfrec->type = type;
	    pfrec->saddr = *saddr ? dupstr(saddr) : NULL;
	    pfrec->sport = sport;
	    pfrec->daddr = dupstr(host);
	    pfrec->dport = dport;
	    pfrec->local = NULL;
	    pfrec->remote = NULL;
	    pfrec->addressfamily = (address_family == '4' ? ADDRTYPE_IPV4 :
				    address_family == '6' ? ADDRTYPE_IPV6 :
				    ADDRTYPE_UNSPEC);

	    epfrec = add234(ssh->portfwds, pfrec);
	    if (epfrec != pfrec) {
		/*
		 * We already have a port forwarding with precisely
		 * these parameters. Hence, no need to do anything;
		 * simply tag the existing one as `keep'.
		 */
		epfrec->keep = TRUE;
		free_portfwd(pfrec);
	    } else if (type == 'L') {
		/* Verbose description of the destination port */
		char *dportdesc = dupprintf("%s:%.*s%.*s%d%.*s",
					    host,
					    (int)(dserv ? strlen(dports) : 0), dports,
					    dserv, "(", dport, dserv, ")");
		const char *err = pfd_addforward(host, dport,
						 *saddr ? saddr : NULL,
						 sport, ssh, &ssh->cfg,
						 &pfrec->local);
		if (err) {
		    logeventf(ssh, "Local port %s forward to %s"
						 &pfrec->local,
						 pfrec->addressfamily);

		logeventf(ssh, "Local %sport %s forward to %s%s%s",
			      " failed: %s", sportdesc, dportdesc, err);
		} else {
		    logeventf(ssh, "Local port %s forwarding to %s",
			      sportdesc, dportdesc);
		}
			  pfrec->addressfamily == ADDRTYPE_IPV4 ? "IPv4 " :
			  pfrec->addressfamily == ADDRTYPE_IPV6 ? "IPv6 " : "",
			  sportdesc, dportdesc,
			  err ? " failed: " : "", err);

		sfree(dportdesc);
	    } else if (type == 'D') {
		const char *err = pfd_addforward(NULL, -1,
						 *saddr ? saddr : NULL,
						 sport, ssh, &ssh->cfg,
						 &pfrec->local);
		if (err) {
		    logeventf(ssh, "Local port %s SOCKS dynamic forward"
						 &pfrec->local,
						 pfrec->addressfamily);

			      " setup failed: %s", sportdesc, err);
		} else {
		    logeventf(ssh, "Local port %s doing SOCKS"
			      " dynamic forwarding", sportdesc);
			logeventf(ssh, "Local %sport %s SOCKS dynamic forward%s%s",
				  pfrec->addressfamily == ADDRTYPE_IPV4 ? "IPv4 " :
				  pfrec->addressfamily == ADDRTYPE_IPV6 ? "IPv6 " : "",
				  sportdesc,
		}
				  err ? " setup failed: " : "", err);
	    } else {
		struct ssh_rportfwd *pf;

		/*
		 * Ensure the remote port forwardings tree exists.
		 */
		if (!ssh->rportfwds) {

}

static void ssh1_msg_port_open(Ssh ssh, struct Packet *pktin)
{
    /* Remote side is trying to open a channel to talk to a
     * forwarded port. Give them back a local channel number. */
    struct ssh_channel *c;
    struct ssh_rportfwd pf;
    struct ssh_rportfwd pf, *pfp;
    int remoteid;
    int hostsize, port;
    char *host, buf[1024];
    const char *e;
    c = snew(struct ssh_channel);
    c->ssh = ssh;

    remoteid = ssh_pkt_getuint32(pktin);
    ssh_pkt_getstring(pktin, &host, &hostsize);
    port = ssh_pkt_getuint32(pktin);

    if (hostsize >= lenof(pf.dhost))
	hostsize = lenof(pf.dhost)-1;
    memcpy(pf.dhost, host, hostsize);
    pf.dhost[hostsize] = '\0';
    pf.dport = port;
    pfp = find234(ssh->rportfwds, &pf, NULL);

    if (find234(ssh->rportfwds, &pf, NULL) == NULL) {
    if (pfp == NULL) {
	sprintf(buf, "Rejected remote port open request for %s:%d",
		pf.dhost, port);
	logevent(buf);
	send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
		    PKT_INT, remoteid, PKT_END);
    } else {
	sprintf(buf, "Received remote port open request for %s:%d",
		pf.dhost, port);
	logevent(buf);
	e = pfd_newconnect(&c->u.pfd.s, pf.dhost, port,
			   c, &ssh->cfg);
			   c, &ssh->cfg, pfp->pfrec->addressfamily);
	if (e != NULL) {
	    char buf[256];
	    sprintf(buf, "Port open failed: %s", e);
	    logevent(buf);
	    sfree(c);
	    send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
			PKT_INT, remoteid, PKT_END);

		  "from %s:%d", pf.sport, peeraddr, peerport);
	if (realpf == NULL) {
	    error = "Remote port is not recognised";
	} else {
	    const char *e = pfd_newconnect(&c->u.pfd.s,
					   realpf->dhost,
					   realpf->dport, c,
					   &ssh->cfg);
					   &ssh->cfg,
					   realpf->pfrec->addressfamily);
	    logeventf(ssh, "Attempting to forward remote port to "
		      "%s:%d", realpf->dhost, realpf->dport);
	    if (e != NULL) {
		logeventf(ssh, "Port open failed: %s", e);
		error = "Port open failed";
	    } else {
		logevent("Forwarded port opened successfully");