Update NSPR to 4.12 and NSS to 3.23 on iOS

nss/lib/ckfw/token.c

 /* 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/. */
 
 /*
  * token.c
  *
  * This file implements the NSSCKFWToken type and methods.
  */
 
@@ skipping 57 matching lines @@
  *  nssCKFWToken_GetHardwareVersion
  *  nssCKFWToken_GetFirmwareVersion
  *  nssCKFWToken_GetUTCTime
  *  nssCKFWToken_OpenSession
  *  nssCKFWToken_GetMechanismCount
  *  nssCKFWToken_GetMechanismTypes
  *  nssCKFWToken_GetMechanism
  */
 
 struct NSSCKFWTokenStr {
-  NSSCKFWMutex *mutex;
-  NSSArena *arena;
-  NSSCKMDToken *mdToken;
-  NSSCKFWSlot *fwSlot;
-  NSSCKMDSlot *mdSlot;
-  NSSCKFWInstance *fwInstance;
-  NSSCKMDInstance *mdInstance;
+    NSSCKFWMutex *mutex;
+    NSSArena *arena;
+    NSSCKMDToken *mdToken;
+    NSSCKFWSlot *fwSlot;
+    NSSCKMDSlot *mdSlot;
+    NSSCKFWInstance *fwInstance;
+    NSSCKMDInstance *mdInstance;
 
-  /*
-   * 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 session counts and hashes are consistant.
-   *
-   * 3) The object hashes are consistant.
-   *
-   * Note that the calls accessing the cached descriptions will call
-   * the NSSCKMDToken methods with the mutex locked.  Those methods
-   * may then call the public NSSCKFWToken routines.  Those public
-   * routines only access the constant data above and the atomic
-   * CK_STATE session state variable below, 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.
-   */
+    /*
+     * 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 session counts and hashes are consistant.
+     *
+     * 3) The object hashes are consistant.
+     *
+     * Note that the calls accessing the cached descriptions will call
+     * the NSSCKMDToken methods with the mutex locked.  Those methods
+     * may then call the public NSSCKFWToken routines.  Those public
+     * routines only access the constant data above and the atomic
+     * CK_STATE session state variable below, 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 *label;
-  NSSUTF8 *manufacturerID;
-  NSSUTF8 *model;
-  NSSUTF8 *serialNumber;
-  CK_VERSION hardwareVersion;
-  CK_VERSION firmwareVersion;
+    NSSUTF8 *label;
+    NSSUTF8 *manufacturerID;
+    NSSUTF8 *model;
+    NSSUTF8 *serialNumber;
+    CK_VERSION hardwareVersion;
+    CK_VERSION firmwareVersion;
 
-  CK_ULONG sessionCount;
-  CK_ULONG rwSessionCount;
-  nssCKFWHash *sessions;
-  nssCKFWHash *sessionObjectHash;
-  nssCKFWHash *mdObjectHash;
-  nssCKFWHash *mdMechanismHash;
+    CK_ULONG sessionCount;
+    CK_ULONG rwSessionCount;
+    nssCKFWHash *sessions;
+    nssCKFWHash *sessionObjectHash;
+    nssCKFWHash *mdObjectHash;
+    nssCKFWHash *mdMechanismHash;
 
-  CK_STATE state;
+    CK_STATE state;
 };
 
 #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
-token_add_pointer
-(
-  const NSSCKFWToken *fwToken
-)
+token_add_pointer(
+    const NSSCKFWToken *fwToken)
 {
-  return CKR_OK;
+    return CKR_OK;
 }
 
 static CK_RV
-token_remove_pointer
-(
-  const NSSCKFWToken *fwToken
-)
+token_remove_pointer(
+    const NSSCKFWToken *fwToken)
 {
-  return CKR_OK;
+    return CKR_OK;
 }
 
 NSS_IMPLEMENT CK_RV
-nssCKFWToken_verifyPointer
-(
-  const NSSCKFWToken *fwToken
-)
+nssCKFWToken_verifyPointer(
+    const NSSCKFWToken *fwToken)
 {
-  return CKR_OK;
+    return CKR_OK;
 }
 
 #endif /* DEBUG */
 
 /*
  * nssCKFWToken_Create
  *
  */
 NSS_IMPLEMENT NSSCKFWToken *
-nssCKFWToken_Create
-(
-  NSSCKFWSlot *fwSlot,
-  NSSCKMDToken *mdToken,
-  CK_RV *pError
-)
+nssCKFWToken_Create(
+    NSSCKFWSlot *fwSlot,
+    NSSCKMDToken *mdToken,
+    CK_RV *pError)
 {
-  NSSArena *arena = (NSSArena *)NULL;
-  NSSCKFWToken *fwToken = (NSSCKFWToken *)NULL;
-  CK_BBOOL called_setup = CK_FALSE;
+    NSSArena *arena = (NSSArena *)NULL;
+    NSSCKFWToken *fwToken = (NSSCKFWToken *)NULL;
+    CK_BBOOL called_setup = CK_FALSE;
 
-  /*
-   * We have already verified the arguments in nssCKFWSlot_GetToken.
-   */
+    /*
+     * We have already verified the arguments in nssCKFWSlot_GetToken.
+     */
 
-  arena = NSSArena_Create();
-  if (!arena) {
-    *pError = CKR_HOST_MEMORY;
-    goto loser;
-  }
+    arena = NSSArena_Create();
+    if (!arena) {
+        *pError = CKR_HOST_MEMORY;
+        goto loser;
+    }
 
-  fwToken = nss_ZNEW(arena, NSSCKFWToken);
-  if (!fwToken) {
-    *pError = CKR_HOST_MEMORY;
-    goto loser;
-  }    
+    fwToken = nss_ZNEW(arena, NSSCKFWToken);
+    if (!fwToken) {
+        *pError = CKR_HOST_MEMORY;
+        goto loser;
+    }
 
-  fwToken->arena = arena;
-  fwToken->mdToken = mdToken;
-  fwToken->fwSlot = fwSlot;
-  fwToken->fwInstance = nssCKFWSlot_GetFWInstance(fwSlot);
-  fwToken->mdInstance = nssCKFWSlot_GetMDInstance(fwSlot);
-  fwToken->state = CKS_RO_PUBLIC_SESSION; /* some default */
-  fwToken->sessionCount = 0;
-  fwToken->rwSessionCount = 0;
+    fwToken->arena = arena;
+    fwToken->mdToken = mdToken;
+    fwToken->fwSlot = fwSlot;
+    fwToken->fwInstance = nssCKFWSlot_GetFWInstance(fwSlot);
+    fwToken->mdInstance = nssCKFWSlot_GetMDInstance(fwSlot);
+    fwToken->state = CKS_RO_PUBLIC_SESSION; /* some default */
+    fwToken->sessionCount = 0;
+    fwToken->rwSessionCount = 0;
 
-  fwToken->mutex = nssCKFWInstance_CreateMutex(fwToken->fwInstance, arena, pError);
-  if (!fwToken->mutex) {
-    if( CKR_OK == *pError ) {
-      *pError = CKR_GENERAL_ERROR;
+    fwToken->mutex = nssCKFWInstance_CreateMutex(fwToken->fwInstance, arena, pError);
+    if (!fwToken->mutex) {
+        if (CKR_OK == *pError) {
+            *pError = CKR_GENERAL_ERROR;
+        }
+        goto loser;
     }
-    goto loser;
-  }
 
-  fwToken->sessions = nssCKFWHash_Create(fwToken->fwInstance, arena, pError);
-  if (!fwToken->sessions) {
-    if( CKR_OK == *pError ) {
-      *pError = CKR_GENERAL_ERROR;
+    fwToken->sessions = nssCKFWHash_Create(fwToken->fwInstance, arena, pError);
+    if (!fwToken->sessions) {
+        if (CKR_OK == *pError) {
+            *pError = CKR_GENERAL_ERROR;
+        }
+        goto loser;
     }
-    goto loser;
-  }
 
-  if( CK_TRUE != nssCKFWInstance_GetModuleHandlesSessionObjects(
-                   fwToken->fwInstance) ) {
-    fwToken->sessionObjectHash = nssCKFWHash_Create(fwToken->fwInstance, 
-                                   arena, pError);
-    if (!fwToken->sessionObjectHash) {
-      if( CKR_OK == *pError ) {
-        *pError = CKR_GENERAL_ERROR;
-      }
-      goto loser;
+    if (CK_TRUE != nssCKFWInstance_GetModuleHandlesSessionObjects(
+                       fwToken->fwInstance)) {
+        fwToken->sessionObjectHash = nssCKFWHash_Create(fwToken->fwInstance,
+                                                        arena, pError);
+        if (!fwToken->sessionObjectHash) {
+            if (CKR_OK == *pError) {
+                *pError = CKR_GENERAL_ERROR;
+            }
+            goto loser;
+        }
     }
-  }
 
-  fwToken->mdObjectHash = nssCKFWHash_Create(fwToken->fwInstance, 
-                            arena, pError);
-  if (!fwToken->mdObjectHash) {
-    if( CKR_OK == *pError ) {
-      *pError = CKR_GENERAL_ERROR;
+    fwToken->mdObjectHash = nssCKFWHash_Create(fwToken->fwInstance,
+                                               arena, pError);
+    if (!fwToken->mdObjectHash) {
+        if (CKR_OK == *pError) {
+            *pError = CKR_GENERAL_ERROR;
+        }
+        goto loser;
     }
-    goto loser;
-  }
 
-  fwToken->mdMechanismHash = nssCKFWHash_Create(fwToken->fwInstance, 
-                            arena, pError);
-  if (!fwToken->mdMechanismHash) {
-    if( CKR_OK == *pError ) {
-      *pError = CKR_GENERAL_ERROR;
+    fwToken->mdMechanismHash = nssCKFWHash_Create(fwToken->fwInstance,
+                                                  arena, pError);
+    if (!fwToken->mdMechanismHash) {
+        if (CKR_OK == *pError) {
+            *pError = CKR_GENERAL_ERROR;
+        }
+        goto loser;
     }
-    goto loser;
-  }
 
-  /* More here */
+    /* More here */
 
-  if (mdToken->Setup) {
-    *pError = mdToken->Setup(mdToken, fwToken, fwToken->mdInstance, fwToken->fwInstance);
-    if( CKR_OK != *pError ) {
-      goto loser;
+    if (mdToken->Setup) {
+        *pError = mdToken->Setup(mdToken, fwToken, fwToken->mdInstance, fwToken->fwInstance);
+        if (CKR_OK != *pError) {
+            goto loser;
+        }
     }
-  }
 
-  called_setup = CK_TRUE;
+    called_setup = CK_TRUE;
 
 #ifdef DEBUG
-  *pError = token_add_pointer(fwToken);
-  if( CKR_OK != *pError ) {
-    goto loser;
-  }
+    *pError = token_add_pointer(fwToken);
+    if (CKR_OK != *pError) {
+        goto loser;
+    }
 #endif /* DEBUG */
 
-  *pError = CKR_OK;
-  return fwToken;
+    *pError = CKR_OK;
+    return fwToken;
 
- loser:
+loser:
 
-  if( CK_TRUE == called_setup ) {
-    if (mdToken->Invalidate) {
-      mdToken->Invalidate(mdToken, fwToken, fwToken->mdInstance, fwToken->fwInstance);
+    if (CK_TRUE == called_setup) {
+        if (mdToken->Invalidate) {
+            mdToken->Invalidate(mdToken, fwToken, fwToken->mdInstance, fwToken->fwInstance);
+        }
     }
-  }
 
-  if (arena) {
-    (void)NSSArena_Destroy(arena);
-  }
+    if (arena) {
+        (void)NSSArena_Destroy(arena);
+    }
 
-  return (NSSCKFWToken *)NULL;
+    return (NSSCKFWToken *)NULL;
 }
 
 static void
-nss_ckfwtoken_session_iterator
-(
-  const void *key,
-  void *value,
-  void *closure
-)
+nss_ckfwtoken_session_iterator(
+    const void *key,
+    void *value,
+    void *closure)
 {
-  /*
-   * Remember that the fwToken->mutex is locked
-   */
-  NSSCKFWSession *fwSession = (NSSCKFWSession *)value;
-  (void)nssCKFWSession_Destroy(fwSession, CK_FALSE);
-  return;
+    /*
+     * Remember that the fwToken->mutex is locked
+     */
+    NSSCKFWSession *fwSession = (NSSCKFWSession *)value;
+    (void)nssCKFWSession_Destroy(fwSession, CK_FALSE);
+    return;
 }
 
 static void
-nss_ckfwtoken_object_iterator
-(
-  const void *key,
-  void *value,
-  void *closure
-)
+nss_ckfwtoken_object_iterator(
+    const void *key,
+    void *value,
+    void *closure)
 {
-  /*
-   * Remember that the fwToken->mutex is locked
-   */
-  NSSCKFWObject *fwObject = (NSSCKFWObject *)value;
-  (void)nssCKFWObject_Finalize(fwObject, CK_FALSE);
-  return;
+    /*
+     * Remember that the fwToken->mutex is locked
+     */
+    NSSCKFWObject *fwObject = (NSSCKFWObject *)value;
+    (void)nssCKFWObject_Finalize(fwObject, CK_FALSE);
+    return;
 }
 
 /*
  * nssCKFWToken_Destroy
  *
  */
 NSS_IMPLEMENT CK_RV
-nssCKFWToken_Destroy
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_Destroy(
+    NSSCKFWToken *fwToken)
 {
-  CK_RV error = CKR_OK;
+    CK_RV error = CKR_OK;
 
 #ifdef NSSDEBUG
-  error = nssCKFWToken_verifyPointer(fwToken);
-  if( CKR_OK != error ) {
-    return error;
-  }
+    error = nssCKFWToken_verifyPointer(fwToken);
+    if (CKR_OK != error) {
+        return error;
+    }
 #endif /* NSSDEBUG */
 
-  (void)nssCKFWMutex_Destroy(fwToken->mutex);
-  
-  if (fwToken->mdToken->Invalidate) {
-    fwToken->mdToken->Invalidate(fwToken->mdToken, fwToken,
-      fwToken->mdInstance, fwToken->fwInstance);
-  }
-  /* we can destroy the list without locking now because no one else is 
-   * referencing us (or _Destroy was invalidly called!)
-   */
-  nssCKFWHash_Iterate(fwToken->sessions, nss_ckfwtoken_session_iterator, 
-                                                                (void *)NULL);
-  nssCKFWHash_Destroy(fwToken->sessions);
+    (void)nssCKFWMutex_Destroy(fwToken->mutex);
 
-  /* session objects go away when their sessions are removed */
-  if (fwToken->sessionObjectHash) {
-    nssCKFWHash_Destroy(fwToken->sessionObjectHash);
-  }
+    if (fwToken->mdToken->Invalidate) {
+        fwToken->mdToken->Invalidate(fwToken->mdToken, fwToken,
+                                     fwToken->mdInstance, fwToken->fwInstance);
+    }
+    /* we can destroy the list without locking now because no one else is
+     * referencing us (or _Destroy was invalidly called!)
+     */
+    nssCKFWHash_Iterate(fwToken->sessions, nss_ckfwtoken_session_iterator,
+                        (void *)NULL);
+    nssCKFWHash_Destroy(fwToken->sessions);
 
-  /* free up the token objects */
-  if (fwToken->mdObjectHash) {
-    nssCKFWHash_Iterate(fwToken->mdObjectHash, nss_ckfwtoken_object_iterator, 
-                                                                (void *)NULL);
-    nssCKFWHash_Destroy(fwToken->mdObjectHash);
-  }
-  if (fwToken->mdMechanismHash) {
-    nssCKFWHash_Destroy(fwToken->mdMechanismHash);
-  }
+    /* session objects go away when their sessions are removed */
+    if (fwToken->sessionObjectHash) {
+        nssCKFWHash_Destroy(fwToken->sessionObjectHash);
+    }
 
-  nssCKFWSlot_ClearToken(fwToken->fwSlot);
-  
+    /* free up the token objects */
+    if (fwToken->mdObjectHash) {
+        nssCKFWHash_Iterate(fwToken->mdObjectHash, nss_ckfwtoken_object_iterator,
+                            (void *)NULL);
+        nssCKFWHash_Destroy(fwToken->mdObjectHash);
+    }
+    if (fwToken->mdMechanismHash) {
+        nssCKFWHash_Destroy(fwToken->mdMechanismHash);
+    }
+
+    nssCKFWSlot_ClearToken(fwToken->fwSlot);
+
 #ifdef DEBUG
-  error = token_remove_pointer(fwToken);
+    error = token_remove_pointer(fwToken);
 #endif /* DEBUG */
 
-  (void)NSSArena_Destroy(fwToken->arena);
-  return error;
+    (void)NSSArena_Destroy(fwToken->arena);
+    return error;
 }
 
 /*
  * nssCKFWToken_GetMDToken
  *
  */
 NSS_IMPLEMENT NSSCKMDToken *
-nssCKFWToken_GetMDToken
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetMDToken(
+    NSSCKFWToken *fwToken)
 {
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return (NSSCKMDToken *)NULL;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return (NSSCKMDToken *)NULL;
+    }
 #endif /* NSSDEBUG */
 
-  return fwToken->mdToken;
+    return fwToken->mdToken;
 }
 
 /*
  * nssCKFWToken_GetArena
  *
  */
 NSS_IMPLEMENT NSSArena *
-nssCKFWToken_GetArena
-(
-  NSSCKFWToken *fwToken,
-  CK_RV *pError
-)
+nssCKFWToken_GetArena(
+    NSSCKFWToken *fwToken,
+    CK_RV *pError)
 {
 #ifdef NSSDEBUG
-  if (!pError) {
-    return (NSSArena *)NULL;
-  }
+    if (!pError) {
+        return (NSSArena *)NULL;
+    }
 
-  *pError = nssCKFWToken_verifyPointer(fwToken);
-  if( CKR_OK != *pError ) {
-    return (NSSArena *)NULL;
-  }
+    *pError = nssCKFWToken_verifyPointer(fwToken);
+    if (CKR_OK != *pError) {
+        return (NSSArena *)NULL;
+    }
 #endif /* NSSDEBUG */
 
-  return fwToken->arena;
+    return fwToken->arena;
 }
 
 /*
  * nssCKFWToken_GetFWSlot
  *
  */
 NSS_IMPLEMENT NSSCKFWSlot *
-nssCKFWToken_GetFWSlot
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetFWSlot(
+    NSSCKFWToken *fwToken)
 {
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return (NSSCKFWSlot *)NULL;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return (NSSCKFWSlot *)NULL;
+    }
 #endif /* NSSDEBUG */
 
-  return fwToken->fwSlot;
+    return fwToken->fwSlot;
 }
 
 /*
  * nssCKFWToken_GetMDSlot
  *
  */
 NSS_IMPLEMENT NSSCKMDSlot *
-nssCKFWToken_GetMDSlot
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetMDSlot(
+    NSSCKFWToken *fwToken)
 {
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return (NSSCKMDSlot *)NULL;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return (NSSCKMDSlot *)NULL;
+    }
 #endif /* NSSDEBUG */
 
-  return fwToken->mdSlot;
+    return fwToken->mdSlot;
 }
 
 /*
  * nssCKFWToken_GetSessionState
  *
  */
 NSS_IMPLEMENT CK_STATE
-nssCKFWToken_GetSessionState
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetSessionState(
+    NSSCKFWToken *fwToken)
 {
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return CKS_RO_PUBLIC_SESSION; /* whatever */
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return CKS_RO_PUBLIC_SESSION; /* whatever */
+    }
 #endif /* NSSDEBUG */
 
-  /*
-   * BTW, do not lock the token in this method.
-   */
+    /*
+     * BTW, do not lock the token in this method.
+     */
 
-  /*
-   * Theoretically, there is no state if there aren't any
-   * sessions open.  But then we'd need to worry about
-   * reporting an error, etc.  What the heck-- let's just
-   * revert to CKR_RO_PUBLIC_SESSION as the "default."
-   */
+    /*
+     * Theoretically, there is no state if there aren't any
+     * sessions open.  But then we'd need to worry about
+     * reporting an error, etc.  What the heck-- let's just
+     * revert to CKR_RO_PUBLIC_SESSION as the "default."
+     */
 
-  return fwToken->state;
+    return fwToken->state;
 }
 
 /*
  * nssCKFWToken_InitToken
  *
  */
 NSS_IMPLEMENT CK_RV
-nssCKFWToken_InitToken
-(
-  NSSCKFWToken *fwToken,
-  NSSItem *pin,
-  NSSUTF8 *label
-)
+nssCKFWToken_InitToken(
+    NSSCKFWToken *fwToken,
+    NSSItem *pin,
+    NSSUTF8 *label)
 {
-  CK_RV error;
+    CK_RV error;
 
 #ifdef NSSDEBUG
-  error = nssCKFWToken_verifyPointer(fwToken);
-  if( CKR_OK != error ) {
-    return CKR_ARGUMENTS_BAD;
-  }
+    error = nssCKFWToken_verifyPointer(fwToken);
+    if (CKR_OK != error) {
+        return CKR_ARGUMENTS_BAD;
+    }
 #endif /* NSSDEBUG */
 
-  error = nssCKFWMutex_Lock(fwToken->mutex);
-  if( CKR_OK != error ) {
+    error = nssCKFWMutex_Lock(fwToken->mutex);
+    if (CKR_OK != error) {
+        return error;
+    }
+
+    if (fwToken->sessionCount > 0) {
+        error = CKR_SESSION_EXISTS;
+        goto done;
+    }
+
+    if (!fwToken->mdToken->InitToken) {
+        error = CKR_DEVICE_ERROR;
+        goto done;
+    }
+
+    if (!pin) {
+        if (nssCKFWToken_GetHasProtectedAuthenticationPath(fwToken)) {
+            ; /* okay */
+        } else {
+            error = CKR_PIN_INCORRECT;
+            goto done;
+        }
+    }
+
+    if (!label) {
+        label = (NSSUTF8 *)"";
+    }
+
+    error = fwToken->mdToken->InitToken(fwToken->mdToken, fwToken,
+                                        fwToken->mdInstance, fwToken->fwInstance, pin, label);
+
+done:
+    (void)nssCKFWMutex_Unlock(fwToken->mutex);
     return error;
-  }
-
-  if( fwToken->sessionCount > 0 ) {
-    error = CKR_SESSION_EXISTS;
-    goto done;
-  }
-
-  if (!fwToken->mdToken->InitToken) {
-    error = CKR_DEVICE_ERROR;
-    goto done;
-  }
-
-  if (!pin) {
-    if( nssCKFWToken_GetHasProtectedAuthenticationPath(fwToken) ) {
-      ; /* okay */
-    } else {
-      error = CKR_PIN_INCORRECT;
-      goto done;
-    }
-  }
-
-  if (!label) {
-    label = (NSSUTF8 *) "";
-  }
-
-  error = fwToken->mdToken->InitToken(fwToken->mdToken, fwToken,
-            fwToken->mdInstance, fwToken->fwInstance, pin, label);
-
- done:
-  (void)nssCKFWMutex_Unlock(fwToken->mutex);
-  return error;
 }
 
 /*
  * nssCKFWToken_GetLabel
  *
  */
 NSS_IMPLEMENT CK_RV
-nssCKFWToken_GetLabel
-(
-  NSSCKFWToken *fwToken,
-  CK_CHAR label[32]
-)
+nssCKFWToken_GetLabel(
+    NSSCKFWToken *fwToken,
+    CK_CHAR label[32])
 {
-  CK_RV error = CKR_OK;
+    CK_RV error = CKR_OK;
 
 #ifdef NSSDEBUG
-  if( (CK_CHAR_PTR)NULL == label ) {
-    return CKR_ARGUMENTS_BAD;
-  }
+    if ((CK_CHAR_PTR)NULL == label) {
+        return CKR_ARGUMENTS_BAD;
+    }
 
-  error = nssCKFWToken_verifyPointer(fwToken);
-  if( CKR_OK != error ) {
-    return error;
-  }
+    error = nssCKFWToken_verifyPointer(fwToken);
+    if (CKR_OK != error) {
+        return error;
+    }
 #endif /* NSSDEBUG */
 
-  error = nssCKFWMutex_Lock(fwToken->mutex);
-  if( CKR_OK != error ) {
+    error = nssCKFWMutex_Lock(fwToken->mutex);
+    if (CKR_OK != error) {
+        return error;
+    }
+
+    if (!fwToken->label) {
+        if (fwToken->mdToken->GetLabel) {
+            fwToken->label = fwToken->mdToken->GetLabel(fwToken->mdToken, fwToken,
+                                                        fwToken->mdInstance, fwToken->fwInstance, &error);
+            if ((!fwToken->label) && (CKR_OK != error)) {
+                goto done;
+            }
+        } else {
+            fwToken->label = (NSSUTF8 *)"";
+        }
+    }
+
+    (void)nssUTF8_CopyIntoFixedBuffer(fwToken->label, (char *)label, 32, ' ');
+    error = CKR_OK;
+
+done:
+    (void)nssCKFWMutex_Unlock(fwToken->mutex);
     return error;
-  }
-
-  if (!fwToken->label) {
-    if (fwToken->mdToken->GetLabel) {
-      fwToken->label = fwToken->mdToken->GetLabel(fwToken->mdToken, fwToken,
-        fwToken->mdInstance, fwToken->fwInstance, &error);
-      if ((!fwToken->label) && (CKR_OK != error)) {
-        goto done;
-      }
-    } else {
-      fwToken->label = (NSSUTF8 *) "";
-    }
-  }
-
-  (void)nssUTF8_CopyIntoFixedBuffer(fwToken->label, (char *)label, 32, ' ');
-  error = CKR_OK;
-
- done:
-  (void)nssCKFWMutex_Unlock(fwToken->mutex);
-  return error;
 }
 
 /*
  * nssCKFWToken_GetManufacturerID
  *
  */
 NSS_IMPLEMENT CK_RV
-nssCKFWToken_GetManufacturerID
-(
-  NSSCKFWToken *fwToken,
-  CK_CHAR manufacturerID[32]
-)
+nssCKFWToken_GetManufacturerID(
+    NSSCKFWToken *fwToken,
+    CK_CHAR manufacturerID[32])
 {
-  CK_RV error = CKR_OK;
+    CK_RV error = CKR_OK;
 
 #ifdef NSSDEBUG
-  if( (CK_CHAR_PTR)NULL == manufacturerID ) {
-    return CKR_ARGUMENTS_BAD;
-  }
+    if ((CK_CHAR_PTR)NULL == manufacturerID) {
+        return CKR_ARGUMENTS_BAD;
+    }
 
-  error = nssCKFWToken_verifyPointer(fwToken);
-  if( CKR_OK != error ) {
-    return error;
-  }
+    error = nssCKFWToken_verifyPointer(fwToken);
+    if (CKR_OK != error) {
+        return error;
+    }
 #endif /* NSSDEBUG */
 
-  error = nssCKFWMutex_Lock(fwToken->mutex);
-  if( CKR_OK != error ) {
+    error = nssCKFWMutex_Lock(fwToken->mutex);
+    if (CKR_OK != error) {
+        return error;
+    }
+
+    if (!fwToken->manufacturerID) {
+        if (fwToken->mdToken->GetManufacturerID) {
+            fwToken->manufacturerID = fwToken->mdToken->GetManufacturerID(fwToken->mdToken,
+                                                                          fwToken, fwToken->mdInstance, fwToken->fwInstance, &error);
+            if ((!fwToken->manufacturerID) && (CKR_OK != error)) {
+                goto done;
+            }
+        } else {
+            fwToken->manufacturerID = (NSSUTF8 *)"";
+        }
+    }
+
+    (void)nssUTF8_CopyIntoFixedBuffer(fwToken->manufacturerID, (char *)manufacturerID, 32, ' ');
+    error = CKR_OK;
+
+done:
+    (void)nssCKFWMutex_Unlock(fwToken->mutex);
     return error;
-  }
-
-  if (!fwToken->manufacturerID) {
-    if (fwToken->mdToken->GetManufacturerID) {
-      fwToken->manufacturerID = fwToken->mdToken->GetManufacturerID(fwToken->mdToken,
-        fwToken, fwToken->mdInstance, fwToken->fwInstance, &error);
-      if ((!fwToken->manufacturerID) && (CKR_OK != error)) {
-        goto done;
-      }
-    } else {
-      fwToken->manufacturerID = (NSSUTF8 *)"";
-    }
-  }
-
-  (void)nssUTF8_CopyIntoFixedBuffer(fwToken->manufacturerID, (char *)manufacturerID, 32, ' ');
-  error = CKR_OK;
-
- done:
-  (void)nssCKFWMutex_Unlock(fwToken->mutex);
-  return error;
 }
 
 /*
  * nssCKFWToken_GetModel
  *
  */
 NSS_IMPLEMENT CK_RV
-nssCKFWToken_GetModel
-(
-  NSSCKFWToken *fwToken,
-  CK_CHAR model[16]
-)
+nssCKFWToken_GetModel(
+    NSSCKFWToken *fwToken,
+    CK_CHAR model[16])
 {
-  CK_RV error = CKR_OK;
+    CK_RV error = CKR_OK;
 
 #ifdef NSSDEBUG
-  if( (CK_CHAR_PTR)NULL == model ) {
-    return CKR_ARGUMENTS_BAD;
-  }
+    if ((CK_CHAR_PTR)NULL == model) {
+        return CKR_ARGUMENTS_BAD;
+    }
 
-  error = nssCKFWToken_verifyPointer(fwToken);
-  if( CKR_OK != error ) {
-    return error;
-  }
+    error = nssCKFWToken_verifyPointer(fwToken);
+    if (CKR_OK != error) {
+        return error;
+    }
 #endif /* NSSDEBUG */
 
-  error = nssCKFWMutex_Lock(fwToken->mutex);
-  if( CKR_OK != error ) {
+    error = nssCKFWMutex_Lock(fwToken->mutex);
+    if (CKR_OK != error) {
+        return error;
+    }
+
+    if (!fwToken->model) {
+        if (fwToken->mdToken->GetModel) {
+            fwToken->model = fwToken->mdToken->GetModel(fwToken->mdToken, fwToken,
+                                                        fwToken->mdInstance, fwToken->fwInstance, &error);
+            if ((!fwToken->model) && (CKR_OK != error)) {
+                goto done;
+            }
+        } else {
+            fwToken->model = (NSSUTF8 *)"";
+        }
+    }
+
+    (void)nssUTF8_CopyIntoFixedBuffer(fwToken->model, (char *)model, 16, ' ');
+    error = CKR_OK;
+
+done:
+    (void)nssCKFWMutex_Unlock(fwToken->mutex);
     return error;
-  }
-
-  if (!fwToken->model) {
-    if (fwToken->mdToken->GetModel) {
-      fwToken->model = fwToken->mdToken->GetModel(fwToken->mdToken, fwToken,
-        fwToken->mdInstance, fwToken->fwInstance, &error);
-      if ((!fwToken->model) && (CKR_OK != error)) {
-        goto done;
-      }
-    } else {
-      fwToken->model = (NSSUTF8 *)"";
-    }
-  }
-
-  (void)nssUTF8_CopyIntoFixedBuffer(fwToken->model, (char *)model, 16, ' ');
-  error = CKR_OK;
-
- done:
-  (void)nssCKFWMutex_Unlock(fwToken->mutex);
-  return error;
 }
 
 /*
  * nssCKFWToken_GetSerialNumber
  *
  */
 NSS_IMPLEMENT CK_RV
-nssCKFWToken_GetSerialNumber
-(
-  NSSCKFWToken *fwToken,
-  CK_CHAR serialNumber[16]
-)
+nssCKFWToken_GetSerialNumber(
+    NSSCKFWToken *fwToken,
+    CK_CHAR serialNumber[16])
 {
-  CK_RV error = CKR_OK;
+    CK_RV error = CKR_OK;
 
 #ifdef NSSDEBUG
-  if( (CK_CHAR_PTR)NULL == serialNumber ) {
-    return CKR_ARGUMENTS_BAD;
-  }
+    if ((CK_CHAR_PTR)NULL == serialNumber) {
+        return CKR_ARGUMENTS_BAD;
+    }
 
-  error = nssCKFWToken_verifyPointer(fwToken);
-  if( CKR_OK != error ) {
-    return error;
-  }
+    error = nssCKFWToken_verifyPointer(fwToken);
+    if (CKR_OK != error) {
+        return error;
+    }
 #endif /* NSSDEBUG */
 
-  error = nssCKFWMutex_Lock(fwToken->mutex);
-  if( CKR_OK != error ) {
+    error = nssCKFWMutex_Lock(fwToken->mutex);
+    if (CKR_OK != error) {
+        return error;
+    }
+
+    if (!fwToken->serialNumber) {
+        if (fwToken->mdToken->GetSerialNumber) {
+            fwToken->serialNumber = fwToken->mdToken->GetSerialNumber(fwToken->mdToken,
+                                                                      fwToken, fwToken->mdInstance, fwToken->fwInstance, &error);
+            if ((!fwToken->serialNumber) && (CKR_OK != error)) {
+                goto done;
+            }
+        } else {
+            fwToken->serialNumber = (NSSUTF8 *)"";
+        }
+    }
+
+    (void)nssUTF8_CopyIntoFixedBuffer(fwToken->serialNumber, (char *)serialNumber, 16, ' ');
+    error = CKR_OK;
+
+done:
+    (void)nssCKFWMutex_Unlock(fwToken->mutex);
     return error;
-  }
-
-  if (!fwToken->serialNumber) {
-    if (fwToken->mdToken->GetSerialNumber) {
-      fwToken->serialNumber = fwToken->mdToken->GetSerialNumber(fwToken->mdToken, 
-        fwToken, fwToken->mdInstance, fwToken->fwInstance, &error);
-      if ((!fwToken->serialNumber) && (CKR_OK != error)) {
-        goto done;
-      }
-    } else {
-      fwToken->serialNumber = (NSSUTF8 *)"";
-    }
-  }
-
-  (void)nssUTF8_CopyIntoFixedBuffer(fwToken->serialNumber, (char *)serialNumber, 16, ' ');
-  error = CKR_OK;
-
- done:
-  (void)nssCKFWMutex_Unlock(fwToken->mutex);
-  return error;
 }
 
-
 /*
  * nssCKFWToken_GetHasRNG
  *
  */
 NSS_IMPLEMENT CK_BBOOL
-nssCKFWToken_GetHasRNG
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetHasRNG(
+    NSSCKFWToken *fwToken)
 {
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return CK_FALSE;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return CK_FALSE;
+    }
 #endif /* NSSDEBUG */
 
-  if (!fwToken->mdToken->GetHasRNG) {
-    return CK_FALSE;
-  }
+    if (!fwToken->mdToken->GetHasRNG) {
+        return CK_FALSE;
+    }
 
-  return fwToken->mdToken->GetHasRNG(fwToken->mdToken, fwToken, 
-    fwToken->mdInstance, fwToken->fwInstance);
+    return fwToken->mdToken->GetHasRNG(fwToken->mdToken, fwToken,
+                                       fwToken->mdInstance, fwToken->fwInstance);
 }
 
 /*
  * nssCKFWToken_GetIsWriteProtected
  *
  */
 NSS_IMPLEMENT CK_BBOOL
-nssCKFWToken_GetIsWriteProtected
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetIsWriteProtected(
+    NSSCKFWToken *fwToken)
 {
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return CK_FALSE;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return CK_FALSE;
+    }
 #endif /* NSSDEBUG */
 
-  if (!fwToken->mdToken->GetIsWriteProtected) {
-    return CK_FALSE;
-  }
+    if (!fwToken->mdToken->GetIsWriteProtected) {
+        return CK_FALSE;
+    }
 
-  return fwToken->mdToken->GetIsWriteProtected(fwToken->mdToken, fwToken, 
-    fwToken->mdInstance, fwToken->fwInstance);
+    return fwToken->mdToken->GetIsWriteProtected(fwToken->mdToken, fwToken,
+                                                 fwToken->mdInstance, fwToken->fwInstance);
 }
 
 /*
  * nssCKFWToken_GetLoginRequired
  *
  */
 NSS_IMPLEMENT CK_BBOOL
-nssCKFWToken_GetLoginRequired
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetLoginRequired(
+    NSSCKFWToken *fwToken)
 {
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return CK_FALSE;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return CK_FALSE;
+    }
 #endif /* NSSDEBUG */
 
-  if (!fwToken->mdToken->GetLoginRequired) {
-    return CK_FALSE;
-  }
+    if (!fwToken->mdToken->GetLoginRequired) {
+        return CK_FALSE;
+    }
 
-  return fwToken->mdToken->GetLoginRequired(fwToken->mdToken, fwToken, 
-    fwToken->mdInstance, fwToken->fwInstance);
+    return fwToken->mdToken->GetLoginRequired(fwToken->mdToken, fwToken,
+                                              fwToken->mdInstance, fwToken->fwInstance);
 }
 
 /*
  * nssCKFWToken_GetUserPinInitialized
  *
  */
 NSS_IMPLEMENT CK_BBOOL
-nssCKFWToken_GetUserPinInitialized
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetUserPinInitialized(
+    NSSCKFWToken *fwToken)
 {
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return CK_FALSE;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return CK_FALSE;
+    }
 #endif /* NSSDEBUG */
 
-  if (!fwToken->mdToken->GetUserPinInitialized) {
-    return CK_FALSE;
-  }
+    if (!fwToken->mdToken->GetUserPinInitialized) {
+        return CK_FALSE;
+    }
 
-  return fwToken->mdToken->GetUserPinInitialized(fwToken->mdToken, fwToken, 
-    fwToken->mdInstance, fwToken->fwInstance);
+    return fwToken->mdToken->GetUserPinInitialized(fwToken->mdToken, fwToken,
+                                                   fwToken->mdInstance, fwToken->fwInstance);
 }
 
 /*
  * nssCKFWToken_GetRestoreKeyNotNeeded
  *
  */
 NSS_IMPLEMENT CK_BBOOL
