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 configure_rewrite_entry (cherokee_list_t *list, cherokee_config_node_t *conf, cherokee_regex_table_t *regexs) { ret_t ret; cherokee_regex_entry_t *n; cherokee_buffer_t *substring; cherokee_boolean_t hidden = true; pcre *re = NULL; cherokee_buffer_t *regex = NULL; TRACE(ENTRIES, "Converting rewrite rule '%s'\n", conf->key.buf); /* Query conf */ cherokee_config_node_read_bool (conf, "show", &hidden); hidden = !hidden; ret = cherokee_config_node_read (conf, "regex", ®ex); if (ret == ret_ok) { ret = cherokee_regex_table_get (regexs, regex->buf, (void **)&re); if (ret != ret_ok) return ret; } ret = cherokee_config_node_read (conf, "substring", &substring); if (ret != ret_ok) return ret; /* New RegEx */ n = (cherokee_regex_entry_t *) malloc(sizeof(cherokee_regex_entry_t)); if (unlikely (n == NULL)) return ret_nomem; INIT_LIST_HEAD (&n->listed); n->re = re; n->hidden = hidden; cherokee_buffer_init (&n->subs); cherokee_buffer_add_buffer (&n->subs, substring); /* Add the list */ cherokee_list_add_tail (&n->listed, list); return ret_ok; }
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_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 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_header_op_configure (cherokee_header_op_t *op, cherokee_config_node_t *conf) { ret_t ret; cherokee_buffer_t *tmp; /* Operation type */ ret = cherokee_config_node_read (conf, "type", &tmp); if (ret != ret_ok) { free (op); return ret_error; } if (cherokee_buffer_case_cmp_str (tmp, "add") == 0) { op->op = cherokee_header_op_add; } else if (cherokee_buffer_case_cmp_str (tmp, "del") == 0) { op->op = cherokee_header_op_del; } else { free (op); return ret_error; } /* Details */ ret = cherokee_config_node_copy (conf, "header", &op->header); if (ret != ret_ok) { free (op); return ret_error; } if (op->op == cherokee_header_op_add) { ret = cherokee_config_node_copy (conf, "value", &op->value); if (ret != ret_ok) { cherokee_buffer_mrproper (&op->header); free (op); return ret_error; } } return ret_ok; }
static ret_t configure (cherokee_rule_geoip_t *rule, cherokee_config_node_t *conf, cherokee_virtual_server_t *vsrv) { ret_t ret; cherokee_buffer_t *tmp = NULL; UNUSED(vsrv); ret = cherokee_config_node_read (conf, "countries", &tmp); if (ret != ret_ok) { LOG_CRITICAL (CHEROKEE_ERROR_RULE_NO_PROPERTY, RULE(rule)->priority, "geoip"); return ret_error; } return parse_contry_list (tmp, &rule->countries); }
static ret_t configure (cherokee_rule_extensions_t *rule, cherokee_config_node_t *conf, cherokee_virtual_server_t *vsrv) { ret_t ret; cherokee_buffer_t *tmp = NULL; UNUSED(vsrv); ret = cherokee_config_node_read (conf, "extensions", &tmp); if (ret != ret_ok) { LOG_CRITICAL (CHEROKEE_ERROR_RULE_NO_PROPERTY, RULE(rule)->priority, "extensions"); return ret_error; } cherokee_config_node_read_bool (conf, "check_local_file", &rule->check_local_file); cherokee_config_node_read_bool (conf, "iocache", &rule->use_iocache); return parse_value (tmp, &rule->extensions); }
ret_t cherokee_logger_writer_configure (cherokee_logger_writer_t *writer, cherokee_config_node_t *config) { ret_t ret; cherokee_buffer_t *tmp = NULL; /* Check the type */ ret = config_read_type (config, &writer->type); if (ret != ret_ok) { return ret; } /* Extra properties */ switch (writer->type) { case cherokee_logger_writer_file: ret = cherokee_config_node_read (config, "filename", &tmp); if (ret != ret_ok) { LOG_ERROR (CHEROKEE_ERROR_LOGGER_WRITER_READ, "file"); return ret_error; } cherokee_buffer_add_buffer (&writer->filename, tmp); break; case cherokee_logger_writer_pipe: ret = cherokee_config_node_read (config, "command", &tmp); if (ret != ret_ok) { LOG_ERROR (CHEROKEE_ERROR_LOGGER_WRITER_READ, "exec"); return ret_error; } cherokee_buffer_add_buffer (&writer->command, tmp); break; default: break; } /* Reside the internal buffer if needed */ ret = cherokee_config_node_read (config, "bufsize", &tmp); if (ret == ret_ok) { int buf_len; ret = cherokee_atoi (tmp->buf, &buf_len); if (ret != ret_ok) { return ret_error; } if (buf_len < LOGGER_MIN_BUFSIZE) buf_len = LOGGER_MIN_BUFSIZE; else if (buf_len > LOGGER_MAX_BUFSIZE) buf_len = LOGGER_MAX_BUFSIZE; cherokee_buffer_mrproper (&writer->buffer); cherokee_buffer_init (&writer->buffer); ret = cherokee_buffer_ensure_size (&writer->buffer, buf_len); if (ret != ret_ok) { LOG_ERROR (CHEROKEE_ERROR_LOGGER_WRITER_ALLOC, writer->max_bufsize); return ret_nomem; } writer->max_bufsize = (size_t)buf_len; } return ret_ok; }