自学教程：C++ uv_tcp_connect函数代码示例

  static void connect(uv_tcp_t* handle, const Address& address, void* data,                      Callback cb) {    Connector* connector = new Connector(address, data, cb);    int rc = 0;#if UV_VERSION_MAJOR == 0    if (address.family() == AF_INET) {      rc = uv_tcp_connect(&connector->req_, handle, *address.addr_in(),                          on_connect);    } else {      rc = uv_tcp_connect6(&connector->req_, handle, *address.addr_in6(),                           on_connect);    }#else    rc = uv_tcp_connect(&connector->req_, handle, address.addr(),                        on_connect);#endif    if (rc != 0) {      connector->status_ = -1;      connector->cb_(connector);      delete connector;    }  }

VALUE rbuv_tcp_connect(VALUE self, VALUE ip, VALUE port) {  VALUE block;  const char *uv_ip;  int uv_port;  rbuv_tcp_t *rbuv_tcp;  struct sockaddr_in connect_addr;  uv_connect_t *uv_connect;  rb_need_block();  block = rb_block_proc();  uv_ip = RSTRING_PTR(ip);  uv_port = FIX2INT(port);  Data_Get_Struct(self, rbuv_tcp_t, rbuv_tcp);  rbuv_tcp->cb_on_connection = block;  uv_connect = malloc(sizeof(*uv_connect));  connect_addr = uv_ip4_addr(uv_ip, uv_port);  RBUV_CHECK_UV_RETURN(uv_tcp_connect(uv_connect, rbuv_tcp->uv_handle,                                      connect_addr, _uv_tcp_on_connect));  RBUV_DEBUG_LOG_DETAIL("self: %s, ip: %s, port: %d, rbuv_tcp: %p, uv_handle: %p",                        RSTRING_PTR(rb_inspect(self)), uv_ip, uv_port, rbuv_tcp,                        rbuv_tcp->uv_handle);  return self;}

static void connection_fail(uv_connect_cb connect_cb) {  struct sockaddr_in client_addr, server_addr;  int r;  ASSERT(0 == uv_ip4_addr("0.0.0.0", 0, &client_addr));  /* There should be no servers listening on this port. */  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));  /* Try to connect to the server and do NUM_PINGS ping-pongs. */  r = uv_tcp_init(uv_default_loop(), &tcp);  ASSERT(!r);  /* We are never doing multiple reads/connects at a time anyway. */  /* so these handles can be pre-initialized. */  ASSERT(0 == uv_tcp_bind(&tcp, (const struct sockaddr*) &client_addr));  r = uv_tcp_connect(&req,                     &tcp,                     (const struct sockaddr*) &server_addr,                     connect_cb);  ASSERT(!r);  uv_run(uv_default_loop(), UV_RUN_DEFAULT);  ASSERT(connect_cb_calls == 1);  ASSERT(close_cb_calls == 1);}

static void pinger_new() {  int r;  struct sockaddr_in client_addr = uv_ip4_addr("0.0.0.0", 0);  struct sockaddr_in server_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);  pinger_t *pinger;  pinger = (pinger_t*)malloc(sizeof(*pinger));  pinger->state = 0;  pinger->pongs = 0;  /* Try to connec to the server and do NUM_PINGS ping-pongs. */  r = uv_tcp_init(&pinger->tcp);  ASSERT(!r);  pinger->tcp.data = pinger;  /* We are never doing multiple reads/connects at a time anyway. */  /* so these handles can be pre-initialized. */  uv_req_init(&pinger->connect_req, (uv_handle_t*)&pinger->tcp,      pinger_connect_cb);  uv_tcp_bind(&pinger->tcp, client_addr);  r = uv_tcp_connect(&pinger->connect_req, server_addr);  ASSERT(!r);}

