Projet client/serveur

**steven6** · 25/02/2014, 22h06

Bonjour,

J'ai un petit projet à effectuer en langage C. Il s'agit d'un client/Serveur.
Le client doit pouvoir envoyer des messages textuel, ces messages sont enregistrés dans un fichier côté serveur.
Le client doit pouvoir à tout moment demander de recevoir le fichier contenant des messages.

Je dois obligatoirement utiliser les socket en TCP. Jusqu’à présent j'utilise les fonction read et write pour écrire sur la socket.

Pour le moment je n'ai qu'une base mais peut être que quelqu'un pourrait m'aider à avancer ce petit projet que je dois rendre rapidement. (Que ce soit par email ou MP...)

En espérant que quelqu'un pourra m'aider car j'ai pas mal de difficultés à faire ce projet.

Merci d'avance.

Je mets un aperçu de ce que j'ai fais pour le moment. Mais même cela n'est pas totalement fonctionnel.

client :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
/* Lancement d'un client :  client_tcp port serveur */
/* compilation : gcc -o client_tcp client_tcp.c   */
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <netdb.h>
#include <sys/socket.h>
#include <netinet/in.h>
 
#define BUFFSIZE 256
#define TRUE 1
 
 
FILE* ouvertureFichier(char * nom, char * droit)
{
	FILE * fd =NULL;
	fd = fopen(nom, droit);
	if (fd == NULL)
	{
		printf("Pb ouverture fichierTweet\n");
		perror("Erreur: ");
		exit(-6);
	}
	return fd;
 
}
 
int main (int argc, char *argv[])
{
 
	int sock, nbOctetLu = 0;
	char buf[256];
	struct sockaddr_in adresse_serveur;
	struct hostent *hote;
	unsigned short port;
	int fd, n=1,ecrit;
	FILE * fichier = NULL;
	char message[140];
	int selectionMenu =0;
	int envoi;
 
	port = 4444;
	/* creation de la socket locale */
	if ((sock = socket(AF_INET,SOCK_STREAM,0)) == -1)
	{
  		perror("socket");
  		exit(1);
	}
 
	/* recuperation de l'adresse IP du serveur (a partir de son nom) */
 
	if ((hote = gethostbyname(argv[1])) == NULL)
	{
  		perror("gethostbyname");
  		exit(2);
	}
 
	/* preparation de l'adresse du serveur */
	adresse_serveur.sin_family = AF_INET;
	adresse_serveur.sin_port = htons(port);
	bcopy(hote->h_addr, &adresse_serveur.sin_addr, hote->h_length);
 
	//printf("L'adresse en notation pointee %s\n", inet_ntoa(adresse_serveur.sin_addr));
	fflush(stdout);
 
	/* demande de connexion au serveur */
	if (connect(sock, (struct sockaddr *) &adresse_serveur, sizeof(adresse_serveur)) == -1)
		{
	  	perror("connect");
	  	exit(3);
		}
 
	/* le serveur a accepte la connexion */
	printf("connexion acceptee\n");
	fflush(stdout);
	int flag =0;
	/* ouverture du fichier a lire */
	//if ((fd = open("tweet", O_RDONLY)) == -1)
	fichier= fopen("tweet","w");
	if(fichier == NULL)
  	{
  		printf("Pb avec tweet\n");
  		perror("Erreur: ");
  		exit(-4);
  	}
 
	while(TRUE)
	{
		printf("Menu : \n1-Envoyer un Tweet\n2-Recevoir le fichier contenant les tweets\n3-quitter\nChoix : ");
		scanf("%d",&selectionMenu);
		//selectionMenu =1;
		if(write(sock,&selectionMenu,sizeof(int)) == 0)
		{
			perror("Write");
 
		}
		///Test
		if(selectionMenu == 1)
		{
			printf("************************* Envoi de tweets *****************\n");
			printf("Pour arreter la saisie tapez \"q\"\n");
			while(n)
			{
 
				printf("Veuillez entrer votre tweet : \n");
				fgets(message,sizeof(message),stdin);
				if(strlen(message) <141)
				{
					//Si le message commence par 'q' et fait 2 caractères ('q\0')
					if(message[0]=='q' && strlen(message)==2)
					{
						strcpy(buf, message);
						if (write(sock, buf, BUFFSIZE) == -1)
						{
					  		perror("write1");
					  		exit(4);
						}
						printf("vous avez demandé la fin de la saisie\n");
						n=0;
					}
					else 
					{
 
						strcpy(buf, message);
						if (write(sock, buf, BUFFSIZE) == -1)
						{
					  		perror("write1");
					  		exit(4);
						}
						printf("Message envoye\n");
 
						fflush(stdout);
 
					}
				}
				else
					printf("La taille maximale d'un tweet est de 140 caractères !\n");
 
 
			}	
 
		}
 
		if(selectionMenu == 2)
		{
 
			printf("************************* Reception du fichier *****************\n");
			fichier=ouvertureFichier("tweet","a+");
			if(fichier == NULL)
  			{
		  		printf("Pb avec tweet\n");
		  		perror("Erreur: ");
		  		exit(-4);
  			}
  			while(nbOctetLu = read(sock, buf,BUFFSIZE)>0)
			{
 
				printf("nbOctetLu : %d", nbOctetLu);
				if(nbOctetLu < 0)
				{
					perror("Erreur read");
					exit(-2);
				}
				printf("%s\n",buf);
				fprintf(fichier,buf, nbOctetLu);
 
			}
 
				printf("Fichier recu\n");
 
				fclose(fichier);
 
		}
		if(selectionMenu == 3)
		{
			fdFichierTweet = ouvertureFichier("fichierTweet","r");
			char ligne[200];
			printf("/*********************** Ensemble des tweets reçus ***********************/\n");
			while(fgets(ligne,200,fdFichierTweet)!= NULL)
			{
				printf("\t- %s", ligne);
			}
			fclose(fdFichierTweet);
 
		}
		if(selectionMenu == 4)
		{
			printf("************************* Terminaison du programme *****************\n");
			return 1;
		}
 
		if(selectionMenu !=1 || selectionMenu !=2 || selectionMenu != 3 || selectionMenu != 4)
		{
			printf("Veuillez saisir 1-2 ou 3\n");
		}
 
	}
 
}

