ReactOS 0.4.15-dev-7924-g5949c20
unicode.c File Reference
#include <rtl.h>
#include <debug.h>
#include <wine/unicode.h>
Include dependency graph for unicode.c:

Go to the source code of this file.

Macros

#define NDEBUG
 
#define ITU_IMPLEMENTED_TESTS   (IS_TEXT_UNICODE_ODD_LENGTH|IS_TEXT_UNICODE_SIGNATURE)
 

Functions

NTSTATUS NTAPI RtlMultiAppendUnicodeStringBuffer (OUT PRTL_UNICODE_STRING_BUFFER StringBuffer, IN ULONG NumberOfAddends, IN PCUNICODE_STRING Addends)
 
WCHAR NTAPI RtlAnsiCharToUnicodeChar (IN OUT PUCHAR *AnsiChar)
 
NTSTATUS NTAPI RtlAnsiStringToUnicodeString (IN OUT PUNICODE_STRING UniDest, IN PANSI_STRING AnsiSource, IN BOOLEAN AllocateDestinationString)
 
ULONG NTAPI RtlxAnsiStringToUnicodeSize (IN PCANSI_STRING AnsiString)
 
NTSTATUS NTAPI RtlAppendStringToString (IN PSTRING Destination, IN const STRING *Source)
 
NTSTATUS NTAPI RtlAppendUnicodeStringToString (IN OUT PUNICODE_STRING Destination, IN PCUNICODE_STRING Source)
 
NTSTATUS NTAPI RtlCharToInteger (PCSZ str, ULONG base, PULONG value)
 
LONG NTAPI RtlCompareString (IN const STRING *s1, IN const STRING *s2, IN BOOLEAN CaseInsensitive)
 
BOOLEAN NTAPI RtlEqualString (IN const STRING *s1, IN const STRING *s2, IN BOOLEAN CaseInsensitive)
 
BOOLEAN NTAPI RtlEqualUnicodeString (IN CONST UNICODE_STRING *s1, IN CONST UNICODE_STRING *s2, IN BOOLEAN CaseInsensitive)
 
VOID NTAPI RtlFreeAnsiString (IN PANSI_STRING AnsiString)
 
VOID NTAPI RtlFreeOemString (IN POEM_STRING OemString)
 
VOID NTAPI RtlFreeUnicodeString (IN PUNICODE_STRING UnicodeString)
 
BOOLEAN NTAPI RtlpDidUnicodeToOemWork (IN PCUNICODE_STRING UnicodeString, IN POEM_STRING OemString)
 
BOOLEAN NTAPI RtlIsValidOemCharacter (IN PWCHAR Char)
 
VOID NTAPI RtlInitAnsiString (IN OUT PANSI_STRING DestinationString, IN PCSZ SourceString)
 
NTSTATUS NTAPI RtlInitAnsiStringEx (IN OUT PANSI_STRING DestinationString, IN PCSZ SourceString)
 
VOID NTAPI RtlInitString (IN OUT PSTRING DestinationString, IN PCSZ SourceString)
 
VOID NTAPI RtlInitUnicodeString (IN OUT PUNICODE_STRING DestinationString, IN PCWSTR SourceString)
 
NTSTATUS NTAPI RtlInitUnicodeStringEx (OUT PUNICODE_STRING DestinationString, IN PCWSTR SourceString)
 
NTSTATUS NTAPI RtlIntegerToChar (ULONG value, ULONG base, ULONG length, PCHAR str)
 
NTSTATUS NTAPI RtlIntegerToUnicode (IN ULONG Value, IN ULONG Base OPTIONAL, IN ULONG Length OPTIONAL, IN OUT LPWSTR String)
 
NTSTATUS NTAPI RtlIntegerToUnicodeString (IN ULONG Value, IN ULONG Base OPTIONAL, IN OUT PUNICODE_STRING String)
 
NTSTATUS NTAPI RtlInt64ToUnicodeString (IN ULONGLONG Value, IN ULONG Base OPTIONAL, IN OUT PUNICODE_STRING String)
 
BOOLEAN NTAPI RtlPrefixString (const STRING *String1, const STRING *String2, BOOLEAN CaseInsensitive)
 
BOOLEAN NTAPI RtlPrefixUnicodeString (PCUNICODE_STRING String1, PCUNICODE_STRING String2, BOOLEAN CaseInsensitive)
 
NTSTATUS NTAPI RtlUnicodeStringToInteger (const UNICODE_STRING *str, ULONG base, ULONG *value)
 
ULONG NTAPI RtlxUnicodeStringToOemSize (IN PCUNICODE_STRING UnicodeString)
 
NTSTATUS NTAPI RtlUnicodeStringToAnsiString (IN OUT PANSI_STRING AnsiDest, IN PCUNICODE_STRING UniSource, IN BOOLEAN AllocateDestinationString)
 
NTSTATUS NTAPI RtlOemStringToUnicodeString (IN OUT PUNICODE_STRING UniDest, IN PCOEM_STRING OemSource, IN BOOLEAN AllocateDestinationString)
 
NTSTATUS NTAPI RtlUnicodeStringToOemString (IN OUT POEM_STRING OemDest, IN PCUNICODE_STRING UniSource, IN BOOLEAN AllocateDestinationString)
 
BOOLEAN NTAPI RtlIsTextUnicode (CONST VOID *buf, INT len, INT *pf)
 
NTSTATUS NTAPI RtlOemStringToCountedUnicodeString (IN OUT PUNICODE_STRING UniDest, IN PCOEM_STRING OemSource, IN BOOLEAN AllocateDestinationString)
 
BOOLEAN NTAPI RtlEqualComputerName (IN PUNICODE_STRING ComputerName1, IN PUNICODE_STRING ComputerName2)
 
BOOLEAN NTAPI RtlEqualDomainName (IN PUNICODE_STRING DomainName1, IN PUNICODE_STRING DomainName2)
 
NTSTATUS NTAPI RtlGUIDFromString (IN UNICODE_STRING *str, OUT GUID *guid)
 
