Réseaux TCP/IP

1 Le programme de l’atelier

Il s’agit d’un atelier de programmation réseau autour d’une manette série.

1.1 Programmation système

Analyse des paquets réseaux reçu par un micro-contrôleur.
Implantation de la partie réseau d’un système d’exploitation.
Dit autrement, implantation d’un embryon de pile TCP/IP.
Paquets reçus sur une liaison série par le protocole SLIP :
- simplification : pas de protocole Ethernet ;
- travail : implanter le procotole SLIP ;
- travail : analyser les entêtes IP ;
- travail : analyser les datagrammes UDP ;
- utilisation des données UDP ;
- travail : générer des paquets IP/UDP.

1.2 Programmation applicative

Communication avec la manette série par UDP.
Utilisation de la bibliothèque des sockets (mode non connecté).
Modification d’un jeu C pour utiliser la manette.

1.3 Configuration système basique

Définition d’une interface réseau SLIP.
Affectation d’adresses IPv4 à l’interface SLIP.

2 Définition d’Internet

Interconnexion de réseaux locaux.
Les données transitent sous forme de paquets.
Les interconnexions utilisent TCP/IP.
Présence de serveurs d’intérêt général.
Modèle de réseaux en 7 couches.

3 Couche 1 : media physiques

De nombreux média de diffusion : radio, cuivre, fibres, ...
Communication filaire robuste et efficace :
- des connexions point à point bi-directionnelles ;
- pas de collision, possibilité de congestion ;
- des distances de plusieurs dizaines de kilomètre ;
- des débits jusqu’à 100 Gb/s.
Communication radio fragile et capricieuse :
- plusieurs flux spatiaux nécessitent plusieurs antennes ;
- très peu de canaux en 2,4Ghz (14 au plus et recouvrants) ;
- regroupement de canaux en 5Ghz pour un débit élevé ;
- des interférences passives (murs, portes, passants, ...) ;
- des interférences actives (autres points d’accès, ...) ;
- un medium partagé avec les autres utilisateurs ;
- affaiblissement avec la distance ;
- ...

4 Couche 2 : les réseaux locaux

Des caractéristiques communes :
- réseau de petite taille (un bâtiment) ;
- possède un mécanisme de diffusion générale.
Une technologie prédominante : Ethernet.
- Format du paquet Ethernet :
  
  6 octets 6 octets 2 octets 48 à 1500 octets
  
  Adresse destination Adresse source Type Données
- Quelques types habituels :
  - 0x0806 : paquet ARP ;
  - 0x0800 : paquet IPv4 ;
  - 0x86dd : paquet IPv6.
- Le format des adresses Ethernet :
  - les adresses Ethernet sont sur 6 octets ;
  - identification unique d’une machine sur un réseau local ;
  - des adresses point à point (unicast) et de diffusion (multicast) ;
  - le préfixe de 3 octets est l’adresse constructeur ;
  - exemple d’adresses Ethernet :
    00:1a:a0:c0:17:6a
    
    ff:ff:ff:ff:ff:ff
Une technologie plus récente : WiFi.
- Le format des trames WiFi est complexe :
  - 4 champs adresses ;
  - un champ type de trame ;
  - un champ durée de transmission ;
  - un champ numéro de séquence ;
  - ...
- Même format d’adresse qu’Ethernet.

5 Couche 2 : les réseaux locaux

Matériels : commutateurs Ethernet et points d’accès WiFi.
Fonctionnement des commutateurs Ethernet :
- équipement actif (alimenté électriquement) ;
- les commutateurs Ethernet gérent des paquets Ethernet ;
- un commutateur comprend de nombreux ports de connexion ;
- des commutateurs sont connectés entre eux par leurs ports ;
- les ordinateurs sont connectés aux ports via des interfaces Ethernet ;
- le nuage de commutation sait transmettre un paquet Ethernet ;
- les paquets sont transmis efficacement (diffusion évitée).
Points d’accès WiFi :
- équipement actif (alimenté électriquement) ;
- généralement une interface Ethernet ;
- généralement deux interfaces radio (2,4Ghz et 5Ghz) ;
- conversion entre le protocole WiFi et le protocole Ethernet ;
- définition de noms de réseau (SSID) ;
- dispositifs d’identification et de chiffrage (e.g. WPA2-PSK).

