static int tcp6_echo_start(int port) { struct sockaddr_in6 addr6 = uv_ip6_addr("::1", port); int r; server = (uv_handle_t*)&tcpServer; serverType = TCP; r = uv_tcp_init(loop, &tcpServer); if (r) { /* TODO: Error codes */ fprintf(stderr, "Socket creation error\n"); return 1; } /* IPv6 is optional as not all platforms support it */ r = uv_tcp_bind6(&tcpServer, addr6); if (r) { /* show message but return OK */ fprintf(stderr, "IPv6 not supported\n"); return 0; } r = uv_listen((uv_stream_t*)&tcpServer, SOMAXCONN, on_connection); if (r) { /* TODO: Error codes */ fprintf(stderr, "Listen error\n"); return 1; } return 0; }
extern "C" int rust_uv_tcp_bind6 (uv_tcp_t* tcp_server, sockaddr_in6* addr_ptr) { // FIXME ref #2064 sockaddr_in6 addr = *addr_ptr; return uv_tcp_bind6(tcp_server, addr); }
static PyObject * TCP_func_bind(TCP *self, PyObject *args) { int r; struct sockaddr sa; PyObject *addr; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "O:bind", &addr)) { return NULL; } if (pyuv_parse_addr_tuple(addr, &sa) < 0) { /* Error is set by the function itself */ return NULL; } if (sa.sa_family == AF_INET) { r = uv_tcp_bind(&self->tcp_h, *(struct sockaddr_in *)&sa); } else { r = uv_tcp_bind6(&self->tcp_h, *(struct sockaddr_in6 *)&sa); } if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_TCPError); return NULL; } Py_RETURN_NONE; }
int uv__tcp_connect6(uv_connect_t* req, uv_tcp_t* handle, struct sockaddr_in6 address, uv_connect_cb cb) { uv_loop_t* loop = handle->loop; int addrsize = sizeof(struct sockaddr_in6); BOOL success; DWORD bytes; if (!uv_allow_ipv6) { uv__set_sys_error(loop, WSAEAFNOSUPPORT); return -1; } 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_bind6(handle, uv_addr_ip6_any_) < 0) return -1; if (!handle->func_connectex) { if(!uv_get_connectex_function(handle->socket, &handle->func_connectex)) { uv__set_sys_error(loop, WSAEAFNOSUPPORT); 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 = handle->func_connectex(handle->socket, (struct sockaddr*) &address, addrsize, NULL, 0, &bytes, &req->overlapped); if (UV_SUCCEEDED_WITHOUT_IOCP(success)) { handle->reqs_pending++; uv_ref(loop); uv_insert_pending_req(loop, (uv_req_t*)req); } else if (UV_SUCCEEDED_WITH_IOCP(success)) { handle->reqs_pending++; uv_ref(loop); } else { uv__set_sys_error(loop, WSAGetLastError()); return -1; } return 0; }
int uv_tcp_connect6(uv_connect_t* req, uv_tcp_t* handle, struct sockaddr_in6 address, uv_connect_cb cb) { int addrsize = sizeof(struct sockaddr_in6); BOOL success; DWORD bytes; if (!uv_allow_ipv6) { uv_new_sys_error(WSAEAFNOSUPPORT); return -1; } if (handle->flags & UV_HANDLE_BIND_ERROR) { LOOP->last_error = handle->error; return -1; } if (address.sin6_family != AF_INET6) { uv_set_sys_error(WSAEFAULT); return -1; } if (!(handle->flags & UV_HANDLE_BOUND) && uv_tcp_bind6(handle, uv_addr_ip6_any_) < 0) return -1; uv_req_init((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 = pConnectEx6(handle->socket, (struct sockaddr*) &address, addrsize, NULL, 0, &bytes, &req->overlapped); if (UV_SUCCEEDED_WITHOUT_IOCP(success)) { handle->reqs_pending++; uv_insert_pending_req((uv_req_t*)req); } else if (UV_SUCCEEDED_WITH_IOCP(success)) { handle->reqs_pending++; } else { uv_set_sys_error(WSAGetLastError()); return -1; } return 0; }
int luv_tcp_bind6(lua_State* 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_in6 address = uv_ip6_addr(host, port); if (uv_tcp_bind6(handle, address)) { uv_err_t err = uv_last_error(luv_get_loop(L)); return luaL_error(L, "tcp_bind6: %s", uv_strerror(err)); } return 0; }
static int echo_start(int port) { struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", port); struct sockaddr_in6 addr6 = uv_ip6_addr("::1", port); int r; r = uv_tcp_init(&server); if (r) { /* TODO: Error codes */ fprintf(stderr, "Socket creation error\n"); return 1; } r = uv_tcp_bind(&server, addr); if (r) { /* TODO: Error codes */ fprintf(stderr, "Bind error\n"); return 1; } r = uv_tcp_listen(&server, 128, on_connection); if (r) { /* TODO: Error codes */ fprintf(stderr, "Listen error\n"); return 1; } r = uv_tcp_init(&server6); if (r) { /* TODO: Error codes */ fprintf(stderr, "Socket creation error\n"); return 1; } /* IPv6 is optional as not all platforms support it */ r = uv_tcp_bind6(&server6, addr6); if (r) { /* show message but return OK */ fprintf(stderr, "IPv6 not supported\n"); return 0; } r = uv_tcp_listen(&server6, 128, on_connection); if (r) { /* TODO: Error codes */ fprintf(stderr, "Listen error on IPv6\n"); return 1; } return 0; }
void TSockSys::Listen(const uint64& SockId, const int& PortN, const bool& IPv6P) { // make sure it's a valid socket IAssert(IsSock(SockId)); uv_tcp_t* SockHnd = SockIdToHndH.GetDat(SockId); // special handling for v4 and v6 when binding if (!IPv6P) { // get address struct sockaddr_in Addr = uv_ip4_addr("0.0.0.0", PortN); // bind socket to port const int BindResCd = uv_tcp_bind(SockHnd, Addr); EAssertR(BindResCd == 0, "SockSys.Listen: Error bidning socket to port: " + SockSys.GetLastErr()); } else { // get address struct sockaddr_in6 Addr = uv_ip6_addr("::", PortN); // bind socket to port const int BindResCd = uv_tcp_bind6(SockHnd, Addr); EAssertR(BindResCd == 0, "SockSys.Listen: Error bidning socket to port: " + SockSys.GetLastErr()); } // make sure we have backlog of at least 128 const int BacklogQueue = (SOMAXCONN < 128) ? 128 : SOMAXCONN; // enable callbacks const int ListenResCd = uv_listen((uv_stream_t*)SockHnd, BacklogQueue, TSockSys::OnAccept); EAssertR(ListenResCd == 0, "SockSys.Listen: Error setting listener on socket: " + SockSys.GetLastErr()); }
int main(int argc, char *argv[]) { char **newargv = uv_setup_args(argc, argv); char *server_listen = SERVER_LISTEN; int server_port = SERVER_PORT; uint8_t *password = (uint8_t *)PASSWORD; uint8_t crypt_method = CRYPTO_METHOD; char *pid_path = PID_FILE; char opt; while((opt = getopt(argc, newargv, "l:p:k:f:m:")) != -1) { // not portable to windows switch(opt) { case 'l': server_listen = optarg; break; case 'p': server_port = atoi(optarg); break; case 'k': password = (uint8_t *)optarg; break; case 'f': pid_path = optarg; break; case 'm': if (!strcmp("rc4", optarg)) crypt_method = METHOD_RC4; else if (!strcmp("shadow", optarg)) crypt_method = METHOD_SHADOWCRYPT; break; default: fprintf(stderr, USAGE, newargv[0]); abort(); } } FILE *pid_file = fopen(pid_path, "wb"); if (!pid_file) FATAL("fopen failed, %s", strerror(errno)); fprintf(pid_file, "%d", getpid()); fclose(pid_file); char *process_title = malloc(PROCESS_TITLE_LENGTH); // we do not like waste memory if (!process_title) FATAL("malloc() failed!"); snprintf(process_title, PROCESS_TITLE_LENGTH, PROCESS_TITLE, server_port); uv_set_process_title(process_title); free(process_title); LOGI(WELCOME_MESSAGE); if (crypt_method == METHOD_SHADOWCRYPT) LOGI("Using shadowcrypt crypto"); else if (crypt_method == METHOD_RC4) LOGI("Using RC4 crypto"); else FATAL("Crypto unknown!"); make_encryptor(NULL, &crypto, crypt_method, password); LOGI("Crypto ready"); int n; uv_loop_t *loop = uv_default_loop(); uv_tcp_t listener; struct sockaddr_in6 addr = uv_ip6_addr(server_listen, server_port); n = uv_tcp_init(loop, &listener); if (n) SHOW_UV_ERROR_AND_EXIT(loop); n = uv_tcp_bind6(&listener, addr); if (n) SHOW_UV_ERROR_AND_EXIT(loop); n = uv_listen((uv_stream_t*)(void *)&listener, 5, connect_cb); if (n) SHOW_UV_ERROR_AND_EXIT(loop); LOGI("Listening on %s:%d", server_listen, server_port); #ifndef NDEBUG setup_signal_handler(loop); #endif /* !NDEBUG */ return uv_run(loop); }