TP Sockets TCP Linux

TP Dveloppement Rseau : Socket TCP (Linux)
2012 tv <tvaira@free.fr> - v.1.0
Sommaire
Linterface socket 2
Pr-requis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
Dfinition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
Manuel du pogrammeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
Modle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Couche Transport . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Numro de ports . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Caractristiques des sockets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Manipulations 5
Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
tape n1 : cration de la socket (ct client) . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
tape n2 : connexion au serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
tape n3 : vrification du bon fonctionnement de la connexion . . . . . . . . . . . . . . . . . 9
tape n4 : change des donnes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
tape n5 : ralisation dun serveur TCP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
tape n6 : mise en attente des connexions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
tape n7 : accepter les demandes connexions . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Bilan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Questions de rvision 24
Les objectifs de ce tp sont de mettre en oeuvre la programmation rseau en utilisant

linterface socket pour le mode connect (TCP) sous Linux.
Remarque : les tp ont pour but dtablir ou de renforcer vos comptences pratiques. Vous pouvez penser
que vous comprenez tout ce que vous lisez ou tout ce que vous a dit votre enseignant mais la rptition et
la pratique sont ncessaires pour dvelopper des comptences en programmation. Ceci est comparable au
sport ou la musique ou tout autre mtier demandant un long entranement pour acqurir lhabilet
ncessaire. Imaginez quelquun qui voudrait disputer une compttion dans lun de ces domaines sans
pratique rgulire. Vous savez bien quel serait le rsultat.
1
LINTERFACE SOCKET
Linterface socket
Pr-requis
La mise en oeuvre de linterface socket ncessite de connatre :
Larchitecture client/serveur
Ladressage IP et les numros de port
Notions dAPI (appels systmes sous Unix) et de programmation en langage C
Les protocoles TCP et UDP, les modes connect et non connect
Dfinition
La notion de socket a t introduite dans les distributions de Berkeley (un fameux
systme de type UNIX, dont beaucoup de distributions actuelles utilisent des morceaux
de code), cest la raison pour laquelle on parle parfois de sockets BSD (Berkeley Software
Distribution).
Intgration d'IP dans Unix BSD (1981)

Interface de programmation socket de Berkeley (1982) : la plus utilise et intgre dans le noyau
Il sagit dun modle permettant la communication inter processus (IPC - Inter Process Communication)
afin de permettre divers processus de communiquer aussi bien sur une mme machine qu travers un
rseau TCP/IP. [Wikipedia]
Socket : mcanisme de communication bidirectionelle entre processus
Manuel du pogrammeur
Le dveloppeur utilisera donc concrtement une interface pour programmer une application TCP/IP
grce par exemple :
lAPI Socket BSD sous Unix/Linux ou
lAPI WinSocket sous Microsoft Windows
Les pages man principales sous Unix/Linux concernant la programmation rseau sont regroupes dans le
chapitre 7 :
socket(7) : interface de programmation des sockets
packet(7) : interface par paquet au niveau priphrique
raw(7) : sockets brutes (raw) IPv4 sous Linux
ip(7) : implmentation Linux du protocole IPv4
udp(7) : protocole UDP pour IPv4
tcp(7) : protocole TCP
L'accs aux pages man se fera donc avec la commande man, par exemple : man 7 socket
Pour Microsoft Windows, on pourra utiliser le service en ligne MSDN :

Windows Socket 2 : msdn.microsoft.com/en-us/library/ms740673(VS.85).aspx
Les fonctions Socket : msdn.microsoft.com/en-us/library/ms741394(VS.85).aspx
TP Dveloppement Rseau : Socket TCP (Linux) 2 / 24 2012 tv <tvaira@free.fr>

LINTERFACE SOCKET
Modle
Rappel : une socket est un point de communication par lequel un processus peut mettre et recevoir des
donnes.
Ce point de communication devra tre reli une adresse IP et un numro de port dans le cas des
protocoles Internet.
Une socket est communment reprsente comme un point dentre initial au niveau TRANSPORT du
modle couches DoD dans la pile de protocole.
Exemple de processus TCP et UDP

