开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
utf8.c
资源名称：nss-3.1.1.tar.gz　[点击查看]
上传用户：lyxiangda
上传日期：2007-01-12
资源大小：3042k
文件大小：18k
源码类别：

CA认证

开发平台：

WINDOWS

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