C++ Proxy_Socket::negotiate方法代码示例

static int plug_proxy_accepting(Plug p, OSSocket sock) {
	Proxy_Plug pp = (Proxy_Plug) p;
	Proxy_Socket ps = pp->proxy_socket;

	if (ps->state != PROXY_STATE_ACTIVE) {
		ps->accepting_sock = sock;
		return ps->negotiate(ps, PROXY_CHANGE_ACCEPTING);
	}
	return plug_accepting(ps->plug, sock);
}

static void plug_proxy_sent(Plug p, int bufsize) {
	Proxy_Plug pp = (Proxy_Plug) p;
	Proxy_Socket ps = pp->proxy_socket;

	if (ps->state != PROXY_STATE_ACTIVE) {
		ps->sent_bufsize = bufsize;
		ps->negotiate(ps, PROXY_CHANGE_SENT);
		return;
	}
	plug_sent(ps->plug, bufsize);
}

static int plug_proxy_accepting(Plug p,
                                accept_fn_t constructor, accept_ctx_t ctx)
{
    Proxy_Plug pp = (Proxy_Plug) p;
    Proxy_Socket ps = pp->proxy_socket;

    if (ps->state != PROXY_STATE_ACTIVE) {
	ps->accepting_constructor = constructor;
	ps->accepting_ctx = ctx;
	return ps->negotiate(ps, PROXY_CHANGE_ACCEPTING);
    }
    return plug_accepting(ps->plug, constructor, ctx);
}

static int plug_proxy_closing(Plug p, const char *error_msg, int error_code,
		int calling_back) {
	Proxy_Plug pp = (Proxy_Plug) p;
	Proxy_Socket ps = pp->proxy_socket;

	if (ps->state != PROXY_STATE_ACTIVE) {
		ps->closing_error_msg = error_msg;
		ps->closing_error_code = error_code;
		ps->closing_calling_back = calling_back;
		return ps->negotiate(ps, PROXY_CHANGE_CLOSING);
	}
	return plug_closing(ps->plug, error_msg, error_code, calling_back);
}

static int plug_proxy_receive(Plug p, int urgent, byte *data, int len) {
	Proxy_Plug pp = (Proxy_Plug) p;
	Proxy_Socket ps = pp->proxy_socket;

	if (ps->state != PROXY_STATE_ACTIVE) {
		/* we will lose the urgentness of this data, but since most,
		 * if not all, of this data will be consumed by the negotiation
		 * process, hopefully it won't affect the protocol above us
		 */
		bufchain_add(&ps->pending_input_data, data, len);
		ps->receive_urgent = urgent;
		ps->receive_data = data;
		ps->receive_len = len;
		return ps->negotiate(ps, PROXY_CHANGE_RECEIVE);
	}
	return plug_receive(ps->plug, urgent, data, len);
}

