path: root/lib/nss/utilwrap.c

/*
 * NSS utility functions
 *
 * 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/. */

#include "secport.h"
#include "secoid.h"
#include "secitem.h"
#include "secdig.h"
#include "secder.h"
#include "secasn1.h"
#include "base64.h"
#include "nssb64.h"
#include "nssrwlk.h"
#include "cert.h"
#include "prerror.h"

/* wrappers for implementation in libnssutil3 */
#undef ATOB_AsciiToData
#undef ATOB_ConvertAsciiToItem
#undef BTOA_ConvertItemToAscii
#undef BTOA_DataToAscii
#undef CERT_GenTime2FormattedAscii
#undef DER_AsciiToTime
#undef DER_DecodeTimeChoice
#undef DER_Encode
#undef DER_EncodeTimeChoice
#undef DER_GeneralizedDayToAscii
#undef DER_GeneralizedTimeToTime
#undef DER_GetInteger
#undef DER_Lengths
#undef DER_TimeChoiceDayToAscii
#undef DER_TimeToGeneralizedTime
#undef DER_TimeToGeneralizedTimeArena
#undef DER_TimeToUTCTime
#undef DER_UTCDayToAscii
#undef DER_UTCTimeToAscii
#undef DER_UTCTimeToTime
#undef NSS_PutEnv
#undef NSSBase64_DecodeBuffer
#undef NSSBase64_EncodeItem
#undef NSSBase64Decoder_Create
#undef NSSBase64Decoder_Destroy
#undef NSSBase64Decoder_Update
#undef NSSBase64Encoder_Create
#undef NSSBase64Encoder_Destroy
#undef NSSBase64Encoder_Update
#undef NSSRWLock_Destroy
#undef NSSRWLock_HaveWriteLock
#undef NSSRWLock_LockRead
#undef NSSRWLock_LockWrite
#undef NSSRWLock_New
#undef NSSRWLock_UnlockRead
#undef NSSRWLock_UnlockWrite
#undef PORT_Alloc
#undef PORT_ArenaAlloc
#undef PORT_ArenaGrow
#undef PORT_ArenaMark
#undef PORT_ArenaRelease
#undef PORT_ArenaStrdup
#undef PORT_ArenaUnmark
#undef PORT_ArenaZAlloc
#undef PORT_Free
#undef PORT_FreeArena
#undef PORT_GetError
#undef PORT_NewArena
#undef PORT_Realloc
#undef PORT_SetError
#undef PORT_SetUCS2_ASCIIConversionFunction
#undef PORT_SetUCS2_UTF8ConversionFunction
#undef PORT_SetUCS4_UTF8ConversionFunction
#undef PORT_Strdup
#undef PORT_UCS2_ASCIIConversion
#undef PORT_UCS2_UTF8Conversion
#undef PORT_ZAlloc
#undef PORT_ZAllocAligned
#undef PORT_ZAllocAlignedOffset
#undef PORT_ZFree
#undef SEC_ASN1Decode
#undef SEC_ASN1DecodeInteger
#undef SEC_ASN1DecodeItem
#undef SEC_ASN1DecoderAbort
#undef SEC_ASN1DecoderClearFilterProc
#undef SEC_ASN1DecoderClearNotifyProc
#undef SEC_ASN1DecoderFinish
#undef SEC_ASN1DecoderSetFilterProc
#undef SEC_ASN1DecoderSetNotifyProc
#undef SEC_ASN1DecoderStart
#undef SEC_ASN1DecoderUpdate
#undef SEC_ASN1Encode
#undef SEC_ASN1EncodeInteger
#undef SEC_ASN1EncodeItem
#undef SEC_ASN1EncoderAbort
#undef SEC_ASN1EncoderClearNotifyProc
#undef SEC_ASN1EncoderClearStreaming
#undef SEC_ASN1EncoderClearTakeFromBuf
#undef SEC_ASN1EncoderFinish
#undef SEC_ASN1EncoderSetNotifyProc
#undef SEC_ASN1EncoderSetStreaming
#undef SEC_ASN1EncoderSetTakeFromBuf
#undef SEC_ASN1EncoderStart
#undef SEC_ASN1EncoderUpdate
#undef SEC_ASN1EncodeUnsignedInteger
#undef SEC_ASN1LengthLength
#undef SEC_QuickDERDecodeItem
#undef SECITEM_AllocItem
#undef SECITEM_ArenaDupItem
#undef SECITEM_CompareItem
#undef SECITEM_CopyItem
#undef SECITEM_DupItem
#undef SECITEM_FreeItem
#undef SECITEM_ItemsAreEqual
#undef SECITEM_ZfreeItem
#undef SECOID_AddEntry
#undef SECOID_CompareAlgorithmID
#undef SECOID_CopyAlgorithmID
#undef SECOID_DestroyAlgorithmID
#undef SECOID_FindOID
#undef SECOID_FindOIDByTag
#undef SECOID_FindOIDTag
#undef SECOID_FindOIDTagDescription
#undef SECOID_GetAlgorithmTag
#undef SECOID_SetAlgorithmID
#undef SGN_CompareDigestInfo
#undef SGN_CopyDigestInfo
#undef SGN_CreateDigestInfo
#undef SGN_DestroyDigestInfo

