Source code

Revision control

Other Tools

/*
* 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"