LINTERFACE SOCKET
Couche Transport
Rappel : la couche Transport est responsable du transport des messages complets de bout en bout (soit
de processus processus) au travers du rseau.
En programmation, si on utilise comme point dentre initial le niveau TRANSPORT, il faudra alors
choisir un des deux protocoles de cette couche :
TCP (Transmission Control Protocol) est un protocole de transport fiable, en mode connect (RFC
793).
UDP (User Datagram Protocol) est un protocole souvent dcrit comme tant non-fiable, en mode
non-connect (RFC 768), mais plus rapide que TCP.
Numro de ports
Rappel : un numro de port sert identifier un processus (lapplication) en cours de communication
par lintermdiaire de son protocole de couche application (associ au service utilis, exemple : 80 pour
HTTP).
Pour chaque port, un numro lui est attribu (cod sur 16 bits), ce qui implique qu'il existe un maximum
de 65 536 ports (216 ) par machine et par protocoles TCP et UDP.
Lattribution des ports est faite par le systme dexploitation, sur demande dune application. Ici, il faut
distinguer les deux situations suivantes :
cas dun processus client : le numro de port utilis par le client sera envoy au processus serveur.
Dans ce cas, le processus client peut demander ce que le systme dexploitation lui attribue nimporte
quel port, condition quil ne soit pas dj attribu.
cas dun processus serveur : le numro de port utilis par le serveur doit tre connu du processus client.
Dans ce cas, le processus serveur doit demander un numro de port prcis au systme dexploitation
qui vrifiera seulement si ce numro nest pas dj attribu.
Une liste des ports dits rservs est disponible dans le chier /etc/services sous Unix/Linux.
Caractristiques des sockets

Rappel : les sockets compatibles BSD reprsentent une interface uniforme entre le processus utilisateur
(user) et les piles de protocoles rseau dans le noyau (kernel) de lOS.
Pour dialoguer, chaque processus devra pralablement crer une socket de communication en indiquant :
le domaine de communication : ceci slectionne la famille de protocole employer. Il faut savoir que
chaque famille possde son adressage. Par exemple pour les protocoles Internet IPv4, on utilisera le
domaine PF_INET ou AF_INET.
le type de socket utiliser pour le dialogue. Pour PF_INET, on aura le choix entre : SOCK_STREAM (qui
correspond un mode connect), SOCK_DGRAM (qui correspond un mode non connect) ou SOCK_RAW
(qui permet un accs direct aux protocoles de la couche Rseau comme IP, ICMP, ...).
le protocole utiliser sur la socket. Le numro de protocole dpend du domaine de communication et
du type de la socket. Normalement, il ny a quun seul protocole par type de socket pour une famille
donne (SOCK_STREAM TCP et SOCK_DGRAM UDP). Nanmoins, rien ne soppose ce que plusieurs
protocoles existent, auquel cas il est ncessaire de le spcifier (cest la cas pour SOCK_RAW o il faudra
prciser le protocole utiliser).

MANIPULATIONS
Une socket appartient une famille. Il existe plusieurs types de sockets. Chaque famille possde son
adressage.
Manipulations
Objectifs
Lobjectif de cette partie est la mise en oeuvre dune communication client/serveur en utilisant une socket
TCP sous Unix/Linux.
tape n1 : cration de la socket (ct client)

Pour crer une socket, on utilisera lappel systme socket(). On commence par consulter la page du
manuel associe cet appel :
$ man 2 socket
SOCKET(2) Manuel du programmeur Linux SOCKET(2)
NOM
socket - Crer un point de communication
SYNOPSIS
#include <sys/types.h> /* Voir NOTES */
#include <sys/socket.h>
int socket(int domain, int type, int protocol);
DESCRIPTION
socket() cre un point de communication, et renvoie un descripteur.
...
VALEUR RENVOYE
Cet appel systme renvoie un descripteur rfrenant la socket cre sil russit.
Sil choue, il renvoie -1 et errno contient le code derreur.
...
Extrait de la page man de lappel systme socket
laide dun diteur de texte (vi, vim, emacs, kwrite, kate, gedit, ... sous Linux), tapez ( la main, pas
de copier/coller, histoire de bien mmoriser !) le programme suivant dans un fichier que vous nommerez
"clientTCP-1.c" :
#include <stdio.h>
#include <stdlib.h> /* pour exit */
#include <sys/types.h>
int main()
{
int descripteurSocket;

MANIPULATIONS
//--- Dbut de ltape n1 :

// Cre un socket de communication
descripteurSocket = socket(PF_INET, SOCK_STREAM, 0); /* 0 indique que lon utilisera le
protocole par dfaut associ SOCK_STREAM soit TCP */
// Teste la valeur renvoye par lappel systme socket()

if(descripteurSocket < 0) /* chec ? */
{
perror("socket"); // Affiche le message derreur
exit(-1); // On sort en indiquant un code erreur
}
//--Fin de ltape n1 !
printf("Socket cre avec succs ! (%d)\n", descripteurSocket);
// On ferme la ressource avant de quitter

close(descripteurSocket);
return 0;
}
Un client TCP en C (itration 1)
Pour le paramtre protocol, on a utilis la valeur 0 (voir commentaire). On aurait pu prciser le protocole
TCP de la manire suivante : IPPROTO_TCP.
tape n2 : connexion au serveur

