Windows socket之最简单的socket程序

2022-05-02 00:15:18

原文:Windows socket之最简单的socket程序

最简单的服务器的socket程序流程如下(面向连接的TCP连接 ):

1. WSAStartup(); 初始化网络库的使用。

2. socket(); 获得一个socket。

3. bind(); 把获得的socket绑定到一个ip 和端口。既然作为服务器, ip通常为本地IP127.0.0.1。

4. listen(); 监听已经绑定了指定端口的socket。

5. accept(); 接受一个来自客户端的连接。

accept()返回一个新的socket,该socket代表着本地服务器与某一个连接过来的客户端的链接。以该socket为参数，可以调用send函数往客户端发送数据，也可以调用recv函数接受客户端发送过来的函数。

最后服务器程序结束的时候调用closesocket()关闭socket, WSACleanup()终止网络库的使用，清理资源。

最简单的客户端的socket程序流程如下(同样是面向连接的TCP连接):

1. WSAStartup();初始化网络库的使用。

2. socket(); 获得一个socket。

3. connect(); 连接到一个服务器。

连接成功后就可以收发数据了。收发完毕后调用closesocket()关闭socket,最后程序结束前调用 WSACleanup()清理资源。

下面直接上代码

需包含以下头文件和定义

#include <stdlib.h>

#include <stdio.h>

#include <WinSock2.h>

#pragma comment(lib,"ws2_32.lib")

#define SERVE_ADDRESS "127.0.0.1"

#define SERVE_PORT 7001

	// ----------------------------       WSAStartup()         ----------------------------//

	WSADATA wsd;

	int resStartup = WSAStartup(MAKEWORD(2,2),&wsd);

	if(0 != resStartup)

	{

		printf("failed to WSAStartup!\n");

		goto Main_End;

	}

	//------------------------------------------------------------------------------//

	// ----------------------------         socket()         ----------------------------//

	SOCKET serverSocket = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);

	if(INVALID_SOCKET == serverSocket)

	{

		printf("failed to invoke socket, the socket returned is invalid!\n");

		goto Main_End;

	}

	// ------------------------------------------------------------------------------------//

	//----------------------------           bind()          ----------------------------//

	// 初始化 struct sockaddr 结构体， SOCKADDR_IN就是 struct sockaddr的宏定义

	SOCKADDR_IN localAddr;

	localAddr.sin_family = AF_INET;

	localAddr.sin_addr.S_un.S_addr = inet_addr(SERVE_ADDRESS);

	localAddr.sin_port = htons(SERVE_PORT);

	memset(localAddr.sin_zero,0x0,sizeof(localAddr.sin_zero));

	//

	int resBind = bind(serverSocket,(sockaddr*)&localAddr,sizeof(SOCKADDR_IN));

	if(0 != resBind)

	{

		printf("failed to bind ! \n");

		goto Main_End;

	}

	//------------------------------------------------------------------------------------//

	//----------------------------          listen()         ----------------------------//

	int resListen = listen(serverSocket,5);

	if(0 != resListen)

	{

		printf("failed to listen! \n");

		goto Main_End;

	}

	printf("the server is listening now!\n");

	//------------------------------------------------------------------------------------//

	//----------------------------        accept()         ----------------------------//

	SOCKADDR_IN clientAddr;

	int addrLen = sizeof(clientAddr);

	SOCKET acceptedSocket = accept(serverSocket,(sockaddr*)&clientAddr,&addrLen);

	if(INVALID_SOCKET == acceptedSocket)

	{

		printf("accept error!\n");

		goto Main_End;

	}

	printf("a client has connected to the server!\n");

	//------------------------------------------------------------------------------------//

	char recvBuffer[256];

	char sendBuffer[256];

	strcpy(sendBuffer,"server:Welcome to connect !");

	int sendBufLen = strlen(sendBuffer);

	int resSend = send(acceptedSocket,sendBuffer,sendBufLen,0);

	while(true)

	{

		if(resSend != sendBufLen)	//发送的长度与需要发送的长度不等

		{

			printf("send data error!!\n");

			break;

		}

		int recvLen = recv(acceptedSocket,recvBuffer,sizeof(recvBuffer),0);

		if(0 == recvLen)

		{

			printf("a client close the socket!\n");

			break;

		}

		else if(recvLen < 0)

		{

			printf("an error has happen when receiving\n");

			break;

		}

		recvBuffer[recvLen] = '\0';

		printf("client:%s\n",recvBuffer);

		//在客户发过来的数据前面加上server:再发回给客户端

		strcpy(sendBuffer,"server:");

		strcat(sendBuffer,recvBuffer);

		sendBufLen = strlen(sendBuffer);

		resSend = send(acceptedSocket,sendBuffer,sendBufLen,0);

	}

	closesocket(acceptedSocket);

	closesocket(serverSocket);

 Main_End:

	WSACleanup();

	system("pause");

	return 0;

