内核模式下的字符串操作

分类： WINDOWS

1）ASCII字符串和宽字符串   

在应用程序中使用两种字符：
a) char型字符串，负责记录ANSI字符集，它是指向一个char数组的指针，每个char型变量大小是一个字节，字符串是以0标志字符串结束的；
b) wchar_t型的宽字符串，负责描述unicode字符集，它是指向一个wchar_t数组的指针，wchar_t字符大小为两个字节，字符串以0标志字符串结束。   
例： 
ANSI字符构造如下：   char *str1 = "ASCE";   
UNICODE字符构造如下：wchar_t *str2 = L"ASCE";   

注：在构造字符串时使用关键字“L”，编译器会自动生成所需要的宽字符   
  
在驱动开发中，DDK将char和wchar_t替换成CHAR和WCHAR。

驱动程序中使用KdPrint宏打印ASCII字符串和宽字符串：   
例： 

CHAR *string1 = "ASCE";
KdPrint(("%s
", string1)); //注意是小写%s

WCHAR *string2 = L"ASCE";
KdPrint(("%S
", string2));

    
2）ANSI_STRING字符串与UNICODE_STRING字符串   
  
DDK不鼓励程序员使用C语言的字符串，主要是因为标准C字符串处理函数容易导致缓冲区溢出等错误。应该使用DDK自定义的字符串： 
这个结构对ASCII字符串进行封装：  

typedef struct _STRING {

  USHORT Length; //字符的长度，单位是字节


  USHORT MaximumLength; //整个字符串缓冲区的最大长度


  PCHAR Buffer; //缓冲区的指针


} ANSI_STRING, *PANSI_STRING;

标准C字符串中，如果缓冲区长度是N，则只能容纳N-1个字符的字符串，最后一个字节存储NULL；
而在STRING字符串中，缓冲区大小是MaximumLength，最大字符串长度可以是MaximumLength，而不是MaximumLength-1。   
  
    
  
DDK将宽字符串封装成UNICODE_STRING数据结构：     

typedef struct _UNICODE_STRING {

  USHORT Length; //字符的长度，单位是字节。如果是N个字符，那么Length等于N的2倍


  USHORT MaximumLength; //整个字符串缓冲区的最大长度，单位是字节


  PWSTR Buffer; //缓冲区的指针


} UNICODE_STRING, *PUNICODE_STRING;

与ANSI_STRING一样，UNICODE_STRING字符串不是以NULL为结束标志的。   
  
    
  
打印这两种字符串方法如下：   

ANSI_STRING ansiString;

//此处略去对ansiString的初始化

KdPrint(("%Z
", &ansiString)); //注意是%Z

UNICODE_STRING uniString;

//此处略去对uniString的初始化

KdPrint(("%wZ
", &uniString));

  
    
3）字符的初始化和销毁   
  
ANSI_STRING字符串和UNICODE_STRING字符串使用前需要进行初始化，有两种方法构造这个数据结构：   
  
(1)使用DDK提供的函数：   

初始化ANSI_STRING字符串：

VOID RtlInitAnsiString(

  __out PANSI_STRING DestinationString, //要初始化的ANSI_STRING字符串


  __in_opt PCSZ SourceString //字符串的内容


);

初始化UNICODE_STRING字符串：

VOID RtlInitUnicodeString(

  __out PUNICODE_STRING DestinationString, //要初始化的UNICODE_STRING字符串


  __in_opt PCWSTR SourceString //字符串的内容


);

这种初始化的优点是操作简单，用完后不用清理内存。但有一个问题，就是如果修改SourceString，同时会导致DestinationString字符发生变化：

ANSI_STRING ansiString;

CHAR *string = "asce";

//初始化ANSI_STRING字符串


RtlInitAnsiString(&ansiString, string);

KdPrint(("ansiString: %Z
", &ansiString));

//改变string


string[0] = 'a';

string[1] = 's';

string[2] = 'c';

string[3] = 'e';

//改变string的同时ansiString也改变了


KdPrint(("ansiString: %Z
", &ansiString));

  
  
(2)程序员自己申请内存，并初始化内存，当不用字符串时，需要回收字符串占用的内存：   
  

#define BUFFER_SIZE 1024

UNICODE_STRING UnicodeString = {0};

//设置缓冲区大小


UnicodeString.MaximumLength = BUFFER_SIZE;

//分配内存


UnicodeString.Buffer = (PWSTR)ExAllocatePool(PagedPool, BUFFER_SIZE);

WCHAR *wideString = L"ASCE";



//设置字符串长度，因为是宽字符，所以是字符长度的倍


UnicodeString.Length = 2*wcslen(wideString);

//保证缓冲区足够大，否则程序终止


ASSERT(UnicodeString.MaximumLength >= UnicodeString.Length);

//内存复制


RtlCopyString(UnicodeString.Buffer, wideString, UnicodeString.Length);



KdPrint(("UnicodeString: %wZ
", &UnicodeString));



//清理内存


ExFreePool(UnicodeString.Buffer);

UnicodeString.Buffer = NULL;

UnicodeString.Length = UnicodeString.MaximumLength = 0;

对于最后一步清理内存，DDK给出了简化函数，分别是RtlFreeAnsiString和RtlFreeUnicodeString，这两个函数内部调用了ExFreePool去回收内存的。

  
4）字符串复制   
  
DDK提供针对ANSI_STRING字符串和UNICODE_STRING字符串的复制字符串函数：   
  

VOID RtlCopyString(

  __out PSTRING DestinationString, //目的字符串


  __in_opt const STRING *SourceString //源字符串


);

VOID RtlCopyUnicodeString(

  __inout PUNICODE_STRING DestinationString, //目的字符串


  __in_opt PCUNICODE_STRING SourceString //源字符串


);

  
下面代码说明了RtlCopyUnicodeString函数的使用：   
  

#define BUFFER_SIZE 1024

//初始化UnicodeString1


UNICODE_STRING UnicodeString1;

RtlInitUnicodeString(&UnicodeString1, L"ASCE");



//初始化UnicodeString2


UNICODE_STRING UnicodeString2 = {0};

UnicodeString2.Buffer = (PWSTR)ExAllocatePool(PagedPool, BUFFER_SIZE);

UnicodeString2.MaximumLength = BUFFER_SIZE;



//将初始化UnicodeString1复制到UnicodeString2


RtlCopyUnicodeString(&UnicodeString2, &UnicodeString1);



//分别显示UnicodeString1和UnicodeString2


KdPrint(("UnicodeString1: %wZ
", &UnicodeString1));

KdPrint(("UnicodeString2: %wZ
", &UnicodeString2));



//销毁UnicodeString2，注意：UnicodeString1不用销毁


RtlFreeUnicodeString(&UnicodeString2);

  
5）字符串比较   
  
DDK提供了对ANSI_STRING字符串和UNICODE_STRING字符串的相关比较函数：   
  

LONG RtlCompareString(

  __in const STRING *String1, //要比较的第一个字符串


  __in const STRING *String2, //要比较的第二个字符串


  __in BOOLEAN CaseInSensitive //是否对大小写敏感


);

LONG RtlCompareUnicodeString(

  __in PCUNICODE_STRING String1, //要比较的第一个字符串


  __in PCUNICODE_STRING String2, //要比较的第二个字符串


  __in BOOLEAN CaseInSensitive //是否对大小写敏感


);

  
DDK同时提供了RtlEqualString和RtlEqualUnicodeString函数，返回为非零代表相等，零代表不相等：   
  

BOOLEAN RtlEqualString(

  __in const STRING *String1,

  __in const STRING *String2,

  __in BOOLEAN CaseInSensitive

);

BOOLEAN RtlEqualUnicodeString(

  __in PCUNICODE_STRING String1,

  __in PCUNICODE_STRING String2,

  __in BOOLEAN CaseInSensitive

);

  
函数实例：   
  

//初始化UnicodeString1


UNICODE_STRING UnicodeString1;

RtlInitUnicodeString(&UnicodeString1, L"ASCE");



//初始化UnicodeString2


UNICODE_STRING UnicodeString2;

RtlnitUnicodeString(&UnicodeString2, L"ASCE BOY");



//判断字符串是否相等


if(RtlEqualUnicodeString(&UnicodeString1, &UnicodeString2, TRUE))

{

         KdPrint(("UnicodeString1 and UnicodeString2 are equal
"));

}

else

{

         KdPrint(("UnicodeString1 and UnicodeString2 are not euqal
"));

}

  
6）字符串转化成大写   
  
DDK提供的将ANSI_STRING字符串和UNICODE_STRING字符串转换成大写的函数如下：   
  
VOID RtlUpperString(   
  
  __inout  PSTRING DestinationString, //目的字符串   
  
  __in     const STRING *SourceString //源字符串   
  
);   
  
NTSTATUS RtlUpcaseUnicodeString(   
  
  __inout  PUNICODE_STRING DestinationString, //目的字符串   
  
  __in     PCUNICODE_STRING SourceString, //源字符串   
  
  __in     BOOLEAN AllocateDestinationString //是否为目的字符串分配内存，   
  
//目的字符串和源字符串可以是同一个字符串   
  
);   
  
实例代码：   
  
//初始化UnicodeString1   
  
UNICODE_STRING UnicodeString;   
  
RtlInitUnicodeString(&UnicodeString, L"ASCE BOY");   
  
//变化前   
  
KdPrint(("UnicodeString: %wZ ", &UnicodeString));   
  
//转化成大写   
  
RtlUpcaseUnicodeString(&UnicodeString, &UnicodeString, FALSE);   
  
//变化后   
  
KdPrint(("UnicodeString: %wZ ", &UnicodeString));   
  
    
  
7）字符串与整型数字相互转换   
  
将UNICODE_STRING字符串转换成整数：   
  
NTSTATUS RtlUnicodeStringToInteger(   
  
  __in      PCUNICODE_STRING String, //需要转换的字符串   
  
  __in_opt  ULONG Base, //转换的数的进制(如2、8、10、16)   
  
  __out     PULONG Value //需要转换的数字   
  
);   
  
    
  
将整数转换成UNICODE_STRING字符串：   
  
NTSTATUS RtlIntegerToUnicodeString(   
  
  __in      ULONG Value, //需要转换的数字   
  
  __in_opt  ULONG Base, //转换的数的进制(2、8、10、16)   
  
  __inout   PUNICODE_STRING String //需要转换的字符串   
  
);    
  
实例代码如下：   
  
#define BUFFER_SIZE 1024   
  
//字符串转换成数字   
  
UNICODE_STRING UnicodeString;   
  
RtlInitUnicodeString(&UnicodeString, L"-100");   
  
ULONG lNumber;   
  
    
  
NTSTATUS nStatus = RtlUnicodeStringToInteger(&UnicodeString, 10, &lNumber);   
  
if(NT_SUCCESS(nStatus))   
  
{   
  
         KdPrint(("Conver to integer successfully "));   
  
         KdPrint(("Result : %d ", lNumber));   
  
}   
  
else  
  
{   
  
         KdPrint(("Conver to integer failed "));   
  
}   
  
    
  
//将数字转换成字符串   
  
UNICODE_STRING UnicodeStringSec = {0};   
  
UnicodeStringSec.Buffer = (PWSTR)ExAllocatePool(PagedPool, BUFFER_SIZE);   
  
UnicodeStringSec.MaximumLength = BUFFER_SIZE;   
  
nStatus = RtlIntegerToUnicodeString(200, 10, &UnicodeStringSec);   
  
    
  
if(NT_SUCCESS(nStatus))   
  
{   
  
         KdPrint(("Cover to string successfully "));   
  
         KdPrint(("Result : %wZ ", &UnicodeStringSec));   
  
}   
  
else  
  
{   
  
         KdPrint(("Conver to string failed "));   
  
}   
  
    
  
//销毁UnicodeStringSec，注意：UnicodeString不用销毁   
  
RtlFreeUnicodeString(&UnicodeStringSec);   
  
    
  
8）ANSI_STRING字符串与UNICODE_STRING字符串的转换   
  
将UNICODE_STRING字符串转换成ANSI_STRING字符串：   
  
NTSTATUS RtlUnicodeStringToAnsiString(   
  
  __inout  PANSI_STRING DestinationString, //需要被转换的字符串   
  
  __in     PCUNICODE_STRING SourceString, //需要转换的源字符串   
  
  __in     BOOLEAN AllocateDestinationString //是否需要对被转换字符串分配内存   
  
);   
  
将ANSI_STRING字符串转换成UNICODE_STRING字符串：   
  
NTSTATUS RtlAnsiStringToUnicodeString(   
  
  __inout  PUNICODE_STRING DestinationString, //需要被转换的字符串   
  
  __in     PCANSI_STRING SourceString, //需要转换的源字符串   
  
  __in     BOOLEAN AllocateDestinationString //是否需要对被转换字符串分配内存   
  
);   
  
实例代码如下：   
  
//将UNICODE_STRING字符串转换成ANSI_STRING字符串   
  
UNICODE_STRING UnicodeString;   
  
RtlInitUnicodeString(&UnicodeString, L"ASCE BOY");   
  
    
  
ANSI_STRING AnsiString;   
  
NTSTATUS nStatus = RtlUnicodeStringToAnsiString(&AnsiString,    
  
                                                                                                                         &UnicodeString, TRUE);   
  
if(NT_SUCCESS(nStatus))   
  
{   
  
         KdPrint(("Conver successfully "));   
  
         KdPrint(("Result:%Z ", &AnsiString));   
  
}   
  
else  
  
{   
  
         KdPrint(("Conver failed "));   
  
}   
  
//销毁AnsiString   
  
RtlFreeAnsiString(&AnsiString);   
  
    
  
//将ANSI_STRING字符串转换成UNICODE_STRING字符串   
  
ANSI_STRING AnsiStringSec;   
  
RtlInitString(&AnsiStringSec, "ASCE BOY");   
  
    
  
UNICODE_STRING UnicodeStringSec;   
  
nStatus = RtlAnsiStringToUnicodeString(&UnicodeStringSec,   
  
                                     &AnsiStringSec, TRUE);   
  
if(NT_SUCCESS(nStatus))   
  
{   
  
         KdPrint(("Conver successfully "));   
  
         KdPrint(("Result: %wZ ", &UnicodeStringSec));   
  
}   
  
else  
  
{   
  
         KdPrint(("Conver failed "));   
  
}   
  
    
  
//销毁UnicodeStringSec   
  
RtlFreeUnicodeString(&UnicodeStringSec);