summaryrefslogtreecommitdiffstats
path: root/security/nss/lib/ckfw/hash.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--security/nss/lib/ckfw/hash.c280
1 files changed, 280 insertions, 0 deletions
diff --git a/security/nss/lib/ckfw/hash.c b/security/nss/lib/ckfw/hash.c
new file mode 100644
index 0000000000..50de4ce148
--- /dev/null
+++ b/security/nss/lib/ckfw/hash.c
@@ -0,0 +1,280 @@
+/* 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/. */
+
+/*
+ * hash.c
+ *
+ * This is merely a couple wrappers around NSPR's PLHashTable, using
+ * the identity hash and arena-aware allocators. The reason I did
+ * this is that hash tables are used in a few places throughout the
+ * NSS Cryptoki Framework in a fairly stereotyped way, and this allows
+ * me to pull the commonalities into one place. Should we ever want
+ * to change the implementation, it's all right here.
+ */
+
+#ifndef CK_T
+#include "ck.h"
+#endif /* CK_T */
+
+/*
+ * nssCKFWHash
+ *
+ * nssCKFWHash_Create
+ * nssCKFWHash_Destroy
+ * nssCKFWHash_Add
+ * nssCKFWHash_Remove
+ * nssCKFWHash_Count
+ * nssCKFWHash_Exists
+ * nssCKFWHash_Lookup
+ * nssCKFWHash_Iterate
+ */
+
+struct nssCKFWHashStr {
+ NSSCKFWMutex *mutex;
+
+ /*
+ * 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)
+{
+ return (PLHashNumber)((char *)key - (char *)NULL);
+}
+
+/*
+ * nssCKFWHash_Create
+ *
+ */
+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)) {
+ *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) {
+ *pError = CKR_GENERAL_ERROR;
+ }
+ (void)nss_ZFreeIf(rv);
+ return (nssCKFWHash *)NULL;
+ }
+
+ 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)
+{
+ (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)
+{
+ CK_RV error = CKR_OK;
+ PLHashEntry *he;
+
+ error = nssCKFWMutex_Lock(hash->mutex);
+ 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)
+{
+ PRBool found;
+
+ if (CKR_OK != nssCKFWMutex_Lock(hash->mutex)) {
+ return;
+ }
+
+ found = PL_HashTableRemove(hash->plHashTable, it);
+ if (found) {
+ hash->count--;
+ }
+
+ (void)nssCKFWMutex_Unlock(hash->mutex);
+ return;
+}
+
+/*
+ * nssCKFWHash_Count
+ *
+ */
+NSS_IMPLEMENT CK_ULONG
+nssCKFWHash_Count(
+ nssCKFWHash *hash)
+{
+ CK_ULONG count;
+
+ 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)
+{
+ void *value;
+
+ if (CKR_OK != nssCKFWMutex_Lock(hash->mutex)) {
+ return CK_FALSE;
+ }
+
+ value = PL_HashTableLookup(hash->plHashTable, it);
+
+ (void)nssCKFWMutex_Unlock(hash->mutex);
+
+ if (!value) {
+ return CK_FALSE;
+ } else {
+ return CK_TRUE;
+ }
+}
+
+/*
+ * nssCKFWHash_Lookup
+ *
+ */
+NSS_IMPLEMENT void *
+nssCKFWHash_Lookup(
+ nssCKFWHash *hash,
+ const void *it)
+{
+ void *rv;
+
+ 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)
+{
+ 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)
+{
+ struct arg_str as;
+ as.fcn = fcn;
+ as.closure = closure;
+
+ if (CKR_OK != nssCKFWMutex_Lock(hash->mutex)) {
+ return;
+ }
+
+ PL_HashTableEnumerateEntries(hash->plHashTable, nss_ckfwhash_enumerator, &as);
+
+ (void)nssCKFWMutex_Unlock(hash->mutex);
+
+ return;
+}