ret_t
cherokee_handler_streaming_configure (cherokee_config_node_t *conf,
cherokee_server_t *srv,
cherokee_module_props_t **_props)
{
ret_t ret;
cherokee_list_t *i;
cherokee_handler_streaming_props_t *props;
if (*_props == NULL) {
CHEROKEE_NEW_STRUCT (n, handler_streaming_props);
cherokee_handler_props_init_base (HANDLER_PROPS(n),
MODULE_PROPS_FREE(cherokee_handler_streaming_props_free));
n->props_file = NULL;
n->auto_rate = true;
n->auto_rate_factor = 0.1;
n->auto_rate_boost = 5;
*_props = MODULE_PROPS(n);
}
props = PROP_STREAMING(*_props);
/* Parse 'streaming' parameters
*/
cherokee_config_node_foreach (i, conf) {
cherokee_config_node_t *subconf = CONFIG_NODE(i);
if (equal_buf_str (&subconf->key, "rate")) {
ret = cherokee_atob (subconf->val.buf, &props->auto_rate);
if (ret != ret_ok) return ret_error;
} else if (equal_buf_str (&subconf->key, "rate_factor")) {
props->auto_rate_factor = strtof (subconf->val.buf, NULL);
} else if (equal_buf_str (&subconf->key, "rate_boost")) {
ret = cherokee_atoi (subconf->val.buf, &props->auto_rate_boost);
if (ret != ret_ok) return ret_error;
}
}
ret_t
cherokee_handler_secdownload_configure (cherokee_config_node_t *conf,
cherokee_server_t *srv,
cherokee_module_props_t **_props)
{
ret_t ret;
cherokee_handler_secdownload_props_t *props;
if (*_props == NULL) {
CHEROKEE_NEW_STRUCT (n, handler_secdownload_props);
cherokee_handler_props_init_base (HANDLER_PROPS(n),
MODULE_PROPS_FREE(cherokee_handler_secdownload_props_free));
cherokee_buffer_init (&n->secret);
n->timeout = 60;
*_props = MODULE_PROPS(n);
}
props = PROP_SECDOWN(*_props);
/* Parse 'file' parameters
*/
props->props_file = NULL;
ret = cherokee_handler_file_configure (conf, srv, (cherokee_module_props_t **)&props->props_file);
if ((ret != ret_ok) && (ret != ret_deny))
return ret;
/* Properties
*/
ret = cherokee_config_node_copy (conf, "secret", &props->secret);
if (ret != ret_ok) {
LOG_CRITICAL_S (CHEROKEE_ERROR_HANDLER_SECDOWN_SECRET);
return ret_error;
}
cherokee_config_node_read_int (conf, "timeout", (int*)&props->timeout);
return ret_ok;
}
ret_t
cherokee_handler_cgi_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_module_props_t **_props)
{
cherokee_handler_cgi_props_t *props;
/* Instance a new property object
*/
if (*_props == NULL) {
CHEROKEE_NEW_STRUCT (n, handler_cgi_props);
cherokee_handler_cgi_base_props_init_base (PROP_CGI_BASE(n),
MODULE_PROPS_FREE(cherokee_handler_cgi_props_free));
*_props = MODULE_PROPS(n);
}
props = PROP_CGI(*_props);
/* Parse local options
*/
return cherokee_handler_cgi_base_configure (conf, srv, _props);
}
ret_t
cherokee_validator_htdigest_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_module_props_t **_props)
{
cherokee_validator_htdigest_props_t *props;
UNUSED(srv);
if (*_props == NULL) {
CHEROKEE_NEW_STRUCT (n, validator_htdigest_props);
cherokee_validator_file_props_init_base (PROP_VFILE(n),
MODULE_PROPS_FREE(props_free));
*_props = MODULE_PROPS(n);
}
props = PROP_HTDIGEST(*_props);
/* Call the file based validator configure
*/
return cherokee_validator_file_configure (conf, srv, _props);
}
ret_t
cherokee_handler_init_base (cherokee_handler_t *hdl,
void *conn,
cherokee_handler_props_t *props,
cherokee_plugin_info_handler_t *info)
{
/* Init the base class
*/
cherokee_module_init_base (MODULE(hdl), MODULE_PROPS(props), PLUGIN_INFO(info));
/* Pure virtual methods
*/
hdl->read_post = NULL;
hdl->add_headers = NULL;
hdl->step = NULL;
/* Parent reference
*/
hdl->connection = conn;
return ret_ok;
}
ret_t
cherokee_validator_init_base (cherokee_validator_t *validator,
cherokee_validator_props_t *props,
cherokee_plugin_info_validator_t *info)
{
cherokee_module_init_base (MODULE(validator), MODULE_PROPS(props), PLUGIN_INFO(info));
validator->check = NULL;
cherokee_buffer_init (&validator->user);
cherokee_buffer_init (&validator->passwd);
cherokee_buffer_init (&validator->realm);
cherokee_buffer_init (&validator->response);
cherokee_buffer_init (&validator->uri);
cherokee_buffer_init (&validator->qop);
cherokee_buffer_init (&validator->nonce);
cherokee_buffer_init (&validator->cnonce);
cherokee_buffer_init (&validator->algorithm);
cherokee_buffer_init (&validator->nc);
return ret_ok;
}
ret_t
cherokee_validator_ldap_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_module_props_t **_props)
{
ret_t ret;
cherokee_list_t *i;
cherokee_validator_ldap_props_t *props;
UNUSED(srv);
if (*_props == NULL) {
CHEROKEE_NEW_STRUCT (n, validator_ldap_props);
cherokee_validator_props_init_base (VALIDATOR_PROPS(n), MODULE_PROPS_FREE(props_free));
n->port = LDAP_DEFAULT_PORT;
n->tls = false;
cherokee_buffer_init (&n->server);
cherokee_buffer_init (&n->binddn);
cherokee_buffer_init (&n->bindpw);
cherokee_buffer_init (&n->basedn);
cherokee_buffer_init (&n->filter);
cherokee_buffer_init (&n->ca_file);
*_props = MODULE_PROPS(n);
}
props = PROP_LDAP(*_props);
cherokee_config_node_foreach (i, conf) {
cherokee_config_node_t *subconf = CONFIG_NODE(i);
if (equal_buf_str (&subconf->key, "server")) {
cherokee_buffer_add_buffer (&props->server, &subconf->val);
} else if (equal_buf_str (&subconf->key, "port")) {
ret = cherokee_atoi (subconf->val.buf, &props->port);
if (ret != ret_ok) return ret_error;
} else if (equal_buf_str (&subconf->key, "bind_dn")) {
cherokee_buffer_add_buffer (&props->binddn, &subconf->val);
} else if (equal_buf_str (&subconf->key, "bind_pw")) {
cherokee_buffer_add_buffer (&props->bindpw, &subconf->val);
} else if (equal_buf_str (&subconf->key, "base_dn")) {
cherokee_buffer_add_buffer (&props->basedn, &subconf->val);
} else if (equal_buf_str (&subconf->key, "filter")) {
cherokee_buffer_add_buffer (&props->filter, &subconf->val);
} else if (equal_buf_str (&subconf->key, "tls")) {
ret = cherokee_atob (subconf->val.buf, &props->tls);
if (ret != ret_ok) return ret_error;
} else if (equal_buf_str (&subconf->key, "ca_file")) {
cherokee_buffer_add_buffer (&props->ca_file, &subconf->val);
} else if (equal_buf_str (&subconf->key, "methods") ||
equal_buf_str (&subconf->key, "realm") ||
equal_buf_str (&subconf->key, "users")) {
/* Handled in validator.c
*/
} else {
LOG_WARNING (CHEROKEE_ERROR_VALIDATOR_LDAP_KEY, subconf->key.buf);
}
}
/* Methods implementation
*/
static ret_t
props_free (cherokee_handler_server_info_props_t *props)
{
return cherokee_module_props_free_base (MODULE_PROPS(props));
}
/* A _configure function will be executed by the webserver
* at the moment of 'first' initialisation. Here you do the
* start of memory management. The processing of the configuration
* parameters.
*/
ret_t
cherokee_handler_xslt_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_module_props_t **_props)
{
cherokee_list_t *i;
cherokee_handler_xslt_props_t *props;
ret_t ret;
if (*_props == NULL) {
CHEROKEE_NEW_STRUCT (n, handler_xslt_props);
cherokee_module_props_init_base (MODULE_PROPS(n),
MODULE_PROPS_FREE(props_free));
/* Look at handler_xslt.h
* This is an xslt of configuration.
*/
xmlInitMemory();
LIBXML_TEST_VERSION
/*
* Register the EXSLT extensions and the test module
*/
exsltRegisterAll();
xsltRegisterTestModule();
cherokee_buffer_init (&n->content_type);
cherokee_buffer_init (&n->stylesheet);
n->global = NULL;
n->globalDoc = NULL;
n->xinclude = false;
n->xincludestyle = false;
// n->sec = xsltNewSecurityPrefs();
// xsltSetDefaultSecurityPrefs(n->sec);
n->defaultEntityLoader = xmlGetExternalEntityLoader();
// xmlSetExternalEntityLoader(xsltprocExternalEntityLoader);
*_props = MODULE_PROPS(n);
}
props = PROP_XSLT(*_props);
/* processing of the parameters, we only know about xslt_config
* it might be a good thing to abort if we found a wrong key, understand
* the consequences: your handler will prevent the server startup upon
* a wrong configuration.
*
* You see the for each method is rather creative. Read more code
* to see with what nice things Cherokee extended the C syntax.
*/
cherokee_config_node_foreach (i, conf) {
cherokee_config_node_t *subconf = CONFIG_NODE(i);
/* Cherokee has a nifty string equal function that allows
* lazy programmers to do strcmp without the == 0.
*/
/*if (equal_buf_str (&subconf->key, "maxdepth")) {
cherokee_atoi(subconf->val.buf, &props->xsltMaxDepth);
} else if (equal_buf_str (&subconf->key, "maxparserdepth")) {
cherokee_atoi(subconf->val.buf, &props->xsltParserMaxDepth);
} else */
if (equal_buf_str (&subconf->key, "options")) {
if (equal_buf_str (&subconf->val, "novalid")) {
props->options |= XML_PARSE_NOENT | XML_PARSE_NOCDATA;
} else if (equal_buf_str (&subconf->val, "nodtdattr")) {
props->options |= XML_PARSE_NOENT | XML_PARSE_DTDLOAD | XML_PARSE_NOCDATA;
} else {
PRINT_MSG ("ERROR: Handler xslt: Unknown value: '%s'\n", subconf->val.buf);
return ret_error;
}
} else if (equal_buf_str (&subconf->key, "nodict")) {
cherokee_boolean_t nodict;
ret = cherokee_atob (subconf->val.buf, &nodict);
if (ret != ret_ok) return ret;
if (nodict) {
props->options |= XML_PARSE_NODICT;
}
#ifdef LIBXML_CATALOG_ENABLED
} else if (equal_buf_str (&subconf->key, "catalogs")) {
cherokee_boolean_t catalogs;
ret = cherokee_atob (subconf->val.buf, &catalogs);
if (ret != ret_ok) return ret;
if (catalogs) {
const char *catalogs = getenv("SGML_CATALOG_FILES");
if (catalogs != NULL) {
xmlLoadCatalogs(catalogs);
}
}
#endif
#ifdef LIBXML_XINCLUDE_ENABLED
} else if (equal_buf_str (&subconf->key, "xinclude")) {
ret = cherokee_atob (subconf->val.buf, &props->xinclude);
} else if (equal_buf_str (&subconf->key, "xincludestyle")) {
ret = cherokee_atob (subconf->val.buf, &props->xincludestyle);
if (props->xincludestyle) {
xsltSetXIncludeDefault(1);
}
#endif
} else if (equal_buf_str (&subconf->key, "contenttype")) {
cherokee_buffer_add(&props->content_type, subconf->val.buf, subconf->val.len);
} else if (equal_buf_str (&subconf->key, "stylesheet")) {
cherokee_buffer_add(&props->stylesheet, subconf->val.buf, subconf->val.len);
} else {
PRINT_MSG ("ERROR: Handler xslt: Unknown key: '%s'\n", subconf->key.buf);
return ret_error;
}
}
ret_t
cherokee_handler_dirlist_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_module_props_t **_props)
{
ret_t ret;
cherokee_list_t *i;
cherokee_handler_dirlist_props_t *props;
const char *theme = NULL;
cherokee_buffer_t theme_path = CHEROKEE_BUF_INIT;
UNUSED(srv);
if (*_props == NULL) {
CHEROKEE_NEW_STRUCT (n, handler_dirlist_props);
cherokee_handler_props_init_base (HANDLER_PROPS(n),
MODULE_PROPS_FREE(cherokee_handler_dirlist_props_free));
n->show_size = true;
n->show_date = true;
n->show_user = false;
n->show_group = false;
n->show_icons = true;
n->show_symlinks = true;
n->redir_symlinks = false;
n->show_hidden = false;
n->show_backup = false;
cherokee_buffer_init (&n->header);
cherokee_buffer_init (&n->footer);
cherokee_buffer_init (&n->entry);
cherokee_buffer_init (&n->css);
cherokee_buffer_init (&n->icon_web_dir);
cherokee_buffer_add_str (&n->icon_web_dir, ICON_WEB_DIR_DEFAULT);
INIT_LIST_HEAD (&n->notice_files);
INIT_LIST_HEAD (&n->hidden_files);
*_props = MODULE_PROPS(n);
}
props = PROP_DIRLIST(*_props);
cherokee_config_node_foreach (i, conf) {
cherokee_config_node_t *subconf = CONFIG_NODE(i);
/* Convert the properties
*/
if (equal_buf_str (&subconf->key, "size")) {
props->show_size = !! atoi (subconf->val.buf);
} else if (equal_buf_str (&subconf->key, "date")) {
props->show_date = !! atoi (subconf->val.buf);
} else if (equal_buf_str (&subconf->key, "user")) {
props->show_user = !! atoi (subconf->val.buf);
} else if (equal_buf_str (&subconf->key, "group")) {
props->show_group = !! atoi (subconf->val.buf);
} else if (equal_buf_str (&subconf->key, "symlinks")) {
props->show_symlinks = !! atoi (subconf->val.buf);
} else if (equal_buf_str (&subconf->key, "redir_symlinks")) {
props->redir_symlinks = !! atoi (subconf->val.buf);
} else if (equal_buf_str (&subconf->key, "hidden")) {
props->show_hidden = !! atoi (subconf->val.buf);
} else if (equal_buf_str (&subconf->key, "backup")) {
props->show_backup = !! atoi (subconf->val.buf);
} else if (equal_buf_str (&subconf->key, "theme")) {
theme = subconf->val.buf;
} else if (equal_buf_str (&subconf->key, "icon_dir")) {
cherokee_buffer_clean (&props->icon_web_dir);
cherokee_buffer_add_buffer (&props->icon_web_dir, &subconf->val);
} else if (equal_buf_str (&subconf->key, "notice_files")) {
ret = cherokee_config_node_read_list (subconf, NULL, file_match_add_cb, &props->notice_files);
if (unlikely (ret != ret_ok))
return ret;
} else if (equal_buf_str (&subconf->key, "hidden_files")) {
ret = cherokee_config_node_read_list (subconf, NULL, file_match_add_cb, &props->hidden_files);
if (unlikely (ret != ret_ok))
return ret;
}
}
ret_t
cherokee_handler_props_free_base (cherokee_handler_props_t *props)
{
return cherokee_module_props_free_base (MODULE_PROPS(props));
}
ret_t
cherokee_validator_mysql_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_module_props_t **_props)
{
cherokee_list_t *i;
cherokee_validator_mysql_props_t *props;
UNUSED(srv);
if(*_props == NULL) {
CHEROKEE_NEW_STRUCT (n, validator_mysql_props);
cherokee_validator_props_init_base (VALIDATOR_PROPS (n), MODULE_PROPS_FREE(props_free));
cherokee_buffer_init (&n->host);
cherokee_buffer_init (&n->unix_socket);
cherokee_buffer_init (&n->user);
cherokee_buffer_init (&n->passwd);
cherokee_buffer_init (&n->database);
cherokee_buffer_init (&n->query);
n->port = MYSQL_DEFAULT_PORT;
n->hash_type = cherokee_mysql_hash_none;
*_props = MODULE_PROPS (n);
}
props = PROP_MYSQL(*_props);
cherokee_config_node_foreach (i, conf) {
cherokee_config_node_t *subconf = CONFIG_NODE(i);
if (equal_buf_str (&subconf->key, "host")) {
cherokee_buffer_add_buffer (&props->host, &subconf->val);
} else if (equal_buf_str (&subconf->key, "port")) {
props->port = atoi (subconf->val.buf);
} else if (equal_buf_str (&subconf->key, "unix_socket")) {
cherokee_buffer_add_buffer (&props->unix_socket, &subconf->val);
} else if (equal_buf_str (&subconf->key, "user")) {
cherokee_buffer_add_buffer (&props->user, &subconf->val);
} else if (equal_buf_str (&subconf->key, "passwd")) {
cherokee_buffer_add_buffer (&props->passwd, &subconf->val);
} else if (equal_buf_str (&subconf->key, "database")) {
cherokee_buffer_add_buffer (&props->database, &subconf->val);
} else if (equal_buf_str (&subconf->key, "query")) {
cherokee_buffer_add_buffer (&props->query, &subconf->val);
} else if (equal_buf_str (&subconf->key, "hash")) {
if (equal_buf_str (&subconf->val, "md5")) {
props->hash_type = cherokee_mysql_hash_md5;
} else if (equal_buf_str (&subconf->val, "sha1")) {
props->hash_type = cherokee_mysql_hash_sha1;
} else {
LOG_CRITICAL (CHEROKEE_ERROR_VALIDATOR_MYSQL_HASH, subconf->val.buf);
return ret_error;
}
} else if ((equal_buf_str (&subconf->key, "methods") ||
equal_buf_str (&subconf->key, "realm")))
{
/* not handled here
*/
} else {
LOG_CRITICAL (CHEROKEE_ERROR_VALIDATOR_MYSQL_KEY, subconf->key.buf);
return ret_error;
}
}
ret_t
cherokee_handler_tmi_configure (cherokee_config_node_t *conf,
cherokee_server_t *srv,
cherokee_module_props_t **_props)
{
ret_t ret;
cherokee_list_t *i;
cherokee_handler_tmi_props_t *props;
cherokee_plugin_info_t *info = NULL;
/* Instance a new property object
*/
if (*_props == NULL) {
CHEROKEE_NEW_STRUCT (n, handler_tmi_props);
cherokee_handler_props_init_base (HANDLER_PROPS(n),
MODULE_PROPS_FREE(props_free));
cherokee_buffer_init (&n->reply);
cherokee_buffer_init (&n->subscriberid);
cherokee_buffer_init (&n->version);
cherokee_buffer_init (&n->dossiername);
cherokee_buffer_init (&n->endpoint);
n->io_threads = 1;
n->validate_xml = false;
CHEROKEE_MUTEX_INIT (&n->mutex, CHEROKEE_MUTEX_FAST);
*_props = MODULE_PROPS(n);
}
props = PROP_TMI(*_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, "subscriberid")) {
cherokee_buffer_clean (&props->subscriberid);
cherokee_buffer_add_buffer (&props->subscriberid, &subconf->val);
} else if (equal_buf_str (&subconf->key, "version")) {
cherokee_buffer_clean (&props->version);
cherokee_buffer_add_buffer (&props->version, &subconf->val);
} else if (equal_buf_str (&subconf->key, "dossiername")) {
cherokee_buffer_clean (&props->dossiername);
cherokee_buffer_add_buffer (&props->dossiername, &subconf->val);
} else 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, "validate_xml")) {
cherokee_atob (subconf->val.buf, &props->validate_xml);
} 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;
}
}
ret_t
cherokee_handler_secdownload_new (cherokee_handler_t **hdl,
void *cnt,
cherokee_module_props_t *props)
{
int re;
ret_t ret;
char *p;
cuint_t path_len;
time_t time_url;
char *time_s;
cherokee_buffer_t md5 = CHEROKEE_BUF_INIT;
cherokee_connection_t *conn = CONN(cnt);
TRACE(ENTRIES, "Analyzing request '%s'\n", conn->request.buf);
/* Sanity check
*/
if (conn->request.len <= 1 + 32 + 2) {
TRACE(ENTRIES, "Malformed URL. Too short: len=%d.\n", conn->request.len);
conn->error_code = http_not_found;
return ret_error;
}
if (conn->request.buf[0] != '/') {
TRACE(ENTRIES, "Malformed URL: %s\n", "Not slash (1)");
conn->error_code = http_not_found;
return ret_error;
}
p = conn->request.buf + 1;
if (check_hex (p, 32)) {
TRACE(ENTRIES, "Malformed URL: %s\n", "No MD5");
conn->error_code = http_not_found;
return ret_error;
}
p += 32;
if (*p != '/') {
TRACE(ENTRIES, "Malformed URL: %s\n", "Not slash (2)");
conn->error_code = http_not_found;
return ret_error;
}
p += 1;
time_s = p;
if (check_hex (p, 8)) {
TRACE(ENTRIES, "Malformed URL: %s\n", "No MD5 (2)");
conn->error_code = http_not_found;
return ret_error;
}
p += 8;
/* Check the time
*/
time_url = get_time (time_s);
if ((cherokee_bogonow_now - time_url) > (int)PROP_SECDOWN(props)->timeout) {
TRACE(ENTRIES, "Time out: %d (now=%d)\n", time_url, cherokee_bogonow_now);
conn->error_code = http_gone;
return ret_error;
}
/* Check the MD5
* [secret][path][hex(time)]
*/
path_len = (conn->request.buf + conn->request.len) - p;
cherokee_buffer_add_buffer (&md5, &PROP_SECDOWN(props)->secret);
cherokee_buffer_add (&md5, p, path_len);
cherokee_buffer_add (&md5, time_s, 8);
cherokee_buffer_encode_md5_digest (&md5);
re = strncasecmp (md5.buf, &conn->request.buf[1], 32);
if (re != 0) {
TRACE(ENTRIES, "MD5 (%s) didn't match\n", md5.buf);
cherokee_buffer_mrproper(&md5);
conn->error_code = http_access_denied;
return ret_error;
}
cherokee_buffer_mrproper (&md5);
/* At this point the request has been validated
*/
if (cherokee_buffer_is_empty (&conn->request_original)) {
cherokee_buffer_add_buffer (&conn->request_original, &conn->request);
cherokee_buffer_add_buffer (&conn->query_string_original, &conn->query_string);
}
cherokee_buffer_clean (&conn->request);
cherokee_buffer_add (&conn->request, p, path_len);
/* Instance the File handler
*/
ret = cherokee_handler_file_new (hdl, cnt, MODULE_PROPS(PROP_SECDOWN(props)->props_file));
if (ret != ret_ok)
return ret_ok;
return ret_ok;
}
