← Back to branch summary

~ubuntu-branches/ubuntu/precise/kompozer/precise

« back to all changes in this revision

Viewing changes to mozilla/security/nss/lib/ckfw/sessobj.c

  • Committer: Bazaar Package Importer
  • Author(s): Anthony Yarusso
  • Date: 2007-08-27 01:11:03 UTC
  • Revision ID: james.westby@ubuntu.com-20070827011103-2jgf4s6532gqu2ka
Tags: upstream-0.7.10
Import upstream version 0.7.10

Show diffs side-by-side

added added

removed removed

Lines of Context:
mozilla/security/nss/lib/ckfw/sessobj.c
 
1
/* 
 
2
 * The contents of this file are subject to the Mozilla Public
 
3
 * License Version 1.1 (the "License"); you may not use this file
 
4
 * except in compliance with the License. You may obtain a copy of
 
5
 * the License at http://www.mozilla.org/MPL/
 
6
 * 
 
7
 * Software distributed under the License is distributed on an "AS
 
8
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 
9
 * implied. See the License for the specific language governing
 
10
 * rights and limitations under the License.
 
11
 * 
 
12
 * The Original Code is the Netscape security libraries.
 
13
 * 
 
14
 * The Initial Developer of the Original Code is Netscape
 
15
 * Communications Corporation.  Portions created by Netscape are 
 
16
 * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
 
17
 * Rights Reserved.
 
18
 * 
 
19
 * Contributor(s):
 
20
 * 
 
21
 * Alternatively, the contents of this file may be used under the
 
22
 * terms of the GNU General Public License Version 2 or later (the
 
23
 * "GPL"), in which case the provisions of the GPL are applicable 
 
24
 * instead of those above.  If you wish to allow use of your 
 
25
 * version of this file only under the terms of the GPL and not to
 
26
 * allow others to use your version of this file under the MPL,
 
27
 * indicate your decision by deleting the provisions above and
 
28
 * replace them with the notice and other provisions required by
 
29
 * the GPL.  If you do not delete the provisions above, a recipient
 
30
 * may use your version of this file under either the MPL or the
 
31
 * GPL.
 
32
 */
 
33
 
 
34
#ifdef DEBUG
 
35
static const char CVS_ID[] = "@(#) $RCSfile: sessobj.c,v $ $Revision: 1.10 $ $Date: 2002/04/05 19:38:03 $ $Name: FIREFOX_1_0_RELEASE $";
 
36
#endif /* DEBUG */
 
37
 
 
38
/*
 
39
 * sessobj.c
 
40
 *
 
41
 * This file contains an NSSCKMDObject implementation for session 
 
42
 * objects.  The framework uses this implementation to manage
 
43
 * session objects when a Module doesn't wish to be bothered.
 
44
 */
 
45
 
 
46
#ifndef CK_T
 
47
#include "ck.h"
 
48
#endif /* CK_T */
 
49
 
 
50
/*
 
51
 * nssCKMDSessionObject
 
52
 *
 
53
 *  -- create --
 
54
 *  nssCKMDSessionObject_Create
 
55
 *
 
56
 *  -- EPV calls --
 
57
 *  nss_ckmdSessionObject_Finalize
 
58
 *  nss_ckmdSessionObject_IsTokenObject
 
59
 *  nss_ckmdSessionObject_GetAttributeCount
 
60
 *  nss_ckmdSessionObject_GetAttributeTypes
 
61
 *  nss_ckmdSessionObject_GetAttributeSize
 
62
 *  nss_ckmdSessionObject_GetAttribute
 
63
 *  nss_ckmdSessionObject_SetAttribute
 
64
 *  nss_ckmdSessionObject_GetObjectSize
 
65
 */
 
66
 
 
67
struct nssCKMDSessionObjectStr {
 
68
  CK_ULONG n;
 
69
  NSSArena *arena;
 
70
  NSSItem *attributes;
 
71
  CK_ATTRIBUTE_TYPE_PTR types;
 
72
  nssCKFWHash *hash;
 
73
};
 
74
typedef struct nssCKMDSessionObjectStr nssCKMDSessionObject;
 
75
 
 
76
#ifdef DEBUG
 
77
/*
 
78
 * But first, the pointer-tracking stuff.
 
79
 *
 
80
 * NOTE: the pointer-tracking support in NSS/base currently relies
 
81
 * upon NSPR's CallOnce support.  That, however, relies upon NSPR's
 
82
 * locking, which is tied into the runtime.  We need a pointer-tracker
 
83
 * implementation that uses the locks supplied through C_Initialize.
 
84
 * That support, however, can be filled in later.  So for now, I'll
 
85
 * just do this routines as no-ops.
 
86
 */
 
87
 
 
88
static CK_RV
 
89
nss_ckmdSessionObject_add_pointer
 
90
(
 
91
  const NSSCKMDObject *mdObject
 
92
)
 
93
{
 
94
  return CKR_OK;
 
95
}
 
96
 
 
97
static CK_RV
 
98
nss_ckmdSessionObject_remove_pointer
 
99
(
 
100
  const NSSCKMDObject *mdObject
 
101
)
 
102
{
 
103
  return CKR_OK;
 
104
}
 
105
 
 
106
#ifdef NSS_DEBUG
 
107
static CK_RV
 
108
nss_ckmdSessionObject_verifyPointer
 
109
(
 
110
  const NSSCKMDObject *mdObject
 
111
)
 
112
{
 
113
  return CKR_OK;
 
114
}
 
115
#endif
 
116
 
 
117
#endif /* DEBUG */
 
118
 
 
119
/*
 
120
 * We must forward-declare these routines
 
121
 */
 
122
static void
 
123
nss_ckmdSessionObject_Finalize
 