-nssCKFWToken_GetRestoreKeyNotNeeded
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetRestoreKeyNotNeeded(
+    NSSCKFWToken *fwToken)
 {
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return CK_FALSE;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return CK_FALSE;
+    }
 #endif /* NSSDEBUG */
 
-  if (!fwToken->mdToken->GetRestoreKeyNotNeeded) {
-    return CK_FALSE;
-  }
+    if (!fwToken->mdToken->GetRestoreKeyNotNeeded) {
+        return CK_FALSE;
+    }
 
-  return fwToken->mdToken->GetRestoreKeyNotNeeded(fwToken->mdToken, fwToken, 
-    fwToken->mdInstance, fwToken->fwInstance);
+    return fwToken->mdToken->GetRestoreKeyNotNeeded(fwToken->mdToken, fwToken,
+                                                    fwToken->mdInstance, fwToken->fwInstance);
 }
 
 /*
  * nssCKFWToken_GetHasClockOnToken
  *
  */
 NSS_IMPLEMENT CK_BBOOL
-nssCKFWToken_GetHasClockOnToken
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetHasClockOnToken(
+    NSSCKFWToken *fwToken)
 {
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return CK_FALSE;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return CK_FALSE;
+    }
 #endif /* NSSDEBUG */
 
-  if (!fwToken->mdToken->GetHasClockOnToken) {
-    return CK_FALSE;
-  }
+    if (!fwToken->mdToken->GetHasClockOnToken) {
+        return CK_FALSE;
+    }
 
