摘要：本文对如何使用面向连接的流式套接字实现对网卡的编程以及如何实现异步网络通讯等问题进行了讨论与阐述。

　　一、 引言

　　在80年代初，美国加利福尼亚大学伯克利分校的研究人员为TCP/IP网络通信开发了一个专门用于网络通讯开发的API。这个API就是Socket接口（套接字）--当今在TCP/IP网络最为通用的一种API，也是在互联网上进行应用开发最为通用的一种API。在微软联合其它几家公司共同制定了一套Windows下的网络编程接口Windows Sockets规范后，由于在其规范中引入了一些异步函数，增加了对网络事件异步选择机制，因此更加符合Windows的消息驱动特性，使网络开发人员可以更加方便的进行高性能网络通讯程序的设计。本文接下来就针对Windows Sockets API进行面向连接的流式套接字编程以及对异步网络通讯的编程实现等问题展开讨论。

　　二、 面向连接的流式套接字编程模型的设计

　　本文在方案选择上采用了在网络编程中最常用的一种模型--客户机/服务器模型。这种客户/服务器模型是一种非对称式编程模式。该模式的基本思想是把集中在一起的应用划分成为功能不同的两个部分，分别在不同的计算机上运行，通过它们之间的分工合作来实现一个完整的功能。对于这种模式而言其中一部分需要作为服务器，用来响应并为客户提供固定的服务；另一部分则作为客户机程序用来向服务器提出请求或要求某种服务。

　　本文选取了基于TCP/IP的客户机/服务器模型和面向连接的流式套接字。其通信原理为：服务器端和客户端都必须建立通信套接字，而且服务器端应先进入监听状态，然后客户端套接字发出连接请求，服务器端收到请求后，建立另一个套接字进行通信，原来负责监听的套接字仍进行监听，如果有其它客户发来连接请求，则再建立一个套接字。默认状态下最多可同时接收5个客户的连接请求，并与之建立通信关系。因此本程序的设计流程应当由服务器首先启动，然后在某一时刻启动客户机并使其与服务器建立连接。服务器与客户机开始都必须调用Windows Sockets API函数socket()建立一个套接字sockets,然后服务器方调用bind()将套接字与一个本地网络地址捆扎在一起，再调用listen()使套接字处于一种被动的准备接收状态，同时规定它的请求队列长度。在此之后服务器就可以通过调用accept()来接收客户机的连接。

　　相对于服务器，客户端的工作就显得比较简单了，当客户端打开套接字之后，便可通过调用connect()和服务器建立连接。连接建立之后，客户和服务器之间就可以通过连接发送和接收资料。最后资料传送结束，双方调用closesocket()关闭套接字来结束这次通讯。整个通讯过程的具体流程框图可大致用下面的流程图来表示：

面向连接的流式套接字编程流程示意图

　　三、 软件设计要点以及异步通讯的实现

　　根据前面设计的程序流程，可将程序划分为两部分：服务器端和客户端。而且整个实现过程可以大致用以下几个非常关键的Windows Sockets API函数将其惯穿下来：

　　服务器方：

socket()->bind()->listen->accept()->recv()/send()->closesocket()

　　客户机方：

socket()->connect()->send()/recv()->closesocket()

　　有鉴于以上几个函数在整个网络编程中的重要性，有必要结合程序实例对其做较深入的剖析。服务器端应用程序在使用套接字之前，首先必须拥有一个Socket，系统调用socket()函数向应用程序提供创建套接字的手段。该套接字实际上是在计算机中提供了一个通信埠，可以通过这个埠与任何一个具有套接字接口的计算机通信。应用程序在网络上传输、接收的信息都通过这个套接字接口来实现的。在应用开发中如同使用文件句柄一样，可以对套接字句柄进行读写操作：

sock=socket(AF_INET,SOCK_STREAM,0);

　　函数的第一个参数用于指定地址族，在Windows下仅支持AF_INET(TCP/IP地址)；第二个参数用于描述套接字的类型，对于流式套接字提供有SOCK_STREAM；最后一个参数指定套接字使用的协议，一般为0。该函数的返回值保存了新套接字的句柄，在程序退出前可以用 closesocket(sock);函数来将其释放。服务器方一旦获取了一个新的套接字后应通过bind()将该套接字与本机上的一个端口相关联：

sockin.sin_family=AF_INET; sockin.sin_addr.s_addr=0; sockin.sin_port=htons(USERPORT); bind(sock,(LPSOCKADDR)&sockin,sizeof(sockin)));

　　该函数的第二个参数是一个指向包含有本机IP地址和端口信息的sockaddr_in结构类型的指针，其成员描述了本地端口号和本地主机地址，经过bind()将服务器进程在网络上标识出来。需要注意的是由于1024以内的埠号都是保留的埠号因此如无特别需要一般不能将sockin.sin_port的埠号设置为1024以内的值。然后调用listen()函数开始侦听，再通过accept()调用等待接收连接以完成连接的建立：

//连接请求队列长度为1，即只允许有一个请求,若有多个请求, //则出现错误，给出错误代码WSAECONNREFUSED。 listen(sock,1); //开启线程避免主程序的阻塞 AfxBeginThread(Server,NULL); …… UINT Server(LPVOID lpVoid) { …… int nLen=sizeof(SOCKADDR); pView->newskt=accept(pView->sock,(LPSOCKADDR)& pView->sockin,(LPINT)& nLen); …… WSAAsyncSelect(pView->newskt,pView->m_hWnd,WM_SOCKET_MSG,FD_READ|FD_CLOSE); return 1; }

　　这里之所以把accept()放到一个线程中去是因为在执行到该函数时如没有客户连接服务器的请求到来，服务器就会停在accept语句上等待连接请求的到来，这势必会引起程序的阻塞，虽然也可以通过设置套接字为非阻塞方式使在没有客户等待时可以使accept（）函数调用立即返回，但这种轮询套接字的方式会使CPU处于忙等待方式，从而降低程序的运行效率大大浪费系统资源。考虑到这种情况，将套接字设置为阻塞工作方式，并为其单独开辟一个子线程，将其阻塞控制在子线程范围内而不会造成整个应用程序的阻塞。对于网络事件的响应显然要采取异步选择机制，只有采取这种方式才可以在由网络对方所引起的不可预知的网络事件发生时能马上在进程中做出及时的响应处理，而在没有网络事件到达时则可以处理其他事件，这种效率是很高的，而且完全符合Windows所标榜的消息触发原则。前面那段代码中的WSAAsyncSelect()函数便是实现网络事件异步选择的核心函数。

　　通过第四个参数注册应用程序感兴取的网络事件，在这里通过FD_READ|FD_CLOSE指定了网络读和网络断开两种事件，当这种事件发生时变会发出由第三个参数指定的自定义消息WM_SOCKET_MSG，接收该消息的窗口通过第二个参数指定其句柄。在消息处理函数中可以通过对消息参数低字节进行判断而区别出发生的是何种网络事件：

