#include "nghttp2_session.h"

#include <string.h>

#include <stddef.h>

#include <stdio.h>

#include <assert.h>

#include <stdarg.h>

#include "nghttp2_helper.h"

#include "nghttp2_net.h"

#include "nghttp2_priority_spec.h"

#include "nghttp2_option.h"

#include "nghttp2_http.h"

#include "nghttp2_pq.h"

#include "nghttp2_debug.h"

static int

session_is_outgoing_concurrent_streams_max(nghttp2_session *session) {

return session->remote_settings.max_concurrent_streams <=

session->num_outgoing_streams;

}

static int

session_is_incoming_concurrent_streams_max(nghttp2_session *session) {

return session->local_settings.max_concurrent_streams <=

session->num_incoming_streams;

}

static int

session_is_incoming_concurrent_streams_pending_max(nghttp2_session *session) {

return session->pending_local_max_concurrent_stream <=

session->num_incoming_streams;

}

static int is_non_fatal(int lib_error_code) {

return lib_error_code < 0 && lib_error_code > NGHTTP2_ERR_FATAL;

}

int nghttp2_is_fatal(int lib_error_code) {

return lib_error_code < NGHTTP2_ERR_FATAL;

}

static int session_enforce_http_messaging(nghttp2_session *session) {

return (session->opt_flags & NGHTTP2_OPTMASK_NO_HTTP_MESSAGING) == 0;

}

static int session_trailer_headers(nghttp2_session *session,

nghttp2_stream *stream,

nghttp2_frame *frame) {

if (!stream || frame->hd.type != NGHTTP2_HEADERS) {

return 0;

}

if (session->server) {

return frame->headers.cat == NGHTTP2_HCAT_HEADERS;

}

return frame->headers.cat == NGHTTP2_HCAT_HEADERS &&

(stream->http_flags & NGHTTP2_HTTP_FLAG_EXPECT_FINAL_RESPONSE) == 0;

}

static int state_reserved_remote(nghttp2_session *session,

nghttp2_stream *stream) {

return stream->state == NGHTTP2_STREAM_RESERVED &&

!nghttp2_session_is_my_stream_id(session, stream->stream_id);

}

static int state_reserved_local(nghttp2_session *session,

nghttp2_stream *stream) {

return stream->state == NGHTTP2_STREAM_RESERVED &&

nghttp2_session_is_my_stream_id(session, stream->stream_id);

}

static int session_is_new_peer_stream_id(nghttp2_session *session,

int32_t stream_id) {

return stream_id != 0 &&

!nghttp2_session_is_my_stream_id(session, stream_id) &&

session->last_recv_stream_id < stream_id;

}

static int session_detect_idle_stream(nghttp2_session *session,

int32_t stream_id) {

/* Assume that stream object with stream_id does not exist */

if (nghttp2_session_is_my_stream_id(session, stream_id)) {

if (session->last_sent_stream_id < stream_id) {

return 1;

}

return 0;

}

if (session_is_new_peer_stream_id(session, stream_id)) {

return 1;

}

return 0;

}

static int check_ext_type_set(const uint8_t *ext_types, uint8_t type) {

return (ext_types[type / 8] & (1 << (type & 0x7))) > 0;

}

