bquintan/ProgC_Reseau_3AE
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Fin du projet. Serveur Fonctionnel

Browse source
This commit is contained in:
BQUINTAN 2020-05-09 19:14:21 +02:00
parent 9b2e4aa4b3
commit 4df267d543
12 changed files with 1493 additions and 1279 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

731
bal.h
View file

@ -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

5
makefile
View file

@ -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

122
readme.txt Normal file
View file

@ -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!

BIN
tsock Normal file
View file

Binary file not shown.

990
tsock.h
View file

@ -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

BIN
tsock_p2
View file

Binary file not shown.

240
tsock_p2.c
View file

@ -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);
}

80
tsock_v0.c
View file

@ -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");
}
}

157
tsock_v1_1.c
View file

@ -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);
}

BIN
tsock_v3
View file

Binary file not shown.

189
tsock_v3.c
View file

@ -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);
}

258
tsock_vf.c Normal file
View file

@ -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);
}