Problème avec le recv()

Bonjours :)

J'ai un petit soucie avec la fonction recv, explication:

J'ai un tableau de socket clients en global (dans un fichier serveur.c)

j'ai 1 recv dans une 1ere fonction "gestion_client"
j'ai 1 recv dans une 2eme fonction récursive

quand un client envoi des donnée et que le recv() de la 1ere fonction est en mode attente cela fonction très bien.

A un temps T, la fonction 1 appel la fonction 2

- le client envoi alors d'autre information mais la fonction 2 ne reçois rien ...

- a la fin de la fonction 2, la fonction 1 afficher TOUTES les infos que le client a envoyer (en 1 seul affichage) lorsque la fonction 2 était en mode recv()

j'ai fait plein de test j'ai vérifier mes recv() et mes send(), la taille des buffer mais rien n'y fait :/

donc si quelqu'un pouvait me dire pourquoi ou me donnée des piste sa serai cool :)

Merci

code de la fonction 1:

Code:

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
 
void *gestionClient(void *idC)
{
	char **tab_mot=NULL;												//tableau qui contien des mot split avec un delimiteur
 
	char bufRead[1024];													// Buffer de Lecture
		memset(bufRead,'\0',1024);
    char bufWrite[1024];												// Buffer D'Ecriture
		memset(bufWrite,'\0',1024);
 
    int id = (int)idC;													// id du client
    char pseudo[64];													// pseudo du client
 
    char chemin_dos[2048]; 												// "CustomerBox/PSEUDO/..."
    FILE *f;															// fichier courant
 
    int doneC = 1;
    while(doneC)
    {
		// reception de la chaine de caracteres 
		if(recv(tab_c[id]->sockClient,bufRead,1024,0) == -1)
		{
			doneC = 0;
			close(tab_c[id]->sockClient);
			tab_c[id]->idClient = -1;
		}
 
		// cherche les mots
		tab_mot = split(bufRead, ":");
		printf("-%s-\n",tab_mot[0]);
 
		if(strcmp(tab_mot[0], "DECO") == 0)
		{
			doneC = 0;
		}	
		else if(strcmp(tab_mot[0], "PSEUDO") == 0)
		{
			strcpy(pseudo,tab_mot[1]);
			sprintf(chemin_dos,"CustomerBox/%s",pseudo);
 
			if(access(chemin_dos,0) == -1)
			{
				mkdir(chemin_dos,0777);
				printf("-> Le dossier '%s' a été créé ! \n",pseudo);
			}
		}
		else if(strcmp(tab_mot[0], "CREA-MAJ") == 0)
		{
			memset(chemin_dos,'\0',2048);
			strcpy(chemin_dos,tab_mot[2]);
 
			if(strcmp(tab_mot[1], "D") == 0)
			{
				sprintf(bufWrite,"Dossier : %s ---> Modification\n",chemin_dos);
				if(access(chemin_dos,0) == -1)
				{
					mkdir(chemin_dos,0777); 
					//Envoi de l'Opperation Effectuée
					if(send(tab_c[id]->sockClient,"CREA",strlen("CREA"),0) == -1)
					{
						perror("***Probleme d'envoi du message de l'opperation effectuée au client***");
						doneC = 0;
					}
					sprintf(bufWrite,"Dossier : %s ---> Creation\n",chemin_dos);
				}
			}
			else if(strcmp(tab_mot[1], "F") == 0)
			{
				if((f = fopen(chemin_dos, "r")) == NULL) 
				{
					f = fopen(chemin_dos, "w+t"); 
 
					//Envoi de l'Opperation Effectuée
					if(send(tab_c[id]->sockClient,"CREA",strlen("CREA"),0) == -1)
					{
						perror("***Probleme d'envoi du message de l'opperation effectuée au client***");
						doneC = 0;
					}
 
					sprintf(bufWrite,"Fichier : %s ---> Creation",chemin_dos);
				}
				else
				{
					fclose(f);
					f = fopen(chemin_dos, "w"); 
 
					//Envoi de l'Opperation Effectuée
					if(send(tab_c[id]->sockClient,"MODIF",strlen("MODIF"),0) == -1)
					{
						perror("***Probleme d'envoi du message de l'opperation effectuée au client***");
						doneC = 0;
					}
 
					sprintf(bufWrite,"Fichier : %s ---> Modification",chemin_dos);
				}
 
				fclose(f);
			}
 
			//Envoi de l'Opperation Effectuée
			if(send(tab_c[id]->sockClient,bufWrite,strlen(bufWrite),0) == -1)
			{
				perror("***Probleme d'envoi du message de l'opperation effectuée au client***");
				doneC = 0;
			}
		}
		else if(strcmp(tab_mot[0], "SUP") == 0)
		{
			sprintf(chemin_dos,"CustomerBox/%s",pseudo);
			if(parcoure_directory(id, chemin_dos) == -1)
				doneC = 0;
 
			sleep(1); //permet au client davoir le temps de ce metre en mode reception
 
			if(send(tab_c[id]->sockClient,"FIN",strlen("FIN"),0) == -1)
			{
				perror("***Probleme d'envoi du message de FIN au client***");
				doneC = 0;
			}
		}
 
		memset(bufRead,'\0',1024);
		memset(bufWrite,'\0',1024);
	}
 
	printf("\n**Un Client vien de ce deco !**\n");
 
	for(doneC = 0; tab_mot[doneC] != NULL; doneC++)
		free(tab_mot[doneC]);
	free(tab_mot);
 
	close(tab_c[id]->sockClient);
	tab_c[id]->idClient = -1;
 
	return NULL;
}

