socket编程——介绍CAsyncSocket类的用法

男娘i 2022-08-02 15:45 610阅读 0赞

MFC socket编程 - wangpei787636458的专栏 - 博客频道 - CSDN.NET  
[http://blog.csdn.net/wangpei787636458/article/details/7055397][http_blog.csdn.net_wangpei787636458_article_details_7055397]

socket编程用法---- 随着计算机网络化的深入，计算机网络编程在程序设计的过程中变得日益重要。由于C++语言对底层操作的优越性，许多文章都曾经介绍过用VC++进行Socket编程的方法。但由于都是直接利用动态连接库wsock32.dll进行操作，实现比较繁琐。其实，VC++的MFC类库中提供了CAsyncSocket这样一个套接字类，用他来实现Socket编程，是非常方便的。  
  
\---- 本文将用一个Echo例程来介绍CAsyncSocket类的用法。  
  
\---- 一． 客户端  
  
\---- 1． 创建一个Dialog Based项目：CSockClient。  
  
\---- 2． 设计对话框  
  
\---- 去掉Ok和Cancle两个按钮，增加ID\_Connect（连接）、ID\_Send（发送）、ID\_Exit（关闭）按钮，增加ListBox控件IDC\_LISTMSG和Edit控件IDC\_EDITMSG，并按下表在ClassWizard中为CCSockClientDlg类添加变量。  
  
Control ID Type Member  
  
IDC\_EDITMSG CEdit m\_MSG  
IDC\_LISTMSG ClistBox m\_MSGS  
  
\---- 3． CAsyncSocket类用DoCallBack函数处理MFC消息，当一个网络事件发生时，DoCallBack函数按网络事件类型：FD\_READ、FD\_WRITE、FD\_ACCEPT、FD\_CONNECT分别调用OnReceive、OnSend、OnAccept、OnConnect函数。由于MFC把这些事件处理函数定义为虚函数，所以要生成一个新的C++类，以重载这些函数，做法如下：  
  
\---- 以Public方式继承CAsyncSocket类，生成新类MySock；  
  
\---- 为MySock类添加虚函数OnReceive、OnConnect、OnSend  
  
\---- 4． 在MySock.ccp中添加以下代码  
  
\#include "CSockClient.h"  
\#include "CSockClientDlg.h"  
  
\---- 5． 在MySock.h中添加以下代码  
  
public:  
BOOL m\_bConnected; //是否连接  
UINT m\_nLength; //消息长度  
char m\_szBuffer\[4096\]; //消息缓冲区  
  
\---- 6． 在MySock.ccp中重载各函数  
  
MySock::MySock()  
\{  
m\_nLength=0;  
memset(m\_szBuffer,0,sizeof(m\_szBuffer));  
m\_bConnected=FALSE;  
\}  
  
MySock::~MySock()  
\{  
//关闭套接字  
if(m\_hSocket!=INVALID\_SOCKET)  
Close();  
\}  
  
void MySock::OnReceive(int nErrorCode)  
\{  
m\_nLength=Receive(m\_szBuffer,sizeof(m\_szBuffer),0);  
//下面两行代码用来获取对话框指针  
CCSockClientApp\* pApp=(CCSockClientApp\*)AfxGetApp();  
CCSockClientDlg\* pDlg=(CCSockClientDlg\*)pApp- >m\_pMainWnd;  
pDlg- >m\_MSGS.InsertString(0,m\_szBuffer);  
memset(m\_szBuffer,0,sizeof(m\_szBuffer));  
CAsyncSocket::OnReceive(nErrorCode);  
\}  
  
void MySock::OnSend(int nErrorCode)  
\{  
Send(m\_szBuffer,m\_nLength,0);  
m\_nLength=0;  
memset(m\_szBuffer,0,sizeof(m\_szBuffer));  
//继续提请一个“读”的网络事件，接收Server消息  
AsyncSelect(FD\_READ);  
CAsyncSocket::OnSend(nErrorCode);  
\}  
  
void MySock::OnConnect(int nErrorCode)  
\{  
if (nErrorCode==0)  
\{  
m\_bConnected=TRUE;  
CCSockClientApp\* pApp=(CCSockClientApp\*)AfxGetApp();  
CCSockClientDlg\* pDlg=(CCSockClientDlg\*)pApp- >m\_pMainWnd;  
memcpy(m\_szBuffer,"Connected to ",13);  
strncat(m\_szBuffer,pDlg- >m\_szServerAdr,  
sizeof(pDlg- >m\_szServerAdr));  
pDlg- >m\_MSGS.InsertString(0,m\_szBuffer);  
AsyncSelect(FD\_READ); 提请一个“读”的网络事件，准备接收  
\}  
CAsyncSocket::OnConnect(nErrorCode);  
\}  
  
\---- 7． 新建对话框IDD\_Addr，用来输入IP地址和Port；生成新类CAddrDlg。增加两个Edit控件：IDC\_Addr、IDC\_Port按下表在ClassWizard中为CAddrDlg类添加变量。  
  
Control ID Type Member  
  
IDC\_Addr CString m\_Addr  
IDC\_Port Int m\_Port  
  
\---- 8． 在CSockClientDlg.ccp中添加代码  
  
\#include "AddrDlg.h"  
protected:  
int TryCount;  
MySock m\_clientSocket;  
UINT m\_szPort;  
public:  
char m\_szServerAdr\[256\];  
  
\---- 9． 双击IDD\_CSOCKCLIENT\_DIALOG对话框中的“连接”按钮，添加以下代码  
  
void CCSockClientDlg::OnConnect()  
\{  
m\_clientSocket.ShutDown(2);  
m\_clientSocket.m\_hSocket=INVALID\_SOCKET;  
m\_clientSocket.m\_bConnected=FALSE;  
CAddrDlg m\_Dlg;  
//默认端口1088  
m\_Dlg.m\_Port=1088;  
if (m\_Dlg.DoModal()==IDOK && !m\_Dlg.m\_Addr.IsEmpty())  
\{  
memcpy(m\_szServerAdr,m\_Dlg.m\_Addr,sizeof(m\_szServerAdr));  
m\_szPort=m\_Dlg.m\_Port;  
//建立计时器，每1秒尝试连接一次，直到连上或TryCount>10  
SetTimer(1,1000,NULL);  
TryCount=0;  
\}  
\}  
  
\---- 10． 添加Windows消息WM\_TIMER响应函数OnTimer  
  
void CCSockClientDlg::OnTimer(UINT nIDEvent)  
\{  
if (m\_clientSocket.m\_hSocket==INVALID\_SOCKET)  
\{  
BOOL bFlag=m\_clientSocket.Create(0,SOCK\_STREAM,FD\_CONNECT);  
if(!bFlag)  
\{  
AfxMessageBox("Socket Error!");  
m\_clientSocket.Close();  
PostQuitMessage(0);  
return;  
\}  
\}  
m\_clientSocket.Connect(m\_szServerAdr,m\_szPort);  
TryCount++;  
if (TryCount >=10 || m\_clientSocket.m\_bConnected)  
\{  
KillTimer(1);  
if (TryCount >=10)  
AfxMessageBox("Connect Failed!");  
return;  
\}  
CDialog::OnTimer(nIDEvent);  
\}  
  
\---- 11． 双击IDD\_CSOCKCLIENT\_DIALOG对话框中的“发送”按钮，添加以下代码  
  
void CCSockClientDlg::OnSend()  
\{  
if (m\_clientSocket.m\_bConnected)  
\{  
m\_clientSocket.m\_nLength=m\_MSG.GetWindowText  
(m\_clientSocket.m\_szBuffer, sizeof(m\_clientSocket.m\_szBuffer));  
m\_clientSocket.AsyncSelect(FD\_WRITE);  
m\_MSG.SetWindowText("");  
\}  
\}  
  
\---- 12． 双击IDD\_CSOCKCLIENT\_DIALOG对话框中的“关闭”按钮，添加以下代码  
  
void CCSockClientDlg::OnExit()  
\{  
//关闭Socket  
m\_clientSocket.ShutDown(2);  
//关闭对话框  
EndDialog(0);  
\}  
  
\----  
12．运行此项目，连接时输入主机名或IP均可，CAsyncSocket类会自动处理。  
\----  
二． 服务端  
\----  
Server端的编程与Client端的类似，下面主要介绍他的Listen及Accept函数  
\----  
1． 建立一个CNewSocket类，重载CAsyncSocket类的OnReceive、OnSend函数，如何进行信息的显示和发送可以参考Client程序。本例中采用将收到信息原封不动发回的方法来实现Echo功能，代码如下  
CNewSocket：：OnReceive（int nErrorCOde）  
\{  
m\_nLength=Receive（m\_szBuffer，sizeof（m\_szBuffer），0）；  
// 直接转发消息  
AsyncSelect（FD\_WRITE）；  
\}  
  
CNewSocket：：OnSend（int nErrorCode）  
\{  
Send（m\_szBuffer，m\_nLength，0）；  
\}  
  
\----  
2． 建立一个CMyServerSocket类，重载CAsyncSocket类的OnAccept函数代码如下  
\----  
在MyServerSocket.h中声明变量  
public:：  
CNewSocket\* m\_pSocket；  
  
void CMyServerSocket：：OnAccept（int nErrorCode）  
\{  
//侦听到连接请求，调用Accept函数  
CNewSocket\* pSocket = new CNewSocket（）；  
if （Accept（\*pSocket））  
\{  
pSocket- >AsyncSelect（FD\_READ）；  
m\_pSocket=pSocket；  
\}  
else  
delete pSocket；  
\}  
  
\----  
3． 为对话框添加一个“侦听”按钮，添加如下代码  
\----  
在CsockServerDlg.ccp中声明变量  
public：  
CMyServerSocket m\_srvrSocket;  
void CCSockServerDlg：：OnListen（）  
\{  
if （m\_srvrSocket.m\_hSocket==INVALID\_SOCKET）  
\{  
BOOL bFlag=m\_srvrSocket.Create  
(UserPort，SOCK\_STREAM，FD\_ACCEPT)；  
if （！bFlag）  
\{  
AfxMessageBox（“Socket Error！”）；  
M\_srvrSocket.Close（）；  
PostQuitMessage（0）；  
Return；  
\}  
\}  
//“侦听”成功，等待连接请求  
if （！m\_srvrSocket。Listen（1））  
\{  
int nErrorCode = m\_srvrSocket.GetLastError（）；  
if （nError！=WSAEWOULDBLOCK）  
\{  
AfxMessageBox（“Socket Error！”）；  
M\_srvrSocket.Close（）；  
PostQuitMessage（0）；  
Return；  
\}  
\}  
\}  
  
\----  
4． 目前程序只能实现Echo功能，将信息原封不动的转发，若能将Accept中由CNewSocket\* pSocket = new CNewSocket（）；得到的Socket指针存入一个CList或一个数组中，便像Client端那样，对所有的连接进行读写控制。  
\----  
三． 总结  
\----  
CAsyncSocket类为我们使用Socket提供了极大方便。建立Socket的WSAStartup过程和bind过程被简化成为Create过程，IP地址类型转换、主机名和IP地址转换的过程中许多复杂的变量类型都被简化成字符串和整数操作，特别是CAsyncSocket类的异步特点，完全可以替代繁琐的线程操作。MFC提供了大量的类库，我们若能灵活的使用他们，便会大大提高编程的效率。

**一、TCP/IP 体系结构与特点**

1、TCP/IP体系结构

TCP/IP协议实际上就是在物理网上的一组完整的网络协议。其中TCP是提供传输层服务，而IP则是提供网络层服务。TCP/IP包括以下协议：（结构如图1.1）

(图1.1)

IP： 网间协议(Internet Protocol) 负责主机间数据的路由和网络上数据的存储。同时为ICMP，TCP，　　　UDP提供分组发送服务。用户进程通常不需要涉及这一层。  
  
　　ARP： 地址解析协议(Address Resolution Protocol)  
　　　此协议将网络地址映射到硬件地址。  
  
　　RARP： 反向地址解析协议(Reverse Address Resolution Protocol)  
　　　此协议将硬件地址映射到网络地址  
  
　　ICMP： 网间报文控制协议(Internet Control Message Protocol)  
　　　此协议处理信关和主机的差错和传送控制。  
  
　　TCP： 传送控制协议(Transmission Control Protocol)  
　　　这是一种提供给用户进程的可靠的全双工字节流面向连接的协议。它要为用户进程提供虚电路服务，并为数据可靠传输建立检查。（注：大多数网络用户程序使用TCP）  
  
　　UDP： 用户数据报协议(User Datagram Protocol)  
　　　这是提供给用户进程的无连接协议，用于传送数据而不执行正确性检查。  
  
　　FTP： 文件传输协议(File Transfer Protocol)  
　　　允许用户以文件操作的方式（文件的增、删、改、查、传送等）与另一主机相互通信。  
  
　　SMTP： 简单邮件传送协议(Simple Mail Transfer Protocol)  
　　　SMTP协议为系统之间传送电子邮件。  
  
　　TELNET：终端协议(Telnet Terminal Procotol)  
　　　允许用户以虚终端方式访问远程主机  
  
　　HTTP： 超文本传输协议(Hypertext Transfer Procotol)  
　　  
　　TFTP: 简单文件传输协议(Trivial File Transfer Protocol)

2、TCP/IP特点  
  
　　TCP/IP协议的核心部分是传输层协议(TCP、UDP)，网络层协议(IP)和物理接口层，这三层通常是在操作系统内核中实现。因此用户一般不涉及。编程时，编程界面有两种形式：一、是由内核心直接提供的系统调用；二、使用以库函数方式提供的各种函数。前者为核内实现，后者为核外实现。用户服务要通过核外的应用程序才能实现，所以要使用套接字(socket)来实现。  
  
　　图1.2是TCP/IP协议核心与应用程序关系图。  
  
  
(图1.2)

**二、专用术语**  
  
　　1、套接字

套接字是网络的基本构件。它是可以被命名和寻址的通信端点，使用中的每一个套接字都有其类型和一个与之相连听进程。套接字存在通信区域（通信区域又称地址簇）中。套接字只与同一区域中的套接字交换数据（跨区域时，需要执行某和转换进程才能实现）。WINDOWS 中的套接字只支持一个域——网际域。套接字具有类型。  
  
　　WINDOWS SOCKET 1.1 版本支持两种套接字：流套接字(SOCK\_STREAM)和数据报套接字(SOCK\_DGRAM)  
  
　　2、WINDOWS SOCKETS 实现  
  
　　一个WINDOWS SOCKETS 实现是指实现了WINDOWS SOCKETS规范所描述的全部功能的一套软件。一般通过DLL文件来实现

3、阻塞处理例程  
  
　　阻塞处理例程(blocking hook,阻塞钩子)是WINDOWS SOCKETS实现为了支持阻塞套接字函数调用而提供的一种机制。

4、多址广播（multicast，多点传送或组播）  
  
　　是一种一对多的传输方式，传输发起者通过一次传输就将信息传送到一组接收者，与单点传送  
(unicast)和广播(Broadcast)相对应。  
  
**一、客户机/服务器模式**  
  
　　在TCP/IP网络中两个进程间的相互作用的主机模式是客户机/服务器模式(Client/Server model)。该模式的建立基于以下两点：1、非对等作用；2、通信完全是异步的。客户机/服务器模式在操作过程中采取的是主动请示方式：

首先服务器方要先启动，并根据请示提供相应服务：（过程如下）  
  
　　1、打开一通信通道并告知本地主机，它愿意在某一个公认地址上接收客户请求。  
  
　　2、等待客户请求到达该端口。  
  
　　3、接收到重复服务请求，处理该请求并发送应答信号。  
  
　　4、返回第二步，等待另一客户请求  
  
　　5、关闭服务器。  
  
　　客户方：  
  
　　1、打开一通信通道，并连接到服务器所在主机的特定端口。  
  
　　2、向服务器发送服务请求报文，等待并接收应答；继续提出请求……  
  
　　3、请求结束后关闭通信通道并终止。

**二、基本套接字**  
  
　　为了更好说明套接字编程原理，给出几个基本的套接字，在以后的篇幅中会给出更详细的使用说明。  
  
　　1、创建套接字——socket()  
  
　　功能：使用前创建一个新的套接字  
  
　　格式：SOCKET PASCAL FAR socket(int af,int type,int procotol);  
  
　　参数：af: 通信发生的区域  
  
　　type: 要建立的套接字类型  
  
　　procotol: 使用的特定协议

2、指定本地地址——bind()  
  
　　功能：将套接字地址与所创建的套接字号联系起来。  
  
　　格式：int PASCAL FAR bind(SOCKET s,const struct sockaddr FAR \* name,int namelen);  
  
　　参数：s: 是由socket()调用返回的并且未作连接的套接字描述符（套接字号）。  
  
　　其它：没有错误，bind()返回0，否则SOCKET\_ERROR  
  
　　地址结构说明：  
  
struct sockaddr\_in  
\{  
short sin\_family;//AF\_INET  
u\_short sin\_port;//16位端口号，网络字节顺序  
struct in\_addr sin\_addr;//32位IP地址，网络字节顺序  
char sin\_zero\[8\];//保留  
\}

3、建立套接字连接——connect()和accept()  
  
　　功能：共同完成连接工作  
  
　　格式：int PASCAL FAR connect(SOCKET s,const struct sockaddr FAR \* name,int namelen);  
  
　　SOCKET PASCAL FAR accept(SOCKET s,struct sockaddr FAR \* name,int FAR \* addrlen);  
  
　　参数：同上

4、监听连接——listen()  
  
　　功能：用于面向连接服务器，表明它愿意接收连接。  
  
　　格式：int PASCAL FAR listen(SOCKET s, int backlog);

5、数据传输——send()与recv()  
  
　　功能：数据的发送与接收  
  
　　格式：int PASCAL FAR send(SOCKET s,const char FAR \* buf,int len,int flags);  
  
　　int PASCAL FAR recv(SOCKET s,const char FAR \* buf,int len,int flags);  
  
　　参数：buf:指向存有传输数据的缓冲区的指针。  
  
　　6、多路复用——select()  
  
　　功能：用来检测一个或多个套接字状态。  
  
　　格式：int PASCAL FAR select(int nfds,fd\_set FAR \* readfds,fd\_set FAR \* writefds,  
fd\_set FAR \* exceptfds,const struct timeval FAR \* timeout);  
  
　　参数：readfds:指向要做读检测的指针  
  
　　　　　writefds:指向要做写检测的指针  
  
　　　　　exceptfds:指向要检测是否出错的指针  
  
　　　　　timeout:最大等待时间

7、关闭套接字——closesocket()  
  
　　功能：关闭套接字s  
  
　　格式：BOOL PASCAL FAR closesocket(SOCKET s);  
  
**三、典型过程图**  
  
　　2.1 面向连接的套接字的系统调用时序图

2.2 无连接协议的套接字调用时序图  
  
  
  
　2.3 面向连接的应用程序流程图

**Windows Socket1.1 程序设计  
  
一、简介**  
  
　　Windows Sockets 是从 Berkeley Sockets 扩展而来的，其在继承 Berkeley Sockets 的基础上，又进行了新的扩充。这些扩充主要是提供了一些异步函数，并增加了符合WINDOWS消息驱动特性的网络事件异步选择机制。  
  
　　Windows Sockets由两部分组成：开发组件和运行组件。  
  
　　开发组件：Windows Sockets 实现文档、应用程序接口(API)引入库和一些头文件。  
  
　　运行组件：Windows Sockets 应用程序接口的动态链接库(WINSOCK.DLL)。

**二、主要扩充说明**

1、异步选择机制：  
  
　　Windows Sockets 的异步选择函数提供了消息机制的网络事件选择，当使用它登记网络事件发生时，应用程序相应窗口函数将收到一个消息，消息中指示了发生的网络事件，以及与事件相关的一些信息。  
  
　　Windows Sockets 提供了一个异步选择函数 WSAAsyncSelect()，用它来注册应用程序感兴趣的网络事件，当这些事件发生时，应用程序相应的窗口函数将收到一个消息。  
  
　　函数结构如下：

<table> 
 <tbody> 
 <tr> 
 <td> int PASCAL FAR WSAAsyncSelect(SOCKET s,HWND hWnd,unsigned int wMsg,long lEvent); </td> 
 </tr> 
 </tbody> 
</table>

参数说明：  
  
　　　hWnd：窗口句柄  
  
　　　wMsg：需要发送的消息  
  
　　　lEvent：事件（以下为事件的内容）

<table> 
 <tbody> 
 <tr> 
 <td> 值： </td> 
 <td> 含义： </td> 
 </tr> 
 <tr> 
 <td> FD_READ </td> 
 <td> 期望在套接字上收到数据（即读准备好）时接到通知 </td> 
 </tr> 
 <tr> 
 <td> FD_WRITE </td> 
 <td> 期望在套接字上可发送数据（即写准备好）时接到通知 </td> 
 </tr> 
 <tr> 
 <td> FD_OOB </td> 
 <td> 期望在套接字上有带外数据到达时接到通知 </td> 
 </tr> 
 <tr> 
 <td> FD_ACCEPT </td> 
 <td> 期望在套接字上有外来连接时接到通知 </td> 
 </tr> 
 <tr> 
 <td> FD_CONNECT </td> 
 <td> 期望在套接字连接建立完成时接到通知 </td> 
 </tr> 
 <tr> 
 <td> FD_CLOSE </td> 
 <td> 期望在套接字关闭时接到通知 </td> 
 </tr> 
 </tbody> 
</table>

例如：我们要在套接字读准备好或写准备好时接到通知，语句如下：

<table> 
 <tbody> 
 <tr> 
 <td> rc=WSAAsyncSelect(s,hWnd,wMsg,FD_READ|FD_WRITE); </td> 
 </tr> 
 </tbody> 
</table>

如果我们需要注销对套接字网络事件的消息发送，只要将 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() 启动和终止套接字。

来自网络

实例

static void\* listenconnect(void\* param)  
\{  
int sockfd = socket (PF\_UNIX, SOCK\_SEQPACKET, 0); //创建本地套接字  
fcntl(sockfd, F\_SETFL, O\_NONBLOCK);  
sockaddr\_un myaddr;  
memset (&myaddr, 0, sizeof(myaddr));  
myaddr.sun\_family = PF\_UNIX;  
strcpy (myaddr.sun\_path, "@/brainaire\_nvr/trans\_serv/socket"); //套接字的名字，任意取  
myaddr.sun\_path\[0\] = 0;  
bind (sockfd, (struct sockaddr\*)&myaddr, sizeof(myaddr)); //将套接字与它的名字绑定  
listen(sockfd, 50);

fd\_set watchset, listenset, clientset; 
FD\_ZERO(&clientset); 
FD\_ZERO(&watchset); 
FD\_ZERO(&listenset); 
FD\_SET(sockfd, &listenset); 
int max\_listen = sockfd + 1; 
int max\_client = 0; 
while (!process\_exit) 
\{ 
watchset = listenset; 
struct timeval tv; 
tv.tv\_sec = 0; 
tv.tv\_usec = 1000; 
if (select(max\_listen, &watchset, NULL, NULL, &tv) > 0 && FD\_ISSET(sockfd, &watchset)) 
\{ 
struct sockaddr addr; 
socklen\_t len; 
int clientfd = accept(sockfd, &addr, &len); 
if (clientfd < 0) 
perror("accept"); 
else 
\{ 
if (clientfd >= max\_client) 
max\_client = clientfd + 1; 
FD\_SET(clientfd, &clientset); 
\} 
\} 
watchset = clientset; 
tv.tv\_sec = 0; 
tv.tv\_usec = 1000; 
int ret = select(max\_client, &watchset, NULL, NULL, &tv); 
if (ret > 0) 
\{ 
for (int clientfd = max\_client - 1; clientfd > 0; clientfd--) 
\{ 
int flags = 0; 
char buff\[BUFSIZ\]; 
int len; 
if (FD\_ISSET(clientfd, &watchset)) 
\{ 
len = recv(clientfd, buff, sizeof(buff), flags); 
if (len <= 0) 
\{ 
FD\_CLR(clientfd, &clientset); 
fprintf(stderr, "\[nvradmin\] client socket %d closed.\\n", clientfd); 
close(clientfd); 
if (clientfd == max\_client - 1) 
max\_client --; 
\} 
else 
\{ 
bool monitorworking = false; 
buff\[len\] = 0; 
int monitorID = atoi(buff); 
if (monitorID != 0) 
\{ 
MyRW\_Lock mylock(&monitorlock); 
\#if THREAD\_NUM 
list<MonitorDaemon>& monitors = monitorslists\[monitorID%THREAD\_NUM\]; 
\#endif 
for (list<MonitorDaemon>::iterator intr = monitors.begin(); intr 
!= monitors.end(); intr ++) 
\{ 
MonitorDaemon m\_daemon = \*intr; 
if (m\_daemon.monitor == NULL) 
break; 
if (m\_daemon.monitor->Id() == monitorID) 
\{ 
fprintf(stderr, "\[nvradmin\] Start Transmitting RealPlay Data to client socket %d\\n", clientfd); 
monitorworking = (0 == m\_daemon.monitor->StartTransData(clientfd)); 
\} 
\} 
\} 
else 
fprintf(stderr, "\[nvradmin\] Received Msgs: len %d, content: %s\\n", len, buff);

if(!monitorworking) 
\{ 
FD\_CLR(clientfd, &clientset); 
fprintf(stderr, "\[nvradmin\] Cannot Start Tranmitting, client Socket %d Closed.\\n", clientfd); 
close(clientfd); 
if (clientfd == max\_client - 1) 
max\_client --; 
\} 
\} 
\} 
\} 
\} 
if(ret < 0) 
perror("Select Connected Sockets"); 
usleep(0); 
\} 
close(sockfd); 
return 0; 
\}

[http_blog.csdn.net_wangpei787636458_article_details_7055397]: http://blog.csdn.net/wangpei787636458/article/details/7055397