Maintenant que nous avons cr une socket TCP, il faut la connecter au processus serveur distant.
Pour cela, on va utiliser lappel systme connect(). On consulte la page du manuel associe cet appel :
$ man 2 connect
CONNECT(2) Manuel du programmeur Linux CONNECT(2)
NOM
connect - Dbuter une connexion sur une socket
SYNOPSIS
int connect(int sockfd, const struct sockaddr *serv_addr,

socklen_t addrlen);
DESCRIPTION
Lappel systme connect() connecte la socket rfrence par le descripteur de fichier
sockfd ladresse indique par serv_addr. ...
VALEUR RENVOYE
connect() renvoie 0 sil russit, ou -1 sil choue, auquel cas errno contient le
code derreur. ...
Extrait de la page man de lappel systme connect

MANIPULATIONS
On rappelle que ladressage du processus distant dpend du domaine de communication (cad la famille
de protocole employe). Ici, nous avons choisi le domaine PF_INET pour les protocoles Internet IPv4.
Dans cette famille, un processus sera identifi par :
une adresse IPv4
un numro de port
Linterface socket propose une structure dadresse gnrique :

struct sockaddr
{
unsigned short int sa_family; //au choix
unsigned char sa_data[14]; //en fonction de la famille
};
La structure gnrique sockaddr
Et le domaine PF_INET utilise une structure compatible :

// Remarque : ces structures sont dclares dans <netinet/in.h>
struct in_addr { unsigned int s_addr; }; // une adresse Ipv4 (32 bits)
struct sockaddr_in
{
unsigned short int sin_family; // <- PF_INET
unsigned short int sin_port; // <- numro de port
struct in_addr sin_addr; // <- adresse IPv4
unsigned char sin_zero[8]; // ajustement pour tre compatible avec sockaddr
};
La structure compatible sockaddr_in pour PF_INET
Il suffit donc dinitialiser une structure sockaddr_in avec les informations distantes du serveur (adresse
IPv4 et numro de port).
Pour crire ces informations dans la structure dadresse, il nous faudra utiliser :
inet_aton() pour convertir une adresse IP depuis la notation IPv4 dcimale pointe vers une forme
binaire (dans lordre doctet du rseau)
htons() pour convertir le numro de port (sur 16 bits) depuis lordre des octets de lhte vers celui
du rseau.
L'ordre des octets du rseau est en fait big-endian. Il est donc plus prudent d'appeler des fonctions qui
respectent cet ordre pour coder des informations dans les en-ttes des protocoles rseaux.
diter le programme suivant dans un fichier que vous nommerez "clientTCP-2.c" :

#include <stdio.h>
#include <string.h> /* pour memset */
#include <netinet/in.h> /* pour struct sockaddr_in */
#include <arpa/inet.h> /* pour htons et inet_aton */
int main()

MANIPULATIONS
{
struct sockaddr_in pointDeRencontreDistant;
socklen_t longueurAdresse;

descripteurSocket = socket(PF_INET, SOCK_STREAM, 0);

if(descripteurSocket < 0) {
}

// Obtient la longueur en octets de la structure sockaddr_in
longueurAdresse = sizeof(pointDeRencontreDistant);
// Initialise 0 la structure sockaddr_in
memset(&pointDeRencontreDistant, 0x00, longueurAdresse);
// Renseigne la structure sockaddr_in avec les informations du serveur distant
pointDeRencontreDistant.sin_family = PF_INET;
// On choisit le numro de port dcoute du serveur
pointDeRencontreDistant.sin_port = htons(IPPORT_USERRESERVED); // = 5000
// On choisit ladresse IPv4 du serveur
inet_aton("192.168.52.2", &pointDeRencontreDistant.sin_addr); // modifier selon ses
besoins
// Dbute la connexion vers le processus serveur distant

if((connect(descripteurSocket, (struct sockaddr *)&pointDeRencontreDistant,
longueurAdresse)) == -1)
{
perror("connect"); // Affiche le message derreur
close(descripteurSocket); // On ferme la ressource avant de quitter
}
//--- Fin de ltape n2 !

printf("Connexion au serveur russie avec succs !\n");

return 0;
}
Si vous testez ce client, vous risquez dobtenir :

$ ./clientTCP-2
Socket cre avec succs ! (3)
connect: Connection refused
Ceci peut sexpliquer tout simplement parce quil ny a pas de processus serveur cette adresse !

MANIPULATIONS
tape n3 : vrification du bon fonctionnement de la connexion

