#if HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC

#include "streams.h"

#include <aliased_struct-inl.h>

#include <async_wrap-inl.h>

#include <base_object-inl.h>

#include <env-inl.h>

#include <memory_tracker-inl.h>

#include <node_blob.h>

#include <node_bob-inl.h>

#include <node_sockaddr-inl.h>

#include "application.h"

#include "bindingdata.h"

#include "defs.h"

#include "session.h"

namespace node {

using v8::Array;

using v8::ArrayBuffer;

using v8::ArrayBufferView;

using v8::BackingStoreInitializationMode;

using v8::BigInt;

using v8::FunctionCallbackInfo;

using v8::FunctionTemplate;

using v8::Global;

using v8::Integer;

using v8::Just;

using v8::Local;

using v8::Maybe;

using v8::Nothing;

using v8::Object;

using v8::ObjectTemplate;

using v8::PropertyAttribute;

using v8::SharedArrayBuffer;

using v8::Uint32;

using v8::Value;

namespace quic {

#define STREAM_STATE(V) \

V(ID, id, int64_t) \

V(PENDING, pending, uint8_t) \

V(FIN_SENT, fin_sent, uint8_t) \

V(FIN_RECEIVED, fin_received, uint8_t) \

V(READ_ENDED, read_ended, uint8_t) \

V(WRITE_ENDED, write_ended, uint8_t) \

V(PAUSED, paused, uint8_t) \

V(RESET, reset, uint8_t) \

V(HAS_OUTBOUND, has_outbound, uint8_t) \

V(HAS_READER, has_reader, uint8_t) \

/* Set when the stream has a block event handler */ \

V(WANTS_BLOCK, wants_block, uint8_t) \

/* Set when the stream has a headers event handler */ \

V(WANTS_HEADERS, wants_headers, uint8_t) \

/* Set when the stream has a reset event handler */ \

V(WANTS_RESET, wants_reset, uint8_t) \

/* Set when the stream has a trailers event handler */ \

V(WANTS_TRAILERS, wants_trailers, uint8_t)

#define STREAM_STATS(V) \

/* Marks the timestamp when the stream object was created. */ \

V(CREATED_AT, created_at) \

/* Marks the timestamp when the stream was opened. This can be different */ \

/* from the created_at timestamp if the stream was created in as pending */ \

V(OPENED_AT, opened_at) \

/* Marks the timestamp when the stream last received data */ \

V(RECEIVED_AT, received_at) \

/* Marks the timestamp when the stream last received an acknowledgement */ \

V(ACKED_AT, acked_at) \

/* Marks the timestamp when the stream was destroyed */ \

V(DESTROYED_AT, destroyed_at) \

/* Records the total number of bytes received by the stream */ \

V(BYTES_RECEIVED, bytes_received) \

/* Records the total number of bytes sent by the stream */ \

V(BYTES_SENT, bytes_sent) \

V(MAX_OFFSET, max_offset) \

V(MAX_OFFSET_ACK, max_offset_ack) \

V(MAX_OFFSET_RECV, max_offset_received) \

V(FINAL_SIZE, final_size)

#define STREAM_JS_METHODS(V) \

V(AttachSource, attachSource, false) \

V(Destroy, destroy, false) \

V(SendHeaders, sendHeaders, false) \

V(StopSending, stopSending, false) \

V(ResetStream, resetStream, false) \

V(SetPriority, setPriority, false) \

V(GetPriority, getPriority, true) \

V(GetReader, getReader, false)

PendingStream::PendingStream(Direction direction,

}

PendingStream::~PendingStream() {

pending_stream_queue_.Remove();

if (waiting_) {

Debug(stream_, "A pending stream was canceled");

}

}

void PendingStream::fulfill(int64_t id) {

}

void PendingStream::reject(QuicError error) {

}

struct Stream::PendingHeaders {

HeadersKind kind;

Global<Array> headers;

HeadersFlags flags;

PendingHeaders(HeadersKind kind_, Global<Array> headers_, HeadersFlags flags_)

: kind(kind_), headers(std::move(headers_)), flags(flags_) {}

DISALLOW_COPY_AND_MOVE(PendingHeaders)

};

struct Stream::State {

#define V(_, name, type) type name;

STREAM_STATE(V)

#undef V

};

STAT_STRUCT(Stream, STREAM)

Maybe<std::shared_ptr<DataQueue>> Stream::GetDataQueueFromSource(

Environment* env, Local<Value> value) {

DCHECK_IMPLIES(!value->IsUndefined(), value->IsObject());

std::vector<std::unique_ptr<DataQueue::Entry>> entries;

if (value->IsUndefined()) {

return Just(std::shared_ptr<DataQueue>());

} else if (value->IsArrayBuffer()) {

auto buffer = value.As<ArrayBuffer>();

entries.push_back(DataQueue::CreateInMemoryEntryFromBackingStore(

buffer->GetBackingStore(), 0, buffer->ByteLength()));

return Just(DataQueue::CreateIdempotent(std::move(entries)));

} else if (value->IsSharedArrayBuffer()) {

auto buffer = value.As<SharedArrayBuffer>();

entries.push_back(DataQueue::CreateInMemoryEntryFromBackingStore(

buffer->GetBackingStore(), 0, buffer->ByteLength()));

return Just(DataQueue::CreateIdempotent(std::move(entries)));

} else if (value->IsArrayBufferView()) {

auto entry =

DataQueue::CreateInMemoryEntryFromView(value.As<ArrayBufferView>());

if (!entry) {

THROW_ERR_INVALID_ARG_TYPE(env, "Data source not detachable");

return Nothing<std::shared_ptr<DataQueue>>();

}

entries.push_back(std::move(entry));

return Just(DataQueue::CreateIdempotent(std::move(entries)));

} else if (Blob::HasInstance(env, value)) {

Blob* blob;

ASSIGN_OR_RETURN_UNWRAP(

&blob, value, Nothing<std::shared_ptr<DataQueue>>());

return Just(blob->getDataQueue().slice(0));

}

// TODO(jasnell): Add streaming sources...

THROW_ERR_INVALID_ARG_TYPE(env, "Invalid data source type");

return Nothing<std::shared_ptr<DataQueue>>();

}

struct Stream::Impl {

// Attaches an outbound data source to the stream.

static void AttachSource(const FunctionCallbackInfo<Value>& args) {

}

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

}

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

}

// Tells the peer to stop sending data for this stream. This has the effect

// of shutting down the readable side of the stream for this peer. Any data

// that has already been received is still readable.

static void StopSending(const FunctionCallbackInfo<Value>& args) {

}

// Sends a reset stream to the peer to tell it we will not be sending any

// more data for this stream. This has the effect of shutting down the

// writable side of the stream for this peer. Any data that is held in the

// outbound queue will be dropped. The stream may still be readable.

static void ResetStream(const FunctionCallbackInfo<Value>& args) {

}

static void SetPriority(const FunctionCallbackInfo<Value>& args) {

}

static void GetPriority(const FunctionCallbackInfo<Value>& args) {

}

static void GetReader(const FunctionCallbackInfo<Value>& args) {

}

};

