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)
NTSTATUS NTAPI	RtlUnicodeStringToCountedOemString (IN OUT POEM_STRING OemDest, IN PCUNICODE_STRING UniSource, IN BOOLEAN AllocateDestinationString)
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 UnicodeString)
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

#define ITU_IMPLEMENTED_TESTS   (IS_TEXT_UNICODE_ODD_LENGTH|IS_TEXT_UNICODE_SIGNATURE)

Definition at line 1269 of file unicode.c.

NDEBUG

#define NDEBUG

Definition at line 15 of file unicode.c.

Function Documentation

RtlAnsiCharToUnicodeChar()

WCHAR NTAPI RtlAnsiCharToUnicodeChar

(

IN OUT PUCHAR *

AnsiChar

)

Definition at line 50 of file unicode.c.

{
    ULONG Size;
    NTSTATUS Status;
    WCHAR UnicodeChar = L' ';
    PAGED_CODE_RTL();

    if (NlsLeadByteInfo)
    {
        Size = (NlsLeadByteInfo[**AnsiChar] == 0) ? 1 : 2;
    }
    else
    {
        DPRINT("HACK::Shouldn't have happened! Consider fixing Usetup and registry entries it creates on install\n");
        Size = 1;
    }

    Status = RtlMultiByteToUnicodeN(&UnicodeChar,
                                    sizeof(WCHAR),
                                    NULL,
                                    (PCHAR)*AnsiChar,
                                    Size);

    if (!NT_SUCCESS(Status))
    {
        UnicodeChar = L' ';
    }

    *AnsiChar += Size;
    return UnicodeChar;
}

RtlAnsiStringToUnicodeString()

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

Definition at line 91 of file unicode.c.

{
    NTSTATUS Status;
    ULONG Length;
    ULONG Index;

    PAGED_CODE_RTL();

    if (NlsMbCodePageTag == FALSE)
    {
        Length = AnsiSource->Length * 2 + sizeof(WCHAR);
    }
    else
    {
        Length = RtlxAnsiStringToUnicodeSize(AnsiSource);
    }
    if (Length > MAXUSHORT) return STATUS_INVALID_PARAMETER_2;
    UniDest->Length = (USHORT)Length - sizeof(WCHAR);

    if (AllocateDestinationString)
    {
        UniDest->Buffer = RtlpAllocateStringMemory(Length, TAG_USTR);
        UniDest->MaximumLength = (USHORT)Length;
        if (!UniDest->Buffer) return STATUS_NO_MEMORY;
    }
    else if (UniDest->Length >= UniDest->MaximumLength)
    {
        return STATUS_BUFFER_OVERFLOW;
    }

    /* UniDest->MaximumLength must be even due to sizeof(WCHAR) being 2 */
    ASSERT(!(UniDest->MaximumLength & 1) && UniDest->Length <= UniDest->MaximumLength);

    Status = RtlMultiByteToUnicodeN(UniDest->Buffer,
                                    UniDest->Length,
                                    &Index,
                                    AnsiSource->Buffer,
                                    AnsiSource->Length);

    if (!NT_SUCCESS(Status))
    {
        if (AllocateDestinationString)
        {
            RtlpFreeStringMemory(UniDest->Buffer, TAG_USTR);
            UniDest->Buffer = NULL;
        }

        return Status;
    }

    UniDest->Buffer[Index / sizeof(WCHAR)] = UNICODE_NULL;
    return Status;
}

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

RtlAppendAsciizToString()

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

Definition at line 2437 of file unicode.c.

{
    SIZE_T Size;

    if (Source)
    {
        Size = strlen(Source);

        if (Destination->Length + Size > Destination->MaximumLength)
        {
            return STATUS_BUFFER_TOO_SMALL;
        }

        RtlMoveMemory(&Destination->Buffer[Destination->Length], Source, Size);
        Destination->Length += (USHORT)Size;
    }

    return STATUS_SUCCESS;
}

RtlAppendStringToString()

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

Definition at line 179 of file unicode.c.

{
    USHORT SourceLength = Source->Length;

    if (SourceLength)
    {
        if (Destination->Length + SourceLength > Destination->MaximumLength)
        {
            return STATUS_BUFFER_TOO_SMALL;
        }

        RtlMoveMemory(&Destination->Buffer[Destination->Length],
                      Source->Buffer,
                      SourceLength);

        Destination->Length += SourceLength;
    }

    return STATUS_SUCCESS;
}

RtlAppendUnicodeStringToString()

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

Definition at line 211 of file unicode.c.

{
    USHORT SourceLength = Source->Length;
    PWCHAR Buffer = &Destination->Buffer[Destination->Length / sizeof(WCHAR)];

    if (SourceLength)
    {
        if ((SourceLength + Destination->Length) > Destination->MaximumLength)
        {
            return STATUS_BUFFER_TOO_SMALL;
        }

        RtlMoveMemory(Buffer, Source->Buffer, SourceLength);
        Destination->Length += SourceLength;

        /* append terminating '\0' if enough space */
        if (Destination->MaximumLength > Destination->Length)
        {
            Buffer[SourceLength / sizeof(WCHAR)] = UNICODE_NULL;
        }
    }

    return STATUS_SUCCESS;
}

RtlAppendUnicodeToString()

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

Definition at line 2396 of file unicode.c.

{
    USHORT Length;
    PWCHAR DestBuffer;

    if (Source)
    {
        UNICODE_STRING UnicodeSource;

        RtlInitUnicodeString(&UnicodeSource, Source);
        Length = UnicodeSource.Length;

        if (Destination->Length + Length > Destination->MaximumLength)
        {
            return STATUS_BUFFER_TOO_SMALL;
        }

        DestBuffer = &Destination->Buffer[Destination->Length / sizeof(WCHAR)];
        RtlMoveMemory(DestBuffer, Source, Length);
        Destination->Length += Length;

        /* append terminating '\0' if enough space */
        if(Destination->MaximumLength > Destination->Length)
        {
            DestBuffer[Length / sizeof(WCHAR)] = UNICODE_NULL;
        }
    }

    return STATUS_SUCCESS;
}

RtlCharToInteger()

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

Definition at line 261 of file unicode.c.

{
    CHAR chCurrent;
    int digit;
    ULONG RunningTotal = 0;
    char bMinus = 0;

    /* skip leading whitespaces */
    while (*str != '\0' && *str <= ' ') str++;

    /* Check for +/- */
    if (*str == '+')
    {
        str++;
    }
    else if (*str == '-')
    {
        bMinus = 1;
        str++;
    }

    /* base = 0 means autobase */
    if (base == 0)
    {
        base = 10;

        if (str[0] == '0')
        {
            if (str[1] == 'b')
            {
                str += 2;
                base = 2;
            }
            else if (str[1] == 'o')
            {
                str += 2;
                base = 8;
            }
            else if (str[1] == 'x')
            {
                str += 2;
                base = 16;
            }
        }
    }
    else if (base != 2 && base != 8 && base != 10 && base != 16)
    {
        return STATUS_INVALID_PARAMETER;
    }

    if (value == NULL) return STATUS_ACCESS_VIOLATION;

    while (*str != '\0')
    {
        chCurrent = *str;

        if (chCurrent >= '0' && chCurrent <= '9')
        {
            digit = chCurrent - '0';
        }
        else if (chCurrent >= 'A' && chCurrent <= 'Z')
        {
            digit = chCurrent - 'A' + 10;
        }
        else if (chCurrent >= 'a' && chCurrent <= 'z')
        {
            digit = chCurrent - 'a' + 10;
        }
        else
        {
            digit = -1;
        }

        if (digit < 0 || digit >= (int)base) break;

        RunningTotal = RunningTotal * base + digit;
        str++;
    }

    *value = bMinus ? (0 - RunningTotal) : RunningTotal;
    return STATUS_SUCCESS;
}

Referenced by CsrParseServerCommandLine(), CsrSrvCreateSharedSection(), ExtractFont(), 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.

{
    unsigned int len;
    LONG ret = 0;
    LPCSTR p1, p2;

    len = min(s1->Length, s2->Length);
    p1 = s1->Buffer;
    p2 = s2->Buffer;

    if (CaseInsensitive)
    {
        while (!ret && len--)
            ret = RtlUpperChar(*p1++) - RtlUpperChar(*p2++);
    }
    else
    {
        while (!ret && len--) ret = *p1++ - *p2++;
    }

    if (!ret) ret = s1->Length - s2->Length;

    return ret;
}

Referenced by RtlEqualString().

RtlCompareUnicodeString()

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

Definition at line 2184 of file unicode.c.

