ret_t cherokee_dwriter_lang_to_type (cherokee_buffer_t *buf, cherokee_dwriter_lang_t *lang) { if (equal_buf_str (buf, "json")) { *lang = dwriter_json; return ret_ok; } if (equal_buf_str (buf, "python")) { *lang = dwriter_python; return ret_ok; } if (equal_buf_str (buf, "php")) { *lang = dwriter_php; return ret_ok; } if (equal_buf_str (buf, "ruby")) { *lang = dwriter_ruby; return ret_ok; } return ret_not_found; }
ret_t cherokee_validator_configure (cherokee_config_node_t *conf, void *config_entry) { ret_t ret; cherokee_list_t *i; cherokee_config_node_t *subconf; cherokee_config_entry_t *entry = CONF_ENTRY(config_entry); cherokee_config_node_foreach (i, conf) { subconf = CONFIG_NODE(i); if (equal_buf_str (&subconf->key, "realm")) { TRACE(ENTRIES, "Realm: %s\n", subconf->val.buf); ret = cherokee_buffer_dup (&subconf->val, &entry->auth_realm); if (ret != ret_ok) return ret; } else if (equal_buf_str (&subconf->key, "methods")) { TRACE(ENTRIES, "Methods: %s\n", subconf->val.buf); ret = cherokee_config_node_read_list (subconf, NULL, add_method, entry); if (ret != ret_ok) return ret; } else if (equal_buf_str (&subconf->key, "users")) { if (entry->users == NULL) { cherokee_avl_new (&entry->users); } ret = cherokee_config_node_read_list (subconf, NULL, add_user, entry->users); if (ret != ret_ok) return ret; } }
static ret_t config_read_type (cherokee_config_node_t *config, cherokee_logger_writer_types_t *type) { ret_t ret; cherokee_buffer_t *tmp = NULL; ret = cherokee_config_node_read (config, "type", &tmp); if (ret != ret_ok) { LOG_ERROR_S (CHEROKEE_ERROR_LOGGER_NO_WRITER); return ret_error; } if (equal_buf_str (tmp, "syslog")) { *type = cherokee_logger_writer_syslog; } else if (equal_buf_str (tmp, "stderr")) { *type = cherokee_logger_writer_stderr; } else if (equal_buf_str (tmp, "file")) { *type = cherokee_logger_writer_file; } else if (equal_buf_str (tmp, "exec")) { *type = cherokee_logger_writer_pipe; } else { LOG_CRITICAL (CHEROKEE_ERROR_LOGGER_WRITER_UNKNOWN, tmp->buf); return ret_error; } return ret_ok; }
ret_t cherokee_handler_file_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_module_props_t **_props) { ret_t ret; cherokee_list_t *i; cherokee_handler_file_props_t *props; UNUSED(srv); if (*_props == NULL) { CHEROKEE_NEW_STRUCT (n, handler_file_props); cherokee_handler_props_init_base (HANDLER_PROPS(n), MODULE_PROPS_FREE(cherokee_handler_file_props_free)); n->use_cache = true; n->send_symlinks = true; *_props = MODULE_PROPS(n); } props = PROP_FILE(*_props); cherokee_config_node_foreach (i, conf) { cherokee_config_node_t *subconf = CONFIG_NODE(i); if (equal_buf_str (&subconf->key, "iocache")) { ret = cherokee_atob (subconf->val.buf, &props->use_cache); if (ret != ret_ok) return ret; } else if (equal_buf_str (&subconf->key, "symlinks")) { ret = cherokee_atob (subconf->val.buf, &props->send_symlinks); if (ret != ret_ok) return ret; } }
ret_t cherokee_iocache_configure (cherokee_iocache_t *iocache, cherokee_config_node_t *conf) { ret_t ret; cherokee_list_t *i; /* Configure parent class */ ret = cherokee_cache_configure (CACHE(iocache), conf); if (ret != ret_ok) return ret; /* Configure it own properties */ cherokee_config_node_foreach (i, conf) { cherokee_config_node_t *subconf = CONFIG_NODE(i); if (equal_buf_str (&subconf->key, "max_file_size")) { iocache->max_file_size = atoi(subconf->val.buf); } else if (equal_buf_str (&subconf->key, "min_file_size")) { iocache->min_file_size = atoi(subconf->val.buf); } else if (equal_buf_str (&subconf->key, "lasting_stat")) { iocache->lasting_stat = atoi(subconf->val.buf); } else if (equal_buf_str (&subconf->key, "lasting_mmap")) { iocache->lasting_mmap = atoi(subconf->val.buf); } }
ret_t cherokee_handler_dbslayer_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_module_props_t **_props) { ret_t ret; cherokee_list_t *i; cherokee_handler_dbslayer_props_t *props; /* Instance a new property object */ if (*_props == NULL) { CHEROKEE_NEW_STRUCT (n, handler_dbslayer_props); cherokee_handler_props_init_base (HANDLER_PROPS(n), MODULE_PROPS_FREE(props_free)); n->balancer = NULL; cherokee_buffer_init (&n->user); cherokee_buffer_init (&n->password); cherokee_buffer_init (&n->db); *_props = MODULE_PROPS(n); } props = PROP_DBSLAYER(*_props); /* Parse the configuration tree */ cherokee_config_node_foreach (i, conf) { cherokee_config_node_t *subconf = CONFIG_NODE(i); if (equal_buf_str (&subconf->key, "balancer")) { ret = cherokee_balancer_instance (&subconf->val, subconf, srv, &props->balancer); if (ret != ret_ok) return ret; } else if (equal_buf_str (&subconf->key, "user")) { cherokee_buffer_clean (&props->user); cherokee_buffer_add_buffer (&props->user, &subconf->val); } else if (equal_buf_str (&subconf->key, "password")) { cherokee_buffer_clean (&props->password); cherokee_buffer_add_buffer (&props->password, &subconf->val); } else if (equal_buf_str (&subconf->key, "db")) { cherokee_buffer_clean (&props->db); cherokee_buffer_add_buffer (&props->db, &subconf->val); } else if (equal_buf_str (&subconf->key, "lang")) { ret = cherokee_dwriter_lang_to_type (&subconf->val, &props->lang); if (ret != ret_ok) { LOG_CRITICAL (CHEROKEE_ERROR_HANDLER_DBSLAYER_LANG, subconf->val.buf); return ret_error; } } }
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 type_str_to_type (cherokee_buffer_t *type_str, cherokee_rule_header_type_t *type) { if (equal_buf_str (type_str, "regex")) { *type = rule_header_type_regex; } else if (equal_buf_str (type_str, "provided")) { *type = rule_header_type_provided; } else { LOG_CRITICAL (CHEROKEE_ERROR_RULE_HEADER_UNKNOWN_TYPE, type_str->buf); return ret_error; } return ret_ok; }
ret_t cherokee_handler_fcgi_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_module_props_t **_props) { ret_t ret; cherokee_list_t *i; cherokee_handler_fcgi_props_t *props; /* Instance a new property object */ if (*_props == NULL) { CHEROKEE_NEW_STRUCT (n, handler_fcgi_props); cherokee_handler_cgi_base_props_init_base (PROP_CGI_BASE(n), MODULE_PROPS_FREE(props_free)); INIT_LIST_HEAD (&n->server_list); n->balancer = NULL; *_props = MODULE_PROPS(n); } props = PROP_FCGI(*_props); /* Parse the configuration tree */ cherokee_config_node_foreach (i, conf) { cherokee_config_node_t *subconf = CONFIG_NODE(i); if (equal_buf_str (&subconf->key, "balancer")) { ret = cherokee_balancer_instance (&subconf->val, subconf, srv, &props->balancer); if (ret != ret_ok) return ret; } }
ret_t cherokee_handler_custom_error_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_module_props_t **_props) { ret_t ret; int val; cherokee_list_t *i; cherokee_config_node_t *subconf; cherokee_handler_custom_error_props_t *props; UNUSED(srv); if (*_props == NULL) { CHEROKEE_NEW_STRUCT (n, handler_custom_error_props); cherokee_handler_props_init_base (HANDLER_PROPS(n), MODULE_PROPS_FREE(props_free)); n->error_code = http_unset; *_props = MODULE_PROPS(n); } props = PROP_CUSTOM_ERROR(*_props); cherokee_config_node_foreach (i, conf) { subconf = CONFIG_NODE(i); if (equal_buf_str (&subconf->key, "error")) { ret = cherokee_atoi (subconf->val.buf, &val); if (ret != ret_ok) return ret; props->error_code = val; } }
static ret_t configure (cherokee_rule_header_t *rule, cherokee_config_node_t *conf, cherokee_virtual_server_t *vsrv) { ret_t ret; cherokee_buffer_t *type = NULL; cherokee_buffer_t *header = NULL; cherokee_regex_table_t *regexs = VSERVER_SRV(vsrv)->regexs; /* Read the header */ ret = cherokee_config_node_read (conf, "header", &header); if (ret != ret_ok) { LOG_ERROR (CHEROKEE_ERROR_RULE_NO_PROPERTY, RULE(rule)->priority, "header"); return ret_error; } ret = header_str_to_type (header, &rule->header); if (ret != ret_ok) { return ret; } /* Type */ ret = cherokee_config_node_read (conf, "type", &type); if (ret == ret_ok) { ret = type_str_to_type (type, &rule->type); if (ret != ret_ok) { return ret; } } /* Read the match */ ret = cherokee_config_node_copy (conf, "match", &rule->match); if (ret != ret_ok) { if (equal_buf_str (type, "regex")) { LOG_ERROR (CHEROKEE_ERROR_RULE_NO_PROPERTY, RULE(rule)->priority, "match"); return ret_error; } } /* Compile the regular expression */ if (! cherokee_buffer_is_empty (&rule->match)) { ret = cherokee_regex_table_add (regexs, rule->match.buf); if (ret != ret_ok) return ret; ret = cherokee_regex_table_get (regexs, rule->match.buf, &rule->pcre); if (ret != ret_ok) return ret; } return ret_ok; }
static ret_t header_str_to_type (cherokee_buffer_t *header, cherokee_common_header_t *common_header) { if (equal_buf_str (header, "Accept-Encoding")) { *common_header = header_accept_encoding; } else if (equal_buf_str (header, "Accept-Charset")) { *common_header = header_accept_charset; } else if (equal_buf_str (header, "Accept-Language")) { *common_header = header_accept_language; } else if (equal_buf_str (header, "Referer")) { *common_header = header_referer; } else if (equal_buf_str (header, "User-Agent")) { *common_header = header_user_agent; } else if (equal_buf_str (header, "Cookie")) { *common_header = header_cookie; } else if (equal_buf_str (header, "Host")) { *common_header = header_host; } else { LOG_CRITICAL (CHEROKEE_ERROR_RULE_HEADER_UNKNOWN_HEADER, header->buf); return ret_error; } return ret_ok; }
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_validator_file_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_module_props_t **_props) { ret_t ret; cherokee_config_node_t *subconf; cherokee_validator_file_props_t *props = PROP_VFILE(*_props); UNUSED (srv); /* Password file */ ret = cherokee_config_node_get (conf, "passwdfile", &subconf); if (ret == ret_ok) { cherokee_buffer_add_buffer (&props->password_file, &subconf->val); } /* Path type */ ret = cherokee_config_node_get (conf, "passwdfile_path", &subconf); if (ret == ret_ok) { if (equal_buf_str (&subconf->val, "full")) { props->password_path_type = val_path_full; } else if (equal_buf_str (&subconf->val, "local_dir")) { props->password_path_type = val_path_local_dir; } else { LOG_ERROR (CHEROKEE_ERROR_VALIDATOR_FILE, subconf->val.buf); return ret_error; } } /* Final checks */ if (cherokee_buffer_is_empty (&props->password_file)) { LOG_CRITICAL_S (CHEROKEE_ERROR_VALIDATOR_FILE_NO_FILE); return ret_error; } return ret_ok; }
ret_t cherokee_handler_server_info_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_module_props_t **_props) { cherokee_list_t *i; cherokee_handler_server_info_props_t *props; UNUSED(srv); if (*_props == NULL) { CHEROKEE_NEW_STRUCT (n, handler_server_info_props); cherokee_module_props_init_base (MODULE_PROPS(n), MODULE_PROPS_FREE(props_free)); n->just_about = false; n->connection_details = false; *_props = MODULE_PROPS(n); } props = PROP_SRV_INFO(*_props); cherokee_config_node_foreach (i, conf) { cherokee_config_node_t *subconf = CONFIG_NODE(i); if (equal_buf_str (&subconf->key, "type")) { if (equal_buf_str (&subconf->val, "normal")) { } else if (equal_buf_str (&subconf->val, "just_about")) { props->just_about = true; } else if (equal_buf_str (&subconf->val, "connection_details")) { props->connection_details = true; } else { LOG_ERROR (CHEROKEE_ERROR_HANDLER_SRV_INFO_TYPE, subconf->val.buf); return ret_error; } } }
ret_t cherokee_encoder_configure (cherokee_config_node_t *config, cherokee_server_t *srv, cherokee_module_props_t **_props) { cherokee_encoder_props_t *props = ENCODER_PROPS(*_props); UNUSED (srv); /* Unset */ if (equal_buf_str (&config->val, "0")) { TRACE (ENTRIES, "Encoder %s: unset\n", config->key.buf); /* Deny */ } else if (equal_buf_str (&config->val, "forbid") || equal_buf_str (&config->val, "deny")) { TRACE (ENTRIES, "Encoder %s: deny\n", config->key.buf); props->perms = cherokee_encoder_forbid; /* Allow */ } else if (equal_buf_str (&config->val, "1") || equal_buf_str (&config->val, "allow")) { TRACE (ENTRIES, "Encoder %s: allow\n", config->key.buf); props->perms = cherokee_encoder_allow; /* Error */ } else { LOG_ERROR (CHEROKEE_ERROR_ENCODER_NOT_SET_VALUE, config->val.buf); return ret_error; } return ret_ok; }
ret_t cherokee_source_configure (cherokee_source_t *src, cherokee_config_node_t *conf) { cherokee_list_t *i; cherokee_config_node_t *child; cherokee_config_node_foreach (i, conf) { child = CONFIG_NODE(i); if (equal_buf_str (&child->key, "host")) { set_host (src, &child->val); } /* Base class: do not display error here */ }
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); } }
/* 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_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_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; } }