Index: lib/ckfw/hash.c |
=================================================================== |
--- a/lib/ckfw/hash.c |
+++ b/lib/ckfw/hash.c |
@@ -37,191 +37,153 @@ struct nssCKFWHashStr { |
* The invariant that mutex protects is: |
* The count accurately reflects the hashtable state. |
*/ |
PLHashTable *plHashTable; |
CK_ULONG count; |
}; |
-static PLHashNumber |
-nss_ckfw_identity_hash |
-( |
- const void *key |
-) |
-{ |
+static PLHashNumber nss_ckfw_identity_hash(const void *key) { |
PRUint32 i = (PRUint32)key; |
PR_ASSERT(sizeof(PLHashNumber) == sizeof(PRUint32)); |
return (PLHashNumber)i; |
} |
/* |
* nssCKFWHash_Create |
* |
*/ |
-NSS_IMPLEMENT nssCKFWHash * |
-nssCKFWHash_Create |
-( |
- NSSCKFWInstance *fwInstance, |
- NSSArena *arena, |
- CK_RV *pError |
-) |
-{ |
+NSS_IMPLEMENT nssCKFWHash *nssCKFWHash_Create(NSSCKFWInstance *fwInstance, |
+ NSSArena *arena, CK_RV *pError) { |
nssCKFWHash *rv; |
#ifdef NSSDEBUG |
if (!pError) { |
return (nssCKFWHash *)NULL; |
} |
- if( PR_SUCCESS != nssArena_verifyPointer(arena) ) { |
+ if (PR_SUCCESS != nssArena_verifyPointer(arena)) { |
*pError = CKR_ARGUMENTS_BAD; |
return (nssCKFWHash *)NULL; |
} |
#endif /* NSSDEBUG */ |
rv = nss_ZNEW(arena, nssCKFWHash); |
if (!rv) { |
*pError = CKR_HOST_MEMORY; |
return (nssCKFWHash *)NULL; |
} |
rv->mutex = nssCKFWInstance_CreateMutex(fwInstance, arena, pError); |
if (!rv->mutex) { |
- if( CKR_OK == *pError ) { |
+ if (CKR_OK == *pError) { |
(void)nss_ZFreeIf(rv); |
*pError = CKR_GENERAL_ERROR; |
} |
return (nssCKFWHash *)NULL; |
} |
- rv->plHashTable = PL_NewHashTable(0, nss_ckfw_identity_hash, |
- PL_CompareValues, PL_CompareValues, &nssArenaHashAllocOps, arena); |
+ rv->plHashTable = |
+ PL_NewHashTable(0, nss_ckfw_identity_hash, PL_CompareValues, |
+ PL_CompareValues, &nssArenaHashAllocOps, arena); |
if (!rv->plHashTable) { |
(void)nssCKFWMutex_Destroy(rv->mutex); |
(void)nss_ZFreeIf(rv); |
*pError = CKR_HOST_MEMORY; |
return (nssCKFWHash *)NULL; |
} |
rv->count = 0; |
return rv; |
} |
/* |
* nssCKFWHash_Destroy |
* |
*/ |
-NSS_IMPLEMENT void |
-nssCKFWHash_Destroy |
-( |
- nssCKFWHash *hash |
-) |
-{ |
+NSS_IMPLEMENT void nssCKFWHash_Destroy(nssCKFWHash *hash) { |
(void)nssCKFWMutex_Destroy(hash->mutex); |
PL_HashTableDestroy(hash->plHashTable); |
(void)nss_ZFreeIf(hash); |
} |
/* |
* nssCKFWHash_Add |
* |
*/ |
NSS_IMPLEMENT CK_RV |
-nssCKFWHash_Add |
-( |
- nssCKFWHash *hash, |
- const void *key, |
- const void *value |
-) |
-{ |
+nssCKFWHash_Add(nssCKFWHash *hash, const void *key, const void *value) { |
CK_RV error = CKR_OK; |
PLHashEntry *he; |
error = nssCKFWMutex_Lock(hash->mutex); |
- if( CKR_OK != error ) { |
+ if (CKR_OK != error) { |
return error; |
} |
- |
+ |
he = PL_HashTableAdd(hash->plHashTable, key, (void *)value); |
if (!he) { |
error = CKR_HOST_MEMORY; |
} else { |
hash->count++; |
} |
(void)nssCKFWMutex_Unlock(hash->mutex); |
return error; |
} |
/* |
* nssCKFWHash_Remove |
* |
*/ |
-NSS_IMPLEMENT void |
-nssCKFWHash_Remove |
-( |
- nssCKFWHash *hash, |
- const void *it |
-) |
-{ |
+NSS_IMPLEMENT void nssCKFWHash_Remove(nssCKFWHash *hash, const void *it) { |
PRBool found; |
- if( CKR_OK != nssCKFWMutex_Lock(hash->mutex) ) { |
+ if (CKR_OK != nssCKFWMutex_Lock(hash->mutex)) { |
return; |
} |
found = PL_HashTableRemove(hash->plHashTable, it); |
- if( found ) { |
+ if (found) { |
hash->count--; |
} |
(void)nssCKFWMutex_Unlock(hash->mutex); |
return; |
} |
/* |
* nssCKFWHash_Count |
* |
*/ |
-NSS_IMPLEMENT CK_ULONG |
-nssCKFWHash_Count |
-( |
- nssCKFWHash *hash |
-) |
-{ |
+NSS_IMPLEMENT CK_ULONG nssCKFWHash_Count(nssCKFWHash *hash) { |
CK_ULONG count; |
- if( CKR_OK != nssCKFWMutex_Lock(hash->mutex) ) { |
+ if (CKR_OK != nssCKFWMutex_Lock(hash->mutex)) { |
return (CK_ULONG)0; |
} |
count = hash->count; |
(void)nssCKFWMutex_Unlock(hash->mutex); |
return count; |
} |
/* |
* nssCKFWHash_Exists |
* |
*/ |
-NSS_IMPLEMENT CK_BBOOL |
-nssCKFWHash_Exists |
-( |
- nssCKFWHash *hash, |
- const void *it |
-) |
-{ |
+NSS_IMPLEMENT CK_BBOOL nssCKFWHash_Exists(nssCKFWHash *hash, const void *it) { |
void *value; |
- if( CKR_OK != nssCKFWMutex_Lock(hash->mutex) ) { |
+ if (CKR_OK != nssCKFWMutex_Lock(hash->mutex)) { |
return CK_FALSE; |
} |
value = PL_HashTableLookup(hash->plHashTable, it); |
(void)nssCKFWMutex_Unlock(hash->mutex); |
if (!value) { |
@@ -230,72 +192,54 @@ nssCKFWHash_Exists |
return CK_TRUE; |
} |
} |
/* |
* nssCKFWHash_Lookup |
* |
*/ |
-NSS_IMPLEMENT void * |
-nssCKFWHash_Lookup |
-( |
- nssCKFWHash *hash, |
- const void *it |
-) |
-{ |
+NSS_IMPLEMENT void *nssCKFWHash_Lookup(nssCKFWHash *hash, const void *it) { |
void *rv; |
- if( CKR_OK != nssCKFWMutex_Lock(hash->mutex) ) { |
+ if (CKR_OK != nssCKFWMutex_Lock(hash->mutex)) { |
return (void *)NULL; |
} |
rv = PL_HashTableLookup(hash->plHashTable, it); |
(void)nssCKFWMutex_Unlock(hash->mutex); |
return rv; |
} |
struct arg_str { |
nssCKFWHashIterator fcn; |
void *closure; |
}; |
-static PRIntn |
-nss_ckfwhash_enumerator |
-( |
- PLHashEntry *he, |
- PRIntn index, |
- void *arg |
-) |
-{ |
+static PRIntn nss_ckfwhash_enumerator(PLHashEntry *he, PRIntn index, |
+ void *arg) { |
struct arg_str *as = (struct arg_str *)arg; |
as->fcn(he->key, he->value, as->closure); |
return HT_ENUMERATE_NEXT; |
} |
/* |
* nssCKFWHash_Iterate |
* |
* NOTE that the iteration function will be called with the hashtable locked. |
*/ |
-NSS_IMPLEMENT void |
-nssCKFWHash_Iterate |
-( |
- nssCKFWHash *hash, |
- nssCKFWHashIterator fcn, |
- void *closure |
-) |
-{ |
+NSS_IMPLEMENT void nssCKFWHash_Iterate(nssCKFWHash *hash, |
+ nssCKFWHashIterator fcn, void *closure) { |
struct arg_str as; |
as.fcn = fcn; |
as.closure = closure; |
- if( CKR_OK != nssCKFWMutex_Lock(hash->mutex) ) { |
+ if (CKR_OK != nssCKFWMutex_Lock(hash->mutex)) { |
return; |
} |
PL_HashTableEnumerateEntries(hash->plHashTable, nss_ckfwhash_enumerator, &as); |
(void)nssCKFWMutex_Unlock(hash->mutex); |
return; |