From 1adb86262f4946b39495fb4096346d37034833b1 Mon Sep 17 00:00:00 2001 From: "wtc%netscape.com" Date: Fri, 22 Sep 2000 22:52:20 +0000 Subject: [PATCH] Added perl-generated files nssckpev.h nssckft.h nssckg.h nssck.api. --- security/nss/lib/ckfw/nssck.api | 1885 ++++++++++++++++++++++++++++++ security/nss/lib/ckfw/nssckepv.h | 128 ++ security/nss/lib/ckfw/nssckft.h | 492 ++++++++ security/nss/lib/ckfw/nssckg.h | 560 +++++++++ 4 files changed, 3065 insertions(+) create mode 100644 security/nss/lib/ckfw/nssck.api create mode 100644 security/nss/lib/ckfw/nssckepv.h create mode 100644 security/nss/lib/ckfw/nssckft.h create mode 100644 security/nss/lib/ckfw/nssckg.h diff --git a/security/nss/lib/ckfw/nssck.api b/security/nss/lib/ckfw/nssck.api new file mode 100644 index 00000000000..0544d521754 --- /dev/null +++ b/security/nss/lib/ckfw/nssck.api @@ -0,0 +1,1885 @@ +/* THIS IS A GENERATED FILE */ +/* + * 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 Netscape are + * Copyright (C) 1994-2000 Netscape Communications Corporation. All + * Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License Version 2 or later (the + * "GPL"), in which case the provisions of the GPL are applicable + * instead of those above. If you wish to allow use of your + * version of this file only under the terms of the GPL and not to + * allow others to use your version of this file under the MPL, + * indicate your decision by deleting the provisions above and + * replace them with the notice and other provisions required by + * the GPL. If you do not delete the provisions above, a recipient + * may use your version of this file under either the MPL or the + * GPL. + */ + +#ifdef DEBUG +static const char NSSCKAPI_CVS_ID[] = "@(#) $RCSfile: nssck.api,v $ $Revision: 1.1 $ $Date: 2000-09-22 22:52:20 $ $Name: $ ; @(#) $RCSfile: nssck.api,v $ $Revision: 1.1 $ $Date: 2000-09-22 22:52:20 $ $Name: $"; +#endif /* DEBUG */ + +/* + * nssck.api + * + * This automatically-generated file is used to generate a set of + * Cryptoki entry points within the object space of a Module using + * the NSS Cryptoki Framework. + * + * The Module should have a .c file with the following: + * + * #define MODULE_NAME name + * #define INSTANCE_NAME instance + * #include "nssck.api" + * + * where "name" is some module-specific name that can be used to + * disambiguate various modules. This included file will then + * define the actual Cryptoki routines which pass through to the + * Framework calls. All routines, except C_GetFunctionList, will + * be prefixed with the name; C_GetFunctionList will be generated + * to return an entry-point vector with these routines. The + * instance specified should be the basic instance of NSSCKMDInstance. + * + * If, prior to including nssck.api, the .c file also specifies + * + * #define DECLARE_STRICT_CRYTPOKI_NAMES + * + * Then a set of "stub" routines not prefixed with the name will + * be included. This would allow the combined module and framework + * to be used in applications which are hard-coded to use the + * PKCS#11 names (instead of going through the EPV). Please note + * that such applications should be careful resolving symbols when + * more than one PKCS#11 module is loaded. + */ + +#ifndef MODULE_NAME +#error "Error: MODULE_NAME must be defined." +#endif /* MODULE_NAME */ + +#ifndef INSTANCE_NAME +#error "Error: INSTANCE_NAME must be defined." +#endif /* INSTANCE_NAME */ + +#ifndef NSSCKT_H +#include "nssckt.h" +#endif /* NSSCKT_H */ + +#ifndef NSSCKFWT_H +#include "nssckfwt.h" +#endif /* NSSCKFWT_H */ + +#ifndef NSSCKFWC_H +#include "nssckfwc.h" +#endif /* NSSCKFWC_H */ + +#ifndef NSSCKEPV_H +#include "nssckepv.h" +#endif /* NSSCKEPV_H */ + +#define __ADJOIN(x,y) x##y + +/* + * The anchor. This object is used to store an "anchor" pointer in + * the Module's object space, so the wrapper functions can relate + * back to this instance. + */ + +static NSSCKFWInstance *fwInstance = (NSSCKFWInstance *)0; + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_Initialize) +( + CK_VOID_PTR pInitArgs +) +{ + return NSSCKFWC_Initialize(&fwInstance, INSTANCE_NAME, pInitArgs); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_Initialize +( + CK_VOID_PTR pInitArgs +) +{ + return __ADJOIN(MODULE_NAME,C_Initialize)(pInitArgs); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_Finalize) +( + CK_VOID_PTR pReserved +) +{ + return NSSCKFWC_Finalize(&fwInstance); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_Finalize +( + CK_VOID_PTR pReserved +) +{ + return __ADJOIN(MODULE_NAME,C_Finalize)(pReserved); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_GetInfo) +( + CK_INFO_PTR pInfo +) +{ + return NSSCKFWC_GetInfo(fwInstance, pInfo); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_GetInfo +( + CK_INFO_PTR pInfo +) +{ + return __ADJOIN(MODULE_NAME,C_GetInfo)(pInfo); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +/* + * C_GetFunctionList is defined at the end. + */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_GetSlotList) +( + CK_BBOOL tokenPresent, + CK_SLOT_ID_PTR pSlotList, + CK_ULONG_PTR pulCount +) +{ + return NSSCKFWC_GetSlotList(fwInstance, tokenPresent, pSlotList, pulCount); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_GetSlotList +( + CK_BBOOL tokenPresent, + CK_SLOT_ID_PTR pSlotList, + CK_ULONG_PTR pulCount +) +{ + return __ADJOIN(MODULE_NAME,C_GetSlotList)(tokenPresent, pSlotList, pulCount); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_GetSlotInfo) +( + CK_SLOT_ID slotID, + CK_SLOT_INFO_PTR pInfo +) +{ + return NSSCKFWC_GetSlotInfo(fwInstance, slotID, pInfo); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_GetSlotInfo +( + CK_SLOT_ID slotID, + CK_SLOT_INFO_PTR pInfo +) +{ + return __ADJOIN(MODULE_NAME,C_GetSlotInfo)(slotID, pInfo); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_GetTokenInfo) +( + CK_SLOT_ID slotID, + CK_TOKEN_INFO_PTR pInfo +) +{ + return NSSCKFWC_GetTokenInfo(fwInstance, slotID, pInfo); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_GetTokenInfo +( + CK_SLOT_ID slotID, + CK_TOKEN_INFO_PTR pInfo +) +{ + return __ADJOIN(MODULE_NAME,C_GetTokenInfo)(slotID, pInfo); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_GetMechanismList) +( + CK_SLOT_ID slotID, + CK_MECHANISM_TYPE_PTR pMechanismList, + CK_ULONG_PTR pulCount +) +{ + return NSSCKFWC_GetMechanismList(fwInstance, slotID, pMechanismList, pulCount); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_GetMechanismList +( + CK_SLOT_ID slotID, + CK_MECHANISM_TYPE_PTR pMechanismList, + CK_ULONG_PTR pulCount +) +{ + return __ADJOIN(MODULE_NAME,C_GetMechanismList)(slotID, pMechanismList, pulCount); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_GetMechanismInfo) +( + CK_SLOT_ID slotID, + CK_MECHANISM_TYPE type, + CK_MECHANISM_INFO_PTR pInfo +) +{ + return NSSCKFWC_GetMechanismInfo(fwInstance, slotID, type, pInfo); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_GetMechanismInfo +( + CK_SLOT_ID slotID, + CK_MECHANISM_TYPE type, + CK_MECHANISM_INFO_PTR pInfo +) +{ + return __ADJOIN(MODULE_NAME,C_GetMechanismInfo)(slotID, type, pInfo); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_InitToken) +( + CK_SLOT_ID slotID, + CK_CHAR_PTR pPin, + CK_ULONG ulPinLen, + CK_CHAR_PTR pLabel +) +{ + return NSSCKFWC_InitToken(fwInstance, slotID, pPin, ulPinLen, pLabel); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_InitToken +( + CK_SLOT_ID slotID, + CK_CHAR_PTR pPin, + CK_ULONG ulPinLen, + CK_CHAR_PTR pLabel +) +{ + return __ADJOIN(MODULE_NAME,C_InitToken)(slotID, pPin, ulPinLen, pLabel); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_InitPIN) +( + CK_SESSION_HANDLE hSession, + CK_CHAR_PTR pPin, + CK_ULONG ulPinLen +) +{ + return NSSCKFWC_InitPIN(fwInstance, hSession, pPin, ulPinLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_InitPIN +( + CK_SESSION_HANDLE hSession, + CK_CHAR_PTR pPin, + CK_ULONG ulPinLen +) +{ + return __ADJOIN(MODULE_NAME,C_InitPIN)(hSession, pPin, ulPinLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_SetPIN) +( + CK_SESSION_HANDLE hSession, + CK_CHAR_PTR pOldPin, + CK_ULONG ulOldLen, + CK_CHAR_PTR pNewPin, + CK_ULONG ulNewLen +) +{ + return NSSCKFWC_SetPIN(fwInstance, hSession, pOldPin, ulOldLen, pNewPin, ulNewLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_SetPIN +( + CK_SESSION_HANDLE hSession, + CK_CHAR_PTR pOldPin, + CK_ULONG ulOldLen, + CK_CHAR_PTR pNewPin, + CK_ULONG ulNewLen +) +{ + return __ADJOIN(MODULE_NAME,C_SetPIN)(hSession, pOldPin, ulOldLen, pNewPin, ulNewLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_OpenSession) +( + CK_SLOT_ID slotID, + CK_FLAGS flags, + CK_VOID_PTR pApplication, + CK_NOTIFY Notify, + CK_SESSION_HANDLE_PTR phSession +) +{ + return NSSCKFWC_OpenSession(fwInstance, slotID, flags, pApplication, Notify, phSession); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_OpenSession +( + CK_SLOT_ID slotID, + CK_FLAGS flags, + CK_VOID_PTR pApplication, + CK_NOTIFY Notify, + CK_SESSION_HANDLE_PTR phSession +) +{ + return __ADJOIN(MODULE_NAME,C_OpenSession)(slotID, flags, pApplication, Notify, phSession); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_CloseSession) +( + CK_SESSION_HANDLE hSession +) +{ + return NSSCKFWC_CloseSession(fwInstance, hSession); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_CloseSession +( + CK_SESSION_HANDLE hSession +) +{ + return __ADJOIN(MODULE_NAME,C_CloseSession)(hSession); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_CloseAllSessions) +( + CK_SLOT_ID slotID +) +{ + return NSSCKFWC_CloseAllSessions(fwInstance, slotID); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_CloseAllSessions +( + CK_SLOT_ID slotID +) +{ + return __ADJOIN(MODULE_NAME,C_CloseAllSessions)(slotID); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_GetSessionInfo) +( + CK_SESSION_HANDLE hSession, + CK_SESSION_INFO_PTR pInfo +) +{ + return NSSCKFWC_GetSessionInfo(fwInstance, hSession, pInfo); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_GetSessionInfo +( + CK_SESSION_HANDLE hSession, + CK_SESSION_INFO_PTR pInfo +) +{ + return __ADJOIN(MODULE_NAME,C_GetSessionInfo)(hSession, pInfo); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_GetOperationState) +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pOperationState, + CK_ULONG_PTR pulOperationStateLen +) +{ + return NSSCKFWC_GetOperationState(fwInstance, hSession, pOperationState, pulOperationStateLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_GetOperationState +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pOperationState, + CK_ULONG_PTR pulOperationStateLen +) +{ + return __ADJOIN(MODULE_NAME,C_GetOperationState)(hSession, pOperationState, pulOperationStateLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_SetOperationState) +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pOperationState, + CK_ULONG ulOperationStateLen, + CK_OBJECT_HANDLE hEncryptionKey, + CK_OBJECT_HANDLE hAuthenticationKey +) +{ + return NSSCKFWC_SetOperationState(fwInstance, hSession, pOperationState, ulOperationStateLen, hEncryptionKey, hAuthenticationKey); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_SetOperationState +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pOperationState, + CK_ULONG ulOperationStateLen, + CK_OBJECT_HANDLE hEncryptionKey, + CK_OBJECT_HANDLE hAuthenticationKey +) +{ + return __ADJOIN(MODULE_NAME,C_SetOperationState)(hSession, pOperationState, ulOperationStateLen, hEncryptionKey, hAuthenticationKey); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_Login) +( + CK_SESSION_HANDLE hSession, + CK_USER_TYPE userType, + CK_CHAR_PTR pPin, + CK_ULONG ulPinLen +) +{ + return NSSCKFWC_Login(fwInstance, hSession, userType, pPin, ulPinLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_Login +( + CK_SESSION_HANDLE hSession, + CK_USER_TYPE userType, + CK_CHAR_PTR pPin, + CK_ULONG ulPinLen +) +{ + return __ADJOIN(MODULE_NAME,C_Login)(hSession, userType, pPin, ulPinLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_Logout) +( + CK_SESSION_HANDLE hSession +) +{ + return NSSCKFWC_Logout(fwInstance, hSession); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_Logout +( + CK_SESSION_HANDLE hSession +) +{ + return __ADJOIN(MODULE_NAME,C_Logout)(hSession); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_CreateObject) +( + CK_SESSION_HANDLE hSession, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount, + CK_OBJECT_HANDLE_PTR phObject +) +{ + return NSSCKFWC_CreateObject(fwInstance, hSession, pTemplate, ulCount, phObject); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_CreateObject +( + CK_SESSION_HANDLE hSession, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount, + CK_OBJECT_HANDLE_PTR phObject +) +{ + return __ADJOIN(MODULE_NAME,C_CreateObject)(hSession, pTemplate, ulCount, phObject); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_CopyObject) +( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hObject, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount, + CK_OBJECT_HANDLE_PTR phNewObject +) +{ + return NSSCKFWC_CopyObject(fwInstance, hSession, hObject, pTemplate, ulCount, phNewObject); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_CopyObject +( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hObject, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount, + CK_OBJECT_HANDLE_PTR phNewObject +) +{ + return __ADJOIN(MODULE_NAME,C_CopyObject)(hSession, hObject, pTemplate, ulCount, phNewObject); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_DestroyObject) +( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hObject +) +{ + return NSSCKFWC_DestroyObject(fwInstance, hSession, hObject); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_DestroyObject +( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hObject +) +{ + return __ADJOIN(MODULE_NAME,C_DestroyObject)(hSession, hObject); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_GetObjectSize) +( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hObject, + CK_ULONG_PTR pulSize +) +{ + return NSSCKFWC_GetObjectSize(fwInstance, hSession, hObject, pulSize); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_GetObjectSize +( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hObject, + CK_ULONG_PTR pulSize +) +{ + return __ADJOIN(MODULE_NAME,C_GetObjectSize)(hSession, hObject, pulSize); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_GetAttributeValue) +( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hObject, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount +) +{ + return NSSCKFWC_GetAttributeValue(fwInstance, hSession, hObject, pTemplate, ulCount); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_GetAttributeValue +( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hObject, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount +) +{ + return __ADJOIN(MODULE_NAME,C_GetAttributeValue)(hSession, hObject, pTemplate, ulCount); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_SetAttributeValue) +( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hObject, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount +) +{ + return NSSCKFWC_SetAttributeValue(fwInstance, hSession, hObject, pTemplate, ulCount); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_SetAttributeValue +( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hObject, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount +) +{ + return __ADJOIN(MODULE_NAME,C_SetAttributeValue)(hSession, hObject, pTemplate, ulCount); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_FindObjectsInit) +( + CK_SESSION_HANDLE hSession, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount +) +{ + return NSSCKFWC_FindObjectsInit(fwInstance, hSession, pTemplate, ulCount); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_FindObjectsInit +( + CK_SESSION_HANDLE hSession, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount +) +{ + return __ADJOIN(MODULE_NAME,C_FindObjectsInit)(hSession, pTemplate, ulCount); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_FindObjects) +( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE_PTR phObject, + CK_ULONG ulMaxObjectCount, + CK_ULONG_PTR pulObjectCount +) +{ + return NSSCKFWC_FindObjects(fwInstance, hSession, phObject, ulMaxObjectCount, pulObjectCount); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_FindObjects +( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE_PTR phObject, + CK_ULONG ulMaxObjectCount, + CK_ULONG_PTR pulObjectCount +) +{ + return __ADJOIN(MODULE_NAME,C_FindObjects)(hSession, phObject, ulMaxObjectCount, pulObjectCount); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_FindObjectsFinal) +( + CK_SESSION_HANDLE hSession +) +{ + return NSSCKFWC_FindObjectsFinal(fwInstance, hSession); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_FindObjectsFinal +( + CK_SESSION_HANDLE hSession +) +{ + return __ADJOIN(MODULE_NAME,C_FindObjectsFinal)(hSession); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_EncryptInit) +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey +) +{ + return NSSCKFWC_EncryptInit(fwInstance, hSession, pMechanism, hKey); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_EncryptInit +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey +) +{ + return __ADJOIN(MODULE_NAME,C_EncryptInit)(hSession, pMechanism, hKey); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_Encrypt) +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pData, + CK_ULONG ulDataLen, + CK_BYTE_PTR pEncryptedData, + CK_ULONG_PTR pulEncryptedDataLen +) +{ + return NSSCKFWC_Encrypt(fwInstance, hSession, pData, ulDataLen, pEncryptedData, pulEncryptedDataLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_Encrypt +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pData, + CK_ULONG ulDataLen, + CK_BYTE_PTR pEncryptedData, + CK_ULONG_PTR pulEncryptedDataLen +) +{ + return __ADJOIN(MODULE_NAME,C_Encrypt)(hSession, pData, ulDataLen, pEncryptedData, pulEncryptedDataLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_EncryptUpdate) +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG_PTR pulEncryptedPartLen +) +{ + return NSSCKFWC_EncryptUpdate(fwInstance, hSession, pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_EncryptUpdate +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG_PTR pulEncryptedPartLen +) +{ + return __ADJOIN(MODULE_NAME,C_EncryptUpdate)(hSession, pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_EncryptFinal) +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pLastEncryptedPart, + CK_ULONG_PTR pulLastEncryptedPartLen +) +{ + return NSSCKFWC_EncryptFinal(fwInstance, hSession, pLastEncryptedPart, pulLastEncryptedPartLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_EncryptFinal +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pLastEncryptedPart, + CK_ULONG_PTR pulLastEncryptedPartLen +) +{ + return __ADJOIN(MODULE_NAME,C_EncryptFinal)(hSession, pLastEncryptedPart, pulLastEncryptedPartLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_DecryptInit) +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey +) +{ + return NSSCKFWC_DecryptInit(fwInstance, hSession, pMechanism, hKey); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_DecryptInit +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey +) +{ + return __ADJOIN(MODULE_NAME,C_DecryptInit)(hSession, pMechanism, hKey); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_Decrypt) +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pEncryptedData, + CK_ULONG ulEncryptedDataLen, + CK_BYTE_PTR pData, + CK_ULONG_PTR pulDataLen +) +{ + return NSSCKFWC_Decrypt(fwInstance, hSession, pEncryptedData, ulEncryptedDataLen, pData, pulDataLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_Decrypt +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pEncryptedData, + CK_ULONG ulEncryptedDataLen, + CK_BYTE_PTR pData, + CK_ULONG_PTR pulDataLen +) +{ + return __ADJOIN(MODULE_NAME,C_Decrypt)(hSession, pEncryptedData, ulEncryptedDataLen, pData, pulDataLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_DecryptUpdate) +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG ulEncryptedPartLen, + CK_BYTE_PTR pPart, + CK_ULONG_PTR pulPartLen +) +{ + return NSSCKFWC_DecryptUpdate(fwInstance, hSession, pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_DecryptUpdate +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG ulEncryptedPartLen, + CK_BYTE_PTR pPart, + CK_ULONG_PTR pulPartLen +) +{ + return __ADJOIN(MODULE_NAME,C_DecryptUpdate)(hSession, pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_DecryptFinal) +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pLastPart, + CK_ULONG_PTR pulLastPartLen +) +{ + return NSSCKFWC_DecryptFinal(fwInstance, hSession, pLastPart, pulLastPartLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_DecryptFinal +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pLastPart, + CK_ULONG_PTR pulLastPartLen +) +{ + return __ADJOIN(MODULE_NAME,C_DecryptFinal)(hSession, pLastPart, pulLastPartLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_DigestInit) +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism +) +{ + return NSSCKFWC_DigestInit(fwInstance, hSession, pMechanism); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_DigestInit +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism +) +{ + return __ADJOIN(MODULE_NAME,C_DigestInit)(hSession, pMechanism); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_Digest) +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pData, + CK_ULONG ulDataLen, + CK_BYTE_PTR pDigest, + CK_ULONG_PTR pulDigestLen +) +{ + return NSSCKFWC_Digest(fwInstance, hSession, pData, ulDataLen, pDigest, pulDigestLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_Digest +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pData, + CK_ULONG ulDataLen, + CK_BYTE_PTR pDigest, + CK_ULONG_PTR pulDigestLen +) +{ + return __ADJOIN(MODULE_NAME,C_Digest)(hSession, pData, ulDataLen, pDigest, pulDigestLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_DigestUpdate) +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen +) +{ + return NSSCKFWC_DigestUpdate(fwInstance, hSession, pPart, ulPartLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_DigestUpdate +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen +) +{ + return __ADJOIN(MODULE_NAME,C_DigestUpdate)(hSession, pPart, ulPartLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_DigestKey) +( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hKey +) +{ + return NSSCKFWC_DigestKey(fwInstance, hSession, hKey); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_DigestKey +( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hKey +) +{ + return __ADJOIN(MODULE_NAME,C_DigestKey)(hSession, hKey); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_DigestFinal) +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pDigest, + CK_ULONG_PTR pulDigestLen +) +{ + return NSSCKFWC_DigestFinal(fwInstance, hSession, pDigest, pulDigestLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_DigestFinal +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pDigest, + CK_ULONG_PTR pulDigestLen +) +{ + return __ADJOIN(MODULE_NAME,C_DigestFinal)(hSession, pDigest, pulDigestLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_SignInit) +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey +) +{ + return NSSCKFWC_SignInit(fwInstance, hSession, pMechanism, hKey); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_SignInit +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey +) +{ + return __ADJOIN(MODULE_NAME,C_SignInit)(hSession, pMechanism, hKey); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_Sign) +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pData, + CK_ULONG ulDataLen, + CK_BYTE_PTR pSignature, + CK_ULONG_PTR pulSignatureLen +) +{ + return NSSCKFWC_Sign(fwInstance, hSession, pData, ulDataLen, pSignature, pulSignatureLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_Sign +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pData, + CK_ULONG ulDataLen, + CK_BYTE_PTR pSignature, + CK_ULONG_PTR pulSignatureLen +) +{ + return __ADJOIN(MODULE_NAME,C_Sign)(hSession, pData, ulDataLen, pSignature, pulSignatureLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_SignUpdate) +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen +) +{ + return NSSCKFWC_SignUpdate(fwInstance, hSession, pPart, ulPartLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_SignUpdate +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen +) +{ + return __ADJOIN(MODULE_NAME,C_SignUpdate)(hSession, pPart, ulPartLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_SignFinal) +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pSignature, + CK_ULONG_PTR pulSignatureLen +) +{ + return NSSCKFWC_SignFinal(fwInstance, hSession, pSignature, pulSignatureLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_SignFinal +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pSignature, + CK_ULONG_PTR pulSignatureLen +) +{ + return __ADJOIN(MODULE_NAME,C_SignFinal)(hSession, pSignature, pulSignatureLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_SignRecoverInit) +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey +) +{ + return NSSCKFWC_SignRecoverInit(fwInstance, hSession, pMechanism, hKey); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_SignRecoverInit +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey +) +{ + return __ADJOIN(MODULE_NAME,C_SignRecoverInit)(hSession, pMechanism, hKey); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_SignRecover) +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pData, + CK_ULONG ulDataLen, + CK_BYTE_PTR pSignature, + CK_ULONG_PTR pulSignatureLen +) +{ + return NSSCKFWC_SignRecover(fwInstance, hSession, pData, ulDataLen, pSignature, pulSignatureLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_SignRecover +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pData, + CK_ULONG ulDataLen, + CK_BYTE_PTR pSignature, + CK_ULONG_PTR pulSignatureLen +) +{ + return __ADJOIN(MODULE_NAME,C_SignRecover)(hSession, pData, ulDataLen, pSignature, pulSignatureLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_VerifyInit) +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey +) +{ + return NSSCKFWC_VerifyInit(fwInstance, hSession, pMechanism, hKey); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_VerifyInit +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey +) +{ + return __ADJOIN(MODULE_NAME,C_VerifyInit)(hSession, pMechanism, hKey); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_Verify) +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pData, + CK_ULONG ulDataLen, + CK_BYTE_PTR pSignature, + CK_ULONG ulSignatureLen +) +{ + return NSSCKFWC_Verify(fwInstance, hSession, pData, ulDataLen, pSignature, ulSignatureLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_Verify +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pData, + CK_ULONG ulDataLen, + CK_BYTE_PTR pSignature, + CK_ULONG ulSignatureLen +) +{ + return __ADJOIN(MODULE_NAME,C_Verify)(hSession, pData, ulDataLen, pSignature, ulSignatureLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_VerifyUpdate) +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen +) +{ + return NSSCKFWC_VerifyUpdate(fwInstance, hSession, pPart, ulPartLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_VerifyUpdate +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen +) +{ + return __ADJOIN(MODULE_NAME,C_VerifyUpdate)(hSession, pPart, ulPartLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_VerifyFinal) +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pSignature, + CK_ULONG ulSignatureLen +) +{ + return NSSCKFWC_VerifyFinal(fwInstance, hSession, pSignature, ulSignatureLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_VerifyFinal +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pSignature, + CK_ULONG ulSignatureLen +) +{ + return __ADJOIN(MODULE_NAME,C_VerifyFinal)(hSession, pSignature, ulSignatureLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_VerifyRecoverInit) +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey +) +{ + return NSSCKFWC_VerifyRecoverInit(fwInstance, hSession, pMechanism, hKey); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_VerifyRecoverInit +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey +) +{ + return __ADJOIN(MODULE_NAME,C_VerifyRecoverInit)(hSession, pMechanism, hKey); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_VerifyRecover) +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pSignature, + CK_ULONG ulSignatureLen, + CK_BYTE_PTR pData, + CK_ULONG_PTR pulDataLen +) +{ + return NSSCKFWC_VerifyRecover(fwInstance, hSession, pSignature, ulSignatureLen, pData, pulDataLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_VerifyRecover +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pSignature, + CK_ULONG ulSignatureLen, + CK_BYTE_PTR pData, + CK_ULONG_PTR pulDataLen +) +{ + return __ADJOIN(MODULE_NAME,C_VerifyRecover)(hSession, pSignature, ulSignatureLen, pData, pulDataLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_DigestEncryptUpdate) +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG_PTR pulEncryptedPartLen +) +{ + return NSSCKFWC_DigestEncryptUpdate(fwInstance, hSession, pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_DigestEncryptUpdate +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG_PTR pulEncryptedPartLen +) +{ + return __ADJOIN(MODULE_NAME,C_DigestEncryptUpdate)(hSession, pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_DecryptDigestUpdate) +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG ulEncryptedPartLen, + CK_BYTE_PTR pPart, + CK_ULONG_PTR pulPartLen +) +{ + return NSSCKFWC_DecryptDigestUpdate(fwInstance, hSession, pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_DecryptDigestUpdate +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG ulEncryptedPartLen, + CK_BYTE_PTR pPart, + CK_ULONG_PTR pulPartLen +) +{ + return __ADJOIN(MODULE_NAME,C_DecryptDigestUpdate)(hSession, pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_SignEncryptUpdate) +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG_PTR pulEncryptedPartLen +) +{ + return NSSCKFWC_SignEncryptUpdate(fwInstance, hSession, pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_SignEncryptUpdate +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG_PTR pulEncryptedPartLen +) +{ + return __ADJOIN(MODULE_NAME,C_SignEncryptUpdate)(hSession, pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_DecryptVerifyUpdate) +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG ulEncryptedPartLen, + CK_BYTE_PTR pPart, + CK_ULONG_PTR pulPartLen +) +{ + return NSSCKFWC_DecryptVerifyUpdate(fwInstance, hSession, pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_DecryptVerifyUpdate +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG ulEncryptedPartLen, + CK_BYTE_PTR pPart, + CK_ULONG_PTR pulPartLen +) +{ + return __ADJOIN(MODULE_NAME,C_DecryptVerifyUpdate)(hSession, pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_GenerateKey) +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount, + CK_OBJECT_HANDLE_PTR phKey +) +{ + return NSSCKFWC_GenerateKey(fwInstance, hSession, pMechanism, pTemplate, ulCount, phKey); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_GenerateKey +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount, + CK_OBJECT_HANDLE_PTR phKey +) +{ + return __ADJOIN(MODULE_NAME,C_GenerateKey)(hSession, pMechanism, pTemplate, ulCount, phKey); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_GenerateKeyPair) +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_ATTRIBUTE_PTR pPublicKeyTemplate, + CK_ULONG ulPublicKeyAttributeCount, + CK_ATTRIBUTE_PTR pPrivateKeyTemplate, + CK_ULONG ulPrivateKeyAttributeCount, + CK_OBJECT_HANDLE_PTR phPublicKey, + CK_OBJECT_HANDLE_PTR phPrivateKey +) +{ + return NSSCKFWC_GenerateKeyPair(fwInstance, hSession, pMechanism, pPublicKeyTemplate, ulPublicKeyAttributeCount, pPrivateKeyTemplate, ulPrivateKeyAttributeCount, phPublicKey, phPrivateKey); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_GenerateKeyPair +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_ATTRIBUTE_PTR pPublicKeyTemplate, + CK_ULONG ulPublicKeyAttributeCount, + CK_ATTRIBUTE_PTR pPrivateKeyTemplate, + CK_ULONG ulPrivateKeyAttributeCount, + CK_OBJECT_HANDLE_PTR phPublicKey, + CK_OBJECT_HANDLE_PTR phPrivateKey +) +{ + return __ADJOIN(MODULE_NAME,C_GenerateKeyPair)(hSession, pMechanism, pPublicKeyTemplate, ulPublicKeyAttributeCount, pPrivateKeyTemplate, ulPrivateKeyAttributeCount, phPublicKey, phPrivateKey); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_WrapKey) +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hWrappingKey, + CK_OBJECT_HANDLE hKey, + CK_BYTE_PTR pWrappedKey, + CK_ULONG_PTR pulWrappedKeyLen +) +{ + return NSSCKFWC_WrapKey(fwInstance, hSession, pMechanism, hWrappingKey, hKey, pWrappedKey, pulWrappedKeyLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_WrapKey +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hWrappingKey, + CK_OBJECT_HANDLE hKey, + CK_BYTE_PTR pWrappedKey, + CK_ULONG_PTR pulWrappedKeyLen +) +{ + return __ADJOIN(MODULE_NAME,C_WrapKey)(hSession, pMechanism, hWrappingKey, hKey, pWrappedKey, pulWrappedKeyLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_UnwrapKey) +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hUnwrappingKey, + CK_BYTE_PTR pWrappedKey, + CK_ULONG ulWrappedKeyLen, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulAttributeCount, + CK_OBJECT_HANDLE_PTR phKey +) +{ + return NSSCKFWC_UnwrapKey(fwInstance, hSession, pMechanism, hUnwrappingKey, pWrappedKey, ulWrappedKeyLen, pTemplate, ulAttributeCount, phKey); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_UnwrapKey +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hUnwrappingKey, + CK_BYTE_PTR pWrappedKey, + CK_ULONG ulWrappedKeyLen, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulAttributeCount, + CK_OBJECT_HANDLE_PTR phKey +) +{ + return __ADJOIN(MODULE_NAME,C_UnwrapKey)(hSession, pMechanism, hUnwrappingKey, pWrappedKey, ulWrappedKeyLen, pTemplate, ulAttributeCount, phKey); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_DeriveKey) +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hBaseKey, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulAttributeCount, + CK_OBJECT_HANDLE_PTR phKey +) +{ + return NSSCKFWC_DeriveKey(fwInstance, hSession, pMechanism, hBaseKey, pTemplate, ulAttributeCount, phKey); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_DeriveKey +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hBaseKey, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulAttributeCount, + CK_OBJECT_HANDLE_PTR phKey +) +{ + return __ADJOIN(MODULE_NAME,C_DeriveKey)(hSession, pMechanism, hBaseKey, pTemplate, ulAttributeCount, phKey); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_SeedRandom) +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pSeed, + CK_ULONG ulSeedLen +) +{ + return NSSCKFWC_SeedRandom(fwInstance, hSession, pSeed, ulSeedLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_SeedRandom +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pSeed, + CK_ULONG ulSeedLen +) +{ + return __ADJOIN(MODULE_NAME,C_SeedRandom)(hSession, pSeed, ulSeedLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_GenerateRandom) +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR RandomData, + CK_ULONG ulRandomLen +) +{ + return NSSCKFWC_GenerateRandom(fwInstance, hSession, RandomData, ulRandomLen); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_GenerateRandom +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR RandomData, + CK_ULONG ulRandomLen +) +{ + return __ADJOIN(MODULE_NAME,C_GenerateRandom)(hSession, RandomData, ulRandomLen); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_GetFunctionStatus) +( + CK_SESSION_HANDLE hSession +) +{ + return NSSCKFWC_GetFunctionStatus(fwInstance, hSession); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_GetFunctionStatus +( + CK_SESSION_HANDLE hSession +) +{ + return __ADJOIN(MODULE_NAME,C_GetFunctionStatus)(hSession); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_CancelFunction) +( + CK_SESSION_HANDLE hSession +) +{ + return NSSCKFWC_CancelFunction(fwInstance, hSession); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_CancelFunction +( + CK_SESSION_HANDLE hSession +) +{ + return __ADJOIN(MODULE_NAME,C_CancelFunction)(hSession); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_WaitForSlotEvent) +( + CK_FLAGS flags, + CK_SLOT_ID_PTR pSlot, + CK_VOID_PTR pRserved +) +{ + return NSSCKFWC_WaitForSlotEvent(fwInstance, flags, pSlot, pRserved); +} + +#ifdef DECLARE_STRICT_CRYPTOKI_NAMES +CK_RV CK_ENTRY +C_WaitForSlotEvent +( + CK_FLAGS flags, + CK_SLOT_ID_PTR pSlot, + CK_VOID_PTR pRserved +) +{ + return __ADJOIN(MODULE_NAME,C_WaitForSlotEvent)(flags, pSlot, pRserved); +} +#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_GetFunctionList) +( + CK_FUNCTION_LIST_PTR_PTR ppFunctionList +); + +static CK_FUNCTION_LIST FunctionList = { + { 2, 1 }, +__ADJOIN(MODULE_NAME,C_Initialize), +__ADJOIN(MODULE_NAME,C_Finalize), +__ADJOIN(MODULE_NAME,C_GetInfo), +__ADJOIN(MODULE_NAME,C_GetFunctionList), +__ADJOIN(MODULE_NAME,C_GetSlotList), +__ADJOIN(MODULE_NAME,C_GetSlotInfo), +__ADJOIN(MODULE_NAME,C_GetTokenInfo), +__ADJOIN(MODULE_NAME,C_GetMechanismList), +__ADJOIN(MODULE_NAME,C_GetMechanismInfo), +__ADJOIN(MODULE_NAME,C_InitToken), +__ADJOIN(MODULE_NAME,C_InitPIN), +__ADJOIN(MODULE_NAME,C_SetPIN), +__ADJOIN(MODULE_NAME,C_OpenSession), +__ADJOIN(MODULE_NAME,C_CloseSession), +__ADJOIN(MODULE_NAME,C_CloseAllSessions), +__ADJOIN(MODULE_NAME,C_GetSessionInfo), +__ADJOIN(MODULE_NAME,C_GetOperationState), +__ADJOIN(MODULE_NAME,C_SetOperationState), +__ADJOIN(MODULE_NAME,C_Login), +__ADJOIN(MODULE_NAME,C_Logout), +__ADJOIN(MODULE_NAME,C_CreateObject), +__ADJOIN(MODULE_NAME,C_CopyObject), +__ADJOIN(MODULE_NAME,C_DestroyObject), +__ADJOIN(MODULE_NAME,C_GetObjectSize), +__ADJOIN(MODULE_NAME,C_GetAttributeValue), +__ADJOIN(MODULE_NAME,C_SetAttributeValue), +__ADJOIN(MODULE_NAME,C_FindObjectsInit), +__ADJOIN(MODULE_NAME,C_FindObjects), +__ADJOIN(MODULE_NAME,C_FindObjectsFinal), +__ADJOIN(MODULE_NAME,C_EncryptInit), +__ADJOIN(MODULE_NAME,C_Encrypt), +__ADJOIN(MODULE_NAME,C_EncryptUpdate), +__ADJOIN(MODULE_NAME,C_EncryptFinal), +__ADJOIN(MODULE_NAME,C_DecryptInit), +__ADJOIN(MODULE_NAME,C_Decrypt), +__ADJOIN(MODULE_NAME,C_DecryptUpdate), +__ADJOIN(MODULE_NAME,C_DecryptFinal), +__ADJOIN(MODULE_NAME,C_DigestInit), +__ADJOIN(MODULE_NAME,C_Digest), +__ADJOIN(MODULE_NAME,C_DigestUpdate), +__ADJOIN(MODULE_NAME,C_DigestKey), +__ADJOIN(MODULE_NAME,C_DigestFinal), +__ADJOIN(MODULE_NAME,C_SignInit), +__ADJOIN(MODULE_NAME,C_Sign), +__ADJOIN(MODULE_NAME,C_SignUpdate), +__ADJOIN(MODULE_NAME,C_SignFinal), +__ADJOIN(MODULE_NAME,C_SignRecoverInit), +__ADJOIN(MODULE_NAME,C_SignRecover), +__ADJOIN(MODULE_NAME,C_VerifyInit), +__ADJOIN(MODULE_NAME,C_Verify), +__ADJOIN(MODULE_NAME,C_VerifyUpdate), +__ADJOIN(MODULE_NAME,C_VerifyFinal), +__ADJOIN(MODULE_NAME,C_VerifyRecoverInit), +__ADJOIN(MODULE_NAME,C_VerifyRecover), +__ADJOIN(MODULE_NAME,C_DigestEncryptUpdate), +__ADJOIN(MODULE_NAME,C_DecryptDigestUpdate), +__ADJOIN(MODULE_NAME,C_SignEncryptUpdate), +__ADJOIN(MODULE_NAME,C_DecryptVerifyUpdate), +__ADJOIN(MODULE_NAME,C_GenerateKey), +__ADJOIN(MODULE_NAME,C_GenerateKeyPair), +__ADJOIN(MODULE_NAME,C_WrapKey), +__ADJOIN(MODULE_NAME,C_UnwrapKey), +__ADJOIN(MODULE_NAME,C_DeriveKey), +__ADJOIN(MODULE_NAME,C_SeedRandom), +__ADJOIN(MODULE_NAME,C_GenerateRandom), +__ADJOIN(MODULE_NAME,C_GetFunctionStatus), +__ADJOIN(MODULE_NAME,C_CancelFunction), +__ADJOIN(MODULE_NAME,C_WaitForSlotEvent) +}; + +CK_RV CK_ENTRY +__ADJOIN(MODULE_NAME,C_GetFunctionList) +( + CK_FUNCTION_LIST_PTR_PTR ppFunctionList +) +{ + *ppFunctionList = &FunctionList; + return CKR_OK; +} + +/* This one is always present */ +CK_RV CK_ENTRY +C_GetFunctionList +( + CK_FUNCTION_LIST_PTR_PTR ppFunctionList +) +{ + return __ADJOIN(MODULE_NAME,C_GetFunctionList)(ppFunctionList); +} + +#undef __ADJOIN + diff --git a/security/nss/lib/ckfw/nssckepv.h b/security/nss/lib/ckfw/nssckepv.h new file mode 100644 index 00000000000..f53f1012edc --- /dev/null +++ b/security/nss/lib/ckfw/nssckepv.h @@ -0,0 +1,128 @@ +/* THIS IS A GENERATED FILE */ +/* + * 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 Netscape are + * Copyright (C) 1994-2000 Netscape Communications Corporation. All + * Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License Version 2 or later (the + * "GPL"), in which case the provisions of the GPL are applicable + * instead of those above. If you wish to allow use of your + * version of this file only under the terms of the GPL and not to + * allow others to use your version of this file under the MPL, + * indicate your decision by deleting the provisions above and + * replace them with the notice and other provisions required by + * the GPL. If you do not delete the provisions above, a recipient + * may use your version of this file under either the MPL or the + * GPL. + */ +#ifndef NSSCKEPV_H +#define NSSCKEPV_H + +#ifdef DEBUG +static const char NSSCKEPV_CVS_ID[] = "@(#) $RCSfile: nssckepv.h,v $ $Revision: 1.1 $ $Date: 2000-09-22 22:52:18 $ $Name: $ ; @(#) $RCSfile: nssckepv.h,v $ $Revision: 1.1 $ $Date: 2000-09-22 22:52:18 $ $Name: $"; +#endif /* DEBUG */ + +/* + * nssckepv.h + * + * This automatically-generated header file defines the type + * CK_FUNCTION_LIST specified by PKCS#11. + */ + +#ifndef NSSCKT_H +#include "nssckt.h" +#endif /* NSSCKT_H */ + +#ifndef NSSCKFT_H +#include "nssckft.h" +#endif /* NSSCKFT_H */ + +struct CK_FUNCTION_LIST { + CK_VERSION version; + CK_C_Initialize C_Initialize; + CK_C_Finalize C_Finalize; + CK_C_GetInfo C_GetInfo; + CK_C_GetFunctionList C_GetFunctionList; + CK_C_GetSlotList C_GetSlotList; + CK_C_GetSlotInfo C_GetSlotInfo; + CK_C_GetTokenInfo C_GetTokenInfo; + CK_C_GetMechanismList C_GetMechanismList; + CK_C_GetMechanismInfo C_GetMechanismInfo; + CK_C_InitToken C_InitToken; + CK_C_InitPIN C_InitPIN; + CK_C_SetPIN C_SetPIN; + CK_C_OpenSession C_OpenSession; + CK_C_CloseSession C_CloseSession; + CK_C_CloseAllSessions C_CloseAllSessions; + CK_C_GetSessionInfo C_GetSessionInfo; + CK_C_GetOperationState C_GetOperationState; + CK_C_SetOperationState C_SetOperationState; + CK_C_Login C_Login; + CK_C_Logout C_Logout; + CK_C_CreateObject C_CreateObject; + CK_C_CopyObject C_CopyObject; + CK_C_DestroyObject C_DestroyObject; + CK_C_GetObjectSize C_GetObjectSize; + CK_C_GetAttributeValue C_GetAttributeValue; + CK_C_SetAttributeValue C_SetAttributeValue; + CK_C_FindObjectsInit C_FindObjectsInit; + CK_C_FindObjects C_FindObjects; + CK_C_FindObjectsFinal C_FindObjectsFinal; + CK_C_EncryptInit C_EncryptInit; + CK_C_Encrypt C_Encrypt; + CK_C_EncryptUpdate C_EncryptUpdate; + CK_C_EncryptFinal C_EncryptFinal; + CK_C_DecryptInit C_DecryptInit; + CK_C_Decrypt C_Decrypt; + CK_C_DecryptUpdate C_DecryptUpdate; + CK_C_DecryptFinal C_DecryptFinal; + CK_C_DigestInit C_DigestInit; + CK_C_Digest C_Digest; + CK_C_DigestUpdate C_DigestUpdate; + CK_C_DigestKey C_DigestKey; + CK_C_DigestFinal C_DigestFinal; + CK_C_SignInit C_SignInit; + CK_C_Sign C_Sign; + CK_C_SignUpdate C_SignUpdate; + CK_C_SignFinal C_SignFinal; + CK_C_SignRecoverInit C_SignRecoverInit; + CK_C_SignRecover C_SignRecover; + CK_C_VerifyInit C_VerifyInit; + CK_C_Verify C_Verify; + CK_C_VerifyUpdate C_VerifyUpdate; + CK_C_VerifyFinal C_VerifyFinal; + CK_C_VerifyRecoverInit C_VerifyRecoverInit; + CK_C_VerifyRecover C_VerifyRecover; + CK_C_DigestEncryptUpdate C_DigestEncryptUpdate; + CK_C_DecryptDigestUpdate C_DecryptDigestUpdate; + CK_C_SignEncryptUpdate C_SignEncryptUpdate; + CK_C_DecryptVerifyUpdate C_DecryptVerifyUpdate; + CK_C_GenerateKey C_GenerateKey; + CK_C_GenerateKeyPair C_GenerateKeyPair; + CK_C_WrapKey C_WrapKey; + CK_C_UnwrapKey C_UnwrapKey; + CK_C_DeriveKey C_DeriveKey; + CK_C_SeedRandom C_SeedRandom; + CK_C_GenerateRandom C_GenerateRandom; + CK_C_GetFunctionStatus C_GetFunctionStatus; + CK_C_CancelFunction C_CancelFunction; + CK_C_WaitForSlotEvent C_WaitForSlotEvent; +}; + +#endif /* NSSCKEPV_H */ diff --git a/security/nss/lib/ckfw/nssckft.h b/security/nss/lib/ckfw/nssckft.h new file mode 100644 index 00000000000..2a3458ecb91 --- /dev/null +++ b/security/nss/lib/ckfw/nssckft.h @@ -0,0 +1,492 @@ +/* THIS IS A GENERATED FILE */ +/* + * 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 Netscape are + * Copyright (C) 1994-2000 Netscape Communications Corporation. All + * Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License Version 2 or later (the + * "GPL"), in which case the provisions of the GPL are applicable + * instead of those above. If you wish to allow use of your + * version of this file only under the terms of the GPL and not to + * allow others to use your version of this file under the MPL, + * indicate your decision by deleting the provisions above and + * replace them with the notice and other provisions required by + * the GPL. If you do not delete the provisions above, a recipient + * may use your version of this file under either the MPL or the + * GPL. + */ +#ifndef NSSCKFT_H +#define NSSCKFT_H + +#ifdef DEBUG +static const char NSSCKFT_CVS_ID[] = "@(#) $RCSfile: nssckft.h,v $ $Revision: 1.1 $ $Date: 2000-09-22 22:52:19 $ $Name: $ ; @(#) $RCSfile: nssckft.h,v $ $Revision: 1.1 $ $Date: 2000-09-22 22:52:19 $ $Name: $"; +#endif /* DEBUG */ + +/* + * nssckft.h + * + * The automatically-generated header file declares a typedef + * each of the Cryptoki functions specified by PKCS#11. + */ + +#ifndef NSSCKT_H +#include "nssckt.h" +#endif /* NSSCKT_H */ + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_Initialize)( + CK_VOID_PTR pInitArgs +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_Finalize)( + CK_VOID_PTR pReserved +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_GetInfo)( + CK_INFO_PTR pInfo +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_GetFunctionList)( + CK_FUNCTION_LIST_PTR_PTR ppFunctionList +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_GetSlotList)( + CK_BBOOL tokenPresent, + CK_SLOT_ID_PTR pSlotList, + CK_ULONG_PTR pulCount +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_GetSlotInfo)( + CK_SLOT_ID slotID, + CK_SLOT_INFO_PTR pInfo +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_GetTokenInfo)( + CK_SLOT_ID slotID, + CK_TOKEN_INFO_PTR pInfo +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_GetMechanismList)( + CK_SLOT_ID slotID, + CK_MECHANISM_TYPE_PTR pMechanismList, + CK_ULONG_PTR pulCount +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_GetMechanismInfo)( + CK_SLOT_ID slotID, + CK_MECHANISM_TYPE type, + CK_MECHANISM_INFO_PTR pInfo +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_InitToken)( + CK_SLOT_ID slotID, + CK_CHAR_PTR pPin, + CK_ULONG ulPinLen, + CK_CHAR_PTR pLabel +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_InitPIN)( + CK_SESSION_HANDLE hSession, + CK_CHAR_PTR pPin, + CK_ULONG ulPinLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_SetPIN)( + CK_SESSION_HANDLE hSession, + CK_CHAR_PTR pOldPin, + CK_ULONG ulOldLen, + CK_CHAR_PTR pNewPin, + CK_ULONG ulNewLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_OpenSession)( + CK_SLOT_ID slotID, + CK_FLAGS flags, + CK_VOID_PTR pApplication, + CK_NOTIFY Notify, + CK_SESSION_HANDLE_PTR phSession +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_CloseSession)( + CK_SESSION_HANDLE hSession +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_CloseAllSessions)( + CK_SLOT_ID slotID +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_GetSessionInfo)( + CK_SESSION_HANDLE hSession, + CK_SESSION_INFO_PTR pInfo +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_GetOperationState)( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pOperationState, + CK_ULONG_PTR pulOperationStateLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_SetOperationState)( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pOperationState, + CK_ULONG ulOperationStateLen, + CK_OBJECT_HANDLE hEncryptionKey, + CK_OBJECT_HANDLE hAuthenticationKey +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_Login)( + CK_SESSION_HANDLE hSession, + CK_USER_TYPE userType, + CK_CHAR_PTR pPin, + CK_ULONG ulPinLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_Logout)( + CK_SESSION_HANDLE hSession +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_CreateObject)( + CK_SESSION_HANDLE hSession, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount, + CK_OBJECT_HANDLE_PTR phObject +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_CopyObject)( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hObject, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount, + CK_OBJECT_HANDLE_PTR phNewObject +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_DestroyObject)( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hObject +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_GetObjectSize)( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hObject, + CK_ULONG_PTR pulSize +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_GetAttributeValue)( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hObject, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_SetAttributeValue)( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hObject, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_FindObjectsInit)( + CK_SESSION_HANDLE hSession, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_FindObjects)( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE_PTR phObject, + CK_ULONG ulMaxObjectCount, + CK_ULONG_PTR pulObjectCount +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_FindObjectsFinal)( + CK_SESSION_HANDLE hSession +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_EncryptInit)( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_Encrypt)( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pData, + CK_ULONG ulDataLen, + CK_BYTE_PTR pEncryptedData, + CK_ULONG_PTR pulEncryptedDataLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_EncryptUpdate)( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG_PTR pulEncryptedPartLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_EncryptFinal)( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pLastEncryptedPart, + CK_ULONG_PTR pulLastEncryptedPartLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_DecryptInit)( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_Decrypt)( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pEncryptedData, + CK_ULONG ulEncryptedDataLen, + CK_BYTE_PTR pData, + CK_ULONG_PTR pulDataLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_DecryptUpdate)( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG ulEncryptedPartLen, + CK_BYTE_PTR pPart, + CK_ULONG_PTR pulPartLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_DecryptFinal)( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pLastPart, + CK_ULONG_PTR pulLastPartLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_DigestInit)( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_Digest)( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pData, + CK_ULONG ulDataLen, + CK_BYTE_PTR pDigest, + CK_ULONG_PTR pulDigestLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_DigestUpdate)( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_DigestKey)( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hKey +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_DigestFinal)( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pDigest, + CK_ULONG_PTR pulDigestLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_SignInit)( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_Sign)( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pData, + CK_ULONG ulDataLen, + CK_BYTE_PTR pSignature, + CK_ULONG_PTR pulSignatureLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_SignUpdate)( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_SignFinal)( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pSignature, + CK_ULONG_PTR pulSignatureLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_SignRecoverInit)( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_SignRecover)( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pData, + CK_ULONG ulDataLen, + CK_BYTE_PTR pSignature, + CK_ULONG_PTR pulSignatureLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_VerifyInit)( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_Verify)( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pData, + CK_ULONG ulDataLen, + CK_BYTE_PTR pSignature, + CK_ULONG ulSignatureLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_VerifyUpdate)( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_VerifyFinal)( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pSignature, + CK_ULONG ulSignatureLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_VerifyRecoverInit)( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_VerifyRecover)( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pSignature, + CK_ULONG ulSignatureLen, + CK_BYTE_PTR pData, + CK_ULONG_PTR pulDataLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_DigestEncryptUpdate)( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG_PTR pulEncryptedPartLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_DecryptDigestUpdate)( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG ulEncryptedPartLen, + CK_BYTE_PTR pPart, + CK_ULONG_PTR pulPartLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_SignEncryptUpdate)( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG_PTR pulEncryptedPartLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_DecryptVerifyUpdate)( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG ulEncryptedPartLen, + CK_BYTE_PTR pPart, + CK_ULONG_PTR pulPartLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_GenerateKey)( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount, + CK_OBJECT_HANDLE_PTR phKey +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_GenerateKeyPair)( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_ATTRIBUTE_PTR pPublicKeyTemplate, + CK_ULONG ulPublicKeyAttributeCount, + CK_ATTRIBUTE_PTR pPrivateKeyTemplate, + CK_ULONG ulPrivateKeyAttributeCount, + CK_OBJECT_HANDLE_PTR phPublicKey, + CK_OBJECT_HANDLE_PTR phPrivateKey +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_WrapKey)( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hWrappingKey, + CK_OBJECT_HANDLE hKey, + CK_BYTE_PTR pWrappedKey, + CK_ULONG_PTR pulWrappedKeyLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_UnwrapKey)( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hUnwrappingKey, + CK_BYTE_PTR pWrappedKey, + CK_ULONG ulWrappedKeyLen, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulAttributeCount, + CK_OBJECT_HANDLE_PTR phKey +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_DeriveKey)( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hBaseKey, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulAttributeCount, + CK_OBJECT_HANDLE_PTR phKey +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_SeedRandom)( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pSeed, + CK_ULONG ulSeedLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_GenerateRandom)( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR RandomData, + CK_ULONG ulRandomLen +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_GetFunctionStatus)( + CK_SESSION_HANDLE hSession +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_CancelFunction)( + CK_SESSION_HANDLE hSession +); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_C_WaitForSlotEvent)( + CK_FLAGS flags, + CK_SLOT_ID_PTR pSlot, + CK_VOID_PTR pRserved +); + +#endif /* NSSCKFT_H */ diff --git a/security/nss/lib/ckfw/nssckg.h b/security/nss/lib/ckfw/nssckg.h new file mode 100644 index 00000000000..da3f3518bad --- /dev/null +++ b/security/nss/lib/ckfw/nssckg.h @@ -0,0 +1,560 @@ +/* THIS IS A GENERATED FILE */ +/* + * 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 Netscape are + * Copyright (C) 1994-2000 Netscape Communications Corporation. All + * Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License Version 2 or later (the + * "GPL"), in which case the provisions of the GPL are applicable + * instead of those above. If you wish to allow use of your + * version of this file only under the terms of the GPL and not to + * allow others to use your version of this file under the MPL, + * indicate your decision by deleting the provisions above and + * replace them with the notice and other provisions required by + * the GPL. If you do not delete the provisions above, a recipient + * may use your version of this file under either the MPL or the + * GPL. + */ +#ifndef NSSCKG_H +#define NSSCKG_H + +#ifdef DEBUG +static const char NSSCKG_CVS_ID[] = "@(#) $RCSfile: nssckg.h,v $ $Revision: 1.1 $ $Date: 2000-09-22 22:52:20 $ $Name: $ ; @(#) $RCSfile: nssckg.h,v $ $Revision: 1.1 $ $Date: 2000-09-22 22:52:20 $ $Name: $"; +#endif /* DEBUG */ + +/* + * nssckg.h + * + * This automatically-generated header file prototypes the Cryptoki + * functions specified by PKCS#11. + */ + +#ifndef NSSCKT_H +#include "nssckt.h" +#endif /* NSSCKT_H */ + +CK_RV CK_ENTRY C_Initialize +( + CK_VOID_PTR pInitArgs +); + +CK_RV CK_ENTRY C_Finalize +( + CK_VOID_PTR pReserved +); + +CK_RV CK_ENTRY C_GetInfo +( + CK_INFO_PTR pInfo +); + +CK_RV CK_ENTRY C_GetFunctionList +( + CK_FUNCTION_LIST_PTR_PTR ppFunctionList +); + +CK_RV CK_ENTRY C_GetSlotList +( + CK_BBOOL tokenPresent, + CK_SLOT_ID_PTR pSlotList, + CK_ULONG_PTR pulCount +); + +CK_RV CK_ENTRY C_GetSlotInfo +( + CK_SLOT_ID slotID, + CK_SLOT_INFO_PTR pInfo +); + +CK_RV CK_ENTRY C_GetTokenInfo +( + CK_SLOT_ID slotID, + CK_TOKEN_INFO_PTR pInfo +); + +CK_RV CK_ENTRY C_GetMechanismList +( + CK_SLOT_ID slotID, + CK_MECHANISM_TYPE_PTR pMechanismList, + CK_ULONG_PTR pulCount +); + +CK_RV CK_ENTRY C_GetMechanismInfo +( + CK_SLOT_ID slotID, + CK_MECHANISM_TYPE type, + CK_MECHANISM_INFO_PTR pInfo +); + +CK_RV CK_ENTRY C_InitToken +( + CK_SLOT_ID slotID, + CK_CHAR_PTR pPin, + CK_ULONG ulPinLen, + CK_CHAR_PTR pLabel +); + +CK_RV CK_ENTRY C_InitPIN +( + CK_SESSION_HANDLE hSession, + CK_CHAR_PTR pPin, + CK_ULONG ulPinLen +); + +CK_RV CK_ENTRY C_SetPIN +( + CK_SESSION_HANDLE hSession, + CK_CHAR_PTR pOldPin, + CK_ULONG ulOldLen, + CK_CHAR_PTR pNewPin, + CK_ULONG ulNewLen +); + +CK_RV CK_ENTRY C_OpenSession +( + CK_SLOT_ID slotID, + CK_FLAGS flags, + CK_VOID_PTR pApplication, + CK_NOTIFY Notify, + CK_SESSION_HANDLE_PTR phSession +); + +CK_RV CK_ENTRY C_CloseSession +( + CK_SESSION_HANDLE hSession +); + +CK_RV CK_ENTRY C_CloseAllSessions +( + CK_SLOT_ID slotID +); + +CK_RV CK_ENTRY C_GetSessionInfo +( + CK_SESSION_HANDLE hSession, + CK_SESSION_INFO_PTR pInfo +); + +CK_RV CK_ENTRY C_GetOperationState +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pOperationState, + CK_ULONG_PTR pulOperationStateLen +); + +CK_RV CK_ENTRY C_SetOperationState +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pOperationState, + CK_ULONG ulOperationStateLen, + CK_OBJECT_HANDLE hEncryptionKey, + CK_OBJECT_HANDLE hAuthenticationKey +); + +CK_RV CK_ENTRY C_Login +( + CK_SESSION_HANDLE hSession, + CK_USER_TYPE userType, + CK_CHAR_PTR pPin, + CK_ULONG ulPinLen +); + +CK_RV CK_ENTRY C_Logout +( + CK_SESSION_HANDLE hSession +); + +CK_RV CK_ENTRY C_CreateObject +( + CK_SESSION_HANDLE hSession, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount, + CK_OBJECT_HANDLE_PTR phObject +); + +CK_RV CK_ENTRY C_CopyObject +( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hObject, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount, + CK_OBJECT_HANDLE_PTR phNewObject +); + +CK_RV CK_ENTRY C_DestroyObject +( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hObject +); + +CK_RV CK_ENTRY C_GetObjectSize +( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hObject, + CK_ULONG_PTR pulSize +); + +CK_RV CK_ENTRY C_GetAttributeValue +( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hObject, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount +); + +CK_RV CK_ENTRY C_SetAttributeValue +( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hObject, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount +); + +CK_RV CK_ENTRY C_FindObjectsInit +( + CK_SESSION_HANDLE hSession, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount +); + +CK_RV CK_ENTRY C_FindObjects +( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE_PTR phObject, + CK_ULONG ulMaxObjectCount, + CK_ULONG_PTR pulObjectCount +); + +CK_RV CK_ENTRY C_FindObjectsFinal +( + CK_SESSION_HANDLE hSession +); + +CK_RV CK_ENTRY C_EncryptInit +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey +); + +CK_RV CK_ENTRY C_Encrypt +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pData, + CK_ULONG ulDataLen, + CK_BYTE_PTR pEncryptedData, + CK_ULONG_PTR pulEncryptedDataLen +); + +CK_RV CK_ENTRY C_EncryptUpdate +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG_PTR pulEncryptedPartLen +); + +CK_RV CK_ENTRY C_EncryptFinal +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pLastEncryptedPart, + CK_ULONG_PTR pulLastEncryptedPartLen +); + +CK_RV CK_ENTRY C_DecryptInit +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey +); + +CK_RV CK_ENTRY C_Decrypt +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pEncryptedData, + CK_ULONG ulEncryptedDataLen, + CK_BYTE_PTR pData, + CK_ULONG_PTR pulDataLen +); + +CK_RV CK_ENTRY C_DecryptUpdate +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG ulEncryptedPartLen, + CK_BYTE_PTR pPart, + CK_ULONG_PTR pulPartLen +); + +CK_RV CK_ENTRY C_DecryptFinal +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pLastPart, + CK_ULONG_PTR pulLastPartLen +); + +CK_RV CK_ENTRY C_DigestInit +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism +); + +CK_RV CK_ENTRY C_Digest +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pData, + CK_ULONG ulDataLen, + CK_BYTE_PTR pDigest, + CK_ULONG_PTR pulDigestLen +); + +CK_RV CK_ENTRY C_DigestUpdate +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen +); + +CK_RV CK_ENTRY C_DigestKey +( + CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hKey +); + +CK_RV CK_ENTRY C_DigestFinal +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pDigest, + CK_ULONG_PTR pulDigestLen +); + +CK_RV CK_ENTRY C_SignInit +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey +); + +CK_RV CK_ENTRY C_Sign +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pData, + CK_ULONG ulDataLen, + CK_BYTE_PTR pSignature, + CK_ULONG_PTR pulSignatureLen +); + +CK_RV CK_ENTRY C_SignUpdate +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen +); + +CK_RV CK_ENTRY C_SignFinal +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pSignature, + CK_ULONG_PTR pulSignatureLen +); + +CK_RV CK_ENTRY C_SignRecoverInit +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey +); + +CK_RV CK_ENTRY C_SignRecover +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pData, + CK_ULONG ulDataLen, + CK_BYTE_PTR pSignature, + CK_ULONG_PTR pulSignatureLen +); + +CK_RV CK_ENTRY C_VerifyInit +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey +); + +CK_RV CK_ENTRY C_Verify +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pData, + CK_ULONG ulDataLen, + CK_BYTE_PTR pSignature, + CK_ULONG ulSignatureLen +); + +CK_RV CK_ENTRY C_VerifyUpdate +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen +); + +CK_RV CK_ENTRY C_VerifyFinal +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pSignature, + CK_ULONG ulSignatureLen +); + +CK_RV CK_ENTRY C_VerifyRecoverInit +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey +); + +CK_RV CK_ENTRY C_VerifyRecover +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pSignature, + CK_ULONG ulSignatureLen, + CK_BYTE_PTR pData, + CK_ULONG_PTR pulDataLen +); + +CK_RV CK_ENTRY C_DigestEncryptUpdate +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG_PTR pulEncryptedPartLen +); + +CK_RV CK_ENTRY C_DecryptDigestUpdate +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG ulEncryptedPartLen, + CK_BYTE_PTR pPart, + CK_ULONG_PTR pulPartLen +); + +CK_RV CK_ENTRY C_SignEncryptUpdate +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG_PTR pulEncryptedPartLen +); + +CK_RV CK_ENTRY C_DecryptVerifyUpdate +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG ulEncryptedPartLen, + CK_BYTE_PTR pPart, + CK_ULONG_PTR pulPartLen +); + +CK_RV CK_ENTRY C_GenerateKey +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount, + CK_OBJECT_HANDLE_PTR phKey +); + +CK_RV CK_ENTRY C_GenerateKeyPair +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_ATTRIBUTE_PTR pPublicKeyTemplate, + CK_ULONG ulPublicKeyAttributeCount, + CK_ATTRIBUTE_PTR pPrivateKeyTemplate, + CK_ULONG ulPrivateKeyAttributeCount, + CK_OBJECT_HANDLE_PTR phPublicKey, + CK_OBJECT_HANDLE_PTR phPrivateKey +); + +CK_RV CK_ENTRY C_WrapKey +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hWrappingKey, + CK_OBJECT_HANDLE hKey, + CK_BYTE_PTR pWrappedKey, + CK_ULONG_PTR pulWrappedKeyLen +); + +CK_RV CK_ENTRY C_UnwrapKey +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hUnwrappingKey, + CK_BYTE_PTR pWrappedKey, + CK_ULONG ulWrappedKeyLen, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulAttributeCount, + CK_OBJECT_HANDLE_PTR phKey +); + +CK_RV CK_ENTRY C_DeriveKey +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hBaseKey, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulAttributeCount, + CK_OBJECT_HANDLE_PTR phKey +); + +CK_RV CK_ENTRY C_SeedRandom +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pSeed, + CK_ULONG ulSeedLen +); + +CK_RV CK_ENTRY C_GenerateRandom +( + CK_SESSION_HANDLE hSession, + CK_BYTE_PTR RandomData, + CK_ULONG ulRandomLen +); + +CK_RV CK_ENTRY C_GetFunctionStatus +( + CK_SESSION_HANDLE hSession +); + +CK_RV CK_ENTRY C_CancelFunction +( + CK_SESSION_HANDLE hSession +); + +CK_RV CK_ENTRY C_WaitForSlotEvent +( + CK_FLAGS flags, + CK_SLOT_ID_PTR pSlot, + CK_VOID_PTR pRserved +); + +#endif /* NSSCKG_H */