stdll.h

IBM的Linux上的PKCS#11实现

             OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE
             OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE
             POSSIBILITY OF SUCH DAMAGES.

             7. GENERAL

             If any provision of this Agreement is invalid or
             unenforceable under applicable law, it shall not affect
             the validity or enforceability of the remainder of the
             terms of this Agreement, and without further action by the
             parties hereto, such provision shall be reformed to the
             minimum extent necessary to make such provision valid and
             enforceable.


             If Recipient institutes patent litigation against a
             Contributor with respect to a patent applicable to
             software (including a cross-claim or counterclaim in a
             lawsuit), then any patent licenses granted by that
             Contributor to such Recipient under this Agreement shall
             terminate as of the date such litigation is filed. In
             addition, If Recipient institutes patent litigation
             against any entity (including a cross-claim or
             counterclaim in a lawsuit) alleging that the Program
             itself (excluding combinations of the Program with other
             software or hardware) infringes such Recipient's
             patent(s), then such Recipient's rights granted under
             Section 2(b) shall terminate as of the date such
             litigation is filed.

             All Recipient's rights under this Agreement shall
             terminate if it fails to comply with any of the material
             terms or conditions of this Agreement and does not cure
             such failure in a reasonable period of time after becoming
             aware of such noncompliance. If all Recipient's rights
             under this Agreement terminate, Recipient agrees to cease
             use and distribution of the Program as soon as reasonably
             practicable. However, Recipient's obligations under this
             Agreement and any licenses granted by Recipient relating
             to the Program shall continue and survive. 

             Everyone is permitted to copy and distribute copies of
             this Agreement, but in order to avoid inconsistency the
             Agreement is copyrighted and may only be modified in the
             following manner. The Agreement Steward reserves the right
             to publish new versions (including revisions) of this
             Agreement from time to time. No one other than the
             Agreement Steward has the right to modify this Agreement.

             IBM is the initial Agreement Steward. IBM may assign the
             responsibility to serve as the Agreement Steward to a
             suitable separate entity. Each new version of the
             Agreement will be given a distinguishing version number.
             The Program (including Contributions) may always be
             distributed subject to the version of the Agreement under
             which it was received. In addition, after a new version of
             the Agreement is published, Contributor may elect to
             distribute the Program (including its Contributions) under
             the new version. Except as expressly stated in Sections
             2(a) and 2(b) above, Recipient receives no rights or
             licenses to the intellectual property of any Contributor
             under this Agreement, whether expressly, by implication,
             estoppel or otherwise. All rights in the Program not
             expressly granted under this Agreement are reserved.


             This Agreement is governed by the laws of the State of New
             York and the intellectual property laws of the United
             States of America. No party to this Agreement will bring a
             legal action under this Agreement more than one year after
             the cause of action arose. Each party waives its rights to
             a jury trial in any resulting litigation. 



*/

/* (C) COPYRIGHT International Business Machines Corp. 2001          */


//
//  API Local control blocks within the PKCS11 Meta API
//
//
//


#include <pkcs11types.h>
#if defined(AIX)
#include <sys/limits.h>
#endif
#if defined(LINUX)
#include <linux/limits.h>
#endif
#include <local_types.h>
#include <slotmgr.h>

#ifndef _STDLL_H
#define _STDLL_H



typedef struct {
   CK_SLOT_ID  slotID;
   CK_SESSION_HANDLE  sessionh;
} ST_SESSION_T ;


typedef ST_SESSION_T ST_SESSION_HANDLE;

/* CK_FUNCTION_LIST is a structure holding a Cryptoki spec
 * version and pointers of appropriate types to all the
 * Cryptoki functions */
/* CK_FUNCTION_LIST is new for v2.0 */



typedef CK_RV CK_ENTRY (CK_PTR ST_C_Initialize)
   (void **ppFunctionList,CK_SLOT_ID slotID,CK_CHAR_PTR pCorrelator);

typedef CK_RV CK_ENTRY	(CK_PTR  ST_C_Finalize)
						(CK_VOID_PTR pReserved);
typedef CK_RV CK_ENTRY	(CK_PTR  ST_C_Terminate)
						(void);
typedef CK_RV CK_ENTRY	(CK_PTR  ST_C_GetInfo)
						(CK_INFO_PTR pInfo);
typedef CK_RV CK_ENTRY	(CK_PTR  ST_C_GetFunctionList)
						(CK_FUNCTION_LIST_PTR_PTR ppFunctionList);
typedef CK_RV CK_ENTRY	(CK_PTR  ST_C_GetSlotList)
						(CK_BBOOL tokenPresent, CK_SLOT_ID_PTR pSlotList,
						 CK_ULONG_PTR pusCount);
typedef CK_RV CK_ENTRY	(CK_PTR  ST_C_GetSlotInfo)
						(CK_SLOT_ID slotID, CK_SLOT_INFO_PTR pInfo);
typedef CK_RV CK_ENTRY	(CK_PTR  ST_C_GetTokenInfo)
						(CK_SLOT_ID slotID, CK_TOKEN_INFO_PTR pInfo);
typedef CK_RV CK_ENTRY	(CK_PTR  ST_C_GetMechanismList)
						(CK_SLOT_ID slotID, CK_MECHANISM_TYPE_PTR pMechanismList,
						 CK_ULONG_PTR pusCount);
typedef CK_RV CK_ENTRY	(CK_PTR  ST_C_GetMechanismInfo)
						(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type,
						 CK_MECHANISM_INFO_PTR pInfo);