124
(
 
125
  NSSCKMDObject *mdObject,
 
126
  NSSCKFWObject *fwObject,
 
127
  NSSCKMDSession *mdSession,
 
128
  NSSCKFWSession *fwSession,
 
129
  NSSCKMDToken *mdToken,
 
130
  NSSCKFWToken *fwToken,
 
131
  NSSCKMDInstance *mdInstance,
 
132
  NSSCKFWInstance *fwInstance
 
133
);
 
134
 
 
135
static CK_RV
 
136
nss_ckmdSessionObject_Destroy
 
137
(
 
138
  NSSCKMDObject *mdObject,
 
139
  NSSCKFWObject *fwObject,
 
140
  NSSCKMDSession *mdSession,
 
141
  NSSCKFWSession *fwSession,
 
142
  NSSCKMDToken *mdToken,
 
143
  NSSCKFWToken *fwToken,
 
144
  NSSCKMDInstance *mdInstance,
 
145
  NSSCKFWInstance *fwInstance
 
146
);
 
147
 
 
148
static CK_BBOOL
 
149
nss_ckmdSessionObject_IsTokenObject
 
150
(
 
151
  NSSCKMDObject *mdObject,
 
152
  NSSCKFWObject *fwObject,
 
153
  NSSCKMDSession *mdSession,
 
154
  NSSCKFWSession *fwSession,
 
155
  NSSCKMDToken *mdToken,
 
156
  NSSCKFWToken *fwToken,
 
157
  NSSCKMDInstance *mdInstance,
 
158
  NSSCKFWInstance *fwInstance
 
159
);
 
160
 
 
161
static CK_ULONG
 
162
nss_ckmdSessionObject_GetAttributeCount
 
163
(
 
164
  NSSCKMDObject *mdObject,
 
165
  NSSCKFWObject *fwObject,
 
166
  NSSCKMDSession *mdSession,
 
167
  NSSCKFWSession *fwSession,
 
168
  NSSCKMDToken *mdToken,
 
169
  NSSCKFWToken *fwToken,
 
170
  NSSCKMDInstance *mdInstance,
 
171
  NSSCKFWInstance *fwInstance,
 
172
  CK_RV *pError
 
173
);
 
174
 
 
175
static CK_RV
 
176
nss_ckmdSessionObject_GetAttributeTypes
 
177
(
 
178
  NSSCKMDObject *mdObject,
 
179
  NSSCKFWObject *fwObject,
 
180
  NSSCKMDSession *mdSession,
 
181
  NSSCKFWSession *fwSession,
 
182
  NSSCKMDToken *mdToken,
 
183
  NSSCKFWToken *fwToken,
 
184
  NSSCKMDInstance *mdInstance,
 
185
  NSSCKFWInstance *fwInstance,
 
186
  CK_ATTRIBUTE_TYPE_PTR typeArray,
 
187
  CK_ULONG ulCount
 
188
);
 
189
 
 
190
static CK_ULONG
 
191
nss_ckmdSessionObject_GetAttributeSize
 
192
(
 
193
  NSSCKMDObject *mdObject,
 
194
  NSSCKFWObject *fwObject,
 
195
  NSSCKMDSession *mdSession,
 
196
  NSSCKFWSession *fwSession,
 
197
  NSSCKMDToken *mdToken,
 
198
  NSSCKFWToken *fwToken,
 
199
  NSSCKMDInstance *mdInstance,
 
200
  NSSCKFWInstance *fwInstance,
 
201
  CK_ATTRIBUTE_TYPE attribute,
 
202
  CK_RV *pError
 
203
);
 
204
 
 
205
static NSSCKFWItem
 
206
nss_ckmdSessionObject_GetAttribute
 
207
(
 
208
  NSSCKMDObject *mdObject,
 
209
  NSSCKFWObject *fwObject,
 
210
  NSSCKMDSession *mdSession,
 
211
  NSSCKFWSession *fwSession,
 
212
  NSSCKMDToken *mdToken,
 
213
  NSSCKFWToken *fwToken,
 
214
  NSSCKMDInstance *mdInstance,
 
215
  NSSCKFWInstance *fwInstance,
 
216
  CK_ATTRIBUTE_TYPE attribute,
 
217
  CK_RV *pError
 
218
);
 
219
 
 
220
static CK_RV
 
221
nss_ckmdSessionObject_SetAttribute
 
222
(
 
223
  NSSCKMDObject *mdObject,
 
224
  NSSCKFWObject *fwObject,
 
225
  NSSCKMDSession *mdSession,
 
226
  NSSCKFWSession *fwSession,
 
227
  NSSCKMDToken *mdToken,
 
228
  NSSCKFWToken *fwToken,
 
229
  NSSCKMDInstance *mdInstance,
 
230
  NSSCKFWInstance *fwInstance,
 
231
  CK_ATTRIBUTE_TYPE attribute,
 
232
  NSSItem *value
 
233
);
 
234
 
 
235
static CK_ULONG
 
236
nss_ckmdSessionObject_GetObjectSize
 
237
(
 
238
  NSSCKMDObject *mdObject,
 
239
  NSSCKFWObject *fwObject,
 
240
  NSSCKMDSession *mdSession,
 
241
  NSSCKFWSession *fwSession,
 
242
  NSSCKMDToken *mdToken,
 
243
  NSSCKFWToken *fwToken,
 
244
  NSSCKMDInstance *mdInstance,
 
245
  NSSCKFWInstance *fwInstance,
 
246
  CK_RV *pError
 
247
);
 
248
 
 
249
/*
 
250
 * nssCKMDSessionObject_Create
 
251
 *
 
252
 */
 
253
NSS_IMPLEMENT NSSCKMDObject *
 
254
nssCKMDSessionObject_Create
 
255
(
 
256
  NSSCKFWToken *fwToken,
 
257
  NSSArena *arena,
 
258
  CK_ATTRIBUTE_PTR attributes,
 
259
  CK_ULONG ulCount,
 
260
  CK_RV *pError
 
261
)
 