void stream_client_do_connect_nonblocking(        skyray_stream_client_t *self, zend_object *protocol_obj,        zend_string *host, zend_long port, zval *return_value){    skyray_reactor_t *reactor = skyray_reactor_from_obj(Z_OBJ_P(self->reactor));    zval zstream;    object_init_ex(&zstream, skyray_ce_Stream);    skyray_stream_t * stream = skyray_stream_from_obj(Z_OBJ(zstream));    skyray_stream_init_nonblocking(stream, SR_TCP, reactor, protocol_obj);    struct sockaddr_in addr;    uv_ip4_addr(host->val, port, &addr);    uv_connect_t *req = (uv_connect_t*)emalloc(sizeof(uv_connect_t));    req->type = UV_TCP;    req->data = stream;    uv_tcp_connect(req, &stream->tcp, (struct sockaddr*)&addr, on_connected);    ZVAL_COPY(return_value, &zstream);}

static void tcp_make_connect(conn_rec* p) {  struct sockaddr_in addr;  tcp_conn_rec* tp;  int r;  tp = (tcp_conn_rec*) p;  r = uv_tcp_init(loop, (uv_tcp_t*)&p->stream);  ASSERT(r == 0);  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));  r = uv_tcp_connect(&tp->conn_req,                     (uv_tcp_t*) &p->stream,                     (const struct sockaddr*) &addr,                     connect_cb);  if (r) {    fprintf(stderr, "uv_tcp_connect error %s/n", uv_err_name(r));    ASSERT(0);  }#if DEBUG  printf("make connect %d/n", p->i);#endif  p->conn_req.data = p;  p->write_req.data = p;  p->stream.data = p;}

void make_client(Stack* stack){    printf("make_client/n");    Connection* connection = new Connection();    ca_assert(stack->world->libuvWorld->uv_loop != NULL);    uv_tcp_init(stack->world->libuvWorld->uv_loop, &connection->uv_tcp);    connection->uv_tcp.data = connection;    Value* ip = circa_input(stack, 0);    Value* port = circa_input(stack, 1);    sockaddr_in bind_addr = uv_ip4_addr(circa_string(ip), circa_int(port));#if 0    if (uv_ip4_addr(circa_string(ip), circa_int(port), &bind_addr)) {        printf("error from uv_ip4_addr/n");        return;    }#endif    uv_connect_t* uv_connect = (uv_connect_t*) malloc(sizeof(*uv_connect));    uv_connect->data = connection;    if (uv_tcp_connect(uv_connect, &connection->uv_tcp, bind_addr, client_on_connect)) {        printf("uv_tcp_connect error/n");    }    Value* out = circa_set_default_output(stack, 0);    circa_set_native_ptr(circa_index(out, 0), connection, ConnectionRelease);    printf("make_client fin/n");}

static void socket_connect(MVMThreadContext *tc, MVMOSHandle *h, MVMString *host, MVMint64 port) {    MVMIOSyncSocketData *data = (MVMIOSyncSocketData *)h->body.data;    if (!data->ss.handle) {        struct sockaddr *dest    = MVM_io_resolve_host_name(tc, host, port);        uv_tcp_t        *socket  = MVM_malloc(sizeof(uv_tcp_t));        uv_connect_t    *connect = MVM_malloc(sizeof(uv_connect_t));        int r;        data->ss.cur_tc = tc;        connect->data   = data;        if ((r = uv_tcp_init(tc->loop, socket)) < 0 ||                (r = uv_tcp_connect(connect, socket, dest, on_connect)) < 0) {            MVM_free(socket);            MVM_free(connect);            MVM_free(dest);            MVM_exception_throw_adhoc(tc, "Failed to connect: %s", uv_strerror(r));        }        uv_ref((uv_handle_t *)socket);        uv_run(tc->loop, UV_RUN_DEFAULT);        data->ss.handle = (uv_stream_t *)socket;        MVM_free(connect);        MVM_free(dest);    }    else {        MVM_exception_throw_adhoc(tc, "Socket is already bound or connected");    }}

static void pinger_new(void) {  struct sockaddr_in client_addr;  struct sockaddr_in server_addr;  pinger_t *pinger;  int r;  ASSERT(0 == uv_ip4_addr("0.0.0.0", 0, &client_addr));  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));  pinger = malloc(sizeof(*pinger));  pinger->state = 0;  pinger->pongs = 0;  /* Try to connect to the server and do NUM_PINGS ping-pongs. */  r = uv_tcp_init(loop, &pinger->tcp);  ASSERT(!r);  pinger->tcp.data = pinger;  uv_tcp_bind(&pinger->tcp, &client_addr);  r = uv_tcp_connect(&pinger->connect_req,                     &pinger->tcp,                     &server_addr,                     pinger_connect_cb);  ASSERT(!r);}