6 Couche 2 : le protocole ARP

Principe : trouver l’adresse Ethernet en fonction de l’adresse IPv4 ;
Acronyme : Address Resolution Protocol ;
Un paquet ARP est encapsulé dans un paquet Ethernet ;
ARP se base sur la diffusion généralisée d’Ethernet ;
ARP est efficace grâce à un cache des réponses ARP ;

Le format du paquet ARP :

2 octets	2 octets	1 octet	1 octet	2 octets	6 octets	4 octets	6 octets	4 octets
Type de matériel	Type de protocole	Longueur @ matérielle	Longueur @ protocole	Opération	@ émetteur matérielle	@ émetteur protocole	@ destinataire matérielle	@ destinataire protocole
0x0001	0x0800	6	4	0x0001 ou 0x0002	-	-	-	-

En IPv6 ARP est intégré dans le protocole ICMPv6.

7 Couche 3 : interconnexion de réseaux

Pile TCP/IP :
- ensemble de protocoles réseau (IP, ICMP, UDP, TCP) ;
- définit le format des paquets d’échange de données ;
- définit comment un paquet est transmis sur un réseau local ;
- définit comment un paquet est routé entre les réseaux ;
- définit comment adresser un paquet à un processus.
Fonctionnement des routeurs IP :
- les routeurs n’utilisent pas de diffusion générale ;
- un routeur comprend des interfaces réseau (ports) ;
- des routeurs peuvent être interconnectés par leurs ports ;
- un commutateur Ethernet peut être connecté à un port ;
- le routeur examine, en particulier, l’adresse IP cible ;
- le routeur choisit le port de sortie via une table de routage ;
- une entrée de la table de routage concerne un réseau IP entier ;
- les entrées peuvent être saisie par un administrateur ;
- les entrées peuvent être apprises des autres routeurs.

8 Couche 3 : le protocole IP

Principe : Format d’échange de données entre deux ordinateurs d’Internet.
Acronyme : Internet Protocol.
La version actuelle est IPv4, la nouvelle est IPv6.
Un paquet contient une entête et des données.

L’entête contient les adresses IP de la source et de la cible :

4 bits	4 bits	1 octet	2 octets	4 octets	1 octet	1 octet	2 octets	4 octets	4 octets
Version	Longueur entêtes	Services et congestion	Longueur totale	Fragmentation	Durée vie	Protocole	Somme de contrôle	@ IPv4 source	@ IPv4 destination
0x4	0x5	0x00	-	0x00000000	0x40	-	-	-	-

Des protocoles encapsulés : 0x01 ICMP, 0x06 TCP ou 0x11 UDP.
Dans un réseau local la résolution d’adresse se fait par ARP (IPv4) ou ICMP (IPv6).
Format des adresses IP :
- identification unique d’une machine sur Internet ;
- les adresses IPv4 sont sur 4 octets ;
- les adresses IPv6 sont sur 16 octets ;
- les réseaux IP sont des plages d’adresses contigües ;
- exemple d’adresses IPv4 :
  192.168.0.1
  
  193.48.57.34
- exemple d’adresses IPv6 :
  fe80::1
  
  2001:660:4401:6002:215:c5ff:fef3:e3f
- exemple de réseaux IPv4 :
  192.168.0.0/255.255.255.0
  
  193.48.57.0/26

Calcul de la somme de contrôle :

porte sur l’entête IPv4 seule ;
somme des mots de 16 bits avec repli des retenues ;

programme C (entrée standard) :

#include <stdio.h>
#include <stdint.h>
int main(void){
uint32_t sum=0; 
uint8_t h,l;
while(scanf("%hhx",&h)==1){ 
  if(scanf("%hhx",&l)!=1) l=0;
  sum += ((uint16_t)h<<8)|l;
  }
while(sum>>16) sum=(sum&0xffff)+(sum>>16);
printf("%04x\n",(uint16_t)~sum);
return 0;
}

programme C (opération sur tableau d’octets) :

