Discussion :

[hb2012]

Bonjour,
J'ai fait un programme qui fait le transfert d'une fichier JSON en utilisant socket du client vers le serveur. En fait, je voulais envoyer un message après le recevoir du fichier du serveur vers le client mais apparemment il y a une problème qui cloche, donc le message n'arrive pas au client. Pouvez-vous m'aider SVP. Voiçi les codes sources :
Serveur.c

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
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <json-c/json.h>
#include <netinet/in.h> 
#include <pthread.h>
#include <stdio.h> 
#include <stdlib.h>
#include <string.h> 
#include <stdarg.h>
#include <sys/mman.h> 
#include <sys/stat.h>
#include <sys/socket.h> 
#include <unistd.h> 
#include "jsmn.h"
 
#define BUFFER_SIZE          1024
#define MARGE_PROGRESSION     100
#define BUFFER_SIZE_JSON   100000
#define MAX_TOKEN_COUNT       128
 
pthread_t        th_server;
pthread_cond_t   cond_sr;
pthread_mutex_t  verrou_sr;
 
/***********************************************************************
 * Main.c: 
 **********************************************************************/
int main(int argc, char *argv[]) 
{ 
  FILE* fichier_sr;
  int   socket         = 0;
  int   size_line, desc_write;
  long  fichier_size   = 0, size_avanc_sr = 0;
  char* fichier_sr_nom = "server_test.json";
  char* line_buf       = (char *) malloc (BUFFER_SIZE*sizeof(char));
  char* Msg_to_cl      = (char* )malloc(BUFFER_SIZE*sizeof(char));  
        Msg_to_cl      = "hello from server\n";  
  pthread_mutex_init (&verrou_sr, NULL); 
  pthread_cond_init (&cond_sr, NULL);
 
  fichier_sr   = fopen(fichier_sr_nom,"w");
  socket       = attente (socket, argv[1]);
  fichier_size = lire_taille_fich(socket, fichier_size);   
 
  pthread_create(&th_server,NULL,thread_pourcentage_server,NULL);
 
  while((size_line = recevoir_fichier(size_line,socket, line_buf)) >= 0) 
  { 
    if (size_line == 0) 
	{
	  break;
	}
	desc_write = ecrire_fichier(desc_write,size_line,fichier_sr,line_buf);
	size_avanc_sr += size_line;
	pthread_mutex_lock(&verrou_sr);
	result_server=100*((float)(size_avanc_sr)/(float)(fichier_size));
	pthread_mutex_unlock(&verrou_sr);
	pthread_cond_broadcast(&cond_sr);
    usleep(100000);
 
	if (desc_write < size_line)
	{
	  perror("File write failed on server.\n");
	}
  }
  pthread_join(th_server, NULL);   
  pthread_mutex_destroy (&verrou_sr);
  pthread_cond_destroy (&cond_sr); 
  fclose(fichier_sr);
  //parseJSON(fichier_sr_nom);
  send(socket,Msg_to_cl,BUFFER_SIZE,0);
  return 0;
}

Client.c

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
#include <arpa/inet.h>
#include <stdio.h> 
#include <unistd.h>
#include <sys/socket.h> 
#include <stdlib.h> 
#include <netinet/in.h> 
#include <string.h> 
#include <sys/stat.h>
#include <pthread.h>
 
#define BUFFER_SIZE      1024
#define MARGE_PROGRESSION 100
 
pthread_t        th_client;
pthread_cond_t   cond_cl;
pthread_mutex_t  verrou_cl;
 
/***********************************************************************
 * Main.c: 
 **********************************************************************/
int main(int argc, char *argv[]) 
{  
  FILE*    fichier_cl;
  int      socket = 0;
  long     size_file     = 0, size_avanc_cl = 0;
  char*    line_str      = NULL;
  char*    file_name     = "client_file.json";
  char*    Msg_from_sr   = (char* )malloc(BUFFER_SIZE*sizeof(char));            
  size_t   line_pos      = 0;
  ssize_t  desc_line;
 
  pthread_mutex_init (&verrou_cl, NULL); 
  pthread_cond_init (&cond_cl, NULL);
 
  fichier_cl = fopen(file_name,"r");
  size_file  = taille_fich(file_name);
 
  socket     = connecte(socket,argv[1],argv[2]);
  socket     = envoyer_taille_fich(socket,size_file);
  pthread_create(&th_client,NULL,thread_pourcentage_client,NULL);
 
  while ((desc_line = getline(&line_str, &line_pos, fichier_cl)) != -1) 
  {
    if((socket = envoyer_fich(socket,line_str)) < 0) 
	{
	  printf("ERROR: Failed to send file %s.\n", file_name);
	  break;
	}
	size_avanc_cl += strlen(line_str);
	pthread_mutex_lock(&verrou_cl);
	result_thread=100*((float)(size_avanc_cl)/(float)(size_file));
	pthread_mutex_unlock(&verrou_cl);
	pthread_cond_broadcast(&cond_cl);
    //usleep(100000);
 
    if (line_str)
    {
    free(line_str);
    }
    line_pos = 0;  
  }
  pthread_join(th_client, NULL);   
  pthread_mutex_destroy (&verrou_cl);
  pthread_cond_destroy (&cond_cl);
  fclose(fichier_cl);
  read(socket, Msg_from_sr, 100);
  return 0; 
}

Merci d'avance

[LittleWhite]

Bonjour,

Certes, je ne vais pas répondre à la question, mais :

• à la fin, vous ne fermez pas les fichiers, ni ne libérez la mémoire ;

• Code :

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

  1
  2
  char* Msg_to_cl      = (char* )malloc(BUFFER_SIZE*sizeof(char));  
          Msg_to_cl      = "hello from server\n";

  Techniquement, ce n'est pas une copie d'une chaîne de caractères, et techniquement, la mémoire allouée juste avant est perdue (car pointeur menant à elle, écrasé) ;
• send(socket,Msg_to_cl,BUFFER_SIZE,0); je conseille de vérifier le code de retour (la valeur retournée) car elle indique s'il y a eu des problème, ou non ;
• vous pouvez déboguer, soit en utilisant un débogueur, soit en ajoutant des printf()/std::cout afin de vérifier que le programme fait bien ce que vous voulez.

[Bousk]

Il y a beaucoup d'erreurs de ce genre et le code est illisible.
Mais aussi, si tu shutdown direct après le send, tu auras beau avoir mis en file d'envoi dans le système ton appel, il va certainement pas perdre de temps à l'envoyer alors que le socket est détruit.

[hb2012]

Merci pour vos réponse, mais je penses que j'ai résolu mon problème en utilisant un autre port de connexion entre le serveur et le client