void CNetServerView::OnSocket(WPARAM wParam,LPARAM lParam) { int iReadLen=0; int message=lParam & 0x0000FFFF; switch(message) { case FD_READ://读事件发生。此时有字符到达，需要进行接收处理 char cDataBuffer[MTU*10]; //通过套接字接收信息 iReadLen = recv(newskt,cDataBuffer,MTU*10,0); //将信息保存到文件 if(!file.Open("ServerFile.txt",CFile::modeReadWrite)) file.Open("E:ServerFile.txt",CFile::modeCreate|CFile::modeReadWrite); file.SeekToEnd(); file.Write(cDataBuffer,iReadLen); file.Close(); break; case FD_CLOSE://网络断开事件发生。此时客户机关闭或退出。 ……//进行相应的处理 break; default: break; } }

　　在这里需要实现对自定义消息WM_SOCKET_MSG的响应，需要在头文件和实现文件中分别添加其消息映射关系：

　　头文件：

//{{AFX_MSG(CNetServerView) //}}AFX_MSG void OnSocket(WPARAM wParam,LPARAM lParam); DECLARE_MESSAGE_MAP()

　　实现文件：

BEGIN_MESSAGE_MAP(CNetServerView, CView) //{{AFX_MSG_MAP(CNetServerView) //}}AFX_MSG_MAP ON_MESSAGE(WM_SOCKET_MSG,OnSocket) END_MESSAGE_MAP()

　　在进行异步选择使用WSAAsyncSelect()函数时，有以下几点需要引起特别的注意：

　　1． 连续使用两次WSAAsyncSelect()函数时，只有第二次设置的事件有效，如：

WSAAsyncSelect(s,hwnd,wMsg1,FD_READ); WSAAsyncSelect(s,hwnd,wMsg2,FD_CLOSE);

　　这样只有当FD_CLOSE事件发生时才会发送wMsg2消息。

　　2．可以在设置过异步选择后通过再次调用WSAAsyncSelect(s,hwnd,0,0);的形式取消在套接字上所设置的异步事件。

　　3．Windows Sockets DLL在一个网络事件发生后，通常只会给相应的应用程序发送一个消息，而不能发送多个消息。但通过使用一些函数隐式地允许重发此事件的消息，这样就可能再次接收到相应的消息。

　　4．在调用过closesocket()函数关闭套接字之后不会再发生FD_CLOSE事件。

　　以上基本完成了服务器方的程序设计，下面对于客户端的实现则要简单多了，在用socket()创建完套接字之后只需通过调用connect()完成同服务器的连接即可，剩下的工作同服务器完全一样：用send()/recv()发送/接收收据，用closesocket()关闭套接字：

sockin.sin_family=AF_INET; //地址族 sockin.sin_addr.S_un.S_addr=IPaddr; //指定服务器的IP地址 sockin.sin_port=m_Port; //指定连接的端口号 int nConnect=connect(sock,(LPSOCKADDR)&sockin,sizeof(sockin));

　　本文采取的是可靠的面向连接的流式套接字。在数据发送上有write()、writev()和send()等三个函数可供选择，其中前两种分别用于缓冲发送和集中发送，而send()则为可控缓冲发送，并且还可以指定传输控制标志为MSG_OOB进行带外数据的发送或是为MSG_DONTROUTE寻径控制选项。在信宿地址的网络号部分指定数据发送需要经过的网络接口，使其可以不经过本地寻径机制直接发送出去。这也是其同write()函数的真正区别所在。由于接收数据系统调用和发送数据系统调用是一一对应的，因此对于数据的接收，在此不再赘述，相应的三个接收函数分别为：read()、readv()和recv()。由于后者功能上的全面，本文在实现上选择了send()-recv()函数对，在具体编程中应当视具体情况的不同灵活选择适当的发送-接收函数对。

　　小结：TCP/IP协议是目前各网络操作系统主要的通讯协议，也是 Internet的通讯协议，本文通过Windows Sockets API实现了对基于TCP/IP协议的面向连接的流式套接字网络通讯程序的设计，并通过异步通讯和多线程等手段提高了程序的运行效率，避免了阻塞的发生。

 

 

一、简介

　　Windows Sockets 是从 Berkeley Sockets 扩展而来的，其在继承 Berkeley Sockets 的基础上，又进行了新的扩充。这些扩充主要是提供了一些异步函数，并增加了符合WINDOWS消息驱动特性的网络事件异步选择机制。

　　Windows Sockets由两部分组成：开发组件和运行组件。

　　开发组件：Windows Sockets 实现文档、应用程序接口(API)引入库和一些头文件。

　　运行组件：Windows Sockets 应用程序接口的动态链接库(WINSOCK.DLL)。
　　二、主要扩充说明
　　1、异步选择机制：

　　Windows Sockets 的异步选择函数提供了消息机制的网络事件选择，当使用它登记网络事件发生时，应用程序相应窗口函数将收到一个消息，消息中指示了发生的网络事件，以及与事件相关的一些信息。

　　Windows Sockets 提供了一个异步选择函数 WSAAsyncSelect()，用它来注册应用程序感兴趣的网络事件，当这些事件发生时，应用程序相应的窗口函数将收到一个消息。

　　函数结构如下：

int PASCAL FAR WSAAsyncSelect(SOCKET s,HWND hWnd,unsigned int wMsg,long lEvent);
　　参数说明：

　　　hWnd：窗口句柄

　　　wMsg：需要发送的消息

　　　lEvent：事件（以下为事件的内容）

值： 含义：
FD_READ 期望在套接字上收到数据（即读准备好）时接到通知
FD_WRITE 期望在套接字上可发送数据（即写准备好）时接到通知
FD_OOB 期望在套接字上有带外数据到达时接到通知
FD_ACCEPT 期望在套接字上有外来连接时接到通知
FD_CONNECT 期望在套接字连接建立完成时接到通知
FD_CLOSE 期望在套接字关闭时接到通知
　　例如：我们要在套接字读准备好或写准备好时接到通知，语句如下：

rc=WSAAsyncSelect(s,hWnd,wMsg,FD_READ|FD_WRITE);
　　如果我们需要注蕴捉幼滞缡录南⒎⑺停灰?lEvent 设置为0
　　2、异步请求函数

　　在 Berkeley Sockets 中请求服务是阻塞的，WINDOWS SICKETS 除了支持这一类函数外，还增加了相应的异步请求函数(WSAAsyncGetXByY();)。

　　3、阻塞处理方法

　　Windows Sockets 为了实现当一个应用程序的套接字调用处于阻塞时，能够放弃CPU让其它应用程序运行，它在调用处于阻塞时便进入一个叫“HOOK”的例程，此例程负责接收和分配WINDOWS消息，使得其它应用程序仍然能够接收到自己的消息并取得控制权。

　　WINDOWS 是非抢先的多任务环境，即若一个程序不主动放弃其控制权，别的程序就不能执行。因此在设计Windows Sockets 程序时，尽管系统支持阻塞操作，但还是反对程序员使用该操作。但由于 SUN 公司下的 Berkeley Sockets 的套接字默认操作是阻塞的，WINDOWS 作为移植的 SOCKETS 也不可避免对这个操作支持。

　　在Windows Sockets 实现中，对于不能立即完成的阻塞操作做如下处理：DLL初始化→循环操作。在循环中，它发送任何 WINDOWS 消息，并检查这个 Windows Sockets 调用是否完成，在必要时，它可以放弃CPU让其它应用程序执行（当然使用超线程的CPU就不会有这个麻烦了^_^）。我们可以调用 WSACancelBlockingCall() 函数取消此阻塞操作。

　　在 Windows Sockets 中，有一个默认的阻塞处理例程 BlockingHook() 简单地获取并发送 WINDOWS 消息。如果要对复杂程序进行处理，Windows Sockets 中还有 WSASetBlockingHook() 提供用户安装自己的阻塞处理例程能力；与该函数相对应的则是 SWAUnhookBlockingHook()，它用于删除先前安装的任何阻塞处理例程，并重新安装默认的处理例程。请注意，设计自己的阻塞处理例程时，除了函数 WSACancelBlockingHook() 之外，它不能使用其它的 Windows Sockets API 函数。在处理例程中调用 WSACancelBlockingHook()函数将取消处于阻塞的操作，它将结束阻塞循环。
　　4、出错处理

　　Windows Sockets 为了和以后多线程环境（WINDOWS/UNIX）兼容，它提供了两个出错处理函数来获取和设置当前线程的最近错误号。（WSAGetLastEror()和WSASetLastError()）
　　5、启动与终止

　　使用函数 WSAStartup() 和 WSACleanup() 启动和终止套接字。
三、Windows Sockets网络程序设计核心
　　我们终于可以开始真正的 Windows Sockets 网络程序设计了。不过我们还是先看一看每个 Windows Sockets 网络程序都要涉及的内容。让我们一步步慢慢走。
　　1、启动与终止

　　在所有 Windows Sockets 函数中，只有启动函数 WSAStartup() 和终止函数 WSACleanup() 是必须使用的。

　　启动函数必须是第一个使用的函数，而且它允许指定 Windows Sockets API 的版本，并获得 SOCKETS的特定的一些技术细节。本结构如下：

int PASCAL FAR WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData);
　　其中 wVersionRequested 保证 SOCKETS 可正常运行的 DLL 版本，如果不支持，则返回错误信息。
我们看一下下面这段代码，看一下如何进行 WSAStartup() 的调用

WORD wVersionRequested;// 定义版本信息变量
WSADATA wsaData;//定义数据信息变量
int err;//定义错误号变量
wVersionRequested = MAKEWORD(1,1);//给版本信息赋值
err = WSAStartup(wVersionRequested, &wsaData);//给错误信息赋值
if(err!=0)
{
return;//告诉用户找不到合适的版本
}
//确认 Windows Sockets DLL 支持 1.1 版本
//DLL 版本可以高于 1.1
//系统返回的版本号始终是最低要求的 1.1，即应用程序与DLL 中可支持的最低版本号
if(LOBYTE(wsaData.wVersion)!= 1|| HIBYTE(wsaData.wVersion)!=1)
{
WSACleanup();//告诉用户找不到合适的版本
return;
}
//Windows Sockets DLL 被进程接受，可以进入下一步操作
　　关闭函数使用时，任何打开并已连接的 SOCK_STREAM 套接字被复位，但那些已由 closesocket() 函数关闭的但仍有未发送数据的套接字不受影响，未发送的数据仍将被发送。程序运行时可能会多次调用 WSAStartuo() 函数，但必须保证每次调用时的 wVersionRequested 的值是相同的。
　　2、异步请求服务

　　Windows Sockets 除支持 Berkeley Sockets 中同步请求，还增加了了一类异步请求服务函数 WSAAsyncGerXByY()。该函数是阻塞请求函数的异步版本。应用程序调用它时，由 Windows Sockets DLL 初始化这一操作并返回调用者，此函数返回一个异步句柄，用来标识这个操作。当结果存储在调用者提供的缓冲区，并且发送一个消息到应用程序相应窗口。常用结构如下：

HANDLE taskHnd;
char hostname="rs6000";
taskHnd = WSAAsyncBetHostByName(hWnd,wMsg,hostname,buf,buflen);
　　需要注意的是，由于 Windows 的内存对像可以设置为可移动和可丢弃，因此在操作内存对象是，必须保证 WIindows Sockets DLL 对象是可用的。

　　3、异步数据传输

　　使用 send() 或 sendto() 函数来发送数据，使用 recv() 或recvfrom() 来接收数据。Windows Sockets 不鼓励用户使用阻塞方式传输数据，因为那样可能会阻塞整个 Windows 环境。下面我们看一个异步数据传输实例：

　　假设套接字 s 在连接建立后，已经使用了函数 WSAAsyncSelect() 在其上注册了网络事件 FD_READ 和 FD_WRITE，并且 wMsg 值为 UM_SOCK，那么我们可以在 Windows 消息循环中增加如下的分支语句：

case UM_SOCK:
switch(lParam)
{
case FD_READ:
len = recv(wParam,lpBuffer,length,0);
break;
case FD_WRITE:
while(send(wParam,lpBuffer,len,0)!=SOCKET_ERROR)
break;
}
break;
　　4、出错处理

　　Windows 提供了一个函数来获取最近的错误码 WSAGetLastError()，推荐的编写方式如下：

len = send (s,lpBuffer,len,0);
of((len==SOCKET_ERROR)&&(WSAGetLastError()==WSAWOULDBLOCK)){...}
实例应用：
基于Visual C++的Winsock API研究

　　为了方便网络编程，90年代初，由Microsoft联合了其他几家公司共同制定了一套WINDOWS下的网络编程接口，即Windows Sockets规范，它不是一种网络协议,而是一套开放的、支持多种协议的Windows下的网络编程接口。现在的Winsock已经基本上实现了与协议无关，你可以使用Winsock来调用多种协议的功能，但较常使用的是TCP/IP协议。Socket实际在计算机中提供了一个通信端口，可以通过这个端口与任何一个具有Socket接口的计算机通信。应用程序在网络上传输，接收的信息都通过这个Socket接口来实现。

　　微软为VC定义了Winsock类如CAsyncSocket类和派生于CAsyncSocket 的CSocket类，它们简单易用，读者朋友当然可以使用这些类来实现自己的网络程序，但是为了更好的了解Winsock API编程技术，我们这里探讨怎样使用底层的API函数实现简单的 Winsock 网络应用程式设计，分别说明如何在Server端和Client端操作Socket，实现基于TCP/IP的数据传送，最后给出相关的源代码。

　　在VC中进行WINSOCK的API编程开发的时候，需要在项目中使用下面三个文件，否则会出现编译错误。

　　1．WINSOCK.H: 这是WINSOCK API的头文件，需要包含在项目中。

　　2．WSOCK32.LIB: WINSOCK API连接库文件。在使用中，一定要把它作为项目的非缺省的连接库包含到项目文件中去。

　　3．WINSOCK.DLL: WINSOCK的动态连接库，位于WINDOWS的安装目录下。

　　一、服务器端操作 socket（套接字）

　　1)在初始化阶段调用WSAStartup()

　　此函数在应用程序中初始化Windows Sockets DLL ，只有此函数调用成功后，应用程序才可以再调用其他Windows Sockets DLL中的API函数。在程式中调用该函数的形式如下：WSAStartup((WORD)((1<<8|1)，（LPWSADATA）&WSAData)，其中(1<<8|1)表示我们用的是WinSocket1.1版本，WSAata用来存储系统传回的关于WinSocket的资料。

　　2)建立Socket

　　初始化WinSock的动态连接库后，需要在服务器端建立一个监听的Socket，为此可以调用Socket()函数用来建立这个监听的Socket，并定义此Socket所使用的通信协议。此函数调用成功返回Socket对象，失败则返回INVALID_SOCKET(调用WSAGetLastError()可得知原因，所有WinSocket 的函数都可以使用这个函数来获取失败的原因)。

SOCKET PASCAL FAR socket( int af, int type, int protocol )
参数: af:目前只提供 PF_INET(AF_INET)；
type：Socket 的类型 (SOCK_STREAM、SOCK_DGRAM)；
protocol：通讯协定(如果使用者不指定则设为0)；

如果要建立的是遵从TCP/IP协议的socket，第二个参数type应为SOCK_STREAM，如为UDP（数据报）的socket，应为SOCK_DGRAM。

　　3)绑定端口

　　接下来要为服务器端定义的这个监听的Socket指定一个地址及端口（Port），这样客户端才知道待会要连接哪一个地址的哪个端口，为此我们要调用bind()函数，该函数调用成功返回0，否则返回SOCKET_ERROR。
int PASCAL FAR bind( SOCKET s, const struct sockaddr FAR *name,int namelen );

参 数： s：Socket对象名；
name：Socket的地址值，这个地址必须是执行这个程式所在机器的IP地址；
namelen：name的长度；

　　如果使用者不在意地址或端口的值，那么可以设定地址为INADDR_ANY，及Port为0，Windows Sockets 会自动将其设定适当之地址及Port (1024 到 5000之间的值)。此后可以调用getsockname()函数来获知其被设定的值。

　　4）监听

　　当服务器端的Socket对象绑定完成之后,服务器端必须建立一个监听的队列来接收客户端的连接请求。listen()函数使服务器端的Socket 进入监听状态，并设定可以建立的最大连接数(目前最大值限制为 5, 最小值为1)。该函数调用成功返回0，否则返回SOCKET_ERROR。

int PASCAL FAR listen( SOCKET s, int backlog );
参 数： s：需要建立监听的Socket；
backlog：最大连接个数；

　　服务器端的Socket调用完listen（）后，如果此时客户端调用connect（）函数提出连接申请的话，Server 端必须再调用accept() 函数，这样服务器端和客户端才算正式完成通信程序的连接动作。为了知道什么时候客户端提出连接要求，从而服务器端的Socket在恰当的时候调用accept()函数完成连接的建立，我们就要使用WSAAsyncSelect（）函数，让系统主动来通知我们有客户端提出连接请求了。该函数调用成功返回0，否则返回SOCKET_ERROR。

