#include "node.h"

#include "node_buffer.h"

#include "node_http2.h"

namespace node {

using v8::ArrayBuffer;

using v8::Boolean;

using v8::Context;

using v8::Function;

using v8::Integer;

using v8::Undefined;

namespace http2 {

enum Http2SettingsIndex {

IDX_SETTINGS_HEADER_TABLE_SIZE,

IDX_SETTINGS_ENABLE_PUSH,

IDX_SETTINGS_INITIAL_WINDOW_SIZE,

IDX_SETTINGS_MAX_FRAME_SIZE,

IDX_SETTINGS_MAX_CONCURRENT_STREAMS,

IDX_SETTINGS_MAX_HEADER_LIST_SIZE,

IDX_SETTINGS_COUNT

};

enum Http2SessionStateIndex {

IDX_SESSION_STATE_EFFECTIVE_LOCAL_WINDOW_SIZE,

IDX_SESSION_STATE_EFFECTIVE_RECV_DATA_LENGTH,

IDX_SESSION_STATE_NEXT_STREAM_ID,

IDX_SESSION_STATE_LOCAL_WINDOW_SIZE,

IDX_SESSION_STATE_LAST_PROC_STREAM_ID,

IDX_SESSION_STATE_REMOTE_WINDOW_SIZE,

IDX_SESSION_STATE_OUTBOUND_QUEUE_SIZE,

IDX_SESSION_STATE_HD_DEFLATE_DYNAMIC_TABLE_SIZE,

IDX_SESSION_STATE_HD_INFLATE_DYNAMIC_TABLE_SIZE,

IDX_SESSION_STATE_COUNT

};

enum Http2StreamStateIndex {

IDX_STREAM_STATE,

IDX_STREAM_STATE_WEIGHT,

IDX_STREAM_STATE_SUM_DEPENDENCY_WEIGHT,

IDX_STREAM_STATE_LOCAL_CLOSE,

IDX_STREAM_STATE_REMOTE_CLOSE,

IDX_STREAM_STATE_LOCAL_WINDOW_SIZE,

IDX_STREAM_STATE_COUNT

};

enum Http2OptionsIndex {

IDX_OPTIONS_MAX_DEFLATE_DYNAMIC_TABLE_SIZE,

IDX_OPTIONS_MAX_RESERVED_REMOTE_STREAMS,

IDX_OPTIONS_MAX_SEND_HEADER_BLOCK_LENGTH,

IDX_OPTIONS_PEER_MAX_CONCURRENT_STREAMS,

IDX_OPTIONS_PADDING_STRATEGY,

IDX_OPTIONS_FLAGS

};

Http2Options::Http2Options(Environment* env) {

nghttp2_option_new(&options_);

uint32_t* buffer = env->http2_options_buffer();

uint32_t flags = buffer[IDX_OPTIONS_FLAGS];

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

(1 << IDX_OPTIONS_MAX_DEFLATE_DYNAMIC_TABLE_SIZE)) {

SetMaxDeflateDynamicTableSize(

buffer[IDX_OPTIONS_MAX_DEFLATE_DYNAMIC_TABLE_SIZE]);

}

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

(1 << IDX_OPTIONS_MAX_RESERVED_REMOTE_STREAMS)) {

SetMaxReservedRemoteStreams(

buffer[IDX_OPTIONS_MAX_RESERVED_REMOTE_STREAMS]);

}

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

(1 << IDX_OPTIONS_MAX_SEND_HEADER_BLOCK_LENGTH)) {

SetMaxSendHeaderBlockLength(

buffer[IDX_OPTIONS_MAX_SEND_HEADER_BLOCK_LENGTH]);

}

SetPeerMaxConcurrentStreams(100); // Recommended default

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

(1 << IDX_OPTIONS_PEER_MAX_CONCURRENT_STREAMS)) {

SetPeerMaxConcurrentStreams(

buffer[IDX_OPTIONS_PEER_MAX_CONCURRENT_STREAMS]);

}

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

(1 << IDX_OPTIONS_PADDING_STRATEGY)) {

SetPaddingStrategy(buffer[IDX_OPTIONS_PADDING_STRATEGY]);

}

}

inline void CopyHeaders(Isolate* isolate,

Local<Context> context,

MaybeStackBuffer<nghttp2_nv>* list,

Local<Array> headers) {

Local<Value> item;

Local<Array> header;

for (size_t n = 0; n < headers->Length(); n++) {

item = headers->Get(context, n).ToLocalChecked();

header = item.As<Array>();

Local<Value> key = header->Get(context, 0).ToLocalChecked();

Local<Value> value = header->Get(context, 1).ToLocalChecked();

CHECK(key->IsString());

CHECK(value->IsString());

size_t keylen = StringBytes::StorageSize(isolate, key, ASCII);

size_t valuelen = StringBytes::StorageSize(isolate, value, ASCII);

nghttp2_nv& nv = (*list)[n];

nv.flags = NGHTTP2_NV_FLAG_NONE;

Local<Value> flag = header->Get(context, 2).ToLocalChecked();

if (flag->BooleanValue(context).ToChecked())

nv.flags |= NGHTTP2_NV_FLAG_NO_INDEX;

nv.name = Malloc<uint8_t>(keylen);

nv.value = Malloc<uint8_t>(valuelen);

nv.namelen =

StringBytes::Write(isolate,

reinterpret_cast<char*>(nv.name),

keylen, key, ASCII);

nv.valuelen =

StringBytes::Write(isolate,

reinterpret_cast<char*>(nv.value),

valuelen, value, ASCII);

}

}