262
{
 
263
  NSSCKMDObject *mdObject = (NSSCKMDObject *)NULL;
 
264
  nssCKMDSessionObject *mdso = (nssCKMDSessionObject *)NULL;
 
265
  CK_ULONG i;
 
266
  nssCKFWHash *hash;
 
267
 
 
268
  mdso = nss_ZNEW(arena, nssCKMDSessionObject);
 
269
  if( (nssCKMDSessionObject *)NULL == mdso ) {
 
270
    goto loser;
 
271
  }
 
272
 
 
273
  mdso->arena = arena;
 
274
  mdso->n = ulCount;
 
275
  mdso->attributes = nss_ZNEWARRAY(arena, NSSItem, ulCount);
 
276
  if( (NSSItem *)NULL == mdso->attributes ) {
 
277
    goto loser;
 
278
  }
 
279
 
 
280
  mdso->types = nss_ZNEWARRAY(arena, CK_ATTRIBUTE_TYPE, ulCount);
 
281
 
 
282
  for( i = 0; i < ulCount; i++ ) {
 
283
    mdso->types[i] = attributes[i].type;
 
284
    mdso->attributes[i].size = attributes[i].ulValueLen;
 
285
    mdso->attributes[i].data = nss_ZAlloc(arena, attributes[i].ulValueLen);
 
286
    if( (void *)NULL == mdso->attributes[i].data ) {
 
287
      goto loser;
 
288
    }
 
289
    (void)nsslibc_memcpy(mdso->attributes[i].data, attributes[i].pValue,
 
290
      attributes[i].ulValueLen);
 
291
  }
 
292
 
 
293
  mdObject = nss_ZNEW(arena, NSSCKMDObject);
 
294
  if( (NSSCKMDObject *)NULL == mdObject ) {
 
295
    goto loser;
 
296
  }
 
297
 
 
298
  mdObject->etc = (void *)mdso;
 
299
  mdObject->Finalize = nss_ckmdSessionObject_Finalize;
 
300
  mdObject->Destroy = nss_ckmdSessionObject_Destroy;
 
301
  mdObject->IsTokenObject = nss_ckmdSessionObject_IsTokenObject;
 
302
  mdObject->GetAttributeCount = nss_ckmdSessionObject_GetAttributeCount;
 
303
  mdObject->GetAttributeTypes = nss_ckmdSessionObject_GetAttributeTypes;
 
304
  mdObject->GetAttributeSize = nss_ckmdSessionObject_GetAttributeSize;
 
305
  mdObject->GetAttribute = nss_ckmdSessionObject_GetAttribute;
 
306
  mdObject->SetAttribute = nss_ckmdSessionObject_SetAttribute;
 
307
  mdObject->GetObjectSize = nss_ckmdSessionObject_GetObjectSize;
 
308
 
 
309
  hash = nssCKFWToken_GetSessionObjectHash(fwToken);
 
310
  if( (nssCKFWHash *)NULL == hash ) {
 
311
    *pError = CKR_GENERAL_ERROR;
 
312
    goto loser;
 
313
  }
 
314
 
 
315
  mdso->hash = hash;
 
316
 
 
317
  *pError = nssCKFWHash_Add(hash, mdObject, mdObject);
 
318
  if( CKR_OK != *pError ) {
 
319
    goto loser;
 
320
  }
 
321
 
 
322
#ifdef DEBUG
 
323
  if( CKR_OK != nss_ckmdSessionObject_add_pointer(mdObject) ) {
 
324
    goto loser;
 
325
  }
 
326
#endif /* DEBUG */
 
327
 
 
328
  *pError = CKR_OK;
 
329
  return mdObject;
 
330
 
 
331
 loser:
 
332
  if( (nssCKMDSessionObject *)NULL != mdso ) {
 
333
    if( (NSSItem *)NULL != mdso->attributes ) {
 
334
      for( i = 0; i < ulCount; i++ ) {
 
335
        nss_ZFreeIf(mdso->attributes[i].data);
 
336
      }
 
337
 
 
338
      nss_ZFreeIf(mdso->attributes);
 
339
    }
 
340
 
 
341
    nss_ZFreeIf(mdso->types);
 
342
    nss_ZFreeIf(mdso);
 
343
  }
 
344
 
 
345
  nss_ZFreeIf(mdObject);
 
346
  *pError = CKR_HOST_MEMORY;
 
347
  return (NSSCKMDObject *)NULL;
 
348
}
 
349
 
 
350
/*
 
351
 * nss_ckmdSessionObject_Finalize
 
352
 *
 
353
 */
 
354
static void
 
355
nss_ckmdSessionObject_Finalize
 
356
(
 
357
  NSSCKMDObject *mdObject,
 
358
  NSSCKFWObject *fwObject,
 
359
  NSSCKMDSession *mdSession,
 
360
  NSSCKFWSession *fwSession,
 
361
  NSSCKMDToken *mdToken,
 
362
  NSSCKFWToken *fwToken,
 
363
  NSSCKMDInstance *mdInstance,
 
364
  NSSCKFWInstance *fwInstance
 
365
)
 
366
{
 
367
  /* This shouldn't ever be called */
 
368
  return;
 
369
}
 
370
 
 
371
/*
 
372
 * nss_ckmdSessionObject_Destroy
 
373
 *
 
374
 */
 
375
 
 
376
static CK_RV
 
377
nss_ckmdSessionObject_Destroy
 
378
(
 
379
  NSSCKMDObject *mdObject,
 
380
  NSSCKFWObject *fwObject,
 
381
  NSSCKMDSession *mdSession,
 
382
  NSSCKFWSession *fwSession,
 
383
  NSSCKMDToken *mdToken,
 
384
  NSSCKFWToken *fwToken,
 
385
  NSSCKMDInstance *mdInstance,
 
386
  NSSCKFWInstance *fwInstance
 
387
)
 
