EXEMPLE DE SERVEUR (MULTI-CLIENTS) TCP (WIN32 / VC++) (11 SEPT 2003 : MAJ)

Network.h

#define SERVERSTAT_STOPPED			0
#define SERVERSTAT_RUNNING			1
#define SERVERSTAT_FATALERR			2

#define SERVERERR_SUCCESS			0
#define SERVERERR_BADCALLPARAM		1
#define SERVERERR_THREAD			2
#define SERVERERR_WS				3

#define MESSTYPE_RECV				1
#define MESSTYPE_NEW				2
#define MESSTYPE_QUIT				3

typedef struct MESSAGE
{
	DWORD ClientID;
	DWORD MessageType;
	void* Data;
	DWORD cbData;
} MESSAGE, *PMESSAGE;

typedef struct MESSAGENODE
{
	PMESSAGE Message;
	MESSAGENODE* pNext;
} MESSAGENODE, *PMESSAGENODE;

typedef struct CLIENT
{
	DWORD ClientID;
	HANDLE Event;
	SOCKET Sock;
} CLIENT, *PCLIENT;

typedef struct CLIENTNODE
{
	PCLIENT pClient;
	CLIENTNODE* pNext;
} CLIENTNODE, *PCLIENTNODE;

typedef class CNetServer
{
public:

	CNetServer(HANDLE hEventNewMess = NULL);
	~CNetServer(void);

	void SetNewMessEvent(HANDLE hEvent = NULL) {hNewMess = hEvent;}
	
	DWORD Start(WORD wServerPort, DWORD dwMaxConnec = 0, BOOL ResetMessQueue = TRUE);
	DWORD Stop(BOOL DelMessQueue = FALSE);

	PMESSAGE GetServerMessage(void); // resultat a détruire avec delete
	BOOL Send(void* Data, DWORD cbData, DWORD ClientID = 0); // 0 pour tous
	BOOL Kick(DWORD ClientID = 0); // 0 pour tous, utilisé a la fermeture du serveur

	WORD GetServerPort(void);
	DWORD GetStatus(void);
	DWORD GetMaxConnec(void);
	void SetMaxConnec(DWORD dwMaxConnec = 0); // 0 pour aucune limite

	void setoptDelClientMessOnPart(BOOL opt);
	BOOL getoptDelClientMessOnPart();
	void setoptMessOnClientNew(BOOL opt);
	BOOL getoptMessOnClientNew();
	void setoptMessOnClientPart(BOOL opt);
	BOOL getoptMessOnClientPart();

private:
	DWORD Status;
	WORD ServerPort;
	DWORD MaxConnec;

	void SetStatus(DWORD dwStatus);

	// on utilise une critical section pour toutes les variables vu qu'elles ne sont
	// pas utilisées tres fréquement
	CRITICAL_SECTION VarCS;

	HANDLE hNewMess;

	// thread
	static DWORD WINAPI ThreadEntry(CNetServer* MyServ);
	HANDLE hThread;
	HANDLE heThreadClose;

	// MessQueue
	BOOL DelClientMessOnPart;
	BOOL MessOnClientNew;
	BOOL MessOnClientPart;

	BOOL AddServerMessage(PMESSAGE Message);
	void DeleteMessageQueue(void);
	CRITICAL_SECTION MessageQueueCS;
	PMESSAGENODE MessageQueueFront;
	PMESSAGENODE MessageQueueBack;
	void DelMessID(DWORD ClientID);
	
	// WS
	SOCKET ListenSock;
	HANDLE ListenEvent;
	
	// ClientList
	DWORD ClientCounter;
	BOOL AddClient(PCLIENT Client);
	void DelClient(PCLIENT Client);
	PCLIENT GetClientByID(DWORD ClientID);
	CRITICAL_SECTION ClientListCS;
	PCLIENTNODE ClientList;
	DWORD GetNextClientID(void);
	DWORD GetNbClients(void);
	HANDLE heClientListChange;

	// help func
	DWORD inline RetFatalErr(DWORD Err);

} CNetServer, *pCNetServer;

Network.cpp

#include <Winsock2.h>
#include "NetWork.h"
#pragma comment(lib, "Ws2_32.lib")
#include <float.h> // pour _logb pour les erreurs de sockets