VOID NTAPI RtlEraseUnicodeString (IN PUNICODE_STRING String)
 
NTSTATUS NTAPI RtlHashUnicodeString (IN CONST UNICODE_STRING *String, IN BOOLEAN CaseInSensitive, IN ULONG HashAlgorithm, OUT PULONG HashValue)
 
 _IRQL_requires_max_ (PASSIVE_LEVEL)
 Queries information details about a security descriptor.
 
NTSTATUS NTAPI RtlLargeIntegerToChar (IN PLARGE_INTEGER Value, IN ULONG Base, IN ULONG Length, IN OUT PCHAR String)
 
NTSTATUS NTAPI RtlUpcaseUnicodeString (IN OUT PUNICODE_STRING UniDest, IN PCUNICODE_STRING UniSource, IN BOOLEAN AllocateDestinationString)
 
NTSTATUS NTAPI RtlUpcaseUnicodeStringToAnsiString (IN OUT PANSI_STRING AnsiDest, IN PCUNICODE_STRING UniSource, IN BOOLEAN AllocateDestinationString)
 
NTSTATUS NTAPI RtlUpcaseUnicodeStringToCountedOemString (IN OUT POEM_STRING OemDest, IN PCUNICODE_STRING UniSource, IN BOOLEAN AllocateDestinationString)
 
NTSTATUS NTAPI RtlUpcaseUnicodeStringToOemString (IN OUT POEM_STRING OemDest, IN PCUNICODE_STRING UniSource, IN BOOLEAN AllocateDestinationString)
 
ULONG NTAPI RtlxOemStringToUnicodeSize (IN PCOEM_STRING OemString)
 
NTSTATUS NTAPI RtlStringFromGUID (IN REFGUID Guid, OUT PUNICODE_STRING GuidString)
 
ULONG NTAPI RtlxUnicodeStringToAnsiSize (IN PCUNICODE_STRING UnicodeString)
 
LONG NTAPI RtlCompareUnicodeString (IN PCUNICODE_STRING s1, IN PCUNICODE_STRING s2, IN BOOLEAN CaseInsensitive)
 
VOID NTAPI RtlCopyString (IN OUT PSTRING DestinationString, IN const STRING *SourceString OPTIONAL)
 
VOID NTAPI RtlCopyUnicodeString (IN OUT PUNICODE_STRING DestinationString, IN PCUNICODE_STRING SourceString)
 
BOOLEAN NTAPI RtlCreateUnicodeString (IN OUT PUNICODE_STRING UniDest, IN PCWSTR Source)
 
BOOLEAN NTAPI RtlCreateUnicodeStringFromAsciiz (OUT PUNICODE_STRING Destination, IN PCSZ Source)
 
NTSTATUS NTAPI RtlDowncaseUnicodeString (IN OUT PUNICODE_STRING UniDest, IN PCUNICODE_STRING UniSource, IN BOOLEAN AllocateDestinationString)
 
NTSTATUS NTAPI RtlAppendUnicodeToString (IN OUT PUNICODE_STRING Destination, IN PCWSTR Source)
 
NTSTATUS NTAPI RtlAppendAsciizToString (IN OUT PSTRING Destination, IN PCSZ Source)
 
VOID NTAPI RtlUpperString (PSTRING DestinationString, const STRING *SourceString)
 
NTSTATUS NTAPI RtlDuplicateUnicodeString (IN ULONG Flags, IN PCUNICODE_STRING SourceString, OUT PUNICODE_STRING DestinationString)
 
NTSTATUS NTAPI RtlValidateUnicodeString (_In_ ULONG Flags, _In_ PCUNICODE_STRING String)
 
NTSTATUS NTAPI RtlpEnsureBufferSize (IN ULONG Flags, IN OUT PRTL_BUFFER Buffer, IN SIZE_T RequiredSize)
 
static BOOLEAN RtlpIsCharInUnicodeString (IN WCHAR Char, IN PCUNICODE_STRING MatchString, IN BOOLEAN CaseInSensitive)
 
NTSTATUS NTAPI RtlFindCharInUnicodeString (IN ULONG Flags, IN PCUNICODE_STRING SearchString, IN PCUNICODE_STRING MatchString, OUT PUSHORT Position)
 
NTSTATUS NTAPI RtlDnsHostNameToComputerName (PUNICODE_STRING ComputerName, PUNICODE_STRING DnsHostName, BOOLEAN AllocateComputerNameString)
 

Variables

BOOLEAN NlsMbCodePageTag
 
BOOLEAN NlsMbOemCodePageTag
 
PUSHORT NlsLeadByteInfo
 
USHORT NlsOemDefaultChar
 
USHORT NlsUnicodeDefaultChar
 
PUSHORT NlsOemLeadByteInfo
 
PWCHAR NlsOemToUnicodeTable
 
PCHAR NlsUnicodeToOemTable
 
PUSHORT NlsUnicodeToMbOemTable
 

Macro Definition Documentation

◆ ITU_IMPLEMENTED_TESTS

Definition at line 1280 of file unicode.c.

◆ NDEBUG

#define NDEBUG

Definition at line 15 of file unicode.c.

Function Documentation

◆ _IRQL_requires_max_()

_IRQL_requires_max_ ( PASSIVE_LEVEL  )

Queries information details about a security descriptor.

Computes the quota size of a security descriptor.

Assigns a security descriptor for a new object.

An extended function that assigns a security descriptor for a new object.

Frees a security descriptor.

An extended function that sets new information data to a security descriptor.

Modifies some information data about a security descriptor.

