CassError cass_inet_from_string(const char* str, CassInet* output) {
#if UV_VERSION_MAJOR == 0
if (uv_inet_pton(AF_INET, str, output->address).code == UV_OK) {
#else
if (uv_inet_pton(AF_INET, str, output->address) == 0) {
#endif
output->address_length = CASS_INET_V4_LENGTH;
return CASS_OK;
#if UV_VERSION_MAJOR == 0
} else if (uv_inet_pton(AF_INET6, str, output->address).code == UV_OK) {
#else
} else if (uv_inet_pton(AF_INET6, str, output->address) == 0) {
#endif
output->address_length = CASS_INET_V6_LENGTH;
return CASS_OK;
} else {
return CASS_ERROR_LIB_BAD_PARAMS;
}
}
CassError cass_inet_from_string_n(const char* str,
size_t str_length,
CassInet* output) {
char buf[CASS_INET_STRING_LENGTH];
// Need space for null terminator
if (str_length > CASS_INET_STRING_LENGTH - 1) {
return CASS_ERROR_LIB_BAD_PARAMS;
}
memcpy(buf, str, str_length);
buf[str_length] = '\0';
return cass_inet_from_string(buf, output);
}
bool Address::validateIP(const std::string& addr)
{
char ia[sizeof(struct in6_addr)];
if (uv_inet_pton(AF_INET, addr.c_str(), &ia) == 0)
return true;
else if (uv_inet_pton(AF_INET6, addr.c_str(), &ia) == 0)
return true;
return false;
}
/* parse a Python tuple containing host, port, flowinfo, scope_id into a sockaddr struct */
static int
pyuv_parse_addr_tuple(PyObject *addr, struct sockaddr_storage *ss)
{
char *host;
int port;
unsigned int scope_id, flowinfo;
struct in_addr addr4;
struct in6_addr addr6;
struct sockaddr_in *sa4;
struct sockaddr_in6 *sa6;
flowinfo = scope_id = 0;
if (!PyTuple_Check(addr)) {
PyErr_Format(PyExc_TypeError, "address must be tuple, not %.500s", Py_TYPE(addr)->tp_name);
return -1;
}
if (!PyArg_ParseTuple(addr, "si|II", &host, &port, &flowinfo, &scope_id)) {
return -1;
}
if (port < 0 || port > 0xffff) {
PyErr_SetString(PyExc_OverflowError, "port must be 0-65535");
return -1;
}
if (flowinfo > 0xfffff) {
PyErr_SetString(PyExc_OverflowError, "flowinfo must be 0-1048575");
return -1;
}
memset(ss, 0, sizeof(struct sockaddr_storage));
if (uv_inet_pton(AF_INET, host, &addr4) == 0) {
/* it's an IPv4 address */
sa4 = (struct sockaddr_in *)ss;
sa4->sin_family = AF_INET;
sa4->sin_port = htons((short)port);
sa4->sin_addr = addr4;
return 0;
} else if (uv_inet_pton(AF_INET6, host, &addr6) == 0) {
/* it's an IPv4 address */
sa6 = (struct sockaddr_in6 *)ss;
sa6->sin6_family = AF_INET6;
sa6->sin6_port = htons((short)port);
sa6->sin6_addr = addr6;
sa6->sin6_flowinfo = flowinfo;
sa6->sin6_scope_id = scope_id;
return 0;
} else {
PyErr_SetString(PyExc_ValueError, "invalid IP address");
return -1;
}
}
void Address::init(const std::string& host, UInt16 port)
{
//TraceLS(this) << "Parse: " << host << ":" << port << endl;
char ia[sizeof(struct in6_addr)];
if (uv_inet_pton(AF_INET, host.c_str(), &ia) == 0)
_base = new IPv4AddressBase(&ia, htons(port));
else if (uv_inet_pton(AF_INET6, host.c_str(), &ia) == 0)
_base = new IPv6AddressBase(&ia, htons(port));
else
throw std::runtime_error("Invalid IP address format: " + host);
}
static PyObject *
DNSResolver_func_getnameinfo(DNSResolver *self, PyObject *args, PyObject *kwargs)
{
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;
ares_cb_data_t *cb_data;
PyObject *callback;
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 > 65536) {
PyErr_SetString(PyExc_ValueError, "port must be between 0 and 65536");
return NULL;
}
if (uv_inet_pton(AF_INET, addr, &addr4) == 1) {
sa4 = uv_ip4_addr(addr, port);
sa = (struct sockaddr *)&sa4;
length = sizeof(struct sockaddr_in);
} else if (uv_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;
}
cb_data = (ares_cb_data_t*) PyMem_Malloc(sizeof *cb_data);
if (!cb_data) {
return PyErr_NoMemory();
}
Py_INCREF(callback);
cb_data->resolver = self;
cb_data->cb = callback;
ares_getnameinfo(self->channel, sa, length, flags, &nameinfo_cb, (void *)cb_data);
Py_RETURN_NONE;
}
int uv_ip6_addr(const char* ip, int port, struct sockaddr_in6* addr) {
char address_part[40];
size_t address_part_size;
const char* zone_index;
memset(addr, 0, sizeof(*addr));
addr->sin6_family = AF_INET6;
addr->sin6_port = htons(port);
zone_index = strchr(ip, '%');
if (zone_index != NULL) {
address_part_size = zone_index - ip;
if (address_part_size >= sizeof(address_part))
address_part_size = sizeof(address_part) - 1;
memcpy(address_part, ip, address_part_size);
address_part[address_part_size] = '\0';
ip = address_part;
zone_index++; /* skip '%' */
/* NOTE: unknown interface (id=0) is silently ignored */
#ifdef _WIN32
addr->sin6_scope_id = atoi(zone_index);
#else
addr->sin6_scope_id = if_nametoindex(zone_index);
#endif
}
return uv_inet_pton(AF_INET6, ip, &addr->sin6_addr);
}
static PyObject *
DNSResolver_func_gethostbyaddr(DNSResolver *self, PyObject *args, PyObject *kwargs)
{
char *name;
int family, length;
void *address;
struct in_addr addr4;
struct in6_addr addr6;
ares_cb_data_t *cb_data;
PyObject *callback;
if (!PyArg_ParseTuple(args, "sO:gethostbyaddr", &name, &callback)) {
return NULL;
}
if (!PyCallable_Check(callback)) {
PyErr_SetString(PyExc_TypeError, "a callable is required");
return NULL;
}
if (uv_inet_pton(AF_INET, name, &addr4) == 1) {
family = AF_INET;
length = sizeof(struct in_addr);
address = (void *)&addr4;
} else if (uv_inet_pton(AF_INET6, name, &addr6) == 1) {
family = AF_INET6;
length = sizeof(struct in6_addr);
address = (void *)&addr6;
} else {
PyErr_SetString(PyExc_ValueError, "invalid IP address");
return NULL;
}
cb_data = (ares_cb_data_t*) PyMem_Malloc(sizeof *cb_data);
if (!cb_data) {
return PyErr_NoMemory();
}
Py_INCREF(callback);
cb_data->resolver = self;
cb_data->cb = callback;
ares_gethostbyaddr(self->channel, address, length, family, &host_cb, (void *)cb_data);
Py_RETURN_NONE;
}
extern "C" struct sockaddr*
rust_malloc_ip4_addr(char *name, int port) {
struct sockaddr_in *addr = (struct sockaddr_in*) calloc(1, rust_sockaddr_size());
assert(addr != NULL);
addr->sin_port = htons(port);
assert(uv_inet_pton(AF_INET, name, &addr->sin_addr) == 0);
addr->sin_family = AF_INET;
return (struct sockaddr*) addr;
}
/*
* Class: com_oracle_libuv_LibUV
* Method: _isIPv6
* Signature: (Ljava/lang/String;)Z
*/
JNIEXPORT jboolean JNICALL Java_com_oracle_libuv_LibUV__1isIPv6
(JNIEnv *env, jclass cls, jstring ip) {
const char *address = env->GetStringUTFChars(ip, JNI_FALSE);
char address_buffer[sizeof(struct in6_addr)];
if (uv_inet_pton(AF_INET6, address, &address_buffer).code == UV_OK) {
return JNI_TRUE;
}
return JNI_FALSE;
}
static int uv__udp_set_membership4(uv_udp_t* handle,
const struct sockaddr_in* multicast_addr,
const char* interface_addr,
uv_membership membership) {
int err;
int optname;
struct ip_mreq mreq;
if (handle->flags & UV_HANDLE_IPV6)
return UV_EINVAL;
/* If the socket is unbound, bind to inaddr_any. */
err = uv_udp_maybe_bind(handle,
(const struct sockaddr*) &uv_addr_ip4_any_,
sizeof(uv_addr_ip4_any_),
UV_UDP_REUSEADDR);
if (err)
return uv_translate_sys_error(err);
memset(&mreq, 0, sizeof mreq);
if (interface_addr) {
err = uv_inet_pton(AF_INET, interface_addr, &mreq.imr_interface.s_addr);
if (err)
return err;
} else {
mreq.imr_interface.s_addr = htonl(INADDR_ANY);
}
mreq.imr_multiaddr.s_addr = multicast_addr->sin_addr.s_addr;
switch (membership) {
case UV_JOIN_GROUP:
optname = IP_ADD_MEMBERSHIP;
break;
case UV_LEAVE_GROUP:
optname = IP_DROP_MEMBERSHIP;
break;
default:
return UV_EINVAL;
}
if (setsockopt(handle->socket,
IPPROTO_IP,
optname,
(char*) &mreq,
sizeof mreq) == SOCKET_ERROR) {
return uv_translate_sys_error(WSAGetLastError());
}
return 0;
}
int bud_config_str_to_addr(const char* host,
uint16_t port,
struct sockaddr_storage* addr) {
int r;
struct sockaddr_in* addr4;
struct sockaddr_in6* addr6;
addr4 = (struct sockaddr_in*) addr;
addr6 = (struct sockaddr_in6*) addr;
r = uv_inet_pton(AF_INET, host, &addr4->sin_addr);
if (r == 0) {
addr4->sin_family = AF_INET;
addr4->sin_port = htons(port);
} else {
addr6->sin6_family = AF_INET6;
r = uv_inet_pton(AF_INET6, host, &addr6->sin6_addr);
if (r == 0)
addr6->sin6_port = htons(port);
}
return r;
}
static int uv__udp_set_membership4(uv_udp_t* handle,
const struct sockaddr_in* multicast_addr,
const char* interface_addr,
uv_membership membership) {
struct ip_mreq mreq;
int optname;
int err;
memset(&mreq, 0, sizeof mreq);
if (interface_addr) {
err = uv_inet_pton(AF_INET, interface_addr, &mreq.imr_interface.s_addr);
if (err)
return err;
} else {
mreq.imr_interface.s_addr = htonl(INADDR_ANY);
}
mreq.imr_multiaddr.s_addr = multicast_addr->sin_addr.s_addr;
switch (membership) {
case UV_JOIN_GROUP:
optname = IP_ADD_MEMBERSHIP;
break;
case UV_LEAVE_GROUP:
optname = IP_DROP_MEMBERSHIP;
break;
default:
return -EINVAL;
}
if (setsockopt(handle->io_watcher.fd,
IPPROTO_IP,
optname,
&mreq,
sizeof(mreq))) {
return -errno;
}
return 0;
}
struct sockaddr_in6 uv_ip6_addr(const char* ip, int port) {
struct sockaddr_in6 addr;
#if defined(UV_PLATFORM_HAS_IP6_LINK_LOCAL_ADDRESS)
char address_part[40];
size_t address_part_size;
const char* zone_index;
#endif
memset(&addr, 0, sizeof(struct sockaddr_in6));
addr.sin6_family = AF_INET6;
addr.sin6_port = htons(port);
#if defined(UV_PLATFORM_HAS_IP6_LINK_LOCAL_ADDRESS)
zone_index = strchr(ip, '%');
if (zone_index != NULL) {
address_part_size = sizeof(address_part);
assert((unsigned)(zone_index - ip) < address_part_size);
strncpy(address_part, ip, zone_index - ip);
address_part[address_part_size - 1] = '\0';
ip = address_part;
zone_index++; /* skip '%' */
/* NOTE: unknown interface (id=0) is silently ignored */
#ifdef _WIN32
addr.sin6_scope_id = atoi(zone_index);
#else
addr.sin6_scope_id = if_nametoindex(zone_index);
#endif
}
#endif
/* result code is ignored - we assume ip is a valid IPv6 address */
uv_inet_pton(AF_INET6, ip, &addr.sin6_addr);
return addr;
}
int uv_ip6_addr(const char* ip, int port, struct sockaddr_in6* addr) {
#if defined(UV_PLATFORM_HAS_IP6_LINK_LOCAL_ADDRESS)
char address_part[40];
size_t address_part_size;
const char* zone_index;
#endif
memset(addr, 0, sizeof(*addr));
addr->sin6_family = AF_INET6;
addr->sin6_port = htons(port);
#if defined(UV_PLATFORM_HAS_IP6_LINK_LOCAL_ADDRESS)
zone_index = strchr(ip, '%');
if (zone_index != NULL) {
address_part_size = zone_index - ip;
if (address_part_size >= sizeof(address_part))
address_part_size = sizeof(address_part) - 1;
memcpy(address_part, ip, address_part_size);
address_part[address_part_size] = '\0';
ip = address_part;
zone_index++; /* skip '%' */
/* NOTE: unknown interface (id=0) is silently ignored */
#ifdef _WIN32
addr->sin6_scope_id = atoi(zone_index);
#else
addr->sin6_scope_id = if_nametoindex(zone_index);
#endif
}
#endif
/* TODO(bnoordhuis) Return an error when the address is bad. */
uv_inet_pton(AF_INET6, ip, &addr->sin6_addr);
return 0;
}
int uv_ip4_addr(const char* ip, int port, struct sockaddr_in* addr) {
memset(addr, 0, sizeof(*addr));
addr->sin_family = AF_INET;
addr->sin_port = htons(port);
return uv_inet_pton(AF_INET, ip, &(addr->sin_addr.s_addr));
}
static int
set_dns_servers(DNSResolver *self, PyObject *value)
{
char *server;
int i, r, length, ret;
struct ares_addr_node *servers;
PyObject *server_list = value;
PyObject *item;
ret = 0;
if (!PyList_Check(server_list)) {
PyErr_SetString(PyExc_TypeError, "servers argument must be a list");
return -1;
}
length = PyList_Size(server_list);
servers = PyMem_Malloc(sizeof(struct ares_addr_node) * length);
for (i = 0; i < length; i++) {
item = PyList_GetItem(server_list, i);
if (!item) {
ret = -1;
goto servers_set_end;
}
server = PyString_AsString(item);
if (!server) {
ret = -1;
goto servers_set_end;
}
if (uv_inet_pton(AF_INET, server, &servers[i].addr.addr4) == 1) {
servers[i].family = AF_INET;
} else if (uv_inet_pton(AF_INET6, server, &servers[i].addr.addr6) == 1) {
servers[i].family = AF_INET6;
} else {
PyErr_SetString(PyExc_ValueError, "invalid IP address");
ret = -1;
goto servers_set_end;
}
if (i > 0) {
servers[i-1].next = &servers[i];
}
}
if (length > 0) {
servers[length-1].next = NULL;
} else {
servers = NULL;
}
r = ares_set_servers(self->channel, servers);
if (r != 0) {
PyErr_SetString(PyExc_DNSError, "error c-ares library options");
ret = -1;
}
servers_set_end:
PyMem_Free(servers);
return ret;
}
bool Address::from_string(const std::string& ip, int port, Address* output) {
char buf[sizeof(struct in6_addr)];
#if UV_VERSION_MAJOR == 0
if (uv_inet_pton(AF_INET, ip.c_str(), &buf).code == UV_OK) {
#else
if (uv_inet_pton(AF_INET, ip.c_str(), &buf) == 0) {
#endif
if (output != NULL) {
struct sockaddr_in addr;
#if UV_VERSION_MAJOR == 0
addr = uv_ip4_addr(ip.c_str(), port);
#else
uv_ip4_addr(ip.c_str(), port, &addr);
#endif
output->init(copy_cast<struct sockaddr_in*, struct sockaddr*>(&addr));
}
return true;
#if UV_VERSION_MAJOR == 0
} else if (uv_inet_pton(AF_INET6, ip.c_str(), &buf).code == UV_OK) {
#else
} else if (uv_inet_pton(AF_INET6, ip.c_str(), &buf) == 0) {
#endif
if (output != NULL) {
struct sockaddr_in6 addr;
#if UV_VERSION_MAJOR == 0
addr = uv_ip6_addr(ip.c_str(), port);
#else
uv_ip6_addr(ip.c_str(), port, &addr);
#endif
output->init(copy_cast<struct sockaddr_in6*, struct sockaddr*>(&addr));
}
return true;
} else {
return false;
}
}
void Address::from_inet(const char* data, size_t size, int port, Address* output) {
assert(size == 4 || size == 16);
if (size == 4) {
char buf[INET_ADDRSTRLEN];
uv_inet_ntop(AF_INET, data, buf, sizeof(buf));
if (output != NULL) {
struct sockaddr_in addr;
#if UV_VERSION_MAJOR == 0
addr = uv_ip4_addr(buf, port);
#else
uv_ip4_addr(buf, port, &addr);
#endif
output->init(copy_cast<struct sockaddr_in*, struct sockaddr*>(&addr));
}
} else {
char buf[INET6_ADDRSTRLEN];
uv_inet_ntop(AF_INET6, data, buf, sizeof(buf));
if (output != NULL) {
struct sockaddr_in6 addr;
#if UV_VERSION_MAJOR == 0
addr = uv_ip6_addr(buf, port);
#else
uv_ip6_addr(buf, port, &addr);
#endif
output->init(copy_cast<struct sockaddr_in6*, struct sockaddr*>(&addr));
}
}
}
