Uprev NSS (in libssl) to NSS 3.21

net/third_party/nss/ssl/sslsnce.c

 /* This file implements the SERVER Session ID cache. 
  * NOTE:  The contents of this file are NOT used by the client.
  *
  * 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/. */
 
 /* Note: ssl_FreeSID() in sslnonce.c gets used for both client and server 
  * cache sids!
  *
@@ skipping 102 matching lines @@
 /*  1 */    PRUint8     masterKeyLen;
 /*  1 */    PRUint8     keyBits;
 /*  1 */    PRUint8     secretKeyBits;
 /*  1 */    PRUint8     cipherArgLen;
 /*101 */} ssl2;
 
         struct {
 /*  2 */    ssl3CipherSuite  cipherSuite;
 /*  2 */    PRUint16    compression;    /* SSLCompressionMethod */
 
-/* 52 */    ssl3SidKeys keys;   /* keys, wrapped as needed. */
+/* 54 */    ssl3SidKeys keys;   /* keys, wrapped as needed. */
 
 /*  4 */    PRUint32    masterWrapMech; 
 /*  4 */    SSL3KEAType exchKeyType;
 /*  4 */    PRInt32     certIndex;
 /*  4 */    PRInt32     srvNameIndex;
 /* 32 */    PRUint8     srvNameHash[SHA256_LENGTH]; /* SHA256 name hash */
-/*104 */} ssl3;
+/*108 */} ssl3;
 /* force sizeof(sidCacheEntry) to be a multiple of cache line size */
         struct {
 /*120 */    PRUint8     filler[120]; /* 72+120==192, a multiple of 16 */
         } forceSize;
     } u;
 };
 typedef struct sidCacheEntryStr sidCacheEntry;
 
 /* The length of this struct is supposed to be a power of 2, e.g. 4KB */
 struct certCacheEntryStr {
@@ skipping 359 matching lines @@
         /* This is an SSL v3 session */
 
         to->u.ssl3.cipherSuite      = from->u.ssl3.cipherSuite;
         to->u.ssl3.compression      = (PRUint16)from->u.ssl3.compression;
         to->u.ssl3.keys             = from->u.ssl3.keys;
         to->u.ssl3.masterWrapMech   = from->u.ssl3.masterWrapMech;
         to->u.ssl3.exchKeyType      = from->u.ssl3.exchKeyType;
         to->sessionIDLength         = from->u.ssl3.sessionIDLength;
         to->u.ssl3.certIndex        = -1;
         to->u.ssl3.srvNameIndex     = -1;
-
         PORT_Memcpy(to->sessionID, from->u.ssl3.sessionID,
                     to->sessionIDLength);
 
         SSL_TRC(8, ("%d: SSL3: ConvertSID: time=%d addr=0x%08x%08x%08x%08x "
                     "cipherSuite=%d",
                     myPid, to->creationTime, to->addr.pr_s6_addr32[0],
                     to->addr.pr_s6_addr32[1], to->addr.pr_s6_addr32[2],
                     to->addr.pr_s6_addr32[3], to->u.ssl3.cipherSuite));
     }
 }
@@ skipping 109 matching lines @@
     to->creationTime    = from->creationTime;
     to->lastAccessTime  = from->lastAccessTime;
     to->expirationTime  = from->expirationTime;
     to->cached          = in_server_cache;
     to->addr            = from->addr;
     to->references      = 1;
     to->authAlgorithm   = from->authAlgorithm;
     to->authKeyBits     = from->authKeyBits;
     to->keaType         = from->keaType;
     to->keaKeyBits      = from->keaKeyBits;
