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

Upgrade evcom 

Made API changes in evcom and had to make minor change src/net.cc to comply.
v0.7.4-release
Ryan 16 years ago
parent
ed8c43d2f3
commit
7d60998ee1
6 changed files with 489 additions and 496 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. 583
      deps/evcom/evcom.c
  2. 67
      deps/evcom/evcom.h
  3. 49
      deps/evcom/test/echo.c
  4. 204
      deps/evcom/test/test.c
  5. 46
      src/net.cc
  6. 36
      src/net.h

583
deps/evcom/evcom.c
View File

File diff suppressed because it is too large

67
deps/evcom/evcom.h
View File

@ -45,9 +45,9 @@ extern "C" {
typedef struct evcom_queue evcom_queue;
typedef struct evcom_buf evcom_buf;
typedef struct evcom_server evcom_server;
typedef struct evcom_socket evcom_socket;
typedef struct evcom_stream evcom_stream;
/* flags for socket and server */
/* flags for stream and server */
#define EVCOM_ATTACHED 0x0001
#define EVCOM_LISTENING 0x0002
#define EVCOM_CONNECTED 0x0004
@ -55,58 +55,59 @@ typedef struct evcom_socket evcom_socket;
#define EVCOM_GOT_HALF_CLOSE 0x0010
#define EVCOM_GOT_FULL_CLOSE 0x0020
#define EVCOM_TOO_MANY_CONN 0x0040
#define EVCOM_READ_PAUSED 0x0080
void evcom_server_init (evcom_server *);
int evcom_server_listen (evcom_server *, struct addrinfo *addrinfo, int backlog);
int evcom_server_listen (evcom_server *, struct sockaddr *address, int backlog);
void evcom_server_attach (EV_P_ evcom_server *);
void evcom_server_detach (evcom_server *);
void evcom_server_close (evcom_server *); // synchronous
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 *);
void evcom_stream_init (evcom_stream *, float timeout);
int evcom_stream_connect (evcom_stream *, struct sockaddr *address);
void evcom_stream_attach (EV_P_ evcom_stream *);
void evcom_stream_detach (evcom_stream *);
void evcom_stream_read_resume (evcom_stream *);
void evcom_stream_read_pause (evcom_stream *);
/* Resets the timeout to stay alive for another socket->timeout seconds
/* Resets the timeout to stay alive for another stream->timeout seconds
*/
void evcom_socket_reset_timeout (evcom_socket *);
void evcom_stream_reset_timeout (evcom_stream *);
/* Writes a buffer to the socket.
/* Writes a buffer to the stream.
*/
void evcom_socket_write (evcom_socket *, evcom_buf *);
void evcom_stream_write (evcom_stream *, evcom_buf *);
void evcom_socket_write_simple (evcom_socket *, const char *str, size_t len);
void evcom_stream_write_simple (evcom_stream *, const char *str, size_t len);
/* 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
/* Once the write buffer is drained, evcom_stream_close will shutdown the
* writing end of the stream and will close the read end once the server
* replies with an EOF.
*/
void evcom_socket_close (evcom_socket *);
void evcom_stream_close (evcom_stream *);
/* Do not wait for the server to reply with EOF. This will only be called
* once the write buffer is drained.
* Warning: For TCP socket, the OS kernel may (should) reply with RST
* Warning: For TCP stream, the OS kernel may (should) reply with RST
* packets if this is called when data is still being received from the
* server.
*/
void evcom_socket_full_close (evcom_socket *);
void evcom_stream_full_close (evcom_stream *);
/* The most extreme measure.
* Will not wait for the write queue to complete.
*/
void evcom_socket_force_close (evcom_socket *);
void evcom_stream_force_close (evcom_stream *);
#if EVCOM_HAVE_GNUTLS
/* Tells the socket to use transport layer security (SSL). evcom_socket does
/* Tells the stream to use transport layer security (SSL). evcom_stream 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 evcom_socket. That is, do not use
* layer of GnuTLS is controlled by evcom_stream. That is, do not use
* gnutls_transport_* functions. Do use the rest of GnuTLS's API.
*/
void evcom_socket_set_secure_session (evcom_socket *, gnutls_session_t);
void evcom_stream_set_secure_session (evcom_stream *, gnutls_session_t);
#endif
evcom_buf * evcom_buf_new (const char* base, size_t len);
@ -144,7 +145,7 @@ struct evcom_server {
/* PUBLIC */
evcom_socket* (*on_connection) (evcom_server *, struct sockaddr *remote_addr);
evcom_stream* (*on_connection) (evcom_server *, struct sockaddr *remote_addr);
/* Executed when a server is closed.
* If evcom_server_close() was called errorno will be 0.
@ -156,7 +157,7 @@ struct evcom_server {
void *data;
};
struct evcom_socket {
struct evcom_stream {
/* read only */
int fd;
#if EV_MULTIPLICITY
@ -167,9 +168,9 @@ struct evcom_socket {
size_t written;
unsigned flags;
/* NULL = that end of the socket is closed. */
int (*read_action) (evcom_socket *);
int (*write_action) (evcom_socket *);
/* NULL = that end of the stream is closed. */
int (*read_action) (evcom_stream *);
int (*write_action) (evcom_stream *);
/* ERROR CODES. 0 = no error. Check on_close. */
int errorno;
@ -187,11 +188,11 @@ struct evcom_socket {
/* public */
size_t chunksize; /* the maximum chunk that on_read() will return */
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 (*on_connect) (evcom_stream *);
void (*on_read) (evcom_stream *, const void *buf, size_t count);
void (*on_drain) (evcom_stream *);
void (*on_close) (evcom_stream *);
void (*on_timeout) (evcom_stream *);
void *data;
};

49
deps/evcom/test/echo.c
View File

@ -16,22 +16,22 @@
#define HOST "127.0.0.1"
#define SOCKFILE "/tmp/oi.sock"
#define PORT "5000"
#define PORT 5000
static int nconnections;
static void
on_peer_close (evcom_socket *socket)
on_peer_close (evcom_stream *stream)
{
assert(socket->errorno == 0);
assert(stream->errorno == 0);
//printf("server connection closed\n");
free(socket);
free(stream);
}
static void
on_peer_timeout (evcom_socket *socket)
on_peer_timeout (evcom_stream *stream)
{
assert(socket);
assert(stream);
fprintf(stderr, "peer connection timeout\n");
assert(0);
}
@ -42,31 +42,31 @@ on_peer_timeout (evcom_socket *socket)
#define TIMEOUT 5.0
static void
on_peer_read (evcom_socket *socket, const void *base, size_t len)
on_peer_read (evcom_stream *stream, const void *base, size_t len)
{
if(len == 0) return;
evcom_socket_write_simple(socket, base, len);
evcom_stream_write_simple(stream, base, len);
}
static evcom_socket*
static evcom_stream*
on_server_connection (evcom_server *server, struct sockaddr *addr)
{
assert(server);
assert(addr);
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;
evcom_stream *stream = malloc(sizeof(evcom_stream));
evcom_stream_init(stream, TIMEOUT);
stream->on_read = on_peer_read;
stream->on_close = on_peer_close;
stream->on_timeout = on_peer_timeout;
nconnections++;
//printf("on server connection\n");
return socket;
return stream;
}
int
@ -76,27 +76,22 @@ main (void)
evcom_server server;
//printf("sizeof(evcom_server): %d\n", sizeof(evcom_server));
//printf("sizeof(evcom_socket): %d\n", sizeof(evcom_socket));
//printf("sizeof(evcom_stream): %d\n", sizeof(evcom_stream));
evcom_server_init(&server);
server.on_connection = on_server_connection;
struct addrinfo *servinfo;
struct addrinfo hints;
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE;
r = getaddrinfo(NULL, PORT, &hints, &servinfo);
assert(r == 0);
struct sockaddr_in address;
memset(&address, 0, sizeof(struct sockaddr_in));
address.sin_family = AF_INET;
address.sin_port = htons(PORT);
address.sin_addr.s_addr = INADDR_ANY;
r = evcom_server_listen(&server, servinfo, 10);
r = evcom_server_listen(&server, (struct sockaddr*)&address, 10);
assert(r == 0);
evcom_server_attach(EV_DEFAULT_ &server);
ev_loop(EV_DEFAULT_ 0);
freeaddrinfo(servinfo);
return 0;
}

204
deps/evcom/test/test.c
View File

@ -16,18 +16,10 @@
# include <gnutls/gnutls.h>
#endif
static const struct addrinfo tcp_hints =
/* ai_flags */ { .ai_flags = 0
/* ai_family */ , .ai_family = AF_UNSPEC
/* ai_socktype */ , .ai_socktype = SOCK_STREAM
, 0
};
#define MARK_PROGRESS write(STDERR_FILENO, ".", 1)
#define HOST "127.0.0.1"
#define SOCKFILE "/tmp/oi.sock"
#define PORT "5000"
#define PORT 5000
static evcom_server server;
static int nconnections;
@ -43,28 +35,28 @@ common_on_server_close (evcom_server *server, int errorno)
}
static void
common_on_peer_close (evcom_socket *socket)
common_on_peer_close (evcom_stream *stream)
{
assert(socket->errorno == 0);
assert(stream->errorno == 0);
printf("server connection closed\n");
#if EVCOM_HAVE_GNUTLS
assert(socket->gnutls_errorno == 0);
if (use_tls) gnutls_deinit(socket->session);
assert(stream->gnutls_errorno == 0);
if (use_tls) gnutls_deinit(stream->session);
#endif
free(socket);
free(stream);
}
static void
common_on_client_timeout (evcom_socket *socket)
common_on_client_timeout (evcom_stream *stream)
{
assert(socket);
assert(stream);
printf("client connection timeout\n");
}
static void
common_on_peer_timeout (evcom_socket *socket)
common_on_peer_timeout (evcom_stream *stream)
{
assert(socket);
assert(stream);
fprintf(stderr, "peer connection timeout\n");
assert(0);
}
@ -75,10 +67,10 @@ 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 (evcom_socket *socket)
void anon_tls_server (evcom_stream *stream)
{
gnutls_session_t session;
socket->data = session;
stream->data = session;
int r = gnutls_init(&session, GNUTLS_SERVER);
assert(r == 0);
@ -87,10 +79,10 @@ void anon_tls_server (evcom_socket *socket)
gnutls_credentials_set(session, GNUTLS_CRD_ANON, server_credentials);
gnutls_dh_set_prime_bits(session, DH_BITS);
evcom_socket_set_secure_session(socket, session);
evcom_stream_set_secure_session(stream, session);
}
void anon_tls_client (evcom_socket *socket)
void anon_tls_client (evcom_stream *stream)
{
gnutls_session_t client_session;
gnutls_anon_client_credentials_t client_credentials;
@ -102,8 +94,8 @@ void anon_tls_client (evcom_socket *socket)
/* Need to enable anonymous KX specifically. */
gnutls_credentials_set(client_session, GNUTLS_CRD_ANON, client_credentials);
evcom_socket_set_secure_session(socket, client_session);
assert(socket->flags & EVCOM_SECURE);
evcom_stream_set_secure_session(stream, client_session);
assert(stream->flags & EVCOM_SECURE);
}
#endif // EVCOM_HAVE_GNUTLS
@ -120,10 +112,10 @@ void anon_tls_client (evcom_socket *socket)
static int successful_ping_count;
static void
pingpong_on_peer_read (evcom_socket *socket, const void *base, size_t len)
pingpong_on_peer_read (evcom_stream *stream, const void *base, size_t len)
{
if (len == 0) {
evcom_socket_close(socket);
evcom_stream_close(stream);
return;
}
@ -132,52 +124,52 @@ pingpong_on_peer_read (evcom_socket *socket, const void *base, size_t len)
buf[len] = 0;
printf("server got message: %s\n", buf);
evcom_socket_write_simple(socket, PONG, sizeof PONG);
evcom_stream_write_simple(stream, PONG, sizeof PONG);
}
static void
pingpong_on_client_close (evcom_socket *socket)
pingpong_on_client_close (evcom_stream *stream)
{
assert(socket);
assert(stream);
printf("client connection closed\n");
evcom_server_close(&server);
}
static evcom_socket*
static evcom_stream*
pingpong_on_server_connection (evcom_server *_server, struct sockaddr *addr)
{
assert(_server == &server);
assert(addr);
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;
evcom_stream *stream = malloc(sizeof(evcom_stream));
evcom_stream_init(stream, PINGPONG_TIMEOUT);
stream->on_read = pingpong_on_peer_read;
stream->on_close = common_on_peer_close;
stream->on_timeout = common_on_peer_timeout;
nconnections++;
#if EVCOM_HAVE_GNUTLS
if (use_tls) anon_tls_server(socket);
if (use_tls) anon_tls_server(stream);
#endif
printf("on server connection\n");
return socket;
return stream;
}
static void
pingpong_on_client_connect (evcom_socket *socket)
pingpong_on_client_connect (evcom_stream *stream)
{
printf("client connected. sending ping\n");
evcom_socket_write_simple(socket, PING, sizeof PING);
evcom_stream_write_simple(stream, PING, sizeof PING);
}
static void
pingpong_on_client_read (evcom_socket *socket, const void *base, size_t len)
pingpong_on_client_read (evcom_stream *stream, const void *base, size_t len)
{
if(len == 0) {
evcom_socket_close(socket);
evcom_stream_close(stream);
return;
}
@ -191,37 +183,37 @@ pingpong_on_client_read (evcom_socket *socket, const void *base, size_t len)
assert(strcmp(buf, PONG) == 0);
if (++successful_ping_count > EXCHANGES) {
evcom_socket_close(socket);
evcom_stream_close(stream);
return;
}
if (successful_ping_count % (EXCHANGES/20) == 0) MARK_PROGRESS;
evcom_socket_write_simple(socket, PING, sizeof PING);
evcom_stream_write_simple(stream, PING, sizeof PING);
}
int
pingpong (struct addrinfo *servinfo)
pingpong (struct sockaddr *address)
{
int r;
evcom_socket client;
evcom_stream client;
successful_ping_count = 0;
nconnections = 0;
got_server_close = 0;
printf("sizeof(evcom_server): %d\n", sizeof(evcom_server));
printf("sizeof(evcom_socket): %d\n", sizeof(evcom_socket));
printf("sizeof(evcom_stream): %d\n", sizeof(evcom_stream));
evcom_server_init(&server);
server.on_connection = pingpong_on_server_connection;
server.on_close = common_on_server_close;
r = evcom_server_listen(&server, servinfo, 10);
r = evcom_server_listen(&server, address, 10);
assert(r == 0);
evcom_server_attach(EV_DEFAULT_ &server);
evcom_socket_init(&client, PINGPONG_TIMEOUT);
evcom_stream_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;
@ -231,9 +223,9 @@ pingpong (struct addrinfo *servinfo)
if (use_tls) anon_tls_client(&client);
#endif
r = evcom_socket_connect(&client, servinfo);
r = evcom_stream_connect(&client, address);
assert(r == 0 && "problem connecting");
evcom_socket_attach(EV_DEFAULT_ &client);
evcom_stream_attach(EV_DEFAULT_ &client);
ev_loop(EV_DEFAULT_ 0);
@ -252,53 +244,53 @@ pingpong (struct addrinfo *servinfo)
#define CONNINT_TIMEOUT 1000.0
static void
connint_on_peer_read(evcom_socket *socket, const void *base, size_t len)
connint_on_peer_read(evcom_stream *stream, const void *base, size_t len)
{
assert(base);
assert(len == 0);
evcom_socket_write_simple(socket, "BYE", 3);
evcom_stream_write_simple(stream, "BYE", 3);
printf("server wrote bye\n");
}
static void
connint_on_peer_drain(evcom_socket *socket)
connint_on_peer_drain(evcom_stream *stream)
{
evcom_socket_close(socket);
evcom_stream_close(stream);
}
static evcom_socket*
static evcom_stream*
connint_on_server_connection(evcom_server *_server, struct sockaddr *addr)
{
assert(_server == &server);
assert(addr);
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;
evcom_stream *stream = malloc(sizeof(evcom_stream));
evcom_stream_init(stream, CONNINT_TIMEOUT);
stream->on_read = connint_on_peer_read;
stream->on_drain = connint_on_peer_drain;
stream->on_close = common_on_peer_close;
stream->on_timeout = common_on_peer_timeout;
#if EVCOM_HAVE_GNUTLS
if (use_tls) anon_tls_server(socket);
if (use_tls) anon_tls_server(stream);
#endif
printf("on server connection\n");
return socket;
return stream;
}
static void
connint_on_client_connect (evcom_socket *socket)
connint_on_client_connect (evcom_stream *stream)
{
printf("on client connection\n");
evcom_socket_close(socket);
evcom_stream_close(stream);
}
static void
connint_on_client_close (evcom_socket *socket)
connint_on_client_close (evcom_stream *stream)
{
evcom_socket_close(socket); // already closed, but it shouldn't crash if we try to do it again
evcom_stream_close(stream); // already closed, but it shouldn't crash if we try to do it again
printf("client connection closed\n");
@ -311,10 +303,10 @@ connint_on_client_close (evcom_socket *socket)
}
static void
connint_on_client_read (evcom_socket *socket, const void *base, size_t len)
connint_on_client_read (evcom_stream *stream, const void *base, size_t len)
{
if (len == 0) {
evcom_socket_close(socket);
evcom_stream_close(stream);
return;
}
@ -325,11 +317,11 @@ connint_on_client_read (evcom_socket *socket, const void *base, size_t len)
printf("client got message: %s\n", buf);
assert(strcmp(buf, "BYE") == 0);
evcom_socket_close(socket);
evcom_stream_close(stream);
}
int
connint (struct addrinfo *servinfo)
connint (struct sockaddr *address)
{
int r;
@ -341,14 +333,14 @@ connint (struct addrinfo *servinfo)
server.on_close = common_on_server_close;
evcom_server_listen(&server, servinfo, 1000);
evcom_server_listen(&server, address, 1000);
evcom_server_attach(EV_DEFAULT_ &server);
evcom_socket clients[NCONN];
evcom_stream clients[NCONN];
int i;
for (i = 0; i < NCONN; i++) {
evcom_socket *client = &clients[i];
evcom_socket_init(client, CONNINT_TIMEOUT);
evcom_stream *client = &clients[i];
evcom_stream_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;
@ -356,9 +348,9 @@ connint (struct addrinfo *servinfo)
#if EVCOM_HAVE_GNUTLS
if (use_tls) anon_tls_client(client);
#endif
r = evcom_socket_connect(client, servinfo);
r = evcom_stream_connect(client, address);
assert(r == 0 && "problem connecting");
evcom_socket_attach(EV_DEFAULT_ client);
evcom_stream_attach(EV_DEFAULT_ client);
}
ev_loop(EV_DEFAULT_ 0);
@ -370,52 +362,26 @@ connint (struct addrinfo *servinfo)
}
struct addrinfo *
create_tcp_address (void)
{
struct addrinfo *servinfo;
int r = getaddrinfo(NULL, PORT, &tcp_hints, &servinfo);
assert(r == 0);
return servinfo;
}
void
free_tcp_address (struct addrinfo *servinfo)
{
freeaddrinfo(servinfo);
}
struct addrinfo *
struct sockaddr *
create_unix_address (void)
{
struct addrinfo *servinfo;
struct stat tstat;
if (lstat(SOCKFILE, &tstat) == 0) {
assert(S_ISSOCK(tstat.st_mode));
unlink(SOCKFILE);
}
servinfo = malloc(sizeof(struct addrinfo));
servinfo->ai_family = AF_UNIX;
servinfo->ai_socktype = SOCK_STREAM;
servinfo->ai_protocol = 0;
struct sockaddr_un *address = calloc(1, sizeof(struct sockaddr_un));
address->sun_family = AF_UNIX;
strcpy(address->sun_path, SOCKFILE);
struct sockaddr_un *sockaddr = calloc(sizeof(struct sockaddr_un), 1);
sockaddr->sun_family = AF_UNIX;
strcpy(sockaddr->sun_path, SOCKFILE);
servinfo->ai_addr = (struct sockaddr*)sockaddr;
servinfo->ai_addrlen = sizeof(struct sockaddr_un);
return servinfo;
return (struct sockaddr*)address;
}
void
free_unix_address (struct addrinfo *servinfo)
free_unix_address (struct sockaddr *address)
{
free(servinfo->ai_addr);
free(servinfo);
free(address);
}
@ -434,21 +400,26 @@ main (void)
gnutls_anon_set_server_dh_params (server_credentials, dh_params);
#endif
struct addrinfo *tcp_address = create_tcp_address();
struct addrinfo *unix_address;
struct sockaddr_in tcp_address;
memset(&tcp_address, 0, sizeof(struct sockaddr_in));
tcp_address.sin_family = AF_INET;
tcp_address.sin_port = htons(PORT);
tcp_address.sin_addr.s_addr = INADDR_ANY;
use_tls = 0;
assert(pingpong(tcp_address) == 0);
assert(connint(tcp_address) == 0);
assert(pingpong((struct sockaddr*)&tcp_address) == 0);
assert(connint((struct sockaddr*)&tcp_address) == 0);
#if EVCOM_HAVE_GNUTLS
use_tls = 1;
assert(pingpong(tcp_address) == 0);
assert(connint(tcp_address) == 0);
assert(pingpong((struct sockaddr*)&tcp_address) == 0);
assert(connint((struct sockaddr*)&tcp_address) == 0);
#endif
struct sockaddr *unix_address;
use_tls = 0;
@ -473,6 +444,5 @@ main (void)
#endif
free_tcp_address(tcp_address);
return 0;
}