客户端代码：

	//----------------------------       WSAStartup()        ----------------------------//

	WSADATA wsd;

	int resStartup = WSAStartup(MAKEWORD(2,2),&wsd);

	if(0 != resStartup)

	{

		printf("failed to WSAStartup!\n");

		goto Main_End;

	}

	//------------------------------------------------------------------------------------//

	//----------------------------       socket()           ----------------------------//

	SOCKET connSocket = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);

	if(INVALID_SOCKET == connSocket)

	{

		printf("the socket returned is invalid!\n");

		goto Main_End;

	}

	//------------------------------------------------------------------------------------//

	//----------------------------       connect()         ----------------------------//

	//初始化struct sockaddr 结构体

	SOCKADDR_IN serverAddr;

	serverAddr.sin_family = AF_INET;

	serverAddr.sin_addr.S_un.S_addr = inet_addr(SERVE_ADDRESS);

	serverAddr.sin_port = htons(SERVE_PORT);

	memset(serverAddr.sin_zero,0x0,sizeof(serverAddr.sin_zero));

	//connect

	int resConn = connect(connSocket,(sockaddr*)&serverAddr,sizeof(serverAddr));

	if(0 != resConn)

	{

		printf("failed to connect to server!!\n");

		goto Main_End;

	}

	//------------------------------------------------------------------------------------//

	char sendBuffer[256];

	char recvBuffer[256];

	while(true)

	{

		int recvLen = recv(connSocket,recvBuffer,256,0);

		if(recvLen < 0)

		{

			printf("receive error!!\n");

			break;

		}

		else if(0 == recvLen)

		{

			printf("the server close the socket!\n");

		}

		recvBuffer[recvLen] = '\0';

		printf("the data recv:%s\n\n\n",recvBuffer);

		printf("please input what you want to send:\n");

		gets(sendBuffer);

		if(0 == strcmp(sendBuffer,"exit"))

		{

			break;

		}

		int sendDataLen = strlen(sendBuffer);

		int nDataSent = send(connSocket,sendBuffer,sendDataLen,0);

		if(nDataSent != sendDataLen)

		{

			printf("failed to send data!!\n");

			break;

		}

	}

	closesocket(connSocket);

	printf("the connection is closed!\n");

 Main_End:

	WSACleanup();

	system("pause");

	return 0;

客户端连接到服务端后，每次给服务端发送一段内容，服务器在内容前面加上server:再发送给客户端。

当客户端发送的内容是exit时，客户端程序跳出循环，关闭socket断开连接。服务端发现客户端断开连接后也关闭套接字结束程序。

当然上面程序只为了演示最简单的网络编程。有若干漏洞。

1. 服务器只能接受一个客户端连接。当然加一个循环语句进去可以重复地接受客户端的连接，但是仍然是每次只处理一个客户端连接。

2.accept, connect,send,recv函数默认均是阻塞函数。当没有客户连接到服务端时，服务端阻塞在accept函数，无法退出程序。当服务器在接受客户端的数据时，如果客户端不发送数据，也不断开连接，那么服务端阻塞在recv函数，无法退出程序。

改进该程序，使得服务端随时都可以停止服务退出程序，无论有多少个用户已经在连接。

为了多个客户端可以同时连接，最容易理解的便是利用多线程。每一个连接的客户端都用一个线程去处理它的通信。

至于为了随时可以退出服务端，不能再调用永久阻塞的函数了。利用select函数，可以阻塞指定的时间，阻塞期间不占CPU。

int select( __in int nfds, __in_out fd_set*readfds, __in_out fd_set*writefds, __in_out fd_set*exceptfds,
__in const struct timeval*timeout);

nfds

用于兼容Berkeley sockets.不用理会，随便给个0值就OK。

readfds

用于检查是否存在可读socket的的一个socket集合。可为空。

writefds

用于检查是否存在可写socket的一个socket集合。可为空。

exceptfds

用于检查是否存在有错误的socket的一个 socket集合，可为空。

timeout

TIMEVAL结构体，用于指定该函数阻塞多长时间。

在调用select时，当readfds不为空时，当readfds中任何一个socket就绪可读时，或者当writefds不为空且writefds中任何一个socket准备就绪可写，或者当exceptfds不为空且任何一个socket发生socket错误时，select就立即返回。否则，直到timeout指定的时间过去以后才返回。

返回值，返回准备就绪的socket的个数。如果为0，说明该函数超时了，如果大于0，说明至少有一个socket就绪。如果小于0，说明发生错误了。

fd_set 是一种集合类型。

typedef struct fd_set {

u_int fd_count; /* how many are SET? */

SOCKET fd_array[FD_SETSIZE]; /* an array of SOCKETs */

} fd_set;

记录着一个socket数组，以及里面的socket个数。

struct timeval是一个表示等待时间的结构体。

struct timeval {

long tv_sec; /* seconds */

long tv_usec; /* and microseconds */

};

tv_sec表示有多少秒，tv_usec表示有多少毫秒。

对于fd_set类型，用到几个宏定义函数。

FD_ZERO(fd_set*), 清空fd_set集合

FD_SET(SOCKET,fd_set*),把socket加入fd_set集合。

FD_ISSET(SOCKET,fd_set*),判断socket是否在集合fd_set中，并且socket准备就绪。

FD_CLR(SOCKET,fd_set*),如果fd_set存在该SOCKET，则移除它。

下面是改进后的服务端代码

typedef struct _ThreadInfo

{

	HANDLE hThread;

	bool bRunning;

	SOCKET sock;

}ThreadInfo;

typedef struct _AcceptThreadParam

{

	bool bRunning;

	SOCKET listeningSocket;

}AcceptThreadParam;

std::list<ThreadInfo*> g_threadInfoList;

CRITICAL_SECTION g_csForList;

DWORD WINAPI ListeningThread(LPVOID lpParameter);

DWORD WINAPI CommunicationThread(LPVOID lpParameter);

int _tmain(int argc, _TCHAR* argv[])

