依睛(IT blog) 我回来了，PHP<-->C/C++ LINUX

笨鸟

统计

积分与排名

友情连接

最新评论

Windows 网络编程技术 第八章 windows socket i/o

Windows 网络编程技术 第八章 windows socket i/o 方法

大 | 中 | 小
2007/12/16    17:24    414   huzhangyou2002信仰的服务器设计不指定
关键字：
引用
套接字模式：锁定、非锁定2    
套接字模式：锁定、非锁定
套接字I/O模型：      select（选择）
WSAAsyncSelect（异步选择）
WSAEventSelect（事件选择）
Overlapped I/O（重叠式I / O）
Completion port（完成端口）




一、 简介

套接字模型的出现，是为了解决套接字模式存在的某些限制。
所有Wi n d o w s平台都支持套接字以锁定或非锁定方式工作。然而，并非每种平台都支持每一种I / O模型。
操作系统对套接字I / O模型的支持情况

引用
平台
select
WSAAsync
WSAEventSelect
Overlapped
Completion Port

Windows CE
支持
不支持
不支持
不支持
不支持

Windows 95（Winsock 1）
支持
支持
不支持
不支持
不支持

Windows 95（Winsock 2）
支持
支持
支持
支持
不支持

Windows 98
支持
支持
支持
支持
不支持

Windows NT
支持
支持
支持
支持
支持

Windows 2000
支持
支持
支持
支持
支持




二、          套接字模式

在锁定模式下，在I / O操作完成前，执行操作的Winsock函数（比如send和recv）会一直等候下去，不会立即返回程序（将控制权交还给程序）。而在非锁定模式下，Winsock函数无论如何都会立即返回。

锁定模式
处在锁定模式的套接字，因为在一个锁定套接字上调用任何一个Winsock API函数，都会产生相同的后果—耗费或长或短的时间"等待"。

非锁定模式
view plaincopy to clipboardprint?
  1. SOCKET s;   
  2. unsigned long ul=1;   
  3. int nRet;   
  4. s = socket(AF_INET,SOCK_STREAM,0);   
  5. nRet = ioctlsocket(s,FIOBIO,(unsigned long *) &ul);   
  6. if(nRet == SOCKET_ERROR)   
  7. {   
  8.      //Failed to put the socket into nonblocking mode   
  9. }   


三、  套接字I/O模型

1. select模型
select函数，可以判断套接字上是否存在数据，或者能否向一个套接字写入数据。
处于锁定模式时，防止I / O调用（如send或recv），进入"锁定"状态；同时防止在套处于非锁定模式时，防止产生WSAEWOULDBLOCK错误。
除非满足事先用参数规定的条件，否则select函数会在进行I / O操作时锁定。

select的函数原型：
int select(
     int nfds,//会被忽略, 为了保持与早期的B e r k e l e y套接字应用程序的兼容
fd_set FAR * readfds,//检查可读性
fd_set FAR * writefds,//检查可写性
fd_set FAR * exceptfds,//于例外数据
const struct timeval FAR * timeout//最多等待I / O操作完成多久的时间。如是空指针，无限期等
);
//fd_set数据类型代表着一系列特定套接字的集合
Wi n s o c k提供下列宏对f d _ s e t进行处理与检查：
■ FD_CLR(s, *set)：从s e t中删除套接字s。
■ FD_ISSET(s, *set)：检查s是否s e t集合的一名成员；如答案是肯定的是，则返回T R U E。
■ FD_SET(s, *set)：将套接字s加入集合s e t。
■ F D _ Z E R O ( * s e t )：将s e t初始化成空集合。

步骤：
引用
1) 使用F D _ Z E R O宏，初始化自己感兴趣的每一个f d _ s e t。
2) 使用F D _ S E T宏，将套接字句柄分配给自己感兴趣的每个f d _ s e t。
3) 调用s e l e c t函数，然后等待在指定的f d _ s e t集合中，I / O活动设置好一个或多个套接字句柄。s e l e c t完成后，会返回在所有f d _ s e t集合中设置的套接字句柄总数，并对每个集合进行相应的更新。
4) 根据s e l e c t的返回值，我们的应用程序便可判断出哪些套接字存在着尚未完成的I / O操作—具体的方法是使用F D _ I S S E T宏，对每个f d _ s e t集合进行检查。
5) 知道了每个集合中"待决"的I / O操作之后，对I / O进行处理，然后返回步骤1 )，继续进行s e l e c t处理。
s e l e c t返回后，它会修改每个f d _ s e t结构，删除那些不存在待决I / O操作的套接字句柄。这正是我们在上述的步骤( 4 )中，为何要使用F D _ I S S E T宏来判断一个特定的套接字是否仍在集合中的原因。