{
    unsigned int len;
    LONG ret = 0;
    LPCWSTR p1, p2;

    len = min(s1->Length, s2->Length) / sizeof(WCHAR);
    p1 = s1->Buffer;
    p2 = s2->Buffer;

    if (CaseInsensitive)
    {
        while (!ret && len--) ret = RtlpUpcaseUnicodeChar(*p1++) - RtlpUpcaseUnicodeChar(*p2++);
    }
    else
    {
        while (!ret && len--) ret = *p1++ - *p2++;
    }

    if (!ret) ret = s1->Length - s2->Length;

    return ret;
}

Referenced by RtlEqualUnicodeString().

RtlCopyString()

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

Definition at line 2216 of file unicode.c.

{
    ULONG SourceLength;
    PCHAR p1, p2;

    /* Check if there was no source given */
    if(!SourceString)
    {
        /* Simply return an empty string */
        DestinationString->Length = 0;
    }
    else
    {
        /* Choose the smallest length */
        SourceLength = min(DestinationString->MaximumLength,
                           SourceString->Length);

        /* Set it */
        DestinationString->Length = (USHORT)SourceLength;

        /* Save the pointers to each buffer */
        p1 = DestinationString->Buffer;
        p2 = SourceString->Buffer;

        /* Loop the buffer */
        while (SourceLength)
        {
            /* Copy the character and move on */
            *p1++ = * p2++;
            SourceLength--;
        }
    }
}

RtlCopyUnicodeString()

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

Definition at line 2257 of file unicode.c.

{
    ULONG SourceLength;

    if(SourceString == NULL)
    {
        DestinationString->Length = 0;
    }
    else
    {
        SourceLength = min(DestinationString->MaximumLength,
                           SourceString->Length);
        DestinationString->Length = (USHORT)SourceLength;

        RtlCopyMemory(DestinationString->Buffer,
                      SourceString->Buffer,
                      SourceLength);

        if (DestinationString->Length < DestinationString->MaximumLength)
        {
            DestinationString->Buffer[SourceLength / sizeof(WCHAR)] = UNICODE_NULL;
        }
    }
}

RtlCreateUnicodeString()

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

Definition at line 2292 of file unicode.c.

{
    SIZE_T Size;
    PAGED_CODE_RTL();

    Size = (wcslen(Source) + 1) * sizeof(WCHAR);
    if (Size > MAXUSHORT) return FALSE;

    UniDest->Buffer = RtlpAllocateStringMemory((ULONG)Size, TAG_USTR);

    if (UniDest->Buffer == NULL) return FALSE;

    RtlCopyMemory(UniDest->Buffer, Source, Size);
    UniDest->MaximumLength = (USHORT)Size;
    UniDest->Length = (USHORT)Size - sizeof (WCHAR);

    return TRUE;
}

RtlCreateUnicodeStringFromAsciiz()

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

Definition at line 2318 of file unicode.c.

{
    ANSI_STRING AnsiString;
    NTSTATUS Status;

    RtlInitAnsiString(&AnsiString, Source);

    Status = RtlAnsiStringToUnicodeString(Destination,
                                          &AnsiString,
                                          TRUE);

    return NT_SUCCESS(Status);
}

RtlDnsHostNameToComputerName()

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

Definition at line 2728 of file unicode.c.

{
    NTSTATUS Status;
    ULONG Length;
    ULONG ComputerNameLength;
    ULONG ComputerNameOemNLength;
    OEM_STRING ComputerNameOem;
    CHAR ComputerNameOemN[MAX_COMPUTERNAME_LENGTH + 1];

    Status = STATUS_INVALID_COMPUTER_NAME;
    ComputerNameLength = DnsHostName->Length;

    /* find the first dot in the dns host name */
    for (Length = 0; Length < DnsHostName->Length / sizeof(WCHAR); Length++)
    {
        if (DnsHostName->Buffer[Length] == L'.')
        {
            /* dot found, so set the length for the oem translation */
            ComputerNameLength = Length * sizeof(WCHAR);
            break;
        }
    }

    /* the computername must have one character */
    if (ComputerNameLength > 0)
    {
        ComputerNameOemNLength = 0;
        /* convert to oem string and use uppercase letters */
        Status = RtlUpcaseUnicodeToOemN(ComputerNameOemN,
                                        MAX_COMPUTERNAME_LENGTH,
                                        &ComputerNameOemNLength,
                                        DnsHostName->Buffer,
                                        ComputerNameLength);

        /* status STATUS_BUFFER_OVERFLOW is not a problem since the computername shoud only
           have MAX_COMPUTERNAME_LENGTH characters */
        if ((Status == STATUS_SUCCESS) ||
                (Status == STATUS_BUFFER_OVERFLOW))
        {
            /* set the termination for the oem string */
            ComputerNameOemN[MAX_COMPUTERNAME_LENGTH] = 0;
            /* set status for the case the next function failed */
            Status = STATUS_INVALID_COMPUTER_NAME;
            /* fillup the oem string structure with the converted computername
               and check it for unmapped characters */
            ComputerNameOem.Buffer = ComputerNameOemN;
            ComputerNameOem.Length = (USHORT)ComputerNameOemNLength;
            ComputerNameOem.MaximumLength = (USHORT)(MAX_COMPUTERNAME_LENGTH + 1);

            if (RtlpDidUnicodeToOemWork(DnsHostName, &ComputerNameOem))
            {
                /* no unmapped character so convert it back to an unicode string */
                Status = RtlOemStringToUnicodeString(ComputerName,
                                                     &ComputerNameOem,
                                                     AllocateComputerNameString);
            }
        }
    }

    return Status;
}

RtlDowncaseUnicodeString()

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

Definition at line 2344 of file unicode.c.

{
    ULONG i;
    ULONG StopGap;
    PAGED_CODE_RTL();

    if (AllocateDestinationString)
    {
        UniDest->MaximumLength = UniSource->Length;
        UniDest->Buffer = RtlpAllocateStringMemory(UniSource->Length, TAG_USTR);
        if (UniDest->Buffer == NULL) return STATUS_NO_MEMORY;
    }
    else if (UniSource->Length > UniDest->MaximumLength)
    {
        return STATUS_BUFFER_OVERFLOW;
    }

    UniDest->Length = UniSource->Length;
    StopGap = UniSource->Length / sizeof(WCHAR);

    for (i = 0 ; i < StopGap; i++)
    {
        if (UniSource->Buffer[i] < L'A')
        {
            UniDest->Buffer[i] = UniSource->Buffer[i];
        }
        else if (UniSource->Buffer[i] <= L'Z')
        {
            UniDest->Buffer[i] = (UniSource->Buffer[i] + (L'a' - L'A'));
        }
        else
        {
            UniDest->Buffer[i] = RtlpDowncaseUnicodeChar(UniSource->Buffer[i]);
        }
    }

    return STATUS_SUCCESS;
}

RtlDuplicateUnicodeString()

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

Definition at line 2492 of file unicode.c.

{
    PAGED_CODE_RTL();

    if (SourceString == NULL || DestinationString == NULL ||
        SourceString->Length > SourceString->MaximumLength ||
        (SourceString->Length == 0 && SourceString->MaximumLength > 0 && SourceString->Buffer == NULL) ||
        Flags == RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING || Flags >= 4)
    {
        return STATUS_INVALID_PARAMETER;
    }


    if ((SourceString->Length == 0) &&
        (Flags != (RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE |
                   RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING)))
    {
        DestinationString->Length = 0;
        DestinationString->MaximumLength = 0;
        DestinationString->Buffer = NULL;
    }
    else
    {
        UINT DestMaxLength = SourceString->Length;

        if (Flags & RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE)
            DestMaxLength += sizeof(UNICODE_NULL);

        DestinationString->Buffer = RtlpAllocateStringMemory(DestMaxLength, TAG_USTR);

        if (DestinationString->Buffer == NULL)
            return STATUS_NO_MEMORY;

        RtlCopyMemory(DestinationString->Buffer, SourceString->Buffer, SourceString->Length);
        DestinationString->Length = SourceString->Length;
        DestinationString->MaximumLength = DestMaxLength;

        if (Flags & RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE)
            DestinationString->Buffer[DestinationString->Length / sizeof(WCHAR)] = 0;
    }

    return STATUS_SUCCESS;
}

RtlEqualComputerName()

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

Definition at line 1532 of file unicode.c.