#include <stdio.h>
#include <stdint.h>

#define SIZE_TOTAL 59
#define SIZE_IPHEAD 20

uint8_t ip[SIZE_TOTAL]={
  0x45,0x00,0x00,0x3b,0x2c,0xf5,0x40,0x00,0x40,0x11,0xd5,0xf7,0xac,0x1a,0x91,0x4a,
  0xc1,0x30,0x39,0x30,0xdd,0x9e,0x00,0x35,0x00,0x27,0x37,0xfe,0x7f,0x4a,0x01,0x00,
  0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x05,0x70,0x72,0x6f,0x78,0x79,0x04,0x70,
  0x6c,0x69,0x6c,0x02,0x66,0x72,0x00,0x00,0x1c,0x00,0x01
  };

uint16_t checksum(uint8_t *bytes,int size){
uint32_t sum=0; 
int i;
for(i=0;i<size;i += 2){
  uint8_t h,l;
  h=bytes[i];
  l=(i<size-1)?bytes[i+1]:0;
  sum += ((uint16_t)h<<8)|l;
  }
while(sum>>16) sum=(sum&0xffff)+(sum>>16);
return (uint16_t)~sum;
}

int main(void){
uint16_t sum=checksum(ip,SIZE_IPHEAD);
printf("%04x\n",sum);
return 0;
}

9 Couche 3,5 : le protocole ICMPv4

Principe : véhicule les erreurs et les informations.
Acronyme : Internet Control Message Protocol.
Protocole de service de TCP/IP.
Un paquet ICMPv4 est encapsulé dans un paquet IPv4.
Permet de remonter les erreurs rencontrées (traceroute).
Permet d’échanger des informations sur l’état du réseau (ping).
Format des entêtes ICMPv4 :

1 octet 1 octet 2 octets

Type Code Somme de contrôle

Principaux types et codes ICMPv4 :

Type	Code	Description
0	0	Réponse d’écho
3	0	Réseau inaccessible
3	1	Machine inaccessible
3	2	Protocole inaccessible
3	3	Port inaccessible
3	4	Fragmentation impossible
4	0	Limitation du débit de la source
5	0	Modification de route
8	0	Demande d’écho
11	0	Datagramme trop vieux

10 Couche 4 : le protocole UDP

Principe : permet d’échanger des données entre processus.
Acronyme : User Datagram Protocol.
Protocole de transport de TCP/IP.
Les paquets UDP sont encapsulés dans des paquets IP.
Les données UDP sont les données des processus.
Les processus sont adressés par la notion de ports.
Des services utilisent des ports bien connus (53 pour le DNS).
UDP est un protocole léger mais peu fiable :
- perte de paquets possible ;
- duplication de paquets possible ;
- ordre de remise non garanti.
Format des entêtes UDP :

2 octet 2 octet 2 octets 2 octets

Port source Port destination Longueur totale Somme de contrôle

Somme de contrôle UDP :

même algorithme que pour IPv4 ;
appliquer sur l’ensemble du paquet UDP ;
prendre en compte une pseudo-entête :
- adresses IPv4 ;
- code du protocole UDP sur 16 bits : 0x0011 ;
- taille du paquet UDP sur 16 bits.

Exemple de calcul :

#include <stdio.h>
#include <stdint.h>

#define SIZE_TOTAL 59
#define SIZE_IPHEAD 20
#define SIZE_IPADDR 4
#define SIZE_PORT 2

uint8_t ip[SIZE_TOTAL]={
  0x45,0x00,0x00,0x3b,0x2c,0xf5,0x40,0x00,0x40,0x11,0xd5,0xf7,0xac,0x1a,0x91,0x4a,
  0xc1,0x30,0x39,0x30,0xdd,0x9e,0x00,0x35,0x00,0x27,0x19,0x14,0x7f,0x4a,0x01,0x00,
  0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x05,0x70,0x72,0x6f,0x78,0x79,0x04,0x70,
  0x6c,0x69,0x6c,0x02,0x66,0x72,0x00,0x00,0x1c,0x00,0x01
  };

