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