diff options
Diffstat (limited to 'netwerk/base/nsSocketTransportService2.cpp')
| -rw-r--r-- | netwerk/base/nsSocketTransportService2.cpp | 1899 |
1 files changed, 1899 insertions, 0 deletions
diff --git a/netwerk/base/nsSocketTransportService2.cpp b/netwerk/base/nsSocketTransportService2.cpp new file mode 100644 index 0000000000..a6aa249465 --- /dev/null +++ b/netwerk/base/nsSocketTransportService2.cpp @@ -0,0 +1,1899 @@ +// vim:set sw=2 sts=2 et cin: +/* 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 "nsSocketTransportService2.h" + +#include "IOActivityMonitor.h" +#include "mozilla/Atomics.h" +#include "mozilla/ChaosMode.h" +#include "mozilla/IntegerPrintfMacros.h" +#include "mozilla/Likely.h" +#include "mozilla/PodOperations.h" +#include "mozilla/Preferences.h" +#include "mozilla/ProfilerMarkers.h" +#include "mozilla/ProfilerThreadSleep.h" +#include "mozilla/PublicSSL.h" +#include "mozilla/ReverseIterator.h" +#include "mozilla/Services.h" +#include "mozilla/StaticPrefs_network.h" +#include "mozilla/Tokenizer.h" +#include "mozilla/Telemetry.h" +#include "nsASocketHandler.h" +#include "nsError.h" +#include "nsIFile.h" +#include "nsINetworkLinkService.h" +#include "nsIOService.h" +#include "nsIObserverService.h" +#include "nsIWidget.h" +#include "nsServiceManagerUtils.h" +#include "nsSocketTransport2.h" +#include "nsThreadUtils.h" +#include "prerror.h" +#include "prnetdb.h" + +namespace mozilla { +namespace net { + +#define SOCKET_THREAD_LONGTASK_MS 3 + +LazyLogModule gSocketTransportLog("nsSocketTransport"); +LazyLogModule gUDPSocketLog("UDPSocket"); +LazyLogModule gTCPSocketLog("TCPSocket"); + +nsSocketTransportService* gSocketTransportService = nullptr; +static Atomic<PRThread*, Relaxed> gSocketThread(nullptr); + +#define SEND_BUFFER_PREF "network.tcp.sendbuffer" +#define KEEPALIVE_ENABLED_PREF "network.tcp.keepalive.enabled" +#define KEEPALIVE_IDLE_TIME_PREF "network.tcp.keepalive.idle_time" +#define KEEPALIVE_RETRY_INTERVAL_PREF "network.tcp.keepalive.retry_interval" +#define KEEPALIVE_PROBE_COUNT_PREF "network.tcp.keepalive.probe_count" +#define SOCKET_LIMIT_TARGET 1000U +#define MAX_TIME_BETWEEN_TWO_POLLS \ + "network.sts.max_time_for_events_between_two_polls" +#define POLL_BUSY_WAIT_PERIOD "network.sts.poll_busy_wait_period" +#define POLL_BUSY_WAIT_PERIOD_TIMEOUT \ + "network.sts.poll_busy_wait_period_timeout" +#define MAX_TIME_FOR_PR_CLOSE_DURING_SHUTDOWN \ + "network.sts.max_time_for_pr_close_during_shutdown" +#define POLLABLE_EVENT_TIMEOUT "network.sts.pollable_event_timeout" + +#define REPAIR_POLLABLE_EVENT_TIME 10 + +uint32_t nsSocketTransportService::gMaxCount; +PRCallOnceType nsSocketTransportService::gMaxCountInitOnce; + +// Utility functions +bool OnSocketThread() { return PR_GetCurrentThread() == gSocketThread; } + +//----------------------------------------------------------------------------- + +bool nsSocketTransportService::SocketContext::IsTimedOut( + PRIntervalTime now) const { + return TimeoutIn(now) == 0; +} + +void nsSocketTransportService::SocketContext::EnsureTimeout( + PRIntervalTime now) { + SOCKET_LOG(("SocketContext::EnsureTimeout socket=%p", mHandler.get())); + if (!mPollStartEpoch) { + SOCKET_LOG((" engaging")); + mPollStartEpoch = now; + } +} + +void nsSocketTransportService::SocketContext::DisengageTimeout() { + SOCKET_LOG(("SocketContext::DisengageTimeout socket=%p", mHandler.get())); + mPollStartEpoch = 0; +} + +PRIntervalTime nsSocketTransportService::SocketContext::TimeoutIn( + PRIntervalTime now) const { + SOCKET_LOG(("SocketContext::TimeoutIn socket=%p, timeout=%us", mHandler.get(), + mHandler->mPollTimeout)); + + if (mHandler->mPollTimeout == UINT16_MAX || !mPollStartEpoch) { + SOCKET_LOG((" not engaged")); + return NS_SOCKET_POLL_TIMEOUT; + } + + PRIntervalTime elapsed = (now - mPollStartEpoch); + PRIntervalTime timeout = PR_SecondsToInterval(mHandler->mPollTimeout); + + if (elapsed >= timeout) { + SOCKET_LOG((" timed out!")); + return 0; + } + SOCKET_LOG((" remains %us", PR_IntervalToSeconds(timeout - elapsed))); + return timeout - elapsed; +} + +void nsSocketTransportService::SocketContext::MaybeResetEpoch() { + if (mPollStartEpoch && mHandler->mPollTimeout == UINT16_MAX) { + mPollStartEpoch = 0; + } +} + +//----------------------------------------------------------------------------- +// ctor/dtor (called on the main/UI thread by the service manager) + +nsSocketTransportService::nsSocketTransportService() + : mPollableEventTimeout(TimeDuration::FromSeconds(6)), + mMaxTimeForPrClosePref(PR_SecondsToInterval(5)), + mNetworkLinkChangeBusyWaitPeriod(PR_SecondsToInterval(50)), + mNetworkLinkChangeBusyWaitTimeout(PR_SecondsToInterval(7)) { + NS_ASSERTION(NS_IsMainThread(), "wrong thread"); + + PR_CallOnce(&gMaxCountInitOnce, DiscoverMaxCount); + + NS_ASSERTION(!gSocketTransportService, "must not instantiate twice"); + gSocketTransportService = this; + + // The Poll list always has an entry at [0]. The rest of the + // list is a duplicate of the Active list's PRFileDesc file descriptors. + PRPollDesc entry = {nullptr, PR_POLL_READ | PR_POLL_EXCEPT, 0}; + mPollList.InsertElementAt(0, entry); +} + +void nsSocketTransportService::ApplyPortRemap(uint16_t* aPort) { + MOZ_ASSERT(IsOnCurrentThreadInfallible()); + + if (!mPortRemapping) { + return; + } + + // Reverse the array to make later rules override earlier rules. + for (auto const& portMapping : Reversed(*mPortRemapping)) { + if (*aPort < std::get<0>(portMapping)) { + continue; + } + if (*aPort > std::get<1>(portMapping)) { + continue; + } + + *aPort = std::get<2>(portMapping); + return; + } +} + +bool nsSocketTransportService::UpdatePortRemapPreference( + nsACString const& aPortMappingPref) { + TPortRemapping portRemapping; + + auto consumePreference = [&]() -> bool { + Tokenizer tokenizer(aPortMappingPref); + + tokenizer.SkipWhites(); + if (tokenizer.CheckEOF()) { + return true; + } + + nsTArray<std::tuple<uint16_t, uint16_t>> ranges(2); + while (true) { + uint16_t loPort; + tokenizer.SkipWhites(); + if (!tokenizer.ReadInteger(&loPort)) { + break; + } + + uint16_t hiPort; + tokenizer.SkipWhites(); + if (tokenizer.CheckChar('-')) { + tokenizer.SkipWhites(); + if (!tokenizer.ReadInteger(&hiPort)) { + break; + } + } else { + hiPort = loPort; + } + + ranges.AppendElement(std::make_tuple(loPort, hiPort)); + + tokenizer.SkipWhites(); + if (tokenizer.CheckChar(',')) { + continue; // another port or port range is expected + } + + if (tokenizer.CheckChar('=')) { + uint16_t targetPort; + tokenizer.SkipWhites(); + if (!tokenizer.ReadInteger(&targetPort)) { + break; + } + + // Storing reversed, because the most common cases (like 443) will very + // likely be listed as first, less common cases will be added to the end + // of the list mapping to the same port. As we iterate the whole + // remapping array from the end, this may have a small perf win by + // hitting the most common cases earlier. + for (auto const& range : Reversed(ranges)) { + portRemapping.AppendElement(std::make_tuple( + std::get<0>(range), std::get<1>(range), targetPort)); + } + ranges.Clear(); + + tokenizer.SkipWhites(); + if (tokenizer.CheckChar(';')) { + continue; // more mappings (or EOF) expected + } + if (tokenizer.CheckEOF()) { + return true; + } + } + + // Anything else is unexpected. + break; + } + + // 'break' from the parsing loop means ill-formed preference + portRemapping.Clear(); + return false; + }; + + bool rv = consumePreference(); + + if (!IsOnCurrentThread()) { + nsCOMPtr<nsIThread> thread = GetThreadSafely(); + if (!thread) { + // Init hasn't been called yet. Could probably just assert. + // If shutdown, the dispatch below will just silently fail. + NS_ASSERTION(false, "ApplyPortRemapPreference before STS::Init"); + return false; + } + thread->Dispatch(NewRunnableMethod<TPortRemapping>( + "net::ApplyPortRemapping", this, + &nsSocketTransportService::ApplyPortRemapPreference, portRemapping)); + } else { + ApplyPortRemapPreference(portRemapping); + } + + return rv; +} + +nsSocketTransportService::~nsSocketTransportService() { + NS_ASSERTION(NS_IsMainThread(), "wrong thread"); + NS_ASSERTION(!mInitialized, "not shutdown properly"); + + gSocketTransportService = nullptr; +} + +//----------------------------------------------------------------------------- +// event queue (any thread) + +already_AddRefed<nsIThread> nsSocketTransportService::GetThreadSafely() { + MutexAutoLock lock(mLock); + nsCOMPtr<nsIThread> result = mThread; + return result.forget(); +} + +NS_IMETHODIMP +nsSocketTransportService::DispatchFromScript(nsIRunnable* event, + uint32_t flags) { + nsCOMPtr<nsIRunnable> event_ref(event); + return Dispatch(event_ref.forget(), flags); +} + +NS_IMETHODIMP +nsSocketTransportService::Dispatch(already_AddRefed<nsIRunnable> event, + uint32_t flags) { + nsCOMPtr<nsIRunnable> event_ref(event); + SOCKET_LOG(("STS dispatch [%p]\n", event_ref.get())); + + nsCOMPtr<nsIThread> thread = GetThreadSafely(); + nsresult rv; + rv = thread ? thread->Dispatch(event_ref.forget(), flags) + : NS_ERROR_NOT_INITIALIZED; + if (rv == NS_ERROR_UNEXPECTED) { + // Thread is no longer accepting events. We must have just shut it + // down on the main thread. Pretend we never saw it. + rv = NS_ERROR_NOT_INITIALIZED; + } + return rv; +} + +NS_IMETHODIMP +nsSocketTransportService::DelayedDispatch(already_AddRefed<nsIRunnable>, + uint32_t) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsSocketTransportService::RegisterShutdownTask(nsITargetShutdownTask* task) { + nsCOMPtr<nsIThread> thread = GetThreadSafely(); + return thread ? thread->RegisterShutdownTask(task) : NS_ERROR_UNEXPECTED; +} + +NS_IMETHODIMP +nsSocketTransportService::UnregisterShutdownTask(nsITargetShutdownTask* task) { + nsCOMPtr<nsIThread> thread = GetThreadSafely(); + return thread ? thread->UnregisterShutdownTask(task) : NS_ERROR_UNEXPECTED; +} + +NS_IMETHODIMP +nsSocketTransportService::IsOnCurrentThread(bool* result) { + *result = OnSocketThread(); + return NS_OK; +} + +NS_IMETHODIMP_(bool) +nsSocketTransportService::IsOnCurrentThreadInfallible() { + return OnSocketThread(); +} + +//----------------------------------------------------------------------------- +// nsIDirectTaskDispatcher + +already_AddRefed<nsIDirectTaskDispatcher> +nsSocketTransportService::GetDirectTaskDispatcherSafely() { + MutexAutoLock lock(mLock); + nsCOMPtr<nsIDirectTaskDispatcher> result = mDirectTaskDispatcher; + return result.forget(); +} + +NS_IMETHODIMP +nsSocketTransportService::DispatchDirectTask( + already_AddRefed<nsIRunnable> aEvent) { + nsCOMPtr<nsIDirectTaskDispatcher> dispatcher = + GetDirectTaskDispatcherSafely(); + NS_ENSURE_TRUE(dispatcher, NS_ERROR_NOT_INITIALIZED); + return dispatcher->DispatchDirectTask(std::move(aEvent)); +} + +NS_IMETHODIMP nsSocketTransportService::DrainDirectTasks() { + nsCOMPtr<nsIDirectTaskDispatcher> dispatcher = + GetDirectTaskDispatcherSafely(); + if (!dispatcher) { + // nothing to drain. + return NS_OK; + } + return dispatcher->DrainDirectTasks(); +} + +NS_IMETHODIMP nsSocketTransportService::HaveDirectTasks(bool* aValue) { + nsCOMPtr<nsIDirectTaskDispatcher> dispatcher = + GetDirectTaskDispatcherSafely(); + if (!dispatcher) { + *aValue = false; + return NS_OK; + } + return dispatcher->HaveDirectTasks(aValue); +} + +//----------------------------------------------------------------------------- +// socket api (socket thread only) + +NS_IMETHODIMP +nsSocketTransportService::NotifyWhenCanAttachSocket(nsIRunnable* event) { + SOCKET_LOG(("nsSocketTransportService::NotifyWhenCanAttachSocket\n")); + + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + + if (CanAttachSocket()) { + return Dispatch(event, NS_DISPATCH_NORMAL); + } + + auto* runnable = new LinkedRunnableEvent(event); + mPendingSocketQueue.insertBack(runnable); + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransportService::AttachSocket(PRFileDesc* fd, + nsASocketHandler* handler) { + SOCKET_LOG( + ("nsSocketTransportService::AttachSocket [handler=%p]\n", handler)); + + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + + if (!CanAttachSocket()) { + return NS_ERROR_NOT_AVAILABLE; + } + + SocketContext sock{fd, handler, 0}; + + AddToIdleList(&sock); + return NS_OK; +} + +// the number of sockets that can be attached at any given time is +// limited. this is done because some operating systems (e.g., Win9x) +// limit the number of sockets that can be created by an application. +// AttachSocket will fail if the limit is exceeded. consumers should +// call CanAttachSocket and check the result before creating a socket. + +bool nsSocketTransportService::CanAttachSocket() { + MOZ_ASSERT(!mShuttingDown); + uint32_t total = mActiveList.Length() + mIdleList.Length(); + bool rv = total < gMaxCount; + + MOZ_ASSERT(mInitialized); + return rv; +} + +nsresult nsSocketTransportService::DetachSocket(SocketContextList& listHead, + SocketContext* sock) { + SOCKET_LOG(("nsSocketTransportService::DetachSocket [handler=%p]\n", + sock->mHandler.get())); + MOZ_ASSERT((&listHead == &mActiveList) || (&listHead == &mIdleList), + "DetachSocket invalid head"); + + { + // inform the handler that this socket is going away + sock->mHandler->OnSocketDetached(sock->mFD); + } + mSentBytesCount += sock->mHandler->ByteCountSent(); + mReceivedBytesCount += sock->mHandler->ByteCountReceived(); + + // cleanup + sock->mFD = nullptr; + + if (&listHead == &mActiveList) { + RemoveFromPollList(sock); + } else { + RemoveFromIdleList(sock); + } + + // NOTE: sock is now an invalid pointer + + // + // notify the first element on the pending socket queue... + // + nsCOMPtr<nsIRunnable> event; + LinkedRunnableEvent* runnable = mPendingSocketQueue.getFirst(); + if (runnable) { + event = runnable->TakeEvent(); + runnable->remove(); + delete runnable; + } + if (event) { + // move event from pending queue to dispatch queue + return Dispatch(event, NS_DISPATCH_NORMAL); + } + return NS_OK; +} + +// Returns the index of a SocketContext within a list, or -1 if it's +// not a pointer to a list element +// NOTE: this could be supplied by nsTArray<> +int64_t nsSocketTransportService::SockIndex(SocketContextList& aList, + SocketContext* aSock) { + ptrdiff_t index = -1; + if (!aList.IsEmpty()) { + index = aSock - &aList[0]; + if (index < 0 || (size_t)index + 1 > aList.Length()) { + index = -1; + } + } + return (int64_t)index; +} + +void nsSocketTransportService::AddToPollList(SocketContext* sock) { + MOZ_ASSERT(SockIndex(mActiveList, sock) == -1, + "AddToPollList Socket Already Active"); + + SOCKET_LOG(("nsSocketTransportService::AddToPollList %p [handler=%p]\n", sock, + sock->mHandler.get())); + + sock->EnsureTimeout(PR_IntervalNow()); + PRPollDesc poll; + poll.fd = sock->mFD; + poll.in_flags = sock->mHandler->mPollFlags; + poll.out_flags = 0; + if (ChaosMode::isActive(ChaosFeature::NetworkScheduling)) { + auto newSocketIndex = mActiveList.Length(); + newSocketIndex = ChaosMode::randomUint32LessThan(newSocketIndex + 1); + mActiveList.InsertElementAt(newSocketIndex, *sock); + // mPollList is offset by 1 + mPollList.InsertElementAt(newSocketIndex + 1, poll); + } else { + // Avoid refcount bump/decrease + mActiveList.EmplaceBack(sock->mFD, sock->mHandler.forget(), + sock->mPollStartEpoch); + mPollList.AppendElement(poll); + } + + SOCKET_LOG( + (" active=%zu idle=%zu\n", mActiveList.Length(), mIdleList.Length())); +} + +void nsSocketTransportService::RemoveFromPollList(SocketContext* sock) { + SOCKET_LOG(("nsSocketTransportService::RemoveFromPollList %p [handler=%p]\n", + sock, sock->mHandler.get())); + + auto index = SockIndex(mActiveList, sock); + MOZ_RELEASE_ASSERT(index != -1, "invalid index"); + + SOCKET_LOG((" index=%" PRId64 " mActiveList.Length()=%zu\n", index, + mActiveList.Length())); + mActiveList.UnorderedRemoveElementAt(index); + // mPollList is offset by 1 + mPollList.UnorderedRemoveElementAt(index + 1); + + SOCKET_LOG( + (" active=%zu idle=%zu\n", mActiveList.Length(), mIdleList.Length())); +} + +void nsSocketTransportService::AddToIdleList(SocketContext* sock) { + MOZ_ASSERT(SockIndex(mIdleList, sock) == -1, + "AddToIdleList Socket Already Idle"); + + SOCKET_LOG(("nsSocketTransportService::AddToIdleList %p [handler=%p]\n", sock, + sock->mHandler.get())); + + // Avoid refcount bump/decrease + mIdleList.EmplaceBack(sock->mFD, sock->mHandler.forget(), + sock->mPollStartEpoch); + + SOCKET_LOG( + (" active=%zu idle=%zu\n", mActiveList.Length(), mIdleList.Length())); +} + +void nsSocketTransportService::RemoveFromIdleList(SocketContext* sock) { + SOCKET_LOG(("nsSocketTransportService::RemoveFromIdleList [handler=%p]\n", + sock->mHandler.get())); + auto index = SockIndex(mIdleList, sock); + MOZ_RELEASE_ASSERT(index != -1); + mIdleList.UnorderedRemoveElementAt(index); + + SOCKET_LOG( + (" active=%zu idle=%zu\n", mActiveList.Length(), mIdleList.Length())); +} + +void nsSocketTransportService::MoveToIdleList(SocketContext* sock) { + SOCKET_LOG(("nsSocketTransportService::MoveToIdleList %p [handler=%p]\n", + sock, sock->mHandler.get())); + MOZ_ASSERT(SockIndex(mIdleList, sock) == -1); + MOZ_ASSERT(SockIndex(mActiveList, sock) != -1); + AddToIdleList(sock); + RemoveFromPollList(sock); +} + +void nsSocketTransportService::MoveToPollList(SocketContext* sock) { + SOCKET_LOG(("nsSocketTransportService::MoveToPollList %p [handler=%p]\n", + sock, sock->mHandler.get())); + MOZ_ASSERT(SockIndex(mIdleList, sock) != -1); + MOZ_ASSERT(SockIndex(mActiveList, sock) == -1); + AddToPollList(sock); + RemoveFromIdleList(sock); +} + +void nsSocketTransportService::ApplyPortRemapPreference( + TPortRemapping const& portRemapping) { + MOZ_ASSERT(IsOnCurrentThreadInfallible()); + + mPortRemapping.reset(); + if (!portRemapping.IsEmpty()) { + mPortRemapping.emplace(portRemapping); + } +} + +PRIntervalTime nsSocketTransportService::PollTimeout(PRIntervalTime now) { + if (mActiveList.IsEmpty()) { + return NS_SOCKET_POLL_TIMEOUT; + } + + // compute minimum time before any socket timeout expires. + PRIntervalTime minR = NS_SOCKET_POLL_TIMEOUT; + for (uint32_t i = 0; i < mActiveList.Length(); ++i) { + const SocketContext& s = mActiveList[i]; + PRIntervalTime r = s.TimeoutIn(now); + if (r < minR) { + minR = r; + } + } + if (minR == NS_SOCKET_POLL_TIMEOUT) { + SOCKET_LOG(("poll timeout: none\n")); + return NS_SOCKET_POLL_TIMEOUT; + } + SOCKET_LOG(("poll timeout: %" PRIu32 "\n", PR_IntervalToSeconds(minR))); + return minR; +} + +int32_t nsSocketTransportService::Poll(TimeDuration* pollDuration, + PRIntervalTime ts) { + MOZ_ASSERT(IsOnCurrentThread()); + PRPollDesc* firstPollEntry; + uint32_t pollCount; + PRIntervalTime pollTimeout; + *pollDuration = nullptr; + + // If there are pending events for this thread then + // DoPollIteration() should service the network without blocking. + bool pendingEvents = false; + mRawThread->HasPendingEvents(&pendingEvents); + + if (mPollList[0].fd) { + mPollList[0].out_flags = 0; + firstPollEntry = &mPollList[0]; + pollCount = mPollList.Length(); + pollTimeout = pendingEvents ? PR_INTERVAL_NO_WAIT : PollTimeout(ts); + } else { + // no pollable event, so busy wait... + pollCount = mActiveList.Length(); + if (pollCount) { + firstPollEntry = &mPollList[1]; + } else { + firstPollEntry = nullptr; + } + pollTimeout = + pendingEvents ? PR_INTERVAL_NO_WAIT : PR_MillisecondsToInterval(25); + } + + if ((ts - mLastNetworkLinkChangeTime) < mNetworkLinkChangeBusyWaitPeriod) { + // Being here means we are few seconds after a network change has + // been detected. + PRIntervalTime to = mNetworkLinkChangeBusyWaitTimeout; + if (to) { + pollTimeout = std::min(to, pollTimeout); + SOCKET_LOG((" timeout shorthened after network change event")); + } + } + + TimeStamp pollStart; + if (Telemetry::CanRecordPrereleaseData()) { + pollStart = TimeStamp::NowLoRes(); + } + + SOCKET_LOG((" timeout = %i milliseconds\n", + PR_IntervalToMilliseconds(pollTimeout))); + + int32_t n; + { +#ifdef MOZ_GECKO_PROFILER + TimeStamp startTime = TimeStamp::Now(); + if (pollTimeout != PR_INTERVAL_NO_WAIT) { + // There will be an actual non-zero wait, let the profiler know about it + // by marking thread as sleeping around the polling call. + profiler_thread_sleep(); + } +#endif + + n = PR_Poll(firstPollEntry, pollCount, pollTimeout); + +#ifdef MOZ_GECKO_PROFILER + if (pollTimeout != PR_INTERVAL_NO_WAIT) { + profiler_thread_wake(); + } + if (profiler_thread_is_being_profiled_for_markers()) { + PROFILER_MARKER_TEXT( + "SocketTransportService::Poll", NETWORK, + MarkerTiming::IntervalUntilNowFrom(startTime), + pollTimeout == PR_INTERVAL_NO_TIMEOUT + ? nsPrintfCString("Poll count: %u, Poll timeout: NO_TIMEOUT", + pollCount) + : pollTimeout == PR_INTERVAL_NO_WAIT + ? nsPrintfCString("Poll count: %u, Poll timeout: NO_WAIT", + pollCount) + : nsPrintfCString("Poll count: %u, Poll timeout: %ums", pollCount, + PR_IntervalToMilliseconds(pollTimeout))); + } +#endif + } + + if (Telemetry::CanRecordPrereleaseData() && !pollStart.IsNull()) { + *pollDuration = TimeStamp::NowLoRes() - pollStart; + } + + SOCKET_LOG((" ...returned after %i milliseconds\n", + PR_IntervalToMilliseconds(PR_IntervalNow() - ts))); + + return n; +} + +//----------------------------------------------------------------------------- +// xpcom api + +NS_IMPL_ISUPPORTS(nsSocketTransportService, nsISocketTransportService, + nsIRoutedSocketTransportService, nsIEventTarget, + nsISerialEventTarget, nsIThreadObserver, nsIRunnable, + nsPISocketTransportService, nsIObserver, nsINamed, + nsIDirectTaskDispatcher) + +static const char* gCallbackPrefs[] = { + SEND_BUFFER_PREF, + KEEPALIVE_ENABLED_PREF, + KEEPALIVE_IDLE_TIME_PREF, + KEEPALIVE_RETRY_INTERVAL_PREF, + KEEPALIVE_PROBE_COUNT_PREF, + MAX_TIME_BETWEEN_TWO_POLLS, + MAX_TIME_FOR_PR_CLOSE_DURING_SHUTDOWN, + POLLABLE_EVENT_TIMEOUT, + "network.socket.forcePort", + nullptr, +}; + +/* static */ +void nsSocketTransportService::UpdatePrefs(const char* aPref, void* aSelf) { + static_cast<nsSocketTransportService*>(aSelf)->UpdatePrefs(); +} + +static uint32_t GetThreadStackSize() { +#ifdef XP_WIN + if (!StaticPrefs::network_allow_large_stack_size_for_socket_thread()) { + return nsIThreadManager::DEFAULT_STACK_SIZE; + } + + const uint32_t kWindowsThreadStackSize = 512 * 1024; + // We can remove this custom stack size when DEFAULT_STACK_SIZE is increased. + static_assert(kWindowsThreadStackSize > nsIThreadManager::DEFAULT_STACK_SIZE); + return kWindowsThreadStackSize; +#else + return nsIThreadManager::DEFAULT_STACK_SIZE; +#endif +} + +// called from main thread only +NS_IMETHODIMP +nsSocketTransportService::Init() { + if (!NS_IsMainThread()) { + NS_ERROR("wrong thread"); + return NS_ERROR_UNEXPECTED; + } + + if (mInitialized) { + return NS_OK; + } + + if (mShuttingDown) { + return NS_ERROR_UNEXPECTED; + } + + nsCOMPtr<nsIThread> thread; + + if (!XRE_IsContentProcess() || + StaticPrefs::network_allow_raw_sockets_in_content_processes_AtStartup()) { + // Since we Poll, we can't use normal LongTask support in Main Process + nsresult rv = NS_NewNamedThread( + "Socket Thread", getter_AddRefs(thread), this, + {GetThreadStackSize(), false, false, Some(SOCKET_THREAD_LONGTASK_MS)}); + NS_ENSURE_SUCCESS(rv, rv); + } else { + // In the child process, we just want a regular nsThread with no socket + // polling. So we don't want to run the nsSocketTransportService runnable on + // it. + nsresult rv = + NS_NewNamedThread("Socket Thread", getter_AddRefs(thread), nullptr, + {nsIThreadManager::DEFAULT_STACK_SIZE, false, false, + Some(SOCKET_THREAD_LONGTASK_MS)}); + NS_ENSURE_SUCCESS(rv, rv); + + // Set up some of the state that nsSocketTransportService::Run would set. + PRThread* prthread = nullptr; + thread->GetPRThread(&prthread); + gSocketThread = prthread; + mRawThread = thread; + } + + { + MutexAutoLock lock(mLock); + // Install our mThread, protecting against concurrent readers + thread.swap(mThread); + mDirectTaskDispatcher = do_QueryInterface(mThread); + MOZ_DIAGNOSTIC_ASSERT( + mDirectTaskDispatcher, + "Underlying thread must support direct task dispatching"); + } + + Preferences::RegisterCallbacks(UpdatePrefs, gCallbackPrefs, this); + UpdatePrefs(); + + nsCOMPtr<nsIObserverService> obsSvc = services::GetObserverService(); + // Note that the observr notifications are forwarded from parent process to + // socket process. We have to make sure the topics registered below are also + // registered in nsIObserver::Init(). + if (obsSvc) { + obsSvc->AddObserver(this, "profile-initial-state", false); + obsSvc->AddObserver(this, "last-pb-context-exited", false); + obsSvc->AddObserver(this, NS_WIDGET_SLEEP_OBSERVER_TOPIC, true); + obsSvc->AddObserver(this, NS_WIDGET_WAKE_OBSERVER_TOPIC, true); + obsSvc->AddObserver(this, "xpcom-shutdown-threads", false); + obsSvc->AddObserver(this, NS_NETWORK_LINK_TOPIC, false); + } + + // We can now dispatch tasks to the socket thread. + mInitialized = true; + return NS_OK; +} + +// called from main thread only +NS_IMETHODIMP +nsSocketTransportService::Shutdown(bool aXpcomShutdown) { + SOCKET_LOG(("nsSocketTransportService::Shutdown\n")); + + NS_ENSURE_STATE(NS_IsMainThread()); + + if (!mInitialized || mShuttingDown) { + // We never inited, or shutdown has already started + return NS_OK; + } + + { + auto observersCopy = mShutdownObservers; + for (auto& observer : observersCopy) { + observer->Observe(); + } + } + + mShuttingDown = true; + + { + MutexAutoLock lock(mLock); + + if (mPollableEvent) { + mPollableEvent->Signal(); + } + } + + // If we're shutting down due to going offline (rather than due to XPCOM + // shutdown), also tear down the thread. The thread will be shutdown during + // xpcom-shutdown-threads if during xpcom-shutdown proper. + if (!aXpcomShutdown) { + ShutdownThread(); + } + + return NS_OK; +} + +nsresult nsSocketTransportService::ShutdownThread() { + SOCKET_LOG(("nsSocketTransportService::ShutdownThread\n")); + + NS_ENSURE_STATE(NS_IsMainThread()); + + if (!mInitialized) { + return NS_OK; + } + + // join with thread + nsCOMPtr<nsIThread> thread = GetThreadSafely(); + thread->Shutdown(); + { + MutexAutoLock lock(mLock); + // Drop our reference to mThread and make sure that any concurrent readers + // are excluded + mThread = nullptr; + mDirectTaskDispatcher = nullptr; + } + + Preferences::UnregisterCallbacks(UpdatePrefs, gCallbackPrefs, this); + + nsCOMPtr<nsIObserverService> obsSvc = services::GetObserverService(); + if (obsSvc) { + obsSvc->RemoveObserver(this, "profile-initial-state"); + obsSvc->RemoveObserver(this, "last-pb-context-exited"); + obsSvc->RemoveObserver(this, NS_WIDGET_SLEEP_OBSERVER_TOPIC); + obsSvc->RemoveObserver(this, NS_WIDGET_WAKE_OBSERVER_TOPIC); + obsSvc->RemoveObserver(this, "xpcom-shutdown-threads"); + obsSvc->RemoveObserver(this, NS_NETWORK_LINK_TOPIC); + } + + if (mAfterWakeUpTimer) { + mAfterWakeUpTimer->Cancel(); + mAfterWakeUpTimer = nullptr; + } + + IOActivityMonitor::Shutdown(); + + mInitialized = false; + mShuttingDown = false; + + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransportService::GetOffline(bool* offline) { + MutexAutoLock lock(mLock); + *offline = mOffline; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransportService::SetOffline(bool offline) { + MutexAutoLock lock(mLock); + if (!mOffline && offline) { + // signal the socket thread to go offline, so it will detach sockets + mGoingOffline = true; + mOffline = true; + } else if (mOffline && !offline) { + mOffline = false; + } + if (mPollableEvent) { + mPollableEvent->Signal(); + } + + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransportService::GetKeepaliveIdleTime(int32_t* aKeepaliveIdleTimeS) { + MOZ_ASSERT(aKeepaliveIdleTimeS); + if (NS_WARN_IF(!aKeepaliveIdleTimeS)) { + return NS_ERROR_NULL_POINTER; + } + *aKeepaliveIdleTimeS = mKeepaliveIdleTimeS; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransportService::GetKeepaliveRetryInterval( + int32_t* aKeepaliveRetryIntervalS) { + MOZ_ASSERT(aKeepaliveRetryIntervalS); + if (NS_WARN_IF(!aKeepaliveRetryIntervalS)) { + return NS_ERROR_NULL_POINTER; + } + *aKeepaliveRetryIntervalS = mKeepaliveRetryIntervalS; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransportService::GetKeepaliveProbeCount( + int32_t* aKeepaliveProbeCount) { + MOZ_ASSERT(aKeepaliveProbeCount); + if (NS_WARN_IF(!aKeepaliveProbeCount)) { + return NS_ERROR_NULL_POINTER; + } + *aKeepaliveProbeCount = mKeepaliveProbeCount; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransportService::CreateTransport(const nsTArray<nsCString>& types, + const nsACString& host, int32_t port, + nsIProxyInfo* proxyInfo, + nsIDNSRecord* dnsRecord, + nsISocketTransport** result) { + return CreateRoutedTransport(types, host, port, ""_ns, 0, proxyInfo, + dnsRecord, result); +} + +NS_IMETHODIMP +nsSocketTransportService::CreateRoutedTransport( + const nsTArray<nsCString>& types, const nsACString& host, int32_t port, + const nsACString& hostRoute, int32_t portRoute, nsIProxyInfo* proxyInfo, + nsIDNSRecord* dnsRecord, nsISocketTransport** result) { + NS_ENSURE_TRUE(mInitialized, NS_ERROR_NOT_INITIALIZED); + NS_ENSURE_TRUE(port >= 0 && port <= 0xFFFF, NS_ERROR_ILLEGAL_VALUE); + + RefPtr<nsSocketTransport> trans = new nsSocketTransport(); + nsresult rv = trans->Init(types, host, port, hostRoute, portRoute, proxyInfo, + dnsRecord); + if (NS_FAILED(rv)) { + return rv; + } + + trans.forget(result); + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransportService::CreateUnixDomainTransport( + nsIFile* aPath, nsISocketTransport** result) { +#ifdef XP_UNIX + nsresult rv; + + NS_ENSURE_TRUE(mInitialized, NS_ERROR_NOT_INITIALIZED); + + nsAutoCString path; + rv = aPath->GetNativePath(path); + NS_ENSURE_SUCCESS(rv, rv); + + RefPtr<nsSocketTransport> trans = new nsSocketTransport(); + + rv = trans->InitWithFilename(path.get()); + NS_ENSURE_SUCCESS(rv, rv); + + trans.forget(result); + return NS_OK; +#else + return NS_ERROR_SOCKET_ADDRESS_NOT_SUPPORTED; +#endif +} + +NS_IMETHODIMP +nsSocketTransportService::CreateUnixDomainAbstractAddressTransport( + const nsACString& aName, nsISocketTransport** result) { + // Abstract socket address is supported on Linux only +#ifdef XP_LINUX + RefPtr<nsSocketTransport> trans = new nsSocketTransport(); + // First character of Abstract socket address is null + UniquePtr<char[]> name(new char[aName.Length() + 1]); + *(name.get()) = 0; + memcpy(name.get() + 1, aName.BeginReading(), aName.Length()); + nsresult rv = trans->InitWithName(name.get(), aName.Length() + 1); + if (NS_FAILED(rv)) { + return rv; + } + + trans.forget(result); + return NS_OK; +#else + return NS_ERROR_SOCKET_ADDRESS_NOT_SUPPORTED; +#endif +} + +NS_IMETHODIMP +nsSocketTransportService::OnDispatchedEvent() { +#ifndef XP_WIN + // On windows poll can hang and this became worse when we introduced the + // patch for bug 698882 (see also bug 1292181), therefore we reverted the + // behavior on windows to be as before bug 698882, e.g. write to the socket + // also if an event dispatch is on the socket thread and writing to the + // socket for each event. + if (OnSocketThread()) { + // this check is redundant to one done inside ::Signal(), but + // we can do it here and skip obtaining the lock - given that + // this is a relatively common occurance its worth the + // redundant code + SOCKET_LOG(("OnDispatchedEvent Same Thread Skip Signal\n")); + return NS_OK; + } +#else + if (gIOService->IsNetTearingDown()) { + // Poll can hang sometimes. If we are in shutdown, we are going to + // start a watchdog. If we do not exit poll within + // REPAIR_POLLABLE_EVENT_TIME signal a pollable event again. + StartPollWatchdog(); + } +#endif + + MutexAutoLock lock(mLock); + if (mPollableEvent) { + mPollableEvent->Signal(); + } + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransportService::OnProcessNextEvent(nsIThreadInternal* thread, + bool mayWait) { + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransportService::AfterProcessNextEvent(nsIThreadInternal* thread, + bool eventWasProcessed) { + return NS_OK; +} + +void nsSocketTransportService::MarkTheLastElementOfPendingQueue() { + mServingPendingQueue = false; +} + +NS_IMETHODIMP +nsSocketTransportService::Run() { + SOCKET_LOG(("STS thread init %d sockets\n", gMaxCount)); + +#if defined(XP_WIN) + // see bug 1361495, gethostname() triggers winsock initialization. + // so do it here (on parent and child) to protect against it being done first + // accidentally on the main thread.. especially via PR_GetSystemInfo(). This + // will also improve latency of first real winsock operation + // .. + // If STS-thread is no longer needed this should still be run before exiting + + char ignoredStackBuffer[255]; + Unused << gethostname(ignoredStackBuffer, 255); +#endif + + psm::InitializeSSLServerCertVerificationThreads(); + + gSocketThread = PR_GetCurrentThread(); + + { + // See bug 1843384: + // Avoid blocking the main thread by allocating the PollableEvent outside + // the mutex. Still has the potential to hang the socket thread, but the + // main thread remains responsive. + PollableEvent* pollable = new PollableEvent(); + MutexAutoLock lock(mLock); + mPollableEvent.reset(pollable); + + // + // NOTE: per bug 190000, this failure could be caused by Zone-Alarm + // or similar software. + // + // NOTE: per bug 191739, this failure could also be caused by lack + // of a loopback device on Windows and OS/2 platforms (it creates + // a loopback socket pair on these platforms to implement a pollable + // event object). if we can't create a pollable event, then we'll + // have to "busy wait" to implement the socket event queue :-( + // + if (!mPollableEvent->Valid()) { + mPollableEvent = nullptr; + NS_WARNING("running socket transport thread without a pollable event"); + SOCKET_LOG(("running socket transport thread without a pollable event")); + } + + PRPollDesc entry = {mPollableEvent ? mPollableEvent->PollableFD() : nullptr, + PR_POLL_READ | PR_POLL_EXCEPT, 0}; + SOCKET_LOG(("Setting entry 0")); + mPollList[0] = entry; + } + + mRawThread = NS_GetCurrentThread(); + + // Ensure a call to GetCurrentSerialEventTarget() returns this event target. + SerialEventTargetGuard guard(this); + + // hook ourselves up to observe event processing for this thread + nsCOMPtr<nsIThreadInternal> threadInt = do_QueryInterface(mRawThread); + threadInt->SetObserver(this); + + // make sure the pseudo random number generator is seeded on this thread + srand(static_cast<unsigned>(PR_Now())); + + // For the calculation of the duration of the last cycle (i.e. the last + // for-loop iteration before shutdown). + TimeStamp startOfCycleForLastCycleCalc; + + // For measuring of the poll iteration duration without time spent blocked + // in poll(). + TimeStamp pollCycleStart; + // Time blocked in poll(). + TimeDuration singlePollDuration; + + // For calculating the time needed for a new element to run. + TimeStamp startOfIteration; + TimeStamp startOfNextIteration; + + // If there is too many pending events queued, we will run some poll() + // between them and the following variable is cumulative time spent + // blocking in poll(). + TimeDuration pollDuration; + + for (;;) { + bool pendingEvents = false; + if (Telemetry::CanRecordPrereleaseData()) { + startOfCycleForLastCycleCalc = TimeStamp::NowLoRes(); + startOfNextIteration = TimeStamp::NowLoRes(); + } + pollDuration = nullptr; + // We pop out to this loop when there are no pending events. + // If we don't reset these, we may not re-enter ProcessNextEvent() + // until we have events to process, and it may seem like we have + // an event running for a very long time. + mRawThread->SetRunningEventDelay(TimeDuration(), TimeStamp()); + + do { + if (Telemetry::CanRecordPrereleaseData()) { + pollCycleStart = TimeStamp::NowLoRes(); + } + + DoPollIteration(&singlePollDuration); + + if (Telemetry::CanRecordPrereleaseData() && !pollCycleStart.IsNull()) { + Telemetry::Accumulate(Telemetry::STS_POLL_BLOCK_TIME, + singlePollDuration.ToMilliseconds()); + Telemetry::AccumulateTimeDelta(Telemetry::STS_POLL_CYCLE, + pollCycleStart + singlePollDuration, + TimeStamp::NowLoRes()); + pollDuration += singlePollDuration; + } + + mRawThread->HasPendingEvents(&pendingEvents); + if (pendingEvents) { + if (!mServingPendingQueue) { + nsresult rv = Dispatch( + NewRunnableMethod( + "net::nsSocketTransportService::" + "MarkTheLastElementOfPendingQueue", + this, + &nsSocketTransportService::MarkTheLastElementOfPendingQueue), + nsIEventTarget::DISPATCH_NORMAL); + if (NS_FAILED(rv)) { + NS_WARNING( + "Could not dispatch a new event on the " + "socket thread."); + } else { + mServingPendingQueue = true; + } + + if (Telemetry::CanRecordPrereleaseData()) { + startOfIteration = startOfNextIteration; + // Everything that comes after this point will + // be served in the next iteration. If no even + // arrives, startOfNextIteration will be reset at the + // beginning of each for-loop. + startOfNextIteration = TimeStamp::NowLoRes(); + } + } + TimeStamp eventQueueStart = TimeStamp::NowLoRes(); + do { + NS_ProcessNextEvent(mRawThread); + pendingEvents = false; + mRawThread->HasPendingEvents(&pendingEvents); + } while (pendingEvents && mServingPendingQueue && + ((TimeStamp::NowLoRes() - eventQueueStart).ToMilliseconds() < + mMaxTimePerPollIter)); + + if (Telemetry::CanRecordPrereleaseData() && !mServingPendingQueue && + !startOfIteration.IsNull()) { + Telemetry::AccumulateTimeDelta(Telemetry::STS_POLL_AND_EVENTS_CYCLE, + startOfIteration + pollDuration, + TimeStamp::NowLoRes()); + pollDuration = nullptr; + } + } + } while (pendingEvents); + + bool goingOffline = false; + // now that our event queue is empty, check to see if we should exit + if (mShuttingDown) { + if (Telemetry::CanRecordPrereleaseData() && + !startOfCycleForLastCycleCalc.IsNull()) { + Telemetry::AccumulateTimeDelta( + Telemetry::STS_POLL_AND_EVENT_THE_LAST_CYCLE, + startOfCycleForLastCycleCalc, TimeStamp::NowLoRes()); + } + break; + } + { + MutexAutoLock lock(mLock); + if (mGoingOffline) { + mGoingOffline = false; + goingOffline = true; + } + } + // Avoid potential deadlock + if (goingOffline) { + Reset(true); + } + } + + SOCKET_LOG(("STS shutting down thread\n")); + + // detach all sockets, including locals + Reset(false); + + // We don't clear gSocketThread so that OnSocketThread() won't be a false + // alarm for events generated by stopping the SSL threads during shutdown. + psm::StopSSLServerCertVerificationThreads(); + + // Final pass over the event queue. This makes sure that events posted by + // socket detach handlers get processed. + NS_ProcessPendingEvents(mRawThread); + + SOCKET_LOG(("STS thread exit\n")); + MOZ_ASSERT(mPollList.Length() == 1); + MOZ_ASSERT(mActiveList.IsEmpty()); + MOZ_ASSERT(mIdleList.IsEmpty()); + + return NS_OK; +} + +void nsSocketTransportService::DetachSocketWithGuard( + bool aGuardLocals, SocketContextList& socketList, int32_t index) { + bool isGuarded = false; + if (aGuardLocals) { + socketList[index].mHandler->IsLocal(&isGuarded); + if (!isGuarded) { + socketList[index].mHandler->KeepWhenOffline(&isGuarded); + } + } + if (!isGuarded) { + DetachSocket(socketList, &socketList[index]); + } +} + +void nsSocketTransportService::Reset(bool aGuardLocals) { + // detach any sockets + int32_t i; + for (i = mActiveList.Length() - 1; i >= 0; --i) { + DetachSocketWithGuard(aGuardLocals, mActiveList, i); + } + for (i = mIdleList.Length() - 1; i >= 0; --i) { + DetachSocketWithGuard(aGuardLocals, mIdleList, i); + } +} + +nsresult nsSocketTransportService::DoPollIteration(TimeDuration* pollDuration) { + SOCKET_LOG(("STS poll iter\n")); + + PRIntervalTime now = PR_IntervalNow(); + + // We can't have more than int32_max sockets in use + int32_t i, count; + // + // poll loop + // + // walk active list backwards to see if any sockets should actually be + // idle, then walk the idle list backwards to see if any idle sockets + // should become active. take care to check only idle sockets that + // were idle to begin with ;-) + // + count = mIdleList.Length(); + for (i = mActiveList.Length() - 1; i >= 0; --i) { + //--- + SOCKET_LOG((" active [%u] { handler=%p condition=%" PRIx32 + " pollflags=%hu }\n", + i, mActiveList[i].mHandler.get(), + static_cast<uint32_t>(mActiveList[i].mHandler->mCondition), + mActiveList[i].mHandler->mPollFlags)); + //--- + if (NS_FAILED(mActiveList[i].mHandler->mCondition)) { + DetachSocket(mActiveList, &mActiveList[i]); + } else { + uint16_t in_flags = mActiveList[i].mHandler->mPollFlags; + if (in_flags == 0) { + MoveToIdleList(&mActiveList[i]); + } else { + // update poll flags + mPollList[i + 1].in_flags = in_flags; + mPollList[i + 1].out_flags = 0; + mActiveList[i].EnsureTimeout(now); + } + } + } + for (i = count - 1; i >= 0; --i) { + //--- + SOCKET_LOG((" idle [%u] { handler=%p condition=%" PRIx32 + " pollflags=%hu }\n", + i, mIdleList[i].mHandler.get(), + static_cast<uint32_t>(mIdleList[i].mHandler->mCondition), + mIdleList[i].mHandler->mPollFlags)); + //--- + if (NS_FAILED(mIdleList[i].mHandler->mCondition)) { + DetachSocket(mIdleList, &mIdleList[i]); + } else if (mIdleList[i].mHandler->mPollFlags != 0) { + MoveToPollList(&mIdleList[i]); + } + } + + { + MutexAutoLock lock(mLock); + if (mPollableEvent) { + // we want to make sure the timeout is measured from the time + // we enter poll(). This method resets the timestamp to 'now', + // if we were first signalled between leaving poll() and here. + // If we didn't do this and processing events took longer than + // the allowed signal timeout, we would detect it as a + // false-positive. AdjustFirstSignalTimestamp is then a no-op + // until mPollableEvent->Clear() is called. + mPollableEvent->AdjustFirstSignalTimestamp(); + } + } + + SOCKET_LOG((" calling PR_Poll [active=%zu idle=%zu]\n", mActiveList.Length(), + mIdleList.Length())); + + // Measures seconds spent while blocked on PR_Poll + int32_t n = 0; + *pollDuration = nullptr; + + if (!gIOService->IsNetTearingDown()) { + // Let's not do polling during shutdown. +#if defined(XP_WIN) + StartPolling(); +#endif + n = Poll(pollDuration, now); +#if defined(XP_WIN) + EndPolling(); +#endif + } + + now = PR_IntervalNow(); +#ifdef MOZ_GECKO_PROFILER + TimeStamp startTime; + bool profiling = profiler_thread_is_being_profiled_for_markers(); + if (profiling) { + startTime = TimeStamp::Now(); + } +#endif + + if (n < 0) { + SOCKET_LOG((" PR_Poll error [%d] os error [%d]\n", PR_GetError(), + PR_GetOSError())); + } else { + // + // service "active" sockets... + // + for (i = 0; i < int32_t(mActiveList.Length()); ++i) { + PRPollDesc& desc = mPollList[i + 1]; + SocketContext& s = mActiveList[i]; + if (n > 0 && desc.out_flags != 0) { + s.DisengageTimeout(); + s.mHandler->OnSocketReady(desc.fd, desc.out_flags); + } else if (s.IsTimedOut(now)) { + SOCKET_LOG(("socket %p timed out", s.mHandler.get())); + s.DisengageTimeout(); + s.mHandler->OnSocketReady(desc.fd, -1); + } else { + s.MaybeResetEpoch(); + } + } + // + // check for "dead" sockets and remove them (need to do this in + // reverse order obviously). + // + for (i = mActiveList.Length() - 1; i >= 0; --i) { + if (NS_FAILED(mActiveList[i].mHandler->mCondition)) { + DetachSocket(mActiveList, &mActiveList[i]); + } + } + + { + MutexAutoLock lock(mLock); + // acknowledge pollable event (should not block) + if (n != 0 && + (mPollList[0].out_flags & (PR_POLL_READ | PR_POLL_EXCEPT)) && + mPollableEvent && + ((mPollList[0].out_flags & PR_POLL_EXCEPT) || + !mPollableEvent->Clear())) { + // On Windows, the TCP loopback connection in the + // pollable event may become broken when a laptop + // switches between wired and wireless networks or + // wakes up from hibernation. We try to create a + // new pollable event. If that fails, we fall back + // on "busy wait". + TryRepairPollableEvent(); + } + + if (mPollableEvent && + !mPollableEvent->IsSignallingAlive(mPollableEventTimeout)) { + SOCKET_LOG(("Pollable event signalling failed/timed out")); + TryRepairPollableEvent(); + } + } + } +#ifdef MOZ_GECKO_PROFILER + if (profiling) { + TimeStamp endTime = TimeStamp::Now(); + if ((endTime - startTime).ToMilliseconds() >= SOCKET_THREAD_LONGTASK_MS) { + struct LongTaskMarker { + static constexpr Span<const char> MarkerTypeName() { + return MakeStringSpan("SocketThreadLongTask"); + } + static void StreamJSONMarkerData( + baseprofiler::SpliceableJSONWriter& aWriter) { + aWriter.StringProperty("category", "LongTask"); + } + static MarkerSchema MarkerTypeDisplay() { + using MS = MarkerSchema; + MS schema{MS::Location::MarkerChart, MS::Location::MarkerTable}; + schema.AddKeyLabelFormatSearchable("category", "Type", + MS::Format::String, + MS::Searchable::Searchable); + return schema; + } + }; + + profiler_add_marker(ProfilerString8View("LongTaskSocketProcessing"), + geckoprofiler::category::OTHER, + MarkerTiming::Interval(startTime, endTime), + LongTaskMarker{}); + } + } + +#endif + + return NS_OK; +} + +void nsSocketTransportService::UpdateSendBufferPref() { + int32_t bufferSize; + + // If the pref is set, honor it. 0 means use OS defaults. + nsresult rv = Preferences::GetInt(SEND_BUFFER_PREF, &bufferSize); + if (NS_SUCCEEDED(rv)) { + mSendBufferSize = bufferSize; + return; + } + +#if defined(XP_WIN) + mSendBufferSize = 131072 * 4; +#endif +} + +nsresult nsSocketTransportService::UpdatePrefs() { + mSendBufferSize = 0; + + UpdateSendBufferPref(); + + // Default TCP Keepalive Values. + int32_t keepaliveIdleTimeS; + nsresult rv = + Preferences::GetInt(KEEPALIVE_IDLE_TIME_PREF, &keepaliveIdleTimeS); + if (NS_SUCCEEDED(rv)) { + mKeepaliveIdleTimeS = clamped(keepaliveIdleTimeS, 1, kMaxTCPKeepIdle); + } + + int32_t keepaliveRetryIntervalS; + rv = Preferences::GetInt(KEEPALIVE_RETRY_INTERVAL_PREF, + &keepaliveRetryIntervalS); + if (NS_SUCCEEDED(rv)) { + mKeepaliveRetryIntervalS = + clamped(keepaliveRetryIntervalS, 1, kMaxTCPKeepIntvl); + } + + int32_t keepaliveProbeCount; + rv = Preferences::GetInt(KEEPALIVE_PROBE_COUNT_PREF, &keepaliveProbeCount); + if (NS_SUCCEEDED(rv)) { + mKeepaliveProbeCount = clamped(keepaliveProbeCount, 1, kMaxTCPKeepCount); + } + bool keepaliveEnabled = false; + rv = Preferences::GetBool(KEEPALIVE_ENABLED_PREF, &keepaliveEnabled); + if (NS_SUCCEEDED(rv) && keepaliveEnabled != mKeepaliveEnabledPref) { + mKeepaliveEnabledPref = keepaliveEnabled; + OnKeepaliveEnabledPrefChange(); + } + + int32_t maxTimePref; + rv = Preferences::GetInt(MAX_TIME_BETWEEN_TWO_POLLS, &maxTimePref); + if (NS_SUCCEEDED(rv) && maxTimePref >= 0) { + mMaxTimePerPollIter = maxTimePref; + } + + int32_t pollBusyWaitPeriod; + rv = Preferences::GetInt(POLL_BUSY_WAIT_PERIOD, &pollBusyWaitPeriod); + if (NS_SUCCEEDED(rv) && pollBusyWaitPeriod > 0) { + mNetworkLinkChangeBusyWaitPeriod = PR_SecondsToInterval(pollBusyWaitPeriod); + } + + int32_t pollBusyWaitPeriodTimeout; + rv = Preferences::GetInt(POLL_BUSY_WAIT_PERIOD_TIMEOUT, + &pollBusyWaitPeriodTimeout); + if (NS_SUCCEEDED(rv) && pollBusyWaitPeriodTimeout > 0) { + mNetworkLinkChangeBusyWaitTimeout = + PR_SecondsToInterval(pollBusyWaitPeriodTimeout); + } + + int32_t maxTimeForPrClosePref; + rv = Preferences::GetInt(MAX_TIME_FOR_PR_CLOSE_DURING_SHUTDOWN, + &maxTimeForPrClosePref); + if (NS_SUCCEEDED(rv) && maxTimeForPrClosePref >= 0) { + mMaxTimeForPrClosePref = PR_MillisecondsToInterval(maxTimeForPrClosePref); + } + + int32_t pollableEventTimeout; + rv = Preferences::GetInt(POLLABLE_EVENT_TIMEOUT, &pollableEventTimeout); + if (NS_SUCCEEDED(rv) && pollableEventTimeout >= 0) { + MutexAutoLock lock(mLock); + mPollableEventTimeout = TimeDuration::FromSeconds(pollableEventTimeout); + } + + nsAutoCString portMappingPref; + rv = Preferences::GetCString("network.socket.forcePort", portMappingPref); + if (NS_SUCCEEDED(rv)) { + bool rv = UpdatePortRemapPreference(portMappingPref); + if (!rv) { + NS_ERROR( + "network.socket.forcePort preference is ill-formed, this will likely " + "make everything unexpectedly fail!"); + } + } + + return NS_OK; +} + +void nsSocketTransportService::OnKeepaliveEnabledPrefChange() { + // Dispatch to socket thread if we're not executing there. + if (!OnSocketThread()) { + gSocketTransportService->Dispatch( + NewRunnableMethod( + "net::nsSocketTransportService::OnKeepaliveEnabledPrefChange", this, + &nsSocketTransportService::OnKeepaliveEnabledPrefChange), + NS_DISPATCH_NORMAL); + return; + } + + SOCKET_LOG(("nsSocketTransportService::OnKeepaliveEnabledPrefChange %s", + mKeepaliveEnabledPref ? "enabled" : "disabled")); + + // Notify each socket that keepalive has been en/disabled globally. + for (int32_t i = mActiveList.Length() - 1; i >= 0; --i) { + NotifyKeepaliveEnabledPrefChange(&mActiveList[i]); + } + for (int32_t i = mIdleList.Length() - 1; i >= 0; --i) { + NotifyKeepaliveEnabledPrefChange(&mIdleList[i]); + } +} + +void nsSocketTransportService::NotifyKeepaliveEnabledPrefChange( + SocketContext* sock) { + MOZ_ASSERT(sock, "SocketContext cannot be null!"); + MOZ_ASSERT(sock->mHandler, "SocketContext does not have a handler!"); + + if (!sock || !sock->mHandler) { + return; + } + + sock->mHandler->OnKeepaliveEnabledPrefChange(mKeepaliveEnabledPref); +} + +NS_IMETHODIMP +nsSocketTransportService::GetName(nsACString& aName) { + aName.AssignLiteral("nsSocketTransportService"); + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransportService::Observe(nsISupports* subject, const char* topic, + const char16_t* data) { + SOCKET_LOG(("nsSocketTransportService::Observe topic=%s", topic)); + + if (!strcmp(topic, "profile-initial-state")) { + if (!Preferences::GetBool(IO_ACTIVITY_ENABLED_PREF, false)) { + return NS_OK; + } + return net::IOActivityMonitor::Init(); + } + + if (!strcmp(topic, "last-pb-context-exited")) { + nsCOMPtr<nsIRunnable> ev = NewRunnableMethod( + "net::nsSocketTransportService::ClosePrivateConnections", this, + &nsSocketTransportService::ClosePrivateConnections); + nsresult rv = Dispatch(ev, nsIEventTarget::DISPATCH_NORMAL); + NS_ENSURE_SUCCESS(rv, rv); + } + + if (!strcmp(topic, NS_TIMER_CALLBACK_TOPIC)) { + nsCOMPtr<nsITimer> timer = do_QueryInterface(subject); + if (timer == mAfterWakeUpTimer) { + mAfterWakeUpTimer = nullptr; + mSleepPhase = false; + } + +#if defined(XP_WIN) + if (timer == mPollRepairTimer) { + DoPollRepair(); + } +#endif + + } else if (!strcmp(topic, NS_WIDGET_SLEEP_OBSERVER_TOPIC)) { + mSleepPhase = true; + if (mAfterWakeUpTimer) { + mAfterWakeUpTimer->Cancel(); + mAfterWakeUpTimer = nullptr; + } + } else if (!strcmp(topic, NS_WIDGET_WAKE_OBSERVER_TOPIC)) { + if (mSleepPhase && !mAfterWakeUpTimer) { + NS_NewTimerWithObserver(getter_AddRefs(mAfterWakeUpTimer), this, 2000, + nsITimer::TYPE_ONE_SHOT); + } + } else if (!strcmp(topic, "xpcom-shutdown-threads")) { + ShutdownThread(); + } else if (!strcmp(topic, NS_NETWORK_LINK_TOPIC)) { + mLastNetworkLinkChangeTime = PR_IntervalNow(); + } + + return NS_OK; +} + +void nsSocketTransportService::ClosePrivateConnections() { + MOZ_ASSERT(IsOnCurrentThread(), "Must be called on the socket thread"); + + for (int32_t i = mActiveList.Length() - 1; i >= 0; --i) { + if (mActiveList[i].mHandler->mIsPrivate) { + DetachSocket(mActiveList, &mActiveList[i]); + } + } + for (int32_t i = mIdleList.Length() - 1; i >= 0; --i) { + if (mIdleList[i].mHandler->mIsPrivate) { + DetachSocket(mIdleList, &mIdleList[i]); + } + } + + ClearPrivateSSLState(); +} + +NS_IMETHODIMP +nsSocketTransportService::GetSendBufferSize(int32_t* value) { + *value = mSendBufferSize; + return NS_OK; +} + +/// ugly OS specific includes are placed at the bottom of the src for clarity + +#if defined(XP_WIN) +# include <windows.h> +#elif defined(XP_UNIX) && !defined(AIX) && !defined(NEXTSTEP) && !defined(QNX) +# include <sys/resource.h> +#endif + +PRStatus nsSocketTransportService::DiscoverMaxCount() { + gMaxCount = SOCKET_LIMIT_MIN; + +#if defined(XP_UNIX) && !defined(AIX) && !defined(NEXTSTEP) && !defined(QNX) + // On unix and os x network sockets and file + // descriptors are the same. OS X comes defaulted at 256, + // most linux at 1000. We can reliably use [sg]rlimit to + // query that and raise it if needed. + + struct rlimit rlimitData {}; + if (getrlimit(RLIMIT_NOFILE, &rlimitData) == -1) { // rlimit broken - use min + return PR_SUCCESS; + } + + if (rlimitData.rlim_cur >= SOCKET_LIMIT_TARGET) { // larger than target! + gMaxCount = SOCKET_LIMIT_TARGET; + return PR_SUCCESS; + } + + int32_t maxallowed = rlimitData.rlim_max; + if ((uint32_t)maxallowed <= SOCKET_LIMIT_MIN) { + return PR_SUCCESS; // so small treat as if rlimit is broken + } + + if ((maxallowed == -1) || // no hard cap - ok to set target + ((uint32_t)maxallowed >= SOCKET_LIMIT_TARGET)) { + maxallowed = SOCKET_LIMIT_TARGET; + } + + rlimitData.rlim_cur = maxallowed; + setrlimit(RLIMIT_NOFILE, &rlimitData); + if ((getrlimit(RLIMIT_NOFILE, &rlimitData) != -1) && + (rlimitData.rlim_cur > SOCKET_LIMIT_MIN)) { + gMaxCount = rlimitData.rlim_cur; + } + +#elif defined(XP_WIN) && !defined(WIN_CE) + // >= XP is confirmed to have at least 1000 + static_assert(SOCKET_LIMIT_TARGET <= 1000, + "SOCKET_LIMIT_TARGET max value is 1000"); + gMaxCount = SOCKET_LIMIT_TARGET; +#else + // other platforms are harder to test - so leave at safe legacy value +#endif + + return PR_SUCCESS; +} + +// Used to return connection info to Dashboard.cpp +void nsSocketTransportService::AnalyzeConnection(nsTArray<SocketInfo>* data, + SocketContext* context, + bool aActive) { + if (context->mHandler->mIsPrivate) { + return; + } + PRFileDesc* aFD = context->mFD; + + PRFileDesc* idLayer = PR_GetIdentitiesLayer(aFD, PR_NSPR_IO_LAYER); + + NS_ENSURE_TRUE_VOID(idLayer); + + PRDescType type = PR_GetDescType(idLayer); + char host[64] = {0}; + uint16_t port; + const char* type_desc; + + if (type == PR_DESC_SOCKET_TCP) { + type_desc = "TCP"; + PRNetAddr peer_addr; + PodZero(&peer_addr); + + PRStatus rv = PR_GetPeerName(aFD, &peer_addr); + if (rv != PR_SUCCESS) { + return; + } + + rv = PR_NetAddrToString(&peer_addr, host, sizeof(host)); + if (rv != PR_SUCCESS) { + return; + } + + if (peer_addr.raw.family == PR_AF_INET) { + port = peer_addr.inet.port; + } else { + port = peer_addr.ipv6.port; + } + port = PR_ntohs(port); + } else { + if (type == PR_DESC_SOCKET_UDP) { + type_desc = "UDP"; + } else { + type_desc = "other"; + } + NetAddr addr; + if (context->mHandler->GetRemoteAddr(&addr) != NS_OK) { + return; + } + if (!addr.ToStringBuffer(host, sizeof(host))) { + return; + } + if (addr.GetPort(&port) != NS_OK) { + return; + } + } + + uint64_t sent = context->mHandler->ByteCountSent(); + uint64_t received = context->mHandler->ByteCountReceived(); + SocketInfo info = {nsCString(host), sent, received, port, aActive, + nsCString(type_desc)}; + + data->AppendElement(info); +} + +void nsSocketTransportService::GetSocketConnections( + nsTArray<SocketInfo>* data) { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + for (uint32_t i = 0; i < mActiveList.Length(); i++) { + AnalyzeConnection(data, &mActiveList[i], true); + } + for (uint32_t i = 0; i < mIdleList.Length(); i++) { + AnalyzeConnection(data, &mIdleList[i], false); + } +} + +bool nsSocketTransportService::IsTelemetryEnabledAndNotSleepPhase() { + return Telemetry::CanRecordPrereleaseData() && !mSleepPhase; +} + +#if defined(XP_WIN) +void nsSocketTransportService::StartPollWatchdog() { + // Start off the timer from a runnable off of the main thread in order to + // avoid a deadlock, see bug 1370448. + RefPtr<nsSocketTransportService> self(this); + NS_DispatchToMainThread(NS_NewRunnableFunction( + "nsSocketTransportService::StartPollWatchdog", [self] { + MutexAutoLock lock(self->mLock); + + // Poll can hang sometimes. If we are in shutdown, we are going to start + // a watchdog. If we do not exit poll within REPAIR_POLLABLE_EVENT_TIME + // signal a pollable event again. + if (gIOService->IsNetTearingDown() && self->mPolling && + !self->mPollRepairTimer) { + NS_NewTimerWithObserver(getter_AddRefs(self->mPollRepairTimer), self, + REPAIR_POLLABLE_EVENT_TIME, + nsITimer::TYPE_REPEATING_SLACK); + } + })); +} + +void nsSocketTransportService::DoPollRepair() { + MutexAutoLock lock(mLock); + if (mPolling && mPollableEvent) { + mPollableEvent->Signal(); + } else if (mPollRepairTimer) { + mPollRepairTimer->Cancel(); + } +} + +void nsSocketTransportService::StartPolling() { + MutexAutoLock lock(mLock); + mPolling = true; +} + +void nsSocketTransportService::EndPolling() { + MutexAutoLock lock(mLock); + mPolling = false; + if (mPollRepairTimer) { + mPollRepairTimer->Cancel(); + } +} + +#endif + +void nsSocketTransportService::TryRepairPollableEvent() { + mLock.AssertCurrentThreadOwns(); + + NS_WARNING("Trying to repair mPollableEvent"); + mPollableEvent.reset(new PollableEvent()); + if (!mPollableEvent->Valid()) { + mPollableEvent = nullptr; + } + SOCKET_LOG( + ("running socket transport thread without " + "a pollable event now valid=%d", + !!mPollableEvent)); + mPollList[0].fd = mPollableEvent ? mPollableEvent->PollableFD() : nullptr; + mPollList[0].in_flags = PR_POLL_READ | PR_POLL_EXCEPT; + mPollList[0].out_flags = 0; +} + +NS_IMETHODIMP +nsSocketTransportService::AddShutdownObserver( + nsISTSShutdownObserver* aObserver) { + mShutdownObservers.AppendElement(aObserver); + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransportService::RemoveShutdownObserver( + nsISTSShutdownObserver* aObserver) { + mShutdownObservers.RemoveElement(aObserver); + return NS_OK; +} + +} // namespace net +} // namespace mozilla |