Initiation à la programmation réseau sous Windows

Comme nous l'avons déjà dit dans le paragraphe précédent, tous les protocoles n'opèrent pas forcément au même niveau. C'est la raison pour laquelle on utilise toujours un modèle en couches lorsque l'on étudie les réseaux. Le modèle OSI, un standard développé par l'ISO afin de normaliser les communications entre les machines, en comporte 7 allant de la couche physique, qui correspond au niveau le plus bas, à la couche « application » qui correspond au niveau le plus élevé. Sur Internet, de nombreux protocoles sont utilisés dont TCP (Transmission Control Protocol) et IP (Internet Protocol). Cette suite de protocole est connue sous le nom de TCP/IP, du nom de deux des protocoles les plus importants de la série : TCP et IP.

On distingue généralement deux types de communications entre les éléments d'un réseau (et non nécessairement un réseau informatique) : les communications en mode connecté et les communications en mode non connecté. La communication en mode connecté est comparable à la communication au téléphone : un programme demande à un autre d'établir une connexion et si ce dernier accepte, la connexion est effectivement établie et la communication entre les deux programmes peut se faire tant que la connexion reste active. En mode non connecté, un programme envoie des données à destination d'un autre programme qui se trouve généralement sur une autre machine sans établir une connexion (l'adresse de destination doit donc toujours être spécifiée à chaque expédition). Ce type de communication est comparable à la communication par courrier. TCP est un exemple de protocole orienté connexion et UDP un exemple de protocole non orienté connexion. Tous deux font partie de la saga TCP/IP.

II-C-1. TCP▲

II-C-2. IP▲

II-C-3. Les protocoles de la couche application▲

II-D-1. En mode connecté▲

II-D-2. En mode non connecté▲

II-E-1. Généralités▲

II-E-2. Les sockets sous Windows▲

#include <winsock2.h>

int main()
{
    WSADATA wsaData;
    
    if (WSAStartup(MAKEWORD(2, 0), &wsaData) != 0)
        /* La fonction WSAStartup a échoué */ ;
    else
    {
        /* ... On peut continuer ... */
        
        /*, Mais il faut appeler WSACleanup a la fin */
        WSACleanup();
    }        

    return 0;
}

Nous allons créer un programme qui va se connecter sur la machine locale (127.0.0.1), sur le port 5050 et qui, une fois connecté, va attendre un message de bienvenue venant du serveur, afficher ce message puis envoyer une réponse au serveur.

La fonction qui permet de créer un socket est socket :

SOCKET socket(int pf, int type, int protocol);

Le premier argument, pf pour protocol family, spécifie la famille de protocoles que le socket doit supporter, dans notre cas : PF_INET (TCP/IP). Cependant, sachez qu'à chaque famille de protocoles correspond une famille d'adresses (chaque architecture est caractérisée par son système d'adressage, sur Internet on utilise l'adressage IP), c'est pourquoi on dit aussi que le premier argument de la fonction socket spécifie la famille d'adresses (en abrégé af pour address family) à utiliser avec le socket. Dans notre cas, on peut donc remplacer PF_INET par AF_INET. D'ailleurs, en fait, PF_INET = AF_INET.

Le deuxième argument, type, permet de spécifier le type du socket. Dans le cas d'un socket PF_INET, on a au moins le choix entre SOCK_STREAM qui permet de créer un socket orienté connexion et SOCK_DGRAM qui permet de créer un socket non orienté connexion. Pour cet exemple, nous allons créer un socket orienté connexion c'est-à-dire de type SOCK_STREAM.

Et enfin le dernier argument, protocol, spécifie le protocole à utiliser avec le socket. Nous pourrons par exemple choisir TCP (IPPROTO_TCP) pour un socket Internet (PF_INET) orienté connexion (SOCK_STREAM) et UDP (IPPROTO_UDP) pour un socket non orienté connexion. La valeur 0 est également acceptée et dans ce cas la fonction va choisir elle-même le protocole qui va le mieux avec notre socket vu les valeurs que nous avons spécifiées dans les deux premiers arguments.

SOCKET s;

