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 :)
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.