class Stream::Outbound final : public MemoryRetainer {

public:

Outbound(Stream* stream, std::shared_ptr<DataQueue> queue)

: stream_(stream),

queue_(std::move(queue)),

reader_(queue_->get_reader()) {}

void Acknowledge(size_t amount) {

}

void Commit(size_t amount) {

}

void Cap() {

}

int Pull(bob::Next<ngtcp2_vec> next,

}

void MemoryInfo(MemoryTracker* tracker) const override {

}

SET_MEMORY_INFO_NAME(Stream::Outbound)

SET_SELF_SIZE(Outbound)

private:

struct OnComplete {

};

void PullUncommitted(bob::Next<ngtcp2_vec> next) {

}

void MarkErrored() {

}

void MarkEnded() {

}

void Append(const DataQueue::Vec* vectors, size_t count, bob::Done done) {

}

Stream* stream_;

std::shared_ptr<DataQueue> queue_;

std::shared_ptr<DataQueue::Reader> reader_;

bool errored_ = false;

// Will be set to true if the reader_ ends up providing a pull result

// asynchronously.

bool next_pending_ = false;

// Will be set to true once reader_ has returned eos.

bool eos_ = false;

// The collection of buffers that we have pulled from reader_ and that we

// are holding onto until they are acknowledged.

struct Entry {

};

std::unique_ptr<Entry> head_ = nullptr;

Entry* commit_head_ = nullptr;

Entry* tail_ = nullptr;

// The total number of uncommitted chunks.

size_t count_ = 0;

// The total number of bytes currently held in the buffer.

size_t total_ = 0;

// The current byte offset of buffer_ that has been confirmed to have been

// sent. Any offset lower than this represents bytes that we are currently

// waiting to be acknowledged. When we receive acknowledgement, we will

// automatically free held bytes from the buffer.

size_t uncommitted_ = 0;

};

