MFC对WinSockt API的封装

MFC提供了两个类CAsyncSocket和CSocket来封装WinSock API，这给程序员提供了一个更简单的网络编程接口。

CAsyncSocket在较低层次上封装了WinSock API，缺省情况下，使用该类创建的socket是非阻塞的socket，所有操作都会立即返回，如果没有得到结果，返回WSAEWOULDBLOCK，表示是一个阻塞操作。

CSocket建立在CAsyncSocket的基础上，是CAsyncSocket的派生类。也就是缺省情况下使用该类创建的socket是非阻塞的socket，但是CSocket的网络I/O是阻塞的，它在完成任务之后才返回。CSocket的阻塞不是建立在“阻塞”socket的基础上，而是在“非阻塞”socket上实现的阻塞操作，在阻塞期间，CSocket实现了本线程的消息循环，因此，虽然是阻塞操作，但是并不影响消息循环，即用户仍然可以和程序交互。

 

CAsyncSocket

CAsyncSocket封装了低层的WinSock API，其成员变量m_hSocket保存其对应的socket句柄。使用CAsyncSocket的方法如下：

首先，在堆或者栈中构造一个CAsyncSocket对象，例如：

CAsyncSocket sock；或者CAsyncSocket *pSock = new CAsyncSocket；

其次，调用Create创建socket，例如：

使用缺省参数创建一个面向连接的socket

sock.Create()

指定参数参数创建一个使用数据报的socket，本地端口为30

pSocket.Create(30, SOCK_DGRM)；

其三，如果是客户程序，使用Connect连接到远地；如果是服务程序，使用Listen监听远地的连接请求。

其四，使用成员函数进行网络I/O。

最后，销毁CAsyncSocket，析构函数调用Close成员函数关闭socket。

 

下面，分析CAsyncSocket的几个函数，从中可以看到它是如何封装低层的WinSock API，简化有关操作的；还可以看到它是如何实现非阻塞的socket和非阻塞操作。

socket对象的创建和捆绑

（1）Create函数

首先，分析socket句柄如何被创建并和CAsyncSocket对象关联。Create的实现如下：

BOOL CAsyncSocket::Create(UINT nSocketPort, int nSocketType, long lEvent, LPCTSTR lpszSocketAddress)

{

if (Socket(nSocketType, lEvent))

{

if (Bind(nSocketPort,lpszSocketAddress))

return TRUE;

int nResult = GetLastError();

Close();

WSASetLastError(nResult);

}

return FALSE;

}

其中：

参数1表示本socket的端口，缺省是0，如果要创建数据报的socket，则必须指定一个端口号。

参数2表示本socket的类型，缺省是SOCK_STREAM，表示面向连接类型。

参数3是屏蔽位，表示希望对本socket监测的事件，缺省是FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE。

参数4表示本socket的IP地址字符串，缺省是NULL。

Create调用Socket函数创建一个socket，并把它捆绑在this所指对象上，监测指定的网络事件。参数2和3被传递给Socket函数，如果希望创建数据报的socket，不要使用缺省参数，指定参数2是SOCK_DGRM。

如果上一步骤成功，则调用bind给新的socket分配端口和IP地址。

 

（2）Socket函数

BOOL CAsyncSocket::Socket(int nSocketType, long lEvent, int nProtocolType, int nAddressFormat)

{

ASSERT(m_hSocket == INVALID_SOCKET);

m_hSocket = socket(nAddressFormat,nSocketType,nProtocolType);

if (m_hSocket != INVALID_SOCKET)

{

CAsyncSocket::AttachHandle(m_hSocket, this, FALSE);

return AsyncSelect(lEvent);

}

return FALSE;

}

其中：

参数1表示Socket类型，缺省值是SOCK_STREAM。

参数2表示希望监测的网络事件，缺省值同Create，指定了全部事件。

参数3表示使用的协议，缺省是0。实际上，SOCK_STREAM类型的socket使用TCP协议，SOCK_DGRM的socket则使用UDP协议。

