Index: lib/libpkix/pkix_pl_nss/system/pkix_pl_hashtable.c |
=================================================================== |
old mode 100755 |
new mode 100644 |
--- a/lib/libpkix/pkix_pl_nss/system/pkix_pl_hashtable.c |
+++ b/lib/libpkix/pkix_pl_nss/system/pkix_pl_hashtable.c |
@@ -8,376 +8,323 @@ |
* |
*/ |
#include "pkix_pl_hashtable.h" |
/* --Private-Structure-------------------------------------------- */ |
struct PKIX_PL_HashTableStruct { |
- pkix_pl_PrimHashTable *primHash; |
- PKIX_PL_Mutex *tableLock; |
- PKIX_UInt32 maxEntriesPerBucket; |
+ pkix_pl_PrimHashTable *primHash; |
+ PKIX_PL_Mutex *tableLock; |
+ PKIX_UInt32 maxEntriesPerBucket; |
}; |
/* --Private-Functions-------------------------------------------- */ |
-#define PKIX_MUTEX_UNLOCK(mutex) \ |
- do { \ |
- if (mutex && lockedMutex == (PKIX_PL_Mutex *)(mutex)) { \ |
- pkixTempResult = \ |
- PKIX_PL_Mutex_Unlock((mutex), plContext); \ |
- PORT_Assert(pkixTempResult == NULL); \ |
- if (pkixTempResult) { \ |
- PKIX_DoAddError(&stdVars, pkixTempResult, plContext); \ |
- pkixTempResult = NULL; \ |
- } \ |
- lockedMutex = NULL; \ |
- } else { \ |
- PORT_Assert(lockedMutex == NULL); \ |
- }\ |
- } while (0) |
+#define PKIX_MUTEX_UNLOCK(mutex) \ |
+ do { \ |
+ if (mutex && lockedMutex == (PKIX_PL_Mutex *)(mutex)) { \ |
+ pkixTempResult = PKIX_PL_Mutex_Unlock((mutex), plContext); \ |
+ PORT_Assert(pkixTempResult == NULL); \ |
+ if (pkixTempResult) { \ |
+ PKIX_DoAddError(&stdVars, pkixTempResult, plContext); \ |
+ pkixTempResult = NULL; \ |
+ } \ |
+ lockedMutex = NULL; \ |
+ } else { \ |
+ PORT_Assert(lockedMutex == NULL); \ |
+ } \ |
+ } while (0) |
- |
-#define PKIX_MUTEX_LOCK(mutex) \ |
- do { \ |
- if (mutex){ \ |
- PORT_Assert(lockedMutex == NULL); \ |
- PKIX_CHECK(PKIX_PL_Mutex_Lock((mutex), plContext), \ |
- PKIX_MUTEXLOCKFAILED); \ |
- lockedMutex = (mutex); \ |
- } \ |
- } while (0) |
+#define PKIX_MUTEX_LOCK(mutex) \ |
+ do { \ |
+ if (mutex) { \ |
+ PORT_Assert(lockedMutex == NULL); \ |
+ PKIX_CHECK(PKIX_PL_Mutex_Lock((mutex), plContext), \ |
+ PKIX_MUTEXLOCKFAILED); \ |
+ lockedMutex = (mutex); \ |
+ } \ |
+ } while (0) |
/* |
* FUNCTION: pkix_pl_HashTable_Destroy |
* (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h) |
*/ |
-static PKIX_Error * |
-pkix_pl_HashTable_Destroy( |
- PKIX_PL_Object *object, |
- void *plContext) |
-{ |
- PKIX_PL_HashTable *ht = NULL; |
- pkix_pl_HT_Elem *item = NULL; |
- PKIX_UInt32 i; |
+static PKIX_Error *pkix_pl_HashTable_Destroy(PKIX_PL_Object *object, |
+ void *plContext) { |
+ PKIX_PL_HashTable *ht = NULL; |
+ pkix_pl_HT_Elem *item = NULL; |
+ PKIX_UInt32 i; |
- PKIX_ENTER(HASHTABLE, "pkix_pl_HashTable_Destroy"); |
- PKIX_NULLCHECK_ONE(object); |
+ PKIX_ENTER(HASHTABLE, "pkix_pl_HashTable_Destroy"); |
+ PKIX_NULLCHECK_ONE(object); |
- PKIX_CHECK(pkix_CheckType(object, PKIX_HASHTABLE_TYPE, plContext), |
- PKIX_OBJECTNOTHASHTABLE); |
+ PKIX_CHECK(pkix_CheckType(object, PKIX_HASHTABLE_TYPE, plContext), |
+ PKIX_OBJECTNOTHASHTABLE); |
- ht = (PKIX_PL_HashTable*) object; |
+ ht = (PKIX_PL_HashTable *)object; |
- /* DecRef every object in the primitive hash table */ |
- for (i = 0; i < ht->primHash->size; i++) { |
- for (item = ht->primHash->buckets[i]; |
- item != NULL; |
- item = item->next) { |
- PKIX_DECREF(item->key); |
- PKIX_DECREF(item->value); |
- } |
- } |
+ /* DecRef every object in the primitive hash table */ |
+ for (i = 0; i < ht->primHash->size; i++) { |
+ for (item = ht->primHash->buckets[i]; item != NULL; item = item->next) { |
+ PKIX_DECREF(item->key); |
+ PKIX_DECREF(item->value); |
+ } |
+ } |
- PKIX_CHECK(pkix_pl_PrimHashTable_Destroy(ht->primHash, plContext), |
- PKIX_PRIMHASHTABLEDESTROYFAILED); |
+ PKIX_CHECK(pkix_pl_PrimHashTable_Destroy(ht->primHash, plContext), |
+ PKIX_PRIMHASHTABLEDESTROYFAILED); |
- PKIX_DECREF(ht->tableLock); |
+ PKIX_DECREF(ht->tableLock); |
cleanup: |
- PKIX_RETURN(HASHTABLE); |
+ PKIX_RETURN(HASHTABLE); |
} |
/* |
* FUNCTION: pkix_pl_HashTable_RegisterSelf |
* DESCRIPTION: |
* Registers PKIX_HASHTABLE_TYPE and its related functions with systemClasses[] |
* THREAD SAFETY: |
* Not Thread Safe - for performance and complexity reasons |
* |
* Since this function is only called by PKIX_PL_Initialize, which should |
* only be called once, it is acceptable that this function is not |
* thread-safe. |
*/ |
-PKIX_Error * |
-pkix_pl_HashTable_RegisterSelf( |
- void *plContext) |
-{ |
+PKIX_Error *pkix_pl_HashTable_RegisterSelf(void *plContext) { |
- extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES]; |
- pkix_ClassTable_Entry entry; |
+ extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES]; |
+ pkix_ClassTable_Entry entry; |
- PKIX_ENTER(HASHTABLE, "pkix_pl_HashTable_RegisterSelf"); |
+ PKIX_ENTER(HASHTABLE, "pkix_pl_HashTable_RegisterSelf"); |
- entry.description = "HashTable"; |
- entry.objCounter = 0; |
- entry.typeObjectSize = sizeof(PKIX_PL_HashTable); |
- entry.destructor = pkix_pl_HashTable_Destroy; |
- entry.equalsFunction = NULL; |
- entry.hashcodeFunction = NULL; |
- entry.toStringFunction = NULL; |
- entry.comparator = NULL; |
- entry.duplicateFunction = NULL; |
+ entry.description = "HashTable"; |
+ entry.objCounter = 0; |
+ entry.typeObjectSize = sizeof(PKIX_PL_HashTable); |
+ entry.destructor = pkix_pl_HashTable_Destroy; |
+ entry.equalsFunction = NULL; |
+ entry.hashcodeFunction = NULL; |
+ entry.toStringFunction = NULL; |
+ entry.comparator = NULL; |
+ entry.duplicateFunction = NULL; |
- systemClasses[PKIX_HASHTABLE_TYPE] = entry; |
+ systemClasses[PKIX_HASHTABLE_TYPE] = entry; |
- PKIX_RETURN(HASHTABLE); |
+ PKIX_RETURN(HASHTABLE); |
} |
/* --Public-Functions------------------------------------------------------- */ |
/* |
* FUNCTION: PKIX_PL_HashTable_Create (see comments in pkix_pl_system.h) |
*/ |
-PKIX_Error * |
-PKIX_PL_HashTable_Create( |
- PKIX_UInt32 numBuckets, |
- PKIX_UInt32 maxEntriesPerBucket, |
- PKIX_PL_HashTable **pResult, |
- void *plContext) |
-{ |
- PKIX_PL_HashTable *hashTable = NULL; |
+PKIX_Error *PKIX_PL_HashTable_Create(PKIX_UInt32 numBuckets, |
+ PKIX_UInt32 maxEntriesPerBucket, |
+ PKIX_PL_HashTable **pResult, |
+ void *plContext) { |
+ PKIX_PL_HashTable *hashTable = NULL; |
- PKIX_ENTER(HASHTABLE, "PKIX_PL_HashTable_Create"); |
- PKIX_NULLCHECK_ONE(pResult); |
+ PKIX_ENTER(HASHTABLE, "PKIX_PL_HashTable_Create"); |
+ PKIX_NULLCHECK_ONE(pResult); |
- if (numBuckets == 0) { |
- PKIX_ERROR(PKIX_NUMBUCKETSEQUALSZERO); |
- } |
+ if (numBuckets == 0) { |
+ PKIX_ERROR(PKIX_NUMBUCKETSEQUALSZERO); |
+ } |
- /* Allocate a new hashtable */ |
- PKIX_CHECK(PKIX_PL_Object_Alloc |
- (PKIX_HASHTABLE_TYPE, |
- sizeof (PKIX_PL_HashTable), |
- (PKIX_PL_Object **)&hashTable, |
- plContext), |
- PKIX_COULDNOTCREATEHASHTABLEOBJECT); |
+ /* Allocate a new hashtable */ |
+ PKIX_CHECK( |
+ PKIX_PL_Object_Alloc(PKIX_HASHTABLE_TYPE, sizeof(PKIX_PL_HashTable), |
+ (PKIX_PL_Object **)&hashTable, plContext), |
+ PKIX_COULDNOTCREATEHASHTABLEOBJECT); |
- /* Create the underlying primitive hash table type */ |
- PKIX_CHECK(pkix_pl_PrimHashTable_Create |
- (numBuckets, &hashTable->primHash, plContext), |
- PKIX_PRIMHASHTABLECREATEFAILED); |
+ /* Create the underlying primitive hash table type */ |
+ PKIX_CHECK( |
+ pkix_pl_PrimHashTable_Create(numBuckets, &hashTable->primHash, plContext), |
+ PKIX_PRIMHASHTABLECREATEFAILED); |
- /* Create a lock for this table */ |
- PKIX_CHECK(PKIX_PL_Mutex_Create(&hashTable->tableLock, plContext), |
- PKIX_ERRORCREATINGTABLELOCK); |
+ /* Create a lock for this table */ |
+ PKIX_CHECK(PKIX_PL_Mutex_Create(&hashTable->tableLock, plContext), |
+ PKIX_ERRORCREATINGTABLELOCK); |
- hashTable->maxEntriesPerBucket = maxEntriesPerBucket; |
+ hashTable->maxEntriesPerBucket = maxEntriesPerBucket; |
- *pResult = hashTable; |
+ *pResult = hashTable; |
cleanup: |
- if (PKIX_ERROR_RECEIVED){ |
- PKIX_DECREF(hashTable); |
- } |
+ if (PKIX_ERROR_RECEIVED) { |
+ PKIX_DECREF(hashTable); |
+ } |
- PKIX_RETURN(HASHTABLE); |
+ PKIX_RETURN(HASHTABLE); |
} |
/* |
* FUNCTION: PKIX_PL_HashTable_Add (see comments in pkix_pl_system.h) |
*/ |
-PKIX_Error * |
-PKIX_PL_HashTable_Add( |
- PKIX_PL_HashTable *ht, |
- PKIX_PL_Object *key, |
- PKIX_PL_Object *value, |
- void *plContext) |
-{ |
- PKIX_PL_Mutex *lockedMutex = NULL; |
- PKIX_PL_Object *deletedKey = NULL; |
- PKIX_PL_Object *deletedValue = NULL; |
- PKIX_UInt32 hashCode; |
- PKIX_PL_EqualsCallback keyComp; |
- PKIX_UInt32 bucketSize = 0; |
+PKIX_Error *PKIX_PL_HashTable_Add(PKIX_PL_HashTable *ht, PKIX_PL_Object *key, |
+ PKIX_PL_Object *value, void *plContext) { |
+ PKIX_PL_Mutex *lockedMutex = NULL; |
+ PKIX_PL_Object *deletedKey = NULL; |
+ PKIX_PL_Object *deletedValue = NULL; |
+ PKIX_UInt32 hashCode; |
+ PKIX_PL_EqualsCallback keyComp; |
+ PKIX_UInt32 bucketSize = 0; |
- PKIX_ENTER(HASHTABLE, "PKIX_PL_HashTable_Add"); |
+ PKIX_ENTER(HASHTABLE, "PKIX_PL_HashTable_Add"); |
#if !defined(PKIX_OBJECT_LEAK_TEST) |
- PKIX_NULLCHECK_THREE(ht, key, value); |
+ PKIX_NULLCHECK_THREE(ht, key, value); |
#else |
- PKIX_NULLCHECK_TWO(key, value); |
+ PKIX_NULLCHECK_TWO(key, value); |
- if (ht == NULL) { |
- PKIX_RETURN(HASHTABLE); |
- } |
+ if (ht == NULL) { |
+ PKIX_RETURN(HASHTABLE); |
+ } |
#endif |
- /* Insert into primitive hashtable */ |
+ /* Insert into primitive hashtable */ |
- PKIX_CHECK(PKIX_PL_Object_Hashcode(key, &hashCode, plContext), |
- PKIX_OBJECTHASHCODEFAILED); |
+ PKIX_CHECK(PKIX_PL_Object_Hashcode(key, &hashCode, plContext), |
+ PKIX_OBJECTHASHCODEFAILED); |
- PKIX_CHECK(pkix_pl_Object_RetrieveEqualsCallback |
- (key, &keyComp, plContext), |
- PKIX_OBJECTRETRIEVEEQUALSCALLBACKFAILED); |
+ PKIX_CHECK(pkix_pl_Object_RetrieveEqualsCallback(key, &keyComp, plContext), |
+ PKIX_OBJECTRETRIEVEEQUALSCALLBACKFAILED); |
- PKIX_MUTEX_LOCK(ht->tableLock); |
+ PKIX_MUTEX_LOCK(ht->tableLock); |
- PKIX_CHECK(pkix_pl_PrimHashTable_GetBucketSize |
- (ht->primHash, |
- hashCode, |
- &bucketSize, |
- plContext), |
- PKIX_PRIMHASHTABLEGETBUCKETSIZEFAILED); |
+ PKIX_CHECK(pkix_pl_PrimHashTable_GetBucketSize(ht->primHash, hashCode, |
+ &bucketSize, plContext), |
+ PKIX_PRIMHASHTABLEGETBUCKETSIZEFAILED); |
- if (ht->maxEntriesPerBucket != 0 && |
- bucketSize >= ht->maxEntriesPerBucket) { |
- /* drop the last one in the bucket */ |
- PKIX_CHECK(pkix_pl_PrimHashTable_RemoveFIFO |
- (ht->primHash, |
- hashCode, |
- (void **) &deletedKey, |
- (void **) &deletedValue, |
- plContext), |
- PKIX_PRIMHASHTABLEGETBUCKETSIZEFAILED); |
- PKIX_DECREF(deletedKey); |
- PKIX_DECREF(deletedValue); |
- } |
+ if (ht->maxEntriesPerBucket != 0 && bucketSize >= ht->maxEntriesPerBucket) { |
+ /* drop the last one in the bucket */ |
+ PKIX_CHECK(pkix_pl_PrimHashTable_RemoveFIFO( |
+ ht->primHash, hashCode, (void **)&deletedKey, |
+ (void **)&deletedValue, plContext), |
+ PKIX_PRIMHASHTABLEGETBUCKETSIZEFAILED); |
+ PKIX_DECREF(deletedKey); |
+ PKIX_DECREF(deletedValue); |
+ } |
- PKIX_CHECK(pkix_pl_PrimHashTable_Add |
- (ht->primHash, |
- (void *)key, |
- (void *)value, |
- hashCode, |
- keyComp, |
- plContext), |
- PKIX_PRIMHASHTABLEADDFAILED); |
+ PKIX_CHECK(pkix_pl_PrimHashTable_Add(ht->primHash, (void *)key, (void *)value, |
+ hashCode, keyComp, plContext), |
+ PKIX_PRIMHASHTABLEADDFAILED); |
- PKIX_INCREF(key); |
- PKIX_INCREF(value); |
- PKIX_MUTEX_UNLOCK(ht->tableLock); |
+ PKIX_INCREF(key); |
+ PKIX_INCREF(value); |
+ PKIX_MUTEX_UNLOCK(ht->tableLock); |
- /* |
- * we don't call PKIX_PL_InvalidateCache here b/c we have |
- * not implemented toString or hashcode for this Object |
- */ |
+/* |
+ * we don't call PKIX_PL_InvalidateCache here b/c we have |
+ * not implemented toString or hashcode for this Object |
+ */ |
cleanup: |
- PKIX_MUTEX_UNLOCK(ht->tableLock); |
+ PKIX_MUTEX_UNLOCK(ht->tableLock); |
- PKIX_RETURN(HASHTABLE); |
+ PKIX_RETURN(HASHTABLE); |
} |
/* |
* FUNCTION: PKIX_PL_HashTable_Remove (see comments in pkix_pl_system.h) |
*/ |
-PKIX_Error * |
-PKIX_PL_HashTable_Remove( |
- PKIX_PL_HashTable *ht, |
- PKIX_PL_Object *key, |
- void *plContext) |
-{ |
- PKIX_PL_Mutex *lockedMutex = NULL; |
- PKIX_PL_Object *origKey = NULL; |
- PKIX_PL_Object *value = NULL; |
- PKIX_UInt32 hashCode; |
- PKIX_PL_EqualsCallback keyComp; |
+PKIX_Error *PKIX_PL_HashTable_Remove(PKIX_PL_HashTable *ht, PKIX_PL_Object *key, |
+ void *plContext) { |
+ PKIX_PL_Mutex *lockedMutex = NULL; |
+ PKIX_PL_Object *origKey = NULL; |
+ PKIX_PL_Object *value = NULL; |
+ PKIX_UInt32 hashCode; |
+ PKIX_PL_EqualsCallback keyComp; |
- PKIX_ENTER(HASHTABLE, "PKIX_PL_HashTable_Remove"); |
+ PKIX_ENTER(HASHTABLE, "PKIX_PL_HashTable_Remove"); |
#if !defined(PKIX_OBJECT_LEAK_TEST) |
- PKIX_NULLCHECK_TWO(ht, key); |
+ PKIX_NULLCHECK_TWO(ht, key); |
#else |
- PKIX_NULLCHECK_ONE(key); |
+ PKIX_NULLCHECK_ONE(key); |
- if (ht == NULL) { |
- PKIX_RETURN(HASHTABLE); |
- } |
+ if (ht == NULL) { |
+ PKIX_RETURN(HASHTABLE); |
+ } |
#endif |
- PKIX_CHECK(PKIX_PL_Object_Hashcode(key, &hashCode, plContext), |
- PKIX_OBJECTHASHCODEFAILED); |
+ PKIX_CHECK(PKIX_PL_Object_Hashcode(key, &hashCode, plContext), |
+ PKIX_OBJECTHASHCODEFAILED); |
- PKIX_CHECK(pkix_pl_Object_RetrieveEqualsCallback |
- (key, &keyComp, plContext), |
- PKIX_OBJECTRETRIEVEEQUALSCALLBACKFAILED); |
+ PKIX_CHECK(pkix_pl_Object_RetrieveEqualsCallback(key, &keyComp, plContext), |
+ PKIX_OBJECTRETRIEVEEQUALSCALLBACKFAILED); |
- PKIX_MUTEX_LOCK(ht->tableLock); |
+ PKIX_MUTEX_LOCK(ht->tableLock); |
- /* Remove from primitive hashtable */ |
- PKIX_CHECK(pkix_pl_PrimHashTable_Remove |
- (ht->primHash, |
- (void *)key, |
- hashCode, |
- keyComp, |
- (void **)&origKey, |
- (void **)&value, |
- plContext), |
- PKIX_PRIMHASHTABLEREMOVEFAILED); |
+ /* Remove from primitive hashtable */ |
+ PKIX_CHECK(pkix_pl_PrimHashTable_Remove(ht->primHash, (void *)key, hashCode, |
+ keyComp, (void **)&origKey, |
+ (void **)&value, plContext), |
+ PKIX_PRIMHASHTABLEREMOVEFAILED); |
- PKIX_MUTEX_UNLOCK(ht->tableLock); |
+ PKIX_MUTEX_UNLOCK(ht->tableLock); |
- PKIX_DECREF(origKey); |
- PKIX_DECREF(value); |
+ PKIX_DECREF(origKey); |
+ PKIX_DECREF(value); |
- /* |
- * we don't call PKIX_PL_InvalidateCache here b/c we have |
- * not implemented toString or hashcode for this Object |
- */ |
+/* |
+ * we don't call PKIX_PL_InvalidateCache here b/c we have |
+ * not implemented toString or hashcode for this Object |
+ */ |
cleanup: |
- PKIX_MUTEX_UNLOCK(ht->tableLock); |
+ PKIX_MUTEX_UNLOCK(ht->tableLock); |
- PKIX_RETURN(HASHTABLE); |
+ PKIX_RETURN(HASHTABLE); |
} |
/* |
* FUNCTION: PKIX_PL_HashTable_Lookup (see comments in pkix_pl_system.h) |
*/ |
-PKIX_Error * |
-PKIX_PL_HashTable_Lookup( |
- PKIX_PL_HashTable *ht, |
- PKIX_PL_Object *key, |
- PKIX_PL_Object **pResult, |
- void *plContext) |
-{ |
- PKIX_PL_Mutex *lockedMutex = NULL; |
- PKIX_UInt32 hashCode; |
- PKIX_PL_EqualsCallback keyComp; |
- PKIX_PL_Object *result = NULL; |
+PKIX_Error *PKIX_PL_HashTable_Lookup(PKIX_PL_HashTable *ht, PKIX_PL_Object *key, |
+ PKIX_PL_Object **pResult, |
+ void *plContext) { |
+ PKIX_PL_Mutex *lockedMutex = NULL; |
+ PKIX_UInt32 hashCode; |
+ PKIX_PL_EqualsCallback keyComp; |
+ PKIX_PL_Object *result = NULL; |
- PKIX_ENTER(HASHTABLE, "PKIX_PL_HashTable_Lookup"); |
+ PKIX_ENTER(HASHTABLE, "PKIX_PL_HashTable_Lookup"); |
#if !defined(PKIX_OBJECT_LEAK_TEST) |
- PKIX_NULLCHECK_THREE(ht, key, pResult); |
+ PKIX_NULLCHECK_THREE(ht, key, pResult); |
#else |
- PKIX_NULLCHECK_TWO(key, pResult); |
+ PKIX_NULLCHECK_TWO(key, pResult); |
- if (ht == NULL) { |
- PKIX_RETURN(HASHTABLE); |
- } |
+ if (ht == NULL) { |
+ PKIX_RETURN(HASHTABLE); |
+ } |
#endif |
- PKIX_CHECK(PKIX_PL_Object_Hashcode(key, &hashCode, plContext), |
- PKIX_OBJECTHASHCODEFAILED); |
+ PKIX_CHECK(PKIX_PL_Object_Hashcode(key, &hashCode, plContext), |
+ PKIX_OBJECTHASHCODEFAILED); |
- PKIX_CHECK(pkix_pl_Object_RetrieveEqualsCallback |
- (key, &keyComp, plContext), |
- PKIX_OBJECTRETRIEVEEQUALSCALLBACKFAILED); |
+ PKIX_CHECK(pkix_pl_Object_RetrieveEqualsCallback(key, &keyComp, plContext), |
+ PKIX_OBJECTRETRIEVEEQUALSCALLBACKFAILED); |
- PKIX_MUTEX_LOCK(ht->tableLock); |
+ PKIX_MUTEX_LOCK(ht->tableLock); |
- /* Lookup in primitive hashtable */ |
- PKIX_CHECK(pkix_pl_PrimHashTable_Lookup |
- (ht->primHash, |
- (void *)key, |
- hashCode, |
- keyComp, |
- (void **)&result, |
- plContext), |
- PKIX_PRIMHASHTABLELOOKUPFAILED); |
+ /* Lookup in primitive hashtable */ |
+ PKIX_CHECK(pkix_pl_PrimHashTable_Lookup(ht->primHash, (void *)key, hashCode, |
+ keyComp, (void **)&result, plContext), |
+ PKIX_PRIMHASHTABLELOOKUPFAILED); |
- PKIX_INCREF(result); |
- PKIX_MUTEX_UNLOCK(ht->tableLock); |
+ PKIX_INCREF(result); |
+ PKIX_MUTEX_UNLOCK(ht->tableLock); |
- *pResult = result; |
+ *pResult = result; |
cleanup: |
- |
- PKIX_MUTEX_UNLOCK(ht->tableLock); |
- PKIX_RETURN(HASHTABLE); |
+ PKIX_MUTEX_UNLOCK(ht->tableLock); |
+ |
+ PKIX_RETURN(HASHTABLE); |
} |