doc：添加有关strverscmp修复的新闻条目。

[libidn.git]/图书馆/idna。c（c）

/*idna.c——国际化域名库原型。
版权所有（C）2002-2024 Simon Josefsson

此文件是GNU Libidn的一部分。

GNU Libidn是自由软件：你可以重新发布它和/或
根据以下任一条款对其进行修改：

*由Free发布的GNU Lesser General Public License
软件基础；许可证的版本3，或（位于
您的选项）任何更高版本。

或

*由Free发布的GNU通用公共许可证
软件基础；许可证的版本2，或（位于
您的选项）任何更高版本。

或者两者并行，比如这里。

GNU Libidn的发布是为了希望它有用，
但无任何保证；甚至没有
适销性或特定用途的适用性。参见GNU
通用公共许可证了解更多详细信息。

您应该已经收到GNU通用公共许可证的副本，并且
GNU Lesser通用公共许可证以及本程序。如果
不是，请参阅<https://www.gnu.org/licenses网站/>. */

#如果定义为HAVE_CONFIG_H
#包括“config.h”
#结尾

#包括<stdlib.h>
#包括<string.h>
#包括<stringprep.h>
#包括<punycode.h>

#包括“idna.h”

/*获取c_strcasecmp。 */
#包括<c-strcase.h>

#定义DOTP（c）（（c）==0x002E||（c）==0x3002||\
（c）==0xFF0E||（c）==0xFF61）

/*核心功能*/

