Bonjour a tous,

Dans le cadre d'un projet scolaire je dois coder un serveur tcp qui est cens� r�ceptionner des structures sur le r�seau via socket TCP. Je ne suis pas autoris� a utiliser de librairies type Qt ou Boost pour la s�rialisation ou pour le r�seau.

Mon probl�me est que les donn�es que je re�oit sont corrompues. Excuser moi pour la longueure du code que je m'appr�te a poster mais si vous voulez avoir une chance de m'aider il vous faut tout les �l�ments.

La structure que j'envoie ( c'est Packet) :
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
 
struct Header
{
  uint32_t      magic;
  uint32_t      checksum;
  uint32_t      timestamp;
  uint16_t      commandId;
  uint16_t      dataSize;
};
 
struct Packet
{
  struct Header header;
  char          data[128];
};
Je s�rialise cette structure avec ces fonctions
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
 
unsigned char                           *Serialization::serialize_uint32(unsigned char *buffer, uint32_t arg)
{
  buffer[3] = (arg >> 24);
  buffer[2] = (arg >> 16);
  buffer[1] = (arg >> 8);
  buffer[0] = (arg);
  return (buffer + sizeof(uint32_t));
}
 
unsigned char                           *Serialization::serialize_uint16(unsigned char *buffer, uint16_t arg)
{
  buffer[1] = (arg >> 8);
  buffer[0] = (arg);
  return (buffer + sizeof(uint16_t));
}
 
unsigned char                           *Serialization::serialize_char(unsigned char *buffer, char arg)
{
  buffer[0] = (arg);
  return (buffer + sizeof(char));
}
 
unsigned char                           *Serialization::serialize_string(unsigned char *buffer, char *arg, int len)
{
  int                           i;
 
  i = -1;
  while (++i < len)
    buffer = serialize_char(buffer, arg[i]);
  return (buffer);
}
 
unsigned char                           *Serialization::serialize_header(unsigned char *buffer, struct Header& arg)
{
  buffer = serialize_uint32(buffer, arg.magic);
  buffer = serialize_uint32(buffer, arg.checksum);
  buffer = serialize_uint32(buffer, arg.timestamp);
  buffer = serialize_uint16(buffer, arg.commandId);
  buffer = serialize_uint16(buffer, arg.dataSize);
  return (buffer);
}
 
unsigned char                           *Serialization::serialize_packet(unsigned char *buffer, struct Packet& arg)
{
  buffer = serialize_header(buffer, arg.header);
  buffer = serialize_string(buffer, arg.data, arg.header.dataSize);
  return (buffer);
}
je d�s�rialise ainsi :
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
 
unsigned char                           *Serialization::deserialize_uint32(unsigned char *buffer, uint32_t *arg)
{
  memcpy((char*)arg, buffer, sizeof(uint32_t));
  *arg = ntohl(*arg);
  return (buffer + sizeof(uint32_t));
}
 
unsigned char                           *Serialization::deserialize_uint16(unsigned char *buffer, uint16_t *arg)
{
  memcpy((char*)arg, buffer, sizeof(uint16_t));
  return (buffer + sizeof(uint16_t));
}
 
unsigned char                           *Serialization::deserialize_char(unsigned char *buffer, char *arg)
{
  memcpy(arg, buffer, sizeof(char));
  return (buffer + sizeof(char));
}
 
unsigned char                           *Serialization::deserialize_string(unsigned char *buffer, char *arg, int len)
{
  memcpy(arg, buffer, len);
  return (buffer + len);
}
 
unsigned char                           *Serialization::deserialize_header(unsigned char *buffer, struct Header& arg)
{
  buffer = deserialize_uint32(buffer, &arg.magic);
  buffer = deserialize_uint32(buffer, &arg.checksum);
  buffer = deserialize_uint32(buffer, &arg.timestamp);
  buffer = deserialize_uint16(buffer, &arg.commandId);
  buffer = deserialize_uint16(buffer, &arg.dataSize);
  return (buffer);
}
 
unsigned char                           *Serialization::deserialize_packet(unsigned char *buffer, struct Packet& arg)
{
  buffer = deserialize_header(buffer, arg.header);
  buffer = deserialize_string(buffer, arg.data, arg.header.dataSize);
  return (buffer);
}
Le code d'envoi de mon client est :
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
 
TcpSocket                     tcp;
Packet                        p;
char                          *serialized;
 
tcp.connectSocket("127.0.0.1", 4242);
p.header.magic = 0;
p.header.checksum = 1;
p.header.timestamp = 2;
p.header.commandId = 3;
p.header.dataSize = ss.str().length();
memset(p.data, 0, 128);
memcpy(p.data, "0", 2);
serialized = new char[sizeof(Header) + 2];
bzero(serialized, sizeof(Header) + 2);
Serialization::serialize_packet(serialized, p);
hexDump("serialized", serialized+1, sizeof(Header) + 2);
ret = tcp.write(serialized, sizeof(Header) + 3);
et mon serveur recoit ainsi (cette fonction est appell� par la boucle sur le select()) :

Code : S�lectionner tout - Visualiser dans une fen�tre � part
1
2
3
4
5
6
7
 
int bav;
 
bav = socket->bytesAvailable();
buff = new char[bav];
socket->read(buff, bav);
hexdump("buff", buff, bav);
methodes read et send de ma classe Socket :
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
 
int                     TcpSocket::read(char *buff, int len)
{
  int                   ret;
 
  ret = recv(this->_socket, buff, len, 0);
  return (ret);
}
 
int                     TcpSocket::bytesAvailable()
{
  int                   ret;
  char                  buff[65536];
 
  ret = recv(this->_socket, buff, 65535, MSG_PEEK);
  return (ret);
}
 
int                     TcpSocket::write(const std::string& buff, int len)
{
  int                   ret;
 
  ret = send(this->_socket, buff.c_str(), len, 0);
  return (ret);
}
voici les deux hexdumps :

client :
00 00 00 00 00 00 01 00 00 00 02 00 03 00 01 30 ...............0

server:
00 00 00 00 14 00 00 00 1c 00 00 00 1a 00 00 00 ...............

J'ai cherch� pendant plusieurs jours avant de venir vous ennuyer avec mon probl�me.
En vous remerciant par avance