Add all NSS files to allow using a complete NSS in the future.

nss/mozilla/security/nss/lib/ckfw/slot.c

Index: nss/mozilla/security/nss/lib/ckfw/slot.c
===================================================================
--- nss/mozilla/security/nss/lib/ckfw/slot.c	(revision 0)
+++ nss/mozilla/security/nss/lib/ckfw/slot.c	(revision 0)
@@ -0,0 +1,759 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is the Netscape security libraries.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1994-2000
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+#ifdef DEBUG
+static const char CVS_ID[] = "@(#) $RCSfile: slot.c,v $ $Revision: 1.7 $ $Date: 2009/02/09 07:55:53 $";
+#endif /* DEBUG */
+
+/*
+ * slot.c
+ *
+ * This file implements the NSSCKFWSlot type and methods.
+ */
+
+#ifndef CK_T
+#include "ck.h"
+#endif /* CK_T */
+
+/*
+ * NSSCKFWSlot
+ *
+ *  -- create/destroy --
+ *  nssCKFWSlot_Create
+ *  nssCKFWSlot_Destroy
+ *
+ *  -- public accessors --
+ *  NSSCKFWSlot_GetMDSlot
+ *  NSSCKFWSlot_GetFWInstance
+ *  NSSCKFWSlot_GetMDInstance
+ *
+ *  -- implement public accessors --
+ *  nssCKFWSlot_GetMDSlot
+ *  nssCKFWSlot_GetFWInstance
+ *  nssCKFWSlot_GetMDInstance
+ *
+ *  -- private accessors --
+ *  nssCKFWSlot_GetSlotID
+ *  nssCKFWSlot_ClearToken
+ *
+ *  -- module fronts --
+ *  nssCKFWSlot_GetSlotDescription
+ *  nssCKFWSlot_GetManufacturerID
+ *  nssCKFWSlot_GetTokenPresent
+ *  nssCKFWSlot_GetRemovableDevice
+ *  nssCKFWSlot_GetHardwareSlot
+ *  nssCKFWSlot_GetHardwareVersion
+ *  nssCKFWSlot_GetFirmwareVersion
+ *  nssCKFWSlot_InitToken
+ *  nssCKFWSlot_GetToken
+ */
+
+struct NSSCKFWSlotStr {
+  NSSCKFWMutex *mutex;
+  NSSCKMDSlot *mdSlot;
+  NSSCKFWInstance *fwInstance;
+  NSSCKMDInstance *mdInstance;
+  CK_SLOT_ID slotID;
+
+  /*
+   * Everything above is set at creation time, and then not modified.
+   * The invariants the mutex protects are:
+   *
+   * 1) Each of the cached descriptions (versions, etc.) are in an
+   *    internally consistant state.
+   *
+   * 2) The fwToken points to the token currently in the slot, and
+   *    it is in a consistant state.
+   *
+   * Note that the calls accessing the cached descriptions will
+   * call the NSSCKMDSlot methods with the mutex locked.  Those
+   * methods may then call the public NSSCKFWSlot routines.  Those
+   * public routines only access the constant data above, so there's
+   * no problem.  But be careful if you add to this object; mutexes
+   * are in general not reentrant, so don't create deadlock situations.
+   */
+
+  NSSUTF8 *slotDescription;
+  NSSUTF8 *manufacturerID;
+  CK_VERSION hardwareVersion;
+  CK_VERSION firmwareVersion;
+  NSSCKFWToken *fwToken;
+};
+
+#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
+slot_add_pointer
+(
+  const NSSCKFWSlot *fwSlot
+)
+{
+  return CKR_OK;
+}
+
+static CK_RV
+slot_remove_pointer
+(
+  const NSSCKFWSlot *fwSlot
+)
+{
+  return CKR_OK;
+}
+
+NSS_IMPLEMENT CK_RV
+nssCKFWSlot_verifyPointer
+(
+  const NSSCKFWSlot *fwSlot
+)
+{
+  return CKR_OK;
+}
+
+#endif /* DEBUG */
+
+/*
+ * nssCKFWSlot_Create
+ *
+ */
+NSS_IMPLEMENT NSSCKFWSlot *
+nssCKFWSlot_Create
+(
+  NSSCKFWInstance *fwInstance,
+  NSSCKMDSlot *mdSlot,
+  CK_SLOT_ID slotID,
+  CK_RV *pError
+)
+{
+  NSSCKFWSlot *fwSlot;
+  NSSCKMDInstance *mdInstance;
+  NSSArena *arena;
+
+#ifdef NSSDEBUG
+  if (!pError) {
+    return (NSSCKFWSlot *)NULL;
+  }
+
+  *pError = nssCKFWInstance_verifyPointer(fwInstance);
+  if( CKR_OK != *pError ) {
+    return (NSSCKFWSlot *)NULL;
+  }
+#endif /* NSSDEBUG */
+
+  mdInstance = nssCKFWInstance_GetMDInstance(fwInstance);
+  if (!mdInstance) {
+    *pError = CKR_GENERAL_ERROR;
+    return (NSSCKFWSlot *)NULL;
+  }
+
+  arena = nssCKFWInstance_GetArena(fwInstance, pError);
+  if (!arena) {
+    if( CKR_OK == *pError ) {
+      *pError = CKR_GENERAL_ERROR;
+    }
+  }
+
+  fwSlot = nss_ZNEW(arena, NSSCKFWSlot);
+  if (!fwSlot) {
+    *pError = CKR_HOST_MEMORY;
+    return (NSSCKFWSlot *)NULL;
+  }
+
+  fwSlot->mdSlot = mdSlot;
+  fwSlot->fwInstance = fwInstance;
+  fwSlot->mdInstance = mdInstance;
+  fwSlot->slotID = slotID;
+
+  fwSlot->mutex = nssCKFWInstance_CreateMutex(fwInstance, arena, pError);
+  if (!fwSlot->mutex) {
+    if( CKR_OK == *pError ) {
+      *pError = CKR_GENERAL_ERROR;
+    }
+    (void)nss_ZFreeIf(fwSlot);
+    return (NSSCKFWSlot *)NULL;
+  }
+
+  if (mdSlot->Initialize) {
+    *pError = CKR_OK;
+    *pError = mdSlot->Initialize(mdSlot, fwSlot, mdInstance, fwInstance);
+    if( CKR_OK != *pError ) {
+      (void)nssCKFWMutex_Destroy(fwSlot->mutex);
+      (void)nss_ZFreeIf(fwSlot);
+      return (NSSCKFWSlot *)NULL;
+    }
+  }
+
+#ifdef DEBUG
+  *pError = slot_add_pointer(fwSlot);
+  if( CKR_OK != *pError ) {
+    if (mdSlot->Destroy) {
+      mdSlot->Destroy(mdSlot, fwSlot, mdInstance, fwInstance);
+    }
+
+    (void)nssCKFWMutex_Destroy(fwSlot->mutex);
+    (void)nss_ZFreeIf(fwSlot);
+    return (NSSCKFWSlot *)NULL;
+  }
+#endif /* DEBUG */
+
+  return fwSlot;
+}
+
+/*
+ * nssCKFWSlot_Destroy
+ *
+ */
+NSS_IMPLEMENT CK_RV
+nssCKFWSlot_Destroy
+(
+  NSSCKFWSlot *fwSlot
+)
+{
+  CK_RV error = CKR_OK;
+
+#ifdef NSSDEBUG
+  error = nssCKFWSlot_verifyPointer(fwSlot);
+  if( CKR_OK != error ) {
+    return error;
+  }
+#endif /* NSSDEBUG */
+  if (fwSlot->fwToken) {
+    nssCKFWToken_Destroy(fwSlot->fwToken);
+  }
+
+  (void)nssCKFWMutex_Destroy(fwSlot->mutex);
+
+  if (fwSlot->mdSlot->Destroy) {
+    fwSlot->mdSlot->Destroy(fwSlot->mdSlot, fwSlot, 
+      fwSlot->mdInstance, fwSlot->fwInstance);
+  }
+
+#ifdef DEBUG
+  error = slot_remove_pointer(fwSlot);
+#endif /* DEBUG */
+  (void)nss_ZFreeIf(fwSlot);
+  return error;
+}
+
+/*
+ * nssCKFWSlot_GetMDSlot
+ *
+ */
+NSS_IMPLEMENT NSSCKMDSlot *
+nssCKFWSlot_GetMDSlot
+(
+  NSSCKFWSlot *fwSlot
+)
+{
+#ifdef NSSDEBUG
+  if( CKR_OK != nssCKFWSlot_verifyPointer(fwSlot) ) {
+    return (NSSCKMDSlot *)NULL;
+  }
+#endif /* NSSDEBUG */
+
+  return fwSlot->mdSlot;
+}
+
+/*
+ * nssCKFWSlot_GetFWInstance
+ *
+ */
+
+NSS_IMPLEMENT NSSCKFWInstance *
+nssCKFWSlot_GetFWInstance
+(
+  NSSCKFWSlot *fwSlot
+)
+{
+#ifdef NSSDEBUG
+  if( CKR_OK != nssCKFWSlot_verifyPointer(fwSlot) ) {
+    return (NSSCKFWInstance *)NULL;
+  }
+#endif /* NSSDEBUG */
+
+  return fwSlot->fwInstance;
+}
+
+/*
+ * nssCKFWSlot_GetMDInstance
+ *
+ */
+
+NSS_IMPLEMENT NSSCKMDInstance *
+nssCKFWSlot_GetMDInstance
+(
+  NSSCKFWSlot *fwSlot
+)
+{
+#ifdef NSSDEBUG
+  if( CKR_OK != nssCKFWSlot_verifyPointer(fwSlot) ) {
+    return (NSSCKMDInstance *)NULL;
+  }
+#endif /* NSSDEBUG */
+
+  return fwSlot->mdInstance;
+}
+
+/*
+ * nssCKFWSlot_GetSlotID
+ *
+ */
+NSS_IMPLEMENT CK_SLOT_ID
+nssCKFWSlot_GetSlotID
+(
+  NSSCKFWSlot *fwSlot
+)
+{
+#ifdef NSSDEBUG
+  if( CKR_OK != nssCKFWSlot_verifyPointer(fwSlot) ) {
+    return (CK_SLOT_ID)0;
+  }
+#endif /* NSSDEBUG */
+
+  return fwSlot->slotID;
+}
+
+/*
+ * nssCKFWSlot_GetSlotDescription
+ *
+ */
+NSS_IMPLEMENT CK_RV
+nssCKFWSlot_GetSlotDescription
+(
+  NSSCKFWSlot *fwSlot,
+  CK_CHAR slotDescription[64]
+)
+{
+  CK_RV error = CKR_OK;
+
+#ifdef NSSDEBUG
+  if( (CK_CHAR_PTR)NULL == slotDescription ) {
+    return CKR_ARGUMENTS_BAD;
+  }
+
+  error = nssCKFWSlot_verifyPointer(fwSlot);
+  if( CKR_OK != error ) {
+    return error;
+  }
+#endif /* NSSDEBUG */
+
+  error = nssCKFWMutex_Lock(fwSlot->mutex);
+  if( CKR_OK != error ) {
+    return error;
+  }
+
+  if (!fwSlot->slotDescription) {
+    if (fwSlot->mdSlot->GetSlotDescription) {
+      fwSlot->slotDescription = fwSlot->mdSlot->GetSlotDescription(
+        fwSlot->mdSlot, fwSlot, fwSlot->mdInstance, 
+        fwSlot->fwInstance, &error);
+      if ((!fwSlot->slotDescription) && (CKR_OK != error)) {
+        goto done;
+      }
+    } else {
+      fwSlot->slotDescription = (NSSUTF8 *) "";
+    }
+  }
+
+  (void)nssUTF8_CopyIntoFixedBuffer(fwSlot->slotDescription, (char *)slotDescription, 64, ' ');
+  error = CKR_OK;
+
+ done:
+  (void)nssCKFWMutex_Unlock(fwSlot->mutex);
+  return error;
+}
+
+/*
+ * nssCKFWSlot_GetManufacturerID
+ *
+ */
+NSS_IMPLEMENT CK_RV
+nssCKFWSlot_GetManufacturerID
+(
+  NSSCKFWSlot *fwSlot,
+  CK_CHAR manufacturerID[32]
+)
+{
+  CK_RV error = CKR_OK;
+
+#ifdef NSSDEBUG
+  if( (CK_CHAR_PTR)NULL == manufacturerID ) {
+    return CKR_ARGUMENTS_BAD;
+  }
+
+  error = nssCKFWSlot_verifyPointer(fwSlot);
+  if( CKR_OK != error ) {
+    return error;
+  }
+#endif /* NSSDEBUG */
+
+  error = nssCKFWMutex_Lock(fwSlot->mutex);
+  if( CKR_OK != error ) {
+    return error;
+  }
+
+  if (!fwSlot->manufacturerID) {
+    if (fwSlot->mdSlot->GetManufacturerID) {
+      fwSlot->manufacturerID = fwSlot->mdSlot->GetManufacturerID(
+        fwSlot->mdSlot, fwSlot, fwSlot->mdInstance, 
+        fwSlot->fwInstance, &error);
+      if ((!fwSlot->manufacturerID) && (CKR_OK != error)) {
+        goto done;
+      }
+    } else {
+      fwSlot->manufacturerID = (NSSUTF8 *) "";
+    }
+  }
+
+  (void)nssUTF8_CopyIntoFixedBuffer(fwSlot->manufacturerID, (char *)manufacturerID, 32, ' ');
+  error = CKR_OK;
+
+ done:
+  (void)nssCKFWMutex_Unlock(fwSlot->mutex);
+  return error;
+}
+
+/*
+ * nssCKFWSlot_GetTokenPresent
+ *
+ */
+NSS_IMPLEMENT CK_BBOOL
+nssCKFWSlot_GetTokenPresent
+(
+  NSSCKFWSlot *fwSlot
+)
+{
+#ifdef NSSDEBUG
+  if( CKR_OK != nssCKFWSlot_verifyPointer(fwSlot) ) {
+    return CK_FALSE;
+  }
+#endif /* NSSDEBUG */
+
+  if (!fwSlot->mdSlot->GetTokenPresent) {
+    return CK_TRUE;
+  }
+
+  return fwSlot->mdSlot->GetTokenPresent(fwSlot->mdSlot, fwSlot,
+    fwSlot->mdInstance, fwSlot->fwInstance);
+}
+
+/*
+ * nssCKFWSlot_GetRemovableDevice
+ *
+ */
+NSS_IMPLEMENT CK_BBOOL
+nssCKFWSlot_GetRemovableDevice
+(
+  NSSCKFWSlot *fwSlot
+)
+{
+#ifdef NSSDEBUG
+  if( CKR_OK != nssCKFWSlot_verifyPointer(fwSlot) ) {
+    return CK_FALSE;
+  }
+#endif /* NSSDEBUG */
+
+  if (!fwSlot->mdSlot->GetRemovableDevice) {
+    return CK_FALSE;
+  }
+
+  return fwSlot->mdSlot->GetRemovableDevice(fwSlot->mdSlot, fwSlot,
+    fwSlot->mdInstance, fwSlot->fwInstance);
+}
+
+/*
+ * nssCKFWSlot_GetHardwareSlot
+ *
+ */
+NSS_IMPLEMENT CK_BBOOL
+nssCKFWSlot_GetHardwareSlot
+(
+  NSSCKFWSlot *fwSlot
+)
+{
+#ifdef NSSDEBUG
+  if( CKR_OK != nssCKFWSlot_verifyPointer(fwSlot) ) {
+    return CK_FALSE;
+  }
+#endif /* NSSDEBUG */
+
+  if (!fwSlot->mdSlot->GetHardwareSlot) {
+    return CK_FALSE;
+  }
+
+  return fwSlot->mdSlot->GetHardwareSlot(fwSlot->mdSlot, fwSlot,
+    fwSlot->mdInstance, fwSlot->fwInstance);
+}
+
+/*
+ * nssCKFWSlot_GetHardwareVersion
+ *
+ */
+NSS_IMPLEMENT CK_VERSION
+nssCKFWSlot_GetHardwareVersion
+(
+  NSSCKFWSlot *fwSlot
+)
+{
+  CK_VERSION rv;
+
+#ifdef NSSDEBUG
+  if( CKR_OK != nssCKFWSlot_verifyPointer(fwSlot) ) {
+    rv.major = rv.minor = 0;
+    return rv;
+  }
+#endif /* NSSDEBUG */
+
+  if( CKR_OK != nssCKFWMutex_Lock(fwSlot->mutex) ) {
+    rv.major = rv.minor = 0;
+    return rv;
+  }
+
+  if( (0 != fwSlot->hardwareVersion.major) ||
+      (0 != fwSlot->hardwareVersion.minor) ) {
+    rv = fwSlot->hardwareVersion;
+    goto done;
+  }
+
+  if (fwSlot->mdSlot->GetHardwareVersion) {
+    fwSlot->hardwareVersion = fwSlot->mdSlot->GetHardwareVersion(
+      fwSlot->mdSlot, fwSlot, fwSlot->mdInstance, fwSlot->fwInstance);
+  } else {
+    fwSlot->hardwareVersion.major = 0;
+    fwSlot->hardwareVersion.minor = 1;
+  }
+
+  rv = fwSlot->hardwareVersion;
+ done:
+  (void)nssCKFWMutex_Unlock(fwSlot->mutex);
+  return rv;
+}
+
+/*
+ * nssCKFWSlot_GetFirmwareVersion
+ *
+ */
+NSS_IMPLEMENT CK_VERSION
+nssCKFWSlot_GetFirmwareVersion
+(
+  NSSCKFWSlot *fwSlot
+)
+{
+  CK_VERSION rv;
+
+#ifdef NSSDEBUG
+  if( CKR_OK != nssCKFWSlot_verifyPointer(fwSlot) ) {
+    rv.major = rv.minor = 0;
+    return rv;
+  }
+#endif /* NSSDEBUG */
+
+  if( CKR_OK != nssCKFWMutex_Lock(fwSlot->mutex) ) {
+    rv.major = rv.minor = 0;
+    return rv;
+  }
+
+  if( (0 != fwSlot->firmwareVersion.major) ||
+      (0 != fwSlot->firmwareVersion.minor) ) {
+    rv = fwSlot->firmwareVersion;
+    goto done;
+  }
+
+  if (fwSlot->mdSlot->GetFirmwareVersion) {
+    fwSlot->firmwareVersion = fwSlot->mdSlot->GetFirmwareVersion(
+      fwSlot->mdSlot, fwSlot, fwSlot->mdInstance, fwSlot->fwInstance);
+  } else {
+    fwSlot->firmwareVersion.major = 0;
+    fwSlot->firmwareVersion.minor = 1;
+  }
+
+  rv = fwSlot->firmwareVersion;
+ done:
+  (void)nssCKFWMutex_Unlock(fwSlot->mutex);
+  return rv;
+}
+
+/*
+ * nssCKFWSlot_GetToken
+ * 
+ */
+NSS_IMPLEMENT NSSCKFWToken *
+nssCKFWSlot_GetToken
+(
+  NSSCKFWSlot *fwSlot,
+  CK_RV *pError
+)
+{
+  NSSCKMDToken *mdToken;
+  NSSCKFWToken *fwToken;
+
+#ifdef NSSDEBUG
+  if (!pError) {
+    return (NSSCKFWToken *)NULL;
+  }
+
+  *pError = nssCKFWSlot_verifyPointer(fwSlot);
+  if( CKR_OK != *pError ) {
+    return (NSSCKFWToken *)NULL;
+  }
+#endif /* NSSDEBUG */
+
+  *pError = nssCKFWMutex_Lock(fwSlot->mutex);
+  if( CKR_OK != *pError ) {
+    return (NSSCKFWToken *)NULL;
+  }
+
+  if (!fwSlot->fwToken) {
+    if (!fwSlot->mdSlot->GetToken) {
+      *pError = CKR_GENERAL_ERROR;
+      fwToken = (NSSCKFWToken *)NULL;
+      goto done;
+    }
+
+    mdToken = fwSlot->mdSlot->GetToken(fwSlot->mdSlot, fwSlot,
+      fwSlot->mdInstance, fwSlot->fwInstance, pError);
+    if (!mdToken) {
+      if( CKR_OK == *pError ) {
+        *pError = CKR_GENERAL_ERROR;
+      }
+      return (NSSCKFWToken *)NULL;
+    }
+
+    fwToken = nssCKFWToken_Create(fwSlot, mdToken, pError);
+    fwSlot->fwToken = fwToken;
+  } else {
+    fwToken = fwSlot->fwToken;
+  }
+
+ done:
+  (void)nssCKFWMutex_Unlock(fwSlot->mutex);
+  return fwToken;
+}
+
+/*
+ * nssCKFWSlot_ClearToken
+ *
+ */
+NSS_IMPLEMENT void
+nssCKFWSlot_ClearToken
+(
+  NSSCKFWSlot *fwSlot
+)
+{
+#ifdef NSSDEBUG
+  if( CKR_OK != nssCKFWSlot_verifyPointer(fwSlot) ) {
+    return;
+  }
+#endif /* NSSDEBUG */
+
+  if( CKR_OK != nssCKFWMutex_Lock(fwSlot->mutex) ) {
+    /* Now what? */
+    return;
+  }
+
+  fwSlot->fwToken = (NSSCKFWToken *)NULL;
+  (void)nssCKFWMutex_Unlock(fwSlot->mutex);
+  return;
+}
+
+/*
+ * NSSCKFWSlot_GetMDSlot
+ *
+ */
+
+NSS_IMPLEMENT NSSCKMDSlot *
+NSSCKFWSlot_GetMDSlot
+(
+  NSSCKFWSlot *fwSlot
+)
+{
+#ifdef DEBUG
+  if( CKR_OK != nssCKFWSlot_verifyPointer(fwSlot) ) {
+    return (NSSCKMDSlot *)NULL;
+  }
+#endif /* DEBUG */
+
+  return nssCKFWSlot_GetMDSlot(fwSlot);
+}
+
+/*
+ * NSSCKFWSlot_GetFWInstance
+ *
+ */
+
+NSS_IMPLEMENT NSSCKFWInstance *
+NSSCKFWSlot_GetFWInstance
+(
+  NSSCKFWSlot *fwSlot
+)
+{
+#ifdef DEBUG
+  if( CKR_OK != nssCKFWSlot_verifyPointer(fwSlot) ) {
+    return (NSSCKFWInstance *)NULL;
+  }
+#endif /* DEBUG */
+
+  return nssCKFWSlot_GetFWInstance(fwSlot);
+}
+
+/*
+ * NSSCKFWSlot_GetMDInstance
+ *
+ */
+
+NSS_IMPLEMENT NSSCKMDInstance *
+NSSCKFWSlot_GetMDInstance
+(
+  NSSCKFWSlot *fwSlot
+)
+{
+#ifdef DEBUG
+  if( CKR_OK != nssCKFWSlot_verifyPointer(fwSlot) ) {
+    return (NSSCKMDInstance *)NULL;
+  }
+#endif /* DEBUG */
+
+  return nssCKFWSlot_GetMDInstance(fwSlot);
+}
Property changes on: nss/mozilla/security/nss/lib/ckfw/slot.c
___________________________________________________________________
Added: svn:eol-style
   + LF