388
{
 
389
#ifdef NSSDEBUG
 
390
  CK_RV error = CKR_OK;
 
391
#endif /* NSSDEBUG */
 
392
  nssCKMDSessionObject *mdso;
 
393
  CK_ULONG i;
 
394
 
 
395
#ifdef NSSDEBUG
 
396
  error = nss_ckmdSessionObject_verifyPointer(mdObject);
 
397
  if( CKR_OK != error ) {
 
398
    return error;
 
399
  }
 
400
#endif /* NSSDEBUG */
 
401
 
 
402
  mdso = (nssCKMDSessionObject *)mdObject->etc;
 
403
 
 
404
  nssCKFWHash_Remove(mdso->hash, mdObject);
 
405
 
 
406
  for( i = 0; i < mdso->n; i++ ) {
 
407
    nss_ZFreeIf(mdso->attributes[i].data);
 
408
  }
 
409
  nss_ZFreeIf(mdso->attributes);
 
410
  nss_ZFreeIf(mdso->types);
 
411
  nss_ZFreeIf(mdso);
 
412
  nss_ZFreeIf(mdObject);
 
413
 
 
414
#ifdef DEBUG
 
415
  (void)nss_ckmdSessionObject_remove_pointer(mdObject);
 
416
#endif /* DEBUG */
 
417
 
 
418
  return CKR_OK;
 
419
}
 
420
 
 
421
/*
 
422
 * nss_ckmdSessionObject_IsTokenObject
 
423
 *
 
424
 */
 
425
 
 
426
static CK_BBOOL
 
427
nss_ckmdSessionObject_IsTokenObject
 
428
(
 
429
  NSSCKMDObject *mdObject,
 
430
  NSSCKFWObject *fwObject,
 
431
  NSSCKMDSession *mdSession,
 
432
  NSSCKFWSession *fwSession,
 
433
  NSSCKMDToken *mdToken,
 
434
  NSSCKFWToken *fwToken,
 
435
  NSSCKMDInstance *mdInstance,
 
436
  NSSCKFWInstance *fwInstance
 
437
)
 
438
{
 
439
#ifdef NSSDEBUG
 
440
  if( CKR_OK != nss_ckmdSessionObject_verifyPointer(mdObject) ) {
 
441
    return CK_FALSE;
 
442
  }
 
443
#endif /* NSSDEBUG */
 
444
 
 
445
  /*
 
446
   * This implementation is only ever used for session objects.
 
447
   */
 
448
  return CK_FALSE;
 
449
}
 
450
 
 
451
/*
 
452
 * nss_ckmdSessionObject_GetAttributeCount
 
453
 *
 
454
 */
 
455
static CK_ULONG
 
456
nss_ckmdSessionObject_GetAttributeCount
 
457
(
 
458
  NSSCKMDObject *mdObject,
 
459
  NSSCKFWObject *fwObject,
 
460
  NSSCKMDSession *mdSession,
 
461
  NSSCKFWSession *fwSession,
 
462
  NSSCKMDToken *mdToken,
 
463
  NSSCKFWToken *fwToken,
 
464
  NSSCKMDInstance *mdInstance,
 
465
  NSSCKFWInstance *fwInstance,
 
466
  CK_RV *pError
 
467
)
 
468
{
 
469
  nssCKMDSessionObject *obj;
 
470
 
 
471
#ifdef NSSDEBUG
 
472
  if( (CK_RV *)NULL == pError ) {
 
473
    return 0;
 
474
  }
 
475
 
 
476
  *pError = nss_ckmdSessionObject_verifyPointer(mdObject);
 
477
  if( CKR_OK != *pError ) {
 
478
    return 0;
 
479
  }
 
480
 
 
481
  /* We could even check all the other arguments, for sanity. */
 
482
#endif /* NSSDEBUG */
 
483
 
 
484
  obj = (nssCKMDSessionObject *)mdObject->etc;
 
485
 
 
486
  return obj->n;
 
487
}
 
488
 
 
489
/*
 
490
 * nss_ckmdSessionObject_GetAttributeTypes
 
491
 *
 
492
 */
 
493
static CK_RV
 
494
nss_ckmdSessionObject_GetAttributeTypes
 
495
(
 
496
  NSSCKMDObject *mdObject,
 
497
  NSSCKFWObject *fwObject,
 
498
  NSSCKMDSession *mdSession,
 
499
  NSSCKFWSession *fwSession,
 
500
  NSSCKMDToken *mdToken,
 
501
  NSSCKFWToken *fwToken,
 
502
  NSSCKMDInstance *mdInstance,
 
503
  NSSCKFWInstance *fwInstance,
 
504
  CK_ATTRIBUTE_TYPE_PTR typeArray,
 
505
  CK_ULONG ulCount
 
506
)
 
507
{
 
508
#ifdef NSSDEBUG
 
509
  CK_RV error = CKR_OK;
 
510
#endif /* NSSDEBUG */
 
511
  nssCKMDSessionObject *obj;
 
512
 
 
513
#ifdef NSSDEBUG
 
514
  error = nss_ckmdSessionObject_verifyPointer(mdObject);
 
515
  if( CKR_OK != error ) {
 
516
    return error;
 
517
  }
 
518
 
 
519
  /* We could even check all the other arguments, for sanity. */
 
520
#endif /* NSSDEBUG */
 
521
 
 
522
  obj = (nssCKMDSessionObject *)mdObject->etc;
 
523
 
 
524
  if( ulCount < obj->n ) {
 
525
    return CKR_BUFFER_TOO_SMALL;
 
526
  }
 
527
 
 
528
  (void)nsslibc_memcpy(typeArray, obj->types, 
 
529
    sizeof(CK_ATTRIBUTE_TYPE) * obj->n);
 
530
 
 
531
  return CKR_OK;
 
532
}
 