Pour tester notre client, il nous faut un serveur ! Pour cela, on va utiliser loutil rseau netcat en mode
serveur (-l) sur le port 5000 (-p 5000) :
$ nc -l -p 5000
Puis :
$ ./clientTCP-2
Connexion au serveur russie avec succs !
Dans l'architecture client/serveur, on rappelle que c'est le client qui a l'initiative de l'change. Il faut donc
que le serveur soit en coute avant que le client fasse sa demande.
tape n4 : change des donnes

On rappelle quune communication TCP est bidirectionnelle full duplex et oriente flux doctets. Il nous
faut donc des fonctions pour crire (envoyer) et lire (recevoir) des octets dans la socket.
Normalement les octets envoys ou reus respectent un protocole de couche APPLICATION. Ici, pour
les tests, notre couche APPLICATION sera vide ! C'est--dire que les donnes envoyes et reues ne
respecteront aucun protocole et ce seront de simples caractres ASCII.
Les fonctions dchanges de donnes sur une socket TCP sont :

read() et write() qui permettent la rception et lenvoi doctets sur un descripteur de socket
recv() et send() qui permettent la rception et lenvoi doctets sur un descripteur de socket avec un
paramtre flags
Les appels recv() et send() sont spciques aux sockets en mode connect. La seule dirence avec
read() et write() est la prsence de flags (cf. man 2 send).
Faire communiquer deux processus sans aucun protocole de couche APPLICATION est tout de mme
difficile ! On va simplement fixer les rgles dchange suivantes :
le client envoie en premier une chane de caractres
et le serveur lui rpondra "ok"
diter le programme suivant dans un fichier que vous nommerez "clientTCP-3.c" :

#include <stdio.h>
#define LG_MESSAGE 256

MANIPULATIONS
int main()
{
char messageEnvoi[LG_MESSAGE]; /* le message de la couche Application ! */
char messageRecu[LG_MESSAGE]; /* le message de la couche Application ! */
int ecrits, lus; /* nb doctets ecrits et lus */
int retour;

descripteurSocket = socket(PF_INET, SOCK_STREAM, 0); /* 0 indique que lon utilisera le

if(descripteurSocket < 0) /* chec ? */
{
}
// Obtient la longueur en octets de la structure sockaddr_in

longueurAdresse = sizeof(pointDeRencontreDistant);
// Initialise 0 la structure sockaddr_in
memset(&pointDeRencontreDistant, 0x00, longueurAdresse);
// Renseigne la structure sockaddr_in avec les informations du serveur distant
pointDeRencontreDistant.sin_family = PF_INET;
// On choisit le numro de port dcoute du serveur
pointDeRencontreDistant.sin_port = htons(IPPORT_USERRESERVED); // = 5000
// On choisit ladresse IPv4 du serveur
inet_aton("192.168.52.2", &pointDeRencontreDistant.sin_addr); // modifier selon ses
besoins
// Dbute la connexion vers le processus serveur distant

if((connect(descripteurSocket, (struct sockaddr *)&pointDeRencontreDistant,
longueurAdresse)) == -1)
{
perror("connect"); // Affiche le message derreur
close(descripteurSocket); // On ferme la ressource avant de quitter
}
printf("Connexion au serveur russie avec succs !\n");

// Initialise 0 les messages
memset(messageEnvoi, 0x00, LG_MESSAGE*sizeof(char));
memset(messageRecu, 0x00, LG_MESSAGE*sizeof(char));
// Envoie un message au serveur

sprintf(messageEnvoi, "Hello world !\n");

MANIPULATIONS
ecrits = write(descripteurSocket, messageEnvoi, strlen(messageEnvoi)); // message

TAILLE variable
switch(ecrits)
{
case -1 : /* une erreur ! */
perror("write");
exit(-3);
case 0 : /* la socket est ferme */
fprintf(stderr, "La socket a t ferme par le serveur !\n\n");
return 0;
default: /* envoi de n octets */
printf("Message %s envoy avec succs (%d octets)\n\n", messageEnvoi, ecrits);
}
/* Reception des donnes du serveur */

lus = read(descripteurSocket, messageRecu, LG_MESSAGE*sizeof(char)); /* attend un message
de TAILLE fixe */
switch(lus)
{
perror("read");
exit(-4);
fprintf(stderr, "La socket a t ferme par le serveur !\n\n");
return 0;
default: /* rception de n octets */
printf("Message reu du serveur : %s (%d octets)\n\n", messageRecu, lus);
}

return 0;
}
On utilise la mme procdure de test que prcdemment en dmarrant un serveur netcat sur le port
5000 :
$ nc -l -p 5000
Puis, on excute notre client :

$ ./clientTCP-3
Message Hello world !
envoy avec succs (14 octets)
Message reu du serveur : ok

MANIPULATIONS
(3 octets)
Dans la console o on a excut le serveur netcat, cela donne :

