[笔记]windows网络编程之常见模型（上）

// OverlappedServer.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <stdlib.h>
#include "winsock2.h"
#pragma   comment(lib,"ws2_32.lib")
#define DATA_BUFSIZE 4096
int _tmain(int argc, _TCHAR* argv[])
{
  //-----------------------------------------
  // 声明和初始化变量
  WSABUF DataBuf;             // 发送和接收数据的缓冲区结构体
  char buffer[DATA_BUFSIZE];      // 缓冲区结构体DataBuf中
  DWORD EventTotal = 0,         // 记录事件对象数组中的数据
    RecvBytes = 0,                // 接收的字节数
    Flags = 0,                    // 标识位
    BytesTransferred = 0;         // 在读、写操作中实际传输的字节数
  // 数组对象数组
  WSAEVENT EventArray[WSA_MAXIMUM_WAIT_EVENTS];
  WSAOVERLAPPED AcceptOverlapped;   // 重叠结构体
  SOCKET ListenSocket, AcceptSocket;    // 监听套接字和与客户端进行通信的套接字
  //-----------------------------------------
  // 初始化Windows Sockets
  WSADATA wsaData;
  WSAStartup(MAKEWORD(2,2), &wsaData);
  //-----------------------------------------
  // 创建监听套接字，并将其绑定到本地IP地址和9990端口
  ListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  u_short port = 9990;
  char* ip;
  sockaddr_in service;
  service.sin_family = AF_INET;
  service.sin_port = htons(port);
  hostent* thisHost;
  thisHost = gethostbyname("");
  ip = inet_ntoa (*(struct in_addr *)*thisHost->h_addr_list); 
  service.sin_addr.s_addr = inet_addr(ip);
  bind(ListenSocket, (SOCKADDR *) &service, sizeof(SOCKADDR));
  //-----------------------------------------
  // 开始监听
  listen(ListenSocket, 1);
  printf("Listening...\n");
  //-----------------------------------------
  // 接收连接请求
  AcceptSocket = accept(ListenSocket, NULL, NULL);
  printf("Client Accepted...\n");
  //-----------------------------------------
  // 创建事件对象，建立重叠结构
  EventArray[EventTotal] = WSACreateEvent();
  ZeroMemory(buffer, DATA_BUFSIZE);
  ZeroMemory(&AcceptOverlapped, sizeof(WSAOVERLAPPED));   // 初始化重叠结构
  AcceptOverlapped.hEvent = EventArray[EventTotal];         // 设置重叠结构中的hEvent字段
  DataBuf.len = DATA_BUFSIZE;                           // 设置缓冲区
  DataBuf.buf = buffer;
  EventTotal++;                                       // 事件对象总数加1
  //-----------------------------------------
  // 处理在套接字上接收到数据
  while (1) {
    DWORD Index;    // 保存处于授信状态的事件对象句柄
    //-----------------------------------------
    // 调用WSARecv()函数在AcceptSocket套接字上以重叠I/O方式接收数据，保存到DataBuf缓冲区中
    if (WSARecv(AcceptSocket, &DataBuf, 1, &RecvBytes, &Flags, &AcceptOverlapped, NULL) == SOCKET_ERROR) {
      if (WSAGetLastError() != WSA_IO_PENDING)
        printf("Error occured at WSARecv()\n");
    }
    //-----------------------------------------
    // 等待完成的重叠I/O调用
    Index = WSAWaitForMultipleEvents(EventTotal, EventArray, FALSE, WSA_INFINITE, FALSE);
    //-----------------------------------------
    // 决定重叠事件的状态
    WSAGetOverlappedResult(AcceptSocket, &AcceptOverlapped, &BytesTransferred, FALSE, &Flags);
    //-----------------------------------------
    // 如果连接已经关闭，则关闭AcceptSocket套接字
    if (BytesTransferred == 0) {
      printf("Closing Socket %d\n", AcceptSocket);
      closesocket(AcceptSocket);
      WSACloseEvent(EventArray[Index - WSA_WAIT_EVENT_0]);
      return -1;
    }
    //-----------------------------------------
    // 如果有数据到达，则将收到的数据则发送回客户端
    if (WSASend(AcceptSocket, &DataBuf, 1, &RecvBytes, Flags, &AcceptOverlapped, NULL) == SOCKET_ERROR)
      printf("WSASend() is busted\n");
    //-----------------------------------------
    // 重置已授信的事件对象
    WSAResetEvent(EventArray[Index - WSA_WAIT_EVENT_0]);
    //-----------------------------------------   
    // 重置Flags变量和重叠结构
    Flags = 0;
    ZeroMemory(&AcceptOverlapped, sizeof(WSAOVERLAPPED));
    ZeroMemory(buffer, DATA_BUFSIZE);
    AcceptOverlapped.hEvent = EventArray[Index - WSA_WAIT_EVENT_0];
    //-----------------------------------------
    // 重置缓冲区
    DataBuf.len = DATA_BUFSIZE;
    DataBuf.buf = buffer;
  }
  system("pause");
  return 0;
}

