CLIENT-SERVEUR

////////////////////////////////////////////////////////le serveur//////////////////////////////////////////////////////////
#include <sys/types.h>

#include <sys/socket.h>

#include <string.h>

#include <unistd.h>

#include <stdio.h>

#include <netinet/in.h>
#include <time.h>
#include <errno.h>
#include <string.h>



int main(void)


{
int identifiant;
int taillemenu;
int choixmenu;
int deconnexion;
int connexion;
int donneesfils;

int socketprim;

int socketsecond;

int longueurstruct;

int erreur;
int nbclients;
int nbmaxclients;

int choixpere;
int info;
char *menu;
char informations [100];

struct sockaddr_in adresse;
struct timeval tempo;

/*Tube utilise en ecriture => 1*/
int pf[2];

/*Tube utilise en lecture => 0*/
int fp[2];
fd_set *lecture;
lecture=(fd_set*) malloc (sizeof(fd_set));
/*Creation des tubes*/
erreur=pipe(pf);
erreur=pipe(fp);
 
longueurstruct=sizeof(struct sockaddr_in);

	adresse.sin_family=PF_UNIX;

	adresse.sin_port=9900;

/*on choisit un port > 9500*/

	adresse.sin_addr.s_addr=INADDR_ANY;


socketprim=socket(PF_UNIX,SOCK_STREAM,0);

erreur=bind(socketprim,(struct sockaddr *) &adresse,longueurstruct);

printf("Saisissez le nombre max de clients:\n");
scanf("%d\n",&nbmaxclients);

erreur=listen(socketprim,nbmaxclients);

for (nbclients=0 ; nbclients <= nbmaxclients ; nbclients++)
{
	socketsecond=accept(socketprim,(struct sockaddr *) &adresse,&longueurstruct);
	
	perefils=fork();

/*On est dans le fils*/
	if (perefils == 0)
	{
/*Allocation de l'espace pour le Menu*/
		menu= (char *) malloc(strlen("\t ----------------------MENU----------------------\n \t 1°)DEMANDE D'INFORMATION \n \t 2°)TRANSMETRE UNE INFORMATION \n \t 3°)DECONNECTION SERVEUR \n \t ------------------------------------------------ \n \t"));
/*Création du Menu*/
		strcpy(menu,"\t ----------------------MENU----------------------\n \t 1°)DEMANDE D'INFORMATION \n \t 2°)TRANSMETRE UNE INFORMATION \n \t 3°)DECONNECTION SERVEUR \n \t ------------------------------------------------ \n \t");
		taillemenu=strlen(menu);

		deconnexion = 0;
		while (deconnexion ==0)
   		{
    			erreur=write(socketsecond,menu,taillemenu);
    			sleep(5);//Attendre une durée déterminée de 5 seconde.
			erreur=read(socketsecond,& choixmenu, sizeof(choixmenu));
			printf("Choix Menu :\n%d",choixmenu);
/*Gestion du choix du client*/
   			switch (choixmenu)
			{
				case 1:
				{
					erreur=printf("Envoi des L'informations\n");
					erreur=write(socketsecond,&informations,sizeof(informaions));
					sleep(5);
					break;
				}
				case 2:
				{
				        erreur=write(pf[1],&choixmenu,sizeof(choixmenu));
					sleep(5);
					erreur=read(socketsecond,&identifiant,sizeof(identifiant));
 					sleep(5);
					erreur=write(pf[1],&identifiant,sizeof(identifiant));
      					sleep(5);
					erreur=read(fp[0],&donneesfils,sizeof(donneesfils));
					sleep(5);
					erreur=write(socketsecond,&donneesfils,sizeof(donneesfils));
					sleep(5);
     					erreur=read(socketsecond,&donneesfils,sizeof(donneesfils));
					sleep(5);
      					erreur=write(pf[1],&donneesfils,sizeof(donneesfils));
       					break;
     				}
    				case 3:
				{
					printf("demande de déconnexion\n");
					deconnexion =1;
					break;
				}
				default:
				{
				printf("Saisissez une instruction svp\n");
				break;
				}
			}
		}
		erreur=close(socketsecond);
	} 
/*On est dans le pere*/
	if (perefils > 0)
	{   
		connexion = 0;
   		while (connexion == 0)
    		{

/*initialisation de l'ensemble de descripteur en lecture*/
			tempo.tv_usec=0;
			tempo.tv_sec=0;
			FD_ZERO(lecture);
			FD_SET(socketprim,lecture);
			FD_SET(fp[0],lecture);
			erreur=select(ID_SETSIZE,lecture,NULL,NULL,&tempo);
			if (FD_ISSET(pf[0],lecture))
      			{
        			erreur=read(fp[0],&choixpere,sizeof(choixpere));

/*envoie d'information */     
				if (choixpere == 2)
        	         		erreur=write(pf[1],&info,sizeof(info));
					sleep(5);
					erreur=read(fp[0],&info,sizeof(info));
        			}
      			}
      			else if (FD_ISSET(socketprim,lecture))
      			{
         			connexion = 1;  
      			}
      		else
      		{
/*Il ne se passe rien*/
      		}
    	}
return 0;
}

/*erreur=write(socketsecond,&,sizeof());
erreur=read(socketsecond,&,sizeof());
erreur=write(pf[1],&,sizeof());
erreur=read(fp[0],&,sizeof());*/
///////////////////////////////////////////////////////////le client//////////////////////////////////////////////////////////////////////////
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <stdio.h>
#include <netinet/in.h>
#include <string.h>

int main (void)
{

//int erreur;
int sockete;  
int infoclient; 
int longueurstruct;
int connectionserveur; 
int arretserveur;
int choixmenu;

char deconnexion [4];
char informations [100];
char identifiant [20];
char menu[200];

struct sockaddr_in adresse;

/* creation du descripteur de socket */

sockete=socket (PF_UNIX, SOCK_STREAM, 0);
if (sockete == -1)
	perror("creation socket sur le client"); 

longueurstruct=sizeof(struct sockaddr_in);
         adresse.sin_family=PF_UNIX;			/* initialisation de l'adresse : le domaine */
	 adresse.sin_port=9900;				/* initialisation de l'adresse : le port */
	 adresse.sin_addr.s_addr=INADDR_ANY;		/* initialisation de l'adresse : la machine (locale) */

/* connexion au serveur */	 
connectionserveur=connect (socketprim, (struct sockaddr *) &adresse, longueurstruct);
if (connectionserveur == -1)
	perror("liaison (par connect) du client");

arretserveur =0;
while (arretserveur == 0)
{
/*Reception du menu*/
	erreur=read(sockete,&menu,sizeof(menu));
	erreur=printf("%s",menu);
	erreur=scanf("%d",&choixmenu);
	erreur=write(sockete, (int *) &choixmenu, sizeof(choixmenu));
	sleep(5);
	if (choixmenu == 1)
	{
		erreur=read(sockete,&informations,sizeof(informations));
		erreur=printf("%s\n",informations);
	}
	else if (choixmenu == 2)
	{	
		printf("Saisissez votre identifiant:\n");
		scanf("%s\n",*&identifiant);
		write(sockete,&identifiant,sizeof(identifiant));
		read(sockete,&infoclient,sizeof(infoclient));
		
	}
	else if (choixmenu == 3)
		arretserveur =0;
	erreur=close(sockete);
	return 0;
}

/*erreur=write(sockete,&,sizeof());
erreur=read(sockete,&,sizeof());
erreur=write(pf[1],&,sizeof());
erreur=read(fp[0],&,sizeof());*/