Apprendre la programmation Réseau sur TCP/IP
Participez au vote ☆☆☆☆☆★★★★★
AnnŽe SpŽciale Informatique
.
1993/1994
PROGRAMMATION RESEAU
SUR TCP/IP
L'INTERFACE DES SOCKETS
Responsable de projet :
Serge Rouveyrol
Projet rŽalisŽ par
Jazouli Abdel illah
Radi Nour-Eddine
Zghal Tarek
1
2
REMERCIEMENT
Nous tenons ˆ remercier vivement M Rouveyrol, qui a bien voulu nous divertir
de la mort en nous proposant cette Žtude sur la programmation rŽseau.
Nous le remercions aussi pour son ouverture et pour ses prŽcieux conseils.
3
4
PREMIERE PARTIE
PRESENTATION DE TCP/IP
INTRODUCTION
I - LE MODELE DE REFERENCE OSI
II - LE MODELE SIMPLIFIE DU PROTOCOLE TCP/IP
1 - PrŽsentation de TCP/IP
1-1 La couche TCP
1-2 Le protocole UDP
1-3 La couche IP
2 - La couche ETHERNET
3 - La couche Application
III - PRESENTATION DES UNITES DE DONNEES DE
PROTOCOLE CIRCULANT ENTRE LES COUCHES
1 - Le datagramme IP
2 - Le paquet UDP
3 - Le paquet TCP
5
6
DEUXIEME PARTIE
LES SOCKETS
I - LE MODELE CLIENT/SERVEUR
1 - DŽfinitions
2 - Applications orientŽes connexion ou sans connexion
II - LES SOCKETS
INTRODUCTION : LES SOCKETS RACONTES AUX ENFANTS
III - ADRESSES DE SOCKETS
1 - Les famille dÕadresse
2 - Les structures dÕadresse
IV - LES APPELS SYSTEMES
1 - LÕappel syst•me socket
2 - LÕappel syst•me bind
3 - LÕappel syst•me connect
4 - LÕappel syst•me listen
5 - LÕappel syst•me accept
V - ECHANGES DÕINFORMATIONS SUR UN SOCKET
1 - Emission dÕinformation
2 - RŽception dÕinformation
VI - ENCHAINEMENT DES APPELS SYSTEMES
1 - Mode connectŽ
2 - Mode non connectŽ
7
8
VII - DES PROCEDURES BIEN UTILES
1 - ProcŽdures rŽseau de conversion de lÕordre des octets
2 - Les oprŽrations sur les octets
3 - Demander et dŽfinir les noms de machine
4 - Obtenir des informations relatives aux machines
5 - Obtenir des informations relatives aux rŽseaux
6 - Obtenir des informations relatives aux protocoles
7 - Obtenir des informations relatives aux services rŽseau
VIII - EXEMPLE DE PROGRAMMES DE CLIENT SERVEUR
1 - Exemple de client
2 - Exemple de serveur
IX - LES APPELS SYSTEME AVANCES
1 - LÕappel syst•me getpeername
2 - LÕappel syst•me getsockname
3 - LÕappel syst•me shutdown
4 - Les ports rŽservŽs
X - DEMANDER DES OPTIONS DE SOCKET
9
10
TROISIEME PARTIE
LES PROGRAMMES DEVELOPPES
- Programme clients.c
- Programme setsock.c
- Pogramme DialogueTCP.c
- Programme DialogueUDP.c
- Programme Serveur.c
- Programme ServeurTCP_iteratif.c
- Programme ServeurTCP_parall•le.c
- Programme ServeurUDP_parall•le.c
- Programme DialogueTCP_serveur.c
- Programme DialogueUDP_serveur.c
BIBLIOGRAPHIE
Ce document est accessible par ftp anonyme sur la machine
fichier .
Les exemples se trouvant dans ce document se trouvent dans le fichier
11
12
INTRODUCTION
Pour comprendre les rŽseaux, il est important de savoir que la recherche et le
dŽveloppement se sont effectuŽs en trois temps. Avant les annŽes 1960, la question
fondamentale Žtait : << Comment est-il possible dÕacheminer, de fa•on fiable et
efficace, des dŽbits le long dÕun support de transmission ? >>. Les rŽsultats ont inclus
le dŽveloppement de la thŽorie du signal.
Aux environ des annŽes 1965, lÕintŽr•t sÕest concentrŽ sur la commutation de
paquets et la question est devenue : << Comment est-il possible de transmettre des
paquets , de fa•on efficace et fiable, sur un support de communication?>>. Les
rŽsultats ont abouti au dŽveloppement des technique de communication par paquets et
des rŽseaux locaux.
Des annŽes 1975 jusquÕˆ aujourdÕhui, lÕattention sÕest portŽe sur les
architectures de rŽseaux et sur la question : << Comment fournir des services de
communication ˆ travers une interconnexion de rŽseaux >>. Les rŽsultats incluent les
techniques dÕinterconnexion, les mod•les de protocoles en couches, les datagrammes,
les services de transport en mode connectŽ et le mod•le client/serveur.
Ce rapport se focalise sur la programmation dÕapplications basŽes sur le mod•le
client/serveur utilisant les protocoles TCP/IP Internet du D.A.R.P.A. ( DŽfense
Advanced Research Projets Agency).
Un protocole est un ensemble de r•gles et de conventions nŽcessaires pour la
communication entre ordinateurs. Comme ces protocoles sont complexes, ils sont
dŽcoupŽs en plusieurs couches pour faciliter leurs implŽmentation. Chacune Žtant
construite sur la prŽcŽdente. Le nombre de couches, leur nom et leur fonction varie
selon les rŽseaux. Cependant, dans chaque rŽseau, lÕobjet de chaque couche est dÕoffrir
certains services aux couches plus hautes.
La couche N dÕune machine g•re la conversation avec la couche N dÕune autre
machine en utilisant un protocole de niveau N. En rŽalitŽ, aucune donnŽe nÕest
transfŽrŽe directement de la couche N dÕune machine ˆ la couche N de lÕautre machine
mais chaque couche passe les donnŽes et le contr™le ˆ la couche immŽdiatement
infŽrieure, jusquÕˆ la plus basse.
En dessous de la couche 1 se trouve le support physique qui vŽhicule rŽellement
la communication. LÕensemble des couches et protocoles est appelŽ lÕarchitecture du
rŽseau.
I - LE MODELE DE REFERENCE OSI
Sept couches sont dŽfinies dans le mod•le normalisŽ connu sous le nom de
mod•le OSI ( Open Systems Interconnection ou Interconnexion de syst•mes ouverts ).
Cette norme de communication repose sur lÕempilement de 7 couches pouvant
communiquer verticalement entre elles ( fig 1 ).
Les diffŽrentes couches du mod•le sont prŽsentŽes ci dessous :
7 APPLICATION
6 PRESENTATION
5 SESSION
4 TRANSPORT
3 RESEAU
2 LIAISON
1 PHYSIQUE
13
figure 1: Mod•le OSI en 7 couches
1- La couche Physique
CÕest la couche de niveau 1 du mod•le . Elle offre les services de lÕinterface
entre lÕŽquipement de traitement informatique ( ordinateur ou terminal) et le support
physique de transmission. LÕunitŽ de transfert gŽrŽe par cette couche est lÕinformation
ŽlŽmentaire binaire.
2- La couche de Contr™le de la liaison
Pour quÕune succession de bits prenne sens, cette couche dŽfinie des
conventions pour dŽlimiter les caract•res ou des groupes de caract•res. Elle a, donc
pour but dÕacheminer sur une voie physique toutes les informations qui lui sont
transmises par la couche supŽrieure. LÕunitŽ de traitement ˆ ce niveau est appelŽe trame
de donnŽes ( de quelques centaines dÕoctets ) .
3- La couche RŽseau
Cette couche permet de gŽrer le sous-rŽseau, la fa•on dont les paquets (
ensemble de trames ) sont acheminŽs de la source au destinataire. La couche rŽseau a de
ce fait pour r™le essentiel dÕassurer les fonctions de routage ( fonction dŽtaillŽe dans la
suite ) .
4- La couche Transport
La fonction de base de cette couche est dÕaccepter des donnŽes de la couche
session, de les dŽcouper, le cas ŽchŽant, en plus petites unitŽs, et de sÕassurer que tous
les morceaux arrivent correctement de lÕautre c™tŽ.
La couche transport crŽe une connexion rŽseau par connexion transport requise
par la couche session. Elle dŽtermine Žgalement le type de services ˆ fournir ˆ la couche
session et, finalement, aux utilisateurs du rŽseau. Le type de service est dŽterminŽ ˆ la
connexion.
5- La couche Session
Cette couche effectue la mise en relation de deux applications et fournit les
protocoles nŽcessaires ˆ la synchronisation des Žchanges, leur arr•t et leur reprise. Elle
permet dÕattribuer un numŽro dÕidentification ˆ lÕŽchange dÕune suite de messages entre
applications.
6- La couche PrŽsentation
Elle permet la traduction des donnŽes transmises dans un format , commun ˆ
toutes les applications, dŽfini par la norme afin de permettre ˆ des ordinateurs ayant
diffŽrents formats de communiquer entre eux.
7- La couche Application.
CÕest la couche de plus haut niveau : le niveau 7. Elle exŽcute des fonctions de
traitement diverses et permet la normalisation de services dÕapplications typŽes telles
que :
14
- Le transfert de fichiers ( FTP),
- La soumission de travaux ˆ distant ( TELNET),
- La messagerie ( MAIL, TALK),
La communication entre deux machines distantes se rŽsume par la figure 2.
Protocole
Programme
Programme
Application
Protocole
PrŽsentation
PrŽsentation
PrŽsentation
Protocole
Session
Session
Session
Protocole
Tansport
Tansport
Transport
Protocole
RŽseau
RŽseau
RŽseau
Protocole
Liaison
Liaison
iaiso n
Interface
hardware
Physique
RŽseau
Physique
Physique
Fig2
II- MODELE SIMPLIFIE DU PROTOCOLE TCP/IP
Introduction
15
Les protocoles existants ne suivent pas toujours le mod•le OSI. En effet certains
protocoles nÕutilisent que certaines couches du mod•le. GŽnŽralement ils se limitent ˆ
une reprŽsentation en 5 couches. Le plus rŽpandu de ces protocoles est TCP/IP ou
UDP/IP.
TCP/IP ou UDP/IP peuvent •tre utilisŽs pour communiquer au sein dÕun
ensemble quelconque de rŽseaux interconnectŽs.
Les protocoles tels que TCP/IP dŽfinissent les r•gles utilisŽes pour Žchanger les
unitŽs de donnŽes, les dŽtails de leurs structure et indiquent comment gŽrer le cas
dÕerreur. De plus, ils nous permettent de traiter la question des normes de
communication indŽpendamment du matŽriel rŽseau de tel ou tel constructeur.
De point de vue de lÕutilisateur, une interconnexion TCP/IP se prŽsente comme
un ensemble de programmes dÕapplication qui utilisent le rŽseau pour effectuer des
t‰ches utiles sans comprendre la technologie TCP/IP, la structure de lÕinterconnexion
sous-jacente, ni m•me le chemin empruntŽ par les donnŽes pour atteindre leur
destination. Les services dÕapplication les plus populaires et les plus rŽpandus
comprennent :
- Le courrier Žlectronique.
- Le transfert de fichier.
- La connexion ˆ distance.
Le mod•le en couche utilisant TCP/IP ou UDP/IP est reprŽsentŽ sur la figure 3.
LÕinterface hardware reprŽsente les couches 1 et 2 du mod•le OSI.
GŽnŽralement les couches 1 et 2 sont reprŽsentŽes par Ethernet mais on peut
aussi avoir token-ring, X25 .
La couche rŽseau est reprŽsentŽe par IP ( Internet Protocol ).
La couche transport est reprŽsentŽe par TCP ( Transmission Control Protocol )
ou
UDP ( User Datagram Protocol ) .
La derni•re couche est la couche application.
16
Couche
Application
Application
Application
utilisateur
utilisateur
Couche
TCP
UDP
Transport
Transmission Control Protocol
User Datagram Protocol
Couche
IP
RŽseau
Internet Protocol
Couche
Interface
Liaison et
hardware
Physique
Fig3
RESEAU EN COUCHES UTILISANT LE PROTOCOL TCP/IP
Dans la partie suivante on va dŽtailler les protocoles Ethernet, TCP, UDP et IP.
1 - PRESENTATION DE TCP/IP
TCP/IP est un ensemble de protocoles organisŽs en couche. Pour Žclaircir cette
conception en couche il est intŽressant dÕŽtudier un exemple.
Une situation typique est lÕenvoi dÕun mail. Le protocole dŽfinit un ensemble de
commandes quÕune machine doit envoyer ˆ une autre, i.e. les commandes nŽcessaires
pour spŽcifier lÕŽmetteur du message, le destinataire, et le contenu du message. En fait
ce protocole suppose lÕexistence dÕun moyen de communication fiable entre les deux
machines.
Le mail dŽfinit seulement un ensemble de commandes et de messages ˆ envoyer
ˆ lÕautre machine. Il est sensŽ •tre utilisŽ avec TCP et IP. TCP assure la livraison des
donnŽes ˆ la machine distante et a la charge de retransmettre ce qui est perdu par le
rŽseau. Si un message est plus grand quÕun datagramme ( ex : le texte dÕun mail ), TCP
se charge de le dŽcouper en plusieurs datagrammes, et sÕassure quÕils sont tous
correctement transmis.
Comme plusieurs applications sont sensŽes utiliser ces fonctions, elles sont
mises ensembles dans un protocole sŽparŽ.
17
On peut imaginer TCP comme une librairie de routines que les applications
peuvent utiliser quand elles dŽsirent avoir une communication rŽseau fiable avec une
machine distante. De la m•me fa•on que les applications demandent des services ˆ la
couche TCP, celle ci demande des services ˆ la couche IP.
Comme pour TCP, on peut imaginer IP est une librairie de routines que TCP
appelle. Certaines applications nÕutilisent pas TCP. Elles peuvent cependant faire appel
aux services fournis par IP.
CÕest cette stratŽgie de construction par niveau de protocole quÕon appelle
mod•le en couche. On prŽsente donc lÕapplication, TCP et IP comme Žtant des couches
sŽparŽes, chacune dÕentre elles demandant des services ˆ la couche en dessous.
GŽnŽralement les applications TCP/IP utilisent 5 couches:
¥ un protocole dÕapplication comme le mail par exemple.
¥ un protocole comme TCP qui propose des services utilisŽs par plusieurs
applications.
¥ IP qui fournit les services de livraison des datagrammes.
¥ un protocole spŽcifique au moyen de transmission utilisŽ.
TCP/IP est basŽ sur un mod•le qui suppose lÕexistence de plusieurs rŽseaux
indŽpendants qui sont interconnectŽs par des passerelles et que lÕutilisateur doit avoir la
possibilitŽ dÕaccŽder aux ressources de chacune des machines prŽsentes sur cet
ensemble de rŽseaux interconnectŽs.
Les datagrammes transiteront souvent par des dizaines de rŽseaux diffŽrents
avant dÕ•tre dŽlivrŽes ˆ leur destinataire. Le routage (cÕest ˆ dire la mani•re
dÕacheminer les donnŽes) nŽcessaire pour accomplir ceci doit •tre invisible ˆ
lÕutilisateur.
Il y a une correspondance unique entre le nom dÕune machine et son adresse
internet. Cette correspondance se trouve dans un fichier /etc/hosts. Voici une partie de
ce fichier sur ensisun.
#
fichier ~comimag/fede/hosts_entete
#
contient l'entete du /etc/hosts de imag
# LISTE DES MACHINES DU RESEAU DE L'IMAG (/etc/hosts)
129.88.40.4 woody
# MAC VX C210 G. Kuntz p. 4321
129.88.40.5 pixou
# SUN 4/110 C205 J. Lemordant
129.88.40.6 filochard
# SUN 3/60 C205 Lemordan (4498)
129.88.40.7 riri
# TX NCD16 C205 Lemordant
129.88.40.8 goofy
# NEXT Color 12/400 C207
129.88.40.9 zaza
# TX NCD MCX17 p.5321 Kuntz C210
129.88.40.10 safira
# MAC IIsi C. Le Faou p
4299
129.88.40.11 droopy droopy1
# SPARC 10/41 C105A P.
129.88.40.12 cubitus
# INTEL GX C205 J. Lemordant
129.88.40.13 esmeralda
# SUN 4/75 C207
C. Le Faou
129.88.40.14 loulou
# TX NCD17C couleur C205
129.88.40.15 aguamarina
# SUN 4/65 1+ C201 C. Le Faou
129.88.40.16 granada
# SUN 4/40 C205
C. Le Faou
129.88.40.17 gemma
# TX NCD 19r H.Bouamama C205
129.88.40.20 ametista
# SUN 4/40 C201
C. Le Faou
129.88.40.23 topazio
# MAC IIci C. Le Faou p
4299
18
129.88.100.73
tetiaroa
# BULL DPX2/25 K51 routeur C
129.88.102.9 pc2
# essais routage
La seule information dont doit disposer lÕutilisateur pour pouvoir accŽder ˆ une
machine distante est son adresse internet. Une adresse internet est un nombre de 32 bits
gŽnŽralement Žcrit sous forme de 4 nombres dŽcimaux reprŽsentant chacun 8 bits de
lÕadresse ( ex : premi•re colonne).
GŽnŽralement on dŽsigne un syst•me par un nom plut™t quÕune adresse. Dans ce
cas, la machine locale consulte une base de donnŽes et retrouve lÕadresse internet
correspondante au nom spŽcifiŽ.
TCP/IP est con•u avec une technologie sans connexion. Les informations sont
envoyŽes comme une sŽquence de datagrammes indŽpendants.
Un datagramme est un ensemble de donnŽes qui est envoyŽ comme un seul message.
Chaque datagramme est envoyŽ indŽpendamment des autres. Par exemple supposons
quÕon ait ˆ transfŽrer un fichier de 10.000 octets.
Les protocoles ne peuvent pas supporter de datagramme de 10.000 octets. Le
protocole se chargera donc de dŽcouper le fichier en 200 datagrammes de 500 octets et
de les envoyer ˆ leur destinataire. A lÕautre bout, ces datagrammes seront rassemblŽs en
un fichier de 10.000 octets.
Il est important de noter que lors du transit de ces donnŽes, le rŽseau nÕa aucune
idŽe sur la relation qui existe entre ces datagrammes.
Il est donc possible que le datagramme 14 arrive avant le datagramme 13. Il est aussi
possible quÕun datagramme soit perdu en cours de route.
TCP assure aussi le controle de fulx de bout en bout entre les deux extrŽmitŽs de
la connexion afin dÕŽviter des probl•mes de congestion.
1.1 LA COUCHE TCP
Deux protocoles sont invoquŽs lors de lÕutilisation de datagrammes TCP/IP.
¥TCP ( Transmission Control Protocol ) qui a pour r™le de dŽcouper
les messages en datagrammes, de les rŽassembler ˆ lÕautre
extrŽmitŽ, rŽenvoyer les datagrammes perdus et les remettre dans
le bon ordre ˆ la rŽception.
¥IP ( Internet Protocol ) qui a la charge du routage individuel des
datagrammes. CÕest cette couche qui g•re les incompatibilitŽs entre
les diffŽrents supports physiques.
Il peut vous para”tre bizarre quÕon ait parlŽ dÕadresse IP et quÕon nÕait pas
expliquŽ comment gŽrer plusieurs connexions sur une m•me machine. En fait il ne
suffit pas de remettre un datagramme ˆ la bonne destination. TCP doit conna”tre la
connexion concernŽe par le datagramme. Cette fonction est connue sous le nom de
dŽmultiplexage.
LÕinformation nŽcessaire pour le dŽmultiplexage est contenue dans un ensemble
dÕent•tes. Une ent•te est tout simplement quelques octets supplŽmentaires placŽs au
dŽbut du datagramme.
Par exemple supposons quÕon dŽsire envoyer le message suivant:
TCP dŽcoupe ce message en puis ajoute une ent•te ˆ chacun de
ces datagrammes. LÕent•te contient au moins 20 octets mais les plus importants sont les
numŽro de port de la source et de destination et le numŽro de sŽquence du datagramme.
Les numŽros de ports servent ˆ diffŽrencier les conversations sur une m•me
19
machine. Le numŽro de sŽquence du datagramme permet au destinataire de remettre les
datagrammes dans le bon ordre et de detecter des pertes sur le rŽseau.
En rŽalitŽ TCP ne numŽrote pas les datagrammes mais les octets. Ainsi, si la
taille du datagramme est de 500 octets, le premier aura le numŽro 0, le second le
numŽro 500.
Enfin mentionnons le checksum qui reprŽsente des octets de redondance
permettant de dŽtecter certaines erreurs et de les corriger Žventuellement sans avoir ˆ
demander la reŽmission du datagramme.
Si nous reprŽsentons lÕent•te par T, notre fichier de dŽpart ressemblerait ˆ :
T T T T T T T
LÕent•te contient aussi un champ reprŽsentant un numŽro dÕacquittement. Par
exemple lÕenvoi dÕun datagramme avec 1500 comme numŽro dÕacquittement suppose la
rŽception de toutes les donnŽes prŽ•Ždant lÕoctet 1500.
Si lÕŽmetteur ne re•oit pas dÕacquittement pendant une certaine pŽriode de
temps, il rŽenvoit la donnŽe supposŽe •tre perdue dans le rŽseau.
1-2 LE PROTOCOLE UDP
Rappelons que TCP dŽcoupe les messages longs en datagrammes avant de les
envoyer. Seulement pour certaines applications les messages mis en jeu pourront •tre
transportŽs dans un seul datagramme. Par exemple rares sont les syst•mes qui
poss•dent une base de donnŽes compl•te qui rŽsoud le probl•me de correspondance
entre les noms des machines et leur adresse. Le syst•me devra donc envoyer une
requ•te ˆ un autre syst•me ayant cette base de donnŽes.
Cette requ•te a de fortes chances de nŽcessiter un seul datagramme pour la
requ•te et un seul pour la rŽponse. Il peut donc nous para”tre utile de dŽfinir un protocle
qui puisse jouer le r™le de TCP mais qui ne poss•derait pas toutes ses fonctions (
segmentation et rŽassemblage ).
LÕalternative la plus connue est UDP ( User Datagram Protocol ). Comme pour
TCP, UDP poss•de une ent•te. cette ent•te est positionnŽe avant le bloc de donnŽes.
UDP dŽlivre ensuite les donnŽes ˆ IP qui rajoute lÕent•te IP, en mentionnant le type de
protocole (UDP).
UDP fournit un service non fiable puisque ce protocole ne permet pas de vŽrifier
le sŽquencement des datagrammes. En effet le numŽro de sŽquence des datagrammes
nÕexiste pas dans lÕent•te UDP.
fragmentation et reassemblage des datagrammes
TCP/IP a ŽtŽ con•u pour sÕadapter ˆ diffŽrents types de rŽseaux.
Seulement les concepteurs des rŽseaux nÕont pas toujours pris des paquets de m•me
taille. On doit donc pouvoir sÕadapter aux grandes et aux petites tailles de paquets.
En fait TCP peut nŽgocier la taille des datagrammes. Lors de lÕŽtablissement
dÕune connexion TCP, les deux extrŽmitŽs envoient la taille maximale quÕelles peuvent
supporter pour un datagramme. CÕest le plus petit de ces deux nombres qui sera
considŽrŽ pour la suite de la connexion.
Le probl•me de cette solution est quÕelle ne prend pas en considŽration les
passerelles entre les deux machines. Par exemple si une passerelle ne peut pas
manipuler des datagrammes de la taille choisie, ils seront dŽcoupŽs en pi•ces (cÕest la
20
fragmentation).
LÕent•te IP contient un champ indiquant que le datagramme a ŽtŽ dŽcoupŽ et
lÕinformation permettant de les remettre ensemble pour reformer le datagramme initial
(cÕest le rŽassemblage) .
1.3 LA COUCHE IP
TCP remet chacun de ses datagrammes ˆ IP en lui indiquant lÕadresse IP
destination. Notons bien que IP nÕa pas besoin de plus dÕinformations pour acheminer
les donnŽes. IP nÕest pas concernŽe par le contenu du datagramme et par lÕent•te TCP.
IP a simplement pour r™le de trouver un chemin lui permettant de livrer le
datagramme ˆ sa destination. Pour permettre aux passerelles et aux rŽseaux
intermŽdiares de faire suivre le datagramme, IP lui ajoute une ent•te.
Les donnŽes les plus importantes dans ce nouvel ent•te sont les adresses source
et
destination, le numŽro de protocole et un autre checksum.
LÕadresse source est lÕadresse de votre machine. Ce qui permet au
destinataire de conna”tre lÕŽmetteur.
LÕadresse destination est lÕadresse du destinataire du message.
Le numŽro de protocole identifie la couche potocolaire qui est au
dessus de IP ( pas for•ement TCP )
Le checksum permet ˆ la couche IP destinataire de vŽrifier lÕintŽgralitŽ des
donnŽes re•ues. CÕest pour des raisons dÕefficacitŽet de sžretŽ que IP rajoute un
checksum.
Si on note I lÕent•te IP, notre fichier de dŽpart sera de la forme:
IT IT IT IT IT IT IT
21
le routage
La description de la couche IP la prŽsente comme Žtant responsable de
lÕacheminement des donnŽes et de leur livraison. CÕest ce quÕon se propose de dŽcrire
dans ce paragraphe. Cette fonction porte le nom de routage.
On supposera que le syst•me sait comment envoyer des donnŽes aux machines
connectŽes sur son rŽseau. Le probl•me surgit lorsque la machine destinataire nÕest pas
sur le m•me rŽseau que la machine qui Žmet le message.
Ce probl•me est rŽsolu par les passerelles. ces derni•res sont gŽnŽralement des
syst•mes qui relient un rŽseau ˆ un ou plusieurs autres rŽseaux. Les passerelles sont
donc supposŽs avoir plusieurs interfaces rŽseau.
Par exemple supposons possŽder une machine unix qui poss•de deux interfaces
Ethernet, chacune connectŽe ˆ un rŽseau. Cette machine peut faire fonction de
passerelle entre ces deux rŽseaux.
Le routage au niveau IP est enti•rement basŽ sur les numŽros dÕadresse. Chaque
syst•me poss•de une table de numŽros dÕadresses. Pour chaque numŽro rŽseau,
correspond une passerelle. CÕest le numŽro de la passerelle ˆ utiliser pour joindre le
rŽseau dŽsirŽ.
Notons que la passerelle nÕa pas ˆ •tre directement connectŽe au rŽseau
destinataire. Elle ne reprŽsente quÕun intermŽdiaire pour atteindre la destination.
Quand un syst•me dŽsire envoyer un datagramme, il commence par voir si
lÕadresse destination correspond ˆ une adresse de son rŽseau. Dans ce cas il emet
directement le message. Dans le cas inverse le syst•me cherche dans sa table la
passerelle ˆ laquelle il doit envoyer le message.
Plusieurs stratŽgies ont ŽtŽ dŽveloppŽes pour minimiser la taille de la table de
routage.
Une de ces statŽgies dŽsigne une passerelle par dŽfaut qui recevra le message si
aucune entrŽe dans la table de routage ne permet dÕidentifier une passerelle de sortie.
Certaines passerelles ˆ qui on sÕadresse rŽpondent Ò IÕm not the best gateway,
use this one insteadÓ. Certains syst•mes utilisent ce message pour mettre ˆ jour leur
table de routage dynamique.
Sur ensisun la table de routage est obtenue en tapant la commande netstat -nr.
On obtient en sortie le fichier suivant:
Routing Table:
Destination Gateway
-------------------- --------------------
127.0.0.1 127.0.0.1
192.33.175.0 192.33.174.36
192.33.174.128 192.33.174.33
192.33.174.160 192.33.174.33
192.33.174.96 192.33.174.35
152.77.0.0 192.33.174.62
129.88.0.0 192.33.174.62
130.190.0.0 192.33.174.62
192.33.174.32 192.33.174.34
192.33.174.64 192.33.174.65
224.0.0.0 192.33.174.34
default 192.33.174.62
On remarquera un chemin de sortie par dŽfaut default qui sera utilisŽ dans le cas
o• lÕadresse de la destination ne figure pas dans la table.
22
2- LA COUCHE ETHERNET
Cette couche correspond aux couches 1 et 2 du mod•le OSI.
La plupart des rŽseaux actuels utilisent Ethernet. Nous allons donc dŽcrire
lÕent•te Ethernet. LorsquÕune donnŽe est envoyŽe sur Ethernet, toutes les machines sur
le rŽseau voient le paquet. Il faut donc une information pour que seule la machine
concernŽe par le message lÕenregistre. Comme vous lÕavez devinŽ, cÕest un ent•te
Ethernet qui est ajoutŽe.
Chaque paquet Ethernet contient un ent•te de 14 octets qui contient les adresses
source et destination.
Chaque machine est supposŽe reconna”tre les paquets contenant son adresse
Ethernet dans le champ destinataire. Il y a donc des moyens de tricher et de lire les
donnŽes du voisins, cÕest une des raisons pour lesquelles Ethernet manque de sŽcuritŽ.
Notons quÕil nyÕa pas de relation entre lÕadresse Ethernet et lÕadresse Internet.
Chaque machine doit possŽder une table de correspondance entre adresse Ethernet et
Internet.
Le checksum est calculŽ sur le paquet entier et ne fait pas partie de lÕent•te. Il
est mis ˆ la fin du paquet. Si on note E lÕent•te Ethernet et C le checksum, notre fichier
initial ressemblera ˆ :
EIT C EIT C EIT C EIT C EIT C EIT C EIT C
Quand ces paquets seront re•us ˆ lÕautre extrŽmitŽ, toutes les ent•tes sont
extraites. LÕinterface Ethernet extrait lÕent•te Ethernet et le cheksum puis passe le
datagramme ˆ la couche IP. IP retire lÕent•te IP, puis passe le datagramme ˆ la couche
TCP. TCP vŽrifie alors le numŽro de sŽquence, et combine tous les datagrammes pour
reconstituer notre fichier initial.
3 - LA COUCHE APPLICATION
Cette couche est au dessus de TCP et IP. Par exemple lorsque vous envoyez un
message cette couche le dŽlivre ˆ TCP qui se charge de le livrer ˆ sa destination.
Comme TCP et IP masquent tous les dŽtails du mŽcanisme dÕacheminement et
de rŽemission des donnŽes, la couche application peut voir une connexion rŽseau
comme un simple flux de donnŽes.
Notons quÕune connexion est identifiŽe par 4 nombres: lÕadresse internet et le
numŽro de port de chaque extrŽmitŽ de la connexion. Chaque datagramme contient ces
4 numŽros. LÕadresse internet est contenue dans lÕent•te IP et les numŽros de ports dans
lÕent•te TCP.
Par exemple on peut avoir les deux connexions suivante simultanement:
adresses internet
ports TCP
connexion1
128.14.5.129 128.14.5.130
1234, 21
connexion2
128.14.5.129 128.14.5.130
1235, 21
La seule diffŽrence entre ces deux connexions est le numŽro de port, et ceci est suffisant
pour les diffŽrencier.
23
encapsulation des donnŽes
Les donnŽes sont transfŽrŽes verticalement dÕune couche ˆ une autre en y
rajoutant un ent•te. Cet ent•te permet de rajouter des informations identifiant le type de
donnŽes, le service demandŽ, le destinataire, lÕadresse source : cÕest lÕencapsulation
des donnŽes.
La figure 4 illustre le mŽcanisme dÕencapsulation.
donnŽes
ent•te
donnŽes
application
Message application
ent•te
ent•te
donnŽes
UDP
application
Message UDP
ent•te
ent•te
ent•te IP
donnŽes
UDP
application
Paquet IP
ent•te
ent•te
ent•te
queue
ent•te IP
donnŽes
Ethernet
UDP
application
Ethernet
Trame Ethernet
Fig 4
ENCAPSULATION DE
DONNEES
24
La communication entre deux machines utilisant le protocole TCP/IP ou
UDP/IP se rŽsume par la suivante ( figure 5 ).
Protocole Aplication
Application
Application
client
seveur
Protocole UDP
UDP
UDP
Protocole IP
IP
IP
Protocole Ethernet
Ethernet
Ethernet
Connection Physique
Fig 5 Connexion de deux applications sur un rŽseau Ethernet, UDP/IP
Chaque couche communique avec son correspondant du m•me niveau. Aucune
donnŽe nÕest transfŽrŽe de la couche N dÕune machine ˆ la couche N dÕune autre
machine, mais chaque couche passe les donnŽes et le contr™le ˆ la couche
immŽdiatement infŽrieure, jusquÕˆ la plus basse. En dessous de la couche 1 se trouve le
support physique qui vŽhicule rŽellement la communication.
III -
PRESENTATION DES UNITES DE DONNEES DE PROTOCOLE
CIRCULANT ENTRE LES COUCHES
1- Le datagramme IP
0
4
8
12
16
20
24
28 31
Version
I.H.L.
Type de service
Longueur totale
Identificateur
drapeaux
offset de fragmentation
DurŽe de vie
Protocol
Checksum de lÕent•te
ADRESSE SOURCE
ADRESSE DESTINATION
OPTIONS
Rembourrage
DONNEES
Fig 6 DATAGRAMME IP
Version :
Ce champ indique la version du format dÕen-t•te utilisŽ. La version utilisŽe
actuellement est la version 4.
25
I.H.L : (Internet Header Length)
`
Longueur de lÕent•te Internet ; nombre de mots de 32 bits utilisŽs par lÕent•te :
ce champs pointe donc sur le dŽbut de la zone donnŽes (au sens IP). La valeur
minimum utilisable est 5.
Type de service :
Ce champ permet de sŽlectionner le type de service dont on souhaite faire
bŽnŽficier le datagramme. Ce param•tre fournit des indications abstraites sur le type de
service souhaitŽ et permet de guider la sŽlection des param•tres effectifs utilisŽs pour la
transmission dÕun datagramme sur un rŽseau donnŽ. un des services offerts sur certains
rŽseaux est la prioritŽ de traitement.
Dans ce dernier cas, et selon le rŽseau, les datagrammes sont traitŽs
diffŽremment selon leur niveau de prioritŽ ( par exemple, ˆ un moment de tr•s forte
charge sur certains rŽseaux, seul les datagrammes de haute prioritŽ sont acceptŽs ).
Il y a quatre param•tres disponibles rŽglant le temps de transmission, le dŽbit, la
fiabilitŽ, et la prioritŽ. Il va de soi que ces param•tres sont relativement couplŽs entre
eux.
format de lÕoctet du type de service
0 2 3
4
5
6
7
prioritŽ
d
D
F
X
X
Bits 0 ˆ 2 : niveau de prioritŽ
111 contr™le rŽseau
110 contr™le inter-rŽseaux
010 ImmŽdiat
001 Prioritaire
000 Normal.
Bit 3 : 0 = dŽlai normal, 1 = dŽlai rŽduit
Bit 4 : 0 = dŽbit normal, 1 = haut dŽbit
Bit 5 : 0 = fiabilitŽ normale, 1 = haute fiabilitŽ
Bit 6 & 7 : rŽservŽs ˆ un futur usage
Longueur totale :
Ce champ dŽsigne la longueur du segment IP en incluant lÕent•te Internet et la
zone de donnŽes. Chaque machine travaillant sur TCP/IP doit •tre capable dÕaccepter
des segments allant au moins jusquÕˆ 576 octets.
Remarque Avant de dŽfinir les champs immŽdiats qui suivent, il faut prŽciser quÕune
trame IP peut •tre divisŽe dans certains rŽseaux lors du chemin de transmission
(passage par les diffŽrents routeurs et passerelles ) avant dÕ•tre rŽassemblŽe pour la
rŽception de la machine destinataire.
Identificateur :
Pointeur utilisŽ pour rŽassembler les fragments dÕun segment.
drapeaux : 3bits
Bit 0 : rŽservŽ, doit •tre ˆ zŽro.
Bit 1 : 0 = fragmentation autorisŽe, 1 = fragmentation interdite
26
Bit 2 : 0 = Dernier fragment, 1 = fragment ˆ suivre.
offset de fragmentation :
Ce champ indique la portion datagramme auquel ce fragment appartient.
DurŽe de vie :
Ce champs indique la durŽe de vie maximale du datagramme dans le syst•me
internet. Une valeur nulle indique que ce datagramme doit •tre dŽtruit.
Protocole :
indique le protocole utilisŽ dans la portion de donnŽes
Checksum de lÕent•te :
VŽrification de la validitŽ de lÕent•te IP.
ADRESSE SOURCE :
Adresse Internet de la machine Žmettrice du datagramme.
ADRESSE DESTINATION :
Adresse Internet de la machine destinataire du datagramme.
OPTIONS :
Ce champ a une taille variable. Il nÕest pas obligatoire et peut ne pas appara”tre
dans le datagramme.
Rembourrage :
UtilisŽ en cas dÕoption pour amener, si besoin, la longueur de lÕent•te internet ˆ
un multiple de 32 bits.
2 - Le paquet UDP
0
16 31
Port source
Port dŽstination
Longueur
Checksum
DonnŽes
Fig 7 Ent•te UDP
Port source :
Le numŽro du port source.
Port destination :
Le numŽro du port destinataire.
Longueur :
longueur du datagramme.
Checksum :
VŽrification de la validitŽ du segment TCP.
27
3 - Le paquet TCP
1
4
8
12
16
20
24
28 31
Port source
Port dŽstination
NumŽro de sŽquence
NumŽro dÕacquitement
Offset
RŽservŽ
Drapeau
Fen•tre
Checksum
Urgent pointer
Options
Rembourrage
DONNEES
Fig 8 Ent•te TCP
Port source :
Le numŽro du port source.
Port destination :
Le numŽro du port destinataire.
NumŽro de sŽquence :
NumŽro de sŽquence du premier octet de donnŽes contenu dans le prŽsent
segment sauf dans le cas o• on a une ouverture de connexion. Dans ce cas lˆ, le champ
prŽsente la valeur ISN (Initial SŽquence Number) et le premier octet de donnŽes a pour
valeur ISN+1.
NumŽro dÕacquittement :
Ce champ contient le numŽro de sŽquence du prochain octet que lÕŽmetteur du
prŽsent segment est pr•t ˆ recevoir. une fois que la connexion est Žtablie , ce champ est
toujours envoyŽ.
Offset :
Ce champ donne le nombre de mots de 32 bits dans lÕent•te TCP. Il indique
donc le dŽbut de la zone donnŽes.
RŽservŽ :
Champ de 6 bits rŽservŽ ˆ un usage futur
Drapeau ou bits de contr™le :
Bit 1 : Indication de la prŽsence de donnŽes urgentes.
Bit 2 : Validation du champ acquittement.
Bit 3 : Fonction Push ( concerne la transmission ŽlŽmentaire de donnŽes)
Bit 4 : RŽinitialisation de la connexion (Reset)
Bit 5 : Synchronisation des numŽros de sŽquence initiaux ˆ lÕŽtablissement de la
connexion.
Fen•tre :
Nombre dÕoctets que lÕŽmetteur du prŽsent segment est pr•t ˆ recevoir. En
concordance avec le champ NumŽro dÕacquittement, cela indique les numŽros de
sŽquence acceptables pour les prochains octets ˆ recevoir ( ils devront •tre distincts et
compris entre le numŽro dÕacquittement et le numŽro dÕacquittement + la fen•tre.
Checksum :
28
VŽrification de la validitŽ du segment TCP.
Urgent pointer :
Ce champ fonctionne en concordance avec le bit 1 des drapeaux. LorsquÕil y a
des donnŽes urgentes ce pointeur indique le numŽro de sŽquence du premier octet qui
suit les donnŽes urgentes.
Options :
Ce champ a une taille variable. Il nÕest pas obligatoire et peut ne pas appara”tre
dans le datagramme.
Rembourrage :
UtilisŽ en cas dÕoption pour amener si besoin est la longueur de lÕent•te internet
ˆ un multiple de 32 bits.
29
2•me PARTIE
LES SOCKETS
30
I - LE MODELE CLIENT SERVEUR
1- dŽfinitions
Les protocoles de communication comme TCP/IP permettent la communication
point ˆ point entre deux applications sÕŽxŽcutant eventuellement sur deux machines
diffŽrentes.
Le dŽtail du transfert effectif des donnŽes entre deux applications est spŽcifiŽ par
le protocole de communication de la couche transport, mais le moment et la fa•on dont
les applications interagissent entre elles sont laissŽs ˆ la charge du programmeur.
LÕarchitcture client/serveur est devenue la mŽthode incontournable pour la
communication point ˆ point au niveau applicatif, quand le protocole utilisŽ est de la
famille TCP/IP.
Ce modŽle est motivŽ par le fait que TCP/IP ne fournit aucun mŽcanisme
permettant lÕexŽcution automatique dÕun programme ˆ lÕarrivŽe dÕun message si bien
que dans une communication point ˆ point, lÕune des applications doit attendre
lÕinitiative de la communication de la part de lÕautre application.
Les applications peuvent •tre classŽes en deux catŽgories:
¥ les clients: applications qui prennent lÕinitiative du lancement de la
communication, cÕest ˆ dire demande lÕouverture de connexion,
lÕenvoi
dÕune requ•te, lÕattente de la rŽponse ˆ la requ•te, reprise de
lÕexŽcution
du programme.
¥ les serveurs: applications qui attendent la communication, cÕest ˆ dire
lÕattente dÕune demande dÕouverture de connexion, la reception
dÕune requ•te et lÕenvoi dÕune rŽponse.
2- applications orientŽes connexion ou sans connexion
Une application est dite orientŽe connexion si le protocole sous-jacent utilisŽ est
en mode connectŽ ( TCP/IP par exemple ).
Une application est dite orientŽe sans connexion si le protocole sous-jacent
utilisŽ est en mode non connectŽ ( UDP/IP par exemple ).
LÕavantage de lÕutilisation dÕun protocole comme TCP/IP est la fiabilitŽ: la
couche transport effectue elle m•me le ÒcheksumÓ, la rŽŽmission de morceaux de
messages perdus, lÕŽlimination des morceaux duppliquŽs, lÕadaptation du dŽbit.
Un protocole comme UDP/IP nÕeffectue pas ces vŽrifications qui doivent alors
•tre faites par le protocole de communication de niveau applicatif. Pour cette raison, la
programmation de clients ou serveurs en mode non connectŽ est plus complexe quÕen
mode connectŽ. Cependant, en rŽseau local o• le transport est fiable, il peut •tre
avantageux dÕutiliser UDP car ce mode de communication demande moins dÕopŽrations
que TCP.
31
II - LES SOCKETS
INTRODUTION
LES SOCKETS RACONTEES AUX ENFANTS
Le concept de socket est assez difficile ˆ apprŽhender. CÕest BSD qui les a
choisis pour accomplir les communications inter-processus (IPC). Cela veut dire quÕun
socket est utilisŽ pour permettre aux processus de communiquer entre eux de la m•me
mani•re que le tŽlŽphone nous permet de communiquer entre nous. LÕanalogie entre le
concept de socket et le tŽlŽphone est assez proche, et sera utilisŽe pour Žclaircir la
notion de socket.
Pour recevoir des coups de tŽlŽphone, vous devez dÕabord installer le tŽlŽphone
chez vous. De la m•me fa•on vous devez commencer par crŽer un socket avant
dÕattendre des demandes de communications. La commande socket() est alors utilisŽe
pour crŽer un nouveau socket.
Seulement il faut crŽer un socket avec les bonnes options. Vous devez spŽcifier
le type dÕadressage du socket. Les deux types d adressage les plus rŽpandus sont
AF_UNIX (famille dÕadresse UNIX) et AF_INET (famille dÕadresse Internet).
AF_INET utilise les adresses Internet qui sont du format suivant (ex:
178.33.174.34). En plus des adresses Internet, on a besoin aussi dÕun numŽro de port
sur la machine pour pouvoir utiliser plusieurs socket simultanŽment.
Une autre option a spŽcifier lors de la crŽation dÕun socket est son type. les deux
types les plus rŽpandus sont SOCK_STREAM et SOCK_DGRAM. SOCK_STREAM
sont spŽcifiques au mode connectŽ alors que SOCK_DGRAM sont spŽcifiques au mode
dŽconnectŽ.
De la m•me fa•on quÕon vous attribue un numŽro de tŽlŽphone pour recevoir
vos appels, on doit spŽcifier au socket une adresse ˆ laquelle il doit recevoirles
messages qui lui sont destinŽs. Ceci est rŽalisŽ par la fonction bind() qui associe un
numŽro au socket.
Les sockets de type SOCK_STREAM ont la possibilitŽ de mettre les requ•tes de
communication dans une file dÕattente , de la m•me fa•on que vous pouvez recevoir un
appel pendant une conversation tŽlŽphonique. CÕest la fonction listen() qui permet de
dŽfinir la capacitŽ de la file dÕattente (jusquÕˆ 5) . Il n est pas indispensable dÕutiliser
cette fonction mais cÕest plut™t une bonne habitude que de ne pas lÕoublier.
LÕŽtape suivante est dÕattendre les demandes de communication. CÕest le r™le de
la fonction accept(). Cette fonction retourne un nouveau socket qui est connectŽ ˆ l
appelant. Le socket initial peut alors se remettre ˆ attendre les demandes de
communication. CÕest pour cette raison quÕon exŽcute un fork ˆ chaque demande de
connexion.
On sait maintenant comment crŽer un socket qui re•oit des demandes de
communication, mais comment lÕappeler ?
Pour le tŽlŽphone vous devez dÕabord avoir le numŽro avant de pouvoir appeler.
Le r™le de la fonction connect() est de connecter un socket a un autre socket qui est en
attente de demande de communication. Maintenant quÕune connexion est Žtablie entre
deux sockets, la conversation peut commencer. CÕest le r™le des fonction read() et
write(). A la fin de la communication on doit raccrocher le tŽlŽphone ou fermer le
32
socket qui a servi ˆ la communication. CÕest le r™le de la fonction close().
Nous attendons avec impatience le transfert dÕappel avec un socket. La partie
suivante se propose dÕapprofondir les points survolŽs par cette br•ve introduction sur
les sockets.
Sous UNIX lÕimplŽmentation est de la forme suivante:
Process
utilisateur
interface d'appel
syst•me de socket
Protocole de
Noyau
communication
TCP/UDP/IP
Liaison de
donnŽes
(Ethernet)
Fig 9 ImplŽmentation du rŽseau sous UNIX
III - ADRESSES DE SOCKETS
1- les familles dÕadresse
Il existe plusieurs familles dÕadresses, chacune correspondant ˆ un protocole
particulier. Les familles les plus rŽpandues sont:
AF_UNIX
Protocoles internes de UNIX
AF_INET
Protocoles Internet
AF_NS
Protocols de Xerox NS
AF_IMPLINK
Famille spŽciale pour des applications
particuli•res auxquelles nous ne nous
intŽresserons pas.
2- les structures dÕadresse
Plusieurs appels syst•mes rŽseaux sous unix nŽcessitent un pointeur sur une
structure dÕadresse de socket. La dŽfinition de cette structure se trouve dans
<sys/socket.h> ;
struct sockaddr {
u_short
sa_family ;
33
char
sa_data[14] ;
} ;
sa_family
: adresse de famille : prend la valeur AF_xxx
sa_data
: peut contenir jusquÕˆ 14 octets de protocole spŽcifique dÕadresse
interprŽtŽ selon le type dÕadresse.
Pour la famille internet les structures suivantes sont dŽfinis dans le fichier
<netinet/in.h>.
struct in_addr {
u_long
s_addr ;
} ;
s_addr
: 32 bits constituants lÕidentificateur du rŽseau et de la machine h™te
ordonnes selon lÕordre rŽseau.
struct sockaddr_in {
short
sin_family ;
u_short
sin_port ;
struct in_addr sin_addr ;
char
sin_zero[8] ;
} ;
sin_family
: AF_INET ;
sin_port
: 16 bits de numŽro de port ( ordonnancement rŽseau) ;
sin_addr
: 32 bits constituants lÕidentificateur du rŽseau et de la machine h™te
ordonnes selon lÕordre rŽseau.
sin_zero[8] : inutilisŽs ;
Le fichier <sys/types.h> fourni des dŽfinitions de C et de types de donnŽes qui sont
utilisŽs dans le syst•me. Ainsi nous verrons appara”tre les dŽfinitions suivantes qui sont
malheureusement diffŽrentes entre les version 4.3BSD et le syst•me V.
TYPE en C
4.3BSD
Syst•me 5
unsigned char
u_char
unchar
unsigned short
u_short
ushort
unsigned int
u_int
uint
unsigned long
u_long
ulong
34
VI - LES APPELS SYSTEME
1- LÕappel syst•me socket
#include <sys/types.h>
#include <sys/socket.h>
int socket (int family, int type, int protocole) ;
La variable family peut prendre 4 valeurs dont les prŽfixes commencent par AF
comme Famille dÕAdresse :
AF_UNIX
Protocoles internes de UNIX
AF_INET
Protocoles Internet
AF_NS
Protocols de Xerox NS
AF_IMPLINK
Famille spŽciale pour des applications
particuli•res auxquelles nous ne nous
intŽresserons pas.
La variable type peut prendre 5 valeurs :
SOCK_STREAM
utilisŽ en mode connectŽ au dessus de TCP.
SOCK_DGRAM
utilisŽ en mode dŽconnectŽ avec des
datagrammes au dessus de UDP.
SOCK_RAW
utilisŽ au dessus de IP
SOCK_SEQPACKET
Sequenced Packet socket. Ce type
nÕest pas utilisable avec TCP/IP ni avec
UDP/IP.
Le mode raw accessible par lÕoption SOCK_RAW lors de la crŽation dÕun
socket, permet lÕacc•s aux interfaces internes du rŽseau. Ce mode nÕest accessible quÕau
super-utilisateur et ne sera pas dŽtaillŽ.
LÕargument protocole dans lÕappel syst•me socket est gŽnŽralement mis ˆ 0.
Dans certaines applications spŽcifiques, il faut cependant spŽcifier la valeur du
protocole. Les combinaisons valides pour la famille AF_INET sont les suivantes :
TYPE
PROTOCOLE
PROTOCOLE
ACTUEL
SOCK_DGRAM
IPPROTO_UDP
UDP
SOCK_STREAM
IPPROTO_TCP
TCP
SOCK_RAW
IPPROTO_ICMP
ICMP
SOCK_RAW
IPPROTO_RAW
(raw)
Les constantes IPPROTO_xxx sont dŽfinies dans le fichier <netinet/in.h>.
LÕappel syst•me socket retourne un entier dont la fonction est similaire ˆ celle dÕun
descripteur de fichier. Nous appellerons cette entier descripteur de sockets (sockfd).
35
2 - LÕappel syst•me bind
#include <sys/types.h>
#include <sys/socket.h>
int bind (int sockfd, struct sockaddr *myaddr , int addrlen) ;
Le premier argument est le descripteur de socket retournŽ par lÕappel socket.
Le second argument est un pointeur sur une adresse de protocole spŽcifique et le
troisi•me est la taille de cette structure dÕadresse. Il y a 3 utilisations possibles de bind :
1 - Le serveur enregistre sa propre adresse aupr•s du syst•me. Il indique au
syst•me que tout message re•u pour cette adresse doit lui •tre fourni. Que la liaison soit
avec ou sans connexion lÕappel de bind est nŽcessaire avant lÕacceptation dÕune requ•te
dÕun client.
2 - Un client peut enregistrer une adresse spŽcifique pour lui m•me.
3 - Un client sans connexion doit sÕassurer que le syst•me lui a affectŽ une
unique adresse que ses correspondants utiliseront afin de lui envoyer des messages.
LÕappel de bind rempli lÕadresse locale et celle du process associŽs au socket.
3 - LÕappel syst•me connect
Un socket est initialement crŽŽ dans lÕŽtat non connectŽ, ce qui signifie quÕil
nÕest associŽ ˆ aucune destination ŽloignŽe. LÕappel syst•me connect associe de fa•on
permanente un socket ˆ une destination ŽloignŽe et le place dans lÕŽtat connectŽ.
Un programme dÕapplication doit invoquer connect pour Žtablir une connexion
avant de pouvoir transfŽrer les donnŽes via un socket de transfert fiable en mode
connectŽ.
Les sockets utilisŽes avec les services de transfert en mode datagramme nÕont
pas besoin dÕŽtablir une connexion avant dÕ•tre utilisŽs, mais procŽder de la sorte
interdit de transfŽrer des donnŽes sans mentionner ˆ chaque fois, lÕadresse de
destination.
#include <sys/types.h>
#include <sys/socket.h>
int connect (int sockfd, struct sockaddr *servaddr , int addrlen) ;
sockfd
est le descripteur de socket retournŽ par lÕappel socket.
servaddr
est un pointeur sur une structure dÕadresse de socket qui indique
lÕadresse
de destination avec laquelle le socket doit se connecter.
addrlen
taille de la structure dÕadresse.
36
4 - LÕappel syst•me listen
#include <sys/types.h>
#include <sys/socket.h>
int listen ( int sockfd, int backlog) ;
Cet appel est gŽnŽralement utilisŽ apr•s les appels socket et bind et juste avant
les appels lÕappel accept. LÕargument backlog spŽcifie le nombre de connections ˆ
Žtablir dans une file dÕattente par le syst•me lorsque le serveur exŽcute lÕappel accept.
Cet argument est gŽnŽralement mis ˆ 5 qui est la valeur maximale utilisŽe.
5 - LÕappel syst•me accept
#include <sys/types.h>
#include <sys/socket.h>
int accept (int sockfd, struct sockaddr *peer , int *addrlen) ;
LÕargument sockfd dŽsigne le descripteur de socket sur lequel seront attendues
les connexions. Peer est un pointeur vers une structure dÕadresse de socket.
LorsquÕune requ•te arrive, le syst•me enregistre lÕadresse du client dans la
stucture *peer et la longueur de lÕadresse dans *addrlen. Il crŽe alors un nouveau socket
connectŽ avec la destination spŽcifiŽe par le client, et renvoit ˆ lÕappelant un descripteur
de socket. Les Žchanges futurs avec ce client se feront donc par lÕintermŽdiaire de ce
socket.
Le socket initiale sockfd nÕa donc pas de destination et reste ouvert pour
accepter de futures demandes.
Tant quÕil nÕy a pas de connexions le serveur se bloque sur cette appel.
LorsquÕune demande de connexion arrive, lÕappel syst•me accept se termine. Le
serveur peut gŽrer les demandes itŽrativement ou simultanŽment :
Dans lÕapproche itŽrative, le serveur traite lui m•me la requ•te, ferme le
nouveau socket puis invoque de nouveau accept pour obtenir la demande suivante.
Dans lÕapproche parall•le, lorsque lÕappel syst•me accept se termine le serveur
crŽe un serveur fils chargŽ de traiter la demande (appel de fork et exec). Lorsque le fils
a terminer il ferme le socket et meurt. Le serveur ma”tre ferme quand ˆ lui la copie du
nouveau socket apr•s avoir exŽcutŽ le fork. Il appel ensuite de nouveau accept pour
obtenir la demande suivante.
Exemple de serveur itŽratif
int sockfd, newsockfd ;
if ( ( sockfd = socket ( ..)) < 0 )
err_sys(Òerreur de socketÒ) ;
if ( bind ( sockfd, .) < 0 )
err_sys (Òerreur de bindÓ)
if ( listen ( sockfd , 5) < 0 ) ;
err_sys (Ò erreur de listenÓ ) ;
37
for ( ; ; ) {
newsockfd = accept ( sockfd, ..) ;
if ( newsockfd < 0)
err_sys( Òerreur de acceptÓ) ;
execute_la_demande( newsockfd ) ;
close ( newsockfd ) ;
}
Exemple de serveur ˆ acc•s concurrent
int sockfd, newsockfd ;
if ( ( sockfd = socket ( ..)) < 0 )
err_sys(Òerreur de socketÒ) ;
if ( bind ( sockfd, .) < 0 )
err_sys (Òerreur de bindÓ)
if ( listen ( sockfd , 5) < 0 ) ;
err_sys (Ò erreur de listenÓ ) ;
for ( ; ; ) {
newsockfd = accept ( sockfd, ..) ;
if ( newsockfd < 0)
err_sys( Òerreur de acceptÓ) ;
if ( fork() == 0 ) {
close ( sockfd ) ;
execute_la_demande( newsockfd ) ;
exit (1) ;
}
close ( newsockfd ) ;
}
V - ƒCHANGES DÕINFORMATIONS SUR UN SOCKET
1- EMISSION DÕINFORMATION
Une fois que le programme dÕapplication dispose dÕun socket, il peut lÕutiliser
afin de transfŽrer des donnŽes. Cinq appels syst•me sont utilisables : send, sendto,
sendmsg, write et writev. Send, write et writev ne sont utilisables quÕavec des sockets
en mode connectŽ car ils ne permettent pas dÕindiquer dÕadresse de destination. Les
diffŽrences entre ces trois appels sont mineures :
#include <sys/types.h>
#include <sys/socket.h>
write ( int sockfd, char *buff, int nbytes ) ;
writev ( int sockfd, iovec *vect_E/S, int lgr_vect_E/S ) ;
int send (int sockfd, char *buff, int nbytes, int flags ) ;
socket
contient le descripteur de socket .
buff
est un pointeur sur un tampon o• sont stockŽes les donnŽes ˆ envoyer.
nbytes
est le nombre dÕoctets ou de caract•res que lÕon dŽsire envoyer
vect_E/S
est un pointeur vers un tableau de pointeurs sur des blocs qui constituent
38
le
message ˆ envoyer.
flags
drapeau de contr™le de la transmission :
Pour le mode non connectŽ on a deux appels sendto et sendmsg qui imposent
dÕindiquer lÕadresse de destination :
#include <sys/types.h>
#include <sys/socket.h>
int sendto (int sockfd, char *buff, int nbytes, int flags, struct sockaddr *to, int addrlen) ;
Les quatres premiers arguments sont les m•mes que pour send, les deux derniers
sont lÕadresse de destination et la taille de cette adresse.
Pour les cas o• on utiliserait frŽquemment lÕappel sendto qui nŽcessite beaucoup
dÕarguments et qui serait donc dÕune utilisation trop lourde on dŽfinit la structure
suivante:
struct struct_mesg {
int *sockaddr ;
int sockaddr_len ;
iovec *vecteur_E/S
int vecteur_E/S_len
int *droit_dÕacces
int droit_dÕacces_len
}
Cette structure sera utilisŽe par lÕappel sendmsg :
int sendmsg ( int sockfd, struct struct_mesg, int flags ) ;
2 - RECEPTION DÕINFORMATION
On distingue 5 appels syst•me de rŽception dÕinformation qui sont symŽtriques
au appels dÕenvoi. Pour le mode connectŽ on a les appelles read, readv et recv et pour le
mode sans connexion on a les appelles recvfrom et recvmsg.
int read ( int sockfd, char *buff, int nbytes ) ;
int readv ( int sockfd, iovec *vect_E/S, int lgr_vect_E/S ) ;
int recv (int sockfd, char *buff, int nbytes, int flags ) ;
sockfd
est le descripteur sur lequel les donnŽes seront lues .
buff
est un pointeur sur un buffer o• seront stockŽes les donnŽes lues
nbytes
est le nombre maximal dÕoctets ou de caract•res qui seront lus.
readv permet de mettre les donnŽes lues dans des cases mŽmoire non contigu‘s.
Ces cases mŽmoires sont pointŽes par un tableau de pointeurs qui lui m•me est pointŽ
par vect_E/S.
lgr_vect_E/S est la longueur de ce tableau.
Pour le mode sans connexion, il faut prŽciser les adresses des correspondants
desquels on attend des donnŽes.
39
int recvfrom (int sockfd, char *buff, int nbytes, int flags, struct sockaddr *from
int addrlen) ;
Pour les m•mes raisons que pour sendto et sendmsg, et pour des raison de
symŽtrie on a dŽfinie lÕappel recvmsg qui utilise la m•me structure que sendmsg.
int recvmsg ( int sockfd, struct struct_mesg, int flags ) ;
DETAIL DES ARGUMENTS FLAGS
Les arguments flags sont soit zŽro soit le rŽsultat dÕun or entre les trois
constantes suivantes :
MSG_OOB
Žmission ou rŽception de donnŽes hors bande
MSG_PEEK
peek at incoming message (recv or recvfrom )
MSG_DONTROUTE bypass routing (send or sendto )
The MSG_PEEK flag lets the caller look at the data thatÕs available to be read, without
having the syst•me discard the data after the recv or recvfrom returns.
MSG_DONTROUTE sera detaillŽ dans les options de socket.
MSG_OOB : les donnŽes hors bande
Les donnŽes hors bande sont des donnŽes urgentes.
Les donnŽes hors bande sont des transmissions indŽpendantes entre une paire de
socket connectŽs. Les donnŽes hors bande sont dŽlivrŽes indŽpendamment des donnŽes
normales. Pour les protocoles de communication qui ne supportent pas les donnŽes hors
bande, les messages urgents sont extraits du flux de donnŽes et stockŽs sŽparŽment.
Ceci laisse le choix ˆ lÕutilisateur entre recevoir les donnŽes urgentes dans lÕordre ou
pas, sans avoir ˆ les stocker dans un buffer.
Si un socket poss•de un process-group, un signal SIGURG est gŽnŽrŽ quand
leprotocole prend connaissance de lÕarrivŽe dÕune donnŽe hors bande. Le process-
group ou le process id qui devra •tre informŽ de lÕarrivŽe dÕune donnŽe urgente peut
•tre initialisŽ par la fonction fcntl().
si plusieurs sockets sont susceptibles de recevoir des donnŽes hors bande,
lÕappel de la fonction select() permet de sŽlectionner le socket devant recevoir la
donnŽe urgente. Pour envoyer des donnŽes hors bande, lÕoption MSG_OOB doit •tre
utilisŽe lors de lÕappel de send() ou sendto().
LE MULTIPLEXAGE
LÕappel syst•me qui permet le multiplexage des sockets est select().
select() examine les descripteurs qui lui sont passŽs en param•tre et teste si
certains sont pr•ts ˆ lire, Žcrire ou ont une condition dÕexception. Les donnŽes hors
bande sont les seules conditions dÕexception que peut recevoir un socket.
description de lÕappel syst•me select():
int select ( int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval
*timeout )
On ne sÕattardera pas sur les structures passŽes en param•tre, seuls les fonctions
40
qui permettront leur manipulation seront dŽtaillŽes. Les arguments 2, 3 et 4 de select
sont des pointeurs sur des structures qui contiendront les descripteurs de sockets ˆ tester
en lecture, Žcriture et en rŽception dÕexception par le select.
Le dernier argument timeout, sÕil est non nul , spŽcifie lÕintervalle de temps
maximal ˆ attendre avant de sortir de select. Si ce pointeur est nulle select() bloquera
indŽfiniment. Pour rŽaliser un polling sur select() ( i.e. select ne rendra la main que
lorsquÕau moins un descripteur aura ŽtŽ sŽlectionnŽ ) le pointeur timeout doit •tre non
nul mais pointant sur une STRUCTURE timeval nulle.
A la fin de select les structures passŽes en arguments contiennent les
descripteurs sŽlectionnŽs par la fonction select
Avant dÕappeler select() , il faut initialiser ses arguments. On commencera
toujours par les initialiser ˆ une structure nulle par la fonction FD_ZERO (fd_set
&fdset).
void FD_SET ( int fd, fd_set &fdset ) ajoute le descripteur fd ˆ fdset.
void FD_CLR ( int fd, fd_set &fdset ) retire le descripteur fd a fdset.
A la fin de select, la fonctionint FD_ISSET ( int fd, fd_set &fdset ) nous permet
de savoir si le descripteur fd est sŽlectionnŽ dans fdset ou non. cette fonction est ˆ
appeler apr•s select().
41
VI- ENCHAINEMENT DES APPELS SYSTEMES
1- mode connectŽ
Deux approches de programmation de serveurs se prŽsentent: lÕapproche
itŽrative et lÕapproche parall•le.
Rappelons que dans lÕapproche itŽrative, le serveur traite lui m•me la requ•te,
ferme le nouveau socket puis invoque de nouveau accept pour obtenir la demande
suivante.
LÕenchainement dans le temps des appels syst•me pour un serveur itŽratif se
rŽsume par la figure suivante:
SERVEUR EN MODE CONNECTE
SOCKET()
BIND()
LISTEN()
CLIENT EN MODE CONNECTE
Attente de
ACCEPT()
SOCKET()
la connexion
client
CONNECT()
connexion
WRITE()
READ()
requ•te
rŽponse
WRITE()
READ()
Fig 10
42
Dans lÕapproche parall•le, lorsque lÕappel syst•me accept se termine le serveur
crŽe un serveur fils chargŽ de traiter la demande (appel de fork et exec). Lorsque le fils
a terminer il ferme le socket et meurt. Le serveur ma”tre ferme quand ˆ lui la copie du
nouveau socket apr•s avoir exŽcutŽ le fork. Il appel ensuite de nouveau accept pour
obtenir la demande suivante.
LÕenchainement des appels syst•mes pour un serveur parall•le se rŽsume par la
figure suivante:
SOCKET()
BIND()
LISTEN()
SELECT()
ACCEPT()
FORK()
fils
P•re
CLOSE(mastersock)
CLOSE(slavesock)
READ()
WRITE()
EXIT()
Fig 11
43
2- mode non connectŽ
Dans le cas dÕun protocole sans connexion, les appels syst•me sont diffŽrents.
Le client nÕŽtablit pas de connexion avec le serveur. Le client envoit un datagramme au
serveur en utilisant lÕappel syst•me sendto(). SymŽtriquement le serveur nÕaccepte pas
de connexion dÕun client, mais attend un datagramme dÕun client avec lÕappel syst•me
recvfrom(). Ce dernier revoie lÕadresse rŽseau du client, avec le datagramme, pour que
le serveur puisse rŽpondre ˆ la bonne adresse.
lÕenchainement dans le temps des appels syst•mes pour une communication en
mode non connectŽ et pour un serveur itŽratif se rŽsume par la figure suivante:
SERVEUR EN MODE DECONNECTE
SOCKET()
CLIENT EN MODE DECONNECTE
BIND()
SOCKET()
RECVFROM()
BIND()
bloque en attendant des donnŽes d'un client
requ•te
SENDTO()
SENDTO()
rŽponse
RECVFROM()
Fig 12
44
LÕenchainement dans le temps des appels syst•mes pour une communication en
mode non connectŽ et pour un serveur parall•le se rŽsume par la figure suivante:
SOCKET()
BIND()
LISTEN()
SELECT()
RECVFROM()
FORK()
fils
P•re
CLOSE(mastersock)
CLOSE(slavesock)
RECVFROM()
SENDTO()
EXIT()
Fig 13
45
VII - DES PROCEDURES BIEN UTILE !
1- PROCEDURES RƒSEAU DE CONVERSION DE LÕORDRE DES OCTETS
Les machines ont des fa•ons diffŽrentes dÕenregistrer les entiers et les protocoles
TCP/IP ont une reprŽsentation des octets normalisŽe et indŽpendante des machines.
Pour que les programmes soient portables sur toutes les machines il faut pouvoir
convertir les reprŽsentations rŽseaux en reprŽsentation machine a chaque de paquet et
vice et versa.
Les fonction de conversion sont les suivantes :
htonl (val)
host to network long : convertit une valeur sur 32 bits de la reprŽsentation
machine vers la reprŽsentation rŽseau.
htons (val)
host to network short : convertit une valeur sur 16 bits de la reprŽsentation
machine vers la reprŽsentation rŽseau.
ntohl (val)
network to host long : convertit une valeur sur 32 bits de la reprŽsentation rŽseau
vers la reprŽsentation machine.
ntohs (val)
network to host short : convertit une valeur sur 16 bits de la reprŽsentation
rŽseau
vers la reprŽsentation machine.
2- LES OPERATIONS SUR LES OCTETS
Pour initialiser une structure o• pour la mettre ˆ jour on dispose de deux
fonctions:
Tout dÕabord la fonction bzero() qui initialise ˆ zŽro tous les champs de la
structure passŽe en param•tre. Cette fonction doit •tre appelŽe avant lÕutilisation de la
structure.
Il y a aussi la fonction bcopy() qui a pour param•tre deux structures et un entier
n qui indique le nombre dÕoctets ˆ copier. Cette fonction copie les n premiers octets de
la structure 1 dans la structure 2.
Les listings de ces deux fonctions sont donnŽs ˆ la fin de cet ouvrage.
3 -DEMANDER ET DEFINIR LES NOMS DE MACHINE
Le syst•me dÕexploitation UNIX g•re en interne un nom de machine. Pour les
machines reliŽes ˆ lÕInternet , le nom interne co•ncide gŽnŽralement avec celui du
domaine qui correspond avec lÕinterface rŽseau principale. LÕappel syst•me Òrechercher
le nom de la machineÓ ( gethostname ) permet aux processus utilisateurs dÕaccŽder au
nom de la machine. LÕappel syst•me ÒdŽfinir le nom de la machineÓ ( sethostname )
permet ˆ des processus privilŽgiŽs de dŽfinir le nom de la machine.
46
Ces appels ont la forme suivante :
gethostname ( nom, longueur ) ;
sethostname ( nom, longueur ) ;
nom
est un pointeur sur une cha”ne de caract•res contenant le nom de la
machine
longueur
est la taille du nom.
4- OBTENIR DES INFORMATIONS RELATIVES AUX MACHINES
Il existe des biblioth•ques de procŽdures qui permettent de retrouver
lÕinformation relative ˆ une machine ˆ partir de son nom de domaine ou de son adresse
IP. LorsquÕelles sont utilisŽes sur des machines qui ont acc•s ˆ un serveur de noms de
domaines. Elles Žmettent une requ•te et attendent la rŽponse. LorsquÕelles sont utilisŽes
sur des machines qui nÕont pas acc•s ˆ un serveur de nom, les machines obtiennent les
informations ˆ partir dÕune base de donnŽes stockŽe sur mŽmoire secondaire.
La fonction gethostbyname (rechercher une machine par son nom) accept un
nom de domaine et renvoie un pointeur vers une structure qui contient lÕinformation
relative ˆ cette machine. LÕappel est le suivant :
ptr = gethostbyname (char *cha”ne_nom) ;
la structure o• gethostbyname met les information est la suivante :
struct hostent {
char
*h_name ;
/*nom officiel de la machine*/
char
*h_aliases ;
/*liste des surnoms de cette machine*/
int
h_addrtype ;
/*type dÕadresse (exple adresse IP) */
int
h_length ;
/*longueur de lÕadresse */
char
**h_addr_list ;
/*liste des adresses de la machine */
/*une machine peut avoir plusieurs
adresses
comme cÕest le cas pour les routeurs
*/
}
#define h_addr a_addr_list[0] ;
La fonction gethostbyaddr ( rechercher une machine par son adresse) produit le
m•me rŽsultat . La diffŽrence entre les deux est que cette fonction a pour argument
lÕadresse de la machine.
ptr = gethostbyaddr (char *addr,int lgr,int type ) ;
addr pointe vers lÕadresse de la machine.
lgr
longueur de lÕadresse.
type
indique le type dÕadresse ( adresse IP par exemple ).
47
5- OBTENIR DES INFORMATIONS RELATIVES AUX RƒSEAUX
De la m•me fa•on que pour lÕacc•s aux informations sur les machines ˆ travers
le rŽseau ou une base de donnŽes, on peut accŽder aux informations sur le rŽseau par les
procŽdures Òrechercher-nom-du rŽseau-par-nomÓ (getnetbyname). Cette procŽdure
prend comme param•tre un nom de rŽseau et rempli une structure dont elle retourne le
pointeur.
ptr = getnetbyname (char *nom) ;
la structure remplie est la suivante :
struct netent {
char
*n_name ;
/*nom officiel de rŽseau *:
char
**n_aliases ;
/*surnom du rŽseau */
int
n_addrtype ;
/*type dÕadresse */
int
n_net ;
/*adresse du rŽseau sur 32 bits */
/*une adresse IP par exple o• le numŽro de
machine sera zŽro */
} ;
La fonction getnetbyaddr ( rechercher-nom-de rŽseau-par-adresse) produit le
m•me rŽsultat. La diffŽrence entre les deux est que cette fonction a pour argument
lÕadresse de la machine.
ptr = getnetbyaddr (addr_net, type ) ;
addr_net
est une adresse sur 32 bits.
type
indique le type dÕadresse.
6 - OBTENIR DES INFORMATIONS RELATIVES AUX PROTOCOLES
Dans la base de donnŽes des protocoles disponibles sur la machine, chaque
protocole a un nom officiel, des alias (surnoms) officiels et un numŽro de protocole
officiel. La procŽdure getprotobyname permet dÕobtenir des informations sur le
protocole en donnant son nom.
ptr = getprotobyname( char *proto_name) ;
la fonction renvoie un pointeur sur la structure dÕinformation suivante :
struct protoent {
char
*p_name ;
/*nom officiel du protocole*/
char
**p_aliases ;
/*surnoms du protocoles*/
int
p_proto ;
/*numŽro du protocole*/
} ;
La fonction getprotobynumber produit le m•me rŽsultat mais fournie comme argument
le numŽro du protocole.
ptr = getprotobynumber (int num_proto ) ;
48
7- OBTENIR DES INFORMATIONS RELATIVES AUX SERVICES RƒSEAUX
Certains numŽros de ports sont rŽservŽs pour TCP comme pour UDP, ainsi par
exemple le port 43 correspond au service whois (qui_est_ce) qui permet de donner des
informations sur les utilisateurs dÕune machine serveur.
la procŽdure getservbyname permet dÕobtenir des informations sur le service en
donnant comme argument une cha”ne de caract•res contenant le numŽro du port, et une
cha”ne contenant le protocole utilisŽ.
ptr = getservbyname (char *num_port, char *proto) ;
ptr pointe sur la structure suivante :
struct servent {
char
*s_name ;
/*nom du service */
char
**s_aliases ;
/*surnoms du service*/
int
s_port ;
/*numŽro du port */
char
*s_proto ;
/*nom du protocole*/
}
49
VIII- EXEMPLE DE PROGRAMME DE CLIENT/SERVEUR
LÕexemple que nous allons dŽvelopper concerne une application de transfert de
fichier. Le client apr•s lÕŽtablissement de la connexion, fournit au serveur un nom de
fichier ( qui correspondra dans le cas de cette application ˆ un signe astrologique) et le
serveur envoi au client le contenu de son fichier ( qui sera donc lÕhoroscope de la
semaine).
1 - exemple de client
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
/* programme client */
main(argc,argv)
int argc ;
char *argv[] ;
{
int sd,lon ;
struct sockaddr_in adsock;
struct hostent *hptr ;
/* infos recuperes sur le host */
struct servent *sptr ;
/* infos recuperes sur le service */
char buf[256] ;
/*buffer de lecture des infos */
char *prog ;
/*nom de ce programme */
char *host ;
/*pointeur sur le nom du host distant */
char *mesg ;
char *resg ;
/*pointeur sur l'utilisateur distant */
prog = argv[0] ;
/* verification du nombre d'arguments de la ligne de commande */
if (argc != 3) {
printf("il faut trois arguments\n") ;
exit(1) ;
}
host = argv[1] ;
mesg = argv[2] ;
/* prendre les infos sur le host */
if((hptr = gethostbyname(host)) == NULL) {
printf("probleme d'infos sur le host \n") ;
exit(1) ;
}
/* initialiser la struct adsock avec les infos recuperes */
/* c a d l'adresse du host et le domaine internet */
bcopy((char *)hptr->h_addr,(char*)&adsock.sin_addr,hptr->h_length) ;
adsock.sin_family = hptr->h_addrtype ;
50
/* prendre les infos sur le service */
if((sptr = getservbyname("2223","tcp")) == NULL ) {
printf("probleme d'infos sur le service \n") ;
exit(1) ;
}
/* recupere le numero du port */
adsock.sin_port = sptr->s_port ;
/* creer maintenant un socket */
if((sd = socket(AF_INET,SOCK_STREAM,0))<0) {
printf("probleme lors de la creation de socket \n") ;
exit(1) ;
}
/* etablir la connexion avec le serveur */
if((connect(sd,( struct sockaddr * ) &adsock,sizeof(adsock))) < 0 ) {
printf("probleme de connexion \n") ;
exit(1) ;
}
/* on va envoyer la requete */
if((write(sd, mesg, strlen(mesg))) < 0 ) {
printf("erreur sur le write \n") ;
exit(1) ;
}
/* lecture de la reponse du serveur */
while((lon =read(sd, buf, sizeof(buf))) > 0)
/* affichage de la reponse sur l'ecran */
write(1, buf, lon) ;
/* on ferme le socket */
close(sd) ;
exit(0) ;
}
51
2 - Exemple de serveur
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#define MAXNOM 32
void renvoi(int s) ;
/* programme serveur */
main(argc,argv)
int argc ;
char *argv[] ;
{
int sd,lacc, nsd ;
struct sockaddr_in adsock, adacc; /* struc adresse internet */
struct hostent *hptr ; /* infos recuperes sur le host */
struct servent *sptr ;
/* infos recuperes sur le service */
char machine[MAXNOM+1] ; /* nom de la machine locale */
char *prog ;
/*nom de ce programme */
char *mesg ;
prog = argv[0] ;
/* prendre les infos sur le service */
if((sptr = getservbyname("2223","tcp")) == NULL ) {
printf("probleme : service inconnu\n") ;
exit(1) ;
}
/* recuperer le nom de la machine locale */
gethostname(machine,MAXNOM) ;
/* prendre les infos sur la machine locale */
if((hptr = gethostbyname(machine)) == NULL) {
printf("probleme : host inconnu\n") ;
exit(1) ;
}
bzero((char*)&adsock, sizeof(adsock));
/*initialiser la struct adsock avec les infos recuperes */
bcopy((char *)&hptr->h_addr,(char*)&adsock.sin_addr,hptr->h_length) ;
adsock.sin_family = AF_INET ;
/* recupere le numero du port */
adsock.sin_port = sptr->s_port ;
adsock.sin_addr.s_addr = INADDR_ANY ;
52
/* creer maintenant un socket */
if((sd = socket(AF_INET,SOCK_STREAM,0))<0) {
printf("probleme lors de la creation de socket \n") ;
exit(1) ;
}
/* on va fair un bind sur le socket */
if(bind(sd,(struct sockaddr *) &adsock ,sizeof(adsock) ) == -1 ) {
printf("probleme avec le bind \n") ;
exit(1) ;
}
/*initialiser la queue d'ecoute */
listen(sd,5) ; /* backlog = 5 */
/* bouble d'attente de nouvelles connexions */
for(;;){
lacc = sizeof(adacc) ;
/* boucle d'accept */
if((nsd = accept(sd, ( struct sockaddr * ) &adacc, &lacc)) < 0 )
{
/* adacc -> infos du client */
printf("erreur sur l'accept \n") ;
exit(1) ;
}
renvoi(nsd) ;
close(nsd);
}
}
/* fonction renvoi */
void renvoi(s)
int s ;
{
char buf[256];
char *fichier;
char f[20];
char *mesgptr;
char mesg[250];
int l, c;
FILE *fp ;
char line[250] ={0} ;
char *lineptr = NULL;
/* lire une requete */
if((l=read(s, buf, sizeof(buf))) <= 0)
return ;
buf[l] = '\0' ; /*fin de chaine */
fichier=f;
if (!strcmp(buf,"lion")) fichier = "lion" ;
if (!strcmp(buf,"cancer")) fichier = "cancer" ;
if (!strcmp(buf,"scorpion")) fichier = "scorpion" ;
if (!strcmp(buf,"taureau")) fichier = "taureau" ;
53
if (!strcmp(buf,"vierge")) fichier = "vierge" ;
if (!strcmp(buf,"poisson")) fichier = "poisson" ;
if (!strcmp(buf,"capricorne")) fichier = "capricorne" ;
if (!strcmp(buf,"balance")) fichier = "balance" ;
if (!strcmp(buf,"belier")) fichier = "belier" ;
if (!strcmp(buf,"verseau")) fichier = "verseau" ;
if (!strcmp(buf,"gemeaux")) fichier = "gemeaux" ;
if((fp=fopen(fichier,"r"))==NULL) {
printf("erreur lors de l'ouverture du fichier\n");}
while(fgets(line,240,fp)){
write(s, line, strlen(line)) ;
}
return ;
}
54
IX - LES APPELS SYSTEME SOCKET AVANCES
1- LÕappel syst•me getpeername
#include <sys/types.h>
#include<sys/socket.h>
int getpeername (int sockfd, struct sockaddr *peer, int *addrlen ) ;
Cette appel syst•me rend le ÒnomÓ du processus correspondant auquel le socket
est connectŽ. Le nom rendu est en fait lÕadresse de la machine correspondante et le
processus correspondant.
2- LÕappel syst•me getsockname
#include <sys/types.h>
#include<sys/socket.h>
int getsockname (int sockfd, struct sockaddr *peer, int *addrlen ) ;
Cette appel rend le nom associŽ au socket cÕest ˆ dire lÕadresse de la machine locale et
le processus local.
3- LÕappel syst•me shutdown
La fa•on normale de clore une session de connexion rŽseau est de faire lÕappel
syst•me close. Cette appel a la propriŽtŽ au moment de son appel de tenter de dŽlivrer
toutes les donner qui sont encore ˆ envoyer. LÕappel shutdown fourni plus de moyens
de contr™le de la connexion au moment de sa fermeture.
int shutdown (int sockfd, int howto) ;
Si howto = 0 aucune donnŽe ne peut •tre re•ue sur le socket.
Si howto = 1 aucune donnŽe ne peut •tre envoyŽe sur le socket.
Si howto = 2 aucune donnŽe ne peut •tre re•ue ou envoyŽe sur le socket.
4 - Les ports rŽservŽs
Il y a deux fa•ons pour un process dÕavoir un numŽro de port :
¥ Le process demande un numŽro de port spŽcifique. Ce qui est le cas pour les
serveurs qui ont besoin dÕun numŽro de port bien connu.
¥ Le process peut aussi laisser le syst•me lui allouer un numŽro de port
automatiquement. En pratique, cela se fait en faisant un appel bind avec comme
argument de port zŽro.
Pour TCP comme pour UDP dans le domaine Internet, il y a des ports rŽservŽs.
Ces derniers vont de 1 ˆ 1023. Le fichier etc/services contient les numŽros de ports
rŽservŽs et les services associŽs. Voici une partie de ce fichier:
55
#
# Network services, Internet style
#
echo
7/tcp
echo
7/udp
systat
11/tcp
users
daytime
13/tcp
daytime
13/udp
netstat
15/tcp
ftp-data
20/tcp
ftp
21/tcp
telnet
23/tcp
smtp
25/tcp
time
37/tcp
timserver
time
37/udp
timserver
name
42/udp
nameserver
whois
43/tcp
nicname
domain
53/udp
domain
53/tcp
hostnames
101/tcp
hostname
# Ajout pour Wais
z3950 210/tcp wais # Wide Area Information Server
LÕinstruction rresvport () fournie ˆ son appelant un socket TCP rŽservŽ.
int rresvport ( int *aport ) ;
Cette fonction crŽe un socket stream Internet et fait un bind avec un port rŽservŽ.
Elle retourne le descripteur de sockets ou -1 sÕil y a eu un probl•me. LÕargument aport
est un pointeur sur un entier qui est le premier port ˆ partir duquel le bind sera fait.
Internet
ports rŽservŽs
1-1023
ports automatiquement allouŽs par le syst•me
1024-5000
ports allouŽs par lÕinstruction rresvport()
512-1023
rŽsumŽ des allocations de port
56
X - DEMANDER DES OPTIONS DE SOCKET
En plus de lÕassociation dÕun socket ˆ une adresse locale ou de sa connexion a
une adresse de destination, appara”t la nŽcessitŽ dÕun mŽcanisme qui permette aux
programmes dÕapplication de piloter les sockets.
Ainsi lors de lÕutilisation de protocoles utilisants temporisateurs et
retransmission, les programmes dÕapplications peuvent souhaiter conna”tre ou dŽfinir
les valeurs de temporisateur. Il peuvent ainsi contr™ler lÕallocation de la mŽmoire
tampon, vŽrifier si le socket autorise la diffusion ou la gestion des donnŽes hors bande.
Plut™t que dÕajouter des primitives pour chaque opŽration de contr™le, les concepteurs
ont choisi de construire un mŽcanisme unique. Ce dernier ne comporte que deux
opŽrations : getsockopt et setsockopt.
LÕappel syst•me getsockopt permet ˆ lÕapplication de demander les informations
relatives au socket. LÕappelant indique le socket, les options intŽressantes et un tampon
o• enregistrer les informations demandŽes. Le syst•me dÕexploitation analyse ses
structures de donnŽes internes relatives au socket et transmet lÕinformation ˆ lÕappelant.
LÕappel est le suivant :
#include <sys/types.h>
#include <sys/socket.h>
int getsockopt (int sockfd, int level, int optname, char *optval, int *optlen ) ;
sockfd dŽsigne le socket sur lequel les informations sont demandŽes.
level indique si lÕopŽration sÕapplique au socket lui m•me ou ˆ un protocole sous-jacent
(TCP IP )
optname indique lÕoption unique ˆ laquelle sÕapplique lÕopŽration
les deux derniers argument sont respectivement le tampon o• seront mis les
informations, et la taille des informations mises dans le tampon.
LÕappel setsockopt permet ˆ lÕapplication de dŽfinir les options de socket :
#include <sys/types.h>
#include <sys/socket.h>
int setsockopt (int sockfd, int level, int optname, char *optval, int *optlen ) ;
Les dŽfinitions des arguments sont identiques ˆ ceux de getsockopt.
Le tableau suivant rŽsume les options de socket
57
level
optname
get
set
Description
flag
type de
donnŽes
IPPROTO_IP
IP_OPTIONS
¥
¥
option de lÕent•te IP
IPPROTO_TCP TCP_MAXSEG
¥
donne la taille max dun
¥
int
segment tcp
TCP_NODELAY
¥
¥
ne pas retarder lÕenvoie
int
pour unir des paquets
SOL_SOCKET
SO_DEBUG
¥
¥
permet des infos de
¥
int
debuggage
SO_DONTROUTE
¥
¥
utilise juste les adresses
¥
int
dÕinterface
SO_ERROR
¥
rend le status de lÕerreur
¥
int
SO_LINGER
¥
¥
contr™le de lÕenvoie des
struct
donnŽes apr•s close
linger
SO_OOBINLINE
¥
¥
concerne la rŽception de
¥
int
donnŽes hors dande
SO_RCVBUF
¥
¥
taille du buffer de
int
rŽception
SO_SNDBUF
¥
¥
taille du buffer dÕenvoi
int
SO_RCVTIMEO
¥
¥
timeout de rŽception
int
SO_SNDTIMEO
¥
¥
timeout dÕemission
int
SO_REUSEADDR
¥
¥
autorise la rŽutilisabilitŽ de
¥
int
lÕadresse locale
SO_TYPE
¥
fournit le type de socket
int
Les options des sockets
IP_OPTIONS :
permet au programmeur de spŽcifier des options dans lÕent•te des
trames IP. Ce qui nŽcessite une bonne connaissance de lÕent•te IP
TCP_MAXSEG :
Retourne la taille maximum de segment utilisŽ pour le socket. La
valeur typique est 1024 octets. Notons que cette valeure affectŽe
par le syst•me ne peut •tre modifiŽe par le programmeur.
TCP_NODELAY : Cette option est utilisŽe dans les rŽseaux lents o• le syst•me
bufferise les commandes ˆ envoyer en attendant la rŽponse du
serveur des requ•tes prŽcŽdentes pour afficher lÕecho.
Lorsque le clients se dŽroule sur un terminal ˆ fen•tre lÕecho nÕest
pas nŽcessaire et lÕoption TCP_NODELAY court-circuite
lÕalgorithme de mise dans le buffer pour que les donnŽes soient
transmises le plus t™t possible cÕest ˆ dire aussi t™t que le rŽseau
le permet.
SO_DEBUG :
Autorise ou pas de debugage au niveau bas dans le noyau. Cette
option autorise le noyau a maintenir un historique des rŽcents
paquets envoyŽs ou re•us.
SO_DONTROUTE : SpŽcifie que les messages sortant doivent passer par les
mŽcanismes de routage normaux des couches basses au lieu
dÕ•tre
dirigŽs vers lÕinterface rŽseau appropriŽe comme spŽcifiŽ dans la
portion rŽseau de lÕadresse de destination.
58
SO_ERROR :
Retourne ˆ lÕappelant le contenu de la variable so_error, qui est
dŽfinie dans <sys/socketvar.h>. Cette variable contient les valeurs
standards des numŽros dÕerreurs UNIX.
SO_LINGER :
Cette option dŽtermine ce quÕil faut faire quand il existe des
messages non envoyŽs pour un socket quand le processus a
exŽcutŽ close sur le socket. Par dŽfaut, close sÕexŽcute
immŽdiatement et le syst•me tente de livrer les donnŽes non
envoyŽes.
Si lÕoption linger est activŽe lÕaction dŽpend de la variable linger
time spŽcifiŽe par lÕutilisateur : si elle est Žgal ˆ zŽro, toute
donnŽes
ˆ envoyer apr•s le close ne sera pas transmise. Sinon elle sera
transmise.
SO_OOBINLINE : Cette option spŽcifie que les donnŽes hors band doivent aussi •tre
placer dans la queue dÕentrŽe. Quand les donnŽes hors bande sont
rŽception nÕest pas nŽcessaire pour lire les donnŽes hors bande.
SO_RCVBUF et SO_SNDBUF : SpŽcifie la taille du buffer de rŽception et
dÕemission pour le socket. Cette option nÕest nŽcessaire que
lorsque lÕon dŽsir une taille de buffer supŽrieure ˆ celle que lÕon a
par dŽfaut.
SO_RCVTIMEO et SNDTIMEO : Ces deux options spŽcifie les valeur de timeout
pour la et lÕenvoie de messages. Cette option est rarement utilisŽe
dans les applications.
SO_REUSEADDR : Informe le syst•me pour quÕil autorise lÕadresse locale ˆ •tre
rŽutilisŽe. Normalement le syst•me nÕautorise pas la rŽutilisation
de
lÕadresse locale; quand connect est appelŽ il requiert que lÕadresse
locale soit unique.
SO_TYPE :
retourne le type de socket. La valeure enti•re retournŽe est une
valeure comme SOCK_STREAM ou SOCK_DGRAM. Cette
option est typiquement appelŽe par un process qui hŽrite un
socket
quant il commence ˆ sÕexŽcuter.
59
TROISIEME PARTIE
LES PROGRAMMES DEVELOPPES
60
L'application dŽveloppŽe consiste en un jeu o• le client essaye de deviner un mot cachŽ
par le serveur. Le client propose successivement des lettres et le serveur lui rŽpond en
lui signalant lÕexistence ou non de la lettre dans le mot cachŽ. Le client a un nombre
d'essais limitŽ pour deviner ce mot.
Programme Client.c
#include <stdio.h>
/* machine, service et protocole par defaut */
#define DEFHOST "localhost"
#define DEFSERVICE "daytime"
#define DEFPROTOCOL "tcp"
/***********************************************************/
/*
*/
/* Ce programme appelle la fonction setsock avec les arguments passes */
/* par l'utilisateur.
*/
/*
*/
/* Exemlple dÕutilisation : client ensisun 1345 udp
*/
/* Les arguments a passer sont:
*/
/*
*/
/*
1) la machine distante sur laquelle s'excecute le serveur.
*/
/*
par defaut c'est la machine locale.
*/
/*
*/
/*
2) le port avec lequel on peut communiquer avec le serveur.
*/
/*
par defaut c'est le port correspondant au service daytime.
*/
/*
*/
/*
3) le protocole de communication ( TCP ou UDP ).
*/
/*
par defaut c'est le protocole TCP.
*/
/*
*/
/*
*/
/*
AUTEURS:
*/
/*
JAZOULI Abdelillah
*/
/*
RADI
Nour-eddine
*/
/*
ZGHAL
Tarek
*/
/*
*/
/*
DATE:
JUIN 1994
*/
/*
*/
/*
*/
/***********************************************************/
int main(argc,argv)
int argc;
/* nombre d arguments passes par l'utilisateur
*/
char *argv[]; /* pointeur sur les arguments
*/
/* argv[0] contient le nombre d'arguments
*/
{
/* nom ou numero de la machine distante supportant le serveur */
char *host = DEFHOST;
61
/* numero de port ou nom d'un service connu */
char *service = DEFSERVICE;
/* nom du protocole utilise TCP ou UDP */
char *protocol = DEFPROTOCOL;
/* descripteur du socket */
int sock;
/* ce switch initialise les varibles host, port et protocole
*/
/* suivant le nombre d'arguments passes par l'utilisateur
*/
switch (argc)
{
case 1:
/* 0 arguments passes en parametre */
break;
case 2:
/* 1 argument passe en parametre */
host = argv[1];
break;
case 3:
/* 2 arguments passes en parametre */
host = argv[1];
service = argv[2];
break;
case 4:
/* 3 arguments passes en parametre */
host = argv[1];
service = argv[2];
protocol = argv[3];
break;
default:
/* probleme dans le nombre d'arguments */
printf("erreur: usage:connection[serveur-port-protocol]\n");
exit(1);
}
/*****************************************************************/
/*
*/
/* appel de la fonction setsock qui va allouer un socket au client.
*/
/* la valeur rendue par setsock est le descripteur de socket alloue.
*/
/*
*/
/*****************************************************************/
sock = setsock(host, service, protocol);
/*****************************************************************/
/*
*/
/* on appelle la fonction de communication correspondant
*/
/* au protocole choisi
*/
/*
*/
/*****************************************************************/
if ( strcmp(protocol,"tcp") == 0 )
dialogueTCP(sock);
else if ( strcmp(protocol,"udp") == 0 )
dialogueUDP(sock);
62
else
printf("protocole inconnu\n");
/* on ferme le socket qui nous a ete alloue */
close(sock);
}
63
Programme setsock.c
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#ifndef INADDR_NONE
#define INADDR_NONE
0xffffffff
# define DEFFLAG 0
#endif
/***********************************************************/
/*
*/
/* Ce programme alloue un socket correspondant aux arguments passes */
/* par le programme appelant.
*/
/*
*/
/* Les arguments a passer sont:
*/
/*
*/
/*
1) la machine distante sur laquelle s'excecute le serveur.
*/
/*
*/
/*
2) le port avec lequel on peut communiquer avec le serveur.
*/
/*
*/
/*
3) le protocole de communication ( TCP ou UDP ).
*/
/*
*/
/*
*/
/*
AUTEURS:
*/
/*
JAZOULI Abdelillah
*/
/*
RADI Nour-eddine
*/
/*
ZGHAL
Tarek
*/
/*
*/
/*
DATE:
JUIN 1994
*/
/*
*/
/*
*/
/***********************************************************/
int setsock(host,service,protocole)
/* nom ou numero de la machine distante supportant le serveur */
char *host ;
/* numero de port ou nom d'un service connu */
char *service ;
/* nom du protocole utilise TCP ou UDP */
char *protocole ;
{
struct hostent *phe;
/* pointeur sur la structure d info du host
*/
struct servent *pse;
/* pointeur sur la structure d info du service
*/
struct protoent *ppe; /* pointeur sur la structure d info du protocole
*/
64
struct sockaddr_in server_in; /* structure d info sur l adresse du serveur */
int sock;
/* descripteur de socket
*/
int sock_type;
/* type associe au socket: STREAM ou DATAGRAM */
char bufreq[1];
/* ce message permet de debloquer le serveur
*/
/* en mode deconnecte (DATAGRAM).
*/
/***********************************************************/
/*
*/
/* mise en place de la structure d information sur le serveur: server_in
*/
/*
*/
/***********************************************************/
/* initialise la structure server_in a zero */
bzero ( (char *)&server_in, sizeof(server_in));
/* mise en place de la famille d'adresse */
server_in.sin_family = AF_INET;
/* mise en place du numero de port du service */
if ( pse = getservbyname(service,protocole) )
{
/* cas ou le service est designe par son nom */
server_in.sin_port = htons(u_short)pse->s_port;
}
/* cas ou le service est designe par un numero de port */
else if ( (server_in.sin_port = htons((u_short)atoi(service)) ) == 0 )
{
/* cas d'erreur sur le service */
printf ("service %s impossible \n",service);
exit(1);
}
/* mise en place du numero du host */
if ( phe = gethostbyname(host) )
/* cas ou le host est designe par un nom (ex:ensisun) */
bcopy ( phe->h_addr, (char *)&server_in.sin_addr , phe->h_length);
/* cas ou le host est designe par un numero () */
else if ((server_in.sin_addr.s_addr = inet_addr(host)) == INADDR_NONE)
{
/* cas d'erreur sur le host */
printf ("entree de host %s impossible \n",host);
exit(1);
}
/*****************************************************************/
/*
*/
/* mise en place de la structure d information sur le protocole
*/
/*
*/
/*****************************************************************/
if ( (ppe = getprotobyname(protocole)) == 0)
65
{
printf ("entree de protcole %s impossible \n",protocole);
exit(1);
}
/*****************************************************************/
/*
*/
/*
allocation de socket
*/
/*
*/
/*****************************************************************/
/* mise en place du type de socket */
if ( strcmp(protocole,"udp") == 0 )
sock_type = SOCK_DGRAM;
else
sock_type = SOCK_STREAM;
/* creation du socket avec le protocole choisi */
sock = socket(PF_INET, sock_type, ppe->p_proto);
if ( sock < 0 )
{
printf ("impossible de creer le socket \n");
exit(1);
}
/* CAS D'UN STREAM SOCKET */
/* connecter le socket au serveur */
if ( sock_type == SOCK_STREAM ){
if ( connect(sock,(struct sockaddr *)&server_in,sizeof(struct sockaddr)) < 0 )
{
printf ("connection a %s,%s impossible \n",host,service);
exit(1);
}
}
/* CAS D'UN DATAGRAM SOCKET */
/* envoyer un message pour communiquer l'adresse du client au serveur */
if ( sock_type == SOCK_DGRAM )
sendto(sock,bufreq,strlen(bufreq),DEFFLAG,(struct
sockaddr*)&server_in,sizeof(server_in)) ;
/* on renvoie le descripteur du socket alloue */
return(sock);
}
/* fin de setsock */
66
DialogueTCP
#include <stdio.h>
#define DEFLINELEN 128
/****************************************************************/
/*
*/
/* Ce programme represente l'application du cote client.
*/
/*
*/
/* L'application developpee consiste en un jeu ou le client essaye de
*/
/* deviner un mot cache par le serveur .
*/
/* Le client propose successivement des lettres et le serveur lui
*/
/* repond en lui signalant l'existance ou nonde la lettre dans
*/
/* le mot cache. Le client a un nombre d'essais limite par le serveur
*/
/* pour deviner le mot cache.
*/
/*
*/
/* Le serveur envoi la valeur 1 pour signaler qu'il va envoyer
*/
/* son dernier message. C'est le cas ou on a trouve le mot cache
*/
/* ou on a depasse le nombre d'essais autorise.
*/
/*
*/
/* Cette application est developpe pour un protocole TCP
*/
/*
*/
/* L'argument a passer est:
*/
/*
*/
/*
1) Le descripteur de socket avec lequel on va communiquer
*/
/*
avec le serveur.
*/
/*
*/
/*
*/
/*
AUTEURS:
*/
/*
JAZOULI Abdelillah
*/
/*
RADI Nour-eddine
*/
/*
ZGHAL
Tarek
*/
/*
*/
/*
DATE:
JUIN 1994
*/
/*
*/
/*
*/
/*****************************************************************/
void dialogueTCP(sock)
int sock;
{
/* buffer qui contiendra la requete du client */
char bufreq[DEFLINELEN+1];
/* buffer qui contiendra la reponse du serveur */
char bufans[DEFLINELEN+1];
int n ;
int PAS_TROUVE = 1;
/* vaut 1 si le client n'a pas encore trouve */
67
/* le mot cache, 0 s'il a trouve
*/
/* on lit le message de bienvenue envoye par le serveur */
if ( (n = read(sock,bufans,DEFLINELEN) ) < 0 )
printf("erreur sur le read \n");
else {
/* on affiche ce message s'il n'ya pas eu d'erreur sur le read*/
bufans[n]='\0' ;
fputs(bufans,stdout) ;
fflush(stdout);
}
/* on boucle indefiniment jusqu'a ce que l'on trouve le mot */
while (PAS_TROUVE) {
/* on vide les buffer de requete et de reponse */
n=0;
bzero(bufans,sizeof(bufans));
bzero(bufreq,sizeof(bufreq));
/* on propose une lettre au serveur */
printf ("proposer une lettre: ");
fflush(stdin);
scanf ("%c",bufreq );
/* on envoi la lettre proposee au serveur */
write (sock,bufreq,strlen(bufreq));
printf ("reponse du serveur: ");
/* on attend la reponse du serveur */
if ( (n=read(sock,bufans,DEFLINELEN)) < 0 )
printf("erreur sur le read \n");
else { /* cas ou on a recu la reponse du serveur */
if (bufans[0]=='1') {
/* cas ou le serveur nous signale qu'il */
/* va envoyer son dernier message */
fflush(stdout);
/* on lit le dernier message */
n=read(sock,bufans,DEFLINELEN) ;
/* on va arreter la communication */
PAS_TROUVE = 0 ;
}
bufans[n]='\0' ;
/* on affiche le message du serveur */
fputs(bufans,stdout) ;
fflush(stdout);
}
printf("\n");
} /* fin du while */
return ;
}
/* fin de dialogueTCP */
68
69
Dialogue UDP
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#define DEFLINELEN 128
#define DEFFLAG 0
/*****************************************************************/
/*
*/
/* Ce programme represente l'application du cote client.
*/
/*
*/
/* L'application developpee consiste en un jeu ou le client doit
*/
/* deviner un mot que le serveur lui a cache.
*/
/* Le client propose successivement des lettres et le serveur lui
*/
/* repond en lui signalant l'existance ou pas de la lettre dans
*/
/* le mot cache. Le client a un nombre d'essais determine par le serveur
*/
/* pour deviner le mot cache.
*/
/*
*/
/* Le serveur envoi la valeur 1 pour signaler qu'il va envoyer
*/
/* son dernier message. C'est le cas ou on a trouve le mot cache
*/
/* ou on a depasse le nombre d'essais autorise.
*/
/*
*/
/* Cette application est developpe pour un protocole UDP
*/
/*
*/
/* L'argument a passer est:
*/
/*
*/
/* 1) Le descripteur de socket avec lequel on va communiquer
*/
/* avec le serveur.
*/
/*
*/
/*
*/
/* AUTEURS:
*/
/* JAZOULI Abdelillah
*/
/* RADI Nour-eddine
*/
/* ZGHAL Tarek
*/
/*
*/
/* DATE: JUIN 1994
*/
/*
*/
/*
*/
/*****************************************************************/
void dialogueUDP(sock)
int sock;
{
/* buffer qui contiendra la requete du client */
char bufreq[DEFLINELEN+1];
70
/* buffer qui contiendra la reponse du serveur */
char bufans[DEFLINELEN+1];
char *bravo = "vous avez trouve le mot !" ;
char *TROUVE= "1";
struct sockaddr_in serv_fils;
int serv_addr_len ;
int n;
int PAS_TROUVE = 1; /* vaut 1 si le client n'a pas encore trouve */
/* le mot cache, 0 s'il a trouve */
serv_addr_len = sizeof(serv_fils) ;
/* on lit le message de bienvenue envoye par le serveur */
if ( (n=recvfrom(sock,bufans,sizeof(bufans),0,(struct sockaddr
*)&serv_fils,&serv_addr_len)) <0 )
printf("erreur sur le read \n");
else {
/* on affiche ce message s'il n'ya pas eu d'erreur sur le read*/
bufans[n]='\0' ;
fputs(bufans,stdout) ;
fflush(stdout);
}
/* on boucle indefiniment jusqu'a ce que l'on trouve le mot */
while (PAS_TROUVE) {
/* on vide les buffer de requete et de reponse */
n=0;
bzero(bufans,sizeof(bufans));
bzero(bufreq,sizeof(bufreq));
/* on propose une lettre au serveur */
printf ("proposer une lettre: ");
fflush(stdin);
scanf ("%c",bufreq );
/* on envoi la lettre proposee au serveur */
sendto(sock,bufreq,strlen(bufreq),DEFFLAG,(struct
sockaddr*)&serv_fils,sizeof(serv_fils)) ;
printf ("reponse du serveur: ");
/* on attend la reponse du serveur */
if ((n=recvfrom(sock,bufans,sizeof(bufans),0,(struct sockaddr
*)&serv_fils,&serv_addr_len))<0)
printf("erreur sur le read \n");
else { /* cas ou on a recu la reponse du serveur */
if (bufans[0]=='1') {
/* cas ou le serveur nous signale qu'il */
71
/* va envoyer son dernier message */
fflush(stdout);
/* on lit le dernier message */
n=recvfrom(sock,bufans,sizeof(bufans),0,(struct sockaddr
*)&serv_fils,&serv_addr_len);
/* on va arreter la communication */
PAS_TROUVE = 0 ;
}
bufans[n]='\0' ;
/* on affiche le message du serveur */
fputs(bufans,stdout) ;
fflush(stdout);
}
printf("\n");
} /*fin du while */
return ;
} /* fin de dialogueUDP */
72
Serveur
#include <stdio.h>
#include <sys/types.h>
/* service et protocole par defaut */
#define DEFSERVICE "1244"
#define DEFPROTOCOL "tcp"
/* nombre max de clients en attente */
#define DEFQUEUELEN 3
extern void serverUDP() ;
extern void serverTCP() ;
/*****************************************************************/
/*
*/
/* Ce programme appelle la fonction setsock avec les arguments passes
*/
/* par l'utilisateur.
*/
/*
*/
/* Les arguments a passer sont:
*/
/*
*/
/* 1) le port avec lequel on peut communiquer avec le serveur.
*/
/* par defaut c'est le port 1234.
*/
/*
*/
/* 2) le protocole de communication ( TCP ou UDP ).
*/
/* par defaut c'est le protocole TCP.
*/
/*
*/
/*
3) le nombre maximum de clients en attente.
*/
/*
par defaut cette valeur vaut 3
*/
/*
*/
/* AUTEURS:
*/
/* JAZOULI Abdelillah
*/
/* RADI Nour-eddine
*/
/* ZGHAL Tarek
*/
/*
*/
/* DATE: JUIN 1994
*/
/*
*/
/*
*/
/****************************************************************/
int main(argc,argv)
int argc; /* nombre d arguments passes par l'utilisateur */
char *argv[]; /* pointeur sur les arguments */
/* argv[0] contient le nombre d'arguments */
{
/* numero de port ou nom d'un service connu */
char *service = DEFSERVICE;
/* nom du protocole utilise TCP ou UDP */
73
char *protocol = DEFPROTOCOL;
/* file d'attente des clients */
int queue_len = DEFQUEUELEN ;
/* descripteur de socket */
int sock ;
/* ce switch initialise les varibles port et protocole */
/* suivant le nombre d'arguments passes par l'utilisateur */
switch( argc)
{
case 1 :
/* 0 arguments passes en parametre */
break ;
case 2 :
/* 1 arguments passes en parametre */
service = argv[1] ; break ;
case 3 :
/* 2 arguments passes en parametre */
service = argv[1] ;
protocol = argv[2] ; break ;
case 4 :
/* 3 arguments passes en parametre */
service = argv[1] ;
protocol = argv[2] ;
queue_len = atoi( argv[3]); break ;
default :
/* probleme dans le nombre d'arguments */
printf("USAGE : service protocol queue_len\n");
exit(1) ;
} /* fin switch */
/****************************************************************/
/*
*/
/* appel de la fonction setsock qui va allouer un socket au client.
*/
/* la valeur rendue par setsock est le descripteur de socket alloue.
*/
/*
*/
/****************************************************************/
sock = setsock( service,protocol,queue_len) ;
/****************************************************************/
/*
*/
/* on appelle la fonction de communication correspondant
*/
/* au protocole choisi
*/
/*
*/
/****************************************************************/
if ( strcmp( protocol,"tcp") == 0 )
serverTCP( sock) ;
else if ( strcmp( protocol,"udp") == 0 )
serverUDP( sock,protocol) ;
else printf(" protocol inconnue \n") ;
/* on ferme le socket */
close(sock);
74
}
75
Setsock.c pour le seveur
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#define DEFPORTBASE 0
/****************************************************************/
/*
*/
/* Ce programme alloue un socket correspondant aux arguments passes
*/
/* par le programme appelant.
*/
/*
*/
/* Les arguments a passer sont:
*/
/*
*/
/* 1) le port avec lequel on peut communiquer avec le serveur.
*/
/*
*/
/* 2) le protocole de communication ( TCP ou UDP ).
*/
/*
*/
/*
3) le nombre max de clients en attente sur le socket
*/
/*
*/
/*
*/
/* AUTEURS:
*/
/* JAZOULI Abdelillah
*/
/* RADI Nour-eddine
*/
/* ZGHAL Tarek
*/
/*
*/
/* DATE: JUIN 1994
*/
/*
*/
/*
*/
/****************************************************************/
int setsock( service,protocol,queue_len)
/* numero de port ou nom d'un service connu */
char *service ;
/* nom du protocole utilise TCP ou UDP */
char *protocol ;
/* nombre maximum de clients en attente sur le socket */
int queue_len ;
{
struct servent *pse;
/* pointeur sur la structure d info du service */
struct protoent *ppe;
/* pointeur sur la structure d info du protocole */
struct sockaddr_in server_in; /* structure d info sur l adresse du serveur */
int sock;
/* descripteur de socket */
76
int socket_type;
/* type associe au socket: STREAM ou DATAGRAM*/
u_short portbase = DEFPORTBASE ;
/****************************************************************/
/*
*/
/* mise en place de la structure d information sur le serveur: server_in
*/
/*
*/
/****************************************************************/
/* initialise la structure server_in a zero */
bzero( (char * ) &server_in,sizeof(server_in) ) ;
/* mise en place de la famille d'adresse */
server_in.sin_family = AF_INET ;
server_in.sin_addr.s_addr = INADDR_ANY ;
/* mise en place du numero de port du service */
if ( pse = getservbyname( service,protocol) )
{
/* cas ou le service est designe par son nom */
server_in.sin_port = htons (ntohs( (u_short)pse->s_port)+portbase) ;
}
/* cas ou le service est designe par un numero de port */
else if ( (server_in.sin_port = htons((u_short)atoi(service))) == 0 )
{
/* cas d'erreur sur le service */
printf("Ce service n'existe pas : %s\n",service) ;
exit(1) ;
}
/****************************************************************/
/*
*/
/* mise en place de la structure d information sur le protocole
*/
/*
*/
/****************************************************************/
if ( ( ppe = getprotobyname(protocol)) == 0 ){
printf(" Protocole %s inconnu\n",protocol) ;
exit(1) ;
}
/****************************************************************/
/*
*/
/* allocation de socket
*/
/*
*/
/****************************************************************/
/* mise en place du type de socket */
if ( strcmp( protocol,"udp") == 0 )
socket_type = SOCK_DGRAM ;
else
77
socket_type = SOCK_STREAM ;
/* creation du socket avec le protocole choisi */
sock = socket( PF_INET,socket_type,ppe->p_proto) ;
if( sock < 0 )
{
printf("IMPOSSIBLE DE CREER UN SOCKET :\n") ;
exit(1) ;
}
/* lien avec le port */
if ( bind(sock,(struct sockaddr *)&server_in,sizeof(server_in)) <0 )
{
printf("IMPOSIBLE DE LIER LE PORT %s :\n",service) ;
exit(1) ;
}
/* on met le socket en mode passif dans le cas */
/* d'un serveur fonctionnant en mode connecte */
if ( socket_type == SOCK_STREAM ) {
if ( listen(sock,queue_len) < 0 )
{
printf("IMPOSIBLE DE METTRE LE PORT %s EN ATTENTE DE
REQUETES :\n",service);
exit(1) ;
}
}
/* on renvoi le descripteur de socket alloue */
return (sock) ;
}
/* fin de setsock */
78
Serveur TCP itŽratif
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
extern int errno ;
extern char *sys_errlist[] ;
extern void dialogueTCP() ;
void serverTCP(dialsock)
int dialsock ;
{
int slavesock ;
int client_addr_len ;
struct sockaddr_in client_in ;
client_addr_len = sizeof( client_in) ;
while(1){
slavesock = accept(dialsock,(struct sockaddr *)&client_in,&client_addr_len);
if ( slavesock < 0){
printf(" OUVERTURE D'UN SOCKET ESCLAVE IMPOSSIBLE\n");
exit(1) ;
}
dialogueTCP(slavesock);
close(slavesock) ;
}
}
79
Serveur TCP parall•le
#include <signal.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
extern void dialogueTCP() ;
/****************************************************************/
/*
*/
/* Ce programme met le serveur en attente de clients.
*/
/* Des que le serveur recoit une requete d'un client, il se debloque
*/
/* et cre un fils qui comuniquera avec le client.
*/
/* Le pere se remet ensuite en attente d'un autre client.
*/
/*
*/
/* L'argument a passer est:
*/
/*
*/
/*
1) Le descripteur de socket avec lequel on va communiquer
*/
/*
*/
/*
*/
/* AUTEURS:
*/
/* JAZOULI Abdelillah
*/
/* RADI Nour-eddine
*/
/* ZGHAL Tarek
*/
/*
*/
/* DATE: JUIN 1994
*/
/*
*/
/*
*/
/****************************************************************/
void serverTCP(mastersock)
int mastersock ;
{
/* descripteur de socket du fils */
int slavesock ;
struct sockaddr_in client_in; /* structure d info sur l adresse du client */
int client_addr_len ;
client_addr_len = sizeof( client_in) ;
/* le pere n'attends pas la fin de ses fils */
signal(SIGCHLD,SIG_IGN);
/* le serveur boucle en attendant des clients */
while (1) {
/* le serveur bloque sur accept en attendant un client */
80
slavesock = accept(mastersock,(struct sockaddr *)&client_in,&client_addr_len);
/* slavesock contient un descripteur de socket qui servira au fils */
if ( slavesock < 0 )
{
/* cas d'erreur */
printf(" OUVERTURE D'UN SOCKET ESCLAVE IMPOSSIBLE\n");
exit(1) ;
}
/* le serveur va creer un fils qui communiquera avec le client */
switch( fork() )
{
case 0: /* fils */
/* le fils ferme le descripteur du pere */
close(mastersock) ;
/* le fils va dialoguer */
dialogueTCP(slavesock) ;
/* le fils ferme son socket */
close(slavesock) ;
/* suicide du fils */
exit() ;
case -1:
/* le pere a rencontre un probleme */
printf(" impossible de creer un fils \n") ;
break ;
default: /* pere */
/* le pere ferme le descripteur du fils */
/* et se remet en attente de client
*/
close(slavesock) ;
break ;
}
/* fin du switch */
} /* fin while: remet le serveur en attente de client */
}
81
Serveur UDP parall•le
#include <stdio.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#define DEFBUFREQ 128
extern void dialogueUDP() ;
/****************************************************************/
/*
*/
/* Ce programme met le serveur en attente de clients.
*/
/* Des que le serveur recoit une requete d'un client, il se debloque
*/
/* et cre un fils qui comuniquera avec le client.
*/
/* Le pere se remet ensuite en attente d'un autre client.
*/
/*
*/
/* L'argument a passer est:
*/
/*
*/
/* 1) Le descripteur de socket avec lequel on va communiquer
*/
/*
*/
/*
*/
/* Ce programme concerne les serveurs UDP
*/
/*
*/
/* AUTEURS:
*/
/* JAZOULI Abdelillah
*/
/* RADI Nour-eddine
*/
/* ZGHAL Tarek
*/
/*
*/
/* DATE: JUIN 1994
*/
/*
*/
/*
*/
/****************************************************************/
void serverUDP(dialsock,protocol)
int dialsock ;
char *protocol ;
{
/* descripteur de socket du fils */
int slavesock ;
char bufreq[DEFBUFREQ+1] ;
struct sockaddr_in client ,name ;
struct protoent *ppe ;
int client_addr_len ;
client_addr_len = sizeof(client) ;
while(1) {
82
/* On doit bloquer le pere s'il n'ya pas de client */
if (recvfrom(dialsock,bufreq,sizeof(bufreq),0,(struct sockaddr
*)&client,&client_addr_len)<0) {
printf("erreur sur recvfrom\n");
exit(1);
}
switch(fork() ) {
case 0 :/* On lance un fils pour s'occuper du dialogue avec un client*/
{
close(dialsock) ; /* socket du pere a fermer */
if ( ( ppe = getprotobyname(protocol) ) == 0 ){
printf("CE PROTOCOLE N'EXISTE PAS : %s\n",protocol) ;
exit(1) ;
}
slavesock = socket(AF_INET,SOCK_DGRAM,ppe->p_proto) ;
name.sin_family = AF_INET ;
name.sin_addr.s_addr = INADDR_ANY ;
name.sin_port = 0 ;
bind(slavesock,( struct sockaddr * )&name ,sizeof(name) ) ;
dialogueUDP(slavesock,client) ;
close(slavesock) ;/*socket du fils a fermer en fin de dialogue */
exit(1) ; /* la mort du fils est ineluctable ! */
}
case -1 : /* erreure sur le fork() */
printf("IMPOSSIBLE DE CRER UN FILS \n") ;
break ;
default : /* Le pere */
close(slavesock) ; /* socket du fils a fermer */
} /* fin switch */
} /* fin while */
}
83
Dialogue TCP serveur
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#define DEFBUFREQ 128
#define DEFBUFANS 128
/****************************************************************/
/*
*/
/* Ce programme represente l'application du cote serveur.
*/
/*
*/
/* L'application developpee consiste en un jeu ou le client doit
*/
/* deviner un mot que le serveur lui a cache.
*/
/* Le client propose successivement des lettres et le serveur lui
*/
/* repond en lui signalant l'existance ou pas de la lettre dans
*/
/* le mot cache. Le client a un nombre d'essais determine par le serveur
*/
/* pour deviner le mot cache.
*/
/*
*/
/* Le serveur choisi de facon aleatoire un mot dans le fichier DICO
*/
/* et demande au client de le deviner.
*/
/*
*/
/* Le serveur envoi la valeur 1 pour signaler qu'il va envoyer
*/
/* son dernier message. C'est le cas ou on a trouve le mot cache
*/
/* ou on a depasse le nombre d'essais autorise.
*/
/*
*/
/* Cette application est developpe pour un protocole TCP
*/
/*
*/
/* L'argument a passer est:
*/
/*
*/
/* 1) Le descripteur de socket avec lequel on va communiquer
*/
/*
*/
/*
*/
/* AUTEURS:
*/
/* JAZOULI Abdelillah
*/
/* RADI Nour-eddine
*/
/* ZGHAL Tarek
*/
/*
*/
/* DATE: JUIN 1994
*/
/*
*/
/*
*/
/****************************************************************/
void dialogueTCP(sock)
int sock ;
84
{
/* buffer qui contiendra la requete du client */
char bufreq[DEFBUFREQ+1];
/* buffer qui contiendra la reponse du serveur */
char bufans[DEFBUFANS+1];
/* mot a devine */
char word1[DEFBUFANS+1];
/* mot intermadiaire devine par le client */
char word2[DEFBUFANS+1];
/* message de bienvenue */
char *MSG_BIENVENUE;
/* message a envoyer au client pour lui indiquer qu'on va arreter */
/* de jouer: soit il a trouve le mot ou nombre d'essais est epuise */
char *TROUVE;
/* contient le nombre de mot dans le fichier dico */
int file_lg=0;
/* le mot cache sera l'entree aleatoire de rang n dans dico */
int n ;
int i;
/* nombre d'essais du client */
int NB_ESSAIS ;
/* descripteur de fichier pour dico */
FILE *fd ;
/* message de bienvenue */
MSG_BIENVENUE="\nBIENVENUE SUR LE SERVEUR GAMES\n\nvous avez 15
coups pour deviner le mot cache. bonne chance\n\n";
/* envoi du message de bienvenue */
write(sock,MSG_BIENVENUE,strlen(MSG_BIENVENUE)) ;
/* code de fin de communication */
TROUVE="1";
/****************************************************************/
/*
*/
/* Choix aleatoire du mot a deviner par le client
*/
/*
*/
/****************************************************************/
/* ouverture du fichier dico */
if ( (fd=fopen("dico","r")) == NULL)
printf ("impossible d'ouvrir le fichier dico\n");
bzero(word1,sizeof(word1));
85
/* calcul du nombre total de mots dans dico */
while (fgets(word1,15,fd)!=NULL)
file_lg++ ;
/* repositionne le pointeur au debut de dico */
rewind(fd);
/* choix d une valeur aleatoire n et initialise */
/* word1 a la Nieme entree de dico */
srand(getpid());
/* on s'assure que n n'est pas nul */
while( (n=rand()%file_lg)==0 );
/* on lit l'entree N */
for (i=1; i<=n; i++)
fgets(word1,15,fd);
/* positonne la fin de chaine */
word1[strlen(word1)-1]='\0';
/* initialise word2 avec des . */
for ( i=0; i<strlen(word1); i++ )
word2[i]='.';
/* positonne la fin de chaine */
word2[strlen(word1)]='\0';
printf("word1:%s\n",word1);
/****************************************************************/
/*
*/
/* boucle principale de reception et de renvoi de reponse
*/
/*
*/
/****************************************************************/
for ( NB_ESSAIS=1; NB_ESSAIS<16; NB_ESSAIS++) {
/* on initialse les buffers de requete et de reponse a 0 */
bzero(bufreq,sizeof(bufreq) ) ;
bzero(bufans,sizeof(bufans) ) ;
/* on lit la lettre proposee par le client */
if ( (n=read(sock,bufreq,DEFBUFREQ)) < 0)
printf ("erreur sur le read \n");
else {
bufreq[n] = '\0';
}
/* compare la lettre recue avec les lettres composant word1 */
for ( i=0; i<strlen(word1); i++) {
/* on met la lettre dans word2 si elle existe dans word1 */
86
if ( bufreq[0]==*(word1+i*sizeof(char)) )
*(word2+i*sizeof(char))=*(word1+i*sizeof(char));
}
if (!strcmp(word2,word1))
{
/* cas ou le client a devine le mot cache */
/* on lui envoi le code d'arret
*/
write(sock,TROUVE,strlen(TROUVE)) ;
TROUVE= "BRAVO vous venez de trouver le mot ";
strcat(TROUVE,word1);
/* on lui envoi le message de felicitations */
write(sock,TROUVE,strlen(TROUVE)) ;
/* on ferme le socket */
fclose(fd);
return;
}
else
{
/* word2 different de word1 */
if (NB_ESSAIS==15)
{
/* le client a epuise ses essais */
TROUVE= "1";
/* on lui envoi le code d'arret
*/
write(sock,TROUVE,strlen(TROUVE)) ;
TROUVE= "DESOLE le mot a deviner etait ";
strcat(TROUVE,word1);
/* on lui envoi la solution */
write(sock,TROUVE,strlen(TROUVE)) ;
}
else
/* on lui envoi word2 */
write(sock,word2,strlen(word2)) ;
}
} /* fin du for */
/* on ferme le fichier */
fclose(fd);
return ;
}
87
Dialogue serveur UDP
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#define DEFBUFREQ 128
#define DEFBUFANS 128
#define DEFFLAG 0
/****************************************************************/
/*
*/
/* Ce programme represente l'application du cote serveur.
*/
/*
*/
/* L'application developpee consiste en un jeu ou le client doit
*/
/* deviner un mot que le serveur lui a cache.
*/
/* Le client propose successivement des lettres et le serveur lui
*/
/* repond en lui signalant l'existance ou pas de la lettre dans
*/
/* le mot cache. Le client a un nombre d'essais determine par le serveur
*/
/* pour deviner le mot cache.
*/
/*
*/
/* Le serveur choisi de facon aleatoire un mot dans le fichier DICO
*/
/* et demande au client de le deviner.
*/
/*
*/
/* Le serveur envoi la valeur 1 pour signaler qu'il va envoyer
*/
/* son dernier message. C'est le cas ou on a trouve le mot cache
*/
/* ou on a depasse le nombre d'essais autorise.
*/
/*
*/
/* Cette application est developpe pour un protocole UDP
*/
/*
*/
/* L'argument a passer est:
*/
/*
*/
/* 1) Le descripteur de socket avec lequel on va communiquer
*/
/*
*/
/* 2) La structure d'adresse du client
*/
/*
*/
/*
*/
/* AUTEURS:
*/
/* JAZOULI Abdelillah
*/
/* RADI Nour-eddine
*/
/* ZGHAL Tarek
*/
/*
*/
/* DATE: JUIN 1994
*/
/*
*/
/*
*/
/****************************************************************/
void dialogueUDP(sock,client)
int sock ;
88
struct sockaddr client ;
{
/* buffer qui contiendra la requete du client */
char bufreq[DEFBUFREQ+1];
/* buffer qui contiendra la reponse du serveur */
char bufans[DEFBUFANS+1];
/* mot a devine */
char word1[DEFBUFANS+1];
/* mot intermadiaire devine par le client */
char word2[DEFBUFANS+1];
/* message de bienvenue */
char *MSG_BIENVENUE;
/* message a envoyer au client pour lui indiquer qu'on va arreter */
/* de jouer: soit il a trouve le mot ou nombre d'essais est epuise */
char *TROUVE;
/* contient le nombre de mot dans le fichier dico */
int file_lg=0;
/* le mot cache sera l'entree aleatoire de rang n dans dico */
int n ;
int i;
/* nombre d'essais du client */
int NB_ESSAIS ;
/* descripteur de fichier pour dico */
FILE *fd ;
/* taille de la structure client */
int client_addr_len = sizeof(client) ;
/* message de bienvenue */
MSG_BIENVENUE="\nBIENVENUE SUR LE SERVEUR GAMES\n\nvous avez 15
coups pour deviner le mot cache. bonne chance\n\n";
/* envoi du message de bienvenue */
sendto(sock,MSG_BIENVENUE,strlen(MSG_BIENVENUE),DEFFLAG,(struct
sockaddr*)&client,sizeof(client)) ;
/* code de fin de communication */
TROUVE="1";
/****************************************************************/
/*
*/
/* Choix aleatoire du mot a deviner par le client
*/
/*
*/
/****************************************************************/
89
/* ouverture du fichier dico */
if ( (fd=fopen("dico","r")) == NULL)
printf ("impossible d'ouvrir le fichier dico\n");
bzero(word1,sizeof(word1));
/* calcul du nombre total de mots dans dico */
while (fgets(word1,10,fd)!=NULL)
file_lg++ ;
/* repositionne le pointeur au debut de dico */
rewind(fd);
/* choix d une valeur aleatoire n et initialise */
/* word1 a la Nieme entree de dico */
srand(getpid());
/* on s'assure que n n'est pas nul */
while( (n=rand()%file_lg)==0 );
/* on lit l'entree N */
for (i=1; i<=n; i++)
fgets(word1,15,fd);
/* positonne la fin de chaine */
word1[strlen(word1)-1]='\0';
/* initialise word2 avec des . */
for ( i=0; i<strlen(word1); i++ )
word2[i]='.';
/* positonne la fin de chaine */
word2[strlen(word1)]='\0';
printf("word1:%s\n",word1);
/****************************************************************/
/*
*/
/* boucle principale de reception et de renvoi de reponse
*/
/*
*/
/****************************************************************/
for ( NB_ESSAIS=1; NB_ESSAIS<16; NB_ESSAIS++) {
/* on initialse les buffers de requete et de reponse a 0 */
bzero(bufreq,sizeof(bufreq) ) ;
bzero(bufans,sizeof(bufans) ) ;
/* on lit la lettre proposee par le client */
if ( ( n=recvfrom(sock,bufreq,sizeof(bufreq), 0, (struct sockaddr *)&client,
&client_addr_len) ) < 0)
printf ("erreur sur le read \n");
else {
bufreq[n] = '\0';
90
}
/* compare la lettre recue avec les lettres composant word1 */
for ( i=0; i<strlen(word1); i++) {
/* on met la lettre dans word2 si elle existe dans word1 */
if ( bufreq[0]==*(word1+i*sizeof(char)) )
*(word2+i*sizeof(char))=*(word1+i*sizeof(char));
}
if (!strcmp(word2,word1))
{ /* cas ou le client a devine le mot cache */
/* on lui envoi le code d'arret */
sendto(sock,TROUVE,strlen(TROUVE),DEFFLAG,(struct
sockaddr *)&client,sizeof(client)) ;
TROUVE= "BRAVO vous venez de trouver le mot ";
strcat(TROUVE,word1);
/* on envoi au client un message de felictations */
sendto(sock,TROUVE,strlen(TROUVE),DEFFLAG,(struct
sockaddr *)&client,sizeof(client)) ;
/* on ferme le socket */
fclose(fd);
return;
}
else
{
/* word2 different de word1 */
if (NB_ESSAIS==15)
{
/* le client a epuise ses essais */
TROUVE= "1";
/* on lui envoi le code d'arret */
sendto(sock,TROUVE,strlen(TROUVE),DEFFLAG,(struct sockaddr
*)&client,sizeof(client)) ;
TROUVE= "DESOLE le mot a deviner etait ";
strcat(TROUVE,word1);
/* on lui envoi la solution */
sendto(sock,TROUVE,strlen(TROUVE),DEFFLAG,(struct sockaddr
*)&client,sizeof(client)) ;
}
else
/* on lui envoi word 2*/
sendto(sock,word2,strlen(word2),DEFFLAG,(struct
sockaddr *)&client,sizeof(client)) ;
}
} /* fin du for */
/* on ferme le fichier */
fclose(fd);
return ;
}
91
Dans nos programmes on a utilisŽ les fonctions bzero() et bcopy() qui nÕŽxistent
pas sur toutes les versions UNIX. Nous avons donc joint un listing de ces deux
fonctions.
La fonction bzero()
/*
NAME
bzero -- zero the contents of a specified memory region
SYNOPSIS
void bzero (char *to, int count)
DESCRIPTION
Zero COUNT bytes of memory pointed to by TO.
*/
void bzero (to, count)
char *to;
int count;
{
while (count-- > 0)
{
*to++ = 0;
}
}
La fonction bcopy()
/* bcopy -- copy memory regions of arbitary length
Copyright (C) 1991 Free Software Foundation, Inc.
NAME
bcopy -- copy memory regions of arbitrary length
SYNOPSIS
void bcopy (char *in, char *out, int length)
DESCRIPTION
Copy LENGTH bytes from memory region pointed to by IN to memory
region pointed to by OUT.
*/
92
void bcopy (src, dest, len)
register char *src, *dest;
int len;
{
if (dest < src)
while (len--)
*dest++ = *src++;
else
{
char *lasts = src + (len-1);
char *lastd = dest + (len-1);
while (len--)
*(char *)lastd-- = *(char *)lasts--;
}
}
93
BIBLIOGRAPHIE
Douglas COMER
TCP/IP : Architecture, protocoles, application.
W.RICHARD STEVENS.
UNIX network programming
Documentation Solaris sur les Sockets
Rapport ENSIMAG de Morel et Tomassino.1993
TCP_IP : programmation rŽseau; les sockets.
Rapport ENSIMAG de Borderies, Chatel, Dens, Reis, 1993
Administration rŽseau
94
