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());
}
}
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;
}
static PyObject *
TCP_func_connect(TCP *self, PyObject *args)
{
int r;
struct sockaddr sa;
uv_connect_t *connect_req = NULL;
PyObject *addr, *callback;
RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL);
RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL);
if (!PyArg_ParseTuple(args, "OO:connect", &addr, &callback)) {
return NULL;
}
if (!PyCallable_Check(callback)) {
PyErr_SetString(PyExc_TypeError, "a callable is required");
return NULL;
}
if (pyuv_parse_addr_tuple(addr, &sa) < 0) {
/* Error is set by the function itself */
return NULL;
}
Py_INCREF(callback);
connect_req = PyMem_Malloc(sizeof *connect_req);
if (!connect_req) {
PyErr_NoMemory();
goto error;
}
connect_req->data = callback;
if (sa.sa_family == AF_INET) {
r = uv_tcp_connect(connect_req, &self->tcp_h, *(struct sockaddr_in *)&sa, on_tcp_client_connection);
} else {
r = uv_tcp_connect6(connect_req, &self->tcp_h, *(struct sockaddr_in6 *)&sa, on_tcp_client_connection);
}
if (r != 0) {
RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_TCPError);
goto error;
}
/* Increase refcount so that object is not removed before the callback is called */
Py_INCREF(self);
Py_RETURN_NONE;
error:
Py_DECREF(callback);
PyMem_Free(connect_req);
return NULL;
}
extern "C" int
rust_uv_tcp_connect6(uv_connect_t* connect_ptr,
uv_tcp_t* tcp_ptr,
uv_connect_cb cb,
sockaddr_in6* addr_ptr) {
// FIXME ref #2064
sockaddr_in6 addr = *addr_ptr;
int result = uv_tcp_connect6(connect_ptr, tcp_ptr, addr, cb);
return result;
}
int luv_tcp_connect6(lua_State* 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);
uv_connect_t* req = (uv_connect_t*)malloc(sizeof(uv_connect_t));
if (uv_tcp_connect6(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));
}
luv_handle_ref(L, handle->data, 1);
return 0;
}
/* same ping-pong test, but using IPv6 connection */
static void tcp_pinger_v6_new() {
int r;
struct sockaddr_in6 server_addr = uv_ip6_addr("::1", TEST_PORT);
pinger_t *pinger;
pinger = (pinger_t*)malloc(sizeof(*pinger));
pinger->state = 0;
pinger->pongs = 0;
/* Try to connec to the server and do NUM_PINGS ping-pongs. */
r = uv_tcp_init(&pinger->tcp);
pinger->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_connect6(&pinger->connect_req, &pinger->tcp, server_addr,
pinger_on_connect);
ASSERT(!r);
}
static int do_handshake(uv_stream_t *stream)
{
server_ctx *ctx = (server_ctx *)stream->data;
int n;
if (!ctx->remote_ip_type) {
if (ctx->buffer_len < 2) // Not interpretable
return 1;
uint8_t addrtype = ctx->handshake_buffer[0];
if (addrtype == ADDRTYPE_IPV4) {
if (ctx->buffer_len < 5)
return 1;
memcpy(ctx->remote_ip, ctx->handshake_buffer + 1, 4);
ctx->remote_ip_type = ADDRTYPE_IPV4;
SHIFT_BYTE_ARRAY_TO_LEFT(ctx->handshake_buffer, 5, HANDSHAKE_BUFFER_SIZE);
ctx->buffer_len -= 5;
// TODO: Print out
} else if (addrtype == ADDRTYPE_DOMAIN) {
uint8_t domain_len = ctx->handshake_buffer[1];
if (!domain_len) { // Domain length is zero
LOGE("Domain length is zero");
uv_close((uv_handle_t*)stream, handshake_client_close_cb);
return -1;
}
if (ctx->buffer_len < domain_len + 2)
return 1;
char domain[domain_len+1];
domain[domain_len] = 0;
memcpy(domain, ctx->handshake_buffer+2, domain_len);
uv_getaddrinfo_t *resolver = (uv_getaddrinfo_t *)malloc(sizeof(uv_getaddrinfo_t));
if (!resolver) {
uv_close((uv_handle_t*)stream, handshake_client_close_cb);
FATAL("malloc() failed!");
}
resolver->data = ctx; // We need to locate back the stream
LOGI("Domain is: %s", domain);
n = uv_getaddrinfo(stream->loop, resolver, client_handshake_domain_resolved, domain, NULL, NULL);
if (n) {
SHOW_UV_ERROR(stream->loop);
uv_close((uv_handle_t*)stream, handshake_client_close_cb);
free(resolver);
return -1;
}
SHIFT_BYTE_ARRAY_TO_LEFT(ctx->handshake_buffer, 2+domain_len, HANDSHAKE_BUFFER_SIZE);
ctx->buffer_len -= 2 + domain_len;
uv_read_stop(stream); // Pause the reading process, wait for resolve result
return 1;
} else { // Unsupported addrtype
LOGI("addrtype unknown, closing");
uv_close((uv_handle_t*)stream, handshake_client_close_cb);
return -1;
}
} // !ctx->remote_ip
if (!ctx->remote_port) {
if (ctx->buffer_len < 2) // Not interpretable
return 1;
ctx->remote_port = *((uint16_t *)ctx->handshake_buffer);
if (!ctx->remote_port) {
LOGE("Remote port is zero");
uv_close((uv_handle_t*)stream, handshake_client_close_cb);
return -1;
}
SHIFT_BYTE_ARRAY_TO_LEFT(ctx->handshake_buffer, 2, HANDSHAKE_BUFFER_SIZE);
ctx->buffer_len -= 2;
// Try connect now
n = uv_tcp_init(stream->loop, &ctx->remote);
if (n)
SHOW_UV_ERROR_AND_EXIT(stream->loop);
uv_connect_t *req = (uv_connect_t *)malloc(sizeof(uv_connect_t));
if (!req) {
uv_close((uv_handle_t*)stream, handshake_client_close_cb);
FATAL("malloc() failed!");
}
req->data = ctx;
if (ctx->remote_ip_type == ADDRTYPE_IPV4) {
struct sockaddr_in remote;
memset(&remote, 0, sizeof(remote));
remote.sin_family = AF_INET;
memcpy(&remote.sin_addr.s_addr, ctx->remote_ip, 4);
remote.sin_port = ctx->remote_port;
n = uv_tcp_connect(req, &ctx->remote, remote, connect_to_remote_cb);
} else if (ctx->remote_ip_type == ADDRTYPE_IPV6) {
struct sockaddr_in6 remote;
memset(&remote, 0, sizeof(remote));
remote.sin6_family = AF_INET6;
memcpy(&remote.sin6_addr.s6_addr, ctx->remote_ip, 16);
remote.sin6_port = ctx->remote_port;
n = uv_tcp_connect6(req, &ctx->remote, remote, connect_to_remote_cb);
} else {
FATAL("addrtype unknown!");
}
if (n) {
SHOW_UV_ERROR(stream->loop);
uv_close((uv_handle_t*)stream, handshake_client_close_cb);
free(req);
return -1;
}
}
uv_read_stop(stream);
return 0;
}
static void connect(uv_tcp_t* handle, const Address& address, void* data,
Callback cb) {
Connector* connector = new Connector(address, data, cb);
int rc = 0;
#if UV_VERSION_MAJOR == 0
if (address.family() == AF_INET) {
rc = uv_tcp_connect(&connector->req_, handle, *address.addr_in(),
on_connect);
} else {
rc = uv_tcp_connect6(&connector->req_, handle, *address.addr_in6(),
on_connect);
}
#else
rc = uv_tcp_connect(&connector->req_, handle, address.addr(),
on_connect);
#endif
if (rc != 0) {
connector->status_ = -1;
connector->cb_(connector);
delete connector;
}
}
