Fin du projet. Serveur Fonctionnel

bal.h

@@ -1,71 +1,660 @@
-//
-// Created by Béranger Quintana | 3AE E
-//
-
-#ifndef PROGC_BAL_H
-#define PROGC_BAL_H
-//---------------------------------------------------
-//---------------Structure Liste---------------------
-//---------------------------------------------------
-
-typedef struct BAL
-{
-    int num_bal ;
-    struct LETTRE* lfirst ;
-    struct LETTRE* lcurrent ;
-    struct LETTRE* llast ;
-    struct BAL* suiv ;
-}BAL;
-
-typedef struct LETTRE
-{
-    int  num;
-    char* message ;
-    struct LETTRE* suiv ;
-};
-
-typedef struct LISTE {
-    struct BAL * bal_premier ;
-    struct BAL * bal_dernier ;
-    struct BAL * bal_courant ;
-}LISTE_BAL;
-//---------------------------------------------------
-//              GESTION BAL
-
-LISTE_BAL* initialiser_bal(){
-
-    LISTE_BAL liste ;
-    liste = (LISTE_BAL)malloc(sizeof(struct LISTE));
-    liste->bal_premier = NULL;
-    liste->bal_dernier = NULL;
-    liste->bal_courant = NULL;
-    return liste ;
-}
-
-void ajouter_bal(int num, LISTE_BAL * liste){
-
-    BAL ma_bal = (BAL)malloc(sizeof(struct BAL));
-    ma_bal->num_bal = num ;
-    ma_bal->l_premier=NULL;
-    ma_bal->l_dernier=NULL;
-    ma_bal->l_courant=NULL;
-    ma_bal->bal_suiv = NULL;
-
-
-    if (liste == NULL)
-    {
-        liste->bal_premier = ma_bal ;
-        liste->bal_dernier = ma_bal ;
-    }
-    else {
-        liste->bal_dernier->bal_suiv = ma_bal ;
-        liste->bal_dernier = ma_bal ;
-    }
-    liste->bal_courant = ma_bal ;
-}
-
-
-LISTE_BAL*
-
-
-#endif //PROGC_BAL_H
+//--------------------------PROG C ET RESEAUX-----------------------
+//                          Nom :    Quintana
+//                          Prénom : Béranger
+//                             Grp : 3AE E
+//------------------------------------------------------------------
+
+#ifndef __tsock__
+//Variable qui donne la longueur max d'un message
+int maxsize=9999;
+//Définitions des types
+
+typedef struct BAL 
+{
+    int num ;
+    int nb;
+    struct LETTRE * l_first ;
+    struct LETTRE * l_last ;
+    struct LETTRE * l_current ;
+    struct BAL * suiv ;
+}BAL ;
+
+typedef struct LETTRE 
+{
+    int num ;
+    int lg;
+    char *message ;
+    struct LETTRE * suiv ;
+}LETTRE ;
+
+typedef struct LISTE_BAL
+{
+    struct BAL * first ;
+    struct BAL * last ;
+    struct BAL * current ;
+    int nb;
+}LISTE_BAL;
+
+//---------------------------------------------------
+//---------Déclaration des fonctions-----------------
+//---------------------------------------------------
+
+LISTE_BAL* init_BAL();
+void add_BAL(int num , LISTE_BAL* liste);
+BAL* find_BAL(LISTE_BAL*liste, int num);
+int find_BALR(LISTE_BAL*liste, int num);
+void add_LETTRE (int n, int lg, BAL* bal , char* mess);
+void printBAL(BAL* bal,int lg);
+void empty(BAL*bal);
+void EBAL(int port, char* dest, int nb_message, int lg_msg, int nBAL);
+void SBAL(int port, char* dest);
+void RBAL(int port, char* dest, int nBAL);
+
+//---------------------------------------------------
+//--------------------GESTION BAL--------------------
+//---------------------------------------------------
+
+LISTE_BAL* init_BAL()
+{
+    LISTE_BAL* liste =(LISTE_BAL*)malloc(sizeof(struct LISTE_BAL));
+    liste->first = NULL;
+    liste->last=NULL;
+    liste->current = NULL;
+    liste->nb=0;
+    return liste ;
+}
+
+//------------------------------------------------
+//----Afficher le contenu d'une Liste de BAL------
+//6-----------------------------------------------
+void printLISTE(struct LISTE_BAL* liste)
+{
+    printf("              __________________________________________\n");
+    printf("                Check général des BAL de notre liste :\n\n");
+    printf("                        %d BAL dans notre liste       \n\n",liste->nb);
+    liste->current=liste->first;
+    while (liste->current!=NULL)
+    {
+    printf("                        BAL n°%d : %d Lettres          \n",liste->current->num,liste->current->nb);
+        liste->current=liste->current->suiv;
+    }
+    printf("              __________________________________________\n\n");
+
+}
+
+//------------------------------------------------
+//--------Afficher le contenu d'une BAL-----------
+//------------------------------------------------
+void printBAL(BAL* bal,int lg)
+{
+    printf("Contenu de la BAL n°%d qui contient %d lettres \n",bal->num,bal->nb) ;
+    bal->l_current=bal->l_first;
+    printf("\n");
+    int n=1;
+    while(bal->l_current!=NULL)
+    {
+        printf("BAL n°%d | %d Lettres, lettre n°%d : [",bal->num,bal->nb,n);
+        afficher_message(bal->l_current->message,lg);
+        bal->l_current=bal->l_current->suiv;
+        n++;
+    }
+    printf("\n\n");
+
+}
+//------------------------------------------------
+//----------------Ajouter une BAL-----------------
+//------------------------------------------------
+
+void add_BAL(int n, LISTE_BAL * liste)
+{
+    BAL *nouv =malloc(sizeof(struct BAL));
+    nouv->num=n;
+    nouv->nb=0;
+    nouv->l_first=NULL;
+    nouv->l_last=NULL;
+    nouv->l_current=NULL;
+    nouv->suiv=NULL;
+
+    if (liste->first == NULL)
+    {
+        liste->first = nouv ;
+        liste->last = nouv ;
+    }
+    else
+    {
+        liste->last->suiv= nouv ;
+        liste->last=nouv ;
+    }
+    liste->nb++;
+}
+
+//------------------------------------------------
+//----Retourne une BAL en fonction de son num-----
+//6-----------------------------------------------
+
+BAL* find_BAL(LISTE_BAL*liste, int num)
+{
+    BAL* bal=malloc(sizeof(struct BAL));
+    liste->current=liste->first;
+    if (liste->first==NULL)
+    {
+        add_BAL(num,liste);
+        bal=liste->first;
+    }
+    else
+    {
+        liste->current=liste->first;
+
+        if (liste->first==liste->last)
+        {
+            if (liste->first->num==num)
+                bal=liste->current;
+            else
+            {
+                add_BAL(num,liste);
+                bal=liste->last;
+            }
+        }
+        else if (liste->first->num==num)
+            bal=liste->first;
+        else
+        {
+            int var=0;
+            while(var==0)
+            {
+                if (liste->current->suiv==NULL)
+                    var=-1;
+                else
+                {
+                    liste->current=liste->current->suiv;
+                    if (liste->current->num==num)
+                        var=1;
+                    if (liste->current==NULL)
+                        var=-1;
+                }
+
+            }
+            if (var==1)
+                bal=liste->current;
+            else
+            {
+                add_BAL(num,liste);
+                bal=liste->last;
+            }
+        }
+    }
+    return bal;
+}
+
+//--------------------------------------------------------------------------------------------
+//----------------------------------------findBALR--------------------------------------------
+//-------Retourne -1 si BAL inexistante ou BAL Vide, lg 1ère lettre si BAL existante----------
+//--------------------------------------------------------------------------------------------
+int find_BALR(LISTE_BAL*liste, int num)
+{
+    int ret;
+    if (liste->first==NULL)
+    {
+        ret=-1;
+    }
+    else
+    {
+        liste->current=liste->first;
+        if (liste->current==liste->last)
+        {
+            if (liste->current->num==num)
+            {
+                if (liste->current->l_first==NULL)
+                    ret=-1;
+                else
+                    ret=liste->current->l_first->lg;
+            }
+            else
+                ret=-1;
+        }
+        else if (liste->first->num==num)
+        {
+            if (liste->current->l_first==NULL)
+                ret=-1;
+
+            else
+                ret=liste->current->l_first->lg;
+        }
+        else
+        {
+            int var=0;
+            while(var==0)
+            {
+                if (liste->current->suiv==NULL)
+                    var=-1;
+                else
+                {
+                    liste->current=liste->current->suiv;
+                    if (liste->current->num==num)
+                        var=1;
+                    if (liste->current==NULL)
+                        var=-1;
+                }
+
+            }
+            if (var==1)
+            {
+                if (liste->current->l_first==NULL)
+                    ret=-1;
+                else
+                    ret=liste->current->l_first->lg;
+            }
+            else
+                ret=-1;
+        }
+
+    }
+    return ret;
+}
+
+//-----------------------------------------------------------------
+//----------------Ajouter une lettre en fin de BAL-----------------
+//-----------------------------------------------------------------
+
+void add_LETTRE (int n, int lg, BAL* bal , char* mess)
+{
+    bal->nb=(bal->nb)+1;
+	LETTRE* nouv;
+	nouv=(LETTRE*)malloc(sizeof(LETTRE));
+	nouv->num=n+1;
+	nouv->lg=lg;
+	nouv->suiv=NULL;
+
+	if (bal->l_first==NULL)
+	{
+        bal->l_first=nouv;
+        bal->l_last=nouv;
+        bal->l_current=nouv;
+    }
+
+	else
+    {
+	    bal->l_last->suiv=nouv;
+        bal->l_last=bal->l_last->suiv;
+    }
+
+    nouv->message=malloc(lg* sizeof(char));
+    for (int i=0 ; i<lg ; i++)
+        nouv->message[i] = mess[i];
+}
+
+//-------------------------------------------------------------------------------------
+//----------------Détruit une liste de BAL en fin d'utilisation de BAL-----------------
+//6------------------------------------------------------------------------------------
+
+void empty(BAL*bal)
+{
+    bal->l_current=bal->l_first;
+    while(bal->l_current!=NULL)
+    {
+        bal->l_current=bal->l_current->suiv;
+        free(bal->l_first);
+        bal->l_first=bal->l_current;
+        (bal->nb)--;
+    }
+}
+void EBAL(int port, char* dest, int nb_message, int lg_msg, int nBAL)
+{
+    //Déclarations
+    int sock;
+    struct sockaddr_in addr_distant ;
+    int lg_addr_distant=sizeof(addr_distant);
+    struct hostent *hp;
+    char motif;
+    char * message=malloc(lg_msg*sizeof(char));
+    int envoi=-1;
+    int lg_pdu=50;
+    int lg_recv;
+    char*pdu=malloc(lg_pdu*sizeof(char));
+
+//---------------------------------------
+//--------Etablissement connexion--------
+//---------------------------------------
+    printf("            SOURCE : Emission de lettres pour la BAL n°%d\n",nBAL);
+    printf("____________________________________________________________________\n\n");
+
+    sprintf(pdu,"0 %d %d %d",nBAL, nb_message,lg_msg);
+
+    //Création socket
+    if((sock=socket(AF_INET,SOCK_STREAM,0))==-1)
+    {
+        printf("Erreur à l'ouverture du Socket Stream");
+        exit(1);
+    }
+    //Construction adresse socket distant
+    memset((char*)&addr_distant,0,sizeof(addr_distant));
+    addr_distant.sin_family=AF_INET;  //Internet
+    addr_distant.sin_port=port;       //Numéro de Port
+
+    //Affectation IP
+    if((hp=gethostbyname(dest))==NULL)
+    {
+        printf("Erreur de requête IP.\n");
+        exit(1);
+    }
+
+    memcpy((char*)&(addr_distant.sin_addr.s_addr), hp->h_addr , hp->h_length);
+
+    //Demande de connexion
+
+    if (connect(sock,(struct sockaddr *)&addr_distant,sizeof(addr_distant))==-1)
+    {
+        printf("Erreur lors de la connexion, en attente de la tentative suivante \n");
+        exit(1);
+    }
+//-----------------------------------------
+//----------------Envoi PDU----------------
+//-----------------------------------------
+
+    if ((envoi=write(sock,pdu,lg_pdu))==-1)
+    {
+        printf("Echec de l'envoi du PDU Emetteur (fonction write en défaut)\n");
+        exit(1);
+    }
+    //-----------------------------------------
+//----------TRANSFERT DE DONNEES-----------
+//-----------------------------------------
+
+
+
+    for (int i=1; i<=nb_message;i++)
+    {
+        printf("SOURCE : lettre n°%d (%d) [", i,lg_msg);
+
+        //Création du message
+        construire_message2(message,motif,lg_msg,i);
+        printbuffer2(nBAL,message);
+        afficher_message(message,lg_msg);
+
+        //Envoi du message
+
+        if ((envoi=write(sock,message,(lg_msg)/*,0,(struct sockaddr*)&addr_distant,lg_addr_distant)*/))==-1)
+        {
+            printf("Echec de l'envoi du message (fonction write en défaut)\n");
+            exit(1);
+        }
+
+    }
+
+
+
+    //Fermeture connexion
+
+    if(shutdown(sock,2)==-1)
+    {
+        printf("Erreur à la fermeture de la connexion TCP \n");
+        exit(1);
+    }
+
+    //Fermeture Socket
+    if (close(sock)==-1)
+    {
+        printf("Echec de la fermeture du socket distant");
+        exit(1);
+    }
+
+    free(message);
+    free(pdu);
+    printf("Envoi effectué avec succès\n");
+}
+
+void SBAL(int port, char*dest)
+{
+    //Déclarations
+    int sock , sock2; //sock bis local orienté échanges
+    struct sockaddr* addr_distant;
+    struct sockaddr_in addr_local;
+    int lg_addr_distant=sizeof(addr_distant);
+    int lg_addr_local=sizeof(addr_local);
+    struct hostent *hp;
+    char motif;
+    char *message;
+    int lg_recv=-1;
+    int lg_sent=-1;
+    int lg_pdu=50;
+    int type=-1;
+    int nb;
+    int lg;
+    int n=1;
+    int nBAL;
+    BAL*bal=malloc(sizeof(struct BAL));
+    char *pdu;//=malloc(sizeof(char));
+    LISTE_BAL* liste;
+//----------------------------------
+//------------Connexion ------------
+//----------------------------------
+
+    //Création socket local
+    if ((sock=socket(AF_INET,SOCK_STREAM,0))==-1)
+    {
+        printf("Echec de la création d'un socket local\n");
+        exit(1);
+    }
+    //Construction adresse socket local | Affectation port et domaine
+    memset((char*)&addr_local, 0 , sizeof(addr_local));
+    addr_local.sin_family=AF_INET;
+    addr_local.sin_addr.s_addr=INADDR_ANY;
+    addr_local.sin_port=port;
+
+    //Bind
+    if (bind(sock,(struct sockaddr *)&addr_local, lg_addr_local)==-1)
+    {
+        printf("Echec du bind.\n");
+        exit(1);
+    }
+    //Check connexions entrantes
+    if (listen(sock,100)<0)
+    {
+        printf("Trop de connexions en attentes, échec de la demande\n");
+        exit(1);
+    }
+    liste=init_BAL();
+    while (1)
+    {
+        if ((sock2=accept(sock,(struct sockaddr*)&addr_distant,&lg_addr_distant))==-1)
+        {
+            printf("Refus de connexion par le serveur\n");
+            exit(1);
+        }
+
+        pdu=malloc(50*sizeof(char));
+        if((lg_pdu=read(sock2,pdu, lg_pdu))<0)
+        {
+            printf("Echec de lecture du PDU entrant\n");
+            exit(1);
+        }
+        sscanf(pdu, "%d %d %d %d", &type, &nBAL, &nb, &lg);
+        //GESTION EMETTEUR
+        if (atoi(pdu)==0)
+        {
+            printf("        ||||||| Réception des lettres pour la BAL n°%d |||||\n\n",nBAL);
+            message=malloc(lg*sizeof(char));
+            int n=0;
+            sscanf(pdu, "%d %d %d %d", &type, &nBAL, &nb, &lg);
+            bal=find_BAL(liste,nBAL);
+
+            while (n!=nb)
+            {
+                message = malloc(lg* sizeof(char));
+                if ((lg_recv = read(sock2, message, lg)) == -1)
+                {
+                    printf("Erreur de lecture\n");
+                    exit(1);
+                }
+                if (lg_recv>0)
+                {
+                    add_LETTRE(n,lg, bal,message);
+                }
+                n++;
+            }
+
+            printBAL(bal,lg);
+        }
+        //GESTION RECEPTEUR
+        else if (atoi(pdu)==1)
+        {
+            sscanf(pdu, "%d %d", &type, &nBAL);
+            printf("        ||||||| Restitution des lettres de la BAL n°%d |||||||\n\n",nBAL);
+            lg=find_BALR(liste,nBAL);
+            if (lg==-1) // Gestion du cas ou la BAL est vide, on envoie un PDU qui sera analysé par le récepteur.
+            {
+                printf("        BAL inexistante, PDU=0 pour informer le récepteur\n\n");
+                sprintf(pdu,"%d %d",lg,nb);
+                //printf ("PDU à envoyer : %d\n",lg);
+                int lg_sent=-1;
+                nb=1;
+                if ((lg_sent=write(sock2,pdu,lg_pdu))==-1) /*,0,(struct sockaddr*)&addr_distant,lg_addr_distant)*/
+                {
+                    printf("Echec de l'envoi du PDU  (fonction write en défaut)\n");
+                    exit(1);
+                }
+            }
+            else
+            {
+                bal=find_BAL(liste,nBAL);
+                bal->l_current=bal->l_first;
+
+                while(bal->l_current!=NULL)
+                {
+                    lg=bal->l_current->lg;
+                    nb=bal->nb;
+                    sprintf(pdu,"%d %d",lg,nb);
+
+                    if ((lg_sent=write(sock2,pdu,lg_pdu))==-1) /*,0,(struct sockaddr*)&addr_distant,lg_addr_distant)*/
+                    {
+                        printf("Echec de l'envoi du PDU Emetteur (fonction write en défaut)\n");
+                        exit(1);
+                    }
+                    message=malloc(lg*sizeof(char));
+                    message=bal->l_current->message;
+
+                    if ((lg_sent=write(sock2,message,lg))==-1)
+                    {
+                        printf("Erreur lors de l'envoi du message n°%d\n",n);
+                        exit(1);
+                    }
+                    printf("BAL n°%d : Restitution de la lettre n°%d (%d) [",nBAL,n,lg);
+                    afficher_message(message,lg);
+                    bal->l_current=bal->l_current->suiv;
+                    n++;
+                }
+                empty(bal);
+                if ((shutdown(sock2 , 2))==-1)
+                {
+                    printf("Erreur à la fermeture de la connexion : shutdown\n");
+                    exit(1);
+                }
+            }
+        }
+        else
+        {
+            printf("PDU non reconnu, on quitte par sécurité\n");
+            exit(1);
+        }
+        printLISTE(liste);
+        free(pdu);
+        free(message);
+    }
+}
+void RBAL(int port, char* dest, int nBAL)
+{
+    //Déclarations
+    int sock;
+    struct sockaddr_in addr_distant;
+    int lg_addr_distant = sizeof(addr_distant);
+    struct hostent *hp;
+    char *message; //Penser au free en fin de programme pour libérer l'espace mémoire
+    int envoi = -1;
+    int lg_pdu=50;
+    int lg_recv=-1;
+    int lg;
+    int nb;
+    char *pdu = malloc(lg_pdu*sizeof(char));
+
+//---------------------------------------
+//--------Etablissement connexion--------
+//---------------------------------------
+
+    sprintf(pdu,"1 %d",nBAL);
+    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+    {
+        printf("Erreur à l'ouverture du Socket Stream");
+        exit(1);
+    }
+
+    //Construction adresse socket distant
+    memset((char *) &addr_distant, 0, sizeof(addr_distant));
+    addr_distant.sin_family = AF_INET;  //Internet
+    addr_distant.sin_port = port;       //Numéro de Port
+
+    //Affectation IP
+    if ((hp = gethostbyname(dest)) == NULL) {
+        printf("Erreur de requête IP.\n");
+        exit(1);
+    }
+
+    memcpy((char *) &(addr_distant.sin_addr.s_addr), hp->h_addr, hp->h_length);
+
+    //Demande de connexion
+
+    if (connect(sock, (struct sockaddr *) &addr_distant, sizeof(addr_distant)) == -1) {
+        printf("Erreur lors de la connexion, en attente de la tentative suivante \n");
+        exit(1);
+    }
+
+//-----------------------------------------
+//----------------Envoi PDU----------------
+//-----------------------------------------
+
+    if ((envoi = write(sock, pdu, lg_pdu)) == -1) /*,0,(struct sockaddr*)&addr_distant,lg_addr_distant)*/
+    {
+        printf("Echec de l'envoi du PDU Emetteur (fonction write en défaut)\n");
+        exit(1);
+    }
+    char*lgmsg=malloc(maxsize* sizeof(char));
+    nb=10;
+    int n=1;
+    lg_recv=1;
+    printf("             PUITS : Réception du contenu de la BAL n°%d\n",nBAL);
+    printf("____________________________________________________________________\n\n");
+
+    while(n<=nb)
+    {
+        if ((lg_recv=read(sock,lgmsg,lg_pdu))==-1)
+        {
+            printf("Erreur à la réception du PDU de longueur de message\n");
+            exit(1);
+        }
+        sscanf(lgmsg,"%d %d", &lg , &nb);
+        if (lg==-1)
+        {
+            printf("       ATTENTION : Pas de courrier à récupérer dans la BAL n°%d\n\n",nBAL);
+            exit(0);
+        }
+
+        message=malloc(lg*sizeof(char));
+        if ((lg_recv=read(sock,message,lg))==-1)
+        {
+            printf("Erreur à la réception du message\n");
+            exit(1);
+        }
+        printf("PUITS : Réception de la lettre n°%d : [",n);
+        afficher_message(message,lg);
+        n++;
+    }
+
+    printf("Fermeture de la Connexion\n");
+    //Ciao le socket
+    if(close(sock)==-1)
+    {
+        printf("Impossible de fermer le socket");
+        exit(1);
+    }
+}
+
+#endif