#define InVarCS EnterCriticalSection(&VarCS)
#define OutVarCS LeaveCriticalSection(&VarCS)

DWORD inline CNetServer::RetFatalErr(DWORD Err)
{
	SetStatus(SERVERSTAT_FATALERR);
	return Err;
}

CNetServer::CNetServer(HANDLE hEventNewMess)
{
	WSADATA wsaData;
	WSAStartup(MAKEWORD(2,0), &wsaData);

	InitializeCriticalSection(&VarCS);
	InitializeCriticalSection(&MessageQueueCS);
	InitializeCriticalSection(&ClientListCS);
	heClientListChange = CreateEvent(NULL, FALSE, FALSE, NULL);
	heThreadClose = CreateEvent(NULL, FALSE, FALSE, NULL);
	hThread = NULL;

	SetStatus(SERVERSTAT_STOPPED);

	MessageQueueFront = NULL;
	MessageQueueBack = NULL;
	hNewMess = hEventNewMess;

	ClientCounter = 0;
	ClientList = NULL;

	ListenSock = INVALID_SOCKET;
	ListenEvent = NULL;

	DelClientMessOnPart = FALSE;
	MessOnClientNew = TRUE;
	MessOnClientPart = TRUE;

}

CNetServer::~CNetServer(void)
{
	Stop();

	if(ListenSock != INVALID_SOCKET)
	{
		shutdown(ListenSock, SD_BOTH);
		if(ListenEvent) { WSACloseEvent(ListenEvent); ListenEvent = NULL; }
		closesocket(ListenSock);
		ListenSock = INVALID_SOCKET;
	}

	Kick();

	if(hThread)
	{
		TerminateThread(hThread, 0); // ceci ne devrait pas arriver
		CloseHandle(hThread);
	}

	DeleteMessageQueue();

	DeleteCriticalSection(&VarCS);
	DeleteCriticalSection(&MessageQueueCS);
	DeleteCriticalSection(&ClientListCS);
	CloseHandle(heClientListChange);
	CloseHandle(heThreadClose);

	WSACleanup();
}

void CNetServer::setoptDelClientMessOnPart(BOOL opt)
{
	InVarCS;
	DelClientMessOnPart = opt;
	OutVarCS;
}

BOOL CNetServer::getoptDelClientMessOnPart()
{
	InVarCS;
	BOOL ret = DelClientMessOnPart;
	OutVarCS;
	return ret;
}

void CNetServer::setoptMessOnClientNew(BOOL opt)
{
	InVarCS;
	MessOnClientNew = opt;
	OutVarCS;
}

BOOL CNetServer::getoptMessOnClientNew()
{
	InVarCS;
	BOOL ret = MessOnClientNew;
	OutVarCS;
	return ret;
}

void CNetServer::setoptMessOnClientPart(BOOL opt)
{
	InVarCS;
	MessOnClientPart = opt;
	OutVarCS;
}

BOOL CNetServer::getoptMessOnClientPart()
{
	InVarCS;
	BOOL ret = MessOnClientPart;
	OutVarCS;
	return ret;
}

WORD CNetServer::GetServerPort(void)
{
	InVarCS;
	WORD ret = ServerPort;
	OutVarCS;
	return ret;
}

DWORD CNetServer::GetStatus(void)
{
	InVarCS;
	DWORD ret = Status;
	OutVarCS;
	return ret;
}

DWORD CNetServer::GetMaxConnec(void)
{
	InVarCS;
	DWORD ret = MaxConnec;
	OutVarCS;
	return ret;
}
void CNetServer::SetMaxConnec(DWORD dwMaxConnec)
{
	InVarCS;
	MaxConnec = dwMaxConnec;
	OutVarCS;
}

void CNetServer::SetStatus(DWORD dwStatus)
{
	InVarCS;
	Status = dwStatus;
	OutVarCS;
}

