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;
}