makefile

@@ -1,3 +1,2 @@
-tsock: tsock_p2.c  tsock.h
-	gcc tsock_p2.c -o tsock_p2 -g
-
+tsock: tsock_vf.c  tsock.h bal.h
+	gcc tsock_vf.c -o tsock -g

readme.txt

@@ -0,0 +1,122 @@
+                    __________________________________________________________________________
+                    ||              Projet de Programmation C orientée réseaux              ||
+                    ||                                                                      ||
+                    ||              Prénom : Béranger                                       ||
+                    ||              Nom :    Quintana                                       ||
+                    ||              Groupe : 3AE E                                          ||
+                    ||______________________________________________________________________||
+
+Bonjour, bienvenue sur ce programme d'échanges basé sur les protocoles TCP et UDP.
+Avec ce programme vous pourrez utiliser ces protocoles sous différentes formes :
+
+                    -De manière classique, avec un puits (-p) qui reçoit les informations d'une source (-s)
+                    -Avec une nouvelle fonctionnalité de serveur de Boite aux Lettres
+
+La fonctionnalité qui sera lancée au démarrage du programme sera celle de BAL.
+
+________________________________________________________________________________________________________________________
+                                                    Lancement de tsock
+________________________________________________________________________________________________________________________
+
+Pour lancer le programme, ouvrez un terminal dans le répertoire de travail, puis tapez la commande :
+
+                                                           make
+
+Cela compilera vos fichiers. Vous pourrez par la suite lancer vos différents programmes.
+________________________________________________________________________________________________________________________
+                                               USAGE de la Boite Aux Lettres
+________________________________________________________________________________________________________________________
+                                                ==========================
+                                                LANCEMENT D'UN SERVEUR BAL
+                                                ==========================
+Ici on peut lancer un serveur de Boites aux lettres sur une adresse IP et un port donné. Ce serveur se comporte comme
+une boucle infinie qui stocke les messages entrants dans des Boites aux lettres et les délivre par la suite après
+requête d'un récepteur.
+
+Pour lancer notre serveur BAL, il faut utiliser l'option -b du programme et lui attribuer un port d'écoute
+    Exemple, je veux lancer un serveur BAL sur le port 9000 :
+        Commande à utiliser :
+                                                     ./tsock -b 9000
+
+                                                   ====================
+                                                   EMISSION DE MESSAGES
+                                                   ====================
+
+Pour envoyer une ou plusieurs lettres,  à un boite aux lettres, il faut utiliser l'option -e# du programme avec # le
+numéro de Boite aux lettres destinataire, ainsi que fournir l'adresse IP du serveur, et le port d'écoute.
+    Exemple je veux envoyer des messages à la BAL n°5 sur l'IP 127.0.0.1, sur le port 9000
+        Commande à utiliser :
+                                               ./tsock -e5 127.0.0.1 9000
+
+        NB : si vous ne précisez pas le numéro de BAL cela envoira par défaut sur la BAL n°0
+
+Options disponibles pour l'émetteur :
+    -n# : fixe le nombre de message à émettre avec # le nombre de messages
+    -l# : fixe la longueur des messages à émettre avec # la longueur des messages pour cet envoi.
+    ATTENTION : On ne peut pas envoyer de messages plus court que les messages présents dans la BAL sous peine de
+                rogner les messages ces derniers. Le programme ne vous en informera pas lors de l'envoi...
+                En revanche, on peut envoyer des messages plus long que ceux précédemment envoyés.
+
+                                                   =====================
+                                                   RECEPTION DE MESSAGES
+                                                   =====================
+
+Pour récupérer les lettres d'une boite aux lettres le principe est le même :
+    Exemple : Je veux récupérer les lettres de la BAL n°5, à l'IP 127.0.0.1, sur le port 9000 :
+        Commande à utiliser :
+                                                 ./tsock -r5 localhost 9000
+
+        Vous ne pouvez ici que récupérer l'ensemble des lettres disponibles dans une des Boites aux lettres.
+        Les options -n et -l ne sont donc pas utilisables.
+
+========================================================================================================================
+========================================================================================================================
+
+Avec ces fichiers vous pourrez également utiliser TCP et UDP dans des usages plus classiques d'envois et réceptions
+directes
+
+________________________________________________________________________________________________________________________
+                                                    USAGE CLASSIQUE
+________________________________________________________________________________________________________________________
+
+    -Il est nécessaire d'activer le puits en premier et en lui attribuant une adresse IP distante ainsi qu'un
+    numéro de port
+        Exemple : Je veux recevoir depuis l'hôte local sur le port 9000
+            Commande à utiliser :
+                                              ./tsock -p localhost 9000
+
+    Seulement après avoir activé notre puits, on peut lancer notre source toujours en lui attribuant l'IP destinataire
+    et le numéro de port ou l'on veut envoyer nos informations.
+        Exemple : Je veux envoyer à destination de l'hote local sur le port 9000
+            Commande à utiliser :
+                                              ./tsock -s localhost 9000
+
+Liste des options :
+
+        -n : permet de fixer le nombre de messages à envoyer (par défaut : 10)
+        -l : permet de fixer la longueur des messages à envoyer (par défaut 30)
+        -u : permet d'utiliser le protocole UDP car TCP est utilisé par défaut
+
+      Pour l'usage classique, il est important que l'utilisateur du puits, paramètre correctement la longueur des
+      messages à recevoir pour pouvoir les recevoir correctement, sinon, la longueur par défaut sera de 30 caractères.
+
+      De plus, concernant le nombre de messages, si l'utilisateur du puits utilise l'option -n, et que le n du puits
+      est inférieur au -n du récepteur, il ne recevra pas les denrniers messages.
+
+________________________________________________________________________________________________________________________
+                                                 Remarques Générales
+________________________________________________________________________________________________________________________
+
+        -En principe, l'utilisation de fonctions de la partie Classique sur une serveur BAL ne fonctionne pas.
+         Par exemple, l'envoi depuis une source TCP (-s) vers un serveur BAL (-b) en fonctionnement contenant déjà des
+         lettres, enverra les lettres sur la dernière BAL utilisée. L'envoi depuis une source vers un serveur BAL ne
+         contenant pas de lettres sera bloquant. Il faudra relancer le serveur BAL pour pouvoir recevoir des lettres.
+
+        -La problématique de la longueur des messages à recevoir côté serveur n'a pas pu être traitée par manque de
+         temps.
+
+        -Il reste surement des coquilles....
+
+Si besoin, n'hésitez pas à me contacter : bquintan@etud.insa-toulouse.fr
+
+Bonne correction!