DWORD CNetServer::Start(WORD wServerPort, DWORD dwMaxConnec, BOOL ResetMessQueue)
{
	if(GetStatus() != SERVERSTAT_STOPPED) return SERVERERR_BADCALLPARAM;

	if(ResetMessQueue) DeleteMessageQueue();
	
	InVarCS;
	ServerPort = wServerPort;
	MaxConnec = dwMaxConnec;
	OutVarCS;

    ListenSock = socket(AF_INET,SOCK_STREAM,0);
    if(ListenSock==INVALID_SOCKET) return RetFatalErr(SERVERERR_WS);
    
    sockaddr_in sain;
    sain.sin_family = AF_INET;
    sain.sin_port = htons(ServerPort);
    sain.sin_addr.s_addr = INADDR_ANY;

    if(bind(ListenSock, (struct sockaddr *) &sain, sizeof(struct sockaddr_in)) == SOCKET_ERROR) return RetFatalErr(SERVERERR_WS);
    if (listen(ListenSock, SOMAXCONN)==SOCKET_ERROR) return RetFatalErr(SERVERERR_WS);

	ListenEvent = WSACreateEvent();
	WSAEventSelect(ListenSock, ListenEvent, FD_ACCEPT);

	// on crée le thread de messages
	DWORD ThreadId;
	hThread = CreateThread(NULL,0, (LPTHREAD_START_ROUTINE)ThreadEntry, this, 0, &ThreadId);
	if(hThread == NULL) return RetFatalErr(SERVERERR_THREAD);

	SetStatus(SERVERSTAT_RUNNING);

	return SERVERERR_SUCCESS;
}

DWORD CNetServer::Stop(BOOL DelMessQueue)
{
	if(GetStatus() != SERVERSTAT_RUNNING) return SERVERERR_BADCALLPARAM;

	// on ferme le thread de messages
	SetEvent(heThreadClose);
	if(WaitForSingleObject(hThread, 5000) == WAIT_TIMEOUT) TerminateThread(hThread, 0);
	CloseHandle(hThread);
	hThread = NULL;

	// on ferme les sockets
	shutdown(ListenSock, SD_BOTH);
	WSACloseEvent(ListenEvent);
	ListenEvent = NULL;
	closesocket(ListenSock);
	ListenSock = INVALID_SOCKET;

	Kick();

	if(DelMessQueue) DeleteMessageQueue();

	SetStatus(SERVERSTAT_STOPPED);

	return SERVERERR_SUCCESS;
}

BOOL CNetServer::Send(void* Data, DWORD cbData, DWORD ClientID)
{
	DWORD dwStatus = GetStatus();
	if(dwStatus == SERVERSTAT_FATALERR) return FALSE;
	if(dwStatus == SERVERSTAT_STOPPED) return FALSE;
	
	if(Data == NULL) return FALSE;
	if(cbData < 1) return FALSE;

	int SizeOpt;
	DWORD cbMaxSize;
	SizeOpt = sizeof(cbMaxSize);
	getsockopt(ListenSock, SOL_SOCKET, SO_RCVBUF, (char*)&(cbMaxSize), &SizeOpt);

	if(cbData > cbMaxSize) return FALSE;

	PCLIENT Client;
	BOOL bRet = TRUE;

	if(ClientID == 0)
	{
		EnterCriticalSection(&ClientListCS);
		for(PCLIENTNODE CurNode = ClientList; CurNode != NULL; CurNode = CurNode->pNext)
			if(send(CurNode->pClient->Sock, (char*)Data, cbData, 0) == SOCKET_ERROR) bRet = FALSE;
		LeaveCriticalSection(&ClientListCS);
	} else {
		Client = GetClientByID(ClientID);
		if(Client == NULL) return FALSE;

		EnterCriticalSection(&ClientListCS);
		if(send(Client->Sock, (char*)Data, cbData, 0) == SOCKET_ERROR) bRet = FALSE;
		LeaveCriticalSection(&ClientListCS);
	}
	
	return bRet;
}

BOOL CNetServer::Kick(DWORD ClientID)
{
	PCLIENT Client;
	BOOL bRet = TRUE;

	if(ClientID == 0)
	{
		EnterCriticalSection(&ClientListCS);
		for(PCLIENTNODE CurNode = ClientList; CurNode != NULL; CurNode = CurNode->pNext)
		{
			shutdown(CurNode->pClient->Sock, SD_BOTH);
			WSACloseEvent(CurNode->pClient->Event);
			closesocket(CurNode->pClient->Sock);
			DelClient(CurNode->pClient);
		}
		LeaveCriticalSection(&ClientListCS);
	} else {
		Client = GetClientByID(ClientID);
		if(Client == NULL) return FALSE;

		EnterCriticalSection(&ClientListCS);

		shutdown(Client->Sock, SD_BOTH);
		WSACloseEvent(Client->Event);
		closesocket(Client->Sock);
		DelClient(Client);

		LeaveCriticalSection(&ClientListCS);
	}
	
	return bRet;

}