static int session_call_error_callback(nghttp2_session *session,

int lib_error_code, const char *fmt,

...) {

size_t bufsize;

va_list ap;

char *buf;

int rv;

nghttp2_mem *mem;

if (!session->callbacks.error_callback &&

!session->callbacks.error_callback2) {

return 0;

}

mem = &session->mem;

va_start(ap, fmt);

rv = vsnprintf(NULL, 0, fmt, ap);

va_end(ap);

if (rv < 0) {

return NGHTTP2_ERR_NOMEM;

}

bufsize = (size_t)(rv + 1);

buf = nghttp2_mem_malloc(mem, bufsize);

if (buf == NULL) {

return NGHTTP2_ERR_NOMEM;

}

va_start(ap, fmt);

rv = vsnprintf(buf, bufsize, fmt, ap);

va_end(ap);

if (rv < 0) {

nghttp2_mem_free(mem, buf);

/* vsnprintf may return error because of various things we can

DEBUGF("error_callback: vsnprintf failed. The template was %s\n", fmt);

return 0;

}

if (session->callbacks.error_callback2) {

rv = session->callbacks.error_callback2(session, lib_error_code, buf,

(size_t)rv, session->user_data);

} else {

rv = session->callbacks.error_callback(session, buf, (size_t)rv,

session->user_data);

}

nghttp2_mem_free(mem, buf);

if (rv != 0) {

return NGHTTP2_ERR_CALLBACK_FAILURE;

}

return 0;

}

static int session_terminate_session(nghttp2_session *session,

int32_t last_stream_id,

uint32_t error_code, const char *reason) {

int rv;

const uint8_t *debug_data;

size_t debug_datalen;

if (session->goaway_flags & NGHTTP2_GOAWAY_TERM_ON_SEND) {

return 0;

}

/* Ignore all incoming frames because we are going to tear down the

session->iframe.state = NGHTTP2_IB_IGN_ALL;

if (reason == NULL) {

debug_data = NULL;

debug_datalen = 0;

} else {

debug_data = (const uint8_t *)reason;

debug_datalen = strlen(reason);

}

rv = nghttp2_session_add_goaway(session, last_stream_id, error_code,

debug_data, debug_datalen,

NGHTTP2_GOAWAY_AUX_TERM_ON_SEND);

if (rv != 0) {

return rv;

}

session->goaway_flags |= NGHTTP2_GOAWAY_TERM_ON_SEND;

return 0;

}

int nghttp2_session_terminate_session(nghttp2_session *session,

uint32_t error_code) {

return session_terminate_session(session, session->last_proc_stream_id,

error_code, NULL);

}

int nghttp2_session_terminate_session2(nghttp2_session *session,

int32_t last_stream_id,

uint32_t error_code) {

return session_terminate_session(session, last_stream_id, error_code, NULL);

}

int nghttp2_session_terminate_session_with_reason(nghttp2_session *session,

uint32_t error_code,

const char *reason) {

return session_terminate_session(session, session->last_proc_stream_id,

error_code, reason);

}

int nghttp2_session_is_my_stream_id(nghttp2_session *session,

int32_t stream_id) {

int rem;

if (stream_id == 0) {

return 0;

}

rem = stream_id & 0x1;

if (session->server) {

return rem == 0;

}

return rem == 1;

}

nghttp2_stream *nghttp2_session_get_stream(nghttp2_session *session,

int32_t stream_id) {

nghttp2_stream *stream;

stream = (nghttp2_stream *)nghttp2_map_find(&session->streams, stream_id);

if (stream == NULL || (stream->flags & NGHTTP2_STREAM_FLAG_CLOSED) ||

stream->state == NGHTTP2_STREAM_IDLE) {

return NULL;

}

return stream;

}

nghttp2_stream *nghttp2_session_get_stream_raw(nghttp2_session *session,

int32_t stream_id) {

return (nghttp2_stream *)nghttp2_map_find(&session->streams, stream_id);

}

static void session_inbound_frame_reset(nghttp2_session *session) {

nghttp2_inbound_frame *iframe = &session->iframe;

nghttp2_mem *mem = &session->mem;

/* A bit risky code, since if this function is called from

switch (iframe->frame.hd.type) {

case NGHTTP2_DATA:

break;

case NGHTTP2_HEADERS:

nghttp2_frame_headers_free(&iframe->frame.headers, mem);

break;

case NGHTTP2_PRIORITY:

nghttp2_frame_priority_free(&iframe->frame.priority);

break;

case NGHTTP2_RST_STREAM:

nghttp2_frame_rst_stream_free(&iframe->frame.rst_stream);

break;

case NGHTTP2_SETTINGS:

nghttp2_frame_settings_free(&iframe->frame.settings, mem);

nghttp2_mem_free(mem, iframe->iv);

iframe->iv = NULL;

iframe->niv = 0;

iframe->max_niv = 0;

break;

case NGHTTP2_PUSH_PROMISE:

nghttp2_frame_push_promise_free(&iframe->frame.push_promise, mem);

break;

case NGHTTP2_PING:

nghttp2_frame_ping_free(&iframe->frame.ping);

break;

case NGHTTP2_GOAWAY:

nghttp2_frame_goaway_free(&iframe->frame.goaway, mem);

break;

case NGHTTP2_WINDOW_UPDATE:

nghttp2_frame_window_update_free(&iframe->frame.window_update);

break;

default:

/* extension frame */

if (check_ext_type_set(session->user_recv_ext_types,

iframe->frame.hd.type)) {

nghttp2_frame_extension_free(&iframe->frame.ext);

} else {

switch (iframe->frame.hd.type) {

case NGHTTP2_ALTSVC:

if ((session->builtin_recv_ext_types & NGHTTP2_TYPEMASK_ALTSVC) == 0) {

break;

}

nghttp2_frame_altsvc_free(&iframe->frame.ext, mem);

break;

case NGHTTP2_ORIGIN:

if ((session->builtin_recv_ext_types & NGHTTP2_TYPEMASK_ORIGIN) == 0) {

break;

}

nghttp2_frame_origin_free(&iframe->frame.ext, mem);

break;

}

}

break;

}

memset(&iframe->frame, 0, sizeof(nghttp2_frame));

memset(&iframe->ext_frame_payload, 0, sizeof(nghttp2_ext_frame_payload));

iframe->state = NGHTTP2_IB_READ_HEAD;

nghttp2_buf_wrap_init(&iframe->sbuf, iframe->raw_sbuf,

sizeof(iframe->raw_sbuf));

iframe->sbuf.mark += NGHTTP2_FRAME_HDLEN;

nghttp2_buf_free(&iframe->lbuf, mem);

nghttp2_buf_wrap_init(&iframe->lbuf, NULL, 0);

iframe->raw_lbuf = NULL;

iframe->payloadleft = 0;

iframe->padlen = 0;

}