// CompletionRoutineServer.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <winsock2.h> 
#include <stdio.h> 
#define PORT 9990       // 监听的端口
#define MSGSIZE 1024    // 发送和接收消息的最大长度
# pragma comment( lib, "ws2_32.lib" ) 
// I/O操作的数据
typedef struct 
{ 
  WSAOVERLAPPED overlap;        // 重叠结构体
  WSABUF Buffer;                // 缓冲区对象
  char szMessage[MSGSIZE] ;     // 缓冲区字符数组
  DWORD NumberOfBytesRecvd;   // 接收字节数
  DWORD Flags;                  // 标识位
  SOCKET sClient;               // 套接字
} PER_IO_OPERATION_DATA, * LPPER_IO_OPERATION_DATA; 
// 工作线程，用于接收用户数据
DWORD WINAPI WorkerThread( LPVOID); 
// 在工作线程中调用WSARecv()函数接收数据时指定的完成例程函数
void CALLBACK CompletionROUTINE( DWORD, DWORD, LPWSAOVERLAPPED, DWORD);
SOCKET g_sNewClientConnection;          // 接收客户端连接请求后得到的
BOOL g_bNewConnectionArrived = FALSE ;    // 标识是否存在未经WorkerThread()函数处理的新的连接
int _tmain(int argc, _TCHAR* argv[])
{
  WSADATA wsaData;                    // Windows Sockets对象
  SOCKET sListen;                     // 与客户端进行通信的套接字
  SOCKADDR_IN local, client;              // 服务器本地地址和客户端地址
  DWORD dwThreadId;                 // 工作线程的线程ID
  int iaddrSize = sizeof(SOCKADDR_IN) ;   // 地址的大小  
  // 初始化Windows Socket环境
  WSAStartup( 0x0202, & wsaData) ; 
  // 创建监听套接字
  sListen = socket ( AF_INET , SOCK_STREAM , IPPROTO_TCP ) ; 
  // 绑定
  local.sin_addr. S_un. S_addr = htonl(INADDR_ANY); 
  local.sin_family = AF_INET ; 
  local.sin_port = htons ( PORT) ; 
  bind(sListen, (struct sockaddr *)&local, sizeof(SOCKADDR_IN)) ; 
  // 监听
  listen(sListen, 3) ; 
  // 创建工作线程
  CreateThread( NULL , 0, WorkerThread, NULL , 0, & dwThreadId) ; 
  // 循环处理来自客户端的连接请求
  while(TRUE) 
  { 
    // 接收连接，得到与客户端进行通信的套接字g_sNewClientConnection
    g_sNewClientConnection = accept(sListen, (struct sockaddr *)&client, &iaddrSize) ; 
    // 标识有新的连接
    g_bNewConnectionArrived = TRUE ; 
    // 打印接入的客户端
    printf("Accepted client:%s:%d\n", inet_ntoa(client.sin_addr), ntohs(client. sin_port)); 
  } 
} 
// 工作线程
DWORD WINAPI WorkerThread( LPVOID lpParam) 
{ 
  LPPER_IO_OPERATION_DATA lpPerIOData = NULL;   // 保存I/O操作的数据
  while (TRUE) 
  { 
    if ( g_bNewConnectionArrived)   // 如果有新的连接请求
    { 
      // 为新的连接执行一个异步操作
      // 为LPPER_IO_OPERATION_DATA结构体分配堆空间
      lpPerIOData = (LPPER_IO_OPERATION_DATA) HeapAlloc( 
        GetProcessHeap( ), 
        HEAP_ZERO_MEMORY, 
        sizeof (PER_IO_OPERATION_DATA)) ; 
      // 初始化结构体lpPerIOData
      lpPerIOData->Buffer.len = MSGSIZE; 
      lpPerIOData->Buffer.buf = lpPerIOData->szMessage; 
      lpPerIOData->sClient = g_sNewClientConnection; 
      // 接收数据
      WSARecv( lpPerIOData->sClient,          // 接收数据的套接字
        &lpPerIOData->Buffer,               // 接收数据的缓冲区
        1,                                // 缓冲区对象的数量
        &lpPerIOData->NumberOfBytesRecvd,   // 接收数据的字节数
        &lpPerIOData->Flags,                // 标识位
        &lpPerIOData->overlap,              // 重叠结构
        CompletionROUTINE) ;                // 完成例程函数，将会在接收数据完成的时候进行相应的调用 
      g_bNewConnectionArrived = FALSE ;     // 标识新的连接已经处理完成
    } 
    SleepEx(1000, TRUE) ;                   // 休息1秒钟，然后继续
  } 
  return 0; 
} 
// 完成例程函数
void CALLBACK CompletionROUTINE( DWORD dwError, // 重叠操作的完成状态
        DWORD cbTransferred,                      // 发送的字节数
        LPWSAOVERLAPPED lpOverlapped,             // 指定重叠操作的结构体
        DWORD dwFlags)                            // 标识位
{ 
  // 将LPWSAOVERLAPPED类型的lpOverlapped转化成了LPPER_IO_OPERATION_DATA
  LPPER_IO_OPERATION_DATA lpPerIOData = ( LPPER_IO_OPERATION_DATA) lpOverlapped;
  // 如果发生错误或者没有数据传输，则关闭套接字，释放资源
  if (dwError != 0 || cbTransferred == 0)   
  { 
    closesocket( lpPerIOData-> sClient) ; 
    HeapFree( GetProcessHeap(), 0, lpPerIOData) ; 
  } 
  else 
  { 
    lpPerIOData->szMessage[cbTransferred] = '\0';   // 标识接收数据的结束
    // 向客户端发送接收到的数据
    send(lpPerIOData->sClient, lpPerIOData->szMessage, cbTransferred, 0) ; 
    // 执行另一个异步操作，接收数据
    memset (&lpPerIOData->overlap, 0, sizeof(WSAOVERLAPPED)); 
    lpPerIOData->Buffer.len = MSGSIZE; 
    lpPerIOData->Buffer.buf = lpPerIOData->szMessage; 
    // 接收数据
    WSARecv( lpPerIOData->sClient, 
            &lpPerIOData->Buffer, 
            1, 
            &lpPerIOData->NumberOfBytesRecvd, 
            &lpPerIOData->Flags, 
            &lpPerIOData->overlap, 
            CompletionROUTINE); 
  } 
}