int PASCAL FAR WSAAsyncSelect( SOCKET s, HWND hWnd,unsigned int wMsg, long lEvent );
参数： s：Socket 对象；
hWnd ：接收消息的窗口句柄；
wMsg：传给窗口的消息；
lEvent：被注册的网络事件，也即是应用程序向窗口发送消息的网路事件，该值为下列值FD_READ、FD_WRITE、FD_OOB、FD_ACCEPT、FD_CONNECT、FD_CLOSE的组合，各个值的具体含意为FD_READ：希望在套接字S收到数据时收到消息；FD_WRITE：希望在套接字S上可以发送数据时收到消息；FD_ACCEPT：希望在套接字S上收到连接请求时收到消息；FD_CONNECT：希望在套接字S上连接成功时收到消息；FD_CLOSE：希望在套接字S上连接关闭时收到消息；FD_OOB：希望在套接字S上收到带外数据时收到消息。

　　具体应用时，wMsg应是在应用程序中定义的消息名称，而消息结构中的lParam则为以上各种网络事件名称。所以，可以在窗口处理自定义消息函数中使用以下结构来响应Socket的不同事件：　　

switch(lParam)　
　 {case FD_READ:
　　　 …　　
　 break;
case FD_WRITE、
　　　 …
　 break;
　　　 …
}

　　5）服务器端接受客户端的连接请求

　　当Client提出连接请求时，Server 端hwnd视窗会收到Winsock Stack送来我们自定义的一个消息，这时，我们可以分析lParam，然后调用相关的函数来处理此事件。为了使服务器端接受客户端的连接请求，就要使用accept() 函数，该函数新建一Socket与客户端的Socket相通，原先监听之Socket继续进入监听状态，等待他人的连接要求。该函数调用成功返回一个新产生的Socket对象，否则返回INVALID_SOCKET。

SOCKET PASCAL FAR accept( SCOKET s, struct sockaddr FAR *addr,int FAR *addrlen );
参数：s：Socket的识别码；
addr：存放来连接的客户端的地址；
addrlen：addr的长度

　　6）结束 socket 连接

　　结束服务器和客户端的通信连接是很简单的，这一过程可以由服务器或客户机的任一端启动，只要调用closesocket()就可以了，而要关闭Server端监听状态的socket，同样也是利用此函数。另外，与程序启动时调用WSAStartup()憨数相对应，程式结束前，需要调用 WSACleanup() 来通知Winsock Stack释放Socket所占用的资源。这两个函数都是调用成功返回0，否则返回SOCKET_ERROR。

int PASCAL FAR closesocket( SOCKET s );
参 数：s：Socket 的识别码；
int PASCAL FAR WSACleanup( void );
参 数： 无
二、客户端Socket的操作

　　1）建立客户端的Socket

　　客户端应用程序首先也是调用WSAStartup() 函数来与Winsock的动态连接库建立关系，然后同样调用socket() 来建立一个TCP或UDP socket（相同协定的 sockets 才能相通，TCP 对 TCP，UDP 对 UDP）。与服务器端的socket 不同的是，客户端的socket 可以调用 bind() 函数，由自己来指定IP地址及port号码；但是也可以不调用 bind()，而由 Winsock来自动设定IP地址及port号码。

　　2）提出连接申请

　　客户端的Socket使用connect()函数来提出与服务器端的Socket建立连接的申请，函数调用成功返回0，否则返回SOCKET_ERROR。

int PASCAL FAR connect( SOCKET s, const struct sockaddr FAR *name, int namelen );
参 数：s：Socket 的识别码；
name：Socket想要连接的对方地址；
namelen：name的长度

　　三、数据的传送

　　虽然基于TCP/IP连接协议（流套接字）的服务是设计客户机/服务器应用程序时的主流标准，但有些服务也是可以通过无连接协议（数据报套接字）提供的。先介绍一下TCP socket 与UDP socket 在传送数据时的特性：Stream (TCP) Socket 提供双向、可靠、有次序、不重复的资料传送。Datagram (UDP) Socket 虽然提供双向的通信，但没有可靠、有次序、不重复的保证，所以UDP传送数据可能会收到无次序、重复的资料，甚至资料在传输过程中出现遗漏。由于UDP Socket 在传送资料时，并不保证资料能完整地送达对方，所以绝大多数应用程序都是采用TCP处理Socket，以保证资料的正确性。一般情况下TCP Socket 的数据发送和接收是调用send() 及recv() 这两个函数来达成，而 UDP Socket则是用sendto() 及recvfrom() 这两个函数，这两个函数调用成功发挥发送或接收的资料的长度，否则返回SOCKET_ERROR。

int PASCAL FAR send( SOCKET s, const char FAR *buf,int len, int flags );
参数：s：Socket 的识别码
buf：存放要传送的资料的暂存区
len buf：的长度
flags：此函数被调用的方式

　　对于Datagram Socket而言，若是 datagram 的大小超过限制，则将不会送出任何资料，并会传回错误值。对Stream Socket 言，Blocking 模式下，若是传送系统内的储存空间不够存放这些要传送的资料，send()将会被block住，直到资料送完为止；如果该Socket被设定为 Non-Blocking 模式，那么将视目前的output buffer空间有多少，就送出多少资料，并不会被 block 住。flags 的值可设为 0 或 MSG_DONTROUTE及 MSG_OOB 的组合。

int PASCAL FAR recv( SOCKET s, char FAR *buf, int len, int flags );
参数：s：Socket 的识别码
buf：存放接收到的资料的暂存区
len buf：的长度
flags：此函数被调用的方式

　　对Stream Socket 言，我们可以接收到目前input buffer内有效的资料，但其数量不超过len的大小。

　　四、自定义的CMySocket类的实现代码：

　　根据上面的知识，我自定义了一个简单的CMySocket类，下面是我定义的该类的部分实现代码：

//////////////////////////////////////
CMySocket::CMySocket() : file://类的构造函数
{
　WSADATA wsaD;
　memset( m_LastError, 0, ERR_MAXLENGTH );
　// m_LastError是类内字符串变量,初始化用来存放最后错误说明的字符串；
　// 初始化类内sockaddr_in结构变量，前者存放客户端地址，后者对应于服务器端地址;
　memset( &m_sockaddr, 0, sizeof( m_sockaddr ) );
　memset( &m_rsockaddr, 0, sizeof( m_rsockaddr ) );
　int result = WSAStartup((WORD)((1<<8|1)， &wsaD);//初始化WinSocket动态连接库;
　if( result != 0 ) // 初始化失败；
　{ set_LastError( "WSAStartup failed!", WSAGetLastError() );
　　return;
　}
}

//////////////////////////////
CMySocket::~CMySocket() { WSACleanup(); }//类的析构函数；
////////////////////////////////////////////////////
int CMySocket::Create( void )
　{// m_hSocket是类内Socket对象，创建一个基于TCP/IP的Socket变量，并将值赋给该变量；
　　if ( (m_hSocket = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP )) == INVALID_SOCKET )
　　{
　　　set_LastError( "socket() failed", WSAGetLastError() );
　　　return ERR_WSAERROR;
　　}
　　return ERR_SUCCESS;
　}
///////////////////////////////////////////////
int CMySocket::Close( void )//关闭Socket对象；
{
　if ( closesocket( m_hSocket ) == SOCKET_ERROR )
　{
　　set_LastError( "closesocket() failed", WSAGetLastError() );
　　return ERR_WSAERROR;
　}
　file://重置sockaddr_in 结构变量；
　memset( &m_sockaddr, 0, sizeof( sockaddr_in ) );
　memset( &m_rsockaddr, 0, sizeof( sockaddr_in ) );
　return ERR_SUCCESS;
}
/////////////////////////////////////////
int CMySocket::Connect( char* strRemote, unsigned int iPort )//定义连接函数；
{
　if( strlen( strRemote ) == 0 || iPort == 0 )
　　return ERR_BADPARAM;
　hostent *hostEnt = NULL;
　long lIPAddress = 0;
　hostEnt = gethostbyname( strRemote );//根据计算机名得到该计算机的相关内容；
　if( hostEnt != NULL )
　{
　　lIPAddress = ((in_addr*)hostEnt->h_addr)->s_addr;
　　m_sockaddr.sin_addr.s_addr = lIPAddress;
　}
　else
　{
　　m_sockaddr.sin_addr.s_addr = inet_addr( strRemote );
　}
　m_sockaddr.sin_family = AF_INET;
　m_sockaddr.sin_port = htons( iPort );
　if( connect( m_hSocket, (SOCKADDR*)&m_sockaddr, sizeof( m_sockaddr ) ) == SOCKET_ERROR )
　{
　　set_LastError( "connect() failed", WSAGetLastError() );
　　return ERR_WSAERROR;
　}
　return ERR_SUCCESS;
}
///////////////////////////////////////////////////////
int CMySocket::Bind( char* strIP, unsigned int iPort )//绑定函数；
{
　if( strlen( strIP ) == 0 || iPort == 0 )
　　return ERR_BADPARAM;
　memset( &m_sockaddr,0, sizeof( m_sockaddr ) );
　m_sockaddr.sin_family = AF_INET;
　m_sockaddr.sin_addr.s_addr = inet_addr( strIP );
　m_sockaddr.sin_port = htons( iPort );
　if ( bind( m_hSocket, (SOCKADDR*)&m_sockaddr, sizeof( m_sockaddr ) ) == SOCKET_ERROR )
　{
　　set_LastError( "bind() failed", WSAGetLastError() );
　　return ERR_WSAERROR;
　}
　return ERR_SUCCESS;
}
//////////////////////////////////////////
int CMySocket::Accept( SOCKET s )//建立连接函数，S为监听Socket对象名；
{
　int Len = sizeof( m_rsockaddr );
　memset( &m_rsockaddr, 0, sizeof( m_rsockaddr ) );
　if( ( m_hSocket = accept( s, (SOCKADDR*)&m_rsockaddr, &Len ) ) == INVALID_SOCKET )
　{
　　set_LastError( "accept() failed", WSAGetLastError() );
　　return ERR_WSAERROR;
　}
　return ERR_SUCCESS;
}
/////////////////////////////////////////////////////
int CMySocket::asyncSelect( HWND hWnd, unsigned int wMsg, long lEvent )
file://事件选择函数；
{
　if( !IsWindow( hWnd ) || wMsg == 0 || lEvent == 0 )
　　return ERR_BADPARAM;
　if( WSAAsyncSelect( m_hSocket, hWnd, wMsg, lEvent ) == SOCKET_ERROR )
　{
　　set_LastError( "WSAAsyncSelect() failed", WSAGetLastError() );
　　return ERR_WSAERROR;
　}
　return ERR_SUCCESS;
}
////////////////////////////////////////////////////
int CMySocket::Listen( int iQueuedConnections )//监听函数；
{
　if( iQueuedConnections == 0 )
　　return ERR_BADPARAM;
　if( listen( m_hSocket, iQueuedConnections ) == SOCKET_ERROR )
　{
　　set_LastError( "listen() failed", WSAGetLastError() );
　　return ERR_WSAERROR;
　}
　return ERR_SUCCESS;
}
////////////////////////////////////////////////////
int CMySocket::Send( char* strData, int iLen )//数据发送函数；
{
　if( strData == NULL || iLen == 0 )
　　return ERR_BADPARAM;
　if( send( m_hSocket, strData, iLen, 0 ) == SOCKET_ERROR )
　{
　　set_LastError( "send() failed", WSAGetLastError() );
　　return ERR_WSAERROR;
　}
　return ERR_SUCCESS;
}
/////////////////////////////////////////////////////
int CMySocket::Receive( char* strData, int iLen )//数据接收函数；
{
　if( strData == NULL )
　　return ERR_BADPARAM;
　int len = 0;
　int ret = 0;
　ret = recv( m_hSocket, strData, iLen, 0 );
　if ( ret == SOCKET_ERROR )
　{
　　set_LastError( "recv() failed", WSAGetLastError() );
　　return ERR_WSAERROR;
　}
　return ret;
}
void CMySocket::set_LastError( char* newError, int errNum )
file://WinSock API操作错误字符串设置函数；
{
　memset( m_LastError, 0, ERR_MAXLENGTH );
　memcpy( m_LastError, newError, strlen( newError ) );
　m_LastError[strlen(newError)+1] = '\0';
}