Parameters
[in]SecurityInformationSecurity information details to be queried from a security descriptor.
[out]SecurityDescriptorThe returned security descriptor with security information data.
[in,out]LengthThe returned length of a security descriptor.
[in,out]ObjectsSecurityDescriptorThe returned object security descriptor.
Returns
Returns STATUS_SUCCESS if the operations have been completed successfully and that the specific information about the security descriptor has been queried. STATUS_BUFFER_TOO_SMALL is returned if the buffer size is too small to contain the queried info about the security descriptor.
Parameters
[in]ObjectIf specified, the function will use this arbitrary object that points to an object security descriptor.
[in]SecurityInformationSecurity information details to be set.
[in]SecurityDescriptorA security descriptor where its info is to be changed.
[in,out]ObjectsSecurityDescriptorThe returned pointer to security descriptor objects.
[in]PoolTypePool type for the new security descriptor to allocate.
[in]GenericMappingThe generic mapping of access rights masks.
Returns
See SeSetSecurityDescriptorInfoEx.
Parameters
[in]ObjectIf specified, the function will use this arbitrary object that points to an object security descriptor.
[in]SecurityInformationSecurity information details to be set.
[in]SecurityDescriptorA security descriptor where its info is to be changed.
[in,out]ObjectsSecurityDescriptorThe returned pointer to security descriptor objects.
[in]AutoInheritFlagsFlags bitmask inheritation, influencing how the security descriptor can be inherited and if it can be in the first place.
[in]PoolTypePool type for the new security descriptor to allocate.
[in]GenericMappingThe generic mapping of access rights masks.
Returns
Returns STATUS_SUCCESS if the operations have been completed without problems and that new info has been set to the security descriptor. STATUS_NO_SECURITY_ON_OBJECT is returned if the object does not have a security descriptor. STATUS_INSUFFICIENT_RESOURCES is returned if memory pool allocation for the new security descriptor with new info set has failed.
Parameters
[in]SecurityDescriptorA security descriptor to be freed from memory.
Returns
Returns STATUS_SUCCESS.
Parameters
[in]_ParentDescriptorA security descriptor of the parent object that is being created.
[in]_ExplicitDescriptorAn explicit security descriptor that is applied to a new object.
[out]NewDescriptorThe new allocated security descriptor.
[in]ObjectTypeThe type of the new object.
[in]IsDirectoryObjectSet this to TRUE if the newly created object is a directory object, otherwise set this to FALSE.
[in]AutoInheritFlagsAutomatic inheritance flags that influence how access control entries within ACLs from security descriptors are inherited.
[in]SubjectContextSecurity subject context of the new object.
[in]GenericMappingGeneric mapping of access mask rights.
[in]PoolTypeThis parameter is unused.
Returns
Returns STATUS_SUCCESS if the operations have been completed successfully and that the security descriptor has been assigned to the new object. STATUS_NO_TOKEN is returned if the caller hasn't supplied a valid argument to a security subject context. STATUS_INVALID_OWNER is returned if the caller hasn't supplied a parent descriptor that belongs to the main user (owner). STATUS_INVALID_PRIMARY_GROUP is returned by the same reason as with the previous NTSTATUS code. The two NTSTATUS codes are returned if the calling thread stated that the owner and/or group is defaulted to the parent descriptor (SEF_DEFAULT_OWNER_FROM_PARENT and/or SEF_DEFAULT_GROUP_FROM_PARENT respectively). STATUS_INSUFFICIENT_RESOURCES is returned if memory pool allocation for the descriptor buffer has failed. A failure NTSTATUS is returned otherwise.
Parameters
[in]ParentDescriptorA security descriptor of the parent object that is being created.
[in]ExplicitDescriptorAn explicit security descriptor that is applied to a new object.
[out]NewDescriptorThe new allocated security descriptor.
[in]IsDirectoryObjectSet this to TRUE if the newly created object is a directory object, otherwise set this to FALSE.
[in]SubjectContextSecurity subject context of the new object.
[in]GenericMappingGeneric mapping of access mask rights.
[in]PoolTypeThis parameter is unused.
Returns
See SeAssignSecurityEx.
Parameters
[in]SecurityDescriptorA security descriptor.
[out]QuotaInfoSizeThe returned quota size of the given security descriptor to the caller. The function may return 0 to this parameter if the descriptor doesn't have a group or a discretionary access control list (DACL) even.
Returns
Returns STATUS_SUCCESS if the quota size of a security descriptor has been computed successfully. STATUS_UNKNOWN_REVISION is returned if the security descriptor has an invalid revision.

Definition at line 1787 of file unicode.c.

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}
LONG NTSTATUS
Definition: precomp.h:26
#define NULL
Definition: types.h:112
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
Status
Definition: gdiplustypes.h:25
_In_ PSID _In_ BOOLEAN AllocateDestinationString
Definition: rtlfuncs.h:1349
_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
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
#define STATUS_INVALID_PARAMETER_2
Definition: ntstatus.h:476
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
#define STATUS_UNMAPPABLE_CHARACTER
Definition: ntstatus.h:590
unsigned short USHORT
Definition: pedump.c:61
#define RtlpFreeStringMemory
Definition: rtlp.h:156
#define RtlpAllocateStringMemory
Definition: rtlp.h:155
#define PAGED_CODE_RTL()
Definition: rtlp.h:16
BOOLEAN NTAPI RtlpDidUnicodeToOemWork(IN PCUNICODE_STRING UnicodeString, IN POEM_STRING OemString)
Definition: unicode.c:472
#define STATUS_SUCCESS
Definition: shellext.h:65
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66
#define TAG_OSTR
Definition: tag.h:147
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define MAXUSHORT
Definition: typedefs.h:83
uint32_t ULONG
Definition: typedefs.h:59
STRING OEM_STRING
Definition: umtypes.h:203
_In_ WDFCOLLECTION _In_ ULONG Index

◆ RtlAnsiCharToUnicodeChar()

WCHAR NTAPI RtlAnsiCharToUnicodeChar ( IN OUT PUCHAR AnsiChar)

Definition at line 50 of file unicode.c.

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}
_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
#define L(x)
Definition: ntvdm.h:50
PUSHORT NlsLeadByteInfo
Definition: nls.c:26
#define DPRINT
Definition: sndvol32.h:71
char * PCHAR
Definition: typedefs.h:51
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
__wchar_t WCHAR
Definition: xmlstorage.h:180

◆ RtlAnsiStringToUnicodeString()

NTSTATUS NTAPI RtlAnsiStringToUnicodeString ( IN OUT PUNICODE_STRING  UniDest,
IN PANSI_STRING  AnsiSource,
IN BOOLEAN  AllocateDestinationString 
)