{
    OEM_STRING OemString1;
    OEM_STRING OemString2;
    BOOLEAN Result = FALSE;

    if (NT_SUCCESS(RtlUpcaseUnicodeStringToOemString(&OemString1,
                                                     ComputerName1,
                                                     TRUE)))
    {
        if (NT_SUCCESS(RtlUpcaseUnicodeStringToOemString(&OemString2,
                                                         ComputerName2,
                                                         TRUE)))
        {
            Result = RtlEqualString(&OemString1, &OemString2, FALSE);
            RtlFreeOemString(&OemString2);
        }

        RtlFreeOemString(&OemString1);
    }

    return Result;
}

Referenced by RtlEqualDomainName().

RtlEqualDomainName()

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

Definition at line 1569 of file unicode.c.

{
    return RtlEqualComputerName(DomainName1, DomainName2);
}

RtlEqualString()

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

Definition at line 388 of file unicode.c.

{
    if (s1->Length != s2->Length) return FALSE;
    return !RtlCompareString(s1, s2, CaseInsensitive);
}

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.

{
    if (s1->Length != s2->Length) return FALSE;
    return !RtlCompareUnicodeString(s1, s2, CaseInsensitive );
}

RtlEraseUnicodeString()

VOID NTAPI RtlEraseUnicodeString

(

IN PUNICODE_STRING

String

)

Definition at line 1712 of file unicode.c.

{
    if (String->Buffer && String->MaximumLength)
    {
        RtlZeroMemory(String->Buffer, String->MaximumLength);
        String->Length = 0;
    }
}

RtlFindCharInUnicodeString()

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

Definition at line 2663 of file unicode.c.

{
    BOOLEAN Found;
    const BOOLEAN WantToFind = (Flags & RTL_FIND_CHAR_IN_UNICODE_STRING_COMPLEMENT_CHAR_SET) == 0;
    const BOOLEAN CaseInSensitive = (Flags & RTL_FIND_CHAR_IN_UNICODE_STRING_CASE_INSENSITIVE) != 0;
    USHORT i, Length;

    DPRINT("RtlFindCharInUnicodeString(%u, '%wZ', '%wZ', %p)\n",
           Flags, SearchString, MatchString, Position);

    /* Parameter checks */
    if (Position == NULL)
        return STATUS_INVALID_PARAMETER;

    *Position = 0;

    if (Flags & ~(RTL_FIND_CHAR_IN_UNICODE_STRING_START_AT_END |
                  RTL_FIND_CHAR_IN_UNICODE_STRING_COMPLEMENT_CHAR_SET |
                  RTL_FIND_CHAR_IN_UNICODE_STRING_CASE_INSENSITIVE))
        return STATUS_INVALID_PARAMETER;

    /* Search */
    Length = SearchString->Length / sizeof(WCHAR);
    if (Flags & RTL_FIND_CHAR_IN_UNICODE_STRING_START_AT_END)
    {
        for (i = Length - 1; (SHORT)i >= 0; i--)
        {
            Found = RtlpIsCharInUnicodeString(SearchString->Buffer[i], MatchString, CaseInSensitive);
            if (Found == WantToFind)
            {
                *Position = i * sizeof(WCHAR);
                return STATUS_SUCCESS;
            }
        }
    }
    else
    {
        for (i = 0; i < Length; i++)
        {
            Found = RtlpIsCharInUnicodeString(SearchString->Buffer[i], MatchString, CaseInSensitive);
            if (Found == WantToFind)
            {
                *Position = (i + 1) * sizeof(WCHAR);
                return STATUS_SUCCESS;
            }
        }
    }

    return STATUS_NOT_FOUND;
}

RtlFreeAnsiString()

VOID NTAPI RtlFreeAnsiString

(

IN PANSI_STRING

AnsiString

)

Definition at line 419 of file unicode.c.

{
    PAGED_CODE_RTL();

    if (AnsiString->Buffer)
    {
        RtlpFreeStringMemory(AnsiString->Buffer, TAG_ASTR);
        RtlZeroMemory(AnsiString, sizeof(ANSI_STRING));
    }
}

RtlFreeOemString()

VOID NTAPI RtlFreeOemString

(

IN POEM_STRING

OemString

)

Definition at line 435 of file unicode.c.

{
    PAGED_CODE_RTL();

    if (OemString->Buffer) RtlpFreeStringMemory(OemString->Buffer, TAG_OSTR);
}

Referenced by RtlEqualComputerName().

RtlFreeUnicodeString()

VOID NTAPI RtlFreeUnicodeString

(

IN PUNICODE_STRING

UnicodeString

)

Definition at line 447 of file unicode.c.

{
    PAGED_CODE_RTL();

    if (UnicodeString->Buffer)
    {
        RtlpFreeStringMemory(UnicodeString->Buffer, TAG_USTR);
        RtlZeroMemory(UnicodeString, sizeof(UNICODE_STRING));
    }
}

RtlGUIDFromString()

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

Definition at line 1596 of file unicode.c.

{
    int i = 0;
    const WCHAR *lpszCLSID = str->Buffer;
    BYTE* lpOut = (BYTE*)guid;

    //TRACE("(%s,%p)\n", debugstr_us(str), guid);

    /* Convert string: {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}
     * to memory:       DWORD... WORD WORD BYTES............
     */
    while (i <= 37)
    {
        switch (i)
        {
            case 0:
                if (*lpszCLSID != '{')
                    return STATUS_INVALID_PARAMETER;
                break;

            case 9:
            case 14:
            case 19:
            case 24:
                if (*lpszCLSID != '-')
                    return STATUS_INVALID_PARAMETER;
                break;

            case 37:
                if (*lpszCLSID != '}')
                    return STATUS_INVALID_PARAMETER;

                break;

            default:
            {
                WCHAR ch = *lpszCLSID, ch2 = lpszCLSID[1];
                unsigned char byte;

                /* Read two hex digits as a byte value */
                if      (ch >= '0' && ch <= '9')
                    ch = ch - '0';
                else if (ch >= 'a' && ch <= 'f')
                    ch = ch - 'a' + 10;
                else if (ch >= 'A' && ch <= 'F')
                    ch = ch - 'A' + 10;
                else
                    return STATUS_INVALID_PARAMETER;

                if      (ch2 >= '0' && ch2 <= '9')
                    ch2 = ch2 - '0';
                else if (ch2 >= 'a' && ch2 <= 'f')
                    ch2 = ch2 - 'a' + 10;
                else if (ch2 >= 'A' && ch2 <= 'F')
                    ch2 = ch2 - 'A' + 10;
                else
                    return STATUS_INVALID_PARAMETER;

                byte = ch << 4 | ch2;

                switch (i)
                {
#ifndef WORDS_BIGENDIAN
                        /* For Big Endian machines, we store the data such that the
                         * dword/word members can be read as DWORDS and WORDS correctly. */
                        /* Dword */
                    case 1:
                        lpOut[3] = byte;
                        break;
                    case 3:
                        lpOut[2] = byte;
                        break;
                    case 5:
                        lpOut[1] = byte;
                        break;
                    case 7:
                        lpOut[0] = byte;
                        lpOut += 4;
                        break;
                        /* Word */
                    case 10:
                    case 15:
                        lpOut[1] = byte;
                        break;
                    case 12:
                    case 17:
                        lpOut[0] = byte;
                        lpOut += 2;
                        break;
#endif
                        /* Byte */
                    default:
                        lpOut[0] = byte;
                        lpOut++;
                        break;
                }

                lpszCLSID++; /* Skip 2nd character of byte */
                i++;
            }
        }

        lpszCLSID++;
        i++;
    }

    return STATUS_SUCCESS;
}

RtlHashUnicodeString()

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

Definition at line 1727 of file unicode.c.

{
    if (String != NULL && HashValue != NULL)
    {
        switch (HashAlgorithm)
        {
            case HASH_STRING_ALGORITHM_DEFAULT:
            case HASH_STRING_ALGORITHM_X65599:
            {
                WCHAR *c, *end;

                *HashValue = 0;
                end = String->Buffer + (String->Length / sizeof(WCHAR));

                if (CaseInSensitive)
                {
                    for (c = String->Buffer; c != end; c++)
                    {
                        /* only uppercase characters if they are 'a' ... 'z'! */
                        *HashValue = ((65599 * (*HashValue)) +
                                      (ULONG)(((*c) >= L'a' && (*c) <= L'z') ?
                                              (*c) - L'a' + L'A' : (*c)));
                    }
                }
                else
                {
                    for (c = String->Buffer; c != end; c++)
                    {
                        *HashValue = ((65599 * (*HashValue)) + (ULONG)(*c));
                    }
                }

                return STATUS_SUCCESS;
            }
        }
    }

    return STATUS_INVALID_PARAMETER;
}

RtlInitAnsiString()

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

Definition at line 562 of file unicode.c.

