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

/*

 * pkix_common.c

 *

 * Common utility functions used by various PKIX_PL functions

 *

 */

#include "pkix_pl_common.h"

/* --Private-Functions-------------------------------------------- */

/*

 * FUNCTION: pkix_LockObject

 * DESCRIPTION:

 *

 *  Locks the object pointed to by "object".

 *

 * PARAMETERS:

 *  "object"

 *      Address of object. 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_LockObject(

        PKIX_PL_Object *object,

        void *plContext)

{

        PKIX_PL_Object *objectHeader;

        PKIX_ENTER(OBJECT, "pkix_LockObject");

        PKIX_NULLCHECK_ONE(object);

        if (object == (PKIX_PL_Object *)PKIX_ALLOC_ERROR()) {

                goto cleanup;

        }

        PKIX_OBJECT_DEBUG("\tShifting object pointer).\n");

        /* The header is sizeof(PKIX_PL_Object) before the object pointer */

        objectHeader = object-1;

        PKIX_OBJECT_DEBUG("\tCalling PR_Lock).\n");

        PR_Lock(objectHeader->lock);

cleanup:

        PKIX_RETURN(OBJECT);

}

/*

 * FUNCTION: pkix_UnlockObject

 * DESCRIPTION:

 *

 *  Unlocks the object pointed to by "object".

 *

 * PARAMETERS:

 *  "object"

 *      Address of Object. 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_UnlockObject(

        PKIX_PL_Object *object,

        void *plContext)

{

        PKIX_PL_Object *objectHeader;

        PRStatus result;

        PKIX_ENTER(OBJECT, "pkix_UnlockObject");

        PKIX_NULLCHECK_ONE(object);

        if (object == (PKIX_PL_Object *)PKIX_ALLOC_ERROR()) {

                goto cleanup;

        }

        PKIX_OBJECT_DEBUG("\tShifting object pointer).\n");

        /* The header is sizeof(PKIX_PL_Object) before the object pointer */

        objectHeader = object-1;

        PKIX_OBJECT_DEBUG("\tCalling PR_Unlock).\n");

        result = PR_Unlock(objectHeader->lock);

        if (result == PR_FAILURE) {

                PKIX_OBJECT_DEBUG("\tPR_Unlock failed.).\n");

                PKIX_ERROR_FATAL(PKIX_ERRORUNLOCKINGOBJECT);

        }

cleanup:

        PKIX_RETURN(OBJECT);

}

/*

 * FUNCTION: pkix_pl_UInt32_Overflows

 * DESCRIPTION:

 *

 *  Returns a PKIX_Boolean indicating whether the unsigned integer

 *  represented by "string" is too large to fit in 32-bits (i.e.

 *  whether it overflows). With the exception of the string "0",

 *  all other strings are stripped of any leading zeros. It is assumed

 *  that every character in "string" is from the set {'0' - '9'}.

 *

 * PARAMETERS

 *  "string"

 *      Address of array of bytes representing PKIX_UInt32 that's being tested

 *      for 32-bit overflow

 * THREAD SAFETY:

 *  Thread Safe (see Thread Safety Definitions in Programmer's Guide)

 * RETURNS:

 *  PKIX_TRUE if PKIX_UInt32 represented by "string" overflows;

 *  PKIX_FALSE otherwise

 */

PKIX_Boolean

pkix_pl_UInt32_Overflows(char *string){

        char *firstNonZero = NULL;

        PKIX_UInt32 length, i;

        char *MAX_UINT32_STRING = "4294967295";

        PKIX_DEBUG_ENTER(OID);

        PKIX_OID_DEBUG("\tCalling PL_strlen).\n");

        length = PL_strlen(string);

        if (length < MAX_DIGITS_32){

                return (PKIX_FALSE);

        }

        firstNonZero = string;

        for (i = 0; i < length; i++){

                if (*string == '0'){

                        firstNonZero++;

                }

        }

        PKIX_OID_DEBUG("\tCalling PL_strlen).\n");

        length = PL_strlen(firstNonZero);

        if (length > MAX_DIGITS_32){

                return (PKIX_TRUE);

        }

        PKIX_OID_DEBUG("\tCalling PL_strlen).\n");

        if (length == MAX_DIGITS_32){

                PKIX_OID_DEBUG("\tCalling PORT_Strcmp).\n");

                if (PORT_Strcmp(firstNonZero, MAX_UINT32_STRING) > 0){

                        return (PKIX_TRUE);

                }

        }

        return (PKIX_FALSE);

}

/*

 * FUNCTION: pkix_pl_getOIDToken

 * DESCRIPTION:

 *

 *  Takes the array of DER-encoded bytes pointed to by "derBytes"

 *  (representing an OID) and the value of "index" representing the index into

 *  the array, and decodes the bytes until an integer token is retrieved. If

 *  successful, this function stores the integer component at "pToken" and

 *  stores the index representing the next byte in the array at "pIndex"

 *  (following the last byte that was used in the decoding). This new output

 *  index can be used in subsequent calls as an input index, allowing each

 *  token of the OID to be retrieved consecutively. Note that there is a

 *  special case for the first byte, in that it encodes two separate integer

 *  tokens. For example, the byte {2a} represents the integer tokens {1,2}.

 *  This special case is not handled here and must be handled by the caller.

 *

 * PARAMETERS

 *  "derBytes"

 *      Address of array of bytes representing a DER-encoded OID.

 *      Must be non-NULL.

 *  "index"

 *      Index into the array that this function will begin decoding at.

 *  "pToken"

 *      Destination for decoded OID token. Must be non-NULL.

 *  "pIndex"

 *      Destination for index of next byte following last byte used.

 *      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.

 */

static PKIX_Error *

pkix_pl_getOIDToken(

        char *derBytes,

        PKIX_UInt32 index,

        PKIX_UInt32 *pToken,

        PKIX_UInt32 *pIndex,

        void *plContext)

{

        PKIX_UInt32 retval, i, tmp;

        PKIX_ENTER(OID, "pkix_pl_getOIDToken");

        PKIX_NULLCHECK_THREE(derBytes, pToken, pIndex);

        /*

         * We should only need to parse a maximum of four bytes, because

         * RFC 3280 "mandates support for OIDs which have arc elements

         * with values that are less than 2^28, that is, they MUST be between

         * 0 and 268,435,455, inclusive.  This allows each arc element to be

         * represented within a single 32 bit word."

         */

        for (i = 0, retval = 0; i < 4; i++) {

            retval <<= 7;

            tmp = derBytes[index];

            index++;

            retval |= (tmp & 0x07f);

            if ((tmp & 0x080) == 0){

                    *pToken = retval;

                    *pIndex = index;

                    goto cleanup;

            }

        }

        PKIX_ERROR(PKIX_INVALIDENCODINGOIDTOKENVALUETOOBIG);

cleanup:

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