Definition at line 91 of file unicode.c.

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}
#define FALSE
Definition: types.h:117
#define ASSERT(a)
Definition: mode.c:44
#define UNICODE_NULL
ULONG NTAPI RtlxAnsiStringToUnicodeSize(IN PCANSI_STRING AnsiString)
Definition: unicode.c:156
BOOLEAN NlsMbCodePageTag
Definition: nlsboot.c:17
#define TAG_USTR
Definition: tag.h:145

Referenced by RtlCreateUnicodeStringFromAsciiz(), RtlInt64ToUnicodeString(), and RtlIntegerToUnicodeString().

◆ RtlAppendAsciizToString()

NTSTATUS NTAPI RtlAppendAsciizToString ( IN OUT PSTRING  Destination,
IN PCSZ  Source 
)

Definition at line 2498 of file unicode.c.

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}
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
_In_ UINT _In_ UINT _In_ PNDIS_PACKET Source
Definition: ndis.h:3169
_In_ PUNICODE_STRING _Inout_ PUNICODE_STRING Destination
Definition: rtlfuncs.h:3004
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
USHORT MaximumLength
Definition: env_spec_w32.h:370
ULONG_PTR SIZE_T
Definition: typedefs.h:80
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:264

◆ RtlAppendStringToString()

NTSTATUS NTAPI RtlAppendStringToString ( IN PSTRING  Destination,
IN const STRING Source 
)

Definition at line 179 of file unicode.c.

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}

◆ RtlAppendUnicodeStringToString()

NTSTATUS NTAPI RtlAppendUnicodeStringToString ( IN OUT PUNICODE_STRING  Destination,
IN PCUNICODE_STRING  Source 
)

Definition at line 211 of file unicode.c.

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}
Definition: bufpool.h:45
uint16_t * PWCHAR
Definition: typedefs.h:56

◆ RtlAppendUnicodeToString()

NTSTATUS NTAPI RtlAppendUnicodeToString ( IN OUT PUNICODE_STRING  Destination,
IN PCWSTR  Source 
)

Definition at line 2457 of file unicode.c.

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}
VOID NTAPI RtlInitUnicodeString(IN OUT PUNICODE_STRING DestinationString, IN PCWSTR SourceString)
Definition: unicode.c:641

◆ RtlCharToInteger()

NTSTATUS NTAPI RtlCharToInteger ( PCSZ  str,
ULONG  base,
PULONG  value 
)

Definition at line 261 of file unicode.c.

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}
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
const WCHAR * str
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
Definition: pdh_main.c:94
char CHAR
Definition: xmlstorage.h:175

Referenced by CsrParseServerCommandLine(), CsrSrvCreateSharedSection(), get_res_nameA(), and LdrpSnapThunk().

◆ RtlCompareString()

LONG NTAPI RtlCompareString ( IN const STRING s1,
IN const STRING s2,
IN BOOLEAN  CaseInsensitive 
)

Definition at line 352 of file unicode.c.

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}
GLenum GLsizei len
Definition: glext.h:6722
struct S1 s1
struct S2 s2
#define min(a, b)
Definition: monoChain.cc:55
_In_ const STRING _In_ BOOLEAN CaseInsensitive
Definition: rtlfuncs.h:2359
CHAR NTAPI RtlUpperChar(_In_ CHAR Source)
Definition: nlsboot.c:229
long LONG
Definition: pedump.c:60
int ret
const char * LPCSTR
Definition: xmlstorage.h:183

Referenced by RtlEqualString().

◆ RtlCompareUnicodeString()

LONG NTAPI RtlCompareUnicodeString ( IN PCUNICODE_STRING  s1,
IN PCUNICODE_STRING  s2,
IN BOOLEAN  CaseInsensitive 
)

Definition at line 2198 of file unicode.c.

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}
WCHAR NTAPI RtlpUpcaseUnicodeChar(_In_ WCHAR Source)
Definition: nlsboot.c:160
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185

Referenced by RtlEqualUnicodeString().

◆ RtlCopyString()

VOID NTAPI RtlCopyString ( IN OUT PSTRING  DestinationString,
IN const STRING *SourceString  OPTIONAL 
)

Definition at line 2277 of file unicode.c.

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}
_Out_ _Inout_ POEM_STRING _In_ PCUNICODE_STRING SourceString
Definition: rtlfuncs.h:1910
_Out_ _Inout_ POEM_STRING DestinationString
Definition: rtlfuncs.h:1909
unsigned short Length
Definition: sprintf.c:451
void * Buffer
Definition: sprintf.c:453
unsigned short MaximumLength
Definition: sprintf.c:452

◆ RtlCopyUnicodeString()

VOID NTAPI RtlCopyUnicodeString ( IN OUT PUNICODE_STRING  DestinationString,
IN PCUNICODE_STRING  SourceString 
)

Definition at line 2318 of file unicode.c.

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}
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263

◆ RtlCreateUnicodeString()

BOOLEAN NTAPI RtlCreateUnicodeString ( IN OUT PUNICODE_STRING  UniDest,
IN PCWSTR  Source 
)

Definition at line 2353 of file unicode.c.

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}
#define TRUE
Definition: types.h:120
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)

◆ RtlCreateUnicodeStringFromAsciiz()

BOOLEAN NTAPI RtlCreateUnicodeStringFromAsciiz ( OUT PUNICODE_STRING  Destination,
IN PCSZ  Source 
)

Definition at line 2379 of file unicode.c.

2382{
2385
2387
2389 &AnsiString,
2390 TRUE);
2391
2392 return NT_SUCCESS(Status);
2393}
@ AnsiString
Definition: dnslib.h:19
VOID NTAPI RtlInitAnsiString(IN OUT PANSI_STRING DestinationString, IN PCSZ SourceString)
Definition: unicode.c:573
NTSTATUS NTAPI RtlAnsiStringToUnicodeString(IN OUT PUNICODE_STRING UniDest, IN PANSI_STRING AnsiSource, IN BOOLEAN AllocateDestinationString)
Definition: unicode.c:91

