summaryrefslogtreecommitdiffstats
path: root/netwerk/protocol/http/Http3Session.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--netwerk/protocol/http/Http3Session.cpp2478
1 files changed, 2478 insertions, 0 deletions
diff --git a/netwerk/protocol/http/Http3Session.cpp b/netwerk/protocol/http/Http3Session.cpp
new file mode 100644
index 0000000000..d2a5f4ed9b
--- /dev/null
+++ b/netwerk/protocol/http/Http3Session.cpp
@@ -0,0 +1,2478 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=4 sw=2 et cindent: */
+/* 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/. */
+
+#include "ASpdySession.h" // because of SoftStreamError()
+#include "Http3Session.h"
+#include "Http3Stream.h"
+#include "Http3StreamBase.h"
+#include "Http3WebTransportSession.h"
+#include "Http3WebTransportStream.h"
+#include "HttpConnectionUDP.h"
+#include "HttpLog.h"
+#include "QuicSocketControl.h"
+#include "SSLServerCertVerification.h"
+#include "SSLTokensCache.h"
+#include "ScopedNSSTypes.h"
+#include "mozilla/RandomNum.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/net/DNS.h"
+#include "nsHttpHandler.h"
+#include "nsIHttpActivityObserver.h"
+#include "nsIOService.h"
+#include "nsITLSSocketControl.h"
+#include "nsNetAddr.h"
+#include "nsQueryObject.h"
+#include "nsSocketTransportService2.h"
+#include "nsThreadUtils.h"
+#include "sslerr.h"
+
+namespace mozilla::net {
+
+const uint64_t HTTP3_APP_ERROR_NO_ERROR = 0x100;
+// const uint64_t HTTP3_APP_ERROR_GENERAL_PROTOCOL_ERROR = 0x101;
+// const uint64_t HTTP3_APP_ERROR_INTERNAL_ERROR = 0x102;
+// const uint64_t HTTP3_APP_ERROR_STREAM_CREATION_ERROR = 0x103;
+// const uint64_t HTTP3_APP_ERROR_CLOSED_CRITICAL_STREAM = 0x104;
+// const uint64_t HTTP3_APP_ERROR_FRAME_UNEXPECTED = 0x105;
+// const uint64_t HTTP3_APP_ERROR_FRAME_ERROR = 0x106;
+// const uint64_t HTTP3_APP_ERROR_EXCESSIVE_LOAD = 0x107;
+// const uint64_t HTTP3_APP_ERROR_ID_ERROR = 0x108;
+// const uint64_t HTTP3_APP_ERROR_SETTINGS_ERROR = 0x109;
+// const uint64_t HTTP3_APP_ERROR_MISSING_SETTINGS = 0x10a;
+const uint64_t HTTP3_APP_ERROR_REQUEST_REJECTED = 0x10b;
+const uint64_t HTTP3_APP_ERROR_REQUEST_CANCELLED = 0x10c;
+// const uint64_t HTTP3_APP_ERROR_REQUEST_INCOMPLETE = 0x10d;
+// const uint64_t HTTP3_APP_ERROR_EARLY_RESPONSE = 0x10e;
+// const uint64_t HTTP3_APP_ERROR_CONNECT_ERROR = 0x10f;
+const uint64_t HTTP3_APP_ERROR_VERSION_FALLBACK = 0x110;
+
+// const uint32_t UDP_MAX_PACKET_SIZE = 4096;
+const uint32_t MAX_PTO_COUNTS = 16;
+
+const uint32_t TRANSPORT_ERROR_STATELESS_RESET = 20;
+
+NS_IMPL_ADDREF(Http3Session)
+NS_IMPL_RELEASE(Http3Session)
+NS_INTERFACE_MAP_BEGIN(Http3Session)
+ NS_INTERFACE_MAP_ENTRY(nsAHttpConnection)
+ NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
+ NS_INTERFACE_MAP_ENTRY_CONCRETE(Http3Session)
+NS_INTERFACE_MAP_END
+
+Http3Session::Http3Session() {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+ LOG(("Http3Session::Http3Session [this=%p]", this));
+
+ mCurrentBrowserId = gHttpHandler->ConnMgr()->CurrentBrowserId();
+ mThroughCaptivePortal = gHttpHandler->GetThroughCaptivePortal();
+}
+
+static nsresult StringAndPortToNetAddr(nsACString& remoteAddrStr,
+ uint16_t remotePort, NetAddr* netAddr) {
+ if (NS_FAILED(netAddr->InitFromString(remoteAddrStr, remotePort))) {
+ return NS_ERROR_FAILURE;
+ }
+
+ return NS_OK;
+}
+
+nsresult Http3Session::Init(const nsHttpConnectionInfo* aConnInfo,
+ nsINetAddr* aSelfAddr, nsINetAddr* aPeerAddr,
+ HttpConnectionUDP* udpConn, uint32_t controlFlags,
+ nsIInterfaceRequestor* callbacks) {
+ LOG3(("Http3Session::Init %p", this));
+
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+ MOZ_ASSERT(udpConn);
+
+ mConnInfo = aConnInfo->Clone();
+ mNetAddr = aPeerAddr;
+
+ bool httpsProxy =
+ aConnInfo->ProxyInfo() ? aConnInfo->ProxyInfo()->IsHTTPS() : false;
+
+ // Create security control and info object for quic.
+ mSocketControl = new QuicSocketControl(
+ httpsProxy ? aConnInfo->ProxyInfo()->Host() : aConnInfo->GetOrigin(),
+ httpsProxy ? aConnInfo->ProxyInfo()->Port() : aConnInfo->OriginPort(),
+ controlFlags, this);
+
+ NetAddr selfAddr;
+ MOZ_ALWAYS_SUCCEEDS(aSelfAddr->GetNetAddr(&selfAddr));
+ NetAddr peerAddr;
+ MOZ_ALWAYS_SUCCEEDS(aPeerAddr->GetNetAddr(&peerAddr));
+
+ LOG3(
+ ("Http3Session::Init origin=%s, alpn=%s, selfAddr=%s, peerAddr=%s,"
+ " qpack table size=%u, max blocked streams=%u webtransport=%d "
+ "[this=%p]",
+ PromiseFlatCString(mConnInfo->GetOrigin()).get(),
+ PromiseFlatCString(mConnInfo->GetNPNToken()).get(),
+ selfAddr.ToString().get(), peerAddr.ToString().get(),
+ gHttpHandler->DefaultQpackTableSize(),
+ gHttpHandler->DefaultHttp3MaxBlockedStreams(),
+ mConnInfo->GetWebTransport(), this));
+
+ if (mConnInfo->GetWebTransport()) {
+ mWebTransportNegotiationStatus = WebTransportNegotiation::NEGOTIATING;
+ }
+
+ uint32_t datagramSize =
+ StaticPrefs::network_webtransport_datagrams_enabled()
+ ? StaticPrefs::network_webtransport_datagram_size()
+ : 0;
+ nsresult rv = NeqoHttp3Conn::Init(
+ mConnInfo->GetOrigin(), mConnInfo->GetNPNToken(), selfAddr, peerAddr,
+ gHttpHandler->DefaultQpackTableSize(),
+ gHttpHandler->DefaultHttp3MaxBlockedStreams(),
+ StaticPrefs::network_http_http3_max_data(),
+ StaticPrefs::network_http_http3_max_stream_data(),
+ StaticPrefs::network_http_http3_version_negotiation_enabled(),
+ mConnInfo->GetWebTransport(), gHttpHandler->Http3QlogDir(), datagramSize,
+ getter_AddRefs(mHttp3Connection));
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ nsAutoCString peerId;
+ mSocketControl->GetPeerId(peerId);
+ nsTArray<uint8_t> token;
+ SessionCacheInfo info;
+ if (StaticPrefs::network_http_http3_enable_0rtt() &&
+ NS_SUCCEEDED(SSLTokensCache::Get(peerId, token, info))) {
+ LOG(("Found a resumption token in the cache."));
+ mHttp3Connection->SetResumptionToken(token);
+ mSocketControl->SetSessionCacheInfo(std::move(info));
+ if (mHttp3Connection->IsZeroRtt()) {
+ LOG(("Can send ZeroRtt data"));
+ RefPtr<Http3Session> self(this);
+ mState = ZERORTT;
+ mZeroRttStarted = TimeStamp::Now();
+ // Let the nsHttpConnectionMgr know that the connection can accept
+ // transactions.
+ // We need to dispatch the following function to this thread so that
+ // it is executed after the current function. At this point a
+ // Http3Session is still being initialized and ReportHttp3Connection
+ // will try to dispatch transaction on this session therefore it
+ // needs to be executed after the initializationg is done.
+ DebugOnly<nsresult> rv = NS_DispatchToCurrentThread(
+ NS_NewRunnableFunction("Http3Session::ReportHttp3Connection",
+ [self]() { self->ReportHttp3Connection(); }));
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+ "NS_DispatchToCurrentThread failed");
+ }
+ }
+
+ if (mState != ZERORTT) {
+ ZeroRttTelemetry(ZeroRttOutcome::NOT_USED);
+ }
+
+ auto config = mConnInfo->GetEchConfig();
+ if (config.IsEmpty()) {
+ if (StaticPrefs::security_tls_ech_grease_http3() && config.IsEmpty()) {
+ if ((RandomUint64().valueOr(0) % 100) >=
+ 100 - StaticPrefs::security_tls_ech_grease_probability()) {
+ // Setting an empty config enables GREASE mode.
+ mSocketControl->SetEchConfig(config);
+ mEchExtensionStatus = EchExtensionStatus::kGREASE;
+ }
+ }
+ } else if (gHttpHandler->EchConfigEnabled(true) && !config.IsEmpty()) {
+ mSocketControl->SetEchConfig(config);
+ mEchExtensionStatus = EchExtensionStatus::kReal;
+ HttpConnectionActivity activity(
+ mConnInfo->HashKey(), mConnInfo->GetOrigin(), mConnInfo->OriginPort(),
+ mConnInfo->EndToEndSSL(), !mConnInfo->GetEchConfig().IsEmpty(),
+ mConnInfo->IsHttp3());
+ gHttpHandler->ObserveHttpActivityWithArgs(
+ activity, NS_ACTIVITY_TYPE_HTTP_CONNECTION,
+ NS_HTTP_ACTIVITY_SUBTYPE_ECH_SET, PR_Now(), 0, ""_ns);
+ } else {
+ mEchExtensionStatus = EchExtensionStatus::kNotPresent;
+ }
+
+ // After this line, Http3Session and HttpConnectionUDP become a cycle. We put
+ // this line in the end of Http3Session::Init to make sure Http3Session can be
+ // released when Http3Session::Init early returned.
+ mUdpConn = udpConn;
+ return NS_OK;
+}
+
+void Http3Session::DoSetEchConfig(const nsACString& aEchConfig) {
+ LOG(("Http3Session::DoSetEchConfig %p of length %zu", this,
+ aEchConfig.Length()));
+ nsTArray<uint8_t> config;
+ config.AppendElements(
+ reinterpret_cast<const uint8_t*>(aEchConfig.BeginReading()),
+ aEchConfig.Length());
+ mHttp3Connection->SetEchConfig(config);
+}
+
+nsresult Http3Session::SendPriorityUpdateFrame(uint64_t aStreamId,
+ uint8_t aPriorityUrgency,
+ bool aPriorityIncremental) {
+ return mHttp3Connection->PriorityUpdate(aStreamId, aPriorityUrgency,
+ aPriorityIncremental);
+}
+
+// Shutdown the http3session and close all transactions.
+void Http3Session::Shutdown() {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+
+ if (mTimer) {
+ mTimer->Cancel();
+ }
+ mTimer = nullptr;
+
+ bool isEchRetry = mError == mozilla::psm::GetXPCOMFromNSSError(
+ SSL_ERROR_ECH_RETRY_WITH_ECH);
+ bool allowToRetryWithDifferentIPFamily =
+ mBeforeConnectedError &&
+ gHttpHandler->ConnMgr()->AllowToRetryDifferentIPFamilyForHttp3(mConnInfo,
+ mError);
+ LOG(("Http3Session::Shutdown %p allowToRetryWithDifferentIPFamily=%d", this,
+ allowToRetryWithDifferentIPFamily));
+ if ((mBeforeConnectedError ||
+ (mError == NS_ERROR_NET_HTTP3_PROTOCOL_ERROR)) &&
+ (mError !=
+ mozilla::psm::GetXPCOMFromNSSError(SSL_ERROR_BAD_CERT_DOMAIN)) &&
+ !isEchRetry && !mConnInfo->GetWebTransport() &&
+ !allowToRetryWithDifferentIPFamily && !mDontExclude) {
+ gHttpHandler->ExcludeHttp3(mConnInfo);
+ }
+
+ for (const auto& stream : mStreamTransactionHash.Values()) {
+ if (mBeforeConnectedError) {
+ // We have an error before we were connected, just restart transactions.
+ // The transaction restart code path will remove AltSvc mapping and the
+ // direct path will be used.
+ MOZ_ASSERT(NS_FAILED(mError));
+ if (isEchRetry) {
+ // We have to propagate this error to nsHttpTransaction, so the
+ // transaction will be restarted with a new echConfig.
+ stream->Close(mError);
+ } else {
+ if (allowToRetryWithDifferentIPFamily && mNetAddr) {
+ NetAddr addr;
+ mNetAddr->GetNetAddr(&addr);
+ gHttpHandler->ConnMgr()->SetRetryDifferentIPFamilyForHttp3(
+ mConnInfo, addr.raw.family);
+ nsHttpTransaction* trans =
+ stream->Transaction()->QueryHttpTransaction();
+ if (trans) {
+ // This is a bit hacky. We redispatch the transaction here to avoid
+ // touching the complicated retry logic in nsHttpTransaction.
+ trans->RemoveConnection();
+ Unused << gHttpHandler->InitiateTransaction(trans,
+ trans->Priority());
+ } else {
+ stream->Close(NS_ERROR_NET_RESET);
+ }
+ // Since Http3Session::Shutdown can be called multiple times, we set
+ // mDontExclude for not putting this domain into the excluded list.
+ mDontExclude = true;
+ } else {
+ stream->Close(NS_ERROR_NET_RESET);
+ }
+ }
+ } else if (!stream->HasStreamId()) {
+ if (NS_SUCCEEDED(mError)) {
+ // Connection has not been started yet. We can restart it.
+ stream->Transaction()->DoNotRemoveAltSvc();
+ }
+ stream->Close(NS_ERROR_NET_RESET);
+ } else if (stream->GetHttp3Stream() &&
+ stream->GetHttp3Stream()->RecvdData()) {
+ stream->Close(NS_ERROR_NET_PARTIAL_TRANSFER);
+ } else if (mError == NS_ERROR_NET_HTTP3_PROTOCOL_ERROR) {
+ stream->Close(NS_ERROR_NET_HTTP3_PROTOCOL_ERROR);
+ } else if (mError == NS_ERROR_NET_RESET) {
+ stream->Close(NS_ERROR_NET_RESET);
+ } else {
+ stream->Close(NS_ERROR_ABORT);
+ }
+ RemoveStreamFromQueues(stream);
+ if (stream->HasStreamId()) {
+ mStreamIdHash.Remove(stream->StreamId());
+ }
+ }
+ mStreamTransactionHash.Clear();
+
+ for (const auto& stream : mWebTransportSessions) {
+ stream->Close(NS_ERROR_ABORT);
+ RemoveStreamFromQueues(stream);
+ mStreamIdHash.Remove(stream->StreamId());
+ }
+ mWebTransportSessions.Clear();
+
+ for (const auto& stream : mWebTransportStreams) {
+ stream->Close(NS_ERROR_ABORT);
+ RemoveStreamFromQueues(stream);
+ mStreamIdHash.Remove(stream->StreamId());
+ }
+ mWebTransportStreams.Clear();
+}
+
+Http3Session::~Http3Session() {
+ LOG3(("Http3Session::~Http3Session %p", this));
+
+ EchOutcomeTelemetry();
+ Telemetry::Accumulate(Telemetry::HTTP3_REQUEST_PER_CONN, mTransactionCount);
+ Telemetry::Accumulate(Telemetry::HTTP3_BLOCKED_BY_STREAM_LIMIT_PER_CONN,
+ mBlockedByStreamLimitCount);
+ Telemetry::Accumulate(Telemetry::HTTP3_TRANS_BLOCKED_BY_STREAM_LIMIT_PER_CONN,
+ mTransactionsBlockedByStreamLimitCount);
+
+ Telemetry::Accumulate(
+ Telemetry::HTTP3_TRANS_SENDING_BLOCKED_BY_FLOW_CONTROL_PER_CONN,
+ mTransactionsSenderBlockedByFlowControlCount);
+
+ if (mThroughCaptivePortal) {
+ if (mTotalBytesRead || mTotalBytesWritten) {
+ auto total =
+ Clamp<uint32_t>((mTotalBytesRead >> 10) + (mTotalBytesWritten >> 10),
+ 0, std::numeric_limits<uint32_t>::max());
+ Telemetry::ScalarAdd(
+ Telemetry::ScalarID::NETWORKING_DATA_TRANSFERRED_CAPTIVE_PORTAL,
+ total);
+ }
+
+ Telemetry::ScalarAdd(
+ Telemetry::ScalarID::NETWORKING_HTTP_CONNECTIONS_CAPTIVE_PORTAL, 1);
+ }
+
+ Shutdown();
+}
+
+// This function may return a socket error.
+// It will not return an error if socket error is
+// NS_BASE_STREAM_WOULD_BLOCK.
+// A caller of this function will close the Http3 connection
+// in case of a error.
+// The only callers is:
+// HttpConnectionUDP::RecvData ->
+// Http3Session::RecvData
+void Http3Session::ProcessInput(nsIUDPSocket* socket) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+ MOZ_ASSERT(mUdpConn);
+
+ LOG(("Http3Session::ProcessInput writer=%p [this=%p state=%d]",
+ mUdpConn.get(), this, mState));
+
+ while (true) {
+ nsTArray<uint8_t> data;
+ NetAddr addr{};
+ // RecvWithAddr actually does not return an error.
+ nsresult rv = socket->RecvWithAddr(&addr, data);
+ MOZ_ALWAYS_SUCCEEDS(rv);
+ if (NS_FAILED(rv) || data.IsEmpty()) {
+ break;
+ }
+ rv = mHttp3Connection->ProcessInput(addr, data);
+ MOZ_ALWAYS_SUCCEEDS(rv);
+ if (NS_FAILED(rv)) {
+ break;
+ }
+
+ LOG(("Http3Session::ProcessInput received=%zu", data.Length()));
+ mTotalBytesRead += data.Length();
+ }
+}
+
+nsresult Http3Session::ProcessTransactionRead(uint64_t stream_id) {
+ RefPtr<Http3StreamBase> stream = mStreamIdHash.Get(stream_id);
+ if (!stream) {
+ LOG(
+ ("Http3Session::ProcessTransactionRead - stream not found "
+ "stream_id=0x%" PRIx64 " [this=%p].",
+ stream_id, this));
+ return NS_OK;
+ }
+
+ return ProcessTransactionRead(stream);
+}
+
+nsresult Http3Session::ProcessTransactionRead(Http3StreamBase* stream) {
+ nsresult rv = stream->WriteSegments();
+
+ if (ASpdySession::SoftStreamError(rv) || stream->Done()) {
+ LOG3(
+ ("Http3Session::ProcessSingleTransactionRead session=%p stream=%p "
+ "0x%" PRIx64 " cleanup stream rv=0x%" PRIx32 " done=%d.\n",
+ this, stream, stream->StreamId(), static_cast<uint32_t>(rv),
+ stream->Done()));
+ CloseStream(stream,
+ (rv == NS_BINDING_RETARGETED) ? NS_BINDING_RETARGETED : NS_OK);
+ return NS_OK;
+ }
+
+ if (NS_FAILED(rv) && rv != NS_BASE_STREAM_WOULD_BLOCK) {
+ return rv;
+ }
+ return NS_OK;
+}
+
+nsresult Http3Session::ProcessEvents() {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+
+ LOG(("Http3Session::ProcessEvents [this=%p]", this));
+
+ // We need an array to pick up header data or a resumption token.
+ nsTArray<uint8_t> data;
+ Http3Event event{};
+ event.tag = Http3Event::Tag::NoEvent;
+
+ nsresult rv = mHttp3Connection->GetEvent(&event, data);
+ if (NS_FAILED(rv)) {
+ LOG(("Http3Session::ProcessEvents [this=%p] rv=%" PRIx32, this,
+ static_cast<uint32_t>(rv)));
+ return rv;
+ }
+
+ while (event.tag != Http3Event::Tag::NoEvent) {
+ switch (event.tag) {
+ case Http3Event::Tag::HeaderReady: {
+ MOZ_ASSERT(mState == CONNECTED);
+ LOG(("Http3Session::ProcessEvents - HeaderReady"));
+ uint64_t id = event.header_ready.stream_id;
+
+ RefPtr<Http3StreamBase> stream = mStreamIdHash.Get(id);
+ if (!stream) {
+ LOG(
+ ("Http3Session::ProcessEvents - HeaderReady - stream not found "
+ "stream_id=0x%" PRIx64 " [this=%p].",
+ id, this));
+ break;
+ }
+
+ MOZ_RELEASE_ASSERT(stream->GetHttp3Stream(),
+ "This must be a Http3Stream");
+
+ stream->SetResponseHeaders(data, event.header_ready.fin,
+ event.header_ready.interim);
+
+ rv = ProcessTransactionRead(stream);
+
+ if (NS_FAILED(rv)) {
+ LOG(("Http3Session::ProcessEvents [this=%p] rv=%" PRIx32, this,
+ static_cast<uint32_t>(rv)));
+ return rv;
+ }
+ break;
+ }
+ case Http3Event::Tag::DataReadable: {
+ MOZ_ASSERT(mState == CONNECTED);
+ LOG(("Http3Session::ProcessEvents - DataReadable"));
+ uint64_t id = event.data_readable.stream_id;
+
+ nsresult rv = ProcessTransactionRead(id);
+
+ if (NS_FAILED(rv)) {
+ LOG(("Http3Session::ProcessEvents [this=%p] rv=%" PRIx32, this,
+ static_cast<uint32_t>(rv)));
+ return rv;
+ }
+ break;
+ }
+ case Http3Event::Tag::DataWritable: {
+ MOZ_ASSERT(CanSandData());
+ LOG(("Http3Session::ProcessEvents - DataWritable"));
+
+ RefPtr<Http3StreamBase> stream =
+ mStreamIdHash.Get(event.data_writable.stream_id);
+
+ if (stream) {
+ StreamReadyToWrite(stream);
+ }
+ } break;
+ case Http3Event::Tag::Reset:
+ LOG(("Http3Session::ProcessEvents %p - Reset", this));
+ ResetOrStopSendingRecvd(event.reset.stream_id, event.reset.error,
+ RESET);
+ break;
+ case Http3Event::Tag::StopSending:
+ LOG(
+ ("Http3Session::ProcessEvents %p - StopSeniding with error "
+ "0x%" PRIx64,
+ this, event.stop_sending.error));
+ if (event.stop_sending.error == HTTP3_APP_ERROR_NO_ERROR) {
+ RefPtr<Http3StreamBase> stream =
+ mStreamIdHash.Get(event.data_writable.stream_id);
+ if (stream) {
+ RefPtr<Http3Stream> httpStream = stream->GetHttp3Stream();
+ MOZ_RELEASE_ASSERT(httpStream, "This must be a Http3Stream");
+ httpStream->StopSending();
+ }
+ } else {
+ ResetOrStopSendingRecvd(event.reset.stream_id, event.reset.error,
+ STOP_SENDING);
+ }
+ break;
+ case Http3Event::Tag::PushPromise:
+ LOG(("Http3Session::ProcessEvents - PushPromise"));
+ break;
+ case Http3Event::Tag::PushHeaderReady:
+ LOG(("Http3Session::ProcessEvents - PushHeaderReady"));
+ break;
+ case Http3Event::Tag::PushDataReadable:
+ LOG(("Http3Session::ProcessEvents - PushDataReadable"));
+ break;
+ case Http3Event::Tag::PushCanceled:
+ LOG(("Http3Session::ProcessEvents - PushCanceled"));
+ break;
+ case Http3Event::Tag::RequestsCreatable:
+ LOG(("Http3Session::ProcessEvents - StreamCreatable"));
+ ProcessPending();
+ break;
+ case Http3Event::Tag::AuthenticationNeeded:
+ LOG(("Http3Session::ProcessEvents - AuthenticationNeeded %d",
+ mAuthenticationStarted));
+ if (!mAuthenticationStarted) {
+ mAuthenticationStarted = true;
+ LOG(("Http3Session::ProcessEvents - AuthenticationNeeded called"));
+ CallCertVerification(Nothing());
+ }
+ break;
+ case Http3Event::Tag::ZeroRttRejected:
+ LOG(("Http3Session::ProcessEvents - ZeroRttRejected"));
+ if (mState == ZERORTT) {
+ mState = INITIALIZING;
+ mTransactionCount = 0;
+ Finish0Rtt(true);
+ ZeroRttTelemetry(ZeroRttOutcome::USED_REJECTED);
+ }
+ break;
+ case Http3Event::Tag::ResumptionToken: {
+ LOG(("Http3Session::ProcessEvents - ResumptionToken"));
+ if (StaticPrefs::network_http_http3_enable_0rtt() && !data.IsEmpty()) {
+ LOG(("Got a resumption token"));
+ nsAutoCString peerId;
+ mSocketControl->GetPeerId(peerId);
+ if (NS_FAILED(SSLTokensCache::Put(
+ peerId, data.Elements(), data.Length(), mSocketControl,
+ PR_Now() + event.resumption_token.expire_in))) {
+ LOG(("Adding resumption token failed"));
+ }
+ }
+ } break;
+ case Http3Event::Tag::ConnectionConnected: {
+ LOG(("Http3Session::ProcessEvents - ConnectionConnected"));
+ bool was0RTT = mState == ZERORTT;
+ mState = CONNECTED;
+ SetSecInfo();
+ mSocketControl->HandshakeCompleted();
+ if (was0RTT) {
+ Finish0Rtt(false);
+ ZeroRttTelemetry(ZeroRttOutcome::USED_SUCCEEDED);
+ }
+
+ OnTransportStatus(mSocketTransport, NS_NET_STATUS_CONNECTED_TO, 0);
+ // Also send the NS_NET_STATUS_TLS_HANDSHAKE_ENDED event.
+ OnTransportStatus(mSocketTransport, NS_NET_STATUS_TLS_HANDSHAKE_ENDED,
+ 0);
+
+ ReportHttp3Connection();
+ // Maybe call ResumeSend:
+ // In case ZeroRtt has been used and it has been rejected, 2 events will
+ // be received: ZeroRttRejected and ConnectionConnected. ZeroRttRejected
+ // that will put all transaction into mReadyForWrite queue and it will
+ // call MaybeResumeSend, but that will not have an effect because the
+ // connection is ont in CONNECTED state. When ConnectionConnected event
+ // is received call MaybeResumeSend to trigger reads for the
+ // zero-rtt-rejected transactions.
+ MaybeResumeSend();
+ } break;
+ case Http3Event::Tag::GoawayReceived:
+ LOG(("Http3Session::ProcessEvents - GoawayReceived"));
+ mGoawayReceived = true;
+ break;
+ case Http3Event::Tag::ConnectionClosing:
+ LOG(("Http3Session::ProcessEvents - ConnectionClosing"));
+ if (NS_SUCCEEDED(mError) && !IsClosing()) {
+ mError = NS_ERROR_NET_HTTP3_PROTOCOL_ERROR;
+ CloseConnectionTelemetry(event.connection_closing.error, true);
+
+ auto isStatelessResetOrNoError = [](CloseError& aError) -> bool {
+ if (aError.tag == CloseError::Tag::TransportInternalErrorOther &&
+ aError.transport_internal_error_other._0 ==
+ TRANSPORT_ERROR_STATELESS_RESET) {
+ return true;
+ }
+ if (aError.tag == CloseError::Tag::TransportError &&
+ aError.transport_error._0 == 0) {
+ return true;
+ }
+ if (aError.tag == CloseError::Tag::PeerError &&
+ aError.peer_error._0 == 0) {
+ return true;
+ }
+ if (aError.tag == CloseError::Tag::AppError &&
+ aError.app_error._0 == HTTP3_APP_ERROR_NO_ERROR) {
+ return true;
+ }
+ if (aError.tag == CloseError::Tag::PeerAppError &&
+ aError.peer_app_error._0 == HTTP3_APP_ERROR_NO_ERROR) {
+ return true;
+ }
+ return false;
+ };
+ if (isStatelessResetOrNoError(event.connection_closing.error)) {
+ mError = NS_ERROR_NET_RESET;
+ }
+ if (event.connection_closing.error.tag == CloseError::Tag::EchRetry) {
+ mSocketControl->SetRetryEchConfig(Substring(
+ reinterpret_cast<const char*>(data.Elements()), data.Length()));
+ mError = psm::GetXPCOMFromNSSError(SSL_ERROR_ECH_RETRY_WITH_ECH);
+ }
+ }
+ return mError;
+ break;
+ case Http3Event::Tag::ConnectionClosed:
+ LOG(("Http3Session::ProcessEvents - ConnectionClosed"));
+ if (NS_SUCCEEDED(mError)) {
+ mError = NS_ERROR_NET_TIMEOUT;
+ CloseConnectionTelemetry(event.connection_closed.error, false);
+ }
+ mIsClosedByNeqo = true;
+ if (event.connection_closed.error.tag == CloseError::Tag::EchRetry) {
+ mSocketControl->SetRetryEchConfig(Substring(
+ reinterpret_cast<const char*>(data.Elements()), data.Length()));
+ mError = psm::GetXPCOMFromNSSError(SSL_ERROR_ECH_RETRY_WITH_ECH);
+ }
+ LOG(("Http3Session::ProcessEvents - ConnectionClosed error=%" PRIx32,
+ static_cast<uint32_t>(mError)));
+ // We need to return here and let HttpConnectionUDP close the session.
+ return mError;
+ break;
+ case Http3Event::Tag::EchFallbackAuthenticationNeeded: {
+ nsCString echPublicName(reinterpret_cast<const char*>(data.Elements()),
+ data.Length());
+ LOG(
+ ("Http3Session::ProcessEvents - EchFallbackAuthenticationNeeded "
+ "echPublicName=%s",
+ echPublicName.get()));
+ if (!mAuthenticationStarted) {
+ mAuthenticationStarted = true;
+ CallCertVerification(Some(echPublicName));
+ }
+ } break;
+ case Http3Event::Tag::WebTransport: {
+ switch (event.web_transport._0.tag) {
+ case WebTransportEventExternal::Tag::Negotiated:
+ LOG(("Http3Session::ProcessEvents - WebTransport %d",
+ event.web_transport._0.negotiated._0));
+ MOZ_ASSERT(mWebTransportNegotiationStatus ==
+ WebTransportNegotiation::NEGOTIATING);
+ mWebTransportNegotiationStatus =
+ event.web_transport._0.negotiated._0
+ ? WebTransportNegotiation::SUCCEEDED
+ : WebTransportNegotiation::FAILED;
+ WebTransportNegotiationDone();
+ break;
+ case WebTransportEventExternal::Tag::Session: {
+ MOZ_ASSERT(mState == CONNECTED);
+
+ uint64_t id = event.web_transport._0.session._0;
+ LOG(
+ ("Http3Session::ProcessEvents - WebTransport Session "
+ " sessionId=0x%" PRIx64,
+ id));
+ RefPtr<Http3StreamBase> stream = mStreamIdHash.Get(id);
+ if (!stream) {
+ LOG(
+ ("Http3Session::ProcessEvents - WebTransport Session - "
+ "stream not found "
+ "stream_id=0x%" PRIx64 " [this=%p].",
+ id, this));
+ break;
+ }
+
+ MOZ_RELEASE_ASSERT(stream->GetHttp3WebTransportSession(),
+ "It must be a WebTransport session");
+ stream->SetResponseHeaders(data, false, false);
+
+ rv = stream->WriteSegments();
+
+ if (ASpdySession::SoftStreamError(rv) || stream->Done()) {
+ LOG3(
+ ("Http3Session::ProcessSingleTransactionRead session=%p "
+ "stream=%p "
+ "0x%" PRIx64 " cleanup stream rv=0x%" PRIx32 " done=%d.\n",
+ this, stream.get(), stream->StreamId(),
+ static_cast<uint32_t>(rv), stream->Done()));
+ // We need to keep the transaction, so we can use it to remove the
+ // stream from mStreamTransactionHash.
+ nsAHttpTransaction* trans = stream->Transaction();
+ if (mStreamTransactionHash.Contains(trans)) {
+ CloseStream(stream, (rv == NS_BINDING_RETARGETED)
+ ? NS_BINDING_RETARGETED
+ : NS_OK);
+ mStreamTransactionHash.Remove(trans);
+ } else {
+ stream->GetHttp3WebTransportSession()->TransactionIsDone(
+ (rv == NS_BINDING_RETARGETED) ? NS_BINDING_RETARGETED
+ : NS_OK);
+ }
+ break;
+ }
+
+ if (NS_FAILED(rv) && rv != NS_BASE_STREAM_WOULD_BLOCK) {
+ LOG(("Http3Session::ProcessEvents [this=%p] rv=%" PRIx32, this,
+ static_cast<uint32_t>(rv)));
+ return rv;
+ }
+ } break;
+ case WebTransportEventExternal::Tag::SessionClosed: {
+ uint64_t id = event.web_transport._0.session_closed.stream_id;
+ LOG(
+ ("Http3Session::ProcessEvents - WebTransport SessionClosed "
+ " sessionId=0x%" PRIx64,
+ id));
+ RefPtr<Http3StreamBase> stream = mStreamIdHash.Get(id);
+ if (!stream) {
+ LOG(
+ ("Http3Session::ProcessEvents - WebTransport SessionClosed - "
+ "stream not found "
+ "stream_id=0x%" PRIx64 " [this=%p].",
+ id, this));
+ break;
+ }
+
+ RefPtr<Http3WebTransportSession> wt =
+ stream->GetHttp3WebTransportSession();
+ MOZ_RELEASE_ASSERT(wt, "It must be a WebTransport session");
+
+ // TODO we do not handle the case when a WebTransport session stream
+ // is closed before headers are sent.
+ SessionCloseReasonExternal& reasonExternal =
+ event.web_transport._0.session_closed.reason;
+ uint32_t status = 0;
+ nsCString reason = ""_ns;
+ if (reasonExternal.tag == SessionCloseReasonExternal::Tag::Error) {
+ status = reasonExternal.error._0;
+ } else if (reasonExternal.tag ==
+ SessionCloseReasonExternal::Tag::Status) {
+ status = reasonExternal.status._0;
+ } else {
+ status = reasonExternal.clean._0;
+ reason.Assign(reinterpret_cast<const char*>(data.Elements()),
+ data.Length());
+ }
+ LOG(("reason.tag=%u err=%u data=%s\n",
+ static_cast<uint32_t>(reasonExternal.tag), status,
+ reason.get()));
+ wt->OnSessionClosed(status, reason);
+
+ } break;
+ case WebTransportEventExternal::Tag::NewStream: {
+ LOG(
+ ("Http3Session::ProcessEvents - WebTransport NewStream "
+ "streamId=0x%" PRIx64 " sessionId=0x%" PRIx64,
+ event.web_transport._0.new_stream.stream_id,
+ event.web_transport._0.new_stream.session_id));
+ uint64_t sessionId = event.web_transport._0.new_stream.session_id;
+ RefPtr<Http3StreamBase> stream = mStreamIdHash.Get(sessionId);
+ if (!stream) {
+ LOG(
+ ("Http3Session::ProcessEvents - WebTransport NewStream - "
+ "session not found "
+ "sessionId=0x%" PRIx64 " [this=%p].",
+ sessionId, this));
+ break;
+ }
+
+ RefPtr<Http3WebTransportSession> wt =
+ stream->GetHttp3WebTransportSession();
+ if (!wt) {
+ break;
+ }
+
+ RefPtr<Http3WebTransportStream> wtStream =
+ wt->OnIncomingWebTransportStream(
+ event.web_transport._0.new_stream.stream_type,
+ event.web_transport._0.new_stream.stream_id);
+ if (!wtStream) {
+ break;
+ }
+
+ // WebTransportStream is managed by Http3Session now.
+ mWebTransportStreams.AppendElement(wtStream);
+ mWebTransportStreamToSessionMap.InsertOrUpdate(wtStream->StreamId(),
+ wt->StreamId());
+ mStreamIdHash.InsertOrUpdate(wtStream->StreamId(),
+ std::move(wtStream));
+ } break;
+ case WebTransportEventExternal::Tag::Datagram:
+ LOG(
+ ("Http3Session::ProcessEvents - "
+ "WebTransportEventExternal::Tag::Datagram [this=%p]",
+ this));
+ uint64_t sessionId = event.web_transport._0.datagram.session_id;
+ RefPtr<Http3StreamBase> stream = mStreamIdHash.Get(sessionId);
+ if (!stream) {
+ LOG(
+ ("Http3Session::ProcessEvents - WebTransport Datagram - "
+ "session not found "
+ "sessionId=0x%" PRIx64 " [this=%p].",
+ sessionId, this));
+ break;
+ }
+
+ RefPtr<Http3WebTransportSession> wt =
+ stream->GetHttp3WebTransportSession();
+ if (!wt) {
+ break;
+ }
+
+ wt->OnDatagramReceived(std::move(data));
+ break;
+ }
+ } break;
+ default:
+ break;
+ }
+ // Delete previous content of data
+ data.TruncateLength(0);
+ rv = mHttp3Connection->GetEvent(&event, data);
+ if (NS_FAILED(rv)) {
+ LOG(("Http3Session::ProcessEvents [this=%p] rv=%" PRIx32, this,
+ static_cast<uint32_t>(rv)));
+ return rv;
+ }
+ }
+
+ return NS_OK;
+} // namespace net
+
+// This function may return a socket error.
+// It will not return an error if socket error is
+// NS_BASE_STREAM_WOULD_BLOCK.
+// A Caller of this function will close the Http3 connection
+// if this function returns an error.
+// Callers are:
+// 1) HttpConnectionUDP::OnQuicTimeoutExpired
+// 2) HttpConnectionUDP::SendData ->
+// Http3Session::SendData
+nsresult Http3Session::ProcessOutput(nsIUDPSocket* socket) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+ MOZ_ASSERT(mUdpConn);
+
+ LOG(("Http3Session::ProcessOutput reader=%p, [this=%p]", mUdpConn.get(),
+ this));
+
+ // Check if we have a packet that could not have been sent in a previous
+ // iteration or maybe get new packets to send.
+ while (true) {
+ nsTArray<uint8_t> packetToSend;
+ nsAutoCString remoteAddrStr;
+ uint16_t port = 0;
+ uint64_t timeout = 0;
+ if (!mHttp3Connection->ProcessOutput(&remoteAddrStr, &port, packetToSend,
+ &timeout)) {
+ SetupTimer(timeout);
+ break;
+ }
+ MOZ_ASSERT(packetToSend.Length());
+ LOG(
+ ("Http3Session::ProcessOutput sending packet with %u bytes to %s "
+ "port=%d [this=%p].",
+ (uint32_t)packetToSend.Length(),
+ PromiseFlatCString(remoteAddrStr).get(), port, this));
+
+ uint32_t written = 0;
+ NetAddr addr;
+ if (NS_FAILED(StringAndPortToNetAddr(remoteAddrStr, port, &addr))) {
+ continue;
+ }
+ nsresult rv = socket->SendWithAddress(&addr, packetToSend, &written);
+
+ LOG(("Http3Session::ProcessOutput sending packet rv=%d osError=%d",
+ static_cast<int32_t>(rv), NS_FAILED(rv) ? PR_GetOSError() : 0));
+ if (NS_FAILED(rv) && (rv != NS_BASE_STREAM_WOULD_BLOCK)) {
+ mSocketError = rv;
+ // If there was an error that is not NS_BASE_STREAM_WOULD_BLOCK
+ // return from here. We do not need to set a timer, because we
+ // will close the connection.
+ return rv;
+ }
+ mTotalBytesWritten += packetToSend.Length();
+ mLastWriteTime = PR_IntervalNow();
+ }
+
+ return NS_OK;
+}
+
+// This is only called when timer expires.
+// It is called by HttpConnectionUDP::OnQuicTimeout.
+// If tihs function returns an error OnQuicTimeout will handle the error
+// properly and close the connection.
+nsresult Http3Session::ProcessOutputAndEvents(nsIUDPSocket* socket) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+ // ProcessOutput could fire another timer. Need to unset the flag before that.
+ mTimerActive = false;
+
+ MOZ_ASSERT(mTimerShouldTrigger);
+
+ Telemetry::AccumulateTimeDelta(Telemetry::HTTP3_TIMER_DELAYED,
+ mTimerShouldTrigger, TimeStamp::Now());
+
+ mTimerShouldTrigger = TimeStamp();
+
+ nsresult rv = ProcessOutput(socket);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ return ProcessEvents();
+}
+
+void Http3Session::SetupTimer(uint64_t aTimeout) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+ // UINT64_MAX indicated a no-op from neqo, which only happens when a
+ // connection is in or going to be Closed state.
+ if (aTimeout == UINT64_MAX) {
+ return;
+ }
+
+ LOG(("Http3Session::SetupTimer to %" PRIu64 "ms [this=%p].", aTimeout, this));
+
+ // Remember the time when the timer should trigger.
+ mTimerShouldTrigger =
+ TimeStamp::Now() + TimeDuration::FromMilliseconds(aTimeout);
+
+ if (mTimerActive && mTimer) {
+ LOG(
+ (" -- Previous timer has not fired. Update the delay instead of "
+ "re-initializing the timer"));
+ mTimer->SetDelay(aTimeout);
+ return;
+ }
+
+ nsresult rv = NS_NewTimerWithCallback(
+ getter_AddRefs(mTimer),
+ [conn = RefPtr{mUdpConn}](nsITimer*) { conn->OnQuicTimeoutExpired(); },
+ aTimeout, nsITimer::TYPE_ONE_SHOT,
+ "net::HttpConnectionUDP::OnQuicTimeout");
+
+ mTimerActive = true;
+
+ if (NS_FAILED(rv)) {
+ NS_DispatchToCurrentThread(
+ NewRunnableMethod("net::HttpConnectionUDP::OnQuicTimeoutExpired",
+ mUdpConn, &HttpConnectionUDP::OnQuicTimeoutExpired));
+ }
+}
+
+bool Http3Session::AddStream(nsAHttpTransaction* aHttpTransaction,
+ int32_t aPriority,
+ nsIInterfaceRequestor* aCallbacks) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+
+ nsHttpTransaction* trans = aHttpTransaction->QueryHttpTransaction();
+
+ if (!mConnection) {
+ // Get the connection from the first transaction.
+ mConnection = aHttpTransaction->Connection();
+ }
+
+ if (IsClosing()) {
+ LOG3(
+ ("Http3Session::AddStream %p atrans=%p trans=%p session unusable - "
+ "resched.\n",
+ this, aHttpTransaction, trans));
+ aHttpTransaction->SetConnection(nullptr);
+ nsresult rv = gHttpHandler->InitiateTransaction(trans, trans->Priority());
+ if (NS_FAILED(rv)) {
+ LOG3(
+ ("Http3Session::AddStream %p atrans=%p trans=%p failed to initiate "
+ "transaction (0x%" PRIx32 ").\n",
+ this, aHttpTransaction, trans, static_cast<uint32_t>(rv)));
+ }
+ return true;
+ }
+
+ aHttpTransaction->SetConnection(this);
+ aHttpTransaction->OnActivated();
+ // reset the read timers to wash away any idle time
+ mLastWriteTime = PR_IntervalNow();
+
+ ClassOfService cos;
+ if (trans) {
+ cos = trans->GetClassOfService();
+ }
+
+ Http3StreamBase* stream = nullptr;
+
+ if (trans && trans->IsForWebTransport()) {
+ LOG3(("Http3Session::AddStream new WeTransport session %p atrans=%p.\n",
+ this, aHttpTransaction));
+ stream = new Http3WebTransportSession(aHttpTransaction, this);
+ mHasWebTransportSession = true;
+ } else {
+ LOG3(("Http3Session::AddStream %p atrans=%p.\n", this, aHttpTransaction));
+ stream = new Http3Stream(aHttpTransaction, this, cos, mCurrentBrowserId);
+ }
+
+ mStreamTransactionHash.InsertOrUpdate(aHttpTransaction, RefPtr{stream});
+
+ if (mState == ZERORTT) {
+ if (!stream->Do0RTT()) {
+ LOG(("Http3Session %p will not get early data from Http3Stream %p", this,
+ stream));
+ if (!mCannotDo0RTTStreams.Contains(stream)) {
+ mCannotDo0RTTStreams.AppendElement(stream);
+ }
+ if ((mWebTransportNegotiationStatus ==
+ WebTransportNegotiation::NEGOTIATING) &&
+ (trans && trans->IsForWebTransport())) {
+ LOG(("waiting for negotiation"));
+ mWaitingForWebTransportNegotiation.AppendElement(stream);
+ }
+ return true;
+ }
+ m0RTTStreams.AppendElement(stream);
+ }
+
+ if ((mWebTransportNegotiationStatus ==
+ WebTransportNegotiation::NEGOTIATING) &&
+ (trans && trans->IsForWebTransport())) {
+ LOG(("waiting for negotiation"));
+ mWaitingForWebTransportNegotiation.AppendElement(stream);
+ return true;
+ }
+
+ if (!mFirstHttpTransaction && !IsConnected()) {
+ mFirstHttpTransaction = aHttpTransaction->QueryHttpTransaction();
+ LOG3(("Http3Session::AddStream first session=%p trans=%p ", this,
+ mFirstHttpTransaction.get()));
+ }
+ StreamReadyToWrite(stream);
+
+ return true;
+}
+
+bool Http3Session::CanReuse() {
+ // TODO: we assume "pooling" is disabled here, so we don't allow this session
+ // to be reused. "pooling" will be implemented in bug 1815735.
+ return CanSandData() && !(mGoawayReceived || mShouldClose) &&
+ !mHasWebTransportSession;
+}
+
+void Http3Session::QueueStream(Http3StreamBase* stream) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+ MOZ_ASSERT(!stream->Queued());
+
+ LOG3(("Http3Session::QueueStream %p stream %p queued.", this, stream));
+
+ stream->SetQueued(true);
+ mQueuedStreams.Push(stream);
+}
+
+void Http3Session::ProcessPending() {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+
+ RefPtr<Http3StreamBase> stream;
+ while ((stream = mQueuedStreams.PopFront())) {
+ LOG3(("Http3Session::ProcessPending %p stream %p woken from queue.", this,
+ stream.get()));
+ MOZ_ASSERT(stream->Queued());
+ stream->SetQueued(false);
+ mReadyForWrite.Push(stream);
+ }
+ MaybeResumeSend();
+}
+
+static void RemoveStreamFromQueue(Http3StreamBase* aStream,
+ nsRefPtrDeque<Http3StreamBase>& queue) {
+ size_t size = queue.GetSize();
+ for (size_t count = 0; count < size; ++count) {
+ RefPtr<Http3StreamBase> stream = queue.PopFront();
+ if (stream != aStream) {
+ queue.Push(stream);
+ }
+ }
+}
+
+void Http3Session::RemoveStreamFromQueues(Http3StreamBase* aStream) {
+ RemoveStreamFromQueue(aStream, mReadyForWrite);
+ RemoveStreamFromQueue(aStream, mQueuedStreams);
+ mSlowConsumersReadyForRead.RemoveElement(aStream);
+}
+
+// This is called by Http3Stream::OnReadSegment.
+// ProcessOutput will be called in Http3Session::ReadSegment that
+// calls Http3Stream::OnReadSegment.
+nsresult Http3Session::TryActivating(
+ const nsACString& aMethod, const nsACString& aScheme,
+ const nsACString& aAuthorityHeader, const nsACString& aPath,
+ const nsACString& aHeaders, uint64_t* aStreamId, Http3StreamBase* aStream) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+ MOZ_ASSERT(*aStreamId == UINT64_MAX);
+
+ LOG(("Http3Session::TryActivating [stream=%p, this=%p state=%d]", aStream,
+ this, mState));
+
+ if (IsClosing()) {
+ if (NS_FAILED(mError)) {
+ return mError;
+ }
+ return NS_ERROR_FAILURE;
+ }
+
+ if (aStream->Queued()) {
+ LOG3(("Http3Session::TryActivating %p stream=%p already queued.\n", this,
+ aStream));
+ return NS_BASE_STREAM_WOULD_BLOCK;
+ }
+
+ if (mState == ZERORTT) {
+ if (!aStream->Do0RTT()) {
+ MOZ_ASSERT(!mCannotDo0RTTStreams.Contains(aStream));
+ return NS_BASE_STREAM_WOULD_BLOCK;
+ }
+ }
+
+ nsresult rv = NS_OK;
+ RefPtr<Http3Stream> httpStream = aStream->GetHttp3Stream();
+ if (httpStream) {
+ rv = mHttp3Connection->Fetch(
+ aMethod, aScheme, aAuthorityHeader, aPath, aHeaders, aStreamId,
+ httpStream->PriorityUrgency(), httpStream->PriorityIncremental());
+ } else {
+ MOZ_RELEASE_ASSERT(aStream->GetHttp3WebTransportSession(),
+ "It must be a WebTransport session");
+ // Don't call CreateWebTransport if we are still waiting for the negotiation
+ // result.
+ if (mWebTransportNegotiationStatus ==
+ WebTransportNegotiation::NEGOTIATING) {
+ if (!mWaitingForWebTransportNegotiation.Contains(aStream)) {
+ mWaitingForWebTransportNegotiation.AppendElement(aStream);
+ }
+ return NS_BASE_STREAM_WOULD_BLOCK;
+ }
+ rv = mHttp3Connection->CreateWebTransport(aAuthorityHeader, aPath, aHeaders,
+ aStreamId);
+ }
+
+ if (NS_FAILED(rv)) {
+ LOG(("Http3Session::TryActivating returns error=0x%" PRIx32 "[stream=%p, "
+ "this=%p]",
+ static_cast<uint32_t>(rv), aStream, this));
+ if (rv == NS_BASE_STREAM_WOULD_BLOCK) {
+ LOG3(
+ ("Http3Session::TryActivating %p stream=%p no room for more "
+ "concurrent streams\n",
+ this, aStream));
+ mTransactionsBlockedByStreamLimitCount++;
+ if (mQueuedStreams.GetSize() == 0) {
+ mBlockedByStreamLimitCount++;
+ }
+ QueueStream(aStream);
+ return rv;
+ }
+ // Ignore this error. This may happen if some events are not handled yet.
+ // TODO we may try to add an assertion here.
+ return NS_OK;
+ }
+
+ LOG(("Http3Session::TryActivating streamId=0x%" PRIx64
+ " for stream=%p [this=%p].",
+ *aStreamId, aStream, this));
+
+ MOZ_ASSERT(*aStreamId != UINT64_MAX);
+
+ if (mTransactionCount > 0 && mStreamIdHash.IsEmpty()) {
+ MOZ_ASSERT(mConnectionIdleStart);
+ MOZ_ASSERT(mFirstStreamIdReuseIdleConnection.isNothing());
+
+ mConnectionIdleEnd = TimeStamp::Now();
+ mFirstStreamIdReuseIdleConnection = Some(*aStreamId);
+ }
+ mStreamIdHash.InsertOrUpdate(*aStreamId, RefPtr{aStream});
+ mTransactionCount++;
+
+ return NS_OK;
+}
+
+// This is called by Http3WebTransportStream::OnReadSegment.
+// TODO: this function is almost the same as TryActivating().
+// We should try to reduce the duplicate code.
+nsresult Http3Session::TryActivatingWebTransportStream(
+ uint64_t* aStreamId, Http3StreamBase* aStream) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+ MOZ_ASSERT(*aStreamId == UINT64_MAX);
+
+ LOG(
+ ("Http3Session::TryActivatingWebTransportStream [stream=%p, this=%p "
+ "state=%d]",
+ aStream, this, mState));
+
+ if (IsClosing()) {
+ if (NS_FAILED(mError)) {
+ return mError;
+ }
+ return NS_ERROR_FAILURE;
+ }
+
+ if (aStream->Queued()) {
+ LOG3(
+ ("Http3Session::TryActivatingWebTransportStream %p stream=%p already "
+ "queued.\n",
+ this, aStream));
+ return NS_BASE_STREAM_WOULD_BLOCK;
+ }
+
+ nsresult rv = NS_OK;
+ RefPtr<Http3WebTransportStream> wtStream =
+ aStream->GetHttp3WebTransportStream();
+ MOZ_RELEASE_ASSERT(wtStream, "It must be a WebTransport stream");
+ rv = mHttp3Connection->CreateWebTransportStream(
+ wtStream->SessionId(), wtStream->StreamType(), aStreamId);
+
+ if (NS_FAILED(rv)) {
+ LOG((
+ "Http3Session::TryActivatingWebTransportStream returns error=0x%" PRIx32
+ "[stream=%p, "
+ "this=%p]",
+ static_cast<uint32_t>(rv), aStream, this));
+ if (rv == NS_BASE_STREAM_WOULD_BLOCK) {
+ LOG3(
+ ("Http3Session::TryActivatingWebTransportStream %p stream=%p no room "
+ "for more "
+ "concurrent streams\n",
+ this, aStream));
+ QueueStream(aStream);
+ return rv;
+ }
+
+ return rv;
+ }
+
+ LOG(("Http3Session::TryActivatingWebTransportStream streamId=0x%" PRIx64
+ " for stream=%p [this=%p].",
+ *aStreamId, aStream, this));
+
+ MOZ_ASSERT(*aStreamId != UINT64_MAX);
+
+ RefPtr<Http3StreamBase> session = mStreamIdHash.Get(wtStream->SessionId());
+ MOZ_ASSERT(session);
+ Http3WebTransportSession* wtSession = session->GetHttp3WebTransportSession();
+ MOZ_ASSERT(wtSession);
+
+ wtSession->RemoveWebTransportStream(wtStream);
+
+ // WebTransportStream is managed by Http3Session now.
+ mWebTransportStreams.AppendElement(wtStream);
+ mWebTransportStreamToSessionMap.InsertOrUpdate(*aStreamId,
+ session->StreamId());
+ mStreamIdHash.InsertOrUpdate(*aStreamId, std::move(wtStream));
+ return NS_OK;
+}
+
+// This is only called by Http3Stream::OnReadSegment.
+// ProcessOutput will be called in Http3Session::ReadSegment that
+// calls Http3Stream::OnReadSegment.
+void Http3Session::CloseSendingSide(uint64_t aStreamId) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+ mHttp3Connection->CloseStream(aStreamId);
+}
+
+// This is only called by Http3Stream::OnReadSegment.
+// ProcessOutput will be called in Http3Session::ReadSegment that
+// calls Http3Stream::OnReadSegment.
+nsresult Http3Session::SendRequestBody(uint64_t aStreamId, const char* buf,
+ uint32_t count, uint32_t* countRead) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+ nsresult rv = mHttp3Connection->SendRequestBody(
+ aStreamId, (const uint8_t*)buf, count, countRead);
+ if (rv == NS_BASE_STREAM_WOULD_BLOCK) {
+ mTransactionsSenderBlockedByFlowControlCount++;
+ } else if (NS_FAILED(rv)) {
+ // Ignore this error. This may happen if some events are not handled yet.
+ // TODO we may try to add an assertion here.
+ // We will pretend that sender is blocked, that will cause the caller to
+ // stop trying.
+ *countRead = 0;
+ rv = NS_BASE_STREAM_WOULD_BLOCK;
+ }
+
+ MOZ_ASSERT((*countRead != 0) || NS_FAILED(rv));
+ return rv;
+}
+
+void Http3Session::ResetOrStopSendingRecvd(uint64_t aStreamId, uint64_t aError,
+ ResetType aType) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+
+ uint64_t sessionId = 0;
+ if (mWebTransportStreamToSessionMap.Get(aStreamId, &sessionId)) {
+ uint8_t wtError = Http3ErrorToWebTransportError(aError);
+ nsresult rv = GetNSResultFromWebTransportError(wtError);
+
+ RefPtr<Http3StreamBase> stream = mStreamIdHash.Get(aStreamId);
+ if (stream) {
+ if (aType == RESET) {
+ stream->SetRecvdReset();
+ }
+ RefPtr<Http3WebTransportStream> wtStream =
+ stream->GetHttp3WebTransportStream();
+ if (wtStream) {
+ CloseWebTransportStream(wtStream, rv);
+ }
+ }
+
+ RefPtr<Http3StreamBase> session = mStreamIdHash.Get(sessionId);
+ if (session) {
+ Http3WebTransportSession* wtSession =
+ session->GetHttp3WebTransportSession();
+ MOZ_ASSERT(wtSession);
+ if (wtSession) {
+ if (aType == RESET) {
+ wtSession->OnStreamReset(aStreamId, rv);
+ } else {
+ wtSession->OnStreamStopSending(aStreamId, rv);
+ }
+ }
+ }
+ return;
+ }
+
+ RefPtr<Http3StreamBase> stream = mStreamIdHash.Get(aStreamId);
+ if (!stream) {
+ return;
+ }
+
+ RefPtr<Http3Stream> httpStream = stream->GetHttp3Stream();
+ if (!httpStream) {
+ return;
+ }
+
+ // We only handle some of Http3 error as epecial, the rest are just equivalent
+ // to cancel.
+ if (aError == HTTP3_APP_ERROR_VERSION_FALLBACK) {
+ // We will restart the request and the alt-svc will be removed
+ // automatically.
+ // Also disable http3 we want http1.1.
+ httpStream->Transaction()->DisableHttp3(false);
+ httpStream->Transaction()->DisableSpdy();
+ CloseStream(stream, NS_ERROR_NET_RESET);
+ } else if (aError == HTTP3_APP_ERROR_REQUEST_REJECTED) {
+ // This request was rejected because server is probably busy or going away.
+ // We can restart the request using alt-svc. Without calling
+ // DoNotRemoveAltSvc the alt-svc route will be removed.
+ httpStream->Transaction()->DoNotRemoveAltSvc();
+ CloseStream(stream, NS_ERROR_NET_RESET);
+ } else {
+ if (httpStream->RecvdData()) {
+ CloseStream(stream, NS_ERROR_NET_PARTIAL_TRANSFER);
+ } else {
+ CloseStream(stream, NS_ERROR_NET_INTERRUPT);
+ }
+ }
+}
+
+void Http3Session::SetConnection(nsAHttpConnection* aConn) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+ mConnection = aConn;
+}
+
+void Http3Session::GetSecurityCallbacks(nsIInterfaceRequestor** aOut) {
+ *aOut = nullptr;
+}
+
+// TODO
+void Http3Session::OnTransportStatus(nsITransport* aTransport, nsresult aStatus,
+ int64_t aProgress) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+
+ if ((aStatus == NS_NET_STATUS_CONNECTED_TO) && !IsConnected()) {
+ // We should ignore the event. This is sent by the nsSocketTranpsort
+ // and it does not mean that HTTP3 session is connected.
+ // We will use this event to mark start of TLS handshake
+ aStatus = NS_NET_STATUS_TLS_HANDSHAKE_STARTING;
+ }
+
+ switch (aStatus) {
+ // These should appear only once, deliver to the first
+ // transaction on the session.
+ case NS_NET_STATUS_RESOLVING_HOST:
+ case NS_NET_STATUS_RESOLVED_HOST:
+ case NS_NET_STATUS_CONNECTING_TO:
+ case NS_NET_STATUS_CONNECTED_TO:
+ case NS_NET_STATUS_TLS_HANDSHAKE_STARTING:
+ case NS_NET_STATUS_TLS_HANDSHAKE_ENDED: {
+ if (!mFirstHttpTransaction) {
+ // if we still do not have a HttpTransaction store timings info in
+ // a HttpConnection.
+ // If some error occur it can happen that we do not have a connection.
+ if (mConnection) {
+ RefPtr<HttpConnectionBase> conn = mConnection->HttpConnection();
+ conn->SetEvent(aStatus);
+ }
+ } else {
+ mFirstHttpTransaction->OnTransportStatus(aTransport, aStatus,
+ aProgress);
+ }
+
+ if (aStatus == NS_NET_STATUS_CONNECTED_TO) {
+ mFirstHttpTransaction = nullptr;
+ }
+ break;
+ }
+
+ default:
+ // The other transport events are ignored here because there is no good
+ // way to map them to the right transaction in HTTP3. Instead, the events
+ // are generated again from the HTTP3 code and passed directly to the
+ // correct transaction.
+
+ // NS_NET_STATUS_SENDING_TO:
+ // This is generated by the socket transport when (part) of
+ // a transaction is written out
+ //
+ // There is no good way to map it to the right transaction in HTTP3,
+ // so it is ignored here and generated separately when the request
+ // is sent from Http3Stream.
+
+ // NS_NET_STATUS_WAITING_FOR:
+ // Created by nsHttpConnection when the request has been totally sent.
+ // There is no good way to map it to the right transaction in HTTP3,
+ // so it is ignored here and generated separately when the same
+ // condition is complete in Http3Stream when there is no more
+ // request body left to be transmitted.
+
+ // NS_NET_STATUS_RECEIVING_FROM
+ // Generated in Http3Stream whenever the stream reads data.
+
+ break;
+ }
+}
+
+bool Http3Session::IsDone() { return mState == CLOSED; }
+
+nsresult Http3Session::Status() {
+ MOZ_ASSERT(false, "Http3Session::Status()");
+ return NS_ERROR_UNEXPECTED;
+}
+
+uint32_t Http3Session::Caps() {
+ MOZ_ASSERT(false, "Http3Session::Caps()");
+ return 0;
+}
+
+nsresult Http3Session::ReadSegments(nsAHttpSegmentReader* reader,
+ uint32_t count, uint32_t* countRead) {
+ MOZ_ASSERT(false, "Http3Session::ReadSegments()");
+ return NS_ERROR_UNEXPECTED;
+}
+
+nsresult Http3Session::SendData(nsIUDPSocket* socket) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+
+ LOG(("Http3Session::SendData [this=%p]", this));
+
+ // 1) go through all streams/transactions that are ready to write and
+ // write their data into quic streams (no network write yet).
+ // 2) call ProcessOutput that will loop until all available packets are
+ // written to a socket or the socket returns an error code.
+ // 3) if we still have streams ready to write call ResumeSend()(we may
+ // still have such streams because on an stream error we return earlier
+ // to let the error be handled).
+
+ nsresult rv = NS_OK;
+ RefPtr<Http3StreamBase> stream;
+
+ // Step 1)
+ while (CanSandData() && (stream = mReadyForWrite.PopFront())) {
+ LOG(("Http3Session::SendData call ReadSegments from stream=%p [this=%p]",
+ stream.get(), this));
+
+ rv = stream->ReadSegments();
+
+ // on stream error we return earlier to let the error be handled.
+ if (NS_FAILED(rv)) {
+ LOG3(("Http3Session::SendData %p returns error code 0x%" PRIx32, this,
+ static_cast<uint32_t>(rv)));
+ MOZ_ASSERT(rv != NS_BASE_STREAM_WOULD_BLOCK);
+ if (rv == NS_BASE_STREAM_WOULD_BLOCK) { // Just in case!
+ rv = NS_OK;
+ } else if (ASpdySession::SoftStreamError(rv)) {
+ CloseStream(stream, rv);
+ LOG3(("Http3Session::SendData %p soft error override\n", this));
+ rv = NS_OK;
+ } else {
+ break;
+ }
+ }
+ }
+
+ if (NS_SUCCEEDED(rv)) {
+ // Step 2:
+ // Call actuall network write.
+ rv = ProcessOutput(socket);
+ }
+
+ // Step 3:
+ MaybeResumeSend();
+
+ if (rv == NS_BASE_STREAM_WOULD_BLOCK) {
+ rv = NS_OK;
+ }
+
+ return rv;
+}
+
+void Http3Session::StreamReadyToWrite(Http3StreamBase* aStream) {
+ MOZ_ASSERT(aStream);
+ mReadyForWrite.Push(aStream);
+ if (CanSandData() && mConnection) {
+ Unused << mConnection->ResumeSend();
+ }
+}
+
+void Http3Session::MaybeResumeSend() {
+ if ((mReadyForWrite.GetSize() > 0) && CanSandData() && mConnection) {
+ Unused << mConnection->ResumeSend();
+ }
+}
+
+nsresult Http3Session::ProcessSlowConsumers() {
+ if (mSlowConsumersReadyForRead.IsEmpty()) {
+ return NS_OK;
+ }
+
+ RefPtr<Http3StreamBase> slowConsumer =
+ mSlowConsumersReadyForRead.ElementAt(0);
+ mSlowConsumersReadyForRead.RemoveElementAt(0);
+
+ nsresult rv = ProcessTransactionRead(slowConsumer);
+
+ return rv;
+}
+
+nsresult Http3Session::WriteSegments(nsAHttpSegmentWriter* writer,
+ uint32_t count, uint32_t* countWritten) {
+ MOZ_ASSERT(false, "Http3Session::WriteSegments()");
+ return NS_ERROR_UNEXPECTED;
+}
+
+nsresult Http3Session::RecvData(nsIUDPSocket* socket) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+
+ // Process slow consumers.
+ nsresult rv = ProcessSlowConsumers();
+ if (NS_FAILED(rv)) {
+ LOG3(("Http3Session %p ProcessSlowConsumers returns 0x%" PRIx32 "\n", this,
+ static_cast<uint32_t>(rv)));
+ return rv;
+ }
+
+ ProcessInput(socket);
+
+ rv = ProcessEvents();
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ rv = ProcessOutput(socket);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ return NS_OK;
+}
+
+const uint32_t HTTP3_TELEMETRY_APP_NECKO = 42;
+
+void Http3Session::Close(nsresult aReason) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+
+ LOG(("Http3Session::Close [this=%p]", this));
+
+ if (NS_FAILED(mError)) {
+ CloseInternal(false);
+ } else {
+ mError = aReason;
+ // If necko closes connection, this will map to the "closing" key and the
+ // value HTTP3_TELEMETRY_APP_NECKO.
+ Telemetry::Accumulate(Telemetry::HTTP3_CONNECTION_CLOSE_CODE_3,
+ "app_closing"_ns, HTTP3_TELEMETRY_APP_NECKO);
+ CloseInternal(true);
+ }
+
+ if (mCleanShutdown || mIsClosedByNeqo || NS_FAILED(mSocketError)) {
+ // It is network-tear-down, a socker error or neqo is state CLOSED
+ // (it does not need to send any more packets or wait for new packets).
+ // We need to remove all references, so that
+ // Http3Session will be destroyed.
+ if (mTimer) {
+ mTimer->Cancel();
+ }
+ mTimer = nullptr;
+ mConnection = nullptr;
+ mUdpConn = nullptr;
+ mState = CLOSED;
+ }
+ if (mConnection) {
+ // resume sending to send CLOSE_CONNECTION frame.
+ Unused << mConnection->ResumeSend();
+ }
+}
+
+void Http3Session::CloseInternal(bool aCallNeqoClose) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+
+ if (IsClosing()) {
+ return;
+ }
+
+ LOG(("Http3Session::Closing [this=%p]", this));
+
+ if (mState != CONNECTED) {
+ mBeforeConnectedError = true;
+ }
+
+ if (mState == ZERORTT) {
+ ZeroRttTelemetry(aCallNeqoClose ? ZeroRttOutcome::USED_CONN_CLOSED_BY_NECKO
+ : ZeroRttOutcome::USED_CONN_ERROR);
+ }
+
+ mState = CLOSING;
+ Shutdown();
+
+ if (aCallNeqoClose) {
+ mHttp3Connection->Close(HTTP3_APP_ERROR_NO_ERROR);
+ }
+
+ mStreamIdHash.Clear();
+ mStreamTransactionHash.Clear();
+}
+
+nsHttpConnectionInfo* Http3Session::ConnectionInfo() {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+ RefPtr<nsHttpConnectionInfo> ci;
+ GetConnectionInfo(getter_AddRefs(ci));
+ return ci.get();
+}
+
+void Http3Session::SetProxyConnectFailed() {
+ MOZ_ASSERT(false, "Http3Session::SetProxyConnectFailed()");
+}
+
+nsHttpRequestHead* Http3Session::RequestHead() {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+ MOZ_ASSERT(false,
+ "Http3Session::RequestHead() "
+ "should not be called after http/3 is setup");
+ return nullptr;
+}
+
+uint32_t Http3Session::Http1xTransactionCount() { return 0; }
+
+nsresult Http3Session::TakeSubTransactions(
+ nsTArray<RefPtr<nsAHttpTransaction>>& outTransactions) {
+ return NS_OK;
+}
+
+//-----------------------------------------------------------------------------
+// Pass through methods of nsAHttpConnection
+//-----------------------------------------------------------------------------
+
+nsAHttpConnection* Http3Session::Connection() {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+ return mConnection;
+}
+
+nsresult Http3Session::OnHeadersAvailable(nsAHttpTransaction* transaction,
+ nsHttpRequestHead* requestHead,
+ nsHttpResponseHead* responseHead,
+ bool* reset) {
+ MOZ_ASSERT(mConnection);
+ if (mConnection) {
+ return mConnection->OnHeadersAvailable(transaction, requestHead,
+ responseHead, reset);
+ }
+ return NS_OK;
+}
+
+bool Http3Session::IsReused() {
+ if (mConnection) {
+ return mConnection->IsReused();
+ }
+ return true;
+}
+
+nsresult Http3Session::PushBack(const char* buf, uint32_t len) {
+ return NS_ERROR_UNEXPECTED;
+}
+
+already_AddRefed<HttpConnectionBase> Http3Session::TakeHttpConnection() {
+ MOZ_ASSERT(false, "TakeHttpConnection of Http3Session");
+ return nullptr;
+}
+
+already_AddRefed<HttpConnectionBase> Http3Session::HttpConnection() {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+ if (mConnection) {
+ return mConnection->HttpConnection();
+ }
+ return nullptr;
+}
+
+void Http3Session::CloseTransaction(nsAHttpTransaction* aTransaction,
+ nsresult aResult) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+ LOG3(("Http3Session::CloseTransaction %p %p 0x%" PRIx32, this, aTransaction,
+ static_cast<uint32_t>(aResult)));
+
+ // Generally this arrives as a cancel event from the connection manager.
+
+ // need to find the stream and call CloseStream() on it.
+ RefPtr<Http3StreamBase> stream = mStreamTransactionHash.Get(aTransaction);
+ if (!stream) {
+ LOG3(("Http3Session::CloseTransaction %p %p 0x%" PRIx32 " - not found.",
+ this, aTransaction, static_cast<uint32_t>(aResult)));
+ return;
+ }
+ LOG3(
+ ("Http3Session::CloseTransaction probably a cancel. this=%p, "
+ "trans=%p, result=0x%" PRIx32 ", streamId=0x%" PRIx64 " stream=%p",
+ this, aTransaction, static_cast<uint32_t>(aResult), stream->StreamId(),
+ stream.get()));
+ CloseStream(stream, aResult);
+ if (mConnection) {
+ Unused << mConnection->ResumeSend();
+ }
+}
+
+void Http3Session::CloseStream(Http3StreamBase* aStream, nsresult aResult) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+ RefPtr<Http3WebTransportStream> wtStream =
+ aStream->GetHttp3WebTransportStream();
+ if (wtStream) {
+ CloseWebTransportStream(wtStream, aResult);
+ return;
+ }
+
+ RefPtr<Http3Stream> httpStream = aStream->GetHttp3Stream();
+ if (httpStream && !httpStream->RecvdFin() && !httpStream->RecvdReset() &&
+ httpStream->HasStreamId()) {
+ mHttp3Connection->CancelFetch(httpStream->StreamId(),
+ HTTP3_APP_ERROR_REQUEST_CANCELLED);
+ }
+
+ aStream->Close(aResult);
+ CloseStreamInternal(aStream, aResult);
+}
+
+void Http3Session::CloseStreamInternal(Http3StreamBase* aStream,
+ nsresult aResult) {
+ LOG3(("Http3Session::CloseStreamInternal %p %p 0x%" PRIx32, this, aStream,
+ static_cast<uint32_t>(aResult)));
+ if (aStream->HasStreamId()) {
+ // We know the transaction reusing an idle connection has succeeded or
+ // failed.
+ if (mFirstStreamIdReuseIdleConnection.isSome() &&
+ aStream->StreamId() == *mFirstStreamIdReuseIdleConnection) {
+ MOZ_ASSERT(mConnectionIdleStart);
+ MOZ_ASSERT(mConnectionIdleEnd);
+
+ if (mConnectionIdleStart) {
+ Telemetry::AccumulateTimeDelta(
+ Telemetry::HTTP3_TIME_TO_REUSE_IDLE_CONNECTTION_MS,
+ NS_SUCCEEDED(aResult) ? "succeeded"_ns : "failed"_ns,
+ mConnectionIdleStart, mConnectionIdleEnd);
+ }
+
+ mConnectionIdleStart = TimeStamp();
+ mConnectionIdleEnd = TimeStamp();
+ mFirstStreamIdReuseIdleConnection.reset();
+ }
+
+ mStreamIdHash.Remove(aStream->StreamId());
+
+ // Start to idle when we remove the last stream.
+ if (mStreamIdHash.IsEmpty()) {
+ mConnectionIdleStart = TimeStamp::Now();
+ }
+ }
+ RemoveStreamFromQueues(aStream);
+ if (nsAHttpTransaction* transaction = aStream->Transaction()) {
+ mStreamTransactionHash.Remove(transaction);
+ }
+ mWebTransportSessions.RemoveElement(aStream);
+ mWebTransportStreams.RemoveElement(aStream);
+ // Close(NS_OK) implies that the NeqoHttp3Conn will be closed, so we can only
+ // do this when there is no Http3Steeam, WebTransportSession and
+ // WebTransportStream.
+ if ((mShouldClose || mGoawayReceived) &&
+ (!mStreamTransactionHash.Count() && mWebTransportSessions.IsEmpty() &&
+ mWebTransportStreams.IsEmpty())) {
+ MOZ_ASSERT(!IsClosing());
+ Close(NS_OK);
+ }
+}
+
+void Http3Session::CloseWebTransportStream(Http3WebTransportStream* aStream,
+ nsresult aResult) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+ LOG3(("Http3Session::CloseWebTransportStream %p %p 0x%" PRIx32, this, aStream,
+ static_cast<uint32_t>(aResult)));
+ if (aStream && !aStream->RecvdFin() && !aStream->RecvdReset() &&
+ (aStream->HasStreamId())) {
+ mHttp3Connection->ResetStream(aStream->StreamId(),
+ HTTP3_APP_ERROR_REQUEST_CANCELLED);
+ }
+
+ aStream->Close(aResult);
+ CloseStreamInternal(aStream, aResult);
+}
+
+void Http3Session::ResetWebTransportStream(Http3WebTransportStream* aStream,
+ uint64_t aErrorCode) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+ LOG3(("Http3Session::ResetWebTransportStream %p %p 0x%" PRIx64, this, aStream,
+ aErrorCode));
+ mHttp3Connection->ResetStream(aStream->StreamId(), aErrorCode);
+}
+
+void Http3Session::StreamStopSending(Http3WebTransportStream* aStream,
+ uint8_t aErrorCode) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+ LOG(("Http3Session::StreamStopSending %p %p 0x%" PRIx32, this, aStream,
+ static_cast<uint32_t>(aErrorCode)));
+ mHttp3Connection->StreamStopSending(aStream->StreamId(), aErrorCode);
+}
+
+nsresult Http3Session::TakeTransport(nsISocketTransport**,
+ nsIAsyncInputStream**,
+ nsIAsyncOutputStream**) {
+ MOZ_ASSERT(false, "TakeTransport of Http3Session");
+ return NS_ERROR_UNEXPECTED;
+}
+
+Http3WebTransportSession* Http3Session::GetWebTransportSession(
+ nsAHttpTransaction* aTransaction) {
+ RefPtr<Http3StreamBase> stream = mStreamTransactionHash.Get(aTransaction);
+
+ if (!stream || !stream->GetHttp3WebTransportSession()) {
+ MOZ_ASSERT(false, "There must be a stream");
+ return nullptr;
+ }
+ RemoveStreamFromQueues(stream);
+ mStreamTransactionHash.Remove(aTransaction);
+ mWebTransportSessions.AppendElement(stream);
+ return stream->GetHttp3WebTransportSession();
+}
+
+bool Http3Session::IsPersistent() { return true; }
+
+void Http3Session::DontReuse() {
+ LOG3(("Http3Session::DontReuse %p\n", this));
+ if (!OnSocketThread()) {
+ LOG3(("Http3Session %p not on socket thread\n", this));
+ nsCOMPtr<nsIRunnable> event = NewRunnableMethod(
+ "Http3Session::DontReuse", this, &Http3Session::DontReuse);
+ gSocketTransportService->Dispatch(event, NS_DISPATCH_NORMAL);
+ return;
+ }
+
+ if (mGoawayReceived || IsClosing()) {
+ return;
+ }
+
+ mShouldClose = true;
+ if (!mStreamTransactionHash.Count()) {
+ Close(NS_OK);
+ }
+}
+
+void Http3Session::CloseWebTransportConn() {
+ LOG3(("Http3Session::CloseWebTransportConn %p\n", this));
+ // We need to dispatch, since Http3Session could be released in
+ // HttpConnectionUDP::CloseTransaction.
+ gSocketTransportService->Dispatch(
+ NS_NewRunnableFunction("Http3Session::CloseWebTransportConn",
+ [self = RefPtr{this}]() {
+ if (self->mUdpConn) {
+ self->mUdpConn->CloseTransaction(
+ self, NS_ERROR_ABORT);
+ }
+ }),
+ NS_DISPATCH_NORMAL);
+}
+
+void Http3Session::CurrentBrowserIdChanged(uint64_t id) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+
+ mCurrentBrowserId = id;
+
+ for (const auto& stream : mStreamTransactionHash.Values()) {
+ RefPtr<Http3Stream> httpStream = stream->GetHttp3Stream();
+ if (httpStream) {
+ httpStream->CurrentBrowserIdChanged(id);
+ }
+ }
+}
+
+// This is called by Http3Stream::OnWriteSegment.
+nsresult Http3Session::ReadResponseData(uint64_t aStreamId, char* aBuf,
+ uint32_t aCount,
+ uint32_t* aCountWritten, bool* aFin) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+
+ nsresult rv = mHttp3Connection->ReadResponseData(aStreamId, (uint8_t*)aBuf,
+ aCount, aCountWritten, aFin);
+
+ // This should not happen, i.e. stream must be present in neqo and in necko at
+ // the same time.
+ MOZ_ASSERT(rv != NS_ERROR_INVALID_ARG);
+ if (NS_FAILED(rv)) {
+ LOG3(("Http3Session::ReadResponseData return an error %" PRIx32
+ " [this=%p]",
+ static_cast<uint32_t>(rv), this));
+ // This error will be handled by neqo and the whole connection will be
+ // closed. We will return NS_BASE_STREAM_WOULD_BLOCK here.
+ *aCountWritten = 0;
+ *aFin = false;
+ rv = NS_BASE_STREAM_WOULD_BLOCK;
+ }
+
+ MOZ_ASSERT((*aCountWritten != 0) || aFin || NS_FAILED(rv));
+ return rv;
+}
+
+void Http3Session::TransactionHasDataToWrite(nsAHttpTransaction* caller) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+ LOG3(("Http3Session::TransactionHasDataToWrite %p trans=%p", this, caller));
+
+ // a trapped signal from the http transaction to the connection that
+ // it is no longer blocked on read.
+
+ RefPtr<Http3StreamBase> stream = mStreamTransactionHash.Get(caller);
+ if (!stream) {
+ LOG3(("Http3Session::TransactionHasDataToWrite %p caller %p not found",
+ this, caller));
+ return;
+ }
+
+ LOG3(("Http3Session::TransactionHasDataToWrite %p ID is 0x%" PRIx64, this,
+ stream->StreamId()));
+
+ StreamHasDataToWrite(stream);
+}
+
+void Http3Session::StreamHasDataToWrite(Http3StreamBase* aStream) {
+ if (!IsClosing()) {
+ StreamReadyToWrite(aStream);
+ } else {
+ LOG3(
+ ("Http3Session::TransactionHasDataToWrite %p closed so not setting "
+ "Ready4Write\n",
+ this));
+ }
+
+ // NSPR poll will not poll the network if there are non system PR_FileDesc's
+ // that are ready - so we can get into a deadlock waiting for the system IO
+ // to come back here if we don't force the send loop manually.
+ Unused << ForceSend();
+}
+
+void Http3Session::TransactionHasDataToRecv(nsAHttpTransaction* caller) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+ LOG3(("Http3Session::TransactionHasDataToRecv %p trans=%p", this, caller));
+
+ // a signal from the http transaction to the connection that it will consume
+ // more
+ RefPtr<Http3StreamBase> stream = mStreamTransactionHash.Get(caller);
+ if (!stream) {
+ LOG3(("Http3Session::TransactionHasDataToRecv %p caller %p not found", this,
+ caller));
+ return;
+ }
+
+ LOG3(("Http3Session::TransactionHasDataToRecv %p ID is 0x%" PRIx64 "\n", this,
+ stream->StreamId()));
+ ConnectSlowConsumer(stream);
+}
+
+void Http3Session::ConnectSlowConsumer(Http3StreamBase* stream) {
+ LOG3(("Http3Session::ConnectSlowConsumer %p 0x%" PRIx64 "\n", this,
+ stream->StreamId()));
+ mSlowConsumersReadyForRead.AppendElement(stream);
+ Unused << ForceRecv();
+}
+
+bool Http3Session::TestJoinConnection(const nsACString& hostname,
+ int32_t port) {
+ return RealJoinConnection(hostname, port, true);
+}
+
+bool Http3Session::JoinConnection(const nsACString& hostname, int32_t port) {
+ return RealJoinConnection(hostname, port, false);
+}
+
+// TODO test
+bool Http3Session::RealJoinConnection(const nsACString& hostname, int32_t port,
+ bool justKidding) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+ if (!mConnection || !CanSandData() || mShouldClose || mGoawayReceived) {
+ return false;
+ }
+
+ nsHttpConnectionInfo* ci = ConnectionInfo();
+ if (nsCString(hostname).EqualsIgnoreCase(ci->Origin()) &&
+ (port == ci->OriginPort())) {
+ return true;
+ }
+
+ nsAutoCString key(hostname);
+ key.Append(':');
+ key.Append(justKidding ? 'k' : '.');
+ key.AppendInt(port);
+ bool cachedResult;
+ if (mJoinConnectionCache.Get(key, &cachedResult)) {
+ LOG(("joinconnection [%p %s] %s result=%d cache\n", this,
+ ConnectionInfo()->HashKey().get(), key.get(), cachedResult));
+ return cachedResult;
+ }
+
+ nsresult rv;
+ bool isJoined = false;
+
+ nsCOMPtr<nsITLSSocketControl> sslSocketControl;
+ mConnection->GetTLSSocketControl(getter_AddRefs(sslSocketControl));
+ if (!sslSocketControl) {
+ return false;
+ }
+
+ bool joinedReturn = false;
+ if (justKidding) {
+ rv = sslSocketControl->TestJoinConnection(mConnInfo->GetNPNToken(),
+ hostname, port, &isJoined);
+ } else {
+ rv = sslSocketControl->JoinConnection(mConnInfo->GetNPNToken(), hostname,
+ port, &isJoined);
+ }
+ if (NS_SUCCEEDED(rv) && isJoined) {
+ joinedReturn = true;
+ }
+
+ LOG(("joinconnection [%p %s] %s result=%d lookup\n", this,
+ ConnectionInfo()->HashKey().get(), key.get(), joinedReturn));
+ mJoinConnectionCache.InsertOrUpdate(key, joinedReturn);
+ if (!justKidding) {
+ // cache a kidding entry too as this one is good for both
+ nsAutoCString key2(hostname);
+ key2.Append(':');
+ key2.Append('k');
+ key2.AppendInt(port);
+ if (!mJoinConnectionCache.Get(key2)) {
+ mJoinConnectionCache.InsertOrUpdate(key2, joinedReturn);
+ }
+ }
+ return joinedReturn;
+}
+
+void Http3Session::CallCertVerification(Maybe<nsCString> aEchPublicName) {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+ LOG(("Http3Session::CallCertVerification [this=%p]", this));
+
+ NeqoCertificateInfo certInfo;
+ if (NS_FAILED(mHttp3Connection->PeerCertificateInfo(&certInfo))) {
+ LOG(("Http3Session::CallCertVerification [this=%p] - no cert", this));
+ mHttp3Connection->PeerAuthenticated(SSL_ERROR_BAD_CERTIFICATE);
+ mError = psm::GetXPCOMFromNSSError(SSL_ERROR_BAD_CERTIFICATE);
+ return;
+ }
+
+ Maybe<nsTArray<nsTArray<uint8_t>>> stapledOCSPResponse;
+ if (certInfo.stapled_ocsp_responses_present) {
+ stapledOCSPResponse.emplace(std::move(certInfo.stapled_ocsp_responses));
+ }
+
+ Maybe<nsTArray<uint8_t>> sctsFromTLSExtension;
+ if (certInfo.signed_cert_timestamp_present) {
+ sctsFromTLSExtension.emplace(std::move(certInfo.signed_cert_timestamp));
+ }
+
+ uint32_t providerFlags;
+ // the return value is always NS_OK, just ignore it.
+ Unused << mSocketControl->GetProviderFlags(&providerFlags);
+
+ nsCString echConfig;
+ nsresult nsrv = mSocketControl->GetEchConfig(echConfig);
+ bool verifyToEchPublicName = NS_SUCCEEDED(nsrv) && !echConfig.IsEmpty() &&
+ aEchPublicName && !aEchPublicName->IsEmpty();
+ const nsACString& hostname =
+ verifyToEchPublicName ? *aEchPublicName : mSocketControl->GetHostName();
+
+ SECStatus rv = psm::AuthCertificateHookWithInfo(
+ mSocketControl, hostname, static_cast<const void*>(this),
+ std::move(certInfo.certs), stapledOCSPResponse, sctsFromTLSExtension,
+ providerFlags);
+ if ((rv != SECSuccess) && (rv != SECWouldBlock)) {
+ LOG(("Http3Session::CallCertVerification [this=%p] AuthCertificate failed",
+ this));
+ mHttp3Connection->PeerAuthenticated(SSL_ERROR_BAD_CERTIFICATE);
+ mError = psm::GetXPCOMFromNSSError(SSL_ERROR_BAD_CERTIFICATE);
+ }
+}
+
+void Http3Session::Authenticated(int32_t aError) {
+ LOG(("Http3Session::Authenticated error=0x%" PRIx32 " [this=%p].", aError,
+ this));
+ if ((mState == INITIALIZING) || (mState == ZERORTT)) {
+ if (psm::IsNSSErrorCode(aError)) {
+ mError = psm::GetXPCOMFromNSSError(aError);
+ LOG(("Http3Session::Authenticated psm-error=0x%" PRIx32 " [this=%p].",
+ static_cast<uint32_t>(mError), this));
+ }
+ mHttp3Connection->PeerAuthenticated(aError);
+
+ // Call OnQuicTimeoutExpired to properly process neqo events and outputs.
+ // We call OnQuicTimeoutExpired instead of ProcessOutputAndEvents, because
+ // HttpConnectionUDP must close this session in case of an error.
+ NS_DispatchToCurrentThread(
+ NewRunnableMethod("net::HttpConnectionUDP::OnQuicTimeoutExpired",
+ mUdpConn, &HttpConnectionUDP::OnQuicTimeoutExpired));
+ }
+}
+
+void Http3Session::SetSecInfo() {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+ NeqoSecretInfo secInfo;
+ if (NS_SUCCEEDED(mHttp3Connection->GetSecInfo(&secInfo))) {
+ mSocketControl->SetSSLVersionUsed(secInfo.version);
+ mSocketControl->SetResumed(secInfo.resumed);
+ mSocketControl->SetNegotiatedNPN(secInfo.alpn);
+
+ mSocketControl->SetInfo(secInfo.cipher, secInfo.version, secInfo.group,
+ secInfo.signature_scheme, secInfo.ech_accepted);
+ mHandshakeSucceeded = true;
+ }
+
+ if (!mSocketControl->HasServerCert()) {
+ mSocketControl->RebuildCertificateInfoFromSSLTokenCache();
+ }
+}
+
+// Transport error have values from 0x0 to 0x11.
+// (https://tools.ietf.org/html/draft-ietf-quic-transport-34#section-20.1)
+// We will map this error to 0-16.
+// 17 will capture error codes between and including 0x12 and 0x0ff. This
+// error codes are not define by the spec but who know peer may sent them.
+// CryptoAlerts have value 0x100 + alert code. The range of alert code is
+// 0x00-0xff. (https://tools.ietf.org/html/draft-ietf-quic-tls_34#section-4.8)
+// Since telemetry does not allow more than 100 bucket, we use three diffrent
+// keys to map all alert codes.
+const uint32_t HTTP3_TELEMETRY_TRANSPORT_END = 16;
+const uint32_t HTTP3_TELEMETRY_TRANSPORT_UNKNOWN = 17;
+const uint32_t HTTP3_TELEMETRY_TRANSPORT_CRYPTO_UNKNOWN = 18;
+// All errors from CloseError::Tag::CryptoError will be map to 19
+const uint32_t HTTP3_TELEMETRY_CRYPTO_ERROR = 19;
+
+uint64_t GetCryptoAlertCode(nsCString& key, uint64_t error) {
+ if (error < 100) {
+ key.Append("_a"_ns);
+ return error;
+ }
+ if (error < 200) {
+ error -= 100;
+ key.Append("_b"_ns);
+ return error;
+ }
+ if (error < 256) {
+ error -= 200;
+ key.Append("_c"_ns);
+ return error;
+ }
+ return HTTP3_TELEMETRY_TRANSPORT_CRYPTO_UNKNOWN;
+}
+
+uint64_t GetTransportErrorCodeForTelemetry(nsCString& key, uint64_t error) {
+ if (error <= HTTP3_TELEMETRY_TRANSPORT_END) {
+ return error;
+ }
+ if (error < 0x100) {
+ return HTTP3_TELEMETRY_TRANSPORT_UNKNOWN;
+ }
+
+ return GetCryptoAlertCode(key, error - 0x100);
+}
+
+// Http3 error codes are 0x100-0x110.
+// (https://tools.ietf.org/html/draft-ietf-quic-http-33#section-8.1)
+// The mapping is described below.
+// 0x00-0x10 mapped to 0-16
+// 0x11-0xff mapped to 17
+// 0x100-0x110 mapped to 18-36
+// 0x111-0x1ff mapped to 37
+// 0x200-0x202 mapped to 38-40
+// Others mapped to 41
+const uint32_t HTTP3_TELEMETRY_APP_UNKNOWN_1 = 17;
+const uint32_t HTTP3_TELEMETRY_APP_START = 18;
+// Values between 0x111 and 0x1ff are no definded and will be map to 18.
+const uint32_t HTTP3_TELEMETRY_APP_UNKNOWN_2 = 37;
+// Error codes between 0x200 and 0x202 are related to qpack.
+// (https://tools.ietf.org/html/draft-ietf-quic-qpack-20#section-6)
+// They will be mapped to 19-21
+const uint32_t HTTP3_TELEMETRY_APP_QPACK_START = 38;
+// Values greater or equal to 0x203 are no definded and will be map to 41.
+const uint32_t HTTP3_TELEMETRY_APP_UNKNOWN_3 = 41;
+
+uint64_t GetAppErrorCodeForTelemetry(uint64_t error) {
+ if (error <= 0x10) {
+ return error;
+ }
+ if (error <= 0xff) {
+ return HTTP3_TELEMETRY_APP_UNKNOWN_1;
+ }
+ if (error <= 0x110) {
+ return error - 0x100 + HTTP3_TELEMETRY_APP_START;
+ }
+ if (error < 0x200) {
+ return HTTP3_TELEMETRY_APP_UNKNOWN_2;
+ }
+ if (error <= 0x202) {
+ return error - 0x200 + HTTP3_TELEMETRY_APP_QPACK_START;
+ }
+ return HTTP3_TELEMETRY_APP_UNKNOWN_3;
+}
+
+void Http3Session::CloseConnectionTelemetry(CloseError& aError, bool aClosing) {
+ uint64_t value = 0;
+ nsCString key = EmptyCString();
+
+ switch (aError.tag) {
+ case CloseError::Tag::TransportInternalError:
+ key = "transport_internal"_ns;
+ value = aError.transport_internal_error._0;
+ break;
+ case CloseError::Tag::TransportInternalErrorOther:
+ key = "transport_other"_ns;
+ value = aError.transport_internal_error_other._0;
+ break;
+ case CloseError::Tag::TransportError:
+ key = "transport"_ns;
+ value = GetTransportErrorCodeForTelemetry(key, aError.transport_error._0);
+ break;
+ case CloseError::Tag::CryptoError:
+ key = "transport"_ns;
+ value = HTTP3_TELEMETRY_CRYPTO_ERROR;
+ break;
+ case CloseError::Tag::CryptoAlert:
+ key = "transport_crypto_alert"_ns;
+ value = GetCryptoAlertCode(key, aError.crypto_alert._0);
+ break;
+ case CloseError::Tag::PeerAppError:
+ key = "peer_app"_ns;
+ value = GetAppErrorCodeForTelemetry(aError.peer_app_error._0);
+ break;
+ case CloseError::Tag::PeerError:
+ key = "peer_transport"_ns;
+ value = GetTransportErrorCodeForTelemetry(key, aError.peer_error._0);
+ break;
+ case CloseError::Tag::AppError:
+ key = "app"_ns;
+ value = GetAppErrorCodeForTelemetry(aError.app_error._0);
+ break;
+ case CloseError::Tag::EchRetry:
+ key = "transport_crypto_alert"_ns;
+ value = 121;
+ }
+
+ key.Append(aClosing ? "_closing"_ns : "_closed"_ns);
+
+ Telemetry::Accumulate(Telemetry::HTTP3_CONNECTION_CLOSE_CODE_3, key, value);
+
+ Http3Stats stats{};
+ mHttp3Connection->GetStats(&stats);
+
+ if (stats.packets_tx > 0) {
+ unsigned long loss = (stats.lost * 10000) / stats.packets_tx;
+ Telemetry::Accumulate(Telemetry::HTTP3_LOSS_RATIO, loss);
+
+ Telemetry::Accumulate(Telemetry::HTTP3_LATE_ACK, "ack"_ns, stats.late_ack);
+ Telemetry::Accumulate(Telemetry::HTTP3_LATE_ACK, "pto"_ns, stats.pto_ack);
+
+ unsigned long late_ack_ratio = (stats.late_ack * 10000) / stats.packets_tx;
+ unsigned long pto_ack_ratio = (stats.pto_ack * 10000) / stats.packets_tx;
+ Telemetry::Accumulate(Telemetry::HTTP3_LATE_ACK_RATIO, "ack"_ns,
+ late_ack_ratio);
+ Telemetry::Accumulate(Telemetry::HTTP3_LATE_ACK_RATIO, "pto"_ns,
+ pto_ack_ratio);
+
+ for (uint32_t i = 0; i < MAX_PTO_COUNTS; i++) {
+ nsAutoCString key;
+ key.AppendInt(i);
+ Telemetry::Accumulate(Telemetry::HTTP3_COUNTS_PTO, key,
+ stats.pto_counts[i]);
+ }
+
+ Telemetry::Accumulate(Telemetry::HTTP3_DROP_DGRAMS, stats.dropped_rx);
+ Telemetry::Accumulate(Telemetry::HTTP3_SAVED_DGRAMS, stats.saved_datagrams);
+ }
+
+ Telemetry::Accumulate(Telemetry::HTTP3_RECEIVED_SENT_DGRAMS, "received"_ns,
+ stats.packets_rx);
+ Telemetry::Accumulate(Telemetry::HTTP3_RECEIVED_SENT_DGRAMS, "sent"_ns,
+ stats.packets_tx);
+}
+
+void Http3Session::Finish0Rtt(bool aRestart) {
+ for (size_t i = 0; i < m0RTTStreams.Length(); ++i) {
+ if (m0RTTStreams[i]) {
+ if (aRestart) {
+ // When we need to restart transactions remove them from all lists.
+ if (m0RTTStreams[i]->HasStreamId()) {
+ mStreamIdHash.Remove(m0RTTStreams[i]->StreamId());
+ }
+ RemoveStreamFromQueues(m0RTTStreams[i]);
+ // The stream is ready to write again.
+ mReadyForWrite.Push(m0RTTStreams[i]);
+ }
+ m0RTTStreams[i]->Finish0RTT(aRestart);
+ }
+ }
+
+ for (size_t i = 0; i < mCannotDo0RTTStreams.Length(); ++i) {
+ if (mCannotDo0RTTStreams[i]) {
+ mReadyForWrite.Push(mCannotDo0RTTStreams[i]);
+ }
+ }
+ m0RTTStreams.Clear();
+ mCannotDo0RTTStreams.Clear();
+ MaybeResumeSend();
+}
+
+void Http3Session::ReportHttp3Connection() {
+ if (CanSandData() && !mHttp3ConnectionReported) {
+ mHttp3ConnectionReported = true;
+ gHttpHandler->ConnMgr()->ReportHttp3Connection(mUdpConn);
+ MaybeResumeSend();
+ }
+}
+
+void Http3Session::EchOutcomeTelemetry() {
+ MOZ_ASSERT(OnSocketThread(), "not on socket thread");
+
+ nsAutoCString key;
+ switch (mEchExtensionStatus) {
+ case EchExtensionStatus::kNotPresent:
+ key = "NONE";
+ break;
+ case EchExtensionStatus::kGREASE:
+ key = "GREASE";
+ break;
+ case EchExtensionStatus::kReal:
+ key = "REAL";
+ break;
+ }
+
+ Telemetry::Accumulate(Telemetry::HTTP3_ECH_OUTCOME, key,
+ mHandshakeSucceeded ? 0 : 1);
+}
+
+void Http3Session::ZeroRttTelemetry(ZeroRttOutcome aOutcome) {
+ Telemetry::Accumulate(Telemetry::HTTP3_0RTT_STATE, aOutcome);
+
+ nsAutoCString key;
+
+ switch (aOutcome) {
+ case USED_SUCCEEDED:
+ key = "succeeded"_ns;
+ break;
+ case USED_REJECTED:
+ key = "rejected"_ns;
+ break;
+ case USED_CONN_ERROR:
+ key = "conn_error"_ns;
+ break;
+ case USED_CONN_CLOSED_BY_NECKO:
+ key = "conn_closed_by_necko"_ns;
+ break;
+ default:
+ break;
+ }
+
+ if (!key.IsEmpty()) {
+ MOZ_ASSERT(mZeroRttStarted);
+ Telemetry::AccumulateTimeDelta(Telemetry::HTTP3_0RTT_STATE_DURATION, key,
+ mZeroRttStarted, TimeStamp::Now());
+ }
+}
+
+nsresult Http3Session::GetTransactionTLSSocketControl(
+ nsITLSSocketControl** tlsSocketControl) {
+ NS_IF_ADDREF(*tlsSocketControl = mSocketControl);
+ return NS_OK;
+}
+
+PRIntervalTime Http3Session::LastWriteTime() { return mLastWriteTime; }
+
+void Http3Session::WebTransportNegotiationDone() {
+ for (size_t i = 0; i < mWaitingForWebTransportNegotiation.Length(); ++i) {
+ if (mWaitingForWebTransportNegotiation[i]) {
+ mReadyForWrite.Push(mWaitingForWebTransportNegotiation[i]);
+ }
+ }
+ mWaitingForWebTransportNegotiation.Clear();
+ MaybeResumeSend();
+}
+
+//=========================================================================
+// WebTransport
+//=========================================================================
+
+nsresult Http3Session::CloseWebTransport(uint64_t aSessionId, uint32_t aError,
+ const nsACString& aMessage) {
+ return mHttp3Connection->CloseWebTransport(aSessionId, aError, aMessage);
+}
+
+nsresult Http3Session::CreateWebTransportStream(
+ uint64_t aSessionId, WebTransportStreamType aStreamType,
+ uint64_t* aStreamId) {
+ return mHttp3Connection->CreateWebTransportStream(aSessionId, aStreamType,
+ aStreamId);
+}
+
+void Http3Session::SendDatagram(Http3WebTransportSession* aSession,
+ nsTArray<uint8_t>& aData,
+ uint64_t aTrackingId) {
+ nsresult rv = mHttp3Connection->WebTransportSendDatagram(aSession->StreamId(),
+ aData, aTrackingId);
+ LOG(("Http3Session::SendDatagram %p res=%" PRIx32, this,
+ static_cast<uint32_t>(rv)));
+ if (!aTrackingId) {
+ return;
+ }
+
+ switch (rv) {
+ case NS_OK:
+ aSession->OnOutgoingDatagramOutCome(
+ aTrackingId, WebTransportSessionEventListener::DatagramOutcome::SENT);
+ break;
+ case NS_ERROR_NOT_AVAILABLE:
+ aSession->OnOutgoingDatagramOutCome(
+ aTrackingId, WebTransportSessionEventListener::DatagramOutcome::
+ DROPPED_TOO_MUCH_DATA);
+ break;
+ default:
+ aSession->OnOutgoingDatagramOutCome(
+ aTrackingId,
+ WebTransportSessionEventListener::DatagramOutcome::UNKNOWN);
+ break;
+ }
+}
+
+uint64_t Http3Session::MaxDatagramSize(uint64_t aSessionId) {
+ uint64_t size = 0;
+ Unused << mHttp3Connection->WebTransportMaxDatagramSize(aSessionId, &size);
+ return size;
+}
+
+} // namespace mozilla::net