[精通WindowsSocket网络开发-基于VC++实现]第六章——Select模式开发[阻塞]

最新推荐文章于 2023-12-22 10:33:31 发布
最新推荐文章于 2023-12-22 10:33:31 发布
阅读量1.6k 收藏 1
点赞数
分类专栏： 网络编程
目录(?) [+]

 套接字Select模型是比较常用的一种I/O模型。利用该模型使得WindowsSockets应用程序可以在同一时间内管理和控制多个套接字。该模型的核心是select()函数。在使用该函数是，还需要用到FD_SET,FD_ZERO,FD_ISSET和FD_CLR四个宏。开发WindowsSocket程序时，应用程序需要这样的能力：当执行操作的套接字满足可读可写条件时，需要给应用程序发送通知，接收到这个通知后，应用程序再调用相应的WindowsSocketsAPI去执行函数调用。套接字的Select模型，就是能够使得应用程序具有这样能力的一种方式。套接字的Select模型，能够使WindowsSockets应用程序同时对多个套接字进行管理。调用select()检查当前各个套接字的当前状态。并且根据该函数的返回值，判断套接字的可读可写性。然后调用相应的WindwosSocketsAPI，完成数据的发送，接收。以一个远程文件下载程序为实例。

套接字Select模型

阻塞模式的套接字执行I/O操作时，如果执行操作的条件没有得到满足，线程就会被阻塞在该调用的函数上。程序不得不处于等待状态。该调用函数什么时候返回，不得而知。

非阻塞模式套接字执行I/O操作时，在某种情况下，调用函数都会立即返回。软件开发人员必须编写更多的代码，对该函数返回的错误进行处理，这无疑增加了开发WindowsSockets应用程序的难度。另外，应用程序中往往需要在一个循环体内反复调用该函数，直到返回成功指示为止，这不是一种很好的做法。

select模型

Select模式是windowsSocket中最常见的I/O模型。所以称其为Select模型，是因为它的核心是利用select()函数实现I/O管理。利用select()函数，WindowsSockets应用程序可以判断套接字上是否存在数据，或者能否向该套接字写入数据。

如上图：在调用recv()接收数据之前，先调用select()。如果此时系统没有可读的数据，那么select()会阻塞在这里。当系统存在可读的数据时，该函数返回。此时应用程序就可以调用recv()接收数据了。 应该可以看到Select模式为开发WindowsSockets应用程序，提供了调用某个函数前的通知机制。

select()函数

[cpp] view plain copy print ?
  1. /*
  2. 1.select()函数
  3. int select(IN int nfds,_inout_opt fd_set FAR * readfds,_inout_opt fd_set FAR * writefds,_inout_opt fd_set FAR * exceptfds,IN const struct timeval FAR * timeout);//通过该函数，WindowsSockets应用程序可以判断套接字是否存在数据，或者能否向其写入数据。
  4. 参数：
  5. int nfsd：被忽略，之所以仍然要提供这个参数，是为了保持与早期的Berkeley套接字应用程序兼容。
  6. fd_set FAR* readfds：具有可读性套接字集合的指针
  7. fd_set FAR* writefds：具有可写性套接字集合的指针
  8. fd_set FAR* exceptfds：检查错误套接字集合的指针
  9. timeval FAR* timeout：用于设置调用select()函数时的等待时间
  10. 返回值：失败返回SOCKET_ERROR,否则，返回。
  11. 调用select()时，readfds,writefds和sexceptfds 3个参数中至少有一个不能设置为NULL。并且，在该非空的参数中，必须至少包含一个套接字。否则select()将没有任何套接字可以等待。
  12. select()返回后，会修改每个fd_set结构，删除那些不存在的没有完成I/O操作的套接字。
  14. 2.struct fd_set
  15. #define FD_SETSIZE      64
  16. typedef struct fd_set //是一个管理多个套接字的结构体
  17. {
  18. u_int fd_count;               //套接字数量
  19. SOCKET  fd_array[FD_SETSIZE];   //套接字数组
  20. } fd_set; //fd_xxx:(file descriptor)文件描述符号，在这是socket句柄
  21. 在程序中使用该结构表示一系列特定套接字的集合。eg：准备接收数据的套接字集合，又称为可读性集合。准备发送数据的套接字集合，又称为可写性集合。
  22. 当select()成功返回后，会在fs_set结构中，返回刚好未完成I/O操作的所有套接字句柄的总量。
  23. A：readfds参数将包含符号下面任何一个条件的套接字
  24. 1.有数据可以读入，此时在该套接字上调用recv()等输入函数，立即接收到对方的数据。
  25. 2.连接已经关闭，重设或中止
  26. 3.假如已经调用listen(),而且一个连接正在建立。那么此时调用accept()会成功
  27. B：writefds参数将包含符号下面任何一个条件的套接字
  28. 1.有数据可以发生。此时在该套接字上可以调用send()等输出函数，向对方发送数据
  29. 2.如果已经在一个非锁定套接字上调用了connect(),此时连接成功
  30. C：exceptfds参数将包含符号下面任何一个条件的套接字
  31. 1.如果已经在一个非锁定套接字上调用了connect()，此时连接失败
  32. 2.有带外(Out-of-band,OOB)数据可供读取
  34. 3. struct  timeval
  35. struct timeval  //用于定义select()函数的等待时间
  36. {
  37.     long    tv_sec;       //秒
  38.     long    tv_usec;     //毫秒
  39. };
  40. 调用select()时，timeout参数可以分为3种情况
  41. A：空指针。select()调用会无限期，等到至少有一个套接字符合设置的条件后，该函数返回
  42. B：0。无论是否有套接字符号设置的条件，select()都立即返回。允许应用程序对该函数进行“轮询”。出于对性能方面的考虑，应避免这样的设置。
  43. C：非0值。如果在等待的时间内，有套接字满足设置的条件，则该函数返回。如果在等待时间内没有套接字满足设置的条件，则该函数在到达设定的时间后返回，并且该返回返回值为0.
  45. 4.宏
  46. FD_CLR(s,*set):从set集合中删除s套接字
  47. FD_ISSET(s,*set):检查s是否为set集合的一名成员。如果s是set集合的一名成员，则返回TRUE
  48. FD_SET(s,*set):将套接字s加入set集合。
  49. FD_ZERO(*set):将set集合初始化为空集合。
  51. 5.调用select()时时有宏
  52. A.使用FD_ZERO宏，初始化自己感兴趣的套接字集合fd_set.eg：FD_ZERO(readfd)
  53. B.使用FD_SET宏，将套接字分配给参与操作的fd_set集合。eg：FD_SET(s,readfd);
  54. C.以该fd_set为参数调用select().等待在指定的fd_set集合中，I/O活动设置好这个套接字。select()完成后会返回在所有fd_set集合中设置的套接字句柄总数，并对每个集合进行相应的更新。
  55. D.select()函数成功返回后，使用FD_ISSSET宏，对每个fd_set集合进行检查。eg:FD_ISSET(s,readfd);如果该宏为TRUE,则说明该套接字可读
  56. */  