int uvplus_tcp::connect(const struct sockaddr *addr, std::function<void(uvplus_tcp *self, int status)> connect_callback) {  uv_connect_t *req = new uv_connect_t;  auto connect_callback_ptr = new std::function<void(uvplus_tcp *self, int status)>(connect_callback);  auto tcp = (uv_tcp_t *)context_ptr();  req->data = static_cast<void *>(connect_callback_ptr);  return uv_tcp_connect(req, tcp, addr, connect_cb);}

static void maybe_connect_some() {  uv_connect_t* req;  uv_tcp_t* tcp;  uv_pipe_t* pipe;  int r;  while (max_connect_socket < TARGET_CONNECTIONS &&         max_connect_socket < write_sockets + MAX_SIMULTANEOUS_CONNECTS) {    if (type == TCP) {      tcp = &tcp_write_handles[max_connect_socket++];      r = uv_tcp_init(tcp);      ASSERT(r == 0);      req = (uv_connect_t*) req_alloc();      r = uv_tcp_connect(req, tcp, connect_addr, connect_cb);      ASSERT(r == 0);    } else {      pipe = &pipe_write_handles[max_connect_socket++];      r = uv_pipe_init(pipe);      ASSERT(r == 0);      req = (uv_connect_t*) req_alloc();      r = uv_pipe_connect(req, pipe, TEST_PIPENAME, connect_cb);      ASSERT(r == 0);    }  }}

voidon_resolved(uv_getaddrinfo_t *req, int status, struct addrinfo *res){	if (status != 0) {		printf("on resolved failed: %s/n", uv_strerror(status));		exit(-1);	}	uv_loop_t  *loop = req->loop;	task       *task = (struct task*)req->data;	http_request *request = task->head_request;	task->addrinfo = res;	char addr[17] = { 0 };	uv_ip4_name((struct sockaddr_in*)res->ai_addr, addr, 16);	printf("resolver ip %s/n", addr);	struct sockaddr_in dest;	uv_ip4_addr(addr, http_url_get_port(task->url), &dest);	uv_tcp_init(loop, request->stream);	request->stream->data = task;	uv_tcp_connect(request->connect, request->stream, (const struct sockaddr*)&dest, send_head_request);	free(req);}

int luv_tcp_connect(lua_State* L) {  int before = lua_gettop(L);  uv_tcp_t* handle = (uv_tcp_t*)luv_checkudata(L, 1, "tcp");  const char* ip_address = luaL_checkstring(L, 2);  int port = luaL_checkint(L, 3);  struct sockaddr_in address = uv_ip4_addr(ip_address, port);  luv_connect_ref_t* ref = (luv_connect_ref_t*)malloc(sizeof(luv_connect_ref_t));  /* Store a reference to the userdata */  ref->L = L;  lua_pushvalue(L, 1);  ref->r = luaL_ref(L, LUA_REGISTRYINDEX);  /* Give the connect_req access to this */  ref->connect_req.data = ref;  if (uv_tcp_connect(&ref->connect_req, handle, address, luv_after_connect)) {    uv_err_t err = uv_last_error(luv_get_loop(L));    return luaL_error(L, "tcp_connect: %s", uv_strerror(err));  }  assert(lua_gettop(L) == before);  return 0;}