code de la fonction 2:

Code:

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
 
int parcoure_directory(int id, char const *name)
{
    DIR *directory;           /* pointeur de répertoire */
    struct dirent *entry;     /* représente une entrée dans un répertoire. */
    struct stat file_stat;    /* informations sur un fichier. */
 
    /* Ce tableau servira à stocker le chemin d'accès complet
     * des fichiers et dossiers. Pour simplifier l'exemple,
     * je le définis comme un tableau statique (avec une taille
     * a priori suffisante pour la majorité des situations),
     * mais on pourrait l'allouer dynamiquement pour pouvoir
     * le redimensionner si jamais on tombait sur un chemin
     * d'accès démesurément long. */
    char chm[2048];
    memset(chm,'\0',2048);
    char dmd[2048];
    memset(dmd,'\0',2048);
	char rep[2048];
	memset(rep,'\0',2048);	
 
    /* On ouvre le dossier. */
    directory = opendir(name);
    if ( directory == NULL ) 
    {
        fprintf(stderr, "Ouvertur directory -> %s --- IMPOSSIBLE\n", name);
        return -1;
    }
 
    /* On boucle sur les entrées du dossier. */
    while ( (entry = readdir(directory)) != NULL ) 
    {
        /* On "saute" les répertoires "." et "..". */
        if ( strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0 )
            continue;
 
        /* On construit le chemin d'accès du fichier en
         * concaténant son nom avec le nom du dossier
         * parent. On intercale "/" entre les deux.
         * NB: '/' est aussi utilisable sous Windows
         * comme séparateur de dossier. */
        snprintf(chm, 2048, "%s/%s", name, entry->d_name);
 
        /* On récupère des infos sur le fichier. */
        if((stat(chm, &file_stat)) == -1) 
		{
			perror("***Probleme dans le stat***\n");
			return -1;
		}
 
        if ( S_ISREG(file_stat.st_mode) ) 
        {
			/* On est sur un fichier, on envoi les info. */
			snprintf(dmd, 2048, "F:%s", chm);
 
			if(send(tab_c[id]->sockClient,dmd,strlen(dmd),0) == -1)
			{
				perror("***Probleme dans l'envoi du chemin du FICHIER***\n");
				return -1;
			}
 
			// Reception de l'Opperation Effectuée
			if(recv(tab_c[id]->sockClient,rep,strlen(rep),0) == -1)
			{
				perror("***Probleme dans la reception de l'opperation effectuer -FICHIER-***\n");
				return -1;
			}
 
			printf("F chm = -%s- || rep = -%s-\n",chm,rep);
			//si le fichier n'existe pas on le supprime
			if(strcmp(rep, "NON") == 0)
				remove(chm);
 
			sleep(1);
        }
        else if ( S_ISDIR(file_stat.st_mode) ) 
        {
            /* On est sur un dossier, on envoi les info et on appelle cette fonction. */
            snprintf(dmd, 2048, "D:%s", chm);
 
			if(send(tab_c[id]->sockClient,dmd,strlen(dmd),0) == -1)
			{
				perror("***Probleme dans l'envoi du chemin du DOSSIER***\n");
				return -1;
			}
 
            // Reception de l'Opperation Effectuée
			if(recv(tab_c[id]->sockClient,rep,strlen(rep),0) == -1)
			{
				perror("***Probleme dans la reception de l'opperation effectuer -DOSSIER-***\n");
				return -1;
			}
 
			printf("F chm = -%s- || rep = -%s-\n",chm,rep);
			//si le dossier n'existe pas on le supprime et egalement tout ce quil y avait dedant
			if(strcmp(rep, "NON") == 0)
				if(remove_directory(chm) == -1)
					return -1;
            sleep(1);
            parcoure_directory(id, chm);
        }
 
        memset(chm,'\0',2048);
        memset(dmd,'\0',2048);
		memset(rep,'\0',2048);
    }
 
    /* On ferme le dossier. */
    closedir(directory);
 
    return 1;
}