参数4表示地址族（地址格式），缺省值是PF_INET（等同于AF_INET）。对于TCP/IP来说，协议族和地址族是同值的。

在socket没有被创建之前，成员变量m_hSocket是一个无效的socket句柄。Socket函数把协议族、socket类型、使用的协议等信息传递给WinSock API函数socket，创建一个socket。如果创建成功，则把它捆绑在this所指对象。

 

（3）捆绑（Attatch）

捆绑过程类似于其他Windows对象，将在模块线程状态的WinSock映射中添加一对新的映射：this所指对象和新创建的socket对象的映射。

另外，如果本模块线程状态的“socket窗口”没有创建，则创建一个，该窗口在异步操作时用来接收WinSock的通知消息，窗口句柄保存到模块线程状态的m_hSocketWindow变量中。函数AsyncSelect将指定该窗口为网络事件消息的接收窗口。

 

（4）指定要监测的网络事件

在捆绑完成之后，调用AsyncSelect指定新创建的socket将监测的网络事件。AsyncSelect实现如下：

BOOL CAsyncSocket::AsyncSelect(long lEvent)

{

ASSERT(m_hSocket != INVALID_SOCKET);

_AFX_SOCK_THREAD_STATE* pState = _afxSockThreadState;

ASSERT(pState->m_hSocketWindow != NULL);

return WSAAsyncSelect(m_hSocket, pState->m_hSocketWindow,

WM_SOCKET_NOTIFY, lEvent) != SOCKET_ERROR;

}

函数参数lEvent表示希望监视的网络事件。

_ afxSockThreadState得到的是当前的模块线程状态，m_ hSocketWindow是本模块在当前线程的“socket窗口”，指定监视m_hSocket 的网络事件，如指定事件发生，给窗口m_hSocketWindow发送WM_SOCKET_NOTIFY消息。被指定的网络事件对应的网络I/O将是异 步操作，是非阻塞操作。例如：指定FR_READ导致Receive是一个异步操作，如果不能立即读到数据，则返回一个错误 WSAEWOULDBLOCK。在数据到达之后，WinSock通知窗口m_hSocketWindow，导致OnReceive被调用。

指定FR_WRITE导致Send是一个异步操作，即使数据没有送出也返回一个错误WSAEWOULDBLOCK。在数据可以发送之后，WinSock通知窗口m_hSocketWindow，导致OnSend被调用。

指定FR_CONNECT导致Connect是一个异步操作，还没有连接上就返回错误信息WSAEWOULDBLOCK，在连接完成之后，WinSock通知窗口m_hSocketWindow，导致OnConnect被调用。

所以，使用CAsyncSocket时，如果使用Create缺省创建socket，则所有网络I/O都是异步操作，进行有关网络I/O时则必须覆盖以下的相关函数：

OnAccept、OnClose、OnConnect、OnOutOfBandData、OnReceive、OnSend。

 

（5）Bind函数

经过上述过程，socket创建完毕，下面，调用Bind函数给m_hSocket指定本地端口和IP地址。Bind的实现如下：

BOOL CAsyncSocket::Bind(UINT nSocketPort, LPCTSTR lpszSocketAddress)

{

USES_CONVERSION;

//使用WinSock的地址结构构造地址信息

SOCKADDR_IN sockAddr;

memset(&sockAddr,0,sizeof(sockAddr));

//得到地址参数的值

LPSTR lpszAscii = T2A((LPTSTR)lpszSocketAddress);

//指定是Internet地址类型

sockAddr.sin_family = AF_INET;

if (lpszAscii == NULL)

//没有指定地址，则自动得到一个本地IP地址

//把32比特的数据从主机字节序转换成网络字节序

sockAddr.sin_addr.s_addr = htonl(INADDR_ANY);

else

{

//得到地址

DWORD lResult = inet_addr(lpszAscii);

if (lResult == INADDR_NONE)

{

WSASetLastError(WSAEINVAL);

return FALSE;

}

sockAddr.sin_addr.s_addr = lResult;

}

//如果端口为0，则WinSock分配一个端口（1024—5000）

//把16比特的数据从主机字节序转换成网络字节序

sockAddr.sin_port = htons((u_short)nSocketPort);

//Bind调用WinSock API函数bind

return Bind((SOCKADDR*)&sockAddr, sizeof(sockAddr));

}

