Applications client/serveur TCP/IP

Applications client/serveur
TCP/IP - Sockets
Rappels
C.Crochepeyre
Applications CS
1
PLAN
•
•
•
•
•
Modèle client/serveur
Modèle ISO et protocole TCP/IP
Comment ça marche?
La programmation: les sockets
Exemples client/serveur: UDP et TCP
C.Crochepeyre
Applications CS
2
Modèle client/serveur : C/S
• L’application informatique est éclatée entre
– La partie application cliente : processus « client »
– La partie application serveur : processus « serveur »
• Le client fournit au serveur les données pour effectuer des
traitements: demande de service
• Le serveur rend le service et retourne au client les résultats
client
C.Crochepeyre
serveur
Applications CS
3
Pourquoi?
•
•
•
•
Le serveur peut être sollicité par plusieurs clients pour le même service
Chaque application peut être distante : réseau
Clients et serveur peuvent s’exécuter sur des machines différentes. Les
puissances de calcul peuvent être mieux réparties
Les applications clientes peuvent être différentes
M2
M1
M3
serveur
clients
C.Crochepeyre
Applications CS
client
4
Côté client
• Le client est à l’initiative de la demande
–
–
–
–
Il doit s’adresser au bon serveur
Lui fournir toutes les données pour effectuer le service
Attendre les résultats
Assurer la présentation
M3
M2
M1
serveur
client
C.Crochepeyre
Applications CS
5
Côté serveur
• Le serveur doit être actif et attendre une demande
• A la demande d’un client, il doit récupérer les données
pour effectuer le traitement
• Il doit renvoyer au client concerné les résultats non
formatés
M3
serveur
client
M1
C.Crochepeyre
M2
Applications CS
6
• Serveur itératif
– Le serveur ne traite qu’une demande à la fois
clients
serveur
• Serveur parallèle
– Le serveur traite plusieurs demandes simultanément
clients
C.Crochepeyre
serveur
Applications CS
7
Les échanges par réseaux
• Communication entre équipements
– LAN: Local Area Network (10 mètres à quelques km)
– MAN: Metropolitan Network (de 10 à 100 km)
– WAN: Wide Area Network (100km au monde entier)
•
•
•
•
Architectures: étoile, anneau, maillage, arbre…
Canaux: bus, satellite,…
Débits: bits/s, Kbits/s, Mbits/s, Gbits/s ..
Protocoles entre équipements: format, ordre des échanges
(envois et réceptions), actions associées
• Echanges sur des réseaux hétérogènes: Inter-Net
C.Crochepeyre
Applications CS
8
Modèle OSI
• ISO International Organisation for Standardization
• Le modèle OSI Open System Interconnection
– Architecture en 7 couches
– Principes:
• Chaque système possède un ensemble de couches
• La communication entre 2 applications de même couche s’effectue
selon un protocole propre à cette couche
• Chaque couche se réfère aux services fournis par les couches
inférieures
• Lors d’un dialogue entre 2 couches de même niveau, les couches
inférieures sont transparentes
C.Crochepeyre
Applications CS
9
• Les couches basses:
– Physique: transmission binaire
– Liaison: transmission de trames
– Réseau: acheminement des paquets, routage, interconnexion des sousréseaux
• Les couches hautes
– Transport: transport de bout en bout des messages, découpage et
réassemblage (paquets), gestion de la connexion
– Session: dialogue entre tâches distantes synchronisation
– Présentation: présentation des données échangées entre applications
– Application: accès aux services par l’utilisateur
• Protocole simplifié: TCP/IP
C.Crochepeyre
Applications CS
10
Le protocole TCP/IP
• Des solutions d’échange de données entre deux processus
distants: fichiers, ftp, applications…
• Le protocole de communication TCP/IP
– TCP utilisé avec IP ou UDP avec IP
– Les couches
• Network Access (couches OSI 1 et 2): ethernet ou autre
• Internet (couche OSI 3): IP
• Host/Host (couche OSI 4): TCP ou UDP
• Processus et applications (couches OSI 5,6 et 7) :tftp, telnet, smtp,
http…
C.Crochepeyre
Applications CS
11
• Le réseau Ethernet
–
–
–
–
–
–
–
Réseau local
Norme IEEE 802.3 technique d’accès CSMA/CD
Topologie: segment de bus
Vitesse de transmission de 10Mbits/s à 1000 Mbits/s
Supports: câble coaxial, paires torsadées, fibre optique
Avantages: simplicité, faible coût, débit élevé, connexion/déconnexion, …
Inconvénients: durée de transmission bornée, absence de récupération
d’erreurs au niveau liaison, pas de mécanisme de priorité…
C.Crochepeyre
Applications CS
12
• Le protocole IP
– Interconnexion de machines situées sur des réseaux différents.
– Assure:
•
•
•
•
•
•
L’adressage par des adresses Internet
Le routage
La fragmentation et réassemblage des paquets
Le contrôle des erreurs
Le contrôle des flux
Le contrôle de la durée de vie du datagramme
– Deux services: send et deliver
– Avantage: hétérogénéité des sous réseaux que doivent traverser les
messages des deux machines
– Met en communication deux machines via des adresses Internet
C.Crochepeyre
Applications CS
13
• UDP et TCP
– Deux services transport, couche supérieure à IP
– UDP: communication légère sans exigence de fiabilité ni de temps de
réponse
• Transmission de messages
• Possibilité de perte, duplication, déséquencement des messages: contrôle
par la couche supérieure application
Exemple TFTP (transfert de fichiers)
– TCP: communication fiable avec connexion
• circuit virtuel entre deux processus
• Pas de message mais un flot d’octets fragmentés en segments
• Fiabilité avec numérotation des octets, acquittement, réordonnancement: contrôle de flux
Exemple SMTP (mail)
– Communication entre deux processus via des n° de port
C.Crochepeyre
Applications CS
14
Adresses IP
• Une adresse IP est unique pour chaque machine
• Attribuée par l’AFNIC centre d'information et de gestion des noms
de domaine internet (France et île de la Réunion).
• Adresse de 32 bits découpés selon l’utilité
– Adresse réseau
– Adresse de la machine
• Classes réseaux: A, B, C, D, E
• Codage adresse IP:
– Décimal pointé
– Symbolique
163.173.212.27
lion.cnam.fr
machine.sous-domaine.domaine
• DNS Domain Name System
– Table de correspondances entre un nom symbolique et une adresse pointée:
163.173.212.27 lion.cnam.fr
– Hiérarchie des serveurs
C.Crochepeyre
Applications CS
15
•
Classe A: 0.0.0.0 à 127.255.255.255
@locale
réseau
0
1
7
•
24
Classe B: 128.0.0.0 à 191.255.255.255
réseau
@locale
1 0
1 1
•
14
18
Classe C: 192.0.0.0 à 223.255.255.255
réseau
@locale
1 1 0
1 1 1
•
21
8
Classe D: 224.0.0.0 à 239.255.255.255
multicast
1 1 1 1
1 1
1
1
C.Crochepeyre
28
Applications CS
16
• Adresse réseau
– Identificateur réseau suivi de zéro
• 163.173.0.0 : réseau 163.173 de classe B
– Diffusion au réseau (broadcast)
• Identificateur du réseau suivi de un
• 163.173.255.255 diffusion au réseau 163.173 de classe B
• Adresse machine
–
–
–
–
Identificateur réseau et machine
163.173.224.27: machine 224.27 du réseau 163.173 de classe B
163.x.x.x: localhost désigne la machine locale
0.0.0.0 utilisé si adresse inconnue de la machine
• Adresse sous réseau
– Utilisation des adresses machines comme adresse sous réseau
– Masque de réseau: 255.255.0.0 pour la classe B
– Masque de sous réseau: 255.255.255.0 pour le sous réseau
Si @IPdest & masque = @de la machine; alors envoi à la machine - sinon
routeur (@IPdest & masque, @IPmachine)
C.Crochepeyre
Applications CS
17
• Adresse Ethernet
– Chaque machine = adresse éthernet sur 48 bits
– Adresse physique
– Correspondance entre @IP et @Ethernet (@MAC)
• ARP Adress Resolution Protocol:
– @IP -> @Ethernet -> machine
– M1 envoie un message ARP avec son @IPM1et @EthernetM1
à toutes les machines, si M2 reconnaît son @IPM2
– M2 répond et renvoie @EthernetM2
– M1 met à jour sa table ARP avec les deux adresses de M2
– M2 met à jour sa table ARP avec les deux adresses de M1
• RARP Reverse ARP:
– Une station recherche son @IP dans une table inversée de
correspondance
– machine -> @Ethernet -> @IP
C.Crochepeyre
Applications CS
18
Comment ça marche?
• Les ports:
– Côté serveur: chaque service (application) ouvre un port de communication
identifié par un n°
– Côté client : chaque client (application) ouvre un port de communication
identifié par n°
– La communication s’établit entre deux applications identifiées (ports) sur
deux machines identifiées (@IP).
• Envoi de paquets :
– UDP: le message envoyé est découpée en datagrammes
– TCP: le flot d’octets est bufferisé en segments
• Les couches UDP et TCP
– UDP et TCP ajoutent aux données les n° ports: port_dest, port_exp
C.Crochepeyre
Applications CS
19
• Couche IP:
– IP ajoute, entre autres, aux données transmises par UDP ou TCP les
adresses IP des machines (destinataire et expéditeur)
@dest, @exp, données…. @dest, @exp, données….
• Les paquets sont acheminés via les réseaux jusqu’à la machine
destinataire @dest
• Les données sont transmises à l’application identifiée par son n°
de port et récupère l’@IP de l’expéditeur
C.Crochepeyre
Applications CS
20
Le client interroge le serveur
Serveur
Client
Port PC
Port PS
« Pourquoi? »
« Pourquoi? »
UDP
UDP
PS PC « Pourquoi? »
PS PC « Pourquoi? »
IP
IP
@S @C PS PC « Pourquoi? »
@S @C PS PC « Pourquoi? »
@S
C.Crochepeyre
@C
Applications CS
21
Programmation: les sockets
•
Programmation des points terminaux de communication entre deux processus
– Une socket à chaque extrémité du canal de communication
• Point de sortie pour l’émission de données
• Point d’entrée pour la réception de données
•
•
•
Utilisation essentielle pour des processus distants. Pour les processus
locaux, d’autres outils (IPCs, PIPE)
A chaque socket sont associés: descripteur, domaine, nom.....
Le SGF est impliqué dans la gestion des sockets
C.Crochepeyre
Applications CS
22
• Descripteur
– Référence attribuée dans le processus créateur
– utilisation des descripteurs de fichiers:
• Entrée dans la table des descripteurs du processus avec
pointeur vers une structure interne de type socket
• Redirection possible d’un fichier standard vers une socket
• fork() : le fils hérite des descripteurs donc des sockets
• Lecture et écriture en spécifiant le descripteur
Table des
fichiers
Table des
descripteurs
du
processus A
i-noeud
socket
Files
Connexions en attentes
Connexions actives
Data à émettre
Data à recevoir
Structure
socket
C.Crochepeyre
Applications CS
23
• Domaine
– Deux domaines possibles
• Internet pour une communication distante
• Unix pour une communication interne (si besoin)
– Un format d’adresses de la socket selon le domaine
– Des protocoles associés au domaine
• Nom
– Référence pour le processus et les autres processus
• Une structure interne avec:
– Pour une communication locale: nom de fichier
– Pour une communication distante: une adresse transport
adresse réseau + n° de port
• Tout processus, non fils, peut hériter de la socket à condition
que le descripteur soit « attaché » à cette référence
– Similitude avec un fichier
• La référence d’une socket est dans un i-nœud particulier
C.Crochepeyre
Applications CS
24
– Socket distante
• Côté client
– Un client doit connaître la référence de la socket serveur afin de
l’appeler
– La référence de la socket cliente peut être laissée à la charge du
système
• Côté serveur
– La référence de la socket serveur doit être connue du client
– La référence de la socket cliente est transmise automatiquement
au serveur lors de la demande du client. Le serveur peut ainsi lui
répondre.
C.Crochepeyre
Applications CS
25
• Le type
– Sémantique associée à la communication
• SOCK_DGRAM pour mode datagramme : des messages
• SOCK_STREAM pour mode connecté : un flot de données
– Similitudes avec
• le courrier : l’expéditeur écrit au destinataire avec son adresse dans
le courrier, pour la réponse
• le téléphone : l’appelant compose le n°, l’appelé décroche et une
ligne de communication est établie entre les deux n°. Ils raccrochent,
la ligne est libérée.
• Deux protocoles, deux modes de communication
– Pour assurer la sémantique (type)
• UDP pour SOCK_DGRAM
• TCP pour SOCK_STREAM
C.Crochepeyre
Applications CS
26
Mode datagramme: le protocole UDP
Côté Client
Côté Serveur
création d’une socket
(attachement)
socket()/bind()
création et attachement
d’une socket
socket() et bind()
construction
adresse du serveur
envoi message au serveur
sendto()
à une @serveur connue
attente message du client
réception
recvfrom()
@client
attente réponse du serveur
réception
recvfrom()
envoi réponse au client
sendto()
C.Crochepeyre
Applications CS
27
Mode connecté: le protocole TCP
Côté Client
Côté Serveur
création d’une socket
(attachement)
socket()/bind()
création et attachement
d’une socket d’écoute
socket() et bind()
construction
adresse du serveur
Ouverture du service
listen()
demande connexion
connect()
à une @serveur connue
Attente de demande de
connexion client
accept()
@client
nouvelle socket de service
échanges
write()
read()
Échanges socket de service
read()
write()
C.Crochepeyre
Applications CS
28
Les primitives de création
• Création d’une socket
sock = socket(domaine, type, protocole)
int sock;
n° du descripteur socket créée
int domaine;
AF_INET ou AF_UNIX (AF_LOCAL..)
int type;
SOCK_DGRAM ou SOCK_STREAM
int protocole;
O protocole par défaut
– Implication des différentes tables du SGF Unix
– Suppression au close() de la socket
– Fonction assimilable à la fonction pipe() mais un seul n° de descripteur, pas de
nom de fichier
– Les processus fils héritent des descripteurs du père donc du descripteur de la
socket
C.Crochepeyre
Applications CS
29
• Suppression d’une socket
close(sock)
int sock;
descripteur socket
– à la fermeture du dernier descripteur de la socket
– Cas STOCK_STREAM: il peut arriver que la suppression soit bloquante
car le tampon d’émission a encore des caractères non transmis.
C.Crochepeyre
Applications CS
30
• Attachement d’une adresse à une socket: nom de la socket
– Le descripteur doit être associé à un nom de fichier si domaine Unix ou
un n° de port et une @IP si domaine Internet
bind(sock, adresse, lgstruct)
int sock;
descripteur socket
int lgstruct;
longueur de la structure selon le domaine
Deux structures différentes : socket interne et socket distante
adresse domaine UNIX
struct sockaddr_un {short
sun_family;
char sun_path [109];} nom fichier
C.Crochepeyre
adresse domaine INTERNET
struct sockaddr_in {short sin_family;
u_short sin_port; @port
struct in_addr sin_addr; @IP
char sin_zero [8];}
Applications CS
31
• Après le bind() le descripteur pointe sur la structure système
associée à la socket
– avec le nom du fichier de type S (socket) spécifié dans sun_path
si Unix
– avec le n° du port et l’adresse IP si Internet
• Possibilités
sin_addr = INADDR_ANY (une des adresses de la machine)
= ou gethostname()…
sin_port = 0 un port libre alloué par le système
= n° port choisi
= getservbyname() ….
C.Crochepeyre
Applications CS
32
• Exemples
socket Unix
struct sockaddr_un sockux;
………..
sockux.sun_family = AF_UNIX;
strcpy(sockux.sun_path, « sockunix.test »)
bind(sock,&sockux,strlen(sockux.sun_path)+2)
socket INTERNET
struct sockaddr_in sockit;
……………..;
sockit.sin_family = AF_INET;
sockit.sin_port = n° du port associé à la socket; (format réseau)
sockit.sin_addr = adresse de la machine; (format réseau)
bind(sock, &sockit,sizeof(sockit));
C.Crochepeyre
Applications CS
33
• Des fonctions pour récupérer les adresses machines
gethostname() récupération du nom de la machine dans une chaîne de
caractères
gethostbyname() récupération du nom de la machine dans une structure
hostent
• Des fonctions pour récupérer les n° ports des services
– Si le service est connu
getservbyname() getservent() getservbyport() permettent de récupérer
les caractéristiques des services dans un structure « servent »
– Service quelconque utilisateur
getsockname() récupération du n° du port attaché à une socket en
fournissant le descripteur
C.Crochepeyre
Applications CS
34
• Conversion des formats des données
– Chaque machine code ses données selon un format local, les échanges
entre machines impliquent donc des conversions
• du format local au format réseau et
• du format réseau au format local
– L’adresse IP et n° port doivent être au format réseau dans la structure
système avant envoi
– L’adresse IP et n° port reçus dans la structure doivent être reconvertis au
format local avant utilisation (ex: pour un printf de l’adresse de la
machine)
• Primitives conversion des données
–
–
–
–
ntohl()
ntohs()
ntonl()
ntons()
C.Crochepeyre
adresse réseau entier long en adresse locale
adresse réseau entier court en adresse locale
adresse locale entier long en adresse réseau
adresse locale entier court en adresse réseau
Applications CS
35
Les primitives d’échanges mode UDP
• Après création de la socket et attachement
• Emission
nc = sendto(sock,msg,option,p_dest,lgdest)
int nc;
nb de car envoyés
int sock;
n° descripteur socket locale
char *msg;
adresse message à envoyer
Int lg;
long du message à envoyer
Int option;
0 pour SOCK_DGRAM
struct sockaddr *p_dest;
struct socket avec l’adresse du destinataire
int lgdest;
long structure socket
sendmsg() envoi de plusieurs messages
C.Crochepeyre
Applications CS
36
• Réception
nc = recvfrom(sock,msg,lg,option,p_exp,lgexp)
int nc;
nb de car reçus
int sock;
n° descripteur socket
char *msg;
adresse récupération du message
Int lg;
taille espace réception
Int option;
0 ou MSG_PEEK
struct sockaddr *p_exp;
struct récup l’adresse de l’expéditeur
int lgdest;
long structure de l’expéditeur
recvmsg() réception de plusieurs messages
C.Crochepeyre
Applications CS
37
Primitives en mode TCP
• Après création de la socket et attachement
• Etablissement du circuit virtuel
côté client
côté serveur
demande de connexion
connect(sock,p_adr,lg_adr)
préparation du service
listen(soke,nb)
traitement de la connexion reçue
socks=accept(socke, p_adr,p_lg_adr)
Client:
int sock;
struct sockaddr *p_adr;
int lg_adr;
descripteur socket cliente
structure contenant @machineServeur et n° port
long de la structure
Serveur
int socke
int nb;
int socks;
struct sockaddr *p_adr;
Int lg_adr;
descripteur socket écoute serveur
nombre maxi de connexions pendantes
descripteur socket de service qui va communiquer avec le client
structure récupérant @machineClient et n° port
long structure
C.Crochepeyre
Applications CS
38
• Emission
nc = write(socks,msg,lg)
int socks
descripteur socket de service
char *msg
adresse du message à envoyer
int lg
long du message
int nc
nb de car réellement émis
Ou
nc = send(socks,msg,lg,option)
option
0 idem write
MSG_OOB caractère urgent (out-of-band)
MSG_PEEK conservation message…
C.Crochepeyre
Applications CS
39
• Réception
Nc = read(socks, msg, lg, option)
int socks
descripteur socket de service
char *msg
adresse du message reçu
int lg
long du message
int nc
nb de car réellement lus
Ou
Nc = recv(socks, msg, lg, option)
C.Crochepeyre
Applications CS
40
Serveur parallèle: TCP
• Pour éviter que le serveur prenne en charge qu’un seul service à la
fois, il crée un processus fils à chaque demande client
• Le processus fils hérite automatiquement des descripteurs ouverts
par le père (socke et socks) dans sa propre table des descripteurs
ainsi que des données associées.
• Chaque fils remplace son code par le code du service à exécuter
exec(service demandé) avec passage en paramètres : socke et socks
• Le fils communique alors directement avec son client
• Le processus serveur est déchargé de ce service et peut accepter
une autre demande.
• Ne pas oublier de fermer
– La socket d’écoute dans le processus fils (non utile)
– La socket de service dans le processus père (non utile)
C.Crochepeyre
Applications CS
41
Serveur parallèle
clients
C.Crochepeyre
serveur
Applications CS
42
Serveur parallèle: TCP
Côté Client
Côté Serveur
création d’une socket
(attachement)
socket()/bind()
création et attachement
d’une socket d’écoute
socket() et bind()
construction
adresse du serveur
Ouverture du service
listen()
demande connexion
connect()
à une @serveur connue
Attente de demande de
connexion client
accept()
@client
nouvelle socket de service
création d’un processus fils
fork() exec()
échanges
write()
read()
C.Crochepeyre
Échanges socket de service
read()
write()
Applications CS
43
Exemple simple UDP
•
Client UDP
/**********************************************/
/*
utilisation des sockets mode datagramme
*/
/*
client UDP
*/
/*
Le client envoie une suite de car au serveur
*/
/*********************************************/
#include
#include
#include
#include
#include
#include
extern
<stdio.h>
<errno.h>
<sys/types.h>
<sys/socket.h>
<netinet/in.h>
<netdb.h>
errno;
main(argc,argv)
char **argv;
{
struct hostent *h;
struct sockaddr_in sin;
char buf[10];
int sock;
C.Crochepeyre
On passe en argument: n° port du service et l’@IP du serveur
Structure pour récupération des propriétés d’une machine
Structure socket on y place l’adresse du serveur
Zone de message
descripteur socket
Applications CS
44
if(argc!=3) {
fprintf(stderr,"usage: %s remotehost remoteport \n",argv[0]);
exit(0); }
if((sock = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP)) < 0)
{
perror("socket");
exit(1); }
if(!(h=gethostbyname(argv[1]))) {
perror(argv[1]);
exit(2); }
bzero(&sin,sizeof(sin));
sin.sin_family = AF_INET;
bcopy(h->h_addr,&sin.sin_addr,h->h_length);
sin.sin_port = htons(atoi(argv[2]));
C.Crochepeyre
création socket cliente UDP
récupération @machine serveur
maj struct socket cliente
n° port serveur
Applications CS
45
if(sendto(sock,"ABC",3,0,&sin, sizeof(sin))!=3) {
fprintf(stderr,"erreur ecriture \n");
exit(1); }
if(sendto(sock,"DEFGH",5, 0,&sin, sizeof(sin))!=5) {
fprintf(stderr,"erreur ecriture \n");
exit(1); }
if(sendto(sock,"IJ",2, 0,&sin, sizeof(sin))!=2) {
fprintf(stderr,"erreur ecriture \n");
exit(1); }
if(sendto(sock,"KLMNOPQRS",9,0,&sin, sizeof(sin))!=9) {
fprintf(stderr,"erreur ecriture \n");
exit(1); }
sleep(2);
if(sendto(sock,"TUV",3, 0,&sin, sizeof(sin))!=3) {
fprintf(stderr,"erreur ecriture \n");
exit(1); }
if(sendto(sock,"WXYZ",4, 0,&sin, sizeof(sin))!=4){
fprintf(stderr,"erreur ecriture \n");
exit(1); }
close (sock);}
C.Crochepeyre
Applications CS
46
•
Serveur UDP
/************************************************/
/* utilisation de socket sur le reseau mode datagramme */
/* partie serveur
*/
/* Le serveur reçoit du client les caractères
*/
/************************************************/
#include <unistd.h>
#include<stdio.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <netdb.h>
struct sockaddr_in sin = {AF_INET};
Struct pour la socket serveur
main()
{
int len, sock;
char ligne[10];
int n;
struct sockaddr_in adr;
Struct pour récupérer l’adresse client
if((sock = socket(AF_INET,SOCK_DGRAM,0)) < 0)
{perror("socket");
exit(1); }
C.Crochepeyre
Applications CS
47
if(bind(sock, &sin, sizeof(sin)) < 0)
attachement de la socket serveur
{perror("bind");
exit(2);
}
len = sizeof(sin);
if(getsockname(sock, &sin, &len) < 0)
récupération n° port attribué à la socket serveur
{perror("getsockname");
exit(3);
}
printf("server bound to port %u 0x%x \n",ntohs(sin.sin_port),sin.sin_port);
affiche le n° port socket serveur
for(;;)
{len = sizeof(adr);
n = recvfrom(sock,ligne,10,0,&adr, &len);
attend les carac du client
if (n == -1) {perror (" pb socket lecture");
exit();
}
ligne[n] ='\0';
printf("la chaine lue par le serveur est %s\n",ligne);
affichage
}
}
C.Crochepeyre
Applications CS
48
Exemple simple TCP
•
Client TCP
/*************************************/
/*
client.c
tcp_client
*/
/*
socket mode connecte
*/
/*
le client attend un message du serveur */
/*
il n’envoie rien au serveur
*/
/*************************************/
#include
#include
#include
#include
#include
#include
extern
<stdio.h>
<errno.h>
<sys/types.h>
<sys/socket.h>
<netinet/in.h>
<netdb.h>
errno;
main(argc,argv)
char **argv;
{
struct hostent *h;
struct sockaddr_in sin;
char buf[2048];
int sock;
C.Crochepeyre
arguments: @port serveur et @machine serveur communiqués par le printf() du serveur
Struct conversion adresses
Struct socket cliente dans laquelle on place l’adresse du serveur
Buffer message du serveur
Descripteur socket cliente
Applications CS
49
if(argc!=3)
{fprintf(stderr,"usage: %s remotehost remoteport \n",argv[0]);
@du port serveur
exit(0);
}
if((sock = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP)) < 0)
création socket cliente TCP
{perror("socket");
exit(1);
}
if(!(h=gethostbyname(argv[1])))
@machine serveur
{perror(argv[1]);
exit(2);
}
bzero(&sin,sizeof(sin));
maj struct socket
sin.sin_family = AF_INET;
bcopy(h->h_addr,&sin.sin_addr,h->h_length);
@machine serveur
sin.sin_port = htons(atoi(argv[2]));
@port serveur
if(connect(sock,&sin,sizeof(sin)) < 0)
{perror("connect");
}
printf ("Attente Message Serveur \n");
read (sock, buf, 18);
printf ("Message Recu : %s \n", buf);
close (sock);
}
C.Crochepeyre
demande connexion au serveur
attente d’un message du serveur
Applications CS
50
•
Serveur TCP
/*************************************/
/*
server.c
tcp_serveur
*/
/*
socket mode connecte
*/
/*
le serveur envoie un message au client */
/*
il n’attend rien du client
*/
/*************************************/
#include
<stdio.h>
#include
<signal.h>
#include
<sys/types.h>
#include
<sys/socket.h>
#include
<sys/time.h>
#include
<netinet/in.h>
#include
<netdb.h>
struct sockaddr_in sin = {AF_INET};
structure socket serveur
main(argc,argv)
char **argv;
{
int namelen, newsock, sock;
if((sock = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP)) < 0)
{perror("socket");
exit(1);
}
C.Crochepeyre
Applications CS
création socket serveur TCP
51
if(bind(sock, &sin, sizeof(sin)) < 0)
attachement de la socket serveur
{perror("bind");
exit(2);
}
namelen = sizeof(sin);
if(getsockname(sock, &sin, &namelen) < 0)
récupération n° port socket serveur
{perror("getsockname");
exit(3);
}
printf("server bound to port %u 0x%x \n",ntohs(sin.sin_port),sin.sin_port); affichage n° port
if(listen(sock,5) < 0)
ouverture du service, 5 connexions pendantes
{perror("listen");
exit(4);
}
for (;;)
{if((newsock = accept(sock,&sin,&namelen)) < 0) attente de connexion cliente, acceptation
{perror("accept");
et création de la socket de service et récupération de
exit(5); }
l’adresse du client dans &sin
write (newsock, "bonjour du Serveur", 18);
le serveur envoie son bonjour au client
close(newsock);
}
}
C.Crochepeyre
Applications CS
52