Changeset 6496:887cca40ba6a in nginx


Ignore:
Timestamp:
04/01/16 12:56:03 (4 years ago)
Author:
Valentin Bartenev <vbart@…>
Branch:
default
Phase:
public
Message:

HTTP/2: rewritten handling of request body.

There are two improvements:

  1. Support for request body filters;
  1. Receiving of request body is started only after the ngx_http_read_client_request_body() call.

The last one fixes the problem when the client_max_body_size value might not be
respected from the right location if the location was changed either during the
process of receiving body or after the whole body had been received.

Location:
src/http
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • src/http/ngx_http_request.h

    r6317 r6496  
    285285    ngx_buf_t                        *buf;
    286286    off_t                             rest;
     287#if (NGX_HTTP_V2)
     288    off_t                             received;
     289#endif
    287290    ngx_chain_t                      *free;
    288291    ngx_chain_t                      *busy;
  • src/http/ngx_http_request_body.c

    r6420 r6496  
    4141    r->main->count++;
    4242
     43    if (r != r->main || r->request_body || r->discard_body) {
     44        r->request_body_no_buffering = 0;
     45        post_handler(r);
     46        return NGX_OK;
     47    }
     48
    4349#if (NGX_HTTP_V2)
    44     if (r->stream && r == r->main) {
     50    if (r->stream) {
    4551        r->request_body_no_buffering = 0;
    4652        rc = ngx_http_v2_read_request_body(r, post_handler);
     
    4854    }
    4955#endif
    50 
    51     if (r != r->main || r->request_body || r->discard_body) {
    52         r->request_body_no_buffering = 0;
    53         post_handler(r);
    54         return NGX_OK;
    55     }
    5656
    5757    if (ngx_http_test_expect(r) != NGX_OK) {
     
    504504    ngx_event_t  *rev;
    505505
     506    if (r != r->main || r->discard_body || r->request_body) {
     507        return NGX_OK;
     508    }
     509
    506510#if (NGX_HTTP_V2)
    507     if (r->stream && r == r->main) {
    508         r->stream->skip_data = NGX_HTTP_V2_DATA_DISCARD;
     511    if (r->stream) {
     512        r->stream->skip_data = 1;
    509513        return NGX_OK;
    510514    }
    511515#endif
    512 
    513     if (r != r->main || r->discard_body || r->request_body) {
    514         return NGX_OK;
    515     }
    516516
    517517    if (ngx_http_test_expect(r) != NGX_OK) {
  • src/http/v2/ngx_http_v2.c

    r6495 r6496  
    5151#define NGX_HTTP_V2_MAX_WINDOW                   ((1U << 31) - 1)
    5252#define NGX_HTTP_V2_DEFAULT_WINDOW               65535
     53
     54#define NGX_HTTP_V2_INITIAL_WINDOW               0
    5355
    5456#define NGX_HTTP_V2_ROOT                         (void *) -1
     
    164166static ngx_int_t ngx_http_v2_construct_cookie_header(ngx_http_request_t *r);
    165167static void ngx_http_v2_run_request(ngx_http_request_t *r);
    166 static ngx_int_t ngx_http_v2_init_request_body(ngx_http_request_t *r);
     168static ngx_int_t ngx_http_v2_process_request_body(ngx_http_request_t *r,
     169    u_char *pos, size_t size, ngx_uint_t last);
     170static ngx_int_t ngx_http_v2_filter_request_body(ngx_http_request_t *r);
    167171static void ngx_http_v2_read_client_request_body_handler(ngx_http_request_t *r);
    168172
     
    763767            ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
    764768                          "client sent padded DATA frame "
    765                           "with incorrect length: %uz",
    766                           h2c->state.length);
     769                          "with incorrect length: 0");
    767770
    768771            return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_SIZE_ERROR);
     
    846849    stream->recv_window -= h2c->state.length;
    847850
    848     if (stream->recv_window < NGX_HTTP_V2_MAX_WINDOW / 4) {
    849 
     851    if (stream->no_flow_control
     852        && stream->recv_window < NGX_HTTP_V2_MAX_WINDOW / 4)
     853    {
    850854        if (ngx_http_v2_send_window_update(h2c, node->id,
    851855                                           NGX_HTTP_V2_MAX_WINDOW
     
    876880    }
    877881
     882    stream->in_closed = h2c->state.flags & NGX_HTTP_V2_END_STREAM_FLAG;
     883
    878884    h2c->state.stream = stream;
    879885
     
    886892    u_char *end)
    887893{
    888     size_t                     size;
    889     ssize_t                    n;
    890     ngx_buf_t                 *buf;
    891     ngx_int_t                  rc;
    892     ngx_temp_file_t           *tf;
    893     ngx_connection_t          *fc;
    894     ngx_http_request_t        *r;
    895     ngx_http_v2_stream_t      *stream;
    896     ngx_http_request_body_t   *rb;
    897     ngx_http_core_loc_conf_t  *clcf;
     894    size_t                 size;
     895    ngx_int_t              rc;
     896    ngx_uint_t             last;
     897    ngx_http_v2_stream_t  *stream;
    898898
    899899    stream = h2c->state.stream;
     
    904904
    905905    if (stream->skip_data) {
    906         stream->in_closed = h2c->state.flags & NGX_HTTP_V2_END_STREAM_FLAG;
    907 
    908         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
    909                        "skipping http2 DATA frame, reason: %d",
    910                        stream->skip_data);
     906        ngx_log_debug0(NGX_LOG_DEBUG_HTTP, h2c->connection->log, 0,
     907                       "skipping http2 DATA frame");
    911908
    912909        return ngx_http_v2_state_skip_padded(h2c, pos, end);
     
    915912    size = end - pos;
    916913
    917     if (size > h2c->state.length) {
     914    if (size >= h2c->state.length) {
    918915        size = h2c->state.length;
    919     }
    920 
    921     r = stream->request;
    922 
    923     if (r->request_body == NULL
    924         && ngx_http_v2_init_request_body(r) != NGX_OK)
    925     {
    926         stream->skip_data = NGX_HTTP_V2_DATA_INTERNAL_ERROR;
    927         return ngx_http_v2_state_skip_padded(h2c, pos, end);
    928     }
    929 
    930     fc = r->connection;
    931     rb = r->request_body;
    932     tf = rb->temp_file;
    933     buf = rb->buf;
    934 
    935     if (size) {
    936         rb->rest += size;
    937 
    938         if (r->headers_in.content_length_n != -1
    939             && r->headers_in.content_length_n < rb->rest)
    940         {
    941             ngx_log_error(NGX_LOG_INFO, fc->log, 0,
    942                           "client intended to send body data "
    943                           "larger than declared");
    944 
    945             stream->skip_data = NGX_HTTP_V2_DATA_ERROR;
    946             goto error;
    947 
    948         } else {
    949             clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
    950 
    951             if (clcf->client_max_body_size
    952                 && clcf->client_max_body_size < rb->rest)
    953             {
    954                 ngx_log_error(NGX_LOG_ERR, fc->log, 0,
    955                               "client intended to send "
    956                               "too large chunked body: %O bytes", rb->rest);
    957 
    958                 stream->skip_data = NGX_HTTP_V2_DATA_ERROR;
    959                 goto error;
    960             }
    961         }
    962 
    963         h2c->state.length -= size;
    964 
    965         if (tf) {
    966             buf->start = pos;
    967             buf->pos = pos;
    968 
    969             pos += size;
    970 
    971             buf->end = pos;
    972             buf->last = pos;
    973 
    974             n = ngx_write_chain_to_temp_file(tf, rb->bufs);
    975 
    976             /* TODO: n == 0 or not complete and level event */
    977 
    978             if (n == NGX_ERROR) {
    979                 stream->skip_data = NGX_HTTP_V2_DATA_INTERNAL_ERROR;
    980                 goto error;
    981             }
    982 
    983             tf->offset += n;
    984 
    985         } else {
    986             buf->last = ngx_cpymem(buf->last, pos, size);
    987             pos += size;
    988         }
    989 
    990         r->request_length += size;
    991     }
     916        last = stream->in_closed;
     917
     918    } else {
     919        last = 0;
     920    }
     921
     922    rc = ngx_http_v2_process_request_body(stream->request, pos, size, last);
     923
     924    if (rc != NGX_OK) {
     925        stream->skip_data = 1;
     926        ngx_http_finalize_request(stream->request, rc);
     927    }
     928
     929    pos += size;
     930    h2c->state.length -= size;
    992931
    993932    if (h2c->state.length) {
    994         if (rb->post_handler) {
    995             clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
    996             ngx_add_timer(fc->read, clcf->client_body_timeout);
    997         }
    998 
    999933        return ngx_http_v2_state_save(h2c, pos, end,
    1000934                                      ngx_http_v2_state_read_data);
    1001935    }
    1002936
    1003     if (h2c->state.flags & NGX_HTTP_V2_END_STREAM_FLAG) {
    1004         stream->in_closed = 1;
    1005 
    1006         if (r->headers_in.content_length_n < 0) {
    1007             r->headers_in.content_length_n = rb->rest;
    1008 
    1009         } else if (r->headers_in.content_length_n != rb->rest) {
    1010             ngx_log_error(NGX_LOG_INFO, fc->log, 0,
    1011                           "client prematurely closed stream: "
    1012                           "only %O out of %O bytes of request body received",
    1013                           rb->rest, r->headers_in.content_length_n);
    1014 
    1015             stream->skip_data = NGX_HTTP_V2_DATA_ERROR;
    1016             goto error;
    1017         }
    1018 
    1019         if (tf) {
    1020             ngx_memzero(buf, sizeof(ngx_buf_t));
    1021 
    1022             buf->in_file = 1;
    1023             buf->file_last = tf->file.offset;
    1024             buf->file = &tf->file;
    1025 
    1026             rb->buf = NULL;
    1027         }
    1028 
    1029         if (rb->post_handler) {
    1030             if (fc->read->timer_set) {
    1031                 ngx_del_timer(fc->read);
    1032             }
    1033 
    1034             r->read_event_handler = ngx_http_block_reading;
    1035             rb->post_handler(r);
    1036         }
    1037 
    1038     } else if (rb->post_handler) {
    1039         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
    1040         ngx_add_timer(fc->read, clcf->client_body_timeout);
    1041     }
    1042 
    1043937    if (h2c->state.padding) {
    1044938        return ngx_http_v2_state_skip_padded(h2c, pos, end);
     
    1046940
    1047941    return ngx_http_v2_state_complete(h2c, pos, end);
    1048 
    1049 error:
    1050 
    1051     if (rb->post_handler) {
    1052         if (fc->read->timer_set) {
    1053             ngx_del_timer(fc->read);
    1054         }
    1055 
    1056         if (stream->skip_data == NGX_HTTP_V2_DATA_ERROR) {
    1057             rc = (r->headers_in.content_length_n == -1)
    1058                  ? NGX_HTTP_REQUEST_ENTITY_TOO_LARGE : NGX_HTTP_BAD_REQUEST;
    1059 
    1060         } else {
    1061             rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
    1062         }
    1063 
    1064         ngx_http_finalize_request(r, rc);
    1065     }
    1066 
    1067     return ngx_http_v2_state_skip_padded(h2c, pos, end);
    1068942}
    1069943
     
    25572431                                         NGX_HTTP_V2_INIT_WINDOW_SIZE_SETTING);
    25582432        buf->last = ngx_http_v2_write_uint32(buf->last,
    2559                                              NGX_HTTP_V2_MAX_WINDOW);
     2433                                             NGX_HTTP_V2_INITIAL_WINDOW);
    25602434
    25612435        buf->last = ngx_http_v2_write_uint16(buf->last,
     
    28792753
    28802754    stream->send_window = h2c->init_window;
    2881     stream->recv_window = NGX_HTTP_V2_MAX_WINDOW;
     2755    stream->recv_window = NGX_HTTP_V2_INITIAL_WINDOW;
    28822756
    28832757    h2c->processing++;
     
    35163390                      "client prematurely closed stream");
    35173391
    3518         r->stream->skip_data = NGX_HTTP_V2_DATA_ERROR;
     3392        r->stream->skip_data = 1;
    35193393
    35203394        ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
     
    35233397
    35243398    ngx_http_process_request(r);
    3525 }
    3526 
    3527 
    3528 static ngx_int_t
    3529 ngx_http_v2_init_request_body(ngx_http_request_t *r)
    3530 {
    3531     ngx_buf_t                 *buf;
    3532     ngx_temp_file_t           *tf;
    3533     ngx_http_request_body_t   *rb;
    3534     ngx_http_core_loc_conf_t  *clcf;
    3535 
    3536     rb = ngx_pcalloc(r->pool, sizeof(ngx_http_request_body_t));
    3537     if (rb == NULL) {
    3538         return NGX_ERROR;
    3539     }
    3540 
    3541     r->request_body = rb;
    3542 
    3543     if (r->stream->in_closed) {
    3544         return NGX_OK;
    3545     }
    3546 
    3547     rb->rest = r->headers_in.content_length_n;
    3548 
    3549     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
    3550 
    3551     if (r->request_body_in_file_only
    3552         || rb->rest > (off_t) clcf->client_body_buffer_size
    3553         || rb->rest < 0)
    3554     {
    3555         tf = ngx_pcalloc(r->pool, sizeof(ngx_temp_file_t));
    3556         if (tf == NULL) {
    3557             return NGX_ERROR;
    3558         }
    3559 
    3560         tf->file.fd = NGX_INVALID_FILE;
    3561         tf->file.log = r->connection->log;
    3562         tf->path = clcf->client_body_temp_path;
    3563         tf->pool = r->pool;
    3564         tf->warn = "a client request body is buffered to a temporary file";
    3565         tf->log_level = r->request_body_file_log_level;
    3566         tf->persistent = r->request_body_in_persistent_file;
    3567         tf->clean = r->request_body_in_clean_file;
    3568 
    3569         if (r->request_body_file_group_access) {
    3570             tf->access = 0660;
    3571         }
    3572 
    3573         rb->temp_file = tf;
    3574 
    3575         if (r->stream->in_closed
    3576             && ngx_create_temp_file(&tf->file, tf->path, tf->pool,
    3577                                     tf->persistent, tf->clean, tf->access)
    3578                != NGX_OK)
    3579         {
    3580             return NGX_ERROR;
    3581         }
    3582 
    3583         buf = ngx_calloc_buf(r->pool);
    3584         if (buf == NULL) {
    3585             return NGX_ERROR;
    3586         }
    3587 
    3588     } else {
    3589 
    3590         if (rb->rest == 0) {
    3591             return NGX_OK;
    3592         }
    3593 
    3594         buf = ngx_create_temp_buf(r->pool, (size_t) rb->rest);
    3595         if (buf == NULL) {
    3596             return NGX_ERROR;
    3597         }
    3598     }
    3599 
    3600     rb->buf = buf;
    3601 
    3602     rb->bufs = ngx_alloc_chain_link(r->pool);
    3603     if (rb->bufs == NULL) {
    3604         return NGX_ERROR;
    3605     }
    3606 
    3607     rb->bufs->buf = buf;
    3608     rb->bufs->next = NULL;
    3609 
    3610     rb->rest = 0;
    3611 
    3612     return NGX_OK;
    36133399}
    36143400
     
    36183404    ngx_http_client_body_handler_pt post_handler)
    36193405{
     3406    off_t                      len;
    36203407    ngx_http_v2_stream_t      *stream;
     3408    ngx_http_request_body_t   *rb;
    36213409    ngx_http_core_loc_conf_t  *clcf;
    36223410
    3623     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
    3624                    "http2 read request body");
    3625 
    36263411    stream = r->stream;
    36273412
    3628     switch (stream->skip_data) {
    3629 
    3630     case NGX_HTTP_V2_DATA_DISCARD:
     3413    if (stream->skip_data) {
     3414        r->request_body_no_buffering = 0;
    36313415        post_handler(r);
    36323416        return NGX_OK;
    3633 
    3634     case NGX_HTTP_V2_DATA_ERROR:
    3635         if (r->headers_in.content_length_n == -1) {
    3636             return NGX_HTTP_REQUEST_ENTITY_TOO_LARGE;
    3637         } else {
    3638             return NGX_HTTP_BAD_REQUEST;
    3639         }
    3640 
    3641     case NGX_HTTP_V2_DATA_INTERNAL_ERROR:
     3417    }
     3418
     3419    rb = ngx_pcalloc(r->pool, sizeof(ngx_http_request_body_t));
     3420    if (rb == NULL) {
    36423421        return NGX_HTTP_INTERNAL_SERVER_ERROR;
    36433422    }
    36443423
    3645     if (!r->request_body && ngx_http_v2_init_request_body(r) != NGX_OK) {
    3646         stream->skip_data = NGX_HTTP_V2_DATA_INTERNAL_ERROR;
     3424    /*
     3425     * set by ngx_pcalloc():
     3426     *
     3427     *     rb->bufs = NULL;
     3428     *     rb->buf = NULL;
     3429     *     rb->received = 0;
     3430     *     rb->free = NULL;
     3431     *     rb->busy = NULL;
     3432     */
     3433
     3434    rb->rest = 1;
     3435    rb->post_handler = post_handler;
     3436
     3437    r->request_body = rb;
     3438
     3439    clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
     3440
     3441    len = r->headers_in.content_length_n;
     3442
     3443    if (len >= 0 && len <= (off_t) clcf->client_body_buffer_size
     3444        && !r->request_body_in_file_only)
     3445    {
     3446        rb->buf = ngx_create_temp_buf(r->pool, (size_t) len);
     3447
     3448    } else {
     3449        rb->buf = ngx_calloc_buf(r->pool);
     3450
     3451        if (rb->buf != NULL) {
     3452            rb->buf->sync = 1;
     3453        }
     3454    }
     3455
     3456    if (rb->buf == NULL) {
    36473457        return NGX_HTTP_INTERNAL_SERVER_ERROR;
    36483458    }
    36493459
    36503460    if (stream->in_closed) {
    3651         post_handler(r);
    3652         return NGX_OK;
    3653     }
    3654 
    3655     r->request_body->post_handler = post_handler;
     3461        return ngx_http_v2_process_request_body(r, NULL, 0, 1);
     3462    }
     3463
     3464    stream->no_flow_control = 1;
     3465
     3466    stream->recv_window = NGX_HTTP_V2_MAX_WINDOW;
     3467
     3468    if (ngx_http_v2_send_window_update(stream->connection, stream->node->id,
     3469                                       stream->recv_window)
     3470        == NGX_ERROR)
     3471    {
     3472        return NGX_HTTP_INTERNAL_SERVER_ERROR;
     3473    }
     3474
     3475    ngx_add_timer(r->connection->read, clcf->client_body_timeout);
    36563476
    36573477    r->read_event_handler = ngx_http_v2_read_client_request_body_handler;
    36583478    r->write_event_handler = ngx_http_request_empty_handler;
    36593479
     3480    return NGX_AGAIN;
     3481}
     3482
     3483
     3484static ngx_int_t
     3485ngx_http_v2_process_request_body(ngx_http_request_t *r, u_char *pos,
     3486    size_t size, ngx_uint_t last)
     3487{
     3488    ngx_buf_t                 *buf;
     3489    ngx_int_t                  rc;
     3490    ngx_connection_t          *fc;
     3491    ngx_http_request_body_t   *rb;
     3492    ngx_http_core_loc_conf_t  *clcf;
     3493
     3494    rb = r->request_body;
     3495
     3496    if (rb == NULL) {
     3497        return NGX_OK;
     3498    }
     3499
     3500    fc = r->connection;
     3501    buf = rb->buf;
     3502
     3503    if (size) {
     3504        if (buf->sync) {
     3505            buf->pos = buf->start = pos;
     3506            buf->last = buf->end = pos + size;
     3507
     3508        } else {
     3509            if (size > (size_t) (buf->end - buf->last)) {
     3510                ngx_log_error(NGX_LOG_INFO, fc->log, 0,
     3511                                "client intended to send body data "
     3512                                "larger than declared");
     3513
     3514                return NGX_HTTP_BAD_REQUEST;
     3515            }
     3516
     3517            buf->last = ngx_cpymem(buf->last, pos, size);
     3518        }
     3519    }
     3520
     3521    if (last) {
     3522        rb->rest = 0;
     3523
     3524        if (fc->read->timer_set) {
     3525            ngx_del_timer(fc->read);
     3526        }
     3527
     3528        rc = ngx_http_v2_filter_request_body(r);
     3529
     3530        if (rc != NGX_OK) {
     3531            return rc;
     3532        }
     3533
     3534        if (buf->sync) {
     3535            /* prevent reusing this buffer in the upstream module */
     3536            rb->buf = NULL;
     3537        }
     3538
     3539        if (r->headers_in.content_length_n == -1) {
     3540            r->headers_in.content_length_n = rb->received;
     3541        }
     3542
     3543        r->read_event_handler = ngx_http_block_reading;
     3544        rb->post_handler(r);
     3545
     3546        return NGX_OK;
     3547    }
     3548
     3549    if (size == 0) {
     3550        return NGX_OK;
     3551    }
     3552
    36603553    clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
    3661     ngx_add_timer(r->connection->read, clcf->client_body_timeout);
    3662 
    3663     return NGX_AGAIN;
     3554    ngx_add_timer(fc->read, clcf->client_body_timeout);
     3555
     3556    if (buf->sync) {
     3557        return ngx_http_v2_filter_request_body(r);
     3558    }
     3559
     3560    return NGX_OK;
     3561}
     3562
     3563
     3564static ngx_int_t
     3565ngx_http_v2_filter_request_body(ngx_http_request_t *r)
     3566{
     3567    ngx_buf_t                 *b, *buf;
     3568    ngx_int_t                  rc;
     3569    ngx_chain_t               *cl;
     3570    ngx_http_request_body_t   *rb;
     3571    ngx_http_core_loc_conf_t  *clcf;
     3572
     3573    rb = r->request_body;
     3574    buf = rb->buf;
     3575
     3576    cl = ngx_chain_get_free_buf(r->pool, &rb->free);
     3577    if (cl == NULL) {
     3578        return NGX_HTTP_INTERNAL_SERVER_ERROR;
     3579    }
     3580
     3581    b = cl->buf;
     3582
     3583    ngx_memzero(b, sizeof(ngx_buf_t));
     3584
     3585    if (buf->pos != buf->last) {
     3586        r->request_length += buf->last - buf->pos;
     3587        rb->received += buf->last - buf->pos;
     3588
     3589        if (r->headers_in.content_length_n != -1) {
     3590            if (rb->received > r->headers_in.content_length_n) {
     3591                ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
     3592                              "client intended to send body data "
     3593                              "larger than declared");
     3594
     3595                return NGX_HTTP_BAD_REQUEST;
     3596            }
     3597
     3598        } else {
     3599            clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
     3600
     3601            if (clcf->client_max_body_size
     3602                && rb->received > clcf->client_max_body_size)
     3603            {
     3604                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
     3605                              "client intended to send too large chunked body: "
     3606                              "%O bytes", rb->received);
     3607
     3608                return NGX_HTTP_REQUEST_ENTITY_TOO_LARGE;
     3609            }
     3610        }
     3611
     3612        b->temporary = 1;
     3613        b->pos = buf->pos;
     3614        b->last = buf->last;
     3615        b->start = b->pos;
     3616        b->end = b->last;
     3617
     3618        buf->pos = buf->last;
     3619    }
     3620
     3621    if (!rb->rest) {
     3622        if (r->headers_in.content_length_n != -1
     3623            && r->headers_in.content_length_n != rb->received)
     3624        {
     3625            ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
     3626                          "client prematurely closed stream: "
     3627                          "only %O out of %O bytes of request body received",
     3628                          rb->received, r->headers_in.content_length_n);
     3629
     3630            return NGX_HTTP_BAD_REQUEST;
     3631        }
     3632
     3633        b->last_buf = 1;
     3634    }
     3635
     3636    b->tag = (ngx_buf_tag_t) &ngx_http_v2_filter_request_body;
     3637
     3638    rc = ngx_http_top_request_body_filter(r, cl);
     3639
     3640    ngx_chain_update_chains(r->pool, &rb->free, &rb->busy, &cl,
     3641                            (ngx_buf_tag_t) &ngx_http_v2_filter_request_body);
     3642
     3643    return rc;
    36643644}
    36653645
     
    36793659
    36803660        fc->timedout = 1;
    3681         r->stream->skip_data = NGX_HTTP_V2_DATA_DISCARD;
     3661        r->stream->skip_data = 1;
    36823662
    36833663        ngx_http_finalize_request(r, NGX_HTTP_REQUEST_TIME_OUT);
     
    36893669                      "client prematurely closed stream");
    36903670
    3691         r->stream->skip_data = NGX_HTTP_V2_DATA_DISCARD;
     3671        r->stream->skip_data = 1;
    36923672
    36933673        ngx_http_finalize_request(r, NGX_HTTP_CLIENT_CLOSED_REQUEST);
  • src/http/v2/ngx_http_v2.h

    r6495 r6496  
    2424#define NGX_HTTP_V2_MAX_FIELD                                                 \
    2525    (127 + (1 << (NGX_HTTP_V2_INT_OCTETS - 1) * 7) - 1)
    26 
    27 #define NGX_HTTP_V2_DATA_DISCARD         1
    28 #define NGX_HTTP_V2_DATA_ERROR           2
    29 #define NGX_HTTP_V2_DATA_INTERNAL_ERROR  3
    3026
    3127#define NGX_HTTP_V2_FRAME_HEADER_SIZE    9
     
    196192    unsigned                         out_closed:1;
    197193    unsigned                         rst_sent:1;
    198     unsigned                         skip_data:2;
     194    unsigned                         no_flow_control:1;
     195    unsigned                         skip_data:1;
    199196};
    200197
Note: See TracChangeset for help on using the changeset viewer.