The Tor Browser: security/manager/ssl/src/nsNSSShutDown.cpp@6474c204b198 (annotated)

security/manager/ssl/src/nsNSSShutDown.cpp@6474c204b198 (annotated)

security/manager/ssl/src/nsNSSShutDown.cpp

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

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

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

 /* 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 "nsNSSShutDown.h"
 #include "nsCOMPtr.h"
 using namespace mozilla;
 #ifdef PR_LOGGING
 extern PRLogModuleInfo* gPIPNSSLog;
 #endif
 struct ObjectHashEntry : PLDHashEntryHdr {
   nsNSSShutDownObject *obj;
 };
 static bool
 ObjectSetMatchEntry(PLDHashTable *table, const PLDHashEntryHdr *hdr,
                          const void *key)
 {
   const ObjectHashEntry *entry = static_cast<const ObjectHashEntry*>(hdr);
   return entry->obj == static_cast<const nsNSSShutDownObject*>(key);
 }
 static bool
 ObjectSetInitEntry(PLDHashTable *table, PLDHashEntryHdr *hdr,
                      const void *key)
 {
   ObjectHashEntry *entry = static_cast<ObjectHashEntry*>(hdr);
   entry->obj = const_cast<nsNSSShutDownObject*>(static_cast<const nsNSSShutDownObject*>(key));
   return true;
 }
 static const PLDHashTableOps gSetOps = {
   PL_DHashAllocTable,
   PL_DHashFreeTable,
   PL_DHashVoidPtrKeyStub,
   ObjectSetMatchEntry,
   PL_DHashMoveEntryStub,
   PL_DHashClearEntryStub,
   PL_DHashFinalizeStub,
   ObjectSetInitEntry
 };
 nsNSSShutDownList *nsNSSShutDownList::singleton = nullptr;
 nsNSSShutDownList::nsNSSShutDownList()
 :mListLock("nsNSSShutDownList.mListLock")
 {
   mActiveSSLSockets = 0;
   mPK11LogoutCancelObjects.ops = nullptr;
   mObjects.ops = nullptr;
   PL_DHashTableInit(&mObjects, &gSetOps, nullptr,
                     sizeof(ObjectHashEntry), 16);
   PL_DHashTableInit(&mPK11LogoutCancelObjects, &gSetOps, nullptr,
                     sizeof(ObjectHashEntry), 16);
 }
 nsNSSShutDownList::~nsNSSShutDownList()
 {
   if (mObjects.ops) {
     PL_DHashTableFinish(&mObjects);
     mObjects.ops = nullptr;
   }
   if (mPK11LogoutCancelObjects.ops) {
     PL_DHashTableFinish(&mPK11LogoutCancelObjects);
     mPK11LogoutCancelObjects.ops = nullptr;
   }
   PR_ASSERT(this == singleton);
   singleton = nullptr;
 }
 void nsNSSShutDownList::remember(nsNSSShutDownObject *o)
 {
   if (!singleton)
     return;
   PR_ASSERT(o);
   MutexAutoLock lock(singleton->mListLock);
     PL_DHashTableOperate(&singleton->mObjects, o, PL_DHASH_ADD);
 }
 void nsNSSShutDownList::forget(nsNSSShutDownObject *o)
 {
   if (!singleton)
     return;
   PR_ASSERT(o);
   MutexAutoLock lock(singleton->mListLock);
   PL_DHashTableOperate(&singleton->mObjects, o, PL_DHASH_REMOVE);
 }
 void nsNSSShutDownList::remember(nsOnPK11LogoutCancelObject *o)
 {
   if (!singleton)
     return;
   PR_ASSERT(o);
   MutexAutoLock lock(singleton->mListLock);
   PL_DHashTableOperate(&singleton->mPK11LogoutCancelObjects, o, PL_DHASH_ADD);
 }
 void nsNSSShutDownList::forget(nsOnPK11LogoutCancelObject *o)
 {
   if (!singleton)
     return;
   PR_ASSERT(o);
   MutexAutoLock lock(singleton->mListLock);
   PL_DHashTableOperate(&singleton->mPK11LogoutCancelObjects, o, PL_DHASH_REMOVE);
 }
 void nsNSSShutDownList::trackSSLSocketCreate()
 {
   if (!singleton)
     return;
   MutexAutoLock lock(singleton->mListLock);
   ++singleton->mActiveSSLSockets;
 }
 void nsNSSShutDownList::trackSSLSocketClose()
 {
   if (!singleton)
     return;
   MutexAutoLock lock(singleton->mListLock);
   --singleton->mActiveSSLSockets;
 }
 bool nsNSSShutDownList::areSSLSocketsActive()
 {
   if (!singleton) {
     // I'd rather prefer to be pessimistic and return true.
     // However, maybe we will get called at a time when the singleton
     // has already been freed, and returning true would bring up an
     // unnecessary warning.
     return false;
   }
   MutexAutoLock lock(singleton->mListLock);
   return (singleton->mActiveSSLSockets > 0);
 }
 nsresult nsNSSShutDownList::doPK11Logout()
 {
     PR_LOG(gPIPNSSLog, PR_LOG_DEBUG, ("canceling all open SSL sockets to disallow future IO\n"));
   // During our iteration we will set a bunch of PRBools to true.
   // Nobody else ever modifies that bool, only we do.
   // We only must ensure that our objects do not go away.
   // This is guaranteed by holding the list lock.
   MutexAutoLock lock(singleton->mListLock);
   PL_DHashTableEnumerate(&mPK11LogoutCancelObjects, doPK11LogoutHelper, 0);
   return NS_OK;
 }
 PLDHashOperator
 nsNSSShutDownList::doPK11LogoutHelper(PLDHashTable *table,
   PLDHashEntryHdr *hdr, uint32_t number, void *arg)
 {
   ObjectHashEntry *entry = static_cast<ObjectHashEntry*>(hdr);
   nsOnPK11LogoutCancelObject *pklco =
     reinterpret_cast<nsOnPK11LogoutCancelObject*>(entry->obj);
   if (pklco) {
     pklco->logout();
   }
   return PL_DHASH_NEXT;
 }
 bool nsNSSShutDownList::isUIActive()
 {
   bool canDisallow = mActivityState.ifPossibleDisallowUI(nsNSSActivityState::test_only);
   bool bIsUIActive = !canDisallow;
   return bIsUIActive;
 }
 bool nsNSSShutDownList::ifPossibleDisallowUI()
 {
   bool isNowDisallowed = mActivityState.ifPossibleDisallowUI(nsNSSActivityState::do_it_for_real);
   return isNowDisallowed;
 }
 void nsNSSShutDownList::allowUI()
 {
   mActivityState.allowUI();
 }
 nsresult nsNSSShutDownList::evaporateAllNSSResources()
 {
   if (PR_SUCCESS != mActivityState.restrictActivityToCurrentThread()) {
     PR_LOG(gPIPNSSLog, PR_LOG_DEBUG, ("failed to restrict activity to current thread\n"));
     return NS_ERROR_FAILURE;
   }
   PR_LOG(gPIPNSSLog, PR_LOG_DEBUG, ("now evaporating NSS resources\n"));
   int removedCount;
   do {
     MutexAutoLock lock(mListLock);
     removedCount = PL_DHashTableEnumerate(&mObjects, evaporateAllNSSResourcesHelper, 0);
   } while (removedCount > 0);
   mActivityState.releaseCurrentThreadActivityRestriction();
   return NS_OK;
 }
 PLDHashOperator
 nsNSSShutDownList::evaporateAllNSSResourcesHelper(PLDHashTable *table,
   PLDHashEntryHdr *hdr, uint32_t number, void *arg)
 {
   ObjectHashEntry *entry = static_cast<ObjectHashEntry*>(hdr);
   {
     MutexAutoUnlock unlock(singleton->mListLock);
     entry->obj->shutdown(nsNSSShutDownObject::calledFromList);
   }
   // Never free more than one entry, because other threads might be calling
   // us and remove themselves while we are iterating over the list,
   // and the behaviour of changing the list while iterating is undefined.
   return (PLDHashOperator)(PL_DHASH_STOP | PL_DHASH_REMOVE);
 }
 nsNSSShutDownList *nsNSSShutDownList::construct()
 {
   if (singleton) {
     // we should never ever be called twice
     return nullptr;
   }
   singleton = new nsNSSShutDownList();
   return singleton;
 }
 nsNSSActivityState::nsNSSActivityState()
 :mNSSActivityStateLock("nsNSSActivityState.mNSSActivityStateLock"),
  mNSSActivityChanged(mNSSActivityStateLock,
                      "nsNSSActivityState.mNSSActivityStateLock"),
  mNSSActivityCounter(0),
  mBlockingUICounter(0),
  mIsUIForbidden(false),
  mNSSRestrictedThread(nullptr)
 {
 }
 nsNSSActivityState::~nsNSSActivityState()
 {
 }
 void nsNSSActivityState::enter()
 {
   MutexAutoLock lock(mNSSActivityStateLock);
   while (mNSSRestrictedThread && mNSSRestrictedThread != PR_GetCurrentThread()) {
     mNSSActivityChanged.Wait();
   }
   ++mNSSActivityCounter;
 }
 void nsNSSActivityState::leave()
 {
   MutexAutoLock lock(mNSSActivityStateLock);
   --mNSSActivityCounter;
   mNSSActivityChanged.NotifyAll();
 }
 void nsNSSActivityState::enterBlockingUIState()
 {
   MutexAutoLock lock(mNSSActivityStateLock);
   ++mBlockingUICounter;
 }
 void nsNSSActivityState::leaveBlockingUIState()
 {
   MutexAutoLock lock(mNSSActivityStateLock);
   --mBlockingUICounter;
 }
 bool nsNSSActivityState::isBlockingUIActive()
 {
   MutexAutoLock lock(mNSSActivityStateLock);
   return (mBlockingUICounter > 0);
 }
 bool nsNSSActivityState::isUIForbidden()
 {
   MutexAutoLock lock(mNSSActivityStateLock);
   return mIsUIForbidden;
 }
 bool nsNSSActivityState::ifPossibleDisallowUI(RealOrTesting rot)
 {
   bool retval = false;
   MutexAutoLock lock(mNSSActivityStateLock);
   // Checking and disallowing the UI must be done atomically.
   if (!mBlockingUICounter) {
     // No UI is currently shown, we are able to evaporate.
     retval = true;
     if (rot == do_it_for_real) {
       // Remember to disallow UI.
       mIsUIForbidden = true;
       // to clear the "forbidden" state,
       // one must either call
       // restrictActivityToCurrentThread() + releaseCurrentThreadActivityRestriction()
       // or cancel the operation by calling
       // unprepareCurrentThreadRestriction()
     }
   }
   return retval;
 }
 void nsNSSActivityState::allowUI()
 {
   MutexAutoLock lock(mNSSActivityStateLock);
   mIsUIForbidden = false;
 }
 PRStatus nsNSSActivityState::restrictActivityToCurrentThread()
 {
   PRStatus retval = PR_FAILURE;
   MutexAutoLock lock(mNSSActivityStateLock);
   if (!mBlockingUICounter) {
     while (0 < mNSSActivityCounter && !mBlockingUICounter) {
       mNSSActivityChanged.Wait(PR_TicksPerSecond());
     }
     if (mBlockingUICounter) {
       // This should never happen.
       // If we arrive here, our logic is broken.
       PR_ASSERT(0);
     }
     else {
       mNSSRestrictedThread = PR_GetCurrentThread();
       retval = PR_SUCCESS;
     }
   }
   return retval;
 }
 void nsNSSActivityState::releaseCurrentThreadActivityRestriction()
 {
   MutexAutoLock lock(mNSSActivityStateLock);
   mNSSRestrictedThread = nullptr;
   mIsUIForbidden = false;
   mNSSActivityChanged.NotifyAll();
 }
 nsNSSShutDownPreventionLock::nsNSSShutDownPreventionLock()
 {
   nsNSSActivityState *state = nsNSSShutDownList::getActivityState();
   if (!state)
     return;
   state->enter();
 }
 nsNSSShutDownPreventionLock::~nsNSSShutDownPreventionLock()
 {
   nsNSSActivityState *state = nsNSSShutDownList::getActivityState();
   if (!state)
     return;
   state->leave();
 }
 nsPSMUITracker::nsPSMUITracker()
 {
   nsNSSActivityState *state = nsNSSShutDownList::getActivityState();
   if (!state)
     return;
   state->enterBlockingUIState();
 }
 nsPSMUITracker::~nsPSMUITracker()
 {
   nsNSSActivityState *state = nsNSSShutDownList::getActivityState();
   if (!state)
     return;
   state->leaveBlockingUIState();
 }
 bool nsPSMUITracker::isUIForbidden()
 {
   nsNSSActivityState *state = nsNSSShutDownList::getActivityState();
   if (!state)
     return false;
   return state->isUIForbidden();
 }

The Tor Browser / annotate

security/manager/ssl/src/nsNSSShutDown.cpp@6474c204b198 (annotated)

security/manager/ssl/src/nsNSSShutDown.cpp