◆ RtlDnsHostNameToComputerName()

NTSTATUS NTAPI RtlDnsHostNameToComputerName ( PUNICODE_STRING  ComputerName,
PUNICODE_STRING  DnsHostName,
BOOLEAN  AllocateComputerNameString 
)

Definition at line 2791 of file unicode.c.

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}
_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
#define STATUS_INVALID_COMPUTER_NAME
Definition: ntstatus.h:526
NTSTATUS NTAPI RtlOemStringToUnicodeString(IN OUT PUNICODE_STRING UniDest, IN PCOEM_STRING OemSource, IN BOOLEAN AllocateDestinationString)
Definition: unicode.c:1180
#define MAX_COMPUTERNAME_LENGTH
Definition: winbase.h:243

◆ RtlDowncaseUnicodeString()

NTSTATUS NTAPI RtlDowncaseUnicodeString ( IN OUT PUNICODE_STRING  UniDest,
IN PCUNICODE_STRING  UniSource,
IN BOOLEAN  AllocateDestinationString 
)

Definition at line 2405 of file unicode.c.

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}
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
WCHAR NTAPI RtlpDowncaseUnicodeChar(_In_ WCHAR Source)
Definition: nlsboot.c:32

◆ RtlDuplicateUnicodeString()

NTSTATUS NTAPI RtlDuplicateUnicodeString ( IN ULONG  Flags,
IN PCUNICODE_STRING  SourceString,
OUT PUNICODE_STRING  DestinationString 
)

Definition at line 2553 of file unicode.c.

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}
#define RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING
Definition: green.h:16
#define RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE
Definition: green.h:15
unsigned int UINT
Definition: ndis.h:50
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170

◆ RtlEqualComputerName()

BOOLEAN NTAPI RtlEqualComputerName ( IN PUNICODE_STRING  ComputerName1,
IN PUNICODE_STRING  ComputerName2 
)

Definition at line 1542 of file unicode.c.

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}
unsigned char BOOLEAN
VOID NTAPI RtlFreeOemString(IN POEM_STRING OemString)
Definition: unicode.c:435
BOOLEAN NTAPI RtlEqualString(IN const STRING *s1, IN const STRING *s2, IN BOOLEAN CaseInsensitive)
Definition: unicode.c:388
NTSTATUS NTAPI RtlUpcaseUnicodeStringToOemString(IN OUT POEM_STRING OemDest, IN PCUNICODE_STRING UniSource, IN BOOLEAN AllocateDestinationString)
Definition: unicode.c:2069
_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

Referenced by RtlEqualDomainName().

◆ RtlEqualDomainName()

BOOLEAN NTAPI RtlEqualDomainName ( IN PUNICODE_STRING  DomainName1,
IN PUNICODE_STRING  DomainName2 
)

Definition at line 1579 of file unicode.c.

1582{
1583 return RtlEqualComputerName(DomainName1, DomainName2);
1584}
BOOLEAN NTAPI RtlEqualComputerName(IN PUNICODE_STRING ComputerName1, IN PUNICODE_STRING ComputerName2)
Definition: unicode.c:1542

◆ RtlEqualString()

BOOLEAN NTAPI RtlEqualString ( IN const STRING s1,
IN const STRING s2,
IN BOOLEAN  CaseInsensitive 
)

Definition at line 388 of file unicode.c.

392{
393 if (s1->Length != s2->Length) return FALSE;
395}
LONG NTAPI RtlCompareString(IN const STRING *s1, IN const STRING *s2, IN BOOLEAN CaseInsensitive)
Definition: unicode.c:352

Referenced by RtlEqualComputerName().

◆ RtlEqualUnicodeString()

BOOLEAN NTAPI RtlEqualUnicodeString ( IN CONST UNICODE_STRING s1,
IN CONST UNICODE_STRING s2,
IN BOOLEAN  CaseInsensitive 
)

Definition at line 405 of file unicode.c.

409{
410 if (s1->Length != s2->Length) return FALSE;
412}
LONG NTAPI RtlCompareUnicodeString(IN PCUNICODE_STRING s1, IN PCUNICODE_STRING s2, IN BOOLEAN CaseInsensitive)
Definition: unicode.c:2198

◆ RtlEraseUnicodeString()

VOID NTAPI RtlEraseUnicodeString ( IN PUNICODE_STRING  String)

Definition at line 1722 of file unicode.c.

1724{
1725 if (String->Buffer && String->MaximumLength)
1726 {
1727 RtlZeroMemory(String->Buffer, String->MaximumLength);
1728 String->Length = 0;
1729 }
1730}
_Must_inspect_result_ _In_ WDFDEVICE _In_ WDFSTRING String
Definition: wdfdevice.h:2433

◆ RtlFindCharInUnicodeString()

NTSTATUS NTAPI RtlFindCharInUnicodeString ( IN ULONG  Flags,
IN PCUNICODE_STRING  SearchString,
IN PCUNICODE_STRING  MatchString,
OUT PUSHORT  Position 
)

Definition at line 2726 of file unicode.c.

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}
static BOOL MatchString(LPCWCH pch1, INT cch1, LPCWCH pch2, INT cch2)
Definition: find.c:91
return Found
Definition: dirsup.c:1270
_In_ const STRING _In_ BOOLEAN CaseInSensitive
Definition: rtlfuncs.h:2390
#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
short SHORT
Definition: pedump.c:59
static BOOLEAN RtlpIsCharInUnicodeString(IN WCHAR Char, IN PCUNICODE_STRING MatchString, IN BOOLEAN CaseInSensitive)
Definition: unicode.c:2698
#define STATUS_NOT_FOUND
Definition: shellext.h:72
static COORD Position
Definition: mouse.c:34

◆ RtlFreeAnsiString()

VOID NTAPI RtlFreeAnsiString ( IN PANSI_STRING  AnsiString)

Definition at line 419 of file unicode.c.

420{
422
423 if (AnsiString->Buffer)
424 {
427 }
428}
#define TAG_ASTR
Definition: tag.h:146

◆ RtlFreeOemString()

