| /* 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_strings.h" |
| #include "apr_thread_proc.h" /* for RLIMIT stuff */ |
| #include "apr_sha1.h" |
| #include "apr_base64.h" |
| #include "apr_buckets.h" |
| |
| #define APR_WANT_STRFUNC |
| #include "apr_want.h" |
| |
| #include "httpd.h" |
| #include "http_config.h" |
| #include "http_connection.h" |
| #include "http_core.h" |
| #include "http_log.h" |
| #include "http_protocol.h" /* For index_of_response(). Grump. */ |
| #include "http_request.h" |
| |
| #if APR_HAS_MMAP |
| #include "apr_mmap.h" |
| #endif /* APR_HAS_MMAP */ |
| |
| #define SHA1_DIGEST_BASE64_LEN 4*(APR_SHA1_DIGESTSIZE/3) |
| |
| /* Generate the human-readable hex representation of an apr_uint64_t |
| * (basically a faster version of 'sprintf("%llx")') |
| */ |
| #define HEX_DIGITS "0123456789abcdef" |
| static char *etag_uint64_to_hex(char *next, apr_uint64_t u) |
| { |
| int printing = 0; |
| int shift = sizeof(apr_uint64_t) * 8 - 4; |
| do { |
| unsigned short next_digit = (unsigned short) |
| ((u >> shift) & (apr_uint64_t)0xf); |
| if (next_digit) { |
| *next++ = HEX_DIGITS[next_digit]; |
| printing = 1; |
| } |
| else if (printing) { |
| *next++ = HEX_DIGITS[next_digit]; |
| } |
| shift -= 4; |
| } while (shift); |
| *next++ = HEX_DIGITS[u & (apr_uint64_t)0xf]; |
| return next; |
| } |
| |
| #define ETAG_WEAK "W/" |
| #define CHARS_PER_UINT64 (sizeof(apr_uint64_t) * 2) |
| |
| static void etag_start(char *etag, const char *weak, char **next) |
| { |
| if (weak) { |
| while (*weak) { |
| *etag++ = *weak++; |
| } |
| } |
| *etag++ = '"'; |
| |
| *next = etag; |
| } |
| |
| static void etag_end(char *next, const char *vlv, apr_size_t vlv_len) |
| { |
| if (vlv) { |
| *next++ = ';'; |
| apr_cpystrn(next, vlv, vlv_len); |
| } |
| else { |
| *next++ = '"'; |
| *next = '\0'; |
| } |
| } |
| |
| /* |
| * Construct a strong ETag by creating a SHA1 hash across the file content. |
| */ |
| static char *make_digest_etag(request_rec *r, etag_rec *er, char *vlv, |
| apr_size_t vlv_len, char *weak, apr_size_t weak_len) |
| { |
| apr_sha1_ctx_t context; |
| unsigned char digest[APR_SHA1_DIGESTSIZE]; |
| apr_file_t *fd = NULL; |
| core_dir_config *cfg; |
| char *etag, *next; |
| apr_bucket_brigade *bb; |
| apr_bucket *e; |
| |
| apr_size_t nbytes; |
| apr_off_t offset = 0, zero = 0, len = 0; |
| apr_status_t status; |
| |
| cfg = (core_dir_config *)ap_get_core_module_config(r->per_dir_config); |
| |
| if (er->fd) { |
| fd = er->fd; |
| } |
| else if (er->pathname) { |
| if ((status = apr_file_open(&fd, er->pathname, APR_READ | APR_BINARY, |
| 0, r->pool)) != APR_SUCCESS) { |
| ap_log_rerror(APLOG_MARK, APLOG_ERR, status, r, APLOGNO(10251) |
| "Make etag: could not open %s", er->pathname); |
| return ""; |
| } |
| } |
| if (!fd) { |
| return ""; |
| } |
| |
| if ((status = apr_file_seek(fd, APR_CUR, &offset)) != APR_SUCCESS) { |
| ap_log_rerror(APLOG_MARK, APLOG_ERR, status, r, APLOGNO(10252) |
| "Make etag: could not seek"); |
| if (er->pathname) { |
| apr_file_close(fd); |
| } |
| return ""; |
| } |
| |
| if ((status = apr_file_seek(fd, APR_END, &len)) != APR_SUCCESS) { |
| ap_log_rerror(APLOG_MARK, APLOG_ERR, status, r, APLOGNO(10258) |
| "Make etag: could not seek"); |
| if (er->pathname) { |
| apr_file_close(fd); |
| } |
| return ""; |
| } |
| |
| if ((status = apr_file_seek(fd, APR_SET, &zero)) != APR_SUCCESS) { |
| ap_log_rerror(APLOG_MARK, APLOG_ERR, status, r, APLOGNO(10253) |
| "Make etag: could not seek"); |
| if (er->pathname) { |
| apr_file_close(fd); |
| } |
| return ""; |
| } |
| |
| bb = apr_brigade_create(r->pool, r->connection->bucket_alloc); |
| |
| e = apr_brigade_insert_file(bb, fd, 0, len, r->pool); |
| |
| #if APR_HAS_MMAP |
| if (cfg->enable_mmap == ENABLE_MMAP_OFF) { |
| (void)apr_bucket_file_enable_mmap(e, 0); |
| } |
| #endif |
| |
| apr_sha1_init(&context); |
| while (!APR_BRIGADE_EMPTY(bb)) |
| { |
| const char *str; |
| |
| e = APR_BRIGADE_FIRST(bb); |
| |
| if ((status = apr_bucket_read(e, &str, &nbytes, APR_BLOCK_READ)) != APR_SUCCESS) { |
| apr_brigade_destroy(bb); |
| ap_log_rerror(APLOG_MARK, APLOG_ERR, status, r, APLOGNO(10254) |
| "Make etag: could not read"); |
| if (er->pathname) { |
| apr_file_close(fd); |
| } |
| return ""; |
| } |
| |
| apr_sha1_update(&context, str, nbytes); |
| apr_bucket_delete(e); |
| } |
| |
| if ((status = apr_file_seek(fd, APR_SET, &offset)) != APR_SUCCESS) { |
| ap_log_rerror(APLOG_MARK, APLOG_ERR, status, r, APLOGNO(10255) |
| "Make etag: could not seek"); |
| if (er->pathname) { |
| apr_file_close(fd); |
| } |
| return ""; |
| } |
| apr_sha1_final(digest, &context); |
| |
| etag = apr_palloc(r->pool, weak_len + sizeof("\"\"") + |
| SHA1_DIGEST_BASE64_LEN + vlv_len + 4); |
| |
| etag_start(etag, weak, &next); |
| next += apr_base64_encode_binary(next, digest, APR_SHA1_DIGESTSIZE) - 1; |
| etag_end(next, vlv, vlv_len); |
| |
| if (er->pathname) { |
| apr_file_close(fd); |
| } |
| |
| return etag; |
| } |
| |
| /* |
| * Construct an entity tag (ETag) from resource information. If it's a real |
| * file, build in some of the file characteristics. If the modification time |
| * is newer than (request-time minus 1 second), mark the ETag as weak - it |
| * could be modified again in as short an interval. |
| */ |
| AP_DECLARE(char *) ap_make_etag_ex(request_rec *r, etag_rec *er) |
| { |
| char *weak = NULL; |
| apr_size_t weak_len = 0, vlv_len = 0; |
| char *etag, *next, *vlv; |
| core_dir_config *cfg; |
| etag_components_t etag_bits; |
| etag_components_t bits_added; |
| |
| cfg = (core_dir_config *)ap_get_core_module_config(r->per_dir_config); |
| etag_bits = (cfg->etag_bits & (~ cfg->etag_remove)) | cfg->etag_add; |
| |
| if (er->force_weak) { |
| weak = ETAG_WEAK; |
| weak_len = sizeof(ETAG_WEAK); |
| } |
| |
| if (r->vlist_validator) { |
| |
| /* If we have a variant list validator (vlv) due to the |
| * response being negotiated, then we create a structured |
| * entity tag which merges the variant etag with the variant |
| * list validator (vlv). This merging makes revalidation |
| * somewhat safer, ensures that caches which can deal with |
| * Vary will (eventually) be updated if the set of variants is |
| * changed, and is also a protocol requirement for transparent |
| * content negotiation. |
| */ |
| |
| /* if the variant list validator is weak, we make the whole |
| * structured etag weak. If we would not, then clients could |
| * have problems merging range responses if we have different |
| * variants with the same non-globally-unique strong etag. |
| */ |
| |
| vlv = r->vlist_validator; |
| if (vlv[0] == 'W') { |
| vlv += 3; |
| weak = ETAG_WEAK; |
| weak_len = sizeof(ETAG_WEAK); |
| } |
| else { |
| vlv++; |
| } |
| vlv_len = strlen(vlv); |
| |
| } |
| else { |
| vlv = NULL; |
| vlv_len = 0; |
| } |
| |
| /* |
| * Did a module flag the need for a strong etag, or did the |
| * configuration tell us to generate a digest? |
| */ |
| if (er->finfo->filetype == APR_REG && |
| (AP_REQUEST_IS_STRONG_ETAG(r) || (etag_bits & ETAG_DIGEST))) { |
| |
| return make_digest_etag(r, er, vlv, vlv_len, weak, weak_len); |
| } |
| |
| /* |
| * If it's a file (or we wouldn't be here) and no ETags |
| * should be set for files, return an empty string and |
| * note it for the header-sender to ignore. |
| */ |
| if (etag_bits & ETAG_NONE) { |
| return ""; |
| } |
| |
| if (etag_bits == ETAG_UNSET) { |
| etag_bits = ETAG_BACKWARD; |
| } |
| /* |
| * Make an ETag header out of various pieces of information. We use |
| * the last-modified date and, if we have a real file, the |
| * length and inode number - note that this doesn't have to match |
| * the content-length (i.e. includes), it just has to be unique |
| * for the file. |
| * |
| * If the request was made within a second of the last-modified date, |
| * we send a weak tag instead of a strong one, since it could |
| * be modified again later in the second, and the validation |
| * would be incorrect. |
| */ |
| if ((er->request_time - er->finfo->mtime < (1 * APR_USEC_PER_SEC))) { |
| weak = ETAG_WEAK; |
| weak_len = sizeof(ETAG_WEAK); |
| } |
| |
| if (er->finfo->filetype != APR_NOFILE) { |
| /* |
| * ETag gets set to [W/]"inode-size-mtime", modulo any |
| * FileETag keywords. |
| */ |
| etag = apr_palloc(r->pool, weak_len + sizeof("\"--\"") + |
| 3 * CHARS_PER_UINT64 + vlv_len + 2); |
| |
| etag_start(etag, weak, &next); |
| |
| bits_added = 0; |
| if (etag_bits & ETAG_INODE) { |
| next = etag_uint64_to_hex(next, er->finfo->inode); |
| bits_added |= ETAG_INODE; |
| } |
| if (etag_bits & ETAG_SIZE) { |
| if (bits_added != 0) { |
| *next++ = '-'; |
| } |
| next = etag_uint64_to_hex(next, er->finfo->size); |
| bits_added |= ETAG_SIZE; |
| } |
| if (etag_bits & ETAG_MTIME) { |
| if (bits_added != 0) { |
| *next++ = '-'; |
| } |
| next = etag_uint64_to_hex(next, er->finfo->mtime); |
| } |
| |
| etag_end(next, vlv, vlv_len); |
| |
| } |
| else { |
| /* |
| * Not a file document, so just use the mtime: [W/]"mtime" |
| */ |
| etag = apr_palloc(r->pool, weak_len + sizeof("\"\"") + |
| CHARS_PER_UINT64 + vlv_len + 2); |
| |
| etag_start(etag, weak, &next); |
| next = etag_uint64_to_hex(next, er->finfo->mtime); |
| etag_end(next, vlv, vlv_len); |
| |
| } |
| |
| return etag; |
| } |
| |
| AP_DECLARE(char *) ap_make_etag(request_rec *r, int force_weak) |
| { |
| etag_rec er; |
| |
| er.vlist_validator = NULL; |
| er.request_time = r->request_time; |
| er.finfo = &r->finfo; |
| er.pathname = r->filename; |
| er.fd = NULL; |
| er.force_weak = force_weak; |
| |
| return ap_make_etag_ex(r, &er); |
| } |
| |
| AP_DECLARE(void) ap_set_etag(request_rec *r) |
| { |
| char *etag; |
| |
| etag_rec er; |
| |
| er.vlist_validator = r->vlist_validator; |
| er.request_time = r->request_time; |
| er.finfo = &r->finfo; |
| er.pathname = r->filename; |
| er.fd = NULL; |
| er.force_weak = 0; |
| |
| etag = ap_make_etag_ex(r, &er); |
| |
| if (etag && etag[0]) { |
| apr_table_setn(r->headers_out, "ETag", etag); |
| } |
| else { |
| apr_table_setn(r->notes, "no-etag", "omit"); |
| } |
| |
| } |
| |
| AP_DECLARE(void) ap_set_etag_fd(request_rec *r, apr_file_t *fd) |
| { |
| char *etag; |
| |
| etag_rec er; |
| |
| er.vlist_validator = r->vlist_validator; |
| er.request_time = r->request_time; |
| er.finfo = &r->finfo; |
| er.pathname = NULL; |
| er.fd = fd; |
| er.force_weak = 0; |
| |
| etag = ap_make_etag_ex(r, &er); |
| |
| if (etag && etag[0]) { |
| apr_table_setn(r->headers_out, "ETag", etag); |
| } |
| else { |
| apr_table_setn(r->notes, "no-etag", "omit"); |
| } |
| |
| } |