-  return fwToken->mdToken->GetHasClockOnToken(fwToken->mdToken, fwToken, 
-    fwToken->mdInstance, fwToken->fwInstance);
+    return fwToken->mdToken->GetHasClockOnToken(fwToken->mdToken, fwToken,
+                                                fwToken->mdInstance, fwToken->fwInstance);
 }
 
 /*
  * nssCKFWToken_GetHasProtectedAuthenticationPath
  *
  */
 NSS_IMPLEMENT CK_BBOOL
-nssCKFWToken_GetHasProtectedAuthenticationPath
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetHasProtectedAuthenticationPath(
+    NSSCKFWToken *fwToken)
 {
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return CK_FALSE;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return CK_FALSE;
+    }
 #endif /* NSSDEBUG */
 
-  if (!fwToken->mdToken->GetHasProtectedAuthenticationPath) {
-    return CK_FALSE;
-  }
+    if (!fwToken->mdToken->GetHasProtectedAuthenticationPath) {
+        return CK_FALSE;
+    }
 
-  return fwToken->mdToken->GetHasProtectedAuthenticationPath(fwToken->mdToken, 
-    fwToken, fwToken->mdInstance, fwToken->fwInstance);
+    return fwToken->mdToken->GetHasProtectedAuthenticationPath(fwToken->mdToken,
+                                                               fwToken, fwToken->mdInstance, fwToken->fwInstance);
 }
 
 /*
  * nssCKFWToken_GetSupportsDualCryptoOperations
  *
  */
 NSS_IMPLEMENT CK_BBOOL