JL_DLLEXPORT int jl_connect_raw(uv_tcp_t *handle,struct sockaddr_storage *addr,                                uv_connect_cb cb){    uv_connect_t *req = (uv_connect_t*)malloc(sizeof(uv_connect_t));    req->data = 0;    return uv_tcp_connect(req,handle,(struct sockaddr*)addr,cb);}

static void tcp_pinger_new(void) {  int r;  struct sockaddr_in server_addr;  pinger_t *pinger;  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));  pinger = malloc(sizeof(*pinger));  pinger->state = 0;  pinger->pongs = 0;  /* Try to connect to the server and do NUM_PINGS ping-pongs. */  r = uv_tcp_init(uv_default_loop(), &pinger->stream.tcp);  pinger->stream.tcp.data = pinger;  ASSERT(!r);  /* We are never doing multiple reads/connects at a time anyway. */  /* so these handles can be pre-initialized. */  r = uv_tcp_connect(&pinger->connect_req,                     &pinger->stream.tcp,                     (const struct sockaddr*) &server_addr,                     pinger_on_connect);  ASSERT(!r);  /* Synchronous connect callbacks are not allowed. */  ASSERT(pinger_on_connect_count == 0);}

	Peer(cpl::net::SockAddr& addr, std::unique_ptr<uv_tcp_t> conn,		 std::shared_ptr<Message_Queue> mq)	: m_active(false)	, m_tcp(std::move(conn))	, m_mq(mq)	, m_valid(true)	, m_address(addr.str())	{		init_loop_handles();		auto req = new uv_connect_t;		req->data = this;		struct sockaddr_storage sockaddr;		addr.get_sockaddr(reinterpret_cast<struct sockaddr*>(&sockaddr));		uv_tcp_connect(req, m_tcp.get(), reinterpret_cast<struct sockaddr*>(&sockaddr),			[](uv_connect_t* req, int status) {				auto self = (Peer*)req->data;				if (status < 0) {					auto tcp_handle = self->m_tcp.release();					self->m_tcp = nullptr;					uv_close((uv_handle_t*)tcp_handle, [](uv_handle_t* handle) {						delete handle;					});					return;				}				self->m_active = true;				self->run();				delete req;			});	}

