mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-08-09 06:29:02 +00:00
727 lines
16 KiB
C
727 lines
16 KiB
C
/* 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);
|
|
}
|