-nssCKFWToken_GetSupportsDualCryptoOperations
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetSupportsDualCryptoOperations(
+    NSSCKFWToken *fwToken)
 {
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return CK_FALSE;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return CK_FALSE;
+    }
 #endif /* NSSDEBUG */
 
-  if (!fwToken->mdToken->GetSupportsDualCryptoOperations) {
-    return CK_FALSE;
-  }
+    if (!fwToken->mdToken->GetSupportsDualCryptoOperations) {
+        return CK_FALSE;
+    }
 
-  return fwToken->mdToken->GetSupportsDualCryptoOperations(fwToken->mdToken, 
-    fwToken, fwToken->mdInstance, fwToken->fwInstance);
+    return fwToken->mdToken->GetSupportsDualCryptoOperations(fwToken->mdToken,
+                                                             fwToken, fwToken->mdInstance, fwToken->fwInstance);
 }
 
 /*
  * nssCKFWToken_GetMaxSessionCount
  *
  */
 NSS_IMPLEMENT CK_ULONG
-nssCKFWToken_GetMaxSessionCount
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetMaxSessionCount(
+    NSSCKFWToken *fwToken)
 {
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return CK_UNAVAILABLE_INFORMATION;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return CK_UNAVAILABLE_INFORMATION;
+    }
 #endif /* NSSDEBUG */
 
-  if (!fwToken->mdToken->GetMaxSessionCount) {
-    return CK_UNAVAILABLE_INFORMATION;
-  }
+    if (!fwToken->mdToken->GetMaxSessionCount) {
+        return CK_UNAVAILABLE_INFORMATION;
+    }
 
-  return fwToken->mdToken->GetMaxSessionCount(fwToken->mdToken, fwToken, 
-    fwToken->mdInstance, fwToken->fwInstance);
+    return fwToken->mdToken->GetMaxSessionCount(fwToken->mdToken, fwToken,
+                                                fwToken->mdInstance, fwToken->fwInstance);
 }
 
 /*
  * nssCKFWToken_GetMaxRwSessionCount
  *
  */
 NSS_IMPLEMENT CK_ULONG
-nssCKFWToken_GetMaxRwSessionCount
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetMaxRwSessionCount(
+    NSSCKFWToken *fwToken)
 {
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return CK_UNAVAILABLE_INFORMATION;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return CK_UNAVAILABLE_INFORMATION;
+    }
 #endif /* NSSDEBUG */
 
-  if (!fwToken->mdToken->GetMaxRwSessionCount) {
-    return CK_UNAVAILABLE_INFORMATION;
-  }
+    if (!fwToken->mdToken->GetMaxRwSessionCount) {
+        return CK_UNAVAILABLE_INFORMATION;
+    }
 
-  return fwToken->mdToken->GetMaxRwSessionCount(fwToken->mdToken, fwToken, 
-    fwToken->mdInstance, fwToken->fwInstance);
+    return fwToken->mdToken->GetMaxRwSessionCount(fwToken->mdToken, fwToken,
+                                                  fwToken->mdInstance, fwToken->fwInstance);
 }
 
 /*
  * nssCKFWToken_GetMaxPinLen
  *
  */
 NSS_IMPLEMENT CK_ULONG
-nssCKFWToken_GetMaxPinLen
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetMaxPinLen(
+    NSSCKFWToken *fwToken)
 {
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return CK_UNAVAILABLE_INFORMATION;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return CK_UNAVAILABLE_INFORMATION;
+    }
 #endif /* NSSDEBUG */
 
-  if (!fwToken->mdToken->GetMaxPinLen) {
-    return CK_UNAVAILABLE_INFORMATION;
-  }
+    if (!fwToken->mdToken->GetMaxPinLen) {
+        return CK_UNAVAILABLE_INFORMATION;
+    }
 