s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
if (s == INVALID_SOCKET)
    /* La fonction socket a échoué */ ;
else
{
    /* ... On continue ... */
    
    /*, Mais il faut liberer le socket a la fin */
    closesocket(s);
}

Maintenant, nous allons connecter ce socket au port 5050 de 127.0.0.1. Nous allons donc dans un premier temps décrire la machine avec laquelle on veut établir une connexion à l'aide d'une structure de type SOCKADDR_IN (struct sockaddr_in), ensuite appeler la fonction connect qui va effectivement faire le lien entre notre socket et le serveur.

SOCKADDR_IN server;

server.sin_family       = AF_INET;
server.sin_addr.s_addr  = inet_addr("127.0.0.1");
server.sin_port         = htons(5050);
memset(&server.sin_zero, '\0', sizeof(server.sin_zero));

if (connect(s, (SOCKADDR *)&server, sizeof(server)) == SOCKET_ERROR)
    /* La fonction connect a échoué */ ;
else
{
    /* Connexion réussie ! */
}

Le champ sin_addr de la structure SOCKADDR_IN qui est censé contenir l'adresse proprement dite n'est pas de type entier. C’est une structure de type IN_ADDR (struct in_addr) qui est composée seulement d'un champ, S_un, qui est une union entre trois objets de types différents, permettant chacun de stocker une adresse IP. Parmi eux, on notera S_addr qui est de type entier long. s_addr est en fait un raccourci (un #define) vers S_un.S_addr. La fonction inet_addr permet de convertir une chaîne contenant une adresse IP en un entier représentant cette adresse. Et enfin, le champ sin_zero est inutilisé, mais il doit être mis à zéro. Il ne sert qu'à faire en sorte que les structures SOCKADDR (présentée plus bas) et SOCKADDR_IN aient la même taille.

La fonction htons (host to netwok short) permet de réarranger l'ordre des octets de l'entier (unsigned short) passé en argument de façon à ce qu'il corresponde au format requis sur le réseau. En effet, sur les machines x86 par exemple, les octets sont rangés en mémoire en commençant par l'octet de poids le plus faible. On appelle ce format little-endian. Or sur le réseau c'est complètement l'inverse : les octets sont rangés en commençant par l'octet de poids le plus fort. C'est le format big-endian. htons fera en sorte, quel que soit le format utilisé sur votre machine, que les octets soient rangés dans le bon ordre. Il y a aussi la fonction ntohs (netwok to host short) qui réalise l'inverse et htonl et ntohl qui s'utilisent de la même façon que les deux premiers, mais avec des arguments de type unsigned long. Sachez également que l'entier retourné par inet_addr est déjà au format réseau (big-endian), c'est pourquoi il ne faut plus appeler htonl (sinon l'ordre des octets sera à nouveau inversé …).

SOCKADDR (struct sockaddr) est une structure générique permettant de décrire n'importe quelle adresse (c'est-à-dire indépendamment du protocole utilisé). Le cast de &server en SOCKADDR * est nécessaire car la conversion de SOCKADDR_IN * à SOCKADDR * ne peut se faire implicitement.

Maintenant, on va attendre le message du serveur puis lui envoyer une réponse après avoir affiché ce message. Il est donc temps de parler des fonctions permettant d'envoyer ou de recevoir des données à travers un socket, à savoir send et recv en mode connecté et sendto et recvfrom en mode non connecté. Dans notre cas, c'est recv et send qu'il faut utiliser.

int send(SOCKET s, const char * buf, int len, int flags);
int recv(SOCKET s, char * buf, int len, int flags);

On constate à quel point ces fonctions sont voisines des fonctions read et write (ou si vous voulez, fread et fwrite). Le seul argument qui mérite d'être commenté est donc l'argument flags. Cet argument est rarement utilisé (la plupart du temps on met tout simplement 0), mais son rôle est de spécifier la manière de réaliser l'opération actuelle. Par exemple dans un recv, le flag MSG_PEEK permet de ne pas retirer les données du tampon de lecture après leur lecture. Dans un send, MSG_DONTROUTE permet de spécifier que les données ne doivent pas être routées. Et enfin, tout comme read et write, ces fonctions retournent le nombre d'octets effectivement lus / écrits ou SOCKET_ERROR en cas d'erreur.