$ nc -l -p 5000
Hello world !
ok
Dans netcat, pour envoyer des donnes au client, il sut de saisir son message et de valider par la touche
Entre.
Que se passe-t-il si le serveur sarrte (en tapant Ctrl-C par exemple !) au lieu denvoyer
"ok" ?
$ nc -l -p 5000
Hello world !
^C
$ ./clientTCP-3
La socket a t ferme par le serveur !
Notre client a bien dtect la fermeture de la socket ct serveur.

Dans les codes sources ci-dessus, nous avons utiliss lappel close() pour fermer la socket et donc la
communication. En TCP, la communication tant bidirectionnelle full duplex, il est possible de fermer
plus finement lchange en utilisant lappel shutdown() :
$ man 2 shutdown
SHUTDOWN(2) Manuel du programmeur Linux SHUTDOWN(2)
NOM
shutdown - Terminer une communication en full-duplex
SYNOPSIS
int shutdown(int s, int how);
DESCRIPTION
La fonction shutdown() termine tout ou partie dune connexion full-duplex sur la
socket s. Si how vaut SHUT_RD, la rception est dsactive.
Si how vaut SHUT_WR, lmission est dsactive. Si how vaut SHUT_RDWR, lemission et
la rception sont dsactives.
VALEUR RENVOYE
Cet appel systme renvoie 0 sil russit, ou -1 sil choue, auquel cas errno
contient le code derreur.
...
Extrait de la page man de lappel systme shutdown

MANIPULATIONS
tape n5 : ralisation dun serveur TCP

videmment, un serveur TCP a lui aussi besoin de crer une socket SOCK_STREAM dans le domaine PF_INET.
Mis part cela, le code source dun serveur TCP basique est trs diffrent dun client TCP dans le
principe. On va dtailler ces diffrences tape par tape.
On rappelle quun serveur TCP attend des demandes de connexion en provenance de processus client. Le
processus client doit connatre au moment de la connexion le numro de port dcoute du serveur.
Pour mettre en oeuvre cela, le serveur va utiliser lappel systme bind() qui va lui permettre de
lier sa socket dcoute une interface et un numro de port local sa machine.
$ man 2 bind
BIND(2) Manuel du programmeur Linux BIND(2)
NOM
bind - Fournir un nom une socket
SYNOPSIS
int bind(int sockfd, const struct sockaddr *addr,

socklen_t addrlen);
DESCRIPTION
Quand une socket est cre avec lappel systme socket(2), elle existe dans lespace
des noms mais na pas de nom assign). bind() affecte ladresse spcifie dans addr
la socket rfrence par le descripteur de fichier sockfd. addrlen indique la taille,
en octets, de la structure dadresse pointe par addr. Traditionnellement cette
opration est appele affectation dun nom une socket .
Il est normalement ncessaire daffecter une adresse locale avec bind() avant quune
socket SOCK_STREAM puisse recevoir des connexions (voir accept(2)).
Les rgles daffectation de nom varient suivant le domaine de communication.

...
VALEUR RENVOYE
Lappel renvoie 0 sil russit, ou -1 sil choue, auquel cas errno contient le code
derreur.
...
Extrait de la page man de lappel systme bind
On rappelle que ladressage dun processus (local ou distant) dpend du domaine de communication
(cad la famille de protocole employe). Ici, nous avons choisi le domaine PF_INET pour les protocoles
Internet IPv4.
Dans cette famille, un processus sera identifi par :
une adresse IPv4
un numro de port

MANIPULATIONS
Rappel : linterface socket propose une structure dadresse gnrique sockaddr et le domaine PF_INET
utilise une structure compatible sockaddr_in.
Il suffit donc dinitialiser une structure sockaddr_in avec les informations locales du serveur (adresse
IPv4 et numro de port).
Pour crire ces informations dans la structure dadresse, il nous faudra utiliser :
htonl() pour convertir une adresse IP (sur 32 bits) depuis lordre des octets de lhte vers celui du
rseau
htons() pour convertir le numro de port (sur 16 bits) depuis lordre des octets de lhte vers celui du
rseau.
Normalement il faudrait indiquer l'adresse IPv4 de l'interface locale du serveur qui acceptera les demandes
de connexions. Il est ici possible de prciser avec INADDR_ANY que toutes les interfaces locales du serveur
accepteront les demandes de connexion des clients.
diter le programme suivant dans un fichier que vous nommerez "serveurTCP-1.c" :

