int test_mem(int argc, char *argv[]) {
unsigned int *array = NULL;
int arraySize = 10;
PKIX_UInt32 actualMinorVersion;
PKIX_UInt32 j = 0;
PKIX_TEST_STD_VARS();
startTests("Memory Allocation");
PKIX_TEST_EXPECT_NO_ERROR(
PKIX_PL_NssContext_Create(0, PKIX_FALSE, NULL, &plContext));
subTest("PKIX_PL_Malloc");
testMalloc(&array);
subTest("PKIX_PL_Realloc");
testRealloc(&array);
subTest("PKIX_PL_Free");
testFree(array);
/* --Negative Test Cases------------------- */
/* Create an integer array of size 10 */
PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Malloc(
(PKIX_UInt32)(arraySize*sizeof (unsigned int)),
(void **) &array, plContext));
(void) printf("Attempting to reallocate 0 sized memory...\n");
PKIX_TEST_EXPECT_NO_ERROR
(PKIX_PL_Realloc(array, 0, (void **) &array, plContext));
(void) printf("Attempting to allocate to null pointer...\n");
PKIX_TEST_EXPECT_ERROR(PKIX_PL_Malloc(10, NULL, plContext));
(void) printf("Attempting to reallocate to null pointer...\n");
PKIX_TEST_EXPECT_ERROR(PKIX_PL_Realloc(NULL, 10, NULL, plContext));
PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(array, plContext));
cleanup:
PKIX_Shutdown(plContext);
endTests("Memory Allocation");
return (0);
}
static char *catDirName(char *dir, char *name, void *plContext)
{
char *pathName = NULL;
PKIX_UInt32 nameLen;
PKIX_UInt32 dirLen;
PKIX_TEST_STD_VARS();
nameLen = PL_strlen(name);
dirLen = PL_strlen(dir);
PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Malloc
(dirLen + nameLen + 2,
(void **)&pathName,
plContext));
PL_strcpy(pathName, dir);
PL_strcat(pathName, "/");
PL_strcat(pathName, name);
printf("pathName = %s\n", pathName);
cleanup:
PKIX_TEST_RETURN();
return (pathName);
}
static
char *createFullPathName(
char *dirName,
char *certFile,
void *plContext)
{
PKIX_UInt32 certFileLen;
PKIX_UInt32 dirNameLen;
char *certPathName = NULL;
PKIX_TEST_STD_VARS();
certFileLen = PL_strlen(certFile);
dirNameLen = PL_strlen(dirName);
PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Malloc
(dirNameLen + certFileLen + 2,
(void **)&certPathName,
plContext));
PL_strcpy(certPathName, dirName);
PL_strcat(certPathName, "/");
PL_strcat(certPathName, certFile);
printf("certPathName = %s\n", certPathName);
cleanup:
PKIX_TEST_RETURN();
return (certPathName);
}
/*
* FUNCTION: PKIX_PL_ByteArray_GetPointer (see comments in pkix_pl_system.h)
*/
PKIX_Error *
PKIX_PL_ByteArray_GetPointer(
PKIX_PL_ByteArray *byteArray,
void **pArray,
void *plContext)
{
void *bytes = NULL;
PKIX_ENTER(BYTEARRAY, "PKIX_PL_ByteArray_GetPointer");
PKIX_NULLCHECK_TWO(byteArray, pArray);
if (byteArray->length != 0){
PKIX_CHECK(PKIX_PL_Malloc
(byteArray->length, &bytes, plContext),
PKIX_MALLOCFAILED);
PKIX_BYTEARRAY_DEBUG("\tCalling PORT_Memcpy).\n");
(void) PORT_Memcpy
(bytes, byteArray->array, byteArray->length);
}
*pArray = bytes;
cleanup:
if (PKIX_ERROR_RECEIVED){
PKIX_FREE(bytes);
}
PKIX_RETURN(BYTEARRAY);
}
static char *
catDirName(char *platform, char *dir, void *plContext)
{
char *pathName = NULL;
PKIX_UInt32 dirLen;
PKIX_UInt32 platformLen;
PKIX_TEST_STD_VARS();
dirLen = PL_strlen(dir);
platformLen = PL_strlen(platform);
PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Malloc(platformLen +
dirLen +
2,
(void **)&pathName, plContext));
PL_strcpy(pathName, platform);
PL_strcat(pathName, "/");
PL_strcat(pathName, dir);
cleanup:
PKIX_TEST_RETURN();
return (pathName);
}
static
void testMalloc(PKIX_UInt32 **array)
{
PKIX_UInt32 i, arraySize = 10;
PKIX_TEST_STD_VARS();
/* Create an integer array of size 10 */
PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Malloc(
(PKIX_UInt32)(arraySize*sizeof (unsigned int)),
(void **) array, plContext));
/* Fill in some values */
(void) printf ("Setting array[i] = i...\n");
for (i = 0; i < arraySize; i++) {
(*array)[i] = i;
if ((*array)[i] != i)
testError("Array has incorrect contents");
}
/* Memory now reflects changes */
(void) printf("\tArray: a[0] = %d, a[5] = %d, a[7] = %d.\n",
(*array[0]), (*array)[5], (*array)[7]);
cleanup:
PKIX_TEST_RETURN();
}
/*
* FUNCTION: pkix_pl_PrimHashTable_Create
* DESCRIPTION:
*
* Creates a new PrimHashtable object with a number of buckets equal to
* "numBuckets" and stores the result at "pResult".
*
* PARAMETERS:
* "numBuckets"
* The number of hash table buckets. Must be non-zero.
* "pResult"
* Address where PrimHashTable pointer will be stored. Must be non-NULL.
* "plContext"
* Platform-specific context pointer.
* THREAD SAFETY:
* Thread Safe (see Thread Safety Definitions in Programmer's Guide)
* RETURNS:
* Returns NULL if the function succeeds.
* Returns a Fatal Error if the function fails in an unrecoverable way.
*/
PKIX_Error *
pkix_pl_PrimHashTable_Create(
PKIX_UInt32 numBuckets,
pkix_pl_PrimHashTable **pResult,
void *plContext)
{
pkix_pl_PrimHashTable *primHashTable = NULL;
PKIX_UInt32 i;
PKIX_ENTER(HASHTABLE, "pkix_pl_PrimHashTable_Create");
PKIX_NULLCHECK_ONE(pResult);
if (numBuckets == 0) {
PKIX_ERROR(PKIX_NUMBUCKETSEQUALSZERO);
}
/* Allocate a new hashtable */
PKIX_CHECK(PKIX_PL_Malloc
(sizeof (pkix_pl_PrimHashTable),
(void **)&primHashTable,
plContext),
PKIX_MALLOCFAILED);
primHashTable->size = numBuckets;
/* Allocate space for the buckets */
PKIX_CHECK(PKIX_PL_Malloc
(numBuckets * sizeof (pkix_pl_HT_Elem*),
(void **)&primHashTable->buckets,
plContext),
PKIX_MALLOCFAILED);
for (i = 0; i < numBuckets; i++) {
primHashTable->buckets[i] = NULL;
}
*pResult = primHashTable;
cleanup:
if (PKIX_ERROR_RECEIVED){
PKIX_FREE(primHashTable);
}
PKIX_RETURN(HASHTABLE);
}
/*
* FUNCTION: pkix_pl_OtherName_Create
* DESCRIPTION:
*
* Creates new OtherName which represents the CERTGeneralName pointed to by
* "nssAltName" and stores it at "pOtherName".
*
* PARAMETERS:
* "nssAltName"
* Address of CERTGeneralName. Must be non-NULL.
* "pOtherName"
* Address where object pointer will be stored. Must be non-NULL.
* "plContext" - Platform-specific context pointer.
* THREAD SAFETY:
* Thread Safe (see Thread Safety Definitions in Programmer's Guide)
* RETURNS:
* Returns NULL if the function succeeds.
* Returns a GeneralName Error if the function fails in a non-fatal way.
* Returns a Fatal Error if the function fails in an unrecoverable way.
*/
static PKIX_Error *
pkix_pl_OtherName_Create(
CERTGeneralName *nssAltName,
OtherName **pOtherName,
void *plContext)
{
OtherName *otherName = NULL;
SECItem secItemName;
SECItem secItemOID;
SECStatus rv;
PKIX_ENTER(GENERALNAME, "pkix_pl_OtherName_Create");
PKIX_NULLCHECK_TWO(nssAltName, pOtherName);
PKIX_CHECK(PKIX_PL_Malloc
(sizeof (OtherName), (void **)&otherName, plContext),
PKIX_MALLOCFAILED);
/* make a copy of the name field */
PKIX_GENERALNAME_DEBUG("\t\tCalling SECITEM_CopyItem).\n");
rv = SECITEM_CopyItem
(NULL, &otherName->name, &nssAltName->name.OthName.name);
if (rv != SECSuccess) {
PKIX_ERROR(PKIX_OUTOFMEMORY);
}
/* make a copy of the oid field */
PKIX_GENERALNAME_DEBUG("\t\tCalling SECITEM_CopyItem).\n");
rv = SECITEM_CopyItem
(NULL, &otherName->oid, &nssAltName->name.OthName.oid);
if (rv != SECSuccess) {
PKIX_ERROR(PKIX_OUTOFMEMORY);
}
*pOtherName = otherName;
cleanup:
if (otherName && PKIX_ERROR_RECEIVED){
secItemName = otherName->name;
secItemOID = otherName->oid;
PKIX_GENERALNAME_DEBUG("\t\tCalling SECITEM_FreeItem).\n");
SECITEM_FreeItem(&secItemName, PR_FALSE);
PKIX_GENERALNAME_DEBUG("\t\tCalling SECITEM_FreeItem).\n");
SECITEM_FreeItem(&secItemOID, PR_FALSE);
PKIX_FREE(otherName);
otherName = NULL;
}
PKIX_RETURN(GENERALNAME);
}
/*
* FUNCTION: pkix_pl_ipAddrBytes2Ascii
* DESCRIPTION:
*
* Converts the DER encoding of an IPAddress pointed to by "secItem" to an
* ASCII representation and stores the result at "pAscii". The ASCII
* representation is guaranteed to end with a NUL character. The input
* SECItem must contain non-NULL data and must have a positive length.
*
* The return value "pAscii" is not reference-counted and will need to
* be freed with PKIX_PL_Free.
* XXX this function assumes that IPv4 addresses are being used
* XXX what about IPv6? can NSS tell the difference
*
* PARAMETERS
* "secItem"
* Address of SECItem which contains bytes and length of DER encoding.
* Must be non-NULL.
* "pAscii"
* Address where object pointer will be stored. Must be non-NULL.
* "plContext"
* Platform-specific context pointer.
* THREAD SAFETY:
* Thread Safe (see Thread Safety Definitions in Programmer's Guide)
* RETURNS:
* Returns NULL if the function succeeds.
* Returns an Object Error if the function fails in a non-fatal way.
* Returns a Fatal Error if the function fails in an unrecoverable way.
*/
PKIX_Error *
pkix_pl_ipAddrBytes2Ascii(
SECItem *secItem,
char **pAscii,
void *plContext)
{
char *data = NULL;
PKIX_UInt32 *tokens = NULL;
PKIX_UInt32 numTokens = 0;
PKIX_UInt32 i = 0;
char *asciiString = NULL;
PKIX_ENTER(OBJECT, "pkix_pl_ipAddrBytes2Ascii");
PKIX_NULLCHECK_THREE(secItem, pAscii, secItem->data);
if (secItem->len == 0) {
PKIX_ERROR_FATAL(PKIX_IPADDRBYTES2ASCIIDATALENGTHZERO);
}
data = (char *)(secItem->data);
numTokens = secItem->len;
/* allocate space for array of integers */
PKIX_CHECK(PKIX_PL_Malloc
(numTokens * sizeof (PKIX_UInt32),
(void **)&tokens,
plContext),
PKIX_MALLOCFAILED);
/* populate array of integers */
for (i = 0; i < numTokens; i++){
tokens[i] = data[i];
}
/* convert array of integers to ASCII */
PKIX_CHECK(pkix_pl_helperBytes2Ascii
(tokens, numTokens, &asciiString, plContext),
PKIX_HELPERBYTES2ASCIIFAILED);
*pAscii = asciiString;
cleanup:
PKIX_FREE(tokens);
PKIX_RETURN(OBJECT);
}
/*
* FUNCTION: PKIX_PL_ByteArray_Create (see comments in pkix_pl_system.h)
*/
PKIX_Error *
PKIX_PL_ByteArray_Create(
void *array,
PKIX_UInt32 length,
PKIX_PL_ByteArray **pByteArray,
void *plContext)
{
PKIX_PL_ByteArray *byteArray = NULL;
PKIX_ENTER(BYTEARRAY, "PKIX_PL_ByteArray_Create");
PKIX_NULLCHECK_ONE(pByteArray);
PKIX_CHECK(PKIX_PL_Object_Alloc
(PKIX_BYTEARRAY_TYPE,
sizeof (PKIX_PL_ByteArray),
(PKIX_PL_Object **)&byteArray,
plContext),
PKIX_COULDNOTCREATEOBJECTSTORAGE);
byteArray->length = length;
byteArray->array = NULL;
if (length != 0){
/* Alloc space for array */
PKIX_NULLCHECK_ONE(array);
PKIX_CHECK(PKIX_PL_Malloc
(length, (void**)&(byteArray->array), plContext),
PKIX_MALLOCFAILED);
PKIX_BYTEARRAY_DEBUG("\tCalling PORT_Memcpy).\n");
(void) PORT_Memcpy(byteArray->array, array, length);
}
*pByteArray = byteArray;
cleanup:
if (PKIX_ERROR_RECEIVED){
PKIX_DECREF(byteArray);
}
PKIX_RETURN(BYTEARRAY);
}
/*
* FUNCTION: PKIX_PL_NssContext_Create
* (see comments in pkix_samples_modules.h)
*/
PKIX_Error *
PKIX_PL_NssContext_Create(
PKIX_UInt32 certificateUsage,
PKIX_Boolean useNssArena,
void *wincx,
void **pNssContext)
{
PKIX_PL_NssContext *context = NULL;
PRArenaPool *arena = NULL;
void *plContext = NULL;
PKIX_ENTER(CONTEXT, "PKIX_PL_NssContext_Create");
PKIX_NULLCHECK_ONE(pNssContext);
PKIX_CHECK(PKIX_PL_Malloc
(sizeof(PKIX_PL_NssContext), (void **)&context, NULL),
PKIX_MALLOCFAILED);
if (useNssArena == PKIX_TRUE) {
PKIX_CONTEXT_DEBUG("\t\tCalling PORT_NewArena\n");
arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
}
context->arena = arena;
context->certificateUsage = (SECCertificateUsage)certificateUsage;
context->wincx = wincx;
context->timeoutSeconds = PKIX_DEFAULT_COMM_TIMEOUT_SECONDS;
context->maxResponseLength = PKIX_DEFAULT_MAX_RESPONSE_LENGTH;
context->crlReloadDelay = PKIX_DEFAULT_CRL_RELOAD_DELAY_SECONDS;
context->badDerCrlReloadDelay =
PKIX_DEFAULT_BAD_CRL_RELOAD_DELAY_SECONDS;
*pNssContext = context;
cleanup:
PKIX_RETURN(CONTEXT);
}
/*
* FUNCTION: pkix_pl_ByteArray_ToString
* (see comments for PKIX_PL_ToStringCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_pl_ByteArray_ToString(
PKIX_PL_Object *object,
PKIX_PL_String **pString,
void *plContext)
{
PKIX_PL_ByteArray *array = NULL;
char *tempText = NULL;
char *stringText = NULL; /* "[OOO, OOO, ... OOO]" */
PKIX_UInt32 i, outputLen, bufferSize;
PKIX_ENTER(BYTEARRAY, "pkix_pl_ByteArray_ToString");
PKIX_NULLCHECK_TWO(object, pString);
PKIX_CHECK(pkix_CheckType(object, PKIX_BYTEARRAY_TYPE, plContext),
PKIX_OBJECTNOTBYTEARRAY);
array = (PKIX_PL_ByteArray *)object;
if ((array->length) == 0) {
PKIX_CHECK(PKIX_PL_String_Create
(PKIX_ESCASCII, "[]", 0, pString, plContext),
PKIX_COULDNOTCREATESTRING);
} else {
/* Allocate space for "XXX, ". */
bufferSize = 2+5*array->length;
/* Allocate space for format string */
PKIX_CHECK(PKIX_PL_Malloc
(bufferSize, (void **)&stringText, plContext),
PKIX_MALLOCFAILED);
stringText[0] = 0;
outputLen = 0;
PKIX_BYTEARRAY_DEBUG("\tCalling PR_smprintf).\n");
tempText =
PR_smprintf
("[%03u", (0x0FF&((char *)(array->array))[0]));
PKIX_BYTEARRAY_DEBUG("\tCalling PL_strlen).\n");
outputLen += PL_strlen(tempText);
PKIX_BYTEARRAY_DEBUG("\tCalling PL_strcat).\n");
stringText = PL_strcat(stringText, tempText);
PKIX_BYTEARRAY_DEBUG("\tCalling PR_smprintf_free).\n");
PR_smprintf_free(tempText);
for (i = 1; i < array->length; i++) {
PKIX_BYTEARRAY_DEBUG("\tCalling PR_smprintf).\n");
tempText = PR_smprintf
(", %03u",
(0x0FF&((char *)(array->array))[i]));
if (tempText == NULL){
PKIX_ERROR(PKIX_PRSMPRINTFFAILED);
}
PKIX_BYTEARRAY_DEBUG("\tCalling PL_strlen).\n");
outputLen += PL_strlen(tempText);
PKIX_BYTEARRAY_DEBUG("\tCalling PL_strcat).\n");
stringText = PL_strcat(stringText, tempText);
PKIX_BYTEARRAY_DEBUG("\tCalling PR_smprintf_free).\n");
PR_smprintf_free(tempText);
tempText = NULL;
}
stringText[outputLen++] = ']';
stringText[outputLen] = 0;
PKIX_CHECK(PKIX_PL_String_Create
(PKIX_ESCASCII, stringText, 0, pString, plContext),
PKIX_STRINGCREATEFAILED);
}
cleanup:
PKIX_FREE(stringText);
PKIX_RETURN(BYTEARRAY);
}
/*
* FUNCTION: pkix_pl_PrimHashTable_Add
* DESCRIPTION:
*
* Adds the value pointed to by "value" to the PrimHashTable pointed to by
* "ht" using the key pointed to by "key" and the hashCode value equal to
* "hashCode", using the function pointed to by "keyComp" to compare keys.
* Assumes the key is either a PKIX_UInt32 or a PKIX_PL_Object. If the value
* already exists in the hashtable, this function returns a non-fatal error.
*
* PARAMETERS:
* "ht"
* Address of PrimHashtable to insert into. Must be non-NULL.
* "key"
* Address of key. Typically a PKIX_UInt32 or PKIX_PL_Object.
* Must be non-NULL.
* "value"
* Address of Object to be added to PrimHashtable. Must be non-NULL.
* "hashCode"
* Hashcode value of the key.
* "keyComp"
* Address of function used to determine if two keys are equal.
* If NULL, pkix_pl_KeyComparator_Default is used.
* "plContext"
* Platform-specific context pointer.
* THREAD SAFETY:
* Not Thread Safe - assumes exclusive access to "ht"
* (see Thread Safety Definitions in Programmer's Guide)
* RETURNS:
* Returns NULL if the function succeeds.
* Returns a HashTable Error if the function fails in a non-fatal way.
* Returns a Fatal Error if the function fails in an unrecoverable way.
*/
PKIX_Error *
pkix_pl_PrimHashTable_Add(
pkix_pl_PrimHashTable *ht,
void *key,
void *value,
PKIX_UInt32 hashCode,
PKIX_PL_EqualsCallback keyComp,
void *plContext)
{
pkix_pl_HT_Elem **elemPtr = NULL;
pkix_pl_HT_Elem *element = NULL;
PKIX_Boolean compResult = PKIX_FALSE;
PKIX_ENTER(HASHTABLE, "pkix_pl_PrimHashTable_Add");
PKIX_NULLCHECK_THREE(ht, key, value);
for (elemPtr = &((ht->buckets)[hashCode%ht->size]), element = *elemPtr;
element != NULL; elemPtr = &(element->next), element = *elemPtr) {
if (element->hashCode != hashCode){
/* no possibility of a match */
continue;
}
if (keyComp == NULL){
PKIX_CHECK(pkix_pl_KeyComparator_Default
((PKIX_UInt32 *)key,
(PKIX_UInt32 *)(element->key),
&compResult,
plContext),
PKIX_COULDNOTTESTWHETHERKEYSEQUAL);
} else {
PKIX_CHECK(keyComp
((PKIX_PL_Object *)key,
(PKIX_PL_Object *)(element->key),
&compResult,
plContext),
PKIX_COULDNOTTESTWHETHERKEYSEQUAL);
}
if ((element->hashCode == hashCode) &&
(compResult == PKIX_TRUE)){
/* Same key already exists in the table */
PKIX_ERROR(PKIX_ATTEMPTTOADDDUPLICATEKEY);
}
}
/* Next Element should be NULL at this point */
if (element != NULL) {
PKIX_ERROR(PKIX_ERRORTRAVERSINGBUCKET);
}
/* Create a new HT_Elem */
PKIX_CHECK(PKIX_PL_Malloc
(sizeof (pkix_pl_HT_Elem), (void **)elemPtr, plContext),
PKIX_MALLOCFAILED);
element = *elemPtr;
element->key = key;
element->value = value;
element->hashCode = hashCode;
element->next = NULL;
cleanup:
PKIX_RETURN(HASHTABLE);
}
/*
* FUNCTION: pkix_EscASCII_to_UTF16
* DESCRIPTION:
*
* Converts array of bytes pointed to by "escAsciiString" with length of
* "escAsciiLength" into a freshly allocated UTF-16 string and stores a
* pointer to that string at "pDest" and stores the string's length at
* "pLength". The caller is responsible for freeing "pDest" using
* PKIX_PL_Free. If "debug" is set, uses EscASCII_Debug encoding.
*
* PARAMETERS:
* "escAsciiString"
* Address of array of bytes representing data source. Must be non-NULL.
* "escAsciiLength"
* Length of data source. Must be even.
* "debug"
* Boolean value indicating whether debug mode is desired.
* "pDest"
* Address where data will be stored. Must be non-NULL.
* "pLength"
* Address where data length will be stored. Must be non-NULL.
* "plContext"
* Platform-specific context pointer.
* THREAD SAFETY:
* Thread Safe (see Thread Safety Definitions in Programmer's Guide)
* RETURNS:
* Returns NULL if the function succeeds.
* Returns a String Error if the function fails in a non-fatal way.
* Returns a Fatal Error if the function fails in an unrecoverable way.
*/
PKIX_Error *
pkix_EscASCII_to_UTF16(
const char *escAsciiString,
PKIX_UInt32 escAsciiLen,
PKIX_Boolean debug,
void **pDest,
PKIX_UInt32 *pLength,
void *plContext)
{
PKIX_UInt32 newLen, i, j, charSize;
PKIX_UInt32 x = 0, y = 0, z = 0;
unsigned char *destPtr = NULL;
unsigned char testChar, testChar2;
unsigned char *stringData = (unsigned char *)escAsciiString;
PKIX_ENTER(STRING, "pkix_EscASCII_to_UTF16");
PKIX_NULLCHECK_THREE(escAsciiString, pDest, pLength);
if (escAsciiLen == 0) {
PKIX_CHECK(PKIX_PL_Malloc(escAsciiLen, pDest, plContext),
PKIX_MALLOCFAILED);
goto cleanup;
}
/* Assume each unicode character takes two bytes */
newLen = escAsciiLen*2;
/* Count up number of unicode encoded characters */
for (i = 0; i < escAsciiLen; i++) {
if (!pkix_isPlaintext(stringData[i], debug)&&
(stringData[i] != '&')) {
PKIX_ERROR(PKIX_ILLEGALCHARACTERINESCAPEDASCII);
} else if (PL_strstr(escAsciiString+i, "&") ==
escAsciiString+i) {
/* Convert EscAscii "&" to two bytes */
newLen -= 8;
i += 4;
} else if ((PL_strstr(escAsciiString+i, "&#x") ==
escAsciiString+i)||
(PL_strstr(escAsciiString+i, "&#X") ==
escAsciiString+i)) {
if (((i+7) <= escAsciiLen)&&
(escAsciiString[i+7] == ';')) {
/* Convert &#xNNNN; to two bytes */
newLen -= 14;
i += 7;
} else if (((i+11) <= escAsciiLen)&&
(escAsciiString[i+11] == ';')) {
/* Convert &#xNNNNNNNN; to four bytes */
newLen -= 20;
i += 11;
} else {
PKIX_ERROR(PKIX_ILLEGALUSEOFAMP);
}
}
}
PKIX_CHECK(PKIX_PL_Malloc(newLen, pDest, plContext),
PKIX_MALLOCFAILED);
/* Copy into newly allocated space */
destPtr = (unsigned char *)*pDest;
i = 0;
while (i < escAsciiLen) {
/* Copy each byte until you hit a & */
if (pkix_isPlaintext(escAsciiString[i], debug)) {
*destPtr++ = 0x00;
*destPtr++ = escAsciiString[i++];
} else if (PL_strstr(escAsciiString+i, "&") ==
escAsciiString+i) {
/* Convert EscAscii "&" to two bytes */
*destPtr++ = 0x00;
*destPtr++ = '&';
i += 5;
} else if (((PL_strstr(escAsciiString+i, "&#x") ==
escAsciiString+i)||
(PL_strstr(escAsciiString+i, "&#X") ==
escAsciiString+i))&&
((i+7) <= escAsciiLen)) {
/* We're either looking at &#xNNNN; or &#xNNNNNNNN; */
charSize = (escAsciiString[i+7] == ';')?4:8;
/* Skip past the &#x */
i += 3;
/* Make sure there is a terminating semi-colon */
if (((i+charSize) > escAsciiLen)||
(escAsciiString[i+charSize] != ';')) {
PKIX_ERROR(PKIX_TRUNCATEDUNICODEINESCAPEDASCII);
}
for (j = 0; j < charSize; j++) {
if (!PKIX_ISXDIGIT
(escAsciiString[i+j])) {
PKIX_ERROR(PKIX_ILLEGALUNICODECHARACTER);
} else if (charSize == 8) {
x |= (pkix_hex2i
(escAsciiString[i+j]))
<<(4*(7-j));
}
}
testChar =
(pkix_hex2i(escAsciiString[i])<<4)|
pkix_hex2i(escAsciiString[i+1]);
testChar2 =
(pkix_hex2i(escAsciiString[i+2])<<4)|
pkix_hex2i(escAsciiString[i+3]);
if (charSize == 4) {
if ((testChar >= 0xD8)&&
(testChar <= 0xDF)) {
PKIX_ERROR(PKIX_ILLEGALSURROGATEPAIR);
} else if ((testChar == 0x00)&&
pkix_isPlaintext(testChar2, debug)) {
PKIX_ERROR(
PKIX_ILLEGALCHARACTERINESCAPEDASCII);
}
*destPtr++ = testChar;
*destPtr++ = testChar2;
} else if (charSize == 8) {
/* First two chars must be 0001-0010 */
if (!((testChar == 0x00)&&
((testChar2 >= 0x01)&&
(testChar2 <= 0x10)))) {
PKIX_ERROR(
PKIX_ILLEGALCHARACTERINESCAPEDASCII);
}
/*
* Unicode Strings of the form:
* x = 0001 0000..0010 FFFF
* Encoded as pairs of UTF-16 where
* y = ((x - 0001 0000) / 400) + D800
* z = ((x - 0001 0000) % 400) + DC00
*/
x -= 0x00010000;
y = (x/0x400)+ 0xD800;
z = (x%0x400)+ 0xDC00;
/* Copy four bytes */
*destPtr++ = (y&0xFF00)>>8;
*destPtr++ = (y&0x00FF);
*destPtr++ = (z&0xFF00)>>8;
*destPtr++ = (z&0x00FF);
}
/* Move past the Hex digits and the semi-colon */
i += charSize+1;
} else {
/*
* FUNCTION: pkix_UTF16_to_EscASCII
* DESCRIPTION:
*
* Converts array of bytes pointed to by "utf16String" with length of
* "utf16Length" (which must be even) into a freshly allocated Escaped ASCII
* string and stores a pointer to that string at "pDest" and stores the
* string's length at "pLength". The Escaped ASCII string's length does not
* include the final NUL character. The caller is responsible for freeing
* "pDest" using PKIX_PL_Free. If "debug" is set, uses EscASCII_Debug
* encoding.
*
* PARAMETERS:
* "utf16String"
* Address of array of bytes representing data source. Must be non-NULL.
* "utf16Length"
* Length of data source. Must be even.
* "debug"
* Boolean value indicating whether debug mode is desired.
* "pDest"
* Address where data will be stored. Must be non-NULL.
* "pLength"
* Address where data length will be stored. Must be non-NULL.
* "plContext"
* Platform-specific context pointer.
* THREAD SAFETY:
* Thread Safe (see Thread Safety Definitions in Programmer's Guide)
* RETURNS:
* Returns NULL if the function succeeds.
* Returns a String Error if the function fails in a non-fatal way.
* Returns a Fatal Error if the function fails in an unrecoverable way.
*/
PKIX_Error *
pkix_UTF16_to_EscASCII(
const void *utf16String,
PKIX_UInt32 utf16Length,
PKIX_Boolean debug,
char **pDest,
PKIX_UInt32 *pLength,
void *plContext)
{
char *destPtr = NULL;
PKIX_UInt32 i, charLen;
PKIX_UInt32 x = 0, y = 0, z = 0;
unsigned char *utf16Char = (unsigned char *)utf16String;
PKIX_ENTER(STRING, "pkix_UTF16_to_EscASCII");
PKIX_NULLCHECK_THREE(utf16String, pDest, pLength);
/* Assume every pair of bytes becomes &#xNNNN; */
charLen = 4*utf16Length;
/* utf16Lenght must be even */
if ((utf16Length % 2) != 0){
PKIX_ERROR(PKIX_UTF16ALIGNMENTERROR);
}
/* Count how many bytes we need */
for (i = 0; i < utf16Length; i += 2) {
if ((utf16Char[i] == 0x00)&&
pkix_isPlaintext(utf16Char[i+1], debug)) {
if (utf16Char[i+1] == '&') {
/* Need to convert this to & */
charLen -= 3;
} else {
/* We can fit this into one char */
charLen -= 7;
}
} else if ((utf16Char[i] >= 0xD8) && (utf16Char[i] <= 0xDB)) {
if ((i+3) >= utf16Length) {
PKIX_ERROR(PKIX_UTF16HIGHZONEALIGNMENTERROR);
} else if ((utf16Char[i+2] >= 0xDC)&&
(utf16Char[i+2] <= 0xDF)) {
/* Quartet of bytes will become &#xNNNNNNNN; */
charLen -= 4;
/* Quartet of bytes will produce 12 chars */
i += 2;
} else {
/* Second pair should be DC00-DFFF */
PKIX_ERROR(PKIX_UTF16LOWZONEERROR);
}
}
}
*pLength = charLen;
/* Ensure this string is null terminated */
charLen++;
/* Allocate space for character array */
PKIX_CHECK(PKIX_PL_Malloc(charLen, (void **)pDest, plContext),
PKIX_MALLOCFAILED);
destPtr = *pDest;
for (i = 0; i < utf16Length; i += 2) {
if ((utf16Char[i] == 0x00)&&
pkix_isPlaintext(utf16Char[i+1], debug)) {
/* Write a single character */
*destPtr++ = utf16Char[i+1];
} else if ((utf16Char[i+1] == '&') && (utf16Char[i] == 0x00)){
*destPtr++ = '&';
*destPtr++ = 'a';
*destPtr++ = 'm';
*destPtr++ = 'p';
*destPtr++ = ';';
} else if ((utf16Char[i] >= 0xD8)&&
(utf16Char[i] <= 0xDB)&&
(utf16Char[i+2] >= 0xDC)&&
(utf16Char[i+2] <= 0xDF)) {
/*
* Special UTF pairs are of the form:
* x = D800..DBFF; y = DC00..DFFF;
* The result is of the form:
* ((x - D800) * 400 + (y - DC00)) + 0001 0000
*/
x = 0x0FFFF & ((utf16Char[i]<<8) | utf16Char[i+1]);
y = 0x0FFFF & ((utf16Char[i+2]<<8) | utf16Char[i+3]);
z = ((x - 0xD800) * 0x400 + (y - 0xDC00)) + 0x00010000;
/* Sprintf &#xNNNNNNNN; */
PKIX_STRING_DEBUG("\tCalling PR_snprintf).\n");
if (PR_snprintf(destPtr, 13, "&#x%08X;", z) ==
(PKIX_UInt32)(-1)) {
PKIX_ERROR(PKIX_PRSNPRINTFFAILED);
}
i += 2;
destPtr += 12;
} else {
/* Sprintf &#xNNNN; */
PKIX_STRING_DEBUG("\tCalling PR_snprintf).\n");
if (PR_snprintf
(destPtr,
9,
"&#x%02X%02X;",
utf16Char[i],
utf16Char[i+1]) ==
(PKIX_UInt32)(-1)) {
PKIX_ERROR(PKIX_PRSNPRINTFFAILED);
}
destPtr += 8;
}
}
*destPtr = '\0';
cleanup:
if (PKIX_ERROR_RECEIVED){
PKIX_FREE(*pDest);
}
PKIX_RETURN(STRING);
}
/*
* FUNCTION: pkix_pl_oidBytes2Ascii
* DESCRIPTION:
*
* Converts the DER encoding of an OID pointed to by "secItem" to an ASCII
* representation and stores it at "pAscii". The ASCII representation is
* guaranteed to end with a NUL character. The input SECItem must contain
* non-NULL data and must have a positive length.
*
* Example: the six bytes {2a 86 48 86 f7 0d} represent the
* four integer tokens {1, 2, 840, 113549}, which we will convert
* into ASCII yielding "1.2.840.113549"
*
* The return value "pAscii" is not reference-counted and will need to
* be freed with PKIX_PL_Free.
*
* PARAMETERS
* "secItem"
* Address of SECItem which contains bytes and length of DER encoding.
* Must be non-NULL.
* "pAscii"
* Address where object pointer will be stored. Must be non-NULL.
* "plContext"
* Platform-specific context pointer.
* THREAD SAFETY:
* Thread Safe (see Thread Safety Definitions in Programmer's Guide)
* RETURNS:
* Returns NULL if the function succeeds.
* Returns an OID Error if the function fails in a non-fatal way.
* Returns a Fatal Error if the function fails in an unrecoverable way.
*/
PKIX_Error *
pkix_pl_oidBytes2Ascii(
SECItem *secItem,
char **pAscii,
void *plContext)
{
char *data = NULL;
PKIX_UInt32 *tokens = NULL;
PKIX_UInt32 token = 0;
PKIX_UInt32 numBytes = 0;
PKIX_UInt32 numTokens = 0;
PKIX_UInt32 i = 0, x = 0, y = 0;
PKIX_UInt32 index = 0;
char *asciiString = NULL;
PKIX_ENTER(OID, "pkix_pl_oidBytes2Ascii");
PKIX_NULLCHECK_THREE(secItem, pAscii, secItem->data);
if (secItem->len == 0) {
PKIX_ERROR_FATAL(PKIX_OIDBYTES2ASCIIDATALENGTHZERO);
}
data = (char *)(secItem->data);
numBytes = secItem->len;
numTokens = 0;
/* calculate how many integer tokens are represented by the bytes. */
for (i = 0; i < numBytes; i++){
if ((data[i] & 0x080) == 0){
numTokens++;
}
}
/* if we are unable to retrieve any tokens at all, we throw an error */
if (numTokens == 0){
PKIX_ERROR(PKIX_INVALIDDERENCODINGFOROID);
}
/* add one more token b/c the first byte always contains two tokens */
numTokens++;
/* allocate space for array of integers */
PKIX_CHECK(PKIX_PL_Malloc
(numTokens * sizeof (PKIX_UInt32),
(void **)&tokens,
plContext),
PKIX_MALLOCFAILED);
/* populate array of integers */
for (i = 0; i < numTokens; i++){
/* retrieve integer token */
PKIX_CHECK(pkix_pl_getOIDToken
(data, index, &token, &index, plContext),
PKIX_GETOIDTOKENFAILED);
if (i == 0){
/*
* special case: the first DER-encoded byte represents
* two tokens. We take advantage of fact that first
* token must be 0, 1, or 2; and second token must be
* between {0, 39} inclusive if first token is 0 or 1.
*/
if (token < 40)
x = 0;
else if (token < 80)
x = 1;
else
x = 2;
y = token - (x * 40);
tokens[0] = x;
tokens[1] = y;
i++;
} else {
tokens[i] = token;
}
}
/* convert array of integers to ASCII */
PKIX_CHECK(pkix_pl_helperBytes2Ascii
(tokens, numTokens, &asciiString, plContext),
PKIX_HELPERBYTES2ASCIIFAILED);
*pAscii = asciiString;
cleanup:
PKIX_FREE(tokens);
PKIX_RETURN(OID);
}
/*
* FUNCTION: pkix_pl_helperBytes2Ascii
* DESCRIPTION:
*
* Converts an array of integers pointed to by "tokens" with a length of
* "numTokens", to an ASCII string consisting of those integers with dots in
* between them and stores the result at "pAscii". The ASCII representation is
* guaranteed to end with a NUL character. This is particularly useful for
* OID's and IP Addresses.
*
* The return value "pAscii" is not reference-counted and will need to
* be freed with PKIX_PL_Free.
*
* PARAMETERS
* "tokens"
* Address of array of integers. Must be non-NULL.
* "numTokens"
* Length of array of integers. Must be non-zero.
* "pAscii"
* Address where object pointer will be stored. Must be non-NULL.
* "plContext"
* Platform-specific context pointer.
* THREAD SAFETY:
* Thread Safe (see Thread Safety Definitions in Programmer's Guide)
* RETURNS:
* Returns NULL if the function succeeds.
* Returns an Object Error if the function fails in a non-fatal way.
* Returns a Fatal Error if the function fails in an unrecoverable way.
*/
PKIX_Error *
pkix_pl_helperBytes2Ascii(
PKIX_UInt32 *tokens,
PKIX_UInt32 numTokens,
char **pAscii,
void *plContext)
{
char *tempString = NULL;
char *outputString = NULL;
char *format = "%d";
PKIX_UInt32 i = 0;
PKIX_UInt32 outputLen = 0;
PKIX_Int32 error;
PKIX_ENTER(OBJECT, "pkix_pl_helperBytes2Ascii");
PKIX_NULLCHECK_TWO(tokens, pAscii);
if (numTokens == 0) {
PKIX_ERROR_FATAL(PKIX_HELPERBYTES2ASCIINUMTOKENSZERO);
}
/*
* tempString will hold the string representation of a PKIX_UInt32 type
* The maximum value that can be held by an unsigned 32-bit integer
* is (2^32 - 1) = 4294967295 (which is ten digits long)
* Since tempString will hold the string representation of a
* PKIX_UInt32, we allocate 11 bytes for it (1 byte for '\0')
*/
PKIX_CHECK(PKIX_PL_Malloc
(MAX_DIGITS_32 + 1, (void **)&tempString, plContext),
PKIX_MALLOCFAILED);
for (i = 0; i < numTokens; i++){
PKIX_OBJECT_DEBUG("\tCalling PR_snprintf).\n");
error = PR_snprintf(tempString,
MAX_DIGITS_32 + 1,
format,
tokens[i]);
if (error == -1){
PKIX_ERROR(PKIX_PRSNPRINTFFAILED);
}
PKIX_OBJECT_DEBUG("\tCalling PL_strlen).\n");
outputLen += PL_strlen(tempString);
/* Include a dot to separate each number */
outputLen++;
}
/* Allocate space for the destination string */
PKIX_CHECK(PKIX_PL_Malloc
(outputLen, (void **)&outputString, plContext),
PKIX_MALLOCFAILED);
*outputString = '\0';
/* Concatenate all strings together */
for (i = 0; i < numTokens; i++){
PKIX_OBJECT_DEBUG("\tCalling PR_snprintf).\n");
error = PR_snprintf(tempString,
MAX_DIGITS_32 + 1,
format,
tokens[i]);
if (error == -1){
PKIX_ERROR(PKIX_PRSNPRINTFFAILED);
}
PKIX_OBJECT_DEBUG("\tCalling PL_strcat).\n");
(void) PL_strcat(outputString, tempString);
/* we don't want to put a "." at the very end */
if (i < (numTokens - 1)){
PKIX_OBJECT_DEBUG("\tCalling PL_strcat).\n");
(void) PL_strcat(outputString, ".");
}
}
/* Ensure output string ends with terminating null */
outputString[outputLen-1] = '\0';
*pAscii = outputString;
outputString = NULL;
cleanup:
PKIX_FREE(outputString);
PKIX_FREE(tempString);
PKIX_RETURN(OBJECT);
}
/*
* FUNCTION: pkix_pl_CollectionCertStoreContext_PopulateCRL
* DESCRIPTION:
*
* Create list of CRLs from *.crl files at directory specified in dirName,
* Not recursive to sub-dirctory. Also assume the directory contents are
* not changed dynamically.
*
* PARAMETERS
* "colCertStoreContext" - Address of CollectionCertStoreContext
* where the dirName is specified and where the return
* CRLs are stored as a list. Must be non-NULL.
* "plContext" - Platform-specific context pointer.
*
* THREAD SAFETY:
* Not Thread Safe - A lock at top level is required.
*
* RETURNS:
* Returns NULL if the function succeeds.
* Returns a CollectionCertStoreContext Error if the function fails in
* a non-fatal way.
* Returns a Fatal Error if the function fails in an unrecoverable way.
*/
static PKIX_Error *
pkix_pl_CollectionCertStoreContext_PopulateCRL(
PKIX_PL_CollectionCertStoreContext *colCertStoreContext,
void *plContext)
{
PKIX_List *crlList = NULL;
PKIX_PL_CRL *crlItem = NULL;
char *dirName = NULL;
char *pathName = NULL;
PKIX_UInt32 dirNameLen = 0;
PRErrorCode prError = 0;
PRDir *dir = NULL;
PRDirEntry *dirEntry = NULL;
PKIX_ENTER(COLLECTIONCERTSTORECONTEXT,
"pkix_pl_CollectionCertStoreContext_PopulateCRL");
PKIX_NULLCHECK_ONE(colCertStoreContext);
/* convert directory to ascii */
PKIX_CHECK(PKIX_PL_String_GetEncoded
(colCertStoreContext->storeDir,
PKIX_ESCASCII,
(void **)&dirName,
&dirNameLen,
plContext),
PKIX_STRINGGETENCODEDFAILED);
/* create CRL list, if no CRL file, should return an empty list */
PKIX_CHECK(PKIX_List_Create(&crlList, plContext),
PKIX_LISTCREATEFAILED);
/* open directory and read in .crl files */
PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG("\t\t Calling PR_OpenDir.\n");
dir = PR_OpenDir(dirName);
if (!dir) {
PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG_ARG
("\t\t Directory Name:%s\n", dirName);
PKIX_ERROR(PKIX_CANNOTOPENCOLLECTIONCERTSTORECONTEXTDIRECTORY);
}
PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG("\t\t Calling PR_ReadDir.\n");
dirEntry = PR_ReadDir(dir, PR_SKIP_HIDDEN | PR_SKIP_BOTH);
if (!dirEntry) {
PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
("\t\t Empty directory.\n");
PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
("\t\t Calling PR_GetError.\n");
prError = PR_GetError();
}
PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG("\t\t Calling PR_SetError.\n");
PR_SetError(0, 0);
while (dirEntry != NULL && prError == 0) {
if (PL_strrstr(dirEntry->name, ".crl") ==
dirEntry->name + PL_strlen(dirEntry->name) - 4) {
PKIX_CHECK_ONLY_FATAL
(PKIX_PL_Malloc
(dirNameLen + PL_strlen(dirEntry->name) + 2,
(void **)&pathName,
plContext),
PKIX_MALLOCFAILED);
if ((!PKIX_ERROR_RECEIVED) && (pathName != NULL)){
PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
("\t\t Calling PL_strcpy for dirName.\n");
PL_strcpy(pathName, dirName);
PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
("\t\t Calling PL_strcat for dirName.\n");
PL_strcat(pathName, "/");
PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
("\t\t Calling PL_strcat for /.\n");
PL_strcat(pathName, dirEntry->name);
PKIX_CHECK_ONLY_FATAL
(pkix_pl_CollectionCertStoreContext_CreateCRL
(pathName, &crlItem, plContext),
PKIX_COLLECTIONCERTSTORECONTEXTCREATECRLFAILED);
if (!PKIX_ERROR_RECEIVED){
PKIX_CHECK_ONLY_FATAL
(PKIX_List_AppendItem
(crlList,
(PKIX_PL_Object *)crlItem,
plContext),
PKIX_LISTAPPENDITEMFAILED);
}
}
PKIX_DECREF(crlItem);
PKIX_FREE(pathName);
}
PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
("\t\t Calling PR_SetError.\n");
PR_SetError(0, 0);
PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
("\t\t Calling PR_ReadDir.\n");
dirEntry = PR_ReadDir(dir, PR_SKIP_HIDDEN | PR_SKIP_BOTH);
if (!dirEntry) {
PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
("\t\t Calling PR_GetError.\n");
prError = PR_GetError();
}
}
if ((prError != 0) && (prError != PR_NO_MORE_FILES_ERROR)) {
PKIX_ERROR(PKIX_COLLECTIONCERTSTORECONTEXTGETSELECTCRLFAILED);
}
PKIX_CHECK(PKIX_List_SetImmutable(crlList, plContext),
PKIX_LISTSETIMMUTABLEFAILED);
PKIX_INCREF(crlList);
colCertStoreContext->crlList = crlList;
cleanup:
if (dir) {
PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
("\t\t Calling PR_CloseDir.\n");
PR_CloseDir(dir);
}
PKIX_FREE(pathName);
PKIX_FREE(dirName);
if (PKIX_ERROR_RECEIVED){
PKIX_DECREF(crlList);
}
PKIX_DECREF(crlItem);
PKIX_DECREF(crlList);
PKIX_RETURN(COLLECTIONCERTSTORECONTEXT);
}
/*
* FUNCTION: pkix_pl_ByteArray_ToHexString
* DESCRIPTION:
*
* Creates a hex-String representation of the ByteArray pointed to by "array"
* and stores the result at "pString". The hex-String consists of hex-digit
* pairs separated by spaces, and the entire string enclosed within square
* brackets, e.g. [43 61 6E 20 79 6F 75 20 72 65 61 64 20 74 68 69 73 3F].
* A zero-length ByteArray is represented as [].
* PARAMETERS
* "array"
* ByteArray to be represented by the hex-String; must be non-NULL
* "pString"
* Address where String will be stored. Must be non-NULL.
* "plContext"
* Platform-specific context pointer.
* THREAD SAFETY:
* Thread Safe (see Thread Safety Definitions in Programmer's Guide)
* RETURNS:
* Returns NULL if the function succeeds.
* Returns a Cert Error if the function fails in a non-fatal way.
* Returns a Fatal Error if the function fails in an unrecoverable way.
*/
PKIX_Error *
pkix_pl_ByteArray_ToHexString(
PKIX_PL_ByteArray *array,
PKIX_PL_String **pString,
void *plContext)
{
char *tempText = NULL;
char *stringText = NULL; /* "[XX XX XX ...]" */
PKIX_UInt32 i, outputLen, bufferSize;
PKIX_ENTER(BYTEARRAY, "pkix_pl_ByteArray_ToHexString");
PKIX_NULLCHECK_TWO(array, pString);
if ((array->length) == 0) {
PKIX_CHECK(PKIX_PL_String_Create
(PKIX_ESCASCII, "[]", 0, pString, plContext),
PKIX_COULDNOTCREATESTRING);
} else {
/*
* Allocate space for format string
* '[' + "XX" + (n-1)*" XX" + ']' + '\0'
*/
bufferSize = 2 + (3*(array->length));
PKIX_CHECK(PKIX_PL_Malloc
(bufferSize, (void **)&stringText, plContext),
PKIX_COULDNOTALLOCATEMEMORY);
stringText[0] = 0;
outputLen = 0;
PKIX_BYTEARRAY_DEBUG("\tCalling PR_smprintf).\n");
tempText = PR_smprintf
("[%02X", (0x0FF&((char *)(array->array))[0]));
PKIX_BYTEARRAY_DEBUG("\tCalling PL_strlen).\n");
outputLen += PL_strlen(tempText);
PKIX_BYTEARRAY_DEBUG("\tCalling PL_strcat).\n");
stringText = PL_strcat(stringText, tempText);
PKIX_BYTEARRAY_DEBUG("\tCalling PR_smprintf_free).\n");
PR_smprintf_free(tempText);
for (i = 1; i < array->length; i++) {
PKIX_BYTEARRAY_DEBUG("\tCalling PR_smprintf).\n");
tempText = PR_smprintf
(" %02X", (0x0FF&((char *)(array->array))[i]));
if (tempText == NULL){
PKIX_ERROR(PKIX_PRSMPRINTFFAILED);
}
PKIX_BYTEARRAY_DEBUG("\tCalling PL_strlen).\n");
outputLen += PL_strlen(tempText);
PKIX_BYTEARRAY_DEBUG("\tCalling PL_strcat).\n");
stringText = PL_strcat(stringText, tempText);
PKIX_BYTEARRAY_DEBUG("\tCalling PR_smprintf_free).\n");
PR_smprintf_free(tempText);
tempText = NULL;
}
stringText[outputLen++] = ']';
stringText[outputLen] = 0;
PKIX_CHECK(PKIX_PL_String_Create
(PKIX_ESCASCII,
stringText,
0,
pString,
plContext),
PKIX_COULDNOTCREATESTRING);
}
cleanup:
PKIX_FREE(stringText);
PKIX_RETURN(BYTEARRAY);
}
/*
* FUNCTION: PKIX_PL_Object_Alloc (see comments in pkix_pl_system.h)
*/
PKIX_Error *
PKIX_PL_Object_Alloc(
PKIX_TYPENUM objType,
PKIX_UInt32 size,
PKIX_PL_Object **pObject,
void *plContext)
{
PKIX_PL_Object *object = NULL;
pkix_ClassTable_Entry *ctEntry = NULL;
PKIX_ENTER(OBJECT, "PKIX_PL_Object_Alloc");
PKIX_NULLCHECK_ONE(pObject);
/*
* We need to ensure that user-defined types have been registered.
* All system types have already been registered by PKIX_PL_Initialize.
*/
if (objType >= PKIX_NUMTYPES) { /* i.e. if this is a user-defined type */
#ifdef PKIX_USER_OBJECT_TYPE
PKIX_Boolean typeRegistered;
PKIX_OBJECT_DEBUG("\tCalling PR_Lock).\n");
PR_Lock(classTableLock);
pkixErrorResult = pkix_pl_PrimHashTable_Lookup
(classTable,
(void *)&objType,
objType,
NULL,
(void **)&ctEntry,
plContext);
PKIX_OBJECT_DEBUG("\tCalling PR_Unlock).\n");
PR_Unlock(classTableLock);
if (pkixErrorResult){
PKIX_ERROR_FATAL(PKIX_COULDNOTLOOKUPINHASHTABLE);
}
typeRegistered = (ctEntry != NULL);
if (!typeRegistered) {
PKIX_ERROR_FATAL(PKIX_UNKNOWNTYPEARGUMENT);
}
#else
PORT_Assert (0);
pkixErrorCode = PKIX_UNKNOWNOBJECTTYPE;
pkixErrorClass = PKIX_FATAL_ERROR;
goto cleanup;
#endif /* PKIX_USER_OBJECT_TYPE */
} else {
ctEntry = &systemClasses[objType];
}
PORT_Assert(size == ctEntry->typeObjectSize);
/* Allocate space for the object header and the requested size */
#ifdef PKIX_OBJECT_LEAK_TEST
PKIX_CHECK(PKIX_PL_Calloc
(1,
((PKIX_UInt32)sizeof (PKIX_PL_Object))+size,
(void **)&object,
plContext),
PKIX_MALLOCFAILED);
#else
PKIX_CHECK(PKIX_PL_Malloc
(((PKIX_UInt32)sizeof (PKIX_PL_Object))+size,
(void **)&object,
plContext),
PKIX_MALLOCFAILED);
#endif /* PKIX_OBJECT_LEAK_TEST */
/* Initialize all object fields */
object->magicHeader = PKIX_MAGIC_HEADER;
object->type = objType;
object->references = 1; /* Default to a single reference */
object->stringRep = NULL;
object->hashcode = 0;
object->hashcodeCached = 0;
/* Cannot use PKIX_PL_Mutex because it depends on Object */
/* Using NSPR Locks instead */
PKIX_OBJECT_DEBUG("\tCalling PR_NewLock).\n");
object->lock = PR_NewLock();
if (object->lock == NULL) {
PKIX_ERROR_ALLOC_ERROR();
}
PKIX_OBJECT_DEBUG("\tShifting object pointer).\n");
/* Return a pointer to the user data. Need to offset by object size */
*pObject = object + 1;
object = NULL;
/* Atomically increment object counter */
PR_ATOMIC_INCREMENT(&ctEntry->objCounter);
cleanup:
PKIX_FREE(object);
PKIX_RETURN(OBJECT);
}
/*
* FUNCTION: PKIX_PL_Object_RegisterType (see comments in pkix_pl_system.h)
*/
PKIX_Error *
PKIX_PL_Object_RegisterType(
PKIX_UInt32 objType,
char *description,
PKIX_PL_DestructorCallback destructor,
PKIX_PL_EqualsCallback equalsFunction,
PKIX_PL_HashcodeCallback hashcodeFunction,
PKIX_PL_ToStringCallback toStringFunction,
PKIX_PL_ComparatorCallback comparator,
PKIX_PL_DuplicateCallback duplicateFunction,
void *plContext)
{
pkix_ClassTable_Entry *ctEntry = NULL;
pkix_pl_Integer *key = NULL;
PKIX_ENTER(OBJECT, "PKIX_PL_Object_RegisterType");
/*
* System types are registered on startup by PKIX_PL_Initialize.
* These can not be overwritten.
*/
if (objType < PKIX_NUMTYPES) { /* if this is a system type */
PKIX_ERROR(PKIX_CANTREREGISTERSYSTEMTYPE);
}
PKIX_OBJECT_DEBUG("\tCalling PR_Lock).\n");
PR_Lock(classTableLock);
PKIX_CHECK(pkix_pl_PrimHashTable_Lookup
(classTable,
(void *)&objType,
objType,
NULL,
(void **)&ctEntry,
plContext),
PKIX_PRIMHASHTABLELOOKUPFAILED);
/* If the type is already registered, throw an error */
if (ctEntry) {
PKIX_ERROR(PKIX_TYPEALREADYREGISTERED);
}
PKIX_CHECK(PKIX_PL_Malloc
(((PKIX_UInt32)sizeof (pkix_ClassTable_Entry)),
(void **)&ctEntry,
plContext),
PKIX_MALLOCFAILED);
/* Set Default Values if none specified */
if (description == NULL){
description = "Object";
}
if (equalsFunction == NULL) {
equalsFunction = pkix_pl_Object_Equals_Default;
}
if (toStringFunction == NULL) {
toStringFunction = pkix_pl_Object_ToString_Default;
}
if (hashcodeFunction == NULL) {
hashcodeFunction = pkix_pl_Object_Hashcode_Default;
}
ctEntry->destructor = destructor;
ctEntry->equalsFunction = equalsFunction;
ctEntry->toStringFunction = toStringFunction;
ctEntry->hashcodeFunction = hashcodeFunction;
ctEntry->comparator = comparator;
ctEntry->duplicateFunction = duplicateFunction;
ctEntry->description = description;
PKIX_CHECK(PKIX_PL_Malloc
(((PKIX_UInt32)sizeof (pkix_pl_Integer)),
(void **)&key,
plContext),
PKIX_COULDNOTMALLOCNEWKEY);
key->ht_int = objType;
PKIX_CHECK(pkix_pl_PrimHashTable_Add
(classTable,
(void *)key,
(void *)ctEntry,
objType,
NULL,
plContext),
PKIX_PRIMHASHTABLEADDFAILED);
cleanup:
PKIX_OBJECT_DEBUG("\tCalling PR_Unlock).\n");
PR_Unlock(classTableLock);
PKIX_RETURN(OBJECT);
}