发送一个内部带有 char 指针的结构？

Question

我试图将一个数据包从我的 C 程序发送到我的 Delphi 程序，数据的大小是可变的，如果我使用 char Data[1024];即使数据是 3 个字节，它也会发送 1024 个字节，如果数据大于 1024，它不会发送全部:(

struct Packet
{
    int State_;
    char *Data;
};

struct Packet MyPacket;
MyPacket.Data = (char *) calloc(8, sizeof(char));
memcpy(MyPacket.Data, "thi sis", 8); 
send(Socket, MyPacket, (int)sizeof(struct Packet), 0);

谢谢 哦，顺便说一句，我在 Windows 下使用 gcc

Answer 1

接收方（Delphi）应该通过发送方和接收方商定的方法了解数据的大小（即，您应该实现一个简单的数据传输协议）。当您传输整个struct时，您的协议还应该注意指定类型。最简单的解决方案是使用文本数据交换格式，例如 XML 或 JASON：

// Code to demonstrate the idea, may not compile.
struct Packet MyPacket;
MyPacket.State_ = 0;
MyPacket.Data = (char *) calloc(8, sizeof(char));
memcpy(MyPacket.Data, "thi sis", 8); 
const char* packetXml = PacketToXml();
/*
packetXml = 
<Packet>
<State>0</State>
<Data>thi sis</Data>
</Packet>
*/
size_t len = strlen(packetXml);
send(Socket, (char*)&len, sizeof(size_t), 0);
send(Socket, packetXml, len, 0);

Answer 2

实际上，您想要做的是发送消息的短标头，后跟可变长度数据。标头应至少包含其后的数据的大小。一个简单的实现是这样的：

struct Packet {
    int State_;
    char *Data;
};
struct PacketHeader {
    uint32_t state;
    uint32_t len;
};

int send_packet(int sock, struct Packet *pkt)
{
    struct PacketHeader hdr;
    int len = strlen(pkt->Data); /* If Data is a C string */
    hdr.state = htonl(pkt->State_);
    hdr.len = htonl(len);
    send(sock, &hdr, sizeof(hdr), 0);
    send(sock, pkt->data, len, 0);
}

我不知道Delphi，但是要解析数据包，你需要做相反的事情。读取标头以获取数据的大小，然后将这么多数据从套接字读取到新分配的缓冲区中。

Answer 3

您需要指定发送数据的正确长度。使用：

sizeof(struct Packet)

就像你所做的那样是错误的，在32位系统上只会给你8个字节，4个字节用于int，4个字节用于char*。

请注意，这

char*

是与字符数组不同的类型。它是一个指向 char 的指针。例如，这里的sizeof的结果是不同的：

char arr[1024];
char* pc = arr;
printf("%d, %d", sizeof(pc), sizeof(arr));

Answer 4

将数据包封装在单个块中的一个老技巧是在数据包末尾使用长度为 1 的数组。

struct Packet 
{
    unsigned packetLengthInBytes_;
    /* All the fixed fields in the packet */
    int  State_;
    /* Generic data in the packet - of actual length given by packetDataLength(packet) */
    char Data[1];
};

unsigned packetDataLength(Packet* packet)
{
    return packet->packetLengthInBytes_ - (sizeof(Packet) - 1);
}

Packet* createPacketFromData(const char* data, unsigned dataSize)
{
    unsigned packetSize = sizeof(Packet) + dataSize - 1;
    Packet* packet = (Packet*)malloc(packetSize);
    packet->packetLengthInBytes_ = packetSize;
    memcpy(packet->Data, data, dataSize);
    return packet;
}

int sendData(int sock, const char* data, unsigned dataSize)
{
    Packet* packet = createPacketFromData(data, dataSize);
    /* [ Yes, think about endian issues.] */
    send(sock, packet, packet->packetLengthInBytes_, 0);
    free(packet);
}

请注意，这意味着我们只有一个 send() 调用，并且通常可以将一个 Packet 作为单个对象传递，其中包含一个分配调用和一个释放调用。

Answer 5

您应该为您的结构实现序列化方法。
您现在尝试发送它的方式永远不会起作用，因为您实际上并没有发送 char* 的内容，而是发送指针本身。这只是一个内部地址，接收程序将不知道您想要完成什么。

Answer 6

指针是对内存地址的引用，因此您当前发送的是地址而不是内容。因此，您需要更改它以发送实际字符数组。
您需要在实际字符数组之前发送大小信息（首选）或定义字符数组结束符号

Answer 7

您的代码不正确 - 当您像这样直接发送结构时，您发送的是一个指针（Data_的地址），而不是实际的字符串。您有两种选择：

1. 正如您已经提到的，在结构内部使用固定大小的数组。

2. 通过套接字手动发送长度和实际字符串数据，例如：

---

int length = 8;
char *data = (char *) calloc(length, sizeof(char));
memcpy(data, "thi sis", 8); 
send(Socket, &length, sizeof(length), 0);
send(Socket, data, length, 0);