[Résolu] Classes pour les sockets - Classes pour faciliter l'utilisation de sockets C, en C++ par kindaichi - page 1

Oui j'ai fait un truc comme ça. Par contre j'ai pas mis de commentaires et j'ai que pour windows parce que je connais pas du tout mac ou linux :x

//SocketSystem.h




#ifndef SOCKET_SYSTEM_H
#define SOCKET_SYSTEM_H

#include <winsock2.h>
#include <stdio.h>


#pragma comment(lib,"WS2_32.lib")
#pragma comment(lib,"SocketSystem.lib")




//Classe statique servant à initialiser le WSA
class SocketSystem{


protected:
	static WSADATA SSinfos;
	static bool init;
	static int erreur;

public:
	SocketSystem() = 0;
	static int Init();
	static void Clean();
	static bool isInit();
	static int getLastError();

};


//Classe de base des 2 types de socket
class Socket
{

protected:
	SOCKET sock;
	int erreur;
	bool connected;

public:
	int Send(const char* message, int taille_max);
	int Recv(char* buffer, int taille_max);
	virtual int deconnect() = 0;
	bool isConnected();
	int getConstructError();


};




//Socket de type client, réutilisable après une déconnection
class ClientSocket: public Socket{


private:

	sockaddr_in sockConfig;
	unsigned long IPConfig;
	unsigned short int portConfig;


public:

	ClientSocket(unsigned long IPaddr = 0, unsigned short int port = 0);
	ClientSocket(const char* IPaddr, unsigned short int port = 0);
	~ClientSocket();
	int connectTo(const char* IPaddr, unsigned short int port = 0);
	int connectTo(unsigned long IPaddr, unsigned short int port = 0);
	int Connect();
	int changeIP(const char* IPaddr);
	int changeIP(unsigned long IPaddr);
	int changePort(unsigned short int port);
	int deconnect();



};


//Socket donnée par un Serveur::Accept(), non instanciable publiquement et non réutilisable
class ServeurSocket: public Socket
{

private:
	
	sockaddr_in csockConfig;
	unsigned short int thisPort;
	ServeurSocket(SOCKET acceptedSock, unsigned short int serveurPort, sockaddr_in infos);
	
	friend class Serveur;



public:
	~ServeurSocket();
	unsigned long getClientIP();
	unsigned short int getPortClient();
	int deconnect();


};


//Serveur
class Serveur
{
	

	sockaddr_in serveurConfig;
	unsigned short int listenPort;
	SOCKET sock;
	bool listenning;
	int error;

public:
	Serveur( unsigned  short int port = 0 );
	~Serveur();
	int getConstructError();
	int setPort( unsigned short int port );
	int Listen(int max);
	ServeurSocket* Accept();
	int stopListen();
	bool isListenning();




};




//Classe permettant de récupérer l'adresse IP d'un host
class HostInfos
{
public:
	static const char* getsIP(char* host);
	static unsigned long getulIP(char* host);
	HostInfos() = 0;
};

//Classe de conversion et de vérification de syntaxe des addresses IP
class IPV4System
{
public:
	static const char* ultos( unsigned long IP );
	static unsigned long stoul( const char* IP );
	static bool checkGoodIP( const char* IParg );
	IPV4System() = 0;
};
#endif

et le code :

#include "SocketSystem.h"
#include <winsock2.h>
#include <ws2tcpip.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>








//
//SocketSystem Initialisations
//
WSADATA SocketSystem::SSinfos;
bool SocketSystem::init=false;
int SocketSystem::erreur=0;






//
//SocketSystem
//
int SocketSystem::Init()
{
		
	
	erreur = WSAStartup(MAKEWORD(2,2),&SSinfos);
		if(erreur == 0)
		{
			init = 1;
			return 0;
		}
		else
			return -1;

		return 0;
}





void SocketSystem::Clean()
{
		erreur = WSACleanup();
		init = 0;
		return;
}



bool SocketSystem::isInit()
{
	return init;
}



int SocketSystem::getLastError()
{
	return WSAGetLastError();
}




//
//Socket
//
bool Socket::isConnected()
{
	return connected;
}
int Socket::Send(const char *message,  int taille_max)
{
	if( connected = true )
	return send(sock, message, taille_max, 0);
	else
		return -1;
}


int Socket::Recv(char *buffer, int taille_max)
{
	if( connected == true )
	return recv(sock, buffer, taille_max, 0);
	else 
		return -1;
}
int Socket::getConstructError()
{
	return erreur;
}
//
//ClientSocket
//
ClientSocket::ClientSocket(unsigned long IPaddr, unsigned short int port)
{
	
	int error=0;


	sockConfig.sin_addr.S_un.S_addr = IPaddr;

	sockConfig.sin_family = AF_INET;

	sockConfig.sin_port = htons(port);

	if( SocketSystem::isInit() != true)
	{
		error=SocketSystem::Init();
		if(error != 0)
		{
			erreur=error;
			return;
		}
	}


	sock = socket(AF_INET, SOCK_STREAM, 0);

	IPConfig = IPaddr;

	portConfig = port;



	return;



}