void *
PORT_Alloc(size_t bytes)
{
    return PORT_Alloc_Util(bytes);
}

void *
PORT_Realloc(void *oldptr, size_t bytes)
{
    return PORT_Realloc_Util(oldptr, bytes);
}

void *
PORT_ZAlloc(size_t bytes)
{
    return PORT_ZAlloc_Util(bytes);
}

void *
PORT_ZAllocAligned(size_t bytes, size_t alignment, void **mem)
{
    return PORT_ZAllocAligned_Util(bytes, alignment, mem);
}

void *
PORT_ZAllocAlignedOffset(size_t bytes, size_t alignment, size_t offset)
{
    return PORT_ZAllocAlignedOffset_Util(bytes, alignment, offset);
}

void
PORT_Free(void *ptr)
{
    PORT_Free_Util(ptr);
}

void
PORT_ZFree(void *ptr, size_t len)
{
    PORT_ZFree_Util(ptr, len);
}

char *
PORT_Strdup(const char *str)
{
    return PORT_Strdup_Util(str);
}

void
PORT_SetError(int value)
{
    PORT_SetError_Util(value);
}

int
PORT_GetError(void)
{
    return PORT_GetError_Util();
}

PLArenaPool *
PORT_NewArena(unsigned long chunksize)
{
    return PORT_NewArena_Util(chunksize);
}

void *
PORT_ArenaAlloc(PLArenaPool *arena, size_t size)
{
    return PORT_ArenaAlloc_Util(arena, size);
}

void *
PORT_ArenaZAlloc(PLArenaPool *arena, size_t size)
{
    return PORT_ArenaZAlloc_Util(arena, size);
}

void
PORT_FreeArena(PLArenaPool *arena, PRBool zero)
{
    PORT_FreeArena_Util(arena, zero);
}

void *
PORT_ArenaGrow(PLArenaPool *arena, void *ptr, size_t oldsize, size_t newsize)
{
    return PORT_ArenaGrow_Util(arena, ptr, oldsize, newsize);
}

void *
PORT_ArenaMark(PLArenaPool *arena)
{
    return PORT_ArenaMark_Util(arena);
}

void
PORT_ArenaRelease(PLArenaPool *arena, void *mark)
{
    PORT_ArenaRelease_Util(arena, mark);
}

void
PORT_ArenaUnmark(PLArenaPool *arena, void *mark)
{
    PORT_ArenaUnmark_Util(arena, mark);
}

char *
PORT_ArenaStrdup(PLArenaPool *arena, const char *str)
{
    return PORT_ArenaStrdup_Util(arena, str);
}

