Esempio n. 1
0
File: udp.c Progetto: EarlGray/ling
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;
}
Esempio n. 2
0
File: luv_udp.c Progetto: xming/lev
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;
}
Esempio n. 3
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_);
}
Esempio n. 4
0
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();
}
Esempio n. 5
0
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;
	}
	
}
Esempio n. 6
0
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);

}
Esempio n. 7
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;
}
Esempio n. 8
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);
}
Esempio n. 9
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;
 }
Esempio n. 10
0
//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);
}
Esempio n. 11
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;
}
Esempio n. 12
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);
}
Esempio n. 13
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);
}
Esempio n. 14
0
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);
}
Esempio n. 15
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);
}
Esempio n. 16
0
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);
}
Esempio n. 17
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;
}
Esempio n. 18
0
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();
}
Esempio n. 19
0
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;
}
Esempio n. 21
0
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;
}
Esempio n. 22
0
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;
}
Esempio n. 23
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);
}
Esempio n. 24
0
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();
}
Esempio n. 26
0
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;
}
Esempio n. 27
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;
    }
}
Esempio n. 28
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;
}
Esempio n. 29
0
File: udp.c Progetto: luvit/luv
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;
}
Esempio n. 30
0
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);
}