uint32_t checksum(uint8_t *bytes,int size,uint32_t sum,unsigned char final){
int i;
for(i=0;i<size;i += 2){
  uint8_t h,l;
  h=bytes[i];
  l=(i<size-1)?bytes[i+1]:0;
  sum += ((uint16_t)h<<8)|l;
  }
if(final){
  while(sum>>16) sum=(sum&0xffff)+(sum>>16);
  return (~sum)&0xffff;
  }
else return sum;
}

int main(void){
uint8_t *udp=ip+SIZE_IPHEAD;
uint8_t *addresses=ip+SIZE_IPHEAD-2*SIZE_IPADDR;
uint8_t protocol[]={0x00,0x11};
uint8_t *udpsize=udp+2*SIZE_PORT;
uint32_t sum=checksum(addresses,2*SIZE_IPADDR,0,0);
sum=checksum(protocol,2,sum,0);
sum=checksum(udpsize,2,sum,0);
sum=checksum(udp,SIZE_TOTAL-SIZE_IPHEAD,sum,1);
printf("%04x\n",sum);
return 0;
}

11 Couche 4 : le protocole TCP

Principe : permet d’échanger des données entre processus.
Acronyme : Transmission Control Protocol.
Protocole de transport de TCP/IP.
Les paquets TCP sont encapsulés dans des paquets IP.
Les données TCP sont les données des processus.
Les processus sont adressés par la notion de ports.
Des services utilisent des ports bien connus (80 pour le Web).
TCP est un protocole fiable :
- établissement et terminaison de connexion ;
- envoi d’accusés de réception ;
- minuteurs pour ré-émission si nécessaire ;
- pas de perte de données, pas de doublon, remise dans l’ordre.
Des entêtes complexes avec de nombreuses options.
Même algorithme de calcul de la somme de contrôle qu’UDP.

12 Couche 5 : inexistante

Le modèle Open Systems Interconnection (OSI) de l’ISO est obsolète.

Une légende urbaine dit que les rédacteurs étaient ivres :

Numéro de couche	Nom du nain	Nom de la couche	Explication
1	Dormeur	Physique	Les connexions physiques sont ennuyeuses
2	Atchoum	Lien	Un renifleur réseau montre une explosion de paquets
3	Joyeux	Réseau	Tout le monde est content de la couche réseau
4	Prof	Transport	Compliqué à comprendre (TCP en particulier)
5	Simplet	Session	Faudrait l’être pour en réaliser une
6	Timide	Présentation	Personne n’en a vu
7	Grincheux	Applications	Un développeur réseau est d’abord rude

13 Couche 6 : inexistante

Le modéle Internet diffère du modèle OSI.
Modèle Internet à 4 couches :
- accès réseau ;
- Internet ;
- transport ;
- application.

14 Couche 7 : programmation réseau

Programmation en C avec la bibliothèque des "sockets".
Disponible depuis 1982 sous Unix BSD.
Utilisée par la plupart des applications réseau.
Caractéristiques des sockets :
- deux sockets pour une communication ;
- représentation gros-boutiste des données ;
- plusieurs familles de sockets ;
- plusieurs modes pour une famille ;
- un adressage pour chaque famille.
Familles de sockets actuelles :
- PF_LOCAL : communication intra-système ;
- PF_INET : communication TCP/IPv4 ;
- PF_INET6 : communication TCP/IPv6 ;
- PF_BLUETOOTH : communication bluetooth.
Modes principaux :
- SOCK_STREAM : mode connecté ;
- SOCK_DGRAM : mode non connecté ;
- SOCK_RAW : mode accès direct.
Structure d’adresses :
- structure classique pour les prototypes struct sockaddr ;
- structure maximale pour le stockage struct sockaddr_storage ;
- type et nom de fichier pour AF_LOCAL ;
- type, adresse IPv4 et port pour AF_INET ;
- type, adresse IPv6, port, etc pour AF_INET6 ;
- type, adresse, canal pour AF_BLUETOOTH.

15 Couche 7 : sockets mode connecté

16 Couche 7 : sockets mode connecté

Une fonction d’initialisation de serveur :