void
PORT_SetUCS4_UTF8ConversionFunction(PORTCharConversionFunc convFunc)
{
    PORT_SetUCS4_UTF8ConversionFunction_Util(convFunc);
}

void
PORT_SetUCS2_ASCIIConversionFunction(PORTCharConversionWSwapFunc convFunc)
{
    PORT_SetUCS2_ASCIIConversionFunction_Util(convFunc);
}

void
PORT_SetUCS2_UTF8ConversionFunction(PORTCharConversionFunc convFunc)
{
    PORT_SetUCS2_UTF8ConversionFunction_Util(convFunc);
}

PRBool
PORT_UCS2_UTF8Conversion(PRBool toUnicode, unsigned char *inBuf,
                         unsigned int inBufLen, unsigned char *outBuf,
                         unsigned int maxOutBufLen, unsigned int *outBufLen)
{
    return PORT_UCS2_UTF8Conversion_Util(toUnicode, inBuf, inBufLen, outBuf,
                                         maxOutBufLen, outBufLen);
}

PRBool
PORT_UCS2_ASCIIConversion(PRBool toUnicode, unsigned char *inBuf,
                          unsigned int inBufLen, unsigned char *outBuf,
                          unsigned int maxOutBufLen, unsigned int *outBufLen,
                          PRBool swapBytes)
{
    return PORT_UCS2_ASCIIConversion_Util(toUnicode, inBuf, inBufLen, outBuf,
                                          maxOutBufLen, outBufLen, swapBytes);
}

int
NSS_PutEnv(const char *envVarName, const char *envValue)
{
    return NSS_PutEnv_Util(envVarName, envValue);
}

SECOidData *
SECOID_FindOID(const SECItem *oid)
{
    return SECOID_FindOID_Util(oid);
}

SECOidTag
SECOID_FindOIDTag(const SECItem *oid)
{
    return SECOID_FindOIDTag_Util(oid);
}

SECOidData *
SECOID_FindOIDByTag(SECOidTag tagnum)
{
    return SECOID_FindOIDByTag_Util(tagnum);
}

SECStatus
SECOID_SetAlgorithmID(PLArenaPool *arena, SECAlgorithmID *aid,
                      SECOidTag tag, SECItem *params)
{
    return SECOID_SetAlgorithmID_Util(arena, aid, tag, params);
}

SECStatus
SECOID_CopyAlgorithmID(PLArenaPool *arena, SECAlgorithmID *dest,
                       const SECAlgorithmID *src)
{
    return SECOID_CopyAlgorithmID_Util(arena, dest, src);
}

SECOidTag
SECOID_GetAlgorithmTag(const SECAlgorithmID *aid)
{
    return SECOID_GetAlgorithmTag_Util(aid);
}

void
SECOID_DestroyAlgorithmID(SECAlgorithmID *aid, PRBool freeit)
{
    SECOID_DestroyAlgorithmID_Util(aid, freeit);
}

SECComparison
SECOID_CompareAlgorithmID(SECAlgorithmID *a,
                          SECAlgorithmID *b)
{
    return SECOID_CompareAlgorithmID_Util(a, b);
}

const char *
SECOID_FindOIDTagDescription(SECOidTag tagnum)
{
    return SECOID_FindOIDTagDescription_Util(tagnum);
}

SECOidTag
SECOID_AddEntry(const SECOidData *src)
{
    return SECOID_AddEntry_Util(src);
}

SECItem *
SECITEM_AllocItem(PLArenaPool *arena, SECItem *item,
                  unsigned int len)
{
    return SECITEM_AllocItem_Util(arena, item, len);
}

SECComparison
SECITEM_CompareItem(const SECItem *a, const SECItem *b)
{
    return SECITEM_CompareItem_Util(a, b);
}

PRBool
SECITEM_ItemsAreEqual(const SECItem *a, const SECItem *b)
{
    return SECITEM_ItemsAreEqual_Util(a, b);
}

SECStatus
SECITEM_CopyItem(PLArenaPool *arena, SECItem *to,
                 const SECItem *from)
{
    return SECITEM_CopyItem_Util(arena, to, from);
}