view plaincopy to clipboardprint?
  1. SOCKET s;   
  2. fd_set fdread;   
  3. int ret;   
  4. //create a socket, and accept a connection   
  5. //Manage I/O on the socket   
  6. while(TRUE)   
  7. {   
  8. //Always clear the read set before calling select()   
  9. FD_ZERO(&fdread);   
  10. //Add socket s to the read set   
  11. FD_SET(s,&fdread);   
  12. If((ret=select(0,&fdread,NULL,NULL,NULL))== SOCKET_ERROR){   
  13.     //Error condition   
  14. }   
  15. if(ret>0)   
  16. {   
  17.     //For this simple case, select() should return the value 1. An application dealing with    
  18.      //more than one socket could get a value greater than 1.At this point,your application    
  19. //should check to see whether the socket is part of a set.   
  20. If(FD_ISSET(s,&fdread))   
  21. {   
  22.                 //A read event has occurred on socket s   
  23. }   
  24. }   
  25. }   

2. WSAAsyncSelect
有用的异步I / O模型，利用这个模型，应用程序可在一个套接字上，接收以Windows消息为基础的网络事件通知。
函数原型：
int WSAAsyncSelect(
    SOCKET s,
    HWND hWnd,//收到通知消息的那个窗口
    unsigned int wMsg, //指定在发生网络事件时，打算接收的消息
    long lEvent//位掩码，对应于一系列网络事件的组合
);

用于WSAAsyncSelect函数的网络事件:
FD_READ 应用程序想要接收有关是否可读的通知，以便读入数据
FD_WRITE 应用程序想要接收有关是否可写的通知，以便写入数据
FD_OOB 应用程序想接收是否有带外（OOB）数据抵达的通知
FD_ACCEPT 应用程序想接收与进入连接有关的通知
FD_CONNECT 应用程序想接收与一次连接或者多点join操作完成的通知
FD_CLOSE 应用程序想接收与套接字关闭有关的通知
FD_QOS 应用程序想接收套接字"服务质量"（QoS）发生更改的通知
FD_GROUP_QOS 应用程序想接收套接字组"服务质量"发生更改的通知（为未来套接字组的使用保留）
FD_ROUTING_INTERFACE_CHANGE 应用程序想接收在指定的方向上，与路由接口发生变化的通知
FD_ADDRESS_LIST_CHANGE 应用程序想接收针对套接字的协议家族，本地地址列表发生变化的通知

窗口例程，函数原型：
LRESULT CALLBACK WindowProc(
    HWND hWnd,
    UINT uMsg,
    WPARAM wParam,
    LPARAM lParam
);
WSAAsyncSelect 调用中定义的消息。wParam参数指定在其上面发生了一个网络事件的套接字。假若同时为这个窗口例程分配了多个套接字，这个参数的重要性便显示出来了。 在lParam参数中，包含了两方面重要的信息。其中， lParam的低位字指定了已经发生的网络事件，而lParam的高位字包含了可能出现的任何错误代码。
网络事件消息抵达一个窗口例程后，应用程 序首先应检查lParam的高字位，以判断是否在套接字上发生了一个网络错误。这里有一个特殊的宏： WSAGETSELECTERROR，可用它返回高字位包含的错误信息。若应用程序发现套接字上没有产生任何错误，接着便应调查到底是哪个网络事件类型， 造成了这条Windows消息的触发—具体的做法便是读取lParam之低字位的内容。此时可使用另一个特殊的宏：WSAGETSELECTEVENT， 用它返回lParam的低字部分。

3.WSAEventSelect
异步I / O模型, 网络事件投递至一个事件对象句柄，而非投递至一个窗口例程。

1.      针对打算使用的每一个套接字，首先创建一个事件对象。
WSAEVENT WSACreateEvent(void);
*相关的函数：BOOL WSAResetEvent(WSAEVENT hEvent);BOOL WSACloseEvent(WSAEVENT hEvent);
WSACreateEvent创建的事件拥有两种工作状态：signaled和nonsignaled，以及两种工作模式：manual reset和auto reset。