{

	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);

	// ----------------------------       WSAStartup()         ----------------------------//

	WSADATA wsd;

	int resStartup = WSAStartup(MAKEWORD(2,2),&wsd);

	if(0 != resStartup)

	{

		printf("failed to WSAStartup!\n");

		return -1;

	}

	//------------------------------------------------------------------------------//

	InitializeCriticalSection(&g_csForList);

	// ----------------------------         socket()         ----------------------------//

	SOCKET serverSocket = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);

	if(INVALID_SOCKET == serverSocket)

	{

		printf("failed to invoke socket, the socket returned is invalid!\n");

		goto Main_End;

	}

	// ------------------------------------------------------------------------------------//

	//----------------------------           bind()          ----------------------------//

	// 初始化 struct sockaddr 结构体， SOCKADDR_IN就是 struct sockaddr的宏定义

	SOCKADDR_IN localAddr;

	localAddr.sin_family = AF_INET;

	localAddr.sin_addr.S_un.S_addr = inet_addr(SERVE_ADDRESS);

	localAddr.sin_port = htons(SERVE_PORT);

	memset(localAddr.sin_zero,0x0,sizeof(localAddr.sin_zero));

	//

	int resBind = bind(serverSocket,(sockaddr*)&localAddr,sizeof(SOCKADDR_IN));

	if(0 != resBind)

	{

		printf("failed to bind ! \n");

		goto Main_End;

	}

	//------------------------------------------------------------------------------------//

	//----------------------------          listen()         ----------------------------//

	int resListen = listen(serverSocket,5);

	if(0 != resListen)

	{

		printf("failed to listen! \n");

		goto Main_End;

	}

	//------------------------------------------------------------------------------------//

	AcceptThreadParam threadParam;

	threadParam.bRunning = true;

	threadParam.listeningSocket = serverSocket;

	HANDLE hListeningThread = CreateThread(0,0,ListeningThread,&threadParam,0,0);

	if(0 == hListeningThread)

	{

		printf("failed to create the listening thread!\n");

		goto Main_End;

	}

	else

	{

		printf("the server is listening now!pass any key to close the server!\n");

	}

	while(true)

	{

		char ch = getchar();

		threadParam.bRunning = false;

		DWORD resWait = WaitForSingleObject(hListeningThread,3000);

		if(WAIT_TIMEOUT == resWait)

		{

			printf("failed to wait for the listening thread exiting!\n");

		}

		else

		{

			printf("the listening thread has exited!\n");

		}

		break;

	}

Main_End:

	if(INVALID_SOCKET != serverSocket)

	{

		closesocket(serverSocket);

		serverSocket = INVALID_SOCKET;

	}

	WSACleanup();

	DeleteCriticalSection(&g_csForList);

	system("pause");

	return 0;

}

DWORD WINAPI ListeningThread(LPVOID lpParameter)

{

	AcceptThreadParam* pAcceptThreadParam = (AcceptThreadParam*)lpParameter;

	SOCKET serverSocket = pAcceptThreadParam->listeningSocket;

	while(pAcceptThreadParam->bRunning)

	{

		//----------------------------        accept()         ----------------------------//

		fd_set fdAccept;

		FD_ZERO(&fdAccept);

		FD_SET(serverSocket,&fdAccept);

		TIMEVAL acceptTimeVal;

		acceptTimeVal.tv_sec = 1;

		acceptTimeVal.tv_usec = 0;

		int selRes = select(0,&fdAccept,0,0,&acceptTimeVal);

		if(selRes > 0)

		{

			SOCKADDR_IN clientAddr;

			int addrLen = sizeof(clientAddr);

			SOCKET acceptedSocket = accept(serverSocket,(sockaddr*)&clientAddr,&addrLen);

			if(INVALID_SOCKET == acceptedSocket)

			{

				printf("accept error!\n");

				break;

			}

			printf("a client has connected to the server!\n");

			ThreadInfo* pTI = new ThreadInfo;

			pTI->bRunning = true;

			pTI->sock = acceptedSocket;

			pTI->hThread = CreateThread(0,0,CommunicationThread,(LPVOID)pTI,0,0);

			if(0 == pTI->hThread)

			{

				printf("failed to create a thread!\n");

				delete pTI;

				pTI = 0;

			}

			else

			{

				EnterCriticalSection(&g_csForList);

				g_threadInfoList.push_back(pTI);

				LeaveCriticalSection(&g_csForList);

			}

		}

		else if(selRes < 0)

		{

			printf("an error has occured when listening !\n");

			break;

		}

	}

	std::list<ThreadInfo*> tempList;

	EnterCriticalSection(&g_csForList);

	std::list<ThreadInfo*>::iterator listIter;

	for(listIter = g_threadInfoList.begin(); listIter != g_threadInfoList.end(); listIter++)

	{

		(*listIter)->bRunning = false;

		tempList.push_back(*listIter);

	}

	g_threadInfoList.clear();

	LeaveCriticalSection(&g_csForList);

	int nSuccessfullyExit = 0;

	for(listIter = tempList.begin(); listIter != tempList.end(); listIter++)

	{

		DWORD resWait = WaitForSingleObject((*listIter)->hThread,2000);

		if(WAIT_TIMEOUT == resWait)

		{

			printf("failed to wait for a communication thread exiting!\n");

		}

		else

		{

			nSuccessfullyExit++;

		}

		delete (*listIter);

	}

	printf("succeed waiting for %d thread exiting!\n",nSuccessfullyExit);

	tempList.clear();

	printf("listening thread is exiting!\n");

	return 0;

}

DWORD WINAPI CommunicationThread(LPVOID lpParameter)

