1 SOCKETS

Document Sample
1 SOCKETS Powered By Docstoc
					IUT Paris 13                                                                  F. Butelle




                                                               TP SOCKETS
                                             Document principal et première série de questions.

TP SOCKETS .................................................................................................................................................................1
1         INTRODUCTION .....................................................................................................................................................1
2         FONCTIONS ESSENTIELLES.....................................................................................................................................1
    2.1       Services offerts .............................................................................................................................................1
    2.2       Mécanismes mis en oeuvre ...........................................................................................................................1
    2.3       Implémentation des sockets ..........................................................................................................................2
3         UTILISATION..........................................................................................................................................................2
    3.1       Principes d'utilisation en Java .....................................................................................................................2
    3.2       Algorithmes pour le client et le serveur : sockets en mode connecté ...........................................................3
    3.3       Implémentation des algorithmes Client/Serveur mode connecté .................................................................3
    3.4       Algorithme "client/serveur" en mode non connecté (mode datagramme) ....................................................3
    3.5       Implémentation en Java, mode non connecté...............................................................................................4
    3.6       Adressage .....................................................................................................................................................4
4         CARACTERISTIQUES DE FONCTIONNEMENT ...........................................................................................................4
    4.1       Attribution des numéros de ports .................................................................................................................4
    4.2       Lecture et écriture sur une socket en mode connecté ...................................................................................4
    4.3       Lecture et écriture sur une socket en mode datagramme .............................................................................5
TRAVAIL A FAIRE ET QUESTIONS ........................................................................................................................5
1         QUESTIONS PRELIMINAIRES ...................................................................................................................................5
2         PROGRAMMATION EN JAVA D’UN CLIENT / SERVEUR SIMPLE AU DESSUS D’UDP. ................................................6


1 Introduction
Nous présentons ici un mécanisme essentiel à la communication entre processus sous UNIX comme sous
d’autres systèmes d’exploitation : les sockets illustrés par la programmation en Java.
La version BSD 4.2 d’UNIX a été la première à inclure TCP/IP dans le noyau du système d’exploitation et à
proposer une interface de programmation de ces protocoles : les sockets.
Les sockets sont donc une API (Application Program Interface), c’est-à-dire une interface entre les
programmes d’applications et les couches dédiées à la gestion du réseau.

2 Fonctions essentielles

2.1 Services offerts
Le terme “ socket ” désigne à la fois une bibliothèque d’interface réseau et l’extrémité d’un canal de
communication (point de communication) par lequel un processus peut émettre ou recevoir des données.
Ce point de communication est représenté par une variable entière, similaire à un descripteur de fichier.
L’interface socket est un ensemble de primitives qui permettent de gérer l’échange de données entre
processus, que ces processus soient exécutés ou non sur la même machine.
La bibliothèque socket masque l’interface et les mécanismes de la couche transport : un appel socket se
traduit par plusieurs requêtes transport. Les sockets en mode connecté permettent d’accéder à un serveur
comme à un fichier.

2.2 Mécanismes mis en oeuvre
a) Modèle client / serveur
Les sockets permettent, entre autres, de construire des applications réparties selon le modèle client /
serveur :


                                                                                     1                                                                Ver. 29/11/2011
IUT Paris 13                                       F. Butelle




                                   Application                      Application
                                    CLIENT                          SERVEUR


                                   SOCKETS                          SOCKETS



                               Protocole Transport              Protocole Transport

                                Protocole Réseau                 Protocole Réseau

                              couches physiques et              couches physiques et
                               liaison de données                liaison de données

                              Figure 1 : Modèle client / serveur et sockets

b) Rangement dans des tampons
Un mécanisme de rangement dans des mémoires tampons est mis en oeuvre par les sockets TCP. Pour
chaque connexion, il existe un tampon d’émission (de 4 Ko à 16 Ko environ) et un tampon de réception. Si
on utilise les sockets au-dessus d’UDP, la taille d’un échange est aussi limitée de 2 Ko à 8 Ko selon les
systèmes.


                                 écriture socket                  lecture socket

                                    Tampon                            Tampon
                                    émission                         réception



                                      Figure 2 : Sockets et tampons
 La lecture sur la socket est bloquante tant qu’il n’y a rien à lire dans le tampon réception (si la socket
  est déclarée non bloquante, la lecture retourne une erreur). Dès leur réception, les données sont
  envoyées à l’application (même si le nombre d’octets reçu est inférieur au nombre d’octets demandé
  par l’application).
 L’écriture sur la socket est bloquante uniquement si le tampon en émission est plein (si la socket a
  été déclarée non bloquante, l’écriture retourne une erreur). Les octets rangés dans le tampon sont émis
  sur le réseau tant que le tampon n’est pas plein.