{
    SIZE_T Size;

    if (SourceString)
    {
        Size = strlen(SourceString);
        if (Size > (MAXUSHORT - sizeof(CHAR))) Size = MAXUSHORT - sizeof(CHAR);
        DestinationString->Length = (USHORT)Size;
        DestinationString->MaximumLength = (USHORT)Size + sizeof(CHAR);
    }
    else
    {
        DestinationString->Length = 0;
        DestinationString->MaximumLength = 0;
    }

    DestinationString->Buffer = (PCHAR)SourceString;
}

Referenced by RtlCreateUnicodeStringFromAsciiz(), and RtlInitString().

RtlInitAnsiStringEx()

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

Definition at line 585 of file unicode.c.

{
    SIZE_T Size;

    if (SourceString)
    {
        Size = strlen(SourceString);
        if (Size > (MAXUSHORT - sizeof(CHAR))) return STATUS_NAME_TOO_LONG;
        DestinationString->Length = (USHORT)Size;
        DestinationString->MaximumLength = (USHORT)Size + sizeof(CHAR);
    }
    else
    {
        DestinationString->Length = 0;
        DestinationString->MaximumLength = 0;
    }

    DestinationString->Buffer = (PCHAR)SourceString;
    return STATUS_SUCCESS;

}

RtlInitString()

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

Definition at line 615 of file unicode.c.

{
    RtlInitAnsiString(DestinationString, SourceString);
}

RtlInitUnicodeString()

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

Definition at line 630 of file unicode.c.

{
    SIZE_T Size;
    CONST SIZE_T MaxSize = (MAXUSHORT & ~1) - sizeof(UNICODE_NULL); // an even number

    if (SourceString)
    {
        Size = wcslen(SourceString) * sizeof(WCHAR);
        __analysis_assume(Size <= MaxSize);

        if (Size > MaxSize)
            Size = MaxSize;
        DestinationString->Length = (USHORT)Size;
        DestinationString->MaximumLength = (USHORT)Size + sizeof(UNICODE_NULL);
    }
    else
    {
        DestinationString->Length = 0;
        DestinationString->MaximumLength = 0;
    }

    DestinationString->Buffer = (PWCHAR)SourceString;
}

Referenced by RtlAppendUnicodeToString().

RtlInitUnicodeStringEx()

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

Definition at line 661 of file unicode.c.

{
    SIZE_T Size;
    CONST SIZE_T MaxSize = (MAXUSHORT & ~1) - sizeof(WCHAR); // an even number

    if (SourceString)
    {
        Size = wcslen(SourceString) * sizeof(WCHAR);
        if (Size > MaxSize) return STATUS_NAME_TOO_LONG;
        DestinationString->Length = (USHORT)Size;
        DestinationString->MaximumLength = (USHORT)Size + sizeof(WCHAR);
    }
    else
    {
        DestinationString->Length = 0;
        DestinationString->MaximumLength = 0;
    }

    DestinationString->Buffer = (PWCHAR)SourceString;
    return STATUS_SUCCESS;
}

RtlInt64ToUnicodeString()

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

Definition at line 842 of file unicode.c.

{
    LARGE_INTEGER LargeInt;
    ANSI_STRING AnsiString;
    CHAR Buffer[65];
    NTSTATUS Status;

    LargeInt.QuadPart = Value;

    Status = RtlLargeIntegerToChar(&LargeInt, Base, sizeof(Buffer), Buffer);
    if (NT_SUCCESS(Status))
    {
        AnsiString.Buffer = Buffer;
        AnsiString.Length = (USHORT)strlen(Buffer);
        AnsiString.MaximumLength = sizeof(Buffer);

        Status = RtlAnsiStringToUnicodeString(String, &AnsiString, FALSE);
    }

    return Status;
}

RtlIntegerToChar()

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

Definition at line 693 of file unicode.c.

{
    CHAR buffer[33];
    PCHAR pos;
    CHAR digit;
    SIZE_T len;

    if (base == 0)
    {
        base = 10;
    }
    else if (base != 2 && base != 8 && base != 10 && base != 16)
    {
        return STATUS_INVALID_PARAMETER;
    }

    pos = &buffer[32];
    *pos = '\0';

    do
    {
        pos--;
        digit = (CHAR)(value % base);
        value = value / base;

        if (digit < 10)
        {
            *pos = '0' + digit;
        }
        else
        {
            *pos = 'A' + digit - 10;
        }
    }
    while (value != 0L);

    len = &buffer[32] - pos;

    if (len > length)
    {
        return STATUS_BUFFER_OVERFLOW;
    }
    else if (str == NULL)
    {
        return STATUS_ACCESS_VIOLATION;
    }
    else if (len == length)
    {
        RtlCopyMemory(str, pos, len);
    }
    else
    {
        RtlCopyMemory(str, pos, len + 1);
    }

    return STATUS_SUCCESS;
}

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 760 of file unicode.c.

{
    ULONG Radix;
    WCHAR  temp[33];
    ULONG v = Value;
    ULONG i;
    PWCHAR tp;
    PWCHAR sp;

    Radix = Base;

    if (Radix == 0) Radix = 10;

    if ((Radix != 2) && (Radix != 8) &&
        (Radix != 10) && (Radix != 16))
    {
        return STATUS_INVALID_PARAMETER;
    }

    tp = temp;

    while (v || tp == temp)
    {
        i = v % Radix;
        v = v / Radix;

        if (i < 10) *tp = (WCHAR)(i + L'0');
        else *tp = (WCHAR)(i + L'a' - 10);

        tp++;
    }

    if ((ULONG)((ULONG_PTR)tp - (ULONG_PTR)temp) >= Length)
    {
        return STATUS_BUFFER_TOO_SMALL;
    }

    sp = String;

    while (tp > temp) *sp++ = *--tp;

    *sp = 0;

    return STATUS_SUCCESS;
}

RtlIntegerToUnicodeString()

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

Definition at line 815 of file unicode.c.

{
    ANSI_STRING AnsiString;
    CHAR Buffer[33];
    NTSTATUS Status;

    Status = RtlIntegerToChar(Value, Base, sizeof(Buffer), Buffer);
    if (NT_SUCCESS(Status))
    {
        AnsiString.Buffer = Buffer;
        AnsiString.Length = (USHORT)strlen(Buffer);
        AnsiString.MaximumLength = sizeof(Buffer);

        Status = RtlAnsiStringToUnicodeString(String, &AnsiString, FALSE);
    }

    return Status;
}

RtlIsTextUnicode()

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

Definition at line 1279 of file unicode.c.