{

	ThreadInfo* pThreadInfo = (ThreadInfo*)lpParameter;

	SOCKET clientSocket = pThreadInfo->sock;

	fd_set fdRead,fdWrite;

	FD_ZERO(&fdRead);

	FD_ZERO(&fdWrite);

	FD_SET(clientSocket,&fdRead);

	FD_SET(clientSocket,&fdWrite);

	TIMEVAL sendTimeVal;

	sendTimeVal.tv_sec = 0;

	sendTimeVal.tv_usec = 500;

	int selRes = select(0,0,&fdWrite,0,&sendTimeVal);

	if(selRes <= 0)

	{

		goto ThreadOver;

	}

	char recvBuffer[256];

	char sendBuffer[256];

	strcpy(sendBuffer,"server:Welcome to connect !");

	int sendBufLen = strlen(sendBuffer);

	int resSend = send(clientSocket,sendBuffer,sendBufLen,0);

	if(resSend != sendBufLen)

	{

		printf("there are %d bytes to send, but it just succeeded sending %d bytes!\n",sendBufLen,resSend);

		goto ThreadOver;

	}

	while(pThreadInfo->bRunning)

	{

		FD_ZERO(&fdRead);

		FD_SET(pThreadInfo->sock,&fdRead);

		TIMEVAL recvTimeVal;

		recvTimeVal.tv_sec = 0;

		recvTimeVal.tv_usec = 500;

		int recvSelRes = select(0,&fdRead,0,0,&recvTimeVal);

		if(recvSelRes < 0)

		{

			printf("socket error when receiving!\n");

			break;

		}

		else if(recvSelRes > 0)

		{

			int recvLen = recv(clientSocket,recvBuffer,sizeof(recvBuffer),0);

			if(0 == recvLen)

			{

				printf("a client close the socket!\n");

				break;

			}

			else if(recvLen < 0)

			{

				printf("an error has happen when recving\n");

				break;

			}

			else

			{

				recvBuffer[recvLen] = '\0';

				printf("a client:%s\n",recvBuffer);

				strcpy(sendBuffer,"server:");

				strcat(sendBuffer,recvBuffer);

				sendBufLen = strlen(sendBuffer);

				FD_ZERO(&fdWrite);

				FD_SET(pThreadInfo->sock,&fdWrite);

				sendTimeVal.tv_sec = 0;

				sendTimeVal.tv_usec = 500;

				int sendSelRes = select(0,0,&fdWrite,0,&sendTimeVal);

				if(sendSelRes > 0)

				{

					int bytesSent = send(clientSocket,sendBuffer,sendBufLen,0);

					if(bytesSent != sendBufLen)

					{

						printf("there are %d bytes to be sent,but only %d bytes are sent!\n",sendBufLen,bytesSent);

						break;

					}

				}

				else

				{

					printf("failed to send in 500 ms!\n");

					break;

				}

			}

		}

	}

ThreadOver:

	closesocket(pThreadInfo->sock);

	bool bMainThreadWaiting = true;

	EnterCriticalSection(&g_csForList);

	std::list<ThreadInfo*>::iterator listIter;

	for(listIter = g_threadInfoList.begin(); listIter != g_threadInfoList.end(); listIter++)

	{

		if(pThreadInfo == (*listIter))

		{

			bMainThreadWaiting = false;

			g_threadInfoList.erase(listIter);

			break;

		}

	}

	LeaveCriticalSection(&g_csForList);

	if(false == bMainThreadWaiting)

	{

		CloseHandle(pThreadInfo->hThread);

		delete pThreadInfo;

		pThreadInfo = 0;

	}

	return 0;

}

前面的代码与之前的一样，改变的地方在于accept的地方。对于一个监听的socket,如果该socket可读，说明有用户连接过来了。

全局维护了一个纪录创建的线程的信息的链表，每创建一个线程都有一个标识该线程是否应该继续循环执行的bool变量。当bRunning变为false的时候，线程函数跳出循环，返回。

当需要停止服务端运行时，服务端只需要按任何一个键和回车，就会通知线程退出，并且调用WaitForSingleObject(),来确认线程已退出。还有利用了 EnterCriticalSection()和LeaveCriticalSection()临界区函数来保证只有一个线程在操作全局的链表。

使用多线程要消耗一定的资源。对于fd_set，默认最多可以容纳64个socket.所以可以用1个线程去处理64个客户端的连接。而不必每个客户端都创建一个线程。

代码如下：

typedef struct _AcceptThreadParam

{

	bool bRunning;

	SOCKET listeningSocket;

}AcceptThreadParam;

#define SOCKET_ARRAY_SIZE 64

SOCKET g_socketArray[SOCKET_ARRAY_SIZE];

int g_socketCount = 0;

CRITICAL_SECTION g_csForSocketArray;

DWORD WINAPI ListeningThread(LPVOID lpParameter);

DWORD WINAPI CommunicationThread(LPVOID lpParameter);

int _tmain(int argc, _TCHAR* argv[])

{

	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);

	// ----------------------------       WSAStartup()         ----------------------------//

	WSADATA wsd;

	int resStartup = WSAStartup(MAKEWORD(2,2),&wsd);

	if(0 != resStartup)

	{

		printf("failed to WSAStartup!\n");

		return -1;

	}

	//------------------------------------------------------------------------------//

	InitializeCriticalSection(&g_csForSocketArray);

	g_socketCount = 0;

	// ----------------------------         socket()         ----------------------------//

	SOCKET serverSocket = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);

	if(INVALID_SOCKET == serverSocket)

	{

		printf("failed to invoke socket, the socket returned is invalid!\n");

		goto Main_End;

	}

	// ------------------------------------------------------------------------------------//

	//----------------------------           bind()          ----------------------------//

	// 初始化 struct sockaddr 结构体， SOCKADDR_IN就是 struct sockaddr的宏定义

	SOCKADDR_IN localAddr;

	localAddr.sin_family = AF_INET;

	localAddr.sin_addr.S_un.S_addr = inet_addr(SERVE_ADDRESS);

	localAddr.sin_port = htons(SERVE_PORT);

	memset(localAddr.sin_zero,0x0,sizeof(localAddr.sin_zero));

	//

	int resBind = bind(serverSocket,(sockaddr*)&localAddr,sizeof(SOCKADDR_IN));

	if(0 != resBind)

	{

		printf("failed to bind ! \n");

		goto Main_End;

	}

	//------------------------------------------------------------------------------------//

	//----------------------------          listen()         ----------------------------//

	int resListen = listen(serverSocket,5);

	if(0 != resListen)

	{

		printf("failed to listen! \n");

		goto Main_End;

	}

	//------------------------------------------------------------------------------------//

	AcceptThreadParam threadParam;

	threadParam.bRunning = true;

	threadParam.listeningSocket = serverSocket;

	bool bCommunicationThreadRunning = true;

	HANDLE hListeningThread = CreateThread(0,0,ListeningThread,&threadParam,0,0);

	HANDLE hCommunicationThread = CreateThread(0,0,CommunicationThread,&bCommunicationThreadRunning,0,0);

	if(0 == hListeningThread || 0 == hCommunicationThread)

	{

		printf("failed to create a thread!\n");

		if(0 != hListeningThread)

		{

			threadParam.bRunning = false;

			WaitForSingleObject(hListeningThread,2000);

			CloseHandle(hListeningThread);

		}

		if(0 != hCommunicationThread)

		{

			bCommunicationThreadRunning = false;

			WaitForSingleObject(hCommunicationThread,2000);

			CloseHandle(hCommunicationThread);

		}

		goto Main_End;

	}

	else

	{

		printf("the server is listening now!pass any key to close the server!\n");

	}

	while(true)

	{

		char ch = getchar();

		threadParam.bRunning = false;

		bCommunicationThreadRunning = false;

		DWORD resWait = WaitForSingleObject(hListeningThread,3000);

		if(WAIT_TIMEOUT == resWait)

		{

			printf("failed to wait for the listening thread exiting!\n");

		}

		else

		{

			printf("the listening thread has exited!\n");

		}

		CloseHandle(hListeningThread);

		resWait = WaitForSingleObject(hCommunicationThread,3000);

		if(WAIT_TIMEOUT == resWait)

		{

			printf("failed to wait for the communication thread exiting!\n");

		}

		else

		{

			printf("the communication thread has exited!\n");

		}

		CloseHandle(hCommunicationThread);

		break;

	}

