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

Soyez le premier à donner votre avis sur cette source.

Vue 18 554 fois - Téléchargée 998 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

24Karas
Messages postés
233
Date d'inscription
jeudi 4 juillet 2002
Statut
Membre
Dernière intervention
5 juillet 2008
-
ça à l'air pa mal du tou : FELICITATION :)
g pa testé mais je m'empresse de le faire ...
Bon courage pour la suite
@++ 24KaraS
BlackGoddess
Messages postés
338
Date d'inscription
jeudi 22 août 2002
Statut
Membre
Dernière intervention
14 juin 2005
-
merci :)
ah ! oui c possible que je me sois aussi un peu embrouiller avec les CriticalSection...
cs_LordBob
Messages postés
2865
Date d'inscription
samedi 2 novembre 2002
Statut
Membre
Dernière intervention
11 mai 2009
8 -
ca orrai été bien ke tu mettre tous les fichier du projet pour Vc++ dans ton zip...
BlackGoddess
Messages postés
338
Date d'inscription
jeudi 22 août 2002
Statut
Membre
Dernière intervention
14 juin 2005
-
wep, dsl je ferais ca la prochaine fois
NerOcrO
Messages postés
33
Date d'inscription
mardi 10 octobre 2000
Statut
Membre
Dernière intervention
27 mai 2004
-
Merci ma couille, j'attendais ça depuis longtemps.

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.