From 6beeb1b708550be0d4a53b272283e17e5e35fe17 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 17:01:30 +0200 Subject: Adding upstream version 2.4.57. Signed-off-by: Daniel Baumann --- modules/filters/mod_brotli.c | 608 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 608 insertions(+) create mode 100644 modules/filters/mod_brotli.c (limited to 'modules/filters/mod_brotli.c') diff --git a/modules/filters/mod_brotli.c b/modules/filters/mod_brotli.c new file mode 100644 index 0000000..0f7d770 --- /dev/null +++ b/modules/filters/mod_brotli.c @@ -0,0 +1,608 @@ +/* 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 "httpd.h" +#include "http_core.h" +#include "http_log.h" +#include "apr_strings.h" + +#include + +module AP_MODULE_DECLARE_DATA brotli_module; + +typedef enum { + ETAG_MODE_ADDSUFFIX = 0, + ETAG_MODE_NOCHANGE = 1, + ETAG_MODE_REMOVE = 2 +} etag_mode_e; + +typedef struct brotli_server_config_t { + int quality; + int lgwin; + int lgblock; + etag_mode_e etag_mode; + const char *note_ratio_name; + const char *note_input_name; + const char *note_output_name; +} brotli_server_config_t; + +static void *create_server_config(apr_pool_t *p, server_rec *s) +{ + brotli_server_config_t *conf = apr_pcalloc(p, sizeof(*conf)); + + /* These default values allow mod_brotli to behave similarly to + * mod_deflate in terms of compression speed and memory usage. + * + * The idea is that since Brotli (generally) gives better compression + * ratio than Deflate, simply enabling mod_brotli on the server + * will reduce the amount of transferred data while keeping everything + * else unchanged. See https://quixdb.github.io/squash-benchmark/ + */ + conf->quality = 5; + conf->lgwin = 18; + /* Zero is a special value for BROTLI_PARAM_LGBLOCK that allows + * Brotli to automatically select the optimal input block size based + * on other encoder parameters. See enc/quality.h: ComputeLgBlock(). + */ + conf->lgblock = 0; + conf->etag_mode = ETAG_MODE_ADDSUFFIX; + + return conf; +} + +static const char *set_filter_note(cmd_parms *cmd, void *dummy, + const char *arg1, const char *arg2) +{ + brotli_server_config_t *conf = + ap_get_module_config(cmd->server->module_config, &brotli_module); + + if (!arg2) { + conf->note_ratio_name = arg1; + return NULL; + } + + if (ap_cstr_casecmp(arg1, "Ratio") == 0) { + conf->note_ratio_name = arg2; + } + else if (ap_cstr_casecmp(arg1, "Input") == 0) { + conf->note_input_name = arg2; + } + else if (ap_cstr_casecmp(arg1, "Output") == 0) { + conf->note_output_name = arg2; + } + else { + return apr_psprintf(cmd->pool, "Unknown BrotliFilterNote type '%s'", + arg1); + } + + return NULL; +} + +static const char *set_compression_quality(cmd_parms *cmd, void *dummy, + const char *arg) +{ + brotli_server_config_t *conf = + ap_get_module_config(cmd->server->module_config, &brotli_module); + int val = atoi(arg); + + if (val < 0 || val > 11) { + return "BrotliCompressionQuality must be between 0 and 11"; + } + + conf->quality = val; + return NULL; +} + +static const char *set_compression_lgwin(cmd_parms *cmd, void *dummy, + const char *arg) +{ + brotli_server_config_t *conf = + ap_get_module_config(cmd->server->module_config, &brotli_module); + int val = atoi(arg); + + if (val < 10 || val > 24) { + return "BrotliCompressionWindow must be between 10 and 24"; + } + + conf->lgwin = val; + return NULL; +} + +static const char *set_compression_lgblock(cmd_parms *cmd, void *dummy, + const char *arg) +{ + brotli_server_config_t *conf = + ap_get_module_config(cmd->server->module_config, &brotli_module); + int val = atoi(arg); + + if (val < 16 || val > 24) { + return "BrotliCompressionMaxInputBlock must be between 16 and 24"; + } + + conf->lgblock = val; + return NULL; +} + +static const char *set_etag_mode(cmd_parms *cmd, void *dummy, + const char *arg) +{ + brotli_server_config_t *conf = + ap_get_module_config(cmd->server->module_config, &brotli_module); + + if (ap_cstr_casecmp(arg, "AddSuffix") == 0) { + conf->etag_mode = ETAG_MODE_ADDSUFFIX; + } + else if (ap_cstr_casecmp(arg, "NoChange") == 0) { + conf->etag_mode = ETAG_MODE_NOCHANGE; + } + else if (ap_cstr_casecmp(arg, "Remove") == 0) { + conf->etag_mode = ETAG_MODE_REMOVE; + } + else { + return "BrotliAlterETag accepts only 'AddSuffix', 'NoChange' and 'Remove'"; + } + + return NULL; +} + +typedef struct brotli_ctx_t { + BrotliEncoderState *state; + apr_bucket_brigade *bb; + apr_off_t total_in; + apr_off_t total_out; +} brotli_ctx_t; + +static void *alloc_func(void *opaque, size_t size) +{ + return apr_bucket_alloc(size, opaque); +} + +static void free_func(void *opaque, void *block) +{ + if (block) { + apr_bucket_free(block); + } +} + +static apr_status_t cleanup_ctx(void *data) +{ + brotli_ctx_t *ctx = data; + + BrotliEncoderDestroyInstance(ctx->state); + ctx->state = NULL; + return APR_SUCCESS; +} + +static brotli_ctx_t *create_ctx(int quality, + int lgwin, + int lgblock, + apr_bucket_alloc_t *alloc, + apr_pool_t *pool) +{ + brotli_ctx_t *ctx = apr_pcalloc(pool, sizeof(*ctx)); + + ctx->state = BrotliEncoderCreateInstance(alloc_func, free_func, alloc); + BrotliEncoderSetParameter(ctx->state, BROTLI_PARAM_QUALITY, quality); + BrotliEncoderSetParameter(ctx->state, BROTLI_PARAM_LGWIN, lgwin); + BrotliEncoderSetParameter(ctx->state, BROTLI_PARAM_LGBLOCK, lgblock); + apr_pool_cleanup_register(pool, ctx, cleanup_ctx, apr_pool_cleanup_null); + + ctx->bb = apr_brigade_create(pool, alloc); + ctx->total_in = 0; + ctx->total_out = 0; + + return ctx; +} + +static apr_status_t process_chunk(brotli_ctx_t *ctx, + const void *data, + apr_size_t len, + ap_filter_t *f) +{ + const apr_byte_t *next_in = data; + apr_size_t avail_in = len; + + while (avail_in > 0) { + apr_byte_t *next_out = NULL; + apr_size_t avail_out = 0; + + if (!BrotliEncoderCompressStream(ctx->state, + BROTLI_OPERATION_PROCESS, + &avail_in, &next_in, + &avail_out, &next_out, NULL)) { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, f->r, APLOGNO(03459) + "Error while compressing data"); + return APR_EGENERAL; + } + + if (BrotliEncoderHasMoreOutput(ctx->state)) { + apr_size_t output_len = 0; + const apr_byte_t *output; + apr_status_t rv; + apr_bucket *b; + + /* Drain the accumulated output. Avoid copying the data by + * wrapping a pointer to the internal output buffer and passing + * it down to the next filter. The pointer is only valid until + * the next call to BrotliEncoderCompressStream(), but we're okay + * with that, since the brigade is cleaned up right after the + * ap_pass_brigade() call. + */ + output = BrotliEncoderTakeOutput(ctx->state, &output_len); + ctx->total_out += output_len; + + b = apr_bucket_transient_create((const char *)output, output_len, + ctx->bb->bucket_alloc); + APR_BRIGADE_INSERT_TAIL(ctx->bb, b); + + rv = ap_pass_brigade(f->next, ctx->bb); + apr_brigade_cleanup(ctx->bb); + if (rv != APR_SUCCESS) { + return rv; + } + } + } + + ctx->total_in += len; + return APR_SUCCESS; +} + +static apr_status_t flush(brotli_ctx_t *ctx, + BrotliEncoderOperation op, + ap_filter_t *f) +{ + while (1) { + const apr_byte_t *next_in = NULL; + apr_size_t avail_in = 0; + apr_byte_t *next_out = NULL; + apr_size_t avail_out = 0; + apr_size_t output_len; + const apr_byte_t *output; + apr_bucket *b; + + if (!BrotliEncoderCompressStream(ctx->state, op, + &avail_in, &next_in, + &avail_out, &next_out, NULL)) { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, f->r, APLOGNO(03460) + "Error while compressing data"); + return APR_EGENERAL; + } + + if (!BrotliEncoderHasMoreOutput(ctx->state)) { + break; + } + + /* A flush can require several calls to BrotliEncoderCompressStream(), + * so place the data on the heap (otherwise, the pointer will become + * invalid after the next call to BrotliEncoderCompressStream()). + */ + output_len = 0; + output = BrotliEncoderTakeOutput(ctx->state, &output_len); + ctx->total_out += output_len; + + b = apr_bucket_heap_create((const char *)output, output_len, NULL, + ctx->bb->bucket_alloc); + APR_BRIGADE_INSERT_TAIL(ctx->bb, b); + } + + return APR_SUCCESS; +} + +static const char *get_content_encoding(request_rec *r) +{ + const char *encoding; + + encoding = apr_table_get(r->headers_out, "Content-Encoding"); + if (encoding) { + const char *err_enc; + + err_enc = apr_table_get(r->err_headers_out, "Content-Encoding"); + if (err_enc) { + encoding = apr_pstrcat(r->pool, encoding, ",", err_enc, NULL); + } + } + else { + encoding = apr_table_get(r->err_headers_out, "Content-Encoding"); + } + + if (r->content_encoding) { + encoding = encoding ? apr_pstrcat(r->pool, encoding, ",", + r->content_encoding, NULL) + : r->content_encoding; + } + + return encoding; +} + +static apr_status_t compress_filter(ap_filter_t *f, apr_bucket_brigade *bb) +{ + request_rec *r = f->r; + brotli_ctx_t *ctx = f->ctx; + apr_status_t rv; + brotli_server_config_t *conf; + + if (APR_BRIGADE_EMPTY(bb)) { + return APR_SUCCESS; + } + + conf = ap_get_module_config(r->server->module_config, &brotli_module); + + if (!ctx) { + const char *encoding; + const char *token; + const char *accepts; + const char *q = NULL; + + /* Only work on main request, not subrequests, that are not + * a 204 response with no content, and are not tagged with the + * no-brotli env variable, and are not a partial response to + * a Range request. + * + * Note that responding to 304 is handled separately to set + * the required headers (such as ETag) per RFC7232, 4.1. + */ + if (r->main || r->status == HTTP_NO_CONTENT + || apr_table_get(r->subprocess_env, "no-brotli") + || apr_table_get(r->headers_out, "Content-Range")) { + ap_remove_output_filter(f); + return ap_pass_brigade(f->next, bb); + } + + /* Let's see what our current Content-Encoding is. */ + encoding = get_content_encoding(r); + + if (encoding) { + const char *tmp = encoding; + + token = ap_get_token(r->pool, &tmp, 0); + while (token && *token) { + if (strcmp(token, "identity") != 0 && + strcmp(token, "7bit") != 0 && + strcmp(token, "8bit") != 0 && + strcmp(token, "binary") != 0) { + /* The data is already encoded, do nothing. */ + ap_remove_output_filter(f); + return ap_pass_brigade(f->next, bb); + } + + if (*tmp) { + ++tmp; + } + token = (*tmp) ? ap_get_token(r->pool, &tmp, 0) : NULL; + } + } + + /* Even if we don't accept this request based on it not having + * the Accept-Encoding, we need to note that we were looking + * for this header and downstream proxies should be aware of + * that. + */ + apr_table_mergen(r->headers_out, "Vary", "Accept-Encoding"); + + accepts = apr_table_get(r->headers_in, "Accept-Encoding"); + if (!accepts) { + ap_remove_output_filter(f); + return ap_pass_brigade(f->next, bb); + } + + /* Do we have Accept-Encoding: br? */ + token = ap_get_token(r->pool, &accepts, 0); + while (token && token[0] && ap_cstr_casecmp(token, "br") != 0) { + while (*accepts == ';') { + ++accepts; + ap_get_token(r->pool, &accepts, 1); + } + + if (*accepts == ',') { + ++accepts; + } + token = (*accepts) ? ap_get_token(r->pool, &accepts, 0) : NULL; + } + + /* Find the qvalue, if provided */ + if (*accepts) { + while (*accepts == ';') { + ++accepts; + } + q = ap_get_token(r->pool, &accepts, 1); + ap_log_rerror(APLOG_MARK, APLOG_TRACE1, 0, r, + "token: '%s' - q: '%s'", token ? token : "NULL", q); + } + + /* No acceptable token found or q=0 */ + if (!token || token[0] == '\0' || + (q && strlen(q) >= 3 && strncmp("q=0.000", q, strlen(q)) == 0)) { + ap_remove_output_filter(f); + return ap_pass_brigade(f->next, bb); + } + + /* If the entire Content-Encoding is "identity", we can replace it. */ + if (!encoding || ap_cstr_casecmp(encoding, "identity") == 0) { + apr_table_setn(r->headers_out, "Content-Encoding", "br"); + } else { + apr_table_mergen(r->headers_out, "Content-Encoding", "br"); + } + + if (r->content_encoding) { + r->content_encoding = apr_table_get(r->headers_out, + "Content-Encoding"); + } + + apr_table_unset(r->headers_out, "Content-Length"); + apr_table_unset(r->headers_out, "Content-MD5"); + + /* https://bz.apache.org/bugzilla/show_bug.cgi?id=39727 + * https://bz.apache.org/bugzilla/show_bug.cgi?id=45023 + * + * ETag must be unique among the possible representations, so a + * change to content-encoding requires a corresponding change to the + * ETag. We make this behavior configurable, and mimic mod_deflate's + * DeflateAlterETag with BrotliAlterETag to keep the transition from + * mod_deflate seamless. + */ + if (conf->etag_mode == ETAG_MODE_REMOVE) { + apr_table_unset(r->headers_out, "ETag"); + } + else if (conf->etag_mode == ETAG_MODE_ADDSUFFIX) { + const char *etag = apr_table_get(r->headers_out, "ETag"); + + if (etag) { + apr_size_t len = strlen(etag); + + if (len > 2 && etag[len - 1] == '"') { + etag = apr_pstrmemdup(r->pool, etag, len - 1); + etag = apr_pstrcat(r->pool, etag, "-br\"", NULL); + apr_table_setn(r->headers_out, "ETag", etag); + } + } + } + + /* For 304 responses, we only need to send out the headers. */ + if (r->status == HTTP_NOT_MODIFIED) { + ap_remove_output_filter(f); + return ap_pass_brigade(f->next, bb); + } + + ctx = create_ctx(conf->quality, conf->lgwin, conf->lgblock, + f->c->bucket_alloc, r->pool); + f->ctx = ctx; + } + + while (!APR_BRIGADE_EMPTY(bb)) { + apr_bucket *e = APR_BRIGADE_FIRST(bb); + + /* Optimization: If we are a HEAD request and bytes_sent is not zero + * it means that we have passed the content-length filter once and + * have more data to send. This means that the content-length filter + * could not determine our content-length for the response to the + * HEAD request anyway (the associated GET request would deliver the + * body in chunked encoding) and we can stop compressing. + */ + if (r->header_only && r->bytes_sent) { + ap_remove_output_filter(f); + return ap_pass_brigade(f->next, bb); + } + + if (APR_BUCKET_IS_EOS(e)) { + rv = flush(ctx, BROTLI_OPERATION_FINISH, f); + if (rv != APR_SUCCESS) { + return rv; + } + + /* Leave notes for logging. */ + if (conf->note_input_name) { + apr_table_setn(r->notes, conf->note_input_name, + apr_off_t_toa(r->pool, ctx->total_in)); + } + if (conf->note_output_name) { + apr_table_setn(r->notes, conf->note_output_name, + apr_off_t_toa(r->pool, ctx->total_out)); + } + if (conf->note_ratio_name) { + if (ctx->total_in > 0) { + int ratio = (int) (ctx->total_out * 100 / ctx->total_in); + + apr_table_setn(r->notes, conf->note_ratio_name, + apr_itoa(r->pool, ratio)); + } + else { + apr_table_setn(r->notes, conf->note_ratio_name, "-"); + } + } + + APR_BUCKET_REMOVE(e); + APR_BRIGADE_INSERT_TAIL(ctx->bb, e); + + rv = ap_pass_brigade(f->next, ctx->bb); + apr_brigade_cleanup(ctx->bb); + apr_pool_cleanup_run(r->pool, ctx, cleanup_ctx); + return rv; + } + else if (APR_BUCKET_IS_FLUSH(e)) { + rv = flush(ctx, BROTLI_OPERATION_FLUSH, f); + if (rv != APR_SUCCESS) { + return rv; + } + + APR_BUCKET_REMOVE(e); + APR_BRIGADE_INSERT_TAIL(ctx->bb, e); + + rv = ap_pass_brigade(f->next, ctx->bb); + apr_brigade_cleanup(ctx->bb); + if (rv != APR_SUCCESS) { + return rv; + } + } + else if (APR_BUCKET_IS_METADATA(e)) { + APR_BUCKET_REMOVE(e); + APR_BRIGADE_INSERT_TAIL(ctx->bb, e); + } + else { + const char *data; + apr_size_t len; + + rv = apr_bucket_read(e, &data, &len, APR_BLOCK_READ); + if (rv != APR_SUCCESS) { + return rv; + } + rv = process_chunk(ctx, data, len, f); + if (rv != APR_SUCCESS) { + return rv; + } + apr_bucket_delete(e); + } + } + return APR_SUCCESS; +} + +static void register_hooks(apr_pool_t *p) +{ + ap_register_output_filter("BROTLI_COMPRESS", compress_filter, NULL, + AP_FTYPE_CONTENT_SET); +} + +static const command_rec cmds[] = { + AP_INIT_TAKE12("BrotliFilterNote", set_filter_note, + NULL, RSRC_CONF, + "Set a note to report on compression ratio"), + AP_INIT_TAKE1("BrotliCompressionQuality", set_compression_quality, + NULL, RSRC_CONF, + "Compression quality between 0 and 11 (higher quality means " + "slower compression)"), + AP_INIT_TAKE1("BrotliCompressionWindow", set_compression_lgwin, + NULL, RSRC_CONF, + "Sliding window size between 10 and 24 (larger windows can " + "improve compression, but require more memory)"), + AP_INIT_TAKE1("BrotliCompressionMaxInputBlock", set_compression_lgblock, + NULL, RSRC_CONF, + "Maximum input block size between 16 and 24 (larger block " + "sizes require more memory)"), + AP_INIT_TAKE1("BrotliAlterETag", set_etag_mode, + NULL, RSRC_CONF, + "Set how mod_brotli should modify ETag response headers: " + "'AddSuffix' (default), 'NoChange', 'Remove'"), + {NULL} +}; + +AP_DECLARE_MODULE(brotli) = { + STANDARD20_MODULE_STUFF, + NULL, /* create per-directory config structure */ + NULL, /* merge per-directory config structures */ + create_server_config, /* create per-server config structure */ + NULL, /* merge per-server config structures */ + cmds, /* command apr_table_t */ + register_hooks /* register hooks */ +}; -- cgit v1.2.3