/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef mozilla_net_Http2Stream_h
#define mozilla_net_Http2Stream_h

// HTTP/2 - RFC7540
// https://www.rfc-editor.org/rfc/rfc7540.txt

#include "mozilla/Attributes.h"
#include "mozilla/UniquePtr.h"
#include "nsAHttpTransaction.h"
#include "nsISupportsPriority.h"
#include "SimpleBuffer.h"

class nsIInputStream;
class nsIOutputStream;

namespace mozilla {
class OriginAttributes;
}

namespace mozilla {
namespace net {

class nsStandardURL;
class Http2Session;
class Http2Decompressor;

class Http2Stream : public nsAHttpSegmentReader,
                    public nsAHttpSegmentWriter,
                    public SupportsWeakPtr<Http2Stream> {
 public:
  MOZ_DECLARE_WEAKREFERENCE_TYPENAME(Http2Stream)
  NS_DECL_NSAHTTPSEGMENTREADER
  NS_DECL_NSAHTTPSEGMENTWRITER

  enum stateType {
    IDLE,
    RESERVED_BY_REMOTE,
    OPEN,
    CLOSED_BY_LOCAL,
    CLOSED_BY_REMOTE,
    CLOSED
  };

  const static int32_t kNormalPriority = 0x1000;
  const static int32_t kWorstPriority =
      kNormalPriority + nsISupportsPriority::PRIORITY_LOWEST;
  const static int32_t kBestPriority =
      kNormalPriority + nsISupportsPriority::PRIORITY_HIGHEST;

  Http2Stream(nsAHttpTransaction *, Http2Session *, int32_t, uint64_t);

  uint32_t StreamID() { return mStreamID; }
  Http2PushedStream *PushSource() { return mPushSource; }
  void ClearPushSource();

  stateType HTTPState() { return mState; }
  void SetHTTPState(stateType val) { mState = val; }

  virtual MOZ_MUST_USE nsresult ReadSegments(nsAHttpSegmentReader *, uint32_t,
                                             uint32_t *);
  virtual MOZ_MUST_USE nsresult WriteSegments(nsAHttpSegmentWriter *, uint32_t,
                                              uint32_t *);
  virtual bool DeferCleanup(nsresult status);

  // The consumer stream is the synthetic pull stream hooked up to this stream
  // http2PushedStream overrides it
  virtual Http2Stream *GetConsumerStream() { return nullptr; };

  const nsCString &Origin() const { return mOrigin; }
  const nsCString &Host() const { return mHeaderHost; }
  const nsCString &Path() const { return mHeaderPath; }

  bool RequestBlockedOnRead() {
    return static_cast<bool>(mRequestBlockedOnRead);
  }

  bool HasRegisteredID() { return mStreamID != 0; }

  nsAHttpTransaction *Transaction() { return mTransaction; }
  virtual nsIRequestContext *RequestContext() {
    return mTransaction ? mTransaction->RequestContext() : nullptr;
  }

  void Close(nsresult reason);
  void SetResponseIsComplete();

  void SetRecvdFin(bool aStatus);
  bool RecvdFin() { return mRecvdFin; }

  void SetRecvdData(bool aStatus) { mReceivedData = aStatus ? 1 : 0; }
  bool RecvdData() { return mReceivedData; }

  void SetSentFin(bool aStatus);
  bool SentFin() { return mSentFin; }

  void SetRecvdReset(bool aStatus);
  bool RecvdReset() { return mRecvdReset; }

  void SetSentReset(bool aStatus);
  bool SentReset() { return mSentReset; }

  void SetQueued(bool aStatus) { mQueued = aStatus ? 1 : 0; }
  bool Queued() { return mQueued; }

  void SetCountAsActive(bool aStatus) { mCountAsActive = aStatus ? 1 : 0; }
  bool CountAsActive() { return mCountAsActive; }

  void SetAllHeadersReceived();
  void UnsetAllHeadersReceived() { mAllHeadersReceived = 0; }
  bool AllHeadersReceived() { return mAllHeadersReceived; }

  void UpdateTransportSendEvents(uint32_t count);
  void UpdateTransportReadEvents(uint32_t count);

  // NS_ERROR_ABORT terminates stream, other failure terminates session
  MOZ_MUST_USE nsresult ConvertResponseHeaders(Http2Decompressor *,
                                               nsACString &, nsACString &,
                                               int32_t &);
  MOZ_MUST_USE nsresult ConvertPushHeaders(Http2Decompressor *, nsACString &,
                                           nsACString &);
  MOZ_MUST_USE nsresult ConvertResponseTrailers(Http2Decompressor *,
                                                nsACString &);

  bool AllowFlowControlledWrite();
  void UpdateServerReceiveWindow(int32_t delta);
  int64_t ServerReceiveWindow() { return mServerReceiveWindow; }

  void DecrementClientReceiveWindow(uint32_t delta) {
    mClientReceiveWindow -= delta;
    mLocalUnacked += delta;
  }

  void IncrementClientReceiveWindow(uint32_t delta) {
    mClientReceiveWindow += delta;
    mLocalUnacked -= delta;
  }

  uint64_t LocalUnAcked();
  int64_t ClientReceiveWindow() { return mClientReceiveWindow; }

  bool BlockedOnRwin() { return mBlockedOnRwin; }

  uint32_t Priority() { return mPriority; }
  void SetPriority(uint32_t);
  void SetPriorityDependency(uint32_t, uint8_t, bool);
  void UpdatePriorityDependency();

  // A pull stream has an implicit sink, a pushed stream has a sink
  // once it is matched to a pull stream.
  virtual bool HasSink() { return true; }

  // This is a no-op on pull streams. Pushed streams override this.
  virtual void SetPushComplete(){};

  virtual ~Http2Stream();

  Http2Session *Session() { return mSession; }

  static MOZ_MUST_USE nsresult MakeOriginURL(const nsACString &origin,
                                             nsCOMPtr<nsIURI> &url);

  static MOZ_MUST_USE nsresult MakeOriginURL(const nsACString &scheme,
                                             const nsACString &origin,
                                             nsCOMPtr<nsIURI> &url);

  // Mirrors nsAHttpTransaction
  bool Do0RTT();
  nsresult Finish0RTT(bool aRestart, bool aAlpnIgnored);

  nsresult GetOriginAttributes(mozilla::OriginAttributes *oa);

  void TopLevelOuterContentWindowIdChanged(uint64_t windowId);

 protected:
  static void CreatePushHashKey(
      const nsCString &scheme, const nsCString &hostHeader,
      const mozilla::OriginAttributes &originAttributes, uint64_t serial,
      const nsACString &pathInfo, nsCString &outOrigin, nsCString &outKey);

  // These internal states track request generation
  enum upstreamStateType {
    GENERATING_HEADERS,
    GENERATING_BODY,
    SENDING_BODY,
    SENDING_FIN_STREAM,
    UPSTREAM_COMPLETE
  };

  uint32_t mStreamID;

  // The session that this stream is a subset of
  Http2Session *mSession;

  // These are temporary state variables to hold the argument to
  // Read/WriteSegments so it can be accessed by On(read/write)segment
  // further up the stack.
  nsAHttpSegmentReader *mSegmentReader;
  nsAHttpSegmentWriter *mSegmentWriter;

  nsCString mOrigin;
  nsCString mHeaderHost;
  nsCString mHeaderScheme;
  nsCString mHeaderPath;

  // Each stream goes from generating_headers to upstream_complete, perhaps
  // looping on multiple instances of generating_body and
  // sending_body for each frame in the upload.
  enum upstreamStateType mUpstreamState;

  // The HTTP/2 state for the stream from section 5.1
  enum stateType mState;

  // Flag is set when all http request headers have been read ID is not stable
  uint32_t mRequestHeadersDone : 1;

  // Flag is set when ID is stable and concurrency limits are met
  uint32_t mOpenGenerated : 1;

  // Flag is set when all http response headers have been read
  uint32_t mAllHeadersReceived : 1;

  // Flag is set when stream is queued inside the session due to
  // concurrency limits being exceeded
  uint32_t mQueued : 1;

  void ChangeState(enum upstreamStateType);

  virtual void AdjustInitialWindow();
  MOZ_MUST_USE nsresult TransmitFrame(const char *, uint32_t *,
                                      bool forceCommitment);

  // The underlying socket transport object is needed to propogate some events
  nsISocketTransport *mSocketTransport;

 private:
  friend class nsAutoPtr<Http2Stream>;

  MOZ_MUST_USE nsresult ParseHttpRequestHeaders(const char *, uint32_t,
                                                uint32_t *);
  MOZ_MUST_USE nsresult GenerateOpen();

  void AdjustPushedPriority();
  void GenerateDataFrameHeader(uint32_t, bool);

  MOZ_MUST_USE nsresult BufferInput(uint32_t, uint32_t *);

  // The underlying HTTP transaction. This pointer is used as the key
  // in the Http2Session mStreamTransactionHash so it is important to
  // keep a reference to it as long as this stream is a member of that hash.
  // (i.e. don't change it or release it after it is set in the ctor).
  RefPtr<nsAHttpTransaction> mTransaction;

  // The quanta upstream data frames are chopped into
  uint32_t mChunkSize;

  // Flag is set when the HTTP processor has more data to send
  // but has blocked in doing so.
  uint32_t mRequestBlockedOnRead : 1;

  // Flag is set after the response frame bearing the fin bit has
  // been processed. (i.e. after the server has closed).
  uint32_t mRecvdFin : 1;

  // Flag is set after 1st DATA frame has been passed to stream
  uint32_t mReceivedData : 1;

  // Flag is set after RST_STREAM has been received for this stream
  uint32_t mRecvdReset : 1;

  // Flag is set after RST_STREAM has been generated for this stream
  uint32_t mSentReset : 1;

  // Flag is set when stream is counted towards MAX_CONCURRENT streams in
  // session
  uint32_t mCountAsActive : 1;

  // Flag is set when a FIN has been placed on a data or header frame
  // (i.e after the client has closed)
  uint32_t mSentFin : 1;

  // Flag is set after the WAITING_FOR Transport event has been generated
  uint32_t mSentWaitingFor : 1;

  // Flag is set after TCP send autotuning has been disabled
  uint32_t mSetTCPSocketBuffer : 1;

  // Flag is set when OnWriteSegment is being called directly from stream
  // instead of transaction
  uint32_t mBypassInputBuffer : 1;

  // The InlineFrame and associated data is used for composing control
  // frames and data frame headers.
  UniquePtr<uint8_t[]> mTxInlineFrame;
  uint32_t mTxInlineFrameSize;
  uint32_t mTxInlineFrameUsed;

  // mTxStreamFrameSize tracks the progress of
  // transmitting a request body data frame. The data frame itself
  // is never copied into the spdy layer.
  uint32_t mTxStreamFrameSize;

  // Buffer for request header compression.
  nsCString mFlatHttpRequestHeaders;

  // Track the content-length of a request body so that we can
  // place the fin flag on the last data packet instead of waiting
  // for a stream closed indication. Relying on stream close results
  // in an extra 0-length runt packet and seems to have some interop
  // problems with the google servers. Connect does rely on stream
  // close by setting this to the max value.
  int64_t mRequestBodyLenRemaining;

  uint32_t mPriority;            // geckoish weight
  uint32_t mPriorityDependency;  // h2 stream id 3 - 0xb
  uint8_t mPriorityWeight;       // h2 weight

  // mClientReceiveWindow, mServerReceiveWindow, and mLocalUnacked are for flow
  // control. *window are signed because the race conditions in asynchronous
  // SETTINGS messages can force them temporarily negative.

  // mClientReceiveWindow is how much data the server will send without getting
  // a
  //   window update
  int64_t mClientReceiveWindow;

  // mServerReceiveWindow is how much data the client is allowed to send without
  //   getting a window update
  int64_t mServerReceiveWindow;

  // LocalUnacked is the number of bytes received by the client but not
  //   yet reflected in a window update. Sending that update will increment
  //   ClientReceiveWindow
  uint64_t mLocalUnacked;

  // True when sending is suspended becuase the server receive window is
  //   <= 0
  bool mBlockedOnRwin;

  // For Progress Events
  uint64_t mTotalSent;
  uint64_t mTotalRead;

  // For Http2Push
  Http2PushedStream *mPushSource;

  // Used to store stream data when the transaction channel cannot keep up
  // and flow control has not yet kicked in.
  SimpleBuffer mSimpleBuffer;

  bool mAttempting0RTT;

  uint64_t mCurrentForegroundTabOuterContentWindowId;

  uint64_t mTransactionTabId;

  /// connect tunnels
 public:
  bool IsTunnel() { return mIsTunnel; }

 private:
  void ClearTransactionsBlockedOnTunnel();
  void MapStreamToPlainText();
  void MapStreamToHttpConnection();

  bool mIsTunnel;
  bool mPlainTextTunnel;
};

}  // namespace net
}  // namespace mozilla

#endif  // mozilla_net_Http2Stream_h