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