static void init_settings(nghttp2_settings_storage *settings) {

settings->header_table_size = NGHTTP2_HD_DEFAULT_MAX_BUFFER_SIZE;

settings->enable_push = 1;

settings->max_concurrent_streams = NGHTTP2_DEFAULT_MAX_CONCURRENT_STREAMS;

settings->initial_window_size = NGHTTP2_INITIAL_WINDOW_SIZE;

settings->max_frame_size = NGHTTP2_MAX_FRAME_SIZE_MIN;

settings->max_header_list_size = UINT32_MAX;

}

static void active_outbound_item_reset(nghttp2_active_outbound_item *aob,

nghttp2_mem *mem) {

DEBUGF("send: reset nghttp2_active_outbound_item\n");

DEBUGF("send: aob->item = %p\n", aob->item);

nghttp2_outbound_item_free(aob->item, mem);

nghttp2_mem_free(mem, aob->item);

aob->item = NULL;

nghttp2_bufs_reset(&aob->framebufs);

aob->state = NGHTTP2_OB_POP_ITEM;

}

int nghttp2_enable_strict_preface = 1;

static int session_new(nghttp2_session **session_ptr,

const nghttp2_session_callbacks *callbacks,

void *user_data, int server,

const nghttp2_option *option, nghttp2_mem *mem) {

int rv;

size_t nbuffer;

size_t max_deflate_dynamic_table_size =

NGHTTP2_HD_DEFAULT_MAX_DEFLATE_BUFFER_SIZE;

if (mem == NULL) {

mem = nghttp2_mem_default();

}

*session_ptr = nghttp2_mem_calloc(mem, 1, sizeof(nghttp2_session));

if (*session_ptr == NULL) {

rv = NGHTTP2_ERR_NOMEM;

goto fail_session;

}

(*session_ptr)->mem = *mem;

mem = &(*session_ptr)->mem;

/* next_stream_id is initialized in either

nghttp2_stream_init(&(*session_ptr)->root, 0, NGHTTP2_STREAM_FLAG_NONE,

NGHTTP2_STREAM_IDLE, NGHTTP2_DEFAULT_WEIGHT, 0, 0, NULL,

mem);

(*session_ptr)->remote_window_size = NGHTTP2_INITIAL_CONNECTION_WINDOW_SIZE;

(*session_ptr)->recv_window_size = 0;

(*session_ptr)->consumed_size = 0;

(*session_ptr)->recv_reduction = 0;

(*session_ptr)->local_window_size = NGHTTP2_INITIAL_CONNECTION_WINDOW_SIZE;

(*session_ptr)->goaway_flags = NGHTTP2_GOAWAY_NONE;

(*session_ptr)->local_last_stream_id = (1u << 31) - 1;

(*session_ptr)->remote_last_stream_id = (1u << 31) - 1;

(*session_ptr)->pending_local_max_concurrent_stream =

NGHTTP2_DEFAULT_MAX_CONCURRENT_STREAMS;

(*session_ptr)->pending_enable_push = 1;

if (server) {

(*session_ptr)->server = 1;

}

init_settings(&(*session_ptr)->remote_settings);

init_settings(&(*session_ptr)->local_settings);

(*session_ptr)->max_incoming_reserved_streams =

NGHTTP2_MAX_INCOMING_RESERVED_STREAMS;

/* Limit max outgoing concurrent streams to sensible value */

(*session_ptr)->remote_settings.max_concurrent_streams = 100;

(*session_ptr)->max_send_header_block_length = NGHTTP2_MAX_HEADERSLEN;

(*session_ptr)->max_outbound_ack = NGHTTP2_DEFAULT_MAX_OBQ_FLOOD_ITEM;

(*session_ptr)->max_settings = NGHTTP2_DEFAULT_MAX_SETTINGS;

if (option) {

if ((option->opt_set_mask & NGHTTP2_OPT_NO_AUTO_WINDOW_UPDATE) &&

option->no_auto_window_update) {

(*session_ptr)->opt_flags |= NGHTTP2_OPTMASK_NO_AUTO_WINDOW_UPDATE;

}

if (option->opt_set_mask & NGHTTP2_OPT_PEER_MAX_CONCURRENT_STREAMS) {

(*session_ptr)->remote_settings.max_concurrent_streams =

option->peer_max_concurrent_streams;

}

if (option->opt_set_mask & NGHTTP2_OPT_MAX_RESERVED_REMOTE_STREAMS) {

(*session_ptr)->max_incoming_reserved_streams =

option->max_reserved_remote_streams;

}

if ((option->opt_set_mask & NGHTTP2_OPT_NO_RECV_CLIENT_MAGIC) &&

option->no_recv_client_magic) {

(*session_ptr)->opt_flags |= NGHTTP2_OPTMASK_NO_RECV_CLIENT_MAGIC;

}

if ((option->opt_set_mask & NGHTTP2_OPT_NO_HTTP_MESSAGING) &&

option->no_http_messaging) {

(*session_ptr)->opt_flags |= NGHTTP2_OPTMASK_NO_HTTP_MESSAGING;

}

if (option->opt_set_mask & NGHTTP2_OPT_USER_RECV_EXT_TYPES) {

memcpy((*session_ptr)->user_recv_ext_types, option->user_recv_ext_types,

sizeof((*session_ptr)->user_recv_ext_types));

}

if (option->opt_set_mask & NGHTTP2_OPT_BUILTIN_RECV_EXT_TYPES) {

(*session_ptr)->builtin_recv_ext_types = option->builtin_recv_ext_types;

}

if ((option->opt_set_mask & NGHTTP2_OPT_NO_AUTO_PING_ACK) &&

option->no_auto_ping_ack) {

(*session_ptr)->opt_flags |= NGHTTP2_OPTMASK_NO_AUTO_PING_ACK;

}

if (option->opt_set_mask & NGHTTP2_OPT_MAX_SEND_HEADER_BLOCK_LENGTH) {

(*session_ptr)->max_send_header_block_length =

option->max_send_header_block_length;

}

if (option->opt_set_mask & NGHTTP2_OPT_MAX_DEFLATE_DYNAMIC_TABLE_SIZE) {

max_deflate_dynamic_table_size = option->max_deflate_dynamic_table_size;

}

if ((option->opt_set_mask & NGHTTP2_OPT_NO_CLOSED_STREAMS) &&

option->no_closed_streams) {

(*session_ptr)->opt_flags |= NGHTTP2_OPTMASK_NO_CLOSED_STREAMS;

}

if (option->opt_set_mask & NGHTTP2_OPT_MAX_OUTBOUND_ACK) {

(*session_ptr)->max_outbound_ack = option->max_outbound_ack;

}

if ((option->opt_set_mask & NGHTTP2_OPT_MAX_SETTINGS) &&

option->max_settings) {

(*session_ptr)->max_settings = option->max_settings;

}

}

rv = nghttp2_hd_deflate_init2(&(*session_ptr)->hd_deflater,

max_deflate_dynamic_table_size, mem);

if (rv != 0) {

goto fail_hd_deflater;

}

rv = nghttp2_hd_inflate_init(&(*session_ptr)->hd_inflater, mem);

if (rv != 0) {

goto fail_hd_inflater;

}

rv = nghttp2_map_init(&(*session_ptr)->streams, mem);

if (rv != 0) {

goto fail_map;

}

nbuffer = ((*session_ptr)->max_send_header_block_length +

NGHTTP2_FRAMEBUF_CHUNKLEN - 1) /

NGHTTP2_FRAMEBUF_CHUNKLEN;

if (nbuffer == 0) {

nbuffer = 1;

}

/* 1 for Pad Field. */

rv = nghttp2_bufs_init3(&(*session_ptr)->aob.framebufs,

NGHTTP2_FRAMEBUF_CHUNKLEN, nbuffer, 1,

NGHTTP2_FRAME_HDLEN + 1, mem);

if (rv != 0) {

goto fail_aob_framebuf;

}

active_outbound_item_reset(&(*session_ptr)->aob, mem);

(*session_ptr)->callbacks = *callbacks;

(*session_ptr)->user_data = user_data;

session_inbound_frame_reset(*session_ptr);

if (nghttp2_enable_strict_preface) {

nghttp2_inbound_frame *iframe = &(*session_ptr)->iframe;

if (server && ((*session_ptr)->opt_flags &

NGHTTP2_OPTMASK_NO_RECV_CLIENT_MAGIC) == 0) {

iframe->state = NGHTTP2_IB_READ_CLIENT_MAGIC;

iframe->payloadleft = NGHTTP2_CLIENT_MAGIC_LEN;

} else {

iframe->state = NGHTTP2_IB_READ_FIRST_SETTINGS;

}

if (!server) {

(*session_ptr)->aob.state = NGHTTP2_OB_SEND_CLIENT_MAGIC;

nghttp2_bufs_add(&(*session_ptr)->aob.framebufs, NGHTTP2_CLIENT_MAGIC,

NGHTTP2_CLIENT_MAGIC_LEN);

}

}

return 0;

fail_aob_framebuf:

nghttp2_map_free(&(*session_ptr)->streams);

fail_map:

nghttp2_hd_inflate_free(&(*session_ptr)->hd_inflater);

fail_hd_inflater:

nghttp2_hd_deflate_free(&(*session_ptr)->hd_deflater);

fail_hd_deflater:

nghttp2_mem_free(mem, *session_ptr);

fail_session:

return rv;

}

