UnicodeString基本操作(Ring3)

// 纯粹做个记录，微软源码  
 1 // Unicode_String_Ring3.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "Unicode_String_Ring3.h"

/*
所有带Ums_前缀的函数都是自己根据windows2000源码实现的

因为Ring3不能直接定义UnicodeString 
所以根据微软的源代码来实现

*/

int main()
{
    Test();
    return 0;
}

void Test()
{
    //初始化
    //StringInitTest();

    //拷贝操作
    //StringCopyTest();
    
    //字符串比较
    //StringCompareTest();
    
    //字符串变大写***
    StringToUpperTest();
    
    //字符串与整型相互转化
    //StringToIntegerTest();
    
    
    //ANSI_STRING字符串与UNICODE_STRING字符串相互转换
    //StringConverTest();
    //最后未释放内存，bug



    printf("Input AnyKey To Exit
");
    getchar();
}

//初始化
void StringInitTest()
{
    Sub_1();
    //Sub_2();
    //Sub_3();
}

void Sub_1()
{
    UNICODE_STRING v1;

    Ums_RtlInitUnicodeString(&v1, L"HelloWorld");

    printf("%Z
", &v1);



}
VOID
Ums_RtlInitUnicodeString(
    OUT PUNICODE_STRING DestinationString,
    IN PCWSTR SourceString OPTIONAL
    )
{
    USHORT Length = 0;
    DestinationString->Length = 0;
    DestinationString->Buffer = (PWSTR)SourceString;
    if (SourceString != NULL) 
    {
        while (*SourceString++) 
        {
            Length += sizeof(*SourceString);
        }

        DestinationString->Length = Length;

        DestinationString->MaximumLength = Length+(USHORT)sizeof(UNICODE_NULL);
    }
    else 
    {
        DestinationString->MaximumLength = 0;
    }
}
void Sub_2()
{
    UNICODE_STRING v1;
    WCHAR BufferData[] = L"HelloWorld";
    v1.Buffer = BufferData;
    v1.Length = wcslen(BufferData) * sizeof(WCHAR);
    v1.MaximumLength = (wcslen(BufferData) + 1) * sizeof(WCHAR);
    printf("%Z
", &v1);
}

void Sub_3()
{
    UNICODE_STRING v1;
    WCHAR BufferData[] = L"HelloWorld";

    v1.Length = wcslen(BufferData) * sizeof(WCHAR);
    v1.MaximumLength = (wcslen(BufferData) + 1) * sizeof(WCHAR);
    v1.Buffer = (WCHAR*)malloc(v1.MaximumLength);
    RtlZeroMemory(v1.Buffer, v1.MaximumLength);
    RtlCopyMemory(v1.Buffer, BufferData, v1.Length);

    printf("%Z
", &v1);
    if (v1.Buffer != NULL)
    {
        free(v1.Buffer);
        v1.Buffer = NULL;
        v1.Length = v1.MaximumLength = 0;
    }
}

//拷贝操作
void StringCopyTest()
{
    UNICODE_STRING SourceString;
    Ums_RtlInitUnicodeString(&SourceString, L"HelloWorld");

    UNICODE_STRING DestinationString = { 0 };
    DestinationString.Buffer = (PWSTR)malloc(BUFFER_SIZE);
    DestinationString.MaximumLength = BUFFER_SIZE;

    Ums_RtlCopyUnicodeString(&DestinationString, &SourceString);

    printf("SourceString:%wZ
", &SourceString);
    printf("DestinationString:%wZ
", &DestinationString);

    Ums_RtlFreeUnicodeString(&DestinationString);
}

VOID
Ums_RtlCopyUnicodeString(
    OUT PUNICODE_STRING DestinationString,
    IN PUNICODE_STRING SourceString OPTIONAL
    )
{
    UNALIGNED WCHAR *Source, *Dest;
    ULONG n;

    if (SourceString!=NULL) 
    {
        Dest = DestinationString->Buffer;
        Source = SourceString->Buffer;
        n = SourceString->Length;
        if ((USHORT)n > DestinationString->MaximumLength) 
        {
            n = DestinationString->MaximumLength;
        }

        DestinationString->Length = (USHORT)n;
        RtlCopyMemory(Dest, Source, n);
        if (DestinationString->Length < DestinationString->MaximumLength) 
        {
            Dest[n / sizeof(WCHAR)] = UNICODE_NULL;
        }

    } 
    else 
    {
        DestinationString->Length = 0;
    }

    return;
}
VOID
Ums_RtlFreeUnicodeString(
    IN OUT PUNICODE_STRING UnicodeString
    )
{
    if (UnicodeString->Buffer) 
    {
        //free(UnicodeString->Buffer);
        
        memset( UnicodeString, 0, sizeof( *UnicodeString ) );
    }
}




//字符串比较
void StringCompareTest()
{
    //初始化UnicodeString1
    UNICODE_STRING UnicodeString1;
    Ums_RtlInitUnicodeString(&UnicodeString1,L"HELLOWORLD");

    //初始化UnicodeString2
    UNICODE_STRING UnicodeString2;
    //Ums_RtlInitUnicodeString(&UnicodeString2, L"Hello");
    //Ums_RtlInitUnicodeString(&UnicodeString2, L"HELLOWORLD");
    Ums_RtlInitUnicodeString(&UnicodeString2, L"helloworld");

    if (Ums_RtlEqualUnicodeString(
        &UnicodeString1, 
        &UnicodeString2, 
        TRUE
        //If TRUE, 
        //case should be ignored when doing the comparison.
    )
        )
    {
        printf("UnicodeString1 and UnicodeString2 are equal
");
    }
    else
    {
        printf("UnicodeString1 and UnicodeString2 are NOT equal
");
    }
}
BOOLEAN
Ums_RtlEqualUnicodeString(
    IN const PUNICODE_STRING String1,
    IN const PUNICODE_STRING String2,
    IN BOOLEAN CaseInSensitive
    )
{
    UNALIGNED WCHAR *s1, *s2;
    USHORT n1, n2;
    WCHAR c1, c2;

    s1 = String1->Buffer;
    s2 = String2->Buffer;
    n1 = (USHORT )(String1->Length / sizeof(WCHAR));
    n2 = (USHORT )(String2->Length / sizeof(WCHAR));

    if ( n1 != n2 ) 
    {
        return FALSE;
    }

    if (CaseInSensitive) 
    {
        while ( n1 ) 
        {
            if ( *s1++ != *s2++ ) 
            {
                c1 = upcase(*(s1-1));
                c2 = upcase(*(s2-1));
                if (c1 != c2) 
                {
                    return( FALSE );
                }
            }
            n1--;
        }
    }
    else 
    {
        while ( n1 ) 
        {

            if (*s1++ != *s2++) 
            {
                return( FALSE );
            }

            n1--;
        }
    }
    return TRUE;
}





//字符串变大写
void StringToUpperTest()
{
    UNICODE_STRING SourceString;
    Ums_RtlInitUnicodeString(&SourceString, L"Hello World");

    UNICODE_STRING DestinationString;
    DestinationString.Buffer = (PWSTR)malloc(BUFFER_SIZE);
    DestinationString.MaximumLength = BUFFER_SIZE;
    
    //变化前
    printf("变化前:%wZ
", &SourceString);
    //变大写
    Ums_RtlUpcaseUnicodeString(
        &DestinationString, //DestinationString
        &SourceString, //SourceString
        FALSE//Specifies if RtlUpcaseUnicodeString is to allocate the buffer space for the DestinationString. 
             //If it does, the buffer must be deallocated by calling RtlFreeUnicodeString.
    );

    //变化后
    printf("变化后:%wZ
", &DestinationString);

    Ums_RtlFreeUnicodeString(&DestinationString);
}




BOOL
Ums_RtlUpcaseUnicodeString(
    OUT PUNICODE_STRING DestinationString,
    IN PCUNICODE_STRING SourceString,
    IN BOOLEAN AllocateDestinationString
    )
{
    ULONG Index;
    ULONG StopIndex;

    

    if ( AllocateDestinationString ) 
    {
        DestinationString->MaximumLength = SourceString->Length;
        //DestinationString->Buffer = (Ums_RtlAllocateStringRoutine)((ULONG)DestinationString->MaximumLength);
        
        DestinationString->Buffer = (PWSTR)malloc((ULONG)DestinationString->MaximumLength);

        if ( !DestinationString->Buffer ) 
        {
            return FALSE;
        }
    }
    else 
    {
        if ( SourceString->Length > DestinationString->MaximumLength ) 
        {
            return FALSE;
        }
    }

    StopIndex = ((ULONG)SourceString->Length) / sizeof( WCHAR );

    for (Index = 0; Index < StopIndex; Index++) 
    {
        DestinationString->Buffer[Index] = (WCHAR)NLS_UPCASE(SourceString->Buffer[Index]);
    }

    DestinationString->Length = SourceString->Length;

    return TRUE;
}


//字符串与整型相互转化
void StringToIntegerTest()
{
    //(1)字符串转换成数字
    UNICODE_STRING UnicodeString1;
    Ums_RtlInitUnicodeString(&UnicodeString1, L"-100");
    
    ULONG lNumber;
    NTSTATUS Status = 
        Ums_RtlUnicodeStringToInteger(//第二个参数Base
            &UnicodeString1, 
            //10,//-100是10进制 //输出-100
            //16,//-100是16进制  //输出-256
            8,   //-100是8进制 //输出-64
            &lNumber
        );

    if (NT_SUCCESS(Status))
    {
        printf("Conver to integer succussfully!
");
        printf("Result:%d
", lNumber);
    }
    else
    {
        printf("Conver to integer unsuccessfully!
");
    }
    //(2)数字转换成字符串
    UNICODE_STRING UnicodeString2 = { 0 };
    UnicodeString2.Buffer = (PWSTR)malloc(BUFFER_SIZE);
    UnicodeString2.MaximumLength = BUFFER_SIZE;

    Status = Ums_RtlIntegerToUnicodeString(//同上 第二参数是Base
        200, 
        //10, //输出200
        //8,  //输出310
        16,   //输出  C8
        &UnicodeString2
    );

    /*
    HEX C8
    DEC 200
    OCT 310
    
    */
    if (NT_SUCCESS(Status))
    {
        printf("Conver to string succussfully!
");
        printf("Result:%wZ
", &UnicodeString2);
    }
    else
    {
        printf("Conver to string unsuccessfully!
");
    }

    //销毁UnicodeString2
    //注意!!UnicodeString1不用销毁
    Ums_RtlFreeUnicodeString(&UnicodeString2);


}
BOOL
Ums_RtlUnicodeStringToInteger(
    IN PUNICODE_STRING String,
    IN ULONG Base OPTIONAL,
    OUT PULONG Value
)
{
    PCWSTR s;
    WCHAR c, Sign;
    ULONG nChars, Result, Digit, Shift;

    s = String->Buffer;
    nChars = String->Length / sizeof(WCHAR);
    while (nChars-- && (Sign = *s++) <= ' ') {
        if (!nChars) {
            Sign = UNICODE_NULL;
            break;
        }
    }

    c = Sign;
    if (c == L'-' || c == L'+') {
        if (nChars) {
            nChars--;
            c = *s++;
        }
        else {
            c = UNICODE_NULL;
        }
    }

    if (((ULONG_PTR)Base)!=NULL) {
        Base = 10;
        Shift = 0;
        if (c == L'0') {
            if (nChars) {
                nChars--;
                c = *s++;
                if (c == L'x') {
                    Base = 16;
                    Shift = 4;
                }
                else
                    if (c == L'o') {
                        Base = 8;
                        Shift = 3;
                    }
                    else
                        if (c == L'b') {
                            Base = 2;
                            Shift = 1;
                        }
                        else {
                            nChars++;
                            s--;
                        }
            }

            if (nChars) {
                nChars--;
                c = *s++;
            }
            else {
                c = UNICODE_NULL;
            }
        }
    }
    else {
        switch (Base) {
        case 16:    Shift = 4;  break;
        case  8:    Shift = 3;  break;
        case  2:    Shift = 1;  break;
        case 10:    Shift = 0;  break;
        default:    return(FALSE);
        }
    }

    Result = 0;
    while (c != UNICODE_NULL) {
        if (c >= L'0' && c <= L'9') {
            Digit = c - L'0';
        }
        else
            if (c >= L'A' && c <= L'F') {
                Digit = c - L'A' + 10;
            }
            else
                if (c >= L'a' && c <= L'f') {
                    Digit = c - L'a' + 10;
                }
                else {
                    break;
                }

                if (Digit >= Base) {
                    break;
                }

                if (Shift == 0) {
                    Result = (Base * Result) + Digit;
                }
                else {
                    Result = (Result << Shift) | Digit;
                }

                if (!nChars) {
                    break;
                }
                nChars--;
                c = *s++;
    }

    if (Sign == L'-') {
        Result = (ULONG)(-(LONG)Result);
    }

    __try 
    {
        *Value = Result;
    }
    __except(EXCEPTION_EXECUTE_HANDLER) {
        return(GetExceptionCode());
    }

    return(TRUE);
}

BOOL
Ums_RtlIntegerToUnicodeString(
    IN ULONG Value,
    IN ULONG Base OPTIONAL,
    IN OUT PUNICODE_STRING String
)
{
    BOOL IsOk;
    char ResultBuffer[16];
    ANSI_STRING AnsiString;

    IsOk = Ums_RtlIntegerToChar(Value, Base, sizeof(ResultBuffer), ResultBuffer);
    if (IsOk) 
    {
        AnsiString.Buffer = ResultBuffer;
        AnsiString.MaximumLength = sizeof(ResultBuffer);
        AnsiString.Length = (USHORT)strlen(ResultBuffer);
        IsOk = Ums_RtlAnsiStringToUnicodeString(String, &AnsiString, FALSE);
    }

    return(IsOk);
}

BOOL
Ums_RtlAnsiStringToUnicodeString(
    OUT PUNICODE_STRING DestinationString,
    IN PANSI_STRING SourceString,
    IN BOOLEAN AllocateDestinationString
)
{
    ULONG UnicodeLength;
    ULONG Index;
    NTSTATUS st;

    UnicodeLength = (SourceString->Length << 1) + sizeof(UNICODE_NULL);

    if (UnicodeLength > MAXUSHORT) {
        return FALSE;
    }

    DestinationString->Length = (USHORT)(UnicodeLength - sizeof(UNICODE_NULL));
    
    /*
    if (AllocateDestinationString) {
        return FALSE;
    }
    else {
        if (DestinationString->Length >= DestinationString->MaximumLength) {
            return FALSE;
        }
    }
    */
    //DestinationString->buffer没有申请内存 所以 我们这里仿造上一个函数的申请
    DestinationString->Buffer = (PWCHAR)malloc(UnicodeLength);

    Index = 0;
    while (Index < DestinationString->Length) 
    {
        DestinationString->Buffer[Index] = (WCHAR)SourceString->Buffer[Index];
        Index++;
    }
    DestinationString->Buffer[Index] = UNICODE_NULL;

    return TRUE;
}


BOOL
Ums_RtlIntegerToChar(
    IN ULONG Value,
    IN ULONG Base OPTIONAL,
    IN LONG OutputLength,
    OUT char* String
)
{
    CHAR Result[33], *s;
    ULONG Shift, Mask, Digit, Length;

    Shift = 0;
    switch (Base) {
    case 16:    Shift = 4;  break;
    case  8:    Shift = 3;  break;
    case  2:    Shift = 1;  break;

    case  0:    Base = 10;
    case 10:    Shift = 0;  break;
    default:    return(FALSE);
    }

    if (Shift != 0) {
        Mask = 0xF >> (4 - Shift);
    }

    s = &Result[32];
    *s = '';
    do {
        if (Shift != 0) {
            Digit = Value & Mask;
            Value >>= Shift;
        }
        else {
            Digit = Value % Base;
            Value = Value / Base;
        }

        *--s = RtlpIntegerChars[Digit];
    } while (Value != 0);

    Length = (ULONG)(&Result[32] - s);
    if (OutputLength < 0) {
        OutputLength = -OutputLength;
        while ((LONG)Length < OutputLength) {
            *--s = '0';
            Length++;
        }
    }

    if ((LONG)Length > OutputLength) 
    {
        return(FALSE);
    }
    else {
        __try {
            RtlMoveMemory(String, s, Length);

            if ((LONG)Length < OutputLength) {
                String[Length] = '';
            }
        }
        
        __except(EXCEPTION_EXECUTE_HANDLER) 
        {
            return(GetExceptionCode());
        }
        
        return(TRUE);
    }
}










//ANSI_STRING字符串与UNICODE_STRING字符串相互
void StringConverTest()
{
    //(1)将UNICODE_STRING字符串转换成ANSI_STRING字符串
    //初始化UnicodeString1
    UNICODE_STRING UnicodeString1;
    Ums_RtlInitUnicodeString(&UnicodeString1, L"HelloWorld");

    ANSI_STRING AnsiString1;
    NTSTATUS Status = Ums_RtlUnicodeStringToAnsiString(
        &AnsiString1, 
        &UnicodeString1, 
        TRUE
        //TRUE if this routine is to allocate the buffer space for the DestinationString. 
        //If it does, the buffer must be deallocated by calling RtlFreeAnsiString.
    );

    if (NT_SUCCESS(Status))
    {
        printf("Conver succussfully!
");
        //printf("Result:%Z
", &AnsiString1);
        //printf("Result:%Z
", AnsiString1.Buffer);
        printf("Result:%s
", AnsiString1.Buffer);
    }
    else
    {
        printf("Conver unsuccessfully!
");
    }

    //销毁AnsiString1
    Ums_RtlFreeAnsiString(&AnsiString1);

    /******************************************/

    //(2)将ANSI_STRING字符串转换成UNICODE_STRING字符串

    ANSI_STRING AnsiString2;
    Ums_RtlInitString(&AnsiString2, "HelloWorld");

    UNICODE_STRING UnicodeString2;
    Status = Ums_RtlAnsiStringToUnicodeString(
        &UnicodeString2, 
        &AnsiString2, 
        TRUE
        //Specifies if this routine should allocate the buffer space for the destination string. 
        //If it does, the caller must deallocate the buffer by calling RtlFreeUnicodeString.
        

    );

    if (NT_SUCCESS(Status))
    {
        printf("Conver succussfully!
");
        //printf("Result:%wZ
", &UnicodeString2);
        //printf("Result:%wZ
", UnicodeString2.Buffer);
        printf("Result:%S
", UnicodeString2.Buffer);
    }
    else
    {
        printf("Conver unsuccessfully!
");
    }

    //销毁UnicodeString2
    Ums_RtlFreeUnicodeString(&UnicodeString2);
}

VOID
Ums_RtlFreeAnsiString(
    IN OUT PANSI_STRING AnsiString
)
{
    if (AnsiString->Buffer) {
        free(AnsiString->Buffer);
        memset(AnsiString, 0, sizeof(*AnsiString));
    }
}
VOID
Ums_RtlInitString(
    OUT PSTRING DestinationString,
    IN char* SourceString OPTIONAL
    )
{
    DestinationString->Length = 0;
    DestinationString->Buffer = (PCHAR)SourceString;
    if ( SourceString !=NULL ) {
        while (*SourceString++) {
            DestinationString->Length++;
            }

        DestinationString->MaximumLength = (SHORT)(DestinationString->Length+1);
        }
    else {
        DestinationString->MaximumLength = 0;
        }
}

BOOL 
Ums_RtlUnicodeStringToAnsiString(
    OUT PANSI_STRING DestinationString,
    IN PUNICODE_STRING SourceString,
    IN BOOLEAN AllocateDestinationString
    )
{
    ULONG AnsiLength;
    ULONG Index;
    NTSTATUS st;
    BOOL ReturnStatus = TRUE;

    

    AnsiLength = Ums_RtlxUnicodeStringToAnsiSize(SourceString);
    if ( AnsiLength > MAXUSHORT ) {
        return FALSE;
        }

    DestinationString->Length = (USHORT)(AnsiLength - 1);
    if ( AllocateDestinationString ) 
    {
        DestinationString->MaximumLength = (USHORT)AnsiLength;
        //DestinationString->Buffer = (RtlAllocateStringRoutine)(AnsiLength);
        DestinationString->Buffer = (PCHAR)malloc(AnsiLength);

        
        if ( !DestinationString->Buffer ) {
            return FALSE;
            }
        }
    else {
        if ( DestinationString->Length >= DestinationString->MaximumLength ) {
            /*
             * Return STATUS_BUFFER_OVERFLOW, but translate as much as
             * will fit into the buffer first.  This is the expected
             * behavior for routines such as GetProfileStringA.
             * Set the length of the buffer to one less than the maximum
             * (so that the trail byte of a double byte char is not
             * overwritten by doing DestinationString->Buffer[Index] = '').
             * RtlUnicodeToMultiByteN is careful not to truncate a
             * multibyte character.
             */
            if (!DestinationString->MaximumLength) {
                return FALSE;
            }
            ReturnStatus = FALSE;
            DestinationString->Length = DestinationString->MaximumLength - 1;
            }
        }

    st = Ums_RtlUnicodeToMultiByteN(
             DestinationString->Buffer,
             DestinationString->Length,
             &Index,
             SourceString->Buffer,
             SourceString->Length
             );

    if (!NT_SUCCESS(st)) {
        if ( AllocateDestinationString ) {
            free(DestinationString->Buffer);
            DestinationString->Buffer = NULL;
        }

        return st;
    }

    DestinationString->Buffer[Index] = '';

    return ReturnStatus;
}

BOOL
Ums_RtlUnicodeToMultiByteN(
    OUT PCH MultiByteString,
    IN ULONG MaxBytesInMultiByteString,
    OUT PULONG BytesInMultiByteString OPTIONAL,
    IN PWCH UnicodeString,
    IN ULONG BytesInUnicodeString
)
{
    ULONG TmpCount;
    ULONG LoopCount;
    ULONG CharsInUnicodeString;
    UCHAR SbChar;
    WCHAR UnicodeChar;
    ULONG i;

    //
    // Convert Unicode byte count to character count. Byte count of
    // multibyte string is equivalent to character count.
    //
    CharsInUnicodeString = BytesInUnicodeString / sizeof(WCHAR);

    LoopCount = (CharsInUnicodeString < MaxBytesInMultiByteString) ?
        CharsInUnicodeString : MaxBytesInMultiByteString;

    if ((BytesInMultiByteString) != NULL)
        *BytesInMultiByteString = LoopCount;


    for (i = 0; i < LoopCount; i++) {
        MultiByteString[i] = (CHAR)UnicodeString[i];
    }

    return TRUE;

}
ULONG
Ums_RtlxUnicodeStringToAnsiSize(
    IN PUNICODE_STRING UnicodeString
)
{
    ULONG  cbMultiByteString;

    

    //
    // Get the size of the string - this call handles DBCS.
    //
    Ums_RtlUnicodeToMultiByteSize( &cbMultiByteString,
                               UnicodeString->Buffer,
                               UnicodeString->Length );

    //
    // Return the size in bytes.
    //
    return (cbMultiByteString + 1);
}
BOOL 
Ums_RtlUnicodeToMultiByteSize(
    OUT PULONG BytesInMultiByteString,
    IN PWCH UnicodeString,
    IN ULONG BytesInUnicodeString)
{
    ULONG cbMultiByte = 0;
    ULONG CharsInUnicodeString;

    /*
     * convert from bytes to chars for easier loop handling.
     */
    CharsInUnicodeString = BytesInUnicodeString / sizeof(WCHAR);

    if (NlsMbCodePageTag) {
        USHORT MbChar;

        while (CharsInUnicodeString--) {
            MbChar = NlsUnicodeToMbAnsiData[ *UnicodeString++ ];
            if (HIBYTE(MbChar) == 0) {
                cbMultiByte++ ;
            } else {
                cbMultiByte += 2;
            }
        }
        *BytesInMultiByteString = cbMultiByte;
    }
    else {
        *BytesInMultiByteString = CharsInUnicodeString;
    }

    return TRUE;
}

ULONG
Ums_RtlxAnsiStringToUnicodeSize(
    IN PANSI_STRING AnsiString
    )


{
    ULONG cbConverted;


    //
    // Get the size of the string - this call handles DBCS.
    //
    Ums_RtlMultiByteToUnicodeSize( &cbConverted ,
                               AnsiString->Buffer,
                               AnsiString->Length );

    //
    // Return the size in bytes.
    //
    return ( cbConverted + sizeof(UNICODE_NULL) );
}
BOOL 
Ums_RtlMultiByteToUnicodeSize(
    OUT PULONG BytesInUnicodeString,
    IN PCH MultiByteString,
    IN ULONG BytesInMultiByteString
)
{
    ULONG cbUnicode = 0;
    if (NlsMbCodePageTag) {
        //
        // The ACP is a multibyte code page.  Check each character
        // to see if it is a lead byte before doing the translation.
        //
        while (BytesInMultiByteString--) {
            if (NlsLeadByteInfo[*(PUCHAR)MultiByteString++]) {
                //
                // Lead byte - translate the trail byte using the table
                // that corresponds to this lead byte.  NOTE: make sure
                // we have a trail byte to convert.
                //
                if (BytesInMultiByteString == 0) {
                    //
                    // RtlMultibyteToUnicodeN() uses the unicode
                    // default character if the last multibyte
                    // character is a lead byte.
                    //
                    cbUnicode += sizeof(WCHAR);
                    break;
                } else {
                    BytesInMultiByteString--;
                    MultiByteString++;
                }
            }
            cbUnicode += sizeof(WCHAR);
        }
        *BytesInUnicodeString = cbUnicode;
    } else {
        //
        // The ACP is a single byte code page.
        //
        *BytesInUnicodeString = BytesInMultiByteString * sizeof(WCHAR);
    }

    return TRUE;
}

#pragma once
#include <windows.h>
#include <iostream>

using namespace std;

#define BUFFER_SIZE 0x400
#define DBCS_TABLE_SIZE 256
#define NT_SUCCESS(Status) (((NTSTATUS)(Status)) >= 0) 

//拷贝
#define upcase(C) 
(WCHAR )(((C) >= 'a' && (C) <= 'z' ? (C) - ('a' - 'A') : (C)))


//字符串变大写
#define LOBYTE(w)           ((UCHAR)((w)))
#define HIBYTE(w)           ((UCHAR)(((USHORT)((w)) >> 8) & 0xFF))
#define GET8(w)             ((ULONG)(((w) >> 8) & 0xff))
#define GETHI4(w)           ((ULONG)(((w) >> 4) & 0xf))
#define GETLO4(w)           ((ULONG)((w) & 0xf))
#define TRAVERSE844W(pTable, wch)                                               
    ( (pTable)[(pTable)[(pTable)[GET8((wch))] + GETHI4((wch))] + GETLO4((wch))] )

PUSHORT Nls844UnicodeUpcaseTable;
extern PUSHORT Nls844UnicodeUpcaseTable;

#define NLS_UPCASE(wch) (                                                   
    ((wch) < 'a' ?                                                          
        (wch)                                                               
    :                                                                       
        ((wch) <= 'z' ?                                                     
            (wch) - ('a'-'A')                                               
        :                                                                   
            ((WCHAR)((wch) + TRAVERSE844W(Nls844UnicodeUpcaseTable,(wch)))) 
        )                                                                   
    )                                                                       
)
#define MAXUSHORT   USHRT_MAX

typedef char *PSZ;

typedef struct _UNICODE_STRING
{
    USHORT Length;
    USHORT MaximumLength;
    PWCHAR Buffer;
}UNICODE_STRING, *PUNICODE_STRING;

typedef const UNICODE_STRING *PCUNICODE_STRING;

typedef struct _STRING {
    USHORT Length;
    USHORT MaximumLength;
#ifdef MIDL_PASS
    [size_is(MaximumLength), length_is(Length)]
#endif // MIDL_PASS
    _Field_size_bytes_part_opt_(MaximumLength, Length) PCHAR Buffer;
} STRING;
typedef STRING *PSTRING;
typedef STRING ANSI_STRING;
typedef PSTRING PANSI_STRING;


CHAR RtlpIntegerChars[] = { '0', '1', '2', '3', '4', '5', '6', '7',
                           '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };





BOOLEAN  NlsMbCodePageTag = FALSE;         // TRUE -> Multibyte ACP, FALSE -> Singlebyte ACP
USHORT   NlsLeadByteInfoTable[DBCS_TABLE_SIZE]; // Lead byte info. for ACP
PUSHORT  NlsLeadByteInfo = NlsLeadByteInfoTable;
PUSHORT  NlsUnicodeToMbAnsiData;           // Unicode to Multibyte Ansi CP translation table



void Test();

//初始化
void StringInitTest();

void Sub_1();
VOID
Ums_RtlInitUnicodeString(
    OUT PUNICODE_STRING DestinationString,
    IN PCWSTR SourceString OPTIONAL
);

void Sub_2();
void Sub_3();



//拷贝操作
void StringCopyTest();
VOID
Ums_RtlCopyUnicodeString(
    OUT PUNICODE_STRING DestinationString,
    IN PUNICODE_STRING SourceString OPTIONAL
);
VOID
Ums_RtlFreeUnicodeString(
    IN OUT PUNICODE_STRING UnicodeString
);



//字符串比较
void StringCompareTest();
BOOLEAN
Ums_RtlEqualUnicodeString(
    IN const PUNICODE_STRING String1,
    IN const PUNICODE_STRING String2,
    IN BOOLEAN CaseInSensitive
);



//字符串变大写
void StringToUpperTest();
BOOL
Ums_RtlUpcaseUnicodeString(
    OUT PUNICODE_STRING DestinationString,
    IN PCUNICODE_STRING SourceString,
    IN BOOLEAN AllocateDestinationString
);




//字符串与整型相互转化
void StringToIntegerTest();

BOOL
Ums_RtlUnicodeStringToInteger(
    IN PUNICODE_STRING String,
    IN ULONG Base OPTIONAL,
    OUT PULONG Value
);
BOOL
Ums_RtlIntegerToUnicodeString(
    IN ULONG Value,
    IN ULONG Base OPTIONAL,
    IN OUT PUNICODE_STRING String
);
BOOL
Ums_RtlIntegerToChar(
    IN ULONG Value,
    IN ULONG Base OPTIONAL,
    IN LONG OutputLength,
    OUT PSZ String
);
BOOL
Ums_RtlAnsiStringToUnicodeString(
    OUT PUNICODE_STRING DestinationString,
    IN PANSI_STRING SourceString,
    IN BOOLEAN AllocateDestinationString
);


//ANSI_STRING字符串与UNICODE_STRING字符串相互
void StringConverTest();

VOID
Ums_RtlFreeAnsiString(
    IN OUT PANSI_STRING AnsiString
);

VOID
Ums_RtlInitString(
    OUT PSTRING DestinationString,
    IN char* SourceString OPTIONAL
);
BOOL
Ums_RtlUnicodeStringToAnsiString(
    OUT PANSI_STRING DestinationString,
    IN PUNICODE_STRING SourceString,
    IN BOOLEAN AllocateDestinationString
);
ULONG
Ums_RtlxAnsiStringToUnicodeSize(
    IN PANSI_STRING AnsiString
);
BOOL
Ums_RtlMultiByteToUnicodeSize(
    OUT PULONG BytesInUnicodeString,
    IN PCH MultiByteString,
    IN ULONG BytesInMultiByteString
);
ULONG
Ums_RtlxUnicodeStringToAnsiSize(
    IN PUNICODE_STRING UnicodeString
);
BOOL
Ums_RtlUnicodeToMultiByteSize(
    OUT PULONG BytesInMultiByteString,
    IN PWCH UnicodeString,
    IN ULONG BytesInUnicodeString
);
BOOL
Ums_RtlUnicodeToMultiByteN(
    OUT PCH MultiByteString,
    IN ULONG MaxBytesInMultiByteString,
    OUT PULONG BytesInMultiByteString OPTIONAL,
    IN PWCH UnicodeString,
    IN ULONG BytesInUnicodeString
);