Avant de fermer (c'est-à-dire libérer) le socket, il faut tout d'abord se déconnecter du serveur à l'aide de la fonction shutdown.

int shutdown(SOCKET s, int how);

Si how = SD_SEND, il ne sera plus possible d'écrire sur le socket. En particulier, si le socket utilise le protocole TCP et que le tampon d'écriture associé au socket n'est pas vide (ce qui signifie qu'il reste encore des données à transmettre), la fonction patientera jusqu'à ce que ce tampon soit complètement vidé (et les données arrivées à destination) avant d’émettre la demande de déconnexion. Une autre manière permettant d'initier une demande de déconnexion est d'utiliser la fonction WSASendDisconnect, mais cette fonction est spécifique de l'API Windows …

Lorsque nous avons bien été déconnectés, c'est à ce moment et à ce moment seulement que l'on peut fermer (libérer) le socket. Cela est réalisé par la fonction closesocket (close sous UNIX puisqu'un socket n'est ni plus ni moins qu'un descripteur de fichier).

Un exemple valant mille mots, voici le code complet de notre programme « client » :

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

int main()
{
    WSADATA wsaData;

    if (WSAStartup(MAKEWORD(2, 0), &wsaData) != 0)
        fprintf(stderr, "La fonction WSAStartup a échoué.\n");
    else
    {
        SOCKET s;
        
        s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (s == INVALID_SOCKET)
            fprintf(stderr, "La fonction socket a échoué.\n");
        else
        {
            SOCKADDR_IN server;
            
            server.sin_family       = AF_INET;
            server.sin_addr.s_addr  = inet_addr("127.0.0.1");
            server.sin_port         = htons(5050);
            memset(&server.sin_zero, '\0', sizeof(server.sin_zero));
            
            if (connect(s, (SOCKADDR *)&server, sizeof(server)) == SOCKET_ERROR)
                fprintf(stderr, "La fonction connect a échoué.\n");
            else
            {
                char buffer[100];
                int n;
                
                n = recv(s, buffer, sizeof(buffer) - 1, 0); /* Lire tout au plus sizeof(buffer) - 1 octets */
                /* Il faut réserver le dernier octet pour le caractère de fin de chaîne, '\0'.             */
                
                if (n != SOCKET_ERROR)
                {
                    buffer[n] = '\0';
                    printf("%s", buffer);
                    
                    send(s, "Au revoir\n", (int)strlen("Au revoir\n"), 0);
                }
                
                shutdown(s, SD_SEND);
            }
            
            closesocket(s);
        }
        
        WSACleanup();
    }
    
    return 0;
}

Le cast du strlen dans le send sert tout simplement à supprimer le warning insupportable de certains compilateurs aboyant que la conversion d'une donnée de type size_t en int peut entraîner des pertes de données. Donc si ce message ne vous gêne pas ou tout simplement si vous ne l'avez pas, vous pouvez très bien le supprimer.

Nous allons à présent créer un serveur qui va écouter sur le port 5050 en attente d'une demande de connexion de la part d'un client. Le cas échéant, la connexion sera acceptée, un message de bienvenue sera envoyé puis lorsque le client aura répondu, le programme se terminera. Bien entendu, un vrai serveur ne se termine pas de cette façon, mais on verra ce détail plus tard.

Nous avons déjà presque tout dit des sockets (enfin je veux dire des bases) dans le paragraphe précédent, mais il y a encore quelques notions sur les serveurs qui n'ont pas encore été présentées. Comme nous le savons bien, une machine peut posséder plusieurs interfaces réseau (ou cartes réseau). À chaque interface peut être associée une adresse IP. Lorsqu'un serveur se met en marche, il doit choisir sur quelle interface (et quel port) il veut écouter, c'est-à-dire attendre les demandes de connexion. Donc si une machine possède deux interfaces, A et B, et qu'un client vient se connecter sur A alors que le serveur écoute sur B, leurs chemins ne se croiseront pas. Or, généralement, on veut que le serveur soit capable d'accepter toutes les demandes de connexion arrivant sur n'importe quelle interface de la machine. Alors que faire ? Eh bien, on met tout simplement INADDR_ANY (0) dans le champ adresse (sin_adrr.s_addr) de la structure SOCKADDR_IN. Ensuite, un serveur n'appelle pas connect mais plutôt accept, qui est une fonction qui permet de rester en attente d'une demande de connexion. Mais avant de faire un accept sur un socket, il faut que celui-ci ait déjà été correctement attaché à un port (comme avec connect) et que ce port soit déjà sur écoute, ce que l'on peut faire respectivement à l'aide des fonctions bind et listen. Donc vous voyez bien qu'un serveur n'est pas plus compliqué qu'un client.

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

int main()
{
    WSADATA wsaData;

    if (WSAStartup(MAKEWORD(2, 0), &wsaData) != 0)
        fprintf(stderr, "La fonction WSAStartup a échoué.\n");
    else
    {
        SOCKET s_server;
        
        s_server = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (s_server == INVALID_SOCKET)
            fprintf(stderr, "La fonction socket a échoué.\n");
        else
        {
            SOCKADDR_IN server;
            
            server.sin_family       = AF_INET;
            server.sin_addr.s_addr  = htonl(INADDR_ANY);
            server.sin_port         = htons(5050);
            memset(&server.sin_zero, '\0', sizeof(server.sin_zero));
            
            if (bind(s_server, (SOCKADDR *)&server, sizeof(server)) == SOCKET_ERROR)
                fprintf(stderr, "La fonction bind a échoué.\n");
            else
            {
                if (listen(s_server, 0) == SOCKET_ERROR) /* listen : commencer l'écoute */
                    fprintf(stderr, "La fonction listen a échoué.\n");
                else
                {
                    SOCKET s_client;
                    SOCKADDR_IN client;
                    int csize = sizeof(client);
                    
                    s_client = accept(s_server, (SOCKADDR *)&client, &csize);
                    
                    if (s_client == INVALID_SOCKET)
                        fprintf(stderr, "La fonction accept a échoué.\n");
                    else
                    {
                        char buffer[100];
                        int n;
                        
                        printf("Le client %s s'est connecté !\n", inet_ntoa(client.sin_addr));
                        
                        strcpy(buffer, "Bonjour\n");
                        send(s_client, buffer, (int)strlen(buffer), 0);
                        
                        n = recv(s_client, buffer, sizeof(buffer) - 1, 0);
                        
                        if (n != SOCKET_ERROR)
                        {
                            buffer[n] = '\0';
                            printf("%s", buffer);
                        }
                        
                        closesocket(s_client);
                    }
                }
            }
            
            closesocket(s_server);
        }
        
        WSACleanup();
    }
    
    return 0;
}

Le second paramètre de la fonction listen s'appelle le backlog. Il indique le nombre maximal de demandes de connexion qu'il peut y avoir dans la file d'attente. En effet, la fonction accept ne traite qu'une seule demande à la fois. Or, pendant que le serveur est en train de traiter cette demande, il y en a d'autres qui peuvent arriver. Ces dernières seront alors placées dans une file d'attente. Ainsi, si le backlog vaut quatre et que quatre demandes de connexion sont déjà en file d'attente, une cinquième demande sera immédiatement refusée. Si le backlog vaut zéro, aucune limite théorique n'est imposée.

Les deux derniers arguments de accept ne sont pas obligatoires (si vous ne les utilisez pas, mettez donc NULL), mais ils permettent de récupérer des informations utiles comme on peut d'ailleurs le constater dans l'exemple. D'ailleurs, on pourra toujours récupérer ces mêmes informations à n'importe quel moment grâce à la fonction getpeername.

La fonction inet_ntoa permet de convertir une adresse représentée par une structure IN_ADDR en chaîne de caractères, dans le format usuel (xxx.xxx.xxx.xxx).

Enfin, sachez qu'un serveur peut également initier la déconnexion d'un client en appelant toujours shutdown sur le socket identifiant le client avec SD_SEND. Ici, il n'était pas vraiment nécessaire d'appeler shutdown car le dernier send du serveur est suivi d'un recv bloquant (c'est le client qui aura le dernier mot !).

