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