int initialisationServeur(char *service,int connexions){
struct addrinfo precisions,*resultat,*origine;
int statut;
int s;

/* Construction de la structure adresse */
memset(&precisions,0,sizeof precisions);
precisions.ai_family=AF_UNSPEC;
precisions.ai_socktype=SOCK_STREAM;
precisions.ai_flags=AI_PASSIVE;
statut=getaddrinfo(NULL,service,&precisions,&origine);
if(statut<0){ perror("initialisationServeur.getaddrinfo"); exit(EXIT_FAILURE); }
struct addrinfo *p;
for(p=origine,resultat=origine;p!=NULL;p=p->ai_next)
  if(p->ai_family==AF_INET6){ resultat=p; break; }

/* Creation d'une socket */
s=socket(resultat->ai_family,resultat->ai_socktype,resultat->ai_protocol);
if(s<0){ perror("initialisationServeur.socket"); exit(EXIT_FAILURE); }

/* Options utiles */
int vrai=1;
if(setsockopt(s,SOL_SOCKET,SO_REUSEADDR,&vrai,sizeof(vrai))<0){
  perror("initialisationServeur.setsockopt (REUSEADDR)");
  exit(EXIT_FAILURE);
  }
if(setsockopt(s,IPPROTO_TCP,TCP_NODELAY,&vrai,sizeof(vrai))<0){
  perror("initialisationServeur.setsockopt (NODELAY)");
  exit(EXIT_FAILURE);
  }

/* Specification de l'adresse de la socket */
statut=bind(s,resultat->ai_addr,resultat->ai_addrlen);
if(statut<0){ freeaddrinfo(origine); shutdown(s,SHUT_RDWR); return -1; }

/* Liberation de la structure d'informations */
freeaddrinfo(origine);

/* Taille de la queue d'attente */
statut=listen(s,connexions);
if(statut<0){ shutdown(s,SHUT_RDWR); return -2; }

return s;
}

Une fonction d’attente des clients :

int boucleServeur(int ecoute,int (*traitement)(int))
{
int dialogue;

while(1){

    /* Attente d'une connexion */
    if((dialogue=accept(ecoute,NULL,NULL))<0) return -1;

    /* Passage de la socket de dialogue a la fonction de traitement */
    if(traitement(dialogue)<0){ shutdown(ecoute,SHUT_RDWR); return 0;}

    }
}

La fonction de traitement des clients :

int gestionClient(int s){

/* Obtient une structure de fichier */
FILE *dialogue=fdopen(s,"a+");
if(dialogue==NULL){ perror("gestionClient.fdopen"); exit(EXIT_FAILURE); }

/* Echo */
char ligne[MAX_LIGNE];
while(fgets(ligne,MAX_LIGNE,dialogue)!=NULL)
  fprintf(dialogue,"> %s",ligne);

/* Termine la connexion */
fclose(dialogue);
return 0;
}

La fonction principale :

#define MAX_CONNEXIONS 16
int main(void)
{
int s;
 
/* Initialisation du serveur */
s=initialisationServeur("4000",MAX_CONNEXIONS);
   
/* Lancement de la boucle d'ecoute */
boucleServeur(s,gestionClient);
}

17 Couche 7 : sockets mode connecté

Un exemple de client :

int connexionServeur(char *hote,char *service){
struct addrinfo precisions,*resultat,*origine;
int statut;
int s;

/* Creation de l'adresse de socket */
memset(&precisions,0,sizeof precisions);
precisions.ai_family=AF_UNSPEC;
precisions.ai_socktype=SOCK_STREAM;
statut=getaddrinfo(hote,service,&precisions,&origine);
if(statut<0){ perror("connexionServeur.getaddrinfo"); exit(EXIT_FAILURE); }
struct addrinfo *p;
for(p=origine,resultat=origine;p!=NULL;p=p->ai_next)
  if(p->ai_family==AF_INET6){ resultat=p; break; }

/* Creation d'une socket */
s=socket(resultat->ai_family,resultat->ai_socktype,resultat->ai_protocol);
if(s<0){ perror("connexionServeur.socket"); exit(EXIT_FAILURE); }

/* Connection de la socket a l'hote */
if(connect(s,resultat->ai_addr,resultat->ai_addrlen)<0)
  { freeaddrinfo(origine); shutdown(s,SHUT_RDWR); return -1; }

/* Liberation de la structure d'informations */
freeaddrinfo(origine);

return s;
}