SECItem *
SECITEM_DupItem(const SECItem *from)
{
    return SECITEM_DupItem_Util(from);
}

SECItem *
SECITEM_ArenaDupItem(PLArenaPool *arena, const SECItem *from)
{
    return SECITEM_ArenaDupItem_Util(arena, from);
}

void
SECITEM_FreeItem(SECItem *zap, PRBool freeit)
{
    SECITEM_FreeItem_Util(zap, freeit);
}

void
SECITEM_ZfreeItem(SECItem *zap, PRBool freeit)
{
    SECITEM_ZfreeItem_Util(zap, freeit);
}

SGNDigestInfo *
SGN_CreateDigestInfo(SECOidTag algorithm,
                     unsigned char *sig,
                     unsigned int sigLen)
{
    return SGN_CreateDigestInfo_Util(algorithm, sig, sigLen);
}

void
SGN_DestroyDigestInfo(SGNDigestInfo *info)
{
    SGN_DestroyDigestInfo_Util(info);
}

SECStatus
SGN_CopyDigestInfo(PLArenaPool *poolp,
                   SGNDigestInfo *a,
                   SGNDigestInfo *b)
{
    return SGN_CopyDigestInfo_Util(poolp, a, b);
}

SECComparison
SGN_CompareDigestInfo(SGNDigestInfo *a, SGNDigestInfo *b)
{
    return SGN_CompareDigestInfo_Util(a, b);
}

SECStatus
DER_Encode(PLArenaPool *arena, SECItem *dest, DERTemplate *t,
           void *src)
{
    return DER_Encode_Util(arena, dest, t, src);
}

SECStatus
DER_Lengths(SECItem *item, int *header_len_p,
            PRUint32 *contents_len_p)
{
    return DER_Lengths_Util(item, header_len_p, contents_len_p);
}

long
DER_GetInteger(const SECItem *src)
{
    return DER_GetInteger_Util(src);
}

SECStatus
DER_TimeToUTCTime(SECItem *result, PRTime time)
{
    return DER_TimeToUTCTime_Util(result, time);
}

SECStatus
DER_AsciiToTime(PRTime *result, const char *string)
{
    return DER_AsciiToTime_Util(result, string);
}

SECStatus
DER_UTCTimeToTime(PRTime *result, const SECItem *time)
{
    return DER_UTCTimeToTime_Util(result, time);
}

char *
DER_UTCTimeToAscii(SECItem *utcTime)
{
    return DER_UTCTimeToAscii_Util(utcTime);
}

char *
DER_UTCDayToAscii(SECItem *utctime)
{
    return DER_UTCDayToAscii_Util(utctime);
}

char *
DER_GeneralizedDayToAscii(SECItem *gentime)
{
    return DER_GeneralizedDayToAscii_Util(gentime);
}

char *
DER_TimeChoiceDayToAscii(SECItem *timechoice)
{
    return DER_TimeChoiceDayToAscii_Util(timechoice);
}

SECStatus
DER_TimeToGeneralizedTime(SECItem *dst, PRTime gmttime)
{
    return DER_TimeToGeneralizedTime_Util(dst, gmttime);
}

SECStatus
DER_TimeToGeneralizedTimeArena(PLArenaPool *arenaOpt,
                               SECItem *dst, PRTime gmttime)
{
    return DER_TimeToGeneralizedTimeArena_Util(arenaOpt, dst, gmttime);
}

SECStatus
DER_GeneralizedTimeToTime(PRTime *dst, const SECItem *time)
{
    return DER_GeneralizedTimeToTime_Util(dst, time);
}

char *
CERT_GenTime2FormattedAscii(PRTime genTime, char *format)
{
    return CERT_GenTime2FormattedAscii_Util(genTime, format);
}

SECStatus
DER_DecodeTimeChoice(PRTime *output, const SECItem *input)
{
    return DER_DecodeTimeChoice_Util(output, input);
}

