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

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);}