/*
1.select()函数 
int select(IN int nfds,_inout_opt fd_set FAR * readfds,_inout_opt fd_set FAR * writefds,_inout_opt fd_set FAR * exceptfds,IN const struct timeval FAR * timeout);//通过该函数，WindowsSockets应用程序可以判断套接字是否存在数据，或者能否向其写入数据。
参数：
int nfsd：被忽略，之所以仍然要提供这个参数，是为了保持与早期的Berkeley套接字应用程序兼容。
fd_set FAR* readfds：具有可读性套接字集合的指针
fd_set FAR* writefds：具有可写性套接字集合的指针
fd_set FAR* exceptfds：检查错误套接字集合的指针
timeval FAR* timeout：用于设置调用select()函数时的等待时间
返回值：失败返回SOCKET_ERROR,否则，返回。
调用select()时，readfds,writefds和sexceptfds 3个参数中至少有一个不能设置为NULL。并且，在该非空的参数中，必须至少包含一个套接字。否则select()将没有任何套接字可以等待。
select()返回后，会修改每个fd_set结构，删除那些不存在的没有完成I/O操作的套接字。

2.struct fd_set
#define FD_SETSIZE      64
typedef struct fd_set //是一个管理多个套接字的结构体
{
u_int fd_count;               //套接字数量
SOCKET  fd_array[FD_SETSIZE];   //套接字数组
} fd_set; //fd_xxx:(file descriptor)文件描述符号，在这是socket句柄
在程序中使用该结构表示一系列特定套接字的集合。eg：准备接收数据的套接字集合，又称为可读性集合。准备发送数据的套接字集合，又称为可写性集合。
当select()成功返回后，会在fs_set结构中，返回刚好未完成I/O操作的所有套接字句柄的总量。
A：readfds参数将包含符号下面任何一个条件的套接字
1.有数据可以读入，此时在该套接字上调用recv()等输入函数，立即接收到对方的数据。
2.连接已经关闭，重设或中止
3.假如已经调用listen(),而且一个连接正在建立。那么此时调用accept()会成功
B：writefds参数将包含符号下面任何一个条件的套接字
1.有数据可以发生。此时在该套接字上可以调用send()等输出函数，向对方发送数据
2.如果已经在一个非锁定套接字上调用了connect(),此时连接成功
C：exceptfds参数将包含符号下面任何一个条件的套接字
1.如果已经在一个非锁定套接字上调用了connect()，此时连接失败
2.有带外(Out-of-band,OOB)数据可供读取

3. struct  timeval
struct timeval  //用于定义select()函数的等待时间
{
    long    tv_sec;       //秒 
    long    tv_usec;     //毫秒
};
调用select()时，timeout参数可以分为3种情况
A：空指针。select()调用会无限期，等到至少有一个套接字符合设置的条件后，该函数返回
B：0。无论是否有套接字符号设置的条件，select()都立即返回。允许应用程序对该函数进行“轮询”。出于对性能方面的考虑，应避免这样的设置。
C：非0值。如果在等待的时间内，有套接字满足设置的条件，则该函数返回。如果在等待时间内没有套接字满足设置的条件，则该函数在到达设定的时间后返回，并且该返回返回值为0.

4.宏
FD_CLR(s,*set):从set集合中删除s套接字
FD_ISSET(s,*set):检查s是否为set集合的一名成员。如果s是set集合的一名成员，则返回TRUE
FD_SET(s,*set):将套接字s加入set集合。
FD_ZERO(*set):将set集合初始化为空集合。

5.调用select()时时有宏
A.使用FD_ZERO宏，初始化自己感兴趣的套接字集合fd_set.eg：FD_ZERO(readfd)
B.使用FD_SET宏，将套接字分配给参与操作的fd_set集合。eg：FD_SET(s,readfd);
C.以该fd_set为参数调用select().等待在指定的fd_set集合中，I/O活动设置好这个套接字。select()完成后会返回在所有fd_set集合中设置的套接字句柄总数，并对每个集合进行相应的更新。
D.select()函数成功返回后，使用FD_ISSSET宏，对每个fd_set集合进行检查。eg:FD_ISSET(s,readfd);如果该宏为TRUE,则说明该套接字可读 
*/

Select模型的优势和不足

select模式优势在于可以同时对多个建立起来的套接字进行有序的管理。可以防止应用程序一次I/O调用过程中，使阻塞模式套接字被迫进入阻塞状态；使非阻塞套接字产生WSAEWOULDBLOCK错误。

select()函数就好像是一个消息中心，当消息到来时，通知应用程序接收和发送数据。这使得WindowsSockets应用程序开发人员可以把精力更多的集中在如何处理数据的发送和接收上。

应该看到完成一次I/O操作经历了两次WindowsSockets函数调用。例如，当接受对方的数据时，第一步，调用select()等待该套接字的满足条件，第二步：调用recv()接收数据。这种结果与在一个阻塞模式的套接字上调用recv()函数是一样的。

因此，使用select()的WindowsSockets程序，其效率可能受损。因为，每一个WindowsSockets I/O调用都会经过该函数，因而会导致严重的CPU额外负担。在CPU的使用率不是关键因素时，这种效率可以接受。但是，当需要高效率时，肯定会产生问题。

远程文件下载程序

服务器端关键代码

