コード例 #1
0
ファイル: benchmark-ping-pongs.c プロジェクト: Kami/node
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);
}
コード例 #2
0
ファイル: test-connection-fail.c プロジェクト: 4T-Shirt/node
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);
}
コード例 #3
0
ファイル: client.c プロジェクト: Lucups/Skyray
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);
}
コード例 #4
0
ファイル: libuv.cpp プロジェクト: andyfischer/circa
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");
}
コード例 #5
0
ファイル: syncsocket.c プロジェクト: stmuk/MoarVM
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");
    }
}
コード例 #6
0
ファイル: client.cpp プロジェクト: Bulliby/Reactive
    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_);
    }
コード例 #7
0
ファイル: luv_tcp.c プロジェクト: gungorkocak/luvit
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;
}
コード例 #8
0
ファイル: rbuv_tcp.c プロジェクト: rbuv/rbuv
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;
}
コード例 #9
0
ファイル: socksys.cpp プロジェクト: davidd2k/qminer
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());
	}
}
コード例 #10
0
ファイル: test1005_async.cpp プロジェクト: QC-git/MyLab
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);

}
コード例 #11
0
ファイル: test-ping-pong.c プロジェクト: AKIo0O/node
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);
}
コード例 #12
0
ファイル: test-getsockname.c プロジェクト: 0x20c24/cjdns
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);
}
コード例 #13
0
ファイル: tcp.cpp プロジェクト: Xsoda/uvplus
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);
}
コード例 #14
0
ファイル: benchmark-ping-pongs.c プロジェクト: Jan357/node
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);
}
コード例 #15
0
ファイル: jl_uv.c プロジェクト: 0/julia
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);
}
コード例 #16
0
ファイル: peer.hpp プロジェクト: Preetam/failure-detector
	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;
			});
	}
コード例 #17
0
ファイル: benchmark-pound.c プロジェクト: sjw7453584/Server
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;
}
コード例 #18
0
ファイル: benchmark-pump.c プロジェクト: CrabDude/node
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);
    }
  }
}
コード例 #19
0
ファイル: task.c プロジェクト: Marcus366/campus-downloader
void
on_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);
}
コード例 #20
0
ファイル: Connection.cpp プロジェクト: Ralith/anchor
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);
}
コード例 #21
0
ファイル: tcpsocket.cpp プロジェクト: runt18/libsourcey
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);
}
コード例 #22
0
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);
}
コード例 #23
0
ファイル: tcp.c プロジェクト: eagles125/pyuv
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;
}
コード例 #24
0
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;
}
コード例 #25
0
ファイル: xsocks_remote.c プロジェクト: cdlz/xsocks
void
connect_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);
    }
}
コード例 #26
0
ファイル: rust_uv.cpp プロジェクト: devmario/rust
extern "C" int
rust_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;
}
コード例 #27
0
ファイル: jl_uv.c プロジェクト: jskDr/julia
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);
}
コード例 #28
0
ファイル: xsocksd_remote.c プロジェクト: nsdown/xsocks-1
void
connect_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);
    }
}
コード例 #29
0
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);
}
コード例 #30
-1
ファイル: connector.hpp プロジェクト: Ilceren/cpp-driver
  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;
    }
  }