void TSockSys::Connect(const uint64& SockId, const PSockHost& SockHost, const int& PortN) {
// make sure it's a valid socket
IAssert(IsSock(SockId));
uv_tcp_t* SockHnd = SockIdToHndH.GetDat(SockId);
// make sure we got a valid socket host
IAssert(SockHost->IsOk());
// get connection handle
uv_connect_t* ConnectHnd = (uv_connect_t*)malloc(sizeof(uv_connect_t));
// special handling for v4 and v6
int ResCd = 0;
if (SockHost->IsIpv4()) {
// get address
struct sockaddr_in Addr = uv_ip4_addr(SockHost->GetIpNum().CStr(), PortN);
// establish connection
ResCd = uv_tcp_connect(ConnectHnd, SockHnd, Addr, TSockSys::OnConnect);
} else if (SockHost->IsIpv6()) {
// get address
struct sockaddr_in6 Addr = uv_ip6_addr(SockHost->GetIpNum().CStr(), PortN);
// establish connection
ResCd = uv_tcp_connect6(ConnectHnd, SockHnd, Addr, TSockSys::OnConnect);
}
// check for errors
if (ResCd != 0) {
// cleanup first
free(SockHnd);
// and throw exception
throw TExcept::New("SockSys.Connect: Error establishing socket connection: " + SockSys.GetLastErr());
}
}
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(&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_network_stream_t*)&tcpServer, 128, on_connection);
if (r) {
/* TODO: Error codes */
fprintf(stderr, "Listen error\n");
return 1;
}
return 0;
}
/*
* Class: com_oracle_libuv_handles_UDPHandle
* Method: _send6
* Signature: (JLjava/nio/ByteBuffer;[BIIILjava/lang/String;)I
*/
JNIEXPORT jint JNICALL Java_com_oracle_libuv_handles_UDPHandle__1send6
(JNIEnv *env, jobject that, jlong udp, jobject buffer, jbyteArray data, jint offset, jint length, jint port, jstring host, jobject context) {
assert(udp);
uv_udp_t* handle = reinterpret_cast<uv_udp_t*>(udp);
const char* h = env->GetStringUTFChars(host, 0);
sockaddr_in6 addr = uv_ip6_addr(h, port);
jbyte* base = (jbyte*) env->GetPrimitiveArrayCritical(data, NULL);
OOME(env, base);
uv_buf_t buf;
buf.base = reinterpret_cast<char*>(base + offset);
buf.len = length;
uv_udp_send_t* req = new uv_udp_send_t();
req->handle = handle;
ContextHolder* req_data = new ContextHolder(env, context);
req->data = req_data;
int r = uv_udp_send6(req, handle, &buf, 1, addr, _send_cb);
env->ReleasePrimitiveArrayCritical(data, base, 0);
if (r) {
delete req_data;
delete req;
ThrowException(env, handle->loop, "uv_udp_send6", h);
}
env->ReleaseStringUTFChars(host, h);
return r;
}
void test_ip6_addr_scope(const char* ip6_addr,
const char* device_name,
unsigned iface_index) {
/* 40 bytes address, 16 bytes device name, plus reserve */
char scoped_addr[128];
struct sockaddr_in6 addr;
/* skip addresses that are not link-local */
if (strncmp(ip6_addr, "fe80::", 6) != 0) return;
#ifdef _WIN32
sprintf(scoped_addr, "%s%%%d", ip6_addr, iface_index);
#else
sprintf(scoped_addr, "%s%%%s", ip6_addr, device_name);
#endif
LOGF("Testing link-local address %s (iface_index: 0x%02x, device_name: %s)\n",
scoped_addr,
iface_index,
device_name);
addr = uv_ip6_addr(scoped_addr, TEST_PORT);
LOGF("Got scope_id 0x%02x\n", addr.sin6_scope_id);
ASSERT(iface_index == addr.sin6_scope_id);
}
extern "C" struct sockaddr_in6
rust_uv_ip6_addr(const char* ip, int port) {
rust_task* task = rust_get_current_task();
LOG(task, stdlib, "before creating addr_ptr.. ip %s" \
" port %d\n", ip, port);
return uv_ip6_addr(ip, port);
}
int luv_tcp_connect6(lua_State* L) {
int before = lua_gettop(L);
uv_tcp_t* handle = (uv_tcp_t*)luv_checkudata(L, 1, "tcp");
const char* ip_address = luaL_checkstring(L, 2);
int port = luaL_checkint(L, 3);
struct sockaddr_in6 address = uv_ip6_addr(ip_address, port);
luv_connect_ref_t* ref = (luv_connect_ref_t*)malloc(sizeof(luv_connect_ref_t));
/* Store a reference to the userdata */
ref->L = L;
lua_pushvalue(L, 1);
ref->r = luaL_ref(L, LUA_REGISTRYINDEX);
/* Give the connect_req access to this */
ref->connect_req.data = ref;
if (uv_tcp_connect6(&ref->connect_req, handle, address, luv_after_connect)) {
uv_err_t err = uv_last_error(luv_get_loop(L));
return luaL_error(L, "tcp_connect6: %s", uv_strerror(err));
}
assert(lua_gettop(L) == before);
return 0;
}
int uvplus_tcp::bind6(const char *ipv6, int port) {
struct sockaddr_in6 addr;
int r = uv_ip6_addr(ipv6, port, &addr);
if (r < 0)
return r;
return bind((const sockaddr *)&addr, 0);
}
int32_t uv_udp_handle_t::write_handle(request_udp_write_t& request)
{
int result;
uv_buf_t uv_buf;
write_uv_request_t* uv_request = get_write_cached_request();
uv_request->m_source = request.m_source;
uv_request->m_session = request.m_session;
uv_request->m_length = request.m_length;
if (request.m_length > 0) {
uv_request->m_string = request.m_string;
uv_buf.len = request.m_length;
uv_buf.base = (char*)request.m_string;
} else {
uv_request->m_buffer = request.m_buffer;
uv_buf.len = buffer_data_length(request.m_buffer);
uv_buf.base = buffer_data_ptr(request.m_buffer);
}
if (!request.m_ipv6) {
result = uv_udp_send(&uv_request->m_write_req, (uv_udp_t*)m_handle, &uv_buf, 1, uv_ip4_addr(REQUEST_SPARE_PTR(request), request.m_port), on_write);
} else {
result = uv_udp_send6(&uv_request->m_write_req, (uv_udp_t*)m_handle, &uv_buf, 1, uv_ip6_addr(REQUEST_SPARE_PTR(request), request.m_port), on_write);
}
if (result == 0) return UV_OK;
put_write_cached_request(uv_request);
return singleton_ref(network_t).last_error(); /* write error occurs */
}
/* same ping-pong test, but using IPv6 connection */
static void tcp_pinger_v6_new(void) {
int r;
struct sockaddr_in6 server_addr;
pinger_t *pinger;
ASSERT(0 ==uv_ip6_addr("::1", TEST_PORT, &server_addr));
pinger = malloc(sizeof(*pinger));
pinger->state = 0;
pinger->pongs = 0;
/* Try to connect to the server and do NUM_PINGS ping-pongs. */
r = uv_tcp_init(uv_default_loop(), &pinger->stream.tcp);
pinger->stream.tcp.data = pinger;
ASSERT(!r);
/* We are never doing multiple reads/connects at a time anyway. */
/* so these handles can be pre-initialized. */
r = uv_tcp_connect(&pinger->connect_req,
&pinger->stream.tcp,
(const struct sockaddr*) &server_addr,
pinger_on_connect);
ASSERT(!r);
/* Synchronous connect callbacks are not allowed. */
ASSERT(pinger_on_connect_count == 0);
}
static int luv_udp_send(lua_State* L) {
uv_udp_t* handle = luv_check_udp(L, 1);
uv_udp_send_t* req;
uv_buf_t buf;
int ret, port, ref;
const char* host;
struct sockaddr_storage addr;
luv_check_buf(L, 2, &buf);
host = luaL_checkstring(L, 3);
port = luaL_checkinteger(L, 4);
if (uv_ip4_addr(host, port, (struct sockaddr_in*)&addr) &&
uv_ip6_addr(host, port, (struct sockaddr_in6*)&addr)) {
return luaL_error(L, "Invalid IP address or port [%s:%d]", host, port);
}
ref = luv_check_continuation(L, 5);
req = (uv_udp_send_t*)lua_newuserdata(L, sizeof(*req));
req->data = luv_setup_req(L, ref);
ret = uv_udp_send(req, handle, &buf, 1, (struct sockaddr*)&addr, luv_udp_send_cb);
if (ret < 0) {
luv_cleanup_req(L, (luv_req_t*)req->data);
lua_pop(L, 1);
return luv_error(L, ret);
}
return 1;
}
static PyObject *
UDP_func_bind(UDP *self, PyObject *args)
{
int r, bind_port, address_type;
char *bind_ip;
RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL);
if (!PyArg_ParseTuple(args, "(si):bind", &bind_ip, &bind_port)) {
return NULL;
}
if (bind_port < 0 || bind_port > 65535) {
PyErr_SetString(PyExc_ValueError, "port must be between 0 and 65535");
return NULL;
}
if (pyuv_guess_ip_family(bind_ip, &address_type)) {
PyErr_SetString(PyExc_ValueError, "invalid IP address");
return NULL;
}
if (address_type == AF_INET) {
r = uv_udp_bind((uv_udp_t *)UV_HANDLE(self), uv_ip4_addr(bind_ip, bind_port), 0);
} else {
r = uv_udp_bind6((uv_udp_t *)UV_HANDLE(self), uv_ip6_addr(bind_ip, bind_port), UV_UDP_IPV6ONLY);
}
if (r != 0) {
RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_UDPError);
return NULL;
}
Py_RETURN_NONE;
}
static int luv__udp_bind(lua_State *L, int family) {
uv_udp_t* handle = (uv_udp_t*)luv_checkudata(L, 1, "udp");
const char* host = luaL_checkstring(L, 2);
int port = luaL_checkint(L, 3);
int flags = 0;
int rc = 0;
switch (family) {
case AF_INET:
rc = uv_udp_bind(handle, uv_ip4_addr(host, port), flags);
break;
case AF_INET6:
rc = uv_udp_bind6(handle, uv_ip6_addr(host, port), flags);
break;
default:
assert(0 && "unexpected family type");
abort();
}
if (rc) {
uv_err_t err = uv_last_error(luv_get_loop(L));
return luaL_error(L, "udp_bind: %s", uv_strerror(err));
}
return 0;
}
static int luv_udp_bind(lua_State* L) {
uv_udp_t* handle = luv_check_udp(L, 1);
const char* host = luaL_checkstring(L, 2);
int port = luaL_checkinteger(L, 3);
unsigned int flags = 0;
struct sockaddr_storage addr;
int ret;
if (uv_ip4_addr(host, port, (struct sockaddr_in*)&addr) &&
uv_ip6_addr(host, port, (struct sockaddr_in6*)&addr)) {
return luaL_error(L, "Invalid IP address or port [%s:%d]", host, port);
}
if (lua_type(L, 4) == LUA_TTABLE) {
luaL_checktype(L, 4, LUA_TTABLE);
lua_getfield(L, 4, "reuseaddr");
if (lua_toboolean(L, -1)) flags |= UV_UDP_REUSEADDR;
lua_pop(L, 1);
lua_getfield(L, 4, "ipv6only");
if (lua_toboolean(L, -1)) flags |= UV_UDP_IPV6ONLY;
lua_pop(L, 1);
}
ret = uv_udp_bind(handle, (struct sockaddr*)&addr, flags);
if (ret < 0) return luv_error(L, ret);
lua_pushinteger(L, ret);
return 1;
}
int uvplus_tcp::connect6(const char *ipv6, int port, std::function<void(uvplus_tcp *self, int status)> connect_callback) {
struct sockaddr_in6 addr;
int r = uv_ip6_addr(ipv6, port, &addr);
if (r < 0)
return r;
return connect((const struct sockaddr *)&addr, connect_callback);
}
static int tcp6_echo_start(int port) {
struct sockaddr_in6 addr6;
int r;
ASSERT(0 == uv_ip6_addr("::1", port, &addr6));
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_bind(&tcpServer, (const struct sockaddr*) &addr6, 0);
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;
}
int network_listen(struct network *net, const char *addr, uint16_t port, uint32_t flags)
{
if (net == NULL || addr == 0 || port == 0) {
return kr_error(EINVAL);
}
/* Parse address. */
int ret = 0;
struct sockaddr_storage sa;
if (strchr(addr, ':') != NULL) {
ret = uv_ip6_addr(addr, port, (struct sockaddr_in6 *)&sa);
} else {
ret = uv_ip4_addr(addr, port, (struct sockaddr_in *)&sa);
}
if (ret != 0) {
return ret;
}
/* Bind interfaces */
struct endpoint *ep = malloc(sizeof(*ep));
memset(ep, 0, sizeof(*ep));
ep->flags = NET_DOWN;
ep->port = port;
ret = open_endpoint(net, ep, (struct sockaddr *)&sa, flags);
if (ret == 0) {
ret = insert_endpoint(net, addr, ep);
}
if (ret != 0) {
close_endpoint(ep);
}
return ret;
}
extern "C" struct sockaddr_in6*
rust_uv_ip6_addrp(const char* ip, int port) {
struct sockaddr_in6 addr = uv_ip6_addr(ip, port);
struct sockaddr_in6 *addrp = (sockaddr_in6*)malloc(sizeof(struct sockaddr_in6));
assert(addrp);
memcpy(addrp, &addr, sizeof(struct sockaddr_in6));
return addrp;
}
inline ip6_addr to_ip6_addr(const std::string& ip, int port)
{
ip6_addr result;
int res = 0;
if ((res = uv_ip6_addr(ip.c_str(), port, &result)) != 0)
throw exception(fs("uv_ip6_addr error: " << error(res).str()));
return result;
}
int uv__udp_set_membership6(uv_udp_t* handle,
const struct sockaddr_in6* multicast_addr,
const char* interface_addr,
uv_membership membership) {
int optname;
int err;
struct ipv6_mreq mreq;
struct sockaddr_in6 addr6;
if ((handle->flags & UV_HANDLE_BOUND) && !(handle->flags & UV_HANDLE_IPV6))
return UV_EINVAL;
err = uv_udp_maybe_bind(handle,
(const struct sockaddr*) &uv_addr_ip6_any_,
sizeof(uv_addr_ip6_any_),
UV_UDP_REUSEADDR);
if (err)
return uv_translate_sys_error(err);
memset(&mreq, 0, sizeof(mreq));
if (interface_addr) {
if (uv_ip6_addr(interface_addr, 0, &addr6))
return UV_EINVAL;
mreq.ipv6mr_interface = addr6.sin6_scope_id;
} else {
mreq.ipv6mr_interface = 0;
}
mreq.ipv6mr_multiaddr = multicast_addr->sin6_addr;
switch (membership) {
case UV_JOIN_GROUP:
optname = IPV6_ADD_MEMBERSHIP;
break;
case UV_LEAVE_GROUP:
optname = IPV6_DROP_MEMBERSHIP;
break;
default:
return UV_EINVAL;
}
if (setsockopt(handle->socket,
IPPROTO_IPV6,
optname,
(char*) &mreq,
sizeof mreq) == SOCKET_ERROR) {
return uv_translate_sys_error(WSAGetLastError());
}
return 0;
}
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_udp_set_multicast_interface(uv_udp_t* handle, const char* interface_addr) {
struct sockaddr_storage addr_st;
struct sockaddr_in* addr4;
struct sockaddr_in6* addr6;
addr4 = (struct sockaddr_in*) &addr_st;
addr6 = (struct sockaddr_in6*) &addr_st;
if (!interface_addr) {
memset(&addr_st, 0, sizeof addr_st);
if (handle->flags & UV_HANDLE_IPV6) {
addr_st.ss_family = AF_INET6;
addr6->sin6_scope_id = 0;
} else {
addr_st.ss_family = AF_INET;
addr4->sin_addr.s_addr = htonl(INADDR_ANY);
}
} else if (uv_ip4_addr(interface_addr, 0, addr4) == 0) {
/* nothing, address was parsed */
} else if (uv_ip6_addr(interface_addr, 0, addr6) == 0) {
/* nothing, address was parsed */
} else {
return UV_EINVAL;
}
if (handle->socket == INVALID_SOCKET)
return UV_EBADF;
if (addr_st.ss_family == AF_INET) {
if (setsockopt(handle->socket,
IPPROTO_IP,
IP_MULTICAST_IF,
(char*) &addr4->sin_addr,
sizeof(addr4->sin_addr)) == SOCKET_ERROR) {
return uv_translate_sys_error(WSAGetLastError());
}
} else if (addr_st.ss_family == AF_INET6) {
if (setsockopt(handle->socket,
IPPROTO_IPV6,
IPV6_MULTICAST_IF,
(char*) &addr6->sin6_scope_id,
sizeof(addr6->sin6_scope_id)) == SOCKET_ERROR) {
return uv_translate_sys_error(WSAGetLastError());
}
} else {
assert(0 && "unexpected address family");
abort();
}
return 0;
}
int uv_udp_set_membership(uv_udp_t* handle,
const char* multicast_addr,
const char* interface_addr,
uv_membership membership) {
struct sockaddr_in addr4;
struct sockaddr_in6 addr6;
if (uv_ip4_addr(multicast_addr, 0, &addr4) == 0)
return uv__udp_set_membership4(handle, &addr4, interface_addr, membership);
else if (uv_ip6_addr(multicast_addr, 0, &addr6) == 0)
return uv__udp_set_membership6(handle, &addr6, interface_addr, membership);
else
return UV_EINVAL;
}
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;
}
void melo_get_sock_addr(const char* ip, int port, melo_sockaddr_t * sockaddr)
{
MELO_ASSERT(NULL != ip, "ip pointer is null");
MELO_ASSERT(NULL != sockaddr, "sockaddr pointer is null");
if(strchr(ip, ':'))
{
uv_ip6_addr(ip, port, (struct sockaddr_in6*)&(sockaddr->addr6));
}
else
{
uv_ip4_addr(ip, port, (struct sockaddr_in*)&(sockaddr->addr4));
}
}
bool Settings::IsBindableIP(const std::string &ip, int family, int* _bind_err) {
MS_TRACE();
struct sockaddr_storage bind_addr;
int bind_socket;
int err = 0;
bool bind_ok;
switch (family) {
case AF_INET:
err = uv_ip4_addr(ip.c_str(), 0, (struct sockaddr_in*)&bind_addr);
if (err)
MS_ABORT("uv_ipv4_addr() failed: %s", uv_strerror(err));
bind_socket = socket(AF_INET, SOCK_DGRAM, 0);
if (bind_socket == -1)
MS_ABORT("socket() failed: %s", std::strerror(errno));
err = bind(bind_socket, (const struct sockaddr*)&bind_addr, sizeof(struct sockaddr_in));
break;
case AF_INET6:
uv_ip6_addr(ip.c_str(), 0, (struct sockaddr_in6*)&bind_addr);
if (err)
MS_ABORT("uv_ipv6_addr() failed: %s", uv_strerror(err));
bind_socket = socket(AF_INET6, SOCK_DGRAM, 0);
if (bind_socket == -1)
MS_ABORT("socket() failed: %s", std::strerror(errno));
err = bind(bind_socket, (const struct sockaddr*)&bind_addr, sizeof(struct sockaddr_in6));
break;
default:
MS_ABORT("unknown family");
}
if (err == 0) {
bind_ok = true;
}
else {
bind_ok = false;
*_bind_err = errno;
}
err = close(bind_socket);
if (err)
MS_ABORT("close() failed: %s", std::strerror(errno));
return bind_ok;
}
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;
}
/*
* Class: com_oracle_libuv_handles_UDPHandle
* Method: _bind6
* Signature: (JILjava/lang/String;)I
*/
JNIEXPORT jint JNICALL Java_com_oracle_libuv_handles_UDPHandle__1bind6
(JNIEnv *env, jobject that, jlong udp, jint port, jstring host) {
assert(udp);
uv_udp_t* handle = reinterpret_cast<uv_udp_t*>(udp);
const char* h = env->GetStringUTFChars(host, 0);
sockaddr_in6 addr = uv_ip6_addr(h, port);
unsigned flags = 0;
int r = uv_udp_bind6(handle, addr, flags);
if (r) {
ThrowException(env, handle->loop, "uv_udp_bind6", h);
}
env->ReleaseStringUTFChars(host, h);
return r;
}
int uv_udp_set_multicast_interface(uv_udp_t* handle, const char* interface_addr) {
struct sockaddr_storage addr_st;
struct sockaddr_in* addr4;
struct sockaddr_in6* addr6;
addr4 = (struct sockaddr_in*) &addr_st;
addr6 = (struct sockaddr_in6*) &addr_st;
if (!interface_addr) {
memset(&addr_st, 0, sizeof addr_st);
if (handle->flags & UV_HANDLE_IPV6) {
addr_st.ss_family = AF_INET6;
addr6->sin6_scope_id = 0;
} else {
addr_st.ss_family = AF_INET;
addr4->sin_addr.s_addr = htonl(INADDR_ANY);
}
} else if (uv_ip4_addr(interface_addr, 0, addr4) == 0) {
/* nothing, address was parsed */
} else if (uv_ip6_addr(interface_addr, 0, addr6) == 0) {
/* nothing, address was parsed */
} else {
return -EINVAL;
}
if (addr_st.ss_family == AF_INET) {
if (setsockopt(handle->io_watcher.fd,
IPPROTO_IP,
IP_MULTICAST_IF,
(void*) &addr4->sin_addr,
sizeof(addr4->sin_addr)) == -1) {
return -errno;
}
} else if (addr_st.ss_family == AF_INET6) {
if (setsockopt(handle->io_watcher.fd,
IPPROTO_IPV6,
IPV6_MULTICAST_IF,
&addr6->sin6_scope_id,
sizeof(addr6->sin6_scope_id)) == -1) {
return -errno;
}
} else {
assert(0 && "unexpected address family");
abort();
}
return 0;
}
void TCPClient::ReconnectTimer(uv_timer_t* handle)
{
TCPClient* theclass = (TCPClient*)handle->data;
if (!theclass->isreconnecting_) {
return;
}
LOG(INFO)<<"start reconnect...\n";
do {
int iret = uv_tcp_init(&theclass->loop_, &theclass->client_handle_->tcphandle);
if (iret) {
LOG(ERROR)<<(GetUVError(iret));
break;
}
theclass->client_handle_->tcphandle.data = theclass->client_handle_;
theclass->client_handle_->parent_server = theclass;
struct sockaddr* pAddr;
if (theclass->isIPv6_) {
struct sockaddr_in6 bind_addr;
int iret = uv_ip6_addr(theclass->connectip_.c_str(), theclass->connectport_, &bind_addr);
if (iret) {
LOG(ERROR)<<(GetUVError(iret));
uv_close((uv_handle_t*)&theclass->client_handle_->tcphandle, NULL);
break;
}
pAddr = (struct sockaddr*)&bind_addr;
} else {
struct sockaddr_in bind_addr;
int iret = uv_ip4_addr(theclass->connectip_.c_str(), theclass->connectport_, &bind_addr);
if (iret) {
LOG(ERROR)<<(GetUVError(iret));
uv_close((uv_handle_t*)&theclass->client_handle_->tcphandle, NULL);
break;
}
pAddr = (struct sockaddr*)&bind_addr;
}
iret = uv_tcp_connect(&theclass->connect_req_, &theclass->client_handle_->tcphandle, (const sockaddr*)pAddr, AfterConnect);
if (iret) {
LOG(ERROR)<<(GetUVError(iret));
uv_close((uv_handle_t*)&theclass->client_handle_->tcphandle, NULL);
break;
}
return;
} while (0);
//reconnect failure, restart timer to trigger reconnect.
uv_timer_stop(handle);
theclass->repeat_time_ *= 2;
uv_timer_start(handle, TCPClient::ReconnectTimer, theclass->repeat_time_, theclass->repeat_time_);
}
static int luv_udp__send(lua_State* L, int family) {
uv_buf_t buf;
uv_udp_t* handle = (uv_udp_t*)luv_checkudata(L, 1, "udp");
size_t len;
const char* chunk = luaL_checklstring(L, 2, &len);
luv_udp_ref_t *ref;
uv_udp_send_t* req = (uv_udp_send_t*)malloc(sizeof(uv_udp_send_t));
int port = luaL_checkint(L, 3);
const char* host = luaL_checkstring(L, 4);
struct sockaddr_in dest;
struct sockaddr_in6 dest6;
int rc;
/* Store a reference to the callback */
lua_pushvalue(L, 5);
ref = malloc(sizeof(*ref));
ref->ref = luaL_ref(L, LUA_REGISTRYINDEX);
req->data = ref;
luv_handle_ref(L, handle->data, 1);
/* Store the chunk
* TODO: this is probably unsafe, should investigate
*/
buf = uv_buf_init((char*)chunk, len);
switch(family) {
case AF_INET:
dest = uv_ip4_addr(host, port);
rc = uv_udp_send(req, handle, &buf, 1, dest, luv_on_udp_send);
break;
case AF_INET6:
dest6 = uv_ip6_addr(host, port);
rc = uv_udp_send6(req, handle, &buf, 1, dest6, luv_on_udp_send);
break;
default:
assert(0 && "unexpected family type");
abort();
}
if (rc) {
uv_err_t err = uv_last_error(luv_get_loop(L));
return luaL_error(L, "udp_send: %s", uv_strerror(err));
}
return 0;
}