Les protocoles utilisés sur Internet sont spécifiés par des documents internationaux appelés RFC (Request For Comments). Ils sont très nombreux et disponibles en téléchargement sur de nombreux sites, dont celui de l'IETF : http://www.ietf.org/.

À l'aide de la fonction gethostname.

int gethostname(char * name, int namelen);

À l'aide de la fonction gethostbyname.

struct hostent * gethostbyname(const char * name);

Cette fonction retourne un pointeur vers une structure de type HOSTENT (struct hostent). Cette structure contient des informations concernant un hôte donné, dont celle qui nous intéresse ici, son adresse. Le programme suivant demande à l'utilisateur d'entrer une chaîne de caractères (sans espace) et affiche l'adresse IP de la machine dont le nom correspond à cette chaîne ou un message d'erreur.

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

int main()
{
    WSADATA wsaData;
    
    if (WSAStartup(MAKEWORD(2, 0), &wsaData) != 0)
        fprintf(stderr, "La fonction WSAStartup a échoué.\n");
    else
    {
        char s[100];
        HOSTENT * h;
        
        printf("Entrez le nom de la machine : "); /* exemples : localhost, developpez.com, www.developpez.com, etc. */
        scanf("%99s", s);
        h = gethostbyname(s);
        
        if (h == NULL)
            fprintf(stderr, "L’hôte '%s' n'a pas pu être trouvé.\n", s);
        else
        {
            /* Supposons que l'adresse de la machine soit 127.0.0.1 */
            /* Alors : h->h_addr_list[0][0] = 127 (1 octet) */
            /*         h->h_addr_list[0][1] = 0   (1 octet) */
            /*         h->h_addr_list[0][2] = 0   (1 octet) */
            /*         h->h_addr_list[0][3] = 1   (1 octet) */
            
            IN_ADDR addr; /* rappel : 'ULONG addr.s_addr;' (4 octets) */
            memcpy(&addr.s_addr, h->h_addr_list[0], sizeof(addr.s_addr));
            
            printf("%s\n", inet_ntoa(addr));
        }
        
        WSACleanup();
    }
    
    return 0;
}