int nghttp2_session_client_new(nghttp2_session **session_ptr,

const nghttp2_session_callbacks *callbacks,

void *user_data) {

return nghttp2_session_client_new3(session_ptr, callbacks, user_data, NULL,

NULL);

}

int nghttp2_session_client_new2(nghttp2_session **session_ptr,

const nghttp2_session_callbacks *callbacks,

void *user_data, const nghttp2_option *option) {

return nghttp2_session_client_new3(session_ptr, callbacks, user_data, option,

NULL);

}

int nghttp2_session_client_new3(nghttp2_session **session_ptr,

const nghttp2_session_callbacks *callbacks,

void *user_data, const nghttp2_option *option,

nghttp2_mem *mem) {

int rv;

nghttp2_session *session;

rv = session_new(&session, callbacks, user_data, 0, option, mem);

if (rv != 0) {

return rv;

}

/* IDs for use in client */

session->next_stream_id = 1;

*session_ptr = session;

return 0;

}

int nghttp2_session_server_new(nghttp2_session **session_ptr,

const nghttp2_session_callbacks *callbacks,

void *user_data) {

return nghttp2_session_server_new3(session_ptr, callbacks, user_data, NULL,

NULL);

}

int nghttp2_session_server_new2(nghttp2_session **session_ptr,

const nghttp2_session_callbacks *callbacks,

void *user_data, const nghttp2_option *option) {

return nghttp2_session_server_new3(session_ptr, callbacks, user_data, option,

NULL);

}