tsock.h

@@ -1,539 +1,451 @@
-//--------------------------PROG C ET RESEAUX-----------------------
-//Nom :    Quintana  -----------------------------------------------
-//Prénom : Béranger  -----------------------------------------------
-//Groupe : 3AE E     -----------------------------------------------
-//------------------------------------------------------------------
-
-#ifndef __tsock__
-
-//---------------------------------------------------
-//-------------Déclaration des fonctions-------------
-//---------------------------------------------------
-
-void construire_message(char *message, char motif, int lg, int i);
-void construire_message2(char *message, char motif, int lg, int i);
-void afficher_message(char *message, int lg);
-void envoi_UDP(int port, int nb_message  , int lg_msg, char*dest);
-void reception_UDP(int port, int nb_message , int lg_message);
-void ClientTCP (int port, int nb_message , int lg_msg, char* dest);
-void ServeurTCP(int port , int nb_message, int lg_msg);
-void printbuffer(int n);
-void printbuffer2(int n , char*message);
-
-
-
-
-//---------------------------------------------------
-//-------------Définitions des fonctions-------------
-//---------------------------------------------------
-
-//-------------Construire message 2 -----------------
-void construire_message2(char *message, char motif, int lg, int i)
-{
-
-    char alphabet[] = "abcdefghijklmnopqrstuvwxyz";
-    if (i>26)
-        motif=alphabet[i%26-1];
-    else if (i=26)
-    	motif='z';
-
-    else
-        motif = alphabet[i - 1];
-
-
-    for (int j=0;j<lg-5;j++)
-    {
-
-        *(message+j+5) = motif;
-    }
-}
-
-//------------------PRINTBUFFER-----------------------
-void printbuffer(int n)
-{
-    if (n<10)
-    {
-        printf("[----%d",n);
-    }
-    if (n>=10 & n<100)
-    {
-        printf("[---%d",n);
-    }
-    if (n>=100 & n<1000)
-    {
-        printf("[--%d",n);
-    }
-    if (n>=1000 & n<10000)
-    {
-        printf("[--%d",n);
-    }
-    if (n>=10000 & n<100000)
-    {
-        printf("[-%d",n);
-    }
-    if (n>=100000 & n<1000000)
-    {
-        printf("[%d",n);
-    }
-    if (n>=1000000)
-    {
-        printf("Trop de messages à envoyer (n>1000000 \n");
-        exit(1);
-    }
-}
-
-
-//------------------PRINTBUFFER2----------------------
-void printbuffer2(int n , char*message)
-{
-	if (n>=100000)
-    {
-        printf("Trop de messages à envoyer (n>1000000 \n");
-        exit(1);
-    }
-
-    if (n<10)
-    {
-        for (int i=0 ; i<4 ; i++)
-        {
-            *(message+i)='-';
-        }
-        //char nb[1];      
-        *(message+4)= n + '0';
-    }
-    if (n>=10 & n<100)
-    {
-    	char nb[2];
-
-        for (int i=0 ; i<3 ; i++)
-        {
-            *(message+i)='-';
-        }
-        sprintf(nb,"%d",n);
-        *(message+3)=*nb;
-        n=n%10;
-        sprintf(nb,"%d", n);
-        *(message+4)=*nb;
-    }
-    if (n>=100 & n<1000)
-    {
-        char nb[3];
-        for (int i=0 ; i<2 ; i++)
-        {
-            *(message+i)='-';
-        }
-        sprintf(nb,"%d",n);
-        *(message+2)=*nb;
-        n=n%100;
-        sprintf(nb,"%d", n);
-        *(message+3)=*nb;
-        n=n%10;
-        sprintf(nb,"%d", n);
-        *(message+4)=*nb;
-    }
-    if (n>=1000 & n<10000)
-    {
-    	int j=1000;
-
-        char nb[4];
-        for (int i=0 ; i<2 ; i++)
-        {
-            *(message+i)='-';
-        }
-
-        sprintf(nb,"%d",n);
-        *(message+1)=*nb;
-        n=n%1000;
-        sprintf(nb,"%d", n);
-        *(message+2)=*nb;
-        n=n%100;
-        sprintf(nb,"%d", n);
-        *(message+3)=*nb;
-        n=n%10;
-        sprintf(nb,"%d", n);
-        *(message+4)=*nb;
-    }
-    if (n>=10000 & n<100000)
-    {
-        char nb[4];
-        for (int i=0 ; i<2 ; i++)
-        {
-            *(message+i)='-';
-        }
-        sprintf(nb,"%d",n);
-        *(message)=*nb;
-        n=n%10000;
-        sprintf(nb,"%d", n);
-        *(message+1)=*nb;
-        n=n%1000;
-        sprintf(nb,"%d", n);
-        *(message+2)=*nb;
-        n=n%100;
-        sprintf(nb,"%d", n);
-        *(message+3)=*nb;
-        n=n%10;
-        sprintf(nb,"%d", n);
-        *(message+4)=*nb;
-    }
-    
-    
-}
-
-//Construction des messages
-
-void construire_message(char *message, char motif, int lg, int i )
-
-{
-	char alphabet[] = "abcdefghijklmnopqrstuvwxyz";
-	if (i>26)
-	    motif=alphabet[i%26-1];
-
-	else
-	    motif = alphabet[i - 1];
-
-
-  	for (int j=0;j<lg-5;j++)
-    {
-    	
-    	*(message+j) = motif;
-    }
-}
-
-//---------------------------------------------------
-//-------------Affichage des messages----------------
-//---------------------------------------------------
-
-void afficher_message(char *message, int lg)
-
-{
-  	
-  	int i;
-
-  	for (i=0;i<lg;i++)
-    {
-      	printf("%c", *(message+i));
-    }
-  	printf("]\n");
-}
-
-
-//----------------------------------------------------
-//----------------Envoi UDP---------------------------
-//----------------------------------------------------
-
-void envoi_UDP(int port ,int nb_mess , int lg_msg,char*dest)
-
-  
-{
-	
-  	int length_addr_dist;
-  	length_addr_dist=sizeof(struct sockaddr_in);
- 	 
-  	int sock;
- 	int sent;
-  	struct sockaddr_in addr_distant;
-  	struct hostent* hp;
-  	char *message=malloc(sizeof(char)*lg_msg) ;
-
-   	if((sock=socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP))==-1) //création du socket + test erreur (socket retourne -1 si le socket ne s'ouvre pas comme il faut
-    {
-      printf("Erreur à la création du socket\n");
-      exit(1);
-    }
-  	memset((char*)&addr_distant,0,sizeof(addr_distant));
-  	addr_distant.sin_family=AF_INET;
-  	addr_distant.sin_port=port;
-
-  	if((hp=gethostbyname(dest))==NULL)
-    {
-      printf("Erreur gethostbyname\n");
-      exit(1);
-    }
-
-    //printf("Après gethostbyname , nb_message= %d\n",nb_mess);
-      
-  	memcpy((char*)&(addr_distant.sin_addr.s_addr), hp->h_addr, hp->h_length);
-  	//printf("Association IP OK\n");
-  	//printf("Nombre de messages à envoyer : %d\n", nb_mess);
-      
-  	for (int i=1; i<=nb_mess ; i++)
-    {
-    	construire_message(message,'a',lg_msg,i);
-      	printf("SOURCE : Envoi n°%d (%d) [", i, lg_msg);
-      	
-
-      	if((sent=sendto(sock,message,lg_msg,0,(struct sockaddr*)&addr_distant,sizeof(addr_distant)))==-1)   
-      	{
-      		printf("Erreur sendto\n");
-      		exit(1);
-      	} 
-      	printbuffer2(i,message);
-      	afficher_message(message,sent);
-    }
-
-  	if(close(sock)==-1) //fermeture + test erreur à la fermeture
-    {
-      printf("Echec à la destruction du socket\n");
-      exit(1);
-    }
-}
-
-//----------------------------------------------------
-//------------------Reception UDP---------------------
-//----------------------------------------------------
-
-void reception_UDP(int port, int nb_message, int lg_message)
-{
-
-  int sock;
-  struct sockaddr_in addr_local,addr_distant;
-  int recv;
-  int lg_dist;
-  char *message=malloc(sizeof(char)*lg_message) ;
-
-  if((sock=socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP))==-1) //création du socket + test erreur d'ouverture
-    {
-      printf("Erreur à la création du socket\n");
-      exit(1);
-    }
-  
-  	memset((char*)&addr_local,0,sizeof(addr_local));//reset de addr_local
- 	addr_local.sin_family=AF_INET;                  //attribution des différents attributs de addr_local
-  	addr_local.sin_port=port;
-  	addr_local.sin_addr.s_addr=INADDR_ANY;          //On dit que l'on veut recevoir sur n'importe quelle carte réseau de notre machine (=INADDR_ANY)
-
-
-  	if ((bind(sock,(struct sockaddr*)&addr_local, sizeof(addr_local)))==-1) //bind de la réception + test erreur du bind
-    {
-      	printf("Echec du Bind\n");
-      	exit(1);
-    }
-
-    //printf("bind OK\n");
-     
-  	if (nb_message==-1)
-     	nb_message=10;
-
-    //printf("%d messages à recevoir\n",nb_message);
-  	lg_dist=sizeof(addr_distant);
-  	//printf("lg_dist initialisé\n");
-      
-  	for (int i=1 ; i<=nb_message ; i++)
-    {
-	  	
-	  	recv=recvfrom(sock,message,lg_message,0,(struct sockaddr*)&addr_distant,&lg_dist);
-  		if (recv==-1) //process de réception (recvfrom natif à l'API socket, + test erreur 
-		{
-		  printf("Erreur receive from\n");
-		  exit(1);
-		}
-    	else 
-		{
-	 		printf("PUITS : Réception n°%d (%d) :",i,lg_message);
-	  		afficher_message(message,recv);
-		}
-    }
-  
-   if(close(sock)==-1) //fermeture + test erreur à la fermeture
-    {
-      printf("Echec à la destruction du socket\n");
-      exit(1);
-    }
-}
-
-//---------------------------------------------------------------
-//----------------ClientTCP <=> source=1-------------------------
-//---------------------------------------------------------------
-
-void ClientTCP (int port, int nb_message , int lg_msg , char* dest)
-{
-	//Déclarations
-	int sock;
-	struct sockaddr_in addr_distant ;
-	int lg_addr_distant=sizeof(addr_distant);
-
-	struct hostent *hp;
-	char motif;
-	char * message=malloc(lg_msg*sizeof(char)); //Penser au free en fin de programme pour libérer l'espace mémoire
-	int envoi=-1;
-
-//---------------------------------------
-//--------Etablissement connexion--------
-//---------------------------------------
-
-	//Création socket 
-	if((sock=socket(AF_INET,SOCK_STREAM,0))==-1)
-	{
-		printf("Erreur à l'ouverture du Socket Stream");
-		exit(1);
-	}
-	
-	//Construction adresse socket distant
-	memset((char*)&addr_distant,0,sizeof(addr_distant));
-	addr_distant.sin_family=AF_INET;  //Internet
-	addr_distant.sin_port=port;       //Numéro de Port
-
-	//Affectation IP
-	if((hp=gethostbyname(dest))==NULL)
-	{
-		printf("Erreur de requête IP.\n");
-		exit(1);
-	}
-
-	memcpy((char*)&(addr_distant.sin_addr.s_addr), hp->h_addr , hp->h_length);
-
-	//Demande de connexion
-	
-	if (connect(sock,(struct sockaddr *)&addr_distant,sizeof(addr_distant))==-1)
-	{
-		printf("Erreur lors de la connexion, en attente de la tentative suivante \n");
-
-	}
-
-	//printf("Connexion Réussie !\n");
-
-//-----------------------------------------
-//----------TRANSFERT DE DONNEES-----------
-//-----------------------------------------
-
-	for (int i=1; i<=nb_message;i++)
-	{
-		printf("SOURCE : envoi n°%d (%d) [", i,lg_msg);
-		//Création du message 
-		
-		construire_message(message,motif,lg_msg,i);
-
-		printbuffer2(i,message);
-		afficher_message(message,lg_msg);
-
-		//Envoi du message 
-
-		if ((envoi=write(sock,message,lg_msg/*,0,(struct sockaddr*)&addr_distant,lg_addr_distant)*/))==-1)
-		{
-			printf("Echec de l'envoi du message (fonction write en défaut)\n");
-			exit(1);
-		}
-	}
-
-	//Fermeture connexion
-
-	if(shutdown(sock,2)==-1)
-	{
-		printf("Erreur à la fermeture de la connexion TCP \n");
-		exit(1);
-	}
-
-	if (close(sock)==-1)
-	{
-		printf("Echec de la fermeture du socket distant");
-		exit(1);
-	}
-
-	free(message);
-
-	printf("Envoi effectué avec succès\n");
-}
-
-//---------------------------------------------------------------
-//----------------ServeurTCP <=> source=0-------------------------
-//---------------------------------------------------------------
-
-void ServeurTCP(int port , int nb_message, int lg_msg)
-{
-	//Déclarations
-	int sock , sock2; //sock bis local orienté échanges 
-	struct sockaddr* addr_distant;
-	struct sockaddr_in addr_local;
-	int lg_addr_distant=sizeof(addr_distant);
-	int lg_addr_local=sizeof(addr_local);
-	struct hostent *hp;
-	char motif;
-	char * message=malloc(lg_msg*sizeof(char)); //Penser au free en fin de programme pour libérer l'espace mémoire
-	int lg_recv=-1;
-
-//-------------
-//Connexion ---
-//-------------
-
-	//Création socket local 	
-
-	if ((sock=socket(AF_INET,SOCK_STREAM,0))==-1)
-	{
-		printf("Echec de la création d'un socket local\n");
-		exit(1);
-	}
-
-	//Construction adresse socket local | Affectation port et domaine
-
-	memset((char*)&addr_local, 0 , sizeof(addr_local));
-	addr_local.sin_family=AF_INET;
-	addr_local.sin_addr.s_addr=INADDR_ANY;
-	addr_local.sin_port=port;
-
-	//printf("Socket créé addressé\n");
-
-	//Bind
-
-	if (bind(sock,(struct sockaddr *)&addr_local, lg_addr_local)==-1)
-	{
-		printf("Echec du bind.\n");
-		exit(1);
-	}
-	//printf("bind effectué\n");
-
-	//Check connexions entrantes 
-
-	if (listen(sock,100)<0)	
-	{
-		printf("Trop de connexions en attentes, échec de la demande\n");
-		exit(1);
-	}
-
-	//rintf("listen accepté\n");
-
-
-	//Accept connexion
-	
-
-	if (nb_message==-1)
-	{
-		nb_message=10;
-	}
-	if ((sock2 = accept(sock,(struct sockaddr*)&addr_distant,&lg_addr_distant))==-1)
-	{
-		printf("Refus de connexion par le serveur\n");
-		exit(1);
-	}
-	//printf("Accept validé, %d messages à recevoir\n",nb_message);
-	//Reception des messages au niveau du socket d'échange
-
-	for (int i=1;i<=nb_message;i++)
-	{
-		printf("PUITS : Réception n°%d (%d) [" , i , lg_msg);
-		if((lg_recv=read(sock2,message, lg_msg))<0)
-		{
-			printf("Echec de la lecture du message entrant \n");
-			exit(1);
-		}
-		afficher_message(message, lg_recv);
-	}
-	//Fermeture connexion
-
-	if ((shutdown(sock , 2))==-1)
-	{
-		printf("Erreur à la fermeture de la connexion : shutdown\n");
-		exit(1);
-	}
-		
-	//Ciao le socket
-	if(close(sock)==-1)
-	{
-		printf("Impossible de fermer le socket");
-	}
-
-	free(message);
-
-
-}
-
-#endif
+//--------------------------PROG C ET RESEAUX-----------------------
+//                          Nom :    Quintana
+//                          Prénom : Béranger
+//                             Grp : 3AE E
+//------------------------------------------------------------------
+#ifndef __tsock__
+//---------------------------------------------------
+//-------------Déclaration des fonctions-------------
+//---------------------------------------------------
+
+void construire_message2(char *message, char motif, int lg, int i);
+void afficher_message(char *message, int lg);
+void envoi_UDP(int port, int nb_message  , int lg_msg, char*dest);
+void reception_UDP(int port, int nb_message , int lg_message);
+void ClientTCP (int port, int nb_message , int lg_msg, char* dest);
+void ServeurTCP(int port , int nb_message, int lg_msg);
+void printbuffer(int n);
+void printbuffer2(int n , char*message);
+//---------------------------------------------------
+//---------------------------------------------------
+//-------------Définitions des fonctions-------------
+//---------------------------------------------------
+//---------------------------------------------------
+
+//---------------------------------------------------
+//-------------Construire message 2 ----------------- : Construit notre message à partir de l'alphabet
+//---------------------------------------------------
+void construire_message2(char *message, char motif, int lg, int i)
+{
+    char alphabet[] = "abcdefghijklmnopqrstuvwxyz";
+    if (i>=27)
+    {
+        if (i%26==0)
+            motif = 'z';
+        else
+            motif = alphabet[i%26-1];
+    }
+
+    else
+        motif=alphabet[i - 1];
+
+    for (int j=0;j<lg-5;j++)
+    {
+        *(message+j+5) = motif;
+    }
+}
+
+
+//----------------------------------------------------
+//------------------PRINTBUFFER2---------------------- : Modifie la variable message pour écrire le buffer ----# avec # le numéro d'envoi
+//----------------------------------------------------
+void printbuffer2(int n , char*message)
+{
+	if (n>=100000)
+    {
+        printf("Trop de messages à envoyer (n>1000000 \n");
+        exit(1);
+    }
+
+    if (n<10)
+    {
+        for (int i=0 ; i<4 ; i++)
+        {
+            *(message+i)='-';
+        }
+        //char nb[1];      
+        *(message+4)= n + '0';
+    }
+    if (n>=10 & n<100)
+    {
+    	char nb[2];
+
+        for (int i=0 ; i<3 ; i++)
+        {
+            *(message+i)='-';
+        }
+        sprintf(nb,"%d",n);
+        *(message+3)=*nb;
+        n=n%10;
+        sprintf(nb,"%d", n);
+        *(message+4)=*nb;
+    }
+    if (n>=100 & n<1000)
+    {
+        char nb[3];
+        for (int i=0 ; i<2 ; i++)
+        {
+            *(message+i)='-';
+        }
+        sprintf(nb,"%d",n);
+        *(message+2)=*nb;
+        n=n%100;
+        sprintf(nb,"%d", n);
+        *(message+3)=*nb;
+        n=n%10;
+        sprintf(nb,"%d", n);
+        *(message+4)=*nb;
+    }
+    if (n>=1000 & n<10000)
+    {
+    	int j=1000;
+
+        char nb[4];
+        for (int i=0 ; i<2 ; i++)
+        {
+            *(message+i)='-';
+        }
+
+        sprintf(nb,"%d",n);
+        *(message+1)=*nb;
+        n=n%1000;
+        sprintf(nb,"%d", n);
+        *(message+2)=*nb;
+        n=n%100;
+        sprintf(nb,"%d", n);
+        *(message+3)=*nb;
+        n=n%10;
+        sprintf(nb,"%d", n);
+        *(message+4)=*nb;
+    }
+    if (n>=10000 & n<100000)
+    {
+        char nb[4];
+        for (int i=0 ; i<2 ; i++)
+        {
+            *(message+i)='-';
+        }
+        sprintf(nb,"%d",n);
+        *(message)=*nb;
+        n=n%10000;
+        sprintf(nb,"%d", n);
+        *(message+1)=*nb;
+        n=n%1000;
+        sprintf(nb,"%d", n);
+        *(message+2)=*nb;
+        n=n%100;
+        sprintf(nb,"%d", n);
+        *(message+3)=*nb;
+        n=n%10;
+        sprintf(nb,"%d", n);
+        *(message+4)=*nb;
+    }
+}
+
+//----------------------------------------------------
+//-------------Affichage des messages-----------------
+//----------------------------------------------------
+void afficher_message(char *message, int lg)
+
+{
+  	for (int i=0;i<lg;i++)
+  	    printf("%c", *(message+i));
+  	printf("]\n");
+}
+
+//----------------------------------------------------
+//--------------------Envoi UDP-----------------------
+//----------------------------------------------------
+
+void envoi_UDP(int port ,int nb_mess , int lg_msg,char*dest)
+{
+	
+  	int length_addr_dist;
+  	length_addr_dist=sizeof(struct sockaddr_in);
+ 	 
+  	int sock;
+ 	int sent;
+  	struct sockaddr_in addr_distant;
+  	struct hostent* hp;
+  	char *message=malloc(sizeof(char)*lg_msg) ;
+
+   	if((sock=socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP))==-1) //création du socket + test erreur (socket retourne -1 si le socket ne s'ouvre pas comme il faut
+    {
+      printf("Erreur à la création du socket\n");
+      exit(1);
+    }
+  	memset((char*)&addr_distant,0,sizeof(addr_distant));
+  	addr_distant.sin_family=AF_INET;
+  	addr_distant.sin_port=port;
+
+  	if((hp=gethostbyname(dest))==NULL)
+    {
+      printf("Erreur gethostbyname\n");
+      exit(1);
+    }
+
+  	memcpy((char*)&(addr_distant.sin_addr.s_addr), hp->h_addr, hp->h_length);
+
+  	for (int i=1; i<=nb_mess ; i++)
+    {
+        printbuffer2(i,message);
+    	construire_message2(message,'a',lg_msg,i);
+      	printf("SOURCE : Envoi n°%d (%d) : [", i, lg_msg);
+      	
+
+      	if((sent=sendto(sock,message,lg_msg,0,(struct sockaddr*)&addr_distant,sizeof(addr_distant)))==-1)   
+      	{
+      		printf("Erreur sendto\n");
+      		exit(1);
+      	}
+      	afficher_message(message,sent);
+    }
+
+  	if(close(sock)==-1) //fermeture + test erreur à la fermeture
+    {
+      printf("Echec à la destruction du socket\n");
+      exit(1);
+    }
+}
+
+//----------------------------------------------------
+//------------------Reception UDP---------------------
+//----------------------------------------------------
+
+void reception_UDP(int port, int nb_message, int lg_message)
+{
+
+  int sock;
+  struct sockaddr_in addr_local,addr_distant;
+  int recv;
+  int lg_dist;
+  char *message=malloc(sizeof(char)*lg_message) ;
+
+  if((sock=socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP))==-1) //création du socket + test erreur d'ouverture
+    {
+      printf("Erreur à la création du socket\n");
+      exit(1);
+    }
+  
+  	memset((char*)&addr_local,0,sizeof(addr_local));//reset de addr_local
+ 	addr_local.sin_family=AF_INET;                  //attribution des différents attributs de addr_local
+  	addr_local.sin_port=port;
+  	addr_local.sin_addr.s_addr=INADDR_ANY;          //On dit que l'on veut recevoir sur n'importe quelle carte réseau de notre machine (=INADDR_ANY)
+
+
+  	if ((bind(sock,(struct sockaddr*)&addr_local, sizeof(addr_local)))==-1) //bind de la réception + test erreur du bind
+    {
+      	printf("Echec du Bind\n");
+      	exit(1);
+    }
+
+
+  	lg_dist=sizeof(addr_distant);
+
+    int i=1;
+    while(recv!=0)
+    {
+        recv=recvfrom(sock,message,lg_message,0,(struct sockaddr*)&addr_distant,&lg_dist);
+        if (recv==-1) //process de réception (recvfrom natif à l'API socket, + test erreur
+        {
+            printf("Erreur receive from\n");
+            exit(1);
+        }
+
+        if (recv!=0)
+        {
+            printf("PUITS : Réception n°%d (%d) : [",i,lg_message);
+            afficher_message(message,recv);
+        }
+        if (i==nb_message)
+        {
+            recv=0;
+            printf("On a atteint le nombre de messages à recevoir\n");
+        }
+
+        i++;
+    }
+  
+   if(close(sock)==-1) //fermeture + test erreur à la fermeture
+    {
+      printf("Echec à la destruction du socket\n");
+      exit(1);
+    }
+}
+
+//----------------------------------------------------
+// ----------------ClientTCP <=> source=1-------------
+//----------------------------------------------------
+void ClientTCP (int port, int nb_message , int lg_msg , char* dest)
+{
+	//Déclarations
+	int sock;
+	struct sockaddr_in addr_distant ;
+	int lg_addr_distant=sizeof(addr_distant);
+
+	struct hostent *hp;
+	char motif;
+	char * message=malloc(lg_msg*sizeof(char));
+	int envoi=-1;
+
+//--------Etablissement connexion--------
+
+	//Création socket 
+	if((sock=socket(AF_INET,SOCK_STREAM,0))==-1)
+	{
+		printf("Erreur à l'ouverture du Socket Stream");
+		exit(1);
+	}
+	
+	//Construction adresse socket distant
+	memset((char*)&addr_distant,0,sizeof(addr_distant));
+	addr_distant.sin_family=AF_INET;  //Internet
+	addr_distant.sin_port=port;       //Numéro de Port
+
+	//Affectation IP
+	if((hp=gethostbyname(dest))==NULL)
+	{
+		printf("Erreur de requête IP.\n");
+		exit(1);
+	}
+
+	memcpy((char*)&(addr_distant.sin_addr.s_addr), hp->h_addr , hp->h_length);
+
+	//Demande de connexion
+	
+	if (connect(sock,(struct sockaddr *)&addr_distant,sizeof(addr_distant))==-1)
+	{
+		printf("Erreur lors de la connexion, en attente de la tentative suivante \n");
+        exit(1);
+	}
+
+	//Connexion Réussie !
+
+//----------TRANSFERT DE DONNEES-----------
+
+	for (int i=1; i<=nb_message;i++)
+	{
+		printf("SOURCE : envoi n°%d (%d) [", i,lg_msg);
+		//Création du message 
+		
+		construire_message2(message,motif,lg_msg,i);
+
+		printbuffer2(i,message);
+		afficher_message(message,lg_msg);
+
+		//Envoi du message 
+
+		if ((envoi=write(sock,message,lg_msg/*,0,(struct sockaddr*)&addr_distant,lg_addr_distant)*/))==-1)
+		{
+			printf("Echec de l'envoi du message (fonction write en défaut)\n");
+			exit(1);
+		}
+	}
+
+	//Fermeture connexion
+
+	if(shutdown(sock,2)==-1)
+	{
+		printf("Erreur à la fermeture de la connexion TCP \n");
+		exit(1);
+	}
+
+	if (close(sock)==-1)
+	{
+		printf("Echec de la fermeture du socket distant");
+		exit(1);
+	}
+
+	free(message);
+	printf("Envoi effectué avec succès\n");
+}
+//------------------------------------------------------------
+//----------------ServeurTCP <=> source=0---------------------
+//------------------------------------------------------------
+
+void ServeurTCP(int port , int nb_message, int lg_msg)
+{
+	//Déclarations
+	int sock , sock2; //sock bis local orienté échanges 
+	struct sockaddr* addr_distant;
+	struct sockaddr_in addr_local;
+	int lg_addr_distant=sizeof(addr_distant);
+	int lg_addr_local=sizeof(addr_local);
+	struct hostent *hp;
+	char motif;
+	char * message=malloc(lg_msg*sizeof(char)); //Penser au free en fin de programme pour libérer l'espace mémoire
+	int lg_recv=-1;
+
+//-----------------Connexion --------------
+
+	//Création socket local 	
+
+	if ((sock=socket(AF_INET,SOCK_STREAM,0))==-1)
+	{
+		printf("Echec de la création d'un socket local\n");
+		exit(1);
+	}
+
+	//Construction adresse socket local | Affectation port et domaine
+
+	memset((char*)&addr_local, 0 , sizeof(addr_local));
+	addr_local.sin_family=AF_INET;
+	addr_local.sin_addr.s_addr=INADDR_ANY;
+	addr_local.sin_port=port;
+	//Bind
+
+	if (bind(sock,(struct sockaddr *)&addr_local, lg_addr_local)==-1)
+	{
+		printf("Echec du bind.\n");
+		exit(1);
+	}
+
+	//Check connexions entrantes 
+
+	if (listen(sock,100)<0)	
+	{
+		printf("Trop de connexions en attentes, échec de la demande\n");
+		exit(1);
+	}
+
+	//Accept connexion
+
+	if (nb_message==-1)
+		nb_message=10;
+
+	if ((sock2 = accept(sock,(struct sockaddr*)&addr_distant,&lg_addr_distant))==-1)
+	{
+		printf("Refus de connexion par le serveur\n");
+		exit(1);
+	}
+
+	//Reception des messages au niveau du socket d'échange
+
+//--------------Reception des données-----------
+    int i=1;
+    while(lg_recv!=0)
+    {
+
+        if((lg_recv=read(sock2,message, lg_msg))<0)
+        {
+            printf("Echec de la lecture du message entrant \n");
+            exit(1);
+        }
+        if (lg_recv!=0)
+        {
+            printf("PUITS : Réception n°%d (%d) [" , i , lg_msg);
+            afficher_message(message, lg_recv);
+            i++;
+        }
+    }
+
+	//Ciao le socket
+	if(close(sock)==-1)
+	{
+		printf("Impossible de fermer le socket");
+		exit(1);
+	}
+	free(message);
+}
+
+#endif

