--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/nss/lib/ckfw/sessobj.c	Mon Jul 28 10:47:06 2014 +0200
@@ -0,0 +1,1075 @@
+/* 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/. */
+
+/*
+ * sessobj.c
+ *
+ * This file contains an NSSCKMDObject implementation for session 
+ * objects.  The framework uses this implementation to manage
+ * session objects when a Module doesn't wish to be bothered.
+ */
+
+#ifndef CK_T
+#include "ck.h"
+#endif /* CK_T */
+
+/*
+ * nssCKMDSessionObject
+ *
+ *  -- create --
+ *  nssCKMDSessionObject_Create
+ *
+ *  -- EPV calls --
+ *  nss_ckmdSessionObject_Finalize
+ *  nss_ckmdSessionObject_IsTokenObject
+ *  nss_ckmdSessionObject_GetAttributeCount
+ *  nss_ckmdSessionObject_GetAttributeTypes
+ *  nss_ckmdSessionObject_GetAttributeSize
+ *  nss_ckmdSessionObject_GetAttribute
+ *  nss_ckmdSessionObject_SetAttribute
+ *  nss_ckmdSessionObject_GetObjectSize
+ */
+
+struct nssCKMDSessionObjectStr {
+  CK_ULONG n;
+  NSSArena *arena;
+  NSSItem *attributes;
+  CK_ATTRIBUTE_TYPE_PTR types;
+  nssCKFWHash *hash;
+};
+typedef struct nssCKMDSessionObjectStr nssCKMDSessionObject;
+
+#ifdef DEBUG
+/*
+ * But first, the pointer-tracking stuff.
+ *
+ * NOTE: the pointer-tracking support in NSS/base currently relies
+ * upon NSPR's CallOnce support.  That, however, relies upon NSPR's
+ * locking, which is tied into the runtime.  We need a pointer-tracker
+ * implementation that uses the locks supplied through C_Initialize.
+ * That support, however, can be filled in later.  So for now, I'll
+ * just do this routines as no-ops.
+ */
+
+static CK_RV
+nss_ckmdSessionObject_add_pointer
+(
+  const NSSCKMDObject *mdObject
+)
+{
+  return CKR_OK;
+}
+
+static CK_RV
+nss_ckmdSessionObject_remove_pointer
+(
+  const NSSCKMDObject *mdObject
+)
+{
+  return CKR_OK;
+}
+
+#ifdef NSS_DEBUG
+static CK_RV
+nss_ckmdSessionObject_verifyPointer
+(
+  const NSSCKMDObject *mdObject
+)
+{
+  return CKR_OK;
+}
+#endif
+
+#endif /* DEBUG */
+
+/*
+ * We must forward-declare these routines
+ */
+static void
+nss_ckmdSessionObject_Finalize
+(
+  NSSCKMDObject *mdObject,
+  NSSCKFWObject *fwObject,
+  NSSCKMDSession *mdSession,
+  NSSCKFWSession *fwSession,
+  NSSCKMDToken *mdToken,
+  NSSCKFWToken *fwToken,
+  NSSCKMDInstance *mdInstance,
+  NSSCKFWInstance *fwInstance
+);
+
+static CK_RV
+nss_ckmdSessionObject_Destroy
+(
+  NSSCKMDObject *mdObject,
+  NSSCKFWObject *fwObject,
+  NSSCKMDSession *mdSession,
+  NSSCKFWSession *fwSession,
+  NSSCKMDToken *mdToken,
+  NSSCKFWToken *fwToken,
+  NSSCKMDInstance *mdInstance,
+  NSSCKFWInstance *fwInstance
+);
+
+static CK_BBOOL
+nss_ckmdSessionObject_IsTokenObject
+(
+  NSSCKMDObject *mdObject,
+  NSSCKFWObject *fwObject,
+  NSSCKMDSession *mdSession,
+  NSSCKFWSession *fwSession,
+  NSSCKMDToken *mdToken,
+  NSSCKFWToken *fwToken,
+  NSSCKMDInstance *mdInstance,
+  NSSCKFWInstance *fwInstance
+);
+
+static CK_ULONG
+nss_ckmdSessionObject_GetAttributeCount
+(
+  NSSCKMDObject *mdObject,
+  NSSCKFWObject *fwObject,
+  NSSCKMDSession *mdSession,
+  NSSCKFWSession *fwSession,
+  NSSCKMDToken *mdToken,
+  NSSCKFWToken *fwToken,
+  NSSCKMDInstance *mdInstance,
+  NSSCKFWInstance *fwInstance,
+  CK_RV *pError
+);
+
+static CK_RV
+nss_ckmdSessionObject_GetAttributeTypes
+(
+  NSSCKMDObject *mdObject,
+  NSSCKFWObject *fwObject,
+  NSSCKMDSession *mdSession,
+  NSSCKFWSession *fwSession,
+  NSSCKMDToken *mdToken,
+  NSSCKFWToken *fwToken,
+  NSSCKMDInstance *mdInstance,
+  NSSCKFWInstance *fwInstance,
+  CK_ATTRIBUTE_TYPE_PTR typeArray,
+  CK_ULONG ulCount
+);
+
+static CK_ULONG
+nss_ckmdSessionObject_GetAttributeSize
+(
+  NSSCKMDObject *mdObject,
+  NSSCKFWObject *fwObject,
+  NSSCKMDSession *mdSession,
+  NSSCKFWSession *fwSession,
+  NSSCKMDToken *mdToken,
+  NSSCKFWToken *fwToken,
+  NSSCKMDInstance *mdInstance,
+  NSSCKFWInstance *fwInstance,
+  CK_ATTRIBUTE_TYPE attribute,
+  CK_RV *pError
+);
+
+static NSSCKFWItem
+nss_ckmdSessionObject_GetAttribute
+(
+  NSSCKMDObject *mdObject,
+  NSSCKFWObject *fwObject,
+  NSSCKMDSession *mdSession,
+  NSSCKFWSession *fwSession,
+  NSSCKMDToken *mdToken,
+  NSSCKFWToken *fwToken,
+  NSSCKMDInstance *mdInstance,
+  NSSCKFWInstance *fwInstance,
+  CK_ATTRIBUTE_TYPE attribute,
+  CK_RV *pError
+);
+
+static CK_RV
+nss_ckmdSessionObject_SetAttribute
+(
+  NSSCKMDObject *mdObject,
+  NSSCKFWObject *fwObject,
+  NSSCKMDSession *mdSession,
+  NSSCKFWSession *fwSession,
+  NSSCKMDToken *mdToken,
+  NSSCKFWToken *fwToken,
+  NSSCKMDInstance *mdInstance,
+  NSSCKFWInstance *fwInstance,
+  CK_ATTRIBUTE_TYPE attribute,
+  NSSItem *value
+);
+
+static CK_ULONG
+nss_ckmdSessionObject_GetObjectSize
+(
+  NSSCKMDObject *mdObject,
+  NSSCKFWObject *fwObject,
+  NSSCKMDSession *mdSession,
+  NSSCKFWSession *fwSession,
+  NSSCKMDToken *mdToken,
+  NSSCKFWToken *fwToken,
+  NSSCKMDInstance *mdInstance,
+  NSSCKFWInstance *fwInstance,
+  CK_RV *pError
+);
+
+/*
+ * nssCKMDSessionObject_Create
+ *
+ */
+NSS_IMPLEMENT NSSCKMDObject *
+nssCKMDSessionObject_Create
+(
+  NSSCKFWToken *fwToken,
+  NSSArena *arena,
+  CK_ATTRIBUTE_PTR attributes,
+  CK_ULONG ulCount,
+  CK_RV *pError
+)
+{
+  NSSCKMDObject *mdObject = (NSSCKMDObject *)NULL;
+  nssCKMDSessionObject *mdso = (nssCKMDSessionObject *)NULL;
+  CK_ULONG i;
+  nssCKFWHash *hash;
+
+  *pError = CKR_OK;
+
+  mdso = nss_ZNEW(arena, nssCKMDSessionObject);
+  if (!mdso) {
+    goto loser;
+  }
+
+  mdso->arena = arena;
+  mdso->n = ulCount;
+  mdso->attributes = nss_ZNEWARRAY(arena, NSSItem, ulCount);
+  if (!mdso->attributes) {
+    goto loser;
+  }
+
+  mdso->types = nss_ZNEWARRAY(arena, CK_ATTRIBUTE_TYPE, ulCount);
+  if (!mdso->types) {
+    goto loser;
+  }
+  for( i = 0; i < ulCount; i++ ) {
+    mdso->types[i] = attributes[i].type;
+    mdso->attributes[i].size = attributes[i].ulValueLen;
+    mdso->attributes[i].data = nss_ZAlloc(arena, attributes[i].ulValueLen);
+    if (!mdso->attributes[i].data) {
+      goto loser;
+    }
+    (void)nsslibc_memcpy(mdso->attributes[i].data, attributes[i].pValue,
+      attributes[i].ulValueLen);
+  }
+
+  mdObject = nss_ZNEW(arena, NSSCKMDObject);
+  if (!mdObject) {
+    goto loser;
+  }
+
+  mdObject->etc = (void *)mdso;
+  mdObject->Finalize = nss_ckmdSessionObject_Finalize;
+  mdObject->Destroy = nss_ckmdSessionObject_Destroy;
+  mdObject->IsTokenObject = nss_ckmdSessionObject_IsTokenObject;
+  mdObject->GetAttributeCount = nss_ckmdSessionObject_GetAttributeCount;
+  mdObject->GetAttributeTypes = nss_ckmdSessionObject_GetAttributeTypes;
+  mdObject->GetAttributeSize = nss_ckmdSessionObject_GetAttributeSize;
+  mdObject->GetAttribute = nss_ckmdSessionObject_GetAttribute;
+  mdObject->SetAttribute = nss_ckmdSessionObject_SetAttribute;
+  mdObject->GetObjectSize = nss_ckmdSessionObject_GetObjectSize;
+
+  hash = nssCKFWToken_GetSessionObjectHash(fwToken);
+  if (!hash) {
+    *pError = CKR_GENERAL_ERROR;
+    goto loser;
+  }
+
+  mdso->hash = hash;
+
+  *pError = nssCKFWHash_Add(hash, mdObject, mdObject);
+  if( CKR_OK != *pError ) {
+    goto loser;
+  }
+
+#ifdef DEBUG
+  if(( *pError = nss_ckmdSessionObject_add_pointer(mdObject)) != CKR_OK ) {
+    goto loser;
+  }
+#endif /* DEBUG */
+
+  return mdObject;
+
+ loser:
+  if (mdso) {
+    if (mdso->attributes) {
+      for( i = 0; i < ulCount; i++ ) {
+        nss_ZFreeIf(mdso->attributes[i].data);
+      }
+      nss_ZFreeIf(mdso->attributes);
+    }
+    nss_ZFreeIf(mdso->types);
+    nss_ZFreeIf(mdso);
+  }
+
+  nss_ZFreeIf(mdObject);
+  if (*pError == CKR_OK) {
+      *pError = CKR_HOST_MEMORY;
+  }
+  return (NSSCKMDObject *)NULL;
+}
+
+/*
+ * nss_ckmdSessionObject_Finalize
+ *
+ */
+static void
+nss_ckmdSessionObject_Finalize
+(
+  NSSCKMDObject *mdObject,
+  NSSCKFWObject *fwObject,
+  NSSCKMDSession *mdSession,
+  NSSCKFWSession *fwSession,
+  NSSCKMDToken *mdToken,
+  NSSCKFWToken *fwToken,
+  NSSCKMDInstance *mdInstance,
+  NSSCKFWInstance *fwInstance
+)
+{
+  /* This shouldn't ever be called */
+  return;
+}
+
+/*
+ * nss_ckmdSessionObject_Destroy
+ *
+ */
+
+static CK_RV
+nss_ckmdSessionObject_Destroy
+(
+  NSSCKMDObject *mdObject,
+  NSSCKFWObject *fwObject,
+  NSSCKMDSession *mdSession,
+  NSSCKFWSession *fwSession,
+  NSSCKMDToken *mdToken,
+  NSSCKFWToken *fwToken,
+  NSSCKMDInstance *mdInstance,
+  NSSCKFWInstance *fwInstance
+)
+{
+#ifdef NSSDEBUG
+  CK_RV error = CKR_OK;
+#endif /* NSSDEBUG */
+  nssCKMDSessionObject *mdso;
+  CK_ULONG i;
+
+#ifdef NSSDEBUG
+  error = nss_ckmdSessionObject_verifyPointer(mdObject);
+  if( CKR_OK != error ) {
+    return error;
+  }
+#endif /* NSSDEBUG */
+
+  mdso = (nssCKMDSessionObject *)mdObject->etc;
+
+  nssCKFWHash_Remove(mdso->hash, mdObject);
+
+  for( i = 0; i < mdso->n; i++ ) {
+    nss_ZFreeIf(mdso->attributes[i].data);
+  }
+  nss_ZFreeIf(mdso->attributes);
+  nss_ZFreeIf(mdso->types);
+  nss_ZFreeIf(mdso);
+  nss_ZFreeIf(mdObject);
+
+#ifdef DEBUG
+  (void)nss_ckmdSessionObject_remove_pointer(mdObject);
+#endif /* DEBUG */
+
+  return CKR_OK;
+}
+
+/*
+ * nss_ckmdSessionObject_IsTokenObject
+ *
+ */
+
+static CK_BBOOL
+nss_ckmdSessionObject_IsTokenObject
+(
+  NSSCKMDObject *mdObject,
+  NSSCKFWObject *fwObject,
+  NSSCKMDSession *mdSession,
+  NSSCKFWSession *fwSession,
+  NSSCKMDToken *mdToken,
+  NSSCKFWToken *fwToken,
+  NSSCKMDInstance *mdInstance,
+  NSSCKFWInstance *fwInstance
+)
+{
+#ifdef NSSDEBUG
+  if( CKR_OK != nss_ckmdSessionObject_verifyPointer(mdObject) ) {
+    return CK_FALSE;
+  }
+#endif /* NSSDEBUG */
+
+  /*
+   * This implementation is only ever used for session objects.
+   */
+  return CK_FALSE;
+}
+
+/*
+ * nss_ckmdSessionObject_GetAttributeCount
+ *
+ */
+static CK_ULONG
+nss_ckmdSessionObject_GetAttributeCount
+(
+  NSSCKMDObject *mdObject,
+  NSSCKFWObject *fwObject,
+  NSSCKMDSession *mdSession,
+  NSSCKFWSession *fwSession,
+  NSSCKMDToken *mdToken,
+  NSSCKFWToken *fwToken,
+  NSSCKMDInstance *mdInstance,
+  NSSCKFWInstance *fwInstance,
+  CK_RV *pError
+)
+{
+  nssCKMDSessionObject *obj;
+
+#ifdef NSSDEBUG
+  if (!pError) {
+    return 0;
+  }
+
+  *pError = nss_ckmdSessionObject_verifyPointer(mdObject);
+  if( CKR_OK != *pError ) {
+    return 0;
+  }
+
+  /* We could even check all the other arguments, for sanity. */
+#endif /* NSSDEBUG */
+
+  obj = (nssCKMDSessionObject *)mdObject->etc;
+
+  return obj->n;
+}
+
+/*
+ * nss_ckmdSessionObject_GetAttributeTypes
+ *
+ */
+static CK_RV
+nss_ckmdSessionObject_GetAttributeTypes
+(
+  NSSCKMDObject *mdObject,
+  NSSCKFWObject *fwObject,
+  NSSCKMDSession *mdSession,
+  NSSCKFWSession *fwSession,
+  NSSCKMDToken *mdToken,
+  NSSCKFWToken *fwToken,
+  NSSCKMDInstance *mdInstance,
+  NSSCKFWInstance *fwInstance,
+  CK_ATTRIBUTE_TYPE_PTR typeArray,
+  CK_ULONG ulCount
+)
+{
+#ifdef NSSDEBUG
+  CK_RV error = CKR_OK;
+#endif /* NSSDEBUG */
+  nssCKMDSessionObject *obj;
+
+#ifdef NSSDEBUG
+  error = nss_ckmdSessionObject_verifyPointer(mdObject);
+  if( CKR_OK != error ) {
+    return error;
+  }
+
+  /* We could even check all the other arguments, for sanity. */
+#endif /* NSSDEBUG */
+
+  obj = (nssCKMDSessionObject *)mdObject->etc;
+
+  if( ulCount < obj->n ) {
+    return CKR_BUFFER_TOO_SMALL;
+  }
+
+  (void)nsslibc_memcpy(typeArray, obj->types, 
+    sizeof(CK_ATTRIBUTE_TYPE) * obj->n);
+
+  return CKR_OK;
+}
+
+/*
+ * nss_ckmdSessionObject_GetAttributeSize
+ *
+ */
+static CK_ULONG
+nss_ckmdSessionObject_GetAttributeSize
+(
+  NSSCKMDObject *mdObject,
+  NSSCKFWObject *fwObject,
+  NSSCKMDSession *mdSession,
+  NSSCKFWSession *fwSession,
+  NSSCKMDToken *mdToken,
+  NSSCKFWToken *fwToken,
+  NSSCKMDInstance *mdInstance,
+  NSSCKFWInstance *fwInstance,
+  CK_ATTRIBUTE_TYPE attribute,
+  CK_RV *pError
+)
+{
+  nssCKMDSessionObject *obj;
+  CK_ULONG i;
+
+#ifdef NSSDEBUG
+  if (!pError) {
+    return 0;
+  }
+
+  *pError = nss_ckmdSessionObject_verifyPointer(mdObject);
+  if( CKR_OK != *pError ) {
+    return 0;
+  }
+
+  /* We could even check all the other arguments, for sanity. */
+#endif /* NSSDEBUG */
+
+  obj = (nssCKMDSessionObject *)mdObject->etc;
+
+  for( i = 0; i < obj->n; i++ ) {
+    if( attribute == obj->types[i] ) {
+      return (CK_ULONG)(obj->attributes[i].size);
+    }
+  }
+
+  *pError = CKR_ATTRIBUTE_TYPE_INVALID;
+  return 0;
+}
+
+/*
+ * nss_ckmdSessionObject_GetAttribute
+ *
+ */
+static NSSCKFWItem
+nss_ckmdSessionObject_GetAttribute
+(
+  NSSCKMDObject *mdObject,
+  NSSCKFWObject *fwObject,
+  NSSCKMDSession *mdSession,
+  NSSCKFWSession *fwSession,
+  NSSCKMDToken *mdToken,
+  NSSCKFWToken *fwToken,
+  NSSCKMDInstance *mdInstance,
+  NSSCKFWInstance *fwInstance,
+  CK_ATTRIBUTE_TYPE attribute,
+  CK_RV *pError
+)
+{
+  NSSCKFWItem item;
+  nssCKMDSessionObject *obj;
+  CK_ULONG i;
+
+  item.needsFreeing = PR_FALSE;
+  item.item = NULL;
+#ifdef NSSDEBUG
+  if (!pError) {
+    return item;
+  }
+
+  *pError = nss_ckmdSessionObject_verifyPointer(mdObject);
+  if( CKR_OK != *pError ) {
+    return item;
+  }
+
+  /* We could even check all the other arguments, for sanity. */
+#endif /* NSSDEBUG */
+
+  obj = (nssCKMDSessionObject *)mdObject->etc;
+
+  for( i = 0; i < obj->n; i++ ) {
+    if( attribute == obj->types[i] ) {
+      item.item = &obj->attributes[i];
+      return item;
+    }
+  }
+
+  *pError = CKR_ATTRIBUTE_TYPE_INVALID;
+  return item;
+}
+
+/*
+ * nss_ckmdSessionObject_SetAttribute
+ *
+ */
+
+/*
+ * Okay, so this implementation sucks.  It doesn't support removing
+ * an attribute (if value == NULL), and could be more graceful about
+ * memory.  It should allow "blank" slots in the arrays, with some
+ * invalid attribute type, and then it could support removal much
+ * more easily.  Do this later.
+ */
+static CK_RV
+nss_ckmdSessionObject_SetAttribute
+(
+  NSSCKMDObject *mdObject,
+  NSSCKFWObject *fwObject,
+  NSSCKMDSession *mdSession,
+  NSSCKFWSession *fwSession,
+  NSSCKMDToken *mdToken,
+  NSSCKFWToken *fwToken,
+  NSSCKMDInstance *mdInstance,
+  NSSCKFWInstance *fwInstance,
+  CK_ATTRIBUTE_TYPE attribute,
+  NSSItem *value
+)
+{
+  nssCKMDSessionObject *obj;
+  CK_ULONG i;
+  NSSItem n;
+  NSSItem *ra;
+  CK_ATTRIBUTE_TYPE_PTR rt;
+#ifdef NSSDEBUG
+  CK_RV error;
+#endif /* NSSDEBUG */
+
+#ifdef NSSDEBUG
+  error = nss_ckmdSessionObject_verifyPointer(mdObject);
+  if( CKR_OK != error ) {
+    return 0;
+  }
+
+  /* We could even check all the other arguments, for sanity. */
+#endif /* NSSDEBUG */
+
+  obj = (nssCKMDSessionObject *)mdObject->etc;
+
+  n.size = value->size;
+  n.data = nss_ZAlloc(obj->arena, n.size);
+  if (!n.data) {
+    return CKR_HOST_MEMORY;
+  }
+  (void)nsslibc_memcpy(n.data, value->data, n.size);
+
+  for( i = 0; i < obj->n; i++ ) {
+    if( attribute == obj->types[i] ) {
+      nss_ZFreeIf(obj->attributes[i].data);
+      obj->attributes[i] = n;
+      return CKR_OK;
+    }
+  }
+
+  /*
+   * It's new.
+   */
+
+  ra = (NSSItem *)nss_ZRealloc(obj->attributes, sizeof(NSSItem) * (obj->n + 1));
+  if (!ra) {
+    nss_ZFreeIf(n.data);
+    return CKR_HOST_MEMORY;
+  }
+  obj->attributes = ra;
+
+  rt = (CK_ATTRIBUTE_TYPE_PTR)nss_ZRealloc(obj->types, 
+                                      sizeof(CK_ATTRIBUTE_TYPE) * (obj->n + 1));
+  if (!rt) {
+    nss_ZFreeIf(n.data);
+    return CKR_HOST_MEMORY;
+  }
+
+  obj->types = rt;
+  obj->attributes[obj->n] = n;
+  obj->types[obj->n] = attribute;
+  obj->n++;
+
+  return CKR_OK;
+}
+
+/*
+ * nss_ckmdSessionObject_GetObjectSize
+ *
+ */
+static CK_ULONG
+nss_ckmdSessionObject_GetObjectSize
+(
+  NSSCKMDObject *mdObject,
+  NSSCKFWObject *fwObject,
+  NSSCKMDSession *mdSession,
+  NSSCKFWSession *fwSession,
+  NSSCKMDToken *mdToken,
+  NSSCKFWToken *fwToken,
+  NSSCKMDInstance *mdInstance,
+  NSSCKFWInstance *fwInstance,
+  CK_RV *pError
+)
+{
+  nssCKMDSessionObject *obj;
+  CK_ULONG i;
+  CK_ULONG rv = (CK_ULONG)0;
+
+#ifdef NSSDEBUG
+  if (!pError) {
+    return 0;
+  }
+
+  *pError = nss_ckmdSessionObject_verifyPointer(mdObject);
+  if( CKR_OK != *pError ) {
+    return 0;
+  }
+
+  /* We could even check all the other arguments, for sanity. */
+#endif /* NSSDEBUG */
+
+  obj = (nssCKMDSessionObject *)mdObject->etc;
+
+  for( i = 0; i < obj->n; i++ ) {
+    rv += obj->attributes[i].size;
+  }
+
+  rv += sizeof(NSSItem) * obj->n;
+  rv += sizeof(CK_ATTRIBUTE_TYPE) * obj->n;
+  rv += sizeof(nssCKMDSessionObject);
+
+  return rv;
+}
+
+/*
+ * nssCKMDFindSessionObjects
+ *
+ *  -- create --
+ *  nssCKMDFindSessionObjects_Create
+ *
+ *  -- EPV calls --
+ *  nss_ckmdFindSessionObjects_Final
+ *  nss_ckmdFindSessionObjects_Next
+ */
+
+struct nodeStr {
+  struct nodeStr *next;
+  NSSCKMDObject *mdObject;
+};
+
+struct nssCKMDFindSessionObjectsStr {
+  NSSArena *arena;
+  CK_RV error;
+  CK_ATTRIBUTE_PTR pTemplate;
+  CK_ULONG ulCount;
+  struct nodeStr *list;
+  nssCKFWHash *hash;
+
+};
+typedef struct nssCKMDFindSessionObjectsStr nssCKMDFindSessionObjects;
+
+#ifdef DEBUG
+/*
+ * But first, the pointer-tracking stuff.
+ *
+ * NOTE: the pointer-tracking support in NSS/base currently relies
+ * upon NSPR's CallOnce support.  That, however, relies upon NSPR's
+ * locking, which is tied into the runtime.  We need a pointer-tracker
+ * implementation that uses the locks supplied through C_Initialize.
+ * That support, however, can be filled in later.  So for now, I'll
+ * just do this routines as no-ops.
+ */
+
+static CK_RV
+nss_ckmdFindSessionObjects_add_pointer
+(
+  const NSSCKMDFindObjects *mdFindObjects
+)
+{
+  return CKR_OK;
+}
+
+static CK_RV
+nss_ckmdFindSessionObjects_remove_pointer
+(
+  const NSSCKMDFindObjects *mdFindObjects
+)
+{
+  return CKR_OK;
+}
+
+#ifdef NSS_DEBUG
+static CK_RV
+nss_ckmdFindSessionObjects_verifyPointer
+(
+  const NSSCKMDFindObjects *mdFindObjects
+)
+{
+  return CKR_OK;
+}
+#endif
+
+#endif /* DEBUG */
+
+/*
+ * We must forward-declare these routines.
+ */
+static void
+nss_ckmdFindSessionObjects_Final
+(
+  NSSCKMDFindObjects *mdFindObjects,
+  NSSCKFWFindObjects *fwFindObjects,
+  NSSCKMDSession *mdSession,
+  NSSCKFWSession *fwSession,
+  NSSCKMDToken *mdToken,
+  NSSCKFWToken *fwToken,
+  NSSCKMDInstance *mdInstance,
+  NSSCKFWInstance *fwInstance
+);
+
+static NSSCKMDObject *
+nss_ckmdFindSessionObjects_Next
+(
+  NSSCKMDFindObjects *mdFindObjects,
+  NSSCKFWFindObjects *fwFindObjects,
+  NSSCKMDSession *mdSession,
+  NSSCKFWSession *fwSession,
+  NSSCKMDToken *mdToken,
+  NSSCKFWToken *fwToken,
+  NSSCKMDInstance *mdInstance,
+  NSSCKFWInstance *fwInstance,
+  NSSArena *arena,
+  CK_RV *pError
+);
+
+static CK_BBOOL
+items_match
+(
+  NSSItem *a,
+  CK_VOID_PTR pValue,
+  CK_ULONG ulValueLen
+)
+{
+  if( a->size != ulValueLen ) {
+    return CK_FALSE;
+  }
+
+  if( PR_TRUE == nsslibc_memequal(a->data, pValue, ulValueLen, (PRStatus *)NULL) ) {
+    return CK_TRUE;
+  } else {
+    return CK_FALSE;
+  }
+}
+
+/*
+ * Our hashtable iterator
+ */
+static void
+findfcn
+(
+  const void *key,
+  void *value,
+  void *closure
+)
+{
+  NSSCKMDObject *mdObject = (NSSCKMDObject *)value;
+  nssCKMDSessionObject *mdso = (nssCKMDSessionObject *)mdObject->etc;
+  nssCKMDFindSessionObjects *mdfso = (nssCKMDFindSessionObjects *)closure;
+  CK_ULONG i, j;
+  struct nodeStr *node;
+
+  if( CKR_OK != mdfso->error ) {
+    return;
+  }
+
+  for( i = 0; i < mdfso->ulCount; i++ ) {
+    CK_ATTRIBUTE_PTR p = &mdfso->pTemplate[i];
+
+    for( j = 0; j < mdso->n; j++ ) {
+      if( mdso->types[j] == p->type ) {
+        if( !items_match(&mdso->attributes[j], p->pValue, p->ulValueLen) ) {
+          return;
+        } else {
+          break;
+        }
+      }
+    }
+
+    if( j == mdso->n ) {
+      /* Attribute not found */
+      return;
+    }
+  }
+
+  /* Matches */
+  node = nss_ZNEW(mdfso->arena, struct nodeStr);
+  if( (struct nodeStr *)NULL == node ) {
+    mdfso->error = CKR_HOST_MEMORY;
+    return;
+  }
+
+  node->mdObject = mdObject;
+  node->next = mdfso->list;
+  mdfso->list = node;
+
+  return;
+}
+
+/*
+ * nssCKMDFindSessionObjects_Create
+ *
+ */
+NSS_IMPLEMENT NSSCKMDFindObjects *
+nssCKMDFindSessionObjects_Create
+(
+  NSSCKFWToken *fwToken,
+  CK_ATTRIBUTE_PTR pTemplate,
+  CK_ULONG ulCount,
+  CK_RV *pError
+)
+{
+  NSSArena *arena;
+  nssCKMDFindSessionObjects *mdfso;
+  nssCKFWHash *hash;
+  NSSCKMDFindObjects *rv;
+
+#ifdef NSSDEBUG
+  if (!pError) {
+    return (NSSCKMDFindObjects *)NULL;
+  }
+
+  *pError = nssCKFWToken_verifyPointer(fwToken);
+  if( CKR_OK != *pError ) {
+    return (NSSCKMDFindObjects *)NULL;
+  }
+
+  if( (CK_ATTRIBUTE_PTR)NULL == pTemplate ) {
+    *pError = CKR_ARGUMENTS_BAD;
+    return (NSSCKMDFindObjects *)NULL;
+  }
+#endif /* NSSDEBUG */
+
+  *pError = CKR_OK;
+
+  hash = nssCKFWToken_GetSessionObjectHash(fwToken);
+  if (!hash) {
+    *pError= CKR_GENERAL_ERROR;
+    return (NSSCKMDFindObjects *)NULL;
+  }
+
+  arena = NSSArena_Create();
+  if (!arena) {
+    *pError = CKR_HOST_MEMORY;
+    return (NSSCKMDFindObjects *)NULL;
+  }
+
+  mdfso = nss_ZNEW(arena, nssCKMDFindSessionObjects);
+  if (!mdfso) {
+    goto loser;
+  }
+
+  rv = nss_ZNEW(arena, NSSCKMDFindObjects);
+  if(rv == NULL) {
+    goto loser;
+  }
+
+  mdfso->error = CKR_OK;
+  mdfso->pTemplate = pTemplate;
+  mdfso->ulCount = ulCount;
+  mdfso->hash = hash;
+
+  nssCKFWHash_Iterate(hash, findfcn, mdfso);
+
+  if( CKR_OK != mdfso->error ) {
+    goto loser;
+  }
+
+  rv->etc = (void *)mdfso;
+  rv->Final = nss_ckmdFindSessionObjects_Final;
+  rv->Next = nss_ckmdFindSessionObjects_Next;
+
+#ifdef DEBUG
+  if( (*pError = nss_ckmdFindSessionObjects_add_pointer(rv)) != CKR_OK ) {
+    goto loser;
+  }
+#endif /* DEBUG */    
+  mdfso->arena = arena;
+
+  return rv;
+
+loser:
+  if (arena) {
+    NSSArena_Destroy(arena);
+  }
+  if (*pError == CKR_OK) {
+      *pError = CKR_HOST_MEMORY;
+  }
+  return NULL;
+}
+
+static void
+nss_ckmdFindSessionObjects_Final
+(
+  NSSCKMDFindObjects *mdFindObjects,
+  NSSCKFWFindObjects *fwFindObjects,
+  NSSCKMDSession *mdSession,
+  NSSCKFWSession *fwSession,
+  NSSCKMDToken *mdToken,
+  NSSCKFWToken *fwToken,
+  NSSCKMDInstance *mdInstance,
+  NSSCKFWInstance *fwInstance
+)
+{
+  nssCKMDFindSessionObjects *mdfso;
+
+#ifdef NSSDEBUG
+  if( CKR_OK != nss_ckmdFindSessionObjects_verifyPointer(mdFindObjects) ) {
+    return;
+  }
+#endif /* NSSDEBUG */
+
+  mdfso = (nssCKMDFindSessionObjects *)mdFindObjects->etc;
+  if (mdfso->arena) NSSArena_Destroy(mdfso->arena);
+
+#ifdef DEBUG
+  (void)nss_ckmdFindSessionObjects_remove_pointer(mdFindObjects);
+#endif /* DEBUG */
+
+  return;
+}
+
+static NSSCKMDObject *
+nss_ckmdFindSessionObjects_Next
+(
+  NSSCKMDFindObjects *mdFindObjects,
+  NSSCKFWFindObjects *fwFindObjects,
+  NSSCKMDSession *mdSession,
+  NSSCKFWSession *fwSession,
+  NSSCKMDToken *mdToken,
+  NSSCKFWToken *fwToken,
+  NSSCKMDInstance *mdInstance,
+  NSSCKFWInstance *fwInstance,
+  NSSArena *arena,
+  CK_RV *pError
+)
+{
+  nssCKMDFindSessionObjects *mdfso;
+  NSSCKMDObject *rv = (NSSCKMDObject *)NULL;
+
+#ifdef NSSDEBUG
+  if( CKR_OK != nss_ckmdFindSessionObjects_verifyPointer(mdFindObjects) ) {
+    return (NSSCKMDObject *)NULL;
+  }
+#endif /* NSSDEBUG */
+
+  mdfso = (nssCKMDFindSessionObjects *)mdFindObjects->etc;
+
+  while (!rv) {
+    if( (struct nodeStr *)NULL == mdfso->list ) {
+      *pError = CKR_OK;
+      return (NSSCKMDObject *)NULL;
+    }
+
+    if( nssCKFWHash_Exists(mdfso->hash, mdfso->list->mdObject) ) {
+      rv = mdfso->list->mdObject;
+    }
+
+    mdfso->list = mdfso->list->next;
+  }
+
+  return rv;
+}