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