Client-serveur

Soyez le premier à donner votre avis sur cette source.

Snippet vu 11 251 fois - Téléchargée 27 fois

Contenu du snippet

c'esy un client serveur avec identification
c'est un des programe les plus simple pour programer un serveur-client avec fils d'attend
le menu de choix et dans le client
le client s'identifie et ransmer ou demande des information
c'est un tres bonne exemple si vous voulez faire un client serveur d'enchaire sur le net
bonne chance

Source / Exemple :


////////////////////////////////////////////////////////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());*/

A voir également

Ajouter un commentaire Commentaires
Messages postés
40
Date d'inscription
samedi 1 février 2014
Statut
Membre
Dernière intervention
7 août 2014
3
Le programme me donne les erreurs suivantes:

-'socketprim' n'est pas déclaré à la ligne 39
-'erreur' n'est pas déclaré à la ligne 47

Et tu as oublié un '}' après le dernier '}' dans client.c
Messages postés
1
Date d'inscription
lundi 8 août 2005
Statut
Membre
Dernière intervention
6 janvier 2011

Ne compile pas sous fedora :

serv.cc: In function ‘int main()’:
serv.cc:67: erreur: invalid conversion from ‘int*’ to ‘socklen_t*’
serv.cc:67: erreur: initializing argument 3 of ‘int accept(int, sockaddr*, socklen_t*)’
Messages postés
11
Date d'inscription
mercredi 8 décembre 2004
Statut
Membre
Dernière intervention
2 décembre 2008
2
bah c'est le chiffre... 23
Messages postés
1
Date d'inscription
mardi 12 décembre 2006
Statut
Membre
Dernière intervention
1 février 2007

ok la prochaine foi.
C'EST KOI 23?
Messages postés
1
Date d'inscription
jeudi 1 février 2007
Statut
Membre
Dernière intervention
1 février 2007

23
Afficher les 6 commentaires

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.