Main_End:

	if(INVALID_SOCKET != serverSocket)

	{

		closesocket(serverSocket);

		serverSocket = INVALID_SOCKET;

	}

	WSACleanup();

	DeleteCriticalSection(&g_csForSocketArray);

	system("pause");

	return 0;

}

DWORD WINAPI ListeningThread(LPVOID lpParameter)

{

	AcceptThreadParam* pAcceptThreadParam = (AcceptThreadParam*)lpParameter;

	SOCKET serverSocket = pAcceptThreadParam->listeningSocket;

	while(pAcceptThreadParam->bRunning)

	{

		//----------------------------        accept()         ----------------------------//

		fd_set fdAccept;

		FD_ZERO(&fdAccept);

		FD_SET(serverSocket,&fdAccept);

		TIMEVAL acceptTimeVal;

		acceptTimeVal.tv_sec = 1;

		acceptTimeVal.tv_usec = 0;

		int selRes = select(0,&fdAccept,0,0,&acceptTimeVal);

		if(selRes > 0)

		{

			SOCKADDR_IN clientAddr;

			int addrLen = sizeof(clientAddr);

			SOCKET acceptedSocket = accept(serverSocket,(sockaddr*)&clientAddr,&addrLen);

			if(INVALID_SOCKET == acceptedSocket)

			{

				printf("accept error!\n");

				break;

			}

			printf("a client has connected to the server!\n");

			fd_set fdWrite;

			FD_ZERO(&fdWrite);

			FD_SET(acceptedSocket,&fdWrite);

			TIMEVAL writeTimeVal;

			writeTimeVal.tv_sec = 0;

			writeTimeVal.tv_usec = 500;

			int writeSelRes = select(0,0,&fdWrite,0,&writeTimeVal);

			if(writeSelRes > 0)

			{

				int sendBufferLen = strlen("server:Welcome to connect!");

				int bytesSent = send(acceptedSocket,"server:Welcome to connect!",sendBufferLen,0);

				if(bytesSent == sendBufferLen)

				{

					EnterCriticalSection(&g_csForSocketArray);

					if(g_socketCount < 64)

					{

						g_socketArray[g_socketCount] = acceptedSocket;

						g_socketCount++;

					}

					else

					{

						printf("the server has accepted more than 64 clients!\n");

						closesocket(acceptedSocket);

					}

					LeaveCriticalSection(&g_csForSocketArray);

				}

				else

				{

					printf("send error, there are %d bytes to be sent, but only %d bytes are sent!\n",sendBufferLen,bytesSent);

					closesocket(acceptedSocket);

				}

			}

			else

			{

				printf("select error of can not wait for sending data when select!\n");

				closesocket(acceptedSocket);

			}

		}

		else if(selRes < 0)

		{

			printf("an error has occured when listening !\n");

			break;

		}

	}

	printf("listening thread is exiting!\n");

	return 0;

}

DWORD WINAPI CommunicationThread(LPVOID lpParameter)

{

	bool* pBRunning = (bool*)lpParameter;

	char recvBuffer[256];

	char tempBuffer[256];

	while(true == *pBRunning)

	{

		int currentSocketCount = 0;

		EnterCriticalSection(&g_csForSocketArray);

		if(0 == g_socketCount)

		{

			LeaveCriticalSection(&g_csForSocketArray);

			Sleep(200);

			continue;

		}

		currentSocketCount = g_socketCount;

		LeaveCriticalSection(&g_csForSocketArray);

		fd_set fdRead;

		FD_ZERO(&fdRead);

		for(int i = 0; i < currentSocketCount; i++)

		{

			FD_SET(g_socketArray[i],&fdRead);

		}

		TIMEVAL readTimeVal;

		readTimeVal.tv_sec = 1;

		readTimeVal.tv_usec = 0;

		int selRes = select(0,&fdRead,0,0,&readTimeVal);

		if(selRes > 0)

		{

			for(int i = 0; i < currentSocketCount; i++)

			{

				if(FD_ISSET(g_socketArray[i],&fdRead) != 0)

				{

					int bytesRecv = recv(g_socketArray[i],recvBuffer,sizeof(recvBuffer),0);

					if(bytesRecv > 0)

					{

						recvBuffer[bytesRecv] = '\0';

						printf("the %d client: %s\n",i + 1,recvBuffer);

						sprintf(tempBuffer,"the server:%s",recvBuffer);

						fd_set fdWrite;

						FD_ZERO(&fdWrite);

						FD_SET(g_socketArray[i],&fdWrite);

						TIMEVAL writeTimeVal;

						writeTimeVal.tv_sec = 0;

						writeTimeVal.tv_usec = 500;

						int writeSelRes = select(g_socketArray[i],0,&fdWrite,0,&writeTimeVal);

						if(writeSelRes > 0)

						{

							int sendBufLen = strlen(tempBuffer);

							int bytesSent = send(g_socketArray[i],tempBuffer,sendBufLen,0);

							if(bytesSent == sendBufLen)

							{

								break;

							}

							else

							{

								printf("there are %d bytes to be sent,but only %d bytes are sent!\n",sendBufLen,bytesSent);

							}

						}

						else

						{

							printf("select error!\n");

						}

					}

					else if(0 == bytesRecv)

					{

						printf("the %d client has closed the socket!\n",i + 1);

					}

					else

					{

						printf("recv error!\n");

					}

					closesocket(g_socketArray[i]);

					EnterCriticalSection(&g_csForSocketArray);

					g_socketArray[i] = g_socketArray[g_socketCount - 1];

					g_socketCount--;

					LeaveCriticalSection(&g_csForSocketArray);

				}

			}

		}

		else if(selRes < 0)

		{

			printf("select error in communication thread!\n");

		}

	}

	EnterCriticalSection(&g_csForSocketArray);

	for(int i = 0; i < g_socketCount; i++)

	{

		closesocket(g_socketArray[i]);

	}

	LeaveCriticalSection(&g_csForSocketArray);

	printf("the communication thread is exiting!\n");

	return 0;

}