La fonction principale :

int main(void)
{
int s;

/* Connection au serveur */
s=connexionServeur(machine,"4000");
if(s<0){ fprintf(stderr,"Erreur de connexion au serveur\n"); exit(EXIT_FAILURE); }    

/* Boucle de communication avec le serveur */
struct pollfd descripteurs[2];
descripteurs[0].fd=s;
descripteurs[0].events=POLLIN;
descripteurs[1].fd=0;
descripteurs[1].events=POLLIN;
while(1){
  char tampon[MAX_TAMPON];
  int nb=poll(descripteurs,2,-1);
  if(nb<0){ perror("main.poll"); exit(EXIT_FAILURE); }
  if((descripteurs[0].revents&POLLIN)!=0){
    int taille=read(s,tampon,MAX_TAMPON);
    if(taille<=0) break;
    write(1,tampon,taille);
    }
  if((descripteurs[1].revents&POLLIN)!=0){
    int taille=read(0,tampon,MAX_TAMPON);
    if(taille<=0) break;
    write(s,tampon,taille);
    }
  }

/* On termine la connexion */
shutdown(s,SHUT_RDWR);

return 0;
}

18 Couche 7 : sockets mode non connecté

19 Couche 7 : sockets mode non connecté

Un exemple de serveur :

int initialisationSocketUDP(char *service){
struct addrinfo precisions,*resultat,*origine;
int statut;
int s;

/* Construction de la structure adresse */
memset(&precisions,0,sizeof precisions);
precisions.ai_family=AF_UNSPEC;
precisions.ai_socktype=SOCK_DGRAM;
precisions.ai_flags=AI_PASSIVE;
statut=getaddrinfo(NULL,service,&precisions,&origine);
if(statut<0){ perror("initialisationSocketUDP.getaddrinfo"); exit(EXIT_FAILURE); }
struct addrinfo *p;
for(p=origine,resultat=origine;p!=NULL;p=p->ai_next)
  if(p->ai_family==AF_INET6){ resultat=p; break; }

/* Creation d'une socket */
s=socket(resultat->ai_family,resultat->ai_socktype,resultat->ai_protocol);
if(s<0){ perror("initialisationSocketUDP.socket"); exit(EXIT_FAILURE); }

/* Options utiles */
int vrai=1;
if(setsockopt(s,SOL_SOCKET,SO_REUSEADDR,&vrai,sizeof(vrai))<0){
  perror("initialisationServeurUDPgenerique.setsockopt (REUSEADDR)");
  exit(EXIT_FAILURE);
  }
if(setsockopt(s,SOL_SOCKET,SO_BROADCAST,&vrai,sizeof vrai)<0){
  perror("initialisationSocketUDP.setsockopt (BROADCAST)");
  exit(EXIT_FAILURE);
  }

/* Specification de l'adresse de la socket */
statut=bind(s,resultat->ai_addr,resultat->ai_addrlen);
if(statut<0) { freeaddrinfo(origine); shutdown(s,SHUT_RDWR); return -1; }

/* Liberation de la structure d'informations */
freeaddrinfo(origine);

return s;
}

Boucle de réception des messages UDP :

int boucleServeurUDP(int s,int (*traitement)(unsigned char *,int,char *)){
while(1){
  struct sockaddr_storage adresse;
  socklen_t taille=sizeof(adresse);
  unsigned char message[MAX_UDP_MESSAGE];
  int nboctets=recvfrom(s,message,MAX_UDP_MESSAGE,0,(struct sockaddr *)&adresse,&taille);
  if(nboctets<0) return -1;
  char nom[MAX_NOM];
  nom[0]='\0';
  getnameinfo((struct sockaddr *)&adresse,taille,nom,MAX_NOM,NULL,0,0);
  if(traitement(message,nboctets,nom)<0) break;
  }
return 0;
}

Programme principal :

int main(void){
int s=initialisationSocketUDP("4242");
boucleServeurUDP(s,votreFonctionUDP);
close(s);
return 0;
}