typedef CK_RV CK_ENTRY	(CK_PTR  ST_C_InitToken)
						(CK_SLOT_ID slotID, CK_CHAR_PTR pPin, CK_ULONG usPinLen,
						 CK_CHAR_PTR pLabel);
typedef CK_RV CK_ENTRY	(CK_PTR  ST_C_InitPIN)
						(ST_SESSION_T hSession, CK_CHAR_PTR pPin,
						 CK_ULONG usPinLen);
typedef CK_RV CK_ENTRY	(CK_PTR  ST_C_SetPIN)
						(ST_SESSION_T hSession, CK_CHAR_PTR pOldPin,
						 CK_ULONG usOldLen, CK_CHAR_PTR pNewPin,
						 CK_ULONG usNewLen);

// typedef CK_RV CK_ENTRY	(CK_PTR  ST_C_OpenSession)
// 						(CK_SLOT_ID slotID, CK_FLAGS flags,
// 						 CK_VOID_PTR pApplication,
// 						 CK_RV  (*Notify) (CK_SESSION_HANDLE hSession,
// 						 CK_NOTIFICATION event, CK_VOID_PTR pApplication),
// 						 CK_SESSION_HANDLE_PTR phSession);

typedef CK_RV CK_ENTRY	(CK_PTR  ST_C_OpenSession)
						(CK_SLOT_ID slotID, CK_FLAGS flags,
						 CK_SESSION_HANDLE_PTR phSession);

typedef CK_RV CK_ENTRY	(CK_PTR  ST_C_CloseSession)
						(ST_SESSION_T hSession);
typedef CK_RV CK_ENTRY	(CK_PTR  ST_C_CloseAllSessions)
						(CK_SLOT_ID slotID);
typedef CK_RV CK_ENTRY	(CK_PTR  ST_C_GetSessionInfo)
						(ST_SESSION_T hSession, CK_SESSION_INFO_PTR pInfo);
typedef CK_RV CK_ENTRY	(CK_PTR  ST_C_GetOperationState)
						(ST_SESSION_T hSession, CK_BYTE_PTR pOperationState,
						 CK_ULONG_PTR pulOperationStateLen);
typedef CK_RV CK_ENTRY	(CK_PTR  ST_C_SetOperationState)
						(ST_SESSION_T hSession, CK_BYTE_PTR pOperationState,
						 CK_ULONG ulOperationStateLen,
						 CK_OBJECT_HANDLE hEncryptionKey,
						 CK_OBJECT_HANDLE hAuthenticationKey);
typedef CK_RV CK_ENTRY	(CK_PTR  ST_C_Login)(ST_SESSION_T hSession,
						 CK_USER_TYPE userType, CK_CHAR_PTR pPin,
						 CK_ULONG usPinLen);
typedef CK_RV CK_ENTRY	(CK_PTR  ST_C_Logout)(ST_SESSION_T hSession);
typedef CK_RV CK_ENTRY	(CK_PTR  ST_C_CreateObject)
						(ST_SESSION_T hSession, CK_ATTRIBUTE_PTR pTemplate,
						 CK_ULONG usCount, CK_OBJECT_HANDLE_PTR phObject);

typedef CK_RV CK_ENTRY	(CK_PTR  ST_C_CopyObject)
						(ST_SESSION_T hSession, CK_OBJECT_HANDLE hObject,
						 CK_ATTRIBUTE_PTR pTemplate, CK_ULONG usCount,
						 CK_OBJECT_HANDLE_PTR phNewObject);
typedef CK_RV CK_ENTRY (CK_PTR  ST_C_DestroyObject)
                       (ST_SESSION_T hSession, CK_OBJECT_HANDLE hObject);
typedef CK_RV CK_ENTRY(CK_PTR  ST_C_GetObjectSize)
                       (ST_SESSION_T hSession, CK_OBJECT_HANDLE hObject,
                        CK_ULONG_PTR pusSize);
typedef CK_RV CK_ENTRY(CK_PTR  ST_C_GetAttributeValue)
                       (ST_SESSION_T hSession, CK_OBJECT_HANDLE hObject,
                        CK_ATTRIBUTE_PTR pTemplate, CK_ULONG usCount);
typedef CK_RV CK_ENTRY(CK_PTR  ST_C_SetAttributeValue)
                       (ST_SESSION_T hSession, CK_OBJECT_HANDLE hObject,
                        CK_ATTRIBUTE_PTR pTemplate, CK_ULONG usCount);
typedef CK_RV CK_ENTRY (CK_PTR  ST_C_FindObjectsInit)
                       (ST_SESSION_T hSession, CK_ATTRIBUTE_PTR pTemplate,
                        CK_ULONG usCount);
typedef CK_RV CK_ENTRY (CK_PTR  ST_C_FindObjects)
                       (ST_SESSION_T hSession,
                        CK_OBJECT_HANDLE_PTR phObject, CK_ULONG usMaxObjectCount,
                        CK_ULONG_PTR pusObjectCount);
typedef CK_RV CK_ENTRY (CK_PTR  ST_C_FindObjectsFinal)
                       (ST_SESSION_T hSession);
typedef CK_RV CK_ENTRY (CK_PTR  ST_C_EncryptInit)
                       (ST_SESSION_T hSession, CK_MECHANISM_PTR pMechanism,
                        CK_OBJECT_HANDLE hKey);
typedef CK_RV CK_ENTRY (CK_PTR  ST_C_Encrypt)
                       (ST_SESSION_T hSession, CK_BYTE_PTR pData,
                        CK_ULONG usDataLen, CK_BYTE_PTR pEncryptedData,
                        CK_ULONG_PTR pusEncryptedDataLen);