inline void FreeHeaders(MaybeStackBuffer<nghttp2_nv>* list) {

for (size_t n = 0; n < list->length(); n++) {

free((*list)[n].name);

free((*list)[n].value);

}

}

void Http2Session::OnFreeSession() {

::delete this;

}

ssize_t Http2Session::OnMaxFrameSizePadding(size_t frameLen,

size_t maxPayloadLen) {

DEBUG_HTTP2("Http2Session: using max frame size padding\n");

return maxPayloadLen;

}

ssize_t Http2Session::OnCallbackPadding(size_t frameLen,

size_t maxPayloadLen) {

DEBUG_HTTP2("Http2Session: using callback padding\n");

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

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

HandleScope handle_scope(isolate);

Context::Scope context_scope(context);

if (object()->Has(context, env()->ongetpadding_string()).FromJust()) {

uint32_t* buffer = env()->http2_padding_buffer();

buffer[0] = frameLen;

buffer[1] = maxPayloadLen;

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

uint32_t retval = buffer[2];

retval = retval <= maxPayloadLen ? retval : maxPayloadLen;

retval = retval >= frameLen ? retval : frameLen;

CHECK_GE(retval, frameLen);

CHECK_LE(retval, maxPayloadLen);

return retval;

}

return frameLen;

}

void Http2Session::SetNextStreamID(const FunctionCallbackInfo<Value>& args) {

Environment* env = Environment::GetCurrent(args);

Http2Session* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());

nghttp2_session* s = session->session();

int32_t id = args[0]->Int32Value(env->context()).ToChecked();

DEBUG_HTTP2("Http2Session: setting next stream id to %d\n", id);

nghttp2_session_set_next_stream_id(s, id);

}

void HttpErrorString(const FunctionCallbackInfo<Value>& args) {

Environment* env = Environment::GetCurrent(args);

uint32_t val = args[0]->Uint32Value(env->context()).ToChecked();

args.GetReturnValue().Set(

OneByteString(env->isolate(), nghttp2_strerror(val)));

}

// Serializes the settings object into a Buffer instance that

// would be suitable, for instance, for creating the Base64

// output for an HTTP2-Settings header field.

void PackSettings(const FunctionCallbackInfo<Value>& args) {

Environment* env = Environment::GetCurrent(args);

HandleScope scope(env->isolate());

std::vector<nghttp2_settings_entry> entries;

entries.reserve(6);

uint32_t* const buffer = env->http2_settings_buffer();

uint32_t flags = buffer[IDX_SETTINGS_COUNT];

if ((flags & (1 << IDX_SETTINGS_HEADER_TABLE_SIZE)) ==

(1 << IDX_SETTINGS_HEADER_TABLE_SIZE)) {

DEBUG_HTTP2("Setting header table size: %d\n",

buffer[IDX_SETTINGS_HEADER_TABLE_SIZE]);

entries.push_back({NGHTTP2_SETTINGS_HEADER_TABLE_SIZE,

buffer[IDX_SETTINGS_HEADER_TABLE_SIZE]});

}

if ((flags & (1 << IDX_SETTINGS_MAX_CONCURRENT_STREAMS)) ==

(1 << IDX_SETTINGS_MAX_CONCURRENT_STREAMS)) {

DEBUG_HTTP2("Setting max concurrent streams: %d\n",

buffer[IDX_SETTINGS_MAX_CONCURRENT_STREAMS]);

entries.push_back({NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS,

buffer[IDX_SETTINGS_MAX_CONCURRENT_STREAMS]});

}

if ((flags & (1 << IDX_SETTINGS_MAX_FRAME_SIZE)) ==

(1 << IDX_SETTINGS_MAX_FRAME_SIZE)) {

DEBUG_HTTP2("Setting max frame size: %d\n",

buffer[IDX_SETTINGS_MAX_FRAME_SIZE]);

entries.push_back({NGHTTP2_SETTINGS_MAX_FRAME_SIZE,

buffer[IDX_SETTINGS_MAX_FRAME_SIZE]});

}

if ((flags & (1 << IDX_SETTINGS_INITIAL_WINDOW_SIZE)) ==

(1 << IDX_SETTINGS_INITIAL_WINDOW_SIZE)) {

DEBUG_HTTP2("Setting initial window size: %d\n",

buffer[IDX_SETTINGS_INITIAL_WINDOW_SIZE]);

entries.push_back({NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE,

buffer[IDX_SETTINGS_INITIAL_WINDOW_SIZE]});

}

if ((flags & (1 << IDX_SETTINGS_MAX_HEADER_LIST_SIZE)) ==

(1 << IDX_SETTINGS_MAX_HEADER_LIST_SIZE)) {

DEBUG_HTTP2("Setting max header list size: %d\n",

buffer[IDX_SETTINGS_MAX_HEADER_LIST_SIZE]);

entries.push_back({NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE,

buffer[IDX_SETTINGS_MAX_HEADER_LIST_SIZE]});

}

if ((flags & (1 << IDX_SETTINGS_ENABLE_PUSH)) ==

(1 << IDX_SETTINGS_ENABLE_PUSH)) {

DEBUG_HTTP2("Setting enable push: %d\n",

buffer[IDX_SETTINGS_ENABLE_PUSH]);

entries.push_back({NGHTTP2_SETTINGS_ENABLE_PUSH,

buffer[IDX_SETTINGS_ENABLE_PUSH]});

}

const size_t len = entries.size() * 6;

MaybeStackBuffer<char> buf(len);

ssize_t ret =

nghttp2_pack_settings_payload(

reinterpret_cast<uint8_t*>(*buf), len, &entries[0], entries.size());

if (ret >= 0) {

args.GetReturnValue().Set(

Buffer::Copy(env, *buf, len).ToLocalChecked());

}

}