VOID NTAPI RtlFreeOemString ( IN POEM_STRING  OemString)

Definition at line 435 of file unicode.c.

436{
438
439 if (OemString->Buffer) RtlpFreeStringMemory(OemString->Buffer, TAG_OSTR);
440}
*BytesInOemString PCHAR OemString
Definition: rtlfuncs.h:1560

Referenced by RtlEqualComputerName().

◆ RtlFreeUnicodeString()

VOID NTAPI RtlFreeUnicodeString ( IN PUNICODE_STRING  UnicodeString)

Definition at line 447 of file unicode.c.

448{
450
451 if (UnicodeString->Buffer)
452 {
455 }
456}

◆ RtlGUIDFromString()

NTSTATUS NTAPI RtlGUIDFromString ( IN UNICODE_STRING str,
OUT GUID guid 
)

Definition at line 1606 of file unicode.c.

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}
#define byte(x, n)
Definition: tomcrypt.h:118
const GUID * guid
unsigned char BYTE
Definition: xxhash.c:193

◆ RtlHashUnicodeString()

NTSTATUS NTAPI RtlHashUnicodeString ( IN CONST UNICODE_STRING String,
IN BOOLEAN  CaseInSensitive,
IN ULONG  HashAlgorithm,
OUT PULONG  HashValue 
)

Definition at line 1737 of file unicode.c.

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}
GLuint GLuint end
Definition: gl.h:1545
const GLubyte * c
Definition: glext.h:8905
#define c
Definition: ke_i.h:80
#define HASH_STRING_ALGORITHM_X65599
Definition: rtlstr.c:33
_In_ BOOLEAN _In_ ULONG HashAlgorithm
Definition: rtlfuncs.h:2038
_In_ BOOLEAN _In_ ULONG _Out_ PULONG HashValue
Definition: rtlfuncs.h:2039
#define HASH_STRING_ALGORITHM_DEFAULT

◆ RtlInitAnsiString()

VOID NTAPI RtlInitAnsiString ( IN OUT PANSI_STRING  DestinationString,
IN PCSZ  SourceString 
)

Definition at line 573 of file unicode.c.

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}
#define CHAR(Char)
#define PCHAR
Definition: match.c:90

Referenced by RtlCreateUnicodeStringFromAsciiz(), and RtlInitString().

◆ RtlInitAnsiStringEx()

NTSTATUS NTAPI RtlInitAnsiStringEx ( IN OUT PANSI_STRING  DestinationString,
IN PCSZ  SourceString 
)

Definition at line 596 of file unicode.c.

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}
#define STATUS_NAME_TOO_LONG
Definition: ntstatus.h:498

◆ RtlInitString()

VOID NTAPI RtlInitString ( IN OUT PSTRING  DestinationString,
IN PCSZ  SourceString 
)

Definition at line 626 of file unicode.c.

◆ RtlInitUnicodeString()

VOID NTAPI RtlInitUnicodeString ( IN OUT PUNICODE_STRING  DestinationString,
IN PCWSTR  SourceString 
)

Definition at line 641 of file unicode.c.

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}
#define __analysis_assume(expr)
Definition: ms_sal.h:2893
#define CONST
Definition: pedump.c:81

Referenced by RtlAppendUnicodeToString().

◆ RtlInitUnicodeStringEx()

NTSTATUS NTAPI RtlInitUnicodeStringEx ( OUT PUNICODE_STRING  DestinationString,
IN PCWSTR  SourceString 
)

Definition at line 672 of file unicode.c.

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}

◆ RtlInt64ToUnicodeString()

NTSTATUS NTAPI RtlInt64ToUnicodeString ( IN ULONGLONG  Value,
IN ULONG Base  OPTIONAL,
IN OUT PUNICODE_STRING  String 
)

Definition at line 853 of file unicode.c.

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}
_In_opt_ ULONG Base
Definition: rtlfuncs.h:2439
NTSTATUS NTAPI RtlLargeIntegerToChar(IN PLARGE_INTEGER Value, IN ULONG Base, IN ULONG Length, IN OUT PCHAR String)
Definition: unicode.c:1860
LONGLONG QuadPart
Definition: typedefs.h:114
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _Out_opt_ PUSHORT _Inout_opt_ PUNICODE_STRING Value
Definition: wdfregistry.h:413

◆ RtlIntegerToChar()

NTSTATUS NTAPI RtlIntegerToChar ( ULONG  value,
ULONG  base,
ULONG  length,
PCHAR  str 
)

Definition at line 704 of file unicode.c.

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}
GLuint buffer
Definition: glext.h:5915
GLuint GLsizei GLsizei * length
Definition: glext.h:6040

Referenced by RtlIntegerToUnicodeString().

◆ RtlIntegerToUnicode()

NTSTATUS NTAPI RtlIntegerToUnicode ( IN ULONG  Value,
IN ULONG Base  OPTIONAL,
IN ULONG Length  OPTIONAL,
IN OUT LPWSTR  String 
)

Definition at line 771 of file unicode.c.

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}
_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
const GLdouble * v
Definition: gl.h:2040
static const WCHAR sp[]
Definition: suminfo.c:287
static calc_node_t temp
Definition: rpn_ieee.c:38
uint32_t ULONG_PTR
Definition: typedefs.h:65

◆ RtlIntegerToUnicodeString()

NTSTATUS NTAPI RtlIntegerToUnicodeString ( IN ULONG  Value,
IN ULONG Base  OPTIONAL,
IN OUT PUNICODE_STRING  String 
)

Definition at line 826 of file unicode.c.

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}
NTSTATUS NTAPI RtlIntegerToChar(ULONG value, ULONG base, ULONG length, PCHAR str)
Definition: unicode.c:704

◆ RtlIsTextUnicode()

BOOLEAN NTAPI RtlIsTextUnicode ( CONST VOID buf,
INT  len,
INT pf 
)