[cpp] view plain copy print ?
  1. /*服务器实现以下功能
  2. 1.使用select模型管理与客户端建立的套接字
  3. 2.同时为多个客户端提供服务器目录信息和下载文件服务
  4. 3.显示客户端的相关请求信息，如：a.客户端连接数量 b.客户端请求的目录 c.客户端请求下载的文件
  5. */ 
  6. //初始化Windows Sockets，设置发送数据缓冲区。 
  7. void CServerDlg::InitSocket(void) 
  8. { 
  9.     WORD    wVersionRequested; //请求的Windows Sockets 实现版本 
  10.     WSADATA wsaData;            //返回协商结果 
  11.     int     nErrCode;          //调用API函数的返回值 
  12.     wVersionRequested = MAKEWORD(2, 2);  
  13.     nErrCode = WSAStartup( wVersionRequested, &wsaData ); 
  14.     if ( 0 != nErrCode )  
  15.     { 
  16.         return; 
  17.     } 
  18.      
  19.     //创建套接字 
  20.     m_sServer = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); 
  21.     if (INVALID_SOCKET == m_sServer) 
  22.     { 
  23.         return; 
  24.     } 
  25.  
  26.     //获取系统默认的发送数据缓冲区大小 
  27.     unsigned int uiRcvBuf; 
  28.     int uiRcvBufLen = sizeof(uiRcvBuf); 
  29.     nErrCode= getsockopt(m_sServer, SOL_SOCKET, SO_SNDBUF,(char*)&uiRcvBuf, &uiRcvBufLen); 
  30.     if (SOCKET_ERROR == nErrCode) 
  31.     { 
  32.         return; 
  33.     } 
  34.  
  35.     //设置系统发送数据缓冲区为默认值的BUF_TIMES倍 
  36.     uiRcvBuf *= BUF_TIMES; 
  37.     nErrCode = setsockopt(m_sServer, SOL_SOCKET, SO_SNDBUF,(char*)&uiRcvBuf, uiRcvBufLen); 
  38.     if (SOCKET_ERROR == nErrCode) 
  39.     { 
  40.         AfxMessageBox(_T("修改系统发送数据缓冲区失败！")); 
  41.     } 
  42.  
  43.     //检查设置系统发送数据缓冲区是否成功 
  44.     unsigned int uiNewRcvBuf; 
  45.     getsockopt(m_sServer, SOL_SOCKET, SO_SNDBUF,(char*)&uiNewRcvBuf, &uiRcvBufLen); 
  46.     if (SOCKET_ERROR == nErrCode || uiNewRcvBuf != uiRcvBuf) 
  47.     { 
  48.         AfxMessageBox(_T("修改系统发送数据缓冲区失败！"));; 
  49.     } 
  50. } 
  51.  
  52. //释放套接字占用的资源 
  53. void CServerDlg::UnInitSocke(void) 
  54. {  
  55.     closesocket(m_sServer); 
  56.     WSACleanup(); 
  57. } 
  58.  
  59. //启动服务 按钮 
  60. void CServerDlg::OnButtonStartup()  
  61. {    
  62.     UpdateData(TRUE);               //更新对话框 
  63.      
  64.     int     reVal;                 //返回值   
  65.     DWORD   dwServIP;        
  66.     m_ctlIP.GetAddress(dwServIP);   //得到服务器IP 
  67.      
  68.     //服务器套接字地址 
  69.     SOCKADDR_IN servAddr; 
  70.     servAddr.sin_family = AF_INET; 
  71.     servAddr.sin_addr.S_un.S_addr = htonl(dwServIP); 
  72.     servAddr.sin_port = htons(SERVERPORT); 
  73.      
  74.     //绑定服务器 
  75.     reVal = bind(m_sServer,(sockaddr*)&servAddr,sizeof(SOCKADDR_IN)); 
  76.     if (SOCKET_ERROR == reVal) 
  77.     { 
  78.         AfxMessageBox(_T("服务器绑定失败"), MB_OK, 0); 
  79.         closesocket(m_sServer); 
  80.         WSACleanup(); 
  81.         return; 
  82.     } 
  83.     else  
  84.     { 
  85.         m_ctlTip.SetWindowText(_T("服务器绑定成功！")); 
  86.         UpdateData(false); 
  87.     } 
  88.      
  89.     //监听 
  90.     reVal = listen(m_sServer,SOMAXCONN); 
  91.     if (SOCKET_ERROR == reVal) 
  92.     { 
  93.         AfxMessageBox(_T("服务器监听失败！"), MB_OK, 0); 
  94.         closesocket(m_sServer); 
  95.         WSACleanup(); 
  96.         return; 
  97.     }    
  98.  
  99.     m_bConning = TRUE;//修改服务器状态 
  100.  
  101.     //创建接受和处理客户端请求线程 
  102.     DWORD dwThread;  
  103.     m_hReqAndData = CreateThread(NULL, 0, DirAndFileSizeServcieThread,this, 0, &dwThread); 
  104.     CloseHandle(m_hReqAndData); 
  105.      
  106.     //更新界面 
  107.     (CButton*)GetDlgItem(IDC_BUTTON_STARTUP)->EnableWindow(FALSE);  //启动按钮无效 
  108.     m_ctlIP.EnableWindow(FALSE);                                    //服务器地址控件无效 
  109.     m_ctlTip.SetWindowText(_T("服务器启动成功！"));                 //显示成功信息 
  110.     UpdateData(FALSE);                                              //初始化对话框     
  111. } 
  112.  
  113. /*接受和处理客户端请求线程
  114. 该函数以select()函数为核心，实现对服务器所有套接字的管理。主要功能：
  115. 1.接收客户端连接请求
  116. 2.调用CClient类的RecvData()函数向接收客户端数据
  117. 3.调用CClient类的SendData()函数向客户端发送数据
  118. 4.调用AddClient()和DeleteClient()实现对客户端的管理
  119. 5.调用ShowClientNumberInfor()更新 服务器节目信息
  120. 客户端启动后向服务器发送连接请求。服务器接收该请求，新建套接字。客户端后续的目录请求和文件长度请求，都在此套接字上完成。当客户端退出时，该套接字关闭。
  121. 当客户端需要下载文件时，首先通过前面建立的套接字获取文件的长度。然后，客户端创建套接字，并向服务器发送连接请求。服务器接收该请求，新建套接字。然后在此套接字上向客户端上传文件。当文件上传  完毕后，关闭该套接字。
  122. 总之，服务器管理客户端的套接字分两种，一种用于处理目录结构和文件长度，另一种用于上传文件。
  123. */ 
  124. DWORD WINAPI CServerDlg::DirAndFileSizeServcieThread(void *pParam) 
  125. { 
  126.      CServerDlg* pServer = (CServerDlg*)pParam; 
  127.      SOCKET sListen = pServer->GetSocket();//获得服务器监听套接字 
  128.       
  129.      FD_SET allSockfd;              //服务器所有套接字集合 
  130.      FD_ZERO(&allSockfd);           //清空集合 
  131.      FD_SET(sListen, &allSockfd);   //将监听套接字加入该集合 
  132.       
  133.      FD_SET readfd;                 //定义满足可读套接字集合 
  134.      FD_SET writefd;                //定义满足可写套接字集合 
  135.      while (pServer->IsConnenting())//服务器运行状态 
  136.      { 
  137.          FD_ZERO(&readfd);          //清空可读集合 
  138.          FD_ZERO(&writefd);         //清空可写集合 
  139.          readfd = allSockfd;        //赋值 
  140.          writefd = allSockfd;       //赋值 
  141.           
  142.          //更新界面信息 
  143.          pServer->ShowClientNumberInfor(allSockfd.fd_count); 
  144.          
  145.          //无限期等待套接字满足条件 
  146.          int nRet = select(0, &readfd, &writefd, NULL, NULL);    
  147.          if (pServer->IsConnenting() && nRet > 0)//添加了pServer->IsConnecting();调试时发现一个问题：当程序执行到上一行代码时，这时单击关闭按钮，资源释放时有一个服务器接收到了一个客户端的连接，其实客户端没有连接，为此出现了异常。 
  148.          { 
  149.              //遍历所有套接字集合 
  150.              for (int i = 0; i < allSockfd.fd_count; i++)         
  151.              { 
  152.                  //存在可读的套接字（包括接收客户端的连接，和接收客户端的数据） 
  153.                  if (FD_ISSET(allSockfd.fd_array[i], &readfd)) 
  154.                  {                    
  155.                      if (allSockfd.fd_array[i] == sListen)//接受客户端连接请求       
  156.                      { 
  157.                          SOCKADDR_IN    addrClient; 
  158.                          int nAddrLen =sizeof(addrClient); 
  159.                          SOCKET sClient = accept(sListen, (sockaddr*)&addrClient, &nAddrLen); 
  160.                          //新建一个 CClient类实例 
  161.                          CClient *pClient = new CClient(sClient, pServer);   
  162.                          //加入客户端管理链表中 
  163.                          pServer->AddClient(pClient);             
  164.                          //加入套接字集合 
  165.                          FD_SET(sClient, &allSockfd);        
  166.                          //更新界面信息 
  167.                          pServer->ShowClientNumberInfor(allSockfd.fd_count);                       
  168.                      } 
  169.                      else//接收客户端数据 
  170.                      {   
  171.                          //得到CClient类的实例 
  172.                          CClient* pClient = pServer->GetClient(allSockfd.fd_array[i]); 
  173.                          if (pClient != NULL) 
  174.                          { 
  175.                              //接收数据 
  176.                              BOOL bRet = pClient->RecvData();                 
  177.                              //接收数据错误或者客户端关闭套接字 
  178.                              if (FALSE == bRet)                          
  179.                              { 
  180.                                  //取出套接字 
  181.                                  SOCKET sTemp = allSockfd.fd_array[i]; 
  182.                                  //从集合中删除 
  183.                                  FD_CLR(allSockfd.fd_array[i], &allSockfd); 
  184.                                  //从客户端管理链表中删除该客户端 
  185.                                  pServer->DeleteClient(sTemp); 
  186.                                  //更新界面信息 
  187.                                  pServer->ShowClientNumberInfor(allSockfd.fd_count); 
  188.                              }            
  189.                          }                        
  190.                      }                
  191.                  } 
  192.                                   
  193.                  if (FD_ISSET(allSockfd.fd_array[i], &writefd))//存在的可写套接字 
  194.                  { 
  195.                      //得到CClient类的实例 
  196.                      CClient* pClient = pServer->GetClient(allSockfd.fd_array[i]); 
  197.                      if (pClient != NULL) 
  198.                      { 
  199.                          //发送数据 
  200.                          BOOL bRet = pClient->SendData();                          
  201.                          if (FALSE == bRet)//发送数据失败 
  202.                          { 
  203.                              //被删除的套接字 
  204.                              SOCKET sDelete = allSockfd.fd_array[i]; 
  205.                              //从集合中删除该套接字 
  206.                              FD_CLR(allSockfd.fd_array[i], &allSockfd); 
  207.                              //从客户端管理链表中删除该客户端 
  208.                              pServer->DeleteClient(sDelete); 
  209.                              //更新界面信息 
  210.                              pServer->ShowClientNumberInfor(allSockfd.fd_count); 
  211.                          }           
  212.                      }                                                
  213.                  } 
  214.              } 
  215.          }        
  216.          Sleep(THREAD_SLEEP);//线程睡眠 
  217.      } 
  218.       
  219.      pServer->DeleteAllClient();//删除所有的客户端 
  220.      return 0; 
  221. }  