serveur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include <unistd.h>
#include <errno.h>
#include <signal.h>
#include <sys/types.h>
#include <netdb.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <time.h>
 
 
#define TRUE 1
#define BUFFSIZE 256
 
FILE* ouvertureFichier(char * nom, char * droit)
{
	FILE * fd =NULL;
	fd = fopen(nom, droit);
	if (fd == NULL)
	{
		printf("Pb ouverture fichierTweet\n");
		perror("Erreur: ");
		exit(-6);
	}
	return fd;
 
}
 
int main(int argc, char* argv[])
{
	int socket_RV, socket_service;
	struct sockaddr_in adresseLocale,adresseClient;
	int lgAdresseLocale, lgAdresseClient;
	struct hostent *hote;
	unsigned short port;
	FILE * fdFichierTweet = NULL;
	int nbOctetsLus=0, nbTotalTweet=0, nbTweetAffiches=0;
	char buffer[BUFFSIZE];
	int selectionMenu = 0;
	int nbClients =0;
	int n;
	int nbEcrit=0;
 
	/* creation de la socket de RV */
	if ((socket_RV = socket(AF_INET, SOCK_STREAM, 0)) == -1)
	{
  	perror("Erreur socket");
  	exit(0);
	}
 
	/* preparation de l'adresse locale */
	port = 4444;
 
	adresseLocale.sin_family = AF_INET;
	adresseLocale.sin_port = htons(port);
	adresseLocale.sin_addr.s_addr = htonl(INADDR_ANY);
	lgAdresseLocale = sizeof(adresseLocale);
 
	/* attachement de la socket a l'adresse locale */
	if ((bind(socket_RV, (struct sockaddr *) &adresseLocale, lgAdresseLocale)) == -1)
	{
  	perror("Erreur bind");
  	exit(1);
	}
	/* declaration d'ouverture du service */
	if (listen(socket_RV, 1)==-1)
	{
  	perror("Erreur listen");
  	exit(2);
	}
	printf("Attente de connexion...\n");
 
	while(TRUE)
	{
		fflush(stdout);
		lgAdresseClient = sizeof(adresseClient);
		socket_service=accept(socket_RV, (struct sockaddr *) &adresseClient, &lgAdresseClient);			
		if(socket_service==-1)
		{
			perror("Erreur accept");
			exit(3);
		}
		nbClients++;
 
		/* un client est arrive */
		printf("nb clients : %d\n", nbClients);
	  	printf("connexion acceptee\n");
	  	fflush(stdout);	
		/*if(nbClients >20)
		{
 
		}
		else
		{*/
			if(fork() == 0)
			{
				int selectionMenu =0 ;
				int reception;
				int nbLus=0;
				close(socket_RV);
				printf("Attente du choix du menu : ");
				nbLus=read(socket_service, &selectionMenu, sizeof(int));
				printf("%d\n", selectionMenu);
				printf("nbLus : %d\n", nbLus);
 
				if(selectionMenu == 1)
				{
					printf("Reception de message(s)\n");
					while(nbOctetsLus = read(socket_service,buffer,BUFFSIZE)>0)
					{
						printf("recu : %s\n", buffer);
						/*if(nbOctetsLus == 0)
						{	
							continue;
						}*/
						if(buffer[0]=='q' && strlen(buffer)==2)
						{
							printf("coucou\n");
							break;
						}
 
						if(nbOctetsLus< 0) 
						{
							perror("Erreur read");
							exit(-7);
						}
						fdFichierTweet = ouvertureFichier("fichierTweet","a+");
						printf("%s : %s\n",inet_ntoa(adresseClient.sin_addr),buffer);
						n = sizeof(buffer);
						fprintf(fdFichierTweet,"%s ",inet_ntoa(adresseClient.sin_addr));
		      				fprintf(fdFichierTweet, buffer, n);
						//fclose(fdFichierTweet);
					}
 
				}
 
				if(selectionMenu == 2)
				{
					//int nbFois = 0;
					fdFichierTweet = ouvertureFichier("fichierTweet","r+");
					printf("Envoi du contenu du fichier en cours...\n");
					while(nbOctetsLus =  read(fileno(fdFichierTweet),buffer,BUFFSIZE)>0)
					{
						//printf("%s\n", buffer);
						nbEcrit=write(socket_service,buffer, 256);
						//printf("nb Octets : %d\n",nbEcrit);
 
					}
					//close(socket_service);	
					printf("Envoi du fichier de tweet\n");
					//fclose(fdFichierTweet);
 
				}
 
 
			}
 
 
 
		//}
 
	}
 
return 1;
 
 
}

