ret_t cherokee_version_add_w_port (cherokee_buffer_t *buf, cherokee_server_token_t level, cuint_t port) { ret_t ret; switch (level) { case cherokee_version_void: ret = ret_ok; break; case cherokee_version_product: ret = cherokee_buffer_add_va (buf, "Cherokee web server, Port %d", port); break; case cherokee_version_minor: ret = cherokee_buffer_add_va (buf, "Cherokee web server " PACKAGE_MAJOR_VERSION "." PACKAGE_MINOR_VERSION ", Port %d", port); break; case cherokee_version_minimal: ret = cherokee_buffer_add_va (buf, "Cherokee web server " PACKAGE_MAJOR_VERSION "." PACKAGE_MINOR_VERSION "." PACKAGE_MICRO_VERSION ", Port %d", port); break; case cherokee_version_os: ret = cherokee_buffer_add_va (buf, "Cherokee web server " PACKAGE_MAJOR_VERSION "." PACKAGE_MINOR_VERSION "." PACKAGE_MICRO_VERSION " (" OS_TYPE "), Port %d", port); break; case cherokee_version_full: ret = cherokee_buffer_add_va (buf, "Cherokee web server " PACKAGE_MAJOR_VERSION "." PACKAGE_MINOR_VERSION "." PACKAGE_MICRO_VERSION PACKAGE_PATCH_VERSION " (" OS_TYPE "), Port %d", port); break; default: SHOULDNT_HAPPEN; ret = ret_error; } return ret; }
static void bogotime_callback (void *param) { struct tm *pnow_tm; cherokee_logger_ncsa_t *logger = LOG_NCSA(param); /* Choose between local and universal time */ if (LOGGER(logger)->utc_time) { pnow_tm = &cherokee_bogonow_tmgmt; } else { pnow_tm = &cherokee_bogonow_tmloc; } /* Render the string */ cherokee_buffer_clean (&now); cherokee_buffer_add_va (&now, " [%02d/%s/%d:%02d:%02d:%02d %c%02d%02d] \"", pnow_tm->tm_mday, month[pnow_tm->tm_mon], 1900 + pnow_tm->tm_year, pnow_tm->tm_hour, pnow_tm->tm_min, pnow_tm->tm_sec, (cherokee_bogonow_tzloc < 0) ? '-' : '+', (int) (abs(cherokee_bogonow_tzloc) / 60), (int) (abs(cherokee_bogonow_tzloc) % 60)); }
static ret_t build_HA1 (cherokee_connection_t *conn, cherokee_buffer_t *buf) { cherokee_buffer_add_va (buf, "%s:%s:%s", conn->validator->user.buf, conn->realm_ref->buf, conn->validator->passwd.buf); cherokee_buffer_encode_md5_digest (buf); return ret_ok; }
static ret_t get_info (cherokee_plugin_loader_t *loader, const char *module, int flags, cherokee_plugin_info_t **info, void **dl_handler) { ret_t ret; cherokee_buffer_t info_name = CHEROKEE_BUF_INIT; /* Build the info struct string */ cherokee_buffer_add_va (&info_name, "cherokee_%s_info", module); /* Open it */ ret = dylib_open (loader, module, flags, dl_handler); if (ret != ret_ok) { cherokee_buffer_mrproper (&info_name); return ret_error; } *info = get_sym_from_dlopen_handler (*dl_handler, info_name.buf); if (*info == NULL) { cherokee_buffer_mrproper (&info_name); return ret_not_found; } /* Free the info struct string */ cherokee_buffer_mrproper (&info_name); return ret_ok; }
ret_t cherokee_dwriter_unsigned (cherokee_dwriter_t *w, unsigned long int l) { ENSURE_VALID_STATE; ENSURE_NOT_KEY; ADD_SEP; ADD_WHITE; cherokee_buffer_add_va (OUT, "%lu", l); ADD_END; ADD_NEW_LINE; return ret_ok; }
ret_t cherokee_handler_admin_add_headers (cherokee_handler_admin_t *hdl, cherokee_buffer_t *buffer) { cherokee_connection_t *conn = HANDLER_CONN(hdl); if (cherokee_connection_should_include_length(conn)) { HANDLER(hdl)->support = hsupport_length; cherokee_buffer_add_va (buffer, "Content-Length: %lu" CRLF, hdl->reply.len); } return ret_ok; }
static ret_t try_read_dh_param(cherokee_config_node_t *conf, DH **dh, int bitsize) { ret_t ret; cherokee_buffer_t *buf; FILE *paramfile = NULL; cherokee_buffer_t confentry = CHEROKEE_BUF_INIT; cherokee_buffer_add_va (&confentry, "dh_param%d", bitsize); /* Read the configuration parameter */ ret = cherokee_config_node_read (conf, confentry.buf, &buf); if (ret != ret_ok) { ret = ret_ok; goto out; } /* Read the file */ paramfile = fopen (buf->buf, "r"); if (paramfile == NULL) { TRACE(ENTRIES, "Cannot open file %s\n", buf->buf); ret = ret_file_not_found; goto out; } /* Process the content */ *dh = PEM_read_DHparams (paramfile, NULL, NULL, NULL); if (*dh == NULL) { TRACE(ENTRIES, "Failed to load PEM %s\n", buf->buf); ret = ret_error; goto out; } ret = ret_ok; out: /* Clean up */ if (paramfile != NULL) { fclose (paramfile); } cherokee_buffer_mrproper (&confentry); return ret; }
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 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 ret_t execute_init_func (cherokee_plugin_loader_t *loader, const char *module, entry_t *entry) { ret_t ret; void (*init_func) (cherokee_plugin_loader_t *); cherokee_buffer_t init_name = CHEROKEE_BUF_INIT; /* Build the init function name */ ret = cherokee_buffer_add_va (&init_name, "cherokee_plugin_%s_init", module); if (unlikely(ret < ret_ok)) { cherokee_buffer_mrproper (&init_name); return ret; } /* Get the function */ if (entry->dlopen_ref == NULL) { cherokee_buffer_mrproper (&init_name); return ret_error; } init_func = get_sym_from_dlopen_handler (entry->dlopen_ref, init_name.buf); /* Only try to execute if it exists */ if (init_func == NULL) { LOG_WARNING (CHEROKEE_ERROR_PLUGIN_NO_INIT, init_name.buf); cherokee_buffer_mrproper (&init_name); return ret_not_found; } /* Free the init function name string */ cherokee_buffer_mrproper (&init_name); /* Execute the init func */ init_func(loader); return ret_ok; }
static ret_t check_deps_file (cherokee_plugin_loader_t *loader, const char *modname) { FILE *file; char temp[128]; cherokee_buffer_t filename = CHEROKEE_BUF_INIT; cherokee_buffer_add_va (&filename, "%s/%s.deps", loader->deps_dir.buf, modname); file = fopen (filename.buf, "r"); if (file == NULL) goto exit; while (!feof(file)) { int len; char *ret; ret = fgets (temp, 127, file); if (ret == NULL) break; len = strlen (temp); if (len < 2) continue; if (temp[0] == '#') continue; if (temp[len-1] == '\n') temp[len-1] = '\0'; cherokee_plugin_loader_load (loader, temp); temp[0] = '\0'; } fclose (file); exit: cherokee_buffer_mrproper (&filename); return ret_ok; }
void cherokee_handler_cgi_add_env_pair (cherokee_handler_cgi_base_t *cgi_base, const char *name, int name_len, const char *content, int content_len) { cherokee_handler_cgi_t *cgi = HDL_CGI(cgi_base); #ifdef _WIN32 cherokee_buffer_add_va (&cgi->envp, "%s=%s", name, content); cherokee_buffer_add (&cgi->envp, "\0", 1); #else char *entry; /* Build the new envp entry */ if (name == NULL) return; entry = (char *) malloc (name_len + content_len + 2); if (entry == NULL) return; memcpy (entry, name, name_len); entry[name_len] = '='; memcpy (entry + name_len + 1, content, content_len); entry[name_len+content_len+1] = '\0'; /* Set it in the table */ cgi->envp[cgi->envp_last] = entry; cgi->envp_last++; /* Sanity check */ if (cgi->envp_last >= ENV_VAR_NUM) { SHOULDNT_HAPPEN; } #endif }
static ret_t dylib_open (cherokee_plugin_loader_t *loader, const char *libname, int extra_flags, void **handler_out) { ret_t ret; void *lib; int flags; cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; flags = RTLD_BASE | extra_flags; /* Build the path string */ ret = cherokee_buffer_add_va (&tmp, "%s/libplugin_%s." MOD_SUFFIX, loader->module_dir.buf, libname); if (unlikely(ret < ret_ok)) { cherokee_buffer_mrproper (&tmp); return ret; } /* Open the library */ CHEROKEE_MUTEX_LOCK (&dlerror_mutex); lib = dlopen (tmp.buf, flags); if (lib == NULL) { LOG_ERROR (CHEROKEE_ERROR_PLUGIN_DLOPEN, dlerror(), tmp.buf); CHEROKEE_MUTEX_UNLOCK (&dlerror_mutex); cherokee_buffer_mrproper (&tmp); return ret_error; } CHEROKEE_MUTEX_UNLOCK (&dlerror_mutex); /* Free the memory */ cherokee_buffer_mrproper (&tmp); *handler_out = lib; return ret_ok; }
int main (int argc, char **argv) { int re; ret_t ret; cint_t val; cint_t param_num; cint_t long_index; cherokee_downloader_t *downloader; cherokee_buffer_t proxy = CHEROKEE_BUF_INIT; cuint_t proxy_port; struct option long_options[] = { /* Options without arguments */ {"help", no_argument, NULL, 'h'}, {"version", no_argument, NULL, 'V'}, {"quiet", no_argument, NULL, 'q'}, {"save-headers", no_argument, NULL, 's'}, {"header", required_argument, NULL, 0 }, {NULL, 0, NULL, 0} }; /* Parse known parameters */ while ((val = getopt_long (argc, argv, "VshqO:", long_options, &long_index)) != -1) { switch (val) { case 'V': printf ("Cherokee Downloader %s\n" "Written by Alvaro Lopez Ortega <*****@*****.**>\n\n" "Copyright (C) 2001-2014 Alvaro Lopez Ortega.\n" "This is free software; see the source for copying conditions. There is NO\n" "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n", PACKAGE_VERSION); return EXIT_OK; case 'O': if (global_fd != UNSET_FD) { close (global_fd); } if ((strlen(optarg) == 1) && (optarg[0] == '-')) { global_fd = fileno(stdout); } else { global_fd = open (optarg, O_WRONLY | O_CREAT, 0644); } if (global_fd < 0) { PRINT_MSG ("ERROR: Can not open %s\n", optarg); return EXIT_ERROR; } break; case 0: break; case 'q': quiet = true; break; case 's': save_headers = true; break; case 'h': case '?': default: print_help(); return EXIT_OK; } } /* The rest.. */ param_num = argc - optind; if (param_num <= 0) { print_usage(); return EXIT_OK; } /* Tracing and proxy discovering.. */ cherokee_init(); cget_find_proxy (&proxy, &proxy_port); for (val=optind; val<optind+param_num; val++) { cherokee_buffer_t url = CHEROKEE_BUF_INIT; /* Build the url buffer */ ret = cherokee_buffer_add_va (&url, "%s", argv[val]); if (ret != ret_ok) exit (EXIT_ERROR); /* Create the downloader object.. */ ret = cherokee_downloader_new (&downloader); if (ret != ret_ok) exit (EXIT_ERROR); ret = cherokee_downloader_init(downloader); if (ret != ret_ok) exit (EXIT_ERROR); if (! cherokee_buffer_is_empty (&proxy)) { ret = cherokee_downloader_set_proxy (downloader, &proxy, proxy_port); if (ret != ret_ok) exit (EXIT_ERROR); } ret = cherokee_downloader_set_url (downloader, &url); if (ret != ret_ok) exit (EXIT_ERROR); ret = cherokee_downloader_connect (downloader); if (ret != ret_ok) exit (EXIT_ERROR); /* Download it! */ ret = do_download (downloader); if ((ret != ret_ok) && (ret != ret_eof)) { exit (EXIT_ERROR); } /* Free the objects.. */ cherokee_buffer_mrproper (&url); cherokee_downloader_free (downloader); } /* Close the output file */ re = close (output_fd); if (re != 0) exit (EXIT_ERROR); cherokee_mrproper(); return EXIT_OK; }
static void render_python_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) { cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; /* Dict: open */ cherokee_buffer_add_char (output, '{'); /* Error type */ cherokee_buffer_add_str (output, "'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; } cherokee_buffer_add_str (output, "\", "); /* Time */ cherokee_buffer_add_str (output, "'time': \""); cherokee_buf_add_bogonow (output, false); cherokee_buffer_add_str (output, "\", "); /* Render the title */ cherokee_buffer_add_str (output, "'title': \""); cherokee_buffer_add_va_list (output, error->title, ap); cherokee_buffer_add_str (output, "\", "); skip_args (ap, error->title); /* File and line*/ cherokee_buffer_add_str (output, "'code': \""); cherokee_buffer_add_va (output, "%s:%d", filename, line); cherokee_buffer_add_str (output, "\", "); /* Error number */ cherokee_buffer_add_str (output, "'error': \""); cherokee_buffer_add_va (output, "%d", error_num); cherokee_buffer_add_str (output, "\", "); /* Description */ if (error->description) { cherokee_buffer_add_str (output, "'description': \""); cherokee_buffer_clean (&tmp); cherokee_buffer_add_va_list (&tmp, error->description, ap); cherokee_buffer_add_escape_html (output, &tmp); cherokee_buffer_add_str (output, "\", "); skip_args (ap, error->description); } /* Admin URL */ if (error->admin_url) { cherokee_buffer_add_str (output, "'admin_url': \""); cherokee_buffer_add_va_list (output, error->admin_url, ap); cherokee_buffer_add_str (output, "\", "); /* ARGS: Skip 'admin_url' */ skip_args (ap, error->admin_url); } /* Debug information */ if (error->debug) { cherokee_buffer_add_str (output, "'debug': \""); cherokee_buffer_add_va_list (output, error->debug, ap); cherokee_buffer_add_str (output, "\", "); /* ARGS: Skip 'debug' */ skip_args (ap, error->debug); } /* Version */ cherokee_buffer_add_str (output, "'version': \""); cherokee_buffer_add_str (output, PACKAGE_VERSION); cherokee_buffer_add_str (output, "\", "); cherokee_buffer_add_str (output, "'compilation_date': \""); cherokee_buffer_add_str (output, __DATE__ " " __TIME__); cherokee_buffer_add_str (output, "\", "); cherokee_buffer_add_str (output, "'configure_args': \""); cherokee_buffer_clean (&tmp); cherokee_buffer_add_str (&tmp, CHEROKEE_CONFIG_ARGS); cherokee_buffer_add_escape_html (output, &tmp); cherokee_buffer_add_buffer (output, &tmp); cherokee_buffer_add_str (output, "\", "); /* Backtrace */ cherokee_buffer_add_str (output, "'backtrace': \""); #ifdef BACKTRACES_ENABLED cherokee_buffer_clean (&tmp); cherokee_buf_add_backtrace (&tmp, 2, "\\n", ""); cherokee_buffer_add_escape_html (output, &tmp); #endif cherokee_buffer_add_str (output, "\", "); /* Let's finish here.. */ if (strcmp (output->buf + output->len - 2, ", ") == 0) { cherokee_buffer_drop_ending (output, 2); } cherokee_buffer_add_str (output, "}\n"); /* Clean up */ cherokee_buffer_mrproper (&tmp); }
static ret_t common_server_initialization (cherokee_server_t *srv) { ret_t ret; struct sigaction act; /* Signals it handles */ memset(&act, 0, sizeof(act)); /* SIGPIPE */ act.sa_handler = SIG_IGN; sigaction (SIGPIPE, &act, NULL); /* Signal Handler */ act.sa_sigaction = signals_handler; act.sa_flags = SA_SIGINFO; sigaction (SIGHUP, &act, NULL); sigaction (SIGUSR2, &act, NULL); sigaction (SIGSEGV, &act, NULL); sigaction (SIGTERM, &act, NULL); sigaction (SIGINT, &act, NULL); sigaction (SIGCHLD, &act, NULL); #ifdef SIGBUS sigaction (SIGBUS, &act, NULL); #endif if (document_root != NULL) { cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; cherokee_buffer_t droot = CHEROKEE_BUF_INIT; /* Sanity check */ if (port > 0xFFFF) { PRINT_ERROR ("Port %d is out of limits\n", port); return ret_error; } /* Build the configuration string */ cherokee_buffer_add (&droot, document_root, strlen(document_root)); cherokee_path_arg_eval (&droot); cherokee_buffer_add_va (&tmp, "server!bind!1!port = %d\n" "vserver!1!document_root = %s\n" BASIC_CONFIG, port, droot.buf); /* Apply it */ ret = cherokee_server_read_config_string (srv, &tmp); cherokee_buffer_mrproper (&tmp); cherokee_buffer_mrproper (&droot); if (ret != ret_ok) { PRINT_MSG ("Couldn't start serving directory %s\n", document_root); return ret_error; } } else { const char *config; /* Check parameter inconsistencies */ if (port_set) { PRINT_MSG ("The -p parameter can only be used in conjunction with -r."); return ret_error; } /* Read the configuration file */ config = (config_file) ? config_file : DEFAULT_CONFIG_FILE; ret = cherokee_server_read_config_file (srv, config); if (ret != ret_ok) { PRINT_MSG ("Couldn't read the config file: %s\n", config); return ret_error; } } if (daemon_mode) cherokee_server_daemonize (srv); ret = cherokee_server_initialize (srv); if (ret != ret_ok) return ret_error; cherokee_server_unlock_threads (srv); return ret_ok; }
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; }
void cherokee_trace_do_trace (const char *entry, const char *file, int line, const char *func, const char *fmt, ...) { ret_t ret; char *p; char *lentry; char *lentry_end; va_list args; cherokee_connection_t *conn; cherokee_buffer_t *trace_modules = &trace.modules; cherokee_boolean_t do_log = false; cherokee_buffer_t entries = CHEROKEE_BUF_INIT; /* Prevents loops */ if (disabled) { return; } disabled = true; /* Return ASAP if nothing is being traced */ if (cherokee_buffer_is_empty (&trace.modules)) { goto out; } /* Check the connection source, if possible */ if (trace.from_filter != NULL) { conn = CONN (CHEROKEE_THREAD_PROP_GET (thread_connection_ptr)); /* No conn, no trace entry */ if (conn == NULL) { goto out; } if (conn->socket.socket < 0) { goto out; } /* Skip the trace if the conn doesn't match */ ret = cherokee_access_ip_match (trace.from_filter, &conn->socket); if (ret != ret_ok) { goto out; } } /* Also, check for 'all' */ p = strstr (trace_modules->buf, "all"); if (p == NULL) { /* Parse the In-code module string */ cherokee_buffer_add (&entries, entry, strlen(entry)); for (lentry = entries.buf;;) { lentry_end = strchr (lentry, ','); if (lentry_end) *lentry_end = '\0'; /* Check the type */ p = strstr (trace_modules->buf, lentry); if (p) { char *tmp = p + strlen(lentry); if ((*tmp == '\0') || (*tmp == ',') || (*tmp == ' ')) do_log = true; } if ((lentry_end == NULL) || (do_log)) break; lentry = lentry_end + 1; } /* Return if trace entry didn't match with the configured list */ if (! do_log) { goto out; } } /* Format the message and log it: * 'entries' is not needed at this stage, reuse it */ cherokee_buffer_clean (&entries); if (trace.print_thread) { int len; char tmp[32+1]; static int longest_len = 0; len = snprintf (tmp, 32+1, "%llX", (unsigned long long) CHEROKEE_THREAD_SELF); longest_len = MAX (longest_len, len); cherokee_buffer_add_str (&entries, "{0x"); cherokee_buffer_add_char_n (&entries, '0', longest_len - len); cherokee_buffer_add (&entries, tmp, len); cherokee_buffer_add_str (&entries, "} "); } if (trace.print_time) { cherokee_buffer_add_char (&entries, '['); cherokee_buf_add_bogonow (&entries, true); cherokee_buffer_add_str (&entries, "] "); } cherokee_buffer_add_va (&entries, "%18s:%04d (%30s): ", file, line, func); va_start (args, fmt); cherokee_buffer_add_va_list (&entries, (char *)fmt, args); va_end (args); if (trace.use_syslog) { cherokee_syslog (LOG_DEBUG, &entries); } else { #ifdef HAVE_FLOCKFILE flockfile (stdout); #endif fprintf (stdout, "%s", entries.buf); #ifdef HAVE_FUNLOCKFILE funlockfile (stdout); #endif } out: cherokee_buffer_mrproper (&entries); disabled = false; }