int nghttp2_session_server_new3(nghttp2_session **session_ptr,

const nghttp2_session_callbacks *callbacks,

void *user_data, const nghttp2_option *option,

nghttp2_mem *mem) {

int rv;

nghttp2_session *session;

rv = session_new(&session, callbacks, user_data, 1, option, mem);

if (rv != 0) {

return rv;

}

/* IDs for use in client */

session->next_stream_id = 2;

*session_ptr = session;

return 0;

}

static int free_streams(nghttp2_map_entry *entry, void *ptr) {

nghttp2_session *session;

nghttp2_stream *stream;

nghttp2_outbound_item *item;

nghttp2_mem *mem;

session = (nghttp2_session *)ptr;

mem = &session->mem;

stream = (nghttp2_stream *)entry;

item = stream->item;

if (item && !item->queued && item != session->aob.item) {

nghttp2_outbound_item_free(item, mem);

nghttp2_mem_free(mem, item);

}

nghttp2_stream_free(stream);

nghttp2_mem_free(mem, stream);

return 0;

}

static void ob_q_free(nghttp2_outbound_queue *q, nghttp2_mem *mem) {

nghttp2_outbound_item *item, *next;

for (item = q->head; item;) {

next = item->qnext;

nghttp2_outbound_item_free(item, mem);

nghttp2_mem_free(mem, item);

item = next;

}

}

