int uv__tcp_connect6(uv_connect_t* req,
uv_tcp_t* handle,
struct sockaddr_in6 address,
uv_connect_cb cb) {
uv_loop_t* loop = handle->loop;
int addrsize = sizeof(struct sockaddr_in6);
BOOL success;
DWORD bytes;
if (!uv_allow_ipv6) {
uv__set_sys_error(loop, WSAEAFNOSUPPORT);
return -1;
}
if (handle->flags & UV_HANDLE_BIND_ERROR) {
uv__set_sys_error(loop, handle->bind_error);
return -1;
}
if (!(handle->flags & UV_HANDLE_BOUND) &&
uv_tcp_bind6(handle, uv_addr_ip6_any_) < 0)
return -1;
if (!handle->func_connectex) {
if(!uv_get_connectex_function(handle->socket, &handle->func_connectex)) {
uv__set_sys_error(loop, WSAEAFNOSUPPORT);
return -1;
}
}
uv_req_init(loop, (uv_req_t*) req);
req->type = UV_CONNECT;
req->handle = (uv_stream_t*) handle;
req->cb = cb;
memset(&req->overlapped, 0, sizeof(req->overlapped));
success = handle->func_connectex(handle->socket,
(struct sockaddr*) &address,
addrsize,
NULL,
0,
&bytes,
&req->overlapped);
if (UV_SUCCEEDED_WITHOUT_IOCP(success)) {
handle->reqs_pending++;
uv_ref(loop);
uv_insert_pending_req(loop, (uv_req_t*)req);
} else if (UV_SUCCEEDED_WITH_IOCP(success)) {
handle->reqs_pending++;
uv_ref(loop);
} else {
uv__set_sys_error(loop, WSAGetLastError());
return -1;
}
return 0;
}
void CefLoop::Run() {
if( !CefLoop::initialized_ || CefLoop::running_ ) return;
#if NODE_VERSION_AT_LEAST(0, 7, 9)
uv_ref((uv_handle_t *)&g_async);
#else
uv_ref(uv_default_loop());
#endif
uv_timer_start(&timer,RunLoop,1,1);
CefLoop::running_ = true;
}
static void term(void *const unused) {
fprintf(stderr, "\nStopping StrongLink server...\n");
uv_ref((uv_handle_t *)sigint);
uv_signal_stop(sigint);
async_close((uv_handle_t *)sigint);
SLNRepoPullsStop(repo);
HTTPServerClose(server_raw);
HTTPServerClose(server_tls);
uv_ref((uv_handle_t *)sigpipe);
uv_signal_stop(sigpipe);
uv_close((uv_handle_t *)sigpipe, NULL);
}
static void socket_connect(MVMThreadContext *tc, MVMOSHandle *h, MVMString *host, MVMint64 port) {
MVMIOSyncSocketData *data = (MVMIOSyncSocketData *)h->body.data;
if (!data->ss.handle) {
struct sockaddr *dest = MVM_io_resolve_host_name(tc, host, port);
uv_tcp_t *socket = MVM_malloc(sizeof(uv_tcp_t));
uv_connect_t *connect = MVM_malloc(sizeof(uv_connect_t));
int r;
data->ss.cur_tc = tc;
connect->data = data;
if ((r = uv_tcp_init(tc->loop, socket)) < 0 ||
(r = uv_tcp_connect(connect, socket, dest, on_connect)) < 0) {
MVM_free(socket);
MVM_free(connect);
MVM_free(dest);
MVM_exception_throw_adhoc(tc, "Failed to connect: %s", uv_strerror(r));
}
uv_ref((uv_handle_t *)socket);
uv_run(tc->loop, UV_RUN_DEFAULT);
data->ss.handle = (uv_stream_t *)socket;
MVM_free(connect);
MVM_free(dest);
}
else {
MVM_exception_throw_adhoc(tc, "Socket is already bound or connected");
}
}
int uv_fs_write(uv_loop_t* loop, uv_fs_t* req, uv_file file, void* buf,
size_t length, off_t offset, uv_fs_cb cb) {
uv_fs_req_init(loop, req, UV_FS_WRITE, NULL, cb);
if (cb) {
/* async */
uv_ref(loop);
req->eio = eio_write(file, buf, length, offset, EIO_PRI_DEFAULT,
uv__fs_after, req);
if (!req->eio) {
uv_err_new(loop, ENOMEM);
return -1;
}
} else {
/* sync */
req->result = offset < 0 ?
write(file, buf, length) :
pwrite(file, buf, length, offset);
if (req->result < 0) {
uv_err_new(loop, errno);
return -1;
}
}
return 0;
}
int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
int mode, uv_fs_cb cb) {
uv_fs_req_init(loop, req, UV_FS_OPEN, path, cb);
if (cb) {
/* async */
uv_ref(loop);
req->eio = eio_open(path, flags, mode, EIO_PRI_DEFAULT, uv__fs_after, req);
if (!req->eio) {
uv_err_new(loop, ENOMEM);
return -1;
}
} else {
/* sync */
req->result = open(path, flags, mode);
if (req->result < 0) {
uv_err_new(loop, errno);
return -1;
}
uv__cloexec(req->result, 1);
}
return 0;
}
static MVMObject * socket_accept(MVMThreadContext *tc, MVMOSHandle *h) {
MVMIOSyncSocketData *data = (MVMIOSyncSocketData *)h->body.data;
while (!data->accept_server) {
uv_ref((uv_handle_t *)data->ss.handle);
uv_run(tc->loop, UV_RUN_DEFAULT);
}
/* Check the accept worked out. */
if (data->accept_status < 0) {
MVM_exception_throw_adhoc(tc, "Failed to listen: unknown error");
}
else {
uv_tcp_t *client = malloc(sizeof(uv_tcp_t));
uv_stream_t *server = data->accept_server;
int r;
uv_tcp_init(tc->loop, client);
data->accept_server = NULL;
if ((r = uv_accept(server, (uv_stream_t *)client)) == 0) {
MVMOSHandle * const result = (MVMOSHandle *)MVM_repr_alloc_init(tc, tc->instance->boot_types.BOOTIO);
MVMIOSyncSocketData * const data = calloc(1, sizeof(MVMIOSyncSocketData));
data->ss.handle = (uv_stream_t *)client;
data->ss.encoding = MVM_encoding_type_utf8;
data->ss.sep = '\n';
result->body.ops = &op_table;
result->body.data = data;
return (MVMObject *)result;
}
else {
uv_close((uv_handle_t*)client, NULL);
free(client);
MVM_exception_throw_adhoc(tc, "Failed to accept: %s", uv_strerror(r));
}
}
}
MVMint64 MVM_io_syncstream_write_str(MVMThreadContext *tc, MVMOSHandle *h, MVMString *str, MVMint64 newline) {
MVMIOSyncStreamData *data = (MVMIOSyncStreamData *)h->body.data;
MVMuint8 *output;
MVMint64 output_size;
uv_write_t *req;
uv_buf_t write_buf;
int r;
output = MVM_string_encode(tc, str, 0, -1, &output_size, data->encoding);
if (newline) {
output = (MVMuint8 *)realloc(output, ++output_size);
output[output_size - 1] = '\n';
}
req = malloc(sizeof(uv_write_t));
write_buf = uv_buf_init(output, output_size);
uv_ref((uv_handle_t *)data->handle);
if ((r = uv_write(req, data->handle, &write_buf, 1, write_cb)) < 0) {
uv_unref((uv_handle_t *)data->handle);
free(req);
free(output);
MVM_exception_throw_adhoc(tc, "Failed to write string to stream: %s", uv_strerror(r));
}
else {
uv_run(tc->loop, UV_RUN_DEFAULT);
free(output);
}
data->total_bytes_written += output_size;
return output_size;
}
void NodeMap::startRender(NodeMap::RenderOptions options) {
view.resize(options.width, options.height);
map->update(mbgl::Update::Dimensions);
map->setClasses(options.classes);
map->setLatLngZoom(mbgl::LatLng(options.latitude, options.longitude), options.zoom);
map->setBearing(options.bearing);
map->setPitch(options.pitch);
map->setDebug(options.debugOptions);
map->renderStill([this](const std::exception_ptr eptr, mbgl::PremultipliedImage&& result) {
if (eptr) {
error = std::move(eptr);
uv_async_send(async);
} else {
assert(!image.data);
image = std::move(result);
uv_async_send(async);
}
});
// Retain this object, otherwise it might get destructed before we are finished rendering the
// still image.
Ref();
// Similarly, we're now waiting for the async to be called, so we need to make sure that it
// keeps the loop alive.
uv_ref(reinterpret_cast<uv_handle_t *>(async));
}
void computeHomography(
const vector<Vector3d>& f_ref,
const vector<Vector3d>& f_cur,
double focal_length,
double reprojection_threshold,
vector<int>& inliers,
vector<Vector3d>& xyz_in_cur,
SE3& T_cur_from_ref)
{
vector<Vector2d, aligned_allocator<Vector2d> > uv_ref(f_ref.size());
vector<Vector2d, aligned_allocator<Vector2d> > uv_cur(f_cur.size());
for(size_t i=0, i_max=f_ref.size(); i<i_max; ++i)
{
uv_ref[i] = vk::project2d(f_ref[i]);
uv_cur[i] = vk::project2d(f_cur[i]);
}
vk::Homography Homography(uv_ref, uv_cur, focal_length, reprojection_threshold);
Homography.computeSE3fromMatches();
vector<int> outliers;
vk::computeInliers(f_cur, f_ref,
Homography.T_c2_from_c1.rotation_matrix(), Homography.T_c2_from_c1.translation(),
reprojection_threshold, focal_length,
xyz_in_cur, inliers, outliers);
T_cur_from_ref = Homography.T_c2_from_c1;
}
static void uv_process_init(uv_loop_t* loop, uv_process_t* handle) {
handle->type = UV_PROCESS;
handle->loop = loop;
handle->flags = 0;
handle->exit_cb = NULL;
handle->pid = 0;
handle->exit_signal = 0;
handle->wait_handle = INVALID_HANDLE_VALUE;
handle->process_handle = INVALID_HANDLE_VALUE;
handle->close_handle = INVALID_HANDLE_VALUE;
handle->child_stdio[0] = INVALID_HANDLE_VALUE;
handle->child_stdio[1] = INVALID_HANDLE_VALUE;
handle->child_stdio[2] = INVALID_HANDLE_VALUE;
uv_req_init(loop, (uv_req_t*)&handle->exit_req);
handle->exit_req.type = UV_PROCESS_EXIT;
handle->exit_req.data = handle;
uv_req_init(loop, (uv_req_t*)&handle->close_req);
handle->close_req.type = UV_PROCESS_CLOSE;
handle->close_req.data = handle;
loop->counters.handle_init++;
loop->counters.process_init++;
uv_ref(loop);
}
EventLoop::~EventLoop() {
uv_ref((uv_handle_t*) &deleteObjectsHandle);
uv_prepare_stop(&deleteObjectsHandle);
uv_close((uv_handle_t*) &deleteObjectsHandle, nullptr);
// Wait remaining handle to close
uv_run(&loop, UV_RUN_DEFAULT);
if(uv_loop_alive(&loop)) {
log(LL_Warning, "Loop still used but delete requested, handles:\n");
uv_walk(&loop,
[](uv_handle_t* handle, void* arg) {
EventLoop* self = (EventLoop*) arg;
const char* type;
switch(handle->type) {
#define X(uc, lc) \
case UV_##uc: \
type = #lc; \
break;
UV_HANDLE_TYPE_MAP(X)
#undef X
default:
type = "<unknown>";
}
self->log(LL_Warning, " [%08X] %s %p\n", handle->flags, type, handle);
},
this);
static int couv_ref(lua_State *L) {
uv_handle_t *handle;
handle = couvL_checkudataclass(L, 1, COUV_HANDLE_MTBL_NAME);
uv_ref(handle);
return 0;
}
ssize_t HTTPConnectionReadRequest(HTTPConnectionRef const conn, HTTPMethod *const method, str_t *const out, size_t const max) {
if(!conn) return UV_EINVAL;
if(!max) return UV_EINVAL;
uv_buf_t buf[1];
int rc;
HTTPEvent type;
size_t len = 0;
for(;;) {
// Use unref because we shouldn't block the server
// on a request that may never arrive.
uv_unref((uv_handle_t *)conn->stream);
rc = HTTPConnectionPeek(conn, &type, buf);
uv_ref((uv_handle_t *)conn->stream);
if(rc < 0) return rc;
if(HTTPHeaderField == type || HTTPHeadersComplete == type) break;
HTTPConnectionPop(conn, buf->len);
if(HTTPMessageBegin == type) continue;
if(HTTPURL != type) {
assertf(0, "Unexpected HTTP event %d", type);
return UV_UNKNOWN;
}
if(len+buf->len+1 > max) return UV_EMSGSIZE;
memcpy(out+len, buf->base, buf->len);
len += buf->len;
out[len] = '\0';
}
*method = conn->parser->method;
return (ssize_t)len;
}
static void uv_process_init(uv_process_t* handle) {
handle->type = UV_PROCESS;
handle->flags = 0;
handle->error = uv_ok_;
handle->exit_cb = NULL;
handle->pid = 0;
handle->exit_signal = 0;
handle->wait_handle = INVALID_HANDLE_VALUE;
handle->process_handle = INVALID_HANDLE_VALUE;
handle->close_handle = INVALID_HANDLE_VALUE;
handle->stdio_pipes[0].server_pipe = NULL;
handle->stdio_pipes[0].child_pipe = INVALID_HANDLE_VALUE;
handle->stdio_pipes[1].server_pipe = NULL;
handle->stdio_pipes[1].child_pipe = INVALID_HANDLE_VALUE;
handle->stdio_pipes[2].server_pipe = NULL;
handle->stdio_pipes[2].child_pipe = INVALID_HANDLE_VALUE;
uv_req_init((uv_req_t*)&handle->exit_req);
handle->exit_req.type = UV_PROCESS_EXIT;
handle->exit_req.data = handle;
uv_req_init((uv_req_t*)&handle->close_req);
handle->close_req.type = UV_PROCESS_CLOSE;
handle->close_req.data = handle;
uv_counters()->handle_init++;
uv_counters()->process_init++;
uv_ref();
}
static void uv_fs_event_init_handle(uv_loop_t* loop, uv_fs_event_t* handle,
const char* filename, uv_fs_event_cb cb) {
handle->type = UV_FS_EVENT;
handle->loop = loop;
handle->flags = 0;
handle->cb = cb;
handle->is_path_dir = 0;
handle->dir_handle = INVALID_HANDLE_VALUE;
handle->buffer = NULL;
handle->req_pending = 0;
handle->filew = NULL;
handle->short_filew = NULL;
uv_req_init(loop, (uv_req_t*)&handle->req);
handle->req.type = UV_FS_EVENT_REQ;
handle->req.data = (void*)handle;
handle->filename = strdup(filename);
if (!handle->filename) {
uv_fatal_error(ERROR_OUTOFMEMORY, "malloc");
}
loop->counters.handle_init++;
loop->counters.fs_event_init++;
uv_ref(loop);
}
/*
* Class: com_oracle_libuv_handles_Handle
* Method: _ref
* Signature: (J)V
*/
JNIEXPORT void JNICALL Java_com_oracle_libuv_handles_Handle__1ref
(JNIEnv *env, jobject that, jlong ptr) {
assert(ptr);
uv_handle_t* handle = reinterpret_cast<uv_handle_t*>(ptr);
uv_ref(handle);
}
int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
uv_fs_req_init(loop, req, UV_FS_FSTAT, NULL, cb);
if (cb) {
/* async */
uv_ref(loop);
req->eio = eio_fstat(file, EIO_PRI_DEFAULT, uv__fs_after, req);
if (!req->eio) {
uv_err_new(loop, ENOMEM);
return -1;
}
} else {
/* sync */
req->result = fstat(file, &req->statbuf);
if (req->result < 0) {
uv_err_new(loop, errno);
return -1;
}
req->ptr = &req->statbuf;
}
return 0;
}
int uv_fs_readdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
uv_fs_cb cb) {
int r;
struct dirent* entry;
size_t size = 0;
size_t d_namlen = 0;
uv_fs_req_init(loop, req, UV_FS_READDIR, path, cb);
if (cb) {
/* async */
uv_ref(loop);
req->eio = eio_readdir(path, flags, EIO_PRI_DEFAULT, uv__fs_after, req);
if (!req->eio) {
uv_err_new(loop, ENOMEM);
return -1;
}
} else {
/* sync */
DIR* dir = opendir(path);
if (!dir) {
uv_err_new(loop, errno);
req->result = -1;
return -1;
}
/* req->result stores number of entries */
req->result = 0;
while ((entry = readdir(dir))) {
d_namlen = strlen(entry->d_name);
/* Skip . and .. */
if ((d_namlen == 1 && entry->d_name[0] == '.') ||
(d_namlen == 2 && entry->d_name[0] == '.' &&
entry->d_name[1] == '.')) {
continue;
}
req->ptr = realloc(req->ptr, size + d_namlen + 1);
/* TODO check ENOMEM */
memcpy((char*)req->ptr + size, entry->d_name, d_namlen);
size += d_namlen;
((char*)req->ptr)[size] = '\0';
size++;
req->result++;
}
r = closedir(dir);
if (r) {
uv_err_new(loop, errno);
req->result = -1;
return -1;
}
}
return 0;
}
bool Handle::ref()
{
if (!active())
return false;
uv_ref(ptr());
return true;
}
static PyObject *
Handle_func_ref(Handle *self)
{
RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL);
RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL);
uv_ref(self->uv_handle);
Py_RETURN_NONE;
}
void EventStream::add(Event * event) {
uv_mutex_lock(&mutex);
eventVector.push_back(event);
uv_ref(reinterpret_cast<uv_handle_t *>(&async));
uv_mutex_unlock(&mutex);
uv_async_send(&async);
}
void uv_stream_init(uv_stream_t* handle) {
handle->write_queue_size = 0;
handle->flags = 0;
handle->error = uv_ok_;
uv_counters()->handle_init++;
uv_counters()->stream_init++;
uv_ref();
}
static void term(void *const unused) {
fprintf(stderr, "\n");
alogf("Stopping StrongLink server...\n");
uv_ref((uv_handle_t *)sigint);
uv_signal_stop(sigint);
async_close((uv_handle_t *)sigint);
SLNRepoPullsStop(repo);
HTTPServerClose(server_raw);
HTTPServerClose(server_tls);
async_pool_enter(NULL);
fflush(NULL); // Everything.
async_pool_leave(NULL);
uv_ref((uv_handle_t *)sigpipe);
uv_signal_stop(sigpipe);
uv_close((uv_handle_t *)sigpipe, NULL);
}
void TSockSys::RefLoop() {
IAssert(LoopRef == NULL);
// create new timer
LoopRef = (uv_timer_t*)malloc(sizeof(uv_timer_t));
// initialize
uv_timer_init(Loop, LoopRef);
// start the timer
uv_timer_start(LoopRef, LoopRefCallback, 0, 60000);
// reference the timer
uv_ref((uv_handle_t*)LoopRef);
}
int uv_queue_work(uv_loop_t* loop, uv_work_t* req, uv_work_cb work_cb,
uv_after_work_cb after_work_cb) {
uv_work_req_init(loop, req, work_cb, after_work_cb);
if (!QueueUserWorkItem(&uv_work_thread_proc, req, WT_EXECUTELONGFUNCTION)) {
uv_set_sys_error(loop, GetLastError());
return -1;
}
uv_ref(loop);
return 0;
}
static int uv__udp_send(uv_udp_send_t* req, uv_udp_t* handle, uv_buf_t bufs[],
int bufcnt, struct sockaddr* addr, int addr_len, uv_udp_send_cb cb) {
uv_loop_t* loop = handle->loop;
DWORD result, bytes;
uv_req_init(loop, (uv_req_t*) req);
req->type = UV_UDP_SEND;
req->handle = handle;
req->cb = cb;
memset(&req->overlapped, 0, sizeof(req->overlapped));
result = WSASendTo(handle->socket,
(WSABUF*)bufs,
bufcnt,
&bytes,
0,
addr,
addr_len,
&req->overlapped,
NULL);
if (UV_SUCCEEDED_WITHOUT_IOCP(result == 0)) {
/* Request completed immediately. */
req->queued_bytes = 0;
handle->reqs_pending++;
uv_ref(loop);
uv_insert_pending_req(loop, (uv_req_t*)req);
} else if (UV_SUCCEEDED_WITH_IOCP(result == 0)) {
/* Request queued by the kernel. */
req->queued_bytes = uv_count_bufs(bufs, bufcnt);
handle->reqs_pending++;
uv_ref(loop);
} else {
/* Send failed due to an error. */
uv__set_sys_error(loop, WSAGetLastError());
return -1;
}
return 0;
}
int uv_fs_readlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
uv_fs_cb cb) {
ssize_t size;
int status;
char* buf;
status = -1;
uv_fs_req_init(loop, req, UV_FS_READLINK, path, cb);
if (cb) {
if ((req->eio = eio_readlink(path, EIO_PRI_DEFAULT, uv__fs_after, req))) {
uv_ref(loop);
return 0;
} else {
uv_err_new(loop, ENOMEM);
return -1;
}
} else {
/* pathconf(_PC_PATH_MAX) may return -1 to signify that path
* lengths have no upper limit or aren't suitable for malloc'ing.
*/
if ((size = pathconf(path, _PC_PATH_MAX)) == -1) {
#if defined(PATH_MAX)
size = PATH_MAX;
#else
size = 4096;
#endif
}
if ((buf = malloc(size + 1)) == NULL) {
uv_err_new(loop, ENOMEM);
return -1;
}
if ((size = readlink(path, buf, size)) == -1) {
req->errorno = errno;
req->result = -1;
free(buf);
} else {
/* Cannot conceivably fail since it shrinks the buffer. */
buf = realloc(buf, size + 1);
buf[size] = '\0';
req->result = 0;
req->ptr = buf;
}
return 0;
}
assert(0 && "unreachable");
}
DecodeBaton() :
width(0),
height(0),
result(NULL),
resultLength(0)
{
#if NODE_MAJOR_VERSION == 0 && NODE_MINOR_VERSION <= 4
ev_ref(EV_DEFAULT_UC);
#else
this->request.data = this;
uv_ref(uv_default_loop());
#endif
}
/* stub implementation of uv_getaddrinfo */
int uv_getaddrinfo(uv_loop_t* loop,
uv_getaddrinfo_t* handle,
uv_getaddrinfo_cb cb,
const char* hostname,
const char* service,
const struct addrinfo* hints) {
eio_req* req;
uv_eio_init(loop);
if (handle == NULL || cb == NULL ||
(hostname == NULL && service == NULL)) {
uv__set_artificial_error(loop, UV_EINVAL);
return -1;
}
uv__req_init(loop, (uv_req_t*)handle);
handle->type = UV_GETADDRINFO;
handle->loop = loop;
handle->cb = cb;
/* TODO don't alloc so much. */
if (hints) {
handle->hints = malloc(sizeof(struct addrinfo));
memcpy(handle->hints, hints, sizeof(struct addrinfo));
}
else {
handle->hints = NULL;
}
/* TODO security! check lengths, check return values. */
handle->hostname = hostname ? strdup(hostname) : NULL;
handle->service = service ? strdup(service) : NULL;
handle->res = NULL;
handle->retcode = 0;
/* TODO check handle->hostname == NULL */
/* TODO check handle->service == NULL */
uv_ref(loop);
req = eio_custom(getaddrinfo_thread_proc, EIO_PRI_DEFAULT,
uv_getaddrinfo_done, handle, &loop->uv_eio_channel);
assert(req);
assert(req->data == handle);
return 0;
}
