lukechilds
/
node
mirror of https://github.com/lukechilds/node.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Rename evnet to evcom.

v0.7.4-release
Ryan 16 years ago
parent
842eaf446d
commit
0fb0af3a6c
12 changed files with 306 additions and 306 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 188
      deps/evcom/evcom.c
  2. 132
      deps/evcom/evcom.h
  3. 30
      deps/evcom/test/echo.c
  4. 138
      deps/evcom/test/test.c
  5. 0
      deps/evcom/test/timeout.rb
  6. 12
      src/net.cc
  7. 40
      src/net.h
  8. 12
      src/node.cc
  9. 4
      src/node.h
  10. 28
      src/process.cc
  11. 6
      src/process.h
  12. 22
      wscript

188
deps/evnet/evnet.c → deps/evcom/evcom.c
View File

@ -1,6 +1,6 @@
/* Copyright (c) 2008,2009 Ryan Dahl /* Copyright (c) 2008,2009 Ryan Dahl
* *
* evnet_queue comes from ngx_queue.h * evcom_queue comes from ngx_queue.h
* Copyright (C) 2002-2009 Igor Sysoev * Copyright (C) 2002-2009 Igor Sysoev
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@ -37,7 +37,7 @@
#include <sys/socket.h> /* shutdown */ #include <sys/socket.h> /* shutdown */
#include <ev.h> #include <ev.h>
#include <evnet.h> #include <evcom.h>
#if EV_MULTIPLICITY #if EV_MULTIPLICITY
# define SOCKET_LOOP_ socket->loop, # define SOCKET_LOOP_ socket->loop,
@ -47,9 +47,9 @@
# define SERVER_LOOP_ # define SERVER_LOOP_
#endif // EV_MULTIPLICITY #endif // EV_MULTIPLICITY
#if EVNET_HAVE_GNUTLS #if EVCOM_HAVE_GNUTLS
static int secure_full_goodbye (evnet_socket *socket); static int secure_full_goodbye (evcom_socket *socket);
static int secure_half_goodbye (evnet_socket *socket); static int secure_half_goodbye (evcom_socket *socket);
#endif #endif
#undef TRUE #undef TRUE
@ -76,16 +76,16 @@ set_nonblock (int fd)
} }
void void
evnet_buf_destroy (evnet_buf *buf) evcom_buf_destroy (evcom_buf *buf)
{ {
free(buf->base); free(buf->base);
free(buf); free(buf);
} }
evnet_buf * evcom_buf *
evnet_buf_new2 (size_t len) evcom_buf_new2 (size_t len)
{ {
evnet_buf *buf = malloc(sizeof(evnet_buf)); evcom_buf *buf = malloc(sizeof(evcom_buf));
if (!buf) return NULL; if (!buf) return NULL;
buf->base = malloc(len); buf->base = malloc(len);
if (!buf->base) { if (!buf->base) {
@ -93,14 +93,14 @@ evnet_buf_new2 (size_t len)
return NULL; return NULL;
} }
buf->len = len; buf->len = len;
buf->release = evnet_buf_destroy; buf->release = evcom_buf_destroy;
return buf; return buf;
} }
evnet_buf * evcom_buf *
evnet_buf_new (const char *base, size_t len) evcom_buf_new (const char *base, size_t len)
{ {
evnet_buf *buf = evnet_buf_new2(len); evcom_buf *buf = evcom_buf_new2(len);
if (!buf) return NULL; if (!buf) return NULL;
memcpy(buf->base, base, len); memcpy(buf->base, base, len);
@ -113,7 +113,7 @@ evnet_buf_new (const char *base, size_t len)
} while (0) } while (0)
static int static int
full_close (evnet_socket *socket) full_close (evcom_socket *socket)
{ {
//printf("close(%d)\n", socket->fd); //printf("close(%d)\n", socket->fd);
if (close(socket->fd) == -1) { if (close(socket->fd) == -1) {
@ -133,7 +133,7 @@ full_close (evnet_socket *socket)
} }
static int static int
half_close (evnet_socket *socket) half_close (evcom_socket *socket)
{ {
int r = shutdown(socket->fd, SHUT_WR); int r = shutdown(socket->fd, SHUT_WR);
if (r == -1) { if (r == -1) {
@ -158,7 +158,7 @@ half_close (evnet_socket *socket)
// This is to be called when ever the out_stream is empty // This is to be called when ever the out_stream is empty
// and we need to change state. // and we need to change state.
static void static void
change_state_for_empty_out_stream (evnet_socket *socket) change_state_for_empty_out_stream (evcom_socket *socket)
{ {
/* /*
* a very complicated bunch of close logic! * a very complicated bunch of close logic!
@ -175,7 +175,7 @@ change_state_for_empty_out_stream (evnet_socket *socket)
} else { } else {
/* Got Full Close. */ /* Got Full Close. */
if (socket->read_action) { if (socket->read_action) {
#if EVNET_HAVE_GNUTLS #if EVCOM_HAVE_GNUTLS
socket->read_action = socket->secure ? secure_full_goodbye : full_close; socket->read_action = socket->secure ? secure_full_goodbye : full_close;
#else #else
socket->read_action = full_close; socket->read_action = full_close;
@ -183,7 +183,7 @@ change_state_for_empty_out_stream (evnet_socket *socket)
} }
if (socket->write_action) { if (socket->write_action) {
#if EVNET_HAVE_GNUTLS #if EVCOM_HAVE_GNUTLS
socket->write_action = socket->secure ? secure_full_goodbye : full_close; socket->write_action = socket->secure ? secure_full_goodbye : full_close;
#else #else
socket->write_action = full_close; socket->write_action = full_close;
@ -193,7 +193,7 @@ change_state_for_empty_out_stream (evnet_socket *socket)
} else { } else {
/* Got Half Close. */ /* Got Half Close. */
if (socket->write_action) { if (socket->write_action) {
#if EVNET_HAVE_GNUTLS #if EVCOM_HAVE_GNUTLS
socket->write_action = socket->secure ? secure_half_goodbye : half_close; socket->write_action = socket->secure ? secure_half_goodbye : half_close;
#else #else
socket->write_action = half_close; socket->write_action = half_close;
@ -204,22 +204,22 @@ change_state_for_empty_out_stream (evnet_socket *socket)
} }
static void static void
update_write_buffer_after_send (evnet_socket *socket, ssize_t sent) update_write_buffer_after_send (evcom_socket *socket, ssize_t sent)
{ {
evnet_queue *q = evnet_queue_last(&socket->out_stream); evcom_queue *q = evcom_queue_last(&socket->out_stream);
evnet_buf *to_write = evnet_queue_data(q, evnet_buf, queue); evcom_buf *to_write = evcom_queue_data(q, evcom_buf, queue);
to_write->written += sent; to_write->written += sent;
socket->written += sent; socket->written += sent;
if (to_write->written == to_write->len) { if (to_write->written == to_write->len) {
evnet_queue_remove(q); evcom_queue_remove(q);
if (to_write->release) { if (to_write->release) {
to_write->release(to_write); to_write->release(to_write);
} }
if (evnet_queue_empty(&socket->out_stream)) { if (evcom_queue_empty(&socket->out_stream)) {
change_state_for_empty_out_stream(socket); change_state_for_empty_out_stream(socket);
if (socket->on_drain) if (socket->on_drain)
socket->on_drain(socket); socket->on_drain(socket);
@ -227,15 +227,15 @@ update_write_buffer_after_send (evnet_socket *socket, ssize_t sent)
} }
} }
#if EVNET_HAVE_GNUTLS #if EVCOM_HAVE_GNUTLS
static int secure_socket_send (evnet_socket *socket); static int secure_socket_send (evcom_socket *socket);
static int secure_socket_recv (evnet_socket *socket); static int secure_socket_recv (evcom_socket *socket);
/* TODO can this be done without ignoring SIGPIPE? */ /* TODO can this be done without ignoring SIGPIPE? */
static ssize_t static ssize_t
nosigpipe_push (gnutls_transport_ptr_t data, const void *buf, size_t len) nosigpipe_push (gnutls_transport_ptr_t data, const void *buf, size_t len)
{ {
evnet_socket *socket = (evnet_socket*)data; evcom_socket *socket = (evcom_socket*)data;
assert(socket->secure); assert(socket->secure);
int flags = 0; int flags = 0;
#ifdef MSG_NOSIGNAL #ifdef MSG_NOSIGNAL
@ -254,7 +254,7 @@ nosigpipe_push (gnutls_transport_ptr_t data, const void *buf, size_t len)
} }
static int static int
secure_handshake (evnet_socket *socket) secure_handshake (evcom_socket *socket)
{ {
assert(socket->secure); assert(socket->secure);
@ -268,7 +268,7 @@ secure_handshake (evnet_socket *socket)
if (r == GNUTLS_E_INTERRUPTED || r == GNUTLS_E_AGAIN) if (r == GNUTLS_E_INTERRUPTED || r == GNUTLS_E_AGAIN)
return AGAIN; return AGAIN;
evnet_socket_reset_timeout(socket); evcom_socket_reset_timeout(socket);
if (!socket->connected) { if (!socket->connected) {
socket->connected = TRUE; socket->connected = TRUE;
@ -287,17 +287,17 @@ secure_handshake (evnet_socket *socket)
} }
static int static int
secure_socket_send (evnet_socket *socket) secure_socket_send (evcom_socket *socket)
{ {
ssize_t sent; ssize_t sent;
if (evnet_queue_empty(&socket->out_stream)) { if (evcom_queue_empty(&socket->out_stream)) {
ev_io_stop(SOCKET_LOOP_ &socket->write_watcher); ev_io_stop(SOCKET_LOOP_ &socket->write_watcher);
return AGAIN; return AGAIN;
} }
evnet_queue *q = evnet_queue_last(&socket->out_stream); evcom_queue *q = evcom_queue_last(&socket->out_stream);
evnet_buf *to_write = evnet_queue_data(q, evnet_buf, queue); evcom_buf *to_write = evcom_queue_data(q, evcom_buf, queue);
assert(socket->secure); assert(socket->secure);
@ -312,7 +312,7 @@ secure_socket_send (evnet_socket *socket)
if (sent == 0) return AGAIN; if (sent == 0) return AGAIN;
evnet_socket_reset_timeout(socket); evcom_socket_reset_timeout(socket);
if (sent == GNUTLS_E_INTERRUPTED || sent == GNUTLS_E_AGAIN) { if (sent == GNUTLS_E_INTERRUPTED || sent == GNUTLS_E_AGAIN) {
return AGAIN; return AGAIN;
@ -331,7 +331,7 @@ secure_socket_send (evnet_socket *socket)
} }
static int static int
secure_socket_recv (evnet_socket *socket) secure_socket_recv (evcom_socket *socket)
{ {
char recv_buffer[socket->chunksize]; char recv_buffer[socket->chunksize];
size_t recv_buffer_size = socket->chunksize; size_t recv_buffer_size = socket->chunksize;
@ -352,7 +352,7 @@ secure_socket_recv (evnet_socket *socket)
return AGAIN; return AGAIN;
} }
evnet_socket_reset_timeout(socket); evcom_socket_reset_timeout(socket);
/* A server may also receive GNUTLS_E_REHANDSHAKE when a client has /* A server may also receive GNUTLS_E_REHANDSHAKE when a client has
* initiated a handshake. In that case the server can only initiate a * initiated a handshake. In that case the server can only initiate a
@ -392,7 +392,7 @@ secure_socket_recv (evnet_socket *socket)
} }
static int static int
secure_full_goodbye (evnet_socket *socket) secure_full_goodbye (evcom_socket *socket)
{ {
assert(socket->secure); assert(socket->secure);
@ -411,7 +411,7 @@ secure_full_goodbye (evnet_socket *socket)
} }
static int static int
secure_half_goodbye (evnet_socket *socket) secure_half_goodbye (evcom_socket *socket)
{ {
assert(socket->secure); assert(socket->secure);
@ -430,7 +430,7 @@ secure_half_goodbye (evnet_socket *socket)
} }
void void
evnet_socket_set_secure_session (evnet_socket *socket, gnutls_session_t session) evcom_socket_set_secure_session (evcom_socket *socket, gnutls_session_t session)
{ {
socket->session = session; socket->session = session;
socket->secure = TRUE; socket->secure = TRUE;
@ -438,19 +438,19 @@ evnet_socket_set_secure_session (evnet_socket *socket, gnutls_session_t session)
#endif /* HAVE GNUTLS */ #endif /* HAVE GNUTLS */
static int static int
socket_send (evnet_socket *socket) socket_send (evcom_socket *socket)
{ {
ssize_t sent; ssize_t sent;
assert(socket->secure == FALSE); assert(socket->secure == FALSE);
if (evnet_queue_empty(&socket->out_stream)) { if (evcom_queue_empty(&socket->out_stream)) {
ev_io_stop(SOCKET_LOOP_ &socket->write_watcher); ev_io_stop(SOCKET_LOOP_ &socket->write_watcher);
return AGAIN; return AGAIN;
} }
evnet_queue *q = evnet_queue_last(&socket->out_stream); evcom_queue *q = evcom_queue_last(&socket->out_stream);
evnet_buf *to_write = evnet_queue_data(q, evnet_buf, queue); evcom_buf *to_write = evcom_queue_data(q, evcom_buf, queue);
int flags = 0; int flags = 0;
#ifdef MSG_NOSIGNAL #ifdef MSG_NOSIGNAL
@ -482,7 +482,7 @@ socket_send (evnet_socket *socket)
} }
} }
evnet_socket_reset_timeout(socket); evcom_socket_reset_timeout(socket);
if (!socket->connected) { if (!socket->connected) {
socket->connected = TRUE; socket->connected = TRUE;
@ -495,7 +495,7 @@ socket_send (evnet_socket *socket)
} }
static int static int
socket_recv (evnet_socket *socket) socket_recv (evcom_socket *socket)
{ {
char buf[TCP_MAXWIN]; char buf[TCP_MAXWIN];
size_t buf_size = TCP_MAXWIN; size_t buf_size = TCP_MAXWIN;
@ -529,10 +529,10 @@ socket_recv (evnet_socket *socket)
} }
} }
evnet_socket_reset_timeout(socket); evcom_socket_reset_timeout(socket);
if (recved == 0) { if (recved == 0) {
evnet_socket_read_stop(socket); evcom_socket_read_stop(socket);
socket->read_action = NULL; socket->read_action = NULL;
if (socket->write_action == NULL) CLOSE_ASAP(socket); if (socket->write_action == NULL) CLOSE_ASAP(socket);
} }
@ -544,7 +544,7 @@ socket_recv (evnet_socket *socket)
} }
static void static void
assign_file_descriptor (evnet_socket *socket, int fd) assign_file_descriptor (evcom_socket *socket, int fd)
{ {
socket->fd = fd; socket->fd = fd;
@ -554,7 +554,7 @@ assign_file_descriptor (evnet_socket *socket, int fd)
socket->read_action = socket_recv; socket->read_action = socket_recv;
socket->write_action = socket_send; socket->write_action = socket_send;
#if EVNET_HAVE_GNUTLS #if EVCOM_HAVE_GNUTLS
if (socket->secure) { if (socket->secure) {
gnutls_transport_set_lowat(socket->session, 0); gnutls_transport_set_lowat(socket->session, 0);
gnutls_transport_set_push_function(socket->session, nosigpipe_push); gnutls_transport_set_push_function(socket->session, nosigpipe_push);
@ -568,10 +568,10 @@ assign_file_descriptor (evnet_socket *socket, int fd)
} }
static void static void
server_close_with_error (evnet_server *server, int errorno) server_close_with_error (evcom_server *server, int errorno)
{ {
if (server->listening) { if (server->listening) {
evnet_server_detach(server); evcom_server_detach(server);
close(server->fd); /* TODO do this on the loop? check return value? */ close(server->fd); /* TODO do this on the loop? check return value? */
server->fd = -1; server->fd = -1;
server->listening = FALSE; server->listening = FALSE;
@ -583,12 +583,12 @@ server_close_with_error (evnet_server *server, int errorno)
} }
/* Retruns evnet_socket if a connection could be accepted. /* Retruns evcom_socket if a connection could be accepted.
* The returned socket is not yet attached to the event loop. * The returned socket is not yet attached to the event loop.
* Otherwise NULL * Otherwise NULL
*/ */
static evnet_socket* static evcom_socket*
accept_connection (evnet_server *server) accept_connection (evcom_server *server)
{ {
struct sockaddr address; /* connector's address information */ struct sockaddr address; /* connector's address information */
socklen_t addr_len = sizeof(address); socklen_t addr_len = sizeof(address);
@ -603,7 +603,7 @@ accept_connection (evnet_server *server)
goto error; goto error;
} }
evnet_socket *socket = NULL; evcom_socket *socket = NULL;
if (server->on_connection) { if (server->on_connection) {
socket = server->on_connection(server, (struct sockaddr*)&address); socket = server->on_connection(server, (struct sockaddr*)&address);
@ -639,7 +639,7 @@ error:
static void static void
on_connection (EV_P_ ev_io *watcher, int revents) on_connection (EV_P_ ev_io *watcher, int revents)
{ {
evnet_server *server = watcher->data; evcom_server *server = watcher->data;
assert(server->listening); assert(server->listening);
#if EV_MULTIPLICITY #if EV_MULTIPLICITY
@ -653,14 +653,14 @@ on_connection (EV_P_ ev_io *watcher, int revents)
} }
/* accept as many connections as possible */ /* accept as many connections as possible */
evnet_socket *socket; evcom_socket *socket;
while ((socket = accept_connection(server))) { while ((socket = accept_connection(server))) {
evnet_socket_attach(EV_A_ socket); evcom_socket_attach(EV_A_ socket);
} }
} }
int int
evnet_server_listen (evnet_server *server, struct addrinfo *addrinfo, int backlog) evcom_server_listen (evcom_server *server, struct addrinfo *addrinfo, int backlog)
{ {
int fd = -1; int fd = -1;
assert(server->listening == FALSE); assert(server->listening == FALSE);
@ -710,13 +710,13 @@ evnet_server_listen (evnet_server *server, struct addrinfo *addrinfo, int backlo
* existing connections. * existing connections.
*/ */
void void
evnet_server_close (evnet_server *server) evcom_server_close (evcom_server *server)
{ {
server_close_with_error(server, 0); server_close_with_error(server, 0);
} }
void void
evnet_server_attach (EV_P_ evnet_server *server) evcom_server_attach (EV_P_ evcom_server *server)
{ {
ev_io_start (EV_A_ &server->connection_watcher); ev_io_start (EV_A_ &server->connection_watcher);
#if EV_MULTIPLICITY #if EV_MULTIPLICITY
@ -726,7 +726,7 @@ evnet_server_attach (EV_P_ evnet_server *server)
} }
void void
evnet_server_detach (evnet_server *server) evcom_server_detach (evcom_server *server)
{ {
ev_io_stop (SERVER_LOOP_ &server->connection_watcher); ev_io_stop (SERVER_LOOP_ &server->connection_watcher);
#if EV_MULTIPLICITY #if EV_MULTIPLICITY
@ -736,7 +736,7 @@ evnet_server_detach (evnet_server *server)
} }
void void
evnet_server_init (evnet_server *server) evcom_server_init (evcom_server *server)
{ {
server->attached = FALSE; server->attached = FALSE;
server->listening = FALSE; server->listening = FALSE;
@ -751,7 +751,7 @@ evnet_server_init (evnet_server *server)
static void static void
on_timeout (EV_P_ ev_timer *watcher, int revents) on_timeout (EV_P_ ev_timer *watcher, int revents)
{ {
evnet_socket *socket = watcher->data; evcom_socket *socket = watcher->data;
#if EV_MULTIPLICITY #if EV_MULTIPLICITY
assert(socket->loop == loop); assert(socket->loop == loop);
@ -766,12 +766,12 @@ on_timeout (EV_P_ ev_timer *watcher, int revents)
} }
static void static void
release_write_buffer(evnet_socket *socket) release_write_buffer(evcom_socket *socket)
{ {
while (!evnet_queue_empty(&socket->out_stream)) { while (!evcom_queue_empty(&socket->out_stream)) {
evnet_queue *q = evnet_queue_last(&socket->out_stream); evcom_queue *q = evcom_queue_last(&socket->out_stream);
evnet_buf *buf = evnet_queue_data(q, evnet_buf, queue); evcom_buf *buf = evcom_queue_data(q, evcom_buf, queue);
evnet_queue_remove(q); evcom_queue_remove(q);
if (buf->release) buf->release(buf); if (buf->release) buf->release(buf);
} }
} }
@ -780,7 +780,7 @@ release_write_buffer(evnet_socket *socket)
static void static void
on_io_event(EV_P_ ev_io *watcher, int revents) on_io_event(EV_P_ ev_io *watcher, int revents)
{ {
evnet_socket *socket = watcher->data; evcom_socket *socket = watcher->data;
if (revents & EV_ERROR) { if (revents & EV_ERROR) {
socket->errorno = 1; socket->errorno = 1;
@ -827,7 +827,7 @@ on_io_event(EV_P_ ev_io *watcher, int revents)
ev_clear_pending (EV_A_ &socket->read_watcher); ev_clear_pending (EV_A_ &socket->read_watcher);
ev_clear_pending (EV_A_ &socket->timeout_watcher); ev_clear_pending (EV_A_ &socket->timeout_watcher);
evnet_socket_detach(socket); evcom_socket_detach(socket);
assert(socket->fd == -1); assert(socket->fd == -1);
if (socket->on_close) socket->on_close(socket); if (socket->on_close) socket->on_close(socket);
@ -844,7 +844,7 @@ on_io_event(EV_P_ ev_io *watcher, int revents)
* gnutls_db_set_ptr (socket->session, _); * gnutls_db_set_ptr (socket->session, _);
*/ */
void void
evnet_socket_init (evnet_socket *socket, float timeout) evcom_socket_init (evcom_socket *socket, float timeout)
{ {
socket->fd = -1; socket->fd = -1;
socket->server = NULL; socket->server = NULL;
@ -854,7 +854,7 @@ evnet_socket_init (evnet_socket *socket, float timeout)
socket->attached = FALSE; socket->attached = FALSE;
socket->connected = FALSE; socket->connected = FALSE;
evnet_queue_init(&socket->out_stream); evcom_queue_init(&socket->out_stream);
ev_init(&socket->write_watcher, on_io_event); ev_init(&socket->write_watcher, on_io_event);
socket->write_watcher.data = socket; socket->write_watcher.data = socket;
@ -868,7 +868,7 @@ evnet_socket_init (evnet_socket *socket, float timeout)
socket->errorno = 0; socket->errorno = 0;
socket->secure = FALSE; socket->secure = FALSE;
#if EVNET_HAVE_GNUTLS #if EVCOM_HAVE_GNUTLS
socket->gnutls_errorno = 0; socket->gnutls_errorno = 0;
socket->session = NULL; socket->session = NULL;
#endif #endif
@ -888,24 +888,24 @@ evnet_socket_init (evnet_socket *socket, float timeout)
} }
void void
evnet_socket_close (evnet_socket *socket) evcom_socket_close (evcom_socket *socket)
{ {
socket->got_half_close = TRUE; socket->got_half_close = TRUE;
if (evnet_queue_empty(&socket->out_stream)) { if (evcom_queue_empty(&socket->out_stream)) {
change_state_for_empty_out_stream(socket); change_state_for_empty_out_stream(socket);
} }
} }
void void
evnet_socket_full_close (evnet_socket *socket) evcom_socket_full_close (evcom_socket *socket)
{ {
socket->got_full_close = TRUE; socket->got_full_close = TRUE;
if (evnet_queue_empty(&socket->out_stream)) { if (evcom_queue_empty(&socket->out_stream)) {
change_state_for_empty_out_stream(socket); change_state_for_empty_out_stream(socket);
} }
} }
void evnet_socket_force_close (evnet_socket *socket) void evcom_socket_force_close (evcom_socket *socket)
{ {
release_write_buffer(socket); release_write_buffer(socket);
@ -914,16 +914,16 @@ void evnet_socket_force_close (evnet_socket *socket)
ev_clear_pending (SOCKET_LOOP_ &socket->timeout_watcher); ev_clear_pending (SOCKET_LOOP_ &socket->timeout_watcher);
socket->write_action = socket->read_action = NULL; socket->write_action = socket->read_action = NULL;
// socket->errorno = EVNET_SOCKET_ERROR_FORCE_CLOSE // socket->errorno = EVCOM_SOCKET_ERROR_FORCE_CLOSE
if (socket->fd > 0) close(socket->fd); if (socket->fd > 0) close(socket->fd);
socket->fd = -1; socket->fd = -1;
evnet_socket_detach(socket); evcom_socket_detach(socket);
} }
void void
evnet_socket_write (evnet_socket *socket, evnet_buf *buf) evcom_socket_write (evcom_socket *socket, evcom_buf *buf)
{ {
if (socket->write_action == NULL) { if (socket->write_action == NULL) {
assert(0 && "Do not write to a closed socket"); assert(0 && "Do not write to a closed socket");
@ -934,7 +934,7 @@ evnet_socket_write (evnet_socket *socket, evnet_buf *buf)
goto error; goto error;
} }
evnet_queue_insert_head(&socket->out_stream, &buf->queue); evcom_queue_insert_head(&socket->out_stream, &buf->queue);
buf->written = 0; buf->written = 0;
if (socket->attached) { if (socket->attached) {
@ -947,13 +947,13 @@ error:
} }
void void
evnet_socket_reset_timeout (evnet_socket *socket) evcom_socket_reset_timeout (evcom_socket *socket)
{ {
ev_timer_again(SOCKET_LOOP_ &socket->timeout_watcher); ev_timer_again(SOCKET_LOOP_ &socket->timeout_watcher);
} }
static void static void
free_simple_buf (evnet_buf *buf) free_simple_buf (evcom_buf *buf)
{ {
free(buf->base); free(buf->base);
free(buf); free(buf);
@ -963,18 +963,18 @@ free_simple_buf (evnet_buf *buf)
* NOTE: Allocates memory. Avoid for performance applications. * NOTE: Allocates memory. Avoid for performance applications.
*/ */
void void
evnet_socket_write_simple (evnet_socket *socket, const char *str, size_t len) evcom_socket_write_simple (evcom_socket *socket, const char *str, size_t len)
{ {
evnet_buf *buf = malloc(sizeof(evnet_buf)); evcom_buf *buf = malloc(sizeof(evcom_buf));
buf->release = free_simple_buf; buf->release = free_simple_buf;
buf->base = strdup(str); buf->base = strdup(str);
buf->len = len; buf->len = len;
evnet_socket_write(socket, buf); evcom_socket_write(socket, buf);
} }
void void
evnet_socket_attach (EV_P_ evnet_socket *socket) evcom_socket_attach (EV_P_ evcom_socket *socket)
{ {
#if EV_MULTIPLICITY #if EV_MULTIPLICITY
socket->loop = loop; socket->loop = loop;
@ -993,7 +993,7 @@ evnet_socket_attach (EV_P_ evnet_socket *socket)
} }
void void
evnet_socket_detach (evnet_socket *socket) evcom_socket_detach (evcom_socket *socket)
{ {
if (socket->attached) { if (socket->attached) {
ev_io_stop(SOCKET_LOOP_ &socket->write_watcher); ev_io_stop(SOCKET_LOOP_ &socket->write_watcher);
@ -1007,14 +1007,14 @@ evnet_socket_detach (evnet_socket *socket)
} }
void void
evnet_socket_read_stop (evnet_socket *socket) evcom_socket_read_stop (evcom_socket *socket)
{ {
ev_io_stop(SOCKET_LOOP_ &socket->read_watcher); ev_io_stop(SOCKET_LOOP_ &socket->read_watcher);
ev_clear_pending(SOCKET_LOOP_ &socket->read_watcher); ev_clear_pending(SOCKET_LOOP_ &socket->read_watcher);
} }
void void
evnet_socket_read_start (evnet_socket *socket) evcom_socket_read_start (evcom_socket *socket)
{ {
if (socket->read_action) { if (socket->read_action) {
ev_io_start(SOCKET_LOOP_ &socket->read_watcher); ev_io_start(SOCKET_LOOP_ &socket->read_watcher);
@ -1023,7 +1023,7 @@ evnet_socket_read_start (evnet_socket *socket)
} }
int int
evnet_socket_connect (evnet_socket *s, struct addrinfo *addrinfo) evcom_socket_connect (evcom_socket *s, struct addrinfo *addrinfo)
{ {
int fd = socket(addrinfo->ai_family, addrinfo->ai_socktype, int fd = socket(addrinfo->ai_family, addrinfo->ai_socktype,
addrinfo->ai_protocol); addrinfo->ai_protocol);

132
deps/evnet/evnet.h → deps/evcom/evcom.h
View File

@ -1,6 +1,6 @@
/* Copyright (c) 2008,2009 Ryan Dahl /* Copyright (c) 2008,2009 Ryan Dahl
* *
* evnet_queue comes from Nginx, ngx_queue.h * evcom_queue comes from Nginx, ngx_queue.h
* Copyright (C) 2002-2009 Igor Sysoev * Copyright (C) 2002-2009 Igor Sysoev
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@ -28,54 +28,54 @@
#include <ev.h> #include <ev.h>
#include <stddef.h> /* offsetof() */ #include <stddef.h> /* offsetof() */
#ifndef evnet_h #ifndef evcom_h
#define evnet_h #define evcom_h
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#ifndef EVNET_HAVE_GNUTLS #ifndef EVCOM_HAVE_GNUTLS
# define EVNET_HAVE_GNUTLS 0 # define EVCOM_HAVE_GNUTLS 0
#endif #endif
#if EVNET_HAVE_GNUTLS #if EVCOM_HAVE_GNUTLS
# include <gnutls/gnutls.h> # include <gnutls/gnutls.h>
#endif #endif
typedef struct evnet_queue evnet_queue; typedef struct evcom_queue evcom_queue;
typedef struct evnet_buf evnet_buf; typedef struct evcom_buf evcom_buf;
typedef struct evnet_server evnet_server; typedef struct evcom_server evcom_server;
typedef struct evnet_socket evnet_socket; typedef struct evcom_socket evcom_socket;
void evnet_server_init (evnet_server *); void evcom_server_init (evcom_server *);
int evnet_server_listen (evnet_server *, struct addrinfo *addrinfo, int backlog); int evcom_server_listen (evcom_server *, struct addrinfo *addrinfo, int backlog);
void evnet_server_attach (EV_P_ evnet_server *); void evcom_server_attach (EV_P_ evcom_server *);
void evnet_server_detach (evnet_server *); void evcom_server_detach (evcom_server *);
void evnet_server_close (evnet_server *); // synchronous void evcom_server_close (evcom_server *); // synchronous
void evnet_socket_init (evnet_socket *, float timeout); void evcom_socket_init (evcom_socket *, float timeout);
int evnet_socket_connect (evnet_socket *, struct addrinfo *addrinfo); int evcom_socket_connect (evcom_socket *, struct addrinfo *addrinfo);
void evnet_socket_attach (EV_P_ evnet_socket *); void evcom_socket_attach (EV_P_ evcom_socket *);
void evnet_socket_detach (evnet_socket *); void evcom_socket_detach (evcom_socket *);
void evnet_socket_read_start (evnet_socket *); void evcom_socket_read_start (evcom_socket *);
void evnet_socket_read_stop (evnet_socket *); void evcom_socket_read_stop (evcom_socket *);
/* Resets the timeout to stay alive for another socket->timeout seconds /* Resets the timeout to stay alive for another socket->timeout seconds
*/ */
void evnet_socket_reset_timeout (evnet_socket *); void evcom_socket_reset_timeout (evcom_socket *);
/* Writes a buffer to the socket. /* Writes a buffer to the socket.
* (Do not send a NULL evnet_buf or a buffer with evnet_buf->base == NULL.) * (Do not send a NULL evcom_buf or a buffer with evcom_buf->base == NULL.)
*/ */
void evnet_socket_write (evnet_socket *, evnet_buf *); void evcom_socket_write (evcom_socket *, evcom_buf *);
void evnet_socket_write_simple (evnet_socket *, const char *str, size_t len); void evcom_socket_write_simple (evcom_socket *, const char *str, size_t len);
/* Once the write buffer is drained, evnet_socket_close will shutdown the /* Once the write buffer is drained, evcom_socket_close will shutdown the
* writing end of the socket and will close the read end once the server * writing end of the socket and will close the read end once the server
* replies with an EOF. * replies with an EOF.
*/ */
void evnet_socket_close (evnet_socket *); void evcom_socket_close (evcom_socket *);
/* Do not wait for the server to reply with EOF. This will only be called /* Do not wait for the server to reply with EOF. This will only be called
* once the write buffer is drained. * once the write buffer is drained.
@ -83,47 +83,47 @@ void evnet_socket_close (evnet_socket *);
* packets if this is called when data is still being received from the * packets if this is called when data is still being received from the
* server. * server.
*/ */
void evnet_socket_full_close (evnet_socket *); void evcom_socket_full_close (evcom_socket *);
/* The most extreme measure. /* The most extreme measure.
* Will not wait for the write queue to complete. * Will not wait for the write queue to complete.
*/ */
void evnet_socket_force_close (evnet_socket *); void evcom_socket_force_close (evcom_socket *);
#if EVNET_HAVE_GNUTLS #if EVCOM_HAVE_GNUTLS
/* Tells the socket to use transport layer security (SSL). evnet_socket does /* Tells the socket to use transport layer security (SSL). evcom_socket does
* not want to make any decisions about security requirements, so the * not want to make any decisions about security requirements, so the
* majoirty of GnuTLS configuration is left to the user. Only the transport * majoirty of GnuTLS configuration is left to the user. Only the transport
* layer of GnuTLS is controlled by evnet_socket. That is, do not use * layer of GnuTLS is controlled by evcom_socket. That is, do not use
* gnutls_transport_* functions. Do use the rest of GnuTLS's API. * gnutls_transport_* functions. Do use the rest of GnuTLS's API.
*/ */
void evnet_socket_set_secure_session (evnet_socket *, gnutls_session_t); void evcom_socket_set_secure_session (evcom_socket *, gnutls_session_t);
#endif #endif
evnet_buf * evnet_buf_new (const char* base, size_t len); evcom_buf * evcom_buf_new (const char* base, size_t len);
evnet_buf * evnet_buf_new2 (size_t len); evcom_buf * evcom_buf_new2 (size_t len);
void evnet_buf_destroy (evnet_buf *); void evcom_buf_destroy (evcom_buf *);
struct evnet_queue { struct evcom_queue {
evnet_queue *prev; evcom_queue *prev;
evnet_queue *next; evcom_queue *next;
}; };
struct evnet_buf { struct evcom_buf {
/* public */ /* public */
char *base; char *base;
size_t len; size_t len;
void (*release) (evnet_buf *); /* called when oi is done with the object */ void (*release) (evcom_buf *); /* called when oi is done with the object */
void *data; void *data;
/* private */ /* private */
size_t written; size_t written;
evnet_queue queue; evcom_queue queue;
}; };
struct evnet_server { struct evcom_server {
/* read only */ /* read only */
int fd; int fd;
#if EV_MULTIPLICITY #if EV_MULTIPLICITY
@ -137,26 +137,26 @@ struct evnet_server {
/* PUBLIC */ /* PUBLIC */
evnet_socket* (*on_connection) (evnet_server *, struct sockaddr *remote_addr); evcom_socket* (*on_connection) (evcom_server *, struct sockaddr *remote_addr);
/* Executed when a server is closed. /* Executed when a server is closed.
* If evnet_server_close() was called errorno will be 0. * If evcom_server_close() was called errorno will be 0.
* An libev error is indicated with errorno == 1 * An libev error is indicated with errorno == 1
* Otherwise errorno is a stdlib errno from a system call, e.g. accept() * Otherwise errorno is a stdlib errno from a system call, e.g. accept()
*/ */
void (*on_close) (evnet_server *, int errorno); void (*on_close) (evcom_server *, int errorno);
void *data; void *data;
}; };
struct evnet_socket { struct evcom_socket {
/* read only */ /* read only */
int fd; int fd;
#if EV_MULTIPLICITY #if EV_MULTIPLICITY
struct ev_loop *loop; struct ev_loop *loop;
#endif #endif
evnet_server *server; evcom_server *server;
evnet_queue out_stream; evcom_queue out_stream;
size_t written; size_t written;
unsigned attached:1; unsigned attached:1;
unsigned connected:1; unsigned connected:1;
@ -165,12 +165,12 @@ struct evnet_socket {
unsigned got_half_close:1; unsigned got_half_close:1;
/* NULL = that end of the socket is closed. */ /* NULL = that end of the socket is closed. */
int (*read_action) (evnet_socket *); int (*read_action) (evcom_socket *);
int (*write_action) (evnet_socket *); int (*write_action) (evcom_socket *);
/* ERROR CODES. 0 = no error. Check on_close. */ /* ERROR CODES. 0 = no error. Check on_close. */
int errorno; int errorno;
#if EVNET_HAVE_GNUTLS #if EVCOM_HAVE_GNUTLS
int gnutls_errorno; int gnutls_errorno;
#endif #endif
@ -178,29 +178,29 @@ struct evnet_socket {
ev_io write_watcher; ev_io write_watcher;
ev_io read_watcher; ev_io read_watcher;
ev_timer timeout_watcher; ev_timer timeout_watcher;
#if EVNET_HAVE_GNUTLS #if EVCOM_HAVE_GNUTLS
gnutls_session_t session; gnutls_session_t session;
#endif #endif
/* public */ /* public */
size_t chunksize; /* the maximum chunk that on_read() will return */ size_t chunksize; /* the maximum chunk that on_read() will return */
void (*on_connect) (evnet_socket *); void (*on_connect) (evcom_socket *);
void (*on_read) (evnet_socket *, const void *buf, size_t count); void (*on_read) (evcom_socket *, const void *buf, size_t count);
void (*on_drain) (evnet_socket *); void (*on_drain) (evcom_socket *);
void (*on_close) (evnet_socket *); void (*on_close) (evcom_socket *);
void (*on_timeout) (evnet_socket *); void (*on_timeout) (evcom_socket *);
void *data; void *data;
}; };
EV_INLINE void EV_INLINE void
evnet_queue_init (evnet_queue *q) evcom_queue_init (evcom_queue *q)
{ {
q->prev = q; q->prev = q;
q->next = q; q->next = q;
} }
EV_INLINE void EV_INLINE void
evnet_queue_insert_head (evnet_queue *h, evnet_queue *x) evcom_queue_insert_head (evcom_queue *h, evcom_queue *x)
{ {
(x)->next = (h)->next; (x)->next = (h)->next;
(x)->next->prev = x; (x)->next->prev = x;
@ -209,7 +209,7 @@ evnet_queue_insert_head (evnet_queue *h, evnet_queue *x)
} }
EV_INLINE void EV_INLINE void
evnet_queue_remove (evnet_queue *x) evcom_queue_remove (evcom_queue *x)
{ {
(x)->next->prev = (x)->prev; (x)->next->prev = (x)->prev;
(x)->prev->next = (x)->next; (x)->prev->next = (x)->next;
@ -219,14 +219,14 @@ evnet_queue_remove (evnet_queue *x)
#endif #endif
} }
#define evnet_queue_empty(h) (h == (h)->prev) #define evcom_queue_empty(h) (h == (h)->prev)
#define evnet_queue_head(h) (h)->next #define evcom_queue_head(h) (h)->next
#define evnet_queue_last(h) (h)->prev #define evcom_queue_last(h) (h)->prev
#define evnet_queue_data(q, type, link) \ #define evcom_queue_data(q, type, link) \
(type *) ((unsigned char *) q - offsetof(type, link)) (type *) ((unsigned char *) q - offsetof(type, link))
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* evnet_h */ #endif /* evcom_h */

30
deps/evnet/test/echo.c → deps/evcom/test/echo.c
View File

@ -11,7 +11,7 @@
#include <ev.h> #include <ev.h>
#include <evnet.h> #include <evcom.h>
#include <gnutls/gnutls.h> #include <gnutls/gnutls.h>
#define HOST "127.0.0.1" #define HOST "127.0.0.1"
@ -21,7 +21,7 @@
static int nconnections; static int nconnections;
static void static void
on_peer_close (evnet_socket *socket) on_peer_close (evcom_socket *socket)
{ {
assert(socket->errorno == 0); assert(socket->errorno == 0);
//printf("server connection closed\n"); //printf("server connection closed\n");
@ -29,7 +29,7 @@ on_peer_close (evnet_socket *socket)
} }
static void static void
on_peer_timeout (evnet_socket *socket) on_peer_timeout (evcom_socket *socket)
{ {
assert(socket); assert(socket);
fprintf(stderr, "peer connection timeout\n"); fprintf(stderr, "peer connection timeout\n");
@ -42,21 +42,21 @@ on_peer_timeout (evnet_socket *socket)
#define TIMEOUT 5.0 #define TIMEOUT 5.0
static void static void
on_peer_read (evnet_socket *socket, const void *base, size_t len) on_peer_read (evcom_socket *socket, const void *base, size_t len)
{ {
if(len == 0) return; if(len == 0) return;
evnet_socket_write_simple(socket, base, len); evcom_socket_write_simple(socket, base, len);
} }
static evnet_socket* static evcom_socket*
on_server_connection (evnet_server *server, struct sockaddr *addr) on_server_connection (evcom_server *server, struct sockaddr *addr)
{ {
assert(server); assert(server);
assert(addr); assert(addr);
evnet_socket *socket = malloc(sizeof(evnet_socket)); evcom_socket *socket = malloc(sizeof(evcom_socket));
evnet_socket_init(socket, TIMEOUT); evcom_socket_init(socket, TIMEOUT);
socket->on_read = on_peer_read; socket->on_read = on_peer_read;
socket->on_close = on_peer_close; socket->on_close = on_peer_close;
socket->on_timeout = on_peer_timeout; socket->on_timeout = on_peer_timeout;
@ -73,12 +73,12 @@ int
main (void) main (void)
{ {
int r; int r;
evnet_server server; evcom_server server;
//printf("sizeof(evnet_server): %d\n", sizeof(evnet_server)); //printf("sizeof(evcom_server): %d\n", sizeof(evcom_server));
//printf("sizeof(evnet_socket): %d\n", sizeof(evnet_socket)); //printf("sizeof(evcom_socket): %d\n", sizeof(evcom_socket));
evnet_server_init(&server); evcom_server_init(&server);
server.on_connection = on_server_connection; server.on_connection = on_server_connection;
struct addrinfo *servinfo; struct addrinfo *servinfo;
@ -90,9 +90,9 @@ main (void)
r = getaddrinfo(NULL, PORT, &hints, &servinfo); r = getaddrinfo(NULL, PORT, &hints, &servinfo);
assert(r == 0); assert(r == 0);
r = evnet_server_listen(&server, servinfo, 10); r = evcom_server_listen(&server, servinfo, 10);
assert(r == 0); assert(r == 0);
evnet_server_attach(EV_DEFAULT_ &server); evcom_server_attach(EV_DEFAULT_ &server);
ev_loop(EV_DEFAULT_ 0); ev_loop(EV_DEFAULT_ 0);

138
deps/evnet/test/test.c → deps/evcom/test/test.c
View File

@ -10,9 +10,9 @@
#include <netinet/in.h> #include <netinet/in.h>
#include <ev.h> #include <ev.h>
#include <evnet.h> #include <evcom.h>
#if EVNET_HAVE_GNUTLS #if EVCOM_HAVE_GNUTLS
# include <gnutls/gnutls.h> # include <gnutls/gnutls.h>
#endif #endif
@ -29,13 +29,13 @@ static const struct addrinfo tcp_hints =
#define SOCKFILE "/tmp/oi.sock" #define SOCKFILE "/tmp/oi.sock"
#define PORT "5000" #define PORT "5000"
static evnet_server server; static evcom_server server;
static int nconnections; static int nconnections;
static int use_tls; static int use_tls;
static int got_server_close; static int got_server_close;
static void static void
common_on_server_close (evnet_server *server, int errorno) common_on_server_close (evcom_server *server, int errorno)
{ {
assert(server); assert(server);
assert(errorno == 0); assert(errorno == 0);
@ -43,11 +43,11 @@ common_on_server_close (evnet_server *server, int errorno)
} }
static void static void
common_on_peer_close (evnet_socket *socket) common_on_peer_close (evcom_socket *socket)
{ {
assert(socket->errorno == 0); assert(socket->errorno == 0);
printf("server connection closed\n"); printf("server connection closed\n");
#if EVNET_HAVE_GNUTLS #if EVCOM_HAVE_GNUTLS
assert(socket->gnutls_errorno == 0); assert(socket->gnutls_errorno == 0);
if (use_tls) gnutls_deinit(socket->session); if (use_tls) gnutls_deinit(socket->session);
#endif #endif
@ -55,27 +55,27 @@ common_on_peer_close (evnet_socket *socket)
} }
static void static void
common_on_client_timeout (evnet_socket *socket) common_on_client_timeout (evcom_socket *socket)
{ {
assert(socket); assert(socket);
printf("client connection timeout\n"); printf("client connection timeout\n");
} }
static void static void
common_on_peer_timeout (evnet_socket *socket) common_on_peer_timeout (evcom_socket *socket)
{ {
assert(socket); assert(socket);
fprintf(stderr, "peer connection timeout\n"); fprintf(stderr, "peer connection timeout\n");
assert(0); assert(0);
} }
#if EVNET_HAVE_GNUTLS #if EVCOM_HAVE_GNUTLS
#define DH_BITS 768 #define DH_BITS 768
static gnutls_anon_server_credentials_t server_credentials; static gnutls_anon_server_credentials_t server_credentials;
const int kx_prio[] = { GNUTLS_KX_ANON_DH, 0 }; const int kx_prio[] = { GNUTLS_KX_ANON_DH, 0 };
static gnutls_dh_params_t dh_params; static gnutls_dh_params_t dh_params;
void anon_tls_server (evnet_socket *socket) void anon_tls_server (evcom_socket *socket)
{ {
gnutls_session_t session; gnutls_session_t session;
socket->data = session; socket->data = session;
@ -87,10 +87,10 @@ void anon_tls_server (evnet_socket *socket)
gnutls_credentials_set(session, GNUTLS_CRD_ANON, server_credentials); gnutls_credentials_set(session, GNUTLS_CRD_ANON, server_credentials);
gnutls_dh_set_prime_bits(session, DH_BITS); gnutls_dh_set_prime_bits(session, DH_BITS);
evnet_socket_set_secure_session(socket, session); evcom_socket_set_secure_session(socket, session);
} }
void anon_tls_client (evnet_socket *socket) void anon_tls_client (evcom_socket *socket)
{ {
gnutls_session_t client_session; gnutls_session_t client_session;
gnutls_anon_client_credentials_t client_credentials; gnutls_anon_client_credentials_t client_credentials;
@ -102,11 +102,11 @@ void anon_tls_client (evnet_socket *socket)
/* Need to enable anonymous KX specifically. */ /* Need to enable anonymous KX specifically. */
gnutls_credentials_set(client_session, GNUTLS_CRD_ANON, client_credentials); gnutls_credentials_set(client_session, GNUTLS_CRD_ANON, client_credentials);
evnet_socket_set_secure_session(socket, client_session); evcom_socket_set_secure_session(socket, client_session);
assert(socket->secure); assert(socket->secure);
} }
#endif // EVNET_HAVE_GNUTLS #endif // EVCOM_HAVE_GNUTLS
@ -120,10 +120,10 @@ void anon_tls_client (evnet_socket *socket)
static int successful_ping_count; static int successful_ping_count;
static void static void
pingpong_on_peer_read (evnet_socket *socket, const void *base, size_t len) pingpong_on_peer_read (evcom_socket *socket, const void *base, size_t len)
{ {
if (len == 0) { if (len == 0) {
evnet_socket_close(socket); evcom_socket_close(socket);
return; return;
} }
@ -132,32 +132,32 @@ pingpong_on_peer_read (evnet_socket *socket, const void *base, size_t len)
buf[len] = 0; buf[len] = 0;
printf("server got message: %s\n", buf); printf("server got message: %s\n", buf);
evnet_socket_write_simple(socket, PONG, sizeof PONG); evcom_socket_write_simple(socket, PONG, sizeof PONG);
} }
static void static void
pingpong_on_client_close (evnet_socket *socket) pingpong_on_client_close (evcom_socket *socket)
{ {
assert(socket); assert(socket);
printf("client connection closed\n"); printf("client connection closed\n");
evnet_server_close(&server); evcom_server_close(&server);
} }
static evnet_socket* static evcom_socket*
pingpong_on_server_connection (evnet_server *_server, struct sockaddr *addr) pingpong_on_server_connection (evcom_server *_server, struct sockaddr *addr)
{ {
assert(_server == &server); assert(_server == &server);
assert(addr); assert(addr);
evnet_socket *socket = malloc(sizeof(evnet_socket)); evcom_socket *socket = malloc(sizeof(evcom_socket));
evnet_socket_init(socket, PINGPONG_TIMEOUT); evcom_socket_init(socket, PINGPONG_TIMEOUT);
socket->on_read = pingpong_on_peer_read; socket->on_read = pingpong_on_peer_read;
socket->on_close = common_on_peer_close; socket->on_close = common_on_peer_close;
socket->on_timeout = common_on_peer_timeout; socket->on_timeout = common_on_peer_timeout;
nconnections++; nconnections++;
#if EVNET_HAVE_GNUTLS #if EVCOM_HAVE_GNUTLS
if (use_tls) anon_tls_server(socket); if (use_tls) anon_tls_server(socket);
#endif #endif
@ -167,17 +167,17 @@ pingpong_on_server_connection (evnet_server *_server, struct sockaddr *addr)
} }
static void static void
pingpong_on_client_connect (evnet_socket *socket) pingpong_on_client_connect (evcom_socket *socket)
{ {
printf("client connected. sending ping\n"); printf("client connected. sending ping\n");
evnet_socket_write_simple(socket, PING, sizeof PING); evcom_socket_write_simple(socket, PING, sizeof PING);
} }
static void static void
pingpong_on_client_read (evnet_socket *socket, const void *base, size_t len) pingpong_on_client_read (evcom_socket *socket, const void *base, size_t len)
{ {
if(len == 0) { if(len == 0) {
evnet_socket_close(socket); evcom_socket_close(socket);
return; return;
} }
@ -191,49 +191,49 @@ pingpong_on_client_read (evnet_socket *socket, const void *base, size_t len)
assert(strcmp(buf, PONG) == 0); assert(strcmp(buf, PONG) == 0);
if (++successful_ping_count > EXCHANGES) { if (++successful_ping_count > EXCHANGES) {
evnet_socket_close(socket); evcom_socket_close(socket);
return; return;
} }
if (successful_ping_count % (EXCHANGES/20) == 0) MARK_PROGRESS; if (successful_ping_count % (EXCHANGES/20) == 0) MARK_PROGRESS;
evnet_socket_write_simple(socket, PING, sizeof PING); evcom_socket_write_simple(socket, PING, sizeof PING);
} }
int int
pingpong (struct addrinfo *servinfo) pingpong (struct addrinfo *servinfo)
{ {
int r; int r;
evnet_socket client; evcom_socket client;
successful_ping_count = 0; successful_ping_count = 0;
nconnections = 0; nconnections = 0;
got_server_close = 0; got_server_close = 0;
printf("sizeof(evnet_server): %d\n", sizeof(evnet_server)); printf("sizeof(evcom_server): %d\n", sizeof(evcom_server));
printf("sizeof(evnet_socket): %d\n", sizeof(evnet_socket)); printf("sizeof(evcom_socket): %d\n", sizeof(evcom_socket));
evnet_server_init(&server); evcom_server_init(&server);
server.on_connection = pingpong_on_server_connection; server.on_connection = pingpong_on_server_connection;
server.on_close = common_on_server_close; server.on_close = common_on_server_close;
r = evnet_server_listen(&server, servinfo, 10); r = evcom_server_listen(&server, servinfo, 10);
assert(r == 0); assert(r == 0);
evnet_server_attach(EV_DEFAULT_ &server); evcom_server_attach(EV_DEFAULT_ &server);
evnet_socket_init(&client, PINGPONG_TIMEOUT); evcom_socket_init(&client, PINGPONG_TIMEOUT);
client.on_read = pingpong_on_client_read; client.on_read = pingpong_on_client_read;
client.on_connect = pingpong_on_client_connect; client.on_connect = pingpong_on_client_connect;
client.on_close = pingpong_on_client_close; client.on_close = pingpong_on_client_close;
client.on_timeout = common_on_client_timeout; client.on_timeout = common_on_client_timeout;
#if EVNET_HAVE_GNUTLS #if EVCOM_HAVE_GNUTLS
if (use_tls) anon_tls_client(&client); if (use_tls) anon_tls_client(&client);
#endif #endif
r = evnet_socket_connect(&client, servinfo); r = evcom_socket_connect(&client, servinfo);
assert(r == 0 && "problem connecting"); assert(r == 0 && "problem connecting");
evnet_socket_attach(EV_DEFAULT_ &client); evcom_socket_attach(EV_DEFAULT_ &client);
ev_loop(EV_DEFAULT_ 0); ev_loop(EV_DEFAULT_ 0);
@ -252,34 +252,34 @@ pingpong (struct addrinfo *servinfo)
#define CONNINT_TIMEOUT 1000.0 #define CONNINT_TIMEOUT 1000.0
static void static void
connint_on_peer_read(evnet_socket *socket, const void *base, size_t len) connint_on_peer_read(evcom_socket *socket, const void *base, size_t len)
{ {
assert(base); assert(base);
assert(len == 0); assert(len == 0);
evnet_socket_write_simple(socket, "BYE", 3); evcom_socket_write_simple(socket, "BYE", 3);
printf("server wrote bye\n"); printf("server wrote bye\n");
} }
static void static void
connint_on_peer_drain(evnet_socket *socket) connint_on_peer_drain(evcom_socket *socket)
{ {
evnet_socket_close(socket); evcom_socket_close(socket);
} }
static evnet_socket* static evcom_socket*
connint_on_server_connection(evnet_server *_server, struct sockaddr *addr) connint_on_server_connection(evcom_server *_server, struct sockaddr *addr)
{ {
assert(_server == &server); assert(_server == &server);
assert(addr); assert(addr);
evnet_socket *socket = malloc(sizeof(evnet_socket)); evcom_socket *socket = malloc(sizeof(evcom_socket));
evnet_socket_init(socket, CONNINT_TIMEOUT); evcom_socket_init(socket, CONNINT_TIMEOUT);
socket->on_read = connint_on_peer_read; socket->on_read = connint_on_peer_read;
socket->on_drain = connint_on_peer_drain; socket->on_drain = connint_on_peer_drain;
socket->on_close = common_on_peer_close; socket->on_close = common_on_peer_close;
socket->on_timeout = common_on_peer_timeout; socket->on_timeout = common_on_peer_timeout;
#if EVNET_HAVE_GNUTLS #if EVCOM_HAVE_GNUTLS
if (use_tls) anon_tls_server(socket); if (use_tls) anon_tls_server(socket);
#endif #endif
@ -289,32 +289,32 @@ connint_on_server_connection(evnet_server *_server, struct sockaddr *addr)
} }
static void static void
connint_on_client_connect (evnet_socket *socket) connint_on_client_connect (evcom_socket *socket)
{ {
printf("on client connection\n"); printf("on client connection\n");
evnet_socket_close(socket); evcom_socket_close(socket);
} }
static void static void
connint_on_client_close (evnet_socket *socket) connint_on_client_close (evcom_socket *socket)
{ {
evnet_socket_close(socket); // already closed, but it shouldn't crash if we try to do it again evcom_socket_close(socket); // already closed, but it shouldn't crash if we try to do it again
printf("client connection closed\n"); printf("client connection closed\n");
if (nconnections % (NCONN/20) == 0) MARK_PROGRESS; if (nconnections % (NCONN/20) == 0) MARK_PROGRESS;
if(++nconnections == NCONN) { if(++nconnections == NCONN) {
evnet_server_close(&server); evcom_server_close(&server);
printf("closing server\n"); printf("closing server\n");
} }
} }
static void static void
connint_on_client_read (evnet_socket *socket, const void *base, size_t len) connint_on_client_read (evcom_socket *socket, const void *base, size_t len)
{ {
if (len == 0) { if (len == 0) {
evnet_socket_close(socket); evcom_socket_close(socket);
return; return;
} }
@ -325,7 +325,7 @@ connint_on_client_read (evnet_socket *socket, const void *base, size_t len)
printf("client got message: %s\n", buf); printf("client got message: %s\n", buf);
assert(strcmp(buf, "BYE") == 0); assert(strcmp(buf, "BYE") == 0);
evnet_socket_close(socket); evcom_socket_close(socket);
} }
int int
@ -336,29 +336,29 @@ connint (struct addrinfo *servinfo)
nconnections = 0; nconnections = 0;
got_server_close = 0; got_server_close = 0;
evnet_server_init(&server); evcom_server_init(&server);
server.on_connection = connint_on_server_connection; server.on_connection = connint_on_server_connection;
server.on_close = common_on_server_close; server.on_close = common_on_server_close;
evnet_server_listen(&server, servinfo, 1000); evcom_server_listen(&server, servinfo, 1000);
evnet_server_attach(EV_DEFAULT_ &server); evcom_server_attach(EV_DEFAULT_ &server);
evnet_socket clients[NCONN]; evcom_socket clients[NCONN];
int i; int i;
for (i = 0; i < NCONN; i++) { for (i = 0; i < NCONN; i++) {
evnet_socket *client = &clients[i]; evcom_socket *client = &clients[i];
evnet_socket_init(client, CONNINT_TIMEOUT); evcom_socket_init(client, CONNINT_TIMEOUT);
client->on_read = connint_on_client_read; client->on_read = connint_on_client_read;
client->on_connect = connint_on_client_connect; client->on_connect = connint_on_client_connect;
client->on_close = connint_on_client_close; client->on_close = connint_on_client_close;
client->on_timeout = common_on_client_timeout; client->on_timeout = common_on_client_timeout;
#if EVNET_HAVE_GNUTLS #if EVCOM_HAVE_GNUTLS
if (use_tls) anon_tls_client(client); if (use_tls) anon_tls_client(client);
#endif #endif
r = evnet_socket_connect(client, servinfo); r = evcom_socket_connect(client, servinfo);
assert(r == 0 && "problem connecting"); assert(r == 0 && "problem connecting");
evnet_socket_attach(EV_DEFAULT_ client); evcom_socket_attach(EV_DEFAULT_ client);
} }
ev_loop(EV_DEFAULT_ 0); ev_loop(EV_DEFAULT_ 0);
@ -422,7 +422,7 @@ free_unix_address (struct addrinfo *servinfo)
int int
main (void) main (void)
{ {
#if EVNET_HAVE_GNUTLS #if EVCOM_HAVE_GNUTLS
gnutls_global_init(); gnutls_global_init();
gnutls_dh_params_init (&dh_params); gnutls_dh_params_init (&dh_params);
@ -442,7 +442,7 @@ main (void)
assert(pingpong(tcp_address) == 0); assert(pingpong(tcp_address) == 0);
assert(connint(tcp_address) == 0); assert(connint(tcp_address) == 0);
#if EVNET_HAVE_GNUTLS #if EVCOM_HAVE_GNUTLS
use_tls = 1; use_tls = 1;
assert(pingpong(tcp_address) == 0); assert(pingpong(tcp_address) == 0);
assert(connint(tcp_address) == 0); assert(connint(tcp_address) == 0);
@ -460,7 +460,7 @@ main (void)
assert(connint(unix_address) == 0); assert(connint(unix_address) == 0);
free_unix_address(unix_address); free_unix_address(unix_address);
#if EVNET_HAVE_GNUTLS #if EVCOM_HAVE_GNUTLS
use_tls = 1; use_tls = 1;
unix_address = create_unix_address(); unix_address = create_unix_address();

0
deps/evnet/test/timeout.rb → deps/evcom/test/timeout.rb
View File

12
src/net.cc
View File

@ -101,7 +101,7 @@ Connection::Init (void)
{ {
opening = false; opening = false;
double timeout = 60.0; // default double timeout = 60.0; // default
evnet_socket_init(&socket_, timeout); evcom_socket_init(&socket_, timeout);
socket_.on_connect = Connection::on_connect; socket_.on_connect = Connection::on_connect;
socket_.on_read = Connection::on_read; socket_.on_read = Connection::on_read;
socket_.on_drain = Connection::on_drain; socket_.on_drain = Connection::on_drain;
@ -275,13 +275,13 @@ Connection::AfterResolve (eio_req *req)
// no error. return. // no error. return.
if (r == 0 && req->result == 0) { if (r == 0 && req->result == 0) {
evnet_socket_attach (EV_DEFAULT_UC_ &connection->socket_); evcom_socket_attach (EV_DEFAULT_UC_ &connection->socket_);
goto out; goto out;
} }
/* RESOLVE ERROR */ /* RESOLVE ERROR */
/* TODO: the whole resolve process should be moved into evnet_socket. /* TODO: the whole resolve process should be moved into evcom_socket.
* The fact that I'm modifying a read-only variable here should be * The fact that I'm modifying a read-only variable here should be
* good evidence of this. * good evidence of this.
*/ */
@ -376,7 +376,7 @@ Connection::Send (const Arguments& args)
// XXX // XXX
// A lot of improvement can be made here. First of all we're allocating // A lot of improvement can be made here. First of all we're allocating
// evnet_bufs for every send which is clearly inefficent - it should use a // evcom_bufs for every send which is clearly inefficent - it should use a
// memory pool or ring buffer. Of course, expressing binary data as an // memory pool or ring buffer. Of course, expressing binary data as an
// array of integers is extremely inefficent. This can improved when v8 // array of integers is extremely inefficent. This can improved when v8
// bug 270 (http://code.google.com/p/v8/issues/detail?id=270) has been // bug 270 (http://code.google.com/p/v8/issues/detail?id=270) has been
@ -386,7 +386,7 @@ Connection::Send (const Arguments& args)
enum encoding enc = ParseEncoding(args[1]); enum encoding enc = ParseEncoding(args[1]);
Local<String> s = args[0]->ToString(); Local<String> s = args[0]->ToString();
size_t len = s->Utf8Length(); size_t len = s->Utf8Length();
evnet_buf *buf = node::buf_new(len); evcom_buf *buf = node::buf_new(len);
switch (enc) { switch (enc) {
case RAW: case RAW:
case ASCII: case ASCII:
@ -405,7 +405,7 @@ Connection::Send (const Arguments& args)
} else if (args[0]->IsArray()) { } else if (args[0]->IsArray()) {
Handle<Array> array = Handle<Array>::Cast(args[0]); Handle<Array> array = Handle<Array>::Cast(args[0]);
size_t len = array->Length(); size_t len = array->Length();
evnet_buf *buf = node::buf_new(len); evcom_buf *buf = node::buf_new(len);
for (size_t i = 0; i < len; i++) { for (size_t i = 0; i < len; i++) {
Local<Value> int_value = array->Get(Integer::New(i)); Local<Value> int_value = array->Get(Integer::New(i));
buf->base[i] = int_value->IntegerValue(); buf->base[i] = int_value->IntegerValue();

40
src/net.h
View File

@ -4,7 +4,7 @@
#include "node.h" #include "node.h"
#include "events.h" #include "events.h"
#include <v8.h> #include <v8.h>
#include <evnet.h> #include <evcom.h>
#include <string.h> #include <string.h>
@ -43,12 +43,12 @@ protected:
virtual ~Connection (void); virtual ~Connection (void);
int Connect (struct addrinfo *address) { int Connect (struct addrinfo *address) {
return evnet_socket_connect (&socket_, address); return evcom_socket_connect (&socket_, address);
} }
void Send (evnet_buf *buf) { evnet_socket_write(&socket_, buf); } void Send (evcom_buf *buf) { evcom_socket_write(&socket_, buf); }
void Close (void) { evnet_socket_close(&socket_); } void Close (void) { evcom_socket_close(&socket_); }
void FullClose (void) { evnet_socket_full_close(&socket_); } void FullClose (void) { evcom_socket_full_close(&socket_); }
void ForceClose (void) { evnet_socket_force_close(&socket_); } void ForceClose (void) { evcom_socket_force_close(&socket_); }
virtual void OnConnect (void); virtual void OnConnect (void);
virtual void OnReceive (const void *buf, size_t len); virtual void OnReceive (const void *buf, size_t len);
@ -68,12 +68,12 @@ protected:
private: private:
/* liboi callbacks */ /* liboi callbacks */
static void on_connect (evnet_socket *s) { static void on_connect (evcom_socket *s) {
Connection *connection = static_cast<Connection*> (s->data); Connection *connection = static_cast<Connection*> (s->data);
connection->OnConnect(); connection->OnConnect();
} }
static void on_read (evnet_socket *s, const void *buf, size_t len) { static void on_read (evcom_socket *s, const void *buf, size_t len) {
Connection *connection = static_cast<Connection*> (s->data); Connection *connection = static_cast<Connection*> (s->data);
assert(connection->attached_); assert(connection->attached_);
if (len == 0) if (len == 0)
@ -82,12 +82,12 @@ private:
connection->OnReceive(buf, len); connection->OnReceive(buf, len);
} }
static void on_drain (evnet_socket *s) { static void on_drain (evcom_socket *s) {
Connection *connection = static_cast<Connection*> (s->data); Connection *connection = static_cast<Connection*> (s->data);
connection->OnDrain(); connection->OnDrain();
} }
static void on_close (evnet_socket *s) { static void on_close (evcom_socket *s) {
Connection *connection = static_cast<Connection*> (s->data); Connection *connection = static_cast<Connection*> (s->data);
assert(connection->socket_.fd < 0); assert(connection->socket_.fd < 0);
@ -105,7 +105,7 @@ private:
connection->Detach(); connection->Detach();
} }
static void on_timeout (evnet_socket *s) { static void on_timeout (evcom_socket *s) {
Connection *connection = static_cast<Connection*> (s->data); Connection *connection = static_cast<Connection*> (s->data);
connection->OnTimeout(); connection->OnTimeout();
} }
@ -116,7 +116,7 @@ private:
static int AfterResolve (eio_req *req); static int AfterResolve (eio_req *req);
char *host_; char *host_;
char *port_; char *port_;
evnet_socket socket_; evcom_socket socket_;
friend class Server; friend class Server;
}; };
@ -133,26 +133,26 @@ protected:
Server (void) : EventEmitter() Server (void) : EventEmitter()
{ {
evnet_server_init(&server_); evcom_server_init(&server_);
server_.on_connection = Server::on_connection; server_.on_connection = Server::on_connection;
server_.on_close = Server::on_close; server_.on_close = Server::on_close;
server_.data = this; server_.data = this;
} }
virtual ~Server () { virtual ~Server () {
evnet_server_close (&server_); evcom_server_close (&server_);
} }
int Listen (struct addrinfo *address) { int Listen (struct addrinfo *address) {
int r = evnet_server_listen (&server_, address, 1024); int r = evcom_server_listen (&server_, address, 1024);
if(r != 0) return r; if(r != 0) return r;
evnet_server_attach (EV_DEFAULT_ &server_); evcom_server_attach (EV_DEFAULT_ &server_);
Attach(); Attach();
return 0; return 0;
} }
void Close ( ) { void Close ( ) {
evnet_server_close (&server_); evcom_server_close (&server_);
} }
virtual v8::Handle<v8::FunctionTemplate> GetConnectionTemplate (void); virtual v8::Handle<v8::FunctionTemplate> GetConnectionTemplate (void);
@ -160,20 +160,20 @@ protected:
private: private:
Connection* OnConnection (struct sockaddr *addr); Connection* OnConnection (struct sockaddr *addr);
static evnet_socket* on_connection (evnet_server *s, struct sockaddr *addr) { static evcom_socket* on_connection (evcom_server *s, struct sockaddr *addr) {
Server *server = static_cast<Server*> (s->data); Server *server = static_cast<Server*> (s->data);
Connection *connection = server->OnConnection (addr); Connection *connection = server->OnConnection (addr);
return &connection->socket_; return &connection->socket_;
} }
void OnClose (int errorno); void OnClose (int errorno);
static void on_close (evnet_server *s, int errorno) { static void on_close (evcom_server *s, int errorno) {
Server *server = static_cast<Server*> (s->data); Server *server = static_cast<Server*> (s->data);
server->OnClose(errorno); server->OnClose(errorno);
server->Detach(); server->Detach();
} }
evnet_server server_; evcom_server server_;
}; };
} // namespace node } // namespace node

12
src/node.cc
View File

@ -23,22 +23,22 @@ using namespace v8;
using namespace node; using namespace node;
static void static void
buf_free (evnet_buf *b) buf_free (evcom_buf *b)
{ {
size_t total = sizeof(evnet_buf) + b->len; size_t total = sizeof(evcom_buf) + b->len;
V8::AdjustAmountOfExternalAllocatedMemory(-total); V8::AdjustAmountOfExternalAllocatedMemory(-total);
free(b); free(b);
} }
evnet_buf * evcom_buf *
node::buf_new (size_t size) node::buf_new (size_t size)
{ {
size_t total = sizeof(evnet_buf) + size; size_t total = sizeof(evcom_buf) + size;
void *p = malloc(total); void *p = malloc(total);
if (p == NULL) return NULL; if (p == NULL) return NULL;
evnet_buf *b = static_cast<evnet_buf*>(p); evcom_buf *b = static_cast<evcom_buf*>(p);
b->base = static_cast<char*>(p) + sizeof(evnet_buf); b->base = static_cast<char*>(p) + sizeof(evcom_buf);
b->len = size; b->len = size;
b->release = buf_free; b->release = buf_free;

4
src/node.h
View File

@ -4,7 +4,7 @@
#include <ev.h> #include <ev.h>
#include <eio.h> #include <eio.h>
#include <v8.h> #include <v8.h>
#include <evnet.h> #include <evcom.h>
#include "object_wrap.h" #include "object_wrap.h"
@ -30,7 +30,7 @@ do { \
enum encoding {ASCII, UTF8, RAW}; enum encoding {ASCII, UTF8, RAW};
enum encoding ParseEncoding (v8::Handle<v8::Value> encoding_v); enum encoding ParseEncoding (v8::Handle<v8::Value> encoding_v);
void FatalException (v8::TryCatch &try_catch); void FatalException (v8::TryCatch &try_catch);
evnet_buf * buf_new (size_t size); evcom_buf * buf_new (size_t size);
} // namespace node } // namespace node
#endif // node_h #endif // node_h

28
src/process.cc
View File

@ -100,13 +100,13 @@ Process::Write (const Arguments& args)
// XXX // XXX
// A lot of improvement can be made here. First of all we're allocating // A lot of improvement can be made here. First of all we're allocating
// evnet_bufs for every send which is clearly inefficent - it should use a // evcom_bufs for every send which is clearly inefficent - it should use a
// memory pool or ring buffer. Of course, expressing binary data as an // memory pool or ring buffer. Of course, expressing binary data as an
// array of integers is extremely inefficent. This can improved when v8 // array of integers is extremely inefficent. This can improved when v8
// bug 270 (http://code.google.com/p/v8/issues/detail?id=270) has been // bug 270 (http://code.google.com/p/v8/issues/detail?id=270) has been
// addressed. // addressed.
evnet_buf *buf; evcom_buf *buf;
size_t len; size_t len;
if (args[0]->IsString()) { if (args[0]->IsString()) {
@ -196,7 +196,7 @@ Process::Process ()
pid_ = 0; pid_ = 0;
evnet_queue_init(&out_stream_); evcom_queue_init(&out_stream_);
} }
Process::~Process () Process::~Process ()
@ -208,10 +208,10 @@ void
Process::Shutdown () Process::Shutdown ()
{ {
// Clear the out_stream // Clear the out_stream
while (!evnet_queue_empty(&out_stream_)) { while (!evcom_queue_empty(&out_stream_)) {
evnet_queue *q = evnet_queue_last(&out_stream_); evcom_queue *q = evcom_queue_last(&out_stream_);
evnet_buf *buf = (evnet_buf*) evnet_queue_data(q, evnet_buf, queue); evcom_buf *buf = (evcom_buf*) evcom_queue_data(q, evcom_buf, queue);
evnet_queue_remove(q); evcom_queue_remove(q);
if (buf->release) buf->release(buf); if (buf->release) buf->release(buf);
} }
@ -394,9 +394,9 @@ Process::OnWritable (EV_P_ ev_io *watcher, int revents)
assert(revents == EV_WRITE); assert(revents == EV_WRITE);
assert(process->stdin_pipe_[1] >= 0); assert(process->stdin_pipe_[1] >= 0);
while (!evnet_queue_empty(&process->out_stream_)) { while (!evcom_queue_empty(&process->out_stream_)) {
evnet_queue *q = evnet_queue_last(&process->out_stream_); evcom_queue *q = evcom_queue_last(&process->out_stream_);
evnet_buf *to_write = (evnet_buf*) evnet_queue_data(q, evnet_buf, queue); evcom_buf *to_write = (evcom_buf*) evcom_queue_data(q, evcom_buf, queue);
sent = write( process->stdin_pipe_[1] sent = write( process->stdin_pipe_[1]
, to_write->base + to_write->written , to_write->base + to_write->written
@ -417,12 +417,12 @@ Process::OnWritable (EV_P_ ev_io *watcher, int revents)
to_write->written += sent; to_write->written += sent;
if (to_write->written == to_write->len) { if (to_write->written == to_write->len) {
evnet_queue_remove(q); evcom_queue_remove(q);
if (to_write->release) to_write->release(to_write); if (to_write->release) to_write->release(to_write);
} }
} }
if (evnet_queue_empty(&process->out_stream_)) { if (evcom_queue_empty(&process->out_stream_)) {
ev_io_stop(EV_DEFAULT_UC_ &process->stdin_watcher_); ev_io_stop(EV_DEFAULT_UC_ &process->stdin_watcher_);
if (process->got_close_) { if (process->got_close_) {
close(process->stdin_pipe_[1]); close(process->stdin_pipe_[1]);
@ -461,10 +461,10 @@ Process::OnCHLD (EV_P_ ev_child *watcher, int revents)
} }
int int
Process::Write (evnet_buf *buf) Process::Write (evcom_buf *buf)
{ {
if (STDIN_CLOSED || got_close_ || got_chld_) return -1; if (STDIN_CLOSED || got_close_ || got_chld_) return -1;
evnet_queue_insert_head(&out_stream_, &buf->queue); evcom_queue_insert_head(&out_stream_, &buf->queue);
buf->written = 0; buf->written = 0;
ev_io_start(EV_DEFAULT_UC_ &stdin_watcher_); ev_io_start(EV_DEFAULT_UC_ &stdin_watcher_);
return 0; return 0;

6
src/process.h
View File

@ -5,7 +5,7 @@
#include "events.h" #include "events.h"
#include <v8.h> #include <v8.h>
#include <ev.h> #include <ev.h>
#include <evnet.h> #include <evcom.h>
namespace node { namespace node {
@ -26,7 +26,7 @@ class Process : EventEmitter {
~Process(); ~Process();
int Spawn (const char *command); int Spawn (const char *command);
int Write (evnet_buf *buf); int Write (evcom_buf *buf);
int Close (void); int Close (void);
int Kill (int sig); int Kill (int sig);
@ -54,7 +54,7 @@ class Process : EventEmitter {
bool got_chld_; bool got_chld_;
int exit_code_; int exit_code_;
evnet_queue out_stream_; evcom_queue out_stream_;
}; };
} // namespace node } // namespace node

22
wscript
View File

@ -112,16 +112,16 @@ def build(bld):
v8_debug.rule = v8rule % ( v8dir_src , deps_tgt , v8dir_tgt, scons, "debug") v8_debug.rule = v8rule % ( v8dir_src , deps_tgt , v8dir_tgt, scons, "debug")
v8_debug.target = join("deps/v8", bld.env["staticlib_PATTERN"] % "v8_g") v8_debug.target = join("deps/v8", bld.env["staticlib_PATTERN"] % "v8_g")
### evnet ### evcom
evnet = bld.new_task_gen("cc", "staticlib") evcom = bld.new_task_gen("cc", "staticlib")
evnet.source = "deps/evnet/evnet.c" evcom.source = "deps/evcom/evcom.c"
evnet.includes = "deps/evnet/ deps/libev/" evcom.includes = "deps/evcom/ deps/libev/"
evnet.name = "evnet" evcom.name = "evcom"
evnet.target = "evnet" evcom.target = "evcom"
# evnet.uselib = "GNUTLS" # evcom.uselib = "GNUTLS"
evnet.install_path = None evcom.install_path = None
if bld.env["USE_DEBUG"]: if bld.env["USE_DEBUG"]:
evnet.clone("debug") evcom.clone("debug")
### http_parser ### http_parser
http_parser = bld.new_task_gen("cc", "staticlib") http_parser = bld.new_task_gen("cc", "staticlib")
@ -174,10 +174,10 @@ def build(bld):
deps/v8/include deps/v8/include
deps/libev deps/libev
deps/libeio deps/libeio
deps/evnet deps/evcom
deps/http_parser deps/http_parser
""" """
node.uselib_local = "evnet ev eio http_parser" node.uselib_local = "evcom ev eio http_parser"
node.uselib = "V8 EXECINFO PROFILER EFENCE" node.uselib = "V8 EXECINFO PROFILER EFENCE"
node.install_path = '${PREFIX}/bin' node.install_path = '${PREFIX}/bin'
node.chmod = 0755 node.chmod = 0755

Write Preview
Loading…
Cancel
Save