内核模式下的字符串操作

来源：互联网发布：网络直播的发展历程编辑：程序博客网时间：2024/04/29 15:12

原文转载自：http://blog.chinaunix.net/uid-24504987-id-153713.html，感谢作者。

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\n", string1)); //注意是小写%s 

WCHAR *string2 = L"ASCE"; 
KdPrint(("%S\n", 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\n", &ansiString)); //注意是%Z 

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

KdPrint(("%wZ\n", &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\n", &ansiString)); 
  
//改变string 

string[0] = 'a'; 
  
string[1] = 's'; 
  
string[2] = 'c'; 
  
string[3] = 'e'; 
  
//改变string的同时ansiString也改变了 

KdPrint(("ansiString: %Z\n", &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\n", &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\n", &UnicodeString1)); 
  
KdPrint(("UnicodeString2: %wZ\n", &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\n")); 
  
} 
  
else 
  
{ 
  
         KdPrint(("UnicodeString1 and UnicodeString2 are not euqal\n")); 
  
}

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\n", &UnicodeString));

//转化成大写

RtlUpcaseUnicodeString(&UnicodeString, &UnicodeString, FALSE);

//变化后

KdPrint(("UnicodeString: %wZ\n", &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\n"));

         KdPrint(("Result : %d\n", lNumber));

}

else

{

         KdPrint(("Conver to integer failed\n"));

}



//将数字转换成字符串

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\n"));

         KdPrint(("Result : %wZ\n", &UnicodeStringSec));

}

else

{

         KdPrint(("Conver to string failed\n"));

}



//销毁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\n"));

         KdPrint(("Result:%Z\n", &AnsiString));

}

else

{

         KdPrint(("Conver failed\n"));

}

//销毁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\n"));

         KdPrint(("Result: %wZ\n", &UnicodeStringSec));

}

else

{

         KdPrint(("Conver failed\n"));

}



//销毁UnicodeStringSec

RtlFreeUnicodeString(&UnicodeStringSec);

0 0