ClientSocket::ClientSocket(const char *IPaddr, unsigned short port)
{
	
	unsigned long finalIP = 0;
	if(IPV4System::checkGoodIP(IPaddr))
		finalIP = inet_addr(IPaddr);
	else
		finalIP = 0;
	int error=0;


	sockConfig.sin_addr.S_un.S_addr = finalIP;

	sockConfig.sin_family = AF_INET;

	sockConfig.sin_port = htons(port);

	if( SocketSystem::isInit() != true)
	{
		error=SocketSystem::Init();
		if(error != 0)
		{
			erreur=error;
			return;
		}
	}


	sock = socket(AF_INET, SOCK_STREAM, 0);

	IPConfig = finalIP;

	portConfig = port;

	return;
}
ClientSocket::~ClientSocket()
{
	closesocket(sock);
	return;
}

int ClientSocket::connectTo(const char *IPaddr, unsigned short port)
{
	
	unsigned short int tempPort = 0;
	if(port == 0)
		tempPort = portConfig;
	else
		tempPort = port;

	if(tempPort == 0)
		return -2;

	if(IPV4System::checkGoodIP(IPaddr))
	{
		return connectTo(IPV4System::stoul(IPaddr), port);
	}
	else 
		return -3;
}
int ClientSocket::connectTo(unsigned long IPaddr, unsigned short port)
{
	unsigned short int tempPort = 0;
	int size = 0;
	int erreur = 0;

	if(IPaddr == 0)
		return -4;
	if(port == 0)
	{
		if(portConfig == 0)
			return -2;
		else
			tempPort = portConfig;
	}
	else
	{
		tempPort = port;
		portConfig = port;
		sockConfig.sin_port = port;
	}
	IPConfig = IPaddr;
	sockConfig.sin_addr.S_un.S_addr = IPaddr;

	size = sizeof(sockConfig);

	if( this->isConnected())
		this->deconnect();

	erreur = connect(sock,(sockaddr*) &sockConfig, size);

	if(erreur == 0)
	{
		connected = true;
		return 0;
	}
	else
		return erreur;



}



int ClientSocket::Connect()
{
	
	
	int erreur = 0;
	if( this->isConnected())
		this->deconnect();
	if(IPConfig != 0 && portConfig != 0)
	{
		erreur = connect(sock,(sockaddr*) &sockConfig, sizeof(sockConfig));
		if(erreur == 0)
		{
			connected = true;
			return 0;
		}
		else return erreur;
	}
	
	else
	{
		return -1;
	}
}

int ClientSocket::deconnect()
{
	connected = false;
	return shutdown(sock,2);
}
int ClientSocket::changePort(unsigned short port)
{
	if( connected == true)
	{
		deconnect();
	}
	

	sockConfig.sin_port = htons( port );

	portConfig = port;

	return 0;
}


int ClientSocket::changeIP(unsigned long IPaddr)
{

	if( connected == true)
	{
		deconnect();
	}

	sockConfig.sin_addr.S_un.S_addr = IPaddr;

	IPConfig = IPaddr;

	return 0;


}

int ClientSocket::changeIP(const char *IPaddr)
{
	if(IPV4System::checkGoodIP(IPaddr))
	{
		changeIP(IPV4System::stoul(IPaddr));
		return 0;
	}
	else
		return -1;
}


//
//ServeurSocket
//
ServeurSocket::ServeurSocket(SOCKET acceptedSock, unsigned short int serveurPort, sockaddr_in infos)
{
	sock = acceptedSock;
	thisPort = serveurPort;
	erreur = 0;
	connected = true;
	csockConfig = infos;
	return;

}
ServeurSocket::~ServeurSocket()
{
	if(connected == true)
	{
		deconnect();
	}
	return;
}
int ServeurSocket::deconnect()
{
	shutdown(sock, 2);
	connected = false;
	return closesocket(sock);
}
unsigned long ServeurSocket::getClientIP()
{
	return csockConfig.sin_addr.S_un.S_addr;
}

unsigned short int ServeurSocket::getPortClient()
{
	return csockConfig.sin_port;
}


//
//Serveur
//
Serveur::Serveur(unsigned short int port)
{
	
	
	
	listenPort = port;
	sock = (SOCKET) 0;
	int erreur = 0;
	error = 0;
	listenning = false;

	serveurConfig.sin_family = AF_INET;
	serveurConfig.sin_port = htons(port);
	serveurConfig.sin_addr.S_un.S_addr = htonl(INADDR_ANY);




	if( !SocketSystem::isInit())
	{
		if( SocketSystem::Init() != 0 )
		{
			error = -1;
			return;
		}

	}

	sock = socket(AF_INET, SOCK_STREAM, 0);
	if(sock == INVALID_SOCKET)
	{
		error = -1;
		return;
	}

	if( port == 0)
		return;

	erreur = bind( sock, (sockaddr*) &serveurConfig, sizeof(serveurConfig));

	if( erreur == SOCKET_ERROR )
	{
		error = -1;
		return;
	}

	return;
}