// Used to fill in the spec defined initial values for each setting.

void RefreshDefaultSettings(const FunctionCallbackInfo<Value>& args) {

DEBUG_HTTP2("Http2Session: refreshing default settings\n");

Environment* env = Environment::GetCurrent(args);

uint32_t* const buffer = env->http2_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_COUNT] =

(1 << IDX_SETTINGS_HEADER_TABLE_SIZE) |

(1 << IDX_SETTINGS_ENABLE_PUSH) |

(1 << IDX_SETTINGS_INITIAL_WINDOW_SIZE) |

(1 << IDX_SETTINGS_MAX_FRAME_SIZE);

}

template <get_setting fn>

void RefreshSettings(const FunctionCallbackInfo<Value>& args) {

DEBUG_HTTP2("Http2Session: refreshing settings for session\n");

CHECK_EQ(args.Length(), 1);

CHECK(args[0]->IsObject());

Http2Session* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args[0].As<Object>());

Environment* env = session->env();

nghttp2_session* s = session->session();

uint32_t* const buffer = env->http2_settings_buffer();

buffer[IDX_SETTINGS_HEADER_TABLE_SIZE] =

fn(s, NGHTTP2_SETTINGS_HEADER_TABLE_SIZE);

buffer[IDX_SETTINGS_MAX_CONCURRENT_STREAMS] =

fn(s, NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS);

buffer[IDX_SETTINGS_INITIAL_WINDOW_SIZE] =

fn(s, NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE);

buffer[IDX_SETTINGS_MAX_FRAME_SIZE] =

fn(s, NGHTTP2_SETTINGS_MAX_FRAME_SIZE);

buffer[IDX_SETTINGS_MAX_HEADER_LIST_SIZE] =

fn(s, NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE);

buffer[IDX_SETTINGS_ENABLE_PUSH] =

fn(s, NGHTTP2_SETTINGS_ENABLE_PUSH);

}

// Used to fill in the spec defined initial values for each setting.

void RefreshSessionState(const FunctionCallbackInfo<Value>& args) {

DEBUG_HTTP2("Http2Session: refreshing session state\n");

CHECK_EQ(args.Length(), 1);

CHECK(args[0]->IsObject());

Environment* env = Environment::GetCurrent(args);

double* const buffer = env->http2_session_state_buffer();

Http2Session* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args[0].As<Object>());

nghttp2_session* s = session->session();

buffer[IDX_SESSION_STATE_EFFECTIVE_LOCAL_WINDOW_SIZE] =

nghttp2_session_get_effective_local_window_size(s);

buffer[IDX_SESSION_STATE_EFFECTIVE_RECV_DATA_LENGTH] =

nghttp2_session_get_effective_recv_data_length(s);

buffer[IDX_SESSION_STATE_NEXT_STREAM_ID] =

nghttp2_session_get_next_stream_id(s);

buffer[IDX_SESSION_STATE_LOCAL_WINDOW_SIZE] =

nghttp2_session_get_local_window_size(s);

buffer[IDX_SESSION_STATE_LAST_PROC_STREAM_ID] =

nghttp2_session_get_last_proc_stream_id(s);

buffer[IDX_SESSION_STATE_REMOTE_WINDOW_SIZE] =

nghttp2_session_get_remote_window_size(s);

buffer[IDX_SESSION_STATE_OUTBOUND_QUEUE_SIZE] =

nghttp2_session_get_outbound_queue_size(s);

buffer[IDX_SESSION_STATE_HD_DEFLATE_DYNAMIC_TABLE_SIZE] =

nghttp2_session_get_hd_deflate_dynamic_table_size(s);

