int uv_udp_set_multicast_interface(uv_udp_t* handle, const char* interface_addr) { struct sockaddr_storage addr_st; struct sockaddr_in* addr4; struct sockaddr_in6* addr6; addr4 = (struct sockaddr_in*) &addr_st; addr6 = (struct sockaddr_in6*) &addr_st; if (!interface_addr) { memset(&addr_st, 0, sizeof addr_st); if (handle->flags & UV_HANDLE_IPV6) { addr_st.ss_family = AF_INET6; addr6->sin6_scope_id = 0; } else { addr_st.ss_family = AF_INET; addr4->sin_addr.s_addr = htonl(INADDR_ANY); } } else if (uv_ip4_addr(interface_addr, 0, addr4) == 0) { /* nothing, address was parsed */ } else if (uv_ip6_addr(interface_addr, 0, addr6) == 0) { /* nothing, address was parsed */ } else { return -EINVAL; } if (addr_st.ss_family == AF_INET) { if (setsockopt(handle->io_watcher.fd, IPPROTO_IP, IP_MULTICAST_IF, (void*) &addr4->sin_addr, sizeof(addr4->sin_addr)) == -1) { return -errno; } } else if (addr_st.ss_family == AF_INET6) { if (setsockopt(handle->io_watcher.fd, IPPROTO_IPV6, IPV6_MULTICAST_IF, &addr6->sin6_scope_id, sizeof(addr6->sin6_scope_id)) == -1) { return -errno; } } else { assert(0 && "unexpected address family"); abort(); } return 0; }
static int luv_udp__send(lua_State* L, int family) { uv_buf_t buf; uv_udp_t* handle = (uv_udp_t*)luv_checkudata(L, 1, "udp"); size_t len; const char* chunk = luaL_checklstring(L, 2, &len); luv_udp_ref_t *ref; uv_udp_send_t* req = (uv_udp_send_t*)malloc(sizeof(uv_udp_send_t)); int port = luaL_checkint(L, 3); const char* host = luaL_checkstring(L, 4); struct sockaddr_in dest; struct sockaddr_in6 dest6; int rc; /* Store a reference to the callback */ lua_pushvalue(L, 5); ref = malloc(sizeof(*ref)); ref->ref = luaL_ref(L, LUA_REGISTRYINDEX); req->data = ref; luv_handle_ref(L, handle->data, 1); /* Store the chunk * TODO: this is probably unsafe, should investigate */ buf = uv_buf_init((char*)chunk, len); switch(family) { case AF_INET: dest = uv_ip4_addr(host, port); rc = uv_udp_send(req, handle, &buf, 1, dest, luv_on_udp_send); break; case AF_INET6: dest6 = uv_ip6_addr(host, port); rc = uv_udp_send6(req, handle, &buf, 1, dest6, luv_on_udp_send); break; default: assert(0 && "unexpected family type"); abort(); } if (rc) { uv_err_t err = uv_last_error(luv_get_loop(L)); return luaL_error(L, "udp_send: %s", uv_strerror(err)); } return 0; }
void TCPClient::ReconnectTimer(uv_timer_t* handle) { TCPClient* theclass = (TCPClient*)handle->data; if (!theclass->isreconnecting_) { return; } LOG(INFO)<<"start reconnect...\n"; do { int iret = uv_tcp_init(&theclass->loop_, &theclass->client_handle_->tcphandle); if (iret) { LOG(ERROR)<<(GetUVError(iret)); break; } theclass->client_handle_->tcphandle.data = theclass->client_handle_; theclass->client_handle_->parent_server = theclass; struct sockaddr* pAddr; if (theclass->isIPv6_) { struct sockaddr_in6 bind_addr; int iret = uv_ip6_addr(theclass->connectip_.c_str(), theclass->connectport_, &bind_addr); if (iret) { LOG(ERROR)<<(GetUVError(iret)); uv_close((uv_handle_t*)&theclass->client_handle_->tcphandle, NULL); break; } pAddr = (struct sockaddr*)&bind_addr; } else { struct sockaddr_in bind_addr; int iret = uv_ip4_addr(theclass->connectip_.c_str(), theclass->connectport_, &bind_addr); if (iret) { LOG(ERROR)<<(GetUVError(iret)); uv_close((uv_handle_t*)&theclass->client_handle_->tcphandle, NULL); break; } pAddr = (struct sockaddr*)&bind_addr; } iret = uv_tcp_connect(&theclass->connect_req_, &theclass->client_handle_->tcphandle, (const sockaddr*)pAddr, AfterConnect); if (iret) { LOG(ERROR)<<(GetUVError(iret)); uv_close((uv_handle_t*)&theclass->client_handle_->tcphandle, NULL); break; } return; } while (0); //reconnect failure, restart timer to trigger reconnect. uv_timer_stop(handle); theclass->repeat_time_ *= 2; uv_timer_start(handle, TCPClient::ReconnectTimer, theclass->repeat_time_, theclass->repeat_time_); }
static void tcp_pump(int n) { ASSERT(n <= MAX_WRITE_HANDLES); TARGET_CONNECTIONS = n; type = TCP; loop = uv_default_loop(); ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &connect_addr)); /* Start making connections */ maybe_connect_some(); uv_run(loop, UV_RUN_DEFAULT); MAKE_VALGRIND_HAPPY(); }
void init() { loop = uv_default_loop(); uv_tcp_t server; uv_tcp_init(loop, &server); struct sockaddr_in bind_addr = uv_ip4_addr("127.0.0.1", 6000); uv_tcp_bind(&server, bind_addr); int r = uv_listen((uv_stream_t*)&server, 128, on_new_connection); if (r) { //fprintf(stderr, "Listen error %s\n", uv_err_name(uv_last_error(loop))); //return 1; } }
static void start_server(void) { struct sockaddr_in addr; int r; TEST_ASSERT(0 == uv_ip4_addr("127.0.0.1", 1234, &addr)); r = uv_tcp_init(uv_default_loop(), &server); TEST_ASSERT(r == 0); r = uv_tcp_bind(&server, (const struct sockaddr*) &addr, 0); TEST_ASSERT(r == 0); r = uv_listen((uv_stream_t*)&server, 128, connection_cb); TEST_ASSERT(r == 0); }
int check_ip(const char * ipstr, http_connection_t * conn) { struct sockaddr_in ip_addr, compare_addr; size_t namelen = sizeof(struct sockaddr_in); uv_tcp_getpeername(&conn->stream, &ip_addr, &namelen); uv_ip4_addr(ipstr, 0, &compare_addr); if (compare_addr.sin_family == ip_addr.sin_family) { return memcmp(&ip_addr.sin_addr, &compare_addr.sin_addr, sizeof compare_addr.sin_addr) == 0; } return 0; }
static void client_connect() { struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT); uv_handle_t* client = (uv_handle_t*)malloc(sizeof *client); uv_req_t* connect_req = (uv_req_t*)malloc(sizeof *connect_req); int r; ASSERT(client != NULL); ASSERT(connect_req != NULL); r = uv_tcp_init(client, close_cb, NULL); ASSERT(r == 0); uv_req_init(connect_req, client, connect_cb); r = uv_connect(connect_req, (struct sockaddr*)&addr); ASSERT(r == 0); }
static int64_t HHVM_METHOD(UVUdp, bind, const String &host, int64_t port) { int64_t ret; struct sockaddr_in addr; auto* data = Native::data<UVUdpData>(this_); if((ret = uv_ip4_addr(host.c_str(), port&0xffff, &addr)) != 0){ return ret; } if((ret = uv_udp_bind(data->udp_handle, (const struct sockaddr*) &addr, 0)) != 0){ return ret; } data->udp_handle->flag |= UV_UDP_HANDLE_START; return ret; }
//start web server, linstening ip:port //ip can be NULL or "", which means "0.0.0.0" void tinyweb_start(uv_loop_t* loop, const char* ip, int port, const char* md5) { strcpy(szMd5, md5); struct sockaddr_in addr; uv_ip4_addr((ip && ip[0]) ? ip : "0.0.0.0", port, &addr); _loop = loop; uv_tcp_init(_loop, &_server); uv_tcp_bind(&_server, (const struct sockaddr*) &addr, 0); uv_listen((uv_stream_t*)&_server, 8, tinyweb_on_connection); uv_thread_t tid; int nRtn = uv_thread_create(&tid, thread_entry, (void*)42); assert(nRtn == 0); }
int luv_tcp_bind (lua_State* L) { int before = lua_gettop(L); uv_tcp_t* handle = (uv_tcp_t*)luv_checkudata(L, 1, "tcp"); const char* host = luaL_checkstring(L, 2); int port = luaL_checkint(L, 3); struct sockaddr_in address = uv_ip4_addr(host, port); if (uv_tcp_bind(handle, address)) { uv_err_t err = uv_last_error(luv_get_loop(L)); return luaL_error(L, "tcp_bind: %s", uv_strerror(err)); } assert(lua_gettop(L) == before); return 0; }
static void start_server() { struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", TEST_PORT); uv_handle_t* server = (uv_handle_t*)malloc(sizeof *server); int r; ASSERT(server != NULL); r = uv_tcp_init(server, close_cb, NULL); ASSERT(r == 0); r = uv_bind(server, (struct sockaddr*) &addr); ASSERT(r == 0); r = uv_listen(server, 128, accept_cb); ASSERT(r == 0); }
int main() { loop = uv_default_loop(); uv_tcp_t server; uv_tcp_init(loop, &server); struct sockaddr_in bind_addr; uv_ip4_addr("0.0.0.0", 7000,&bind_addr); uv_tcp_bind(&server, (struct sockaddr*)&bind_addr,0); int r = uv_listen((uv_stream_t*) &server, 128, on_new_connection); if (r) { printf("listen error\n"); return 1; } return uv_run(loop, UV_RUN_DEFAULT); }
static void start_server(void) { server_context_t* context; struct sockaddr_in addr; uv_os_sock_t sock; int r; ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); sock = create_bound_socket(addr); context = create_server_context(sock); r = listen(sock, 100); ASSERT(r == 0); r = uv_poll_start(&context->poll_handle, UV_READABLE, server_poll_cb); ASSERT(r == 0); }
int main(int argc, char **argv) { loop = uv_loop_new(); //uv_default_loop(); uv_tcp_t server; uv_tcp_init(loop, &server); struct sockaddr_in bind_addr = uv_ip4_addr("0.0.0.0", 7000); uv_tcp_bind(&server, bind_addr); int r = uv_listen((uv_stream_t*) &server, 128, on_new_connection); if (r) { fprintf(stderr, "Listen error %s\n", uv_err_name(uv_last_error(loop))); return 1; } return uv_run(loop); }
int main() { loop = uv_default_loop(); setup_workers(); uv_tcp_t server; uv_tcp_init(loop, &server); struct sockaddr_in bind_addr = uv_ip4_addr("0.0.0.0", 7000); uv_tcp_bind(&server, bind_addr); if (uv_listen((uv_stream_t*) &server, 128, on_new_connection)) { fprintf(stderr, "Listen error %s\n", uv_err_name(uv_last_error(loop))); return 2; } return uv_run(loop, UV_RUN_DEFAULT); }
UvTcpSocket* UvTcpSocket::createUvTcpSokcet( LibuvUsageEnvironment* env, string szAddr, int port) { int ret = 0; do { uv_loop_t* uv_loop = (uv_loop_t*)env->TaskScheduler()->loopHandle(); ASSERT(uv_loop); if(!uv_loop){ LOG_ERROR("create loop error\r\n"); ret = -1; break; } struct sockaddr_in addr; ret = uv_ip4_addr(szAddr.c_str(),port,&addr); ASSERT(ret == 0); if (ret){ LOG_ERROR("get ip error\r\n"); break; } uv_tcp_t* tcp_stream = (uv_tcp_t*)malloc(sizeof uv_tcp_t); ret = uv_tcp_init(uv_loop, tcp_stream); ASSERT(ret == 0); if(ret){ LOG_ERROR("create server socket error\r\n"); break; } ret = uv_tcp_bind(tcp_stream,(const sockaddr*)&addr,0); if (ret) { LOG_ERROR("bind error \r\n"); break; } UvTcpSocket* tcp = new UvTcpSocket(env, tcp_stream); return tcp; }while(0); LOG_ERROR("Create uv socket error \r\n"); return NULL; }
static void do_test(uv_udp_recv_cb recv_cb, int bind_flags) { struct sockaddr_in6 addr6; struct sockaddr_in addr; uv_buf_t buf; int r; ASSERT(0 == uv_ip6_addr("::0", TEST_PORT, &addr6)); r = uv_udp_init(uv_default_loop(), &server); ASSERT(r == 0); r = uv_udp_bind(&server, (const struct sockaddr*) &addr6, bind_flags); ASSERT(r == 0); r = uv_udp_recv_start(&server, alloc_cb, recv_cb); ASSERT(r == 0); r = uv_udp_init(uv_default_loop(), &client); ASSERT(r == 0); buf = uv_buf_init("PING", 4); ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); r = uv_udp_send(&req_, &client, &buf, 1, (const struct sockaddr*) &addr, send_cb); ASSERT(r == 0); r = uv_timer_init(uv_default_loop(), &timeout); ASSERT(r == 0); r = uv_timer_start(&timeout, timeout_cb, 500, 0); ASSERT(r == 0); ASSERT(close_cb_called == 0); ASSERT(send_cb_called == 0); ASSERT(recv_cb_called == 0); uv_run(uv_default_loop(), UV_RUN_DEFAULT); ASSERT(close_cb_called == 3); MAKE_VALGRIND_HAPPY(); }
int ipc_helper_bind_twice(void) { /* * This is launched from test-ipc.c. stdin is a duplex channel * over which two handles will be transmitted. */ struct sockaddr_in addr; uv_write_t write_req; uv_write_t write_req2; int r; uv_buf_t buf; ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); r = uv_pipe_init(uv_default_loop(), &channel, 1); ASSERT(r == 0); uv_pipe_open(&channel, 0); ASSERT(1 == uv_is_readable((uv_stream_t*) &channel)); ASSERT(1 == uv_is_writable((uv_stream_t*) &channel)); ASSERT(0 == uv_is_closing((uv_handle_t*) &channel)); buf = uv_buf_init("hello\n", 6); r = uv_tcp_init(uv_default_loop(), &tcp_server); ASSERT(r == 0); r = uv_tcp_init(uv_default_loop(), &tcp_server2); ASSERT(r == 0); r = uv_tcp_bind(&tcp_server, (const struct sockaddr*) &addr, 0); ASSERT(r == 0); r = uv_tcp_bind(&tcp_server2, (const struct sockaddr*) &addr, 0); ASSERT(r == 0); r = uv_write2(&write_req, (uv_stream_t*)&channel, &buf, 1, (uv_stream_t*)&tcp_server, NULL); ASSERT(r == 0); r = uv_write2(&write_req2, (uv_stream_t*)&channel, &buf, 1, (uv_stream_t*)&tcp_server2, NULL); ASSERT(r == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); ASSERT(r == 0); MAKE_VALGRIND_HAPPY(); return 0; }
static PyObject * Channel_func_getnameinfo(Channel *self, PyObject *args) { char *addr; int port, flags, length; struct in_addr addr4; struct in6_addr addr6; struct sockaddr *sa; struct sockaddr_in sa4; struct sockaddr_in6 sa6; PyObject *callback; CHECK_CHANNEL(self); if (!PyArg_ParseTuple(args, "(si)iO:getnameinfo", &addr, &port, &flags, &callback)) { return NULL; } if (!PyCallable_Check(callback)) { PyErr_SetString(PyExc_TypeError, "a callable is required"); return NULL; } if (port < 0 || port > 65535) { PyErr_SetString(PyExc_ValueError, "port must be between 0 and 65535"); return NULL; } if (ares_inet_pton(AF_INET, addr, &addr4) == 1) { sa4 = uv_ip4_addr(addr, port); sa = (struct sockaddr *)&sa4; length = sizeof(struct sockaddr_in); } else if (ares_inet_pton(AF_INET6, addr, &addr6) == 1) { sa6 = uv_ip6_addr(addr, port); sa = (struct sockaddr *)&sa6; length = sizeof(struct sockaddr_in6); } else { PyErr_SetString(PyExc_ValueError, "invalid IP address"); return NULL; } Py_INCREF(callback); ares_getnameinfo(self->channel, sa, length, flags, &nameinfo_cb, (void *)callback); Py_RETURN_NONE; }
H_CONNECTION KUVSocket::Listen(LPCSTR szAddress, UINT nPort) { H_CONNECTION ret = INVALID_HANDLER; if (!szAddress) { sprintf_s(g_ErrorMsg, "KUVSocket::Listen Fail, the address is empty\n%s", g_ErrorMsg); return ret; } /*hostent* host = gethostbyname(szAddress); if (!host) { sprintf_s(ErrorMsg, "KUVSocket::Listen Fail, get host Error, the szAddress is %s", szAddress); return ret; } struct sockaddr_in addrBind; addrBind.sin_family = AF_INET; memcpy(&addrBind.sin_addr, host->h_addr_list[0], sizeof(in_addr)); addrBind.sin_port = htons(nPort);*/ struct sockaddr_in addrBind = uv_ip4_addr(szAddress, nPort); uv_tcp_t* pListen = NULL; pListen = CreateSocket(ret); if (!pListen) { sprintf_s(g_ErrorMsg, "KUVSocket::Listen Fail, create socket Error\n%s", g_ErrorMsg); return ret; } m_nError = uv_tcp_bind(pListen, addrBind); if (m_nError) { ReleaseSocket(ret); return ret; } m_nError = uv_listen((uv_stream_t*)pListen, SOMAXCONN, OnConnectionIncoming); if (m_nError) { return ret; } return ret; }
static int ipc_helper(int listen_after_write) { /* * This is launched from test-ipc.c. stdin is a duplex channel that we * over which a handle will be transmitted. In this initial version only * data is transfered over the channel. XXX edit this comment after handle * transfer is added. */ uv_write_t write_req; int r; uv_buf_t buf; r = uv_pipe_init(uv_default_loop(), &channel, 1); ASSERT(r == 0); uv_pipe_open(&channel, 0); r = uv_tcp_init(uv_default_loop(), &tcp_server); ASSERT(r == 0); r = uv_tcp_bind(&tcp_server, uv_ip4_addr("0.0.0.0", TEST_PORT)); ASSERT(r == 0); if (!listen_after_write) { r = uv_listen((uv_stream_t*)&tcp_server, 12, ipc_on_connection); ASSERT(r == 0); } buf = uv_buf_init("hello\n", 6); r = uv_write2(&write_req, (uv_stream_t*)&channel, &buf, 1, (uv_stream_t*)&tcp_server, NULL); ASSERT(r == 0); if (listen_after_write) { r = uv_listen((uv_stream_t*)&tcp_server, 12, ipc_on_connection); ASSERT(r == 0); } r = uv_run(uv_default_loop()); ASSERT(r == 0); ASSERT(connection_accepted == 1); ASSERT(close_cb_called == 3); return 0; }
static void start_server(uv_loop_t* loop, uv_tcp_t* handle) { struct sockaddr_in addr; int r; ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); r = uv_tcp_init(loop, handle); ASSERT(r == 0); r = uv_tcp_bind(handle, &addr); ASSERT(r == 0); r = uv_listen((uv_stream_t*)handle, 128, connection_cb); ASSERT(r == 0); uv_unref((uv_handle_t*)handle); }
static void prep_tcploopback() { /* for test, use echo server - TCP port TEST_PORT on loopback */ struct sockaddr_in test_server = uv_ip4_addr("127.0.0.1", 0); int rc = 0; optmask = 0; optmask = ARES_OPT_SERVERS | ARES_OPT_TCP_PORT | ARES_OPT_FLAGS; options.servers = &test_server.sin_addr; options.nservers = 1; options.tcp_port = htons(TEST_PORT_2); options.flags = ARES_FLAG_USEVC; rc = uv_ares_init_options(loop, &channel, &options, optmask); ASSERT(rc == ARES_SUCCESS); }
void ServerSocket::Listen(uv_loop_t* loop, int port) { uv_tcp_init(loop, getSocket()); // Loby port 8124 struct sockaddr_in lobby_addr = uv_ip4_addr("0.0.0.0", port); uv_tcp_bind(getSocket(), lobby_addr); getSocket()->data = this; int result = uv_listen((uv_stream_t*)getSocket(), 128, on_new_connection); if (result) { OnListeningError (); cerr << "Lobby server could not listen\n" << uv_err_name(uv_last_error(loop)); } else OnListening(); }
static int tcp_listener(int port) { struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", port); struct sockaddr sockname; int namelen = sizeof(sockname); char ip[20]; int r; r = uv_tcp_init(loop, &tcpServer); if (r) { fprintf(stderr, "Socket creation error\n"); return 1; } r = uv_tcp_bind(&tcpServer, addr); if (r) { fprintf(stderr, "Bind error\n"); return 1; } r = uv_listen((uv_stream_t*)&tcpServer, 128, on_connection); if (r) { fprintf(stderr, "Listen error\n"); return 1; } memset(&sockname, -1, sizeof sockname); r = uv_getsockname((uv_handle_t*)&tcpServer, &sockname, &namelen); if (r != 0) { fprintf(stderr, "uv_getsockname error (listening) %d\n", uv_last_error(loop).code); } ASSERT(r == 0); r = uv_ip4_name((struct sockaddr_in*)&sockname, ip, 20); ASSERT(r == 0); ASSERT(ip[0] == '0'); ASSERT(ip[1] == '.'); ASSERT(ip[2] == '0'); printf("sockname = %s\n", ip); getsocknamecount++; return 0; }
bool TCPClient::Connect(const char* ip, int port) { closeinl(); if (!init()) { return false; } connectip_ = ip; connectport_ = port; isIPv6_ = false; struct sockaddr_in bind_addr; int iret = uv_ip4_addr(connectip_.c_str(), connectport_, &bind_addr); if (iret) { errmsg_ = GetUVError(iret); LOG(ERROR)<<(errmsg_); return false; } iret = uv_tcp_connect(&connect_req_, &client_handle_->tcphandle, (const sockaddr*)&bind_addr, AfterConnect); if (iret) { errmsg_ = GetUVError(iret); LOG(ERROR)<<(errmsg_); return false; } LOG(INFO) << "client(" << this << ")start connect to server(" << ip << ":" << port << ")"; iret = uv_thread_create(&connect_threadhandle_, ConnectThread, this);//thread to wait for succeed connect. if (iret) { errmsg_ = GetUVError(iret); LOG(ERROR)<<(errmsg_); return false; } int wait_count = 0; while (connectstatus_ == CONNECT_DIS) { sleep(100); if (++wait_count > 100) { connectstatus_ = CONNECT_TIMEOUT; break; } } if (CONNECT_FINISH != connectstatus_) { errmsg_ = "connect time out"; return false; } else { return true; } }
static int tcp_bind(lua_State* L) { struct sockaddr_in addr; const char* host; tcp_obj* self; int port; int r; self = luaL_checkudata(L, 1, "uv.tcp"); host = luaL_checkstring(L, 2); port = luaL_checkint(L, 3); addr = uv_ip4_addr(host, port); r = uv_tcp_bind(&self->handle, addr); lua_pushinteger(L, r); return 1; }
static int luv_udp_try_send(lua_State* L) { uv_udp_t* handle = luv_check_udp(L, 1); uv_buf_t buf; int ret, port; const char* host; struct sockaddr_storage addr; luv_check_buf(L, 2, &buf); host = luaL_checkstring(L, 3); port = luaL_checkinteger(L, 4); if (uv_ip4_addr(host, port, (struct sockaddr_in*)&addr) && uv_ip6_addr(host, port, (struct sockaddr_in6*)&addr)) { return luaL_error(L, "Invalid IP address or port [%s:%d]", host, port); } ret = uv_udp_try_send(handle, &buf, 1, (struct sockaddr*)&addr); if (ret < 0) return luv_error(L, ret); lua_pushinteger(L, ret); return 1; }
static void start_server() { struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", TEST_PORT); uv_tcp_t* server = (uv_tcp_t*)malloc(sizeof *server); int r; ASSERT(server != NULL); r = uv_tcp_init(server); ASSERT(r == 0); ASSERT(uv_counters()->tcp_init == 1); ASSERT(uv_counters()->handle_init == 1); r = uv_tcp_bind(server, addr); ASSERT(r == 0); r = uv_tcp_listen(server, 128, connection_cb); ASSERT(r == 0); }