bool Stream::HasInstance(Environment* env, Local<Value> value) {

return GetConstructorTemplate(env)->HasInstance(value);

}

Local<FunctionTemplate> Stream::GetConstructorTemplate(Environment* env) {

auto& state = BindingData::Get(env);

auto tmpl = state.stream_constructor_template();

if (tmpl.IsEmpty()) {

auto isolate = env->isolate();

tmpl = NewFunctionTemplate(isolate, IllegalConstructor);

tmpl->SetClassName(state.stream_string());

tmpl->Inherit(AsyncWrap::GetConstructorTemplate(env));

tmpl->InstanceTemplate()->SetInternalFieldCount(kInternalFieldCount);

#define V(name, key, no_side_effect) \

if (no_side_effect) { \

SetProtoMethodNoSideEffect(isolate, tmpl, #key, Impl::name); \

} else { \

SetProtoMethod(isolate, tmpl, #key, Impl::name); \

}

STREAM_JS_METHODS(V)

#undef V

state.set_stream_constructor_template(tmpl);

}

return tmpl;

}

void Stream::RegisterExternalReferences(ExternalReferenceRegistry* registry) {

#define V(name, _, __) registry->Register(Impl::name);

STREAM_JS_METHODS(V)

#undef V

}

void Stream::InitPerIsolate(IsolateData* data, Local<ObjectTemplate> target) {

// TODO(@jasnell): Implement the per-isolate state

}

void Stream::InitPerContext(Realm* realm, Local<Object> target) {

USE(GetConstructorTemplate(realm->env()));

#define V(name, _) IDX_STATS_STREAM_##name,

enum StreamStatsIdx { STREAM_STATS(V) IDX_STATS_STREAM_COUNT };

#undef V

#define V(name, key, __) \

auto IDX_STATE_STREAM_##name = offsetof(Stream::State, key);

STREAM_STATE(V)

#undef V

#define V(name, _) NODE_DEFINE_CONSTANT(target, IDX_STATS_STREAM_##name);

STREAM_STATS(V)

#undef V

#define V(name, _, __) NODE_DEFINE_CONSTANT(target, IDX_STATE_STREAM_##name);

STREAM_STATE(V)

#undef V

constexpr int QUIC_STREAM_HEADERS_KIND_HINTS =

static_cast<int>(HeadersKind::HINTS);

constexpr int QUIC_STREAM_HEADERS_KIND_INITIAL =

static_cast<int>(HeadersKind::INITIAL);

constexpr int QUIC_STREAM_HEADERS_KIND_TRAILING =

static_cast<int>(HeadersKind::TRAILING);

constexpr int QUIC_STREAM_HEADERS_FLAGS_NONE =

static_cast<int>(HeadersFlags::NONE);

constexpr int QUIC_STREAM_HEADERS_FLAGS_TERMINAL =

static_cast<int>(HeadersFlags::TERMINAL);

NODE_DEFINE_CONSTANT(target, QUIC_STREAM_HEADERS_KIND_HINTS);

NODE_DEFINE_CONSTANT(target, QUIC_STREAM_HEADERS_KIND_INITIAL);

NODE_DEFINE_CONSTANT(target, QUIC_STREAM_HEADERS_KIND_TRAILING);

NODE_DEFINE_CONSTANT(target, QUIC_STREAM_HEADERS_FLAGS_NONE);

NODE_DEFINE_CONSTANT(target, QUIC_STREAM_HEADERS_FLAGS_TERMINAL);

}

Stream* Stream::From(void* stream_user_data) {

DCHECK_NOT_NULL(stream_user_data);

return static_cast<Stream*>(stream_user_data);

}

BaseObjectPtr<Stream> Stream::Create(Session* session,

int64_t id,

std::shared_ptr<DataQueue> source) {

DCHECK_GE(id, 0);

DCHECK_NOT_NULL(session);

Local<Object> obj;

if (!GetConstructorTemplate(session->env())

->InstanceTemplate()

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

.ToLocal(&obj)) {

return {};

}

return MakeDetachedBaseObject<Stream>(

BaseObjectWeakPtr<Session>(session), obj, id, std::move(source));

}

BaseObjectPtr<Stream> Stream::Create(Session* session,

Direction direction,

std::shared_ptr<DataQueue> source) {

DCHECK_NOT_NULL(session);

Local<Object> obj;

if (!GetConstructorTemplate(session->env())

->InstanceTemplate()

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

.ToLocal(&obj)) {

return {};

}

return MakeBaseObject<Stream>(

BaseObjectWeakPtr<Session>(session), obj, direction, std::move(source));

}

Stream::Stream(BaseObjectWeakPtr<Session> session,

}

Stream::Stream(BaseObjectWeakPtr<Session> session,

}

Stream::~Stream() {

// Make sure that Destroy() was called before Stream is actually destructed.

DCHECK_NE(stats_->destroyed_at, 0);

}

void Stream::NotifyStreamOpened(int64_t id) {

CHECK(is_pending());

Debug(this, "Pending stream opened with id %" PRIi64, id);

state_->pending = 0;

state_->id = id;

STAT_RECORD_TIMESTAMP(Stats, opened_at);

// Now that the stream is actually opened, add it to the sessions

// list of known open streams.

session().AddStream(BaseObjectPtr<Stream>(this),

Session::CreateStreamOption::DO_NOT_NOTIFY);

CHECK_EQ(ngtcp2_conn_set_stream_user_data(this->session(), id, this), 0);

maybe_pending_stream_.reset();

if (pending_priority_) {

auto& priority = pending_priority_.value();

session().application().SetStreamPriority(

*this, priority.priority, priority.flags);

pending_priority_ = std::nullopt;

}

decltype(pending_headers_queue_) queue;

pending_headers_queue_.swap(queue);

for (auto& headers : queue) {

// TODO(@jasnell): What if the application does not support headers?

session().application().SendHeaders(*this,

headers->kind,

headers->headers.Get(env()->isolate()),

headers->flags);

}

// If the stream is not a local undirectional stream and is_readable is

// false, then we should shutdown the streams readable side now.

if (!is_local_unidirectional() && !is_readable()) {

NotifyReadableEnded(pending_close_read_code_);

}

if (!is_remote_unidirectional() && !is_writable()) {

NotifyWritableEnded(pending_close_write_code_);

}

// Finally, if we have an outbound data source attached already, make

// sure our stream is scheduled. This is likely a bit superfluous

// since the stream likely hasn't had any opporunity to get blocked

// yet, but just for completeness, let's make sure.

if (outbound_) session().ResumeStream(id);

}

void Stream::NotifyReadableEnded(uint64_t code) {

CHECK(!is_pending());

Session::SendPendingDataScope send_scope(&session());

ngtcp2_conn_shutdown_stream_read(session(), 0, id(), code);

}

void Stream::NotifyWritableEnded(uint64_t code) {

CHECK(!is_pending());

Session::SendPendingDataScope send_scope(&session());

ngtcp2_conn_shutdown_stream_write(session(), 0, id(), code);

}

void Stream::EnqueuePendingHeaders(HeadersKind kind,

Local<Array> headers,

HeadersFlags flags) {

Debug(this, "Enqueuing headers for pending stream");

pending_headers_queue_.push_back(std::make_unique<PendingHeaders>(

kind, Global<Array>(env()->isolate(), headers), flags));

}

bool Stream::is_pending() const {

return state_->pending;

}

int64_t Stream::id() const {

return state_->id;

}

Side Stream::origin() const {

CHECK(!is_pending());

return (state_->id & 0b01) ? Side::SERVER : Side::CLIENT;

}

Direction Stream::direction() const {

if (state_->pending) {

CHECK(maybe_pending_stream_.has_value());

auto& val = maybe_pending_stream_.value();

return val->direction();

}

return (state_->id & 0b10) ? Direction::UNIDIRECTIONAL

: Direction::BIDIRECTIONAL;

}

Session& Stream::session() const {

return *session_;

}

bool Stream::is_local_unidirectional() const {

return direction() == Direction::UNIDIRECTIONAL &&

ngtcp2_conn_is_local_stream(*session_, id());

}

bool Stream::is_remote_unidirectional() const {

return direction() == Direction::UNIDIRECTIONAL &&

!ngtcp2_conn_is_local_stream(*session_, id());

}

bool Stream::is_eos() const {

return state_->fin_sent;

}

bool Stream::is_writable() const {

// Remote unidirectional streams are never writable, and remote streams can

// never be pending.

if (!is_pending() && direction() == Direction::UNIDIRECTIONAL &&

!ngtcp2_conn_is_local_stream(session(), id())) {

return false;

}

return state_->write_ended == 0;

}