VladPolskiy/apache-http-server
1
0
Fork 0
mirror of https://github.com/apache/httpd.git synced 2025-08-03 16:33:59 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
trunk
apache-http-server/modules/http2/h2_config.c
Stefan Eissing e1fe1d8505 *) mod_md: update to version 2.0.30 
- Fixed bug in handling over long response headers. When the 64 KB limit
       of nghttp2 was exceeded, the request was not reset and the client was
       left hanging, waiting for it. Now the stream is reset.
     - Added new directive `H2MaxHeaderBlockLen` to set the limit on response
       header sizes.
     - Fixed handling of Timeout vs. KeepAliveTimeout when first request on a
       connection was reset.



git-svn-id: https://svn.apache.org/repos/asf/httpd/httpd/trunk@1924145 13f79535-47bb-0310-9956-ffa450edef68
2025-03-03 12:32:31 +00:00

1105 lines
39 KiB
C
Raw Permalink Blame History

/* 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 <assert.h>
#include <apr_hash.h>
#include <apr_lib.h>
#include <httpd.h>
#include <http_core.h>
#include <http_config.h>
#include <http_log.h>
#include <http_vhost.h>
#include <ap_mpm.h>
#include <apr_strings.h>
#include "h2.h"
#include "h2_conn_ctx.h"
#include "h2_c1.h"
#include "h2_config.h"
#include "h2_protocol.h"
#include "h2_private.h"
#define DEF_VAL (-1)
#define H2_CONFIG_GET(a, b, n) \
(((a)->n == DEF_VAL)? (b) : (a))->n
#define H2_CONFIG_SET(a, n, v) \
((a)->n = v)
#define CONFIG_CMD_SET(cmd,dir,var,val) \
h2_config_seti(((cmd)->path? (dir) : NULL), h2_config_sget((cmd)->server), var, val)
#define CONFIG_CMD_SET64(cmd,dir,var,val) \
h2_config_seti64(((cmd)->path? (dir) : NULL), h2_config_sget((cmd)->server), var, val)
/* Apache httpd module configuration for h2. */
typedef struct h2_config {
const char *name;
int h2_max_streams; /* max concurrent # streams (http2) */
int h2_window_size; /* stream window size (http2) */
int min_workers; /* min # of worker threads/child */
int max_workers; /* max # of worker threads/child */
apr_interval_time_t idle_limit; /* max duration for idle workers */
int stream_max_mem_size; /* max # bytes held in memory/stream */
int h2_direct; /* if mod_h2 is active directly */
int modern_tls_only; /* Accept only modern TLS in HTTP/2 connections */
int h2_upgrade; /* Allow HTTP/1 upgrade to h2/h2c */
apr_int64_t tls_warmup_size; /* Amount of TLS data to send before going full write size */
int tls_cooldown_secs; /* Seconds of idle time before going back to small TLS records */
int h2_push; /* if HTTP/2 server push is enabled */
struct apr_hash_t *priorities; /* map of content-type to h2_priority records */
int push_diary_size; /* # of entries in push diary */
int copy_files; /* if files shall be copied vs setaside on output */
apr_array_header_t *push_list; /* list of h2_push_res configurations */
apr_table_t *early_headers; /* HTTP headers for a 103 response */
int early_hints; /* support status code 103 */
int padding_bits;
int padding_always;
int output_buffered;
apr_interval_time_t stream_timeout;/* beam timeout */
int max_data_frame_len; /* max # bytes in a single h2 DATA frame */
int max_hd_block_len; /* max # bytes in a response header block */
int proxy_requests; /* act as forward proxy */
int h2_websockets; /* if mod_h2 negotiating WebSockets */
} h2_config;
typedef struct h2_dir_config {
const char *name;
int h2_upgrade; /* Allow HTTP/1 upgrade to h2/h2c */
int h2_push; /* if HTTP/2 server push is enabled */
apr_array_header_t *push_list; /* list of h2_push_res configurations */
apr_table_t *early_headers; /* HTTP headers for a 103 response */
int early_hints; /* support status code 103 */
apr_interval_time_t stream_timeout;/* beam timeout */
} h2_dir_config;
static h2_config defconf = {
"default",
100, /* max_streams */
H2_INITIAL_WINDOW_SIZE, /* window_size */
-1, /* min workers */
-1, /* max workers */
apr_time_from_sec(10 * 60), /* workers idle limit */
32 * 1024, /* stream max mem size */
-1, /* h2 direct mode */
1, /* modern TLS only */
-1, /* HTTP/1 Upgrade support */
1024*1024, /* TLS warmup size */
1, /* TLS cooldown secs */
1, /* HTTP/2 server push enabled */
NULL, /* map of content-type to priorities */
256, /* push diary size */
0, /* copy files across threads */
NULL, /* push list */
NULL, /* early headers */
0, /* early hints, http status 103 */
0, /* padding bits */
1, /* padding always */
1, /* stream output buffered */
-1, /* beam timeout */
0, /* max DATA frame len, 0 == no extra limit */
0, /* max header block len, 0 == no extra limit */
0, /* forward proxy */
0, /* WebSockets negotiation, enabled */
};
static h2_dir_config defdconf = {
"default",
-1, /* HTTP/1 Upgrade support */
-1, /* HTTP/2 server push enabled */
NULL, /* push list */
NULL, /* early headers */
-1, /* early hints, http status 103 */
-1, /* beam timeout */
};
void h2_config_init(apr_pool_t *pool)
{
(void)pool;
}
void *h2_config_create_svr(apr_pool_t *pool, server_rec *s)
{
h2_config *conf = (h2_config *)apr_pcalloc(pool, sizeof(h2_config));
char *name = apr_pstrcat(pool, "srv[", s->defn_name, "]", NULL);
conf->name = name;
conf->h2_max_streams = DEF_VAL;
conf->h2_window_size = DEF_VAL;
conf->min_workers = DEF_VAL;
conf->max_workers = DEF_VAL;
conf->idle_limit = DEF_VAL;
conf->stream_max_mem_size = DEF_VAL;
conf->h2_direct = DEF_VAL;
conf->modern_tls_only = DEF_VAL;
conf->h2_upgrade = DEF_VAL;
conf->tls_warmup_size = DEF_VAL;
conf->tls_cooldown_secs = DEF_VAL;
conf->h2_push = DEF_VAL;
conf->priorities = NULL;
conf->push_diary_size = DEF_VAL;
conf->copy_files = DEF_VAL;
conf->push_list = NULL;
conf->early_headers = NULL;
conf->early_hints = DEF_VAL;
conf->padding_bits = DEF_VAL;
conf->padding_always = DEF_VAL;
conf->output_buffered = DEF_VAL;
conf->stream_timeout = DEF_VAL;
conf->max_data_frame_len = DEF_VAL;
conf->max_hd_block_len = DEF_VAL;
conf->proxy_requests = DEF_VAL;
conf->h2_websockets = DEF_VAL;
return conf;
}
static void *h2_config_merge(apr_pool_t *pool, void *basev, void *addv)
{
h2_config *base = (h2_config *)basev;
h2_config *add = (h2_config *)addv;
h2_config *n = (h2_config *)apr_pcalloc(pool, sizeof(h2_config));
char *name = apr_pstrcat(pool, "merged[", add->name, ", ", base->name, "]", NULL);
n->name = name;
n->h2_max_streams = H2_CONFIG_GET(add, base, h2_max_streams);
n->h2_window_size = H2_CONFIG_GET(add, base, h2_window_size);
n->min_workers = H2_CONFIG_GET(add, base, min_workers);
n->max_workers = H2_CONFIG_GET(add, base, max_workers);
n->idle_limit = H2_CONFIG_GET(add, base, idle_limit);
n->stream_max_mem_size = H2_CONFIG_GET(add, base, stream_max_mem_size);
n->h2_direct = H2_CONFIG_GET(add, base, h2_direct);
n->modern_tls_only = H2_CONFIG_GET(add, base, modern_tls_only);
n->h2_upgrade = H2_CONFIG_GET(add, base, h2_upgrade);
n->tls_warmup_size = H2_CONFIG_GET(add, base, tls_warmup_size);
n->tls_cooldown_secs = H2_CONFIG_GET(add, base, tls_cooldown_secs);
n->h2_push = H2_CONFIG_GET(add, base, h2_push);
if (add->priorities && base->priorities) {
n->priorities = apr_hash_overlay(pool, add->priorities, base->priorities);
}
else {
n->priorities = add->priorities? add->priorities : base->priorities;
}
n->push_diary_size = H2_CONFIG_GET(add, base, push_diary_size);
n->copy_files = H2_CONFIG_GET(add, base, copy_files);
n->output_buffered = H2_CONFIG_GET(add, base, output_buffered);
if (add->push_list && base->push_list) {
n->push_list = apr_array_append(pool, base->push_list, add->push_list);
}
else {
n->push_list = add->push_list? add->push_list : base->push_list;
}
if (add->early_headers && base->early_headers) {
n->early_headers = apr_table_overlay(pool, add->early_headers, base->early_headers);
}
else {
n->early_headers = add->early_headers? add->early_headers : base->early_headers;
}
n->early_hints = H2_CONFIG_GET(add, base, early_hints);
n->padding_bits = H2_CONFIG_GET(add, base, padding_bits);
n->padding_always = H2_CONFIG_GET(add, base, padding_always);
n->stream_timeout = H2_CONFIG_GET(add, base, stream_timeout);
n->max_data_frame_len = H2_CONFIG_GET(add, base, max_data_frame_len);
n->max_hd_block_len = H2_CONFIG_GET(add, base, max_hd_block_len);
n->proxy_requests = H2_CONFIG_GET(add, base, proxy_requests);
n->h2_websockets = H2_CONFIG_GET(add, base, h2_websockets);
return n;
}
void *h2_config_merge_svr(apr_pool_t *pool, void *basev, void *addv)
{
return h2_config_merge(pool, basev, addv);
}
void *h2_config_create_dir(apr_pool_t *pool, char *x)
{
h2_dir_config *conf = (h2_dir_config *)apr_pcalloc(pool, sizeof(h2_dir_config));
const char *s = x? x : "unknown";
char *name = apr_pstrcat(pool, "dir[", s, "]", NULL);
conf->name = name;
conf->h2_upgrade = DEF_VAL;
conf->h2_push = DEF_VAL;
conf->early_hints = DEF_VAL;
conf->stream_timeout = DEF_VAL;
return conf;
}
void *h2_config_merge_dir(apr_pool_t *pool, void *basev, void *addv)
{
h2_dir_config *base = (h2_dir_config *)basev;
h2_dir_config *add = (h2_dir_config *)addv;
h2_dir_config *n = (h2_dir_config *)apr_pcalloc(pool, sizeof(h2_dir_config));
n->name = apr_pstrcat(pool, "merged[", add->name, ", ", base->name, "]", NULL);
n->h2_upgrade = H2_CONFIG_GET(add, base, h2_upgrade);
n->h2_push = H2_CONFIG_GET(add, base, h2_push);
if (add->push_list && base->push_list) {
n->push_list = apr_array_append(pool, base->push_list, add->push_list);
}
else {
n->push_list = add->push_list? add->push_list : base->push_list;
}
if (add->early_headers && base->early_headers) {
n->early_headers = apr_table_overlay(pool, add->early_headers, base->early_headers);
}
else {
n->early_headers = add->early_headers? add->early_headers : base->early_headers;
}
n->early_hints = H2_CONFIG_GET(add, base, early_hints);
n->stream_timeout = H2_CONFIG_GET(add, base, stream_timeout);
return n;
}
static apr_int64_t h2_srv_config_geti64(const h2_config *conf, h2_config_var_t var)
{
switch(var) {
case H2_CONF_MAX_STREAMS:
return H2_CONFIG_GET(conf, &defconf, h2_max_streams);
case H2_CONF_WIN_SIZE:
return H2_CONFIG_GET(conf, &defconf, h2_window_size);
case H2_CONF_MIN_WORKERS:
return H2_CONFIG_GET(conf, &defconf, min_workers);
case H2_CONF_MAX_WORKERS:
return H2_CONFIG_GET(conf, &defconf, max_workers);
case H2_CONF_MAX_WORKER_IDLE_LIMIT:
return H2_CONFIG_GET(conf, &defconf, idle_limit);
case H2_CONF_STREAM_MAX_MEM:
return H2_CONFIG_GET(conf, &defconf, stream_max_mem_size);
case H2_CONF_MODERN_TLS_ONLY:
return H2_CONFIG_GET(conf, &defconf, modern_tls_only);
case H2_CONF_UPGRADE:
return H2_CONFIG_GET(conf, &defconf, h2_upgrade);
case H2_CONF_DIRECT:
return H2_CONFIG_GET(conf, &defconf, h2_direct);
case H2_CONF_TLS_WARMUP_SIZE:
return H2_CONFIG_GET(conf, &defconf, tls_warmup_size);
case H2_CONF_TLS_COOLDOWN_SECS:
return H2_CONFIG_GET(conf, &defconf, tls_cooldown_secs);
case H2_CONF_PUSH:
return H2_CONFIG_GET(conf, &defconf, h2_push);
case H2_CONF_PUSH_DIARY_SIZE:
return H2_CONFIG_GET(conf, &defconf, push_diary_size);
case H2_CONF_COPY_FILES:
return H2_CONFIG_GET(conf, &defconf, copy_files);
case H2_CONF_EARLY_HINTS:
return H2_CONFIG_GET(conf, &defconf, early_hints);
case H2_CONF_PADDING_BITS:
return H2_CONFIG_GET(conf, &defconf, padding_bits);
case H2_CONF_PADDING_ALWAYS:
return H2_CONFIG_GET(conf, &defconf, padding_always);
case H2_CONF_OUTPUT_BUFFER:
return H2_CONFIG_GET(conf, &defconf, output_buffered);
case H2_CONF_STREAM_TIMEOUT:
return H2_CONFIG_GET(conf, &defconf, stream_timeout);
case H2_CONF_MAX_DATA_FRAME_LEN:
return H2_CONFIG_GET(conf, &defconf, max_data_frame_len);
case H2_CONF_PROXY_REQUESTS:
return H2_CONFIG_GET(conf, &defconf, proxy_requests);
case H2_CONF_WEBSOCKETS:
return H2_CONFIG_GET(conf, &defconf, h2_websockets);
case H2_CONF_MAX_HEADER_BLOCK_LEN:
return H2_CONFIG_GET(conf, &defconf, max_hd_block_len);
default:
return DEF_VAL;
}
}
static void h2_srv_config_seti(h2_config *conf, h2_config_var_t var, int val)
{
switch(var) {
case H2_CONF_MAX_STREAMS:
H2_CONFIG_SET(conf, h2_max_streams, val);
break;
case H2_CONF_WIN_SIZE:
H2_CONFIG_SET(conf, h2_window_size, val);
break;
case H2_CONF_MIN_WORKERS:
H2_CONFIG_SET(conf, min_workers, val);
break;
case H2_CONF_MAX_WORKERS:
H2_CONFIG_SET(conf, max_workers, val);
break;
case H2_CONF_STREAM_MAX_MEM:
H2_CONFIG_SET(conf, stream_max_mem_size, val);
break;
case H2_CONF_MODERN_TLS_ONLY:
H2_CONFIG_SET(conf, modern_tls_only, val);
break;
case H2_CONF_UPGRADE:
H2_CONFIG_SET(conf, h2_upgrade, val);
break;
case H2_CONF_DIRECT:
H2_CONFIG_SET(conf, h2_direct, val);
break;
case H2_CONF_TLS_WARMUP_SIZE:
H2_CONFIG_SET(conf, tls_warmup_size, val);
break;
case H2_CONF_TLS_COOLDOWN_SECS:
H2_CONFIG_SET(conf, tls_cooldown_secs, val);
break;
case H2_CONF_PUSH:
H2_CONFIG_SET(conf, h2_push, val);
break;
case H2_CONF_PUSH_DIARY_SIZE:
H2_CONFIG_SET(conf, push_diary_size, val);
break;
case H2_CONF_COPY_FILES:
H2_CONFIG_SET(conf, copy_files, val);
break;
case H2_CONF_EARLY_HINTS:
H2_CONFIG_SET(conf, early_hints, val);
break;
case H2_CONF_PADDING_BITS:
H2_CONFIG_SET(conf, padding_bits, val);
break;
case H2_CONF_PADDING_ALWAYS:
H2_CONFIG_SET(conf, padding_always, val);
break;
case H2_CONF_OUTPUT_BUFFER:
H2_CONFIG_SET(conf, output_buffered, val);
break;
case H2_CONF_MAX_DATA_FRAME_LEN:
H2_CONFIG_SET(conf, max_data_frame_len, val);
break;
case H2_CONF_PROXY_REQUESTS:
H2_CONFIG_SET(conf, proxy_requests, val);
break;
case H2_CONF_WEBSOCKETS:
H2_CONFIG_SET(conf, h2_websockets, val);
break;
case H2_CONF_MAX_HEADER_BLOCK_LEN:
H2_CONFIG_SET(conf, max_hd_block_len, val);
default:
break;
}
}
static void h2_srv_config_seti64(h2_config *conf, h2_config_var_t var, apr_int64_t val)
{
switch(var) {
case H2_CONF_TLS_WARMUP_SIZE:
H2_CONFIG_SET(conf, tls_warmup_size, val);
break;
case H2_CONF_STREAM_TIMEOUT:
H2_CONFIG_SET(conf, stream_timeout, val);
break;
case H2_CONF_MAX_WORKER_IDLE_LIMIT:
H2_CONFIG_SET(conf, idle_limit, val);
break;
default:
h2_srv_config_seti(conf, var, (int)val);
break;
}
}
static h2_config *h2_config_sget(server_rec *s)
{
h2_config *cfg = (h2_config *)ap_get_module_config(s->module_config,
&http2_module);
ap_assert(cfg);
return cfg;
}
static const h2_dir_config *h2_config_rget(request_rec *r)
{
h2_dir_config *cfg = (h2_dir_config *)ap_get_module_config(r->per_dir_config,
&http2_module);
ap_assert(cfg);
return cfg;
}
static apr_int64_t h2_dir_config_geti64(const h2_dir_config *conf, h2_config_var_t var)
{
switch(var) {
case H2_CONF_UPGRADE:
return H2_CONFIG_GET(conf, &defdconf, h2_upgrade);
case H2_CONF_PUSH:
return H2_CONFIG_GET(conf, &defdconf, h2_push);
case H2_CONF_EARLY_HINTS:
return H2_CONFIG_GET(conf, &defdconf, early_hints);
case H2_CONF_STREAM_TIMEOUT:
return H2_CONFIG_GET(conf, &defdconf, stream_timeout);
default:
return DEF_VAL;
}
}
static void h2_config_seti(h2_dir_config *dconf, h2_config *conf, h2_config_var_t var, int val)
{
int set_srv = !dconf;
if (dconf) {
switch(var) {
case H2_CONF_UPGRADE:
H2_CONFIG_SET(dconf, h2_upgrade, val);
break;
case H2_CONF_PUSH:
H2_CONFIG_SET(dconf, h2_push, val);
break;
case H2_CONF_EARLY_HINTS:
H2_CONFIG_SET(dconf, early_hints, val);
break;
default:
/* not handled in dir_conf */
set_srv = 1;
break;
}
}
if (set_srv) {
h2_srv_config_seti(conf, var, val);
}
}
static void h2_config_seti64(h2_dir_config *dconf, h2_config *conf, h2_config_var_t var, apr_int64_t val)
{
int set_srv = !dconf;
if (dconf) {
switch(var) {
case H2_CONF_STREAM_TIMEOUT:
H2_CONFIG_SET(dconf, stream_timeout, val);
break;
default:
/* not handled in dir_conf */
set_srv = 1;
break;
}
}
if (set_srv) {
h2_srv_config_seti64(conf, var, val);
}
}
static const h2_config *h2_config_get(conn_rec *c)
{
h2_conn_ctx_t *conn_ctx = h2_conn_ctx_get(c);
if (conn_ctx && conn_ctx->server) {
return h2_config_sget(conn_ctx->server);
}
return h2_config_sget(c->base_server);
}
int h2_config_cgeti(conn_rec *c, h2_config_var_t var)
{
return (int)h2_srv_config_geti64(h2_config_get(c), var);
}
apr_int64_t h2_config_cgeti64(conn_rec *c, h2_config_var_t var)
{
return h2_srv_config_geti64(h2_config_get(c), var);
}
int h2_config_sgeti(server_rec *s, h2_config_var_t var)
{
return (int)h2_srv_config_geti64(h2_config_sget(s), var);
}
apr_int64_t h2_config_sgeti64(server_rec *s, h2_config_var_t var)
{
return h2_srv_config_geti64(h2_config_sget(s), var);
}
int h2_config_geti(request_rec *r, server_rec *s, h2_config_var_t var)
{
return (int)h2_config_geti64(r, s, var);
}
apr_int64_t h2_config_geti64(request_rec *r, server_rec *s, h2_config_var_t var)
{
apr_int64_t mode = r? (int)h2_dir_config_geti64(h2_config_rget(r), var) : DEF_VAL;
return (mode != DEF_VAL)? mode : h2_config_sgeti64(s, var);
}
int h2_config_rgeti(request_rec *r, h2_config_var_t var)
{
return h2_config_geti(r, r->server, var);
}
apr_int64_t h2_config_rgeti64(request_rec *r, h2_config_var_t var)
{
return h2_config_geti64(r, r->server, var);
}
apr_array_header_t *h2_config_push_list(request_rec *r)
{
const h2_config *sconf;
const h2_dir_config *conf = h2_config_rget(r);
if (conf && conf->push_list) {
return conf->push_list;
}
sconf = h2_config_sget(r->server);
return sconf? sconf->push_list : NULL;
}
apr_table_t *h2_config_early_headers(request_rec *r)
{
const h2_config *sconf;
const h2_dir_config *conf = h2_config_rget(r);
if (conf && conf->early_headers) {
return conf->early_headers;
}
sconf = h2_config_sget(r->server);
return sconf? sconf->early_headers : NULL;
}
const struct h2_priority *h2_cconfig_get_priority(conn_rec *c, const char *content_type)
{
const h2_config *conf = h2_config_get(c);
if (content_type && conf->priorities) {
apr_ssize_t len = (apr_ssize_t)strcspn(content_type, "; \t");
h2_priority *prio = apr_hash_get(conf->priorities, content_type, len);
return prio? prio : apr_hash_get(conf->priorities, "*", 1);
}
return NULL;
}
static const char *h2_conf_set_max_streams(cmd_parms *cmd,
void *dirconf, const char *value)
{
apr_int64_t ival = (int)apr_atoi64(value);
if (ival < 1) {
return "value must be > 0";
}
CONFIG_CMD_SET64(cmd, dirconf, H2_CONF_MAX_STREAMS, ival);
return NULL;
}
static const char *h2_conf_set_window_size(cmd_parms *cmd,
void *dirconf, const char *value)
{
int val = (int)apr_atoi64(value);
if (val < 1024) {
return "value must be >= 1024";
}
CONFIG_CMD_SET(cmd, dirconf, H2_CONF_WIN_SIZE, val);
return NULL;
}
static const char *h2_conf_set_min_workers(cmd_parms *cmd,
void *dirconf, const char *value)
{
int val = (int)apr_atoi64(value);
if (val < 1) {
return "value must be > 0";
}
CONFIG_CMD_SET(cmd, dirconf, H2_CONF_MIN_WORKERS, val);
return NULL;
}
static const char *h2_conf_set_max_workers(cmd_parms *cmd,
void *dirconf, const char *value)
{
int val = (int)apr_atoi64(value);
if (val < 1) {
return "value must be > 0";
}
CONFIG_CMD_SET(cmd, dirconf, H2_CONF_MAX_WORKERS, val);
return NULL;
}
static const char *h2_conf_set_max_worker_idle_limit(cmd_parms *cmd,
void *dirconf, const char *value)
{
apr_interval_time_t timeout;
apr_status_t rv = ap_timeout_parameter_parse(value, &timeout, "s");
if (rv != APR_SUCCESS) {
return "Invalid idle limit value";
}
if (timeout <= 0) {
timeout = DEF_VAL;
}
CONFIG_CMD_SET64(cmd, dirconf, H2_CONF_MAX_WORKER_IDLE_LIMIT, timeout);
return NULL;
}
static const char *h2_conf_set_stream_max_mem_size(cmd_parms *cmd,
void *dirconf, const char *value)
{
int val = (int)apr_atoi64(value);
if (val < 1024) {
return "value must be >= 1024";
}
CONFIG_CMD_SET(cmd, dirconf, H2_CONF_STREAM_MAX_MEM, val);
return NULL;
}
static const char *h2_conf_set_max_data_frame_len(cmd_parms *cmd,
void *dirconf, const char *value)
{
int val = (int)apr_atoi64(value);
if (val < 0) {
return "value must be 0 or larger";
}
CONFIG_CMD_SET(cmd, dirconf, H2_CONF_MAX_DATA_FRAME_LEN, val);
return NULL;
}
static const char *h2_conf_set_max_hd_block_len(cmd_parms *cmd,
void *dirconf, const char *value)
{
int val = (int)apr_atoi64(value);
if (val < 0) {
return "value must be 0 or larger";
}
CONFIG_CMD_SET(cmd, dirconf, H2_CONF_MAX_HEADER_BLOCK_LEN, val);
return NULL;
}
static const char *h2_conf_set_session_extra_files(cmd_parms *cmd,
void *dirconf, const char *value)
{
/* deprecated, ignore */
(void)dirconf;
(void)value;
ap_log_perror(APLOG_MARK, APLOG_WARNING, 0, cmd->pool, /* NO LOGNO */
"H2SessionExtraFiles is obsolete and will be ignored");
return NULL;
}
static const char *h2_conf_set_serialize_headers(cmd_parms *parms,
void *dirconf, const char *value)
{
if (!strcasecmp(value, "On")) {
ap_log_error(APLOG_MARK, APLOG_WARNING, 0, parms->server, APLOGNO(10307)
"%s: this feature has been disabled and the directive "
"to enable it is ignored.", parms->cmd->name);
}
return NULL;
}
static const char *h2_conf_set_direct(cmd_parms *cmd,
void *dirconf, const char *value)
{
if (!strcasecmp(value, "On")) {
CONFIG_CMD_SET(cmd, dirconf, H2_CONF_DIRECT, 1);
return NULL;
}
else if (!strcasecmp(value, "Off")) {
CONFIG_CMD_SET(cmd, dirconf, H2_CONF_DIRECT, 0);
return NULL;
}
return "value must be On or Off";
}
static const char *h2_conf_set_push(cmd_parms *cmd, void *dirconf, const char *value)
{
if (!strcasecmp(value, "On")) {
CONFIG_CMD_SET(cmd, dirconf, H2_CONF_PUSH, 1);
return NULL;
}
else if (!strcasecmp(value, "Off")) {
CONFIG_CMD_SET(cmd, dirconf, H2_CONF_PUSH, 0);
return NULL;
}
return "value must be On or Off";
}
static const char *h2_conf_set_websockets(cmd_parms *cmd,
void *dirconf, const char *value)
{
if (!strcasecmp(value, "On")) {
#if H2_USE_WEBSOCKETS
CONFIG_CMD_SET(cmd, dirconf, H2_CONF_WEBSOCKETS, 1);
return NULL;
#elif !H2_USE_PIPES
return "HTTP/2 WebSockets are not supported on this platform";
#else
return "HTTP/2 WebSockets are not supported in this server version";
#endif
}
else if (!strcasecmp(value, "Off")) {
CONFIG_CMD_SET(cmd, dirconf, H2_CONF_WEBSOCKETS, 0);
return NULL;
}
return "value must be On or Off";
}
static const char *h2_conf_add_push_priority(cmd_parms *cmd, void *_cfg,
const char *ctype, const char *sdependency,
const char *sweight)
{
h2_config *cfg = (h2_config *)h2_config_sget(cmd->server);
const char *sdefweight = "16"; /* default AFTER weight */
h2_dependency dependency;
h2_priority *priority;
int weight;
(void)_cfg;
if (!*ctype) {
return "1st argument must be a mime-type, like 'text/css' or '*'";
}
if (!sweight) {
/* 2 args only, but which one? */
if (apr_isdigit(sdependency[0])) {
sweight = sdependency;
sdependency = "AFTER"; /* default dependency */
}
}
if (!strcasecmp("AFTER", sdependency)) {
dependency = H2_DEPENDANT_AFTER;
}
else if (!strcasecmp("BEFORE", sdependency)) {
dependency = H2_DEPENDANT_BEFORE;
if (sweight) {
return "dependency 'Before' does not allow a weight";
}
}
else if (!strcasecmp("INTERLEAVED", sdependency)) {
dependency = H2_DEPENDANT_INTERLEAVED;
sdefweight = "256"; /* default INTERLEAVED weight */
}
else {
return "dependency must be one of 'After', 'Before' or 'Interleaved'";
}
weight = (int)apr_atoi64(sweight? sweight : sdefweight);
if (weight < NGHTTP2_MIN_WEIGHT) {
return apr_psprintf(cmd->pool, "weight must be a number >= %d",
NGHTTP2_MIN_WEIGHT);
}
priority = apr_pcalloc(cmd->pool, sizeof(*priority));
priority->dependency = dependency;
priority->weight = weight;
if (!cfg->priorities) {
cfg->priorities = apr_hash_make(cmd->pool);
}
apr_hash_set(cfg->priorities, ctype, (apr_ssize_t)strlen(ctype), priority);
return NULL;
}
static const char *h2_conf_set_modern_tls_only(cmd_parms *cmd,
void *dirconf, const char *value)
{
if (!strcasecmp(value, "On")) {
CONFIG_CMD_SET(cmd, dirconf, H2_CONF_MODERN_TLS_ONLY, 1);
return NULL;
}
else if (!strcasecmp(value, "Off")) {
CONFIG_CMD_SET(cmd, dirconf, H2_CONF_MODERN_TLS_ONLY, 0);
return NULL;
}
return "value must be On or Off";
}
static const char *h2_conf_set_upgrade(cmd_parms *cmd,
void *dirconf, const char *value)
{
if (!strcasecmp(value, "On")) {
CONFIG_CMD_SET(cmd, dirconf, H2_CONF_UPGRADE, 1);
return NULL;
}
else if (!strcasecmp(value, "Off")) {
CONFIG_CMD_SET(cmd, dirconf, H2_CONF_UPGRADE, 0);
return NULL;
}
return "value must be On or Off";
}
static const char *h2_conf_set_tls_warmup_size(cmd_parms *cmd,
void *dirconf, const char *value)
{
apr_int64_t val = apr_atoi64(value);
CONFIG_CMD_SET64(cmd, dirconf, H2_CONF_TLS_WARMUP_SIZE, val);
return NULL;
}
static const char *h2_conf_set_tls_cooldown_secs(cmd_parms *cmd,
void *dirconf, const char *value)
{
apr_int64_t val = (int)apr_atoi64(value);
CONFIG_CMD_SET64(cmd, dirconf, H2_CONF_TLS_COOLDOWN_SECS, val);
return NULL;
}
static const char *h2_conf_set_push_diary_size(cmd_parms *cmd,
void *dirconf, const char *value)
{
int val = (int)apr_atoi64(value);
if (val < 0) {
return "value must be >= 0";
}
if (val > 0 && (val & (val-1))) {
return "value must a power of 2";
}
if (val > (1 << 15)) {
return "value must <= 65536";
}
CONFIG_CMD_SET(cmd, dirconf, H2_CONF_PUSH_DIARY_SIZE, val);
return NULL;
}
static const char *h2_conf_set_copy_files(cmd_parms *cmd,
void *dirconf, const char *value)
{
if (!strcasecmp(value, "On")) {
CONFIG_CMD_SET(cmd, dirconf, H2_CONF_COPY_FILES, 1);
return NULL;
}
else if (!strcasecmp(value, "Off")) {
CONFIG_CMD_SET(cmd, dirconf, H2_CONF_COPY_FILES, 0);
return NULL;
}
return "value must be On or Off";
}
static void add_push(apr_array_header_t **plist, apr_pool_t *pool, h2_push_res *push)
{
h2_push_res *new;
if (!*plist) {
*plist = apr_array_make(pool, 10, sizeof(*push));
}
new = apr_array_push(*plist);
new->uri_ref = push->uri_ref;
new->critical = push->critical;
}
static const char *h2_conf_add_push_res(cmd_parms *cmd, void *dirconf,
const char *arg1, const char *arg2,
const char *arg3)
{
h2_push_res push;
const char *last = arg3;
memset(&push, 0, sizeof(push));
if (!strcasecmp("add", arg1)) {
push.uri_ref = arg2;
}
else {
push.uri_ref = arg1;
last = arg2;
if (arg3) {
return "too many parameter";
}
}
if (last) {
if (!strcasecmp("critical", last)) {
push.critical = 1;
}
else {
return "unknown last parameter";
}
}
if (cmd->path) {
add_push(&(((h2_dir_config*)dirconf)->push_list), cmd->pool, &push);
}
else {
add_push(&(h2_config_sget(cmd->server)->push_list), cmd->pool, &push);
}
return NULL;
}
static const char *h2_conf_add_early_hint(cmd_parms *cmd, void *dirconf,
const char *name, const char *value)
{
apr_table_t *hds, **phds;
if(!name || !*name)
return "Early Hint header name must not be empty";
if(!value)
return "Early Hint header value must not be empty";
while (apr_isspace(*value))
++value;
if(!*value)
return "Early Hint header value must not be empty/only space";
if (*ap_scan_http_field_content(value))
return "Early Hint header value contains invalid characters";
if (cmd->path) {
phds = &((h2_dir_config*)dirconf)->early_headers;
}
else {
phds = &(h2_config_sget(cmd->server))->early_headers;
}
hds = *phds;
if (!hds) {
*phds = hds = apr_table_make(cmd->pool, 10);
}
apr_table_add(hds, name, value);
return NULL;
}
static const char *h2_conf_set_early_hints(cmd_parms *cmd,
void *dirconf, const char *value)
{
int val;
if (!strcasecmp(value, "On")) val = 1;
else if (!strcasecmp(value, "Off")) val = 0;
else return "value must be On or Off";
CONFIG_CMD_SET(cmd, dirconf, H2_CONF_EARLY_HINTS, val);
if (cmd->path) {
ap_log_perror(APLOG_MARK, APLOG_WARNING, 0, cmd->pool,
"H2EarlyHints = %d on path %s", val, cmd->path);
}
return NULL;
}
static const char *h2_conf_set_padding(cmd_parms *cmd, void *dirconf, const char *value)
{
int val;
val = (int)apr_atoi64(value);
if (val < 0) {
return "number of bits must be >= 0";
}
if (val > 8) {
return "number of bits must be <= 8";
}
CONFIG_CMD_SET(cmd, dirconf, H2_CONF_PADDING_BITS, val);
return NULL;
}
static const char *h2_conf_set_output_buffer(cmd_parms *cmd,
void *dirconf, const char *value)
{
if (!strcasecmp(value, "On")) {
CONFIG_CMD_SET(cmd, dirconf, H2_CONF_OUTPUT_BUFFER, 1);
return NULL;
}
else if (!strcasecmp(value, "Off")) {
CONFIG_CMD_SET(cmd, dirconf, H2_CONF_OUTPUT_BUFFER, 0);
return NULL;
}
return "value must be On or Off";
}
static const char *h2_conf_set_stream_timeout(cmd_parms *cmd,
void *dirconf, const char *value)
{
apr_status_t rv;
apr_interval_time_t timeout;
rv = ap_timeout_parameter_parse(value, &timeout, "s");
if (rv != APR_SUCCESS) {
return "Invalid timeout value";
}
CONFIG_CMD_SET64(cmd, dirconf, H2_CONF_STREAM_TIMEOUT, timeout);
return NULL;
}
static const char *h2_conf_set_proxy_requests(cmd_parms *cmd,
void *dirconf, const char *value)
{
if (!strcasecmp(value, "On")) {
CONFIG_CMD_SET(cmd, dirconf, H2_CONF_PROXY_REQUESTS, 1);
return NULL;
}
else if (!strcasecmp(value, "Off")) {
CONFIG_CMD_SET(cmd, dirconf, H2_CONF_PROXY_REQUESTS, 0);
return NULL;
}
return "value must be On or Off";
}
void h2_get_workers_config(server_rec *s, int *pminw, int *pmaxw,
apr_time_t *pidle_limit)
{
int threads_per_child = 0;
*pminw = h2_config_sgeti(s, H2_CONF_MIN_WORKERS);
*pmaxw = h2_config_sgeti(s, H2_CONF_MAX_WORKERS);
ap_mpm_query(AP_MPMQ_MAX_THREADS, &threads_per_child);
if (*pminw <= 0) {
*pminw = threads_per_child;
}
if (*pmaxw <= 0) {
*pmaxw = H2MAX(4, 3 * (*pminw) / 2);
}
*pidle_limit = h2_config_sgeti64(s, H2_CONF_MAX_WORKER_IDLE_LIMIT);
}
#define AP_END_CMD AP_INIT_TAKE1(NULL, NULL, NULL, RSRC_CONF, NULL)
const command_rec h2_cmds[] = {
AP_INIT_TAKE1("H2MaxSessionStreams", h2_conf_set_max_streams, NULL,
RSRC_CONF, "maximum number of open streams per session"),
AP_INIT_TAKE1("H2WindowSize", h2_conf_set_window_size, NULL,
RSRC_CONF, "window size on client DATA"),
AP_INIT_TAKE1("H2MinWorkers", h2_conf_set_min_workers, NULL,
RSRC_CONF, "minimum number of worker threads per child"),
AP_INIT_TAKE1("H2MaxWorkers", h2_conf_set_max_workers, NULL,
RSRC_CONF, "maximum number of worker threads per child"),
AP_INIT_TAKE1("H2MaxWorkerIdleSeconds", h2_conf_set_max_worker_idle_limit, NULL,
RSRC_CONF, "maximum number of idle seconds before a worker shuts down"),
AP_INIT_TAKE1("H2StreamMaxMemSize", h2_conf_set_stream_max_mem_size, NULL,
RSRC_CONF, "maximum number of bytes buffered in memory for a stream"),
AP_INIT_TAKE1("H2SerializeHeaders", h2_conf_set_serialize_headers, NULL,
RSRC_CONF, "disabled, this directive has no longer an effect."),
AP_INIT_TAKE1("H2ModernTLSOnly", h2_conf_set_modern_tls_only, NULL,
RSRC_CONF, "off to not impose RFC 7540 restrictions on TLS"),
AP_INIT_TAKE1("H2Upgrade", h2_conf_set_upgrade, NULL,
RSRC_CONF|OR_AUTHCFG, "on to allow HTTP/1 Upgrades to h2/h2c"),
AP_INIT_TAKE1("H2Direct", h2_conf_set_direct, NULL,
RSRC_CONF, "on to enable direct HTTP/2 mode"),
AP_INIT_TAKE1("H2SessionExtraFiles", h2_conf_set_session_extra_files, NULL,
RSRC_CONF, "number of extra file a session might keep open (obsolete)"),
AP_INIT_TAKE1("H2TLSWarmUpSize", h2_conf_set_tls_warmup_size, NULL,
RSRC_CONF, "number of bytes on TLS connection before doing max writes"),
AP_INIT_TAKE1("H2TLSCoolDownSecs", h2_conf_set_tls_cooldown_secs, NULL,
RSRC_CONF, "seconds of idle time on TLS before shrinking writes"),
AP_INIT_TAKE1("H2Push", h2_conf_set_push, NULL,
RSRC_CONF|OR_AUTHCFG, "off to disable HTTP/2 server push"),
AP_INIT_TAKE23("H2PushPriority", h2_conf_add_push_priority, NULL,
RSRC_CONF, "define priority of PUSHed resources per content type"),
AP_INIT_TAKE1("H2PushDiarySize", h2_conf_set_push_diary_size, NULL,
RSRC_CONF, "size of push diary"),
AP_INIT_TAKE1("H2CopyFiles", h2_conf_set_copy_files, NULL,
OR_FILEINFO, "on to perform copy of file data"),
AP_INIT_TAKE123("H2PushResource", h2_conf_add_push_res, NULL,
OR_FILEINFO|OR_AUTHCFG, "add a resource to be pushed in this location/on this server."),
AP_INIT_TAKE1("H2EarlyHints", h2_conf_set_early_hints, NULL,
RSRC_CONF, "on to enable interim status 103 responses"),
AP_INIT_TAKE1("H2Padding", h2_conf_set_padding, NULL,
RSRC_CONF, "set payload padding"),
AP_INIT_TAKE1("H2OutputBuffering", h2_conf_set_output_buffer, NULL,
RSRC_CONF, "set stream output buffer on/off"),
AP_INIT_TAKE1("H2StreamTimeout", h2_conf_set_stream_timeout, NULL,
RSRC_CONF, "set stream timeout"),
AP_INIT_TAKE1("H2MaxDataFrameLen", h2_conf_set_max_data_frame_len, NULL,
RSRC_CONF, "maximum number of bytes in a single HTTP/2 DATA frame"),
AP_INIT_TAKE1("H2MaxHeaderBlockLen", h2_conf_set_max_hd_block_len, NULL,
RSRC_CONF, "maximum number of bytes in a response header block"),
AP_INIT_TAKE2("H2EarlyHint", h2_conf_add_early_hint, NULL,
OR_FILEINFO|OR_AUTHCFG, "add a a 'Link:' header for a 103 Early Hints response."),
AP_INIT_TAKE1("H2ProxyRequests", h2_conf_set_proxy_requests, NULL,
OR_FILEINFO, "Enables forward proxy requests via HTTP/2"),
AP_INIT_TAKE1("H2WebSockets", h2_conf_set_websockets, NULL,
RSRC_CONF, "off to disable WebSockets over HTTP/2"),
AP_END_CMD
};
Reference in New Issue View Git Blame Copy Permalink