#include <stdio.h>
#include <unistd.h> /* pour sleep */
#define PORT IPPORT_USERRESERVED // = 5000
int main()
{
int socketEcoute;
struct sockaddr_in pointDeRencontreLocal;

socketEcoute = socket(PF_INET, SOCK_STREAM, 0); /* 0 indique que lon utilisera le

if(socketEcoute < 0) /* chec ? */
{
}
printf("Socket cre avec succs ! (%d)\n", socketEcoute);
// On prpare ladresse dattachement locale

longueurAdresse = sizeof(struct sockaddr_in);
memset(&pointDeRencontreLocal, 0x00, longueurAdresse);
pointDeRencontreLocal.sin_family = PF_INET;

MANIPULATIONS
pointDeRencontreLocal.sin_addr.s_addr = htonl(INADDR_ANY); // toutes les interfaces

locales disponibles
pointDeRencontreLocal.sin_port = htons(PORT); // = 5000
// On demande lattachement local de la socket

if((bind(socketEcoute, (struct sockaddr *)&pointDeRencontreLocal, longueurAdresse)) < 0)
{
perror("bind");
exit(-2);
}

printf("Socket attache avec succs !\n");
// On sendort ... (cf. test)

sleep(2);

close(socketEcoute);
return 0;
}
Un serveur TCP en C (itration 1)
Le test est concluant :

$ ./serveurTCP-1
Socket attache avec succs !
Attention, tout de mme de bien comprendre quun numro de port identifie un processus communiquant !
Excutons deux fois le mme serveur et on obtient alors :
$ ./serveurTCP-1 & ./serveurTCP-1
bind: Address already in use
Explication : l'attachement local au numro de port 5000 du deuxime processus choue car ce numro
de port est dj attribu par le systme d'exploitation au premier processus serveur.

MANIPULATIONS
tape n6 : mise en attente des connexions

Maintenant que le serveur a cr et attach une socket dcoute, il doit la placer en attente passive,
cest--dire capable daccepter les demandes de connexion des processus clients.
Pour cela, on va utiliser lappel systme listen() :
$ man 2 listen
LISTEN(2) Manuel du programmeur Linux LISTEN(2)
NOM
listen - Attendre des connexions sur une socket
SYNOPSIS
int listen(int sockfd, int backlog);
DESCRIPTION
listen() marque la socket rfrence par sockfd comme une socket passive, cest--
dire comme une socket qui sera utilise pour accepter les demandes de connexions
entrantes en utilisant accept().
Largument sockfd est un descripteur de fichier qui fait rfrence une socket de
type SOCK_STREAM.
Largument backlog dfinit une longueur maximale jusqu laquelle la file des
connexions en attente pour sockfd peut crotre. Si une nouvelle connexion arrive
alors que la file est pleine, le client reoit une erreur indiquant ECONNREFUSED,
ou, si le protocole sous-jacent supporte les retransmissions, la requte peut tre
ignore afin quun nouvel essai russisse.
VALEUR RENVOYE
Cet appel systme renvoie 0 si il russit, ou -1 en cas dchec, auquel cas errno est
renseigne en consquence.
...
Extrait de la page man de lappel systme listen
Si la le est pleine, le serveur sera dans une situation de DOS (Deny Of Service ) car il ne peut plus traiter
les nouvelles demandes de connexion.

#include <stdio.h>

MANIPULATIONS
int main()
{
int socketEcoute;


if(socketEcoute < 0) {
}

locales disponibles
pointDeRencontreLocal.sin_port = htons(PORT); // = 5000

{
perror("bind");
exit(-2);
}

// On fixe la taille de la file dattente 5 (pour les demandes de connexion non encore
traites)
if(listen(socketEcoute, 5) < 0)
{
perror("listen");
exit(-3);
}

printf("Socket place en coute passive ...\n");

return 0;
}

MANIPULATIONS
tape n7 : accepter les demandes connexions

Cette tape est cruciale pour le serveur. Il lui faut maintenant accepter les demandes de connexion en
provenance des processus client.
Pour cela, il va utiliser lappel systme accept() :
$ man 2 accept
ACCEPT(2) Manuel du programmeur Linux ACCEPT(2)
NOM
accept - Accepter une connexion sur une socket
SYNOPSIS
int accept(int sockfd, struct sockaddr *adresse, socklen_t *longueur);
DESCRIPTION
Lappel systme accept() est employ avec les sockets utilisant un protocole en mode
connect SOCK_STREAM. Il extrait la premire connexion de la file des connexions
en attente de la socket sockfd lcoute, cre une nouvelle socket connecte, et
renvoie un nouveau descripteur de fichier qui fait rfrence cette socket.
La nouvelle socket nest pas en tat dcoute. La socket originale sockfd nest pas
modifie par lappel systme.
...
VALEUR RENVOYE
Sil russit, accept() renvoie un entier non ngatif, constituant un descripteur pour
la nouvelle socket. Sil choue, lappel renvoie -1 et errno contient le code d
erreur.
...
Extrait de la page man de lappel systme accept
Explication : imaginons qu'un client se connecte notre socket d'coute. L'appel accept() va retourner
une nouvelle socket connecte au client qui servira de socket de dialogue. La socket d'coute reste
inchange et peut donc servir accepter des nouvelles connexions.
Le principe est simple mais un problme apparat pour le serveur : comment dialoguer avec le client
connect et continuer attendre des nouvelles connexions ? Il y a plusieurs solutions ce problme
notamment la programmation multi-tche car ici le serveur a besoin de parallliser plusieurs traitements.
On va pour linstant ignorer ce problme et mettre en oeuvre un serveur basique : cest--dire mono-client
(ou plus exactement un client aprs lautre) !
Concernant le dialogue, on utilisera au choix les mmes fonctions (read()/write() ou recv()/send())

