Skip to content
This repository has been archived by the owner. It is now read-only.
Permalink
Browse files

uv: upgrade to 56a31f0

  • Loading branch information
bnoordhuis committed Jan 3, 2012
1 parent aa67b1f commit 075acfa2d6c823ec9ccedba5fdbca172752d1e4a
@@ -784,6 +784,13 @@ struct uv_pipe_s {
*/
UV_EXTERN int uv_pipe_init(uv_loop_t*, uv_pipe_t* handle, int ipc);

/*
* Connects two initialized pipes on different loops.
* Data written to one pipe will appear on the other side.
* This function is thread-safe.
*/
UV_EXTERN uv_err_t uv_pipe_pair(uv_pipe_t* a, uv_pipe_t* b);

/*
* Opens an existing file descriptor or HANDLE as a pipe.
*/
@@ -1313,7 +1320,8 @@ UV_EXTERN uv_err_t uv_dlopen(const char* filename, uv_lib_t* library);
UV_EXTERN uv_err_t uv_dlclose(uv_lib_t library);

/*
* Retrieves a data pointer from a dynamic library.
* Retrieves a data pointer from a dynamic library. It is legal for a symbol to
* map to NULL.
*/
UV_EXTERN uv_err_t uv_dlsym(uv_lib_t library, const char* name, void** ptr);

@@ -25,11 +25,17 @@
#include <dlfcn.h>
#include <errno.h>

/* The dl family of functions don't set errno. We need a good way to communicate
* errors to the caller but there is only dlerror() and that returns a string -
* a string that may or may not be safe to keep a reference to...
*/
static const uv_err_t uv_inval_ = { UV_EINVAL, EINVAL };


uv_err_t uv_dlopen(const char* filename, uv_lib_t* library) {
void* handle = dlopen(filename, RTLD_LAZY);
if (handle == NULL) {
return uv__new_sys_error(errno);
return uv_inval_;
}

*library = handle;
@@ -39,17 +45,23 @@ uv_err_t uv_dlopen(const char* filename, uv_lib_t* library) {

uv_err_t uv_dlclose(uv_lib_t library) {
if (dlclose(library) != 0) {
return uv__new_sys_error(errno);
return uv_inval_;
}

return uv_ok_;
}


uv_err_t uv_dlsym(uv_lib_t library, const char* name, void** ptr) {
void* address = dlsym(library, name);
if (address == NULL) {
return uv__new_sys_error(errno);
void* address;

/* Reset error status. */
dlerror();

address = dlsym(library, name);

if (dlerror()) {
return uv_inval_;
}

*ptr = (void*) address;
@@ -185,4 +185,9 @@ void uv__udp_watcher_stop(uv_udp_t* handle, ev_io* w);
/* fs */
void uv__fs_event_destroy(uv_fs_event_t* handle);

#define UV__F_IPC (1 << 0)
#define UV__F_NONBLOCK (1 << 1)
int uv__make_socketpair(int fds[2], int flags);
int uv__make_pipe(int fds[2], int flags);

#endif /* UV_UNIX_INTERNAL_H_ */
@@ -30,6 +30,10 @@
#include <stdlib.h>


static uv_once_t uv__pipe_pair_lock_guard = UV_ONCE_INIT;
static uv_mutex_t uv__pipe_pair_lock;


int uv_pipe_init(uv_loop_t* loop, uv_pipe_t* handle, int ipc) {
uv__stream_init(loop, (uv_stream_t*)handle, UV_NAMED_PIPE);
loop->counters.pipe_init++;
@@ -39,6 +43,38 @@ int uv_pipe_init(uv_loop_t* loop, uv_pipe_t* handle, int ipc) {
}


void uv__pipe_pair_lock_init() {
uv_mutex_init(&uv__pipe_pair_lock);
}


uv_err_t uv_pipe_pair(uv_pipe_t* a, uv_pipe_t* b) {
int fds[2];
int r;
uv_err_t err;

/* Make sure that the mutex is only initialized once. */
uv_once(&uv__pipe_pair_lock_guard, uv__pipe_pair_lock_init);

uv_mutex_lock(&uv__pipe_pair_lock);

r = uv__make_socketpair(fds, UV__F_NONBLOCK | UV__F_IPC);

if (r) {
err = uv__new_sys_error(errno);
} else {
uv_pipe_open(a, fds[0]);
uv_pipe_open(b, fds[1]);
err = uv_ok_;
}

uv_mutex_unlock(&uv__pipe_pair_lock);

return err;
}



int uv_pipe_bind(uv_pipe_t* handle, const char* name) {
struct sockaddr_un saddr;
const char* pipe_fname;
@@ -63,10 +63,7 @@ static void uv__chld(EV_P_ ev_child* watcher, int revents) {
}


#define UV__F_IPC (1 << 0)
#define UV__F_NONBLOCK (1 << 1)

static int uv__make_socketpair(int fds[2], int flags) {
int uv__make_socketpair(int fds[2], int flags) {
#ifdef SOCK_NONBLOCK
int fl;

@@ -103,7 +100,7 @@ static int uv__make_socketpair(int fds[2], int flags) {
}


static int uv__make_pipe(int fds[2], int flags) {
int uv__make_pipe(int fds[2], int flags) {
#if HAVE_SYS_PIPE2
int fl;

@@ -91,6 +91,12 @@ int uv_pipe_init(uv_loop_t* loop, uv_pipe_t* handle, int ipc) {
}


uv_err_t uv_pipe_pair(uv_pipe_t* a, uv_pipe_t* b) {
/* Implement me */
return uv__new_artificial_error(UV_ENOSYS);
}


static void uv_pipe_connection_init(uv_pipe_t* handle) {
uv_connection_init((uv_stream_t*) handle);
handle->read_req.data = handle;
@@ -29,6 +29,7 @@ TEST_DECLARE (tcp_ping_pong_v6)
TEST_DECLARE (tcp_ref)
TEST_DECLARE (tcp_ref2)
TEST_DECLARE (pipe_ping_pong)
TEST_DECLARE (pipe_pair)
TEST_DECLARE (delayed_accept)
TEST_DECLARE (multiple_listen)
TEST_DECLARE (tcp_writealot)
@@ -165,6 +166,8 @@ TASK_LIST_START
TEST_ENTRY (pipe_ping_pong)
TEST_HELPER (pipe_ping_pong, pipe_echo_server)

TEST_ENTRY (pipe_pair)

TEST_ENTRY (delayed_accept)
TEST_ENTRY (multiple_listen)

@@ -0,0 +1,137 @@
/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/

#include "uv.h"
#include "task.h"

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define PING "PING"

static uv_pipe_t a;
static uv_pipe_t b;
static uv_write_t req;
static uv_buf_t buf;
static enum {
STATE_MAIN_START,
STATE_THREAD_START,
STATE_MAIN_CLOSE,
STATE_THREAD_CLOSE,
} state;


static void pinger_read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {
ASSERT(state == STATE_MAIN_CLOSE);
state = STATE_THREAD_CLOSE;

ASSERT((uv_pipe_t*)stream == &b);

ASSERT(nread < 0);
ASSERT(uv_last_error(stream->loop).code == UV_EOF);

free(buf.base);

uv_close((uv_handle_t*)stream, NULL);
}


static void main_thread_read_cb(uv_stream_t* stream, ssize_t nread,
uv_buf_t buf) {
ASSERT(state == STATE_THREAD_START);
state = STATE_MAIN_CLOSE;

ASSERT((uv_pipe_t*)stream == &a);
ASSERT(stream->loop == uv_default_loop());

if (nread > 0) {
ASSERT(strcmp(buf.base, PING) == 0);
uv_close((uv_handle_t*)stream, NULL);
}

free(buf.base);
}


static uv_buf_t alloc_cb(uv_handle_t* handle, size_t size) {
uv_buf_t buf;
buf.base = (char*)malloc(size);
buf.len = size;
return buf;
}


void start(void* data) {
uv_loop_t* loop;
int r;

ASSERT(state == STATE_MAIN_START);
state = STATE_THREAD_START;

loop = data;

buf = uv_buf_init(PING, strlen(PING));

if (uv_write(&req, (uv_stream_t*)&b, &buf, 1, NULL)) {
FATAL("uv_write failed");
}

uv_read_start((uv_stream_t*)&b, alloc_cb, pinger_read_cb);

uv_run(loop);

ASSERT(state == STATE_THREAD_CLOSE);
}


TEST_IMPL(pipe_pair) {
int r;
uv_err_t err;
uv_thread_t tid;
uv_loop_t* loop;

state = STATE_MAIN_START;

r = uv_pipe_init(uv_default_loop(), &a, 1);
ASSERT(r == 0);

loop = uv_loop_new();
ASSERT(loop);

r = uv_pipe_init(loop, &b, 1);
ASSERT(r == 0);

err = uv_pipe_pair(&a, &b);
ASSERT(err.code == UV_OK);

r = uv_thread_create(&tid, start, loop);
ASSERT(r == 0);

uv_read_start((uv_stream_t*)&a, alloc_cb, main_thread_read_cb);

uv_run(uv_default_loop());
uv_thread_join(&tid);

ASSERT(state == STATE_THREAD_CLOSE);

return 0;
}
@@ -302,6 +302,7 @@
'test/test-ping-pong.c',
'test/test-pipe-bind-error.c',
'test/test-pipe-connect-error.c',
'test/test-pipe-pair.c',
'test/test-platform-output.c',
'test/test-process-title.c',
'test/test-ref.c',

0 comments on commit 075acfa

Please sign in to comment.
You can’t perform that action at this time.