SECStatus
DER_EncodeTimeChoice(PLArenaPool *arena, SECItem *output,
                     PRTime input)
{
    return DER_EncodeTimeChoice_Util(arena, output, input);
}

SEC_ASN1DecoderContext *
SEC_ASN1DecoderStart(PLArenaPool *pool,
                     void *dest,
                     const SEC_ASN1Template *t)
{
    return SEC_ASN1DecoderStart_Util(pool, dest, t);
}

SECStatus
SEC_ASN1DecoderUpdate(SEC_ASN1DecoderContext *cx,
                      const char *buf,
                      unsigned long len)
{
    return SEC_ASN1DecoderUpdate_Util(cx, buf, len);
}

SECStatus
SEC_ASN1DecoderFinish(SEC_ASN1DecoderContext *cx)
{
    return SEC_ASN1DecoderFinish_Util(cx);
}

void
SEC_ASN1DecoderAbort(SEC_ASN1DecoderContext *cx, int error)
{
    SEC_ASN1DecoderAbort_Util(cx, error);
}

void
SEC_ASN1DecoderSetFilterProc(SEC_ASN1DecoderContext *cx,
                             SEC_ASN1WriteProc fn,
                             void *arg, PRBool no_store)
{
    SEC_ASN1DecoderSetFilterProc_Util(cx, fn, arg, no_store);
}

void
SEC_ASN1DecoderClearFilterProc(SEC_ASN1DecoderContext *cx)
{
    SEC_ASN1DecoderClearFilterProc_Util(cx);
}

void
SEC_ASN1DecoderSetNotifyProc(SEC_ASN1DecoderContext *cx,
                             SEC_ASN1NotifyProc fn,
                             void *arg)
{
    SEC_ASN1DecoderSetNotifyProc_Util(cx, fn, arg);
}

void
SEC_ASN1DecoderClearNotifyProc(SEC_ASN1DecoderContext *cx)
{
    SEC_ASN1DecoderClearNotifyProc_Util(cx);
}

SECStatus
SEC_ASN1Decode(PLArenaPool *pool, void *dest,
               const SEC_ASN1Template *t,
               const char *buf, long len)
{
    return SEC_ASN1Decode_Util(pool, dest, t, buf, len);
}

SECStatus
SEC_ASN1DecodeItem(PLArenaPool *pool, void *dest,
                   const SEC_ASN1Template *t,
                   const SECItem *src)
{
    return SEC_ASN1DecodeItem_Util(pool, dest, t, src);
}

SECStatus
SEC_QuickDERDecodeItem(PLArenaPool *arena, void *dest,
                       const SEC_ASN1Template *templateEntry,
                       const SECItem *src)
{
    return SEC_QuickDERDecodeItem_Util(arena, dest, templateEntry, src);
}

SEC_ASN1EncoderContext *
SEC_ASN1EncoderStart(const void *src,
                     const SEC_ASN1Template *t,
                     SEC_ASN1WriteProc fn,
                     void *output_arg)
{
    return SEC_ASN1EncoderStart_Util(src, t, fn, output_arg);
}

SECStatus
SEC_ASN1EncoderUpdate(SEC_ASN1EncoderContext *cx,
                      const char *buf,
                      unsigned long len)
{
    return SEC_ASN1EncoderUpdate_Util(cx, buf, len);
}

void
SEC_ASN1EncoderFinish(SEC_ASN1EncoderContext *cx)
{
    SEC_ASN1EncoderFinish_Util(cx);
}

void
SEC_ASN1EncoderAbort(SEC_ASN1EncoderContext *cx, int error)
{
    SEC_ASN1EncoderAbort_Util(cx, error);
}

void
SEC_ASN1EncoderSetNotifyProc(SEC_ASN1EncoderContext *cx,
                             SEC_ASN1NotifyProc fn,
                             void *arg)
{
    SEC_ASN1EncoderSetNotifyProc_Util(cx, fn, arg);
}