**imperio** · 26/02/2014, 13h09

Le principe d'un forum est que l'aide puisse etre accessible a tous, aucun interet de t'aider donc si c'est par MP ou par mail. Autre chose : tes imperatifs de rendu on s'en fiche, ce n'est pas notre probleme.

Je dois obligatoirement utiliser les socket en TCP. Jusqu’à présent j'utilise les fonction read et write pour écrire sur la socket.

Jusque la rien d'anormal, pour des echanges reseaux necessitant la bonne reception de toutes les donnees, le protocole TCP est celui a utiliser. En ce qui concerne les fonctions read et write, tu pourrais utiliser recv et send si tu veux (cherche leur man sur le net, ca te fera pas de mal).

Pour ce qui est de ton probleme, il n'y a rien de bien complique. En general, dans les echanges reseaux j'aime bien faire de cette facon :

- le premier octet (ou plus si besoin) est l'identifiant (le type du message en gros)
- les 4 octets suivants sont la taille du message qui va suivre (ca me permet d'allouer la memoire et de lire les donnees en une fois en gros)
- les donnees

Dans ton case, tu pourrais par-exemple decider que l'id 0 veut dire que tu vas recevoir un message et l'id 1 voudrait dire que tu vas recevoir un fichier. Dans le deuxieme cas, il te suffit d'ouvrir un fichier (tu peux meme t'amuser a passer le nom dans ton message) et d'ecrire tout ce que tu vas recevoir dedans.

**steven6** · 26/02/2014, 21h27

Ok, je te remercie pour ton aide.

Je n'ai pas pensé structurer mes envois de données de cette manière. Je vais essayer et voir pour le faire avec send et recv.

**imperio** · 26/02/2014, 23h34

Ce n'etait qu'un exemple, tu peux tres bien t'y prendre autrement ! Par-exemple tu peux decider que lorsque tu recois un '\n' ou un '\0' c'est la fin du message. Par-contre je pense qu'utiliser send et recv est une bonne idee etant donne que leur prototype est quasiment le meme (les sockets sont un type a part entier sous windows si je me souviens bien).

**skeud** · 27/02/2014, 15h24

Envoyé par imperio

Par-contre je pense qu'utiliser send et recv est une bonne idee etant donne que leur prototype est quasiment le meme (les sockets sont un type a part entier sous windows si je me souviens bien).

Effectivement, utilisé read et write n'est absolument pas portable:
read et write prennent un int en paramètre, sous UNIX, les sockets sont stockées sous la formes d'int donc ça ne pose pas de soucis.
Par contre sous windows c'est un type à part entière (SOCKET). Voici un petit lien de dvp pour aidé la compréhension des socket windows.

Pour ton échange entre client et serveur, j'utilise cette méthode:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
struct packet {
char code;
int size;
char* data;
};
 
//envois d'un packet (struct packet* pc)
sendv(socket, pc, sizeof(*pc)+pc->size, 0);
 
//reception d'un packet
struct packet* receiveFrom(Socket socket) {
struct packet* pc = malloc(sizeof(*pc));
if (pc) {
  if (recv(socket, pc, sizeof(*pc), 0) == sizeof(*pc)) {
    pc->data = malloc(pc->size);
    if (pc->data && recv(socket, pc->data, pc->size, 0) == pc->size)
      return (pc);
    else
      printf("erreur de reception des data");
  }
  else
    printf("erreur de reception du header");
  if (pc->data)
    free(pc->data);
  free(pc);
  }
return (NULL);
}

J'ai repris l'exemple de VDD pour ce bout de code, mais si tu as besoin d'envoyé d'autre type de données, le code est le meme, il suffit juste de bien mettre ta variable size à jour en fonction des données que tu envois. (La variable code, n'est pas une obligation non plus).

Voili voilou

.

Projet client/serveur

Réseau C

Vue hybride

Discussions similaires

Partager

Partager