Communication en mode message asynchrone - Interfaces de mode message asynchrone Exemple de l'interface socket Berkeley

 
Communication en mode
  message asynchrone

Interfaces de mode message
         asynchrone

Exemple de l’interface socket
         Berkeley

         Anas ABOU EL KALAM - CNAM   1
Introduction: interfaces de mode
    message dans les réseaux

Deux approches principales (++approches annexes)
  Comme interface d’un service de niveau transport
  Comme interface d’un service de niveau application
     mode unifié de communication par messages
    pour des applications
     Offrant des extensions plus ou moins
    significatives par rapport au niveau transport

                Anas ABOU EL KALAM - CNAM
                                      2
Introduction: interfaces de mode
    message dans les réseaux

          Anas ABOU EL KALAM - CNAM
                                3
Les interfaces de "transport" en
      mode message asynchrone
  Communication de bout en bout : "End to end communication"
Existence piles de protocoles de couches basses résumées au niveau transport
      NetBIOS ==> IPX/SPX ==> TCP/IP, ...
  Existence d'interfaces logicielles pour l'accès à des piles de
  protocoles : API utilisable de préférence pour plusieurs piles
      Sockets, TLI, NetBEUI, APPC/CPI-C, ...

                                                     Tubes    CPI-C
                            NetBEUI   Sockets TLI             APPC
                                                    nommés
                Transport
                                       TCP          SPX      LU 6.2
                                                             APPN
                 Réseau     NetBIOS     IP          IPX
                                           IEEE 802-2 - PPP
                 Liaison                        LLC / SNAP
                                               MAC
                Physique     Anas ABOU
                             Réseau Réseau EL KALAM - CNAM
                                               Voie point à point 4
                                     Local
Les API de "transport" (1)
Sockets
   Interface de programmation pour la suite TCP/IP. 1981. Berkeley BSD.
   Le standard UNIX de facto.
   L'API sockets sous Windows est baptisée WinSock.
TLI ("Transport Layer Interface")
Proposition AT&T d'une interface TCP/IP pour System V, plus performante
et plus indépendante du réseau sous-jacent (1986, 25 primitives).
NetBEUI "NetBios Extended Basic Input Output System"
   Interface de programmation introduite en 1984 pour le PC Network
   (utilisé pour la pile NetBIOS") pile de protocoles pour les réseaux locaux
   (IBM et Microsoft).
   Utilisé pour la pile de communication SPX/IPX de Novell ("Sequenced
   Packed Exchange/ Internet Packet Exchange").
                        Anas ABOU EL KALAM - CNAM
                                              5
Les API de "transport" (2)
Les tubes nommés ("Named pipes")
  Interface d'échange entre processus IPC ("InterProcessCommunication")
  introduite sous UNIX BSD pour étendre la notion de tube.
  permettent de considérer les échanges réseaux comme des accès
  fichiers (disponibles sur TCP/IP, SPX/IPX).
APPC et CPI-C
  "Advanced Program to Program Communication" et "Common
  Programming Interface for Communication“.
  Pour architecture réseau incorporant tout type de matériels grands,
  moyens et petits systèmes sous le nom d'APPN (" Advanced Peer to Peer
  Network").
  CPI-C (40 primitives) simplifie l'interface APPC et masque les différences.

                       Anas ABOU EL KALAM - CNAM
                                             6
Interfaces d'application en mode
    message : notion de MOM
MOM : "Message Oriented Middleware"
  1993 : Consortium autour de IBM puis normalisation (OSI).
A) Interface universelle pour des échanges en mode message
  asynchrone (qui cache les différentes API transport).
B) Notion de files d'attentes de messages ("Message queues"):
     Les files d’attente sont persistantes (sur disque) ou non persistantes.
       • Avec file non persistante : comportement est celui du transport.
       • Avec file persistante : un site qui n'est pas opérationnel sera atteint
          lors de son réveil (fonctionnement asynchrone similaire au courrier électronique)
Produits commerciaux
  MQ series : Message Queues Series IBM.
  MSMQ : Microsoft Message Queueing.
  Autres produits: TIBCO, SUN.
                           Anas ABOU EL KALAM - CNAM
                                                 7
