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;
}
}
void
u3_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);
}
int
main(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);
}
}
