security/nss/lib/base/utf8.c

   1 /* ***** BEGIN LICENSE BLOCK *****
   2  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   3  *
   4  * The contents of this file are subject to the Mozilla Public License Version
   5  * 1.1 (the "License"); you may not use this file except in compliance with
   6  * the License. You may obtain a copy of the License at
   7  * http://www.mozilla.org/MPL/
   8  *
   9  * Software distributed under the License is distributed on an "AS IS" basis,
  10  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11  * for the specific language governing rights and limitations under the
  12  * License.
  13  *
  14  * The Original Code is the Netscape security libraries.
  15  *
  16  * The Initial Developer of the Original Code is
  17  * Netscape Communications Corporation.
  18  * Portions created by the Initial Developer are Copyright (C) 1994-2000
  19  * the Initial Developer. All Rights Reserved.
  20  *
  21  * Contributor(s):
  22  *
  23  * Alternatively, the contents of this file may be used under the terms of
  24  * either the GNU General Public License Version 2 or later (the "GPL"), or
  25  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  26  * in which case the provisions of the GPL or the LGPL are applicable instead
  27  * of those above. If you wish to allow use of your version of this file only
  28  * under the terms of either the GPL or the LGPL, and not to allow others to
  29  * use your version of this file under the terms of the MPL, indicate your
  30  * decision by deleting the provisions above and replace them with the notice
  31  * and other provisions required by the GPL or the LGPL. If you do not delete
  32  * the provisions above, a recipient may use your version of this file under
  33  * the terms of any one of the MPL, the GPL or the LGPL.
  34  *
  35  * ***** END LICENSE BLOCK ***** */
  36
  37 #ifdef DEBUG
  38 static const char CVS_ID[] = "@(#) $RCSfile: utf8.c,v $ $Revision: 1.7 $ $Date: 2005/01/20 02:25:45 $";
  39 #endif /* DEBUG */
  40
  41 /*
  42  * utf8.c
  43  *
  44  * This file contains some additional utility routines required for
  45  * handling UTF8 strings.
  46  */
  47
  48 #ifndef BASE_H
  49 #include "base.h"
  50 #endif /* BASE_H */
  51
  52 #include "plstr.h"
  53
  54 /*
  55  * NOTES:
  56  *
  57  * There's an "is hex string" function in pki1/atav.c.  If we need
  58  * it in more places, pull that one out.
  59  */
  60
  61 /*
  62  * nssUTF8_CaseIgnoreMatch
  63  *
  64  * Returns true if the two UTF8-encoded strings pointed to by the
  65  * two specified NSSUTF8 pointers differ only in typcase.
  66  *
  67  * The error may be one of the following values:
  68  *  NSS_ERROR_INVALID_POINTER
  69  *
  70  * Return value:
  71  *  PR_TRUE if the strings match, ignoring case
  72  *  PR_FALSE if they don't
  73  *  PR_FALSE upon error
  74  */
  75
  76 NSS_IMPLEMENT PRBool
  77 nssUTF8_CaseIgnoreMatch
  78 (
  79   const NSSUTF8 *a,
  80   const NSSUTF8 *b,
  81   PRStatus *statusOpt
  82 )
  83 {
  84 #ifdef NSSDEBUG
  85   if( ((const NSSUTF8 *)NULL == a) ||
  86       ((const NSSUTF8 *)NULL == b) ) {
  87     nss_SetError(NSS_ERROR_INVALID_POINTER);
  88     if( (PRStatus *)NULL != statusOpt ) {
  89       *statusOpt = PR_FAILURE;
  90     }
  91     return PR_FALSE;
  92   }
  93 #endif /* NSSDEBUG */
  94
  95   if( (PRStatus *)NULL != statusOpt ) {
  96     *statusOpt = PR_SUCCESS;
  97   }
  98
  99   /*
 100    * XXX fgmr
 101    *
 102    * This is, like, so wrong!
 103    */
 104   if( 0 == PL_strcasecmp((const char *)a, (const char *)b) ) {
 105     return PR_TRUE;
 106   } else {
 107     return PR_FALSE;
 108   }
 109 }
 110
 111 /*
 112  * nssUTF8_PrintableMatch
 113  *
 114  * Returns true if the two Printable strings pointed to by the
 115  * two specified NSSUTF8 pointers match when compared with the
 116  * rules for Printable String (leading and trailing spaces are
 117  * disregarded, extents of whitespace match irregardless of length,
 118  * and case is not significant), then PR_TRUE will be returned.
 119  * Otherwise, PR_FALSE will be returned.  Upon failure, PR_FALSE
 120  * will be returned.  If the optional statusOpt argument is not
 121  * NULL, then PR_SUCCESS or PR_FAILURE will be stored in that
 122  * location.
 123  *
 124  * The error may be one of the following values:
 125  *  NSS_ERROR_INVALID_POINTER
 126  *
 127  * Return value:
 128  *  PR_TRUE if the strings match, ignoring case
 129  *  PR_FALSE if they don't
 130  *  PR_FALSE upon error
 131  */
 132
 133 NSS_IMPLEMENT PRBool
 134 nssUTF8_PrintableMatch
 135 (
 136   const NSSUTF8 *a,
 137   const NSSUTF8 *b,
 138   PRStatus *statusOpt
 139 )
 140 {
 141   PRUint8 *c;
 142   PRUint8 *d;
 143
 144 #ifdef NSSDEBUG
 145   if( ((const NSSUTF8 *)NULL == a) ||
 146       ((const NSSUTF8 *)NULL == b) ) {
 147     nss_SetError(NSS_ERROR_INVALID_POINTER);
 148     if( (PRStatus *)NULL != statusOpt ) {
 149       *statusOpt = PR_FAILURE;
 150     }
 151     return PR_FALSE;
 152   }
 153 #endif /* NSSDEBUG */
 154
 155   if( (PRStatus *)NULL != statusOpt ) {
 156     *statusOpt = PR_SUCCESS;
 157   }
 158
 159   c = (PRUint8 *)a;
 160   d = (PRUint8 *)b;
 161
 162   while( ' ' == *c ) {
 163     c++;
 164   }
 165
 166   while( ' ' == *d ) {
 167     d++;
 168   }
 169
 170   while( ('\0' != *c) && ('\0' != *d) ) {
 171     PRUint8 e, f;
 172
 173     e = *c;
 174     f = *d;
 175
 176     if( ('a' <= e) && (e <= 'z') ) {
 177       e -= ('a' - 'A');
 178     }
 179
 180     if( ('a' <= f) && (f <= 'z') ) {
 181       f -= ('a' - 'A');
 182     }
 183
 184     if( e != f ) {
 185       return PR_FALSE;
 186     }
 187
 188     c++;
 189     d++;
 190
 191     if( ' ' == *c ) {
 192       while( ' ' == *c ) {
 193         c++;
 194       }
 195       c--;
 196     }
 197
 198     if( ' ' == *d ) {
 199       while( ' ' == *d ) {
 200         d++;
 201       }
 202       d--;
 203     }
 204   }
 205
 206   while( ' ' == *c ) {
 207     c++;
 208   }
 209
 210   while( ' ' == *d ) {
 211     d++;
 212   }
 213
 214   if( *c == *d ) {
 215     /* And both '\0', btw */
 216     return PR_TRUE;
 217   } else {
 218     return PR_FALSE;
 219   }
 220 }
 221
 222 /*
 223  * nssUTF8_Duplicate
 224  *
 225  * This routine duplicates the UTF8-encoded string pointed to by the
 226  * specified NSSUTF8 pointer.  If the optional arenaOpt argument is
 227  * not null, the memory required will be obtained from that arena;
 228  * otherwise, the memory required will be obtained from the heap.
 229  * A pointer to the new string will be returned.  In case of error,
 230  * an error will be placed on the error stack and NULL will be
 231  * returned.
 232  *
 233  * The error may be one of the following values:
 234  *  NSS_ERROR_INVALID_POINTER
 235  *  NSS_ERROR_INVALID_ARENA
 236  *  NSS_ERROR_NO_MEMORY
 237  */
 238
 239 NSS_IMPLEMENT NSSUTF8 *
 240 nssUTF8_Duplicate
 241 (
 242   const NSSUTF8 *s,
 243   NSSArena *arenaOpt
 244 )
 245 {
 246   NSSUTF8 *rv;
 247   PRUint32 len;
 248
 249 #ifdef NSSDEBUG
 250   if( (const NSSUTF8 *)NULL == s ) {
 251     nss_SetError(NSS_ERROR_INVALID_POINTER);
 252     return (NSSUTF8 *)NULL;
 253   }
 254
 255   if( (NSSArena *)NULL != arenaOpt ) {
 256     if( PR_SUCCESS != nssArena_verifyPointer(arenaOpt) ) {
 257       return (NSSUTF8 *)NULL;
 258     }
 259   }
 260 #endif /* NSSDEBUG */
 261
 262   len = PL_strlen((const char *)s);
 263 #ifdef PEDANTIC
 264   if( '\0' != ((const char *)s)[ len ] ) {
 265     /* must have wrapped, e.g., too big for PRUint32 */
 266     nss_SetError(NSS_ERROR_NO_MEMORY);
 267     return (NSSUTF8 *)NULL;
 268   }
 269 #endif /* PEDANTIC */
 270   len++; /* zero termination */
 271
 272   rv = nss_ZAlloc(arenaOpt, len);
 273   if( (void *)NULL == rv ) {
 274     return (NSSUTF8 *)NULL;
 275   }
 276
 277   (void)nsslibc_memcpy(rv, s, len);
 278   return rv;
 279 }
 280
 281 /*
 282  * nssUTF8_Size
 283  *
 284  * This routine returns the length in bytes (including the terminating
 285  * null) of the UTF8-encoded string pointed to by the specified
 286  * NSSUTF8 pointer.  Zero is returned on error.
 287  *
 288  * The error may be one of the following values:
 289  *  NSS_ERROR_INVALID_POINTER
 290  *  NSS_ERROR_VALUE_TOO_LARGE
 291  *
 292  * Return value:
 293  *  0 on error
 294  *  nonzero length of the string.
 295  */
 296
 297 NSS_IMPLEMENT PRUint32
 298 nssUTF8_Size
 299 (
 300   const NSSUTF8 *s,
 301   PRStatus *statusOpt
 302 )
 303 {
 304   PRUint32 sv;
 305
 306 #ifdef NSSDEBUG
 307   if( (const NSSUTF8 *)NULL == s ) {
 308     nss_SetError(NSS_ERROR_INVALID_POINTER);
 309     if( (PRStatus *)NULL != statusOpt ) {
 310       *statusOpt = PR_FAILURE;
 311     }
 312     return 0;
 313   }
 314 #endif /* NSSDEBUG */
 315
 316   sv = PL_strlen((const char *)s) + 1;
 317 #ifdef PEDANTIC
 318   if( '\0' != ((const char *)s)[ sv-1 ] ) {
 319     /* wrapped */
 320     nss_SetError(NSS_ERROR_VALUE_TOO_LARGE);
 321     if( (PRStatus *)NULL != statusOpt ) {
 322       *statusOpt = PR_FAILURE;
 323     }
 324     return 0;
 325   }
 326 #endif /* PEDANTIC */
 327
 328   if( (PRStatus *)NULL != statusOpt ) {
 329     *statusOpt = PR_SUCCESS;
 330   }
 331
 332   return sv;
 333 }
 334
 335 /*
 336  * nssUTF8_Length
 337  *
 338  * This routine returns the length in characters (not including the
 339  * terminating null) of the UTF8-encoded string pointed to by the
 340  * specified NSSUTF8 pointer.
 341  *
 342  * The error may be one of the following values:
 343  *  NSS_ERROR_INVALID_POINTER
 344  *  NSS_ERROR_VALUE_TOO_LARGE
 345  *  NSS_ERROR_INVALID_STRING
 346  *
 347  * Return value:
 348  *  length of the string (which may be zero)
 349  *  0 on error
 350  */
 351
 352 NSS_IMPLEMENT PRUint32
 353 nssUTF8_Length
 354 (
 355   const NSSUTF8 *s,
 356   PRStatus *statusOpt
 357 )
 358 {
 359   PRUint32 l = 0;
 360   const PRUint8 *c = (const PRUint8 *)s;
 361
 362 #ifdef NSSDEBUG
 363   if( (const NSSUTF8 *)NULL == s ) {
 364     nss_SetError(NSS_ERROR_INVALID_POINTER);
 365     goto loser;
 366   }
 367 #endif /* NSSDEBUG */
 368
 369   /*
 370    * From RFC 2044:
 371    *
 372    * UCS-4 range (hex.)           UTF-8 octet sequence (binary)
 373    * 0000 0000-0000 007F   0xxxxxxx
 374    * 0000 0080-0000 07FF   110xxxxx 10xxxxxx
 375    * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx
 376    * 0001 0000-001F FFFF   11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
 377    * 0020 0000-03FF FFFF   111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
 378    * 0400 0000-7FFF FFFF   1111110x 10xxxxxx ... 10xxxxxx
 379    */
 380
 381   while( 0 != *c ) {
 382     PRUint32 incr;
 383     if( (*c & 0x80) == 0 ) {
 384       incr = 1;
 385     } else if( (*c & 0xE0) == 0xC0 ) {
 386       incr = 2;
 387     } else if( (*c & 0xF0) == 0xE0 ) {
 388       incr = 3;
 389     } else if( (*c & 0xF8) == 0xF0 ) {
 390       incr = 4;
 391     } else if( (*c & 0xFC) == 0xF8 ) {
 392       incr = 5;
 393     } else if( (*c & 0xFE) == 0xFC ) {
 394       incr = 6;
 395     } else {
 396       nss_SetError(NSS_ERROR_INVALID_STRING);
 397       goto loser;
 398     }
 399
 400     l += incr;
 401
 402 #ifdef PEDANTIC
 403     if( l < incr ) {
 404       /* Wrapped-- too big */
 405       nss_SetError(NSS_ERROR_VALUE_TOO_LARGE);
 406       goto loser;
 407     }
 408
 409     {
 410       PRUint8 *d;
 411       for( d = &c[1]; d < &c[incr]; d++ ) {
 412         if( (*d & 0xC0) != 0xF0 ) {
 413           nss_SetError(NSS_ERROR_INVALID_STRING);
 414           goto loser;
 415         }
 416       }
 417     }
 418 #endif /* PEDANTIC */
 419
 420     c += incr;
 421   }
 422
 423   if( (PRStatus *)NULL != statusOpt ) {
 424     *statusOpt = PR_SUCCESS;
 425   }
 426
 427   return l;
 428
 429  loser:
 430   if( (PRStatus *)NULL != statusOpt ) {
 431     *statusOpt = PR_FAILURE;
 432   }
 433
 434   return 0;
 435 }
 436
 437
 438 /*
 439  * nssUTF8_Create
 440  *
 441  * This routine creates a UTF8 string from a string in some other
 442  * format.  Some types of string may include embedded null characters,
 443  * so for them the length parameter must be used.  For string types
 444  * that are null-terminated, the length parameter is optional; if it
 445  * is zero, it will be ignored.  If the optional arena argument is
 446  * non-null, the memory used for the new string will be obtained from
 447  * that arena, otherwise it will be obtained from the heap.  This
 448  * routine may return NULL upon error, in which case it will have
 449  * placed an error on the error stack.
 450  *
 451  * The error may be one of the following:
 452  *  NSS_ERROR_INVALID_POINTER
 453  *  NSS_ERROR_NO_MEMORY
 454  *  NSS_ERROR_UNSUPPORTED_TYPE
 455  *
 456  * Return value:
 457  *  NULL upon error
 458  *  A non-null pointer to a new UTF8 string otherwise
 459  */
 460
 461 extern const NSSError NSS_ERROR_INTERNAL_ERROR; /* XXX fgmr */
 462
 463 NSS_IMPLEMENT NSSUTF8 *
 464 nssUTF8_Create
 465 (
 466   NSSArena *arenaOpt,
 467   nssStringType type,
 468   const void *inputString,
 469   PRUint32 size /* in bytes, not characters */
 470 )
 471 {
 472   NSSUTF8 *rv = NULL;
 473
 474 #ifdef NSSDEBUG
 475   if( (NSSArena *)NULL != arenaOpt ) {
 476     if( PR_SUCCESS != nssArena_verifyPointer(arenaOpt) ) {
 477       return (NSSUTF8 *)NULL;
 478     }
 479   }
 480
 481   if( (const void *)NULL == inputString ) {
 482     nss_SetError(NSS_ERROR_INVALID_POINTER);
 483     return (NSSUTF8 *)NULL;
 484   }
 485 #endif /* NSSDEBUG */
 486
 487   switch( type ) {
 488   case nssStringType_DirectoryString:
 489     /* This is a composite type requiring BER */
 490     nss_SetError(NSS_ERROR_UNSUPPORTED_TYPE);
 491     break;
 492   case nssStringType_TeletexString:
 493     /*
 494      * draft-ietf-pkix-ipki-part1-11 says in part:
 495      *
 496      * In addition, many legacy implementations support names encoded
 497      * in the ISO 8859-1 character set (Latin1String) but tag them as
 498      * TeletexString.  The Latin1String includes characters used in
 499      * Western European countries which are not part of the
 500      * TeletexString charcter set.  Implementations that process
 501      * TeletexString SHOULD be prepared to handle the entire ISO
 502      * 8859-1 character set.[ISO 8859-1].
 503      */
 504     nss_SetError(NSS_ERROR_INTERNAL_ERROR); /* unimplemented */
 505     break;
 506   case nssStringType_PrintableString:
 507     /*
 508      * PrintableString consists of A-Za-z0-9 ,()+,-./:=?
 509      * This is a subset of ASCII, which is a subset of UTF8.
 510      * So we can just duplicate the string over.
 511      */
 512
 513     if( 0 == size ) {
 514       rv = nssUTF8_Duplicate((const NSSUTF8 *)inputString, arenaOpt);
 515     } else {
 516       rv = nss_ZAlloc(arenaOpt, size+1);
 517       if( (NSSUTF8 *)NULL == rv ) {
 518         return (NSSUTF8 *)NULL;
 519       }
 520
 521       (void)nsslibc_memcpy(rv, inputString, size);
 522     }
 523
 524     break;
 525   case nssStringType_UniversalString:
 526     /* 4-byte unicode */
 527     nss_SetError(NSS_ERROR_INTERNAL_ERROR); /* unimplemented */
 528     break;
 529   case nssStringType_BMPString:
 530     /* Base Multilingual Plane of Unicode */
 531     nss_SetError(NSS_ERROR_INTERNAL_ERROR); /* unimplemented */
 532     break;
 533   case nssStringType_UTF8String:
 534     if( 0 == size ) {
 535       rv = nssUTF8_Duplicate((const NSSUTF8 *)inputString, arenaOpt);
 536     } else {
 537       rv = nss_ZAlloc(arenaOpt, size+1);
 538       if( (NSSUTF8 *)NULL == rv ) {
 539         return (NSSUTF8 *)NULL;
 540       }
 541
 542       (void)nsslibc_memcpy(rv, inputString, size);
 543     }
 544
 545     break;
 546   case nssStringType_PHGString:
 547     /*
 548      * PHGString is an IA5String (with case-insensitive comparisons).
 549      * IA5 is ~almost~ ascii; ascii has dollar-sign where IA5 has
 550      * currency symbol.
 551      */
 552     nss_SetError(NSS_ERROR_INTERNAL_ERROR); /* unimplemented */
 553     break;
 554   case nssStringType_GeneralString:
 555     nss_SetError(NSS_ERROR_INTERNAL_ERROR); /* unimplemented */
 556     break;
 557   default:
 558     nss_SetError(NSS_ERROR_UNSUPPORTED_TYPE);
 559     break;
 560   }
 561
 562   return rv;
 563 }
 564
 565 NSS_IMPLEMENT NSSItem *
 566 nssUTF8_GetEncoding
 567 (
 568   NSSArena *arenaOpt,
 569   NSSItem *rvOpt,
 570   nssStringType type,
 571   NSSUTF8 *string
 572 )
 573 {
 574   NSSItem *rv = (NSSItem *)NULL;
 575   PRStatus status = PR_SUCCESS;
 576
 577 #ifdef NSSDEBUG
 578   if( (NSSArena *)NULL != arenaOpt ) {
 579     if( PR_SUCCESS != nssArena_verifyPointer(arenaOpt) ) {
 580       return (NSSItem *)NULL;
 581     }
 582   }
 583
 584   if( (NSSUTF8 *)NULL == string ) {
 585     nss_SetError(NSS_ERROR_INVALID_POINTER);
 586     return (NSSItem *)NULL;
 587   }
 588 #endif /* NSSDEBUG */
 589
 590   switch( type ) {
 591   case nssStringType_DirectoryString:
 592     nss_SetError(NSS_ERROR_INTERNAL_ERROR); /* unimplemented */
 593     break;
 594   case nssStringType_TeletexString:
 595     nss_SetError(NSS_ERROR_INTERNAL_ERROR); /* unimplemented */
 596     break;
 597   case nssStringType_PrintableString:
 598     nss_SetError(NSS_ERROR_INTERNAL_ERROR); /* unimplemented */
 599     break;
 600   case nssStringType_UniversalString:
 601     nss_SetError(NSS_ERROR_INTERNAL_ERROR); /* unimplemented */
 602     break;
 603   case nssStringType_BMPString:
 604     nss_SetError(NSS_ERROR_INTERNAL_ERROR); /* unimplemented */
 605     break;
 606   case nssStringType_UTF8String:
 607     {
 608       NSSUTF8 *dup = nssUTF8_Duplicate(string, arenaOpt);
 609       if( (NSSUTF8 *)NULL == dup ) {
 610         return (NSSItem *)NULL;
 611       }
 612
 613       if( (NSSItem *)NULL == rvOpt ) {
 614         rv = nss_ZNEW(arenaOpt, NSSItem);
 615         if( (NSSItem *)NULL == rv ) {
 616           (void)nss_ZFreeIf(dup);
 617           return (NSSItem *)NULL;
 618         }
 619       } else {
 620         rv = rvOpt;
 621       }
 622
 623       rv->data = dup;
 624       dup = (NSSUTF8 *)NULL;
 625       rv->size = nssUTF8_Size(rv->data, &status);
 626       if( (0 == rv->size) && (PR_SUCCESS != status) ) {
 627         if( (NSSItem *)NULL == rvOpt ) {
 628           (void)nss_ZFreeIf(rv);
 629         }
 630         return (NSSItem *)NULL;
 631       }
 632     }
 633     break;
 634   case nssStringType_PHGString:
 635     nss_SetError(NSS_ERROR_INTERNAL_ERROR); /* unimplemented */
 636     break;
 637   default:
 638     nss_SetError(NSS_ERROR_UNSUPPORTED_TYPE);
 639     break;
 640   }
 641
 642   return rv;
 643 }
 644
 645 /*
 646  * nssUTF8_CopyIntoFixedBuffer
 647  *
 648  * This will copy a UTF8 string into a fixed-length buffer, making
 649  * sure that the all characters are valid.  Any remaining space will
 650  * be padded with the specified ASCII character, typically either
 651  * null or space.
 652  *
 653  * Blah, blah, blah.
 654  */
 655
 656 NSS_IMPLEMENT PRStatus
 657 nssUTF8_CopyIntoFixedBuffer
 658 (
 659   NSSUTF8 *string,
 660   char *buffer,
 661   PRUint32 bufferSize,
 662   char pad
 663 )
 664 {
 665   PRUint32 stringSize = 0;
 666
 667 #ifdef NSSDEBUG
 668   if( (char *)NULL == buffer ) {
 669     nss_SetError(NSS_ERROR_INVALID_POINTER);
 670     return PR_FALSE;
 671   }
 672
 673   if( 0 == bufferSize ) {
 674     nss_SetError(NSS_ERROR_INVALID_ARGUMENT);
 675     return PR_FALSE;
 676   }
 677
 678   if( (pad & 0x80) != 0x00 ) {
 679     nss_SetError(NSS_ERROR_INVALID_ARGUMENT);
 680     return PR_FALSE;
 681   }
 682 #endif /* NSSDEBUG */
 683
 684   if( (NSSUTF8 *)NULL == string ) {
 685     string = (NSSUTF8 *) "";
 686   }
 687
 688   stringSize = nssUTF8_Size(string, (PRStatus *)NULL);
 689   stringSize--; /* don't count the trailing null */
 690   if( stringSize > bufferSize ) {
 691     PRUint32 bs = bufferSize;
 692     (void)nsslibc_memcpy(buffer, string, bufferSize);
 693
 694     if( (            ((buffer[ bs-1 ] & 0x80) == 0x00)) ||
 695         ((bs > 1) && ((buffer[ bs-2 ] & 0xE0) == 0xC0)) ||
 696         ((bs > 2) && ((buffer[ bs-3 ] & 0xF0) == 0xE0)) ||
 697         ((bs > 3) && ((buffer[ bs-4 ] & 0xF8) == 0xF0)) ||
 698         ((bs > 4) && ((buffer[ bs-5 ] & 0xFC) == 0xF8)) ||
 699         ((bs > 5) && ((buffer[ bs-6 ] & 0xFE) == 0xFC)) ) {
 700       /* It fit exactly */
 701       return PR_SUCCESS;
 702     }
 703
 704     /* Too long.  We have to trim the last character */
 705     for( /*bs*/; bs != 0; bs-- ) {
 706       if( (buffer[bs-1] & 0xC0) != 0x80 ) {
 707         buffer[bs-1] = pad;
 708         break;
 709       } else {
 710         buffer[bs-1] = pad;
 711       }
 712     }
 713   } else {
 714     (void)nsslibc_memset(buffer, pad, bufferSize);
 715     (void)nsslibc_memcpy(buffer, string, stringSize);
 716   }
 717
 718   return PR_SUCCESS;
 719 }
 720
 721 /*
 722  * nssUTF8_Equal
 723  *
 724  */
 725
 726 NSS_IMPLEMENT PRBool
 727 nssUTF8_Equal
 728 (
 729   const NSSUTF8 *a,
 730   const NSSUTF8 *b,
 731   PRStatus *statusOpt
 732 )
 733 {
 734   PRUint32 la, lb;
 735
 736 #ifdef NSSDEBUG
 737   if( ((const NSSUTF8 *)NULL == a) ||
 738       ((const NSSUTF8 *)NULL == b) ) {
 739     nss_SetError(NSS_ERROR_INVALID_POINTER);
 740     if( (PRStatus *)NULL != statusOpt ) {
 741       *statusOpt = PR_FAILURE;
 742     }
 743     return PR_FALSE;
 744   }
 745 #endif /* NSSDEBUG */
 746
 747   la = nssUTF8_Size(a, statusOpt);
 748   if( 0 == la ) {
 749     return PR_FALSE;
 750   }
 751
 752   lb = nssUTF8_Size(b, statusOpt);
 753   if( 0 == lb ) {
 754     return PR_FALSE;
 755   }
 756
 757   if( la != lb ) {
 758     return PR_FALSE;
 759   }
 760
 761   return nsslibc_memequal(a, b, la, statusOpt);
 762 }