46
src/net.cc
View File

@ -99,18 +99,18 @@ Connection::Init (void)
{
opening = false;
double timeout = 60.0; // default
evcom_socket_init(&socket_, timeout);
socket_.on_connect = Connection::on_connect;
socket_.on_read = Connection::on_read;
socket_.on_drain = Connection::on_drain;
socket_.on_close = Connection::on_close;
socket_.on_timeout = Connection::on_timeout;
socket_.data = this;
evcom_stream_init(&stream_, timeout);
stream_.on_connect = Connection::on_connect;
stream_.on_read = Connection::on_read;
stream_.on_drain = Connection::on_drain;
stream_.on_close = Connection::on_close;
stream_.on_timeout = Connection::on_timeout;
stream_.data = this;
}
Connection::~Connection ()
{
assert(socket_.fd < 0 && "garbage collecting open Connection");
assert(stream_.fd < 0 && "garbage collecting open Connection");
ForceClose();
}
@ -128,19 +128,19 @@ Connection::New (const Arguments& args)
enum Connection::readyState
Connection::ReadyState (void)
{
if (socket_.flags & EVCOM_GOT_FULL_CLOSE)
if (stream_.flags & EVCOM_GOT_FULL_CLOSE)
return CLOSED;
if (socket_.flags & EVCOM_GOT_HALF_CLOSE)
return (socket_.read_action == NULL ? CLOSED : READ_ONLY);
if (stream_.flags & EVCOM_GOT_HALF_CLOSE)
return (stream_.read_action == NULL ? CLOSED : READ_ONLY);
if (socket_.read_action && socket_.write_action)
if (stream_.read_action && stream_.write_action)
return OPEN;
else if (socket_.write_action)
else if (stream_.write_action)
return WRITE_ONLY;
else if (socket_.read_action)
else if (stream_.read_action)
return READ_ONLY;
else if (opening)
@ -165,9 +165,9 @@ Connection::Connect (const Arguments& args)
connection->Init(); // in case we're reusing the socket... ?
}
assert(connection->socket_.fd < 0);
assert(connection->socket_.read_action == NULL);
assert(connection->socket_.write_action == NULL);
assert(connection->stream_.fd < 0);
assert(connection->stream_.read_action == NULL);
assert(connection->stream_.write_action == NULL);
if (args.Length() == 0)
return ThrowException(String::New("Must specify a port."));
@ -267,23 +267,23 @@ Connection::AfterResolve (eio_req *req)
connection->opening = false;
int r = 0;
if (req->result == 0) r = connection->Connect(address);
if (req->result == 0) r = connection->Connect(address->ai_addr);
if (address_list) freeaddrinfo(address_list);
// no error. return.
if (r == 0 && req->result == 0) {
evcom_socket_attach (EV_DEFAULT_UC_ &connection->socket_);
evcom_stream_attach (EV_DEFAULT_UC_ &connection->stream_);
goto out;
}
/* RESOLVE ERROR */
/* TODO: the whole resolve process should be moved into evcom_socket.
/* TODO: the whole resolve process should be moved into evcom_stream.
* The fact that I'm modifying a read-only variable here should be
* good evidence of this.
*/
connection->socket_.errorno = r | req->result;
connection->stream_.errorno = r | req->result;
connection->OnDisconnect();
@ -451,7 +451,7 @@ Connection::OnDisconnect ()
HandleScope scope;
Handle<Value> argv[1];
argv[0] = socket_.errorno == 0 ? False() : True();
argv[0] = stream_.errorno == 0 ? False() : True();
Emit("disconnect", 1, argv);
}
@ -623,7 +623,7 @@ Server::Listen (const Arguments& args)
address = AddressDefaultToIPv4(address_list);
server->Listen(address, backlog);
server->Listen(address->ai_addr, backlog);
if (address_list) freeaddrinfo(address_list);

