The Tor Browser: netwerk/protocol/http/Http2Session.h@deefc01c0e14 (annotated)

netwerk/protocol/http/Http2Session.h@deefc01c0e14 (annotated)

netwerk/protocol/http/Http2Session.h

Thu, 15 Jan 2015 21:03:48 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 15 Jan 2015 21:03:48 +0100
branch: TOR_BUG_9701
changeset 11: deefc01c0e14
permissions: -rw-r--r--

Integrate friendly tips from Tor colleagues to make (or not) 4.5 alpha 3;
This includes removal of overloaded (but unused) methods, and addition of
a overlooked call to DataStruct::SetData(nsISupports, uint32_t, bool.)

 /* -*- Mode: C++; tab-width: 2; 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_Http2Session_h
 #define mozilla_net_Http2Session_h
 // HTTP/2
 #include "ASpdySession.h"
 #include "mozilla/Attributes.h"
 #include "nsAHttpConnection.h"
 #include "nsClassHashtable.h"
 #include "nsDataHashtable.h"
 #include "nsDeque.h"
 #include "nsHashKeys.h"
 #include "Http2Compression.h"
 class nsISocketTransport;
 namespace mozilla {
 namespace net {
 class Http2PushedStream;
 class Http2Stream;
 class Http2Session MOZ_FINAL : public ASpdySession
   , public nsAHttpConnection
   , public nsAHttpSegmentReader
   , public nsAHttpSegmentWriter
 {
 public:
   NS_DECL_ISUPPORTS
     NS_DECL_NSAHTTPTRANSACTION
     NS_DECL_NSAHTTPCONNECTION(mConnection)
     NS_DECL_NSAHTTPSEGMENTREADER
     NS_DECL_NSAHTTPSEGMENTWRITER
    Http2Session(nsAHttpTransaction *, nsISocketTransport *, int32_t);
   ~Http2Session();
   bool AddStream(nsAHttpTransaction *, int32_t);
   bool CanReuse() { return !mShouldGoAway && !mClosed; }
   bool RoomForMoreStreams();
   // When the connection is active this is called up to once every 1 second
   // return the interval (in seconds) that the connection next wants to
   // have this invoked. It might happen sooner depending on the needs of
   // other connections.
   uint32_t  ReadTimeoutTick(PRIntervalTime now);
   // Idle time represents time since "goodput".. e.g. a data or header frame
   PRIntervalTime IdleTime();
   // Registering with a newID of 0 means pick the next available odd ID
   uint32_t RegisterStreamID(Http2Stream *, uint32_t aNewID = 0);
 /*
   HTTP/2 framing
 1                   2                   3
 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |         Length (16)           |   Type (8)    |   Flags (8)   |
   +-+-------------+---------------+-------------------------------+
   |R|                 Stream Identifier (31)                      |
   +-+-------------------------------------------------------------+
   |                     Frame Data (0...)                       ...
   +---------------------------------------------------------------+
 */
   enum frameType {
     FRAME_TYPE_DATA = 0,
     FRAME_TYPE_HEADERS = 1,
     FRAME_TYPE_PRIORITY = 2,
     FRAME_TYPE_RST_STREAM = 3,
     FRAME_TYPE_SETTINGS = 4,
     FRAME_TYPE_PUSH_PROMISE = 5,
     FRAME_TYPE_PING = 6,
     FRAME_TYPE_GOAWAY = 7,
     FRAME_TYPE_WINDOW_UPDATE = 8,
     FRAME_TYPE_CONTINUATION = 9,
     FRAME_TYPE_LAST = 10
   };
   // NO_ERROR is a macro defined on windows, so we'll name the HTTP2 goaway
   // code NO_ERROR to be NO_HTTP_ERROR
   enum errorType {
     NO_HTTP_ERROR = 0,
     PROTOCOL_ERROR = 1,
     INTERNAL_ERROR = 2,
     FLOW_CONTROL_ERROR = 3,
     SETTINGS_TIMEOUT_ERROR = 4,
     STREAM_CLOSED_ERROR = 5,
     FRAME_SIZE_ERROR = 6,
     REFUSED_STREAM_ERROR = 7,
     CANCEL_ERROR = 8,
     COMPRESSION_ERROR = 9,
     CONNECT_ERROR = 10,
     ENHANCE_YOUR_CALM = 11,
     INADEQUATE_SECURITY = 12
   };
   // These are frame flags. If they, or other undefined flags, are
   // used on frames other than the comments indicate they MUST be ignored.
   const static uint8_t kFlag_END_STREAM = 0x01; // data, headers
   const static uint8_t kFlag_END_HEADERS = 0x04; // headers, continuation
   const static uint8_t kFlag_PRIORITY = 0x08; //headers
   const static uint8_t kFlag_END_PUSH_PROMISE = 0x04; // push promise
   const static uint8_t kFlag_ACK = 0x01; // ping and settings
   const static uint8_t kFlag_END_SEGMENT = 0x02; // data
   const static uint8_t kFlag_PAD_LOW = 0x10; // data, headers, continuation
   const static uint8_t kFlag_PAD_HIGH = 0x20; // data, headers, continuation
   enum {
     SETTINGS_TYPE_HEADER_TABLE_SIZE = 1, // compression table size
     SETTINGS_TYPE_ENABLE_PUSH = 2,     // can be used to disable push
     SETTINGS_TYPE_MAX_CONCURRENT = 3,  // streams recvr allowed to initiate
     SETTINGS_TYPE_INITIAL_WINDOW = 4  // bytes for flow control default
   };
   // This should be big enough to hold all of your control packets,
   // but if it needs to grow for huge headers it can do so dynamically.
   const static uint32_t kDefaultBufferSize = 2048;
   // kDefaultQueueSize must be >= other queue size constants
   const static uint32_t kDefaultQueueSize =  32768;
   const static uint32_t kQueueMinimumCleanup = 24576;
   const static uint32_t kQueueTailRoom    =  4096;
   const static uint32_t kQueueReserved    =  1024;
   const static uint32_t kDefaultMaxConcurrent = 100;
   const static uint32_t kMaxStreamID = 0x7800000;
   // This is a sentinel for a deleted stream. It is not a valid
   // 31 bit stream ID.
   const static uint32_t kDeadStreamID = 0xffffdead;
   // below the emergency threshold of local window we ack every received
   // byte. Above that we coalesce bytes into the MinimumToAck size.
   const static int32_t  kEmergencyWindowThreshold = 256 * 1024;
   const static uint32_t kMinimumToAck = 4 * 1024 * 1024;
   // The default rwin is 64KB - 1 unless updated by a settings frame
   const static uint32_t kDefaultRwin = 65535;
   // Frames with HTTP semantics are limited to 2^14 - 1 bytes of length in
   // order to preserve responsiveness
   const static uint32_t kMaxFrameData = 16383;
   static nsresult RecvHeaders(Http2Session *);
   static nsresult RecvPriority(Http2Session *);
   static nsresult RecvRstStream(Http2Session *);
   static nsresult RecvSettings(Http2Session *);
   static nsresult RecvPushPromise(Http2Session *);
   static nsresult RecvPing(Http2Session *);
   static nsresult RecvGoAway(Http2Session *);
   static nsresult RecvWindowUpdate(Http2Session *);
   static nsresult RecvContinuation(Http2Session *);
   template<typename T>
   static void EnsureBuffer(nsAutoArrayPtr<T> &,
                            uint32_t, uint32_t, uint32_t &);
   char       *EnsureOutputBuffer(uint32_t needed);
   template<typename charType>
   void CreateFrameHeader(charType dest, uint16_t frameLength,
                          uint8_t frameType, uint8_t frameFlags,
                          uint32_t streamID);
   // For writing the data stream to LOG4
   static void LogIO(Http2Session *, Http2Stream *, const char *,
                     const char *, uint32_t);
   // an overload of nsAHttpConnection
   void TransactionHasDataToWrite(nsAHttpTransaction *);
   // a similar version for Http2Stream
   void TransactionHasDataToWrite(Http2Stream *);
   // an overload of nsAHttpSegementReader
   virtual nsresult CommitToSegmentSize(uint32_t size, bool forceCommitment);
   nsresult BufferOutput(const char *, uint32_t, uint32_t *);
   void     FlushOutputQueue();
   uint32_t AmountOfOutputBuffered() { return mOutputQueueUsed - mOutputQueueSent; }
   uint32_t GetServerInitialStreamWindow() { return mServerInitialStreamWindow; }
   void ConnectPushedStream(Http2Stream *stream);
   void MaybeDecrementConcurrent(Http2Stream *stream);
   nsresult ConfirmTLSProfile();
   uint64_t Serial() { return mSerial; }
   void PrintDiagnostics (nsCString &log);
   // Streams need access to these
   uint32_t SendingChunkSize() { return mSendingChunkSize; }
   uint32_t PushAllowance() { return mPushAllowance; }
   Http2Compressor *Compressor() { return &mCompressor; }
   nsISocketTransport *SocketTransport() { return mSocketTransport; }
   int64_t ServerSessionWindow() { return mServerSessionWindow; }
   void DecrementServerSessionWindow (uint32_t bytes) { mServerSessionWindow -= bytes; }
 private:
   // These internal states do not correspond to the states of the HTTP/2 specification
   enum internalStateType {
     BUFFERING_OPENING_SETTINGS,
     BUFFERING_FRAME_HEADER,
     BUFFERING_CONTROL_FRAME,
     PROCESSING_DATA_FRAME_PADDING_CONTROL,
     PROCESSING_DATA_FRAME,
     DISCARDING_DATA_FRAME_PADDING,
     DISCARDING_DATA_FRAME,
     PROCESSING_COMPLETE_HEADERS,
     PROCESSING_CONTROL_RST_STREAM
   };
   static const uint8_t kMagicHello[24];
   nsresult    ResponseHeadersComplete();
   uint32_t    GetWriteQueueSize();
   void        ChangeDownstreamState(enum internalStateType);
   void        ResetDownstreamState();
   nsresult    ReadyToProcessDataFrame(enum internalStateType);
   nsresult    UncompressAndDiscard();
   void        GeneratePing(bool);
   void        GenerateSettingsAck();
   void        GeneratePriority(uint32_t, uint32_t);
   void        GenerateRstStream(uint32_t, uint32_t);
   void        GenerateGoAway(uint32_t);
   void        CleanupStream(Http2Stream *, nsresult, errorType);
   void        CloseStream(Http2Stream *, nsresult);
   void        SendHello();
   void        RemoveStreamFromQueues(Http2Stream *);
   nsresult    ParsePadding(uint8_t &, uint16_t &);
   void        SetWriteCallbacks();
   void        RealignOutputQueue();
   bool        RoomForMoreConcurrent();
   void        ActivateStream(Http2Stream *);
   void        ProcessPending();
   nsresult    SetInputFrameDataStream(uint32_t);
   bool        VerifyStream(Http2Stream *, uint32_t);
   void        SetNeedsCleanup();
   void        UpdateLocalRwin(Http2Stream *stream, uint32_t bytes);
   void        UpdateLocalStreamWindow(Http2Stream *stream, uint32_t bytes);
   void        UpdateLocalSessionWindow(uint32_t bytes);
   // a wrapper for all calls to the nshttpconnection level segment writer. Used
   // to track network I/O for timeout purposes
   nsresult   NetworkRead(nsAHttpSegmentWriter *, char *, uint32_t, uint32_t *);
   static PLDHashOperator ShutdownEnumerator(nsAHttpTransaction *,
                                             nsAutoPtr<Http2Stream> &,
                                             void *);
   static PLDHashOperator GoAwayEnumerator(nsAHttpTransaction *,
                                           nsAutoPtr<Http2Stream> &,
                                           void *);
   static PLDHashOperator UpdateServerRwinEnumerator(nsAHttpTransaction *,
                                                     nsAutoPtr<Http2Stream> &,
                                                     void *);
   static PLDHashOperator RestartBlockedOnRwinEnumerator(nsAHttpTransaction *,
                                                         nsAutoPtr<Http2Stream> &,
                                                         void *);
   // This is intended to be nsHttpConnectionMgr:nsConnectionHandle taken
   // from the first transaction on this session. That object contains the
   // pointer to the real network-level nsHttpConnection object.
   nsRefPtr<nsAHttpConnection> mConnection;
   // The underlying socket transport object is needed to propogate some events
   nsISocketTransport         *mSocketTransport;
   // 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;
   uint32_t          mSendingChunkSize;        /* the transmission chunk size */
   uint32_t          mNextStreamID;            /* 24 bits */
   uint32_t          mConcurrentHighWater;     /* max parallelism on session */
   uint32_t          mPushAllowance;           /* rwin for unmatched pushes */
   internalStateType mDownstreamState; /* in frame, between frames, etc..  */
   // Maintain 2 indexes - one by stream ID, one by transaction pointer.
   // There are also several lists of streams: ready to write, queued due to
   // max parallelism, streams that need to force a read for push, and the full
   // set of pushed streams.
   // The objects are not ref counted - they get destroyed
   // by the nsClassHashtable implementation when they are removed from
   // the transaction hash.
   nsDataHashtable<nsUint32HashKey, Http2Stream *>     mStreamIDHash;
   nsClassHashtable<nsPtrHashKey<nsAHttpTransaction>,
     Http2Stream>                                      mStreamTransactionHash;
   nsDeque                                             mReadyForWrite;
   nsDeque                                             mQueuedStreams;
   nsDeque                                             mReadyForRead;
   nsTArray<Http2PushedStream *>                       mPushedStreams;
   // Compression contexts for header transport.
   // HTTP/2 compresses only HTTP headers and does not reset the context in between
   // frames. Even data that is not associated with a stream (e.g invalid
   // stream ID) is passed through these contexts to keep the compression
   // context correct.
   Http2Compressor     mCompressor;
   Http2Decompressor   mDecompressor;
   nsCString           mDecompressBuffer;
   // mInputFrameBuffer is used to store received control packets and the 8 bytes
   // of header on data packets
   uint32_t             mInputFrameBufferSize; // buffer allocation
   uint32_t             mInputFrameBufferUsed; // amt of allocation used
   nsAutoArrayPtr<char> mInputFrameBuffer;
   // mInputFrameDataSize/Read are used for tracking the amount of data consumed
   // in a frame after the 8 byte header. Control frames are always fully buffered
   // and the fixed 8 byte leading header is at mInputFrameBuffer + 0, the first
   // data byte (i.e. the first settings/goaway/etc.. specific byte) is at
   // mInputFrameBuffer + 8
   // The frame size is mInputFrameDataSize + the constant 8 byte header
   uint32_t             mInputFrameDataSize;
   uint32_t             mInputFrameDataRead;
   bool                 mInputFrameFinal; // This frame was marked FIN
   uint8_t              mInputFrameType;
   uint8_t              mInputFrameFlags;
   uint32_t             mInputFrameID;
   uint16_t             mPaddingLength;
   // When a frame has been received that is addressed to a particular stream
   // (e.g. a data frame after the stream-id has been decoded), this points
   // to the stream.
   Http2Stream          *mInputFrameDataStream;
   // mNeedsCleanup is a state variable to defer cleanup of a closed stream
   // If needed, It is set in session::OnWriteSegments() and acted on and
   // cleared when the stack returns to session::WriteSegments(). The stream
   // cannot be destroyed directly out of OnWriteSegments because
   // stream::writeSegments() is on the stack at that time.
   Http2Stream          *mNeedsCleanup;
   // This reason code in the last processed RESET frame
   uint32_t             mDownstreamRstReason;
   // When HEADERS/PROMISE are chained together, this is the expected ID of the next
   // recvd frame which must be the same type
   uint32_t             mExpectedHeaderID;
   uint32_t             mExpectedPushPromiseID;
   uint32_t             mContinuedPromiseStream;
   // for the conversion of downstream http headers into http/2 formatted headers
   // The data here does not persist between frames
   nsCString            mFlatHTTPResponseHeaders;
   uint32_t             mFlatHTTPResponseHeadersOut;
   // when set, the session will go away when it reaches 0 streams. This flag
   // is set when: the stream IDs are running out (at either the client or the
   // server), when DontReuse() is called, a RST that is not specific to a
   // particular stream is received, a GOAWAY frame has been received from
   // the server.
   bool                 mShouldGoAway;
   // the session has received a nsAHttpTransaction::Close()  call
   bool                 mClosed;
   // the session received a GoAway frame with a valid GoAwayID
   bool                 mCleanShutdown;
   // The TLS comlpiance checks are not done in the ctor beacuse of bad
   // exception handling - so we do them at IO time and cache the result
   bool                 mTLSProfileConfirmed;
   // A specifc reason code for the eventual GoAway frame. If set to NO_HTTP_ERROR
   // only NO_HTTP_ERROR, PROTOCOL_ERROR, or INTERNAL_ERROR will be sent.
   errorType            mGoAwayReason;
   // If a GoAway message was received this is the ID of the last valid
   // stream. 0 otherwise. (0 is never a valid stream id.)
   uint32_t             mGoAwayID;
   // The last stream processed ID we will send in our GoAway frame.
   uint32_t             mOutgoingGoAwayID;
   // The limit on number of concurrent streams for this session. Normally it
   // is basically unlimited, but the SETTINGS control message from the
   // server might bring it down.
   uint32_t             mMaxConcurrent;
   // The actual number of concurrent streams at this moment. Generally below
   // mMaxConcurrent, but the max can be lowered in real time to a value
   // below the current value
   uint32_t             mConcurrent;
   // The number of server initiated promises, tracked for telemetry
   uint32_t             mServerPushedResources;
   // The server rwin for new streams as determined from a SETTINGS frame
   uint32_t             mServerInitialStreamWindow;
   // The Local Session window is how much data the server is allowed to send
   // (across all streams) without getting a window update to stream 0. It is
   // signed because asynchronous changes via SETTINGS can drive it negative.
   int64_t              mLocalSessionWindow;
   // The Remote Session Window is how much data the client is allowed to send
   // (across all streams) without receiving a window update to stream 0. It is
   // signed because asynchronous changes via SETTINGS can drive it negative.
   int64_t              mServerSessionWindow;
   // This is a output queue of bytes ready to be written to the SSL stream.
   // When that streams returns WOULD_BLOCK on direct write the bytes get
   // coalesced together here. This results in larger writes to the SSL layer.
   // The buffer is not dynamically grown to accomodate stream writes, but
   // does expand to accept infallible session wide frames like GoAway and RST.
   uint32_t             mOutputQueueSize;
   uint32_t             mOutputQueueUsed;
   uint32_t             mOutputQueueSent;
   nsAutoArrayPtr<char> mOutputQueueBuffer;
   PRIntervalTime       mPingThreshold;
   PRIntervalTime       mLastReadEpoch;     // used for ping timeouts
   PRIntervalTime       mLastDataReadEpoch; // used for IdleTime()
   PRIntervalTime       mPingSentEpoch;
   // used as a temporary buffer while enumerating the stream hash during GoAway
   nsDeque  mGoAwayStreamsToRestart;
   // Each session gets a unique serial number because the push cache is correlated
   // by the load group and the serial number can be used as part of the cache key
   // to make sure streams aren't shared across sessions.
   uint64_t        mSerial;
 };
 } // namespace mozilla::net
 } // namespace mozilla
 #endif // mozilla_net_Http2Session_h

The Tor Browser / annotate

netwerk/protocol/http/Http2Session.h@deefc01c0e14 (annotated)

netwerk/protocol/http/Http2Session.h