/*服务器实现以下功能
1.使用select模型管理与客户端建立的套接字
2.同时为多个客户端提供服务器目录信息和下载文件服务
3.显示客户端的相关请求信息，如：a.客户端连接数量 b.客户端请求的目录 c.客户端请求下载的文件
*/
//初始化Windows Sockets，设置发送数据缓冲区。
void CServerDlg::InitSocket(void)
{
	WORD	wVersionRequested;	//请求的Windows Sockets 实现版本
	WSADATA	wsaData;			//返回协商结果
	int		nErrCode;			//调用API函数的返回值
	wVersionRequested = MAKEWORD(2, 2);	
	nErrCode = WSAStartup( wVersionRequested, &wsaData );
	if ( 0 != nErrCode ) 
	{
		return;
	}
	
	//创建套接字
	m_sServer = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (INVALID_SOCKET == m_sServer)
	{
		return;
	}

	//获取系统默认的发送数据缓冲区大小
	unsigned int uiRcvBuf;
	int uiRcvBufLen = sizeof(uiRcvBuf);
	nErrCode= getsockopt(m_sServer, SOL_SOCKET, SO_SNDBUF,(char*)&uiRcvBuf, &uiRcvBufLen);
	if (SOCKET_ERROR == nErrCode)
	{
		return;
	}

	//设置系统发送数据缓冲区为默认值的BUF_TIMES倍
	uiRcvBuf *= BUF_TIMES;
	nErrCode = setsockopt(m_sServer, SOL_SOCKET, SO_SNDBUF,(char*)&uiRcvBuf, uiRcvBufLen);
	if (SOCKET_ERROR == nErrCode)
	{
		AfxMessageBox(_T("修改系统发送数据缓冲区失败！"));
	}

	//检查设置系统发送数据缓冲区是否成功
	unsigned int uiNewRcvBuf;
	getsockopt(m_sServer, SOL_SOCKET, SO_SNDBUF,(char*)&uiNewRcvBuf, &uiRcvBufLen);
	if (SOCKET_ERROR == nErrCode || uiNewRcvBuf != uiRcvBuf)
	{
		AfxMessageBox(_T("修改系统发送数据缓冲区失败！"));;
	}
}

//释放套接字占用的资源
void CServerDlg::UnInitSocke(void)
{ 
	closesocket(m_sServer);
	WSACleanup();
}

//启动服务 按钮
void CServerDlg::OnButtonStartup() 
{	
	UpdateData(TRUE);				//更新对话框
	
	int		reVal;					//返回值	
	DWORD	dwServIP;		
	m_ctlIP.GetAddress(dwServIP);	//得到服务器IP
	
	//服务器套接字地址
	SOCKADDR_IN servAddr;
	servAddr.sin_family = AF_INET;
	servAddr.sin_addr.S_un.S_addr = htonl(dwServIP);
	servAddr.sin_port = htons(SERVERPORT);
	
	//绑定服务器
	reVal = bind(m_sServer,(sockaddr*)&servAddr,sizeof(SOCKADDR_IN));
	if (SOCKET_ERROR == reVal)
	{
		AfxMessageBox(_T("服务器绑定失败"), MB_OK, 0);
		closesocket(m_sServer);
		WSACleanup();
		return;
	}
	else 
	{
		m_ctlTip.SetWindowText(_T("服务器绑定成功！"));
		UpdateData(false);
	}
	
	//监听
	reVal = listen(m_sServer,SOMAXCONN);
	if (SOCKET_ERROR == reVal)
	{
		AfxMessageBox(_T("服务器监听失败！"), MB_OK, 0);
		closesocket(m_sServer);
		WSACleanup();
		return;
	}	

	m_bConning = TRUE;//修改服务器状态

	//创建接受和处理客户端请求线程
	DWORD dwThread;	
	m_hReqAndData = CreateThread(NULL, 0, DirAndFileSizeServcieThread, this, 0, &dwThread);
	CloseHandle(m_hReqAndData);
	
	//更新界面
	(CButton*)GetDlgItem(IDC_BUTTON_STARTUP)->EnableWindow(FALSE);	//启动按钮无效
	m_ctlIP.EnableWindow(FALSE);									//服务器地址控件无效
	m_ctlTip.SetWindowText(_T("服务器启动成功！"));					 //显示成功信息
	UpdateData(FALSE);												//初始化对话框	
}

