← Back to branch summary

~ubuntu-branches/ubuntu/trusty/xulrunner/trusty

« back to all changes in this revision

Viewing changes to security/nss-fips/lib/ckfw/nssck.api

  • Committer: Bazaar Package Importer
  • Author(s): Devid Antonio Filoni
  • Date: 2008-08-25 13:04:18 UTC
  • mfrom: (1.1.12 upstream)
  • Revision ID: james.westby@ubuntu.com-20080825130418-ck1i2ms384tzb9m0
Tags: 1.8.1.16+nobinonly-0ubuntu1
https://launchpad.net/bugs/254618
* New upstream release (taken from upstream CVS), LP: #254618.
* Fix MFSA 2008-35, MFSA 2008-34, MFSA 2008-33, MFSA 2008-32, MFSA 2008-31,
  MFSA 2008-30, MFSA 2008-29, MFSA 2008-28, MFSA 2008-27, MFSA 2008-25,
  MFSA 2008-24, MFSA 2008-23, MFSA 2008-22, MFSA 2008-21, MFSA 2008-26 also
  known as CVE-2008-2933, CVE-2008-2785, CVE-2008-2811, CVE-2008-2810,
  CVE-2008-2809, CVE-2008-2808, CVE-2008-2807, CVE-2008-2806, CVE-2008-2805,
  CVE-2008-2803, CVE-2008-2802, CVE-2008-2801, CVE-2008-2800, CVE-2008-2798.
* Drop 89_bz419350_attachment_306066 patch, merged upstream.
* Bump Standards-Version to 3.8.0.

Show diffs side-by-side

added added

removed removed

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