Interfaces en mode message
         asynchrone

 Exemple d’un service pour
       TCP et UDP :
   les sockets Berkeley

         Anas ABOU EL KALAM - CNAM   8
Généralités interface "socket"
  1982 : API réseaux pour la version UNIX BSD.
Deux programmes différents
          » Le serveur se met en attente de demandes (passif)
          » Le client initie le dialogue par une demande (actif)
  Objectifs
      Fournir des moyens de communications entre processus ( IPC)
      utilisables en toutes circonstances: échanges locaux ou réseaux.
Pour programmeur
          offre moyen d'utiliser des fonctions du SE semblables à celles qui
          régissent l'accès aux fichiers, e.g., lire&écrire données sur réseau
          comme il ferait sur système fichiers
Pour usagers
          cacher détails d'implantation des couches transport.
          Si possible, cacher les différences entre protocoles de transport
          hétérogènes sous   Anas
                               uneABOU       EL KALAM
                                    même interface    (TCP, -Novell
                                                              CNAM
                                                               9 XNS, OSI)
Analogie avec le téléphone
Socket = point d’accès au réseau pour couches transport
   désigne souvent l'ensemble min des infos permettant à un logiciel
   d'écouter les tentatives d'établissement de connexion réseau,
       e.g., @IP, protocole (souvent UDP ou TCP) et port ...
    Comparable à un téléphone
   C’est l’extrémité d’un canal de communication permettant l’échange de
   donnée entre deux entités (les utilisateurs du téléphone)
utilisateurs des téléphones          applis/process qui utilisent ces sockets
   Utilisateur demandeur             c’est le client, c’est lui qui compose num
   Utilisateur en attente coup fil   c’est le serveur, il décroche
                        Anas
Une fois la communication     ABOU
                          établie,      EL bi-directionnelle
                                   elle est KALAM - CNAM  10et symétrique
Exemple d’utilisation d’une application
     client/serveur : appli SSH
 /etc/services
    ssh 22/udp # SSH Remote Login Protocol
    ssh 22/tcp   # SSH Remote Login Protocol
 ssh toto.titi.fr
    lance client en lui donnant nom DNS ou @ du serveur à connecter
    L’appli consulte l’annuaire DNS : toto.titi.fr -> 195.221.225.6
    demande connexion avec socket du serveur (195.221.225.6, 22)
    socket côté client est (192.1.1.2, 3400)
        numéro port libre sur machine où tourne client (192.1.1.2)
 Il faut qu’1 serveur (process/demon) ssh soit lancé sur machine destination
    sshd (ps -aux | grep sshd)

                         Anas ABOU EL KALAM - CNAM
                                               11
Exemple d’utilisation d’une application
     client/serveur : appli SSH
 /etc/services
    ssh 22/udp # SSH Remote Login Protocol
    ssh 22/tcp   # SSH Remote Login Protocol
 ssh toto.titi.fr
    lance client en lui donnant nom DNS ou @ du serveur à connecter
    L’appli consulte l’annuaire DNS : toto.titi.fr -> 195.221.225.6
    demande connexion avec socket du serveur (195.221.225.6, 22)
    socket côté client est (192.1.1.2, port libre, e.g., 3400)
 Serveur ssh (sshd) doit être lancé sur machine dest. (ps -aux | grep sshd)
                        Client         Serveur
                    Ssh toto.titi.fr    Sshd

                            Anas ABOU EL KALAM - CNAM
                                                  12
Exemple d’utilisation d’une application
     client/serveur : appli SSH
                                            Serveur
                             Client
                                             Sshd
                         Ssh toto.titi.fr

 Une fois communication établie, le flux de donnée peut être bi-directionnel

 NSAP,TSAP ==> communication est identifiée par le quadruplet:
    (@IP source, port source, @IP destination, port destination)

        Une adresse Internet: identifie la machine dans le réseau

        Un numéro de port: identifie l’application sur la machine

                         Anas ABOU EL KALAM - CNAM
                                               13