-  return fwToken->mdToken->GetMaxPinLen(fwToken->mdToken, fwToken, 
-    fwToken->mdInstance, fwToken->fwInstance);
+    return fwToken->mdToken->GetMaxPinLen(fwToken->mdToken, fwToken,
+                                          fwToken->mdInstance, fwToken->fwInstance);
 }
 
 /*
  * nssCKFWToken_GetMinPinLen
  *
  */
 NSS_IMPLEMENT CK_ULONG
-nssCKFWToken_GetMinPinLen
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetMinPinLen(
+    NSSCKFWToken *fwToken)
 {
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return CK_UNAVAILABLE_INFORMATION;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return CK_UNAVAILABLE_INFORMATION;
+    }
 #endif /* NSSDEBUG */
 
-  if (!fwToken->mdToken->GetMinPinLen) {
-    return CK_UNAVAILABLE_INFORMATION;
-  }
+    if (!fwToken->mdToken->GetMinPinLen) {
+        return CK_UNAVAILABLE_INFORMATION;
+    }
 
-  return fwToken->mdToken->GetMinPinLen(fwToken->mdToken, fwToken, 
-    fwToken->mdInstance, fwToken->fwInstance);
+    return fwToken->mdToken->GetMinPinLen(fwToken->mdToken, fwToken,
+                                          fwToken->mdInstance, fwToken->fwInstance);
 }
 
 /*
  * nssCKFWToken_GetTotalPublicMemory
  *
  */
 NSS_IMPLEMENT CK_ULONG
-nssCKFWToken_GetTotalPublicMemory
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetTotalPublicMemory(
+    NSSCKFWToken *fwToken)
 {
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return CK_UNAVAILABLE_INFORMATION;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return CK_UNAVAILABLE_INFORMATION;
+    }
 #endif /* NSSDEBUG */
 
-  if (!fwToken->mdToken->GetTotalPublicMemory) {
-    return CK_UNAVAILABLE_INFORMATION;
-  }
+    if (!fwToken->mdToken->GetTotalPublicMemory) {
+        return CK_UNAVAILABLE_INFORMATION;
+    }
 
-  return fwToken->mdToken->GetTotalPublicMemory(fwToken->mdToken, fwToken, 
-    fwToken->mdInstance, fwToken->fwInstance);
+    return fwToken->mdToken->GetTotalPublicMemory(fwToken->mdToken, fwToken,
+                                                  fwToken->mdInstance, fwToken->fwInstance);
 }
 
 /*
  * nssCKFWToken_GetFreePublicMemory
  *
  */
 NSS_IMPLEMENT CK_ULONG
-nssCKFWToken_GetFreePublicMemory
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetFreePublicMemory(
+    NSSCKFWToken *fwToken)
 {
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return CK_UNAVAILABLE_INFORMATION;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return CK_UNAVAILABLE_INFORMATION;
+    }
 #endif /* NSSDEBUG */
 
-  if (!fwToken->mdToken->GetFreePublicMemory) {
-    return CK_UNAVAILABLE_INFORMATION;
-  }
+    if (!fwToken->mdToken->GetFreePublicMemory) {
+        return CK_UNAVAILABLE_INFORMATION;
+    }
 
-  return fwToken->mdToken->GetFreePublicMemory(fwToken->mdToken, fwToken, 
-    fwToken->mdInstance, fwToken->fwInstance);
+    return fwToken->mdToken->GetFreePublicMemory(fwToken->mdToken, fwToken,
+                                                 fwToken->mdInstance, fwToken->fwInstance);
 }
 
 /*
  * nssCKFWToken_GetTotalPrivateMemory
  *
  */
 NSS_IMPLEMENT CK_ULONG
-nssCKFWToken_GetTotalPrivateMemory
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetTotalPrivateMemory(
+    NSSCKFWToken *fwToken)
 {
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return CK_UNAVAILABLE_INFORMATION;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return CK_UNAVAILABLE_INFORMATION;
+    }
 #endif /* NSSDEBUG */
 
-  if (!fwToken->mdToken->GetTotalPrivateMemory) {
-    return CK_UNAVAILABLE_INFORMATION;
-  }
+    if (!fwToken->mdToken->GetTotalPrivateMemory) {
+        return CK_UNAVAILABLE_INFORMATION;
+    }
 
-  return fwToken->mdToken->GetTotalPrivateMemory(fwToken->mdToken, fwToken, 
-    fwToken->mdInstance, fwToken->fwInstance);
+    return fwToken->mdToken->GetTotalPrivateMemory(fwToken->mdToken, fwToken,
+                                                   fwToken->mdInstance, fwToken->fwInstance);
 }
 
 /*
  * nssCKFWToken_GetFreePrivateMemory
  *
  */
 NSS_IMPLEMENT CK_ULONG
-nssCKFWToken_GetFreePrivateMemory
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetFreePrivateMemory(
+    NSSCKFWToken *fwToken)
 {
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return CK_UNAVAILABLE_INFORMATION;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return CK_UNAVAILABLE_INFORMATION;
+    }
 #endif /* NSSDEBUG */
 
-  if (!fwToken->mdToken->GetFreePrivateMemory) {
-    return CK_UNAVAILABLE_INFORMATION;
-  }
+    if (!fwToken->mdToken->GetFreePrivateMemory) {
+        return CK_UNAVAILABLE_INFORMATION;
+    }
 
-  return fwToken->mdToken->GetFreePrivateMemory(fwToken->mdToken, fwToken, 
-    fwToken->mdInstance, fwToken->fwInstance);
+    return fwToken->mdToken->GetFreePrivateMemory(fwToken->mdToken, fwToken,
+                                                  fwToken->mdInstance, fwToken->fwInstance);
 }
 
 /*
  * nssCKFWToken_GetHardwareVersion
  *
  */
 NSS_IMPLEMENT CK_VERSION
-nssCKFWToken_GetHardwareVersion
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetHardwareVersion(
+    NSSCKFWToken *fwToken)
 {
-  CK_VERSION rv;
+    CK_VERSION rv;
 
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    rv.major = rv.minor = 0;
-    return rv;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        rv.major = rv.minor = 0;
+        return rv;
+    }
 #endif /* NSSDEBUG */
 
-  if( CKR_OK != nssCKFWMutex_Lock(fwToken->mutex) ) {
-    rv.major = rv.minor = 0;
+    if (CKR_OK != nssCKFWMutex_Lock(fwToken->mutex)) {
+        rv.major = rv.minor = 0;
+        return rv;
+    }
+
+    if ((0 != fwToken->hardwareVersion.major) ||
+        (0 != fwToken->hardwareVersion.minor)) {
+        rv = fwToken->hardwareVersion;
+        goto done;
+    }
+
+    if (fwToken->mdToken->GetHardwareVersion) {
+        fwToken->hardwareVersion = fwToken->mdToken->GetHardwareVersion(
+            fwToken->mdToken, fwToken, fwToken->mdInstance, fwToken->fwInstance);
+    } else {
+        fwToken->hardwareVersion.major = 0;
+        fwToken->hardwareVersion.minor = 1;
+    }
+
+    rv = fwToken->hardwareVersion;
+
+done:
+    (void)nssCKFWMutex_Unlock(fwToken->mutex);
     return rv;
-  }
-
-  if( (0 != fwToken->hardwareVersion.major) ||
-      (0 != fwToken->hardwareVersion.minor) ) {
-    rv = fwToken->hardwareVersion;
-    goto done;
-  }
-
-  if (fwToken->mdToken->GetHardwareVersion) {
-    fwToken->hardwareVersion = fwToken->mdToken->GetHardwareVersion(
-      fwToken->mdToken, fwToken, fwToken->mdInstance, fwToken->fwInstance);
-  } else {
-    fwToken->hardwareVersion.major = 0;
-    fwToken->hardwareVersion.minor = 1;
-  }
-
-  rv = fwToken->hardwareVersion;
-
- done:
-  (void)nssCKFWMutex_Unlock(fwToken->mutex);
-  return rv;
 }
 
 /*
  * nssCKFWToken_GetFirmwareVersion
  *
  */
 NSS_IMPLEMENT CK_VERSION
-nssCKFWToken_GetFirmwareVersion
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetFirmwareVersion(
+    NSSCKFWToken *fwToken)
 {
-  CK_VERSION rv;
+    CK_VERSION rv;
 
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    rv.major = rv.minor = 0;
-    return rv;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        rv.major = rv.minor = 0;
+        return rv;
+    }
 #endif /* NSSDEBUG */
 
-  if( CKR_OK != nssCKFWMutex_Lock(fwToken->mutex) ) {
-    rv.major = rv.minor = 0;
+    if (CKR_OK != nssCKFWMutex_Lock(fwToken->mutex)) {
+        rv.major = rv.minor = 0;
+        return rv;
+    }
+
+    if ((0 != fwToken->firmwareVersion.major) ||
+        (0 != fwToken->firmwareVersion.minor)) {
+        rv = fwToken->firmwareVersion;
+        goto done;
+    }
+
+    if (fwToken->mdToken->GetFirmwareVersion) {
+        fwToken->firmwareVersion = fwToken->mdToken->GetFirmwareVersion(
+            fwToken->mdToken, fwToken, fwToken->mdInstance, fwToken->fwInstance);
+    } else {
+        fwToken->firmwareVersion.major = 0;
+        fwToken->firmwareVersion.minor = 1;
+    }
+
+    rv = fwToken->firmwareVersion;
+
+done:
+    (void)nssCKFWMutex_Unlock(fwToken->mutex);
     return rv;
-  }
-
-  if( (0 != fwToken->firmwareVersion.major) ||
-      (0 != fwToken->firmwareVersion.minor) ) {
-    rv = fwToken->firmwareVersion;
-    goto done;
-  }
-
-  if (fwToken->mdToken->GetFirmwareVersion) {
-    fwToken->firmwareVersion = fwToken->mdToken->GetFirmwareVersion(
-      fwToken->mdToken, fwToken, fwToken->mdInstance, fwToken->fwInstance);
-  } else {
-    fwToken->firmwareVersion.major = 0;
-    fwToken->firmwareVersion.minor = 1;
-  }
-
-  rv = fwToken->firmwareVersion;
-
- done:
-  (void)nssCKFWMutex_Unlock(fwToken->mutex);
-  return rv;
 }
 
 /*
  * nssCKFWToken_GetUTCTime
  *
  */
 NSS_IMPLEMENT CK_RV