　　有了上述类的定义，就可以在网络程序的服务器和客户端分别定义CMySocket对象，建立连接，传送数据了。例如，为了在服务器和客户端发送数据，需要在服务器端定义两个CMySocket对象ServerSocket1和ServerSocket2，分别用于监听和连接，客户端定义一个CMySocket对象ClientSocket，用于发送或接收数据，如果建立的连接数大于一，可以在服务器端再定义CMySocket对象，但要注意连接数不要大于五。

　　由于Socket API函数还有许多，如获取远端服务器、本地客户机的IP地址、主机名等等，读者可以再此基础上对CMySocket补充完善，实现更多的功能。
TCP/IP Winsock编程要点
利用Winsock编程由同步和异步方式，同步方式逻辑清晰，编程专注于应用，在抢先式的多任务操作系统中(WinNt、Win2K)采用多线程方式效率基本达到异步方式的水平，应此以下为同步方式编程要点。

　　1、快速通信

　　Winsock的Nagle算法将降低小数据报的发送速度，而系统默认是使用Nagle算法,使用

int setsockopt(

SOCKET s,

int level,

int optname,

const char FAR *optval,

int optlen

);函数关闭它

　　例子：

SOCKET sConnect;

sConnect=::socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);

int bNodelay = 1;

int err;

err = setsockopt(

sConnect,

IPPROTO_TCP,

TCP_NODELAY,

(char *)&bNodelay,

sizoeof(bNodelay));//不采用延时算法

if (err != NO_ERROR)

TRACE ("setsockopt failed for some reason\n");;

　　2、SOCKET的SegMentSize和收发缓冲

　　TCPSegMentSize是发送接受时单个数据报的最大长度，系统默认为1460，收发缓冲大小为8192。

　　在SOCK_STREAM方式下，如果单次发送数据超过1460，系统将分成多个数据报传送，在对方接受到的将是一个数据流，应用程序需要增加断帧的判断。当然可以采用修改注册表的方式改变1460的大小，但MicrcoSoft认为1460是最佳效率的参数，不建议修改。

　　在工控系统中，建议关闭Nagle算法，每次发送数据小于1460个字节（推荐1400），这样每次发送的是一个完整的数据报，减少对方对数据流的断帧处理。

　　3、同步方式中减少断网时connect函数的阻塞时间

　　同步方式中的断网时connect的阻塞时间为20秒左右，可采用gethostbyaddr事先判断到服务主机的路径是否是通的，或者先ping一下对方主机的IP地址。

　　A、采用gethostbyaddr阻塞时间不管成功与否为4秒左右。

　　例子：

LONG lPort=3024;

struct sockaddr_in ServerHostAddr;//服务主机地址

ServerHostAddr.sin_family=AF_INET;

ServerHostAddr.sin_port=::htons(u_short(lPort));

ServerHostAddr.sin_addr.s_addr=::inet_addr("192.168.1.3");

HOSTENT* pResult=gethostbyaddr((const char *) &

(ServerHostAddr.sin_addr.s_addr),4,AF_INET);

if(NULL==pResult)

{

int nErrorCode=WSAGetLastError();

TRACE("gethostbyaddr errorcode=%d",nErrorCode);

}

else

{

TRACE("gethostbyaddr %s\n",pResult->h_name);;

}

　　B、采用PING方式时间约2秒左右

　　暂略
4、同步方式中解决recv，send阻塞问题

　　采用select函数解决，在收发前先检查读写可用状态。

　　A、读

　　例子：

TIMEVAL tv01 = {0, 1};//1ms钟延迟,实际为0-10毫秒

int nSelectRet;

int nErrorCode;

FD_SET fdr = {1, sConnect};

nSelectRet=::select(0, &fdr, NULL, NULL, &tv01);//检查可读状态

if(SOCKET_ERROR==nSelectRet)

{

nErrorCode=WSAGetLastError();

TRACE("select read status errorcode=%d",nErrorCode);

::closesocket(sConnect);

goto 重新连接（客户方），或服务线程退出（服务方）;

}

if(nSelectRet==0)//超时发生，无可读数据

{

继续查读状态或向对方主动发送

}

else

{

读数据

}

　　B、写

TIMEVAL tv01 = {0, 1};//1ms钟延迟,实际为9-10毫秒

int nSelectRet;

int nErrorCode;

FD_SET fdw = {1, sConnect};

nSelectRet=::select(0, NULL, NULL,&fdw, &tv01);//检查可写状态

if(SOCKET_ERROR==nSelectRet)

{

nErrorCode=WSAGetLastError();

TRACE("select write status errorcode=%d",nErrorCode);

::closesocket(sConnect);

//goto 重新连接（客户方），或服务线程退出（服务方）;

}

if(nSelectRet==0)//超时发生，缓冲满或网络忙

{

//继续查写状态或查读状态

}

else

{

//发送

}

　　5、改变TCP收发缓冲区大小

　　系统默认为8192，利用如下方式可改变。

SOCKET sConnect;

sConnect=::socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);

int nrcvbuf=1024*20;

int err=setsockopt(

sConnect,

SOL_SOCKET,

SO_SNDBUF,//写缓冲，读缓冲为SO_RCVBUF

(char *)&nrcvbuf,

sizeof(nrcvbuf));

if (err != NO_ERROR)

{

TRACE("setsockopt Error!\n");

}

在设置缓冲时，检查是否真正设置成功用

int getsockopt(

SOCKET s,

int level,

int optname,

char FAR *optval,

int FAR *optlen

);

　　6、服务方同一端口多IP地址的bind和listen

　　在可靠性要求高的应用中，要求使用双网和多网络通道，再服务方很容易实现，用如下方式可建立客户对本机所有IP地址在端口3024下的请求服务。

SOCKET hServerSocket_DS=INVALID_SOCKET;

struct sockaddr_in HostAddr_DS;//服务器主机地址

LONG lPort=3024;

HostAddr_DS.sin_family=AF_INET;

HostAddr_DS.sin_port=::htons(u_short(lPort));

HostAddr_DS.sin_addr.s_addr=htonl(INADDR_ANY);

hServerSocket_DS=::socket( AF_INET, SOCK_STREAM,IPPROTO_TCP);

if(hServerSocket_DS==INVALID_SOCKET)

{

AfxMessageBox("建立数据服务器SOCKET 失败!");

return FALSE;

}

if(SOCKET_ERROR==::bind(hServerSocket_DS,(struct

sockaddr *)(&(HostAddr_DS)),sizeof(SOCKADDR)))

{

int nErrorCode=WSAGetLastError ();

TRACE("bind error=%d\n",nErrorCode);

AfxMessageBox("Socket Bind 错误!");

return FALSE;

}

if(SOCKET_ERROR==::listen(hServerSocket_DS,10))//10个客户

{

AfxMessageBox("Socket listen 错误!");

return FALSE;

}

AfxBeginThread(ServerThreadProc,NULL,THREAD_PRIORITY_NORMAL);

　　在客户方要复杂一些，连接断后，重联不成功则应换下一个IP地址连接。也可采用同时连接好后备用的方式。

　　7、用TCP/IP Winsock实现变种Client/Server

　　传统的Client/Server为客户问、服务答，收发是成对出现的。而变种的Client/Server是指在连接时有客户和服务之分，建立好通信连接后，不再有严格的客户和服务之分，任何方都可主动发送，需要或不需要回答看应用而言，这种方式在工控行业很有用，比如RTDB作为I/O Server的客户，但I/O Server也可主动向RTDB发送开关状态变位、随即事件等信息。在很大程度上减少了网络通信负荷、提高了效率。

　　采用1-6的TCP/IP编程要点，在Client和Server方均已接收优先，适当控制时序就能实现。
Windows Sockets API实现网络异步通讯
摘要：本文对如何使用面向连接的流式套接字实现对网卡的编程以及如何实现异步网络通讯等问题进行了讨论与阐述。

　　一、 引言

　　在80年代初，美国加利福尼亚大学伯克利分校的研究人员为TCP/IP网络通信开发了一个专门用于网络通讯开发的API。这个API就是Socket接口（套接字）--当今在TCP/IP网络最为通用的一种API，也是在互联网上进行应用开发最为通用的一种API。在微软联合其它几家公司共同制定了一套Windows下的网络编程接口Windows Sockets规范后，由于在其规范中引入了一些异步函数，增加了对网络事件异步选择机制，因此更加符合Windows的消息驱动特性，使网络开发人员可以更加方便的进行高性能网络通讯程序的设计。本文接下来就针对Windows Sockets API进行面向连接的流式套接字编程以及对异步网络通讯的编程实现等问题展开讨论。

　　二、 面向连接的流式套接字编程模型的设计

　　本文在方案选择上采用了在网络编程中最常用的一种模型--客户机/服务器模型。这种客户/服务器模型是一种非对称式编程模式。该模式的基本思想是把集中在一起的应用划分成为功能不同的两个部分，分别在不同的计算机上运行，通过它们之间的分工合作来实现一个完整的功能。对于这种模式而言其中一部分需要作为服务器，用来响应并为客户提供固定的服务；另一部分则作为客户机程序用来向服务器提出请求或要求某种服务。

　　本文选取了基于TCP/IP的客户机/服务器模型和面向连接的流式套接字。其通信原理为：服务器端和客户端都必须建立通信套接字，而且服务器端应先进入监听状态，然后客户端套接字发出连接请求，服务器端收到请求后，建立另一个套接字进行通信，原来负责监听的套接字仍进行监听，如果有其它客户发来连接请求，则再建立一个套接字。默认状态下最多可同时接收5个客户的连接请求，并与之建立通信关系。因此本程序的设计流程应当由服务器首先启动，然后在某一时刻启动客户机并使其与服务器建立连接。服务器与客户机开始都必须调用Windows Sockets API函数socket()建立一个套接字sockets,然后服务器方调用bind()将套接字与一个本地网络地址捆扎在一起，再调用listen()使套接字处于一种被动的准备接收状态，同时规定它的请求队列长度。在此之后服务器就可以通过调用accept()来接收客户机的连接。

　　相对于服务器，客户端的工作就显得比较简单了，当客户端打开套接字之后，便可通过调用connect()和服务器建立连接。连接建立之后，客户和服务器之间就可以通过连接发送和接收资料。最后资料传送结束，双方调用closesocket()关闭套接字来结束这次通讯。整个通讯过程的具体流程框图可大致用下面的流程图来表示：


　　　　　　　　面向连接的流式套接字编程流程示意图
　　三、 软件设计要点以及异步通讯的实现

　　根据前面设计的程序流程，可将程序划分为两部分：服务器端和客户端。而且整个实现过程可以大致用以下几个非常关键的Windows Sockets API函数将其惯穿下来：

　　服务器方：

socket()->bind()->listen->accept()->recv()/send()->closesocket()

　　客户机方：

socket()->connect()->send()/recv()->closesocket()

　　有鉴于以上几个函数在整个网络编程中的重要性，有必要结合程序实例对其做较深入的剖析。服务器端应用程序在使用套接字之前，首先必须拥有一个Socket，系统调用socket()函数向应用程序提供创建套接字的手段。该套接字实际上是在计算机中提供了一个通信埠，可以通过这个埠与任何一个具有套接字接口的计算机通信。应用程序在网络上传输、接收的信息都通过这个套接字接口来实现的。在应用开发中如同使用文件句柄一样，可以对套接字句柄进行读写操作：

sock=socket(AF_INET,SOCK_STREAM,0);

　　函数的第一个参数用于指定地址族，在Windows下仅支持AF_INET(TCP/IP地址)；第二个参数用于描述套接字的类型，对于流式套接字提供有SOCK_STREAM；最后一个参数指定套接字使用的协议，一般为0。该函数的返回值保存了新套接字的句柄，在程序退出前可以用 closesocket(sock);函数来将其释放。服务器方一旦获取了一个新的套接字后应通过bind()将该套接字与本机上的一个端口相关联：

sockin.sin_family=AF_INET;
sockin.sin_addr.s_addr=0;
sockin.sin_port=htons(USERPORT);
bind(sock,(LPSOCKADDR)&sockin,sizeof(sockin)));

　　该函数的第二个参数是一个指向包含有本机IP地址和端口信息的sockaddr_in结构类型的指针，其成员描述了本地端口号和本地主机地址，经过bind()将服务器进程在网络上标识出来。需要注意的是由于1024以内的埠号都是保留的埠号因此如无特别需要一般不能将sockin.sin_port的埠号设置为1024以内的值。然后调用listen()函数开始侦听，再通过accept()调用等待接收连接以完成连接的建立：

