[socket编程] 一个服务器与多个客户端之间通信

转自：http://blog.csdn.net/neicole/article/details/7539444 并加以改进

Server程序：

 // OneServerMain.cpp

 #include <iostream>
 #include <cstdio>
 #include <string>
 #include <cstring>
 #include <vector>
 #include <iterator>
 #include <algorithm>
 #include <Winsock2.h>
 #include <Windows.h>

 using namespace std;
 HANDLE bufferMutex;        // 令其能互斥成功正常通信的信号量句柄
 SOCKET sockConn;        // 客户端的套接字
 vector <SOCKET> clientSocketGroup;

 DWORD WINAPI SendMessageThread(LPVOID IpParameter);
 DWORD WINAPI ReceiveMessageThread(LPVOID IpParameter);

 int main()
 {
     // 加载socket动态链接库(dll)
     WORD wVersionRequested;
     WSADATA wsaData;    // 该结构用于接收Wjndows Socket的结构信息
     wVersionRequested = MAKEWORD( ,  );    // 请求2.2版本的WinSock库
     int err = WSAStartup( wVersionRequested, &wsaData );
     if ( err !=  )
     {
         return -;  // 返回值为零的时候是表示成功申请WSAStartup
     }
     if ( LOBYTE( wsaData.wVersion ) !=  ||    HIBYTE( wsaData.wVersion ) !=  )   // 检测是否2.2版本的socket库
     {
         WSACleanup( );
         return -;
     }

     // 创建socket操作，建立流式套接字，返回套接字号sockSrv
     SOCKET sockSrv = socket(AF_INET, SOCK_STREAM, );

     // 套接字sockSrv与本地地址相连
     SOCKADDR_IN addrSrv;
     addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY); // 将INADDR_ANY转换为网络字节序，调用 htonl(long型)或htons(整型)
     addrSrv.sin_family = AF_INET;
     addrSrv.sin_port = htons();

     // 绑定套接字
     if(SOCKET_ERROR == bind(sockSrv, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR)))
     {
         return -;
     }

     // 将套接字设置为监听模式（连接请求），listen()通知TCP服务器准备好接收连接，最大连接数为20
     listen(sockSrv, );

     cout << "服务器已成功就绪，若服务器想发送信息给客户端，可直接输入内容后按回车.\n";

     // 设置信号量的值
     bufferMutex = CreateSemaphore(NULL, , , NULL);

     // 建立一个向所有客户端发送信息的线程
     HANDLE sendThread = CreateThread(NULL, , SendMessageThread, NULL, , NULL);

     while(true)// 不断等待客户端请求的到来
     {
         sockConn = accept(sockSrv, NULL, NULL);
         if (SOCKET_ERROR != sockConn)
         {
             clientSocketGroup.push_back(sockConn);  //若连接成功则将客户端套接字加入clientSocketGroup
         }

         // 建立一个接收指定客户端信息的线程
         HANDLE receiveThread = CreateThread(NULL, , ReceiveMessageThread, (LPVOID)sockConn, , NULL);

         WaitForSingleObject(bufferMutex, INFINITE);        // P操作（资源未被占用则使用资源）
         if(NULL == receiveThread)
         {
             cout << "CreatThread AnswerThread() failed." << endl;
         }
         else
         {
             cout << "Create Receive Client Thread OK." << endl;
         }
         ReleaseSemaphore(bufferMutex, , NULL);        // V操作（资源占用完毕将其释放）
     }

     WaitForSingleObject(sendThread, INFINITE);  // 等待线程结束
     CloseHandle(sendThread);
     CloseHandle(bufferMutex);
     WSACleanup();    // 终止对套接字库的使用
     system("pause");
     return ;
 }

 DWORD WINAPI SendMessageThread(LPVOID IpParameter)
 {
     while()
     {
         string talk;
         getline(cin, talk);
         WaitForSingleObject(bufferMutex, INFINITE);        // P（资源未被占用）

         //若服务器要主动关闭
         if("quit" == talk)
         {
             talk.push_back('\0');
             for(int i = ; i < clientSocketGroup.size(); ++i)
             {
                 send(clientSocketGroup[i], talk.c_str(), talk.size(), );    // 发送信息
             }
             ReleaseSemaphore(bufferMutex, , NULL);        // V（资源占用完毕）
             exit();
         }

         cout << "I Say:(\"quit\"to exit):" << talk << endl;

         for(int i = ; i < clientSocketGroup.size(); ++i)
         {
             send(clientSocketGroup[i], talk.c_str(), talk.size(), );    // 发送信息
         }
         ReleaseSemaphore(bufferMutex, , NULL);        // V（资源占用完毕）
     }
     return ;
 }

 DWORD WINAPI ReceiveMessageThread(LPVOID IpParameter)
 {
     SOCKET ClientSocket=(SOCKET)(LPVOID)IpParameter;
     while()
     {
         char recvBuf[];
         int recv_id = recv(ClientSocket, recvBuf, , );

         WaitForSingleObject(bufferMutex, INFINITE);        // P操作（资源未被占用）

         if(recv_id == -)
         {
             vector<SOCKET>::iterator result = find(clientSocketGroup.begin(), clientSocketGroup.end(), ClientSocket);
             clientSocketGroup.erase(result);
             closesocket(ClientSocket);
             ReleaseSemaphore(bufferMutex, , NULL);        // V操作（资源占用完毕）
             cout << "Attention: A Client accidentally dropped ..." << endl;
             break;
         }

         //若从客户端收到了"quit"命令则将该客户端套接字从clientSocketGroup中清除并关闭
         if (recvBuf[] == 'q' && recvBuf[] == 'u' && recvBuf[] == 'i' && recvBuf[] == 't' && recvBuf[] == '\0')
         {
             vector<SOCKET>::iterator result = find(clientSocketGroup.begin(), clientSocketGroup.end(), ClientSocket);
             clientSocketGroup.erase(result);
             closesocket(ClientSocket);
             ReleaseSemaphore(bufferMutex, , NULL);        // V操作（资源占用完毕）
             cout << "Attention: A Client has left ..." << endl;
             break;
         }

         cout << "One Client Says: " << recvBuf << endl;     // 接收信息

         ReleaseSemaphore(bufferMutex, , NULL);        // V（资源占用完毕）
     }
     return ;
 }

