static void im_ssl_event(nx_module_t *module, nx_event_t *event)
{
nx_module_input_t *input = NULL;
ASSERT(event != NULL);
switch ( event->type )
{
case NX_EVENT_READ:
im_ssl_read(module, event);
break;
case NX_EVENT_WRITE:
im_ssl_write(module, event);
break;
case NX_EVENT_DISCONNECT:
CHECKERR_MSG(apr_socket_data_get((void **) &input, "input",
(apr_socket_t *) event->data),
"couldn't get input data from socket");
im_ssl_disconnect(input);
break;
case NX_EVENT_POLL:
if ( nx_module_get_status(module) == NX_MODULE_STATUS_RUNNING )
{
nx_module_pollset_poll(module, TRUE);
}
break;
default:
nx_panic("invalid event type: %d", event->type);
}
}
static void im_ssl_read(nx_module_t *module, nx_event_t *event)
{
nx_im_ssl_conf_t *imconf;
nx_logdata_t *logdata;
apr_socket_t *sock;
nx_module_input_t *input = NULL;
char *ipstr;
nx_exception_t e;
boolean disconnect;
ASSERT(module != NULL);
ASSERT(event != NULL);
log_debug("im_ssl_read");
if ( nx_module_get_status(module) != NX_MODULE_STATUS_RUNNING )
{
log_debug("module %s not running, not reading any more data", module->name);
return;
}
imconf = (nx_im_ssl_conf_t *) module->config;
sock = (apr_socket_t *) event->data;
ASSERT(imconf->listensock != NULL);
if ( sock == imconf->listensock )
{
im_ssl_accept(module);
return;
}
//else we have data from a client connection
CHECKERR_MSG(apr_socket_data_get((void **) &input, "input", sock),
"couldn't get input data from socket");
ASSERT(input != NULL); // if this is null there is a race/double free in event handling
disconnect = im_ssl_fill_buffer(module, input);
try
{
while ( (logdata = input->inputfunc->func(input, input->inputfunc->data)) != NULL )
{
//log_debug("read: [%s]", logdata->data);
ipstr = nx_module_input_data_get(input, "recv_from_str");
nx_logdata_set_string(logdata, "MessageSourceAddress", ipstr);
nx_module_add_logdata_input(module, input, logdata);
}
}
catch(e)
{
im_ssl_free_input(input);
rethrow_msg(e, "Module %s couldn't read the input", input->module->name);
}
if ( disconnect == TRUE )
{
im_ssl_disconnect(input);
}
}
static void im_ssl_write(nx_module_t *module, nx_event_t *event)
{
int rv;
SSL *ssl;
apr_socket_t *sock;
nx_module_input_t *input = NULL;
int errcode;
nx_exception_t e;
sock = (apr_socket_t *) event->data;
ASSERT(module != NULL);
CHECKERR_MSG(apr_socket_data_get((void **) &input, "input", sock),
"couldn't get input data from socket");
ASSERT(input != NULL);
ssl = (SSL *) nx_module_input_data_get(input, "ssl");
ASSERT(ssl != NULL);
if ( !SSL_is_init_finished(ssl) )
{
log_debug("doing handshake");
try
{
if ( (rv = SSL_do_handshake(ssl)) <= 0 )
{
switch ( (errcode = nx_ssl_check_io_error(ssl, rv)) )
{
case SSL_ERROR_ZERO_RETURN: // disconnected
throw_msg("im_ssl got disconnected during handshake");
break;
case SSL_ERROR_WANT_WRITE:
log_debug("im_ssl WANT_WRITE");
nx_module_pollset_add_socket(module, input->desc.s, APR_POLLOUT | APR_POLLHUP);
break;
case SSL_ERROR_WANT_READ:
log_debug("im_ssl WANT_READ");
nx_module_pollset_add_socket(module, input->desc.s, APR_POLLIN | APR_POLLHUP);
break;
default:
throw_msg("im_ssl couldn't write handshake data (error code: %d)", errcode);
}
}
}
catch(e)
{
log_exception(e);
im_ssl_disconnect(input);
return;
}
}
else
{
log_warn("SSL socket should not be sending anything after the handshake");
nx_module_pollset_add_socket(module, input->desc.s, APR_POLLIN | APR_POLLHUP);
}
}
/** Wrapper around apr_socket_close() to invoke the cleanup callback.
*/
apr_status_t
cpe_socket_close(apr_socket_t *sock)
{
apr_status_t rv;
void *p = NULL;
apr_socket_close(sock);
CHECK(apr_socket_data_get(&p, "dummykey", sock));
CHECK(cpe_socket_cleanup_cb(p));
return rv;
}
static void socket_userdata(abts_case *tc, void *data)
{
apr_socket_t *sock1, *sock2;
apr_status_t rv;
void *user;
const char *key = "GENERICKEY";
rv = apr_socket_create(&sock1, AF_INET, SOCK_STREAM, 0, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_socket_create(&sock2, AF_INET, SOCK_STREAM, 0, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_socket_data_set(sock1, "SOCK1", key, NULL);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_socket_data_set(sock2, "SOCK2", key, NULL);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_socket_data_get(&user, key, sock1);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_STR_EQUAL(tc, "SOCK1", user);
rv = apr_socket_data_get(&user, key, sock2);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_STR_EQUAL(tc, "SOCK2", user);
}
static void im_tcp_got_disconnect(nx_module_t *module, nx_event_t *event)
{
apr_socket_t *sock;
nx_module_input_t *input;
apr_sockaddr_t *sa;
char *ipstr;
ASSERT(event != NULL);
ASSERT(module != NULL);
log_debug("im_tcp_disconnect");
sock = (apr_socket_t *) event->data;
CHECKERR_MSG(apr_socket_data_get((void **) &input, "input", sock),
"couldn't get input data from socket");
CHECKERR_MSG(apr_socket_addr_get(&sa, APR_REMOTE, input->desc.s),
"couldn't get info on accepted socket");
CHECKERR_MSG(apr_sockaddr_ip_get(&ipstr, sa),
"couldn't get IP of accepted socket");
log_warn("TCP connection closed from %s:%u", ipstr, sa->port);
im_tcp_free_input(input);
}
static apr_status_t
get_input_buffer (apr_socket_t * socket, input_buffer_t ** buffer_r)
{
return (apr_socket_data_get (((void **) buffer_r), "input-buffer", socket));
}
static void im_tcp_read(nx_module_t *module, nx_event_t *event)
{
nx_im_tcp_conf_t *imconf;
nx_logdata_t *logdata;
boolean volatile got_eof = FALSE;
apr_socket_t *sock;
nx_module_input_t *input;
apr_sockaddr_t *sa;
char *ipstr;
apr_status_t rv;
nx_exception_t e;
ASSERT(event != NULL);
ASSERT(module != NULL);
log_debug("im_tcp_read");
if ( nx_module_get_status(module) != NX_MODULE_STATUS_RUNNING )
{
log_debug("module %s not running, not reading any more data", module->name);
return;
}
imconf = (nx_im_tcp_conf_t *) module->config;
sock = (apr_socket_t *) event->data;
ASSERT(imconf->listensock != NULL);
if ( sock == imconf->listensock )
{
im_tcp_accept(module);
return;
}
//else we have data from a client connection
CHECKERR_MSG(apr_socket_data_get((void **) &input, "input", sock),
"couldn't get input data from socket");
ASSERT(input != NULL); // if this is null there is a race/double free in event handling
if ( (rv = nx_module_input_fill_buffer_from_socket(input)) != APR_SUCCESS )
{
if ( APR_STATUS_IS_ECONNREFUSED(rv) ||
APR_STATUS_IS_ECONNABORTED(rv) ||
APR_STATUS_IS_ECONNRESET(rv) ||
APR_STATUS_IS_ETIMEDOUT(rv) ||
APR_STATUS_IS_TIMEUP(rv) ||
APR_STATUS_IS_EHOSTUNREACH(rv) ||
APR_STATUS_IS_ENETUNREACH(rv) ||
APR_STATUS_IS_EOF(rv) )
{
got_eof = TRUE;
}
else if ( APR_STATUS_IS_EAGAIN(rv) )
{
nx_module_add_poll_event(module);
}
else
{
im_tcp_free_input(input);
throw(rv, "Module %s couldn't read from socket", input->module->name);
}
}
try
{
while ( (logdata = input->inputfunc->func(input, input->inputfunc->data)) != NULL )
{
//log_debug("read %d bytes: [%s]", (int) logdata->datalen, logdata->data);
ipstr = nx_module_input_data_get(input, "recv_from_str");
nx_logdata_set_string(logdata, "MessageSourceAddress", ipstr);
nx_module_add_logdata_input(module, input, logdata);
}
}
catch(e)
{
im_tcp_free_input(input);
rethrow_msg(e, "Module %s couldn't read the input", input->module->name);
}
if ( got_eof == TRUE )
{
CHECKERR_MSG(apr_socket_addr_get(&sa, APR_REMOTE, input->desc.s),
"couldn't get info on accepted socket");
CHECKERR_MSG(apr_sockaddr_ip_get(&ipstr, sa),
"couldn't get IP of accepted socket");
log_aprwarn(rv, "TCP connection closed from %s:%u", ipstr, sa->port);
im_tcp_free_input(input);
}
}
