|
Support de cours Réseaux EISTI |
|
/* Fichiers a inclure .... */
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/utsname.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
/* Constantes */
/* Message envoye au serveur */
#define TAILLEMAX 100 /* Pour chaine de caracteres */
/* Prototypages */
int main(int argc, char ** argv);
int main(int argc, char ** argv)
{
int Fd; /* Descripteur de fichier (socket) */
int Fd4; /* Descripteur de fichier (socket) */
int FdAccept; /* Descripteur de fichier (socket) */
struct sockaddr_in Sockaddr; /* Descriptif d'un socket */
struct sockaddr_in Sockaddr4; /* Descriptif d'un socket */
struct hostent * Machine4; /* Machine ou reside le serveur4 */
struct servent * Service4; /* Service (ou port) ou le serveur4 est attache */
struct hostent * Machine; /* Machine ou reside le serveur */
struct servent * Service; /* Service (ou port) ou le serveur est attache */
struct utsname Uname; /* Informations sur la machine (non, version,...) */
char Message[TAILLEMAX +1];
char Message4[TAILLEMAX +1];
char Reponse[TAILLEMAX+1]; /* Reponse a Auto2 */
char NomMachine[SYS_NMLN +1];
int Piece; /* Numero de la piece traitee */
int Lenght;
/* Verifier l'appel */
if (argc != 4)
{
fprintf(stderr,"Syntaxe : %s Port Machine4 Port4...\n",argv[0]);
exit (-7);
}
/* Obtenir le nom de la machine sur le reseau */
if ( uname(&Uname) == -1)
{
perror("Auto1 : : uname :");
exit(-10);
}
strcpy(NomMachine,Uname.nodename);
/* le serveur est sur la machine ou on lance le programme */
Machine = gethostbyname(NomMachine);
if (Machine == NULL)
{
perror("Auto1 : : gethostbyname");
exit(-1);
}
/* initialisation de la structure */
memset(&Sockaddr,0,sizeof(struct sockaddr_in));
/* on travaille sur TCP/IP */
Sockaddr.sin_family = PF_INET;
memcpy(&(Sockaddr.sin_addr),Machine->h_addr,Machine->h_length);
/* on ecoute sur quel port ???? */
Service = getservbyname(argv[1],"tcp");
if (Service == NULL)
{
perror("Auto1 : : getservbyname");
exit(-2);
}
Sockaddr.sin_port = Service->s_port;
/* Initialisation vers Automat4 */
Machine4 = gethostbyname(argv[4]);
if (Machine4 == NULL)
{
perror("Auto1 : : gethostbyname");
exit(-1);
}
/* initialisation de la structure */
memset(&Sockaddr4,0,sizeof(struct sockaddr_in));
/* on travaille sur TCP/IP */
Sockaddr4.sin_family = PF_INET;
memcpy(&(Sockaddr4.sin_addr),Machine4->h_addr,Machine4->h_length);
/* on ecoute sur quel port ???? */
Service4 = getservbyname(argv[5],"tcp");
if (Service4 == NULL)
{
perror("Auto1 : : getservbyname");
exit(-2);
}
Sockaddr4.sin_port = Service4->s_port;
/* On peut avoir le socket */
/* PF_INET => socket tcp/ip */
/* SOCK_STREAM => tcp comme protocol */
/* 0 => protocole par defaut sur tcp */
Fd = socket(PF_INET,SOCK_STREAM,0);
if (Fd == -1)
{
perror("Auto1 : : socket");
exit(-3);
}
/* reserver le port sur lequel on veut ecouter */
if (bind(Fd,(struct sockaddr *) & Sockaddr,sizeof(struct sockaddr_in)) == -1)
{
perror("Auto1 : : bind");
exit (-4);
}
/* on attend au maximum une connection a la fois */
if (listen(Fd,1) == -1)
{
perror("Auto1 : : listen");
exit (-5);
}
Piece = 0;
while (1)
{
printf(" Auto1 : Mettre une Piece (puis RETURN) \n");
getchar();
Piece +=1; /* On traite une piece en plus ... */
printf("Auto1 : Traiter Piece numero %d\n",Piece);
sleep(5);
/* Informer auto4 */
/* On peut avoir le socket */
/* PF_INET => socket tcp/ip */
/* SOCK_STREAM => tcp comme protocol */
/* 0 => protocole par defaut sur tcp */
Fd4 = socket(PF_INET,SOCK_STREAM,0);
if (Fd4 == -1)
{
perror("Auto1 : : socket");
exit(-3);
}
if (connect ( Fd4,(struct sockaddr *) &Sockaddr4,sizeof(struct sockaddr_in))== -1)
{
perror("Auto1 : connect");
exit(-11);
}
sprintf(Message4,"Auto1 a fini la piece numero %d",Piece);
write(Fd4,Message4,strlen(Message4)+1);
close(Fd4);
printf("Auto1 : Attendre Demande...\n");
/* on accepte la connexion */
Lenght = sizeof(struct sockaddr_in);
if ((FdAccept = accept(Fd,(struct sockaddr *) &Sockaddr, &Lenght)) == -1)
{
perror("Auto1 : : accept");
exit (-6);
}
/* on tente la lecture du message */
read(FdAccept,Message,TAILLEMAX);
/* On devrait testert la validiter de la demande .... */
sprintf(Reponse,"%d :Voici la piece ",Piece);
write(FdAccept,Reponse,strlen(Reponse)+1);
close(FdAccept);
}
close(Fd);
exit(0);
}
automate2
/* Fichiers a inclure .... */
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/utsname.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
/* Constantes */
/* Message envoye au serveur */
#define MESSAGE " Donner une piece ! "
#define TAILLEMAX 100 /* Pour chaine de caracteres */
/* Prototypages */
int main(int argc, char ** argv);
int main(int argc, char ** argv)
{
int Fd4; /* Descripteur de fichier (socket) */
int Fd21; /* Descripteur de fichier (socket) */
int Fd23; /* Descripteur de fichier (socket) */
int FdAccept23; /* Descripteur de fichier (socket) */
struct sockaddr_in Sockaddr23; /* Descriptif d'un socket */
struct sockaddr_in Sockaddr4; /* Descriptif d'un socket */
struct sockaddr_in Sockaddr21; /* Descriptif d'un socket */
struct hostent * Machine4; /* Machine ou reside auto4 */
struct hostent * Machine23; /* Machine ou reside le client */
struct hostent * Machine21; /* Machine ou reside le serveur */
struct servent * Service21; /* Service (ou port) ou le serveur est attache */
struct servent * Service4; /* Service (ou port) ou le serveur 4est attache */
struct servent * Service23; /* Service (ou port) ou le serveur est attache */
struct utsname Uname; /* Informations sur la machine (non, version,...) */
int res; /* pour tester les fonctions */
char Message4[TAILLEMAX +1];
char Message[TAILLEMAX +1];
char Reponse[TAILLEMAX+1]; /* Reponse a Auto3 */
char NomMachine[SYS_NMLN +1];
int Piece; /* Numero de la piece traitee */
int Lenght;
/* Verifier l'appel */
if (argc != 6)
{
fprintf(stderr,"Syntaxe : %s PortServeur MachineClinet PortClient Machine4 port4\n",
argv[0]);
exit (-7);
}
/* Obtenir le nom de la machine sur le reseau */
if ( uname(&Uname) == -1)
{
perror("Auto2 : : uname :");
exit(-10);
}
strcpy(NomMachine,Uname.nodename);
/* le serveur est sur la machine ou on lance le programme */
Machine23 = gethostbyname(NomMachine);
if (Machine23 == NULL)
{
perror("Auto2 : : gethostbyname");
exit(-1);
}
/* initialisation de la structure */
memset(&Sockaddr23,0,sizeof(struct sockaddr_in));
/* on travaille sur TCP/IP */
Sockaddr23.sin_family = PF_INET;
memcpy(&(Sockaddr23.sin_addr),Machine23->h_addr,Machine23->h_length);
/* on ecoute sur quel port ???? */
Service23 = getservbyname(argv[1],"tcp");
if (Service23 == NULL)
{
perror("Auto2 : : getservbyname");
exit(-2);
}
Sockaddr23.sin_port = Service23->s_port;
/* On peut avoir le socket */
/* PF_INET => socket tcp/ip */
/* SOCK_STREAM => tcp comme protocol */
/* 0 => protocole par defaut sur tcp */
Fd23 = socket(PF_INET,SOCK_STREAM,0);
if (Fd23 == -1)
{
perror("Auto2 : : socket");
exit(-3);
}
/* reserver le port sur lequel on veut ecouter */
if (bind(Fd23,(struct sockaddr *) & Sockaddr23,sizeof(struct sockaddr_in)) == -1)
{
perror("Auto2 : : bind");
exit (-4);
}
/* on attend au maximum une connection a la fois */
if (listen(Fd23,1) == -1)
{
perror("Auto2 : : listen");
exit (-5);
}
/* Initialisation de la partie Client */
/* addresse de la machine du serveur */
Machine21 = gethostbyname(argv[2]);
if (Machine21 == NULL)
{
perror("Auto2 : gethostbyname");
exit(-1);
}
/* initialisation de la structure */
memset(&Sockaddr21,0,sizeof(struct sockaddr_in));
/* on travaille sur TCP/IP */
Sockaddr21.sin_family = PF_INET;
memcpy(&Sockaddr21.sin_addr,Machine21->h_addr,Machine21->h_length);
/* on ecoute sur quel port ???? */
Service21 = getservbyname(argv[3],"tcp");
if (Service21 == NULL)
{
perror("Auto2 : getservbyname");
exit(-2);
}
Sockaddr21.sin_port = Service21->s_port;
/* Initialisation vers Automat4 */
Machine4 = gethostbyname(argv[4]);
if (Machine4 == NULL)
{
perror("Auto1 : : gethostbyname");
exit(-1);
}
/* initialisation de la structure */
memset(&Sockaddr4,0,sizeof(struct sockaddr_in));
/* on travaille sur TCP/IP */
Sockaddr4.sin_family = PF_INET;
memcpy(&(Sockaddr4.sin_addr),Machine4->h_addr,Machine4->h_length);
/* on ecoute sur quel port ???? */
Service4 = getservbyname(argv[5],"tcp");
if (Service4 == NULL)
{
perror("Auto1 : : getservbyname");
exit(-2);
}
Sockaddr4.sin_port = Service4->s_port;
Piece = 0;
while (1)
{
printf("Auto2 : demander piece ... \n");
res = -1;
while (res == -1)
{
/* On peut avoir le socket */
/* PF_INET => socket tcp/ip */
/* SOCK_STREAM => tcp comme protocol */
/* 0 => protocole par defaut sur tcp */
Fd21 = socket(PF_INET,SOCK_STREAM,0);
if (Fd21 == -1)
{
perror("Auto2 : socket");
exit(-3);
}
res=connect(Fd21,(struct sockaddr *) &Sockaddr21,sizeof(struct sockaddr_in));
if ( res < 0)
{
perror("Auto2 : connect");
close(Fd21);
sleep(1);
}
}
/* on Demande la piece ... */
write(Fd21,MESSAGE,strlen(MESSAGE) +1 );
read(Fd21,Reponse,TAILLEMAX +1 );
sscanf(Reponse,"%d",&Piece);
close(Fd21);
printf("Auto2 : Traiter piece numero %d \n",Piece);
sleep(5);
/* Informer Auto4 */
/* On peut avoir le socket */
/* PF_INET => socket tcp/ip */
/* SOCK_STREAM => tcp comme protocol */
/* 0 => protocole par defaut sur tcp */
Fd4 = socket(PF_INET,SOCK_STREAM,0);
if (Fd4 == -1)
{
perror("Auto1 : : socket");
exit(-3);
}
if (connect ( Fd4,(struct sockaddr *) &Sockaddr4,sizeof(struct sockaddr_in))== -1)
{
perror("Auto2 : connect");
exit(-11);
}
sprintf(Message4,"Auto2 a fini la piece numero %d",Piece);
write(Fd4,Message4,strlen(Message4)+1);
close(Fd4);
printf("Auto2 : Attendre Demande...\n");
/* on accepte la connexion */
Lenght = sizeof(struct sockaddr_in);
if ((FdAccept23= accept(Fd23,(struct sockaddr *) &Sockaddr23, &Lenght)) == -1)
{
perror("Auto2 : : accept");
exit (-6);
}
/* on tente la lecture du message */
read(FdAccept23,Message,TAILLEMAX);
/* On devrait testert la validiter de la demande .... */
sprintf(Reponse,"%d :Voici la piece ",Piece);
write(FdAccept23,Reponse,strlen(Reponse)+1);
close(FdAccept23);
}
close(Fd23);
exit(0);
}
automate 3
/* Fichiers a inclure .... */
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
/* Constantes */
/* Message envoye au serveur */
#define MESSAGE " Message du client .... "
#define TAILLEMAX 100
/* Prototypages */
int main(int argc, char ** argv);
int main(int argc, char ** argv)
{
int Fd; /* Descripteur de fichier (socket) */
int Fd4; /* Descripteur de fichier (socket) */
struct sockaddr_in Sockaddr; /* Descriptif d'un socket */
struct sockaddr_in Sockaddr4; /* Descriptif d'un socket */
struct hostent * Machine4; /* Machine ou reside le serveur4 */
struct servent * Service4; /* Service (ou port) ou le serveur4 est attache */
struct hostent * Machine; /* Machine ou reside le serveur */
struct servent * Service; /* Service (ou port) ou le serveur est attache */
int res; /* pour tester le connect */
char Reponse[TAILLEMAX +1];/* Reponse du serveur */
char Message4[TAILLEMAX +1];/* Reponse du serveur */
int Piece ; /* numero de la piece a traiter */
/* verifier le lancement */
if ( argc != 5)
{
fprintf(stderr," Auto3 : Syntaxe : %s : Machine Port Machine4 Port4...\n",argv[0]);
exit(-10);
}
/* addresse de la machine du serveur */
Machine = gethostbyname(argv[1]);
if (Machine == NULL)
{
perror("Auto3 : gethostbyname");
exit(-1);
}
/* initialisation de la structure */
memset(&Sockaddr,0,sizeof(struct sockaddr_in));
/* on travaille sur TCP/IP */
Sockaddr.sin_family = PF_INET;
memcpy(&Sockaddr.sin_addr,Machine->h_addr,Machine->h_length);
/* on ecoute sur quel port ???? */
Service = getservbyname(argv[2],"tcp");
if (Service == NULL)
{
perror("Auto3 : getservbyname");
exit(-2);
}
Sockaddr.sin_port = Service->s_port;
/* Initialisation vers Automat4 */
Machine4 = gethostbyname(argv[3]);
if (Machine4 == NULL)
{
perror("Auto3 : : gethostbyname");
exit(-1);
}
/* initialisation de la structure */
memset(&Sockaddr4,0,sizeof(struct sockaddr_in));
/* on travaille sur TCP/IP */
Sockaddr4.sin_family = PF_INET;
memcpy(&(Sockaddr4.sin_addr),Machine4->h_addr,Machine4->h_length);
/* on ecoute sur quel port ???? */
Service4 = getservbyname(argv[4],"tcp");
if (Service4 == NULL)
{
perror("Auto3 : : getservbyname");
exit(-2);
}
Sockaddr4.sin_port = Service4->s_port;
while (1)
{
printf("Auto3 : demander piece ... \n");
res = -1;
while (res == -1)
{
/* On peut avoir le socket */
/* PF_INET => socket tcp/ip */
/* SOCK_STREAM => tcp comme protocol */
/* 0 => protocole par defaut sur tcp */
Fd = socket(PF_INET,SOCK_STREAM,0);
if (Fd == -1)
{
perror("Auto3 : socket");
exit(-3);
}
res=connect(Fd,(struct sockaddr *) &Sockaddr,sizeof(struct sockaddr_in));
if ( res < 0)
{
perror("Auto3 : connect");
close(Fd);
sleep(1);
}
}
/* on Demande la piece ... */
write(Fd,MESSAGE,strlen(MESSAGE) +1 );
read(Fd,Reponse,TAILLEMAX +1 );
sscanf(Reponse,"%d",&Piece);
close(Fd);
printf("Auto3 : Traiter piece numero %d \n",Piece);
sleep(5);
/* Informer auto4 */
/* On peut avoir le socket */
/* PF_INET => socket tcp/ip */
/* SOCK_STREAM => tcp comme protocol */
/* 0 => protocole par defaut sur tcp */
Fd4 = socket(PF_INET,SOCK_STREAM,0);
if (Fd4 == -1)
{
perror("Auto3 : : socket");
exit(-3);
}
if (connect ( Fd4,(struct sockaddr *) &Sockaddr4,sizeof(struct sockaddr_in))== -1)
{
perror("Auto3 : connect");
exit(-11);
}
sprintf(Message4,"Auto3 a fini la piece numero %d",Piece);
write(Fd4,Message4,strlen(Message4)+1);
close(Fd4);
printf("Auto3 : Enlvevez la piece puis RETURN \n");
getchar();
}
exit(0);
}
/* Fichiers a inclure .... */
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/utsname.h>
#include <netdb.h>
#include <signal.h>
#include <netinet/in.h>
#include <arpa/inet.h>
/* Constantes */
/* Message envoye au serveur */
#define TAILLEMAX 100 /* Pour chaine de caracteres */
/* Prototypages */
int main(int argc, char ** argv);
void Repondeur(int Fd);
int main(int argc, char ** argv)
{
pid_t Pid;
int Fd; /* Descripteur de fichier (socket) */
int FdAccept; /* Descripteur de fichier (socket) */
struct sockaddr_in Sockaddr; /* Descriptif d'un socket */
struct hostent * Machine; /* Machine ou reside le serveur */
struct servent * Service; /* Service (ou port) ou le serveur est attache */
struct utsname Uname; /* Informations sur la machine (non, version,...) */
char Message[TAILLEMAX +1];
char NomMachine[SYS_NMLN +1];
int Lenght;
struct sigaction Action; /* Gestion des signaux */
/* Verifier l'appel */
if (argc != 2)
{
fprintf(stderr,"Syntaxe : %s Port...\n",argv[0]);
exit (-7);
}
/* Obtenir le nom de la machine sur le reseau */
if ( uname(&Uname) == -1)
{
perror("Serveur: uname :");
exit(-10);
}
strcpy(NomMachine,Uname.nodename);
/* le serveur est sur la machine ou on lance le programme */
Machine = gethostbyname(NomMachine);
if (Machine == NULL)
{
perror("Serveur : gethostbyname");
exit(-1);
}
/* initialisation de la structure */
memset(&Sockaddr,0,sizeof(struct sockaddr_in));
/* on travaille sur TCP/IP */
Sockaddr.sin_family = PF_INET;
memcpy(&(Sockaddr.sin_addr),Machine->h_addr,Machine->h_length);
/* on ecoute sur quel port ???? */
Service = getservbyname(argv[1],"tcp");
if (Service == NULL)
{
perror("Serveur : getservbyname");
exit(-2);
}
Sockaddr.sin_port = Service->s_port;
/* On peut avoir le socket */
/* PF_INET => socket tcp/ip */
/* SOCK_STREAM => tcp comme protocol */
/* 0 => protocole par defaut sur tcp */
Fd = socket(PF_INET,SOCK_STREAM,0);
if (Fd == -1)
{
perror("Serveur : socket");
exit(-3);
}
/* reserver le port sur lequel on veut ecouter */
if (bind(Fd,(struct sockaddr *) & Sockaddr,sizeof(struct sockaddr_in)) == -1)
{
perror("Serveur : bind");
exit (-4);
}
/* on attend au maximum une connection a la fois */
if (listen(Fd,10) == -1)
{
perror("Serveur : listen");
exit (-5);
}
while (1)
{
/* on accepte la connexion */
Lenght = sizeof(struct sockaddr_in);
if ((FdAccept = accept(Fd,(struct sockaddr *) &Sockaddr, &Lenght)) == -1)
{
perror("Serveur : accept");
exit (-6);
}
/* On ignore la mort des repondeurs */
Action.sa_handler = SIG_IGN;
Action.sa_flags = SA_NOCLDWAIT;
if (sigaction(SIGCHLD,&Action,NULL) == -1)
{
perror("Automat4 sigaction");
exit(-30);
}
/* On lance le repondeur */
Pid = fork();
switch(Pid)
{
case -1 : /* Erreur */
perror("Fork");
exit(-1);
break;
case 0: /* Le fils qui va etre le repondeur */
/* fermer le socket du bind */
close(Fd);
/* Apeller le repondeur */
Repondeur(FdAccept);
exit(0);
break;
default : /* le pere */
/* rien a dire don fermer le fdaccept */
close(FdAccept);
break;
}
}
close(Fd);
exit(0);
}
/********************************************/
/* Le repondeur recoit le socket de dialoque*/
/********************************************/
void Repondeur(int Fd)
{
char Message[TAILLEMAX+1];
memset(Message,'\0',TAILLEMAX+1);
read(Fd,Message,TAILLEMAX);
printf("%s\n",Message);
close(Fd);
}
|
|
Support de cours Réseaux EISTI |
|