2.3 Implémentation des sockets
Dans la version BSD 4.3 d’UNIX, les sockets sont implémentées dans le noyau UNIX. Dans la version
System V Release 4, les sockets sont implémentées sous la forme d’une bibliothèque au-dessus de TLI
(Transport Level Interface). L’interface socket est ainsi conservée pour les applications existantes : les
mêmes primitives sont utilisées (ainsi que sous Windows). Divers langages ont repris du C, la gestion des
sockets, nous voyons ici les implémentations en Java.

3 Utilisation

3.1 Principes d'utilisation en Java
Un seul domaine existe en Java : l'architecture d'Internet. Il n'y a pas pour l'instant d'équivalence pour les
autres domaines (sockets UNIX etc). La distinction du type dans ce domaine se fait par la classe de
sockets : ServerSocket et Socket pour le mode connecté et DatagramSocket pour les sockets en mode
non conecté.


                                                       2                                     Ver. 29/11/2011
IUT Paris 13                                        F. Butelle



3.2 Algorithmes pour le client et le serveur : sockets en mode connecté
    CLIENT :
         Crée une socket
         Se connecte au serveur en donnant l’adresse socket distante (adresse Internet du serveur et
          numéro de port du service). Le système d'exploitation attribue pour cette connexion
          automatiquement un numéro de port local au client
         Lit et/ou écrit sur la socket
         Ferme la socket

    SERVEUR :
        Crée une socket
        Associe une adresse socket (adresse Internet et numéro de port) au service : “ binding ”
        Se met à l’écoute des connexions entrantes ;
        Pour chaque connexion entrante:
          Accepte la connexion (une nouvelle socket est créée avec les mêmes caractéristiques que la
            socket d’origine, ce qui permet de lancer un thread ou un processus fils pour gérer cette
            connexion).
          Lit et/ou écrit sur la nouvelle socket
          Ferme la nouvelle socket

3.3 Implémentation des algorithmes Client/Serveur mode connecté
                 CLIENT                                           SERVEUR "serv"
                                                                 ServerSocket(PORT)

           Socket(ip,PORT)                                                          Nouvelle socket et
                                                                     .accept()
                                                                                    éventuellement nouveau thread
                                                                                    ici...
                                                   in = new BufferedReader(
    in = new BufferedReader(...(                        new InputStreamReader(
         socket.getInputStream()))                          cxion.getInputStream()))
out = new PrintWriter(…(                       out = new PrintWriter(
     socket.getOutputStream()))                     new BufferedOutputStream(
                                                        cxion.getOutputStream()))

        out.println(…);out.flush()     Transfert                   in.readLine();
              in.readLine();           de                    out.println(…);out.flush()
                                       données
             socket.close()                                         cxion.close()



                               Figure 3 : exemple d'utilisation, mode connecté.


3.4 Algorithme "client/serveur" en mode non connecté (mode datagramme)
    CLIENT (émetteur) :
         Crée une socket
         Associe une adresse socket au service : “ binding ” (opération qui n’est nécessaire que si le
          Processus va recevoir des données)
         Lit et/ou écrit sur la socket

    SERVEUR (récepteur) :
        Crée une socket
        Associe une adresse socket au service : “ binding ” (opération nécessaire)
        Lit et/ou écrit sur la socket




                                                        3                                          Ver. 29/11/2011
IUT Paris 13                                       F. Butelle



3.5 Implémentation en Java, mode non connecté.
                 CLIENT                           SERVEUR

           DatagramSocket ()               DatagramSocket (port)

           DatagramPacket(..)                DatagramPacket (...)

                sock.send()
                                                sock.receive()
                                                                                   : appel pouvant être
                                             DatagramPacket (...)                  bloquant
                                                                                   : appel non bloquant
           DatagramPacket(..)
                                                 sock.send ()
               sock.receive()



                    Figure 4 : Utilisation courante des sockets en mode datagramme.


3.6 Adressage
Les problèmes d'adressage sont masqués en Java car il n'y a que le domaine AF_INET (Internet) de
considéré. L'adresse IP est fournie par le biais d'objets de la classe InetAddress dont on retiendra les
méthodes suivantes :
.getAddress() : retourne l'adresse IP sous forme de tableau de "byte".
.getLocalhost() : retourne un objet InetAddress contenant l'adresse IP de l'hôte (pas 127.0.0.1).
.getHostName() : retourne une chaîne de caractère : l'adresse symbolique de l'objet.
InetAddress.getByName(chaîne) : permet de récupérer l'adresse IP sous forme d'objet InetAddress
correspondant au nom symbolique donné en paramètre.