// MessageQueue
BOOL CNetServer::AddServerMessage(PMESSAGE Message)
{
	EnterCriticalSection(&MessageQueueCS);

	if(MessageQueueFront == NULL)
	{
		MessageQueueFront = new MESSAGENODE;
		MessageQueueFront->Message = Message;
		MessageQueueFront->pNext = NULL;
		MessageQueueBack = NULL;
	} 
	else if(MessageQueueFront->pNext == NULL)
	{
		MessageQueueBack = new MESSAGENODE;
		MessageQueueBack->Message = Message;
		MessageQueueBack->pNext = NULL;
		MessageQueueFront->pNext = MessageQueueBack;

	} else {
		PMESSAGENODE NewNode = new MESSAGENODE;
		NewNode->Message = Message;
		NewNode->pNext = NULL;
		MessageQueueBack->pNext = NewNode;
		MessageQueueBack = NewNode;
	}

	LeaveCriticalSection(&MessageQueueCS);
	
	if(hNewMess) SetEvent(hNewMess);

	return TRUE;
}

PMESSAGE CNetServer::GetServerMessage(void)
{
	EnterCriticalSection(&MessageQueueCS);
	
	PMESSAGENODE pRetNode;

	if(MessageQueueFront == NULL)
	{
		pRetNode = NULL;
	} else {
		pRetNode = MessageQueueFront;
		MessageQueueFront = pRetNode->pNext;

		if(MessageQueueFront == NULL)
		{
			MessageQueueBack = NULL;
		} else if(MessageQueueFront->pNext == NULL)
		{
			MessageQueueBack = NULL;
		}
	}
	
	LeaveCriticalSection(&MessageQueueCS);

	if(pRetNode == NULL) return NULL;

	PMESSAGE pRet = pRetNode->Message;
	delete pRetNode;
	return pRet;
}

void CNetServer::DeleteMessageQueue(void)
{
	PMESSAGE pMess;
	while((pMess = GetServerMessage()) != NULL)
	{
		if(pMess->Data && pMess->cbData) delete[] pMess->Data;
		delete pMess;
	}
}

void CNetServer::DelMessID(DWORD ClientID)
{
	EnterCriticalSection(&MessageQueueCS);

	PMESSAGENODE pMessNode;
	PMESSAGENODE pTmpNode;
	// tant que le 1er convient
	while(MessageQueueFront)
	{
		if(MessageQueueFront->Message->ClientID == ClientID)
		{
			if(MessageQueueFront->Message->Data && MessageQueueFront->Message->cbData) delete[] MessageQueueFront->Message->Data;
			delete MessageQueueFront->Message;

			MessageQueueFront = MessageQueueFront->pNext;
			if(MessageQueueFront == NULL)
			{
				// il y avait qu'un message
				MessageQueueBack = NULL;
				LeaveCriticalSection(&MessageQueueCS);
				return;
			}
		} else break;
	}
	
	if(MessageQueueFront)
	{
		// on parcourt le queue de message
		for(pMessNode = MessageQueueFront; pMessNode->pNext != NULL; pMessNode = pMessNode->pNext)
		{
			if(pMessNode->pNext->Message->ClientID == ClientID)
			{
				pTmpNode = pMessNode->pNext;
				pMessNode->pNext = pMessNode->pNext->pNext;
	
				if(pTmpNode->Message->Data && pTmpNode->Message->cbData) delete[] pTmpNode->Message->Data;
				delete pTmpNode->Message;
				delete pTmpNode;
	
				if(pMessNode->pNext == NULL) // c t le dernier
				{
					MessageQueueBack = pMessNode;
					LeaveCriticalSection(&MessageQueueCS);
					return;
				}
			}
		}
	}

	LeaveCriticalSection(&MessageQueueCS);
}
// ClientList
// !!! ATTENTION !!! il faut owner la ClientListCS avant d'appeler cette fonction !!!
BOOL CNetServer::AddClient(PCLIENT Client)
{
	PCLIENTNODE NewNode = new CLIENTNODE;

	NewNode->pClient = Client;
	NewNode->pNext = ClientList;
	ClientList = NewNode;
	
	SetEvent(heClientListChange);

	return TRUE;
}

