Bonjour,

Je suis en train d developper une petite application permettant a un client de se connecter a un serveur puis de recuperer des fichiers. J'utilise le protocole TCP. Un probleme intervient lorsque j'essaie de transferer des fichiers de plusieur ko.
Le serveur effectue bien l'envoi de tous les octets du fichiers (la somme des retours du send() est égale a la taille du fichier) mais le client reste bloqué sur un recv() car a un moment dans la boucle while, la valeur de retour de recv n'est pas la taille du tampon (256, 128 ou autres) mais une valeur tres faible, generalement 6.

Voila un bout de code montrant comment se fait l'envoi coté serveur et la reception coté 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
 
//********Coté serveur**************
				long tailleFichier = getSize(nom);  //renvoie la taille du fichier nom
				char msg[256];
				sprintf(msg, "%d", tailleFichier);
				int lgMsg = strlen(msg);
				int snd = send(descBr, msg, lgMsg, 0); //on envoie la taille du fichier au client
 
				//Si le fichier existe on l'expédie au client
				if (tailleFichier != -1)
				{
					//Ouverture du fichier a envoyer
					size_t s = nom.size() + 1;
					char * nomFichier = new char[ s ];
					strncpy( nomFichier, nom.c_str(), s );
					FILE* fichier;
					if((fichier=fopen(nomFichier, "rb")) == NULL)
					{
						cout << "Probleme lors de l'ouverture du fichier." << endl;
					}
 
					//Expedition du fichier
					cout << "Debut de l'expedition du fichier" << endl;
					int octetsEnvoyes = 0;
					int octetsLus;
					char buffer [256];
					while(octetsEnvoyes != tailleFichier)
					{
						octetsLus=fread(buffer, 1, 256, fichier);
						snd = send(descBr, buffer, octetsLus, 0);
						octetsEnvoyes = octetsEnvoyes + snd;
				         }
 
					//On fini par fermer le fichier
					fclose(fichier);
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
 
//*************Coté client****************
        char  tamponReception [256];
	int lgReception = sizeof(tamponReception);
	int retourRecv = recv (descLocale, tamponReception, lgReception, 0); //recption de la taille du fichier
	tamponReception[lgReception] = '\0';
	long tailleFichier= atoi (tamponReception);
 
	//On crée et ouvre le fichier que va nous envoyer le serveur
	FILE* fichier;
	if((fichier=fopen("./monFic", "wb")) == NULL)
	{
		cout << "impossible de creer le fichier" << endl;
	}
	long octetsRecus = 0;
	while(octetsRecus != tailleFichier)
	{
			retourRecv=recv(descLocale,tamponReception, 256, 0);
			octetsRecus = octetsRecus + retourRecv;
			fwrite(tamponReception, 1, retourRecv, fichier);
	}
	fclose(fichier);
Dès que je transfere des fichiers de quelques ko un des buffers n'est rempli qu'a 5 ou 6 char coté client en plein milieur de la transmission alors qu'il devrait etre de 256. J'ai testé avec des valeur beaucoup plus faible de l'ordre de 16 ou 32 et ça plante toujours dès que le fichier est trop gros :/
Quelques remarques bizarre :
- si je met la taille de mon buffer à une valeur <= 7 là c'est ok meme pour des fichiers plus gros (comme un mp3 de qques MO) mais c'est horriblement long;
- lorsque je teste sur des petits fichiers (sources de mon prog par exemple), ça marche tout le temps meme avec des buffers importants
- Pour un meme fichier faisant planter, le buffer de taille anormalement rempli est toujours de la meme taille (5 ou 6)
Je suis dessus depuis hier et rien a faire : j'etais persuader qu'en tcp il n'y avait pas de perte de donnée :/