Le champ h_addr_list est un tableau contenant une liste d'adresses permettant chacune d'identifier l'hôte (en effet un hôte peut posséder plusieurs adresses logiques). Le dernier élément de ce tableau est un pointeur nul (NULL). La macro h_addr est également définie et correspond à h_addr_list[0]. Sous Windows uniquement, il existe une fonction plus à la mode, getaddrinfo, permettant d'avoir plus d'informations (cette fonction n'existe pas sous UNIX).

Cette question se pose souvent quand on a affaire à un serveur. La fonction accept permet d'associer un socket à un client accepté et de récupérer en même temps l'adresse du client (deuxième et troisième arguments). Si jamais on a oublié de récupérer cette adresse au moment de l'accept, on pourra toujours les obtenir plus tard à l'aide de la fonction getpeername.

int getpeername(SOCKET s, struct sockaddr * name, int * namelen);

Remarquez bien que les deux derniers arguments sont exactement les mêmes que ceux d'accept …

Nous avons vu d'après les exemples précédents que certaines fonctions comme recv ou accept ne répondent que lorsque des données arrivent sur le socket. Les applications client/serveur sont donc généralement multithreadées (une application multithreadée est une application qui réalise plusieurs tâches (thread) en même temps) afin de pouvoir traiter en même temps les événements qui se produisent sur le réseau d'une part et les entrées de l'utilisateur d'autre part. Mais il existe également d'autres méthodes, plus ou moins basées sur l'utilisation des sockets non bloquants. Ce sont ces méthodes que nous allons étudier dans cette partie.