20 Couche 7 : sockets mode non connecté

Un exemple de client :

void *creationAddresseUDP(char *hote,char *service){
struct addrinfo precisions,*resultat,*origine;
int statut;

/* Creation de l'adresse de socket */
memset(&precisions,0,sizeof precisions);
precisions.ai_family=AF_UNSPEC;
precisions.ai_socktype=SOCK_DGRAM;
statut=getaddrinfo(hote,service,&precisions,&origine);
if(statut<0){ perror("creationAddressUDP.getaddrinfo"); exit(EXIT_FAILURE); }
struct addrinfo *p;
for(p=origine,resultat=origine;p!=NULL;p=p->ai_next)
  if(p->ai_family==AF_INET6){ resultat=p; break; }

/* Copie de la structure adresse */
struct sockaddr_storage *adresse=malloc(sizeof(struct sockaddr_storage));
if(adresse==NULL){ perror("creationAddressUDP.malloc"); exit(EXIT_FAILURE); }
memcpy(adresse,resultat->ai_addr,resultat->ai_addrlen);

/* Liberation de la structure d'informations */
freeaddrinfo(origine);

return adresse;
}

void messageUDP(int s,void *adresse,unsigned char *message,int taille){
int nboctets=sendto(s,message,taille,0,(struct sockaddr *)adresse,sizeof(struct sockaddr_storage));
if(nboctets<0){ perror("messageUDP.sento"); exit(EXIT_FAILURE); }
}

Programme principal :

int main(int argc,char *argv[]){
if(argc!=3){
  fprintf(stderr,"Syntaxe : %s <serveur> <message>\n",argv[0]);
  exit(EXIT_FAILURE);
  }
char *hote=argv[1];
char *message=argv[2];
char *service="4242";
int s=initialisationSocketUDP("0");
void *cible=creationAddresseUDP(hote,service);
int i;
for(i=0;i<10;i++)
  messageUDP(s,cible,(unsigned char *)&i,sizeof i);
free(cible);
close(s);
return 0;
}

21 Couche 7 : Protocole DNS

Traduction de noms Internet en adresses IP.
Exemple : www.polytech-lille.fr donne 193.48.57.52.
La résolution inverse est possible.
Exemple : 52.57.48.193.in-addr.arpa donne calais.escaut.net.
De nombreuses autres informations sont disponibles.
Exemple : polytech-lille.fr pour le type NS donne beuvry.escaut.net.
Base de données distribuée et hiérarchique.
Une résolution récursive :
- requête "type A pour www.polytech-lille.fr" au serveur DNS local ;
- requête identique du DNS local à un serveur DNS racine (stockés sur disque) ;
- retour du serveur racine avec, comme indices, les serveurs DNS de fr ;
- requête initiale du DNS local à un serveur DNS de fr ;
- retour du serveur de fr avec, comme indices, les serveurs DNS de polytech-lille.fr ;
- requête initiale du DNS local à un serveur DNS de polytech-lille.fr ;
- réponse du serveur DNS de polytech-lille.fr "type A, adresse 193.48.57.52" ;
- mise en cache de la réponse et propagation au client DNS.

22 Couche 7 : Protocole HTTP

Sert des pages contenant des informations.
Ces pages possédent des adresses appelées URL (Uniform Resource Locator).
Les pages HTML (Hypertext Markup Language) contiennent des références à d’autres pages.
Un protocole simple pour la toile : HTTP (Hypertext Transfer Protocol).
Accès aux pages avec un client HTTP : un navigateur Web.
Les navigateurs utilisent le DNS pour résoudre les URL.
Les principales commandes HTTP :
- GET : réclame un document ;
- HEAD : réclame uniquement les entêtes ;
- POST : envoi de données au serveur ;
- PUT : envoi du document d’URL spécifiée.
Les différentes étapes de la récupération d’une page Web :
- une requête du navigateur au serveur avec la commande GET ;
- envoi des entêtes annexes à la requête par le navigateur ...
- ... terminé par une ligne vide ;
- une réponse du serveur à la commande incluant un code numérique ;
- envoi des entêtes liées à la page par le serveur ...
- ... terminé par une ligne vide ;
- enfin transmission de la page par le serveur.

