《windows网络编程技术》之 Winsock I/O方法（1）

select模型：

select函数原型

int select(

    int nfds,

    fd_set   FAR * readfds,

    fd_set   FAR * writefds,

    fd_set   FAR * exceptfds,

    const struct  timeval  FAR * timeout

);

nfds为了保持与早期兼容，可忽略。

fd_set，代表一系列特定的套接字的集合，readset用于检查可读性，writeset用于检查可写性，exceptset用于检查异常数据，具体用法如下：

假定我们想测试一个套接字是否可读，必须将该套接字增加到readset中，再等待select函数完成，完成后判断该套接字是否仍然是readset集合的一部分，是，则该套接字可读。三个参数至少有一个不为null。

其中的timeval的结构如下：

struct timeval

{

   long      tv_sec;  (秒)

   long      tv_usec; (毫秒)

}

 

如select函数调用失败，返回SOCKET_ERROR.

对fd_set集合进行操作，可用宏：

FD_CLR(s,*set)：从set中删除套接字s；

FD_ISSET(s,*set):检查s是否是set集合的一员，返回true或false

FD_SET(s,*set):将套接字s加入集合set

FD_ZERO(*set)：将set初始化为空集合。

 

WSAAsyncSelect 模型  

利用这个模型，应用程序可在一个套接字上接收以Windows消息为基础的网络时间通知。使用这种模型，必须提供一个“窗口”，用于接收消息。函数原型如下：

int WSAAsyncSelect(

        SOCKET   s,

        HWND    hwnd,

        unsigned   int  wMsg,

        Long   lEvent

);

s:对应套接字

hwnd：接收消息的窗体句柄

wMsg：发送的消息，应该为一个比WM_USER大的值。

IEvent：对应为一系列网络事件的组合，包括：FD_READ,FD_WRITE,FD_ACCEPT,FD_CONNECT,FD_CLOSE.

如：WSAAsyncSelect（s,hwnd,WM_SOCKET,FD_CONNECT|FD_READ|FD_WRITE|FD_CLOSE）

在调用WSAAsyncSelect后，即在hwnd对应的窗体回调函数中对网络事件（消息）进行处理：

LRESULT CALLBACK WindowProc(

    HWND   hWnd,

    UINT     uMsg,

     WPARAM  wParam,

    LPARAM    lParam

);

其中wParam指定在其上面发生了一个网络事件的套接字。

lParam低字节指定了已经发生的网络事件，而lParam的高字节包含了可能出现的错误代码。在网络事件消息到达的时候，先调用WSAGETSELECTERROR宏返回高字节包含的错误信息。若没有错误，则调用WSAGETSELECTEVENT宏返回lParam低字节部分。

 

WSAEventSelect 模型

和WSAAsyncSelect模型不同的是，这种模型中网络事件会投递至一个事件对象句柄，而非窗口句柄。所以要求我们针对每一个套接字都要建立一个事件对象。用WSACreateEvent函数，定义如下：

WSAEVENT   WSACreateEvent(void);

然后调用WSAEventSelect函数，定义如下：

int   WSAEventSelect(

        SOCKET  s;

        WSAEVENT    hEventObject,

        long    lNetworkEvents

);

鉴于这个模型的复杂性，还是用代码说话吧：

#include
#include
#include

#define PORT 5150
#define DATA_BUFSIZE 8192

typedef struct _SOCKET_INFORMATION {
   CHAR Buffer[DATA_BUFSIZE];
   WSABUF DataBuf;
   SOCKET Socket;
   DWORD BytesSEND;
   DWORD BytesRECV;
} SOCKET_INFORMATION, * LPSOCKET_INFORMATION;

BOOL CreateSocketInformation(SOCKET s);
void FreeSocketInformation(DWORD Event);

DWORD EventTotal = 0;
WSAEVENT EventArray[WSA_MAXIMUM_WAIT_EVENTS];
LPSOCKET_INFORMATION SocketArray[WSA_MAXIMUM_WAIT_EVENTS];

