?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel32: Move ReadConsole and WriteConsole to kernelbase.
[wine.git] / dlls / ntdll / locale.c
blob81263f4616a57c81080fed9b30f91c43dea3ab64
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 "wine/debug.h"
34
35 WINE_DEFAULT_DEBUG_CHANNEL(nls);
36
37 /* NLS codepage file format:
38 *
39 * header:
40 * WORD offset to cp2uni table in words
41 * WORD CodePage
42 * WORD MaximumCharacterSize
43 * BYTE[2] DefaultChar
44 * WORD UniDefaultChar
45 * WORD TransDefaultChar
46 * WORD TransUniDefaultChar
47 * BYTE[12] LeadByte
48 * cp2uni table:
49 * WORD offset to uni2cp table in words
50 * WORD[256] cp2uni table
51 * WORD glyph table size
52 * WORD[glyph_table_size] glyph table
53 * WORD number of lead byte ranges
54 * WORD[256] lead byte offsets in words
55 * WORD[leadbytes][256] cp2uni table for lead bytes
56 * uni2cp table:
57 * WORD 0 / 4
58 * BYTE[65536] / WORD[65536] uni2cp table
59 */
60
61 enum nls_section_type
62 {
63 NLS_SECTION_SORTKEYS = 9,
64 NLS_SECTION_CASEMAP = 10,
65 NLS_SECTION_CODEPAGE = 11,
66 NLS_SECTION_NORMALIZE = 12
67 };
68
69 UINT NlsAnsiCodePage = 0;
70 BYTE NlsMbCodePageTag = 0;
71 BYTE NlsMbOemCodePageTag = 0;
72
73 /* NLS normalization file */
74 struct norm_table
75 {
76 WCHAR name[13]; /* 00 file name */
77 USHORT checksum[3]; /* 1a checksum? */
78 USHORT version[4]; /* 20 Unicode version */
79 USHORT form; /* 28 normalization form */
80 USHORT len_factor; /* 2a factor for length estimates */
81 USHORT unknown1; /* 2c */
82 USHORT decomp_size; /* 2e decomposition hash size */
83 USHORT comp_size; /* 30 composition hash size */
84 USHORT unknown2; /* 32 */
85 USHORT classes; /* 34 combining classes table offset */
86 USHORT props_level1; /* 36 char properties table level 1 offset */
87 USHORT props_level2; /* 38 char properties table level 2 offset */
88 USHORT decomp_hash; /* 3a decomposition hash table offset */
89 USHORT decomp_map; /* 3c decomposition character map table offset */
90 USHORT decomp_seq; /* 3e decomposition character sequences offset */
91 USHORT comp_hash; /* 40 composition hash table offset */
92 USHORT comp_seq; /* 42 composition character sequences offset */
93 /* BYTE[] combining class values */
94 /* BYTE[0x2200] char properties index level 1 */
95 /* BYTE[] char properties index level 2 */
96 /* WORD[] decomposition hash table */
97 /* WORD[] decomposition character map */
98 /* WORD[] decomposition character sequences */
99 /* WORD[] composition hash table */
100 /* WORD[] composition character sequences */
101 };
102
103 LCID user_lcid = 0, system_lcid = 0;
104
105 static NLSTABLEINFO nls_info;
106 static HMODULE kernel32_handle;
107 static CPTABLEINFO unix_table;
108 static struct norm_table *norm_tables[16];
109
110
111 static NTSTATUS load_string( ULONG id, LANGID lang, WCHAR *buffer, ULONG len )
112 {
113 const IMAGE_RESOURCE_DATA_ENTRY *data;
114 LDR_RESOURCE_INFO info;
115 NTSTATUS status;
116 WCHAR *p;
117 int i;
118
119 info.Type = 6; /* RT_STRING */
120 info.Name = (id >> 4) + 1;
121 info.Language = lang;
122 if ((status = LdrFindResource_U( kernel32_handle, &info, 3, &data ))) return status;
123 p = (WCHAR *)((char *)kernel32_handle + data->OffsetToData);
124 for (i = 0; i < (id & 0x0f); i++) p += *p + 1;
125 if (*p >= len) return STATUS_BUFFER_TOO_SMALL;
126 memcpy( buffer, p + 1, *p * sizeof(WCHAR) );
127 buffer[*p] = 0;
128 return STATUS_SUCCESS;
129 }
130
131
132 static DWORD mbtowc_size( const CPTABLEINFO *info, LPCSTR str, UINT len )
133 {
134 DWORD res;
135
136 if (!info->DBCSCodePage) return len;
137
138 for (res = 0; len; len--, str++, res++)
139 {
140 if (info->DBCSOffsets[(unsigned char)*str] && len > 1)
141 {
142 str++;
143 len--;
144 }
145 }
146 return res;
147 }
148
149
150 static DWORD wctomb_size( const CPTABLEINFO *info, LPCWSTR str, UINT len )
151 {
152 if (info->DBCSCodePage)
153 {
154 WCHAR *uni2cp = info->WideCharTable;
155 DWORD res;
156
157 for (res = 0; len; len--, str++, res++)
158 if (uni2cp[*str] & 0xff00) res++;
159 return res;
160 }
161 else return len;
162 }
163
164
165 static WCHAR casemap( USHORT *table, WCHAR ch )
166 {
167 return ch + table[table[table[ch >> 8] + ((ch >> 4) & 0x0f)] + (ch & 0x0f)];
168 }
169
170
171 static WCHAR casemap_ascii( WCHAR ch )
172 {
173 if (ch >= 'a' && ch <= 'z') ch -= 'a' - 'A';
174 return ch;
175 }
176
177
178 static int get_utf16( const WCHAR *src, unsigned int srclen, unsigned int *ch )
179 {
180 if (IS_HIGH_SURROGATE( src[0] ))
181 {
182 if (srclen <= 1) return 0;
183 if (!IS_LOW_SURROGATE( src[1] )) return 0;
184 *ch = 0x10000 + ((src[0] & 0x3ff) << 10) + (src[1] & 0x3ff);
185 return 2;
186 }
187 if (IS_LOW_SURROGATE( src[0] )) return 0;
188 *ch = src[0];
189 return 1;
190 }
191
192 static void put_utf16( WCHAR *dst, unsigned int ch )
193 {
194 if (ch >= 0x10000)
195 {
196 ch -= 0x10000;
197 dst[0] = 0xd800 | (ch >> 10);
198 dst[1] = 0xdc00 | (ch & 0x3ff);
199 }
200 else dst[0] = ch;
201 }
202
203
204 static NTSTATUS load_norm_table( ULONG form, const struct norm_table **info )
205 {
206 unsigned int i;
207 USHORT *data, *tables;
208 SIZE_T size;
209 NTSTATUS status;
210
211 if (!form) return STATUS_INVALID_PARAMETER;
212 if (form >= ARRAY_SIZE(norm_tables)) return STATUS_OBJECT_NAME_NOT_FOUND;
213
214 if (!norm_tables[form])
215 {
216 if ((status = NtGetNlsSectionPtr( NLS_SECTION_NORMALIZE, form, NULL, (void **)&data, &size )))
217 return status;
218
219 /* sanity checks */
220
221 if (size <= 0x44) goto invalid;
222 if (data[0x14] != form) goto invalid;
223 tables = data + 0x1a;
224 for (i = 0; i < 8; i++)
225 {
226 if (tables[i] > size / sizeof(USHORT)) goto invalid;
227 if (i && tables[i] < tables[i-1]) goto invalid;
228 }
229
230 if (InterlockedCompareExchangePointer( (void **)&norm_tables[form], data, NULL ))
231 RtlFreeHeap( GetProcessHeap(), 0, data );
232 }
233 *info = norm_tables[form];
234 return STATUS_SUCCESS;
235
236 invalid:
237 RtlFreeHeap( GetProcessHeap(), 0, data );
238 return STATUS_INVALID_PARAMETER;
239 }
240
241
242 static BYTE rol( BYTE val, BYTE count )
243 {
244 return (val << count) | (val >> (8 - count));
245 }
246
247
248 static BYTE get_char_props( const struct norm_table *info, unsigned int ch )
249 {
250 const BYTE *level1 = (const BYTE *)((const USHORT *)info + info->props_level1);
251 const BYTE *level2 = (const BYTE *)((const USHORT *)info + info->props_level2);
252 BYTE off = level1[ch / 128];
253
254 if (!off || off >= 0xfb) return rol( off, 5 );
255 return level2[(off - 1) * 128 + ch % 128];
256 }
257
258
259 #define HANGUL_SBASE 0xac00
260 #define HANGUL_LBASE 0x1100
261 #define HANGUL_VBASE 0x1161
262 #define HANGUL_TBASE 0x11a7
263 #define HANGUL_LCOUNT 19
264 #define HANGUL_VCOUNT 21
265 #define HANGUL_TCOUNT 28
266 #define HANGUL_NCOUNT (HANGUL_VCOUNT * HANGUL_TCOUNT)
267 #define HANGUL_SCOUNT (HANGUL_LCOUNT * HANGUL_NCOUNT)
268
269 static const WCHAR *get_decomposition( const struct norm_table *info, unsigned int ch,
270 BYTE props, WCHAR *buffer, unsigned int *ret_len )
271 {
272 const struct pair { WCHAR src; USHORT dst; } *pairs;
273 const USHORT *hash_table = (const USHORT *)info + info->decomp_hash;
274 const WCHAR *ret;
275 unsigned int i, pos, end, len, hash;
276
277 /* default to no decomposition */
278 put_utf16( buffer, ch );
279 *ret_len = 1 + (ch >= 0x10000);
280 if (!props || props == 0x7f) return buffer;
281
282 if (props == 0xff) /* Hangul or invalid char */
283 {
284 if (ch >= HANGUL_SBASE && ch < HANGUL_SBASE + HANGUL_SCOUNT)
285 {
286 unsigned short sindex = ch - HANGUL_SBASE;
287 unsigned short tindex = sindex % HANGUL_TCOUNT;
288 buffer[0] = HANGUL_LBASE + sindex / HANGUL_NCOUNT;
289 buffer[1] = HANGUL_VBASE + (sindex % HANGUL_NCOUNT) / HANGUL_TCOUNT;
290 if (tindex) buffer[2] = HANGUL_TBASE + tindex;
291 *ret_len = 2 + !!tindex;
292 return buffer;
293 }
294 /* ignore other chars in Hangul range */
295 if (ch >= HANGUL_LBASE && ch < HANGUL_LBASE + 0x100) return buffer;
296 if (ch >= HANGUL_SBASE && ch < HANGUL_SBASE + 0x2c00) return buffer;
297 return NULL;
298 }
299
300 hash = ch % info->decomp_size;
301 pos = hash_table[hash];
302 if (pos >> 13)
303 {
304 if (props != 0xbf) return buffer;
305 ret = (const USHORT *)info + info->decomp_seq + (pos & 0x1fff);
306 len = pos >> 13;
307 }
308 else
309 {
310 pairs = (const struct pair *)((const USHORT *)info + info->decomp_map);
311
312 /* find the end of the hash bucket */
313 for (i = hash + 1; i < info->decomp_size; i++) if (!(hash_table[i] >> 13)) break;
314 if (i < info->decomp_size) end = hash_table[i];
315 else for (end = pos; pairs[end].src; end++) ;
316
317 for ( ; pos < end; pos++)
318 {
319 if (pairs[pos].src != (WCHAR)ch) continue;
320 ret = (const USHORT *)info + info->decomp_seq + (pairs[pos].dst & 0x1fff);
321 len = pairs[pos].dst >> 13;
322 break;
323 }
324 if (pos >= end) return buffer;
325 }
326
327 if (len == 7) while (ret[len]) len++;
328 if (!ret[0]) len = 0; /* ignored char */
329 *ret_len = len;
330 return ret;
331 }
332
333
334 static BYTE get_combining_class( const struct norm_table *info, unsigned int c )
335 {
336 const BYTE *classes = (const BYTE *)((const USHORT *)info + info->classes);
337 BYTE class = get_char_props( info, c ) & 0x3f;
338
339 if (class == 0x3f) return 0;
340 return classes[class];
341 }
342
343
344 static BOOL is_starter( const struct norm_table *info, unsigned int c )
345 {
346 return !get_combining_class( info, c );
347 }
348
349
350 static BOOL reorderable_pair( const struct norm_table *info, unsigned int c1, unsigned int c2 )
351 {
352 BYTE ccc1, ccc2;
353
354 /* reorderable if ccc1 > ccc2 > 0 */
355 ccc1 = get_combining_class( info, c1 );
356 if (ccc1 < 2) return FALSE;
357 ccc2 = get_combining_class( info, c2 );
358 return ccc2 && (ccc1 > ccc2);
359 }
360
361 static void canonical_order_substring( const struct norm_table *info, WCHAR *str, unsigned int len )
362 {
363 unsigned int i, ch1, ch2, len1, len2;
364 BOOL swapped;
365
366 do
367 {
368 swapped = FALSE;
369 for (i = 0; i < len - 1; i += len1)
370 {
371 if (!(len1 = get_utf16( str + i, len - i, &ch1 ))) break;
372 if (i + len1 >= len) break;
373 if (!(len2 = get_utf16( str + i + len1, len - i - len1, &ch2 ))) break;
374 if (reorderable_pair( info, ch1, ch2 ))
375 {
376 WCHAR tmp[2];
377 memcpy( tmp, str + i, len1 * sizeof(WCHAR) );
378 memcpy( str + i, str + i + len1, len2 * sizeof(WCHAR) );
379 memcpy( str + i + len2, tmp, len1 * sizeof(WCHAR) );
380 swapped = TRUE;
381 i += len2 - len1;
382 }
383 }
384 } while (swapped);
385 }
386
387
388 /****************************************************************************
389 * canonical_order_string
390 *
391 * Reorder the string into canonical order - D108/D109.
392 *
393 * Starters (chars with combining class == 0) don't move, so look for continuous
394 * substrings of non-starters and only reorder those.
395 */
396 static void canonical_order_string( const struct norm_table *info, WCHAR *str, unsigned int len )
397 {
398 unsigned int ch, i, r, next = 0;
399
400 for (i = 0; i < len; i += r)
401 {
402 if (!(r = get_utf16( str + i, len - i, &ch ))) return;
403 if (i && is_starter( info, ch ))
404 {
405 if (i > next + 1) /* at least two successive non-starters */
406 canonical_order_substring( info, str + next, i - next );
407 next = i + r;
408 }
409 }
410 if (i > next + 1) canonical_order_substring( info, str + next, i - next );
411 }
412
413
414 static NTSTATUS decompose_string( const struct norm_table *info, const WCHAR *src, int src_len,
415 WCHAR *dst, int *dst_len )
416 {
417 BYTE props;
418 int src_pos, dst_pos;
419 unsigned int ch, len, decomp_len;
420 WCHAR buffer[3];
421 const WCHAR *decomp;
422
423 for (src_pos = dst_pos = 0; src_pos < src_len; src_pos += len)
424 {
425 if (!(len = get_utf16( src + src_pos, src_len - src_pos, &ch )))
426 {
427 *dst_len = src_pos + IS_HIGH_SURROGATE( src[src_pos] );
428 return STATUS_NO_UNICODE_TRANSLATION;
429 }
430 props = get_char_props( info, ch );
431 if (!(decomp = get_decomposition( info, ch, props, buffer, &decomp_len )))
432 {
433 /* allow final null */
434 if (!ch && src_pos == src_len - 1 && dst_pos < *dst_len)
435 {
436 dst[dst_pos++] = 0;
437 break;
438 }
439 *dst_len = src_pos;
440 return STATUS_NO_UNICODE_TRANSLATION;
441 }
442 if (dst_pos + decomp_len > *dst_len)
443 {
444 *dst_len += (src_len - src_pos) * info->len_factor;
445 return STATUS_BUFFER_TOO_SMALL;
446 }
447 memcpy( dst + dst_pos, decomp, decomp_len * sizeof(WCHAR) );
448 dst_pos += decomp_len;
449 }
450
451 canonical_order_string( info, dst, dst_pos );
452 *dst_len = dst_pos;
453 return STATUS_SUCCESS;
454 }
455
456
457 static unsigned int compose_hangul( unsigned int ch1, unsigned int ch2 )
458 {
459 if (ch1 >= HANGUL_LBASE && ch1 < HANGUL_LBASE + HANGUL_LCOUNT)
460 {
461 int lindex = ch1 - HANGUL_LBASE;
462 int vindex = ch2 - HANGUL_VBASE;
463 if (vindex >= 0 && vindex < HANGUL_VCOUNT)
464 return HANGUL_SBASE + (lindex * HANGUL_VCOUNT + vindex) * HANGUL_TCOUNT;
465 }
466 if (ch1 >= HANGUL_SBASE && ch1 < HANGUL_SBASE + HANGUL_SCOUNT)
467 {
468 int sindex = ch1 - HANGUL_SBASE;
469 if (!(sindex % HANGUL_TCOUNT))
470 {
471 int tindex = ch2 - HANGUL_TBASE;
472 if (tindex > 0 && tindex < HANGUL_TCOUNT) return ch1 + tindex;
473 }
474 }
475 return 0;
476 }
477
478
479 static unsigned int compose_chars( const struct norm_table *info, unsigned int ch1, unsigned int ch2 )
480 {
481 const USHORT *table = (const USHORT *)info + info->comp_hash;
482 const WCHAR *chars = (const USHORT *)info + info->comp_seq;
483 unsigned int hash, start, end, i, len, ch[3];
484
485 hash = (ch1 + 95 * ch2) % info->comp_size;
486 start = table[hash];
487 end = table[hash + 1];
488 while (start < end)
489 {
490 for (i = 0; i < 3; i++, start += len) len = get_utf16( chars + start, end - start, ch + i );
491 if (ch[0] == ch1 && ch[1] == ch2) return ch[2];
492 }
493 return 0;
494 }
495
496 static unsigned int compose_string( const struct norm_table *info, WCHAR *str, unsigned int srclen )
497 {
498 unsigned int i, ch, comp, len, start_ch = 0, last_starter = srclen;
499 BYTE class, prev_class = 0;
500
501 for (i = 0; i < srclen; i += len)
502 {
503 if (!(len = get_utf16( str + i, srclen - i, &ch ))) return 0;
504 class = get_combining_class( info, ch );
505 if (last_starter == srclen || (prev_class && prev_class >= class) ||
506 (!(comp = compose_hangul( start_ch, ch )) &&
507 !(comp = compose_chars( info, start_ch, ch ))))
508 {
509 if (!class)
510 {
511 last_starter = i;
512 start_ch = ch;
513 }
514 prev_class = class;
515 }
516 else
517 {
518 int comp_len = 1 + (comp >= 0x10000);
519 int start_len = 1 + (start_ch >= 0x10000);
520
521 if (comp_len != start_len)
522 memmove( str + last_starter + comp_len, str + last_starter + start_len,
523 (i - (last_starter + start_len)) * sizeof(WCHAR) );
524 memmove( str + i + comp_len - start_len, str + i + len, (srclen - i - len) * sizeof(WCHAR) );
525 srclen += comp_len - start_len - len;
526 start_ch = comp;
527 i = last_starter;
528 len = comp_len;
529 prev_class = 0;
530 put_utf16( str + i, comp );
531 }
532 }
533 return srclen;
534 }
535
536
537 static NTSTATUS open_nls_data_file( ULONG type, ULONG id, HANDLE *file )
538 {
539 static const WCHAR pathfmtW[] = {'\\','?','?','\\','%','s','%','s',0};
540 static const WCHAR keyfmtW[] =
541 {'\\','R','e','g','i','s','t','r','y','\\','M','a','c','h','i','n','e','\\','S','y','s','t','e','m','\\',
542 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
543 'C','o','n','t','r','o','l','\\','N','l','s','\\','%','s',0};
544 static const WCHAR sortdirW[] = {'C',':','\\','w','i','n','d','o','w','s','\\',
545 'g','l','o','b','a','l','i','z','a','t','i','o','n','\\',
546 's','o','r','t','i','n','g','\\',0};
547 static const WCHAR cpW[] = {'C','o','d','e','p','a','g','e',0};
548 static const WCHAR normW[] = {'N','o','r','m','a','l','i','z','a','t','i','o','n',0};
549 static const WCHAR langW[] = {'L','a','n','g','u','a','g','e',0};
550 static const WCHAR cpfmtW[] = {'%','u',0};
551 static const WCHAR normfmtW[] = {'%','x',0};
552 static const WCHAR langfmtW[] = {'%','0','4','x',0};
553 static const WCHAR winedatadirW[] = {'W','I','N','E','D','A','T','A','D','I','R',0};
554 static const WCHAR winebuilddirW[] = {'W','I','N','E','B','U','I','L','D','D','I','R',0};
555 static const WCHAR dataprefixW[] = {'\\','n','l','s','\\',0};
556 static const WCHAR cpdefaultW[] = {'c','_','%','0','3','d','.','n','l','s',0};
557 static const WCHAR intlW[] = {'l','_','i','n','t','l','.','n','l','s',0};
558 static const WCHAR normnfcW[] = {'n','o','r','m','n','f','c','.','n','l','s',0};
559 static const WCHAR normnfdW[] = {'n','o','r','m','n','f','d','.','n','l','s',0};
560 static const WCHAR normnfkcW[] = {'n','o','r','m','n','f','k','c','.','n','l','s',0};
561 static const WCHAR normnfkdW[] = {'n','o','r','m','n','f','k','d','.','n','l','s',0};
562 static const WCHAR normidnaW[] = {'n','o','r','m','i','d','n','a','.','n','l','s',0};
563 static const WCHAR sortkeysW[] = {'s','o','r','t','d','e','f','a','u','l','t','.','n','l','s',0};
564
565 DWORD size;
566 HANDLE handle;
567 NTSTATUS status = STATUS_OBJECT_NAME_NOT_FOUND;
568 IO_STATUS_BLOCK io;
569 OBJECT_ATTRIBUTES attr;
570 UNICODE_STRING nameW, valueW;
571 WCHAR buffer[MAX_PATH], value[10];
572 const WCHAR *name = NULL, *dir = system_dir;
573 KEY_VALUE_PARTIAL_INFORMATION *info;
574
575 /* get filename from registry */
576
577 switch (type)
578 {
579 case NLS_SECTION_SORTKEYS:
580 if (id) return STATUS_INVALID_PARAMETER_1;
581 buffer[0] = 0;
582 break;
583 case NLS_SECTION_CASEMAP:
584 if (id) return STATUS_UNSUCCESSFUL;
585 swprintf( buffer, ARRAY_SIZE(buffer), keyfmtW, langW );
586 swprintf( value, ARRAY_SIZE(value), langfmtW, LANGIDFROMLCID(system_lcid) );
587 break;
588 case NLS_SECTION_CODEPAGE:
589 swprintf( buffer, ARRAY_SIZE(buffer), keyfmtW, cpW );
590 swprintf( value, ARRAY_SIZE(value), cpfmtW, id );
591 break;
592 case NLS_SECTION_NORMALIZE:
593 swprintf( buffer, ARRAY_SIZE(buffer), keyfmtW, normW );
594 swprintf( value, ARRAY_SIZE(value), normfmtW, id );
595 break;
596 default:
597 return STATUS_INVALID_PARAMETER_1;
598 }
599
600 if (buffer[0])
601 {
602 RtlInitUnicodeString( &nameW, buffer );
603 RtlInitUnicodeString( &valueW, value );
604 InitializeObjectAttributes( &attr, &nameW, 0, 0, NULL );
605 if (!(status = NtOpenKey( &handle, KEY_READ, &attr )))
606 {
607 info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
608 size = sizeof(buffer) - sizeof(WCHAR);
609 if (!(status = NtQueryValueKey( handle, &valueW, KeyValuePartialInformation, info, size, &size )))
610 {
611 ((WCHAR *)info->Data)[info->DataLength / sizeof(WCHAR)] = 0;
612 name = (WCHAR *)info->Data;
613 }
614 NtClose( handle );
615 }
616 }
617
618 if (!name || !*name) /* otherwise some hardcoded defaults */
619 {
620 switch (type)
621 {
622 case NLS_SECTION_SORTKEYS:
623 name = sortkeysW;
624 dir = sortdirW;
625 break;
626 case NLS_SECTION_CASEMAP:
627 name = intlW;
628 break;
629 case NLS_SECTION_CODEPAGE:
630 swprintf( buffer, ARRAY_SIZE(buffer), cpdefaultW, id );
631 name = buffer;
632 break;
633 case NLS_SECTION_NORMALIZE:
634 switch (id)
635 {
636 case NormalizationC: name = normnfcW; break;
637 case NormalizationD: name = normnfdW; break;
638 case NormalizationKC: name = normnfkcW; break;
639 case NormalizationKD: name = normnfkdW; break;
640 case 13: name = normidnaW; break;
641 }
642 break;
643 }
644 if (!name) return status;
645 }
646
647 /* try to open file in system dir */
648
649 valueW.MaximumLength = (wcslen(name) + wcslen(dir) + 5) * sizeof(WCHAR);
650 if (!(valueW.Buffer = RtlAllocateHeap( GetProcessHeap(), 0, valueW.MaximumLength )))
651 return STATUS_NO_MEMORY;
652 valueW.Length = swprintf( valueW.Buffer, valueW.MaximumLength/sizeof(WCHAR),
653 pathfmtW, dir, name ) * sizeof(WCHAR);
654 InitializeObjectAttributes( &attr, &valueW, 0, 0, NULL );
655 status = NtOpenFile( file, GENERIC_READ, &attr, &io, FILE_SHARE_READ, FILE_SYNCHRONOUS_IO_ALERT );
656 if (!status) TRACE( "found %s\n", debugstr_w( valueW.Buffer ));
657 RtlFreeUnicodeString( &valueW );
658 if (status != STATUS_OBJECT_NAME_NOT_FOUND && status != STATUS_OBJECT_PATH_NOT_FOUND) return status;
659
660 /* not found, try in build or data dir */
661
662 RtlInitUnicodeString( &nameW, winebuilddirW );
663 valueW.MaximumLength = 0;
664 if (RtlQueryEnvironmentVariable_U( NULL, &nameW, &valueW ) != STATUS_BUFFER_TOO_SMALL)
665 {
666 RtlInitUnicodeString( &nameW, winedatadirW );
667 if (RtlQueryEnvironmentVariable_U( NULL, &nameW, &valueW ) != STATUS_BUFFER_TOO_SMALL)
668 return status;
669 }
670 valueW.MaximumLength = valueW.Length + sizeof(dataprefixW) + wcslen(name) * sizeof(WCHAR);
671 if (!(valueW.Buffer = RtlAllocateHeap( GetProcessHeap(), 0, valueW.MaximumLength )))
672 return STATUS_NO_MEMORY;
673 if (!RtlQueryEnvironmentVariable_U( NULL, &nameW, &valueW ))
674 {
675 wcscat( valueW.Buffer, dataprefixW );
676 wcscat( valueW.Buffer, name );
677 valueW.Length = wcslen(valueW.Buffer) * sizeof(WCHAR);
678 InitializeObjectAttributes( &attr, &valueW, 0, 0, NULL );
679 status = NtOpenFile( file, GENERIC_READ, &attr, &io, FILE_SHARE_READ, FILE_SYNCHRONOUS_IO_ALERT );
680 if (!status) TRACE( "found %s\n", debugstr_w( valueW.Buffer ));
681 }
682 RtlFreeUnicodeString( &valueW );
683 return status;
684 }
685
686
687 void init_unix_codepage(void)
688 {
689 USHORT *data = unix_funcs->get_unix_codepage_data();
690 if (data) RtlInitCodePageTable( data, &unix_table );
691 }
692
693
694 static LCID locale_to_lcid( WCHAR *win_name )
695 {
696 WCHAR *p;
697 LCID lcid;
698
699 if (!RtlLocaleNameToLcid( win_name, &lcid, 0 )) return lcid;
700
701 /* try neutral name */
702 if ((p = wcsrchr( win_name, '-' )))
703 {
704 *p = 0;
705 if (!RtlLocaleNameToLcid( win_name, &lcid, 2 ))
706 {
707 if (SUBLANGID(lcid) == SUBLANG_NEUTRAL)
708 lcid = MAKELANGID( PRIMARYLANGID(lcid), SUBLANG_DEFAULT );
709 return lcid;
710 }
711 }
712 return 0;
713 }
714
715
716 /******************************************************************
717 * init_locale
718 */
719 void init_locale( HMODULE module )
720 {
721 WCHAR system_locale[LOCALE_NAME_MAX_LENGTH];
722 WCHAR user_locale[LOCALE_NAME_MAX_LENGTH];
723
724 kernel32_handle = module;
725
726 unix_funcs->get_locales( system_locale, user_locale );
727 system_lcid = locale_to_lcid( system_locale );
728 user_lcid = locale_to_lcid( user_locale );
729 if (!system_lcid) system_lcid = MAKELCID( MAKELANGID(LANG_ENGLISH,SUBLANG_DEFAULT), SORT_DEFAULT );
730 if (!user_lcid) user_lcid = system_lcid;
731
732 NtSetDefaultUILanguage( LANGIDFROMLCID(user_lcid) );
733 NtSetDefaultLocale( TRUE, user_lcid );
734 NtSetDefaultLocale( FALSE, system_lcid );
735 TRACE( "system=%04x user=%04x\n", system_lcid, user_lcid );
736 }
737
738
739 /******************************************************************
740 * ntdll_umbstowcs
741 */
742 DWORD ntdll_umbstowcs( const char *src, DWORD srclen, WCHAR *dst, DWORD dstlen )
743 {
744 DWORD reslen;
745
746 if (unix_table.CodePage)
747 RtlCustomCPToUnicodeN( &unix_table, dst, dstlen * sizeof(WCHAR), &reslen, src, srclen );
748 else
749 RtlUTF8ToUnicodeN( dst, dstlen * sizeof(WCHAR), &reslen, src, srclen );
750 return reslen / sizeof(WCHAR);
751 }
752
753
754 /******************************************************************
755 * ntdll_wcstoumbs
756 */
757 int ntdll_wcstoumbs( const WCHAR *src, DWORD srclen, char *dst, DWORD dstlen, BOOL strict )
758 {
759 DWORD i, reslen;
760
761 if (!unix_table.CodePage)
762 RtlUnicodeToUTF8N( dst, dstlen, &reslen, src, srclen * sizeof(WCHAR) );
763 else if (!strict)
764 RtlUnicodeToCustomCPN( &unix_table, dst, dstlen, &reslen, src, srclen * sizeof(WCHAR) );
765 else /* do it by hand to make sure every character roundtrips correctly */
766 {
767 if (unix_table.DBCSOffsets)
768 {
769 const unsigned short *uni2cp = unix_table.WideCharTable;
770 for (i = dstlen; srclen && i; i--, srclen--, src++)
771 {
772 unsigned short ch = uni2cp[*src];
773 if (ch >> 8)
774 {
775 if (unix_table.DBCSOffsets[unix_table.DBCSOffsets[ch >> 8] + (ch & 0xff)] != *src)
776 return -1;
777 if (i == 1) break; /* do not output a partial char */
778 i--;
779 *dst++ = ch >> 8;
780 }
781 else
782 {
783 if (unix_table.MultiByteTable[ch] != *src) return -1;
784 *dst++ = (char)ch;
785 }
786 }
787 reslen = dstlen - i;
788 }
789 else
790 {
791 const unsigned char *uni2cp = unix_table.WideCharTable;
792 reslen = min( srclen, dstlen );
793 for (i = 0; i < reslen; i++)
794 {
795 unsigned char ch = uni2cp[src[i]];
796 if (unix_table.MultiByteTable[ch] != src[i]) return -1;
797 dst[i] = ch;
798 }
799 }
800 }
801 return reslen;
802 }
803
804
805 /******************************************************************
806 * __wine_get_unix_codepage (NTDLL.@)
807 */
808 UINT CDECL __wine_get_unix_codepage(void)
809 {
810 if (!unix_table.CodePage) return CP_UTF8;
811 return unix_table.CodePage;
812 }
813
814
815 static NTSTATUS get_dummy_preferred_ui_language( DWORD flags, LANGID lang, ULONG *count,
816 WCHAR *buffer, ULONG *size )
817 {
818 WCHAR name[LOCALE_NAME_MAX_LENGTH + 2];
819 NTSTATUS status;
820 ULONG len;
821
822 FIXME("(0x%x %p %p %p) returning a dummy value (current locale)\n", flags, count, buffer, size);
823
824 status = load_string( (flags & MUI_LANGUAGE_ID) ? LOCALE_ILANGUAGE : LOCALE_SNAME,
825 lang, name, ARRAY_SIZE(name) );
826 if (status) return status;
827
828 len = wcslen( name ) + 2;
829 name[len - 1] = 0;
830 if (buffer)
831 {
832 if (len > *size)
833 {
834 *size = len;
835 return STATUS_BUFFER_TOO_SMALL;
836 }
837 memcpy( buffer, name, len * sizeof(WCHAR) );
838 }
839 *size = len;
840 *count = 1;
841 TRACE("returned variable content: %d, \"%s\", %d\n", *count, debugstr_w(buffer), *size);
842 return STATUS_SUCCESS;
843
844 }
845
846 /**************************************************************************
847 * RtlGetProcessPreferredUILanguages (NTDLL.@)
848 */
849 NTSTATUS WINAPI RtlGetProcessPreferredUILanguages( DWORD flags, ULONG *count, WCHAR *buffer, ULONG *size )
850 {
851 LANGID ui_language;
852
853 FIXME( "%08x, %p, %p %p\n", flags, count, buffer, size );
854
855 NtQueryDefaultUILanguage( &ui_language );
856 return get_dummy_preferred_ui_language( flags, ui_language, count, buffer, size );
857 }
858
859
860 /**************************************************************************
861 * RtlGetSystemPreferredUILanguages (NTDLL.@)
862 */
863 NTSTATUS WINAPI RtlGetSystemPreferredUILanguages( DWORD flags, ULONG unknown, ULONG *count,
864 WCHAR *buffer, ULONG *size )
865 {
866 LANGID ui_language;
867
868 if (flags & ~(MUI_LANGUAGE_NAME | MUI_LANGUAGE_ID | MUI_MACHINE_LANGUAGE_SETTINGS)) return STATUS_INVALID_PARAMETER;
869 if ((flags & MUI_LANGUAGE_NAME) && (flags & MUI_LANGUAGE_ID)) return STATUS_INVALID_PARAMETER;
870 if (*size && !buffer) return STATUS_INVALID_PARAMETER;
871
872 NtQueryInstallUILanguage( &ui_language );
873 return get_dummy_preferred_ui_language( flags, ui_language, count, buffer, size );
874 }
875
876
877 /**************************************************************************
878 * RtlGetThreadPreferredUILanguages (NTDLL.@)
879 */
880 NTSTATUS WINAPI RtlGetThreadPreferredUILanguages( DWORD flags, ULONG *count, WCHAR *buffer, ULONG *size )
881 {
882 LANGID ui_language;
883
884 FIXME( "%08x, %p, %p %p\n", flags, count, buffer, size );
885
886 NtQueryDefaultUILanguage( &ui_language );
887 return get_dummy_preferred_ui_language( flags, ui_language, count, buffer, size );
888 }
889
890
891 /**************************************************************************
892 * RtlGetUserPreferredUILanguages (NTDLL.@)
893 */
894 NTSTATUS WINAPI RtlGetUserPreferredUILanguages( DWORD flags, ULONG unknown, ULONG *count,
895 WCHAR *buffer, ULONG *size )
896 {
897 LANGID ui_language;
898
899 if (flags & ~(MUI_LANGUAGE_NAME | MUI_LANGUAGE_ID)) return STATUS_INVALID_PARAMETER;
900 if ((flags & MUI_LANGUAGE_NAME) && (flags & MUI_LANGUAGE_ID)) return STATUS_INVALID_PARAMETER;
901 if (*size && !buffer) return STATUS_INVALID_PARAMETER;
902
903 NtQueryDefaultUILanguage( &ui_language );
904 return get_dummy_preferred_ui_language( flags, ui_language, count, buffer, size );
905 }
906
907
908 /**************************************************************************
909 * RtlSetProcessPreferredUILanguages (NTDLL.@)
910 */
911 NTSTATUS WINAPI RtlSetProcessPreferredUILanguages( DWORD flags, PCZZWSTR buffer, ULONG *count )
912 {
913 FIXME( "%u, %p, %p\n", flags, buffer, count );
914 return STATUS_SUCCESS;
915 }
916
917
918 /**************************************************************************
919 * RtlSetThreadPreferredUILanguages (NTDLL.@)
920 */
921 NTSTATUS WINAPI RtlSetThreadPreferredUILanguages( DWORD flags, PCZZWSTR buffer, ULONG *count )
922 {
923 FIXME( "%u, %p, %p\n", flags, buffer, count );
924 return STATUS_SUCCESS;
925 }
926
927
928 /**************************************************************************
929 * NtGetNlsSectionPtr (NTDLL.@)
930 */
931 NTSTATUS WINAPI NtGetNlsSectionPtr( ULONG type, ULONG id, void *unknown, void **ptr, SIZE_T *size )
932 {
933 FILE_END_OF_FILE_INFORMATION info;
934 IO_STATUS_BLOCK io;
935 HANDLE file;
936 NTSTATUS status;
937
938 if ((status = open_nls_data_file( type, id, &file ))) return status;
939
940 if ((status = NtQueryInformationFile( file, &io, &info, sizeof(info), FileEndOfFileInformation )))
941 goto done;
942 /* FIXME: return a heap block instead of a file mapping for now */
943 if (!(*ptr = RtlAllocateHeap( GetProcessHeap(), 0, info.EndOfFile.QuadPart )))
944 {
945 status = STATUS_NO_MEMORY;
946 goto done;
947 }
948 status = NtReadFile( file, 0, NULL, NULL, &io, *ptr, info.EndOfFile.QuadPart, NULL, NULL );
949 if (!status && io.Information != info.EndOfFile.QuadPart) status = STATUS_INVALID_FILE_FOR_SECTION;
950 if (!status) *size = io.Information;
951 else RtlFreeHeap( GetProcessHeap(), 0, *ptr );
952 done:
953 NtClose( file );
954 return status;
955 }
956
957
958 /******************************************************************
959 * RtlInitCodePageTable (NTDLL.@)
960 */
961 void WINAPI RtlInitCodePageTable( USHORT *ptr, CPTABLEINFO *info )
962 {
963 USHORT hdr_size = ptr[0];
964
965 info->CodePage = ptr[1];
966 info->MaximumCharacterSize = ptr[2];
967 info->DefaultChar = ptr[3];
968 info->UniDefaultChar = ptr[4];
969 info->TransDefaultChar = ptr[5];
970 info->TransUniDefaultChar = ptr[6];
971 memcpy( info->LeadByte, ptr + 7, sizeof(info->LeadByte) );
972 ptr += hdr_size;
973
974 info->WideCharTable = ptr + ptr[0] + 1;
975 info->MultiByteTable = ++ptr;
976 ptr += 256;
977 if (*ptr++) ptr += 256; /* glyph table */
978 info->DBCSRanges = ptr;
979 if (*ptr) /* dbcs ranges */
980 {
981 info->DBCSCodePage = 1;
982 info->DBCSOffsets = ptr + 1;
983 }
984 else
985 {
986 info->DBCSCodePage = 0;
987 info->DBCSOffsets = NULL;
988 }
989 }
990
991
992 /**************************************************************************
993 * RtlInitNlsTables (NTDLL.@)
994 */
995 void WINAPI RtlInitNlsTables( USHORT *ansi, USHORT *oem, USHORT *casetable, NLSTABLEINFO *info )
996 {
997 RtlInitCodePageTable( ansi, &info->AnsiTableInfo );
998 RtlInitCodePageTable( oem, &info->OemTableInfo );
999 info->UpperCaseTable = casetable + 2;
1000 info->LowerCaseTable = casetable + casetable[1] + 2;
1001 }
1002
1003
1004 /**************************************************************************
1005 * RtlResetRtlTranslations (NTDLL.@)
1006 */
1007 void WINAPI RtlResetRtlTranslations( const NLSTABLEINFO *info )
1008 {
1009 NlsAnsiCodePage = info->AnsiTableInfo.CodePage;
1010 NlsMbCodePageTag = info->AnsiTableInfo.DBCSCodePage;
1011 NlsMbOemCodePageTag = info->OemTableInfo.DBCSCodePage;
1012 nls_info = *info;
1013 }
1014
1015
1016 /**************************************************************************
1017 * RtlAnsiCharToUnicodeChar (NTDLL.@)
1018 */
1019 WCHAR WINAPI RtlAnsiCharToUnicodeChar( char **ansi )
1020 {
1021 if (nls_info.AnsiTableInfo.DBCSOffsets)
1022 {
1023 USHORT off = nls_info.AnsiTableInfo.DBCSOffsets[(unsigned char)**ansi];
1024 if (off)
1025 {
1026 (*ansi)++;
1027 return nls_info.AnsiTableInfo.DBCSOffsets[off + (unsigned char)*(*ansi)++];
1028 }
1029 }
1030 return nls_info.AnsiTableInfo.MultiByteTable[(unsigned char)*(*ansi)++];
1031 }
1032
1033
1034 /******************************************************************************
1035 * RtlCompareUnicodeStrings (NTDLL.@)
1036 */
1037 LONG WINAPI RtlCompareUnicodeStrings( const WCHAR *s1, SIZE_T len1, const WCHAR *s2, SIZE_T len2,
1038 BOOLEAN case_insensitive )
1039 {
1040 LONG ret = 0;
1041 SIZE_T len = min( len1, len2 );
1042
1043 if (case_insensitive)
1044 {
1045 if (nls_info.UpperCaseTable)
1046 {
1047 while (!ret && len--) ret = casemap( nls_info.UpperCaseTable, *s1++ ) -
1048 casemap( nls_info.UpperCaseTable, *s2++ );
1049 }
1050 else /* locale not setup yet */
1051 {
1052 while (!ret && len--) ret = casemap_ascii( *s1++ ) - casemap_ascii( *s2++ );
1053 }
1054 }
1055 else
1056 {
1057 while (!ret && len--) ret = *s1++ - *s2++;
1058 }
1059 if (!ret) ret = len1 - len2;
1060 return ret;
1061 }
1062
1063
1064 /**************************************************************************
1065 * RtlPrefixUnicodeString (NTDLL.@)
1066 */
1067 BOOLEAN WINAPI RtlPrefixUnicodeString( const UNICODE_STRING *s1, const UNICODE_STRING *s2,
1068 BOOLEAN ignore_case )
1069 {
1070 unsigned int i;
1071
1072 if (s1->Length > s2->Length) return FALSE;
1073 if (ignore_case)
1074 {
1075 for (i = 0; i < s1->Length / sizeof(WCHAR); i++)
1076 if (casemap( nls_info.UpperCaseTable, s1->Buffer[i] ) !=
1077 casemap( nls_info.UpperCaseTable, s2->Buffer[i] )) return FALSE;
1078 }
1079 else
1080 {
1081 for (i = 0; i < s1->Length / sizeof(WCHAR); i++)
1082 if (s1->Buffer[i] != s2->Buffer[i]) return FALSE;
1083 }
1084 return TRUE;
1085 }
1086
1087
1088
1089 /******************************************************************************
1090 * RtlHashUnicodeString (NTDLL.@)
1091 */
1092 NTSTATUS WINAPI RtlHashUnicodeString( const UNICODE_STRING *string, BOOLEAN case_insensitive,
1093 ULONG alg, ULONG *hash )
1094 {
1095 unsigned int i;
1096
1097 if (!string || !hash) return STATUS_INVALID_PARAMETER;
1098
1099 switch (alg)
1100 {
1101 case HASH_STRING_ALGORITHM_DEFAULT:
1102 case HASH_STRING_ALGORITHM_X65599:
1103 break;
1104 default:
1105 return STATUS_INVALID_PARAMETER;
1106 }
1107
1108 *hash = 0;
1109 if (!case_insensitive)
1110 for (i = 0; i < string->Length / sizeof(WCHAR); i++)
1111 *hash = *hash * 65599 + string->Buffer[i];
1112 else if (nls_info.UpperCaseTable)
1113 for (i = 0; i < string->Length / sizeof(WCHAR); i++)
1114 *hash = *hash * 65599 + casemap( nls_info.UpperCaseTable, string->Buffer[i] );
1115 else /* locale not setup yet */
1116 for (i = 0; i < string->Length / sizeof(WCHAR); i++)
1117 *hash = *hash * 65599 + casemap_ascii( string->Buffer[i] );
1118 return STATUS_SUCCESS;
1119 }
1120
1121
1122 /**************************************************************************
1123 * RtlCustomCPToUnicodeN (NTDLL.@)
1124 */
1125 NTSTATUS WINAPI RtlCustomCPToUnicodeN( CPTABLEINFO *info, WCHAR *dst, DWORD dstlen, DWORD *reslen,
1126 const char *src, DWORD srclen )
1127 {
1128 DWORD i, ret;
1129
1130 dstlen /= sizeof(WCHAR);
1131 if (info->DBCSOffsets)
1132 {
1133 for (i = dstlen; srclen && i; i--, srclen--, src++, dst++)
1134 {
1135 USHORT off = info->DBCSOffsets[(unsigned char)*src];
1136 if (off && srclen > 1)
1137 {
1138 src++;
1139 srclen--;
1140 *dst = info->DBCSOffsets[off + (unsigned char)*src];
1141 }
1142 else *dst = info->MultiByteTable[(unsigned char)*src];
1143 }
1144 ret = dstlen - i;
1145 }
1146 else
1147 {
1148 ret = min( srclen, dstlen );
1149 for (i = 0; i < ret; i++) dst[i] = info->MultiByteTable[(unsigned char)src[i]];
1150 }
1151 if (reslen) *reslen = ret * sizeof(WCHAR);
1152 return STATUS_SUCCESS;
1153 }
1154
1155
1156 /**************************************************************************
1157 * RtlUnicodeToCustomCPN (NTDLL.@)
1158 */
1159 NTSTATUS WINAPI RtlUnicodeToCustomCPN( CPTABLEINFO *info, char *dst, DWORD dstlen, DWORD *reslen,
1160 const WCHAR *src, DWORD srclen )
1161 {
1162 DWORD i, ret;
1163
1164 srclen /= sizeof(WCHAR);
1165 if (info->DBCSCodePage)
1166 {
1167 WCHAR *uni2cp = info->WideCharTable;
1168
1169 for (i = dstlen; srclen && i; i--, srclen--, src++)
1170 {
1171 if (uni2cp[*src] & 0xff00)
1172 {
1173 if (i == 1) break; /* do not output a partial char */
1174 i--;
1175 *dst++ = uni2cp[*src] >> 8;
1176 }
1177 *dst++ = (char)uni2cp[*src];
1178 }
1179 ret = dstlen - i;
1180 }
1181 else
1182 {
1183 char *uni2cp = info->WideCharTable;
1184 ret = min( srclen, dstlen );
1185 for (i = 0; i < ret; i++) dst[i] = uni2cp[src[i]];
1186 }
1187 if (reslen) *reslen = ret;
1188 return STATUS_SUCCESS;
1189 }
1190
1191
1192 /**************************************************************************
1193 * RtlMultiByteToUnicodeN (NTDLL.@)
1194 */
1195 NTSTATUS WINAPI RtlMultiByteToUnicodeN( WCHAR *dst, DWORD dstlen, DWORD *reslen,
1196 const char *src, DWORD srclen )
1197 {
1198 if (nls_info.AnsiTableInfo.WideCharTable)
1199 return RtlCustomCPToUnicodeN( &nls_info.AnsiTableInfo, dst, dstlen, reslen, src, srclen );
1200
1201 /* locale not setup yet */
1202 dstlen = min( srclen, dstlen / sizeof(WCHAR) );
1203 if (reslen) *reslen = dstlen * sizeof(WCHAR);
1204 while (dstlen--) *dst++ = *src++ & 0x7f;
1205 return STATUS_SUCCESS;
1206 }
1207
1208
1209 /**************************************************************************
1210 * RtlMultiByteToUnicodeSize (NTDLL.@)
1211 */
1212 NTSTATUS WINAPI RtlMultiByteToUnicodeSize( DWORD *size, const char *str, DWORD len )
1213 {
1214 *size = mbtowc_size( &nls_info.AnsiTableInfo, str, len ) * sizeof(WCHAR);
1215 return STATUS_SUCCESS;
1216 }
1217
1218
1219 /**************************************************************************
1220 * RtlOemToUnicodeN (NTDLL.@)
1221 */
1222 NTSTATUS WINAPI RtlOemToUnicodeN( WCHAR *dst, DWORD dstlen, DWORD *reslen,
1223 const char *src, DWORD srclen )
1224 {
1225 return RtlCustomCPToUnicodeN( &nls_info.OemTableInfo, dst, dstlen, reslen, src, srclen );
1226 }
1227
1228
1229 /**************************************************************************
1230 * RtlOemStringToUnicodeSize (NTDLL.@)
1231 * RtlxOemStringToUnicodeSize (NTDLL.@)
1232 */
1233 DWORD WINAPI RtlOemStringToUnicodeSize( const STRING *str )
1234 {
1235 return (mbtowc_size( &nls_info.OemTableInfo, str->Buffer, str->Length ) + 1) * sizeof(WCHAR);
1236 }
1237
1238
1239 /**************************************************************************
1240 * RtlUnicodeStringToOemSize (NTDLL.@)
1241 * RtlxUnicodeStringToOemSize (NTDLL.@)
1242 */
1243 DWORD WINAPI RtlUnicodeStringToOemSize( const UNICODE_STRING *str )
1244 {
1245 return wctomb_size( &nls_info.OemTableInfo, str->Buffer, str->Length / sizeof(WCHAR) ) + 1;
1246 }
1247
1248
1249 /**************************************************************************
1250 * RtlUnicodeToMultiByteN (NTDLL.@)
1251 */
1252 NTSTATUS WINAPI RtlUnicodeToMultiByteN( char *dst, DWORD dstlen, DWORD *reslen,
1253 const WCHAR *src, DWORD srclen )
1254 {
1255 if (nls_info.AnsiTableInfo.WideCharTable)
1256 return RtlUnicodeToCustomCPN( &nls_info.AnsiTableInfo, dst, dstlen, reslen, src, srclen );
1257
1258 /* locale not setup yet */
1259 dstlen = min( srclen / sizeof(WCHAR), dstlen );
1260 if (reslen) *reslen = dstlen;
1261 while (dstlen--)
1262 {
1263 WCHAR ch = *src++;
1264 if (ch > 0x7f) ch = '?';
1265 *dst++ = ch;
1266 }
1267 return STATUS_SUCCESS;
1268 }
1269
1270
1271 /**************************************************************************
1272 * RtlUnicodeToMultiByteSize (NTDLL.@)
1273 */
1274 NTSTATUS WINAPI RtlUnicodeToMultiByteSize( DWORD *size, const WCHAR *str, DWORD len )
1275 {
1276 *size = wctomb_size( &nls_info.AnsiTableInfo, str, len / sizeof(WCHAR) );
1277 return STATUS_SUCCESS;
1278 }
1279
1280
1281 /**************************************************************************
1282 * RtlUnicodeToOemN (NTDLL.@)
1283 */
1284 NTSTATUS WINAPI RtlUnicodeToOemN( char *dst, DWORD dstlen, DWORD *reslen,
1285 const WCHAR *src, DWORD srclen )
1286 {
1287 return RtlUnicodeToCustomCPN( &nls_info.OemTableInfo, dst, dstlen, reslen, src, srclen );
1288 }
1289
1290
1291 /**************************************************************************
1292 * RtlDowncaseUnicodeChar (NTDLL.@)
1293 */
1294 WCHAR WINAPI RtlDowncaseUnicodeChar( WCHAR wch )
1295 {
1296 if (nls_info.LowerCaseTable) return casemap( nls_info.LowerCaseTable, wch );
1297 if (wch >= 'A' && wch <= 'Z') wch += 'a' - 'A';
1298 return wch;
1299 }
1300
1301
1302 /**************************************************************************
1303 * RtlDowncaseUnicodeString (NTDLL.@)
1304 */
1305 NTSTATUS WINAPI RtlDowncaseUnicodeString( UNICODE_STRING *dest, const UNICODE_STRING *src,
1306 BOOLEAN alloc )
1307 {
1308 DWORD i, len = src->Length;
1309
1310 if (alloc)
1311 {
1312 dest->MaximumLength = len;
1313 if (!(dest->Buffer = RtlAllocateHeap( GetProcessHeap(), 0, len ))) return STATUS_NO_MEMORY;
1314 }
1315 else if (len > dest->MaximumLength) return STATUS_BUFFER_OVERFLOW;
1316
1317 for (i = 0; i < len / sizeof(WCHAR); i++)
1318 dest->Buffer[i] = casemap( nls_info.LowerCaseTable, src->Buffer[i] );
1319 dest->Length = len;
1320 return STATUS_SUCCESS;
1321 }
1322
1323
1324 /**************************************************************************
1325 * RtlUpcaseUnicodeChar (NTDLL.@)
1326 */
1327 WCHAR WINAPI RtlUpcaseUnicodeChar( WCHAR wch )
1328 {
1329 return casemap( nls_info.UpperCaseTable, wch );
1330 }
1331
1332
1333 /**************************************************************************
1334 * RtlUpcaseUnicodeString (NTDLL.@)
1335 */
1336 NTSTATUS WINAPI RtlUpcaseUnicodeString( UNICODE_STRING *dest, const UNICODE_STRING *src,
1337 BOOLEAN alloc )
1338 {
1339 DWORD i, len = src->Length;
1340
1341 if (alloc)
1342 {
1343 dest->MaximumLength = len;
1344 if (!(dest->Buffer = RtlAllocateHeap( GetProcessHeap(), 0, len ))) return STATUS_NO_MEMORY;
1345 }
1346 else if (len > dest->MaximumLength) return STATUS_BUFFER_OVERFLOW;
1347
1348 for (i = 0; i < len / sizeof(WCHAR); i++)
1349 dest->Buffer[i] = casemap( nls_info.UpperCaseTable, src->Buffer[i] );
1350 dest->Length = len;
1351 return STATUS_SUCCESS;
1352 }
1353
1354
1355 /**************************************************************************
1356 * RtlUpcaseUnicodeToCustomCPN (NTDLL.@)
1357 */
1358 NTSTATUS WINAPI RtlUpcaseUnicodeToCustomCPN( CPTABLEINFO *info, char *dst, DWORD dstlen, DWORD *reslen,
1359 const WCHAR *src, DWORD srclen )
1360 {
1361 DWORD i, ret;
1362
1363 srclen /= sizeof(WCHAR);
1364 if (info->DBCSCodePage)
1365 {
1366 WCHAR *uni2cp = info->WideCharTable;
1367
1368 for (i = dstlen; srclen && i; i--, srclen--, src++)
1369 {
1370 WCHAR ch = casemap( nls_info.UpperCaseTable, *src );
1371 if (uni2cp[ch] & 0xff00)
1372 {
1373 if (i == 1) break; /* do not output a partial char */
1374 i--;
1375 *dst++ = uni2cp[ch] >> 8;
1376 }
1377 *dst++ = (char)uni2cp[ch];
1378 }
1379 ret = dstlen - i;
1380 }
1381 else
1382 {
1383 char *uni2cp = info->WideCharTable;
1384 ret = min( srclen, dstlen );
1385 for (i = 0; i < ret; i++) dst[i] = uni2cp[casemap( nls_info.UpperCaseTable, src[i] )];
1386 }
1387 if (reslen) *reslen = ret;
1388 return STATUS_SUCCESS;
1389 }
1390
1391
1392 /**************************************************************************
1393 * RtlUpcaseUnicodeToMultiByteN (NTDLL.@)
1394 */
1395 NTSTATUS WINAPI RtlUpcaseUnicodeToMultiByteN( char *dst, DWORD dstlen, DWORD *reslen,
1396 const WCHAR *src, DWORD srclen )
1397 {
1398 return RtlUpcaseUnicodeToCustomCPN( &nls_info.AnsiTableInfo, dst, dstlen, reslen, src, srclen );
1399 }
1400
1401
1402 /**************************************************************************
1403 * RtlUpcaseUnicodeToOemN (NTDLL.@)
1404 */
1405 NTSTATUS WINAPI RtlUpcaseUnicodeToOemN( char *dst, DWORD dstlen, DWORD *reslen,
1406 const WCHAR *src, DWORD srclen )
1407 {
1408 if (nls_info.OemTableInfo.WideCharTable)
1409 return RtlUpcaseUnicodeToCustomCPN( &nls_info.OemTableInfo, dst, dstlen, reslen, src, srclen );
1410
1411 /* locale not setup yet */
1412 dstlen = min( srclen / sizeof(WCHAR), dstlen );
1413 if (reslen) *reslen = dstlen;
1414 while (dstlen--)
1415 {
1416 WCHAR ch = *src++;
1417 if (ch > 0x7f) ch = '?';
1418 else ch = casemap_ascii( ch );
1419 *dst++ = ch;
1420 }
1421 return STATUS_SUCCESS;
1422 }
1423
1424
1425 /*********************************************************************
1426 * towlower (NTDLL.@)
1427 */
1428 WCHAR __cdecl towlower( WCHAR ch )
1429 {
1430 if (ch >= 0x100) return ch;
1431 return casemap( nls_info.LowerCaseTable, ch );
1432 }
1433
1434
1435 /*********************************************************************
1436 * towupper (NTDLL.@)
1437 */
1438 WCHAR __cdecl towupper( WCHAR ch )
1439 {
1440 if (nls_info.UpperCaseTable) return casemap( nls_info.UpperCaseTable, ch );
1441 return casemap_ascii( ch );
1442 }
1443
1444
1445 /******************************************************************
1446 * RtlLocaleNameToLcid (NTDLL.@)
1447 */
1448 NTSTATUS WINAPI RtlLocaleNameToLcid( const WCHAR *name, LCID *lcid, ULONG flags )
1449 {
1450 /* locale name format is: lang[-script][-country][_modifier] */
1451
1452 static const WCHAR sepW[] = {'-','_',0};
1453
1454 const IMAGE_RESOURCE_DIRECTORY *resdir;
1455 const IMAGE_RESOURCE_DIRECTORY_ENTRY *et;
1456 LDR_RESOURCE_INFO info;
1457 WCHAR buf[LOCALE_NAME_MAX_LENGTH];
1458 WCHAR lang[LOCALE_NAME_MAX_LENGTH]; /* language ("en") (note: buffer contains the other strings too) */
1459 WCHAR *country = NULL; /* country ("US") */
1460 WCHAR *script = NULL; /* script ("Latn") */
1461 WCHAR *p;
1462 int i;
1463
1464 if (!name) return STATUS_INVALID_PARAMETER_1;
1465
1466 if (!name[0])
1467 {
1468 *lcid = LANG_INVARIANT;
1469 goto found;
1470 }
1471 if (wcslen( name ) >= LOCALE_NAME_MAX_LENGTH) return STATUS_INVALID_PARAMETER_1;
1472 wcscpy( lang, name );
1473
1474 if ((p = wcspbrk( lang, sepW )) && *p == '-')
1475 {
1476 *p++ = 0;
1477 country = p;
1478 if ((p = wcspbrk( p, sepW )) && *p == '-')
1479 {
1480 *p++ = 0;
1481 script = country;
1482 country = p;
1483 p = wcspbrk( p, sepW );
1484 }
1485 if (p) *p = 0; /* FIXME: modifier is ignored */
1486 /* second value can be script or country, check length to resolve the ambiguity */
1487 if (!script && wcslen( country ) == 4)
1488 {
1489 script = country;
1490 country = NULL;
1491 }
1492 }
1493
1494 info.Type = 6; /* RT_STRING */
1495 info.Name = (LOCALE_SNAME >> 4) + 1;
1496 if (LdrFindResourceDirectory_U( kernel32_handle, &info, 2, &resdir ))
1497 return STATUS_INVALID_PARAMETER_1;
1498
1499 et = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resdir + 1);
1500 for (i = 0; i < resdir->NumberOfNamedEntries + resdir->NumberOfIdEntries; i++)
1501 {
1502 LANGID id = et[i].u.Id;
1503
1504 if (PRIMARYLANGID(id) == LANG_NEUTRAL) continue;
1505
1506 if (!load_string( LOCALE_SNAME, id, buf, ARRAY_SIZE(buf) ) && !wcsicmp( name, buf ))
1507 {
1508 *lcid = MAKELCID( id, SORT_DEFAULT ); /* FIXME: handle sort order */
1509 goto found;
1510 }
1511
1512 if (load_string( LOCALE_SISO639LANGNAME, id, buf, ARRAY_SIZE(buf) ) || wcsicmp( lang, buf ))
1513 continue;
1514
1515 if (script)
1516 {
1517 unsigned int len = wcslen( script );
1518 if (load_string( LOCALE_SSCRIPTS, id, buf, ARRAY_SIZE(buf) )) continue;
1519 p = buf;
1520 while (*p)
1521 {
1522 if (!wcsnicmp( p, script, len ) && (!p[len] || p[len] == ';')) break;
1523 if (!(p = wcschr( p, ';'))) break;
1524 p++;
1525 }
1526 if (!p || !*p) continue;
1527 }
1528
1529 if (!country && (flags & 2))
1530 {
1531 if (!script) id = MAKELANGID( PRIMARYLANGID(id), LANG_NEUTRAL );
1532 switch (id)
1533 {
1534 case MAKELANGID( LANG_CHINESE, SUBLANG_NEUTRAL ):
1535 case MAKELANGID( LANG_CHINESE, SUBLANG_CHINESE_SINGAPORE ):
1536 *lcid = MAKELCID( 0x7804, SORT_DEFAULT );
1537 break;
1538 case MAKELANGID( LANG_CHINESE, SUBLANG_CHINESE_TRADITIONAL ):
1539 case MAKELANGID( LANG_CHINESE, SUBLANG_CHINESE_MACAU ):
1540 case MAKELANGID( LANG_CHINESE, SUBLANG_CHINESE_HONGKONG ):
1541 *lcid = MAKELCID( 0x7c04, SORT_DEFAULT );
1542 break;
1543 default:
1544 *lcid = MAKELANGID( PRIMARYLANGID(id), SUBLANG_NEUTRAL );
1545 break;
1546 }
1547 goto found;
1548 }
1549 }
1550 return STATUS_INVALID_PARAMETER_1;
1551
1552 found:
1553 TRACE( "%s -> %04x\n", debugstr_w(name), *lcid );
1554 return STATUS_SUCCESS;
1555 }
1556
1557
1558 /* helper for the various utf8 mbstowcs functions */
1559 static unsigned int decode_utf8_char( unsigned char ch, const char **str, const char *strend )
1560 {
1561 /* number of following bytes in sequence based on first byte value (for bytes above 0x7f) */
1562 static const char utf8_length[128] =
1563 {
1564 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x80-0x8f */
1565 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x90-0x9f */
1566 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xa0-0xaf */
1567 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xb0-0xbf */
1568 0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 0xc0-0xcf */
1569 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 0xd0-0xdf */
1570 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, /* 0xe0-0xef */
1571 3,3,3,3,3,0,0,0,0,0,0,0,0,0,0,0 /* 0xf0-0xff */
1572 };
1573
1574 /* first byte mask depending on UTF-8 sequence length */
1575 static const unsigned char utf8_mask[4] = { 0x7f, 0x1f, 0x0f, 0x07 };
1576
1577 unsigned int len = utf8_length[ch - 0x80];
1578 unsigned int res = ch & utf8_mask[len];
1579 const char *end = *str + len;
1580
1581 if (end > strend)
1582 {
1583 *str = end;
1584 return ~0;
1585 }
1586 switch (len)
1587 {
1588 case 3:
1589 if ((ch = end[-3] ^ 0x80) >= 0x40) break;
1590 res = (res << 6) | ch;
1591 (*str)++;
1592 if (res < 0x10) break;
1593 case 2:
1594 if ((ch = end[-2] ^ 0x80) >= 0x40) break;
1595 res = (res << 6) | ch;
1596 if (res >= 0x110000 >> 6) break;
1597 (*str)++;
1598 if (res < 0x20) break;
1599 if (res >= 0xd800 >> 6 && res <= 0xdfff >> 6) break;
1600 case 1:
1601 if ((ch = end[-1] ^ 0x80) >= 0x40) break;
1602 res = (res << 6) | ch;
1603 (*str)++;
1604 if (res < 0x80) break;
1605 return res;
1606 }
1607 return ~0;
1608 }
1609
1610
1611 /**************************************************************************
1612 * RtlUTF8ToUnicodeN (NTDLL.@)
1613 */
1614 NTSTATUS WINAPI RtlUTF8ToUnicodeN( WCHAR *dst, DWORD dstlen, DWORD *reslen, const char *src, DWORD srclen )
1615 {
1616 unsigned int res, len;
1617 NTSTATUS status = STATUS_SUCCESS;
1618 const char *srcend = src + srclen;
1619 WCHAR *dstend;
1620
1621 if (!src) return STATUS_INVALID_PARAMETER_4;
1622 if (!reslen) return STATUS_INVALID_PARAMETER;
1623
1624 dstlen /= sizeof(WCHAR);
1625 dstend = dst + dstlen;
1626 if (!dst)
1627 {
1628 for (len = 0; src < srcend; len++)
1629 {
1630 unsigned char ch = *src++;
1631 if (ch < 0x80) continue;
1632 if ((res = decode_utf8_char( ch, &src, srcend )) > 0x10ffff)
1633 status = STATUS_SOME_NOT_MAPPED;
1634 else
1635 if (res > 0xffff) len++;
1636 }
1637 *reslen = len * sizeof(WCHAR);
1638 return status;
1639 }
1640
1641 while ((dst < dstend) && (src < srcend))
1642 {
1643 unsigned char ch = *src++;
1644 if (ch < 0x80) /* special fast case for 7-bit ASCII */
1645 {
1646 *dst++ = ch;
1647 continue;
1648 }
1649 if ((res = decode_utf8_char( ch, &src, srcend )) <= 0xffff)
1650 {
1651 *dst++ = res;
1652 }
1653 else if (res <= 0x10ffff) /* we need surrogates */
1654 {
1655 res -= 0x10000;
1656 *dst++ = 0xd800 | (res >> 10);
1657 if (dst == dstend) break;
1658 *dst++ = 0xdc00 | (res & 0x3ff);
1659 }
1660 else
1661 {
1662 *dst++ = 0xfffd;
1663 status = STATUS_SOME_NOT_MAPPED;
1664 }
1665 }
1666 if (src < srcend) status = STATUS_BUFFER_TOO_SMALL; /* overflow */
1667 *reslen = (dstlen - (dstend - dst)) * sizeof(WCHAR);
1668 return status;
1669 }
1670
1671
1672 /**************************************************************************
1673 * RtlUnicodeToUTF8N (NTDLL.@)
1674 */
1675 NTSTATUS WINAPI RtlUnicodeToUTF8N( char *dst, DWORD dstlen, DWORD *reslen, const WCHAR *src, DWORD srclen )
1676 {
1677 char *end;
1678 unsigned int val, len;
1679 NTSTATUS status = STATUS_SUCCESS;
1680
1681 if (!src) return STATUS_INVALID_PARAMETER_4;
1682 if (!reslen) return STATUS_INVALID_PARAMETER;
1683 if (dst && (srclen & 1)) return STATUS_INVALID_PARAMETER_5;
1684
1685 srclen /= sizeof(WCHAR);
1686
1687 if (!dst)
1688 {
1689 for (len = 0; srclen; srclen--, src++)
1690 {
1691 if (*src < 0x80) len++; /* 0x00-0x7f: 1 byte */
1692 else if (*src < 0x800) len += 2; /* 0x80-0x7ff: 2 bytes */
1693 else
1694 {
1695 if (!get_utf16( src, srclen, &val ))
1696 {
1697 val = 0xfffd;
1698 status = STATUS_SOME_NOT_MAPPED;
1699 }
1700 if (val < 0x10000) len += 3; /* 0x800-0xffff: 3 bytes */
1701 else /* 0x10000-0x10ffff: 4 bytes */
1702 {
1703 len += 4;
1704 src++;
1705 srclen--;
1706 }
1707 }
1708 }
1709 *reslen = len;
1710 return status;
1711 }
1712
1713 for (end = dst + dstlen; srclen; srclen--, src++)
1714 {
1715 WCHAR ch = *src;
1716
1717 if (ch < 0x80) /* 0x00-0x7f: 1 byte */
1718 {
1719 if (dst > end - 1) break;
1720 *dst++ = ch;
1721 continue;
1722 }
1723 if (ch < 0x800) /* 0x80-0x7ff: 2 bytes */
1724 {
1725 if (dst > end - 2) break;
1726 dst[1] = 0x80 | (ch & 0x3f);
1727 ch >>= 6;
1728 dst[0] = 0xc0 | ch;
1729 dst += 2;
1730 continue;
1731 }
1732 if (!get_utf16( src, srclen, &val ))
1733 {
1734 val = 0xfffd;
1735 status = STATUS_SOME_NOT_MAPPED;
1736 }
1737 if (val < 0x10000) /* 0x800-0xffff: 3 bytes */
1738 {
1739 if (dst > end - 3) break;
1740 dst[2] = 0x80 | (val & 0x3f);
1741 val >>= 6;
1742 dst[1] = 0x80 | (val & 0x3f);
1743 val >>= 6;
1744 dst[0] = 0xe0 | val;
1745 dst += 3;
1746 }
1747 else /* 0x10000-0x10ffff: 4 bytes */
1748 {
1749 if (dst > end - 4) break;
1750 dst[3] = 0x80 | (val & 0x3f);
1751 val >>= 6;
1752 dst[2] = 0x80 | (val & 0x3f);
1753 val >>= 6;
1754 dst[1] = 0x80 | (val & 0x3f);
1755 val >>= 6;
1756 dst[0] = 0xf0 | val;
1757 dst += 4;
1758 src++;
1759 srclen--;
1760 }
1761 }
1762 if (srclen) status = STATUS_BUFFER_TOO_SMALL;
1763 *reslen = dstlen - (end - dst);
1764 return status;
1765 }
1766
1767
1768 /******************************************************************************
1769 * RtlIsNormalizedString (NTDLL.@)
1770 */
1771 NTSTATUS WINAPI RtlIsNormalizedString( ULONG form, const WCHAR *str, INT len, BOOLEAN *res )
1772 {
1773 const struct norm_table *info;
1774 NTSTATUS status;
1775 BYTE props, class, last_class = 0;
1776 unsigned int ch;
1777 int i, r, result = 1;
1778
1779 if ((status = load_norm_table( form, &info ))) return status;
1780
1781 if (len == -1) len = wcslen( str );
1782
1783 for (i = 0; i < len && result; i += r)
1784 {
1785 if (!(r = get_utf16( str + i, len - i, &ch ))) return STATUS_NO_UNICODE_TRANSLATION;
1786 if (info->comp_size)
1787 {
1788 if ((ch >= HANGUL_VBASE && ch < HANGUL_VBASE + HANGUL_VCOUNT) ||
1789 (ch >= HANGUL_TBASE && ch < HANGUL_TBASE + HANGUL_TCOUNT))
1790 {
1791 result = -1; /* QC=Maybe */
1792 continue;
1793 }
1794 }
1795 else if (ch >= HANGUL_SBASE && ch < HANGUL_SBASE + HANGUL_SCOUNT)
1796 {
1797 result = 0; /* QC=No */
1798 break;
1799 }
1800 props = get_char_props( info, ch );
1801 class = props & 0x3f;
1802 if (class == 0x3f)
1803 {
1804 last_class = 0;
1805 if (props == 0xbf) result = 0; /* QC=No */
1806 else if (props == 0xff)
1807 {
1808 /* ignore other chars in Hangul range */
1809 if (ch >= HANGUL_LBASE && ch < HANGUL_LBASE + 0x100) continue;
1810 if (ch >= HANGUL_SBASE && ch < HANGUL_SBASE + 0x2c00) continue;
1811 /* allow final null */
1812 if (!ch && i == len - 1) continue;
1813 return STATUS_NO_UNICODE_TRANSLATION;
1814 }
1815 }
1816 else if (props & 0x80)
1817 {
1818 if ((props & 0xc0) == 0xc0) result = -1; /* QC=Maybe */
1819 if (class && class < last_class) result = 0; /* QC=No */
1820 last_class = class;
1821 }
1822 else last_class = 0;
1823 }
1824
1825 if (result == -1)
1826 {
1827 int dstlen = len * 4;
1828 NTSTATUS status;
1829 WCHAR *buffer = RtlAllocateHeap( GetProcessHeap(), 0, dstlen * sizeof(WCHAR) );
1830 if (!buffer) return STATUS_NO_MEMORY;
1831 status = RtlNormalizeString( form, str, len, buffer, &dstlen );
1832 result = !status && (dstlen == len) && !wcsncmp( buffer, str, len );
1833 RtlFreeHeap( GetProcessHeap(), 0, buffer );
1834 }
1835 *res = result;
1836 return STATUS_SUCCESS;
1837 }
1838
1839
1840 /******************************************************************************
1841 * RtlNormalizeString (NTDLL.@)
1842 */
1843 NTSTATUS WINAPI RtlNormalizeString( ULONG form, const WCHAR *src, INT src_len, WCHAR *dst, INT *dst_len )
1844 {
1845 int buf_len;
1846 WCHAR *buf = NULL;
1847 const struct norm_table *info;
1848 NTSTATUS status = STATUS_SUCCESS;
1849
1850 TRACE( "%x %s %d %p %d\n", form, debugstr_wn(src, src_len), src_len, dst, *dst_len );
1851
1852 if ((status = load_norm_table( form, &info ))) return status;
1853
1854 if (src_len == -1) src_len = wcslen(src) + 1;
1855
1856 if (!*dst_len)
1857 {
1858 *dst_len = src_len * info->len_factor;
1859 if (*dst_len > 64) *dst_len = max( 64, src_len + src_len / 8 );
1860 return STATUS_SUCCESS;
1861 }
1862 if (!src_len)
1863 {
1864 *dst_len = 0;
1865 return STATUS_SUCCESS;
1866 }
1867
1868 if (!info->comp_size) return decompose_string( info, src, src_len, dst, dst_len );
1869
1870 buf_len = src_len * 4;
1871 for (;;)
1872 {
1873 buf = RtlAllocateHeap( GetProcessHeap(), 0, buf_len * sizeof(WCHAR) );
1874 if (!buf) return STATUS_NO_MEMORY;
1875 status = decompose_string( info, src, src_len, buf, &buf_len );
1876 if (status != STATUS_BUFFER_TOO_SMALL) break;
1877 RtlFreeHeap( GetProcessHeap(), 0, buf );
1878 }
1879 if (!status)
1880 {
1881 buf_len = compose_string( info, buf, buf_len );
1882 if (*dst_len >= buf_len) memcpy( dst, buf, buf_len * sizeof(WCHAR) );
1883 else status = STATUS_BUFFER_TOO_SMALL;
1884 }
1885 RtlFreeHeap( GetProcessHeap(), 0, buf );
1886 *dst_len = buf_len;
1887 return status;
1888 }
1889
1890
1891 /* Punycode parameters */
1892 enum { BASE = 36, TMIN = 1, TMAX = 26, SKEW = 38, DAMP = 700 };
1893
1894 static BOOL check_invalid_chars( const struct norm_table *info, DWORD flags,
1895 const unsigned int *buffer, int len )
1896 {
1897 int i;
1898
1899 for (i = 0; i < len; i++)
1900 {
1901 switch (buffer[i])
1902 {
1903 case 0x200c: /* zero-width non-joiner */
1904 case 0x200d: /* zero-width joiner */
1905 if (!i || get_combining_class( info, buffer[i - 1] ) != 9) return TRUE;
1906 break;
1907 case 0x2260: /* not equal to */
1908 case 0x226e: /* not less than */
1909 case 0x226f: /* not greater than */
1910 if (flags & IDN_USE_STD3_ASCII_RULES) return TRUE;
1911 break;
1912 }
1913 switch (get_char_props( info, buffer[i] ))
1914 {
1915 case 0xbf:
1916 return TRUE;
1917 case 0xff:
1918 if (buffer[i] >= HANGUL_SBASE && buffer[i] < HANGUL_SBASE + 0x2c00) break;
1919 return TRUE;
1920 case 0x7f:
1921 if (!(flags & IDN_ALLOW_UNASSIGNED)) return TRUE;
1922 break;
1923 }
1924 }
1925
1926 if ((flags & IDN_USE_STD3_ASCII_RULES) && len && (buffer[0] == '-' || buffer[len - 1] == '-'))
1927 return TRUE;
1928
1929 return FALSE;
1930 }
1931
1932
1933 /******************************************************************************
1934 * RtlIdnToAscii (NTDLL.@)
1935 */
1936 NTSTATUS WINAPI RtlIdnToAscii( DWORD flags, const WCHAR *src, INT srclen, WCHAR *dst, INT *dstlen )
1937 {
1938 static const WCHAR prefixW[] = {'x','n','-','-'};
1939 const struct norm_table *info;
1940 NTSTATUS status;
1941 WCHAR normstr[256], res[256];
1942 unsigned int ch, buffer[64];
1943 int i, len, start, end, out_label, out = 0, normlen = ARRAY_SIZE(normstr);
1944
1945 TRACE( "%x %s %p %d\n", flags, debugstr_wn(src, srclen), dst, *dstlen );
1946
1947 if ((status = load_norm_table( 13, &info ))) return status;
1948
1949 if ((status = RtlIdnToNameprepUnicode( flags, src, srclen, normstr, &normlen ))) return status;
1950
1951 /* implementation of Punycode based on RFC 3492 */
1952
1953 for (start = 0; start < normlen; start = end + 1)
1954 {
1955 int n = 0x80, bias = 72, delta = 0, b = 0, h, buflen = 0;
1956
1957 out_label = out;
1958 for (i = start; i < normlen; i += len)
1959 {
1960 if (!(len = get_utf16( normstr + i, normlen - i, &ch ))) break;
1961 if (!ch || ch == '.') break;
1962 if (ch < 0x80) b++;
1963 buffer[buflen++] = ch;
1964 }
1965 end = i;
1966
1967 if (b == end - start)
1968 {
1969 if (end < normlen) b++;
1970 if (out + b > ARRAY_SIZE(res)) return STATUS_INVALID_IDN_NORMALIZATION;
1971 memcpy( res + out, normstr + start, b * sizeof(WCHAR) );
1972 out += b;
1973 continue;
1974 }
1975
1976 if (buflen >= 4 && buffer[2] == '-' && buffer[3] == '-') return STATUS_INVALID_IDN_NORMALIZATION;
1977 if (check_invalid_chars( info, flags, buffer, buflen )) return STATUS_INVALID_IDN_NORMALIZATION;
1978
1979 if (out + 5 + b > ARRAY_SIZE(res)) return STATUS_INVALID_IDN_NORMALIZATION;
1980 memcpy( res + out, prefixW, sizeof(prefixW) );
1981 out += ARRAY_SIZE(prefixW);
1982 if (b)
1983 {
1984 for (i = start; i < end; i++) if (normstr[i] < 0x80) res[out++] = normstr[i];
1985 res[out++] = '-';
1986 }
1987
1988 for (h = b; h < buflen; delta++, n++)
1989 {
1990 int m = 0x10ffff, q, k;
1991
1992 for (i = 0; i < buflen; i++) if (buffer[i] >= n && m > buffer[i]) m = buffer[i];
1993 delta += (m - n) * (h + 1);
1994 n = m;
1995
1996 for (i = 0; i < buflen; i++)
1997 {
1998 if (buffer[i] == n)
1999 {
2000 for (q = delta, k = BASE; ; k += BASE)
2001 {
2002 int t = k <= bias ? TMIN : k >= bias + TMAX ? TMAX : k - bias;
2003 int disp = q < t ? q : t + (q - t) % (BASE - t);
2004 if (out + 1 > ARRAY_SIZE(res)) return STATUS_INVALID_IDN_NORMALIZATION;
2005 res[out++] = disp <= 25 ? 'a' + disp : '0' + disp - 26;
2006 if (q < t) break;
2007 q = (q - t) / (BASE - t);
2008 }
2009 delta /= (h == b ? DAMP : 2);
2010 delta += delta / (h + 1);
2011 for (k = 0; delta > ((BASE - TMIN) * TMAX) / 2; k += BASE) delta /= BASE - TMIN;
2012 bias = k + ((BASE - TMIN + 1) * delta) / (delta + SKEW);
2013 delta = 0;
2014 h++;
2015 }
2016 else if (buffer[i] < n) delta++;
2017 }
2018 }
2019
2020 if (out - out_label > 63) return STATUS_INVALID_IDN_NORMALIZATION;
2021
2022 if (end < normlen)
2023 {
2024 if (out + 1 > ARRAY_SIZE(res)) return STATUS_INVALID_IDN_NORMALIZATION;
2025 res[out++] = normstr[end];
2026 }
2027 }
2028
2029 if (*dstlen)
2030 {
2031 if (out <= *dstlen) memcpy( dst, res, out * sizeof(WCHAR) );
2032 else status = STATUS_BUFFER_TOO_SMALL;
2033 }
2034 *dstlen = out;
2035 return status;
2036 }
2037
2038
2039 /******************************************************************************
2040 * RtlIdnToNameprepUnicode (NTDLL.@)
2041 */
2042 NTSTATUS WINAPI RtlIdnToNameprepUnicode( DWORD flags, const WCHAR *src, INT srclen,
2043 WCHAR *dst, INT *dstlen )
2044 {
2045 const struct norm_table *info;
2046 unsigned int ch;
2047 NTSTATUS status;
2048 WCHAR buf[256];
2049 int i, start, len, buflen = ARRAY_SIZE(buf);
2050
2051 if (flags & ~(IDN_ALLOW_UNASSIGNED | IDN_USE_STD3_ASCII_RULES)) return STATUS_INVALID_PARAMETER;
2052 if (!src || srclen < -1) return STATUS_INVALID_PARAMETER;
2053
2054 TRACE( "%x %s %p %d\n", flags, debugstr_wn(src, srclen), dst, *dstlen );
2055
2056 if ((status = load_norm_table( 13, &info ))) return status;
2057
2058 if (srclen == -1) srclen = wcslen(src) + 1;
2059
2060 for (i = 0; i < srclen; i++) if (src[i] < 0x20 || src[i] >= 0x7f) break;
2061
2062 if (i == srclen || (i == srclen - 1 && !src[i])) /* ascii only */
2063 {
2064 if (srclen > buflen) return STATUS_INVALID_IDN_NORMALIZATION;
2065 memcpy( buf, src, srclen * sizeof(WCHAR) );
2066 buflen = srclen;
2067 }
2068 else if ((status = RtlNormalizeString( 13, src, srclen, buf, &buflen )))
2069 {
2070 if (status == STATUS_NO_UNICODE_TRANSLATION) status = STATUS_INVALID_IDN_NORMALIZATION;
2071 return status;
2072 }
2073
2074 for (i = start = 0; i < buflen; i += len)
2075 {
2076 if (!(len = get_utf16( buf + i, buflen - i, &ch ))) break;
2077 if (!ch) break;
2078 if (ch == '.')
2079 {
2080 if (start == i) return STATUS_INVALID_IDN_NORMALIZATION;
2081 /* maximal label length is 63 characters */
2082 if (i - start > 63) return STATUS_INVALID_IDN_NORMALIZATION;
2083 if ((flags & IDN_USE_STD3_ASCII_RULES) && (buf[start] == '-' || buf[i-1] == '-'))
2084 return STATUS_INVALID_IDN_NORMALIZATION;
2085 start = i + 1;
2086 continue;
2087 }
2088 if (flags & IDN_USE_STD3_ASCII_RULES)
2089 {
2090 if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||
2091 (ch >= '0' && ch <= '9') || ch == '-') continue;
2092 return STATUS_INVALID_IDN_NORMALIZATION;
2093 }
2094 if (!(flags & IDN_ALLOW_UNASSIGNED))
2095 {
2096 if (get_char_props( info, ch ) == 0x7f) return STATUS_INVALID_IDN_NORMALIZATION;
2097 }
2098 }
2099 if (!i || i - start > 63) return STATUS_INVALID_IDN_NORMALIZATION;
2100 if ((flags & IDN_USE_STD3_ASCII_RULES) && (buf[start] == '-' || buf[i-1] == '-'))
2101 return STATUS_INVALID_IDN_NORMALIZATION;
2102
2103 if (*dstlen)
2104 {
2105 if (buflen <= *dstlen) memcpy( dst, buf, buflen * sizeof(WCHAR) );
2106 else status = STATUS_BUFFER_TOO_SMALL;
2107 }
2108 *dstlen = buflen;
2109 return status;
2110 }
2111
2112
2113 /******************************************************************************
2114 * RtlIdnToUnicode (NTDLL.@)
2115 */
2116 NTSTATUS WINAPI RtlIdnToUnicode( DWORD flags, const WCHAR *src, INT srclen, WCHAR *dst, INT *dstlen )
2117 {
2118 const struct norm_table *info;
2119 int i, buflen, start, end, out_label, out = 0;
2120 NTSTATUS status;
2121 UINT buffer[64];
2122 WCHAR ch;
2123
2124 if (!src || srclen < -1) return STATUS_INVALID_PARAMETER;
2125 if (srclen == -1) srclen = wcslen( src ) + 1;
2126
2127 TRACE( "%x %s %p %d\n", flags, debugstr_wn(src, srclen), dst, *dstlen );
2128
2129 if ((status = load_norm_table( 13, &info ))) return status;
2130
2131 for (start = 0; start < srclen; )
2132 {
2133 int n = 0x80, bias = 72, pos = 0, old_pos, w, k, t, delim = 0, digit, delta;
2134
2135 out_label = out;
2136 for (i = start; i < srclen; i++)
2137 {
2138 ch = src[i];
2139 if (ch > 0x7f || (i != srclen - 1 && !ch)) return STATUS_INVALID_IDN_NORMALIZATION;
2140 if (!ch || ch == '.') break;
2141 if (ch == '-') delim = i;
2142
2143 if (!(flags & IDN_USE_STD3_ASCII_RULES)) continue;
2144 if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||
2145 (ch >= '0' && ch <= '9') || ch == '-')
2146 continue;
2147 return STATUS_INVALID_IDN_NORMALIZATION;
2148 }
2149 end = i;
2150
2151 /* last label may be empty */
2152 if (start == end && ch) return STATUS_INVALID_IDN_NORMALIZATION;
2153
2154 if (end - start < 4 ||
2155 (src[start] != 'x' && src[start] != 'X') ||
2156 (src[start + 1] != 'n' && src[start + 1] != 'N') ||
2157 src[start + 2] != '-' || src[start + 3] != '-')
2158 {
2159 if (end - start > 63) return STATUS_INVALID_IDN_NORMALIZATION;
2160
2161 if ((flags & IDN_USE_STD3_ASCII_RULES) && (src[start] == '-' || src[end - 1] == '-'))
2162 return STATUS_INVALID_IDN_NORMALIZATION;
2163
2164 if (end < srclen) end++;
2165 if (*dstlen)
2166 {
2167 if (out + end - start <= *dstlen)
2168 memcpy( dst + out, src + start, (end - start) * sizeof(WCHAR));
2169 else return STATUS_BUFFER_TOO_SMALL;
2170 }
2171 out += end - start;
2172 start = end;
2173 continue;
2174 }
2175
2176 if (delim == start + 3) delim++;
2177 buflen = 0;
2178 for (i = start + 4; i < delim && buflen < ARRAY_SIZE(buffer); i++) buffer[buflen++] = src[i];
2179 if (buflen) i++;
2180 while (i < end)
2181 {
2182 old_pos = pos;
2183 w = 1;
2184 for (k = BASE; ; k += BASE)
2185 {
2186 if (i >= end) return STATUS_INVALID_IDN_NORMALIZATION;
2187 ch = src[i++];
2188 if (ch >= 'a' && ch <= 'z') digit = ch - 'a';
2189 else if (ch >= 'A' && ch <= 'Z') digit = ch - 'A';
2190 else if (ch >= '0' && ch <= '9') digit = ch - '0' + 26;
2191 else return STATUS_INVALID_IDN_NORMALIZATION;
2192 pos += digit * w;
2193 t = k <= bias ? TMIN : k >= bias + TMAX ? TMAX : k - bias;
2194 if (digit < t) break;
2195 w *= BASE - t;
2196 }
2197
2198 delta = (pos - old_pos) / (!old_pos ? DAMP : 2);
2199 delta += delta / (buflen + 1);
2200 for (k = 0; delta > ((BASE - TMIN) * TMAX) / 2; k += BASE) delta /= BASE - TMIN;
2201 bias = k + ((BASE - TMIN + 1) * delta) / (delta + SKEW);
2202 n += pos / (buflen + 1);
2203 pos %= buflen + 1;
2204
2205 if (buflen >= ARRAY_SIZE(buffer) - 1) return STATUS_INVALID_IDN_NORMALIZATION;
2206 memmove( buffer + pos + 1, buffer + pos, (buflen - pos) * sizeof(*buffer) );
2207 buffer[pos++] = n;
2208 buflen++;
2209 }
2210
2211 if (check_invalid_chars( info, flags, buffer, buflen )) return STATUS_INVALID_IDN_NORMALIZATION;
2212
2213 for (i = 0; i < buflen; i++)
2214 {
2215 int len = 1 + (buffer[i] >= 0x10000);
2216 if (*dstlen)
2217 {
2218 if (out + len <= *dstlen) put_utf16( dst + out, buffer[i] );
2219 else return STATUS_BUFFER_TOO_SMALL;
2220 }
2221 out += len;
2222 }
2223
2224 if (out - out_label > 63) return STATUS_INVALID_IDN_NORMALIZATION;
2225
2226 if (end < srclen)
2227 {
2228 if (*dstlen)
2229 {
2230 if (out + 1 <= *dstlen) dst[out] = src[end];
2231 else return STATUS_BUFFER_TOO_SMALL;
2232 }
2233 out++;
2234 }
2235 start = end + 1;
2236 }
2237 *dstlen = out;
2238 return STATUS_SUCCESS;
2239 }
Windows API implementation