ReactOS 0.4.15-dev-8093-g3285f69
unicode.c
Go to the documentation of this file.
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
31
32
33/* FUNCTIONS *****************************************************************/
34
38 IN ULONG NumberOfAddends,
39 IN PCUNICODE_STRING Addends)
40{
43}
44
45/*
46* @implemented
47*/
51{
52 ULONG Size;
54 WCHAR UnicodeChar = L' ';
56
58 {
59 Size = (NlsLeadByteInfo[**AnsiChar] == 0) ? 1 : 2;
60 }
61 else
62 {
63 DPRINT("HACK::Shouldn't have happened! Consider fixing Usetup and registry entries it creates on install\n");
64 Size = 1;
65 }
66
67 Status = RtlMultiByteToUnicodeN(&UnicodeChar,
68 sizeof(WCHAR),
69 NULL,
70 (PCHAR)*AnsiChar,
71 Size);
72
73 if (!NT_SUCCESS(Status))
74 {
75 UnicodeChar = L' ';
76 }
77
78 *AnsiChar += Size;
79 return UnicodeChar;
80}
81
82/*
83 * @implemented
84 *
85 * NOTES
86 * This function always writes a terminating '\0'.
87 * If the dest buffer is too small a partial copy is NOT performed!
88 */
92 IN OUT PUNICODE_STRING UniDest,
93 IN PANSI_STRING AnsiSource,
95{
99
101
102 if (NlsMbCodePageTag == FALSE)
103 {
104 Length = (AnsiSource->Length + 1) * sizeof(WCHAR);
105 }
106 else
107 {
109 }
111 UniDest->Length = (USHORT)Length - sizeof(WCHAR);
112
114 {
115 UniDest->Buffer = RtlpAllocateStringMemory(Length, TAG_USTR);
116 UniDest->MaximumLength = (USHORT)Length;
117 if (!UniDest->Buffer) return STATUS_NO_MEMORY;
118 }
119 else if (UniDest->Length >= UniDest->MaximumLength)
120 {
122 }
123
124 /* UniDest->MaximumLength must be even due to sizeof(WCHAR) being 2 */
125 ASSERT(!(UniDest->MaximumLength & 1) && UniDest->Length <= UniDest->MaximumLength);
126
127 Status = RtlMultiByteToUnicodeN(UniDest->Buffer,
128 UniDest->Length,
129 &Index,
130 AnsiSource->Buffer,
131 AnsiSource->Length);
132
133 if (!NT_SUCCESS(Status))
134 {
136 {
137 RtlpFreeStringMemory(UniDest->Buffer, TAG_USTR);
138 UniDest->Buffer = NULL;
139 }
140
141 return Status;
142 }
143
144 UniDest->Buffer[Index / sizeof(WCHAR)] = UNICODE_NULL;
145 return Status;
146}
147
148/*
149 * @implemented
150 *
151 * RETURNS
152 * The calculated size in bytes including nullterm.
153 */
154ULONG
155NTAPI
157{
158 ULONG Size;
160
161 /* Convert from Mb String to Unicode Size */
163 AnsiString->Buffer,
164 AnsiString->Length);
165
166 /* Return the size plus the null-char */
167 return(Size + sizeof(WCHAR));
168}
169
170/*
171 * @implemented
172 *
173 * NOTES
174 * If src->length is zero dest is unchanged.
175 * Dest is never nullterminated.
176 */
178NTAPI
180 IN const STRING *Source)
181{
182 USHORT SourceLength = Source->Length;
183
184 if (SourceLength)
185 {
186 if (Destination->Length + SourceLength > Destination->MaximumLength)
187 {
189 }
190
192 Source->Buffer,
193 SourceLength);
194
195 Destination->Length += SourceLength;
196 }
197
198 return STATUS_SUCCESS;
199}
200
201/*
202 * @implemented
203 *
204 * NOTES
205 * If src->length is zero dest is unchanged.
206 * Dest is nullterminated when the MaximumLength allowes it.
207 * When dest fits exactly in MaximumLength characters the nullterm is ommitted.
208 */
210NTAPI
214{
215 USHORT SourceLength = Source->Length;
217
218 if (SourceLength)
219 {
220 if ((SourceLength + Destination->Length) > Destination->MaximumLength)
221 {
223 }
224
225 RtlMoveMemory(Buffer, Source->Buffer, SourceLength);
226 Destination->Length += SourceLength;
227
228 /* append terminating '\0' if enough space */
230 {
231 Buffer[SourceLength / sizeof(WCHAR)] = UNICODE_NULL;
232 }
233 }
234
235 return STATUS_SUCCESS;
236}
237
238/**************************************************************************
239 * RtlCharToInteger (NTDLL.@)
240 * @implemented
241 * Converts a character string into its integer equivalent.
242 *
243 * RETURNS
244 * Success: STATUS_SUCCESS. value contains the converted number
245 * Failure: STATUS_INVALID_PARAMETER, if base is not 0, 2, 8, 10 or 16.
246 * STATUS_ACCESS_VIOLATION, if value is NULL.
247 *
248 * NOTES
249 * For base 0 it uses 10 as base and the string should be in the format
250 * "{whitespace} [+|-] [0[x|o|b]] {digits}".
251 * For other bases the string should be in the format
252 * "{whitespace} [+|-] {digits}".
253 * No check is made for value overflow, only the lower 32 bits are assigned.
254 * If str is NULL it crashes, as the native function does.
255 *
256 * DIFFERENCES
257 * This function does not read garbage behind '\0' as the native version does.
258 */
260NTAPI
262 PCSZ str, /* [I] '\0' terminated single-byte string containing a number */
263 ULONG base, /* [I] Number base for conversion (allowed 0, 2, 8, 10 or 16) */
264 PULONG value) /* [O] Destination for the converted value */
265{
266 CHAR chCurrent;
267 int digit;
268 ULONG RunningTotal = 0;
269 char bMinus = 0;
270
271 /* skip leading whitespaces */
272 while (*str != '\0' && *str <= ' ') str++;
273
274 /* Check for +/- */
275 if (*str == '+')
276 {
277 str++;
278 }
279 else if (*str == '-')
280 {
281 bMinus = 1;
282 str++;
283 }
284
285 /* base = 0 means autobase */
286 if (base == 0)
287 {
288 base = 10;
289
290 if (str[0] == '0')
291 {
292 if (str[1] == 'b')
293 {
294 str += 2;
295 base = 2;
296 }
297 else if (str[1] == 'o')
298 {
299 str += 2;
300 base = 8;
301 }
302 else if (str[1] == 'x')
303 {
304 str += 2;
305 base = 16;
306 }
307 }
308 }
309 else if (base != 2 && base != 8 && base != 10 && base != 16)
310 {
312 }
313
314 if (value == NULL) return STATUS_ACCESS_VIOLATION;
315
316 while (*str != '\0')
317 {
318 chCurrent = *str;
319
320 if (chCurrent >= '0' && chCurrent <= '9')
321 {
322 digit = chCurrent - '0';
323 }
324 else if (chCurrent >= 'A' && chCurrent <= 'Z')
325 {
326 digit = chCurrent - 'A' + 10;
327 }
328 else if (chCurrent >= 'a' && chCurrent <= 'z')
329 {
330 digit = chCurrent - 'a' + 10;
331 }
332 else
333 {
334 digit = -1;
335 }
336
337 if (digit < 0 || digit >= (int)base) break;
338
339 RunningTotal = RunningTotal * base + digit;
340 str++;
341 }
342
343 *value = bMinus ? (0 - RunningTotal) : RunningTotal;
344 return STATUS_SUCCESS;
345}
346
347/*
348 * @implemented
349 */
350LONG
351NTAPI
353 IN const STRING *s1,
354 IN const STRING *s2,
356{
357 unsigned int len;
358 LONG ret = 0;
359 LPCSTR p1, p2;
360
361 len = min(s1->Length, s2->Length);
362 p1 = s1->Buffer;
363 p2 = s2->Buffer;
364
365 if (CaseInsensitive)
366 {
367 while (!ret && len--)
368 ret = RtlUpperChar(*p1++) - RtlUpperChar(*p2++);
369 }
370 else
371 {
372 while (!ret && len--) ret = *p1++ - *p2++;
373 }
374
375 if (!ret) ret = s1->Length - s2->Length;
376
377 return ret;
378}
379
380/*
381 * @implemented
382 *
383 * RETURNS
384 * TRUE if strings are equal.
385 */
387NTAPI
389 IN const STRING *s1,
390 IN const STRING *s2,
392{
393 if (s1->Length != s2->Length) return FALSE;
395}
396
397/*
398 * @implemented
399 *
400 * RETURNS
401 * TRUE if strings are equal.
402 */
404NTAPI
409{
410 if (s1->Length != s2->Length) return FALSE;
412}
413
414/*
415 * @implemented
416 */
417VOID
418NTAPI
420{
422
423 if (AnsiString->Buffer)
424 {
427 }
428}
429
430/*
431 * @implemented
432 */
433VOID
434NTAPI
436{
438
439 if (OemString->Buffer) RtlpFreeStringMemory(OemString->Buffer, TAG_OSTR);
440}
441
442/*
443 * @implemented
444 */
445VOID
446NTAPI
448{
450
451 if (UnicodeString->Buffer)
452 {
455 }
456}
457
458
459/*
460 * @implemented
461 *
462 * NOTES
463 * Check the OEM string to match the Unicode string.
464 *
465 * Functions which convert Unicode strings to OEM strings will set a
466 * DefaultChar from the OEM codepage when the characters are unknown.
467 * So check it against the Unicode string and return false when the
468 * Unicode string does not contain a TransDefaultChar.
469 */
471NTAPI
474{
475 ULONG i = 0;
476
478 {
479 /* single-byte code page */
480 /* Go through all characters of a string */
481 while (i < OemString->Length)
482 {
483 /* Check if it got translated into a default char,
484 * but source char wasn't a default char equivalent
485 */
486 if ((OemString->Buffer[i] == NlsOemDefaultChar) &&
488 {
489 /* Yes, it means unmappable characters were found */
490 return FALSE;
491 }
492
493 /* Move to the next char */
494 i++;
495 }
496
497 /* All chars were translated successfuly */
498 return TRUE;
499 }
500 else
501 {
502 /* multibyte code page */
503
504 /* FIXME */
505 return TRUE;
506 }
507}
508
509/*
510* @implemented
511*/
513NTAPI
515{
516 WCHAR UnicodeChar;
517 WCHAR OemChar;
518
519 /* If multi-byte code page present */
521 {
523
524 OemChar = NlsUnicodeToMbOemTable[*Char];
525
526 /* If character has Lead Byte */
527 Offset = NlsOemLeadByteInfo[HIBYTE(OemChar)];
528 if (Offset)
529 {
530 /* Use DBCS table */
531 UnicodeChar = NlsOemLeadByteInfo[Offset + LOBYTE(OemChar)];
532 }
533 else
534 {
535 UnicodeChar = NlsOemToUnicodeTable[OemChar];
536 }
537
538 /* Upcase */
539 UnicodeChar = RtlpUpcaseUnicodeChar(UnicodeChar);
540
541 /* Receive OEM character from the table */
542 OemChar = NlsUnicodeToMbOemTable[UnicodeChar];
543 }
544 else
545 {
546 /* Receive Unicode character from the table */
548
549 /* Receive OEM character from the table */
550 OemChar = NlsUnicodeToOemTable[UnicodeChar];
551 }
552
553 /* Not valid character, failed */
554 if (OemChar == NlsOemDefaultChar)
555 {
556 DPRINT1("\\u%04x is not valid for OEM\n", *Char);
557 return FALSE;
558 }
559
560 *Char = UnicodeChar;
561
562 return TRUE;
563}
564
565/*
566 * @implemented
567 *
568 * NOTES
569 * If source is NULL the length of source is assumed to be 0.
570 */
571VOID
572NTAPI
575{
576 SIZE_T Size;
577
578 if (SourceString)
579 {
581 if (Size > (MAXUSHORT - sizeof(CHAR))) Size = MAXUSHORT - sizeof(CHAR);
584 }
585 else
586 {
589 }
590
592}
593
595NTAPI
598{
599 SIZE_T Size;
600
601 if (SourceString)
602 {
604 if (Size > (MAXUSHORT - sizeof(CHAR))) return STATUS_NAME_TOO_LONG;
607 }
608 else
609 {
612 }
613
615 return STATUS_SUCCESS;
616
617}
618/*
619 * @implemented
620 *
621 * NOTES
622 * If source is NULL the length of source is assumed to be 0.
623 */
624VOID
625NTAPI
629{
631}
632
633/*
634 * @implemented
635 *
636 * NOTES
637 * If source is NULL the length of source is assumed to be 0.
638 */
639VOID
640NTAPI
644{
645 SIZE_T Size;
646 CONST SIZE_T MaxSize = (MAXUSHORT & ~1) - sizeof(UNICODE_NULL); // an even number
647
648 if (SourceString)
649 {
650 Size = wcslen(SourceString) * sizeof(WCHAR);
651 __analysis_assume(Size <= MaxSize);
652
653 if (Size > MaxSize)
654 Size = MaxSize;
657 }
658 else
659 {
662 }
663
665}
666
667/*
668 * @implemented
669 */
671NTAPI
675{
676 SIZE_T Size;
677 CONST SIZE_T MaxSize = (MAXUSHORT & ~1) - sizeof(WCHAR); // an even number
678
679 if (SourceString)
680 {
681 Size = wcslen(SourceString) * sizeof(WCHAR);
682 if (Size > MaxSize) return STATUS_NAME_TOO_LONG;
685 }
686 else
687 {
690 }
691
693 return STATUS_SUCCESS;
694}
695
696/*
697 * @implemented
698 *
699 * NOTES
700 * Writes at most length characters to the string str.
701 * Str is nullterminated when length allowes it.
702 * When str fits exactly in length characters the nullterm is ommitted.
703 */
705 ULONG value, /* [I] Value to be converted */
706 ULONG base, /* [I] Number base for conversion (allowed 0, 2, 8, 10 or 16) */
707 ULONG length, /* [I] Length of the str buffer in bytes */
708 PCHAR str) /* [O] Destination for the converted value */
709{
710 CHAR buffer[33];
711 PCHAR pos;
712 CHAR digit;
713 SIZE_T len;
714
715 if (base == 0)
716 {
717 base = 10;
718 }
719 else if (base != 2 && base != 8 && base != 10 && base != 16)
720 {
722 }
723
724 pos = &buffer[32];
725 *pos = '\0';
726
727 do
728 {
729 pos--;
730 digit = (CHAR)(value % base);
731 value = value / base;
732
733 if (digit < 10)
734 {
735 *pos = '0' + digit;
736 }
737 else
738 {
739 *pos = 'A' + digit - 10;
740 }
741 }
742 while (value != 0L);
743
744 len = &buffer[32] - pos;
745
746 if (len > length)
747 {
749 }
750 else if (str == NULL)
751 {
753 }
754 else if (len == length)
755 {
757 }
758 else
759 {
760 RtlCopyMemory(str, pos, len + 1);
761 }
762
763 return STATUS_SUCCESS;
764}
765
766/*
767 * @implemented
768 */
770NTAPI
772 IN ULONG Value,
776{
777 ULONG Radix;
778 WCHAR temp[33];
779 ULONG v = Value;
780 ULONG i;
781 PWCHAR tp;
782 PWCHAR sp;
783
784 Radix = Base;
785
786 if (Radix == 0) Radix = 10;
787
788 if ((Radix != 2) && (Radix != 8) &&
789 (Radix != 10) && (Radix != 16))
790 {
792 }
793
794 tp = temp;
795
796 while (v || tp == temp)
797 {
798 i = v % Radix;
799 v = v / Radix;
800
801 if (i < 10) *tp = (WCHAR)(i + L'0');
802 else *tp = (WCHAR)(i + L'a' - 10);
803
804 tp++;
805 }
806
807 if ((ULONG)((ULONG_PTR)tp - (ULONG_PTR)temp) >= Length)
808 {
810 }
811
812 sp = String;
813
814 while (tp > temp) *sp++ = *--tp;
815
816 *sp = 0;
817
818 return STATUS_SUCCESS;
819}
820
821/*
822 * @implemented
823 */
825NTAPI
827 IN ULONG Value,
830{
832 CHAR Buffer[33];
834
836 if (NT_SUCCESS(Status))
837 {
838 AnsiString.Buffer = Buffer;
839 AnsiString.Length = (USHORT)strlen(Buffer);
840 AnsiString.MaximumLength = sizeof(Buffer);
841
843 }
844
845 return Status;
846}
847
848/*
849 * @implemented
850 */
852NTAPI
857{
858 LARGE_INTEGER LargeInt;
860 CHAR Buffer[65];
862
863 LargeInt.QuadPart = Value;
864
865 Status = RtlLargeIntegerToChar(&LargeInt, Base, sizeof(Buffer), Buffer);
866 if (NT_SUCCESS(Status))
867 {
868 AnsiString.Buffer = Buffer;
869 AnsiString.Length = (USHORT)strlen(Buffer);
870 AnsiString.MaximumLength = sizeof(Buffer);
871
873 }
874
875 return Status;
876}
877
878/*
879 * @implemented
880 *
881 * RETURNS
882 * TRUE if String2 contains String1 as a prefix.
883 */
885NTAPI
887 const STRING *String1,
888 const STRING *String2,
890{
891 PCHAR pc1;
892 PCHAR pc2;
893 ULONG NumChars;
894
895 if (String2->Length < String1->Length)
896 return FALSE;
897
898 NumChars = String1->Length;
899 pc1 = String1->Buffer;
900 pc2 = String2->Buffer;
901
902 if (pc1 && pc2)
903 {
904 if (CaseInsensitive)
905 {
906 while (NumChars--)
907 {
908 if (RtlUpperChar(*pc1++) != RtlUpperChar(*pc2++))
909 return FALSE;
910 }
911 }
912 else
913 {
914 while (NumChars--)
915 {
916 if (*pc1++ != *pc2++)
917 return FALSE;
918 }
919 }
920
921 return TRUE;
922 }
923
924 return FALSE;
925}
926
927/*
928 * @implemented
929 *
930 * RETURNS
931 * TRUE if String2 contains String1 as a prefix.
932 */
934NTAPI
936 PCUNICODE_STRING String1,
939{
940 PWCHAR pc1;
941 PWCHAR pc2;
942 ULONG NumChars;
943
944 if (String2->Length < String1->Length)
945 return FALSE;
946
947 NumChars = String1->Length / sizeof(WCHAR);
948 pc1 = String1->Buffer;
949 pc2 = String2->Buffer;
950
951 if (pc1 && pc2)
952 {
953 if (CaseInsensitive)
954 {
955 while (NumChars--)
956 {
957 if (RtlpUpcaseUnicodeChar(*pc1++) !=
959 return FALSE;
960 }
961 }
962 else
963 {
964 while (NumChars--)
965 {
966 if (*pc1++ != *pc2++)
967 return FALSE;
968 }
969 }
970
971 return TRUE;
972 }
973
974 return FALSE;
975}
976
977/*
978 * @implemented
979 */
981NTAPI
983 const UNICODE_STRING *str, /* [I] Unicode string to be converted */
984 ULONG base, /* [I] Number base for conversion (allowed 0, 2, 8, 10 or 16) */
985 ULONG *value) /* [O] Destination for the converted value */
986{
987 LPWSTR lpwstr = str->Buffer;
988 USHORT CharsRemaining = str->Length / sizeof(WCHAR);
989 WCHAR wchCurrent;
990 int digit;
991 ULONG RunningTotal = 0;
992 char bMinus = 0;
993
994 while (CharsRemaining >= 1 && *lpwstr <= ' ')
995 {
996 lpwstr++;
997 CharsRemaining--;
998 }
999
1000 if (CharsRemaining >= 1)
1001 {
1002 if (*lpwstr == '+')
1003 {
1004 lpwstr++;
1005 CharsRemaining--;
1006 }
1007 else if (*lpwstr == '-')
1008 {
1009 bMinus = 1;
1010 lpwstr++;
1011 CharsRemaining--;
1012 }
1013 }
1014
1015 if (base == 0)
1016 {
1017 base = 10;
1018
1019 if (CharsRemaining >= 2 && lpwstr[0] == '0')
1020 {
1021 if (lpwstr[1] == 'b')
1022 {
1023 lpwstr += 2;
1024 CharsRemaining -= 2;
1025 base = 2;
1026 }
1027 else if (lpwstr[1] == 'o')
1028 {
1029 lpwstr += 2;
1030 CharsRemaining -= 2;
1031 base = 8;
1032 }
1033 else if (lpwstr[1] == 'x')
1034 {
1035 lpwstr += 2;
1036 CharsRemaining -= 2;
1037 base = 16;
1038 }
1039 }
1040 }
1041 else if (base != 2 && base != 8 && base != 10 && base != 16)
1042 {
1044 }
1045
1046 if (value == NULL)
1047 {
1049 }
1050
1051 while (CharsRemaining >= 1)
1052 {
1053 wchCurrent = *lpwstr;
1054
1055 if (wchCurrent >= '0' && wchCurrent <= '9')
1056 {
1057 digit = wchCurrent - '0';
1058 }
1059 else if (wchCurrent >= 'A' && wchCurrent <= 'Z')
1060 {
1061 digit = wchCurrent - 'A' + 10;
1062 }
1063 else if (wchCurrent >= 'a' && wchCurrent <= 'z')
1064 {
1065 digit = wchCurrent - 'a' + 10;
1066 }
1067 else
1068 {
1069 digit = -1;
1070 }
1071
1072 if (digit < 0 || (ULONG)digit >= base) break;
1073
1074 RunningTotal = RunningTotal * base + digit;
1075 lpwstr++;
1076 CharsRemaining--;
1077 }
1078
1079 *value = bMinus ? (0 - RunningTotal) : RunningTotal;
1080 return STATUS_SUCCESS;
1081}
1082
1083/*
1084 * @implemented
1085 *
1086 * RETURNS
1087 * Bytes necessary for the conversion including nullterm.
1088 */
1089ULONG
1090NTAPI
1092{
1093 ULONG Size;
1094
1095 /* Convert the Unicode String to Mb Size */
1097 UnicodeString->Buffer,
1098 UnicodeString->Length);
1099
1100 /* Return the size + the null char */
1101 return (Size + sizeof(CHAR));
1102}
1103
1104/*
1105 * @implemented
1106 *
1107 * NOTES
1108 * This function always writes a terminating '\0'.
1109 * It performs a partial copy if ansi is too small.
1110 */
1112NTAPI
1114 IN OUT PANSI_STRING AnsiDest,
1115 IN PCUNICODE_STRING UniSource,
1117{
1119 NTSTATUS RealStatus;
1120 ULONG Length;
1121 ULONG Index;
1122
1124
1125 ASSERT(!(UniSource->Length & 1));
1126
1127 if (NlsMbCodePageTag == FALSE)
1128 {
1129 Length = (UniSource->Length + sizeof(WCHAR)) / sizeof(WCHAR);
1130 }
1131 else
1132 {
1134 }
1135
1137
1138 AnsiDest->Length = (USHORT)Length - sizeof(CHAR);
1139
1141 {
1142 AnsiDest->Buffer = RtlpAllocateStringMemory(Length, TAG_ASTR);
1143 AnsiDest->MaximumLength = (USHORT)Length;
1144
1145 if (!AnsiDest->Buffer) return STATUS_NO_MEMORY;
1146 }
1147 else if (AnsiDest->Length >= AnsiDest->MaximumLength)
1148 {
1149 if (!AnsiDest->MaximumLength) return STATUS_BUFFER_OVERFLOW;
1150
1152 AnsiDest->Length = AnsiDest->MaximumLength - 1;
1153 }
1154
1155 RealStatus = RtlUnicodeToMultiByteN(AnsiDest->Buffer,
1156 AnsiDest->Length,
1157 &Index,
1158 UniSource->Buffer,
1159 UniSource->Length);
1160
1161 if (!NT_SUCCESS(RealStatus) && AllocateDestinationString)
1162 {
1163 RtlpFreeStringMemory(AnsiDest->Buffer, TAG_ASTR);
1164 return RealStatus;
1165 }
1166
1167 AnsiDest->Buffer[Index] = ANSI_NULL;
1168 return Status;
1169}
1170
1171/*
1172 * @implemented
1173 *
1174 * NOTES
1175 * This function always writes a terminating '\0'.
1176 * Does NOT perform a partial copy if unicode is too small!
1177 */
1179NTAPI
1181 IN OUT PUNICODE_STRING UniDest,
1182 IN PCOEM_STRING OemSource,
1184{
1186 ULONG Length;
1187 ULONG Index;
1188
1190
1191 Length = RtlOemStringToUnicodeSize(OemSource);
1192
1194
1195 UniDest->Length = (USHORT)Length - sizeof(WCHAR);
1196
1198 {
1199 UniDest->Buffer = RtlpAllocateStringMemory(Length, TAG_USTR);
1200 UniDest->MaximumLength = (USHORT)Length;
1201
1202 if (!UniDest->Buffer) return STATUS_NO_MEMORY;
1203 }
1204 else if (UniDest->Length >= UniDest->MaximumLength)
1205 {
1207 }
1208
1209 Status = RtlOemToUnicodeN(UniDest->Buffer,
1210 UniDest->Length,
1211 &Index,
1212 OemSource->Buffer,
1213 OemSource->Length);
1214
1216 {
1217 RtlpFreeStringMemory(UniDest->Buffer, TAG_USTR);
1218 UniDest->Buffer = NULL;
1219 return Status;
1220 }
1221
1222 UniDest->Buffer[Index / sizeof(WCHAR)] = UNICODE_NULL;
1223 return Status;
1224}
1225
1226/*
1227 * @implemented
1228 *
1229 * NOTES
1230 * This function always '\0' terminates the string returned.
1231 */
1233NTAPI
1235 IN OUT POEM_STRING OemDest,
1236 IN PCUNICODE_STRING UniSource,
1238{
1240 ULONG Length;
1241 ULONG Index;
1242
1244
1245 Length = RtlUnicodeStringToOemSize(UniSource);
1246
1248
1249 OemDest->Length = (USHORT)Length - sizeof(CHAR);
1250
1252 {
1253 OemDest->Buffer = RtlpAllocateStringMemory(Length, TAG_OSTR);
1254 OemDest->MaximumLength = (USHORT)Length;
1255
1256 if (!OemDest->Buffer) return STATUS_NO_MEMORY;
1257 }
1258 else if (OemDest->Length >= OemDest->MaximumLength)
1259 {
1261 }
1262
1263 Status = RtlUnicodeToOemN(OemDest->Buffer,
1264 OemDest->Length,
1265 &Index,
1266 UniSource->Buffer,
1267 UniSource->Length);
1268
1270 {
1271 RtlpFreeStringMemory(OemDest->Buffer, TAG_OSTR);
1272 OemDest->Buffer = NULL;
1273 return Status;
1274 }
1275
1276 OemDest->Buffer[Index] = ANSI_NULL;
1277 return Status;
1278}
1279
1280#define ITU_IMPLEMENTED_TESTS (IS_TEXT_UNICODE_ODD_LENGTH|IS_TEXT_UNICODE_SIGNATURE)
1281
1282/*
1283 * @implemented
1284 *
1285 * RETURNS
1286 * The length of the string if all tests were passed, 0 otherwise.
1287 */
1288BOOLEAN
1289NTAPI
1291{
1292 static const WCHAR std_control_chars[] = {'\r', '\n', '\t', ' ', 0x3000, 0};
1293 static const WCHAR byterev_control_chars[] = {0x0d00, 0x0a00, 0x0900, 0x2000, 0};
1294 const WCHAR *s = buf;
1295 int i;
1296 unsigned int flags = MAXULONG, out_flags = 0;
1297 UCHAR last_lo_byte = 0;
1298 UCHAR last_hi_byte = 0;
1299 ULONG hi_byte_diff = 0;
1300 ULONG lo_byte_diff = 0;
1301 ULONG weight = 3;
1302 ULONG lead_byte = 0;
1303
1304 if (len < sizeof(WCHAR))
1305 {
1306 /* FIXME: MSDN documents IS_TEXT_UNICODE_BUFFER_TOO_SMALL but there is no such thing... */
1307 if (pf) *pf = 0;
1308
1309 return FALSE;
1310 }
1311
1312 if (pf)
1313 flags = *pf;
1314
1315 /*
1316 * Apply various tests to the text string. According to the
1317 * docs, each test "passed" sets the corresponding flag in
1318 * the output flags. But some of the tests are mutually
1319 * exclusive, so I don't see how you could pass all tests ...
1320 */
1321
1322 /* Check for an odd length ... pass if even. */
1323 if (len & 1) out_flags |= IS_TEXT_UNICODE_ODD_LENGTH;
1324
1325 if (((char *)buf)[len - 1] == 0)
1326 len--; /* Windows seems to do something like that to avoid e.g. false IS_TEXT_UNICODE_NULL_BYTES */
1327
1328 len /= sizeof(WCHAR);
1329
1330 /* Windows only checks the first 256 characters */
1331 if (len > 256) len = 256;
1332
1333 /* Check for the special byte order unicode marks. */
1334 if (*s == 0xFEFF) out_flags |= IS_TEXT_UNICODE_SIGNATURE;
1335 if (*s == 0xFFFE) out_flags |= IS_TEXT_UNICODE_REVERSE_SIGNATURE;
1336
1337 for (i = 0; i < len; i++)
1338 {
1339 UCHAR lo_byte = LOBYTE(s[i]);
1340 UCHAR hi_byte = HIBYTE(s[i]);
1341
1342 lo_byte_diff += max(lo_byte, last_lo_byte) - min(lo_byte, last_lo_byte);
1343 hi_byte_diff += max(hi_byte, last_hi_byte) - min(hi_byte, last_hi_byte);
1344
1345 last_lo_byte = lo_byte;
1346 last_hi_byte = hi_byte;
1347
1348 switch (s[i])
1349 {
1350 case 0xFFFE: /* Reverse BOM */
1351 case UNICODE_NULL:
1352 case 0x0A0D: /* ASCII CRLF (packed into one word) */
1353 case 0xFFFF: /* Unicode 0xFFFF */
1354 out_flags |= IS_TEXT_UNICODE_ILLEGAL_CHARS;
1355 break;
1356 }
1357 }
1358
1360 {
1361 for (i = 0; i < len; i++)
1362 {
1363 if (NlsLeadByteInfo[s[i]])
1364 {
1365 ++lead_byte;
1366 ++i;
1367 }
1368 }
1369
1370 if (lead_byte)
1371 {
1372 weight = (len / 2) - 1;
1373
1374 if (lead_byte < (weight / 3))
1375 weight = 3;
1376 else if (lead_byte < ((weight * 2) / 3))
1377 weight = 2;
1378 else
1379 weight = 1;
1380
1381 out_flags |= IS_TEXT_UNICODE_DBCS_LEADBYTE;
1382 }
1383 }
1384
1385 if (lo_byte_diff < 127 && !hi_byte_diff)
1386 {
1387 out_flags |= IS_TEXT_UNICODE_ASCII16;
1388 }
1389
1390 if (hi_byte_diff && !lo_byte_diff)
1391 {
1393 }
1394
1395 if ((weight * lo_byte_diff) < hi_byte_diff)
1396 {
1398 }
1399
1400 /* apply some statistical analysis */
1402 ((weight * hi_byte_diff) < lo_byte_diff))
1403 {
1404 out_flags |= IS_TEXT_UNICODE_STATISTICS;
1405 }
1406
1407 /* Check for unicode NULL chars */
1409 {
1410 for (i = 0; i < len; i++)
1411 {
1412 if (!(s[i] & 0xff) || !(s[i] >> 8))
1413 {
1414 out_flags |= IS_TEXT_UNICODE_NULL_BYTES;
1415 break;
1416 }
1417 }
1418 }
1419
1421 {
1422 for (i = 0; i < len; i++)
1423 {
1424 if (strchrW(std_control_chars, s[i]))
1425 {
1426 out_flags |= IS_TEXT_UNICODE_CONTROLS;
1427 break;
1428 }
1429 }
1430 }
1431
1433 {
1434 for (i = 0; i < len; i++)
1435 {
1436 if (strchrW(byterev_control_chars, s[i]))
1437 {
1439 break;
1440 }
1441 }
1442 }
1443
1444 if (pf)
1445 {
1446 out_flags &= *pf;
1447 *pf = out_flags;
1448 }
1449
1450 /* check for flags that indicate it's definitely not valid Unicode */
1452
1453 /* now check for invalid ASCII, and assume Unicode if so */
1454 if (out_flags & IS_TEXT_UNICODE_NOT_ASCII_MASK) return TRUE;
1455
1456 /* now check for Unicode flags */
1457 if (out_flags & IS_TEXT_UNICODE_UNICODE_MASK) return TRUE;
1458
1459 /* no flags set */
1460 return FALSE;
1461}
1462
1463
1464/*
1465 * @implemented
1466 *
1467 * NOTES
1468 * Same as RtlOemStringToUnicodeString but doesn't write terminating null
1469 * A partial copy is NOT performed if the dest buffer is too small!
1470 */
1472NTAPI
1474 IN OUT PUNICODE_STRING UniDest,
1475 IN PCOEM_STRING OemSource,
1477{
1479 ULONG Length;
1480 ULONG Index;
1481
1483
1484 /* Calculate size of the string */
1486
1487 /* If it's 0 then zero out dest string and return */
1488 if (!Length)
1489 {
1490 RtlZeroMemory(UniDest, sizeof(UNICODE_STRING));
1491 return STATUS_SUCCESS;
1492 }
1493
1494 /* Check if length is a sane value */
1496
1497 /* Store it in dest string */
1498 UniDest->Length = (USHORT)Length;
1499
1500 /* If we're asked to alloc the string - do so */
1502 {
1503 UniDest->Buffer = RtlpAllocateStringMemory(Length, TAG_USTR);
1504 UniDest->MaximumLength = (USHORT)Length;
1505
1506 if (!UniDest->Buffer) return STATUS_NO_MEMORY;
1507 }
1508 else if (UniDest->Length > UniDest->MaximumLength)
1509 {
1511 }
1512
1513 /* Do the conversion */
1514 Status = RtlOemToUnicodeN(UniDest->Buffer,
1515 UniDest->Length,
1516 &Index,
1517 OemSource->Buffer,
1518 OemSource->Length);
1519
1521 {
1522 /* Conversion failed, free dest string and return status code */
1523 RtlpFreeStringMemory(UniDest->Buffer, TAG_USTR);
1524 UniDest->Buffer = NULL;
1525 return Status;
1526 }
1527
1528 return STATUS_SUCCESS;
1529}
1530
1531/*
1532 * @implemented
1533 *
1534 * RETURNS
1535 * TRUE if the names are equal, FALSE if not
1536 *
1537 * NOTES
1538 * The comparison is case insensitive.
1539 */
1540BOOLEAN
1541NTAPI
1543 IN PUNICODE_STRING ComputerName1,
1544 IN PUNICODE_STRING ComputerName2)
1545{
1546 OEM_STRING OemString1;
1547 OEM_STRING OemString2;
1549
1551 ComputerName1,
1552 TRUE)))
1553 {
1555 ComputerName2,
1556 TRUE)))
1557 {
1558 Result = RtlEqualString(&OemString1, &OemString2, FALSE);
1559 RtlFreeOemString(&OemString2);
1560 }
1561
1562 RtlFreeOemString(&OemString1);
1563 }
1564
1565 return Result;
1566}
1567
1568/*
1569 * @implemented
1570 *
1571 * RETURNS
1572 * TRUE if the names are equal, FALSE if not
1573 *
1574 * NOTES
1575 * The comparison is case insensitive.
1576 */
1577BOOLEAN
1578NTAPI
1580 IN PUNICODE_STRING DomainName1,
1581 IN PUNICODE_STRING DomainName2)
1582{
1583 return RtlEqualComputerName(DomainName1, DomainName2);
1584}
1585
1586/*
1587 * @implemented
1588 *
1589 * RIPPED FROM WINE's ntdll\rtlstr.c rev 1.45
1590 *
1591 * Convert a string representation of a GUID into a GUID.
1592 *
1593 * PARAMS
1594 * str [I] String representation in the format "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}"
1595 * guid [O] Destination for the converted GUID
1596 *
1597 * RETURNS
1598 * Success: STATUS_SUCCESS. guid contains the converted value.
1599 * Failure: STATUS_INVALID_PARAMETER, if str is not in the expected format.
1600 *
1601 * SEE ALSO
1602 * See RtlStringFromGUID.
1603 */
1605NTAPI
1608 OUT GUID* guid)
1609{
1610 int i = 0;
1611 const WCHAR *lpszCLSID = str->Buffer;
1612 BYTE* lpOut = (BYTE*)guid;
1613
1614 //TRACE("(%s,%p)\n", debugstr_us(str), guid);
1615
1616 /* Convert string: {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}
1617 * to memory: DWORD... WORD WORD BYTES............
1618 */
1619 while (i <= 37)
1620 {
1621 switch (i)
1622 {
1623 case 0:
1624 if (*lpszCLSID != '{')
1626 break;
1627
1628 case 9:
1629 case 14:
1630 case 19:
1631 case 24:
1632 if (*lpszCLSID != '-')
1634 break;
1635
1636 case 37:
1637 if (*lpszCLSID != '}')
1639
1640 break;
1641
1642 default:
1643 {
1644 WCHAR ch = *lpszCLSID, ch2 = lpszCLSID[1];
1645 unsigned char byte;
1646
1647 /* Read two hex digits as a byte value */
1648 if (ch >= '0' && ch <= '9')
1649 ch = ch - '0';
1650 else if (ch >= 'a' && ch <= 'f')
1651 ch = ch - 'a' + 10;
1652 else if (ch >= 'A' && ch <= 'F')
1653 ch = ch - 'A' + 10;
1654 else
1656
1657 if (ch2 >= '0' && ch2 <= '9')
1658 ch2 = ch2 - '0';
1659 else if (ch2 >= 'a' && ch2 <= 'f')
1660 ch2 = ch2 - 'a' + 10;
1661 else if (ch2 >= 'A' && ch2 <= 'F')
1662 ch2 = ch2 - 'A' + 10;
1663 else
1665
1666 byte = ch << 4 | ch2;
1667
1668 switch (i)
1669 {
1670#ifndef WORDS_BIGENDIAN
1671 /* For Big Endian machines, we store the data such that the
1672 * dword/word members can be read as DWORDS and WORDS correctly. */
1673 /* Dword */
1674 case 1:
1675 lpOut[3] = byte;
1676 break;
1677 case 3:
1678 lpOut[2] = byte;
1679 break;
1680 case 5:
1681 lpOut[1] = byte;
1682 break;
1683 case 7:
1684 lpOut[0] = byte;
1685 lpOut += 4;
1686 break;
1687 /* Word */
1688 case 10:
1689 case 15:
1690 lpOut[1] = byte;
1691 break;
1692 case 12:
1693 case 17:
1694 lpOut[0] = byte;
1695 lpOut += 2;
1696 break;
1697#endif
1698 /* Byte */
1699 default:
1700 lpOut[0] = byte;
1701 lpOut++;
1702 break;
1703 }
1704
1705 lpszCLSID++; /* Skip 2nd character of byte */
1706 i++;
1707 }
1708 }
1709
1710 lpszCLSID++;
1711 i++;
1712 }
1713
1714 return STATUS_SUCCESS;
1715}
1716
1717/*
1718 * @implemented
1719 */
1720VOID
1721NTAPI
1724{
1725 if (String->Buffer && String->MaximumLength)
1726 {
1727 RtlZeroMemory(String->Buffer, String->MaximumLength);
1728 String->Length = 0;
1729 }
1730}
1731
1732/*
1733* @implemented
1734*/
1736NTAPI
1742{
1743 if (String != NULL && HashValue != NULL)
1744 {
1745 switch (HashAlgorithm)
1746 {
1749 {
1750 WCHAR *c, *end;
1751
1752 *HashValue = 0;
1753 end = String->Buffer + (String->Length / sizeof(WCHAR));
1754
1755 if (CaseInSensitive)
1756 {
1757 for (c = String->Buffer; c != end; c++)
1758 {
1759 /* only uppercase characters if they are 'a' ... 'z'! */
1760 *HashValue = ((65599 * (*HashValue)) +
1761 (ULONG)(((*c) >= L'a' && (*c) <= L'z') ?
1762 (*c) - L'a' + L'A' : (*c)));
1763 }
1764 }
1765 else
1766 {
1767 for (c = String->Buffer; c != end; c++)
1768 {
1769 *HashValue = ((65599 * (*HashValue)) + (ULONG)(*c));
1770 }
1771 }
1772
1773 return STATUS_SUCCESS;
1774 }
1775 }
1776 }
1777
1779}
1780
1781/*
1782 * @implemented
1783 *
1784 * NOTES
1785 * Same as RtlUnicodeStringToOemString but doesn't write terminating null
1786 */
1791NTAPI
1792RtlUnicodeStringToCountedOemString(
1795 POEM_STRING OemDest,
1796 _In_ PCUNICODE_STRING UniSource,
1798{
1800 ULONG Length;
1801 ULONG Index;
1802
1804
1805 /* Calculate size of the string */
1806 Length = RtlUnicodeStringToCountedOemSize(UniSource);
1807
1808 /* If it's 0 then zero out dest string and return */
1809 if (!Length)
1810 {
1811 RtlZeroMemory(OemDest, sizeof(OEM_STRING));
1812 return STATUS_SUCCESS;
1813 }
1814
1815 /* Check if length is a sane value */
1817
1818 /* Store it in dest string */
1819 OemDest->Length = (USHORT)Length;
1820
1821 /* If we're asked to alloc the string - do so */
1823 {
1824 OemDest->Buffer = RtlpAllocateStringMemory(Length, TAG_OSTR);
1825 OemDest->MaximumLength = (USHORT)Length;
1826 if (!OemDest->Buffer) return STATUS_NO_MEMORY;
1827 }
1828 else if (OemDest->Length > OemDest->MaximumLength)
1829 {
1831 }
1832
1833 /* Do the conversion */
1834 Status = RtlUnicodeToOemN(OemDest->Buffer,
1835 OemDest->Length,
1836 &Index,
1837 UniSource->Buffer,
1838 UniSource->Length);
1839
1840 /* Check for unmapped character */
1841 if (NT_SUCCESS(Status) && !RtlpDidUnicodeToOemWork(UniSource, OemDest))
1843
1845 {
1846 /* Conversion failed, free dest string and return status code */
1847 RtlpFreeStringMemory(OemDest->Buffer, TAG_OSTR);
1848 OemDest->Buffer = NULL;
1849 return Status;
1850 }
1851
1852 return Status;
1853}
1854
1855/*
1856 * @implemented
1857 */
1859NTAPI
1862 IN ULONG Base,
1863 IN ULONG Length,
1865{
1866 ULONGLONG Val = Value->QuadPart;
1867 CHAR Buffer[65];
1868 CHAR Digit;
1869 SIZE_T Len;
1870 PCHAR Pos;
1871
1872 if (Base == 0) Base = 10;
1873
1874 if ((Base != 2) && (Base != 8) && (Base != 10) && (Base != 16))
1875 {
1877 }
1878
1879 Pos = &Buffer[64];
1880 *Pos = '\0';
1881
1882 do
1883 {
1884 Pos--;
1885 Digit = (CHAR)(Val % Base);
1886 Val = Val / Base;
1887
1888 if (Digit < 10)
1889 *Pos = '0' + Digit;
1890 else
1891 *Pos = 'A' + Digit - 10;
1892 }
1893 while (Val != 0L);
1894
1895 Len = &Buffer[64] - Pos;
1896
1897 if (Len > Length)
1899
1900 /* If possible, add the 0 termination */
1901 if (Len < Length)
1902 Len += 1;
1903
1904 /* Copy the string to the target using SEH */
1905 return RtlpSafeCopyMemory(String, Pos, Len);
1906}
1907
1908/*
1909 * @implemented
1910 *
1911 * NOTES
1912 * dest is never '\0' terminated because it may be equal to src, and src
1913 * might not be '\0' terminated. dest->Length is only set upon success.
1914 */
1916NTAPI
1918 IN OUT PUNICODE_STRING UniDest,
1919 IN PCUNICODE_STRING UniSource,
1921{
1922 ULONG i, j;
1923
1925
1927 {
1928 UniDest->MaximumLength = UniSource->Length;
1929 UniDest->Buffer = RtlpAllocateStringMemory(UniDest->MaximumLength, TAG_USTR);
1930 if (UniDest->Buffer == NULL) return STATUS_NO_MEMORY;
1931 }
1932 else if (UniSource->Length > UniDest->MaximumLength)
1933 {
1935 }
1936
1937 j = UniSource->Length / sizeof(WCHAR);
1938
1939 for (i = 0; i < j; i++)
1940 {
1941 UniDest->Buffer[i] = RtlpUpcaseUnicodeChar(UniSource->Buffer[i]);
1942 }
1943
1944 UniDest->Length = UniSource->Length;
1945 return STATUS_SUCCESS;
1946}
1947
1948/*
1949 * @implemented
1950 *
1951 * NOTES
1952 * This function always writes a terminating '\0'.
1953 * It performs a partial copy if ansi is too small.
1954 */
1956NTAPI
1958 IN OUT PANSI_STRING AnsiDest,
1959 IN PCUNICODE_STRING UniSource,
1961{
1963 ULONG Length;
1964 ULONG Index;
1966
1969
1970 AnsiDest->Length = (USHORT)Length - sizeof(CHAR);
1971
1973 {
1974 AnsiDest->Buffer = RtlpAllocateStringMemory(Length, TAG_ASTR);
1975 AnsiDest->MaximumLength = (USHORT)Length;
1976 if (!AnsiDest->Buffer) return STATUS_NO_MEMORY;
1977 }
1978 else if (AnsiDest->Length >= AnsiDest->MaximumLength)
1979 {
1980 if (!AnsiDest->MaximumLength) return STATUS_BUFFER_OVERFLOW;
1981 }
1982
1983 Status = RtlUpcaseUnicodeToMultiByteN(AnsiDest->Buffer,
1984 AnsiDest->Length,
1985 &Index,
1986 UniSource->Buffer,
1987 UniSource->Length);
1988
1990 {
1991 RtlpFreeStringMemory(AnsiDest->Buffer, TAG_ASTR);
1992 AnsiDest->Buffer = NULL;
1993 return Status;
1994 }
1995
1996 AnsiDest->Buffer[Index] = ANSI_NULL;
1997 return Status;
1998}
1999
2000/*
2001 * @implemented
2002 *
2003 * NOTES
2004 * This function always writes a terminating '\0'.
2005 * It performs a partial copy if ansi is too small.
2006 */
2008NTAPI
2010 IN OUT POEM_STRING OemDest,
2011 IN PCUNICODE_STRING UniSource,
2013{
2015 ULONG Length;
2016 ULONG Index;
2018
2019 Length = RtlUnicodeStringToCountedOemSize(UniSource);
2020
2021 if (!Length)
2022 {
2023 RtlZeroMemory(OemDest, sizeof(OEM_STRING));
2024 }
2025
2027
2028 OemDest->Length = (USHORT)Length;
2029
2031 {
2032 OemDest->Buffer = RtlpAllocateStringMemory(Length, TAG_OSTR);
2033 OemDest->MaximumLength = (USHORT)Length;
2034 if (!OemDest->Buffer) return STATUS_NO_MEMORY;
2035 }
2036 else if (OemDest->Length > OemDest->MaximumLength)
2037 {
2039 }
2040
2041 Status = RtlUpcaseUnicodeToOemN(OemDest->Buffer,
2042 OemDest->Length,
2043 &Index,
2044 UniSource->Buffer,
2045 UniSource->Length);
2046
2047 /* Check for unmapped characters */
2048 if (NT_SUCCESS(Status) && !RtlpDidUnicodeToOemWork(UniSource, OemDest))
2050
2052 {
2053 RtlpFreeStringMemory(OemDest->Buffer, TAG_OSTR);
2054 OemDest->Buffer = NULL;
2055 return Status;
2056 }
2057
2058 return Status;
2059}
2060
2061/*
2062 * @implemented
2063 * NOTES
2064 * OEM string is always nullterminated
2065 * It performs a partial copy if oem is too small.
2066 */
2068NTAPI
2070 IN OUT POEM_STRING OemDest,
2071 IN PCUNICODE_STRING UniSource,
2073{
2075 ULONG Length;
2076 ULONG Index;
2078
2079 Length = RtlUnicodeStringToOemSize(UniSource);
2081
2082 OemDest->Length = (USHORT)Length - sizeof(CHAR);
2083
2085 {
2086 OemDest->Buffer = RtlpAllocateStringMemory(Length, TAG_OSTR);
2087 OemDest->MaximumLength = (USHORT)Length;
2088 if (!OemDest->Buffer) return STATUS_NO_MEMORY;
2089 }
2090 else if (OemDest->Length >= OemDest->MaximumLength)
2091 {
2093 }
2094
2095 Status = RtlUpcaseUnicodeToOemN(OemDest->Buffer,
2096 OemDest->Length,
2097 &Index,
2098 UniSource->Buffer,
2099 UniSource->Length);
2100
2101 /* Check for unmapped characters */
2102 if (NT_SUCCESS(Status) && !RtlpDidUnicodeToOemWork(UniSource, OemDest))
2104
2106 {
2107 RtlpFreeStringMemory(OemDest->Buffer, TAG_OSTR);
2108 OemDest->Buffer = NULL;
2109 return Status;
2110 }
2111
2112 OemDest->Buffer[Index] = ANSI_NULL;
2113 return Status;
2114}
2115
2116/*
2117 * @implemented
2118 *
2119 * RETURNS
2120 * Bytes calculated including nullterm
2121 */
2122ULONG
2123NTAPI
2125{
2126 ULONG Size;
2127
2128 /* Convert the Mb String to Unicode Size */
2130 OemString->Buffer,
2131 OemString->Length);
2132
2133 /* Return the size + null-char */
2134 return (Size + sizeof(WCHAR));
2135}
2136
2137/*
2138 * @implemented
2139 */
2141NTAPI
2144{
2145 /* Setup the string */
2146 GuidString->Length = 38 * sizeof(WCHAR);
2147 GuidString->MaximumLength = GuidString->Length + sizeof(UNICODE_NULL);
2148 GuidString->Buffer = RtlpAllocateStringMemory(GuidString->MaximumLength,
2149 TAG_USTR);
2150 if (!GuidString->Buffer) return STATUS_NO_MEMORY;
2151
2152 /* Now format the GUID */
2153 swprintf(GuidString->Buffer,
2154 L"{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
2155 Guid->Data1,
2156 Guid->Data2,
2157 Guid->Data3,
2158 Guid->Data4[0],
2159 Guid->Data4[1],
2160 Guid->Data4[2],
2161 Guid->Data4[3],
2162 Guid->Data4[4],
2163 Guid->Data4[5],
2164 Guid->Data4[6],
2165 Guid->Data4[7]);
2166 return STATUS_SUCCESS;
2167}
2168
2169/*
2170 * @implemented
2171 *
2172 * RETURNS
2173 * Bytes calculated including nullterm
2174 */
2175ULONG
2176NTAPI
2178{
2179 ULONG Size;
2181
2182 ASSERT(!(UnicodeString->Length & 1));
2183
2184 /* Convert the Unicode String to Mb Size */
2186 UnicodeString->Buffer,
2187 UnicodeString->Length);
2188
2189 /* Return the size + null-char */
2190 return (Size + sizeof(CHAR));
2191}
2192
2193/*
2194 * @implemented
2195 */
2196LONG
2197NTAPI
2202{
2203 unsigned int len;
2204 LONG ret = 0;
2205 LPCWSTR p1, p2;
2206
2207 len = min(s1->Length, s2->Length) / sizeof(WCHAR);
2208 p1 = s1->Buffer;
2209 p2 = s2->Buffer;
2210
2211 if (CaseInsensitive)
2212 {
2213 while (!ret && len--) ret = RtlpUpcaseUnicodeChar(*p1++) - RtlpUpcaseUnicodeChar(*p2++);
2214 }
2215 else
2216 {
2217 while (!ret && len--) ret = *p1++ - *p2++;
2218 }
2219
2220 if (!ret) ret = s1->Length - s2->Length;
2221
2222 return ret;
2223}
2224
2225/*
2226 * @implemented
2227 */
2231LONG
2232NTAPI
2239{
2240 LONG Result = 0;
2241 SIZE_T MinStringLength = min(String1Length, String2Length);
2242 SIZE_T Index;
2243
2244 if (CaseInSensitive)
2245 {
2246 for (Index = 0; Index < MinStringLength; Index++)
2247 {
2248 WCHAR Char1 = RtlpUpcaseUnicodeChar(String1[Index]);
2250 Result = Char1 - Char2;
2251 if (Result != 0)
2252 {
2253 return Result;
2254 }
2255 }
2256 }
2257 else
2258 {
2259 for (Index = 0; Index < MinStringLength; Index++)
2260 {
2261 Result = String1[Index] - String2[Index];
2262 if (Result != 0)
2263 {
2264 return Result;
2265 }
2266 }
2267 }
2268
2270}
2271
2272/*
2273 * @implemented
2274 */
2275VOID
2276NTAPI
2280{
2281 ULONG SourceLength;
2282 PCHAR p1, p2;
2283
2284 /* Check if there was no source given */
2285 if (!SourceString)
2286 {
2287 /* Simply return an empty string */
2289 }
2290 else
2291 {
2292 /* Choose the smallest length */
2293 SourceLength = min(DestinationString->MaximumLength,
2295
2296 /* Set it */
2297 DestinationString->Length = (USHORT)SourceLength;
2298
2299 /* Save the pointers to each buffer */
2301 p2 = SourceString->Buffer;
2302
2303 /* Loop the buffer */
2304 while (SourceLength)
2305 {
2306 /* Copy the character and move on */
2307 *p1++ = * p2++;
2308 SourceLength--;
2309 }
2310 }
2311}
2312
2313/*
2314 * @implemented
2315 */
2316VOID
2317NTAPI
2321{
2322 ULONG SourceLength;
2323
2324 if (!SourceString)
2325 {
2327 }
2328 else
2329 {
2330 SourceLength = min(DestinationString->MaximumLength,
2332 DestinationString->Length = (USHORT)SourceLength;
2333
2336 SourceLength);
2337
2339 {
2340 DestinationString->Buffer[SourceLength / sizeof(WCHAR)] = UNICODE_NULL;
2341 }
2342 }
2343}
2344
2345/*
2346 * @implemented
2347 *
2348 * NOTES
2349 * Creates a nullterminated UNICODE_STRING
2350 */
2351BOOLEAN
2352NTAPI
2354 IN OUT PUNICODE_STRING UniDest,
2356{
2357 SIZE_T Size;
2359
2360 Size = (wcslen(Source) + 1) * sizeof(WCHAR);
2361 if (Size > MAXUSHORT) return FALSE;
2362
2363 UniDest->Buffer = RtlpAllocateStringMemory((ULONG)Size, TAG_USTR);
2364
2365 if (UniDest->Buffer == NULL) return FALSE;
2366
2367 RtlCopyMemory(UniDest->Buffer, Source, Size);
2368 UniDest->MaximumLength = (USHORT)Size;
2369 UniDest->Length = (USHORT)Size - sizeof (WCHAR);
2370
2371 return TRUE;
2372}
2373
2374/*
2375 * @implemented
2376 */
2377BOOLEAN
2378NTAPI
2381 IN PCSZ Source)
2382{
2385
2387
2389 &AnsiString,
2390 TRUE);
2391
2392 return NT_SUCCESS(Status);
2393}
2394
2395/*
2396 * @implemented
2397 *
2398 * NOTES
2399 * Dest is never '\0' terminated because it may be equal to src, and src
2400 * might not be '\0' terminated.
2401 * Dest->Length is only set upon success.
2402 */
2404NTAPI
2406 IN OUT PUNICODE_STRING UniDest,
2407 IN PCUNICODE_STRING UniSource,
2409{
2410 ULONG i;
2411 ULONG StopGap;
2413
2415 {
2416 UniDest->MaximumLength = UniSource->Length;
2417 UniDest->Buffer = RtlpAllocateStringMemory(UniSource->Length, TAG_USTR);
2418 if (UniDest->Buffer == NULL) return STATUS_NO_MEMORY;
2419 }
2420 else if (UniSource->Length > UniDest->MaximumLength)
2421 {
2423 }
2424
2425 UniDest->Length = UniSource->Length;
2426 StopGap = UniSource->Length / sizeof(WCHAR);
2427
2428 for (i = 0 ; i < StopGap; i++)
2429 {
2430 if (UniSource->Buffer[i] < L'A')
2431 {
2432 UniDest->Buffer[i] = UniSource->Buffer[i];
2433 }
2434 else if (UniSource->Buffer[i] <= L'Z')
2435 {
2436 UniDest->Buffer[i] = (UniSource->Buffer[i] + (L'a' - L'A'));
2437 }
2438 else
2439 {
2440 UniDest->Buffer[i] = RtlpDowncaseUnicodeChar(UniSource->Buffer[i]);
2441 }
2442 }
2443
2444 return STATUS_SUCCESS;
2445}
2446
2447/*
2448 * @implemented
2449 *
2450 * NOTES
2451 * if src is NULL dest is unchanged.
2452 * dest is '\0' terminated when the MaximumLength allowes it.
2453 * When dest fits exactly in MaximumLength characters the '\0' is ommitted.
2454 */
2456NTAPI
2459{
2460 USHORT Length;
2461 PWCHAR DestBuffer;
2462
2463 if (Source)
2464 {
2465 UNICODE_STRING UnicodeSource;
2466
2467 RtlInitUnicodeString(&UnicodeSource, Source);
2468 Length = UnicodeSource.Length;
2469
2471 {
2473 }
2474
2475 DestBuffer = &Destination->Buffer[Destination->Length / sizeof(WCHAR)];
2476 RtlMoveMemory(DestBuffer, Source, Length);
2478
2479 /* append terminating '\0' if enough space */
2481 {
2482 DestBuffer[Length / sizeof(WCHAR)] = UNICODE_NULL;
2483 }
2484 }
2485
2486 return STATUS_SUCCESS;
2487}
2488
2489/*
2490 * @implemented
2491 *
2492 * NOTES
2493 * if src is NULL dest is unchanged.
2494 * dest is never '\0' terminated.
2495 */
2497NTAPI
2500 IN PCSZ Source)
2501{
2502 SIZE_T Size;
2503
2504 if (Source)
2505 {
2506 Size = strlen(Source);
2507
2509 {
2511 }
2512
2515 }
2516
2517 return STATUS_SUCCESS;
2518}
2519
2520/*
2521 * @implemented
2522 */
2523VOID
2524NTAPI
2526 const STRING *SourceString)
2527{
2528 USHORT Length;
2529 PCHAR Src, Dest;
2530
2533
2534 Src = SourceString->Buffer;
2535 Dest = DestinationString->Buffer;
2537
2538 while (Length)
2539 {
2540 *Dest++ = RtlUpperChar(*Src++);
2541 Length--;
2542 }
2543}
2544
2545/*
2546 * @implemented
2547 *
2548 * NOTES
2549 * See RtlpDuplicateUnicodeString
2550 */
2552NTAPI
2554 IN ULONG Flags,
2557{
2559
2560 if (SourceString == NULL || DestinationString == NULL ||
2564 {
2566 }
2567
2568
2569 if ((SourceString->Length == 0) &&
2572 {
2576 }
2577 else
2578 {
2579 UINT DestMaxLength = SourceString->Length;
2580
2582 DestMaxLength += sizeof(UNICODE_NULL);
2583
2585
2587 return STATUS_NO_MEMORY;
2588
2591 DestinationString->MaximumLength = DestMaxLength;
2592
2595 }
2596
2597 return STATUS_SUCCESS;
2598}
2599
2600/*
2601 * @implemented
2602 */
2604NTAPI
2608{
2609 /* In Windows <= 2003 no flags are supported yet! */
2610 if (Flags != 0)
2612
2613 /* NOTE: a NULL Unicode string pointer is considered to be a valid one! */
2614 if (String == NULL)
2615 {
2616 return STATUS_SUCCESS;
2617 }
2618 else if (!((String->Buffer == NULL) && (String->Length != 0 || String->MaximumLength != 0)) &&
2619 (String->Length % sizeof(WCHAR) == 0) &&
2620 (String->MaximumLength % sizeof(WCHAR) == 0) &&
2621 (String->Length <= String->MaximumLength))
2622 {
2623 return STATUS_SUCCESS;
2624 }
2625 else
2626 {
2628 }
2629}
2630
2631/*
2632 * @implemented
2633 */
2635NTAPI
2637 IN ULONG Flags,
2640{
2641 PUCHAR NewBuffer;
2642
2643 /* Parameter checks */
2646 if (Buffer == NULL)
2648
2649 /*
2650 * We don't need to grow the buffer if its size
2651 * is already larger than the required size.
2652 */
2653 if (Buffer->Size >= RequiredSize)
2654 return STATUS_SUCCESS;
2655
2656 /*
2657 * When we are using the static buffer as our buffer, we don't need
2658 * to grow it if its size is already larger than the required size.
2659 * In this case, just keep it but update the current buffer size to
2660 * the one requested.
2661 * (But NEVER EVER modify the size of the static buffer!!)
2662 * Otherwise, we'll need to create a new buffer and use this one instead.
2663 */
2664 if ( (Buffer->Buffer == Buffer->StaticBuffer) &&
2665 (Buffer->StaticSize >= RequiredSize) )
2666 {
2667 Buffer->Size = RequiredSize;
2668 return STATUS_SUCCESS;
2669 }
2670
2671 /* The buffer we are using is not large enough, try to create a bigger one */
2673 if (NewBuffer == NULL)
2674 return STATUS_NO_MEMORY;
2675
2676 /* Copy the original content if needed */
2677 if (!(Flags & RTL_SKIP_BUFFER_COPY))
2678 {
2679 RtlMoveMemory(NewBuffer, Buffer->Buffer, Buffer->Size);
2680 }
2681
2682 /* Free the original buffer only if it's not the static buffer */
2683 if (Buffer->Buffer != Buffer->StaticBuffer)
2684 {
2686 }
2687
2688 /* Update the members */
2689 Buffer->Buffer = NewBuffer;
2690 Buffer->Size = RequiredSize;
2691
2692 /* Done */
2693 return STATUS_SUCCESS;
2694}
2695
2696static
2697BOOLEAN
2699 IN WCHAR Char,
2702{
2703 USHORT i;
2704
2705 if (CaseInSensitive)
2706 Char = RtlpUpcaseUnicodeChar(Char);
2707
2708 for (i = 0; i < MatchString->Length / sizeof(WCHAR); i++)
2709 {
2710 WCHAR OtherChar = MatchString->Buffer[i];
2711 if (CaseInSensitive)
2712 OtherChar = RtlpUpcaseUnicodeChar(OtherChar);
2713
2714 if (Char == OtherChar)
2715 return TRUE;
2716 }
2717
2718 return FALSE;
2719}
2720
2721/*
2722 * @implemented
2723 */
2725NTAPI
2727 IN ULONG Flags,
2728 IN PCUNICODE_STRING SearchString,
2731{
2732 BOOLEAN Found;
2735 USHORT i, Length;
2736
2737 DPRINT("RtlFindCharInUnicodeString(%u, '%wZ', '%wZ', %p)\n",
2738 Flags, SearchString, MatchString, Position);
2739
2740 /* Parameter checks */
2741 if (Position == NULL)
2743
2744 *Position = 0;
2745
2750
2751 /* Search */
2752 Length = SearchString->Length / sizeof(WCHAR);
2754 {
2755 for (i = Length - 1; (SHORT)i >= 0; i--)
2756 {
2757 Found = RtlpIsCharInUnicodeString(SearchString->Buffer[i], MatchString, CaseInSensitive);
2758 if (Found == WantToFind)
2759 {
2760 *Position = i * sizeof(WCHAR);
2761 return STATUS_SUCCESS;
2762 }
2763 }
2764 }
2765 else
2766 {
2767 for (i = 0; i < Length; i++)
2768 {
2769 Found = RtlpIsCharInUnicodeString(SearchString->Buffer[i], MatchString, CaseInSensitive);
2770 if (Found == WantToFind)
2771 {
2772 *Position = (i + 1) * sizeof(WCHAR);
2773 return STATUS_SUCCESS;
2774 }
2775 }
2776 }
2777
2778 return STATUS_NOT_FOUND;
2779}
2780
2781/*
2782 * @implemented
2783 *
2784 * NOTES
2785 * Get the maximum of MAX_COMPUTERNAME_LENGTH characters from the dns.host name until the dot is found.
2786 * Convert is to an uppercase oem string and check for unmapped characters.
2787 * Then convert the oem string back to an unicode string.
2788 */
2790NTAPI
2791RtlDnsHostNameToComputerName(PUNICODE_STRING ComputerName, PUNICODE_STRING DnsHostName, BOOLEAN AllocateComputerNameString)
2792{
2794 ULONG Length;
2795 ULONG ComputerNameLength;
2796 ULONG ComputerNameOemNLength;
2797 OEM_STRING ComputerNameOem;
2798 CHAR ComputerNameOemN[MAX_COMPUTERNAME_LENGTH + 1];
2799
2801 ComputerNameLength = DnsHostName->Length;
2802
2803 /* find the first dot in the dns host name */
2804 for (Length = 0; Length < DnsHostName->Length / sizeof(WCHAR); Length++)
2805 {
2806 if (DnsHostName->Buffer[Length] == L'.')
2807 {
2808 /* dot found, so set the length for the oem translation */
2809 ComputerNameLength = Length * sizeof(WCHAR);
2810 break;
2811 }
2812 }
2813
2814 /* the computername must have one character */
2815 if (ComputerNameLength > 0)
2816 {
2817 ComputerNameOemNLength = 0;
2818 /* convert to oem string and use uppercase letters */
2819 Status = RtlUpcaseUnicodeToOemN(ComputerNameOemN,
2821 &ComputerNameOemNLength,
2822 DnsHostName->Buffer,
2823 ComputerNameLength);
2824
2825 /* status STATUS_BUFFER_OVERFLOW is not a problem since the computername shoud only
2826 have MAX_COMPUTERNAME_LENGTH characters */
2827 if ((Status == STATUS_SUCCESS) ||
2829 {
2830 /* set the termination for the oem string */
2831 ComputerNameOemN[MAX_COMPUTERNAME_LENGTH] = 0;
2832 /* set status for the case the next function failed */
2834 /* fillup the oem string structure with the converted computername
2835 and check it for unmapped characters */
2836 ComputerNameOem.Buffer = ComputerNameOemN;
2837 ComputerNameOem.Length = (USHORT)ComputerNameOemNLength;
2838 ComputerNameOem.MaximumLength = (USHORT)(MAX_COMPUTERNAME_LENGTH + 1);
2839
2840 if (RtlpDidUnicodeToOemWork(DnsHostName, &ComputerNameOem))
2841 {
2842 /* no unmapped character so convert it back to an unicode string */
2843 Status = RtlOemStringToUnicodeString(ComputerName,
2844 &ComputerNameOem,
2845 AllocateComputerNameString);
2846 }
2847 }
2848 }
2849
2850 return Status;
2851}
2852
unsigned char BOOLEAN
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
LONG NTSTATUS
Definition: precomp.h:26
#define DPRINT1
Definition: precomp.h:8
static BOOL MatchString(LPCWCH pch1, INT cch1, LPCWCH pch2, INT cch2)
Definition: find.c:91
#define CHAR(Char)
#define UNIMPLEMENTED
Definition: debug.h:118
#define NTSYSAPI
Definition: ntoskrnl.h:12
return Found
Definition: dirsup.c:1270
Definition: bufpool.h:45
#define Len
Definition: deflate.h:82
ush Pos
Definition: deflate.h:92
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define TAG_USTR
Definition: libsupp.c:997
#define RtlpAllocateStringMemory(Bytes, Tag)
Definition: libsupp.c:1000
static const unsigned char pc1[56]
Definition: des.c:54
static const unsigned char pc2[48]
Definition: des.c:68
#define byte(x, n)
Definition: tomcrypt.h:118
#define swprintf
Definition: precomp.h:40
@ AnsiString
Definition: dnslib.h:19
_In_ uint64_t _In_ uint64_t _In_ uint64_t _In_opt_ traverse_ptr * tp
Definition: btrfs.c:2996
#define ULONG_PTR
Definition: config.h:101
#define _IRQL_requires_max_(irql)
Definition: driverspecs.h:230
#define __drv_allocatesMem(kind)
Definition: driverspecs.h:257
#define PASSIVE_LEVEL
Definition: env_spec_w32.h:693
std::wstring STRING
Definition: fontsub.cpp:33
Status
Definition: gdiplustypes.h:25
const GLdouble * v
Definition: gl.h:2040
GLdouble s
Definition: gl.h:2039
GLuint GLuint end
Definition: gl.h:1545
GLuint buffer
Definition: glext.h:5915
const GLubyte * c
Definition: glext.h:8905
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLbitfield flags
Definition: glext.h:7161
GLuint GLsizei GLsizei * length
Definition: glext.h:6040
GLenum GLsizei len
Definition: glext.h:6722
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
#define RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING
Definition: green.h:16
#define RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE
Definition: green.h:15
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define LOBYTE(W)
Definition: jmemdos.c:487
#define HIBYTE(W)
Definition: jmemdos.c:486
#define c
Definition: ke_i.h:80
WCHAR StringBuffer[156]
Definition: ldrinit.c:41
const GUID * guid
struct S1 s1
struct S2 s2
#define PCHAR
Definition: match.c:90
#define ASSERT(a)
Definition: mode.c:44
static PWSTR GuidString
Definition: apphelp.c:93
static const WCHAR sp[]
Definition: suminfo.c:287
#define HASH_STRING_ALGORITHM_X65599
Definition: rtlstr.c:33
#define min(a, b)
Definition: monoChain.cc:55
#define __analysis_assume(expr)
Definition: ms_sal.h:2893
#define _Inout_
Definition: ms_sal.h:378
#define _At_(target, annos)
Definition: ms_sal.h:244
#define _Must_inspect_result_
Definition: ms_sal.h:558
#define _Out_
Definition: ms_sal.h:345
#define _When_(expr, annos)
Definition: ms_sal.h:254
#define _In_
Definition: ms_sal.h:308
#define _In_reads_(size)
Definition: ms_sal.h:319
unsigned int UINT
Definition: ndis.h:50
_In_ UINT _In_ UINT _In_ PNDIS_PACKET Source
Definition: ndis.h:3169
_In_ const STRING * String2
Definition: rtlfuncs.h:2357
_Out_ _Inout_ POEM_STRING _In_ PCUNICODE_STRING SourceString
Definition: rtlfuncs.h:1910
_In_ const STRING _In_ BOOLEAN CaseInSensitive
Definition: rtlfuncs.h:2390
NTSYSAPI BOOLEAN NTAPI RtlIsTextUnicode(_In_ CONST VOID *Buffer, _In_ INT Size, _Inout_opt_ INT *Flags)
_In_ const STRING _In_ BOOLEAN CaseInsensitive
Definition: rtlfuncs.h:2359
_In_ PSID _In_ BOOLEAN AllocateDestinationString
Definition: rtlfuncs.h:1349
_In_ PUNICODE_STRING _Inout_ PUNICODE_STRING Destination
Definition: rtlfuncs.h:3004
_Must_inspect_result_ NTSYSAPI LONG NTAPI RtlCompareUnicodeStrings(_In_reads_(String1Length) PCWCH String1, _In_ SIZE_T String1Length, _In_reads_(String2Length) PCWCH String2, _In_ SIZE_T String2Length, _In_ BOOLEAN CaseInSensitive)
_In_opt_ ULONG Base
Definition: rtlfuncs.h:2439
_Out_ _Inout_ POEM_STRING DestinationString
Definition: rtlfuncs.h:1909
#define RTL_SKIP_BUFFER_COPY
Definition: rtlfuncs.h:2451
WCHAR NTAPI RtlpUpcaseUnicodeChar(_In_ WCHAR Source)
Definition: nlsboot.c:160
WCHAR NTAPI RtlpDowncaseUnicodeChar(_In_ WCHAR Source)
Definition: nlsboot.c:32
_Use_decl_annotations_ NTSTATUS NTAPI RtlUpcaseUnicodeToMultiByteN(_Out_ PCHAR MbString, _In_ ULONG MbSize, _Out_opt_ PULONG ResultSize, _In_ PCWCH UnicodeString, _In_ ULONG UnicodeSize)
Definition: nlsboot.c:185
_Use_decl_annotations_ NTSTATUS NTAPI RtlUnicodeToOemN(_Out_ PCHAR OemString, _In_ ULONG OemSize, _Out_opt_ PULONG ResultSize, _In_ PCWCH UnicodeString, _In_ ULONG UnicodeSize)
Definition: nlsboot.c:263
_Use_decl_annotations_ NTSTATUS NTAPI RtlUnicodeToMultiByteN(_Out_ PCHAR MbString, _In_ ULONG MbSize, _Out_opt_ PULONG ResultSize, _In_ PCWCH UnicodeString, _In_ ULONG UnicodeSize)
Definition: nlsboot.c:107
_Use_decl_annotations_ NTSTATUS NTAPI RtlUpcaseUnicodeToOemN(_Out_ PCHAR OemString, _In_ ULONG OemSize, _Out_opt_ PULONG ResultSize, _In_ PCWCH UnicodeString, _In_ ULONG UnicodeSize)
Definition: nlsboot.c:301
_Use_decl_annotations_ NTSTATUS NTAPI RtlUnicodeToMultiByteSize(_Out_ PULONG MbSize, _In_ PCWCH UnicodeString, _In_ ULONG UnicodeSize)
Definition: nlsboot.c:145
_Use_decl_annotations_ NTSTATUS NTAPI RtlMultiByteToUnicodeN(_Out_ PWCH UnicodeString, _In_ ULONG UnicodeSize, _Out_opt_ PULONG ResultSize, _In_ PCCH MbString, _In_ ULONG MbSize)
Definition: nlsboot.c:62
_Use_decl_annotations_ NTSTATUS NTAPI RtlOemToUnicodeN(_Out_ PWCHAR UnicodeString, _In_ ULONG UnicodeSize, _Out_opt_ PULONG ResultSize, _In_ PCCH OemString, _In_ ULONG OemSize)
Definition: nlsboot.c:282
CHAR NTAPI RtlUpperChar(_In_ CHAR Source)
Definition: nlsboot.c:229
_Use_decl_annotations_ NTSTATUS NTAPI RtlMultiByteToUnicodeSize(_Out_ PULONG UnicodeSize, _In_ PCCH MbString, _In_ ULONG MbSize)
Definition: nlsboot.c:93
CONST WCHAR * PCWCH
Definition: ntbasedef.h:411
#define UNICODE_NULL
#define ANSI_NULL
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
#define RTL_FIND_CHAR_IN_UNICODE_STRING_START_AT_END
Definition: rtl.h:25
#define RTL_FIND_CHAR_IN_UNICODE_STRING_COMPLEMENT_CHAR_SET
Definition: rtl.h:26
#define RTL_FIND_CHAR_IN_UNICODE_STRING_CASE_INSENSITIVE
Definition: rtl.h:27
#define STATUS_INVALID_PARAMETER_2
Definition: ntstatus.h:476
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
#define STATUS_INVALID_COMPUTER_NAME
Definition: ntstatus.h:526
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:239
#define STATUS_UNMAPPABLE_CHARACTER
Definition: ntstatus.h:590
#define STATUS_NAME_TOO_LONG
Definition: ntstatus.h:498
#define L(x)
Definition: ntvdm.h:50
#define CONST
Definition: pedump.c:81
short SHORT
Definition: pedump.c:59
long LONG
Definition: pedump.c:60
unsigned short USHORT
Definition: pedump.c:61
#define strchrW(s, c)
Definition: unicode.h:40
const WCHAR * str
static calc_node_t temp
Definition: rpn_ieee.c:38
NTSTATUS NTAPI RtlpSafeCopyMemory(_Out_writes_bytes_all_(Length) VOID UNALIGNED *Destination, _In_reads_bytes_(Length) CONST VOID UNALIGNED *Source, _In_ SIZE_T Length)
Definition: rtlcompat.c:56
#define RtlpFreeStringMemory
Definition: rtlp.h:156
#define PAGED_CODE_RTL()
Definition: rtlp.h:16
NTSTATUS NTAPI RtlDnsHostNameToComputerName(PUNICODE_STRING ComputerName, PUNICODE_STRING DnsHostName, BOOLEAN AllocateComputerNameString)
Definition: unicode.c:2791
NTSTATUS NTAPI RtlUnicodeStringToOemString(IN OUT POEM_STRING OemDest, IN PCUNICODE_STRING UniSource, IN BOOLEAN AllocateDestinationString)
Definition: unicode.c:1234
NTSTATUS NTAPI RtlCharToInteger(PCSZ str, ULONG base, PULONG value)
Definition: unicode.c:261
USHORT NlsOemDefaultChar
Definition: nlsboot.c:25
NTSTATUS NTAPI RtlpEnsureBufferSize(IN ULONG Flags, IN OUT PRTL_BUFFER Buffer, IN SIZE_T RequiredSize)
Definition: unicode.c:2636
BOOLEAN NTAPI RtlpDidUnicodeToOemWork(IN PCUNICODE_STRING UnicodeString, IN POEM_STRING OemString)
Definition: unicode.c:472
BOOLEAN NTAPI RtlPrefixUnicodeString(PCUNICODE_STRING String1, PCUNICODE_STRING String2, BOOLEAN CaseInsensitive)
Definition: unicode.c:935
NTSTATUS NTAPI RtlInt64ToUnicodeString(IN ULONGLONG Value, IN ULONG Base OPTIONAL, IN OUT PUNICODE_STRING String)
Definition: unicode.c:853
VOID NTAPI RtlFreeOemString(IN POEM_STRING OemString)
Definition: unicode.c:435
NTSTATUS NTAPI RtlMultiAppendUnicodeStringBuffer(OUT PRTL_UNICODE_STRING_BUFFER StringBuffer, IN ULONG NumberOfAddends, IN PCUNICODE_STRING Addends)
Definition: unicode.c:37
NTSTATUS NTAPI RtlUpcaseUnicodeStringToAnsiString(IN OUT PANSI_STRING AnsiDest, IN PCUNICODE_STRING UniSource, IN BOOLEAN AllocateDestinationString)
Definition: unicode.c:1957
NTSTATUS NTAPI RtlDuplicateUnicodeString(IN ULONG Flags, IN PCUNICODE_STRING SourceString, OUT PUNICODE_STRING DestinationString)
Definition: unicode.c:2553
PWCHAR NlsOemToUnicodeTable
Definition: nlsboot.c:20
NTSTATUS NTAPI RtlAppendUnicodeToString(IN OUT PUNICODE_STRING Destination, IN PCWSTR Source)
Definition: unicode.c:2457
PUSHORT NlsUnicodeToMbOemTable
Definition: nlsboot.c:22
NTSTATUS NTAPI RtlIntegerToUnicodeString(IN ULONG Value, IN ULONG Base OPTIONAL, IN OUT PUNICODE_STRING String)
Definition: unicode.c:826
BOOLEAN NTAPI RtlPrefixString(const STRING *String1, const STRING *String2, BOOLEAN CaseInsensitive)
Definition: unicode.c:886
BOOLEAN NTAPI RtlEqualString(IN const STRING *s1, IN const STRING *s2, IN BOOLEAN CaseInsensitive)
Definition: unicode.c:388
VOID NTAPI RtlFreeAnsiString(IN PANSI_STRING AnsiString)
Definition: unicode.c:419
BOOLEAN NTAPI RtlEqualDomainName(IN PUNICODE_STRING DomainName1, IN PUNICODE_STRING DomainName2)
Definition: unicode.c:1579
NTSTATUS NTAPI RtlLargeIntegerToChar(IN PLARGE_INTEGER Value, IN ULONG Base, IN ULONG Length, IN OUT PCHAR String)
Definition: unicode.c:1860
NTSTATUS NTAPI RtlDowncaseUnicodeString(IN OUT PUNICODE_STRING UniDest, IN PCUNICODE_STRING UniSource, IN BOOLEAN AllocateDestinationString)
Definition: unicode.c:2405
ULONG NTAPI RtlxOemStringToUnicodeSize(IN PCOEM_STRING OemString)
Definition: unicode.c:2124
NTSTATUS NTAPI RtlHashUnicodeString(IN CONST UNICODE_STRING *String, IN BOOLEAN CaseInSensitive, IN ULONG HashAlgorithm, OUT PULONG HashValue)
Definition: unicode.c:1737
NTSTATUS NTAPI RtlUnicodeStringToInteger(const UNICODE_STRING *str, ULONG base, ULONG *value)
Definition: unicode.c:982
NTSTATUS NTAPI RtlAppendAsciizToString(IN OUT PSTRING Destination, IN PCSZ Source)
Definition: unicode.c:2498
LONG NTAPI RtlCompareUnicodeString(IN PCUNICODE_STRING s1, IN PCUNICODE_STRING s2, IN BOOLEAN CaseInsensitive)
Definition: unicode.c:2198
NTSTATUS NTAPI RtlUpcaseUnicodeStringToCountedOemString(IN OUT POEM_STRING OemDest, IN PCUNICODE_STRING UniSource, IN BOOLEAN AllocateDestinationString)
Definition: unicode.c:2009
BOOLEAN NTAPI RtlEqualUnicodeString(IN CONST UNICODE_STRING *s1, IN CONST UNICODE_STRING *s2, IN BOOLEAN CaseInsensitive)
Definition: unicode.c:405
NTSTATUS NTAPI RtlIntegerToUnicode(IN ULONG Value, IN ULONG Base OPTIONAL, IN ULONG Length OPTIONAL, IN OUT LPWSTR String)
Definition: unicode.c:771
PUSHORT NlsOemLeadByteInfo
Definition: nlsboot.c:23
ULONG NTAPI RtlxUnicodeStringToAnsiSize(IN PCUNICODE_STRING UnicodeString)
Definition: unicode.c:2177
USHORT NlsUnicodeDefaultChar
Definition: nlsboot.c:26
VOID NTAPI RtlFreeUnicodeString(IN PUNICODE_STRING UnicodeString)
Definition: unicode.c:447
ULONG NTAPI RtlxAnsiStringToUnicodeSize(IN PCANSI_STRING AnsiString)
Definition: unicode.c:156
BOOLEAN NTAPI RtlEqualComputerName(IN PUNICODE_STRING ComputerName1, IN PUNICODE_STRING ComputerName2)
Definition: unicode.c:1542
BOOLEAN NlsMbOemCodePageTag
Definition: nlsboot.c:19
NTSTATUS NTAPI RtlValidateUnicodeString(_In_ ULONG Flags, _In_ PCUNICODE_STRING String)
Definition: unicode.c:2605
NTSTATUS NTAPI RtlUpcaseUnicodeStringToOemString(IN OUT POEM_STRING OemDest, IN PCUNICODE_STRING UniSource, IN BOOLEAN AllocateDestinationString)
Definition: unicode.c:2069
PUSHORT NlsLeadByteInfo
Definition: nls.c:26
NTSTATUS NTAPI RtlUnicodeStringToAnsiString(IN OUT PANSI_STRING AnsiDest, IN PCUNICODE_STRING UniSource, IN BOOLEAN AllocateDestinationString)
Definition: unicode.c:1113
VOID NTAPI RtlUpperString(PSTRING DestinationString, const STRING *SourceString)
Definition: unicode.c:2525
VOID NTAPI RtlCopyUnicodeString(IN OUT PUNICODE_STRING DestinationString, IN PCUNICODE_STRING SourceString)
Definition: unicode.c:2318
NTSTATUS NTAPI RtlFindCharInUnicodeString(IN ULONG Flags, IN PCUNICODE_STRING SearchString, IN PCUNICODE_STRING MatchString, OUT PUSHORT Position)
Definition: unicode.c:2726
NTSTATUS NTAPI RtlInitAnsiStringEx(IN OUT PANSI_STRING DestinationString, IN PCSZ SourceString)
Definition: unicode.c:596
WCHAR NTAPI RtlAnsiCharToUnicodeChar(IN OUT PUCHAR *AnsiChar)
Definition: unicode.c:50
static BOOLEAN RtlpIsCharInUnicodeString(IN WCHAR Char, IN PCUNICODE_STRING MatchString, IN BOOLEAN CaseInSensitive)
Definition: unicode.c:2698
NTSTATUS NTAPI RtlOemStringToCountedUnicodeString(IN OUT PUNICODE_STRING UniDest, IN PCOEM_STRING OemSource, IN BOOLEAN AllocateDestinationString)
Definition: unicode.c:1473
NTSTATUS NTAPI RtlIntegerToChar(ULONG value, ULONG base, ULONG length, PCHAR str)
Definition: unicode.c:704
NTSTATUS NTAPI RtlGUIDFromString(IN UNICODE_STRING *str, OUT GUID *guid)
Definition: unicode.c:1606
BOOLEAN NTAPI RtlIsValidOemCharacter(IN PWCHAR Char)
Definition: unicode.c:514
VOID NTAPI RtlInitString(IN OUT PSTRING DestinationString, IN PCSZ SourceString)
Definition: unicode.c:626
ULONG NTAPI RtlxUnicodeStringToOemSize(IN PCUNICODE_STRING UnicodeString)
Definition: unicode.c:1091
VOID NTAPI RtlInitUnicodeString(IN OUT PUNICODE_STRING DestinationString, IN PCWSTR SourceString)
Definition: unicode.c:641
VOID NTAPI RtlEraseUnicodeString(IN PUNICODE_STRING String)
Definition: unicode.c:1722
BOOLEAN NTAPI RtlCreateUnicodeString(IN OUT PUNICODE_STRING UniDest, IN PCWSTR Source)
Definition: unicode.c:2353
NTSTATUS NTAPI RtlUpcaseUnicodeString(IN OUT PUNICODE_STRING UniDest, IN PCUNICODE_STRING UniSource, IN BOOLEAN AllocateDestinationString)
Definition: unicode.c:1917
NTSTATUS NTAPI RtlStringFromGUID(IN REFGUID Guid, OUT PUNICODE_STRING GuidString)
Definition: unicode.c:2142
NTSTATUS NTAPI RtlInitUnicodeStringEx(OUT PUNICODE_STRING DestinationString, IN PCWSTR SourceString)
Definition: unicode.c:672
NTSTATUS NTAPI RtlAppendStringToString(IN PSTRING Destination, IN const STRING *Source)
Definition: unicode.c:179
PCHAR NlsUnicodeToOemTable
Definition: nlsboot.c:21
VOID NTAPI RtlInitAnsiString(IN OUT PANSI_STRING DestinationString, IN PCSZ SourceString)
Definition: unicode.c:573
VOID NTAPI RtlCopyString(IN OUT PSTRING DestinationString, IN const STRING *SourceString OPTIONAL)
Definition: unicode.c:2277
BOOLEAN NlsMbCodePageTag
Definition: nlsboot.c:17
NTSTATUS NTAPI RtlAnsiStringToUnicodeString(IN OUT PUNICODE_STRING UniDest, IN PANSI_STRING AnsiSource, IN BOOLEAN AllocateDestinationString)
Definition: unicode.c:91
NTSTATUS NTAPI RtlOemStringToUnicodeString(IN OUT PUNICODE_STRING UniDest, IN PCOEM_STRING OemSource, IN BOOLEAN AllocateDestinationString)
Definition: unicode.c:1180
BOOLEAN NTAPI RtlCreateUnicodeStringFromAsciiz(OUT PUNICODE_STRING Destination, IN PCSZ Source)
Definition: unicode.c:2379
LONG NTAPI RtlCompareString(IN const STRING *s1, IN const STRING *s2, IN BOOLEAN CaseInsensitive)
Definition: unicode.c:352
NTSTATUS NTAPI RtlAppendUnicodeStringToString(IN OUT PUNICODE_STRING Destination, IN PCUNICODE_STRING Source)
Definition: unicode.c:211
weight
Definition: sortkey.c:157
#define STATUS_SUCCESS
Definition: shellext.h:65
#define STATUS_NOT_FOUND
Definition: shellext.h:72
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66
#define DPRINT
Definition: sndvol32.h:73
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68
Definition: scsiwmi.h:51
unsigned short Length
Definition: sprintf.c:451
void * Buffer
Definition: sprintf.c:453
unsigned short MaximumLength
Definition: sprintf.c:452
USHORT MaximumLength
Definition: env_spec_w32.h:370
static COORD Position
Definition: mouse.c:34
#define max(a, b)
Definition: svc.c:63
#define TAG_OSTR
Definition: tag.h:147
#define TAG_ASTR
Definition: tag.h:146
#define MAXULONG
Definition: typedefs.h:251
uint32_t * PULONG
Definition: typedefs.h:59
const uint16_t * PCWSTR
Definition: typedefs.h:57
#define NTAPI
Definition: typedefs.h:36
ULONG_PTR SIZE_T
Definition: typedefs.h:80
int32_t INT
Definition: typedefs.h:58
uint16_t * PUSHORT
Definition: typedefs.h:56
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define MAXUSHORT
Definition: typedefs.h:83
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define IN
Definition: typedefs.h:39
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:264
uint16_t * PWCHAR
Definition: typedefs.h:56
unsigned char * PUCHAR
Definition: typedefs.h:53
uint32_t ULONG
Definition: typedefs.h:59
uint64_t ULONGLONG
Definition: typedefs.h:67
#define OUT
Definition: typedefs.h:40
char * PCHAR
Definition: typedefs.h:51
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
CONST STRING * PCOEM_STRING
Definition: umtypes.h:205
STRING OEM_STRING
Definition: umtypes.h:203
CONST char * PCSZ
Definition: umtypes.h:125
LONGLONG QuadPart
Definition: typedefs.h:114
Definition: pdh_main.c:94
int ret
_In_ WDFCOLLECTION _In_ ULONG Index
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ ULONG _Out_ PVOID _Out_ PULONG RequiredSize
Definition: wdfdevice.h:4439
_Must_inspect_result_ _In_ WDFDEVICE _In_ WDFSTRING String
Definition: wdfdevice.h:2433
_Must_inspect_result_ _In_ WDFOBJECT _In_ CONST GUID * Guid
Definition: wdfobject.h:762
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _Out_opt_ PUSHORT _Inout_opt_ PUNICODE_STRING Value
Definition: wdfregistry.h:413
#define MAX_COMPUTERNAME_LENGTH
Definition: winbase.h:243
#define IS_TEXT_UNICODE_ILLEGAL_CHARS
Definition: winnt_old.h:894
#define IS_TEXT_UNICODE_UNICODE_MASK
Definition: winnt_old.h:898
#define IS_TEXT_UNICODE_REVERSE_ASCII16
Definition: winnt_old.h:887
#define IS_TEXT_UNICODE_NOT_ASCII_MASK
Definition: winnt_old.h:901
#define IS_TEXT_UNICODE_NULL_BYTES
Definition: winnt_old.h:897
#define IS_TEXT_UNICODE_REVERSE_CONTROLS
Definition: winnt_old.h:891
#define IS_TEXT_UNICODE_REVERSE_MASK
Definition: winnt_old.h:899
#define IS_TEXT_UNICODE_DBCS_LEADBYTE
Definition: winnt_old.h:896
#define IS_TEXT_UNICODE_CONTROLS
Definition: winnt_old.h:890
#define IS_TEXT_UNICODE_ODD_LENGTH
Definition: winnt_old.h:895
#define IS_TEXT_UNICODE_REVERSE_SIGNATURE
Definition: winnt_old.h:893
#define IS_TEXT_UNICODE_NOT_UNICODE_MASK
Definition: winnt_old.h:900
#define IS_TEXT_UNICODE_STATISTICS
Definition: winnt_old.h:888
#define IS_TEXT_UNICODE_ASCII16
Definition: winnt_old.h:886
#define IS_TEXT_UNICODE_SIGNATURE
Definition: winnt_old.h:892
#define IS_TEXT_UNICODE_REVERSE_STATISTICS
Definition: winnt_old.h:889
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:409
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
#define RtlOemStringToUnicodeSize(STRING)
_In_ SIZE_T _In_ SIZE_T String2Length
Definition: rtlfuncs.h:515
_In_ BOOLEAN _In_ ULONG HashAlgorithm
Definition: rtlfuncs.h:2038
#define RtlUnicodeStringToOemSize(STRING)
*BytesInOemString PCHAR OemString
Definition: rtlfuncs.h:1560
_In_ SIZE_T String1Length
Definition: rtlfuncs.h:513
#define RtlUnicodeStringToAnsiSize(String)
Definition: rtlfuncs.h:1005
_In_ BOOLEAN _In_ ULONG _Out_ PULONG HashValue
Definition: rtlfuncs.h:2039
#define RtlOemStringToCountedUnicodeSize(STRING)
#define HASH_STRING_ALGORITHM_DEFAULT
const char * LPCSTR
Definition: xmlstorage.h:183
unsigned char UCHAR
Definition: xmlstorage.h:181
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
char CHAR
Definition: xmlstorage.h:175
unsigned char BYTE
Definition: xxhash.c:193