其中：函数参数1指定了端口；参数2指定了一个包含本地地址的字符串，缺省是NULL。

函数Bind 首先使用结构SOCKADDR_IN构造地址信息。该结构的域sin_family表示地址格式（TCP/IP同协议族），赋值为AF_INET （Internet地址格式）；域sin_port表示端口，如果参数1为0，则WinSock分配一个端口给它，范围在1024和5000之间；域 sin_addr是表示地址信息，它是一个联合体，其中s_addr表示如下形式的字符串，“28.56.22.8”。如果参数没有指定地址，则WinSock自动地得到本地IP地址（如果有几个网卡，则使用其中一个的地址）。

 

（6）总结Create的过程

首先，调用socket函数创建一个socket；然后把创建的socket对象映射到CAsyncSocket对象（捆绑在一起），指定本socket要通知的网络事件，并创建一个“socket窗口”来接收网络事件消息，最后，指定socket的本地信息。

下一步，是使用成员函数Connect 连接远地主机，配置socket的远地信息。函数Connect类似于Bind，把指定的远地地址转换成SOCKADDR_IN对象表示的地址信息（包括 网络字节序的转换），然后调用WinSock函数Connect连接远地主机，配置socket的远地端口和远地IP地址。

异步网络事件的处理

当网络事件发生时，“socket窗口”接收WM_SOCKET_NOTIFY消息，消息处理函数OnSocketNotify被调用。“socket窗口”的定义和消息处理是MFC实现的。

OnSocketNotify回调CAsyncSocket的成员函数DoCallBack，DoCallBack调用事件处理函数，如OnRead、OnWrite等。摘录DoCallBack的一段代码如下：

switch (WSAGETSELECTEVENT(lParam))