Definition at line 1290 of file unicode.c.

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}
GLdouble s
Definition: gl.h:2039
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLbitfield flags
Definition: glext.h:7161
#define LOBYTE(W)
Definition: jmemdos.c:487
#define HIBYTE(W)
Definition: jmemdos.c:486
#define strchrW(s, c)
Definition: unicode.h:34
weight
Definition: sortkey.c:157
#define max(a, b)
Definition: svc.c:63
#define MAXULONG
Definition: typedefs.h:251
#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
unsigned char UCHAR
Definition: xmlstorage.h:181

◆ RtlIsValidOemCharacter()

BOOLEAN NTAPI RtlIsValidOemCharacter ( IN PWCHAR  Char)

Definition at line 514 of file unicode.c.

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}
#define DPRINT1
Definition: precomp.h:8
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
USHORT NlsOemDefaultChar
Definition: nlsboot.c:25
PWCHAR NlsOemToUnicodeTable
Definition: nlsboot.c:20
PUSHORT NlsUnicodeToMbOemTable
Definition: nlsboot.c:22
PUSHORT NlsOemLeadByteInfo
Definition: nlsboot.c:23
BOOLEAN NlsMbOemCodePageTag
Definition: nlsboot.c:19
PCHAR NlsUnicodeToOemTable
Definition: nlsboot.c:21

Referenced by RtlGenerate8dot3Name(), and START_TEST().

◆ RtlLargeIntegerToChar()

NTSTATUS NTAPI RtlLargeIntegerToChar ( IN PLARGE_INTEGER  Value,
IN ULONG  Base,
IN ULONG  Length,
IN OUT PCHAR  String 
)

Definition at line 1860 of file unicode.c.

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}
#define Len
Definition: deflate.h:82
ush Pos
Definition: deflate.h:92
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
uint64_t ULONGLONG
Definition: typedefs.h:67

Referenced by RtlInt64ToUnicodeString().

◆ RtlMultiAppendUnicodeStringBuffer()

NTSTATUS NTAPI RtlMultiAppendUnicodeStringBuffer ( OUT PRTL_UNICODE_STRING_BUFFER  StringBuffer,
IN ULONG  NumberOfAddends,
IN PCUNICODE_STRING  Addends 
)

Definition at line 37 of file unicode.c.

40{
43}
#define UNIMPLEMENTED
Definition: debug.h:115
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:239

◆ RtlOemStringToCountedUnicodeString()

NTSTATUS NTAPI RtlOemStringToCountedUnicodeString ( IN OUT PUNICODE_STRING  UniDest,
IN PCOEM_STRING  OemSource,
IN BOOLEAN  AllocateDestinationString 
)

Definition at line 1473 of file unicode.c.

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}
_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
#define RtlOemStringToCountedUnicodeSize(STRING)

Referenced by _Requires_lock_held_(), FatQueryShortNameInfo(), FatSearchBufferForLabel(), FatSetFsLabelInfo(), and FatTunnelFcbOrDcb().

◆ RtlOemStringToUnicodeString()

NTSTATUS NTAPI RtlOemStringToUnicodeString ( IN OUT PUNICODE_STRING  UniDest,
IN PCOEM_STRING  OemSource,
IN BOOLEAN  AllocateDestinationString 
)

Definition at line 1180 of file unicode.c.

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}
#define RtlOemStringToUnicodeSize(STRING)

Referenced by RtlDnsHostNameToComputerName().

◆ RtlpDidUnicodeToOemWork()

BOOLEAN NTAPI RtlpDidUnicodeToOemWork ( IN PCUNICODE_STRING  UnicodeString,
IN POEM_STRING  OemString 
)

Definition at line 472 of file unicode.c.

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}
USHORT NlsUnicodeDefaultChar
Definition: nlsboot.c:26

Referenced by _IRQL_requires_max_(), RtlDnsHostNameToComputerName(), RtlUpcaseUnicodeStringToCountedOemString(), and RtlUpcaseUnicodeStringToOemString().

◆ RtlpEnsureBufferSize()

NTSTATUS NTAPI RtlpEnsureBufferSize ( IN ULONG  Flags,
IN OUT PRTL_BUFFER  Buffer,
IN SIZE_T  RequiredSize 
)

Definition at line 2636 of file unicode.c.

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}
#define RTL_SKIP_BUFFER_COPY
Definition: rtlfuncs.h:2451
unsigned char * PUCHAR
Definition: typedefs.h:53
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ ULONG _Out_ PVOID _Out_ PULONG RequiredSize
Definition: wdfdevice.h:4439

◆ RtlpIsCharInUnicodeString()

static BOOLEAN RtlpIsCharInUnicodeString ( IN WCHAR  Char,
IN PCUNICODE_STRING  MatchString,
IN BOOLEAN  CaseInSensitive 
)
static

Definition at line 2698 of file unicode.c.

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}

Referenced by RtlFindCharInUnicodeString().

◆ RtlPrefixString()

BOOLEAN NTAPI RtlPrefixString ( const STRING String1,
const STRING String2,
BOOLEAN  CaseInsensitive 
)

Definition at line 886 of file unicode.c.

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}
static const unsigned char pc1[56]
Definition: des.c:54
static const unsigned char pc2[48]
Definition: des.c:68
_In_ const STRING * String2
Definition: rtlfuncs.h:2357

◆ RtlPrefixUnicodeString()

BOOLEAN NTAPI RtlPrefixUnicodeString ( PCUNICODE_STRING  String1,
PCUNICODE_STRING  String2,
BOOLEAN  CaseInsensitive 
)

Definition at line 935 of file unicode.c.

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}

◆ RtlStringFromGUID()

NTSTATUS NTAPI RtlStringFromGUID ( IN REFGUID  Guid,
OUT PUNICODE_STRING  GuidString 
)

Definition at line 2142 of file unicode.c.

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}
#define swprintf
Definition: precomp.h:40
static PWSTR GuidString
Definition: apphelp.c:93
_Must_inspect_result_ _In_ WDFOBJECT _In_ CONST GUID * Guid
Definition: wdfobject.h:762

◆ RtlUnicodeStringToAnsiString()

