Daniel Zimmermann <netzimme@aim.com>
[reactos.git] / reactos / lib / rtl / unicode.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS system libraries
4 * PURPOSE: Unicode Conversion Routines
5 * FILE: lib/rtl/unicode.c
6 * PROGRAMMER: Alex Ionescu (alex@relsoft.net)
7 * Emanuele Aliberti
8 * Gunnar Dalsnes
9 */
10
11 /* INCLUDES *****************************************************************/
12
13 #include <rtl.h>
14
15 #define NDEBUG
16 #include <debug.h>
17
18 #include <wine/unicode.h>
19
20 /* GLOBALS *******************************************************************/
21
22 extern BOOLEAN NlsMbCodePageTag;
23 extern BOOLEAN NlsMbOemCodePageTag;
24 extern PUSHORT NlsLeadByteInfo;
25
26 extern USHORT NlsOemDefaultChar;
27 extern USHORT NlsUnicodeDefaultChar;
28
29 /* FUNCTIONS *****************************************************************/
30
31 /*
32 * @implemented
33 */
34 WCHAR
35 NTAPI
36 RtlAnsiCharToUnicodeChar(IN PUCHAR *AnsiChar)
37 {
38 ULONG Size;
39 NTSTATUS Status;
40 WCHAR UnicodeChar = L' ';
41
42 Size = (NlsLeadByteInfo[**AnsiChar] == 0) ? 1 : 2;
43
44 Status = RtlMultiByteToUnicodeN(&UnicodeChar,
45 sizeof(WCHAR),
46 NULL,
47 (PCHAR)*AnsiChar,
48 Size);
49
50 if (!NT_SUCCESS(Status))
51 {
52 UnicodeChar = L' ';
53 }
54
55 *AnsiChar += Size;
56 return UnicodeChar;
57 }
58
59 /*
60 * @implemented
61 *
62 * NOTES
63 * This function always writes a terminating '\0'.
64 * If the dest buffer is too small a partial copy is NOT performed!
65 */
66 NTSTATUS
67 NTAPI
68 RtlAnsiStringToUnicodeString(
69 IN OUT PUNICODE_STRING UniDest,
70 IN PANSI_STRING AnsiSource,
71 IN BOOLEAN AllocateDestinationString)
72 {
73 NTSTATUS Status;
74 ULONG Length;
75 ULONG Index;
76
77 PAGED_CODE_RTL();
78
79 Length = RtlAnsiStringToUnicodeSize(AnsiSource);
80 if (Length > MAXUSHORT) return STATUS_INVALID_PARAMETER_2;
81 UniDest->Length = (USHORT)Length - sizeof(WCHAR);
82
83 if (AllocateDestinationString)
84 {
85 UniDest->Buffer = RtlpAllocateStringMemory(Length, TAG_USTR);
86 UniDest->MaximumLength = Length;
87 if (!UniDest->Buffer) return STATUS_NO_MEMORY;
88 }
89 else if (UniDest->Length >= UniDest->MaximumLength)
90 {
91 return STATUS_BUFFER_OVERFLOW;
92 }
93
94 Status = RtlMultiByteToUnicodeN(UniDest->Buffer,
95 UniDest->Length,
96 &Index,
97 AnsiSource->Buffer,
98 AnsiSource->Length);
99
100 if (!NT_SUCCESS(Status))
101 {
102 if (AllocateDestinationString)
103 {
104 RtlpFreeStringMemory(UniDest->Buffer, TAG_USTR);
105 UniDest->Buffer = NULL;
106 }
107 return Status;
108 }
109
110 UniDest->Buffer[Index / sizeof(WCHAR)] = UNICODE_NULL;
111 return Status;
112 }
113
114 /*
115 * @implemented
116 *
117 * RETURNS
118 * The calculated size in bytes including nullterm.
119 */
120 ULONG
121 NTAPI
122 RtlxAnsiStringToUnicodeSize(IN PCANSI_STRING AnsiString)
123 {
124 ULONG Size;
125
126 /* Convert from Mb String to Unicode Size */
127 RtlMultiByteToUnicodeSize(&Size,
128 AnsiString->Buffer,
129 AnsiString->Length);
130
131 /* Return the size plus the null-char */
132 return(Size + sizeof(WCHAR));
133 }
134
135 /*
136 * @implemented
137 *
138 * NOTES
139 * If src->length is zero dest is unchanged.
140 * Dest is never nullterminated.
141 */
142 NTSTATUS
143 NTAPI
144 RtlAppendStringToString(IN PSTRING Destination,
145 IN PSTRING Source)
146 {
147 USHORT SourceLength = Source->Length;
148
149 if (SourceLength)
150 {
151 if (Destination->Length + SourceLength > Destination->MaximumLength)
152 {
153 return STATUS_BUFFER_TOO_SMALL;
154 }
155
156 RtlMoveMemory(&Destination->Buffer[Destination->Length],
157 Source->Buffer,
158 SourceLength);
159
160 Destination->Length += SourceLength;
161 }
162
163 return STATUS_SUCCESS;
164 }
165
166 /*
167 * @implemented
168 *
169 * NOTES
170 * If src->length is zero dest is unchanged.
171 * Dest is nullterminated when the MaximumLength allowes it.
172 * When dest fits exactly in MaximumLength characters the nullterm is ommitted.
173 */
174 NTSTATUS
175 NTAPI
176 RtlAppendUnicodeStringToString(
177 IN OUT PUNICODE_STRING Destination,
178 IN PCUNICODE_STRING Source)
179 {
180 USHORT SourceLength = Source->Length;
181 PWCHAR Buffer = &Destination->Buffer[Destination->Length / sizeof(WCHAR)];
182
183 if (SourceLength)
184 {
185 if ((SourceLength+ Destination->Length) > Destination->MaximumLength)
186 {
187 return STATUS_BUFFER_TOO_SMALL;
188 }
189
190 RtlMoveMemory(Buffer, Source->Buffer, SourceLength);
191 Destination->Length += SourceLength;
192
193 /* append terminating '\0' if enough space */
194 if (Destination->MaximumLength > Destination->Length)
195 {
196 Buffer[SourceLength / sizeof(WCHAR)] = UNICODE_NULL;
197 }
198 }
199
200 return STATUS_SUCCESS;
201 }
202
203 /**************************************************************************
204 * RtlCharToInteger (NTDLL.@)
205 * @implemented
206 * Converts a character string into its integer equivalent.
207 *
208 * RETURNS
209 * Success: STATUS_SUCCESS. value contains the converted number
210 * Failure: STATUS_INVALID_PARAMETER, if base is not 0, 2, 8, 10 or 16.
211 * STATUS_ACCESS_VIOLATION, if value is NULL.
212 *
213 * NOTES
214 * For base 0 it uses 10 as base and the string should be in the format
215 * "{whitespace} [+|-] [0[x|o|b]] {digits}".
216 * For other bases the string should be in the format
217 * "{whitespace} [+|-] {digits}".
218 * No check is made for value overflow, only the lower 32 bits are assigned.
219 * If str is NULL it crashes, as the native function does.
220 *
221 * DIFFERENCES
222 * This function does not read garbage behind '\0' as the native version does.
223 */
224 NTSTATUS
225 NTAPI
226 RtlCharToInteger(
227 PCSZ str, /* [I] '\0' terminated single-byte string containing a number */
228 ULONG base, /* [I] Number base for conversion (allowed 0, 2, 8, 10 or 16) */
229 PULONG value) /* [O] Destination for the converted value */
230 {
231 CHAR chCurrent;
232 int digit;
233 ULONG RunningTotal = 0;
234 char bMinus = 0;
235
236 while (*str != '\0' && *str <= ' ') {
237 str++;
238 } /* while */
239
240 if (*str == '+') {
241 str++;
242 } else if (*str == '-') {
243 bMinus = 1;
244 str++;
245 } /* if */
246
247 if (base == 0) {
248 base = 10;
249 if (str[0] == '0') {
250 if (str[1] == 'b') {
251 str += 2;
252 base = 2;
253 } else if (str[1] == 'o') {
254 str += 2;
255 base = 8;
256 } else if (str[1] == 'x') {
257 str += 2;
258 base = 16;
259 } /* if */
260 } /* if */
261 } else if (base != 2 && base != 8 && base != 10 && base != 16) {
262 return STATUS_INVALID_PARAMETER;
263 } /* if */
264
265 if (value == NULL) {
266 return STATUS_ACCESS_VIOLATION;
267 } /* if */
268
269 while (*str != '\0') {
270 chCurrent = *str;
271 if (chCurrent >= '0' && chCurrent <= '9') {
272 digit = chCurrent - '0';
273 } else if (chCurrent >= 'A' && chCurrent <= 'Z') {
274 digit = chCurrent - 'A' + 10;
275 } else if (chCurrent >= 'a' && chCurrent <= 'z') {
276 digit = chCurrent - 'a' + 10;
277 } else {
278 digit = -1;
279 } /* if */
280 if (digit < 0 || digit >= (int)base) {
281 *value = bMinus ? -RunningTotal : RunningTotal;
282 return STATUS_SUCCESS;
283 } /* if */
284
285 RunningTotal = RunningTotal * base + digit;
286 str++;
287 } /* while */
288
289 *value = bMinus ? -RunningTotal : RunningTotal;
290 return STATUS_SUCCESS;
291 }
292
293 /*
294 * @implemented
295 */
296 LONG
297 NTAPI
298 RtlCompareString(
299 IN PSTRING s1,
300 IN PSTRING s2,
301 IN BOOLEAN CaseInsensitive)
302 {
303 unsigned int len;
304 LONG ret = 0;
305 LPCSTR p1, p2;
306
307 len = min(s1->Length, s2->Length);
308 p1 = s1->Buffer;
309 p2 = s2->Buffer;
310
311 if (CaseInsensitive)
312 {
313 while (!ret && len--) ret = RtlUpperChar(*p1++) - RtlUpperChar(*p2++);
314 }
315 else
316 {
317 while (!ret && len--) ret = *p1++ - *p2++;
318 }
319 if (!ret) ret = s1->Length - s2->Length;
320 return ret;
321 }
322
323 /*
324 * @implemented
325 *
326 * RETURNS
327 * TRUE if strings are equal.
328 */
329 BOOLEAN
330 NTAPI
331 RtlEqualString(
332 IN PSTRING s1,
333 IN PSTRING s2,
334 IN BOOLEAN CaseInsensitive)
335 {
336 if (s1->Length != s2->Length) return FALSE;
337 return !RtlCompareString(s1, s2, CaseInsensitive);
338 }
339
340 /*
341 * @implemented
342 *
343 * RETURNS
344 * TRUE if strings are equal.
345 */
346 BOOLEAN
347 NTAPI
348 RtlEqualUnicodeString(
349 IN CONST UNICODE_STRING *s1,
350 IN CONST UNICODE_STRING *s2,
351 IN BOOLEAN CaseInsensitive)
352 {
353 if (s1->Length != s2->Length) return FALSE;
354 return !RtlCompareUnicodeString(s1, s2, CaseInsensitive );
355 }
356
357 /*
358 * @implemented
359 */
360 VOID
361 NTAPI
362 RtlFreeAnsiString(IN PANSI_STRING AnsiString)
363 {
364 PAGED_CODE_RTL();
365
366 if (AnsiString->Buffer)
367 {
368 RtlpFreeStringMemory(AnsiString->Buffer, TAG_ASTR);
369 RtlZeroMemory(AnsiString, sizeof(ANSI_STRING));
370 }
371 }
372
373 /*
374 * @implemented
375 */
376 VOID
377 NTAPI
378 RtlFreeOemString(IN POEM_STRING OemString)
379 {
380 PAGED_CODE_RTL();
381
382 if (OemString->Buffer) RtlpFreeStringMemory(OemString->Buffer, TAG_OSTR);
383 }
384
385 /*
386 * @implemented
387 */
388 VOID
389 NTAPI
390 RtlFreeUnicodeString(IN PUNICODE_STRING UnicodeString)
391 {
392 PAGED_CODE_RTL();
393
394 if (UnicodeString->Buffer)
395 {
396 RtlpFreeStringMemory(UnicodeString->Buffer, TAG_USTR);
397 RtlZeroMemory(UnicodeString, sizeof(UNICODE_STRING));
398 }
399 }
400
401
402 /*
403 * @implemented
404 *
405 * NOTES
406 * Check the OEM string to match the Unicode string.
407 *
408 * Functions which convert Unicode strings to OEM strings will set a
409 * DefaultChar from the OEM codepage when the characters are unknown.
410 * So check it against the Unicode string and return false when the
411 * Unicode string does not contain a TransDefaultChar.
412 */
413 BOOLEAN
414 NTAPI
415 RtlpDidUnicodeToOemWork(IN PCUNICODE_STRING UnicodeString,
416 IN POEM_STRING OemString)
417 {
418 ULONG i = 0;
419
420 if (NlsMbOemCodePageTag == FALSE)
421 {
422 /* single-byte code page */
423 /* Go through all characters of a string */
424 while (i < OemString->Length)
425 {
426 /* Check if it got translated into a default char,
427 * but source char wasn't a default char equivalent
428 */
429 if ((OemString->Buffer[i] == NlsOemDefaultChar) &&
430 (UnicodeString->Buffer[i] != NlsUnicodeDefaultChar))
431 {
432 /* Yes, it means unmappable characters were found */
433 return FALSE;
434 }
435
436 /* Move to the next char */
437 i++;
438 }
439
440 /* All chars were translated successfuly */
441 return TRUE;
442 }
443 else
444 {
445 /* multibyte code page */
446
447 /* FIXME */
448 return TRUE;
449 }
450 }
451
452 /*
453 * @unimplemented
454 */
455 BOOLEAN
456 NTAPI
457 RtlIsValidOemCharacter(IN PWCHAR Char)
458 {
459 UNIMPLEMENTED;
460 return FALSE;
461 }
462
463 /*
464 * @implemented
465 *
466 * NOTES
467 * If source is NULL the length of source is assumed to be 0.
468 */
469 VOID
470 NTAPI
471 RtlInitAnsiString(IN OUT PANSI_STRING DestinationString,
472 IN PCSZ SourceString)
473 {
474 ULONG DestSize;
475
476 if(SourceString)
477 {
478 DestSize = strlen(SourceString);
479 DestinationString->Length = (USHORT)DestSize;
480 DestinationString->MaximumLength = (USHORT)DestSize + sizeof(CHAR);
481 }
482 else
483 {
484 DestinationString->Length = 0;
485 DestinationString->MaximumLength = 0;
486 }
487
488 DestinationString->Buffer = (PCHAR)SourceString;
489 }
490
491 NTSTATUS
492 NTAPI
493 RtlInitAnsiStringEx(IN OUT PANSI_STRING DestinationString,
494 IN PCSZ SourceString)
495 {
496 ULONG DestSize;
497
498 if(SourceString)
499 {
500 DestSize = strlen(SourceString);
501 if (DestSize >= 0xFFFF) return STATUS_NAME_TOO_LONG;
502 DestinationString->Length = (USHORT)DestSize;
503 DestinationString->MaximumLength = (USHORT)DestSize + sizeof(CHAR);
504 }
505 else
506 {
507 DestinationString->Length = 0;
508 DestinationString->MaximumLength = 0;
509 }
510
511 DestinationString->Buffer = (PCHAR)SourceString;
512 return STATUS_SUCCESS;
513
514 }
515 /*
516 * @implemented
517 *
518 * NOTES
519 * If source is NULL the length of source is assumed to be 0.
520 */
521 VOID
522 NTAPI
523 RtlInitString(
524 IN OUT PSTRING DestinationString,
525 IN PCSZ SourceString)
526 {
527 RtlInitAnsiString(DestinationString, SourceString);
528 }
529
530 /*
531 * @implemented
532 *
533 * NOTES
534 * If source is NULL the length of source is assumed to be 0.
535 */
536 VOID
537 NTAPI
538 RtlInitUnicodeString(IN OUT PUNICODE_STRING DestinationString,
539 IN PCWSTR SourceString)
540 {
541 ULONG DestSize;
542
543 if(SourceString)
544 {
545 DestSize = wcslen(SourceString) * sizeof(WCHAR);
546 DestinationString->Length = (USHORT)DestSize;
547 DestinationString->MaximumLength = (USHORT)DestSize + sizeof(WCHAR);
548 }
549 else
550 {
551 DestinationString->Length = 0;
552 DestinationString->MaximumLength = 0;
553 }
554
555 DestinationString->Buffer = (PWCHAR)SourceString;
556 }
557
558 /*
559 * @implemented
560 */
561 NTSTATUS
562 NTAPI
563 RtlInitUnicodeStringEx(OUT PUNICODE_STRING DestinationString,
564 IN PCWSTR SourceString)
565 {
566 ULONG DestSize;
567
568 if(SourceString)
569 {
570 DestSize = wcslen(SourceString) * sizeof(WCHAR);
571 if (DestSize >= 0xFFFC) return STATUS_NAME_TOO_LONG;
572 DestinationString->Length = (USHORT)DestSize;
573 DestinationString->MaximumLength = (USHORT)DestSize + sizeof(WCHAR);
574 }
575 else
576 {
577 DestinationString->Length = 0;
578 DestinationString->MaximumLength = 0;
579 }
580
581 DestinationString->Buffer = (PWCHAR)SourceString;
582 return STATUS_SUCCESS;
583 }
584
585 /*
586 * @implemented
587 *
588 * NOTES
589 * Writes at most length characters to the string str.
590 * Str is nullterminated when length allowes it.
591 * When str fits exactly in length characters the nullterm is ommitted.
592 */
593 NTSTATUS NTAPI RtlIntegerToChar(
594 ULONG value, /* [I] Value to be converted */
595 ULONG base, /* [I] Number base for conversion (allowed 0, 2, 8, 10 or 16) */
596 ULONG length, /* [I] Length of the str buffer in bytes */
597 PCHAR str) /* [O] Destination for the converted value */
598 {
599 CHAR buffer[33];
600 PCHAR pos;
601 CHAR digit;
602 ULONG len;
603
604 if (base == 0) {
605 base = 10;
606 } else if (base != 2 && base != 8 && base != 10 && base != 16) {
607 return STATUS_INVALID_PARAMETER;
608 } /* if */
609
610 pos = &buffer[32];
611 *pos = '\0';
612
613 do {
614 pos--;
615 digit = value % base;
616 value = value / base;
617 if (digit < 10) {
618 *pos = '0' + digit;
619 } else {
620 *pos = 'A' + digit - 10;
621 } /* if */
622 } while (value != 0L);
623
624 len = &buffer[32] - pos;
625 if (len > length) {
626 return STATUS_BUFFER_OVERFLOW;
627 } else if (str == NULL) {
628 return STATUS_ACCESS_VIOLATION;
629 } else if (len == length) {
630 memcpy(str, pos, len);
631 } else {
632 memcpy(str, pos, len + 1);
633 } /* if */
634 return STATUS_SUCCESS;
635 }
636
637 /*
638 * @implemented
639 */
640 NTSTATUS
641 NTAPI
642 RtlIntegerToUnicode(
643 IN ULONG Value,
644 IN ULONG Base OPTIONAL,
645 IN ULONG Length OPTIONAL,
646 IN OUT LPWSTR String
647 )
648 {
649 ULONG Radix;
650 WCHAR temp[33];
651 ULONG v = Value;
652 ULONG i;
653 PWCHAR tp;
654 PWCHAR sp;
655
656 Radix = Base;
657 if (Radix == 0)
658 Radix = 10;
659
660 if ((Radix != 2) && (Radix != 8) &&
661 (Radix != 10) && (Radix != 16))
662 {
663 return STATUS_INVALID_PARAMETER;
664 }
665
666 tp = temp;
667 while (v || tp == temp)
668 {
669 i = v % Radix;
670 v = v / Radix;
671 if (i < 10)
672 *tp = i + L'0';
673 else
674 *tp = i + L'a' - 10;
675 tp++;
676 }
677
678 if ((ULONG)((ULONG_PTR)tp - (ULONG_PTR)temp) >= Length)
679 {
680 return STATUS_BUFFER_TOO_SMALL;
681 }
682
683 sp = String;
684 while (tp > temp)
685 *sp++ = *--tp;
686 *sp = 0;
687
688 return STATUS_SUCCESS;
689 }
690
691 /*
692 * @implemented
693 */
694 NTSTATUS
695 NTAPI
696 RtlIntegerToUnicodeString(
697 IN ULONG Value,
698 IN ULONG Base OPTIONAL,
699 IN OUT PUNICODE_STRING String)
700 {
701 ANSI_STRING AnsiString;
702 CHAR Buffer[33];
703 NTSTATUS Status;
704
705 Status = RtlIntegerToChar(Value, Base, sizeof(Buffer), Buffer);
706 if (NT_SUCCESS(Status))
707 {
708 AnsiString.Buffer = Buffer;
709 AnsiString.Length = (USHORT)strlen(Buffer);
710 AnsiString.MaximumLength = sizeof(Buffer);
711
712 Status = RtlAnsiStringToUnicodeString(String, &AnsiString, FALSE);
713 }
714
715 return Status;
716 }
717
718 /*
719 * @implemented
720 */
721 NTSTATUS
722 NTAPI
723 RtlInt64ToUnicodeString (
724 IN ULONGLONG Value,
725 IN ULONG Base OPTIONAL,
726 IN OUT PUNICODE_STRING String)
727 {
728 LARGE_INTEGER LargeInt;
729 ANSI_STRING AnsiString;
730 CHAR Buffer[65];
731 NTSTATUS Status;
732
733 LargeInt.QuadPart = Value;
734
735 Status = RtlLargeIntegerToChar(&LargeInt, Base, sizeof(Buffer), Buffer);
736 if (NT_SUCCESS(Status))
737 {
738 AnsiString.Buffer = Buffer;
739 AnsiString.Length = (USHORT)strlen(Buffer);
740 AnsiString.MaximumLength = sizeof(Buffer);
741
742 Status = RtlAnsiStringToUnicodeString(String, &AnsiString, FALSE);
743 }
744
745 return Status;
746 }
747
748 /*
749 * @implemented
750 *
751 * RETURNS
752 * TRUE if String2 contains String1 as a prefix.
753 */
754 BOOLEAN
755 NTAPI
756 RtlPrefixString(
757 PANSI_STRING String1,
758 PANSI_STRING String2,
759 BOOLEAN CaseInsensitive)
760 {
761 PCHAR pc1;
762 PCHAR pc2;
763 ULONG Length;
764
765 if (String2->Length < String1->Length)
766 return FALSE;
767
768 Length = String1->Length;
769 pc1 = String1->Buffer;
770 pc2 = String2->Buffer;
771
772 if (pc1 && pc2)
773 {
774 if (CaseInsensitive)
775 {
776 while (Length--)
777 {
778 if (RtlUpperChar (*pc1++) != RtlUpperChar (*pc2++))
779 return FALSE;
780 }
781 }
782 else
783 {
784 while (Length--)
785 {
786 if (*pc1++ != *pc2++)
787 return FALSE;
788 }
789 }
790 return TRUE;
791 }
792 return FALSE;
793 }
794
795 /*
796 * @implemented
797 *
798 * RETURNS
799 * TRUE if String2 contains String1 as a prefix.
800 */
801 BOOLEAN
802 NTAPI
803 RtlPrefixUnicodeString(
804 PCUNICODE_STRING String1,
805 PCUNICODE_STRING String2,
806 BOOLEAN CaseInsensitive)
807 {
808 PWCHAR pc1;
809 PWCHAR pc2;
810 ULONG Length;
811
812 if (String2->Length < String1->Length)
813 return FALSE;
814
815 Length = String1->Length / 2;
816 pc1 = String1->Buffer;
817 pc2 = String2->Buffer;
818
819 if (pc1 && pc2)
820 {
821 if (CaseInsensitive)
822 {
823 while (Length--)
824 {
825 if (RtlUpcaseUnicodeChar (*pc1++)
826 != RtlUpcaseUnicodeChar (*pc2++))
827 return FALSE;
828 }
829 }
830 else
831 {
832 while (Length--)
833 {
834 if( *pc1++ != *pc2++ )
835 return FALSE;
836 }
837 }
838 return TRUE;
839 }
840 return FALSE;
841 }
842 /*
843 * @implemented
844 */
845 NTSTATUS
846 NTAPI
847 RtlUnicodeStringToInteger(const UNICODE_STRING *str, /* [I] Unicode string to be converted */
848 ULONG base, /* [I] Number base for conversion (allowed 0, 2, 8, 10 or 16) */
849 ULONG *value) /* [O] Destination for the converted value */
850 {
851 LPWSTR lpwstr = str->Buffer;
852 USHORT CharsRemaining = str->Length / sizeof(WCHAR);
853 WCHAR wchCurrent;
854 int digit;
855 ULONG RunningTotal = 0;
856 char bMinus = 0;
857
858 while (CharsRemaining >= 1 && *lpwstr <= ' ') {
859 lpwstr++;
860 CharsRemaining--;
861 } /* while */
862
863 if (CharsRemaining >= 1) {
864 if (*lpwstr == '+') {
865 lpwstr++;
866 CharsRemaining--;
867 } else if (*lpwstr == '-') {
868 bMinus = 1;
869 lpwstr++;
870 CharsRemaining--;
871 } /* if */
872 } /* if */
873
874 if (base == 0) {
875 base = 10;
876 if (CharsRemaining >= 2 && lpwstr[0] == '0') {
877 if (lpwstr[1] == 'b') {
878 lpwstr += 2;
879 CharsRemaining -= 2;
880 base = 2;
881 } else if (lpwstr[1] == 'o') {
882 lpwstr += 2;
883 CharsRemaining -= 2;
884 base = 8;
885 } else if (lpwstr[1] == 'x') {
886 lpwstr += 2;
887 CharsRemaining -= 2;
888 base = 16;
889 } /* if */
890 } /* if */
891 } else if (base != 2 && base != 8 && base != 10 && base != 16) {
892 return STATUS_INVALID_PARAMETER;
893 } /* if */
894
895 if (value == NULL) {
896 return STATUS_ACCESS_VIOLATION;
897 } /* if */
898
899 while (CharsRemaining >= 1) {
900 wchCurrent = *lpwstr;
901 if (wchCurrent >= '0' && wchCurrent <= '9') {
902 digit = wchCurrent - '0';
903 } else if (wchCurrent >= 'A' && wchCurrent <= 'Z') {
904 digit = wchCurrent - 'A' + 10;
905 } else if (wchCurrent >= 'a' && wchCurrent <= 'z') {
906 digit = wchCurrent - 'a' + 10;
907 } else {
908 digit = -1;
909 } /* if */
910 if (digit < 0 || digit >= base) {
911 *value = bMinus ? -RunningTotal : RunningTotal;
912 return STATUS_SUCCESS;
913 } /* if */
914
915 RunningTotal = RunningTotal * base + digit;
916 lpwstr++;
917 CharsRemaining--;
918 } /* while */
919
920 *value = bMinus ? -RunningTotal : RunningTotal;
921 return STATUS_SUCCESS;
922 }
923
924 /*
925 * @implemented
926 *
927 * RETURNS
928 * Bytes necessary for the conversion including nullterm.
929 */
930 ULONG
931 NTAPI
932 RtlxUnicodeStringToOemSize(IN PCUNICODE_STRING UnicodeString)
933 {
934 ULONG Size;
935
936 /* Convert the Unicode String to Mb Size */
937 RtlUnicodeToMultiByteSize(&Size,
938 UnicodeString->Buffer,
939 UnicodeString->Length);
940
941 /* Return the size + the null char */
942 return (Size + sizeof(CHAR));
943 }
944
945 /*
946 * @implemented
947 *
948 * NOTES
949 * This function always writes a terminating '\0'.
950 * It performs a partial copy if ansi is too small.
951 */
952 NTSTATUS
953 NTAPI
954 RtlUnicodeStringToAnsiString(
955 IN OUT PANSI_STRING AnsiDest,
956 IN PCUNICODE_STRING UniSource,
957 IN BOOLEAN AllocateDestinationString)
958 {
959 NTSTATUS Status = STATUS_SUCCESS;
960 NTSTATUS RealStatus;
961 ULONG Length;
962 ULONG Index;
963
964 PAGED_CODE_RTL();
965
966 Length = RtlUnicodeStringToAnsiSize(UniSource);
967 if (Length > MAXUSHORT) return STATUS_INVALID_PARAMETER_2;
968
969 AnsiDest->Length = (USHORT)Length - sizeof(CHAR);
970
971 if (AllocateDestinationString)
972 {
973 AnsiDest->Buffer = RtlpAllocateStringMemory(Length, TAG_ASTR);
974 AnsiDest->MaximumLength = Length;
975 if (!AnsiDest->Buffer) return STATUS_NO_MEMORY;
976 }
977 else if (AnsiDest->Length >= AnsiDest->MaximumLength)
978 {
979 if (!AnsiDest->MaximumLength) return STATUS_BUFFER_OVERFLOW;
980
981 Status = STATUS_BUFFER_OVERFLOW;
982 AnsiDest->Length = AnsiDest->MaximumLength - 1;
983 }
984
985 RealStatus = RtlUnicodeToMultiByteN(AnsiDest->Buffer,
986 AnsiDest->Length,
987 &Index,
988 UniSource->Buffer,
989 UniSource->Length);
990
991 if (!NT_SUCCESS(RealStatus) && AllocateDestinationString)
992 {
993 RtlpFreeStringMemory(AnsiDest->Buffer, TAG_ASTR);
994 return RealStatus;
995 }
996
997 AnsiDest->Buffer[Index] = ANSI_NULL;
998 return Status;
999 }
1000
1001 /*
1002 * @implemented
1003 *
1004 * NOTES
1005 * This function always writes a terminating '\0'.
1006 * Does NOT perform a partial copy if unicode is too small!
1007 */
1008 NTSTATUS
1009 NTAPI
1010 RtlOemStringToUnicodeString(
1011 IN OUT PUNICODE_STRING UniDest,
1012 IN PCOEM_STRING OemSource,
1013 IN BOOLEAN AllocateDestinationString)
1014 {
1015 NTSTATUS Status;
1016 ULONG Length;
1017 ULONG Index;
1018
1019 PAGED_CODE_RTL();
1020
1021 Length = RtlOemStringToUnicodeSize(OemSource);
1022 if (Length > MAXUSHORT) return STATUS_INVALID_PARAMETER_2;
1023
1024 UniDest->Length = (USHORT)Length - sizeof(WCHAR);
1025
1026 if (AllocateDestinationString)
1027 {
1028 UniDest->Buffer = RtlpAllocateStringMemory(Length, TAG_USTR);
1029 UniDest->MaximumLength = Length;
1030 if (!UniDest->Buffer) return STATUS_NO_MEMORY;
1031 }
1032 else if (UniDest->Length >= UniDest->MaximumLength)
1033 {
1034 return STATUS_BUFFER_OVERFLOW;
1035 }
1036
1037 Status = RtlOemToUnicodeN(UniDest->Buffer,
1038 UniDest->Length,
1039 &Index,
1040 OemSource->Buffer,
1041 OemSource->Length);
1042
1043 if (!NT_SUCCESS(Status) && AllocateDestinationString)
1044 {
1045 RtlpFreeStringMemory(UniDest->Buffer, TAG_USTR);
1046 UniDest->Buffer = NULL;
1047 return Status;
1048 }
1049
1050 UniDest->Buffer[Index / sizeof(WCHAR)] = UNICODE_NULL;
1051 return Status;
1052 }
1053
1054 /*
1055 * @implemented
1056 *
1057 * NOTES
1058 * This function always '\0' terminates the string returned.
1059 */
1060 NTSTATUS
1061 NTAPI
1062 RtlUnicodeStringToOemString(
1063 IN OUT POEM_STRING OemDest,
1064 IN PCUNICODE_STRING UniSource,
1065 IN BOOLEAN AllocateDestinationString)
1066 {
1067 NTSTATUS Status;
1068 ULONG Length;
1069 ULONG Index;
1070
1071 PAGED_CODE_RTL();
1072
1073 Length = RtlUnicodeStringToOemSize(UniSource);
1074 if (Length > MAXUSHORT) return STATUS_INVALID_PARAMETER_2;
1075
1076 OemDest->Length = (USHORT)Length - sizeof(CHAR);
1077
1078 if (AllocateDestinationString)
1079 {
1080 OemDest->Buffer = RtlpAllocateStringMemory(Length, TAG_OSTR);
1081 OemDest->MaximumLength = Length;
1082 if (!OemDest->Buffer) return STATUS_NO_MEMORY;
1083 }
1084 else if (OemDest->Length >= OemDest->MaximumLength)
1085 {
1086 return STATUS_BUFFER_OVERFLOW;
1087 }
1088
1089 Status = RtlUnicodeToOemN(OemDest->Buffer,
1090 OemDest->Length,
1091 &Index,
1092 UniSource->Buffer,
1093 UniSource->Length);
1094
1095 if (!NT_SUCCESS(Status) && AllocateDestinationString)
1096 {
1097 RtlpFreeStringMemory(OemDest->Buffer, TAG_OSTR);
1098 OemDest->Buffer = NULL;
1099 return Status;
1100 }
1101
1102 OemDest->Buffer[Index] = ANSI_NULL;
1103 return Status;
1104 }
1105
1106 #define ITU_IMPLEMENTED_TESTS (IS_TEXT_UNICODE_ODD_LENGTH|IS_TEXT_UNICODE_SIGNATURE)
1107
1108 /*
1109 * @implemented
1110 *
1111 * RETURNS
1112 * The length of the string if all tests were passed, 0 otherwise.
1113 */
1114 BOOLEAN
1115 NTAPI
1116 RtlIsTextUnicode( PVOID buf, INT len, INT *pf )
1117 {
1118 static const WCHAR std_control_chars[] = {'\r','\n','\t',' ',0x3000,0};
1119 static const WCHAR byterev_control_chars[] = {0x0d00,0x0a00,0x0900,0x2000,0};
1120 const WCHAR *s = buf;
1121 int i;
1122 unsigned int flags = MAXULONG, out_flags = 0;
1123
1124 if (len < sizeof(WCHAR))
1125 {
1126 /* FIXME: MSDN documents IS_TEXT_UNICODE_BUFFER_TOO_SMALL but there is no such thing... */
1127 if (pf) *pf = 0;
1128 return FALSE;
1129 }
1130 if (pf)
1131 flags = *pf;
1132 /*
1133 * Apply various tests to the text string. According to the
1134 * docs, each test "passed" sets the corresponding flag in
1135 * the output flags. But some of the tests are mutually
1136 * exclusive, so I don't see how you could pass all tests ...
1137 */
1138
1139 /* Check for an odd length ... pass if even. */
1140 if (len & 1) out_flags |= IS_TEXT_UNICODE_ODD_LENGTH;
1141
1142 if (((char *)buf)[len - 1] == 0)
1143 len--; /* Windows seems to do something like that to avoid e.g. false IS_TEXT_UNICODE_NULL_BYTES */
1144
1145 len /= sizeof(WCHAR);
1146 /* Windows only checks the first 256 characters */
1147 if (len > 256) len = 256;
1148
1149 /* Check for the special byte order unicode marks. */
1150 if (*s == 0xFEFF) out_flags |= IS_TEXT_UNICODE_SIGNATURE;
1151 if (*s == 0xFFFE) out_flags |= IS_TEXT_UNICODE_REVERSE_SIGNATURE;
1152
1153 /* apply some statistical analysis */
1154 if (flags & IS_TEXT_UNICODE_STATISTICS)
1155 {
1156 int stats = 0;
1157 /* FIXME: checks only for ASCII characters in the unicode stream */
1158 for (i = 0; i < len; i++)
1159 {
1160 if (s[i] <= 255) stats++;
1161 }
1162 if (stats > len / 2)
1163 out_flags |= IS_TEXT_UNICODE_STATISTICS;
1164 }
1165
1166 /* Check for unicode NULL chars */
1167 if (flags & IS_TEXT_UNICODE_NULL_BYTES)
1168 {
1169 for (i = 0; i < len; i++)
1170 {
1171 if (!(s[i] & 0xff) || !(s[i] >> 8))
1172 {
1173 out_flags |= IS_TEXT_UNICODE_NULL_BYTES;
1174 break;
1175 }
1176 }
1177 }
1178
1179 if (flags & IS_TEXT_UNICODE_CONTROLS)
1180 {
1181 for (i = 0; i < len; i++)
1182 {
1183 if (strchrW(std_control_chars, s[i]))
1184 {
1185 out_flags |= IS_TEXT_UNICODE_CONTROLS;
1186 break;
1187 }
1188 }
1189 }
1190
1191 if (flags & IS_TEXT_UNICODE_REVERSE_CONTROLS)
1192 {
1193 for (i = 0; i < len; i++)
1194 {
1195 if (strchrW(byterev_control_chars, s[i]))
1196 {
1197 out_flags |= IS_TEXT_UNICODE_REVERSE_CONTROLS;
1198 break;
1199 }
1200 }
1201 }
1202
1203 if (pf)
1204 {
1205 out_flags &= *pf;
1206 *pf = out_flags;
1207 }
1208 /* check for flags that indicate it's definitely not valid Unicode */
1209 if (out_flags & (IS_TEXT_UNICODE_REVERSE_MASK | IS_TEXT_UNICODE_NOT_UNICODE_MASK)) return FALSE;
1210 /* now check for invalid ASCII, and assume Unicode if so */
1211 if (out_flags & IS_TEXT_UNICODE_NOT_ASCII_MASK) return TRUE;
1212 /* now check for Unicode flags */
1213 if (out_flags & IS_TEXT_UNICODE_UNICODE_MASK) return TRUE;
1214 /* no flags set */
1215 return FALSE;
1216 }
1217
1218
1219 /*
1220 * @implemented
1221 *
1222 * NOTES
1223 * Same as RtlOemStringToUnicodeString but doesn't write terminating null
1224 * A partial copy is NOT performed if the dest buffer is too small!
1225 */
1226 NTSTATUS
1227 NTAPI
1228 RtlOemStringToCountedUnicodeString(
1229 IN OUT PUNICODE_STRING UniDest,
1230 IN PCOEM_STRING OemSource,
1231 IN BOOLEAN AllocateDestinationString)
1232 {
1233 NTSTATUS Status;
1234 ULONG Length;
1235 ULONG Index;
1236
1237 PAGED_CODE_RTL();
1238
1239 /* Calculate size of the string */
1240 Length = RtlOemStringToCountedUnicodeSize(OemSource);
1241
1242 /* If it's 0 then zero out dest string and return */
1243 if (!Length)
1244 {
1245 RtlZeroMemory(UniDest, sizeof(UNICODE_STRING));
1246 return STATUS_SUCCESS;
1247 }
1248
1249 /* Check if length is a sane value */
1250 if (Length > MAXUSHORT) return STATUS_INVALID_PARAMETER_2;
1251
1252 /* Store it in dest string */
1253 UniDest->Length = (USHORT)Length;
1254
1255 /* If we're asked to alloc the string - do so */
1256 if (AllocateDestinationString)
1257 {
1258 UniDest->Buffer = RtlpAllocateStringMemory(Length, TAG_USTR);
1259 UniDest->MaximumLength = Length;
1260 if (!UniDest->Buffer) return STATUS_NO_MEMORY;
1261 }
1262 else if (UniDest->Length > UniDest->MaximumLength)
1263 {
1264 return STATUS_BUFFER_OVERFLOW;
1265 }
1266
1267 /* Do the conversion */
1268 Status = RtlOemToUnicodeN(UniDest->Buffer,
1269 UniDest->Length,
1270 &Index,
1271 OemSource->Buffer,
1272 OemSource->Length);
1273
1274 if (!NT_SUCCESS(Status) && AllocateDestinationString)
1275 {
1276 /* Conversion failed, free dest string and return status code */
1277 RtlpFreeStringMemory(UniDest->Buffer, TAG_USTR);
1278 UniDest->Buffer = NULL;
1279 return Status;
1280 }
1281
1282 return STATUS_SUCCESS;
1283 }
1284
1285 /*
1286 * @implemented
1287 *
1288 * RETURNS
1289 * TRUE if the names are equal, FALSE if not
1290 *
1291 * NOTES
1292 * The comparison is case insensitive.
1293 */
1294 BOOLEAN
1295 NTAPI
1296 RtlEqualComputerName(
1297 IN PUNICODE_STRING ComputerName1,
1298 IN PUNICODE_STRING ComputerName2)
1299 {
1300 OEM_STRING OemString1;
1301 OEM_STRING OemString2;
1302 BOOLEAN Result = FALSE;
1303
1304 if (NT_SUCCESS(RtlUpcaseUnicodeStringToOemString(&OemString1,
1305 ComputerName1,
1306 TRUE)))
1307 {
1308 if (NT_SUCCESS(RtlUpcaseUnicodeStringToOemString(&OemString2,
1309 ComputerName2,
1310 TRUE)))
1311 {
1312 Result = RtlEqualString(&OemString1, &OemString2, FALSE);
1313 RtlFreeOemString(&OemString2);
1314 }
1315 RtlFreeOemString(&OemString1);
1316 }
1317
1318 return Result;
1319 }
1320
1321 /*
1322 * @implemented
1323 *
1324 * RETURNS
1325 * TRUE if the names are equal, FALSE if not
1326 *
1327 * NOTES
1328 * The comparison is case insensitive.
1329 */
1330 BOOLEAN
1331 NTAPI
1332 RtlEqualDomainName (
1333 IN PUNICODE_STRING DomainName1,
1334 IN PUNICODE_STRING DomainName2
1335 )
1336 {
1337 return RtlEqualComputerName(DomainName1, DomainName2);
1338 }
1339
1340 /*
1341 * @implemented
1342 *
1343 * RIPPED FROM WINE's ntdll\rtlstr.c rev 1.45
1344 *
1345 * Convert a string representation of a GUID into a GUID.
1346 *
1347 * PARAMS
1348 * str [I] String representation in the format "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}"
1349 * guid [O] Destination for the converted GUID
1350 *
1351 * RETURNS
1352 * Success: STATUS_SUCCESS. guid contains the converted value.
1353 * Failure: STATUS_INVALID_PARAMETER, if str is not in the expected format.
1354 *
1355 * SEE ALSO
1356 * See RtlStringFromGUID.
1357 */
1358 NTSTATUS
1359 NTAPI
1360 RtlGUIDFromString(
1361 IN UNICODE_STRING *str,
1362 OUT GUID* guid
1363 )
1364 {
1365 int i = 0;
1366 const WCHAR *lpszCLSID = str->Buffer;
1367 BYTE* lpOut = (BYTE*)guid;
1368
1369 //TRACE("(%s,%p)\n", debugstr_us(str), guid);
1370
1371 /* Convert string: {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}
1372 * to memory: DWORD... WORD WORD BYTES............
1373 */
1374 while (i <= 37)
1375 {
1376 switch (i)
1377 {
1378 case 0:
1379 if (*lpszCLSID != '{')
1380 return STATUS_INVALID_PARAMETER;
1381 break;
1382
1383 case 9:
1384 case 14:
1385 case 19:
1386 case 24:
1387 if (*lpszCLSID != '-')
1388 return STATUS_INVALID_PARAMETER;
1389 break;
1390
1391 case 37:
1392 if (*lpszCLSID != '}')
1393 return STATUS_INVALID_PARAMETER;
1394 break;
1395
1396 default:
1397 {
1398 WCHAR ch = *lpszCLSID, ch2 = lpszCLSID[1];
1399 unsigned char byte;
1400
1401 /* Read two hex digits as a byte value */
1402 if (ch >= '0' && ch <= '9')
1403 ch = ch - '0';
1404 else if (ch >= 'a' && ch <= 'f')
1405 ch = ch - 'a' + 10;
1406 else if (ch >= 'A' && ch <= 'F')
1407 ch = ch - 'A' + 10;
1408 else
1409 return STATUS_INVALID_PARAMETER;
1410
1411 if (ch2 >= '0' && ch2 <= '9')
1412 ch2 = ch2 - '0';
1413 else if (ch2 >= 'a' && ch2 <= 'f')
1414 ch2 = ch2 - 'a' + 10;
1415 else if (ch2 >= 'A' && ch2 <= 'F')
1416 ch2 = ch2 - 'A' + 10;
1417 else
1418 return STATUS_INVALID_PARAMETER;
1419
1420 byte = ch << 4 | ch2;
1421
1422 switch (i)
1423 {
1424 #ifndef WORDS_BIGENDIAN
1425 /* For Big Endian machines, we store the data such that the
1426 * dword/word members can be read as DWORDS and WORDS correctly. */
1427 /* Dword */
1428 case 1:
1429 lpOut[3] = byte;
1430 break;
1431 case 3:
1432 lpOut[2] = byte;
1433 break;
1434 case 5:
1435 lpOut[1] = byte;
1436 break;
1437 case 7:
1438 lpOut[0] = byte;
1439 lpOut += 4;
1440 break;
1441 /* Word */
1442 case 10:
1443 case 15:
1444 lpOut[1] = byte;
1445 break;
1446 case 12:
1447 case 17:
1448 lpOut[0] = byte;
1449 lpOut += 2;
1450 break;
1451 #endif
1452 /* Byte */
1453 default:
1454 lpOut[0] = byte;
1455 lpOut++;
1456 break;
1457 }
1458 lpszCLSID++; /* Skip 2nd character of byte */
1459 i++;
1460 }
1461 }
1462 lpszCLSID++;
1463 i++;
1464 }
1465
1466 return STATUS_SUCCESS;
1467 }
1468
1469 /*
1470 * @implemented
1471 */
1472 VOID
1473 NTAPI
1474 RtlEraseUnicodeString(
1475 IN PUNICODE_STRING String)
1476 {
1477 if (String->Buffer && String->MaximumLength)
1478 {
1479 RtlZeroMemory(String->Buffer, String->MaximumLength);
1480 String->Length = 0;
1481 }
1482 }
1483
1484 /*
1485 * @implemented
1486 */
1487 NTSTATUS
1488 NTAPI
1489 RtlHashUnicodeString(
1490 IN CONST UNICODE_STRING *String,
1491 IN BOOLEAN CaseInSensitive,
1492 IN ULONG HashAlgorithm,
1493 OUT PULONG HashValue)
1494 {
1495 if (String != NULL && HashValue != NULL)
1496 {
1497 switch (HashAlgorithm)
1498 {
1499 case HASH_STRING_ALGORITHM_DEFAULT:
1500 case HASH_STRING_ALGORITHM_X65599:
1501 {
1502 WCHAR *c, *end;
1503
1504 *HashValue = 0;
1505 end = String->Buffer + (String->Length / sizeof(WCHAR));
1506
1507 if (CaseInSensitive)
1508 {
1509 for (c = String->Buffer;
1510 c != end;
1511 c++)
1512 {
1513 /* only uppercase characters if they are 'a' ... 'z'! */
1514 *HashValue = ((65599 * (*HashValue)) +
1515 (ULONG)(((*c) >= L'a' && (*c) <= L'z') ?
1516 (*c) - L'a' + L'A' : (*c)));
1517 }
1518 }
1519 else
1520 {
1521 for (c = String->Buffer;
1522 c != end;
1523 c++)
1524 {
1525 *HashValue = ((65599 * (*HashValue)) + (ULONG)(*c));
1526 }
1527 }
1528 return STATUS_SUCCESS;
1529 }
1530 }
1531 }
1532
1533 return STATUS_INVALID_PARAMETER;
1534 }
1535
1536 /*
1537 * @implemented
1538 *
1539 * NOTES
1540 * Same as RtlUnicodeStringToOemString but doesn't write terminating null
1541 * Does a partial copy if the dest buffer is too small
1542 */
1543 NTSTATUS
1544 NTAPI
1545 RtlUnicodeStringToCountedOemString(
1546 IN OUT POEM_STRING OemDest,
1547 IN PUNICODE_STRING UniSource,
1548 IN BOOLEAN AllocateDestinationString)
1549 {
1550 NTSTATUS Status;
1551 ULONG Length;
1552 ULONG Index;
1553
1554 PAGED_CODE_RTL();
1555
1556 /* Calculate size of the string */
1557 Length = RtlUnicodeStringToCountedOemSize(UniSource);
1558
1559 /* If it's 0 then zero out dest string and return */
1560 if (!Length)
1561 {
1562 RtlZeroMemory(OemDest, sizeof(OEM_STRING));
1563 return STATUS_SUCCESS;
1564 }
1565
1566 /* Check if length is a sane value */
1567 if (Length > MAXUSHORT) return STATUS_INVALID_PARAMETER_2;
1568
1569 /* Store it in dest string */
1570 OemDest->Length = (USHORT)Length;
1571
1572 /* If we're asked to alloc the string - do so */
1573 if (AllocateDestinationString)
1574 {
1575 OemDest->Buffer = RtlpAllocateStringMemory(Length, TAG_OSTR);
1576 OemDest->MaximumLength = Length;
1577 if (!OemDest->Buffer) return STATUS_NO_MEMORY;
1578 }
1579 else if (OemDest->Length > OemDest->MaximumLength)
1580 {
1581 return STATUS_BUFFER_OVERFLOW;
1582 }
1583
1584 /* Do the conversion */
1585 Status = RtlUnicodeToOemN(OemDest->Buffer,
1586 OemDest->Length,
1587 &Index,
1588 UniSource->Buffer,
1589 UniSource->Length);
1590
1591 /* Check for unmapped character */
1592 if (NT_SUCCESS(Status) && !RtlpDidUnicodeToOemWork(UniSource, OemDest))
1593 Status = STATUS_UNMAPPABLE_CHARACTER;
1594
1595 if (!NT_SUCCESS(Status) && AllocateDestinationString)
1596 {
1597 /* Conversion failed, free dest string and return status code */
1598 RtlpFreeStringMemory(OemDest->Buffer, TAG_OSTR);
1599 OemDest->Buffer = NULL;
1600 return Status;
1601 }
1602
1603 return Status;
1604 }
1605
1606 /*
1607 * @implemented
1608 */
1609 NTSTATUS
1610 NTAPI
1611 RtlLargeIntegerToChar(
1612 IN PLARGE_INTEGER Value,
1613 IN ULONG Base,
1614 IN ULONG Length,
1615 IN OUT PCHAR String)
1616 {
1617 ULONGLONG Val = Value->QuadPart;
1618 NTSTATUS Status = STATUS_SUCCESS;
1619 CHAR Buffer[65];
1620 CHAR Digit;
1621 ULONG Len;
1622 PCHAR Pos;
1623
1624 if (Base == 0) Base = 10;
1625
1626 if ((Base != 2) && (Base != 8) &&
1627 (Base != 10) && (Base != 16))
1628 {
1629 return STATUS_INVALID_PARAMETER;
1630 }
1631
1632 Pos = &Buffer[64];
1633 *Pos = '\0';
1634
1635 do
1636 {
1637 Pos--;
1638 Digit = Val % Base;
1639 Val = Val / Base;
1640 if (Digit < 10)
1641 *Pos = '0' + Digit;
1642 else
1643 *Pos = 'A' + Digit - 10;
1644 }
1645 while (Val != 0L);
1646
1647 Len = &Buffer[64] - Pos;
1648
1649 if (Len > Length)
1650 return STATUS_BUFFER_OVERFLOW;
1651
1652 #if 1 /* It needs to be removed, when will probably use SEH in rtl */
1653 if (String == NULL)
1654 {
1655 return STATUS_ACCESS_VIOLATION;
1656 }
1657 #endif
1658
1659 #if 0
1660 _SEH2_TRY
1661 {
1662 #endif
1663 if (Len == Length)
1664 RtlCopyMemory(String, Pos, Len);
1665 else
1666 RtlCopyMemory(String, Pos, Len + 1);
1667 #if 0
1668 }
1669 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1670 {
1671 /* Get the error code */
1672 Status = _SEH2_GetExceptionCode();
1673 }
1674 _SEH2_END;
1675 #endif
1676
1677 return Status;
1678 }
1679
1680 /*
1681 * @implemented
1682 *
1683 * NOTES
1684 * dest is never '\0' terminated because it may be equal to src, and src
1685 * might not be '\0' terminated. dest->Length is only set upon success.
1686 */
1687 NTSTATUS
1688 NTAPI
1689 RtlUpcaseUnicodeString(
1690 IN OUT PUNICODE_STRING UniDest,
1691 IN PCUNICODE_STRING UniSource,
1692 IN BOOLEAN AllocateDestinationString)
1693 {
1694 ULONG i, j;
1695
1696 PAGED_CODE_RTL();
1697
1698 if (AllocateDestinationString == TRUE)
1699 {
1700 UniDest->MaximumLength = UniSource->Length;
1701 UniDest->Buffer = RtlpAllocateStringMemory(UniDest->MaximumLength, TAG_USTR);
1702 if (UniDest->Buffer == NULL) return STATUS_NO_MEMORY;
1703 }
1704 else if (UniSource->Length > UniDest->MaximumLength)
1705 {
1706 return STATUS_BUFFER_OVERFLOW;
1707 }
1708
1709 j = UniSource->Length / sizeof(WCHAR);
1710
1711 for (i = 0; i < j; i++)
1712 {
1713 UniDest->Buffer[i] = RtlUpcaseUnicodeChar(UniSource->Buffer[i]);
1714 }
1715
1716 UniDest->Length = UniSource->Length;
1717 return STATUS_SUCCESS;
1718 }
1719
1720 /*
1721 * @implemented
1722 *
1723 * NOTES
1724 * This function always writes a terminating '\0'.
1725 * It performs a partial copy if ansi is too small.
1726 */
1727 NTSTATUS
1728 NTAPI
1729 RtlUpcaseUnicodeStringToAnsiString(
1730 IN OUT PANSI_STRING AnsiDest,
1731 IN PUNICODE_STRING UniSource,
1732 IN BOOLEAN AllocateDestinationString)
1733 {
1734 NTSTATUS Status;
1735 ULONG Length;
1736 ULONG Index;
1737
1738 PAGED_CODE_RTL();
1739
1740 Length = RtlUnicodeStringToAnsiSize(UniSource);
1741 if (Length > MAXUSHORT) return STATUS_INVALID_PARAMETER_2;
1742
1743 AnsiDest->Length = (USHORT)Length - sizeof(CHAR);
1744
1745 if (AllocateDestinationString)
1746 {
1747 AnsiDest->Buffer = RtlpAllocateStringMemory(Length, TAG_ASTR);
1748 AnsiDest->MaximumLength = Length;
1749 if (!AnsiDest->Buffer) return STATUS_NO_MEMORY;
1750 }
1751 else if (AnsiDest->Length >= AnsiDest->MaximumLength)
1752 {
1753 if (!AnsiDest->MaximumLength) return STATUS_BUFFER_OVERFLOW;
1754 }
1755
1756 Status = RtlUpcaseUnicodeToMultiByteN(AnsiDest->Buffer,
1757 AnsiDest->Length,
1758 &Index,
1759 UniSource->Buffer,
1760 UniSource->Length);
1761
1762 if (!NT_SUCCESS(Status) && AllocateDestinationString)
1763 {
1764 RtlpFreeStringMemory(AnsiDest->Buffer, TAG_ASTR);
1765 AnsiDest->Buffer = NULL;
1766 return Status;
1767 }
1768
1769 AnsiDest->Buffer[Index] = ANSI_NULL;
1770 return Status;
1771 }
1772
1773 /*
1774 * @implemented
1775 *
1776 * NOTES
1777 * This function always writes a terminating '\0'.
1778 * It performs a partial copy if ansi is too small.
1779 */
1780 NTSTATUS
1781 NTAPI
1782 RtlUpcaseUnicodeStringToCountedOemString(
1783 IN OUT POEM_STRING OemDest,
1784 IN PCUNICODE_STRING UniSource,
1785 IN BOOLEAN AllocateDestinationString)
1786 {
1787 NTSTATUS Status;
1788 ULONG Length;
1789 ULONG Index;
1790
1791 PAGED_CODE_RTL();
1792
1793 Length = RtlUnicodeStringToCountedOemSize(UniSource);
1794
1795 if (!Length)
1796 {
1797 RtlZeroMemory(OemDest, sizeof(OEM_STRING));
1798 }
1799
1800 if (Length > MAXUSHORT) return STATUS_INVALID_PARAMETER_2;
1801
1802 OemDest->Length = (USHORT)Length;
1803
1804 if (AllocateDestinationString)
1805 {
1806 OemDest->Buffer = RtlpAllocateStringMemory(Length, TAG_OSTR);
1807 OemDest->MaximumLength = Length;
1808 if (!OemDest->Buffer) return STATUS_NO_MEMORY;
1809 }
1810 else if (OemDest->Length > OemDest->MaximumLength)
1811 {
1812 return STATUS_BUFFER_OVERFLOW;
1813 }
1814
1815 Status = RtlUpcaseUnicodeToOemN(OemDest->Buffer,
1816 OemDest->Length,
1817 &Index,
1818 UniSource->Buffer,
1819 UniSource->Length);
1820
1821 /* Check for unmapped characters */
1822 if (NT_SUCCESS(Status) && !RtlpDidUnicodeToOemWork(UniSource, OemDest))
1823 Status = STATUS_UNMAPPABLE_CHARACTER;
1824
1825 if (!NT_SUCCESS(Status) && AllocateDestinationString)
1826 {
1827 RtlpFreeStringMemory(OemDest->Buffer, TAG_OSTR);
1828 OemDest->Buffer = NULL;
1829 return Status;
1830 }
1831
1832 return Status;
1833 }
1834
1835 /*
1836 * @implemented
1837 * NOTES
1838 * Oem string is allways nullterminated
1839 * It performs a partial copy if oem is too small.
1840 */
1841 NTSTATUS
1842 NTAPI
1843 RtlUpcaseUnicodeStringToOemString (
1844 IN OUT POEM_STRING OemDest,
1845 IN PCUNICODE_STRING UniSource,
1846 IN BOOLEAN AllocateDestinationString)
1847 {
1848 NTSTATUS Status;
1849 ULONG Length;
1850 ULONG Index;
1851
1852 PAGED_CODE_RTL();
1853
1854 Length = RtlUnicodeStringToOemSize(UniSource);
1855 if (Length > MAXUSHORT) return STATUS_INVALID_PARAMETER_2;
1856
1857 OemDest->Length = (USHORT)Length - sizeof(CHAR);
1858
1859 if (AllocateDestinationString)
1860 {
1861 OemDest->Buffer = RtlpAllocateStringMemory(Length, TAG_OSTR);
1862 OemDest->MaximumLength = Length;
1863 if (!OemDest->Buffer) return STATUS_NO_MEMORY;
1864 }
1865 else if (OemDest->Length >= OemDest->MaximumLength)
1866 {
1867 return STATUS_BUFFER_OVERFLOW;
1868 }
1869
1870 Status = RtlUpcaseUnicodeToOemN(OemDest->Buffer,
1871 OemDest->Length,
1872 &Index,
1873 UniSource->Buffer,
1874 UniSource->Length);
1875
1876 /* Check for unmapped characters */
1877 if (NT_SUCCESS(Status) && !RtlpDidUnicodeToOemWork(UniSource, OemDest))
1878 Status = STATUS_UNMAPPABLE_CHARACTER;
1879
1880 if (!NT_SUCCESS(Status) && AllocateDestinationString)
1881 {
1882 RtlpFreeStringMemory(OemDest->Buffer, TAG_OSTR);
1883 OemDest->Buffer = NULL;
1884 return Status;
1885 }
1886
1887 OemDest->Buffer[Index] = ANSI_NULL;
1888 return Status;
1889 }
1890
1891 /*
1892 * @implemented
1893 *
1894 * RETURNS
1895 * Bytes calculated including nullterm
1896 */
1897 ULONG
1898 NTAPI
1899 RtlxOemStringToUnicodeSize(IN PCOEM_STRING OemString)
1900 {
1901 ULONG Size;
1902
1903 /* Convert the Mb String to Unicode Size */
1904 RtlMultiByteToUnicodeSize(&Size,
1905 OemString->Buffer,
1906 OemString->Length);
1907
1908 /* Return the size + null-char */
1909 return (Size + sizeof(WCHAR));
1910 }
1911
1912 /*
1913 * @implemented
1914 */
1915 NTSTATUS
1916 NTAPI
1917 RtlStringFromGUID (IN REFGUID Guid,
1918 OUT PUNICODE_STRING GuidString)
1919 {
1920 /* Setup the string */
1921 GuidString->Length = 38 * sizeof(WCHAR);
1922 GuidString->MaximumLength = GuidString->Length + sizeof(UNICODE_NULL);
1923 GuidString->Buffer = RtlpAllocateStringMemory(GuidString->MaximumLength,
1924 TAG_USTR);
1925 if (!GuidString->Buffer) return STATUS_NO_MEMORY;
1926
1927 /* Now format the GUID */
1928 swprintf(GuidString->Buffer,
1929 L"{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
1930 Guid->Data1,
1931 Guid->Data2,
1932 Guid->Data3,
1933 Guid->Data4[0],
1934 Guid->Data4[1],
1935 Guid->Data4[2],
1936 Guid->Data4[3],
1937 Guid->Data4[4],
1938 Guid->Data4[5],
1939 Guid->Data4[6],
1940 Guid->Data4[7]);
1941 return STATUS_SUCCESS;
1942 }
1943
1944 /*
1945 * @implemented
1946 *
1947 * RETURNS
1948 * Bytes calculated including nullterm
1949 */
1950 ULONG
1951 NTAPI
1952 RtlxUnicodeStringToAnsiSize(IN PCUNICODE_STRING UnicodeString)
1953 {
1954 ULONG Size;
1955
1956 /* Convert the Unicode String to Mb Size */
1957 RtlUnicodeToMultiByteSize(&Size,
1958 UnicodeString->Buffer,
1959 UnicodeString->Length);
1960
1961 /* Return the size + null-char */
1962 return (Size + sizeof(CHAR));
1963 }
1964
1965 /*
1966 * @implemented
1967 */
1968 LONG
1969 NTAPI
1970 RtlCompareUnicodeString(
1971 IN PCUNICODE_STRING s1,
1972 IN PCUNICODE_STRING s2,
1973 IN BOOLEAN CaseInsensitive)
1974 {
1975 unsigned int len;
1976 LONG ret = 0;
1977 LPCWSTR p1, p2;
1978
1979 len = min(s1->Length, s2->Length) / sizeof(WCHAR);
1980 p1 = s1->Buffer;
1981 p2 = s2->Buffer;
1982
1983 if (CaseInsensitive)
1984 {
1985 while (!ret && len--) ret = RtlUpcaseUnicodeChar(*p1++) - RtlUpcaseUnicodeChar(*p2++);
1986 }
1987 else
1988 {
1989 while (!ret && len--) ret = *p1++ - *p2++;
1990 }
1991 if (!ret) ret = s1->Length - s2->Length;
1992 return ret;
1993 }
1994
1995 /*
1996 * @implemented
1997 */
1998 VOID
1999 NTAPI
2000 RtlCopyString(
2001 IN OUT PSTRING DestinationString,
2002 IN PSTRING SourceString OPTIONAL)
2003 {
2004 ULONG SourceLength;
2005 PCHAR p1, p2;
2006
2007 /* Check if there was no source given */
2008 if(!SourceString)
2009 {
2010 /* Simply return an empty string */
2011 DestinationString->Length = 0;
2012 }
2013 else
2014 {
2015 /* Choose the smallest length */
2016 SourceLength = min(DestinationString->MaximumLength,
2017 SourceString->Length);
2018
2019 /* Set it */
2020 DestinationString->Length = (USHORT)SourceLength;
2021
2022 /* Save the pointers to each buffer */
2023 p1 = DestinationString->Buffer;
2024 p2 = SourceString->Buffer;
2025
2026 /* Loop the buffer */
2027 while (SourceLength)
2028 {
2029 /* Copy the character and move on */
2030 *p1++ = * p2++;
2031 SourceLength--;
2032 }
2033 }
2034 }
2035
2036 /*
2037 * @implemented
2038 */
2039 VOID
2040 NTAPI
2041 RtlCopyUnicodeString(
2042 IN OUT PUNICODE_STRING DestinationString,
2043 IN PCUNICODE_STRING SourceString)
2044 {
2045 ULONG SourceLength;
2046
2047 if(SourceString == NULL)
2048 {
2049 DestinationString->Length = 0;
2050 }
2051 else
2052 {
2053 SourceLength = min(DestinationString->MaximumLength,
2054 SourceString->Length);
2055 DestinationString->Length = (USHORT)SourceLength;
2056
2057 RtlCopyMemory(DestinationString->Buffer,
2058 SourceString->Buffer,
2059 SourceLength);
2060
2061 if (DestinationString->Length < DestinationString->MaximumLength)
2062 {
2063 DestinationString->Buffer[SourceLength / sizeof(WCHAR)] = UNICODE_NULL;
2064 }
2065 }
2066 }
2067
2068 /*
2069 * @implemented
2070 *
2071 * NOTES
2072 * Creates a nullterminated UNICODE_STRING
2073 */
2074 BOOLEAN
2075 NTAPI
2076 RtlCreateUnicodeString(
2077 IN OUT PUNICODE_STRING UniDest,
2078 IN PCWSTR Source)
2079 {
2080 ULONG Length;
2081
2082 PAGED_CODE_RTL();
2083
2084 Length = (wcslen(Source) + 1) * sizeof(WCHAR);
2085 if (Length > 0xFFFE) return FALSE;
2086
2087 UniDest->Buffer = RtlpAllocateStringMemory(Length, TAG_USTR);
2088
2089 if (UniDest->Buffer == NULL) return FALSE;
2090
2091 RtlCopyMemory(UniDest->Buffer, Source, Length);
2092 UniDest->MaximumLength = (USHORT)Length;
2093 UniDest->Length = Length - sizeof (WCHAR);
2094
2095 return TRUE;
2096 }
2097
2098 /*
2099 * @implemented
2100 */
2101 BOOLEAN
2102 NTAPI
2103 RtlCreateUnicodeStringFromAsciiz(
2104 OUT PUNICODE_STRING Destination,
2105 IN PCSZ Source)
2106 {
2107 ANSI_STRING AnsiString;
2108 NTSTATUS Status;
2109
2110 RtlInitAnsiString(&AnsiString, Source);
2111
2112 Status = RtlAnsiStringToUnicodeString(Destination,
2113 &AnsiString,
2114 TRUE);
2115
2116 return NT_SUCCESS(Status);
2117 }
2118
2119 /*
2120 * @implemented
2121 *
2122 * NOTES
2123 * Dest is never '\0' terminated because it may be equal to src, and src
2124 * might not be '\0' terminated.
2125 * Dest->Length is only set upon success.
2126 */
2127 NTSTATUS
2128 NTAPI
2129 RtlDowncaseUnicodeString(
2130 IN OUT PUNICODE_STRING UniDest,
2131 IN PCUNICODE_STRING UniSource,
2132 IN BOOLEAN AllocateDestinationString)
2133 {
2134 ULONG i;
2135 ULONG StopGap;
2136
2137 PAGED_CODE_RTL();
2138
2139 if (AllocateDestinationString)
2140 {
2141 UniDest->MaximumLength = UniSource->Length;
2142 UniDest->Buffer = RtlpAllocateStringMemory(UniSource->Length, TAG_USTR);
2143 if (UniDest->Buffer == NULL) return STATUS_NO_MEMORY;
2144 }
2145 else if (UniSource->Length > UniDest->MaximumLength)
2146 {
2147 return STATUS_BUFFER_OVERFLOW;
2148 }
2149
2150 UniDest->Length = UniSource->Length;
2151 StopGap = UniSource->Length / sizeof(WCHAR);
2152
2153 for (i= 0 ; i < StopGap; i++)
2154 {
2155 if (UniSource->Buffer[i] < L'A')
2156 {
2157 UniDest->Buffer[i] = UniSource->Buffer[i];
2158 }
2159 else if (UniSource->Buffer[i] <= L'Z')
2160 {
2161 UniDest->Buffer[i] = (UniSource->Buffer[i] + (L'a' - L'A'));
2162 }
2163 else
2164 {
2165 UniDest->Buffer[i] = RtlDowncaseUnicodeChar(UniSource->Buffer[i]);
2166 }
2167 }
2168
2169 return STATUS_SUCCESS;
2170 }
2171
2172 /*
2173 * @implemented
2174 *
2175 * NOTES
2176 * if src is NULL dest is unchanged.
2177 * dest is '\0' terminated when the MaximumLength allowes it.
2178 * When dest fits exactly in MaximumLength characters the '\0' is ommitted.
2179 */
2180 NTSTATUS
2181 NTAPI
2182 RtlAppendUnicodeToString(IN OUT PUNICODE_STRING Destination,
2183 IN PCWSTR Source)
2184 {
2185 USHORT Length;
2186 PWCHAR DestBuffer;
2187
2188 if (Source)
2189 {
2190 UNICODE_STRING UnicodeSource;
2191
2192 RtlInitUnicodeString(&UnicodeSource, Source);
2193 Length = UnicodeSource.Length;
2194
2195 if (Destination->Length + Length > Destination->MaximumLength)
2196 {
2197 return STATUS_BUFFER_TOO_SMALL;
2198 }
2199
2200 DestBuffer = &Destination->Buffer[Destination->Length / sizeof(WCHAR)];
2201 RtlMoveMemory(DestBuffer, Source, Length);
2202 Destination->Length += Length;
2203
2204 /* append terminating '\0' if enough space */
2205 if(Destination->MaximumLength > Destination->Length)
2206 {
2207 DestBuffer[Length / sizeof(WCHAR)] = UNICODE_NULL;
2208 }
2209 }
2210
2211 return STATUS_SUCCESS;
2212 }
2213
2214 /*
2215 * @implemented
2216 *
2217 * NOTES
2218 * if src is NULL dest is unchanged.
2219 * dest is never '\0' terminated.
2220 */
2221 NTSTATUS
2222 NTAPI
2223 RtlAppendAsciizToString(
2224 IN OUT PSTRING Destination,
2225 IN PCSZ Source)
2226 {
2227 ULONG Length;
2228
2229 if (Source)
2230 {
2231 Length = (USHORT)strlen(Source);
2232
2233 if (Destination->Length + Length > Destination->MaximumLength)
2234 {
2235 return STATUS_BUFFER_TOO_SMALL;
2236 }
2237
2238 RtlMoveMemory(&Destination->Buffer[Destination->Length], Source, Length);
2239 Destination->Length += Length;
2240 }
2241
2242 return STATUS_SUCCESS;
2243 }
2244
2245 /*
2246 * @implemented
2247 */
2248 VOID
2249 NTAPI
2250 RtlUpperString(PSTRING DestinationString,
2251 PSTRING SourceString)
2252 {
2253 ULONG Length;
2254 PCHAR Src, Dest;
2255
2256 Length = min(SourceString->Length,
2257 DestinationString->MaximumLength);
2258
2259 Src = SourceString->Buffer;
2260 Dest = DestinationString->Buffer;
2261 DestinationString->Length = Length;
2262 while (Length)
2263 {
2264 *Dest++ = RtlUpperChar(*Src++);
2265 Length--;
2266 }
2267 }
2268
2269 /*
2270 * @implemented
2271 *
2272 * NOTES
2273 * See RtlpDuplicateUnicodeString
2274 */
2275 NTSTATUS
2276 NTAPI
2277 RtlDuplicateUnicodeString(
2278 IN ULONG Flags,
2279 IN PCUNICODE_STRING SourceString,
2280 OUT PUNICODE_STRING DestinationString)
2281 {
2282 PAGED_CODE_RTL();
2283
2284 if (SourceString == NULL || DestinationString == NULL ||
2285 SourceString->Length > SourceString->MaximumLength ||
2286 (SourceString->Length == 0 && SourceString->MaximumLength > 0 && SourceString->Buffer == NULL) ||
2287 Flags == RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING || Flags >= 4) {
2288 return STATUS_INVALID_PARAMETER;
2289 }
2290
2291
2292 if ((SourceString->Length == 0) &&
2293 (Flags != (RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE |
2294 RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING)))
2295 {
2296 DestinationString->Length = 0;
2297 DestinationString->MaximumLength = 0;
2298 DestinationString->Buffer = NULL;
2299 }
2300 else
2301 {
2302 UINT DestMaxLength = SourceString->Length;
2303
2304 if (Flags & RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE)
2305 DestMaxLength += sizeof(UNICODE_NULL);
2306
2307 DestinationString->Buffer = RtlpAllocateStringMemory(DestMaxLength, TAG_USTR);
2308 if (DestinationString->Buffer == NULL)
2309 return STATUS_NO_MEMORY;
2310
2311 RtlCopyMemory(DestinationString->Buffer, SourceString->Buffer, SourceString->Length);
2312 DestinationString->Length = SourceString->Length;
2313 DestinationString->MaximumLength = DestMaxLength;
2314
2315 if (Flags & RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE)
2316 DestinationString->Buffer[DestinationString->Length / sizeof(WCHAR)] = 0;
2317 }
2318
2319 return STATUS_SUCCESS;
2320 }
2321
2322 /*
2323 * @implemented
2324 */
2325 NTSTATUS NTAPI
2326 RtlValidateUnicodeString(IN ULONG Flags,
2327 IN PCUNICODE_STRING UnicodeString)
2328 {
2329 /* currently no flags are supported! */
2330 ASSERT(Flags == 0);
2331
2332 if ((Flags == 0) &&
2333 ((UnicodeString == NULL) ||
2334 ((UnicodeString->Length != 0) &&
2335 (UnicodeString->Buffer != NULL) &&
2336 ((UnicodeString->Length % sizeof(WCHAR)) == 0) &&
2337 ((UnicodeString->MaximumLength % sizeof(WCHAR)) == 0) &&
2338 (UnicodeString->MaximumLength >= UnicodeString->Length))))
2339 {
2340 /* a NULL pointer as a unicode string is considered to be a valid unicode
2341 string! */
2342 return STATUS_SUCCESS;
2343 }
2344 else
2345 {
2346 return STATUS_INVALID_PARAMETER;
2347 }
2348 }
2349
2350 NTSTATUS
2351 NTAPI
2352 RtlFindCharInUnicodeString(IN ULONG Flags,
2353 IN PUNICODE_STRING SearchString,
2354 IN PCUNICODE_STRING MatchString,
2355 OUT PUSHORT Position)
2356 {
2357 int main_idx;
2358 unsigned int search_idx;
2359
2360 switch (Flags)
2361 {
2362 case 0:
2363 {
2364 for (main_idx = 0; main_idx < SearchString->Length / sizeof(WCHAR); main_idx++)
2365 {
2366 for (search_idx = 0; search_idx < MatchString->Length / sizeof(WCHAR); search_idx++)
2367 {
2368 if (SearchString->Buffer[main_idx] == MatchString->Buffer[search_idx])
2369 {
2370 *Position = (main_idx + 1) * sizeof(WCHAR);
2371 return STATUS_SUCCESS;
2372 }
2373 }
2374 }
2375 *Position = 0;
2376 return STATUS_NOT_FOUND;
2377 }
2378
2379 case 1:
2380 {
2381 for (main_idx = SearchString->Length / sizeof(WCHAR) - 1; main_idx >= 0; main_idx--)
2382 {
2383 for (search_idx = 0; search_idx < MatchString->Length / sizeof(WCHAR); search_idx++)
2384 {
2385 if (SearchString->Buffer[main_idx] == MatchString->Buffer[search_idx])
2386 {
2387 *Position = main_idx * sizeof(WCHAR);
2388 return STATUS_SUCCESS;
2389 }
2390 }
2391 }
2392 *Position = 0;
2393 return STATUS_NOT_FOUND;
2394 }
2395
2396 case 2:
2397 {
2398 for (main_idx = 0; main_idx < SearchString->Length / sizeof(WCHAR); main_idx++)
2399 {
2400 search_idx = 0;
2401 while (search_idx < MatchString->Length / sizeof(WCHAR) &&
2402 SearchString->Buffer[main_idx] != MatchString->Buffer[search_idx])
2403 {
2404 search_idx++;
2405 }
2406 if (search_idx >= MatchString->Length / sizeof(WCHAR))
2407 {
2408 *Position = (main_idx + 1) * sizeof(WCHAR);
2409 return STATUS_SUCCESS;
2410 }
2411 }
2412 *Position = 0;
2413 return STATUS_NOT_FOUND;
2414 }
2415
2416 case 3:
2417 {
2418 for (main_idx = SearchString->Length / sizeof(WCHAR) - 1; main_idx >= 0; main_idx--)
2419 {
2420 search_idx = 0;
2421 while (search_idx < MatchString->Length / sizeof(WCHAR) &&
2422 SearchString->Buffer[main_idx] != MatchString->Buffer[search_idx])
2423 {
2424 search_idx++;
2425 }
2426 if (search_idx >= MatchString->Length / sizeof(WCHAR))
2427 {
2428 *Position = main_idx * sizeof(WCHAR);
2429 return STATUS_SUCCESS;
2430 }
2431 }
2432 *Position = 0;
2433 return STATUS_NOT_FOUND;
2434 }
2435 } /* switch */
2436
2437 return STATUS_NOT_FOUND;
2438 }
2439
2440 /*
2441 * @implemented
2442 *
2443 * NOTES
2444 * Get the maximum of MAX_COMPUTERNAME_LENGTH characters from the dns.host name until the dot is found.
2445 * Convert is to an uppercase oem string and check for unmapped characters.
2446 * Then convert the oem string back to an unicode string.
2447 */
2448 NTSTATUS
2449 NTAPI
2450 RtlDnsHostNameToComputerName(PUNICODE_STRING ComputerName,PUNICODE_STRING DnsHostName,BOOLEAN AllocateComputerNameString)
2451 {
2452 NTSTATUS Status;
2453 ULONG Length;
2454 ULONG ComputerNameLength;
2455 ULONG ComputerNameOemNLength;
2456 OEM_STRING ComputerNameOem;
2457 CHAR ComputerNameOemN[MAX_COMPUTERNAME_LENGTH + 1];
2458
2459 Status = STATUS_INVALID_COMPUTER_NAME;
2460 ComputerNameLength = DnsHostName->Length;
2461
2462 /* find the first dot in the dns host name */
2463 for (Length = 0;Length < DnsHostName->Length/sizeof(WCHAR);Length++)
2464 {
2465 if (DnsHostName->Buffer[Length] == L'.')
2466 {
2467 /* dot found, so set the length for the oem translation */
2468 ComputerNameLength = Length*sizeof(WCHAR);
2469 break;
2470 }
2471 }
2472
2473 /* the computername must have one character */
2474 if (ComputerNameLength > 0)
2475 {
2476 ComputerNameOemNLength = 0;
2477 /* convert to oem string and use uppercase letters */
2478 Status = RtlUpcaseUnicodeToOemN(ComputerNameOemN,
2479 MAX_COMPUTERNAME_LENGTH,
2480 &ComputerNameOemNLength,
2481 DnsHostName->Buffer,
2482 ComputerNameLength);
2483 /* status STATUS_BUFFER_OVERFLOW is not a problem since the computername shoud only
2484 have MAX_COMPUTERNAME_LENGTH characters */
2485 if ((Status == STATUS_SUCCESS) ||
2486 (Status == STATUS_BUFFER_OVERFLOW))
2487 {
2488 /* set the termination for the oem string */
2489 ComputerNameOemN[MAX_COMPUTERNAME_LENGTH] = 0;
2490 /* set status for the case the next function failed */
2491 Status = STATUS_INVALID_COMPUTER_NAME;
2492 /* fillup the oem string structure with the converted computername
2493 and check it for unmapped characters */
2494 ComputerNameOem.Buffer = ComputerNameOemN;
2495 ComputerNameOem.Length = (USHORT)ComputerNameOemNLength;
2496 ComputerNameOem.MaximumLength = (USHORT)(MAX_COMPUTERNAME_LENGTH + 1);
2497 if (RtlpDidUnicodeToOemWork(DnsHostName, &ComputerNameOem) == TRUE)
2498 {
2499 /* no unmapped character so convert it back to an unicode string */
2500 Status = RtlOemStringToUnicodeString(ComputerName,
2501 &ComputerNameOem,
2502 AllocateComputerNameString);
2503 }
2504 }
2505 }
2506
2507 return Status;
2508 }
2509