The Tor Browser / file revision

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

 /*

  * utf8.c

  *

  * This file contains some additional utility routines required for

  * handling UTF8 strings.

  */

 #ifndef BASE_H

 #include "base.h"

 #endif /* BASE_H */

 #include "plstr.h"

 /*

  * NOTES:

  *

  * There's an "is hex string" function in pki1/atav.c.  If we need

  * it in more places, pull that one out.

  */

 /*

  * nssUTF8_CaseIgnoreMatch

  * 

  * Returns true if the two UTF8-encoded strings pointed to by the 

  * two specified NSSUTF8 pointers differ only in typcase.

  *

  * The error may be one of the following values:

  *  NSS_ERROR_INVALID_POINTER

  *

  * Return value:

  *  PR_TRUE if the strings match, ignoring case

  *  PR_FALSE if they don't

  *  PR_FALSE upon error

  */

 NSS_IMPLEMENT PRBool

 nssUTF8_CaseIgnoreMatch

 (

   const NSSUTF8 *a,

   const NSSUTF8 *b,

   PRStatus *statusOpt

 )

 {

 #ifdef NSSDEBUG

   if( ((const NSSUTF8 *)NULL == a) ||

       ((const NSSUTF8 *)NULL == b) ) {

     nss_SetError(NSS_ERROR_INVALID_POINTER);

     if( (PRStatus *)NULL != statusOpt ) {

       *statusOpt = PR_FAILURE;

     }

     return PR_FALSE;

   }

 #endif /* NSSDEBUG */

   if( (PRStatus *)NULL != statusOpt ) {

     *statusOpt = PR_SUCCESS;

   }

   /*

    * XXX fgmr

    *

    * This is, like, so wrong!

    */

   if( 0 == PL_strcasecmp((const char *)a, (const char *)b) ) {

     return PR_TRUE;

   } else {

     return PR_FALSE;

   }

 }

 /*

  * nssUTF8_PrintableMatch

  *

  * Returns true if the two Printable strings pointed to by the 

  * two specified NSSUTF8 pointers match when compared with the 

  * rules for Printable String (leading and trailing spaces are 

  * disregarded, extents of whitespace match irregardless of length, 

  * and case is not significant), then PR_TRUE will be returned.

  * Otherwise, PR_FALSE will be returned.  Upon failure, PR_FALSE

  * will be returned.  If the optional statusOpt argument is not

  * NULL, then PR_SUCCESS or PR_FAILURE will be stored in that

  * location.

  *

  * The error may be one of the following values:

  *  NSS_ERROR_INVALID_POINTER

  *

  * Return value:

  *  PR_TRUE if the strings match, ignoring case

  *  PR_FALSE if they don't

  *  PR_FALSE upon error

  */

 NSS_IMPLEMENT PRBool

 nssUTF8_PrintableMatch

 (

   const NSSUTF8 *a,

   const NSSUTF8 *b,

   PRStatus *statusOpt

 )

 {

   PRUint8 *c;

   PRUint8 *d;

 #ifdef NSSDEBUG

   if( ((const NSSUTF8 *)NULL == a) ||

       ((const NSSUTF8 *)NULL == b) ) {

     nss_SetError(NSS_ERROR_INVALID_POINTER);

     if( (PRStatus *)NULL != statusOpt ) {

       *statusOpt = PR_FAILURE;

     }

     return PR_FALSE;

   }

 #endif /* NSSDEBUG */

   if( (PRStatus *)NULL != statusOpt ) {

     *statusOpt = PR_SUCCESS;

   }

   c = (PRUint8 *)a;

   d = (PRUint8 *)b;

   while( ' ' == *c ) {

     c++;

   }

   while( ' ' == *d ) {

     d++;

   }

   while( ('\0' != *c) && ('\0' != *d) ) {

     PRUint8 e, f;

     e = *c;

     f = *d;

     if( ('a' <= e) && (e <= 'z') ) {

       e -= ('a' - 'A');

     }

     if( ('a' <= f) && (f <= 'z') ) {

       f -= ('a' - 'A');

     }

     if( e != f ) {

       return PR_FALSE;

     }

     c++;

     d++;

     if( ' ' == *c ) {

       while( ' ' == *c ) {

         c++;

       }

       c--;

     }

     if( ' ' == *d ) {

       while( ' ' == *d ) {

         d++;

       }

       d--;

     }

   }

   while( ' ' == *c ) {

     c++;

   }

   while( ' ' == *d ) {

     d++;

   }

   if( *c == *d ) {

     /* And both '\0', btw */

     return PR_TRUE;

   } else {

     return PR_FALSE;

   }

 }

 /*

  * nssUTF8_Duplicate

  *

  * This routine duplicates the UTF8-encoded string pointed to by the

  * specified NSSUTF8 pointer.  If the optional arenaOpt argument is

  * not null, the memory required will be obtained from that arena;

  * otherwise, the memory required will be obtained from the heap.

  * A pointer to the new string will be returned.  In case of error,

  * an error will be placed on the error stack and NULL will be 

  * returned.

  *

  * The error may be one of the following values:

  *  NSS_ERROR_INVALID_POINTER

  *  NSS_ERROR_INVALID_ARENA

  *  NSS_ERROR_NO_MEMORY

  */

 NSS_IMPLEMENT NSSUTF8 *

 nssUTF8_Duplicate

 (

   const NSSUTF8 *s,

   NSSArena *arenaOpt

 )

 {

   NSSUTF8 *rv;

   PRUint32 len;

 #ifdef NSSDEBUG

   if( (const NSSUTF8 *)NULL == s ) {

     nss_SetError(NSS_ERROR_INVALID_POINTER);

     return (NSSUTF8 *)NULL;

   }

   if( (NSSArena *)NULL != arenaOpt ) {

     if( PR_SUCCESS != nssArena_verifyPointer(arenaOpt) ) {

       return (NSSUTF8 *)NULL;

     }

   }

 #endif /* NSSDEBUG */

   len = PL_strlen((const char *)s);

 #ifdef PEDANTIC

   if( '\0' != ((const char *)s)[ len ] ) {

     /* must have wrapped, e.g., too big for PRUint32 */

     nss_SetError(NSS_ERROR_NO_MEMORY);

     return (NSSUTF8 *)NULL;

   }

 #endif /* PEDANTIC */

   len++; /* zero termination */

   rv = nss_ZAlloc(arenaOpt, len);

   if( (void *)NULL == rv ) {

     return (NSSUTF8 *)NULL;

   }

   (void)nsslibc_memcpy(rv, s, len);

   return rv;

 }

 /*

  * nssUTF8_Size

  *

  * This routine returns the length in bytes (including the terminating

  * null) of the UTF8-encoded string pointed to by the specified

  * NSSUTF8 pointer.  Zero is returned on error.

  *

  * The error may be one of the following values:

  *  NSS_ERROR_INVALID_POINTER

  *  NSS_ERROR_VALUE_TOO_LARGE

  *

  * Return value:

  *  0 on error

  *  nonzero length of the string.

  */

 NSS_IMPLEMENT PRUint32

 nssUTF8_Size

 (

   const NSSUTF8 *s,

   PRStatus *statusOpt

 )

 {

   PRUint32 sv;

 #ifdef NSSDEBUG

   if( (const NSSUTF8 *)NULL == s ) {

     nss_SetError(NSS_ERROR_INVALID_POINTER);

     if( (PRStatus *)NULL != statusOpt ) {

       *statusOpt = PR_FAILURE;

     }

     return 0;

   }

 #endif /* NSSDEBUG */

   sv = PL_strlen((const char *)s) + 1;

 #ifdef PEDANTIC

   if( '\0' != ((const char *)s)[ sv-1 ] ) {

     /* wrapped */

     nss_SetError(NSS_ERROR_VALUE_TOO_LARGE);

     if( (PRStatus *)NULL != statusOpt ) {

       *statusOpt = PR_FAILURE;

     }

     return 0;

   }

 #endif /* PEDANTIC */

   if( (PRStatus *)NULL != statusOpt ) {

     *statusOpt = PR_SUCCESS;

   }

   return sv;

 }

 /*

  * nssUTF8_Length

  *

  * This routine returns the length in characters (not including the

  * terminating null) of the UTF8-encoded string pointed to by the

  * specified NSSUTF8 pointer.

  *

  * The error may be one of the following values:

  *  NSS_ERROR_INVALID_POINTER

  *  NSS_ERROR_VALUE_TOO_LARGE

  *  NSS_ERROR_INVALID_STRING

  *

  * Return value:

  *  length of the string (which may be zero)

  *  0 on error

  */

 NSS_IMPLEMENT PRUint32

 nssUTF8_Length

 (

   const NSSUTF8 *s,

   PRStatus *statusOpt

 )

 {

   PRUint32 l = 0;

   const PRUint8 *c = (const PRUint8 *)s;

 #ifdef NSSDEBUG

   if( (const NSSUTF8 *)NULL == s ) {

     nss_SetError(NSS_ERROR_INVALID_POINTER);

     goto loser;

   }

 #endif /* NSSDEBUG */

   /*

    * From RFC 2044:

    *

    * UCS-4 range (hex.)           UTF-8 octet sequence (binary)

    * 0000 0000-0000 007F   0xxxxxxx

    * 0000 0080-0000 07FF   110xxxxx 10xxxxxx

    * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx

    * 0001 0000-001F FFFF   11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

    * 0020 0000-03FF FFFF   111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx

    * 0400 0000-7FFF FFFF   1111110x 10xxxxxx ... 10xxxxxx

    */  

   while( 0 != *c ) {

     PRUint32 incr;

     if( (*c & 0x80) == 0 ) {

       incr = 1;

     } else if( (*c & 0xE0) == 0xC0 ) {

       incr = 2;

     } else if( (*c & 0xF0) == 0xE0 ) {

       incr = 3;

     } else if( (*c & 0xF8) == 0xF0 ) {

       incr = 4;

     } else if( (*c & 0xFC) == 0xF8 ) {

       incr = 5;

     } else if( (*c & 0xFE) == 0xFC ) {

       incr = 6;

     } else {

       nss_SetError(NSS_ERROR_INVALID_STRING);

       goto loser;

     }

     l += incr;

 #ifdef PEDANTIC

     if( l < incr ) {

       /* Wrapped-- too big */

       nss_SetError(NSS_ERROR_VALUE_TOO_LARGE);

       goto loser;

     }

     {

       PRUint8 *d;

       for( d = &c[1]; d < &c[incr]; d++ ) {

         if( (*d & 0xC0) != 0xF0 ) {

           nss_SetError(NSS_ERROR_INVALID_STRING);

           goto loser;

         }

       }

     }

 #endif /* PEDANTIC */

     c += incr;

   }

   if( (PRStatus *)NULL != statusOpt ) {

     *statusOpt = PR_SUCCESS;

   }

   return l;

  loser:

   if( (PRStatus *)NULL != statusOpt ) {

     *statusOpt = PR_FAILURE;

   }

   return 0;

 }

 /*

  * nssUTF8_Create

  *

  * This routine creates a UTF8 string from a string in some other

  * format.  Some types of string may include embedded null characters,

  * so for them the length parameter must be used.  For string types

  * that are null-terminated, the length parameter is optional; if it

  * is zero, it will be ignored.  If the optional arena argument is

  * non-null, the memory used for the new string will be obtained from

  * that arena, otherwise it will be obtained from the heap.  This

  * routine may return NULL upon error, in which case it will have

  * placed an error on the error stack.

  *

  * The error may be one of the following:

  *  NSS_ERROR_INVALID_POINTER

  *  NSS_ERROR_NO_MEMORY

  *  NSS_ERROR_UNSUPPORTED_TYPE

  *

  * Return value:

  *  NULL upon error

  *  A non-null pointer to a new UTF8 string otherwise

  */

 extern const NSSError NSS_ERROR_INTERNAL_ERROR; /* XXX fgmr */

 NSS_IMPLEMENT NSSUTF8 *

 nssUTF8_Create

 (

   NSSArena *arenaOpt,

   nssStringType type,

   const void *inputString,

   PRUint32 size /* in bytes, not characters */

 )

 {

   NSSUTF8 *rv = NULL;

 #ifdef NSSDEBUG

   if( (NSSArena *)NULL != arenaOpt ) {

     if( PR_SUCCESS != nssArena_verifyPointer(arenaOpt) ) {

       return (NSSUTF8 *)NULL;

     }

   }

   if( (const void *)NULL == inputString ) {

     nss_SetError(NSS_ERROR_INVALID_POINTER);

     return (NSSUTF8 *)NULL;

   }

 #endif /* NSSDEBUG */

   switch( type ) {

   case nssStringType_DirectoryString:

     /* This is a composite type requiring BER */

     nss_SetError(NSS_ERROR_UNSUPPORTED_TYPE);

     break;

   case nssStringType_TeletexString:

     /*

      * draft-ietf-pkix-ipki-part1-11 says in part:

      *

      * In addition, many legacy implementations support names encoded 

      * in the ISO 8859-1 character set (Latin1String) but tag them as 

      * TeletexString.  The Latin1String includes characters used in 

      * Western European countries which are not part of the 

      * TeletexString charcter set.  Implementations that process 

      * TeletexString SHOULD be prepared to handle the entire ISO 

      * 8859-1 character set.[ISO 8859-1].

      */

     nss_SetError(NSS_ERROR_INTERNAL_ERROR); /* unimplemented */

     break;

   case nssStringType_PrintableString:

     /*

      * PrintableString consists of A-Za-z0-9 ,()+,-./:=?

      * This is a subset of ASCII, which is a subset of UTF8.

      * So we can just duplicate the string over.

      */

     if( 0 == size ) {

       rv = nssUTF8_Duplicate((const NSSUTF8 *)inputString, arenaOpt);

     } else {

       rv = nss_ZAlloc(arenaOpt, size+1);

       if( (NSSUTF8 *)NULL == rv ) {

         return (NSSUTF8 *)NULL;

       }

       (void)nsslibc_memcpy(rv, inputString, size);

     }

     break;

   case nssStringType_UniversalString:

     /* 4-byte unicode */

     nss_SetError(NSS_ERROR_INTERNAL_ERROR); /* unimplemented */

     break;

   case nssStringType_BMPString:

     /* Base Multilingual Plane of Unicode */

     nss_SetError(NSS_ERROR_INTERNAL_ERROR); /* unimplemented */

     break;

   case nssStringType_UTF8String:

     if( 0 == size ) {

       rv = nssUTF8_Duplicate((const NSSUTF8 *)inputString, arenaOpt);

     } else {

       rv = nss_ZAlloc(arenaOpt, size+1);

       if( (NSSUTF8 *)NULL == rv ) {

         return (NSSUTF8 *)NULL;

       }

       (void)nsslibc_memcpy(rv, inputString, size);

     }

     break;

   case nssStringType_PHGString:

     /* 

      * PHGString is an IA5String (with case-insensitive comparisons).

      * IA5 is ~almost~ ascii; ascii has dollar-sign where IA5 has

      * currency symbol.

      */

     nss_SetError(NSS_ERROR_INTERNAL_ERROR); /* unimplemented */

     break;

   case nssStringType_GeneralString:

     nss_SetError(NSS_ERROR_INTERNAL_ERROR); /* unimplemented */

     break;

   default:

     nss_SetError(NSS_ERROR_UNSUPPORTED_TYPE);

     break;

   }

   return rv;

 }

 NSS_IMPLEMENT NSSItem *

 nssUTF8_GetEncoding

 (

   NSSArena *arenaOpt,

   NSSItem *rvOpt,

   nssStringType type,

   NSSUTF8 *string

 )

 {

   NSSItem *rv = (NSSItem *)NULL;

   PRStatus status = PR_SUCCESS;

 #ifdef NSSDEBUG

   if( (NSSArena *)NULL != arenaOpt ) {

     if( PR_SUCCESS != nssArena_verifyPointer(arenaOpt) ) {

       return (NSSItem *)NULL;

     }

   }

   if( (NSSUTF8 *)NULL == string ) {

     nss_SetError(NSS_ERROR_INVALID_POINTER);

     return (NSSItem *)NULL;

   }

 #endif /* NSSDEBUG */

   switch( type ) {

   case nssStringType_DirectoryString:

     nss_SetError(NSS_ERROR_INTERNAL_ERROR); /* unimplemented */

     break;

   case nssStringType_TeletexString:

     nss_SetError(NSS_ERROR_INTERNAL_ERROR); /* unimplemented */

     break;

   case nssStringType_PrintableString:

     nss_SetError(NSS_ERROR_INTERNAL_ERROR); /* unimplemented */

     break;

   case nssStringType_UniversalString:

     nss_SetError(NSS_ERROR_INTERNAL_ERROR); /* unimplemented */

     break;

   case nssStringType_BMPString:

     nss_SetError(NSS_ERROR_INTERNAL_ERROR); /* unimplemented */

     break;

   case nssStringType_UTF8String:

     {

       NSSUTF8 *dup = nssUTF8_Duplicate(string, arenaOpt);

       if( (NSSUTF8 *)NULL == dup ) {

         return (NSSItem *)NULL;

       }

       if( (NSSItem *)NULL == rvOpt ) {

         rv = nss_ZNEW(arenaOpt, NSSItem);

         if( (NSSItem *)NULL == rv ) {

           (void)nss_ZFreeIf(dup);

           return (NSSItem *)NULL;

         }

       } else {

         rv = rvOpt;

       }

       rv->data = dup;

       dup = (NSSUTF8 *)NULL;

       rv->size = nssUTF8_Size(rv->data, &status);

       if( (0 == rv->size) && (PR_SUCCESS != status) ) {

         if( (NSSItem *)NULL == rvOpt ) {

           (void)nss_ZFreeIf(rv);

         }

         return (NSSItem *)NULL;

       }

     }

     break;

   case nssStringType_PHGString:

     nss_SetError(NSS_ERROR_INTERNAL_ERROR); /* unimplemented */

     break;

   default:

     nss_SetError(NSS_ERROR_UNSUPPORTED_TYPE);

     break;

   }

   return rv;

 }

 /*

  * nssUTF8_CopyIntoFixedBuffer

  *

  * This will copy a UTF8 string into a fixed-length buffer, making 

  * sure that the all characters are valid.  Any remaining space will

  * be padded with the specified ASCII character, typically either 

  * null or space.

  *

  * Blah, blah, blah.

  */

 NSS_IMPLEMENT PRStatus

 nssUTF8_CopyIntoFixedBuffer

 (

   NSSUTF8 *string,

   char *buffer,

   PRUint32 bufferSize,

   char pad

 )

 {

   PRUint32 stringSize = 0;

 #ifdef NSSDEBUG

   if( (char *)NULL == buffer ) {

     nss_SetError(NSS_ERROR_INVALID_POINTER);

     return PR_FALSE;

   }

   if( 0 == bufferSize ) {

     nss_SetError(NSS_ERROR_INVALID_ARGUMENT);

     return PR_FALSE;

   }

   if( (pad & 0x80) != 0x00 ) {

     nss_SetError(NSS_ERROR_INVALID_ARGUMENT);

     return PR_FALSE;

   }

 #endif /* NSSDEBUG */

   if( (NSSUTF8 *)NULL == string ) {

     string = (NSSUTF8 *) "";

   }

   stringSize = nssUTF8_Size(string, (PRStatus *)NULL);

   stringSize--; /* don't count the trailing null */

   if( stringSize > bufferSize ) {

     PRUint32 bs = bufferSize;

     (void)nsslibc_memcpy(buffer, string, bufferSize);

     if( (            ((buffer[ bs-1 ] & 0x80) == 0x00)) ||

         ((bs > 1) && ((buffer[ bs-2 ] & 0xE0) == 0xC0)) ||

         ((bs > 2) && ((buffer[ bs-3 ] & 0xF0) == 0xE0)) ||

         ((bs > 3) && ((buffer[ bs-4 ] & 0xF8) == 0xF0)) ||

         ((bs > 4) && ((buffer[ bs-5 ] & 0xFC) == 0xF8)) ||

         ((bs > 5) && ((buffer[ bs-6 ] & 0xFE) == 0xFC)) ) {

       /* It fit exactly */

       return PR_SUCCESS;

     }

     /* Too long.  We have to trim the last character */

     for( /*bs*/; bs != 0; bs-- ) {

       if( (buffer[bs-1] & 0xC0) != 0x80 ) {

         buffer[bs-1] = pad;

         break;

       } else {

         buffer[bs-1] = pad;

       }

     }      

   } else {

     (void)nsslibc_memset(buffer, pad, bufferSize);

     (void)nsslibc_memcpy(buffer, string, stringSize);

   }

   return PR_SUCCESS;

 }

 /*

  * nssUTF8_Equal

  *

  */

 NSS_IMPLEMENT PRBool

 nssUTF8_Equal

 (

   const NSSUTF8 *a,

   const NSSUTF8 *b,

   PRStatus *statusOpt

 )

 {

   PRUint32 la, lb;

 #ifdef NSSDEBUG

   if( ((const NSSUTF8 *)NULL == a) ||

       ((const NSSUTF8 *)NULL == b) ) {

     nss_SetError(NSS_ERROR_INVALID_POINTER);

     if( (PRStatus *)NULL != statusOpt ) {

       *statusOpt = PR_FAILURE;

     }

     return PR_FALSE;

   }

 #endif /* NSSDEBUG */

   la = nssUTF8_Size(a, statusOpt);

   if( 0 == la ) {

     return PR_FALSE;

   }

   lb = nssUTF8_Size(b, statusOpt);

   if( 0 == lb ) {

     return PR_FALSE;

   }

   if( la != lb ) {

     return PR_FALSE;

   }

   return nsslibc_memequal(a, b, la, statusOpt);

 }