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

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

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

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

int uv__tcp_connect(uv_connect_t* req,                    uv_tcp_t* handle,                    struct sockaddr_in address,                    uv_connect_cb cb) {  uv_loop_t* loop = handle->loop;  int addrsize = sizeof(struct sockaddr_in);  BOOL success;  DWORD bytes;  if (handle->flags & UV_HANDLE_BIND_ERROR) {    uv__set_sys_error(loop, handle->bind_error);    return -1;  }  if (!(handle->flags & UV_HANDLE_BOUND) &&      uv_tcp_bind(handle, uv_addr_ip4_any_) < 0)    return -1;  uv_req_init(loop, (uv_req_t*) req);  req->type = UV_CONNECT;  req->handle = (uv_stream_t*) handle;  req->cb = cb;  memset(&req->overlapped, 0, sizeof(req->overlapped));  success = pConnectEx(handle->socket,                       (struct sockaddr*) &address,                       addrsize,                       NULL,                       0,                       &bytes,                       &req->overlapped);  if (UV_SUCCEEDED_WITHOUT_IOCP(success)) {    /* Process the req without IOCP. */    handle->reqs_pending++;    uv_insert_pending_req(loop, (uv_req_t*)req);  } else if (UV_SUCCEEDED_WITH_IOCP(success)) {    /* The req will be processed with IOCP. */    handle->reqs_pending++;  } else {    uv__set_sys_error(loop, WSAGetLastError());    return -1;  }  return 0;}