static int inflight_settings_new(nghttp2_inflight_settings **settings_ptr,

const nghttp2_settings_entry *iv, size_t niv,

nghttp2_mem *mem) {

*settings_ptr = nghttp2_mem_malloc(mem, sizeof(nghttp2_inflight_settings));

if (!*settings_ptr) {

return NGHTTP2_ERR_NOMEM;

}

if (niv > 0) {

(*settings_ptr)->iv = nghttp2_frame_iv_copy(iv, niv, mem);

if (!(*settings_ptr)->iv) {

nghttp2_mem_free(mem, *settings_ptr);

return NGHTTP2_ERR_NOMEM;

}

} else {

(*settings_ptr)->iv = NULL;

}

(*settings_ptr)->niv = niv;

(*settings_ptr)->next = NULL;

return 0;

}

static void inflight_settings_del(nghttp2_inflight_settings *settings,

nghttp2_mem *mem) {

if (!settings) {

return;

}

nghttp2_mem_free(mem, settings->iv);

nghttp2_mem_free(mem, settings);

}

void nghttp2_session_del(nghttp2_session *session) {

nghttp2_mem *mem;

nghttp2_inflight_settings *settings;

if (session == NULL) {

return;

}

mem = &session->mem;

for (settings = session->inflight_settings_head; settings;) {

nghttp2_inflight_settings *next = settings->next;

inflight_settings_del(settings, mem);

settings = next;

}

nghttp2_stream_free(&session->root);

/* Have to free streams first, so that we can check

nghttp2_map_each_free(&session->streams, free_streams, session);

nghttp2_map_free(&session->streams);

ob_q_free(&session->ob_urgent, mem);

ob_q_free(&session->ob_reg, mem);

ob_q_free(&session->ob_syn, mem);

active_outbound_item_reset(&session->aob, mem);

session_inbound_frame_reset(session);

nghttp2_hd_deflate_free(&session->hd_deflater);

nghttp2_hd_inflate_free(&session->hd_inflater);

nghttp2_bufs_free(&session->aob.framebufs);

nghttp2_mem_free(mem, session);

}

int nghttp2_session_reprioritize_stream(

nghttp2_session *session, nghttp2_stream *stream,

const nghttp2_priority_spec *pri_spec_in) {

int rv;

nghttp2_stream *dep_stream = NULL;

nghttp2_priority_spec pri_spec_default;

const nghttp2_priority_spec *pri_spec = pri_spec_in;

assert(pri_spec->stream_id != stream->stream_id);

if (!nghttp2_stream_in_dep_tree(stream)) {

return 0;

}

if (pri_spec->stream_id != 0) {

dep_stream = nghttp2_session_get_stream_raw(session, pri_spec->stream_id);

if (!dep_stream &&

session_detect_idle_stream(session, pri_spec->stream_id)) {

nghttp2_priority_spec_default_init(&pri_spec_default);

dep_stream = nghttp2_session_open_stream(

session, pri_spec->stream_id, NGHTTP2_FLAG_NONE, &pri_spec_default,

NGHTTP2_STREAM_IDLE, NULL);

if (dep_stream == NULL) {

return NGHTTP2_ERR_NOMEM;

}

} else if (!dep_stream || !nghttp2_stream_in_dep_tree(dep_stream)) {

nghttp2_priority_spec_default_init(&pri_spec_default);

pri_spec = &pri_spec_default;

}

}

if (pri_spec->stream_id == 0) {

dep_stream = &session->root;

} else if (nghttp2_stream_dep_find_ancestor(dep_stream, stream)) {

DEBUGF("stream: cycle detected, dep_stream(%p)=%d stream(%p)=%d\n",

dep_stream, dep_stream->stream_id, stream, stream->stream_id);

nghttp2_stream_dep_remove_subtree(dep_stream);

rv = nghttp2_stream_dep_add_subtree(stream->dep_prev, dep_stream);

if (rv != 0) {

return rv;

}

}

assert(dep_stream);

if (dep_stream == stream->dep_prev && !pri_spec->exclusive) {

/* This is minor optimization when just weight is changed. */

nghttp2_stream_change_weight(stream, pri_spec->weight);

return 0;

}