{
    static const WCHAR std_control_chars[] = {'\r', '\n', '\t', ' ', 0x3000, 0};
    static const WCHAR byterev_control_chars[] = {0x0d00, 0x0a00, 0x0900, 0x2000, 0};
    const WCHAR *s = buf;
    int i;
    unsigned int flags = MAXULONG, out_flags = 0;
    UCHAR last_lo_byte = 0;
    UCHAR last_hi_byte = 0;
    ULONG hi_byte_diff = 0;
    ULONG lo_byte_diff = 0;
    ULONG weight = 3;
    ULONG lead_byte = 0;

    if (len < sizeof(WCHAR))
    {
        /* FIXME: MSDN documents IS_TEXT_UNICODE_BUFFER_TOO_SMALL but there is no such thing... */
        if (pf) *pf = 0;

        return FALSE;
    }

    if (pf)
        flags = *pf;

    /*
     * Apply various tests to the text string. According to the
     * docs, each test "passed" sets the corresponding flag in
     * the output flags. But some of the tests are mutually
     * exclusive, so I don't see how you could pass all tests ...
     */

    /* Check for an odd length ... pass if even. */
    if (len & 1) out_flags |= IS_TEXT_UNICODE_ODD_LENGTH;

    if (((char *)buf)[len - 1] == 0)
        len--;  /* Windows seems to do something like that to avoid e.g. false IS_TEXT_UNICODE_NULL_BYTES  */

    len /= sizeof(WCHAR);

    /* Windows only checks the first 256 characters */
    if (len > 256) len = 256;

    /* Check for the special byte order unicode marks. */
    if (*s == 0xFEFF) out_flags |= IS_TEXT_UNICODE_SIGNATURE;
    if (*s == 0xFFFE) out_flags |= IS_TEXT_UNICODE_REVERSE_SIGNATURE;

    for (i = 0; i < len; i++)
    {
        UCHAR lo_byte = LOBYTE(s[i]);
        UCHAR hi_byte = HIBYTE(s[i]);

        lo_byte_diff += max(lo_byte, last_lo_byte) - min(lo_byte, last_lo_byte);
        hi_byte_diff += max(hi_byte, last_hi_byte) - min(hi_byte, last_hi_byte);

        last_lo_byte = lo_byte;
        last_hi_byte = hi_byte;

        switch (s[i])
        {
            case 0xFFFE: /* Reverse BOM */
            case UNICODE_NULL:
            case 0x0A0D: /* ASCII CRLF (packed into one word) */
            case 0xFFFF: /* Unicode 0xFFFF */
                out_flags |= IS_TEXT_UNICODE_ILLEGAL_CHARS;
                break;
        }
    }

    if (NlsMbCodePageTag)
    {
        for (i = 0; i < len; i++)
        {
            if (NlsLeadByteInfo[s[i]])
            {
                ++lead_byte;
                ++i;
            }
        }

        if (lead_byte)
        {
            weight = (len / 2) - 1;

            if (lead_byte < (weight / 3))
                weight = 3;
            else if (lead_byte < ((weight * 2) / 3))
                weight = 2;
            else
                weight = 1;

            if (pf && (*pf & IS_TEXT_UNICODE_DBCS_LEADBYTE))
                out_flags |= IS_TEXT_UNICODE_DBCS_LEADBYTE;
        }
    }

    if (lo_byte_diff < 127 && !hi_byte_diff)
    {
        out_flags |= IS_TEXT_UNICODE_ASCII16;
    }

    if (hi_byte_diff && !lo_byte_diff)
    {
        out_flags |= IS_TEXT_UNICODE_REVERSE_ASCII16;
    }

    if ((weight * lo_byte_diff) < hi_byte_diff)
    {
        out_flags |= IS_TEXT_UNICODE_REVERSE_STATISTICS;
    }

    /* apply some statistical analysis */
    if ((flags & IS_TEXT_UNICODE_STATISTICS) &&
        ((weight * hi_byte_diff) < lo_byte_diff))
    {
        out_flags |= IS_TEXT_UNICODE_STATISTICS;
    }

    /* Check for unicode NULL chars */
    if (flags & IS_TEXT_UNICODE_NULL_BYTES)
    {
        for (i = 0; i < len; i++)
        {
            if (!(s[i] & 0xff) || !(s[i] >> 8))
            {
                out_flags |= IS_TEXT_UNICODE_NULL_BYTES;
                break;
            }
        }
    }

    if (flags & IS_TEXT_UNICODE_CONTROLS)
    {
        for (i = 0; i < len; i++)
        {
            if (strchrW(std_control_chars, s[i]))
            {
                out_flags |= IS_TEXT_UNICODE_CONTROLS;
                break;
            }
        }
    }

    if (flags & IS_TEXT_UNICODE_REVERSE_CONTROLS)
    {
        for (i = 0; i < len; i++)
        {
            if (strchrW(byterev_control_chars, s[i]))
            {
                out_flags |= IS_TEXT_UNICODE_REVERSE_CONTROLS;
                break;
            }
        }
    }

    if (pf)
    {
        out_flags &= *pf;
        *pf = out_flags;
    }

    /* check for flags that indicate it's definitely not valid Unicode */
    if (out_flags & (IS_TEXT_UNICODE_REVERSE_MASK | IS_TEXT_UNICODE_NOT_UNICODE_MASK)) return FALSE;

    /* now check for invalid ASCII, and assume Unicode if so */
    if (out_flags & IS_TEXT_UNICODE_NOT_ASCII_MASK) return TRUE;

    /* now check for Unicode flags */
    if (out_flags & IS_TEXT_UNICODE_UNICODE_MASK) return TRUE;

    /* no flags set */
    return FALSE;
}

Referenced by IsTextUnicode().

RtlIsValidOemCharacter()

BOOLEAN NTAPI RtlIsValidOemCharacter

(

IN PWCHAR

Char

)

Definition at line 514 of file unicode.c.

{
    WCHAR UnicodeChar;
    WCHAR OemChar;

    /* If multi-byte code page present */
    if (NlsMbOemCodePageTag)
    {
        USHORT Offset = 0;

        OemChar = NlsUnicodeToMbOemTable[*Char];

        /* If character has Lead Byte */
        if (NlsOemLeadByteInfo[HIBYTE(OemChar)])
            Offset = NlsOemLeadByteInfo[HIBYTE(OemChar)];

        /* Receive Unicode character from the table */
        UnicodeChar = RtlpUpcaseUnicodeChar(NlsOemToUnicodeTable[LOBYTE(OemChar) + Offset]);

        /* Receive OEM character from the table */
        OemChar = NlsUnicodeToMbOemTable[UnicodeChar];
    }
    else
    {
        /* Receive Unicode character from the table */
        UnicodeChar = RtlpUpcaseUnicodeChar(NlsOemToUnicodeTable[(UCHAR)NlsUnicodeToOemTable[*Char]]);

        /* Receive OEM character from the table */
        OemChar = NlsUnicodeToOemTable[UnicodeChar];
    }

    /* Not valid character, failed */
    if (OemChar == NlsOemDefaultChar)
        return FALSE;

    *Char = UnicodeChar;

    return TRUE;
}

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 1846 of file unicode.c.

{
    ULONGLONG Val = Value->QuadPart;
    CHAR Buffer[65];
    CHAR Digit;
    SIZE_T Len;
    PCHAR Pos;

    if (Base == 0) Base = 10;

    if ((Base != 2) && (Base != 8) && (Base != 10) && (Base != 16))
    {
        return STATUS_INVALID_PARAMETER;
    }

    Pos = &Buffer[64];
    *Pos = '\0';

    do
    {
        Pos--;
        Digit = (CHAR)(Val % Base);
        Val = Val / Base;

        if (Digit < 10)
            *Pos = '0' + Digit;
        else
            *Pos = 'A' + Digit - 10;
    }
    while (Val != 0L);

    Len = &Buffer[64] - Pos;

    if (Len > Length)
        return STATUS_BUFFER_OVERFLOW;

    /* If possible, add the 0 termination */
    if (Len < Length)
        Len += 1;

    /* Copy the string to the target using SEH */
    return RtlpSafeCopyMemory(String, Pos, Len);
}

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.

