Commit 9889a8bf authored by Yann Ylavic's avatar Yann Ylavic
Browse files

Merge r1804096, r1807238, r1809981, r1810088, r1810089 from trunk: 

bumping version, removing some unused code, fixes in base64url from mod_md

On the trunk:

  *) mod_http2: DoS flow control protection is less agressive as long as active tasks stay
     below worker capacity. Intended to fix problems with media streaming. 


On the trunk:
mod_http2: v0.10.12, removed optimization for mutex handling in bucket beams that could lead to assertion failure in edge cases.


reverting r1807238 bc not addressing the issue https://github.com/icing/mod_h2/issues/120

mod_http2: non-dev 1.10.12 for backport


Submitted by: icing
Reviewed by: icing, steffenal, ylavic


git-svn-id: https://svn.apache.org/repos/asf/httpd/httpd/branches/2.4.x@1812081 13f79535-47bb-0310-9956-ffa450edef68
parent b653de9e

CHANGES

+4 −0
Original line number Diff line number Diff line 
                                                         -*- coding: utf-8 -*-

Changes with Apache 2.4.29



  *) mod_http2: v0.10.12, removed optimization for mutex handling in bucket

     beams that could lead to assertion failure in edge cases.

     [Stefan Eissing] 



  *) mod_proxy: Fix regression for non decimal loadfactor parameter introduced

     in 2.4.28.  [Jim Jagielski]

STATUS

+0 −4
Original line number Diff line number Diff line
@@ -128,10 +128,6 @@ RELEASE SHOWSTOPPERS: 
PATCHES ACCEPTED TO BACKPORT FROM TRUNK:

  [ start all new proposals below, under PATCHES PROPOSED. ]



   *) mod_http2: Fix race condition on request body handling.

      2.4.x patch: svn merge -c 1804096,1807238,1809981,1810088,1810089 ^/httpd/httpd/trunk .

      +1: icing, steffenal, ylavic



   *) mod_rewrite,core: Avoid the 'Vary: Host' response header when HTTP_HOST

                        is used in a condition that evaluates to true.

      trunk patch: http://svn.apache.org/r1808746

modules/http2/h2_bucket_beam.c

+4 −37
Original line number Diff line number Diff line
@@ -210,16 +210,7 @@ static apr_status_t mutex_enter(void *ctx, h2_beam_lock *pbl) 


static apr_status_t enter_yellow(h2_bucket_beam *beam, h2_beam_lock *pbl)

{

    h2_beam_mutex_enter *enter = beam->m_enter;

    if (enter) {

        void *ctx = beam->m_ctx;

        if (ctx) {

            return enter(ctx, pbl);

        }

    }

    pbl->mutex = NULL;

    pbl->leave = NULL;

    return APR_SUCCESS;

    return mutex_enter(beam, pbl);

}