nghttp2_stream_dep_remove_subtree(stream);

/* We have to update weight after removing stream from tree */

stream->weight = pri_spec->weight;

if (pri_spec->exclusive) {

rv = nghttp2_stream_dep_insert_subtree(dep_stream, stream);

} else {

rv = nghttp2_stream_dep_add_subtree(dep_stream, stream);

}

if (rv != 0) {

return rv;

}

return 0;

}

int nghttp2_session_add_item(nghttp2_session *session,

nghttp2_outbound_item *item) {

/* TODO Return error if stream is not found for the frame requiring

int rv = 0;

nghttp2_stream *stream;

nghttp2_frame *frame;

frame = &item->frame;

stream = nghttp2_session_get_stream(session, frame->hd.stream_id);

switch (frame->hd.type) {

case NGHTTP2_DATA:

if (!stream) {

return NGHTTP2_ERR_STREAM_CLOSED;

}

if (stream->item) {

return NGHTTP2_ERR_DATA_EXIST;

}

rv = nghttp2_stream_attach_item(stream, item);

if (rv != 0) {

return rv;

}

return 0;

case NGHTTP2_HEADERS:

/* We push request HEADERS and push response HEADERS to

/* TODO If 2 HEADERS are submitted for reserved stream, then

if (frame->headers.cat == NGHTTP2_HCAT_REQUEST ||

(stream && stream->state == NGHTTP2_STREAM_RESERVED)) {

nghttp2_outbound_queue_push(&session->ob_syn, item);

item->queued = 1;

return 0;

;

}

nghttp2_outbound_queue_push(&session->ob_reg, item);

item->queued = 1;

return 0;

case NGHTTP2_SETTINGS:

case NGHTTP2_PING:

nghttp2_outbound_queue_push(&session->ob_urgent, item);

item->queued = 1;

return 0;

case NGHTTP2_RST_STREAM:

if (stream) {

stream->state = NGHTTP2_STREAM_CLOSING;

}

nghttp2_outbound_queue_push(&session->ob_reg, item);

item->queued = 1;

return 0;

case NGHTTP2_PUSH_PROMISE: {

nghttp2_headers_aux_data *aux_data;

nghttp2_priority_spec pri_spec;

aux_data = &item->aux_data.headers;

if (!stream) {

return NGHTTP2_ERR_STREAM_CLOSED;

}

nghttp2_priority_spec_init(&pri_spec, stream->stream_id,

NGHTTP2_DEFAULT_WEIGHT, 0);

if (!nghttp2_session_open_stream(

session, frame->push_promise.promised_stream_id,

NGHTTP2_STREAM_FLAG_NONE, &pri_spec, NGHTTP2_STREAM_RESERVED,

aux_data->stream_user_data)) {

return NGHTTP2_ERR_NOMEM;

}

/* We don't have to call nghttp2_session_adjust_closed_stream()

nghttp2_outbound_queue_push(&session->ob_reg, item);

item->queued = 1;

return 0;

}

case NGHTTP2_WINDOW_UPDATE:

if (stream) {

stream->window_update_queued = 1;

} else if (frame->hd.stream_id == 0) {

session->window_update_queued = 1;

}

nghttp2_outbound_queue_push(&session->ob_reg, item);

item->queued = 1;

return 0;

default:

nghttp2_outbound_queue_push(&session->ob_reg, item);

item->queued = 1;

return 0;

}

}

int nghttp2_session_add_rst_stream(nghttp2_session *session, int32_t stream_id,

uint32_t error_code) {

int rv;

nghttp2_outbound_item *item;

nghttp2_frame *frame;

nghttp2_stream *stream;

nghttp2_mem *mem;

mem = &session->mem;

stream = nghttp2_session_get_stream(session, stream_id);

if (stream && stream->state == NGHTTP2_STREAM_CLOSING) {

return 0;

}

/* Sending RST_STREAM to an idle stream is subject to protocol

if (nghttp2_session_is_my_stream_id(session, stream_id)) {

if ((uint32_t)stream_id >= session->next_stream_id) {

return 0;

}

} else if (session->last_recv_stream_id < stream_id) {

return 0;

}

/* Cancel pending request HEADERS in ob_syn if this RST_STREAM

if (!session->server && nghttp2_session_is_my_stream_id(session, stream_id) &&

nghttp2_outbound_queue_top(&session->ob_syn)) {

nghttp2_headers_aux_data *aux_data;

nghttp2_frame *headers_frame;

headers_frame = &nghttp2_outbound_queue_top(&session->ob_syn)->frame;

assert(headers_frame->hd.type == NGHTTP2_HEADERS);

if (headers_frame->hd.stream_id <= stream_id) {

for (item = session->ob_syn.head; item; item = item->qnext) {

aux_data = &item->aux_data.headers;

if (item->frame.hd.stream_id < stream_id) {

continue;

}

/* stream_id in ob_syn queue must be strictly increasing. If

if (item->frame.hd.stream_id > stream_id || aux_data->canceled) {

break;

}

aux_data->error_code = error_code;

aux_data->canceled = 1;