mirror of https://github.com/lukechilds/node.git
Ryan Dahl
15 years ago
19 changed files with 8 additions and 5703 deletions
@ -1,75 +0,0 @@ |
|||||
# Define EVDIR=/foo/bar if your libev header and library files are in
|
|
||||
# /foo/bar/include and /foo/bar/lib directories.
|
|
||||
EVDIR=$(HOME)/local/libev |
|
||||
|
|
||||
# Define GNUTLSDIR=/foo/bar if your gnutls header and library files are in
|
|
||||
# /foo/bar/include and /foo/bar/lib directories.
|
|
||||
#
|
|
||||
# Comment out the following line to disable TLS
|
|
||||
GNUTLSDIR=/usr |
|
||||
|
|
||||
# CFLAGS and LDFLAGS are for the users to override from the command line.
|
|
||||
CFLAGS = -g -I. -Wall -Werror -Wextra #-DNDEBUG=1 |
|
||||
LDFLAGS = |
|
||||
|
|
||||
CC = gcc |
|
||||
AR = ar |
|
||||
RANLIB = ranlib |
|
||||
|
|
||||
ifdef EVDIR |
|
||||
CFLAGS += -I$(EVDIR)/include |
|
||||
LDFLAGS += -L$(EVDIR)/lib |
|
||||
endif |
|
||||
|
|
||||
LDFLAGS += -lev |
|
||||
|
|
||||
ifdef GNUTLSDIR |
|
||||
CFLAGS += -I$(GNUTLSDIR)/include -DEVCOM_HAVE_GNUTLS=1 |
|
||||
LDFLAGS += -L$(GNUTLSDIR)/lib |
|
||||
LDFLAGS += -lgnutls |
|
||||
endif |
|
||||
|
|
||||
DEP = evcom.h |
|
||||
SRC = evcom.c |
|
||||
OBJ = ${SRC:.c=.o} |
|
||||
|
|
||||
NAME=libevcom |
|
||||
OUTPUT_A=$(NAME).a |
|
||||
|
|
||||
all: $(OUTPUT_A) test/test test/echo |
|
||||
|
|
||||
$(OUTPUT_A): $(OBJ) |
|
||||
$(AR) cru $(OUTPUT_A) $(OBJ) |
|
||||
$(RANLIB) $(OUTPUT_A) |
|
||||
|
|
||||
.c.o: |
|
||||
$(CC) -c ${CFLAGS} $< |
|
||||
|
|
||||
${OBJ}: ${DEP} |
|
||||
|
|
||||
FAIL=ruby -e 'puts "\033[1;31m FAIL\033[m"' |
|
||||
PASS=ruby -e 'puts "\033[1;32m PASS\033[m"' |
|
||||
|
|
||||
test: test/test test/echo test/timeout.rb |
|
||||
@echo test.c |
|
||||
@test/test > /dev/null && $(PASS) || $(FAIL) |
|
||||
@echo timeout.rb |
|
||||
@test/timeout.rb |
|
||||
|
|
||||
test/test: test/test.c $(OUTPUT_A) |
|
||||
$(CC) $(LDFLAGS) $(CFLAGS) -o $@ test/test.c $(OUTPUT_A) |
|
||||
|
|
||||
test/echo: test/echo.c $(OUTPUT_A) |
|
||||
$(CC) $(LDFLAGS) $(CFLAGS) -o $@ test/echo.c $(OUTPUT_A) |
|
||||
|
|
||||
send_states.png: send_states.dot |
|
||||
dot -Tpng -o send_states.png send_states.dot |
|
||||
|
|
||||
recv_states.png: recv_states.dot |
|
||||
dot -Tpng -o recv_states.png recv_states.dot |
|
||||
|
|
||||
clean: |
|
||||
rm -rf test/test test/echo |
|
||||
rm -f $(OUTPUT_A) *.o |
|
||||
|
|
||||
.PHONY: all clean test |
|
||||
File diff suppressed because it is too large
@ -1,260 +0,0 @@ |
|||||
/* Copyright (c) 2008,2009 Ryan Dahl
|
|
||||
* |
|
||||
* 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 |
|
||||
* modification, are permitted provided that the following conditions |
|
||||
* are met: |
|
||||
* 1. Redistributions of source code must retain the above copyright |
|
||||
* notice, this list of conditions and the following disclaimer. |
|
||||
* 2. Redistributions in binary form must reproduce the above copyright |
|
||||
* notice, this list of conditions and the following disclaimer in the |
|
||||
* documentation and/or other materials provided with the distribution. |
|
||||
* |
|
||||
* THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND |
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE |
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|
||||
* SUCH DAMAGE. |
|
||||
*/ |
|
||||
#include <netdb.h> |
|
||||
#include <ev.h> |
|
||||
#include <stddef.h> /* offsetof() */ |
|
||||
|
|
||||
#ifndef evcom_h |
|
||||
#define evcom_h |
|
||||
|
|
||||
#ifdef __cplusplus |
|
||||
extern "C" { |
|
||||
#endif |
|
||||
|
|
||||
#ifndef EVCOM_HAVE_GNUTLS |
|
||||
# define EVCOM_HAVE_GNUTLS 0 |
|
||||
#endif |
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
# include <gnutls/gnutls.h> |
|
||||
#endif |
|
||||
|
|
||||
/* The maximum evcom_stream will try to read in one callback */ |
|
||||
#ifndef EVCOM_CHUNKSIZE |
|
||||
# define EVCOM_CHUNKSIZE (8*1024) |
|
||||
#endif |
|
||||
|
|
||||
/* flags for stream and server */ |
|
||||
#define EVCOM_ATTACHED 0x0001 |
|
||||
#define EVCOM_LISTENING 0x0002 |
|
||||
#define EVCOM_CONNECTED 0x0004 |
|
||||
#define EVCOM_SECURE 0x0008 |
|
||||
#define EVCOM_DUPLEX 0x0010 |
|
||||
#define EVCOM_GOT_CLOSE 0x0020 |
|
||||
#define EVCOM_PAUSED 0x0040 |
|
||||
#define EVCOM_READABLE 0x0080 |
|
||||
#define EVCOM_WRITABLE 0x0100 |
|
||||
#define EVCOM_TOO_MANY_CONN 0x0200 |
|
||||
|
|
||||
enum evcom_stream_state { EVCOM_INITIALIZED |
|
||||
, EVCOM_CONNECTING |
|
||||
, EVCOM_CONNECTED_RW /* read write */ |
|
||||
, EVCOM_CONNECTED_RO /* read only */ |
|
||||
, EVCOM_CONNECTED_WO /* write only */ |
|
||||
, EVCOM_CLOSING |
|
||||
, EVCOM_CLOSED |
|
||||
}; |
|
||||
|
|
||||
typedef struct evcom_queue { |
|
||||
struct evcom_queue *prev; |
|
||||
struct evcom_queue *next; |
|
||||
} evcom_queue; |
|
||||
|
|
||||
typedef struct evcom_buf { |
|
||||
/* public */ |
|
||||
char *base; |
|
||||
size_t len; |
|
||||
void (*release) (struct evcom_buf *); /* called when oi is done with the object */ |
|
||||
void *data; |
|
||||
|
|
||||
/* private */ |
|
||||
size_t written; |
|
||||
evcom_queue queue; |
|
||||
} evcom_buf; |
|
||||
|
|
||||
#if EV_MULTIPLICITY |
|
||||
# define EVCOM_LOOP struct ev_loop *loop; |
|
||||
#else |
|
||||
# define EVCOM_LOOP |
|
||||
#endif |
|
||||
|
|
||||
#define EVCOM_DESCRIPTOR(type) \ |
|
||||
/* private */ unsigned int flags; \ |
|
||||
/* private */ int (*action) (struct evcom_descriptor*); \ |
|
||||
/* read-only */ int errorno; \ |
|
||||
/* read-only */ int fd; \ |
|
||||
/* read-only */ EVCOM_LOOP \ |
|
||||
/* public */ void *data; \ |
|
||||
/* public */ void (*on_close) (struct type*); |
|
||||
|
|
||||
/* abstract base class */ |
|
||||
typedef struct evcom_descriptor { |
|
||||
EVCOM_DESCRIPTOR(evcom_descriptor) |
|
||||
} evcom_descriptor; |
|
||||
|
|
||||
typedef struct evcom_reader { |
|
||||
EVCOM_DESCRIPTOR(evcom_reader) |
|
||||
ev_io read_watcher; /* private */ |
|
||||
void (*on_read) (struct evcom_reader*, const void* buf, size_t len); /* public */ |
|
||||
} evcom_reader; |
|
||||
|
|
||||
typedef struct evcom_writer { |
|
||||
EVCOM_DESCRIPTOR(evcom_writer) |
|
||||
ev_io write_watcher; /* private */ |
|
||||
evcom_queue out; /* private */ |
|
||||
} evcom_writer; |
|
||||
|
|
||||
typedef struct evcom_stream { |
|
||||
/* PRIVATE */ |
|
||||
EVCOM_LOOP |
|
||||
int errorno; |
|
||||
unsigned int flags; |
|
||||
evcom_queue out; |
|
||||
ev_io read_watcher; |
|
||||
ev_io write_watcher; |
|
||||
int (*send_action) (struct evcom_stream*); |
|
||||
int (*recv_action) (struct evcom_stream*); |
|
||||
ev_timer timeout_watcher; |
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
gnutls_session_t session; |
|
||||
#endif |
|
||||
|
|
||||
/* READ-ONLY */ |
|
||||
int recvfd; |
|
||||
int sendfd; |
|
||||
struct evcom_server *server; |
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
int gnutls_errorno; |
|
||||
#endif |
|
||||
|
|
||||
/* PUBLIC */ |
|
||||
void (*on_connect) (struct evcom_stream *); |
|
||||
void (*on_timeout) (struct evcom_stream *); |
|
||||
void (*on_read) (struct evcom_stream *, const void* buf, size_t len); |
|
||||
void (*on_drain) (struct evcom_stream *); |
|
||||
void (*on_close) (struct evcom_stream *); |
|
||||
void *data; |
|
||||
} evcom_stream; |
|
||||
|
|
||||
typedef struct evcom_server { |
|
||||
EVCOM_DESCRIPTOR(evcom_server) |
|
||||
|
|
||||
/* PRIVATE */ |
|
||||
ev_io watcher; |
|
||||
|
|
||||
/* PUBLIC */ |
|
||||
struct evcom_stream* |
|
||||
(*on_connection)(struct evcom_server *, struct sockaddr *remote_addr); |
|
||||
} evcom_server; |
|
||||
|
|
||||
/* Highly recommended to ignore SIGPIPE! */ |
|
||||
void evcom_ignore_sigpipe (void); |
|
||||
|
|
||||
void evcom_reader_init (evcom_reader*); |
|
||||
void evcom_reader_set (evcom_reader*, int fd); |
|
||||
void evcom_reader_attach (EV_P_ evcom_reader*); |
|
||||
void evcom_reader_detach (evcom_reader*); |
|
||||
void evcom_reader_close (evcom_reader*); |
|
||||
|
|
||||
void evcom_writer_init (evcom_writer*); |
|
||||
void evcom_writer_set (evcom_writer*, int fd); |
|
||||
void evcom_writer_attach (EV_P_ evcom_writer*); |
|
||||
void evcom_writer_detach (evcom_writer*); |
|
||||
void evcom_writer_write (evcom_writer*, const char *str, size_t len); |
|
||||
void evcom_writer_close (evcom_writer*); |
|
||||
|
|
||||
void evcom_server_init (evcom_server *); |
|
||||
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 *); |
|
||||
|
|
||||
void evcom_stream_init (evcom_stream *); |
|
||||
|
|
||||
int evcom_stream_pair (evcom_stream *a, evcom_stream *b); |
|
||||
int evcom_stream_connect (evcom_stream *, struct sockaddr *address); |
|
||||
void evcom_stream_assign_fds (evcom_stream *, int recvfd, int sendfd); |
|
||||
|
|
||||
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 *); |
|
||||
void evcom_stream_reset_timeout (evcom_stream *, float timeout); |
|
||||
void evcom_stream_set_no_delay (evcom_stream *, int no_delay); |
|
||||
ssize_t evcom_stream_write (evcom_stream *, const char *str, size_t len); |
|
||||
/* 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_stream_close (evcom_stream *); |
|
||||
|
|
||||
/* Will not wait for the write queue to complete. Closes both directions */ |
|
||||
void evcom_stream_force_close (evcom_stream *); |
|
||||
|
|
||||
|
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
/* 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_stream. That is, do not use |
|
||||
* gnutls_transport_* functions. Do use the rest of GnuTLS's API. |
|
||||
*/ |
|
||||
void evcom_stream_set_secure_session (evcom_stream *, gnutls_session_t); |
|
||||
#endif |
|
||||
|
|
||||
enum evcom_stream_state evcom_stream_state (evcom_stream *stream); |
|
||||
|
|
||||
evcom_buf* evcom_buf_new (const char* base, size_t len); |
|
||||
evcom_buf* evcom_buf_new2 (size_t len); |
|
||||
|
|
||||
EV_INLINE void |
|
||||
evcom_queue_init (evcom_queue *q) |
|
||||
{ |
|
||||
q->prev = q; |
|
||||
q->next = q; |
|
||||
} |
|
||||
|
|
||||
EV_INLINE void |
|
||||
evcom_queue_insert_head (evcom_queue *h, evcom_queue *x) |
|
||||
{ |
|
||||
(x)->next = (h)->next; |
|
||||
(x)->next->prev = x; |
|
||||
(x)->prev = h; |
|
||||
(h)->next = x; |
|
||||
} |
|
||||
|
|
||||
EV_INLINE void |
|
||||
evcom_queue_remove (evcom_queue *x) |
|
||||
{ |
|
||||
(x)->next->prev = (x)->prev; |
|
||||
(x)->prev->next = (x)->next; |
|
||||
#ifndef NDEBUG |
|
||||
(x)->prev = NULL; |
|
||||
(x)->next = NULL; |
|
||||
#endif |
|
||||
} |
|
||||
|
|
||||
#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 /* evcom_h */ |
|
||||
@ -1,37 +0,0 @@ |
|||||
strict digraph recv_states { |
|
||||
start [peripheries=2]; |
|
||||
end [peripheries=2]; |
|
||||
handshake; |
|
||||
recv_data; |
|
||||
wait_for_resume; |
|
||||
wait_for_close; |
|
||||
close_one; |
|
||||
close_both; |
|
||||
|
|
||||
node [label="", shape="box", height=0.1, width=0.1]; |
|
||||
close; |
|
||||
|
|
||||
|
|
||||
|
|
||||
start -> handshake [label="tls"]; |
|
||||
start -> recv_data; |
|
||||
|
|
||||
handshake -> close [label="error"]; |
|
||||
handshake -> recv_data; |
|
||||
|
|
||||
recv_data -> handshake [label="rehandshake"]; |
|
||||
recv_data -> wait_for_resume [label="pause"]; |
|
||||
recv_data -> wait_for_close [label="eof"]; |
|
||||
recv_data -> close [label="error"]; |
|
||||
|
|
||||
wait_for_resume -> recv_data; |
|
||||
|
|
||||
wait_for_close -> close; |
|
||||
|
|
||||
close -> close_one [label="duplex"]; |
|
||||
close -> close_both; |
|
||||
|
|
||||
close_one -> end; |
|
||||
close_both -> end; |
|
||||
|
|
||||
} |
|
||||
@ -1,65 +0,0 @@ |
|||||
strict digraph send_states { |
|
||||
start [peripheries=2]; |
|
||||
end [peripheries=2]; |
|
||||
connection_established; |
|
||||
handshake; |
|
||||
send_data; |
|
||||
shutdown; |
|
||||
gnutls_bye; |
|
||||
close_one; |
|
||||
close_both; |
|
||||
|
|
||||
wait_for_connect; |
|
||||
wait_for_buf; |
|
||||
wait_for_eof; |
|
||||
|
|
||||
node [label="", shape="box", height=0.1, width=0.1]; |
|
||||
close; |
|
||||
drain; |
|
||||
hangup; |
|
||||
hangup_unsecure; |
|
||||
|
|
||||
|
|
||||
|
|
||||
start -> wait_for_connect [label="duplex"]; |
|
||||
start -> connection_established; |
|
||||
|
|
||||
wait_for_connect -> connection_established; |
|
||||
wait_for_connect -> close [label="error"]; |
|
||||
|
|
||||
connection_established -> handshake [label="tls"]; |
|
||||
connection_established -> send_data; |
|
||||
|
|
||||
handshake -> close [label="error"]; |
|
||||
handshake -> send_data; |
|
||||
|
|
||||
send_data -> close [label="error"]; |
|
||||
send_data -> drain [label="drain"]; |
|
||||
|
|
||||
drain -> wait_for_buf; |
|
||||
drain -> hangup [label="got_close"]; |
|
||||
|
|
||||
wait_for_buf -> send_data; |
|
||||
wait_for_buf -> drain [label="empty_buf"]; |
|
||||
|
|
||||
hangup -> gnutls_bye [label="tls"]; |
|
||||
hangup -> hangup_unsecure; |
|
||||
|
|
||||
gnutls_bye -> wait_for_eof; |
|
||||
gnutls_bye -> close [label="error"]; |
|
||||
|
|
||||
hangup_unsecure -> shutdown [label="duplex"]; |
|
||||
hangup_unsecure -> close_one; |
|
||||
|
|
||||
shutdown -> wait_for_eof; |
|
||||
shutdown -> close [label="error"]; |
|
||||
|
|
||||
wait_for_eof -> close_one; |
|
||||
close_one -> wait_for_eof [label="readable"]; |
|
||||
|
|
||||
close -> close_both; |
|
||||
close -> close_one [label="duplex"]; |
|
||||
|
|
||||
close_both -> end; |
|
||||
close_one -> end; |
|
||||
} |
|
||||
@ -1,100 +0,0 @@ |
|||||
#include <stdio.h> |
|
||||
#include <stdlib.h> |
|
||||
#include <string.h> |
|
||||
#include <unistd.h> |
|
||||
#include <assert.h> |
|
||||
|
|
||||
#include <sys/types.h> |
|
||||
#include <sys/socket.h> |
|
||||
#include <sys/un.h> |
|
||||
#include <netinet/in.h> |
|
||||
|
|
||||
|
|
||||
#include <ev.h> |
|
||||
#include <evcom.h> |
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
# include <gnutls/gnutls.h> |
|
||||
#endif |
|
||||
|
|
||||
#define HOST "127.0.0.1" |
|
||||
#define SOCKFILE "/tmp/oi.sock" |
|
||||
#define PORT 5000 |
|
||||
|
|
||||
static int nconnections; |
|
||||
|
|
||||
static void |
|
||||
on_peer_close (evcom_stream *stream) |
|
||||
{ |
|
||||
assert(stream->errorno == 0); |
|
||||
//printf("server connection closed\n");
|
|
||||
free(stream); |
|
||||
} |
|
||||
|
|
||||
static void |
|
||||
on_peer_timeout (evcom_stream *stream) |
|
||||
{ |
|
||||
assert(stream); |
|
||||
fprintf(stderr, "peer connection timeout\n"); |
|
||||
assert(0); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
|
|
||||
// timeout must match the timeout in timeout.rb
|
|
||||
#define TIMEOUT 5.0 |
|
||||
|
|
||||
static void |
|
||||
on_peer_read (evcom_stream *stream, const void *base, size_t len) |
|
||||
{ |
|
||||
if(len == 0) return; |
|
||||
|
|
||||
evcom_stream_write(stream, base, len); |
|
||||
} |
|
||||
|
|
||||
static evcom_stream* |
|
||||
on_server_connection (evcom_server *server, struct sockaddr *addr) |
|
||||
{ |
|
||||
assert(server); |
|
||||
assert(addr); |
|
||||
|
|
||||
evcom_stream *stream = malloc(sizeof(evcom_stream)); |
|
||||
evcom_stream_init(stream); |
|
||||
stream->on_read = on_peer_read; |
|
||||
stream->on_close = on_peer_close; |
|
||||
stream->on_timeout = on_peer_timeout; |
|
||||
evcom_stream_reset_timeout(stream, TIMEOUT); |
|
||||
|
|
||||
nconnections++; |
|
||||
|
|
||||
|
|
||||
//printf("on server connection\n");
|
|
||||
|
|
||||
return stream; |
|
||||
} |
|
||||
|
|
||||
int |
|
||||
main (void) |
|
||||
{ |
|
||||
int r; |
|
||||
evcom_server server; |
|
||||
|
|
||||
//printf("sizeof(evcom_server): %d\n", sizeof(evcom_server));
|
|
||||
//printf("sizeof(evcom_stream): %d\n", sizeof(evcom_stream));
|
|
||||
|
|
||||
evcom_server_init(&server); |
|
||||
server.on_connection = on_server_connection; |
|
||||
|
|
||||
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, (struct sockaddr*)&address, 10); |
|
||||
assert(r == 0); |
|
||||
evcom_server_attach(EV_DEFAULT_ &server); |
|
||||
|
|
||||
ev_loop(EV_DEFAULT_ 0); |
|
||||
|
|
||||
return 0; |
|
||||
} |
|
||||
@ -1,892 +0,0 @@ |
|||||
#include <stdio.h> |
|
||||
#include <stdlib.h> |
|
||||
#include <string.h> |
|
||||
#include <unistd.h> |
|
||||
#include <assert.h> |
|
||||
|
|
||||
#include <sys/types.h> |
|
||||
#include <sys/socket.h> |
|
||||
#include <sys/un.h> |
|
||||
#include <netinet/in.h> |
|
||||
|
|
||||
#include <ev.h> |
|
||||
#include <evcom.h> |
|
||||
|
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
# include <gnutls/gnutls.h> |
|
||||
#endif |
|
||||
|
|
||||
#undef MAX |
|
||||
#define MAX(a,b) ((a) > (b) ? (a) : (b)) |
|
||||
|
|
||||
#undef MIN |
|
||||
#define MIN(a,b) ((a) < (b) ? (a) : (b)) |
|
||||
|
|
||||
#define MARK_PROGRESS(c,cur,max) \ |
|
||||
if (cur % (MAX(max,50)/50) == 0) write(STDERR_FILENO, c, 1) |
|
||||
|
|
||||
#define SOCKFILE "/tmp/oi.sock" |
|
||||
#define PORT 5000 |
|
||||
|
|
||||
static evcom_server server; |
|
||||
static int nconnections; |
|
||||
static int use_tls; |
|
||||
static int got_server_close; |
|
||||
|
|
||||
static void |
|
||||
common_on_server_close (evcom_server *s) |
|
||||
{ |
|
||||
printf("server on_close\n"); |
|
||||
assert(s == &server); |
|
||||
assert(s->errorno == 0); |
|
||||
got_server_close = 1; |
|
||||
evcom_server_detach(s); |
|
||||
} |
|
||||
|
|
||||
static void |
|
||||
common_on_peer_close (evcom_stream *stream) |
|
||||
{ |
|
||||
assert(EVCOM_CLOSED == evcom_stream_state(stream)); |
|
||||
assert(stream->errorno == 0); |
|
||||
printf("server connection closed\n"); |
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
assert(stream->gnutls_errorno == 0); |
|
||||
if (use_tls) gnutls_deinit(stream->session); |
|
||||
#endif |
|
||||
evcom_stream_detach(stream); |
|
||||
free(stream); |
|
||||
} |
|
||||
|
|
||||
static void |
|
||||
common_on_client_timeout (evcom_stream *stream) |
|
||||
{ |
|
||||
assert(stream); |
|
||||
printf("client connection timeout\n"); |
|
||||
} |
|
||||
|
|
||||
static void |
|
||||
common_on_peer_timeout (evcom_stream *stream) |
|
||||
{ |
|
||||
assert(stream); |
|
||||
fprintf(stderr, "peer connection timeout\n"); |
|
||||
assert(0); |
|
||||
} |
|
||||
|
|
||||
#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 (evcom_stream *stream) |
|
||||
{ |
|
||||
gnutls_session_t session; |
|
||||
stream->data = session; |
|
||||
|
|
||||
int r = gnutls_init(&session, GNUTLS_SERVER); |
|
||||
assert(r == 0); |
|
||||
gnutls_set_default_priority(session); |
|
||||
gnutls_kx_set_priority (session, kx_prio); |
|
||||
gnutls_credentials_set(session, GNUTLS_CRD_ANON, server_credentials); |
|
||||
gnutls_dh_set_prime_bits(session, DH_BITS); |
|
||||
|
|
||||
evcom_stream_set_secure_session(stream, session); |
|
||||
} |
|
||||
|
|
||||
void anon_tls_client (evcom_stream *stream) |
|
||||
{ |
|
||||
gnutls_session_t client_session; |
|
||||
gnutls_anon_client_credentials_t client_credentials; |
|
||||
|
|
||||
gnutls_anon_allocate_client_credentials (&client_credentials); |
|
||||
gnutls_init(&client_session, GNUTLS_CLIENT); |
|
||||
gnutls_set_default_priority(client_session); |
|
||||
gnutls_kx_set_priority(client_session, kx_prio); |
|
||||
/* Need to enable anonymous KX specifically. */ |
|
||||
gnutls_credentials_set(client_session, GNUTLS_CRD_ANON, client_credentials); |
|
||||
|
|
||||
evcom_stream_set_secure_session(stream, client_session); |
|
||||
assert(stream->flags & EVCOM_SECURE); |
|
||||
} |
|
||||
|
|
||||
#endif // EVCOM_HAVE_GNUTLS
|
|
||||
|
|
||||
|
|
||||
|
|
||||
|
|
||||
|
|
||||
#define PING "PING" |
|
||||
#define PONG "PONG" |
|
||||
#define EXCHANGES 500 |
|
||||
#define PINGPONG_TIMEOUT 5.0 |
|
||||
|
|
||||
static int successful_ping_count; |
|
||||
|
|
||||
static void |
|
||||
pingpong_on_peer_read (evcom_stream *stream, const void *base, size_t len) |
|
||||
{ |
|
||||
if (len == 0) { |
|
||||
evcom_stream_close(stream); |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
char buf[2000]; |
|
||||
strncpy(buf, base, len); |
|
||||
buf[len] = 0; |
|
||||
printf("server got message: %s\n", buf); |
|
||||
|
|
||||
evcom_stream_write(stream, PONG, sizeof PONG); |
|
||||
} |
|
||||
|
|
||||
static void |
|
||||
pingpong_on_client_close (evcom_stream *stream) |
|
||||
{ |
|
||||
assert(EVCOM_CLOSED == evcom_stream_state(stream)); |
|
||||
assert(stream); |
|
||||
printf("client connection closed\n"); |
|
||||
evcom_server_close(&server); |
|
||||
evcom_stream_detach(stream); |
|
||||
} |
|
||||
|
|
||||
static evcom_stream* |
|
||||
pingpong_on_server_connection (evcom_server *_server, struct sockaddr *addr) |
|
||||
{ |
|
||||
assert(_server == &server); |
|
||||
assert(addr); |
|
||||
|
|
||||
evcom_stream *stream = malloc(sizeof(evcom_stream)); |
|
||||
evcom_stream_init(stream); |
|
||||
stream->on_read = pingpong_on_peer_read; |
|
||||
stream->on_close = common_on_peer_close; |
|
||||
stream->on_timeout = common_on_peer_timeout; |
|
||||
evcom_stream_reset_timeout(stream, PINGPONG_TIMEOUT); |
|
||||
|
|
||||
assert(EVCOM_INITIALIZED == evcom_stream_state(stream)); |
|
||||
|
|
||||
nconnections++; |
|
||||
|
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
if (use_tls) anon_tls_server(stream); |
|
||||
#endif |
|
||||
|
|
||||
printf("on server connection\n"); |
|
||||
|
|
||||
return stream; |
|
||||
} |
|
||||
|
|
||||
static void |
|
||||
pingpong_on_client_connect (evcom_stream *stream) |
|
||||
{ |
|
||||
printf("client connected. sending ping\n"); |
|
||||
evcom_stream_write(stream, PING, sizeof PING); |
|
||||
assert(EVCOM_CONNECTED_RW == evcom_stream_state(stream)); |
|
||||
} |
|
||||
|
|
||||
static void |
|
||||
pingpong_on_client_read (evcom_stream *stream, const void *base, size_t len) |
|
||||
{ |
|
||||
if(len == 0) { |
|
||||
evcom_stream_close(stream); |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
assert(len = strlen(PONG)); |
|
||||
|
|
||||
char buf[len+1]; |
|
||||
strncpy(buf, base, len); |
|
||||
buf[len] = 0; |
|
||||
printf("client got message: %s\n", buf); |
|
||||
|
|
||||
assert(strcmp(buf, PONG) == 0); |
|
||||
|
|
||||
if (++successful_ping_count > EXCHANGES) { |
|
||||
evcom_stream_close(stream); |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
MARK_PROGRESS(".", successful_ping_count, EXCHANGES); |
|
||||
|
|
||||
evcom_stream_write(stream, PING, sizeof PING); |
|
||||
} |
|
||||
|
|
||||
int |
|
||||
pingpong (struct sockaddr *address) |
|
||||
{ |
|
||||
int r; |
|
||||
evcom_stream client; |
|
||||
|
|
||||
successful_ping_count = 0; |
|
||||
nconnections = 0; |
|
||||
got_server_close = 0; |
|
||||
|
|
||||
evcom_server_init(&server); |
|
||||
server.on_connection = pingpong_on_server_connection; |
|
||||
server.on_close = common_on_server_close; |
|
||||
|
|
||||
r = evcom_server_listen(&server, address, 10); |
|
||||
assert(r == 0); |
|
||||
evcom_server_attach(EV_DEFAULT_ &server); |
|
||||
|
|
||||
evcom_stream_init(&client); |
|
||||
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; |
|
||||
evcom_stream_reset_timeout(&client, PINGPONG_TIMEOUT); |
|
||||
|
|
||||
assert(EVCOM_INITIALIZED == evcom_stream_state(&client)); |
|
||||
|
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
if (use_tls) anon_tls_client(&client); |
|
||||
#endif |
|
||||
|
|
||||
r = evcom_stream_connect(&client, address); |
|
||||
assert(r == 0 && "problem connecting"); |
|
||||
evcom_stream_attach(EV_DEFAULT_ &client); |
|
||||
|
|
||||
ev_loop(EV_DEFAULT_ 0); |
|
||||
|
|
||||
printf("successful_ping_count = %d\n", successful_ping_count); |
|
||||
assert(successful_ping_count == EXCHANGES + 1); |
|
||||
assert(nconnections == 1); |
|
||||
assert(got_server_close); |
|
||||
|
|
||||
return 0; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
|
|
||||
#define NCONN 50 |
|
||||
#define CONNINT_TIMEOUT 10.0 |
|
||||
|
|
||||
static void |
|
||||
send_bye_and_close(evcom_stream *stream, const void *base, size_t len) |
|
||||
{ |
|
||||
assert(base); |
|
||||
assert(len == 0); |
|
||||
evcom_stream_write(stream, "BYE", 3); |
|
||||
printf("server wrote bye\n"); |
|
||||
evcom_stream_close(stream); |
|
||||
} |
|
||||
|
|
||||
static evcom_stream* |
|
||||
connint_on_connection(evcom_server *_server, struct sockaddr *addr) |
|
||||
{ |
|
||||
assert(_server == &server); |
|
||||
assert(addr); |
|
||||
|
|
||||
evcom_stream *stream = malloc(sizeof(evcom_stream)); |
|
||||
evcom_stream_init(stream); |
|
||||
stream->on_read = send_bye_and_close; |
|
||||
stream->on_close = common_on_peer_close; |
|
||||
stream->on_timeout = common_on_peer_timeout; |
|
||||
evcom_stream_reset_timeout(stream, CONNINT_TIMEOUT); |
|
||||
|
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
if (use_tls) anon_tls_server(stream); |
|
||||
#endif |
|
||||
|
|
||||
printf("on server connection\n"); |
|
||||
|
|
||||
return stream; |
|
||||
} |
|
||||
|
|
||||
static void |
|
||||
connint_on_client_connect (evcom_stream *stream) |
|
||||
{ |
|
||||
printf("on client connection\n"); |
|
||||
evcom_stream_close(stream); |
|
||||
} |
|
||||
|
|
||||
static void |
|
||||
connint_on_client_close (evcom_stream *stream) |
|
||||
{ |
|
||||
evcom_stream_close(stream); // already closed, but it shouldn't crash if we try to do it again
|
|
||||
|
|
||||
printf("client connection closed\n"); |
|
||||
|
|
||||
MARK_PROGRESS(".", nconnections, NCONN); |
|
||||
|
|
||||
if(++nconnections == NCONN) { |
|
||||
evcom_server_close(&server); |
|
||||
printf("closing server\n"); |
|
||||
} |
|
||||
|
|
||||
evcom_stream_detach(stream); |
|
||||
} |
|
||||
|
|
||||
static void |
|
||||
connint_on_client_read (evcom_stream *stream, const void *base, size_t len) |
|
||||
{ |
|
||||
if (len == 0) { |
|
||||
evcom_stream_close(stream); |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
char buf[200000]; |
|
||||
strncpy(buf, base, len); |
|
||||
buf[len] = 0; |
|
||||
|
|
||||
printf("client got message: %s\n", buf); |
|
||||
|
|
||||
assert(strcmp(buf, "BYE") == 0); |
|
||||
evcom_stream_close(stream); |
|
||||
} |
|
||||
|
|
||||
int |
|
||||
connint (struct sockaddr *address) |
|
||||
{ |
|
||||
int r; |
|
||||
|
|
||||
nconnections = 0; |
|
||||
got_server_close = 0; |
|
||||
|
|
||||
evcom_server_init(&server); |
|
||||
server.on_connection = connint_on_connection; |
|
||||
server.on_close = common_on_server_close; |
|
||||
|
|
||||
evcom_server_listen(&server, address, 1000); |
|
||||
evcom_server_attach(EV_DEFAULT_ &server); |
|
||||
|
|
||||
evcom_stream clients[NCONN]; |
|
||||
int i; |
|
||||
for (i = 0; i < NCONN; i++) { |
|
||||
evcom_stream *client = &clients[i]; |
|
||||
evcom_stream_init(client); |
|
||||
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; |
|
||||
evcom_stream_reset_timeout(client, CONNINT_TIMEOUT); |
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
if (use_tls) anon_tls_client(client); |
|
||||
#endif |
|
||||
r = evcom_stream_connect(client, address); |
|
||||
assert(r == 0 && "problem connecting"); |
|
||||
evcom_stream_attach(EV_DEFAULT_ client); |
|
||||
} |
|
||||
|
|
||||
ev_loop(EV_DEFAULT_ 0); |
|
||||
|
|
||||
assert(nconnections == NCONN); |
|
||||
assert(got_server_close); |
|
||||
|
|
||||
return 0; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
static evcom_reader reader; |
|
||||
static evcom_writer writer; |
|
||||
static int reader_got_close = 0; |
|
||||
static int reader_got_eof = 0; |
|
||||
static int reader_got_hello = 0; |
|
||||
static int reader_cnt = 0; |
|
||||
static int writer_got_close = 0; |
|
||||
#define PIPE_MSG "hello world" |
|
||||
#define PIPE_CNT 5000 |
|
||||
|
|
||||
static void |
|
||||
reader_read (evcom_reader *r, const void *str, size_t len) |
|
||||
{ |
|
||||
assert(r == &reader); |
|
||||
|
|
||||
if (len == 0) { |
|
||||
reader_got_eof = 1; |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
assert(len == strlen(PIPE_MSG)); |
|
||||
|
|
||||
if (strncmp(str, PIPE_MSG, strlen(PIPE_MSG)) == 0) { |
|
||||
reader_got_hello = 1; |
|
||||
} |
|
||||
|
|
||||
if (++reader_cnt < PIPE_CNT) { |
|
||||
MARK_PROGRESS(".", reader_cnt, PIPE_CNT); |
|
||||
evcom_writer_write(&writer, PIPE_MSG, strlen(PIPE_MSG)); |
|
||||
} else { |
|
||||
evcom_writer_close(&writer); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
static void |
|
||||
reader_close (evcom_reader *r) |
|
||||
{ |
|
||||
assert(r == &reader); |
|
||||
reader_got_close = 1; |
|
||||
evcom_reader_detach(r); |
|
||||
} |
|
||||
|
|
||||
static void |
|
||||
writer_close (evcom_writer *w) |
|
||||
{ |
|
||||
assert(w == &writer); |
|
||||
writer_got_close = 1; |
|
||||
evcom_writer_detach(w); |
|
||||
} |
|
||||
|
|
||||
int |
|
||||
pipe_stream (void) |
|
||||
{ |
|
||||
reader_cnt = 0; |
|
||||
reader_got_close = 0; |
|
||||
reader_got_hello = 0; |
|
||||
reader_got_eof = 0; |
|
||||
writer_got_close = 0; |
|
||||
|
|
||||
int pipefd[2]; |
|
||||
int r = pipe(pipefd); |
|
||||
if (r < 0) { |
|
||||
perror("pipe()"); |
|
||||
return -1; |
|
||||
} |
|
||||
|
|
||||
evcom_reader_init(&reader); |
|
||||
reader.on_read = reader_read; |
|
||||
reader.on_close = reader_close; |
|
||||
evcom_reader_set(&reader, pipefd[0]); |
|
||||
evcom_reader_attach(EV_DEFAULT_ &reader); |
|
||||
|
|
||||
evcom_writer_init(&writer); |
|
||||
writer.on_close = writer_close; |
|
||||
evcom_writer_set(&writer, pipefd[1]); |
|
||||
evcom_writer_attach(EV_DEFAULT_ &writer); |
|
||||
|
|
||||
evcom_writer_write(&writer, PIPE_MSG, strlen(PIPE_MSG)); |
|
||||
|
|
||||
ev_loop(EV_DEFAULT_ 0); |
|
||||
|
|
||||
assert(reader_got_close); |
|
||||
assert(reader_got_hello); |
|
||||
assert(reader_got_eof); |
|
||||
assert(writer_got_close); |
|
||||
assert(reader_cnt == PIPE_CNT); |
|
||||
|
|
||||
return 0; |
|
||||
} |
|
||||
|
|
||||
#define PAIR_PINGPONG_TIMEOUT 5000.0 |
|
||||
#define PAIR_PINGPONG_EXCHANGES 50 |
|
||||
static int a_got_close; |
|
||||
static int a_got_connect; |
|
||||
static int b_got_close; |
|
||||
static int b_got_connect; |
|
||||
static int pair_pingpong_cnt; |
|
||||
static evcom_stream a, b; |
|
||||
|
|
||||
void a_connect (evcom_stream *stream) |
|
||||
{ |
|
||||
assert(stream == &a); |
|
||||
a_got_connect = 1; |
|
||||
} |
|
||||
|
|
||||
void a_close (evcom_stream *stream) |
|
||||
{ |
|
||||
evcom_stream_detach(stream); |
|
||||
assert(stream == &a); |
|
||||
a_got_close = 1; |
|
||||
|
|
||||
assert(stream->errorno == 0); |
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
if (stream->gnutls_errorno) { |
|
||||
fprintf(stderr, "\nGNUTLS ERROR: %s\n", gnutls_strerror(stream->gnutls_errorno)); |
|
||||
} |
|
||||
assert(stream->gnutls_errorno == 0); |
|
||||
if (use_tls) gnutls_deinit(stream->session); |
|
||||
#endif |
|
||||
} |
|
||||
|
|
||||
void a_read (evcom_stream *stream, const void *buf, size_t len) |
|
||||
{ |
|
||||
assert(stream == &a); |
|
||||
if (len == 0) return; |
|
||||
|
|
||||
assert(len == strlen(PONG)); |
|
||||
assert(strncmp(buf, PONG, strlen(PONG)) == 0); |
|
||||
|
|
||||
if (++pair_pingpong_cnt < PAIR_PINGPONG_EXCHANGES) { |
|
||||
evcom_stream_write(&a, PING, strlen(PING)); |
|
||||
} else if (pair_pingpong_cnt == PAIR_PINGPONG_EXCHANGES) { |
|
||||
evcom_stream_close(stream); |
|
||||
} |
|
||||
|
|
||||
MARK_PROGRESS(".", pair_pingpong_cnt, PAIR_PINGPONG_EXCHANGES); |
|
||||
} |
|
||||
|
|
||||
void b_connect (evcom_stream *stream) |
|
||||
{ |
|
||||
assert(stream == &b); |
|
||||
b_got_connect = 1; |
|
||||
} |
|
||||
|
|
||||
void b_close (evcom_stream *stream) |
|
||||
{ |
|
||||
evcom_stream_detach(stream); |
|
||||
assert(stream == &b); |
|
||||
b_got_close = 1; |
|
||||
|
|
||||
assert(stream->errorno == 0); |
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
if (stream->gnutls_errorno) { |
|
||||
fprintf(stderr, "\nGNUTLS ERROR: %s\n", gnutls_strerror(stream->gnutls_errorno)); |
|
||||
} |
|
||||
assert(stream->gnutls_errorno == 0); |
|
||||
if (use_tls) gnutls_deinit(stream->session); |
|
||||
#endif |
|
||||
} |
|
||||
|
|
||||
void b_read (evcom_stream *stream, const void *buf, size_t len) |
|
||||
{ |
|
||||
assert(stream == &b); |
|
||||
if (len == 0) { |
|
||||
evcom_stream_close(stream); |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
assert(len == strlen(PING)); |
|
||||
assert(strncmp(buf, PING, strlen(PING)) == 0); |
|
||||
|
|
||||
evcom_stream_write(&b, PONG, strlen(PONG)); |
|
||||
} |
|
||||
|
|
||||
int |
|
||||
pair_pingpong (int use_pipe) |
|
||||
{ |
|
||||
a_got_close = 0; |
|
||||
a_got_connect = 0; |
|
||||
b_got_close = 0; |
|
||||
b_got_connect = 0; |
|
||||
pair_pingpong_cnt = 0; |
|
||||
|
|
||||
evcom_stream_init(&a); |
|
||||
a.on_close = a_close; |
|
||||
a.on_connect = a_connect; |
|
||||
a.on_read = a_read; |
|
||||
evcom_stream_reset_timeout(&a, PAIR_PINGPONG_TIMEOUT); |
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
if (use_tls) anon_tls_client(&a); |
|
||||
#endif |
|
||||
|
|
||||
evcom_stream_init(&b); |
|
||||
b.on_close = b_close; |
|
||||
b.on_connect = b_connect; |
|
||||
b.on_read = b_read; |
|
||||
evcom_stream_reset_timeout(&b, PAIR_PINGPONG_TIMEOUT); |
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
if (use_tls) anon_tls_server(&b); |
|
||||
#endif |
|
||||
|
|
||||
if (use_pipe) { |
|
||||
int pipeA[2], pipeB[2]; |
|
||||
assert(0 == pipe(pipeA)); |
|
||||
assert(0 == pipe(pipeB)); |
|
||||
|
|
||||
evcom_stream_assign_fds(&a, pipeA[0], pipeB[1]); |
|
||||
evcom_stream_assign_fds(&b, pipeB[0], pipeA[1]); |
|
||||
|
|
||||
} else { |
|
||||
int r = evcom_stream_pair(&a, &b); |
|
||||
assert(r == 0); |
|
||||
} |
|
||||
|
|
||||
evcom_stream_attach(EV_DEFAULT_ &a); |
|
||||
evcom_stream_attach(EV_DEFAULT_ &b); |
|
||||
|
|
||||
evcom_stream_write(&a, PING, strlen(PING)); |
|
||||
|
|
||||
ev_loop(EV_DEFAULT_ 0); |
|
||||
|
|
||||
assert(a_got_close); |
|
||||
assert(a_got_connect); |
|
||||
assert(b_got_close); |
|
||||
assert(b_got_connect); |
|
||||
assert(pair_pingpong_cnt == PAIR_PINGPONG_EXCHANGES); |
|
||||
|
|
||||
return 0; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
static void |
|
||||
free_stream (evcom_stream *stream) |
|
||||
{ |
|
||||
assert(stream->errorno == 0); |
|
||||
free(stream); |
|
||||
} |
|
||||
|
|
||||
#define ZERO_TIMEOUT 50.0 |
|
||||
static size_t zero_to_write = 0; |
|
||||
static size_t zero_written = 0; |
|
||||
static size_t zero_read = 0; |
|
||||
static size_t zero_client_closed = 0; |
|
||||
|
|
||||
static void |
|
||||
error_out (evcom_stream *stream) |
|
||||
{ |
|
||||
assert(stream); |
|
||||
fprintf(stderr, "peer connection timeout\n"); |
|
||||
assert(0); |
|
||||
} |
|
||||
|
|
||||
static void |
|
||||
echo (evcom_stream *stream, const void *base, size_t len) |
|
||||
{ |
|
||||
if(len == 0) { |
|
||||
fprintf(stderr, "close"); |
|
||||
evcom_stream_close(stream); |
|
||||
} else { |
|
||||
evcom_stream_write(stream, base, len); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
static evcom_stream* |
|
||||
make_echo_connection (evcom_server *server, struct sockaddr *addr) |
|
||||
{ |
|
||||
assert(server); |
|
||||
assert(addr); |
|
||||
|
|
||||
evcom_stream *stream = malloc(sizeof(evcom_stream)); |
|
||||
evcom_stream_init(stream); |
|
||||
stream->on_read = echo; |
|
||||
stream->on_close = free_stream; |
|
||||
stream->on_timeout = error_out; |
|
||||
evcom_stream_reset_timeout(stream, ZERO_TIMEOUT); |
|
||||
|
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
if (use_tls) anon_tls_server(stream); |
|
||||
#endif |
|
||||
|
|
||||
return stream; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
static void |
|
||||
zero_start (evcom_stream *stream) |
|
||||
{ |
|
||||
evcom_stream_write(stream, "0", 1); |
|
||||
zero_written++; |
|
||||
} |
|
||||
|
|
||||
static void |
|
||||
zero_close (evcom_stream *stream) |
|
||||
{ |
|
||||
assert(stream); |
|
||||
zero_client_closed = 1; |
|
||||
} |
|
||||
|
|
||||
static void |
|
||||
zero_recv (evcom_stream *stream, const void *buf, size_t len) |
|
||||
{ |
|
||||
MARK_PROGRESS("-", zero_read, zero_to_write); |
|
||||
zero_read += len; |
|
||||
|
|
||||
size_t i; |
|
||||
|
|
||||
for (i = 0; i < len; i++) { |
|
||||
assert(((char*)buf)[i] == '0'); |
|
||||
} |
|
||||
|
|
||||
for (i = 0; i < MIN(zero_to_write - zero_written, 90000); i++) { |
|
||||
evcom_stream_write(stream, "0", 1); |
|
||||
zero_written++; |
|
||||
|
|
||||
MARK_PROGRESS(".", zero_written, zero_to_write); |
|
||||
|
|
||||
if (zero_written == zero_to_write) { |
|
||||
|
|
||||
fprintf(stderr, "CLOSE"); |
|
||||
evcom_stream_close(stream); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
if (len == 0) { |
|
||||
fprintf(stderr, "finish"); |
|
||||
evcom_server_close(&server); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
int |
|
||||
zero_stream (struct sockaddr *address, size_t to_write) |
|
||||
{ |
|
||||
int r; |
|
||||
|
|
||||
assert(to_write >= 1024); // should be kind of big at least.
|
|
||||
zero_to_write = to_write; |
|
||||
got_server_close = 0; |
|
||||
zero_written = 0; |
|
||||
zero_read = 0; |
|
||||
zero_client_closed = 0; |
|
||||
|
|
||||
evcom_server_init(&server); |
|
||||
server.on_connection = make_echo_connection; |
|
||||
server.on_close = common_on_server_close; |
|
||||
|
|
||||
evcom_server_listen(&server, address, 1000); |
|
||||
evcom_server_attach(EV_DEFAULT_ &server); |
|
||||
|
|
||||
evcom_stream client; |
|
||||
evcom_stream_init(&client); |
|
||||
client.on_read = zero_recv; |
|
||||
client.on_connect = zero_start; |
|
||||
client.on_close = zero_close; |
|
||||
client.on_timeout = error_out; |
|
||||
evcom_stream_reset_timeout(&client, ZERO_TIMEOUT); |
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
if (use_tls) anon_tls_client(&client); |
|
||||
#endif |
|
||||
r = evcom_stream_connect(&client, address); |
|
||||
assert(r == 0 && "problem connecting"); |
|
||||
evcom_stream_attach(EV_DEFAULT_ &client); |
|
||||
|
|
||||
ev_loop(EV_DEFAULT_ 0); |
|
||||
|
|
||||
assert(got_server_close); |
|
||||
assert(zero_written == zero_to_write); |
|
||||
assert(zero_read == zero_to_write); |
|
||||
assert(zero_client_closed) ; |
|
||||
|
|
||||
return 0; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
struct sockaddr * |
|
||||
create_unix_address (void) |
|
||||
{ |
|
||||
struct stat tstat; |
|
||||
if (lstat(SOCKFILE, &tstat) == 0) { |
|
||||
assert(S_ISSOCK(tstat.st_mode)); |
|
||||
unlink(SOCKFILE); |
|
||||
} |
|
||||
|
|
||||
struct sockaddr_un *address = calloc(1, sizeof(struct sockaddr_un)); |
|
||||
address->sun_family = AF_UNIX; |
|
||||
strcpy(address->sun_path, SOCKFILE); |
|
||||
|
|
||||
return (struct sockaddr*)address; |
|
||||
} |
|
||||
|
|
||||
void |
|
||||
free_unix_address (struct sockaddr *address) |
|
||||
{ |
|
||||
struct stat tstat; |
|
||||
if (lstat(SOCKFILE, &tstat) == 0) { |
|
||||
assert(S_ISSOCK(tstat.st_mode)); |
|
||||
unlink(SOCKFILE); |
|
||||
} |
|
||||
free(address); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
int |
|
||||
main (void) |
|
||||
{ |
|
||||
fprintf(stderr, "sizeof(evcom_server): %d\n", (int)sizeof(evcom_server)); |
|
||||
fprintf(stderr, "sizeof(evcom_stream): %d\n", (int)sizeof(evcom_stream)); |
|
||||
fprintf(stderr, "sizeof(evcom_reader): %d\n", (int)sizeof(evcom_reader)); |
|
||||
fprintf(stderr, "sizeof(evcom_writer): %d\n", (int)sizeof(evcom_writer)); |
|
||||
|
|
||||
evcom_ignore_sigpipe(); |
|
||||
|
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
gnutls_global_init(); |
|
||||
|
|
||||
gnutls_dh_params_init (&dh_params); |
|
||||
|
|
||||
fsync((int)stderr); |
|
||||
gnutls_dh_params_generate2 (dh_params, DH_BITS); |
|
||||
|
|
||||
gnutls_anon_allocate_server_credentials (&server_credentials); |
|
||||
gnutls_anon_set_server_dh_params (server_credentials, dh_params); |
|
||||
#endif |
|
||||
|
|
||||
|
|
||||
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; |
|
||||
|
|
||||
fprintf(stderr, "pair_pingpong use_pipe=1: "); |
|
||||
assert(pair_pingpong(1) == 0); |
|
||||
fprintf(stderr, "\n"); |
|
||||
|
|
||||
fprintf(stderr, "pair_pingpong use_pipe=0: "); |
|
||||
assert(pair_pingpong(0) == 0); |
|
||||
fprintf(stderr, "\n"); |
|
||||
|
|
||||
fprintf(stderr, "zero_stream tcp: "); |
|
||||
assert(zero_stream((struct sockaddr*)&tcp_address, 5*1024*1024) == 0); |
|
||||
fprintf(stderr, "\n"); |
|
||||
|
|
||||
fprintf(stderr, "pipe_stream: "); |
|
||||
assert(pipe_stream() == 0); |
|
||||
fprintf(stderr, "\n"); |
|
||||
|
|
||||
fprintf(stderr, "pingpong tcp: "); |
|
||||
assert(pingpong((struct sockaddr*)&tcp_address) == 0); |
|
||||
fprintf(stderr, "\n"); |
|
||||
|
|
||||
fprintf(stderr, "connint tcp: "); |
|
||||
assert(connint((struct sockaddr*)&tcp_address) == 0); |
|
||||
fprintf(stderr, "\n"); |
|
||||
|
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
use_tls = 1; |
|
||||
|
|
||||
fprintf(stderr, "zero_stream ssl: "); |
|
||||
assert(zero_stream((struct sockaddr*)&tcp_address, 50*1024) == 0); |
|
||||
fprintf(stderr, "\n"); |
|
||||
|
|
||||
fprintf(stderr, "pair_pingpong ssl use_pipe=1: "); |
|
||||
assert(pair_pingpong(1) == 0); |
|
||||
fprintf(stderr, "\n"); |
|
||||
|
|
||||
fprintf(stderr, "pair_pingpong ssl use_pipe=0: "); |
|
||||
assert(pair_pingpong(0) == 0); |
|
||||
fprintf(stderr, "\n"); |
|
||||
|
|
||||
fprintf(stderr, "pingpong ssl: "); |
|
||||
assert(pingpong((struct sockaddr*)&tcp_address) == 0); |
|
||||
fprintf(stderr, "\n"); |
|
||||
|
|
||||
fprintf(stderr, "connint ssl: "); |
|
||||
assert(connint((struct sockaddr*)&tcp_address) == 0); |
|
||||
fprintf(stderr, "\n"); |
|
||||
|
|
||||
#endif |
|
||||
|
|
||||
struct sockaddr *unix_address; |
|
||||
|
|
||||
use_tls = 0; |
|
||||
|
|
||||
fprintf(stderr, "pingpong unix: "); |
|
||||
unix_address = create_unix_address(); |
|
||||
assert(pingpong(unix_address) == 0); |
|
||||
free_unix_address(unix_address); |
|
||||
fprintf(stderr, "\n"); |
|
||||
|
|
||||
fprintf(stderr, "connint unix: "); |
|
||||
unix_address = create_unix_address(); |
|
||||
assert(connint(unix_address) == 0); |
|
||||
free_unix_address(unix_address); |
|
||||
fprintf(stderr, "\n"); |
|
||||
|
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
use_tls = 1; |
|
||||
|
|
||||
fprintf(stderr, "pingpong unix ssl: "); |
|
||||
unix_address = create_unix_address(); |
|
||||
assert(pingpong(unix_address) == 0); |
|
||||
free_unix_address(unix_address); |
|
||||
fprintf(stderr, "\n"); |
|
||||
|
|
||||
fprintf(stderr, "connint unix ssl: "); |
|
||||
unix_address = create_unix_address(); |
|
||||
assert(connint(unix_address) == 0); |
|
||||
free_unix_address(unix_address); |
|
||||
fprintf(stderr, "\n"); |
|
||||
#endif |
|
||||
|
|
||||
return 0; |
|
||||
} |
|
||||
@ -1,98 +0,0 @@ |
|||||
#!/usr/bin/env ruby |
|
||||
require 'socket' |
|
||||
|
|
||||
def test(description) |
|
||||
pid = fork do |
|
||||
exec(File.dirname(__FILE__) + "/echo") |
|
||||
end |
|
||||
|
|
||||
puts "#{description}: " |
|
||||
begin |
|
||||
sleep 0.5 # give time for the server to start |
|
||||
yield(pid) |
|
||||
rescue |
|
||||
puts "\033[1;31mFAIL\033[m" |
|
||||
raise $! |
|
||||
ensure |
|
||||
`kill -9 #{pid}` |
|
||||
end |
|
||||
puts "\033[1;32mPASS\033[m" |
|
||||
end |
|
||||
|
|
||||
test("make sure echo server works") do |
|
||||
socket = TCPSocket.open("localhost", 5000) |
|
||||
w = socket.write("hello"); |
|
||||
raise "error" unless w == 5 |
|
||||
|
|
||||
got = socket.recv(5); |
|
||||
raise "error" unless got == "hello" |
|
||||
|
|
||||
socket.close |
|
||||
end |
|
||||
|
|
||||
test("doing nothing should not timeout the server") do |pid| |
|
||||
10.times do |
|
||||
print "." |
|
||||
STDOUT.flush |
|
||||
if Process.waitpid(pid, Process::WNOHANG) |
|
||||
raise "server died when it shouldn't have" |
|
||||
end |
|
||||
sleep 1 |
|
||||
end |
|
||||
puts "" |
|
||||
end |
|
||||
|
|
||||
test("connecting and doing nothing to should timeout in 5 seconds") do |pid| |
|
||||
socket = TCPSocket.open("localhost", 5000) |
|
||||
i = 0 |
|
||||
10.times do |
|
||||
print "." |
|
||||
STDOUT.flush |
|
||||
break if Process.waitpid(pid, Process::WNOHANG) |
|
||||
sleep 1 |
|
||||
i+=1 |
|
||||
end |
|
||||
puts "" |
|
||||
raise "died too soon (after #{i} seconds)" if i < 5 |
|
||||
raise "died too late (after #{i} seconds)" if i > 6 |
|
||||
end |
|
||||
|
|
||||
|
|
||||
test("connecting and writing once to should timeout in 5 seconds") do |pid| |
|
||||
socket = TCPSocket.open("localhost", 5000) |
|
||||
w = socket.write("hello"); |
|
||||
raise "error" unless w == 5 |
|
||||
|
|
||||
i = 0 |
|
||||
10.times do |
|
||||
print "." |
|
||||
STDOUT.flush |
|
||||
break if Process.waitpid(pid, Process::WNOHANG) |
|
||||
sleep 1 |
|
||||
i+=1 |
|
||||
end |
|
||||
puts "" |
|
||||
raise "died too soon (after #{i} seconds)" if i < 5 |
|
||||
raise "died too late (after #{i} seconds)" if i > 6 |
|
||||
end |
|
||||
|
|
||||
test("connecting waiting 3, writing once to should timeout in 8 seconds") do |pid| |
|
||||
socket = TCPSocket.open("localhost", 5000) |
|
||||
|
|
||||
sleep 3 |
|
||||
|
|
||||
w = socket.write("hello"); |
|
||||
raise "error" unless w == 5 |
|
||||
|
|
||||
i = 0 |
|
||||
10.times do |
|
||||
print "." |
|
||||
STDOUT.flush |
|
||||
break if Process.waitpid(pid, Process::WNOHANG) |
|
||||
sleep 1 |
|
||||
i+=1 |
|
||||
end |
|
||||
puts "" |
|
||||
raise "died too soon (after #{i} seconds)" if i < 5 |
|
||||
raise "died too late (after #{i} seconds)" if i > 6 |
|
||||
end |
|
||||
@ -1,641 +0,0 @@ |
|||||
var sys = require('sys'); |
|
||||
var events = require('events'); |
|
||||
|
|
||||
// FIXME: The TCP binding isn't actually used here, but it needs to be
|
|
||||
// loaded before the http binding.
|
|
||||
process.binding('tcp'); |
|
||||
|
|
||||
var http = process.binding('http'); |
|
||||
|
|
||||
var CRLF = "\r\n"; |
|
||||
var STATUS_CODES = exports.STATUS_CODES = { |
|
||||
100 : 'Continue', |
|
||||
101 : 'Switching Protocols', |
|
||||
200 : 'OK', |
|
||||
201 : 'Created', |
|
||||
202 : 'Accepted', |
|
||||
203 : 'Non-Authoritative Information', |
|
||||
204 : 'No Content', |
|
||||
205 : 'Reset Content', |
|
||||
206 : 'Partial Content', |
|
||||
300 : 'Multiple Choices', |
|
||||
301 : 'Moved Permanently', |
|
||||
302 : 'Moved Temporarily', |
|
||||
303 : 'See Other', |
|
||||
304 : 'Not Modified', |
|
||||
305 : 'Use Proxy', |
|
||||
400 : 'Bad Request', |
|
||||
401 : 'Unauthorized', |
|
||||
402 : 'Payment Required', |
|
||||
403 : 'Forbidden', |
|
||||
404 : 'Not Found', |
|
||||
405 : 'Method Not Allowed', |
|
||||
406 : 'Not Acceptable', |
|
||||
407 : 'Proxy Authentication Required', |
|
||||
408 : 'Request Time-out', |
|
||||
409 : 'Conflict', |
|
||||
410 : 'Gone', |
|
||||
411 : 'Length Required', |
|
||||
412 : 'Precondition Failed', |
|
||||
413 : 'Request Entity Too Large', |
|
||||
414 : 'Request-URI Too Large', |
|
||||
415 : 'Unsupported Media Type', |
|
||||
500 : 'Internal Server Error', |
|
||||
501 : 'Not Implemented', |
|
||||
502 : 'Bad Gateway', |
|
||||
503 : 'Service Unavailable', |
|
||||
504 : 'Gateway Time-out', |
|
||||
505 : 'HTTP Version not supported' |
|
||||
}; |
|
||||
|
|
||||
var connection_expression = /Connection/i; |
|
||||
var transfer_encoding_expression = /Transfer-Encoding/i; |
|
||||
var close_expression = /close/i; |
|
||||
var chunk_expression = /chunk/i; |
|
||||
var content_length_expression = /Content-Length/i; |
|
||||
|
|
||||
|
|
||||
/* Abstract base class for ServerRequest and ClientResponse. */ |
|
||||
function IncomingMessage (connection) { |
|
||||
events.EventEmitter.call(this); |
|
||||
|
|
||||
this.connection = connection; |
|
||||
this.httpVersion = null; |
|
||||
this.headers = {}; |
|
||||
|
|
||||
// request (server) only
|
|
||||
this.url = ""; |
|
||||
|
|
||||
this.method = null; |
|
||||
|
|
||||
// response (client) only
|
|
||||
this.statusCode = null; |
|
||||
this.client = this.connection; |
|
||||
} |
|
||||
sys.inherits(IncomingMessage, events.EventEmitter); |
|
||||
exports.IncomingMessage = IncomingMessage; |
|
||||
|
|
||||
IncomingMessage.prototype._parseQueryString = function () { |
|
||||
throw new Error("_parseQueryString is deprecated. Use require(\"querystring\") to parse query strings.\n"); |
|
||||
}; |
|
||||
|
|
||||
IncomingMessage.prototype.setBodyEncoding = function (enc) { |
|
||||
// TODO: Find a cleaner way of doing this.
|
|
||||
this.connection.setEncoding(enc); |
|
||||
}; |
|
||||
|
|
||||
IncomingMessage.prototype.pause = function () { |
|
||||
this.connection.pause(); |
|
||||
}; |
|
||||
|
|
||||
IncomingMessage.prototype.resume = function () { |
|
||||
this.connection.resume(); |
|
||||
}; |
|
||||
|
|
||||
IncomingMessage.prototype._addHeaderLine = function (field, value) { |
|
||||
if (field in this.headers) { |
|
||||
// TODO Certain headers like 'Content-Type' should not be concatinated.
|
|
||||
// See https://www.google.com/reader/view/?tab=my#overview-page
|
|
||||
this.headers[field] += ", " + value; |
|
||||
} else { |
|
||||
this.headers[field] = value; |
|
||||
} |
|
||||
}; |
|
||||
|
|
||||
function OutgoingMessage (connection) { |
|
||||
events.EventEmitter.call(this, connection); |
|
||||
|
|
||||
this.connection = connection; |
|
||||
|
|
||||
this.output = []; |
|
||||
this.outputEncodings = []; |
|
||||
|
|
||||
this.closeOnFinish = false; |
|
||||
this.chunked_encoding = false; |
|
||||
this.should_keep_alive = true; |
|
||||
this.use_chunked_encoding_by_default = true; |
|
||||
|
|
||||
this.flushing = false; |
|
||||
this.headWritten = false; |
|
||||
|
|
||||
this.finished = false; |
|
||||
} |
|
||||
sys.inherits(OutgoingMessage, events.EventEmitter); |
|
||||
exports.OutgoingMessage = OutgoingMessage; |
|
||||
|
|
||||
OutgoingMessage.prototype._send = function (data, encoding) { |
|
||||
var length = this.output.length; |
|
||||
|
|
||||
if (length === 0) { |
|
||||
this.output.push(data); |
|
||||
encoding = encoding || "ascii"; |
|
||||
this.outputEncodings.push(encoding); |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
var lastEncoding = this.outputEncodings[length-1]; |
|
||||
var lastData = this.output[length-1]; |
|
||||
|
|
||||
if ((lastEncoding === encoding) || |
|
||||
(!encoding && data.constructor === lastData.constructor)) { |
|
||||
if (lastData.constructor === String) { |
|
||||
this.output[length-1] = lastData + data; |
|
||||
} else { |
|
||||
this.output[length-1] = lastData.concat(data); |
|
||||
} |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
this.output.push(data); |
|
||||
encoding = encoding || "ascii"; |
|
||||
this.outputEncodings.push(encoding); |
|
||||
}; |
|
||||
|
|
||||
OutgoingMessage.prototype.sendHeaderLines = function (first_line, headers) { |
|
||||
var sent_connection_header = false; |
|
||||
var sent_content_length_header = false; |
|
||||
var sent_transfer_encoding_header = false; |
|
||||
|
|
||||
// first_line in the case of request is: "GET /index.html HTTP/1.1\r\n"
|
|
||||
// in the case of response it is: "HTTP/1.1 200 OK\r\n"
|
|
||||
var message_header = first_line; |
|
||||
var field, value; |
|
||||
for (var i in headers) { |
|
||||
if (headers[i] instanceof Array) { |
|
||||
field = headers[i][0]; |
|
||||
value = headers[i][1]; |
|
||||
} else { |
|
||||
if (!headers.hasOwnProperty(i)) continue; |
|
||||
field = i; |
|
||||
value = headers[i]; |
|
||||
} |
|
||||
|
|
||||
message_header += field + ": " + value + CRLF; |
|
||||
|
|
||||
if (connection_expression.test(field)) { |
|
||||
sent_connection_header = true; |
|
||||
if (close_expression.test(value)) this.closeOnFinish = true; |
|
||||
|
|
||||
} else if (transfer_encoding_expression.test(field)) { |
|
||||
sent_transfer_encoding_header = true; |
|
||||
if (chunk_expression.test(value)) this.chunked_encoding = true; |
|
||||
|
|
||||
} else if (content_length_expression.test(field)) { |
|
||||
sent_content_length_header = true; |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// keep-alive logic
|
|
||||
if (sent_connection_header == false) { |
|
||||
if (this.should_keep_alive && |
|
||||
(sent_content_length_header || this.use_chunked_encoding_by_default)) { |
|
||||
message_header += "Connection: keep-alive\r\n"; |
|
||||
} else { |
|
||||
this.closeOnFinish = true; |
|
||||
message_header += "Connection: close\r\n"; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
if (sent_content_length_header == false && sent_transfer_encoding_header == false) { |
|
||||
if (this.use_chunked_encoding_by_default) { |
|
||||
message_header += "Transfer-Encoding: chunked\r\n"; |
|
||||
this.chunked_encoding = true; |
|
||||
} |
|
||||
else { |
|
||||
this.closeOnFinish = true; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
message_header += CRLF; |
|
||||
|
|
||||
this._send(message_header); |
|
||||
// wait until the first body chunk, or close(), is sent to flush.
|
|
||||
}; |
|
||||
|
|
||||
|
|
||||
OutgoingMessage.prototype.sendBody = function () { |
|
||||
throw new Error("sendBody() has been renamed to write(). " + |
|
||||
"The 'body' event has been renamed to 'data' and " + |
|
||||
"the 'complete' event has been renamed to 'end'."); |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
OutgoingMessage.prototype.write = function (chunk, encoding) { |
|
||||
if ( (this instanceof ServerResponse) && !this.headWritten) { |
|
||||
throw new Error("writeHead() must be called before write()") |
|
||||
} |
|
||||
|
|
||||
encoding = encoding || "ascii"; |
|
||||
if (this.chunked_encoding) { |
|
||||
this._send(process._byteLength(chunk, encoding).toString(16)); |
|
||||
this._send(CRLF); |
|
||||
this._send(chunk, encoding); |
|
||||
this._send(CRLF); |
|
||||
} else { |
|
||||
this._send(chunk, encoding); |
|
||||
} |
|
||||
|
|
||||
if (this.flushing) { |
|
||||
this.flush(); |
|
||||
} else { |
|
||||
this.flushing = true; |
|
||||
} |
|
||||
}; |
|
||||
|
|
||||
OutgoingMessage.prototype.flush = function () { |
|
||||
this.emit("flush"); |
|
||||
}; |
|
||||
|
|
||||
OutgoingMessage.prototype.finish = function () { |
|
||||
throw new Error("finish() has been renamed to close()."); |
|
||||
}; |
|
||||
|
|
||||
OutgoingMessage.prototype.close = function () { |
|
||||
if (this.chunked_encoding) this._send("0\r\n\r\n"); // last chunk
|
|
||||
this.finished = true; |
|
||||
this.flush(); |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
function ServerResponse (req) { |
|
||||
OutgoingMessage.call(this, req.connection); |
|
||||
|
|
||||
if (req.httpVersionMajor < 1 || req.httpVersionMinor < 1) { |
|
||||
this.use_chunked_encoding_by_default = false; |
|
||||
this.should_keep_alive = false; |
|
||||
} |
|
||||
} |
|
||||
sys.inherits(ServerResponse, OutgoingMessage); |
|
||||
exports.ServerResponse = ServerResponse; |
|
||||
|
|
||||
|
|
||||
ServerResponse.prototype.writeHead = function (statusCode) { |
|
||||
var reasonPhrase, headers, headerIndex; |
|
||||
|
|
||||
if (typeof arguments[1] == 'string') { |
|
||||
reasonPhrase = arguments[1]; |
|
||||
headerIndex = 2; |
|
||||
} else { |
|
||||
reasonPhrase = STATUS_CODES[statusCode] || "unknown"; |
|
||||
headerIndex = 1; |
|
||||
} |
|
||||
|
|
||||
if (typeof arguments[headerIndex] == 'object') { |
|
||||
headers = arguments[headerIndex]; |
|
||||
} else { |
|
||||
headers = {}; |
|
||||
} |
|
||||
|
|
||||
var status_line = "HTTP/1.1 " + statusCode.toString() + " " |
|
||||
+ reasonPhrase + CRLF; |
|
||||
this.sendHeaderLines(status_line, headers); |
|
||||
this.headWritten = true; |
|
||||
}; |
|
||||
|
|
||||
// TODO eventually remove sendHeader(), writeHeader()
|
|
||||
ServerResponse.prototype.sendHeader = ServerResponse.prototype.writeHead; |
|
||||
ServerResponse.prototype.writeHeader = ServerResponse.prototype.writeHead; |
|
||||
|
|
||||
function ClientRequest (connection, method, url, headers) { |
|
||||
OutgoingMessage.call(this, connection); |
|
||||
|
|
||||
this.should_keep_alive = false; |
|
||||
if (method === "GET" || method === "HEAD") { |
|
||||
this.use_chunked_encoding_by_default = false; |
|
||||
} else { |
|
||||
this.use_chunked_encoding_by_default = true; |
|
||||
} |
|
||||
this.closeOnFinish = true; |
|
||||
|
|
||||
this.sendHeaderLines(method + " " + url + " HTTP/1.1\r\n", headers); |
|
||||
} |
|
||||
sys.inherits(ClientRequest, OutgoingMessage); |
|
||||
exports.ClientRequest = ClientRequest; |
|
||||
|
|
||||
ClientRequest.prototype.finish = function () { |
|
||||
throw new Error( "finish() has been renamed to close() and no longer takes " |
|
||||
+ "a response handler as an argument. Manually add a 'response' listener " |
|
||||
+ "to the request object." |
|
||||
); |
|
||||
}; |
|
||||
|
|
||||
ClientRequest.prototype.close = function () { |
|
||||
if (arguments.length > 0) { |
|
||||
throw new Error( "ClientRequest.prototype.close does not take any arguments. " |
|
||||
+ "Add a response listener manually to the request object." |
|
||||
); |
|
||||
} |
|
||||
OutgoingMessage.prototype.close.call(this); |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
function createIncomingMessageStream (connection, incoming_listener) { |
|
||||
var incoming, field, value; |
|
||||
|
|
||||
connection.addListener("messageBegin", function () { |
|
||||
incoming = new IncomingMessage(connection); |
|
||||
field = null; |
|
||||
value = null; |
|
||||
}); |
|
||||
|
|
||||
// Only servers will get URL events.
|
|
||||
connection.addListener("url", function (data) { |
|
||||
incoming.url += data; |
|
||||
}); |
|
||||
|
|
||||
connection.addListener("headerField", function (data) { |
|
||||
if (value) { |
|
||||
incoming._addHeaderLine(field, value); |
|
||||
field = null; |
|
||||
value = null; |
|
||||
} |
|
||||
if (field) { |
|
||||
field += data; |
|
||||
} else { |
|
||||
field = data; |
|
||||
} |
|
||||
}); |
|
||||
|
|
||||
connection.addListener("headerValue", function (data) { |
|
||||
if (value) { |
|
||||
value += data; |
|
||||
} else { |
|
||||
value = data; |
|
||||
} |
|
||||
}); |
|
||||
|
|
||||
connection.addListener("headerComplete", function (info) { |
|
||||
if (field && value) { |
|
||||
incoming._addHeaderLine(field, value); |
|
||||
} |
|
||||
|
|
||||
incoming.httpVersion = info.httpVersion; |
|
||||
incoming.httpVersionMajor = info.versionMajor; |
|
||||
incoming.httpVersionMinor = info.versionMinor; |
|
||||
|
|
||||
if (info.method) { |
|
||||
// server only
|
|
||||
incoming.method = info.method; |
|
||||
} else { |
|
||||
// client only
|
|
||||
incoming.statusCode = info.statusCode; |
|
||||
} |
|
||||
|
|
||||
incoming_listener(incoming, info.should_keep_alive); |
|
||||
}); |
|
||||
|
|
||||
connection.addListener("body", function (chunk) { |
|
||||
incoming.emit('data', chunk); |
|
||||
}); |
|
||||
|
|
||||
connection.addListener("messageComplete", function () { |
|
||||
incoming.emit('end'); |
|
||||
}); |
|
||||
} |
|
||||
|
|
||||
/* Returns true if the message queue is finished and the connection |
|
||||
* should be closed. */ |
|
||||
function flushMessageQueue (connection, queue) { |
|
||||
while (queue[0]) { |
|
||||
var message = queue[0]; |
|
||||
|
|
||||
while (message.output.length > 0) { |
|
||||
if (connection.readyState !== "open" && connection.readyState !== "writeOnly") { |
|
||||
return true; |
|
||||
} |
|
||||
|
|
||||
var data = message.output.shift(); |
|
||||
var encoding = message.outputEncodings.shift(); |
|
||||
|
|
||||
connection.write(data, encoding); |
|
||||
} |
|
||||
|
|
||||
if (!message.finished) break; |
|
||||
|
|
||||
message.emit("sent"); |
|
||||
queue.shift(); |
|
||||
|
|
||||
if (message.closeOnFinish) return true; |
|
||||
} |
|
||||
return false; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
exports.createServer = function (requestListener, options) { |
|
||||
var server = new http.Server(); |
|
||||
//server.setOptions(options);
|
|
||||
server.addListener("request", requestListener); |
|
||||
server.addListener("connection", connectionListener); |
|
||||
return server; |
|
||||
}; |
|
||||
|
|
||||
function connectionListener (connection) { |
|
||||
// An array of responses for each connection. In pipelined connections
|
|
||||
// we need to keep track of the order they were sent.
|
|
||||
var responses = []; |
|
||||
|
|
||||
connection.resetParser(); |
|
||||
|
|
||||
// is this really needed?
|
|
||||
connection.addListener("end", function () { |
|
||||
if (responses.length == 0) { |
|
||||
connection.close(); |
|
||||
} else { |
|
||||
responses[responses.length-1].closeOnFinish = true; |
|
||||
} |
|
||||
}); |
|
||||
|
|
||||
|
|
||||
createIncomingMessageStream(connection, function (incoming, should_keep_alive) { |
|
||||
var req = incoming; |
|
||||
|
|
||||
var res = new ServerResponse(req); |
|
||||
res.should_keep_alive = should_keep_alive; |
|
||||
res.addListener("flush", function () { |
|
||||
if (flushMessageQueue(connection, responses)) { |
|
||||
connection.close(); |
|
||||
} |
|
||||
}); |
|
||||
responses.push(res); |
|
||||
|
|
||||
connection.server.emit("request", req, res); |
|
||||
}); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
exports.createClient = function (port, host) { |
|
||||
var client = new http.Client(); |
|
||||
var secure_credentials={ secure : false }; |
|
||||
|
|
||||
var requests = []; |
|
||||
var currentRequest; |
|
||||
|
|
||||
client.tcpSetSecure = client.setSecure; |
|
||||
client.setSecure = function(format_type, ca_certs, crl_list, private_key, certificate) { |
|
||||
secure_credentials.secure = true; |
|
||||
secure_credentials.format_type = format_type; |
|
||||
secure_credentials.ca_certs = ca_certs; |
|
||||
secure_credentials.crl_list = crl_list; |
|
||||
secure_credentials.private_key = private_key; |
|
||||
secure_credentials.certificate = certificate; |
|
||||
} |
|
||||
|
|
||||
client._reconnect = function () { |
|
||||
if (client.readyState != "opening") { |
|
||||
//sys.debug("HTTP CLIENT: reconnecting readyState = " + client.readyState);
|
|
||||
client.connect(port, host); |
|
||||
if (secure_credentials.secure) { |
|
||||
client.tcpSetSecure(secure_credentials.format_type, |
|
||||
secure_credentials.ca_certs, |
|
||||
secure_credentials.crl_list, |
|
||||
secure_credentials.private_key, |
|
||||
secure_credentials.certificate); |
|
||||
} |
|
||||
} |
|
||||
}; |
|
||||
|
|
||||
client._pushRequest = function (req) { |
|
||||
req.addListener("flush", function () { |
|
||||
if (client.readyState == "closed") { |
|
||||
//sys.debug("HTTP CLIENT request flush. reconnect. readyState = " + client.readyState);
|
|
||||
client._reconnect(); |
|
||||
return; |
|
||||
} |
|
||||
//sys.debug("client flush readyState = " + client.readyState);
|
|
||||
if (req == currentRequest) flushMessageQueue(client, [req]); |
|
||||
}); |
|
||||
requests.push(req); |
|
||||
}; |
|
||||
|
|
||||
client.addListener("connect", function () { |
|
||||
client.resetParser(); |
|
||||
currentRequest = requests.shift(); |
|
||||
currentRequest.flush(); |
|
||||
}); |
|
||||
|
|
||||
client.addListener("end", function () { |
|
||||
//sys.debug("client got end closing. readyState = " + client.readyState);
|
|
||||
client.close(); |
|
||||
}); |
|
||||
|
|
||||
client.addListener("close", function (had_error) { |
|
||||
if (had_error) { |
|
||||
client.emit("error"); |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
//sys.debug("HTTP CLIENT onClose. readyState = " + client.readyState);
|
|
||||
|
|
||||
// If there are more requests to handle, reconnect.
|
|
||||
if (requests.length > 0) { |
|
||||
client._reconnect(); |
|
||||
} |
|
||||
}); |
|
||||
|
|
||||
createIncomingMessageStream(client, function (res) { |
|
||||
//sys.debug("incoming response!");
|
|
||||
|
|
||||
res.addListener('end', function ( ) { |
|
||||
//sys.debug("request complete disconnecting. readyState = " + client.readyState);
|
|
||||
client.close(); |
|
||||
}); |
|
||||
|
|
||||
currentRequest.emit("response", res); |
|
||||
}); |
|
||||
|
|
||||
return client; |
|
||||
}; |
|
||||
|
|
||||
http.Client.prototype.get = function () { |
|
||||
throw new Error("client.get(...) is now client.request('GET', ...)"); |
|
||||
}; |
|
||||
|
|
||||
http.Client.prototype.head = function () { |
|
||||
throw new Error("client.head(...) is now client.request('HEAD', ...)"); |
|
||||
}; |
|
||||
|
|
||||
http.Client.prototype.post = function () { |
|
||||
throw new Error("client.post(...) is now client.request('POST', ...)"); |
|
||||
}; |
|
||||
|
|
||||
http.Client.prototype.del = function () { |
|
||||
throw new Error("client.del(...) is now client.request('DELETE', ...)"); |
|
||||
}; |
|
||||
|
|
||||
http.Client.prototype.put = function () { |
|
||||
throw new Error("client.put(...) is now client.request('PUT', ...)"); |
|
||||
}; |
|
||||
|
|
||||
http.Client.prototype.request = function (method, url, headers) { |
|
||||
if (typeof(url) != "string") { // assume method was omitted, shift arguments
|
|
||||
headers = url; |
|
||||
url = method; |
|
||||
method = null; |
|
||||
} |
|
||||
var req = new ClientRequest(this, method || "GET", url, headers); |
|
||||
this._pushRequest(req); |
|
||||
return req; |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
exports.cat = function (url, encoding_, headers_) { |
|
||||
var encoding = 'utf8', |
|
||||
headers = {}, |
|
||||
callback = null; |
|
||||
|
|
||||
// parse the arguments for the various options... very ugly
|
|
||||
if (typeof(arguments[1]) == 'string') { |
|
||||
encoding = arguments[1]; |
|
||||
if (typeof(arguments[2]) == 'object') { |
|
||||
headers = arguments[2]; |
|
||||
if (typeof(arguments[3]) == 'function') callback = arguments[3]; |
|
||||
} else { |
|
||||
if (typeof(arguments[2]) == 'function') callback = arguments[2]; |
|
||||
} |
|
||||
} else { |
|
||||
// didn't specify encoding
|
|
||||
if (typeof(arguments[1]) == 'object') { |
|
||||
headers = arguments[1]; |
|
||||
callback = arguments[2]; |
|
||||
} else { |
|
||||
callback = arguments[1]; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
var url = require("url").parse(url); |
|
||||
|
|
||||
var hasHost = false; |
|
||||
for (var i in headers) { |
|
||||
if (i.toLowerCase() === "host") { |
|
||||
hasHost = true; |
|
||||
break; |
|
||||
} |
|
||||
} |
|
||||
if (!hasHost) headers["Host"] = url.hostname; |
|
||||
|
|
||||
var content = ""; |
|
||||
|
|
||||
var client = exports.createClient(url.port || 80, url.hostname); |
|
||||
var req = client.request((url.pathname || "/")+(url.search || "")+(url.hash || ""), headers); |
|
||||
|
|
||||
req.addListener('response', function (res) { |
|
||||
if (res.statusCode < 200 || res.statusCode >= 300) { |
|
||||
if (callback) callback(res.statusCode); |
|
||||
client.close(); |
|
||||
return; |
|
||||
} |
|
||||
res.setBodyEncoding(encoding); |
|
||||
res.addListener('data', function (chunk) { content += chunk; }); |
|
||||
res.addListener('end', function () { |
|
||||
if (callback) callback(null, content); |
|
||||
}); |
|
||||
}); |
|
||||
|
|
||||
client.addListener("error", function (err) { |
|
||||
// todo an error should actually be passed here...
|
|
||||
if (callback) callback(new Error('Connection error')); |
|
||||
}); |
|
||||
|
|
||||
req.close(); |
|
||||
}; |
|
||||
@ -1,26 +0,0 @@ |
|||||
var tcp = process.binding('tcp'); |
|
||||
|
|
||||
var TLS_STATUS_CODES = { |
|
||||
1 : 'JS_GNUTLS_CERT_VALIDATED', |
|
||||
0 : 'JS_GNUTLS_CERT_UNDEFINED', |
|
||||
} |
|
||||
TLS_STATUS_CODES[-100] = 'JS_GNUTLS_CERT_SIGNER_NOT_FOUND'; |
|
||||
TLS_STATUS_CODES[-101] = 'JS_GNUTLS_CERT_SIGNER_NOT_CA'; |
|
||||
TLS_STATUS_CODES[-102] = 'JS_GNUTLS_CERT_INVALID'; |
|
||||
TLS_STATUS_CODES[-103] = 'JS_GNUTLS_CERT_NOT_ACTIVATED'; |
|
||||
TLS_STATUS_CODES[-104] = 'JS_GNUTLS_CERT_EXPIRED'; |
|
||||
TLS_STATUS_CODES[-105] = 'JS_GNUTLS_CERT_REVOKED'; |
|
||||
TLS_STATUS_CODES[-106] = 'JS_GNUTLS_CERT_DOES_NOT_MATCH_HOSTNAME'; |
|
||||
|
|
||||
exports.createServer = function (on_connection, options) { |
|
||||
var server = new tcp.Server(); |
|
||||
server.addListener("connection", on_connection); |
|
||||
//server.setOptions(options);
|
|
||||
return server; |
|
||||
}; |
|
||||
|
|
||||
exports.createConnection = function (port, host) { |
|
||||
var connection = new tcp.Connection(); |
|
||||
connection.connect(port, host); |
|
||||
return connection; |
|
||||
}; |
|
||||
@ -1,392 +0,0 @@ |
|||||
#include <node_http.h> |
|
||||
|
|
||||
#include <assert.h> |
|
||||
#include <stdio.h> |
|
||||
#include <strings.h> |
|
||||
|
|
||||
using namespace v8; |
|
||||
using namespace node; |
|
||||
|
|
||||
Persistent<FunctionTemplate> HTTPConnection::client_constructor_template; |
|
||||
Persistent<FunctionTemplate> HTTPConnection::server_constructor_template; |
|
||||
|
|
||||
static Persistent<String> method_symbol; |
|
||||
static Persistent<String> status_code_symbol; |
|
||||
static Persistent<String> http_version_symbol; |
|
||||
static Persistent<String> version_major_symbol; |
|
||||
static Persistent<String> version_minor_symbol; |
|
||||
static Persistent<String> should_keep_alive_symbol; |
|
||||
|
|
||||
static Persistent<String> message_begin_symbol; |
|
||||
static Persistent<String> message_complete_symbol; |
|
||||
static Persistent<String> url_symbol; |
|
||||
static Persistent<String> query_string_symbol; |
|
||||
static Persistent<String> path_symbol; |
|
||||
static Persistent<String> fragment_symbol; |
|
||||
static Persistent<String> header_field_symbol; |
|
||||
static Persistent<String> header_value_symbol; |
|
||||
static Persistent<String> header_complete_symbol; |
|
||||
static Persistent<String> body_symbol; |
|
||||
static Persistent<String> end_symbol; |
|
||||
|
|
||||
static Persistent<String> delete_sym; |
|
||||
static Persistent<String> get_sym; |
|
||||
static Persistent<String> head_sym; |
|
||||
static Persistent<String> post_sym; |
|
||||
static Persistent<String> put_sym; |
|
||||
static Persistent<String> connect_sym; |
|
||||
static Persistent<String> options_sym; |
|
||||
static Persistent<String> trace_sym; |
|
||||
static Persistent<String> copy_sym; |
|
||||
static Persistent<String> lock_sym; |
|
||||
static Persistent<String> mkcol_sym; |
|
||||
static Persistent<String> move_sym; |
|
||||
static Persistent<String> propfind_sym; |
|
||||
static Persistent<String> proppatch_sym; |
|
||||
static Persistent<String> unlock_sym; |
|
||||
static Persistent<String> unknown_method_sym; |
|
||||
|
|
||||
static struct http_parser_settings settings; |
|
||||
|
|
||||
void |
|
||||
HTTPConnection::Initialize (Handle<Object> target) |
|
||||
{ |
|
||||
HandleScope scope; |
|
||||
|
|
||||
Local<FunctionTemplate> t = FunctionTemplate::New(NewClient); |
|
||||
client_constructor_template = Persistent<FunctionTemplate>::New(t); |
|
||||
client_constructor_template->Inherit(Connection::constructor_template); |
|
||||
client_constructor_template->InstanceTemplate()->SetInternalFieldCount(1); |
|
||||
client_constructor_template->SetClassName(String::NewSymbol("Client")); |
|
||||
NODE_SET_PROTOTYPE_METHOD(client_constructor_template, "resetParser", ResetParser); |
|
||||
target->Set(String::NewSymbol("Client"), client_constructor_template->GetFunction()); |
|
||||
|
|
||||
t = FunctionTemplate::New(NewServer); |
|
||||
server_constructor_template = Persistent<FunctionTemplate>::New(t); |
|
||||
server_constructor_template->Inherit(Connection::constructor_template); |
|
||||
server_constructor_template->InstanceTemplate()->SetInternalFieldCount(1); |
|
||||
NODE_SET_PROTOTYPE_METHOD(server_constructor_template, "resetParser", ResetParser); |
|
||||
server_constructor_template->SetClassName(String::NewSymbol("ServerSideConnection")); |
|
||||
|
|
||||
end_symbol = NODE_PSYMBOL("end"); |
|
||||
|
|
||||
settings.on_message_begin = on_message_begin; |
|
||||
settings.on_path = on_path; |
|
||||
settings.on_query_string = on_query_string; |
|
||||
settings.on_url = on_url; |
|
||||
settings.on_fragment = on_fragment; |
|
||||
settings.on_header_field = on_header_field; |
|
||||
settings.on_header_value = on_header_value; |
|
||||
settings.on_headers_complete = on_headers_complete; |
|
||||
settings.on_body = on_body; |
|
||||
settings.on_message_complete = on_message_complete; |
|
||||
} |
|
||||
|
|
||||
Handle<Value> |
|
||||
HTTPConnection::NewClient (const Arguments& args) |
|
||||
{ |
|
||||
HandleScope scope; |
|
||||
|
|
||||
HTTPConnection *connection = new HTTPConnection(HTTP_RESPONSE); |
|
||||
connection->Wrap(args.This()); |
|
||||
|
|
||||
return args.This(); |
|
||||
} |
|
||||
|
|
||||
Handle<Value> |
|
||||
HTTPConnection::NewServer (const Arguments& args) |
|
||||
{ |
|
||||
HandleScope scope; |
|
||||
|
|
||||
HTTPConnection *connection = new HTTPConnection(HTTP_REQUEST); |
|
||||
connection->Wrap(args.This()); |
|
||||
|
|
||||
return args.This(); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
Handle<Value> HTTPConnection::ResetParser(const Arguments& args) { |
|
||||
HandleScope scope; |
|
||||
HTTPConnection *connection = ObjectWrap::Unwrap<HTTPConnection>(args.Holder()); |
|
||||
connection->ResetParser(); |
|
||||
return Undefined(); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void |
|
||||
HTTPConnection::OnReceive (const void *buf, size_t len) |
|
||||
{ |
|
||||
HandleScope scope; |
|
||||
|
|
||||
assert(refs_); |
|
||||
size_t nparsed; |
|
||||
|
|
||||
nparsed = http_parser_execute(&parser_, settings, static_cast<const char*>(buf), len); |
|
||||
|
|
||||
if (nparsed != len) { |
|
||||
ForceClose(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
void |
|
||||
HTTPConnection::OnEOF () |
|
||||
{ |
|
||||
HandleScope scope; |
|
||||
assert(refs_); |
|
||||
size_t nparsed; |
|
||||
nparsed = http_parser_execute(&parser_, settings, NULL, 0); |
|
||||
Emit(end_symbol, 0, NULL); |
|
||||
} |
|
||||
|
|
||||
int |
|
||||
HTTPConnection::on_message_begin (http_parser *parser) |
|
||||
{ |
|
||||
if (message_begin_symbol.IsEmpty()) { |
|
||||
method_symbol = NODE_PSYMBOL("method"); |
|
||||
status_code_symbol = NODE_PSYMBOL("statusCode"); |
|
||||
http_version_symbol = NODE_PSYMBOL("httpVersion"); |
|
||||
version_major_symbol = NODE_PSYMBOL("versionMajor"); |
|
||||
version_minor_symbol = NODE_PSYMBOL("versionMinor"); |
|
||||
should_keep_alive_symbol = NODE_PSYMBOL("should_keep_alive"); |
|
||||
|
|
||||
message_begin_symbol = NODE_PSYMBOL("messageBegin"); |
|
||||
message_complete_symbol = NODE_PSYMBOL("messageComplete"); |
|
||||
url_symbol = NODE_PSYMBOL("url"); |
|
||||
query_string_symbol = NODE_PSYMBOL("queryString"); |
|
||||
path_symbol = NODE_PSYMBOL("path"); |
|
||||
fragment_symbol = NODE_PSYMBOL("fragment"); |
|
||||
header_field_symbol = NODE_PSYMBOL("headerField"); |
|
||||
header_value_symbol = NODE_PSYMBOL("headerValue"); |
|
||||
header_complete_symbol = NODE_PSYMBOL("headerComplete"); |
|
||||
body_symbol = NODE_PSYMBOL("body"); |
|
||||
|
|
||||
delete_sym = NODE_PSYMBOL("DELETE"); |
|
||||
get_sym = NODE_PSYMBOL("GET"); |
|
||||
head_sym = NODE_PSYMBOL("HEAD"); |
|
||||
post_sym = NODE_PSYMBOL("POST"); |
|
||||
put_sym = NODE_PSYMBOL("PUT"); |
|
||||
connect_sym = NODE_PSYMBOL("CONNECT"); |
|
||||
options_sym = NODE_PSYMBOL("OPTIONS"); |
|
||||
trace_sym = NODE_PSYMBOL("TRACE"); |
|
||||
copy_sym = NODE_PSYMBOL("COPY"); |
|
||||
lock_sym = NODE_PSYMBOL("LOCK"); |
|
||||
mkcol_sym = NODE_PSYMBOL("MKCOL"); |
|
||||
move_sym = NODE_PSYMBOL("MOVE"); |
|
||||
propfind_sym = NODE_PSYMBOL("PROPFIND"); |
|
||||
proppatch_sym = NODE_PSYMBOL("PROPPATCH"); |
|
||||
unlock_sym = NODE_PSYMBOL("UNLOCK"); |
|
||||
unknown_method_sym = NODE_PSYMBOL("UNKNOWN_METHOD"); |
|
||||
} |
|
||||
|
|
||||
HTTPConnection *connection = static_cast<HTTPConnection*> (parser->data); |
|
||||
assert(connection->refs_); |
|
||||
connection->Emit(message_begin_symbol, 0, NULL); |
|
||||
return 0; |
|
||||
} |
|
||||
|
|
||||
int |
|
||||
HTTPConnection::on_message_complete (http_parser *parser) |
|
||||
{ |
|
||||
HTTPConnection *connection = static_cast<HTTPConnection*> (parser->data); |
|
||||
assert(connection->refs_); |
|
||||
connection->Emit(message_complete_symbol, 0, NULL); |
|
||||
return 0; |
|
||||
} |
|
||||
|
|
||||
int |
|
||||
HTTPConnection::on_url (http_parser *parser, const char *buf, size_t len) |
|
||||
{ |
|
||||
HTTPConnection *connection = static_cast<HTTPConnection*>(parser->data); |
|
||||
assert(connection->refs_); |
|
||||
Local<Value> argv[1] = { String::New(buf, len) }; |
|
||||
connection->Emit(url_symbol, 1, argv); |
|
||||
return 0; |
|
||||
} |
|
||||
|
|
||||
int |
|
||||
HTTPConnection::on_query_string (http_parser *parser, const char *buf, size_t len) |
|
||||
{ |
|
||||
HTTPConnection *connection = static_cast<HTTPConnection*>(parser->data); |
|
||||
assert(connection->refs_); |
|
||||
Local<Value> argv[1] = { String::New(buf, len) }; |
|
||||
connection->Emit(query_string_symbol, 1, argv); |
|
||||
return 0; |
|
||||
} |
|
||||
|
|
||||
int |
|
||||
HTTPConnection::on_path (http_parser *parser, const char *buf, size_t len) |
|
||||
{ |
|
||||
HTTPConnection *connection = static_cast<HTTPConnection*>(parser->data); |
|
||||
assert(connection->refs_); |
|
||||
Local<Value> argv[1] = { String::New(buf, len) }; |
|
||||
connection->Emit(path_symbol, 1, argv); |
|
||||
return 0; |
|
||||
} |
|
||||
|
|
||||
int |
|
||||
HTTPConnection::on_fragment (http_parser *parser, const char *buf, size_t len) |
|
||||
{ |
|
||||
HTTPConnection *connection = static_cast<HTTPConnection*>(parser->data); |
|
||||
assert(connection->refs_); |
|
||||
Local<Value> argv[1] = { String::New(buf, len) }; |
|
||||
connection->Emit(fragment_symbol, 1, argv); |
|
||||
return 0; |
|
||||
} |
|
||||
|
|
||||
const static char normalizer[] = |
|
||||
"\0------------------------------" |
|
||||
"-----------------0123456789-----" |
|
||||
"--abcdefghijklmnopqrstuvwxyz----" |
|
||||
"--abcdefghijklmnopqrstuvwxyz----" |
|
||||
"--------------------------------" |
|
||||
"--------------------------------" |
|
||||
"--------------------------------" |
|
||||
"--------------------------------"; |
|
||||
|
|
||||
int |
|
||||
HTTPConnection::on_header_field (http_parser *parser, const char *buf, size_t len) |
|
||||
{ |
|
||||
HTTPConnection *connection = static_cast<HTTPConnection*>(parser->data); |
|
||||
assert(connection->refs_); |
|
||||
|
|
||||
// NORMALIZE
|
|
||||
size_t i; |
|
||||
char *nonconstbuf = (char*)buf; // FIXME
|
|
||||
for (i = 0; i < len; i++) { nonconstbuf[i] = normalizer[buf[i]]; } |
|
||||
|
|
||||
Local<Value> argv[1] = { String::New(buf, len) }; |
|
||||
connection->Emit(header_field_symbol, 1, argv); |
|
||||
return 0; |
|
||||
} |
|
||||
|
|
||||
int |
|
||||
HTTPConnection::on_header_value (http_parser *parser, const char *buf, size_t len) |
|
||||
{ |
|
||||
HTTPConnection *connection = static_cast<HTTPConnection*>(parser->data); |
|
||||
assert(connection->refs_); |
|
||||
|
|
||||
Local<Value> argv[1] = { String::New(buf, len) }; |
|
||||
connection->Emit(header_value_symbol, 1, argv); |
|
||||
return 0; |
|
||||
} |
|
||||
|
|
||||
static inline Persistent<String> |
|
||||
method_to_str(enum http_method m) { |
|
||||
switch (m) { |
|
||||
case HTTP_DELETE: return delete_sym; |
|
||||
case HTTP_GET: return get_sym; |
|
||||
case HTTP_HEAD: return head_sym; |
|
||||
case HTTP_POST: return post_sym; |
|
||||
case HTTP_PUT: return put_sym; |
|
||||
case HTTP_CONNECT: return connect_sym; |
|
||||
case HTTP_OPTIONS: return options_sym; |
|
||||
case HTTP_TRACE: return trace_sym; |
|
||||
case HTTP_COPY: return copy_sym; |
|
||||
case HTTP_LOCK: return lock_sym; |
|
||||
case HTTP_MKCOL: return mkcol_sym; |
|
||||
case HTTP_MOVE: return move_sym; |
|
||||
case HTTP_PROPFIND: return propfind_sym; |
|
||||
case HTTP_PROPPATCH: return proppatch_sym; |
|
||||
case HTTP_UNLOCK: return unlock_sym; |
|
||||
default: return unknown_method_sym; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
int |
|
||||
HTTPConnection::on_headers_complete (http_parser *parser) |
|
||||
{ |
|
||||
HTTPConnection *connection = static_cast<HTTPConnection*> (parser->data); |
|
||||
assert(connection->refs_); |
|
||||
|
|
||||
Local<Object> message_info = Object::New(); |
|
||||
|
|
||||
// METHOD
|
|
||||
if (connection->type_ == HTTP_REQUEST) { |
|
||||
message_info->Set(method_symbol, method_to_str(connection->parser_.method)); |
|
||||
} |
|
||||
|
|
||||
// STATUS
|
|
||||
if (connection->type_ == HTTP_RESPONSE) { |
|
||||
message_info->Set(status_code_symbol, |
|
||||
Integer::New(connection->parser_.status_code)); |
|
||||
} |
|
||||
|
|
||||
// VERSION
|
|
||||
char version[10]; |
|
||||
snprintf( version |
|
||||
, 10 |
|
||||
, "%d.%d" |
|
||||
, connection->parser_.http_major |
|
||||
, connection->parser_.http_minor |
|
||||
); |
|
||||
message_info->Set(http_version_symbol, String::New(version)); |
|
||||
message_info->Set(version_major_symbol, |
|
||||
Integer::New(connection->parser_.http_major)); |
|
||||
message_info->Set(version_minor_symbol, |
|
||||
Integer::New(connection->parser_.http_minor)); |
|
||||
|
|
||||
message_info->Set(should_keep_alive_symbol, |
|
||||
http_should_keep_alive(&connection->parser_) ? True() : False()); |
|
||||
|
|
||||
Local<Value> argv[1] = { message_info }; |
|
||||
|
|
||||
connection->Emit(header_complete_symbol, 1, argv); |
|
||||
|
|
||||
return 0; |
|
||||
} |
|
||||
|
|
||||
int |
|
||||
HTTPConnection::on_body (http_parser *parser, const char *buf, size_t len) |
|
||||
{ |
|
||||
assert(len != 0); |
|
||||
|
|
||||
HTTPConnection *connection = static_cast<HTTPConnection*> (parser->data); |
|
||||
assert(connection->refs_); |
|
||||
|
|
||||
// TODO each message should have their encoding.
|
|
||||
// don't look at the conneciton for encoding
|
|
||||
Local<Value> data = Encode(buf, len, connection->encoding_); |
|
||||
connection->Emit(body_symbol, 1, &data); |
|
||||
|
|
||||
return 0; |
|
||||
} |
|
||||
|
|
||||
Persistent<FunctionTemplate> HTTPServer::constructor_template; |
|
||||
|
|
||||
void |
|
||||
HTTPServer::Initialize (Handle<Object> target) |
|
||||
{ |
|
||||
HandleScope scope; |
|
||||
|
|
||||
Local<FunctionTemplate> t = FunctionTemplate::New(New); |
|
||||
constructor_template = Persistent<FunctionTemplate>::New(t); |
|
||||
constructor_template->Inherit(Server::constructor_template); |
|
||||
constructor_template->InstanceTemplate()->SetInternalFieldCount(1); |
|
||||
constructor_template->SetClassName(String::NewSymbol("Server")); |
|
||||
target->Set(String::NewSymbol("Server"), constructor_template->GetFunction()); |
|
||||
} |
|
||||
|
|
||||
Handle<Value> |
|
||||
HTTPServer::New (const Arguments& args) |
|
||||
{ |
|
||||
HandleScope scope; |
|
||||
|
|
||||
HTTPServer *server = new HTTPServer(); |
|
||||
server->Wrap(args.This()); |
|
||||
|
|
||||
return args.This(); |
|
||||
} |
|
||||
|
|
||||
Handle<FunctionTemplate> |
|
||||
HTTPServer::GetConnectionTemplate (void) |
|
||||
{ |
|
||||
return HTTPConnection::server_constructor_template; |
|
||||
} |
|
||||
|
|
||||
Connection* |
|
||||
HTTPServer::UnwrapConnection (Local<Object> connection) |
|
||||
{ |
|
||||
HandleScope scope; |
|
||||
return ObjectWrap::Unwrap<HTTPConnection>(connection); |
|
||||
} |
|
||||
|
|
||||
@ -1,68 +0,0 @@ |
|||||
#ifndef node_http_h |
|
||||
#define node_http_h |
|
||||
|
|
||||
#include <node_net.h> |
|
||||
#include <v8.h> |
|
||||
#include <http_parser.h> |
|
||||
|
|
||||
namespace node { |
|
||||
|
|
||||
class HTTPConnection : public Connection { |
|
||||
public: |
|
||||
static void Initialize (v8::Handle<v8::Object> target); |
|
||||
|
|
||||
static v8::Persistent<v8::FunctionTemplate> client_constructor_template; |
|
||||
static v8::Persistent<v8::FunctionTemplate> server_constructor_template; |
|
||||
|
|
||||
protected: |
|
||||
static v8::Handle<v8::Value> NewClient (const v8::Arguments& args); |
|
||||
static v8::Handle<v8::Value> NewServer (const v8::Arguments& args); |
|
||||
static v8::Handle<v8::Value> ResetParser(const v8::Arguments& args); |
|
||||
|
|
||||
HTTPConnection (enum http_parser_type t) |
|
||||
: Connection() |
|
||||
{ |
|
||||
type_ = t; |
|
||||
ResetParser(); |
|
||||
} |
|
||||
|
|
||||
void ResetParser() { |
|
||||
http_parser_init (&parser_, type_); |
|
||||
parser_.data = this; |
|
||||
} |
|
||||
|
|
||||
void OnReceive (const void *buf, size_t len); |
|
||||
void OnEOF (); |
|
||||
|
|
||||
static int on_message_begin (http_parser *parser); |
|
||||
static int on_url (http_parser *parser, const char *at, size_t length); |
|
||||
static int on_query_string (http_parser *parser, const char *at, size_t length); |
|
||||
static int on_path (http_parser *parser, const char *at, size_t length); |
|
||||
static int on_fragment (http_parser *parser, const char *at, size_t length); |
|
||||
static int on_header_field (http_parser *parser, const char *buf, size_t len); |
|
||||
static int on_header_value (http_parser *parser, const char *buf, size_t len); |
|
||||
static int on_headers_complete (http_parser *parser); |
|
||||
static int on_body (http_parser *parser, const char *buf, size_t len); |
|
||||
static int on_message_complete (http_parser *parser); |
|
||||
|
|
||||
enum http_parser_type type_; |
|
||||
http_parser parser_; |
|
||||
friend class HTTPServer; |
|
||||
}; |
|
||||
|
|
||||
class HTTPServer : public Server { |
|
||||
public: |
|
||||
static void Initialize (v8::Handle<v8::Object> target); |
|
||||
static v8::Persistent<v8::FunctionTemplate> constructor_template; |
|
||||
|
|
||||
protected: |
|
||||
static v8::Handle<v8::Value> New (const v8::Arguments& args); |
|
||||
|
|
||||
HTTPServer (void) : Server() {} |
|
||||
|
|
||||
v8::Handle<v8::FunctionTemplate> GetConnectionTemplate (void); |
|
||||
Connection* UnwrapConnection (v8::Local<v8::Object> connection); |
|
||||
}; |
|
||||
|
|
||||
} // namespace node
|
|
||||
#endif |
|
||||
File diff suppressed because it is too large
@ -1,284 +0,0 @@ |
|||||
// Copyright 2009 Ryan Dahl <ry@tinyclouds.org>
|
|
||||
#ifndef SRC_NET_H_ |
|
||||
#define SRC_NET_H_ |
|
||||
|
|
||||
#include <node.h> |
|
||||
#include <node_events.h> |
|
||||
#include <v8.h> |
|
||||
#include <evcom.h> |
|
||||
|
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
#include <gnutls/gnutls.h> |
|
||||
#include <gnutls/x509.h> |
|
||||
#endif |
|
||||
|
|
||||
|
|
||||
namespace node { |
|
||||
|
|
||||
class Server; |
|
||||
|
|
||||
class Connection : public EventEmitter { |
|
||||
public: |
|
||||
static void Initialize(v8::Handle<v8::Object> target); |
|
||||
|
|
||||
protected: |
|
||||
/* v8 interface */ |
|
||||
static v8::Persistent<v8::FunctionTemplate> constructor_template; |
|
||||
static v8::Handle<v8::Value> New(const v8::Arguments& args); |
|
||||
static v8::Handle<v8::Value> Connect(const v8::Arguments& args); |
|
||||
static v8::Handle<v8::Value> Send(const v8::Arguments& args); |
|
||||
static v8::Handle<v8::Value> Write(const v8::Arguments& args); |
|
||||
static v8::Handle<v8::Value> SendUtf8(const v8::Arguments& args); |
|
||||
static v8::Handle<v8::Value> Close(const v8::Arguments& args); |
|
||||
static v8::Handle<v8::Value> ForceClose(const v8::Arguments& args); |
|
||||
static v8::Handle<v8::Value> SetEncoding(const v8::Arguments& args); |
|
||||
static v8::Handle<v8::Value> Pause(const v8::Arguments& args); |
|
||||
static v8::Handle<v8::Value> Resume(const v8::Arguments& args); |
|
||||
static v8::Handle<v8::Value> SetTimeout(const v8::Arguments& args); |
|
||||
static v8::Handle<v8::Value> SetNoDelay(const v8::Arguments& args); |
|
||||
|
|
||||
static v8::Handle<v8::Value> ReadyStateGetter(v8::Local<v8::String> _, |
|
||||
const v8::AccessorInfo& info); |
|
||||
static v8::Handle<v8::Value> FDGetter(v8::Local<v8::String> _, |
|
||||
const v8::AccessorInfo& info); |
|
||||
|
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
static v8::Handle<v8::Value> SetSecure(const v8::Arguments& args); |
|
||||
static v8::Handle<v8::Value> VerifyPeer(const v8::Arguments& args); |
|
||||
static v8::Handle<v8::Value> GetPeerCertificate(const v8::Arguments& args); |
|
||||
#endif |
|
||||
|
|
||||
Connection() : EventEmitter() { |
|
||||
encoding_ = BINARY; |
|
||||
|
|
||||
host_ = NULL; |
|
||||
port_ = NULL; |
|
||||
|
|
||||
Init(); |
|
||||
} |
|
||||
virtual ~Connection(); |
|
||||
|
|
||||
int Connect(struct sockaddr *address) { |
|
||||
return evcom_stream_connect(&stream_, address); |
|
||||
} |
|
||||
|
|
||||
ssize_t Write(const char *buf, size_t len) { |
|
||||
return evcom_stream_write(&stream_, buf, len); |
|
||||
} |
|
||||
|
|
||||
void Close() { |
|
||||
evcom_stream_close(&stream_); |
|
||||
} |
|
||||
|
|
||||
void ForceClose() { |
|
||||
evcom_stream_force_close(&stream_); |
|
||||
} |
|
||||
|
|
||||
void Pause() { |
|
||||
evcom_stream_read_pause(&stream_); |
|
||||
} |
|
||||
|
|
||||
void Resume() { |
|
||||
evcom_stream_read_resume(&stream_); |
|
||||
} |
|
||||
|
|
||||
void SetTimeout(float timeout) { |
|
||||
evcom_stream_reset_timeout(&stream_, timeout); |
|
||||
} |
|
||||
|
|
||||
void SetNoDelay(bool no_delay) { |
|
||||
evcom_stream_set_no_delay(&stream_, no_delay); |
|
||||
} |
|
||||
|
|
||||
virtual void OnConnect(); |
|
||||
virtual void OnReceive(const void *buf, size_t len); |
|
||||
virtual void OnEOF(); |
|
||||
virtual void OnClose(); |
|
||||
virtual void OnTimeout(); |
|
||||
virtual void OnDrain(); |
|
||||
|
|
||||
v8::Local<v8::Object> GetProtocol(); |
|
||||
|
|
||||
enum evcom_stream_state ReadyState() { |
|
||||
return evcom_stream_state(&stream_); |
|
||||
} |
|
||||
|
|
||||
enum encoding encoding_; |
|
||||
bool resolving_; |
|
||||
bool secure_; |
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
gnutls_certificate_credentials_t credentials; |
|
||||
#endif |
|
||||
|
|
||||
private: |
|
||||
|
|
||||
/* liboi callbacks */ |
|
||||
static void on_connect(evcom_stream *s) { |
|
||||
Connection *connection = static_cast<Connection*>(s->data); |
|
||||
connection->OnConnect(); |
|
||||
} |
|
||||
|
|
||||
static void on_read(evcom_stream *s, const void *buf, size_t len) { |
|
||||
Connection *connection = static_cast<Connection*>(s->data); |
|
||||
assert(connection->refs_); |
|
||||
if (len == 0) |
|
||||
connection->OnEOF(); |
|
||||
else |
|
||||
connection->OnReceive(buf, len); |
|
||||
} |
|
||||
|
|
||||
static void on_close(evcom_stream *s) { |
|
||||
Connection *connection = static_cast<Connection*>(s->data); |
|
||||
|
|
||||
evcom_stream_detach(s); |
|
||||
|
|
||||
assert(connection->stream_.recvfd < 0); |
|
||||
assert(connection->stream_.sendfd < 0); |
|
||||
|
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
if (connection->secure_) { |
|
||||
if (connection->stream_.session) { |
|
||||
gnutls_deinit(connection->stream_.session); |
|
||||
connection->stream_.session = NULL; |
|
||||
} |
|
||||
if (!connection->stream_.server && connection->credentials) { |
|
||||
gnutls_certificate_free_credentials(connection->credentials); |
|
||||
connection->credentials = NULL; |
|
||||
} |
|
||||
} |
|
||||
#endif |
|
||||
|
|
||||
connection->OnClose(); |
|
||||
|
|
||||
assert(connection->refs_); |
|
||||
|
|
||||
connection->Unref(); |
|
||||
} |
|
||||
|
|
||||
static void on_timeout(evcom_stream *s) { |
|
||||
Connection *connection = static_cast<Connection*>(s->data); |
|
||||
connection->OnTimeout(); |
|
||||
} |
|
||||
|
|
||||
static void on_drain(evcom_stream *s) { |
|
||||
Connection *connection = static_cast<Connection*>(s->data); |
|
||||
connection->OnDrain(); |
|
||||
} |
|
||||
|
|
||||
void Init(); // constructor helper.
|
|
||||
|
|
||||
static int Resolve(eio_req *req); |
|
||||
static int AfterResolve(eio_req *req); |
|
||||
char *host_; |
|
||||
char *port_; |
|
||||
evcom_stream stream_; |
|
||||
|
|
||||
friend class Server; |
|
||||
}; |
|
||||
|
|
||||
class Server : public EventEmitter { |
|
||||
public: |
|
||||
static void Initialize(v8::Handle<v8::Object> target); |
|
||||
|
|
||||
protected: |
|
||||
static v8::Persistent<v8::FunctionTemplate> constructor_template; |
|
||||
static v8::Handle<v8::Value> New(const v8::Arguments& args); |
|
||||
static v8::Handle<v8::Value> Listen(const v8::Arguments& args); |
|
||||
static v8::Handle<v8::Value> Close(const v8::Arguments& args); |
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
static v8::Handle<v8::Value> SetSecure(const v8::Arguments& args); |
|
||||
#endif |
|
||||
|
|
||||
Server() : EventEmitter() { |
|
||||
evcom_server_init(&server_); |
|
||||
server_.on_connection = Server::on_connection; |
|
||||
server_.on_close = Server::on_close; |
|
||||
server_.data = this; |
|
||||
secure_ = false; |
|
||||
} |
|
||||
|
|
||||
virtual ~Server() { |
|
||||
assert(server_.fd >= 0); |
|
||||
} |
|
||||
|
|
||||
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_); |
|
||||
Ref(); |
|
||||
return 0; |
|
||||
} |
|
||||
|
|
||||
void Close() { |
|
||||
evcom_server_close(&server_); |
|
||||
} |
|
||||
|
|
||||
virtual v8::Handle<v8::FunctionTemplate> GetConnectionTemplate(); |
|
||||
virtual Connection* UnwrapConnection(v8::Local<v8::Object> connection); |
|
||||
|
|
||||
private: |
|
||||
Connection* OnConnection(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->stream_; |
|
||||
} |
|
||||
|
|
||||
void OnClose(int errorno); |
|
||||
|
|
||||
static void on_close(evcom_server *s) { |
|
||||
Server *server = static_cast<Server*>(s->data); |
|
||||
evcom_server_detach(s); |
|
||||
server->OnClose(s->errorno); |
|
||||
server->Unref(); |
|
||||
} |
|
||||
|
|
||||
evcom_server server_; |
|
||||
|
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
gnutls_certificate_credentials_t credentials; |
|
||||
#endif |
|
||||
bool secure_; |
|
||||
}; |
|
||||
|
|
||||
} // namespace node
|
|
||||
#endif // SRC_NET_H_
|
|
||||
|
|
||||
#if EVCOM_HAVE_GNUTLS |
|
||||
void init_tls_session(evcom_stream* stream_, |
|
||||
gnutls_certificate_credentials_t credentials, |
|
||||
gnutls_connection_end_t session_type); |
|
||||
|
|
||||
int verify_certificate_chain(gnutls_session_t session, |
|
||||
const char *hostname, |
|
||||
const gnutls_datum_t * cert_chain, |
|
||||
int cert_chain_length, |
|
||||
gnutls_x509_crl_t *crl_list, |
|
||||
int crl_list_size, |
|
||||
gnutls_x509_crt_t *ca_list, |
|
||||
int ca_list_size); |
|
||||
|
|
||||
int verify_cert2(gnutls_x509_crt_t crt, |
|
||||
gnutls_x509_crt_t issuer, |
|
||||
gnutls_x509_crl_t * crl_list, |
|
||||
int crl_list_size); |
|
||||
|
|
||||
int verify_last_cert(gnutls_x509_crt_t crt, |
|
||||
gnutls_x509_crt_t * ca_list, |
|
||||
int ca_list_size, |
|
||||
gnutls_x509_crl_t * crl_list, |
|
||||
int crl_list_size); |
|
||||
|
|
||||
#define JS_GNUTLS_CERT_VALIDATED 1 |
|
||||
#define JS_GNUTLS_CERT_UNDEFINED 0 |
|
||||
|
|
||||
#define JS_GNUTLS_CERT_SIGNER_NOT_FOUND -100 |
|
||||
#define JS_GNUTLS_CERT_SIGNER_NOT_CA -101 |
|
||||
#define JS_GNUTLS_CERT_INVALID -102 |
|
||||
#define JS_GNUTLS_CERT_NOT_ACTIVATED -103 |
|
||||
#define JS_GNUTLS_CERT_EXPIRED -104 |
|
||||
#define JS_GNUTLS_CERT_REVOKED -105 |
|
||||
#define JS_GNUTLS_CERT_DOES_NOT_MATCH_HOSTNAME -106 |
|
||||
|
|
||||
#endif |
|
||||
Loading…
Reference in new issue