/**
*idna_to_ascii_4i：
*@in：带有unicode代码点的输入数组。
*@inlen：带有unicode代码点的输入数组的长度。
*@out：输出以零结尾的字符串，该字符串必须有at的空间
*至少63个字符加上终止零。
*@flags：#Idna_flags值，例如，%Idna_ALLOW_UNASSIGNED或
*%IDNA_USE_STD3_ASCII_RULES。
*
*ToASCII操作采用一系列Unicode代码点
*组成一个域标签并将其转换为一系列代码
ASCII范围内的*点（0..7F）。如果ToASCII成功
*原始序列和结果序列是等效的标签。
*
*需要注意的是，ToASCII操作可能会失败。ToASCII码
*如果任何步骤失败，则失败。如果ToASCII操作的任何步骤
*在域名的任何标签上都失败，该域名不得使用
*作为国际化域名。用这个消亡的方法
*故障取决于应用程序。
*
*ToASCII的输入是一系列代码点，即AllowUnassigned
*标志和UseSTD3ASCIIRules标志。ToASCII的输出是
*ASCII码点序列或故障条件。
*
*ToASCII从不改变ASCII中的代码点序列
*范围开始（尽管可能会失败）。应用ToASCII
*多次操作与仅应用效果完全相同
*一次。
*
*返回值：成功时返回0，或返回#Idna_rc错误代码。
*/
整数
idna_to_ascii4i（const uint32_t*in，size_t inlen，char*out，int标志）
{
size_t长度，outlen；
uint32_t*src；/*XXX不需要复制数据？ */
整数rc；

 /*
*ToASCII由以下步骤组成：
  *
*1。如果序列中的所有代码点都在ASCII范围内（0..7F）
*然后跳到步骤3。
  */

 {
大小_ i；
int-inasciirange；

inasciirange=1；
对于（i=0；i<入口；i++）
如果（in[i]>0x7F）
inasciirange=0；
if（inasciirange）
     {
src=malloc（大小（in[0]）*（入口+1））；
如果（src==NULL）
返回IDNA_MALLOC_ERROR；

memcpy（src，in，sizeof（in[0]）*入口）；
src[入口]=0；

转到步骤3；
     }
 }

/*
*2.执行[NAMEPREP]中指定的步骤，如果有则失败
*错误。[NAMEPREP]中使用了AllowUnassigned标志。
  */

 {
字符*p；

p=字符串rep_ucs4_to_utf8（in，（ssize_t）inlen，NULL，NULL）；
如果（p==空）
返回IDNA_MALLOC_ERROR；

len=斯特伦（p）；
做
     {
char*newp；

len=2*len+10；/*XXX最好猜猜？ */
newp=重新分配（p，len）；
if（newp==NULL）
{
自由（p）；
返回IDNA_MALLOC_ERROR；
         }
p=新p；

if（标志&IDNA_ALLOW_UNASSIGNED）
rc=字符串rep_nameprep（p，len）；
其他
rc=字符串rep_nameprep_no_unassigned（p，len）；
     }
同时（rc==STRINGPREP_TOO_SMALL_BUFFER）；

if（rc！=字符串PREP_OK）
     {
自由（p）；
返回IDNA_STRINGPREP_ERROR；
     }

src=字符串rep_utf8_to_ucs4（p，-1，NULL）；

自由（p）；

if（！src）
返回IDNA_MALLOC_ERROR；
}

第3步：
 /*
*3.如果设置了UseSTD3ASCIIRules标志，则执行以下检查：
  *
*（a）验证无非LDH ASCII码点；也就是说，
*缺少0..2C、2E。。2F、3A。。40、5B。。60和7B。。第7页。
  *
*（b）验证前导和尾随连字符-分钟的缺失；
*即，在开始和结束时没有U+002D
*序列。
  */

if（标志&IDNA_USE_STD3_ASCII_RULES）
{
大小_ i；

对于（i=0；src[i]；i++）
如果（src[i]<=0x2C||src[i]==0x2E||src[i]==0x2F||
（src[i]>=0x3A&&src[i]<=0x40）||
（src[i]>=0x5B&&src[i]<=0x60）||
（src[i]>=0x7B&&src[i]<=0x7F）
         {
自由（src）；
返回IDNA_CONTAINS_NON_LDH；
         }

如果（src[0]==0x002D||（i>0&&src[i-1]==x002D）
       {
自由（src）；
返回IDNA_CONTAINS_MINUS；
       }
   }

 /*
*4.如果序列中的所有代码点都在ASCII范围内
*（0..7F），然后跳到步骤8。
  */

{
大小_ i；
int-inasciirange；

inasciirange=1；
对于（i=0；src[i]；i++）
     {
如果（src[i]>0x7F）
inasciirange=0；
/*如果要跳到步骤8，请将字符串复制到输出缓冲区*/
如果（i<64）
输出[i]=src[i]；
     }
如果（i<64）
输出[i]=“\0”；
其他
     {
自由（src）；
返回IDNA_INVALID_LENGTH；
     }
if（inasciirange）
转到步骤8；
 }

 /*
*5.验证序列不是以ACE前缀开头。
  *
  */

 {
大小_ i；
int匹配；

匹配=1；
对于（i=0；匹配&&i<strlen（IDNA_ACE_PREFIX）；i++）
如果（（（uint32_t）IDNA_ACE_PREFIX[i]&0xFF）=src[i]）
匹配=0；
if（匹配）
{
自由（src）；
返回IDNA_CONTAINS_ACE_PREFIX；
     }
 }

 /*
*6.使用[PUNYCODE]中的编码算法对序列进行编码
*，如果出现错误则失败。
  */
for（len=0；src[len]；len++）
   ;
src[len]=“\0”；
outlen=63-strlen（IDNA_ACE_PREFIX）；
rc=punycode_encode（len，src，NULL，
&outlen，&out[strlen（IDNA_ACE_PREFIX）]）；
如果（rc！=PUNYCODE_SUCCESS）
{
自由（src）；
返回IDNA_PUNYCODE_ERROR；
   }
out[strlen（IDNA_ACE_PREFIX）+outlen]=“\0”；

 /*
*7.在ACE前缀之前。
  */

memcpy（输出，IDNA_ACE_PREFIX，strlen（IDNA_ACE _PREFIX））；

 /*
*8.验证代码点的数量是否在1到63之间
*包含（0除外）。
  */

第8步：
自由（src）；
if（strlen（out）<1）
返回IDNA_INVALID_LENGTH；

返回IDNA_SUCCESS；
}

