/** * 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; }