The Tor Browser: security/nss/lib/ckfw/nssck.api@6474c204b198

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     1 /* THIS IS A GENERATED FILE */

     2 /* This Source Code Form is subject to the terms of the Mozilla Public

     3  * License, v. 2.0. If a copy of the MPL was not distributed with this

     4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     6 /*

     7  * nssck.api

     8  *

     9  * This automatically-generated file is used to generate a set of

    10  * Cryptoki entry points within the object space of a Module using

    11  * the NSS Cryptoki Framework.

    12  *

    13  * The Module should have a .c file with the following:

    14  *

    15  *  #define MODULE_NAME name

    16  *  #define INSTANCE_NAME instance

    17  *  #include "nssck.api"

    18  *

    19  * where "name" is some module-specific name that can be used to

    20  * disambiguate various modules.  This included file will then

    21  * define the actual Cryptoki routines which pass through to the

    22  * Framework calls.  All routines, except C_GetFunctionList, will

    23  * be prefixed with the name; C_GetFunctionList will be generated

    24  * to return an entry-point vector with these routines.  The

    25  * instance specified should be the basic instance of NSSCKMDInstance.

    26  *

    27  * If, prior to including nssck.api, the .c file also specifies

    28  *

    29  *  #define DECLARE_STRICT_CRYTPOKI_NAMES

    30  *

    31  * Then a set of "stub" routines not prefixed with the name will

    32  * be included.  This would allow the combined module and framework

    33  * to be used in applications which are hard-coded to use the

    34  * PKCS#11 names (instead of going through the EPV).  Please note

    35  * that such applications should be careful resolving symbols when

    36  * more than one PKCS#11 module is loaded.

    37  */

    39 #ifndef MODULE_NAME

    40 #error "Error: MODULE_NAME must be defined."

    41 #endif /* MODULE_NAME */

    43 #ifndef INSTANCE_NAME

    44 #error "Error: INSTANCE_NAME must be defined."

    45 #endif /* INSTANCE_NAME */

    47 #ifndef NSSCKT_H

    48 #include "nssckt.h"

    49 #endif /* NSSCKT_H */

    51 #ifndef NSSCKFWT_H

    52 #include "nssckfwt.h"

    53 #endif /* NSSCKFWT_H */

    55 #ifndef NSSCKFWC_H

    56 #include "nssckfwc.h"

    57 #endif /* NSSCKFWC_H */

    59 #ifndef NSSCKEPV_H

    60 #include "nssckepv.h"

    61 #endif /* NSSCKEPV_H */

    63 #define ADJOIN(x,y) x##y

    65 #define __ADJOIN(x,y) ADJOIN(x,y)

    67 /*

    68  * The anchor.  This object is used to store an "anchor" pointer in

    69  * the Module's object space, so the wrapper functions can relate

    70  * back to this instance.

    71  */

    73 static NSSCKFWInstance *fwInstance = (NSSCKFWInstance *)0;

    75 static CK_RV CK_ENTRY

    76 __ADJOIN(MODULE_NAME,C_Initialize)

    77 (

    78   CK_VOID_PTR pInitArgs

    79 )

    80 {

    81   return NSSCKFWC_Initialize(&fwInstance, INSTANCE_NAME, pInitArgs);

    82 }

    84 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

    85 CK_RV CK_ENTRY

    86 C_Initialize

    87 (

    88   CK_VOID_PTR pInitArgs

    89 )

    90 {

    91   return __ADJOIN(MODULE_NAME,C_Initialize)(pInitArgs);

    92 }

    93 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

    95 static CK_RV CK_ENTRY

    96 __ADJOIN(MODULE_NAME,C_Finalize)

    97 (

    98   CK_VOID_PTR pReserved

    99 )

   100 {

   101   return NSSCKFWC_Finalize(&fwInstance);

   102 }

   104 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   105 CK_RV CK_ENTRY

   106 C_Finalize

   107 (

   108   CK_VOID_PTR pReserved

   109 )

   110 {

   111   return __ADJOIN(MODULE_NAME,C_Finalize)(pReserved);

   112 }

   113 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   115 static CK_RV CK_ENTRY

   116 __ADJOIN(MODULE_NAME,C_GetInfo)

   117 (

   118   CK_INFO_PTR pInfo

   119 )

   120 {

   121   return NSSCKFWC_GetInfo(fwInstance, pInfo);

   122 }

   124 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   125 CK_RV CK_ENTRY

   126 C_GetInfo

   127 (

   128   CK_INFO_PTR pInfo

   129 )

   130 {

   131   return __ADJOIN(MODULE_NAME,C_GetInfo)(pInfo);

   132 }

   133 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   135 /*

   136  * C_GetFunctionList is defined at the end.

   137  */

   139 static CK_RV CK_ENTRY

   140 __ADJOIN(MODULE_NAME,C_GetSlotList)

   141 (

   142   CK_BBOOL tokenPresent,

   143   CK_SLOT_ID_PTR pSlotList,

   144   CK_ULONG_PTR pulCount

   145 )

   146 {

   147   return NSSCKFWC_GetSlotList(fwInstance, tokenPresent, pSlotList, pulCount);

   148 }

   150 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   151 CK_RV CK_ENTRY

   152 C_GetSlotList

   153 (

   154   CK_BBOOL tokenPresent,

   155   CK_SLOT_ID_PTR pSlotList,

   156   CK_ULONG_PTR pulCount

   157 )

   158 {

   159   return __ADJOIN(MODULE_NAME,C_GetSlotList)(tokenPresent, pSlotList, pulCount);

   160 }

   161 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   163 static CK_RV CK_ENTRY

   164 __ADJOIN(MODULE_NAME,C_GetSlotInfo)

   165 (

   166   CK_SLOT_ID slotID,

   167   CK_SLOT_INFO_PTR pInfo

   168 )

   169 {

   170   return NSSCKFWC_GetSlotInfo(fwInstance, slotID, pInfo);

   171 }

   173 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   174 CK_RV CK_ENTRY

   175 C_GetSlotInfo

   176 (

   177   CK_SLOT_ID slotID,

   178   CK_SLOT_INFO_PTR pInfo

   179 )

   180 {

   181   return __ADJOIN(MODULE_NAME,C_GetSlotInfo)(slotID, pInfo);

   182 }

   183 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   185 static CK_RV CK_ENTRY

   186 __ADJOIN(MODULE_NAME,C_GetTokenInfo)

   187 (

   188   CK_SLOT_ID slotID,

   189   CK_TOKEN_INFO_PTR pInfo

   190 )

   191 {

   192   return NSSCKFWC_GetTokenInfo(fwInstance, slotID, pInfo);

   193 }

   195 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   196 CK_RV CK_ENTRY

   197 C_GetTokenInfo

   198 (

   199   CK_SLOT_ID slotID,

   200   CK_TOKEN_INFO_PTR pInfo

   201 )

   202 {

   203   return __ADJOIN(MODULE_NAME,C_GetTokenInfo)(slotID, pInfo);

   204 }

   205 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   207 static CK_RV CK_ENTRY

   208 __ADJOIN(MODULE_NAME,C_GetMechanismList)

   209 (

   210   CK_SLOT_ID slotID,

   211   CK_MECHANISM_TYPE_PTR pMechanismList,

   212   CK_ULONG_PTR pulCount

   213 )

   214 {

   215   return NSSCKFWC_GetMechanismList(fwInstance, slotID, pMechanismList, pulCount);

   216 }

   218 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   219 CK_RV CK_ENTRY

   220 C_GetMechanismList

   221 (

   222   CK_SLOT_ID slotID,

   223   CK_MECHANISM_TYPE_PTR pMechanismList,

   224   CK_ULONG_PTR pulCount

   225 )

   226 {

   227   return __ADJOIN(MODULE_NAME,C_GetMechanismList)(slotID, pMechanismList, pulCount);

   228 }

   229 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   231 static CK_RV CK_ENTRY

   232 __ADJOIN(MODULE_NAME,C_GetMechanismInfo)

   233 (

   234   CK_SLOT_ID slotID,

   235   CK_MECHANISM_TYPE type,

   236   CK_MECHANISM_INFO_PTR pInfo

   237 )

   238 {

   239   return NSSCKFWC_GetMechanismInfo(fwInstance, slotID, type, pInfo);

   240 }

   242 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   243 CK_RV CK_ENTRY

   244 C_GetMechanismInfo

   245 (

   246   CK_SLOT_ID slotID,

   247   CK_MECHANISM_TYPE type,

   248   CK_MECHANISM_INFO_PTR pInfo

   249 )

   250 {

   251   return __ADJOIN(MODULE_NAME,C_GetMechanismInfo)(slotID, type, pInfo);

   252 }

   253 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   255 static CK_RV CK_ENTRY

   256 __ADJOIN(MODULE_NAME,C_InitToken)

   257 (

   258   CK_SLOT_ID slotID,

   259   CK_CHAR_PTR pPin,

   260   CK_ULONG ulPinLen,

   261   CK_CHAR_PTR pLabel

   262 )

   263 {

   264   return NSSCKFWC_InitToken(fwInstance, slotID, pPin, ulPinLen, pLabel);

   265 }

   267 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   268 CK_RV CK_ENTRY

   269 C_InitToken

   270 (

   271   CK_SLOT_ID slotID,

   272   CK_CHAR_PTR pPin,

   273   CK_ULONG ulPinLen,

   274   CK_CHAR_PTR pLabel

   275 )

   276 {

   277   return __ADJOIN(MODULE_NAME,C_InitToken)(slotID, pPin, ulPinLen, pLabel);

   278 }

   279 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   281 static CK_RV CK_ENTRY

   282 __ADJOIN(MODULE_NAME,C_InitPIN)

   283 (

   284   CK_SESSION_HANDLE hSession,

   285   CK_CHAR_PTR pPin,

   286   CK_ULONG ulPinLen

   287 )

   288 {

   289   return NSSCKFWC_InitPIN(fwInstance, hSession, pPin, ulPinLen);

   290 }

   292 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   293 CK_RV CK_ENTRY

   294 C_InitPIN

   295 (

   296   CK_SESSION_HANDLE hSession,

   297   CK_CHAR_PTR pPin,

   298   CK_ULONG ulPinLen

   299 )

   300 {

   301   return __ADJOIN(MODULE_NAME,C_InitPIN)(hSession, pPin, ulPinLen);

   302 }

   303 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   305 static CK_RV CK_ENTRY

   306 __ADJOIN(MODULE_NAME,C_SetPIN)

   307 (

   308   CK_SESSION_HANDLE hSession,

   309   CK_CHAR_PTR pOldPin,

   310   CK_ULONG ulOldLen,

   311   CK_CHAR_PTR pNewPin,

   312   CK_ULONG ulNewLen

   313 )

   314 {

   315   return NSSCKFWC_SetPIN(fwInstance, hSession, pOldPin, ulOldLen, pNewPin, ulNewLen);

   316 }

   318 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   319 CK_RV CK_ENTRY

   320 C_SetPIN

   321 (

   322   CK_SESSION_HANDLE hSession,

   323   CK_CHAR_PTR pOldPin,

   324   CK_ULONG ulOldLen,

   325   CK_CHAR_PTR pNewPin,

   326   CK_ULONG ulNewLen

   327 )

   328 {

   329   return __ADJOIN(MODULE_NAME,C_SetPIN)(hSession, pOldPin, ulOldLen, pNewPin, ulNewLen);

   330 }

   331 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   333 static CK_RV CK_ENTRY

   334 __ADJOIN(MODULE_NAME,C_OpenSession)

   335 (

   336   CK_SLOT_ID slotID,

   337   CK_FLAGS flags,

   338   CK_VOID_PTR pApplication,

   339   CK_NOTIFY Notify,

   340   CK_SESSION_HANDLE_PTR phSession

   341 )

   342 {

   343   return NSSCKFWC_OpenSession(fwInstance, slotID, flags, pApplication, Notify, phSession);

   344 }

   346 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   347 CK_RV CK_ENTRY

   348 C_OpenSession

   349 (

   350   CK_SLOT_ID slotID,

   351   CK_FLAGS flags,

   352   CK_VOID_PTR pApplication,

   353   CK_NOTIFY Notify,

   354   CK_SESSION_HANDLE_PTR phSession

   355 )

   356 {

   357   return __ADJOIN(MODULE_NAME,C_OpenSession)(slotID, flags, pApplication, Notify, phSession);

   358 }

   359 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   361 static CK_RV CK_ENTRY

   362 __ADJOIN(MODULE_NAME,C_CloseSession)

   363 (

   364   CK_SESSION_HANDLE hSession

   365 )

   366 {

   367   return NSSCKFWC_CloseSession(fwInstance, hSession);

   368 }

   370 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   371 CK_RV CK_ENTRY

   372 C_CloseSession

   373 (

   374   CK_SESSION_HANDLE hSession

   375 )

   376 {

   377   return __ADJOIN(MODULE_NAME,C_CloseSession)(hSession);

   378 }

   379 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   381 static CK_RV CK_ENTRY

   382 __ADJOIN(MODULE_NAME,C_CloseAllSessions)

   383 (

   384   CK_SLOT_ID slotID

   385 )

   386 {

   387   return NSSCKFWC_CloseAllSessions(fwInstance, slotID);

   388 }

   390 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   391 CK_RV CK_ENTRY

   392 C_CloseAllSessions

   393 (

   394   CK_SLOT_ID slotID

   395 )

   396 {

   397   return __ADJOIN(MODULE_NAME,C_CloseAllSessions)(slotID);

   398 }

   399 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   401 static CK_RV CK_ENTRY

   402 __ADJOIN(MODULE_NAME,C_GetSessionInfo)

   403 (

   404   CK_SESSION_HANDLE hSession,

   405   CK_SESSION_INFO_PTR pInfo

   406 )

   407 {

   408   return NSSCKFWC_GetSessionInfo(fwInstance, hSession, pInfo);

   409 }

   411 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   412 CK_RV CK_ENTRY

   413 C_GetSessionInfo

   414 (

   415   CK_SESSION_HANDLE hSession,

   416   CK_SESSION_INFO_PTR pInfo

   417 )

   418 {

   419   return __ADJOIN(MODULE_NAME,C_GetSessionInfo)(hSession, pInfo);

   420 }

   421 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   423 static CK_RV CK_ENTRY

   424 __ADJOIN(MODULE_NAME,C_GetOperationState)

   425 (

   426   CK_SESSION_HANDLE hSession,

   427   CK_BYTE_PTR pOperationState,

   428   CK_ULONG_PTR pulOperationStateLen

   429 )

   430 {

   431   return NSSCKFWC_GetOperationState(fwInstance, hSession, pOperationState, pulOperationStateLen);

   432 }

   434 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   435 CK_RV CK_ENTRY

   436 C_GetOperationState

   437 (

   438   CK_SESSION_HANDLE hSession,

   439   CK_BYTE_PTR pOperationState,

   440   CK_ULONG_PTR pulOperationStateLen

   441 )

   442 {

   443   return __ADJOIN(MODULE_NAME,C_GetOperationState)(hSession, pOperationState, pulOperationStateLen);

   444 }

   445 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   447 static CK_RV CK_ENTRY

   448 __ADJOIN(MODULE_NAME,C_SetOperationState)

   449 (

   450   CK_SESSION_HANDLE hSession,

   451   CK_BYTE_PTR pOperationState,

   452   CK_ULONG ulOperationStateLen,

   453   CK_OBJECT_HANDLE hEncryptionKey,

   454   CK_OBJECT_HANDLE hAuthenticationKey

   455 )

   456 {

   457   return NSSCKFWC_SetOperationState(fwInstance, hSession, pOperationState, ulOperationStateLen, hEncryptionKey, hAuthenticationKey);

   458 }

   460 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   461 CK_RV CK_ENTRY

   462 C_SetOperationState

   463 (

   464   CK_SESSION_HANDLE hSession,

   465   CK_BYTE_PTR pOperationState,

   466   CK_ULONG ulOperationStateLen,

   467   CK_OBJECT_HANDLE hEncryptionKey,

   468   CK_OBJECT_HANDLE hAuthenticationKey

   469 )

   470 {

   471   return __ADJOIN(MODULE_NAME,C_SetOperationState)(hSession, pOperationState, ulOperationStateLen, hEncryptionKey, hAuthenticationKey);

   472 }

   473 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   475 static CK_RV CK_ENTRY

   476 __ADJOIN(MODULE_NAME,C_Login)

   477 (

   478   CK_SESSION_HANDLE hSession,

   479   CK_USER_TYPE userType,

   480   CK_CHAR_PTR pPin,

   481   CK_ULONG ulPinLen

   482 )

   483 {

   484   return NSSCKFWC_Login(fwInstance, hSession, userType, pPin, ulPinLen);

   485 }

   487 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   488 CK_RV CK_ENTRY

   489 C_Login

   490 (

   491   CK_SESSION_HANDLE hSession,

   492   CK_USER_TYPE userType,

   493   CK_CHAR_PTR pPin,

   494   CK_ULONG ulPinLen

   495 )

   496 {

   497   return __ADJOIN(MODULE_NAME,C_Login)(hSession, userType, pPin, ulPinLen);

   498 }

   499 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   501 static CK_RV CK_ENTRY

   502 __ADJOIN(MODULE_NAME,C_Logout)

   503 (

   504   CK_SESSION_HANDLE hSession

   505 )

   506 {

   507   return NSSCKFWC_Logout(fwInstance, hSession);

   508 }

   510 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   511 CK_RV CK_ENTRY

   512 C_Logout

   513 (

   514   CK_SESSION_HANDLE hSession

   515 )

   516 {

   517   return __ADJOIN(MODULE_NAME,C_Logout)(hSession);

   518 }

   519 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   521 static CK_RV CK_ENTRY

   522 __ADJOIN(MODULE_NAME,C_CreateObject)

   523 (

   524   CK_SESSION_HANDLE hSession,

   525   CK_ATTRIBUTE_PTR pTemplate,

   526   CK_ULONG ulCount,

   527   CK_OBJECT_HANDLE_PTR phObject

   528 )

   529 {

   530   return NSSCKFWC_CreateObject(fwInstance, hSession, pTemplate, ulCount, phObject);

   531 }

   533 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   534 CK_RV CK_ENTRY

   535 C_CreateObject

   536 (

   537   CK_SESSION_HANDLE hSession,

   538   CK_ATTRIBUTE_PTR pTemplate,

   539   CK_ULONG ulCount,

   540   CK_OBJECT_HANDLE_PTR phObject

   541 )

   542 {

   543   return __ADJOIN(MODULE_NAME,C_CreateObject)(hSession, pTemplate, ulCount, phObject);

   544 }

   545 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   547 static CK_RV CK_ENTRY

   548 __ADJOIN(MODULE_NAME,C_CopyObject)

   549 (

   550   CK_SESSION_HANDLE hSession,

   551   CK_OBJECT_HANDLE hObject,

   552   CK_ATTRIBUTE_PTR pTemplate,

   553   CK_ULONG ulCount,

   554   CK_OBJECT_HANDLE_PTR phNewObject

   555 )

   556 {

   557   return NSSCKFWC_CopyObject(fwInstance, hSession, hObject, pTemplate, ulCount, phNewObject);

   558 }

   560 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   561 CK_RV CK_ENTRY

   562 C_CopyObject

   563 (

   564   CK_SESSION_HANDLE hSession,

   565   CK_OBJECT_HANDLE hObject,

   566   CK_ATTRIBUTE_PTR pTemplate,

   567   CK_ULONG ulCount,

   568   CK_OBJECT_HANDLE_PTR phNewObject

   569 )

   570 {

   571   return __ADJOIN(MODULE_NAME,C_CopyObject)(hSession, hObject, pTemplate, ulCount, phNewObject);

   572 }

   573 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   575 static CK_RV CK_ENTRY

   576 __ADJOIN(MODULE_NAME,C_DestroyObject)

   577 (

   578   CK_SESSION_HANDLE hSession,

   579   CK_OBJECT_HANDLE hObject

   580 )

   581 {

   582   return NSSCKFWC_DestroyObject(fwInstance, hSession, hObject);

   583 }

   585 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   586 CK_RV CK_ENTRY

   587 C_DestroyObject

   588 (

   589   CK_SESSION_HANDLE hSession,

   590   CK_OBJECT_HANDLE hObject

   591 )

   592 {

   593   return __ADJOIN(MODULE_NAME,C_DestroyObject)(hSession, hObject);

   594 }

   595 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   597 static CK_RV CK_ENTRY

   598 __ADJOIN(MODULE_NAME,C_GetObjectSize)

   599 (

   600   CK_SESSION_HANDLE hSession,

   601   CK_OBJECT_HANDLE hObject,

   602   CK_ULONG_PTR pulSize

   603 )

   604 {

   605   return NSSCKFWC_GetObjectSize(fwInstance, hSession, hObject, pulSize);

   606 }

   608 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   609 CK_RV CK_ENTRY

   610 C_GetObjectSize

   611 (

   612   CK_SESSION_HANDLE hSession,

   613   CK_OBJECT_HANDLE hObject,

   614   CK_ULONG_PTR pulSize

   615 )

   616 {

   617   return __ADJOIN(MODULE_NAME,C_GetObjectSize)(hSession, hObject, pulSize);

   618 }

   619 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   621 static CK_RV CK_ENTRY

   622 __ADJOIN(MODULE_NAME,C_GetAttributeValue)

   623 (

   624   CK_SESSION_HANDLE hSession,

   625   CK_OBJECT_HANDLE hObject,

   626   CK_ATTRIBUTE_PTR pTemplate,

   627   CK_ULONG ulCount

   628 )

   629 {

   630   return NSSCKFWC_GetAttributeValue(fwInstance, hSession, hObject, pTemplate, ulCount);

   631 }

   633 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   634 CK_RV CK_ENTRY

   635 C_GetAttributeValue

   636 (

   637   CK_SESSION_HANDLE hSession,

   638   CK_OBJECT_HANDLE hObject,

   639   CK_ATTRIBUTE_PTR pTemplate,

   640   CK_ULONG ulCount

   641 )

   642 {

   643   return __ADJOIN(MODULE_NAME,C_GetAttributeValue)(hSession, hObject, pTemplate, ulCount);

   644 }

   645 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   647 static CK_RV CK_ENTRY

   648 __ADJOIN(MODULE_NAME,C_SetAttributeValue)

   649 (

   650   CK_SESSION_HANDLE hSession,

   651   CK_OBJECT_HANDLE hObject,

   652   CK_ATTRIBUTE_PTR pTemplate,

   653   CK_ULONG ulCount

   654 )

   655 {

   656   return NSSCKFWC_SetAttributeValue(fwInstance, hSession, hObject, pTemplate, ulCount);

   657 }

   659 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   660 CK_RV CK_ENTRY

   661 C_SetAttributeValue

   662 (

   663   CK_SESSION_HANDLE hSession,

   664   CK_OBJECT_HANDLE hObject,

   665   CK_ATTRIBUTE_PTR pTemplate,

   666   CK_ULONG ulCount

   667 )

   668 {

   669   return __ADJOIN(MODULE_NAME,C_SetAttributeValue)(hSession, hObject, pTemplate, ulCount);

   670 }

   671 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   673 static CK_RV CK_ENTRY

   674 __ADJOIN(MODULE_NAME,C_FindObjectsInit)

   675 (

   676   CK_SESSION_HANDLE hSession,

   677   CK_ATTRIBUTE_PTR pTemplate,

   678   CK_ULONG ulCount

   679 )

   680 {

   681   return NSSCKFWC_FindObjectsInit(fwInstance, hSession, pTemplate, ulCount);

   682 }

   684 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   685 CK_RV CK_ENTRY

   686 C_FindObjectsInit

   687 (

   688   CK_SESSION_HANDLE hSession,

   689   CK_ATTRIBUTE_PTR pTemplate,

   690   CK_ULONG ulCount

   691 )

   692 {

   693   return __ADJOIN(MODULE_NAME,C_FindObjectsInit)(hSession, pTemplate, ulCount);

   694 }

   695 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   697 static CK_RV CK_ENTRY

   698 __ADJOIN(MODULE_NAME,C_FindObjects)

   699 (

   700   CK_SESSION_HANDLE hSession,

   701   CK_OBJECT_HANDLE_PTR phObject,

   702   CK_ULONG ulMaxObjectCount,

   703   CK_ULONG_PTR pulObjectCount

   704 )

   705 {

   706   return NSSCKFWC_FindObjects(fwInstance, hSession, phObject, ulMaxObjectCount, pulObjectCount);

   707 }

   709 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   710 CK_RV CK_ENTRY

   711 C_FindObjects

   712 (

   713   CK_SESSION_HANDLE hSession,

   714   CK_OBJECT_HANDLE_PTR phObject,

   715   CK_ULONG ulMaxObjectCount,

   716   CK_ULONG_PTR pulObjectCount

   717 )

   718 {

   719   return __ADJOIN(MODULE_NAME,C_FindObjects)(hSession, phObject, ulMaxObjectCount, pulObjectCount);

   720 }

   721 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   723 static CK_RV CK_ENTRY

   724 __ADJOIN(MODULE_NAME,C_FindObjectsFinal)

   725 (

   726   CK_SESSION_HANDLE hSession

   727 )

   728 {

   729   return NSSCKFWC_FindObjectsFinal(fwInstance, hSession);

   730 }

   732 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   733 CK_RV CK_ENTRY

   734 C_FindObjectsFinal

   735 (

   736   CK_SESSION_HANDLE hSession

   737 )

   738 {

   739   return __ADJOIN(MODULE_NAME,C_FindObjectsFinal)(hSession);

   740 }

   741 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   743 static CK_RV CK_ENTRY

   744 __ADJOIN(MODULE_NAME,C_EncryptInit)

   745 (

   746   CK_SESSION_HANDLE hSession,

   747   CK_MECHANISM_PTR pMechanism,

   748   CK_OBJECT_HANDLE hKey

   749 )

   750 {

   751   return NSSCKFWC_EncryptInit(fwInstance, hSession, pMechanism, hKey);

   752 }

   754 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   755 CK_RV CK_ENTRY

   756 C_EncryptInit

   757 (

   758   CK_SESSION_HANDLE hSession,

   759   CK_MECHANISM_PTR pMechanism,

   760   CK_OBJECT_HANDLE hKey

   761 )

   762 {

   763   return __ADJOIN(MODULE_NAME,C_EncryptInit)(hSession, pMechanism, hKey);

   764 }

   765 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   767 static CK_RV CK_ENTRY

   768 __ADJOIN(MODULE_NAME,C_Encrypt)

   769 (

   770   CK_SESSION_HANDLE hSession,

   771   CK_BYTE_PTR pData,

   772   CK_ULONG ulDataLen,

   773   CK_BYTE_PTR pEncryptedData,

   774   CK_ULONG_PTR pulEncryptedDataLen

   775 )

   776 {

   777   return NSSCKFWC_Encrypt(fwInstance, hSession, pData, ulDataLen, pEncryptedData, pulEncryptedDataLen);

   778 }

   780 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   781 CK_RV CK_ENTRY

   782 C_Encrypt

   783 (

   784   CK_SESSION_HANDLE hSession,

   785   CK_BYTE_PTR pData,

   786   CK_ULONG ulDataLen,

   787   CK_BYTE_PTR pEncryptedData,

   788   CK_ULONG_PTR pulEncryptedDataLen

   789 )

   790 {

   791   return __ADJOIN(MODULE_NAME,C_Encrypt)(hSession, pData, ulDataLen, pEncryptedData, pulEncryptedDataLen);

   792 }

   793 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   795 static CK_RV CK_ENTRY

   796 __ADJOIN(MODULE_NAME,C_EncryptUpdate)

   797 (

   798   CK_SESSION_HANDLE hSession,

   799   CK_BYTE_PTR pPart,

   800   CK_ULONG ulPartLen,

   801   CK_BYTE_PTR pEncryptedPart,

   802   CK_ULONG_PTR pulEncryptedPartLen

   803 )

   804 {

   805   return NSSCKFWC_EncryptUpdate(fwInstance, hSession, pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen);

   806 }

   808 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   809 CK_RV CK_ENTRY

   810 C_EncryptUpdate

   811 (

   812   CK_SESSION_HANDLE hSession,

   813   CK_BYTE_PTR pPart,

   814   CK_ULONG ulPartLen,

   815   CK_BYTE_PTR pEncryptedPart,

   816   CK_ULONG_PTR pulEncryptedPartLen

   817 )

   818 {

   819   return __ADJOIN(MODULE_NAME,C_EncryptUpdate)(hSession, pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen);

   820 }

   821 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   823 static CK_RV CK_ENTRY

   824 __ADJOIN(MODULE_NAME,C_EncryptFinal)

   825 (

   826   CK_SESSION_HANDLE hSession,

   827   CK_BYTE_PTR pLastEncryptedPart,

   828   CK_ULONG_PTR pulLastEncryptedPartLen

   829 )

   830 {

   831   return NSSCKFWC_EncryptFinal(fwInstance, hSession, pLastEncryptedPart, pulLastEncryptedPartLen);

   832 }

   834 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   835 CK_RV CK_ENTRY

   836 C_EncryptFinal

   837 (

   838   CK_SESSION_HANDLE hSession,

   839   CK_BYTE_PTR pLastEncryptedPart,

   840   CK_ULONG_PTR pulLastEncryptedPartLen

   841 )

   842 {

   843   return __ADJOIN(MODULE_NAME,C_EncryptFinal)(hSession, pLastEncryptedPart, pulLastEncryptedPartLen);

   844 }

   845 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   847 static CK_RV CK_ENTRY

   848 __ADJOIN(MODULE_NAME,C_DecryptInit)

   849 (

   850   CK_SESSION_HANDLE hSession,

   851   CK_MECHANISM_PTR pMechanism,

   852   CK_OBJECT_HANDLE hKey

   853 )

   854 {

   855   return NSSCKFWC_DecryptInit(fwInstance, hSession, pMechanism, hKey);

   856 }

   858 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   859 CK_RV CK_ENTRY

   860 C_DecryptInit

   861 (

   862   CK_SESSION_HANDLE hSession,

   863   CK_MECHANISM_PTR pMechanism,

   864   CK_OBJECT_HANDLE hKey

   865 )

   866 {

   867   return __ADJOIN(MODULE_NAME,C_DecryptInit)(hSession, pMechanism, hKey);

   868 }

   869 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   871 static CK_RV CK_ENTRY

   872 __ADJOIN(MODULE_NAME,C_Decrypt)

   873 (

   874   CK_SESSION_HANDLE hSession,

   875   CK_BYTE_PTR pEncryptedData,

   876   CK_ULONG ulEncryptedDataLen,

   877   CK_BYTE_PTR pData,

   878   CK_ULONG_PTR pulDataLen

   879 )

   880 {

   881   return NSSCKFWC_Decrypt(fwInstance, hSession, pEncryptedData, ulEncryptedDataLen, pData, pulDataLen);

   882 }

   884 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   885 CK_RV CK_ENTRY

   886 C_Decrypt

   887 (

   888   CK_SESSION_HANDLE hSession,

   889   CK_BYTE_PTR pEncryptedData,

   890   CK_ULONG ulEncryptedDataLen,

   891   CK_BYTE_PTR pData,

   892   CK_ULONG_PTR pulDataLen

   893 )

   894 {

   895   return __ADJOIN(MODULE_NAME,C_Decrypt)(hSession, pEncryptedData, ulEncryptedDataLen, pData, pulDataLen);

   896 }

   897 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   899 static CK_RV CK_ENTRY

   900 __ADJOIN(MODULE_NAME,C_DecryptUpdate)

   901 (

   902   CK_SESSION_HANDLE hSession,

   903   CK_BYTE_PTR pEncryptedPart,

   904   CK_ULONG ulEncryptedPartLen,

   905   CK_BYTE_PTR pPart,

   906   CK_ULONG_PTR pulPartLen

   907 )

   908 {

   909   return NSSCKFWC_DecryptUpdate(fwInstance, hSession, pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen);

   910 }

   912 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   913 CK_RV CK_ENTRY

   914 C_DecryptUpdate

   915 (

   916   CK_SESSION_HANDLE hSession,

   917   CK_BYTE_PTR pEncryptedPart,

   918   CK_ULONG ulEncryptedPartLen,

   919   CK_BYTE_PTR pPart,

   920   CK_ULONG_PTR pulPartLen

   921 )

   922 {

   923   return __ADJOIN(MODULE_NAME,C_DecryptUpdate)(hSession, pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen);

   924 }

   925 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   927 static CK_RV CK_ENTRY

   928 __ADJOIN(MODULE_NAME,C_DecryptFinal)

   929 (

   930   CK_SESSION_HANDLE hSession,

   931   CK_BYTE_PTR pLastPart,

   932   CK_ULONG_PTR pulLastPartLen

   933 )

   934 {

   935   return NSSCKFWC_DecryptFinal(fwInstance, hSession, pLastPart, pulLastPartLen);

   936 }

   938 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   939 CK_RV CK_ENTRY

   940 C_DecryptFinal

   941 (

   942   CK_SESSION_HANDLE hSession,

   943   CK_BYTE_PTR pLastPart,

   944   CK_ULONG_PTR pulLastPartLen

   945 )

   946 {

   947   return __ADJOIN(MODULE_NAME,C_DecryptFinal)(hSession, pLastPart, pulLastPartLen);

   948 }

   949 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   951 static CK_RV CK_ENTRY

   952 __ADJOIN(MODULE_NAME,C_DigestInit)

   953 (

   954   CK_SESSION_HANDLE hSession,

   955   CK_MECHANISM_PTR pMechanism

   956 )

   957 {

   958   return NSSCKFWC_DigestInit(fwInstance, hSession, pMechanism);

   959 }

   961 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   962 CK_RV CK_ENTRY

   963 C_DigestInit

   964 (

   965   CK_SESSION_HANDLE hSession,

   966   CK_MECHANISM_PTR pMechanism

   967 )

   968 {

   969   return __ADJOIN(MODULE_NAME,C_DigestInit)(hSession, pMechanism);

   970 }

   971 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

   973 static CK_RV CK_ENTRY

   974 __ADJOIN(MODULE_NAME,C_Digest)

   975 (

   976   CK_SESSION_HANDLE hSession,

   977   CK_BYTE_PTR pData,

   978   CK_ULONG ulDataLen,

   979   CK_BYTE_PTR pDigest,

   980   CK_ULONG_PTR pulDigestLen

   981 )

   982 {

   983   return NSSCKFWC_Digest(fwInstance, hSession, pData, ulDataLen, pDigest, pulDigestLen);

   984 }

   986 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

   987 CK_RV CK_ENTRY

   988 C_Digest

   989 (

   990   CK_SESSION_HANDLE hSession,

   991   CK_BYTE_PTR pData,

   992   CK_ULONG ulDataLen,

   993   CK_BYTE_PTR pDigest,

   994   CK_ULONG_PTR pulDigestLen

   995 )

   996 {

   997   return __ADJOIN(MODULE_NAME,C_Digest)(hSession, pData, ulDataLen, pDigest, pulDigestLen);

   998 }

   999 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1001 static CK_RV CK_ENTRY

  1002 __ADJOIN(MODULE_NAME,C_DigestUpdate)

  1003 (

  1004   CK_SESSION_HANDLE hSession,

  1005   CK_BYTE_PTR pPart,

  1006   CK_ULONG ulPartLen

  1007 )

  1008 {

  1009   return NSSCKFWC_DigestUpdate(fwInstance, hSession, pPart, ulPartLen);

  1010 }

  1012 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1013 CK_RV CK_ENTRY

  1014 C_DigestUpdate

  1015 (

  1016   CK_SESSION_HANDLE hSession,

  1017   CK_BYTE_PTR pPart,

  1018   CK_ULONG ulPartLen

  1019 )

  1020 {

  1021   return __ADJOIN(MODULE_NAME,C_DigestUpdate)(hSession, pPart, ulPartLen);

  1022 }

  1023 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1025 static CK_RV CK_ENTRY

  1026 __ADJOIN(MODULE_NAME,C_DigestKey)

  1027 (

  1028   CK_SESSION_HANDLE hSession,

  1029   CK_OBJECT_HANDLE hKey

  1030 )

  1031 {

  1032   return NSSCKFWC_DigestKey(fwInstance, hSession, hKey);

  1033 }

  1035 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1036 CK_RV CK_ENTRY

  1037 C_DigestKey

  1038 (

  1039   CK_SESSION_HANDLE hSession,

  1040   CK_OBJECT_HANDLE hKey

  1041 )

  1042 {

  1043   return __ADJOIN(MODULE_NAME,C_DigestKey)(hSession, hKey);

  1044 }

  1045 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1047 static CK_RV CK_ENTRY

  1048 __ADJOIN(MODULE_NAME,C_DigestFinal)

  1049 (

  1050   CK_SESSION_HANDLE hSession,

  1051   CK_BYTE_PTR pDigest,

  1052   CK_ULONG_PTR pulDigestLen

  1053 )

  1054 {

  1055   return NSSCKFWC_DigestFinal(fwInstance, hSession, pDigest, pulDigestLen);

  1056 }

  1058 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1059 CK_RV CK_ENTRY

  1060 C_DigestFinal

  1061 (

  1062   CK_SESSION_HANDLE hSession,

  1063   CK_BYTE_PTR pDigest,

  1064   CK_ULONG_PTR pulDigestLen

  1065 )

  1066 {

  1067   return __ADJOIN(MODULE_NAME,C_DigestFinal)(hSession, pDigest, pulDigestLen);

  1068 }

  1069 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1071 static CK_RV CK_ENTRY

  1072 __ADJOIN(MODULE_NAME,C_SignInit)

  1073 (

  1074   CK_SESSION_HANDLE hSession,

  1075   CK_MECHANISM_PTR pMechanism,

  1076   CK_OBJECT_HANDLE hKey

  1077 )

  1078 {

  1079   return NSSCKFWC_SignInit(fwInstance, hSession, pMechanism, hKey);

  1080 }

  1082 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1083 CK_RV CK_ENTRY

  1084 C_SignInit

  1085 (

  1086   CK_SESSION_HANDLE hSession,

  1087   CK_MECHANISM_PTR pMechanism,

  1088   CK_OBJECT_HANDLE hKey

  1089 )

  1090 {

  1091   return __ADJOIN(MODULE_NAME,C_SignInit)(hSession, pMechanism, hKey);

  1092 }

  1093 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1095 static CK_RV CK_ENTRY

  1096 __ADJOIN(MODULE_NAME,C_Sign)

  1097 (

  1098   CK_SESSION_HANDLE hSession,

  1099   CK_BYTE_PTR pData,

  1100   CK_ULONG ulDataLen,

  1101   CK_BYTE_PTR pSignature,

  1102   CK_ULONG_PTR pulSignatureLen

  1103 )

  1104 {

  1105   return NSSCKFWC_Sign(fwInstance, hSession, pData, ulDataLen, pSignature, pulSignatureLen);

  1106 }

  1108 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1109 CK_RV CK_ENTRY

  1110 C_Sign

  1111 (

  1112   CK_SESSION_HANDLE hSession,

  1113   CK_BYTE_PTR pData,

  1114   CK_ULONG ulDataLen,

  1115   CK_BYTE_PTR pSignature,

  1116   CK_ULONG_PTR pulSignatureLen

  1117 )

  1118 {

  1119   return __ADJOIN(MODULE_NAME,C_Sign)(hSession, pData, ulDataLen, pSignature, pulSignatureLen);

  1120 }

  1121 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1123 static CK_RV CK_ENTRY

  1124 __ADJOIN(MODULE_NAME,C_SignUpdate)

  1125 (

  1126   CK_SESSION_HANDLE hSession,

  1127   CK_BYTE_PTR pPart,

  1128   CK_ULONG ulPartLen

  1129 )

  1130 {

  1131   return NSSCKFWC_SignUpdate(fwInstance, hSession, pPart, ulPartLen);

  1132 }

  1134 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1135 CK_RV CK_ENTRY

  1136 C_SignUpdate

  1137 (

  1138   CK_SESSION_HANDLE hSession,

  1139   CK_BYTE_PTR pPart,

  1140   CK_ULONG ulPartLen

  1141 )

  1142 {

  1143   return __ADJOIN(MODULE_NAME,C_SignUpdate)(hSession, pPart, ulPartLen);

  1144 }

  1145 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1147 static CK_RV CK_ENTRY

  1148 __ADJOIN(MODULE_NAME,C_SignFinal)

  1149 (

  1150   CK_SESSION_HANDLE hSession,

  1151   CK_BYTE_PTR pSignature,

  1152   CK_ULONG_PTR pulSignatureLen

  1153 )

  1154 {

  1155   return NSSCKFWC_SignFinal(fwInstance, hSession, pSignature, pulSignatureLen);

  1156 }

  1158 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1159 CK_RV CK_ENTRY

  1160 C_SignFinal

  1161 (

  1162   CK_SESSION_HANDLE hSession,

  1163   CK_BYTE_PTR pSignature,

  1164   CK_ULONG_PTR pulSignatureLen

  1165 )

  1166 {

  1167   return __ADJOIN(MODULE_NAME,C_SignFinal)(hSession, pSignature, pulSignatureLen);

  1168 }

  1169 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1171 static CK_RV CK_ENTRY

  1172 __ADJOIN(MODULE_NAME,C_SignRecoverInit)

  1173 (

  1174   CK_SESSION_HANDLE hSession,

  1175   CK_MECHANISM_PTR pMechanism,

  1176   CK_OBJECT_HANDLE hKey

  1177 )

  1178 {

  1179   return NSSCKFWC_SignRecoverInit(fwInstance, hSession, pMechanism, hKey);

  1180 }

  1182 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1183 CK_RV CK_ENTRY

  1184 C_SignRecoverInit

  1185 (

  1186   CK_SESSION_HANDLE hSession,

  1187   CK_MECHANISM_PTR pMechanism,

  1188   CK_OBJECT_HANDLE hKey

  1189 )

  1190 {

  1191   return __ADJOIN(MODULE_NAME,C_SignRecoverInit)(hSession, pMechanism, hKey);

  1192 }

  1193 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1195 static CK_RV CK_ENTRY

  1196 __ADJOIN(MODULE_NAME,C_SignRecover)

  1197 (

  1198   CK_SESSION_HANDLE hSession,

  1199   CK_BYTE_PTR pData,

  1200   CK_ULONG ulDataLen,

  1201   CK_BYTE_PTR pSignature,

  1202   CK_ULONG_PTR pulSignatureLen

  1203 )

  1204 {

  1205   return NSSCKFWC_SignRecover(fwInstance, hSession, pData, ulDataLen, pSignature, pulSignatureLen);

  1206 }

  1208 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1209 CK_RV CK_ENTRY

  1210 C_SignRecover

  1211 (

  1212   CK_SESSION_HANDLE hSession,

  1213   CK_BYTE_PTR pData,

  1214   CK_ULONG ulDataLen,

  1215   CK_BYTE_PTR pSignature,

  1216   CK_ULONG_PTR pulSignatureLen

  1217 )

  1218 {

  1219   return __ADJOIN(MODULE_NAME,C_SignRecover)(hSession, pData, ulDataLen, pSignature, pulSignatureLen);

  1220 }

  1221 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1223 static CK_RV CK_ENTRY

  1224 __ADJOIN(MODULE_NAME,C_VerifyInit)

  1225 (

  1226   CK_SESSION_HANDLE hSession,

  1227   CK_MECHANISM_PTR pMechanism,

  1228   CK_OBJECT_HANDLE hKey

  1229 )

  1230 {

  1231   return NSSCKFWC_VerifyInit(fwInstance, hSession, pMechanism, hKey);

  1232 }

  1234 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1235 CK_RV CK_ENTRY

  1236 C_VerifyInit

  1237 (

  1238   CK_SESSION_HANDLE hSession,

  1239   CK_MECHANISM_PTR pMechanism,

  1240   CK_OBJECT_HANDLE hKey

  1241 )

  1242 {

  1243   return __ADJOIN(MODULE_NAME,C_VerifyInit)(hSession, pMechanism, hKey);

  1244 }

  1245 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1247 static CK_RV CK_ENTRY

  1248 __ADJOIN(MODULE_NAME,C_Verify)

  1249 (

  1250   CK_SESSION_HANDLE hSession,

  1251   CK_BYTE_PTR pData,

  1252   CK_ULONG ulDataLen,

  1253   CK_BYTE_PTR pSignature,

  1254   CK_ULONG ulSignatureLen

  1255 )

  1256 {

  1257   return NSSCKFWC_Verify(fwInstance, hSession, pData, ulDataLen, pSignature, ulSignatureLen);

  1258 }

  1260 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1261 CK_RV CK_ENTRY

  1262 C_Verify

  1263 (

  1264   CK_SESSION_HANDLE hSession,

  1265   CK_BYTE_PTR pData,

  1266   CK_ULONG ulDataLen,

  1267   CK_BYTE_PTR pSignature,

  1268   CK_ULONG ulSignatureLen

  1269 )

  1270 {

  1271   return __ADJOIN(MODULE_NAME,C_Verify)(hSession, pData, ulDataLen, pSignature, ulSignatureLen);

  1272 }

  1273 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1275 static CK_RV CK_ENTRY

  1276 __ADJOIN(MODULE_NAME,C_VerifyUpdate)

  1277 (

  1278   CK_SESSION_HANDLE hSession,

  1279   CK_BYTE_PTR pPart,

  1280   CK_ULONG ulPartLen

  1281 )

  1282 {

  1283   return NSSCKFWC_VerifyUpdate(fwInstance, hSession, pPart, ulPartLen);

  1284 }

  1286 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1287 CK_RV CK_ENTRY

  1288 C_VerifyUpdate

  1289 (

  1290   CK_SESSION_HANDLE hSession,

  1291   CK_BYTE_PTR pPart,

  1292   CK_ULONG ulPartLen

  1293 )

  1294 {

  1295   return __ADJOIN(MODULE_NAME,C_VerifyUpdate)(hSession, pPart, ulPartLen);

  1296 }

  1297 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1299 static CK_RV CK_ENTRY

  1300 __ADJOIN(MODULE_NAME,C_VerifyFinal)

  1301 (

  1302   CK_SESSION_HANDLE hSession,

  1303   CK_BYTE_PTR pSignature,

  1304   CK_ULONG ulSignatureLen

  1305 )

  1306 {

  1307   return NSSCKFWC_VerifyFinal(fwInstance, hSession, pSignature, ulSignatureLen);

  1308 }

  1310 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1311 CK_RV CK_ENTRY

  1312 C_VerifyFinal

  1313 (

  1314   CK_SESSION_HANDLE hSession,

  1315   CK_BYTE_PTR pSignature,

  1316   CK_ULONG ulSignatureLen

  1317 )

  1318 {

  1319   return __ADJOIN(MODULE_NAME,C_VerifyFinal)(hSession, pSignature, ulSignatureLen);

  1320 }

  1321 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1323 static CK_RV CK_ENTRY

  1324 __ADJOIN(MODULE_NAME,C_VerifyRecoverInit)

  1325 (

  1326   CK_SESSION_HANDLE hSession,

  1327   CK_MECHANISM_PTR pMechanism,

  1328   CK_OBJECT_HANDLE hKey

  1329 )

  1330 {

  1331   return NSSCKFWC_VerifyRecoverInit(fwInstance, hSession, pMechanism, hKey);

  1332 }

  1334 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1335 CK_RV CK_ENTRY

  1336 C_VerifyRecoverInit

  1337 (

  1338   CK_SESSION_HANDLE hSession,

  1339   CK_MECHANISM_PTR pMechanism,

  1340   CK_OBJECT_HANDLE hKey

  1341 )

  1342 {

  1343   return __ADJOIN(MODULE_NAME,C_VerifyRecoverInit)(hSession, pMechanism, hKey);

  1344 }

  1345 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1347 static CK_RV CK_ENTRY

  1348 __ADJOIN(MODULE_NAME,C_VerifyRecover)

  1349 (

  1350   CK_SESSION_HANDLE hSession,

  1351   CK_BYTE_PTR pSignature,

  1352   CK_ULONG ulSignatureLen,

  1353   CK_BYTE_PTR pData,

  1354   CK_ULONG_PTR pulDataLen

  1355 )

  1356 {

  1357   return NSSCKFWC_VerifyRecover(fwInstance, hSession, pSignature, ulSignatureLen, pData, pulDataLen);

  1358 }

  1360 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1361 CK_RV CK_ENTRY

  1362 C_VerifyRecover

  1363 (

  1364   CK_SESSION_HANDLE hSession,

  1365   CK_BYTE_PTR pSignature,

  1366   CK_ULONG ulSignatureLen,

  1367   CK_BYTE_PTR pData,

  1368   CK_ULONG_PTR pulDataLen

  1369 )

  1370 {

  1371   return __ADJOIN(MODULE_NAME,C_VerifyRecover)(hSession, pSignature, ulSignatureLen, pData, pulDataLen);

  1372 }

  1373 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1375 static CK_RV CK_ENTRY

  1376 __ADJOIN(MODULE_NAME,C_DigestEncryptUpdate)

  1377 (

  1378   CK_SESSION_HANDLE hSession,

  1379   CK_BYTE_PTR pPart,

  1380   CK_ULONG ulPartLen,

  1381   CK_BYTE_PTR pEncryptedPart,

  1382   CK_ULONG_PTR pulEncryptedPartLen

  1383 )

  1384 {

  1385   return NSSCKFWC_DigestEncryptUpdate(fwInstance, hSession, pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen);

  1386 }

  1388 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1389 CK_RV CK_ENTRY

  1390 C_DigestEncryptUpdate

  1391 (

  1392   CK_SESSION_HANDLE hSession,

  1393   CK_BYTE_PTR pPart,

  1394   CK_ULONG ulPartLen,

  1395   CK_BYTE_PTR pEncryptedPart,

  1396   CK_ULONG_PTR pulEncryptedPartLen

  1397 )

  1398 {

  1399   return __ADJOIN(MODULE_NAME,C_DigestEncryptUpdate)(hSession, pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen);

  1400 }

  1401 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1403 static CK_RV CK_ENTRY

  1404 __ADJOIN(MODULE_NAME,C_DecryptDigestUpdate)

  1405 (

  1406   CK_SESSION_HANDLE hSession,

  1407   CK_BYTE_PTR pEncryptedPart,

  1408   CK_ULONG ulEncryptedPartLen,

  1409   CK_BYTE_PTR pPart,

  1410   CK_ULONG_PTR pulPartLen

  1411 )

  1412 {

  1413   return NSSCKFWC_DecryptDigestUpdate(fwInstance, hSession, pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen);

  1414 }

  1416 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1417 CK_RV CK_ENTRY

  1418 C_DecryptDigestUpdate

  1419 (

  1420   CK_SESSION_HANDLE hSession,

  1421   CK_BYTE_PTR pEncryptedPart,

  1422   CK_ULONG ulEncryptedPartLen,

  1423   CK_BYTE_PTR pPart,

  1424   CK_ULONG_PTR pulPartLen

  1425 )

  1426 {

  1427   return __ADJOIN(MODULE_NAME,C_DecryptDigestUpdate)(hSession, pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen);

  1428 }

  1429 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1431 static CK_RV CK_ENTRY

  1432 __ADJOIN(MODULE_NAME,C_SignEncryptUpdate)

  1433 (

  1434   CK_SESSION_HANDLE hSession,

  1435   CK_BYTE_PTR pPart,

  1436   CK_ULONG ulPartLen,

  1437   CK_BYTE_PTR pEncryptedPart,

  1438   CK_ULONG_PTR pulEncryptedPartLen

  1439 )

  1440 {

  1441   return NSSCKFWC_SignEncryptUpdate(fwInstance, hSession, pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen);

  1442 }

  1444 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1445 CK_RV CK_ENTRY

  1446 C_SignEncryptUpdate

  1447 (

  1448   CK_SESSION_HANDLE hSession,

  1449   CK_BYTE_PTR pPart,

  1450   CK_ULONG ulPartLen,

  1451   CK_BYTE_PTR pEncryptedPart,

  1452   CK_ULONG_PTR pulEncryptedPartLen

  1453 )

  1454 {

  1455   return __ADJOIN(MODULE_NAME,C_SignEncryptUpdate)(hSession, pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen);

  1456 }

  1457 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1459 static CK_RV CK_ENTRY

  1460 __ADJOIN(MODULE_NAME,C_DecryptVerifyUpdate)

  1461 (

  1462   CK_SESSION_HANDLE hSession,

  1463   CK_BYTE_PTR pEncryptedPart,

  1464   CK_ULONG ulEncryptedPartLen,

  1465   CK_BYTE_PTR pPart,

  1466   CK_ULONG_PTR pulPartLen

  1467 )

  1468 {

  1469   return NSSCKFWC_DecryptVerifyUpdate(fwInstance, hSession, pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen);

  1470 }

  1472 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1473 CK_RV CK_ENTRY

  1474 C_DecryptVerifyUpdate

  1475 (

  1476   CK_SESSION_HANDLE hSession,

  1477   CK_BYTE_PTR pEncryptedPart,

  1478   CK_ULONG ulEncryptedPartLen,

  1479   CK_BYTE_PTR pPart,

  1480   CK_ULONG_PTR pulPartLen

  1481 )

  1482 {

  1483   return __ADJOIN(MODULE_NAME,C_DecryptVerifyUpdate)(hSession, pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen);

  1484 }

  1485 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1487 static CK_RV CK_ENTRY

  1488 __ADJOIN(MODULE_NAME,C_GenerateKey)

  1489 (

  1490   CK_SESSION_HANDLE hSession,

  1491   CK_MECHANISM_PTR pMechanism,

  1492   CK_ATTRIBUTE_PTR pTemplate,

  1493   CK_ULONG ulCount,

  1494   CK_OBJECT_HANDLE_PTR phKey

  1495 )

  1496 {

  1497   return NSSCKFWC_GenerateKey(fwInstance, hSession, pMechanism, pTemplate, ulCount, phKey);

  1498 }

  1500 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1501 CK_RV CK_ENTRY

  1502 C_GenerateKey

  1503 (

  1504   CK_SESSION_HANDLE hSession,

  1505   CK_MECHANISM_PTR pMechanism,

  1506   CK_ATTRIBUTE_PTR pTemplate,

  1507   CK_ULONG ulCount,

  1508   CK_OBJECT_HANDLE_PTR phKey

  1509 )

  1510 {

  1511   return __ADJOIN(MODULE_NAME,C_GenerateKey)(hSession, pMechanism, pTemplate, ulCount, phKey);

  1512 }

  1513 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1515 static CK_RV CK_ENTRY

  1516 __ADJOIN(MODULE_NAME,C_GenerateKeyPair)

  1517 (

  1518   CK_SESSION_HANDLE hSession,

  1519   CK_MECHANISM_PTR pMechanism,

  1520   CK_ATTRIBUTE_PTR pPublicKeyTemplate,

  1521   CK_ULONG ulPublicKeyAttributeCount,

  1522   CK_ATTRIBUTE_PTR pPrivateKeyTemplate,

  1523   CK_ULONG ulPrivateKeyAttributeCount,

  1524   CK_OBJECT_HANDLE_PTR phPublicKey,

  1525   CK_OBJECT_HANDLE_PTR phPrivateKey

  1526 )

  1527 {

  1528   return NSSCKFWC_GenerateKeyPair(fwInstance, hSession, pMechanism, pPublicKeyTemplate, ulPublicKeyAttributeCount, pPrivateKeyTemplate, ulPrivateKeyAttributeCount, phPublicKey, phPrivateKey);

  1529 }

  1531 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1532 CK_RV CK_ENTRY

  1533 C_GenerateKeyPair

  1534 (

  1535   CK_SESSION_HANDLE hSession,

  1536   CK_MECHANISM_PTR pMechanism,

  1537   CK_ATTRIBUTE_PTR pPublicKeyTemplate,

  1538   CK_ULONG ulPublicKeyAttributeCount,

  1539   CK_ATTRIBUTE_PTR pPrivateKeyTemplate,

  1540   CK_ULONG ulPrivateKeyAttributeCount,

  1541   CK_OBJECT_HANDLE_PTR phPublicKey,

  1542   CK_OBJECT_HANDLE_PTR phPrivateKey

  1543 )

  1544 {

  1545   return __ADJOIN(MODULE_NAME,C_GenerateKeyPair)(hSession, pMechanism, pPublicKeyTemplate, ulPublicKeyAttributeCount, pPrivateKeyTemplate, ulPrivateKeyAttributeCount, phPublicKey, phPrivateKey);

  1546 }

  1547 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1549 static CK_RV CK_ENTRY

  1550 __ADJOIN(MODULE_NAME,C_WrapKey)

  1551 (

  1552   CK_SESSION_HANDLE hSession,

  1553   CK_MECHANISM_PTR pMechanism,

  1554   CK_OBJECT_HANDLE hWrappingKey,

  1555   CK_OBJECT_HANDLE hKey,

  1556   CK_BYTE_PTR pWrappedKey,

  1557   CK_ULONG_PTR pulWrappedKeyLen

  1558 )

  1559 {

  1560   return NSSCKFWC_WrapKey(fwInstance, hSession, pMechanism, hWrappingKey, hKey, pWrappedKey, pulWrappedKeyLen);

  1561 }

  1563 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1564 CK_RV CK_ENTRY

  1565 C_WrapKey

  1566 (

  1567   CK_SESSION_HANDLE hSession,

  1568   CK_MECHANISM_PTR pMechanism,

  1569   CK_OBJECT_HANDLE hWrappingKey,

  1570   CK_OBJECT_HANDLE hKey,

  1571   CK_BYTE_PTR pWrappedKey,

  1572   CK_ULONG_PTR pulWrappedKeyLen

  1573 )

  1574 {

  1575   return __ADJOIN(MODULE_NAME,C_WrapKey)(hSession, pMechanism, hWrappingKey, hKey, pWrappedKey, pulWrappedKeyLen);

  1576 }

  1577 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1579 static CK_RV CK_ENTRY

  1580 __ADJOIN(MODULE_NAME,C_UnwrapKey)

  1581 (

  1582   CK_SESSION_HANDLE hSession,

  1583   CK_MECHANISM_PTR pMechanism,

  1584   CK_OBJECT_HANDLE hUnwrappingKey,

  1585   CK_BYTE_PTR pWrappedKey,

  1586   CK_ULONG ulWrappedKeyLen,

  1587   CK_ATTRIBUTE_PTR pTemplate,

  1588   CK_ULONG ulAttributeCount,

  1589   CK_OBJECT_HANDLE_PTR phKey

  1590 )

  1591 {

  1592   return NSSCKFWC_UnwrapKey(fwInstance, hSession, pMechanism, hUnwrappingKey, pWrappedKey, ulWrappedKeyLen, pTemplate, ulAttributeCount, phKey);

  1593 }

  1595 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1596 CK_RV CK_ENTRY

  1597 C_UnwrapKey

  1598 (

  1599   CK_SESSION_HANDLE hSession,

  1600   CK_MECHANISM_PTR pMechanism,

  1601   CK_OBJECT_HANDLE hUnwrappingKey,

  1602   CK_BYTE_PTR pWrappedKey,

  1603   CK_ULONG ulWrappedKeyLen,

  1604   CK_ATTRIBUTE_PTR pTemplate,

  1605   CK_ULONG ulAttributeCount,

  1606   CK_OBJECT_HANDLE_PTR phKey

  1607 )

  1608 {

  1609   return __ADJOIN(MODULE_NAME,C_UnwrapKey)(hSession, pMechanism, hUnwrappingKey, pWrappedKey, ulWrappedKeyLen, pTemplate, ulAttributeCount, phKey);

  1610 }

  1611 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1613 static CK_RV CK_ENTRY

  1614 __ADJOIN(MODULE_NAME,C_DeriveKey)

  1615 (

  1616   CK_SESSION_HANDLE hSession,

  1617   CK_MECHANISM_PTR pMechanism,

  1618   CK_OBJECT_HANDLE hBaseKey,

  1619   CK_ATTRIBUTE_PTR pTemplate,

  1620   CK_ULONG ulAttributeCount,

  1621   CK_OBJECT_HANDLE_PTR phKey

  1622 )

  1623 {

  1624   return NSSCKFWC_DeriveKey(fwInstance, hSession, pMechanism, hBaseKey, pTemplate, ulAttributeCount, phKey);

  1625 }

  1627 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1628 CK_RV CK_ENTRY

  1629 C_DeriveKey

  1630 (

  1631   CK_SESSION_HANDLE hSession,

  1632   CK_MECHANISM_PTR pMechanism,

  1633   CK_OBJECT_HANDLE hBaseKey,

  1634   CK_ATTRIBUTE_PTR pTemplate,

  1635   CK_ULONG ulAttributeCount,

  1636   CK_OBJECT_HANDLE_PTR phKey

  1637 )

  1638 {

  1639   return __ADJOIN(MODULE_NAME,C_DeriveKey)(hSession, pMechanism, hBaseKey, pTemplate, ulAttributeCount, phKey);

  1640 }

  1641 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1643 static CK_RV CK_ENTRY

  1644 __ADJOIN(MODULE_NAME,C_SeedRandom)

  1645 (

  1646   CK_SESSION_HANDLE hSession,

  1647   CK_BYTE_PTR pSeed,

  1648   CK_ULONG ulSeedLen

  1649 )

  1650 {

  1651   return NSSCKFWC_SeedRandom(fwInstance, hSession, pSeed, ulSeedLen);

  1652 }

  1654 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1655 CK_RV CK_ENTRY

  1656 C_SeedRandom

  1657 (

  1658   CK_SESSION_HANDLE hSession,

  1659   CK_BYTE_PTR pSeed,

  1660   CK_ULONG ulSeedLen

  1661 )

  1662 {

  1663   return __ADJOIN(MODULE_NAME,C_SeedRandom)(hSession, pSeed, ulSeedLen);

  1664 }

  1665 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1667 static CK_RV CK_ENTRY

  1668 __ADJOIN(MODULE_NAME,C_GenerateRandom)

  1669 (

  1670   CK_SESSION_HANDLE hSession,

  1671   CK_BYTE_PTR RandomData,

  1672   CK_ULONG ulRandomLen

  1673 )

  1674 {

  1675   return NSSCKFWC_GenerateRandom(fwInstance, hSession, RandomData, ulRandomLen);

  1676 }

  1678 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1679 CK_RV CK_ENTRY

  1680 C_GenerateRandom

  1681 (

  1682   CK_SESSION_HANDLE hSession,

  1683   CK_BYTE_PTR RandomData,

  1684   CK_ULONG ulRandomLen

  1685 )

  1686 {

  1687   return __ADJOIN(MODULE_NAME,C_GenerateRandom)(hSession, RandomData, ulRandomLen);

  1688 }

  1689 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1691 static CK_RV CK_ENTRY

  1692 __ADJOIN(MODULE_NAME,C_GetFunctionStatus)

  1693 (

  1694   CK_SESSION_HANDLE hSession

  1695 )

  1696 {

  1697   return NSSCKFWC_GetFunctionStatus(fwInstance, hSession);

  1698 }

  1700 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1701 CK_RV CK_ENTRY

  1702 C_GetFunctionStatus

  1703 (

  1704   CK_SESSION_HANDLE hSession

  1705 )

  1706 {

  1707   return __ADJOIN(MODULE_NAME,C_GetFunctionStatus)(hSession);

  1708 }

  1709 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1711 static CK_RV CK_ENTRY

  1712 __ADJOIN(MODULE_NAME,C_CancelFunction)

  1713 (

  1714   CK_SESSION_HANDLE hSession

  1715 )

  1716 {

  1717   return NSSCKFWC_CancelFunction(fwInstance, hSession);

  1718 }

  1720 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1721 CK_RV CK_ENTRY

  1722 C_CancelFunction

  1723 (

  1724   CK_SESSION_HANDLE hSession

  1725 )

  1726 {

  1727   return __ADJOIN(MODULE_NAME,C_CancelFunction)(hSession);

  1728 }

  1729 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1731 static CK_RV CK_ENTRY

  1732 __ADJOIN(MODULE_NAME,C_WaitForSlotEvent)

  1733 (

  1734   CK_FLAGS flags,

  1735   CK_SLOT_ID_PTR pSlot,

  1736   CK_VOID_PTR pRserved

  1737 )

  1738 {

  1739   return NSSCKFWC_WaitForSlotEvent(fwInstance, flags, pSlot, pRserved);

  1740 }

  1742 #ifdef DECLARE_STRICT_CRYPTOKI_NAMES

  1743 CK_RV CK_ENTRY

  1744 C_WaitForSlotEvent

  1745 (

  1746   CK_FLAGS flags,

  1747   CK_SLOT_ID_PTR pSlot,

  1748   CK_VOID_PTR pRserved

  1749 )

  1750 {

  1751   return __ADJOIN(MODULE_NAME,C_WaitForSlotEvent)(flags, pSlot, pRserved);

  1752 }

  1753 #endif /* DECLARE_STRICT_CRYPTOKI_NAMES */

  1755 static CK_RV CK_ENTRY

  1756 __ADJOIN(MODULE_NAME,C_GetFunctionList)

  1757 (

  1758   CK_FUNCTION_LIST_PTR_PTR ppFunctionList

  1759 );

  1761 static CK_FUNCTION_LIST FunctionList = {

  1762   { 2, 1 },

  1763 __ADJOIN(MODULE_NAME,C_Initialize),

  1764 __ADJOIN(MODULE_NAME,C_Finalize),

  1765 __ADJOIN(MODULE_NAME,C_GetInfo),

  1766 __ADJOIN(MODULE_NAME,C_GetFunctionList),

  1767 __ADJOIN(MODULE_NAME,C_GetSlotList),

  1768 __ADJOIN(MODULE_NAME,C_GetSlotInfo),

  1769 __ADJOIN(MODULE_NAME,C_GetTokenInfo),

  1770 __ADJOIN(MODULE_NAME,C_GetMechanismList),

  1771 __ADJOIN(MODULE_NAME,C_GetMechanismInfo),

  1772 __ADJOIN(MODULE_NAME,C_InitToken),

  1773 __ADJOIN(MODULE_NAME,C_InitPIN),

  1774 __ADJOIN(MODULE_NAME,C_SetPIN),

  1775 __ADJOIN(MODULE_NAME,C_OpenSession),

  1776 __ADJOIN(MODULE_NAME,C_CloseSession),

  1777 __ADJOIN(MODULE_NAME,C_CloseAllSessions),

  1778 __ADJOIN(MODULE_NAME,C_GetSessionInfo),

  1779 __ADJOIN(MODULE_NAME,C_GetOperationState),

  1780 __ADJOIN(MODULE_NAME,C_SetOperationState),

  1781 __ADJOIN(MODULE_NAME,C_Login),

  1782 __ADJOIN(MODULE_NAME,C_Logout),

  1783 __ADJOIN(MODULE_NAME,C_CreateObject),

  1784 __ADJOIN(MODULE_NAME,C_CopyObject),

  1785 __ADJOIN(MODULE_NAME,C_DestroyObject),

  1786 __ADJOIN(MODULE_NAME,C_GetObjectSize),

  1787 __ADJOIN(MODULE_NAME,C_GetAttributeValue),

  1788 __ADJOIN(MODULE_NAME,C_SetAttributeValue),

  1789 __ADJOIN(MODULE_NAME,C_FindObjectsInit),

  1790 __ADJOIN(MODULE_NAME,C_FindObjects),

  1791 __ADJOIN(MODULE_NAME,C_FindObjectsFinal),

  1792 __ADJOIN(MODULE_NAME,C_EncryptInit),

  1793 __ADJOIN(MODULE_NAME,C_Encrypt),

  1794 __ADJOIN(MODULE_NAME,C_EncryptUpdate),

  1795 __ADJOIN(MODULE_NAME,C_EncryptFinal),

  1796 __ADJOIN(MODULE_NAME,C_DecryptInit),

  1797 __ADJOIN(MODULE_NAME,C_Decrypt),

  1798 __ADJOIN(MODULE_NAME,C_DecryptUpdate),

  1799 __ADJOIN(MODULE_NAME,C_DecryptFinal),

  1800 __ADJOIN(MODULE_NAME,C_DigestInit),

  1801 __ADJOIN(MODULE_NAME,C_Digest),

  1802 __ADJOIN(MODULE_NAME,C_DigestUpdate),

  1803 __ADJOIN(MODULE_NAME,C_DigestKey),

  1804 __ADJOIN(MODULE_NAME,C_DigestFinal),

  1805 __ADJOIN(MODULE_NAME,C_SignInit),

  1806 __ADJOIN(MODULE_NAME,C_Sign),

  1807 __ADJOIN(MODULE_NAME,C_SignUpdate),

  1808 __ADJOIN(MODULE_NAME,C_SignFinal),

  1809 __ADJOIN(MODULE_NAME,C_SignRecoverInit),

  1810 __ADJOIN(MODULE_NAME,C_SignRecover),

  1811 __ADJOIN(MODULE_NAME,C_VerifyInit),

  1812 __ADJOIN(MODULE_NAME,C_Verify),

  1813 __ADJOIN(MODULE_NAME,C_VerifyUpdate),

  1814 __ADJOIN(MODULE_NAME,C_VerifyFinal),

  1815 __ADJOIN(MODULE_NAME,C_VerifyRecoverInit),

  1816 __ADJOIN(MODULE_NAME,C_VerifyRecover),

  1817 __ADJOIN(MODULE_NAME,C_DigestEncryptUpdate),

  1818 __ADJOIN(MODULE_NAME,C_DecryptDigestUpdate),

  1819 __ADJOIN(MODULE_NAME,C_SignEncryptUpdate),

  1820 __ADJOIN(MODULE_NAME,C_DecryptVerifyUpdate),

  1821 __ADJOIN(MODULE_NAME,C_GenerateKey),

  1822 __ADJOIN(MODULE_NAME,C_GenerateKeyPair),

  1823 __ADJOIN(MODULE_NAME,C_WrapKey),

  1824 __ADJOIN(MODULE_NAME,C_UnwrapKey),

  1825 __ADJOIN(MODULE_NAME,C_DeriveKey),

  1826 __ADJOIN(MODULE_NAME,C_SeedRandom),

  1827 __ADJOIN(MODULE_NAME,C_GenerateRandom),

  1828 __ADJOIN(MODULE_NAME,C_GetFunctionStatus),

  1829 __ADJOIN(MODULE_NAME,C_CancelFunction),

  1830 __ADJOIN(MODULE_NAME,C_WaitForSlotEvent)

  1831 };

  1833 static CK_RV CK_ENTRY

  1834 __ADJOIN(MODULE_NAME,C_GetFunctionList)

  1835 (

  1836   CK_FUNCTION_LIST_PTR_PTR ppFunctionList

  1837 )

  1838 {

  1839   *ppFunctionList = &FunctionList;

  1840   return CKR_OK;

  1841 }

  1843 /* This one is always present */

  1844 CK_RV CK_ENTRY

  1845 C_GetFunctionList

  1846 (

  1847   CK_FUNCTION_LIST_PTR_PTR ppFunctionList

  1848 )

  1849 {

  1850   return __ADJOIN(MODULE_NAME,C_GetFunctionList)(ppFunctionList);

  1851 }

  1853 #undef __ADJOIN

The Tor Browser / file revision

security/nss/lib/ckfw/nssck.api@6474c204b198

security/nss/lib/ckfw/nssck.api