在vs2008中编译通过，vs2010应该也没有问题。
使用静态MFC dll。
其他配置保持默认即可。
可能需要设置/MTD运行时。
可以实现向指定客户端ip发送信息
（该客户端必须首先连接进服务器）
从指定客户端ip中取出数据。
我使用C++类进行了封装，
对各种异常进行了处理。
进行了较详细的注释，
如果有函数不清楚，可以去msdn上查一查。
1，客户端类
#pragma once
#define RECEIVE_SIZE 1024
/****************************************************
//Client
function :
save info of client
***************************************************/
class Client
{
public:
Client();
~Client();
public:
CCriticalSection m_cs;
BYTE m_pRemainBuf[RECEIVE_SIZE]; //数据缓存区
BYTE m_nDataLen; //数据缓冲区中已有数据的长度
BYTE m_pReceBuf[RECEIVE_SIZE]; //接受到的数据
OVERLAPPED m_OverLapped;
WSABUF m_DataBuf;
SOCKADDR_IN m_ClientAddress;
//[!if NET_TYPE_TCP]
SOCKET m_hClientSock; //communication socket;
//[!endif]
public:
//***********将数据存入Client对应的缓冲区中*******************
BOOL SetData(int len);
//***********从Client对应的缓冲区中取出数据*******************
int GetData(char * buff, int len);
};
实现：
#include "stdafx.h"
#include "Client.h"
/****************************************************************************
* Name
Client
* Type
public
* Function
construction function
* Return Value
null
* Parameters
null
*****************************************************************************/
Client::Client()
{
//[!if NET_TYPE_TCP]
m_hClientSock = INVALID_SOCKET;
//[!endif]
m_nDataLen = 0;
memset(m_pRemainBuf, 0, RECEIVE_SIZE);
memset(m_pReceBuf,0,RECEIVE_SIZE);
memset(&m_OverLapped, 0, sizeof(m_OverLapped));
}
/****************************************************************************
* Name
~Client
* Type
public
* Function
* Return Value
null
* Parameters
null
*****************************************************************************/
Client::~Client()
{
int a=0;
a=3;
}
//*********************TCP接受数据************************
//**************缓冲区没有溢出，则将数据追加其后**********
BOOL Client::SetData( int len )
{
if (len<0)
{
return FALSE;
}
if (len==0)
{
return TRUE;
}
m_cs.Lock();
if (m_nDataLen+len>=RECEIVE_SIZE)
{
if (len<RECEIVE_SIZE)
{
memcpy_s(m_pRemainBuf, RECEIVE_SIZE, m_pReceBuf, len);
m_nDataLen = len;
}
else
{
memcpy_s(m_pRemainBuf, RECEIVE_SIZE, m_pReceBuf, RECEIVE_SIZE);
m_nDataLen = (BYTE)RECEIVE_SIZE;
}
}
else
{
memcpy_s(m_pRemainBuf + m_nDataLen, RECEIVE_SIZE-m_nDataLen, m_pReceBuf, len);
m_nDataLen += len;
}
m_cs.Unlock();
return TRUE;
}
int Client::GetData( char * buff, int len )
{
if (!buff)
{
return 0;
}
int result=0;
m_cs.Lock();
if (m_nDataLen <= len)
{
memcpy_s(buff, len, m_pRemainBuf, m_nDataLen);
result = m_nDataLen;
m_nDataLen = 0;
}
else
{
memcpy_s(buff, len, m_pRemainBuf, len);
memmove_s(m_pRemainBuf, RECEIVE_SIZE, m_pRemainBuf + len, m_nDataLen-len);
m_nDataLen -= len;
result = len;
}
m_cs.Unlock();
return result;
}
2，TCP完成端口的封装
头文件：
/************************************************************************/
//* 文件名称: IOCP_TCP.h
//* 文件标示:
//* 摘 要:采用完成端口技术处理网络数据
//*
//* 当前版本:1.0
//* 作 者:hxy
//* 完成日期:2013-11-16
//*
/************************************************************************/
#ifndef _COMPLETIONPORT_H__
#define _COMPLETIONPORT_H__
#include <winsock2.h>
#include <mswsock.h>
#include "afxmt.h"
#include <vector>
#include "Client.h"
using namespace std;
#pragma once
#define MAXTHREAD_COUNT 8
#define RECEIVE_SIZE 1024
#define PORT 502
class Client;
class CompletionPort
{
public:
CompletionPort();
~CompletionPort();
//************初始化****************************
// 参数： 需要绑定的ip和port
// 功能： 初始化socket库
// 设置需要绑定的ip和port
//**********************************************
BOOL Init(char * lpszHostAddress, UINT nHostPort);
//************启动******************************
// 功能： 1,启动监听功能; 2,生成完成端口对象
//**********************************************
BOOL Active(void);
//************停止******************************
// 功能： 停止监听功能，
// 释放Active中的申请的所有资源
//**********************************************
BOOL Close(void);
//************接受数据**************************
// 功能： 接受指定客户端ip的数据
// 参数： buff：指向接受数据的缓冲区
// len: 缓冲区的大小
// ip: 客户端ip，如192.168.31.27
// 说明： buff的内存由调用者提供
//**********************************************
int ReceiveData(char * buff, int len, char * ip);
//************发送数据***************************
// 功能： 向指定的客户端ip的数据
// 参数： buff：指向发送数据的缓冲区
// len: 缓冲区的大小
// ip: 客户端ip，如192.168.31.27
//**********************************************
int SendData(const char * buff, int len, char * ip);
//-------------------------内部使用--------------------------------
//************监听*******************************
// 功能： 监听客户端连接线程
//***********************************************
void MonitorServerSocket();
//************监听客户端发送的数据***************
// 功能： 监听客户端连接线程函数
//***********************************************
void MonitorIoCompletionPort();
//************处理客户端连接*********************
// 功能： 客户端连接处理函数
//***********************************************
void OnClientAccept();
//************处理客户端关闭*********************
// 功能： 客户端关闭处理函数
//***********************************************
BOOL OnClientClose(DWORD dwSockId);
private:
//************初始化Socket库*********************
// 功能： 初始化Socket库
//***********************************************
BOOL InitWinsock();
void ProcessData(Client* pClient);
Client* GetClient(DWORD dwSockId, int& index);
//----------------------------Client 管理-------------------------
//************增加客户端*********************
BOOL AddClient( Client * const pClient);
//************删除客户端*********************
BOOL DeleteClient( int index);
//************查询客户端*********************
Client * GetClient( const char * ip);
private:
SOCKADDR_IN m_HostAddress; //服务器端地址（ip，port，协议）等
vector<Client*> m_ClientVector; //客户端表
rec_lock m_cs; //客户端表同步
BOOL m_bIsQuit; //退出标识
HANDLE m_hQuitEvent; //退出事件句柄
HANDLE m_hCOP; //完成端口句柄
HANDLE m_hThreadArray[MAXTHREAD_COUNT]; //接收数据线程句柄
int m_nThreadArray; //接收数据线程数量
HANDLE m_hListen; //监听连接线程句柄
SOCKET m_ListenSocket; //监听socket
BOOL m_bQuitThread; //监听线程退出标识
WSAEVENT m_wsaEvent; //网络事件
};
#endif
实现文件：
#include "StdAfx.h"
#include "IOCP_TCP.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/****************************************************************************
* Name
ThreadTcpServer
* Type
public
* Function
thread to monitor a socket and accept a link
* Return Value
DWORD WINAPI
* Parameters
void * lpParameter
*****************************************************************************/
DWORD WINAPI ThreadTcpServer(void * lpParameter)
{
CompletionPort* pCpPort = (CompletionPort*)lpParameter;
pCpPort->MonitorServerSocket();
return 0;
}
/****************************************************************************
* Name
CompletionRoutine
* Type
public
* Function
work thread of completionport
* Return Value
DWORD WINAPI
* Parameters
void * lpParameter translate a pointer of this
*****************************************************************************/
DWORD WINAPI CompletionRoutine(void * lpParameter)
{
CompletionPort* pCpPort = (CompletionPort*)lpParameter;
pCpPort->MonitorIoCompletionPort();
return 0;
}
/****************************************************************************
* Name
CompletionPort
* Type
public
* Function
constructor
* Return Value
null
* Parameters
null
*****************************************************************************/
CompletionPort::CompletionPort()
{
//_CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF| _CRTDBG_LEAK_CHECK_DF);
m_hCOP = INVALID_HANDLE_VALUE;
m_hListen = INVALID_HANDLE_VALUE;
for (int i=0; i< MAXTHREAD_COUNT; i++)
{
m_hThreadArray[i] = INVALID_HANDLE_VALUE;
}
m_bQuitThread = FALSE;
m_wsaEvent = NULL;
m_ListenSocket = INVALID_SOCKET;
m_ClientVector.clear();
m_bIsQuit = FALSE;
m_hQuitEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
m_nThreadArray = 0;
}
/****************************************************************************
* Name
~CompletionPort
* Type
public
* Function
do sth to release memory
* Return Value
null
* Parameters
null
*****************************************************************************/
CompletionPort::~CompletionPort()
{
int i = 0;
m_bIsQuit = TRUE;
Sleep(10);
if (INVALID_HANDLE_VALUE != m_hCOP)
{
m_bIsQuit = TRUE;
//等待所有接受数据的线程结束
WaitForMultipleObjects(m_nThreadArray, m_hThreadArray, TRUE, INFINITE);
while (INVALID_HANDLE_VALUE != m_hThreadArray[i])
{
CloseHandle(m_hThreadArray[i]);
m_hThreadArray[i-1] = INVALID_HANDLE_VALUE;
i++;
}
//关闭完成端口
CloseHandle(m_hCOP);
m_hCOP=NULL;
}
// 关闭监听socket
if (INVALID_SOCKET != m_ListenSocket)
{
closesocket(m_ListenSocket);
m_ListenSocket = NULL;
}
// 关闭监听线程
m_bQuitThread = TRUE;
WaitForSingleObject(m_hListen, INFINITE);
if (INVALID_HANDLE_VALUE != m_hListen)
{
CloseHandle(m_hListen);
m_hListen = NULL;
}
WSACloseEvent(m_wsaEvent);
m_wsaEvent = NULL;
// 关闭客户端连接socket
for( size_t i=0; i<m_ClientVector.size(); i++)
{
Client* pClient = m_ClientVector[i];
if( pClient != NULL)
{
if (pClient->m_hClientSock != INVALID_SOCKET)
{
shutdown(pClient->m_hClientSock, 2);
closesocket(pClient->m_hClientSock);
pClient->m_hClientSock = INVALID_SOCKET;
}
delete pClient;
pClient = NULL;
}
}
CloseHandle(m_hQuitEvent);
m_ClientVector.clear();
}
BOOL CompletionPort::Init(char * lpszHostAddress, UINT nHostPort)
{
if (!InitWinsock())
{
return FALSE;
}
m_HostAddress.sin_family = AF_INET;
m_HostAddress.sin_addr.s_addr = inet_addr((char *)lpszHostAddress);
if (m_HostAddress.sin_addr.s_addr == INADDR_NONE)
{
LPHOSTENT lphost;
lphost = gethostbyname((char *)lpszHostAddress);
if (lphost != NULL)
m_HostAddress.sin_addr.s_addr = ((LPIN_ADDR)lphost->h_addr)->s_addr;
else
{
WSASetLastError(WSAEINVAL);
return FALSE;
}
}
m_HostAddress.sin_port = htons((u_short)nHostPort);
return true;
}
//************启动******************************
// 功能： 启动监听功能
//**********************************************
BOOL CompletionPort::Active()
{
//-------------------------------监听连接---------------------------------------
//创建监听Socket
m_ListenSocket = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_IP, NULL, 0, WSA_FLAG_OVERLAPPED);
if (INVALID_SOCKET == m_ListenSocket)
{
return FALSE;
}
int nResult = bind(m_ListenSocket, (PSOCKADDR)&m_HostAddress, sizeof(m_HostAddress));
if (SOCKET_ERROR == nResult)
{
closesocket(m_ListenSocket);
return FALSE;
}
nResult = listen(m_ListenSocket, 20);
if (SOCKET_ERROR == nResult)
{
closesocket(m_ListenSocket);
return FALSE;
}
m_wsaEvent = WSACreateEvent();
if (NULL == m_wsaEvent)
{
return FALSE;
}
WSAEventSelect(m_ListenSocket, m_wsaEvent, FD_ACCEPT);
//创建监听连接的线程
m_hListen = CreateThread(NULL, 0, ThreadTcpServer, (LPVOID)this, 0, NULL);
if (NULL == m_hListen)
{
return FALSE;
}
//-------------------------------完成端口---------------------------------------
//创建完成端口句柄
m_hCOP = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, NULL, 0);
if (NULL == m_hCOP)
{
return FALSE;
}
//创建处理数据的线程
SYSTEM_INFO SysInfo;
GetSystemInfo(&SysInfo);
for (int i=0; i<(int)SysInfo.dwNumberOfProcessors && (i<MAXTHREAD_COUNT); i++)
{
m_hThreadArray[i] = CreateThread(NULL, 0, CompletionRoutine, (LPVOID)this, 0, NULL);
if (NULL == m_hThreadArray[i])
{
while (i>0)
{
CloseHandle(m_hThreadArray[i-1]);
m_hThreadArray[i-1] = INVALID_HANDLE_VALUE;
i--;
}
return FALSE;
}
m_nThreadArray ++;
}
return TRUE;
}
//************从完成端口取数据******************
// 功能： 从完成端口取数据
// 返回： 字节数，如果ip未连接则返回0
//**********************************************
int CompletionPort::ReceiveData(char * buff, int len, char * ip)
{
if (!buff || !ip)
{
return 0;
}
Client * pClient = GetClient(ip);
if (!pClient)
{
return 0;
}
return pClient->GetData(buff, len);
}
//************发送数据***************************
// 功能： 向指定的客户端ip的数据
// 参数： buff：指向发送数据的缓冲区
// len: 要发送的数据的字节数
// ip: 客户端ip，如192.168.31.27
// 返回： 发送的字节数，错误则返回0
//**********************************************
int CompletionPort::SendData(const char * buff, int len, char * ip)
{
if (!buff || !ip)
{
return 0;
}
int ret =0;
//在取得客户端指针之后，完成端口线程会删除该客户端，
//可能造成最null指针的解引用，所有这里使用结构化异常进行处理
__try
{
Client * pClient = GetClient(ip);
if (!pClient)
{
return 0;
}
DWORD result = 0;
ret =send(pClient->m_hClientSock, buff, len, 0);
//int ret = WriteFile((HANDLE)pClient->m_hClientSock, buff, len, &result, NULL);
}
__except (EXCEPTION_EXECUTE_HANDLER)
{
printf("客户端已被删除，发送失败");
}
return ret;
}
/****************************************************************************
* Name
InitWinsock
* Type
public
* Function
initialize socket
* Return Value
BOOL
* Parameters
null
*****************************************************************************/
BOOL CompletionPort::InitWinsock()
{
WSADATA wsd;
int nResult = WSAStartup(MAKEWORD(2,2), &wsd);
if (0 != nResult)
{
return FALSE;
}
return TRUE;
}
/****************************************************************************
* Name
MonitorServerSocket
* Type
public
* Function
function to monitor a socket and accept a link
* Return Value
null
* Parameters
null
*****************************************************************************/
void CompletionPort::MonitorServerSocket()
{
DWORD dwWaitCode;
WSANETWORKEVENTS wsaNetWorkEvents;
while( true )
{
if( m_bQuitThread ) //判断监听线程退出条件是否满足
{
SetEvent(m_hQuitEvent);
TRACE("Monitor Server Quit\n");
return ;
}
dwWaitCode = WSAWaitForMultipleEvents(1, &m_wsaEvent, FALSE, 2000, FALSE);//等待网络事件
if(dwWaitCode != WAIT_OBJECT_0)
continue;
if( SOCKET_ERROR == WSAEnumNetworkEvents(m_ListenSocket, m_wsaEvent,&wsaNetWorkEvents ))//枚举网络事件
{
int nErrorCode = WSAGetLastError();
TRACE("WSAEnumNetworkEvents Error");
}
else
{
if( wsaNetWorkEvents.lNetworkEvents & FD_ACCEPT)
{
OnClientAccept();
}
}
}
}
/****************************************************************************
* Name
OnClientAccept
* Type
public
* Function
function to monitor a socket and accept a link
* Return Value
null
* Parameters
null
*****************************************************************************/
void CompletionPort::OnClientAccept()
{
int nSockAddrLength = sizeof(SOCKADDR_IN);
Client* pClntData = new Client();
pClntData->m_hClientSock = accept(m_ListenSocket,
(struct sockaddr*)&(pClntData->m_ClientAddress),
&nSockAddrLength);
if (INVALID_SOCKET == pClntData->m_hClientSock)
{
delete pClntData;
}
AddClient(pClntData);
HANDLE hCompletePort = CreateIoCompletionPort((HANDLE)pClntData->m_hClientSock, m_hCOP,
(DWORD)pClntData->m_hClientSock,0);
if( hCompletePort != m_hCOP)
{
TRACE("Create Communication CompletionPort failure!\n");
}
ReadFile((HANDLE)pClntData->m_hClientSock, pClntData->m_pReceBuf, RECEIVE_SIZE, NULL,
&pClntData->m_OverLapped);
}
/****************************************************************************
* Name
MonitorIoCompletionPort
* Type
public
* Function
function to monitor completionport
* Return Value
void
* Parameters
null
*****************************************************************************/
void CompletionPort::MonitorIoCompletionPort()
{
TRACE("Begin Monitor IoPort \n");
BOOL bSuc = FALSE;
DWORD dwNumBytes = 0;
DWORD dwKey = -1;
DWORD dwSockId = 0;
LPOVERLAPPED completedOverlapped;
int nLen =0;
while( true )
{
//判断监听线程退出条件是否满足
if( m_bIsQuit)
{
TRACE("Monitor IoCompletionPort Quit\n");
SetEvent(m_hQuitEvent);
return;
}
//查询完全端口状态
dwKey = -1;
bSuc = GetQueuedCompletionStatus( m_hCOP, &dwNumBytes, &dwKey, &completedOverlapped, 2000);
if (bSuc==FALSE)
{
int nError = WSAGetLastError();
if (nError == WSA_WAIT_TIMEOUT)
{
continue;
}
if (nError == ERROR_NETNAME_DELETED)
{
OnClientClose(dwKey);
continue;
}
TRACE("GetQueuedCompletionStatus Error: %d\n", nError);
continue;
}
if (dwKey>0)
{
dwSockId = dwKey;
nLen = dwNumBytes;
if( nLen > 0)
{
int index = -1;
Client* pClient = GetClient(dwSockId, index);
if( pClient == NULL)
continue;
try
{
//Sleep(50);
if (nLen >1024)
{
nLen = 1024;
//CDebug::ShowErroMessage("接收到数据长度过长！");
}
pClient->SetData(nLen);
//ProcessData(pClient);
//向完全端口发送读指令，等待下一次数据
ZeroMemory(pClient->m_pReceBuf,RECEIVE_SIZE);
ReadFile((HANDLE)pClient->m_hClientSock,pClient->m_pReceBuf,RECEIVE_SIZE,NULL,&pClient->m_OverLapped);
}
catch(...)
{
TRACE("catch an error");
}
}
else
{
OnClientClose(dwSockId);
}
}
}
}
/****************************************************************************
* Name
GetClient
* Type
public
* Function
get a pointer to point class of Client
* Return Value
Client*
* Parameters
DWORD dwSockId : socket ID
int& index: the position in the vector
*****************************************************************************/
Client* CompletionPort::GetClient(DWORD dwSockId, int& index)
{
Client* pNewData = NULL;
m_cs.lock();
for (size_t i = 0; i < m_ClientVector.size(); i++)
{
if (m_ClientVector[i]->m_hClientSock == dwSockId)
{
index = i;
pNewData = m_ClientVector[i];
break;
}
}
m_cs.unlock();
return pNewData;
}
/****************************************************************************
* Name
OnClientClose
* Type
public
* Function
close the socket that dont translate data
* Return Value
BOOL
* Parameters
DWORD dwSockId: socket ID
*****************************************************************************/
BOOL CompletionPort::OnClientClose(DWORD dwSockId)
{
int index = -1;
Client* pClient = GetClient(dwSockId, index);
if ((NULL != pClient) && (-1 != index))
{
closesocket(pClient->m_hClientSock);
DeleteClient(index);
pClient = NULL;
}
return TRUE;
}
//----------------------------Client 管理-------------------------
//************增加客户端*********************
BOOL CompletionPort::AddClient(Client * const pClient)
{
if (!pClient)
{
return FALSE;
}
m_cs.lock();
m_ClientVector.push_back(pClient);
m_cs.unlock();
return TRUE;
}
//************删除客户端*********************
BOOL CompletionPort::DeleteClient(int index)
{
m_cs.lock();
delete m_ClientVector[index];
m_ClientVector.erase(m_ClientVector.begin() + index);
m_cs.unlock();
return TRUE;
}
//************查询客户端*********************
Client * CompletionPort::GetClient(const char * ip)
{
Client* pNewClient = NULL;
ULONG nAddr = inet_addr(ip);
m_cs.lock();
for (size_t i = 0; i < m_ClientVector.size(); i++)
{
if (m_ClientVector[i]->m_ClientAddress.sin_addr.s_addr == nAddr)
{
pNewClient = m_ClientVector[i];
break;
}
}
m_cs.unlock();
return pNewClient;
}
3，测试文件：
// IOCPTest.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include "IOCP_TCP.h"
#include <iostream>
int _tmain(int argc, _TCHAR* argv[])
{
CCriticalSection *p = new CCriticalSection;
delete p;
CompletionPort * cp = new CompletionPort();
cp->Init("192.168.31.27", 4567); //需要修改为自己的ip
cp->Active();
char buff[1024]={0};
char recBuff[1024]={0};
int len;
while (true)
{
scanf_s("%s", buff, 1023);
len = strlen(buff);
cp->SendData(buff, len, "192.168.31.27"); //客户端的ip
ZeroMemory(recBuff,1024);
cp->ReceiveData(recBuff, 1024, "192.168.31.27"); //客户端的ip
printf("\n%s\n", recBuff);
}
delete cp;
return 0;
}
5，预编译头文件
// stdafx.h : include file for standard system include files,
// or project specific include files that are used frequently, but
// are changed infrequently
//
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#define _WIN32_WINNT 0x0501
#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers
#include <afxwin.h> // MFC core and standard components
#include <afxext.h> // MFC extensions
#ifndef _AFX_NO_OLE_SUPPORT
#include <afxole.h> // MFC OLE classes
#include <afxodlgs.h> // MFC OLE dialog classes
#include <afxdisp.h> // MFC Automation classes
#endif // _AFX_NO_OLE_SUPPORT
#ifndef _AFX_NO_DB_SUPPORT
#include <afxdb.h> // MFC ODBC database classes
#endif // _AFX_NO_DB_SUPPORT
#ifndef _AFX_NO_DAO_SUPPORT
#include <afxdao.h> // MFC DAO database classes
#endif // _AFX_NO_DAO_SUPPORT
#include <afxdtctl.h> // MFC support for Internet Explorer 4 Common Controls
#ifndef _AFX_NO_AFXCMN_SUPPORT
#include <afxcmn.h> // MFC support for Windows Common Controls
#endif // _AFX_NO_AFXCMN_SUPPORT
//外部库文件引用
#include <afxmt.h>
#include <afx.h>
#include <afxtempl.h>
#include <winsock2.h>
#include <memory>
//外部自定义头文件引用
//#include "Resource.h"
//#include "ICOMPro.h"
//#include "datatype.h"
//#include "Reg.h"
//#include "Debug.h"
//#include "Helper.h"
#if defined(_WIN32_WCE_CEPC) || defined(_ARM_)
#include "AtomCE.h"
#endif
//编译选项
//[!if TRYCONNECT_TRUE]
//#define _TRYCONNECT_TRUE
//[!endif]
//
//[!if TRYCONNECT_USERDEFINE]
//#define _TRYCONNECT_USEDEFINE
//[!endif]
//
//[!if TRYCONNECT_USEPACKET]
//#define _TRYCONNECT_USEPACKET
//[!endif]
//
//[!if REOPENCOM]
//#define _REOPENCOM
//[!endif]
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#include "lock.h"