/* 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 3629:
*
* UTF8-octets = *( UTF8-char )
* UTF8-char = UTF8-1 / UTF8-2 / UTF8-3 / UTF8-4
* UTF8-1 = %x00-7F
* UTF8-2 = %xC2-DF UTF8-tail
* UTF8-3 = %xE0 %xA0-BF UTF8-tail / %xE1-EC 2( UTF8-tail ) /
* %xED %x80-9F UTF8-tail / %xEE-EF 2( UTF8-tail )
* UTF8-4 = %xF0 %x90-BF 2( UTF8-tail ) / %xF1-F3 3( UTF8-tail ) /
* %xF4 %x80-8F 2( UTF8-tail )
* UTF8-tail = %x80-BF
*/
while (0 != *c) {
PRUint32 incr;
if (*c < 0x80) {
incr = 1;
}
else if (*c < 0xC2) {
nss_SetError(NSS_ERROR_INVALID_STRING);
goto loser;
}
else if (*c < 0xE0) {
incr = 2;
}
else if (*c == 0xE0) {
if (c[1] < 0xA0) {
nss_SetError(NSS_ERROR_INVALID_STRING);
goto loser;
}
incr = 3;
}
else if (*c < 0xF0) {
if (*c == 0xED && c[1] > 0x9F) {
nss_SetError(NSS_ERROR_INVALID_STRING);
goto loser;
}
incr = 3;
}
else if (*c == 0xF0) {
if (c[1] < 0x90) {
nss_SetError(NSS_ERROR_INVALID_STRING);
goto loser;
}
incr = 4;
}
else if (*c < 0xF4) {
incr = 4;
}
else if (*c == 0xF4) {
if (c[1] > 0x8F) {
nss_SetError(NSS_ERROR_INVALID_STRING);
goto loser;
}
incr = 4;
}
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;
}
#endif /* PEDANTIC */
{
const PRUint8 *d;
for (d = &c[1]; d < &c[incr]; d++) {
if ((*d & 0xC0) != 0x80) {
nss_SetError(NSS_ERROR_INVALID_STRING);
goto loser;
}
}
}
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);
}