tsock_p2.c

@@ -1,240 +0,0 @@
-//--------------------------PROG C ET RESEAUX-----------------------
-//Nom :    Quintana  -----------------------------------------------
-//Prénom : Béranger  -----------------------------------------------
-//Groupe : 3AE E     -----------------------------------------------
-//------------------------------------------------------------------
-
-
-/* librairie standard ... */
-#include <stdlib.h>
-/* pour getopt */
-#include <unistd.h>
-/* déclaration des types de base */
-#include <sys/types.h>
-/* constantes relatives aux domaines, types et protocoles */
-#include <sys/socket.h>
-/* constantes et structures propres au domaine UNIX */
-#include <sys/un.h>
-/* constantes et structures propres au domaine INTERNET */
-#include <netinet/in.h>
-/* structures retournées par les fonctions de gestion de la base de
-données du réseau */
-#include <netdb.h>
-/* pour les entrées/sorties */
-#include <stdio.h>
-/* pour la gestion des erreurs */
-#include <errno.h>
-/* fonctions de tsock*/
-#include "tsock.h"
-/*fonctions de BAL*/
-#include "bal.h"
-/* pour afficher l'adresse d'un socket */
-#include <arpa/inet.h>
-
-
-/**********************************************************************
-Programme Principal
-**********************************************************************/
-
-void main (int argc, char **argv)
-{
-
-    //Déclarations
-
-    int c;
-    extern char *optarg;
-    extern int optind;
-    int nb_message = -1; /* Nb de messages à envoyer ou à recevoir, par défaut : 10 en émission, infini en réception */
-    int source = -1 ; /* 0=puits, 1=source */
-    int tcp=1; //tcp=1 => tcp ; tcp=0 =>udp
-    struct hostent *hp;
-    int bal=-1;
-    int port = -1; //Numéro de port
-    int recep=-1;
-    port =htons(port);
-
-    char *dest ;
-    int lg =30;
-
-    while ((c = getopt(argc, argv, "pn:sul:be:r:")) != -1)
-    {
-
-        switch (c)
-        {
-            case 'p':
-                if (source == 1)
-                {
-                    printf("usage: cmd [-p|-s][-n ##]\n");
-                    exit(1);
-                }
-                source = 0;
-                break;
-
-            case 's':
-                if (source == 0)
-                {
-                    printf("usage: cmd [-p|-s][-n ##]\n");
-                    exit(1) ;
-                }
-                dest=argv[argc-2];
-                source = 1;
-                break;
-
-            case 'n':
-                nb_message = atoi(optarg);
-                if (nb_message>100000)
-                {
-                    printf("Trop d'envois, n> 100 000\n");
-                    exit (1);
-                }
-                break;
-
-            case 'u':
-                tcp=0;
-                break;
-
-            case 'l':
-                lg = atoi(optarg);
-                break;
-
-            case 'b' :
-                bal=1;
-                break;
-
-            case 'e' :
-                if (recep==1)
-                {
-                    printf("On ne peut pas être émetteur et récepteur, -r ou -e, pas les deux\n");
-                    exit(1);
-                }
-
-                bal=1;
-                recep=0;
-
-                break;
-
-            case 'r' :
-                if (recep==0)
-                {
-                    printf("On ne peut être émetteur et récepteur en même temps : -e ou -r mais pas les deux\n");
-                    exit(1);
-                }
-                bal=1;
-                recep=1;
-
-
-                break;
-
-
-            default:
-                printf("usage: cmd [-p|-s|-b|-e|-r][-n ##]\n");
-                break;
-        }
-    }
-
-    if ((port=atoi(argv[argc-1]))!=-1)
-    {
-        port=htons(port);
-    }
-    dest=argv[argc-2];
-
-    if (source == -1 & bal ==-1)
-    {
-        printf("usage: cmd [-p|-s][-n ##]\n");
-        exit(1) ;
-    }
-    if (bal == -1)
-    {
-        if (source == 1)
-            printf("SOURCE : ");
-        else
-            printf("PUITS : ");
-
-
-        if (tcp==1)
-            printf("Protocole de transport : TCP | ");
-
-        else
-            printf("Protocole de transport : UDP | ");
-
-        if (nb_message == -1)
-        {
-
-            if (source == 1)
-            {
-                nb_message = 10;
-                printf("Nombre d'envois : %d | ", nb_message);
-            }
-            else
-                printf("Nombre de receptions : infini | ");
-        }
-
-        else
-        {
-            if (source == 1)
-            {
-
-                printf("Nombre d'envois = %d | ", nb_message);
-            }
-            else
-            {
-                printf("nb de tampons à recevoir = %d | ",nb_message);
-            }
-        }
-
-        printf("Destinataire : %s\n", dest);
-
-
-        //Envoi de message, Source en UDP
-
-        int length_addr_dist;
-        length_addr_dist=sizeof(struct sockaddr_in);
-
-
-        if(source==1 & tcp==0)
-        {
-            envoi_UDP(port,nb_message,lg,dest);
-        }
-
-            //PUITS de réception en UDP
-
-        else if (source==0 & tcp==0)
-        {
-            reception_UDP(port,nb_message,lg);
-        }
-
-
-        else if (source==0 & tcp==1)
-        {
-
-            ServeurTCP(port, nb_message, lg);
-        }
-
-        else if (source==1 & tcp==1)
-        {
-
-            ClientTCP(port,nb_message,lg,dest);
-        }
-    }
-
-    else
-    {
-        if (bal==1 &recep==0)
-        {
-            printf("On fait un serveur BAL\n");
-        }
-
-        else if (bal==1 & recep ==0)
-        {
-            printf("On est emetteur de lettres\n");
-        }
-
-        else if(bal==1 &recep == 1)
-        {
-            printf("On récupère des lettres \n");
-        }
-    }
-
-
-    exit(0);
-}

