protocol/http/nsHttpConnection.h

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* 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 nsHttpConnection_h__
#define nsHttpConnection_h__

#include "nsHttpConnectionInfo.h"
#include "nsHttpResponseHead.h"
#include "nsAHttpTransaction.h"
#include "nsCOMPtr.h"
#include "nsAutoPtr.h"
#include "nsProxyRelease.h"
#include "prinrval.h"
#include "TunnelUtils.h"
#include "mozilla/Mutex.h"
#include "ARefBase.h"
#include "TimingStruct.h"

#include "nsIAsyncInputStream.h"
#include "nsIAsyncOutputStream.h"
#include "nsIInterfaceRequestor.h"
#include "nsITimer.h"

class nsISocketTransport;
class nsISSLSocketControl;

namespace mozilla {
namespace net {

class nsHttpHandler;
class ASpdySession;

// 1dcc863e-db90-4652-a1fe-13fea0b54e46
#define NS_HTTPCONNECTION_IID                        \
  {                                                  \
    0x1dcc863e, 0xdb90, 0x4652, {                    \
      0xa1, 0xfe, 0x13, 0xfe, 0xa0, 0xb5, 0x4e, 0x46 \
    }                                                \
  }

//-----------------------------------------------------------------------------
// nsHttpConnection - represents a connection to a HTTP server (or proxy)
//
// NOTE: this objects lives on the socket thread only.  it should not be
// accessed from any other thread.
//-----------------------------------------------------------------------------

class nsHttpConnection final : public nsAHttpSegmentReader,
                               public nsAHttpSegmentWriter,
                               public nsIInputStreamCallback,
                               public nsIOutputStreamCallback,
                               public nsITransportEventSink,
                               public nsIInterfaceRequestor,
                               public NudgeTunnelCallback,
                               public ARefBase,
                               public nsSupportsWeakReference {
  virtual ~nsHttpConnection();

 public:
  NS_DECLARE_STATIC_IID_ACCESSOR(NS_HTTPCONNECTION_IID)
  NS_DECL_THREADSAFE_ISUPPORTS
  NS_DECL_NSAHTTPSEGMENTREADER
  NS_DECL_NSAHTTPSEGMENTWRITER
  NS_DECL_NSIINPUTSTREAMCALLBACK
  NS_DECL_NSIOUTPUTSTREAMCALLBACK
  NS_DECL_NSITRANSPORTEVENTSINK
  NS_DECL_NSIINTERFACEREQUESTOR
  NS_DECL_NUDGETUNNELCALLBACK

  nsHttpConnection();

  // Initialize the connection:
  //  info        - specifies the connection parameters.
  //  maxHangTime - limits the amount of time this connection can spend on a
  //                single transaction before it should no longer be kept
  //                alive.  a value of 0xffff indicates no limit.
  MOZ_MUST_USE nsresult Init(nsHttpConnectionInfo *info, uint16_t maxHangTime,
                             nsISocketTransport *, nsIAsyncInputStream *,
                             nsIAsyncOutputStream *, bool connectedTransport,
                             nsIInterfaceRequestor *, PRIntervalTime);

  // Activate causes the given transaction to be processed on this
  // connection.  It fails if there is already an existing transaction unless
  // a multiplexing protocol such as SPDY is being used
  MOZ_MUST_USE nsresult Activate(nsAHttpTransaction *, uint32_t caps,
                                 int32_t pri);

  void SetFastOpen(bool aFastOpen);
  // Close this connection and return the transaction. The transaction is
  // restarted as well. This will only happened before connection is
  // connected.
  nsAHttpTransaction *CloseConnectionFastOpenTakesTooLongOrError(
      bool aCloseocketTransport);

  // Close the underlying socket transport.
  void Close(nsresult reason, bool aIsShutdown = false);

  //-------------------------------------------------------------------------
  // XXX document when these are ok to call

  bool IsKeepAlive() {
    return mUsingSpdyVersion || (mKeepAliveMask && mKeepAlive);
  }
  bool CanReuse();  // can this connection be reused?
  bool CanDirectlyActivate();

  // Returns time in seconds for how long connection can be reused.
  uint32_t TimeToLive();

  void DontReuse();

  bool IsProxyConnectInProgress() { return mProxyConnectInProgress; }

  bool LastTransactionExpectedNoContent() {
    return mLastTransactionExpectedNoContent;
  }

  void SetLastTransactionExpectedNoContent(bool val) {
    mLastTransactionExpectedNoContent = val;
  }

  bool NeedSpdyTunnel() {
    return mConnInfo->UsingHttpsProxy() && !mTLSFilter &&
           mConnInfo->UsingConnect();
  }

  // A connection is forced into plaintext when it is intended to be used as a
  // CONNECT tunnel but the setup fails. The plaintext only carries the CONNECT
  // error.
  void ForcePlainText() { mForcePlainText = true; }

  bool IsUrgentStartPreferred() const {
    return mUrgentStartPreferredKnown && mUrgentStartPreferred;
  }
  void SetUrgentStartPreferred(bool urgent);

  nsISocketTransport *Transport() { return mSocketTransport; }
  nsAHttpTransaction *Transaction() { return mTransaction; }
  nsHttpConnectionInfo *ConnectionInfo() { return mConnInfo; }

  // nsAHttpConnection compatible methods (non-virtual):
  MOZ_MUST_USE nsresult OnHeadersAvailable(nsAHttpTransaction *,
                                           nsHttpRequestHead *,
                                           nsHttpResponseHead *, bool *reset);
  void CloseTransaction(nsAHttpTransaction *, nsresult reason,
                        bool aIsShutdown = false);
  void GetConnectionInfo(nsHttpConnectionInfo **ci) {
    NS_IF_ADDREF(*ci = mConnInfo);
  }
  MOZ_MUST_USE nsresult TakeTransport(nsISocketTransport **,
                                      nsIAsyncInputStream **,
                                      nsIAsyncOutputStream **);
  void GetSecurityInfo(nsISupports **);
  bool IsPersistent() { return IsKeepAlive() && !mDontReuse; }
  bool IsReused();
  void SetIsReusedAfter(uint32_t afterMilliseconds);
  MOZ_MUST_USE nsresult PushBack(const char *data, uint32_t length);
  MOZ_MUST_USE nsresult ResumeSend();
  MOZ_MUST_USE nsresult ResumeRecv();
  int64_t MaxBytesRead() { return mMaxBytesRead; }
  uint8_t GetLastHttpResponseVersion() { return mLastHttpResponseVersion; }

  friend class HttpConnectionForceIO;
  MOZ_MUST_USE nsresult ForceSend();
  MOZ_MUST_USE nsresult ForceRecv();

  static MOZ_MUST_USE nsresult ReadFromStream(nsIInputStream *, void *,
                                              const char *, uint32_t, uint32_t,
                                              uint32_t *);

  // When a persistent connection is in the connection manager idle
  // connection pool, the nsHttpConnection still reads errors and hangups
  // on the socket so that it can be proactively released if the server
  // initiates a termination. Only call on socket thread.
  void BeginIdleMonitoring();
  void EndIdleMonitoring();

  bool UsingSpdy() { return !!mUsingSpdyVersion; }
  uint8_t GetSpdyVersion() { return mUsingSpdyVersion; }
  bool EverUsedSpdy() { return mEverUsedSpdy; }
  PRIntervalTime Rtt() { return mRtt; }

  // true when connection SSL NPN phase is complete and we know
  // authoritatively whether UsingSpdy() or not.
  bool ReportedNPN() { return mReportedSpdy; }

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

  // For Active and Idle connections, this will be called when
  // mTCPKeepaliveTransitionTimer fires, to check if the TCP keepalive config
  // should move from short-lived (fast-detect) to long-lived.
  static void UpdateTCPKeepalive(nsITimer *aTimer, void *aClosure);

  // When the connection is active this is called every second
  void ReadTimeoutTick();

  int64_t BytesWritten() { return mTotalBytesWritten; }  // includes TLS
  int64_t ContentBytesWritten() { return mContentBytesWritten; }

  void SetSecurityCallbacks(nsIInterfaceRequestor *aCallbacks);
  void PrintDiagnostics(nsCString &log);

  void SetTransactionCaps(uint32_t aCaps) { mTransactionCaps = aCaps; }

  // IsExperienced() returns true when the connection has started at least one
  // non null HTTP transaction of any version.
  bool IsExperienced() { return mExperienced; }

  static MOZ_MUST_USE nsresult MakeConnectString(nsAHttpTransaction *trans,
                                                 nsHttpRequestHead *request,
                                                 nsACString &result);
  void SetupSecondaryTLS();
  void SetInSpdyTunnel(bool arg);

  // Check active connections for traffic (or not). SPDY connections send a
  // ping, ordinary HTTP connections get some time to get traffic to be
  // considered alive.
  void CheckForTraffic(bool check);

  // NoTraffic() returns true if there's been no traffic on the (non-spdy)
  // connection since CheckForTraffic() was called.
  bool NoTraffic() {
    return mTrafficStamp &&
           (mTrafficCount == (mTotalBytesWritten + mTotalBytesRead)) &&
           !mFastOpen;
  }
  // override of nsAHttpConnection
  virtual uint32_t Version();

  bool TestJoinConnection(const nsACString &hostname, int32_t port);
  bool JoinConnection(const nsACString &hostname, int32_t port);

  void SetFastOpenStatus(uint8_t tfoStatus);
  uint8_t GetFastOpenStatus() { return mFastOpenStatus; }

  void SetEvent(nsresult aStatus);

  // Return true when the socket this connection is using has not been
  // authenticated using a client certificate.  Before SSL negotiation
  // has finished this returns false.
  bool NoClientCertAuth() const;

 private:
  // Value (set in mTCPKeepaliveConfig) indicates which set of prefs to use.
  enum TCPKeepaliveConfig {
    kTCPKeepaliveDisabled = 0,
    kTCPKeepaliveShortLivedConfig,
    kTCPKeepaliveLongLivedConfig
  };

  // called to cause the underlying socket to start speaking SSL
  MOZ_MUST_USE nsresult InitSSLParams(bool connectingToProxy,
                                      bool ProxyStartSSL);
  MOZ_MUST_USE nsresult SetupNPNList(nsISSLSocketControl *ssl, uint32_t caps);

  MOZ_MUST_USE nsresult OnTransactionDone(nsresult reason);
  MOZ_MUST_USE nsresult OnSocketWritable();
  MOZ_MUST_USE nsresult OnSocketReadable();

  MOZ_MUST_USE nsresult SetupProxyConnect();

  PRIntervalTime IdleTime();
  bool IsAlive();

  // Makes certain the SSL handshake is complete and NPN negotiation
  // has had a chance to happen
  MOZ_MUST_USE bool EnsureNPNComplete(nsresult &aOut0RTTWriteHandshakeValue,
                                      uint32_t &aOut0RTTBytesWritten);
  void SetupSSL();

  // Start the Spdy transaction handler when NPN indicates spdy/*
  void StartSpdy(nsISSLSocketControl *ssl, uint8_t versionLevel);
  // Like the above, but do the bare minimum to do 0RTT data, so we can back
  // it out, if necessary
  void Start0RTTSpdy(uint8_t versionLevel);

  // Helpers for Start*Spdy
  nsresult TryTakeSubTransactions(nsTArray<RefPtr<nsAHttpTransaction> > &list);
  nsresult MoveTransactionsToSpdy(nsresult status,
                                  nsTArray<RefPtr<nsAHttpTransaction> > &list);

  // Directly Add a transaction to an active connection for SPDY
  MOZ_MUST_USE nsresult AddTransaction(nsAHttpTransaction *, int32_t);

  // Used to set TCP keepalives for fast detection of dead connections during
  // an initial period, and slower detection for long-lived connections.
  MOZ_MUST_USE nsresult StartShortLivedTCPKeepalives();
  MOZ_MUST_USE nsresult StartLongLivedTCPKeepalives();
  MOZ_MUST_USE nsresult DisableTCPKeepalives();

 private:
  nsCOMPtr<nsISocketTransport> mSocketTransport;
  nsCOMPtr<nsIAsyncInputStream> mSocketIn;
  nsCOMPtr<nsIAsyncOutputStream> mSocketOut;

  nsresult mSocketInCondition;
  nsresult mSocketOutCondition;

  nsCOMPtr<nsIInputStream> mProxyConnectStream;
  nsCOMPtr<nsIInputStream> mRequestStream;

  // mTransaction only points to the HTTP Transaction callbacks if the
  // transaction is open, otherwise it is null.
  RefPtr<nsAHttpTransaction> mTransaction;
  RefPtr<TLSFilterTransaction> mTLSFilter;

  RefPtr<nsHttpHandler> mHttpHandler;  // keep gHttpHandler alive

  Mutex mCallbacksLock;
  nsMainThreadPtrHandle<nsIInterfaceRequestor> mCallbacks;

  RefPtr<nsHttpConnectionInfo> mConnInfo;

  PRIntervalTime mLastReadTime;
  PRIntervalTime mLastWriteTime;
  PRIntervalTime
      mMaxHangTime;  // max download time before dropping keep-alive status
  PRIntervalTime mIdleTimeout;  // value of keep-alive: timeout=
  PRIntervalTime mConsiderReusedAfterInterval;
  PRIntervalTime mConsiderReusedAfterEpoch;
  int64_t mCurrentBytesRead;     // data read per activation
  int64_t mMaxBytesRead;         // max read in 1 activation
  int64_t mTotalBytesRead;       // total data read
  int64_t mTotalBytesWritten;    // does not include CONNECT tunnel
  int64_t mContentBytesWritten;  // does not include CONNECT tunnel or TLS

  RefPtr<nsIAsyncInputStream> mInputOverflow;

  PRIntervalTime mRtt;

  // Whether the first non-null transaction dispatched on this connection was
  // urgent-start or not
  bool mUrgentStartPreferred;
  // A flag to prevent reset of mUrgentStartPreferred by subsequent transactions
  bool mUrgentStartPreferredKnown;
  bool mConnectedTransport;
  bool mKeepAlive;
  bool mKeepAliveMask;
  bool mDontReuse;
  bool mIsReused;
  bool mCompletedProxyConnect;
  bool mLastTransactionExpectedNoContent;
  bool mIdleMonitoring;
  bool mProxyConnectInProgress;
  bool mExperienced;
  bool mInSpdyTunnel;
  bool mForcePlainText;

  // A snapshot of current number of transfered bytes
  int64_t mTrafficCount;
  bool mTrafficStamp;  // true then the above is set

  // The number of <= HTTP/1.1 transactions performed on this connection. This
  // excludes spdy transactions.
  uint32_t mHttp1xTransactionCount;

  // Keep-Alive: max="mRemainingConnectionUses" provides the number of future
  // transactions (including the current one) that the server expects to allow
  // on this persistent connection.
  uint32_t mRemainingConnectionUses;

  // SPDY related
  bool mNPNComplete;
  bool mSetupSSLCalled;

  // version level in use, 0 if unused
  uint8_t mUsingSpdyVersion;

  RefPtr<ASpdySession> mSpdySession;
  int32_t mPriority;
  bool mReportedSpdy;

  // mUsingSpdyVersion is cleared when mSpdySession is freed, this is permanent
  bool mEverUsedSpdy;

  // mLastHttpResponseVersion stores the last response's http version seen.
  uint8_t mLastHttpResponseVersion;

  // The capabailities associated with the most recent transaction
  uint32_t mTransactionCaps;

  // If a large keepalive has been requested for any trans,
  // scale the default by this factor
  uint32_t mDefaultTimeoutFactor;

  bool mResponseTimeoutEnabled;

  // Flag to indicate connection is in inital keepalive period (fast detect).
  uint32_t mTCPKeepaliveConfig;
  nsCOMPtr<nsITimer> mTCPKeepaliveTransitionTimer;

 private:
  // For ForceSend()
  static void ForceSendIO(nsITimer *aTimer, void *aClosure);
  MOZ_MUST_USE nsresult MaybeForceSendIO();
  bool mForceSendPending;
  nsCOMPtr<nsITimer> mForceSendTimer;

  // Helper variable for 0RTT handshake;
  bool m0RTTChecked;             // Possible 0RTT has been
                                 // checked.
  bool mWaitingFor0RTTResponse;  // We have are
                                 // sending 0RTT
                                 // data and we
                                 // are waiting
                                 // for the end of
                                 // the handsake.
  int64_t mContentBytesWritten0RTT;
  bool mEarlyDataNegotiated;  // Only used for telemetry
  nsCString mEarlyNegotiatedALPN;
  bool mDid0RTTSpdy;

  bool mFastOpen;
  uint8_t mFastOpenStatus;

  bool mForceSendDuringFastOpenPending;
  bool mReceivedSocketWouldBlockDuringFastOpen;
  bool mCheckNetworkStallsWithTFO;
  PRIntervalTime mLastRequestBytesSentTime;

 public:
  void BootstrapTimings(TimingStruct times);

 private:
  TimingStruct mBootstrappedTimings;
  bool mBootstrappedTimingsSet;
};

NS_DEFINE_STATIC_IID_ACCESSOR(nsHttpConnection, NS_HTTPCONNECTION_IID)

}  // namespace net
}  // namespace mozilla

#endif  // nsHttpConnection_h__