36
src/net.h
View File

@ -42,13 +42,13 @@ protected:
}
virtual ~Connection (void);
int Connect (struct addrinfo *address) {
return evcom_socket_connect (&socket_, address);
int Connect (struct sockaddr *address) {
return evcom_stream_connect (&stream_, address);
}
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_); }
void Send (evcom_buf *buf) { evcom_stream_write(&stream_, buf); }
void Close (void) { evcom_stream_close(&stream_); }
void FullClose (void) { evcom_stream_full_close(&stream_); }
void ForceClose (void) { evcom_stream_force_close(&stream_); }
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 (evcom_socket *s) {
static void on_connect (evcom_stream *s) {
Connection *connection = static_cast<Connection*> (s->data);
connection->OnConnect();
}
static void on_read (evcom_socket *s, const void *buf, size_t len) {
static void on_read (evcom_stream *s, const void *buf, size_t len) {
Connection *connection = static_cast<Connection*> (s->data);
assert(connection->attached_);
if (len == 0)
@ -82,17 +82,17 @@ private:
connection->OnReceive(buf, len);
}
static void on_drain (evcom_socket *s) {
static void on_drain (evcom_stream *s) {
Connection *connection = static_cast<Connection*> (s->data);
connection->OnDrain();
}
static void on_close (evcom_socket *s) {
static void on_close (evcom_stream *s) {
Connection *connection = static_cast<Connection*> (s->data);
assert(connection->socket_.fd < 0);
assert(connection->socket_.read_action == NULL);
assert(connection->socket_.write_action == NULL);
assert(connection->stream_.fd < 0);
assert(connection->stream_.read_action == NULL);
assert(connection->stream_.write_action == NULL);
connection->OnDisconnect();
@ -105,7 +105,7 @@ private:
connection->Detach();
}
static void on_timeout (evcom_socket *s) {
static void on_timeout (evcom_stream *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_;
evcom_socket socket_;
evcom_stream stream_;
friend class Server;
};
@ -143,7 +143,7 @@ protected:
evcom_server_close (&server_);
}
int Listen (struct addrinfo *address, int backlog) {
int Listen (struct sockaddr *address, int backlog) {
int r = evcom_server_listen (&server_, address, backlog);
if(r != 0) return r;
evcom_server_attach (EV_DEFAULT_ &server_);
@ -160,10 +160,10 @@ protected:
private:
Connection* OnConnection (struct sockaddr *addr);
static evcom_socket* on_connection (evcom_server *s, struct sockaddr *addr) {
static evcom_stream* on_connection (evcom_server *s, struct sockaddr *addr) {
Server *server = static_cast<Server*> (s->data);
Connection *connection = server->OnConnection (addr);
return &connection->socket_;
return &connection->stream_;
}
void OnClose (int errorno);

Write Preview
Loading…
Cancel
Save