Update NSS to 3.21 RTM and NSPR to 4.11 RTM

nss/lib/certdb/crl.c

 /* 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/. */
 
 /*
  * Moved from secpkcs7.c
  */
  
 #include "cert.h"
 #include "certi.h"
@@ skipping 609 matching lines @@
 }
 
 
 CERTSignedCrl *
 crl_storeCRL (PK11SlotInfo *slot,char *url,
                   CERTSignedCrl *newCrl, SECItem *derCrl, int type)
 {
     CERTSignedCrl *oldCrl = NULL, *crl = NULL;
     PRBool deleteOldCrl = PR_FALSE;
     CK_OBJECT_HANDLE crlHandle = CK_INVALID_HANDLE;
-    SECStatus rv;
 
     PORT_Assert(newCrl);
     PORT_Assert(derCrl);
     PORT_Assert(type == SEC_CRL_TYPE);
 
     if (type != SEC_CRL_TYPE) {
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
         return NULL;
     }
 
     /* we can't use the cache here because we must look in the same
        token */
-    rv = SEC_FindCrlByKeyOnSlot(slot, &newCrl->crl.derName, type,
-                                &oldCrl, CRL_DECODE_SKIP_ENTRIES);
+    (void)SEC_FindCrlByKeyOnSlot(slot, &newCrl->crl.derName, type,
+                                 &oldCrl, CRL_DECODE_SKIP_ENTRIES);
     /* if there is an old crl on the token, make sure the one we are
        installing is newer. If not, exit out, otherwise delete the
        old crl.
      */
     if (oldCrl != NULL) {
         /* if it's already there, quietly continue */
         if (SECITEM_CompareItem(newCrl->derCrl, oldCrl->derCrl) 
                                                 == SECEqual) {
             crl = newCrl;
             crl->slot = PK11_ReferenceSlot(slot);
@@ skipping 2031 matching lines @@
                     rv = SECFailure;
                 }
             }
             else
             {
                 /* no revocation date, certificate is permanently revoked */
                 rv = SECFailure;
             }
             if (SECFailure == rv)
             {
-                SECStatus rv2 = CERT_FindCRLEntryReasonExten(entry, &reason);
+                (void)CERT_FindCRLEntryReasonExten(entry, &reason);
                 PORT_SetError(SEC_ERROR_REVOKED_CERTIFICATE);
             }
             break;
 
         case dpcacheEmpty:
             /* useful for NIST policy */
             status = certRevocationStatusUnknown;
             break;
 
         case dpcacheNoEntry:
@@ skipping 336 matching lines @@
 }
 
 /* take ownership of CRL, and insert it into the named CRL cache
  * and indexed CRL cache
  */
 SECStatus cert_CacheCRLByGeneralName(CERTCertDBHandle* dbhandle, SECItem* crl,
                                      const SECItem* canonicalizedName)
 {
     NamedCRLCacheEntry* oldEntry, * newEntry = NULL;
     NamedCRLCache* ncc = NULL;
-    SECStatus rv = SECSuccess, rv2;
+    SECStatus rv = SECSuccess;
 
     PORT_Assert(namedCRLCache.lock);
     PORT_Assert(namedCRLCache.entries);
 
     if (!crl || !canonicalizedName)
     {
         PORT_Assert(0);
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
         return SECFailure;
     }
@@ skipping 17 matching lines @@
                                     &newEntry) )
     {
         if (!oldEntry)
         {
             /* add new good entry to the hash table */
             if (NULL == PL_HashTableAdd(namedCRLCache.entries,
                                         (void*) newEntry->canonicalizedName,
                                         (void*) newEntry))
             {
                 PORT_Assert(0);
-                rv2 = NamedCRLCacheEntry_Destroy(newEntry);
-                PORT_Assert(SECSuccess == rv2);
+                NamedCRLCacheEntry_Destroy(newEntry);

[davidben, 2015/12/11 22:10:58]

[Why didn't they PORT_CheckSuccess this one too? Oh well, whatever.]

                 rv = SECFailure;
             }
         }
         else
         {
             PRBool removed;
             /* remove the old CRL from the cache if needed */
             if (oldEntry->inCRLCache)
             {
                 rv = CERT_UncacheCRL(dbhandle, oldEntry->crl);
                 PORT_Assert(SECSuccess == rv);
             }
             removed = PL_HashTableRemove(namedCRLCache.entries,
                                       (void*) oldEntry->canonicalizedName);
             PORT_Assert(removed);
             if (!removed)
             {
                 rv = SECFailure;
                 /* leak old entry since we couldn't remove it from the hash table */
             }
             else
             {
-                rv2 = NamedCRLCacheEntry_Destroy(oldEntry);
-                PORT_Assert(SECSuccess == rv2);
+                PORT_CheckSuccess(NamedCRLCacheEntry_Destroy(oldEntry));
             }
             if (NULL == PL_HashTableAdd(namedCRLCache.entries,
                                       (void*) newEntry->canonicalizedName,
                                       (void*) newEntry))
             {
                 PORT_Assert(0);
                 rv = SECFailure;
             }
         }
     } else
@@ skipping 26 matching lines @@
                 PRBool removed = PL_HashTableRemove(namedCRLCache.entries,
                                           (void*) oldEntry->canonicalizedName);
                 PORT_Assert(removed);
                 if (!removed)
                 {
                     /* leak old entry since we couldn't remove it from the hash table */
                     rv = SECFailure;
                 }
                 else
                 {
-                    rv2 = NamedCRLCacheEntry_Destroy(oldEntry);
-                    PORT_Assert(SECSuccess == rv2);
+                    PORT_CheckSuccess(NamedCRLCacheEntry_Destroy(oldEntry));
                 }
                 if (NULL == PL_HashTableAdd(namedCRLCache.entries,
                                           (void*) newEntry->canonicalizedName,
                                           (void*) newEntry))
                 {
                     PORT_Assert(0);
                     rv = SECFailure;
                 }
             }
         }
     }
-    rv2 = cert_ReleaseNamedCRLCache(ncc);
-    PORT_Assert(SECSuccess == rv2);
+    PORT_CheckSuccess(cert_ReleaseNamedCRLCache(ncc));
 
     return rv;
 }
 
 static SECStatus CachedCrl_Create(CachedCrl** returned, CERTSignedCrl* crl,
                                   CRLOrigin origin)
 {
     CachedCrl* newcrl = NULL;
     if (!returned)
     {
@@ skipping 182 matching lines @@
            to CERT_CacheCRL previously. That API takes a SECItem*, thus, we
            just do a pointer comparison here.
         */
         if (b->crl->derCrl == a->crl->derCrl)
         {
             *isDupe = PR_TRUE;
         }
     }
     return SECSuccess;
 }