/*接受和处理客户端请求线程
 该函数以select()函数为核心，实现对服务器所有套接字的管理。主要功能：
 1.接收客户端连接请求
 2.调用CClient类的RecvData()函数向接收客户端数据
 3.调用CClient类的SendData()函数向客户端发送数据
 4.调用AddClient()和DeleteClient()实现对客户端的管理
 5.调用ShowClientNumberInfor()更新 服务器节目信息
 客户端启动后向服务器发送连接请求。服务器接收该请求，新建套接字。客户端后续的目录请求和文件长度请求，都在此套接字上完成。当客户端退出时，该套接字关闭。
 当客户端需要下载文件时，首先通过前面建立的套接字获取文件的长度。然后，客户端创建套接字，并向服务器发送连接请求。服务器接收该请求，新建套接字。然后在此套接字上向客户端上传文件。当文件上传  完毕后，关闭该套接字。
 总之，服务器管理客户端的套接字分两种，一种用于处理目录结构和文件长度，另一种用于上传文件。
 */
 DWORD WINAPI CServerDlg::DirAndFileSizeServcieThread(void *pParam)
 {
	 CServerDlg* pServer = (CServerDlg*)pParam;
	 SOCKET sListen = pServer->GetSocket();//获得服务器监听套接字
	 
	 FD_SET	allSockfd;				//服务器所有套接字集合
	 FD_ZERO(&allSockfd);			//清空集合
	 FD_SET(sListen, &allSockfd);	//将监听套接字加入该集合
	 
	 FD_SET readfd;					//定义满足可读套接字集合
	 FD_SET writefd;				//定义满足可写套接字集合
	 while (pServer->IsConnenting())//服务器运行状态
	 {
		 FD_ZERO(&readfd);			//清空可读集合
		 FD_ZERO(&writefd);			//清空可写集合
		 readfd = allSockfd;		//赋值
		 writefd = allSockfd;		//赋值
		 
		 //更新界面信息
		 pServer->ShowClientNumberInfor(allSockfd.fd_count);
		
		 //无限期等待套接字满足条件
		 int nRet = select(0, &readfd, &writefd, NULL, NULL);	
		 if (pServer->IsConnenting() && nRet > 0)//添加了pServer->IsConnecting();调试时发现一个问题：当程序执行到上一行代码时，这时单击关闭按钮，资源释放时有一个服务器接收到了一个客户端的连接，其实客户端没有连接，为此出现了异常。
		 {
			 //遍历所有套接字集合
			 for (int i = 0; i < allSockfd.fd_count; i++)		
			 {
				 //存在可读的套接字（包括接收客户端的连接，和接收客户端的数据）
				 if (FD_ISSET(allSockfd.fd_array[i], &readfd))
				 {					 
					 if (allSockfd.fd_array[i] == sListen)//接受客户端连接请求 		
					 {
						 SOCKADDR_IN	addrClient;
						 int nAddrLen = sizeof(addrClient);
						 SOCKET sClient = accept(sListen, (sockaddr*)&addrClient, &nAddrLen);
						 //新建一个 CClient类实例
						 CClient *pClient = new CClient(sClient, pServer);	
						 //加入客户端管理链表中
						 pServer->AddClient(pClient);			
						 //加入套接字集合
						 FD_SET(sClient, &allSockfd);		
						 //更新界面信息
						 pServer->ShowClientNumberInfor(allSockfd.fd_count);						 
					 }
					 else //接收客户端数据
					 {	
						 //得到CClient类的实例
						 CClient* pClient = pServer->GetClient(allSockfd.fd_array[i]);
						 if (pClient != NULL)
						 {
							 //接收数据
							 BOOL bRet = pClient->RecvData();				
							 //接收数据错误或者客户端关闭套接字
							 if (FALSE == bRet)							
							 {
								 //取出套接字
								 SOCKET sTemp = allSockfd.fd_array[i];
								 //从集合中删除
								 FD_CLR(allSockfd.fd_array[i], &allSockfd);
								 //从客户端管理链表中删除该客户端
								 pServer->DeleteClient(sTemp);
								 //更新界面信息
								 pServer->ShowClientNumberInfor(allSockfd.fd_count);
							 }			 
						 }						 
					 }				 
				 }
				 				 
				 if (FD_ISSET(allSockfd.fd_array[i], &writefd))//存在的可写套接字
				 {
					 //得到CClient类的实例
					 CClient* pClient = pServer->GetClient(allSockfd.fd_array[i]);
					 if (pClient != NULL)
					 {
						 //发送数据
						 BOOL bRet = pClient->SendData();						 
						 if (FALSE == bRet)//发送数据失败
						 {
							 //被删除的套接字
							 SOCKET sDelete = allSockfd.fd_array[i];
							 //从集合中删除该套接字
							 FD_CLR(allSockfd.fd_array[i], &allSockfd);
							 //从客户端管理链表中删除该客户端
							 pServer->DeleteClient(sDelete);
							 //更新界面信息
							 pServer->ShowClientNumberInfor(allSockfd.fd_count);
						 }			
					 }							 					 
				 }
			 }
		 }		 
		 Sleep(THREAD_SLEEP);//线程睡眠
	 }
	 
	 pServer->DeleteAllClient();//删除所有的客户端
	 return 0;
 }

客户端关键代码