//连接请求队列长度为1，即只允许有一个请求,若有多个请求,
//则出现错误，给出错误代码WSAECONNREFUSED。
listen(sock,1);
//开启线程避免主程序的阻塞
AfxBeginThread(Server,NULL);
……
UINT Server(LPVOID lpVoid)
{
……
int nLen=sizeof(SOCKADDR);
pView->newskt=accept(pView->sock,(LPSOCKADDR)& pView->sockin,(LPINT)& nLen);
……
WSAAsyncSelect(pView->newskt,pView->m_hWnd,WM_SOCKET_MSG,FD_READ|FD_CLOSE);
return 1;
}

　　这里之所以把accept()放到一个线程中去是因为在执行到该函数时如没有客户连接服务器的请求到来，服务器就会停在accept语句上等待连接请求的到来，这势必会引起程序的阻塞，虽然也可以通过设置套接字为非阻塞方式使在没有客户等待时可以使accept（）函数调用立即返回，但这种轮询套接字的方式会使CPU处于忙等待方式，从而降低程序的运行效率大大浪费系统资源。考虑到这种情况，将套接字设置为阻塞工作方式，并为其单独开辟一个子线程，将其阻塞控制在子线程范围内而不会造成整个应用程序的阻塞。对于网络事件的响应显然要采取异步选择机制，只有采取这种方式才可以在由网络对方所引起的不可预知的网络事件发生时能马上在进程中做出及时的响应处理，而在没有网络事件到达时则可以处理其他事件，这种效率是很高的，而且完全符合Windows所标榜的消息触发原则。前面那段代码中的WSAAsyncSelect()函数便是实现网络事件异步选择的核心函数。
通过第四个参数注册应用程序感兴取的网络事件，在这里通过FD_READ|FD_CLOSE指定了网络读和网络断开两种事件，当这种事件发生时变会发出由第三个参数指定的自定义消息WM_SOCKET_MSG，接收该消息的窗口通过第二个参数指定其句柄。在消息处理函数中可以通过对消息参数低字节进行判断而区别出发生的是何种网络事件：

void CNetServerView::OnSocket(WPARAM wParam,LPARAM lParam)
{
int iReadLen=0;
int message=lParam & 0x0000FFFF;
switch(message)
{
case FD_READ://读事件发生。此时有字符到达，需要进行接收处理
char cDataBuffer[MTU*10];
//通过套接字接收信息
iReadLen = recv(newskt,cDataBuffer,MTU*10,0);
//将信息保存到文件
if(!file.Open("ServerFile.txt",CFile::modeReadWrite))
file.Open("E:ServerFile.txt",CFile::modeCreate|CFile::modeReadWrite);
file.SeekToEnd();
file.Write(cDataBuffer,iReadLen);
file.Close();
break;
case FD_CLOSE://网络断开事件发生。此时客户机关闭或退出。
……//进行相应的处理
break;
default:
break;
}
}

　　在这里需要实现对自定义消息WM_SOCKET_MSG的响应，需要在头文件和实现文件中分别添加其消息映射关系：

　　头文件：

//{{AFX_MSG(CNetServerView)
//}}AFX_MSG
void OnSocket(WPARAM wParam,LPARAM lParam);
DECLARE_MESSAGE_MAP()

　　实现文件：

BEGIN_MESSAGE_MAP(CNetServerView, CView)
//{{AFX_MSG_MAP(CNetServerView)
//}}AFX_MSG_MAP
ON_MESSAGE(WM_SOCKET_MSG,OnSocket)
END_MESSAGE_MAP()

　　在进行异步选择使用WSAAsyncSelect()函数时，有以下几点需要引起特别的注意：

　　1． 连续使用两次WSAAsyncSelect()函数时，只有第二次设置的事件有效，如：

WSAAsyncSelect(s,hwnd,wMsg1,FD_READ);
WSAAsyncSelect(s,hwnd,wMsg2,FD_CLOSE);

　　这样只有当FD_CLOSE事件发生时才会发送wMsg2消息。

　　2．可以在设置过异步选择后通过再次调用WSAAsyncSelect(s,hwnd,0,0);的形式取消在套接字上所设置的异步事件。

　　3．Windows Sockets DLL在一个网络事件发生后，通常只会给相应的应用程序发送一个消息，而不能发送多个消息。但通过使用一些函数隐式地允许重发此事件的消息，这样就可能再次接收到相应的消息。

　　4．在调用过closesocket()函数关闭套接字之后不会再发生FD_CLOSE事件。

　　以上基本完成了服务器方的程序设计，下面对于客户端的实现则要简单多了，在用socket()创建完套接字之后只需通过调用connect()完成同服务器的连接即可，剩下的工作同服务器完全一样：用send()/recv()发送/接收收据，用closesocket()关闭套接字：

sockin.sin_family=AF_INET; //地址族
sockin.sin_addr.S_un.S_addr=IPaddr; //指定服务器的IP地址
sockin.sin_port=m_Port; //指定连接的端口号
int nConnect=connect(sock,(LPSOCKADDR)&sockin,sizeof(sockin));

　　本文采取的是可靠的面向连接的流式套接字。在数据发送上有write()、writev()和send()等三个函数可供选择，其中前两种分别用于缓冲发送和集中发送，而send()则为可控缓冲发送，并且还可以指定传输控制标志为MSG_OOB进行带外数据的发送或是为MSG_DONTROUTE寻径控制选项。在信宿地址的网络号部分指定数据发送需要经过的网络接口，使其可以不经过本地寻径机制直接发送出去。这也是其同write()函数的真正区别所在。由于接收数据系统调用和发送数据系统调用是一一对应的，因此对于数据的接收，在此不再赘述，相应的三个接收函数分别为：read()、readv()和recv()。由于后者功能上的全面，本文在实现上选择了send()-recv()函数对，在具体编程中应当视具体情况的不同灵活选择适当的发送-接收函数对。

　　小结：TCP/IP协议是目前各网络操作系统主要的通讯协议，也是 Internet的通讯协议，本文通过Windows Sockets API实现了对基于TCP/IP协议的面向连接的流式套接字网络通讯程序的设计，并通过异步通讯和多线程等手段提高了程序的运行效率，避免了阻塞的发生。
用VC++6.0的Sockets API实现一个聊天室程序
1.VC++网络编程及Windows Sockets API简介

　　VC++对网络编程的支持有socket支持，WinInet支持，MAPI和ISAPI支持等。其中，Windows Sockets API是TCP/IP网络环境里，也是Internet上进行开发最为通用的API。最早美国加州大学Berkeley分校在UNIX下为TCP/IP协议开发了一个API，这个API就是著名的Berkeley Socket接口(套接字)。在桌面操作系统进入Windows时代后，仍然继承了Socket方法。在TCP/IP网络通信环境下，Socket数据传输是一种特殊的I/O，它也相当于一种文件描述符，具有一个类似于打开文件的函数调用-socket()。可以这样理解：Socket实际上是一个通信端点，通过它，用户的Socket程序可以通过网络和其他的Socket应用程序通信。Socket存在于一个"通信域"(为描述一般的线程如何通过Socket进行通信而引入的一种抽象概念)里，并且与另一个域的Socket交换数据。Socket有三类。第一种是SOCK_STREAM(流式)，提供面向连接的可靠的通信服务，比如telnet,http。第二种是SOCK_DGRAM(数据报)，提供无连接不可靠的通信，比如UDP。第三种是SOCK_RAW(原始)，主要用于协议的开发和测试，支持通信底层操作，比如对IP和ICMP的直接访问。

　　2.Windows Socket机制分析

　　2.1一些基本的Socket系统调用

　　主要的系统调用包括：socket()-创建Socket；bind()-将创建的Socket与本地端口绑定；connect()与accept()-建立Socket连接；listen()-服务器监听是否有连接请求；send()-数据的可控缓冲发送；recv()-可控缓冲接收；closesocket()-关闭Socket。

　　2.2Windows Socket的启动与终止

　　启动函数WSAStartup()建立与Windows Sockets DLL的连接，终止函数WSAClearup()终止使用该DLL，这两个函数必须成对使用。

　　2.3异步选择机制

　　Windows是一个非抢占式的操作系统，而不采取UNIX的阻塞机制。当一个通信事件产生时，操作系统要根据设置选择是否对该事件加以处理，WSAAsyncSelect()函数就是用来选择系统所要处理的相应事件。当Socket收到设定的网络事件中的一个时，会给程序窗口一个消息，这个消息里会指定产生网络事件的Socket，发生的事件类型和错误码。

　　2.4异步数据传输机制

　　WSAAsyncSelect()设定了Socket上的须响应通信事件后，每发生一个这样的事件就会产生一个WM_SOCKET消息传给窗口。而在窗口的回调函数中就应该添加相应的数据传输处理代码。

　　3.聊天室程序的设计说明

　　3.1实现思想

　　在Internet上的聊天室程序一般都是以服务器提供服务端连接响应，使用者通过客户端程序登录到服务器，就可以与登录在同一服务器上的用户交谈，这是一个面向连接的通信过程。因此，程序要在TCP/IP环境下，实现服务器端和客户端两部分程序。

　　3.2服务器端工作流程

　　服务器端通过socket()系统调用创建一个Socket数组后(即设定了接受连接客户的最大数目)，与指定的本地端口绑定bind()，就可以在端口进行侦听listen()。如果有客户端连接请求，则在数组中选择一个空Socket，将客户端地址赋给这个Socket。然后登录成功的客户就可以在服务器上聊天了。

　　3.3客户端工作流程

　　客户端程序相对简单，只需要建立一个Socket与服务器端连接，成功后通过这个Socket来发送和接收数据就可以了。
4.核心代码分析

　　限于篇幅，这里仅给出与网络编程相关的核心代码，其他的诸如聊天文字的服务器和客户端显示读者可以自行添加。

　　4.1服务器端代码

　　开启服务器功能:

void OnServerOpen() //开启服务器功能
{
　WSADATA wsaData;
　int iErrorCode;
　char chInfo[64];
　if (WSAStartup(WINSOCK_VERSION, &wsaData)) //调用Windows Sockets DLL
　　{ MessageBeep(MB_ICONSTOP);
　　　MessageBox("Winsock无法初始化!", AfxGetAppName(), MB_OK|MB_ICONSTOP);
　　　WSACleanup();
　　　return; }
　else
　　WSACleanup();
　　if (gethostname(chInfo, sizeof(chInfo)))
　　{ ReportWinsockErr("\n无法获取主机!\n ");
　　　return; }
　　CString csWinsockID = "\n==>>服务器功能开启在端口：No. ";
　　csWinsockID += itoa(m_pDoc->m_nServerPort, chInfo, 10);
　　csWinsockID += "\n";
　　PrintString(csWinsockID); //在程序视图显示提示信息的函数，读者可自行创建
　　m_pDoc->m_hServerSocket=socket(PF_INET, SOCK_STREAM, DEFAULT_PROTOCOL);
　　//创建服务器端Socket，类型为SOCK_STREAM，面向连接的通信
　　if (m_pDoc->m_hServerSocket == INVALID_SOCKET)
　　{ ReportWinsockErr("无法创建服务器socket!");
　　　return;}
　　m_pDoc->m_sockServerAddr.sin_family = AF_INET;
　　m_pDoc->m_sockServerAddr.sin_addr.s_addr = INADDR_ANY;
　　m_pDoc->m_sockServerAddr.sin_port = htons(m_pDoc->m_nServerPort);
　　if (bind(m_pDoc->m_hServerSocket, (LPSOCKADDR)&m_pDoc->m_sockServerAddr, 　　
　　　　 sizeof(m_pDoc->m_sockServerAddr)) == SOCKET_ERROR) //与选定的端口绑定
　　　{ReportWinsockErr("无法绑定服务器socket!");
　　　　return;}
　　　iErrorCode=WSAAsyncSelect(m_pDoc->m_hServerSocket,m_hWnd,
　　　WM_SERVER_ACCEPT, FD_ACCEPT);
　　　//设定服务器相应的网络事件为FD_ACCEPT，即连接请求，
　　　// 产生相应传递给窗口的消息为WM_SERVER_ACCEPT
　　if (iErrorCode == SOCKET_ERROR)
　　　{ ReportWinsockErr("WSAAsyncSelect设定失败!");
　　　　return;}
　　if (listen(m_pDoc->m_hServerSocket, QUEUE_SIZE) == SOCKET_ERROR) //开始监听客户连接请求
　　　{ReportWinsockErr("服务器socket监听失败!");
　　　　m_pParentMenu->EnableMenuItem(ID_SERVER_OPEN, MF_ENABLED);
　　　　return;}
　　m_bServerIsOpen = TRUE; //监视服务器是否打开的变量
　return;
}

