| OLD | NEW |
|---|
| (Empty) |
| 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, pulCou
nt); | |
| 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, ulNew
Len); | |
| 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, ul
NewLen); | |
| 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, p
hSession); | |
| 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, pulOp
erationStateLen); | |
| 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, pu
lOperationStateLen); | |
| 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, ulOpe
rationStateLen, 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, ul
OperationStateLen, 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, phObjec
t); | |
| 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, phOb
ject); | |
| 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, ulCoun
t, 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, ul
Count); | |
| 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, ul
Count); | |
| 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, ulMaxObjectCoun
t, 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, pEncryptedD
ata, 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, pEncrypt
edPart, 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, pEncr
yptedPart, 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, pulLast
EncryptedPartLen); | |
| 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, pulL
astEncryptedPartLen); | |
| 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, ulEncryptedDataL
en, 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, ulEncryptedDa
taLen, 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, ulEncrypte
dPartLen, 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, ulEncry
ptedPartLen, 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, pulLastPartLe
n); | |
| 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, pulDig
estLen); | |
| 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, pul
DigestLen); | |
| 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, pulSi
gnatureLen); | |
| 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, pu
lSignatureLen); | |
| 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, pSignat
ure, 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, ulS
ignatureLen); | |
| 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, ulSignatureLe
n); | |
| 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, ulSignature
Len, 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, pE
ncryptedPart, 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, ulEn
cryptedPartLen, 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, u
lEncryptedPartLen, 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, pEnc
ryptedPart, 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, p
EncryptedPart, 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, ulEn
cryptedPartLen, 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, u
lEncryptedPartLen, 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, ulCou
nt, 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, ul
Count, 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, pPublicKeyTe
mplate, ulPublicKeyAttributeCount, pPrivateKeyTemplate, ulPrivateKeyAttributeCou
nt, 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, pPublicKe
yTemplate, ulPublicKeyAttributeCount, pPrivateKeyTemplate, ulPrivateKeyAttribute
Count, 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, hKe
y, 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, pW
rappedKey, 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, pTemplat
e, 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, pTemp
late, 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, ulRandomLe
n); | |
| 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 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 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 #ifndef NSS_STATIC | |
| 1844 /* This one is always present */ | |
| 1845 CK_RV CK_ENTRY | |
| 1846 C_GetFunctionList | |
| 1847 ( | |
| 1848 CK_FUNCTION_LIST_PTR_PTR ppFunctionList | |
| 1849 ) | |
| 1850 { | |
| 1851 return __ADJOIN(MODULE_NAME,C_GetFunctionList)(ppFunctionList); | |
| 1852 } | |
| 1853 #endif | |
| 1854 | |
| 1855 #undef __ADJOIN | |
| 1856 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2078763002:
Delete bundled copy of NSS and replace with README. (Closed)
Base URL: https://chromium.googlesource.com/chromium/deps/nss@master