Mercurial > trustbridge > nss-cmake-static

comparison nss/lib/ckfw/nssck.api @ 0:1e5118fa0cb1

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