2012-01-24 14:02:24 +01:00
|
|
|
/*
|
2014-03-30 12:09:21 +02:00
|
|
|
* nghttp2 - HTTP/2 C Library
|
2012-01-24 14:02:24 +01:00
|
|
|
*
|
|
|
|
* Copyright (c) 2012 Tatsuhiro Tsujikawa
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
|
|
* a copy of this software and associated documentation files (the
|
|
|
|
* "Software"), to deal in the Software without restriction, including
|
|
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
|
|
* distribute, sublicense, and/or sell copies of the Software, and to
|
|
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
|
|
* the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be
|
|
|
|
* included in all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
|
|
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
|
|
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
|
|
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
*/
|
2013-07-12 17:19:03 +02:00
|
|
|
#include "nghttp2_stream.h"
|
2012-01-24 14:02:24 +01:00
|
|
|
|
2012-02-19 15:42:25 +01:00
|
|
|
#include <assert.h>
|
2014-03-25 18:04:24 +01:00
|
|
|
#include <stdio.h>
|
2012-02-19 15:42:25 +01:00
|
|
|
|
2014-03-31 15:51:33 +02:00
|
|
|
#include "nghttp2_helper.h"
|
|
|
|
|
2013-07-12 17:19:03 +02:00
|
|
|
void nghttp2_stream_init(nghttp2_stream *stream, int32_t stream_id,
|
2014-03-25 18:04:24 +01:00
|
|
|
uint8_t flags,
|
2013-07-12 17:19:03 +02:00
|
|
|
nghttp2_stream_state initial_state,
|
2014-04-14 16:53:54 +02:00
|
|
|
int32_t weight,
|
2014-04-17 14:15:14 +02:00
|
|
|
nghttp2_stream_roots *roots,
|
2013-08-08 14:12:49 +02:00
|
|
|
int32_t remote_initial_window_size,
|
|
|
|
int32_t local_initial_window_size,
|
2012-02-03 17:37:21 +01:00
|
|
|
void *stream_user_data)
|
2012-01-24 14:02:24 +01:00
|
|
|
{
|
2013-07-12 17:19:03 +02:00
|
|
|
nghttp2_map_entry_init(&stream->map_entry, stream_id);
|
2012-01-24 14:02:24 +01:00
|
|
|
stream->stream_id = stream_id;
|
2012-01-25 15:46:07 +01:00
|
|
|
stream->flags = flags;
|
2012-01-25 17:04:01 +01:00
|
|
|
stream->state = initial_state;
|
2013-07-12 17:19:03 +02:00
|
|
|
stream->shut_flags = NGHTTP2_SHUT_NONE;
|
2012-02-03 17:37:21 +01:00
|
|
|
stream->stream_user_data = stream_user_data;
|
2014-04-02 15:55:49 +02:00
|
|
|
stream->data_item = NULL;
|
2013-08-08 14:12:49 +02:00
|
|
|
stream->remote_window_size = remote_initial_window_size;
|
|
|
|
stream->local_window_size = local_initial_window_size;
|
2012-02-25 16:12:32 +01:00
|
|
|
stream->recv_window_size = 0;
|
2014-07-25 14:26:03 +02:00
|
|
|
stream->consumed_size = 0;
|
2013-10-12 10:02:37 +02:00
|
|
|
stream->recv_reduction = 0;
|
2014-04-24 17:35:48 +02:00
|
|
|
stream->blocked_sent = 0;
|
2014-03-25 18:04:24 +01:00
|
|
|
|
|
|
|
stream->dep_prev = NULL;
|
|
|
|
stream->dep_next = NULL;
|
|
|
|
stream->sib_prev = NULL;
|
|
|
|
stream->sib_next = NULL;
|
|
|
|
|
2014-03-30 10:41:54 +02:00
|
|
|
stream->closed_next = NULL;
|
|
|
|
|
2014-03-25 18:04:24 +01:00
|
|
|
stream->dpri = NGHTTP2_STREAM_DPRI_NO_DATA;
|
|
|
|
stream->num_substreams = 1;
|
2014-04-14 16:53:54 +02:00
|
|
|
stream->weight = weight;
|
|
|
|
stream->effective_weight = stream->weight;
|
|
|
|
stream->sum_dep_weight = 0;
|
2014-04-24 16:37:40 +02:00
|
|
|
stream->sum_norest_weight = 0;
|
2014-04-17 14:15:14 +02:00
|
|
|
|
|
|
|
stream->roots = roots;
|
|
|
|
stream->root_prev = NULL;
|
|
|
|
stream->root_next = NULL;
|
2012-01-24 14:02:24 +01:00
|
|
|
}
|
|
|
|
|
2013-07-12 17:19:03 +02:00
|
|
|
void nghttp2_stream_free(nghttp2_stream *stream)
|
2012-02-02 13:51:52 +01:00
|
|
|
{
|
2014-04-02 15:55:49 +02:00
|
|
|
if(stream->flags & NGHTTP2_STREAM_FLAG_DEFERRED_ALL) {
|
|
|
|
nghttp2_outbound_item_free(stream->data_item);
|
|
|
|
free(stream->data_item);
|
|
|
|
}
|
2014-03-25 18:04:24 +01:00
|
|
|
|
2014-04-02 15:55:49 +02:00
|
|
|
/* We don't free stream->data_item otherwise. */
|
2012-02-02 13:51:52 +01:00
|
|
|
}
|
2012-01-28 16:08:51 +01:00
|
|
|
|
2013-07-12 17:19:03 +02:00
|
|
|
void nghttp2_stream_shutdown(nghttp2_stream *stream, nghttp2_shut_flag flag)
|
2012-01-28 16:08:51 +01:00
|
|
|
{
|
|
|
|
stream->shut_flags |= flag;
|
|
|
|
}
|
2012-02-02 13:51:52 +01:00
|
|
|
|
2014-05-08 16:07:29 +02:00
|
|
|
static int stream_push_data(nghttp2_stream *stream, nghttp2_pq *pq,
|
|
|
|
uint64_t cycle)
|
2014-03-31 16:01:05 +02:00
|
|
|
{
|
|
|
|
int rv;
|
|
|
|
|
2014-04-02 15:55:49 +02:00
|
|
|
assert(stream->data_item);
|
|
|
|
assert(stream->data_item->queued == 0);
|
2014-03-31 16:01:05 +02:00
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
if(stream->data_item->weight > stream->effective_weight) {
|
|
|
|
stream->data_item->weight = stream->effective_weight;
|
2014-03-31 16:01:05 +02:00
|
|
|
}
|
|
|
|
|
2014-05-08 16:07:29 +02:00
|
|
|
stream->data_item->cycle = cycle;
|
|
|
|
|
2014-04-02 15:55:49 +02:00
|
|
|
rv = nghttp2_pq_push(pq, stream->data_item);
|
2014-03-31 16:01:05 +02:00
|
|
|
|
|
|
|
if(rv != 0) {
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2014-04-02 15:55:49 +02:00
|
|
|
stream->data_item->queued = 1;
|
2014-03-31 16:01:05 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-03-25 18:04:24 +01:00
|
|
|
static nghttp2_stream* stream_first_sib(nghttp2_stream *stream)
|
|
|
|
{
|
|
|
|
for(; stream->sib_prev; stream = stream->sib_prev);
|
|
|
|
|
|
|
|
return stream;
|
|
|
|
}
|
|
|
|
|
|
|
|
static nghttp2_stream* stream_last_sib(nghttp2_stream *stream)
|
|
|
|
{
|
|
|
|
for(; stream->sib_next; stream = stream->sib_next);
|
|
|
|
|
|
|
|
return stream;
|
|
|
|
}
|
|
|
|
|
|
|
|
static nghttp2_stream* stream_update_dep_length(nghttp2_stream *stream,
|
|
|
|
ssize_t delta)
|
|
|
|
{
|
|
|
|
stream->num_substreams += delta;
|
|
|
|
|
|
|
|
stream = stream_first_sib(stream);
|
|
|
|
|
|
|
|
if(stream->dep_prev) {
|
|
|
|
return stream_update_dep_length(stream->dep_prev, delta);
|
|
|
|
}
|
|
|
|
|
|
|
|
return stream;
|
|
|
|
}
|
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
int32_t nghttp2_stream_dep_distributed_weight(nghttp2_stream *stream,
|
|
|
|
int32_t weight)
|
2014-03-31 15:51:33 +02:00
|
|
|
{
|
2014-04-14 16:53:54 +02:00
|
|
|
weight = stream->weight * weight / stream->sum_dep_weight;
|
2014-03-31 15:51:33 +02:00
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
return nghttp2_max(1, weight);
|
|
|
|
}
|
2014-03-31 15:51:33 +02:00
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
int32_t nghttp2_stream_dep_distributed_effective_weight
|
|
|
|
(nghttp2_stream *stream, int32_t weight)
|
|
|
|
{
|
2014-04-27 07:40:10 +02:00
|
|
|
if(stream->sum_norest_weight == 0) {
|
|
|
|
return stream->effective_weight;
|
|
|
|
}
|
|
|
|
|
2014-04-24 16:37:40 +02:00
|
|
|
weight = stream->effective_weight * weight / stream->sum_norest_weight;
|
2014-03-31 15:51:33 +02:00
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
return nghttp2_max(1, weight);
|
2014-03-31 15:51:33 +02:00
|
|
|
}
|
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
/* Updates effective_weight of descendant streams in subtree of
|
|
|
|
|stream|. We assume that stream->effective_weight is already set
|
|
|
|
right. */
|
|
|
|
static void stream_update_dep_effective_weight(nghttp2_stream *stream)
|
2014-03-25 18:04:24 +01:00
|
|
|
{
|
2014-04-14 16:53:54 +02:00
|
|
|
nghttp2_stream *si;
|
2014-03-25 18:04:24 +01:00
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
DEBUGF(fprintf(stderr, "stream: update_dep_effective_weight "
|
2014-04-24 16:37:40 +02:00
|
|
|
"stream(%p)=%d, weight=%d, sum_norest_weight=%d\n",
|
|
|
|
stream, stream->stream_id, stream->weight,
|
|
|
|
stream->sum_norest_weight));
|
|
|
|
|
|
|
|
/* stream->sum_norest_weight == 0 means there is no
|
|
|
|
NGHTTP2_STREAM_DPRI_TOP under stream */
|
|
|
|
if(stream->dpri != NGHTTP2_STREAM_DPRI_NO_DATA ||
|
|
|
|
stream->sum_norest_weight == 0) {
|
|
|
|
return;
|
|
|
|
}
|
2014-03-25 18:04:24 +01:00
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
for(si = stream->dep_next; si; si = si->sib_next) {
|
2014-04-24 16:37:40 +02:00
|
|
|
if(si->dpri != NGHTTP2_STREAM_DPRI_REST) {
|
|
|
|
si->effective_weight = nghttp2_stream_dep_distributed_effective_weight
|
|
|
|
(stream, si->weight);
|
|
|
|
}
|
2014-03-25 18:04:24 +01:00
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
stream_update_dep_effective_weight(si);
|
|
|
|
}
|
2014-03-25 18:04:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void stream_update_dep_set_rest(nghttp2_stream *stream)
|
|
|
|
{
|
|
|
|
if(stream == NULL) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(stream->dpri == NGHTTP2_STREAM_DPRI_REST) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(stream->dpri == NGHTTP2_STREAM_DPRI_TOP) {
|
|
|
|
stream->dpri = NGHTTP2_STREAM_DPRI_REST;
|
|
|
|
|
|
|
|
stream_update_dep_set_rest(stream->sib_next);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
stream_update_dep_set_rest(stream->sib_next);
|
|
|
|
stream_update_dep_set_rest(stream->dep_next);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Performs dfs starting |stream|, search stream which can become
|
2014-04-02 15:55:49 +02:00
|
|
|
* NGHTTP2_STREAM_DPRI_TOP and queues its data_item.
|
2014-03-25 18:04:24 +01:00
|
|
|
*
|
2014-04-14 16:53:54 +02:00
|
|
|
* This function returns 0 if it succeeds, or one of the following
|
|
|
|
* negative error codes:
|
2014-03-25 18:04:24 +01:00
|
|
|
*
|
|
|
|
* NGHTTP2_ERR_NOMEM
|
|
|
|
* Out of memory.
|
|
|
|
*/
|
2014-05-08 16:07:29 +02:00
|
|
|
static int stream_update_dep_set_top(nghttp2_stream *stream, nghttp2_pq *pq,
|
|
|
|
uint64_t cycle)
|
2014-03-25 18:04:24 +01:00
|
|
|
{
|
2014-04-14 16:53:54 +02:00
|
|
|
int rv;
|
2014-04-24 16:37:40 +02:00
|
|
|
nghttp2_stream *si;
|
2014-03-25 18:04:24 +01:00
|
|
|
|
|
|
|
if(stream->dpri == NGHTTP2_STREAM_DPRI_TOP) {
|
2014-04-14 16:53:54 +02:00
|
|
|
return 0;
|
2014-03-25 18:04:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if(stream->dpri == NGHTTP2_STREAM_DPRI_REST) {
|
|
|
|
DEBUGF(fprintf(stderr, "stream: stream=%d data is top\n",
|
|
|
|
stream->stream_id));
|
|
|
|
|
2014-04-02 15:55:49 +02:00
|
|
|
if(!stream->data_item->queued) {
|
2014-05-08 16:07:29 +02:00
|
|
|
rv = stream_push_data(stream, pq, cycle);
|
2014-03-25 18:04:24 +01:00
|
|
|
|
|
|
|
if(rv != 0) {
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
stream->dpri = NGHTTP2_STREAM_DPRI_TOP;
|
|
|
|
|
2014-04-24 16:37:40 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
for(si = stream->dep_next; si; si = si->sib_next) {
|
2014-05-08 16:07:29 +02:00
|
|
|
rv = stream_update_dep_set_top(si, pq, cycle);
|
2014-03-31 15:51:33 +02:00
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
if(rv != 0) {
|
2014-03-31 15:51:33 +02:00
|
|
|
return rv;
|
|
|
|
}
|
2014-03-25 18:04:24 +01:00
|
|
|
}
|
|
|
|
|
2014-04-24 16:37:40 +02:00
|
|
|
return 0;
|
|
|
|
}
|
2014-03-25 18:04:24 +01:00
|
|
|
|
2014-04-24 16:37:40 +02:00
|
|
|
/*
|
|
|
|
* Updates stream->sum_norest_weight recursively. We have to gather
|
|
|
|
* effective sum of weight of descendants. If stream->dpri ==
|
|
|
|
* NGHTTP2_STREAM_DPRI_NO_DATA, we have to go deeper and check that
|
|
|
|
* any of its descendants has dpri value of NGHTTP2_STREAM_DPRI_TOP.
|
|
|
|
* If so, we have to add weight of its direct descendants to
|
|
|
|
* stream->sum_norest_weight. To make this work, this function
|
|
|
|
* returns 1 if any of its descendants has dpri value of
|
|
|
|
* NGHTTP2_STREAM_DPRI_TOP, otherwise 0.
|
|
|
|
*/
|
|
|
|
static int stream_update_dep_sum_norest_weight(nghttp2_stream *stream)
|
|
|
|
{
|
|
|
|
nghttp2_stream *si;
|
|
|
|
int rv;
|
2014-03-25 18:04:24 +01:00
|
|
|
|
2014-04-24 16:37:40 +02:00
|
|
|
stream->sum_norest_weight = 0;
|
|
|
|
|
|
|
|
if(stream->dpri == NGHTTP2_STREAM_DPRI_TOP) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(stream->dpri == NGHTTP2_STREAM_DPRI_REST) {
|
|
|
|
return 0;
|
2014-03-25 18:04:24 +01:00
|
|
|
}
|
|
|
|
|
2014-04-24 16:37:40 +02:00
|
|
|
rv = 0;
|
2014-03-31 15:51:33 +02:00
|
|
|
|
2014-04-24 16:37:40 +02:00
|
|
|
for(si = stream->dep_next; si; si = si->sib_next) {
|
|
|
|
|
|
|
|
if(stream_update_dep_sum_norest_weight(si)) {
|
|
|
|
rv = 1;
|
|
|
|
stream->sum_norest_weight += si->weight;
|
|
|
|
}
|
2014-03-31 15:51:33 +02:00
|
|
|
}
|
|
|
|
|
2014-04-24 16:37:40 +02:00
|
|
|
return rv;
|
2014-03-25 18:04:24 +01:00
|
|
|
}
|
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
static int stream_update_dep_on_attach_data(nghttp2_stream *stream,
|
2014-05-08 16:07:29 +02:00
|
|
|
nghttp2_pq *pq, uint64_t cycle)
|
2014-03-25 18:04:24 +01:00
|
|
|
{
|
2014-04-14 16:53:54 +02:00
|
|
|
int rv;
|
2014-03-25 18:04:24 +01:00
|
|
|
nghttp2_stream *root_stream;
|
|
|
|
|
|
|
|
stream->dpri = NGHTTP2_STREAM_DPRI_REST;
|
|
|
|
|
|
|
|
stream_update_dep_set_rest(stream->dep_next);
|
|
|
|
|
|
|
|
root_stream = nghttp2_stream_get_dep_root(stream);
|
|
|
|
|
|
|
|
DEBUGF(fprintf(stderr, "root=%p, stream=%p\n", root_stream, stream));
|
|
|
|
|
2014-05-08 16:07:29 +02:00
|
|
|
rv = stream_update_dep_set_top(root_stream, pq, cycle);
|
2014-03-25 18:04:24 +01:00
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
if(rv != 0) {
|
2014-03-25 18:04:24 +01:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2014-04-24 16:37:40 +02:00
|
|
|
stream_update_dep_sum_norest_weight(root_stream);
|
|
|
|
stream_update_dep_effective_weight(root_stream);
|
|
|
|
|
2014-03-25 18:04:24 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int stream_update_dep_on_detach_data(nghttp2_stream *stream,
|
2014-05-08 16:07:29 +02:00
|
|
|
nghttp2_pq *pq, uint64_t cycle)
|
2014-03-25 18:04:24 +01:00
|
|
|
{
|
2014-04-14 16:53:54 +02:00
|
|
|
int rv;
|
2014-03-31 15:51:33 +02:00
|
|
|
nghttp2_stream *root_stream;
|
|
|
|
|
2014-03-25 18:04:24 +01:00
|
|
|
stream->dpri = NGHTTP2_STREAM_DPRI_NO_DATA;
|
|
|
|
|
2014-03-31 15:51:33 +02:00
|
|
|
root_stream = nghttp2_stream_get_dep_root(stream);
|
|
|
|
|
2014-05-08 16:07:29 +02:00
|
|
|
rv = stream_update_dep_set_top(root_stream, pq, cycle);
|
2014-03-31 15:51:33 +02:00
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
if(rv != 0) {
|
2014-03-31 15:51:33 +02:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2014-04-24 16:37:40 +02:00
|
|
|
stream_update_dep_sum_norest_weight(root_stream);
|
|
|
|
stream_update_dep_effective_weight(root_stream);
|
|
|
|
|
2014-03-31 15:51:33 +02:00
|
|
|
return 0;
|
2014-03-25 18:04:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int nghttp2_stream_attach_data(nghttp2_stream *stream,
|
2014-04-02 15:55:49 +02:00
|
|
|
nghttp2_outbound_item *data_item,
|
2014-05-08 16:07:29 +02:00
|
|
|
nghttp2_pq *pq,
|
|
|
|
uint64_t cycle)
|
2014-03-25 18:04:24 +01:00
|
|
|
{
|
2014-04-02 15:55:49 +02:00
|
|
|
assert((stream->flags & NGHTTP2_STREAM_FLAG_DEFERRED_ALL) == 0);
|
2014-04-03 08:52:21 +02:00
|
|
|
assert(stream->data_item == NULL);
|
2014-03-25 18:04:24 +01:00
|
|
|
|
|
|
|
DEBUGF(fprintf(stderr, "stream: stream=%d attach data=%p\n",
|
2014-04-02 15:55:49 +02:00
|
|
|
stream->stream_id, data_item));
|
2014-03-25 18:04:24 +01:00
|
|
|
|
2014-04-03 08:52:21 +02:00
|
|
|
stream->data_item = data_item;
|
|
|
|
|
2014-05-08 16:07:29 +02:00
|
|
|
return stream_update_dep_on_attach_data(stream, pq, cycle);
|
2014-03-25 18:04:24 +01:00
|
|
|
}
|
|
|
|
|
2014-05-08 16:07:29 +02:00
|
|
|
int nghttp2_stream_detach_data(nghttp2_stream *stream, nghttp2_pq *pq,
|
|
|
|
uint64_t cycle)
|
2014-03-25 18:04:24 +01:00
|
|
|
{
|
|
|
|
DEBUGF(fprintf(stderr, "stream: stream=%d detach data=%p\n",
|
2014-04-02 15:55:49 +02:00
|
|
|
stream->stream_id, stream->data_item));
|
2014-03-25 18:04:24 +01:00
|
|
|
|
2014-04-02 15:55:49 +02:00
|
|
|
stream->data_item = NULL;
|
|
|
|
stream->flags &= ~NGHTTP2_STREAM_FLAG_DEFERRED_ALL;
|
2014-03-25 18:04:24 +01:00
|
|
|
|
2014-05-08 16:07:29 +02:00
|
|
|
return stream_update_dep_on_detach_data(stream, pq, cycle);
|
2014-03-25 18:04:24 +01:00
|
|
|
}
|
|
|
|
|
2014-04-03 08:48:19 +02:00
|
|
|
int nghttp2_stream_defer_data(nghttp2_stream *stream, uint8_t flags,
|
2014-05-08 16:07:29 +02:00
|
|
|
nghttp2_pq *pq, uint64_t cycle)
|
2012-02-19 15:42:25 +01:00
|
|
|
{
|
2014-04-02 15:55:49 +02:00
|
|
|
assert(stream->data_item);
|
2014-03-25 18:04:24 +01:00
|
|
|
|
2014-04-03 08:48:19 +02:00
|
|
|
DEBUGF(fprintf(stderr, "stream: stream=%d defer data=%p cause=%02x\n",
|
|
|
|
stream->stream_id, stream->data_item, flags));
|
|
|
|
|
2014-04-02 15:55:49 +02:00
|
|
|
stream->flags |= flags;
|
2014-04-03 08:48:19 +02:00
|
|
|
|
2014-05-08 16:07:29 +02:00
|
|
|
return stream_update_dep_on_detach_data(stream, pq, cycle);
|
2012-02-19 15:42:25 +01:00
|
|
|
}
|
|
|
|
|
2014-04-02 15:58:06 +02:00
|
|
|
int nghttp2_stream_resume_deferred_data(nghttp2_stream *stream,
|
2014-05-08 16:07:29 +02:00
|
|
|
nghttp2_pq *pq, uint64_t cycle)
|
2012-02-19 15:42:25 +01:00
|
|
|
{
|
2014-04-02 15:55:49 +02:00
|
|
|
assert(stream->data_item);
|
2014-03-25 18:04:24 +01:00
|
|
|
|
2014-04-03 08:52:21 +02:00
|
|
|
DEBUGF(fprintf(stderr, "stream: stream=%d resume data=%p\n",
|
|
|
|
stream->stream_id, stream->data_item));
|
|
|
|
|
2014-04-02 15:55:49 +02:00
|
|
|
stream->flags &= ~NGHTTP2_STREAM_FLAG_DEFERRED_ALL;
|
2014-03-25 18:04:24 +01:00
|
|
|
|
2014-05-08 16:07:29 +02:00
|
|
|
return stream_update_dep_on_attach_data(stream, pq, cycle);
|
2014-04-02 15:55:49 +02:00
|
|
|
}
|
2014-03-25 18:04:24 +01:00
|
|
|
|
2014-04-02 15:55:49 +02:00
|
|
|
int nghttp2_stream_check_deferred_data(nghttp2_stream *stream)
|
|
|
|
{
|
|
|
|
return stream->data_item &&
|
|
|
|
(stream->flags & NGHTTP2_STREAM_FLAG_DEFERRED_ALL);
|
|
|
|
}
|
|
|
|
|
|
|
|
int nghttp2_stream_check_deferred_by_flow_control(nghttp2_stream *stream)
|
|
|
|
{
|
|
|
|
return stream->data_item &&
|
|
|
|
(stream->flags & NGHTTP2_STREAM_FLAG_DEFERRED_FLOW_CONTROL);
|
2012-02-19 15:42:25 +01:00
|
|
|
}
|
2012-03-09 16:10:11 +01:00
|
|
|
|
2013-08-08 17:58:52 +02:00
|
|
|
static int update_initial_window_size
|
|
|
|
(int32_t *window_size_ptr,
|
2013-08-08 14:12:49 +02:00
|
|
|
int32_t new_initial_window_size,
|
|
|
|
int32_t old_initial_window_size)
|
2012-03-09 16:10:11 +01:00
|
|
|
{
|
2013-08-08 17:58:52 +02:00
|
|
|
int64_t new_window_size = (int64_t)(*window_size_ptr) +
|
2013-08-08 14:12:49 +02:00
|
|
|
new_initial_window_size - old_initial_window_size;
|
|
|
|
if(INT32_MIN > new_window_size ||
|
|
|
|
new_window_size > NGHTTP2_MAX_WINDOW_SIZE) {
|
|
|
|
return -1;
|
|
|
|
}
|
2014-06-11 16:37:16 +02:00
|
|
|
*window_size_ptr = (int32_t)new_window_size;
|
2013-08-08 14:12:49 +02:00
|
|
|
return 0;
|
2012-03-09 16:10:11 +01:00
|
|
|
}
|
2013-07-24 18:49:05 +02:00
|
|
|
|
2013-08-08 17:58:52 +02:00
|
|
|
int nghttp2_stream_update_remote_initial_window_size
|
|
|
|
(nghttp2_stream *stream,
|
|
|
|
int32_t new_initial_window_size,
|
|
|
|
int32_t old_initial_window_size)
|
|
|
|
{
|
|
|
|
return update_initial_window_size(&stream->remote_window_size,
|
|
|
|
new_initial_window_size,
|
|
|
|
old_initial_window_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
int nghttp2_stream_update_local_initial_window_size
|
|
|
|
(nghttp2_stream *stream,
|
|
|
|
int32_t new_initial_window_size,
|
|
|
|
int32_t old_initial_window_size)
|
|
|
|
{
|
|
|
|
return update_initial_window_size(&stream->local_window_size,
|
|
|
|
new_initial_window_size,
|
|
|
|
old_initial_window_size);
|
|
|
|
}
|
|
|
|
|
2013-07-24 18:49:05 +02:00
|
|
|
void nghttp2_stream_promise_fulfilled(nghttp2_stream *stream)
|
|
|
|
{
|
|
|
|
stream->state = NGHTTP2_STREAM_OPENED;
|
|
|
|
}
|
2014-03-25 18:04:24 +01:00
|
|
|
|
|
|
|
nghttp2_stream* nghttp2_stream_get_dep_root(nghttp2_stream *stream)
|
|
|
|
{
|
|
|
|
for(;;) {
|
|
|
|
if(stream->sib_prev) {
|
|
|
|
stream = stream->sib_prev;
|
|
|
|
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(stream->dep_prev) {
|
|
|
|
stream = stream->dep_prev;
|
|
|
|
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return stream;
|
|
|
|
}
|
|
|
|
|
|
|
|
int nghttp2_stream_dep_subtree_find(nghttp2_stream *stream,
|
|
|
|
nghttp2_stream *target)
|
|
|
|
{
|
|
|
|
if(stream == NULL) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(stream == target) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(nghttp2_stream_dep_subtree_find(stream->sib_next, target)) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return nghttp2_stream_dep_subtree_find(stream->dep_next, target);
|
|
|
|
}
|
|
|
|
|
|
|
|
void nghttp2_stream_dep_insert(nghttp2_stream *dep_stream,
|
|
|
|
nghttp2_stream *stream)
|
|
|
|
{
|
|
|
|
nghttp2_stream *si;
|
2014-04-24 16:37:40 +02:00
|
|
|
nghttp2_stream *root_stream;
|
2014-03-25 18:04:24 +01:00
|
|
|
|
2014-04-02 15:55:49 +02:00
|
|
|
assert(stream->data_item == NULL);
|
2014-03-25 18:04:24 +01:00
|
|
|
|
|
|
|
DEBUGF(fprintf(stderr,
|
|
|
|
"stream: dep_insert dep_stream(%p)=%d, stream(%p)=%d\n",
|
|
|
|
dep_stream, dep_stream->stream_id,
|
|
|
|
stream, stream->stream_id));
|
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
stream->sum_dep_weight = dep_stream->sum_dep_weight;
|
|
|
|
dep_stream->sum_dep_weight = stream->weight;
|
|
|
|
|
2014-03-25 18:04:24 +01:00
|
|
|
if(dep_stream->dep_next) {
|
|
|
|
for(si = dep_stream->dep_next; si; si = si->sib_next) {
|
|
|
|
stream->num_substreams += si->num_substreams;
|
|
|
|
}
|
|
|
|
|
|
|
|
stream->dep_next = dep_stream->dep_next;
|
|
|
|
stream->dep_next->dep_prev = stream;
|
|
|
|
}
|
|
|
|
|
|
|
|
dep_stream->dep_next = stream;
|
|
|
|
stream->dep_prev = dep_stream;
|
|
|
|
|
2014-04-24 16:37:40 +02:00
|
|
|
root_stream = stream_update_dep_length(dep_stream, 1);
|
|
|
|
|
|
|
|
stream_update_dep_sum_norest_weight(root_stream);
|
|
|
|
stream_update_dep_effective_weight(root_stream);
|
2014-04-17 14:15:14 +02:00
|
|
|
|
|
|
|
++stream->roots->num_streams;
|
2014-03-25 18:04:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void nghttp2_stream_dep_add(nghttp2_stream *dep_stream,
|
|
|
|
nghttp2_stream *stream)
|
|
|
|
{
|
|
|
|
nghttp2_stream *last_sib;
|
2014-04-24 16:37:40 +02:00
|
|
|
nghttp2_stream *root_stream;
|
2014-03-25 18:04:24 +01:00
|
|
|
|
2014-04-02 15:55:49 +02:00
|
|
|
assert(stream->data_item == NULL);
|
2014-03-25 18:04:24 +01:00
|
|
|
|
|
|
|
DEBUGF(fprintf(stderr,
|
|
|
|
"stream: dep_add dep_stream(%p)=%d, stream(%p)=%d\n",
|
|
|
|
dep_stream, dep_stream->stream_id,
|
|
|
|
stream, stream->stream_id));
|
|
|
|
|
2014-04-24 16:37:40 +02:00
|
|
|
root_stream = stream_update_dep_length(dep_stream, 1);
|
2014-03-25 18:04:24 +01:00
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
dep_stream->sum_dep_weight += stream->weight;
|
|
|
|
|
2014-03-25 18:04:24 +01:00
|
|
|
if(dep_stream->dep_next == NULL) {
|
|
|
|
dep_stream->dep_next = stream;
|
|
|
|
stream->dep_prev = dep_stream;
|
2014-04-14 16:53:54 +02:00
|
|
|
} else {
|
|
|
|
last_sib = stream_last_sib(dep_stream->dep_next);
|
|
|
|
last_sib->sib_next = stream;
|
|
|
|
stream->sib_prev = last_sib;
|
2014-03-25 18:04:24 +01:00
|
|
|
}
|
|
|
|
|
2014-04-24 16:37:40 +02:00
|
|
|
stream_update_dep_sum_norest_weight(root_stream);
|
|
|
|
stream_update_dep_effective_weight(root_stream);
|
2014-04-17 14:15:14 +02:00
|
|
|
|
|
|
|
++stream->roots->num_streams;
|
2014-03-25 18:04:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void nghttp2_stream_dep_remove(nghttp2_stream *stream)
|
|
|
|
{
|
2014-04-24 16:37:40 +02:00
|
|
|
nghttp2_stream *prev, *next, *dep_next, *dep_prev, *si, *root_stream;
|
2014-04-14 16:53:54 +02:00
|
|
|
int32_t sum_dep_weight_delta;
|
2014-03-25 18:04:24 +01:00
|
|
|
|
2014-04-24 16:37:40 +02:00
|
|
|
root_stream = NULL;
|
|
|
|
|
2014-03-25 18:04:24 +01:00
|
|
|
DEBUGF(fprintf(stderr, "stream: dep_remove stream(%p)=%d\n",
|
|
|
|
stream, stream->stream_id));
|
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
/* Distribute weight of |stream| to direct descendants */
|
|
|
|
sum_dep_weight_delta = -stream->weight;
|
|
|
|
|
|
|
|
for(si = stream->dep_next; si; si = si->sib_next) {
|
|
|
|
si->weight = nghttp2_stream_dep_distributed_weight(stream, si->weight);
|
|
|
|
|
|
|
|
sum_dep_weight_delta += si->weight;
|
|
|
|
}
|
|
|
|
|
2014-03-25 18:04:24 +01:00
|
|
|
prev = stream_first_sib(stream);
|
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
dep_prev = prev->dep_prev;
|
|
|
|
|
|
|
|
if(dep_prev) {
|
2014-04-24 16:37:40 +02:00
|
|
|
root_stream = stream_update_dep_length(dep_prev, -1);
|
2014-04-14 16:53:54 +02:00
|
|
|
|
|
|
|
dep_prev->sum_dep_weight += sum_dep_weight_delta;
|
2014-03-25 18:04:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if(stream->sib_prev) {
|
|
|
|
prev = stream->sib_prev;
|
|
|
|
dep_next = stream->dep_next;
|
|
|
|
|
|
|
|
if(dep_next) {
|
|
|
|
dep_next->dep_prev = NULL;
|
|
|
|
|
|
|
|
prev->sib_next = dep_next;
|
|
|
|
dep_next->sib_prev = prev;
|
|
|
|
} else {
|
|
|
|
next = stream->sib_next;
|
|
|
|
|
|
|
|
prev->sib_next = next;
|
|
|
|
|
|
|
|
if(next) {
|
|
|
|
next->sib_prev = prev;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if(stream->dep_prev) {
|
|
|
|
prev = stream->dep_prev;
|
|
|
|
dep_next = stream->dep_next;
|
|
|
|
|
|
|
|
if(dep_next) {
|
|
|
|
prev->dep_next = dep_next;
|
|
|
|
dep_next->dep_prev = prev;
|
|
|
|
} else if(stream->sib_next) {
|
|
|
|
next = stream->sib_next;
|
|
|
|
|
|
|
|
prev->dep_next = next;
|
|
|
|
next->dep_prev = prev;
|
|
|
|
|
|
|
|
next->sib_prev = NULL;
|
|
|
|
} else {
|
|
|
|
prev->dep_next = NULL;
|
|
|
|
dep_next = NULL;
|
|
|
|
}
|
|
|
|
} else {
|
2014-04-17 14:15:14 +02:00
|
|
|
nghttp2_stream_roots_remove(stream->roots, stream);
|
|
|
|
|
2014-03-25 18:04:24 +01:00
|
|
|
dep_next = NULL;
|
|
|
|
|
|
|
|
/* stream is a root of tree. Removing stream makes its
|
|
|
|
descendants a root of its own subtree. */
|
|
|
|
|
|
|
|
for(si = stream->dep_next; si;) {
|
|
|
|
next = si->sib_next;
|
|
|
|
|
|
|
|
si->dep_prev = NULL;
|
|
|
|
si->sib_prev = NULL;
|
|
|
|
si->sib_next = NULL;
|
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
/* We already distributed weight of |stream| to this. */
|
|
|
|
si->effective_weight = si->weight;
|
|
|
|
|
2014-04-17 14:15:14 +02:00
|
|
|
nghttp2_stream_roots_add(si->roots, si);
|
|
|
|
|
2014-03-25 18:04:24 +01:00
|
|
|
si = next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(dep_next && stream->sib_next) {
|
|
|
|
prev = stream_last_sib(dep_next);
|
|
|
|
next = stream->sib_next;
|
|
|
|
|
|
|
|
prev->sib_next = next;
|
|
|
|
next->sib_prev = prev;
|
|
|
|
}
|
|
|
|
|
2014-04-24 16:37:40 +02:00
|
|
|
if(root_stream) {
|
|
|
|
stream_update_dep_sum_norest_weight(root_stream);
|
|
|
|
stream_update_dep_effective_weight(root_stream);
|
2014-04-14 16:53:54 +02:00
|
|
|
}
|
|
|
|
|
2014-03-25 18:04:24 +01:00
|
|
|
stream->num_substreams = 1;
|
2014-04-14 16:53:54 +02:00
|
|
|
stream->sum_dep_weight = 0;
|
|
|
|
|
2014-03-25 18:04:24 +01:00
|
|
|
stream->dep_prev = NULL;
|
|
|
|
stream->dep_next = NULL;
|
|
|
|
stream->sib_prev = NULL;
|
|
|
|
stream->sib_next = NULL;
|
2014-04-17 14:15:14 +02:00
|
|
|
|
|
|
|
--stream->roots->num_streams;
|
2014-03-25 18:04:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int nghttp2_stream_dep_insert_subtree(nghttp2_stream *dep_stream,
|
|
|
|
nghttp2_stream *stream,
|
2014-05-08 16:07:29 +02:00
|
|
|
nghttp2_pq *pq,
|
|
|
|
uint64_t cycle)
|
2014-03-25 18:04:24 +01:00
|
|
|
{
|
|
|
|
nghttp2_stream *last_sib;
|
|
|
|
nghttp2_stream *dep_next;
|
|
|
|
nghttp2_stream *root_stream;
|
|
|
|
size_t delta_substreams;
|
2014-04-14 16:53:54 +02:00
|
|
|
int rv;
|
2014-03-25 18:04:24 +01:00
|
|
|
|
|
|
|
DEBUGF(fprintf(stderr, "stream: dep_insert_subtree dep_stream(%p)=%d "
|
|
|
|
"stream(%p)=%d\n",
|
|
|
|
dep_stream, dep_stream->stream_id,
|
|
|
|
stream, stream->stream_id));
|
|
|
|
|
|
|
|
delta_substreams = stream->num_substreams;
|
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
stream_update_dep_set_rest(stream);
|
2014-03-25 18:04:24 +01:00
|
|
|
|
|
|
|
if(dep_stream->dep_next) {
|
2014-04-14 16:53:54 +02:00
|
|
|
/* dep_stream->num_substreams includes dep_stream itself */
|
|
|
|
stream->num_substreams += dep_stream->num_substreams - 1;
|
2014-03-25 18:04:24 +01:00
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
stream->sum_dep_weight += dep_stream->sum_dep_weight;
|
|
|
|
dep_stream->sum_dep_weight = stream->weight;
|
|
|
|
|
|
|
|
dep_next = dep_stream->dep_next;
|
2014-03-25 18:04:24 +01:00
|
|
|
|
|
|
|
stream_update_dep_set_rest(dep_next);
|
|
|
|
|
|
|
|
dep_stream->dep_next = stream;
|
|
|
|
stream->dep_prev = dep_stream;
|
|
|
|
|
|
|
|
if(stream->dep_next) {
|
|
|
|
last_sib = stream_last_sib(stream->dep_next);
|
|
|
|
|
|
|
|
last_sib->sib_next = dep_next;
|
|
|
|
dep_next->sib_prev = last_sib;
|
|
|
|
|
|
|
|
dep_next->dep_prev = NULL;
|
|
|
|
} else {
|
|
|
|
stream->dep_next = dep_next;
|
|
|
|
dep_next->dep_prev = stream;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
dep_stream->dep_next = stream;
|
|
|
|
stream->dep_prev = dep_stream;
|
2014-04-14 16:53:54 +02:00
|
|
|
|
|
|
|
assert(dep_stream->sum_dep_weight == 0);
|
|
|
|
dep_stream->sum_dep_weight = stream->weight;
|
2014-03-25 18:04:24 +01:00
|
|
|
}
|
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
root_stream = stream_update_dep_length(dep_stream, delta_substreams);
|
2014-03-31 15:51:33 +02:00
|
|
|
|
2014-05-08 16:07:29 +02:00
|
|
|
rv = stream_update_dep_set_top(root_stream, pq, cycle);
|
2014-03-31 15:51:33 +02:00
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
if(rv != 0) {
|
2014-03-31 15:51:33 +02:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2014-04-24 16:37:40 +02:00
|
|
|
stream_update_dep_sum_norest_weight(root_stream);
|
|
|
|
stream_update_dep_effective_weight(root_stream);
|
|
|
|
|
2014-03-31 15:51:33 +02:00
|
|
|
return 0;
|
2014-03-25 18:04:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int nghttp2_stream_dep_add_subtree(nghttp2_stream *dep_stream,
|
|
|
|
nghttp2_stream *stream,
|
2014-05-08 16:07:29 +02:00
|
|
|
nghttp2_pq *pq,
|
|
|
|
uint64_t cycle)
|
2014-03-25 18:04:24 +01:00
|
|
|
{
|
|
|
|
nghttp2_stream *last_sib;
|
|
|
|
nghttp2_stream *root_stream;
|
2014-04-14 16:53:54 +02:00
|
|
|
int rv;
|
2014-03-25 18:04:24 +01:00
|
|
|
|
|
|
|
DEBUGF(fprintf(stderr, "stream: dep_add_subtree dep_stream(%p)=%d "
|
|
|
|
"stream(%p)=%d\n",
|
|
|
|
dep_stream, dep_stream->stream_id,
|
|
|
|
stream, stream->stream_id));
|
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
stream_update_dep_set_rest(stream);
|
2014-03-25 18:04:24 +01:00
|
|
|
|
|
|
|
if(dep_stream->dep_next) {
|
2014-04-14 16:53:54 +02:00
|
|
|
dep_stream->sum_dep_weight += stream->weight;
|
|
|
|
|
2014-03-25 18:04:24 +01:00
|
|
|
last_sib = stream_last_sib(dep_stream->dep_next);
|
|
|
|
|
|
|
|
last_sib->sib_next = stream;
|
|
|
|
stream->sib_prev = last_sib;
|
|
|
|
} else {
|
|
|
|
dep_stream->dep_next = stream;
|
|
|
|
stream->dep_prev = dep_stream;
|
2014-04-14 16:53:54 +02:00
|
|
|
|
|
|
|
assert(dep_stream->sum_dep_weight == 0);
|
|
|
|
dep_stream->sum_dep_weight = stream->weight;
|
2014-03-25 18:04:24 +01:00
|
|
|
}
|
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
root_stream = stream_update_dep_length(dep_stream, stream->num_substreams);
|
2014-03-31 15:51:33 +02:00
|
|
|
|
2014-05-08 16:07:29 +02:00
|
|
|
rv = stream_update_dep_set_top(root_stream, pq, cycle);
|
2014-03-31 15:51:33 +02:00
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
if(rv != 0) {
|
2014-03-31 15:51:33 +02:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2014-04-24 16:37:40 +02:00
|
|
|
stream_update_dep_sum_norest_weight(root_stream);
|
|
|
|
stream_update_dep_effective_weight(root_stream);
|
|
|
|
|
2014-03-31 15:51:33 +02:00
|
|
|
return 0;
|
2014-03-25 18:04:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void nghttp2_stream_dep_remove_subtree(nghttp2_stream *stream)
|
|
|
|
{
|
2014-04-24 16:37:40 +02:00
|
|
|
nghttp2_stream *prev, *next, *dep_prev, *root_stream;
|
2014-03-25 18:04:24 +01:00
|
|
|
|
2014-03-31 15:51:33 +02:00
|
|
|
DEBUGF(fprintf(stderr, "stream: dep_remove_subtree stream(%p)=%d\n",
|
|
|
|
stream, stream->stream_id));
|
|
|
|
|
2014-03-25 18:04:24 +01:00
|
|
|
if(stream->sib_prev) {
|
|
|
|
prev = stream->sib_prev;
|
|
|
|
|
|
|
|
prev->sib_next = stream->sib_next;
|
|
|
|
if(prev->sib_next) {
|
|
|
|
prev->sib_next->sib_prev = prev;
|
|
|
|
}
|
|
|
|
|
|
|
|
prev = stream_first_sib(prev);
|
2014-04-14 16:53:54 +02:00
|
|
|
|
|
|
|
dep_prev = prev->dep_prev;
|
|
|
|
|
2014-03-25 18:04:24 +01:00
|
|
|
} else if(stream->dep_prev) {
|
2014-04-14 16:53:54 +02:00
|
|
|
dep_prev = stream->dep_prev;
|
2014-03-25 18:04:24 +01:00
|
|
|
next = stream->sib_next;
|
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
dep_prev->dep_next = next;
|
2014-03-25 18:04:24 +01:00
|
|
|
|
|
|
|
if(next) {
|
2014-04-14 16:53:54 +02:00
|
|
|
next->dep_prev = dep_prev;
|
2014-03-25 18:04:24 +01:00
|
|
|
|
|
|
|
next->sib_prev = NULL;
|
|
|
|
}
|
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
} else {
|
2014-04-17 14:15:14 +02:00
|
|
|
nghttp2_stream_roots_remove(stream->roots, stream);
|
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
dep_prev = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(dep_prev) {
|
|
|
|
dep_prev->sum_dep_weight -= stream->weight;
|
|
|
|
|
2014-04-24 16:37:40 +02:00
|
|
|
root_stream = stream_update_dep_length(dep_prev, -stream->num_substreams);
|
2014-04-14 16:53:54 +02:00
|
|
|
|
2014-04-24 16:37:40 +02:00
|
|
|
stream_update_dep_sum_norest_weight(root_stream);
|
|
|
|
stream_update_dep_effective_weight(root_stream);
|
2014-03-25 18:04:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
stream->sib_prev = NULL;
|
|
|
|
stream->sib_next = NULL;
|
|
|
|
stream->dep_prev = NULL;
|
|
|
|
}
|
|
|
|
|
2014-05-08 16:07:29 +02:00
|
|
|
int nghttp2_stream_dep_make_root(nghttp2_stream *stream, nghttp2_pq *pq,
|
|
|
|
uint64_t cycle)
|
2014-03-25 18:04:24 +01:00
|
|
|
{
|
2014-04-14 16:53:54 +02:00
|
|
|
int rv;
|
2014-03-31 15:51:33 +02:00
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
DEBUGF(fprintf(stderr, "stream: dep_make_root stream(%p)=%d\n",
|
2014-03-31 15:51:33 +02:00
|
|
|
stream, stream->stream_id));
|
|
|
|
|
2014-04-17 14:15:14 +02:00
|
|
|
nghttp2_stream_roots_add(stream->roots, stream);
|
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
stream_update_dep_set_rest(stream);
|
|
|
|
|
|
|
|
stream->effective_weight = stream->weight;
|
2014-03-31 15:51:33 +02:00
|
|
|
|
2014-05-08 16:07:29 +02:00
|
|
|
rv = stream_update_dep_set_top(stream, pq, cycle);
|
2014-03-31 15:51:33 +02:00
|
|
|
|
2014-04-14 16:53:54 +02:00
|
|
|
if(rv != 0) {
|
2014-03-31 15:51:33 +02:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2014-04-24 16:37:40 +02:00
|
|
|
stream_update_dep_sum_norest_weight(stream);
|
|
|
|
stream_update_dep_effective_weight(stream);
|
|
|
|
|
2014-03-31 15:51:33 +02:00
|
|
|
return 0;
|
2014-03-25 18:04:24 +01:00
|
|
|
}
|
2014-04-17 14:15:14 +02:00
|
|
|
|
|
|
|
int nghttp2_stream_dep_all_your_stream_are_belong_to_us
|
2014-05-08 16:07:29 +02:00
|
|
|
(nghttp2_stream *stream, nghttp2_pq *pq, uint64_t cycle)
|
2014-04-17 14:15:14 +02:00
|
|
|
{
|
|
|
|
nghttp2_stream *first, *si;
|
|
|
|
|
|
|
|
DEBUGF(fprintf(stderr, "stream: ALL YOUR STREAM ARE BELONG TO US "
|
|
|
|
"stream(%p)=%d\n",
|
|
|
|
stream, stream->stream_id));
|
|
|
|
|
|
|
|
first = stream->roots->head;
|
|
|
|
|
|
|
|
/* stream must not be include in stream->roots->head list */
|
|
|
|
assert(first != stream);
|
|
|
|
|
|
|
|
if(first) {
|
|
|
|
nghttp2_stream *prev;
|
|
|
|
|
|
|
|
prev = first;
|
|
|
|
|
|
|
|
DEBUGF(fprintf(stderr, "stream: root stream(%p)=%d\n",
|
|
|
|
first, first->stream_id));
|
|
|
|
|
|
|
|
stream->sum_dep_weight += first->weight;
|
|
|
|
stream->num_substreams += first->num_substreams;
|
|
|
|
|
|
|
|
for(si = first->root_next; si; si = si->root_next) {
|
|
|
|
|
|
|
|
assert(si != stream);
|
|
|
|
|
|
|
|
DEBUGF(fprintf(stderr, "stream: root stream(%p)=%d\n",
|
|
|
|
si, si->stream_id));
|
|
|
|
|
|
|
|
stream->sum_dep_weight += si->weight;
|
|
|
|
stream->num_substreams += si->num_substreams;
|
|
|
|
|
|
|
|
si->sib_prev = prev;
|
|
|
|
prev->sib_next = si;
|
|
|
|
|
|
|
|
prev = si;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(stream->dep_next) {
|
|
|
|
nghttp2_stream *last_sib;
|
|
|
|
|
|
|
|
last_sib = stream_last_sib(stream->dep_next);
|
|
|
|
|
|
|
|
last_sib->sib_next = first;
|
|
|
|
first->sib_prev = last_sib;
|
|
|
|
} else {
|
|
|
|
stream->dep_next = first;
|
|
|
|
first->dep_prev = stream;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
nghttp2_stream_roots_remove_all(stream->roots);
|
|
|
|
|
2014-05-08 16:07:29 +02:00
|
|
|
return nghttp2_stream_dep_make_root(stream, pq, cycle);
|
2014-04-17 14:15:14 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int nghttp2_stream_in_dep_tree(nghttp2_stream *stream)
|
|
|
|
{
|
|
|
|
return stream->dep_prev || stream->dep_next ||
|
|
|
|
stream->sib_prev || stream->sib_next ||
|
|
|
|
stream->root_next || stream->root_prev ||
|
|
|
|
stream->roots->head == stream;
|
|
|
|
}
|
|
|
|
|
|
|
|
void nghttp2_stream_roots_init(nghttp2_stream_roots *roots)
|
|
|
|
{
|
|
|
|
roots->head = NULL;
|
|
|
|
roots->num_streams = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void nghttp2_stream_roots_free(nghttp2_stream_roots *roots)
|
|
|
|
{}
|
|
|
|
|
|
|
|
void nghttp2_stream_roots_add(nghttp2_stream_roots *roots,
|
|
|
|
nghttp2_stream *stream)
|
|
|
|
{
|
|
|
|
if(roots->head) {
|
|
|
|
stream->root_next = roots->head;
|
|
|
|
roots->head->root_prev = stream;
|
|
|
|
}
|
|
|
|
|
|
|
|
roots->head = stream;
|
|
|
|
}
|
|
|
|
|
|
|
|
void nghttp2_stream_roots_remove(nghttp2_stream_roots *roots,
|
|
|
|
nghttp2_stream *stream)
|
|
|
|
{
|
|
|
|
nghttp2_stream *root_prev, *root_next;
|
|
|
|
|
|
|
|
root_prev = stream->root_prev;
|
|
|
|
root_next = stream->root_next;
|
|
|
|
|
|
|
|
if(root_prev) {
|
|
|
|
root_prev->root_next = root_next;
|
|
|
|
|
|
|
|
if(root_next) {
|
|
|
|
root_next->root_prev = root_prev;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if(root_next) {
|
|
|
|
root_next->root_prev = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
roots->head = root_next;
|
|
|
|
}
|
|
|
|
|
|
|
|
stream->root_prev = NULL;
|
|
|
|
stream->root_next = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void nghttp2_stream_roots_remove_all(nghttp2_stream_roots *roots)
|
|
|
|
{
|
|
|
|
nghttp2_stream *si, *next;
|
|
|
|
|
|
|
|
for(si = roots->head; si;) {
|
|
|
|
next = si->root_next;
|
|
|
|
|
|
|
|
si->root_prev = NULL;
|
|
|
|
si->root_next = NULL;
|
|
|
|
|
|
|
|
si = next;
|
|
|
|
}
|
|
|
|
|
|
|
|
roots->head = NULL;
|
|
|
|
}
|