PageRenderTime 201ms CodeModel.GetById 115ms app.highlight 13ms RepoModel.GetById 67ms app.codeStats 1ms

/gecko_api/include/nssck.api

http://firefox-mac-pdf.googlecode.com/
Unknown | 1890 lines | 1737 code | 153 blank | 0 comment | 0 complexity | 5be327e83134479d348f3515004c3aa5 MD5 | raw file
   1/* THIS IS A GENERATED FILE */
   2/* ***** BEGIN LICENSE BLOCK *****
   3 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4 *
   5 * The contents of this file are subject to the Mozilla Public License Version
   6 * 1.1 (the "License"); you may not use this file except in compliance with
   7 * the License. You may obtain a copy of the License at
   8 * http://www.mozilla.org/MPL/
   9 *
  10 * Software distributed under the License is distributed on an "AS IS" basis,
  11 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12 * for the specific language governing rights and limitations under the
  13 * License.
  14 *
  15 * The Original Code is the Netscape security libraries.
  16 *
  17 * The Initial Developer of the Original Code is
  18 * Netscape Communications Corporation.
  19 * Portions created by the Initial Developer are Copyright (C) 1994-2000
  20 * the Initial Developer. All Rights Reserved.
  21 *
  22 * Contributor(s):
  23 *
  24 * Alternatively, the contents of this file may be used under the terms of
  25 * either the GNU General Public License Version 2 or later (the "GPL"), or
  26 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27 * in which case the provisions of the GPL or the LGPL are applicable instead
  28 * of those above. If you wish to allow use of your version of this file only
  29 * under the terms of either the GPL or the LGPL, and not to allow others to
  30 * use your version of this file under the terms of the MPL, indicate your
  31 * decision by deleting the provisions above and replace them with the notice
  32 * and other provisions required by the GPL or the LGPL. If you do not delete
  33 * the provisions above, a recipient may use your version of this file under
  34 * the terms of any one of the MPL, the GPL or the LGPL.
  35 *
  36 * ***** END LICENSE BLOCK ***** */
  37
  38#ifdef DEBUG
  39static const char NSSCKAPI_CVS_ID[] = "@(#) $RCSfile: nssck.api,v $ $Revision: 1.7 $ $Date: 2005/02/02 22:28:11 $ ; @(#) $RCSfile: nssck.api,v $ $Revision: 1.7 $ $Date: 2005/02/02 22:28:11 $";
  40#endif /* DEBUG */
  41
  42/*
  43 * nssck.api
  44 *
  45 * This automatically-generated file is used to generate a set of
  46 * Cryptoki entry points within the object space of a Module using
  47 * the NSS Cryptoki Framework.
  48 *
  49 * The Module should have a .c file with the following:
  50 *
  51 *  #define MODULE_NAME name
  52 *  #define INSTANCE_NAME instance
  53 *  #include "nssck.api"
  54 *
  55 * where "name" is some module-specific name that can be used to
  56 * disambiguate various modules.  This included file will then
  57 * define the actual Cryptoki routines which pass through to the
  58 * Framework calls.  All routines, except C_GetFunctionList, will
  59 * be prefixed with the name; C_GetFunctionList will be generated
  60 * to return an entry-point vector with these routines.  The
  61 * instance specified should be the basic instance of NSSCKMDInstance.
  62 *
  63 * If, prior to including nssck.api, the .c file also specifies
  64 *
  65 *  #define DECLARE_STRICT_CRYTPOKI_NAMES
  66 *
  67 * Then a set of "stub" routines not prefixed with the name will
  68 * be included.  This would allow the combined module and framework
  69 * to be used in applications which are hard-coded to use the
  70 * PKCS#11 names (instead of going through the EPV).  Please note
  71 * that such applications should be careful resolving symbols when
  72 * more than one PKCS#11 module is loaded.
  73 */
  74
  75#ifndef MODULE_NAME
  76#error "Error: MODULE_NAME must be defined."
  77#endif /* MODULE_NAME */
  78
  79#ifndef INSTANCE_NAME
  80#error "Error: INSTANCE_NAME must be defined."
  81#endif /* INSTANCE_NAME */
  82
  83#ifndef NSSCKT_H
  84#include "nssckt.h"
  85#endif /* NSSCKT_H */
  86
  87#ifndef NSSCKFWT_H
  88#include "nssckfwt.h"
  89#endif /* NSSCKFWT_H */
  90
  91#ifndef NSSCKFWC_H
  92#include "nssckfwc.h"
  93#endif /* NSSCKFWC_H */
  94
  95#ifndef NSSCKEPV_H
  96#include "nssckepv.h"
  97#endif /* NSSCKEPV_H */
  98
  99#define ADJOIN(x,y) x##y
 100
 101#define __ADJOIN(x,y) ADJOIN(x,y)
 102
 103/*
 104 * The anchor.  This object is used to store an "anchor" pointer in
 105 * the Module's object space, so the wrapper functions can relate
 106 * back to this instance.
 107 */
 108
 109static NSSCKFWInstance *fwInstance = (NSSCKFWInstance *)0;
 110
 111static CK_RV CK_ENTRY
 112__ADJOIN(MODULE_NAME,C_Initialize)
 113(
 114  CK_VOID_PTR pInitArgs
 115)
 116{
 117  return NSSCKFWC_Initialize(&fwInstance, INSTANCE_NAME, pInitArgs);
 118}
 119
 120#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 121CK_RV CK_ENTRY 
 122C_Initialize
 123(
 124  CK_VOID_PTR pInitArgs
 125)
 126{
 127  return __ADJOIN(MODULE_NAME,C_Initialize)(pInitArgs);
 128}
 129#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 130
 131static CK_RV CK_ENTRY
 132__ADJOIN(MODULE_NAME,C_Finalize)
 133(
 134  CK_VOID_PTR pReserved
 135)
 136{
 137  return NSSCKFWC_Finalize(&fwInstance);
 138}
 139
 140#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 141CK_RV CK_ENTRY
 142C_Finalize
 143(
 144  CK_VOID_PTR pReserved
 145)
 146{
 147  return __ADJOIN(MODULE_NAME,C_Finalize)(pReserved);
 148}
 149#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 150
 151static CK_RV CK_ENTRY
 152__ADJOIN(MODULE_NAME,C_GetInfo)
 153(
 154  CK_INFO_PTR pInfo
 155)
 156{
 157  return NSSCKFWC_GetInfo(fwInstance, pInfo);
 158}
 159
 160#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 161CK_RV CK_ENTRY
 162C_GetInfo
 163(
 164  CK_INFO_PTR pInfo
 165)
 166{
 167  return __ADJOIN(MODULE_NAME,C_GetInfo)(pInfo);
 168}
 169#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 170
 171/*
 172 * C_GetFunctionList is defined at the end.
 173 */
 174
 175static CK_RV CK_ENTRY
 176__ADJOIN(MODULE_NAME,C_GetSlotList)
 177(
 178  CK_BBOOL tokenPresent,
 179  CK_SLOT_ID_PTR pSlotList,
 180  CK_ULONG_PTR pulCount
 181)
 182{
 183  return NSSCKFWC_GetSlotList(fwInstance, tokenPresent, pSlotList, pulCount);
 184}
 185
 186#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 187CK_RV CK_ENTRY
 188C_GetSlotList
 189(
 190  CK_BBOOL tokenPresent,
 191  CK_SLOT_ID_PTR pSlotList,
 192  CK_ULONG_PTR pulCount
 193)
 194{
 195  return __ADJOIN(MODULE_NAME,C_GetSlotList)(tokenPresent, pSlotList, pulCount);
 196}
 197#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 198
 199static CK_RV CK_ENTRY
 200__ADJOIN(MODULE_NAME,C_GetSlotInfo)
 201(
 202  CK_SLOT_ID slotID,
 203  CK_SLOT_INFO_PTR pInfo
 204)
 205{
 206  return NSSCKFWC_GetSlotInfo(fwInstance, slotID, pInfo);
 207}
 208
 209#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 210CK_RV CK_ENTRY
 211C_GetSlotInfo
 212(
 213  CK_SLOT_ID slotID,
 214  CK_SLOT_INFO_PTR pInfo
 215)
 216{
 217  return __ADJOIN(MODULE_NAME,C_GetSlotInfo)(slotID, pInfo);
 218}
 219#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 220
 221static CK_RV CK_ENTRY
 222__ADJOIN(MODULE_NAME,C_GetTokenInfo)
 223(
 224  CK_SLOT_ID slotID,
 225  CK_TOKEN_INFO_PTR pInfo
 226)
 227{
 228  return NSSCKFWC_GetTokenInfo(fwInstance, slotID, pInfo);
 229}
 230
 231#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 232CK_RV CK_ENTRY
 233C_GetTokenInfo
 234(
 235  CK_SLOT_ID slotID,
 236  CK_TOKEN_INFO_PTR pInfo
 237)
 238{
 239  return __ADJOIN(MODULE_NAME,C_GetTokenInfo)(slotID, pInfo);
 240}
 241#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 242
 243static CK_RV CK_ENTRY
 244__ADJOIN(MODULE_NAME,C_GetMechanismList)
 245(
 246  CK_SLOT_ID slotID,
 247  CK_MECHANISM_TYPE_PTR pMechanismList,
 248  CK_ULONG_PTR pulCount
 249)
 250{
 251  return NSSCKFWC_GetMechanismList(fwInstance, slotID, pMechanismList, pulCount);
 252}
 253
 254#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 255CK_RV CK_ENTRY
 256C_GetMechanismList
 257(
 258  CK_SLOT_ID slotID,
 259  CK_MECHANISM_TYPE_PTR pMechanismList,
 260  CK_ULONG_PTR pulCount
 261)
 262{
 263  return __ADJOIN(MODULE_NAME,C_GetMechanismList)(slotID, pMechanismList, pulCount);
 264}
 265#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 266
 267static CK_RV CK_ENTRY
 268__ADJOIN(MODULE_NAME,C_GetMechanismInfo)
 269(
 270  CK_SLOT_ID slotID,
 271  CK_MECHANISM_TYPE type,
 272  CK_MECHANISM_INFO_PTR pInfo
 273)
 274{
 275  return NSSCKFWC_GetMechanismInfo(fwInstance, slotID, type, pInfo);
 276}
 277
 278#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 279CK_RV CK_ENTRY
 280C_GetMechanismInfo
 281(
 282  CK_SLOT_ID slotID,
 283  CK_MECHANISM_TYPE type,
 284  CK_MECHANISM_INFO_PTR pInfo
 285)
 286{
 287  return __ADJOIN(MODULE_NAME,C_GetMechanismInfo)(slotID, type, pInfo);
 288}
 289#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 290
 291static CK_RV CK_ENTRY
 292__ADJOIN(MODULE_NAME,C_InitToken)
 293(
 294  CK_SLOT_ID slotID,
 295  CK_CHAR_PTR pPin,
 296  CK_ULONG ulPinLen,
 297  CK_CHAR_PTR pLabel
 298)
 299{
 300  return NSSCKFWC_InitToken(fwInstance, slotID, pPin, ulPinLen, pLabel);
 301}
 302
 303#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 304CK_RV CK_ENTRY
 305C_InitToken
 306(
 307  CK_SLOT_ID slotID,
 308  CK_CHAR_PTR pPin,
 309  CK_ULONG ulPinLen,
 310  CK_CHAR_PTR pLabel
 311)
 312{
 313  return __ADJOIN(MODULE_NAME,C_InitToken)(slotID, pPin, ulPinLen, pLabel);
 314}
 315#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 316
 317static CK_RV CK_ENTRY
 318__ADJOIN(MODULE_NAME,C_InitPIN)
 319(
 320  CK_SESSION_HANDLE hSession,
 321  CK_CHAR_PTR pPin,
 322  CK_ULONG ulPinLen
 323)
 324{
 325  return NSSCKFWC_InitPIN(fwInstance, hSession, pPin, ulPinLen);
 326}
 327
 328#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 329CK_RV CK_ENTRY
 330C_InitPIN
 331(
 332  CK_SESSION_HANDLE hSession,
 333  CK_CHAR_PTR pPin,
 334  CK_ULONG ulPinLen
 335)
 336{
 337  return __ADJOIN(MODULE_NAME,C_InitPIN)(hSession, pPin, ulPinLen);
 338}
 339#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 340
 341static CK_RV CK_ENTRY
 342__ADJOIN(MODULE_NAME,C_SetPIN)
 343(
 344  CK_SESSION_HANDLE hSession,
 345  CK_CHAR_PTR pOldPin,
 346  CK_ULONG ulOldLen,
 347  CK_CHAR_PTR pNewPin,
 348  CK_ULONG ulNewLen
 349)
 350{
 351  return NSSCKFWC_SetPIN(fwInstance, hSession, pOldPin, ulOldLen, pNewPin, ulNewLen);
 352}
 353
 354#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 355CK_RV CK_ENTRY
 356C_SetPIN
 357(
 358  CK_SESSION_HANDLE hSession,
 359  CK_CHAR_PTR pOldPin,
 360  CK_ULONG ulOldLen,
 361  CK_CHAR_PTR pNewPin,
 362  CK_ULONG ulNewLen
 363)
 364{
 365  return __ADJOIN(MODULE_NAME,C_SetPIN)(hSession, pOldPin, ulOldLen, pNewPin, ulNewLen);
 366}
 367#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 368
 369static CK_RV CK_ENTRY
 370__ADJOIN(MODULE_NAME,C_OpenSession)
 371(
 372  CK_SLOT_ID slotID,
 373  CK_FLAGS flags,
 374  CK_VOID_PTR pApplication,
 375  CK_NOTIFY Notify,
 376  CK_SESSION_HANDLE_PTR phSession
 377)
 378{
 379  return NSSCKFWC_OpenSession(fwInstance, slotID, flags, pApplication, Notify, phSession);
 380}
 381
 382#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 383CK_RV CK_ENTRY
 384C_OpenSession
 385(
 386  CK_SLOT_ID slotID,
 387  CK_FLAGS flags,
 388  CK_VOID_PTR pApplication,
 389  CK_NOTIFY Notify,
 390  CK_SESSION_HANDLE_PTR phSession
 391)
 392{
 393  return __ADJOIN(MODULE_NAME,C_OpenSession)(slotID, flags, pApplication, Notify, phSession);
 394}
 395#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 396
 397static CK_RV CK_ENTRY
 398__ADJOIN(MODULE_NAME,C_CloseSession)
 399(
 400  CK_SESSION_HANDLE hSession
 401)
 402{
 403  return NSSCKFWC_CloseSession(fwInstance, hSession);
 404}
 405
 406#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 407CK_RV CK_ENTRY
 408C_CloseSession
 409(
 410  CK_SESSION_HANDLE hSession
 411)
 412{
 413  return __ADJOIN(MODULE_NAME,C_CloseSession)(hSession);
 414}
 415#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 416
 417static CK_RV CK_ENTRY
 418__ADJOIN(MODULE_NAME,C_CloseAllSessions)
 419(
 420  CK_SLOT_ID slotID
 421)
 422{
 423  return NSSCKFWC_CloseAllSessions(fwInstance, slotID);
 424}
 425
 426#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 427CK_RV CK_ENTRY
 428C_CloseAllSessions
 429(
 430  CK_SLOT_ID slotID
 431)
 432{
 433  return __ADJOIN(MODULE_NAME,C_CloseAllSessions)(slotID);
 434}
 435#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 436
 437static CK_RV CK_ENTRY
 438__ADJOIN(MODULE_NAME,C_GetSessionInfo)
 439(
 440  CK_SESSION_HANDLE hSession,
 441  CK_SESSION_INFO_PTR pInfo
 442)
 443{
 444  return NSSCKFWC_GetSessionInfo(fwInstance, hSession, pInfo);
 445}
 446
 447#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 448CK_RV CK_ENTRY
 449C_GetSessionInfo
 450(
 451  CK_SESSION_HANDLE hSession,
 452  CK_SESSION_INFO_PTR pInfo
 453)
 454{
 455  return __ADJOIN(MODULE_NAME,C_GetSessionInfo)(hSession, pInfo);
 456}
 457#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 458
 459static CK_RV CK_ENTRY
 460__ADJOIN(MODULE_NAME,C_GetOperationState)
 461(
 462  CK_SESSION_HANDLE hSession,
 463  CK_BYTE_PTR pOperationState,
 464  CK_ULONG_PTR pulOperationStateLen
 465)
 466{
 467  return NSSCKFWC_GetOperationState(fwInstance, hSession, pOperationState, pulOperationStateLen);
 468}
 469
 470#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 471CK_RV CK_ENTRY
 472C_GetOperationState
 473(
 474  CK_SESSION_HANDLE hSession,
 475  CK_BYTE_PTR pOperationState,
 476  CK_ULONG_PTR pulOperationStateLen
 477)
 478{
 479  return __ADJOIN(MODULE_NAME,C_GetOperationState)(hSession, pOperationState, pulOperationStateLen);
 480}
 481#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 482
 483static CK_RV CK_ENTRY
 484__ADJOIN(MODULE_NAME,C_SetOperationState)
 485(
 486  CK_SESSION_HANDLE hSession,
 487  CK_BYTE_PTR pOperationState,
 488  CK_ULONG ulOperationStateLen,
 489  CK_OBJECT_HANDLE hEncryptionKey,
 490  CK_OBJECT_HANDLE hAuthenticationKey
 491)
 492{
 493  return NSSCKFWC_SetOperationState(fwInstance, hSession, pOperationState, ulOperationStateLen, hEncryptionKey, hAuthenticationKey);
 494}
 495
 496#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 497CK_RV CK_ENTRY
 498C_SetOperationState
 499(
 500  CK_SESSION_HANDLE hSession,
 501  CK_BYTE_PTR pOperationState,
 502  CK_ULONG ulOperationStateLen,
 503  CK_OBJECT_HANDLE hEncryptionKey,
 504  CK_OBJECT_HANDLE hAuthenticationKey
 505)
 506{
 507  return __ADJOIN(MODULE_NAME,C_SetOperationState)(hSession, pOperationState, ulOperationStateLen, hEncryptionKey, hAuthenticationKey);
 508}
 509#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 510
 511static CK_RV CK_ENTRY
 512__ADJOIN(MODULE_NAME,C_Login)
 513(
 514  CK_SESSION_HANDLE hSession,
 515  CK_USER_TYPE userType,
 516  CK_CHAR_PTR pPin,
 517  CK_ULONG ulPinLen
 518)
 519{
 520  return NSSCKFWC_Login(fwInstance, hSession, userType, pPin, ulPinLen);
 521}
 522
 523#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 524CK_RV CK_ENTRY
 525C_Login
 526(
 527  CK_SESSION_HANDLE hSession,
 528  CK_USER_TYPE userType,
 529  CK_CHAR_PTR pPin,
 530  CK_ULONG ulPinLen
 531)
 532{
 533  return __ADJOIN(MODULE_NAME,C_Login)(hSession, userType, pPin, ulPinLen);
 534}
 535#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 536
 537static CK_RV CK_ENTRY
 538__ADJOIN(MODULE_NAME,C_Logout)
 539(
 540  CK_SESSION_HANDLE hSession
 541)
 542{
 543  return NSSCKFWC_Logout(fwInstance, hSession);
 544}
 545
 546#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 547CK_RV CK_ENTRY
 548C_Logout
 549(
 550  CK_SESSION_HANDLE hSession
 551)
 552{
 553  return __ADJOIN(MODULE_NAME,C_Logout)(hSession);
 554}
 555#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 556
 557static CK_RV CK_ENTRY
 558__ADJOIN(MODULE_NAME,C_CreateObject)
 559(
 560  CK_SESSION_HANDLE hSession,
 561  CK_ATTRIBUTE_PTR pTemplate,
 562  CK_ULONG ulCount,
 563  CK_OBJECT_HANDLE_PTR phObject
 564)
 565{
 566  return NSSCKFWC_CreateObject(fwInstance, hSession, pTemplate, ulCount, phObject);
 567}
 568
 569#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 570CK_RV CK_ENTRY
 571C_CreateObject
 572(
 573  CK_SESSION_HANDLE hSession,
 574  CK_ATTRIBUTE_PTR pTemplate,
 575  CK_ULONG ulCount,
 576  CK_OBJECT_HANDLE_PTR phObject
 577)
 578{
 579  return __ADJOIN(MODULE_NAME,C_CreateObject)(hSession, pTemplate, ulCount, phObject);
 580}
 581#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 582
 583static CK_RV CK_ENTRY
 584__ADJOIN(MODULE_NAME,C_CopyObject)
 585(
 586  CK_SESSION_HANDLE hSession,
 587  CK_OBJECT_HANDLE hObject,
 588  CK_ATTRIBUTE_PTR pTemplate,
 589  CK_ULONG ulCount,
 590  CK_OBJECT_HANDLE_PTR phNewObject
 591)
 592{
 593  return NSSCKFWC_CopyObject(fwInstance, hSession, hObject, pTemplate, ulCount, phNewObject);
 594}
 595
 596#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 597CK_RV CK_ENTRY
 598C_CopyObject
 599(
 600  CK_SESSION_HANDLE hSession,
 601  CK_OBJECT_HANDLE hObject,
 602  CK_ATTRIBUTE_PTR pTemplate,
 603  CK_ULONG ulCount,
 604  CK_OBJECT_HANDLE_PTR phNewObject
 605)
 606{
 607  return __ADJOIN(MODULE_NAME,C_CopyObject)(hSession, hObject, pTemplate, ulCount, phNewObject);
 608}
 609#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 610
 611static CK_RV CK_ENTRY
 612__ADJOIN(MODULE_NAME,C_DestroyObject)
 613(
 614  CK_SESSION_HANDLE hSession,
 615  CK_OBJECT_HANDLE hObject
 616)
 617{
 618  return NSSCKFWC_DestroyObject(fwInstance, hSession, hObject);
 619}
 620
 621#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 622CK_RV CK_ENTRY
 623C_DestroyObject
 624(
 625  CK_SESSION_HANDLE hSession,
 626  CK_OBJECT_HANDLE hObject
 627)
 628{
 629  return __ADJOIN(MODULE_NAME,C_DestroyObject)(hSession, hObject);
 630}
 631#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 632
 633static CK_RV CK_ENTRY
 634__ADJOIN(MODULE_NAME,C_GetObjectSize)
 635(
 636  CK_SESSION_HANDLE hSession,
 637  CK_OBJECT_HANDLE hObject,
 638  CK_ULONG_PTR pulSize
 639)
 640{
 641  return NSSCKFWC_GetObjectSize(fwInstance, hSession, hObject, pulSize);
 642}
 643
 644#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 645CK_RV CK_ENTRY
 646C_GetObjectSize
 647(
 648  CK_SESSION_HANDLE hSession,
 649  CK_OBJECT_HANDLE hObject,
 650  CK_ULONG_PTR pulSize
 651)
 652{
 653  return __ADJOIN(MODULE_NAME,C_GetObjectSize)(hSession, hObject, pulSize);
 654}
 655#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 656
 657static CK_RV CK_ENTRY
 658__ADJOIN(MODULE_NAME,C_GetAttributeValue)
 659(
 660  CK_SESSION_HANDLE hSession,
 661  CK_OBJECT_HANDLE hObject,
 662  CK_ATTRIBUTE_PTR pTemplate,
 663  CK_ULONG ulCount
 664)
 665{
 666  return NSSCKFWC_GetAttributeValue(fwInstance, hSession, hObject, pTemplate, ulCount);
 667}
 668
 669#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 670CK_RV CK_ENTRY
 671C_GetAttributeValue
 672(
 673  CK_SESSION_HANDLE hSession,
 674  CK_OBJECT_HANDLE hObject,
 675  CK_ATTRIBUTE_PTR pTemplate,
 676  CK_ULONG ulCount
 677)
 678{
 679  return __ADJOIN(MODULE_NAME,C_GetAttributeValue)(hSession, hObject, pTemplate, ulCount);
 680}
 681#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 682
 683static CK_RV CK_ENTRY
 684__ADJOIN(MODULE_NAME,C_SetAttributeValue)
 685(
 686  CK_SESSION_HANDLE hSession,
 687  CK_OBJECT_HANDLE hObject,
 688  CK_ATTRIBUTE_PTR pTemplate,
 689  CK_ULONG ulCount
 690)
 691{
 692  return NSSCKFWC_SetAttributeValue(fwInstance, hSession, hObject, pTemplate, ulCount);
 693}
 694
 695#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 696CK_RV CK_ENTRY
 697C_SetAttributeValue
 698(
 699  CK_SESSION_HANDLE hSession,
 700  CK_OBJECT_HANDLE hObject,
 701  CK_ATTRIBUTE_PTR pTemplate,
 702  CK_ULONG ulCount
 703)
 704{
 705  return __ADJOIN(MODULE_NAME,C_SetAttributeValue)(hSession, hObject, pTemplate, ulCount);
 706}
 707#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 708
 709static CK_RV CK_ENTRY
 710__ADJOIN(MODULE_NAME,C_FindObjectsInit)
 711(
 712  CK_SESSION_HANDLE hSession,
 713  CK_ATTRIBUTE_PTR pTemplate,
 714  CK_ULONG ulCount
 715)
 716{
 717  return NSSCKFWC_FindObjectsInit(fwInstance, hSession, pTemplate, ulCount);
 718}
 719
 720#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 721CK_RV CK_ENTRY
 722C_FindObjectsInit
 723(
 724  CK_SESSION_HANDLE hSession,
 725  CK_ATTRIBUTE_PTR pTemplate,
 726  CK_ULONG ulCount
 727)
 728{
 729  return __ADJOIN(MODULE_NAME,C_FindObjectsInit)(hSession, pTemplate, ulCount);
 730}
 731#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 732
 733static CK_RV CK_ENTRY
 734__ADJOIN(MODULE_NAME,C_FindObjects)
 735(
 736  CK_SESSION_HANDLE hSession,
 737  CK_OBJECT_HANDLE_PTR phObject,
 738  CK_ULONG ulMaxObjectCount,
 739  CK_ULONG_PTR pulObjectCount
 740)
 741{
 742  return NSSCKFWC_FindObjects(fwInstance, hSession, phObject, ulMaxObjectCount, pulObjectCount);
 743}
 744
 745#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 746CK_RV CK_ENTRY
 747C_FindObjects
 748(
 749  CK_SESSION_HANDLE hSession,
 750  CK_OBJECT_HANDLE_PTR phObject,
 751  CK_ULONG ulMaxObjectCount,
 752  CK_ULONG_PTR pulObjectCount
 753)
 754{
 755  return __ADJOIN(MODULE_NAME,C_FindObjects)(hSession, phObject, ulMaxObjectCount, pulObjectCount);
 756}
 757#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 758
 759static CK_RV CK_ENTRY
 760__ADJOIN(MODULE_NAME,C_FindObjectsFinal)
 761(
 762  CK_SESSION_HANDLE hSession
 763)
 764{
 765  return NSSCKFWC_FindObjectsFinal(fwInstance, hSession);
 766}
 767
 768#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 769CK_RV CK_ENTRY
 770C_FindObjectsFinal
 771(
 772  CK_SESSION_HANDLE hSession
 773)
 774{
 775  return __ADJOIN(MODULE_NAME,C_FindObjectsFinal)(hSession);
 776}
 777#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 778
 779static CK_RV CK_ENTRY
 780__ADJOIN(MODULE_NAME,C_EncryptInit)
 781(
 782  CK_SESSION_HANDLE hSession,
 783  CK_MECHANISM_PTR pMechanism,
 784  CK_OBJECT_HANDLE hKey
 785)
 786{
 787  return NSSCKFWC_EncryptInit(fwInstance, hSession, pMechanism, hKey);
 788}
 789
 790#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 791CK_RV CK_ENTRY
 792C_EncryptInit
 793(
 794  CK_SESSION_HANDLE hSession,
 795  CK_MECHANISM_PTR pMechanism,
 796  CK_OBJECT_HANDLE hKey
 797)
 798{
 799  return __ADJOIN(MODULE_NAME,C_EncryptInit)(hSession, pMechanism, hKey);
 800}
 801#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 802
 803static CK_RV CK_ENTRY
 804__ADJOIN(MODULE_NAME,C_Encrypt)
 805(
 806  CK_SESSION_HANDLE hSession,
 807  CK_BYTE_PTR pData,
 808  CK_ULONG ulDataLen,
 809  CK_BYTE_PTR pEncryptedData,
 810  CK_ULONG_PTR pulEncryptedDataLen
 811)
 812{
 813  return NSSCKFWC_Encrypt(fwInstance, hSession, pData, ulDataLen, pEncryptedData, pulEncryptedDataLen);
 814}
 815
 816#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 817CK_RV CK_ENTRY
 818C_Encrypt
 819(
 820  CK_SESSION_HANDLE hSession,
 821  CK_BYTE_PTR pData,
 822  CK_ULONG ulDataLen,
 823  CK_BYTE_PTR pEncryptedData,
 824  CK_ULONG_PTR pulEncryptedDataLen
 825)
 826{
 827  return __ADJOIN(MODULE_NAME,C_Encrypt)(hSession, pData, ulDataLen, pEncryptedData, pulEncryptedDataLen);
 828}
 829#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 830
 831static CK_RV CK_ENTRY
 832__ADJOIN(MODULE_NAME,C_EncryptUpdate)
 833(
 834  CK_SESSION_HANDLE hSession,
 835  CK_BYTE_PTR pPart,
 836  CK_ULONG ulPartLen,
 837  CK_BYTE_PTR pEncryptedPart,
 838  CK_ULONG_PTR pulEncryptedPartLen
 839)
 840{
 841  return NSSCKFWC_EncryptUpdate(fwInstance, hSession, pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen);
 842}
 843
 844#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 845CK_RV CK_ENTRY
 846C_EncryptUpdate
 847(
 848  CK_SESSION_HANDLE hSession,
 849  CK_BYTE_PTR pPart,
 850  CK_ULONG ulPartLen,
 851  CK_BYTE_PTR pEncryptedPart,
 852  CK_ULONG_PTR pulEncryptedPartLen
 853)
 854{
 855  return __ADJOIN(MODULE_NAME,C_EncryptUpdate)(hSession, pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen);
 856}
 857#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 858
 859static CK_RV CK_ENTRY
 860__ADJOIN(MODULE_NAME,C_EncryptFinal)
 861(
 862  CK_SESSION_HANDLE hSession,
 863  CK_BYTE_PTR pLastEncryptedPart,
 864  CK_ULONG_PTR pulLastEncryptedPartLen
 865)
 866{
 867  return NSSCKFWC_EncryptFinal(fwInstance, hSession, pLastEncryptedPart, pulLastEncryptedPartLen);
 868}
 869
 870#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 871CK_RV CK_ENTRY
 872C_EncryptFinal
 873(
 874  CK_SESSION_HANDLE hSession,
 875  CK_BYTE_PTR pLastEncryptedPart,
 876  CK_ULONG_PTR pulLastEncryptedPartLen
 877)
 878{
 879  return __ADJOIN(MODULE_NAME,C_EncryptFinal)(hSession, pLastEncryptedPart, pulLastEncryptedPartLen);
 880}
 881#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 882
 883static CK_RV CK_ENTRY
 884__ADJOIN(MODULE_NAME,C_DecryptInit)
 885(
 886  CK_SESSION_HANDLE hSession,
 887  CK_MECHANISM_PTR pMechanism,
 888  CK_OBJECT_HANDLE hKey
 889)
 890{
 891  return NSSCKFWC_DecryptInit(fwInstance, hSession, pMechanism, hKey);
 892}
 893
 894#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 895CK_RV CK_ENTRY
 896C_DecryptInit
 897(
 898  CK_SESSION_HANDLE hSession,
 899  CK_MECHANISM_PTR pMechanism,
 900  CK_OBJECT_HANDLE hKey
 901)
 902{
 903  return __ADJOIN(MODULE_NAME,C_DecryptInit)(hSession, pMechanism, hKey);
 904}
 905#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 906
 907static CK_RV CK_ENTRY
 908__ADJOIN(MODULE_NAME,C_Decrypt)
 909(
 910  CK_SESSION_HANDLE hSession,
 911  CK_BYTE_PTR pEncryptedData,
 912  CK_ULONG ulEncryptedDataLen,
 913  CK_BYTE_PTR pData,
 914  CK_ULONG_PTR pulDataLen
 915)
 916{
 917  return NSSCKFWC_Decrypt(fwInstance, hSession, pEncryptedData, ulEncryptedDataLen, pData, pulDataLen);
 918}
 919
 920#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 921CK_RV CK_ENTRY
 922C_Decrypt
 923(
 924  CK_SESSION_HANDLE hSession,
 925  CK_BYTE_PTR pEncryptedData,
 926  CK_ULONG ulEncryptedDataLen,
 927  CK_BYTE_PTR pData,
 928  CK_ULONG_PTR pulDataLen
 929)
 930{
 931  return __ADJOIN(MODULE_NAME,C_Decrypt)(hSession, pEncryptedData, ulEncryptedDataLen, pData, pulDataLen);
 932}
 933#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 934
 935static CK_RV CK_ENTRY
 936__ADJOIN(MODULE_NAME,C_DecryptUpdate)
 937(
 938  CK_SESSION_HANDLE hSession,
 939  CK_BYTE_PTR pEncryptedPart,
 940  CK_ULONG ulEncryptedPartLen,
 941  CK_BYTE_PTR pPart,
 942  CK_ULONG_PTR pulPartLen
 943)
 944{
 945  return NSSCKFWC_DecryptUpdate(fwInstance, hSession, pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen);
 946}
 947
 948#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 949CK_RV CK_ENTRY
 950C_DecryptUpdate
 951(
 952  CK_SESSION_HANDLE hSession,
 953  CK_BYTE_PTR pEncryptedPart,
 954  CK_ULONG ulEncryptedPartLen,
 955  CK_BYTE_PTR pPart,
 956  CK_ULONG_PTR pulPartLen
 957)
 958{
 959  return __ADJOIN(MODULE_NAME,C_DecryptUpdate)(hSession, pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen);
 960}
 961#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 962
 963static CK_RV CK_ENTRY
 964__ADJOIN(MODULE_NAME,C_DecryptFinal)
 965(
 966  CK_SESSION_HANDLE hSession,
 967  CK_BYTE_PTR pLastPart,
 968  CK_ULONG_PTR pulLastPartLen
 969)
 970{
 971  return NSSCKFWC_DecryptFinal(fwInstance, hSession, pLastPart, pulLastPartLen);
 972}
 973
 974#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 975CK_RV CK_ENTRY
 976C_DecryptFinal
 977(
 978  CK_SESSION_HANDLE hSession,
 979  CK_BYTE_PTR pLastPart,
 980  CK_ULONG_PTR pulLastPartLen
 981)
 982{
 983  return __ADJOIN(MODULE_NAME,C_DecryptFinal)(hSession, pLastPart, pulLastPartLen);
 984}
 985#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
 986
 987static CK_RV CK_ENTRY
 988__ADJOIN(MODULE_NAME,C_DigestInit)
 989(
 990  CK_SESSION_HANDLE hSession,
 991  CK_MECHANISM_PTR pMechanism
 992)
 993{
 994  return NSSCKFWC_DigestInit(fwInstance, hSession, pMechanism);
 995}
 996
 997#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
 998CK_RV CK_ENTRY
 999C_DigestInit