　　响应客户发送聊天文字到服务器：ON_MESSAGE(WM_CLIENT_READ, OnClientRead)

LRESULT OnClientRead(WPARAM wParam, LPARAM lParam)
{
　int iRead;
　int iBufferLength;
　int iEnd;
　int iRemainSpace;
　char chInBuffer[1024];
　int i;
　for(i=0;(i<MAXCLIENT)&&(M_ACLIENTSOCKET[I]!=WPARAM);I++)
　　//MAXClient是服务器可响应连接的最大数目
　　{}
　if(i==MAXClient) return 0L;
　　iBufferLength = iRemainSpace = sizeof(chInBuffer);
　　iEnd = 0;
　　iRemainSpace -= iEnd;
　　iBytesRead = recv(m_aClientSocket[i], (LPSTR)(chInBuffer+iEnd), iSpaceRemaining, NO_FLAGS); 　　//用可控缓冲接收函数recv()来接收字符
　　iEnd+=iRead;
　if (iBytesRead == SOCKET_ERROR)
　　ReportWinsockErr("recv出错!");
　　chInBuffer[iEnd] = '\0';
　if (lstrlen(chInBuffer) != 0)
　　{PrintString(chInBuffer); //服务器端文字显示
　　　OnServerBroadcast(chInBuffer); //自己编写的函数，向所有连接的客户广播这个客户的聊天文字
　　}
　return(0L);
}

　　对于客户断开连接，会产生一个FD_CLOSE消息，只须相应地用closesocket()关闭相应的Socket即可，这个处理比较简单。

　　4.2客户端代码

　　连接到服务器：

void OnSocketConnect()
{ WSADATA wsaData;
　DWORD dwIPAddr;
　SOCKADDR_IN sockAddr;
　if(WSAStartup(WINSOCK_VERSION,&wsaData)) //调用Windows Sockets DLL
　{MessageBox("Winsock无法初始化!",NULL,MB_OK);
　　return;
　}
　m_hSocket=socket(PF_INET,SOCK_STREAM,0); //创建面向连接的socket
　sockAddr.sin_family=AF_INET; //使用TCP/IP协议
　sockAddr.sin_port=m_iPort; //客户端指定的IP地址
　sockAddr.sin_addr.S_un.S_addr=dwIPAddr;
　int nConnect=connect(m_hSocket,(LPSOCKADDR)&sockAddr,sizeof(sockAddr)); //请求连接
　if(nConnect)
　　ReportWinsockErr("连接失败!");
　else
　　MessageBox("连接成功!",NULL,MB_OK);
　　int iErrorCode=WSAAsyncSelect(m_hSocket,m_hWnd,WM_SOCKET_READ,FD_READ);
　　//指定响应的事件，为服务器发送来字符
　if(iErrorCode==SOCKET_ERROR)
　MessageBox("WSAAsyncSelect设定失败!");
}

　　接收服务器端发送的字符也使用可控缓冲接收函数recv()，客户端聊天的字符发送使用数据可控缓冲发送函数send()，这两个过程比较简单，在此就不加赘述了。

　　5.小结

　　通过聊天室程序的编写，可以基本了解Windows Sockets API编程的基本过程和精要之处。本程序在VC++6.0下编译通过，在使用windows 98/NT的局域网里运行良好。
用VC++制作一个简单的局域网消息发送工程
本工程类似于oicq的消息发送机制，不过他只能够发送简单的字符串。虽然简单，但他也是一个很好的VC网络学习例子。

　　本例通过VC带的SOCKET类，重载了他的一个接受类mysock类，此类可以吧接收到的信息显示在客户区理。以下是实现过程：

　　建立一个MFC 单文档工程，工程名为oicq,在第四步选取WINDOWS SOCKetS支持，其它取默认设置即可。为了简单，这里直接把about对话框作些改变，作为发送信息界面。

　　这里通过失去对话框来得到发送的字符串、获得焦点时把字符串发送出去。创建oicq类的窗口，获得VIEW类指针，进而可以把接收到的信息显示出来。

extern CString bb;
void CAboutDlg::OnKillFocus(CWnd* pNewWnd)
{
　// TODO: Add your message handler code here
　CDialog::OnKillFocus(pNewWnd);
　bb=m_edit;
}
对于OICQVIEW类
char aa[100];
CString mm;
CDC* pdc;
class mysock:public CSocket //派生mysock类，此类既有接受功能
{public:void OnReceive(int nErrorCode) //可以随时接收信息
　{
　　CSocket::Receive((void*)aa,100,0);
　　mm=aa;
　　CString ll=" ";//在显示消息之前，消除前面发送的消息
　　pdc->TextOut(50,50,ll);
　　pdc->TextOut(50,50,mm);
　}
};

mysock sock1;
CString bb;
BOOL COicqView::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
{
　CView::OnSetFocus(pOldWnd);

　// TODO: Add your message handler code here and/or call default
　bb="besting:"+bb; //确定发送者身份为besting
　sock1.SendTo(bb,100,1060,"192.168.0.255",0); //获得焦点以广播形式发送信息，端口号为1060

　return CView::OnSetCursor(pWnd, nHitTest, message);
}

int COicqView::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
　if (CView::OnCreate(lpCreateStruct) == -1)
　　return -1;
　　sock1.Create(1060,SOCK_DGRAM,NULL);//以数据报形式发送消息

　　static CClientDC wdc(this); //获得当前视类的指针
　　pdc=&wdc;
　　// TODO: Add your specialized creation code here

　　return 0;
}

运行一下，打开ABOUT对话框，输入发送信息，enter键就可以发送信息了，是不是有点像qq啊？

 

谈起socket编程，大家也许会想起QQ和IE，没错。还有许多网络工具如P2P、NetMeeting等在应用层实现的应用程序，也是用socket来实现的。Socket是一个网络编程接口，实现于网络应用层，Windows Socket包括了一套系统组件，充分利用了Microsoft Windows 消息驱动的特点。Socket规范1.1版是在1993年1月发行的，并广泛用于此后出现的Windows9x操作系统中。Socket规范2.2版（其在Windows平台上的版本是Winsock2.2，也叫Winsock2）在 1996 年 5 月发行，Windows NT 5.0及以后版本的Windows系统支持Winsock2，在Winsock2中，支持多个传输协议的原始套接字，重叠I/O模型、服务质量控制等。

本文向大家介绍Windows Sockets的一些关于用C#实现的原始套接字(Raw Socket)的编程，以及在此基础上实现的网络封包监视技术。同Winsock1相比，Winsock2最明显的就是支持了Raw Socket套接字类型，使用Raw Socket，可把网卡设置成混杂模式，在这种模式下，我们可以收到网络上的IP包，当然包括目的不是本机的IP包，通过原始套接字，我们也可以更加自如地控制Windows下的多种协议，而且能够对网络底层的传输机制进行控制。

在本文例子中，我在nbyte.BasicClass命名空间实现了RawSocket类，它包含了我们实现数据包监视的核心技术。在实现这个类之前，需要先写一个IP头结构，来暂时存放一些有关网络封包的信息：

[StructLayout(LayoutKind.Explicit)]
public struct IPHeader
{
[FieldOffset(0)] public byte ip_verlen; //I4位首部长度+4位IP版本号
[FieldOffset(1)] public byte ip_tos; //8位服务类型TOS
[FieldOffset(2)] public ushort ip_totallength; //16位数据包总长度（字节）
[FieldOffset(4)] public ushort ip_id; //16位标识
[FieldOffset(6)] public ushort ip_offset; //3位标志位
[FieldOffset(8)] public byte ip_ttl; //8位生存时间 TTL
[FieldOffset(9)] public byte ip_protocol; //8位协议(TCP, UDP, ICMP, Etc.)
[FieldOffset(10)] public ushort ip_checksum; //16位IP首部校验和
[FieldOffset(12)] public uint ip_srcaddr; //32位源IP地址
[FieldOffset(16)] public uint ip_destaddr; //32位目的IP地址
}

这样，当每一个封包到达时候，可以用强制类型转化把包中的数据流转化为一个个IPHeader对象。
下面就开始写RawSocket类了，一开始，先定义几个参数，包括：
private bool error_occurred; //套接字在接收包时是否产生错误
public bool KeepRunning; //是否继续进行
private static int len_receive_buf; //得到的数据流的长度
byte [] receive_buf_bytes; //收到的字节
private Socket socket = null; //声明套接字
还有一个常量：
const int SIO_RCVALL = unchecked((int)0x98000001);//监听所有的数据包

这里的SIO_RCVALL是指示RawSocket接收所有的数据包，在以后的IOContrl函数中要用，在下面的构造函数中，实现了对一些变量参数的初始化：

public RawSocket() //构造函数
{
error_occurred=false;
len_receive_buf = 4096;
receive_buf_bytes = new byte[len_receive_buf];
}

下面的函数实现了创建RawSocket，并把它与终结点（IPEndPoint：本机IP和端口）绑定：
public void CreateAndBindSocket(string IP) //建立并绑定套接字
{
socket = new Socket(AddressFamily.InterNetwork, SocketType.Raw, ProtocolType.IP);
socket.Blocking = false; //置socket非阻塞状态
socket.Bind(new IPEndPoint(IPAddress.Parse(IP), 0)); //绑定套接字

if (SetSocketOption()==false) error_occurred=true;
}
其中，在创建套接字的一句socket = new Socket(AddressFamily.InterNetwork, SocketType.Raw, ProtocolType.IP);中有3个参数：

第一个参数是设定地址族，MSDN上的描述是“指定 Socket 实例用来解析地址的寻址方案”，当要把套接字绑定到终结点（IPEndPoint）时，需要使用InterNetwork成员，即采用IP版本4的地址格式，这也是当今大多数套接字编程所采用一个寻址方案（AddressFamily）。

第二个参数设置的套接字类型就是我们使用的Raw类型了，SocketType是一个枚举数据类型，Raw套接字类型支持对基础传输协议的访问。通过使用 SocketType.Raw，你不光可以使用传输控制协议(Tcp)和用户数据报协议(Udp)进行通信，也可以使用网际消息控制协议 (Icmp) 和 Internet 组管理协议 (Igmp) 来进行通信。在发送时，您的应用程序必须提供完整的 IP 标头。所接收的数据报在返回时会保持其 IP 标头和选项不变。

第三个参数设置协议类型，Socket 类使用 ProtocolType 枚举数据类型向 Windows Socket API 通知所请求的协议。这里使用的是IP协议，所以要采用ProtocolType.IP参数。

在CreateAndBindSocket函数中有一个自定义的SetSocketOption函数，它和Socket类中的SetSocketOption不同，我们在这里定义的是具有IO控制功能的SetSocketOption，它的定义如下：

private bool SetSocketOption() //设置raw socket
{
bool ret_value = true;
try
{
socket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.HeaderIncluded, 1);
byte []IN = new byte[4]{1, 0, 0, 0};
byte []OUT = new byte[4];

//低级别操作模式,接受所有的数据包，这一步是关键，必须把socket设成raw和IP Level才可用SIO_RCVALL
int ret_code = socket.IOControl(SIO_RCVALL, IN, OUT);
ret_code = OUT[0] + OUT[1] + OUT[2] + OUT[3];//把4个8位字节合成一个32位整数
if(ret_code != 0) ret_value = false;
}
catch(SocketException)
{
ret_value = false;
}
return ret_value;
}

