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/. */ 5 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 */ 38 39#ifndef MODULE_NAME 40#error "Error: MODULE_NAME must be defined." 41#endif /* MODULE_NAME */ 42 43#ifndef INSTANCE_NAME 44#error "Error: INSTANCE_NAME must be defined." 45#endif /* INSTANCE_NAME */ 46 47#ifndef NSSCKT_H 48#include "nssckt.h" 49#endif /* NSSCKT_H */ 50 51#ifndef NSSCKFWT_H 52#include "nssckfwt.h" 53#endif /* NSSCKFWT_H */ 54 55#ifndef NSSCKFWC_H 56#include "nssckfwc.h" 57#endif /* NSSCKFWC_H */ 58 59#ifndef NSSCKEPV_H 60#include "nssckepv.h" 61#endif /* NSSCKEPV_H */ 62 63#define ADJOIN(x,y) x##y 64 65#define __ADJOIN(x,y) ADJOIN(x,y) 66 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 */ 72 73static NSSCKFWInstance *fwInstance = (NSSCKFWInstance *)0; 74 75static 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} 83 84#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 85CK_RV CK_ENTRY 86C_Initialize 87( 88 CK_VOID_PTR pInitArgs 89) 90{ 91 return __ADJOIN(MODULE_NAME,C_Initialize)(pInitArgs); 92} 93#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ 94 95static CK_RV CK_ENTRY 96__ADJOIN(MODULE_NAME,C_Finalize) 97( 98 CK_VOID_PTR pReserved 99) 100{ 101 return NSSCKFWC_Finalize(&fwInstance); 102} 103 104#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 105CK_RV CK_ENTRY 106C_Finalize 107( 108 CK_VOID_PTR pReserved 109) 110{ 111 return __ADJOIN(MODULE_NAME,C_Finalize)(pReserved); 112} 113#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ 114 115static 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} 123 124#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 125CK_RV CK_ENTRY 126C_GetInfo 127( 128 CK_INFO_PTR pInfo 129) 130{ 131 return __ADJOIN(MODULE_NAME,C_GetInfo)(pInfo); 132} 133#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ 134 135/* 136 * C_GetFunctionList is defined at the end. 137 */ 138 139static 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} 149 150#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 151CK_RV CK_ENTRY 152C_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 */ 162 163static 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} 172 173#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 174CK_RV CK_ENTRY 175C_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 */ 184 185static 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} 194 195#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 196CK_RV CK_ENTRY 197C_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 */ 206 207static 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} 217 218#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 219CK_RV CK_ENTRY 220C_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 */ 230 231static 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} 241 242#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 243CK_RV CK_ENTRY 244C_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 */ 254 255static 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} 266 267#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 268CK_RV CK_ENTRY 269C_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 */ 280 281static 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} 291 292#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 293CK_RV CK_ENTRY 294C_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 */ 304 305static 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} 317 318#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 319CK_RV CK_ENTRY 320C_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 */ 332 333static 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} 345 346#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 347CK_RV CK_ENTRY 348C_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 */ 360 361static 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} 369 370#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 371CK_RV CK_ENTRY 372C_CloseSession 373( 374 CK_SESSION_HANDLE hSession 375) 376{ 377 return __ADJOIN(MODULE_NAME,C_CloseSession)(hSession); 378} 379#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ 380 381static 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} 389 390#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 391CK_RV CK_ENTRY 392C_CloseAllSessions 393( 394 CK_SLOT_ID slotID 395) 396{ 397 return __ADJOIN(MODULE_NAME,C_CloseAllSessions)(slotID); 398} 399#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ 400 401static 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} 410 411#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 412CK_RV CK_ENTRY 413C_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 */ 422 423static 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} 433 434#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 435CK_RV CK_ENTRY 436C_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 */ 446 447static 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} 459 460#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 461CK_RV CK_ENTRY 462C_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 */ 474 475static 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} 486 487#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 488CK_RV CK_ENTRY 489C_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 */ 500 501static 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} 509 510#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 511CK_RV CK_ENTRY 512C_Logout 513( 514 CK_SESSION_HANDLE hSession 515) 516{ 517 return __ADJOIN(MODULE_NAME,C_Logout)(hSession); 518} 519#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ 520 521static 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} 532 533#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 534CK_RV CK_ENTRY 535C_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 */ 546 547static 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} 559 560#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 561CK_RV CK_ENTRY 562C_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 */ 574 575static 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} 584 585#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 586CK_RV CK_ENTRY 587C_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 */ 596 597static 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} 607 608#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 609CK_RV CK_ENTRY 610C_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 */ 620 621static 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} 632 633#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 634CK_RV CK_ENTRY 635C_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 */ 646 647static 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} 658 659#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 660CK_RV CK_ENTRY 661C_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 */ 672 673static 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} 683 684#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 685CK_RV CK_ENTRY 686C_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 */ 696 697static 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} 708 709#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 710CK_RV CK_ENTRY 711C_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 */ 722 723static 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} 731 732#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 733CK_RV CK_ENTRY 734C_FindObjectsFinal 735( 736 CK_SESSION_HANDLE hSession 737) 738{ 739 return __ADJOIN(MODULE_NAME,C_FindObjectsFinal)(hSession); 740} 741#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ 742 743static 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} 753 754#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 755CK_RV CK_ENTRY 756C_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 */ 766 767static 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} 779 780#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 781CK_RV CK_ENTRY 782C_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 */ 794 795static 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} 807 808#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 809CK_RV CK_ENTRY 810C_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 */ 822 823static 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} 833 834#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 835CK_RV CK_ENTRY 836C_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 */ 846 847static 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} 857 858#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 859CK_RV CK_ENTRY 860C_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 */ 870 871static 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} 883 884#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 885CK_RV CK_ENTRY 886C_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 */ 898 899static 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} 911 912#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 913CK_RV CK_ENTRY 914C_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 */ 926 927static 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} 937 938#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 939CK_RV CK_ENTRY 940C_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 */ 950 951static 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} 960 961#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 962CK_RV CK_ENTRY 963C_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 */ 972 973static 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} 985 986#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 987CK_RV CK_ENTRY 988C_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 */ 1000 1001static 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} 1011 1012#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1013CK_RV CK_ENTRY 1014C_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 */ 1024 1025static 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} 1034 1035#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1036CK_RV CK_ENTRY 1037C_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 */ 1046 1047static 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} 1057 1058#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1059CK_RV CK_ENTRY 1060C_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 */ 1070 1071static 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} 1081 1082#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1083CK_RV CK_ENTRY 1084C_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 */ 1094 1095static 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} 1107 1108#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1109CK_RV CK_ENTRY 1110C_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 */ 1122 1123static 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} 1133 1134#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1135CK_RV CK_ENTRY 1136C_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 */ 1146 1147static 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} 1157 1158#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1159CK_RV CK_ENTRY 1160C_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 */ 1170 1171static 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} 1181 1182#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1183CK_RV CK_ENTRY 1184C_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 */ 1194 1195static 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} 1207 1208#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1209CK_RV CK_ENTRY 1210C_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 */ 1222 1223static 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} 1233 1234#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1235CK_RV CK_ENTRY 1236C_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 */ 1246 1247static 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} 1259 1260#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1261CK_RV CK_ENTRY 1262C_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 */ 1274 1275static 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} 1285 1286#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1287CK_RV CK_ENTRY 1288C_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 */ 1298 1299static 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} 1309 1310#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1311CK_RV CK_ENTRY 1312C_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 */ 1322 1323static 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} 1333 1334#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1335CK_RV CK_ENTRY 1336C_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 */ 1346 1347static 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} 1359 1360#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1361CK_RV CK_ENTRY 1362C_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 */ 1374 1375static 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} 1387 1388#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1389CK_RV CK_ENTRY 1390C_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 */ 1402 1403static 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} 1415 1416#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1417CK_RV CK_ENTRY 1418C_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 */ 1430 1431static 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} 1443 1444#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1445CK_RV CK_ENTRY 1446C_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 */ 1458 1459static 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} 1471 1472#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1473CK_RV CK_ENTRY 1474C_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 */ 1486 1487static 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} 1499 1500#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1501CK_RV CK_ENTRY 1502C_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 */ 1514 1515static 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} 1530 1531#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1532CK_RV CK_ENTRY 1533C_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 */ 1548 1549static 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} 1562 1563#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1564CK_RV CK_ENTRY 1565C_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 */ 1578 1579static 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} 1594 1595#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1596CK_RV CK_ENTRY 1597C_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 */ 1612 1613static 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} 1626 1627#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1628CK_RV CK_ENTRY 1629C_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 */ 1642 1643static 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} 1653 1654#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1655CK_RV CK_ENTRY 1656C_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 */ 1666 1667static 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} 1677 1678#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1679CK_RV CK_ENTRY 1680C_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 */ 1690 1691static 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} 1699 1700#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1701CK_RV CK_ENTRY 1702C_GetFunctionStatus 1703( 1704 CK_SESSION_HANDLE hSession 1705) 1706{ 1707 return __ADJOIN(MODULE_NAME,C_GetFunctionStatus)(hSession); 1708} 1709#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ 1710 1711static 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} 1719 1720#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1721CK_RV CK_ENTRY 1722C_CancelFunction 1723( 1724 CK_SESSION_HANDLE hSession 1725) 1726{ 1727 return __ADJOIN(MODULE_NAME,C_CancelFunction)(hSession); 1728} 1729#endif /* DECLARE_STRICT_CRYPTOKI_NAMES */ 1730 1731static 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} 1741 1742#ifdef DECLARE_STRICT_CRYPTOKI_NAMES 1743CK_RV CK_ENTRY 1744C_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 */ 1754 1755static CK_RV CK_ENTRY 1756__ADJOIN(MODULE_NAME,C_GetFunctionList) 1757( 1758 CK_FUNCTION_LIST_PTR_PTR ppFunctionList 1759); 1760 1761static 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}; 1832 1833static 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} 1842 1843/* This one is always present */ 1844CK_RV CK_ENTRY 1845C_GetFunctionList 1846( 1847 CK_FUNCTION_LIST_PTR_PTR ppFunctionList 1848) 1849{ 1850 return __ADJOIN(MODULE_NAME,C_GetFunctionList)(ppFunctionList); 1851} 1852 1853#undef __ADJOIN 1854 1855