static void leave_yellow(h2_bucket_beam *beam, h2_beam_lock *pbl)
@@ -568,13 +559,12 @@ static apr_status_t beam_cleanup(void *data) 
{

    h2_bucket_beam *beam = data;

    apr_status_t status = APR_SUCCESS;

    int safe_send = !beam->m_enter || (beam->owner == H2_BEAM_OWNER_SEND);

    int safe_recv = !beam->m_enter || (beam->owner == H2_BEAM_OWNER_RECV);

    int safe_send = (beam->owner == H2_BEAM_OWNER_SEND);

    int safe_recv = (beam->owner == H2_BEAM_OWNER_RECV);

    

    /* 

     * Owner of the beam is going away, depending on which side it owns,

     * cleanup strategies will differ with multi-thread protection

     * still in place (beam->m_enter).

     * cleanup strategies will differ.

     *

     * In general, receiver holds references to memory from sender. 

     * Clean up receiver first, if safe, then cleanup sender, if safe.
@@ -680,29 +670,6 @@ apr_size_t h2_beam_buffer_size_get(h2_bucket_beam *beam) 
    return buffer_size;

}



void h2_beam_mutex_set(h2_bucket_beam *beam, 

                       h2_beam_mutex_enter m_enter,

                       void *m_ctx)

{

    h2_beam_lock bl;

    

    if (enter_yellow(beam, &bl) == APR_SUCCESS) {

        beam->m_enter = m_enter;

        beam->m_ctx   = m_ctx;

        leave_yellow(beam, &bl);

    }

}



void h2_beam_mutex_enable(h2_bucket_beam *beam)

{

    h2_beam_mutex_set(beam, mutex_enter, beam);

}



void h2_beam_mutex_disable(h2_bucket_beam *beam)

{

    h2_beam_mutex_set(beam, NULL, NULL);

}



void h2_beam_timeout_set(h2_bucket_beam *beam, apr_interval_time_t timeout)

{

    h2_beam_lock bl;

modules/http2/h2_bucket_beam.h

+3 −14
Original line number Diff line number Diff line
@@ -64,13 +64,11 @@ typedef struct { 
 * via the h2_beam_send(). It gives the beam to the green thread which then

 * can receive buckets into its own brigade via h2_beam_receive().

 *

 * Sending and receiving can happen concurrently, if a thread mutex is set

 * for the beam, see h2_beam_mutex_set.

 * Sending and receiving can happen concurrently.

 *

 * The beam can limit the amount of data it accepts via the buffer_size. This

 * can also be adjusted during its lifetime. When the beam not only gets a 

 * mutex but als a condition variable (in h2_beam_mutex_set()), sends and

 * receives can be done blocking. A timeout can be set for such blocks.

 * can also be adjusted during its lifetime. Sends and receives can be done blocking. 

 * A timeout can be set for such blocks.

 *

 * Care needs to be taken when terminating the beam. The beam registers at

 * the pool it was created with and will cleanup after itself. However, if
@@ -191,8 +189,6 @@ struct h2_bucket_beam { 


    struct apr_thread_mutex_t *lock;

    struct apr_thread_cond_t *change;

    void *m_ctx;

    h2_beam_mutex_enter *m_enter;

    

    apr_off_t cons_bytes_reported;    /* amount of bytes reported as consumed */

    h2_beam_ev_callback *cons_ev_cb;
@@ -315,13 +311,6 @@ int h2_beam_is_closed(h2_bucket_beam *beam); 
 */

apr_status_t h2_beam_wait_empty(h2_bucket_beam *beam, apr_read_type_e block);



void h2_beam_mutex_set(h2_bucket_beam *beam, 

                       h2_beam_mutex_enter m_enter,

                       void *m_ctx);



void h2_beam_mutex_enable(h2_bucket_beam *beam);

void h2_beam_mutex_disable(h2_bucket_beam *beam);



/** 

 * Set/get the timeout for blocking read/write operations. Only works

 * if a mutex has been set for the beam.

modules/http2/h2_mplx.c

+0 −11
Original line number Diff line number Diff line
@@ -543,9 +543,6 @@ static apr_status_t out_open(h2_mplx *m, int stream_id, h2_bucket_beam *beam) 
        h2_beam_on_file_beam(stream->output, h2_beam_no_files, NULL);

    }

    

    /* time to protect the beam against multi-threaded use */

    h2_beam_mutex_enable(stream->output);

    

    /* we might see some file buckets in the output, see

     * if we have enough handles reserved. */

    check_data_for(m, stream, 0);
@@ -853,10 +850,6 @@ static void task_done(h2_mplx *m, h2_task *task, h2_req_engine *ngn) 
                          H2_STRM_MSG(stream, "task_done, stream open")); 

            if (stream->input) {

                h2_beam_leave(stream->input);

                h2_beam_mutex_disable(stream->input);

            }

            if (stream->output) {

                h2_beam_mutex_disable(stream->output);

            }



            /* more data will not arrive, resume the stream */
@@ -869,10 +862,6 @@ static void task_done(h2_mplx *m, h2_task *task, h2_req_engine *ngn) 
                      H2_STRM_MSG(stream, "task_done, in hold"));

        if (stream->input) {

            h2_beam_leave(stream->input);

            h2_beam_mutex_disable(stream->input);

        }

        if (stream->output) {

            h2_beam_mutex_disable(stream->output);

        }

        stream_joined(m, stream);

    }