dlls/ntdll/locale.c

   1 /*
   2  * Locale functions
   3  *
   4  * Copyright 2004, 2019 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define NONAMELESSUNION
  22
  23 #include <stdarg.h>
  24 #include <string.h>
  25 #include <stdlib.h>
  26
  27 #include "ntstatus.h"
  28 #define WIN32_NO_STATUS
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "winnls.h"
  32 #include "ntdll_misc.h"
  33 #include "locale_private.h"
  34 #include "wine/debug.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(nls);
  37
  38 UINT NlsAnsiCodePage = 0;
  39 BYTE NlsMbCodePageTag = 0;
  40 BYTE NlsMbOemCodePageTag = 0;
  41
  42 static const WCHAR *locale_strings;
  43 static NLSTABLEINFO nls_info = { { CP_UTF8 }, { CP_UTF8 } };
  44 static struct norm_table *norm_tables[16];
  45 static const NLS_LOCALE_LCID_INDEX *lcids_index;
  46 static const NLS_LOCALE_LCNAME_INDEX *lcnames_index;
  47 static const NLS_LOCALE_HEADER *locale_table;
  48
  49
  50 static WCHAR casemap( USHORT *table, WCHAR ch )
  51 {
  52     return ch + table[table[table[ch >> 8] + ((ch >> 4) & 0x0f)] + (ch & 0x0f)];
  53 }
  54
  55
  56 static WCHAR casemap_ascii( WCHAR ch )
  57 {
  58     if (ch >= 'a' && ch <= 'z') ch -= 'a' - 'A';
  59     return ch;
  60 }
  61
  62
  63 static NTSTATUS load_norm_table( ULONG form, const struct norm_table **info )
  64 {
  65     unsigned int i;
  66     USHORT *data, *tables;
  67     SIZE_T size;
  68     NTSTATUS status;
  69
  70     if (!form) return STATUS_INVALID_PARAMETER;
  71     if (form >= ARRAY_SIZE(norm_tables)) return STATUS_OBJECT_NAME_NOT_FOUND;
  72
  73     if (!norm_tables[form])
  74     {
  75         if ((status = NtGetNlsSectionPtr( NLS_SECTION_NORMALIZE, form, NULL, (void **)&data, &size )))
  76             return status;
  77
  78         /* sanity checks */
  79
  80         if (size <= 0x44) goto invalid;
  81         if (data[0x14] != form) goto invalid;
  82         tables = data + 0x1a;
  83         for (i = 0; i < 8; i++)
  84         {
  85             if (tables[i] > size / sizeof(USHORT)) goto invalid;
  86             if (i && tables[i] < tables[i-1]) goto invalid;
  87         }
  88
  89         if (InterlockedCompareExchangePointer( (void **)&norm_tables[form], data, NULL ))
  90             NtUnmapViewOfSection( GetCurrentProcess(), data );
  91     }
  92     *info = norm_tables[form];
  93     return STATUS_SUCCESS;
  94
  95 invalid:
  96     NtUnmapViewOfSection( GetCurrentProcess(), data );
  97     return STATUS_INVALID_PARAMETER;
  98 }
  99
 100
 101 static int compare_locale_names( const WCHAR *n1, const WCHAR *n2 )
 102 {
 103     for (;;)
 104     {
 105         WCHAR ch1 = casemap_ascii( *n1++ );
 106         WCHAR ch2 = casemap_ascii( *n2++ );
 107         if (ch1 == '_') ch1 = '-';
 108         if (ch2 == '_') ch2 = '-';
 109         if (!ch1 || ch1 != ch2) return ch1 - ch2;
 110     }
 111 }
 112
 113
 114 static const NLS_LOCALE_LCNAME_INDEX *find_lcname_entry( const WCHAR *name )
 115 {
 116     int min = 0, max = locale_table->nb_lcnames - 1;
 117
 118     if (!name) return NULL;
 119     while (min <= max)
 120     {
 121         int res, pos = (min + max) / 2;
 122         const WCHAR *str = locale_strings + lcnames_index[pos].name;
 123         res = compare_locale_names( name, str + 1 );
 124         if (res < 0) max = pos - 1;
 125         else if (res > 0) min = pos + 1;
 126         else return &lcnames_index[pos];
 127     }
 128     return NULL;
 129 }
 130
 131
 132 static const NLS_LOCALE_LCID_INDEX *find_lcid_entry( LCID lcid )
 133 {
 134     int min = 0, max = locale_table->nb_lcids - 1;
 135
 136     while (min <= max)
 137     {
 138         int pos = (min + max) / 2;
 139         if (lcid < lcids_index[pos].id) max = pos - 1;
 140         else if (lcid > lcids_index[pos].id) min = pos + 1;
 141         else return &lcids_index[pos];
 142     }
 143     return NULL;
 144 }
 145
 146
 147 static const NLS_LOCALE_DATA *get_locale_data( UINT idx )
 148 {
 149     ULONG offset = locale_table->locales_offset + idx * locale_table->locale_size;
 150     return (const NLS_LOCALE_DATA *)((const char *)locale_table + offset);
 151 }
 152
 153
 154 void locale_init(void)
 155 {
 156     USHORT utf8[2] = { 0, CP_UTF8 };
 157     WCHAR locale[LOCALE_NAME_MAX_LENGTH];
 158     UNICODE_STRING name, value;
 159     LARGE_INTEGER unused;
 160     SIZE_T size;
 161     LCID system_lcid, user_lcid = 0;
 162     UINT ansi_cp = 1252, oem_cp = 437;
 163     void *ansi_ptr = utf8, *oem_ptr = utf8, *case_ptr;
 164     NTSTATUS status;
 165     struct
 166     {
 167         UINT ctypes;
 168         UINT unknown1;
 169         UINT unknown2;
 170         UINT unknown3;
 171         UINT locales;
 172         UINT charmaps;
 173         UINT geoids;
 174         UINT scripts;
 175     } *header;
 176
 177     status = RtlGetLocaleFileMappingAddress( (void **)&header, &system_lcid, &unused );
 178     if (status)
 179     {
 180         ERR( "locale init failed %x\n", status );
 181         return;
 182     }
 183     locale_table = (const NLS_LOCALE_HEADER *)((char *)header + header->locales);
 184     lcids_index = (const NLS_LOCALE_LCID_INDEX *)((char *)locale_table + locale_table->lcids_offset);
 185     lcnames_index = (const NLS_LOCALE_LCNAME_INDEX *)((char *)locale_table + locale_table->lcnames_offset);
 186     locale_strings = (const WCHAR *)((char *)locale_table + locale_table->strings_offset);
 187
 188     value.Buffer = locale;
 189     value.MaximumLength = sizeof(locale);
 190     RtlInitUnicodeString( &name, L"WINEUSERLOCALE" );
 191     if (!RtlQueryEnvironmentVariable_U( NULL, &name, &value ))
 192     {
 193         const NLS_LOCALE_LCNAME_INDEX *entry = find_lcname_entry( locale );
 194         if (entry) user_lcid = get_locale_data( entry->idx )->idefaultlanguage;
 195     }
 196     if (!user_lcid) user_lcid = system_lcid;
 197     NtSetDefaultUILanguage( user_lcid );
 198     NtSetDefaultLocale( TRUE, user_lcid );
 199
 200     if (system_lcid == LOCALE_CUSTOM_UNSPECIFIED)
 201     {
 202         system_lcid = MAKELANGID( LANG_ENGLISH, SUBLANG_DEFAULT );
 203         ansi_cp = oem_cp = CP_UTF8;
 204     }
 205     else
 206     {
 207         const NLS_LOCALE_LCID_INDEX *entry = find_lcid_entry( system_lcid );
 208         ansi_cp = get_locale_data( entry->idx )->idefaultansicodepage;
 209         oem_cp = get_locale_data( entry->idx )->idefaultcodepage;
 210     }
 211
 212     NtGetNlsSectionPtr( 10, 0, NULL, &case_ptr, &size );
 213     NtCurrentTeb()->Peb->UnicodeCaseTableData = case_ptr;
 214     if (ansi_cp != CP_UTF8)
 215     {
 216         NtGetNlsSectionPtr( 11, ansi_cp, NULL, &ansi_ptr, &size );
 217         NtCurrentTeb()->Peb->AnsiCodePageData = ansi_ptr;
 218     }
 219     if (oem_cp != CP_UTF8)
 220     {
 221         NtGetNlsSectionPtr( 11, oem_cp, NULL, &oem_ptr, &size );
 222         NtCurrentTeb()->Peb->OemCodePageData = oem_ptr;
 223     }
 224     RtlInitNlsTables( ansi_ptr, oem_ptr, case_ptr, &nls_info );
 225     NlsAnsiCodePage     = nls_info.AnsiTableInfo.CodePage;
 226     NlsMbCodePageTag    = nls_info.AnsiTableInfo.DBCSCodePage;
 227     NlsMbOemCodePageTag = nls_info.OemTableInfo.DBCSCodePage;
 228 }
 229
 230
 231 static NTSTATUS get_dummy_preferred_ui_language( DWORD flags, LANGID lang, ULONG *count,
 232                                                  WCHAR *buffer, ULONG *size )
 233 {
 234     WCHAR name[LOCALE_NAME_MAX_LENGTH + 2];
 235     NTSTATUS status;
 236     ULONG len;
 237
 238     FIXME("(0x%x %p %p %p) returning a dummy value (current locale)\n", flags, count, buffer, size);
 239
 240     if (flags & MUI_LANGUAGE_ID) swprintf( name, ARRAY_SIZE(name), L"%04lX", lang );
 241     else
 242     {
 243         UNICODE_STRING str;
 244
 245         str.Buffer = name;
 246         str.MaximumLength = sizeof(name);
 247         status = RtlLcidToLocaleName( lang, &str, 0, FALSE );
 248         if (status) return status;
 249     }
 250
 251     len = wcslen( name ) + 2;
 252     name[len - 1] = 0;
 253     if (buffer)
 254     {
 255         if (len > *size)
 256         {
 257             *size = len;
 258             return STATUS_BUFFER_TOO_SMALL;
 259         }
 260         memcpy( buffer, name, len * sizeof(WCHAR) );
 261     }
 262     *size = len;
 263     *count = 1;
 264     TRACE("returned variable content: %d, \"%s\", %d\n", *count, debugstr_w(buffer), *size);
 265     return STATUS_SUCCESS;
 266
 267 }
 268
 269 /**************************************************************************
 270  *      RtlGetProcessPreferredUILanguages   (NTDLL.@)
 271  */
 272 NTSTATUS WINAPI RtlGetProcessPreferredUILanguages( DWORD flags, ULONG *count, WCHAR *buffer, ULONG *size )
 273 {
 274     LANGID ui_language;
 275
 276     FIXME( "%08x, %p, %p %p\n", flags, count, buffer, size );
 277
 278     NtQueryDefaultUILanguage( &ui_language );
 279     return get_dummy_preferred_ui_language( flags, ui_language, count, buffer, size );
 280 }
 281
 282
 283 /**************************************************************************
 284  *      RtlGetSystemPreferredUILanguages   (NTDLL.@)
 285  */
 286 NTSTATUS WINAPI RtlGetSystemPreferredUILanguages( DWORD flags, ULONG unknown, ULONG *count,
 287                                                   WCHAR *buffer, ULONG *size )
 288 {
 289     LANGID ui_language;
 290
 291     if (flags & ~(MUI_LANGUAGE_NAME | MUI_LANGUAGE_ID | MUI_MACHINE_LANGUAGE_SETTINGS)) return STATUS_INVALID_PARAMETER;
 292     if ((flags & MUI_LANGUAGE_NAME) && (flags & MUI_LANGUAGE_ID)) return STATUS_INVALID_PARAMETER;
 293     if (*size && !buffer) return STATUS_INVALID_PARAMETER;
 294
 295     NtQueryInstallUILanguage( &ui_language );
 296     return get_dummy_preferred_ui_language( flags, ui_language, count, buffer, size );
 297 }
 298
 299
 300 /**************************************************************************
 301  *      RtlGetThreadPreferredUILanguages   (NTDLL.@)
 302  */
 303 NTSTATUS WINAPI RtlGetThreadPreferredUILanguages( DWORD flags, ULONG *count, WCHAR *buffer, ULONG *size )
 304 {
 305     LANGID ui_language;
 306
 307     FIXME( "%08x, %p, %p %p\n", flags, count, buffer, size );
 308
 309     NtQueryDefaultUILanguage( &ui_language );
 310     return get_dummy_preferred_ui_language( flags, ui_language, count, buffer, size );
 311 }
 312
 313
 314 /**************************************************************************
 315  *      RtlGetUserPreferredUILanguages   (NTDLL.@)
 316  */
 317 NTSTATUS WINAPI RtlGetUserPreferredUILanguages( DWORD flags, ULONG unknown, ULONG *count,
 318                                                 WCHAR *buffer, ULONG *size )
 319 {
 320     LANGID ui_language;
 321
 322     if (flags & ~(MUI_LANGUAGE_NAME | MUI_LANGUAGE_ID)) return STATUS_INVALID_PARAMETER;
 323     if ((flags & MUI_LANGUAGE_NAME) && (flags & MUI_LANGUAGE_ID)) return STATUS_INVALID_PARAMETER;
 324     if (*size && !buffer) return STATUS_INVALID_PARAMETER;
 325
 326     NtQueryDefaultUILanguage( &ui_language );
 327     return get_dummy_preferred_ui_language( flags, ui_language, count, buffer, size );
 328 }
 329
 330
 331 /**************************************************************************
 332  *      RtlSetProcessPreferredUILanguages   (NTDLL.@)
 333  */
 334 NTSTATUS WINAPI RtlSetProcessPreferredUILanguages( DWORD flags, PCZZWSTR buffer, ULONG *count )
 335 {
 336     FIXME( "%u, %p, %p\n", flags, buffer, count );
 337     return STATUS_SUCCESS;
 338 }
 339
 340
 341 /**************************************************************************
 342  *      RtlSetThreadPreferredUILanguages   (NTDLL.@)
 343  */
 344 NTSTATUS WINAPI RtlSetThreadPreferredUILanguages( DWORD flags, PCZZWSTR buffer, ULONG *count )
 345 {
 346     FIXME( "%u, %p, %p\n", flags, buffer, count );
 347     return STATUS_SUCCESS;
 348 }
 349
 350
 351 /******************************************************************
 352  *      RtlInitCodePageTable   (NTDLL.@)
 353  */
 354 void WINAPI RtlInitCodePageTable( USHORT *ptr, CPTABLEINFO *info )
 355 {
 356     static const CPTABLEINFO utf8_cpinfo = { CP_UTF8, 4, '?', 0xfffd, '?', '?' };
 357
 358     if (ptr[1] == CP_UTF8) *info = utf8_cpinfo;
 359     else init_codepage_table( ptr, info );
 360 }
 361
 362
 363 /**************************************************************************
 364  *      RtlInitNlsTables   (NTDLL.@)
 365  */
 366 void WINAPI RtlInitNlsTables( USHORT *ansi, USHORT *oem, USHORT *casetable, NLSTABLEINFO *info )
 367 {
 368     RtlInitCodePageTable( ansi, &info->AnsiTableInfo );
 369     RtlInitCodePageTable( oem, &info->OemTableInfo );
 370     info->UpperCaseTable = casetable + 2;
 371     info->LowerCaseTable = casetable + casetable[1] + 2;
 372 }
 373
 374
 375 /**************************************************************************
 376  *      RtlResetRtlTranslations   (NTDLL.@)
 377  */
 378 void WINAPI RtlResetRtlTranslations( const NLSTABLEINFO *info )
 379 {
 380     NlsAnsiCodePage     = info->AnsiTableInfo.CodePage;
 381     NlsMbCodePageTag    = info->AnsiTableInfo.DBCSCodePage;
 382     NlsMbOemCodePageTag = info->OemTableInfo.DBCSCodePage;
 383     nls_info = *info;
 384 }
 385
 386
 387 /**************************************************************************
 388  *      RtlGetLocaleFileMappingAddress   (NTDLL.@)
 389  */
 390 NTSTATUS WINAPI RtlGetLocaleFileMappingAddress( void **ptr, LCID *lcid, LARGE_INTEGER *size )
 391 {
 392     static void *cached_ptr;
 393     static LCID cached_lcid;
 394
 395     if (!cached_ptr)
 396     {
 397         void *addr;
 398         NTSTATUS status = NtInitializeNlsFiles( &addr, &cached_lcid, size );
 399
 400         if (status) return status;
 401         if (InterlockedCompareExchangePointer( &cached_ptr, addr, NULL ))
 402             NtUnmapViewOfSection( GetCurrentProcess(), addr );
 403     }
 404     *ptr = cached_ptr;
 405     *lcid = cached_lcid;
 406     return STATUS_SUCCESS;
 407 }
 408
 409
 410 /**************************************************************************
 411  *      RtlAnsiCharToUnicodeChar   (NTDLL.@)
 412  */
 413 WCHAR WINAPI RtlAnsiCharToUnicodeChar( char **ansi )
 414 {
 415     unsigned char ch = *(*ansi)++;
 416
 417     if (nls_info.AnsiTableInfo.CodePage == CP_UTF8)
 418     {
 419         unsigned int res;
 420
 421         if (ch < 0x80) return ch;
 422         if ((res = decode_utf8_char( ch, (const char **)ansi, *ansi + 3 )) > 0x10ffff) res = 0xfffd;
 423         return res;
 424     }
 425     if (nls_info.AnsiTableInfo.DBCSOffsets)
 426     {
 427         USHORT off = nls_info.AnsiTableInfo.DBCSOffsets[ch];
 428         if (off) return nls_info.AnsiTableInfo.DBCSOffsets[off + (unsigned char)*(*ansi)++];
 429     }
 430     return nls_info.AnsiTableInfo.MultiByteTable[ch];
 431 }
 432
 433
 434 /******************************************************************************
 435  *      RtlCompareUnicodeStrings   (NTDLL.@)
 436  */
 437 LONG WINAPI RtlCompareUnicodeStrings( const WCHAR *s1, SIZE_T len1, const WCHAR *s2, SIZE_T len2,
 438                                       BOOLEAN case_insensitive )
 439 {
 440     LONG ret = 0;
 441     SIZE_T len = min( len1, len2 );
 442
 443     if (case_insensitive)
 444     {
 445         if (nls_info.UpperCaseTable)
 446         {
 447             while (!ret && len--) ret = casemap( nls_info.UpperCaseTable, *s1++ ) -
 448                                         casemap( nls_info.UpperCaseTable, *s2++ );
 449         }
 450         else  /* locale not setup yet */
 451         {
 452             while (!ret && len--) ret = casemap_ascii( *s1++ ) - casemap_ascii( *s2++ );
 453         }
 454     }
 455     else
 456     {
 457         while (!ret && len--) ret = *s1++ - *s2++;
 458     }
 459     if (!ret) ret = len1 - len2;
 460     return ret;
 461 }
 462
 463
 464 /**************************************************************************
 465  *      RtlPrefixUnicodeString   (NTDLL.@)
 466  */
 467 BOOLEAN WINAPI RtlPrefixUnicodeString( const UNICODE_STRING *s1, const UNICODE_STRING *s2,
 468                                        BOOLEAN ignore_case )
 469 {
 470     unsigned int i;
 471
 472     if (s1->Length > s2->Length) return FALSE;
 473     if (ignore_case)
 474     {
 475         for (i = 0; i < s1->Length / sizeof(WCHAR); i++)
 476             if (casemap( nls_info.UpperCaseTable, s1->Buffer[i] ) !=
 477                 casemap( nls_info.UpperCaseTable, s2->Buffer[i] )) return FALSE;
 478     }
 479     else
 480     {
 481         for (i = 0; i < s1->Length / sizeof(WCHAR); i++)
 482             if (s1->Buffer[i] != s2->Buffer[i]) return FALSE;
 483     }
 484     return TRUE;
 485 }
 486
 487
 488
 489 /******************************************************************************
 490  *      RtlHashUnicodeString   (NTDLL.@)
 491  */
 492 NTSTATUS WINAPI RtlHashUnicodeString( const UNICODE_STRING *string, BOOLEAN case_insensitive,
 493                                       ULONG alg, ULONG *hash )
 494 {
 495     unsigned int i;
 496
 497     if (!string || !hash) return STATUS_INVALID_PARAMETER;
 498
 499     switch (alg)
 500     {
 501     case HASH_STRING_ALGORITHM_DEFAULT:
 502     case HASH_STRING_ALGORITHM_X65599:
 503         break;
 504     default:
 505         return STATUS_INVALID_PARAMETER;
 506     }
 507
 508     *hash = 0;
 509     if (!case_insensitive)
 510         for (i = 0; i < string->Length / sizeof(WCHAR); i++)
 511             *hash = *hash * 65599 + string->Buffer[i];
 512     else if (nls_info.UpperCaseTable)
 513         for (i = 0; i < string->Length / sizeof(WCHAR); i++)
 514             *hash = *hash * 65599 + casemap( nls_info.UpperCaseTable, string->Buffer[i] );
 515     else  /* locale not setup yet */
 516         for (i = 0; i < string->Length / sizeof(WCHAR); i++)
 517             *hash = *hash * 65599 + casemap_ascii( string->Buffer[i] );
 518     return STATUS_SUCCESS;
 519 }
 520
 521
 522 /**************************************************************************
 523  *      RtlCustomCPToUnicodeN   (NTDLL.@)
 524  */
 525 NTSTATUS WINAPI RtlCustomCPToUnicodeN( CPTABLEINFO *info, WCHAR *dst, DWORD dstlen, DWORD *reslen,
 526                                        const char *src, DWORD srclen )
 527 {
 528     unsigned int ret = cp_mbstowcs( info, dst, dstlen / sizeof(WCHAR), src, srclen );
 529     if (reslen) *reslen = ret * sizeof(WCHAR);
 530     return STATUS_SUCCESS;
 531 }
 532
 533
 534 /**************************************************************************
 535  *      RtlUnicodeToCustomCPN   (NTDLL.@)
 536  */
 537 NTSTATUS WINAPI RtlUnicodeToCustomCPN( CPTABLEINFO *info, char *dst, DWORD dstlen, DWORD *reslen,
 538                                        const WCHAR *src, DWORD srclen )
 539 {
 540     unsigned int ret = cp_wcstombs( info, dst, dstlen, src, srclen / sizeof(WCHAR) );
 541     if (reslen) *reslen = ret;
 542     return STATUS_SUCCESS;
 543 }
 544
 545
 546 /**************************************************************************
 547  *      RtlMultiByteToUnicodeN   (NTDLL.@)
 548  */
 549 NTSTATUS WINAPI RtlMultiByteToUnicodeN( WCHAR *dst, DWORD dstlen, DWORD *reslen,
 550                                         const char *src, DWORD srclen )
 551 {
 552     unsigned int ret;
 553
 554     if (nls_info.AnsiTableInfo.CodePage != CP_UTF8)
 555         ret = cp_mbstowcs( &nls_info.AnsiTableInfo, dst, dstlen / sizeof(WCHAR), src, srclen );
 556     else
 557         utf8_mbstowcs( dst, dstlen / sizeof(WCHAR), &ret, src, srclen );
 558
 559     if (reslen) *reslen = ret * sizeof(WCHAR);
 560     return STATUS_SUCCESS;
 561 }
 562
 563
 564 /**************************************************************************
 565  *      RtlMultiByteToUnicodeSize   (NTDLL.@)
 566  */
 567 NTSTATUS WINAPI RtlMultiByteToUnicodeSize( DWORD *size, const char *str, DWORD len )
 568 {
 569     unsigned int ret;
 570
 571     if (nls_info.AnsiTableInfo.CodePage != CP_UTF8)
 572         ret = cp_mbstowcs_size( &nls_info.AnsiTableInfo, str, len );
 573     else
 574         utf8_mbstowcs_size( str, len, &ret );
 575
 576     *size = ret * sizeof(WCHAR);
 577     return STATUS_SUCCESS;
 578 }
 579
 580
 581 /**************************************************************************
 582  *      RtlOemToUnicodeN   (NTDLL.@)
 583  */
 584 NTSTATUS WINAPI RtlOemToUnicodeN( WCHAR *dst, DWORD dstlen, DWORD *reslen,
 585                                   const char *src, DWORD srclen )
 586 {
 587     unsigned int ret;
 588
 589     if (nls_info.OemTableInfo.CodePage != CP_UTF8)
 590         ret = cp_mbstowcs( &nls_info.OemTableInfo, dst, dstlen / sizeof(WCHAR), src, srclen );
 591     else
 592         utf8_mbstowcs( dst, dstlen / sizeof(WCHAR), &ret, src, srclen );
 593
 594     if (reslen) *reslen = ret * sizeof(WCHAR);
 595     return STATUS_SUCCESS;
 596 }
 597
 598
 599 /**************************************************************************
 600  *      RtlOemStringToUnicodeSize   (NTDLL.@)
 601  *      RtlxOemStringToUnicodeSize  (NTDLL.@)
 602  */
 603 DWORD WINAPI RtlOemStringToUnicodeSize( const STRING *str )
 604 {
 605     unsigned int ret;
 606
 607     if (nls_info.OemTableInfo.CodePage != CP_UTF8)
 608         ret = cp_mbstowcs_size( &nls_info.OemTableInfo, str->Buffer, str->Length );
 609     else
 610         utf8_mbstowcs_size( str->Buffer, str->Length, &ret );
 611
 612     return (ret + 1) * sizeof(WCHAR);
 613 }
 614
 615
 616 /**************************************************************************
 617  *      RtlUnicodeStringToOemSize   (NTDLL.@)
 618  *      RtlxUnicodeStringToOemSize  (NTDLL.@)
 619  */
 620 DWORD WINAPI RtlUnicodeStringToOemSize( const UNICODE_STRING *str )
 621 {
 622     unsigned int ret;
 623
 624     if (nls_info.OemTableInfo.CodePage != CP_UTF8)
 625         ret = cp_wcstombs_size( &nls_info.OemTableInfo, str->Buffer, str->Length / sizeof(WCHAR) );
 626     else
 627         utf8_wcstombs_size( str->Buffer, str->Length / sizeof(WCHAR), &ret );
 628
 629     return ret + 1;
 630 }
 631
 632
 633 /**************************************************************************
 634  *      RtlUnicodeToMultiByteN   (NTDLL.@)
 635  */
 636 NTSTATUS WINAPI RtlUnicodeToMultiByteN( char *dst, DWORD dstlen, DWORD *reslen,
 637                                         const WCHAR *src, DWORD srclen )
 638 {
 639     unsigned int ret;
 640
 641     if (nls_info.AnsiTableInfo.CodePage != CP_UTF8)
 642         ret = cp_wcstombs( &nls_info.AnsiTableInfo, dst, dstlen, src, srclen / sizeof(WCHAR) );
 643     else
 644         utf8_wcstombs( dst, dstlen, &ret, src, srclen / sizeof(WCHAR) );
 645
 646     if (reslen) *reslen = ret;
 647     return STATUS_SUCCESS;
 648 }
 649
 650
 651 /**************************************************************************
 652  *      RtlUnicodeToMultiByteSize   (NTDLL.@)
 653  */
 654 NTSTATUS WINAPI RtlUnicodeToMultiByteSize( DWORD *size, const WCHAR *str, DWORD len )
 655 {
 656     unsigned int ret;
 657
 658     if (nls_info.AnsiTableInfo.CodePage != CP_UTF8)
 659         ret = cp_wcstombs_size( &nls_info.AnsiTableInfo, str, len / sizeof(WCHAR) );
 660     else
 661         utf8_wcstombs_size( str, len / sizeof(WCHAR), &ret );
 662
 663     *size = ret;
 664     return STATUS_SUCCESS;
 665 }
 666
 667
 668 /**************************************************************************
 669  *      RtlUnicodeToOemN   (NTDLL.@)
 670  */
 671 NTSTATUS WINAPI RtlUnicodeToOemN( char *dst, DWORD dstlen, DWORD *reslen,
 672                                   const WCHAR *src, DWORD srclen )
 673 {
 674     unsigned int ret;
 675
 676     if (nls_info.OemTableInfo.CodePage != CP_UTF8)
 677         ret = cp_wcstombs( &nls_info.OemTableInfo, dst, dstlen, src, srclen / sizeof(WCHAR) );
 678     else
 679         utf8_wcstombs( dst, dstlen, &ret, src, srclen / sizeof(WCHAR) );
 680
 681     if (reslen) *reslen = ret;
 682     return STATUS_SUCCESS;
 683 }
 684
 685
 686 /**************************************************************************
 687  *      RtlDowncaseUnicodeChar   (NTDLL.@)
 688  */
 689 WCHAR WINAPI RtlDowncaseUnicodeChar( WCHAR wch )
 690 {
 691     if (nls_info.LowerCaseTable) return casemap( nls_info.LowerCaseTable, wch );
 692     if (wch >= 'A' && wch <= 'Z') wch += 'a' - 'A';
 693     return wch;
 694 }
 695
 696
 697 /**************************************************************************
 698  *      RtlDowncaseUnicodeString   (NTDLL.@)
 699  */
 700 NTSTATUS WINAPI RtlDowncaseUnicodeString( UNICODE_STRING *dest, const UNICODE_STRING *src,
 701                                           BOOLEAN alloc )
 702 {
 703     DWORD i, len = src->Length;
 704
 705     if (alloc)
 706     {
 707         dest->MaximumLength = len;
 708         if (!(dest->Buffer = RtlAllocateHeap( GetProcessHeap(), 0, len ))) return STATUS_NO_MEMORY;
 709     }
 710     else if (len > dest->MaximumLength) return STATUS_BUFFER_OVERFLOW;
 711
 712     for (i = 0; i < len / sizeof(WCHAR); i++)
 713         dest->Buffer[i] = casemap( nls_info.LowerCaseTable, src->Buffer[i] );
 714     dest->Length = len;
 715     return STATUS_SUCCESS;
 716 }
 717
 718
 719 /**************************************************************************
 720  *      RtlUpcaseUnicodeChar   (NTDLL.@)
 721  */
 722 WCHAR WINAPI RtlUpcaseUnicodeChar( WCHAR wch )
 723 {
 724     return casemap( nls_info.UpperCaseTable, wch );
 725 }
 726
 727
 728 /**************************************************************************
 729  *      RtlUpcaseUnicodeString   (NTDLL.@)
 730  */
 731 NTSTATUS WINAPI RtlUpcaseUnicodeString( UNICODE_STRING *dest, const UNICODE_STRING *src,
 732                                         BOOLEAN alloc )
 733 {
 734     DWORD i, len = src->Length;
 735
 736     if (alloc)
 737     {
 738         dest->MaximumLength = len;
 739         if (!(dest->Buffer = RtlAllocateHeap( GetProcessHeap(), 0, len ))) return STATUS_NO_MEMORY;
 740     }
 741     else if (len > dest->MaximumLength) return STATUS_BUFFER_OVERFLOW;
 742
 743     for (i = 0; i < len / sizeof(WCHAR); i++)
 744         dest->Buffer[i] = casemap( nls_info.UpperCaseTable, src->Buffer[i] );
 745     dest->Length = len;
 746     return STATUS_SUCCESS;
 747 }
 748
 749
 750 /**************************************************************************
 751  *      RtlUpcaseUnicodeToCustomCPN   (NTDLL.@)
 752  */
 753 NTSTATUS WINAPI RtlUpcaseUnicodeToCustomCPN( CPTABLEINFO *info, char *dst, DWORD dstlen, DWORD *reslen,
 754                                              const WCHAR *src, DWORD srclen )
 755 {
 756     DWORD i, ret;
 757
 758     srclen /= sizeof(WCHAR);
 759     if (info->DBCSCodePage)
 760     {
 761         WCHAR *uni2cp = info->WideCharTable;
 762
 763         for (i = dstlen; srclen && i; i--, srclen--, src++)
 764         {
 765             WCHAR ch = casemap( nls_info.UpperCaseTable, *src );
 766             if (uni2cp[ch] & 0xff00)
 767             {
 768                 if (i == 1) break;  /* do not output a partial char */
 769                 i--;
 770                 *dst++ = uni2cp[ch] >> 8;
 771             }
 772             *dst++ = (char)uni2cp[ch];
 773         }
 774         ret = dstlen - i;
 775     }
 776     else
 777     {
 778         char *uni2cp = info->WideCharTable;
 779         ret = min( srclen, dstlen );
 780         for (i = 0; i < ret; i++) dst[i] = uni2cp[casemap( nls_info.UpperCaseTable, src[i] )];
 781     }
 782     if (reslen) *reslen = ret;
 783     return STATUS_SUCCESS;
 784 }
 785
 786
 787 static NTSTATUS upcase_unicode_to_utf8( char *dst, DWORD dstlen, DWORD *reslen,
 788                                         const WCHAR *src, DWORD srclen )
 789 {
 790     char *end;
 791     unsigned int val;
 792     NTSTATUS status = STATUS_SUCCESS;
 793
 794     srclen /= sizeof(WCHAR);
 795
 796     for (end = dst + dstlen; srclen; srclen--, src++)
 797     {
 798         WCHAR ch = casemap( nls_info.UpperCaseTable, *src );
 799
 800         if (ch < 0x80)  /* 0x00-0x7f: 1 byte */
 801         {
 802             if (dst > end - 1) break;
 803             *dst++ = ch;
 804             continue;
 805         }
 806         if (ch < 0x800)  /* 0x80-0x7ff: 2 bytes */
 807         {
 808             if (dst > end - 2) break;
 809             dst[1] = 0x80 | (ch & 0x3f);
 810             ch >>= 6;
 811             dst[0] = 0xc0 | ch;
 812             dst += 2;
 813             continue;
 814         }
 815         if (!get_utf16( src, srclen, &val ))
 816         {
 817             val = 0xfffd;
 818             status = STATUS_SOME_NOT_MAPPED;
 819         }
 820         if (val < 0x10000)  /* 0x800-0xffff: 3 bytes */
 821         {
 822             if (dst > end - 3) break;
 823             dst[2] = 0x80 | (val & 0x3f);
 824             val >>= 6;
 825             dst[1] = 0x80 | (val & 0x3f);
 826             val >>= 6;
 827             dst[0] = 0xe0 | val;
 828             dst += 3;
 829         }
 830         else   /* 0x10000-0x10ffff: 4 bytes */
 831         {
 832             if (dst > end - 4) break;
 833             dst[3] = 0x80 | (val & 0x3f);
 834             val >>= 6;
 835             dst[2] = 0x80 | (val & 0x3f);
 836             val >>= 6;
 837             dst[1] = 0x80 | (val & 0x3f);
 838             val >>= 6;
 839             dst[0] = 0xf0 | val;
 840             dst += 4;
 841             src++;
 842             srclen--;
 843         }
 844     }
 845     if (srclen) status = STATUS_BUFFER_TOO_SMALL;
 846     if (reslen) *reslen = dstlen - (end - dst);
 847     return status;
 848 }
 849
 850 /**************************************************************************
 851  *      RtlUpcaseUnicodeToMultiByteN   (NTDLL.@)
 852  */
 853 NTSTATUS WINAPI RtlUpcaseUnicodeToMultiByteN( char *dst, DWORD dstlen, DWORD *reslen,
 854                                               const WCHAR *src, DWORD srclen )
 855 {
 856     if (nls_info.AnsiTableInfo.CodePage == CP_UTF8)
 857         return upcase_unicode_to_utf8( dst, dstlen, reslen, src, srclen );
 858     return RtlUpcaseUnicodeToCustomCPN( &nls_info.AnsiTableInfo, dst, dstlen, reslen, src, srclen );
 859 }
 860
 861
 862 /**************************************************************************
 863  *      RtlUpcaseUnicodeToOemN   (NTDLL.@)
 864  */
 865 NTSTATUS WINAPI RtlUpcaseUnicodeToOemN( char *dst, DWORD dstlen, DWORD *reslen,
 866                                         const WCHAR *src, DWORD srclen )
 867 {
 868     if (nls_info.OemTableInfo.CodePage == CP_UTF8)
 869         return upcase_unicode_to_utf8( dst, dstlen, reslen, src, srclen );
 870     return RtlUpcaseUnicodeToCustomCPN( &nls_info.OemTableInfo, dst, dstlen, reslen, src, srclen );
 871 }
 872
 873
 874 /*********************************************************************
 875  *      towlower   (NTDLL.@)
 876  */
 877 WCHAR __cdecl towlower( WCHAR ch )
 878 {
 879     if (ch >= 0x100) return ch;
 880     return casemap( nls_info.LowerCaseTable, ch );
 881 }
 882
 883
 884 /*********************************************************************
 885  *           towupper    (NTDLL.@)
 886  */
 887 WCHAR __cdecl towupper( WCHAR ch )
 888 {
 889     if (nls_info.UpperCaseTable) return casemap( nls_info.UpperCaseTable, ch );
 890     return casemap_ascii( ch );
 891 }
 892
 893
 894 /******************************************************************
 895  *      RtlIsValidLocaleName   (NTDLL.@)
 896  */
 897 BOOLEAN WINAPI RtlIsValidLocaleName( const WCHAR *name, ULONG flags )
 898 {
 899     const NLS_LOCALE_LCNAME_INDEX *entry = find_lcname_entry( name );
 900
 901     if (!entry) return FALSE;
 902     /* reject neutral locale unless flag 2 is set */
 903     if (!(flags & 2) && !get_locale_data( entry->idx )->inotneutral) return FALSE;
 904     return TRUE;
 905 }
 906
 907
 908 /******************************************************************
 909  *      RtlLcidToLocaleName   (NTDLL.@)
 910  */
 911 NTSTATUS WINAPI RtlLcidToLocaleName( LCID lcid, UNICODE_STRING *str, ULONG flags, BOOLEAN alloc )
 912 {
 913     const NLS_LOCALE_LCID_INDEX *entry;
 914     const WCHAR *name;
 915     ULONG len;
 916
 917     if (!str) return STATUS_INVALID_PARAMETER_2;
 918
 919     switch (lcid)
 920     {
 921     case LOCALE_USER_DEFAULT:
 922         NtQueryDefaultLocale( TRUE, &lcid );
 923         break;
 924     case LOCALE_SYSTEM_DEFAULT:
 925     case LOCALE_CUSTOM_DEFAULT:
 926         NtQueryDefaultLocale( FALSE, &lcid );
 927         break;
 928     case LOCALE_CUSTOM_UI_DEFAULT:
 929         return STATUS_UNSUCCESSFUL;
 930     case LOCALE_CUSTOM_UNSPECIFIED:
 931         return STATUS_INVALID_PARAMETER_1;
 932     }
 933
 934     if (!(entry = find_lcid_entry( lcid ))) return STATUS_INVALID_PARAMETER_1;
 935     /* reject neutral locale unless flag 2 is set */
 936     if (!(flags & 2) && !get_locale_data( entry->idx )->inotneutral) return STATUS_INVALID_PARAMETER_1;
 937
 938     name = locale_strings + entry->name;
 939     len = *name++;
 940
 941     if (alloc)
 942     {
 943         if (!(str->Buffer = RtlAllocateHeap( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) )))
 944             return STATUS_NO_MEMORY;
 945         str->MaximumLength = (len + 1) * sizeof(WCHAR);
 946     }
 947     else if (str->MaximumLength < (len + 1) * sizeof(WCHAR)) return STATUS_BUFFER_TOO_SMALL;
 948
 949     wcscpy( str->Buffer, name );
 950     str->Length = len * sizeof(WCHAR);
 951     TRACE( "%04x -> %s\n", lcid, debugstr_us(str) );
 952     return STATUS_SUCCESS;
 953 }
 954
 955
 956 /******************************************************************
 957  *      RtlLocaleNameToLcid   (NTDLL.@)
 958  */
 959 NTSTATUS WINAPI RtlLocaleNameToLcid( const WCHAR *name, LCID *lcid, ULONG flags )
 960 {
 961     const NLS_LOCALE_LCNAME_INDEX *entry = find_lcname_entry( name );
 962
 963     if (!entry) return STATUS_INVALID_PARAMETER_1;
 964     /* reject neutral locale unless flag 2 is set */
 965     if (!(flags & 2) && !get_locale_data( entry->idx )->inotneutral) return STATUS_INVALID_PARAMETER_1;
 966     *lcid = entry->id;
 967     TRACE( "%s -> %04x\n", debugstr_w(name), *lcid );
 968     return STATUS_SUCCESS;
 969 }
 970
 971
 972 /**************************************************************************
 973  *      RtlUTF8ToUnicodeN   (NTDLL.@)
 974  */
 975 NTSTATUS WINAPI RtlUTF8ToUnicodeN( WCHAR *dst, DWORD dstlen, DWORD *reslen, const char *src, DWORD srclen )
 976 {
 977     unsigned int ret;
 978     NTSTATUS status;
 979
 980     if (!src) return STATUS_INVALID_PARAMETER_4;
 981     if (!reslen) return STATUS_INVALID_PARAMETER;
 982
 983     if (!dst)
 984         status = utf8_mbstowcs_size( src, srclen, &ret );
 985     else
 986         status = utf8_mbstowcs( dst, dstlen / sizeof(WCHAR), &ret, src, srclen );
 987
 988     *reslen = ret * sizeof(WCHAR);
 989     return status;
 990 }
 991
 992
 993 /**************************************************************************
 994  *      RtlUnicodeToUTF8N   (NTDLL.@)
 995  */
 996 NTSTATUS WINAPI RtlUnicodeToUTF8N( char *dst, DWORD dstlen, DWORD *reslen, const WCHAR *src, DWORD srclen )
 997 {
 998     unsigned int ret;
 999     NTSTATUS status;
1000
1001     if (!src) return STATUS_INVALID_PARAMETER_4;
1002     if (!reslen) return STATUS_INVALID_PARAMETER;
1003     if (dst && (srclen & 1)) return STATUS_INVALID_PARAMETER_5;
1004
1005     if (!dst)
1006         status = utf8_wcstombs_size( src, srclen / sizeof(WCHAR), &ret );
1007     else
1008         status = utf8_wcstombs( dst, dstlen, &ret, src, srclen / sizeof(WCHAR) );
1009
1010     *reslen = ret;
1011     return status;
1012 }
1013
1014
1015 /******************************************************************************
1016  *      RtlIsNormalizedString   (NTDLL.@)
1017  */
1018 NTSTATUS WINAPI RtlIsNormalizedString( ULONG form, const WCHAR *str, INT len, BOOLEAN *res )
1019 {
1020     const struct norm_table *info;
1021     NTSTATUS status;
1022     BYTE props, class, last_class = 0;
1023     unsigned int ch;
1024     int i, r, result = 1;
1025
1026     if ((status = load_norm_table( form, &info ))) return status;
1027
1028     if (len == -1) len = wcslen( str );
1029
1030     for (i = 0; i < len && result; i += r)
1031     {
1032         if (!(r = get_utf16( str + i, len - i, &ch ))) return STATUS_NO_UNICODE_TRANSLATION;
1033         if (info->comp_size)
1034         {
1035             if ((ch >= HANGUL_VBASE && ch < HANGUL_VBASE + HANGUL_VCOUNT) ||
1036                 (ch >= HANGUL_TBASE && ch < HANGUL_TBASE + HANGUL_TCOUNT))
1037             {
1038                 result = -1;  /* QC=Maybe */
1039                 continue;
1040             }
1041         }
1042         else if (ch >= HANGUL_SBASE && ch < HANGUL_SBASE + HANGUL_SCOUNT)
1043         {
1044             result = 0;  /* QC=No */
1045             break;
1046         }
1047         props = get_char_props( info, ch );
1048         class = props & 0x3f;
1049         if (class == 0x3f)
1050         {
1051             last_class = 0;
1052             if (props == 0xbf) result = 0;  /* QC=No */
1053             else if (props == 0xff)
1054             {
1055                 /* ignore other chars in Hangul range */
1056                 if (ch >= HANGUL_LBASE && ch < HANGUL_LBASE + 0x100) continue;
1057                 if (ch >= HANGUL_SBASE && ch < HANGUL_SBASE + 0x2c00) continue;
1058                 /* allow final null */
1059                 if (!ch && i == len - 1) continue;
1060                 return STATUS_NO_UNICODE_TRANSLATION;
1061             }
1062         }
1063         else if (props & 0x80)
1064         {
1065             if ((props & 0xc0) == 0xc0) result = -1;  /* QC=Maybe */
1066             if (class && class < last_class) result = 0;  /* QC=No */
1067             last_class = class;
1068         }
1069         else last_class = 0;
1070     }
1071
1072     if (result == -1)
1073     {
1074         int dstlen = len * 4;
1075         NTSTATUS status;
1076         WCHAR *buffer = RtlAllocateHeap( GetProcessHeap(), 0, dstlen * sizeof(WCHAR) );
1077         if (!buffer) return STATUS_NO_MEMORY;
1078         status = RtlNormalizeString( form, str, len, buffer, &dstlen );
1079         result = !status && (dstlen == len) && !wcsncmp( buffer, str, len );
1080         RtlFreeHeap( GetProcessHeap(), 0, buffer );
1081     }
1082     *res = result;
1083     return STATUS_SUCCESS;
1084 }
1085
1086
1087 /******************************************************************************
1088  *      RtlNormalizeString   (NTDLL.@)
1089  */
1090 NTSTATUS WINAPI RtlNormalizeString( ULONG form, const WCHAR *src, INT src_len, WCHAR *dst, INT *dst_len )
1091 {
1092     int buf_len;
1093     WCHAR *buf = NULL;
1094     const struct norm_table *info;
1095     NTSTATUS status = STATUS_SUCCESS;
1096
1097     TRACE( "%x %s %d %p %d\n", form, debugstr_wn(src, src_len), src_len, dst, *dst_len );
1098
1099     if ((status = load_norm_table( form, &info ))) return status;
1100
1101     if (src_len == -1) src_len = wcslen(src) + 1;
1102
1103     if (!*dst_len)
1104     {
1105         *dst_len = src_len * info->len_factor;
1106         if (*dst_len > 64) *dst_len = max( 64, src_len + src_len / 8 );
1107         return STATUS_SUCCESS;
1108     }
1109     if (!src_len)
1110     {
1111         *dst_len = 0;
1112         return STATUS_SUCCESS;
1113     }
1114
1115     if (!info->comp_size) return decompose_string( info, src, src_len, dst, dst_len );
1116
1117     buf_len = src_len * 4;
1118     for (;;)
1119     {
1120         buf = RtlAllocateHeap( GetProcessHeap(), 0, buf_len * sizeof(WCHAR) );
1121         if (!buf) return STATUS_NO_MEMORY;
1122         status = decompose_string( info, src, src_len, buf, &buf_len );
1123         if (status != STATUS_BUFFER_TOO_SMALL) break;
1124         RtlFreeHeap( GetProcessHeap(), 0, buf );
1125     }
1126     if (!status)
1127     {
1128         buf_len = compose_string( info, buf, buf_len );
1129         if (*dst_len >= buf_len) memcpy( dst, buf, buf_len * sizeof(WCHAR) );
1130         else status = STATUS_BUFFER_TOO_SMALL;
1131     }
1132     RtlFreeHeap( GetProcessHeap(), 0, buf );
1133     *dst_len = buf_len;
1134     return status;
1135 }
1136
1137
1138 /* Punycode parameters */
1139 enum { BASE = 36, TMIN = 1, TMAX = 26, SKEW = 38, DAMP = 700 };
1140
1141 static BOOL check_invalid_chars( const struct norm_table *info, DWORD flags,
1142                                  const unsigned int *buffer, int len )
1143 {
1144     int i;
1145
1146     for (i = 0; i < len; i++)
1147     {
1148         switch (buffer[i])
1149         {
1150         case 0x200c:  /* zero-width non-joiner */
1151         case 0x200d:  /* zero-width joiner */
1152             if (!i || get_combining_class( info, buffer[i - 1] ) != 9) return TRUE;
1153             break;
1154         case 0x2260:  /* not equal to */
1155         case 0x226e:  /* not less than */
1156         case 0x226f:  /* not greater than */
1157             if (flags & IDN_USE_STD3_ASCII_RULES) return TRUE;
1158             break;
1159         }
1160         switch (get_char_props( info, buffer[i] ))
1161         {
1162         case 0xbf:
1163             return TRUE;
1164         case 0xff:
1165             if (buffer[i] >= HANGUL_SBASE && buffer[i] < HANGUL_SBASE + 0x2c00) break;
1166             return TRUE;
1167         case 0x7f:
1168             if (!(flags & IDN_ALLOW_UNASSIGNED)) return TRUE;
1169             break;
1170         }
1171     }
1172
1173     if ((flags & IDN_USE_STD3_ASCII_RULES) && len && (buffer[0] == '-' || buffer[len - 1] == '-'))
1174         return TRUE;
1175
1176     return FALSE;
1177 }
1178
1179
1180 /******************************************************************************
1181  *      RtlIdnToAscii   (NTDLL.@)
1182  */
1183 NTSTATUS WINAPI RtlIdnToAscii( DWORD flags, const WCHAR *src, INT srclen, WCHAR *dst, INT *dstlen )
1184 {
1185     static const WCHAR prefixW[] = {'x','n','-','-'};
1186     const struct norm_table *info;
1187     NTSTATUS status;
1188     WCHAR normstr[256], res[256];
1189     unsigned int ch, buffer[64];
1190     int i, len, start, end, out_label, out = 0, normlen = ARRAY_SIZE(normstr);
1191
1192     TRACE( "%x %s %p %d\n", flags, debugstr_wn(src, srclen), dst, *dstlen );
1193
1194     if ((status = load_norm_table( 13, &info ))) return status;
1195
1196     if ((status = RtlIdnToNameprepUnicode( flags, src, srclen, normstr, &normlen ))) return status;
1197
1198     /* implementation of Punycode based on RFC 3492 */
1199
1200     for (start = 0; start < normlen; start = end + 1)
1201     {
1202         int n = 0x80, bias = 72, delta = 0, b = 0, h, buflen = 0;
1203
1204         out_label = out;
1205         for (i = start; i < normlen; i += len)
1206         {
1207             if (!(len = get_utf16( normstr + i, normlen - i, &ch ))) break;
1208             if (!ch || ch == '.') break;
1209             if (ch < 0x80) b++;
1210             buffer[buflen++] = ch;
1211         }
1212         end = i;
1213
1214         if (b == end - start)
1215         {
1216             if (end < normlen) b++;
1217             if (out + b > ARRAY_SIZE(res)) return STATUS_INVALID_IDN_NORMALIZATION;
1218             memcpy( res + out, normstr + start, b * sizeof(WCHAR) );
1219             out += b;
1220             continue;
1221         }
1222
1223         if (buflen >= 4 && buffer[2] == '-' && buffer[3] == '-') return STATUS_INVALID_IDN_NORMALIZATION;
1224         if (check_invalid_chars( info, flags, buffer, buflen )) return STATUS_INVALID_IDN_NORMALIZATION;
1225
1226         if (out + 5 + b > ARRAY_SIZE(res)) return STATUS_INVALID_IDN_NORMALIZATION;
1227         memcpy( res + out, prefixW, sizeof(prefixW) );
1228         out += ARRAY_SIZE(prefixW);
1229         if (b)
1230         {
1231             for (i = start; i < end; i++) if (normstr[i] < 0x80) res[out++] = normstr[i];
1232             res[out++] = '-';
1233         }
1234
1235         for (h = b; h < buflen; delta++, n++)
1236         {
1237             int m = 0x10ffff, q, k;
1238
1239             for (i = 0; i < buflen; i++) if (buffer[i] >= n && m > buffer[i]) m = buffer[i];
1240             delta += (m - n) * (h + 1);
1241             n = m;
1242
1243             for (i = 0; i < buflen; i++)
1244             {
1245                 if (buffer[i] == n)
1246                 {
1247                     for (q = delta, k = BASE; ; k += BASE)
1248                     {
1249                         int t = k <= bias ? TMIN : k >= bias + TMAX ? TMAX : k - bias;
1250                         int disp = q < t ? q : t + (q - t) % (BASE - t);
1251                         if (out + 1 > ARRAY_SIZE(res)) return STATUS_INVALID_IDN_NORMALIZATION;
1252                         res[out++] = disp <= 25 ? 'a' + disp : '0' + disp - 26;
1253                         if (q < t) break;
1254                         q = (q - t) / (BASE - t);
1255                     }
1256                     delta /= (h == b ? DAMP : 2);
1257                     delta += delta / (h + 1);
1258                     for (k = 0; delta > ((BASE - TMIN) * TMAX) / 2; k += BASE) delta /= BASE - TMIN;
1259                     bias = k + ((BASE - TMIN + 1) * delta) / (delta + SKEW);
1260                     delta = 0;
1261                     h++;
1262                 }
1263                 else if (buffer[i] < n) delta++;
1264             }
1265         }
1266
1267         if (out - out_label > 63) return STATUS_INVALID_IDN_NORMALIZATION;
1268
1269         if (end < normlen)
1270         {
1271             if (out + 1 > ARRAY_SIZE(res)) return STATUS_INVALID_IDN_NORMALIZATION;
1272             res[out++] = normstr[end];
1273         }
1274     }
1275
1276     if (*dstlen)
1277     {
1278         if (out <= *dstlen) memcpy( dst, res, out * sizeof(WCHAR) );
1279         else status = STATUS_BUFFER_TOO_SMALL;
1280     }
1281     *dstlen = out;
1282     return status;
1283 }
1284
1285
1286 /******************************************************************************
1287  *      RtlIdnToNameprepUnicode   (NTDLL.@)
1288  */
1289 NTSTATUS WINAPI RtlIdnToNameprepUnicode( DWORD flags, const WCHAR *src, INT srclen,
1290                                          WCHAR *dst, INT *dstlen )
1291 {
1292     const struct norm_table *info;
1293     unsigned int ch;
1294     NTSTATUS status;
1295     WCHAR buf[256];
1296     int i, start, len, buflen = ARRAY_SIZE(buf);
1297
1298     if (flags & ~(IDN_ALLOW_UNASSIGNED | IDN_USE_STD3_ASCII_RULES)) return STATUS_INVALID_PARAMETER;
1299     if (!src || srclen < -1) return STATUS_INVALID_PARAMETER;
1300
1301     TRACE( "%x %s %p %d\n", flags, debugstr_wn(src, srclen), dst, *dstlen );
1302
1303     if ((status = load_norm_table( 13, &info ))) return status;
1304
1305     if (srclen == -1) srclen = wcslen(src) + 1;
1306
1307     for (i = 0; i < srclen; i++) if (src[i] < 0x20 || src[i] >= 0x7f) break;
1308
1309     if (i == srclen || (i == srclen - 1 && !src[i]))  /* ascii only */
1310     {
1311         if (srclen > buflen) return STATUS_INVALID_IDN_NORMALIZATION;
1312         memcpy( buf, src, srclen * sizeof(WCHAR) );
1313         buflen = srclen;
1314     }
1315     else if ((status = RtlNormalizeString( 13, src, srclen, buf, &buflen )))
1316     {
1317         if (status == STATUS_NO_UNICODE_TRANSLATION) status = STATUS_INVALID_IDN_NORMALIZATION;
1318         return status;
1319     }
1320
1321     for (i = start = 0; i < buflen; i += len)
1322     {
1323         if (!(len = get_utf16( buf + i, buflen - i, &ch ))) break;
1324         if (!ch) break;
1325         if (ch == '.')
1326         {
1327             if (start == i) return STATUS_INVALID_IDN_NORMALIZATION;
1328             /* maximal label length is 63 characters */
1329             if (i - start > 63) return STATUS_INVALID_IDN_NORMALIZATION;
1330             if ((flags & IDN_USE_STD3_ASCII_RULES) && (buf[start] == '-' || buf[i-1] == '-'))
1331                 return STATUS_INVALID_IDN_NORMALIZATION;
1332             start = i + 1;
1333             continue;
1334         }
1335         if (flags & IDN_USE_STD3_ASCII_RULES)
1336         {
1337             if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||
1338                 (ch >= '0' && ch <= '9') || ch == '-') continue;
1339             return STATUS_INVALID_IDN_NORMALIZATION;
1340         }
1341         if (!(flags & IDN_ALLOW_UNASSIGNED))
1342         {
1343             if (get_char_props( info, ch ) == 0x7f) return STATUS_INVALID_IDN_NORMALIZATION;
1344         }
1345     }
1346     if (!i || i - start > 63) return STATUS_INVALID_IDN_NORMALIZATION;
1347     if ((flags & IDN_USE_STD3_ASCII_RULES) && (buf[start] == '-' || buf[i-1] == '-'))
1348         return STATUS_INVALID_IDN_NORMALIZATION;
1349
1350     if (*dstlen)
1351     {
1352         if (buflen <= *dstlen) memcpy( dst, buf, buflen * sizeof(WCHAR) );
1353         else status = STATUS_BUFFER_TOO_SMALL;
1354     }
1355     *dstlen = buflen;
1356     return status;
1357 }
1358
1359
1360 /******************************************************************************
1361  *      RtlIdnToUnicode   (NTDLL.@)
1362  */
1363 NTSTATUS WINAPI RtlIdnToUnicode( DWORD flags, const WCHAR *src, INT srclen, WCHAR *dst, INT *dstlen )
1364 {
1365     const struct norm_table *info;
1366     int i, buflen, start, end, out_label, out = 0;
1367     NTSTATUS status;
1368     UINT buffer[64];
1369     WCHAR ch;
1370
1371     if (!src || srclen < -1) return STATUS_INVALID_PARAMETER;
1372     if (srclen == -1) srclen = wcslen( src ) + 1;
1373
1374     TRACE( "%x %s %p %d\n", flags, debugstr_wn(src, srclen), dst, *dstlen );
1375
1376     if ((status = load_norm_table( 13, &info ))) return status;
1377
1378     for (start = 0; start < srclen; )
1379     {
1380         int n = 0x80, bias = 72, pos = 0, old_pos, w, k, t, delim = 0, digit, delta;
1381
1382         out_label = out;
1383         for (i = start; i < srclen; i++)
1384         {
1385             ch = src[i];
1386             if (ch > 0x7f || (i != srclen - 1 && !ch)) return STATUS_INVALID_IDN_NORMALIZATION;
1387             if (!ch || ch == '.') break;
1388             if (ch == '-') delim = i;
1389
1390             if (!(flags & IDN_USE_STD3_ASCII_RULES)) continue;
1391             if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||
1392                 (ch >= '0' && ch <= '9') || ch == '-')
1393                 continue;
1394             return STATUS_INVALID_IDN_NORMALIZATION;
1395         }
1396         end = i;
1397
1398         /* last label may be empty */
1399         if (start == end && ch) return STATUS_INVALID_IDN_NORMALIZATION;
1400
1401         if (end - start < 4 ||
1402             (src[start] != 'x' && src[start] != 'X') ||
1403             (src[start + 1] != 'n' && src[start + 1] != 'N') ||
1404             src[start + 2] != '-' || src[start + 3] != '-')
1405         {
1406             if (end - start > 63) return STATUS_INVALID_IDN_NORMALIZATION;
1407
1408             if ((flags & IDN_USE_STD3_ASCII_RULES) && (src[start] == '-' || src[end - 1] == '-'))
1409                 return STATUS_INVALID_IDN_NORMALIZATION;
1410
1411             if (end < srclen) end++;
1412             if (*dstlen)
1413             {
1414                 if (out + end - start <= *dstlen)
1415                     memcpy( dst + out, src + start, (end - start) * sizeof(WCHAR));
1416                 else return STATUS_BUFFER_TOO_SMALL;
1417             }
1418             out += end - start;
1419             start = end;
1420             continue;
1421         }
1422
1423         if (delim == start + 3) delim++;
1424         buflen = 0;
1425         for (i = start + 4; i < delim && buflen < ARRAY_SIZE(buffer); i++) buffer[buflen++] = src[i];
1426         if (buflen) i++;
1427         while (i < end)
1428         {
1429             old_pos = pos;
1430             w = 1;
1431             for (k = BASE; ; k += BASE)
1432             {
1433                 if (i >= end) return STATUS_INVALID_IDN_NORMALIZATION;
1434                 ch = src[i++];
1435                 if (ch >= 'a' && ch <= 'z') digit = ch - 'a';
1436                 else if (ch >= 'A' && ch <= 'Z') digit = ch - 'A';
1437                 else if (ch >= '0' && ch <= '9') digit = ch - '0' + 26;
1438                 else return STATUS_INVALID_IDN_NORMALIZATION;
1439                 pos += digit * w;
1440                 t = k <= bias ? TMIN : k >= bias + TMAX ? TMAX : k - bias;
1441                 if (digit < t) break;
1442                 w *= BASE - t;
1443             }
1444
1445             delta = (pos - old_pos) / (!old_pos ? DAMP : 2);
1446             delta += delta / (buflen + 1);
1447             for (k = 0; delta > ((BASE - TMIN) * TMAX) / 2; k += BASE) delta /= BASE - TMIN;
1448             bias = k + ((BASE - TMIN + 1) * delta) / (delta + SKEW);
1449             n += pos / (buflen + 1);
1450             pos %= buflen + 1;
1451
1452             if (buflen >= ARRAY_SIZE(buffer) - 1) return STATUS_INVALID_IDN_NORMALIZATION;
1453             memmove( buffer + pos + 1, buffer + pos, (buflen - pos) * sizeof(*buffer) );
1454             buffer[pos++] = n;
1455             buflen++;
1456         }
1457
1458         if (check_invalid_chars( info, flags, buffer, buflen )) return STATUS_INVALID_IDN_NORMALIZATION;
1459
1460         for (i = 0; i < buflen; i++)
1461         {
1462             int len = 1 + (buffer[i] >= 0x10000);
1463             if (*dstlen)
1464             {
1465                 if (out + len <= *dstlen) put_utf16( dst + out, buffer[i] );
1466                 else return STATUS_BUFFER_TOO_SMALL;
1467             }
1468             out += len;
1469         }
1470
1471         if (out - out_label > 63) return STATUS_INVALID_IDN_NORMALIZATION;
1472
1473         if (end < srclen)
1474         {
1475             if (*dstlen)
1476             {
1477                 if (out + 1 <= *dstlen) dst[out] = src[end];
1478                 else return STATUS_BUFFER_TOO_SMALL;
1479             }
1480             out++;
1481         }
1482         start = end + 1;
1483     }
1484     *dstlen = out;
1485     return STATUS_SUCCESS;
1486 }