C++ 通过C+中的套接字传输数据+；_C++_C_Sockets_Serialization_Tcp

C++ 通过C+中的套接字传输数据+；

c++ c sockets serialization tcp

C++ 通过C+中的套接字传输数据+；,c++,c,sockets,serialization,tcp,C++,C,Sockets,Serialization,Tcp,我目前正在从事一个使用网络的项目。我必须发送一个结构 struct Header { uint32_t magic; uint32_t checksum; uint32_t timestamp; uint16_t commandId; uint16_t dataSize; }; struct Packet { struct Header header; char

我目前正在从事一个使用网络的项目。我必须发送一个结构

    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];
    };

我正在尝试使用TCP将结构数据包从一个套接字发送到另一个套接字。我试着这样发送我的结构

      send(socket, &my_struct, sizeof(my_struct), 0);

但它不起作用，所以我尝试将结构序列化为字符*

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::deserialize_uint32(unsigned char *buffer, uint32_t *arg)
    {
      memcpy((char*)arg, buffer, sizeof(uint32_t));
      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));
    }

即使客户端同时发送结构头数据，当我在服务器端读取时，数据也会损坏为什么数据会损坏

客户端发送循环

    TcpSocket                     tcp;
    Packet                        p;
    std::stringstream             ss;
    int                           cpt = 0;
    int                           ret = 0;
    char                          *serialized;

    tcp.connectSocket("127.0.0.1", 4242);
    while (getchar())
    {
      ss.str("");
      ss.clear();
  ss << cpt++;
  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, ss.str().c_str(), ss.str().length());
  serialized = new char[sizeof(Header) + ss.str().length()];
  bzero(serialized, sizeof(Header) + ss.str().length());
  Serialization::serialize_packet(serialized, p);
  hexDump("serialized", serialized+1, sizeof(Header) + ss.str().length());
  ret = tcp.write(serialized+1, sizeof(Header) + ss.str().length());
}

套接字->读取（）：

当我运行这些程序时：

    ./server
    [Server] new connexion :: [5]
    recv returns : 17
    buff serialized:
      0000  00 00 00 00 14 00 00 00 1c 00 00 00 1a 00 00 00  ................
      0010  1b

    ./client
    serialized data:
      0000  00 00 00 00 00 00 01 00 00 00 02 00 03 00 01 30  ...............0
      0010  00
    send returns : 17

每次只需屏蔽低8位：

buffer[3] = (arg >> 24) & 0xff;
buffer[2] = (arg >> 16) & 0xff;
buffer[1] = (arg >> 8) & 0xff;
buffer[0] = (arg) & 0xff;

反序列化时也要执行同样的操作

如果我是你，我就不会重新发明轮子。有很多经过良好记录和测试的库/协议正是为了满足您的需求。我刚刚想到的一个小清单：

JSON
XML
科尔巴

buff = new char[bav];
socket->read(buff, bav);
hexdump("buff", buff, bav);
socket->read() :

int TcpSocket::read(char *buff, int len)
{
    return recv(this->_socket, buff, len, 0);
}

recv（）

man 2 recv

recv（）

recv（）

recv（）

```
recv（）
```
调用可能会完全填满您的缓冲区
```
recv（）
```
调用可能会部分填充缓冲区
```
recv（）
```
调用可能返回0，表示发送方已关闭连接
```
recv（）
```
调用可能指示
```
EINTR
```
，因为它被系统调用中断
```
recv（）
```
调用可能指示
```
econreset
```
，因为发送方突然关闭了连接或已消失
```
recv（）
```
调用可能会遇到其他错误

send（）

recv（）

unsigned char

C++

uint32\u t

arg

buffer

unsigned char

unsigned char

x=arg

x=arg&0xff

recv（）

buff = new char[bav];
socket->read(buff, bav);
hexdump("buff", buff, bav);
socket->read() :

int TcpSocket::read(char *buff, int len)
{
    return recv(this->_socket, buff, len, 0);
}