[转] 完成端口例子

小咪咪 2022-08-26 11:17 145阅读 0赞

*引用:http://blog.csdn.net/wei801004/archive/2005/11/15/530147.aspx*  
// CompletePort.cpp : 定义控制台应用程序的入口点。  
  
// Module Name: iocmplt.cpp  
//  
// Description:  
//  
//    This sample illustrates how to develop a simple echo server Winsock  
//    application using the completeion port I/O model. This  
//    sample is implemented as a console-style application and simply prints  
//    messages when connections are established and removed from the server.  
//    The application listens for TCP connections on port 5150 and accepts them  
//    as they arrive. When this application receives data from a client, it  
//    simply echos (this is why we call it an echo server) the data back in  
//    it's original form until the client closes the connection.  
//  
// Compile:  
//  
//    cl -o iocmplt iocmplt.cpp ws2\_32.lib  
//  
// Command Line Options:  
//  
//    iocmplt.exe  
//  
//    Note: There are no command line options for this sample.  
\#include "stdafx.h"  
\#include <winsock2.h>  
\#include <windows.h>  
\#include <stdio.h>  
  
\#define PORT 5150  
\#define DATA\_BUFSIZE 8192  
  
\#pragma comment(lib, "Ws2\_32")  
  
typedef struct  
\{  
   OVERLAPPED Overlapped;  
   WSABUF DataBuf;  
   CHAR Buffer\[DATA\_BUFSIZE\];  
   DWORD BytesSEND;  
   DWORD BytesRECV;  
\} PER\_IO\_OPERATION\_DATA, \* LPPER\_IO\_OPERATION\_DATA;  
  
  
typedef struct  
\{  
   SOCKET Socket;  
\} PER\_HANDLE\_DATA, \* LPPER\_HANDLE\_DATA;  
  
  
DWORD WINAPI ServerWorkerThread(LPVOID CompletionPortID);  
  