que le client.

#include <stdio.h>

MANIPULATIONS
#define LG_MESSAGE 256
int main()
{
int socketEcoute;
int socketDialogue;
char messageEnvoi[LG_MESSAGE]; /* le message de la couche Application ! */
char messageRecu[LG_MESSAGE]; /* le message de la couche Application ! */
int ecrits, lus; /* nb doctets ecrits et lus */
int retour;


if(socketEcoute < 0) /* chec ? */
{
}

locales disponibles
pointDeRencontreLocal.sin_port = htons(PORT);

{
perror("bind");
exit(-2);
}

MANIPULATIONS
// On fixe la taille de la file dattente 5 (pour les demandes de connexion non encore
traites)
if(listen(socketEcoute, 5) < 0)
{
perror("listen");
exit(-3);
}
printf("Socket place en coute passive ...\n");

// boucle dattente de connexion : en thorie, un serveur attend indfiniment !
while(1)
{
memset(messageEnvoi, 0x00, LG_MESSAGE*sizeof(char));
memset(messageRecu, 0x00, LG_MESSAGE*sizeof(char));
printf("Attente dune demande de connexion (quitter avec Ctrl-C)\n\n");
// cest un appel bloquant
socketDialogue = accept(socketEcoute, (struct sockaddr *)&pointDeRencontreDistant, &
longueurAdresse);
if (socketDialogue < 0)
{
perror("accept");
close(socketDialogue);
exit(-4);
}
// On rception les donnes du client (cf. protocole)

lus = read(socketDialogue, messageRecu, LG_MESSAGE*sizeof(char)); // ici appel
bloquant
switch(lus)
{
perror("read");
exit(-5);
fprintf(stderr, "La socket a t ferme par le client !\n\n");
return 0;
default: /* rception de n octets */
printf("Message reu : %s (%d octets)\n\n", messageRecu, lus);
}
// On envoie des donnes vers le client (cf. protocole)

sprintf(messageEnvoi, "ok\n");
ecrits = write(socketDialogue, messageEnvoi, strlen(messageEnvoi));
switch(ecrits)
{
perror("write");

MANIPULATIONS
exit(-6);
fprintf(stderr, "La socket a t ferme par le client !\n\n");
return 0;
default: /* envoi de n octets */
printf("Message %s envoy (%d octets)\n\n", messageEnvoi, ecrits);
}
// On ferme la socket de dialogue et on se replace en attente ...

}

return 0;
}
Testons notre serveur avec notre client :

$ ./serveurTCP-3
Socket place en coute passive ...
Attente dune demande de connexion (quitter avec Ctrl-C)
Message reu : Hello world !

(14 octets)
Message ok
envoy (3 octets)
Message reu : Hello world !

(14 octets)
Message ok
envoy (3 octets)
^C
On va excuter deux clients la suite :

$ ./clientTCP-3

MANIPULATIONS

(3 octets)
$ ./clientTCP-3

(3 octets)
Il est videmment possible de tester notre serveur avec des clients TCP existants comme telnet ou
netcat.

MANIPULATIONS
Bilan
Lchange entre un client et un serveur TCP peut tre maintenant schmatis de la manire suivante :
Les appels systmes utiliss dans un change TCP

QUESTIONS DE RVISION
Questions de rvision
Lide de base des questions de rvision est de vous donner une chance de voir si vous avez identifi et
compris les points cls de ce TP.
Question 1. Quest-ce quune socket ?
Question 2. Quelles sont les trois caractristiques dune socket ?
Question 3. Quelles sont les deux informations qui dfinissent un point de communication en IPv4 ?
Question 4. Comment le serveur connat-il le port utilis par le client ?
Question 5. Comment le client connat-il le port utilis par le serveur ?
Question 6. quelle couche du modle DoD est relie linterface de programmation socket ?
Question 7. Quel protocole de niveau Transport permet dtablir une communication en mode connect ?
Question 8. Quel protocole de niveau Transport permet dtablir une communication en mode non-
connect ?
Question 9. Quel est lordre des octets en rseau ?
Question 10. quels protocoles correspond le domaine PF_INET ou AF_INET ? Est-ce le seul utilisable
avec linterface socket ? En citer au moins un autre.

