void client_accept_cb(uv_stream_t *server, int status) { struct client_context *client = new_client(); struct remote_context *remote = new_remote(idle_timeout); client->remote = remote; remote->client = client; uv_timer_init(server->loop, remote->timer); uv_tcp_init(server->loop, &client->handle.tcp); uv_tcp_init(server->loop, &remote->handle.tcp); int rc = uv_accept(server, &client->handle.stream); if (rc == 0) { int namelen = sizeof client->addr; uv_tcp_getpeername(&client->handle.tcp, &client->addr, &namelen); reset_timer(remote); // start timer connect_to_remote(remote); } else { logger_log(LOG_ERR, "accept error: %s", uv_strerror(rc)); close_client(client); close_remote(remote); } }
static int tcp_get_peerip(lua_State *l) { tcp_udata_t *udata = connection_udata(l); ls_tcp_t *handle = udata->handle; struct sockaddr sockname; int namelen = sizeof(sockname); struct sockaddr_in *sin = (struct sockaddr_in*)&sockname; char ip[17]; if (handle == NULL) return ls_error_return(l, LS_ERRCODE_EOF, "tcp connection closed"); if (uv_tcp_getpeername(&handle->handle, &sockname, &namelen)) { return ls_error_return(l, LS_ERRCODE_ERROR, "get sock name error"); } if (uv_ip4_name(sin, ip, sizeof ip)) { return ls_error_return(l, LS_ERRCODE_ERROR, "invalid ipv4."); } lua_pushboolean(l, 1); lua_pushstring(l, ip); return 2; }
static void do_accept(uv_stream_t* server, int status) { CHECK(status); GETDATA(ircd_t, ircd, server); struct irc_session *new_session = (struct irc_session *)malloc(sizeof(struct irc_session)); uv_tcp_init(uv_default_loop(),&new_session->handle); new_session->handle.data = new_session; new_session->buffer = NULL; new_session->ircd = ircd; new_session->mode = INITIALIZING; if (uv_accept((uv_stream_t*)&ircd->handle, (uv_stream_t*)&new_session->handle) < 0) { free(new_session); perror("accept"); } else { struct sockaddr_storage addr; int addrlen = sizeof(addr); uv_tcp_getpeername(&new_session->handle,(struct sockaddr*)&addr,&addrlen); printf("accepted connection from %s\n", sprint_addrport((struct sockaddr *)&addr)); new_session->inbuf_used = 0; new_session->next = ircd->session_list; if (!inet_ntop(AF_INET6, &((struct sockaddr_in6 *)&addr)->sin6_addr, new_session->ip, INET6_ADDRSTRLEN)) { perror("inet_ntop"); } ircd->session_list = new_session; uv_read_start((uv_stream_t*)&new_session->handle,alloc_buffer,on_read); } }
Address HttpRequest::clientAddress() { Address address; if (_handle.isTcp) { struct sockaddr_in addr = {0}; int len = sizeof(sockaddr_in); int r = uv_tcp_getpeername(&_handle.tcp, (struct sockaddr*)&addr, &len); if (r) { // TODO: warn? return address; } if (addr.sin_family != AF_INET) { // TODO: warn return address; } // addrstr is a pointer to static buffer, no need to free char* addrstr = inet_ntoa(addr.sin_addr); if (addrstr) address.host = std::string(addrstr); else { // TODO: warn? } address.port = ntohs(addr.sin_port); } return address; }
int luv_tcp_getpeername(lua_State* L) { uv_tcp_t* handle = (uv_tcp_t*)luv_checkudata(L, 1, "tcp"); int port = 0; char ip[INET6_ADDRSTRLEN]; int family; struct sockaddr_storage address; int addrlen = sizeof(address); if (uv_tcp_getpeername(handle, (struct sockaddr*)(&address), &addrlen)) { uv_err_t err = uv_last_error(luv_get_loop(L)); return luaL_error(L, "tcp_getpeername: %s", uv_strerror(err)); } family = address.ss_family; if (family == AF_INET) { struct sockaddr_in* addrin = (struct sockaddr_in*)&address; uv_inet_ntop(AF_INET, &(addrin->sin_addr), ip, INET6_ADDRSTRLEN); port = ntohs(addrin->sin_port); } else if (family == AF_INET6) { struct sockaddr_in6* addrin6 = (struct sockaddr_in6*)&address; uv_inet_ntop(AF_INET6, &(addrin6->sin6_addr), ip, INET6_ADDRSTRLEN); port = ntohs(addrin6->sin6_port); } lua_newtable(L); lua_pushnumber(L, port); lua_setfield(L, -2, "port"); lua_pushnumber(L, family); lua_setfield(L, -2, "family"); lua_pushstring(L, ip); lua_setfield(L, -2, "address"); return 1; }
void UvTcpSocket::on_connection1(uv_stream_t* stream, int status) { uv_stream_t* client = NULL; int conditon = SOCKET_READABLE; do { m_newConnection = NULL; ASSERT(status == 0); if (status) { print_info("connection error\r\n"); break; } client = (uv_stream_t*)malloc(sizeof uv_tcp_t); int ret = uv_tcp_init((uv_loop_t*)m_env->TaskScheduler()->loopHandle(), (uv_tcp_t*)client); ASSERT(ret == 0); if (ret) { LOG_ERROR("tcp error \r\n"); break; } ret = uv_accept(stream,(uv_stream_t*)client); ASSERT(ret == 0); if(ret) { LOG_ERROR("accept error\r\n"); break; } struct sockaddr_in addrIn ; int addrSize = sizeof(sockaddr); uv_tcp_getsockname((uv_tcp_t*)client, (sockaddr*)&addrIn, &addrSize); struct sockaddr_in addrInPeer ; uv_tcp_getpeername((uv_tcp_t*)client, (sockaddr*)&addrInPeer, &addrSize); char serverIp[128],client[128]; uv_ip4_name(&addrInPeer,client,128); uv_ip4_name(&addrIn,serverIp,128); LOG_DEBUG("%s:%d accept connection from %s:%d",serverIp, htons(addrIn.sin_port),client,htons(addrInPeer.sin_port)); m_newConnection = new UvTcpSocket(m_env,(uv_tcp_t*)client); if(m_ioHandlerProc) m_ioHandlerProc(m_ClientData, conditon); return ; } while (0); conditon |= SOCKET_EXCEPTION; if(m_ioHandlerProc) m_ioHandlerProc(m_ClientData, conditon); if(client) free(client); }
extern "C" int rust_uv_tcp_getpeername (uv_tcp_t* handle, sockaddr_storage* name) { // sockaddr_storage is big enough to hold either // sockaddr_in or sockaddr_in6 int namelen = sizeof(sockaddr_in); return uv_tcp_getpeername(handle, (sockaddr*)name, &namelen); }
PeerAddress UvTcpServerStream::GetPeerAddress() { sockaddr_storage addr; int len = sizeof(addr); uv_tcp_getpeername(m_client.get(), reinterpret_cast<sockaddr*>(&addr), &len); return PeerAddress(reinterpret_cast<sockaddr*>(&addr), static_cast<socklen_t>(len)); }
static int luv_tcp_getpeername(lua_State* L) { uv_tcp_t* handle = luv_check_tcp(L, 1); struct sockaddr_storage address; int addrlen = sizeof(address); int ret = uv_tcp_getpeername(handle, (struct sockaddr*)&address, &addrlen); if (ret < 0) return luv_error(L, ret); parse_sockaddr(L, &address, addrlen); return 1; }
static int lluv_tcp_getpeername(lua_State *L){ lluv_handle_t *handle = lluv_check_tcp(L, 1, LLUV_FLAG_OPEN); struct sockaddr_storage sa; int sa_len = sizeof(sa); int err = uv_tcp_getpeername(LLUV_H(handle, uv_tcp_t), (struct sockaddr*)&sa, &sa_len); lua_settop(L, 1); if(err < 0){ return lluv_fail(L, handle->flags, LLUV_ERR_UV, err, NULL); } return lluv_push_addr(L, &sa); }
static int get_nameinfo(lcb_io_opt_t iobase, lcb_sockdata_t *sockbase, struct lcb_nameinfo_st *ni) { my_sockdata_t *sock = (my_sockdata_t *)sockbase; my_iops_t *io = (my_iops_t *)iobase; uv_tcp_getpeername(&sock->tcp.t, ni->remote.name, ni->remote.len); uv_tcp_getsockname(&sock->tcp.t, ni->local.name, ni->local.len); (void)io; return 0; }
bud_client_error_t bud_client_fill_host(bud_client_t* client, bud_client_host_t* host) { int r; struct sockaddr_storage storage; int storage_size; struct sockaddr_in* addr; struct sockaddr_in6* addr6; storage_size = sizeof(storage); if (host == &client->remote) { r = uv_tcp_getpeername(&client->frontend.tcp, (struct sockaddr*) &storage, &storage_size); } else { r = uv_tcp_getsockname(&client->frontend.tcp, (struct sockaddr*) &storage, &storage_size); } if (r != 0) goto fatal; addr = (struct sockaddr_in*) &storage; addr6 = (struct sockaddr_in6*) &storage; host->family = storage.ss_family; if (storage.ss_family == AF_INET) { host->port = addr->sin_port; r = uv_inet_ntop(AF_INET, &addr->sin_addr, host->host, sizeof(host->host)); } else if (storage.ss_family == AF_INET6) { host->port = addr6->sin6_port; r = uv_inet_ntop(AF_INET6, &addr6->sin6_addr, host->host, sizeof(host->host)); } else { r = -1; goto fatal; } if (r != 0) goto fatal; host->host_len = strlen(host->host); return bud_client_ok(&client->backend); fatal: return bud_client_error(bud_error_num(kBudErrClientProxyline, r), &client->backend); }
void rig_pb_stream_accept_tcp_connection(rig_pb_stream_t *stream, uv_tcp_t *server) { uv_loop_t *loop = rut_uv_shell_get_loop(stream->shell); struct sockaddr name; int namelen; int err; c_return_if_fail(stream->type == STREAM_TYPE_DISCONNECTED); c_return_if_fail(stream->hostname == NULL); c_return_if_fail(stream->port == NULL); c_return_if_fail(stream->resolving == false); uv_tcp_init(loop, &stream->tcp.socket); stream->tcp.socket.data = stream; err = uv_accept((uv_stream_t *)server, (uv_stream_t *)&stream->tcp.socket); if (err != 0) { c_warning("Failed to accept tcp connection: %s", uv_strerror(err)); uv_close((uv_handle_t *)&stream->tcp.socket, NULL); return; } err = uv_tcp_getpeername(&stream->tcp.socket, &name, &namelen); if (err != 0) { c_warning("Failed to query peer address of tcp socket: %s", uv_strerror(err)); stream->hostname = c_strdup("unknown"); stream->port = c_strdup("0"); } else if (name.sa_family != AF_INET) { c_warning("Accepted connection isn't ipv4"); stream->hostname = c_strdup("unknown"); stream->port = c_strdup("0"); } else { struct sockaddr_in *addr = (struct sockaddr_in *)&name; char ip_address[17] = {'\0'}; uv_ip4_name(addr, ip_address, 16); stream->hostname = c_strdup(ip_address); stream->port = c_strdup_printf("%u", ntohs(addr->sin_port)); } stream->type = STREAM_TYPE_TCP; set_connected(stream); }
static void remote_timer_expire(uv_timer_t *handle) { struct remote_context *remote = handle->data; struct client_context *client = remote->client; if (verbose) { struct sockaddr peername; int namelen = sizeof peername; uv_tcp_getpeername(&client->handle.tcp, &peername, &namelen); char addr[INET6_ADDRSTRLEN + 1]; int port = ip_name(&peername, addr, sizeof addr); logger_log(LOG_WARNING, "%s:%d <-> %s connection timeout", addr, port, dest_addr_buf); } close_client(client); close_remote(remote); }
const char * melo_get_tcp_ip_port(uv_tcp_t* uvclient, char* ipbuf, int buflen, int* port) { struct sockaddr addr; int len = sizeof(addr); int r = uv_tcp_getpeername(uvclient, &addr, &len); if (r == 0) { return melo_get_ip_port(&addr, ipbuf, buflen, port); } else { printf("\n!!! [uvx] get client ip fails: %s\n", uv_strerror(r)); return NULL; } }
int SocketGetPeerInfo(SocketRef const socket, char *const out, size_t const max) { assert(max > 0); assert(out); if(!socket) return UV_EINVAL; struct sockaddr_storage peer[1]; int len = sizeof(*peer); int rc = uv_tcp_getpeername(socket->stream, (struct sockaddr *)peer, &len); if(rc < 0) return rc; uv_getnameinfo_t req[1]; rc = async_getnameinfo(req, (struct sockaddr *)peer, NI_NUMERICSERV); if(rc < 0) return rc; strlcpy(out, req->host, max); return 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 remote_timer_expire(uv_timer_t *handle) { struct remote_context *remote = handle->data; struct client_context *client = remote->client; if (verbose) { struct sockaddr peername; int namelen = sizeof peername; uv_tcp_getpeername(&client->handle.tcp, &peername, &namelen); char addr1[INET6_ADDRSTRLEN + 1]; char addr2[INET6_ADDRSTRLEN + 1]; int p1 = ip_name(&peername, addr1, sizeof addr2); int p2 = ip_name(&client->target_addr, addr2, sizeof(addr2)); logger_log(LOG_WARNING, "%s:%d <-> %s:%d timeout", addr1, p1, addr2, p2); } close_client(client); close_remote(remote); }
bool tcp_connection::set_peer_address() { int err; int len = sizeof(m_peer_addr); err = uv_tcp_getpeername(m_uv_handle, (struct sockaddr*)&m_peer_addr, &len); if (err) { osd_printf_error("uv_tcp_getpeername() failed: %s\n", uv_strerror(err)); return false; } int family; GetAddressInfo((const struct sockaddr*)&m_peer_addr, &family, m_peer_ip, &m_peer_port); return true; }
static void on_connect(uv_stream_t *server, int status) { grpc_tcp_listener *sp = (grpc_tcp_listener *)server->data; uv_tcp_t *client; grpc_endpoint *ep = NULL; grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; grpc_resolved_address peer_name; char *peer_name_string; int err; if (status < 0) { gpr_log(GPR_INFO, "Skipping on_accept due to error: %s", uv_strerror(status)); return; } client = gpr_malloc(sizeof(uv_tcp_t)); uv_tcp_init(uv_default_loop(), client); // UV documentation says this is guaranteed to succeed uv_accept((uv_stream_t *)server, (uv_stream_t *)client); // If the server has not been started, we discard incoming connections if (sp->server->on_accept_cb == NULL) { uv_close((uv_handle_t *)client, accepted_connection_close_cb); } else { peer_name_string = NULL; memset(&peer_name, 0, sizeof(grpc_resolved_address)); peer_name.len = sizeof(struct sockaddr_storage); err = uv_tcp_getpeername(client, (struct sockaddr *)&peer_name.addr, (int *)&peer_name.len); if (err == 0) { peer_name_string = grpc_sockaddr_to_uri(&peer_name); } else { gpr_log(GPR_INFO, "uv_tcp_getpeername error: %s", uv_strerror(status)); } ep = grpc_tcp_create(client, sp->server->resource_quota, peer_name_string); // Create acceptor. grpc_tcp_server_acceptor *acceptor = gpr_malloc(sizeof(*acceptor)); acceptor->from_server = sp->server; acceptor->port_index = sp->port_index; acceptor->fd_index = 0; sp->server->on_accept_cb(&exec_ctx, sp->server->on_accept_cb_arg, ep, NULL, acceptor); grpc_exec_ctx_finish(&exec_ctx); } }
static PyObject * TCP_func_getpeername(TCP *self) { int err, namelen; struct sockaddr_storage peername; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); namelen = sizeof(peername); err = uv_tcp_getpeername(&self->tcp_h, (struct sockaddr *)&peername, &namelen); if (err < 0) { RAISE_UV_EXCEPTION(err, PyExc_TCPError); return NULL; } return makesockaddr((struct sockaddr *)&peername); }
net::Address TCPSocket::peerAddress() const { //TraceLS(this) << "Get peer address: " << closed() << endl; if (!active()) return net::Address(); //throw std::runtime_error("Invalid TCP socket: No peer address"); struct sockaddr_storage address; int addrlen = sizeof(address); int r = uv_tcp_getpeername(ptr<uv_tcp_t>(), reinterpret_cast<sockaddr*>(&address), &addrlen); if (r) return net::Address(); //throwLastError("Invalid TCP socket: No peer address"); return net::Address(reinterpret_cast<const sockaddr*>(&address), addrlen); }
static PyObject * TCP_func_getpeername(TCP *self) { int r, namelen; struct sockaddr peername; namelen = sizeof(peername); RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); r = uv_tcp_getpeername(&self->tcp_h, &peername, &namelen); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_TCPError); return NULL; } return makesockaddr(&peername, namelen); }
bool TcpConnection::SetPeerAddress() { MS_TRACE(); int err; int len = sizeof(this->peerAddr); err = uv_tcp_getpeername(this->uvHandle, (struct sockaddr*)&this->peerAddr, &len); if (err) { MS_ERROR("uv_tcp_getpeername() failed: %s", uv_strerror(err)); return false; } int family; Utils::IP::GetAddressInfo((const struct sockaddr*)&this->peerAddr, &family, this->peerIP, &this->peerPort); return true; }
static void on_connect(uv_connect_t* req, int status) { struct sockaddr sockname, peername; int r, namelen; ASSERT(status == 0); namelen = sizeof sockname; r = uv_tcp_getsockname((uv_tcp_t*) req->handle, &sockname, &namelen); ASSERT(r == 0); check_sockname(&sockname, "127.0.0.1", 0, "connected socket"); getsocknamecount++; namelen = sizeof peername; r = uv_tcp_getpeername((uv_tcp_t*) req->handle, &peername, &namelen); ASSERT(r == 0); check_sockname(&peername, "127.0.0.1", server_port, "connected socket peer"); getpeernamecount++; uv_close((uv_handle_t*)&tcp, NULL); }
static int tcp_get_peerport(lua_State *l) { tcp_udata_t *udata = connection_udata(l); ls_tcp_t *handle = udata->handle; struct sockaddr sockname; int namelen = sizeof(sockname); struct sockaddr_in *sin = (struct sockaddr_in*)&sockname; if (handle == NULL) return ls_error_return(l, LS_ERRCODE_EOF, "tcp connection closed"); if (uv_tcp_getpeername(&handle->handle, &sockname, &namelen)) { return ls_error_return(l, LS_ERRCODE_ERROR, "get sock name error"); } lua_pushboolean(l, 1); lua_pushinteger(l, ntohs(sin->sin_port)); return 2; }
int uv_tcp_open(uv_tcp_t* handle, uv_os_sock_t sock) { WSAPROTOCOL_INFOW protocol_info; int opt_len; int err; struct sockaddr_storage saddr; int saddr_len; /* Detect the address family of the socket. */ opt_len = (int) sizeof protocol_info; if (getsockopt(sock, SOL_SOCKET, SO_PROTOCOL_INFOW, (char*) &protocol_info, &opt_len) == SOCKET_ERROR) { return uv_translate_sys_error(GetLastError()); } err = uv_tcp_set_socket(handle->loop, handle, sock, protocol_info.iAddressFamily, 1); if (err) { return uv_translate_sys_error(err); } /* Support already active socket. */ saddr_len = sizeof(saddr); if (!uv_tcp_getsockname(handle, (struct sockaddr*) &saddr, &saddr_len)) { /* Socket is already bound. */ handle->flags |= UV_HANDLE_BOUND; saddr_len = sizeof(saddr); if (!uv_tcp_getpeername(handle, (struct sockaddr*) &saddr, &saddr_len)) { /* Socket is already connected. */ uv_connection_init((uv_stream_t*) handle); handle->flags |= UV_HANDLE_READABLE | UV_HANDLE_WRITABLE; } } return 0; }
TStr TSockSys::GetPeerIpNum(const uint64& SockId) { // make sure it's a valid socket IAssert(IsSock(SockId)); uv_tcp_t* SockHnd = SockIdToHndH.GetDat(SockId); // get peer IP struct sockaddr PeerName; int NameLen = sizeof(PeerName); const int ResCd = uv_tcp_getpeername(SockHnd, &PeerName, &NameLen); EAssertR(ResCd == 0, "SockSys.GetLocalIpNum: " + SockSys.GetLastErr()); // decode IP char PeerIpNum[17]; if (PeerName.sa_family == AF_INET) { uv_ip4_name((sockaddr_in*)&PeerName, PeerIpNum, sizeof(PeerIpNum)); } else if (PeerName.sa_family == AF_INET6) { uv_ip6_name((sockaddr_in6*)&PeerName, PeerIpNum, sizeof(PeerIpNum)); } else { throw TExcept::New("SockSys.GetLocalIpNum: unkown address family"); } // return return TStr(PeerIpNum); }
static int tcp_listener(void) { struct sockaddr_in addr; struct sockaddr sockname, peername; int namelen; int r; ASSERT(0 == uv_ip4_addr("0.0.0.0", server_port, &addr)); 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); namelen = sizeof sockname; r = uv_tcp_getsockname(&tcpServer, &sockname, &namelen); ASSERT(r == 0); check_sockname(&sockname, "0.0.0.0", server_port, "server socket"); getsocknamecount++; namelen = sizeof sockname; r = uv_tcp_getpeername(&tcpServer, &peername, &namelen); ASSERT(r == UV_ENOTCONN); getpeernamecount++; return 0; }
static void on_connection(uv_stream_t* server, int status) { //当有客户端连接时触发 int r; Request* request; struct sockaddr_in sockaddr; //定义套接字地址 socklen_t addrlen; uv_stream_t* handle; dprint("on connection."); if (status != 0) { //状态判断, 状态必须为0 fprintf(stderr, "Connect error %d\n", uv_last_error(loop).code); } ASSERT(status == 0); handle = malloc(sizeof(uv_tcp_t)); GIL_LOCK(0); request = Request_init(); GIL_UNLOCK(0); r = uv_tcp_init(loop, (uv_tcp_t*)handle);//初始化连接流结构体 ASSERT(r == 0); r = uv_accept(server, handle); ASSERT(r == 0); //-----------------得到客户端信息 addrlen = sizeof(struct sockaddr_in); r = uv_tcp_getpeername((uv_tcp_t *)handle, (struct sockaddr *)&sockaddr, &addrlen); ASSERT(r == 0); request->client_addr = PyString_FromString(inet_ntoa(sockaddr.sin_addr)); request->client_fd = 1;//request->ev_watcher.socket; request->ev_watcher = handle; handle->data = request; DBG_REQ(request, "Accepted client %s:%d on fd %d", inet_ntoa(sockaddr.sin_addr), ntohs(sockaddr.sin_port), (int)(GET_HANDLE_FD(handle))); //@@@@@@@@@@@@@@@@@free(&sockaddr); //-----------------读事件循环 r = uv_read_start(handle, on_alloc, on_read); ASSERT(r == 0); }