其中，设置套接字选项时必须使套接字包含IP包头，否则无法填充IPHeader结构，也无法获得数据包信息。
int ret_code = socket.IOControl(SIO_RCVALL, IN, OUT);是函数中最关键的一步了，因为，在windows中我们不能用Receive函数来接收raw socket上的数据，这是因为，所有的IP包都是先递交给系统核心，然后再传输到用户程序，当发送一个raws socket包的时候（比如syn），核心并不知道，也没有这个数据被发送或者连接建立的记录，因此，当远端主机回应的时候，系统核心就把这些包都全部丢掉，从而到不了应用程序上。所以，就不能简单地使用接收函数来接收这些数据报。要达到接收数据的目的，就必须采用嗅探，接收所有通过的数据包，然后进行筛选，留下符合我们需要的。可以通过设置SIO_RCVALL，表示接收所有网络上的数据包。接下来介绍一下IOControl函数。MSDN解释它说是设置套接字为低级别操作模式，怎么低级别操作法？其实这个函数与API中的WSAIoctl函数很相似。WSAIoctl函数定义如下：

int WSAIoctl(
SOCKET s, //一个指定的套接字
DWORD dwIoControlCode, //控制操作码
LPVOID lpvInBuffer, //指向输入数据流的指针
DWORD cbInBuffer, //输入数据流的大小（字节数）
LPVOID lpvOutBuffer, // 指向输出数据流的指针
DWORD cbOutBuffer, //输出数据流的大小（字节数）
LPDWORD lpcbBytesReturned, //指向输出字节流数目的实数值
LPWSAOVERLAPPED lpOverlapped, //指向一个WSAOVERLAPPED结构
LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine//指向操作完成时执行的例程
);

C#的IOControl函数不像WSAIoctl函数那么复杂，其中只包括其中的控制操作码、输入字节流、输出字节流三个参数，不过这三个参数已经足够了。我们看到函数中定义了一个字节数组：byte []IN = new byte[4]{1, 0, 0, 0}实际上它是一个值为1的DWORD或是Int32，同样byte []OUT = new byte[4];也是，它整和了一个int,作为WSAIoctl函数中参数lpcbBytesReturned指向的值。
因为设置套接字选项时可能会发生错误，需要用一个值传递错误标志：

public bool ErrorOccurred
{
get
{
return error_occurred;
}
}

下面的函数实现的数据包的接收：

//解析接收的数据包，形成PacketArrivedEventArgs事件数据类对象，并引发PacketArrival事件
unsafe private void Receive(byte [] buf, int len)
{
byte temp_protocol=0;
uint temp_version=0;
uint temp_ip_srcaddr=0;
uint temp_ip_destaddr=0;
short temp_srcport=0;
short temp_dstport=0;
IPAddress temp_ip;

PacketArrivedEventArgs e=new PacketArrivedEventArgs();//新网络数据包信息事件

fixed(byte *fixed_buf = buf)
{
IPHeader * head = (IPHeader *) fixed_buf;//把数据流整和为IPHeader结构
e.HeaderLength=(uint)(head->ip_verlen & 0x0F) << 2;

temp_protocol = head->ip_protocol;
switch(temp_protocol)//提取协议类型
{
case 1: e.Protocol="ICMP"; break;
case 2: e.Protocol="IGMP"; break;
case 6: e.Protocol="TCP"; break;
case 17: e.Protocol="UDP"; break;
default: e.Protocol= "UNKNOWN"; break;
}

temp_version =(uint)(head->ip_verlen & 0xF0) >> 4;//提取IP协议版本
e.IPVersion = temp_version.ToString();

//以下语句提取出了PacketArrivedEventArgs对象中的其他参数
temp_ip_srcaddr = head->ip_srcaddr;
temp_ip_destaddr = head->ip_destaddr;
temp_ip = new IPAddress(temp_ip_srcaddr);
e.OriginationAddress =temp_ip.ToString();
temp_ip = new IPAddress(temp_ip_destaddr);
e.DestinationAddress = temp_ip.ToString();

temp_srcport = *(short *)&fixed_buf[e.HeaderLength];
temp_dstport = *(short *)&fixed_buf[e.HeaderLength+2];
e.OriginationPort=IPAddress.NetworkToHostOrder(temp_srcport).ToString();
e.DestinationPort=IPAddress.NetworkToHostOrder(temp_dstport).ToString();

e.PacketLength =(uint)len;
e.MessageLength =(uint)len - e.HeaderLength;

e.ReceiveBuffer=buf;
//把buf中的IP头赋给PacketArrivedEventArgs中的IPHeaderBuffer
Array.Copy(buf,0,e.IPHeaderBuffer,0,(int)e.HeaderLength);
//把buf中的包中内容赋给PacketArrivedEventArgs中的MessageBuffer
Array.Copy(buf,(int)e.HeaderLength,e.MessageBuffer,0,(int)e.MessageLength);
}
//引发PacketArrival事件
OnPacketArrival(e);
}

大家注意到了，在上面的函数中，我们使用了指针这种所谓的不安全代码，可见在C#中指针和移位运算这些原始操作也可以给程序员带来编程上的便利。在函数中声明PacketArrivedEventArgs类对象，以便通过OnPacketArrival(e)函数通过事件把数据包信息传递出去。其中PacketArrivedEventArgs类是RawSocket类中的嵌套类，它继承了系统事件（Event）类，封装了数据包的IP、端口、协议等其他数据包头中包含的信息。在启动接收数据包的函数中，我们使用了异步操作的方法，以下函数开启了异步监听的接口：

public void Run() //开始监听
{
IAsyncResult ar = socket.BeginReceive(receive_buf_bytes, 0, len_receive_buf, SocketFlags.None, new AsyncCallback(CallReceive), this);
}

Socket.BeginReceive函数返回了一个异步操作的接口，并在此接口的生成函数BeginReceive中声明了异步回调函数CallReceive，并把接收到的网络数据流传给receive_buf_bytes，这样就可用一个带有异步操作的接口参数的异步回调函数不断地接收数据包：

private void CallReceive(IAsyncResult ar)//异步回调
{
int received_bytes;
received_bytes = socket.EndReceive(ar);
Receive(receive_buf_bytes, received_bytes);
if (KeepRunning) Run();
}

此函数当挂起或结束异步读取后去接收一个新的数据包，这样能保证让每一个数据包都能够被程序探测到。
下面通过声明代理事件句柄来实现和外界的通信：

public delegate void PacketArrivedEventHandler(Object sender, PacketArrivedEventArgs args);
//事件句柄：包到达时引发事件
public event PacketArrivedEventHandler PacketArrival;//声明时间句柄函数

这样就可以实现对数据包信息的获取，采用异步回调函数，可以提高接收数据包的效率，并通过代理事件把封包信息传递到外界。既然能把所有的封包信息传递出去，就可以实现对数据包的分析了：）不过RawSocket的任务还没有完，最后不要望了关闭套接字啊：

public void Shutdown() //关闭raw socket
{
if(socket != null)
{
socket.Shutdown(SocketShutdown.Both);
socket.Close();
}
}

以上介绍了RawSocket类通过构造IP头获取了包中的信息，并通过异步回调函数实现了数据包的接收，并使用时间代理句柄和自定义的数据包信息事件类把数据包信息发送出去，从而实现了网络数据包的监视，这样我们就可以在外部添加一些函数对数据包进行分析了。

 

using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;

 

using System.Threading;
using System.Net.Sockets;
using System.Net;
namespace Chat_Server
{
/// <summary>
/// Form1 的摘要说明。
/// </summary>
public class Form1 : System.Windows.Forms.Form
{
/// <summary>
/// 必需的设计器变量。
/// </summary>
private System.ComponentModel.Container components = null;

static int listenport=6666;
Socket clientsocket;
private System.Windows.Forms.ListBox lbClients;
ArrayList clients;
private System.Windows.Forms.Button button1;
Thread clientservice;
private System.Windows.Forms.Label label1;
Thread threadListen;

public Form1()
{

InitializeComponent();

}

/// <summary>
/// 清理所有正在使用的资源。
/// </summary>
protected override void Dispose( bool disposing )
{
if( disposing )
{

if(clientservice != null)
{
clientservice.Abort();
}
if(threadListen != null)
{
try
{
threadListen.Abort();
}
catch(Exception ex)
{
threadListen = null;
}
}

if (components != null)
{
components.Dispose();
}
}
base.Dispose( disposing );

}

#region Windows 窗体设计器生成的代码
/// <summary>
/// 设计器支持所需的方法 - 不要使用代码编辑器修改
/// 此方法的内容。
/// </summary>
private void InitializeComponent()
{
this.lbClients = new System.Windows.Forms.ListBox();
this.button1 = new System.Windows.Forms.Button();
this.label1 = new System.Windows.Forms.Label();
this.SuspendLayout();
//
// lbClients
//
this.lbClients.ItemHeight = 12;
this.lbClients.Location = new System.Drawing.Point(16, 24);
this.lbClients.Name = "lbClients";
this.lbClients.Size = new System.Drawing.Size(184, 268);
this.lbClients.TabIndex = 0;
//
// button1
//
this.button1.Location = new System.Drawing.Point(272, 56);
this.button1.Name = "button1";
this.button1.TabIndex = 1;
this.button1.Text = "button1";
this.button1.Click += new System.EventHandler(this.button1_Click);
//
// label1
//
this.label1.Location = new System.Drawing.Point(240, 136);
this.label1.Name = "label1";
this.label1.Size = new System.Drawing.Size(120, 32);
this.label1.TabIndex = 2;
this.label1.Text = "label1";
//
// Form1
//
this.AutoScaleBaseSize = new System.Drawing.Size(6, 14);
this.ClientSize = new System.Drawing.Size(368, 309);
this.Controls.Add(this.label1);
this.Controls.Add(this.button1);
this.Controls.Add(this.lbClients);
this.Name = "Form1";
this.Text = "Form1";
this.Load += new System.EventHandler(this.Form1_Load);
this.ResumeLayout(false);

}
#endregion

/// <summary>
/// 应用程序的主入口点。
/// </summary>
[STAThread]
static void Main()
{
Application.Run(new Form1());
}

private void StartListening()
{
　 TcpListener listener = new TcpListener(listenport);
　 listener.Start();
label1.Text = "listening....";
while (true)
{
try
{

Socket s = listener.AcceptSocket();
clientsocket = s;
clientservice = new Thread(new ThreadStart(ServiceClient));
clientservice.Start();
}
catch(Exception ex)
{
MessageBox.Show("listening Error: "+ex.Message);
}
}
}
private void ServiceClient()
{
Socket client = clientsocket;
bool keepalive = true;

while (keepalive)
{
Byte[] buffer = new Byte[1024];
int bufLen = 0;
try
{
bufLen = client.Available ;

client.Receive(buffer,0,bufLen,SocketFlags.None);
if(bufLen==0)
continue;
}
catch(Exception ex)
{
MessageBox.Show("Receive Error:"+ex.Message);
return;
}

string clientcommand = System.Text.Encoding.ASCII.GetString(buffer).Substring(0,bufLen);

string[] tokens = clientcommand.Split(new Char[]{'|'});
Console.WriteLine(clientcommand);

if (tokens[0] == "CONN")
{
for(int n=0; n<clients.Count;n++)
{
Client cl = (Client)clients[n];
SendToClient(cl, "JOIN|" + tokens[1]);
}
EndPoint ep = client.RemoteEndPoint;
Client c = new Client(tokens[1], ep, clientservice, client);

string message = "LIST|" + GetChatterList() +"\r\n";
SendToClient(c, message);

clients.Add(c);

lbClients.Items.Add(c);

}
if (tokens[0] == "CHAT")
{
for(int n=0; n<clients.Count;n++)
{
Client cl = (Client)clients[n];
SendToClient(cl, clientcommand);
}
}
if (tokens[0] == "PRIV")
{
string destclient = tokens[3];
for(int n=0; n<clients.Count;n++)
{
Client cl = (Client)clients[n];
if(cl.Name.CompareTo(tokens[3]) == 0)
SendToClient(cl, clientcommand);
if(cl.Name.CompareTo(tokens[1]) == 0)
SendToClient(cl, clientcommand);
}
}
if (tokens[0] == "GONE")
{
int remove = 0;
bool found = false;
int c = clients.Count;
for(int n=0; n<clients.Count;n++)
{
Client cl = (Client)clients[n];
SendToClient(cl, clientcommand);
if(cl.Name.CompareTo(tokens[1]) == 0)
{
remove = n;
found = true;
lbClients.Items.Remove(cl);
}
}
if(found)
clients.RemoveAt(remove);
client.Close();
keepalive = false;
}
}
}

private string GetChatterList()
{
string result = "";

for(int i=0;i<clients.Count;i++)
{
result += ((Client)clients[i]).Name+"|";
}
return result;

}

private void SendToClient(Client cl,string clientCommand)
{
Byte[] message = System.Text.Encoding.ASCII.GetBytes(clientCommand);
Socket s = cl.Sock;
if(s.Connected)
{
s.Send(message,message.Length,0);
}
}

private void Form1_Load(object sender, System.EventArgs e)
{
clients = new ArrayList();
}

private void button1_Click(object sender, System.EventArgs e)
{
threadListen = new Thread(new ThreadStart(StartListening));
threadListen.Start();
}
}
}

 

 