tsock_v0.c

@@ -1,80 +0,0 @@
-/* librairie standard ... */
-#include <stdlib.h>
-/* pour getopt */
-#include <unistd.h>
-/* déclaration des types de base */
-#include <sys/types.h>
-/* constantes relatives aux domaines, types et protocoles */
-#include <sys/socket.h>
-/* constantes et structures propres au domaine UNIX */
-#include <sys/un.h>
-/* constantes et structures propres au domaine INTERNET */
-#include <netinet/in.h>
-/* structures retournées par les fonctions de gestion de la base de
-données du réseau */
-#include <netdb.h>
-/* pour les entrées/sorties */
-#include <stdio.h>
-/* pour la gestion des erreurs */
-#include <errno.h>
-
-void main (int argc, char **argv)
-{
-	int c;
-	extern char *optarg;
-	extern int optind;
-	int nb_message = -1; /* Nb de messages à envoyer ou à recevoir, par défaut : 10 en émission, infini en réception */
-	int source = -1 ; /* 0=puits, 1=source */
-	while ((c = getopt(argc, argv, "pn:s")) != -1) {
-		switch (c) {
-		case 'p':
-			if (source == 1) {
-				printf("usage: cmd [-p|-s][-n ##]\n");
-				exit(1);
-			}
-			source = 0;
-			break;
-
-		case 's':
-			if (source == 0) {
-				printf("usage: cmd [-p|-s][-n ##]\n");
-				exit(1) ;
-			}
-			source = 1;
-			break;
-
-		case 'n':
-			nb_message = atoi(optarg);
-			break;
-
-		default:
-			printf("usage: cmd [-p|-s][-n ##]\n");
-			break;
-		}
-	}
-
-	if (source == -1) {
-		printf("usage: cmd [-p|-s][-n ##]\n");
-		exit(1) ;
-	}
-
-	if (source == 1)
-		printf("on est dans le source\n");
-	else
-		printf("on est dans le puits\n");
-
-	if (nb_message != -1) {
-		if (source == 1)
-			printf("nb de tampons à envoyer : %d\n", nb_message);
-		else
-			printf("nb de tampons à recevoir : %d\n", nb_message);
-	} else {
-		if (source == 1) {
-			nb_message = 10 ;
-			printf("nb de tampons à envoyer = 10 par défaut\n");
-		} else
-		printf("nb de tampons à envoyer = infini\n");
-
-	}
-}
-