/*ToUnicode（）。可能realloc（）utf8in。将无条件释放utf8in。 */
静态int
idna_to_unicode内部（字符*utf8in，
uint32_t*out，size_t*outlen，int标志）
{
整数rc；
char tmpout[64]；
size_t utf8len=字符串（utf8in）+1；
size_t addlen=0，addinc=utf8len/10+1；

 /*
*ToUnicode由以下步骤组成：
*
*1.如果序列包含ASCII范围之外的任何代码点
*（0..7F）然后继续执行步骤2，否则跳至步骤3。
  */

 {
大小_ i；
int-inasciirange；

inasciirange=1；
对于（i=0；utf8in[i]；i++）
if（utf8in[i]和~0x7F）
inasciirange=0；
if（inasciirange）
转到步骤3；
 }

 /*
*2.执行[NAMEPREP]中指定的步骤，如果存在
*错误。（如果此处也执行ToASCII的步骤3，则不会
*影响ToUnicode的整体行为，但不是
*必要。）AllowUnassigned标志用于[NAMEPREP]中。
  */
做
   {
char*newp=重新分配（utf8in，utf8len+addlen）；
if（newp==NULL）
{
自由（utf8in）；
返回IDNA_MALLOC_ERROR；
       }
utf8in=新p；
if（标志&IDNA_ALLOW_UNASSIGNED）
rc=字符串rep_nameprep（utf8in，utf8len+addlen）；
其他
rc=字符串rep_nameprep_no_unassigned（utf8in，utf8len+addlen）；
addlen+=addinc；
addinc*=2；
   }
同时（rc==STRINGPREP_TOO_SMALL_BUFFER）；

if（rc！=字符串PREP_OK）
   {
自由（utf8in）；
返回IDNA_STRINGPREP_ERROR；
   }

/*3.验证序列是否以ACE前缀开头，并保存一个
*序列的副本。
  * ...ToASCII和ToUnicode操作必须识别ACE
前缀区分大小写。
  */

第3步：
if（c_strncasemp（utf8in，IDNA_ACE_PREFIX，strlen（IDNA_ACE _PREFIX））= 0)
   {
自由（utf8in）；
返回IDNA_NO_ACE_PREFIX；
   }

/*4.删除ACE前缀。
  */

内存移动（utf8in，&utf8in[strlen（IDNA_ACE_PREFIX）]，
strlen（utf8in）-strlen（IDNA_ACE_PREFIX）+1）；

/*5.使用[PUNYCODE]中的解码算法解码序列
*如果出现错误，则失败。保存结果的副本
*此步骤。
  */

（*外）--；/*为零保留一个*/

rc=punycode_decode（字符串（utf8in），utf8in.，outlen，out，NULL）；
如果（rc！=PUNYCODE_SUCCESS）
   {
自由（utf8in）；
返回IDNA_PUNYCODE_ERROR；
   }

out[*outlen]=0；/*加零*/

/*6.应用到ASCII。
  */

rc=idna_to_ascii_4i（out，*outlen，tmpout，flags）；
如果（rc！=IDNA_SUCCESS）
   {
自由（utf8in）；
返回rc；
   }

/*7.验证步骤6的结果是否与保存的副本匹配
*步骤3，使用区分大小写的ASCII比较。
  */

if（c_strcasecmp（utf8in，tmpout+strlen（IDNA_ACE_PREFIX））= 0)
   {
自由（utf8in）；
返回IDNA_ROUNDTRIP_VERIFY_ERROR；
   }

/*8.从步骤5返回保存的副本。
  */

自由（utf8in）；
返回IDNA_SUCCESS；
}

/**
*idna_to_unicode _ 44i：
*@in：带有unicode代码点的输入数组。
*@inlen：带有unicode代码点的输入数组的长度。
*@out:带有unicode代码点的输出数组。
*@outlen：在输入时，具有unicode代码点的输出数组的最大大小，
*退出时，带有unicode代码点的输出数组的实际大小。
*@flags：#Idna_flags值，例如，%Idna_ALLOW_UNASSIGNED或
*%IDNA_USE_STD3_ASCII_RULES。
*
*ToUnicode操作采用一系列Unicode代码点
*组成一个域标签并返回Unicode序列
*代码点。如果输入序列是ACE形式的标签，则
*结果是不在ACE中的等效国际化标签
*形式，否则原始序列将原封不动地返回。
*
*ToUnicode从未失败。如果任何步骤失败，则原始输入
*序列在该步骤中立即返回。
*
*Punycode解码器输出的代码点永远不会超过它
*输入，但Nameprep可以，因此ToUnicode可以。请注意
表示代码点序列所需的八位字节数
*取决于使用的特定字符编码。
*
*ToUnicode的输入是一系列代码点
*AllowUnassigned标志和UseSTD3ASCIIRules标志。的输出
*ToUnicode始终是一系列Unicode代码点。
*
*返回值：返回#Idna_rc错误条件，但必须是
*用于调试目的。输出缓冲区始终
*保证根据
*规范（sans-malloc引起的错误）。注意！这意味着
*通常忽略此函数的返回代码，如下所示
*检查它意味着打破标准。
*/
整数
idna_to_unicode _44i（常量uint32_t*in，大小_入口，
uint32_t*out，size_t*outlen，int标志）
{
整数rc；
size_t outlensave=*outlen；
字符*p；

p=字符串rep_ucs4_to_utf8（in，（ssize_t）入口，NULL，NULL）；
如果（p==空）
返回IDNA_MALLOC_ERROR；

rc=idna_to_unicode内部（p，out，outlen，flags）；
如果（rc！=IDNA_SUCCESS）
   {
memcpy（输出、输入、大小（输入[0]）*（输入<输出保存？
入口：outlensave）；
*outlen=入口；
   }

/*p在idna_to_unicode_internal中被释放。  */

返回rc；
}

