使用NDIS驱动监测以太网络活动

转载自： http://blog.csdn.net/ddtpower/article/details/656687

 

本论文提供了NDIS的基本的理解，应用程序如何与驱动程序交互，发挥驱动程序最佳性能。本论文也说明了使用例子驱动（PACKET.SYS）监测以太网的应用程序。本论文不是帮助程序员开发网络驱动而是帮助他使用这样的驱动。

 

引言

       从计算机被发明以来，对大多数编程人员来说，编写设备驱动都是令人着迷的。开发驱动是为了满足特定应用的需要。这个目的导致大量不同种类的驱动被开发出来，例如打印机驱动，文件系统驱动等。此外，特定的应用与特定种类的驱动相对应。随着Internet的到来，编写网络驱动成为驱动开发的核心。 为帮助开发网络设备驱动，微软为Windows NT操作系统开发了网络设备接口规范（NDIS）库。

1、简介

1、1 什么是设备驱动

设备驱动是操作系统和输入输出设备间的粘合剂。驱动负责将操作系统的请求传输，转化为特定物理设备控制器能够理解的命令。

1、2 什么是网络接口卡

       网络接口卡（NIC）是一个物理设备，类似于网关，通过它，网络中的任何设备都可以发送和接收数据帧。不同网络中，网络接口卡的名称是不同的。例如，以太网中称为以太网接口卡，令牌环网中称为令牌环网接口卡，等等。

 

 

1、3 什么是网络驱动接口规范（NDIS）

       网络驱动接口规范描述了一个接口，通过这个接口，一个或多个NIC驱动可以与一个或多个覆盖在其上的 协议驱动和操作系统通信。NDIS为网络驱动开发提供了完整的抽象。对所有外部功能来说，NIC驱动都依赖于NDIS，这些功能包括 与协议驱动的通信，注册，截获NIC硬件中断，与下层的NIC的通信。

1、4 为什么需要NDIS

       NDIS库（NDIS.SYS）为NIC驱动的编写提供了完整的抽象接口。库输出所有可以在NIC驱动开发中使用的NT内核模式函数。这个库负责响应所有下层NIC驱动特定的任务，保持绑定和状态信息。

2、特点与使用

2、1基本特征

l        单NIC驱动

l        NDIS库

l        均衡处理器支持

l        多协议驱动支持

l        管理

l        发送类型

l        操作标志

l        全双工操作

l        ARCNET和WAN支持

2、2 驱动类型

       Windows NT支持三种类型的驱动：

l        网络接口卡驱动（NIC）

l        中间协议驱动

l        上层协议驱动

 

2、2、1 网络接口卡驱动

NIC驱动管理网络接口卡（NIC）。NIC驱动接口在下边界直接控制硬件（NIC），在上边界提供上层驱动访问的接口：

l        发送和接收包

l        重置NIC（Reset）

l        停止NIC

l        查询NIC

l        设置NIC操作特性

NIC驱动的两种类型

l         微端口驱动：微端口驱动应用于管理NIC硬件特殊操作，包括在NIC上发送和接收数据。微端口驱动不能直接呼叫系统例程，只能呼叫NDIS提供的函数。

l         完全NIC驱动：完全NIC驱动不仅管理硬件而且管理NDIS完成的的操作系统特定任务。完全NIC驱动必须保持接收数据的绑定信息。

2、2、2 中间协议驱动

       中间协议驱动接口位于上层协议驱动和微端口驱动之间。对于上层传输驱动程序来书，中间驱动看起来像是微端口驱动。对微端口驱动来说，看起来像是协议驱动。使用中间协议驱动的主要是为了传输媒质，存在于对于传输驱动未知和微端口管理之间的新的媒质类型。

2、2、3 上层协议驱动

       上层协议驱动应用于TDI接口或其它向用户提供服务的特定应用接口。例如 驱动调用NDIS分配包，向包中烤贝数据和向底层发送包。它也在它的底层提供协议接口，来接收下层驱动发送来的包。

2、3 应用程序和驱动的交互

       在Windows NT下的所有驱动必须具有DriverEntry函数，作为驱动的进入点。驱动中其它的函数是通过DriverEntry函数声明的。应用程序调用函数如CreateFile，ReadFile等，会由NT I/O管理器生成相应IRP（输入/输出请求包）。

