andre@0: /* This Source Code Form is subject to the terms of the Mozilla Public
andre@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this
andre@0:  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
andre@0: /*
andre@0:  * pkix_pl_bytearray.c
andre@0:  *
andre@0:  * ByteArray Object Functions
andre@0:  *
andre@0:  */
andre@0: 
andre@0: #include "pkix_pl_bytearray.h"
andre@0: 
andre@0: /* --Private-ByteArray-Functions------------------------------------- */
andre@0: 
andre@0: /*
andre@0:  * FUNCTION: pkix_pl_ByteArray_ToHexString
andre@0:  * DESCRIPTION:
andre@0:  *
andre@0:  *  Creates a hex-String representation of the ByteArray pointed to by "array"
andre@0:  *  and stores the result at "pString". The hex-String consists of hex-digit
andre@0:  *  pairs separated by spaces, and the entire string enclosed within square
andre@0:  *  brackets, e.g. [43 61 6E 20 79 6F 75 20 72 65 61 64 20 74 68 69 73 3F].
andre@0:  *  A zero-length ByteArray is represented as [].
andre@0:  * PARAMETERS
andre@0:  *  "array"
andre@0:  *      ByteArray to be represented by the hex-String; must be non-NULL
andre@0:  *  "pString"
andre@0:  *      Address where String will be stored. Must be non-NULL.
andre@0:  *  "plContext"
andre@0:  *      Platform-specific context pointer.
andre@0:  * THREAD SAFETY:
andre@0:  *  Thread Safe (see Thread Safety Definitions in Programmer's Guide)
andre@0:  * RETURNS:
andre@0:  *  Returns NULL if the function succeeds.
andre@0:  *  Returns a Cert Error if the function fails in a non-fatal way.
andre@0:  *  Returns a Fatal Error if the function fails in an unrecoverable way.
andre@0:  */
andre@0: PKIX_Error *
andre@0: pkix_pl_ByteArray_ToHexString(
andre@0:         PKIX_PL_ByteArray *array,
andre@0:         PKIX_PL_String **pString,
andre@0:         void *plContext)
andre@0: {
andre@0:         char *tempText = NULL;
andre@0:         char *stringText = NULL; /* "[XX XX XX ...]" */
andre@0:         PKIX_UInt32 i, outputLen, bufferSize;
andre@0: 
andre@0:         PKIX_ENTER(BYTEARRAY, "pkix_pl_ByteArray_ToHexString");
andre@0:         PKIX_NULLCHECK_TWO(array, pString);
andre@0: 
andre@0:         if ((array->length) == 0) {
andre@0:                 PKIX_CHECK(PKIX_PL_String_Create
andre@0:                         (PKIX_ESCASCII, "[]", 0, pString, plContext),
andre@0:                         PKIX_COULDNOTCREATESTRING);
andre@0:         } else {
andre@0:                 /*
andre@0:                  * Allocate space for format string
andre@0:                  * '[' + "XX" + (n-1)*" XX" + ']' + '\0'
andre@0:                  */
andre@0:                 bufferSize = 2 + (3*(array->length));
andre@0: 
andre@0:                 PKIX_CHECK(PKIX_PL_Malloc
andre@0:                         (bufferSize, (void **)&stringText, plContext),
andre@0:                         PKIX_COULDNOTALLOCATEMEMORY);
andre@0: 
andre@0:                 stringText[0] = 0;
andre@0:                 outputLen = 0;
andre@0: 
andre@0:                 PKIX_BYTEARRAY_DEBUG("\tCalling PR_smprintf).\n");
andre@0:                 tempText = PR_smprintf
andre@0:                         ("[%02X", (0x0FF&((char *)(array->array))[0]));
andre@0:                 PKIX_BYTEARRAY_DEBUG("\tCalling PL_strlen).\n");
andre@0:                 outputLen += PL_strlen(tempText);
andre@0: 
andre@0:                 PKIX_BYTEARRAY_DEBUG("\tCalling PL_strcat).\n");
andre@0:                 stringText = PL_strcat(stringText, tempText);
andre@0: 
andre@0:                 PKIX_BYTEARRAY_DEBUG("\tCalling PR_smprintf_free).\n");
andre@0:                 PR_smprintf_free(tempText);
andre@0: 
andre@0:                 for (i = 1; i < array->length; i++) {
andre@0:                         PKIX_BYTEARRAY_DEBUG("\tCalling PR_smprintf).\n");
andre@0:                         tempText = PR_smprintf
andre@0:                                 (" %02X", (0x0FF&((char *)(array->array))[i]));
andre@0: 
andre@0:                         if (tempText == NULL){
andre@0:                                 PKIX_ERROR(PKIX_PRSMPRINTFFAILED);
andre@0:                         }
andre@0: 
andre@0:                         PKIX_BYTEARRAY_DEBUG("\tCalling PL_strlen).\n");
andre@0:                         outputLen += PL_strlen(tempText);
andre@0: 
andre@0:                         PKIX_BYTEARRAY_DEBUG("\tCalling PL_strcat).\n");
andre@0:                         stringText = PL_strcat(stringText, tempText);
andre@0: 
andre@0:                         PKIX_BYTEARRAY_DEBUG("\tCalling PR_smprintf_free).\n");
andre@0:                         PR_smprintf_free(tempText);
andre@0:                         tempText = NULL;
andre@0:                 }
andre@0: 
andre@0:                 stringText[outputLen++] = ']';
andre@0:                 stringText[outputLen] = 0;
andre@0: 
andre@0:                 PKIX_CHECK(PKIX_PL_String_Create
andre@0:                         (PKIX_ESCASCII,
andre@0:                         stringText,
andre@0:                         0,
andre@0:                         pString,
andre@0:                         plContext),
andre@0:                         PKIX_COULDNOTCREATESTRING);
andre@0:         }
andre@0: 
andre@0: cleanup:
andre@0: 
andre@0:         PKIX_FREE(stringText);
andre@0:         PKIX_RETURN(BYTEARRAY);
andre@0: }
andre@0: 
andre@0: /*
andre@0:  * FUNCTION: pkix_pl_ByteArray_Comparator
andre@0:  * (see comments for PKIX_PL_ComparatorCallback in pkix_pl_system.h)
andre@0:  *
andre@0:  *  NOTE:
andre@0:  *  It is not clear that this definition of comparing byte arrays makes
andre@0:  *  sense. It does allow you to tell whether two blocks of memory are
andre@0:  *  identical, so we only use it for the Equals function (i.e. we don't
andre@0:  *  register it as a Compare function for ByteArray).
andre@0:  */
andre@0: static PKIX_Error *
andre@0: pkix_pl_ByteArray_Comparator(
andre@0:         PKIX_PL_Object *firstObject,
andre@0:         PKIX_PL_Object *secondObject,
andre@0:         PKIX_Int32 *pResult,
andre@0:         void *plContext)
andre@0: {
andre@0:         PKIX_PL_ByteArray *firstByteArray = NULL;
andre@0:         PKIX_PL_ByteArray *secondByteArray = NULL;
andre@0:         unsigned char *firstData = NULL;
andre@0:         unsigned char *secondData = NULL;
andre@0:         PKIX_UInt32 i;
andre@0: 
andre@0:         PKIX_ENTER(BYTEARRAY, "pkix_pl_ByteArray_Comparator");
andre@0:         PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult);
andre@0: 
andre@0:         PKIX_CHECK(pkix_CheckTypes
andre@0:                 (firstObject, secondObject, PKIX_BYTEARRAY_TYPE, plContext),
andre@0:                 PKIX_ARGUMENTSNOTBYTEARRAYS);
andre@0: 
andre@0:         /* It's safe to cast */
andre@0:         firstByteArray = (PKIX_PL_ByteArray *)firstObject;
andre@0:         secondByteArray = (PKIX_PL_ByteArray *)secondObject;
andre@0: 
andre@0:         *pResult = 0;
andre@0:         firstData = (unsigned char *)firstByteArray->array;
andre@0:         secondData = (unsigned char *)secondByteArray->array;
andre@0: 
andre@0:         if (firstByteArray->length < secondByteArray->length) {
andre@0:                 *pResult = -1;
andre@0:         } else if (firstByteArray->length > secondByteArray->length) {
andre@0:                 *pResult = 1;
andre@0:         } else if (firstByteArray->length == secondByteArray->length) {
andre@0:                 /* Check if both array contents are identical */
andre@0:                 for (i = 0;
andre@0:                     (i < firstByteArray->length) && (*pResult == 0);
andre@0:                     i++) {
andre@0:                         if (firstData[i] < secondData[i]) {
andre@0:                                 *pResult = -1;
andre@0:                         } else if (firstData[i] > secondData[i]) {
andre@0:                                 *pResult = 1;
andre@0:                         }
andre@0:                 }
andre@0:         }
andre@0: 
andre@0: cleanup:
andre@0: 
andre@0:         PKIX_RETURN(BYTEARRAY);
andre@0: }
andre@0: 
andre@0: /*
andre@0:  * FUNCTION: pkix_pl_ByteArray_ToString
andre@0:  * (see comments for PKIX_PL_ToStringCallback in pkix_pl_system.h)
andre@0:  */
andre@0: static PKIX_Error *
andre@0: pkix_pl_ByteArray_ToString(
andre@0:         PKIX_PL_Object *object,
andre@0:         PKIX_PL_String **pString,
andre@0:         void *plContext)
andre@0: {
andre@0:         PKIX_PL_ByteArray *array = NULL;
andre@0:         char *tempText = NULL;
andre@0:         char *stringText = NULL; /* "[OOO, OOO, ... OOO]" */
andre@0:         PKIX_UInt32 i, outputLen, bufferSize;
andre@0: 
andre@0:         PKIX_ENTER(BYTEARRAY, "pkix_pl_ByteArray_ToString");
andre@0:         PKIX_NULLCHECK_TWO(object, pString);
andre@0: 
andre@0:         PKIX_CHECK(pkix_CheckType(object, PKIX_BYTEARRAY_TYPE, plContext),
andre@0:                     PKIX_OBJECTNOTBYTEARRAY);
andre@0: 
andre@0:         array = (PKIX_PL_ByteArray *)object;
andre@0: 
andre@0:         if ((array->length) == 0) {
andre@0:                 PKIX_CHECK(PKIX_PL_String_Create
andre@0:                         (PKIX_ESCASCII, "[]", 0, pString, plContext),
andre@0:                         PKIX_COULDNOTCREATESTRING);
andre@0:         } else {
andre@0:                 /* Allocate space for "XXX, ". */
andre@0:                 bufferSize = 2+5*array->length;
andre@0: 
andre@0:                 /* Allocate space for format string */
andre@0:                 PKIX_CHECK(PKIX_PL_Malloc
andre@0:                         (bufferSize, (void **)&stringText, plContext),
andre@0:                         PKIX_MALLOCFAILED);
andre@0: 
andre@0:                 stringText[0] = 0;
andre@0:                 outputLen = 0;
andre@0: 
andre@0:                 PKIX_BYTEARRAY_DEBUG("\tCalling PR_smprintf).\n");
andre@0:                 tempText =
andre@0:                         PR_smprintf
andre@0:                             ("[%03u", (0x0FF&((char *)(array->array))[0]));
andre@0:                 PKIX_BYTEARRAY_DEBUG("\tCalling PL_strlen).\n");
andre@0:                 outputLen += PL_strlen(tempText);
andre@0: 
andre@0:                 PKIX_BYTEARRAY_DEBUG("\tCalling PL_strcat).\n");
andre@0:                 stringText = PL_strcat(stringText, tempText);
andre@0: 
andre@0:                 PKIX_BYTEARRAY_DEBUG("\tCalling PR_smprintf_free).\n");
andre@0:                 PR_smprintf_free(tempText);
andre@0: 
andre@0:                 for (i = 1; i < array->length; i++) {
andre@0:                         PKIX_BYTEARRAY_DEBUG("\tCalling PR_smprintf).\n");
andre@0:                         tempText = PR_smprintf
andre@0:                                 (", %03u",
andre@0:                                 (0x0FF&((char *)(array->array))[i]));
andre@0: 
andre@0:                         if (tempText == NULL){
andre@0:                                 PKIX_ERROR(PKIX_PRSMPRINTFFAILED);
andre@0:                         }
andre@0: 
andre@0:                         PKIX_BYTEARRAY_DEBUG("\tCalling PL_strlen).\n");
andre@0:                         outputLen += PL_strlen(tempText);
andre@0: 
andre@0:                         PKIX_BYTEARRAY_DEBUG("\tCalling PL_strcat).\n");
andre@0:                         stringText = PL_strcat(stringText, tempText);
andre@0: 
andre@0:                         PKIX_BYTEARRAY_DEBUG("\tCalling PR_smprintf_free).\n");
andre@0:                         PR_smprintf_free(tempText);
andre@0:                         tempText = NULL;
andre@0:                 }
andre@0: 
andre@0:                 stringText[outputLen++] = ']';
andre@0:                 stringText[outputLen] = 0;
andre@0: 
andre@0:                 PKIX_CHECK(PKIX_PL_String_Create
andre@0:                         (PKIX_ESCASCII, stringText, 0, pString, plContext),
andre@0:                         PKIX_STRINGCREATEFAILED);
andre@0: 
andre@0:         }
andre@0: 
andre@0: cleanup:
andre@0: 
andre@0:         PKIX_FREE(stringText);
andre@0:         PKIX_RETURN(BYTEARRAY);
andre@0: }
andre@0: 
andre@0: /*
andre@0:  * FUNCTION: pkix_pl_ByteArray_Equals
andre@0:  * (see comments for PKIX_PL_EqualsCallback in pkix_pl_system.h)
andre@0:  */
andre@0: static PKIX_Error *
andre@0: pkix_pl_ByteArray_Equals(
andre@0:         PKIX_PL_Object *first,
andre@0:         PKIX_PL_Object *second,
andre@0:         PKIX_Boolean *pResult,
andre@0:         void *plContext)
andre@0: {
andre@0:         PKIX_UInt32 secondType;
andre@0:         PKIX_Int32 cmpResult = 0;
andre@0: 
andre@0:         PKIX_ENTER(BYTEARRAY, "pkix_pl_ByteArray_Equals");
andre@0:         PKIX_NULLCHECK_THREE(first, second, pResult);
andre@0: 
andre@0:         /* Sanity check: Test that "first" is a ByteArray */
andre@0:         PKIX_CHECK(pkix_CheckType(first, PKIX_BYTEARRAY_TYPE, plContext),
andre@0:                     PKIX_FIRSTARGUMENTNOTBYTEARRAY);
andre@0: 
andre@0:         PKIX_CHECK(PKIX_PL_Object_GetType(second, &secondType, plContext),
andre@0:                     PKIX_COULDNOTGETTYPEOFSECONDARGUMENT);
andre@0: 
andre@0:         /* If types differ, then we will return false */
andre@0:         *pResult = PKIX_FALSE;
andre@0: 
andre@0:         /* Second type may not be a BA */
andre@0:         if (secondType != PKIX_BYTEARRAY_TYPE) goto cleanup;
andre@0: 
andre@0:         /* It's safe to cast here */
andre@0:         PKIX_CHECK(pkix_pl_ByteArray_Comparator
andre@0:                 (first, second, &cmpResult, plContext),
andre@0:                 PKIX_BYTEARRAYCOMPARATORFAILED);
andre@0: 
andre@0:         /* ByteArrays are equal iff Comparator Result is 0 */
andre@0:         *pResult = (cmpResult == 0);
andre@0: 
andre@0: cleanup:
andre@0: 
andre@0:         PKIX_RETURN(BYTEARRAY);
andre@0: }
andre@0: 
andre@0: /*
andre@0:  * FUNCTION: pkix_pl_ByteArray_Destroy
andre@0:  * (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)
andre@0:  */
andre@0: static PKIX_Error *
andre@0: pkix_pl_ByteArray_Destroy(
andre@0:         PKIX_PL_Object *object,
andre@0:         void *plContext)
andre@0: {
andre@0:         PKIX_PL_ByteArray *array = NULL;
andre@0: 
andre@0:         PKIX_ENTER(BYTEARRAY, "pkix_pl_ByteArray_Destroy");
andre@0:         PKIX_NULLCHECK_ONE(object);
andre@0: 
andre@0:         PKIX_CHECK(pkix_CheckType(object, PKIX_BYTEARRAY_TYPE, plContext),
andre@0:                     PKIX_OBJECTNOTBYTEARRAY);
andre@0: 
andre@0:         array = (PKIX_PL_ByteArray*)object;
andre@0: 
andre@0:         PKIX_FREE(array->array);
andre@0:         array->array = NULL;
andre@0:         array->length = 0;
andre@0: 
andre@0: cleanup:
andre@0: 
andre@0:         PKIX_RETURN(BYTEARRAY);
andre@0: }
andre@0: 
andre@0: /*
andre@0:  * FUNCTION: pkix_pl_ByteArray_Hashcode
andre@0:  * (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h)
andre@0:  */
andre@0: static PKIX_Error *
andre@0: pkix_pl_ByteArray_Hashcode(
andre@0:         PKIX_PL_Object *object,
andre@0:         PKIX_UInt32 *pHashcode,
andre@0:         void *plContext)
andre@0: {
andre@0:         PKIX_PL_ByteArray *array = NULL;
andre@0: 
andre@0:         PKIX_ENTER(BYTEARRAY, "pkix_pl_ByteArray_Hashcode");
andre@0:         PKIX_NULLCHECK_TWO(object, pHashcode);
andre@0: 
andre@0:         PKIX_CHECK(pkix_CheckType(object, PKIX_BYTEARRAY_TYPE, plContext),
andre@0:                     PKIX_OBJECTNOTBYTEARRAY);
andre@0: 
andre@0:         array = (PKIX_PL_ByteArray*)object;
andre@0: 
andre@0:         PKIX_CHECK(pkix_hash
andre@0:                 ((const unsigned char *)array->array,
andre@0:                 array->length,
andre@0:                 pHashcode,
andre@0:                 plContext),
andre@0:                 PKIX_HASHFAILED);
andre@0: 
andre@0: cleanup:
andre@0: 
andre@0:         PKIX_RETURN(BYTEARRAY);
andre@0: }
andre@0: 
andre@0: /*
andre@0:  * FUNCTION: pkix_pl_ByteArray_RegisterSelf
andre@0:  * DESCRIPTION:
andre@0:  * Registers PKIX_BYTEARRAY_TYPE and its related functions with systemClasses[]
andre@0:  * THREAD SAFETY:
andre@0:  *  Not Thread Safe - for performance and complexity reasons
andre@0:  *
andre@0:  *  Since this function is only called by PKIX_PL_Initialize, which should
andre@0:  *  only be called once, it is acceptable that this function is not
andre@0:  *  thread-safe.
andre@0:  */
andre@0: PKIX_Error *
andre@0: pkix_pl_ByteArray_RegisterSelf(void *plContext)
andre@0: {
andre@0: 
andre@0:         extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES];
andre@0:         pkix_ClassTable_Entry entry;
andre@0: 
andre@0:         PKIX_ENTER(BYTEARRAY, "pkix_pl_ByteArray_RegisterSelf");
andre@0: 
andre@0:         entry.description = "ByteArray";
andre@0:         entry.objCounter = 0;
andre@0:         entry.typeObjectSize = sizeof(PKIX_PL_ByteArray);
andre@0:         entry.destructor = pkix_pl_ByteArray_Destroy;
andre@0:         entry.equalsFunction = pkix_pl_ByteArray_Equals;
andre@0:         entry.hashcodeFunction = pkix_pl_ByteArray_Hashcode;
andre@0:         entry.toStringFunction = pkix_pl_ByteArray_ToString;
andre@0:         entry.comparator = NULL;
andre@0:         entry.duplicateFunction = pkix_duplicateImmutable;
andre@0: 
andre@0:         systemClasses[PKIX_BYTEARRAY_TYPE] = entry;
andre@0: 
andre@0:         PKIX_RETURN(BYTEARRAY);
andre@0: }
andre@0: 
andre@0: /* --Public-Functions------------------------------------------------------- */
andre@0: 
andre@0: /*
andre@0:  * FUNCTION: PKIX_PL_ByteArray_Create (see comments in pkix_pl_system.h)
andre@0:  */
andre@0: PKIX_Error *
andre@0: PKIX_PL_ByteArray_Create(
andre@0:         void *array,
andre@0:         PKIX_UInt32 length,
andre@0:         PKIX_PL_ByteArray **pByteArray,
andre@0:         void *plContext)
andre@0: {
andre@0:         PKIX_PL_ByteArray *byteArray = NULL;
andre@0: 
andre@0:         PKIX_ENTER(BYTEARRAY, "PKIX_PL_ByteArray_Create");
andre@0:         PKIX_NULLCHECK_ONE(pByteArray);
andre@0: 
andre@0:         PKIX_CHECK(PKIX_PL_Object_Alloc
andre@0:                 (PKIX_BYTEARRAY_TYPE,
andre@0:                 sizeof (PKIX_PL_ByteArray),
andre@0:                 (PKIX_PL_Object **)&byteArray,
andre@0:                 plContext),
andre@0:                 PKIX_COULDNOTCREATEOBJECTSTORAGE);
andre@0: 
andre@0:         byteArray->length = length;
andre@0:         byteArray->array = NULL;
andre@0: 
andre@0:         if (length != 0){
andre@0:                 /* Alloc space for array */
andre@0:                 PKIX_NULLCHECK_ONE(array);
andre@0: 
andre@0:                 PKIX_CHECK(PKIX_PL_Malloc
andre@0:                             (length, (void**)&(byteArray->array), plContext),
andre@0:                             PKIX_MALLOCFAILED);
andre@0: 
andre@0:                 PKIX_BYTEARRAY_DEBUG("\tCalling PORT_Memcpy).\n");
andre@0:                 (void) PORT_Memcpy(byteArray->array, array, length);
andre@0:         }
andre@0: 
andre@0:         *pByteArray = byteArray;
andre@0: 
andre@0: cleanup:
andre@0: 
andre@0:         if (PKIX_ERROR_RECEIVED){
andre@0:                 PKIX_DECREF(byteArray);
andre@0:         }
andre@0: 
andre@0:         PKIX_RETURN(BYTEARRAY);
andre@0: }
andre@0: 
andre@0: /*
andre@0:  * FUNCTION: PKIX_PL_ByteArray_GetPointer (see comments in pkix_pl_system.h)
andre@0:  */
andre@0: PKIX_Error *
andre@0: PKIX_PL_ByteArray_GetPointer(
andre@0:         PKIX_PL_ByteArray *byteArray,
andre@0:         void **pArray,
andre@0:         void *plContext)
andre@0: {
andre@0:         void *bytes = NULL;
andre@0:         PKIX_ENTER(BYTEARRAY, "PKIX_PL_ByteArray_GetPointer");
andre@0:         PKIX_NULLCHECK_TWO(byteArray, pArray);
andre@0: 
andre@0:         if (byteArray->length != 0){
andre@0:                 PKIX_CHECK(PKIX_PL_Malloc
andre@0:                             (byteArray->length, &bytes, plContext),
andre@0:                             PKIX_MALLOCFAILED);
andre@0: 
andre@0:                 PKIX_BYTEARRAY_DEBUG("\tCalling PORT_Memcpy).\n");
andre@0:                 (void) PORT_Memcpy
andre@0:                         (bytes, byteArray->array, byteArray->length);
andre@0:         }
andre@0: 
andre@0:         *pArray = bytes;
andre@0: 
andre@0: cleanup:
andre@0: 
andre@0:         if (PKIX_ERROR_RECEIVED){
andre@0:                 PKIX_FREE(bytes);
andre@0:         }
andre@0: 
andre@0:         PKIX_RETURN(BYTEARRAY);
andre@0: }
andre@0: 
andre@0: /*
andre@0:  * FUNCTION: PKIX_PL_ByteArray_GetLength (see comments in pkix_pl_system.h)
andre@0:  */
andre@0: PKIX_Error *
andre@0: PKIX_PL_ByteArray_GetLength(
andre@0:         PKIX_PL_ByteArray *byteArray,
andre@0:         PKIX_UInt32 *pLength,
andre@0:         void *plContext)
andre@0: {
andre@0:         PKIX_ENTER(BYTEARRAY, "PKIX_PL_ByteArray_GetLength");
andre@0:         PKIX_NULLCHECK_TWO(byteArray, pLength);
andre@0: 
andre@0:         *pLength = byteArray->length;
andre@0: 
andre@0:         PKIX_RETURN(BYTEARRAY);
andre@0: }