buffer[IDX_SESSION_STATE_HD_INFLATE_DYNAMIC_TABLE_SIZE] =

nghttp2_session_get_hd_inflate_dynamic_table_size(s);

}

void RefreshStreamState(const FunctionCallbackInfo<Value>& args) {

Environment* env = Environment::GetCurrent(args);

CHECK_EQ(args.Length(), 2);

CHECK(args[0]->IsObject());

CHECK(args[1]->IsNumber());

int32_t id = args[1]->Int32Value(env->context()).ToChecked();

DEBUG_HTTP2("Http2Session: refreshing stream %d state\n", id);

Http2Session* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args[0].As<Object>());

nghttp2_session* s = session->session();

Nghttp2Stream* stream;

double* const buffer = env->http2_stream_state_buffer();

if ((stream = session->FindStream(id)) == nullptr) {

buffer[IDX_STREAM_STATE] = NGHTTP2_STREAM_STATE_IDLE;

buffer[IDX_STREAM_STATE_WEIGHT] =

buffer[IDX_STREAM_STATE_SUM_DEPENDENCY_WEIGHT] =

buffer[IDX_STREAM_STATE_LOCAL_CLOSE] =

buffer[IDX_STREAM_STATE_REMOTE_CLOSE] =

buffer[IDX_STREAM_STATE_LOCAL_WINDOW_SIZE] = 0;

return;

}

nghttp2_stream* str =

nghttp2_session_find_stream(s, stream->id());

if (str == nullptr) {

buffer[IDX_STREAM_STATE] = NGHTTP2_STREAM_STATE_IDLE;

buffer[IDX_STREAM_STATE_WEIGHT] =

buffer[IDX_STREAM_STATE_SUM_DEPENDENCY_WEIGHT] =

buffer[IDX_STREAM_STATE_LOCAL_CLOSE] =

buffer[IDX_STREAM_STATE_REMOTE_CLOSE] =

buffer[IDX_STREAM_STATE_LOCAL_WINDOW_SIZE] = 0;

} else {

buffer[IDX_STREAM_STATE] =

nghttp2_stream_get_state(str);

buffer[IDX_STREAM_STATE_WEIGHT] =

nghttp2_stream_get_weight(str);

buffer[IDX_STREAM_STATE_SUM_DEPENDENCY_WEIGHT] =

nghttp2_stream_get_sum_dependency_weight(str);

buffer[IDX_STREAM_STATE_LOCAL_CLOSE] =

nghttp2_session_get_stream_local_close(s, id);

buffer[IDX_STREAM_STATE_REMOTE_CLOSE] =

nghttp2_session_get_stream_remote_close(s, id);

buffer[IDX_STREAM_STATE_LOCAL_WINDOW_SIZE] =

nghttp2_session_get_stream_local_window_size(s, id);

}

}

void Http2Session::New(const FunctionCallbackInfo<Value>& args) {

Environment* env = Environment::GetCurrent(args);

CHECK(args.IsConstructCall());

int val = args[0]->IntegerValue(env->context()).ToChecked();

nghttp2_session_type type = static_cast<nghttp2_session_type>(val);

DEBUG_HTTP2("Http2Session: creating a session of type: %d\n", type);

new Http2Session(env, args.This(), type);

}

// Capture the stream that this session will use to send and receive data

void Http2Session::Consume(const FunctionCallbackInfo<Value>& args) {

Http2Session* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());

CHECK(args[0]->IsExternal());

session->Consume(args[0].As<External>());

}

void Http2Session::Destroy(const FunctionCallbackInfo<Value>& args) {

DEBUG_HTTP2("Http2Session: destroying session\n");

Http2Session* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());

session->Unconsume();

session->Free();

}

void Http2Session::SubmitPriority(const FunctionCallbackInfo<Value>& args) {

Environment* env = Environment::GetCurrent(args);

Http2Session* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());

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

nghttp2_priority_spec spec;

int32_t id = args[0]->Int32Value(context).ToChecked();

int32_t parent = args[1]->Int32Value(context).ToChecked();

int32_t weight = args[2]->Int32Value(context).ToChecked();

bool exclusive = args[3]->BooleanValue(context).ToChecked();

bool silent = args[4]->BooleanValue(context).ToChecked();

DEBUG_HTTP2("Http2Session: submitting priority for stream %d: "

"parent: %d, weight: %d, exclusive: %d, silent: %d\n",

id, parent, weight, exclusive, silent);

CHECK_GT(id, 0);

CHECK_GE(parent, 0);

CHECK_GE(weight, 0);

Nghttp2Stream* stream;

if (!(stream = session->FindStream(id))) {

// invalid stream

return args.GetReturnValue().Set(NGHTTP2_ERR_INVALID_STREAM_ID);

}

nghttp2_priority_spec_init(&spec, parent, weight, exclusive ? 1 : 0);

args.GetReturnValue().Set(stream->SubmitPriority(&spec, silent));

}

void Http2Session::SubmitSettings(const FunctionCallbackInfo<Value>& args) {

Http2Session* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());

