Source code

Revision control

Copy as Markdown

Other Tools

/* -*- Mode: C++; tab-width: 4; 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 */
#ifndef nsHttpConnection_h__
#define nsHttpConnection_h__
#include <functional>
#include "HttpConnectionBase.h"
#include "nsHttpConnectionInfo.h"
#include "nsHttpResponseHead.h"
#include "nsAHttpTransaction.h"
#include "nsCOMPtr.h"
#include "nsProxyRelease.h"
#include "prinrval.h"
#include "mozilla/Mutex.h"
#include "ARefBase.h"
#include "TimingStruct.h"
#include "HttpTrafficAnalyzer.h"
#include "TlsHandshaker.h"
#include "nsIAsyncInputStream.h"
#include "nsIAsyncOutputStream.h"
#include "nsIInterfaceRequestor.h"
#include "nsISocketTransport.h"
#include "nsISupportsPriority.h"
#include "nsITimer.h"
#include "nsITlsHandshakeListener.h"
class nsISocketTransport;
class nsITLSSocketControl;
namespace mozilla {
namespace net {
class nsHttpHandler;
class ASpdySession;
// 1dcc863e-db90-4652-a1fe-13fea0b54e46
{ \
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 HttpConnectionBase,
public nsAHttpSegmentReader,
public nsAHttpSegmentWriter,
public nsIInputStreamCallback,
public nsIOutputStreamCallback,
public nsITransportEventSink,
public nsIInterfaceRequestor {
virtual ~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.
[[nodiscard]] virtual nsresult Init(nsHttpConnectionInfo* info,
uint16_t maxHangTime, nsISocketTransport*,
bool connectedTransport, nsresult status,
nsIInterfaceRequestor*, PRIntervalTime,
bool forWebSocket);
// XXX document when these are ok to call
bool IsKeepAlive() {
return (mUsingSpdyVersion != SpdyVersion::NONE) ||
(mKeepAliveMask && mKeepAlive);
// Returns time in seconds for how long connection can be reused.
uint32_t TimeToLive();
bool NeedSpdyTunnel() {
return mConnInfo->UsingHttpsProxy() && !mHasTLSTransportLayer &&
// 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);
void SetIsReusedAfter(uint32_t afterMilliseconds);
int64_t MaxBytesRead() { return mMaxBytesRead; }
HttpVersion GetLastHttpResponseVersion() { return mLastHttpResponseVersion; }
friend class HttpConnectionForceIO;
friend class TlsHandshaker;
// 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() override { return (mUsingSpdyVersion != SpdyVersion::NONE); }
SpdyVersion GetSpdyVersion() { return mUsingSpdyVersion; }
bool EverUsedSpdy() { return mEverUsedSpdy; }
bool UsingHttp3() override { return false; }
// 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 ContentBytesWritten() { return mContentBytesWritten; }
void SetupSecondaryTLS();
void SetInSpdyTunnel();
// 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));
// 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 override;
WebSocketSupport GetWebSocketSupport() override;
int64_t BytesWritten() override { return mTotalBytesWritten; }
nsISocketTransport* Transport() override { return mSocketTransport; }
nsresult GetSelfAddr(NetAddr* addr) override;
nsresult GetPeerAddr(NetAddr* addr) override;
bool ResolvedByTRR() override;
bool GetEchConfigUsed() override;
nsIRequest::TRRMode EffectiveTRRMode() override;
TRRSkippedReason TRRSkipReason() override;
bool IsForWebSocket() { return mForWebSocket; }
// The following functions are related to setting up a tunnel.
[[nodiscard]] static nsresult MakeConnectString(
nsAHttpTransaction* trans, nsHttpRequestHead* request, nsACString& result,
bool h2ws, bool aShouldResistFingerprinting);
[[nodiscard]] static nsresult ReadFromStream(nsIInputStream*, void*,
const char*, uint32_t, uint32_t,
nsresult CreateTunnelStream(nsAHttpTransaction* httpTransaction,
nsHttpConnection** aHttpConnection,
bool aIsWebSocket = false);
bool RequestDone() { return mRequestDone; }
enum HttpConnectionState {
} mState{HttpConnectionState::UNINITIALIZED};
void ChangeState(HttpConnectionState newState);
// Tunnel retated functions:
bool TunnelSetupInProgress() { return mState == SETTING_UP_TUNNEL; }
void SetTunnelSetupDone();
nsresult CheckTunnelIsNeeded();
nsresult SetupProxyConnectStream();
nsresult SendConnectRequest(void* closure, uint32_t* transactionBytes);
void HandleTunnelResponse(uint16_t responseStatus, bool* reset);
void HandleWebSocketResponse(nsHttpRequestHead* requestHead,
nsHttpResponseHead* responseHead,
uint16_t responseStatus);
void ResetTransaction(RefPtr<nsAHttpTransaction>&& trans);
// Value (set in mTCPKeepaliveConfig) indicates which set of prefs to use.
enum TCPKeepaliveConfig {
kTCPKeepaliveDisabled = 0,
[[nodiscard]] nsresult OnTransactionDone(nsresult reason);
[[nodiscard]] nsresult OnSocketWritable();
[[nodiscard]] nsresult OnSocketReadable();
PRIntervalTime IdleTime();
bool IsAlive();
// Start the Spdy transaction handler when NPN indicates spdy/*
void StartSpdy(nsITLSSocketControl* ssl, SpdyVersion spdyVersion);
// Like the above, but do the bare minimum to do 0RTT data, so we can back
// it out, if necessary
void Start0RTTSpdy(SpdyVersion spdyVersion);
// 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
[[nodiscard]] 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.
[[nodiscard]] nsresult StartShortLivedTCPKeepalives();
[[nodiscard]] nsresult StartLongLivedTCPKeepalives();
[[nodiscard]] nsresult DisableTCPKeepalives();
bool CheckCanWrite0RTTData();
void PostProcessNPNSetup(bool handshakeSucceeded, bool hasSecurityInfo,
bool earlyDataUsed);
void Reset0RttForSpdy();
void HandshakeDoneInternal();
uint32_t TransactionCaps() const { return mTransactionCaps; }
void MarkAsDontReuse();
// mTransaction only points to the HTTP Transaction callbacks if the
// transaction is open, otherwise it is null.
RefPtr<nsAHttpTransaction> mTransaction;
RefPtr<TlsHandshaker> mTlsHandshaker;
nsCOMPtr<nsIAsyncInputStream> mSocketIn;
nsCOMPtr<nsIAsyncOutputStream> mSocketOut;
nsresult mSocketInCondition{NS_ERROR_NOT_INITIALIZED};
nsresult mSocketOutCondition{NS_ERROR_NOT_INITIALIZED};
RefPtr<nsHttpHandler> mHttpHandler; // keep gHttpHandler alive
PRIntervalTime mLastReadTime{0};
PRIntervalTime mLastWriteTime{0};
// max download time before dropping keep-alive status
PRIntervalTime mMaxHangTime{0};
PRIntervalTime mIdleTimeout; // value of keep-alive: timeout=
PRIntervalTime mConsiderReusedAfterInterval{0};
PRIntervalTime mConsiderReusedAfterEpoch{0};
int64_t mCurrentBytesRead{0}; // data read per activation
int64_t mMaxBytesRead{0}; // max read in 1 activation
int64_t mTotalBytesRead{0}; // total data read
int64_t mContentBytesWritten{0}; // does not include CONNECT tunnel or TLS
RefPtr<nsIAsyncInputStream> mInputOverflow;
// Whether the first non-null transaction dispatched on this connection was
// urgent-start or not
bool mUrgentStartPreferred{false};
// A flag to prevent reset of mUrgentStartPreferred by subsequent transactions
bool mUrgentStartPreferredKnown{false};
bool mConnectedTransport{false};
// assume to keep-alive by default
bool mKeepAlive{true};
bool mKeepAliveMask{true};
bool mDontReuse{false};
bool mIsReused{false};
bool mLastTransactionExpectedNoContent{false};
bool mIdleMonitoring{false};
bool mInSpdyTunnel{false};
bool mForcePlainText{false};
// A snapshot of current number of transfered bytes
int64_t mTrafficCount{0};
bool mTrafficStamp{false}; // true then the above is set
// The number of <= HTTP/1.1 transactions performed on this connection. This
// excludes spdy transactions.
uint32_t mHttp1xTransactionCount{0};
// 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{0xffffffff};
// version level in use, 0 if unused
SpdyVersion mUsingSpdyVersion{SpdyVersion::NONE};
RefPtr<ASpdySession> mSpdySession;
RefPtr<ASpdySession> mWebSocketHttp2Session;
int32_t mPriority{nsISupportsPriority::PRIORITY_NORMAL};
bool mReportedSpdy{false};
// mUsingSpdyVersion is cleared when mSpdySession is freed, this is permanent
bool mEverUsedSpdy{false};
// mLastHttpResponseVersion stores the last response's http version seen.
HttpVersion mLastHttpResponseVersion{HttpVersion::v1_1};
// If a large keepalive has been requested for any trans,
// scale the default by this factor
uint32_t mDefaultTimeoutFactor{1};
bool mResponseTimeoutEnabled{false};
// Flag to indicate connection is in inital keepalive period (fast detect).
uint32_t mTCPKeepaliveConfig{kTCPKeepaliveDisabled};
nsCOMPtr<nsITimer> mTCPKeepaliveTransitionTimer;
// For ForceSend()
static void ForceSendIO(nsITimer* aTimer, void* aClosure);
[[nodiscard]] nsresult MaybeForceSendIO();
bool mForceSendPending{false};
nsCOMPtr<nsITimer> mForceSendTimer;
int64_t mContentBytesWritten0RTT{0};
bool mDid0RTTSpdy{false};
nsresult mErrorBeforeConnect = NS_OK;
nsCOMPtr<nsISocketTransport> mSocketTransport;
// This flag indicates if the connection is used for WebSocket.
// - When true and mInSpdyTunnel is also true: WebSocket over HTTP/2.
// - When true and mInSpdyTunnel is false: WebSocket over HTTP/1.1.
bool mForWebSocket{false};
std::function<void()> mContinueHandshakeDone{nullptr};
bool mThroughCaptivePortal;
int64_t mTotalBytesWritten = 0; // does not include CONNECT tunnel
nsCOMPtr<nsIInputStream> mProxyConnectStream;
bool mRequestDone{false};
bool mHasTLSTransportLayer{false};
bool mTransactionDisallowHttp3{false};
} // namespace net
} // namespace mozilla
#endif // nsHttpConnection_h__