// !!! ATTENTION !!! il faut owner la ClientListCS avant d'appeler cette fonction !!!
void CNetServer::DelClient(PCLIENT Client)
{
	// si c le 1er
	if(ClientList == NULL) 
		return;

	if(!memcmp(ClientList->pClient, Client, sizeof(CLIENT)))
	{
		PCLIENTNODE DelNode = ClientList;
		ClientList = ClientList->pNext;
		delete DelNode->pClient;
		delete DelNode;
		SetEvent(heClientListChange);
		return;
	}
	
	// si c le 2eme et plus
	PCLIENTNODE CurNode = ClientList;
	while(CurNode->pNext != NULL)
	{
		if(!memcmp(CurNode->pNext->pClient, Client, sizeof(CLIENT)))
		{
			PCLIENTNODE DelNode = ClientList->pNext;
			CurNode->pNext = CurNode->pNext->pNext;
			delete DelNode->pClient;
			delete DelNode;
			SetEvent(heClientListChange);
			break;
		}

		CurNode = CurNode->pNext;
	}
}

PCLIENT CNetServer::GetClientByID(DWORD ClientID)
{
	EnterCriticalSection(&ClientListCS);
	
	PCLIENT pRet = NULL;

	PCLIENTNODE CurNode = ClientList;
	while(CurNode != NULL)
	{
		if(CurNode->pClient->ClientID == ClientID)
		{
			pRet = new CLIENT;
			if(pRet == NULL)
			{
				LeaveCriticalSection(&ClientListCS);
				return NULL;
			}
			memcpy(pRet, CurNode->pClient, sizeof(CLIENT));
			break;
		}

		CurNode = CurNode->pNext;
	}

	LeaveCriticalSection(&ClientListCS);

	return pRet;
}

DWORD CNetServer::GetNextClientID(void)
{
	EnterCriticalSection(&ClientListCS);
	ClientCounter++;
	DWORD dwRet = ClientCounter;
	LeaveCriticalSection(&ClientListCS);
	return ClientCounter;
}

DWORD CNetServer::GetNbClients(void)
{
	DWORD i = 0;
	EnterCriticalSection(&ClientListCS);
	for(PCLIENTNODE CurNode = ClientList; CurNode !=NULL; CurNode = CurNode->pNext) i++;
	LeaveCriticalSection(&ClientListCS);
	return i;
}