Environment* env = session->env();

uint32_t* const buffer = env->http2_settings_buffer();

uint32_t flags = buffer[IDX_SETTINGS_COUNT];

std::vector<nghttp2_settings_entry> entries;

entries.reserve(6);

if ((flags & (1 << IDX_SETTINGS_HEADER_TABLE_SIZE)) ==

(1 << IDX_SETTINGS_HEADER_TABLE_SIZE)) {

DEBUG_HTTP2("Setting header table size: %d\n",

buffer[IDX_SETTINGS_HEADER_TABLE_SIZE]);

entries.push_back({NGHTTP2_SETTINGS_HEADER_TABLE_SIZE,

buffer[IDX_SETTINGS_HEADER_TABLE_SIZE]});

}

if ((flags & (1 << IDX_SETTINGS_MAX_CONCURRENT_STREAMS)) ==

(1 << IDX_SETTINGS_MAX_CONCURRENT_STREAMS)) {

DEBUG_HTTP2("Setting max concurrent streams: %d\n",

buffer[IDX_SETTINGS_MAX_CONCURRENT_STREAMS]);

entries.push_back({NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS,

buffer[IDX_SETTINGS_MAX_CONCURRENT_STREAMS]});

}

if ((flags & (1 << IDX_SETTINGS_MAX_FRAME_SIZE)) ==

(1 << IDX_SETTINGS_MAX_FRAME_SIZE)) {

DEBUG_HTTP2("Setting max frame size: %d\n",

buffer[IDX_SETTINGS_MAX_FRAME_SIZE]);

entries.push_back({NGHTTP2_SETTINGS_MAX_FRAME_SIZE,

buffer[IDX_SETTINGS_MAX_FRAME_SIZE]});

}

if ((flags & (1 << IDX_SETTINGS_INITIAL_WINDOW_SIZE)) ==

(1 << IDX_SETTINGS_INITIAL_WINDOW_SIZE)) {

DEBUG_HTTP2("Setting initial window size: %d\n",

buffer[IDX_SETTINGS_INITIAL_WINDOW_SIZE]);

entries.push_back({NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE,

buffer[IDX_SETTINGS_INITIAL_WINDOW_SIZE]});

}

if ((flags & (1 << IDX_SETTINGS_MAX_HEADER_LIST_SIZE)) ==

(1 << IDX_SETTINGS_MAX_HEADER_LIST_SIZE)) {

DEBUG_HTTP2("Setting max header list size: %d\n",

buffer[IDX_SETTINGS_MAX_HEADER_LIST_SIZE]);

entries.push_back({NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE,

buffer[IDX_SETTINGS_MAX_HEADER_LIST_SIZE]});

}

if ((flags & (1 << IDX_SETTINGS_ENABLE_PUSH)) ==

(1 << IDX_SETTINGS_ENABLE_PUSH)) {

DEBUG_HTTP2("Setting enable push: %d\n",

buffer[IDX_SETTINGS_ENABLE_PUSH]);

entries.push_back({NGHTTP2_SETTINGS_ENABLE_PUSH,

buffer[IDX_SETTINGS_ENABLE_PUSH]});

}

if (entries.size() > 0) {

args.GetReturnValue().Set(

session->Nghttp2Session::SubmitSettings(&entries[0], entries.size()));

} else {

args.GetReturnValue().Set(

session->Nghttp2Session::SubmitSettings(nullptr, 0));

}

}

void Http2Session::SubmitRstStream(const FunctionCallbackInfo<Value>& args) {

Environment* env = Environment::GetCurrent(args);

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

CHECK(args[0]->IsNumber());

CHECK(args[1]->IsNumber());

Http2Session* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());

int32_t id = args[0]->Int32Value(context).ToChecked();

uint32_t code = args[1]->Uint32Value(context).ToChecked();

Nghttp2Stream* stream;

if (!(stream = session->FindStream(id))) {

// invalid stream

return args.GetReturnValue().Set(NGHTTP2_ERR_INVALID_STREAM_ID);

}

DEBUG_HTTP2("Http2Session: sending rst_stream for stream %d, code: %d\n",

id, code);

args.GetReturnValue().Set(stream->SubmitRstStream(code));

}

void Http2Session::SubmitRequest(const FunctionCallbackInfo<Value>& args) {

// args[0] Array of headers

// args[1] endStream boolean

// args[2] parentStream ID (for priority spec)

// args[3] weight (for priority spec)

// args[4] exclusive boolean (for priority spec)

CHECK(args[0]->IsArray());

Http2Session* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());

Environment* env = session->env();

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

Isolate* isolate = env->isolate();

Local<Array> headers = args[0].As<Array>();

bool endStream = args[1]->BooleanValue(context).ToChecked();

int32_t parent = args[2]->Int32Value(context).ToChecked();

int32_t weight = args[3]->Int32Value(context).ToChecked();

bool exclusive = args[4]->BooleanValue(context).ToChecked();