[cpp] view plain copy print ?
  1. /*
  2. A.主线程
  3. 1.创建发送和接收目录线程
  4. 2.接受用户界面操作并更新界面
  6. B.发送请求接收目录线程
  7. 1.向服务器发送根目录请求，并接收其返回的数据
  8. 2.向服务器发送子目录请求，并接收其返回的数据
  9. 3.向服务器发送下载文件的长度请求，并接收其返回数据
  10. 4.启动创建文件下载线程
  12. C.创建下载文件线程
  13. 1.创建3个下载文件线程
  14. 2.为每个下载文件线程分配下载文件任务，包括下载文件的开始位置和长度
  15. 3.下载文件线程返回后，合并文件
  17. D.下载文件线程
  18. 1.向服务器发送下载文件请求。请求中包括文件路径，下载文件开始位置和文件长度等信息
  19. 2.接收服务器发送的文件
  20. 3.保存文件
  21. */ 
  22. //初始化Windows Sockets 
  23. void CClientDlg::InitSocket(void) 
  24. {    
  25.     WORD    wVersionRequested;         //请求socket版本 
  26.     WSADATA wsaData;                    //wsaData结构 
  27.     int     nErrCode;                  //返回值 
  28.      
  29.     wVersionRequested = MAKEWORD( 2, 2 );//请求windows Sockets 2.2版本  
  30.     nErrCode = WSAStartup( wVersionRequested, &wsaData ); 
  31.     if ( 0 != nErrCode ) 
  32.     { 
  33.         return; 
  34.     } 
  35.      
  36.     //创建套接字 
  37.     m_sHost = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); 
  38.     if (INVALID_SOCKET == m_sHost) 
  39.     { 
  40.         return; 
  41.     } 
  42.      
  43.     //设置系统接收数据为默认的BUF_TIMES倍 
  44.     unsigned int uiRcvBuf; 
  45.     int uiRcvBufLen = sizeof(uiRcvBuf); 
  46.     nErrCode= getsockopt(m_sHost, SOL_SOCKET, SO_RCVBUF,(char*)&uiRcvBuf, &uiRcvBufLen); 
  47.     if (SOCKET_ERROR == nErrCode) 
  48.     { 
  49.         return; 
  50.     } 
  51.     uiRcvBuf *= BUF_TIMES; 
  52.     nErrCode = setsockopt(m_sHost, SOL_SOCKET, SO_RCVBUF,(char*)&uiRcvBuf, uiRcvBufLen); 
  53.     if (SOCKET_ERROR == nErrCode) 
  54.     { 
  55.         AfxMessageBox(_T("修改系统发送数据缓冲区失败！")); 
  56.     } 
  57.  
  58.     //检查设置系统接收数据缓冲区是否成功 
  59.     unsigned int uiNewRcvBuf; 
  60.     getsockopt(m_sHost, SOL_SOCKET, SO_RCVBUF,(char*)&uiNewRcvBuf, &uiRcvBufLen); 
  61.     if (SOCKET_ERROR == nErrCode || uiNewRcvBuf != uiRcvBuf) 
  62.     { 
  63.         AfxMessageBox(_T("修改系统发送数据缓冲区失败！"));; 
  64.     } 
  65. } 
  66.  
  67. //释放套接字占用的资源  
  68. void CClientDlg::UnInitSocket(void) 
  69. { 
  70.     closesocket(m_sHost); 
  71.     WSACleanup();    
  72. } 
  73.  
  74. //连接服务器 
  75. void CClientDlg::OnButtonConnect()  
  76. { 
  77.     //获得服务器的IP地址 
  78.     UpdateData(TRUE); 
  79.     DWORD dwServIP; 
  80.     m_ctlIP.GetAddress(dwServIP); 
  81.  
  82.     //服务器套结字地址 
  83.     SOCKADDR_IN servAddr; 
  84.     servAddr.sin_family = AF_INET; 
  85.     servAddr.sin_addr.S_un.S_addr = htonl(dwServIP); 
  86.     servAddr.sin_port = htons(SERVERPORT); 
  87.  
  88.     //连接服务器 
  89.     int nErrCode; 
  90.     nErrCode = connect(m_sHost,(sockaddr*)&servAddr, sizeof(SOCKADDR_IN)); 
  91.     if (SOCKET_ERROR == nErrCode) 
  92.     { 
  93.         AfxMessageBox("连接服务器失败！",MB_OK, 0);  
  94.         return; 
  95.     } 
  96.      
  97.     //显示连接服务器成功信息 
  98.     m_ctlTip.SetWindowText(_T("连接服务器成功!")); 
  99.     m_bConning = TRUE; 
  100.  
  101.     //请求服务器目录 
  102.     m_nReqCur = REQROOT; 
  103.  
  104.     //创建发送和接收目录线程 
  105.     DWORD dwThread; 
  106.     m_hThreadSR = CreateThread(NULL, 0, SendAndRecvDirInforThread, this, 0, &dwThread); 
  107.     CloseHandle(m_hThreadSR); 
  108.  
  109.     //设置连接服务器按钮为无效状态 
  110.     CButton *pBt = (CButton*)this->GetDlgItem(IDC_BUTTON_CONNECT); 
  111.     pBt->EnableWindow(FALSE); 
  112. } 
  113.  
  114. //发送请求接收目录信息线程 
  115. DWORD CClientDlg::SendAndRecvDirInforThread(void* pParam) 
  116. { 
  117.     CClientDlg* pClient = (CClientDlg*)pParam; 
  118.     SOCKET  sHost = pClient->GetHostSocket();//客户端套接字    
  119.  
  120.     FD_SET writefd; //可写集合 
  121.     FD_SET readfd;  //可读集合 
  122.  
  123.     while (pClient->IsConning()) 
  124.     { 
  125.         FD_ZERO(&writefd);      //清零 
  126.         FD_ZERO(&readfd);       //清零 
  127.         FD_SET(sHost, &writefd);//添加到可写集合 
  128.         FD_SET(sHost, &readfd); //添加到可读集合 
  129.  
  130.         int reVal = 0; 
  131.         reVal = select(0, &readfd, &writefd, NULL, NULL);//等待套接字满足条件 
  132.         if (SOCKET_ERROR == reVal) 
  133.         { 
  134.             AfxMessageBox(_T("select错误")); 
  135.             return 0; 
  136.         } 
  137.         else if ( reVal > 0) 
  138.         { 
  139.             if (FD_ISSET(sHost, &writefd))         //满足可写的条件 
  140.             { 
  141.                 if (FALSE == pClient->SendReq())//发送数据 
  142.                 { 
  143.                     AfxMessageBox(_T("select错误")); 
  144.                     return 0; 
  145.                 }            
  146.             }            
  147.  
  148.             if (FD_ISSET(sHost, &readfd))          //满足可读的条件 
  149.             { 
  150.                 if(FALSE == pClient->RecvDirInfor())//接收数据 
  151.                 { 
  152.                     AfxMessageBox("接收目录信息失败！"); 
  153.                     return 0; 
  154.                 } 
  155.             }            
  156.         } 
  157.         Sleep(THREAD_SLEEP);//线程睡眠      
  158.     }    
  159.     return 0; 
  160. } 
  161.  
  162. //发送请求 
  163. BOOL CClientDlg::SendReq(void) 
  164. { 
  165.     int reVal;         //返回值 
  166.     switch(m_nReqCur)   //请求类型 
  167.     { 
  168.     case REQROOT://根目录 
  169.         { 
  170.             //发送数据包，只有包头 
  171.             hdr header; 
  172.             memset(&header, 0, sizeof(header)); 
  173.             header.type = ROOT; 
  174.             header.len = HEADLEN; 
  175.  
  176.             reVal = send(m_sHost, (char*)&header, HEADLEN, 0); 
  177.             if (SOCKET_ERROR == reVal) 
  178.             { 
  179.                 AfxMessageBox(_T("发送数据失败！")); 
  180.                 return FALSE; 
  181.             } 
  182.             m_nReqCur = REQNON; 
  183.             break; 
  184.         } 
  185.     case REQDIRC://子目录 
  186.         { 
  187.             hdr header; 
  188.             memset(&header, 0, sizeof(header)); 
  189.             header.type = DIRC; 
  190.             header.len = HEADLEN + m_strReqDir.size(); 
  191.  
  192.             //先发送包头 
  193.             reVal = send(m_sHost,(char*)&header, HEADLEN, 0); 
  194.             if (SOCKET_ERROR == reVal) 
  195.             { 
  196.                 AfxMessageBox(_T("发送数据失败！")); 
  197.                 return FALSE; 
  198.             } 
  199.  
  200.             //再发送包体 
  201.             reVal = send(m_sHost,m_strReqDir.c_str(), m_strReqDir.size(), 0); 
  202.             if (SOCKET_ERROR == reVal) 
  203.             { 
  204.                 AfxMessageBox(_T("发送数据失败！")); 
  205.                 return FALSE; 
  206.             } 
  207.             m_nReqCur = REQNON; 
  208.             m_strReqDir.erase(m_strReqDir.begin(), m_strReqDir.end());//清空 
  209.             break; 
  210.         } 
  211.     case REQFSIZ: 
  212.         { 
  213.             hdr header; 
  214.             memset(&header, 0, sizeof(header)); 
  215.             header.type = FSIZ; 
  216.             header.len = HEADLEN + m_strReqFile.size(); 
  217.  
  218.             //先发送包头 
  219.             reVal = send(m_sHost,(char*)&header, HEADLEN, 0); 
  220.             if (SOCKET_ERROR == reVal) 
  221.             { 
  222.                 AfxMessageBox(_T("发送数据失败！")); 
  223.                 return FALSE; 
  224.             } 
  225.  
  226.             //再发送包体 
  227.             reVal = send(m_sHost,m_strReqFile.c_str(), m_strReqFile.size(), 0); 
  228.             if (SOCKET_ERROR == reVal) 
  229.             { 
  230.                 AfxMessageBox(_T("发送数据失败！")); 
  231.                 return FALSE; 
  232.             } 
  233.             m_nReqCur = REQNON; 
  234.  
  235.             break; 
  236.         } 
  237.     case REQFDAT: 
  238.         { 
  239.             break; 
  240.         } 
  241.     default: 
  242.         break; 
  243.     } 
  244.     return TRUE; 
  245. } 
  246.  
  247. //接收服务器数据 
  248. BOOL CClientDlg::RecvDirInfor(void) 
  249. { 
  250.     BOOL    reVal = TRUE;   //返回值    
  251.     int     nErrCode;      //错误值 
  252.  
  253.     //读取包头 
  254.     hdr header; 
  255.     nErrCode = recv(m_sHost,(char*)&header, HEADLEN,0);      
  256.     if (SOCKET_ERROR == nErrCode || 0 == nErrCode)//服务器关闭了 
  257.     { 
  258.         AfxMessageBox(_T("服务器关闭！")); 
  259.         reVal = FALSE;           
  260.     }    
  261.  
  262.     //读取包体 
  263.     int nDataLen = header.len - HEADLEN;//包体的长度 
  264.     switch(header.type)                //根据数据包的类型分类 再读取包体 
  265.     { 
  266.     case ROOT://根目录 
  267.     case DIRC://文件目录 
  268.         { 
  269.             if(FALSE == RecvDirString(nDataLen)) 
  270.             { 
  271.                 AfxMessageBox("接收目录信息失败！"); 
  272.                 reVal = FALSE; 
  273.             }            
  274.             break; 
  275.         } 
  276.     case FSIZ://文件大小 
  277.         { 
  278.             RecvFileSize(header.flen); 
  279.             break; 
  280.         }    
  281.     default: 
  282.         break;                       
  283.     }    
  284.     return reVal; 
  285. }  
