#include "aliased_buffer.h"

#include "node.h"

#include "node_buffer.h"

#include "node_http2.h"

#include "node_http2_state.h"

#include "node_perf.h"

#include <algorithm>

namespace node {

using v8::ArrayBuffer;

using v8::Boolean;

using v8::Context;

using v8::Float64Array;

using v8::Function;

using v8::Integer;

using v8::Number;

using v8::ObjectTemplate;

using v8::String;

using v8::Uint32;

using v8::Uint32Array;

using v8::Undefined;

using node::performance::PerformanceEntry;

namespace http2 {

namespace {

const char zero_bytes_256[256] = {};

inline Http2Stream* GetStream(Http2Session* session,

int32_t id,

nghttp2_data_source* source) {

Http2Stream* stream = static_cast<Http2Stream*>(source->ptr);

if (stream == nullptr)

stream = session->FindStream(id);

CHECK_NE(stream, nullptr);

CHECK_EQ(id, stream->id());

return stream;

}

} // anonymous namespace

// These configure the callbacks required by nghttp2 itself. There are

// two sets of callback functions, one that is used if a padding callback

// is set, and other that does not include the padding callback.

const Http2Session::Callbacks Http2Session::callback_struct_saved[2] = {

Callbacks(false),

Callbacks(true)};

// The Http2Scope object is used to queue a write to the i/o stream. It is

// used whenever any action is take on the underlying nghttp2 API that may

// push data into nghttp2 outbound data queue.

//

// For example:

//

// Http2Scope h2scope(session);

// nghttp2_submit_ping(**session, ... );

//

// When the Http2Scope passes out of scope and is deconstructed, it will

// call Http2Session::MaybeScheduleWrite().

Http2Scope::Http2Scope(Http2Stream* stream) : Http2Scope(stream->session()) {}

Http2Scope::Http2Scope(Http2Session* session) {

if (session == nullptr)

return;

if (session->flags_ & (SESSION_STATE_HAS_SCOPE |

SESSION_STATE_WRITE_SCHEDULED)) {

// There is another scope further below on the stack, or it is already

// known that a write is scheduled. In either case, there is nothing to do.

return;

}

session->flags_ |= SESSION_STATE_HAS_SCOPE;

session_ = session;

// Always keep the session object alive for at least as long as

// this scope is active.

session_handle_ = session->object();

CHECK(!session_handle_.IsEmpty());

}

Http2Scope::~Http2Scope() {

if (session_ == nullptr)

return;

session_->flags_ &= ~SESSION_STATE_HAS_SCOPE;

session_->MaybeScheduleWrite();

}

// The Http2Options object is used during the construction of Http2Session

// instances to configure an appropriate nghttp2_options struct. The class

// uses a single TypedArray instance that is shared with the JavaScript side

// to more efficiently pass values back and forth.

Http2Options::Http2Options(Environment* env) {

nghttp2_option_new(&options_);

// We manually handle flow control within a session in order to

// implement backpressure -- that is, we only send WINDOW_UPDATE

// frames to the remote peer as data is actually consumed by user

// code. This ensures that the flow of data over the connection

// does not move too quickly and limits the amount of data we

// are required to buffer.

nghttp2_option_set_no_auto_window_update(options_, 1);

// Enable built in support for ALTSVC frames. Once we add support for

// other non-built in extension frames, this will need to be handled

// a bit differently. For now, let's let nghttp2 take care of it.

nghttp2_option_set_builtin_recv_extension_type(options_, NGHTTP2_ALTSVC);

AliasedBuffer<uint32_t, v8::Uint32Array>& buffer =

env->http2_state()->options_buffer;

uint32_t flags = buffer[IDX_OPTIONS_FLAGS];

if (flags & (1 << IDX_OPTIONS_MAX_DEFLATE_DYNAMIC_TABLE_SIZE)) {

nghttp2_option_set_max_deflate_dynamic_table_size(

options_,

buffer[IDX_OPTIONS_MAX_DEFLATE_DYNAMIC_TABLE_SIZE]);

}

if (flags & (1 << IDX_OPTIONS_MAX_RESERVED_REMOTE_STREAMS)) {

nghttp2_option_set_max_reserved_remote_streams(

options_,

buffer[IDX_OPTIONS_MAX_RESERVED_REMOTE_STREAMS]);

}

if (flags & (1 << IDX_OPTIONS_MAX_SEND_HEADER_BLOCK_LENGTH)) {

nghttp2_option_set_max_send_header_block_length(

options_,

buffer[IDX_OPTIONS_MAX_SEND_HEADER_BLOCK_LENGTH]);

}

// Recommended default

nghttp2_option_set_peer_max_concurrent_streams(options_, 100);

if (flags & (1 << IDX_OPTIONS_PEER_MAX_CONCURRENT_STREAMS)) {

nghttp2_option_set_peer_max_concurrent_streams(

options_,

buffer[IDX_OPTIONS_PEER_MAX_CONCURRENT_STREAMS]);

}

// The padding strategy sets the mechanism by which we determine how much

// additional frame padding to apply to DATA and HEADERS frames. Currently

// this is set on a per-session basis, but eventually we may switch to

// a per-stream setting, giving users greater control

if (flags & (1 << IDX_OPTIONS_PADDING_STRATEGY)) {

padding_strategy_type strategy =

static_cast<padding_strategy_type>(

buffer.GetValue(IDX_OPTIONS_PADDING_STRATEGY));

SetPaddingStrategy(strategy);

}

// The max header list pairs option controls the maximum number of

// header pairs the session may accept. This is a hard limit.. that is,

// if the remote peer sends more than this amount, the stream will be

// automatically closed with an RST_STREAM.

if (flags & (1 << IDX_OPTIONS_MAX_HEADER_LIST_PAIRS)) {

SetMaxHeaderPairs(buffer[IDX_OPTIONS_MAX_HEADER_LIST_PAIRS]);

}

// The HTTP2 specification places no limits on the number of HTTP2

// PING frames that can be sent. In order to prevent PINGS from being

// abused as an attack vector, however, we place a strict upper limit

// on the number of unacknowledged PINGS that can be sent at any given

// time.

if (flags & (1 << IDX_OPTIONS_MAX_OUTSTANDING_PINGS)) {

SetMaxOutstandingPings(buffer[IDX_OPTIONS_MAX_OUTSTANDING_PINGS]);

}

// The HTTP2 specification places no limits on the number of HTTP2

// SETTINGS frames that can be sent. In order to prevent PINGS from being

// abused as an attack vector, however, we place a strict upper limit

// on the number of unacknowledged SETTINGS that can be sent at any given

// time.

if (flags & (1 << IDX_OPTIONS_MAX_OUTSTANDING_SETTINGS)) {

SetMaxOutstandingSettings(buffer[IDX_OPTIONS_MAX_OUTSTANDING_SETTINGS]);

}

// The HTTP2 specification places no limits on the amount of memory

// that a session can consume. In order to prevent abuse, we place a

// cap on the amount of memory a session can consume at any given time.

// this is a credit based system. Existing streams may cause the limit

// to be temporarily exceeded but once over the limit, new streams cannot

// created.

// Important: The maxSessionMemory option in javascript is expressed in

// terms of MB increments (i.e. the value 1 == 1 MB)

if (flags & (1 << IDX_OPTIONS_MAX_SESSION_MEMORY)) {

SetMaxSessionMemory(buffer[IDX_OPTIONS_MAX_SESSION_MEMORY] * 1e6);

}

}

void Http2Session::Http2Settings::Init() {

AliasedBuffer<uint32_t, v8::Uint32Array>& buffer =

env()->http2_state()->settings_buffer;

uint32_t flags = buffer[IDX_SETTINGS_COUNT];

size_t n = 0;

#define GRABSETTING(N, trace) \

if (flags & (1 << IDX_SETTINGS_##N)) { \

uint32_t val = buffer[IDX_SETTINGS_##N]; \

DEBUG_HTTP2SESSION2(session_, "setting " trace ": %d\n", val); \

entries_[n++] = \

nghttp2_settings_entry {NGHTTP2_SETTINGS_##N, val}; \

}

GRABSETTING(HEADER_TABLE_SIZE, "header table size");

GRABSETTING(MAX_CONCURRENT_STREAMS, "max concurrent streams");

GRABSETTING(MAX_FRAME_SIZE, "max frame size");

GRABSETTING(INITIAL_WINDOW_SIZE, "initial window size");

GRABSETTING(MAX_HEADER_LIST_SIZE, "max header list size");

GRABSETTING(ENABLE_PUSH, "enable push");

#undef GRABSETTING

count_ = n;

}

Http2Session::Http2Settings::Http2Settings(

Environment* env)

: AsyncWrap(env,

env->http2settings_constructor_template()

->NewInstance(env->context())

.ToLocalChecked(),

AsyncWrap::PROVIDER_HTTP2SETTINGS),

session_(nullptr),

startTime_(0) {

Init();

}

// The Http2Settings class is used to configure a SETTINGS frame that is

// to be sent to the connected peer. The settings are set using a TypedArray

// that is shared with the JavaScript side.

Http2Session::Http2Settings::Http2Settings(

Http2Session* session)

: AsyncWrap(session->env(),

session->env()->http2settings_constructor_template()

->NewInstance(session->env()->context())

.ToLocalChecked(),

AsyncWrap::PROVIDER_HTTP2SETTINGS),

session_(session),

startTime_(uv_hrtime()) {

Init();

}

Http2Session::Http2Settings::~Http2Settings() {

if (!object().IsEmpty())

ClearWrap(object());

}

// Generates a Buffer that contains the serialized payload of a SETTINGS

// frame. This can be used, for instance, to create the Base64-encoded

// content of an Http2-Settings header field.

Local<Value> Http2Session::Http2Settings::Pack() {

const size_t len = count_ * 6;

Local<Value> buf = Buffer::New(env(), len).ToLocalChecked();

ssize_t ret =

nghttp2_pack_settings_payload(

reinterpret_cast<uint8_t*>(Buffer::Data(buf)), len,

&entries_[0], count_);

if (ret >= 0)

return buf;

else

return Undefined(env()->isolate());

}

// Updates the shared TypedArray with the current remote or local settings for

// the session.

void Http2Session::Http2Settings::Update(Environment* env,

Http2Session* session,

get_setting fn) {

AliasedBuffer<uint32_t, v8::Uint32Array>& buffer =

env->http2_state()->settings_buffer;

buffer[IDX_SETTINGS_HEADER_TABLE_SIZE] =

fn(**session, NGHTTP2_SETTINGS_HEADER_TABLE_SIZE);

buffer[IDX_SETTINGS_MAX_CONCURRENT_STREAMS] =

fn(**session, NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS);

buffer[IDX_SETTINGS_INITIAL_WINDOW_SIZE] =

fn(**session, NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE);

buffer[IDX_SETTINGS_MAX_FRAME_SIZE] =

fn(**session, NGHTTP2_SETTINGS_MAX_FRAME_SIZE);

buffer[IDX_SETTINGS_MAX_HEADER_LIST_SIZE] =

fn(**session, NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE);

buffer[IDX_SETTINGS_ENABLE_PUSH] =

fn(**session, NGHTTP2_SETTINGS_ENABLE_PUSH);

}

// Initializes the shared TypedArray with the default settings values.

void Http2Session::Http2Settings::RefreshDefaults(Environment* env) {

AliasedBuffer<uint32_t, v8::Uint32Array>& buffer =

env->http2_state()->settings_buffer;

buffer[IDX_SETTINGS_HEADER_TABLE_SIZE] =

DEFAULT_SETTINGS_HEADER_TABLE_SIZE;

buffer[IDX_SETTINGS_ENABLE_PUSH] =

DEFAULT_SETTINGS_ENABLE_PUSH;

buffer[IDX_SETTINGS_INITIAL_WINDOW_SIZE] =

DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE;

buffer[IDX_SETTINGS_MAX_FRAME_SIZE] =

DEFAULT_SETTINGS_MAX_FRAME_SIZE;

buffer[IDX_SETTINGS_MAX_HEADER_LIST_SIZE] =

DEFAULT_SETTINGS_MAX_HEADER_LIST_SIZE;

buffer[IDX_SETTINGS_COUNT] =

(1 << IDX_SETTINGS_HEADER_TABLE_SIZE) |

(1 << IDX_SETTINGS_ENABLE_PUSH) |

(1 << IDX_SETTINGS_INITIAL_WINDOW_SIZE) |

(1 << IDX_SETTINGS_MAX_FRAME_SIZE) |

(1 << IDX_SETTINGS_MAX_HEADER_LIST_SIZE);

}

void Http2Session::Http2Settings::Send() {

Http2Scope h2scope(session_);

CHECK_EQ(nghttp2_submit_settings(**session_, NGHTTP2_FLAG_NONE,

&entries_[0], count_), 0);

}

void Http2Session::Http2Settings::Done(bool ack) {

uint64_t end = uv_hrtime();

double duration = (end - startTime_) / 1e6;

Local<Value> argv[2] = {

Boolean::New(env()->isolate(), ack),

Number::New(env()->isolate(), duration)

};

MakeCallback(env()->ondone_string(), arraysize(argv), argv);

delete this;

}

// The Http2Priority class initializes an appropriate nghttp2_priority_spec

// struct used when either creating a stream or updating its priority

// settings.

Http2Priority::Http2Priority(Environment* env,

Local<Value> parent,

Local<Value> weight,

Local<Value> exclusive) {

Local<Context> context = env->context();

int32_t parent_ = parent->Int32Value(context).ToChecked();

int32_t weight_ = weight->Int32Value(context).ToChecked();

bool exclusive_ = exclusive->BooleanValue(context).ToChecked();

DEBUG_HTTP2("Http2Priority: parent: %d, weight: %d, exclusive: %d\n",

parent_, weight_, exclusive_);

nghttp2_priority_spec_init(&spec, parent_, weight_, exclusive_ ? 1 : 0);

}

inline const char* Http2Session::TypeName() {

switch (session_type_) {

case NGHTTP2_SESSION_SERVER: return "server";

case NGHTTP2_SESSION_CLIENT: return "client";

default:

// This should never happen

ABORT();

}

}

// The Headers class initializes a proper array of nghttp2_nv structs

// containing the header name value pairs.

Headers::Headers(Isolate* isolate,

Local<Context> context,

Local<Array> headers) {

Local<Value> header_string = headers->Get(context, 0).ToLocalChecked();

Local<Value> header_count = headers->Get(context, 1).ToLocalChecked();

count_ = header_count.As<Uint32>()->Value();

int header_string_len = header_string.As<String>()->Length();

if (count_ == 0) {

CHECK_EQ(header_string_len, 0);

return;

}

// Allocate a single buffer with count_ nghttp2_nv structs, followed

// by the raw header data as passed from JS. This looks like:

// | possible padding | nghttp2_nv | nghttp2_nv | ... | header contents |

buf_.AllocateSufficientStorage((alignof(nghttp2_nv) - 1) +

count_ * sizeof(nghttp2_nv) +

header_string_len);

// Make sure the start address is aligned appropriately for an nghttp2_nv*.

char* start = reinterpret_cast<char*>(

ROUND_UP(reinterpret_cast<uintptr_t>(*buf_), alignof(nghttp2_nv)));

char* header_contents = start + (count_ * sizeof(nghttp2_nv));

nghttp2_nv* const nva = reinterpret_cast<nghttp2_nv*>(start);

CHECK_LE(header_contents + header_string_len, *buf_ + buf_.length());

CHECK_EQ(header_string.As<String>()

->WriteOneByte(reinterpret_cast<uint8_t*>(header_contents),

0, header_string_len,

String::NO_NULL_TERMINATION),

header_string_len);

size_t n = 0;

char* p;

for (p = header_contents; p < header_contents + header_string_len; n++) {

if (n >= count_) {

// This can happen if a passed header contained a null byte. In that

// case, just provide nghttp2 with an invalid header to make it reject

// the headers list.

static uint8_t zero = '\0';

nva[0].name = nva[0].value = &zero;

nva[0].namelen = nva[0].valuelen = 1;

count_ = 1;

return;

}

nva[n].flags = NGHTTP2_NV_FLAG_NONE;

nva[n].name = reinterpret_cast<uint8_t*>(p);

nva[n].namelen = strlen(p);

p += nva[n].namelen + 1;

nva[n].value = reinterpret_cast<uint8_t*>(p);

nva[n].valuelen = strlen(p);

p += nva[n].valuelen + 1;

}

}

// Sets the various callback functions that nghttp2 will use to notify us

// about significant events while processing http2 stuff.

Http2Session::Callbacks::Callbacks(bool kHasGetPaddingCallback) {

CHECK_EQ(nghttp2_session_callbacks_new(&callbacks), 0);

nghttp2_session_callbacks_set_on_begin_headers_callback(

callbacks, OnBeginHeadersCallback);

nghttp2_session_callbacks_set_on_header_callback2(

callbacks, OnHeaderCallback);

nghttp2_session_callbacks_set_on_frame_recv_callback(

callbacks, OnFrameReceive);

nghttp2_session_callbacks_set_on_stream_close_callback(

callbacks, OnStreamClose);

nghttp2_session_callbacks_set_on_data_chunk_recv_callback(

callbacks, OnDataChunkReceived);

nghttp2_session_callbacks_set_on_frame_not_send_callback(

callbacks, OnFrameNotSent);

nghttp2_session_callbacks_set_on_invalid_header_callback2(

callbacks, OnInvalidHeader);

nghttp2_session_callbacks_set_error_callback(

callbacks, OnNghttpError);

nghttp2_session_callbacks_set_send_data_callback(

callbacks, OnSendData);

nghttp2_session_callbacks_set_on_invalid_frame_recv_callback(

callbacks, OnInvalidFrame);

nghttp2_session_callbacks_set_on_frame_send_callback(

callbacks, OnFrameSent);

if (kHasGetPaddingCallback) {

nghttp2_session_callbacks_set_select_padding_callback(

callbacks, OnSelectPadding);

}

}

Http2Session::Callbacks::~Callbacks() {

nghttp2_session_callbacks_del(callbacks);

}

Http2Session::Http2Session(Environment* env,

Local<Object> wrap,

nghttp2_session_type type)

: AsyncWrap(env, wrap, AsyncWrap::PROVIDER_HTTP2SESSION),

session_type_(type) {

MakeWeak<Http2Session>(this);

statistics_.start_time = uv_hrtime();

// Capture the configuration options for this session

Http2Options opts(env);

max_session_memory_ = opts.GetMaxSessionMemory();

uint32_t maxHeaderPairs = opts.GetMaxHeaderPairs();

max_header_pairs_ =

type == NGHTTP2_SESSION_SERVER

? std::max(maxHeaderPairs, 4U) // minimum # of request headers

: std::max(maxHeaderPairs, 1U); // minimum # of response headers

max_outstanding_pings_ = opts.GetMaxOutstandingPings();

max_outstanding_settings_ = opts.GetMaxOutstandingSettings();

padding_strategy_ = opts.GetPaddingStrategy();

bool hasGetPaddingCallback =

padding_strategy_ != PADDING_STRATEGY_NONE;

nghttp2_session_callbacks* callbacks

= callback_struct_saved[hasGetPaddingCallback ? 1 : 0].callbacks;

auto fn = type == NGHTTP2_SESSION_SERVER ?

nghttp2_session_server_new2 :

nghttp2_session_client_new2;

// This should fail only if the system is out of memory, which

// is going to cause lots of other problems anyway, or if any

// of the options are out of acceptable range, which we should

// be catching before it gets this far. Either way, crash if this

// fails.

CHECK_EQ(fn(&session_, callbacks, this, *opts), 0);

outgoing_storage_.reserve(4096);

outgoing_buffers_.reserve(32);

}

Http2Session::~Http2Session() {

CHECK_EQ(flags_ & SESSION_STATE_HAS_SCOPE, 0);

DEBUG_HTTP2SESSION(this, "freeing nghttp2 session");

for (const auto& iter : streams_)

iter.second->session_ = nullptr;

nghttp2_session_del(session_);

}

inline bool HasHttp2Observer(Environment* env) {

AliasedBuffer<uint32_t, v8::Uint32Array>& observers =

env->performance_state()->observers;

return observers[performance::NODE_PERFORMANCE_ENTRY_TYPE_HTTP2] != 0;

}

void Http2Stream::EmitStatistics() {

if (!HasHttp2Observer(env()))

return;

Http2StreamPerformanceEntry* entry =

new Http2StreamPerformanceEntry(env(), id_, statistics_);

env()->SetImmediate([](Environment* env, void* data) {

Http2StreamPerformanceEntry* entry =

static_cast<Http2StreamPerformanceEntry*>(data);

if (HasHttp2Observer(env)) {

AliasedBuffer<double, v8::Float64Array>& buffer =

env->http2_state()->stream_stats_buffer;

buffer[IDX_STREAM_STATS_ID] = entry->id();

if (entry->first_byte() != 0) {

buffer[IDX_STREAM_STATS_TIMETOFIRSTBYTE] =

(entry->first_byte() - entry->startTimeNano()) / 1e6;

} else {

buffer[IDX_STREAM_STATS_TIMETOFIRSTBYTE] = 0;

}

if (entry->first_header() != 0) {

buffer[IDX_STREAM_STATS_TIMETOFIRSTHEADER] =

(entry->first_header() - entry->startTimeNano()) / 1e6;

} else {

buffer[IDX_STREAM_STATS_TIMETOFIRSTHEADER] = 0;

}

if (entry->first_byte_sent() != 0) {

buffer[IDX_STREAM_STATS_TIMETOFIRSTBYTESENT] =

(entry->first_byte_sent() - entry->startTimeNano()) / 1e6;

} else {

buffer[IDX_STREAM_STATS_TIMETOFIRSTBYTESENT] = 0;

}

buffer[IDX_STREAM_STATS_SENTBYTES] = entry->sent_bytes();

buffer[IDX_STREAM_STATS_RECEIVEDBYTES] = entry->received_bytes();

entry->Notify(entry->ToObject());

}

delete entry;

}, static_cast<void*>(entry));

}

void Http2Session::EmitStatistics() {

if (!HasHttp2Observer(env()))

return;

Http2SessionPerformanceEntry* entry =

new Http2SessionPerformanceEntry(env(), statistics_, session_type_);

env()->SetImmediate([](Environment* env, void* data) {

Http2SessionPerformanceEntry* entry =

static_cast<Http2SessionPerformanceEntry*>(data);

if (HasHttp2Observer(env)) {

AliasedBuffer<double, v8::Float64Array>& buffer =

env->http2_state()->session_stats_buffer;

buffer[IDX_SESSION_STATS_TYPE] = entry->type();

buffer[IDX_SESSION_STATS_PINGRTT] = entry->ping_rtt() / 1e6;

buffer[IDX_SESSION_STATS_FRAMESRECEIVED] = entry->frame_count();

buffer[IDX_SESSION_STATS_FRAMESSENT] = entry->frame_sent();

buffer[IDX_SESSION_STATS_STREAMCOUNT] = entry->stream_count();

buffer[IDX_SESSION_STATS_STREAMAVERAGEDURATION] =

entry->stream_average_duration();

buffer[IDX_SESSION_STATS_DATA_SENT] = entry->data_sent();

buffer[IDX_SESSION_STATS_DATA_RECEIVED] = entry->data_received();

buffer[IDX_SESSION_STATS_MAX_CONCURRENT_STREAMS] =

entry->max_concurrent_streams();

entry->Notify(entry->ToObject());

}

delete entry;

}, static_cast<void*>(entry));

}

// Closes the session and frees the associated resources

void Http2Session::Close(uint32_t code, bool socket_closed) {

DEBUG_HTTP2SESSION(this, "closing session");

if (flags_ & SESSION_STATE_CLOSED)

return;

flags_ |= SESSION_STATE_CLOSED;

// Stop reading on the i/o stream

if (stream_ != nullptr)

stream_->ReadStop();

// If the socket is not closed, then attempt to send a closing GOAWAY

// frame. There is no guarantee that this GOAWAY will be received by

// the peer but the HTTP/2 spec recommends sendinng it anyway. We'll

// make a best effort.

if (!socket_closed) {

Http2Scope h2scope(this);

DEBUG_HTTP2SESSION2(this, "terminating session with code %d", code);

CHECK_EQ(nghttp2_session_terminate_session(session_, code), 0);

} else if (stream_ != nullptr) {

stream_->RemoveStreamListener(this);

}

// If there are outstanding pings, those will need to be canceled, do

// so on the next iteration of the event loop to avoid calling out into

// javascript since this may be called during garbage collection.

while (!outstanding_pings_.empty()) {

Http2Session::Http2Ping* ping = PopPing();

env()->SetImmediate([](Environment* env, void* data) {

static_cast<Http2Session::Http2Ping*>(data)->Done(false);

}, static_cast<void*>(ping));

}

statistics_.end_time = uv_hrtime();

EmitStatistics();

}

// Locates an existing known stream by ID. nghttp2 has a similar method

// but this is faster and does not fail if the stream is not found.

inline Http2Stream* Http2Session::FindStream(int32_t id) {

auto s = streams_.find(id);

return s != streams_.end() ? s->second : nullptr;

}

inline bool Http2Session::CanAddStream() {

uint32_t maxConcurrentStreams =

nghttp2_session_get_local_settings(

session_, NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS);

size_t maxSize =

std::min(streams_.max_size(), static_cast<size_t>(maxConcurrentStreams));

// We can add a new stream so long as we are less than the current

// maximum on concurrent streams and there's enough available memory

return streams_.size() < maxSize &&

IsAvailableSessionMemory(sizeof(Http2Stream));

}

inline void Http2Session::AddStream(Http2Stream* stream) {

CHECK_GE(++statistics_.stream_count, 0);

streams_[stream->id()] = stream;

size_t size = streams_.size();

if (size > statistics_.max_concurrent_streams)

statistics_.max_concurrent_streams = size;

IncrementCurrentSessionMemory(stream->self_size());

}

inline void Http2Session::RemoveStream(Http2Stream* stream) {

if (streams_.empty() || stream == nullptr)

return; // Nothing to remove, item was never added?

streams_.erase(stream->id());

DecrementCurrentSessionMemory(stream->self_size());

}

// Used as one of the Padding Strategy functions. Will attempt to ensure

// that the total frame size, including header bytes, are 8-byte aligned.

// If maxPayloadLen is smaller than the number of bytes necessary to align,

// will return maxPayloadLen instead.

ssize_t Http2Session::OnDWordAlignedPadding(size_t frameLen,

size_t maxPayloadLen) {

size_t r = (frameLen + 9) % 8;

if (r == 0) return frameLen; // If already a multiple of 8, return.

size_t pad = frameLen + (8 - r);

// If maxPayloadLen happens to be less than the calculated pad length,

// use the max instead, even tho this means the frame will not be

// aligned.

pad = std::min(maxPayloadLen, pad);

DEBUG_HTTP2SESSION2(this, "using frame size padding: %d", pad);

return pad;

}

// Used as one of the Padding Strategy functions. Uses the maximum amount

// of padding allowed for the current frame.

ssize_t Http2Session::OnMaxFrameSizePadding(size_t frameLen,

size_t maxPayloadLen) {

DEBUG_HTTP2SESSION2(this, "using max frame size padding: %d", maxPayloadLen);

return maxPayloadLen;

}

// Used as one of the Padding Strategy functions. Uses a callback to JS land

// to determine the amount of padding for the current frame. This option is

// rather more expensive because of the JS boundary cross. It generally should

// not be the preferred option.

ssize_t Http2Session::OnCallbackPadding(size_t frameLen,

size_t maxPayloadLen) {

if (frameLen == 0) return 0;

DEBUG_HTTP2SESSION(this, "using callback to determine padding");

Isolate* isolate = env()->isolate();

HandleScope handle_scope(isolate);

Local<Context> context = env()->context();

Context::Scope context_scope(context);

AliasedBuffer<uint32_t, v8::Uint32Array>& buffer =

env()->http2_state()->padding_buffer;

buffer[PADDING_BUF_FRAME_LENGTH] = frameLen;

buffer[PADDING_BUF_MAX_PAYLOAD_LENGTH] = maxPayloadLen;

buffer[PADDING_BUF_RETURN_VALUE] = frameLen;

MakeCallback(env()->ongetpadding_string(), 0, nullptr);

uint32_t retval = buffer[PADDING_BUF_RETURN_VALUE];

retval = std::min(retval, static_cast<uint32_t>(maxPayloadLen));

retval = std::max(retval, static_cast<uint32_t>(frameLen));

DEBUG_HTTP2SESSION2(this, "using padding size %d", retval);

return retval;

}

// Write data received from the i/o stream to the underlying nghttp2_session.

// On each call to nghttp2_session_mem_recv, nghttp2 will begin calling the

// various callback functions. Each of these will typically result in a call

// out to JavaScript so this particular function is rather hot and can be

// quite expensive. This is a potential performance optimization target later.

ssize_t Http2Session::Write(const uv_buf_t* bufs, size_t nbufs) {

size_t total = 0;

// Note that nghttp2_session_mem_recv is a synchronous operation that

// will trigger a number of other callbacks. Those will, in turn have

// multiple side effects.

for (size_t n = 0; n < nbufs; n++) {

DEBUG_HTTP2SESSION2(this, "receiving %d bytes [wants data? %d]",

bufs[n].len,

nghttp2_session_want_read(session_));

ssize_t ret =

nghttp2_session_mem_recv(session_,

reinterpret_cast<uint8_t*>(bufs[n].base),

bufs[n].len);

CHECK_NE(ret, NGHTTP2_ERR_NOMEM);

if (ret < 0)

return ret;

total += ret;

}

// Send any data that was queued up while processing the received data.

if (!IsDestroyed()) {

SendPendingData();

}

return total;

}

inline int32_t GetFrameID(const nghttp2_frame* frame) {

// If this is a push promise, we want to grab the id of the promised stream

return (frame->hd.type == NGHTTP2_PUSH_PROMISE) ?

frame->push_promise.promised_stream_id :

frame->hd.stream_id;

}

// Called by nghttp2 at the start of receiving a HEADERS frame. We use this

// callback to determine if a new stream is being created or if we are simply

// adding a new block of headers to an existing stream. The header pairs

// themselves are set in the OnHeaderCallback

int Http2Session::OnBeginHeadersCallback(nghttp2_session* handle,

const nghttp2_frame* frame,

void* user_data) {

Http2Session* session = static_cast<Http2Session*>(user_data);

int32_t id = GetFrameID(frame);

DEBUG_HTTP2SESSION2(session, "beginning headers for stream %d", id);

Http2Stream* stream = session->FindStream(id);

if (stream == nullptr) {

if (!session->CanAddStream()) {

// Too many concurrent streams being opened

nghttp2_submit_rst_stream(**session, NGHTTP2_FLAG_NONE, id,

NGHTTP2_ENHANCE_YOUR_CALM);

return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;

}

new Http2Stream(session, id, frame->headers.cat);

} else if (!stream->IsDestroyed()) {

stream->StartHeaders(frame->headers.cat);

}

return 0;

}

// Called by nghttp2 for each header name/value pair in a HEADERS block.

// This had to have been preceded by a call to OnBeginHeadersCallback so

// the Http2Stream is guaranteed to already exist.

int Http2Session::OnHeaderCallback(nghttp2_session* handle,

const nghttp2_frame* frame,

nghttp2_rcbuf* name,

nghttp2_rcbuf* value,

uint8_t flags,

void* user_data) {

Http2Session* session = static_cast<Http2Session*>(user_data);

int32_t id = GetFrameID(frame);

Http2Stream* stream = session->FindStream(id);

CHECK_NE(stream, nullptr);

// If the stream has already been destroyed, ignore.

if (!stream->IsDestroyed() && !stream->AddHeader(name, value, flags)) {

// This will only happen if the connected peer sends us more

// than the allowed number of header items at any given time

stream->SubmitRstStream(NGHTTP2_ENHANCE_YOUR_CALM);

return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;

}

return 0;

}

// Called by nghttp2 when a complete HTTP2 frame has been received. There are

// only a handful of frame types tha we care about handling here.

int Http2Session::OnFrameReceive(nghttp2_session* handle,

const nghttp2_frame* frame,

void* user_data) {

Http2Session* session = static_cast<Http2Session*>(user_data);

session->statistics_.frame_count++;

DEBUG_HTTP2SESSION2(session, "complete frame received: type: %d",

frame->hd.type);

switch (frame->hd.type) {

case NGHTTP2_DATA:

session->HandleDataFrame(frame);

break;

case NGHTTP2_PUSH_PROMISE:

// Intentional fall-through, handled just like headers frames

case NGHTTP2_HEADERS:

session->HandleHeadersFrame(frame);

break;

case NGHTTP2_SETTINGS:

session->HandleSettingsFrame(frame);

break;

case NGHTTP2_PRIORITY:

session->HandlePriorityFrame(frame);

break;

case NGHTTP2_GOAWAY:

session->HandleGoawayFrame(frame);

break;

case NGHTTP2_PING:

session->HandlePingFrame(frame);

break;

case NGHTTP2_ALTSVC:

session->HandleAltSvcFrame(frame);

break;

default:

break;

}

return 0;

}

int Http2Session::OnInvalidFrame(nghttp2_session* handle,

const nghttp2_frame *frame,

int lib_error_code,

void* user_data) {

Http2Session* session = static_cast<Http2Session*>(user_data);

DEBUG_HTTP2SESSION2(session, "invalid frame received, code: %d",

lib_error_code);

// If the error is fatal or if error code is ERR_STREAM_CLOSED... emit error

if (nghttp2_is_fatal(lib_error_code) ||

lib_error_code == NGHTTP2_ERR_STREAM_CLOSED) {

Environment* env = session->env();

Isolate* isolate = env->isolate();

HandleScope scope(isolate);

Local<Context> context = env->context();

Context::Scope context_scope(context);

Local<Value> arg = Integer::New(isolate, lib_error_code);

session->MakeCallback(env->error_string(), 1, &arg);

}

return 0;

}

// If nghttp2 is unable to send a queued up frame, it will call this callback

// to let us know. If the failure occurred because we are in the process of

// closing down the session or stream, we go ahead and ignore it. We don't

// really care about those and there's nothing we can reasonably do about it

// anyway. Other types of failures are reported up to JavaScript. This should

// be exceedingly rare.

int Http2Session::OnFrameNotSent(nghttp2_session* handle,

const nghttp2_frame* frame,

int error_code,

void* user_data) {

Http2Session* session = static_cast<Http2Session*>(user_data);

Environment* env = session->env();

DEBUG_HTTP2SESSION2(session, "frame type %d was not sent, code: %d",

frame->hd.type, error_code);

// Do not report if the frame was not sent due to the session closing

if (error_code != NGHTTP2_ERR_SESSION_CLOSING &&

error_code != NGHTTP2_ERR_STREAM_CLOSED &&

error_code != NGHTTP2_ERR_STREAM_CLOSING) {

Isolate* isolate = env->isolate();

HandleScope scope(isolate);

Local<Context> context = env->context();

Context::Scope context_scope(context);

Local<Value> argv[3] = {

Integer::New(isolate, frame->hd.stream_id),

Integer::New(isolate, frame->hd.type),

Integer::New(isolate, error_code)

};

session->MakeCallback(env->onframeerror_string(), arraysize(argv), argv);

}

return 0;

}

int Http2Session::OnFrameSent(nghttp2_session* handle,

const nghttp2_frame* frame,

void* user_data) {

Http2Session* session = static_cast<Http2Session*>(user_data);

session->statistics_.frame_sent += 1;

return 0;

}

// Called by nghttp2 when a stream closes.

int Http2Session::OnStreamClose(nghttp2_session* handle,

int32_t id,

uint32_t code,

void* user_data) {

Http2Session* session = static_cast<Http2Session*>(user_data);

Environment* env = session->env();

Isolate* isolate = env->isolate();

HandleScope scope(isolate);

Local<Context> context = env->context();

Context::Scope context_scope(context);

DEBUG_HTTP2SESSION2(session, "stream %d closed with code: %d", id, code);

Http2Stream* stream = session->FindStream(id);

// Intentionally ignore the callback if the stream does not exist or has

// already been destroyed

if (stream != nullptr && !stream->IsDestroyed()) {

stream->Close(code);

// It is possible for the stream close to occur before the stream is

// ever passed on to the javascript side. If that happens, skip straight

// to destroying the stream. We can check this by looking for the

// onstreamclose function. If it exists, then the stream has already

// been passed on to javascript.

Local<Value> fn =

stream->object()->Get(context, env->onstreamclose_string())

.ToLocalChecked();

if (fn->IsFunction()) {

Local<Value> argv[] = {

Integer::NewFromUnsigned(isolate, code)

};

stream->MakeCallback(fn.As<Function>(), arraysize(argv), argv);

} else {

stream->Destroy();

}

}

return 0;

}

// Called by nghttp2 when an invalid header has been received. For now, we

// ignore these. If this callback was not provided, nghttp2 would handle

// invalid headers strictly and would shut down the stream. We are intentionally

// being more lenient here although we may want to revisit this choice later.

int Http2Session::OnInvalidHeader(nghttp2_session* session,

const nghttp2_frame* frame,

nghttp2_rcbuf* name,

nghttp2_rcbuf* value,

uint8_t flags,

void* user_data) {

// Ignore invalid header fields by default.

return 0;

}

// When nghttp2 receives a DATA frame, it will deliver the data payload to

// us in discrete chunks. We push these into a linked list stored in the

// Http2Sttream which is flushed out to JavaScript as quickly as possible.

// This can be a particularly hot path.

int Http2Session::OnDataChunkReceived(nghttp2_session* handle,

uint8_t flags,

int32_t id,

const uint8_t* data,

size_t len,

void* user_data) {

Http2Session* session = static_cast<Http2Session*>(user_data);

DEBUG_HTTP2SESSION2(session, "buffering data chunk for stream %d, size: "

"%d, flags: %d", id, len, flags);

Environment* env = session->env();

HandleScope scope(env->isolate());

// We should never actually get a 0-length chunk so this check is

// only a precaution at this point.

if (len > 0) {

// Notify nghttp2 that we've consumed a chunk of data on the connection

// so that it can send a WINDOW_UPDATE frame. This is a critical part of

// the flow control process in http2

CHECK_EQ(nghttp2_session_consume_connection(handle, len), 0);

Http2Stream* stream = session->FindStream(id);

// If the stream has been destroyed, ignore this chunk

if (stream->IsDestroyed())

return 0;

stream->statistics_.received_bytes += len;

// Repeatedly ask the stream's owner for memory, and copy the read data

// into those buffers.

// The typical case is actually the exception here; Http2StreamListeners

// know about the HTTP2 session associated with this stream, so they know

// about the larger from-socket read buffer, so they do not require copying.

do {

uv_buf_t buf = stream->EmitAlloc(len);

ssize_t avail = len;

if (static_cast<ssize_t>(buf.len) < avail)

avail = buf.len;

// `buf.base == nullptr` is the default Http2StreamListener's way

// of saying that it wants a pointer to the raw original.

// Since it has access to the original socket buffer from which the data

// was read in the first place, it can use that to minizime ArrayBuffer

// allocations.

if (LIKELY(buf.base == nullptr))

buf.base = reinterpret_cast<char*>(const_cast<uint8_t*>(data));

else