DEBUG_HTTP2("Http2Session: submitting request: headers: %d, end-stream: %d, "

"parent: %d, weight: %d, exclusive: %d\n", headers->Length(),

endStream, parent, weight, exclusive);

nghttp2_priority_spec prispec;

nghttp2_priority_spec_init(&prispec, parent, weight, exclusive ? 1 : 0);

Headers list(isolate, context, headers);

int32_t ret = session->Nghttp2Session::SubmitRequest(&prispec,

*list, list.length(),

nullptr, endStream);

DEBUG_HTTP2("Http2Session: request submitted, response: %d\n", ret);

args.GetReturnValue().Set(ret);

}

void Http2Session::SubmitResponse(const FunctionCallbackInfo<Value>& args) {

CHECK(args[0]->IsNumber());

CHECK(args[1]->IsArray());

Http2Session* session;

Nghttp2Stream* stream;

ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());

Environment* env = session->env();

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

Isolate* isolate = env->isolate();

int32_t id = args[0]->Int32Value(context).ToChecked();

Local<Array> headers = args[1].As<Array>();

bool endStream = args[2]->BooleanValue(context).ToChecked();

DEBUG_HTTP2("Http2Session: submitting response for stream %d: headers: %d, "

"end-stream: %d\n", id, headers->Length(), endStream);

if (!(stream = session->FindStream(id))) {

return args.GetReturnValue().Set(NGHTTP2_ERR_INVALID_STREAM_ID);

}

Headers list(isolate, context, headers);

args.GetReturnValue().Set(

stream->SubmitResponse(*list, list.length(), endStream));

}

void Http2Session::SubmitFile(const FunctionCallbackInfo<Value>& args) {

CHECK(args[0]->IsNumber()); // Stream ID

CHECK(args[1]->IsNumber()); // File Descriptor

CHECK(args[2]->IsArray()); // Headers

Http2Session* session;

Nghttp2Stream* stream;

ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());

Environment* env = session->env();

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

Isolate* isolate = env->isolate();

int32_t id = args[0]->Int32Value(context).ToChecked();

int fd = args[1]->Int32Value(context).ToChecked();

Local<Array> headers = args[2].As<Array>();

DEBUG_HTTP2("Http2Session: submitting file %d for stream %d: headers: %d, "

"end-stream: %d\n", fd, id, headers->Length());

if (!(stream = session->FindStream(id))) {

return args.GetReturnValue().Set(NGHTTP2_ERR_INVALID_STREAM_ID);

}

Headers list(isolate, context, headers);

args.GetReturnValue().Set(stream->SubmitFile(fd, *list, list.length()));

}

void Http2Session::SendHeaders(const FunctionCallbackInfo<Value>& args) {

CHECK(args[0]->IsNumber());

CHECK(args[1]->IsArray());

Http2Session* session;

Nghttp2Stream* stream;

ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());

Environment* env = session->env();

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

Isolate* isolate = env->isolate();

int32_t id = args[0]->Int32Value(env->context()).ToChecked();

Local<Array> headers = args[1].As<Array>();

DEBUG_HTTP2("Http2Session: sending informational headers for stream %d, "

"count: %d\n", id, headers->Length());

if (!(stream = session->FindStream(id))) {

return args.GetReturnValue().Set(NGHTTP2_ERR_INVALID_STREAM_ID);

}

Headers list(isolate, context, headers);

args.GetReturnValue().Set(stream->SubmitInfo(*list, list.length()));

}

void Http2Session::ShutdownStream(const FunctionCallbackInfo<Value>& args) {

Environment* env = Environment::GetCurrent(args);

CHECK(args[0]->IsNumber());

Http2Session* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());

Nghttp2Stream* stream;

int32_t id = args[0]->Int32Value(env->context()).ToChecked();

DEBUG_HTTP2("Http2Session: shutting down stream %d\n", id);

if (!(stream = session->FindStream(id))) {

return args.GetReturnValue().Set(NGHTTP2_ERR_INVALID_STREAM_ID);

}

stream->Shutdown();

}

void Http2Session::StreamReadStart(const FunctionCallbackInfo<Value>& args) {

Environment* env = Environment::GetCurrent(args);

CHECK(args[0]->IsNumber());

Http2Session* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());

Nghttp2Stream* stream;

int32_t id = args[0]->Int32Value(env->context()).ToChecked();

if (!(stream = session->FindStream(id))) {

return args.GetReturnValue().Set(NGHTTP2_ERR_INVALID_STREAM_ID);

}

stream->ReadStart();

}

void Http2Session::StreamReadStop(const FunctionCallbackInfo<Value>& args) {

Environment* env = Environment::GetCurrent(args);

CHECK(args[0]->IsNumber());

Http2Session* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());

Nghttp2Stream* stream;

int32_t id = args[0]->Int32Value(env->context()).ToChecked();

if (!(stream = session->FindStream(id))) {

return args.GetReturnValue().Set(NGHTTP2_ERR_INVALID_STREAM_ID);

}

stream->ReadStop();

}

