Mise en œuvre de la communication Ethernet par Socket windows

Mise en œuvre de la communication Ethernet par SOCKET Windows
02/12/13
Réseau
Mise en œuvre de la communication Ethernet par
Socket windows
Sommaire
Table des matières
1PRÉSENTATION............................................................................................................................... 2
2MISE EN ŒUVRE DE LA COMMUNICATION PAR SOCKET................................................ 5
3MISE EN ŒUVRE............................................................................................................................. 6
4UTILISATION DE LA DLL SOCKET.......................................................................................... 14
5PATTERNS DE TRAITEMENT DES ERREURS POUR UNE FONCTION API WINDOWS
.............................................................................................................................................................. 15
6DÉCLARATION DES VARIABLES ET TRANSTYPAGE......................................................... 16
7SYNOPTIQUE DE MISE EN ŒUVRE ET DE TEST.................................................................. 17
8OPTION DE COMPILATION POUR L'UTILISATION DE LA LIBRAIRIE SOCKET AVEC
VISUEL STUDIO............................................................................................................................... 19
9DÉFINITION DU STANDARD DE PROGRAMMATION POUR VISUAL STUDIO .............20
Bibliographie
Annexe 2 : épreuve de conception du BTS II ; Communication réseau ; la communication clientserveur.
Préparation à la certification Microsoft Windows 2000 Server ; Microsoft Certified Professional ;
Examen 70-215 ; Microsoft Press.
Site WEB
Logiciel utilitaire réseau :
http:\\logiciels.ntfaqfr.com/Reseau.html
http://broux.developpez.com/articles/c/sockets/
http://c.developpez.com/cours/sockets-c-cpp-demystifies/
Sniffer : recherche avec le logiciel wireshark
SOCKET.odt
1/20
P. TREBOSC
Mise en œuvre de la communication Ethernet par SOCKET Windows
02/12/13
1 Présentation
La communication inter-processus par sockets permet de mettre en relation via des protocoles
des applications exécutées sur un même ordinateur ou sur 2 ordinateurs distants connectés par un
réseau local.
Adresse IP + N° port
Socket
Adresse IP + N° port
Socket active + Socket passive
Processus serveur
Réseau Ethernet
Processus client
Architecture pour communication socket entre 2 machines
Adresse IP + N° port
Processus serveur
+
Processus client
Architecture pour communication socket entre 2 processus d’une même machines
Chaque machine est connectée au réseau Ethernet grâce à l’installation d’une carte réseau.
L’installation consiste à installer physiquement la carte sur le bus de la carte mère et à installer son
driver et le protocole TCP/IP.
L’adresse au protocole internet IP est fixée soit manuellement par l’administrateur soit
directement par le serveur du service DHCP s’il est mis en œuvre.
Un socket peut être vu comme une structure de données qui associe 2 éléments :
•
Une adresse IP.
•
Un numéro de port utilisé pour la connexion.
La représentation que l’on peut en faire est celle d’une boîte aux lettres.
Cela permet notamment d’avoir plusieurs applications de communication qui s’exécutent sur une
même machine et qui sont distinguées par le numéro de port. On en reparlera dans la description
de l’instruction bind().
Ce document présente la mise en œuvre des sockets pour une communication avec un
client/serveur TCP
SOCKET.odt
2/20
P. TREBOSC
Mise en œuvre de la communication Ethernet par SOCKET Windows
02/12/13
Pile de protocole sous Windows
Couche Application 7
Windows 95
Windows 95
Couche Présentation 6
Windows 95
Windows 95
Couche Session 5
Windows 95
Windows 95
Couche Transport 4
TCP
TCP
Couche Réseau 3
IP
IP
Couche Liaison 2
Ethernet
Ethernet
Couche Physique 1
10 base 100
10 base 100
Client
Couche OSI
SOCKET
Serveur
Réseau local Ethernet
Organisation de la famille de protocoles TCP/IP sur les 4 couches sous
Windows
Application
Windows Socket
Application
NetBios
Windows Socket
TCP
NetBT
ICMP
IGMP
Technologie LAN :
Ethernet,
Token Ring,
FDDI
SOCKET.odt
UDP
IP
APPLICATION
TRANSPORT
ARP
Technologie
WAN :
Lignes série,
Relais de trames,
ATM
3/20
INTERNET
INTERFACE
RESEAU
P. TREBOSC
Mise en œuvre de la communication Ethernet par SOCKET Windows
02/12/13
Couche Internet : Les protocoles de cette couche intègrent les paquets dans les datagrammes
internet et exécutent tous les algorithmes de routage nécessaires.
Protocoles
Description
IP
Fournit une remise de paquets sans connexion à l’ensemble des autres protocoles
de la famille. Il n’y pas de garantie ni de l’arrivée ni de l’ordre de la séquence.
ARP
Fournit la mise en correspondance (mappage) d’une adresse IP et de l’adresse de
la sous couche MAC, nécessaire à l’acquisition de l’adresse de contrôle MAC
physique de la destination (adresse de la carte réseau installée dans la machine).
Le système qui détient l’adresse IP répond en envoyant son adresse physique au
demandeur. La sous couche MAC communique directement avec la carte réseau
et endosse la responsabilité de l’acheminement de données sans erreur entre 2
ordinateurs du réseau.
ICMP
Fournit une communication spéciale entre les hôtes et leur permet de partager les
informations d’état et d’erreur. Ces informations sont utilisées par les protocoles
de niveau supérieur pour corriger les erreurs de transmission. L’utilitaire Ping
utilise les paquets ICMP pour déterminer si un périphérique IP donné présent sur
le réseau est opérationnel ou non.
IGMP
Fournit une capacité de multi-diffusion pour communiquer et gérer des
informations sur l’ensemble des équipements présents au sein d’un groupe de
multidiffusion. Il informe les routeurs de multi-diffusion avoisinants de la
présence de membres d’un groupe hôte sur un réseau donné.
Couche de transport : Les protocoles de cette couche fournissent des sessions de
communication entre différents ordinateurs.
TCP
Fournit des communications fiables orientés connexion. Il garantit la fourniture
et la mise en séquence des paquets de données. On l’utilise pour la transmission
de grandes quantités de données.
UDP
Fournit des communications sans connexion et ne garantit pas la fourniture des
paquets. On l’utilise dans le cas de transmission de petite quantité de données
vers plusieurs destinataires.
Couche application : C’est par cette couche que les applications obtiennent un accès au réseau.
Elle intègre un grand nombre d’utilitaires et de service TCP/IP standard : FTP, Telnet, SNMP,
DNS etc.
Winsock
NetBT
SOCKET.odt
Agit comme l’interface standard entre les applications reposant sur des sockets et
des protocoles TCP/IP
Agit comme l’interface standard pour les services NetBIOS, notamment ceux
destinés aux noms, aux datagrammes et aux sessions. Il fournit également une
interface standard entre des applications NetBIOS et des protocoles TCP/IP
4/20
P. TREBOSC
Mise en œuvre de la communication Ethernet par SOCKET Windows
02/12/13
2 Mise en œuvre de la communication par SOCKET
Définitions
L’hôte est la machine qui applique le processus ou l’application qui utilise la communication par
socket.
Les phases sont les suivantes :
•
Création de la SOCKET avec les bonnes options : primitive socket().
•
Préparation de la communication : bind(), listen(), accept(), connect(),
•
Communication primitive : : write(), read()
•
Fermeture primitive : close().
Le schéma ci-dessous présente le principe de communication orientée connexion TCP entre un
serveur et un client. Comme on peut le constater, ce processus est synchronisé.
Serveur
Création
Client
Création
Socket()
Socket
Socket Passive
Socket()
Attachement
ou d'écoute
IP + N° port
Bind()
Listen()
Attente Passive
d'une connexion
Accept()
Processus bloqué
Connexion établie
Création
Socket Active
Attente Passive
Send()
Recv()
Le traitement de
l'application
utilisant le
message
d'une communication
Attente Passive
d'une communication
Connect()
Recv()
Traite()
Send()
Traite()
Close()
Close()
schéma de principe de communication SOCKET
SOCKET.odt
5/20
P. TREBOSC
Mise en œuvre de la communication Ethernet par SOCKET Windows
02/12/13
3 Mise en œuvre
Il existe au moins 3 méthodes pour implémenter la communication socket :
•
Primitives Berkeley, accessibles avec les API Windows socket est compatible ou
d’implémentation a peu près identique quel que soit le système d’exploitation.
•
Primitives API Windows évoluées WSA, les instructions apportent des extensions
par rapport aux fonction Berkeley.
•
Composants disponibles si on utilise un environnement de développement graphique.
L'utilisation de ces contrôles nécessite néanmoins une connaissance approfondie des
mécanismes mis en jeu.
Les 2 premières solutions sont mises en œuvre en utilisant le synoptique de principe du
paragraphe précédent.
Architecture WinSock
Le système d’exploitation Windows contient la DLL qui permet la mise en œuvre de la
communication par Socket. Elle établit le lien entre les couches basses de l’OS et l’application. La
version WinSock2 à succédée à la première version WinSock 1.1 L’architecture peut être
représentée par la figure ci-dessous.
Il incombe au développeur de s’assurer de la correspondance des primitives utilisées avec la
version de DLL chargée dans le système d’exploitation Windows.
Application
Application
Application
Application
WinSock
2
WinSock
WinSock 2
WinSock1.1
1.1
WINSOCK.DLL
WINSOCK.DLL(16
(16bits)
bits)
WSOCK32.DLL
WSOCK32.DLL(32
(32bits)
bits)
WS2_32.DLL
WS2_32.DLL(32
(32bits)
bits)(WinSock2
(WinSock2DLL)
DLL)
TCP/IP
TCP/IP- -based
based
Namespace
Namespace
Service
Serviceprovider
provider
e.g
e.gDNS
DNS
TCP/IP
TCP/IP
Transport
Transport
Service
Serviceprovider
provider
Rappel : On parle de mode bloquant pour une instruction qui stoppe le déroulement d’un
processus tant qu’elle n’est pas exécutée. Dans ce cas l’application est bloquée si l’on a pas pris la
précaution de la fabriquer en mode muliti-thread.
SOCKET.odt
6/20
P. TREBOSC
Mise en œuvre de la communication Ethernet par SOCKET Windows
02/12/13
Je décris brièvement ci-dessous les instructions au standard Berkeley. On remarque l'instruction
ioctlsocket qui est indispensable pour travailler en mode bloquant sous Windows.
Structures d'adresse
Structure d’adresse générique (valable dans tous les cas de domaine)
struct sockaddr
{
u_short
sa_family;
/*famille d’adresse*/
char
sa_data[14];
/* 14 octets d’adresse*/
};
Evidemment, cette structure doit être renseignée avant l’exécution de bind().
namelen : [in] Longueur de la structure d’adresse sockaddr.
Dans le domaine AF_INET, la structure de famille d’adresse de style internet spécifique à
utiliser est :
struct sockaddr_in {
short sin_family;
/*AF_INET*/
char sin_port;
/*port choisi, sur 2 octets*/
struct in_addr sin_addr;
/*adresse internet, sur 4 octets*/
char sin_zero[8];
/*caractères de remplissage 8 zéros*/
};
Cette adresse devra être renseignée puis transtypée pour être utilisée dans les paramètres des
fonctions. Voir le paragraphe
En cas d’adresse IP invalide, ou de demande d’attachement à un port déjà occupé, bind()
échoue et retourne –1. Il faut donc faire attention au choix du port dans le domaine non réservé.
Le symbole INADDR_ANY, placé dans le champ sin_addr, désigne les adresses internets de
l’hôte.
struct in_addr {
union {
struct { u_char s_b1,s_b2,s_b3,s_b4; } S_un_b;
struct { u_short s_w1,s_w2; } S_un_w;
u_long S_addr;
} S_un;
Si on veut accepter les sockets sur une seule adresse par exemple :
sin.sin_addr.s_addr = inet_addr("200.0.0.1");
On remarque le transtypage d'une chaîne de caractères en adresse de type INET.
Ces structures peuvent être visualisées dans l'environnement de développement. On accède à la
déclaration d'une structure en cliquant droit sur la ligne de déclaration et chercher la déclaration.
SOCKET.odt
7/20
P. TREBOSC
Mise en œuvre de la communication Ethernet par SOCKET Windows
02/12/13
En résumé
Dans les aides des API socket présentées ci-dessous, on retrouve en paramètre la structure
générique sockaddr. Si on travaille dans le domaine AFINET, il faudra utiliser et renseigner la
structure sockaddr_in qui sera transtypée en sockaddr pour être utilisée en paramètre dans
les API.
Pour le client qui va se connecter au serveur, il faut renseigner le l'adresse IP du serveur et le port
de communication.
Pour le serveur qui attend les demande de connexion , il n'est pas nécessaire de renseigner
l'adresse IP.
Primitives application serveur
Bind()
Associe (ou lie) une adresse locale à un Socket..
Une fois que le point de communication Socket est créé, on lui associe les éléments ci-dessous
qui renseigne l’application :
•
une adresse locale IP qui identifie la machine hôte de l'application
•
un numéro de port qui distingue le processus exécuté dans la machine qui désire
communiquer par ce point (il peut y avoir plusieurs processus exécuté simultanément sur
une même machine qui communique par le même carte réseau donc avec la même
adresse IP).
Ce doublet s'appelle adresse d'attachement du point de communication.
int bind (SOCKET s, const struct sockaddr FAR*
name, int namelen
);
ou
int bind(sock, (SOCKADDR*)&sin, sizeof(sin));
Rappel : Il faut transtyper le passage d'adresse de la donnée (LPSOCKADDR)
Paramètres
S : [in] Descripteur du socket retourné par socket()
Name : [in] Adresse d’attachement, de type variable suivant la famille d’adressage (le domaine)
SOCKET.odt
8/20
P. TREBOSC
Mise en œuvre de la communication Ethernet par SOCKET Windows
02/12/13
Listen()
Met en écoute un socket vers une connexion
La primitive listen() joue 2 rôles :
•
Déclaration aux couches inférieures du protocole que la socket dont le descripteur est
passé en argument est dite passive ou d'écoute (c’est à dire qu’elle sert uniquement à
écouter les demandes de connexion), et qu’elle est prête à accepter des requêtes de
connexion.
•
Demande au système de réserver une file d’attente pour mémoriser les demandes de
connexion simultanées.
int listen (SOCKET s, int backlog);
Paramètres
S : [in] Descripteur du socket.
Backlog : [in] Taille de la file d’attente, c’est à dire le nombre de requêtes simultanées que le
système accepte de suspendre en attente de traitement. Si la valeur est SOMAXCONN, le service
fixe la taille à la valeur maximum "raisonnable".
Instruction appliquée pour les serveurs orientés connexion TCP.
Accept()
Accepte une connexion sur un socket .
La primitive réalise successivement les 2 opérations suivantes :
•
Elle attend l’établissement d’une connexion sur la socket d’écoute pendant un laps de
temps déterminé.
•
Un fois la connexion établit (par le client), l’instruction extrait la première connexion de
la queue de la connexion associée à S (de listen()), puis crée un nouveau socket,
active, avec son handle qui servira ultérieurement à la communication entre le client et le
serveur.
Si le mode de communication est bloquant, la primitive accept() bloque l'application jusqu'à
ce qu'une connexion arrive. La configuration du mode de communication se fait avec la fonction
ioctlsocket().
SOCKET accept (SOCKET s, struct sockaddr FAR* addr, int FAR* addrlen);
Paramètres
S : [in] Descripteur du socket passive qui est à l’écoute après le listen().
Addr : [out] Récupération de l’adresse complète (IP et n° de port) du client au retour de l’appel.
Le format est identique à celui qui a été déclaré. Pour le domaine INET, sockaddr et en
fait
sockaddr_in.
Addrlen : [out] Pointeur sur un entier qui contient la longueur de la structure d’adresse sockaddr.
En INET sockaddr_in.
SOCKET : Entier
retourné par la primitive qui est le descripteur de la socket active qui vient
d’être créée pour communiquer.
SOCKET.odt
9/20
P. TREBOSC
Mise en œuvre de la communication Ethernet par SOCKET Windows
02/12/13
Lorque la primitive accept() est traitée nous disposons d’une nouvelle socket (active) dont
l’attachement est fait et qui est en relation avec le processus client. On connaît l’adresse du
processus client (IP + N° de port).
Il faut donc pour le serveur céer 2 sockets : sock avec sin et csock avec csin.
Instruction appliquée pour les serveurs orienté connexion TCP.
Primitives application client
Connect()
Etablit une connexion vers une destination spécifiée: l'application serveur en état accept.
Le connect() complète les informations des processus client (renseigné automatiquement) et
serveur.
En mode bloquant, l'application client attend que l'application serveur ai ouvert une connection
avec accept.
La configuration du mode de communication bloquant ou non bloquant se fait avec l'instruction
ioctlsocket.
int connect (SOCKET s, const struct sockaddr FAR*
name, int namelen);
Paramètres
S : [in] Descripteur du socket. locale
Name : [in] Adresse d’attachement du point de communication distant (serveur) avec lequel on
veut rentrer en contact.
On utilise :
récupération de l’adresse d’une machine pour remplir le champ
sin_addr de la structure, et pour mettre en relation avec un service standard. Si une
machine est une passerelle, elle peut avoir plusieurs adresse IP pour chaque carte
réseau installée.
•
gethostbyname()
•
Getservbyname()
pour connaître le numéro de port du serveur.
Namelen : [in] Longueur de l’adresse.
SOCKET.odt
10/20
P. TREBOSC
Mise en œuvre de la communication Ethernet par SOCKET Windows
02/12/13
Primitives communes application serveur et client
Socket()
Création d’un point de communication.
SOCKET socket (int domain, int type, int protocole);
L’entier retourné correspond au descripteur du socket créé.
Domaine ou famille d’adressage
•
AF_UNIX : machine locale
•
AF_INET : internet (famille d’adresse utilisée par les protocoles de la famille TCP/IP
Type de socket
•
SOCK_STREAM : full-duplex, fiable, avec connexion, préservation de l’ordre des
données, non duplication des données, données hors bande (urgentes).
•
SOCK_DGRAM : non-fiable, sans connexion, préservation des limites de messages.
•
SOCK_RAW : bas niveau, pour développer de nouveau protocoles
Protocole : Il peut être mis à zéro par défaut car il est généralement fixé par le choix du domaine et
du type de socket.
AF_INET + SOCK_DGRAM  UDP
AF_INET + SOCK_ STREAM  TCP
Si on utilise une famille d’adressage qui propose plusieurs protocoles pour un type de service
identique, il faut déterminer le protocole : IPPROTO_UDP, IPPROTO_TCP,
IPPROTO_ICMP et IPPROTO_RAW.
SOCKET.odt
11/20
P. TREBOSC
Mise en œuvre de la communication Ethernet par SOCKET Windows
02/12/13
Ioctlsocket()
Contrôle le mode de fonctionnement bloquant ou non bloquant des sockets.
SOCKET ioctlsocket (SOCKET s, long cmd, u_long FAR* argp);
Paramètres
S : [in] Descripteur du socket.
Cmd : [in] Commande pour mettre en œuvre le socket s
Les commandes peuvent être FIONBIO, FIONREAD ou SIOCATMARK.
Pour configurer le mode bloquant on utilise la commande FIONBIO.
Argp : [in/out] Pointeur vers cmd.
//Exemple pour
//
//
FIONBIO : Paramétrage du mode bloquant ou non bloquant.
Si p = 0 mode bloquant
Si p <> 0 mode non bloquant
Exemple :
unsigned long int p = 0;
ioctlsocket (s, FIONBIO, &p);
s est le descripteur de socket retourné à la création.
Cette fonction est à appliquer avant les instructions bloquantes, sur l’application serveur avant la
fonction accept(…) et elle est valable pour la fonction recv(…). Pour le client, il faut l’appliquer
avant la fonction recv(…).
Recv()
Reçoit des données sur un socket.
Si le socket est configuré en mode bloquant, l'instruction est bloquante et attend qu'un message
arrive (send()) en provenance de l'application distante connectée.
int recv (SOCKET s, char FAR* buf, int len, int flags
);
Paramètres
S : [in] Descripteur de la socket..
Buf : [out] Buffer pour les données entrantes.
Len : [in] Taille du buffer.
Flags : [in] Spécifie le chemin dans lequel l’appel est fait. Flags est généralement à 0.
Int : indique le nombre d'octets lus.
SOCKET.odt
12/20
P. TREBOSC
Mise en œuvre de la communication Ethernet par SOCKET Windows
02/12/13
Send()
Envoie une donnée sur une socket connectée.
Si la socket est configurée en mode bloquant, l'instruction est bloquante et attend que le message
soit arrivée (recv()) sur l'application distante connectée.
int send (SOCKET s, const char FAR * buf, int len, int flags);
Paramètres
S : [in] Descripteur de la socket..
Buf : [in] Buffer pour les données à transmettre.
Len : [in] Taille du buffer.
Flags : [in] Spécifie le chemin dans lequel l’appel est fait. Flags est généralement à 0.
Int : indique le nombre d'octets lus ou une erreur si problème lors de d'envoi.
Close()
Fermeture d'une socket.
int closesocket (SOCKET s);
Paramètres
S : [in] Descripteur du socket.
Attention : pour l’application serveur, il faut fermer 2 sockets.
SOCKET.odt
13/20
P. TREBOSC
Mise en œuvre de la communication Ethernet par SOCKET Windows
02/12/13
4 Utilisation de la DLL Socket
Faire un include de la dll winsock choisis.
Avant d'utiliser les instructions API Windows Socket, il faut vérifier la version installée puis
démarrer la DLL.
Lorsque la communication est terminée, il faut fermer la DLL.
Il faut inclure au projet les fichiers de déclaration nécessaires. Pour les connaître on peut se
reporter à l'aide de l'environnement de développement.
Vérification de la version DLL
//Initialisation de l'utilisation de la DLL windows pour les Sockets
//détermine la version supportée par le système d'exploitation.
//Cela permet à une DLL socket windows et à l'application développée d'être
//compatible. On compare les résultats contenus dans wsaData (wVersion et
//wHighVersion et on vérifie la compatibilité avec wVersionRequested
//Déclaration des données pour WSAStartup
WORD wVersionRequested;
WSADATA wsaData;
// Fixe la version de la DLL socket pour l'application à 2;
wVersionRequested = MAKEWORD(1,0);// ou wVersionRequested=MAKEWORD( 2, 0 );
Démarrage de la DLL avec traitement des erreurs
// Traitement des erreurs pour API Windows
err = WSAStartup( wVersionRequested, &wsaData );
if (err != 0 )
{//Traitement de l'erreur
switch (err)
{
case WSASYSNOTREADY : strcpy(MesErr,\
"Le réseau n'est pas prêt pour la communication.");
break;
case WSAVERNOTSUPPORTED : strcpy(MesErr,"Version non \
compatible.");
break;
case WSAEINPROGRESS : strcpy(MesErr,"Socket windows \
bloquante de version 1.1 en cours.");
break;
case WSAEPROCLIM : strcpy(MesErr,"Limitation des tâches \
supportée par windows.");break;
case WSAEFAULT : strcpy(MesErr,"IpWSAData n'est pas un \
pointeur valide.");break;
}
//Signalisation de l'erreur
//Si composition bidirectionnelle avec l'IHM – A EVITER EN OBJET DE METIER
if ( Application->MessageBox(MesErr,"Serveur : Erreur WSAStartup \
init et compatibilté DLL socket", MB_OK) != IDOK)
Application->Terminated;
//Plutôt passer le message en paramètre si erreur ou « OK » si pas d'erreur
}
// fin si
Fermeture de la DLL
//Fin d'utilisation de la DLL
WSACleanup()
SOCKET.odt
14/20
P. TREBOSC
Mise en œuvre de la communication Ethernet par SOCKET Windows
02/12/13
5 Patterns de traitement des erreurs pour une fonction API
Windows
Les instructions décrites retournent généralement un argument qui peut indiquer une erreur. Pour
obtenir une application fiable, il faut traiter les erreurs en signalant un message à l'écran. Le
schéma est le suivant :
1. Instruction par exemple ioctlsocket()
2. Traitement du code erreur associé à ioctlsocket()
Le code ci-dessous donne la méthode pour traiter les erreurs. Ce code doit être compris puis
réutilisé.
unsigned long int p = 0;
if (ioctlsocket(SockPassive,FIONBIO,&p) != 0)
{
//Récupération de la dernière erreur
erreur = WSAGetLastError();
//Traitement de l'erreur
switch (erreur)
{
case WSANOTINITIALISED : strcpy(MesErr,\
"A successful WSAStartup must occur before using this function.");
break;
case WSAENETDOWN : strcpy(MesErr,\
"The network subsystem has failed.");break;
case WSAEINPROGRESS : strcpy(MesErr,\
"A blocking Windows Sockets 1.1 call is in progress, or the \
service provider is still processing a callback function.");
break;
case WSAENOTSOCK : strcpy(MesErr,\
"The descriptor s is not a socket.");
break;
case WSAEFAULT : strcpy(MesErr,\
"The argp argument is not a valid part of the user address
space.");
break;
}
//Dans un environnement Graphique
if ( Application->MessageBox(MesErr, \
"Client : Erreur API ioctlsocket", MB_OK) != IDOK)
{ // reset de l'erreur
WSASetLastError(0);
return -1;
}
}
Les cas d'erreur possibles pour une fonction se trouvent dans l'aide en ligne.
Ici on affiche le message d'erreur dans la méthode. Ce n'est pas portable, il vaut mieux que la
méthode retourne le message d'erreur pour respecter la séparation IHM objet de métier.
SOCKET.odt
15/20
P. TREBOSC
Mise en œuvre de la communication Ethernet par SOCKET Windows
02/12/13
6 Déclaration des variables et transtypage
Déclaration des types utilisés
Un certain nombre de variables de type complexe doivent être déclarées : socket, adresse…
// création d'un numéro de descripteur de socket
//la fonction socket retourne un type SOCKET
SOCKET SockPassive;
SOCKET SockActive;
//déclaration de la structure addresse type inetrnet d’un socket.
// Les deux types de déclarations sont équivalents
SOCKADDR_IN sin;
struct sockaddr_in pin;
u_short port;
// numéro de port affecté à la Socket
const char FAR *AdIPDist;
// adresse IP de la machine distante à
//contacter
Utilisation des sockets dans les primitives
if(connect(Sock,(LPSOCKADDR) & SockPassive, sizeof(struct sockaddr_in)) ==
-1)
Ou
if(connect(sock,(struct sockaddr*) & SockPassive, sizeof(struct
sockaddr_in)) == -1)
Pour accept int FAR* addrlen s'écrit par exemple : int taille =
sizeof(struct sockaddr_in);
Macros de conversion des entiers en port
Le problème se pose avec la représentation des entiers : numéro de port et adresse IP de la
structure d’adresse sockaddr_in.
Cette représentation varie suivant les plates-formes de travail :
•
Big-endian : poids fort puis poids faible
•
Little-endian : poids faible puis poids fort
Les protocoles de la famille TCP/IP travaillent sur des entiers de type Big-endian. On utilise les
macros ci-dessous de conversion pour représenter les entiers de numéro de port et d’adresse IP.
: entier long, représentation hôte  représentation réseau (Host to Network long)
Htons(x) : entier court, représentation hôte  représentation réseau (Host to Network short)
Htohl(x) : entier long, représentation réseau  représentation hôte (Host to Host long)
Htohs(x) : entier court, représentation réseau  représentation hôte(Host to Host short)
Htonl(x)
SOCKET.odt
16/20
P. TREBOSC
Mise en œuvre de la communication Ethernet par SOCKET Windows
02/12/13
Exemple :
//Déclaration d’un port de communication avec la fonction de transtypage htons()
Int port ;
Htons(port) ;
Transtypage
Transtypage d'adresses IP
inet_addr("200.0.0.1")
Transtypage des tructures d'adresse socket
Voici les différentes façons de transtyper une structure sockaddr_in en sockaddr pour
utilisation dans les API socket :
(SOCKADDR*) &SockPassiveAddr
ou
(LPSOCKADDR) &SockPassiveAddr
ou
(struct sockaddr*) &SockPassiveAddr
7 Synoptique de mise en œuvre et de test
Etape 1
Créer un projet sous Builder qui contient une feuille TFIHM pour l'interface graphique Homme
Machine.
Ajouter une unité ClsUtilSocket (c'est à dire un .cpp et un .h) et ClsServeurSocket ou
ClsClientSocket (suivant l'application développée) pour contenir les classes de métier de travail
avec les Sockets.
SOCKET.odt
17/20
P. TREBOSC
Mise en œuvre de la communication Ethernet par SOCKET Windows
02/12/13
Etape 2
Créer la composition bidirectionnelle entre le formulaire de l'interface graphique et l'objet de
métier : la classe serveur ou client.
Créer l'héritage entre les classes
ClsClientSocket
ClsUtilSocket et les classes
ClsServeurSocket ou
ClsUtilSocket
Tout ce qui est
commun
aux deux applications
client et serveur
TFIHM
ClsServeurSocket
L'interface
graphique
Homme-machine
Ce qui est spécifique
au serveur socket
On peut faire une seule classe qui fait client et serveur et qui se configure suivant l'application.
Etape 3 : développement
Serveur
Vérifier la version de la DLL Windows
Client
Démarrage socket
Déclaration d'une socket passive d'attente de connexion pour le serveur et socket de
communication pour le client
Application du principe de communication SOCKET
voir synoptique
SOCKET.odt
18/20
P. TREBOSC
Mise en œuvre de la communication Ethernet par SOCKET Windows
02/12/13
Remarque
Il est possible de créer une classe fermer() différente dans la classe serveur de la classe fermer() de
la classe clsUtilSocket. On utilise le polymorphisme de méthode.
Dans fermer() de la classe clsServeur, on ferme deux sockets, la socket passive et la socket active.
Dans fermer() de la classe clsUtilSocket, on ferme une socket, ce qui est le cas pour le cas d'un
client.
8 Option de compilation pour l'utilisation de la librairie socket
avec Visuel studio
#pragma warning(disable : 4996)
#include <winsock.h>
//Option de compilation
#pragma comment(lib, "wsock32.lib")
//ou
//#include <winsock2.h>
//#pragma comment(lib, "ws2_32.lib")
Ne pas oublier de modifier la propriété du projet : Prise en charge du Common Langage
Runtime ) /clr
Pour obtenir une aide en ligne spécifique au API socket tapez par exemple dans index :
pour VS 2008 : connect function [Winsock]
pour VS 2010 : connect Function (Windows)
Transformation d'une String en char*
StringToHGlobalAnsi copie les contenus d'un objet managé String dans le segment natif et puis
le convertit, au format ANSI à la volée (American National Standards Institute) . Cette méthode
alloue de la mémoire de tas natif requis :
//using namespace System::Runtime::InteropServices;
System::String ^ str = "Hello world";
char* str2 = (char*)(void*)Marshal::StringToHGlobalAnsi(str);
printf(str2);
//Libère la mémoire précédemment allouée de la mémoire non managée
Marshal::FreeHGlobal(safe_cast<IntPtr>(str2));
SOCKET.odt
19/20
P. TREBOSC
Mise en œuvre de la communication Ethernet par SOCKET Windows
02/12/13
9 Définition du standard de programmation pour Visual studio
La ligne de définition de l'option de précompilation ci-dessous est défini graphiquement*.
#pragma comment(lib, "wsock32.lib")
Rajouter la dépendance wsock32.lib
dans modifier rajouter wsock32.lib
SOCKET.odt
20/20
P. TREBOSC