Discussion :

[nuFox]

Bonjour voila ... Je me pose des questions sur ma declaration de pointeur et son allocation de mémoire ...

Je vous transmet les info's ... Est ce que vous pourriez me dire si c'est correct ?

Merci d'avance

Ma structure :

Code :

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

1
2
3
4
5
6
7
 
struct packetRec{
  char control;
  char lenght;
  unsigned short checksum;
  char *data;    
};

Ma declaration :

Code :

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

1
2
3
4
5
6
7
 
// Creation du pointeur
struct packetRec *packet;
// Allocation de la taille.
packet = malloc(sizeof(struct packetRec));
// Mise à zero.
memset(packet, 0x0, sizeof(struct packetRec));

[cmoibal]

Bonjour,
est ce qu'il y a une erreur dans ce code ??

[nuFox]

Non, aucune erreur je pense ... Enfin il ne dit rien a la compilation ...

Mais la question que je me pose, c'est que comme dans ma structure, j'ai une chaine de caractere non définie en taille ... Et que je ne fais qu'un malloc a la création du pointeur ... Et que je ne sais pas combien vaudra ma chaine de caractere dans ma structure ... Est ce que cela ne pourrait pas poser probleme ? :s

[cmoibal]

oui, un pointeur sur une zone non reservé posera un problème...

le malloc de la structure : c'est une allocation de la memoire pour le pointeur de la structure seulement.


et pour le pointeur de la chaine de caractere il faut faire une nouvelle malloc.

[nuFox]

Le probleme, c'est que je ne connais pas la taille de la chaine de caractere ... Elle est variable ...

Enfaite je t'explique tout ...

Je recois des packet que l'on ma envoyé sur le réseaux ... Ce paquet est mis dans un buffer ...

Je créée mon pointeur vers la structure ... Mais le probleme c'est que dans le packet que je recois, j'ai plusieur parametre ... 3parametres de taille connu .. Puisque declaré dans un format d'une taille connu ... Mais la chaine de caractere correspond au reste des donnée du packet recu ... Et donc je ne sais pas definir ca taille ... Et donc j'ai du mal a faire un malloc

Je te place mon code entier peut etre pour que tu puisses mieux visualiser la situation ...

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
 
// ********************************************************
// Fonction Receive
// ********************************************************
void receive(statMeasRead *cluster1, commParaReadWrit *cluster2, packetRejected *cluster3){
 
 
  int sel;
  fd_set read;
  struct timeval timeout;
  unsigned short saveChecksum;
  unsigned short returnChecksum;
 
  timeout.tv_sec = 0;
  timeout.tv_usec = 100000;
 
  FD_ZERO(&read);
  FD_SET(idSocket, &read);
 
  sel = select(idSocket + 1, &read, NULL, NULL, &timeout);
 
  // Probleme avec la fonction select.
  if(sel == SOCKET_ERROR){
    sprintf(codeErreur,"%d",WSAGetLastError());
    MessageBox(NULL,codeErreur, "Erreur receive : fonction select() !",MB_OK|MB_ICONERROR);
  }
 
  // Temps écoulé pour la fonction select.
  else if(sel == 0){
    MessageBox(NULL,codeErreur, "Erreur receive : select() timeout!",MB_OK|MB_ICONERROR);
    step = 3;
  }
 
  // Il y a un message a recuperer.
  else{
 
    //S'il y a une action a faire pour recv ... la fonction est faite
    if(FD_ISSET(idSocket, &read)){     
      nbCaractere = recv(idSocket, recbuf, 15-1, 0);
 
      // Erreur lors de la fonction rec().
      if(nbCaractere==SOCKET_ERROR){
	    sprintf(codeErreur,"%d",WSAGetLastError());
	    MessageBox(NULL,codeErreur, "Erreur receive : fonction recv() !",MB_OK|MB_ICONERROR);
 
	    //Le serveur est mort, code erreur = 10054.
	    if(strcmp(codeErreur,"10054") == 0) step = 3;
      }    
      else{
	    recbuf[nbCaractere]='\0'; // Permet de fermer le tableau après le contenu des data, car la fonction recv ne le fait pas
 
	    // Creation du pointeur
	    struct packetRec *packet;
 
	    // Allocation de la taille.
	    packet = malloc(sizeof(struct packetRec));
 
	    // Mise à zero.
	    memset(packet, 0x0, sizeof(struct packetRec));
 
	    memcpy((void*)packet, (const void*)recbuf, nbCaractere);
 
	    // Test du checksum.
	    saveChecksum = packet->checksum;
	    packet->checksum = 0;
	    returnChecksum = checksum((unsigned short *)packet, packet->lenght);
 
	    if(saveChecksum == returnChecksum) packet->checksum = saveChecksum;
 
	    // Test du byte de control si checksum OK
	    if(packet->checksum != 0){	
 
	      // Status and Measures reading (PLC answer)
	      if(packet->control == 0x02){	        
	        memcpy((void *)cluster1, (const void*)recbuf, nbCaractere); 
          }
 
	      // Command/Parameter reading or writing (PLC answer)
	      if(packet->control == 0x12 || packet->control == 0x17){       
	        memcpy((void*)cluster2, (const void*)recbuf, nbCaractere);
          }
 
	      // PLC answer at a "parameter/command writing" request by "Last packet rejected"
	      if(packet->control == 0x18){	        
            memcpy((void *)cluster3, (const void*)recbuf, nbCaractere);
          }
        }
	    else MessageBox(NULL,"Le calcule du checkSum à trouvé une erreur", "Erreur receive : fonction checksum() !",MB_OK|MB_ICONERROR);
 
	    //Liberation de la mémoire.
        free(packet);
        packet = NULL;                       
      }
    }
  }
}

[valefor]

C'est dangereux ton truc, parceque ta structure paquet ne représentera pas le paquet réel. En effet l'espace que tu alloueras dynamiquement pour la chaine ne sera pas à la suite du checksum !

De plus comment tu peux lire une trame si tu ne connais pas sa longeur ?

Je te propose (en gros) :

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
 
struct packetRec
{
  char control;
  char lenght;
  unsigned short checksum;
  char data[];    
};
 
unsigned char recbuf[beaucoup];
 
read(recbuf, 4);
length = ((packetRec *)recbuf)->length;
read(recbuf + 4 , length);
 
/* et puis là soit tu travaille sur le recbuf, soit tu travaille sur une nouvelle trame allouée */