static int luv_interface_addresses(lua_State* L) {
uv_interface_address_t* interfaces;
int count, i;
char ip[INET6_ADDRSTRLEN];
char netmask[INET6_ADDRSTRLEN];
uv_interface_addresses(&interfaces, &count);
lua_newtable(L);
for (i = 0; i < count; i++) {
lua_getfield(L, -1, interfaces[i].name);
if (!lua_istable(L, -1)) {
lua_pop(L, 1);
lua_newtable(L);
lua_pushvalue(L, -1);
lua_setfield(L, -3, interfaces[i].name);
}
lua_newtable(L);
lua_pushboolean(L, interfaces[i].is_internal);
lua_setfield(L, -2, "internal");
lua_pushlstring(L, interfaces[i].phys_addr, sizeof(interfaces[i].phys_addr));
lua_setfield(L, -2, "mac");
if (interfaces[i].address.address4.sin_family == AF_INET) {
uv_ip4_name(&interfaces[i].address.address4, ip, sizeof(ip));
uv_ip4_name(&interfaces[i].netmask.netmask4, netmask, sizeof(netmask));
} else if (interfaces[i].address.address4.sin_family == AF_INET6) {
uv_ip6_name(&interfaces[i].address.address6, ip, sizeof(ip));
uv_ip6_name(&interfaces[i].netmask.netmask6, netmask, sizeof(netmask));
} else {
strncpy(ip, "<unknown sa family>", INET6_ADDRSTRLEN);
strncpy(netmask, "<unknown sa family>", INET6_ADDRSTRLEN);
}
lua_pushstring(L, ip);
lua_setfield(L, -2, "ip");
lua_pushstring(L, netmask);
lua_setfield(L, -2, "netmask");
lua_pushstring(L, luv_af_num_to_string(interfaces[i].address.address4.sin_family));
lua_setfield(L, -2, "family");
lua_rawseti(L, -2, lua_rawlen (L, -2) + 1);
lua_pop(L, 1);
}
uv_free_interface_addresses(interfaces, count);
return 1;
}
/* Modified from Python Modules/socketmodule.c */
static PyObject *
makesockaddr(struct sockaddr *addr, int addrlen)
{
struct sockaddr_in *addr4;
struct sockaddr_in6 *addr6;
char ip[INET6_ADDRSTRLEN];
if (addrlen == 0) {
/* No address */
Py_RETURN_NONE;
}
switch (addr->sa_family) {
case AF_INET:
{
addr4 = (struct sockaddr_in*)addr;
uv_ip4_name(addr4, ip, INET_ADDRSTRLEN);
return Py_BuildValue("si", ip, ntohs(addr4->sin_port));
}
case AF_INET6:
{
addr6 = (struct sockaddr_in6*)addr;
uv_ip6_name(addr6, ip, INET6_ADDRSTRLEN);
return Py_BuildValue("siii", ip, ntohs(addr6->sin6_port), addr6->sin6_flowinfo, addr6->sin6_scope_id);
}
default:
/* If we don't know the address family, don't raise an exception -- return it as a tuple. */
return Py_BuildValue("is#", addr->sa_family, addr->sa_data, sizeof(addr->sa_data));
}
}
extern bool sockaddr_host(struct sockaddr* addr, char* host, uint32_t host_len, bool* ipv6, uint16_t* port)
{
uint16_t family = addr->sa_family;
if (family == AF_INET) {
if (host != NULL) {
uv_ip4_name((sockaddr_in*)addr, host, host_len);
}
if (ipv6 != NULL) {
*ipv6 = false;
}
if (port != NULL) {
*port = ntohs(((sockaddr_in*)addr)->sin_port);
}
return true;
}
if (family == AF_INET6) {
if (host != NULL) {
uv_ip6_name((sockaddr_in6*)addr, host, host_len);
}
if (ipv6 != NULL) {
*ipv6 = true;
}
if (port != NULL) {
*port = ntohs(((sockaddr_in6*)addr)->sin6_port);
}
return true;
}
return false;
}
static void
on_udp_read(uv_udp_t* handle, int nread, uv_buf_t buf, struct sockaddr* addr, unsigned flags)
{
PyGILState_STATE gstate = PyGILState_Ensure();
char ip[INET6_ADDRSTRLEN];
struct sockaddr_in addr4;
struct sockaddr_in6 addr6;
uv_err_t err;
UDP *self;
PyObject *result, *address_tuple, *data, *py_errorno;
ASSERT(handle);
ASSERT(flags == 0);
self = (UDP *)handle->data;
ASSERT(self);
/* Object could go out of scope in the callback, increase refcount to avoid it */
Py_INCREF(self);
if (nread == 0) {
goto done;
}
if (nread > 0) {
ASSERT(addr);
if (addr->sa_family == AF_INET) {
addr4 = *(struct sockaddr_in*)addr;
uv_ip4_name(&addr4, ip, INET_ADDRSTRLEN);
address_tuple = Py_BuildValue("(si)", ip, ntohs(addr4.sin_port));
} else {
addr6 = *(struct sockaddr_in6*)addr;
uv_ip6_name(&addr6, ip, INET6_ADDRSTRLEN);
address_tuple = Py_BuildValue("(si)", ip, ntohs(addr6.sin6_port));
}
data = PyBytes_FromStringAndSize(buf.base, nread);
py_errorno = Py_None;
Py_INCREF(Py_None);
} else {
address_tuple = Py_None;
Py_INCREF(Py_None);
data = Py_None;
Py_INCREF(Py_None);
err = uv_last_error(UV_HANDLE_LOOP(self));
py_errorno = PyInt_FromLong((long)err.code);
}
result = PyObject_CallFunctionObjArgs(self->on_read_cb, self, address_tuple, PyInt_FromLong((long)flags), data, py_errorno, NULL);
if (result == NULL) {
handle_uncaught_exception(HANDLE(self)->loop);
}
Py_XDECREF(result);
Py_DECREF(address_tuple);
Py_DECREF(data);
Py_DECREF(py_errorno);
done:
Py_DECREF(self);
PyGILState_Release(gstate);
}
std::string host() const
{
char dest[46];
if (uv_ip6_name(const_cast<sockaddr_in6*>(&_addr), dest, 46) != 0)
throw std::runtime_error("Cannot parse IPv6 hostname");
return dest;
}
static PyObject *
UDP_func_getsockname(UDP *self)
{
int r, namelen;
char ip[INET6_ADDRSTRLEN];
struct sockaddr sockname;
struct sockaddr_in *addr4;
struct sockaddr_in6 *addr6;
namelen = sizeof(sockname);
RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL);
RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL);
r = uv_udp_getsockname((uv_udp_t *)UV_HANDLE(self), &sockname, &namelen);
if (r != 0) {
RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_UDPError);
return NULL;
}
if (sockname.sa_family == AF_INET) {
addr4 = (struct sockaddr_in*)&sockname;
uv_ip4_name(addr4, ip, INET_ADDRSTRLEN);
return Py_BuildValue("si", ip, ntohs(addr4->sin_port));
} else if (sockname.sa_family == AF_INET6) {
addr6 = (struct sockaddr_in6*)&sockname;
uv_ip6_name(addr6, ip, INET6_ADDRSTRLEN);
return Py_BuildValue("si", ip, ntohs(addr6->sin6_port));
} else {
PyErr_SetString(PyExc_UDPError, "unknown address type detected");
return NULL;
}
}
void TSockSys::OnGetHost(uv_getaddrinfo_t* RequestHnd, int Status, struct addrinfo* AddrInfo) {
// get SockHost
PSockHost SockHost;
if (SockSys.HndToSockHostH.IsKey((uint64)RequestHnd)) {
SockHost = SockSys.HndToSockHostH.GetDat((uint64)RequestHnd);
SockSys.HndToSockHostH.DelKey((uint64)RequestHnd);
} else {
free(RequestHnd); uv_freeaddrinfo(AddrInfo);
SaveToErrLog("SockSys.OnGetHost: unkown RequestId");
return;
}
// get SockEvent
PSockEvent SockEvent;
if (SockHost->IsSockEvent()) {
SockEvent = SockHost->GetSockEvent();
} else {
free(RequestHnd); uv_freeaddrinfo(AddrInfo);
SaveToErrLog("SockSys.OnGetHost: SockHost without SockEvent");
return;
}
// parse results
if (Status == 0) {
SockHost->Status = shsOk;
// temporary buffer for storing IPs
char _addr[64] = {'\0'};
// iterate over all the resolved IPs
struct addrinfo* AddrInfoIter = AddrInfo;
while (AddrInfoIter != NULL) {
//if (AddrInfoIter->ai_family
//AF_INET6
// get IP as string
if (AddrInfoIter->ai_family == AF_INET) {
uv_ip4_name((struct sockaddr_in*)AddrInfoIter->ai_addr, _addr, sizeof(_addr));
} else if (AddrInfoIter->ai_family == AF_INET6) {
uv_ip6_name((struct sockaddr_in6*)AddrInfoIter->ai_addr, _addr, sizeof(_addr));
}
TStr IpNum(_addr);
// add to SockHost
SockHost->AddIpNum(IpNum);
// go to the next IP on the list
AddrInfoIter = AddrInfoIter->ai_next;
}
} else if (Status == -1) {
// something went wrong
SockHost->Status = shsError;
SockHost->ErrMsg = "SockSys.OnGetHost: " + SockSys.GetLastErr();
} else {
// unkown status
SockHost->Status = shsError;
SockHost->ErrMsg = TStr::Fmt("SockSys.OnGetHost: unkown status %d", Status);
}
// clean up
free(RequestHnd); uv_freeaddrinfo(AddrInfo);
// callback
SockEvent->OnGetHost(SockHost);
}
inline bool from_ip6_addr(ip6_addr* src, std::string& ip, int& port)
{
char dest[46];
if(uv_ip6_name(src, dest, 46) == 0)
{
ip = dest;
port = static_cast<int>(ntohs(src->sin6_port));
return true;
}
return false;
}
int
ip_name(const struct sockaddr *ip, char *name, size_t size) {
int port = -1;
if (ip->sa_family == AF_INET) {
uv_ip4_name((const struct sockaddr_in*)ip, name, size);
port = ntohs(((const struct sockaddr_in*)ip)->sin_port);
} else if (ip->sa_family == AF_INET6) {
uv_ip6_name((const struct sockaddr_in6*)ip, name, size);
port = ntohs(((const struct sockaddr_in6*)ip)->sin6_port);
}
return port;
}
/** List available interfaces. */
static int net_interfaces(lua_State *L)
{
/* Retrieve interface list */
int count = 0;
char buf[INET6_ADDRSTRLEN]; /* http://tools.ietf.org/html/rfc4291 */
uv_interface_address_t *info = NULL;
uv_interface_addresses(&info, &count);
lua_newtable(L);
for (int i = 0; i < count; ++i) {
uv_interface_address_t iface = info[i];
lua_getfield(L, -1, iface.name);
if (lua_isnil(L, -1)) {
lua_pop(L, 1);
lua_newtable(L);
}
/* Address */
lua_getfield(L, -1, "addr");
if (lua_isnil(L, -1)) {
lua_pop(L, 1);
lua_newtable(L);
}
if (iface.address.address4.sin_family == AF_INET) {
uv_ip4_name(&iface.address.address4, buf, sizeof(buf));
} else if (iface.address.address4.sin_family == AF_INET6) {
uv_ip6_name(&iface.address.address6, buf, sizeof(buf));
} else {
buf[0] = '\0';
}
lua_pushstring(L, buf);
lua_rawseti(L, -2, lua_rawlen(L, -2) + 1);
lua_setfield(L, -2, "addr");
/* Hardware address. */
char *p = buf;
memset(buf, 0, sizeof(buf));
for (unsigned k = 0; k < sizeof(iface.phys_addr); ++k) {
sprintf(p, "%.2x:", iface.phys_addr[k] & 0xff);
p += 3;
}
*(p - 1) = '\0';
lua_pushstring(L, buf);
lua_setfield(L, -2, "mac");
/* Push table */
lua_setfield(L, -2, iface.name);
}
uv_free_interface_addresses(info, count);
return 1;
}
inline error read_addr_info(int status, addrinfo* res, char* buf, bool &is_ip4)
{
if(status == 0){
if(res->ai_family == AF_INET){
uv_ip4_name(reinterpret_cast<struct sockaddr_in*>(res->ai_addr), buf, res->ai_addrlen);
is_ip4 = true;
} else if(res->ai_family == AF_INET6) {
uv_ip6_name(reinterpret_cast<struct sockaddr_in6*>(res->ai_addr), buf, res->ai_addrlen);
is_ip4 = false;
} else {
is_ip4 = false;
return error(EAI_ADDRFAMILY);
}
}
return error(status);
}
void Client::connect(const std::vector<addrinfo*> &ipv4, const std::vector<addrinfo*> &ipv6)
{
addrinfo *addr = nullptr;
m_ipv6 = ipv4.empty() && !ipv6.empty();
if (m_ipv6) {
addr = ipv6[ipv6.size() == 1 ? 0 : rand() % ipv6.size()];
uv_ip6_name(reinterpret_cast<sockaddr_in6*>(addr->ai_addr), m_ip, 45);
}
else {
addr = ipv4[ipv4.size() == 1 ? 0 : rand() % ipv4.size()];
uv_ip4_name(reinterpret_cast<sockaddr_in*>(addr->ai_addr), m_ip, 16);
}
connect(addr->ai_addr);
}
static PyObject *
Util_func_interface_addresses(PyObject *obj)
{
int i, count;
char ip[INET6_ADDRSTRLEN];
uv_interface_address_t* interfaces;
uv_err_t err;
PyObject *result, *item, *exc_data;
UNUSED_ARG(obj);
err = uv_interface_addresses(&interfaces, &count);
if (err.code == UV_OK) {
result = PyList_New(0);
if (!result) {
uv_free_interface_addresses(interfaces, count);
PyErr_NoMemory();
return NULL;
}
for (i = 0; i < count; i++) {
item = PyDict_New();
if (!item)
continue;
PyDict_SetItemString(item, "name", PyString_FromString(interfaces[i].name));
PyDict_SetItemString(item, "is_internal", PyBool_FromLong((long)interfaces[i].is_internal));
if (interfaces[i].address.address4.sin_family == AF_INET) {
uv_ip4_name(&interfaces[i].address.address4, ip, INET_ADDRSTRLEN);
PyDict_SetItemString(item, "address", PyString_FromString(ip));
} else if (interfaces[i].address.address4.sin_family == AF_INET6) {
uv_ip6_name(&interfaces[i].address.address6, ip, INET6_ADDRSTRLEN);
PyDict_SetItemString(item, "address", PyString_FromString(ip));
}
if (PyList_Append(result, item))
continue;
Py_DECREF(item);
}
uv_free_interface_addresses(interfaces, count);
return result;
} else {
exc_data = Py_BuildValue("(is)", err.code, uv_strerror(err));
if (exc_data != NULL) {
PyErr_SetObject(PyExc_UVError, exc_data);
Py_DECREF(exc_data);
}
return NULL;
}
}
static int rava_system_interfaces(lua_State* L)
{
int size, i;
char buf[INET6_ADDRSTRLEN];
uv_interface_address_t* info;
int r = uv_interface_addresses(&info, &size);
lua_settop(L, 0);
if (r < 0) {
lua_pushboolean(L, 0);
luaL_error(L, uv_strerror(r));
return 2;
}
lua_newtable(L);
for (i = 0; i < size; i++) {
uv_interface_address_t addr = info[i];
lua_newtable(L);
lua_pushstring(L, addr.name);
lua_setfield(L, -2, "name");
lua_pushboolean(L, addr.is_internal);
lua_setfield(L, -2, "is_internal");
if (addr.address.address4.sin_family == PF_INET) {
uv_ip4_name(&addr.address.address4, buf, sizeof(buf));
}
else if (addr.address.address4.sin_family == PF_INET6) {
uv_ip6_name(&addr.address.address6, buf, sizeof(buf));
}
lua_pushstring(L, buf);
lua_setfield(L, -2, "address");
lua_rawseti(L, -2, i + 1);
}
uv_free_interface_addresses(info, size);
return 1;
}
static PyObject *
Util_func_interface_addresses(PyObject *obj)
{
int i, count;
char ip[INET6_ADDRSTRLEN];
uv_interface_address_t* interfaces;
uv_err_t err;
PyObject *result, *item, *exc_data;
UNUSED_ARG(obj);
err = uv_interface_addresses(&interfaces, &count);
if (err.code == UV_OK) {
result = PyList_New(count);
if (!result) {
uv_free_interface_addresses(interfaces, count);
return NULL;
}
for (i = 0; i < count; i++) {
item = PyStructSequence_New(&InterfaceAddressesResultType);
if (!item) {
Py_DECREF(result);
uv_free_interface_addresses(interfaces, count);
return NULL;
}
PyStructSequence_SET_ITEM(item, 0, Py_BuildValue("s", interfaces[i].name));
PyStructSequence_SET_ITEM(item, 1, PyBool_FromLong((long)interfaces[i].is_internal));
if (interfaces[i].address.address4.sin_family == AF_INET) {
uv_ip4_name(&interfaces[i].address.address4, ip, INET_ADDRSTRLEN);
} else if (interfaces[i].address.address4.sin_family == AF_INET6) {
uv_ip6_name(&interfaces[i].address.address6, ip, INET6_ADDRSTRLEN);
}
PyStructSequence_SET_ITEM(item, 2, Py_BuildValue("s", ip));
PyList_SET_ITEM(result, i, item);
}
uv_free_interface_addresses(interfaces, count);
return result;
} else {
exc_data = Py_BuildValue("(is)", err.code, uv_strerror(err));
if (exc_data != NULL) {
PyErr_SetObject(PyExc_UVError, exc_data);
Py_DECREF(exc_data);
}
return NULL;
}
}
int luv_interface_addresses(lua_State* L) {
uv_interface_address_t* interfaces;
int count, i;
char ip[INET6_ADDRSTRLEN];
uv_interface_addresses(&interfaces, &count);
lua_newtable(L);
for (i = 0; i < count; i++) {
const char* family;
lua_getfield(L, -1, interfaces[i].name);
if (!lua_istable(L, -1)) {
lua_pop(L, 1);
lua_newtable(L);
lua_pushvalue(L, -1);
lua_setfield(L, -3, interfaces[i].name);
}
lua_newtable(L);
lua_pushboolean(L, interfaces[i].is_internal);
lua_setfield(L, -2, "internal");
if (interfaces[i].address.address4.sin_family == AF_INET) {
uv_ip4_name(&interfaces[i].address.address4,ip, sizeof(ip));
family = "IPv4";
} else if (interfaces[i].address.address4.sin_family == AF_INET6) {
uv_ip6_name(&interfaces[i].address.address6, ip, sizeof(ip));
family = "IPv6";
} else {
strncpy(ip, "<unknown sa family>", INET6_ADDRSTRLEN);
family = "<unknown>";
}
lua_pushstring(L, ip);
lua_setfield(L, -2, "address");
lua_pushstring(L, family);
lua_setfield(L, -2, "family");
lua_rawseti(L, -2, lua_objlen (L, -2) + 1);
lua_pop(L, 1);
}
uv_free_interface_addresses(interfaces, count);
return 1;
}
std::string Address::to_string(bool with_port) const {
std::stringstream ss;
char host[INET6_ADDRSTRLEN + 1] = {'\0'};
if (family() == AF_INET) {
uv_ip4_name(const_cast<struct sockaddr_in*>(addr_in()), host,
INET_ADDRSTRLEN);
ss << host;
if (with_port) ss << ":" << port();
} else if (family() == AF_INET6) {
uv_ip6_name(const_cast<struct sockaddr_in6*>(addr_in6()), host,
INET6_ADDRSTRLEN);
if (with_port) ss << "[";
ss << host;
if (with_port) ss << "]:" << port();
} else {
assert(false);
}
return ss.str();
}
bool
ip_to_string(const struct sockaddr_storage *ip, char *ipstr, size_t len)
{
int ret;
switch(ip->ss_family)
{
case AF_INET:
ret = uv_ip4_name((struct sockaddr_in *)ip, ipstr, len);
break;
case AF_INET6:
ret = uv_ip6_name((struct sockaddr_in6 *)ip, ipstr, len);
break;
default:
assert(0);
return false;
}
return ret == 0;
}
extern bool socket_host(uv_os_sock_t sock, bool local, char* host, uint32_t host_len, bool* ipv6, uint16_t* port)
{
union sock_name_u {
sockaddr_in sock4;
sockaddr_in6 sock6;
} sock_name;
int sock_len = sizeof(sock_name);
#ifdef _WIN32
int result = local ? getsockname(sock, (sockaddr*)&sock_name, &sock_len) : getpeername(sock, (sockaddr*)&sock_name, &sock_len);
#else
int result = local ? getsockname(sock, (sockaddr*)&sock_name, (socklen_t*)&sock_len) : getpeername(sock, (sockaddr*)&sock_name, (socklen_t*)&sock_len);
#endif
if (result != 0)
return false;
uint16_t family = ((sockaddr*)&sock_name)->sa_family;
if (family == AF_INET) {
if (host != NULL) {
uv_ip4_name(&sock_name.sock4, host, host_len);
}
if (ipv6 != NULL) {
*ipv6 = false;
}
if (port != NULL) {
*port = ntohs(sock_name.sock4.sin_port);
}
return true;
}
if (family == AF_INET6) {
if (host != NULL) {
uv_ip6_name(&sock_name.sock6, host, host_len);
}
if (ipv6 != NULL) {
*ipv6 = true;
}
if (port != NULL) {
*port = ntohs(sock_name.sock6.sin6_port);
}
return true;
}
return false;
}
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 PyObject *
Util_func_interface_addresses(PyObject *obj)
{
static char buf[INET6_ADDRSTRLEN+1];
int i, count;
uv_interface_address_t* interfaces;
int err;
PyObject *result, *item, *exc_data;
UNUSED_ARG(obj);
err = uv_interface_addresses(&interfaces, &count);
if (err < 0) {
exc_data = Py_BuildValue("(is)", err, uv_strerror(err));
if (exc_data != NULL) {
PyErr_SetObject(PyExc_UVError, exc_data);
Py_DECREF(exc_data);
}
return NULL;
}
result = PyList_New(count);
if (!result) {
uv_free_interface_addresses(interfaces, count);
return NULL;
}
for (i = 0; i < count; i++) {
item = PyStructSequence_New(&InterfaceAddressesResultType);
if (!item) {
Py_DECREF(result);
uv_free_interface_addresses(interfaces, count);
return NULL;
}
PyStructSequence_SET_ITEM(item, 0, Py_BuildValue("s", interfaces[i].name));
PyStructSequence_SET_ITEM(item, 1, PyBool_FromLong((long)interfaces[i].is_internal));
if (interfaces[i].address.address4.sin_family == AF_INET) {
uv_ip4_name(&interfaces[i].address.address4, buf, sizeof(buf));
} else if (interfaces[i].address.address4.sin_family == AF_INET6) {
uv_ip6_name(&interfaces[i].address.address6, buf, sizeof(buf));
}
PyStructSequence_SET_ITEM(item, 2, Py_BuildValue("s", buf));
if (interfaces[i].netmask.netmask4.sin_family == AF_INET) {
uv_ip4_name(&interfaces[i].netmask.netmask4, buf, sizeof(buf));
} else if (interfaces[i].netmask.netmask4.sin_family == AF_INET6) {
uv_ip6_name(&interfaces[i].netmask.netmask6, buf, sizeof(buf));
}
PyStructSequence_SET_ITEM(item, 3, Py_BuildValue("s", buf));
PyOS_snprintf(buf, sizeof(buf), "%02x:%02x:%02x:%02x:%02x:%02x",
(unsigned char)interfaces[i].phys_addr[0],
(unsigned char)interfaces[i].phys_addr[1],
(unsigned char)interfaces[i].phys_addr[2],
(unsigned char)interfaces[i].phys_addr[3],
(unsigned char)interfaces[i].phys_addr[4],
(unsigned char)interfaces[i].phys_addr[5]);
PyStructSequence_SET_ITEM(item, 4, Py_BuildValue("s", buf));
PyList_SET_ITEM(result, i, item);
}
uv_free_interface_addresses(interfaces, count);
return result;
}
extern "C" int
rust_uv_ip6_name(struct sockaddr_in6* src, char* dst, size_t size) {
int result = uv_ip6_name(src, dst, size);
return result;
}
static void lluv_on_getaddrinfo(uv_getaddrinfo_t* arg, int status, struct addrinfo* res){
lluv_req_t *req = lluv_req_byptr((uv_req_t*)arg);
lluv_loop_t *loop = lluv_loop_byptr(arg->loop);
lua_State *L = loop->L;
struct addrinfo* a = res;
int i = 0;
LLUV_CHECK_LOOP_CB_INVARIANT(L);
lua_rawgeti(L, LLUV_LUA_REGISTRY, req->cb);
lluv_req_free(L, req);
assert(!lua_isnil(L, -1));
lluv_loop_pushself(L, loop);
if(status < 0){
uv_freeaddrinfo(res);
lluv_error_create(L, LLUV_ERR_UV, (uv_errno_t)status, NULL);
LLUV_LOOP_CALL_CB(L, loop, 2);
LLUV_CHECK_LOOP_CB_INVARIANT(L);
return;
}
lua_pushnil(L);
lua_newtable(L);
for(a = res; a; a = a->ai_next){
char buf[INET6_ADDRSTRLEN + 1];
int port;
lua_newtable(L);
switch (a->ai_family){
case AF_INET:{
struct sockaddr_in *sa = (struct sockaddr_in*)a->ai_addr;
uv_ip4_name(sa, buf, sizeof(buf));
lua_pushstring(L, buf);
lua_setfield(L, -2, "address");
if((port = ntohs(sa->sin_port))){
lua_pushinteger(L, port);
lua_setfield(L, -2, "port");
}
break;
}
case AF_INET6:{
struct sockaddr_in6 *sa = (struct sockaddr_in6*)a->ai_addr;
uv_ip6_name(sa, buf, sizeof(buf));
lua_pushstring(L, buf);
lua_setfield(L, -2, "address");
if((port = ntohs(sa->sin6_port))){
lua_pushinteger(L, port);
lua_setfield(L, -2, "port");
}
break;
}
}
if(a->ai_canonname){
lua_pushstring(L, a->ai_canonname);
lua_setfield(L, -2, "canonname");
}
lluv_push_ai_family(L, a->ai_family);
lua_setfield(L, -2, "family");
lluv_push_ai_stype(L, a->ai_socktype);
lua_setfield(L, -2, "socktype");
lluv_push_ai_proto(L, a->ai_protocol);
lua_setfield(L, -2, "protocol");
lua_rawseti(L, -2, ++i);
}
uv_freeaddrinfo(res);
LLUV_LOOP_CALL_CB(L, loop, 3);
LLUV_CHECK_LOOP_CB_INVARIANT(L);
}