{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

RtlOemStringToCountedUnicodeString()

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

Definition at line 1463 of file unicode.c.

{
    NTSTATUS Status;
    ULONG Length;
    ULONG Index;

    PAGED_CODE_RTL();

    /* Calculate size of the string */
    Length = RtlOemStringToCountedUnicodeSize(OemSource);

    /* If it's 0 then zero out dest string and return */
    if (!Length)
    {
        RtlZeroMemory(UniDest, sizeof(UNICODE_STRING));
        return STATUS_SUCCESS;
    }

    /* Check if length is a sane value */
    if (Length > MAXUSHORT) return STATUS_INVALID_PARAMETER_2;

    /* Store it in dest string */
    UniDest->Length = (USHORT)Length;

    /* If we're asked to alloc the string - do so */
    if (AllocateDestinationString)
    {
        UniDest->Buffer = RtlpAllocateStringMemory(Length, TAG_USTR);
        UniDest->MaximumLength = (USHORT)Length;

        if (!UniDest->Buffer) return STATUS_NO_MEMORY;
    }
    else if (UniDest->Length > UniDest->MaximumLength)
    {
        return STATUS_BUFFER_OVERFLOW;
    }

    /* Do the conversion */
    Status = RtlOemToUnicodeN(UniDest->Buffer,
                              UniDest->Length,
                              &Index,
                              OemSource->Buffer,
                              OemSource->Length);

    if (!NT_SUCCESS(Status) && AllocateDestinationString)
    {
        /* Conversion failed, free dest string and return status code */
        RtlpFreeStringMemory(UniDest->Buffer, TAG_USTR);
        UniDest->Buffer = NULL;
        return Status;
    }

    return STATUS_SUCCESS;
}

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 1169 of file unicode.c.

{
    NTSTATUS Status;
    ULONG Length;
    ULONG Index;

    PAGED_CODE_RTL();

    Length = RtlOemStringToUnicodeSize(OemSource);

    if (Length > MAXUSHORT) return STATUS_INVALID_PARAMETER_2;

    UniDest->Length = (USHORT)Length - sizeof(WCHAR);

    if (AllocateDestinationString)
    {
        UniDest->Buffer = RtlpAllocateStringMemory(Length, TAG_USTR);
        UniDest->MaximumLength = (USHORT)Length;

        if (!UniDest->Buffer) return STATUS_NO_MEMORY;
    }
    else if (UniDest->Length >= UniDest->MaximumLength)
    {
        return STATUS_BUFFER_OVERFLOW;
    }

    Status = RtlOemToUnicodeN(UniDest->Buffer,
                              UniDest->Length,
                              &Index,
                              OemSource->Buffer,
                              OemSource->Length);

    if (!NT_SUCCESS(Status) && AllocateDestinationString)
    {
        RtlpFreeStringMemory(UniDest->Buffer, TAG_USTR);
        UniDest->Buffer = NULL;
        return Status;
    }

    UniDest->Buffer[Index / sizeof(WCHAR)] = UNICODE_NULL;
    return Status;
}

Referenced by RtlDnsHostNameToComputerName().

RtlpDidUnicodeToOemWork()

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

Definition at line 472 of file unicode.c.

{
    ULONG i = 0;

    if (NlsMbOemCodePageTag == FALSE)
    {
        /* single-byte code page */
        /* Go through all characters of a string */
        while (i < OemString->Length)
        {
            /* Check if it got translated into a default char,
             * but source char wasn't a default char equivalent
             */
            if ((OemString->Buffer[i] == NlsOemDefaultChar) &&
                (UnicodeString->Buffer[i] != NlsUnicodeDefaultChar))
            {
                /* Yes, it means unmappable characters were found */
                return FALSE;
            }

            /* Move to the next char */
            i++;
        }

        /* All chars were translated successfuly */
        return TRUE;
    }
    else
    {
        /* multibyte code page */

        /* FIXME */
        return TRUE;
    }
}

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

RtlpEnsureBufferSize()

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

Definition at line 2573 of file unicode.c.

{
    PUCHAR NewBuffer;

    /* Parameter checks */
    if (Flags & ~RTL_SKIP_BUFFER_COPY)
        return STATUS_INVALID_PARAMETER;
    if (Buffer == NULL)
        return STATUS_INVALID_PARAMETER;

    /*
     * We don't need to grow the buffer if its size
     * is already larger than the required size.
     */
    if (Buffer->Size >= RequiredSize)
        return STATUS_SUCCESS;

    /*
     * When we are using the static buffer as our buffer, we don't need
     * to grow it if its size is already larger than the required size.
     * In this case, just keep it but update the current buffer size to
     * the one requested.
     * (But NEVER EVER modify the size of the static buffer!!)
     * Otherwise, we'll need to create a new buffer and use this one instead.
     */
    if ( (Buffer->Buffer == Buffer->StaticBuffer) &&
         (Buffer->StaticSize >= RequiredSize) )
    {
        Buffer->Size = RequiredSize;
        return STATUS_SUCCESS;
    }

    /* The buffer we are using is not large enough, try to create a bigger one */
    NewBuffer = RtlpAllocateStringMemory(RequiredSize, TAG_USTR);
    if (NewBuffer == NULL)
        return STATUS_NO_MEMORY;

    /* Copy the original content if needed */
    if (!(Flags & RTL_SKIP_BUFFER_COPY))
    {
        RtlMoveMemory(NewBuffer, Buffer->Buffer, Buffer->Size);
    }

    /* Free the original buffer only if it's not the static buffer */
    if (Buffer->Buffer != Buffer->StaticBuffer)
    {
        RtlpFreeStringMemory(Buffer->Buffer, TAG_USTR);
    }

    /* Update the members */
    Buffer->Buffer = NewBuffer;
    Buffer->Size   = RequiredSize;

    /* Done */
    return STATUS_SUCCESS;
}

RtlpIsCharInUnicodeString()

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

static

Definition at line 2635 of file unicode.c.

{
    USHORT i;

    if (CaseInSensitive)
        Char = RtlpUpcaseUnicodeChar(Char);

    for (i = 0; i < MatchString->Length / sizeof(WCHAR); i++)
    {
        WCHAR OtherChar = MatchString->Buffer[i];
        if (CaseInSensitive)
            OtherChar = RtlpUpcaseUnicodeChar(OtherChar);

        if (Char == OtherChar)
            return TRUE;
    }

    return FALSE;
}

Referenced by RtlFindCharInUnicodeString().

RtlPrefixString()

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

Definition at line 875 of file unicode.c.

{
    PCHAR pc1;
    PCHAR pc2;
    ULONG NumChars;

    if (String2->Length < String1->Length)
        return FALSE;

    NumChars = String1->Length;
    pc1 = String1->Buffer;
    pc2 = String2->Buffer;

    if (pc1 && pc2)
    {
        if (CaseInsensitive)
        {
            while (NumChars--)
            {
                if (RtlUpperChar(*pc1++) != RtlUpperChar(*pc2++))
                    return FALSE;
            }
        }
        else
        {
            while (NumChars--)
            {
                if (*pc1++ != *pc2++)
                    return FALSE;
            }
        }

        return TRUE;
    }

    return FALSE;
}

RtlPrefixUnicodeString()

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

Definition at line 924 of file unicode.c.

{
    PWCHAR pc1;
    PWCHAR pc2;
    ULONG  NumChars;

    if (String2->Length < String1->Length)
        return FALSE;

    NumChars = String1->Length / sizeof(WCHAR);
    pc1 = String1->Buffer;
    pc2 = String2->Buffer;

    if (pc1 && pc2)
    {
        if (CaseInsensitive)
        {
            while (NumChars--)
            {
                if (RtlpUpcaseUnicodeChar(*pc1++) !=
                    RtlpUpcaseUnicodeChar(*pc2++))
                    return FALSE;
            }
        }
        else
        {
            while (NumChars--)
            {
                if (*pc1++ != *pc2++)
                    return FALSE;
            }
        }

        return TRUE;
    }

    return FALSE;
}

RtlStringFromGUID()

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

Definition at line 2128 of file unicode.c.

{
    /* Setup the string */
    GuidString->Length = 38 * sizeof(WCHAR);
    GuidString->MaximumLength = GuidString->Length + sizeof(UNICODE_NULL);
    GuidString->Buffer = RtlpAllocateStringMemory(GuidString->MaximumLength,
                                                  TAG_USTR);
    if (!GuidString->Buffer) return STATUS_NO_MEMORY;

    /* Now format the GUID */
    swprintf(GuidString->Buffer,
             L"{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
             Guid->Data1,
             Guid->Data2,
             Guid->Data3,
             Guid->Data4[0],
             Guid->Data4[1],
             Guid->Data4[2],
             Guid->Data4[3],
             Guid->Data4[4],
             Guid->Data4[5],
             Guid->Data4[6],
             Guid->Data4[7]);
    return STATUS_SUCCESS;
}

RtlUnicodeStringToAnsiString()

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

Definition at line 1102 of file unicode.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    NTSTATUS RealStatus;
    ULONG Length;
    ULONG Index;

    PAGED_CODE_RTL();

    ASSERT(!(UniSource->Length & 1));

    if (NlsMbCodePageTag == FALSE)
    {
        Length = (UniSource->Length + sizeof(WCHAR)) / sizeof(WCHAR);
    }
    else
    {
        Length = RtlxUnicodeStringToAnsiSize(UniSource);
    }

    if (Length > MAXUSHORT) return STATUS_INVALID_PARAMETER_2;

    AnsiDest->Length = (USHORT)Length - sizeof(CHAR);

    if (AllocateDestinationString)
    {
        AnsiDest->Buffer = RtlpAllocateStringMemory(Length, TAG_ASTR);
        AnsiDest->MaximumLength = (USHORT)Length;

        if (!AnsiDest->Buffer) return STATUS_NO_MEMORY;
    }
    else if (AnsiDest->Length >= AnsiDest->MaximumLength)
    {
        if (!AnsiDest->MaximumLength) return STATUS_BUFFER_OVERFLOW;

        Status = STATUS_BUFFER_OVERFLOW;
        AnsiDest->Length = AnsiDest->MaximumLength - 1;
    }

    RealStatus = RtlUnicodeToMultiByteN(AnsiDest->Buffer,
                                        AnsiDest->Length,
                                        &Index,
                                        UniSource->Buffer,
                                        UniSource->Length);

    if (!NT_SUCCESS(RealStatus) && AllocateDestinationString)
    {
        RtlpFreeStringMemory(AnsiDest->Buffer, TAG_ASTR);
        return RealStatus;
    }

    AnsiDest->Buffer[Index] = ANSI_NULL;
    return Status;
}

RtlUnicodeStringToCountedOemString()

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

Definition at line 1780 of file unicode.c.

