int main()
{
apr_thread_t* push_thds[1000];
apr_thread_t* pop_thds[1000];
apr_threadattr_t* thd_attr;
apr_initialize();
apr_pool_create(&global_pool, NULL);
apr_atomic_init(global_pool);
frl_queue_create(&queue, global_pool, 1, FRL_LOCK_FREE);
apr_threadattr_create(&thd_attr, global_pool);
apr_time_t now = apr_time_now();
for (int i = 0; i < 100; i++)
{
apr_thread_create(&pop_thds[i], thd_attr, threadsafe_test_pop, (void*)i, global_pool);
apr_thread_create(&push_thds[i], thd_attr, threadsafe_test_push, (void*)i, global_pool);
}
apr_status_t rv;
for (int i = 0; i < 100; i++)
{
printf("Stop at %d\n", i+1);
apr_thread_join(&rv, push_thds[i]);
apr_thread_join(&rv, pop_thds[i]);
}
printf("Pass with %dus.\n", apr_time_now()-now);
apr_terminate();
}
void slayer_server_stats_timer_thread(apr_pool_t *mpool,slayer_server_stats_t *stats) {
apr_threadattr_t *thread_attr;
apr_thread_t *thread;
apr_threadattr_create(&thread_attr,mpool);
apr_threadattr_detach_set(thread_attr,1); // detach
apr_threadattr_stacksize_set(thread_attr,4096*10);
apr_thread_create(&thread,thread_attr,slayer_server_stats_timer_thread_run,stats,mpool);
}
apr_status_t handle_new_client(apr_socket_t *socket, apr_pool_t *pool,
dynalogin_session_t *h)
{
char buf[ERRBUFLEN + 1];
apr_status_t res;
apr_threadattr_t *t_attr;
apr_thread_t *t;
apr_pool_t *subpool;
socket_thread_data_t *thread_data;
res = apr_pool_create(&subpool, pool);
if(res != APR_SUCCESS)
{
syslog(LOG_ERR, "failed to create pool: %s",
apr_strerror(res, buf, ERRBUFLEN));
apr_socket_close(socket);
return res;
}
res = apr_threadattr_create(&t_attr, subpool);
if(res != APR_SUCCESS)
{
syslog(LOG_ERR, "failed to create threadattr: %s",
apr_strerror(res, buf, ERRBUFLEN));
apr_pool_destroy(subpool);
apr_socket_close(socket);
return res;
}
thread_data = apr_pcalloc(subpool, sizeof(struct socket_thread_data_t));
if(thread_data == NULL)
{
syslog(LOG_ERR, "handle_new_client: apr_pcalloc failed");
apr_pool_destroy(subpool);
apr_socket_close(socket);
return res;
}
thread_data->pool = subpool;
thread_data->socket = socket;
thread_data->tls_session = NULL; // to be populated later if using TLS
thread_data->dynalogin_session = h;
res = apr_thread_create(&t, t_attr,
(apr_thread_start_t)socket_thread_main, thread_data, subpool);
if(res != APR_SUCCESS)
{
syslog(LOG_ERR, "failed to spawn a thread: %s",
apr_strerror(res, buf, ERRBUFLEN));
apr_pool_destroy(subpool);
apr_socket_close(socket);
}
return res;
}
int openenv(DB_ENV **pdb_env,const char *home,const char *data_dir,
const char *log_dir,FILE *err_file,
int cachesize,unsigned int flag,apr_pool_t *p)
{
int rv = -1;
if((rv = db_env_create(pdb_env,0)) != 0){
return rv;
}
if((rv = (*pdb_env)->set_cachesize((*pdb_env),0,cachesize,0)) != 0){
return rv;
}
if((rv = (*pdb_env)->set_data_dir((*pdb_env),data_dir)) != 0){
return rv;
}
if((rv = (*pdb_env)->set_lg_dir((*pdb_env),log_dir)) != 0){
return rv;
}
if((rv = (*pdb_env)->set_lk_detect((*pdb_env),DB_LOCK_DEFAULT)) != 0){
return rv;
}
if((rv = (*pdb_env)->set_tx_max((*pdb_env),1024)) != 0){
return rv;
}
if((rv = (*pdb_env)->set_lg_bsize((*pdb_env),cachesize)) != 0){
return rv;
}
if((rv =(*pdb_env)->set_flags((*pdb_env),
DB_TXN_NOSYNC,1) !=0))
{
return rv;
}
if((rv = (*pdb_env)->open((*pdb_env),home,flag,0)) != 0){
(*pdb_env)->close((*pdb_env),0);
return rv;
}
if((rv=(*pdb_env)->log_set_config((*pdb_env),DB_LOG_AUTO_REMOVE,1) != 0))
{
return rv;
}
apr_threadattr_create(&thread_attr,p);
apr_threadattr_detach_set(thread_attr,1);
rv = apr_thread_create(&chkpnt_threadid,thread_attr,chkpnt_thread,*pdb_env,p);
if(rv != APR_SUCCESS){
return -1;
}
return 0;
}
SWITCH_DECLARE(switch_status_t) switch_threadattr_create(switch_threadattr_t ** new_attr, switch_memory_pool_t *pool)
{
switch_status_t status;
if ((status = apr_threadattr_create(new_attr, pool)) == SWITCH_STATUS_SUCCESS) {
#ifndef WIN32
(*new_attr)->priority = SWITCH_PRI_LOW;
#endif
}
return status;
}
test_server_handle * test_start_looped_server(char *response_string, int port, apr_pool_t *mp) {
server_thread_data *data = apr_palloc(mp, sizeof(server_thread_data));
data->handle = apr_palloc(mp, sizeof(test_server_handle));
//apr_thread_mutex_create(&data->handle->mutex, APR_THREAD_MUTEX_UNNESTED, mp);
//apr_thread_cond_create(&data->handle->cond, mp);
data->port = port;
data->request_process_callback = looped_response_test;
data->callback_data = response_string;
apr_threadattr_t *thd_attr;
apr_threadattr_create(&thd_attr, mp);
data->handle->test_server_running = 0;
apr_status_t rv = apr_thread_create(&data->handle->test_server_thread, thd_attr, test_server_run, (void*)data, mp);
assert(rv == APR_SUCCESS);
while(data->handle->test_server_running ==0) {
apr_sleep(100);
}
return data->handle;
}
static int selinux_handler(request_rec *r)
{
apr_threadattr_t *thread_attr;
apr_thread_t *thread;
apr_status_t rv, thread_rv;
/*
* If the hook is invoked under the worker context,
* we simply skips this module.
*/
if (am_worker)
return DECLINED;
apr_threadattr_create(&thread_attr, r->pool);
/* 0 means PTHREAD_CREATE_JOINABLE */
apr_threadattr_detach_set(thread_attr, 0);
rv = apr_thread_create(&thread, thread_attr,
selinux_worker_handler,
r, r->pool);
if (rv != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, errno, r,
"Unable to launch a one-time worker thread");
return HTTP_INTERNAL_SERVER_ERROR;
}
rv = apr_thread_join(&thread_rv, thread);
if (rv != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, errno, r,
"Unable to join the one-time worker thread");
/* kill itself to clean up the thread */
r->connection->aborted = 1;
return HTTP_INTERNAL_SERVER_ERROR;
}
return thread_rv;
}
int main(int argc, const char **argv)
{
apr_status_t status;
apr_pool_t *pool;
apr_sockaddr_t *address;
serf_context_t *context;
serf_connection_t *connection;
app_baton_t app_ctx;
handler_baton_t *handler_ctx;
apr_uri_t url;
const char *raw_url, *method;
int count;
apr_getopt_t *opt;
char opt_c;
char *authn = NULL;
const char *opt_arg;
/* For the parser threads */
apr_thread_t *thread[3];
apr_threadattr_t *tattr;
apr_status_t parser_status;
parser_baton_t *parser_ctx;
apr_initialize();
atexit(apr_terminate);
apr_pool_create(&pool, NULL);
apr_atomic_init(pool);
/* serf_initialize(); */
/* Default to one round of fetching. */
count = 1;
/* Default to GET. */
method = "GET";
apr_getopt_init(&opt, pool, argc, argv);
while ((status = apr_getopt(opt, "a:hv", &opt_c, &opt_arg)) ==
APR_SUCCESS) {
int srclen, enclen;
switch (opt_c) {
case 'a':
srclen = strlen(opt_arg);
enclen = apr_base64_encode_len(srclen);
authn = apr_palloc(pool, enclen + 6);
strcpy(authn, "Basic ");
(void) apr_base64_encode(&authn[6], opt_arg, srclen);
break;
case 'h':
print_usage(pool);
exit(0);
break;
case 'v':
puts("Serf version: " SERF_VERSION_STRING);
exit(0);
default:
break;
}
}
if (opt->ind != opt->argc - 1) {
print_usage(pool);
exit(-1);
}
raw_url = argv[opt->ind];
apr_uri_parse(pool, raw_url, &url);
if (!url.port) {
url.port = apr_uri_port_of_scheme(url.scheme);
}
if (!url.path) {
url.path = "/";
}
if (strcasecmp(url.scheme, "https") == 0) {
app_ctx.using_ssl = 1;
}
else {
app_ctx.using_ssl = 0;
}
status = apr_sockaddr_info_get(&address,
url.hostname, APR_UNSPEC, url.port, 0,
pool);
if (status) {
printf("Error creating address: %d\n", status);
exit(1);
}
context = serf_context_create(pool);
/* ### Connection or Context should have an allocator? */
app_ctx.bkt_alloc = serf_bucket_allocator_create(pool, NULL, NULL);
app_ctx.ssl_ctx = NULL;
app_ctx.authn = authn;
connection = serf_connection_create(context, address,
conn_setup, &app_ctx,
closed_connection, &app_ctx,
pool);
handler_ctx = (handler_baton_t*)serf_bucket_mem_alloc(app_ctx.bkt_alloc,
sizeof(handler_baton_t));
handler_ctx->allocator = app_ctx.bkt_alloc;
handler_ctx->doc_queue = apr_array_make(pool, 1, sizeof(doc_path_t*));
handler_ctx->doc_queue_alloc = app_ctx.bkt_alloc;
handler_ctx->requests_outstanding =
(apr_uint32_t*)serf_bucket_mem_alloc(app_ctx.bkt_alloc,
sizeof(apr_uint32_t));
apr_atomic_set32(handler_ctx->requests_outstanding, 0);
handler_ctx->hdr_read = 0;
parser_ctx = (void*)serf_bucket_mem_alloc(app_ctx.bkt_alloc,
sizeof(parser_baton_t));
parser_ctx->requests_outstanding = handler_ctx->requests_outstanding;
parser_ctx->connection = connection;
parser_ctx->app_ctx = &app_ctx;
parser_ctx->doc_queue = handler_ctx->doc_queue;
parser_ctx->doc_queue_alloc = handler_ctx->doc_queue_alloc;
/* Restrict ourselves to this host. */
parser_ctx->hostinfo = url.hostinfo;
status = apr_thread_mutex_create(&parser_ctx->mutex,
APR_THREAD_MUTEX_DEFAULT, pool);
if (status) {
printf("Couldn't create mutex %d\n", status);
return status;
}
status = apr_thread_cond_create(&parser_ctx->condvar, pool);
if (status) {
printf("Couldn't create condvar: %d\n", status);
return status;
}
/* Let the handler now which condvar to use. */
handler_ctx->doc_queue_condvar = parser_ctx->condvar;
apr_threadattr_create(&tattr, pool);
/* Start the parser thread. */
apr_thread_create(&thread[0], tattr, parser_thread, parser_ctx, pool);
/* Deliver the first request. */
create_request(url.hostinfo, url.path, NULL, NULL, parser_ctx, pool);
/* Go run our normal thread. */
while (1) {
int tries = 0;
status = serf_context_run(context, SERF_DURATION_FOREVER, pool);
if (APR_STATUS_IS_TIMEUP(status))
continue;
if (status) {
char buf[200];
printf("Error running context: (%d) %s\n", status,
apr_strerror(status, buf, sizeof(buf)));
exit(1);
}
/* We run this check to allow our parser threads to add more
* requests to our queue.
*/
for (tries = 0; tries < 3; tries++) {
if (!apr_atomic_read32(handler_ctx->requests_outstanding)) {
#ifdef SERF_VERBOSE
printf("Waiting...");
#endif
apr_sleep(100000);
#ifdef SERF_VERBOSE
printf("Done\n");
#endif
}
else {
break;
}
}
if (tries >= 3) {
break;
}
/* Debugging purposes only! */
serf_debug__closed_conn(app_ctx.bkt_alloc);
}
printf("Quitting...\n");
serf_connection_close(connection);
/* wake up the parser via condvar signal */
apr_thread_cond_signal(parser_ctx->condvar);
status = apr_thread_join(&parser_status, thread[0]);
if (status) {
printf("Error joining thread: %d\n", status);
return status;
}
serf_bucket_mem_free(app_ctx.bkt_alloc, handler_ctx->requests_outstanding);
serf_bucket_mem_free(app_ctx.bkt_alloc, parser_ctx);
apr_pool_destroy(pool);
return 0;
}
void mapcache_prefetch_tiles(mapcache_context *ctx, mapcache_tile **tiles, int ntiles)
{
apr_thread_t **threads;
apr_threadattr_t *thread_attrs;
int nthreads;
#if !APR_HAS_THREADS
int i;
for(i=0; i<ntiles; i++) {
mapcache_tileset_tile_get(ctx, tiles[i]);
GC_CHECK_ERROR(ctx);
}
#else
int i,rv;
_thread_tile* thread_tiles;
if(ntiles==1 || ctx->config->threaded_fetching == 0) {
/* if threads disabled, or only fetching a single tile, don't launch a thread for the operation */
for(i=0; i<ntiles; i++) {
mapcache_tileset_tile_get(ctx, tiles[i]);
GC_CHECK_ERROR(ctx);
}
return;
}
/* allocate a thread struct for each tile. Not all will be used */
thread_tiles = (_thread_tile*)apr_pcalloc(ctx->pool,ntiles*sizeof(_thread_tile));
#if 1 || !USE_THREADPOOL
/* use multiple threads, to fetch from multiple metatiles and/or multiple tilesets */
apr_threadattr_create(&thread_attrs, ctx->pool);
threads = (apr_thread_t**)apr_pcalloc(ctx->pool, ntiles*sizeof(apr_thread_t*));
nthreads = 0;
for(i=0; i<ntiles; i++) {
int j;
thread_tiles[i].tile = tiles[i];
thread_tiles[i].launch = 1;
j=i-1;
/*
* we only launch one thread per metatile as in the unseeded case the threads
* for a same metatile will lock while only a single thread launches the actual
* rendering request
*/
while(j>=0) {
/* check that the given metatile hasn't been rendered yet */
if(thread_tiles[j].launch &&
(thread_tiles[i].tile->tileset == thread_tiles[j].tile->tileset) &&
(thread_tiles[i].tile->x / thread_tiles[i].tile->tileset->metasize_x ==
thread_tiles[j].tile->x / thread_tiles[j].tile->tileset->metasize_x)&&
(thread_tiles[i].tile->y / thread_tiles[i].tile->tileset->metasize_y ==
thread_tiles[j].tile->y / thread_tiles[j].tile->tileset->metasize_y)) {
thread_tiles[i].launch = 0; /* this tile will not have a thread spawned for it */
break;
}
j--;
}
if(thread_tiles[i].launch)
thread_tiles[i].ctx = ctx->clone(ctx);
}
for(i=0; i<ntiles; i++) {
if(!thread_tiles[i].launch) continue; /* skip tiles that have been marked */
rv = apr_thread_create(&threads[i], thread_attrs, _thread_get_tile, (void*)&(thread_tiles[i]), thread_tiles[i].ctx->pool);
if(rv != APR_SUCCESS) {
ctx->set_error(ctx,500, "failed to create thread %d of %d\n",i,ntiles);
break;
}
nthreads++;
}
/* wait for launched threads to finish */
for(i=0; i<ntiles; i++) {
if(!thread_tiles[i].launch) continue;
apr_thread_join(&rv, threads[i]);
if(rv != APR_SUCCESS) {
ctx->set_error(ctx,500, "thread %d of %d failed on exit\n",i,ntiles);
}
if(GC_HAS_ERROR(thread_tiles[i].ctx)) {
/* transfer error message from child thread to main context */
ctx->set_error(ctx,thread_tiles[i].ctx->get_error(thread_tiles[i].ctx),
thread_tiles[i].ctx->get_error_message(thread_tiles[i].ctx));
}
}
for(i=0; i<ntiles; i++) {
/* fetch the tiles that did not get a thread launched for them */
if(thread_tiles[i].launch) continue;
mapcache_tileset_tile_get(ctx, tiles[i]);
GC_CHECK_ERROR(ctx);
}
#else
/* experimental version using a threadpool, disabled for stability reasons */
apr_thread_pool_t *thread_pool;
apr_thread_pool_create(&thread_pool,2,ctx->config->download_threads,ctx->pool);
for(i=0; i<ntiles; i++) {
ctx->log(ctx,MAPCACHE_DEBUG,"starting thread for tile %s",tiles[i]->tileset->name);
thread_tiles[i].tile = tiles[i];
thread_tiles[i].ctx = ctx->clone(ctx);
rv = apr_thread_pool_push(thread_pool,_thread_get_tile,(void*)&(thread_tiles[i]), 0,NULL);
if(rv != APR_SUCCESS) {
ctx->set_error(ctx,500, "failed to push thread %d of %d in thread pool\n",i,ntiles);
break;
}
}
GC_CHECK_ERROR(ctx);
while(apr_thread_pool_tasks_run_count(thread_pool) != ntiles || apr_thread_pool_busy_count(thread_pool)>0)
apr_sleep(10000);
apr_thread_pool_destroy(thread_pool);
for(i=0; i<ntiles; i++) {
if(GC_HAS_ERROR(thread_tiles[i].ctx)) {
ctx->set_error(ctx,thread_tiles[i].ctx->get_error(thread_tiles[i].ctx),
thread_tiles[i].ctx->get_error_message(thread_tiles[i].ctx));
}
}
#endif
#endif
}
SWITCH_DECLARE(switch_status_t) switch_threadattr_create(switch_threadattr_t ** new_attr, switch_memory_pool_t *pool)
{
return apr_threadattr_create(new_attr, pool);
}
void lfd_listen(apr_pool_t * mp)
{
apr_pool_t * thd_pool = NULL;
apr_socket_t * listen_sock;
apr_socket_t * client_sock;
apr_thread_t *thd;
apr_threadattr_t * thattr;
apr_pollfd_t pfd;
apr_interval_time_t timeout = lfd_config_max_acceptloop_timeout;
apr_int32_t nsds;
apr_status_t rc;
create_listen_socket(&listen_sock, mp);
if(NULL == listen_sock)
{
lfd_log(LFD_ERROR, "lfd_listen: could not create listen socket");
return;
}
rc = apr_threadattr_create(&thattr, mp);
if(APR_SUCCESS != rc)
{
lfd_log_apr_err(rc, "apr_threadattr_create failed");
return;
}
while(1)
{
//###: Should I allocate the pool as a subpool of the root pool?
//What is the amount allocated per pool and is it freed when the child pool is destroyed?
//rc = apr_pool_create(&thd_pool, mp);
if(NULL == thd_pool)
{
rc = apr_pool_create(&thd_pool, NULL);
if(APR_SUCCESS != rc)
{
lfd_log_apr_err(rc, "apr_pool_create of thd_pool failed");
continue;
}
}
create_pollfd_from_socket(&pfd, listen_sock, mp);
rc = apr_poll(&pfd, 1, &nsds, timeout);
if((APR_SUCCESS != rc) && (!APR_STATUS_IS_TIMEUP(rc)) && (!APR_STATUS_IS_EINTR(rc)))
{
//break - an unrecoverable error occured
lfd_log_apr_err(rc, "apr_poll failed");
break;
}
if(apr_atomic_read32(&ftp_must_exit))
{
//if the flag says we must exit, we comply, so bye bye!
return;
}
if(APR_STATUS_IS_TIMEUP(rc) || APR_STATUS_IS_EINTR(rc) || (APR_POLLIN != pfd.rtnevents))
{
continue;
}
rc = apr_socket_accept(&client_sock, listen_sock, thd_pool);
if(APR_SUCCESS != rc)
{
//###: For which errorcode must we break out of the loop?
lfd_log_apr_err(rc, "apr_socket_accept failed");
if(APR_STATUS_IS_EAGAIN(rc))
{
lfd_log(LFD_ERROR, "lfd_listen: APR_STATUS_IS_EAGAIN");
}
continue;
}
rc = apr_thread_create(&thd, thattr, &lfd_worker_protocol_main, (void*)client_sock, thd_pool);
if(APR_SUCCESS != rc)
{
lfd_log_apr_err(rc, "apr_thread_create failed");
apr_socket_close(client_sock);
continue;
}
thd_pool = NULL;
}
}
void * CALLBACK mosquitto_on_connect(const WebSocketServer *server)
{
MosquittoData *dib = NULL;
apr_sockaddr_t *sa;
if ((server != NULL) && (server->version == WEBSOCKET_SERVER_VERSION_1)) {
/* Get access to the request_rec strucure for this connection */
request_rec *r = server->request(server);
if (r != NULL) {
apr_pool_t *pool = NULL;
size_t i, count = server->protocol_count(server);
/* Only support "mqtt" */
for (i = 0; i < count; i++) {
const char *protocol = server->protocol_index(server, i);
if ((protocol != NULL) &&
(strncmp(protocol, "mqtt",4) == 0)) {
/* If the client can speak the protocol, set it in the response */
server->protocol_set(server, protocol);
break;
}
}
/* If the protocol negotiation worked, create a new memory pool */
if ((i < count) &&
(apr_pool_create(&pool, r->pool) == APR_SUCCESS)) {
/* Allocate memory to hold mosquitto state */
if ((dib = (MosquittoData *) apr_palloc(pool, sizeof(MosquittoData))) != NULL) {
apr_thread_t *thread = NULL;
apr_threadattr_t *thread_attr = NULL;
dib->server = server;
dib->pool = pool;
dib->thread = NULL;
dib->counter = 0;
dib->active = 1;
request_rec *r = server->request(server);
mosquitto_cfg* dir = ap_get_module_config(r->per_dir_config, &mod_websocket_mosquitto) ;
int rv = apr_sockaddr_info_get(&sa,dir->broker,APR_UNSPEC,atoi(dir->port),APR_IPV6_ADDR_OK ,pool);
if (rv)
ap_log_error(APLOG_MARK, APLOG_CRIT,0,NULL,"apr_sockaddr_info_get failed #%x",rv);
else
ap_log_error(APLOG_MARK, APLOG_DEBUG,0,NULL,"Address family %s",sa->family == APR_INET6 ? "IPv6" : "IPv4");
rv = apr_socket_create(&dib->sockfd,sa->family, SOCK_STREAM, APR_PROTO_TCP,pool);
if (rv) ap_log_error(APLOG_MARK, APLOG_CRIT,0,NULL,"apr_socket_create failed #%x",rv);
rv = apr_socket_connect(dib->sockfd,sa);
if (rv) ap_log_error(APLOG_MARK, APLOG_CRIT,0,NULL,"apr_socket_connect failed #%x",rv);
/* Create a non-detached thread that will perform the work */
if ((apr_threadattr_create(&thread_attr, pool) == APR_SUCCESS) &&
(apr_threadattr_detach_set(thread_attr, 0) == APR_SUCCESS) &&
(apr_thread_create(&thread, thread_attr, mosquitto_run, dib, pool) == APR_SUCCESS)) {
dib->thread = thread;
/* Success */
pool = NULL;
} else {
dib = NULL;
}
}
if (pool != NULL) {
apr_pool_destroy(pool);
}
}
}
}
return dib;
}
static int process_security_handler(request_rec *r)
{
int i;
const char *extension;
apr_threadattr_t *thread_attr;
apr_thread_t *thread;
apr_status_t status, thread_status;
int enable = 0;
int name_len = 0;
process_security_config_t *conf = ap_get_module_config(r->server->module_config, &process_security_module);
if (thread_on)
return DECLINED;
if (conf->all_ext_enable) {
enable = ON;
} else {
for (i = 0; i < conf->extensions->nelts; i++) {
extension = ((char **)conf->extensions->elts)[i];
name_len = strlen(r->filename) - strlen(extension);
if (name_len >= 0 && strcmp(&r->filename[name_len], extension) == 0)
enable = ON;
}
}
if (!enable)
return DECLINED;
apr_threadattr_create(&thread_attr, r->pool);
apr_threadattr_detach_set(thread_attr, 0);
status = apr_thread_create(&thread
, thread_attr
, process_security_thread_handler
, r
, r->pool);
if (status != APR_SUCCESS) {
ap_log_error (APLOG_MARK
, APLOG_ERR
, 0
, NULL
, "%s ERROR %s: Unable to create a thread"
, MODULE_NAME
, __func__
);
return HTTP_INTERNAL_SERVER_ERROR;
}
status = apr_thread_join(&thread_status, thread);
if (status != APR_SUCCESS) {
ap_log_error (APLOG_MARK
, APLOG_ERR
, 0
, NULL
, "%s ERROR %s: Unable to join a thread"
, MODULE_NAME
, __func__
);
r->connection->aborted = 1;
return HTTP_INTERNAL_SERVER_ERROR;
}
return thread_status;
}
static int build_startup_data(const WebSocketServer *server) {
apr_pool_t *main_pool = NULL;
apr_pool_t *stateful_session_pool = NULL;
apr_thread_t *thread = NULL;
apr_threadattr_t *thread_attr = NULL;
apr_thread_mutex_t *mutex = NULL;
request_rec *r = server->request(server);
// create a pool for our translator data
// Do not use r->pool as the parent, since r->pool will be freed
// when the current client disconnects.
if (apr_pool_create(&main_pool, NULL) != APR_SUCCESS) {
osrfLogError(OSRF_LOG_MARK, "WS Unable to create apr_pool");
return 1;
}
trans = (osrfWebsocketTranslator*)
apr_palloc(main_pool, sizeof(osrfWebsocketTranslator));
if (trans == NULL) {
osrfLogError(OSRF_LOG_MARK, "WS Unable to create translator");
return 1;
}
trans->server = server;
trans->main_pool = main_pool;
trans->osrf_router = osrfConfigGetValue(NULL, "/router_name");
trans->osrf_domain = osrfConfigGetValue(NULL, "/domain");
// opensrf session / recipient cache
trans->stateful_session_cache = apr_hash_make(trans->main_pool);
if (trans->stateful_session_cache == NULL) {
osrfLogError(OSRF_LOG_MARK, "WS unable to create session cache");
return 1;
}
// opensrf session / recipient string pool; cleared regularly
// the only data entering this pools are the session strings.
if (apr_pool_create(&stateful_session_pool, trans->main_pool) != APR_SUCCESS) {
osrfLogError(OSRF_LOG_MARK, "WS Unable to create apr_pool");
return NULL;
}
trans->stateful_session_pool = stateful_session_pool;
if (apr_thread_mutex_create(
&mutex, APR_THREAD_MUTEX_UNNESTED,
trans->main_pool) != APR_SUCCESS) {
osrfLogError(OSRF_LOG_MARK, "WS unable to create thread mutex");
return 1;
}
trans->mutex = mutex;
// responder thread
if ( (apr_threadattr_create(&thread_attr, trans->main_pool) == APR_SUCCESS) &&
(apr_threadattr_detach_set(thread_attr, 0) == APR_SUCCESS) &&
(apr_thread_create(&thread, thread_attr,
osrf_responder_thread_main, trans, trans->main_pool) == APR_SUCCESS)) {
trans->responder_thread = thread;
} else {
osrfLogError(OSRF_LOG_MARK, "WS unable to create responder thread");
return 1;
}
// idle timeout thread
thread = NULL; // reset
thread_attr = NULL; // reset
if ( (apr_threadattr_create(&thread_attr, trans->main_pool) == APR_SUCCESS) &&
(apr_threadattr_detach_set(thread_attr, 0) == APR_SUCCESS) &&
(apr_thread_create(&thread, thread_attr,
osrf_idle_timeout_thread_main, trans, trans->main_pool) == APR_SUCCESS)) {
osrfLogDebug(OSRF_LOG_MARK, "WS created idle timeout thread");
trans->idle_timeout_thread = thread;
} else {
osrfLogError(OSRF_LOG_MARK, "WS unable to create idle timeout thread");
return 1;
}
return APR_SUCCESS;
}
void *CALLBACK tcp_proxy_on_connect(const WebSocketServer * server)
{
TcpProxyData *tpd = NULL;
if ((server != NULL) && (server->version == WEBSOCKET_SERVER_VERSION_1)) {
/* Get access to the request_rec strucure for this connection */
request_rec *r = server->request(server);
APACHELOG(APLOG_DEBUG, r, "tcp_proxy_on_connect starting");
if (r != NULL) {
apr_pool_t *pool = NULL;
size_t i = 0, count = server->protocol_count(server);
websocket_tcp_proxy_config_rec *conf =
(websocket_tcp_proxy_config_rec *) ap_get_module_config(r->
per_dir_config,
&websocket_tcp_proxy_module);
const char *requiredprotocol = conf ? conf->protocol : NULL;
if (requiredprotocol) {
for (i = 0; i < count; i++) {
const char *protocol = server->protocol_index(server, i);
if (protocol && (strcmp(protocol, requiredprotocol) == 0)) {
/* If the client can speak the protocol, set it in the response */
server->protocol_set(server, protocol);
break;
}
}
}
else {
count = 1; /* ensure i<count */
}
/* If the protocol negotiation worked, create a new memory pool */
if ((i < count) &&
(apr_pool_create(&pool, r->pool) == APR_SUCCESS)) {
APACHELOG(APLOG_DEBUG, r,
"tcp_proxy_on_connect protocol correct");
/* Allocate memory to hold the tcp proxy state */
if ((tpd =
(TcpProxyData *) apr_palloc(pool,
sizeof(TcpProxyData))) !=
NULL) {
apr_thread_t *thread = NULL;
apr_threadattr_t *thread_attr = NULL;
tpd->server = server;
tpd->pool = pool;
tpd->thread = NULL;
tpd->tcpsocket = NULL;
tpd->active = 1;
tpd->base64 = 0;
tpd->timeout = 30;
tpd->port = "echo";
tpd->host = "127.0.0.1";
tpd->initialdata = NULL;
websocket_tcp_proxy_config_rec *conf =
(websocket_tcp_proxy_config_rec *)
ap_get_module_config(r->per_dir_config,
&websocket_tcp_proxy_module);
if (conf) {
tpd->base64 = conf->base64;
tpd->timeout = conf->timeout;
if (conf->host)
tpd->host = apr_pstrdup(pool, conf->host);
if (conf->port)
tpd->port = apr_pstrdup(pool, conf->port);
APACHELOG(APLOG_DEBUG, r,
"tcp_proxy_on_connect: base64 is %d",
conf->base64);
}
else {
APACHELOG(APLOG_DEBUG, r,
"tcp_proxy_on_connect: no config");
}
/* Check we can authenticate the incoming user (this is a hook for others to add to)
* Check we can connect
* And if we have initial data to send, then send that
*/
if ((APR_SUCCESS ==
tcp_proxy_do_authenticate(r, tpd, pool))
&& (APR_SUCCESS ==
tcp_proxy_do_tcp_connect(r, tpd, pool))
&& (APR_SUCCESS ==
tcp_proxy_send_initial_data(r, tpd, pool))) {
/* Create a non-detached thread that will perform the work */
if ((apr_threadattr_create(&thread_attr, pool) ==
APR_SUCCESS)
&& (apr_threadattr_detach_set(thread_attr, 0) ==
APR_SUCCESS)
&&
(apr_thread_create
(&thread, thread_attr, tcp_proxy_run, tpd,
pool) == APR_SUCCESS)) {
tpd->thread = thread;
/* Success */
pool = NULL;
}
else {
tpd = NULL;
}
}
else
tpd = NULL;
}
if (pool != NULL) {
apr_pool_destroy(pool);
}
}
}
}
return tpd;
}
