c - C中通过套接字发送多个字段的数据

Question

我想通过套接字发送具有以下格式的数据包:

struct Packet{
   uint32_t  seqnum;
   uint16_t  check;
   char data[1024]
}; 

每个数据包都有一个序列号、校验和以及数据包包含的数据。我如何将这 3 个字段放入缓冲区中以通过套接字发送，然后在接收时，可以提取这些字段？例如，是否可以将缓冲区的前 4 个字节作为 seqnum，将接下来的 4 个字节作为检查，然后将剩余的 1024 个字节作为数据？因此，接收方将期望接收总共 1032 个字节，然后应该能够提取前 4 个字节并生成序列号，接下来的 4 个字节并生成校验和，最后 1024 个字节作为数据？我通过 UDP 执行此操作，因此无法单独发送字段。

Answer 1

编辑 - OP 没有要求使用 C++，但是如果有帮助的话，底层实现是用 C 完成的。

我修改了 Boost 示例网站中的一个类来满足您的需求，它是您的缓冲区和结构的便捷包装器。这应该可以满足您的需求，但它没有考虑大字节序或小字节序。

当您的消息始终是固定大小时，这会变得更加容易，但是在 header 中添加另一个 4 字节整数来保存消息长度将为您节省大量带宽，而且操作起来非常简单。

message myMessage;

myMessage.setSequence(nextSequenceNumber);
myMessage.setCheckSum(mycheckSum);

 //assuming the message you have is a std::string
memcpy( myMessage.body(), message.c_str(), myMessage.body_length() );
myMessage.encode_header();
sendto(socket, myMessage.data(), myMessage.length(), 0, &my_sockaddrsizeof(my_sockaddr));

myMessage.reset();
recvfrom(socket, myMessage.data(), myMessage.length(), 0, &my_sockaddr, &my_sockaddr_len);

if(!myMessage.decodeHeader()){
// handle bad header/corrupt message
}

int32_t sequence = myMessage.getSequence();
int32_t checkSum = myMessage.getSheckSum();

class message
{
public:
    enum { check_length = 4 };
    enum { seq_length = 4 };
    enum { body_length = 1024 };
    message() : _checkSum(0), _sequence(0), _body_length(1024), _header_length(8) {}  // constructor + init list

    const char* data() const   { return data_; }
    char* data()               { return data_; }
    const char* body() const   { return data_ + check_length + seq_length; }
    char* body()               { return data_ + check_length + seq_length; }
    std::size_t length()   { return _body_length + _header_length; }
    std::size_t body_length() { return _body_length; }
    int32_t const& getCheckSum()  const { return _checkSum; }
    int32_t const& getSequence()  const { return _sequence; }
    void setCheckSum(const int32_t& s) { _checkSum = s; }
    void setSequence(const int32_t& s) { _sequence = s; }

    bool decode_header()
    {
        char check_sum[check_length + seq_length + 1] = "";
        char sequence[check_length + seq_length + 1] = "";
        strncat_s(check_sum, data_, seq_length);
        strncat_s(sequence, data_ + check_length, check_length);
        _checkSum = std::atoi(check_sum);
        _sequence = std::atoi(sequence);

        if (_checkSum == 0 || _sequence == 0)  
        {
            std::cout << "Header malfunction" << std::endl;
            return false;
        }
        return true;
    }

    void encode_header()
    {
        char header[check_length + seq_length + 1] = "";
        std::memcpy(header, &_sequence, sizeof(int32_t));
        std::memcpy(header + seq_length, &_checkSum, sizeof(int32_t));
        std::memcpy(data_, header, check_length + seq_length);
    }

    void reset()
    {
        memset(&data_[0], 0, sizeof(data_));
        int32_t _checkSum = 0;
        int32_t _sequence = 0;
    }

private:
    char data_[check_length + seq_length + body_length];
    int32_t _body_length, _header_length;
    int32_t _checkSum;
    int32_t _sequence;
};