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

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

@ -1,6 +1,6 @@
/* 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
*
* Redistribution and use in source and binary forms, with or without
@ -28,54 +28,54 @@
#include <ev.h>
#include <stddef.h> /* offsetof() */
#ifndef evnet_h
#define evnet_h
#ifndef evcom_h
#define evcom_h
#ifdef __cplusplus
extern "C" {
#endif
#ifndef EVNET_HAVE_GNUTLS
# define EVNET_HAVE_GNUTLS 0
#ifndef EVCOM_HAVE_GNUTLS
# define EVCOM_HAVE_GNUTLS 0
#endif
#if EVNET_HAVE_GNUTLS
#if EVCOM_HAVE_GNUTLS
# include <gnutls/gnutls.h>
#endif
typedef struct evnet_queue evnet_queue;
typedef struct evnet_buf evnet_buf;
typedef struct evnet_server evnet_server;
typedef struct evnet_socket evnet_socket;
typedef struct evcom_queue evcom_queue;
typedef struct evcom_buf evcom_buf;
typedef struct evcom_server evcom_server;
typedef struct evcom_socket evcom_socket;
void evnet_server_init (evnet_server *);
int evnet_server_listen (evnet_server *, struct addrinfo *addrinfo, int backlog);
void evnet_server_attach (EV_P_ evnet_server *);
void evnet_server_detach (evnet_server *);
void evnet_server_close (evnet_server *); // synchronous
void evcom_server_init (evcom_server *);
int evcom_server_listen (evcom_server *, struct addrinfo *addrinfo, int backlog);
void evcom_server_attach (EV_P_ evcom_server *);
void evcom_server_detach (evcom_server *);
void evcom_server_close (evcom_server *); // synchronous
void evnet_socket_init (evnet_socket *, float timeout);
int evnet_socket_connect (evnet_socket *, struct addrinfo *addrinfo);
void evnet_socket_attach (EV_P_ evnet_socket *);
void evnet_socket_detach (evnet_socket *);
void evnet_socket_read_start (evnet_socket *);
void evnet_socket_read_stop (evnet_socket *);
void evcom_socket_init (evcom_socket *, float timeout);
int evcom_socket_connect (evcom_socket *, struct addrinfo *addrinfo);
void evcom_socket_attach (EV_P_ evcom_socket *);
void evcom_socket_detach (evcom_socket *);
void evcom_socket_read_start (evcom_socket *);
void evcom_socket_read_stop (evcom_socket *);
/* 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.
* (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
* 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
* 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
* server.
*/
void evnet_socket_full_close (evnet_socket *);
void evcom_socket_full_close (evcom_socket *);
/* The most extreme measure.
* 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
/* Tells the socket to use transport layer security (SSL). evnet_socket does
#if EVCOM_HAVE_GNUTLS
/* Tells the socket to use transport layer security (SSL). evcom_socket does
* not want to make any decisions about security requirements, so the
* 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.
*/
void evnet_socket_set_secure_session (evnet_socket *, gnutls_session_t);
void evcom_socket_set_secure_session (evcom_socket *, gnutls_session_t);
#endif
evnet_buf * evnet_buf_new (const char* base, size_t len);
evnet_buf * evnet_buf_new2 (size_t len);
void evnet_buf_destroy (evnet_buf *);
evcom_buf * evcom_buf_new (const char* base, size_t len);
evcom_buf * evcom_buf_new2 (size_t len);
void evcom_buf_destroy (evcom_buf *);
struct evnet_queue {
evnet_queue *prev;
evnet_queue *next;
struct evcom_queue {
evcom_queue *prev;
evcom_queue *next;
};
struct evnet_buf {
struct evcom_buf {
/* public */
char *base;
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;
/* private */
size_t written;
evnet_queue queue;
evcom_queue queue;
};
struct evnet_server {
struct evcom_server {
/* read only */
int fd;
#if EV_MULTIPLICITY
@ -137,26 +137,26 @@ struct evnet_server {
/* 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.
* 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
* 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;
};
struct evnet_socket {
struct evcom_socket {
/* read only */
int fd;
#if EV_MULTIPLICITY
struct ev_loop *loop;
#endif
evnet_server *server;
evnet_queue out_stream;
evcom_server *server;
evcom_queue out_stream;
size_t written;
unsigned attached:1;
unsigned connected:1;
@ -165,12 +165,12 @@ struct evnet_socket {
unsigned got_half_close:1;
/* NULL = that end of the socket is closed. */
int (*read_action) (evnet_socket *);
int (*write_action) (evnet_socket *);
int (*read_action) (evcom_socket *);
int (*write_action) (evcom_socket *);
/* ERROR CODES. 0 = no error. Check on_close. */
int errorno;
#if EVNET_HAVE_GNUTLS
#if EVCOM_HAVE_GNUTLS
int gnutls_errorno;
#endif
@ -178,29 +178,29 @@ struct evnet_socket {
ev_io write_watcher;
ev_io read_watcher;
ev_timer timeout_watcher;
#if EVNET_HAVE_GNUTLS
#if EVCOM_HAVE_GNUTLS
gnutls_session_t session;
#endif
/* public */
size_t chunksize; /* the maximum chunk that on_read() will return */
void (*on_connect) (evnet_socket *);
void (*on_read) (evnet_socket *, const void *buf, size_t count);
void (*on_drain) (evnet_socket *);
void (*on_close) (evnet_socket *);
void (*on_timeout) (evnet_socket *);
void (*on_connect) (evcom_socket *);
void (*on_read) (evcom_socket *, const void *buf, size_t count);
void (*on_drain) (evcom_socket *);
void (*on_close) (evcom_socket *);
void (*on_timeout) (evcom_socket *);
void *data;
};
EV_INLINE void
evnet_queue_init (evnet_queue *q)
evcom_queue_init (evcom_queue *q)
{
q->prev = q;
q->next = q;
}
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->prev = x;
@ -209,7 +209,7 @@ evnet_queue_insert_head (evnet_queue *h, evnet_queue *x)
}
EV_INLINE void
evnet_queue_remove (evnet_queue *x)
evcom_queue_remove (evcom_queue *x)
{
(x)->next->prev = (x)->prev;
(x)->prev->next = (x)->next;
@ -219,14 +219,14 @@ evnet_queue_remove (evnet_queue *x)
#endif
}
#define evnet_queue_empty(h) (h == (h)->prev)
#define evnet_queue_head(h) (h)->next
#define evnet_queue_last(h) (h)->prev
#define evnet_queue_data(q, type, link) \
#define evcom_queue_empty(h) (h == (h)->prev)
#define evcom_queue_head(h) (h)->next
#define evcom_queue_last(h) (h)->prev
#define evcom_queue_data(q, type, link) \
(type *) ((unsigned char *) q - offsetof(type, link))
#ifdef __cplusplus
}
#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 <evnet.h>
#include <evcom.h>
#include <gnutls/gnutls.h>
#define HOST "127.0.0.1"
@ -21,7 +21,7 @@
static int nconnections;
static void
on_peer_close (evnet_socket *socket)
on_peer_close (evcom_socket *socket)
{
assert(socket->errorno == 0);
//printf("server connection closed\n");
@ -29,7 +29,7 @@ on_peer_close (evnet_socket *socket)
}
static void
on_peer_timeout (evnet_socket *socket)
on_peer_timeout (evcom_socket *socket)
{
assert(socket);
fprintf(stderr, "peer connection timeout\n");
@ -42,21 +42,21 @@ on_peer_timeout (evnet_socket *socket)
#define TIMEOUT 5.0
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;
evnet_socket_write_simple(socket, base, len);
evcom_socket_write_simple(socket, base, len);
}
static evnet_socket*
on_server_connection (evnet_server *server, struct sockaddr *addr)
static evcom_socket*
on_server_connection (evcom_server *server, struct sockaddr *addr)
{
assert(server);
assert(addr);
evnet_socket *socket = malloc(sizeof(evnet_socket));
evnet_socket_init(socket, TIMEOUT);
evcom_socket *socket = malloc(sizeof(evcom_socket));
evcom_socket_init(socket, TIMEOUT);
socket->on_read = on_peer_read;
socket->on_close = on_peer_close;
socket->on_timeout = on_peer_timeout;
@ -73,12 +73,12 @@ int
main (void)
{
int r;
evnet_server server;
evcom_server server;
//printf("sizeof(evnet_server): %d\n", sizeof(evnet_server));
//printf("sizeof(evnet_socket): %d\n", sizeof(evnet_socket));
//printf("sizeof(evcom_server): %d\n", sizeof(evcom_server));
//printf("sizeof(evcom_socket): %d\n", sizeof(evcom_socket));
evnet_server_init(&server);
evcom_server_init(&server);
server.on_connection = on_server_connection;
struct addrinfo *servinfo;
@ -90,9 +90,9 @@ main (void)
r = getaddrinfo(NULL, PORT, &hints, &servinfo);
assert(r == 0);
r = evnet_server_listen(&server, servinfo, 10);
r = evcom_server_listen(&server, servinfo, 10);
assert(r == 0);
evnet_server_attach(EV_DEFAULT_ &server);
evcom_server_attach(EV_DEFAULT_ &server);
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 <ev.h>
#include <evnet.h>
#include <evcom.h>
#if EVNET_HAVE_GNUTLS
#if EVCOM_HAVE_GNUTLS
# include <gnutls/gnutls.h>
#endif
@ -29,13 +29,13 @@ static const struct addrinfo tcp_hints =
#define SOCKFILE "/tmp/oi.sock"
#define PORT "5000"
static evnet_server server;
static evcom_server server;
static int nconnections;
static int use_tls;
static int got_server_close;
static void
common_on_server_close (evnet_server *server, int errorno)
common_on_server_close (evcom_server *server, int errorno)
{
assert(server);
assert(errorno == 0);
@ -43,11 +43,11 @@ common_on_server_close (evnet_server *server, int errorno)
}
static void
common_on_peer_close (evnet_socket *socket)
common_on_peer_close (evcom_socket *socket)
{
assert(socket->errorno == 0);
printf("server connection closed\n");
#if EVNET_HAVE_GNUTLS
#if EVCOM_HAVE_GNUTLS
assert(socket->gnutls_errorno == 0);
if (use_tls) gnutls_deinit(socket->session);
#endif
@ -55,27 +55,27 @@ common_on_peer_close (evnet_socket *socket)
}
static void
common_on_client_timeout (evnet_socket *socket)
common_on_client_timeout (evcom_socket *socket)
{
assert(socket);
printf("client connection timeout\n");
}
static void
common_on_peer_timeout (evnet_socket *socket)
common_on_peer_timeout (evcom_socket *socket)
{
assert(socket);
fprintf(stderr, "peer connection timeout\n");
assert(0);
}
#if EVNET_HAVE_GNUTLS
#if EVCOM_HAVE_GNUTLS
#define DH_BITS 768
static gnutls_anon_server_credentials_t server_credentials;
const int kx_prio[] = { GNUTLS_KX_ANON_DH, 0 };
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;
socket->data = session;
@ -87,10 +87,10 @@ void anon_tls_server (evnet_socket *socket)
gnutls_credentials_set(session, GNUTLS_CRD_ANON, server_credentials);
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_anon_client_credentials_t client_credentials;
@ -102,11 +102,11 @@ void anon_tls_client (evnet_socket *socket)
/* Need to enable anonymous KX specifically. */
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);
}
#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 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) {
evnet_socket_close(socket);
evcom_socket_close(socket);
return;
}
@ -132,32 +132,32 @@ pingpong_on_peer_read (evnet_socket *socket, const void *base, size_t len)
buf[len] = 0;
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
pingpong_on_client_close (evnet_socket *socket)
pingpong_on_client_close (evcom_socket *socket)
{
assert(socket);
printf("client connection closed\n");
evnet_server_close(&server);
evcom_server_close(&server);
}
static evnet_socket*
pingpong_on_server_connection (evnet_server *_server, struct sockaddr *addr)
static evcom_socket*
pingpong_on_server_connection (evcom_server *_server, struct sockaddr *addr)
{
assert(_server == &server);
assert(addr);
evnet_socket *socket = malloc(sizeof(evnet_socket));
evnet_socket_init(socket, PINGPONG_TIMEOUT);
evcom_socket *socket = malloc(sizeof(evcom_socket));
evcom_socket_init(socket, PINGPONG_TIMEOUT);
socket->on_read = pingpong_on_peer_read;
socket->on_close = common_on_peer_close;
socket->on_timeout = common_on_peer_timeout;
nconnections++;
#if EVNET_HAVE_GNUTLS
#if EVCOM_HAVE_GNUTLS
if (use_tls) anon_tls_server(socket);
#endif
@ -167,17 +167,17 @@ pingpong_on_server_connection (evnet_server *_server, struct sockaddr *addr)
}
static void
pingpong_on_client_connect (evnet_socket *socket)
pingpong_on_client_connect (evcom_socket *socket)
{
printf("client connected. sending ping\n");
evnet_socket_write_simple(socket, PING, sizeof PING);
evcom_socket_write_simple(socket, PING, sizeof PING);
}
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) {
evnet_socket_close(socket);
evcom_socket_close(socket);
return;
}
@ -191,49 +191,49 @@ pingpong_on_client_read (evnet_socket *socket, const void *base, size_t len)
assert(strcmp(buf, PONG) == 0);
if (++successful_ping_count > EXCHANGES) {
evnet_socket_close(socket);
evcom_socket_close(socket);
return;
}
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
pingpong (struct addrinfo *servinfo)
{
int r;
evnet_socket client;
evcom_socket client;
successful_ping_count = 0;
nconnections = 0;
got_server_close = 0;
printf("sizeof(evnet_server): %d\n", sizeof(evnet_server));
printf("sizeof(evnet_socket): %d\n", sizeof(evnet_socket));
printf("sizeof(evcom_server): %d\n", sizeof(evcom_server));
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_close = common_on_server_close;
r = evnet_server_listen(&server, servinfo, 10);
r = evcom_server_listen(&server, servinfo, 10);
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_connect = pingpong_on_client_connect;
client.on_close = pingpong_on_client_close;
client.on_timeout = common_on_client_timeout;
#if EVNET_HAVE_GNUTLS
#if EVCOM_HAVE_GNUTLS
if (use_tls) anon_tls_client(&client);
#endif
r = evnet_socket_connect(&client, servinfo);
r = evcom_socket_connect(&client, servinfo);
assert(r == 0 && "problem connecting");
evnet_socket_attach(EV_DEFAULT_ &client);
evcom_socket_attach(EV_DEFAULT_ &client);
ev_loop(EV_DEFAULT_ 0);
@ -252,34 +252,34 @@ pingpong (struct addrinfo *servinfo)
#define CONNINT_TIMEOUT 1000.0
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(len == 0);
evnet_socket_write_simple(socket, "BYE", 3);
evcom_socket_write_simple(socket, "BYE", 3);
printf("server wrote bye\n");
}
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*
connint_on_server_connection(evnet_server *_server, struct sockaddr *addr)
static evcom_socket*
connint_on_server_connection(evcom_server *_server, struct sockaddr *addr)
{
assert(_server == &server);
assert(addr);
evnet_socket *socket = malloc(sizeof(evnet_socket));
evnet_socket_init(socket, CONNINT_TIMEOUT);
evcom_socket *socket = malloc(sizeof(evcom_socket));
evcom_socket_init(socket, CONNINT_TIMEOUT);
socket->on_read = connint_on_peer_read;
socket->on_drain = connint_on_peer_drain;
socket->on_close = common_on_peer_close;
socket->on_timeout = common_on_peer_timeout;
#if EVNET_HAVE_GNUTLS
#if EVCOM_HAVE_GNUTLS
if (use_tls) anon_tls_server(socket);
#endif
@ -289,32 +289,32 @@ connint_on_server_connection(evnet_server *_server, struct sockaddr *addr)
}
static void
connint_on_client_connect (evnet_socket *socket)
connint_on_client_connect (evcom_socket *socket)
{
printf("on client connection\n");
evnet_socket_close(socket);
evcom_socket_close(socket);
}
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");
if (nconnections % (NCONN/20) == 0) MARK_PROGRESS;
if(++nconnections == NCONN) {
evnet_server_close(&server);
evcom_server_close(&server);
printf("closing server\n");
}
}
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) {
evnet_socket_close(socket);
evcom_socket_close(socket);
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);
assert(strcmp(buf, "BYE") == 0);
evnet_socket_close(socket);
evcom_socket_close(socket);
}
int
@ -336,29 +336,29 @@ connint (struct addrinfo *servinfo)
nconnections = 0;
got_server_close = 0;
evnet_server_init(&server);
evcom_server_init(&server);
server.on_connection = connint_on_server_connection;
server.on_close = common_on_server_close;
evnet_server_listen(&server, servinfo, 1000);
evnet_server_attach(EV_DEFAULT_ &server);
evcom_server_listen(&server, servinfo, 1000);
evcom_server_attach(EV_DEFAULT_ &server);
evnet_socket clients[NCONN];
evcom_socket clients[NCONN];
int i;
for (i = 0; i < NCONN; i++) {
evnet_socket *client = &clients[i];
evnet_socket_init(client, CONNINT_TIMEOUT);
evcom_socket *client = &clients[i];
evcom_socket_init(client, CONNINT_TIMEOUT);
client->on_read = connint_on_client_read;
client->on_connect = connint_on_client_connect;
client->on_close = connint_on_client_close;
client->on_timeout = common_on_client_timeout;
#if EVNET_HAVE_GNUTLS
#if EVCOM_HAVE_GNUTLS
if (use_tls) anon_tls_client(client);
#endif
r = evnet_socket_connect(client, servinfo);
r = evcom_socket_connect(client, servinfo);
assert(r == 0 && "problem connecting");
evnet_socket_attach(EV_DEFAULT_ client);
evcom_socket_attach(EV_DEFAULT_ client);
}
ev_loop(EV_DEFAULT_ 0);
@ -422,7 +422,7 @@ free_unix_address (struct addrinfo *servinfo)
int
main (void)
{
#if EVNET_HAVE_GNUTLS
#if EVCOM_HAVE_GNUTLS
gnutls_global_init();
gnutls_dh_params_init (&dh_params);
@ -442,7 +442,7 @@ main (void)
assert(pingpong(tcp_address) == 0);
assert(connint(tcp_address) == 0);
#if EVNET_HAVE_GNUTLS
#if EVCOM_HAVE_GNUTLS
use_tls = 1;
assert(pingpong(tcp_address) == 0);
assert(connint(tcp_address) == 0);
@ -460,7 +460,7 @@ main (void)
assert(connint(unix_address) == 0);
free_unix_address(unix_address);
#if EVNET_HAVE_GNUTLS
#if EVCOM_HAVE_GNUTLS
use_tls = 1;
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;
double timeout = 60.0; // default
evnet_socket_init(&socket_, timeout);
evcom_socket_init(&socket_, timeout);
socket_.on_connect = Connection::on_connect;
socket_.on_read = Connection::on_read;
socket_.on_drain = Connection::on_drain;
@ -275,13 +275,13 @@ Connection::AfterResolve (eio_req *req)
// no error. return.
if (r == 0 && req->result == 0) {
evnet_socket_attach (EV_DEFAULT_UC_ &connection->socket_);
evcom_socket_attach (EV_DEFAULT_UC_ &connection->socket_);
goto out;
}
/* 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
* good evidence of this.
*/
@ -376,7 +376,7 @@ Connection::Send (const Arguments& args)
// XXX
// 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
// 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
@ -386,7 +386,7 @@ Connection::Send (const Arguments& args)
enum encoding enc = ParseEncoding(args[1]);
Local<String> s = args[0]->ToString();
size_t len = s->Utf8Length();
evnet_buf *buf = node::buf_new(len);
evcom_buf *buf = node::buf_new(len);
switch (enc) {
case RAW:
case ASCII:
@ -405,7 +405,7 @@ Connection::Send (const Arguments& args)
} else if (args[0]->IsArray()) {
Handle<Array> array = Handle<Array>::Cast(args[0]);
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++) {
Local<Value> int_value = array->Get(Integer::New(i));
buf->base[i] = int_value->IntegerValue();

40
src/net.h
View File

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

12
src/node.cc
View File

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

4
src/node.h
View File

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

28
src/process.cc
View File

@ -100,13 +100,13 @@ Process::Write (const Arguments& args)
// XXX
// 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
// 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
// addressed.
evnet_buf *buf;
evcom_buf *buf;
size_t len;
if (args[0]->IsString()) {
@ -196,7 +196,7 @@ Process::Process ()
pid_ = 0;
evnet_queue_init(&out_stream_);
evcom_queue_init(&out_stream_);
}
Process::~Process ()
@ -208,10 +208,10 @@ void
Process::Shutdown ()
{
// Clear the out_stream
while (!evnet_queue_empty(&out_stream_)) {
evnet_queue *q = evnet_queue_last(&out_stream_);
evnet_buf *buf = (evnet_buf*) evnet_queue_data(q, evnet_buf, queue);
evnet_queue_remove(q);
while (!evcom_queue_empty(&out_stream_)) {
evcom_queue *q = evcom_queue_last(&out_stream_);
evcom_buf *buf = (evcom_buf*) evcom_queue_data(q, evcom_buf, queue);
evcom_queue_remove(q);
if (buf->release) buf->release(buf);
}
@ -394,9 +394,9 @@ Process::OnWritable (EV_P_ ev_io *watcher, int revents)
assert(revents == EV_WRITE);
assert(process->stdin_pipe_[1] >= 0);
while (!evnet_queue_empty(&process->out_stream_)) {
evnet_queue *q = evnet_queue_last(&process->out_stream_);
evnet_buf *to_write = (evnet_buf*) evnet_queue_data(q, evnet_buf, queue);
while (!evcom_queue_empty(&process->out_stream_)) {
evcom_queue *q = evcom_queue_last(&process->out_stream_);
evcom_buf *to_write = (evcom_buf*) evcom_queue_data(q, evcom_buf, queue);
sent = write( process->stdin_pipe_[1]
, to_write->base + to_write->written
@ -417,12 +417,12 @@ Process::OnWritable (EV_P_ ev_io *watcher, int revents)
to_write->written += sent;
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 (evnet_queue_empty(&process->out_stream_)) {
if (evcom_queue_empty(&process->out_stream_)) {
ev_io_stop(EV_DEFAULT_UC_ &process->stdin_watcher_);
if (process->got_close_) {
close(process->stdin_pipe_[1]);
@ -461,10 +461,10 @@ Process::OnCHLD (EV_P_ ev_child *watcher, int revents)
}
int
Process::Write (evnet_buf *buf)
Process::Write (evcom_buf *buf)
{
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;
ev_io_start(EV_DEFAULT_UC_ &stdin_watcher_);
return 0;

6
src/process.h
View File

@ -5,7 +5,7 @@
#include "events.h"
#include <v8.h>
#include <ev.h>
#include <evnet.h>
#include <evcom.h>
namespace node {
@ -26,7 +26,7 @@ class Process : EventEmitter {
~Process();
int Spawn (const char *command);
int Write (evnet_buf *buf);
int Write (evcom_buf *buf);
int Close (void);
int Kill (int sig);
@ -54,7 +54,7 @@ class Process : EventEmitter {
bool got_chld_;
int exit_code_;
evnet_queue out_stream_;
evcom_queue out_stream_;
};
} // 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.target = join("deps/v8", bld.env["staticlib_PATTERN"] % "v8_g")
### evnet
evnet = bld.new_task_gen("cc", "staticlib")
evnet.source = "deps/evnet/evnet.c"
evnet.includes = "deps/evnet/ deps/libev/"
evnet.name = "evnet"
evnet.target = "evnet"
# evnet.uselib = "GNUTLS"
evnet.install_path = None
### evcom
evcom = bld.new_task_gen("cc", "staticlib")
evcom.source = "deps/evcom/evcom.c"
evcom.includes = "deps/evcom/ deps/libev/"
evcom.name = "evcom"
evcom.target = "evcom"
# evcom.uselib = "GNUTLS"
evcom.install_path = None
if bld.env["USE_DEBUG"]:
evnet.clone("debug")
evcom.clone("debug")
### http_parser
http_parser = bld.new_task_gen("cc", "staticlib")
@ -174,10 +174,10 @@ def build(bld):
deps/v8/include
deps/libev
deps/libeio
deps/evnet
deps/evcom
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.install_path = '${PREFIX}/bin'
node.chmod = 0755

Write Preview
Loading…
Cancel
Save