-nssCKFWToken_GetUTCTime
-(
-  NSSCKFWToken *fwToken,
-  CK_CHAR utcTime[16]
-)
+nssCKFWToken_GetUTCTime(
+    NSSCKFWToken *fwToken,
+    CK_CHAR utcTime[16])
 {
-  CK_RV error = CKR_OK;
+    CK_RV error = CKR_OK;
 
 #ifdef NSSDEBUG
-  error = nssCKFWToken_verifyPointer(fwToken);
-  if( CKR_OK != error ) {
-    return error;
-  }
+    error = nssCKFWToken_verifyPointer(fwToken);
+    if (CKR_OK != error) {
+        return error;
+    }
 
-  if( (CK_CHAR_PTR)NULL == utcTime ) {
-    return CKR_ARGUMENTS_BAD;
-  }
+    if ((CK_CHAR_PTR)NULL == utcTime) {
+        return CKR_ARGUMENTS_BAD;
+    }
 #endif /* DEBUG */
 
-  if( CK_TRUE != nssCKFWToken_GetHasClockOnToken(fwToken) ) {
-    /* return CKR_DEVICE_ERROR; */
-    (void)nssUTF8_CopyIntoFixedBuffer((NSSUTF8 *)NULL, (char *)utcTime, 16, ' ');
-    return CKR_OK;
-  }
-
-  if (!fwToken->mdToken->GetUTCTime) {
-    /* It said it had one! */
-    return CKR_GENERAL_ERROR;
-  }
-
-  error = fwToken->mdToken->GetUTCTime(fwToken->mdToken, fwToken, 
-            fwToken->mdInstance, fwToken->fwInstance, utcTime);
-  if( CKR_OK != error ) {
-    return error;
-  }
-
-  /* Sanity-check the data */
-  {
-    /* Format is YYYYMMDDhhmmss00 */
-    int i;
-    int Y, M, D, h, m, s;
-    static int dims[] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
-
-    for( i = 0; i < 16; i++ ) {
-      if( (utcTime[i] < '0') || (utcTime[i] > '9') ) {
-        goto badtime;
-      }
+    if (CK_TRUE != nssCKFWToken_GetHasClockOnToken(fwToken)) {
+        /* return CKR_DEVICE_ERROR; */
+        (void)nssUTF8_CopyIntoFixedBuffer((NSSUTF8 *)NULL, (char *)utcTime, 16, ' ');
+        return CKR_OK;
     }
 
-    Y = ((utcTime[ 0] - '0') * 1000) + ((utcTime[1] - '0') * 100) +
-        ((utcTime[ 2] - '0') * 10) + (utcTime[ 3] - '0');
-    M = ((utcTime[ 4] - '0') * 10) + (utcTime[ 5] - '0');
-    D = ((utcTime[ 6] - '0') * 10) + (utcTime[ 7] - '0');
-    h = ((utcTime[ 8] - '0') * 10) + (utcTime[ 9] - '0');
-    m = ((utcTime[10] - '0') * 10) + (utcTime[11] - '0');
-    s = ((utcTime[12] - '0') * 10) + (utcTime[13] - '0');
+    if (!fwToken->mdToken->GetUTCTime) {
+        /* It said it had one! */
+        return CKR_GENERAL_ERROR;
+    }
 
-    if( (Y < 1990) || (Y > 3000) ) goto badtime; /* Y3K problem.  heh heh heh */
-    if( (M < 1) || (M > 12) ) goto badtime;
-    if( (D < 1) || (D > 31) ) goto badtime;
+    error = fwToken->mdToken->GetUTCTime(fwToken->mdToken, fwToken,
+                                         fwToken->mdInstance, fwToken->fwInstance, utcTime);
+    if (CKR_OK != error) {
+        return error;
+    }
 
-    if( D > dims[M-1] ) goto badtime; /* per-month check */
-    if( (2 == M) && (((Y%4)||!(Y%100))&&(Y%400)) && (D > 28) ) goto badtime; /* leap years */
+    /* Sanity-check the data */
+    {
+        /* Format is YYYYMMDDhhmmss00 */
+        int i;
+        int Y, M, D, h, m, s;
+        static int dims[] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
 
-    if( (h < 0) || (h > 23) ) goto badtime;
-    if( (m < 0) || (m > 60) ) goto badtime;
-    if( (s < 0) || (s > 61) ) goto badtime;
+        for (i = 0; i < 16; i++) {
+            if ((utcTime[i] < '0') || (utcTime[i] > '9')) {
+                goto badtime;
+            }
+        }
 
-    /* 60m and 60 or 61s is only allowed for leap seconds. */
-    if( (60 == m) || (s >= 60) ) {
-      if( (23 != h) || (60 != m) || (s < 60) ) goto badtime;
-      /* leap seconds can only happen on June 30 or Dec 31.. I think */
-      /* if( ((6 != M) || (30 != D)) && ((12 != M) || (31 != D)) ) goto badtime; */
+        Y = ((utcTime[0] - '0') * 1000) + ((utcTime[1] - '0') * 100) +
+            ((utcTime[2] - '0') * 10) + (utcTime[3] - '0');
+        M = ((utcTime[4] - '0') * 10) + (utcTime[5] - '0');
+        D = ((utcTime[6] - '0') * 10) + (utcTime[7] - '0');
+        h = ((utcTime[8] - '0') * 10) + (utcTime[9] - '0');
+        m = ((utcTime[10] - '0') * 10) + (utcTime[11] - '0');
+        s = ((utcTime[12] - '0') * 10) + (utcTime[13] - '0');
+
+        if ((Y < 1990) || (Y > 3000))
+            goto badtime; /* Y3K problem.  heh heh heh */
+        if ((M < 1) || (M > 12))
+            goto badtime;
+        if ((D < 1) || (D > 31))
+            goto badtime;
+
+        if (D > dims[M - 1])
+            goto badtime; /* per-month check */
+        if ((2 == M) && (((Y % 4) || !(Y % 100)) &&
+                         (Y % 400)) &&
+            (D > 28))
+            goto badtime; /* leap years */
+
+        if ((h < 0) || (h > 23))
+            goto badtime;
+        if ((m < 0) || (m > 60))
+            goto badtime;
+        if ((s < 0) || (s > 61))
+            goto badtime;
+
+        /* 60m and 60 or 61s is only allowed for leap seconds. */
+        if ((60 == m) || (s >= 60)) {
+            if ((23 != h) || (60 != m) || (s < 60))
+                goto badtime;
+            /* leap seconds can only happen on June 30 or Dec 31.. I think */
+            /* if( ((6 != M) || (30 != D)) && ((12 != M) || (31 != D)) ) goto badtime; */
+        }
     }
-  }
 
-  return CKR_OK;
+    return CKR_OK;
 
- badtime:
-  return CKR_GENERAL_ERROR;
+badtime:
+    return CKR_GENERAL_ERROR;
 }
 
 /*
  * nssCKFWToken_OpenSession
  *
  */
 NSS_IMPLEMENT NSSCKFWSession *
-nssCKFWToken_OpenSession
-(
-  NSSCKFWToken *fwToken,
-  CK_BBOOL rw,
-  CK_VOID_PTR pApplication,
-  CK_NOTIFY Notify,
-  CK_RV *pError
-)
+nssCKFWToken_OpenSession(
+    NSSCKFWToken *fwToken,
+    CK_BBOOL rw,
+    CK_VOID_PTR pApplication,
+    CK_NOTIFY Notify,
+    CK_RV *pError)
 {
-  NSSCKFWSession *fwSession = (NSSCKFWSession *)NULL;
-  NSSCKMDSession *mdSession;
+    NSSCKFWSession *fwSession = (NSSCKFWSession *)NULL;
+    NSSCKMDSession *mdSession;
 
 #ifdef NSSDEBUG
-  if (!pError) {
-    return (NSSCKFWSession *)NULL;
-  }
+    if (!pError) {
+        return (NSSCKFWSession *)NULL;
+    }
 
-  *pError = nssCKFWToken_verifyPointer(fwToken);
-  if( CKR_OK != *pError ) {
-    return (NSSCKFWSession *)NULL;
-  }
+    *pError = nssCKFWToken_verifyPointer(fwToken);
+    if (CKR_OK != *pError) {
+        return (NSSCKFWSession *)NULL;
+    }
 
-  switch( rw ) {
-  case CK_TRUE:
-  case CK_FALSE:
-    break;
-  default:
-    *pError = CKR_ARGUMENTS_BAD;
-    return (NSSCKFWSession *)NULL;
-  }
+    switch (rw) {
+        case CK_TRUE:
+        case CK_FALSE:
+            break;
+        default:
+            *pError = CKR_ARGUMENTS_BAD;
+            return (NSSCKFWSession *)NULL;
+    }
 #endif /* NSSDEBUG */
 
-  *pError = nssCKFWMutex_Lock(fwToken->mutex);
-  if( CKR_OK != *pError ) {
-    return (NSSCKFWSession *)NULL;
-  }
+    *pError = nssCKFWMutex_Lock(fwToken->mutex);
+    if (CKR_OK != *pError) {
+        return (NSSCKFWSession *)NULL;
+    }
 
-  if( CK_TRUE == rw ) {
-    /* Read-write session desired */
-    if( CK_TRUE == nssCKFWToken_GetIsWriteProtected(fwToken) ) {
-      *pError = CKR_TOKEN_WRITE_PROTECTED;
-      goto done;
+    if (CK_TRUE == rw) {
+        /* Read-write session desired */
+        if (CK_TRUE == nssCKFWToken_GetIsWriteProtected(fwToken)) {
+            *pError = CKR_TOKEN_WRITE_PROTECTED;
+            goto done;
+        }
+    } else {
+        /* Read-only session desired */
+        if (CKS_RW_SO_FUNCTIONS == nssCKFWToken_GetSessionState(fwToken)) {
+            *pError = CKR_SESSION_READ_WRITE_SO_EXISTS;
+            goto done;
+        }
     }
-  } else {
-    /* Read-only session desired */
-    if( CKS_RW_SO_FUNCTIONS == nssCKFWToken_GetSessionState(fwToken) ) {
-      *pError = CKR_SESSION_READ_WRITE_SO_EXISTS;
-      goto done;
+
+    /* We could compare sesion counts to any limits we know of, I guess.. */
+
+    if (!fwToken->mdToken->OpenSession) {
+        /*
+         * I'm not sure that the Module actually needs to implement
+         * mdSessions -- the Framework can keep track of everything
+         * needed, really.  But I'll sort out that detail later..
+         */
+        *pError = CKR_GENERAL_ERROR;
+        goto done;
     }
-  }
 
-  /* We could compare sesion counts to any limits we know of, I guess.. */
+    fwSession = nssCKFWSession_Create(fwToken, rw, pApplication, Notify, pError);
+    if (!fwSession) {
+        if (CKR_OK == *pError) {
+            *pError = CKR_GENERAL_ERROR;
+        }
+        goto done;
+    }
 
-  if (!fwToken->mdToken->OpenSession) {
-    /*
-     * I'm not sure that the Module actually needs to implement
-     * mdSessions -- the Framework can keep track of everything 
-     * needed, really.  But I'll sort out that detail later..
-     */
-    *pError = CKR_GENERAL_ERROR;
-    goto done;
-  }
+    mdSession = fwToken->mdToken->OpenSession(fwToken->mdToken, fwToken,
+                                              fwToken->mdInstance, fwToken->fwInstance, fwSession,
+                                              rw, pError);
+    if (!mdSession) {
+        (void)nssCKFWSession_Destroy(fwSession, CK_FALSE);
+        if (CKR_OK == *pError) {
+            *pError = CKR_GENERAL_ERROR;
+        }
+        goto done;
+    }
 
-  fwSession = nssCKFWSession_Create(fwToken, rw, pApplication, Notify, pError);
-  if (!fwSession) {
-    if( CKR_OK == *pError ) {
-      *pError = CKR_GENERAL_ERROR;
+    *pError = nssCKFWSession_SetMDSession(fwSession, mdSession);
+    if (CKR_OK != *pError) {
+        if (mdSession->Close) {
+            mdSession->Close(mdSession, fwSession, fwToken->mdToken, fwToken,
+                             fwToken->mdInstance, fwToken->fwInstance);
+        }
+        (void)nssCKFWSession_Destroy(fwSession, CK_FALSE);
+        goto done;
     }
-    goto done;
-  }
 
-  mdSession = fwToken->mdToken->OpenSession(fwToken->mdToken, fwToken,
-                fwToken->mdInstance, fwToken->fwInstance, fwSession,
-                rw, pError);
-  if (!mdSession) {
-    (void)nssCKFWSession_Destroy(fwSession, CK_FALSE);
-    if( CKR_OK == *pError ) {
-      *pError = CKR_GENERAL_ERROR;
+    *pError = nssCKFWHash_Add(fwToken->sessions, fwSession, fwSession);
+    if (CKR_OK != *pError) {
+        (void)nssCKFWSession_Destroy(fwSession, CK_FALSE);
+        fwSession = (NSSCKFWSession *)NULL;
+        goto done;
     }
-    goto done;
-  }
 
-  *pError = nssCKFWSession_SetMDSession(fwSession, mdSession);
-  if( CKR_OK != *pError ) {
-    if (mdSession->Close) {
-      mdSession->Close(mdSession, fwSession, fwToken->mdToken, fwToken,
-      fwToken->mdInstance, fwToken->fwInstance);
-    }
-    (void)nssCKFWSession_Destroy(fwSession, CK_FALSE);
-    goto done;
-  }
-
-  *pError = nssCKFWHash_Add(fwToken->sessions, fwSession, fwSession);
-  if( CKR_OK != *pError ) {
-    (void)nssCKFWSession_Destroy(fwSession, CK_FALSE);
-    fwSession = (NSSCKFWSession *)NULL;
-    goto done;
-  }
-
- done:
-  (void)nssCKFWMutex_Unlock(fwToken->mutex);
-  return fwSession;
+done:
+    (void)nssCKFWMutex_Unlock(fwToken->mutex);
+    return fwSession;
 }
 
 /*
  * nssCKFWToken_GetMechanismCount
  *
  */
 NSS_IMPLEMENT CK_ULONG
-nssCKFWToken_GetMechanismCount
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetMechanismCount(
+    NSSCKFWToken *fwToken)
 {
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return 0;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return 0;
+    }
 #endif /* NSSDEBUG */
 
-  if (!fwToken->mdToken->GetMechanismCount) {
-    return 0;
-  }
+    if (!fwToken->mdToken->GetMechanismCount) {
+        return 0;
+    }
 
-  return fwToken->mdToken->GetMechanismCount(fwToken->mdToken, fwToken,
-    fwToken->mdInstance, fwToken->fwInstance);
+    return fwToken->mdToken->GetMechanismCount(fwToken->mdToken, fwToken,
+                                               fwToken->mdInstance, fwToken->fwInstance);
 }
 
 /*
  * nssCKFWToken_GetMechanismTypes
  *
  */
 NSS_IMPLEMENT CK_RV
-nssCKFWToken_GetMechanismTypes
-(
-  NSSCKFWToken *fwToken,
-  CK_MECHANISM_TYPE types[]
-)
+nssCKFWToken_GetMechanismTypes(
+    NSSCKFWToken *fwToken,
+    CK_MECHANISM_TYPE types[])
 {
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return CKR_ARGUMENTS_BAD;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return CKR_ARGUMENTS_BAD;
+    }
 
-  if (!types) {
-    return CKR_ARGUMENTS_BAD;
-  }
+    if (!types) {
+        return CKR_ARGUMENTS_BAD;
+    }
 #endif /* NSSDEBUG */
 
-  if (!fwToken->mdToken->GetMechanismTypes) {
-    /*
-     * This should only be called with a sufficiently-large
-     * "types" array, which can only be done if GetMechanismCount
-     * is implemented.  If that's implemented (and returns nonzero),
-     * then this should be too.  So return an error.
-     */
-    return CKR_GENERAL_ERROR;
-  }
+    if (!fwToken->mdToken->GetMechanismTypes) {
+        /*
+         * This should only be called with a sufficiently-large
+         * "types" array, which can only be done if GetMechanismCount
+         * is implemented.  If that's implemented (and returns nonzero),
+         * then this should be too.  So return an error.
+         */
+        return CKR_GENERAL_ERROR;
+    }
 
-  return fwToken->mdToken->GetMechanismTypes(fwToken->mdToken, fwToken,
-    fwToken->mdInstance, fwToken->fwInstance, types);
+    return fwToken->mdToken->GetMechanismTypes(fwToken->mdToken, fwToken,
+                                               fwToken->mdInstance, fwToken->fwInstance, types);
 }
 
-
 /*
  * nssCKFWToken_GetMechanism
  *
  */
 NSS_IMPLEMENT NSSCKFWMechanism *
-nssCKFWToken_GetMechanism
-(
-  NSSCKFWToken *fwToken,
-  CK_MECHANISM_TYPE which,
-  CK_RV *pError
-)
+nssCKFWToken_GetMechanism(
+    NSSCKFWToken *fwToken,
+    CK_MECHANISM_TYPE which,
+    CK_RV *pError)
 {
-  NSSCKMDMechanism *mdMechanism;
-  if (!fwToken->mdMechanismHash) {
-    *pError = CKR_GENERAL_ERROR;
-    return (NSSCKFWMechanism *)NULL;
-  }
-  
-  if (!fwToken->mdToken->GetMechanism) {
-    /*
-     * If we don't implement any GetMechanism function, then we must
-     * not support any.
-     */
-    *pError = CKR_MECHANISM_INVALID;
-    return (NSSCKFWMechanism *)NULL;
-  }
+    NSSCKMDMechanism *mdMechanism;
+    if (!fwToken->mdMechanismHash) {
+        *pError = CKR_GENERAL_ERROR;
+        return (NSSCKFWMechanism *)NULL;
+    }
 
-  /* lookup in hash table */
-  mdMechanism = fwToken->mdToken->GetMechanism(fwToken->mdToken, fwToken,
-    fwToken->mdInstance, fwToken->fwInstance, which, pError);
-  if (!mdMechanism) {
-    return (NSSCKFWMechanism *) NULL;
-  }
-  /* store in hash table */
-  return nssCKFWMechanism_Create(mdMechanism, fwToken->mdToken, fwToken,
-    fwToken->mdInstance, fwToken->fwInstance);
+    if (!fwToken->mdToken->GetMechanism) {
+        /*
+         * If we don't implement any GetMechanism function, then we must
+         * not support any.
+         */
+        *pError = CKR_MECHANISM_INVALID;
+        return (NSSCKFWMechanism *)NULL;
+    }
+
+    /* lookup in hash table */
+    mdMechanism = fwToken->mdToken->GetMechanism(fwToken->mdToken, fwToken,
+                                                 fwToken->mdInstance, fwToken->fwInstance, which, pError);
+    if (!mdMechanism) {
+        return (NSSCKFWMechanism *)NULL;
+    }
+    /* store in hash table */
+    return nssCKFWMechanism_Create(mdMechanism, fwToken->mdToken, fwToken,
+                                   fwToken->mdInstance, fwToken->fwInstance);
 }
 
 NSS_IMPLEMENT CK_RV
-nssCKFWToken_SetSessionState
-(
-  NSSCKFWToken *fwToken,
-  CK_STATE newState
-)
+nssCKFWToken_SetSessionState(
+    NSSCKFWToken *fwToken,
+    CK_STATE newState)
 {
-  CK_RV error = CKR_OK;
+    CK_RV error = CKR_OK;
 
 #ifdef NSSDEBUG
-  error = nssCKFWToken_verifyPointer(fwToken);
-  if( CKR_OK != error ) {
-    return error;
-  }
+    error = nssCKFWToken_verifyPointer(fwToken);
+    if (CKR_OK != error) {
+        return error;
+    }
 
-  switch( newState ) {
-  case CKS_RO_PUBLIC_SESSION:
-  case CKS_RO_USER_FUNCTIONS:
-  case CKS_RW_PUBLIC_SESSION:
-  case CKS_RW_USER_FUNCTIONS:
-  case CKS_RW_SO_FUNCTIONS:
-    break;
-  default:
-    return CKR_ARGUMENTS_BAD;
-  }
+    switch (newState) {
+        case CKS_RO_PUBLIC_SESSION:
+        case CKS_RO_USER_FUNCTIONS:
+        case CKS_RW_PUBLIC_SESSION:
+        case CKS_RW_USER_FUNCTIONS:
+        case CKS_RW_SO_FUNCTIONS:
+            break;
+        default:
+            return CKR_ARGUMENTS_BAD;
+    }
 #endif /* NSSDEBUG */
 
-  error = nssCKFWMutex_Lock(fwToken->mutex);
-  if( CKR_OK != error ) {
-    return error;
-  }
+    error = nssCKFWMutex_Lock(fwToken->mutex);
+    if (CKR_OK != error) {
+        return error;
+    }
 
-  fwToken->state = newState;
-  (void)nssCKFWMutex_Unlock(fwToken->mutex);
-  return CKR_OK;
+    fwToken->state = newState;
+    (void)nssCKFWMutex_Unlock(fwToken->mutex);
+    return CKR_OK;
 }
 
 /*
  * nssCKFWToken_RemoveSession
  *
  */
 NSS_IMPLEMENT CK_RV
-nssCKFWToken_RemoveSession
-(
-  NSSCKFWToken *fwToken,
-  NSSCKFWSession *fwSession
-)
+nssCKFWToken_RemoveSession(
+    NSSCKFWToken *fwToken,
+    NSSCKFWSession *fwSession)
 {
-  CK_RV error = CKR_OK;
+    CK_RV error = CKR_OK;
 
 #ifdef NSSDEBUG
-  error = nssCKFWToken_verifyPointer(fwToken);
-  if( CKR_OK != error ) {
-    return error;
-  }
+    error = nssCKFWToken_verifyPointer(fwToken);
+    if (CKR_OK != error) {
+        return error;
+    }
 
-  error = nssCKFWSession_verifyPointer(fwSession);
-  if( CKR_OK != error ) {
-    return error;
-  }
+    error = nssCKFWSession_verifyPointer(fwSession);
+    if (CKR_OK != error) {
+        return error;
+    }
 #endif /* NSSDEBUG */
 
-  error = nssCKFWMutex_Lock(fwToken->mutex);
-  if( CKR_OK != error ) {
+    error = nssCKFWMutex_Lock(fwToken->mutex);
+    if (CKR_OK != error) {
+        return error;
+    }
+
+    if (CK_TRUE != nssCKFWHash_Exists(fwToken->sessions, fwSession)) {
+        error = CKR_SESSION_HANDLE_INVALID;
+        goto done;
+    }
+
+    nssCKFWHash_Remove(fwToken->sessions, fwSession);
+    fwToken->sessionCount--;
+
+    if (nssCKFWSession_IsRWSession(fwSession)) {
+        fwToken->rwSessionCount--;
+    }
+
+    if (0 == fwToken->sessionCount) {
+        fwToken->rwSessionCount = 0;            /* sanity */
+        fwToken->state = CKS_RO_PUBLIC_SESSION; /* some default */
+    }
+
+    error = CKR_OK;
+
+done:
+    (void)nssCKFWMutex_Unlock(fwToken->mutex);
     return error;
-  }
-
-  if( CK_TRUE != nssCKFWHash_Exists(fwToken->sessions, fwSession) ) {
-    error = CKR_SESSION_HANDLE_INVALID;
-    goto done;
-  }
-
-  nssCKFWHash_Remove(fwToken->sessions, fwSession);
-  fwToken->sessionCount--;
-
-  if( nssCKFWSession_IsRWSession(fwSession) ) {
-    fwToken->rwSessionCount--;
-  }
-
-  if( 0 == fwToken->sessionCount ) {
-    fwToken->rwSessionCount = 0; /* sanity */
-    fwToken->state = CKS_RO_PUBLIC_SESSION; /* some default */
-  }
-
-  error = CKR_OK;
-
- done:
-  (void)nssCKFWMutex_Unlock(fwToken->mutex);
-  return error;
 }
 
-
 /*
  * nssCKFWToken_CloseAllSessions
  *
  */
 NSS_IMPLEMENT CK_RV
-nssCKFWToken_CloseAllSessions
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_CloseAllSessions(
+    NSSCKFWToken *fwToken)
 {
-  CK_RV error = CKR_OK;
+    CK_RV error = CKR_OK;
 
 #ifdef NSSDEBUG
-  error = nssCKFWToken_verifyPointer(fwToken);
-  if( CKR_OK != error ) {
-    return error;
-  }
+    error = nssCKFWToken_verifyPointer(fwToken);
+    if (CKR_OK != error) {
+        return error;
+    }
 #endif /* NSSDEBUG */
 
-  error = nssCKFWMutex_Lock(fwToken->mutex);
-  if( CKR_OK != error ) {
+    error = nssCKFWMutex_Lock(fwToken->mutex);
+    if (CKR_OK != error) {
+        return error;
+    }
+
+    nssCKFWHash_Iterate(fwToken->sessions, nss_ckfwtoken_session_iterator, (void *)NULL);
+
+    nssCKFWHash_Destroy(fwToken->sessions);
+
+    fwToken->sessions = nssCKFWHash_Create(fwToken->fwInstance, fwToken->arena, &error);
+    if (!fwToken->sessions) {
+        if (CKR_OK == error) {
+            error = CKR_GENERAL_ERROR;
+        }
+        goto done;
+    }
+
+    fwToken->state = CKS_RO_PUBLIC_SESSION; /* some default */
+    fwToken->sessionCount = 0;
+    fwToken->rwSessionCount = 0;
+
+    error = CKR_OK;
+
+done:
+    (void)nssCKFWMutex_Unlock(fwToken->mutex);
     return error;
-  }
-
-  nssCKFWHash_Iterate(fwToken->sessions, nss_ckfwtoken_session_iterator, (void *)NULL);
-
-  nssCKFWHash_Destroy(fwToken->sessions);
-
-  fwToken->sessions = nssCKFWHash_Create(fwToken->fwInstance, fwToken->arena, &error);
-  if (!fwToken->sessions) {
-    if( CKR_OK == error ) {
-      error = CKR_GENERAL_ERROR;
-    }
-    goto done;
-  }
-
-  fwToken->state = CKS_RO_PUBLIC_SESSION; /* some default */
-  fwToken->sessionCount = 0;
-  fwToken->rwSessionCount = 0;
-
-  error = CKR_OK;
-
- done:
-  (void)nssCKFWMutex_Unlock(fwToken->mutex);
-  return error;
 }
 
 /*
  * nssCKFWToken_GetSessionCount
  *
  */
 NSS_IMPLEMENT CK_ULONG
-nssCKFWToken_GetSessionCount
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetSessionCount(
+    NSSCKFWToken *fwToken)
 {
-  CK_ULONG rv;
+    CK_ULONG rv;
 
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return (CK_ULONG)0;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return (CK_ULONG)0;
+    }
 #endif /* NSSDEBUG */
 
-  if( CKR_OK != nssCKFWMutex_Lock(fwToken->mutex) ) {
-    return (CK_ULONG)0;
-  }
+    if (CKR_OK != nssCKFWMutex_Lock(fwToken->mutex)) {
+        return (CK_ULONG)0;
+    }
 
-  rv = fwToken->sessionCount;
-  (void)nssCKFWMutex_Unlock(fwToken->mutex);
-  return rv;
+    rv = fwToken->sessionCount;
+    (void)nssCKFWMutex_Unlock(fwToken->mutex);
+    return rv;
 }
 
 /*
  * nssCKFWToken_GetRwSessionCount
  *
  */
 NSS_IMPLEMENT CK_ULONG
-nssCKFWToken_GetRwSessionCount
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetRwSessionCount(
+    NSSCKFWToken *fwToken)
 {
-  CK_ULONG rv;
+    CK_ULONG rv;
 
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return (CK_ULONG)0;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return (CK_ULONG)0;
+    }
 #endif /* NSSDEBUG */
 
-  if( CKR_OK != nssCKFWMutex_Lock(fwToken->mutex) ) {
-    return (CK_ULONG)0;
-  }
+    if (CKR_OK != nssCKFWMutex_Lock(fwToken->mutex)) {
+        return (CK_ULONG)0;
+    }
 
-  rv = fwToken->rwSessionCount;
-  (void)nssCKFWMutex_Unlock(fwToken->mutex);
-  return rv;
+    rv = fwToken->rwSessionCount;
+    (void)nssCKFWMutex_Unlock(fwToken->mutex);
+    return rv;
 }
 
 /*
  * nssCKFWToken_GetRoSessionCount
  *
  */
 NSS_IMPLEMENT CK_ULONG
-nssCKFWToken_GetRoSessionCount
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetRoSessionCount(
+    NSSCKFWToken *fwToken)
 {
-  CK_ULONG rv;
+    CK_ULONG rv;
 
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return (CK_ULONG)0;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return (CK_ULONG)0;
+    }
 #endif /* NSSDEBUG */
 
-  if( CKR_OK != nssCKFWMutex_Lock(fwToken->mutex) ) {
-    return (CK_ULONG)0;
-  }
+    if (CKR_OK != nssCKFWMutex_Lock(fwToken->mutex)) {
+        return (CK_ULONG)0;
+    }
 
-  rv = fwToken->sessionCount - fwToken->rwSessionCount;
-  (void)nssCKFWMutex_Unlock(fwToken->mutex);
-  return rv;
+    rv = fwToken->sessionCount - fwToken->rwSessionCount;
+    (void)nssCKFWMutex_Unlock(fwToken->mutex);
+    return rv;
 }
 
 /*
  * nssCKFWToken_GetSessionObjectHash
  *
  */
 NSS_IMPLEMENT nssCKFWHash *
-nssCKFWToken_GetSessionObjectHash
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetSessionObjectHash(
+    NSSCKFWToken *fwToken)
 {
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return (nssCKFWHash *)NULL;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return (nssCKFWHash *)NULL;
+    }
 #endif /* NSSDEBUG */
 
-  return fwToken->sessionObjectHash;
+    return fwToken->sessionObjectHash;
 }
 
 /*
  * nssCKFWToken_GetMDObjectHash
  *
  */
 NSS_IMPLEMENT nssCKFWHash *