tsock_v1_1.c

@@ -1,157 +0,0 @@
-//--------------------------PROG C ET RESEAUX-----------------------
-//Nom : Quintana     -----------------------------------------------
-//Prénom : Béranger  -----------------------------------------------
-//Groupe : 3AE E     -----------------------------------------------
-//------------------------------------------------------------------
-
-
-/* librairie standard ... */
-#include <stdlib.h>
-/* pour getopt */
-#include <unistd.h>
-/* déclaration des types de base */
-#include <sys/types.h>
-/* constantes relatives aux domaines, types et protocoles */
-#include <sys/socket.h>
-/* constantes et structures propres au domaine UNIX */
-#include <sys/un.h>
-/* constantes et structures propres au domaine INTERNET */
-#include <netinet/in.h>
-/* structures retournées par les fonctions de gestion de la base de
-données du réseau */
-#include <netdb.h>
-/* pour les entrées/sorties */
-#include <stdio.h>
-/* pour la gestion des erreurs */
-#include <errno.h>
-/* fonctions de tsock*/
-#include "tsock.h"
-
-
-/**********************************************************************
-Programme Principal
-**********************************************************************/
-
-void main (int argc, char **argv)
-{
-
-  //Déclarations
-  
-  int c;
-  extern char *optarg;
-  extern int optind;
-  int nb_message = -1; /* Nb de messages à envoyer ou à recevoir, par défaut : 10 en émission, infini en réception */
-  int source = -1 ; /* 0=puits, 1=source */
-  int tcp=1; //tcp=1 => tcp ; tcp=0 =>udp
-  struct hostent *hp;
-  
-  int port = -1; //Numéro de port
-  port =htons(port);
-  
-  char *dest ;
-  int lg_local;
-  
-  while ((c = getopt(argc, argv, "pn:su")) != -1) {
-	  
-	  
-    switch (c) {
-    case 'p':
-      if (source == 1) {
-	printf("usage: cmd [-p|-s][-n ##]\n");
-	exit(1);
-      }
-      source = 0;
-      break;
-
-    case 's':
-      if (source == 0) {
-	printf("usage: cmd [-p|-s][-n ##]\n");
-	exit(1) ;
-      }
-      dest=argv[argc-2];
-      source = 1;
-      break;
-
-    case 'n':
-      nb_message = atoi(optarg);
-      break;
-
-    case 'u':
-      if (tcp ==0){
-	printf("usage : cmd [-p| -s] [-u][-n##]\n");
-      }
-      tcp=0;
-      break;		  	  		        
-
-    default:
-      printf("usage: cmd [-p|-s][-n ##]\n");
-      break;
-    }
-  }
-
-  if ((port=atoi(argv[argc-1]))!=-1)
-    {
-      port=htons(port);
-    }
-  dest=argv[argc-2];
-
-
-  if (source == -1)
-    {
-      printf("usage: cmd [-p|-s][-n ##]\n");
-      exit(1) ;
-    }
-  if (tcp==1)
-    {
-      printf("On utilise TCP\n");
-    }
-  else
-    {printf("On utilise UDP\n");}
-
-
-  if (source == 1)
-    printf("on est dans le source\n");
-  else
-    printf("on est dans le puits\n");
-	
-
-  if (nb_message != -1)
-    {
-    if (source == 1)
-      printf("nb de tampons à envoyer : %d\n", nb_message);
-    else
-      printf("nb de tampons à recevoir : %d\n", nb_message);
-    }
-  else
-    {
-    if (source == 1)
-      {
-	nb_message = 10 ;
-	printf("nb de tampons à envoyer = 10 par défaut\n");
-      }
-    else
-      printf("nb de tampons à envoyer = infini\n");	    
-
-  }
-
-
-  //Envoi de message, Source en UDP
-  
-  int length_addr_dist;
-  length_addr_dist=sizeof(struct sockaddr_in);
-
-
-  
-  if(source==1 & tcp==0)
-    {
-      envoi_UDP(nb_message,port,50);
-    }
-
-  //PUITS de réception en UDP
-  
-  else if (source==0 & tcp==0)
-    {
-      reception_UDP(port,nb_message,50);
-    }
-  exit(0);	
-}

