|
|
@ -1,3 +1,29 @@ |
|
|
|
/* Copyright (c) 2008,2009 Ryan Dahl
|
|
|
|
* |
|
|
|
* oi_queue comes from 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 <stdio.h> |
|
|
|
#include <stdlib.h> |
|
|
|
#include <assert.h> |
|
|
@ -21,9 +47,13 @@ |
|
|
|
|
|
|
|
#if HAVE_GNUTLS |
|
|
|
# include <gnutls/gnutls.h> |
|
|
|
# define GNUTLS_NEED_WRITE (gnutls_record_get_direction(socket->session) == 1) |
|
|
|
# define GNUTLS_NEED_READ (gnutls_record_get_direction(socket->session) == 0) |
|
|
|
#endif |
|
|
|
#endif // HAVE_GNUTLS
|
|
|
|
|
|
|
|
/* a few forwards
|
|
|
|
* they wont even be defined if not having gnutls |
|
|
|
* */ |
|
|
|
static int secure_full_goodbye (oi_socket *socket); |
|
|
|
static int secure_half_goodbye (oi_socket *socket); |
|
|
|
|
|
|
|
#undef TRUE |
|
|
|
#define TRUE 1 |
|
|
@ -36,30 +66,56 @@ |
|
|
|
#define AGAIN 1 |
|
|
|
#define ERROR 2 |
|
|
|
|
|
|
|
#define RAISE_ERROR(s, _domain, _code) do { \ |
|
|
|
if(s->on_error) { \ |
|
|
|
struct oi_error __oi_error; \ |
|
|
|
__oi_error.domain = _domain; \ |
|
|
|
__oi_error.code = _code; \ |
|
|
|
s->on_error(s, __oi_error); \ |
|
|
|
void |
|
|
|
oi_buf_destroy (oi_buf *buf) |
|
|
|
{ |
|
|
|
free(buf->base); |
|
|
|
free(buf); |
|
|
|
} |
|
|
|
|
|
|
|
oi_buf * |
|
|
|
oi_buf_new2 (size_t len) |
|
|
|
{ |
|
|
|
oi_buf *buf = malloc(sizeof(oi_buf)); |
|
|
|
if(!buf) |
|
|
|
return NULL; |
|
|
|
buf->base = malloc(len); |
|
|
|
if(!buf->base) { |
|
|
|
free(buf); |
|
|
|
return NULL; |
|
|
|
} |
|
|
|
buf->len = len; |
|
|
|
buf->release = oi_buf_destroy; |
|
|
|
return buf; |
|
|
|
} |
|
|
|
|
|
|
|
oi_buf * |
|
|
|
oi_buf_new (const char *base, size_t len) |
|
|
|
{ |
|
|
|
oi_buf *buf = oi_buf_new2(len); |
|
|
|
if(!buf) |
|
|
|
return NULL; |
|
|
|
memcpy(buf->base, base, len); |
|
|
|
return buf; |
|
|
|
} |
|
|
|
|
|
|
|
#define CLOSE_ASAP(socket) do { \ |
|
|
|
if ((socket)->read_action) { \ |
|
|
|
(socket)->read_action = full_close; \ |
|
|
|
} \ |
|
|
|
if ((socket)->write_action) { \ |
|
|
|
(socket)->write_action = full_close; \ |
|
|
|
} \ |
|
|
|
} while(0) \ |
|
|
|
} while (0) |
|
|
|
|
|
|
|
static int |
|
|
|
full_close(oi_socket *socket) |
|
|
|
{ |
|
|
|
if(-1 == close(socket->fd) && errno == EINTR) { |
|
|
|
/* TODO fd still open. next loop call close again? */ |
|
|
|
assert(0 && "implement me"); |
|
|
|
return ERROR; |
|
|
|
} |
|
|
|
if (close(socket->fd) == -1) |
|
|
|
return errno == EINTR ? AGAIN : ERROR; |
|
|
|
|
|
|
|
socket->read_action = NULL; |
|
|
|
socket->write_action = NULL; |
|
|
|
|
|
|
|
if(socket->attached) { |
|
|
|
ev_feed_event(SOCKET_LOOP_ &socket->read_watcher, EV_READ); |
|
|
|
} |
|
|
|
return OKAY; |
|
|
|
} |
|
|
|
|
|
|
@ -67,18 +123,55 @@ static int |
|
|
|
half_close(oi_socket *socket) |
|
|
|
{ |
|
|
|
int r = shutdown(socket->fd, SHUT_WR); |
|
|
|
|
|
|
|
if (r == -1) { |
|
|
|
RAISE_ERROR(socket, OI_ERROR_SHUTDOWN, errno); |
|
|
|
socket->errorno = errno; |
|
|
|
assert(0 && "Shouldn't get an error on shutdown"); |
|
|
|
return ERROR; |
|
|
|
} |
|
|
|
|
|
|
|
socket->write_action = NULL; |
|
|
|
|
|
|
|
/* TODO set timer to zero so we get a callback soon */ |
|
|
|
return OKAY; |
|
|
|
} |
|
|
|
|
|
|
|
// This is to be called when ever the out_stream is empty
|
|
|
|
// and we need to change state.
|
|
|
|
static void |
|
|
|
change_state_for_empty_out_stream (oi_socket *socket) |
|
|
|
{ |
|
|
|
/*
|
|
|
|
* a very complicated bunch of close logic! |
|
|
|
* XXX this is awful. FIXME |
|
|
|
*/ |
|
|
|
if (socket->got_half_close == FALSE) { |
|
|
|
if (socket->got_full_close == FALSE) { |
|
|
|
/* Normal situation. Didn't get any close signals. */ |
|
|
|
ev_io_stop(SOCKET_LOOP_ &socket->write_watcher); |
|
|
|
} else { |
|
|
|
/* Got Full Close. */ |
|
|
|
if (socket->read_action) |
|
|
|
#if HAVE_GNUTLS |
|
|
|
socket->read_action = socket->secure ? secure_full_goodbye : full_close; |
|
|
|
#else |
|
|
|
socket->read_action = full_close; |
|
|
|
#endif |
|
|
|
|
|
|
|
if (socket->write_action) |
|
|
|
#if HAVE_GNUTLS |
|
|
|
socket->write_action = socket->secure ? secure_full_goodbye : full_close; |
|
|
|
#else |
|
|
|
socket->write_action = full_close; |
|
|
|
#endif |
|
|
|
} |
|
|
|
} else { |
|
|
|
/* Got Half Close. */ |
|
|
|
if (socket->write_action) |
|
|
|
#if HAVE_GNUTLS |
|
|
|
socket->write_action = socket->secure ? secure_half_goodbye : half_close; |
|
|
|
#else |
|
|
|
socket->write_action = half_close; |
|
|
|
#endif |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
static void |
|
|
|
update_write_buffer_after_send (oi_socket *socket, ssize_t sent) |
|
|
|
{ |
|
|
@ -96,14 +189,13 @@ update_write_buffer_after_send(oi_socket *socket, ssize_t sent) |
|
|
|
} |
|
|
|
|
|
|
|
if (oi_queue_empty(&socket->out_stream)) { |
|
|
|
ev_io_stop(SOCKET_LOOP_ &socket->write_watcher); |
|
|
|
change_state_for_empty_out_stream(socket); |
|
|
|
if (socket->on_drain) |
|
|
|
socket->on_drain(socket); |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
#if HAVE_GNUTLS |
|
|
|
static int secure_socket_send(oi_socket *socket); |
|
|
|
static int secure_socket_recv(oi_socket *socket); |
|
|
@ -138,7 +230,7 @@ secure_handshake(oi_socket *socket) |
|
|
|
int r = gnutls_handshake(socket->session); |
|
|
|
|
|
|
|
if (gnutls_error_is_fatal(r)) { |
|
|
|
RAISE_ERROR(socket, OI_ERROR_GNUTLS, r); |
|
|
|
socket->gnutls_errorno = r; |
|
|
|
return ERROR; |
|
|
|
} |
|
|
|
|
|
|
@ -149,8 +241,7 @@ secure_handshake(oi_socket *socket) |
|
|
|
|
|
|
|
if (!socket->connected) { |
|
|
|
socket->connected = TRUE; |
|
|
|
if(socket->on_connect) |
|
|
|
socket->on_connect(socket); |
|
|
|
if (socket->on_connect) socket->on_connect(socket); |
|
|
|
} |
|
|
|
|
|
|
|
if (socket->read_action) |
|
|
@ -183,7 +274,7 @@ secure_socket_send(oi_socket *socket) |
|
|
|
); |
|
|
|
|
|
|
|
if (gnutls_error_is_fatal(sent)) { |
|
|
|
RAISE_ERROR(socket, OI_ERROR_GNUTLS, sent); |
|
|
|
socket->gnutls_errorno = sent; |
|
|
|
return ERROR; |
|
|
|
} |
|
|
|
|
|
|
@ -193,15 +284,6 @@ secure_socket_send(oi_socket *socket) |
|
|
|
oi_socket_reset_timeout(socket); |
|
|
|
|
|
|
|
if (sent == GNUTLS_E_INTERRUPTED || sent == GNUTLS_E_AGAIN) { |
|
|
|
if(GNUTLS_NEED_READ) { |
|
|
|
if(socket->read_action) { |
|
|
|
socket->read_action = secure_socket_send; |
|
|
|
} else { |
|
|
|
/* TODO GnuTLS needs read but already got EOF */ |
|
|
|
assert(0 && "needs read but already got EOF"); |
|
|
|
return ERROR; |
|
|
|
} |
|
|
|
} |
|
|
|
return AGAIN; |
|
|
|
} |
|
|
|
|
|
|
@ -220,8 +302,8 @@ secure_socket_send(oi_socket *socket) |
|
|
|
static int |
|
|
|
secure_socket_recv(oi_socket *socket) |
|
|
|
{ |
|
|
|
char recv_buffer[TCP_MAXWIN]; |
|
|
|
size_t recv_buffer_size = MIN(TCP_MAXWIN, socket->chunksize); |
|
|
|
char recv_buffer[socket->chunksize]; |
|
|
|
size_t recv_buffer_size = socket->chunksize; |
|
|
|
ssize_t recved; |
|
|
|
|
|
|
|
assert(socket->secure); |
|
|
@ -231,21 +313,11 @@ secure_socket_recv(oi_socket *socket) |
|
|
|
//printf("secure socket recv %d %p\n", recved, socket->on_connect);
|
|
|
|
|
|
|
|
if (gnutls_error_is_fatal(recved)) { |
|
|
|
RAISE_ERROR(socket, OI_ERROR_GNUTLS, recved); |
|
|
|
socket->gnutls_errorno = recved; |
|
|
|
return ERROR; |
|
|
|
} |
|
|
|
|
|
|
|
if (recved == GNUTLS_E_INTERRUPTED || recved == GNUTLS_E_AGAIN) { |
|
|
|
if(GNUTLS_NEED_WRITE) { |
|
|
|
if(socket->write_action) { |
|
|
|
printf("need write\n"); |
|
|
|
socket->write_action = secure_socket_recv; |
|
|
|
} else { |
|
|
|
/* TODO GnuTLS needs send but already closed write end */ |
|
|
|
assert(0 && "needs read but cannot"); |
|
|
|
return ERROR; |
|
|
|
} |
|
|
|
} |
|
|
|
return AGAIN; |
|
|
|
} |
|
|
|
|
|
|
@ -260,8 +332,8 @@ secure_socket_recv(oi_socket *socket) |
|
|
|
socket->write_action = secure_handshake; |
|
|
|
return OKAY; |
|
|
|
} else { |
|
|
|
/* TODO */ |
|
|
|
assert(0 && "needs read but cannot"); |
|
|
|
socket->read_action = full_close; |
|
|
|
// set error
|
|
|
|
return ERROR; |
|
|
|
} |
|
|
|
} |
|
|
@ -284,51 +356,46 @@ secure_socket_recv(oi_socket *socket) |
|
|
|
} |
|
|
|
|
|
|
|
static int |
|
|
|
secure_goodbye(oi_socket *socket, gnutls_close_request_t how) |
|
|
|
secure_full_goodbye (oi_socket *socket) |
|
|
|
{ |
|
|
|
assert(socket->secure); |
|
|
|
|
|
|
|
int r = gnutls_bye(socket->session, how); |
|
|
|
int r = gnutls_bye(socket->session, GNUTLS_SHUT_RDWR); |
|
|
|
|
|
|
|
if (gnutls_error_is_fatal(r)) { |
|
|
|
RAISE_ERROR(socket, OI_ERROR_GNUTLS, r); |
|
|
|
socket->gnutls_errorno = r; |
|
|
|
return ERROR; |
|
|
|
} |
|
|
|
|
|
|
|
if (r == GNUTLS_E_INTERRUPTED || r == GNUTLS_E_AGAIN) |
|
|
|
return AGAIN; |
|
|
|
|
|
|
|
return OKAY; |
|
|
|
} |
|
|
|
CLOSE_ASAP(socket); |
|
|
|
|
|
|
|
static int |
|
|
|
secure_full_goodbye(oi_socket *socket) |
|
|
|
{ |
|
|
|
int r = secure_goodbye(socket, GNUTLS_SHUT_RDWR); |
|
|
|
if(OKAY == r) { |
|
|
|
return full_close(socket); |
|
|
|
} |
|
|
|
return r; |
|
|
|
return OKAY; |
|
|
|
} |
|
|
|
|
|
|
|
static int |
|
|
|
secure_half_goodbye (oi_socket *socket) |
|
|
|
{ |
|
|
|
int r = secure_goodbye(socket, GNUTLS_SHUT_WR); |
|
|
|
if(OKAY == r) { |
|
|
|
return half_close(socket); |
|
|
|
assert(socket->secure); |
|
|
|
|
|
|
|
int r = gnutls_bye(socket->session, GNUTLS_SHUT_WR); |
|
|
|
|
|
|
|
if (gnutls_error_is_fatal(r)) { |
|
|
|
socket->gnutls_errorno = r; |
|
|
|
return ERROR; |
|
|
|
} |
|
|
|
return r; |
|
|
|
|
|
|
|
if (r == GNUTLS_E_INTERRUPTED || r == GNUTLS_E_AGAIN) |
|
|
|
return AGAIN; |
|
|
|
|
|
|
|
if (socket->write_action) |
|
|
|
socket->write_action = half_close; |
|
|
|
|
|
|
|
return OKAY; |
|
|
|
} |
|
|
|
|
|
|
|
/* Tells the socket to use transport layer security (SSL). liboi 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 liboi. |
|
|
|
* |
|
|
|
* That is, do not use gnutls_transport_* functions. |
|
|
|
* Do use the rest of GnuTLS's API. |
|
|
|
*/ |
|
|
|
void |
|
|
|
oi_socket_set_secure_session (oi_socket *socket, gnutls_session_t session) |
|
|
|
{ |
|
|
@ -370,21 +437,25 @@ socket_send(oi_socket *socket) |
|
|
|
|
|
|
|
if (sent < 0) { |
|
|
|
switch (errno) { |
|
|
|
#ifdef EWOULDBLOCK |
|
|
|
case EWOULDBLOCK: |
|
|
|
#else |
|
|
|
case EAGAIN: |
|
|
|
#endif |
|
|
|
return AGAIN; |
|
|
|
|
|
|
|
case ECONNREFUSED: |
|
|
|
socket->errorno = errno; |
|
|
|
return ERROR; |
|
|
|
|
|
|
|
case ECONNRESET: |
|
|
|
socket->write_action = NULL; |
|
|
|
/* TODO maybe just clear write buffer instead of error?
|
|
|
|
* They should be able to read still from the socket. |
|
|
|
*/ |
|
|
|
RAISE_ERROR(socket, OI_ERROR_SEND, errno); |
|
|
|
socket->errorno = errno; |
|
|
|
return ERROR; |
|
|
|
|
|
|
|
default: |
|
|
|
perror("send()"); |
|
|
|
assert(0 && "oi shouldn't let this happen."); |
|
|
|
socket->errorno = errno; |
|
|
|
return ERROR; |
|
|
|
} |
|
|
|
} |
|
|
@ -393,7 +464,7 @@ socket_send(oi_socket *socket) |
|
|
|
|
|
|
|
if (!socket->connected) { |
|
|
|
socket->connected = TRUE; |
|
|
|
if(socket->on_connect) { socket->on_connect(socket); } |
|
|
|
if (socket->on_connect) socket->on_connect(socket); |
|
|
|
} |
|
|
|
|
|
|
|
update_write_buffer_after_send(socket, sent); |
|
|
@ -412,7 +483,7 @@ socket_recv(oi_socket *socket) |
|
|
|
|
|
|
|
if (!socket->connected) { |
|
|
|
socket->connected = TRUE; |
|
|
|
if(socket->on_connect) { socket->on_connect(socket); } |
|
|
|
if (socket->on_connect) socket->on_connect(socket); |
|
|
|
return OKAY; |
|
|
|
} |
|
|
|
|
|
|
@ -420,18 +491,20 @@ socket_recv(oi_socket *socket) |
|
|
|
|
|
|
|
if (recved < 0) { |
|
|
|
switch (errno) { |
|
|
|
#ifdef EWOULDBLOCK |
|
|
|
case EWOULDBLOCK: |
|
|
|
#else |
|
|
|
case EAGAIN: |
|
|
|
#endif |
|
|
|
return AGAIN; |
|
|
|
|
|
|
|
case EINTR: |
|
|
|
return AGAIN; |
|
|
|
|
|
|
|
/* A remote host refused to allow the network connection (typically
|
|
|
|
* because it is not running the requested service). */ |
|
|
|
case ECONNREFUSED: |
|
|
|
RAISE_ERROR(socket, OI_ERROR_RECV, errno); |
|
|
|
return ERROR; |
|
|
|
|
|
|
|
case ECONNRESET: |
|
|
|
RAISE_ERROR(socket, OI_ERROR_RECV, errno); |
|
|
|
socket->errorno = errno; |
|
|
|
return ERROR; |
|
|
|
|
|
|
|
default: |
|
|
@ -541,7 +614,6 @@ int |
|
|
|
oi_server_listen(oi_server *server, struct addrinfo *addrinfo) |
|
|
|
{ |
|
|
|
int fd = -1; |
|
|
|
struct linger ling = {0, 0}; |
|
|
|
assert(server->listening == FALSE); |
|
|
|
|
|
|
|
fd = socket( addrinfo->ai_family |
|
|
@ -563,7 +635,6 @@ oi_server_listen(oi_server *server, struct addrinfo *addrinfo) |
|
|
|
flags = 1; |
|
|
|
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void *)&flags, sizeof(flags)); |
|
|
|
setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (void *)&flags, sizeof(flags)); |
|
|
|
setsockopt(fd, SOL_SOCKET, SO_LINGER, (void *)&ling, sizeof(ling)); |
|
|
|
|
|
|
|
/* XXX: Sending single byte chunks in a response body? Perhaps there is a
|
|
|
|
* need to enable the Nagel algorithm dynamically. For now disabling. |
|
|
@ -650,10 +721,7 @@ on_timeout(EV_P_ ev_timer *watcher, int revents) |
|
|
|
// printf("on_timeout\n");
|
|
|
|
|
|
|
|
if (socket->on_timeout) { socket->on_timeout(socket); } |
|
|
|
|
|
|
|
|
|
|
|
/* TODD set timer to zero */ |
|
|
|
full_close(socket); |
|
|
|
// timeout does not automatically kill your connection. you must!
|
|
|
|
} |
|
|
|
|
|
|
|
static void |
|
|
@ -674,45 +742,42 @@ on_io_event(EV_P_ ev_io *watcher, int revents) |
|
|
|
oi_socket *socket = watcher->data; |
|
|
|
|
|
|
|
if (revents & EV_ERROR) { |
|
|
|
RAISE_ERROR(socket, OI_ERROR_EV, 0); |
|
|
|
goto close; |
|
|
|
socket->errorno = 1; |
|
|
|
CLOSE_ASAP(socket); |
|
|
|
} |
|
|
|
|
|
|
|
int r; |
|
|
|
int have_read_event = TRUE; |
|
|
|
int have_write_event = TRUE; |
|
|
|
int have_read_event = (socket->read_action != NULL); |
|
|
|
int have_write_event = (socket->write_action != NULL); |
|
|
|
|
|
|
|
while (have_read_event || have_write_event) { |
|
|
|
|
|
|
|
if(socket->read_action) { |
|
|
|
/* RECV LOOP - TRY TO CLEAR THE BUFFER */ |
|
|
|
if (socket->read_action == NULL) |
|
|
|
have_read_event = FALSE; |
|
|
|
else { |
|
|
|
r = socket->read_action(socket); |
|
|
|
if(r == ERROR) goto close; |
|
|
|
if(r == AGAIN) have_read_event = FALSE; |
|
|
|
} else { |
|
|
|
|
|
|
|
if (r == AGAIN) |
|
|
|
have_read_event = FALSE; |
|
|
|
else if (r == ERROR) |
|
|
|
CLOSE_ASAP(socket); |
|
|
|
} |
|
|
|
|
|
|
|
if(socket->write_action) { |
|
|
|
r = socket->write_action(socket); |
|
|
|
if(r == ERROR) goto close; |
|
|
|
if(r == AGAIN) have_write_event = FALSE; |
|
|
|
} else { |
|
|
|
/* SEND LOOP - TRY TO CLEAR THE BUFFER */ |
|
|
|
if (socket->write_action == NULL) |
|
|
|
have_write_event = FALSE; |
|
|
|
} |
|
|
|
|
|
|
|
else { |
|
|
|
r = socket->write_action(socket); |
|
|
|
|
|
|
|
if(socket->read_watcher.active == FALSE) |
|
|
|
have_read_event = FALSE; |
|
|
|
if(socket->write_watcher.active == FALSE) |
|
|
|
if (r == AGAIN) |
|
|
|
have_write_event = FALSE; |
|
|
|
else if (r == ERROR) |
|
|
|
CLOSE_ASAP(socket); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
if(socket->write_action == NULL && socket->read_action == NULL) |
|
|
|
goto close; |
|
|
|
|
|
|
|
return; |
|
|
|
|
|
|
|
close: |
|
|
|
// Close when both sides of the stream are closed.
|
|
|
|
if (socket->write_action == NULL && socket->read_action == NULL) { |
|
|
|
release_write_buffer(socket); |
|
|
|
|
|
|
|
ev_clear_pending (EV_A_ &socket->write_watcher); |
|
|
@ -725,6 +790,7 @@ close: |
|
|
|
/* WARNING: user can free socket in on_close so no more
|
|
|
|
* access beyond this point. */ |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
/**
|
|
|
|
* If using SSL do consider setting |
|
|
@ -752,13 +818,17 @@ oi_socket_init(oi_socket *socket, float timeout) |
|
|
|
ev_init(&socket->read_watcher, on_io_event); |
|
|
|
socket->read_watcher.data = socket; |
|
|
|
|
|
|
|
socket->got_full_close = FALSE; |
|
|
|
socket->got_half_close = FALSE; |
|
|
|
|
|
|
|
socket->errorno = 0; |
|
|
|
|
|
|
|
socket->secure = FALSE; |
|
|
|
socket->wait_for_secure_hangup = FALSE; |
|
|
|
#if HAVE_GNUTLS |
|
|
|
socket->gnutls_errorno = 0; |
|
|
|
socket->session = NULL; |
|
|
|
#endif |
|
|
|
|
|
|
|
/* TODO higher resolution timer */ |
|
|
|
ev_timer_init(&socket->timeout_watcher, on_timeout, 0., timeout); |
|
|
|
socket->timeout_watcher.data = socket; |
|
|
|
|
|
|
@ -769,91 +839,51 @@ oi_socket_init(oi_socket *socket, float timeout) |
|
|
|
socket->on_connect = NULL; |
|
|
|
socket->on_read = NULL; |
|
|
|
socket->on_drain = NULL; |
|
|
|
socket->on_error = NULL; |
|
|
|
socket->on_timeout = NULL; |
|
|
|
} |
|
|
|
|
|
|
|
void |
|
|
|
oi_socket_write_eof (oi_socket *socket) |
|
|
|
{ |
|
|
|
#if HAVE_GNUTLS |
|
|
|
/* try to hang up properly for secure connections */ |
|
|
|
if(socket->secure) |
|
|
|
{ |
|
|
|
if( socket->connected /* completed handshake */ |
|
|
|
&& socket->write_action /* write end is open */ |
|
|
|
) |
|
|
|
oi_socket_close (oi_socket *socket) |
|
|
|
{ |
|
|
|
socket->write_action = secure_half_goodbye; |
|
|
|
if(socket->attached) |
|
|
|
ev_io_start(SOCKET_LOOP_ &socket->write_watcher); |
|
|
|
return; |
|
|
|
} |
|
|
|
/* secure servers cannot handle half-closed connections? */ |
|
|
|
full_close(socket); |
|
|
|
return; |
|
|
|
} |
|
|
|
#endif // HAVE_GNUTLS
|
|
|
|
|
|
|
|
if(socket->write_action) |
|
|
|
half_close(socket); |
|
|
|
else |
|
|
|
full_close(socket); |
|
|
|
socket->got_half_close = TRUE; |
|
|
|
if (oi_queue_empty(&socket->out_stream)) |
|
|
|
change_state_for_empty_out_stream(socket); |
|
|
|
} |
|
|
|
|
|
|
|
void |
|
|
|
oi_socket_close (oi_socket *socket) |
|
|
|
oi_socket_full_close (oi_socket *socket) |
|
|
|
{ |
|
|
|
#if HAVE_GNUTLS |
|
|
|
/* try to hang up properly for secure connections */ |
|
|
|
if( socket->secure |
|
|
|
&& socket->connected /* completed handshake */ |
|
|
|
&& socket->write_action /* write end is open */ |
|
|
|
) |
|
|
|
{ |
|
|
|
if(socket->wait_for_secure_hangup && socket->read_action) { |
|
|
|
socket->write_action = secure_full_goodbye; |
|
|
|
socket->read_action = secure_full_goodbye; |
|
|
|
} else { |
|
|
|
socket->write_action = secure_half_goodbye; |
|
|
|
socket->read_action = NULL; |
|
|
|
} |
|
|
|
|
|
|
|
if(socket->attached) |
|
|
|
ev_io_start(SOCKET_LOOP_ &socket->write_watcher); |
|
|
|
|
|
|
|
return; |
|
|
|
} |
|
|
|
#endif // HAVE_GNUTLS
|
|
|
|
|
|
|
|
full_close(socket); |
|
|
|
socket->got_full_close = TRUE; |
|
|
|
if (oi_queue_empty(&socket->out_stream)) |
|
|
|
change_state_for_empty_out_stream(socket); |
|
|
|
} |
|
|
|
|
|
|
|
/*
|
|
|
|
* Resets the timeout to stay alive for another socket->timeout seconds |
|
|
|
*/ |
|
|
|
void |
|
|
|
oi_socket_reset_timeout(oi_socket *socket) |
|
|
|
void oi_socket_force_close (oi_socket *socket) |
|
|
|
{ |
|
|
|
ev_timer_again(SOCKET_LOOP_ &socket->timeout_watcher); |
|
|
|
// socket->errorno = OI_SOCKET_ERROR_FORCE_CLOSE
|
|
|
|
CLOSE_ASAP(socket); |
|
|
|
} |
|
|
|
|
|
|
|
/**
|
|
|
|
* Writes a string to the socket. This is actually sets a watcher which may |
|
|
|
* take multiple iterations to write the entire string. |
|
|
|
*/ |
|
|
|
void |
|
|
|
oi_socket_write(oi_socket *socket, oi_buf *buf) |
|
|
|
{ |
|
|
|
if(socket->write_action == NULL) |
|
|
|
return; |
|
|
|
assert(socket->write_action != NULL && "Do not write to a closed socket"); |
|
|
|
assert(socket->got_full_close == FALSE && "Do not write to a closing socket"); |
|
|
|
assert(socket->got_half_close == FALSE && "Do not write to a closing socket"); |
|
|
|
|
|
|
|
oi_queue_insert_head(&socket->out_stream, &buf->queue); |
|
|
|
|
|
|
|
buf->written = 0; |
|
|
|
// XXX if (socket->attached) ??
|
|
|
|
|
|
|
|
if (socket->attached) { |
|
|
|
ev_io_start(SOCKET_LOOP_ &socket->write_watcher); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
void |
|
|
|
oi_socket_reset_timeout(oi_socket *socket) |
|
|
|
{ |
|
|
|
ev_timer_again(SOCKET_LOOP_ &socket->timeout_watcher); |
|
|
|
} |
|
|
|
|
|
|
|
static void |
|
|
|
free_simple_buf ( oi_buf *buf ) |
|
|
@ -891,9 +921,6 @@ oi_socket_attach(EV_P_ oi_socket *socket) |
|
|
|
|
|
|
|
if (socket->write_action) |
|
|
|
ev_io_start(EV_A_ &socket->write_watcher); |
|
|
|
|
|
|
|
/* make sure the io_event happens soon in the case we're being reattached */ |
|
|
|
ev_feed_event(EV_A_ &socket->read_watcher, EV_READ); |
|
|
|
} |
|
|
|
|
|
|
|
void |
|
|
|