TP Sockets TCP Linux

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

TP Sockets TCP Linux

Hochgeladen von

Copyright:

Verfügbare Formate

TP Dveloppement Rseau : Socket TCP (Linux)

2012 tv <tvaira@free.fr> - v.1.0

Les objectifs de ce tp sont de mettre en oeuvre la programmation rseau en utilisant

Intgration d'IP dans Unix BSD (1981)

Socket : mcanisme de communication bidirectionelle entre processus

Pour Microsoft Windows, on pourra utiliser le service en ligne MSDN :

TP Dveloppement Rseau : Socket TCP (Linux) 2 / 24 2012 tv <tvaira@free.fr>

Exemple de processus TCP et UDP

TP Dveloppement Rseau : Socket TCP (Linux) 3 / 24 2012 tv <tvaira@free.fr>

Caractristiques des sockets

TP Dveloppement Rseau : Socket TCP (Linux) 4 / 24 2012 tv <tvaira@free.fr>

tape n1 : cration de la socket (ct client)

SOCKET(2) Manuel du programmeur Linux SOCKET(2)

int socket(int domain, int type, int protocol);

TP Dveloppement Rseau : Socket TCP (Linux) 5 / 24 2012 tv <tvaira@free.fr>

//--- Dbut de ltape n1 :

// Teste la valeur renvoye par lappel systme socket()

// On ferme la ressource avant de quitter

tape n2 : connexion au serveur

CONNECT(2) Manuel du programmeur Linux CONNECT(2)

int connect(int sockfd, const struct sockaddr *serv_addr,

TP Dveloppement Rseau : Socket TCP (Linux) 6 / 24 2012 tv <tvaira@free.fr>

Linterface socket propose une structure dadresse gnrique :

Et le domaine PF_INET utilise une structure compatible :

diter le programme suivant dans un fichier que vous nommerez "clientTCP-2.c" :

TP Dveloppement Rseau : Socket TCP (Linux) 7 / 24 2012 tv <tvaira@free.fr>

// Cre un socket de communication

// Teste la valeur renvoye par lappel systme socket()

printf("Socket cre avec succs ! (%d)\n", descripteurSocket);

//--- Dbut de ltape n2 :

// Dbute la connexion vers le processus serveur distant

//--- Fin de ltape n2 !

// On ferme la ressource avant de quitter

Si vous testez ce client, vous risquez dobtenir :

TP Dveloppement Rseau : Socket TCP (Linux) 8 / 24 2012 tv <tvaira@free.fr>

tape n3 : vrification du bon fonctionnement de la connexion

tape n4 : change des donnes

Les fonctions dchanges de donnes sur une socket TCP sont :

diter le programme suivant dans un fichier que vous nommerez "clientTCP-3.c" :

#define LG_MESSAGE 256

TP Dveloppement Rseau : Socket TCP (Linux) 9 / 24 2012 tv <tvaira@free.fr>

// Cre un socket de communication

// Teste la valeur renvoye par lappel systme socket()

printf("Socket cre avec succs ! (%d)\n", descripteurSocket);

// Obtient la longueur en octets de la structure sockaddr_in

// Dbute la connexion vers le processus serveur distant

printf("Connexion au serveur russie avec succs !\n");

//--- Dbut de ltape n4 :

// Envoie un message au serveur

TP Dveloppement Rseau : Socket TCP (Linux) 10 / 24 2012 tv <tvaira@free.fr>

ecrits = write(descripteurSocket, messageEnvoi, strlen(messageEnvoi)); // message

/* Reception des donnes du serveur */

// On ferme la ressource avant de quitter

Puis, on excute notre client :

Message reu du serveur : ok

TP Dveloppement Rseau : Socket TCP (Linux) 11 / 24 2012 tv <tvaira@free.fr>

Dans la console o on a excut le serveur netcat, cela donne :

La socket a t ferme par le serveur !

Notre client a bien dtect la fermeture de la socket ct serveur.

SHUTDOWN(2) Manuel du programmeur Linux SHUTDOWN(2)

int shutdown(int s, int how);

TP Dveloppement Rseau : Socket TCP (Linux) 12 / 24 2012 tv <tvaira@free.fr>

tape n5 : ralisation dun serveur TCP

int accept(int sockfd, struct sockaddr adresse, socklen_t longueur);