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

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

security/manager/ssl/src/nsSmartCardMonitor.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 "nspr.h"
 #include "pk11func.h"
 #include "nsNSSComponent.h"
 #include "nsSmartCardMonitor.h"
 #include "nsIDOMSmartCardEvent.h"
 #include "nsServiceManagerUtils.h"
 #include "mozilla/unused.h"
 using namespace mozilla;
 //
 // The SmartCard monitoring thread should start up for each module we load
 // that has removable tokens. This code calls an NSS function which waits
 // until there is a change in the token state. NSS uses the
 // C_WaitForSlotEvent() call in PKCS #11 if the module implements the call,
 // otherwise NSS will poll the token in a loop with a delay of 'latency'
 // between polls. Note that the C_WaitForSlotEvent() may wake up on any type
 // of token event, so it's necessary to filter these events down to just the
 // insertion and removal events we are looking for.
 //
 // Once the event is found, It is passed to nsNSSComponent for dispatching
 // on the UI thread, and forwarding to any interested listeners (including
 // javascript).
 //
 // self linking and removing double linked entry
 // adopts the thread it is passed.
 class SmartCardThreadEntry {
 public:
  SmartCardThreadEntry *next;
  SmartCardThreadEntry *prev;
  SmartCardThreadEntry **head;
  SmartCardMonitoringThread *thread;
  SmartCardThreadEntry(SmartCardMonitoringThread *thread_,
    SmartCardThreadEntry *next_, SmartCardThreadEntry *prev_,
    SmartCardThreadEntry **head_) :
    next(next_), prev(prev_), head(head_), thread(thread_) {
     if (prev) { prev->next = this; } else { *head = this; }
     if (next) { next->prev = this; }
   }
   ~SmartCardThreadEntry() {
     if (prev) { prev->next = next; } else { *head = next; }
     if (next) { next->prev = prev; }
     // NOTE: automatically stops the thread
     delete thread;
   }
 };
 //
 // SmartCardThreadList is a class to help manage the running threads.
 // That way new threads could be started and old ones terminated as we
 // load and unload modules.
 //
 SmartCardThreadList::SmartCardThreadList() : head(0)
 {
 }
 SmartCardThreadList::~SmartCardThreadList()
 {
   // the head is self linking and unlinking, the following
   // loop removes all entries on the list.
   // it will also stop the thread if it happens to be running
   while (head) {
     delete head;
   }
 }
 void
 SmartCardThreadList::Remove(SECMODModule *aModule)
 {
   for (SmartCardThreadEntry *current = head; current; current = current->next) {
     if (current->thread->GetModule() == aModule) {
       // NOTE: automatically stops the thread and dequeues it from the list
       delete current;
       return;
     }
   }
 }
 // adopts the thread passed to it. Starts the thread as well
 nsresult
 SmartCardThreadList::Add(SmartCardMonitoringThread *thread)
 {
   SmartCardThreadEntry *current = new SmartCardThreadEntry(thread, head, nullptr,
                                                            &head);
   // OK to forget current here, it's on the list.
   unused << current;
   return thread->Start();
 }
 // We really should have a Unity PL Hash function...
 static PLHashNumber
 unity(const void *key) { return PLHashNumber(NS_PTR_TO_INT32(key)); }
 SmartCardMonitoringThread::SmartCardMonitoringThread(SECMODModule *module_)
   : mThread(nullptr)
 {
   mModule = SECMOD_ReferenceModule(module_);
   // simple hash functions, most modules have less than 3 slots, so 10 buckets
   // should be plenty
   mHash = PL_NewHashTable(10, unity, PL_CompareValues,
                            PL_CompareStrings, nullptr, 0);
 }
 //
 // when we shutdown the thread, be sure to stop it first. If not, it just might
 // crash when the mModule it is looking at disappears.
 //
 SmartCardMonitoringThread::~SmartCardMonitoringThread()
 {
   Stop();
   SECMOD_DestroyModule(mModule);
   if (mHash) {
     PL_HashTableDestroy(mHash);
   }
 }
 nsresult
 SmartCardMonitoringThread::Start()
 {
   if (!mThread) {
     mThread = PR_CreateThread(PR_SYSTEM_THREAD, LaunchExecute, this,
                               PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
                               PR_JOINABLE_THREAD, 0);
   }
   return mThread ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
 }
 //
 // Should only stop if we are through with the module.
 // CancelWait has the side effect of losing all the keys and
 // current operations on the module!. (See the comment in
 // SECMOD_CancelWait for why this is so..).
 //
 void SmartCardMonitoringThread::Stop()
 {
   SECStatus rv;
   rv = SECMOD_CancelWait(mModule);
   if (rv != SECSuccess) {
     // we didn't wake up the Wait, so don't try to join the thread
     // otherwise we will hang forever...
     return;
   }
   // confused about the memory model here? NSPR owns the memory for
   // threads. non-joinable threads are freed when the thread dies.
   // joinable threads are freed after the call to PR_JoinThread.
   // That means if SECMOD_CancelWait fails, we'll leak the mThread
   // structure. this is considered preferable to hanging (which is
   // what will happen if we try to join a thread that blocked).
   if (mThread) {
     PR_JoinThread(mThread);
     mThread = 0;
   }
 }
 //
 // remember the name and series of a token in a particular slot.
 // This is important because the name is no longer available when
 // the token is removed. If listeners depended on this information,
 // They would be out of luck. It also is a handy way of making sure
 // we don't generate spurious insertion and removal events as the slot
 // cycles through various states.
 //
 void
 SmartCardMonitoringThread::SetTokenName(CK_SLOT_ID slotid,
                                        const char *tokenName, uint32_t series)
 {
   if (mHash) {
     if (tokenName) {
       int len = strlen(tokenName) + 1;
       /* this must match the allocator used in
        * PLHashAllocOps.freeEntry DefaultFreeEntry */
       char *entry = (char *)PR_Malloc(len+sizeof(uint32_t));
       if (entry) {
         memcpy(entry,&series,sizeof(uint32_t));
         memcpy(&entry[sizeof(uint32_t)],tokenName,len);
         PL_HashTableAdd(mHash,(void *)(uintptr_t)slotid, entry); /* adopt */
         return;
       }
     }
     else {
       // if tokenName was not provided, remove the old one (implicit delete)
       PL_HashTableRemove(mHash,(void *)(uintptr_t)slotid);
     }
   }
 }
 // retrieve the name saved above
 const char *
 SmartCardMonitoringThread::GetTokenName(CK_SLOT_ID slotid)
 {
   const char *tokenName = nullptr;
   const char *entry;
   if (mHash) {
     entry = (const char *)PL_HashTableLookupConst(mHash,(void *)(uintptr_t)slotid);
     if (entry) {
       tokenName = &entry[sizeof(uint32_t)];
     }
   }
   return tokenName;
 }
 // retrieve the series saved in SetTokenName above
 uint32_t
 SmartCardMonitoringThread::GetTokenSeries(CK_SLOT_ID slotid)
 {
   uint32_t series = 0;
   const char *entry;
   if (mHash) {
     entry = (const char *)PL_HashTableLookupConst(mHash,(void *)(uintptr_t)slotid);
     if (entry) {
       memcpy(&series,entry,sizeof(uint32_t));
     }
   }
   return series;
 }
 //
 // helper function to pass the event off to nsNSSComponent.
 //
 nsresult
 SmartCardMonitoringThread::SendEvent(const nsAString &eventType,
                                      const char *tokenName)
 {
   static NS_DEFINE_CID(kNSSComponentCID, NS_NSSCOMPONENT_CID);
   nsresult rv;
   nsCOMPtr<nsINSSComponent>
                     nssComponent(do_GetService(kNSSComponentCID, &rv));
   if (NS_FAILED(rv))
     return rv;
   // NSS returns actual UTF8, not ASCII
   nssComponent->PostEvent(eventType, NS_ConvertUTF8toUTF16(tokenName));
   return NS_OK;
 }
 //
 // This is the main loop.
 //
 void SmartCardMonitoringThread::Execute()
 {
   PK11SlotInfo *slot;
   const char *tokenName = nullptr;
   //
   // populate token names for already inserted tokens.
   //
   PK11SlotList *sl =
             PK11_FindSlotsByNames(mModule->dllName, nullptr, nullptr, true);
   PK11SlotListElement *sle;
   if (sl) {
     for (sle=PK11_GetFirstSafe(sl); sle;
                                       sle=PK11_GetNextSafe(sl,sle,false)) {
       SetTokenName(PK11_GetSlotID(sle->slot),
                   PK11_GetTokenName(sle->slot), PK11_GetSlotSeries(sle->slot));
     }
     PK11_FreeSlotList(sl);
   }
   // loop starts..
   do {
     slot = SECMOD_WaitForAnyTokenEvent(mModule, 0, PR_SecondsToInterval(1)  );
     if (!slot) {
       break;
     }
     // now we have a potential insertion or removal event, see if the slot
     // is present to determine which it is...
     if (PK11_IsPresent(slot)) {
       // insertion
       CK_SLOT_ID slotID = PK11_GetSlotID(slot);
       uint32_t series = PK11_GetSlotSeries(slot);
       // skip spurious insertion events...
       if (series != GetTokenSeries(slotID)) {
         // if there's a token name, then we have not yet issued a remove
         // event for the previous token, do so now...
         tokenName = GetTokenName(slotID);
         if (tokenName) {
           SendEvent(NS_LITERAL_STRING(SMARTCARDEVENT_REMOVE), tokenName);
         }
         tokenName = PK11_GetTokenName(slot);
         // save the token name and series
         SetTokenName(slotID, tokenName, series);
         SendEvent(NS_LITERAL_STRING(SMARTCARDEVENT_INSERT), tokenName);
       }
     } else {
       // retrieve token name
       CK_SLOT_ID slotID = PK11_GetSlotID(slot);
       tokenName = GetTokenName(slotID);
       // if there's not a token name, then the software isn't expecting
       // a (or another) remove event.
       if (tokenName) {
         SendEvent(NS_LITERAL_STRING(SMARTCARDEVENT_REMOVE), tokenName);
         // clear the token name (after we send it)
         SetTokenName(slotID, nullptr, 0);
       }
     }
     PK11_FreeSlot(slot);
   } while (1);
 }
 // accessor to help searching active Monitoring threads
 const SECMODModule * SmartCardMonitoringThread::GetModule()
 {
   return mModule;
 }
 // C-like calling sequence to glue into PR_CreateThread.
 void SmartCardMonitoringThread::LaunchExecute(void *arg)
 {
   PR_SetCurrentThreadName("SmartCard");
   ((SmartCardMonitoringThread*)arg)->Execute();
 }

The Tor Browser / annotate

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

security/manager/ssl/src/nsSmartCardMonitor.cpp