void main(void)  
\{  
   SOCKADDR\_IN InternetAddr;  
   SOCKET Listen;  
   SOCKET Accept;  
   HANDLE CompletionPort;  
   SYSTEM\_INFO SystemInfo;  
   LPPER\_HANDLE\_DATA PerHandleData;  
   LPPER\_IO\_OPERATION\_DATA PerIoData;  
   int i;  
   DWORD RecvBytes;  
   DWORD Flags;  
   DWORD ThreadID;  
   WSADATA wsaData;  
   DWORD Ret;  
  
   if ((Ret = WSAStartup(0x0202, &wsaData)) != 0)  
   \{  
      printf("WSAStartup failed with error %d/n", Ret);  
      return;  
   \}  
  
   // Setup an I/O completion port.  
  
   if ((CompletionPort = CreateIoCompletionPort(INVALID\_HANDLE\_VALUE, NULL, 0, 0)) == NULL)  
   \{  
      printf( "CreateIoCompletionPort failed with error: %d/n", GetLastError());  
      return;  
   \}  
  
   // Determine how many processors are on the system.  
  
   GetSystemInfo(&SystemInfo);  
  
   // Create worker threads based on the number of processors available on the  
   // system. Create two worker threads for each processor.  
  
   for(i = 0; i < SystemInfo.dwNumberOfProcessors \* 2; i++)  
   \{  
      HANDLE ThreadHandle;  
  
      // Create a server worker thread and pass the completion port to the thread.  
  
      if ((ThreadHandle = CreateThread(NULL, 0, ServerWorkerThread, CompletionPort,  
         0, &ThreadID)) == NULL)  
      \{  
         printf("CreateThread() failed with error %d/n", GetLastError());  
         return;  
      \}  
  
      // Close the thread handle  
      CloseHandle(ThreadHandle);  
   \}  
  
   // Create a listening socket  
  
   if ((Listen = WSASocket(AF\_INET, SOCK\_STREAM, 0, NULL, 0,  
      WSA\_FLAG\_OVERLAPPED)) == INVALID\_SOCKET)  
   \{  
      printf("WSASocket() 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;  
   \}  
  
   // Prepare socket for listening  
  
   if (listen(Listen, 5) == SOCKET\_ERROR)  
   \{  
      printf("listen() failed with error %d/n", WSAGetLastError());  
      return;  
   \}  
  
   // Accept connections and assign to the completion port.  
  
   while(TRUE)  
   \{  
      if ((Accept = WSAAccept(Listen, NULL, NULL, NULL, 0)) == SOCKET\_ERROR)  
      \{  
         printf("WSAAccept() failed with error %d/n", WSAGetLastError());  
         return;  
      \}  
  
      // Create a socket information structure to associate with the socket  
      if ((PerHandleData = (LPPER\_HANDLE\_DATA) GlobalAlloc(GPTR,  
         sizeof(PER\_HANDLE\_DATA))) == NULL)  
      \{  
         printf("GlobalAlloc() failed with error %d/n", GetLastError());  
         return;  
      \}  
  
      // Associate the accepted socket with the original completion port.  
  
      printf("Socket number %d connected/n", Accept);  
      PerHandleData->Socket = Accept;  
  
      if (CreateIoCompletionPort((HANDLE) Accept, CompletionPort, (DWORD) PerHandleData,  
         0) == NULL)  
      \{  
         printf("CreateIoCompletionPort failed with error %d/n", GetLastError());  
         return;  
      \}  
  
      // Create per I/O socket information structure to associate with the  
      // WSARecv call below.  
  
      if ((PerIoData = (LPPER\_IO\_OPERATION\_DATA) GlobalAlloc(GPTR,          sizeof(PER\_IO\_OPERATION\_DATA))) == NULL)  
      \{  
         printf("GlobalAlloc() failed with error %d/n", GetLastError());  
         return;  
      \}  
  
      ZeroMemory(&(PerIoData->Overlapped), sizeof(OVERLAPPED));  
      PerIoData->BytesSEND = 0;  
      PerIoData->BytesRECV = 0;  
      PerIoData->DataBuf.len = DATA\_BUFSIZE;  
      PerIoData->DataBuf.buf = PerIoData->Buffer;  
  
      Flags = 0;  
      if (WSARecv(Accept, &(PerIoData->DataBuf), 1, &RecvBytes, &Flags,  
         &(PerIoData->Overlapped), NULL) == SOCKET\_ERROR)  
      \{  
         if (WSAGetLastError() != ERROR\_IO\_PENDING)  
         \{  
            printf("WSARecv() failed with error %d/n", WSAGetLastError());  
            return;  
         \}  
      \}  
   \}  
\}  
  
DWORD WINAPI ServerWorkerThread(LPVOID CompletionPortID)  
\{  
   HANDLE CompletionPort = (HANDLE) CompletionPortID;  
   DWORD BytesTransferred;  
   LPOVERLAPPED Overlapped;  
   LPPER\_HANDLE\_DATA PerHandleData;  
   LPPER\_IO\_OPERATION\_DATA PerIoData;  
   DWORD SendBytes, RecvBytes;  
   DWORD Flags;  
   
   while(TRUE)  
   \{  
   
      if (GetQueuedCompletionStatus(CompletionPort, &BytesTransferred,  
         (LPDWORD)&PerHandleData, (LPOVERLAPPED \*) &PerIoData, INFINITE) == 0)  
      \{  
         printf("GetQueuedCompletionStatus failed with error %d/n", GetLastError());  
         return 0;  
      \}  
  
  
      // First check to see if an error has occured on the socket and if so  
      // then close the socket and cleanup the SOCKET\_INFORMATION structure  
      // associated with the socket.  
  
      if (BytesTransferred == 0)  
      \{  
         printf("Closing socket %d/n", PerHandleData->Socket);  
  
         if (closesocket(PerHandleData->Socket) == SOCKET\_ERROR)  
         \{  
            printf("closesocket() failed with error %d/n", WSAGetLastError());  
            return 0;  
         \}  
  
         GlobalFree(PerHandleData);  
         GlobalFree(PerIoData);  
         continue;  
      \}  
  
      // Check to see if the BytesRECV field equals zero. If this is so, then  
      // this means a WSARecv call just completed so update the BytesRECV field  
      // with the BytesTransferred value from the completed WSARecv() call.  
  
      if (PerIoData->BytesRECV == 0)  
      \{  
         PerIoData->BytesRECV = BytesTransferred;  
         PerIoData->BytesSEND = 0;  
      \}  
      else  
      \{  
         PerIoData->BytesSEND += BytesTransferred;  
      \}  
  
      if (PerIoData->BytesRECV > PerIoData->BytesSEND)  
      \{  
  
         // Post another WSASend() request.  
         // Since WSASend() is not gauranteed to send all of the bytes requested,  
         // continue posting WSASend() calls until all received bytes are sent.  
  
         ZeroMemory(&(PerIoData->Overlapped), sizeof(OVERLAPPED));  
  
         PerIoData->DataBuf.buf = PerIoData->Buffer + PerIoData->BytesSEND;  
         PerIoData->DataBuf.len = PerIoData->BytesRECV - PerIoData->BytesSEND;  
  
         if (WSASend(PerHandleData->Socket, &(PerIoData->DataBuf), 1, &SendBytes, 0,  
            &(PerIoData->Overlapped), NULL) == SOCKET\_ERROR)  
         \{  
            if (WSAGetLastError() != ERROR\_IO\_PENDING)  
            \{  
               printf("WSASend() failed with error %d/n", WSAGetLastError());  
               return 0;  
            \}  
         \}  
      \}  
      else  
      \{  
         PerIoData->BytesRECV = 0;  
  
         // Now that there are no more bytes to send post another WSARecv() request.  
  
         Flags = 0;  
         ZeroMemory(&(PerIoData->Overlapped), sizeof(OVERLAPPED));  
  
         PerIoData->DataBuf.len = DATA\_BUFSIZE;  
         PerIoData->DataBuf.buf = PerIoData->Buffer;  
  
         if (WSARecv(PerHandleData->Socket, &(PerIoData->DataBuf), 1, &RecvBytes, &Flags,  
            &(PerIoData->Overlapped), NULL) == SOCKET\_ERROR)  
         \{  
            if (WSAGetLastError() != ERROR\_IO\_PENDING)  
            \{  
               printf("WSARecv() failed with error %d/n", WSAGetLastError());  
               return 0;  
            \}  
         \}  
      \}  
   \}  
\}