Lorsqu'un socket est créé, celui-ci est dans le mode par défaut qui n'est autre que le mode bloquant. Pour mettre un socket en mode non bloquant, il suffit d'appeler la fonction ioctlsocket (et là encore, ioctl sous UNIX étant donné qu'un socket n'est ni plus ni moins qu'un descripteur de fichier …) sur ce socket en fournissant les bons paramètres (nous y reviendrons tout à l'heure). Lorsqu'un socket est en mode non bloquant, les fonctions comme recv, accept, etc. renvoient immédiatement après l'appel si les données ont pu être lues ou non. Si aucune donnée n'a pu être lue, la fonction retournera une valeur indiquant une erreur et WSAGetLastError retournera WSAEWOULDBLOCK. L'extrait de code suivant montre comment rendre un socket (s) non bloquant.

ULONG fionbio = TRUE;
ioctlsocket(s, FIONBIO, &fionbio);

La fonction setsockopt permet d'ajuster certaines options d'un socket comme le délai d'attente des fonctions de lecture par exemple. Lorsqu'un tel délai a été fixé, si aucune donnée n'arrive durant la période spécifiée, la fonction échoue et WSAGetLastError retourne WSATIMEDOUT. On peut également fixer un tel délai aux fonctions d'écriture. Évidemment, toutes ces manœuvres n'ont d'intérêt que sur des sockets bloquants puisqu'un socket non bloquant est déjà … non bloquant.

int setsockopt(SOCKET s, int level, int optname, const char * optval, int optlen);

L'argument level indique à quel niveau (par exemple SOL_SOCKET) se situe l'option (optname) que l'on veut modifier. L'extrait de code suivant montre comment accorder 2 secondes aux fonctions de lecture pour compléter leur opération.

DWORD timeo = 2000; /* 2000 ms */
setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeo, sizeof(timeo));

Windows permet d'associer un message à chaque événement se produisant sur un socket (arrivée de données, arrivée d'une demande de connexion, etc.). Cela permet de développer des programmes très structurés et facilement maintenables. Il existe également d'autres techniques similaires, mais plus difficiles à mettre en œuvre, c'est pourquoi nous ne parlerons ici que de la première.

Cette technique se résume en fait à l'utilisation d'une et une seule fonction en plus : WSAAsyncSelect.

int WSAAsyncSelect(SOCKET s, HWND hWnd, unsigned int wMsg, long lEvent);

wMsg est le message qu'on veut associer avec le socket et lEvent une combinaison de valeurs indiquant les différents événements autorisés à provoquer l'envoi du message. Les valeurs les plus utilisées sont :

• FD_ACCEPT : permet d'être notifié de la présence d'une demande de connexion ;
• FD_READ : permet d'être notifié de la présence de données dans le tampon de lecture ; associé au socket
• FD_WRITE : permet d'être notifié lorsque le socket peut être écrit ;
• FD_CLOSE : permet d'être notifié de la fermeture d'une connexion.

Par exemple :

#define WM_NETEVENT (WM_APP + 1)

...

WSAAsyncSelect(s, hWnd, WM_NETEVENT, FD_READ | FD_WRITE);

Permet d'ordonner à Windows de nous envoyer le message WM_NETEVENT à travers la fenêtre hWnd chaque fois qu'un événement FD_READ ou FD_WRITE se produit sur le socket s.

Après un appel réussi à WSAAsyncSelect, le socket que l'on a utilisé devient non bloquant (tant mieux !). Lorsqu'un message est envoyé à la fenêtre, on a :

• Dans wParam : le socket sur lequel l'événement s'est produit ;
• LOWORD(lParam) : l'événement qui s'est produit (FD_XXX) ;
• HIWORD(lParam) : un code d'erreur.

Les macros WSAGETSELECTEVENT et WSAGETSELECTERROR (nécessitent tous lParam en paramètre) permettent de récupérer respectivement la description de l'événement et le code d'erreur avec un niveau d'abstraction plus élevé.

Pour terminer, sachez également qu'un socket retourné par accept a les mêmes propriétés que le socket d'écoute, c'est-à-dire comme si le même WSAAsyncSelect avait été aussi appliqué au nouveau socket. Rien ne nous empêche cependant de modifier les propriétés au socket ainsi créé.