posix_quic-master 创建stream

这里主要介绍quic stream的创建

QuicStream stream = QuicCreateStream(fd);//创建stream流

跟进这个QuicCreateStream()函数

QuicStream QuicCreateStream(QuicSocket sock)
{
//先判断传入的套接字
auto socket = EntryBase::GetFdManager().Get(sock);
if (!socket || socket->Category() != EntryCategory::Socket) {
DebugPrint(dbg_api, "sock = %d, return = -1, errno = EBADF", sock);
errno = EBADF;
return -1;
}
//返回一个id
auto stream = ((QuicSocketEntry*)socket.get())->CreateStream();
if (!stream) {
DebugPrint(dbg_api, "sock = %d, return = -1, errno = %d", sock, errno);
return -1;
}

DebugPrint(dbg_api, "sock = %d, newStream = %d", sock, stream->Fd());
return stream->Fd();
}

//跟进这个CreateStream()

QuicStreamEntryPtr QuicSocketEntry::CreateStream()
{
if (!IsConnected()) {
errno = ENOTCONN;	/* Transport endpoint is not connected */
return QuicStreamEntryPtr();
}

//首先是if循环语句 判断是否连接 我们跟进这个函数是什么

bool QuicSocketEntry::IsConnected()
{
return socketState_ == QuicSocketState_Connected;//连接状态
}

创建流的时候返回的是一个QuicStreamEntryPtr()

posix_quic::QuicStreamEntryPtr::shared_ptr() noexcept
constexpr shared_ptr() noexcept
: __shared_ptr<_Tp>() { }

跟进一下这个函数CreateOutgoingDynamicStream();

QuartcStream* QuartcSession::CreateOutgoingDynamicStream() {
// Use default priority for incoming QUIC streams.
// TODO(zhihuang): Determine if this value is correct.
return ActivateDataStream(CreateDataStream(GetNextOutgoingStreamId(),
QuicStream::kDefaultPriority));}

在上述函数中我们看到了设置流的优先级 这里采用的是默认的优先级QuicStream::kDefaultPriority,
以及创建流ID的函数 GetNextOutgoingStreamId(),

QuicStreamId QuicSession::GetNextOutgoingStreamId() {
QuicStreamId id = next_outgoing_stream_id_;
next_outgoing_stream_id_ += 2;
return id;
}

我们知道每个流ID都是独一无二的,使用每次增加2的方式改变流ID,使得每个都不相同
客户端创建的流是以偶数形式存在的.

std::unique_ptr<QuartcStream> QuartcSession::CreateDataStream(
QuicStreamId id,
SpdyPriority priority) {
if (crypto_stream_ == nullptr || !crypto_stream_->encryption_established()) {//判断是否加密
// Encryption not active so no stream created
return nullptr;
}
auto stream = QuicMakeUnique<QuartcStream>(id, this);
if (stream) {//这个stream不为空
// Register the stream to the QuicWriteBlockedList. |priority| is clamped
// between 0 and 7, with 0 being the highest priority and 7 the lowest
// priority.
if (!register_streams_early()) {//确保之前没有被登记过
write_blocked_streams()->RegisterStream(//根据流id和优先级来登记
stream->id(), /* is_static_stream= */ false, priority);
} else {//如果之前登记过,那么更新一下优先级别
write_blocked_streams()->UpdateStreamPriority(stream->id(), priority);
}

if (IsIncomingStream(id)) {
DCHECK(session_delegate_);
// Incoming streams need to be registered with the session_delegate_.
session_delegate_->OnIncomingStream(stream.get());
}
}
return stream;
}

An endpoint uses the Stream ID and Offset fields in STREAM frames to place data in order!

// A SPDY priority is a number between 0 and 7 (inclusive).
typedef uint8_t SpdyPriority;

// Lowest and Highest here refer to SPDY priorities as described in
// https://www.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3-1#TOC-2.3.3-Stream-priority
const SpdyPriority kV3HighestPriority = 0;
const SpdyPriority kV3LowestPriority = 7;
// Returns SPDY 3.x priority value clamped to the valid range of [0, 7].
SPDY_EXPORT_PRIVATE SpdyPriority ClampSpdy3Priority(SpdyPriority priority);

流是有八个优先级,是根据SPDY的优先级来的
最高级别是0

const SpdyPriority kV3HighestPriority = 0

最低级别是7

const SpdyPriority kV3LowestPriority = 7;

QuicSession拿到这个流的数据 换句话 说就是将stream交付于quicsession管理

return ActivateDataStream(CreateDataStream(GetNextOutgoingStreamId(),
QuicStream::kDefaultPriority));

QuartcStream* QuartcSession::ActivateDataStream(
std::unique_ptr<QuartcStream> stream) {
// Transfer ownership of the data stream to the session via ActivateStream().
QuartcStream* raw = stream.release();
if (raw) {
// Make QuicSession take ownership of the stream.
ActivateStream(std::unique_ptr<QuicStream>(raw));
}
return raw;
}