1
/* ***** BEGIN LICENSE BLOCK *****
2
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
4
* The contents of this file are subject to the Mozilla Public License Version
5
* 1.1 (the "License"); you may not use this file except in compliance with
6
* the License. You may obtain a copy of the License at
7
* http://www.mozilla.org/MPL/
9
* Software distributed under the License is distributed on an "AS IS" basis,
10
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
11
* for the specific language governing rights and limitations under the
14
* The Original Code is the Netscape security libraries.
16
* The Initial Developer of the Original Code is
17
* Netscape Communications Corporation.
18
* Portions created by the Initial Developer are Copyright (C) 1994-2000
19
* the Initial Developer. All Rights Reserved.
23
* Alternatively, the contents of this file may be used under the terms of
24
* either the GNU General Public License Version 2 or later (the "GPL"), or
25
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
26
* in which case the provisions of the GPL or the LGPL are applicable instead
27
* of those above. If you wish to allow use of your version of this file only
28
* under the terms of either the GPL or the LGPL, and not to allow others to
29
* use your version of this file under the terms of the MPL, indicate your
30
* decision by deleting the provisions above and replace them with the notice
31
* and other provisions required by the GPL or the LGPL. If you do not delete
32
* the provisions above, a recipient may use your version of this file under
33
* the terms of any one of the MPL, the GPL or the LGPL.
35
* ***** END LICENSE BLOCK ***** */
37
* secport.c - portability interfaces for security libraries
39
* This file abstracts out libc functionality that libsec depends on
41
* NOTE - These are not public interfaces. These stubs are to allow the
42
* SW FORTEZZA to link with some low level security functions without dragging
45
* $Id: nsprstub.c,v 1.7 2007/07/24 16:14:15 biswatosh.chakraborty%sun.com Exp $
58
unsigned long port_allocFailures;
60
/* locations for registering Unicode conversion functions.
61
* Is this the appropriate location? or should they be
62
* moved to client/server specific locations?
64
PORTCharConversionFunc ucs4Utf8ConvertFunc;
65
PORTCharConversionFunc ucs2Utf8ConvertFunc;
66
PORTCharConversionWSwapFunc ucs2AsciiConvertFunc;
69
PORT_Alloc(size_t bytes)
73
/* Always allocate a non-zero amount of bytes */
74
rv = (void *)malloc(bytes ? bytes : 1);
77
PORT_SetError(SEC_ERROR_NO_MEMORY);
83
PORT_Realloc(void *oldptr, size_t bytes)
87
rv = (void *)realloc(oldptr, bytes);
90
PORT_SetError(SEC_ERROR_NO_MEMORY);
96
PORT_ZAlloc(size_t bytes)
100
/* Always allocate a non-zero amount of bytes */
101
rv = (void *)calloc(1, bytes ? bytes : 1);
103
++port_allocFailures;
104
PORT_SetError(SEC_ERROR_NO_MEMORY);
118
PORT_ZFree(void *ptr, size_t len)
126
/********************* Arena code follows *****************************/
130
PORT_NewArena(unsigned long chunksize)
134
arena = (PLArenaPool*)PORT_ZAlloc(sizeof(PLArenaPool));
135
if ( arena != NULL ) {
136
PR_InitArenaPool(arena, "security", chunksize, sizeof(double));
142
PORT_ArenaAlloc(PLArenaPool *arena, size_t size)
146
PL_ARENA_ALLOCATE(p, arena, size);
148
++port_allocFailures;
149
PORT_SetError(SEC_ERROR_NO_MEMORY);
156
PORT_ArenaZAlloc(PLArenaPool *arena, size_t size)
160
PL_ARENA_ALLOCATE(p, arena, size);
162
++port_allocFailures;
163
PORT_SetError(SEC_ERROR_NO_MEMORY);
165
PORT_Memset(p, 0, size);
171
/* need to zeroize!! */
173
PORT_FreeArena(PLArenaPool *arena, PRBool zero)
175
PR_FinishArenaPool(arena);
180
PORT_ArenaGrow(PLArenaPool *arena, void *ptr, size_t oldsize, size_t newsize)
182
PORT_Assert(newsize >= oldsize);
184
PL_ARENA_GROW(ptr, arena, oldsize, ( newsize - oldsize ) );
187
++port_allocFailures;
188
PORT_SetError(SEC_ERROR_NO_MEMORY);
194
PORT_ArenaMark(PLArenaPool *arena)
198
result = PL_ARENA_MARK(arena);
203
PORT_ArenaRelease(PLArenaPool *arena, void *mark)
205
PL_ARENA_RELEASE(arena, mark);
209
PORT_ArenaUnmark(PLArenaPool *arena, void *mark)
215
PORT_ArenaStrdup(PLArenaPool *arena,const char *str) {
216
int len = PORT_Strlen(str)+1;
219
newstr = (char*)PORT_ArenaAlloc(arena,len);
221
PORT_Memcpy(newstr,str,len);
228
* replace the nice thread-safe Error stack code with something
229
* that will work without all the NSPR features.
231
static PRInt32 stack[2] = {0, 0};
234
nss_SetError(PRUint32 value)
240
PR_IMPLEMENT(PRInt32)
247
PR_IMPLEMENT(PRInt32 *)
248
NSS_GetErrorStack(void)
254
nss_ClearErrorStack(void)
262
* replace the pointer tracking stuff for the same reasons.
263
* If you want to turn pointer tracking on, simply ifdef out this code and
264
* link with real NSPR.
266
PR_IMPLEMENT(PRStatus)
267
nssPointerTracker_initialize(nssPointerTracker *tracker)
273
PR_IMPLEMENT(PRStatus)
274
nssPointerTracker_finalize(nssPointerTracker *tracker)
279
PR_IMPLEMENT(PRStatus)
280
nssPointerTracker_add(nssPointerTracker *tracker, const void *pointer)
285
PR_IMPLEMENT(PRStatus)
286
nssPointerTracker_remove(nssPointerTracker *tracker, const void *pointer)
291
PR_IMPLEMENT(PRStatus)
292
nssPointerTracker_verify(nssPointerTracker *tracker, const void *pointer)
299
* Do not use NSPR stubs for MinGW because they can't resolve references
300
* to the _imp__PR_XXX symbols. This is merely an expedient hack and not
301
* the right solution.
303
#if !(defined(WIN32) && defined(__GNUC__))
304
PR_IMPLEMENT(PRThread *)
305
PR_GetCurrentThread(void)
307
return (PRThread *)1;
313
PR_Assert(const char *expr, const char *file, int line) {
318
PR_Alloc(PRUint32 bytes) { return malloc(bytes); }
321
PR_Malloc(PRUint32 bytes) { return malloc(bytes); }
324
PR_Calloc(PRUint32 blocks, PRUint32 bytes) { return calloc(blocks,bytes); }
327
PR_Realloc(void * blocks, PRUint32 bytes) { return realloc(blocks,bytes); }
330
PR_Free(void *ptr) { free(ptr); }
333
/* Old template; want to expunge it eventually. */
337
const SEC_ASN1Template SECOID_AlgorithmIDTemplate[] = {
339
0, NULL, sizeof(SECAlgorithmID) },
340
{ SEC_ASN1_OBJECT_ID,
341
offsetof(SECAlgorithmID,algorithm), },
342
{ SEC_ASN1_OPTIONAL | SEC_ASN1_ANY,
343
offsetof(SECAlgorithmID,parameters), },
347
PR_IMPLEMENT(PRStatus) PR_Sleep(PRIntervalTime ticks) { return PR_SUCCESS; }
349
/* This is not atomic! */
350
PR_IMPLEMENT(PRInt32) PR_AtomicDecrement(PRInt32 *val) { return --(*val); }
352
PR_IMPLEMENT(PRInt32) PR_AtomicSet(PRInt32 *val) { return ++(*val); }
356
/* now make the RNG happy */ /* This is not atomic! */
357
PR_IMPLEMENT(PRInt32) PR_AtomicIncrement(PRInt32 *val) { return ++(*val); }
358
#endif /* ! (WIN32 && GCC) */
360
static CK_C_INITIALIZE_ARGS_PTR nssstub_pInitArgs = NULL;
361
static CK_C_INITIALIZE_ARGS nssstub_initArgs;
362
static NSSArena *nssstub_arena = NULL;
363
static CryptokiLockingState nssstub_LockingState = SingleThreaded;
366
nssSetLockArgs(CK_C_INITIALIZE_ARGS_PTR pInitArgs, CryptokiLockingState* returned)
368
CK_ULONG count = (CK_ULONG)0;
369
CK_BBOOL os_ok = CK_FALSE;
371
if (nssstub_pInitArgs == NULL) {
372
if (pInitArgs != NULL) {
373
nssstub_initArgs = *pInitArgs;
374
nssstub_pInitArgs = &nssstub_initArgs;
375
if( (CK_CREATEMUTEX )NULL != pInitArgs->CreateMutex ) count++;
376
if( (CK_DESTROYMUTEX)NULL != pInitArgs->DestroyMutex ) count++;
377
if( (CK_LOCKMUTEX )NULL != pInitArgs->LockMutex ) count++;
378
if( (CK_UNLOCKMUTEX )NULL != pInitArgs->UnlockMutex ) count++;
379
os_ok = (pInitArgs->flags & CKF_OS_LOCKING_OK) ? CK_TRUE : CK_FALSE;
381
if( (0 != count) && (4 != count) ) {
382
rv = CKR_ARGUMENTS_BAD;
386
nssstub_pInitArgs = pInitArgs;
388
/* nssstub_arena = NSSArena_Create(); */
391
if( (0 == count) && (CK_TRUE == os_ok) ) {
393
* This is case #2 in the description of C_Initialize:
394
* The library will be called in a multithreaded way, but
395
* no routines were specified: os locking calls should be
396
* used. Unfortunately, this can be hard.. like, I think
397
* I may have to dynamically look up the entry points in
398
* the instance of NSPR already going in the application.
400
* I know that *we* always specify routines, so this only
401
* comes up if someone is using NSS to create their own
402
* PCKS#11 modules for other products. Oh, heck, I'll
403
* worry about this then.
411
* With the above test out of the way, we know this is case
412
* #1 in the description of C_Initialize: this library will
413
* not be called in a multithreaded way.
416
nssstub_LockingState = SingleThreaded;
419
* We know that we're in either case #3 or #4 in the description
420
* of C_Initialize. Case #3 says we should use the specified
421
* functions, case #4 cays we can use either the specified ones
422
* or the OS ones. I'll use the specified ones.
424
nssstub_LockingState = MultiThreaded;
428
*returned = nssstub_LockingState;
433
* Do not use NSPR stubs for MinGW because they can't resolve references
434
* to the _imp__PR_XXX symbols. This is merely an expedient hack and not
435
* the right solution.
437
#if !(defined(WIN32) && defined(__GNUC__))
439
PR_IMPLEMENT(PRLock *)
442
NSSCKFWMutex *mlock = NULL;
445
mlock = nssCKFWMutex_Create(nssstub_pInitArgs,nssstub_LockingState,nssstub_arena,&error);
446
lock = (PRLock *)mlock;
448
/* if we don't have a lock, nssCKFWMutex can deal with things */
449
if (lock == NULL) lock=(PRLock *) 1;
454
PR_DestroyLock(PRLock *lock) {
455
NSSCKFWMutex *mlock = (NSSCKFWMutex *)lock;
456
if (lock == (PRLock *)1) return;
457
nssCKFWMutex_Destroy(mlock);
461
PR_Lock(PRLock *lock) {
462
NSSCKFWMutex *mlock = (NSSCKFWMutex *)lock;
463
if (lock == (PRLock *)1) return;
464
nssCKFWMutex_Lock(mlock);
467
PR_IMPLEMENT(PRStatus)
468
PR_Unlock(PRLock *lock) {
469
NSSCKFWMutex *mlock = (NSSCKFWMutex *)lock;
470
if (lock == (PRLock *)1) return PR_SUCCESS;
471
nssCKFWMutex_Unlock(mlock);
477
/* this implementation is here to satisfy the PRMonitor use in plarena.c.
478
** It appears that it doesn't need re-entrant locks. It could have used
479
** PRLock instead of PRMonitor. So, this implementation just uses
480
** PRLock for a PRMonitor.
482
PR_IMPLEMENT(PRMonitor*)
485
return (PRMonitor *) PR_NewLock();
490
PR_EnterMonitor(PRMonitor *mon)
492
PR_Lock( (PRLock *)mon );
495
PR_IMPLEMENT(PRStatus)
496
PR_ExitMonitor(PRMonitor *mon)
498
return PR_Unlock( (PRLock *)mon );
503
/* This is NOT threadsafe. It is merely a pseudo-functional stub.
505
PR_IMPLEMENT(PRStatus) PR_CallOnce(
506
PRCallOnceType *once,
509
/* This is not really atomic! */
510
if (1 == PR_AtomicIncrement(&once->initialized)) {
511
once->status = (*func)();
513
/* Should wait to be sure that func has finished before returning. */
519
** Compute the log of the least power of 2 greater than or equal to n
521
PRIntn PR_CeilingLog2(PRUint32 i) {
523
PR_CEILING_LOG2(log2,i);
526
#endif /* ! (WIN32 && GCC) */
528
/********************** end of arena functions ***********************/
added
removed
mozilla/security/nss/lib/ckfw/nsprstub.c