tsock_v3.c

@@ -1,189 +0,0 @@
-//--------------------------PROG C ET RESEAUX-----------------------
-//Nom :    Quintana  -----------------------------------------------
-//Prénom : Béranger  -----------------------------------------------
-//Groupe : 3AE E     -----------------------------------------------
-//------------------------------------------------------------------
-
-
-/* librairie standard ... */
-#include <stdlib.h>
-/* pour getopt */
-#include <unistd.h>
-/* déclaration des types de base */
-#include <sys/types.h>
-/* constantes relatives aux domaines, types et protocoles */
-#include <sys/socket.h>
-/* constantes et structures propres au domaine UNIX */
-#include <sys/un.h>
-/* constantes et structures propres au domaine INTERNET */
-#include <netinet/in.h>
-/* structures retournées par les fonctions de gestion de la base de
-données du réseau */
-#include <netdb.h>
-/* pour les entrées/sorties */
-#include <stdio.h>
-/* pour la gestion des erreurs */
-#include <errno.h>
-/* fonctions de tsock*/
-#include "tsock.h"
-/* pour afficher l'adresse d'un socket */
-#include <arpa/inet.h>
-
-
-/**********************************************************************
-Programme Principal
-**********************************************************************/
-
-void main (int argc, char **argv)
-{
-
-  	//Déclarations
-  
-  	int c;
-  	extern char *optarg;
-  	extern int optind;
-  	int nb_message = -1; /* Nb de messages à envoyer ou à recevoir, par défaut : 10 en émission, infini en réception */
-  	int source = -1 ; /* 0=puits, 1=source */
-  	int tcp=1; //tcp=1 => tcp ; tcp=0 =>udp
-  	struct hostent *hp;
-  
-  	int port = -1; //Numéro de port
-  	port =htons(port);
-  
-  	char *dest ;
-  	int lg =30;
-  
-  	while ((c = getopt(argc, argv, "pn:sul:")) != -1) 
-  	{ 
-	  
-    	switch (c) 
-    	{
-    		case 'p':
-      			if (source == 1) 
-      			{
-					printf("usage: cmd [-p|-s][-n ##]\n");
-					exit(1);
-      			}
-      			source = 0;
-      		break;
-
-    		case 's':
-      			if (source == 0) 
-      			{
-    				printf("usage: cmd [-p|-s][-n ##]\n");
-					exit(1) ;
-      			}
-      			dest=argv[argc-2];
-      			source = 1;
-      		break;
-
-    		case 'n':
-      			nb_message = atoi(optarg);
-            if (nb_message>100000)
-            {
-              printf("Trop d'envois, n> 100 000\n");
-              exit (1);
-            }
-      		break;	
-
-    		case 'u':
-      			tcp=0;
-      		break;
-
-          case 'l':
-            lg = atoi(optarg);
-          break;  	  		        
-
-		    default:
-    			printf("usage: cmd [-p|-s][-n ##]\n");
-      		break;
-    	}
-  	}
-
-  	if ((port=atoi(argv[argc-1]))!=-1)
-    {
-      port=htons(port);
-    }
-  	dest=argv[argc-2];
-
-  	if (source == -1)
-    {
-    	printf("usage: cmd [-p|-s][-n ##]\n");
-      exit(1) ;
-    }
-
-  	if (source == 1)
-    	printf("SOURCE : ");
-  	else
-    	printf("PUITS : ");
-
-  	
-  	if (tcp==1)
-    	printf("Protocole de transport : TCP | ");
-    
-  	else
-    	printf("Protocole de transport : UDP | ");
-
-  	if (nb_message == -1)
-  	{
-
-    	if (source == 1)
-    	{	
-    		nb_message = 10;
-      		printf("Nombre d'envois : %d | ", nb_message);
-    	}
-    	else
-      		printf("Nombre de receptions : infini | ");
-    }
-
-  	else
-    {
-    	if (source == 1)
-    	{
-			
-			printf("Nombre d'envois = %d | ", nb_message);
-    	}
-    	else
-    	{
-    		printf("nb de tampons à recevoir = %d | ",nb_message);	
-    	}	
-    }
-
-    printf("Destinataire : %s\n", dest);
-
-
-  	//Envoi de message, Source en UDP
-  
-  	int length_addr_dist;
-  	length_addr_dist=sizeof(struct sockaddr_in);
-
-  
-  	if(source==1 & tcp==0)
-    {
-      envoi_UDP(port,nb_message,lg,dest);
-    }
-
-  	//PUITS de réception en UDP
-  
-  	else if (source==0 & tcp==0)
-    {
-      reception_UDP(port,nb_message,lg);
-    }
-
-
-  	else if (source==0 & tcp==1)
-  	{
-    	
-    	ServeurTCP(port, nb_message, lg);
-  	}
-
-  	else if (source==1 & tcp==1)
-  	{
-    	
-    	ClientTCP(port,nb_message,lg,dest);
-  	}
-
-	exit(0); 
-}
-
-

