The Tor Browser: netwerk/protocol/http/SpdySession31.h@6474c204b198 (annotated)

netwerk/protocol/http/SpdySession31.h@6474c204b198 (annotated)

netwerk/protocol/http/SpdySession31.h

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- 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_SpdySession31_h
 #define mozilla_net_SpdySession31_h
 // spdy/3.1
 #include "ASpdySession.h"
 #include "mozilla/Attributes.h"
 #include "nsAHttpConnection.h"
 #include "nsClassHashtable.h"
 #include "nsDataHashtable.h"
 #include "nsDeque.h"
 #include "nsHashKeys.h"
 #include "zlib.h"
 class nsISocketTransport;
 namespace mozilla { namespace net {
 class SpdyPushedStream31;
 class SpdyStream31;
 class SpdySession31 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
   SpdySession31(nsAHttpTransaction *, nsISocketTransport *, int32_t);
   ~SpdySession31();
   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(SpdyStream31 *, uint32_t aNewID = 0);
   const static uint8_t kVersion        = 3;
   const static uint8_t kFlag_Control   = 0x80;
   const static uint8_t kFlag_Data_FIN  = 0x01;
   const static uint8_t kFlag_Data_UNI  = 0x02;
   enum
   {
     CONTROL_TYPE_FIRST = 0,
     CONTROL_TYPE_SYN_STREAM = 1,
     CONTROL_TYPE_SYN_REPLY = 2,
     CONTROL_TYPE_RST_STREAM = 3,
     CONTROL_TYPE_SETTINGS = 4,
     CONTROL_TYPE_NOOP = 5,                        /* deprecated */
     CONTROL_TYPE_PING = 6,
     CONTROL_TYPE_GOAWAY = 7,
     CONTROL_TYPE_HEADERS = 8,
     CONTROL_TYPE_WINDOW_UPDATE = 9,
     CONTROL_TYPE_CREDENTIAL = 10,
     CONTROL_TYPE_LAST = 11
   };
   enum rstReason
   {
     RST_PROTOCOL_ERROR = 1,
     RST_INVALID_STREAM = 2,
     RST_REFUSED_STREAM = 3,
     RST_UNSUPPORTED_VERSION = 4,
     RST_CANCEL = 5,
     RST_INTERNAL_ERROR = 6,
     RST_FLOW_CONTROL_ERROR = 7,
     RST_STREAM_IN_USE = 8,
     RST_STREAM_ALREADY_CLOSED = 9,
     RST_INVALID_CREDENTIALS = 10,
     RST_FRAME_TOO_LARGE = 11
   };
   enum goawayReason
   {
     OK = 0,
     PROTOCOL_ERROR = 1,
     INTERNAL_ERROR = 2,    // sometimes misdocumented as 11
     NUM_STATUS_CODES = 3   // reserved by chromium but undocumented
   };
   enum settingsFlags
   {
     PERSIST_VALUE = 1,
     PERSISTED_VALUE = 2
   };
   enum
   {
     SETTINGS_TYPE_UPLOAD_BW = 1, // kb/s
     SETTINGS_TYPE_DOWNLOAD_BW = 2, // kb/s
     SETTINGS_TYPE_RTT = 3, // ms
     SETTINGS_TYPE_MAX_CONCURRENT = 4, // streams
     SETTINGS_TYPE_CWND = 5, // packets
     SETTINGS_TYPE_DOWNLOAD_RETRANS_RATE = 6, // percentage
     SETTINGS_TYPE_INITIAL_WINDOW = 7,  // bytes for flow control
     SETTINGS_CLIENT_CERTIFICATE_VECTOR_SIZE = 8
   };
   // 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.
   // About 1% of responses from SPDY google services seem to be > 1000
   // with all less than 2000 when compression is enabled.
   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 = 1024 * 1024;
   const static uint32_t kMinimumToAck = 64 * 1024;
   // The default rwin is 64KB unless updated by a settings frame
   const static uint32_t kDefaultRwin = 64 * 1024;
   static nsresult HandleSynStream(SpdySession31 *);
   static nsresult HandleSynReply(SpdySession31 *);
   static nsresult HandleRstStream(SpdySession31 *);
   static nsresult HandleSettings(SpdySession31 *);
   static nsresult HandleNoop(SpdySession31 *);
   static nsresult HandlePing(SpdySession31 *);
   static nsresult HandleGoAway(SpdySession31 *);
   static nsresult HandleHeaders(SpdySession31 *);
   static nsresult HandleWindowUpdate(SpdySession31 *);
   static nsresult HandleCredential(SpdySession31 *);
   template<typename T>
     static void EnsureBuffer(nsAutoArrayPtr<T> &,
                              uint32_t, uint32_t, uint32_t &);
   // For writing the SPDY data stream to LOG4
   static void LogIO(SpdySession31 *, SpdyStream31 *, const char *,
                     const char *, uint32_t);
   // an overload of nsAHttpConnection
   void TransactionHasDataToWrite(nsAHttpTransaction *);
   // a similar version for SpdyStream31
   void TransactionHasDataToWrite(SpdyStream31 *);
   // 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(SpdyStream31 *stream);
   void DecrementConcurrent(SpdyStream31 *stream);
   uint64_t Serial() { return mSerial; }
   void     PrintDiagnostics (nsCString &log);
   // Streams need access to these
   uint32_t SendingChunkSize() { return mSendingChunkSize; }
   uint32_t PushAllowance() { return mPushAllowance; }
   z_stream *UpstreamZlib() { return &mUpstreamZlib; }
   nsISocketTransport *SocketTransport() { return mSocketTransport; }
   int64_t RemoteSessionWindow() { return mRemoteSessionWindow; }
   void DecrementRemoteSessionWindow (uint32_t bytes) { mRemoteSessionWindow -= bytes; }
 private:
   enum stateType {
     BUFFERING_FRAME_HEADER,
     BUFFERING_CONTROL_FRAME,
     PROCESSING_DATA_FRAME,
     DISCARDING_DATA_FRAME,
     PROCESSING_COMPLETE_HEADERS,
     PROCESSING_CONTROL_RST_STREAM
   };
   nsresult    ResponseHeadersComplete();
   uint32_t    GetWriteQueueSize();
   void        ChangeDownstreamState(enum stateType);
   void        ResetDownstreamState();
   nsresult    UncompressAndDiscard(uint32_t, uint32_t);
   void        zlibInit();
   void        GeneratePing(uint32_t);
   void        GenerateRstStream(uint32_t, uint32_t);
   void        GenerateGoAway(uint32_t);
   void        CleanupStream(SpdyStream31 *, nsresult, rstReason);
   void        CloseStream(SpdyStream31 *, nsresult);
   void        GenerateSettings();
   void        RemoveStreamFromQueues(SpdyStream31 *);
   void        SetWriteCallbacks();
   void        RealignOutputQueue();
   bool        RoomForMoreConcurrent();
   void        ActivateStream(SpdyStream31 *);
   void        ProcessPending();
   nsresult    SetInputFrameDataStream(uint32_t);
   bool        VerifyStream(SpdyStream31 *, uint32_t);
   void        SetNeedsCleanup();
   void        UpdateLocalRwin(SpdyStream31 *stream, uint32_t bytes);
   void        UpdateLocalStreamWindow(SpdyStream31 *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<SpdyStream31> &,
                                             void *);
   static PLDHashOperator GoAwayEnumerator(nsAHttpTransaction *,
                                           nsAutoPtr<SpdyStream31> &,
                                           void *);
   static PLDHashOperator UpdateServerRwinEnumerator(nsAHttpTransaction *,
                                                     nsAutoPtr<SpdyStream31> &,
                                                     void *);
   static PLDHashOperator RestartBlockedOnRwinEnumerator(nsAHttpTransaction *,
                                                         nsAutoPtr<SpdyStream31> &,
                                                         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 */
   stateType         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, SpdyStream31 *>     mStreamIDHash;
   nsClassHashtable<nsPtrHashKey<nsAHttpTransaction>,
     SpdyStream31>                                     mStreamTransactionHash;
   nsDeque                                             mReadyForWrite;
   nsDeque                                             mQueuedStreams;
   nsDeque                                             mReadyForRead;
   nsTArray<SpdyPushedStream31 *>                      mPushedStreams;
   // Compression contexts for header transport using deflate.
   // SPDY compresses only HTTP headers and does not reset zlib 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.
   z_stream            mDownstreamZlib;
   z_stream            mUpstreamZlib;
   // mInputFrameBuffer is used to store received control packets and the 8 bytes
   // of header on data packets
   uint32_t             mInputFrameBufferSize;
   uint32_t             mInputFrameBufferUsed;
   nsAutoArrayPtr<char> mInputFrameBuffer;
   // mInputFrameDataSize/Read are used for tracking the amount of data consumed
   // in a data frame. the data itself is not buffered in spdy
   // The frame size is mInputFrameDataSize + the constant 8 byte header
   uint32_t             mInputFrameDataSize;
   uint32_t             mInputFrameDataRead;
   bool                 mInputFrameDataLast; // This frame was marked FIN
   // 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.
   SpdyStream31          *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.
   SpdyStream31          *mNeedsCleanup;
   // The CONTROL_TYPE value for a control frame
   uint32_t             mFrameControlType;
   // This reason code in the last processed RESET frame
   uint32_t             mDownstreamRstReason;
   // for the conversion of downstream http headers into spdy 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;
   // indicates PROCESSING_COMPLETE_HEADERS state was pushed onto the stack
   // over an active PROCESSING_DATA_FRAME, which should be restored when
   // the processed headers are written to the stream
   bool                 mDataPending;
   // 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 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 SYN-STREAMS, 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              mRemoteSessionWindow;
   // 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;
   uint32_t             mNextPingID;
   // 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
 #endif // mozilla_net_SpdySession31_h

The Tor Browser / annotate

netwerk/protocol/http/SpdySession31.h@6474c204b198 (annotated)

netwerk/protocol/http/SpdySession31.h