{
    NTSTATUS Status;
    ULONG Length;
    ULONG Index;

    PAGED_CODE_RTL();

    /* Calculate size of the string */
    Length = RtlUnicodeStringToCountedOemSize(UniSource);

    /* If it's 0 then zero out dest string and return */
    if (!Length)
    {
        RtlZeroMemory(OemDest, sizeof(OEM_STRING));
        return STATUS_SUCCESS;
    }

    /* Check if length is a sane value */
    if (Length > MAXUSHORT) return STATUS_INVALID_PARAMETER_2;

    /* Store it in dest string */
    OemDest->Length = (USHORT)Length;

    /* If we're asked to alloc the string - do so */
    if (AllocateDestinationString)
    {
        OemDest->Buffer = RtlpAllocateStringMemory(Length, TAG_OSTR);
        OemDest->MaximumLength = (USHORT)Length;
        if (!OemDest->Buffer) return STATUS_NO_MEMORY;
    }
    else if (OemDest->Length > OemDest->MaximumLength)
    {
        return STATUS_BUFFER_OVERFLOW;
    }

    /* Do the conversion */
    Status = RtlUnicodeToOemN(OemDest->Buffer,
                              OemDest->Length,
                              &Index,
                              UniSource->Buffer,
                              UniSource->Length);

    /* Check for unmapped character */
    if (NT_SUCCESS(Status) && !RtlpDidUnicodeToOemWork(UniSource, OemDest))
        Status = STATUS_UNMAPPABLE_CHARACTER;

    if (!NT_SUCCESS(Status) && AllocateDestinationString)
    {
        /* Conversion failed, free dest string and return status code */
        RtlpFreeStringMemory(OemDest->Buffer, TAG_OSTR);
        OemDest->Buffer = NULL;
        return Status;
    }

    return Status;
}

Referenced by CdIs8dot3Name().

RtlUnicodeStringToInteger()

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

Definition at line 971 of file unicode.c.

{
    LPWSTR lpwstr = str->Buffer;
    USHORT CharsRemaining = str->Length / sizeof(WCHAR);
    WCHAR wchCurrent;
    int digit;
    ULONG RunningTotal = 0;
    char bMinus = 0;

    while (CharsRemaining >= 1 && *lpwstr <= ' ')
    {
        lpwstr++;
        CharsRemaining--;
    }

    if (CharsRemaining >= 1)
    {
        if (*lpwstr == '+')
        {
            lpwstr++;
            CharsRemaining--;
        }
        else if (*lpwstr == '-')
        {
            bMinus = 1;
            lpwstr++;
            CharsRemaining--;
        }
    }

    if (base == 0)
    {
        base = 10;

        if (CharsRemaining >= 2 && lpwstr[0] == '0')
        {
            if (lpwstr[1] == 'b')
            {
                lpwstr += 2;
                CharsRemaining -= 2;
                base = 2;
            }
            else if (lpwstr[1] == 'o')
            {
                lpwstr += 2;
                CharsRemaining -= 2;
                base = 8;
            }
            else if (lpwstr[1] == 'x')
            {
                lpwstr += 2;
                CharsRemaining -= 2;
                base = 16;
            }
        }
    }
    else if (base != 2 && base != 8 && base != 10 && base != 16)
    {
        return STATUS_INVALID_PARAMETER;
    }

    if (value == NULL)
    {
        return STATUS_ACCESS_VIOLATION;
    }

    while (CharsRemaining >= 1)
    {
        wchCurrent = *lpwstr;

        if (wchCurrent >= '0' && wchCurrent <= '9')
        {
            digit = wchCurrent - '0';
        }
        else if (wchCurrent >= 'A' && wchCurrent <= 'Z')
        {
            digit = wchCurrent - 'A' + 10;
        }
        else if (wchCurrent >= 'a' && wchCurrent <= 'z')
        {
            digit = wchCurrent - 'a' + 10;
        }
        else
        {
            digit = -1;
        }

        if (digit < 0 || (ULONG)digit >= base) break;

        RunningTotal = RunningTotal * base + digit;
        lpwstr++;
        CharsRemaining--;
    }

    *value = bMinus ? (0 - RunningTotal) : RunningTotal;
    return STATUS_SUCCESS;
}

RtlUnicodeStringToOemString()

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

Definition at line 1223 of file unicode.c.

{
    NTSTATUS Status;
    ULONG Length;
    ULONG Index;

    PAGED_CODE_RTL();

    Length = RtlUnicodeStringToOemSize(UniSource);

    if (Length > MAXUSHORT) return STATUS_INVALID_PARAMETER_2;

    OemDest->Length = (USHORT)Length - sizeof(CHAR);

    if (AllocateDestinationString)
    {
        OemDest->Buffer = RtlpAllocateStringMemory(Length, TAG_OSTR);
        OemDest->MaximumLength = (USHORT)Length;

        if (!OemDest->Buffer) return STATUS_NO_MEMORY;
    }
    else if (OemDest->Length >= OemDest->MaximumLength)
    {
        return STATUS_BUFFER_OVERFLOW;
    }

    Status = RtlUnicodeToOemN(OemDest->Buffer,
                              OemDest->Length,
                              &Index,
                              UniSource->Buffer,
                              UniSource->Length);

    if (!NT_SUCCESS(Status) && AllocateDestinationString)
    {
        RtlpFreeStringMemory(OemDest->Buffer, TAG_OSTR);
        OemDest->Buffer = NULL;
        return Status;
    }

    OemDest->Buffer[Index] = ANSI_NULL;
    return Status;
}

RtlUpcaseUnicodeString()

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

Definition at line 1903 of file unicode.c.

{
    ULONG i, j;

    PAGED_CODE_RTL();

    if (AllocateDestinationString)
    {
        UniDest->MaximumLength = UniSource->Length;
        UniDest->Buffer = RtlpAllocateStringMemory(UniDest->MaximumLength, TAG_USTR);
        if (UniDest->Buffer == NULL) return STATUS_NO_MEMORY;
    }
    else if (UniSource->Length > UniDest->MaximumLength)
    {
        return STATUS_BUFFER_OVERFLOW;
    }

    j = UniSource->Length / sizeof(WCHAR);

    for (i = 0; i < j; i++)
    {
        UniDest->Buffer[i] = RtlpUpcaseUnicodeChar(UniSource->Buffer[i]);
    }

    UniDest->Length = UniSource->Length;
    return STATUS_SUCCESS;
}

RtlUpcaseUnicodeStringToAnsiString()

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

Definition at line 1943 of file unicode.c.

{
    NTSTATUS Status;
    ULONG Length;
    ULONG Index;
    PAGED_CODE_RTL();

    Length = RtlUnicodeStringToAnsiSize(UniSource);
    if (Length > MAXUSHORT) return STATUS_INVALID_PARAMETER_2;

    AnsiDest->Length = (USHORT)Length - sizeof(CHAR);

    if (AllocateDestinationString)
    {
        AnsiDest->Buffer = RtlpAllocateStringMemory(Length, TAG_ASTR);
        AnsiDest->MaximumLength = (USHORT)Length;
        if (!AnsiDest->Buffer) return STATUS_NO_MEMORY;
    }
    else if (AnsiDest->Length >= AnsiDest->MaximumLength)
    {
        if (!AnsiDest->MaximumLength) return STATUS_BUFFER_OVERFLOW;
    }

    Status = RtlUpcaseUnicodeToMultiByteN(AnsiDest->Buffer,
                                          AnsiDest->Length,
                                          &Index,
                                          UniSource->Buffer,
                                          UniSource->Length);

    if (!NT_SUCCESS(Status) && AllocateDestinationString)
    {
        RtlpFreeStringMemory(AnsiDest->Buffer, TAG_ASTR);
        AnsiDest->Buffer = NULL;
        return Status;
    }

    AnsiDest->Buffer[Index] = ANSI_NULL;
    return Status;
}

RtlUpcaseUnicodeStringToCountedOemString()

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

Definition at line 1995 of file unicode.c.

{
    NTSTATUS Status;
    ULONG Length;
    ULONG Index;
    PAGED_CODE_RTL();

    Length = RtlUnicodeStringToCountedOemSize(UniSource);

    if (!Length)
    {
        RtlZeroMemory(OemDest, sizeof(OEM_STRING));
    }

    if (Length > MAXUSHORT) return STATUS_INVALID_PARAMETER_2;

    OemDest->Length = (USHORT)Length;

    if (AllocateDestinationString)
    {
        OemDest->Buffer = RtlpAllocateStringMemory(Length, TAG_OSTR);
        OemDest->MaximumLength = (USHORT)Length;
        if (!OemDest->Buffer) return STATUS_NO_MEMORY;
    }
    else if (OemDest->Length > OemDest->MaximumLength)
    {
        return STATUS_BUFFER_OVERFLOW;
    }

    Status = RtlUpcaseUnicodeToOemN(OemDest->Buffer,
                                    OemDest->Length,
                                    &Index,
                                    UniSource->Buffer,
                                    UniSource->Length);

    /* Check for unmapped characters */
    if (NT_SUCCESS(Status) && !RtlpDidUnicodeToOemWork(UniSource, OemDest))
        Status = STATUS_UNMAPPABLE_CHARACTER;

    if (!NT_SUCCESS(Status) && AllocateDestinationString)
    {
        RtlpFreeStringMemory(OemDest->Buffer, TAG_OSTR);
        OemDest->Buffer = NULL;
        return Status;
    }

    return Status;
}