533
 
 
534
/*
 
535
 * nss_ckmdSessionObject_GetAttributeSize
 
536
 *
 
537
 */
 
538
static CK_ULONG
 
539
nss_ckmdSessionObject_GetAttributeSize
 
540
(
 
541
  NSSCKMDObject *mdObject,
 
542
  NSSCKFWObject *fwObject,
 
543
  NSSCKMDSession *mdSession,
 
544
  NSSCKFWSession *fwSession,
 
545
  NSSCKMDToken *mdToken,
 
546
  NSSCKFWToken *fwToken,
 
547
  NSSCKMDInstance *mdInstance,
 
548
  NSSCKFWInstance *fwInstance,
 
549
  CK_ATTRIBUTE_TYPE attribute,
 
550
  CK_RV *pError
 
551
)
 
552
{
 
553
  nssCKMDSessionObject *obj;
 
554
  CK_ULONG i;
 
555
 
 
556
#ifdef NSSDEBUG
 
557
  if( (CK_RV *)NULL == pError ) {
 
558
    return 0;
 
559
  }
 
560
 
 
561
  *pError = nss_ckmdSessionObject_verifyPointer(mdObject);
 
562
  if( CKR_OK != *pError ) {
 
563
    return 0;
 
564
  }
 
565
 
 
566
  /* We could even check all the other arguments, for sanity. */
 
567
#endif /* NSSDEBUG */
 
568
 
 
569
  obj = (nssCKMDSessionObject *)mdObject->etc;
 
570
 
 
571
  for( i = 0; i < obj->n; i++ ) {
 
572
    if( attribute == obj->types[i] ) {
 
573
      return (CK_ULONG)(obj->attributes[i].size);
 
574
    }
 
575
  }
 
576
 
 
577
  *pError = CKR_ATTRIBUTE_TYPE_INVALID;
 
578
  return 0;
 
579
}
 
580
 
 
581
/*
 
582
 * nss_ckmdSessionObject_GetAttribute
 
583
 *
 
584
 */
 
585
static NSSCKFWItem
 
586
nss_ckmdSessionObject_GetAttribute
 
587
(
 
588
  NSSCKMDObject *mdObject,
 
589
  NSSCKFWObject *fwObject,
 
590
  NSSCKMDSession *mdSession,
 
591
  NSSCKFWSession *fwSession,
 
592
  NSSCKMDToken *mdToken,
 
593
  NSSCKFWToken *fwToken,
 
594
  NSSCKMDInstance *mdInstance,
 
595
  NSSCKFWInstance *fwInstance,
 
596
  CK_ATTRIBUTE_TYPE attribute,
 
597
  CK_RV *pError
 
598
)
 
599
{
 
600
  NSSCKFWItem item;
 
601
  nssCKMDSessionObject *obj;
 
602
  CK_ULONG i;
 
603
 
 
604
  item.needsFreeing = PR_FALSE;
 
605
  item.item = NULL;
 
606
#ifdef NSSDEBUG
 
607
  if( (CK_RV *)NULL == pError ) {
 
608
    return item;
 
609
  }
 
610
 
 
611
  *pError = nss_ckmdSessionObject_verifyPointer(mdObject);
 
612
  if( CKR_OK != *pError ) {
 
613
    return item;
 
614
  }
 
615
 
 
616
  /* We could even check all the other arguments, for sanity. */
 
617
#endif /* NSSDEBUG */
 
618
 
 
619
  obj = (nssCKMDSessionObject *)mdObject->etc;
 
620
 
 
621
  for( i = 0; i < obj->n; i++ ) {
 
622
    if( attribute == obj->types[i] ) {
 
623
      item.item = &obj->attributes[i];
 
624
      return item;
 
625
    }
 
626
  }
 
627
 
 
628
  *pError = CKR_ATTRIBUTE_TYPE_INVALID;
 
629
  return item;
 
630
}
 
631
 
 
632
/*
 
633
 * nss_ckmdSessionObject_SetAttribute
 
634
 *
 
635
 */
 
636
 
 
637
/*
 
638
 * Okay, so this implementation sucks.  It doesn't support removing
 
639
 * an attribute (if value == NULL), and could be more graceful about
 
640
 * memory.  It should allow "blank" slots in the arrays, with some
 
641
 * invalid attribute type, and then it could support removal much
 
642
 * more easily.  Do this later.
 
643
 */
 
644
static CK_RV
 
645
nss_ckmdSessionObject_SetAttribute
 
646
(
 
647
  NSSCKMDObject *mdObject,
 
648
  NSSCKFWObject *fwObject,
 
649
  NSSCKMDSession *mdSession,
 
650
  NSSCKFWSession *fwSession,
 
651
  NSSCKMDToken *mdToken,
 
652
  NSSCKFWToken *fwToken,
 
653
  NSSCKMDInstance *mdInstance,
 
654
  NSSCKFWInstance *fwInstance,
 
655
  CK_ATTRIBUTE_TYPE attribute,
 
656
  NSSItem *value
 
657
)
 