完成的功能一样。只需要一个线程就可以处理多个客户端了。

还可以用异步IO来实现该服务器，以下是用完成端口来实现同样功能的服务器。

typedef struct _RepeatAcceptingThreadParam

{

	SOCKET listeningSocket;

	bool* pBRunning;

}RepeatAcceptingThreadParam;

typedef struct _CompletionPortWorkerThreadParam

{

	HANDLE hCompletionPort;

	bool* pBRunning;

}CompletionPortWorkerThreadParam;

#define MESSAGE_BUF_SIZE 1024

enum OPERATION_TYPE

{

	OPERATION_SEND,

	OPERATION_RECV

};

typedef struct

{

	SOCKET sock;

	WSAOVERLAPPED overlap;

	WSABUF wsaBuf;

	char message[1024];

	DWORD bytesRecv;

	DWORD flags;

	OPERATION_TYPE operationType;

}PER_IO_OPERATION_DATA;

//global vector, which saves the information of the client sockets connected to the server

std::vector<PER_IO_OPERATION_DATA*> g_perIoDataPointerVec;

//accept sockets connected to the server's listening socket in a recycle - while

DWORD WINAPI RepeatAcceptingThread(LPVOID lpParameter);	

//the worker thread that deal with the communications between the server and the clients.

DWORD WINAPI CompletionPortWorkerThread(LPVOID lpParameter);

int _tmain(int argc,_TCHAR* argv[])

{

	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);

	// ----------------------------       WSAStartup()         ----------------------------//

	WSADATA wsd;

	int resStartup = WSAStartup(MAKEWORD(2,2),&wsd);

	if(0 != resStartup)

	{

		printf("failed to WSAStartup!\n");

		return -1;

	}

	//------------------------------------------------------------------------------//

	// ----------------------------         socket()         ----------------------------//

	SOCKET serverSocket = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);

	if(INVALID_SOCKET == serverSocket)

	{

		printf("failed to invoke socket, the socket returned is invalid!\n");

		return -1;

	}

	// ------------------------------------------------------------------------------------//

	//----------------------------           bind()          ----------------------------//

	// 初始化 struct sockaddr 结构体， SOCKADDR_IN就是 struct sockaddr的宏定义

	SOCKADDR_IN localAddr;

	localAddr.sin_family = AF_INET;

	localAddr.sin_addr.S_un.S_addr = inet_addr(SERVE_ADDRESS);

	localAddr.sin_port = htons(SERVE_PORT);

	memset(localAddr.sin_zero,0x0,sizeof(localAddr.sin_zero));

	//

	int resBind = bind(serverSocket,(sockaddr*)&localAddr,sizeof(SOCKADDR_IN));

	if(0 != resBind)

	{

		printf("failed to bind ! \n");

		closesocket(serverSocket);

		return -1;

	}

	//------------------------------------------------------------------------------------//

	//----------------------------          listen()         ----------------------------//

	int resListen = listen(serverSocket,5);

	if(0 != resListen)

	{

		printf("failed to listen! \n");

		closesocket(serverSocket);

		return -1;

	}

	//------------------------------------------------------------------------------------//

	bool bRepeatAcceptingThreadRunning = true;	// a bool variable that take control of terminating the RepeatAcceptingThread.

	//init the parameter for the RepeatAcceptingThread.

	RepeatAcceptingThreadParam rtp;

	rtp.listeningSocket = serverSocket;

	rtp.pBRunning = &bRepeatAcceptingThreadRunning;

	HANDLE hRepeatAcceptingThread = CreateThread(0,0,RepeatAcceptingThread,&rtp,0,0);

	if(0 == hRepeatAcceptingThread)

	{

		printf("failed to create the repeat-accepting thread!\n");

		closesocket(serverSocket);

		return -1;

	}

	printf("the repeat-accepting thread has run!\n");

	while(true)

	{

		// pass any key

		char ch = getchar();

		bRepeatAcceptingThreadRunning = false;//to notify the RepeatAcceptingThread to exit safely 

		DWORD waitRes = WaitForSingleObject(hRepeatAcceptingThread,3000);

		if(WAIT_TIMEOUT == waitRes)

		{

			printf("failed to wait for the repeatAcceptingThread exiting!\n");

		}

		else

		{

			printf("the repeat accepting thread has exited!\n");

		}

		CloseHandle(hRepeatAcceptingThread);

		break;

	}

	system("pause");

	return 0;

}

DWORD WINAPI RepeatAcceptingThread(LPVOID lpParameter)