2.     将其与某个套接字关联在一起，同时注册自己感兴趣的网络事件类型。
int WSAEventSelect(Socket s,WSAEVENT hEventObject,long lNetworkEvents);

3.      套接字同一个事件对象句柄关联在一起后，应用程序便可开始I/O处理；方法是等待网络事件触发事件对象句柄的工作状态。 WSAWaitForMultipleEvents函数的设计宗旨便是用来等待一个或多个事件对象句柄，并在事先指定的一个或所有句柄进入"已传信"状态 后，或在超过了一个规定的时间周期后，立即返回。
DWORD WSAWaitForMultipleEvents(
          DWORD cEvents,
          const WSAEVENT FAR * lphEvents,
          BOOL fWaitAll,
          DWORD dwTimeOut,
          BOOL fAlertable
);
WSAWaitForMultipleEvents 只能支持由WSA_MAXIMUM_WAIT_EVENTS对象规定的一个最大值，在此定义成64个。因此，针对发出 WSAWaitForMultipleEvents调用的每个线程，该I/O模型一次最多都只能支持6 4个套接字。假如想让这个模型同时管理不止64个套接字，必须创建额外的工作者线程，以便等待更多的事件对象。

4.     知道了造成网络事件的套接字后，接下来调用WSAEnumNetworkEvents函数，调查发生了什么类型的网络事件。
int WSAEnumNetworkEvents(SOCKET s,WSAEVENT hEventObject,LPWSANETWORKEVENTS lpNetworkEvents)；

4. Overlapped I/O
重叠I / O（Overlapped I/O）模型使应用程序能达到更佳的系统性能。
重叠模型的基本设计原理便是让应用程序使用一个重叠的数据结构，一次投递一个或多个Winsock I/O请求。
首 先使用WSA_FLAG_OVERLAPPED这个标志，创建一个套接字。s = WSASocket(AF_INET, SOCK_STREAM, 0 ,NULL,0,WSA_FLAG_OVERLAPPED);创建套接字的时候，假如使用的是socket函数，而非WSASocket函数，那么会默认 设置WSA_FLAG_OVERLAPPED标志。成功建好一个套接字，同时将其与一个本地接口绑定到一起后，便可开始进行重叠I / O 操作，方法是调用下述的Wi n s o c k 函数，同时指定一个WSAOVERLAPPED结构（可选）：
■ WSASend
■ WSASendTo
■ WSARecv
■ WSARecvFrom
■ WSAIoctl
■ AcceptEx
■ TrnasmitFile
引用
步骤：
1) 创建一个套接字，开始在指定的端口上监听连接请求。
2) 接受一个进入的连接请求。
3) 为接受的套接字新建一个WSAOVERLAPPED结构，并为该结构分配一个事件对象句柄。也将事件对象句柄分配给一个事件数组，以便稍后由WSAWaitForMultipleEvents函数使用。
4) 在套接字上投递一个异步WSARecv请求，指定参数为WSAOVERLAPPED结构。注意函数通常会以失败告终，返回SOCKET_ERROR错误状态WSA_IO_PENDING（I/O操作尚未完成）。
5) 使用步骤3 )的事件数组，调用WSAWaitForMultipleEvents函数，并等待与重叠调用关联在一起的事件进入"已传信"状态（换言之，等待那个事件的"触发"）。
6) WSAWaitForMultipleEvents函数完成后，针对事件数组，调用WSAResetEvent（重设事件）函数，从而重设事件对象，并对完成的重叠请求进行处理。
7) 使用WSAGetOverlappedResult函数，判断重叠调用的返回状态是什么。
8) 在套接字上投递另一个重叠WSARecv请求。
9) 重复步骤5 ) ~ 8 )。