/***************************** client类 ********************/

/************************** 放于 chatServer 项目中 *********/

using System;
using System.Threading;

namespace Chat_Server
{
using System.Net.Sockets;
using System.Net;

///
/// Client 的摘要说明。
///
public class Client
{
private Thread clthread;
private EndPoint endpoint;
private string name;
private Socket sock;

public Client(string _name, EndPoint _endpoint, Thread _thread, Socket _sock)
{
// TODO: 在此处添加构造函数逻辑
clthread = _thread;
endpoint = _endpoint;
name = _name;
sock = _sock;
}

public override string ToString()
{
return endpoint.ToString()+ " : " + name;
}

public Thread CLThread
{
get{return clthread;}
set{clthread = value;}
}

public EndPoint Host
{
get{return endpoint;}
set{endpoint = value;}
}

public string Name
{
get{return name;}
set{name = value;}
}

public Socket Sock
{
get{return sock;}
set{sock = value;}
}
}
}

/***************************** chatClient ************************************/

using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;

using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Threading;

namespace Chat_Client
{
/// <summary>
/// Form1 的摘要说明。
/// </summary>
public class Form1 : System.Windows.Forms.Form
{
private System.Windows.Forms.CheckBox checkBox1;
private System.Windows.Forms.StatusBar statusBar1;

NetworkStream ns;
StreamReader sr;
TcpClient clientsocket;
bool connected;
Thread receive;
string serveraddress = "219.228.231.85";
int serverport = 6666;

private System.Windows.Forms.RichTextBox rtbChatIn;
private System.Windows.Forms.ListBox lbChatters;
private System.Windows.Forms.TextBox ChatOut;
private System.Windows.Forms.Button btnDisconnect;
private System.Windows.Forms.Button btnSend;
private System.Windows.Forms.TextBox clientName;

string clientname;
private System.Windows.Forms.Button btnConnect;

private System.ComponentModel.Container components = null;

public Form1()
{

InitializeComponent();

}

/// <summary>
/// 清理所有正在使用的资源。
/// </summary>
protected override void Dispose( bool disposing )
{
if( disposing )
{
if(receive != null)
{
QuitChat();
}
if (components != null)
{
components.Dispose();
}
}
base.Dispose( disposing );
}

#region Windows 窗体设计器生成的代码
/// <summary>
/// 设计器支持所需的方法 - 不要使用代码编辑器修改
/// 此方法的内容。
/// </summary>
private void InitializeComponent()
{
this.lbChatters = new System.Windows.Forms.ListBox();
this.rtbChatIn = new System.Windows.Forms.RichTextBox();
this.checkBox1 = new System.Windows.Forms.CheckBox();
this.ChatOut = new System.Windows.Forms.TextBox();
this.btnSend = new System.Windows.Forms.Button();
this.statusBar1 = new System.Windows.Forms.StatusBar();
this.btnDisconnect = new System.Windows.Forms.Button();
this.clientName = new System.Windows.Forms.TextBox();
this.btnConnect = new System.Windows.Forms.Button();
this.SuspendLayout();
//
// lbChatters
//
this.lbChatters.ItemHeight = 12;
this.lbChatters.Location = new System.Drawing.Point(32, 40);
this.lbChatters.Name = "lbChatters";
this.lbChatters.Size = new System.Drawing.Size(112, 172);
this.lbChatters.TabIndex = 0;
//
// rtbChatIn
//
this.rtbChatIn.Location = new System.Drawing.Point(160, 40);
this.rtbChatIn.Name = "rtbChatIn";
this.rtbChatIn.Size = new System.Drawing.Size(208, 176);
this.rtbChatIn.TabIndex = 2;
this.rtbChatIn.Text = "";
//
// checkBox1
//
this.checkBox1.Location = new System.Drawing.Point(16, 248);
this.checkBox1.Name = "checkBox1";
this.checkBox1.TabIndex = 3;
this.checkBox1.Text = "checkBox1";
//
// ChatOut
//
this.ChatOut.Location = new System.Drawing.Point(136, 248);
this.ChatOut.Name = "ChatOut";
this.ChatOut.Size = new System.Drawing.Size(136, 21);
this.ChatOut.TabIndex = 4;
this.ChatOut.Text = "message";
//
// btnSend
//
this.btnSend.Location = new System.Drawing.Point(336, 248);
this.btnSend.Name = "btnSend";
this.btnSend.TabIndex = 5;
this.btnSend.Text = "send";
this.btnSend.Click += new System.EventHandler(this.btnSend_Click);
//
// statusBar1
//
this.statusBar1.Location = new System.Drawing.Point(0, 287);
this.statusBar1.Name = "statusBar1";
this.statusBar1.Size = new System.Drawing.Size(464, 22);
this.statusBar1.TabIndex = 6;
this.statusBar1.Text = "statusBar1";
//
// btnDisconnect
//
this.btnDisconnect.Enabled = false;
this.btnDisconnect.Location = new System.Drawing.Point(392, 112);
this.btnDisconnect.Name = "btnDisconnect";
this.btnDisconnect.Size = new System.Drawing.Size(64, 32);
this.btnDisconnect.TabIndex = 7;
this.btnDisconnect.Text = "断开";
this.btnDisconnect.Click += new System.EventHandler(this.btnDisconnect_Click);
//
// clientName
//
this.clientName.Location = new System.Drawing.Point(96, 8);
this.clientName.Name = "clientName";
this.clientName.TabIndex = 8;
this.clientName.Text = "name";
//
// btnConnect
//
this.btnConnect.Location = new System.Drawing.Point(392, 56);
this.btnConnect.Name = "btnConnect";
this.btnConnect.Size = new System.Drawing.Size(64, 32);
this.btnConnect.TabIndex = 9;
this.btnConnect.Text = "连接";
this.btnConnect.Click += new System.EventHandler(this.btnConnect_Click);
//
// Form1
//
this.AutoScaleBaseSize = new System.Drawing.Size(6, 14);
this.ClientSize = new System.Drawing.Size(464, 309);
this.Controls.Add(this.btnConnect);
this.Controls.Add(this.clientName);
this.Controls.Add(this.btnDisconnect);
this.Controls.Add(this.statusBar1);
this.Controls.Add(this.btnSend);
this.Controls.Add(this.ChatOut);
this.Controls.Add(this.checkBox1);
this.Controls.Add(this.rtbChatIn);
this.Controls.Add(this.lbChatters);
this.Name = "Form1";
this.Text = "Form1";
this.ResumeLayout(false);

}
#endregion

/// <summary>
/// 应用程序的主入口点。
/// </summary>
[STAThread]
static void Main()
{
Application.Run(new Form1());
}

private void EstablishConnection()
{
statusBar1.Text = "正在连接到服务器";

try
{
clientsocket = new TcpClient(serveraddress,serverport);
ns = clientsocket.GetStream();
sr = new StreamReader(ns);
connected = true;

}
catch (Exception)
{
MessageBox.Show("不能连接到服务器！","错误",
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
statusBar1.Text = "已断开连接";
}
}

private void RegisterWithServer()
{
lbChatters.Items.Clear();

clientname = clientName.Text;
try
{
string command = "CONN|" + clientname; //+"\r\n";
Byte[] outbytes = System.Text.Encoding.ASCII.GetBytes(command.ToCharArray());
ns.Write(outbytes,0,outbytes.Length);

string serverresponse = sr.ReadLine();
serverresponse.Trim();
string[] tokens = serverresponse.Split('|');
if(tokens[0] == "LIST")
{
statusBar1.Text = "已连接";
btnDisconnect.Enabled = true;
}
if(tokens[1] != "")
{
for(int n=1; n<tokens.Length;n++)
lbChatters.Items.Add(tokens[n].Trim(new char[]{'\r','\n'}));
}
this.Text = clientname + "：已连接到服务器";

}
catch (Exception ex)
{
MessageBox.Show("注册时发生错误！"+ex.Message,"错误",
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
connected = false;
}
}

private void ReceiveChat()
{
bool keepalive = true;
while (keepalive)
{
try
{
Byte[] buffer = new Byte[1024]; // 2048???
ns.Read(buffer,0,buffer.Length);
string chatter = System.Text.Encoding.ASCII.GetString(buffer);
string[] tokens = chatter.Split(new Char[]{'|'});

if (tokens[0] == "CHAT")
{
rtbChatIn.AppendText(tokens[1]);
// if(logging)
// logwriter.WriteLine(tokens[1]);
}
if (tokens[0] == "PRIV")
{
rtbChatIn.AppendText("Private from ");
rtbChatIn.AppendText(tokens[1].Trim() );
rtbChatIn.AppendText(tokens[2] + "\r\n");
// if(logging)
// {
// logwriter.Write("Private from ");
// logwriter.Write(tokens[1].Trim() );
// logwriter.WriteLine(tokens[2] + "\r\n");
// }
}
if (tokens[0] == "JOIN")
{
rtbChatIn.AppendText(tokens[1].Trim() );
rtbChatIn.AppendText(" has joined the Chat\r\n");
// if(logging)
// {
// logwriter.WriteLine(tokens[1]+" has joined the Chat");
// }
string newguy = tokens[1].Trim(new char[]{'\r','\n'});
lbChatters.Items.Add(newguy);
}
if (tokens[0] == "GONE")
{
rtbChatIn.AppendText(tokens[1].Trim() );
rtbChatIn.AppendText(" has left the Chat\r\n");
// if(logging)
// {
// logwriter.WriteLine(tokens[1]+" has left the Chat");
// }
lbChatters.Items.Remove(tokens[1].Trim(new char[]{'\r','\n'}));
}
if (tokens[0] == "QUIT")
{
ns.Close();
clientsocket.Close();
keepalive = false;
statusBar1.Text = "服务器端已停止";
connected= false;
btnSend.Enabled = false;
btnDisconnect.Enabled = false;
}
}
catch(Exception){}
}
}

private void QuitChat()
{
if(connected)
{
try
{
string command = "GONE|" + clientname;
Byte[] outbytes = System.Text.Encoding.ASCII.GetBytes(command.ToCharArray());
ns.Write(outbytes,0,outbytes.Length);
clientsocket.Close();
}
catch(Exception ex)
{
MessageBox.Show(ex.Message);
}
}
// if(logging)
// logwriter.Close();
if(receive != null && receive.IsAlive)
receive.Abort();
this.Text = "客户端";

connected = false;

}

private void btnSend_Click(object sender, System.EventArgs e)
{
if(connected)
{
try
{
string command = "CHAT|" + clientname+": "+ChatOut.Text+"\r\n";
Byte[] outbytes = System.Text.Encoding.ASCII.GetBytes(command.ToCharArray());
ns.Write(outbytes,0,outbytes.Length);
//clientsocket.Close();
}
catch(Exception ex)
{
MessageBox.Show(ex.Message);
}
}
}

private void btnConnect_Click(object sender, System.EventArgs e)
{
EstablishConnection();
RegisterWithServer();
if(connected)
{
receive = new Thread(new ThreadStart(ReceiveChat));
receive.Start();
}
}

private void btnDisconnect_Click(object sender, System.EventArgs e)
{
QuitChat();
}
}
}