-    
+
     return to;
 
   loser:
     if (to) {
         if (version < SSL_LIBRARY_VERSION_3_0) {
             if (to->u.ssl2.masterKey.data)
                 PORT_Free(to->u.ssl2.masterKey.data);
             if (to->u.ssl2.cipherArg.data)
                 PORT_Free(to->u.ssl2.cipherArg.data);
         } else {
@@ skipping 570 matching lines @@
     memcpy(cacheMem, cache, sizeof *cache);
 
     /* save private copies of these values */
     cache->cacheMemMap = cacheMemMap;
     cache->cacheMem    = cacheMem;
     cache->sharedCache = (cacheDesc *)cacheMem;
 
     /* Fix pointers in our private copy of cache descriptor to point to 
     ** spaces in shared memory 
     */
-    ptr = (ptrdiff_t)cache->cacheMem;
-    *(ptrdiff_t *)(&cache->sidCacheLocks) += ptr;
-    *(ptrdiff_t *)(&cache->keyCacheLock ) += ptr;
-    *(ptrdiff_t *)(&cache->certCacheLock) += ptr;
-    *(ptrdiff_t *)(&cache->srvNameCacheLock) += ptr;
-    *(ptrdiff_t *)(&cache->sidCacheSets ) += ptr;
-    *(ptrdiff_t *)(&cache->sidCacheData ) += ptr;
-    *(ptrdiff_t *)(&cache->certCacheData) += ptr;
-    *(ptrdiff_t *)(&cache->keyCacheData ) += ptr;
-    *(ptrdiff_t *)(&cache->ticketKeyNameSuffix) += ptr;
-    *(ptrdiff_t *)(&cache->ticketEncKey ) += ptr;
-    *(ptrdiff_t *)(&cache->ticketMacKey ) += ptr;
-    *(ptrdiff_t *)(&cache->ticketKeysValid) += ptr;
-    *(ptrdiff_t *)(&cache->srvNameCacheData) += ptr;
+    cache->sidCacheLocks = (sidCacheLock *)
+        (cache->cacheMem + (ptrdiff_t)cache->sidCacheLocks);
+    cache->keyCacheLock = (sidCacheLock *)
+        (cache->cacheMem + (ptrdiff_t)cache->keyCacheLock);
+    cache->certCacheLock = (sidCacheLock *)
+        (cache->cacheMem + (ptrdiff_t)cache->certCacheLock);
+    cache->srvNameCacheLock = (sidCacheLock *)
+        (cache->cacheMem + (ptrdiff_t)cache->srvNameCacheLock);
+    cache->sidCacheSets = (sidCacheSet *)
+        (cache->cacheMem + (ptrdiff_t)cache->sidCacheSets);
+    cache->sidCacheData = (sidCacheEntry *)
+        (cache->cacheMem + (ptrdiff_t)cache->sidCacheData);
+    cache->certCacheData = (certCacheEntry *)
+        (cache->cacheMem + (ptrdiff_t)cache->certCacheData);
+    cache->keyCacheData = (SSLWrappedSymWrappingKey *)
+        (cache->cacheMem + (ptrdiff_t)cache->keyCacheData);
+    cache->ticketKeyNameSuffix = (PRUint8 *)
+        (cache->cacheMem + (ptrdiff_t)cache->ticketKeyNameSuffix);
+    cache->ticketEncKey = (encKeyCacheEntry *)
+        (cache->cacheMem + (ptrdiff_t)cache->ticketEncKey);
+    cache->ticketMacKey = (encKeyCacheEntry *)
+        (cache->cacheMem + (ptrdiff_t)cache->ticketMacKey);
+    cache->ticketKeysValid = (PRUint32 *)
+        (cache->cacheMem + (ptrdiff_t)cache->ticketKeysValid);
+    cache->srvNameCacheData = (srvNameCacheEntry *)
+        (cache->cacheMem + (ptrdiff_t)cache->srvNameCacheData);
 
     /* initialize the locks */
     init_time = ssl_Time();
     pLock = cache->sidCacheLocks;
     for (locks_to_initialize = cache->numSIDCacheLocks + 3;
          locks_initialized < locks_to_initialize; 
          ++locks_initialized, ++pLock ) {
 
         SECStatus err = sslMutex_Init(&pLock->mutex, shared);
         if (err) {
@@ skipping 222 matching lines @@
     }
 }
 
 SECStatus
 SSL_InheritMPServerSIDCacheInstance(cacheDesc *cache, const char * envString)
 {
     unsigned char * decoString = NULL;
     char *          fmString   = NULL;
     char *          myEnvString = NULL;
     unsigned int    decoLen;
-    ptrdiff_t       ptr;
     inheritance     inherit;
     cacheDesc       my;
 #ifdef WINNT
     sidCacheLock* newLocks;
     int           locks_initialized = 0;
     int           locks_to_initialize = 0;
 #endif
     SECStatus     status = ssl_Init();
 
     if (status != SECSuccess) {
@@ skipping 75 matching lines @@
     ** cache->cacheMem computed just above.  So, we copy cache into 
     ** the automatic variable "my", to preserve the variables while
     ** cache is overwritten.
     */
     my = *cache;  /* save values computed above. */
     memcpy(cache, cache->sharedCache, sizeof *cache); /* overwrite */
 
     /* Fix pointers in our private copy of cache descriptor to point to 
     ** spaces in shared memory, whose address is now in "my".
     */
-    ptr = (ptrdiff_t)my.cacheMem;
-    *(ptrdiff_t *)(&cache->sidCacheLocks) += ptr;
-    *(ptrdiff_t *)(&cache->keyCacheLock ) += ptr;
-    *(ptrdiff_t *)(&cache->certCacheLock) += ptr;
-    *(ptrdiff_t *)(&cache->srvNameCacheLock) += ptr;
-    *(ptrdiff_t *)(&cache->sidCacheSets ) += ptr;
-    *(ptrdiff_t *)(&cache->sidCacheData ) += ptr;
-    *(ptrdiff_t *)(&cache->certCacheData) += ptr;
-    *(ptrdiff_t *)(&cache->keyCacheData ) += ptr;
-    *(ptrdiff_t *)(&cache->ticketKeyNameSuffix) += ptr;
-    *(ptrdiff_t *)(&cache->ticketEncKey ) += ptr;
-    *(ptrdiff_t *)(&cache->ticketMacKey ) += ptr;
-    *(ptrdiff_t *)(&cache->ticketKeysValid) += ptr;
-    *(ptrdiff_t *)(&cache->srvNameCacheData) += ptr;
+    cache->sidCacheLocks = (sidCacheLock *)
+        (my.cacheMem + (ptrdiff_t)cache->sidCacheLocks);
+    cache->keyCacheLock = (sidCacheLock *)
+        (my.cacheMem + (ptrdiff_t)cache->keyCacheLock);
+    cache->certCacheLock = (sidCacheLock *)
+        (my.cacheMem + (ptrdiff_t)cache->certCacheLock);
+    cache->srvNameCacheLock = (sidCacheLock *)
+        (my.cacheMem + (ptrdiff_t)cache->srvNameCacheLock);
+    cache->sidCacheSets = (sidCacheSet *)
+        (my.cacheMem + (ptrdiff_t)cache->sidCacheSets);
+    cache->sidCacheData = (sidCacheEntry *)
+        (my.cacheMem + (ptrdiff_t)cache->sidCacheData);
+    cache->certCacheData = (certCacheEntry *)
+        (my.cacheMem + (ptrdiff_t)cache->certCacheData);
+    cache->keyCacheData = (SSLWrappedSymWrappingKey *)
+        (my.cacheMem + (ptrdiff_t)cache->keyCacheData);
+    cache->ticketKeyNameSuffix = (PRUint8 *)
+        (my.cacheMem + (ptrdiff_t)cache->ticketKeyNameSuffix);
+    cache->ticketEncKey = (encKeyCacheEntry *)
+        (my.cacheMem + (ptrdiff_t)cache->ticketEncKey);
+    cache->ticketMacKey = (encKeyCacheEntry *)
+        (my.cacheMem + (ptrdiff_t)cache->ticketMacKey);
+    cache->ticketKeysValid = (PRUint32 *)
+        (my.cacheMem + (ptrdiff_t)cache->ticketKeysValid);
+    cache->srvNameCacheData = (srvNameCacheEntry *)
+        (my.cacheMem + (ptrdiff_t)cache->srvNameCacheData);
 
     cache->cacheMemMap = my.cacheMemMap;
     cache->cacheMem    = my.cacheMem;
     cache->sharedCache = (cacheDesc *)cache->cacheMem;
 
 #ifdef WINNT
     /*  On Windows NT we need to "fix" the sidCacheLocks here to support fibers
     **  When NT fibers are used in a multi-process server, a second level of
     **  locking is needed to prevent a deadlock, in case a fiber acquires the
     **  cross-process mutex, yields, and another fiber is later scheduled on
@@ skipping 596 matching lines @@
 }
 
 SECStatus 
 SSL_SetMaxServerCacheLocks(PRUint32 maxLocks)
 {
     PR_ASSERT(!"SSL servers are not supported on this platform. (SSL_SetMaxServerCacheLocks)");
     return SECFailure;
 }
 
 #endif /* XP_UNIX || XP_WIN32 */