Chinaunix首页 | 论坛 | 博客

Linkin\'s notehaozhou2008.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

haozhou2008

  • 博客访问： 433209
  • 博文数量： 72
  • 博客积分： 1583
  • 博客等级： 上尉
  • 技术积分： 775
  • 用 户 组： 普通用户
  • 注册时间： 2010-09-23 09:36
文章分类

全部博文（72）

文章存档

2011年（72）

我的朋友
最近访客
推荐博文
相关博文
内核模式下的字符串操作

分类： WINDOWS

2011-03-04 13:56:11

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字符串和宽字符串：   
例： 
  1. CHAR *string1 = "ASCE";
  2. KdPrint(("%s\n", string1)); //注意是小写%s

  4. WCHAR *string2 = L"ASCE";
  5. KdPrint(("%S\n", string2));
   
2）ANSI_STRING字符串与UNICODE_STRING字符串  
 
DDK不鼓励程序员使用C语言的字符串，主要是因为标准C字符串处理函数容易导致缓冲区溢出等错误。应该使用DDK自定义的字符串： 
这个结构对ASCII字符串进行封装：  
  1. typedef struct _STRING {
  2.   
  3.   USHORT Length; //字符的长度，单位是字节

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

  8.   
  9.   PCHAR Buffer; //缓冲区的指针

  11.   
  12. } ANSI_STRING, *PANSI_STRING;
标准C字符串中，如果缓冲区长度是N，则只能容纳N-1个字符的字符串，最后一个字节存储NULL；
而在STRING字符串中，缓冲区大小是MaximumLength，最大字符串长度可以是MaximumLength，而不是MaximumLength-1。   
  
    
 
DDK将宽字符串封装成UNICODE_STRING数据结构：     
  1. typedef struct _UNICODE_STRING {
  2.   
  3.   USHORT Length; //字符的长度，单位是字节。如果是N个字符，那么Length等于N的2倍

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

  8.   
  9.   PWSTR Buffer; //缓冲区的指针

  11.   
  12. } UNICODE_STRING, *PUNICODE_STRING;
与ANSI_STRING一样，UNICODE_STRING字符串不是以NULL为结束标志的。  
 
   
 
打印这两种字符串方法如下：   
  1. ANSI_STRING ansiString;
  3. //此处略去对ansiString的初始化

  5. KdPrint(("%Z\n", &ansiString)); //注意是%Z

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

  11. KdPrint(("%wZ\n", &uniString));
  
    
3）字符的初始化和销毁  
 
ANSI_STRING字符串和UNICODE_STRING字符串使用前需要进行初始化，有两种方法构造这个数据结构：  
 
(1)使用DDK提供的函数：   
  1. 初始化ANSI_STRING字符串：
  2.   
  3. VOID RtlInitAnsiString(
  4.   
  5.   __out PANSI_STRING DestinationString, //要初始化的ANSI_STRING字符串

  7.   
  8.   __in_opt PCSZ SourceString //字符串的内容

  10.   
  11. );
  12.   
  13. 初始化UNICODE_STRING字符串：
  14.   
  15. VOID RtlInitUnicodeString(
  16.   
  17.   __out PUNICODE_STRING DestinationString, //要初始化的UNICODE_STRING字符串

  19.   
  20.   __in_opt PCWSTR SourceString //字符串的内容

  22.   
  23. );
  24.   
  25. 这种初始化的优点是操作简单，用完后不用清理内存。但有一个问题，就是如果修改SourceString，同时会导致DestinationString字符发生变化：
  26.   
  27. ANSI_STRING ansiString;
  28.   
  29. CHAR *string = "asce";
  30.   
  31. //初始化ANSI_STRING字符串

  33.   
  34. RtlInitAnsiString(&ansiString, string);
  35.   
  36. KdPrint(("ansiString: %Z\n", &ansiString));
  37.   
  38. //改变string

  40.   
  41. string[0] = 'a';
  42.   
  43. string[1] = 's';
  44.   
  45. string[2] = 'c';
  46.   
  47. string[3] = 'e';
  48.   
  49. //改变string的同时ansiString也改变了

  51.   
  52. KdPrint(("ansiString: %Z\n", &ansiString));
  
  
(2)程序员自己申请内存，并初始化内存，当不用字符串时，需要回收字符串占用的内存：   
  
  1. #define BUFFER_SIZE 1024
  2.   
  3. UNICODE_STRING UnicodeString = {0};
  4.   
  5. //设置缓冲区大小

  7.   
  8. UnicodeString.MaximumLength = BUFFER_SIZE;
  9.   
  10. //分配内存

  12.   
  13. UnicodeString.Buffer = (PWSTR)ExAllocatePool(PagedPool, BUFFER_SIZE);
  14.   
  15. WCHAR *wideString = L"ASCE";
  16.   
  17.     
  18.   
  19. //设置字符串长度，因为是宽字符，所以是字符长度的倍

  21.   
  22. UnicodeString.Length = 2*wcslen(wideString);
  23.   
  24. //保证缓冲区足够大，否则程序终止

  26.   
  27. ASSERT(UnicodeString.MaximumLength >= UnicodeString.Length);
  28.   
  29. //内存复制

  31.   
  32. RtlCopyString(UnicodeString.Buffer, wideString, UnicodeString.Length);
  33.   
  34.     
  35.   
  36. KdPrint(("UnicodeString: %wZ\n", &UnicodeString));
  37.   
  38.     
  39.   
  40. //清理内存

  42.   
  43. ExFreePool(UnicodeString.Buffer);
  44.   
  45. UnicodeString.Buffer = NULL;
  46.   
  47. UnicodeString.Length = UnicodeString.MaximumLength = 0;
  48.   
  49. 对于最后一步清理内存，DDK给出了简化函数，分别是RtlFreeAnsiString和RtlFreeUnicodeString，这两个函数内部调用了ExFreePool去回收内存的。
  