/*
A.主线程
1.创建发送和接收目录线程
2.接受用户界面操作并更新界面

B.发送请求接收目录线程
1.向服务器发送根目录请求，并接收其返回的数据
2.向服务器发送子目录请求，并接收其返回的数据
3.向服务器发送下载文件的长度请求，并接收其返回数据
4.启动创建文件下载线程

C.创建下载文件线程
1.创建3个下载文件线程
2.为每个下载文件线程分配下载文件任务，包括下载文件的开始位置和长度
3.下载文件线程返回后，合并文件

D.下载文件线程
1.向服务器发送下载文件请求。请求中包括文件路径，下载文件开始位置和文件长度等信息
2.接收服务器发送的文件
3.保存文件
*/
//初始化Windows Sockets
void CClientDlg::InitSocket(void)
{	
	WORD	wVersionRequested;			//请求socket版本
	WSADATA	wsaData;					//wsaData结构
	int		nErrCode;					//返回值
	
	wVersionRequested = MAKEWORD( 2, 2 );//请求windows Sockets 2.2版本	
	nErrCode = WSAStartup( wVersionRequested, &wsaData );
	if ( 0 != nErrCode )
	{
		return;
	}
	
	//创建套接字
	m_sHost = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (INVALID_SOCKET == m_sHost)
	{
		return;
	}
	
	//设置系统接收数据为默认的BUF_TIMES倍
	unsigned int uiRcvBuf;
	int uiRcvBufLen = sizeof(uiRcvBuf);
	nErrCode= getsockopt(m_sHost, SOL_SOCKET, SO_RCVBUF,(char*)&uiRcvBuf, &uiRcvBufLen);
	if (SOCKET_ERROR == nErrCode)
	{
		return;
	}
	uiRcvBuf *= BUF_TIMES;
	nErrCode = setsockopt(m_sHost, SOL_SOCKET, SO_RCVBUF,(char*)&uiRcvBuf, uiRcvBufLen);
	if (SOCKET_ERROR == nErrCode)
	{
		AfxMessageBox(_T("修改系统发送数据缓冲区失败！"));
	}

	//检查设置系统接收数据缓冲区是否成功
	unsigned int uiNewRcvBuf;
	getsockopt(m_sHost, SOL_SOCKET, SO_RCVBUF,(char*)&uiNewRcvBuf, &uiRcvBufLen);
	if (SOCKET_ERROR == nErrCode || uiNewRcvBuf != uiRcvBuf)
	{
		AfxMessageBox(_T("修改系统发送数据缓冲区失败！"));;
	}
}

 //释放套接字占用的资源 
void CClientDlg::UnInitSocket(void)
{
	closesocket(m_sHost);
	WSACleanup();	
}

//连接服务器
void CClientDlg::OnButtonConnect() 
{
	//获得服务器的IP地址
	UpdateData(TRUE);
	DWORD dwServIP;
	m_ctlIP.GetAddress(dwServIP);

	//服务器套结字地址
	SOCKADDR_IN servAddr;
	servAddr.sin_family = AF_INET;
	servAddr.sin_addr.S_un.S_addr = htonl(dwServIP);
	servAddr.sin_port = htons(SERVERPORT);

	//连接服务器
	int nErrCode;
	nErrCode = connect(m_sHost,(sockaddr*)&servAddr, sizeof(SOCKADDR_IN));
	if (SOCKET_ERROR == nErrCode)
	{
		AfxMessageBox("连接服务器失败！",MB_OK, 0);	
		return;
	}
	
	//显示连接服务器成功信息
	m_ctlTip.SetWindowText(_T("连接服务器成功!"));
	m_bConning = TRUE;

	//请求服务器目录
	m_nReqCur = REQROOT;

	//创建发送和接收目录线程
	DWORD dwThread;
	m_hThreadSR = CreateThread(NULL, 0, SendAndRecvDirInforThread, this, 0, &dwThread);
 	CloseHandle(m_hThreadSR);

	//设置连接服务器按钮为无效状态
	CButton *pBt = (CButton*)this->GetDlgItem(IDC_BUTTON_CONNECT);
	pBt->EnableWindow(FALSE);
}

//发送请求接收目录信息线程
DWORD CClientDlg::SendAndRecvDirInforThread(void* pParam)
{
	CClientDlg* pClient = (CClientDlg*)pParam;
	SOCKET	sHost = pClient->GetHostSocket();//客户端套接字	

	FD_SET writefd;	//可写集合
	FD_SET readfd;	//可读集合

	while (pClient->IsConning())
	{
		FD_ZERO(&writefd);		//清零
		FD_ZERO(&readfd);		//清零
		FD_SET(sHost, &writefd);//添加到可写集合
		FD_SET(sHost, &readfd);	//添加到可读集合

		int reVal = 0;
		reVal = select(0, &readfd, &writefd, NULL, NULL);//等待套接字满足条件
		if (SOCKET_ERROR == reVal)
		{
			AfxMessageBox(_T("select错误"));
			return 0;
		}
		else if ( reVal > 0)
		{
			if (FD_ISSET(sHost, &writefd))			//满足可写的条件
			{
				if (FALSE == pClient->SendReq())	//发送数据
				{
					AfxMessageBox(_T("select错误"));
					return 0;
				}			
			}			

			if (FD_ISSET(sHost, &readfd))			//满足可读的条件
			{
				if(FALSE == pClient->RecvDirInfor())//接收数据
				{
					AfxMessageBox("接收目录信息失败！");
					return 0;
				}
			}			
		}
		Sleep(THREAD_SLEEP);//线程睡眠		
	}	
	return 0;
}

//发送请求
BOOL CClientDlg::SendReq(void)
{
	int reVal;			//返回值
	switch(m_nReqCur)	//请求类型
	{
	case REQROOT://根目录
		{
			//发送数据包，只有包头
			hdr header;
			memset(&header, 0, sizeof(header));
			header.type = ROOT;
			header.len = HEADLEN;

			reVal = send(m_sHost, (char*)&header, HEADLEN, 0);
			if (SOCKET_ERROR == reVal)
			{
				AfxMessageBox(_T("发送数据失败！"));
				return FALSE;
			}
			m_nReqCur = REQNON;
			break;
		}
	case REQDIRC://子目录
		{
			hdr header;
			memset(&header, 0, sizeof(header));
			header.type = DIRC;
			header.len = HEADLEN + m_strReqDir.size();

			//先发送包头
			reVal = send(m_sHost,(char*)&header, HEADLEN, 0);
			if (SOCKET_ERROR == reVal)
			{
				AfxMessageBox(_T("发送数据失败！"));
				return FALSE;
			}

			//再发送包体
			reVal = send(m_sHost,m_strReqDir.c_str(), m_strReqDir.size(), 0);
			if (SOCKET_ERROR == reVal)
			{
				AfxMessageBox(_T("发送数据失败！"));
				return FALSE;
			}
			m_nReqCur = REQNON;
			m_strReqDir.erase(m_strReqDir.begin(), m_strReqDir.end());//清空
			break;
		}
	case REQFSIZ:
		{
			hdr header;
			memset(&header, 0, sizeof(header));
			header.type = FSIZ;
			header.len = HEADLEN + m_strReqFile.size();

			//先发送包头
			reVal = send(m_sHost,(char*)&header, HEADLEN, 0);
			if (SOCKET_ERROR == reVal)
			{
				AfxMessageBox(_T("发送数据失败！"));
				return FALSE;
			}

			//再发送包体
			reVal = send(m_sHost,m_strReqFile.c_str(), m_strReqFile.size(), 0);
			if (SOCKET_ERROR == reVal)
			{
				AfxMessageBox(_T("发送数据失败！"));
				return FALSE;
			}
			m_nReqCur = REQNON;

			break;
		}
	case REQFDAT:
		{
			break;
		}
	default:
		break;
	}
	return TRUE;
}

//接收服务器数据
BOOL CClientDlg::RecvDirInfor(void)
{
	BOOL	reVal = TRUE;	//返回值	
	int		nErrCode;		//错误值

	//读取包头
	hdr header;
	nErrCode = recv(m_sHost,(char*)&header, HEADLEN,0);		
	if (SOCKET_ERROR == nErrCode || 0 == nErrCode)//服务器关闭了
	{
		AfxMessageBox(_T("服务器关闭！"));
		reVal = FALSE;			
	}	

	//读取包体
	int nDataLen = header.len - HEADLEN;//包体的长度	
	switch(header.type)					//根据数据包的类型分类 再读取包体
	{
	case ROOT://根目录
	case DIRC://文件目录
		{
			if(FALSE == RecvDirString(nDataLen))
			{
				AfxMessageBox("接收目录信息失败！");
				reVal = FALSE;
			}			
			break;
		}
	case FSIZ://文件大小
		{
			RecvFileSize(header.flen);
			break;
		}	
	default:
		break;						
	}	
	return reVal;
}

