| /* 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. | |
| */ | |
| /* | |
| * mod_expires.c | |
| * version 0.0.11 | |
| * status beta | |
| * | |
| * Andrew Wilson <Andrew.Wilson@cm.cf.ac.uk> 26.Jan.96 | |
| * | |
| * This module allows you to control the form of the Expires: header | |
| * that Apache issues for each access. Directives can appear in | |
| * configuration files or in .htaccess files so expiry semantics can | |
| * be defined on a per-directory basis. | |
| * | |
| * DIRECTIVE SYNTAX | |
| * | |
| * Valid directives are: | |
| * | |
| * ExpiresActive on | off | |
| * ExpiresDefault <code><seconds> | |
| * ExpiresByType type/encoding <code><seconds> | |
| * | |
| * Valid values for <code> are: | |
| * | |
| * 'M' expires header shows file modification date + <seconds> | |
| * 'A' expires header shows access time + <seconds> | |
| * | |
| * [I'm not sure which of these is best under different | |
| * circumstances, I guess it's for other people to explore. | |
| * The effects may be indistinguishable for a number of cases] | |
| * | |
| * <seconds> should be an integer value [acceptable to atoi()] | |
| * | |
| * There is NO space between the <code> and <seconds>. | |
| * | |
| * For example, a directory which contains information which changes | |
| * frequently might contain: | |
| * | |
| * # reports generated by cron every hour. don't let caches | |
| * # hold onto stale information | |
| * ExpiresDefault M3600 | |
| * | |
| * Another example, our html pages can change all the time, the gifs | |
| * tend not to change often: | |
| * | |
| * # pages are hot (1 week), images are cold (1 month) | |
| * ExpiresByType text/html A604800 | |
| * ExpiresByType image/gif A2592000 | |
| * | |
| * Expires can be turned on for all URLs on the server by placing the | |
| * following directive in a conf file: | |
| * | |
| * ExpiresActive on | |
| * | |
| * ExpiresActive can also appear in .htaccess files, enabling the | |
| * behaviour to be turned on or off for each chosen directory. | |
| * | |
| * # turn off Expires behaviour in this directory | |
| * # and subdirectories | |
| * ExpiresActive off | |
| * | |
| * Directives defined for a directory are valid in subdirectories | |
| * unless explicitly overridden by new directives in the subdirectory | |
| * .htaccess files. | |
| * | |
| * ALTERNATIVE DIRECTIVE SYNTAX | |
| * | |
| * Directives can also be defined in a more readable syntax of the form: | |
| * | |
| * ExpiresDefault "<base> [plus] {<num> <type>}*" | |
| * ExpiresByType type/encoding "<base> [plus] {<num> <type>}*" | |
| * | |
| * where <base> is one of: | |
| * access | |
| * now equivalent to 'access' | |
| * modification | |
| * | |
| * where the 'plus' keyword is optional | |
| * | |
| * where <num> should be an integer value [acceptable to atoi()] | |
| * | |
| * where <type> is one of: | |
| * years | |
| * months | |
| * weeks | |
| * days | |
| * hours | |
| * minutes | |
| * seconds | |
| * | |
| * For example, any of the following directives can be used to make | |
| * documents expire 1 month after being accessed, by default: | |
| * | |
| * ExpiresDefault "access plus 1 month" | |
| * ExpiresDefault "access plus 4 weeks" | |
| * ExpiresDefault "access plus 30 days" | |
| * | |
| * The expiry time can be fine-tuned by adding several '<num> <type>' | |
| * clauses: | |
| * | |
| * ExpiresByType text/html "access plus 1 month 15 days 2 hours" | |
| * ExpiresByType image/gif "modification plus 5 hours 3 minutes" | |
| * | |
| * --- | |
| * | |
| * Change-log: | |
| * 29.Jan.96 Hardened the add_* functions. Server will now bail out | |
| * if bad directives are given in the conf files. | |
| * 02.Feb.96 Returns DECLINED if not 'ExpiresActive on', giving other | |
| * expires-aware modules a chance to play with the same | |
| * directives. [Michael Rutman] | |
| * 03.Feb.96 Call tzset() before localtime(). Trying to get the module | |
| * to work properly in non GMT timezones. | |
| * 12.Feb.96 Modified directive syntax to allow more readable commands: | |
| * ExpiresDefault "now plus 10 days 20 seconds" | |
| * ExpiresDefault "access plus 30 days" | |
| * ExpiresDefault "modification plus 1 year 10 months 30 days" | |
| * 13.Feb.96 Fix call to table_get() with NULL 2nd parameter [Rob Hartill] | |
| * 19.Feb.96 Call gm_timestr_822() to get time formatted correctly, can't | |
| * rely on presence of HTTP_TIME_FORMAT in Apache 1.1+. | |
| * 21.Feb.96 This version (0.0.9) reverses assumptions made in 0.0.8 | |
| * about star/star handlers. Reverting to 0.0.7 behaviour. | |
| * 08.Jun.96 allows ExpiresDefault to be used with responses that use | |
| * the DefaultType by not DECLINING, but instead skipping | |
| * the table_get check and then looking for an ExpiresDefault. | |
| * [Rob Hartill] | |
| * 04.Nov.96 'const' definitions added. | |
| * | |
| * TODO | |
| * add support for Cache-Control: max-age=20 from the HTTP/1.1 | |
| * proposal (in this case, a ttl of 20 seconds) [ask roy] | |
| * add per-file expiry and explicit expiry times - duplicates some | |
| * of the mod_cern_meta.c functionality. eg: | |
| * ExpiresExplicit index.html "modification plus 30 days" | |
| * | |
| * BUGS | |
| * Hi, welcome to the internet. | |
| */ | |
| #include "apr.h" | |
| #include "apr_strings.h" | |
| #include "apr_lib.h" | |
| #define APR_WANT_STRFUNC | |
| #include "apr_want.h" | |
| #include "ap_config.h" | |
| #include "httpd.h" | |
| #include "http_config.h" | |
| #include "http_log.h" | |
| #include "http_request.h" | |
| #include "http_protocol.h" | |
| typedef struct { | |
| int active; | |
| int wildcards; | |
| char *expiresdefault; | |
| apr_table_t *expiresbytype; | |
| } expires_dir_config; | |
| /* from mod_dir, why is this alias used? | |
| */ | |
| #define DIR_CMD_PERMS OR_INDEXES | |
| #define ACTIVE_ON 1 | |
| #define ACTIVE_OFF 0 | |
| #define ACTIVE_DONTCARE 2 | |
| module AP_MODULE_DECLARE_DATA expires_module; | |
| static void *create_dir_expires_config(apr_pool_t *p, char *dummy) | |
| { | |
| expires_dir_config *new = | |
| (expires_dir_config *) apr_pcalloc(p, sizeof(expires_dir_config)); | |
| new->active = ACTIVE_DONTCARE; | |
| new->wildcards = 0; | |
| new->expiresdefault = NULL; | |
| new->expiresbytype = apr_table_make(p, 4); | |
| return (void *) new; | |
| } | |
| static const char *set_expiresactive(cmd_parms *cmd, void *in_dir_config, int arg) | |
| { | |
| expires_dir_config *dir_config = in_dir_config; | |
| /* if we're here at all it's because someone explicitly | |
| * set the active flag | |
| */ | |
| dir_config->active = ACTIVE_ON; | |
| if (arg == 0) { | |
| dir_config->active = ACTIVE_OFF; | |
| } | |
| return NULL; | |
| } | |
| /* check_code() parse 'code' and return NULL or an error response | |
| * string. If we return NULL then real_code contains code converted | |
| * to the cnnnn format. | |
| */ | |
| static char *check_code(apr_pool_t *p, const char *code, char **real_code) | |
| { | |
| char *word; | |
| char base = 'X'; | |
| int modifier = 0; | |
| int num = 0; | |
| int factor; | |
| /* 0.0.4 compatibility? | |
| */ | |
| if ((code[0] == 'A') || (code[0] == 'M')) { | |
| *real_code = (char *)code; | |
| return NULL; | |
| } | |
| /* <base> [plus] {<num> <type>}* | |
| */ | |
| /* <base> | |
| */ | |
| word = ap_getword_conf(p, &code); | |
| if (!strncasecmp(word, "now", 1) || | |
| !strncasecmp(word, "access", 1)) { | |
| base = 'A'; | |
| } | |
| else if (!strncasecmp(word, "modification", 1)) { | |
| base = 'M'; | |
| } | |
| else { | |
| return apr_pstrcat(p, "bad expires code, unrecognised <base> '", | |
| word, "'", NULL); | |
| } | |
| /* [plus] | |
| */ | |
| word = ap_getword_conf(p, &code); | |
| if (!strncasecmp(word, "plus", 1)) { | |
| word = ap_getword_conf(p, &code); | |
| } | |
| /* {<num> <type>}* | |
| */ | |
| while (word[0]) { | |
| /* <num> | |
| */ | |
| if (apr_isdigit(word[0])) { | |
| num = atoi(word); | |
| } | |
| else { | |
| return apr_pstrcat(p, "bad expires code, numeric value expected <num> '", | |
| word, "'", NULL); | |
| } | |
| /* <type> | |
| */ | |
| word = ap_getword_conf(p, &code); | |
| if (word[0] == '\0') { | |
| return apr_pstrcat(p, "bad expires code, missing <type>", NULL); | |
| } | |
| if (!strncasecmp(word, "years", 1)) { | |
| factor = 60 * 60 * 24 * 365; | |
| } | |
| else if (!strncasecmp(word, "months", 2)) { | |
| factor = 60 * 60 * 24 * 30; | |
| } | |
| else if (!strncasecmp(word, "weeks", 1)) { | |
| factor = 60 * 60 * 24 * 7; | |
| } | |
| else if (!strncasecmp(word, "days", 1)) { | |
| factor = 60 * 60 * 24; | |
| } | |
| else if (!strncasecmp(word, "hours", 1)) { | |
| factor = 60 * 60; | |
| } | |
| else if (!strncasecmp(word, "minutes", 2)) { | |
| factor = 60; | |
| } | |
| else if (!strncasecmp(word, "seconds", 1)) { | |
| factor = 1; | |
| } | |
| else { | |
| return apr_pstrcat(p, "bad expires code, unrecognised <type>", | |
| "'", word, "'", NULL); | |
| } | |
| modifier = modifier + factor * num; | |
| /* next <num> | |
| */ | |
| word = ap_getword_conf(p, &code); | |
| } | |
| *real_code = apr_psprintf(p, "%c%d", base, modifier); | |
| return NULL; | |
| } | |
| static const char *set_expiresbytype(cmd_parms *cmd, void *in_dir_config, | |
| const char *mime, const char *code) | |
| { | |
| expires_dir_config *dir_config = in_dir_config; | |
| char *response, *real_code; | |
| const char *check; | |
| check = ap_strrchr_c(mime, '/'); | |
| if (check == NULL) { | |
| return "Invalid mimetype: should contain a slash"; | |
| } | |
| if ((strlen(++check) == 1) && (*check == '*')) { | |
| dir_config->wildcards = 1; | |
| } | |
| if ((response = check_code(cmd->pool, code, &real_code)) == NULL) { | |
| apr_table_setn(dir_config->expiresbytype, mime, real_code); | |
| return NULL; | |
| } | |
| return apr_pstrcat(cmd->pool, | |
| "'ExpiresByType ", mime, " ", code, "': ", response, NULL); | |
| } | |
| static const char *set_expiresdefault(cmd_parms *cmd, void *in_dir_config, | |
| const char *code) | |
| { | |
| expires_dir_config * dir_config = in_dir_config; | |
| char *response, *real_code; | |
| if ((response = check_code(cmd->pool, code, &real_code)) == NULL) { | |
| dir_config->expiresdefault = real_code; | |
| return NULL; | |
| } | |
| return apr_pstrcat(cmd->pool, | |
| "'ExpiresDefault ", code, "': ", response, NULL); | |
| } | |
| static const command_rec expires_cmds[] = | |
| { | |
| AP_INIT_FLAG("ExpiresActive", set_expiresactive, NULL, DIR_CMD_PERMS, | |
| "Limited to 'on' or 'off'"), | |
| AP_INIT_TAKE2("ExpiresByType", set_expiresbytype, NULL, DIR_CMD_PERMS, | |
| "a MIME type followed by an expiry date code"), | |
| AP_INIT_TAKE1("ExpiresDefault", set_expiresdefault, NULL, DIR_CMD_PERMS, | |
| "an expiry date code"), | |
| {NULL} | |
| }; | |
| static void *merge_expires_dir_configs(apr_pool_t *p, void *basev, void *addv) | |
| { | |
| expires_dir_config *new = (expires_dir_config *) apr_pcalloc(p, sizeof(expires_dir_config)); | |
| expires_dir_config *base = (expires_dir_config *) basev; | |
| expires_dir_config *add = (expires_dir_config *) addv; | |
| if (add->active == ACTIVE_DONTCARE) { | |
| new->active = base->active; | |
| } | |
| else { | |
| new->active = add->active; | |
| } | |
| if (add->expiresdefault != NULL) { | |
| new->expiresdefault = add->expiresdefault; | |
| } | |
| else { | |
| new->expiresdefault = base->expiresdefault; | |
| } | |
| new->wildcards = add->wildcards; | |
| new->expiresbytype = apr_table_overlay(p, add->expiresbytype, | |
| base->expiresbytype); | |
| return new; | |
| } | |
| /* | |
| * Handle the setting of the expiration response header fields according | |
| * to our criteria. | |
| */ | |
| static int set_expiration_fields(request_rec *r, const char *code, | |
| apr_table_t *t) | |
| { | |
| apr_time_t base; | |
| apr_time_t additional; | |
| apr_time_t expires; | |
| int additional_sec; | |
| char *timestr; | |
| switch (code[0]) { | |
| case 'M': | |
| if (r->finfo.filetype == APR_NOFILE) { | |
| /* file doesn't exist on disk, so we can't do anything based on | |
| * modification time. Note that this does _not_ log an error. | |
| */ | |
| return DECLINED; | |
| } | |
| base = r->finfo.mtime; | |
| additional_sec = atoi(&code[1]); | |
| additional = apr_time_from_sec(additional_sec); | |
| break; | |
| case 'A': | |
| /* there's been some discussion and it's possible that | |
| * 'access time' will be stored in request structure | |
| */ | |
| base = r->request_time; | |
| additional_sec = atoi(&code[1]); | |
| additional = apr_time_from_sec(additional_sec); | |
| break; | |
| default: | |
| /* expecting the add_* routines to be case-hardened this | |
| * is just a reminder that module is beta | |
| */ | |
| ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01500) | |
| "internal error: bad expires code: %s", r->filename); | |
| return HTTP_INTERNAL_SERVER_ERROR; | |
| } | |
| expires = base + additional; | |
| if (expires < r->request_time) { | |
| expires = r->request_time; | |
| } | |
| apr_table_mergen(t, "Cache-Control", | |
| apr_psprintf(r->pool, "max-age=%" APR_TIME_T_FMT, | |
| apr_time_sec(expires - r->request_time))); | |
| timestr = apr_palloc(r->pool, APR_RFC822_DATE_LEN); | |
| apr_rfc822_date(timestr, expires); | |
| apr_table_setn(t, "Expires", timestr); | |
| return OK; | |
| } | |
| /* | |
| * Output filter to set the Expires response header field | |
| * according to the content-type of the response -- if it hasn't | |
| * already been set. | |
| */ | |
| static apr_status_t expires_filter(ap_filter_t *f, | |
| apr_bucket_brigade *b) | |
| { | |
| request_rec *r; | |
| expires_dir_config *conf; | |
| const char *expiry; | |
| apr_table_t *t; | |
| /* Don't add Expires headers to errors */ | |
| if (ap_is_HTTP_ERROR(f->r->status)) { | |
| ap_remove_output_filter(f); | |
| return ap_pass_brigade(f->next, b); | |
| } | |
| r = f->r; | |
| conf = (expires_dir_config *) ap_get_module_config(r->per_dir_config, | |
| &expires_module); | |
| /* | |
| * Check to see which output header table we should use; | |
| * mod_cgi loads script fields into r->err_headers_out, | |
| * for instance. | |
| */ | |
| expiry = apr_table_get(r->err_headers_out, "Expires"); | |
| if (expiry != NULL) { | |
| t = r->err_headers_out; | |
| } | |
| else { | |
| expiry = apr_table_get(r->headers_out, "Expires"); | |
| t = r->headers_out; | |
| } | |
| if (expiry == NULL) { | |
| /* | |
| * No expiration has been set, so we can apply any managed by | |
| * this module. First, check to see if there is an applicable | |
| * ExpiresByType directive. | |
| */ | |
| expiry = apr_table_get(conf->expiresbytype, | |
| ap_field_noparam(r->pool, r->content_type)); | |
| if (expiry == NULL) { | |
| int usedefault = 1; | |
| /* | |
| * See if we have a wildcard entry for the major type. | |
| */ | |
| if (conf->wildcards) { | |
| char *checkmime; | |
| char *spos; | |
| checkmime = apr_pstrdup(r->pool, r->content_type); | |
| spos = checkmime ? ap_strchr(checkmime, '/') : NULL; | |
| if (spos != NULL) { | |
| /* | |
| * Without a '/' character, nothing we have will match. | |
| * However, we have one. | |
| */ | |
| if (strlen(++spos) > 0) { | |
| *spos++ = '*'; | |
| *spos = '\0'; | |
| } | |
| else { | |
| checkmime = apr_pstrcat(r->pool, checkmime, "*", NULL); | |
| } | |
| expiry = apr_table_get(conf->expiresbytype, checkmime); | |
| usedefault = (expiry == NULL); | |
| } | |
| } | |
| if (usedefault) { | |
| /* | |
| * Use the ExpiresDefault directive | |
| */ | |
| expiry = conf->expiresdefault; | |
| } | |
| } | |
| if (expiry != NULL) { | |
| set_expiration_fields(r, expiry, t); | |
| } | |
| } | |
| ap_remove_output_filter(f); | |
| return ap_pass_brigade(f->next, b); | |
| } | |
| static void expires_insert_filter(request_rec *r) | |
| { | |
| expires_dir_config *conf; | |
| /* Don't add Expires headers to errors */ | |
| if (ap_is_HTTP_ERROR(r->status)) { | |
| return; | |
| } | |
| /* Say no to subrequests */ | |
| if (r->main != NULL) { | |
| return; | |
| } | |
| conf = (expires_dir_config *) ap_get_module_config(r->per_dir_config, | |
| &expires_module); | |
| /* Check to see if the filter is enabled and if there are any applicable | |
| * config directives for this directory scope | |
| */ | |
| if (conf->active != ACTIVE_ON || | |
| (apr_is_empty_table(conf->expiresbytype) && !conf->expiresdefault)) { | |
| return; | |
| } | |
| ap_add_output_filter("MOD_EXPIRES", NULL, r, r->connection); | |
| } | |
| static void register_hooks(apr_pool_t *p) | |
| { | |
| /* mod_expires needs to run *before* the cache save filter which is | |
| * AP_FTYPE_CONTENT_SET-1. Otherwise, our expires won't be honored. | |
| */ | |
| ap_register_output_filter("MOD_EXPIRES", expires_filter, NULL, | |
| AP_FTYPE_CONTENT_SET-2); | |
| ap_hook_insert_error_filter(expires_insert_filter, NULL, NULL, APR_HOOK_MIDDLE); | |
| ap_hook_insert_filter(expires_insert_filter, NULL, NULL, APR_HOOK_MIDDLE); | |
| } | |
| AP_DECLARE_MODULE(expires) = | |
| { | |
| STANDARD20_MODULE_STUFF, | |
| create_dir_expires_config, /* dir config creater */ | |
| merge_expires_dir_configs, /* dir merger --- default is to override */ | |
| NULL, /* server config */ | |
| NULL, /* merge server configs */ | |
| expires_cmds, /* command apr_table_t */ | |
| register_hooks /* register hooks */ | |
| }; |