Always initialize session cache locks lazily.

net/third_party/nss/ssl/sslnonce.c

 /* 
  * This file implements the CLIENT Session ID cache.  
  *
  * ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
  * 1.1 (the "License"); you may not use this file except in compliance with
  * the License. You may obtain a copy of the License at
  * http://www.mozilla.org/MPL/
@@ skipping 47 matching lines @@
 static PZLock *      cacheLock = NULL;
 
 /* sids can be in one of 4 states:
  *
  * never_cached,        created, but not yet put into cache. 
  * in_client_cache,     in the client cache's linked list.
  * in_server_cache,     entry came from the server's cache file.
  * invalid_cache        has been removed from the cache. 
  */
 
-#define LOCK_CACHE      lock_cache()
+#define LOCK_CACHE      PZ_Lock(cacheLock)
 #define UNLOCK_CACHE    PZ_Unlock(cacheLock)
 
 static SECStatus
 ssl_InitClientSessionCacheLock(void)
 {
     cacheLock = PZ_NewLock(nssILockCache);
     return cacheLock ? SECSuccess : SECFailure;
 }
 
 static SECStatus
 ssl_FreeClientSessionCacheLock(void)
 {
     if (cacheLock) {
         PZ_DestroyLock(cacheLock);
         cacheLock = NULL;
         return SECSuccess;
     }
     PORT_SetError(SEC_ERROR_NOT_INITIALIZED);
     return SECFailure;
 }
 
-static PRBool LocksInitializedEarly = PR_FALSE;
-
 static SECStatus
 FreeSessionCacheLocks()
 {
     SECStatus rv1, rv2;
     rv1 = ssl_FreeSymWrapKeysLock();
     rv2 = ssl_FreeClientSessionCacheLock();
     if ( (SECSuccess == rv1) && (SECSuccess == rv2) ) {
         return SECSuccess;
     }
     return SECFailure;
 }
 
 static SECStatus
 InitSessionCacheLocks(void)
 {
     SECStatus rv1, rv2;
     PRErrorCode rc;
     rv1 = ssl_InitSymWrapKeysLock();
     rv2 = ssl_InitClientSessionCacheLock();
     if ( (SECSuccess == rv1) && (SECSuccess == rv2) ) {
         return SECSuccess;
     }
     rc = PORT_GetError();
     FreeSessionCacheLocks();
     PORT_SetError(rc);
     return SECFailure;
 }
 
-/* free the session cache locks if they were initialized early */
-SECStatus
-ssl_FreeSessionCacheLocks()
-{
-    PORT_Assert(PR_TRUE == LocksInitializedEarly);
-    if (!LocksInitializedEarly) {
-        PORT_SetError(SEC_ERROR_NOT_INITIALIZED);
-        return SECFailure;
-    }
-    FreeSessionCacheLocks();
-    LocksInitializedEarly = PR_FALSE;
-    return SECSuccess;
-}
-
 static PRCallOnceType lockOnce;
 
 /* free the session cache locks if they were initialized lazily */
 static SECStatus ssl_ShutdownLocks(void* appData, void* nssData)
 {
-    PORT_Assert(PR_FALSE == LocksInitializedEarly);
-    if (LocksInitializedEarly) {
-        PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
-        return SECFailure;
-    }
     FreeSessionCacheLocks();
     memset(&lockOnce, 0, sizeof(lockOnce));
     return SECSuccess;
 }
 
 static PRStatus initSessionCacheLocksLazily(void)
 {
     SECStatus rv = InitSessionCacheLocks();
     if (SECSuccess != rv) {
         return PR_FAILURE;
     }
     rv = NSS_RegisterShutdown(ssl_ShutdownLocks, NULL);
     PORT_Assert(SECSuccess == rv);
     if (SECSuccess != rv) {
         return PR_FAILURE;
     }
     return PR_SUCCESS;
 }
 
-/* lazyInit means that the call is not happening during a 1-time
- * initialization function, but rather during dynamic, lazy initialization
- */
+/* the call is happening during dynamic, lazy initialization */
 SECStatus
-ssl_InitSessionCacheLocks(PRBool lazyInit)
+ssl_InitSessionCacheLocks()
 {
-    if (LocksInitializedEarly) {
-        return SECSuccess;
-    }
-
-    if (lazyInit) {
-        return (PR_SUCCESS ==
-                PR_CallOnce(&lockOnce, initSessionCacheLocksLazily)) ?
-               SECSuccess : SECFailure;
-    }
-     
-    if (SECSuccess == InitSessionCacheLocks()) {
-        LocksInitializedEarly = PR_TRUE;
-        return SECSuccess;
-    }
-
-    return SECFailure;
-}
-
-static void 
-lock_cache(void)
-{
-    ssl_InitSessionCacheLocks(PR_TRUE);
-    PZ_Lock(cacheLock);
+    return (PR_SUCCESS ==
+            PR_CallOnce(&lockOnce, initSessionCacheLocksLazily)) ?
+           SECSuccess : SECFailure;
 }
 
 /* BEWARE: This function gets called for both client and server SIDs !!
  * If the unreferenced sid is not in the cache, Free sid and its contents.
  */
 static void
 ssl_DestroySID(sslSessionID *sid)
 {
     int i;
     SSL_TRC(8, ("SSL: destroy sid: sid=0x%x cached=%d", sid, sid->cached));
@@ skipping 268 matching lines @@
     } else {
         sec->cache   = CacheSID;
         sec->uncache = LockAndUncacheSID;
     }
 }
 
 /* wipe out the entire client session cache. */
 void
 SSL_ClearSessionCache(void)
 {
+    if (!cacheLock)
+        return;      /* lock was never initialized */
     LOCK_CACHE;
     while(cache != NULL)
         UncacheSID(cache);
     UNLOCK_CACHE;
 }
 
 /* returns an unsigned int containing the number of seconds in PR_Now() */
 PRUint32
 ssl_Time(void)
 {
@@ skipping 38 matching lines @@
         sid->u.ssl3.sessionTicket.ticket.len = 0;
     }
     sid->u.ssl3.sessionTicket.received_timestamp =
         session_ticket->received_timestamp;
     sid->u.ssl3.sessionTicket.ticket_lifetime_hint =
         session_ticket->ticket_lifetime_hint;
 
     UNLOCK_CACHE;
     return SECSuccess;
 }