// Copyright (c) 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef QUICHE_QUIC_CORE_QUIC_STREAM_ID_MANAGER_H_
#define QUICHE_QUIC_CORE_QUIC_STREAM_ID_MANAGER_H_

#include "net/third_party/quiche/src/quic/core/frames/quic_frame.h"
#include "net/third_party/quiche/src/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h"

namespace quic {

namespace test {
class QuicSessionPeer;
class QuicStreamIdManagerPeer;
}  // namespace test

class QuicSession;

// Amount to increment a stream ID value to get the next stream ID in
// the stream ID space.
const QuicStreamId kV99StreamIdIncrement = 4;

// This constant controls the size of the window when deciding whether
// to generate a MAX STREAM ID frame or not. See the discussion of the
// window, below, for more details.
const int kMaxStreamIdWindowDivisor = 2;

// This class manages the stream ids for Version 99/IETF QUIC.
// TODO(fkastenholz): Expand to support bi- and uni-directional stream ids
// TODO(fkastenholz): Roll in pre-version-99 management
class QUIC_EXPORT_PRIVATE QuicStreamIdManager {
 public:
  QuicStreamIdManager(QuicSession* session,
                      QuicStreamId next_outgoing_stream_id,
                      QuicStreamId largest_peer_created_stream_id,
                      QuicStreamId first_incoming_dynamic_stream_id,
                      size_t max_allowed_outgoing_streams,
                      size_t max_allowed_incoming_streams);

  ~QuicStreamIdManager();

  // Generate a string suitable for sending to the log/etc to show current state
  // of the stream ID manager.
  std::string DebugString() const {
    return QuicStrCat(
        " { max_allowed_outgoing_stream_id: ", max_allowed_outgoing_stream_id_,
        ", actual_max_allowed_incoming_stream_id_: ",
        actual_max_allowed_incoming_stream_id_,
        ", advertised_max_allowed_incoming_stream_id_: ",
        advertised_max_allowed_incoming_stream_id_,
        ", max_stream_id_window_: ", max_stream_id_window_,
        ", max_allowed_outgoing_streams_: ", max_allowed_outgoing_streams_,
        ", max_allowed_incoming_streams_: ", max_allowed_incoming_streams_,
        ", available_incoming_streams_: ", available_incoming_streams_,
        ", first_incoming_dynamic_stream_id_: ",
        first_incoming_dynamic_stream_id_,
        ", first_outgoing_dynamic_stream_id_: ",
        first_outgoing_dynamic_stream_id_, " }");
  }

  // Processes the MAX STREAM ID frame, invoked from
  // QuicSession::OnMaxStreamIdFrame. It has the same semantics as the
  // QuicFramerVisitorInterface, returning true if the framer should continue
  // processing the packet, false if not.
  bool OnMaxStreamIdFrame(const QuicMaxStreamIdFrame& frame);

  // Processes the STREAM ID BLOCKED frame, invoked from
  // QuicSession::OnStreamIdBlockedFrame. It has the same semantics as the
  // QuicFramerVisitorInterface, returning true if the framer should continue
  // processing the packet, false if not.
  bool OnStreamIdBlockedFrame(const QuicStreamIdBlockedFrame& frame);

  // Indicates whether the next outgoing stream ID can be allocated or not. The
  // test is whether it will exceed the maximum-stream-id or not.
  bool CanOpenNextOutgoingStream();

  // Generate and send a MAX_STREAM_ID frame.
  void SendMaxStreamIdFrame();

  // Invoked to deal with releasing a stream ID.
  void OnStreamClosed(QuicStreamId stream_id);

  // Returns the next outgoing stream id. If it fails (due to running into the
  // max_allowed_outgoing_stream_id limit) then it returns an invalid stream id.
  QuicStreamId GetNextOutgoingStreamId();

  // Initialize the maximum allowed incoming stream id and number of streams.
  void SetMaxOpenIncomingStreams(size_t max_streams);

  // Initialize the maximum allowed outgoing stream id, number of streams, and
  // MAX_STREAM_ID advertisement window.
  void SetMaxOpenOutgoingStreams(size_t max_streams);

  // Register a new stream as a static stream. This is used so that the
  // advertised maximum stream ID can be calculated based on the start of the
  // dynamic stream space. This method will take any stream ID, one that either
  // this node or the peer will initiate.
  void RegisterStaticStream(QuicStreamId stream_id);

  // Check that an incoming stream id is valid -- is below the maximum allowed
  // stream ID. Note that this method uses the actual maximum, not the most
  // recently advertised maximum this helps preserve the Google-QUIC semantic
  // that we actually care about the number of open streams, not the maximum
  // stream ID.  Returns true if the stream ID is valid. If the stream ID fails
  // the test, will close the connection (per the protocol specification) and
  // return false. This method also maintains state with regard to the number of
  // streams that the peer can open (used for generating MAX_STREAM_ID frames).
  // This method should be called exactly once for each incoming stream
  // creation.
  bool MaybeIncreaseLargestPeerStreamId(const QuicStreamId stream_id);

  // Returns true if |id| is still available.
  bool IsAvailableStream(QuicStreamId id) const;

