static ret_t
parse_if (cherokee_buffer_t *buf, const char *if_entry, size_t len_entry, cherokee_boolean_t show)
{
char *begin;
char *end;
cherokee_buffer_t token = CHEROKEE_BUF_INIT;
cherokee_buffer_add_str (&token, "%if ");
cherokee_buffer_add (&token, if_entry, len_entry);
cherokee_buffer_add_str (&token, "%");
begin = strstr (buf->buf, token.buf);
if (begin == NULL)
goto error;
end = strstr (begin, "%fi%");
if (end == NULL)
goto error;
if (show) {
cherokee_buffer_remove_chunk (buf, end - buf->buf, 4);
cherokee_buffer_remove_chunk (buf, begin - buf->buf, token.len);
} else {
cherokee_buffer_remove_chunk (buf, begin - buf->buf, (end+4) - begin);
}
cherokee_buffer_mrproper (&token);
return ret_ok;
error:
cherokee_buffer_mrproper (&token);
return ret_error;
}
static ret_t
dbslayer_add_headers (cherokee_handler_dbslayer_t *hdl,
cherokee_buffer_t *buffer)
{
switch (HANDLER_DBSLAYER_PROPS(hdl)->lang) {
case dwriter_json:
cherokee_buffer_add_str (buffer, "Content-Type: application/json" CRLF);
break;
case dwriter_python:
cherokee_buffer_add_str (buffer, "Content-Type: application/x-python" CRLF);
break;
case dwriter_php:
cherokee_buffer_add_str (buffer, "Content-Type: application/x-php" CRLF);
break;
case dwriter_ruby:
cherokee_buffer_add_str (buffer, "Content-Type: application/x-ruby" CRLF);
break;
case dwriter_xmlrpc:
cherokee_buffer_add_str (buffer, "Content-Type: application/xml+rpc" CRLF);
break;
default:
SHOULDNT_HAPPEN;
return ret_error;
}
return ret_ok;
}
ret_t
cherokee_version_add_simple (cherokee_buffer_t *buf, cherokee_server_token_t level)
{
ret_t ret;
switch (level) {
case cherokee_version_void:
ret = ret_ok;
break;
case cherokee_version_product:
ret = cherokee_buffer_add_str (buf, "Cherokee");
break;
case cherokee_version_minor:
ret = cherokee_buffer_add_str (buf, "Cherokee/" PACKAGE_MAJOR_VERSION "." PACKAGE_MINOR_VERSION);
break;
case cherokee_version_minimal:
ret = cherokee_buffer_add_str (buf, "Cherokee/" PACKAGE_MAJOR_VERSION "." PACKAGE_MINOR_VERSION "." PACKAGE_MICRO_VERSION);
break;
case cherokee_version_os:
ret = cherokee_buffer_add_str (buf, "Cherokee/" PACKAGE_MAJOR_VERSION "." PACKAGE_MINOR_VERSION "." PACKAGE_MICRO_VERSION " (" OS_TYPE ")");
break;
case cherokee_version_full:
ret = cherokee_buffer_add_str (buf, "Cherokee/" PACKAGE_MAJOR_VERSION "." PACKAGE_MINOR_VERSION "." PACKAGE_MICRO_VERSION PACKAGE_PATCH_VERSION " (" OS_TYPE ")");
break;
default:
SHOULDNT_HAPPEN;
ret = ret_error;
}
return ret_ok;
}
ret_t
cherokee_plugin_loader_init (cherokee_plugin_loader_t *loader)
{
ret_t ret;
ret = cherokee_avl_init (&loader->table);
if (unlikely(ret < ret_ok))
return ret;
/* Plug-in dir
*/
ret = cherokee_buffer_init (&loader->module_dir);
if (unlikely(ret < ret_ok))
return ret;
cherokee_buffer_add_str (&loader->module_dir, CHEROKEE_PLUGINDIR);
/* Plug-in dependencies dir
*/
ret = cherokee_buffer_init (&loader->deps_dir);
if (unlikely(ret < ret_ok))
return ret;
cherokee_buffer_add_str (&loader->deps_dir, CHEROKEE_DEPSDIR);
ret = load_static_linked_modules (loader);
if (unlikely(ret < ret_ok))
return ret;
return ret_ok;
}
ret_t
cherokee_dwriter_list_close (cherokee_dwriter_t *w)
{
ENSURE_VALID_STATE;
if (w->pretty)
cherokee_buffer_add_str (OUT, "\n");
w->depth -= 1;
ADD_END; ADD_WHITE;
switch (w->lang) {
case dwriter_json:
case dwriter_python:
case dwriter_ruby:
cherokee_buffer_add_str (OUT, "]");
break;
case dwriter_php:
cherokee_buffer_add_str (OUT, ")");
break;
default:
SHOULDNT_HAPPEN;
}
ADD_NEW_LINE;
return ret_ok;
}
ret_t
cherokee_dwriter_list_open (cherokee_dwriter_t *w)
{
ENSURE_VALID_STATE; ENSURE_NOT_KEY;
ADD_SEP; ADD_WHITE;
INCREMENT_DEPTH;
CS = dwriter_list_start;
switch (w->lang) {
case dwriter_json:
case dwriter_python:
case dwriter_ruby:
cherokee_buffer_add_str (OUT, "[");
break;
case dwriter_php:
cherokee_buffer_add_str (OUT, "array(");
break;
default:
SHOULDNT_HAPPEN;
}
if (w->pretty)
cherokee_buffer_add_str (OUT, "\n");
ADD_NEW_LINE;
return ret_ok;
}
ret_t
cherokee_header_op_render (cherokee_list_t *ops_list,
cherokee_buffer_t *buffer)
{
cherokee_list_t *i;
cherokee_header_op_t *op;
list_for_each (i, ops_list){
op = HEADER_OP(i);
if (op->op == cherokee_header_op_add) {
/* Check whether there is a previous
* header. If so, get rid of it.
*/
remove_header (buffer, &op->header);
/* Add the new entry
*/
cherokee_buffer_add_buffer (buffer, &op->header);
cherokee_buffer_add_str (buffer, ": ");
cherokee_buffer_add_buffer (buffer, &op->value);
cherokee_buffer_add_str (buffer, CRLF);
} else if (op->op == cherokee_header_op_del) {
remove_header (buffer, &op->header);
}
}
ret_t
cherokee_validator_digest_response (cherokee_validator_t *validator,
char *A1,
cherokee_buffer_t *buf,
cherokee_connection_t *conn)
{
ret_t ret;
cherokee_buffer_t a2 = CHEROKEE_BUF_INIT;
/* A1 has to be in string of length 32:
* MD5_digest(user":"******":"passwd)
*/
/* Sanity checks
*/
if (A1 == NULL)
return ret_deny;
if (cherokee_buffer_is_empty (&validator->nonce))
return ret_deny;
/* Build A2
*/
ret = digest_HA2 (validator, &a2, conn);
if (ret != ret_ok)
goto error;
/* Build the final string
*/
cherokee_buffer_ensure_size (buf, 32 + a2.len + validator->nonce.len + 4);
cherokee_buffer_add (buf, A1, 32);
cherokee_buffer_add_str (buf, ":");
cherokee_buffer_add_buffer (buf, &validator->nonce);
cherokee_buffer_add_str (buf, ":");
if (!cherokee_buffer_is_empty (&validator->qop)) {
if (!cherokee_buffer_is_empty (&validator->nc))
cherokee_buffer_add_buffer (buf, &validator->nc);
cherokee_buffer_add_str (buf, ":");
if (!cherokee_buffer_is_empty (&validator->cnonce))
cherokee_buffer_add_buffer (buf, &validator->cnonce);
cherokee_buffer_add_str (buf, ":");
cherokee_buffer_add_buffer (buf, &validator->qop);
cherokee_buffer_add_str (buf, ":");
}
cherokee_buffer_add_buffer (buf, &a2);
cherokee_buffer_encode_md5_digest (buf);
cherokee_buffer_mrproper (&a2);
return ret_ok;
error:
cherokee_buffer_mrproper (&a2);
return ret;
}
static ret_t
get_stats_cb (cherokee_cache_t *cache,
cherokee_buffer_t *info)
{
size_t total = 0;
cherokee_iocache_get_mmaped_size (IOCACHE(cache), &total);
cherokee_buffer_add_str (info, "IOcache mappped: ");
cherokee_buffer_add_fsize (info, total);
cherokee_buffer_add_str (info, "\n");
return ret_ok;
}
static ret_t
find_empty_port (int starting, int *port)
{
ret_t ret;
cherokee_socket_t s;
int p = starting;
cherokee_buffer_t bind_ = CHEROKEE_BUF_INIT;
cherokee_buffer_add_str (&bind_, "127.0.0.1");
cherokee_socket_init (&s);
cherokee_socket_set_client (&s, AF_INET);
while (true) {
ret = cherokee_socket_bind (&s, p, &bind_);
if (ret == ret_ok)
break;
p += 1;
if (p > 0XFFFF)
return ret_error;
}
cherokee_socket_close (&s);
cherokee_socket_mrproper (&s);
cherokee_buffer_mrproper (&bind_);
*port = p;
return ret_ok;
}
static ret_t
digest_HA2 (cherokee_validator_t *validator, cherokee_buffer_t *buf, cherokee_connection_t *conn)
{
ret_t ret;
const char *method;
cuint_t method_len;
/* Sanity check
*/
if (cherokee_buffer_is_empty (&validator->uri))
return ret_deny;
ret = cherokee_http_method_to_string (conn->header.method, &method, &method_len);
if (unlikely (ret != ret_ok))
return ret;
cherokee_buffer_ensure_size (buf, method_len + 1 + validator->uri.len);
cherokee_buffer_add (buf, method, method_len);
cherokee_buffer_add_str (buf, ":");
cherokee_buffer_add_buffer (buf, &validator->uri);
cherokee_buffer_encode_md5_digest (buf);
return ret_ok;
}
static ret_t
do_download__read_body (cherokee_downloader_t *downloader, void *param)
{
ret_t ret;
ssize_t len;
cherokee_buffer_t tmp = CHEROKEE_BUF_INIT;
UNUSED(param);
/* Write down
*/
len = write (output_fd, downloader->body.buf, downloader->body.len);
if (len > 0) {
ret = cherokee_buffer_move_to_begin (&downloader->body, len);
if (ret != ret_ok) return ret;
}
/* Print info
*/
cherokee_buffer_add_fsize (&tmp, downloader->content_length);
cherokee_buffer_add_str (&tmp, " of ");
cherokee_buffer_add_fsize (&tmp, downloader->info.body_recv);
if (! quiet) {
fprintf (stderr, "\rDownloading: %s", tmp.buf);
fflush(stderr);
}
cherokee_buffer_mrproper (&tmp);
return ret_ok;
}
static ret_t
match (cherokee_rule_request_t *rule,
cherokee_connection_t *conn,
cherokee_config_entry_t *ret_conf)
{
int re;
ret_t ret;
cherokee_regex_table_t *regexs = CONN_SRV(conn)->regexs;
UNUSED(ret_conf);
/* Sanity checks
*/
if (unlikely (regexs == NULL)) {
LOG_ERROR_S (CHEROKEE_ERROR_RULE_REQUEST_NO_TABLE);
return ret_error;
}
if (unlikely (rule->pcre == NULL)) {
LOG_ERROR_S (CHEROKEE_ERROR_RULE_REQUEST_NO_PCRE_PTR);
return ret_error;
}
/* Build the request string
*/
if (! cherokee_buffer_is_empty (&conn->query_string)) {
cherokee_buffer_add_str (&conn->request, "?");
cherokee_buffer_add_buffer (&conn->request, &conn->query_string);
}
/* Evaluate the pcre
*/
re = pcre_exec (rule->pcre, NULL,
conn->request.buf,
conn->request.len,
0, 0,
conn->regex_ovector, OVECTOR_LEN);
if (re < 0) {
TRACE (ENTRIES, "Request \"%s\" didn't match with \"%s\"\n",
conn->request.buf, rule->pattern.buf);
ret = ret_not_found;
goto restore;
}
conn->regex_ovecsize = re;
TRACE (ENTRIES, "Request \"%s\" matches with \"%s\", ovecsize=%d\n",
conn->request.buf, rule->pattern.buf, conn->regex_ovecsize);
ret = ret_ok;
restore:
if (! cherokee_buffer_is_empty (&conn->query_string)) {
cherokee_buffer_drop_ending (&conn->request, conn->query_string.len + 1);
}
return ret;
}
/* Utilities
*/
ret_t
cherokee_handler_add_header_options (cherokee_handler_t *hdl,
cherokee_buffer_t *buffer)
{
ret_t ret;
int http_n;
const char *method_name;
cuint_t method_name_len;
cherokee_http_method_t method;
cherokee_http_method_t supported_methods;
cherokee_boolean_t first = true;
/* Introspect the handler
*/
supported_methods = PLUGIN_INFO_HANDLER (MODULE (hdl)->info)->valid_methods;
/* Build the response string
*/
cherokee_buffer_add_str (buffer, "Allow: ");
for (http_n=0; http_n < cherokee_http_method_LENGTH; http_n++)
{
method = HTTP_METHOD (1LL << http_n);
if (supported_methods & method) {
method_name = NULL;
method_name_len = 0;
if (! first) {
cherokee_buffer_add_str (buffer, ", ");
} else {
first = false;
}
ret = cherokee_http_method_to_string (method, &method_name, &method_name_len);
if (unlikely ((ret != ret_ok) || (! method_name))) {
continue;
}
cherokee_buffer_add (buffer, method_name, method_name_len);
}
}
cherokee_buffer_add_str (buffer, CRLF);
return ret_ok;
}
ret_t
cherokee_validator_digest_check (cherokee_validator_t *validator, cherokee_buffer_t *passwd, cherokee_connection_t *conn)
{
ret_t ret;
int re = -1;
cherokee_buffer_t a1 = CHEROKEE_BUF_INIT;
cherokee_buffer_t buf = CHEROKEE_BUF_INIT;
/* Sanity check
*/
if (cherokee_buffer_is_empty (&validator->user) ||
cherokee_buffer_is_empty (&validator->realm))
return ret_deny;
/* Build A1
*/
cherokee_buffer_ensure_size (&a1,
validator->user.len + 1 +
validator->realm.len + 1 +
passwd->len);
cherokee_buffer_add_buffer (&a1, &validator->user);
cherokee_buffer_add_str (&a1, ":");
cherokee_buffer_add_buffer (&a1, &validator->realm);
cherokee_buffer_add_str (&a1, ":");
cherokee_buffer_add_buffer (&a1, passwd);
cherokee_buffer_encode_md5_digest (&a1);
/* Build a possible response
*/
ret = cherokee_validator_digest_response (validator, a1.buf, &buf, conn);
if (unlikely(ret != ret_ok))
goto go_out;
/* Compare and return
*/
re = cherokee_buffer_cmp_buf (&conn->validator->response, &buf);
go_out:
cherokee_buffer_mrproper (&a1);
cherokee_buffer_mrproper (&buf);
return (re == 0) ? ret_ok : ret_deny;
}
ret_t
cherokee_request_header_add_header (cherokee_request_header_t *request, char *ptr, cuint_t len)
{
cherokee_buffer_ensure_addlen (&request->extra_headers, len + CSZLEN(CRLF));
cherokee_buffer_add (&request->extra_headers, ptr, len);
cherokee_buffer_add_str (&request->extra_headers, CRLF);
return ret_ok;
}
ret_t
cherokee_logger_writer_get_id (cherokee_config_node_t *config,
cherokee_buffer_t *id)
{
ret_t ret;
cherokee_buffer_t *tmp;
cherokee_logger_writer_types_t type;
ret = config_read_type (config, &type);
if (ret != ret_ok) {
return ret;
}
switch (type) {
case cherokee_logger_writer_syslog:
cherokee_buffer_add_str (id, "syslog");
break;
case cherokee_logger_writer_stderr:
cherokee_buffer_add_str (id, "stderr");
break;
case cherokee_logger_writer_file:
ret = cherokee_config_node_read (config, "filename", &tmp);
if (ret == ret_ok) {
cherokee_buffer_add_buffer (id, tmp);
} else {
cherokee_buffer_add_str (id, "unknown");
}
break;
case cherokee_logger_writer_pipe:
ret = cherokee_config_node_read (config, "command", &tmp);
if (ret == ret_ok) {
cherokee_buffer_add_buffer (id, tmp);
} else {
cherokee_buffer_add_str (id, "unknown");
}
break;
default:
SHOULDNT_HAPPEN;
return ret_error;
}
return ret_ok;
}
static void
render_human_error (cherokee_error_type_t type,
const char *filename,
int line,
int error_num,
const cherokee_error_t *error,
cherokee_buffer_t *output,
va_list ap)
{
UNUSED (error_num);
/* Time */
cherokee_buffer_add_char (output, '[');
cherokee_buf_add_bogonow (output, false);
cherokee_buffer_add_str (output, "] ");
/* Error type */
switch (type) {
case cherokee_err_warning:
cherokee_buffer_add_str (output, "(warning)");
break;
case cherokee_err_error:
cherokee_buffer_add_str (output, "(error)");
break;
case cherokee_err_critical:
cherokee_buffer_add_str (output, "(critical)");
break;
default:
SHOULDNT_HAPPEN;
}
/* Source */
cherokee_buffer_add_va (output, " %s:%d - ", filename, line);
/* Error */
cherokee_buffer_add_va_list (output, error->title, ap);
cherokee_buffer_add_char (output, '\n');
/* Backtrace */
#ifdef BACKTRACES_ENABLED
cherokee_buf_add_backtrace (output, 2, "\n", " ");
#endif
}
static void
add_null (cherokee_dwriter_t *w)
{
switch (w->lang) {
case dwriter_json:
cherokee_buffer_add_str (OUT, "null");
break;
case dwriter_python:
cherokee_buffer_add_str (OUT, "None");
break;
case dwriter_php:
cherokee_buffer_add_str (OUT, "NULL");
break;
case dwriter_ruby:
cherokee_buffer_add_str (OUT, "nil");
break;
default:
SHOULDNT_HAPPEN;
}
}
static ret_t
local_file_exists (cherokee_rule_extensions_t *rule,
cherokee_connection_t *conn,
cherokee_config_entry_t *ret_conf)
{
ret_t ret;
struct stat *info;
struct stat nocache_info;
cherokee_boolean_t is_file;
cherokee_iocache_entry_t *io_entry = NULL;
cherokee_server_t *srv = CONN_SRV(conn);
cherokee_buffer_t *tmp = THREAD_TMP_BUF1(CONN_THREAD(conn));
UNUSED(rule);
/* Build the full path
*/
cherokee_buffer_clean (tmp);
if (ret_conf->document_root != NULL) {
/* A previous non-final rule set a custom document root */
cherokee_buffer_add_buffer (tmp, ret_conf->document_root);
} else {
cherokee_buffer_add_buffer (tmp, &conn->local_directory);
}
cherokee_buffer_add_str (tmp, "/");
cherokee_buffer_add_buffer (tmp, &conn->request);
/* Check the local file
*/
ret = cherokee_io_stat (srv->iocache, tmp, rule->use_iocache,
&nocache_info, &io_entry, &info);
is_file = S_ISREG(info->st_mode);
if (io_entry) {
cherokee_iocache_entry_unref (&io_entry);
}
/* Report and return
*/
if (ret != ret_ok) {
TRACE(ENTRIES, "Rule extensions: almost matched '%s', but file does not exist\n", tmp->buf);
return ret_not_found;
}
if (! is_file) {
TRACE(ENTRIES, "Rule extensions: almost matched '%s', but it is not a file\n", tmp->buf);
return ret_not_found;
}
return ret_ok;
}
ret_t
cherokee_handler_tmi_step (cherokee_handler_tmi_t *hdl, cherokee_buffer_t *buffer)
{
char time_buf[21];
size_t len;
len = strftime(time_buf, 21, "%Y-%m-%dT%H:%S:%MZ", &cherokee_bogonow_tmgmt);
cherokee_buffer_add_buffer (buffer, &HANDLER_TMI_PROPS(hdl)->reply);
cherokee_buffer_add (buffer, time_buf, len);
#ifdef LIBXML_PUSH_ENABLED
if (hdl->validate_xml) {
cherokee_buffer_add_str (buffer, "</tmi8:Timestamp><tmi8:ResponseCode>");
if (hdl->inflated && hdl->z_ret != Z_OK) {
cherokee_buffer_add_str(buffer, "PE");
} else {
xmlParseChunk(hdl->ctxt, NULL, 0, 1);
if (hdl->ctxt->wellFormed) {
cherokee_buffer_add_str(buffer, "OK");
} else {
cherokee_buffer_add_str(buffer, "SE");
}
}
cherokee_buffer_add_str (buffer, "</tmi8:ResponseCode></tmi8:VV_TM_RES>");
return ret_eof_have_data;
}
#endif
cherokee_buffer_add_str (buffer, "</tmi8:Timestamp><tmi8:ResponseCode>OK</tmi8:ResponseCode></tmi8:VV_TM_RES>");
return ret_eof_have_data;
}
ret_t
cherokee_dwriter_bool (cherokee_dwriter_t *w, cherokee_boolean_t b)
{
ENSURE_VALID_STATE; ENSURE_NOT_KEY;
ADD_SEP; ADD_WHITE;
switch (w->lang) {
case dwriter_json:
case dwriter_ruby:
if (b)
cherokee_buffer_add_str (OUT, "true");
else
cherokee_buffer_add_str (OUT, "false");
break;
case dwriter_python:
if (b)
cherokee_buffer_add_str (OUT, "True");
else
cherokee_buffer_add_str (OUT, "False");
break;
case dwriter_php:
if (b)
cherokee_buffer_add_str (OUT, "TRUE");
else
cherokee_buffer_add_str (OUT, "FALSE");
break;
default:
SHOULDNT_HAPPEN;
}
ADD_END; ADD_NEW_LINE;
return ret_ok;
}
ret_t
cherokee_dwriter_string (cherokee_dwriter_t *w, const char *s, int len)
{
ENSURE_VALID_STATE;
ADD_SEP; ADD_WHITE;
if (unlikely (s == NULL)) {
add_null (w);
goto out;
}
cherokee_buffer_add_str (OUT, "\"");
escape_string (w->tmp, s, len, w->lang);
cherokee_buffer_add (OUT, w->tmp->buf, w->tmp->len);
cherokee_buffer_add_str (OUT, "\"");
out:
ADD_END; ADD_NEW_LINE;
return ret_ok;
}
ret_t
cherokee_handler_ssi_add_headers (cherokee_handler_ssi_t *hdl,
cherokee_buffer_t *buffer)
{
ret_t ret;
char *ext;
cherokee_buffer_t *mime = NULL;
cherokee_server_t *srv = HANDLER_SRV(hdl);
cherokee_connection_t *conn = HANDLER_CONN(hdl);
/* MIME type
*/
if (srv->mime != NULL) {
ext = strrchr (conn->request.buf, '.');
if (ext == NULL)
return ret_ok;
ret = cherokee_mime_get_by_suffix (srv->mime, ext+1, &hdl->mime);
if (ret == ret_ok) {
cherokee_mime_entry_get_type (hdl->mime, &mime);
cherokee_buffer_add_str (buffer, "Content-Type: ");
cherokee_buffer_add_buffer (buffer, mime);
cherokee_buffer_add_str (buffer, CRLF);
}
}
/* Length
*/
if (cherokee_connection_should_include_length(conn)) {
HANDLER(hdl)->support = hsupport_length;
cherokee_buffer_add_str (buffer, "Content-Length: ");
cherokee_buffer_add_ullong10(buffer, (cullong_t) hdl->render.len);
cherokee_buffer_add_str (buffer, CRLF);
}
return ret_ok;
}
static ret_t
write_logger (cherokee_buffer_t *buf,
cherokee_logger_writer_t *error_writer)
{
int val;
/* No writer
*/
if (error_writer == NULL) {
goto nothing;
}
switch (error_writer->type) {
case cherokee_logger_writer_stderr:
val = 6;
cherokee_buffer_add (buf, (char *)&val, sizeof(int));
cherokee_buffer_add_str (buf, "stderr");
cherokee_buffer_add_char (buf, '\0');
break;
case cherokee_logger_writer_file:
val = 5 + error_writer->filename.len;
cherokee_buffer_add (buf, (char *)&val, sizeof(int));
cherokee_buffer_add_str (buf, "file,");
cherokee_buffer_add_buffer (buf, &error_writer->filename);
cherokee_buffer_add_char (buf, '\0');
break;
default:
goto nothing;
}
return ret_ok;
nothing:
val = 0;
cherokee_buffer_add (buf, (char *)&val, sizeof(int));
return ret_ok;
}
static ret_t
init_tmp_dir (void)
{
ret_t ret;
cherokee_buffer_init (&cherokee_tmp_dir);
cherokee_tmp_dir_copy (&cherokee_tmp_dir);
cherokee_buffer_add_str (&cherokee_tmp_dir, "/cherokee.XXXXXXXXXXX");
ret = cherokee_mkdtemp (cherokee_tmp_dir.buf);
if (unlikely (ret != ret_ok)) {
return ret_error;
}
return ret_ok;
}
ret_t
cherokee_post_read_header (cherokee_post_t *post,
void *cnt)
{
ret_t ret;
char *info = NULL;
cuint_t info_len = 0;
cherokee_connection_t *conn = CONN(cnt);
switch (post->read_header_phase) {
case cherokee_post_read_header_init:
/* Read the header
*/
ret = parse_header (post, conn);
if (unlikely (ret != ret_ok)) {
return ret;
}
post->has_info = true;
ret = remove_surplus (post, conn);
if (unlikely (ret != ret_ok)) {
return ret;
}
/* Expect: 100-continue
* http://www.w3.org/Protocols/rfc2616/rfc2616-sec8.html
*/
ret = cherokee_header_get_known (&conn->header, header_expect, &info, &info_len);
if (likely (ret != ret_ok)) {
return ret_ok;
}
cherokee_buffer_add_str (&post->read_header_100cont, HTTP_100_RESPONSE);
post->read_header_phase = cherokee_post_read_header_100cont;
case cherokee_post_read_header_100cont:
return reply_100_continue (post, conn);
}
SHOULDNT_HAPPEN;
return ret_error;
}
static ret_t
config_server (cherokee_server_t *srv)
{
ret_t ret;
cherokee_config_node_t conf;
cherokee_buffer_t buf = CHEROKEE_BUF_INIT;
cherokee_buffer_t rrd_dir = CHEROKEE_BUF_INIT;
cherokee_buffer_t rrd_bin = CHEROKEE_BUF_INIT;
cherokee_buffer_t fake;
/* Generate the password
*/
if (unsecure == 0) {
ret = generate_admin_password (&password);
if (ret != ret_ok)
return ret;
}
/* Configure the embedded server
*/
if (scgi_port > 0) {
ret = find_empty_port (scgi_port, &scgi_port);
} else {
ret = remove_old_socket (DEFAULT_UNIX_SOCKET);
}
if (ret != ret_ok) {
return ret_error;
}
cherokee_buffer_add_va (&buf, "server!bind!1!port = %d\n", port);
cherokee_buffer_add_str (&buf, "server!ipv6 = 1\n");
cherokee_buffer_add_str (&buf, "server!max_connection_reuse = 0\n");
cherokee_buffer_add_va (&buf, "server!iocache = %d\n", iocache);
if (bind_to) {
cherokee_buffer_add_va (&buf, "server!bind!1!interface = %s\n", bind_to);
}
if (thread_num != -1) {
cherokee_buffer_add_va (&buf, "server!thread_number = %d\n", thread_num);
}
cherokee_buffer_add_str (&buf, "vserver!1!nick = default\n");
cherokee_buffer_add_va (&buf, "vserver!1!document_root = %s\n", document_root);
if (scgi_port <= 0) {
cherokee_buffer_add_va (&buf,
"source!1!nick = app-logic\n"
"source!1!type = interpreter\n"
"source!1!timeout = " TIMEOUT "\n"
"source!1!host = %s\n"
"source!1!interpreter = %s/server.py %s %s %s\n"
"source!1!env_inherited = 1\n",
DEFAULT_UNIX_SOCKET, document_root,
DEFAULT_UNIX_SOCKET, config_file,
(debug) ? "-x" : "");
} else {
cherokee_buffer_add_va (&buf,
"source!1!nick = app-logic\n"
"source!1!type = interpreter\n"
"source!1!timeout = " TIMEOUT "\n"
"source!1!host = localhost:%d\n"
"source!1!interpreter = %s/server.py %d %s %s\n"
"source!1!env_inherited = 1\n",
scgi_port, document_root,
scgi_port, config_file,
(debug) ? "-x" : "");
}
if (debug) {
cherokee_buffer_add_str (&buf, "source!1!debug = 1\n");
}
cherokee_buffer_add_str (&buf,
RULE_PRE "1!match = default\n"
RULE_PRE "1!handler = scgi\n"
RULE_PRE "1!timeout = " TIMEOUT "\n"
RULE_PRE "1!handler!balancer = round_robin\n"
RULE_PRE "1!handler!balancer!source!1 = 1\n");
cherokee_buffer_add_str (&buf, RULE_PRE "1!handler!env!CTK_COOKIE = ");
generate_admin_password (&buf);
cherokee_buffer_add_char (&buf, '\n');
if (! debug) {
cherokee_buffer_add_str (&buf, RULE_PRE "1!encoder!gzip = 1\n");
}
if ((unsecure == 0) &&
(!cherokee_buffer_is_empty (&password)))
{
cherokee_buffer_add_va (&buf,
RULE_PRE "1!auth = authlist\n"
RULE_PRE "1!auth!methods = digest\n"
RULE_PRE "1!auth!realm = Cherokee-admin\n"
RULE_PRE "1!auth!list!1!user = admin\n"
RULE_PRE "1!auth!list!1!password = %s\n",
password.buf);
}
cherokee_buffer_add_str (&buf,
RULE_PRE "2!match = directory\n"
RULE_PRE "2!match!directory = /about\n"
RULE_PRE "2!handler = server_info\n");
cherokee_buffer_add_str (&buf,
RULE_PRE "3!match = directory\n"
RULE_PRE "3!match!directory = /static\n"
RULE_PRE "3!handler = file\n"
RULE_PRE "3!expiration = time\n"
RULE_PRE "3!expiration!time = 30d\n");
cherokee_buffer_add_va (&buf,
RULE_PRE "4!match = request\n"
RULE_PRE "4!match!request = ^/favicon.ico$\n"
RULE_PRE "4!document_root = %s/static/images\n"
RULE_PRE "4!handler = file\n"
RULE_PRE "4!expiration = time\n"
RULE_PRE "4!expiration!time = 30d\n",
document_root);
cherokee_buffer_add_va (&buf,
RULE_PRE "5!match = directory\n"
RULE_PRE "5!match!directory = /icons_local\n"
RULE_PRE "5!handler = file\n"
RULE_PRE "5!document_root = %s\n"
RULE_PRE "5!expiration = time\n"
RULE_PRE "5!expiration!time = 30d\n",
CHEROKEE_ICONSDIR);
cherokee_buffer_add_va (&buf,
RULE_PRE "6!match = directory\n"
RULE_PRE "6!match!directory = /CTK\n"
RULE_PRE "6!handler = file\n"
RULE_PRE "6!document_root = %s/CTK/static\n"
RULE_PRE "6!expiration = time\n"
RULE_PRE "6!expiration!time = 30d\n",
document_root);
/* Embedded help
*/
cherokee_buffer_add_va (&buf,
RULE_PRE "7!match = and\n"
RULE_PRE "7!match!left = directory\n"
RULE_PRE "7!match!left!directory = /help\n"
RULE_PRE "7!match!right = not\n"
RULE_PRE "7!match!right!right = extensions\n"
RULE_PRE "7!match!right!right!extensions = html\n"
RULE_PRE "7!handler = file\n");
cherokee_buffer_add_va (&buf,
RULE_PRE "8!match = fullpath\n"
RULE_PRE "8!match!fullpath!1 = /static/help_404.html\n"
RULE_PRE "8!handler = file\n"
RULE_PRE "8!document_root = %s\n", document_root);
cherokee_buffer_add_va (&buf,
RULE_PRE "9!match = and\n"
RULE_PRE "9!match!left = directory\n"
RULE_PRE "9!match!left!directory = /help\n"
RULE_PRE "9!match!right = not\n"
RULE_PRE "9!match!right!right = exists\n"
RULE_PRE "9!match!right!right!match_any = 1\n"
RULE_PRE "9!handler = redir\n"
RULE_PRE "9!handler!rewrite!1!show = 1\n"
RULE_PRE "9!handler!rewrite!1!substring = /static/help_404.html\n");
cherokee_buffer_add_va (&buf,
RULE_PRE "10!match = directory\n"
RULE_PRE "10!match!directory = /help\n"
RULE_PRE "10!match!final = 0\n"
RULE_PRE "10!document_root = %s\n", CHEROKEE_DOCDIR);
/* GZip
*/
if (! debug) {
cherokee_buffer_add_va (&buf,
RULE_PRE "15!match = extensions\n"
RULE_PRE "15!match!extensions = css,js,html\n"
RULE_PRE "15!match!final = 0\n"
RULE_PRE "15!encoder!gzip = 1\n");
}
/* RRDtool graphs
*/
cherokee_config_node_init (&conf);
cherokee_buffer_fake (&fake, config_file, strlen(config_file));
ret = cherokee_config_reader_parse (&conf, &fake);
if (ret == ret_ok) {
cherokee_config_node_copy (&conf, "server!collector!rrdtool_path", &rrd_bin);
cherokee_config_node_copy (&conf, "server!collector!database_dir", &rrd_dir);
}
if (! cherokee_buffer_is_empty (&rrd_bin)) {
cherokee_buffer_add_va (&buf,
RULE_PRE "20!handler!rrdtool_path = %s\n", rrd_bin.buf);
}
if (! cherokee_buffer_is_empty (&rrd_dir)) {
cherokee_buffer_add_va (&buf,
RULE_PRE "20!handler!database_dir = %s\n", rrd_dir.buf);
}
cherokee_buffer_add_str (&buf,
RULE_PRE "20!match = directory\n"
RULE_PRE "20!match!directory = /graphs\n"
RULE_PRE "20!handler = render_rrd\n"
RULE_PRE "20!expiration = epoch\n"
RULE_PRE "20!expiration!caching = no-cache\n"
RULE_PRE "20!expiration!caching!no-store = 1\n");
cherokee_buffer_add_str (&buf, RULE_PRE "20!document_root = ");
cherokee_tmp_dir_copy (&buf);
cherokee_buffer_add_va (&buf, "/cherokee/rrd-cache\n");
/* MIME types
*/
cherokee_buffer_add_str (&buf,
"mime!text/javascript!extensions = js\n"
"mime!text/css!extensions = css\n"
"mime!image/png!extensions = png\n"
"mime!image/jpeg!extensions = jpeg,jpg\n"
"mime!image/svg+xml!extensions = svg,svgz\n"
"mime!image/gif!extensions = gif\n");
ret = cherokee_server_read_config_string (srv, &buf);
if (ret != ret_ok) {
PRINT_ERROR_S ("Could not initialize the server\n");
return ret;
}
cherokee_config_node_mrproper (&conf);
cherokee_buffer_mrproper (&rrd_bin);
cherokee_buffer_mrproper (&rrd_dir);
cherokee_buffer_mrproper (&buf);
return ret_ok;
}
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;
}
}
static ret_t
match (cherokee_rule_directory_t *rule,
cherokee_connection_t *conn,
cherokee_config_entry_t *ret_conf)
{
UNUSED(ret_conf);
/* Not the same lenght
*/
if (conn->request.len < rule->directory.len) {
TRACE(ENTRIES, "Match directory: rule=%s req=%s: (shorter) ret_not_found\n",
rule->directory.buf, conn->request.buf);
return ret_not_found;
}
/* Does not match
*/
if (strncmp (rule->directory.buf, conn->request.buf, rule->directory.len) != 0) {
TRACE(ENTRIES, "Match directory: rule=%s req=%s: (str) ret_not_found\n",
rule->directory.buf, conn->request.buf);
return ret_not_found;
}
/* Does not match: same begining, but a longer name
*/
if ((conn->request.len > rule->directory.len) &&
(conn->request.buf[rule->directory.len] != '/'))
{
TRACE(ENTRIES, "Match directory: rule=%s req=%s: (str) ret_not_found\n",
rule->directory.buf, conn->request.buf);
return ret_not_found;
}
/* If the request is exactly the directory entry, and it
* doesn't end with a slash, it must be redirected. Eg:
*
* web_directory = "/blog"
* request = "/blog"
*
* It must be redirected to "/blog/"
*/
if ((conn->request.len > 1) &&
(cherokee_buffer_end_char (&conn->request) != '/') &&
(cherokee_buffer_cmp_buf (&conn->request, &rule->directory) == 0))
{
cherokee_buffer_add_str (&conn->request, "/");
cherokee_connection_set_redirect (conn, &conn->request);
cherokee_buffer_drop_ending (&conn->request, 1);
TRACE(ENTRIES, "Had to redirect to: %s\n", conn->redirect.buf);
conn->error_code = http_moved_permanently;
return ret_error;
}
/* Copy the web directory property
*/
if ((RULE(rule)->config.handler_new_func != NULL) ||
(RULE(rule)->config.document_root != NULL))
{
cherokee_buffer_clean (&conn->web_directory);
cherokee_buffer_add_buffer (&conn->web_directory, &rule->directory);
}
TRACE(ENTRIES, "Match! rule=%s req=%s web_directory=%s: ret_ok\n",
rule->directory.buf, conn->request.buf, conn->web_directory.buf);
return ret_ok;
}