Enfin, cette classe dispose de la méthode .toString qui permet d'afficher un objet InetAddress sous la
forme nom symbolique/adresse IP.

4 Caractéristiques de fonctionnement

4.1 Attribution des numéros de ports
Les ports de numéro inférieur à 1024 sont réservés aux services standards.
Pour le serveur, le numéro de port est soit fixé dans le code du programme, soit lu dans le fichier
/etc/services (ou windows\services), soit attribué par le système par l'appel du constructeur.
Pour le client, le numéro de port est soit fixé dans le code, soit lu dans le fichier /etc/services, soit attribué
par le système si le paramètre ne figure pas dans le constructeur. Pour récupérer le numéro de port, on
dispose des méthodes getPort() ( ainsi que getLocalPort() en mode connecté).
Lorsque l’on fixe le numéro de port dans le code, il faut vérifier que ce numéro n’est pas déjà utilisé dans
/etc/services et ne fait pas non plus partie des numéros attribués dynamiquement aux serveurs RPC
(Remote Procedure Call) par la commande rpcinfo –p (ou rpc_dump , pas d'équivalent direct sous windows), ni
déjà utilisés par divers processus (netstat –an disponible aussi sous windows).


4.2 Lecture et écriture sur une socket en mode connecté
La lecture sur une socket en mode connecté en C présente la particularité suivante : la primitive revient
quand au moins un octet a été lu ; il en résulte que le nombre d'octets lus est bien souvent inférieur au
nombre d'octets demandés. Il faut alors boucler sur la primitive de lecture pour obtenir la suite...
En Java le problème est réglé par l'utilisation de classes de bufferisation de lecture/écrite (voir Figure 3 :
exemple d'utilisation, mode connecté.).



                                                       4                                         Ver. 29/11/2011
IUT Paris 13                                    F. Butelle



4.3 Lecture et écriture sur une socket en mode datagramme
En général les lectures sont bloquantes et les écritures sont non bloquantes dans ce mode. Il faut utiliser
les méthodes send() et receive().

Pour pouvoir faire une diffusion de message aucun paramétrage spécial n'est nécessaire à partir du jdk1.1.
L’adresse du serveur pour le client doit être une adresse de diffusion : “ 192.168.1.255 ” par exemple pour
diffuser sur toutes les stations du réseau de classe C 192.168.1.



                     Travail à faire et questions
                                                   Séance 1.
Problème : Nous voulons programmer (de préférence en Java sous Linux) un client et un serveur (via
Internet sur une machine distante), les échanges d’information auront lieu au dessus de UDP et pourront
être distantes. Le serveur fournira une application minimale : répondre en renvoyant la chaîne de
caractères qu’il a recu ainsi que l’adresse IP de l’émetteur.

          VOUS REPONDREZ AUX QUESTIONS SUIVANTES SUR UNE FEUILLE SEPAREE
                  AVEC VOS NOMS ET PRENOMS (TRINOMES INTERDITS).

           En première ligne de vos programmes, mettez en commentaire vos noms et prénoms
                            ainsi que l’objet du programme et ses paramètres.


1 Questions préliminaires

Question 1 : Quel est le mode de communication (connecté ou non) ?

Question 2 : Tapez      more /etc/services              — A quoi sert ce fichier ?

Question 3 : Tapez        more /etc/inetd.conf          — A quoi sert ce fichier ? Qu’en concluez vous
quand a l’utilisation des ports 7 et 13 ?

Question 4 : Quelle est l’adresse symbolique de votre machine (commande hostname) ?

Question 5 : Quelle l’adresse IP de votre machine ? Quelle est l’adresse MAC de sa carte Ethernet ?
Quelle est l'adresse de diffusion (commande /sbin/ifconfig )

Question 6 : Tapez       telnet hpiut2 13 ; puis telnet localhost 13 puis
telnet serveur 13 — Ensuite connectez vous sur le serveur de nom serveur par telnet serveur.
Consultez son fichier /etc/inetd.conf -- Comparez et Expliquez !

Question 7 : Tapez      telnet -e A votre-machine 7        puis un certain nombre de lignes, puis un A
seul en début de ligne. Essayez de même avec serveur et la machine de votre binôme voisin. Expliquez
le résultat.

Question 8 : Vos conclusion sur telnet <machinehote> <numero_de_port> a quoi cela sert-il ? — Quel
rapport avec notre problème ?




                                                    5                                      Ver. 29/11/2011
IUT Paris 13                                      F. Butelle




2 Programmation en Java d’un Client / Serveur simple au dessus d’UDP.
Documentation sur les classes java : ouvrez un netscape avec comme URL file:/logiciels/javadocs

Question 1 : Écrire un programme (affiche) qui affiche l’adresse Internet associée au nom de la
machine donnée en paramètre.
       Testez avec les paramètres suivants : localhost ; hpiut2 ; serveur ; r20504 ; 192.168.205.4

Question 2 : Programmer une classe ServiceUDP comportant les elements suivants :
       Attributs:
                private DatagramSocket socket;
                private InetAddress  adresseIP;
                private int          port;

        Constructeur pour le client :
               public ServiceUDP(String adresseDest,int portDest) throws IOException

        Constructeur pour le serveur :
               public ServiceUDP(int portEcoute) throws IOException

        Methodes :
              public void envoyer(String mesg) throws IOException
              public String recevoir() throws IOException
              public String getAdresse()

Notes : La classe TestClient est deja programmee et disponible dans
/home/users/TPGTR/Systeme2 (de meme ServiceUDP.class et TestClient.class sont fournis pour vos
tests)


Question 3 : Compilez TestClient et testez votre implémentation de ServiceUDP avec les exemples de
paramètres suivants : (les guillemets sont importants bien sûr!)
localhost 7 "ceci est un essai"
serveur 7 "autre essai"

de même avec la machine d'un binôme votre voisin et le port 13.

Question 4 : Écrire un programme udpserveur (utilisant la classe ServiceUDP) avec un paramètre : le
numéro de port sur lequel il doit se mettre à l’écoute. Il doit afficher l'adresse IP du client et lui répondre.
       Pour éviter les conflits sur les numéros de port, vous devez disposer d’un numéro de port différent
       de ceux déjà utilisés par le système. Prenez de préférence le numéro de port 20000. Vérifiez que
       ce port n’est pas déjà utilisé (lire le §4.1).

        Tester ce serveur avec votre client (dans deux fenêtres différentes). Puis avec la machine d'un
        binôme voisin.

Question 5 : Si d'autres binômes ont réussi à faire un serveur tenter une diffusion de message...
       N’oubliez pas que plusieurs serveurs peuvent répondre : il faut afficher qui répond et ne pas se
       contenter de la première réponse...

Question 6 : Modifier le serveur pour qu'il exécute les commandes du client. (voir la classe Runtime).
Faites des tests avec des commandes graphiques, par exemple xeyes !




                                                      6                                        Ver. 29/11/2011
IUT Paris 13                                     F. Butelle




          CORRECTION DES TPS SOCKETS
                   session1
1.Questions préliminaires
Question 1 : Quel est le mode de communication (connecté ou non) ?
       Puisque l’on veut utiliser UDP - ce ne peut être qu’en mode non connecté autrement dit
       datagramme. Donc la classe DatagramSocket.

Question 2 :. Tapez      more /etc/services                  — A quoi sert ce fichier ?
       Extrait du fichier /etc/services :

         tcpmux             1/tcp                        #    TCP port multiplexer (RFC 1078)
         echo               7/tcp                        #    Echo
         echo               7/udp                        #
         discard            9/tcp    sink null           #    Discard
         discard            9/udp    sink null           #
         systat            11/tcp    users               #    Active Users
         daytime           13/tcp                        #    Daytime
         daytime           13/udp                        #

        Il répertorie la liste des numéros de ports standards (universellement reconnus) qui sont associés à
        un service précis. On remarque entre-autres le port 7 est destiné à faire un écho des chaînes qui
        lui sont envoyées et le port 13 est destiné à donner l’heure. Tous les deux fonctionnent à la fois
        avec TCP et UDP.

Question 3 : Tapez        more /etc/inetd.conf            — A quoi sert ce fichier ? Qu’en concluez vous
quand a l’utilisation des ports 7 et 13 ?
       Extrait du fichier /etc/inetd.conf d'une machine rxxx

         #       inetd internal services
         #
         ##
         echo        stream tcp nowait root internal
         #echo       dgram udp nowait root internal
         daytime     stream tcp nowait root internal
         daytime     dgram udp nowait root internal

        Il liste les programmes serveurs gérés par inetd, lancés lorsque tel ou tel numéro de port est
        demandé avec TCP ou UDP (la distinction est importante). Les etudiants doivent remarquer que la
        ligne echo en mode udp est en commentaire... donc qu’il n’y a pas de serveur en ecoute sur le port
        7 de udp...il verifieront avec leur client ou le client fourni.

Question 4 : Quelle est l’adresse symbolique de votre machine (commande hostname) ?
Quelle l’adresse IP de votre machine ? Quelle est l’adresse MAC de sa carte Ethernet ? Quelle est
l'adresse de diffusion (commande /sbin/ifconfig )
Tapez telnet hpiut2 13 ; puis telnet localhost 13 puis
telnet serveur 13 — Ensuite connectez vous sur le serveur de nom serveur par telnet serveur.
Consultez son fichier /etc/inetd.conf -- Comparez et Expliquez
        On a vu grace à la question précédente que leur machine n’avait pas de serveur en ecoute sur le
        port 13 TCP/ alors que serveur en a un... qui donne son heure correctement.

Question 7 : Tapez       telnet -e A votre-machine 7             puis un certain nombre de lignes, puis un
A seul en début de ligne. Essayez de même avec serveur et la machine de votre binôme voisin. Expliquez
le résultat.
         Le port 7 est dédié à l’echo des chaines qui lui sont envoyées. lili et hpiut2 ont tous les deux des
         serveurs qui écoute ce port en TCP.


                                                     7                                       Ver. 29/11/2011
IUT Paris 13                                  F. Butelle



Question 8 : Vos conclusion sur telnet <machinehote> <numero_de_port> a quoi cela sert-il ? — Quel
rapport avec notre problème ?
        telnet est un client TCP. Pas UDP. Notre pb est de faire un client UDP. puis un serveur UDP.
1Question 4 : Quelle est l’adresse symbolique de votre machine (commande hostname) ?
        Taper hostname ! ! c’est quelque chose comme R20504 (R<numerosalle><numerode machine>
1Question 5 : Quelle l’adresse IP de votre machine ? Quelle est l’adresse MAC de sa carte Ethernet ?
Quelle est l'adresse de diffusion (commande /sbin/ifconfig )
        Logiquement l’adresse IP doit être de type 192.168.<numerosalle>.<numero de machine>
        L’adresse MAC est sous forme de 6 octets en Hexa.

2. Programmation en C d’un Client / Serveur simple au dessus d’UDP.
Question 1 : Écrire un programme (affiche) qui affiche l’adresse Internet associée au nom de la machine
donnée en paramètre.
       System.out.println(adresse) ou adresse est un objet InetAddress…

                                         “ ServiceUDP.java ”

import java.net.*;
import java.io.*;

public class ServiceUDP {
      private DatagramSocket socket;
      private InetAddress adresseIP;
      private int port;

       public ServiceUDP(int portEcoute) throws IOException{
             port= portEcoute;
             socket = new DatagramSocket(port); // port local specifique
       }

       public ServiceUDP(String adresseDest,int portDest) throws IOException{
             port = portDest;
             adresseIP = InetAddress.getByName(adresseDest);
             socket = new DatagramSocket(); // port local fixe par le systeme.
       }

       public void envoyer(String mesg) throws IOException {
             DatagramPacket packet=new
                   DatagramPacket(mesg.getBytes(),mesg.length(),adresseIP,port);
             socket.send(packet);
       }

      public String recevoir() throws IOException {
            byte buffer[]=new byte[8192]; /* c'est souvent le max accepté par le
système */
            String message;
            DatagramPacket packet = new DatagramPacket(buffer,buffer.length);
            System.out.println("attente message");
            socket.receive(packet);
            message = new String(buffer).trim();
            port = packet.getPort();
            adresseIP = packet.getAddress();
            return(message);
      }

      public String getAdresse() {
            return (adresseIP.toString());
      }
}//fin de la classe




                                                  8                                     Ver. 29/11/2011
IUT Paris 13                       F. Butelle



                               testServeur.java

import java.io.*;
public class TestServeur {
      public static void main(String[] args){
      //vérifie les arguments de la ligne de commande pour l'adresse hôte
            if (args.length !=1){
                  System.out.println("usage : java TestServeur <portecoute>");
                  System.exit(0);
            }
      try {
            ServiceUDP client = new ServiceUDP(Integer.parseInt(args[0]));
            System.out.println("question:"+client.recevoir());
            client.envoyer("OK !"+client.getAdresse());
            String mesgrecu= client.recevoir();
            System.out.println("question:"+ mesgrecu);
            // Runtime.getRuntime().exec(mesgrecu.trim()));
            client.envoyer("OK !"+client.getAdresse());
      }
      catch(IOException e) {
            e.printStackTrace();}
      } // end main
}




                                       9                           Ver. 29/11/2011

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:6
posted:11/30/2011
language:French
pages:9