Serveur::~Serveur()
{
	closesocket(sock);
	return;
}
int Serveur::setPort(unsigned short int port)
{
	
	if( listenning == true )
	{
		this->stopListen();
	}
	
	serveurConfig.sin_port = htons( port );
	listenPort = port;

	if( port == 0 )
		return 0;

	return bind(sock, (sockaddr*) &serveurConfig, sizeof(serveurConfig));


}


int Serveur::Listen(int max)
{
	if( listenPort == 0 )
		return -1;
	int erreur = 0;
	erreur = listen( sock, max );
	if(erreur == 0)
	{
		listenning = true;
		return 0;
	}
	else
		return erreur;
}


ServeurSocket* Serveur::Accept()
{

	if(listenning == false)
		return 0;
	sockaddr_in cConfig;
	int size = sizeof(cConfig);
	SOCKET cSock;
	ServeurSocket* tempSock = 0;

	cSock = accept(sock, (sockaddr*) &cConfig, &size);
	tempSock = new ServeurSocket(cSock, listenPort, cConfig);
	return tempSock;
}
bool Serveur::isListenning()
{
	return listenning;
}
int Serveur::stopListen()
{
	listenning = false;
	return shutdown(sock, 2);
}

int Serveur::getConstructError()
{
	return error;
}
//
//HostInfos
//
unsigned long HostInfos::getulIP(char *host)
{
	
	if( !SocketSystem::isInit())
		SocketSystem::Init();

	struct addrinfo *host_infos = NULL;
	sockaddr_in *addresse;
	int erreur = 0;

	erreur = getaddrinfo( host, 0, 0, &host_infos );

	if( erreur != 0)
		return 0;

	addresse = (sockaddr_in *) host_infos->ai_addr;

	return addresse->sin_addr.S_un.S_addr;

}

const char* HostInfos::getsIP(char *host)
{
	static char buffer[16] = {0};
	unsigned long ip_host = 0;
	ip_host = getulIP(host);
	return IPV4System::ultos(ip_host);
}

//
//IPSystem
//

const char* IPV4System::ultos(unsigned long IP)
{
	in_addr temp;
	temp.S_un.S_addr = IP;
	return inet_ntoa( temp );
}

unsigned long IPV4System::stoul(const char *IP)
{
	unsigned long temp = 0;
	temp = inet_addr( IP );
	return temp;
}

bool IPV4System::checkGoodIP(const char *IParg)
{

	int rang = 0;    //rang en puissance de 10 du nombre de l'adresse IP
	int temp = 0;    //nombre temporaire de l'ip
	int partie = 1;  //partie de l'ip
	int i = 0;
	const int taille = strlen(IParg) - 1;


	bool nombreOK = false; //vrai s'il un nombre est présent

	char car = 0;

	for( i=0; i<=taille; i++)
	{


		car = IParg[taille - i];
		if( car >= 48 && car <= 57 )
		{
			nombreOK = true;
			temp += ( car - 48 )* (int) pow((double) 10, rang);
			rang++;
			if(temp > 255)
				return false;
			
		}

		else if( car == '.')
		{
			if( nombreOK == true )
			{
				partie++;
				if( partie > 4 )
					return false;

				temp = 0;
				rang = 0;
				nombreOK = false;
			}
			else
				return false;
			
		}

		else
			return false;
	}
	if( partie == 4 && nombreOK == true )
		return true;
	else
		return false;





	
}

Voilà

En espérant que ça puisse t'aider (j'essayerai de rajouter des coms)

PS: Je n'ai jamais dit que mon code était parfait (au cas ou :x)

kindaichi

11 juin 2008 à 18:24:30

Bonjour,
Je voudrai savoir est ce que quelqu'un a déjà fait des classes C++ qui facilitent l'utilisation des sockets en C++ ? Je voudrai m'inspirer pour organiser mes sources qui utilise des sockets C, en classes C++.
Merci beaucoup.

Anonyme

11 juin 2008 à 19:10:16

Tu peux mettre résolu.
http://www.developpez.net/forums/showthread.php?p=3370645

thesimsone

11 juin 2008 à 19:12:50

11 juin 2008 à 19:18:17

Thanks Davidbrcz.
thesimsone, je vais looké ton code source, merci.

Classes pour les sockets

Classes pour faciliter l'utilisation de sockets C, en C++

Classes pour les sockets

Supprimer

Modérer

Signaler le message aux modérateurs