Address HttpRequest::serverAddress() {
Address address;
if (_handle.isTcp) {
struct sockaddr_in addr = {0};
int len = sizeof(sockaddr_in);
int r = uv_tcp_getsockname(&_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;
}
static int tcp_get_localip(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_getsockname(&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;
}
int luv_tcp_getsockname(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_getsockname(handle, (struct sockaddr*)(&address), &addrlen)) {
uv_err_t err = uv_last_error(luv_get_loop(L));
return luaL_error(L, "tcp_getsockname: %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;
}
static void tcp_connector(void) {
struct sockaddr_in server_addr;
struct sockaddr sockname;
int r, namelen;
ASSERT(0 == uv_ip4_addr("127.0.0.1", server_port, &server_addr));
r = uv_tcp_init(loop, &tcp);
tcp.data = &connect_req;
ASSERT(!r);
r = uv_tcp_connect(&connect_req,
&tcp,
(const struct sockaddr*) &server_addr,
on_connect);
ASSERT(!r);
/* Fetch the actual port used by the connecting socket. */
namelen = sizeof sockname;
r = uv_tcp_getsockname(&tcp, &sockname, &namelen);
ASSERT(!r);
ASSERT(sockname.sa_family == AF_INET);
connect_port = ntohs(((struct sockaddr_in*) &sockname)->sin_port);
ASSERT(connect_port > 0);
}
static grpc_error *add_socket_to_server(grpc_tcp_server *s, uv_tcp_t *handle,
const grpc_resolved_address *addr,
unsigned port_index,
grpc_tcp_listener **listener) {
grpc_tcp_listener *sp = NULL;
int port = -1;
int status;
grpc_error *error;
grpc_resolved_address sockname_temp;
// The last argument to uv_tcp_bind is flags
status = uv_tcp_bind(handle, (struct sockaddr *)addr->addr, 0);
if (status != 0) {
error = GRPC_ERROR_CREATE("Failed to bind to port");
error =
grpc_error_set_str(error, GRPC_ERROR_STR_OS_ERROR, uv_strerror(status));
return error;
}
status = uv_listen((uv_stream_t *)handle, SOMAXCONN, on_connect);
if (status != 0) {
error = GRPC_ERROR_CREATE("Failed to listen to port");
error =
grpc_error_set_str(error, GRPC_ERROR_STR_OS_ERROR, uv_strerror(status));
return error;
}
sockname_temp.len = (int)sizeof(struct sockaddr_storage);
status = uv_tcp_getsockname(handle, (struct sockaddr *)&sockname_temp.addr,
(int *)&sockname_temp.len);
if (status != 0) {
error = GRPC_ERROR_CREATE("getsockname failed");
error =
grpc_error_set_str(error, GRPC_ERROR_STR_OS_ERROR, uv_strerror(status));
return error;
}
port = grpc_sockaddr_get_port(&sockname_temp);
GPR_ASSERT(port >= 0);
GPR_ASSERT(!s->on_accept_cb && "must add ports before starting server");
sp = gpr_malloc(sizeof(grpc_tcp_listener));
sp->next = NULL;
if (s->head == NULL) {
s->head = sp;
} else {
s->tail->next = sp;
}
s->tail = sp;
sp->server = s;
sp->handle = handle;
sp->port = port;
sp->port_index = port_index;
handle->data = sp;
s->open_ports++;
GPR_ASSERT(sp->handle);
*listener = sp;
return GRPC_ERROR_NONE;
}
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_getsockname
(uv_tcp_t* handle, sockaddr_storage* name) {
// sockaddr_storage is big enough to hold either
// sockaddr_in or sockaddr_in6
int namelen = sizeof(sockaddr_storage);
return uv_tcp_getsockname(handle, (sockaddr*)name, &namelen);
}
/*
*
* SOCKS5 Replies
* +----+-----+-------+------+----------+----------+
* |VER | REP | RSV | ATYP | BND.ADDR | BND.PORT |
* +----+-----+-------+------+----------+----------+
* | 1 | 1 | X'00' | 1 | Variable | 2 |
* +----+-----+-------+------+----------+----------+
*
*/
void
request_ack(struct client_context *client, enum s5_rep rep) {
struct remote_context *remote = client->remote;
struct sockaddr addr;
int addrlen = sizeof(addr);
int buflen;
uint8_t *buf;
buf = remote->packet.buf;
buf[0] = 0x05; // VER
buf[1] = rep; // REP
buf[2] = 0x00; // RSV
memset(&addr, 0, sizeof(addr));
if (client->cmd == S5_CMD_UDP_ASSOCIATE) {
uv_tcp_getsockname(&client->handle.tcp, (struct sockaddr *) &addr, &addrlen);
} else {
uv_tcp_getsockname(&remote->handle.tcp, (struct sockaddr *) &addr, &addrlen);
}
if (addr.sa_family == AF_INET6) {
buf[3] = 0x04; /* ATYP - IPv6. */
const struct sockaddr_in6 *addr6 = (const struct sockaddr_in6 *)&addr;
memcpy(buf + 4, &addr6->sin6_addr, 16); /* BND.ADDR */
memcpy(buf + 20, &addr6->sin6_port, 2); /* BND.PORT */
buflen = 22;
} else {
buf[3] = 0x01; /* ATYP - IPv4. */
const struct sockaddr_in *addr4 = (const struct sockaddr_in *)&addr;
memcpy(buf + 4, &addr4->sin_addr, 4); /* BND.ADDR */
memcpy(buf + 8, &addr4->sin_port, 2); /* BND.PORT */
buflen = 10;
}
if (rep == S5_REP_SUCCESSED) {
if (client->cmd == S5_CMD_CONNECT) {
client->stage = XSTAGE_FORWARD;
} else {
client->stage = XSTAGE_UDP_RELAY;
}
} else {
client->stage = XSTAGE_TERMINATE;
}
forward_to_client(client, buf, buflen);
}
static int luv_tcp_getsockname(lua_State* L) {
uv_tcp_t* handle = luv_check_tcp(L, 1);
struct sockaddr_storage address;
int addrlen = sizeof(address);
int ret = uv_tcp_getsockname(handle, (struct sockaddr*)&address, &addrlen);
if (ret < 0) return luv_error(L, ret);
parse_sockaddr(L, &address, addrlen);
return 1;
}
static int lluv_tcp_getsockname(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_getsockname(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);
}
int uv_getsockname(uv_handle_t* handle, struct sockaddr* name, int* namelen) {
switch (handle->type) {
case UV_TCP:
return uv_tcp_getsockname((uv_tcp_t*) handle, name, namelen);
case UV_UDP:
return uv_udp_getsockname((uv_udp_t*) handle, name, namelen);
default:
uv_set_sys_error(WSAENOTSOCK);
return -1;
}
}
void test_succeeds(void) {
grpc_resolved_address resolved_addr;
struct sockaddr_in *addr = (struct sockaddr_in *)resolved_addr.addr;
uv_tcp_t *svr_handle = gpr_malloc(sizeof(uv_tcp_t));
int connections_complete_before;
grpc_closure done;
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
gpr_log(GPR_DEBUG, "test_succeeds");
memset(&resolved_addr, 0, sizeof(resolved_addr));
resolved_addr.len = sizeof(struct sockaddr_in);
addr->sin_family = AF_INET;
/* create a dummy server */
GPR_ASSERT(0 == uv_tcp_init(uv_default_loop(), svr_handle));
GPR_ASSERT(0 == uv_tcp_bind(svr_handle, (struct sockaddr *)addr, 0));
GPR_ASSERT(0 == uv_listen((uv_stream_t *)svr_handle, 1, connection_cb));
gpr_mu_lock(g_mu);
connections_complete_before = g_connections_complete;
gpr_mu_unlock(g_mu);
/* connect to it */
GPR_ASSERT(uv_tcp_getsockname(svr_handle, (struct sockaddr *)addr,
(int *)&resolved_addr.len) == 0);
GRPC_CLOSURE_INIT(&done, must_succeed, NULL, grpc_schedule_on_exec_ctx);
grpc_tcp_client_connect(&exec_ctx, &done, &g_connecting, NULL, NULL,
&resolved_addr, gpr_inf_future(GPR_CLOCK_REALTIME));
gpr_mu_lock(g_mu);
while (g_connections_complete == connections_complete_before) {
grpc_pollset_worker *worker = NULL;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work",
grpc_pollset_work(&exec_ctx, g_pollset, &worker,
gpr_now(GPR_CLOCK_MONOTONIC),
grpc_timeout_seconds_to_deadline(5))));
gpr_mu_unlock(g_mu);
grpc_exec_ctx_flush(&exec_ctx);
gpr_mu_lock(g_mu);
}
// This will get cleaned up when the pollset runs again or gets shutdown
uv_close((uv_handle_t *)svr_handle, close_cb);
gpr_mu_unlock(g_mu);
grpc_exec_ctx_finish(&exec_ctx);
}
net::Address TCPSocket::address() const
{
if (!active())
return net::Address();
//throw std::runtime_error("Invalid TCP socket: No address");
struct sockaddr_storage address;
int addrlen = sizeof(address);
int r = uv_tcp_getsockname(ptr<uv_tcp_t>(),
reinterpret_cast<sockaddr*>(&address),
&addrlen);
if (r)
return net::Address();
//throwLastError("Invalid TCP socket: No address");
return net::Address(reinterpret_cast<const sockaddr*>(&address), addrlen);
}
bool tcp_server::set_local_address()
{
int err;
int len = sizeof(m_local_addr);
err = uv_tcp_getsockname(m_uv_handle, (struct sockaddr*)&m_local_addr, &len);
if (err)
{
osd_printf_error("uv_tcp_getsockname() failed: %s\n", uv_strerror(err));
return false;
}
int family;
GetAddressInfo((const struct sockaddr*)&m_local_addr, &family, m_local_ip, &m_local_port);
return true;
}
static int tcp_server_tostring(lua_State *l)
{
tcp_udata_t *udata = server_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)
lua_pushliteral(l, "tcp server (closed)");
else if (!uv_tcp_getsockname(&handle->handle, &sockname, &namelen) &&
!uv_ip4_name(sin, ip, sizeof ip))
lua_pushfstring(l, "tcp server (%s:%d)", ip, ntohs(sin->sin_port));
else
lua_pushliteral(l, "tcp server (invalid)");
return 1;
}
static PyObject *
TCP_func_getsockname(TCP *self)
{
int err, namelen;
struct sockaddr_storage sockname;
RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL);
RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL);
namelen = sizeof(sockname);
err = uv_tcp_getsockname(&self->tcp_h, (struct sockaddr *)&sockname, &namelen);
if (err < 0) {
RAISE_UV_EXCEPTION(err, PyExc_TCPError);
return NULL;
}
return makesockaddr((struct sockaddr *)&sockname);
}
static PyObject *
TCP_func_getsockname(TCP *self)
{
int r, namelen;
struct sockaddr sockname;
namelen = sizeof(sockname);
RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL);
RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL);
r = uv_tcp_getsockname(&self->tcp_h, &sockname, &namelen);
if (r != 0) {
RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_TCPError);
return NULL;
}
return makesockaddr(&sockname, namelen);
}
static int tcp_get_localport(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_getsockname(&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;
}
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);
}
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::GetLocalIpNum(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 SockName;
int NameLen = sizeof(SockName);
const int ResCd = uv_tcp_getsockname(SockHnd, &SockName, &NameLen);
EAssertR(ResCd == 0, "SockSys.GetLocalIpNum: " + SockSys.GetLastErr());
// decode IP
char SockIpNum[64];
if (SockName.sa_family == AF_INET) {
uv_ip4_name((sockaddr_in*)&SockName, SockIpNum, sizeof(SockIpNum));
} else if (SockName.sa_family == AF_INET6) {
uv_ip6_name((sockaddr_in6*)&SockName, SockIpNum, sizeof(SockIpNum));
} else {
throw TExcept::New("SockSys.GetLocalIpNum: unkown address family");
}
// return
return TStr(SockIpNum);
}
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) {
struct sockaddr sockname, peername;
int namelen;
uv_handle_t* handle;
int r;
if (status != 0) {
fprintf(stderr, "Connect error %d\n",
uv_last_error(loop).code);
}
ASSERT(status == 0);
handle = (uv_handle_t*) malloc(sizeof(uv_tcp_t));
ASSERT(handle != NULL);
r = uv_tcp_init(loop, (uv_tcp_t*)handle);
ASSERT(r == 0);
/* associate server with stream */
handle->data = server;
r = uv_accept(server, (uv_stream_t*)handle);
ASSERT(r == 0);
namelen = sizeof sockname;
r = uv_tcp_getsockname((uv_tcp_t*) handle, &sockname, &namelen);
ASSERT(r == 0);
check_sockname(&sockname, "127.0.0.1", server_port, "accepted socket");
getsocknamecount++;
namelen = sizeof peername;
r = uv_tcp_getpeername((uv_tcp_t*) handle, &peername, &namelen);
ASSERT(r == 0);
check_sockname(&peername, "127.0.0.1", connect_port, "accepted socket peer");
getpeernamecount++;
r = uv_read_start((uv_stream_t*)handle, alloc, after_read);
ASSERT(r == 0);
}
JL_DLLEXPORT int jl_tcp_getsockname(uv_tcp_t *handle, uint16_t* port,
void* host, uint32_t* family)
{
int namelen;
struct sockaddr_storage addr;
memset(&addr, 0, sizeof(struct sockaddr_storage));
namelen = sizeof addr;
int res = uv_tcp_getsockname(handle, (struct sockaddr*)&addr, &namelen);
*family = addr.ss_family;
if (addr.ss_family == AF_INET) {
struct sockaddr_in* addr4 = (struct sockaddr_in*)&addr;
*port = addr4->sin_port;
memcpy(host, &(addr4->sin_addr), 4);
} else if (addr.ss_family == AF_INET6) {
struct sockaddr_in6* addr6 = (struct sockaddr_in6*)&addr;
*port = addr6->sin6_port;
memcpy(host, &(addr6->sin6_addr), 16);
} else {
return -1;
}
return res;
}
static int tcp_tostring(lua_State *l)
{
tcp_udata_t *udata = connection_udata(l);
ls_tcp_t *handle = udata->handle;
struct sockaddr lsockname, rsockname;
int lnamelen = sizeof(lsockname);
int rnamelen = sizeof(rsockname);
struct sockaddr_in *lsin = (struct sockaddr_in*)&lsockname;
struct sockaddr_in *rsin = (struct sockaddr_in*)&rsockname;
char lip[17], rip[17];
if (handle == NULL)
lua_pushliteral(l, "tcp connection (closed)");
else if (!uv_tcp_getsockname(&handle->handle, &lsockname, &lnamelen) &&
!uv_ip4_name(lsin, lip, sizeof lip) &&
!uv_tcp_getpeername(&handle->handle, &rsockname, &rnamelen) &&
!uv_ip4_name(rsin, rip, sizeof rip))
lua_pushfstring(l, "tcp connection (local: %s:%d, remote: %s:%d)", lip, ntohs(lsin->sin_port), rip, ntohs(rsin->sin_port));
else
lua_pushliteral(l, "tcp connection (invalid)");
return 1;
}
int UvTcpSocket::getSockname(struct sockaddr_in* name)
{
int size = sizeof sockaddr_in;
return uv_tcp_getsockname(m_uv_tcp, (sockaddr*)name, &size);
}
grpc_error *grpc_tcp_server_add_port(grpc_tcp_server *s,
const grpc_resolved_address *addr,
int *port) {
// This function is mostly copied from tcp_server_windows.c
grpc_tcp_listener *sp = NULL;
uv_tcp_t *handle;
grpc_resolved_address addr6_v4mapped;
grpc_resolved_address wildcard;
grpc_resolved_address *allocated_addr = NULL;
grpc_resolved_address sockname_temp;
unsigned port_index = 0;
int status;
grpc_error *error = GRPC_ERROR_NONE;
if (s->tail != NULL) {
port_index = s->tail->port_index + 1;
}
/* Check if this is a wildcard port, and if so, try to keep the port the same
as some previously created listener. */
if (grpc_sockaddr_get_port(addr) == 0) {
for (sp = s->head; sp; sp = sp->next) {
sockname_temp.len = sizeof(struct sockaddr_storage);
if (0 == uv_tcp_getsockname(sp->handle,
(struct sockaddr *)&sockname_temp.addr,
(int *)&sockname_temp.len)) {
*port = grpc_sockaddr_get_port(&sockname_temp);
if (*port > 0) {
allocated_addr = gpr_malloc(sizeof(grpc_resolved_address));
memcpy(allocated_addr, addr, sizeof(grpc_resolved_address));
grpc_sockaddr_set_port(allocated_addr, *port);
addr = allocated_addr;
break;
}
}
}
}
if (grpc_sockaddr_to_v4mapped(addr, &addr6_v4mapped)) {
addr = &addr6_v4mapped;
}
/* Treat :: or 0.0.0.0 as a family-agnostic wildcard. */
if (grpc_sockaddr_is_wildcard(addr, port)) {
grpc_sockaddr_make_wildcard6(*port, &wildcard);
addr = &wildcard;
}
handle = gpr_malloc(sizeof(uv_tcp_t));
status = uv_tcp_init(uv_default_loop(), handle);
if (status == 0) {
error = add_socket_to_server(s, handle, addr, port_index, &sp);
} else {
error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
"Failed to initialize UV tcp handle");
error =
grpc_error_set_str(error, GRPC_ERROR_STR_OS_ERROR,
grpc_slice_from_static_string(uv_strerror(status)));
}
gpr_free(allocated_addr);
if (error != GRPC_ERROR_NONE) {
grpc_error *error_out = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
"Failed to add port to server", &error, 1);
GRPC_ERROR_UNREF(error);
error = error_out;
*port = -1;
} else {
GPR_ASSERT(sp != NULL);
*port = sp->port;
}
return error;
}
int uvplus_tcp::getsockname(struct sockaddr *name, int *namelen) {
auto tcp = (uv_tcp_t *)context_ptr();
return uv_tcp_getsockname(tcp, name, namelen);
}