-nssCKFWToken_GetMDObjectHash
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetMDObjectHash(
+    NSSCKFWToken *fwToken)
 {
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return (nssCKFWHash *)NULL;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return (nssCKFWHash *)NULL;
+    }
 #endif /* NSSDEBUG */
 
-  return fwToken->mdObjectHash;
+    return fwToken->mdObjectHash;
 }
 
 /*
  * nssCKFWToken_GetObjectHandleHash
  *
  */
 NSS_IMPLEMENT nssCKFWHash *
-nssCKFWToken_GetObjectHandleHash
-(
-  NSSCKFWToken *fwToken
-)
+nssCKFWToken_GetObjectHandleHash(
+    NSSCKFWToken *fwToken)
 {
 #ifdef NSSDEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return (nssCKFWHash *)NULL;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return (nssCKFWHash *)NULL;
+    }
 #endif /* NSSDEBUG */
 
-  return fwToken->mdObjectHash;
+    return fwToken->mdObjectHash;
 }
 
 /*
  * NSSCKFWToken_GetMDToken
  *
  */
 
 NSS_IMPLEMENT NSSCKMDToken *
-NSSCKFWToken_GetMDToken
-(
-  NSSCKFWToken *fwToken
-)
+NSSCKFWToken_GetMDToken(
+    NSSCKFWToken *fwToken)
 {
 #ifdef DEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return (NSSCKMDToken *)NULL;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return (NSSCKMDToken *)NULL;
+    }
 #endif /* DEBUG */
 