/*处理多个标签的包装纸*/

/**
*idna_to_ascii_4z：
*@input:以零结尾的输入Unicode字符串。
*@output：指向新分配的输出字符串的指针。
*@flags：#Idna_flags值，例如，%Idna_ALLOW_UNASSIGNED或
*%IDNA_USE_STD3_ASCII_RULES。
*
*将UCS-4域名转换为ASCII字符串。域名可以
*包含多个由点分隔的标签。输出缓冲区必须
*由调用方释放。
*
*返回值：成功时返回%IDNA_SUCCESS，或返回错误代码。
**/
整数
idna_to_ascii_4z（常量uint32_t*输入，字符**输出，int标志）
{
const uint32_t*开始=输入；
const uint32_t*结束；
char buf[64]；
char*out=空；
整数rc；

/*1）当点用作标签分隔符时
字符必须识别为点：U+002E（句号），
U+3002（表意全停），U+FF0E（全停），
U+FF61（半宽度象形全停）。 */

if（输入[0]==0）
{
/*处理隐式零长度根标签。 */
*输出=malloc（1）；
if（！*输出）
返回IDNA_MALLOC_ERROR；
strcpy（*输出，“”）；
返回IDNA_SUCCESS；
   }

if（DOTP（输入[0]）&&输入[1]==0）
   {
/*处理显式零长度根标签。 */
*输出=malloc（2）；
if（！*输出）
返回IDNA_MALLOC_ERROR；
strcpy（*输出，“.”）；
返回IDNA_SUCCESS；
   }

*输出=NULL；
做
   {
end=开始；

for（；*end&&！DOTP（*end）；结束++）
       ;

if（*end=='\0'&&start==end）
       {
/*处理显式零长度根标签。 */
buf[0]=“\0”；
       }
其他
       {
rc=idna_to_ascii4i（开始，（size_t）（结束-开始），buf，标志）；
如果（rc！=IDNA_SUCCESS）
           {
自由（退出）；
返回rc；
           }
       }

如果（out）
       {
size_t l=字符串（输出）+1+字符串（buf）+1；
char*newp=重新分配（out，l）；
if（！newp）
           {
自由（退出）；
返回IDNA_MALLOC_ERROR；
           }
out=newp；
strcat（out，“.”）；
strcat（out，buf）；
       }
其他
       {
输出=strdup（buf）；
if（！out）
返回IDNA_MALLOC_ERROR；
       }

开始=结束+1；
   }
while（*结束）；

*输出=输出；

返回IDNA_SUCCESS；
}

/**
*idna_to_ascii_8z：
*@input:以零结尾的输入UTF-8字符串。
*@output：指向新分配的输出字符串的指针。
*@flags：#Idna_flags值，例如，%Idna_ALLOW_UNASSIGNED或
*%IDNA_USE_STD3_ASCII_RULES。
*
*将UTF-8域名转换为ASCII字符串。域名可以
*包含多个由点分隔的标签。输出缓冲区必须
*由调用者解除分配。
*
*返回值：成功时返回%IDNA_SUCCESS，或返回错误代码。
**/
整数
idna_to_ascii8z（const char*输入，char**输出，int标志）
{
uint32_t*ucs4；
size_t ucs4len；
整数rc；

ucs4=字符串rep_utf8_to_ucs4（输入，-1，&ucs4len）；
如果（！ucs4）
返回IDNA_ICONV_ERROR；

rc=idna_to_ascii4z（ucs4，输出，标志）；

自由（ucs4）；

返回rc；

}

/**
*idna_to_ascii_lz：
*@input:在当前语言环境中编码的以零结尾的输入字符串
*字符集。
*@output：指向新分配的输出字符串的指针。
*@flags：#Idna_flags值，例如，%Idna_ALLOW_UNASSIGNED或
*%IDNA_USE_STD3_ASCII_RULES。
*
*将区域设置编码中的域名转换为ASCII字符串
*域名可能包含多个标签，由点分隔。  The
*输出缓冲区必须由调用方释放。
*
*返回值：成功时返回%IDNA_SUCCESS，或返回错误代码。
**/
整数
idna_to_ascii_lz（const char*输入，char**输出，int标志）
{
字符*utf8；
整数rc；

utf8=字符串rep_locale_to_utf8（输入）；
如果（！utf8）
返回IDNA_ICONV_ERROR；

rc=idna_to_ascii8z（utf8，输出，标志）；

自由（utf8）；

返回rc；
}