658
{
 
659
  nssCKMDSessionObject *obj;
 
660
  CK_ULONG i;
 
661
  NSSItem n;
 
662
  NSSItem *ra;
 
663
  CK_ATTRIBUTE_TYPE_PTR rt;
 
664
#ifdef NSSDEBUG
 
665
  CK_RV error;
 
666
#endif /* NSSDEBUG */
 
667
 
 
668
#ifdef NSSDEBUG
 
669
  error = nss_ckmdSessionObject_verifyPointer(mdObject);
 
670
  if( CKR_OK != error ) {
 
671
    return 0;
 
672
  }
 
673
 
 
674
  /* We could even check all the other arguments, for sanity. */
 
675
#endif /* NSSDEBUG */
 
676
 
 
677
  obj = (nssCKMDSessionObject *)mdObject->etc;
 
678
 
 
679
  n.size = value->size;
 
680
  n.data = nss_ZAlloc(obj->arena, n.size);
 
681
  if( (void *)NULL == n.data ) {
 
682
    return CKR_HOST_MEMORY;
 
683
  }
 
684
  (void)nsslibc_memcpy(n.data, value->data, n.size);
 
685
 
 
686
  for( i = 0; i < obj->n; i++ ) {
 
687
    if( attribute == obj->types[i] ) {
 
688
      nss_ZFreeIf(obj->attributes[i].data);
 
689
      obj->attributes[i] = n;
 
690
      return CKR_OK;
 
691
    }
 
692
  }
 
693
 
 
694
  /*
 
695
   * It's new.
 
696
   */
 
697
 
 
698
  ra = (NSSItem *)nss_ZRealloc(obj->attributes, sizeof(NSSItem) * (obj->n + 1));
 
699
  if( (NSSItem *)NULL == ra ) {
 
700
    nss_ZFreeIf(n.data);
 
701
    return CKR_HOST_MEMORY;
 
702
  }
 
703
 
 
704
  rt = (CK_ATTRIBUTE_TYPE_PTR)nss_ZRealloc(obj->types, (obj->n + 1));
 
705
  if( (CK_ATTRIBUTE_TYPE_PTR)NULL == rt ) {
 
706
    nss_ZFreeIf(n.data);
 
707
    obj->attributes = (NSSItem *)nss_ZRealloc(ra, sizeof(NSSItem) * obj->n);
 
708
    if( (NSSItem *)NULL == obj->attributes ) {
 
709
      return CKR_GENERAL_ERROR;
 
710
    }
 
711
    return CKR_HOST_MEMORY;
 
712
  }
 
713
 
 
714
  obj->attributes = ra;
 
715
  obj->types = rt;
 
716
  obj->attributes[obj->n] = n;
 
717
  obj->types[obj->n] = attribute;
 
718
  obj->n++;
 
719
 
 
720
  return CKR_OK;
 
721
}
 
722
 
 
723
/*
 
724
 * nss_ckmdSessionObject_GetObjectSize
 
725
 *
 
726
 */
 
727
static CK_ULONG
 
728
nss_ckmdSessionObject_GetObjectSize
 
729
(
 
730
  NSSCKMDObject *mdObject,
 
731
  NSSCKFWObject *fwObject,
 
732
  NSSCKMDSession *mdSession,
 
733
  NSSCKFWSession *fwSession,
 
734
  NSSCKMDToken *mdToken,
 
735
  NSSCKFWToken *fwToken,
 
736
  NSSCKMDInstance *mdInstance,
 
737
  NSSCKFWInstance *fwInstance,
 
738
  CK_RV *pError
 
739
)
 
740
{
 
741
  nssCKMDSessionObject *obj;
 
742
  CK_ULONG i;
 
743
  CK_ULONG rv = (CK_ULONG)0;
 
744
 
 
745
#ifdef NSSDEBUG
 
746
  if( (CK_RV *)NULL == pError ) {
 
747
    return 0;
 
748
  }
 
749
 
 
750
  *pError = nss_ckmdSessionObject_verifyPointer(mdObject);
 
751
  if( CKR_OK != *pError ) {
 
752
    return 0;
 
753
  }
 
754
 
 
755
  /* We could even check all the other arguments, for sanity. */
 
756
#endif /* NSSDEBUG */
 
757
 
 
758
  obj = (nssCKMDSessionObject *)mdObject->etc;
 
759
 
 
760
  for( i = 0; i < obj->n; i++ ) {
 
761
    rv += obj->attributes[i].size;
 
762
  }
 
763
 
 
764
  rv += sizeof(NSSItem) * obj->n;
 
765
  rv += sizeof(CK_ATTRIBUTE_TYPE) * obj->n;
 
766
  rv += sizeof(nssCKMDSessionObject);
 
767
 
 
768
  return rv;
 
769
}
 
770
 
 
771
/*
 
772
 * nssCKMDFindSessionObjects
 
773
 *
 
774
 *  -- create --
 
775
 *  nssCKMDFindSessionObjects_Create
 
776
 *
 
777
 *  -- EPV calls --
 
778
 *  nss_ckmdFindSessionObjects_Final
 
779
 *  nss_ckmdFindSessionObjects_Next
 
780
 */
 
781
 
 
782
struct nodeStr {
 
783
  struct nodeStr *next;
 
784
  NSSCKMDObject *mdObject;
 
785
};
 
786
 
 
787
struct nssCKMDFindSessionObjectsStr {
 
788
  NSSArena *arena;
 
789
  CK_RV error;
 
790
  CK_ATTRIBUTE_PTR pTemplate;
 
791
  CK_ULONG ulCount;
 
792
  struct nodeStr *list;
 
793
  nssCKFWHash *hash;
 
794
 
 
795
};
 
796
typedef struct nssCKMDFindSessionObjectsStr nssCKMDFindSessionObjects;
 
797
 
 
798
#ifdef DEBUG
 
799
/*
 
800
 * But first, the pointer-tracking stuff.
 
801
 *
 
802
 * NOTE: the pointer-tracking support in NSS/base currently relies
 
803
 * upon NSPR's CallOnce support.  That, however, relies upon NSPR's
 
804
 * locking, which is tied into the runtime.  We need a pointer-tracker
 
805
 * implementation that uses the locks supplied through C_Initialize.
 
806
 * That support, however, can be filled in later.  So for now, I'll
 
807
 * just do this routines as no-ops.
 
808
 */
 
809
 
 
810
static CK_RV
 
811
nss_ckmdFindSessionObjects_add_pointer
 
812
(
 
813
  const NSSCKMDFindObjects *mdFindObjects
 
814
)
 
815
{
 
816
  return CKR_OK;
 
817
}
 
818
 
 
819
static CK_RV
 
820
nss_ckmdFindSessionObjects_remove_pointer
 