在NT下，几乎所有I/O操作都是包驱动的。每个I/O操作由工作顺序来描述，工作顺序告诉驱动做什么和通过I/O子系统追踪请求的过程。这些工作顺序通过一个称为I/O请求包（IRP）的数据结构的形式给出。 这个IRP为完成特定操作按顺序调用驱动中的进入点。

 

3、在以太网中使用NDIS监测数据包 

              本节以一个NDIS驱动例子说明监测以太网。

              Packet 监测捕获在局域网中传输的的所有包。这是由以太网的广播特性决定的。通过以太网发送的包是向网络中所有计算机广播的。每台计算机上的以太网卡检查每个包的目的是否是它自己，如果是则接收，不是则拒绝。利用这个基本的功能来捕获网络中传输的所有数据包。 以太网卡可以被设置工作于好几种模式，可以设置于期望中的捕获数据包的模式。一个这样的可以工作于期望的例子驱动程序PACKET.SYS来自微软Windows NT 设备开发工具（DDK）。

3、1 以太网接口卡的模式

       以太网接口卡可以被设置的模式如下：

l        广播

l        多播

l        直接

l        混杂

       广播：数据帧可以发向网络中所有计算机， 这种帧的目的地址是0xffffff，也称为帧的广播地址。任何设置为广播模式的网卡都接收目的地址为广播地址的数据帧。通常所有的网卡被配置为接收广播帧。

       多播：发往一组计算机的帧称为多播帧， 使用特定的多播地址作为目的地址。这些计算机的组构成了多播组。这样，多播组里的任何一个成员计算机将会接收具有多播目的地址的帧。尽管网卡可以不是一个多播组里成员，但可以配置为多播模式，这样就可以接收所有多播帧。

       直接： 发往特定计算机的帧具有特定计算机的物理地址（以太网地址）的目的地址。具有特定物理地址的计算机将接收特定的帧，丢弃其它的帧。网卡可以设置为仅仅接收直接帧。

       混杂：设置为这个模式的网卡接收所有收到的数据包。这个模式具有的以太网的广播特性是包监测应用程序的关键。

       PACKET.SYS例子驱动可以将网卡设置为以上提到的模式。 应用可以利用PACKET.SYS将网卡设置为混杂模式，以便于捕获网络中传输的所有数据包。

3、2 关于例子驱动PACKET.SYS

       例子PACKET.SYS来自NT DDK。这个驱动可以将网卡设置为任何期望的模式，并且允许应用程序通过网络发送和接收数据包。除驱动程序的sys文件之外，还提供了一个DLL（PACKET32.DLL），通过此DLL应用程序可以和驱动程序通信。

3、2、1应用程序如何同PACKET.SYS通信

应用程序调用DLL中的函数，这些函数依次调用PACKET.SYS驱动中的进入点。驱动程序利用NDIS.SYS输出函数与网络接口卡通信。

 

 

3、2、2 如何在应用程序中使用PACKET32.DLL

应用程序使用驱动读取所有到达NIC的数据包。以下示例说明了这个过程。

在上述过程中使用的结构体定义如下：

 

[cpp] view plain copy

1. typedef struct _ADAPTER   
2. {   
3.     HANDLE     hFile;                               // 保存由CreateFile方法返回的句柄  
4.     TCHAR      SymbolicLink[MAX_LINK_NAME_LENGTH];  // 保存驱动的符号链接名  
5. } ADAPTER, *LPADAPTER;  

[cpp] view plain copy

1. typedef struct _PACKET   
2. {  
3.     HANDLE       hEvent;    // 保存和适配器对象相应的事件句柄  
4.     OVERLAPPED   OverLapped;// 包含异步输入输出信息的OVERLAPPED结构  
5.     PVOID        Buffer;    // 包含发送和接收数据的缓冲区  
6.     UINT         Length;    // 缓冲区长度  
7. } PACKET, *LPPACKET;  

[cpp] view plain copy

1. typedef struct _CONTROL_BLOCK   
2. {  
3.     LPADAPTER   hFile;              // 指向适配器对象的指针  
4.     HANDLE      hEvent;             // 保存事件句柄     
5.     // Name of the driver as registered in the registry.  
6.     TCHAR       AdapterName[64];    // 注册表中注册的驱动名           
7.     HANDLE      hMem;               // 保存接收数据包的缓冲区  
8.     LPBYTE      lpMem;  
9.     HGLOBAL     hMem2;              //  保存发送数据包的缓冲区  
10.     LPBYTE      lpMem2;          
11.     ULONG       PacketLength;       // 包长度   
12.     ULONG       LastReadSize;       // 最后读取的包大小     
13.     UINT        BufferSize;         // 缓冲区长度  
14. } CONTROL_BLOCK, *PCONTROL_BLOCK;  

 应用程序开始

 