void main(void)
{
   SOCKET Listen;
   SOCKET Accept;
   SOCKADDR_IN InternetAddr;
   DWORD Event;
   WSANETWORKEVENTS NetworkEvents;
   WSADATA wsaData;
   DWORD Ret;
   DWORD Flags;
   DWORD RecvBytes;
   DWORD SendBytes;

   if ((Ret = WSAStartup(0x0202, &wsaData)) != 0)  //初始化winsock
   {
      printf("WSAStartup() failed with error %d\n", Ret);
      return;
   }

   if ((Listen = socket (AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) //创建Listen套接字
   {
      printf("socket() failed with error %d\n", WSAGetLastError());
      return;
   }

   CreateSocketInformation(Listen);  //创建一个_SOCKET_INFORMATION结构实体

   if (WSAEventSelect(Listen, EventArray[EventTotal - 1], FD_ACCEPT|FD_CLOSE) == SOCKET_ERROR)
   {
      printf("WSAEventSelect() failed with error %d\n", WSAGetLastError());
      return;
   }

   InternetAddr.sin_family = AF_INET;
   InternetAddr.sin_addr.s_addr = htonl(INADDR_ANY);
   InternetAddr.sin_port = htons(PORT);

   if (bind(Listen, (PSOCKADDR) &InternetAddr, sizeof(InternetAddr)) == SOCKET_ERROR)
   {
      printf("bind() failed with error %d\n", WSAGetLastError());
      return;
   }

   if (listen(Listen, 5))
   {
      printf("listen() failed with error %d\n", WSAGetLastError());
      return;
   }
       

   while(TRUE)
   {
      // Wait for one of the sockets to receive I/O notification and
      if ((Event = WSAWaitForMultipleEvents(EventTotal, EventArray, FALSE,
         WSA_INFINITE, FALSE)) == WSA_WAIT_FAILED)
      {
         printf("WSAWaitForMultipleEvents failed with error %d\n", WSAGetLastError());
         return;
      }

//通过SocketArray[Event - WSA_WAIT_EVENT_0]获得事件是在哪个socket上发生

//通过WSAEnumNetworkEvents获得发生了什么类型的网络事件
      if (WSAEnumNetworkEvents(SocketArray[Event - WSA_WAIT_EVENT_0]->Socket, EventArray[Event -
         WSA_WAIT_EVENT_0], &NetworkEvents) == SOCKET_ERROR)  //必须减去预定义值，才能得到实际的索引位置
      {
         printf("WSAEnumNetworkEvents failed with error %d\n", WSAGetLastError());
         return;
      }

     
      if (NetworkEvents.lNetworkEvents & FD_ACCEPT)
      {
         if (NetworkEvents.iErrorCode[FD_ACCEPT_BIT] != 0)
         {
            printf("FD_ACCEPT failed with error %d\n", NetworkEvents.iErrorCode[FD_ACCEPT_BIT]);
            break;
         }

         if ((Accept = accept(SocketArray[Event - WSA_WAIT_EVENT_0]->Socket, NULL, NULL)) == INVALID_SOCKET)
         {  
            printf("accept() failed with error %d\n", WSAGetLastError());
            break;
         }

         if (EventTotal > WSA_MAXIMUM_WAIT_EVENTS)
         {
            printf("Too many connections - closing socket.\n");
            closesocket(Accept);
            break;
         }

         CreateSocketInformation(Accept);//一旦有套接字accepted了，就创建事件对象和LPSOCKET_INFORMATION 结构

         if (WSAEventSelect(Accept, EventArray[EventTotal - 1], FD_READ|FD_WRITE|FD_CLOSE) == SOCKET_ERROR) //继续对accepted 的 套接字调用WSAEventSelect
         {
            printf("WSAEventSelect() failed with error %d\n", WSAGetLastError());
            return;
         }

         printf("Socket %d connected\n", Accept);
      }

      // Try to read and write data to and from the data buffer if read and write events occur.

      if (NetworkEvents.lNetworkEvents & FD_READ ||
         NetworkEvents.lNetworkEvents & FD_WRITE)
      {
         if (NetworkEvents.lNetworkEvents & FD_READ &&
            NetworkEvents.iErrorCode[FD_READ_BIT] != 0)
         {
            printf("FD_READ failed with error %d\n", NetworkEvents.iErrorCode[FD_READ_BIT]);
            break;
         }

         if (NetworkEvents.lNetworkEvents & FD_WRITE &&
            NetworkEvents.iErrorCode[FD_WRITE_BIT] != 0)
         {
            printf("FD_WRITE failed with error %d\n", NetworkEvents.iErrorCode[FD_WRITE_BIT]);
            break;
         }

         LPSOCKET_INFORMATION SocketInfo = SocketArray[Event - WSA_WAIT_EVENT_0];

         // Read data only if the receive buffer is empty.

         if (SocketInfo->BytesRECV == 0)
         {
            SocketInfo->DataBuf.buf = SocketInfo->Buffer;
            SocketInfo->DataBuf.len = DATA_BUFSIZE;

            Flags = 0;
            if (WSARecv(SocketInfo->Socket, &(SocketInfo->DataBuf), 1, &RecvBytes,
               &Flags, NULL, NULL) == SOCKET_ERROR)
            {
               if (WSAGetLastError() != WSAEWOULDBLOCK)
               {
                  printf("WSARecv() failed with error %d\n", WSAGetLastError());
                  FreeSocketInformation(Event - WSA_WAIT_EVENT_0);
                  return;
               }
            }
            else
            {
               SocketInfo->BytesRECV = RecvBytes;
            }
         }

         // Write buffer data if it is available.

         if (SocketInfo->BytesRECV > SocketInfo->BytesSEND)
         {
            SocketInfo->DataBuf.buf = SocketInfo->Buffer + SocketInfo->BytesSEND;
            SocketInfo->DataBuf.len = SocketInfo->BytesRECV - SocketInfo->BytesSEND;

            if (WSASend(SocketInfo->Socket, &(SocketInfo->DataBuf), 1, &SendBytes, 0,
               NULL, NULL) == SOCKET_ERROR)
            {
               if (WSAGetLastError() != WSAEWOULDBLOCK)
               {
                  printf("WSASend() failed with error %d\n", WSAGetLastError());
                  FreeSocketInformation(Event - WSA_WAIT_EVENT_0);
                  return;
               }

               // A WSAEWOULDBLOCK error has occured. An FD_WRITE event will be posted
               // when more buffer space becomes available
            }
            else
            {
               SocketInfo->BytesSEND += SendBytes;

               if (SocketInfo->BytesSEND == SocketInfo->BytesRECV)
               {
                  SocketInfo->BytesSEND = 0;
                  SocketInfo->BytesRECV = 0;
               }
            }
         }
      }

      if (NetworkEvents.lNetworkEvents & FD_CLOSE)
      {
         if (NetworkEvents.iErrorCode[FD_CLOSE_BIT] != 0)
         {
            printf("FD_CLOSE failed with error %d\n", NetworkEvents.iErrorCode[FD_CLOSE_BIT]);
            break;
         }

         printf("Closing socket information %d\n", SocketArray[Event - WSA_WAIT_EVENT_0]->Socket);

         FreeSocketInformation(Event - WSA_WAIT_EVENT_0);
      }
   }
   return;
}

BOOL CreateSocketInformation(SOCKET s)
{
   LPSOCKET_INFORMATION SI;
     
   if ((EventArray[EventTotal] = WSACreateEvent()) == WSA_INVALID_EVENT)
   {
      printf("WSACreateEvent() failed with error %d\n", WSAGetLastError());
      return FALSE;
   }

   if ((SI = (LPSOCKET_INFORMATION) GlobalAlloc(GPTR,
      sizeof(SOCKET_INFORMATION))) == NULL)
   {
      printf("GlobalAlloc() failed with error %d\n", GetLastError());
      return FALSE;
   }

   // Prepare SocketInfo structure for use.

   SI->Socket = s;
   SI->BytesSEND = 0;
   SI->BytesRECV = 0;

   SocketArray[EventTotal] = SI;

   EventTotal++;

   return(TRUE);
}

void FreeSocketInformation(DWORD Event)
{
   LPSOCKET_INFORMATION SI = SocketArray[Event];
   DWORD i;

   closesocket(SI->Socket);

   GlobalFree(SI);

   WSACloseEvent(EventArray[Event]);

   // Squash the socket and event arrays

   for (i = Event; i < EventTotal; i++)
   {
      EventArray[i] = EventArray[i + 1];
      SocketArray[i] = SocketArray[i + 1];
   }

   EventTotal--;
}

有了源代码，一切都是那么清晰，呵呵。

终于可以进入重叠模型了。。。