ftp-mini

							2008 / 2009                                                     Abd-Errazzak BELLA




    RAPPORT DE PROJET :
         MINI FTP




                                                    Enseignant : Nadjib ACHIR

Licence Informatique Appliquée | Rapport de projet : Mini FTP               1/5
2008 / 2009                                                                 Abd-Errazzak BELLA




 Objectif du Projet :

         Le but du projet est de réaliser un client (miniftp) et un serveur (miniftpd)) de
 transfert de fichiers à distance. Afin de réaliser celui ci nous utiliseront la couche de
 transport fiable TCP. Pour transférer un fichier, un client établit une connection avec un
 serveur préalablement exécuté sur la machine distante contactée. A la suite de ce premier
 contact, le client attend l'accusé de réception qui lui permettra d'enclencher la procédure
 adéquate à la réception du fichier. La connection est alors fermée à l'issue du transfert du
 fichier, ce qui permet ainsi une seule requête par connection.

        Dans le rapport qui suit, je me propose de vous expliquer la programmation du Mini
 FTP utilisée dans la construction des modèles client, et serveur. Dans un premier temps
 sera étudiée la partie cliente, et dans un second temps la partie serveur. Puis pour finir,
 quelques remarques seront données sur le projet mené.


 1 La Partie Cliente

       Le client dispose de 4 requêtes pour communiquer avec le serveur. Et celles ci
 doivent suivre un formatage strict afin que le serveur puisse exécuter ces dernières.
 L'usage du client FTP est donc le suivant :

    ●   hostname dir pathname : liste le contenu du répertoire pathname sur hostname
    ●   hostname del distfilename : suppression du fichier distfilename sur le serveur
    ●   hostname get distfilename localfilename : récupération du fichier distfilename
        situé sur la machine hôte du serveur (hostname) et enregistrement de ce fichier sur
        la machine hôte du client sous le nom localfilename.
    ●   hostname put localfilename distfilename : envoi du fichier localfilename sur la
        machine hôte du serveur.

       Avant de transmettre la requête au serveur, celle ci est identifiée par le client, afin
 de préparer (si la requête est conforme) le traitement correspondant à la requête.

 a. Établissement d'un connection

        Pour commencer on renseigne les informations concernant la machine hôte du
 serveur à disposition du client (famille internet AF_INET, ainsi que l'ip du serveur et le port
 d'écoute du serveur convertis au format réseau).
 On créé ensuite une socket client avec l'appel de fonction socket(AF_INET,
 SOCK_STREAM, IPPROTO_TCP) Si cette appel fonctionne, la valeur de retour est
 différente de -1 (sinon on quitte alors le programme) et on récupère la valeur dans la

Licence Informatique Appliquée | Rapport de projet : Mini FTP                                2/5
2008 / 2009                                                                 Abd-Errazzak BELLA


 variable sock.
 Et c'est alors que grâce à la fonction connect(sock, (struct sockaddr*)&serveur,
 serveur_len) on tente d'établir une connection. Si celle ci retourne un entier négatif, alors
 la tentative de connection a échoué, et on sort du programme.
 On récupère le nom de la socket utilisée pour la connection avec : getsockname(sock,
 (struct sockaddr*)&moi, &moi_len) ;

         Le client est clairement connecté au serveur, et une communication est possible.

 b. Traitement des requêtes


           La connection établie, le client envoi au serveur sa requête, que ce dernier renvoi
 s'il l'a reçu correctement, et commence la phase de traitement. Celle ci se caractérisant
 par un appel de fonction correspondant à la requête exécutée.


     1. Syntaxe d'une requête :
              A l'aide de la procédure formule_requete (char ** ligne, int nb_arguments,
              char buf_write[1<<8]), le client décortique la requête générale entrée au
              lancement du programme (concrètement un ./miniftp hostname port dir) où seul
              une partie des informations est utile au serveur.
     2. Traitements :
              La requête envoyé, et une confirmation du serveur reçue par le client, celui-ci
              peut connaissant la requête appeler la fonction correspondant au traitement
              approprié à la requête.(elles prennent tout un argument au minimum, la socket
              connectée au serveur)
         1.
     ●   DEL: La requete dir permettant de détruire un fichier présent sur le serveur, elle ne
         nécessite aucune action de la part du client une fois l'instruction donnée. La bonne
         marche de celle-ci ne dépend que du serveur.
     ●   DIR: Le client se met à l'écoute des données textuelles à recevoir, et les affiche à
         l'écran au fur et à mesure de leur réception à l'aide de la procédure
         command_dir(int sock_pipe)
     ●   GET: La procédure command_get(int sock_pipe, char * local), ouvre un nouveau
         fichier en écriture (dont le nom est contenu dans la variable local). Cette création
         est suivie de l'écoute de la socket sock_pipe (préalablement connectée) tant qu'il y
         a du contenu reçu à travers de la socket. Ce contenu reçu sous la forme d'un buffer
         est réécrit au fur et à mesure sur le fichier précédemment ouvert, jusqu'à en
         récupérer tout le contenu.
     ●   PUT: C'est au travers de la procédure command_put(int sock_pipe, char * local),
         qu'un fichier local existant (dont le nom est contenu dans la variable local) est