  // Return true if given stream is peer initiated.
  bool IsIncomingStream(QuicStreamId id) const;

  size_t max_allowed_outgoing_streams() const {
    return max_allowed_outgoing_streams_;
  }
  size_t max_allowed_incoming_streams() const {
    return max_allowed_incoming_streams_;
  }
  QuicStreamId max_allowed_outgoing_stream_id() const {
    return max_allowed_outgoing_stream_id_;
  }
  QuicStreamId advertised_max_allowed_incoming_stream_id() const {
    return advertised_max_allowed_incoming_stream_id_;
  }
  QuicStreamId actual_max_allowed_incoming_stream_id() const {
    return actual_max_allowed_incoming_stream_id_;
  }
  QuicStreamId max_stream_id_window() const { return max_stream_id_window_; }

  QuicStreamId next_outgoing_stream_id() const {
    return next_outgoing_stream_id_;
  }

  QuicStreamId first_incoming_dynamic_stream_id() {
    return first_incoming_dynamic_stream_id_;
  }
  QuicStreamId first_outgoing_dynamic_stream_id() {
    return first_outgoing_dynamic_stream_id_;
  }
  size_t available_incoming_streams() { return available_incoming_streams_; }

  void set_max_allowed_incoming_streams(size_t stream_count) {
    max_allowed_incoming_streams_ = stream_count;
  }

  void set_largest_peer_created_stream_id(
      QuicStreamId largest_peer_created_stream_id) {
    largest_peer_created_stream_id_ = largest_peer_created_stream_id;
  }

 private:
  friend class test::QuicSessionPeer;
  friend class test::QuicStreamIdManagerPeer;

  // Check whether the MAX_STREAM_ID window has opened up enough and, if so,
  // generate and send a MAX_STREAM_ID frame.
  void MaybeSendMaxStreamIdFrame();

  // Back reference to the session containing this Stream ID Manager.
  // needed to access various session methods, such as perspective()
  QuicSession* session_;

  // The ID to use for the next outgoing stream.
  QuicStreamId next_outgoing_stream_id_;

  // Set of stream ids that are less than the largest stream id that has been
  // received, but are nonetheless available to be created.
  QuicUnorderedSet<QuicStreamId> available_streams_;

  QuicStreamId largest_peer_created_stream_id_;

  // The maximum stream ID value that we can use. This is initialized based on,
  // first, the default number of open streams we can do, updated per the number
  // of streams we receive in the transport parameters, and then finally is
  // modified whenever a MAX_STREAM_ID frame is received from the peer.
  QuicStreamId max_allowed_outgoing_stream_id_;

  // Unlike for streams this node initiates, for incoming streams, there are two
  // maxima; the actual maximum which is the limit the peer must obey and the
  // maximum that was most recently advertised to the peer in a MAX_STREAM_ID
  // frame.
  //
  // The advertised maximum is never larger than the actual maximum. The actual
  // maximum increases whenever an incoming stream is closed. The advertised
  // maximum increases (to the actual maximum) whenever a MAX_STREAM_ID is sent.
  //
  // The peer is granted some leeway, incoming streams are accepted as long as
  // their stream id is not greater than the actual maximum.  The protocol
  // specifies that the advertised maximum is the limit. This implmentation uses
  // the actual maximum in order to support Google-QUIC semantics, where it's
  // the number of open streams, not their ID number, that is the real limit.
  QuicStreamId actual_max_allowed_incoming_stream_id_;
  QuicStreamId advertised_max_allowed_incoming_stream_id_;

  // max_stream_id_window_ is set to max_allowed_outgoing_streams_ / 2
  // (half of the number of streams that are allowed).  The local node
  // does not send a MAX_STREAM_ID frame to the peer until the local node
  // believes that the peer can open fewer than |max_stream_id_window_|
  // streams. When that is so, the local node sends a MAX_STREAM_ID every time
  // an inbound stream is closed.
  QuicStreamId max_stream_id_window_;

  // Maximum number of outgoing and incoming streams that are allowed to be
  // concurrently opened. Initialized as part of configuration.
  size_t max_allowed_outgoing_streams_;
  size_t max_allowed_incoming_streams_;

  // Keep track of the first dynamic stream id (which is the largest static
  // stream id plus one id).  For Google QUIC, static streams are not counted
  // against the stream count limit. When the number of static streams
  // increases, the maximum stream id has to increase by a corresponding amount.
  // These are used as floors from which the relevant maximum is
  // calculated. Keeping the "first dynamic" rather than the "last static" has
  // some implementation advantages.
  QuicStreamId first_incoming_dynamic_stream_id_;
  QuicStreamId first_outgoing_dynamic_stream_id_;

  // Number of streams that that this node believes that the
  // peer can open. It is initialized to the same value as
  // max_allowed_incoming_streams_. It is decremented every
  // time a new incoming stream is detected.  A MAX_STREAM_ID
  // is sent whenver a stream closes and this counter is less
  // than the window. When that happens, it is incremented by
  // the number of streams we make available (the actual max
  // stream ID - the most recently advertised one)
  size_t available_incoming_streams_;
};

}  // namespace quic

#endif  // QUICHE_QUIC_CORE_QUIC_STREAM_ID_MANAGER_H_