/**
* Read a cookie called name, placing its value in val.
*
* Both the Cookie and Cookie2 headers are scanned for the cookie.
*
* If the cookie is duplicated, this function returns APR_EGENERAL. If found,
* and if remove is non zero, the cookie will be removed from the headers, and
* thus kept private from the backend.
*/
AP_DECLARE(apr_status_t) ap_cookie_read(request_rec * r, const char *name, const char **val,
int remove)
{
ap_cookie_do v;
v.r = r;
v.encoded = NULL;
v.new_cookies = apr_table_make(r->pool, 10);
v.duplicated = 0;
v.name = name;
apr_table_do((int (*) (void *, const char *, const char *))
extract_cookie_line, (void *) &v, r->headers_in,
"Cookie", "Cookie2", NULL);
if (v.duplicated) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00011) LOG_PREFIX
"client submitted cookie '%s' more than once: %s", v.name, r->uri);
return APR_EGENERAL;
}
/* remove our cookie(s), and replace them */
if (remove) {
apr_table_unset(r->headers_in, "Cookie");
apr_table_unset(r->headers_in, "Cookie2");
r->headers_in = apr_table_overlay(r->pool, r->headers_in, v.new_cookies);
}
*val = v.encoded;
return APR_SUCCESS;
}
static void proxy_clear_connection(apr_pool_t *p, apr_table_t *headers)
{
header_dptr x;
x.pool = p;
x.table = headers;
apr_table_unset(headers, "Proxy-Connection");
apr_table_do(clear_conn_headers, &x, headers, "Connection", NULL);
apr_table_unset(headers, "Connection");
}
void
chxj_header_inf_clear(request_rec *r)
{
int ii=0;
for (;v_header_inf_table[ii] != NULL; ii++) {
apr_table_unset(r->headers_out, v_header_inf_table[ii]);
apr_table_unset(r->err_headers_out, v_header_inf_table[ii]);
}
}
/* Create a new table consisting of those elements from an input
* headers table that are allowed to be stored in a cache.
*/
CACHE_DECLARE(apr_table_t *)ap_cache_cacheable_hdrs_out(apr_pool_t *pool,
apr_table_t *t,
server_rec *s)
{
cache_server_conf *conf;
char **header;
int i;
/* Make a copy of the headers, and remove from
* the copy any hop-by-hop headers, as defined in Section
* 13.5.1 of RFC 2616
*/
apr_table_t *headers_out;
headers_out = apr_table_copy(pool, t);
apr_table_unset(headers_out, "Connection");
apr_table_unset(headers_out, "Keep-Alive");
apr_table_unset(headers_out, "Proxy-Authenticate");
apr_table_unset(headers_out, "Proxy-Authorization");
apr_table_unset(headers_out, "TE");
apr_table_unset(headers_out, "Trailers");
apr_table_unset(headers_out, "Transfer-Encoding");
apr_table_unset(headers_out, "Upgrade");
conf = (cache_server_conf *)ap_get_module_config(s->module_config,
&cache_module);
/* Remove the user defined headers set with CacheIgnoreHeaders.
* This may break RFC 2616 compliance on behalf of the administrator.
*/
header = (char **)conf->ignore_headers->elts;
for (i = 0; i < conf->ignore_headers->nelts; i++) {
apr_table_unset(headers_out, header[i]);
}
return headers_out;
}
/**
* Fixup routine for request header processing.
*
* @params r The request record
*/
static apr_status_t replace_input_fixup(request_rec *r)
{
replace_server_t *conf = ap_get_module_config(r->server->module_config,
&replace_module);
replace_filter_t *filter = (replace_filter_t*)apr_hash_get(conf->h,
REQUEST_REPLACE_FILTER,
APR_HASH_KEY_STRING);
header_replace_pattern_t *pattern;
/* Exit if there is no filter definition. */
if (filter == NULL) {
return DECLINED;
}
/* Loop the configured patterns */
for (pattern = filter->header_pattern; pattern != NULL; pattern = pattern->next) {
apr_table_t *header_table = apr_table_make(r->pool, 2);
header_replace_cb_t *hrcb = apr_palloc(r->pool,
sizeof(header_replace_cb_t));
hrcb->header_table = header_table;
hrcb->pattern = pattern->pattern;
hrcb->extra = pattern->extra;
hrcb->replacement = pattern->replacement;
hrcb->r = r;
apr_table_do(replace_header_cb, hrcb, r->headers_in,
pattern->header, NULL);
if (!apr_is_empty_table(header_table)) {
apr_table_unset(r->headers_in, pattern->header);
r->headers_in = apr_table_overlay(r->pool, r->headers_in,
header_table);
}
}
return OK;
}
SV *modperl_table_get_set(pTHX_ apr_table_t *table, char *key,
SV *sv_val, int do_taint)
{
SV *retval = &PL_sv_undef;
if (table == NULL) {
/* do nothing */
}
else if (key == NULL) {
retval = modperl_hash_tie(aTHX_ "APR::Table",
(SV *)NULL, (void*)table);
}
else if (!sv_val) { /* no val was passed */
char *val;
if ((val = (char *)apr_table_get(table, key))) {
retval = newSVpv(val, 0);
}
else {
retval = newSV(0);
}
if (do_taint) {
SvTAINTED_on(retval);
}
}
else if (!SvOK(sv_val)) { /* val was passed in as undef */
apr_table_unset(table, key);
}
else {
apr_table_set(table, key, SvPV_nolen(sv_val));
}
return retval;
}
static int post_read_handler(request_rec *r)
{
conn_rec *c = r->connection;
my_config *conf = ap_get_module_config (c->base_server->module_config, &myfixip_module);
const char *new_ip = NULL;
// Save original IP
save_req_ip(r);
new_ip = apr_table_get(c->notes, NOTE_REWRITE_IP);
if (conf->resetHeader || new_ip || !check_trusted(c, conf)) {
apr_table_unset(r->headers_in, HDR_USERAGENT_IP);
}
if (new_ip) {
// Set Header
apr_table_set(r->headers_in, HDR_USERAGENT_IP, new_ip);
} else {
// Get Header
new_ip = apr_table_get(r->headers_in, HDR_USERAGENT_IP);
}
#ifdef DEBUG
ap_log_error(APLOG_MARK, APLOG_WARNING, 0, NULL, MODULE_NAME "::post_read_handler IP Connection from: %s:%d [%s] to port=%d newip=%s (OK)", _CLIENT_IP, _CLIENT_ADDR->port, _USERAGENT_IP, c->local_addr->port, new_ip);
#endif
if (new_ip && strcmp(_USERAGENT_IP, new_ip)) { // Change
rewrite_req_ip(r, new_ip);
}
return DECLINED;
}
static am_status_t set_request_body(am_request_t *rq) {
const char *thisfunc = "set_request_body():";
request_rec *r = (request_rec *) (rq != NULL ? rq->ctx : NULL);
am_status_t status = AM_EINVAL;
if (r == NULL || rq == NULL) {
return status;
}
apr_table_unset(r->notes, amagent_post_filter_name);
if (ISVALID(rq->post_data) && rq->post_data_sz > 0) {
size_t data_sz = rq->post_data_sz;
char *encoded = base64_encode(rq->post_data, &data_sz);
if (encoded != NULL) {
apr_table_set(r->notes, amagent_post_filter_name, encoded);
am_log_debug(rq->instance_id, "%s preserved %d bytes", thisfunc,
rq->post_data_sz);
/* restore the content length so that we have a
* match with a re-played data in the agent filter
*/
r->clength = rq->post_data_sz;
apr_table_set(r->headers_in, "Content-Length",
apr_psprintf(r->pool, "%ld", rq->post_data_sz));
free(encoded);
}
}
return AM_SUCCESS;
}
static void filter_insert(request_rec *r)
{
mod_filter_chain *p;
ap_filter_rec_t *filter;
mod_filter_cfg *cfg = ap_get_module_config(r->per_dir_config,
&filter_module);
#ifndef NO_PROTOCOL
int ranges = 1;
mod_filter_ctx *ctx = apr_pcalloc(r->pool, sizeof(mod_filter_ctx));
ap_set_module_config(r->request_config, &filter_module, ctx);
#endif
for (p = cfg->chain; p; p = p->next) {
filter = apr_hash_get(cfg->live_filters, p->fname, APR_HASH_KEY_STRING);
if (filter == NULL) {
ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r,
"Unknown filter %s not added", p->fname);
continue;
}
ap_add_output_filter_handle(filter, NULL, r, r->connection);
#ifndef NO_PROTOCOL
if (ranges && (filter->proto_flags
& (AP_FILTER_PROTO_NO_BYTERANGE
| AP_FILTER_PROTO_CHANGE_LENGTH))) {
ctx->range = apr_table_get(r->headers_in, "Range");
apr_table_unset(r->headers_in, "Range");
ranges = 0;
}
#endif
}
return;
}
static int table_ass_subscript(tableobject *self, PyObject *key,
PyObject *val)
{
char *k;
if (key && !PyString_Check(key)) {
PyErr_SetString(PyExc_TypeError,
"table keys must be strings");
return -1;
}
k = PyString_AsString(key);
if (val == NULL) {
apr_table_unset(self->table, k);
}
else {
if (val && !PyString_Check(val)) {
PyErr_SetString(PyExc_TypeError,
"table values must be strings");
return -1;
}
apr_table_set(self->table, k, PyString_AsString(val));
}
return 0;
}
/*
* Internal redirect / subrequest handler, working on request_status hook
*/
static int scgi_request_status(int *status, request_rec *r)
{
scgi_request_config *req_conf;
if ( (*status == OK)
&& (req_conf = ap_get_module_config(r->request_config,
&proxy_scgi_module))) {
switch (req_conf->type) {
case scgi_internal_redirect:
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
"proxy: " PROXY_FUNCTION ": Internal redirect to %s",
req_conf->location);
r->status_line = NULL;
if (r->method_number != M_GET) {
/* keep HEAD, which is passed around as M_GET, too */
r->method = "GET";
r->method_number = M_GET;
}
apr_table_unset(r->headers_in, "Content-Length");
ap_internal_redirect_handler(req_conf->location, r);
return OK;
/* break; */
case scgi_sendfile:
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
"proxy: " PROXY_FUNCTION ": File subrequest to %s",
req_conf->location);
do {
request_rec *rr;
rr = ap_sub_req_lookup_file(req_conf->location, r,
r->output_filters);
if (rr->status == HTTP_OK && rr->finfo.filetype != 0) {
/*
* We don't touch Content-Length here. It might be
* borked (there's plenty of room for a race condition).
* Either the backend sets it or it's gonna be chunked.
*/
ap_run_sub_req(rr);
}
else {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
"Subrequest to file '%s' not possible. "
"(rr->status=%d, rr->finfo.filetype=%d)",
req_conf->location, rr->status,
rr->finfo.filetype);
*status = HTTP_INTERNAL_SERVER_ERROR;
return *status;
}
} while(0);
return OK;
/* break; */
}
}
return DECLINED;
}
CAMLprim value
netcgi2_apache_table_unset (value tv, value key)
{
CAMLparam2 (tv, key);
table *t = Table_val (tv);
apr_table_unset (t, String_val (key));
CAMLreturn (Val_unit);
}
static void accept_headers(cache_handle_t *h, request_rec *r)
{
apr_table_t *cookie_table;
const char *v;
v = apr_table_get(h->resp_hdrs, "Content-Type");
if (v) {
ap_set_content_type(r, v);
apr_table_unset(h->resp_hdrs, "Content-Type");
}
/* If the cache gave us a Last-Modified header, we can't just
* pass it on blindly because of restrictions on future values.
*/
v = apr_table_get(h->resp_hdrs, "Last-Modified");
if (v) {
ap_update_mtime(r, apr_date_parse_http(v));
ap_set_last_modified(r);
apr_table_unset(h->resp_hdrs, "Last-Modified");
}
/* The HTTP specification says that it is legal to merge duplicate
* headers into one. Some browsers that support Cookies don't like
* merged headers and prefer that each Set-Cookie header is sent
* separately. Lets humour those browsers by not merging.
* Oh what a pain it is.
*/
cookie_table = apr_table_make(r->pool, 2);
apr_table_do(set_cookie_doo_doo, cookie_table, r->err_headers_out,
"Set-Cookie", NULL);
apr_table_do(set_cookie_doo_doo, cookie_table, h->resp_hdrs,
"Set-Cookie", NULL);
apr_table_unset(r->err_headers_out, "Set-Cookie");
apr_table_unset(h->resp_hdrs, "Set-Cookie");
apr_table_overlap(r->headers_out, h->resp_hdrs,
APR_OVERLAP_TABLES_SET);
apr_table_overlap(r->err_headers_out, h->resp_err_hdrs,
APR_OVERLAP_TABLES_SET);
if (!apr_is_empty_table(cookie_table)) {
r->err_headers_out = apr_table_overlay(r->pool, r->err_headers_out,
cookie_table);
}
}
static am_status_t set_header_in_request(am_request_t *rq, const char *key, const char *value) {
request_rec *r = (request_rec *) (rq != NULL ? rq->ctx : NULL);
if (r == NULL || !ISVALID(key)) return AM_EINVAL;
/* remove all instances of the header first */
apr_table_unset(r->headers_in, key);
if (ISVALID(value)) {
apr_table_set(r->headers_in, key, value);
}
return AM_SUCCESS;
}
static apr_status_t amagent_post_filter(ap_filter_t *f, apr_bucket_brigade *bucket_out,
ap_input_mode_t emode, apr_read_type_e eblock, apr_off_t nbytes) {
request_rec *r = f->r;
conn_rec *c = r->connection;
apr_bucket *bucket;
apr_size_t sz;
char *clean;
const char *data = apr_table_get(r->notes, amagent_post_filter_name);
do {
if (data == NULL) break;
sz = strlen(data);
clean = base64_decode(data, &sz);
if (clean == NULL) break;
apr_table_unset(r->notes, amagent_post_filter_name);
LOG_R(APLOG_DEBUG, r, "amagent_post_filter(): reposting %ld bytes", sz);
bucket = apr_bucket_heap_create((const char *) clean, sz, NULL, c->bucket_alloc);
if (bucket == NULL) {
free(clean);
return APR_EGENERAL;
}
APR_BRIGADE_INSERT_TAIL(bucket_out, bucket);
free(clean);
bucket = apr_bucket_eos_create(c->bucket_alloc);
if (bucket == NULL) {
return APR_EGENERAL;
}
APR_BRIGADE_INSERT_TAIL(bucket_out, bucket);
ap_remove_input_filter(f);
return APR_SUCCESS;
} while (0);
apr_table_unset(r->notes, amagent_post_filter_name);
ap_remove_input_filter(f);
return ap_get_brigade(f->next, bucket_out, emode, eblock, nbytes);
}
/*
* set a name/value key pair in the session
*/
static apr_status_t oidc_session_set_22(request_rec *r, session_rec *z,
const char *key, const char *value) {
/* only set it if non-NULL, otherwise delete the entry */
if (value) {
apr_table_set(z->entries, key, value);
} else {
apr_table_unset(z->entries, key);
}
return OK;
}
static void php_apache_request_ctor(ap_filter_t *f, php_struct *ctx)
{
char *content_type;
char *content_length;
const char *auth;
PG(during_request_startup) = 0;
SG(sapi_headers).http_response_code = !f->r->status ? HTTP_OK : f->r->status;
SG(request_info).content_type = apr_table_get(f->r->headers_in, "Content-Type");
#undef safe_strdup
#define safe_strdup(x) ((x)?strdup((x)):NULL)
SG(request_info).query_string = safe_strdup(f->r->args);
SG(request_info).request_method = f->r->method;
SG(request_info).proto_num = f->r->proto_num;
SG(request_info).request_uri = safe_strdup(f->r->uri);
SG(request_info).path_translated = safe_strdup(f->r->filename);
f->r->no_local_copy = 1;
content_type = sapi_get_default_content_type();
f->r->content_type = apr_pstrdup(f->r->pool, content_type);
efree(content_type);
content_length = (char *) apr_table_get(f->r->headers_in, "Content-Length");
SG(request_info).content_length = (content_length ? atol(content_length) : 0);
apr_table_unset(f->r->headers_out, "Content-Length");
apr_table_unset(f->r->headers_out, "Last-Modified");
apr_table_unset(f->r->headers_out, "Expires");
apr_table_unset(f->r->headers_out, "ETag");
auth = apr_table_get(f->r->headers_in, "Authorization");
php_handle_auth_data(auth);
if (SG(request_info).auth_user == NULL && f->r->user) {
SG(request_info).auth_user = estrdup(f->r->user);
}
ctx->r->user = apr_pstrdup(ctx->r->pool, SG(request_info).auth_user);
php_request_startup();
}
/**
* Take two sets of headers, sandwich them together, and apply the result to
* r->headers_out.
*
* To complicate this, a header may be duplicated in either table. Should a
* header exist in the top table, all matching headers will be removed from
* the bottom table before the headers are combined. The Warning headers are
* handled specially. Warnings are added rather than being replaced, while
* in the case of revalidation 1xx Warnings are stripped.
*
* The Content-Type and Last-Modified headers are then re-parsed and inserted
* into the request.
*/
void cache_accept_headers(cache_handle_t *h, request_rec *r, apr_table_t *top,
apr_table_t *bottom, int revalidation)
{
const char *v;
if (revalidation) {
r->headers_out = apr_table_make(r->pool, 10);
apr_table_do(filter_header_do, r->headers_out, bottom, NULL);
}
else if (r->headers_out != bottom) {
r->headers_out = apr_table_copy(r->pool, bottom);
}
apr_table_do(remove_header_do, r->headers_out, top, NULL);
apr_table_do(add_header_do, r->headers_out, top, NULL);
v = apr_table_get(r->headers_out, "Content-Type");
if (v) {
ap_set_content_type(r, v);
/*
* Also unset possible Content-Type headers in r->headers_out and
* r->err_headers_out as they may be different to what we have received
* from the cache.
* Actually they are not needed as r->content_type set by
* ap_set_content_type above will be used in the store_headers functions
* of the storage providers as a fallback and the HTTP_HEADER filter
* does overwrite the Content-Type header with r->content_type anyway.
*/
apr_table_unset(r->headers_out, "Content-Type");
apr_table_unset(r->err_headers_out, "Content-Type");
}
/* If the cache gave us a Last-Modified header, we can't just
* pass it on blindly because of restrictions on future values.
*/
v = apr_table_get(r->headers_out, "Last-Modified");
if (v) {
ap_update_mtime(r, apr_date_parse_http(v));
ap_set_last_modified(r);
}
}
static int remove_header_do(void *v, const char *key, const char *val)
{
if ((*key == 'W' || *key == 'w') && !strcasecmp(key, "Warning")) {
/* any stored Warning headers with warn-code 2xx MUST be retained
* in the cache entry and the forwarded response.
*/
}
else {
apr_table_unset(v, key);
}
return 1;
}
/**
* Initialisation of filter to handle a kept body on subrequests.
*
* If a body is to be reinserted into a subrequest, any chunking will have
* been removed from the body during storage. We need to change the request
* from Transfer-Encoding: chunked to an explicit Content-Length.
*/
static int kept_body_filter_init(ap_filter_t *f) {
apr_off_t length = 0;
request_rec *r = f->r;
apr_bucket_brigade *kept_body = r->kept_body;
if (kept_body) {
apr_table_unset(r->headers_in, "Transfer-Encoding");
apr_brigade_length(kept_body, 1, &length);
apr_table_setn(r->headers_in, "Content-Length", apr_off_t_toa(r->pool, length));
}
return OK;
}
static void table_unset(abts_case *tc, void *data)
{
const char *val;
apr_table_t *t = apr_table_make(p, 1);
apr_table_set(t, "a", "1");
apr_table_set(t, "b", "2");
apr_table_unset(t, "b");
ABTS_INT_EQUAL(tc, 1, apr_table_elts(t)->nelts);
val = apr_table_get(t, "a");
ABTS_STR_EQUAL(tc, "1", val);
val = apr_table_get(t, "b");
ABTS_PTR_EQUAL(tc, (void *)NULL, (void *)val);
}
static const char *add_env_module_vars_unset(cmd_parms *cmd, void *sconf_,
const char *arg)
{
env_dir_config_rec *sconf = sconf_;
/* Always UnsetEnv FOO in the same context as {Set,Pass}Env FOO
* only if this UnsetEnv follows the {Set,Pass}Env. The merge
* will only apply unsetenv to the parent env (main server).
*/
apr_table_set(sconf->unsetenv, arg, NULL);
apr_table_unset(sconf->vars, arg);
return NULL;
}
static int php_apache_request_ctor(request_rec *r, php_struct *ctx)
{
char *content_length;
const char *auth;
SG(sapi_headers).http_response_code = !r->status ? HTTP_OK : r->status;
SG(request_info).content_type = apr_table_get(r->headers_in, "Content-Type");
SG(request_info).query_string = apr_pstrdup(r->pool, r->args);
SG(request_info).request_method = r->method;
SG(request_info).proto_num = r->proto_num;
SG(request_info).request_uri = apr_pstrdup(r->pool, r->uri);
SG(request_info).path_translated = apr_pstrdup(r->pool, r->filename);
r->no_local_copy = 1;
content_length = (char *) apr_table_get(r->headers_in, "Content-Length");
if (content_length) {
ZEND_ATOL(SG(request_info).content_length, content_length);
} else {
SG(request_info).content_length = 0;
}
apr_table_unset(r->headers_out, "Content-Length");
apr_table_unset(r->headers_out, "Last-Modified");
apr_table_unset(r->headers_out, "Expires");
apr_table_unset(r->headers_out, "ETag");
auth = apr_table_get(r->headers_in, "Authorization");
php_handle_auth_data(auth);
if (SG(request_info).auth_user == NULL && r->user) {
SG(request_info).auth_user = estrdup(r->user);
}
ctx->r->user = apr_pstrdup(ctx->r->pool, SG(request_info).auth_user);
return php_request_startup();
}
static int
php_apache_sapi_header_handler(sapi_header_struct *sapi_header, sapi_header_op_enum op, sapi_headers_struct *sapi_headers)
{
php_struct *ctx;
char *val, *ptr;
ctx = SG(server_context);
switch(op) {
case SAPI_HEADER_DELETE:
apr_table_unset(ctx->r->headers_out, sapi_header->header);
return 0;
case SAPI_HEADER_DELETE_ALL:
apr_table_clear(ctx->r->headers_out);
return 0;
case SAPI_HEADER_ADD:
case SAPI_HEADER_REPLACE:
val = strchr(sapi_header->header, ':');
if (!val) {
sapi_free_header(sapi_header);
return 0;
}
ptr = val;
*val = '\0';
do {
val++;
} while (*val == ' ');
if (!strcasecmp(sapi_header->header, "content-type"))
ctx->r->content_type = apr_pstrdup(ctx->r->pool, val);
else if (!strcasecmp(sapi_header->header, "content-length"))
ap_set_content_length(ctx->r, strtol(val, (char **)NULL, 10));
else if (op == SAPI_HEADER_REPLACE)
apr_table_set(ctx->r->headers_out, sapi_header->header, val);
else
apr_table_add(ctx->r->headers_out, sapi_header->header, val);
*ptr = ':';
return SAPI_HEADER_ADD;
default:
return 0;
}
}
mapcache_http_response *mapcache_core_proxy_request(mapcache_context *ctx, mapcache_request_proxy *req_proxy)
{
mapcache_http *http;
mapcache_http_response *response = mapcache_http_response_create(ctx->pool);
response->data = mapcache_buffer_create(30000,ctx->pool);
http = req_proxy->http;
if(req_proxy->pathinfo) {
http = mapcache_http_clone(ctx,http);
if( (*(req_proxy->pathinfo)) == '/' ||
http->url[strlen(http->url)-1] == '/')
http->url = apr_pstrcat(ctx->pool,http->url,req_proxy->pathinfo,NULL);
else
http->url = apr_pstrcat(ctx->pool,http->url,"/",req_proxy->pathinfo,NULL);
}
mapcache_http_do_request_with_params(ctx,http,req_proxy->params,response->data,response->headers,&response->code);
if(response->code !=0 && GC_HAS_ERROR(ctx)) {
/* the http request was successful, but the server returned an error */
ctx->clear_errors(ctx);
}
/*remove some headers that should not be sent back to the client*/
apr_table_unset(response->headers,"Transfer-Encoding");
apr_table_unset(response->headers,"Connection");
return response;
}
static int clear_conn_headers(void *data, const char *key, const char *val)
{
apr_table_t *headers = ((header_dptr*)data)->table;
apr_pool_t *pool = ((header_dptr*)data)->pool;
const char *name;
char *next = apr_pstrdup(pool, val);
while (*next) {
name = next;
while (*next && !apr_isspace(*next) && (*next != ',')) {
++next;
}
while (*next && (apr_isspace(*next) || (*next == ','))) {
*next++ = '\0';
}
apr_table_unset(headers, name);
}
return 1;
}
static void *merge_env_dir_configs(apr_pool_t *p, void *basev, void *addv)
{
env_dir_config_rec *base = basev;
env_dir_config_rec *add = addv;
env_dir_config_rec *res = apr_palloc(p, sizeof(*res));
const apr_table_entry_t *elts;
const apr_array_header_t *arr;
int i;
/*
* res->vars = copy_table( p, base->vars );
* foreach $unsetenv ( @add->unsetenv )
* table_unset( res->vars, $unsetenv );
* foreach $element ( @add->vars )
* table_set( res->vars, $element.key, $element.val );
*
* add->unsetenv already removed the vars from add->vars,
* if they preceded the UnsetEnv directive.
*/
res->vars = apr_table_copy(p, base->vars);
res->unsetenv = NULL;
arr = apr_table_elts(add->unsetenv);
if (arr) {
elts = (const apr_table_entry_t *)arr->elts;
for (i = 0; i < arr->nelts; ++i) {
apr_table_unset(res->vars, elts[i].key);
}
}
arr = apr_table_elts(add->vars);
if (arr) {
elts = (const apr_table_entry_t *)arr->elts;
for (i = 0; i < arr->nelts; ++i) {
apr_table_setn(res->vars, elts[i].key, elts[i].val);
}
}
return res;
}
// copied from mod_session.c
static apr_status_t oidc_session_identity_decode(request_rec * r,
session_rec * z) {
char *last = NULL;
char *encoded, *pair;
const char *sep = "&";
//oidc_debug(r, "decoding %s", z->encoded);
/* sanity check - anything to decode? */
if (!z->encoded) {
return APR_SUCCESS;
}
/* decode what we have */
encoded = apr_pstrdup(r->pool, z->encoded);
pair = apr_strtok(encoded, sep, &last);
while (pair && pair[0]) {
char *plast = NULL;
const char *psep = "=";
char *key = apr_strtok(pair, psep, &plast);
char *val = apr_strtok(NULL, psep, &plast);
//oidc_debug(r, "decoding %s=%s", key, val);
if (key && *key) {
if (!val || !*val) {
apr_table_unset(z->entries, key);
} else if (!ap_unescape_urlencoded(key)
&& !ap_unescape_urlencoded(val)) {
if (!strcmp(OIDC_SESSION_EXPIRY_KEY, key)) {
z->expiry = (apr_time_t) apr_atoi64(val);
} else {
apr_table_set(z->entries, key, val);
}
}
}
pair = apr_strtok(NULL, sep, &last);
}
z->encoded = NULL;
return APR_SUCCESS;
}
static void filter_insert(request_rec *r)
{
mod_filter_chain *p;
ap_filter_rec_t *filter;
mod_filter_cfg *cfg = ap_get_module_config(r->per_dir_config,
&filter_module);
#ifndef NO_PROTOCOL
int ranges = 1;
mod_filter_ctx *ctx = apr_pcalloc(r->pool, sizeof(mod_filter_ctx));
ap_set_module_config(r->request_config, &filter_module, ctx);
#endif
/** IG: Now that we've merged to the final config, go one last time
* through the chain, and prune out the NULL filters */
for (p = cfg->chain; p; p = p->next) {
if (p->fname == NULL)
cfg->chain = p->next;
}
for (p = cfg->chain; p; p = p->next) {
filter = apr_hash_get(cfg->live_filters, p->fname, APR_HASH_KEY_STRING);
if (filter == NULL) {
ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r, APLOGNO(01380)
"Unknown filter %s not added", p->fname);
continue;
}
ap_add_output_filter_handle(filter, NULL, r, r->connection);
#ifndef NO_PROTOCOL
if (ranges && (filter->proto_flags
& (AP_FILTER_PROTO_NO_BYTERANGE
| AP_FILTER_PROTO_CHANGE_LENGTH))) {
ctx->range = apr_table_get(r->headers_in, "Range");
apr_table_unset(r->headers_in, "Range");
ranges = 0;
}
#endif
}
}
static saxctxt *check_html_filter_init(ap_filter_t * f)
{
saxctxt *fctx;
if (!f->ctx) {
cdn_conf *cfg = ap_get_module_config(f->r->per_dir_config, &cdn_module);
const char *errmsg = NULL;
if(!f->r->content_type)
errmsg = "check_html_filter_init: no content-type; bailing out of cdn filter";
else if(cfg->content_types) {
int i, found = 0;
tattr *content_types = (tattr *)cfg->content_types->elts;
for(i = 0; i < cfg->content_types->nelts; ++i) {
if(!strncasecmp(content_types[i].val, f->r->content_type, strlen(content_types[i].val))) {
found = 1;
break;
}
}
if(!found)
errmsg = "check_html_filter_init: Content-type doesn't match any defined types; "
"not inserting cdn filter";
}
if(errmsg) {
ap_log_error(APLOG_MARK, APLOG_DEBUG, APR_SUCCESS, f->r->server, "%s", errmsg);
ap_remove_output_filter(f);
return NULL;
}
fctx = f->ctx = apr_pcalloc(f->r->pool, sizeof(saxctxt));
fctx->f = f;
fctx->bb =
apr_brigade_create(f->r->pool, f->r->connection->bucket_alloc);
fctx->cfg = cfg;
apr_table_unset(f->r->headers_out, "Content-Length");
}
return f->ctx;
}