RtlUpcaseUnicodeStringToOemString()

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

Definition at line 2055 of file unicode.c.

{
    NTSTATUS Status;
    ULONG Length;
    ULONG Index;
    PAGED_CODE_RTL();

    Length = RtlUnicodeStringToOemSize(UniSource);
    if (Length > MAXUSHORT) return STATUS_INVALID_PARAMETER_2;

    OemDest->Length = (USHORT)Length - sizeof(CHAR);

    if (AllocateDestinationString)
    {
        OemDest->Buffer = RtlpAllocateStringMemory(Length, TAG_OSTR);
        OemDest->MaximumLength = (USHORT)Length;
        if (!OemDest->Buffer) return STATUS_NO_MEMORY;
    }
    else if (OemDest->Length >= OemDest->MaximumLength)
    {
        return STATUS_BUFFER_OVERFLOW;
    }

    Status = RtlUpcaseUnicodeToOemN(OemDest->Buffer,
                                    OemDest->Length,
                                    &Index,
                                    UniSource->Buffer,
                                    UniSource->Length);

    /* Check for unmapped characters */
    if (NT_SUCCESS(Status) && !RtlpDidUnicodeToOemWork(UniSource, OemDest))
        Status = STATUS_UNMAPPABLE_CHARACTER;

    if (!NT_SUCCESS(Status) && AllocateDestinationString)
    {
        RtlpFreeStringMemory(OemDest->Buffer, TAG_OSTR);
        OemDest->Buffer = NULL;
        return Status;
    }

    OemDest->Buffer[Index] = ANSI_NULL;
    return Status;
}

Referenced by RtlEqualComputerName().

RtlUpperString()

VOID NTAPI RtlUpperString	(	PSTRING	DestinationString,
		const STRING *	SourceString
	)

Definition at line 2464 of file unicode.c.

{
    USHORT Length;
    PCHAR Src, Dest;

    Length = min(SourceString->Length,
                 DestinationString->MaximumLength);

    Src = SourceString->Buffer;
    Dest = DestinationString->Buffer;
    DestinationString->Length = Length;

    while (Length)
    {
        *Dest++ = RtlUpperChar(*Src++);
        Length--;
    }
}

RtlValidateUnicodeString()

NTSTATUS NTAPI RtlValidateUnicodeString	(	IN ULONG	Flags,
		IN PCUNICODE_STRING	UnicodeString
	)

Definition at line 2544 of file unicode.c.

{
    /* currently no flags are supported! */
    ASSERT(Flags == 0);

    if ((Flags == 0) &&
        ((UnicodeString == NULL) ||
         ((UnicodeString->Length != 0) &&
          (UnicodeString->Buffer != NULL) &&
          ((UnicodeString->Length % sizeof(WCHAR)) == 0) &&
          ((UnicodeString->MaximumLength % sizeof(WCHAR)) == 0) &&
          (UnicodeString->MaximumLength >= UnicodeString->Length))))
    {
        /* a NULL pointer as a unicode string is considered to be a valid unicode
           string! */
        return STATUS_SUCCESS;
    }
    else
    {
        return STATUS_INVALID_PARAMETER;
    }
}

RtlxAnsiStringToUnicodeSize()

ULONG NTAPI RtlxAnsiStringToUnicodeSize

(

IN PCANSI_STRING

AnsiString

)

Definition at line 156 of file unicode.c.

{
    ULONG Size;
    PAGED_CODE_RTL();

    /* Convert from Mb String to Unicode Size */
    RtlMultiByteToUnicodeSize(&Size,
                              AnsiString->Buffer,
                              AnsiString->Length);

    /* Return the size plus the null-char */
    return(Size + sizeof(WCHAR));
}

Referenced by RtlAnsiStringToUnicodeString().

RtlxOemStringToUnicodeSize()

ULONG NTAPI RtlxOemStringToUnicodeSize

(

IN PCOEM_STRING

OemString

)

Definition at line 2110 of file unicode.c.

{
    ULONG Size;

    /* Convert the Mb String to Unicode Size */
    RtlMultiByteToUnicodeSize(&Size,
                              OemString->Buffer,
                              OemString->Length);

    /* Return the size + null-char */
    return (Size + sizeof(WCHAR));
}

RtlxUnicodeStringToAnsiSize()

ULONG NTAPI RtlxUnicodeStringToAnsiSize

(

IN PCUNICODE_STRING

UnicodeString

)

Definition at line 2163 of file unicode.c.

{
    ULONG Size;
    PAGED_CODE_RTL();

    ASSERT(!(UnicodeString->Length & 1));

    /* Convert the Unicode String to Mb Size */
    RtlUnicodeToMultiByteSize(&Size,
                              UnicodeString->Buffer,
                              UnicodeString->Length);

    /* Return the size + null-char */
    return (Size + sizeof(CHAR));
}

Referenced by RtlUnicodeStringToAnsiString().

RtlxUnicodeStringToOemSize()

ULONG NTAPI RtlxUnicodeStringToOemSize

(

IN PCUNICODE_STRING

UnicodeString

)

Definition at line 1080 of file unicode.c.

{
    ULONG Size;

    /* Convert the Unicode String to Mb Size */
    RtlUnicodeToMultiByteSize(&Size,
                              UnicodeString->Buffer,
                              UnicodeString->Length);

    /* Return the size + the null char */
    return (Size + sizeof(CHAR));
}

Referenced by Ext2UnicodeToOEMSize(), FFSSetRenameInfo(), FFSv1AllocateFcb(), FFSv2AllocateFcb(), and RfsdUnicodeToOEMSize().

Variable Documentation

NlsLeadByteInfo

PUSHORT NlsLeadByteInfo

Definition at line 26 of file nls.c.

Referenced by RtlAnsiCharToUnicodeChar(), RtlIsTextUnicode(), RtlMultiByteToUnicodeN(), RtlMultiByteToUnicodeSize(), and RtlResetRtlTranslations().

NlsMbCodePageTag

BOOLEAN NlsMbCodePageTag

Definition at line 22 of file nls.c.

Referenced by RtlAnsiStringToUnicodeString(), RtlIsTextUnicode(), RtlMultiByteToUnicodeN(), RtlMultiByteToUnicodeSize(), RtlResetRtlTranslations(), RtlUnicodeStringToAnsiString(), RtlUnicodeToMultiByteN(), RtlUnicodeToMultiByteSize(), RtlUpcaseUnicodeToMultiByteN(), and RtlUpperChar().

NlsMbOemCodePageTag

BOOLEAN NlsMbOemCodePageTag

Definition at line 29 of file nls.c.

Referenced by RtlIsValidOemCharacter(), RtlOemToUnicodeN(), RtlpDidUnicodeToOemWork(), RtlResetRtlTranslations(), RtlUnicodeToOemN(), and RtlUpcaseUnicodeToOemN().

NlsOemDefaultChar

USHORT NlsOemDefaultChar

Definition at line 35 of file nls.c.

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

NlsOemLeadByteInfo

PUSHORT NlsOemLeadByteInfo

Definition at line 33 of file nls.c.

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

NlsOemToUnicodeTable

PWCHAR NlsOemToUnicodeTable

Definition at line 30 of file nls.c.

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

NlsUnicodeDefaultChar

USHORT NlsUnicodeDefaultChar

Definition at line 36 of file nls.c.

Referenced by RtlpDidUnicodeToOemWork(), and RtlResetRtlTranslations().

NlsUnicodeToMbOemTable

PUSHORT NlsUnicodeToMbOemTable

Definition at line 32 of file nls.c.

Referenced by RtlIsValidOemCharacter(), RtlResetRtlTranslations(), RtlUnicodeToOemN(), and RtlUpcaseUnicodeToOemN().

NlsUnicodeToOemTable

PCHAR NlsUnicodeToOemTable

Definition at line 31 of file nls.c.

Referenced by RtlIsValidOemCharacter(), RtlResetRtlTranslations(), RtlUnicodeToOemN(), and RtlUpcaseUnicodeToOemN().