-  return nssCKFWToken_GetMDToken(fwToken);
+    return nssCKFWToken_GetMDToken(fwToken);
 }
 
 /*
  * NSSCKFWToken_GetArena
  *
  */
 
 NSS_IMPLEMENT NSSArena *
-NSSCKFWToken_GetArena
-(
-  NSSCKFWToken *fwToken,
-  CK_RV *pError
-)
+NSSCKFWToken_GetArena(
+    NSSCKFWToken *fwToken,
+    CK_RV *pError)
 {
 #ifdef DEBUG
-  if (!pError) {
-    return (NSSArena *)NULL;
-  }
+    if (!pError) {
+        return (NSSArena *)NULL;
+    }
 
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    *pError = CKR_ARGUMENTS_BAD;
-    return (NSSArena *)NULL;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        *pError = CKR_ARGUMENTS_BAD;
+        return (NSSArena *)NULL;
+    }
 #endif /* DEBUG */
 
-  return nssCKFWToken_GetArena(fwToken, pError);
+    return nssCKFWToken_GetArena(fwToken, pError);
 }
 
 /*
  * NSSCKFWToken_GetFWSlot
  *
  */
 
 NSS_IMPLEMENT NSSCKFWSlot *
-NSSCKFWToken_GetFWSlot
-(
-  NSSCKFWToken *fwToken
-)
+NSSCKFWToken_GetFWSlot(
+    NSSCKFWToken *fwToken)
 {
 #ifdef DEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return (NSSCKFWSlot *)NULL;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return (NSSCKFWSlot *)NULL;
+    }
 #endif /* DEBUG */
 
-  return nssCKFWToken_GetFWSlot(fwToken);
+    return nssCKFWToken_GetFWSlot(fwToken);
 }
 
 /*
  * NSSCKFWToken_GetMDSlot
  *
  */
 
 NSS_IMPLEMENT NSSCKMDSlot *
-NSSCKFWToken_GetMDSlot
-(
-  NSSCKFWToken *fwToken
-)
+NSSCKFWToken_GetMDSlot(
+    NSSCKFWToken *fwToken)
 {
 #ifdef DEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return (NSSCKMDSlot *)NULL;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return (NSSCKMDSlot *)NULL;
+    }
 #endif /* DEBUG */
 
-  return nssCKFWToken_GetMDSlot(fwToken);
+    return nssCKFWToken_GetMDSlot(fwToken);
 }
 
 /*
  * NSSCKFWToken_GetSessionState
  *
  */
 
 NSS_IMPLEMENT CK_STATE
-NSSCKFWSession_GetSessionState
-(
-  NSSCKFWToken *fwToken
-)
+NSSCKFWSession_GetSessionState(
+    NSSCKFWToken *fwToken)
 {
 #ifdef DEBUG
-  if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
-    return CKS_RO_PUBLIC_SESSION;
-  }
+    if (CKR_OK != nssCKFWToken_verifyPointer(fwToken)) {
+        return CKS_RO_PUBLIC_SESSION;
+    }
 #endif /* DEBUG */
 
-  return nssCKFWToken_GetSessionState(fwToken);
+    return nssCKFWToken_GetSessionState(fwToken);
 }