Si des erreur ou des absurdité vous pique l’œil merci de me le dire ;)

Personne n'a d'idées ?? 8O

Les seules suggestions que j'ai sont les suivantes :

- socket invalide passée en paramètre (dû à un id qui ne serait plus à la valeur attendu)
- déconnexion du client (ce qui n'a pas l'air d'être le cas)

Autre chose : ton sleep(1) pour permettre au client de se mettre en mode réception est une horreur. Fais plutôt appel à recv ! Quand ton client est "prêt" il utilise send, ce qui débloquera ton autre programme.

Merci pour ta rep je ferais plus de test au niveau de l'id car sa ma l'aire d’être une bonne idée :)

Et merci pour ton aide car oui le je me doutai bien que sleep() ne devais pas être la bonne solution ^^'

je reviens donnée mes résultats dans la soirée a toute ;)

Bon après quelque test, l'id et la socket de cette id sont les même dans les 2 fonction et a chaque appel récursif donc je ne vois vraiment pas pourquoi cela ne marche pas :/

Je commence a me dire que sa ne doit pas marcher avec une fonction récursive 8O

si sa peut aider voici le résultat du serveur (avec le test de lid et de la socket)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
** Un nouveau Client vien de ce connecter**
-PSEUDO-
-SUP-
id -> 0, socket -> 4 //avant lappel de la fonction 2
id -> 0, socket -> 4 //a chaque appel de la fonction 2 (récursif)
F chm = -CustomerBox/zelo/dos2- || rep = --
id -> 0, socket -> 4
F chm = -CustomerBox/zelo/dos2/true - 2.jpg- || rep = --
F chm = -CustomerBox/zelo/toto.txt- || rep = --
F chm = -CustomerBox/zelo/dos4- || rep = --
id -> 0, socket -> 4
F chm = -CustomerBox/zelo/dos4/true - 4.jpg- || rep = --
F chm = -CustomerBox/zelo/dos1- || rep = --
id -> 0, socket -> 4
F chm = -CustomerBox/zelo/dos1/true - 1.jpg- || rep = --
F chm = -CustomerBox/zelo/dos3- || rep = --
id -> 0, socket -> 4
F chm = -CustomerBox/zelo/dos3/true - 3.jpg- || rep = --
// fin de la fonction récursive et retour a la fonction 1
-NONNONNON-
-DECO-
 
**Un Client vien de ce deco !**