NTSTATUS NTAPI RtlUnicodeStringToAnsiString ( IN OUT PANSI_STRING  AnsiDest,
IN PCUNICODE_STRING  UniSource,
IN BOOLEAN  AllocateDestinationString 
)

Definition at line 1113 of file unicode.c.

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}
_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
#define ANSI_NULL
ULONG NTAPI RtlxUnicodeStringToAnsiSize(IN PCUNICODE_STRING UnicodeString)
Definition: unicode.c:2177

◆ RtlUnicodeStringToInteger()

NTSTATUS NTAPI RtlUnicodeStringToInteger ( const UNICODE_STRING str,
ULONG  base,
ULONG value 
)

Definition at line 982 of file unicode.c.

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}
WCHAR * LPWSTR
Definition: xmlstorage.h:184

◆ RtlUnicodeStringToOemString()

NTSTATUS NTAPI RtlUnicodeStringToOemString ( IN OUT POEM_STRING  OemDest,
IN PCUNICODE_STRING  UniSource,
IN BOOLEAN  AllocateDestinationString 
)

Definition at line 1234 of file unicode.c.

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}
#define RtlUnicodeStringToOemSize(STRING)

◆ RtlUpcaseUnicodeString()

NTSTATUS NTAPI RtlUpcaseUnicodeString ( IN OUT PUNICODE_STRING  UniDest,
IN PCUNICODE_STRING  UniSource,
IN BOOLEAN  AllocateDestinationString 
)

Definition at line 1917 of file unicode.c.

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}
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

◆ RtlUpcaseUnicodeStringToAnsiString()

NTSTATUS NTAPI RtlUpcaseUnicodeStringToAnsiString ( IN OUT PANSI_STRING  AnsiDest,
IN PCUNICODE_STRING  UniSource,
IN BOOLEAN  AllocateDestinationString 
)

Definition at line 1957 of file unicode.c.

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}
_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
#define RtlUnicodeStringToAnsiSize(String)
Definition: rtlfuncs.h:1005

◆ RtlUpcaseUnicodeStringToCountedOemString()

NTSTATUS NTAPI RtlUpcaseUnicodeStringToCountedOemString ( IN OUT POEM_STRING  OemDest,
IN PCUNICODE_STRING  UniSource,
IN BOOLEAN  AllocateDestinationString 
)

Definition at line 2009 of file unicode.c.

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}

◆ RtlUpcaseUnicodeStringToOemString()

NTSTATUS NTAPI RtlUpcaseUnicodeStringToOemString ( IN OUT POEM_STRING  OemDest,
IN PCUNICODE_STRING  UniSource,
IN BOOLEAN  AllocateDestinationString 
)

Definition at line 2069 of file unicode.c.

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}

Referenced by RtlEqualComputerName().

◆ RtlUpperString()

VOID NTAPI RtlUpperString ( PSTRING  DestinationString,
const STRING SourceString 
)

Definition at line 2525 of file unicode.c.

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}

◆ RtlValidateUnicodeString()

NTSTATUS NTAPI RtlValidateUnicodeString ( _In_ ULONG  Flags,
_In_ PCUNICODE_STRING  String 
)

Definition at line 2605 of file unicode.c.

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}

Referenced by LsaApLogonUserEx2(), LsapSetLogonSessionData(), MsvpChangePassword(), NtlmFixupAndValidateUStr(), SeReportSecurityEvent(), and START_TEST().

◆ RtlxAnsiStringToUnicodeSize()

ULONG NTAPI RtlxAnsiStringToUnicodeSize ( IN PCANSI_STRING  AnsiString)

Definition at line 156 of file unicode.c.

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}
_Use_decl_annotations_ NTSTATUS NTAPI RtlMultiByteToUnicodeSize(_Out_ PULONG UnicodeSize, _In_ PCCH MbString, _In_ ULONG MbSize)
Definition: nlsboot.c:93

Referenced by RtlAnsiStringToUnicodeString().

◆ RtlxOemStringToUnicodeSize()

ULONG NTAPI RtlxOemStringToUnicodeSize ( IN PCOEM_STRING  OemString)

Definition at line 2124 of file unicode.c.

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}

◆ RtlxUnicodeStringToAnsiSize()

ULONG NTAPI RtlxUnicodeStringToAnsiSize ( IN PCUNICODE_STRING  UnicodeString)

Definition at line 2177 of file unicode.c.

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}
_Use_decl_annotations_ NTSTATUS NTAPI RtlUnicodeToMultiByteSize(_Out_ PULONG MbSize, _In_ PCWCH UnicodeString, _In_ ULONG UnicodeSize)
Definition: nlsboot.c:145

Referenced by RtlUnicodeStringToAnsiString(), and START_TEST().

◆ RtlxUnicodeStringToOemSize()

ULONG NTAPI RtlxUnicodeStringToOemSize ( IN PCUNICODE_STRING  UnicodeString)

Definition at line 1091 of file unicode.c.

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}

Referenced by Ext2UnicodeToOEMSize(), and START_TEST().

Variable Documentation

◆ NlsLeadByteInfo

◆ NlsMbCodePageTag

◆ NlsMbOemCodePageTag

◆ NlsOemDefaultChar

◆ NlsOemLeadByteInfo

PUSHORT NlsOemLeadByteInfo
extern

Definition at line 23 of file nlsboot.c.

Referenced by RtlIsValidOemCharacter(), RtlOemToUnicodeN(), and RtlResetRtlTranslations().

◆ NlsOemToUnicodeTable

PWCHAR NlsOemToUnicodeTable
extern

Definition at line 20 of file nlsboot.c.

Referenced by RtlIsValidOemCharacter(), RtlOemToUnicodeN(), and RtlResetRtlTranslations().

◆ NlsUnicodeDefaultChar

USHORT NlsUnicodeDefaultChar
extern

Definition at line 26 of file nlsboot.c.

Referenced by RtlpDidUnicodeToOemWork(), and RtlResetRtlTranslations().

◆ NlsUnicodeToMbOemTable

PUSHORT NlsUnicodeToMbOemTable
extern

◆ NlsUnicodeToOemTable

PCHAR NlsUnicodeToOemTable
extern