Exemple de serveur (multi-clients) tcp (win32 / vc++) (11 sept 2003 : maj)

Soyez le premier à donner votre avis sur cette source.

Vue 18 572 fois - Téléchargée 999 fois

Description

ceci est donc une tite classe (faite avec vc++6 puis fini ac le 7)
pour faire un serveur TCP.
il peut accepter plusieurs clients simultanément.
on peut paramétrer le port bien sur et le nbr max de connexions.
lorsque qu'un client de connecte, se deconnecte ou envoit un message, on récupère ces infos avec une "message-queue" (SERVER::GetServerMessage)
on peut virer un client avec SERVER::Kick
voila ...

Source / Exemple :


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;
}

Conclusion :


il me semble qu'il reste qd mm 2-3 tits bugs (g un peu testé mais pas a fond)
notament il y en a un pour l'ID Client, lorsque par exemple le 2 se barre et qu'il y a un 3 le 3 devient 2 ou un truc comme ca.

Si jms vous trouvez des bugs, ou des solutions aux bugs, mci de me les faire parvenir (ds.blackgoddess@ifrance.com), si vs avez des questions n'hesitez pas non plus :)

j'espere que ca pourra vous servir :)
bonne prog
@+

7 mai 2003 / 16h30 : MAJ

voila, puisque les nouvelles fonctionalités dont j'ai parlé ci-dessous vont être beaucoup plus longues que prévues, j'ai corrigés le bug des ressources (en fait j'ai refait la moitié de la classe) et je la remets donc.
Merci de me signaler d'autres bugs :)

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

psyjc
Messages postés
182
Date d'inscription
dimanche 29 juin 2003
Statut
Membre
Dernière intervention
18 avril 2008

J'ai trouvé.. (ca m'apprendra a pas chercher...)
psyjc
Messages postés
182
Date d'inscription
dimanche 29 juin 2003
Statut
Membre
Dernière intervention
18 avril 2008

Salut blackgoddess.
je me suis inspiré de ton code pour coder un serveur multi clients sur un seul thread mais je le problème qui a été évoqué ci dessus : wsawaitformultipleevent boucle et bouffe 100% proc. comment a tu fais pour régler ce problème et être bloquant dans l'attente d'un évènement ?
Merci d'avance?
BlackGoddess
Messages postés
338
Date d'inscription
jeudi 22 août 2002
Statut
Membre
Dernière intervention
14 juin 2005

Stood > pour le FD_SETSIZE, on peut en effet changer la valeur.
Malheureusement cette valeur est statique, définie a la compilation.
Je ne connais pas l'implémentation des fd_set, mais je suppose que ca doit etre un tableau. Aussi définir une trop grande valeur par rapport au nombre de clients potentiels pourrait nuire aux performances par exemple.
Ca ne permet donc pas une gestion souple du nombre de clients :(
vinceVD
Messages postés
11
Date d'inscription
mardi 4 mars 2003
Statut
Membre
Dernière intervention
26 mai 2005

Salut je viens aussi de me truover bloquer a cause de la limite de 64connex, au début je croyé qe ct a cause de XP SP2 mais apparament non.J'ai vu les deux méthode que tu as proposé et je voudrait savoir si quelqu'un a testé une de ces soluces ou tout simplement a réussi a contourner le pb. Merci de vos réponse
vinceVD
Messages postés
11
Date d'inscription
mardi 4 mars 2003
Statut
Membre
Dernière intervention
26 mai 2005

Salut je viens aussi de me truover bloquer a cause de la limite de 64connex, au début je croyé qe ct a cause de XP SP2 mais apparament non.J'ai vu les deux méthode que tu as proposé et je voudrait savoir si quelqu'un a testé une de ces soluces ou tout simplement a réussi a contourner le pb. Merci de vos réponse

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.