void test1(){	Sleep(5000);	struct sockaddr_in addr;	uv_tcp_t client;	uv_os_sock_t sock;	int r;	//int nRet = uv_ip4_addr("127.0.0.1", 1234, &addr);	TEST_ASSERT(0 == uv_ip4_addr("127.0.0.1", 1234, &addr));	startup();	sock = create_tcp_socket();	r = uv_tcp_init(uv_default_loop(), &client);	TEST_ASSERT(r == 0);	r = uv_tcp_open(&client, sock);	TEST_ASSERT(r == 0);	r = uv_tcp_connect(&connect_req,		&client,		(const struct sockaddr*) &addr,		connect_cb);	TEST_ASSERT(r == 0);	uv_run(uv_default_loop(), UV_RUN_DEFAULT);// 	ASSERT(shutdown_cb_called == 1);// 	ASSERT(connect_cb_called == 1);// 	ASSERT(write_cb_called == 1);// 	ASSERT(close_cb_called == 1);}

void TSockSys::Connect(const uint64& SockId, const PSockHost& SockHost, const int& PortN) {	// make sure it's a valid socket	IAssert(IsSock(SockId));	uv_tcp_t* SockHnd = SockIdToHndH.GetDat(SockId);	// make sure we got a valid socket host	IAssert(SockHost->IsOk());	// get connection handle	uv_connect_t* ConnectHnd = (uv_connect_t*)malloc(sizeof(uv_connect_t));	// special handling for v4 and v6	int ResCd = 0;	if (SockHost->IsIpv4()) {		// get address		struct sockaddr_in Addr = uv_ip4_addr(SockHost->GetIpNum().CStr(), PortN);		// establish connection		ResCd = uv_tcp_connect(ConnectHnd, SockHnd, Addr, TSockSys::OnConnect);	} else if (SockHost->IsIpv6()) {		// get address		struct sockaddr_in6 Addr = uv_ip6_addr(SockHost->GetIpNum().CStr(), PortN);		// establish connection		ResCd = uv_tcp_connect6(ConnectHnd, SockHnd, Addr, TSockSys::OnConnect);	}	// check for errors	if (ResCd != 0) {		// cleanup first		free(SockHnd);		// and throw exception		throw TExcept::New("SockSys.Connect: Error establishing socket connection: " + SockSys.GetLastErr());	}}

static void tcp_connector(void) {  struct sockaddr_in server_addr;  struct sockaddr sockname;  int r, namelen;  ASSERT(0 == uv_ip4_addr("127.0.0.1", server_port, &server_addr));  r = uv_tcp_init(loop, &tcp);  tcp.data = &connect_req;  ASSERT(!r);  r = uv_tcp_connect(&connect_req,                     &tcp,                     (const struct sockaddr*) &server_addr,                     on_connect);  ASSERT(!r);  /* Fetch the actual port used by the connecting socket. */  namelen = sizeof sockname;  r = uv_tcp_getsockname(&tcp, &sockname, &namelen);  ASSERT(!r);  ASSERT(sockname.sa_family == AF_INET);  connect_port = ntohs(((struct sockaddr_in*) &sockname)->sin_port);  ASSERT(connect_port > 0);}

    void client::onResolved(uv_getaddrinfo_t* resolver_, int status_, struct addrinfo* res_)    {        if (status_ == -1)        {            throw std::runtime_error(uv_err_name(status_));        }        int r = 0;        data_t* data = (data_t*)resolver_->data;        //char addr[17] = {'/0'};        //uv_ip4_name((struct sockaddr_in*)res_->ai_addr, addr, 16);        //@TODO add ip6 support        //std::cout << "Resolved ip : " << addr << std::endl;        uv_tcp_init(data->loop, &data->sock);        data->connect_req.data = data;        r = uv_tcp_connect(            &(data->connect_req),            &(data->sock),            (const sockaddr*)res_->ai_addr,            onConnect        );        if (r)        {            throw std::runtime_error(uv_err_name(r));        }        uv_freeaddrinfo(res_);    }

void Connection::connect(in6_addr ip, in_port_t port) {  struct sockaddr_in6 addr;  memset(&addr, 0, sizeof(addr));  addr.sin6_family = AF_INET6;  addr.sin6_port = htons(port);  addr.sin6_addr = ip;  uv_tcp_connect(&connect_req, &handle, reinterpret_cast<struct sockaddr *>(&addr), connect_cb);}

void ClientSocket::BeginConnect(uv_loop_t* loop, string addr, int port) {		uv_connect_t* connect = (uv_connect_t*)malloc(sizeof(uv_connect_t));	uv_tcp_init(loop, getSocket());	getSocket()->data = this;	struct sockaddr_in dest = uv_ip4_addr(addr.c_str(), port);	uv_tcp_connect(connect, getSocket(), dest, on_connect);}

void TCPSocket::connect(const net::Address& peerAddress) {    TraceLS(this) << "Connecting to " << peerAddress << endl;    init();    auto req = new uv_connect_t;    req->data = this;    int r = uv_tcp_connect(req, ptr<uv_tcp_t>(), peerAddress.addr(), internal::onConnect);    if (r) setAndThrowError("TCP connect failed", r);}

static PyObject *TCP_func_connect(TCP *self, PyObject *args){    int r;    struct sockaddr sa;    uv_connect_t *connect_req = NULL;    PyObject *addr, *callback;    RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL);    RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL);    if (!PyArg_ParseTuple(args, "OO:connect", &addr, &callback)) {        return NULL;    }    if (!PyCallable_Check(callback)) {        PyErr_SetString(PyExc_TypeError, "a callable is required");        return NULL;    }    if (pyuv_parse_addr_tuple(addr, &sa) < 0) {        /* Error is set by the function itself */        return NULL;    }    Py_INCREF(callback);    connect_req = PyMem_Malloc(sizeof *connect_req);    if (!connect_req) {        PyErr_NoMemory();        goto error;    }    connect_req->data = callback;    if (sa.sa_family == AF_INET) {        r = uv_tcp_connect(connect_req, &self->tcp_h, *(struct sockaddr_in *)&sa, on_tcp_client_connection);    } else {        r = uv_tcp_connect6(connect_req, &self->tcp_h, *(struct sockaddr_in6 *)&sa, on_tcp_client_connection);    }    if (r != 0) {        RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_TCPError);        goto error;    }    /* Increase refcount so that object is not removed before the callback is called */    Py_INCREF(self);    Py_RETURN_NONE;error:    Py_DECREF(callback);    PyMem_Free(connect_req);    return NULL;}

