NGHTTP2_STREAM_FLAG_NONE = 0x0,

// Writable side has ended

NGHTTP2_STREAM_FLAG_SHUT = 0x1,

// Reading has started

NGHTTP2_STREAM_FLAG_READ_START = 0x2,

// Reading is paused

NGHTTP2_STREAM_FLAG_READ_PAUSED = 0x4,

// Stream is closed

NGHTTP2_STREAM_FLAG_CLOSED = 0x8,

// Stream is destroyed

NGHTTP2_STREAM_FLAG_DESTROYED = 0x10,

// Stream has trailers

NGHTTP2_STREAM_FLAG_TRAILERS = 0x20,

// Stream has received all the data it can

NGHTTP2_STREAM_FLAG_EOS = 0x40

// Stream is not going to have any DATA frames

STREAM_OPTION_EMPTY_PAYLOAD = 0x1,

// Stream might have trailing headers

STREAM_OPTION_GET_TRAILERS = 0x2,

WriteWrap* req_wrap = nullptr;

uv_buf_t buf;

inline explicit nghttp2_stream_write(uv_buf_t buf_) : buf(buf_) {}

inline nghttp2_stream_write(WriteWrap* req, uv_buf_t buf_) :

req_wrap(req), buf(buf_) {}

nghttp2_rcbuf* name = nullptr;

nghttp2_rcbuf* value = nullptr;

uint8_t flags = 0;

HTTP_KNOWN_HEADER_MIN,

#define V(name, value) HTTP_HEADER_##name,

HTTP_KNOWN_HEADERS(V)

#undef V

#define V(name, code) HTTP_STATUS_##name = code,

HTTP_STATUS_CODES(V)

#undef V

// No padding strategy. This is the default.

PADDING_STRATEGY_NONE,

// Attempts to ensure that the frame is 8-byte aligned

PADDING_STRATEGY_ALIGNED,

// Padding will ensure all data frames are maxFrameSize

PADDING_STRATEGY_MAX,

// Padding will be determined via a JS callback. Note that this can be

// expensive because the callback is called once for every DATA and

// HEADERS frame. For performance reasons, this strategy should be

// avoided.

PADDING_STRATEGY_CALLBACK

SESSION_STATE_NONE = 0x0,

SESSION_STATE_HAS_SCOPE = 0x1,

SESSION_STATE_WRITE_SCHEDULED = 0x2,

SESSION_STATE_CLOSED = 0x4,

SESSION_STATE_CLOSING = 0x8,

SESSION_STATE_SENDING = 0x10,

public:

explicit Http2Scope(Http2Stream* stream);

explicit Http2Scope(Http2Session* session);

~Http2Scope();

private:

Http2Session* session_ = nullptr;

Local<Object> session_handle_;

public:

explicit Http2Options(Environment* env);

~Http2Options() {

nghttp2_option_del(options_);

}

nghttp2_option* operator*() const {

return options_;

}

void SetMaxHeaderPairs(uint32_t max) {

max_header_pairs_ = max;

}

uint32_t GetMaxHeaderPairs() const {

return max_header_pairs_;

}

void SetPaddingStrategy(padding_strategy_type val) {

padding_strategy_ = static_cast<padding_strategy_type>(val);

}

padding_strategy_type GetPaddingStrategy() const {

return padding_strategy_;

}

void SetMaxOutstandingPings(size_t max) {

max_outstanding_pings_ = max;

}

size_t GetMaxOutstandingPings() {

return max_outstanding_pings_;

}

void SetMaxOutstandingSettings(size_t max) {

max_outstanding_settings_ = max;

}

size_t GetMaxOutstandingSettings() {

return max_outstanding_settings_;

}

void SetMaxSessionMemory(uint64_t max) {

max_session_memory_ = max;

}

uint64_t GetMaxSessionMemory() {

return max_session_memory_;

}

private:

nghttp2_option* options_;

uint64_t max_session_memory_ = DEFAULT_MAX_SESSION_MEMORY;