{

case FD_READ:

{

DWORD nBytes;

//得到可以一次读取的字节数

pSocket->IOCtl(FIONREAD, &nBytes);

if (nBytes != 0)

pSocket->OnReceive(nErrorCode);

}

break;

case FD_WRITE:

pSocket->OnSend(nErrorCode);

break;

case FD_OOB:

pSocket->OnOutOfBandData(nErrorCode);

break;

case FD_ACCEPT:

pSocket->OnAccept(nErrorCode);

break;

case FD_CONNECT:

pSocket->OnConnect(nErrorCode);

break;

case FD_CLOSE:

pSocket->OnClose(nErrorCode);

break;

lParam是WM_SOCKET_NOFITY的消息参数，OnSocketNotify传递给函数DoCallBack，表示通知事件。

函数IOCtl是CAsyncSocket的成员函数，用来对socket的I/O进行控制。这里的使用表示本次调用Receive函数至多可以读nBytes个字节。

从上面的讨论可以看出，从创建socket 到网络I/O，CAsyncSocket直接封装了低层的WinSock API，简化了WinSock编程，实现了一个异步操作的界面。如果希望某个操作是阻塞操作，则在调用Create时不要指定该操作对应的网络事件。例 如，希望Connect和Send是阻塞操作，在任务完成之后才返回，则可以使用如下的语句：

pSocket->Create(0, SOCK_STREAM, FR_WRITE|FR_OOB|FR_ACCEPT|FR_CLOSE);

这样，在Connect和Send时，如果是用户界面线程的话，可能阻塞线程消息循环。所以，最好在工作者线程中使用阻塞操作。

 

CSocket

如果希望在用户界面线程中使用阻塞socket，则可以使用CSocket。它在非阻塞socket基础之上实现了阻塞操作，在阻塞期间实现了消息循环。

对于CSocket，处理网络事件通知的函数OnAccept、OnClose、OnReceive仍然可以使用，OnConnect、OnSend在CSocket中永远不会被调用，另外OnOutOfBandData在CSocket中不鼓励使用。

CSocket 对象在调用Connect、Send、Accept、Close、Receive等成员函数后，这些函数在完成任务之后（连接被建立、数据被发送、连接请 求被接收、socket被关闭、数据被读取）之后才会返回。因此，Connect和Send不会导致OnConnect和OnSend被调用。如果覆盖虚 拟函数OnReceive、OnAccept、OnClose，不主动调用Receive、Accept、Close，则在网络事件到达之后导致对应的虚 拟函数被调用，虚拟函数的实现应该调用Receive、Accept、Close来完成操作。下面，就一个函数Receive来考察CSocket如何实 现阻塞操作和消息循环的。

int CSocket::Receive(void* lpBuf, int nBufLen, int nFlags)

{

//m_pbBlocking是CSocket的成员变量，用来标识当前是否正在进行

//阻塞操作。但不能同时进行两个阻塞操作。

if (m_pbBlocking != NULL)

{

WSASetLastError(WSAEINPROGRESS);

return FALSE;

}

//完成数据读取

int nResult;

while ((nResult = CAsyncSocket::Receive(lpBuf, nBufLen, nFlags))== SOCKET_ERROR)

{

if (GetLastError() == WSAEWOULDBLOCK)

{

//进入消息循环，等待网络事件FD_READ

if (!PumpMessages(FD_READ))

return SOCKET_ERROR;

}

else

return SOCKET_ERROR;

}

return nResult;

}

其中：

参数1指定一个缓冲区保存读取的数据；参数2指定缓冲区的大小；参数3取值MSG_PEEK（数据拷贝到缓冲区，但不从输入队列移走），或者MSG_OOB（处理带外数据），或者MSG_PEEK|MSG_OOB。

Receive函数首先判断当前CSocket对象是否正在处理一个阻塞操作，如果是，则返回错误WSAEINPROGRESS；否则，开始数据读取的处理。

读取数据时，如果基类CAsyncSocket 的Receive读取到了数据，则返回；否则，如果返回一个错误，而且错误号是WSAEWOULDBLOCK，则表示操作阻塞，于是调用 PumpMessage进入消息循环等待数据到达（网络事件FD_READ发生）。数据到达之后退出消息循环，再次调用CAsyncSocket的 Receive读取数据，直到没有数据可读为止。

PumpMessages是CSocket的成员函数，它完成以下工作：

（1）设置m_pbBlocking，表示进入阻塞操作。

（2） 进行消息循环，如果有以下事件发生则退出消息循环：收到指定定时器的定时事件消息WM_TIMER，退出循环，返回TRUE；收到发送给本socket的 消息WM_SOCKET_NOTIFY，网络事件FD_CLOSE或者等待的网络事件发生，退出循环，返回TRUE；发送错误或者收到WM_QUIT消 息，退出循环，返回FALSE；

（3） 在消息循环中，把WM_SOCKET_DEAD消息和发送给其他socket的通知消息WM_SOCKET_NOFITY放进模块线程状态的通知消息列表 m_listSocketNotifications，在阻塞操作完成之后处理；对其他消息，则把它们送给目的窗口的窗口过程处理。

 

CSocketFile

MFC还提供了一个网络编程模式，可以充分利用CSocket的特性。该模式的基础是CSocketFile类。使用方法如下：

首先，构造一个CSocket对象；调用Create函数创建一个socket对象（SOCK_STREAM类型）。

接着，如果是客户程序，调用Connect连接到远地主机；如果是服务器程序，先调用Listen监听socket端口，收到连接请求后调用Accept接收请求。

然后，创建一个和CSocket对象关联的CSocketFile对象，创建一个和CSocketFile对象关联的CArchive对象，指定CArchive对象是用于读或者写。如果既要读又要写，则创建两个CArchive对象。

创建工作完成之后，使用CArchive对象在客户和服务器之间传送数据

使用完毕，销毁CArchive对象、CSocketFile对象、CSocket对象。

从前面的章节可以知道，CArchive 可以以一个CFile对象为基础，通过<<和>>操作符完成对文件的二进制流的操作。所以可以从CFile派生一个类，实现 CFile的操作界面（Read和Write）。由于CSocket提供了阻塞操作，所以完全可以像读写文件一样读写socket数据。

下面，分析CSocketFile的设计和实现。

CSocketFile的构造函数和析构函数的实现

构造函数的实现

CSocketFile::CSocketFile(CSocket* pSocket, BOOL bArchiveCompatible)

{

m_pSocket = pSocket;

m_bArchiveCompatible = bArchiveCompatible;

#ifdef _DEBUG

ASSERT(m_pSocket != NULL);

ASSERT(m_pSocket->m_hSocket != INVALID_SOCKET);

int nType = 0;

int nTypeLen = sizeof(int);

ASSERT(m_pSocket->GetSockOpt(SO_TYPE,&nType,&nTypeLen));

ASSERT(nType == SOCK_STREAM);

#endif // _DEBUG

}

其中：

构造函数的参数1指向关联的CSocket对象，被保存在成员变量m_pSocket中；

参数2指定该对象是否和一个CArchive对象关联（不关联则独立使用），被保存在成员变量bArchiveCompatible中。

Degug部分用于检测m_pSocket是否是SOCK_STREAM类型。

析构函数的实现

CSocketFile::~CSocketFile()

{

}

（2）CSocketFile的读写的实现

分析CSocketFile如何用文件的读写实现网络I/O。

文件读的实现

UINT CSocketFile::Read(void* lpBuf, UINT nCount)

{

ASSERT(m_pSocket != NULL);

int nRead;

//CSocketFile对象独立使用

if (!m_bArchiveCompatible)

{

int nLeft = nCount;

PBYTE pBuf = (PBYTE)lpBuf;

//读完nCount个字节的数据

while(nLeft > 0)

{

//CSocket的Receive，阻塞操作，读取到数据才继续

nRead = m_pSocket->Receive(pBuf, nLeft);

if (nRead == SOCKET_ERROR)

{

int nError = m_pSocket->GetLastError();

AfxThrowFileException(CFileException::generic, nError);

ASSERT(FALSE);

}

else if (nRead == 0)

{

return nCount - nLeft;

}

nLeft -= nRead;

pBuf += nRead;

}

return nCount - nLeft;

}

//和一个CArchive对象关联使用读取数据，能读多少是多少

nRead = m_pSocket->Receive(lpBuf, nCount, 0);

if (nRead == SOCKET_ERROR)

{

int nError = m_pSocket->GetLastError();

AfxThrowFileException(CFileException::generic, nError);

ASSERT(FALSE);

}

return nRead;

}

文件写的实现

void CSocketFile::Write(const void* lpBuf, UINT nCount)

{

ASSERT (m_pSocket!=NULL);

//CSocket的函数Send，阻塞操作，发送完毕才继续

int nWritten = m_pSocket->Send(lpBuf, nCount);

if (nWritten == SOCKET_ERROR)

{

int nError = m_pSocket->GetLastError();

AfxThrowFileException(CFileException::generic, nError);

}

}

从CSockefFile 的读写实现可以看出，CSocketFile如果独立使用，在Read操作时可能出现无限等待，因为数据是分多个消息多次送达的，没有读取到指定长度的数 据并不表示数据读取完毕。但是和CArchive配合使用，则仅仅读取到数据就返回。至于数据是否读取完毕，可以使用CArchive的 IsBufferEmpty函数来判断。

其他CFile界面，CSocketFile没有实现。

从CScocketFile的设计和实现来看，CSocketFile是使用CSocket的一个很好的例子，也是使用CFile的一个例子。