DWORD WINAPI CNetServer::ThreadEntry(CNetServer* MyServ)
{
	WSANETWORKEVENTS EventResult;
	PCLIENT Client;
	DWORD ClientID;
	PMESSAGE Message;
	PCLIENTNODE CurNode;

	int SizeOpt;
	char* RecvDataBuf;
	DWORD cbRecvDataBuf;

	HANDLE* TabEvents;
	int cbTabEvents;
	int i;
	DWORD WaitRes;

	bool bMustClose = false;
	while(!bMustClose)
	{
		// on construit le tableau des evenements a attendre
		cbTabEvents = 3;

		EnterCriticalSection(&MyServ->ClientListCS);
		
		for(CurNode = MyServ->ClientList; CurNode != NULL; CurNode = CurNode->pNext)
			cbTabEvents++;
		
		TabEvents = new HANDLE[cbTabEvents];

		i=3;
		for(CurNode = MyServ->ClientList; CurNode != NULL; CurNode = CurNode->pNext)
		{
			TabEvents[i] = CurNode->pClient->Event;
			i++;
		}

		LeaveCriticalSection(&MyServ->ClientListCS);

		TabEvents[0] = MyServ->heThreadClose;
		TabEvents[1] = MyServ->heClientListChange;
		TabEvents[2] = MyServ->ListenEvent;
		
		WaitRes = WSAWaitForMultipleEvents(cbTabEvents, TabEvents, FALSE, WSA_INFINITE, FALSE);

		delete TabEvents;

		switch(WaitRes)
		{
		case WSA_WAIT_EVENT_0:
			{
				bMustClose = true;
			}
			break;

		case WSA_WAIT_EVENT_0+1:
			// on fait rien, c t juste pour rafraichir la liste des evenements a attendre
			break;

		case WSA_WAIT_EVENT_0+2:
			{
				WSAEnumNetworkEvents(MyServ->ListenSock, MyServ->ListenEvent, &EventResult);
				if(EventResult.lNetworkEvents == FD_ACCEPT)
				{
					if( (!(MyServ->GetNbClients() > MyServ->GetMaxConnec())) | (MyServ->GetMaxConnec() == 0) )
					{
						Client = new CLIENT;
						ClientID = MyServ->GetNextClientID();
						Client->ClientID = ClientID;
						Client->Sock = accept(MyServ->ListenSock, NULL, NULL);
						Client->Event = WSACreateEvent();
						WSAEventSelect(Client->Sock, Client->Event, FD_READ | FD_CLOSE);
						MyServ->AddClient(Client);
						
						if(MyServ->getoptMessOnClientNew())
						{
							Message = new MESSAGE;
							Message->ClientID = ClientID;
							Message->MessageType = MESSTYPE_NEW;
							Message->cbData = 0;
							Message->Data = NULL;
							MyServ->AddServerMessage(Message);
						}
					}
				}
			}
			break;

		default:
			{
				// on récupère le client en question
				i=3;
				for(CurNode = MyServ->ClientList; CurNode != NULL; CurNode = CurNode->pNext)
				{
					if(WSA_WAIT_EVENT_0+i == WaitRes) 
						break;
					else
						i++;
				}

				WSAEnumNetworkEvents(CurNode->pClient->Sock, CurNode->pClient->Event, &EventResult);
				switch(EventResult.lNetworkEvents)
				{
				case FD_READ:
					{
						if (EventResult.iErrorCode[(int) _logb(EventResult.lNetworkEvents)]) // erreur
						{
							WSACloseEvent(CurNode->pClient->Event);
							closesocket(CurNode->pClient->Sock);
							ClientID = CurNode->pClient->ClientID;
							MyServ->DelClient(CurNode->pClient);
							
							if(MyServ->getoptDelClientMessOnPart()) MyServ->DelMessID(ClientID);
							
							if(MyServ->getoptMessOnClientPart())
							{
								Message = new MESSAGE;
								Message->ClientID = ClientID;
								Message->MessageType = MESSTYPE_QUIT;
								Message->cbData = 0;
								Message->Data = NULL;
								MyServ->AddServerMessage(Message);
							}
						} else {
							Message = new MESSAGE;
							SizeOpt = sizeof(cbRecvDataBuf);
							getsockopt(CurNode->pClient->Sock, SOL_SOCKET, SO_RCVBUF, (char*)&(cbRecvDataBuf), &SizeOpt);
							RecvDataBuf = new char[cbRecvDataBuf];
							if((Message->cbData = recv(CurNode->pClient->Sock, RecvDataBuf, cbRecvDataBuf, 0)) == SOCKET_ERROR) {MyServ->Status = SERVERSTAT_FATALERR; return 0;}
							Message->Data = (void*)new char[Message->cbData];
							memcpy(Message->Data, RecvDataBuf, Message->cbData);
							Message->ClientID = CurNode->pClient->ClientID;
							Message->MessageType = MESSTYPE_RECV;
							MyServ->AddServerMessage(Message);
						}
					}
					break;
				case FD_CLOSE:
					{
						WSACloseEvent(CurNode->pClient->Event);
						closesocket(CurNode->pClient->Sock);
						ClientID = CurNode->pClient->ClientID;
						MyServ->DelClient(CurNode->pClient);
						
						if(MyServ->getoptDelClientMessOnPart()) MyServ->DelMessID(ClientID);
						
						if(MyServ->getoptMessOnClientPart())
						{
							Message = new MESSAGE;
							Message->ClientID = ClientID;
							Message->MessageType = MESSTYPE_QUIT;
							Message->cbData = 0;
							Message->Data = NULL;
							MyServ->AddServerMessage(Message);
						}
					}
					break;
				}
			}
			break;

		} // switch
	} // while
	return 0;
}