Exemple de session HTTP :

$ nc www.polytech-lille.fr 80
GET / HTTP/1.1
Host: pevele.escaut.net
Accept: */*
User-Agent: WebParTelnet
From: Xavier.Redon@polytech-lille.fr
If-Modified-Since: Sat, 10 Jan 2003 19:43:31 GMT   

HTTP/1.1 200 OK
Date: Tue, 11 Mar 2003 20:44:29 GMT
Server: Apache/1.3.27 (Unix) Debian GNU/Linux PHP/4.2.3
X-Powered-By: PHP/4.2.3
Transfer-Encoding: chunked
Content-Type: text/html

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<HTML> <HEAD>
<TITLE>Polytech'Lille > Ecole polytechnique universitaire de Lille,
...

23 Couche 7 : Protocoles SMTP, POP et IMAP

Acronyme : Simple Mail Transfert Protocol.
Acronyme : Post Office Protocol.
Acronyme : Internet Message Access Protocol.
Des clients de messagerie permettent d’envoyer des messages.
Les messages sont envoyé à une ou des adresses de courriel.
Les messages sont aiguillés grâce au DNS.
Les messages sont reçus par des serveurs SMTP.
Les serveurs SMTP confient les messages à des facteurs.
Les facteurs stockent les messages dans des boites aux lettres.
Un message est constitué d’une entête et d’un corps.
Le corps d’un message est souvent au format MIME (Multipurpose Internet Mail Extensions).
Des clients de messagerie récupérent les messages (POP ou IMAP).

Exemple de session SMTP :

$ host -t MX polytech-lille.fr
polytech-lille.fr mail is handled by 50 peronne.escaut.net.
polytech-lille.fr mail is handled by 100 douaisis.escaut.net.
$ nc -C peronne.escaut.net 25
220 <serveur SMTP> ESMTP Sendmail ...
HELO <domaine du client SMTP>
250 <serveur SMTP> Hello pleased to meet you
MAIL FROM: <Zorro@monterey.org>
250 Zorro@monterey.org... Sender ok
RCPT TO: <Xavier.Redon@polytech-lille.fr>
250 Recipient ok
DATA
354 Enter mail, end with "." on a line by itself
Subject: Z comme zozo

Je tiens a vous dire que j'ai prevenu l'ISO de
votre manque de respect envers le modele OSI.
Zorro
.
250 PAA27560 Message accepted for delivery
QUIT  
221 <serveur SMTP> closing connection
$

Exemple de session POP :

$ nc pop.polytech-lille.fr 110
+OK <Serveur POP3> POP3 3.3(28) w/IMAP client 
USER rex
+OK User name accepted, password please
PASS <shut!!>
+OK Mailbox rex open, 1 messages
LIST
+OK Mailbox scan listing follows
1 2234
.
TOP 1 1
+OK Top of message follows
Return-Path: <Zorro@monterey.org>
.
DELE 1
+OK Message deleted
QUIT
+OK Sayonara
$

Exemple de session IMAP :

$ nc pop.polytech-lille.fr 143
* OK pevele Cyrus IMAP4 v1.5.14 server ready
tag1 login rex <shut!!>
tag1 OK User logged in
tag2 list "" *
* LIST () "." "INBOX"
* LIST () "." "INBOX.Drafts"
* LIST () "." "INBOX.Sent"
* LIST () "." "INBOX.Trash"
tag2 OK Completed
tag3 select inbox
* FLAGS (\Answered \Flagged \Draft \Deleted \Seen)
* 241 EXISTS
* 0 RECENT
* OK [UNSEEN 180] 
tag3 OK [READ-WRITE] Completed
tag4 fetch 10 body[text]
* 10 FETCH (BODY[TEXT] {125}
Salut,
...
A+,
tag4 OK Completed
tag5 logout
* BYE LOGOUT received
tag5 OK Completed
$

Ce document a été traduit de L^AT_EX par H^EV^EA

2 octet	2 octet	2 octets	2 octets
Port source	Port destination	Longueur totale	Somme de contrôle