void
SEC_ASN1EncoderClearNotifyProc(SEC_ASN1EncoderContext *cx)
{
    SEC_ASN1EncoderClearNotifyProc_Util(cx);
}

void
SEC_ASN1EncoderSetStreaming(SEC_ASN1EncoderContext *cx)
{
    SEC_ASN1EncoderSetStreaming_Util(cx);
}

void
SEC_ASN1EncoderClearStreaming(SEC_ASN1EncoderContext *cx)
{
    SEC_ASN1EncoderClearStreaming_Util(cx);
}

void
SEC_ASN1EncoderSetTakeFromBuf(SEC_ASN1EncoderContext *cx)
{
    SEC_ASN1EncoderSetTakeFromBuf_Util(cx);
}

void
SEC_ASN1EncoderClearTakeFromBuf(SEC_ASN1EncoderContext *cx)
{
    SEC_ASN1EncoderClearTakeFromBuf_Util(cx);
}

SECStatus
SEC_ASN1Encode(const void *src, const SEC_ASN1Template *t,
               SEC_ASN1WriteProc output_proc,
               void *output_arg)
{
    return SEC_ASN1Encode_Util(src, t, output_proc, output_arg);
}

SECItem *
SEC_ASN1EncodeItem(PLArenaPool *pool, SECItem *dest,
                   const void *src, const SEC_ASN1Template *t)
{
    return SEC_ASN1EncodeItem_Util(pool, dest, src, t);
}

SECItem *
SEC_ASN1EncodeInteger(PLArenaPool *pool,
                      SECItem *dest, long value)
{
    return SEC_ASN1EncodeInteger_Util(pool, dest, value);
}

SECItem *
SEC_ASN1EncodeUnsignedInteger(PLArenaPool *pool,
                              SECItem *dest,
                              unsigned long value)
{
    return SEC_ASN1EncodeUnsignedInteger_Util(pool, dest, value);
}

SECStatus
SEC_ASN1DecodeInteger(SECItem *src,
                      unsigned long *value)
{
    return SEC_ASN1DecodeInteger_Util(src, value);
}

int
SEC_ASN1LengthLength(unsigned long len)
{
    return SEC_ASN1LengthLength_Util(len);
}

char *
BTOA_DataToAscii(const unsigned char *data, unsigned int len)
{
    return BTOA_DataToAscii_Util(data, len);
}

unsigned char *
ATOB_AsciiToData(const char *string, unsigned int *lenp)
{
    return ATOB_AsciiToData_Util(string, lenp);
}

SECStatus
ATOB_ConvertAsciiToItem(SECItem *binary_item, const char *ascii)
{
    return ATOB_ConvertAsciiToItem_Util(binary_item, ascii);
}

char *
BTOA_ConvertItemToAscii(SECItem *binary_item)
{
    return BTOA_ConvertItemToAscii_Util(binary_item);
}

NSSBase64Decoder *
NSSBase64Decoder_Create(PRInt32 (*output_fn)(void *, const unsigned char *,
                                             PRInt32),
                        void *output_arg)
{
    return NSSBase64Decoder_Create_Util(output_fn, output_arg);
}

NSSBase64Encoder *
NSSBase64Encoder_Create(PRInt32 (*output_fn)(void *, const char *, PRInt32),
                        void *output_arg)
{
    return NSSBase64Encoder_Create_Util(output_fn, output_arg);
}

SECStatus
NSSBase64Decoder_Update(NSSBase64Decoder *data, const char *buffer,
                        PRUint32 size)
{
    return NSSBase64Decoder_Update_Util(data, buffer, size);
}

SECStatus
NSSBase64Encoder_Update(NSSBase64Encoder *data, const unsigned char *buffer,
                        PRUint32 size)
{
    return NSSBase64Encoder_Update_Util(data, buffer, size);
}

SECStatus
NSSBase64Decoder_Destroy(NSSBase64Decoder *data, PRBool abort_p)
{
    return NSSBase64Decoder_Destroy_Util(data, abort_p);
}

