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); }
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); }
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); }
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"); } }
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_); }
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; }
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; }
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()); } }
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); }
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); }
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); }
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 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); }
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); }
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; }); }
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; }
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); } } }
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); }
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 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); }
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); }
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; }
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); } }
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; }
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); }
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); } }
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); }
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; } }