enum Evenements AfficherParametres( struct Global *g)
{
char Buffer[20] ;
Ipv4ToS(g->IPInterface,Buffer) ;
printf("Adresse IP :%s \n",Buffer);
Ipv4ToS(g->NetworkMask,Buffer ) ;
printf("Masque R�eau :%s \n",Buffer);
Ipv4ToS(g->Gateway,Buffer ) ;
printf("Adresse Passerelle :%s \n",Buffer);
Ipv4ToS(g->IPDNS,Buffer ) ;
printf("Adresse serveur DNS :%s \n",Buffer);
printf("Port pour votre client DNS :%d \n",g->PortRequeteDNS);
printf("Port Application :%d \n",g->PortApplication);
printf("Protocole utilis�:") ;
if ( g->Protocole == UDP )
printf("UDP\n") ;
else
if ( g->Protocole == TCP )
printf("TCP \n") ;
else
printf("??? \n") ;
printf("ServiceDNS %d \n", g->ActivationDNS );
return(NEAN) ;
}
void AffichePaquet( struct Paquet *pp)
{
char Buffer1[30], Buffer2[30] ;
Ipv4ToS(pp->IPSource,Buffer1 ) ;
Ipv4ToS(pp->IPDestination,Buffer2 ) ;
fprintf(stderr,"Reseau:message :%s:%s %d\n",Buffer1,Buffer2,pp->Protocole) ;
}
enum Evenements RequeteDNS(char Buffer[],int *PTS,int *PTD,int IPSource, int *IPDestination,int *Protocole,struct Global *g)
{
int Ip ;
char NomDNS[50] ;
printf("Traitement d'une requete DNS %s \n",Buffer) ;
Ip = RechercheNomDB(FICHIERDNS,Buffer) ;
if(Ip)
{
char ChaineIP[80] ;
Ipv4ToS(Ip,ChaineIP ) ;
printf("L'ip de %s est %s \n",Buffer,ChaineIP) ;
/* fabrication de la r�onse */
strcpy(NomDNS,Buffer ) ;
sprintf(Buffer,"%s %s",NomDNS,ChaineIP) ;
*PTD = *PTS ;
*PTS = 53 ;
*IPDestination = IPSource ;
*Protocole = UDP ;
return(ENVOI) ;
}
else
printf("Resolution impossible !!!\n") ;
return(NEAN) ;
}
enum Evenements GenerationTrame(struct Trame *UneTrame,void *Contenu, struct Global *g )
{
char Buffer[200] ;
char BufferIP[20] ;
int rc ;
/* Remplissage de la trame */
UneTrame->Numero = 0 ;
UneTrame->MacDestination.Constructeur = 0xFF ;
UneTrame->MacDestination.Numero = g->MacD ; /* Je nai pas implement�arp */
UneTrame->MacSource.Constructeur = 0xFF ;
UneTrame->MacSource.Numero = g->IPInterface ; /* Je nai pas implement�arp */
/* &(g->IPInterface) */
memcpy(UneTrame->Buffer,Contenu,sizeof(UneTrame->Buffer)) ;
Ipv4ToS((UneTrame->MacDestination).Numero,BufferIP ) ; /* A controler */
fprintf(stderr,"Liaison: contenu :%s vers FF:%s \n",UneTrame->Buffer,BufferIP ) ;
AffichePaquet((struct Paquet *) UneTrame->Buffer) ;
rc = VersCouchePhysique(&(g->TPhys),UneTrame,sizeof(struct Trame)) ;
if (rc == -1 )
{
perror("Motif:") ;
return(NEAN) ;
}
else
{
fprintf(stderr,"Liaison: %d bytes �rits\n",rc) ;
return(ENVOI) ;
}
}
void AfficheTableRoutage(struct EntreeTableRoutage TableRoutage[],int NbrEntrees )
{
int i = 0 ;
while(i < NbrEntrees )
{
char Buffer[30] ;
char Buffer2[30] ;
char Buffer3[30] ;
Ipv4ToS(TableRoutage[i].Adresse,Buffer) ;
Ipv4ToS(TableRoutage[i].Gateway,Buffer2) ;
Ipv4ToS(TableRoutage[i].Masque,Buffer3) ;
printf("Adresse reseau %s:Interface %d gateway %s masque %s \n",Buffer,TableRoutage[i].Ligne,Buffer2,Buffer3) ;
i++ ;
}
return ;
}
enum Evenements ReceptionICMP(Buffer,IPSource )
{
char BufferProv[20] ;
int *Code ;
Ipv4ToS(IPSource,BufferProv) ;
printf("ICMP Adresse IP Source:%s .......... \n",BufferProv);
return(NEAN) ;
}
int main(int argc, char *argv[])
{
int rc;
int Desc;
int tm;
int Port, Ip;
char Tampon[80];
struct sockaddr_in psoo; /* o = origine */
struct sockaddr_in psos; /* s = serveur */
struct sockaddr_in psor; /* r = remote */
struct Requete UneRequete;
memset(&psoo, 0, sizeof(struct sockaddr_in));
memset(&psos, 0, sizeof(struct sockaddr_in));
memset(&psor, 0, sizeof(struct sockaddr_in));
if (argc!=5)
{
printf("cli client portc serveur ports\n");
exit(1);
}
Desc = CreateSockets(&psoo, &psos, argv[1], atoi(argv[2]), argv[3], atoi(argv[4]));
if (Desc == -1)
perror("CreateSockets:");
else
fprintf(stderr, "CreateSockets %d\n", Desc);
Ip = GetIP(&psoo);
Port = GetPort(&psoo);
memset(Tampon, 0, sizeof(Tampon));
Ipv4ToS(Ip, Tampon);
printf("Adresse Ip du client %s : Port %d \n", Tampon, Port);
UneRequete.Type = Question;
strncpy(UneRequete.Message, "Multiclient; Bonjour", sizeof(UneRequete.Message));
rc = SendDatagram(Desc, &UneRequete, sizeof(struct Requete), &psos);
if (rc == -1)
perror("SendDatagram");
else
fprintf(stderr, "Envoi de %d bytes\n", rc);
memset(&UneRequete, 0, sizeof(struct Requete));
tm = sizeof(struct Requete);
rc = ReceiveDatagram(Desc, &UneRequete, tm, &psor);
if (rc == -1)
perror("ReceiveDatagram");
else
fprintf(stderr, "bytes:%d:%s\n", rc, UneRequete.Message);
close(Desc);
}
void AffichageTableFiltrage(struct Regle TableFiltrage[],int NbrRegles)
{
int I = 0 ;
char Buffer[80] ;
while ( I < NbrRegles )
{
printf("%d ",TableFiltrage[I].LigneEntree ) ;
Ipv4ToS(TableFiltrage[I].IPSource,Buffer ) ;
printf("%s ",Buffer ) ;
printf(" \\ %d ", TableFiltrage[I].MasqueS ) ;
Ipv4ToS(TableFiltrage[I].IPDestination,Buffer ) ;
printf("%s ",Buffer ) ;
printf(" \\ %d ", TableFiltrage[I].MasqueD ) ;
printf("%d ",TableFiltrage[I].PortSource ) ;
printf("%d ",TableFiltrage[I].PortDestination ) ;
if (TableFiltrage[I].Protocole == IP )
printf("IP ") ;
else
if (TableFiltrage[I].Protocole == UDP )
printf("UDP ") ;
else
if (TableFiltrage[I].Protocole == TCP )
printf("TCP ") ;
else
{
printf("Politique non connue \n") ;
exit(0) ;
}
if (TableFiltrage[I].Politique == DROP )
printf("DROP \n") ;
else
if (TableFiltrage[I].Politique == ACCEPT )
printf("ACCEPT \n") ;
else
{
printf("Politique non connue \n") ;
exit(0) ;
}
I++ ;
}
}
int ip_address(char *Buffer,struct Global *g)
{
int rc ;
char arg0[80],arg0B[80],LIP[80],arg2[80],arg3[80],arg4[80] ;
struct Interface *pI ;
int UneIP ;
fprintf(stderr,"Entree IP adress\n") ;
AfficheInterfaces(g->pI) ;
bzero(arg0,sizeof(arg0));
bzero(LIP,sizeof(LIP));
sscanf(Buffer,"%s %s %s\n",arg0,arg0B,LIP) ;
/*----------- arg1 est l'adresse IP ------------------------*/
pI = RechercheInterfaceNom(g->CurrentInterface,g->pI) ;
if ( pI == NULL )
{
fprintf(stderr,"Le nom de l'interface n'existe pas %s \n",g->CurrentInterface) ;
return (0) ;
}
if (Ipv4ToInt(LIP,&UneIP)!=-1) /* IP ligne valide ? */
{
int ETR ;
int Ligne ;
char Buf[30] ;
Ipv4ToS(UneIP,Buf) ;
Ligne = ObtenirLigne(pI) ;
fprintf(stderr,"L'adresse Pour la ligne %d est la suivante %s.\n",Ligne, Buf ) ;
ETR = ObtenirEntreeTableRoutage(pI) ;
if (ETR ==-1)
{
/* première fois qu on assigne une ip £*/
AjoutEntreeTableRoutage( g->TableRoutage,UneIP & 0xFFFFFF00 , Ligne, UneIP ,0xFFFFFF00, &g->NbrEntrees) ;
ModifieEntreeTableRoutage(g->NbrEntrees-1,pI) ;
}
else
{
fprintf(stderr,"Modiication de l entrée de la table de routage \n") ;
RemplaceEntreeTableRoutage( g->TableRoutage,UneIP & 0xFFFFFF00 , Ligne, UneIP ,0xFFFFFF00, ETR) ;
}
ModifieIP(UneIP,pI) ;
AfficheInterfaces(g->pI) ;
}
else
{
fprintf(stderr,"L'adresse %s est mauvaise.",LIP) ;
return 0 ;
}
AfficheInterfaces(g->pI) ;
fprintf(stderr,"Sortie Ip_adress\n") ;
return 1 ;
}
enum Evenements ResolutionDNSFichier()
{
char NomAResoudre[80] ;
char NomFichier[80] ;
char Buffer1[80] ;
int Ip ;
printf("Entrez le nom a v�ifier:") ;
fgets(NomAResoudre,sizeof NomAResoudre,stdin) ;
NomAResoudre[strlen(NomAResoudre)-1] = 0 ;
printf("Le NomAResoudre est :%s:\n",NomAResoudre) ;
strncpy(NomFichier,FICHIERDNS,sizeof NomFichier ) ;
Ip = RechercheNomDB(FICHIERDNS,NomAResoudre) ;
if(Ip)
{
Ipv4ToS(Ip,Buffer1 ) ;
printf("L'ip de %s est %s \n",NomAResoudre,Buffer1) ;
}
return(NEAN) ;
}
int FiltragePaquet(int LigneEntree,struct Regle TableFiltrage[],int NbrRegles, struct Paquet* PP,int *R)
{
struct Segment *PS ;
char Tampon[80] ;
int i = 0 ;
PS = ( struct Segment * ) PP->Buffer ;
for( i = 0 ;i < NbrRegles ; i++ )
{
*R= i+1 ;
fprintf(stderr,"\nReseau: Regle %d",*R ) ;
if ( (TableFiltrage[i].LigneEntree !=0) && (TableFiltrage[i].LigneEntree != LigneEntree ))
continue ;
fprintf(stderr,"LE,") ;
Ipv4ToS((PP->IPSource & generer_masque(TableFiltrage[i].MasqueS)), Tampon) ;
fprintf(stderr,"R Masque %s \n",Tampon ) ;
if ( (TableFiltrage[i].IPSource!=0) && (TableFiltrage[i].IPSource != (PP->IPSource & generer_masque(TableFiltrage[i].MasqueS)) ))
continue ;
fprintf(stderr,"IPS,");
if ( (TableFiltrage[i].IPDestination!=0) && (TableFiltrage[i].IPDestination != (PP->IPDestination & generer_masque(TableFiltrage[i].MasqueD)) ))
continue ;
fprintf(stderr,"IPD,") ;
if ( (TableFiltrage[i].PortSource!=0) && (TableFiltrage[i].PortSource != PS->PortSource ))
continue ;
fprintf(stderr,"PS,") ;
if ( (TableFiltrage[i].PortDestination!=0) && (TableFiltrage[i].PortDestination != PS->PortDestination ))
continue ;
fprintf(stderr,"PD,") ;
if (TableFiltrage[i].Protocole!= IP)
if ( (TableFiltrage[i].Protocole!=0) && (TableFiltrage[i].Protocole != PP->Protocole ))
continue ;
fprintf(stderr,"Protocole.") ;
if(TableFiltrage[i].Politique==DROP)
return 1 ;
if(TableFiltrage[i].Politique==ACCEPT)
return 0 ;
}
*R = 0 ;
return (0 );
}
int ip_route(char *Buffer,struct Global *g)
{
int Adresse ;
int Ligne ;
int Gateway ;
int Masque ;
int rc ;
struct Interface *pI ;
char arg0[80],arg0B[80],arg1[80],arg2[80],arg3[80],arg4[80] ;
fprintf(stderr,"Entree ip_route\n") ;
bzero(arg0,sizeof(arg0));
bzero(arg1,sizeof(arg1));
bzero(arg2,sizeof(arg0));
bzero(arg3,sizeof(arg1));
bzero(arg4,sizeof(arg1));
/* Syntaxe 10.1.2.0 255.255.255.0 etho */
sscanf(Buffer,"%s %s %s %s %s %s\n",arg0,arg0B,arg1,arg2,arg3,arg4) ;
if (Ipv4ToInt(arg1,&Adresse)!=-1) /* IP ligne valide ? */
{
char Buf[30] ;
Ipv4ToS(Adresse,Buf) ;
fprintf(stderr,"L'adresse est la suivante %s.\n", Buf ) ;
}
else
{
fprintf(stderr,"Adresse IP 1 non valide \n") ;
return(0) ;
}
if (Ipv4ToInt(arg2,&Masque)!=-1) /* IP ligne valide ? */
{
char Buf[30] ;
Ipv4ToS(Masque,Buf) ;
fprintf(stderr,"L'adresse est la suivante %s.\n", Buf ) ;
}
else
{
fprintf(stderr,"Masque IP non valide \n") ;
return(0) ;
}
/* RechercheInterface(arg3,g->NomInterface ,g->NbrLignes ,&Ligne ) */
pI = RechercheInterfaceNom(arg3,g->pI) ;
if ( pI!=NULL )
{
Ligne = ObtenirLigne(pI) ;
printf("Interface valide %d\n",Ligne) ;
}
else
{
printf("Interface non valide \n") ;
return(0) ;
}
if (Ipv4ToInt(arg4,&Gateway)!=-1) /* IP ligne valide ? */
{
char Buf[30] ;
Ipv4ToS(Gateway,Buf) ;
fprintf(stderr,"L'adresse est la suivante %s.\n", Buf ) ;
}
else
{
fprintf(stderr,"Gateway non valide \n") ;
return(0) ;
}
AjoutEntreeTableRoutage(g->TableRoutage,Adresse, Ligne,Gateway,Masque,& (g->NbrEntrees)) ;
return(1) ;
}
int main(int argc, char *argv[])
{
int rc;
int Desc;
struct sockaddr_in psoo; /* o = origine */
struct sockaddr_in psos; /* s = serveur */
struct sockaddr_in psor; /* r = remote */
int tm;
struct Requete UneRequete;
char Tampon[40];
int Ip, Port;
memset(&psoo, 0, sizeof(struct sockaddr_in));
memset(&psos, 0, sizeof(struct sockaddr_in));
memset(&psor, 0, sizeof(struct sockaddr_in));
printf("Ceci est le serveur\n");
if (argc!=3)
{
printf("ser ser port \n");
exit(1);
}
Desc = CreateSockets(&psoo, NULL, argv[1], atoi(argv[2]), NULL, 0);
if (Desc == -1)
perror("CreateSockets");
else
printf(" CreateSockets : %d \n", Desc);
while(1)
{
tm = sizeof(struct Requete);
rc = ReceiveDatagram(Desc, &UneRequete, tm, &psor);
if (rc == -1)
perror("ReceiveDatagram");
else
fprintf(stderr, "bytes:%d:%s\n", rc, UneRequete.Message);
/***********************************************************************
int Ipv4ToInt(char *s, int *ip);
void Ipv4ToS(int ip, char *s);
int GetIP(struct sockaddr_in *pin);
int GetPort(struct sockaddr_in *pin);
***********************************************************************/
Ip = GetIP(&psor);
Port = GetPort(&psor);
memset(Tampon, 0, sizeof(Tampon));
Ipv4ToS(Ip, Tampon);
printf("Adresse Ip du client %s : Port %d \n", Tampon, Port);
/* reponse avec psor qui contient toujours l'adresse du dernier client */
UneRequete.Type = Reponse;
strcat(UneRequete.Message, " Client");
rc = SendDatagram(Desc, &UneRequete, sizeof(struct Requete), &psor);
if (rc == -1)
perror("SendDatagram:");
else
fprintf(stderr, "bytes:%d\n", rc);
}
}
int main(int argc, char *argv[])
{
int rc;
int Desc;
int tm;
int Port, Ip;
char Tampon[80];
int returned_from_longjump;
unsigned int time_interval;
int ret;
int Compteur = 0;
struct sockaddr_in psoo; /* o = origine */
struct sockaddr_in psos; /* s = serveur */
struct sockaddr_in psor; /* r = remote */
struct Requete UneRequete;
char *pret;
memset(&psoo, 0, sizeof(struct sockaddr_in));
memset(&psos, 0, sizeof(struct sockaddr_in));
memset(&psor, 0, sizeof(struct sockaddr_in));
if (argc!=5)
{
printf("cli client portc serveur ports\n");
exit(1);
}
Desc = CreateSockets(&psoo, &psos, argv[1], atoi(argv[2]), argv[3], atoi(argv[4]));
if (Desc == -1)
perror("CreateSockets:");
else
fprintf(stderr, "CreateSockets %d !!!!\n", Desc);
Ip = GetIP(&psoo);
Port = GetPort(&psoo);
memset(Tampon, 0, sizeof(Tampon));
Ipv4ToS(Ip, Tampon);
printf("Adresse Ip du client %s : Port %d \n", Tampon, Port);
Compteur = 0;
printf(" GetPid %d \n", getpid());
while(1)
{
/* ici setjmp */
returned_from_longjump = sigsetjmp(env, 1); /* <> 0 pour sauver le masque, ne surtout pas utiliser setjmp */
if (returned_from_longjump!= 0)
switch (returned_from_longjump) {
case SIGINT:
printf("longjumped from interrupt %d\n", SIGINT);
exit(0);
break;
case SIGALRM:
printf("longjumped from alarm %d\n", SIGALRM);
printf("Alarme numero %d \n", NbrAlarmes);
if (NbrAlarmes==4)
exit(0);
break;
};
signal(SIGINT, signal_handler);
signal(SIGUSR1, signal_handler);
signal(SIGALRM, signal_alarm);
UneRequete.Compteur = Compteur;
UneRequete.Type = Question;
strncpy(UneRequete.Message, "Hello Multiclient", sizeof(UneRequete.Message));
rc = SendDatagram(Desc, &UneRequete, sizeof(struct Requete), &psos);
fprintf(stderr, "Turlututu \n");
if (rc == -1)
perror("SendDatagram");
else
fprintf(stderr, "Envoi du message %d avec %d bytes\n", UneRequete.Compteur, rc);
memset(&UneRequete, 0, sizeof(struct Requete));
tm = sizeof(struct Requete);
time_interval = 5;
ret = alarm(time_interval);
// signal(SIGALRM, signal_alarm);
tm = sizeof(UneRequete);
printf("Ecoute sur le descripeur %d \n", Desc);
rc = ReceiveDatagram(Desc, &UneRequete, tm, &psor);
fprintf(stderr, "raison:%d \n", rc);
pret = strerror(errno);
fprintf(stderr, "Message est : %s \n", pret);
ret = alarm(0);
if (rc == -1)
{
perror("ReceiveDatagram");
}
else
{
fprintf(stderr, "bytes:%d:%s\n", rc, UneRequete.Message);
}
Compteur++;
sleep(5);
}
close(Desc);
}
int main(int argc,char *argv[])
{
int rc ;
struct Physique L ; /* pour eviter un bug curieux !!!!!!!*/
int tm ;
int HLs[100] ;
int HEs[100] ;
char Buffer[50] ;
int HL,HE ;
int descphys ;
static struct gEvenement gEv ;
int IPR,PORTD ;
bzero(&L,sizeof (struct Physique)) ;
bzero(HLs, sizeof(HLs )) ;
bzero(HEs, sizeof(HEs)) ;
printf("Ceci est le serveur\n") ;
if ( argc!=3)
{
printf("ser ser port \n") ;
exit(1) ;
}
descphys = CreerConnexion(&L,argv[1],atoi(argv[2]),NULL,0) ;
if ( descphys == -1 )
perror("CreerLiaison:") ;
else
printf("Liaison Cree \n") ;
HLs[descphys]=1 ;
HLs[0] = 1 ;
rc = PrepareEvenement(&gEv,HLs,HEs,100,300,0 ) ;
if ( rc== -1 )
perror("PrepareEvenement:") ;
while(1)
{
rc = AttendreEvenement(&gEv,&HL,&HE) ;
if ( rc == -1 )
perror("AttendreEvenement:") ;
else
printf("Event:%d\n",HL) ;
if ( HL == 0 )
{
char Buffer[100] ;
fgets(Buffer,sizeof Buffer,stdin) ;
Buffer[strlen(Buffer)]=0 ;
printf("La touche enfoncee est %s \n",Buffer) ;
sleep(10) ;
}
if ( HL == descphys )
{
struct Message Msg ;
tm = sizeof(struct Message) ;
rc = OrigineCouchePhysique(&L,&Msg,&tm ) ;
if ( rc == -1 )
{
perror("OrigineCouchePhysique") ;
return(-1) ;
}
else
printf("bytes:%d:%d + %d : %s\n",rc,Msg.Entier1,Msg.Entier2,Msg.Commentaire ) ;
IPR=IPDistante(&L) ;
PORTD=PortDistant(&L) ;
Ipv4ToS(IPR, Buffer) ;
printf("IP distante %s Port Distant %d \n",Buffer,PORTD ) ;
/* calcul de la r�onse */
Msg.Resultat = Msg.Entier1 + Msg.Entier2 ;
rc = Repondre(&L,&Msg,sizeof(struct Message)) ;
if ( rc == -1 )
{
perror("OrigineCouchePhysique") ;
return(-1) ;
}
else
printf("bytes ecrits :%d\n",rc ) ;
}
}
}
void CoucheLiaison(struct Global *g)
{
int rc ;
/* static char Buffer[TBUFFERTRAME] ; */
static struct Trame UneTrame ;
static int Numero = 0 ;
int NL ;
int EHL,EHE ;
int MacD ;
// Ancienne Position de PrepareEvenement
while(1)
{
rc = PrepareEvenement( &(g->gEv),g->HandleL,g->HandleE,100,300,0 ) ;
/* on s'endort en attendant que quelque chose se produise */
printf(">>>") ; fflush(stdout) ;
rc = AttendreEvenement(&(g->gEv),&EHL,&EHE) ;
printf("Liaison:EHL %d\n",EHL) ;
if ( rc == 0 )
printf("Liaison:Timeout !!!!!\n") ;
else
if ( rc == -1 )
{
printf("Liaison:Erreur attendre Evenement !!!\n") ;
exit(0) ;
}
else
if ( EHL == 0 ) /* Frappe du clavier */
{
char Chaine[200] ;
fgets(Chaine,sizeof Chaine,stdin ) ;
Interpreteur(Chaine,g) ;
}
else
if ( EHL != 0 ) /* evenement reseau */
{
int tm=sizeof(UneTrame) ;
struct Interface *pUneI ;
pUneI=RechercheInterfaceDesc( EHL,g->pI) ;
if ( pUneI == NULL )
{
fprintf(stderr,"Liaison: Pas d'interface pour evenement %d\n",EHL ) ;
exit(0) ;
}
else
fprintf(stderr,"l'interface a ete trouvee \n") ;
rc = OrigineCouchePhysique(ObtenirPhys(pUneI),&UneTrame,&tm) ;
/* memcpy(Buffer,UneTrame.Buffer,sizeof Buffer) ; */
fprintf(stderr,"Liaison:%d bytes lus\n",rc) ;
/* Pour simplifier le code : la mac = IP */
NL = ObtenirLigne(pUneI) ;
if ( UneTrame.MacDestination.Numero == ObtenirIP(pUneI) )
{
rc = CoucheReseau(RECEPTION,UneTrame.Buffer,sizeof (UneTrame.Buffer),&NL,g,&MacD) ;
}
else
{
char TamponSource[30] ;
char TamponDest[30] ;
bzero(TamponDest,sizeof(TamponDest)) ;
bzero(TamponSource,sizeof(TamponSource)) ;
Ipv4ToS(UneTrame.MacSource.Numero,TamponSource) ;
Ipv4ToS(UneTrame.MacDestination.Numero,TamponDest) ;
fprintf(stderr,"Liaison:La mac recue ne correspond pas Source FF:%s , dest FF:%s \n",TamponSource ,TamponDest) ;
/* Ajouter ici La mac source */
fprintf(stderr," Le paramêtre gateway de l'émetteur est sans doute faux \n") ;
}
}
else
printf("Non connu !!!!!\n") ;
/* faut il emettre une trame sur une ligne */
if ( rc == ROUTAGE || rc==ENVOI )
{
char Buffer[20] ;
struct Interface *pUneI ;
bzero(Buffer,sizeof(Buffer)) ;
/*---- On r�crit vers l'interface correspondante ----*/
UneTrame.MacDestination.Constructeur = 0xFF ;
UneTrame.MacDestination.Numero = MacD ; /* je n'ai pas implement�arp */
Ipv4ToS(UneTrame.MacDestination.Numero,Buffer ) ;
fprintf(stderr,"Liaison;FF:%s\n",Buffer);
fprintf(stderr,"Liaison: La Ligne de Sorite est %d \n",NL ) ;
pUneI = RechercheInterfaceLigne(NL,g->pI) ;
if ( pUneI == NULL )
{
fprintf(stderr,"Liaison: Cette ligne n'existe pas !!!\n") ;
exit(0) ;
}
rc = VersCouchePhysique(ObtenirPhys(pUneI),&UneTrame,sizeof(UneTrame)) ;
if (rc == -1 )
perror("Motif:") ;
else
fprintf(stderr,"Liaison: %d bytes �rits vers FF:%s\n",rc,Buffer) ;
}
}
}
int CoucheReseau(int ev,char Buffer[],int tBuffer,int *Ligne,struct Global *g,int *MacD)
{
static int Numero ;
int res ;
struct Paquet *pp ;
struct Segment *ps ;
int LigneEntree ;
int Regle ;
static int IPS ;
static int IPD ;
char Buffer1[30], Buffer2[30] ;
struct Interface *pUneI ;
fprintf(stderr,"Reseau:Debut\n") ;
switch(ev)
{
case MENU:
case RECEPTION:
LigneEntree = *Ligne ;
fprintf(stderr,"Ligne Entree %d \n",LigneEntree) ;
pp = (struct Paquet*) Buffer ;
Ipv4ToS(pp->IPSource,Buffer1 ) ;
Ipv4ToS(pp->IPDestination,Buffer2 ) ;
fprintf(stderr,"Reseau:%s %s %d\n",Buffer1,Buffer2,
pp->Numero ) ;
/* *Ligne contient l'interface par laquelle on rentre */
pUneI = RechercheInterfaceLigne(*Ligne,g->pI) ;
if ( pUneI == NULL )
{
fprintf(stderr,"Pas d'interface pour la ligne %d!",LigneEntree) ;
exit(0) ;
}
if (FiltragePaquet(LigneEntree,g->TableFiltrage,g->NbrRegles,pp,&Regle))
{
res = NEAN ;
fprintf(stderr,"Filtrage :Reseau Regle: %d DROP Ligne entree:%d ", Regle ,LigneEntree ) ;
fprintf(stderr,"IPS: %s IPD: %s ",Buffer1,Buffer2 ) ;
ps = ( struct Segment * ) pp->Buffer ;
fprintf(stderr,"Port Source: %d Port Destination: %d ",ps->PortSource ,ps->PortDestination ) ;
fprintf(stderr,"\n") ;
}
else
{
/* Il faut traiter les paquets non filtré */
/* Chercher une interface pingée */
pUneI = g->pI ;
while( pUneI)
{
fprintf(stderr,"Reseau: Recherche d'interface pingee\n");
if ( pp->IPDestination == ObtenirIP(pUneI))
{
/* traiter ici le ping */
int *Code ;
Code =(int*) pp->Buffer ;
if ( *Code == ICMPECHO )
{
int tempo ;
fprintf(stderr,"Reception ICMP ECHO et generation ICMP Response \n") ;
tempo = pp->IPSource ;
pp->IPSource = pp->IPDestination ;
pp->IPDestination = tempo ;
*Code = ICMPRESPONSE ;
break ;
}
}
pUneI = InterfaceSuivante(pUneI) ;
}
*Ligne = Routage(g->TableRoutage,g->pI,g->NbrEntrees,pp->IPDestination,MacD) ;
// A verifier seule la ligne de sortie est bonne Paramêtre Regle , ligne entrée pas bon
fprintf(stderr,"Routqge Regle: %d ACCEPT Lin %d Lout: %d ",Regle, LigneEntree,*Ligne ) ;
fprintf(stderr,"IPS: %s IPD: %s ",Buffer1,Buffer2 ) ;
ps = ( struct Segment * ) pp->Buffer ;
fprintf(stderr,"Port Source: %d Port Destination: %d ",ps->PortSource ,ps->PortDestination ) ;
fprintf(stderr,"\n") ;
if (*Ligne) /* Une ligne valide est fournie */
res = ROUTAGE ;
else
res = NEAN ;
}
break ;
default:
res = NEAN ;
break ;
}
fprintf(stderr,"Reseau:Fin\n") ;
return res ;
}
enum Evenements CoucheReseau( enum Evenements ev,char Buffer[],int tBuffer,struct Global *g)
{
static int Numero ;
int res ;
struct Paquet *pp ;
int IPDestination ;
int IPD ;
int Protocole ;
/********************* Phase Montante *******************************************************/
fprintf(stderr,"Reseau:Debut\n") ;
redo:
pp = (struct Paquet *) Buffer ;
switch(ev)
{
case MENU:
case RECEPTION:
{
char Buffer1[30], Buffer2[30] ;
Ipv4ToS(pp->IPSource,Buffer1 ) ;
Ipv4ToS(pp->IPDestination,Buffer2 ) ;
fprintf(stderr,"Reseau:%s:%s: %d \n",Buffer1,Buffer2,pp->Numero) ;
if ( pp->IPDestination == g->IPInterface )
{
Protocole = pp->Protocole ;
if ( Protocole == ICMP )
{
int *code ;
code = (int * ) pp->Buffer ;
if ( *code == ICMPRESPONSE )
{
fprintf(stderr,"Reseau: Reception ICMPRESPONSE \n") ;
res = CoucheTransport(RECEPTIONICMP,pp->Buffer,sizeof(pp->Buffer),&Protocole,pp->IPSource,&IPDestination,g) ;
}
else
if (*code == ICMPECHO )
{
fprintf(stderr,"Reseau: Reception ICMPECHO et generation ICMP RESPONSE \n") ;
/* Generation de la reponse */
*code = ICMPRESPONSE ;
IPDestination = pp->IPSource ;
Protocole = ICMP ;
res = ENVOI ;
}
else
{
fprintf(stderr,"Reseau: Code ICMP Inconnu \n") ;
res = NEAN ;
}
}
else
res = CoucheTransport(ev,pp->Buffer,sizeof(pp->Buffer),&Protocole,pp->IPSource,&IPDestination,g) ;
}
else
{
printf("Reseau:Adresse de destination non connue \n") ;
res = NEAN ;
}
}
break ;
default:
res = NEAN ;
}
fprintf(stderr,"reseau:phase descendante\n") ;
switch(res)
{
case ENVOI:
{
res = GenerationPaquet(pp,IPDestination,Protocole,pp->Buffer, g ) ;
if (res==RECEPTION )
{
ev = res ;
goto redo;
}
break ;
}
case NEAN:
break ;
default:
fprintf(stderr,"Reseau: Option non reconnue\n") ;
break ;
}
fprintf(stderr,"Reseau:Fin\n") ;
return res ;
}
void CoucheLiaison(struct Global *g)
{
int rc ;
enum Evenements rce ;
static char Buffer[TBUFFERTRAME] ;
static struct Trame UneTrame ;
int EHL,EHE ;
int Redo = 1 ;
while(Redo)
{
if (g->WaitReceive )
g->HandleL[0] = 0 ; /* En Mode WaitReceive le clavlier est désactivé */
else
g->HandleL[0] = 1 ;
rc = PrepareEvenement( &(g->gEv),g->HandleL,g->HandleE,100,300,0 ) ;
/* on s'endort en attendant que quelque chose se produise */
if (!VericationParametreTransport(g) )
printf("ENCODEZ VOS PARAMETRES DE TRANSPORT !!!!!\n") ;
printf(">>>");fflush(stdout);
rc = AttendreEvenement(&(g->gEv),&EHL,&EHE) ;
fprintf(stderr,"Liaison:EHL %d\n",EHL) ;
if ( rc == -1 )
{
printf("Liaison:Erreur attendre Evenement \n");
exit(0) ;
}
else
if ( rc == 0 )
printf("Liaison:Timeout!!!!\n") ;
else
{
/* gestion de l'evenement */
if ( EHL == 0 ) /* Frappe du clavier */
{
/* appel à l interpreteur */
char Chaine[50] ;
fgets(Chaine,sizeof(Chaine),stdin) ; /* Evitez le getchar() !!!!! */
Chaine[strlen(Chaine)-1]=0 ; /* On supprime le newline */
fprintf(stderr,"La touche press� est %s \n",Chaine) ;
rc = Interpreteur( Chaine, g) ;
if ( rc==0 )
{
fprintf(stderr,"erreur de Syntaxe \n") ;
printf("erreur de Syntaxe \n") ;
}
}
else
if ( EHL != 0 ) /* evenement reseau */
{
int tm=sizeof(UneTrame) ;
/* Corriger ici */
if ( g->WaitReceive)
{
Redo = 0 ;
g->WaitReceive = 0 ;
}
rc = OrigineCouchePhysique(&(g->TPhys),&UneTrame,&tm) ;
memcpy(Buffer,UneTrame.Buffer,sizeof(UneTrame.Buffer)) ;
fprintf(stderr,"Liaison::%d bytes lus\n",tm) ;
if (UneTrame.MacDestination.Numero== g->IPInterface )
{
rce = CoucheReseau(RECEPTION,Buffer,sizeof Buffer,g) ;
}
else
{
char BufferIP[20] ;
Ipv4ToS(UneTrame.MacDestination.Numero,BufferIP ) ;
fprintf(stderr,"Liaison la mac n'est pas bonne FF:%s \n",BufferIP) ;
rce=NEAN ;
}
}
else
printf("Non connu !!!!!\n") ;
/***En envoi de la trame *******************************************/
if ( rce == ENVOI ) /* Bug si mauvaise position */
{
rc = GenerationTrame(&UneTrame,Buffer,g ) ;
}
}
}
};