/**
*idna_to_unicode _4z4z：
*@input:以零结尾的Unicode字符串。
*@output：指向新分配的输出Unicode字符串的指针。
*@flags:#Idna_flags值，例如%Idna_ALLOW_UNASSIGNED或
*%IDNA_USE_STD3_ASCII_RULES。
*
*将UCS-4格式的可能ACE编码域名转换为
*UCS-4字符串。域名可能包含多个标签，
*由点分隔。输出缓冲区必须由
*来电者。
*
*返回值：成功返回%IDNA_SUCCESS，或返回错误代码。
**/
整数
idna_to_unicode 4z4z（const uint32_t*输入，uint32-t**输出，int标志）
{
const uint32_t*开始=输入；
const uint32_t*结束；
uint32_t*buf；
size_t buflen；
uint32_t*out=空；
size_t outlen=0；

*输出=NULL；

做
{
end=开始；

for（；*end&&！DOTP（*end）；结束++）
       ;

buflen=（size_t）（结束-开始）；
buf=malloc（大小（buf[0]）*（buflen+1））；
if（！buf）
       {
自由（退出）；
返回IDNA_MALLOC_ERROR；
       }

/*不要按照规范检查返回代码！ */
idna_to_unicode _44i（开始，（size_t）（结束-开始），
buf，&buflen，flags）；

if（输出）
       {
uint32_t*newp=重新分配（out，
大小（出[0]）
*（outlen+1+buflen+1）；
if（！newp）
           {
自由（buf）；
自由（退出）；
返回IDNA_MALLOC_ERROR；
}
out=newp；
out[outlen++]=0x002E；       /* '.'（完全停止）*/
memcpy（out+outlen，buf，sizeof（buf[0]）*buflen）；
outlen+=buflen；
out[outlen]=0x0；
自由（buf）；
       }
其他
{
输出=buf；
outlen=buflen；
out[outlen]=0x0；
       }

开始=结束+1；
   }
while（*结束）；

*输出=输出；

返回IDNA_SUCCESS；
}

/**
*idna_to_unicode _8z4z：
*@input:以零结尾的UTF-8字符串。
*@output：指向新分配的输出Unicode字符串的指针。
*@flags：#Idna_flags值，例如，%Idna_ALLOW_UNASSIGNED或
*%IDNA_USE_STD3_ASCII_RULES。
*
*将UTF-8格式的可能ACE编码域名转换为
*UCS-4字符串。域名可能包含多个标签，
*由点分隔。输出缓冲区必须由
*来电者。
*
*返回值：成功时返回%IDNA_SUCCESS，或返回错误代码。
**/
整数
idna_to_unicode 8z4z（const字符*输入，uint32_t**输出，int标志）
{
uint32_t*ucs4；
size_t ucs4len；
整数rc；

ucs4=字符串rep_utf8_to_ucs4（输入，-1，&ucs4len）；
如果（！ucs4）
返回IDNA_ICONV_ERROR；

rc=idna_to_unicode 4z4z（ucs4，输出，标志）；
自由（ucs4）；

返回rc；
}

/**
*idna_to_unicode _8z8z：
*@input:以零结尾的UTF-8字符串。
*@output：指向新分配的输出UTF-8字符串的指针。
*@flags：#Idna_flags值，例如，%Idna_ALLOW_UNASSIGNED或
*%IDNA_USE_STD3_ASCII_RULES。
*
*将UTF-8格式的可能ACE编码域名转换为
*UTF-8字符串。域名可能包含多个标签，
*由点分隔。输出缓冲区必须由
*来电者。
*
*返回值：成功时返回%IDNA_SUCCESS，或返回错误代码。
**/
整数
idna_to_unicode 8z8z（const char*输入，char**输出，int标志）
{
uint32_t*ucs4；
整数rc；

rc=idna_to_unicode 8z4z（输入，&ucs4，标志）；
如果（rc！=IDNA_SUCCESS）
返回rc；

*输出=字符串rep_ucs4_to_utf8（ucs4，-1，NULL，NULL）；
自由（ucs4）；

if（！*输出）
返回IDNA_ICONV_ERROR；

返回IDNA_SUCCESS；
}