view plaincopy to clipboardprint?
  1.                         
  2.               void main(void)   
  3. {   
  4.      WSABUF DataBuf;   
  5.      DWORD EventTotal = 0;   
  6.      WSAEVENT EventArray[WSA_MAXIMUM_WAIT_EVENTS];   
  7.      WSAOVERLAPPED AcceptOverlapped;   
  8.      SOCKET ListenSocket,AcceptSocket;   
  9.      //Step 1:Start Winsock and set up a listening socket   
  10.      ...   
  11.      //Step 2:Accept an inbound connection   
  12.      AcceptSocket = accept(ListenSocket, NULL , NULL);   
  13.      //Step 3:Set up an overlapped structure   
  14.      EventArray[EventTotal] = WSACreateEvent();   
  15.      ZeroMemory(&AcceptOverlapped, sizeof(WSAOVERLAPPED));   
  16.      AcceptOverlapped.hEvent= EventArray[EventTotal];             
  17.      DataBuf.len = DATA_BUFSIZE;   
  18.      DataBuf.buf = buffer;   
  19.      EventTotal ++;   
  20.      //Step 4:Post a WSARecv request to begin receiving data on the socket   
  21. WSARecv(AcceptSocket, &DataBuf, 1, &RecvBytes, &Flags, &AcceptOverlapped, NULL);   
  22. While(TRUE)   
  23. {   
  24.      //Step 5:Wait for the overlapped I/O call to complete    
  25.      Index = WSAWaitForMultipleEvents(EventTotal,EventArray,FALSE,WSA_INFINITE,FALSE);   
  26. //Index should be 0,because we have only one event handle in EventArray   
  27. //Step 6:Reset the signaled event    
  28. WSAResetEvent(EventArray[Index - WSA_WAIT_EVENT_0]);   
  29. //Step 7:Determine the status of the overlapped request   
  30. WSAGetOverlappedResult(AcceptSocket, &AcceptOverlapped, &BytesTransferred, FALSE, &Flags);   
  31. //First check to see whether the peer has closed the connection, and if so, close the socket   
  32. if(BytesTransferred == 0){   
  33.     closesocket(AcceptSocket);   
  34.     WSACloseEvent(EventArray[Index - WSA_WAIT_EVENT_0]);   
  35.     Return;   
  36. }   
  37. //Do something with the received data.   
  38. //DataBuf contains the received data.   
  39. ...   
  40. //Step 8:Post another WSARecv() request on the socket   
  41. Flags = 0;   
  42. ZeroMemory(&AcceptOverlapped,sizeof(WSAOVERLAPPED));   
  43. AcceptOverlapped.hEvent = EventArray[Index - WSA_WAIT_EVENT_0];   
  44. DataBuf.len = DATA_BUFSIZE;   
  45. DataBuf.buf = Buffer;   
  46. WSARecv(AcceptSocket, &DataBuf, 1, &RecvBytes, &Flags, &AcceptOverlapped,NULL);   
  47. }   
  48. }   

在Windows NT和Windows 2000中，重叠I/O模型也允许应用程序以一种重叠方式，实现对连接的接受。具体的做法是在监听套接字上调用AcceptEx函数。

完成例程
"完成例程"是我们的应用程序用来管理完成的重叠I / O请求的另一种方法。完成例程其实就是一些函数。设计宗旨是通过调用者的线程，为一个已完成的I / O请求提供服务。
void CALLBACK CompletionROUTINE(
      DWORD dwError, //表明了一个重叠操作（由l p O v e r l a p p e d指定）的完成状态是什么。
      DWORD cbTransferred,//实际传输的字节量
  LPWSAOVERLAPPED lpOverlapped,
  DWORD dwFlags // 0
);
在用一个完成例程提交的重叠请求，与用一个事件对象提交的重叠请求之间，存在着一项非常重要的区别。WSAOVERLAPPED结构的事件字段hEvent并未使用；
引用
步骤：
1) 新建一个套接字，开始在指定端口上，监听一个进入的连接。
2) 接受一个进入的连接请求。
3) 为接受的套接字创建一个WSAOVERLAPPED结构。
4) 在套接字上投递一个异步WSARecv请求，方法是将WSAOVERLAPPED指定成为参数，同时提供一个完成例程。
5) 在将fAlertable参数设为TRUE的前提下，调用WSAWaitForMultipleEvents，并等待一个重叠I/O请求完成。重叠请求完 成后，完成例程会自动执行，而且WSAWaitForMultipleEven ts会返回一个WSA_IO_COMPLETION。在完成例程内，可随一个完成例程一道，投递另一个重叠WSARecv请求。
6) 检查WSAWaitForMultipleEvents是否返回WSA_IO_COMPLETION。
7) 重复步骤5 )和6 )。