{

	//get the parameters passed by the creator of the thread.

	RepeatAcceptingThreadParam* pParam = (RepeatAcceptingThreadParam*)lpParameter;

	SOCKET listeningSocket = pParam->listeningSocket;

	bool* pStillRun = pParam->pBRunning;

	// create a completion port

	HANDLE hCompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE,0,0,0);

	if(0 == hCompletionPort)

	{

		printf("failed to CreateIoCompletionPort!\n");

		return -1;

	}

	// a bool variable for notifying the worker threads of exiting.

	bool bWorkThreadRunning = true;

	// a vector of HANDLEs,which will be used for synchronization of waiting the worker threads to exit.

	std::vector<HANDLE> threadHandlesVec;

	SYSTEM_INFO systemInfo;

	GetSystemInfo(&systemInfo);

	//the parameter to be passed to the worker thread.

	CompletionPortWorkerThreadParam cpwtp;

	cpwtp.pBRunning = &bWorkThreadRunning;

	cpwtp.hCompletionPort = hCompletionPort;

	for(int i = 0; i < systemInfo.dwNumberOfProcessors; i++)

	{

		HANDLE hThread = CreateThread(0,0,CompletionPortWorkerThread,&cpwtp,0,0);

		if(0 == hThread)

		{

			printf("failed to create a completion port worker thread!\n");

			bWorkThreadRunning = false;

			// terminate all threads created safely.

			std::vector<HANDLE>::iterator vecIter;

			for(vecIter = threadHandlesVec.begin(); vecIter != threadHandlesVec.end(); vecIter++)

			{

				DWORD waitRes = WaitForSingleObject(*vecIter,2000);

				if(WAIT_TIMEOUT == waitRes)

				{

					printf("failed the wait for the completion port worker thread!\n");

				}

				CloseHandle(*vecIter);

			}

			threadHandlesVec.clear();

			CloseHandle(hCompletionPort);

			return -1;

		}

		else

		{

			threadHandlesVec.push_back(hThread);	//add the handle to the vector

		}

	}

	printf("succeed creating completion port worker threads!\n");

	while(true == *pStillRun)

	{

		fd_set fdAccept;

		FD_ZERO(&fdAccept);

		FD_SET(listeningSocket,&fdAccept);

		TIMEVAL acceptTimeVal;

		acceptTimeVal.tv_sec = 1;

		acceptTimeVal.tv_usec = 0;

		int selRes = select(0,&fdAccept,0,0,&acceptTimeVal);

		if(selRes > 0)	// a client connected

		{

			SOCKADDR_IN clientAddr;

			int addrLen = sizeof(clientAddr);

			SOCKET acceptedSocket = WSAAccept(listeningSocket,(struct sockaddr*)&clientAddr,&addrLen,0,0);

			if(0 == acceptedSocket)

			{

				printf("failed to accept a connection!\n");

			}

			else

			{

				printf("a clent %s:%d has connected!\n",inet_ntoa(clientAddr.sin_addr),ntohs(clientAddr.sin_port));

				PER_IO_OPERATION_DATA* perIoData = new PER_IO_OPERATION_DATA;

				if(0 == perIoData)

				{

					closesocket(acceptedSocket);

					printf("failed to new a struct! there is not enough memory!\n\n");

				}

				else

				{

					//associate the newly connected client socket with the completion port.

					if(0 == CreateIoCompletionPort((HANDLE)acceptedSocket,hCompletionPort,(ULONG_PTR)perIoData,0))

					{

						printf("failed to associate the newly connected client socket with the completion port!\n");

						closesocket(acceptedSocket);

						delete perIoData;

						perIoData = 0;

					}

					else

					{

						//associated successfully, Set the information of the client socket in A PER_IO_OPERATION_DATA struct.

						//when a IO operation is completed, we can get notified with the struct to be one of the parameters.

						perIoData->sock = acceptedSocket;

						perIoData->operationType = OPERATION_SEND;

						perIoData->wsaBuf.buf = perIoData->message;

						perIoData->overlap.hEvent = INVALID_HANDLE_VALUE;

						strcpy(perIoData->message,"Welcome to connect to the server!");

						perIoData->wsaBuf.len = strlen(perIoData->message);

						int sendRes = WSASend(acceptedSocket,&(perIoData->wsaBuf),1,&(perIoData->bytesRecv),0,0,0);

						if(0 == sendRes)	//finished immediately

						{

							// asynchronously invoke a receive operation. When the reception finished,we can get its information by

							// invoking GetQueuedCompletionStatus()

							perIoData->wsaBuf.buf = perIoData->message;

							perIoData->wsaBuf.len = MESSAGE_BUF_SIZE;

							perIoData->flags = 0;

							perIoData->operationType = OPERATION_RECV;

							ZeroMemory(&perIoData->overlap,sizeof(perIoData->overlap));

							int recvRes = WSARecv(acceptedSocket,&perIoData->wsaBuf,1,&perIoData->bytesRecv,&perIoData->flags,&perIoData->overlap,0);

							if(0 == recvRes)	//the receiving operation finished immediately , the information of the operation has been queued.

							{

								g_perIoDataPointerVec.push_back(perIoData);

							}

							else if(SOCKET_ERROR == recvRes && WSA_IO_PENDING == WSAGetLastError())	//the receiving operation will finish later

							{

								g_perIoDataPointerVec.push_back(perIoData);

							}

							else

							{

								printf("failed to WSARecv!\n");

								closesocket(acceptedSocket);

								delete perIoData;

								perIoData = 0;

							}

						}

						else if(SOCKET_ERROR == sendRes && WSA_IO_PENDING == WSAGetLastError())		//the sending operation will finish later

						{

							g_perIoDataPointerVec.push_back(perIoData);

						}

						else

						{

							//int lastErr = WSAGetLastError();

							printf("send data error!\n");

							closesocket(acceptedSocket);

							delete perIoData;

							perIoData = 0;

						}

					}

				}

			}

		}

		else if(selRes < 0)

		{

			printf("select error!\n");

		}

	}

	bWorkThreadRunning = false;	//notifies the worker threads of exiting

	// terminate all threads created safely.

	std::vector<HANDLE>::iterator vecIter;

	for(vecIter = threadHandlesVec.begin(); vecIter != threadHandlesVec.end(); vecIter++)

	{

		DWORD waitRes = WaitForSingleObject(*vecIter,2000);

		if(WAIT_TIMEOUT == waitRes)

		{

			printf("failed the wait for the completion port worker thread!\n");

		}

		CloseHandle(*vecIter);

	}

	threadHandlesVec.clear();

	CloseHandle(hCompletionPort);

	//delete the structs of PER_IO_OPERATION_DATA newed for clients connected.

	std::vector<PER_IO_OPERATION_DATA*>::iterator pIoDataPointerIter;

	for(pIoDataPointerIter = g_perIoDataPointerVec.begin(); pIoDataPointerIter != g_perIoDataPointerVec.end(); pIoDataPointerIter++)

	{

		closesocket((*pIoDataPointerIter)->sock);

		delete (*pIoDataPointerIter);

		*pIoDataPointerIter = 0;

	}

	g_perIoDataPointerVec.clear();

	printf(" the repeat accepting thread is exiting!\n");

	return 0;

}