[cpp] view plain copy

1. CONTROL_BLOCK cbAdapter;   
2. ULONG NameLength=64;  
3.   
4. // 得到驱动在注册表中注册的名字  
5. PacketGetAdapterNames(CbAdapter.AdapterName,&NameLength);  
6.   
7. CbAdapter.BufferSize=1514; // 保留1514字节，最大帧长度  
8.    
9. // 分配并锁定内存缓冲区用于发送和接收数据包  
10. CbAdapter.hMem=GlobalAlloc(GPTR, 1514);   
11. CbAdapter.lpMem=(LPBYTE)GlobalLock(CbAdapter.hMem);  
12. CbAdapter.hMem2=GlobalAlloc(GPTR,1514);  
13. CbAdapter.lpMem2=(LPBYTE)GlobalLock(CbAdapter.hMem2);  
14.    
15. // 打开优先的适配器用于接收数据,  
16. // 函数依次调用CreateFile方法，调用驱动程序中相应的进入点。为随后的读写操作打开适配器  
17. CbAdapter.hFile=(ADAPTER*)PacketOpenAdapter(CbAdapter.AdapterName);  
18.    
19. // 打开适配器域  
20. if (CbAdapter.hFile = = NULL)   
21. {  
22.     AfxMessageBox("Open Adapter failed");  
23. }  
24.    
25.   
26. // 此Packet对象用于从网络上接收所有数据的包  
27. PVOID Packet;  
28. // 设置过滤条件为混杂(非选择)模式  
29. // 此函数依次呼叫DeviceIoControl方法，用来设置网卡工作于期望的模式。  
30. Filter = NDIS_PACKET_TYPE_PROMISCUOUS;  
31.    
32. // 设置网卡为混杂模式  
33. PacketSetFilter(CbAdapter.hFile, Filter);  
34.    
35. // 分配缓冲区用于接收数据包  
36. Packet=PacketAllocatePacket(CbAdapter.hFile);  
37.    
38. // 初始化接收数据包缓冲区  
39. if(Packet != NULL)  
40. {  
41.     PacketInitPacket((PACKET *)Packet,(char *)pdData[nCurrentWriteLocation].pData,1514);  
42.   
43.     // 从驱动中读取数据包  
44.     // 此函数依次调用ReadFile方法来读取通过EIC从网络上收到的数据  
45.     PacketReceivePacket(CbAdapter.hFile,(PACKET *)Packet,TRUE,&pdData[nCurrentWriteLocation].nPacketLength );   

上述插入代码描述了应用程序如何使用 PACKET.SYS驱动设置以太网接口卡为混杂模式，用来捕获所有网络上的数据包。

 

以上代码清晰的描述了应用程序利用例子驱动PACKET.SYS将EIC设置为期望的模式，发送和接收数据包。

3、2、3 应用程序中使用的在Packet32.dll中定义的函数如下：

下面的函数PacketGetAdapterNames返回注册表中注册的驱动名

[cpp] view plain copy

1. ULONG  
2. PacketGetAdapterNames(  
3.     PTSTR   pStr,  
4.     PULONG BufferSize  
5.    )  
6. {  
7.     HKEY       SystemKey;  
8.     HKEY       ControlSetKey;  
9.     HKEY       ServicesKey;  
10.     HKEY       NdisPerfKey;  
11.     HKEY       LinkageKey;  
12.     LONG       Status;  
13.     DWORD      RegType;  
14.     // Open the Key HKEY_LOCAL_MACHINE,打开HKEY_LOCAL_MACHINE键值  
15.     Status=RegOpenKeyEx(  
16.                HKEY_LOCAL_MACHINE,  
17.                TEXT("SYSTEM"),  
18.                0,  
19.                KEY_READ,  
20.                &SystemKey  
21.                );  
22.     if (Status == ERROR_SUCCESS) {  
23.        // Open the key currentcontrolset 打开currentcontrolset键值  
24.         Status=RegOpenKeyEx(  
25.                    SystemKey,  
26.                    TEXT("CurrentControlSet"),  
27.                    0,  
28.                    KEY_READ,  
29.                    &ControlSetKey  
30.                    );  
31.         if (Status == ERROR_SUCCESS) {  
32.             // Open the key Services打开Services键值  
33.             Status=RegOpenKeyEx(  
34.                        ControlSetKey,  
35.                        TEXT("Services"),  
36.                        0,  
37.                        KEY_READ,  
38.                        &ServicesKey  
39.                        );  
40.             if (Status == ERROR_SUCCESS) {  
41.         // Open the key Packet. 打开Packet键值  
42.         Status=RegOpenKeyEx(  
43.                            ServicesKey,  
44.                            TEXT("Packet"),  
45.                            0,  
46.                            KEY_READ,  
47.                            &NdisPerfKey  
48.                            );  
49.                 if (Status == ERROR_SUCCESS) {  
50.             // Open the key Linkage.打开Linkage键值  
51.                     Status=RegOpenKeyEx(  
52.                                NdisPerfKey,  
53.                                TEXT("Linkage"),  
54.                                0,  
55.                                KEY_READ,  
56.                                &LinkageKey  
57.                                );  
58.                     if (Status == ERROR_SUCCESS) {  
59.                    // Open the key Export.        
60.                         Status=RegQueryValueEx(  
61.                                    LinkageKey,  
62.                                    TEXT("Export"),  
63.                                    NULL,  
64.                                    &RegType,  
65.                                    (LPBYTE)pStr,  
66.                                    BufferSize  
67.                                    );  
68.              // Close all the keys that have been opened so far.关闭已打开的所有键值  
69.                         RegCloseKey(LinkageKey);  
70.                     }  
71.                     RegCloseKey(NdisPerfKey);  
72.                 }  
73.                 RegCloseKey(ServicesKey);  
74.             }  
75.             RegCloseKey(ControlSetKey);  
76.         }  
77.         RegCloseKey(SystemKey);  
78.     }  
79.     return Status;  
80. }  

 

[cpp] view plain copy

1. PVOID PacketOpenAdapter(LPTSTR   AdapterName)  
2. {  
3.     LPADAPTER lpAdapter;  
4.     BOOLEAN    Result;  
5.        
6.     ODS("Packet32: PacketOpenAdapter/n");  
7.   
8.     // 为适配器对象分配全局内存  
9.     lpAdapter=(LPADAPTER)GlobalAllocPtr(GMEM_MOVEABLE | GMEM_ZEROINIT,sizeof(ADAPTER));  
10.     if (lpAdapter==NULL)   
11.     {  
12.          ODS("Packet32: PacketOpenAdapter GlobalAlloc Failed/n");  
13.          return NULL;  
14.     }  
15.    
16.     //  将名字拷贝到符号链接名  
17.     wsprintf(lpAdapter->SymbolicLink, TEXT(".//%s%s"), DOSNAMEPREFIX, &AdapterName[8] );  
18.    
19.     // Defines an MS-DOS name for the device.  
20.     Result=DefineDosDevice(DDD_RAW_TARGET_PATH,&lpAdapter->SymbolicLink[4], AdapterName);  
21.    
22.     if (Result)   
23.     {  
24.         // Creates and returns a file handle for the specified device. 为特定设备创建并返回文件句柄  
25.         lpAdapter->hFile=CreateFile(lpAdapter->SymbolicLink,GENERIC_WRITE | GENERIC_READ,0,NULL,CREATE_ALWAYS,FILE_FLAG_OVERLAPPED,0);  
26.    
27.         if (lpAdapter->hFile != INVALID_HANDLE_VALUE)   
28.         {  
29.             return lpAdapter;  
30.         }  
31.     }  
32.     ODS("Packet32: PacketOpenAdapter Could not open adapter /n");  
33.    
34.     GlobalFreePtr(lpAdapter );  
35.     return NULL;  
36.  }     

函数PacketOpenAdapter为设备定义了一个新的DOS设备名，调用CreaetFile方法来创建并打开通信设备，得到指向设备的句柄。应用程序预先调用此函数来发送和接收数据包。CreateFile方法 调用驱动中指定为IRP_MJ_CREATE的进入点，此进入点调用NDIS库，输出NdisOpenAdapter函数打开适配器。

 

以下的 函数PacketAllocatePacket为packet对象分配内存，调用CreateEvent函数来建立特定文件句柄的事件。

[cpp] view plain copy

1. PVOID PacketAllocatePacket(LPADAPTER   AdapterObject)  
2. {  
3.     LPPACKET    lpPacket;  
4.     //  为Packet对象分配内存  
5.     lpPacket=(LPPACKET)GlobalAllocPtr(GMEM_MOVEABLE | GMEM_ZEROINIT,sizeof(PACKET));  
6.     if (lpPacket==NULL)   
7.     {  
8.         ODS("Packet32: PacketAllocateSendPacket: GlobalAlloc Failed/n");  
9.         return NULL;  
10.     }  
11.     // 操作结束时建立事件对象   
12.     lpPacket->OverLapped.hEvent=CreateEvent( NULL,FALSE,FALSE, NULL);  
13.     if (lpPacket->OverLapped.hEvent==NULL)  
14.     {  
15.         ODS("Packet32: PacketAllocateSendPacket: CreateEvent Failed/n");  
16.         GlobalFreePtr(lpPacket);  
17.         return NULL;  
18.     }  
19.     return lpPacket;  
20. }  

PacketInitPacket函数设置packet对象缓冲区

[cpp] view plain copy

1. VOID PacketInitPacket(LPPACKET    lpPacket,PVOID       Buffer,UINT        Length)  
2. {  
3.     // 设置packet对象缓冲区到缓冲区  
4.     lpPacket->Buffer=Buffer;  
5.     // 设置packet对象缓冲区长度到缓冲区长度  
6.     lpPacket->Length=Length;  
7. }  

PacketReceivePacket函数调用驱动中适当的进入点来读取网络中获得的数据包，放入声明的缓冲区。ReadFile方法使用在CreateFile方法中获得的句柄来完成此操作。

[cpp] view plain copy

1. BOOLEAN PacketReceivePacket(LPADAPTER AdapterObject,LPPACKET lpPacket,BOOLEAN Sync,PULONG BytesReceived)  
2. {  
3.     BOOLEAN      Result;   
4.     // 设置偏移量为0  
5.     lpPacket->OverLapped.Offset=0;  
6.     lpPacket->OverLapped.OffsetHigh=0;  
7.     if (!ResetEvent(lpPacket->OverLapped.hEvent))   
8.     {  
9.         return FALSE;  
10.     }  
11.     // 调用ReadFile来读取数据包  
12.     Result=ReadFile(AdapterObject->hFile,lpPacket->Buffer, lpPacket->Length, BytesReceived, &lpPacket->OverLapped);  
13.     if (Sync)   
14.     {  
15.         // They want to wait  
16.         Result=GetOverlappedResult(AdapterObject->hFile,&lpPacket->OverLapped,BytesReceived, TRUE );  
17.     }  
18.     else  
19.     {  
20.         // They don't want to wait, they will call PacketWaitPacket to get  
21.         // The real result  
22.         //不等待，调用PacketWaitPacket得到真实值  
23.         Result = TRUE;  
24.     }  
25.     return Result;  
26. }  

使用驱动PACKET.SYS监测有许多例程是有用的。注意，没有提供更多的应用细节。

本节仅仅说明了使用NDIS例子驱动PACKET.SYS监控所有网络动作的应用程序如何编写。

 

4、如何识别HTTP请求

       上节描述了怎样从以太网中捕获所有的数据包。我们的意图是不仅仅捕获所有数据包，并且监控网络上的Internet活动，这意味着 我们应该识别携带HTTP请求的数据包。这需要 以太网帧结构和IP。 本节描述了TCP/IP包的标识，HTTP请求的标识，帧中的URL信息的获取。

 

4、1  网络数据流

       为了在分层的网络中传输数据，从应用程序传输数据到协议栈中中相应的协议。之后，此协议处理完数据之后，将数据传向栈中的下一个协议。在数据穿越每一层协议的同时，协议栈上相应协议为了栈中下一层协议，将数据封装起来。因此， 封装就是一个将数据存储成协议栈中更低层协议要求的格式的过程。

因此，我们可以看出，应用程序模块封装从用户应用消息传来的数据；TCP模块封装应用数据，增加TCP头并且发往下一层；当数据传向网络栈中IP模块时，IP模块将TCP段格式化为IP报文或称为包；以太网驱动将IP模块传来的数据格式化并将数据放入以太网帧中。

这就解释了帧中如何封装IP报文，IP包如何封装TCP/UDP数据。为了识别HTTP请求， 首先，我们应该识别包为TCP/IP包，然后检查此包是否是TCP包，最后识别此包是否HTTP请求。

 

4、2 识别TCP/IP包

为识别一个数据包是TCP/IP包，我们应该首先看看以太网的帧结构。

以太网的帧数据包含了14字节头。

       以太网帧头的域是：

l        目的地址（6字节）

l        源地址（6字节）

l        帧类型（2字节）

       就像名字的含义，目的地址域说明了以太网帧的目的。类似的，源地址说明了帧的源。帧的类型域是我们关心的。这个域标识了帧的协议。

       如果包是有效的IP包，则帧类型域（第13和第14字节）将会是080016。

 

 

 

4、3 识别TCP包

       识别了TCP/IP包之后，下一个任务是识别出包是否是TCP包或其他包。 因为HTTP请求仅仅通过TCP请求来传输，所以我们可以忽略其他包。为确定包是否是一个TCP包，我们 必须分析IP头。IP头如下所示：

IP头的重要域是：

l        头部长度（4位）和版本号（4位）

l        包总长度（2字节）

l        数据在传输层上使用的协议类型。下表说明了IP包的通用TCP/IP协议类型域

Protocol	Value(Decimal)
TCP	6
UDP	17
ICMP	1
IGMP	2

l        头部校验和（2字节）

l        源IP（4字节）

l        目的IP（4字节）

       IP头中协议域的值为06说明了数据包是TCP包。

4、4  识别HTTP请求

              识别出数据包是TCP包后，我们必须识别包是否是HTTP请求包。为找出包中是否包含HTTP请求，我们必须检查TCP头，TCP头如下所示：

       TCP头中重要的域是：

l        源端口（2字节）

l        目的端口（2字节）

l        序列号（4字节）

l        标识号（4字节）

l        Hlen，保留和代码位（2字节）

l        窗口（2字节）

l        校验和（2字节）

l        紧急点（2字节）

       如上所述，TCP头中，我们最关心的域是 源和目的端口域。这些域说明了连接建立的端口。不同的TCP服务比如 HTTP，FTP等等使用特定的端口号来提供他们的服务。

       对HTTP服务来说，端口号是008010或005016。 如果源端口域包含值是80（HTTP端口号），则包就是HTTP响应包。如果目的端口域是80，则包是HTTP请求包。

4、5  获取URL

       现在我们已经发现包是一个HTTP请求包了，找到包中包含的URL地址就相对简单了。

       在浏览器中键入的请求被以GET或POST请求的形式被发HTTP服务器。浏览器添加其他的与浏览器相关的信息，发往相应的HTTP服务器。完整的信息包含了封装在数据包中的请求页的URL。因此，依靠分析数据包就可以得到URL。 URL出项在数据包中的通用格式为：

       GET/HTTP/1.0

       以上的URL是我们键入浏览器的任何站点默认页。如果我们请求站点的其他页或点击页面中提供的链接，然后请求页也被放入GET请求中。例如，当我们请求的页面为sample.html，则URL将会是：

GET/sample.html HTTP/1.0

       因此，通过在数据包中查找GET串，就可以获取URL请求。

 

5、 驱动性能和操作系统兼容性

       在混杂模式下，驱动捕获到达网卡的所有数据包。如果网络流量很大，就有可能不能捕获而丢包。这必须考虑在内。 驱动中使用的是NDIS版本是3.0。驱动在Windows NT下工作良好，但不能在Windows95下工作，因为Windows95仅仅支持的是NDIS是2.1版本和NDIS 3.1版本。

在WINDOWS CE中使用驱动的相关问题

       Windows CE中NDIS应用是Windows NT下NDIS4.0的一个子集。为Windows NT写的驱动代码可以在Windows CE下工作，但需要考虑到一些问题。才Windows CE下，驱动会被编译为DLL，而不是Windows NT下的.SYS文件。而且，CE不支持内建的DMA和分配连续的内存块。更进一步， 为CE编写NDIS驱动，程序员必须考虑到电源管理的问题。这就是说，必须提供附加的电源管理代码。