4）字符串复制  
 
DDK提供针对ANSI_STRING字符串和UNICODE_STRING字符串的复制字符串函数：   
  
  1. VOID RtlCopyString(
  2.   
  3.   __out PSTRING DestinationString, //目的字符串

  5.   
  6.   __in_opt const STRING *SourceString //源字符串

  8.   
  9. );
  10.   
  11. VOID RtlCopyUnicodeString(
  12.   
  13.   __inout PUNICODE_STRING DestinationString, //目的字符串

  15.   
  16.   __in_opt PCUNICODE_STRING SourceString //源字符串

  18.   
  19. );
 
下面代码说明了RtlCopyUnicodeString函数的使用：   
  
  1. #define BUFFER_SIZE 1024
  2.   
  3. //初始化UnicodeString1

  5.   
  6. UNICODE_STRING UnicodeString1;
  7.   
  8. RtlInitUnicodeString(&UnicodeString1, L"ASCE");
  9.   
  10.     
  11.   
  12. //初始化UnicodeString2

  14.   
  15. UNICODE_STRING UnicodeString2 = {0};
  16.   
  17. UnicodeString2.Buffer = (PWSTR)ExAllocatePool(PagedPool, BUFFER_SIZE);
  18.   
  19. UnicodeString2.MaximumLength = BUFFER_SIZE;
  20.   
  21.     
  22.   
  23. //将初始化UnicodeString1复制到UnicodeString2

  25.   
  26. RtlCopyUnicodeString(&UnicodeString2, &UnicodeString1);
  27.   
  28.     
  29.   
  30. //分别显示UnicodeString1和UnicodeString2

  32.   
  33. KdPrint(("UnicodeString1: %wZ\n", &UnicodeString1));
  34.   
  35. KdPrint(("UnicodeString2: %wZ\n", &UnicodeString2));
  36.   
  37.     
  38.   
  39. //销毁UnicodeString2，注意：UnicodeString1不用销毁

  41.   
  42. RtlFreeUnicodeString(&UnicodeString2);
  
5）字符串比较  
 
DDK提供了对ANSI_STRING字符串和UNICODE_STRING字符串的相关比较函数：   
  
  1. LONG RtlCompareString(
  2.   
  3.   __in const STRING *String1, //要比较的第一个字符串

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

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

  11.   
  12. );
  13.   
  14. LONG RtlCompareUnicodeString(
  15.   
  16.   __in PCUNICODE_STRING String1, //要比较的第一个字符串

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

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

  24.   
  25. );
  
DDK同时提供了RtlEqualString和RtlEqualUnicodeString函数，返回为非零代表相等，零代表不相等：   
  
  1. BOOLEAN RtlEqualString(
  2.   
  3.   __in const STRING *String1,
  4.   
  5.   __in const STRING *String2,
  6.   
  7.   __in BOOLEAN CaseInSensitive
  8.   
  9. );
  10.   
  11. BOOLEAN RtlEqualUnicodeString(
  12.   
  13.   __in PCUNICODE_STRING String1,
  14.   
  15.   __in PCUNICODE_STRING String2,
  16.   
  17.   __in BOOLEAN CaseInSensitive
  18.   
  19. );
  
函数实例：   
  
  1. //初始化UnicodeString1

  3.   
  4. UNICODE_STRING UnicodeString1;
  5.   
  6. RtlInitUnicodeString(&UnicodeString1, L"ASCE");
  7.   
  8.     
  9.   
  10. //初始化UnicodeString2

  12.   
  13. UNICODE_STRING UnicodeString2;
  14.   
  15. RtlnitUnicodeString(&UnicodeString2, L"ASCE BOY");
  16.   
  17.     
  18.   
  19. //判断字符串是否相等

  21.   
  22. if(RtlEqualUnicodeString(&UnicodeString1, &UnicodeString2, TRUE))
  23.   
  24. {
  25.   
  26.          KdPrint(("UnicodeString1 and UnicodeString2 are equal\n"));
  27.   
  28. }
  29.   
  30. else
  31.   
  32. {
  33.   
  34.          KdPrint(("UnicodeString1 and UnicodeString2 are not euqal\n"));
  35.   
  36. }
 
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);  

 
阅读(10220) | 评论(0) | 转发(0) |
0

上一篇：寒江独钓之串口的过滤运行

下一篇：VC 6.0工程配置

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6