821
(
 
822
  const NSSCKMDFindObjects *mdFindObjects
 
823
)
 
824
{
 
825
  return CKR_OK;
 
826
}
 
827
 
 
828
#ifdef NSS_DEBUG
 
829
static CK_RV
 
830
nss_ckmdFindSessionObjects_verifyPointer
 
831
(
 
832
  const NSSCKMDFindObjects *mdFindObjects
 
833
)
 
834
{
 
835
  return CKR_OK;
 
836
}
 
837
#endif
 
838
 
 
839
#endif /* DEBUG */
 
840
 
 
841
/*
 
842
 * We must forward-declare these routines.
 
843
 */
 
844
static void
 
845
nss_ckmdFindSessionObjects_Final
 
846
(
 
847
  NSSCKMDFindObjects *mdFindObjects,
 
848
  NSSCKFWFindObjects *fwFindObjects,
 
849
  NSSCKMDSession *mdSession,
 
850
  NSSCKFWSession *fwSession,
 
851
  NSSCKMDToken *mdToken,
 
852
  NSSCKFWToken *fwToken,
 
853
  NSSCKMDInstance *mdInstance,
 
854
  NSSCKFWInstance *fwInstance
 
855
);
 
856
 
 
857
static NSSCKMDObject *
 
858
nss_ckmdFindSessionObjects_Next
 
859
(
 
860
  NSSCKMDFindObjects *mdFindObjects,
 
861
  NSSCKFWFindObjects *fwFindObjects,
 
862
  NSSCKMDSession *mdSession,
 
863
  NSSCKFWSession *fwSession,
 
864
  NSSCKMDToken *mdToken,
 
865
  NSSCKFWToken *fwToken,
 
866
  NSSCKMDInstance *mdInstance,
 
867
  NSSCKFWInstance *fwInstance,
 
868
  NSSArena *arena,
 
869
  CK_RV *pError
 
870
);
 
871
 
 
872
static CK_BBOOL
 
873
items_match
 
874
(
 
875
  NSSItem *a,
 
876
  CK_VOID_PTR pValue,
 
877
  CK_ULONG ulValueLen
 
878
)
 
879
{
 
880
  if( a->size != ulValueLen ) {
 
881
    return CK_FALSE;
 
882
  }
 
883
 
 
884
  if( PR_TRUE == nsslibc_memequal(a->data, pValue, ulValueLen, (PRStatus *)NULL) ) {
 
885
    return CK_TRUE;
 
886
  } else {
 
887
    return CK_FALSE;
 
888
  }
 
889
}
 
890
 
 
891
/*
 
892
 * Our hashtable iterator
 
893
 */
 
894
static void
 
895
findfcn
 
896
(
 
897
  const void *key,
 
898
  void *value,
 
899
  void *closure
 
900
)
 
901
{
 
902
  NSSCKMDObject *mdObject = (NSSCKMDObject *)value;
 
903
  nssCKMDSessionObject *mdso = (nssCKMDSessionObject *)mdObject->etc;
 
904
  nssCKMDFindSessionObjects *mdfso = (nssCKMDFindSessionObjects *)closure;
 
905
  CK_ULONG i, j;
 
906
  struct nodeStr *node;
 
907
 
 
908
  if( CKR_OK != mdfso->error ) {
 
909
    return;
 
910
  }
 
911
 
 
912
  for( i = 0; i < mdfso->ulCount; i++ ) {
 
913
    CK_ATTRIBUTE_PTR p = &mdfso->pTemplate[i];
 
914
 
 
915
    for( j = 0; j < mdso->n; j++ ) {
 
916
      if( mdso->types[j] == p->type ) {
 
917
        if( !items_match(&mdso->attributes[j], p->pValue, p->ulValueLen) ) {
 
918
          return;
 
919
        } else {
 
920
          break;
 
921
        }
 
922
      }
 
923
    }
 
924
 
 
925
    if( j == mdso->n ) {
 
926
      /* Attribute not found */
 
927
      return;
 
928
    }
 
929
  }
 
930
 
 
931
  /* Matches */
 
932
  node = nss_ZNEW(mdfso->arena, struct nodeStr);
 
933
  if( (struct nodeStr *)NULL == node ) {
 
934
    mdfso->error = CKR_HOST_MEMORY;
 
935
    return;
 
936
  }
 
937
 
 
938
  node->mdObject = mdObject;
 
939
  node->next = mdfso->list;
 
940
  mdfso->list = node;
 
941
 
 
942
  return;
 
943
}
 
944
 
 
945
/*
 
946
 * nssCKMDFindSessionObjects_Create
 
947
 *
 
948
 */
 
949
NSS_IMPLEMENT NSSCKMDFindObjects *
 
950
nssCKMDFindSessionObjects_Create
 
951
(
 
952
  NSSCKFWToken *fwToken,
 
953
  CK_ATTRIBUTE_PTR pTemplate,
 
954
  CK_ULONG ulCount,
 
955
  CK_RV *pError
 
956
)
 
