#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::BigInt;

using v8::FunctionCallbackInfo;

using v8::FunctionTemplate;

using v8::Integer;

using v8::Just;

using v8::Local;

using v8::Maybe;

using v8::Nothing;

using v8::Object;

using v8::PropertyAttribute;

using v8::SharedArrayBuffer;

using v8::Uint32;

using v8::Value;

namespace quic {

#define STREAM_STATE(V) \

V(ID, id, int64_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(DESTROYED, destroyed, uint8_t) \

V(PAUSED, paused, uint8_t) \

V(RESET, reset, 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) \

V(CREATED_AT, created_at) \

V(RECEIVED_AT, received_at) \

V(ACKED_AT, acked_at) \

V(CLOSING_AT, closing_at) \

V(DESTROYED_AT, destroyed_at) \

V(BYTES_RECEIVED, bytes_received) \

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)

struct Stream::State {

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

STREAM_STATE(V)

#undef V

};

STAT_STRUCT(Stream, STREAM)

namespace {

Maybe<std::shared_ptr<DataQueue>> GetDataQueueFromSource(Environment* env,

}

} // namespace

struct Stream::Impl {

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) {

}

void Stream::RegisterExternalReferences(ExternalReferenceRegistry* registry) {

}

void Stream::Initialize(Environment* env, Local<Object> target) {

}

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,

}

Stream::Stream(BaseObjectWeakPtr<Session> session,

}

Stream::~Stream() {

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

DCHECK(is_destroyed());

}

int64_t Stream::id() const {

return state_->id;

}

Side Stream::origin() const {

return origin_;

}

Direction Stream::direction() const {

return direction_;

}

Session& Stream::session() const {

return *session_;

}

bool Stream::is_destroyed() const {

return state_->destroyed;

}

bool Stream::is_eos() const {

return state_->fin_sent;

}

bool Stream::is_writable() const {

}

bool Stream::is_readable() const {

}

BaseObjectPtr<Blob::Reader> Stream::get_reader() {

}

void Stream::set_final_size(uint64_t final_size) {

}

void Stream::set_outbound(std::shared_ptr<DataQueue> source) {

}

void Stream::EntryRead(size_t amount) {

}

int Stream::DoPull(bob::Next<ngtcp2_vec> next,

}

void Stream::BeginHeaders(HeadersKind kind) {

}

bool Stream::AddHeader(const Header& header) {

}

void Stream::Acknowledge(size_t datalen) {

}

void Stream::Commit(size_t datalen) {

if (!is_destroyed() && outbound_) outbound_->Commit(datalen);

}

void Stream::EndWritable() {

}

void Stream::EndReadable(std::optional<uint64_t> maybe_final_size) {

}

void Stream::Destroy(QuicError error) {

}

void Stream::ReceiveData(const uint8_t* data,

}

void Stream::ReceiveStopSending(QuicError error) {

}

void Stream::ReceiveStreamReset(uint64_t final_size, QuicError error) {

}

void Stream::EmitBlocked() {

}

void Stream::EmitClose(const QuicError& error) {

}

void Stream::EmitHeaders() {