效果图：

源码下载

本文转载来自：http://blog.csdn.net/ouyangshima/article/details/8982582

tanyufeng_521
关注
专栏目录
精通windows socks网络开发--基于visual C++实现
C__Monkey的专栏
09-19 622
1,在开发中应该根据具体情况，选择相应的windows sockets版本，导入wscok32.lib有两种方法：   头文件引用： #pragma comment(lib,"wsock32.lib)   2.80是HTTP通信端口，21是FTP通信端口；   3，INVALID_SOCKET不是一个有效的套接字；   所以判断是否成功创建套接字的方法： SOCKET s =s
c++实现win socket 编程中的Select I/O模型
01-28
采用C++语言实现，在VS2010下开发，代码中有相关的注释，如发现问题请不吝指教，谢谢
windows socket----select模型
keep_moving_cqu的专栏
09-08 1276
一般我们的网络编程都是用bind ,listen,accept,send/sendto,recv/recvfrom。在创建套接字的时候，是默认使用阻塞模式的，每当我们调用send/sendto等方法时，套接字都会进入阻塞状态，等到条件满足后才返回。当然为每个连接创建线程是个解决这个问题的好办法。如：比较容易想到的一种服务器模型就是采用一个主线程，负责监听客户端的连接请求，当接收到某个客户端的连接请
socket编程中select的使用
JonnyWei的专栏
12-04 1593
         Select在Socket编程中还是比较重要的，可是对于初学Socket的人来说都不太爱用Select写程序，他们只是习惯写诸如connect、 accept、recv或recvfrom这样的阻塞程序（所谓阻塞方式block，顾名思义，就是进程或是线程执行到这些函数时必须等待某个事件的发生，如果事件没有发生，进程或线程就被阻塞，函数不能立即返回）。可是使用Select就可以完成
c++SOCKET升级为select模型（待完善）
baidu_41553551的博客
05-21 320
上节接服务端与客户端1.2——发送结构化消息_贪睡的蜗牛的博客-CSDN博客 FD_SET 参考【一文搞懂】FD_SET的使用_欧恩意的博客-CSDN博客_fd_set 一个long类型的数组（我们可以认为这是一个很大的字节数组），提供给select()机制使用的一种数据结构。主要功能是建立联系。其中每一个数组元素都能与任意一个打开的句柄（socket句柄、文件、命名管道、设备句柄等）建立联系。 设置这种联系是“可以理解为给打开的句柄添加了一种标识(读or写or异常)的标识” ...
C++ select模型详解（多路复用IO）
田螺姑娘的博客
11-25 2729
C++ select模型详解（多路复用IO） TIPS：以下内容纯属博主自主查阅资料并结合个人理解得出，各位读者仅做参考即可。 关于其它的IO模型可参考链接（阻塞I/O、非阻塞I/O、多路复用I/O、信号I/O、异步I/O）： 引言   在什么情况下需要使用select模型呢？阻塞I/O问题我们可以使用多线程处理或者将阻塞I/O改为非阻塞I/O，系统调用之后就返回结果，可是完成I/O（即获取数据），我们不得不使用polling（轮询），可每次轮询都是一次系统调用，这将导致一些情况下非阻塞I/O甚至不
[精通windowssocket网络开发-基于vc++实现]源代码
最新发布
01-30
通过精通Windows Socket网络开发-基于VC实现的源代码，可以实现各种网络应用程序，如客户端/服务器程序、网络通信工具、网络游戏等。这些应用程序可以在Windows平台上运行，并提供稳定、高效的网络通信服务。 总之...
精通Windows Sockets网络开发：基于Visual C++实现-带源码
05-21
精通Windows Sockets网络开发——基于Visual C++实现 目 录 第1篇网络开发基础篇 第1章准备开发环境 1.1windows sockets开发概述 1.1.1网络程序开发应用 1.1.2网络程序结构——c/s、b/s 1.1.3网络程序通信基础——...
【精通Windows+Sockets网络开发：基于Visual+C++实现】
03-22
精通Windows+Sockets网络开发：基于Visual+C++实现，资料全，欢迎使用
编程语言-基于VC++的冻干机监控系统的设计与开发.pdf
06-25
### 编程语言-基于VC++的冻干机监控系统的设计与开发 #### 概述 本文档介绍了一种基于VC++（Visual C++）的冻干机监控系统的开发过程。该系统旨在满足北京速原真空技术有限公司对于制药行业中冻干机的控制需求。...
windows socket封装（完成端口，select）
01-14
基于第一个版本比较粗糙，目前对windows下实用的模式进行封装，以达到简单易用，并且完善了第一个版本中的处理不当问题，更为完善。下载分值也更低
VC下SOCKET编程实例(服务器+客户端)源代码
05-09
VC下SOCKET编程实例(服务器+客户端)源代码,很实用，可以用来做扩展开发
c++socket的select函数以及多路复用
qq_44913716的博客
11-28 1956
c++socket的select函数以及多路复用
c++ winsocket select(八)
nocomment_84的博客
02-24 258
1 带宽破2M，去掉打印语句 2 select 可以实现无阻赛 二 代码 1mysocket.h #include <Winsock2.h> #include<vector> #include"mythread.h" const int RECEIVE_BUF_SIZE = 10240; const int DATA_BUF_SIZE = 102400; cla...
C++ Windows Socket五种I/O模型之Select模型
weixin_45317033的博客
03-24 817
概述 Windows操作系统提供了选择（Select）、异步选择 （WSAAsyncSelect）、事件选择（WSAEventSelect）、重叠I/O（Overlapped I/O）和完成端口 （Completion Port)共五种I/O模型。每一种模型均适用于一种特定的应用场景。今天主要讲一下Select 模型。 涉及的API int WSAAPI select( int nfds, fd_set *readfds, fd_set *writefds,
C语言socket编程-select
LLLLLiangCCCCChen的博客
12-22 1486
在早期的Unix系统中，每个进程都有一个单独的I/O流，这种方式效率低下，因为每个I/O操作都需要等待数据的到来。为了提高效率，Unix引入了select函数，它可以同时监听多个文件描述符，随着网络通信的发展，select函数也被广泛应用于网络编程中，它可以同时监听多个网络连接，当其中任意一个连接有数据到来时，就可以进行相应的处理，从而实现高效的网络通信。
Server - Select网络模型
莫忘输赢的博客
08-04 286
Select网络模型 利用select网络模型可以很好的优化之前写的简单的tcp程序。废话少说，直接步入正题： typedef struct fd_set { u_int fd_count; // 有多少个socket SOCKET fd_array[FD_SETSIZE]; // 客户端socket数组，FD_SETSIZE为64 ...
vc++ windows socket I/O模型 WSAeventSelect 模型例子
ssihc0的专栏
01-24 1953
// WSAEventSelect.cpp : 定义控制台应用程序的入口点。//#include "stdafx.h"#include "IniSock.h"CIniSock inisock;int _tmain(int argc, _TCHAR* argv[]){ //事件句柄和sock 句柄表 WSAEVENT eventArray[WSA_MAXIMU
VC中的socket编程
Guix
10-24 534
基于TCP的socket编程服务器端程序：1、创建socket2、将套接字绑定到一个本地地址和端口上bind3、将套接字设为监听模式，准备接受客户请求listen4、等待客户请求到来；当请求到来后，结合搜此次连接的套接字accept5、用返回的套接字和客户端进行通信send/recv6、返回，等待另一客户请求。7、关闭套接字。源码：#pragma   com
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值