void TCPSocket::bind(const net::Address& address, unsigned flags) {    TraceLS(this) << "Binding on " << address << endl;    init();    int r;    switch (address.af()) {    case AF_INET:        r = uv_tcp_bind(ptr<uv_tcp_t>(), address.addr(), flags);        break;    //case AF_INET6:    //    r = uv_tcp_bind6(ptr<uv_tcp_t>(), *reinterpret_cast<const sockaddr_in6*>(address.addr()));    //    break;    default:        throw std::runtime_error("Unexpected address family");    }    if (r) setAndThrowError("TCP bind failed", r);}

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

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

int ipc_helper_tcp_connection() {  /*   * This is launched from test-ipc.c. stdin is a duplex channel that we   * over which a handle will be transmitted.   */  int r;  struct sockaddr_in addr;  r = uv_pipe_init(uv_default_loop(), &channel, 1);  ASSERT(r == 0);  uv_pipe_open(&channel, 0);  ASSERT(uv_is_readable((uv_stream_t*)&channel));  ASSERT(uv_is_writable((uv_stream_t*)&channel));  ASSERT(!uv_is_closing((uv_handle_t*)&channel));  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);  r = uv_listen((uv_stream_t*)&tcp_server, 12, ipc_on_connection_tcp_conn);  ASSERT(r == 0);  /* Make a connection to the server */  r = uv_tcp_init(uv_default_loop(), &conn.conn);  ASSERT(r == 0);  addr = uv_ip4_addr("127.0.0.1", TEST_PORT);  r = uv_tcp_connect(&conn.conn_req, (uv_tcp_t*)&conn.conn, addr, connect_child_process_cb);  ASSERT(r == 0);  r = uv_run(uv_default_loop());  ASSERT(r == 0);  ASSERT(tcp_conn_read_cb_called == 1);  ASSERT(tcp_conn_write_cb_called == 1);  ASSERT(close_cb_called == 4);  MAKE_VALGRIND_HAPPY();  return 0;}

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

void listen_scgi_server(struct scgi_server s){    int uv_errno, i;    uv_tcp_t tcp;    /* initialize tcp socket and bind it to prepared addresses */    uv_tcp_init(s.loop, &tcp);    for (i=0; i<s.nbind_addrs; i++)        uv_tcp_bind(&tcp, s.bind_addrs[i]);    tcp.data = (void *) &s;  /* pack scgi_server */    uv_errno = uv_listen((uv_stream_t *) &tcp, s.max_conn, on_connect);    if (uv_errno)        on_connect_error(s.loop, uv_errno);    else        uv_run(s.loop, UV_RUN_DEFAULT);}

/* _http_start(): start http server.*/static void_http_start(u2_http* htp_u){  struct sockaddr_in add_u;  uv_tcp_init(u2L, &htp_u->wax_u);  memset(&add_u, 0, sizeof(add_u));  add_u.sin_family = AF_INET;  add_u.sin_addr.s_addr = INADDR_ANY;  /*  Try ascending ports.  */  while ( 1 ) {    add_u.sin_port = htons(htp_u->por_w);    if ( 0 != uv_tcp_bind(&htp_u->wax_u, add_u)  ) {      uv_err_t las_u = uv_last_error(u2L);      if ( UV_EADDRINUSE == las_u.code ) {        htp_u->por_w++;        continue;      }      else {        uL(fprintf(uH, "http: bind: %s/n", uv_strerror(las_u)));      }    }    if ( 0 != uv_listen((uv_stream_t*)&htp_u->wax_u, 16, _http_listen_cb) ) {      uv_err_t las_u = uv_last_error(u2L);      if ( UV_EADDRINUSE == las_u.code ) {        htp_u->por_w++;        continue;      }      else {        uL(fprintf(uH, "http: listen: %s/n", uv_strerror(las_u)));      }    }    uL(fprintf(uH, "http: live (%s) on %d/n",                   (u2_yes == htp_u->sec) ? "/"secure/"" : "insecure",                   htp_u->por_w));    break;  }}

/* _http_start(): start http server.*/static void_http_start(u3_http* htp_u){  struct sockaddr_in add_u;  uv_tcp_init(u3L, &htp_u->wax_u);  memset(&add_u, 0, sizeof(add_u));  add_u.sin_family = AF_INET;  add_u.sin_addr.s_addr = INADDR_ANY;  /*  Try ascending ports.  */  while ( 1 ) {    add_u.sin_port = htons(htp_u->por_w);    int ret;    if ( 0 != (ret = uv_tcp_bind(&htp_u->wax_u, (const struct sockaddr*) & add_u, 0))  ) {      if ( UV_EADDRINUSE == ret ) {        htp_u->por_w++;        continue;      }      else {        uL(fprintf(uH, "http: bind: %s/n", uv_strerror(ret)));      }    }    if ( 0 != (ret = uv_listen((uv_stream_t*)&htp_u->wax_u, 16, _http_listen_cb)) ) {      if ( UV_EADDRINUSE == ret ) {        htp_u->por_w++;        continue;      }      else {        uL(fprintf(uH, "http: listen: %s/n", uv_strerror(ret)));      }    }#if 0    uL(fprintf(uH, "http: live (%s) on %d/n",                   (c3y == htp_u->sec) ? "/"secure/"" : "insecure",                   htp_u->por_w));#endif    break;  }}

voidu3_term_io_talk(void){  struct sockaddr_in add_u;  u3_utel* tel_u = &u3_Host.tel_u;  uv_tcp_init(u3L, &tel_u->uty_t.wax_u);  tel_u->por_s = 10023;  memset(&add_u, 0, sizeof(add_u));  add_u.sin_family = AF_INET;  add_u.sin_addr.s_addr = htonl(INADDR_LOOPBACK);  /*  Try ascending ports.  */  while ( 1 ) {    add_u.sin_port = htons(tel_u->por_s);    c3_w ret ;    if ( 0 != (ret = uv_tcp_bind(&tel_u->uty_t.wax_u, (const struct sockaddr*) & add_u, 0))  ) {      if ( UV_EADDRINUSE == ret ) {        tel_u->por_s++;        continue;      }      else {        uL(fprintf(uH, "term: bind: %s/n", uv_strerror(ret)));      }    }    c3_w ret_w;    if ( 0 != (ret_w = uv_listen((uv_stream_t*)&tel_u->uty_t.wax_u,                               16, _term_listen_cb)) )    {      if ( UV_EADDRINUSE == ret_w ) {        tel_u->por_s++;        continue;      }      else {        uL(fprintf(uH, "term: listen: %s/n", uv_strerror(ret_w)));      }    }    uL(fprintf(uH, "term: live on %d/n", tel_u->por_s));    break;  }}

int main() {  static const int kBacklog = 128;  uv_loop_t* loop;  struct sockaddr_in addr;  loop = uv_default_loop();  CHECK(uv_tcp_init(loop, &server));  CHECK(uv_ip4_addr("0.0.0.0", 9000, &addr));  CHECK(uv_tcp_bind(&server, (struct sockaddr*) &addr, 0));  CHECK(uv_listen((uv_stream_t*) &server, kBacklog, connection_cb));  fprintf(stderr, "Listening on 0.0.0.0:9000/n");  CHECK(uv_run(loop, UV_RUN_DEFAULT));  return 0;}

int tcp_bind(uv_tcp_t *handle, struct sockaddr *addr){	unsigned flags = UV_UDP_REUSEADDR;	if (addr->sa_family == AF_INET6) {		flags |= UV_UDP_IPV6ONLY;	}	int ret = uv_tcp_bind(handle, addr, flags);	if (ret != 0) {		return ret;	}	ret = uv_listen((uv_stream_t *)handle, 16, tcp_accept);	if (ret != 0) {		return ret;	}	handle->data = NULL;	return 0;}

int main( void ){    sqlite3 *db;    struct sockaddr_in addr = uv_ip4_addr( "127.0.0.1", 9050 );    int ret = 0;    uv_tcp_t listener;    uv_loop_t *loop;    ret = sqlite3_open( "data.db", &db );    if ( ret != 0 ) {        printf( "Open SQLite Database Failed/n" );        return -1;    }    loop = uv_default_loop();    uv_tcp_init( loop, &listener );    listener.data = db;    uv_tcp_bind( &listener, addr );    uv_listen( ( uv_stream_t *) &listener, 1 , conn_done );    uv_run( loop, UV_RUN_DEFAULT );}

int main(int argc,char *argv[]){	uv_loop_t  *loop = uv_default_loop();	int         status;	uv_tcp_t    server;	int         port;#ifdef _WIN32	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_CHECK_ALWAYS_DF);#endif	if (argc < 4) {		usage();		return 0;	}	status = sscanf(argv[1],"%d",&port);	if (status != 1) {		usage();		printf("invalid telnet port number : %s/n",argv[1]);		return 1;	}	utb_server_data.udp_ipaddr = argv[2];	status = sscanf(argv[3],"%d",&utb_server_data.udp_port);	if(status != 1) {		usage();		printf("invalid udp port number : %s/n",argv[3]);		return 1;	}	uv_tcp_init(loop,&server);	struct sockaddr_in bind_addr = uv_ip4_addr("0.0.0.0",port);	status = uv_tcp_bind(&server,bind_addr);	assert(status == 0);	status = uv_listen((uv_stream_t*)&server,1,utb_on_connection);	assert(status == 0);	server.data = &utb_server_data;	return uv_run(loop,UV_RUN_DEFAULT);}

intmain(int argc, char **argv){     loop = uv_default_loop();     struct sockaddr_in addr;     uv_ip4_addr("0.0.0.0", 3000, &addr);     uv_tcp_init(loop, &server);     uv_tcp_bind(&server, (const struct sockaddr*)&addr, 0);     int r = uv_listen((uv_stream_t *)&server, 128, on_connection);     if (r) {	  /* error */     }     return uv_run(loop, UV_RUN_DEFAULT);}

int main() {  loop = uv_default_loop();  uv_tcp_t server;  uv_tcp_init(loop, &server);  struct sockaddr_in bind_addr;  int r = uv_ip4_addr("0.0.0.0", 7000, &bind_addr);  assert(!r);  uv_tcp_bind(&server, (struct sockaddr*)&bind_addr);  r = uv_listen((uv_stream_t*) &server, 128 /*backlog*/, connection_cb);  if (r) ERROR("listen error", r)  fprintf(stderr, "Listening on localhost:7000/n");  uv_run(loop, UV_RUN_DEFAULT);  return 0;}

int ws_listen(ws_server_t *ptr, uv_loop_t *loop, int port, ws_malloc_connect cb, void *cb_obj){	ptr->loop = loop;	ptr->port = port;	ptr->cb.cb_malloc = cb;	ptr->cb.obj_malloc = cb_obj;	uv_tcp_init(ptr->loop, &ptr->server);	ptr->server.data = ptr;	struct sockaddr_in addr;	uv_ip4_addr("0.0.0.0", port, &addr);	uv_tcp_bind(&ptr->server, (const struct sockaddr*)&addr, 0);	uv_listen((uv_stream_t *)(&ptr->server), 1000, cb_connection);	return 0;}

int main (int argc, char** argv){	int r;	server_param = parse_arguments (argc, argv);	LOG ("Extracting data ...");	training_set = server_extract_data (server_param);	LOG ("Learning ...");	compile_training_set (training_set);	factors = learn (training_set, server_param->model);	factors_backup = copy_learned_factors (factors);	LOG ("Learning completed");	complete = malloc(20 *sizeof(int));	memset(complete,0,20 *sizeof(int));	//parser_settings.on_headers_complete = on_headers_complete;	parser_settings.on_url = on_url;	parser_settings.on_header_value = on_value;	uv_loop = uv_default_loop();	r = uv_tcp_init (uv_loop, &server);	CHECK (r, "bind");	struct sockaddr_in address = uv_ip4_addr ("0.0.0.0", server_param->port);	r = uv_tcp_bind (&server, address);	CHECK (r, "bind");	uv_listen ( (uv_stream_t*) &server, 128, on_connect);	LOGF ("listening on port %u", server_param->port);    	uv_timer_t timer;    	r = uv_timer_init(uv_default_loop(), &timer);    	assert(r == 0);   	r = uv_timer_start(&timer, timer_cb, 10000, 10000);    	assert(r == 0);	  	r = uv_mutex_init(&factors_mutex);  	assert(r == 0);  	r = uv_mutex_init(&factors_backup_mutex);  	assert(r == 0);  	r = uv_mutex_init(&tset_mutex);  	assert(r == 0);	uv_run (uv_loop);}

static void make_server (int port, int sel) {   struct clt *clt = malloc (sizeof (struct clt));   uv_tcp_init (loop, &clt->server);   clt->server.data = clt;   /* Set up a listener and start a new machine for each    * incoming connection. (I'm not going into stdin/out    * right now, libuv isn't scary but...)    */   struct sockaddr_in bind_addr;   uv_ip4_addr ("0.0.0.0", port, &bind_addr);   uv_tcp_bind (&clt->server, (struct sockaddr *)&bind_addr, 0);   int r = uv_listen ((uv_stream_t*) &clt->server, 128, on_new_connection);   if (r) {      fprintf (stderr, "Listen error %s/n",               uv_err_name (r));      exit (1);   }}

VALUE rbuv_tcp_bind(VALUE self, VALUE ip, VALUE port) {  const char *uv_ip;  int uv_port;  rbuv_tcp_t *rbuv_tcp;  struct sockaddr_in bind_addr;    uv_ip = RSTRING_PTR(ip);  uv_port = FIX2INT(port);    bind_addr = uv_ip4_addr(uv_ip, uv_port);    Data_Get_Struct(self, rbuv_tcp_t, rbuv_tcp);  RBUV_CHECK_UV_RETURN(uv_tcp_bind(rbuv_tcp->uv_handle, bind_addr));    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;}

int main() {  int r;  loop = uv_default_loop();  setup_workers();  struct sockaddr_in bind_addr;  r = uv_ip4_addr("0.0.0.0", 7000, &bind_addr);  if (r) ERROR("obtaining ipv4 address", r);  uv_tcp_t server;  uv_tcp_init(loop, &server);  r = uv_tcp_bind(&server, (const struct sockaddr*) &bind_addr);  if (r) ERROR("binding server to socket", r);  r = uv_listen((uv_stream_t*) &server, 128/*backlog*/, connection_cb);  if (r) ERROR("listening for connections", r);  return uv_run(loop, UV_RUN_DEFAULT);}

//ToDo: Server struct for state info?int main(int argc, char *argv[]){	struct sockaddr_in addr;	uv_loop_t *loop = uv_default_loop();	uv_ip4_addr("0.0.0.0", 25565, &addr);	uv_tcp_t server;	if (uv_tcp_init(loop, &server)) {		printf("Something has gone terribly wrong/n");		return -1;	}	if (uv_tcp_bind(&server, (struct sockaddr*)&addr, 0)) {		printf("Something has gone terribly wrong2/n");		return -1;	}	if (uv_listen((uv_stream_t*)&server, SOMAXCONN, server_connect_cb)) {		printf("Something has gone terribly wrong3/n");		return -1;	}	return uv_run(loop, UV_RUN_DEFAULT);}

    void    make_new_connections() {	assert(lock.lock_held_by_current_thread());	while (!connect_queue.empty()) {	    std::pair<connect_data *, chan_handle> pair = connect_queue.front();	    connect_queue.pop();            connect_data *cd = pair.first;	    struct sockaddr_in client_addr = uv_ip4_addr("0.0.0.0", 0);	    struct sockaddr_in server_addr = uv_ip4_addr(cd->ip_addr, 80);	    cd->thread = this;	    cd->chan = pair.second;	    cd->connect.data = cd;	    uv_tcp_init(loop, &cd->tcp);	    uv_tcp_bind(&cd->tcp, client_addr);	    uv_tcp_connect(&cd->connect, &cd->tcp, server_addr, connect_cb);	}    }