ret_t
cherokee_logger_writer_new (cherokee_logger_writer_t **writer)
{
CHEROKEE_NEW_STRUCT(n,logger_writer);
INIT_LIST_HEAD (&n->listed);
n->type = cherokee_logger_writer_syslog;
n->fd = -1;
n->max_bufsize = DEFAULT_LOGGER_MAX_BUFSIZE;
cherokee_buffer_init (&n->command);
cherokee_buffer_init (&n->filename);
cherokee_buffer_init (&n->buffer);
cherokee_buffer_ensure_size (&n->buffer, n->max_bufsize);
n->priv = malloc (sizeof(priv_t));
if (n->priv == NULL) {
cherokee_buffer_mrproper (&n->buffer);
free(n);
return ret_nomem;
}
CHEROKEE_MUTEX_INIT (&PRIV(n)->mutex, NULL);
n->initialized = false;
*writer = n;
return ret_ok;
}
ret_t
cherokee_handler_proxy_hosts_init (cherokee_handler_proxy_hosts_t *hosts)
{
CHEROKEE_MUTEX_INIT (&hosts->hosts_mutex, CHEROKEE_MUTEX_FAST);
cherokee_avl_init (&hosts->hosts);
cherokee_buffer_init (&hosts->tmp);
return ret_ok;
}
ret_t
cherokee_handler_zeromq_configure (cherokee_config_node_t *conf,
cherokee_server_t *srv,
cherokee_module_props_t **_props)
{
ret_t ret;
cherokee_list_t *i;
cherokee_handler_zeromq_props_t *props;
cherokee_plugin_info_t *info = NULL;
/* Instance a new property object
*/
if (*_props == NULL) {
CHEROKEE_NEW_STRUCT (n, handler_zeromq_props);
cherokee_handler_props_init_base (HANDLER_PROPS(n),
MODULE_PROPS_FREE(props_free));
cherokee_buffer_init (&n->endpoint);
n->io_threads = 1;
CHEROKEE_MUTEX_INIT (&n->mutex, CHEROKEE_MUTEX_FAST);
*_props = MODULE_PROPS(n);
}
props = PROP_ZEROMQ(*_props);
/* Voodoo to get our own backend gzipper
*/
ret = cherokee_plugin_loader_get (&srv->loader, "gzip", &info);
if (ret != ret_ok) {
return ret;
}
/* Parse the configuration tree
*/
cherokee_config_node_foreach (i, conf) {
cherokee_config_node_t *subconf = CONFIG_NODE(i);
if (equal_buf_str (&subconf->key, "endpoint")) {
cherokee_buffer_clean (&props->endpoint);
cherokee_buffer_add_buffer (&props->endpoint, &subconf->val);
} else if (equal_buf_str (&subconf->key, "io_threads")) {
props->io_threads = atoi(subconf->val.buf);
} else if (equal_buf_str (&subconf->key, "encoder") && info->configure) {
encoder_func_configure_t configure = info->configure;
props->encoder_props = NULL;
ret = configure (subconf, srv, (cherokee_module_props_t **)&props->encoder_props);
if (ret != ret_ok) {
return ret;
}
props->encoder_props->instance_func = PLUGIN_INFO(info)->instance;
}
}
static ret_t
priv_new (priv_t **priv)
{
priv_t *n;
n = malloc (sizeof (priv_t));
if (n == NULL) {
return ret_nomem;
}
CHEROKEE_MUTEX_INIT (&n->mutex, CHEROKEE_MUTEX_FAST);
*priv = n;
return ret_ok;
}
ret_t
cherokee_handler_proxy_poll_new (cherokee_handler_proxy_poll_t **poll,
cuint_t reuse_max)
{
CHEROKEE_NEW_STRUCT (n, handler_proxy_poll);
n->reuse_len = 0;
n->reuse_max = reuse_max;
INIT_LIST_HEAD (&n->active);
INIT_LIST_HEAD (&n->reuse);
CHEROKEE_MUTEX_INIT (&n->mutex, CHEROKEE_MUTEX_FAST);
*poll = n;
return ret_ok;
}
ret_t
cherokee_spawner_init (void)
{
#ifdef HAVE_SYSV_SEMAPHORES
ret_t ret;
cherokee_buffer_t name = CHEROKEE_BUF_INIT;
if (! _active) {
return ret_ok;
}
/* Monitor mutex */
CHEROKEE_MUTEX_INIT (&spawning_mutex, CHEROKEE_MUTEX_FAST);
/* Shared memory */
cherokee_buffer_add_va (&name, TMPDIR "/cherokee-spawner-%d", getppid());
ret = cherokee_shm_init (&cherokee_spawn_shared);
if (ret != ret_ok) {
goto error;
}
ret = cherokee_shm_map (&cherokee_spawn_shared, &name);
if (ret != ret_ok) {
goto error;
}
/* Semaphore */
cherokee_spawn_sem = semget (getppid(), 0, 0);
if (cherokee_spawn_sem < 0) {
goto error;
}
TRACE (ENTRIES",sem", "Got semaphore %d\n", cherokee_spawn_sem);
cherokee_buffer_mrproper (&name);
return ret_ok;
error:
LOG_ERRNO (errno, cherokee_err_warning, CHEROKEE_ERROR_SPAWNER_TMP_INIT, name.buf);
cherokee_buffer_mrproper (&name);
return ret_error;
#else
return ret_not_found;
#endif
}
static ret_t
iocache_entry_new_cb (cherokee_cache_t *cache,
cherokee_buffer_t *key,
void *param,
cherokee_cache_entry_t **ret_entry)
{
CHEROKEE_NEW_STRUCT(n, iocache_entry_extension);
UNUSED(param);
CHEROKEE_MUTEX_INIT (&PRIV(n)->parent_lock, CHEROKEE_MUTEX_FAST);
/* Init its parent class
*/
#ifdef HAVE_PTHREAD
cherokee_cache_entry_init (CACHE_ENTRY(n), key, cache, &PRIV(n)->parent_lock);
#else
cherokee_cache_entry_init (CACHE_ENTRY(n), key, cache, NULL);
#endif
/* Set the virtual methods
*/
CACHE_ENTRY(n)->clean_cb = clean_info_cb;
CACHE_ENTRY(n)->fetch_cb = fetch_info_cb;
CACHE_ENTRY(n)->free_cb = free_cb;
/* Init its properties
*/
PRIV(n)->stat_expiration = 0;
PRIV(n)->mmap_expiration = 0;
PUBL(n)->mmaped = NULL;
PUBL(n)->mmaped_len = 0;
PUBL(n)->info = 0;
PUBL(n)->state_ret = ret_ok;
/* Return the new object
*/
*ret_entry = CACHE_ENTRY(n);
return ret_ok;
}
ret_t
cherokee_logger_init_base (cherokee_logger_t *logger,
cherokee_plugin_info_t *info,
cherokee_config_node_t *config)
{
ret_t ret;
CHEROKEE_NEW_TYPE(priv, struct cherokee_logger_private);
/* Init the base class
*/
cherokee_module_init_base (MODULE(logger), NULL, info);
/* Pure virtual methods
*/
logger->priv = priv;
logger->write_access = NULL;
logger->utc_time = false;
/* Private
*/
logger->priv->backup_mode = false;
CHEROKEE_MUTEX_INIT (&PRIV(logger)->mutex, NULL);
cherokee_x_real_ip_init (&logger->priv->x_real_ip);
/* Read the configuration
*/
ret = cherokee_x_real_ip_configure (&logger->priv->x_real_ip, config);
if (ret != ret_ok) {
return ret_error;
}
cherokee_config_node_read_bool (config, "utc_time", &logger->utc_time);
return ret_ok;
}