int async_tcp_connect(uv_tcp_t *const stream, struct sockaddr const *const addr) {	async_state state[1];	state->thread = async_active();	uv_connect_t req[1];	req->data = state;	int rc = uv_tcp_connect(req, stream, addr, connect_cb);	if(rc < 0) return rc;	async_yield();	return state->status;}

extern "C" intrust_uv_tcp_connect(uv_connect_t* connect_ptr,        uv_tcp_t* tcp_ptr,        uv_connect_cb cb,        sockaddr_in* addr_ptr) {    // FIXME ref #2064    sockaddr_in addr = *addr_ptr;    int result = uv_tcp_connect(connect_ptr, tcp_ptr, addr, cb);    return result;}

voidconnect_to_remote(struct remote_context *remote) {    remote->stage = XSTAGE_CONNECT;    remote->connect_req.data = remote;    int rc = uv_tcp_connect(&remote->connect_req, &remote->handle.tcp, &server_addr, remote_connect_cb);    if (rc) {        logger_log(LOG_ERR, "connect to server error: %s", uv_strerror(rc));        request_ack(remote->client, S5_REP_NETWORK_UNREACHABLE);    }}

DLLEXPORT int jl_tcp6_connect(uv_tcp_t *handle, void *host, uint16_t port){    struct sockaddr_in6 addr;    uv_connect_t *req = (uv_connect_t*)malloc(sizeof(uv_connect_t));    req->data = 0;    memset(&addr, 0, sizeof(struct sockaddr_in6));    addr.sin6_family = AF_INET6;    memcpy(&addr.sin6_addr, host, 16);    addr.sin6_port = port;    return uv_tcp_connect(req,handle,(struct sockaddr*)&addr,&jl_uv_connectcb);}

voidconnect_to_remote(struct remote_context *remote) {    remote->stage = XSTAGE_CONNECT;    remote->connect_req.data = remote;    int rc = uv_tcp_connect(&remote->connect_req, &remote->handle.tcp, &remote->addr, remote_connect_cb);    if (rc) {        logger_log(LOG_ERR, "connect to %s error: %s", remote->client->target_addr, uv_strerror(rc));        close_client(remote->client);        close_remote(remote);    }}

void httpreq_on_resolved(uv_getaddrinfo_t* resolver, int status, struct addrinfo* res) {    if(status == -1) {        printf("ERROR: httpreq_on_resolved(), cannot resoleve. @todo clean memory/n");        return;    }    HTTPRequest* req = static_cast<HTTPRequest*>(resolver->data);    uv_tcp_init(req->loop, &req->tcp_req);    uv_tcp_connect(&req->connect_req, &req->tcp_req, *(struct sockaddr_in*)res->ai_addr, httpreq_on_connect);    uv_freeaddrinfo(res);}