RetroZilla/security/nss/lib/freebl/stubs.c
roytam1 44b7f056d9 cherry-picked mozilla NSS upstream changes (to rev bad5fd065fa1, which is on par with 3.20):
bug1001332, 56b691c003ad, bug1086145, bug1054069, bug1155922, bug991783, bug1125025, bug1162521, bug1162644, bug1132941, bug1164364, bug1166205, bug1166163, bug1166515, bug1138554, bug1167046, bug1167043, bug1169451, bug1172128, bug1170322, bug102794, bug1128184, bug557830, bug1174648, bug1180244, bug1177784, bug1173413, bug1169174, bug1084669, bug951455, bug1183395, bug1177430, bug1183827, bug1160139, bug1154106, bug1142209, bug1185033, bug1193467, bug1182667(with sha512 changes backed out, which breaks VC6 compilation), bug1158489, bug337796
2018-07-14 21:22:32 +08:00

662 lines
16 KiB
C

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/*
* Allow freebl and softoken to be loaded without util or NSPR.
*
* These symbols are overridden once real NSPR, and libutil are attached.
*/
#define _GNU_SOURCE 1
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <fcntl.h>
#include <time.h>
#include <unistd.h>
#include <sys/time.h>
#include <dlfcn.h>
#include <prio.h>
#include <prlink.h>
#include <prlog.h>
#include <prthread.h>
#include <plstr.h>
#include <prinit.h>
#include <prlock.h>
#include <prmem.h>
#include <prerror.h>
#include <prmon.h>
#include <pratom.h>
#include <prsystem.h>
#include <prinrval.h>
#include <prtime.h>
#include <prcvar.h>
#include <secasn1.h>
#include <secdig.h>
#include <secport.h>
#include <secitem.h>
#include <blapi.h>
#include <private/pprio.h>
#define FREEBL_NO_WEAK 1
#define WEAK __attribute__((weak))
#ifdef FREEBL_NO_WEAK
/*
* This uses function pointers.
*
* CONS: A separate function is needed to
* fill in the function pointers.
*
* PROS: it works on all platforms.
* it allows for dynamically finding nspr and libutil, even once
* softoken is loaded and running. (NOTE: this may be a problem if
* we switch between the stubs and real NSPR on the fly. NSPR will
* do bad things if passed an _FakeArena to free or allocate from).
*/
#define STUB_DECLARE(ret, fn, args) \
typedef ret (*type_##fn) args; \
static type_##fn ptr_##fn = NULL
#define STUB_SAFE_CALL0(fn) \
if (ptr_##fn) { return ptr_##fn(); }
#define STUB_SAFE_CALL1(fn,a1) \
if (ptr_##fn) { return ptr_##fn(a1); }
#define STUB_SAFE_CALL2(fn,a1,a2) \
if (ptr_##fn) { return ptr_##fn(a1,a2); }
#define STUB_SAFE_CALL3(fn,a1,a2,a3) \
if (ptr_##fn) { return ptr_##fn(a1,a2,a3); }
#define STUB_SAFE_CALL4(fn,a1,a2,a3,a4) \
if (ptr_##fn) { return ptr_##fn(a1,a2,a3,a4); }
#define STUB_SAFE_CALL6(fn,a1,a2,a3,a4,a5,a6) \
if (ptr_##fn) { return ptr_##fn(a1,a2,a3,a4,a5,a6); }
#define STUB_FETCH_FUNCTION(fn) \
ptr_##fn = (type_##fn) dlsym(lib,#fn); \
if (ptr_##fn == NULL) { \
return SECFailure; \
}
#else
/*
* this uses the loader weak attribute. it works automatically, but once
* freebl is loaded, the symbols are 'fixed' (later loading of NSPR or
* libutil will not resolve these symbols.
*/
#define STUB_DECLARE(ret, fn, args) \
WEAK extern ret fn args
#define STUB_SAFE_CALL0(fn) \
if (fn) { return fn(); }
#define STUB_SAFE_CALL1(fn,a1) \
if (fn) { return fn(a1); }
#define STUB_SAFE_CALL2(fn,a1,a2) \
if (fn) { return fn(a1,a2); }
#define STUB_SAFE_CALL3(fn,a1,a2,a3) \
if (fn) { return fn(a1,a2,a3); }
#define STUB_SAFE_CALL4(fn,a1,a2,a3,a4) \
if (fn) { return fn(a1,a2,a3,a4); }
#define STUB_SAFE_CALL6(fn,a1,a2,a3,a4,a5,a6) \
if (fn) { return fn(a1,a2,a3,a4,a5,a6); }
#endif
STUB_DECLARE(void *,PORT_Alloc_Util,(size_t len));
STUB_DECLARE(void *,PORT_ArenaAlloc_Util,(PLArenaPool *arena, size_t size));
STUB_DECLARE(void *,PORT_ArenaZAlloc_Util,(PLArenaPool *arena, size_t size));
STUB_DECLARE(void ,PORT_Free_Util,(void *ptr));
STUB_DECLARE(void ,PORT_FreeArena_Util,(PLArenaPool *arena, PRBool zero));
STUB_DECLARE(int,PORT_GetError_Util,(void));
STUB_DECLARE(PLArenaPool *,PORT_NewArena_Util,(unsigned long chunksize));
STUB_DECLARE(void,PORT_SetError_Util,(int value));
STUB_DECLARE(void *,PORT_ZAlloc_Util,(size_t len));
STUB_DECLARE(void,PORT_ZFree_Util,(void *ptr, size_t len));
STUB_DECLARE(void,PR_Assert,(const char *s, const char *file, PRIntn ln));
STUB_DECLARE(PRStatus,PR_CallOnce,(PRCallOnceType *once, PRCallOnceFN func));
STUB_DECLARE(PRStatus,PR_Close,(PRFileDesc *fd));
STUB_DECLARE(void,PR_DestroyLock,(PRLock *lock));
STUB_DECLARE(void,PR_DestroyCondVar,(PRCondVar *cvar));
STUB_DECLARE(void,PR_Free,(void *ptr));
STUB_DECLARE(char * ,PR_GetLibraryFilePathname,(const char *name,
PRFuncPtr addr));
STUB_DECLARE(PRFileDesc *,PR_ImportPipe,(PROsfd osfd));
STUB_DECLARE(void,PR_Lock,(PRLock *lock));
STUB_DECLARE(PRCondVar *,PR_NewCondVar,(PRLock *lock));
STUB_DECLARE(PRLock *,PR_NewLock,(void));
STUB_DECLARE(PRStatus,PR_NotifyCondVar,(PRCondVar *cvar));
STUB_DECLARE(PRStatus,PR_NotifyAllCondVar,(PRCondVar *cvar));
STUB_DECLARE(PRFileDesc *,PR_Open,(const char *name, PRIntn flags,
PRIntn mode));
STUB_DECLARE(PRInt32,PR_Read,(PRFileDesc *fd, void *buf, PRInt32 amount));
STUB_DECLARE(PROffset32,PR_Seek,(PRFileDesc *fd, PROffset32 offset,
PRSeekWhence whence));
STUB_DECLARE(PRStatus,PR_Sleep,(PRIntervalTime ticks));
STUB_DECLARE(PRStatus,PR_Unlock,(PRLock *lock));
STUB_DECLARE(PRStatus,PR_WaitCondVar,(PRCondVar *cvar,
PRIntervalTime timeout));
STUB_DECLARE(SECItem *,SECITEM_AllocItem_Util,(PLArenaPool *arena,
SECItem *item,unsigned int len));
STUB_DECLARE(SECComparison,SECITEM_CompareItem_Util,(const SECItem *a,
const SECItem *b));
STUB_DECLARE(SECStatus,SECITEM_CopyItem_Util,(PLArenaPool *arena,
SECItem *to,const SECItem *from));
STUB_DECLARE(void,SECITEM_FreeItem_Util,(SECItem *zap, PRBool freeit));
STUB_DECLARE(void,SECITEM_ZfreeItem_Util,(SECItem *zap, PRBool freeit));
STUB_DECLARE(SECOidTag,SECOID_FindOIDTag_Util,(const SECItem *oid));
STUB_DECLARE(int, NSS_SecureMemcmp,(const void *a, const void *b, size_t n));
#define PORT_ZNew_stub(type) (type*)PORT_ZAlloc_stub(sizeof(type))
#define PORT_New_stub(type) (type*)PORT_Alloc_stub(sizeof(type))
#define PORT_ZNewArray_stub(type, num) \
(type*) PORT_ZAlloc_stub (sizeof(type)*(num))
/*
* NOTE: in order to support hashing only the memory allocation stubs,
* the get library name stubs, and the file io stubs are needed (the latter
* two are for the library verification). The remaining stubs are simply to
* compile. Attempts to use the library for other operations without NSPR
* will most likely fail.
*/
/* memory */
extern void *
PORT_Alloc_stub(size_t len)
{
STUB_SAFE_CALL1(PORT_Alloc_Util, len);
return malloc(len);
}
extern void
PORT_Free_stub(void *ptr)
{
STUB_SAFE_CALL1(PORT_Free_Util, ptr);
return free(ptr);
}
extern void *
PORT_ZAlloc_stub(size_t len)
{
STUB_SAFE_CALL1(PORT_ZAlloc_Util, len);
void *ptr = malloc(len);
if (ptr) {
memset(ptr, 0, len);
}
return ptr;
}
extern void
PORT_ZFree_stub(void *ptr, size_t len)
{
STUB_SAFE_CALL2(PORT_ZFree_Util, ptr, len);
memset(ptr, 0, len);
return free(ptr);
}
extern void
PR_Free_stub(void *ptr)
{
STUB_SAFE_CALL1(PR_Free, ptr);
return free(ptr);
}
/*
* arenas
*
*/
extern PLArenaPool *
PORT_NewArena_stub(unsigned long chunksize)
{
STUB_SAFE_CALL1(PORT_NewArena_Util, chunksize);
abort();
return NULL;
}
extern void *
PORT_ArenaAlloc_stub(PLArenaPool *arena, size_t size)
{
STUB_SAFE_CALL2(PORT_ArenaZAlloc_Util, arena, size);
abort();
return NULL;
}
extern void *
PORT_ArenaZAlloc_stub(PLArenaPool *arena, size_t size)
{
STUB_SAFE_CALL2(PORT_ArenaZAlloc_Util, arena, size);
abort();
return NULL;
}
extern void
PORT_FreeArena_stub(PLArenaPool *arena, PRBool zero)
{
STUB_SAFE_CALL2(PORT_FreeArena_Util, arena, zero);
abort();
}
/* io */
extern PRFileDesc *
PR_Open_stub(const char *name, PRIntn flags, PRIntn mode)
{
int *lfd = NULL;
int fd;
int lflags = 0;
STUB_SAFE_CALL3(PR_Open, name, flags, mode);
if (flags & PR_RDWR) {
lflags = O_RDWR;
} else if (flags & PR_WRONLY) {
lflags = O_WRONLY;
} else {
lflags = O_RDONLY;
}
if (flags & PR_EXCL)
lflags |= O_EXCL;
if (flags & PR_APPEND)
lflags |= O_APPEND;
if (flags & PR_TRUNCATE)
lflags |= O_TRUNC;
fd = open(name, lflags, mode);
if (fd >= 0) {
lfd = PORT_New_stub(int);
if (lfd != NULL) {
*lfd = fd;
}
}
return (PRFileDesc *)lfd;
}
extern PRFileDesc *
PR_ImportPipe_stub(PROsfd fd)
{
int *lfd = NULL;
STUB_SAFE_CALL1(PR_ImportPipe, fd);
lfd = PORT_New_stub(int);
if (lfd != NULL) {
*lfd = fd;
}
return (PRFileDesc *)lfd;
}
extern PRStatus
PR_Close_stub(PRFileDesc *fd)
{
int *lfd;
STUB_SAFE_CALL1(PR_Close, fd);
lfd = (int *)fd;
close(*lfd);
PORT_Free_stub(lfd);
return PR_SUCCESS;
}
extern PRInt32
PR_Read_stub(PRFileDesc *fd, void *buf, PRInt32 amount)
{
int *lfd;
STUB_SAFE_CALL3(PR_Read, fd, buf, amount);
lfd = (int *)fd;
return read(*lfd, buf, amount);
}
extern PROffset32
PR_Seek_stub(PRFileDesc *fd, PROffset32 offset, PRSeekWhence whence)
{
int *lfd;
int lwhence = SEEK_SET;
STUB_SAFE_CALL3(PR_Seek, fd, offset, whence);
lfd = (int *)fd;
switch (whence) {
case PR_SEEK_CUR:
lwhence = SEEK_CUR;
break;
case PR_SEEK_END:
lwhence = SEEK_END;
break;
case PR_SEEK_SET:
break;
}
return lseek(*lfd, offset, lwhence);
}
/*
* library
*/
extern char *
PR_GetLibraryFilePathname_stub(const char *name, PRFuncPtr addr)
{
Dl_info dli;
char *result;
STUB_SAFE_CALL2(PR_GetLibraryFilePathname, name, addr);
if (dladdr((void *)addr, &dli) == 0) {
return NULL;
}
result = PORT_Alloc_stub(strlen(dli.dli_fname)+1);
if (result != NULL) {
strcpy(result, dli.dli_fname);
}
return result;
}
#include <errno.h>
/* errors */
extern int
PORT_GetError_stub(void)
{
STUB_SAFE_CALL0(PORT_GetError_Util);
return errno;
}
extern void
PORT_SetError_stub(int value)
{
STUB_SAFE_CALL1(PORT_SetError_Util, value);
errno = value;
}
/* misc */
extern void
PR_Assert_stub(const char *s, const char *file, PRIntn ln)
{
STUB_SAFE_CALL3(PR_Assert, s, file, ln);
fprintf(stderr, "%s line %d: %s\n", file, ln, s);
abort();
}
/* time */
extern PRStatus
PR_Sleep_stub(PRIntervalTime ticks)
{
STUB_SAFE_CALL1(PR_Sleep, ticks);
usleep(ticks*1000);
return PR_SUCCESS;
}
/* locking */
extern PRLock *
PR_NewLock_stub(void)
{
STUB_SAFE_CALL0(PR_NewLock);
abort();
return NULL;
}
extern PRStatus
PR_Unlock_stub(PRLock *lock)
{
STUB_SAFE_CALL1(PR_Unlock, lock);
abort();
return PR_FAILURE;
}
extern void
PR_Lock_stub(PRLock *lock)
{
STUB_SAFE_CALL1(PR_Lock, lock);
abort();
return;
}
extern void
PR_DestroyLock_stub(PRLock *lock)
{
STUB_SAFE_CALL1(PR_DestroyLock, lock);
abort();
return;
}
extern PRCondVar *
PR_NewCondVar_stub(PRLock *lock)
{
STUB_SAFE_CALL1(PR_NewCondVar, lock);
abort();
return NULL;
}
extern PRStatus
PR_NotifyCondVar_stub(PRCondVar *cvar)
{
STUB_SAFE_CALL1(PR_NotifyCondVar, cvar);
abort();
return PR_FAILURE;
}
extern PRStatus
PR_NotifyAllCondVar_stub(PRCondVar *cvar)
{
STUB_SAFE_CALL1(PR_NotifyAllCondVar, cvar);
abort();
return PR_FAILURE;
}
extern PRStatus
PR_WaitCondVar_stub(PRCondVar *cvar, PRIntervalTime timeout)
{
STUB_SAFE_CALL2(PR_WaitCondVar, cvar, timeout);
abort();
return PR_FAILURE;
}
extern void
PR_DestroyCondVar_stub(PRCondVar *cvar)
{
STUB_SAFE_CALL1(PR_DestroyCondVar, cvar);
abort();
return;
}
/*
* NOTE: this presupposes GCC 4.1
*/
extern PRStatus
PR_CallOnce_stub(PRCallOnceType *once, PRCallOnceFN func)
{
STUB_SAFE_CALL2(PR_CallOnce, once, func);
abort();
return PR_FAILURE;
}
/*
* SECITEMS implement Item Utilities
*/
extern void
SECITEM_FreeItem_stub(SECItem *zap, PRBool freeit)
{
STUB_SAFE_CALL2(SECITEM_FreeItem_Util, zap, freeit);
abort();
}
extern SECItem *
SECITEM_AllocItem_stub(PLArenaPool *arena, SECItem *item, unsigned int len)
{
STUB_SAFE_CALL3(SECITEM_AllocItem_Util, arena, item, len);
abort();
return NULL;
}
extern SECComparison
SECITEM_CompareItem_stub(const SECItem *a, const SECItem *b)
{
STUB_SAFE_CALL2(SECITEM_CompareItem_Util, a, b);
abort();
return SECEqual;
}
extern SECStatus
SECITEM_CopyItem_stub(PLArenaPool *arena, SECItem *to, const SECItem *from)
{
STUB_SAFE_CALL3(SECITEM_CopyItem_Util, arena, to, from);
abort();
return SECFailure;
}
extern SECOidTag
SECOID_FindOIDTag_stub(const SECItem *oid)
{
STUB_SAFE_CALL1(SECOID_FindOIDTag_Util, oid);
abort();
return SEC_OID_UNKNOWN;
}
extern void
SECITEM_ZfreeItem_stub(SECItem *zap, PRBool freeit)
{
STUB_SAFE_CALL2(SECITEM_ZfreeItem_Util, zap, freeit);
abort();
}
extern int
NSS_SecureMemcmp_stub(const void *a, const void *b, size_t n)
{
STUB_SAFE_CALL3(NSS_SecureMemcmp, a, b, n);
abort();
}
#ifdef FREEBL_NO_WEAK
static const char *nsprLibName = SHLIB_PREFIX"nspr4."SHLIB_SUFFIX;
static const char *nssutilLibName = SHLIB_PREFIX"nssutil3."SHLIB_SUFFIX;
static SECStatus
freebl_InitNSPR(void *lib)
{
STUB_FETCH_FUNCTION(PR_Free);
STUB_FETCH_FUNCTION(PR_Open);
STUB_FETCH_FUNCTION(PR_ImportPipe);
STUB_FETCH_FUNCTION(PR_Close);
STUB_FETCH_FUNCTION(PR_Read);
STUB_FETCH_FUNCTION(PR_Seek);
STUB_FETCH_FUNCTION(PR_GetLibraryFilePathname);
STUB_FETCH_FUNCTION(PR_Assert);
STUB_FETCH_FUNCTION(PR_Sleep);
STUB_FETCH_FUNCTION(PR_CallOnce);
STUB_FETCH_FUNCTION(PR_NewCondVar);
STUB_FETCH_FUNCTION(PR_NotifyCondVar);
STUB_FETCH_FUNCTION(PR_NotifyAllCondVar);
STUB_FETCH_FUNCTION(PR_WaitCondVar);
STUB_FETCH_FUNCTION(PR_DestroyCondVar);
STUB_FETCH_FUNCTION(PR_NewLock);
STUB_FETCH_FUNCTION(PR_Unlock);
STUB_FETCH_FUNCTION(PR_Lock);
STUB_FETCH_FUNCTION(PR_DestroyLock);
return SECSuccess;
}
static SECStatus
freebl_InitNSSUtil(void *lib)
{
STUB_FETCH_FUNCTION(PORT_Alloc_Util);
STUB_FETCH_FUNCTION(PORT_Free_Util);
STUB_FETCH_FUNCTION(PORT_ZAlloc_Util);
STUB_FETCH_FUNCTION(PORT_ZFree_Util);
STUB_FETCH_FUNCTION(PORT_NewArena_Util);
STUB_FETCH_FUNCTION(PORT_ArenaAlloc_Util);
STUB_FETCH_FUNCTION(PORT_ArenaZAlloc_Util);
STUB_FETCH_FUNCTION(PORT_FreeArena_Util);
STUB_FETCH_FUNCTION(PORT_GetError_Util);
STUB_FETCH_FUNCTION(PORT_SetError_Util);
STUB_FETCH_FUNCTION(SECITEM_FreeItem_Util);
STUB_FETCH_FUNCTION(SECITEM_AllocItem_Util);
STUB_FETCH_FUNCTION(SECITEM_CompareItem_Util);
STUB_FETCH_FUNCTION(SECITEM_CopyItem_Util);
STUB_FETCH_FUNCTION(SECITEM_ZfreeItem_Util);
STUB_FETCH_FUNCTION(SECOID_FindOIDTag_Util);
STUB_FETCH_FUNCTION(NSS_SecureMemcmp);
return SECSuccess;
}
/*
* fetch the library if it's loaded. For NSS it should already be loaded
*/
#define freebl_getLibrary(libName) \
dlopen (libName, RTLD_LAZY|RTLD_NOLOAD)
#define freebl_releaseLibrary(lib) \
if (lib) dlclose(lib)
static void * FREEBLnsprGlobalLib = NULL;
static void * FREEBLnssutilGlobalLib = NULL;
void __attribute ((destructor)) FREEBL_unload()
{
freebl_releaseLibrary(FREEBLnsprGlobalLib);
freebl_releaseLibrary(FREEBLnssutilGlobalLib);
}
#endif
/*
* load the symbols from the real libraries if available.
*
* if force is set, explicitly load the libraries if they are not already
* loaded. If we could not use the real libraries, return failure.
*/
extern SECStatus
FREEBL_InitStubs()
{
SECStatus rv = SECSuccess;
#ifdef FREEBL_NO_WEAK
void *nspr = NULL;
void *nssutil = NULL;
/* NSPR should be first */
if (!FREEBLnsprGlobalLib) {
nspr = freebl_getLibrary(nsprLibName);
if (!nspr) {
return SECFailure;
}
rv = freebl_InitNSPR(nspr);
if (rv != SECSuccess) {
freebl_releaseLibrary(nspr);
return rv;
}
FREEBLnsprGlobalLib = nspr; /* adopt */
}
/* now load NSSUTIL */
if (!FREEBLnssutilGlobalLib) {
nssutil= freebl_getLibrary(nssutilLibName);
if (!nssutil) {
return SECFailure;
}
rv = freebl_InitNSSUtil(nssutil);
if (rv != SECSuccess) {
freebl_releaseLibrary(nssutil);
return rv;
}
FREEBLnssutilGlobalLib = nssutil; /* adopt */
}
#endif
return rv;
}