1000(
1001  CK_SESSION_HANDLE hSession,
1002  CK_MECHANISM_PTR pMechanism
1003)
1004{
1005  return __ADJOIN(MODULE_NAME,C_DigestInit)(hSession, pMechanism);
1006}
1007#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1008
1009static CK_RV CK_ENTRY
1010__ADJOIN(MODULE_NAME,C_Digest)
1011(
1012  CK_SESSION_HANDLE hSession,
1013  CK_BYTE_PTR pData,
1014  CK_ULONG ulDataLen,
1015  CK_BYTE_PTR pDigest,
1016  CK_ULONG_PTR pulDigestLen
1017)
1018{
1019  return NSSCKFWC_Digest(fwInstance, hSession, pData, ulDataLen, pDigest, pulDigestLen);
1020}
1021
1022#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1023CK_RV CK_ENTRY
1024C_Digest
1025(
1026  CK_SESSION_HANDLE hSession,
1027  CK_BYTE_PTR pData,
1028  CK_ULONG ulDataLen,
1029  CK_BYTE_PTR pDigest,
1030  CK_ULONG_PTR pulDigestLen
1031)
1032{
1033  return __ADJOIN(MODULE_NAME,C_Digest)(hSession, pData, ulDataLen, pDigest, pulDigestLen);
1034}
1035#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1036
1037static CK_RV CK_ENTRY
1038__ADJOIN(MODULE_NAME,C_DigestUpdate)
1039(
1040  CK_SESSION_HANDLE hSession,
1041  CK_BYTE_PTR pPart,
1042  CK_ULONG ulPartLen
1043)
1044{
1045  return NSSCKFWC_DigestUpdate(fwInstance, hSession, pPart, ulPartLen);
1046}
1047
1048#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1049CK_RV CK_ENTRY
1050C_DigestUpdate
1051(
1052  CK_SESSION_HANDLE hSession,
1053  CK_BYTE_PTR pPart,
1054  CK_ULONG ulPartLen
1055)
1056{
1057  return __ADJOIN(MODULE_NAME,C_DigestUpdate)(hSession, pPart, ulPartLen);
1058}
1059#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1060
1061static CK_RV CK_ENTRY
1062__ADJOIN(MODULE_NAME,C_DigestKey)
1063(
1064  CK_SESSION_HANDLE hSession,
1065  CK_OBJECT_HANDLE hKey
1066)
1067{
1068  return NSSCKFWC_DigestKey(fwInstance, hSession, hKey);
1069}
1070
1071#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1072CK_RV CK_ENTRY
1073C_DigestKey
1074(
1075  CK_SESSION_HANDLE hSession,
1076  CK_OBJECT_HANDLE hKey
1077)
1078{
1079  return __ADJOIN(MODULE_NAME,C_DigestKey)(hSession, hKey);
1080}
1081#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1082
1083static CK_RV CK_ENTRY
1084__ADJOIN(MODULE_NAME,C_DigestFinal)
1085(
1086  CK_SESSION_HANDLE hSession,
1087  CK_BYTE_PTR pDigest,
1088  CK_ULONG_PTR pulDigestLen
1089)
1090{
1091  return NSSCKFWC_DigestFinal(fwInstance, hSession, pDigest, pulDigestLen);
1092}
1093
1094#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1095CK_RV CK_ENTRY
1096C_DigestFinal
1097(
1098  CK_SESSION_HANDLE hSession,
1099  CK_BYTE_PTR pDigest,
1100  CK_ULONG_PTR pulDigestLen
1101)
1102{
1103  return __ADJOIN(MODULE_NAME,C_DigestFinal)(hSession, pDigest, pulDigestLen);
1104}
1105#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1106
1107static CK_RV CK_ENTRY
1108__ADJOIN(MODULE_NAME,C_SignInit)
1109(
1110  CK_SESSION_HANDLE hSession,
1111  CK_MECHANISM_PTR pMechanism,
1112  CK_OBJECT_HANDLE hKey
1113)
1114{
1115  return NSSCKFWC_SignInit(fwInstance, hSession, pMechanism, hKey);
1116}
1117
1118#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1119CK_RV CK_ENTRY
1120C_SignInit
1121(
1122  CK_SESSION_HANDLE hSession,
1123  CK_MECHANISM_PTR pMechanism,
1124  CK_OBJECT_HANDLE hKey
1125)
1126{
1127  return __ADJOIN(MODULE_NAME,C_SignInit)(hSession, pMechanism, hKey);
1128}
1129#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1130
1131static CK_RV CK_ENTRY
1132__ADJOIN(MODULE_NAME,C_Sign)
1133(
1134  CK_SESSION_HANDLE hSession,
1135  CK_BYTE_PTR pData,
1136  CK_ULONG ulDataLen,
1137  CK_BYTE_PTR pSignature,
1138  CK_ULONG_PTR pulSignatureLen
1139)
1140{
1141  return NSSCKFWC_Sign(fwInstance, hSession, pData, ulDataLen, pSignature, pulSignatureLen);
1142}
1143
1144#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1145CK_RV CK_ENTRY
1146C_Sign
1147(
1148  CK_SESSION_HANDLE hSession,
1149  CK_BYTE_PTR pData,
1150  CK_ULONG ulDataLen,
1151  CK_BYTE_PTR pSignature,
1152  CK_ULONG_PTR pulSignatureLen
1153)
1154{
1155  return __ADJOIN(MODULE_NAME,C_Sign)(hSession, pData, ulDataLen, pSignature, pulSignatureLen);
1156}
1157#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1158
1159static CK_RV CK_ENTRY
1160__ADJOIN(MODULE_NAME,C_SignUpdate)
1161(
1162  CK_SESSION_HANDLE hSession,
1163  CK_BYTE_PTR pPart,
1164  CK_ULONG ulPartLen
1165)
1166{
1167  return NSSCKFWC_SignUpdate(fwInstance, hSession, pPart, ulPartLen);
1168}
1169
1170#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1171CK_RV CK_ENTRY
1172C_SignUpdate
1173(
1174  CK_SESSION_HANDLE hSession,
1175  CK_BYTE_PTR pPart,
1176  CK_ULONG ulPartLen
1177)
1178{
1179  return __ADJOIN(MODULE_NAME,C_SignUpdate)(hSession, pPart, ulPartLen);
1180}
1181#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1182
1183static CK_RV CK_ENTRY
1184__ADJOIN(MODULE_NAME,C_SignFinal)
1185(
1186  CK_SESSION_HANDLE hSession,
1187  CK_BYTE_PTR pSignature,
1188  CK_ULONG_PTR pulSignatureLen
1189)
1190{
1191  return NSSCKFWC_SignFinal(fwInstance, hSession, pSignature, pulSignatureLen);
1192}
1193
1194#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1195CK_RV CK_ENTRY
1196C_SignFinal
1197(
1198  CK_SESSION_HANDLE hSession,
1199  CK_BYTE_PTR pSignature,
1200  CK_ULONG_PTR pulSignatureLen
1201)
1202{
1203  return __ADJOIN(MODULE_NAME,C_SignFinal)(hSession, pSignature, pulSignatureLen);
1204}
1205#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1206
1207static CK_RV CK_ENTRY
1208__ADJOIN(MODULE_NAME,C_SignRecoverInit)
1209(
1210  CK_SESSION_HANDLE hSession,
1211  CK_MECHANISM_PTR pMechanism,
1212  CK_OBJECT_HANDLE hKey
1213)
1214{
1215  return NSSCKFWC_SignRecoverInit(fwInstance, hSession, pMechanism, hKey);
1216}
1217
1218#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1219CK_RV CK_ENTRY
1220C_SignRecoverInit
1221(
1222  CK_SESSION_HANDLE hSession,
1223  CK_MECHANISM_PTR pMechanism,
1224  CK_OBJECT_HANDLE hKey
1225)
1226{
1227  return __ADJOIN(MODULE_NAME,C_SignRecoverInit)(hSession, pMechanism, hKey);
1228}
1229#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1230
1231static CK_RV CK_ENTRY
1232__ADJOIN(MODULE_NAME,C_SignRecover)
1233(
1234  CK_SESSION_HANDLE hSession,
1235  CK_BYTE_PTR pData,
1236  CK_ULONG ulDataLen,
1237  CK_BYTE_PTR pSignature,
1238  CK_ULONG_PTR pulSignatureLen
1239)
1240{
1241  return NSSCKFWC_SignRecover(fwInstance, hSession, pData, ulDataLen, pSignature, pulSignatureLen);
1242}
1243
1244#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1245CK_RV CK_ENTRY
1246C_SignRecover
1247(
1248  CK_SESSION_HANDLE hSession,
1249  CK_BYTE_PTR pData,
1250  CK_ULONG ulDataLen,
1251  CK_BYTE_PTR pSignature,
1252  CK_ULONG_PTR pulSignatureLen
1253)
1254{
1255  return __ADJOIN(MODULE_NAME,C_SignRecover)(hSession, pData, ulDataLen, pSignature, pulSignatureLen);
1256}
1257#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1258
1259static CK_RV CK_ENTRY
1260__ADJOIN(MODULE_NAME,C_VerifyInit)
1261(
1262  CK_SESSION_HANDLE hSession,
1263  CK_MECHANISM_PTR pMechanism,
1264  CK_OBJECT_HANDLE hKey
1265)
1266{
1267  return NSSCKFWC_VerifyInit(fwInstance, hSession, pMechanism, hKey);
1268}
1269
1270#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1271CK_RV CK_ENTRY
1272C_VerifyInit
1273(
1274  CK_SESSION_HANDLE hSession,
1275  CK_MECHANISM_PTR pMechanism,
1276  CK_OBJECT_HANDLE hKey
1277)
1278{
1279  return __ADJOIN(MODULE_NAME,C_VerifyInit)(hSession, pMechanism, hKey);
1280}
1281#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1282
1283static CK_RV CK_ENTRY
1284__ADJOIN(MODULE_NAME,C_Verify)
1285(
1286  CK_SESSION_HANDLE hSession,
1287  CK_BYTE_PTR pData,
1288  CK_ULONG ulDataLen,
1289  CK_BYTE_PTR pSignature,
1290  CK_ULONG ulSignatureLen
1291)
1292{
1293  return NSSCKFWC_Verify(fwInstance, hSession, pData, ulDataLen, pSignature, ulSignatureLen);
1294}
1295
1296#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1297CK_RV CK_ENTRY
1298C_Verify
1299(
1300  CK_SESSION_HANDLE hSession,
1301  CK_BYTE_PTR pData,
1302  CK_ULONG ulDataLen,
1303  CK_BYTE_PTR pSignature,
1304  CK_ULONG ulSignatureLen
1305)
1306{
1307  return __ADJOIN(MODULE_NAME,C_Verify)(hSession, pData, ulDataLen, pSignature, ulSignatureLen);
1308}
1309#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1310
1311static CK_RV CK_ENTRY
1312__ADJOIN(MODULE_NAME,C_VerifyUpdate)
1313(
1314  CK_SESSION_HANDLE hSession,
1315  CK_BYTE_PTR pPart,
1316  CK_ULONG ulPartLen
1317)
1318{
1319  return NSSCKFWC_VerifyUpdate(fwInstance, hSession, pPart, ulPartLen);
1320}
1321
1322#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1323CK_RV CK_ENTRY
1324C_VerifyUpdate
1325(
1326  CK_SESSION_HANDLE hSession,
1327  CK_BYTE_PTR pPart,
1328  CK_ULONG ulPartLen
1329)
1330{
1331  return __ADJOIN(MODULE_NAME,C_VerifyUpdate)(hSession, pPart, ulPartLen);
1332}
1333#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1334
1335static CK_RV CK_ENTRY
1336__ADJOIN(MODULE_NAME,C_VerifyFinal)
1337(
1338  CK_SESSION_HANDLE hSession,
1339  CK_BYTE_PTR pSignature,
1340  CK_ULONG ulSignatureLen
1341)
1342{
1343  return NSSCKFWC_VerifyFinal(fwInstance, hSession, pSignature, ulSignatureLen);
1344}
1345
1346#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1347CK_RV CK_ENTRY
1348C_VerifyFinal
1349(
1350  CK_SESSION_HANDLE hSession,
1351  CK_BYTE_PTR pSignature,
1352  CK_ULONG ulSignatureLen
1353)
1354{
1355  return __ADJOIN(MODULE_NAME,C_VerifyFinal)(hSession, pSignature, ulSignatureLen);
1356}
1357#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1358
1359static CK_RV CK_ENTRY
1360__ADJOIN(MODULE_NAME,C_VerifyRecoverInit)
1361(
1362  CK_SESSION_HANDLE hSession,
1363  CK_MECHANISM_PTR pMechanism,
1364  CK_OBJECT_HANDLE hKey
1365)
1366{
1367  return NSSCKFWC_VerifyRecoverInit(fwInstance, hSession, pMechanism, hKey);
1368}
1369
1370#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1371CK_RV CK_ENTRY
1372C_VerifyRecoverInit
1373(
1374  CK_SESSION_HANDLE hSession,
1375  CK_MECHANISM_PTR pMechanism,
1376  CK_OBJECT_HANDLE hKey
1377)
1378{
1379  return __ADJOIN(MODULE_NAME,C_VerifyRecoverInit)(hSession, pMechanism, hKey);
1380}
1381#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1382
1383static CK_RV CK_ENTRY
1384__ADJOIN(MODULE_NAME,C_VerifyRecover)
1385(
1386  CK_SESSION_HANDLE hSession,
1387  CK_BYTE_PTR pSignature,
1388  CK_ULONG ulSignatureLen,
1389  CK_BYTE_PTR pData,
1390  CK_ULONG_PTR pulDataLen
1391)
1392{
1393  return NSSCKFWC_VerifyRecover(fwInstance, hSession, pSignature, ulSignatureLen, pData, pulDataLen);
1394}
1395
1396#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1397CK_RV CK_ENTRY
1398C_VerifyRecover
1399(
1400  CK_SESSION_HANDLE hSession,
1401  CK_BYTE_PTR pSignature,
1402  CK_ULONG ulSignatureLen,
1403  CK_BYTE_PTR pData,
1404  CK_ULONG_PTR pulDataLen
1405)
1406{
1407  return __ADJOIN(MODULE_NAME,C_VerifyRecover)(hSession, pSignature, ulSignatureLen, pData, pulDataLen);
1408}
1409#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1410
1411static CK_RV CK_ENTRY
1412__ADJOIN(MODULE_NAME,C_DigestEncryptUpdate)
1413(
1414  CK_SESSION_HANDLE hSession,
1415  CK_BYTE_PTR pPart,
1416  CK_ULONG ulPartLen,
1417  CK_BYTE_PTR pEncryptedPart,
1418  CK_ULONG_PTR pulEncryptedPartLen
1419)
1420{
1421  return NSSCKFWC_DigestEncryptUpdate(fwInstance, hSession, pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen);
1422}
1423
1424#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1425CK_RV CK_ENTRY
1426C_DigestEncryptUpdate
1427(
1428  CK_SESSION_HANDLE hSession,
1429  CK_BYTE_PTR pPart,
1430  CK_ULONG ulPartLen,
1431  CK_BYTE_PTR pEncryptedPart,
1432  CK_ULONG_PTR pulEncryptedPartLen
1433)
1434{
1435  return __ADJOIN(MODULE_NAME,C_DigestEncryptUpdate)(hSession, pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen);
1436}
1437#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1438
1439static CK_RV CK_ENTRY
1440__ADJOIN(MODULE_NAME,C_DecryptDigestUpdate)
1441(
1442  CK_SESSION_HANDLE hSession,
1443  CK_BYTE_PTR pEncryptedPart,
1444  CK_ULONG ulEncryptedPartLen,
1445  CK_BYTE_PTR pPart,
1446  CK_ULONG_PTR pulPartLen
1447)
1448{
1449  return NSSCKFWC_DecryptDigestUpdate(fwInstance, hSession, pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen);
1450}
1451
1452#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1453CK_RV CK_ENTRY
1454C_DecryptDigestUpdate
1455(
1456  CK_SESSION_HANDLE hSession,
1457  CK_BYTE_PTR pEncryptedPart,
1458  CK_ULONG ulEncryptedPartLen,
1459  CK_BYTE_PTR pPart,
1460  CK_ULONG_PTR pulPartLen
1461)
1462{
1463  return __ADJOIN(MODULE_NAME,C_DecryptDigestUpdate)(hSession, pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen);
1464}
1465#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1466
1467static CK_RV CK_ENTRY
1468__ADJOIN(MODULE_NAME,C_SignEncryptUpdate)
1469(
1470  CK_SESSION_HANDLE hSession,
1471  CK_BYTE_PTR pPart,
1472  CK_ULONG ulPartLen,
1473  CK_BYTE_PTR pEncryptedPart,
1474  CK_ULONG_PTR pulEncryptedPartLen
1475)
1476{
1477  return NSSCKFWC_SignEncryptUpdate(fwInstance, hSession, pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen);
1478}
1479
1480#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1481CK_RV CK_ENTRY
1482C_SignEncryptUpdate
1483(
1484  CK_SESSION_HANDLE hSession,
1485  CK_BYTE_PTR pPart,
1486  CK_ULONG ulPartLen,
1487  CK_BYTE_PTR pEncryptedPart,
1488  CK_ULONG_PTR pulEncryptedPartLen
1489)
1490{
1491  return __ADJOIN(MODULE_NAME,C_SignEncryptUpdate)(hSession, pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen);
1492}
1493#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1494
1495static CK_RV CK_ENTRY
1496__ADJOIN(MODULE_NAME,C_DecryptVerifyUpdate)
1497(
1498  CK_SESSION_HANDLE hSession,
1499  CK_BYTE_PTR pEncryptedPart,
1500  CK_ULONG ulEncryptedPartLen,
1501  CK_BYTE_PTR pPart,
1502  CK_ULONG_PTR pulPartLen
1503)
1504{
1505  return NSSCKFWC_DecryptVerifyUpdate(fwInstance, hSession, pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen);
1506}
1507
1508#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1509CK_RV CK_ENTRY
1510C_DecryptVerifyUpdate
1511(
1512  CK_SESSION_HANDLE hSession,
1513  CK_BYTE_PTR pEncryptedPart,
1514  CK_ULONG ulEncryptedPartLen,
1515  CK_BYTE_PTR pPart,
1516  CK_ULONG_PTR pulPartLen
1517)
1518{
1519  return __ADJOIN(MODULE_NAME,C_DecryptVerifyUpdate)(hSession, pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen);
1520}
1521#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1522
1523static CK_RV CK_ENTRY
1524__ADJOIN(MODULE_NAME,C_GenerateKey)
1525(
1526  CK_SESSION_HANDLE hSession,
1527  CK_MECHANISM_PTR pMechanism,
1528  CK_ATTRIBUTE_PTR pTemplate,
1529  CK_ULONG ulCount,
1530  CK_OBJECT_HANDLE_PTR phKey
1531)
1532{
1533  return NSSCKFWC_GenerateKey(fwInstance, hSession, pMechanism, pTemplate, ulCount, phKey);
1534}
1535
1536#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1537CK_RV CK_ENTRY
1538C_GenerateKey
1539(
1540  CK_SESSION_HANDLE hSession,
1541  CK_MECHANISM_PTR pMechanism,
1542  CK_ATTRIBUTE_PTR pTemplate,
1543  CK_ULONG ulCount,
1544  CK_OBJECT_HANDLE_PTR phKey
1545)
1546{
1547  return __ADJOIN(MODULE_NAME,C_GenerateKey)(hSession, pMechanism, pTemplate, ulCount, phKey);
1548}
1549#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1550
1551static CK_RV CK_ENTRY
1552__ADJOIN(MODULE_NAME,C_GenerateKeyPair)
1553(
1554  CK_SESSION_HANDLE hSession,
1555  CK_MECHANISM_PTR pMechanism,
1556  CK_ATTRIBUTE_PTR pPublicKeyTemplate,
1557  CK_ULONG ulPublicKeyAttributeCount,
1558  CK_ATTRIBUTE_PTR pPrivateKeyTemplate,
1559  CK_ULONG ulPrivateKeyAttributeCount,
1560  CK_OBJECT_HANDLE_PTR phPublicKey,
1561  CK_OBJECT_HANDLE_PTR phPrivateKey
1562)
1563{
1564  return NSSCKFWC_GenerateKeyPair(fwInstance, hSession, pMechanism, pPublicKeyTemplate, ulPublicKeyAttributeCount, pPrivateKeyTemplate, ulPrivateKeyAttributeCount, phPublicKey, phPrivateKey);
1565}
1566
1567#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1568CK_RV CK_ENTRY
1569C_GenerateKeyPair
1570(
1571  CK_SESSION_HANDLE hSession,
1572  CK_MECHANISM_PTR pMechanism,
1573  CK_ATTRIBUTE_PTR pPublicKeyTemplate,
1574  CK_ULONG ulPublicKeyAttributeCount,
1575  CK_ATTRIBUTE_PTR pPrivateKeyTemplate,
1576  CK_ULONG ulPrivateKeyAttributeCount,
1577  CK_OBJECT_HANDLE_PTR phPublicKey,
1578  CK_OBJECT_HANDLE_PTR phPrivateKey
1579)
1580{
1581  return __ADJOIN(MODULE_NAME,C_GenerateKeyPair)(hSession, pMechanism, pPublicKeyTemplate, ulPublicKeyAttributeCount, pPrivateKeyTemplate, ulPrivateKeyAttributeCount, phPublicKey, phPrivateKey);
1582}
1583#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1584
1585static CK_RV CK_ENTRY
1586__ADJOIN(MODULE_NAME,C_WrapKey)
1587(
1588  CK_SESSION_HANDLE hSession,
1589  CK_MECHANISM_PTR pMechanism,
1590  CK_OBJECT_HANDLE hWrappingKey,
1591  CK_OBJECT_HANDLE hKey,
1592  CK_BYTE_PTR pWrappedKey,
1593  CK_ULONG_PTR pulWrappedKeyLen
1594)
1595{
1596  return NSSCKFWC_WrapKey(fwInstance, hSession, pMechanism, hWrappingKey, hKey, pWrappedKey, pulWrappedKeyLen);
1597}
1598
1599#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1600CK_RV CK_ENTRY
1601C_WrapKey
1602(
1603  CK_SESSION_HANDLE hSession,
1604  CK_MECHANISM_PTR pMechanism,
1605  CK_OBJECT_HANDLE hWrappingKey,
1606  CK_OBJECT_HANDLE hKey,
1607  CK_BYTE_PTR pWrappedKey,
1608  CK_ULONG_PTR pulWrappedKeyLen
1609)
1610{
1611  return __ADJOIN(MODULE_NAME,C_WrapKey)(hSession, pMechanism, hWrappingKey, hKey, pWrappedKey, pulWrappedKeyLen);
1612}
1613#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1614
1615static CK_RV CK_ENTRY
1616__ADJOIN(MODULE_NAME,C_UnwrapKey)
1617(
1618  CK_SESSION_HANDLE hSession,
1619  CK_MECHANISM_PTR pMechanism,
1620  CK_OBJECT_HANDLE hUnwrappingKey,
1621  CK_BYTE_PTR pWrappedKey,
1622  CK_ULONG ulWrappedKeyLen,
1623  CK_ATTRIBUTE_PTR pTemplate,
1624  CK_ULONG ulAttributeCount,
1625  CK_OBJECT_HANDLE_PTR phKey
1626)
1627{
1628  return NSSCKFWC_UnwrapKey(fwInstance, hSession, pMechanism, hUnwrappingKey, pWrappedKey, ulWrappedKeyLen, pTemplate, ulAttributeCount, phKey);
1629}
1630
1631#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1632CK_RV CK_ENTRY
1633C_UnwrapKey
1634(
1635  CK_SESSION_HANDLE hSession,
1636  CK_MECHANISM_PTR pMechanism,
1637  CK_OBJECT_HANDLE hUnwrappingKey,
1638  CK_BYTE_PTR pWrappedKey,
1639  CK_ULONG ulWrappedKeyLen,
1640  CK_ATTRIBUTE_PTR pTemplate,
1641  CK_ULONG ulAttributeCount,
1642  CK_OBJECT_HANDLE_PTR phKey
1643)
1644{
1645  return __ADJOIN(MODULE_NAME,C_UnwrapKey)(hSession, pMechanism, hUnwrappingKey, pWrappedKey, ulWrappedKeyLen, pTemplate, ulAttributeCount, phKey);
1646}
1647#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1648
1649static CK_RV CK_ENTRY
1650__ADJOIN(MODULE_NAME,C_DeriveKey)
1651(
1652  CK_SESSION_HANDLE hSession,
1653  CK_MECHANISM_PTR pMechanism,
1654  CK_OBJECT_HANDLE hBaseKey,
1655  CK_ATTRIBUTE_PTR pTemplate,
1656  CK_ULONG ulAttributeCount,
1657  CK_OBJECT_HANDLE_PTR phKey
1658)
1659{
1660  return NSSCKFWC_DeriveKey(fwInstance, hSession, pMechanism, hBaseKey, pTemplate, ulAttributeCount, phKey);
1661}
1662
1663#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1664CK_RV CK_ENTRY
1665C_DeriveKey
1666(
1667  CK_SESSION_HANDLE hSession,
1668  CK_MECHANISM_PTR pMechanism,
1669  CK_OBJECT_HANDLE hBaseKey,
1670  CK_ATTRIBUTE_PTR pTemplate,
1671  CK_ULONG ulAttributeCount,
1672  CK_OBJECT_HANDLE_PTR phKey
1673)
1674{
1675  return __ADJOIN(MODULE_NAME,C_DeriveKey)(hSession, pMechanism, hBaseKey, pTemplate, ulAttributeCount, phKey);
1676}
1677#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1678
1679static CK_RV CK_ENTRY
1680__ADJOIN(MODULE_NAME,C_SeedRandom)
1681(
1682  CK_SESSION_HANDLE hSession,
1683  CK_BYTE_PTR pSeed,
1684  CK_ULONG ulSeedLen
1685)
1686{
1687  return NSSCKFWC_SeedRandom(fwInstance, hSession, pSeed, ulSeedLen);
1688}
1689
1690#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1691CK_RV CK_ENTRY
1692C_SeedRandom
1693(
1694  CK_SESSION_HANDLE hSession,
1695  CK_BYTE_PTR pSeed,
1696  CK_ULONG ulSeedLen
1697)
1698{
1699  return __ADJOIN(MODULE_NAME,C_SeedRandom)(hSession, pSeed, ulSeedLen);
1700}
1701#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1702
1703static CK_RV CK_ENTRY
1704__ADJOIN(MODULE_NAME,C_GenerateRandom)
1705(
1706  CK_SESSION_HANDLE hSession,
1707  CK_BYTE_PTR RandomData,
1708  CK_ULONG ulRandomLen
1709)
1710{
1711  return NSSCKFWC_GenerateRandom(fwInstance, hSession, RandomData, ulRandomLen);
1712}
1713
1714#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1715CK_RV CK_ENTRY
1716C_GenerateRandom
1717(
1718  CK_SESSION_HANDLE hSession,
1719  CK_BYTE_PTR RandomData,
1720  CK_ULONG ulRandomLen
1721)
1722{
1723  return __ADJOIN(MODULE_NAME,C_GenerateRandom)(hSession, RandomData, ulRandomLen);
1724}
1725#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1726
1727static CK_RV CK_ENTRY
1728__ADJOIN(MODULE_NAME,C_GetFunctionStatus)
1729(
1730  CK_SESSION_HANDLE hSession
1731)
1732{
1733  return NSSCKFWC_GetFunctionStatus(fwInstance, hSession);
1734}
1735
1736#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1737CK_RV CK_ENTRY
1738C_GetFunctionStatus
1739(
1740  CK_SESSION_HANDLE hSession
1741)
1742{
1743  return __ADJOIN(MODULE_NAME,C_GetFunctionStatus)(hSession);
1744}
1745#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1746
1747static CK_RV CK_ENTRY
1748__ADJOIN(MODULE_NAME,C_CancelFunction)
1749(
1750  CK_SESSION_HANDLE hSession
1751)
1752{
1753  return NSSCKFWC_CancelFunction(fwInstance, hSession);
1754}
1755
1756#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1757CK_RV CK_ENTRY
1758C_CancelFunction
1759(
1760  CK_SESSION_HANDLE hSession
1761)
1762{
1763  return __ADJOIN(MODULE_NAME,C_CancelFunction)(hSession);
1764}
1765#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1766
1767static CK_RV CK_ENTRY
1768__ADJOIN(MODULE_NAME,C_WaitForSlotEvent)
1769(
1770  CK_FLAGS flags,
1771  CK_SLOT_ID_PTR pSlot,
1772  CK_VOID_PTR pRserved
1773)
1774{
1775  return NSSCKFWC_WaitForSlotEvent(fwInstance, flags, pSlot, pRserved);
1776}
1777
1778#ifdef DECLARE_STRICT_CRYPTOKI_NAMES
1779CK_RV CK_ENTRY
1780C_WaitForSlotEvent
1781(
1782  CK_FLAGS flags,
1783  CK_SLOT_ID_PTR pSlot,
1784  CK_VOID_PTR pRserved
1785)
1786{
1787  return __ADJOIN(MODULE_NAME,C_WaitForSlotEvent)(flags, pSlot, pRserved);
1788}
1789#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */
1790
1791static CK_RV CK_ENTRY
1792__ADJOIN(MODULE_NAME,C_GetFunctionList)
1793(
1794  CK_FUNCTION_LIST_PTR_PTR ppFunctionList
1795);
1796
1797static CK_FUNCTION_LIST FunctionList = {
1798  { 2, 1 },
1799__ADJOIN(MODULE_NAME,C_Initialize),
1800__ADJOIN(MODULE_NAME,C_Finalize),
1801__ADJOIN(MODULE_NAME,C_GetInfo),
1802__ADJOIN(MODULE_NAME,C_GetFunctionList),
1803__ADJOIN(MODULE_NAME,C_GetSlotList),
1804__ADJOIN(MODULE_NAME,C_GetSlotInfo),
1805__ADJOIN(MODULE_NAME,C_GetTokenInfo),
1806__ADJOIN(MODULE_NAME,C_GetMechanismList),
1807__ADJOIN(MODULE_NAME,C_GetMechanismInfo),
1808__ADJOIN(MODULE_NAME,C_InitToken),
1809__ADJOIN(MODULE_NAME,C_InitPIN),
1810__ADJOIN(MODULE_NAME,C_SetPIN),
1811__ADJOIN(MODULE_NAME,C_OpenSession),
1812__ADJOIN(MODULE_NAME,C_CloseSession),
1813__ADJOIN(MODULE_NAME,C_CloseAllSessions),
1814__ADJOIN(MODULE_NAME,C_GetSessionInfo),
1815__ADJOIN(MODULE_NAME,C_GetOperationState),
1816__ADJOIN(MODULE_NAME,C_SetOperationState),
1817__ADJOIN(MODULE_NAME,C_Login),
1818__ADJOIN(MODULE_NAME,C_Logout),
1819__ADJOIN(MODULE_NAME,C_CreateObject),
1820__ADJOIN(MODULE_NAME,C_CopyObject),
1821__ADJOIN(MODULE_NAME,C_DestroyObject),
1822__ADJOIN(MODULE_NAME,C_GetObjectSize),
1823__ADJOIN(MODULE_NAME,C_GetAttributeValue),
1824__ADJOIN(MODULE_NAME,C_SetAttributeValue),
1825__ADJOIN(MODULE_NAME,C_FindObjectsInit),
1826__ADJOIN(MODULE_NAME,C_FindObjects),
1827__ADJOIN(MODULE_NAME,C_FindObjectsFinal),
1828__ADJOIN(MODULE_NAME,C_EncryptInit),
1829__ADJOIN(MODULE_NAME,C_Encrypt),
1830__ADJOIN(MODULE_NAME,C_EncryptUpdate),
1831__ADJOIN(MODULE_NAME,C_EncryptFinal),
1832__ADJOIN(MODULE_NAME,C_DecryptInit),
1833__ADJOIN(MODULE_NAME,C_Decrypt),
1834__ADJOIN(MODULE_NAME,C_DecryptUpdate),
1835__ADJOIN(MODULE_NAME,C_DecryptFinal),
1836__ADJOIN(MODULE_NAME,C_DigestInit),
1837__ADJOIN(MODULE_NAME,C_Digest),
1838__ADJOIN(MODULE_NAME,C_DigestUpdate),
1839__ADJOIN(MODULE_NAME,C_DigestKey),
1840__ADJOIN(MODULE_NAME,C_DigestFinal),
1841__ADJOIN(MODULE_NAME,C_SignInit),
1842__ADJOIN(MODULE_NAME,C_Sign),
1843__ADJOIN(MODULE_NAME,C_SignUpdate),
1844__ADJOIN(MODULE_NAME,C_SignFinal),
1845__ADJOIN(MODULE_NAME,C_SignRecoverInit),
1846__ADJOIN(MODULE_NAME,C_SignRecover),
1847__ADJOIN(MODULE_NAME,C_VerifyInit),
1848__ADJOIN(MODULE_NAME,C_Verify),
1849__ADJOIN(MODULE_NAME,C_VerifyUpdate),
1850__ADJOIN(MODULE_NAME,C_VerifyFinal),
1851__ADJOIN(MODULE_NAME,C_VerifyRecoverInit),
1852__ADJOIN(MODULE_NAME,C_VerifyRecover),
1853__ADJOIN(MODULE_NAME,C_DigestEncryptUpdate),
1854__ADJOIN(MODULE_NAME,C_DecryptDigestUpdate),
1855__ADJOIN(MODULE_NAME,C_SignEncryptUpdate),
1856__ADJOIN(MODULE_NAME,C_DecryptVerifyUpdate),
1857__ADJOIN(MODULE_NAME,C_GenerateKey),
1858__ADJOIN(MODULE_NAME,C_GenerateKeyPair),
1859__ADJOIN(MODULE_NAME,C_WrapKey),
1860__ADJOIN(MODULE_NAME,C_UnwrapKey),
1861__ADJOIN(MODULE_NAME,C_DeriveKey),
1862__ADJOIN(MODULE_NAME,C_SeedRandom),
1863__ADJOIN(MODULE_NAME,C_GenerateRandom),
1864__ADJOIN(MODULE_NAME,C_GetFunctionStatus),
1865__ADJOIN(MODULE_NAME,C_CancelFunction),
1866__ADJOIN(MODULE_NAME,C_WaitForSlotEvent)
1867};
1868
1869static CK_RV CK_ENTRY
1870__ADJOIN(MODULE_NAME,C_GetFunctionList)
1871(
1872  CK_FUNCTION_LIST_PTR_PTR ppFunctionList
1873)
1874{
1875  *ppFunctionList = &FunctionList;
1876  return CKR_OK;
1877}
1878
1879/* This one is always present */
1880CK_RV CK_ENTRY
1881C_GetFunctionList
1882(
1883  CK_FUNCTION_LIST_PTR_PTR ppFunctionList
1884)
1885{
1886  return __ADJOIN(MODULE_NAME,C_GetFunctionList)(ppFunctionList);
1887}
1888
1889#undef __ADJOIN
1890