void Http2Session::SendShutdownNotice(

const FunctionCallbackInfo<Value>& args) {

Http2Session* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());

session->SubmitShutdownNotice();

}

void Http2Session::SubmitGoaway(const FunctionCallbackInfo<Value>& args) {

Http2Session* session;

Environment* env = Environment::GetCurrent(args);

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

ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());

uint32_t errorCode = args[0]->Uint32Value(context).ToChecked();

int32_t lastStreamID = args[1]->Int32Value(context).ToChecked();

Local<Value> opaqueData = args[2];

uint8_t* data = NULL;

size_t length = 0;

if (opaqueData->BooleanValue(context).ToChecked()) {

THROW_AND_RETURN_UNLESS_BUFFER(env, opaqueData);

SPREAD_BUFFER_ARG(opaqueData, buf);

data = reinterpret_cast<uint8_t*>(buf_data);

length = buf_length;

}

DEBUG_HTTP2("Http2Session: initiating immediate shutdown. "

"last-stream-id: %d, code: %d, opaque-data: %d\n",

lastStreamID, errorCode, length);

int status = nghttp2_submit_goaway(session->session(),

NGHTTP2_FLAG_NONE,

lastStreamID,

errorCode,

data, length);

args.GetReturnValue().Set(status);

}

void Http2Session::DestroyStream(const FunctionCallbackInfo<Value>& args) {

Environment* env = Environment::GetCurrent(args);

Http2Session* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());

CHECK_EQ(args.Length(), 1);

CHECK(args[0]->IsNumber());

int32_t id = args[0]->Int32Value(env->context()).ToChecked();

DEBUG_HTTP2("Http2Session: destroy stream %d\n", id);

Nghttp2Stream* stream;

if (!(stream = session->FindStream(id))) {

return args.GetReturnValue().Set(NGHTTP2_ERR_INVALID_STREAM_ID);

}

stream->Destroy();

}

void Http2Session::SubmitPushPromise(const FunctionCallbackInfo<Value>& args) {

Http2Session* session;

Environment* env = Environment::GetCurrent(args);

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

Isolate* isolate = env->isolate();

ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());

CHECK(args[0]->IsNumber()); // parent stream ID

CHECK(args[1]->IsArray()); // headers array

Nghttp2Stream* parent;

int32_t id = args[0]->Int32Value(context).ToChecked();

Local<Array> headers = args[1].As<Array>();

bool endStream = args[2]->BooleanValue(context).ToChecked();

DEBUG_HTTP2("Http2Session: submitting push promise for stream %d: "

"end-stream: %d, headers: %d\n", id, endStream,

headers->Length());

if (!(parent = session->FindStream(id))) {

return args.GetReturnValue().Set(NGHTTP2_ERR_INVALID_STREAM_ID);

}

Headers list(isolate, context, headers);

int32_t ret = parent->SubmitPushPromise(*list, list.length(),

nullptr, endStream);

DEBUG_HTTP2("Http2Session: push promise submitted, ret: %d\n", ret);

args.GetReturnValue().Set(ret);

}

int Http2Session::DoWrite(WriteWrap* req_wrap,

uv_buf_t* bufs,

size_t count,

uv_stream_t* send_handle) {

Environment* env = req_wrap->env();

Local<Object> req_wrap_obj = req_wrap->object();

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

Nghttp2Stream* stream;

{

Local<Value> val =

req_wrap_obj->Get(context, env->stream_string()).ToLocalChecked();

int32_t id = val->Int32Value(context).ToChecked();

if (!val->IsNumber() || !(stream = FindStream(id))) {

// invalid stream

req_wrap->Dispatched();

req_wrap->Done(0);

return NGHTTP2_ERR_INVALID_STREAM_ID;

}

}

nghttp2_stream_write_t* req = new nghttp2_stream_write_t;

req->data = req_wrap;

auto AfterWrite = [](nghttp2_stream_write_t* req, int status) {

WriteWrap* wrap = static_cast<WriteWrap*>(req->data);

wrap->Done(status);

delete req;

};

req_wrap->Dispatched();

stream->Write(req, bufs, count, AfterWrite);

return 0;

}

void Http2Session::AllocateSend(size_t recommended, uv_buf_t* buf) {

buf->base = stream_alloc();

buf->len = kAllocBufferSize;

}

void Http2Session::Send(uv_buf_t* buf, size_t length) {

if (stream_ == nullptr || !stream_->IsAlive() || stream_->IsClosing()) {

return;

}

HandleScope scope(env()->isolate());

auto AfterWrite = [](WriteWrap* req_wrap, int status) {

req_wrap->Dispose();

};

Local<Object> req_wrap_obj =

env()->write_wrap_constructor_function()

->NewInstance(env()->context()).ToLocalChecked();

WriteWrap* write_req = WriteWrap::New(env(),

req_wrap_obj,

this,

AfterWrite);

uv_buf_t actual = uv_buf_init(buf->base, length);

if (stream_->DoWrite(write_req, &actual, 1, nullptr)) {

write_req->Dispose();

}

}