Socket new_connection(SockAddr addr,
                      const char *hostname,
                      int port,
                      int privport,
                      int oobinline,
                      int nodelay,
                      int keepalive,
                      Plug plug,
                      Conf *conf)
{
  static const struct socket_function_table socket_fn_table = {
      sk_proxy_plug,
      sk_proxy_close,
      sk_proxy_write,
      sk_proxy_write_oob,
      sk_proxy_write_eof,
      sk_proxy_flush,
      sk_proxy_set_frozen,
      sk_proxy_socket_error,
      NULL, /* peer_info */
  };

  static const struct plug_function_table plug_fn_table = {
      plug_proxy_log,
      plug_proxy_closing,
      plug_proxy_receive,
      plug_proxy_sent,
      plug_proxy_accepting};

  if (conf_get_int(conf, CONF_proxy_type) != PROXY_NONE &&
      proxy_for_destination(addr, hostname, port, conf)) {
    Proxy_Socket ret;
    Proxy_Plug pplug;
    SockAddr proxy_addr;
    char *proxy_canonical_name;
    const char *proxy_type;
    Socket sret;
    int type;

    if ((sret = platform_new_connection(addr,
                                        hostname,
                                        port,
                                        privport,
                                        oobinline,
                                        nodelay,
                                        keepalive,
                                        plug,
                                        conf)) != NULL)
      return sret;

    ret = snew(struct Socket_proxy_tag);
    ret->fn = &socket_fn_table;
    ret->conf = conf_copy(conf);
    ret->plug = plug;
    ret->remote_addr = addr; /* will need to be freed on close */
    ret->remote_port = port;

    ret->error = NULL;
    ret->pending_flush = 0;
    ret->pending_eof = 0;
    ret->freeze = 0;

    bufchain_init(&ret->pending_input_data);
    bufchain_init(&ret->pending_output_data);
    bufchain_init(&ret->pending_oob_output_data);

    ret->sub_socket = NULL;
    ret->state = PROXY_STATE_NEW;
    ret->negotiate = NULL;

    type = conf_get_int(conf, CONF_proxy_type);
    if (type == PROXY_HTTP) {
      ret->negotiate = proxy_http_negotiate;
      proxy_type = "HTTP";
    } else if (type == PROXY_SOCKS4) {
      ret->negotiate = proxy_socks4_negotiate;
      proxy_type = "SOCKS 4";
    } else if (type == PROXY_SOCKS5) {
      ret->negotiate = proxy_socks5_negotiate;
      proxy_type = "SOCKS 5";
    } else if (type == PROXY_TELNET) {
      ret->negotiate = proxy_telnet_negotiate;
      proxy_type = "Telnet";
    } else {
      ret->error = "Proxy error: Unknown proxy method";
      return (Socket)ret;
    }

    {
      char *logmsg = dupprintf("Will use %s proxy at %s:%d to connect"
                               " to %s:%d",
                               proxy_type,
                               conf_get_str(conf, CONF_proxy_host),
                               conf_get_int(conf, CONF_proxy_port),
                               hostname,
                               port);
      plug_log(plug, 2, NULL, 0, logmsg, 0);
      sfree(logmsg);
    }

//.........这里部分代码省略.........

Socket new_connection(SockAddr addr, char *hostname,
		      int port, int privport,
		      int oobinline, int nodelay, int keepalive,
		      Plug plug, const Config *cfg)
{
    static const struct socket_function_table socket_fn_table = {
	sk_proxy_plug,
	sk_proxy_close,
	sk_proxy_write,
	sk_proxy_write_oob,
	sk_proxy_flush,
	sk_proxy_set_private_ptr,
	sk_proxy_get_private_ptr,
	sk_proxy_set_frozen,
	sk_proxy_socket_error
    };

    static const struct plug_function_table plug_fn_table = {
	plug_proxy_log,
	plug_proxy_closing,
	plug_proxy_receive,
	plug_proxy_sent,
	plug_proxy_accepting
    };

    if (cfg->proxy_type != PROXY_NONE &&
	proxy_for_destination(addr, hostname, port, cfg))
    {
	Proxy_Socket ret;
	Proxy_Plug pplug;
	SockAddr proxy_addr;
	char *proxy_canonical_name;
	Socket sret;

	if ((sret = platform_new_connection(addr, hostname, port, privport,
					    oobinline, nodelay, keepalive,
					    plug, cfg)) !=
	    NULL)
	    return sret;

	ret = snew(struct Socket_proxy_tag);
	ret->fn = &socket_fn_table;
	ret->cfg = *cfg;	       /* STRUCTURE COPY */
	ret->plug = plug;
	ret->remote_addr = addr;       /* will need to be freed on close */
	ret->remote_port = port;

	ret->error = NULL;
	ret->pending_flush = 0;
	ret->freeze = 0;

	bufchain_init(&ret->pending_input_data);
	bufchain_init(&ret->pending_output_data);
	bufchain_init(&ret->pending_oob_output_data);

	ret->sub_socket = NULL;
	ret->state = PROXY_STATE_NEW;
	ret->negotiate = NULL;
	
	if (cfg->proxy_type == PROXY_HTTP) {
	    ret->negotiate = proxy_http_negotiate;
	} else if (cfg->proxy_type == PROXY_SOCKS4) {
            ret->negotiate = proxy_socks4_negotiate;
	} else if (cfg->proxy_type == PROXY_SOCKS5) {
            ret->negotiate = proxy_socks5_negotiate;
	} else if (cfg->proxy_type == PROXY_TELNET) {
	    ret->negotiate = proxy_telnet_negotiate;
	} else {
	    ret->error = "Proxy error: Unknown proxy method";
	    return (Socket) ret;
	}

	/* create the proxy plug to map calls from the actual
	 * socket into our proxy socket layer */
	pplug = snew(struct Plug_proxy_tag);
	pplug->fn = &plug_fn_table;
	pplug->proxy_socket = ret;

	/* look-up proxy */
	proxy_addr = sk_namelookup(cfg->proxy_host,
				   &proxy_canonical_name, cfg->addressfamily);
	if (sk_addr_error(proxy_addr) != NULL) {
	    ret->error = "Proxy error: Unable to resolve proxy host name";
	    return (Socket)ret;
	}
	sfree(proxy_canonical_name);

	/* create the actual socket we will be using,
	 * connected to our proxy server and port.
	 */
	ret->sub_socket = sk_new(proxy_addr, cfg->proxy_port,
				 privport, oobinline,
				 nodelay, keepalive, (Plug) pplug);
	if (sk_socket_error(ret->sub_socket) != NULL)
	    return (Socket) ret;

	/* start the proxy negotiation process... */
	sk_set_frozen(ret->sub_socket, 0);
	ret->negotiate(ret, PROXY_CHANGE_NEW);

//.........这里部分代码省略.........