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_ssl_free_input(nx_module_input_t *input)
{
nx_im_ssl_conf_t *imconf;
SSL *ssl;
imconf = (nx_im_ssl_conf_t *) input->module->config;
if ( input->desc.s != NULL )
{
apr_socket_close(input->desc.s);
nx_module_pollset_remove_socket(input->module, input->desc.s);
nx_module_remove_events_by_data(input->module, input->desc.s);
apr_socket_data_set(input->desc.s, NULL, "input", NULL);
NX_DLIST_REMOVE(imconf->connections, input, link);
ssl = nx_module_input_data_get(input, "ssl");
nx_ssl_destroy(&ssl);
nx_module_input_free(input);
}
}
static apr_status_t
open_lisp_socket (lisp_cfg_t * cfg)
{
apr_sockaddr_t * addr;
apr_socket_t * socket;
if ((SERVER_SOCKET (cfg)) != 0)
{
if (SERVER_SOCKET_SAFE_P (cfg))
return (APR_SUCCESS);
RELAY_ERROR (close_lisp_socket (cfg));
}
RELAY_ERROR
(apr_sockaddr_info_get ((&addr), (cfg->server_address), APR_UNSPEC,
(cfg->server_port), 0, socket_pool));
#if (HAVE_APR_1_2_2)
RELAY_ERROR (apr_socket_create ((&socket), AF_INET, SOCK_STREAM, APR_PROTO_TCP, socket_pool));
#else
RELAY_ERROR (apr_socket_create ((&socket), AF_INET, SOCK_STREAM, socket_pool));
#endif
#if (HAVE_APR_1_2_2)
RELAY_ERROR (apr_socket_connect (socket, addr));
#else
RELAY_ERROR (apr_connect (socket, addr));
#endif
{
input_buffer_t * buffer
= (apr_palloc (socket_pool, (sizeof (input_buffer_t))));
(buffer -> start) = (buffer -> data);
(buffer -> end) = (buffer -> data);
RELAY_ERROR (apr_socket_data_set (socket, buffer, "input-buffer", 0));
}
(SERVER_SOCKET (cfg)) = socket;
(SERVER_SOCKET_SAFE_P (cfg)) = 0;
return (APR_SUCCESS);
}
static void im_ssl_accept(nx_module_t *module)
{
nx_im_ssl_conf_t *imconf;
apr_socket_t *sock;
apr_sockaddr_t *sa;
char *ipstr;
nx_module_input_t *input;
SSL *ssl;
apr_pool_t *pool = NULL;
apr_status_t rv;
nx_exception_t e;
log_debug("im_ssl_accept");
imconf = (nx_im_ssl_conf_t *) module->config;
pool = nx_pool_create_child(module->pool);
try
{
if ( (rv = apr_socket_accept(&sock, imconf->listensock, pool)) != APR_SUCCESS )
{
if ( APR_STATUS_IS_EAGAIN(rv) )
{
nx_module_add_poll_event(module);
apr_pool_destroy(pool);
}
else
{
throw(rv, "couldn't accept connection on %s:%u (statuscode: %d)",
imconf->host, imconf->port, rv);
}
}
if ( rv == APR_SUCCESS )
{
CHECKERR_MSG(apr_socket_opt_set(sock, APR_SO_NONBLOCK, 1),
"couldn't set SO_NONBLOCK on accepted socket");
CHECKERR_MSG(apr_socket_timeout_set(sock, 0),
"couldn't set socket timeout on accepted socket");
CHECKERR_MSG(apr_socket_addr_get(&sa, APR_REMOTE, sock),
"couldn't get info on accepted socket");
CHECKERR_MSG(apr_sockaddr_ip_get(&ipstr, sa),
"couldn't get IP of accepted socket");
nx_module_pollset_add_socket(module, imconf->listensock, APR_POLLIN | APR_POLLHUP);
ssl = nx_ssl_from_socket(&(imconf->ssl_ctx), sock);
ASSERT(ssl != NULL);
SSL_set_accept_state(ssl);
//SSL_accept(ssl);
CHECKERR_MSG(apr_socket_opt_set(sock, APR_SO_NONBLOCK, 1),
"couldn't set SO_NONBLOCK on accepted socket");
CHECKERR_MSG(apr_socket_timeout_set(sock, 0),
"couldn't set socket timeout on accepted socket");
input = nx_module_input_new(module, pool);
input->desc_type = APR_POLL_SOCKET;
input->desc.s = sock;
input->inputfunc = imconf->inputfunc;
ASSERT(input->inputfunc != NULL);
nx_module_input_data_set(input, "ssl", ssl);
CHECKERR_MSG(apr_socket_data_set(sock, input, "input", NULL),
"couldn't set data on socket");
NX_DLIST_INSERT_TAIL(imconf->connections, input, link);
nx_module_input_data_set(input, "recv_from_str", ipstr);
nx_module_pollset_add_socket(module, sock, APR_POLLIN | APR_POLLHUP);
log_info("SSL connection accepted from %s:%u", ipstr, sa->port);
}
}
catch(e)
{
apr_pool_destroy(pool);
rethrow(e);
}
}
/*! Internal use callback associated with cpe_socket_after_accept().
* Handle the accept and put the new accepted socket in the event system.
*/
static apr_status_t
cpe_socket_accept_cb(void *context, apr_pollfd_t *pfd, cpe_event *e)
{
apr_socket_t *newsock;
apr_status_t rv;
apr_sockaddr_t *sockaddr;
cpe_socket_prepare_ctx *ctx;
cpe_event *event;
char *hostip;
ctx = context;
assert(ctx != NULL);
pfd = NULL;
cpe_event_add(e);
CHECK(rv = apr_socket_accept(&newsock, ctx->pc_orig_socket, g_cpe_pool));
rv = apr_socket_addr_get(&sockaddr, APR_REMOTE, newsock);
if (rv == APR_SUCCESS) {
apr_sockaddr_ip_get(&hostip, sockaddr);
} else {
cpe_log(CPE_ERR, "apr_sock_addr_get: %s", cpe_errmsg(rv));
cpe_socket_close(newsock);
return rv;
}
if (cpe_increment_peers(ctx) != APR_SUCCESS) {
cpe_socket_close(newsock);
cpe_log(CPE_WARN, "rejected connection from %s %d (too many)",
hostip, sockaddr->port);
return APR_EGENERAL;
}
/* Useless because APR doesn't call the callback on socket close (as
* documented), but on pool destruction. So for the time being we use
* our wrapper cpe_socket_close()
*/
CHECK(apr_socket_data_set(newsock, ctx, "dummykey", cpe_socket_cleanup_cb));
/* SECURITY: if the user didn't specify an accept filter, accept
* only connections from localhost
*/
if (ctx->pc_afilter != NULL) {
rv = ctx->pc_afilter(sockaddr);
} else {
rv = cpe_filter_localhost(sockaddr);
}
if (rv != APR_SUCCESS) {
cpe_socket_close(newsock);
cpe_log(CPE_WARN, "rejected connection from %s %d (filtered)",
hostip, sockaddr->port);
return rv;
}
cpe_log(CPE_INFO, "accepted connection from %s %d", hostip,
sockaddr->port);
/* Critical for CPE: set the socket non-blocking. */
apr_socket_opt_set(newsock, APR_SO_NONBLOCK, 1);
apr_socket_timeout_set(newsock, 0);
/*
* Create an event for the new socket and add it to the event system.
*/
cpe_log(CPE_DEB, "new accepted socket %p, creating event", newsock);
event = cpe_event_fdesc_create(APR_POLL_SOCKET, ctx->pc_reqevents,
(apr_descriptor) newsock, 0, ctx->pc_callback, ctx->pc_ctx1);
if (event == NULL) {
cpe_log(CPE_ERR, "%s", "cpe_event_fdesc_create fail");
return APR_EGENERAL;
}
CHECK(cpe_event_add(event));
if (ctx->pc_one_shot_cb != NULL) {
CHECK(ctx->pc_one_shot_cb(ctx->pc_one_shot_ctx, &event->ev_pollfd, event));
}
return rv;
}