957
{
 
958
  NSSArena *arena;
 
959
  nssCKMDFindSessionObjects *mdfso;
 
960
  nssCKFWHash *hash;
 
961
  NSSCKMDFindObjects *rv;
 
962
 
 
963
#ifdef NSSDEBUG
 
964
  if( (CK_RV *)NULL == pError ) {
 
965
    return (NSSCKMDFindObjects *)NULL;
 
966
  }
 
967
 
 
968
  *pError = nssCKFWToken_verifyPointer(fwToken);
 
969
  if( CKR_OK != *pError ) {
 
970
    return (NSSCKMDFindObjects *)NULL;
 
971
  }
 
972
 
 
973
  if( (CK_ATTRIBUTE_PTR)NULL == pTemplate ) {
 
974
    *pError = CKR_ARGUMENTS_BAD;
 
975
    return (NSSCKMDFindObjects *)NULL;
 
976
  }
 
977
#endif /* NSSDEBUG */
 
978
 
 
979
  hash = nssCKFWToken_GetSessionObjectHash(fwToken);
 
980
  if( (nssCKFWHash *)NULL == hash ) {
 
981
    *pError= CKR_GENERAL_ERROR;
 
982
    return (NSSCKMDFindObjects *)NULL;
 
983
  }
 
984
 
 
985
  arena = NSSArena_Create();
 
986
  if( (NSSArena *)NULL == arena ) {
 
987
    *pError = CKR_HOST_MEMORY;
 
988
    return (NSSCKMDFindObjects *)NULL;
 
989
  }
 
990
 
 
991
  mdfso = nss_ZNEW(arena, nssCKMDFindSessionObjects);
 
992
  if( (nssCKMDFindSessionObjects *)NULL == mdfso ) {
 
993
    NSSArena_Destroy(arena);
 
994
    *pError = CKR_HOST_MEMORY;
 
995
    return (NSSCKMDFindObjects *)NULL;
 
996
  }
 
997
 
 
998
  rv = nss_ZNEW(arena, NSSCKMDFindObjects);
 
999
 
 
1000
  mdfso->error = CKR_OK;
 
1001
  mdfso->pTemplate = pTemplate;
 
1002
  mdfso->ulCount = ulCount;
 
1003
  mdfso->hash = hash;
 
1004
 
 
1005
  nssCKFWHash_Iterate(hash, findfcn, mdfso);
 
1006
 
 
1007
  if( CKR_OK != mdfso->error ) {
 
1008
    NSSArena_Destroy(arena);
 
1009
    *pError = CKR_HOST_MEMORY;
 
1010
    return (NSSCKMDFindObjects *)NULL;
 
1011
  }
 
1012
 
 
1013
  rv->etc = (void *)mdfso;
 
1014
  rv->Final = nss_ckmdFindSessionObjects_Final;
 
1015
  rv->Next = nss_ckmdFindSessionObjects_Next;
 
1016
 
 
1017
#ifdef DEBUG
 
1018
  if( (*pError = nss_ckmdFindSessionObjects_add_pointer(rv)) != CKR_OK ) {
 
1019
    NSSArena_Destroy(arena);
 
1020
    return (NSSCKMDFindObjects *)NULL;
 
1021
  }
 
1022
#endif /* DEBUG */    
 
1023
  mdfso->arena = arena;
 
1024
 
 
1025
  return rv;
 
1026
}
 
1027
 
 
1028
static void
 
1029
nss_ckmdFindSessionObjects_Final
 
1030
(
 
1031
  NSSCKMDFindObjects *mdFindObjects,
 
1032
  NSSCKFWFindObjects *fwFindObjects,
 
1033
  NSSCKMDSession *mdSession,
 
1034
  NSSCKFWSession *fwSession,
 
1035
  NSSCKMDToken *mdToken,
 
1036
  NSSCKFWToken *fwToken,
 
1037
  NSSCKMDInstance *mdInstance,
 
1038
  NSSCKFWInstance *fwInstance
 
1039
)
 
1040
{
 
1041
  nssCKMDFindSessionObjects *mdfso;
 
1042
 
 
1043
#ifdef NSSDEBUG
 
1044
  if( CKR_OK != nss_ckmdFindSessionObjects_verifyPointer(mdFindObjects) ) {
 
1045
    return;
 
1046
  }
 
1047
#endif /* NSSDEBUG */
 
1048
 
 
1049
  mdfso = (nssCKMDFindSessionObjects *)mdFindObjects->etc;
 
1050
  if (mdfso->arena) NSSArena_Destroy(mdfso->arena);
 
1051
 
 
1052
#ifdef DEBUG
 
1053
  (void)nss_ckmdFindSessionObjects_remove_pointer(mdFindObjects);
 
1054
#endif /* DEBUG */
 
1055
 
 
1056
  return;
 
1057
}
 
1058
 
 
1059
static NSSCKMDObject *
 
1060
nss_ckmdFindSessionObjects_Next
 
1061
(
 
1062
  NSSCKMDFindObjects *mdFindObjects,
 
1063
  NSSCKFWFindObjects *fwFindObjects,
 
1064
  NSSCKMDSession *mdSession,
 
1065
  NSSCKFWSession *fwSession,
 
1066
  NSSCKMDToken *mdToken,
 
1067
  NSSCKFWToken *fwToken,
 
1068
  NSSCKMDInstance *mdInstance,
 
1069
  NSSCKFWInstance *fwInstance,
 
1070
  NSSArena *arena,
 
1071
  CK_RV *pError
 
1072
)
 
1073
{
 
1074
  nssCKMDFindSessionObjects *mdfso;
 
1075
  NSSCKMDObject *rv = (NSSCKMDObject *)NULL;
 
1076
 
 
1077
#ifdef NSSDEBUG
 
1078
  if( CKR_OK != nss_ckmdFindSessionObjects_verifyPointer(mdFindObjects) ) {
 
1079
    return (NSSCKMDObject *)NULL;
 
1080
  }
 
1081
#endif /* NSSDEBUG */
 
1082
 
 
1083
  mdfso = (nssCKMDFindSessionObjects *)mdFindObjects->etc;
 
1084
 
 
1085
  while( (NSSCKMDObject *)NULL == rv ) {
 
1086
    if( (struct nodeStr *)NULL == mdfso->list ) {
 
1087
      *pError = CKR_OK;
 
1088
      return (NSSCKMDObject *)NULL;
 
1089
    }
 
1090
 
 
1091
    if( nssCKFWHash_Exists(mdfso->hash, mdfso->list->mdObject) ) {
 
1092
      rv = mdfso->list->mdObject;
 
1093
    }
 
1094
 
 
1095
    mdfso->list = mdfso->list->next;
 
1096
  }
 
1097
 
 
1098
  return rv;
 
1099
}