Licence Informatique Appliquée | Rapport de projet : Mini FTP                               3/5
2008 / 2009                                                                 Abd-Errazzak BELLA


         ouvert en lecture, et son contenu est passé dans un buffer (donc partie par partie)
         et envoyé au fur et à mesure de son remplissage, via la socket connectée
         sock_pipe.

 2 La Partie Serveur

       Une fois exécuté de façon correcte, le serveur se met à l'écoute d'un port spécifié
 en argument lors de son lancement. Ceci afin de répondre aux demandes de connection
 reçus sur ce port, et effectué les requêtes demandés une que fois cette première
 (connection) réalisée.

 a. Mise à l'écoute du serveur
         Une socket d'écoute est créée, de la même façon que sur le client grâce à la
 fonction socket(AF_INET, SOCK_STREAM, IPPROTO_TCP). Celle ci est alors associée
 à l'extrémité local définie/renseignée dans la structure de type sockaddr_in que l'on a
 nommé serveur.
         L'appel de fonction listen(sock, MAX_USERS) permet alors au serveur d'indiquer
 qu'il peut accepter les connections.
 Mais ce n'est qu'à l'appel de la fonction sock_pipe = accept ( sock, (struct sockaddr
 *)&client, &client_len ), prenant en paramètre l'identificateur de la socket d'écoute sock
 et la structure contenant l'adresse de l'extrémité correspondant au client. En cas d'erreur
 elle renvoie -1, autrement c'est le descripteur de socket de service qui est renvoyé et
 récupéré dans la variable sock_pipe.

 b. Traitement des requêtes


        L'appel de procédure traitement_req(sock_pipe, buf_read), fait appel à deux
 sous fonction. formule_requete(requete) qui retourne la commande lue dans le buffer
 buf_read sous la forme d'une structure de type requete_recu.
 Et traitement = cmd_to_int (req.cmd) qui permet de dissocier la commande à effectuer,
 et lancer le traitement correspondant grâce à un switch(traitement).


     ●   DEL : La procédure commande_del(req) effectue la suppression d'un fichier dont
         le nom est spécifié dans la structure req.
         Il se distingue 2 phases dans cette procédure : la création d'un processus fils, et
         l'exécution au sein du processus créé de la procédure execlp("rm", "rm",
         filename, NULL) dont l'appel clôt le programme (d'où la nécessité du fork)
     ●   DIR : La procédure commande_dir(sock_pipe, req) appelée liste les fichiers d'un


Licence Informatique Appliquée | Rapport de projet : Mini FTP                                  4/5
2008 / 2009                                                                  Abd-Errazzak BELLA


         répertoire présent sur la machine hôte du serveur.
         3 phases sont nécessaires : la création d'un tube de communication, la redirection
         du listing réalisé avec execlp("ls", "ls", NULL) et enfin l'envoi du résultat via la
         socket connectée sock_pipe.
     ●   GET : Cette commande déclenche l'appel command_get(int sock_pipe,
         requete_recu getrequete) qui lit et remplit un buffer, puis transmet le contenu à
         travers sock_pipe, et ainsi de suite jusqu'à ce qu'il n'y ait plus rien à lire sur le
         fichier à transmettre.
     ●   PUT : Grâce à la procédure command_put(int sock_pipe, requete_recu
         putrequete), le traitement contraire à GET est réalisé ce qui permet la
         récupération du fichier envoyé par le client via sock_pipe.



 Complément et Remarques Personnelles
     ●   Pour des raisons de lisibilité et de lecture, j'ai choisi de créer un certain nombre de
         variables plus « parlantes ». Celles-ci ne sont pas nécessaire au bon
         fonctionnement des deux programmes. Toute fois, elles permettent une lecture plus
         aisée du code.
     ●   Ce rapport ne fait pas part de tous les tests présents, et effectués, ceux-ci sont
         nombreux et nécessaire du fait la grande possibilité d'erreurs que constitue
         l'utilisation des socket c.
     ●   Avec un peu plus de temps, il aurait été possible de réaliser un projet qui me
         satisfasse plus. Néanmoins celui-ci est loin de ne m'avoir apporté de l'expérience.




Licence Informatique Appliquée | Rapport de projet : Mini FTP                                    5/5