tsock_vf.c

@@ -0,0 +1,258 @@
+//--------------------------PROG C ET RESEAUX-----------------------
+//                          Nom :    Quintana
+//                          Prénom : Béranger
+//                             Grp : 3AE E
+//------------------------------------------------------------------
+
+
+/* librairie standard ... */
+#include <stdlib.h>
+/* pour getopt */
+#include <unistd.h>
+/* déclaration des types de base */
+#include <sys/types.h>
+/* constantes relatives aux domaines, types et protocoles */
+#include <sys/socket.h>
+/* constantes et structures propres au domaine UNIX */
+#include <sys/un.h>
+/* constantes et structures propres au domaine INTERNET */
+#include <netinet/in.h>
+/* structures retournées par les fonctions de gestion de la base de
+données du réseau */
+#include <netdb.h>
+/* pour les entrées/sorties */
+#include <stdio.h>
+/* pour la gestion des erreurs */
+#include <errno.h>
+/* fonctions de tsock*/
+#include "tsock.h"
+/* fonctions de BAL */
+#include "bal.h"
+/* pour afficher l'adresse d'un socket */
+#include <arpa/inet.h>
+
+
+//----------------------------------------------------------------------
+//                        Programme Principal
+//----------------------------------------------------------------------
+
+void main (int argc, char **argv)
+{
+
+  	//Déclarations
+  
+  	int c;
+  	extern char *optarg;
+  	extern int optind;
+  	int nb_message = -1; /* Nb de messages à envoyer ou à recevoir, par défaut : 10 en émission, infini en réception */
+  	int source = -1 ; /* 0=puits, 1=source */
+  	int tcp=1; //tcp=1 => tcp ; tcp=0 =>udp
+  	struct hostent *hp;
+    int bal=-1;
+  	int port = -1; //Numéro de port
+    int recep=-1;
+  	port =htons(port);
+  	int nb_lettres=3;
+    int nBAL=-1;
+  	char *dest ;
+  	int lg =30;
+  
+  	while ((c = getopt(argc, argv, "pn:sul:be:r:")) != -1) 
+  	{
+    	switch (c) 
+    	{
+    		case 'p':
+      			if (source == 1) 
+      			{
+                    printf("ATTENTION :\n On ne peut être source et puits en même temps, Veuillez enlever une des deux options -s ou -p\n\n");
+					exit(1);
+      			}
+      			source = 0;
+      		break;
+    		case 's':
+      			if (source == 0) 
+      			{
+    				  printf("ATTENTION :\n On ne peut être source et puits en même temps, Veuillez enlever une des deux options -s ou -p\n\n");
+    				  exit(1) ;
+      			}
+      			dest=argv[argc-2];
+      			source = 1;
+      		break;
+            case 'b' :
+                if (source!=-1)
+                {
+                    printf("ATTENTION :\nOn ne peut utiliser le service de Boite aux lettres et l'usage classique de TCP|UDP en même temps.\nVeuillez retirer une des options -b ou -s|-p\n\n");
+                    exit(1);
+                }
+                bal=1;
+                break;
+            case 'e' :
+                if (source!=-1)
+                {
+                    printf("ATTENTION :\nOn ne peut utiliser le service de Boite aux lettres et l'usage classique de TCP|UDP en même temps.\nVeuillez retirer une des options -e ou -s|-p\n\n");
+                    exit(1);
+                }
+                if (recep==1)
+                {
+                    printf("On ne peut pas être émetteur et récepteur, -r ou -e, pas les deux\n");
+                    exit(1);
+                }
+                bal=1;
+                recep=0;
+                nBAL = atoi(optarg);
+                break;
+            case 'r' :
+                if (recep==0)
+                {
+                    printf("On ne peut être émetteur et récepteur en même temps : -e ou -r mais pas les deux\n");
+                    exit(1);
+                }
+                bal=1;
+                recep=1;
+                nBAL = atoi(optarg);
+                break;
+    		case 'n':
+      			nb_message = atoi(optarg);
+                if (nb_message>100000)
+                {
+                    printf("Trop d'envois, n> 100 000\n");
+                    exit (1);
+                }
+                if (recep==1)
+                {
+                    printf("ATTENTION :\nVous devez récupérer l'intégralité du contenu de la BAL. Vous ne pouvez donc pas fixer n\n\n");
+                    exit(1);
+                }
+      		break;
+    		case 'u':
+      			tcp=0;
+      			if (bal!=-1)
+                {
+      			    printf("ATTENTION : \nL'envoi sur BAL ne se fait que via TCP, Veuillez enlever l'option -u\n\n");
+      			    exit(1);
+                }
+      		break;
+            case 'l':
+                lg = atoi(optarg);
+                if (lg>maxsize)
+                {
+                    printf("Taille des messages supérieure à la limite fixée à %d\n",maxsize);
+                }
+                if (recep==1)
+                {
+                    printf("ATTENTION :\nVous devez récupérer l'intégralité du contenu de la BAL. Vous ne pouvez donc pas fixer l\n\n");
+                    exit(1);
+                }
+            break;
+		    default:
+    			printf("usage: ./tsock [-p|-s] ou [-b|-e|-r] [-n ##]\n");
+    			exit(1);
+      		break;
+    	}
+  	}
+
+
+  	if ((port=atoi(argv[argc-1]))!=-1)
+    {
+        port=htons(port);
+    }
+
+  	dest=argv[argc-2];
+
+  	if (source == -1 & bal ==-1)
+    {
+    	printf("usage: ./tsock [-p|-s] ou [-b|-e|-r] + [-n ##]\n");
+        exit(1) ;
+    }
+
+//Service Partie 1 Sans BAL
+    if (bal == -1)
+    {
+        if (source == 1)
+            printf("SOURCE : ");
+        else
+            printf("PUITS : ");
+
+      
+        if (tcp==1)
+            printf("Protocole de transport : TCP | ");
+      
+        else
+            printf("Protocole de transport : UDP | ");
+
+        if (nb_message == -1)  //Attribution du nombre de message à envoyer/recevoir si absence de -n XX
+        {
+            if (source == 1)
+            {
+                nb_message = 10;
+                printf("Nombre d'envois : %d | ", nb_message);
+            }
+            else
+                printf("Nombre de receptions : infini | ");
+        }
+
+        else
+        {
+            if (source == 1)
+                printf("Nombre d'envois = %d | ", nb_message);
+            else
+                printf("nb de tampons à recevoir = %d | ",nb_message);
+        }
+
+        printf("Destinataire : %s\n", dest);
+
+
+    //Envoi de message, Source en UDP
+
+        if(source==1 & tcp==0)
+            envoi_UDP(port,nb_message,lg,dest);
+
+
+    //PUITS de réception en UDP
+        else if (source==0 & tcp==0)
+            reception_UDP(port,nb_message,lg);
+
+    //Envoi de message en TCP
+        else if (source==0 & tcp==1)
+            ServeurTCP(port, nb_message, lg);
+
+        else if (source==1 & tcp==1)
+            ClientTCP(port,nb_message,lg,dest);
+    }
+    else //Partie 2 : UDP,TCP+BAL
+    {
+        if (nb_message == -1)  //Attribution du nombre de message à envoyer/recevoir si absence de -n XX
+        {
+            if (recep == 0)
+                nb_message = 10;
+
+        }
+        if (bal==1 &recep==-1)
+        {
+            printf("____________________________________________________________________\n\n");
+            printf("                             SERVEUR BAL                            \n");
+            printf("____________________________________________________________________\n\n");
+            SBAL(port, dest);
+        }
+
+        else if (bal==1 & recep ==0)
+        {
+            printf("____________________________________________________________________\n\n");
+            printf("                             EMETTEUR BAL                           \n");
+            printf("____________________________________________________________________\n\n");
+            EBAL(port, dest,nb_message,lg, nBAL);
+        }
+
+        else if(bal==1 &recep == 1)
+        {
+            printf("____________________________________________________________________\n\n");
+            printf("                            RECEPTEUR BAL                           \n");
+            printf("____________________________________________________________________\n\n");
+            RBAL(port,dest,nBAL);
+        }
+    }
+
+	exit(0);
+}
+
+