Client程序：

 // MulClientMain.cpp

 #include <iostream>
 #include <cstdio>
 #include <string>
 #include <cstring>
 #include <winsock2.h>
 #include <Windows.h>

 using namespace std;

 SOCKET sockClient;        // 连接成功后的套接字
 HANDLE bufferMutex;        // 令其能互斥成功正常通信的信号量句柄

 DWORD WINAPI SendMessageThread(LPVOID IpParameter);
 DWORD WINAPI ReceiveMessageThread(LPVOID IpParameter);

 int main()
 {
     // 加载socket动态链接库(dll)
     WORD wVersionRequested;
     WSADATA wsaData;    // 这结构是用于接收Wjndows Socket的结构信息的
     wVersionRequested = MAKEWORD( ,  );   // 请求2.2版本的WinSock库
     int err = WSAStartup( wVersionRequested, &wsaData );
     if ( err !=  ) // 返回值为零的时候是表示成功申请WSAStartup
     {
         return -;
     }
     if ( LOBYTE( wsaData.wVersion ) !=  ||    HIBYTE( wsaData.wVersion ) !=  )   // 检查版本号是否正确
     {
         WSACleanup( );
         return -;
     }

     // 创建socket操作，建立流式套接字，返回套接字号sockClient
     sockClient = socket(AF_INET, SOCK_STREAM, );
     if(sockClient == INVALID_SOCKET)
     {
         cout << "Error at socket(): " << WSAGetLastError() << endl;
         WSACleanup();
         return -;
     }

     SOCKADDR_IN addrSrv;
     addrSrv.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");        // 本地回路地址是127.0.0.1;
     addrSrv.sin_family = AF_INET;
     addrSrv.sin_port = htons();

     // 将套接字sockClient与远程主机相连
     // int connect( SOCKET s,  const struct sockaddr* name,  int namelen);
     // 第一个参数：需要进行连接操作的套接字
     // 第二个参数：设定所需要连接的地址信息
     // 第三个参数：地址的长度
     int con_id = connect(sockClient, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR));
     if(con_id == -)
     {
         cout << "Error at connect(): " << WSAGetLastError() << endl;
         WSACleanup();
         return -;
     }

     cout << "本客户端已准备就绪，用户可直接输入文字向服务器反馈信息。\n";

     bufferMutex = CreateSemaphore(NULL, , , NULL);

     //创建发送信息与接收信息的线程
     HANDLE sendThread = CreateThread(NULL, , SendMessageThread, NULL, , NULL);
     HANDLE receiveThread = CreateThread(NULL, , ReceiveMessageThread, NULL, , NULL);

     WaitForSingleObject(sendThread, INFINITE);  // 等待线程结束

     closesocket(sockClient);
     CloseHandle(sendThread);
     CloseHandle(receiveThread);
     CloseHandle(bufferMutex);
     WSACleanup();    // 终止对套接字库的使用

     cout << "End linking..." << endl;
     system("pause");
     return ;
 }

 DWORD WINAPI SendMessageThread(LPVOID IpParameter)
 {
     while()
     {
         string talk;
         getline(cin, talk);
         WaitForSingleObject(bufferMutex, INFINITE);        // P（资源未被占用）
         if("quit" == talk)
         {
             talk.push_back('\0');
             send(sockClient, talk.c_str(), talk.size(), );
             break;
         }

         cout << "I Say:(\"quit\"to exit):" << talk << endl;
         send(sockClient, talk.c_str(), talk.size(), );    // 发送信息
         ReleaseSemaphore(bufferMutex, , NULL);        // V（资源占用完毕）
     }
     return ;
 }

 DWORD WINAPI ReceiveMessageThread(LPVOID IpParameter)
 {
     while()
     {
         char recvBuf[];
         recv(sockClient, recvBuf, , );
         WaitForSingleObject(bufferMutex, INFINITE);        // P操作（资源未被占用）
         if (recvBuf[] == 'q' && recvBuf[] == 'u' && recvBuf[] == 'i' && recvBuf[] == 't' && recvBuf[] == '\0')
         {
             closesocket(sockClient);
             ReleaseSemaphore(bufferMutex, , NULL);        // V操作（资源占用完毕）
             cout << "Server has been closed ..." << endl;
             exit(-);
         }
         cout << "Server Says: " << recvBuf << endl;     // 接收信息
         ReleaseSemaphore(bufferMutex, , NULL);        // V操作（资源占用完毕）
     }
     return ;
 }