Exemple d’utilisation d’une application
     client/serveur : annuaires
 Local Nom/adresses internet: fichier système        (/etc/hosts)   sur machine
 Global Nom/adresses internet: DNS (C/S, distribué)
 Local Application/numéro port: fichier système         (/etc/services)   sur machine
    Numéro port attribués aux applications “standards” (réservés
Choix de conception des sockets
           avec TCP
TCP : fiable, connexion, bidirectionnel, point à point
   connexion identifiée par @ socket des 2 extrémités
   socket TCP peut être utilisée par plusieurs connexions TCP
   simultanément
Un échange TCP est orienté flot d'octets
   Les zones de données qui correspondent à des envois successifs ne sont
   pas connues à la réception
   Pour optimiser TCP peut tamponner les données et les émettre
   ultérieurement
   "push" : demander l'émission immédiate d'un segment.
   "urgent" : permettre l'échange rapide de données exceptionnelles avec
   signalement d'arrivéeAnas ABOU EL KALAM - CNAM    15
Choix de conception des sockets
           avec UDP

UDP : non fiable, sans connexion, bidirectionnel, point à point
@ UDP d'une socket
  (Num port UDP , @ IP)
Un échange UDP est sans connexion (échange de
datagrammes).
Les zones de données qui correspondent à des envois
successifs sont respectées à la réception.

                    Anas ABOU EL KALAM - CNAM
                                          16
Exemple des protocoles et services
    de transport INTERNET

   Les primitives de l'interface
              socket

  Exemple en langage C en UNIX.

            Anas ABOU EL KALAM - CNAM   17
Choix de conception des sockets
Une socket est analogue à un objet (de communication)

 Type : protocole de transport? sémantique de l'accès au service?
 Nom : identifiant unique sur chaque site (entier 16 bits)
 Ensemble de primitives : service pour l'accès aux fonctions de transport
 Données encapsulées :
   descriptif (pour sa désignation et sa gestion)
   files d'attente de messages en entrée et en sortie

                         Anas ABOU EL KALAM - CNAM
                                               18
Primitive socket
Création d'un nouveau point d'accès de service transport
  définition de son type.
  allocation de l'espace des données.
Trois paramètres d'appel
  Famille d'adresses réseaux utilisées : locale, réseau IP, réseau OSI ...
  Type de la socket (du service) sémantique de la communication.
  Protocole de transport utilisé.
Un paramètre résultat
 Numéro descripteur socket
Profil d'appel de la primitive en C
   #include 
   #include 
   #include 
   int socket (int famille, int type, int protocole);
                              Anas ABOU EL KALAM - CNAM
                                                    19
Primitive socket
Récupération de sa propre adresse
  Permet de définir la socket locale
  int gethostname (char *nom, int longueur_nom)
      renseigne le nom de la machine sur laquelle s’exécute la procédure
  On utilise ensuite gethostbyname pour avoir l’adresse associée

Récupération d’un numéro de port alloué dynamiquement
  int getsockname(int socket, struct sockaddr_in *p_ad_s, int *len)
      *len doit contenir la longueur de la structure sockaddr_in

                       Anas ABOU EL KALAM - CNAM
                                             20
Socket: Accès à son @ et numéro port
Récupération de sa propre adresse
  Permet de définir la socket locale
  int gethostname (char *nom, int longueur_nom)
      renseigne le nom de la machine sur laquelle s’exécute la procédure
  On utilise ensuite gethostbyname pour avoir l’adresse associée

Récupération d’un numéro de port alloué dynamiquement
  int getsockname(int socket, struct sockaddr_in *p_ad_s, int *len)
      *len doit contenir la longueur de la structure sockaddr_in

                       Anas ABOU EL KALAM - CNAM
                                             21
Socket: Installer nouvelle prise téléphone
La fonction int socket (int domaine, int mode, int protocole)
   retourne un identificateur de socket (entier qui est un descripteur de
   fichier), -1 en cas d’erreur
       Identificateur: locale à la machine et n’est pas connu par destinataire
domaine
   AF-INET : prise Réseau Internet
   PF-INET : prise pour utilisation locale (interne à machine entre process)
mode
   SOCK_STREAM (pour TCP),
   SOCK_DGRAM (pour UDP),
   SOCK_RAW (pour IP)

                         Anas ABOU EL KALAM - CNAM
                                               22
Socket: Associer un numéro à la prise de
                téléphone
   La fonction int bind( int sock, sockaddr_in *p_adr_s, int lg_struct)
       sock: identificateur de la socket
       p_adr_s: pointeur vers structure contenant numéros à associer à socket
       (@IP et port)
       lg_struct: la longueur de la structure
   Structure sockaddr_in
       (A remplir avant l’appel de bind)
       struct sockaddr_in
{ short sin_family"; /* famille d’adresse"*/
  ushort sin_port"; /* numéro de port */
  ulong sin_addr"; /* adresse de niveau 3": IP*/
  char sin_zero [8]";     /* inutilisé (mis à zéro) */
}
                                 Anas ABOU EL KALAM - CNAM
                                                       23
Socket: Numéros spéciaux
Possibilité de laisser au système le choix d’un num port
libre au moment de l’appel à la fonction bind
   C’est intéressant dans le cas d’un client
   Il suffit de mettre dans la structure sockaddr_in le
   champ sin_port à 0

Possibilité d’associer à une socket l’ensemble des
adresses IP de la machine dans le cas où elle est
connectée à plusieurs réseaux
   permettre dans le cas d’un serveur d’être accessible
   via ces différents réseaux
   Il suffit de remplir dans la structure sockaddr_in le
   champ sin_addr par la constante INADDR_ANY
                         Anas ABOU EL KALAM - CNAM
                                               24
Socket: Appel d’un numéro et
  établissement communication par le client
  Préciser les numéros du destinataire (serveur)

  Remplir une structure sockaddr_in avec numéros du destinataire

  Appeler la fonction d’établissement de communication qui

dépend du protocole (UDP ou TCP)

                        Anas ABOU EL KALAM - CNAM
                                              25
Cas client mode non connecté : établissement
      de la communication par le client
 Pas d’établissement de connexion préalable
    on envoie le premier paquet de donnée
 int sendto (int sock, char *data, int lg_data, struct sockaddr_in
 *p_ad_s, int flags, int lg_struct)
    Data: Les données tableau (ou chaîne) de caractères à envoyer
    Lg_data : leur longueur
    sockaddr_in : structure contenant les numéros du destinataires
    Flags : non utilisé , à mettre à 0
    Retour :
       Si erreur     ==> -1
       Sinon ==> le nombre d’octets

                       Anas ABOU EL KALAM - CNAM
                                             26
Cas serveur mode non-connecté : Attente
        d’appel sur un téléphone
Mettre en place la prise (socket) et lui affecter des numéros (bind)

Se tenir prêt à recevoir des coups de fil des clients
   Dans cas UDP, cela se manifeste par l’envoi d’un 1er paquet de donnée

int recvfrom (int sock, char *data, int lg_data, struct sockaddr_in
*p_ad_s, int flags, int lg_struct)
   Data: tableau (ou chaîne) de caractères reçu (rempli par la fonction)
   p_ad_s: structure remplie par recvfrom et qui contient les numéros du
   client qui vient d’envoyer ces données
   Retour :
  Si erreur ==> -1
  Sinon       ==> le nombre d’octets
                          Anas ABOU EL KALAM - CNAM
                                                27
Cas UDP : Un appel téléphonique
Le récepteur possède un buffer d’une taille fixe

Une fois le premier paquet émis

Le serveur peut aussi envoyer des données au client

                          Anas ABOU EL KALAM - CNAM
                                                28
Cas client TCP : établissement de la
         communication par le client
Il y a l’établissement d’une connexion préalable

les données seront envoyées ensuite

int connect (int sock, struct sockaddr_in *p_ad_s, int lg_struct)
   p_ad_s : structure contenant les numéros du destinataires
   Retour :
      Connexion réussie ==> 0
       Sinon       ==> -1

                      Anas ABOU EL KALAM - CNAM
                                            29
Cas serveur TCP : Attente d’appel sur un
              téléphone
Mettre en place la prise (socket) et lui affecter des numéros (bind)

Se tenir prêt à recevoir des coups de fil des clients

int listen (int sock, int nb_requete)
   sock: identificateur socket dont on a renseigné précédemment numéros
   nb_requete: nombre maximale de requête pouvant être mémorisé en
   attendant un traitement par le serveur

                          Anas ABOU EL KALAM - CNAM
                                                30
Cas serveur TCP : Acceptation d’un appel
            sur un téléphone
Le serveur peut accepter une demande de communication sur une socket
précédemment mise en attente (listen)
int accept ( int sock, struct sockaddr_in *p_ad_s, int lg_struct)
   sock : identificateur de la socket en attente
   p_ad_s: structure qui est remplie par recvfrom et qui contient les
   numéros du client qui vient d’envoyer ces données
      cette fonction est bloquante si il n’y a pas eu de demande de
      connexion de client
   ATTENTION: elle retourne un nouvel identificateur de socket mais
   portant les même numéros (port et adresse).
      C’est sur cette nouvelle socket que peuvent se faire les échanges

                         Anas ABOU EL KALAM - CNAM
                                               31
Cas TCP : Un appel téléphonique

         Anas ABOU EL KALAM - CNAM
                               32
Cas TCP : On parle dans le téléphone
Une fois la connexion établie le client peut envoyer et recevoir des
données, le serveur aussi (après l’accept)
int write ( int sock, char *data, int lg_data)
   Data: Le tableau (ou chaîne) de caractères reçu (rempli par la fonction)
   Lg_data : on précise la taille du tableau
   Retourne nombre d’octets effectivement envoyés, -1 s’il y a une erreur
int read ( int sock, char *data, int lg_data)
   Data: Le tableau (ou chaîne) de caractères à envoyer
   Lg_data : on précise la taille du tableau
   Retourne le nombre d’octets effectivement reçus, -1 s’il y a une erreur

                          Anas ABOU EL KALAM - CNAM
                                                33
Le problème de la langue
Données ne sont pas représentées de la même façon suivant processeurs
   ==> Il faut passer par un traducteur avant de les envoyer sur réseau
short int htons (short int x)
   retourne l’entier court (2 octets) à la norme réseau de x (passé en
   norme machine) ===> Home to Network
short int htonl (short int x)
   retourne l’entier long (4 octets) à la norme réseau de x
short int ntohs (short int x)
   Retourne l’entier court (2 octets) à la norme machine de x (passé en
   norme réseau) ===> Network to Host
short int ntohl (short int x)
   retourne l’entier long (4 octets) à la norme réseau de x

                        Anas ABOU EL KALAM - CNAM
                                              34
Cas de UDP et TCP : Fin communication
Il faut maintenant raccrocher le téléphone
int close ( int sock)
Retourne -1 si il y a une erreur
Fermeture complète, on ne peut plus envoyer ou recevoir de données
La connexion est complètement fermée et libérée une fois que le client et
le serveur on fait close
la fermeture est symétrique: client ou serveur peut commencer la
fermeture
int shutdown ( int sock, int sens)
On peut préciser sens fermeture==> connexion pas complètement fermée
   0 fermeture en entrée
   1 fermeture en sortie
   2 fermeture dans les deux sens: équivalent à un close
                         Anas ABOU EL KALAM - CNAM
                                               35
Retourne -1 si il y a une erreur, 0 sinon
Les options
On peut consulter/modifier des options sur des sockets allouées
Exemples
   Taille du buffer de réception, d’émission
   Définition de socket multicast
   Réception/émission de paquets broadcast
   Priorité
   ...
Fonction int getsockopt
   Consultation des options en cours
Fonction int setsockopt
   Modification des options

                        Anas ABOU EL KALAM - CNAM
                                              36
Approfondissement des paramètres
      de la primitive socket
 Paramètre Famille
        AF_UNIX   :    Communication locale (i-node)
        AF_INET   :    Communication Internet
        AF_ISO    :    Communication ISO
 ....
 Paramètre Type
        SOCK_STREAM : Flot d'octets en mode connecté
         (ne préserve pas les limites de l'enregistrement)
        SOCK_DGRAM : Datagramme en mode non connecté
         (préserve les limites de l'enregistrement)
        SOCK_RAW : Accès aux couches basses.
        SOCK_SEQPACKET : Format structuré ordonné
         (protocoles différents de l'Internet)
 Paramètre Type de protocole
  Valeur          Relation avec le paramètre type
     IPPROTO_TCP            SOCK_STREAM
     IPPROTO_UDP            SOCK_DGRAM
     IPPROTO_ICMP           SOCK_RAW
     IPPROTO_RAW            SOCK_RAW
                                Anas ABOU EL KALAM - CNAM
                                                      37
Primitive bind
  Primitive pour l'attribution d'une adresse de socket à un
  descripteur de socket.
  N’est pas réalisé lors de la création du descriptif (socket).
      Un serveur (qui accepte des connexions) doit définir sur quelle adresse.
      Un client (qui ouvre des connexions) n'est pas forcé de définir une
      adresse (qui est alors attribuée automatiquement).
  Profil d'appel de la primitive
#include 
#include 
int bind ( int s,
         struct sockaddr_in *mon_adresse,
         int longueur_mon_adresse )
  Trois paramètres d'appel
      Numéro du descriptif de Socket (s).
      Structure de donnée adresse de socket Pour internet type sockaddr_in.
                           Anas
      Longueur de la structure   ABOU EL KALAM - CNAM
                               d'adresse.                 38
Approfondissement
           concernant la primitive bind
    Descripteur d'adresse de socket          Un exemple d'exécution de "bind" pour les
                                             protocoles Internet.
#include 
                                         struct servent *sp
struct sockaddr_in {                     struct sockaddr_in sin
    short        sin_family;
    u_short            sin_port;         /* Pour connaître le numéro de port */
    struct in_addr     sin_addr;         if((sp=getservbyname(service,"tcp")==NULL)
                                         /* cas d'erreur */
    char         sin_zero[8]; };
                                         /* Remplissage de la structure sockaddr */
                                         /* htonl convertit dans le bon ordre */
                                         /* INADDR_ANY adresse IP du site local */
                                         sin.sin_family= AF_INET;
                                         sin.sin_port = sp -> s_port;
                                         sin.sin_addr.s_addr=htonl(INADDR_ANY):

                                         /* Création d'une socket internet */
                                         if ((s=socket(AF_INET,SOCK_STREAM,0))
Primitive listen

  Utilisé dans le mode connecté lorsque plusieurs
  clients sont susceptibles d'établir plusieurs
  connexions avec un serveur.
  Indique le nombre d'appel maximum attendu
  pour réserver l'espace nécessaire aux descriptifs des
  connexions.
  La primitive listen est immédiate (non bloquante).
  Profil d'appel : int listen (int s , int max_connexion)
s : Référence du descripteur de socket
max_connexion : Nombre maximum de connexions.
                     Anas ABOU EL KALAM - CNAM
                                           40
Primitive accept
   La primitive accept permet de se bloquer en attente d'une nouvelle
   demande de connexion (donc en mode connecté TCP).
   Après accept, la connexion est complète entre les deux processus.
   Le site qui émet accept exécute une ouverture passive.
   Pour chaque nouvelle connexion entrante la primitive fournit un
   pointeur sur un nouveau descriptif de socket qui est du même modèle que
   le descritif précédemment créé.
   Profil d'appel
#include 
#include 
int accept ( int ns,
         struct sockaddr_in *addr_cl,
         int lg_addr_cl)

ns      : Référence nouvelle socket
addr_cl : L'adresse du client.
lg_addr_cl: La longueur de l'adresse.
                               Anas ABOU EL KALAM - CNAM
                                                     41
Approfondissement concernant les
    primitives listen et accept
  Exemple de code UNIX : pour un serveur qui accepte des
  connexions successives et qui créé un processus pour traiter
  chaque client.
#include 
/* Adresse socket du client appelant */
struct sockaddr_in from;
quelen = ... ;
if (listen (s, quelen)
Primitive connect
   La primitive connect (bloquante) permet à un client de demander
   l'ouverture (active) de connexion à un serveur.
   L'adresse du serveur doit être fournie.
   La partie extrémité locale relative au client est renseignée
   automatiquement.
   Ensuite le client ne fournit plus l'adresse du serveur pour chaque
   appel mais le descriptif de la socket (qui contient l’adresses serveur).
   Profil d'appel
#include 
#include 
int connect ( int s,
         struct sockaddr_in *addr_serv,
         int lg_addr_serv)

s       : La référence de la socket
addr_serv    : L'adresse du serveur.
lg_addr_serv : La longueur de l'adresse.
                               Anas ABOU EL KALAM - CNAM
                                                     43
Primitives send, recv
   Les primitives send, recv (bloquantes) permettent
   l'échange effectif des données.
   Le profil d'appel est identique à celui des primitives
   read et write sur fichiers avec un quatrième paramètre pour
   préciser des options de communications.
   Profil d'appel
#include 
#include 
int send (int s, char *zone,
     int lg_zone, int options_com)
int recv (int s,char *zone,
     int lg_zone, int options_com)
s             : La référence de la socket
zone               : La zone à échanger.
lg_zone       : La longueur de la zone.
options_com        : Les options (données urgentes , ....)
                                Anas ABOU EL KALAM - CNAM
                                                      44
Primitives sendto, recvfrom
    Les primitives sendto, recvfrom permettent l'échange des données dans le mode
    non connecté UDP.
    On doit préciser l'adresse destinataire dans toutes les primitives sendto et
    l'adresse émetteur dans les recvfrom.
    Profil d'appel
#include 
#include 
int sendto (        int s,
      char *zone,
      int lg_zone,
      int options_com,
      struct sockaddr_in *addr_dest,
      int lg_addr)
int recvfrom (int s,
      char *zone,
      int lg_zone,
      int options_com,
      struct sockaddr_in *addr_emet,
      int *lg_addr)
addr_dest : L'adresse du destinataire.
addr_emet           : L'adresse de l'émetteur.
lg_addr      : La longueur de l'adresse.  Anas ABOU EL KALAM - CNAM
                                                                45
Primitives shutdown, close
Shutdown permet la terminaison des échanges sur
une socket suivi de la fermeture de la connexion :
   Profil d’appel : int shutdown(s , h); Pour la socket s.
   h = 0 : l’usager ne veut plus recevoir de données
   h = 1 : l’usager ne veut plus envoyer de données
   h = 2 : l’usager ne veut plus ni recevoir, ni envoyer.
Close : Permet la fermeture d'une connexion et la
destruction du descriptif.
   Profil d'appel
#include 
#include 
int close ( int s )
                      Anas ABOU EL KALAM - CNAM
                                            46
Résumé : Interface socket

Fonctionnement en       Fonctionnement en
TCP                     UDP
- Serveur.                socket
 socket                   recvfrom, sendto
 bind                     close
 listen
 accept
 recv, send
 close
- Client.
 socket
 connect
 recv, send
 close      Anas ABOU EL KALAM - CNAM
                                  47
En Travaux pratiques : Compilation et debugage

   client.c et serveur.c “prêt à l’emploi”
      Récupération des arguments passés au moment du lancement
         client 192.0.1.1 2200 udp
         serveur 2200 udp
   makefile pour compiler fon.c, fon.h avec client.c et serveur.c
   Commandes: make, make clean
   Mode debug possible (voir dans le makefile : -DDEBUG) pour
avoir des traces d’exécution à l’écran des primitives des sockets
   Pour tester votre client indépendamment du serveur, vous pouvez utiliser
   socklab pour dialoguer avec votre programme

                             Anas ABOU EL KALAM - CNAM
                                                   48
Cas TCP : Serveur à traitement itératif des clients

 demandes de connexion sont mémorisés par TCP en attente de traitement
 La socket passive est toujours à l’écoute
 Les connexions sont traitées les unes après les autres à travers la socket
 générée par la fonction accept

                          Anas ABOU EL KALAM - CNAM
                                                49
Cas UDP : Serveur à traitement itératif des clients

 les paquets reçus sont mémorisés dans un buffer en attente de réception
 Si le dialogue se résume à l’échange de deux paquets (question/ réponse),
    on traite successivement les demandes
 Si le dialogue est plus compliqué (dialogue à état)
    Il va y avoir mélange des demandes de comms et des échanges dans
    des communications “déjà établies”
    Il faut alors créer une nouvelle socket à la main (comme le fait l’accept)
    et continuer le dialogue sur cette nouvelle socket
    Cette socket est forcément sur un port différent
    Ce nouveau port doit donc être communiqué au client au moment de
    sa demande de communication

                          Anas ABOU EL KALAM - CNAM
                                                50
Cas UDP : Serveur à traitement itératif des clients
- Question/réponse

                  Anas ABOU EL KALAM - CNAM
                                        51
Vous pouvez aussi lire