/**
*idna_to_unicode_8zlz：
*@input:以零结尾的UTF-8字符串。
*@output:指向编码在
*当前区域设置的字符集。
*@flags：#Idna_flags值，例如，%Idna_ALLOW_UNASSIGNED或
*%IDNA_USE_STD3_ASCII_RULES。
*
*将UTF-8格式的可能ACE编码域名转换为
*在当前区域设置的字符集中编码的字符串。域
*名称可能包含多个标签，由点分隔。输出
*缓冲区必须由调用方释放。
*
*返回值：成功时返回%IDNA_SUCCESS，或返回错误代码。
**/
整数
idna_to_unicode 8zlz（const char*输入，char**输出，int标志）
{
字符*utf8；
整数rc；

rc=idna_to_unicode 8z8z（输入，&utf8，标志）；
如果（rc！=IDNA_SUCCESS）
返回rc；

*输出=字符串rep_utf8_to_locale（utf8）；
自由（utf8）；

if（！*输出）
返回IDNA_ICONV_ERROR；

返回IDNA_SUCCESS；
}

/**
*idna_to_unicode _ lzlz：
*@input:在当前语言环境中编码的以零结尾的字符串
*字符集。
*@output:指向编码在
*当前区域设置的字符集。
*@flags：#Idna_flags值，例如，%Idna_ALLOW_UNASSIGNED或
*%IDNA_USE_STD3_ASCII_RULES。
*
*转换可能使用区域设置字符的ACE编码域名
*设置为在当前语言环境的字符集中编码的字符串。
*域名可能包含多个标签，由点分隔。  The
*输出缓冲区必须由调用方释放。
*
*返回值：成功返回%IDNA_SUCCESS，或返回错误代码。
**/
整数
idna_to_unicode _lzlz（const char*输入，char**输出，int标志）
{
字符*utf8；
整数rc；

utf8=字符串rep_locale_to_utf8（输入）；
如果（！utf8）
返回IDNA_ICONV_ERROR；

rc=idna_to_unicode 8zlz（utf8，输出，标志）；
自由（utf8）；

返回rc；
}

/**
*IDNA_ACE_PREFIX
*
*IANA分配的用于IDNA的前缀。“xn--”
*/

/**
*标识（_R）：
*@IDNA_SUCCESS：操作成功。此值保证为
*始终为零，其余的只能保证保持不变
*非零值，用于逻辑比较。
*@IDNA_STRINGPREP_ERROR:字符串准备期间出错。
*@IDNA_PUNYCODE_ERROR：PUNYCODE操作期间出错。
*@IDNA_CONTAINS_NON_LDH：对于IDNA_USE_STD3_ASCII_RULES，表示
*字符串包含非LDH ASCII字符。
*@IDNA_CONTAINS_LDH：与@IDNA_CONTAINS-NON_LDH相同，以实现兼容性
*早期版本中有打字错误。
*@IDNA_CONTAINS_MINUS：对于IDNA_USE_STD3_ASCII_RULES，表示
*字符串包含前导或尾随连字符-分钟（U+002D）。
*@IDNA_INVALID_LENGTH：最终输出字符串不在
*（含）1到63个字符。
*@IDNA_NO_ACE_PREFIX:字符串不包含ACE前缀
*（用于ToUnicode）。
*@IDNA_ROUNDTRIP_VERIFY_ERROR：输出上的ToASCII操作
*string不等于输入。
*@IDNA_CONTAINS_ACE_PREFIX：输入包含ACE前缀（用于
*ToASCII）。
*@IDNA_ICONV_ERROR：字符编码转换错误。
*@IDNA_MALLOC_ERROR:无法分配缓冲区（这通常是
*致命错误）。
*@IDNA_DLOPEN_ERROR:无法DLOPEN libcidn DSO（仅使用
*libc内部）。
*
*idna_to_ascii_4i（）的枚举返回码，
*idna_to_unicode_44i（）函数（以及从这些函数派生的函数
*功能）。保证值0始终与
*成功。
*/


/**
*Idna_flags（标识_标志）：
*@IDNA_ALLOW_UNASSIGNED:不要拒绝包含未分配的字符串
*Unicode代码点。
*@IDNA_USE_STD3_ASCII_RULES：根据STD3验证字符串
*规则（即普通主机名规则）。
*
*传递给idna_to_ascii_4i（）、idna_toSunicode_44i（）等的标志。
*/