SECStatus
NSSBase64Encoder_Destroy(NSSBase64Encoder *data, PRBool abort_p)
{
    return NSSBase64Encoder_Destroy_Util(data, abort_p);
}

SECItem *
NSSBase64_DecodeBuffer(PLArenaPool *arenaOpt, SECItem *outItemOpt,
                       const char *inStr, unsigned int inLen)
{
    return NSSBase64_DecodeBuffer_Util(arenaOpt, outItemOpt, inStr, inLen);
}

char *
NSSBase64_EncodeItem(PLArenaPool *arenaOpt, char *outStrOpt,
                     unsigned int maxOutLen, SECItem *inItem)
{
    return NSSBase64_EncodeItem_Util(arenaOpt, outStrOpt, maxOutLen, inItem);
}

NSSRWLock *
NSSRWLock_New(PRUint32 lock_rank, const char *lock_name)
{
    return NSSRWLock_New_Util(lock_rank, lock_name);
}

void
NSSRWLock_Destroy(NSSRWLock *lock)
{
    NSSRWLock_Destroy_Util(lock);
}

void
NSSRWLock_LockRead(NSSRWLock *lock)
{
    NSSRWLock_LockRead_Util(lock);
}

void
NSSRWLock_LockWrite(NSSRWLock *lock)
{
    NSSRWLock_LockWrite_Util(lock);
}

void
NSSRWLock_UnlockRead(NSSRWLock *lock)
{
    NSSRWLock_UnlockRead_Util(lock);
}

void
NSSRWLock_UnlockWrite(NSSRWLock *lock)
{
    NSSRWLock_UnlockWrite_Util(lock);
}

PRBool
NSSRWLock_HaveWriteLock(NSSRWLock *rwlock)
{
    return NSSRWLock_HaveWriteLock_Util(rwlock);
}

SECStatus
__nss_InitLock(PZLock **ppLock, nssILockType ltype)
{
    PORT_SetError(PR_NOT_IMPLEMENTED_ERROR);
    return SECFailure;
}

/* templates duplicated in libnss3 and libnssutil3 */

#undef NSS_Get_SEC_AnyTemplate
#undef NSS_Get_SEC_BitStringTemplate
#undef NSS_Get_SEC_BMPStringTemplate
#undef NSS_Get_SEC_BooleanTemplate
#undef NSS_Get_SEC_GeneralizedTimeTemplate
#undef NSS_Get_SEC_IA5StringTemplate
#undef NSS_Get_SEC_IntegerTemplate
#undef NSS_Get_SEC_NullTemplate
#undef NSS_Get_SEC_ObjectIDTemplate
#undef NSS_Get_SEC_OctetStringTemplate
#undef NSS_Get_SEC_PointerToAnyTemplate
#undef NSS_Get_SEC_PointerToOctetStringTemplate
#undef NSS_Get_SEC_SetOfAnyTemplate
#undef NSS_Get_SEC_UTCTimeTemplate
#undef NSS_Get_SEC_UTF8StringTemplate
#undef NSS_Get_SECOID_AlgorithmIDTemplate
#undef NSS_Get_sgn_DigestInfoTemplate
#undef SEC_AnyTemplate
#undef SEC_BitStringTemplate
#undef SEC_BMPStringTemplate
#undef SEC_BooleanTemplate
#undef SEC_GeneralizedTimeTemplate
#undef SEC_IA5StringTemplate
#undef SEC_IntegerTemplate
#undef SEC_NullTemplate
#undef SEC_ObjectIDTemplate
#undef SEC_OctetStringTemplate
#undef SEC_PointerToAnyTemplate
#undef SEC_PointerToOctetStringTemplate
#undef SEC_SetOfAnyTemplate
#undef SEC_UTCTimeTemplate
#undef SEC_UTF8StringTemplate
#undef SECOID_AlgorithmIDTemplate
#undef sgn_DigestInfoTemplate

#include "templates.c"