| Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/C/Apache/server/ (Apache Software Stiftung Version 2.4.65©) Datei vom 7.6.2025 mit Größe 188 kB |
|
SSL core.c
Interaktion und |
|||||||||
|
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "apr.h" #include "apr_strings.h" #include "apr_lib.h" #include "apr_fnmatch.h" #include "apr_hash.h" #include "apr_thread_proc.h" /* for RLIMIT stuff */ #include "apr_random.h" #include "apr_version.h" #if APR_MAJOR_VERSION < 2 #include "apu_version.h" #endif #define APR_WANT_IOVEC #define APR_WANT_STRFUNC #define APR_WANT_MEMFUNC #include "apr_want.h" #include "ap_config.h" #include "httpd.h" #include "http_config.h" #include "http_core.h" #include "http_protocol.h" /* For index_of_response(). Grump. */ #include "http_request.h" #include "http_ssl.h" #include "http_vhost.h" #include "http_main.h" /* For the default_handler below... */ #include "http_log.h" #include "util_md5.h" #include "http_connection.h" #include "apr_buckets.h" #include "util_filter.h" #include "util_ebcdic.h" #include "util_mutex.h" #include "util_time.h" #include "mpm_common.h" #include "scoreboard.h" #include "mod_core.h" #include "mod_proxy.h" #include "ap_listen.h" #include "ap_regex.h" #include "mod_so.h" /* for ap_find_loaded_module_symbol */ #if defined(RLIMIT_CPU) || defined (RLIMIT_DATA) || defined (RLIMIT_VMEM) || defined(RLIM #include "unixd.h" #endif #if APR_HAVE_UNISTD_H #include <unistd.h> #endif /* LimitRequestBody handling */ #define AP_LIMIT_REQ_BODY_UNSET ((apr_off_t) -1) #define AP_DEFAULT_LIMIT_REQ_BODY ((apr_off_t) 1<<30) /* 1GB */ /* LimitXMLRequestBody handling */ #define AP_LIMIT_UNSET ((long) -1) #define AP_DEFAULT_LIMIT_XML_BODY ((apr_size_t)1000000) /* Hard limit for ap_escape_html2() */ #define AP_MAX_LIMIT_XML_BODY ((apr_size_t)(APR_SIZE_MAX / 6 - 1)) #define AP_MIN_SENDFILE_BYTES (256) /* maximum include nesting level */ #ifndef AP_MAX_INCLUDE_DEPTH #define AP_MAX_INCLUDE_DEPTH (128) #endif /* valid in core-conf, but not in runtime r->used_path_info */ #define AP_ACCEPT_PATHINFO_UNSET 3 #define AP_CONTENT_MD5_OFF 0 #define AP_CONTENT_MD5_ON 1 #define AP_CONTENT_MD5_UNSET 2 #define AP_FLUSH_MAX_THRESHOLD 65535 #define AP_FLUSH_MAX_PIPELINED 4 APR_HOOK_STRUCT( APR_HOOK_LINK(get_mgmt_items) APR_HOOK_LINK(insert_network_bucket) APR_HOOK_LINK(get_pollfd_from_conn) ) AP_IMPLEMENT_HOOK_RUN_ALL(int, get_mgmt_items, (apr_pool_t *p, const char *val, apr_hash_t *ht), (p, val, ht), OK, DECLINED) AP_IMPLEMENT_HOOK_RUN_FIRST(apr_status_t, insert_network_bucket, (conn_rec *c, apr_bucket_brigade *bb, apr_socket_t *socket), (c, bb, socket), AP_DECLINED) AP_IMPLEMENT_HOOK_RUN_FIRST(apr_status_t, get_pollfd_from_conn, (conn_rec *c, struct apr_pollfd_t *pfd, apr_interval_time_t *ptimeout), (c, pfd, ptimeout), APR_ENOTIMPL) /* Server core module... This module provides support for really basic * server operations, including options and commands which control the * operation of other modules. Consider this the bureaucracy module. * * The core module also defines handlers, etc., to handle just enough * to allow a server with the core module ONLY to actually serve documents. * * This file could almost be mod_core.c, except for the stuff which affects * the http_conf_globals. */ /* we know core's module_index is 0 */ #undef APLOG_MODULE_INDEX #define APLOG_MODULE_INDEX AP_CORE_MODULE_INDEX /* Handles for core filters */ AP_DECLARE_DATA ap_filter_rec_t *ap_subreq_core_filter_handle; AP_DECLARE_DATA ap_filter_rec_t *ap_core_output_filter_handle; AP_DECLARE_DATA ap_filter_rec_t *ap_content_length_filter_handle; AP_DECLARE_DATA ap_filter_rec_t *ap_core_input_filter_handle; /* Provide ap_document_root_check storage and default value = true */ AP_DECLARE_DATA int ap_document_root_check = 1; /* magic pointer for ErrorDocument xxx "default" */ static char errordocument_default; /* Global state allocated out of pconf: variables here MUST be * cleared/reset in reset_config(), a pconf cleanup, to avoid the * variable getting reused after the pool is cleared. */ static apr_array_header_t *saved_server_config_defines = NULL; static apr_table_t *server_config_defined_vars = NULL; AP_DECLARE_DATA const char *ap_runtime_dir = NULL; AP_DECLARE_DATA int ap_main_state = AP_SQ_MS_INITIAL_STARTUP; AP_DECLARE_DATA int ap_run_mode = AP_SQ_RM_UNKNOWN; AP_DECLARE_DATA int ap_config_generation = 0; static void *create_core_dir_config(apr_pool_t *a, char *dir) { core_dir_config *conf; conf = (core_dir_config *)apr_pcalloc(a, sizeof(core_dir_config)); /* conf->r and conf->d[_*] are initialized by dirsection() or left NULL */ conf->opts = dir ? OPT_UNSET : OPT_UNSET|OPT_SYM_LINKS; conf->opts_add = conf->opts_remove = OPT_NONE; conf->override = OR_UNSET|OR_NONE; conf->override_opts = OPT_UNSET | OPT_ALL | OPT_SYM_OWNER | OPT_MULTI; conf->content_md5 = AP_CONTENT_MD5_UNSET; conf->accept_path_info = AP_ACCEPT_PATHINFO_UNSET; conf->use_canonical_name = USE_CANONICAL_NAME_UNSET; conf->use_canonical_phys_port = USE_CANONICAL_PHYS_PORT_UNSET; conf->hostname_lookups = HOSTNAME_LOOKUP_UNSET; /* * left as NULL (we use apr_pcalloc): * conf->limit_cpu = NULL; * conf->limit_mem = NULL; * conf->limit_nproc = NULL; * conf->sec_file = NULL; * conf->sec_if = NULL; */ conf->limit_req_body = AP_LIMIT_REQ_BODY_UNSET; conf->limit_xml_body = AP_LIMIT_UNSET; conf->server_signature = srv_sig_unset; conf->add_default_charset = ADD_DEFAULT_CHARSET_UNSET; conf->add_default_charset_name = DEFAULT_ADD_DEFAULT_CHARSET_NAME; /* Overriding all negotiation * Set NULL by apr_pcalloc: * conf->mime_type = NULL; * conf->handler = NULL; * conf->output_filters = NULL; * conf->input_filters = NULL; */ /* * Flag for use of inodes in ETags. */ conf->etag_bits = ETAG_UNSET; conf->etag_add = ETAG_UNSET; conf->etag_remove = ETAG_UNSET; conf->enable_mmap = ENABLE_MMAP_UNSET; conf->enable_sendfile = ENABLE_SENDFILE_UNSET; conf->allow_encoded_slashes = 0; conf->decode_encoded_slashes = 0; conf->max_ranges = AP_MAXRANGES_UNSET; conf->max_overlaps = AP_MAXRANGES_UNSET; conf->max_reversals = AP_MAXRANGES_UNSET; conf->cgi_pass_auth = AP_CGI_PASS_AUTH_UNSET; conf->qualify_redirect_url = AP_CORE_CONFIG_UNSET; return (void *)conf; } static void *merge_core_dir_configs(apr_pool_t *a, void *basev, void *newv) { core_dir_config *base = (core_dir_config *)basev; core_dir_config *new = (core_dir_config *)newv; core_dir_config *conf; /* Create this conf by duplicating the base, replacing elements * (or creating copies for merging) where new-> values exist. */ conf = (core_dir_config *)apr_pmemdup(a, base, sizeof(core_dir_config)); conf->d = new->d; conf->d_is_fnmatch = new->d_is_fnmatch; conf->d_components = new->d_components; conf->r = new->r; conf->refs = new->refs; conf->condition = new->condition; if (new->opts & OPT_UNSET) { /* there was no explicit setting of new->opts, so we merge * preserve the invariant (opts_add & opts_remove) == 0 */ conf->opts_add = (conf->opts_add & ~new->opts_remove) | new->opts_add; conf->opts_remove = (conf->opts_remove & ~new->opts_add) | new->opts_remove; conf->opts = (conf->opts & ~conf->opts_remove) | conf->opts_add; /* If Includes was enabled with exec in the base config, but * was enabled without exec in the new config, then disable * exec in the merged set. */ if (((base->opts & (OPT_INCLUDES|OPT_INC_WITH_EXEC)) == (OPT_INCLUDES|OPT_INC_WITH_EXEC)) && ((new->opts & (OPT_INCLUDES|OPT_INC_WITH_EXEC)) == OPT_INCLUDES)) { conf->opts &= ~OPT_INC_WITH_EXEC; } } else { /* otherwise we just copy, because an explicit opts setting * overrides all earlier +/- modifiers */ conf->opts = new->opts; conf->opts_add = new->opts_add; conf->opts_remove = new->opts_remove; } if (!(new->override & OR_UNSET)) { conf->override = new->override; } if (!(new->override_opts & OPT_UNSET)) { conf->override_opts = new->override_opts; } if (new->override_list != NULL) { conf->override_list = new->override_list; } if (conf->response_code_exprs == NULL) { conf->response_code_exprs = new->response_code_exprs; } else if (new->response_code_exprs != NULL) { conf->response_code_exprs = apr_hash_overlay(a, new->response_code_exprs, conf->response_code_exprs); } /* Otherwise we simply use the base->response_code_exprs array */ if (new->hostname_lookups != HOSTNAME_LOOKUP_UNSET) { conf->hostname_lookups = new->hostname_lookups; } if (new->content_md5 != AP_CONTENT_MD5_UNSET) { conf->content_md5 = new->content_md5; } if (new->accept_path_info != AP_ACCEPT_PATHINFO_UNSET) { conf->accept_path_info = new->accept_path_info; } if (new->use_canonical_name != USE_CANONICAL_NAME_UNSET) { conf->use_canonical_name = new->use_canonical_name; } if (new->use_canonical_phys_port != USE_CANONICAL_PHYS_PORT_UNSET) { conf->use_canonical_phys_port = new->use_canonical_phys_port; } #ifdef RLIMIT_CPU if (new->limit_cpu) { conf->limit_cpu = new->limit_cpu; } #endif #if defined(RLIMIT_DATA) || defined(RLIMIT_VMEM) || defined(RLIMIT_AS) if (new->limit_mem) { conf->limit_mem = new->limit_mem; } #endif #ifdef RLIMIT_NPROC if (new->limit_nproc) { conf->limit_nproc = new->limit_nproc; } #endif if (new->limit_req_body != AP_LIMIT_REQ_BODY_UNSET) { conf->limit_req_body = new->limit_req_body; } if (new->limit_xml_body != AP_LIMIT_UNSET) conf->limit_xml_body = new->limit_xml_body; if (!conf->sec_file) { conf->sec_file = new->sec_file; } else if (new->sec_file) { /* If we merge, the merge-result must have its own array */ conf->sec_file = apr_array_append(a, base->sec_file, new->sec_file); } /* Otherwise we simply use the base->sec_file array */ if (!conf->sec_if) { conf->sec_if = new->sec_if; } else if (new->sec_if) { /* If we merge, the merge-result must have its own array */ conf->sec_if = apr_array_append(a, base->sec_if, new->sec_if); } /* Otherwise we simply use the base->sec_if array */ if (new->server_signature != srv_sig_unset) { conf->server_signature = new->server_signature; } if (new->add_default_charset != ADD_DEFAULT_CHARSET_UNSET) { conf->add_default_charset = new->add_default_charset; conf->add_default_charset_name = new->add_default_charset_name; } /* Overriding all negotiation */ if (new->mime_type) { conf->mime_type = new->mime_type; } if (new->handler) { conf->handler = new->handler; } if (new->expr_handler) { conf->expr_handler = new->expr_handler; } if (new->output_filters) { conf->output_filters = new->output_filters; } if (new->input_filters) { conf->input_filters = new->input_filters; } /* * Now merge the setting of the FileETag directive. */ if (new->etag_bits == ETAG_UNSET) { conf->etag_add = (conf->etag_add & (~ new->etag_remove)) | new->etag_add; conf->etag_remove = (conf->etag_remove & (~ new->etag_add)) | new->etag_remove; conf->etag_bits = (conf->etag_bits & (~ conf->etag_remove)) | conf->etag_add; } else { conf->etag_bits = new->etag_bits; conf->etag_add = new->etag_add; conf->etag_remove = new->etag_remove; } if (conf->etag_bits != ETAG_NONE) { conf->etag_bits &= (~ ETAG_NONE); } if (new->enable_mmap != ENABLE_MMAP_UNSET) { conf->enable_mmap = new->enable_mmap; } if (new->enable_sendfile != ENABLE_SENDFILE_UNSET) { conf->enable_sendfile = new->enable_sendfile; } if (new->read_buf_size) { conf->read_buf_size = new->read_buf_size; } else { conf->read_buf_size = base->read_buf_size; } conf->allow_encoded_slashes = new->allow_encoded_slashes; conf->decode_encoded_slashes = new->decode_encoded_slashes; if (new->log) { if (!conf->log) { conf->log = new->log; } else { conf->log = ap_new_log_config(a, new->log); ap_merge_log_config(base->log, conf->log); } } conf->max_ranges = new->max_ranges != AP_MAXRANGES_UNSET ? new->max_ranges : base->max_range conf->max_overlaps = new->max_overlaps != AP_MAXRANGES_UNSET ? new->max_overlaps : base->max conf->max_reversals = new->max_reversals != AP_MAXRANGES_UNSET ? new->max_reversals : base-> conf->cgi_pass_auth = new->cgi_pass_auth != AP_CGI_PASS_AUTH_UNSET ? new->cgi_pass_auth : b if (new->cgi_var_rules) { if (!conf->cgi_var_rules) { conf->cgi_var_rules = new->cgi_var_rules; } else { conf->cgi_var_rules = apr_hash_overlay(a, new->cgi_var_rules, conf->cgi_var_rules); } } AP_CORE_MERGE_FLAG(qualify_redirect_url, conf, base, new); return (void*)conf; } #if APR_HAS_SO_ACCEPTFILTER #ifndef ACCEPT_FILTER_NAME #define ACCEPT_FILTER_NAME "httpready" #ifdef __FreeBSD_version #if __FreeBSD_version < 411000 /* httpready broken before 4.1.1 */ #undef ACCEPT_FILTER_NAME #define ACCEPT_FILTER_NAME "dataready" #endif #endif #endif #endif static void *create_core_server_config(apr_pool_t *a, server_rec *s) { core_server_config *conf; int is_virtual = s->is_virtual; conf = (core_server_config *)apr_pcalloc(a, sizeof(core_server_config)); /* global-default / global-only settings */ if (!is_virtual) { conf->ap_document_root = DOCUMENT_LOCATION; conf->access_name = DEFAULT_ACCESS_FNAME; /* A mapping only makes sense in the global context */ conf->accf_map = apr_table_make(a, 5); #if APR_HAS_SO_ACCEPTFILTER apr_table_setn(conf->accf_map, "http", ACCEPT_FILTER_NAME); apr_table_setn(conf->accf_map, "https", "dataready"); #elif defined(WIN32) /* 'data' is disabled on Windows due to a DoS vuln (PR 59970) */ apr_table_setn(conf->accf_map, "http", "connect"); apr_table_setn(conf->accf_map, "https", "connect"); #else apr_table_setn(conf->accf_map, "http", "data"); apr_table_setn(conf->accf_map, "https", "data"); #endif conf->flush_max_threshold = AP_FLUSH_MAX_THRESHOLD; conf->flush_max_pipelined = AP_FLUSH_MAX_PIPELINED; } else { /* Use main ErrorLogFormat while the vhost is loading */ core_server_config *main_conf = ap_get_core_module_config(ap_server_conf->module_config); conf->error_log_format = main_conf->error_log_format; conf->flush_max_pipelined = -1; } /* initialization, no special case for global context */ conf->sec_dir = apr_array_make(a, 40, sizeof(ap_conf_vector_t *)); conf->sec_url = apr_array_make(a, 40, sizeof(ap_conf_vector_t *)); /* pcalloc'ed - we have NULL's/0's conf->gprof_dir = NULL; ** recursion stopper; 0 == unset conf->redirect_limit = 0; conf->subreq_limit = 0; conf->protocol = NULL; */ conf->trace_enable = AP_TRACE_UNSET; conf->protocols = apr_array_make(a, 5, sizeof(const char *)); conf->protocols_honor_order = -1; conf->merge_slashes = AP_CORE_CONFIG_UNSET; conf->strict_host_check= AP_CORE_CONFIG_UNSET; return (void *)conf; } static void *merge_core_server_configs(apr_pool_t *p, void *basev, void *virtv) { core_server_config *base = (core_server_config *)basev; core_server_config *virt = (core_server_config *)virtv; core_server_config *conf = (core_server_config *) apr_pmemdup(p, base, sizeof(core_server_config)); if (virt->ap_document_root) conf->ap_document_root = virt->ap_document_root; if (virt->access_name) conf->access_name = virt->access_name; /* XXX optimize to keep base->sec_ pointers if virt->sec_ array is empty */ conf->sec_dir = apr_array_append(p, base->sec_dir, virt->sec_dir); conf->sec_url = apr_array_append(p, base->sec_url, virt->sec_url); if (virt->redirect_limit) conf->redirect_limit = virt->redirect_limit; if (virt->subreq_limit) conf->subreq_limit = virt->subreq_limit; if (virt->trace_enable != AP_TRACE_UNSET) conf->trace_enable = virt->trace_enable; if (virt->http09_enable != AP_HTTP09_UNSET) conf->http09_enable = virt->http09_enable; if (virt->http_conformance != AP_HTTP_CONFORMANCE_UNSET) conf->http_conformance = virt->http_conformance; if (virt->http_methods != AP_HTTP_METHODS_UNSET) conf->http_methods = virt->http_methods; /* no action for virt->accf_map, not allowed per-vhost */ if (virt->protocol) conf->protocol = virt->protocol; if (virt->gprof_dir) conf->gprof_dir = virt->gprof_dir; if (virt->error_log_format) conf->error_log_format = virt->error_log_format; if (virt->error_log_conn) conf->error_log_conn = virt->error_log_conn; if (virt->error_log_req) conf->error_log_req = virt->error_log_req; conf->merge_trailers = (virt->merge_trailers != AP_MERGE_TRAILERS_UNSET) ? virt->merge_trailers : base->merge_trailers; conf->protocols = ((virt->protocols->nelts > 0)? virt->protocols : base->protocols); conf->protocols_honor_order = ((virt->protocols_honor_order < 0)? base->protocols_honor_order : virt->protocols_honor_order); AP_CORE_MERGE_FLAG(merge_slashes, conf, base, virt); conf->flush_max_threshold = (virt->flush_max_threshold) ? virt->flush_max_threshold : base->flush_max_threshold; conf->flush_max_pipelined = (virt->flush_max_pipelined >= 0) ? virt->flush_max_pipelined : base->flush_max_pipelined; conf->strict_host_check = (virt->strict_host_check != AP_CORE_CONFIG_UNSET) ? virt->strict_host_check : base->strict_host_check; AP_CORE_MERGE_FLAG(strict_host_check, conf, base, virt); return conf; } /* Add per-directory configuration entry (for <directory> section); * these are part of the core server config. */ AP_CORE_DECLARE(void) ap_add_per_dir_conf(server_rec *s, void *dir_config) { core_server_config *sconf = ap_get_core_module_config(s->module_config); void **new_space = (void **)apr_array_push(sconf->sec_dir); *new_space = dir_config; } AP_CORE_DECLARE(void) ap_add_per_url_conf(server_rec *s, void *url_config) { core_server_config *sconf = ap_get_core_module_config(s->module_config); void **new_space = (void **)apr_array_push(sconf->sec_url); *new_space = url_config; } AP_CORE_DECLARE(void) ap_add_file_conf(apr_pool_t *p, core_dir_config *conf, void *url_config) { void **new_space; if (!conf->sec_file) conf->sec_file = apr_array_make(p, 2, sizeof(ap_conf_vector_t *)); new_space = (void **)apr_array_push(conf->sec_file); *new_space = url_config; } AP_CORE_DECLARE(const char *) ap_add_if_conf(apr_pool_t *p, core_dir_config *conf, void *if_config) { void **new_space; core_dir_config *new = ap_get_module_config(if_config, &core_module); if (!conf->sec_if) { conf->sec_if = apr_array_make(p, 2, sizeof(ap_conf_vector_t *)); } if (new->condition_ifelse & AP_CONDITION_ELSE) { int have_if = 0; if (conf->sec_if->nelts > 0) { core_dir_config *last; ap_conf_vector_t *lastelt = APR_ARRAY_IDX(conf->sec_if, conf->sec_if->nelts - 1, ap_conf_vector_t *); last = ap_get_module_config(lastelt, &core_module); if (last->condition_ifelse & AP_CONDITION_IF) have_if = 1; } if (!have_if) return " " } new_space = (void **)apr_array_push(conf->sec_if); *new_space = if_config; return NULL; } /* We need to do a stable sort, qsort isn't stable. So to make it stable * we'll be maintaining the original index into the list, and using it * as the minor key during sorting. The major key is the number of * components (where the root component is zero). */ struct reorder_sort_rec { ap_conf_vector_t *elt; int orig_index; }; static int reorder_sorter(const void *va, const void *vb) { const struct reorder_sort_rec *a = va; const struct reorder_sort_rec *b = vb; core_dir_config *core_a; core_dir_config *core_b; core_a = ap_get_core_module_config(a->elt); core_b = ap_get_core_module_config(b->elt); /* a regex always sorts after a non-regex */ if (!core_a->r && core_b->r) { return -1; } else if (core_a->r && !core_b->r) { return 1; } /* we always sort next by the number of components */ if (core_a->d_components < core_b->d_components) { return -1; } else if (core_a->d_components > core_b->d_components) { return 1; } /* They have the same number of components, we now have to compare * the minor key to maintain the original order (from the config.) */ return a->orig_index - b->orig_index; } void ap_core_reorder_directories(apr_pool_t *p, server_rec *s) { core_server_config *sconf; apr_array_header_t *sec_dir; struct reorder_sort_rec *sortbin; int nelts; ap_conf_vector_t **elts; int i; apr_pool_t *tmp; sconf = ap_get_core_module_config(s->module_config); sec_dir = sconf->sec_dir; nelts = sec_dir->nelts; elts = (ap_conf_vector_t **)sec_dir->elts; if (!nelts) { /* simple case of already being sorted... */ /* We're not checking this condition to be fast... we're checking * it to avoid trying to palloc zero bytes, which can trigger some * memory debuggers to barf */ return; } /* we have to allocate tmp space to do a stable sort */ apr_pool_create(&tmp, p); apr_pool_tag(tmp, "core_reorder_directories"); sortbin = apr_palloc(tmp, sec_dir->nelts * sizeof(*sortbin)); for (i = 0; i < nelts; ++i) { sortbin[i].orig_index = i; sortbin[i].elt = elts[i]; } qsort(sortbin, nelts, sizeof(*sortbin), reorder_sorter); /* and now copy back to the original array */ for (i = 0; i < nelts; ++i) { elts[i] = sortbin[i].elt; } apr_pool_destroy(tmp); } /***************************************************************** * * There are some elements of the core config structures in which * other modules have a legitimate interest (this is ugly, but necessary * to preserve NCSA back-compatibility). So, we have a bunch of accessors * here... */ AP_DECLARE(int) ap_allow_options(request_rec *r) { core_dir_config *conf = (core_dir_config *)ap_get_core_module_config(r->per_dir_config); return conf->opts; } AP_DECLARE(int) ap_allow_overrides(request_rec *r) { core_dir_config *conf; conf = (core_dir_config *)ap_get_core_module_config(r->per_dir_config); return conf->override; } /* * Optional function coming from mod_authn_core, used for * retrieving the type of authorization */ static APR_OPTIONAL_FN_TYPE(authn_ap_auth_type) *authn_ap_auth_type; AP_DECLARE(const char *) ap_auth_type(request_rec *r) { if (authn_ap_auth_type) { return authn_ap_auth_type(r); } return NULL; } /* * Optional function coming from mod_authn_core, used for * retrieving the authorization realm */ static APR_OPTIONAL_FN_TYPE(authn_ap_auth_name) *authn_ap_auth_name; AP_DECLARE(const char *) ap_auth_name(request_rec *r) { if (authn_ap_auth_name) { return authn_ap_auth_name(r); } return NULL; } /* * Optional function coming from mod_access_compat, used to determine how access control interacts with authentication/authorization */ static APR_OPTIONAL_FN_TYPE(access_compat_ap_satisfies) *access_compat_ap_satisfie AP_DECLARE(int) ap_satisfies(request_rec *r) { if (access_compat_ap_satisfies) { return access_compat_ap_satisfies(r); } return SATISFY_NOSPEC; } AP_DECLARE(const char *) ap_document_root(request_rec *r) /* Don't use this! */ { core_server_config *sconf; core_request_config *rconf = ap_get_core_module_config(r->request_config); if (rconf->document_root) return rconf->document_root; sconf = ap_get_core_module_config(r->server->module_config); return sconf->ap_document_root; } AP_DECLARE(const char *) ap_context_prefix(request_rec *r) { core_request_config *conf = ap_get_core_module_config(r->request_config); if (conf->context_prefix) return conf->context_prefix; else return ""; } AP_DECLARE(const char *) ap_context_document_root(request_rec *r) { core_request_config *conf = ap_get_core_module_config(r->request_config); if (conf->context_document_root) return conf->context_document_root; else return ap_document_root(r); } AP_DECLARE(void) ap_set_document_root(request_rec *r, const char *document_root) { core_request_config *conf = ap_get_core_module_config(r->request_config); conf->document_root = document_root; } AP_DECLARE(void) ap_set_context_info(request_rec *r, const char *context_prefix, const char *context_document_root) { core_request_config *conf = ap_get_core_module_config(r->request_config); if (context_prefix) conf->context_prefix = context_prefix; if (context_document_root) conf->context_document_root = context_document_root; } /* Should probably just get rid of this... the only code that cares is * part of the core anyway (and in fact, it isn't publicised to other * modules). */ char *ap_response_code_string(request_rec *r, int error_index) { core_dir_config *dirconf; core_request_config *reqconf = ap_get_core_module_config(r->request_config); const char *err; const char *response; ap_expr_info_t *expr; /* check for string registered via ap_custom_response() first */ if (reqconf->response_code_strings != NULL && reqconf->response_code_strings[error_index] != NULL) { return reqconf->response_code_strings[error_index]; } /* check for string specified via ErrorDocument */ dirconf = ap_get_core_module_config(r->per_dir_config); if (!dirconf->response_code_exprs) { return NULL; } expr = apr_hash_get(dirconf->response_code_exprs, &error_index, sizeof(error_index)); if (!expr) { return NULL; } /* special token to indicate revert back to default */ if ((char *) expr == &errordocument_default) { return NULL; } err = NULL; response = ap_expr_str_exec(r, expr, &err); if (err) { ap_log_rerror( APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(02841) "core: ErrorDocument: can't " "evaluate require expression: %s", err); return NULL; } /* alas, duplication required as we return not-const */ return apr_pstrdup(r->pool, response); } /* Code from Harald Hanche-Olsen <hanche@imf.unit.no> */ static APR_INLINE int do_double_reverse (int double_reverse, const char *remote_host, apr_sockaddr_t *client_addr, apr_pool_t *pool) { apr_sockaddr_t *sa; apr_status_t rv; if (double_reverse) { /* already done */ return double_reverse; } if (remote_host == NULL || remote_host[0] == '\0') { /* single reverse failed, so don't bother */ return -1; } rv = apr_sockaddr_info_get(&sa, remote_host, APR_UNSPEC, 0, 0, pool); if (rv == APR_SUCCESS) { while (sa) { if (apr_sockaddr_equal(sa, client_addr)) { return 1; } sa = sa->next; } } return -1; } AP_DECLARE(const char *) ap_get_remote_host(conn_rec *conn, void *dir_config, int type, int *str_is_ip) { int hostname_lookups; int ignored_str_is_ip; if (!str_is_ip) { /* caller doesn't want to know */ str_is_ip = &ignored_str_is_ip; } *str_is_ip = 0; /* If we haven't checked the host name, and we want to */ if (dir_config) { hostname_lookups = ((core_dir_config *)ap_get_core_module_config(dir_config)) ->hostname_lookups; if (hostname_lookups == HOSTNAME_LOOKUP_UNSET) { hostname_lookups = HOSTNAME_LOOKUP_OFF; } } else { /* the default */ hostname_lookups = HOSTNAME_LOOKUP_OFF; } if (type != REMOTE_NOLOOKUP && conn->remote_host == NULL && (type == REMOTE_DOUBLE_REV || hostname_lookups != HOSTNAME_LOOKUP_OFF)) { if (apr_getnameinfo(&conn->remote_host, conn->client_addr, 0) == APR_SUCCESS) { ap_str_tolower(conn->remote_host); if (hostname_lookups == HOSTNAME_LOOKUP_DOUBLE) { conn->double_reverse = do_double_reverse(conn->double_reverse, conn->remote_host, conn->client_addr, conn->pool); if (conn->double_reverse != 1) { conn->remote_host = NULL; } } } /* if failed, set it to the NULL string to indicate error */ if (conn->remote_host == NULL) { conn->remote_host = ""; } } if (type == REMOTE_DOUBLE_REV) { conn->double_reverse = do_double_reverse(conn->double_reverse, conn->remote_host, conn->client_addr, conn->pool); if (conn->double_reverse == -1) { return NULL; } } /* * Return the desired information; either the remote DNS name, if found, * or either NULL (if the hostname was requested) or the IP address * (if any identifier was requested). */ if (conn->remote_host != NULL && conn->remote_host[0] != '\0') { return conn->remote_host; } else { if (type == REMOTE_HOST || type == REMOTE_DOUBLE_REV) { return NULL; } else { *str_is_ip = 1; return conn->client_ip; } } } AP_DECLARE(const char *) ap_get_useragent_host(request_rec *r, int type, int *str_is_ip) { conn_rec *conn = r->connection; int hostname_lookups; int ignored_str_is_ip; /* Guard here when examining the host before the read_request hook * has populated an r->useragent_addr */ if (!r->useragent_addr || (r->useragent_addr == conn->client_addr)) { return ap_get_remote_host(conn, r->per_dir_config, type, str_is_ip); } if (!str_is_ip) { /* caller doesn't want to know */ str_is_ip = &ignored_str_is_ip; } *str_is_ip = 0; hostname_lookups = ((core_dir_config *) ap_get_core_module_config(r->per_dir_config)) ->hostname_lookups; if (hostname_lookups == HOSTNAME_LOOKUP_UNSET) { hostname_lookups = HOSTNAME_LOOKUP_OFF; } if (type != REMOTE_NOLOOKUP && r->useragent_host == NULL && (type == REMOTE_DOUBLE_REV || hostname_lookups != HOSTNAME_LOOKUP_OFF)) { if (apr_getnameinfo(&r->useragent_host, r->useragent_addr, 0) == APR_SUCCESS) { ap_str_tolower(r->useragent_host); if (hostname_lookups == HOSTNAME_LOOKUP_DOUBLE) { r->double_reverse = do_double_reverse(r->double_reverse, r->useragent_host, r->useragent_addr, r->pool); if (r->double_reverse != 1) { r->useragent_host = NULL; } } } /* if failed, set it to the NULL string to indicate error */ if (r->useragent_host == NULL) { r->useragent_host = ""; } } if (type == REMOTE_DOUBLE_REV) { r->double_reverse = do_double_reverse(r->double_reverse, r->useragent_host, r->useragent_addr, r->pool); if (r->double_reverse == -1) { return NULL; } } /* * Return the desired information; either the remote DNS name, if found, * or either NULL (if the hostname was requested) or the IP address * (if any identifier was requested). */ if (r->useragent_host != NULL && r->useragent_host[0] != '\0') { return r->useragent_host; } else { if (type == REMOTE_HOST || type == REMOTE_DOUBLE_REV) { return NULL; } else { *str_is_ip = 1; return r->useragent_ip; } } } /* * Optional function coming from mod_ident, used for looking up ident user */ static APR_OPTIONAL_FN_TYPE(ap_ident_lookup) *ident_lookup; AP_DECLARE(const char *) ap_get_remote_logname(request_rec *r) { if (r->connection->remote_logname != NULL) { return r->connection->remote_logname; } if (ident_lookup) { return ident_lookup(r); } return NULL; } /* There are two options regarding what the "name" of a server is. The * "canonical" name as defined by ServerName and Port, or the "client's * name" as supplied by a possible Host: header or full URI. * * The DNS option to UseCanonicalName causes this routine to do a * reverse lookup on the local IP address of the connection and use * that for the ServerName. This makes its value more reliable while * at the same time allowing Demon's magic virtual hosting to work. * The assumption is that DNS lookups are sufficiently quick... * -- fanf 1998-10-03 */ AP_DECLARE(const char *) ap_get_server_name(request_rec *r) { conn_rec *conn = r->connection; core_dir_config *d; const char *retval; d = (core_dir_config *)ap_get_core_module_config(r->per_dir_config); switch (d->use_canonical_name) { case USE_CANONICAL_NAME_ON: retval = r->server->server_hostname; break; case USE_CANONICAL_NAME_DNS: if (conn->local_host == NULL) { if (apr_getnameinfo(&conn->local_host, conn->local_addr, 0) != APR_SUCCESS) conn->local_host = apr_pstrdup(conn->pool, r->server->server_hostname); else { ap_str_tolower(conn->local_host); } } retval = conn->local_host; break; case USE_CANONICAL_NAME_OFF: case USE_CANONICAL_NAME_UNSET: retval = r->hostname ? r->hostname : r->server->server_hostname; break; default: ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00109) "ap_get_server_name: Invalid UCN Option somehow"); retval = "localhost"; break; } return retval; } /* * Get the current server name from the request for the purposes * of using in a URL. If the server name is an IPv6 literal * address, it will be returned in URL format (e.g., "[fe80::1]"). */ AP_DECLARE(const char *) ap_get_server_name_for_url(request_rec *r) { const char *plain_server_name = ap_get_server_name(r); #if APR_HAVE_IPV6 if (ap_strchr_c(plain_server_name, ':')) { /* IPv6 literal? */ return apr_pstrcat(r->pool, "[", plain_server_name, "]", NULL); } #endif return plain_server_name; } AP_DECLARE(apr_port_t) ap_get_server_port(const request_rec *r) { apr_port_t port; core_dir_config *d = (core_dir_config *)ap_get_core_module_config(r->per_dir_config); switch (d->use_canonical_name) { case USE_CANONICAL_NAME_OFF: case USE_CANONICAL_NAME_DNS: case USE_CANONICAL_NAME_UNSET: if (d->use_canonical_phys_port == USE_CANONICAL_PHYS_PORT_ON) port = r->parsed_uri.port_str ? r->parsed_uri.port : r->connection->local_addr->port ? r->connection->local_addr->port : r->server->port ? r->server->port : ap_default_port(r); else /* USE_CANONICAL_PHYS_PORT_OFF or USE_CANONICAL_PHYS_PORT_UNSET */ port = r->parsed_uri.port_str ? r->parsed_uri.port : r->server->port ? r->server->port : ap_default_port(r); break; case USE_CANONICAL_NAME_ON: /* With UseCanonicalName on (and in all versions prior to 1.3) * Apache will use the hostname and port specified in the * ServerName directive to construct a canonical name for the * server. (If no port was specified in the ServerName * directive, Apache uses the port supplied by the client if * any is supplied, and finally the default port for the protocol * used. */ if (d->use_canonical_phys_port == USE_CANONICAL_PHYS_PORT_ON) port = r->server->port ? r->server->port : r->connection->local_addr->port ? r->connection->local_addr->port : ap_default_port(r); else /* USE_CANONICAL_PHYS_PORT_OFF or USE_CANONICAL_PHYS_PORT_UNSET */ port = r->server->port ? r->server->port : ap_default_port(r); break; default: ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00110) "ap_get_server_port: Invalid UCN Option somehow"); port = ap_default_port(r); break; } return port; } AP_DECLARE(char *) ap_construct_url(apr_pool_t *p, const char *uri, request_rec *r) { unsigned port = ap_get_server_port(r); const char *host = ap_get_server_name_for_url(r); if (ap_is_default_port(port, r)) { return apr_pstrcat(p, ap_http_scheme(r), "://", host, uri, NULL); } return apr_psprintf(p, "%s://%s:%u%s", ap_http_scheme(r), host, port, uri); } AP_DECLARE(apr_off_t) ap_get_limit_req_body(const request_rec *r) { core_dir_config *d = (core_dir_config *)ap_get_core_module_config(r->per_dir_config); if (d->limit_req_body == AP_LIMIT_REQ_BODY_UNSET) { return AP_DEFAULT_LIMIT_REQ_BODY; } return d->limit_req_body; } AP_DECLARE(apr_size_t) ap_get_read_buf_size(const request_rec *r) { core_dir_config *d = ap_get_core_module_config(r->per_dir_config); return d->read_buf_size ? d->read_buf_size : AP_IOBUFSIZE; } /***************************************************************** * * Commands... this module handles almost all of the NCSA httpd.conf * commands, but most of the old srm.conf is in the modules. */ /* returns a parent if it matches the given directive */ static const ap_directive_t * find_parent(const ap_directive_t *dirp, const char *what) { while (dirp->parent != NULL) { dirp = dirp->parent; /* ### it would be nice to have atom-ized directives */ if (ap_cstr_casecmp(dirp->directive, what) == 0) return dirp; } return NULL; } AP_DECLARE(const char *) ap_check_cmd_context(cmd_parms *cmd, unsigned forbidden) { const char *gt = (cmd->cmd->name[0] == '<' && cmd->cmd->name[strlen(cmd->cmd->name)-1] != '>') ? ">" : ""; const ap_directive_t *found; if ((forbidden & NOT_IN_VIRTUALHOST) && cmd->server->is_virtual) { return apr_pstrcat(cmd->pool, cmd->cmd->name, gt, " cannot occur within } if ((forbidden & NOT_IN_DIR_CONTEXT) && cmd->limited != -1) { return apr_pstrcat(cmd->pool, cmd->cmd->name, gt, " cannot occur within "section", NULL); } if ((forbidden & NOT_IN_HTACCESS) && (cmd->pool == cmd->temp_pool)) { return apr_pstrcat(cmd->pool, cmd->cmd->name, gt, " cannot occur within htaccess files", NULL); } if ((forbidden & NOT_IN_DIR_LOC_FILE) == NOT_IN_DIR_LOC_FILE) { if (cmd->path != NULL) { return apr_pstrcat(cmd->pool, cmd->cmd->name, gt, " cannot occur within directory context", NULL); } if (cmd->cmd->req_override & EXEC_ON_READ) { /* EXEC_ON_READ must be NOT_IN_DIR_LOC_FILE, if not, it will * (deliberately) segfault below in the individual tests... */ return NULL; } } if (((forbidden & NOT_IN_DIRECTORY) && ((found = find_parent(cmd->directive, " || (found = find_parent(cmd->directive, " || ((forbidden & NOT_IN_LOCATION) && ((found = find_parent(cmd->directive, " || (found = find_parent(cmd->directive, " || ((forbidden & NOT_IN_FILES) && ((found = find_parent(cmd->directive, " || (found = find_parent(cmd->directive, " || (found = find_parent(cmd->directive, " || (found = find_parent(cmd->directive, " || (found = find_parent(cmd->directive, " || ((forbidden & NOT_IN_PROXY) && ((found = find_parent(cmd->directive, " || (found = find_parent(cmd->directive, " return apr_pstrcat(cmd->pool, cmd->cmd->name, gt, " cannot occur within ", found->directive, "> section", NULL); } return NULL; } static const char *set_access_name(cmd_parms *cmd, void *dummy, const char *arg) { void *sconf = cmd->server->module_config; core_server_config *conf = ap_get_core_module_config(sconf); const char *err = ap_check_cmd_context(cmd, NOT_IN_DIR_CONTEXT); if (err != NULL) { return err; } conf->access_name = apr_pstrdup(cmd->pool, arg); return NULL; } AP_DECLARE(const char *) ap_resolve_env(apr_pool_t *p, const char * word) { # define SMALL_EXPANSION 5 struct sll { struct sll *next; const char *string; apr_size_t len; } *result, *current, sresult[SMALL_EXPANSION]; char *res_buf, *cp; const char *s, *e, *ep; unsigned spc; apr_size_t outlen; s = ap_strchr_c(word, '$'); if (!s) { return word; } /* well, actually something to do */ ep = word + strlen(word); spc = 0; result = current = &(sresult[spc++]); current->next = NULL; current->string = word; current->len = s - word; outlen = current->len; do { /* prepare next entry */ if (current->len) { current->next = (spc < SMALL_EXPANSION) ? &(sresult[spc++]) : (struct sll *)apr_palloc(p, sizeof(*current->next)); current = current->next; current->next = NULL; current->len = 0; } if (*s == '$') { if (s[1] == '{' && (e = ap_strchr_c(s+2, '}'))) { char *name = apr_pstrmemdup(p, s+2, e-s-2); word = NULL; if (server_config_defined_vars) word = apr_table_get(server_config_defined_vars, name); if (!word) word = apr_pstrdup(p, getenv(name)); if (word) { current->string = word; current->len = strlen(word); outlen += current->len; } else { if (ap_strchr(name, ':') == 0) ap_log_error(APLOG_MARK, APLOG_WARNING, 0, NULL, APLOGNO(00111) "Config variable ${%s} is not defined", name); current->string = s; current->len = e - s + 1; outlen += current->len; } s = e + 1; } else { current->string = s++; current->len = 1; ++outlen; } } else { word = s; s = ap_strchr_c(s, '$'); current->string = word; current->len = s ? s - word : ep - word; outlen += current->len; } } while (s && *s); /* assemble result */ res_buf = cp = apr_palloc(p, outlen + 1); do { if (result->len) { memcpy(cp, result->string, result->len); cp += result->len; } result = result->next; } while (result); res_buf[outlen] = '\0'; return res_buf; } static int reset_config_defines(void *dummy) { ap_server_config_defines = saved_server_config_defines; saved_server_config_defines = NULL; server_config_defined_vars = NULL; ap_runtime_dir = NULL; return OK; } /* * Make sure we can revert the effects of Define/UnDefine when restarting. * This function must be called once per loading of the config, before * ap_server_config_defines is changed. This may be during reading of the * config, which is even before the pre_config hook is run (due to * EXEC_ON_READ for Define/UnDefine). */ static void init_config_defines(apr_pool_t *pconf) { saved_server_config_defines = ap_server_config_defines; /* Use apr_array_copy instead of apr_array_copy_hdr because it does not * protect from the way unset_define removes entries. */ ap_server_config_defines = apr_array_copy(pconf, ap_server_config_defines); } static const char *set_define(cmd_parms *cmd, void *dummy, const char *name, const char *value) { const char *err = ap_check_cmd_context(cmd, NOT_IN_HTACCESS); if (err) return err; if (ap_strchr_c(name, ':') != NULL) { return "Variable name must not contain ':'"; } if (!saved_server_config_defines) { init_config_defines(cmd->pool); } if (!ap_exists_config_define(name)) { *(const char **)apr_array_push(ap_server_config_defines) = name; } if (value) { if (!server_config_defined_vars) { server_config_defined_vars = apr_table_make(cmd->pool, 5); } apr_table_setn(server_config_defined_vars, name, value); } return NULL; } static const char *unset_define(cmd_parms *cmd, void *dummy, const char *name) { int i; const char **defines; const char *err = ap_check_cmd_context(cmd, NOT_IN_HTACCESS); if (err) return err; if (ap_strchr_c(name, ':') != NULL) { return "Variable name must not contain ':'"; } if (!saved_server_config_defines) { init_config_defines(cmd->pool); } defines = (const char **)ap_server_config_defines->elts; for (i = 0; i < ap_server_config_defines->nelts; i++) { if (strcmp(defines[i], name) == 0) { defines[i] = *(const char **)apr_array_pop(ap_server_config_defines); break; } } if (server_config_defined_vars) { apr_table_unset(server_config_defined_vars, name); } return NULL; } static const char *generate_error(cmd_parms *cmd, void *dummy, const char *arg) { if (!arg || !*arg) { return "The Error directive was used with no message."; } if (*arg == '"' || *arg == '\'') { /* strip off quotes */ apr_size_t len = strlen(arg); char last = *(arg + len - 1); if (*arg == last) { return apr_pstrndup(cmd->pool, arg + 1, len - 2); } } return arg; } #ifdef GPROF static const char *set_gprof_dir(cmd_parms *cmd, void *dummy, const char *arg) { void *sconf = cmd->server->module_config; core_server_config *conf = ap_get_core_module_config(sconf); const char *err = ap_check_cmd_context(cmd, NOT_IN_DIR_CONTEXT); if (err != NULL) { return err; } conf->gprof_dir = apr_pstrdup(cmd->pool, arg); return NULL; } #endif /*GPROF*/ static const char *set_add_default_charset(cmd_parms *cmd, void *d_, const char *arg) { core_dir_config *d = d_; if (!ap_cstr_casecmp(arg, "Off")) { d->add_default_charset = ADD_DEFAULT_CHARSET_OFF; } else if (!ap_cstr_casecmp(arg, "On")) { d->add_default_charset = ADD_DEFAULT_CHARSET_ON; d->add_default_charset_name = DEFAULT_ADD_DEFAULT_CHARSET_NAME; } else { d->add_default_charset = ADD_DEFAULT_CHARSET_ON; d->add_default_charset_name = arg; } return NULL; } static const char *set_document_root(cmd_parms *cmd, void *dummy, const char *arg) { void *sconf = cmd->server->module_config; core_server_config *conf = ap_get_core_module_config(sconf); const char *err = ap_check_cmd_context(cmd, NOT_IN_DIR_CONTEXT); if (err != NULL) { return err; } /* When ap_document_root_check is false; skip all the stuff below */ if (!ap_document_root_check) { conf->ap_document_root = arg; return NULL; } /* Make it absolute, relative to ServerRoot */ arg = ap_server_root_relative(cmd->pool, arg); if (arg == NULL) { return "DocumentRoot must be a directory"; } /* TODO: ap_configtestonly */ if (apr_filepath_merge((char**)&conf->ap_document_root, NULL, arg, APR_FILEPATH_TRUENAME, cmd->pool) != APR_SUCCESS || !ap_is_directory(cmd->temp_pool, arg)) { if (cmd->server->is_virtual) { ap_log_perror(APLOG_MARK, APLOG_STARTUP, 0, cmd->pool, APLOGNO(00112) "Warning: DocumentRoot [%s] does not exist", arg); conf->ap_document_root = arg; } else { return apr_psprintf(cmd->pool, "DocumentRoot '%s' is not a directory, or is not readable", arg); } } return NULL; } AP_DECLARE(void) ap_custom_response(request_rec *r, int status, const char *string) { core_request_config *conf = ap_get_core_module_config(r->request_config); int idx; if (conf->response_code_strings == NULL) { conf->response_code_strings = apr_pcalloc(r->pool, sizeof(*conf->response_code_strings) * RESPONSE_CODES); } idx = ap_index_of_response(status); conf->response_code_strings[idx] = ((ap_is_url(string) || (*string == '/')) && (*string != '"')) ? apr_pstrdup(r->pool, string) : apr_pstrcat(r->pool, "\"", string, NULL); } static const char *set_error_document(cmd_parms *cmd, void *conf_, const char *errno_str, const char *msg) { core_dir_config *conf = conf_; int error_number, index_number, idx500; enum { MSG, LOCAL_PATH, REMOTE_PATH } what = MSG; /* 1st parameter should be a 3 digit number, which we recognize; * convert it into an array index */ error_number = atoi(errno_str); idx500 = ap_index_of_response(HTTP_INTERNAL_SERVER_ERROR); if (error_number == HTTP_INTERNAL_SERVER_ERROR) { index_number = idx500; } else if ((index_number = ap_index_of_response(error_number)) == idx500) { return apr_pstrcat(cmd->pool, "Unsupported HTTP response code ", errno_str, NULL); } /* Heuristic to determine second argument. */ if (ap_strchr_c(msg,' ')) what = MSG; else if (msg[0] == '/') what = LOCAL_PATH; else if (ap_is_url(msg)) what = REMOTE_PATH; else what = MSG; /* The entry should be ignored if it is a full URL for a 401 error */ if (error_number == 401 && what == REMOTE_PATH) { ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, cmd->server, APLOGNO(00113) "%s:%d cannot use a full URL in a 401 ErrorDocument " "directive --- ignoring!", cmd->directive->filename, cmd->directive->line_num); } else { /* Store it... */ if (conf->response_code_exprs == NULL) { conf->response_code_exprs = apr_hash_make(cmd->pool); } if (ap_cstr_casecmp(msg, "default") == 0) { /* special case: ErrorDocument 404 default restores the * canned server error response */ apr_hash_set(conf->response_code_exprs, apr_pmemdup(cmd->pool, &index_number, sizeof(index_number)), sizeof(index_number), &errordocument_default); } else { ap_expr_info_t *expr; const char *expr_err = NULL; /* hack. Prefix a " if it is a msg; as that is what * http_protocol.c relies on to distinguish between * a msg and a (local) path. */ const char *response = (what == MSG) ? apr_pstrcat(cmd->pool, "\"", msg, NULL) : apr_pstrdup(cmd->pool, msg); expr = ap_expr_parse_cmd(cmd, response, AP_EXPR_FLAG_STRING_RESULT, &expr_err, NULL); if (expr_err) { return apr_pstrcat(cmd->temp_pool, "Cannot parse expression in ErrorDocument: ", expr_err, NULL); } apr_hash_set(conf->response_code_exprs, apr_pmemdup(cmd->pool, &index_number, sizeof(index_number)), sizeof(index_number), expr); } } return NULL; } static const char *set_allow_opts(cmd_parms *cmd, allow_options_t *opts, const char *l) { allow_options_t opt; int first = 1; char *w, *p = (char *) l; char *tok_state; while ((w = apr_strtok(p, ",", &tok_state)) != NULL) { if (first) { p = NULL; *opts = OPT_NONE; first = 0; } if (!ap_cstr_casecmp(w, "Indexes")) { opt = OPT_INDEXES; } else if (!ap_cstr_casecmp(w, "Includes")) { /* If Includes is permitted, both Includes and * IncludesNOEXEC may be changed. */ opt = (OPT_INCLUDES | OPT_INC_WITH_EXEC); } else if (!ap_cstr_casecmp(w, "IncludesNOEXEC")) { opt = OPT_INCLUDES; } else if (!ap_cstr_casecmp(w, "FollowSymLinks")) { opt = OPT_SYM_LINKS; } else if (!ap_cstr_casecmp(w, "SymLinksIfOwnerMatch")) { opt = OPT_SYM_OWNER; } else if (!ap_cstr_casecmp(w, "ExecCGI")) { opt = OPT_EXECCGI; } else if (!ap_cstr_casecmp(w, "MultiViews")) { opt = OPT_MULTI; } else if (!ap_cstr_casecmp(w, "RunScripts")) { /* AI backcompat. Yuck */ opt = OPT_MULTI|OPT_EXECCGI; } else if (!ap_cstr_casecmp(w, "None")) { opt = OPT_NONE; } else if (!ap_cstr_casecmp(w, "All")) { opt = OPT_ALL; } else { return apr_pstrcat(cmd->pool, "Illegal option ", w, NULL); } *opts |= opt; } (*opts) &= (~OPT_UNSET); return NULL; } static const char *set_override(cmd_parms *cmd, void *d_, const char *l) { core_dir_config *d = d_; char *w; char *k, *v; const char *err; /* Throw a warning if we're in <Location> or <Files> */ if (ap_check_cmd_context(cmd, NOT_IN_LOCATION | NOT_IN_FILES)) { ap_log_error(APLOG_MARK, APLOG_WARNING, 0, cmd->server, APLOGNO(00114) "Useless use of AllowOverride in line %d of %s.", cmd->directive->line_num, cmd->directive->filename); } if ((err = ap_check_cmd_context(cmd, NOT_IN_HTACCESS)) != NULL) return err; d->override = OR_NONE; while (l[0]) { w = ap_getword_conf(cmd->temp_pool, &l); k = w; v = strchr(k, '='); if (v) { *v++ = '\0'; } if (!ap_cstr_casecmp(w, "Limit")) { d->override |= OR_LIMIT; } else if (!ap_cstr_casecmp(k, "Options")) { d->override |= OR_OPTIONS; if (v) { if ((err = set_allow_opts(cmd, &(d->override_opts), v)) != NULL) return err; } else d->override_opts = OPT_ALL; } else if (!ap_cstr_casecmp(w, "FileInfo")) { d->override |= OR_FILEINFO; } else if (!ap_cstr_casecmp(w, "AuthConfig")) { d->override |= OR_AUTHCFG; } else if (!ap_cstr_casecmp(w, "Indexes")) { d->override |= OR_INDEXES; } else if (!ap_cstr_casecmp(w, "Nonfatal")) { if (!v) { return apr_pstrcat(cmd->pool, "=Override, =Unknown or =All expected after ", w, NULL) } else if (!ap_cstr_casecmp(v, "Override")) { d->override |= NONFATAL_OVERRIDE; } else if (!ap_cstr_casecmp(v, "Unknown")) { d->override |= NONFATAL_UNKNOWN; } else if (!ap_cstr_casecmp(v, "All")) { d->override |= NONFATAL_ALL; } } else if (!ap_cstr_casecmp(w, "None")) { d->override = OR_NONE; } else if (!ap_cstr_casecmp(w, "All")) { d->override = OR_ALL; } else { return apr_pstrcat(cmd->pool, "Illegal override option ", w, NULL); } d->override &= ~OR_UNSET; } return NULL; } static const char *set_cgi_pass_auth(cmd_parms *cmd, void *d_, int flag) { core_dir_config *d = d_; d->cgi_pass_auth = flag ? AP_CGI_PASS_AUTH_ON : AP_CGI_PASS_AUTH_OFF; return NULL; } static const char *set_cgi_var(cmd_parms *cmd, void *d_, const char *var, const char *rule_) { core_dir_config *d = d_; char *rule = apr_pstrdup(cmd->pool, rule_); ap_str_tolower(rule); if (!strcmp(var, "REQUEST_URI")) { if (strcmp(rule, "current-uri") && strcmp(rule, "original-uri")) { return "Valid rules for REQUEST_URI are 'current-uri' and 'original-uri'"; } } else { return apr_pstrcat(cmd->pool, "Unrecognized CGI variable: \"", var, "\"", NULL); } if (!d->cgi_var_rules) { d->cgi_var_rules = apr_hash_make(cmd->pool); } apr_hash_set(d->cgi_var_rules, var, APR_HASH_KEY_STRING, rule); return NULL; } static const char *set_qualify_redirect_url(cmd_parms *cmd, void *d_, int flag) { core_dir_config *d = d_; d->qualify_redirect_url = flag ? AP_CORE_CONFIG_ON : AP_CORE_CONFIG_OFF; return NULL; } static const char *set_core_server_flag(cmd_parms *cmd, void *s_, int flag) { core_server_config *conf = ap_get_core_module_config(cmd->server->module_config); return ap_set_flag_slot(cmd, conf, flag); } static const char *set_override_list(cmd_parms *cmd, void *d_, int argc, char *const argv[] { core_dir_config *d = d_; int i; const char *err; /* Throw a warning if we're in <Location> or <Files> */ if (ap_check_cmd_context(cmd, NOT_IN_LOCATION | NOT_IN_FILES)) { ap_log_error(APLOG_MARK, APLOG_WARNING, 0, cmd->server, APLOGNO(00115) "Useless use of AllowOverrideList at %s:%d", cmd->directive->filename, cmd->directive->line_num); } if ((err = ap_check_cmd_context(cmd, NOT_IN_HTACCESS)) != NULL) return err; d->override_list = apr_table_make(cmd->pool, argc); for (i = 0; i < argc; i++) { if (!ap_cstr_casecmp(argv[i], "None")) { if (argc != 1) { return "'None' not allowed with other directives in " "AllowOverrideList"; } return NULL; } else { const command_rec *result = NULL; module *mod = ap_top_module; result = ap_find_command_in_modules(argv[i], &mod); if (result == NULL) { ap_log_error(APLOG_MARK, APLOG_WARNING, 0, cmd->server, APLOGNO(00116) "Discarding unrecognized " "directive `%s' in AllowOverrideList at %s:%d", argv[i], cmd->directive->filename, cmd->directive->line_num); continue; } else if ((result->req_override & (OR_ALL|ACCESS_CONF)) == 0) { ap_log_error(APLOG_MARK, APLOG_WARNING, 0, cmd->server, APLOGNO(02304) "Discarding directive `%s' not " "allowed in AllowOverrideList at %s:%d", argv[i], cmd->directive->filename, cmd->directive->line_num); continue; } else { apr_table_setn(d->override_list, argv[i], "1"); } } } return NULL; } static const char *set_options(cmd_parms *cmd, void *d_, const char *l) { core_dir_config *d = d_; allow_options_t opt; int first = 1; int merge = 0; int all_none = 0; char action; while (l[0]) { char *w = ap_getword_conf(cmd->temp_pool, &l); action = '\0'; if (*w == '+' || *w == '-') { action = *(w++); if (!merge && !first && !all_none) { return "Either all Options must start with + or -, or no Option may."; } merge = 1; } else if (first) { d->opts = OPT_NONE; } else if (merge) { return "Either all Options must start with + or -, or no Option may."; } if (!ap_cstr_casecmp(w, "Indexes")) { opt = OPT_INDEXES; } else if (!ap_cstr_casecmp(w, "Includes")) { opt = (OPT_INCLUDES | OPT_INC_WITH_EXEC); } else if (!ap_cstr_casecmp(w, "IncludesNOEXEC")) { opt = OPT_INCLUDES; } --> -------------------- --> maximum size reached --> -------------------- ¤ Dauer der Verarbeitung: 0.47 Sekunden (vorverarbeitet) ¤*© Formatika GbR, Deutschland |
|
2026-03-28