uint32_t max_header_pairs_ = DEFAULT_MAX_HEADER_LIST_PAIRS;

padding_strategy_type padding_strategy_ = PADDING_STRATEGY_NONE;

size_t max_outstanding_pings_ = DEFAULT_MAX_PINGS;

size_t max_outstanding_settings_ = DEFAULT_MAX_SETTINGS;

public:

Http2Priority(Environment* env,

Local<Value> parent,

Local<Value> weight,

Local<Value> exclusive);

nghttp2_priority_spec* operator*() {

return &spec;

}

private:

nghttp2_priority_spec spec;

public:

uv_buf_t OnStreamAlloc(size_t suggested_size) override;

void OnStreamRead(ssize_t nread, const uv_buf_t& buf) override;

public StreamBase {

public:

Http2Stream(Http2Session* session,

int32_t id,

nghttp2_headers_category category = NGHTTP2_HCAT_HEADERS,

int options = 0);

~Http2Stream() override;

nghttp2_stream* operator*();

Http2Session* session() { return session_; }

const Http2Session* session() const { return session_; }

void EmitStatistics();

// Process a Data Chunk

void OnDataChunk(uv_buf_t* chunk);

// Required for StreamBase

int ReadStart() override;

// Required for StreamBase

int ReadStop() override;

// Required for StreamBase

int DoShutdown(ShutdownWrap* req_wrap) override;

bool HasWantsWrite() const override { return true; }

// Initiate a response on this stream.

int SubmitResponse(nghttp2_nv* nva, size_t len, int options);

// Submit informational headers for this stream

int SubmitInfo(nghttp2_nv* nva, size_t len);

// Submit trailing headers for this stream

int SubmitTrailers(nghttp2_nv* nva, size_t len);

void OnTrailers();

// Submit a PRIORITY frame for this stream

int SubmitPriority(nghttp2_priority_spec* prispec, bool silent = false);

// Submits an RST_STREAM frame using the given code

void SubmitRstStream(const uint32_t code);

void FlushRstStream();

// Submits a PUSH_PROMISE frame with this stream as the parent.

Http2Stream* SubmitPushPromise(

nghttp2_nv* nva,

size_t len,

int32_t* ret,

int options = 0);

void Close(int32_t code);

// Destroy this stream instance and free all held memory.

void Destroy();

inline bool IsDestroyed() const {

return flags_ & NGHTTP2_STREAM_FLAG_DESTROYED;

}

inline bool IsWritable() const {

return !(flags_ & NGHTTP2_STREAM_FLAG_SHUT);

}

inline bool IsPaused() const {

return flags_ & NGHTTP2_STREAM_FLAG_READ_PAUSED;

}

inline bool IsClosed() const {

return flags_ & NGHTTP2_STREAM_FLAG_CLOSED;

}

inline bool HasTrailers() const {

return flags_ & NGHTTP2_STREAM_FLAG_TRAILERS;

}

// Returns true if this stream is in the reading state, which occurs when

// the NGHTTP2_STREAM_FLAG_READ_START flag has been set and the

// NGHTTP2_STREAM_FLAG_READ_PAUSED flag is *not* set.

inline bool IsReading() const {

return flags_ & NGHTTP2_STREAM_FLAG_READ_START &&

!(flags_ & NGHTTP2_STREAM_FLAG_READ_PAUSED);

}

// Returns the RST_STREAM code used to close this stream

inline int32_t code() const { return code_; }

// Returns the stream identifier for this stream

inline int32_t id() const { return id_; }

inline void IncrementAvailableOutboundLength(size_t amount);

inline void DecrementAvailableOutboundLength(size_t amount);

bool AddHeader(nghttp2_rcbuf* name, nghttp2_rcbuf* value, uint8_t flags);

inline nghttp2_header* headers() {

return current_headers_.data();

}

inline nghttp2_headers_category headers_category() const {

return current_headers_category_;

}

inline size_t headers_count() const {

return current_headers_.size();

}

void StartHeaders(nghttp2_headers_category category);

// Required for StreamBase

bool IsAlive() override {

return true;

}

// Required for StreamBase

bool IsClosing() override {

return false;

}

AsyncWrap* GetAsyncWrap() override { return this; }

int DoWrite(WriteWrap* w, uv_buf_t* bufs, size_t count,

uv_stream_t* send_handle) override;

size_t self_size() const override { return sizeof(*this); }

std::string diagnostic_name() const override;

// JavaScript API

static void GetID(const FunctionCallbackInfo<Value>& args);

static void Destroy(const FunctionCallbackInfo<Value>& args);

static void FlushData(const FunctionCallbackInfo<Value>& args);

static void Priority(const FunctionCallbackInfo<Value>& args);

static void PushPromise(const FunctionCallbackInfo<Value>& args);

static void RefreshState(const FunctionCallbackInfo<Value>& args);

static void Info(const FunctionCallbackInfo<Value>& args);

static void Trailers(const FunctionCallbackInfo<Value>& args);

static void Respond(const FunctionCallbackInfo<Value>& args);

static void RstStream(const FunctionCallbackInfo<Value>& args);

class Provider;

struct Statistics {

uint64_t start_time;

uint64_t end_time;

uint64_t first_header; // Time first header was received

uint64_t first_byte; // Time first DATA frame byte was received

uint64_t first_byte_sent; // Time first DATA frame byte was sent

uint64_t sent_bytes;

uint64_t received_bytes;

};

Statistics statistics_ = {};

private:

Http2Session* session_; // The Parent HTTP/2 Session

int32_t id_; // The Stream Identifier

int32_t code_ = NGHTTP2_NO_ERROR; // The RST_STREAM code (if any)

int flags_ = NGHTTP2_STREAM_FLAG_NONE; // Internal state flags

uint32_t max_header_pairs_ = DEFAULT_MAX_HEADER_LIST_PAIRS;

uint32_t max_header_length_ = DEFAULT_SETTINGS_MAX_HEADER_LIST_SIZE;

// The Current Headers block... As headers are received for this stream,

// they are temporarily stored here until the OnFrameReceived is called

// signalling the end of the HEADERS frame

nghttp2_headers_category current_headers_category_ = NGHTTP2_HCAT_HEADERS;

uint32_t current_headers_length_ = 0; // total number of octets

std::vector<nghttp2_header> current_headers_;

// This keeps track of the amount of data read from the socket while the

// socket was in paused mode. When `ReadStart()` is called (and not before

// then), we tell nghttp2 that we consumed that data to get proper

// backpressure handling.

size_t inbound_consumed_data_while_paused_ = 0;

// Outbound Data... This is the data written by the JS layer that is

// waiting to be written out to the socket.

std::queue<nghttp2_stream_write> queue_;

size_t available_outbound_length_ = 0;

Http2StreamListener stream_listener_;

friend class Http2Session;

int32_t id,

uint8_t* buf,

size_t length,

uint32_t* flags,

nghttp2_data_source* source,

public:

Http2Session(Environment* env,

Local<Object> wrap,

nghttp2_session_type type = NGHTTP2_SESSION_SERVER);

~Http2Session() override;

class Http2Ping;

class Http2Settings;

void EmitStatistics();

inline StreamBase* underlying_stream() {

return static_cast<StreamBase*>(stream_);

}

void Start();

void Stop();

void Close(uint32_t code = NGHTTP2_NO_ERROR,

bool socket_closed = false);

void Consume(Local<External> external);

void Unconsume();

void Goaway(uint32_t code, int32_t lastStreamID, uint8_t* data, size_t len);

void AltSvc(int32_t id,

uint8_t* origin,

size_t origin_len,

uint8_t* value,

size_t value_len);

bool Ping(v8::Local<v8::Function> function);

uint8_t SendPendingData();

// Submits a new request. If the request is a success, assigned

// will be a pointer to the Http2Stream instance assigned.

// This only works if the session is a client session.

Http2Stream* SubmitRequest(

nghttp2_priority_spec* prispec,

nghttp2_nv* nva,

size_t len,

int32_t* ret,

int options = 0);

inline nghttp2_session_type type() const { return session_type_; }

inline nghttp2_session* session() const { return session_; }

inline nghttp2_session* operator*() { return session_; }

inline uint32_t GetMaxHeaderPairs() const { return max_header_pairs_; }

inline const char* TypeName() const;

inline bool IsDestroyed() {

return (flags_ & SESSION_STATE_CLOSED) || session_ == nullptr;

}

// Schedule a write if nghttp2 indicates it wants to write to the socket.

void MaybeScheduleWrite();

// Stop reading if nghttp2 doesn't want to anymore.

void MaybeStopReading();

// Returns pointer to the stream, or nullptr if stream does not exist

inline Http2Stream* FindStream(int32_t id);

inline bool CanAddStream();

// Adds a stream instance to this session

inline void AddStream(Http2Stream* stream);

// Removes a stream instance from this session

inline void RemoveStream(Http2Stream* stream);

// Indicates whether there currently exist outgoing buffers for this stream.

bool HasWritesOnSocketForStream(Http2Stream* stream);

// Write data to the session

ssize_t Write(const uv_buf_t* bufs, size_t nbufs);

size_t self_size() const override { return sizeof(*this); }

std::string diagnostic_name() const override;

// Schedule an RstStream for after the current write finishes.

inline void AddPendingRstStream(int32_t stream_id) {

pending_rst_streams_.emplace_back(stream_id);

}

inline bool HasPendingRstStream(int32_t stream_id) {

return pending_rst_streams_.end() != std::find(pending_rst_streams_.begin(),

pending_rst_streams_.end(),

stream_id);

}

// Handle reads/writes from the underlying network transport.

void OnStreamRead(ssize_t nread, const uv_buf_t& buf) override;

void OnStreamAfterWrite(WriteWrap* w, int status) override;

// The JavaScript API

static void New(const FunctionCallbackInfo<Value>& args);

static void Consume(const FunctionCallbackInfo<Value>& args);

static void Unconsume(const FunctionCallbackInfo<Value>& args);

static void Destroying(const FunctionCallbackInfo<Value>& args);

static void Destroy(const FunctionCallbackInfo<Value>& args);

static void Settings(const FunctionCallbackInfo<Value>& args);

static void Request(const FunctionCallbackInfo<Value>& args);

static void SetNextStreamID(const FunctionCallbackInfo<Value>& args);

static void Goaway(const FunctionCallbackInfo<Value>& args);

static void UpdateChunksSent(const FunctionCallbackInfo<Value>& args);

static void RefreshState(const FunctionCallbackInfo<Value>& args);

static void Ping(const FunctionCallbackInfo<Value>& args);

static void AltSvc(const FunctionCallbackInfo<Value>& args);

template <get_setting fn>

static void RefreshSettings(const FunctionCallbackInfo<Value>& args);

template <get_setting fn>

static void GetSettings(const FunctionCallbackInfo<Value>& args);

uv_loop_t* event_loop() const {

return env()->event_loop();

}

Http2Ping* PopPing();

bool AddPing(Http2Ping* ping);

Http2Settings* PopSettings();

bool AddSettings(Http2Settings* settings);

void IncrementCurrentSessionMemory(uint64_t amount) {

current_session_memory_ += amount;

}

void DecrementCurrentSessionMemory(uint64_t amount) {

current_session_memory_ -= amount;

}

// Returns the current session memory including the current size of both

// the inflate and deflate hpack headers, the current outbound storage

// queue, and pending writes.

uint64_t GetCurrentSessionMemory() {

uint64_t total = current_session_memory_ + sizeof(Http2Session);

total += nghttp2_session_get_hd_deflate_dynamic_table_size(session_);

total += nghttp2_session_get_hd_inflate_dynamic_table_size(session_);

total += outgoing_storage_.size();

return total;

}

// Return true if current_session_memory + amount is less than the max

bool IsAvailableSessionMemory(uint64_t amount) {

return GetCurrentSessionMemory() + amount <= max_session_memory_;

}

struct Statistics {

uint64_t start_time;

uint64_t end_time;

uint64_t ping_rtt;

uint64_t data_sent;

uint64_t data_received;

uint32_t frame_count;

uint32_t frame_sent;

int32_t stream_count;

size_t max_concurrent_streams;

double stream_average_duration;

};

Statistics statistics_ = {};

private:

// Frame Padding Strategies

ssize_t OnDWordAlignedPadding(size_t frameLength,

size_t maxPayloadLen);

ssize_t OnMaxFrameSizePadding(size_t frameLength,

size_t maxPayloadLen);

ssize_t OnCallbackPadding(size_t frameLength,

size_t maxPayloadLen);

// Frame Handler

void HandleDataFrame(const nghttp2_frame* frame);

void HandleGoawayFrame(const nghttp2_frame* frame);

void HandleHeadersFrame(const nghttp2_frame* frame);

void HandlePriorityFrame(const nghttp2_frame* frame);

void HandleSettingsFrame(const nghttp2_frame* frame);

void HandlePingFrame(const nghttp2_frame* frame);

void HandleAltSvcFrame(const nghttp2_frame* frame);

// nghttp2 callbacks

static int OnBeginHeadersCallback(

nghttp2_session* session,

const nghttp2_frame* frame,

void* user_data);

static int OnHeaderCallback(

nghttp2_session* session,

const nghttp2_frame* frame,

nghttp2_rcbuf* name,

nghttp2_rcbuf* value,

uint8_t flags,

void* user_data);

static int OnFrameReceive(

nghttp2_session* session,

const nghttp2_frame* frame,

void* user_data);

static int OnFrameNotSent(

nghttp2_session* session,

const nghttp2_frame* frame,

int error_code,

void* user_data);

static int OnFrameSent(

nghttp2_session* session,

const nghttp2_frame* frame,

void* user_data);

static int OnStreamClose(

nghttp2_session* session,

int32_t id,

uint32_t code,

void* user_data);

static int OnInvalidHeader(

nghttp2_session* session,

const nghttp2_frame* frame,

nghttp2_rcbuf* name,

nghttp2_rcbuf* value,

uint8_t flags,

void* user_data);

static int OnDataChunkReceived(

nghttp2_session* session,

uint8_t flags,

int32_t id,

const uint8_t* data,

size_t len,

void* user_data);

static ssize_t OnSelectPadding(

nghttp2_session* session,

const nghttp2_frame* frame,

size_t maxPayloadLen,

void* user_data);

static int OnNghttpError(

nghttp2_session* session,

const char* message,

size_t len,

void* user_data);

static int OnSendData(

nghttp2_session* session,

nghttp2_frame* frame,

const uint8_t* framehd,

size_t length,

nghttp2_data_source* source,

void* user_data);

static int OnInvalidFrame(

nghttp2_session* session,

const nghttp2_frame *frame,

int lib_error_code,

void* user_data);

struct Callbacks {

inline explicit Callbacks(bool kHasGetPaddingCallback);

inline ~Callbacks();

nghttp2_session_callbacks* callbacks;

};

/* Use callback_struct_saved[kHasGetPaddingCallback ? 1 : 0] */

static const Callbacks callback_struct_saved[2];

// The underlying nghttp2_session handle

nghttp2_session* session_;

// The session type: client or server

nghttp2_session_type session_type_;

// The maximum number of header pairs permitted for streams on this session

uint32_t max_header_pairs_ = DEFAULT_MAX_HEADER_LIST_PAIRS;

// The maximum amount of memory allocated for this session

uint64_t max_session_memory_ = DEFAULT_MAX_SESSION_MEMORY;

uint64_t current_session_memory_ = 0;

// The collection of active Http2Streams associated with this session

std::unordered_map<int32_t, Http2Stream*> streams_;

int flags_ = SESSION_STATE_NONE;

// The StreamBase instance being used for i/o