Quelle Http2StreamBase.h Sprache: C

/* -*- 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_Http2StreamBase_h
#define mozilla_net_Http2StreamBase_h

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

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

class nsISocketTransport;
class nsIInputStream;
class nsIOutputStream;

namespace mozilla {
class OriginAttributes;
}

namespace mozilla::net {

class nsStandardURL;
class Http2Session;
class Http2Stream;
class Http2PushedStream;
class Http2Decompressor;

class Http2StreamBase : public nsAHttpSegmentReader,
                        public nsAHttpSegmentWriter,
                        public SupportsWeakPtr {
public:
  NS_DECL_NSAHTTPSEGMENTREADER

  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;

  Http2StreamBase(uint64_t, Http2Session*, int32_t, uint64_t);

  uint32_t StreamID() { return mStreamID; }

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

  [[nodiscard]] virtual nsresult ReadSegments(nsAHttpSegmentReader*, uint32_t,
                                              uint32_t*);
  [[nodiscard]] virtual nsresult WriteSegments(nsAHttpSegmentWriter*, uint32_t,
                                               uint32_t*);
  virtual bool DeferCleanup(nsresult status);

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

  virtual nsAHttpTransaction* Transaction() { return nullptr; }
  nsHttpTransaction* HttpTransaction();
  virtual nsIRequestContext* RequestContext() { return nullptr; }

  virtual void CloseStream(nsresult reason) = 0;
  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
  [[nodiscard]] nsresult ConvertResponseHeaders(Http2Decompressor*, nsACString&,
                                                nsACString&, int32_t&);
  [[nodiscard]] 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 RFC7540Priority() { return mRFC7540Priority; }
  uint32_t PriorityDependency() { return mPriorityDependency; }
  uint8_t PriorityWeight() { return mPriorityWeight; }
  void SetPriority(uint32_t);
  void SetPriorityDependency(uint32_t, uint32_t);
  void UpdatePriorityDependency();

  uint64_t TransactionBrowserId() { return mTransactionBrowserId; }

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

  already_AddRefed<Http2Session> Session();

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

  nsresult GetOriginAttributes(mozilla::OriginAttributes* oa);

  virtual void CurrentBrowserIdChanged(uint64_t id);
  // For use by pushed streams only
  void CurrentBrowserIdChangedInternal(uint64_t id);

  virtual void UpdatePriorityRFC7540(Http2Session* session);
  virtual void UpdatePriority(Http2Session* session);

  virtual bool IsTunnel() { return false; }

  virtual uint32_t GetWireStreamId() { return mStreamID; }
  virtual Http2Stream* GetHttp2Stream() { return nullptr; }
  virtual Http2PushedStream* GetHttp2PushedStream() { return nullptr; }

  [[nodiscard]] virtual nsresult OnWriteSegment(char*, uint32_t,
                                                uint32_t*) override;

  virtual nsHttpConnectionInfo* ConnectionInfo();

  bool DataBuffered() { return mSimpleBuffer.Available(); }

  virtual nsresult Condition() { return NS_OK; }

  virtual void DisableSpdy() {
    if (Transaction()) {
      Transaction()->DisableSpdy();
    }
  }
  virtual void ReuseConnectionOnRestartOK(bool aReuse) {
    if (Transaction()) {
      Transaction()->ReuseConnectionOnRestartOK(aReuse);
    }
  }
  virtual void MakeNonSticky() {
    if (Transaction()) {
      Transaction()->MakeNonSticky();
    }
  }

protected:
  virtual ~Http2StreamBase();

  virtual void HandleResponseHeaders(nsACString& aHeadersOut,
                                     int32_t httpResponseCode) {}
  virtual nsresult CallToWriteData(uint32_t count, uint32_t* countRead) = 0;
  virtual nsresult CallToReadData(uint32_t count, uint32_t* countWritten) = 0;
  virtual bool CloseSendStreamWhenDone() { return true; }

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

  uint32_t mStreamID{0};

  // The session that this stream is a subset of
  nsWeakPtr 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.
  RefPtr<nsAHttpSegmentReader> mSegmentReader;
  nsAHttpSegmentWriter* mSegmentWriter{nullptr};

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

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

  // 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();
  [[nodiscard]] nsresult TransmitFrame(const char*, uint32_t*,
                                       bool forceCommitment);

  // The underlying socket transport object is needed to propogate some events
  nsCOMPtr<nsISocketTransport> mSocketTransport;

  uint8_t mPriorityWeight = 0;       // h2 weight
  uint32_t mPriorityDependency = 0;  // h2 stream id this one depends on
  uint64_t mCurrentBrowserId;
  uint64_t mTransactionBrowserId{0};

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

  uint32_t mRFC7540Priority = 0;  // geckoish weight

  // 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{0};

private:
  friend class mozilla::DefaultDelete<Http2StreamBase>;

  [[nodiscard]] nsresult ParseHttpRequestHeaders(const char*, uint32_t,
                                                 uint32_t*);
  [[nodiscard]] nsresult GenerateOpen();

  virtual nsresult GenerateHeaders(nsCString& aCompressedData,
                                   uint8_t& firstFrameFlags) = 0;

  void GenerateDataFrameHeader(uint32_t, bool);

  [[nodiscard]] nsresult BufferInput(uint32_t, uint32_t*);

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

  // 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{0};

  // 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{0};

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

  // For Progress Events
  uint64_t mTotalSent{0};
  uint64_t mTotalRead{0};

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

  bool mAttempting0RTT{false};
};

}  // namespace mozilla::net

#endif  // mozilla_net_Http2StreamBase_h

quality97%

¤ Dauer der Verarbeitung: 0.8 Sekunden ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.