void Http2Session::OnTrailers(Nghttp2Stream* stream,

MaybeStackBuffer<nghttp2_nv>* trailers) {

DEBUG_HTTP2("Http2Session: prompting for trailers on stream %d\n",

stream->id());

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

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

HandleScope scope(isolate);

Context::Scope context_scope(context);

if (object()->Has(context, env()->ontrailers_string()).FromJust()) {

Local<Value> argv[1] = {

Integer::New(isolate, stream->id())

};

Local<Value> ret = MakeCallback(env()->ontrailers_string(),

arraysize(argv), argv);

if (!ret.IsEmpty()) {

if (ret->IsArray()) {

Local<Array> headers = ret.As<Array>();

if (headers->Length() > 0) {

trailers->AllocateSufficientStorage(headers->Length());

CopyHeaders(isolate, context, trailers, headers);

}

}

}

}

}

void Http2Session::OnHeaders(Nghttp2Stream* stream,

nghttp2_header_list* headers,

nghttp2_headers_category cat,

uint8_t flags) {

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

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

Context::Scope context_scope(context);

HandleScope scope(isolate);

Local<String> name_str;

Local<String> value_str;

Local<Array> holder = Array::New(isolate);

Local<Function> fn = env()->push_values_to_array_function();

Local<Value> argv[NODE_PUSH_VAL_TO_ARRAY_MAX * 2];

// The headers are passed in above as a linked list of nghttp2_header_list

// structs. The following converts that into a JS array with the structure:

// [name1, value1, name2, value2, name3, value3, name3, value4] and so on.

// That array is passed up to the JS layer and converted into an Object form

// like {name1: value1, name2: value2, name3: [value3, value4]}. We do it

// this way for performance reasons (it's faster to generate and pass an

// array than it is to generate and pass the object).

do {

size_t j = 0;

while (headers != nullptr && j < arraysize(argv) / 2) {

nghttp2_header_list* item = headers;

// The header name and value are passed as external one-byte strings

name_str = ExternalHeader::New(isolate, item->name);

value_str = ExternalHeader::New(isolate, item->value);

argv[j * 2] = name_str;

argv[j * 2 + 1] = value_str;

headers = item->next;

j++;

}

// For performance, we pass name and value pairs to array.protototype.push

// in batches of size NODE_PUSH_VAL_TO_ARRAY_MAX * 2 until there are no

// more items to push.

if (j > 0) {

fn->Call(env()->context(), holder, j * 2, argv).ToLocalChecked();

}

} while (headers != nullptr);

if (object()->Has(context, env()->onheaders_string()).FromJust()) {

Local<Value> argv[4] = {

Integer::New(isolate, stream->id()),

Integer::New(isolate, cat),

Integer::New(isolate, flags),

holder

};

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

}

}

void Http2Session::OnStreamClose(int32_t id, uint32_t code) {

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

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

HandleScope scope(isolate);

Context::Scope context_scope(context);

if (object()->Has(context, env()->onstreamclose_string()).FromJust()) {

Local<Value> argv[2] = {

Integer::New(isolate, id),

Integer::NewFromUnsigned(isolate, code)

};

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

}

}

void FreeDataChunk(char* data, void* hint) {

nghttp2_data_chunk_t* item = reinterpret_cast<nghttp2_data_chunk_t*>(hint);

delete[] data;

data_chunk_free_list.push(item);

}

void Http2Session::OnDataChunk(

Nghttp2Stream* stream,

nghttp2_data_chunk_t* chunk) {

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

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

HandleScope scope(isolate);

Local<Object> obj = Object::New(isolate);

obj->Set(context,

env()->id_string(),

Integer::New(isolate, stream->id())).FromJust();

ssize_t len = -1;

Local<Object> buf;

if (chunk != nullptr) {

len = chunk->buf.len;

buf = Buffer::New(isolate,

chunk->buf.base, len,

FreeDataChunk,

chunk).ToLocalChecked();

}

EmitData(len, buf, obj);

}

void Http2Session::OnSettings(bool ack) {

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

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

HandleScope scope(isolate);

Context::Scope context_scope(context);

if (object()->Has(context, env()->onsettings_string()).FromJust()) {

Local<Value> argv[1] = { Boolean::New(isolate, ack) };

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

}

}

void Http2Session::OnFrameError(int32_t id, uint8_t type, int error_code) {

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

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

HandleScope scope(isolate);

Context::Scope context_scope(context);

if (object()->Has(context, env()->onframeerror_string()).FromJust()) {

Local<Value> argv[3] = {

Integer::New(isolate, id),

Integer::New(isolate, type),

Integer::New(isolate, error_code)

};

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

}

}

void Http2Session::OnPriority(int32_t stream,

int32_t parent,

int32_t weight,

int8_t exclusive) {

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

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

HandleScope scope(isolate);

Context::Scope context_scope(context);

if (object()->Has(context, env()->onpriority_string()).FromJust()) {

Local<Value> argv[4] = {