view plaincopy to clipboardprint?
  1. SOCKET AcceptSocket;   
  2. WSABUF DataBuf;   
  3. void main(void)   
  4. {   
  5.             WSAOVERLAPPED Overlapped;   
  6. //Step 1:Start Winsock, and set up a listening socket   
  7.     ...   
  8. //Step 2:Accept a new connection   
  9.     AcceptSocket = accept(ListenSocket, NULL, NULL);   
  10. //Step 3:Now that we have an accepted socket,start processing I/O using overlapped I/O with a completion routine.    
  11. //To get the overlapped I/O processing started,first submit an overlapped WSARECV() request.   
  12.     Flags = 0;   
  13.     ZeroMemory(&Overlapped, sizeof(WSAOVERLAPPED));   
  14.     DataBuf.len = DATA_BUFSIZE;   
  15.     DataBuf.buf = Buffer;   
  16. //Step 4: Post an asynchronous WSARecv() request on the socket by specifying the WSAOVERLAPPED structure    
  17. //as a parameter, and supply the WorkerRoutine function below as the completion routine   
  18. if(WSARecv(AcceptSocket,&DataBuf,1,&RecvBytes,&Flags,&Overlapped,WorkerRoutine) == SOCKET_ERROR){   
  19.     if(WSAGetLastError()!=WSA_IO_PENDING){   
  20.                   return;   
  21. }   
  22.     //Since the WSAWaitForMultipleEvents() API requires waiting on one or more event objects   
  23. //we will have to create a dummy event object. As an alternative, we can use SleepEx() instead.   
  24. EventArray[0] = WSACreatedEvent();   
  25. While(TRUE)   
  26. {     
  27.            //Step 5:   
  28. Index = WSAWaitForMultipleEvents(1, EventArray, FALSE, WSA_INFINITE, TRUE);   
  29. //Step 6:   
  30.    if(Index = = WAIT_IO_COMPLETION) {   
  31.            //An overlapped request completion routine just completed.Continue servicing more completion rouines.   
  32.                   break;   
  33. }   
  34. else{   
  35.    //A bad error occurred - stop processing.   
  36.    Return;   
  37. }   
  38. }   
  39. }    
  40. }   
  41.     
  42. void CALLBACK WorkerRoutine(DWORD Error,DWORD BytesTransferred,LPWSAOVERLAPPED overlapped,DWORD InFlags)   
  43. {   
  44.     DWORD SendBytes, RecvBytes;   
  45.     DWORD Flags;   
  46.     If(Error!=0||BytesTransferred == 0){   
  47.      //a bad error occurred on the socket   
  48.     closesocket(AcceptSocket);   
  49.     return;   
  50. }   
  51. //At this point, an overlapped WSARecv() request completed successfully.Now we can retrieve the received data that is    
  52. //contained in the variable DataBuf. After Processing the received data,We need to post another overlapped    
  53. //WSARecv() or WSASend() request.For Simplicity,we need to post another overlapped WSARecv() or WSASend()    
  54. //request.For Simplicity,we will post another WSARecv() request.   
  55. Flags = 0;   
  56. ZeroMemory(&Overlapped, sizeof(WSAOVERLAPPED));   
  57. DataBuf.len = DATA_BUFSIZE;   
  58. DataBuf.buf = Buffer;   
  59. if (WSARecv(AcceptSocket,*DataBuf,1,&RecvBytes,&Flags,&Overlapped,WorkerRoutine)==SOCKET_ERROR){   
  60.     if(WSAGetLastError()!=WSA_IO_PENDING){   
  61.    return;   
  62. }   
  63. }      
  64. }   
  65.    

5、完成端口模型
引用
" 完成端口"模型是迄今为止最为复杂的一种I / O模型。然而，假若一个应用程序同时需要管理为数众多的套接字，那么采用这种模型，往往可以达到最佳的系统性能！但不幸的是，该模型只适用于 Windows NT和Windows 2000操作系统。因其设计的复杂性，只有在你的应用程序需要同时管理数百乃至上千个套接字的时候，而且希望随着系统内安装的C P U数量的增多，应用程序的性能也可以线性提升，才应考虑采用"完成端口"模型。要记住的一个基本准则是，假如要为Windows NT或Windows 2000开发高性能的服务器应用，同时希望为大量套接字I / O请求提供服务（We b服务器便是这方面的典型例子），那么I / O完成端口模型便是最佳选择！

posted on 2008-01-17 11:34 向左向右走 阅读(349) 评论(0)  编辑 收藏 引用

只有注册用户登录后才能发表评论。