bool ReleaseIOOperationData(PER_IO_OPERATION_DATA* & pDataToBeDeleted)

{

	bool retVal = false;

	std::vector<PER_IO_OPERATION_DATA*>::iterator vecIter;

	for(vecIter = g_perIoDataPointerVec.begin(); vecIter != g_perIoDataPointerVec.end(); vecIter++)

	{

		if(pDataToBeDeleted == (*vecIter))

		{

			g_perIoDataPointerVec.erase(vecIter);

			closesocket(pDataToBeDeleted->sock);

			delete pDataToBeDeleted;

			pDataToBeDeleted = 0;

			retVal = true;

			break;

		}

	}

	return retVal;

}

DWORD WINAPI CompletionPortWorkerThread(LPVOID lpParameter)

{

	CompletionPortWorkerThreadParam* pParam = (CompletionPortWorkerThreadParam*)lpParameter;

	bool* pStillRun = pParam->pBRunning;

	HANDLE hCompletionPort = pParam->hCompletionPort;

	DWORD dwBytesTransfered;

	PER_IO_OPERATION_DATA* pIoData;

	WSAOVERLAPPED* pOverlap;

	while(true == *pStillRun)

	{

		dwBytesTransfered = 0;

		pIoData = 0;

		pOverlap = 0;

		BOOL bGetStatus = GetQueuedCompletionStatus(hCompletionPort,&dwBytesTransfered,(PULONG_PTR)&pIoData,&pOverlap,500);

		if(FALSE == bGetStatus)

		{

			if(0 == pOverlap)	//did not get a packet from the queue.

			{

				continue;

			}

			else

			{

				//get a packet for a failed I/O operation.

			}

		}

		if(OPERATION_SEND == pIoData->operationType)

		{

			if(0 == dwBytesTransfered)	//a packet for a failed I/O operation.

			{

				printf("the client %d has close the socket!\n",pIoData->sock);

				ReleaseIOOperationData(pIoData);

			}

			else

			{

				// receive operation.

				pIoData->operationType = OPERATION_RECV;

				pIoData->wsaBuf.buf = pIoData->message;

				pIoData->wsaBuf.len = MESSAGE_BUF_SIZE;

				pIoData->flags = 0;

				ZeroMemory(&pIoData->overlap,sizeof(pIoData->overlap));

				int recvRes = WSARecv(pIoData->sock,&pIoData->wsaBuf,1,&pIoData->bytesRecv,&pIoData->flags,&pIoData->overlap,0);

				if(0 != recvRes && WSA_IO_PENDING != WSAGetLastError())

				{

					printf("recv error, may be the client %d has close the socket!\n",pIoData->sock);

					ReleaseIOOperationData(pIoData);

				}

			}

		}

		else if(OPERATION_RECV == pIoData->operationType)

		{

			if(0 == dwBytesTransfered)	//a packet for a failed I/O operation.

			{

				printf("the client %d has close the socket!\n",pIoData->sock);

				ReleaseIOOperationData(pIoData);

			}

			else

			{

				// show the data received

				pIoData->message[dwBytesTransfered] = '\0';

				printf("the client %d:%s \n",pIoData->sock,pIoData->message);

				//send back the data received add a "server:" in the front

				char tempBuf[MESSAGE_BUF_SIZE];

				sprintf(tempBuf,"server:%s",pIoData->message);

				strcpy(pIoData->message,tempBuf);

				pIoData->operationType = OPERATION_SEND;

				pIoData->wsaBuf.buf = pIoData->message;

				pIoData->wsaBuf.len = strlen(pIoData->message);

				int sendRes = WSASend(pIoData->sock,&pIoData->wsaBuf,1,&pIoData->bytesRecv,0,0,0);

				if(0 == sendRes)

				{

					pIoData->operationType = OPERATION_RECV;

					pIoData->wsaBuf.buf = pIoData->message;

					pIoData->wsaBuf.len = MESSAGE_BUF_SIZE;

					pIoData->flags = 0;

					ZeroMemory(&pIoData->overlap,sizeof(pIoData->overlap));

					int recvRes = WSARecv(pIoData->sock,&pIoData->wsaBuf,1,&pIoData->bytesRecv,&pIoData->flags,&pIoData->overlap,0);

					if(0 != recvRes && WSA_IO_PENDING != WSAGetLastError())

					{

						printf("recv error, may be the client %d has close the socket!\n",pIoData->sock);

						ReleaseIOOperationData(pIoData);

					}

				}

				else if(SOCKET_ERROR == sendRes && WSA_IO_PENDING == WSAGetLastError())

				{

				}

				else

				{

					printf("send error, maybe the client %d has close the socket!\n",pIoData->sock);

					ReleaseIOOperationData(pIoData);

				}

			}

		}

	}

	printf("a completion port thread is exiting!\n");

	return 0;

}

码农公寓

相关文章