第1步：

发送第一个包：数据数组的第一个元素，类型规范的int值。

之后文件名大小（没有路径）为unsigned short。

之后，文件名（没有路径）为C-string而没有NULL终止。

至少文件长度应为unsigned integer。

两种尺寸都应按网络字节顺序发送！

所有这些信息都必须在一个单个数据报中。实际上我只有一个unsigned char数组，由客户端发送。

我以为我可以一个接一个地为这个阵列分配任何东西。但是，不要认为这有效。

第2步：

发送第二个包：键入规范为int作为第一个元素。然后是给定文件的数据（我也将其保存为unsigned char数组）。这更容易，因为我只有容易放入unsigned char数组的信息。

所以，我认为，必须有一种方法来构建一个通用的方法或类似的东西，它返回一个数据报，所以我可以填写我想要在这个数据报中的所有数据类型，并让我的数据报准备好发送，你懂？

如果有人知道如何做好准备，那就太好了。正确的数据报 - 对我来说最重要的是：

我的数据报阵列应该具有哪种类型？要使用sendTo()发送它，它需要是unsigned char数组，对吧？

最好的问候，非常感谢！

Answer 1

您可以使用结构来映射您的信息，例如：

struct Packet {
   unsigned short filnemanesize;
   char [MAX_LEN] filename;
   unsigned int   filesize;
   //etc.
}

您可以通过套接字

直接发送此结构

send(mySocket, (void*) myStruct, sizeof(myStuct), 0);

但是编译器使用不同的成员打包，因此服务器会看到不同的数据。（对于完全相同的平台/编译器，它是安全的）。

通常的做法是将结构序列化为char数组，这是一个完整的例子：

#include <stdint.h>
#include <iostream>
#include <WinSock2.h>
#pragma comment(lib, "Ws2_32.lib")
using namespace std;


#define MAX_FILENAME_SIZE 10
typedef struct {
    int32_t type;
    uint16_t fileNameSize;
    uint32_t extraPadding; //just some manual padding (example)
    char fileName [MAX_FILENAME_SIZE];
    uint32_t fileSize;
} Packet;

const size_t PACKET_RAW_SIZE = sizeof(int32_t) + sizeof(uint16_t) + (MAX_FILENAME_SIZE * sizeof(char)) + sizeof(uint32_t);

size_t serialize(unsigned char * const dst, const Packet * src) {

    /*  Protocoll Specification:
        [Type:4Byte][fileNameSize:2Byte][fileName:nByte][fileSize:4Byte]
    */


    uint16_t offset = 0;

    //type
    memcpy(dst + offset, &src->type, sizeof(src->type));
    offset += sizeof(src->type);

    //fileNameSize
    memcpy(dst + offset, &src->fileNameSize, sizeof(src->fileNameSize));
    offset += sizeof(src->fileNameSize);

    //fileName
    memcpy(dst + offset, &src->fileName, ntohs(src->fileNameSize));
    offset += ntohs(src->fileNameSize);

    //fileSize
    memcpy(dst + offset, &src->fileSize, sizeof(src->fileSize));
    offset += sizeof(src->fileSize);

    return offset;
}

int main(int argc, _TCHAR* argv[])
{
    unsigned char buffer[PACKET_RAW_SIZE];
    for (int i = 0; i < PACKET_RAW_SIZE; buffer[i++] = 0);  //nice visual effect, not nessasarry
    Packet myPacket;
    myPacket.type = htonl(0xAFFEAFFE);                  
    myPacket.fileNameSize = htons(4);                       //convert 4 to network byte order as required
    myPacket.fileSize = htonl(42);
    myPacket.fileName[0] = 'T';                         
    myPacket.fileName[1] = 'E';
    myPacket.fileName[2] = 'S';
    myPacket.fileName[3] = 'T';

    myPacket.extraPadding = 0xFFFFFFFF;                     // better visual effect

    cout << "struct Packet size: " << sizeof(Packet) << endl;
    cout << "PACKET_RAW_SIZE: " << PACKET_RAW_SIZE << endl;

    size_t bufferSize = serialize(&buffer[0], &myPacket);

    cout << "myPacket: " << endl;
    for (int i = 0; i < sizeof(myPacket); i++) {
        unsigned char * ptr = (unsigned char *) &myPacket;
        cout << std::showbase << std::hex << "Offset: " << i * sizeof(unsigned char) << "\t Value: " <<  (uint16_t)*(ptr + i) << "\t" << *(ptr + i) << endl;
    }
    cout << endl;

    cout << "buffer: " << endl;
    for (int i = 0; i < bufferSize; i++) {
        cout << std::showbase << std::hex << "Offset: " << i * sizeof(unsigned char) << "\t Value: " << (uint16_t)buffer[i] << "\t" << buffer[i] << endl;
    }

    cout << endl;

    return 0;
}

/* 
    Program-Output:

    struct Packet size : 28
    PACKET_RAW_SIZE : 20
    myPacket :
    Offset : 0        Value : 0xaf    »
    Offset : 0x1      Value : 0xfe    ■
    Offset : 0x2      Value : 0xaf    »
    Offset : 0x3      Value : 0xfe    ■
    Offset : 0x4      Value : 0
    Offset : 0x5      Value : 0x4     ♦ 
    Offset : 0x6      Value : 0x9a    Ü
    Offset : 0x7      Value : 0xf     ☼
    Offset : 0x8      Value : 0xff
    Offset : 0x9      Value : 0xff
    Offset : 0xa      Value : 0xff
    Offset : 0xb      Value : 0xff
    Offset : 0xc      Value : 0x54    T
    Offset : 0xd      Value : 0x45    E
    Offset : 0xe      Value : 0x53    S
    Offset : 0xf      Value : 0x54    T
    Offset : 0x10     Value : 0x52    R
    Offset : 0x11     Value : 0x17    ↨
    Offset : 0x12     Value : 0x9f    ƒ
    Offset : 0x13     Value : 0xf     ☼
    Offset : 0x14     Value : 0x1     ☺
    Offset : 0x15     Value : 0
    Offset : 0x16     Value : 0
    Offset : 0x17     Value : 0
    Offset : 0x18     Value : 0
    Offset : 0x19     Value : 0
    Offset : 0x1a     Value : 0
    Offset : 0x1b     Value : 0x2a *

    buffer :
    Offset : 0        Value : 0xaf    »     | <= type
    Offset : 0x1      Value : 0xfe    ■     |
    Offset : 0x2      Value : 0xaf    »     |   
    Offset : 0x3      Value : 0xfe    ■     |   
    Offset : 0x4      Value : 0                 | <= fileNameSize
    Offset : 0x5      Value : 0x4     ♦         | (network byte order)
    Offset : 0x6      Value : 0x54    T             |   <= fileName
    Offset : 0x7      Value : 0x45    E             |
    Offset : 0x8      Value : 0x53    S             |
    Offset : 0x9      Value : 0x54    T             |
    Offset : 0xa      Value : 0                         | <= fileSize 
    Offset : 0xb      Value : 0                         | (network byte order)
    Offset : 0xc      Value : 0                         |
    Offset : 0xd      Value : 0x2a                      |

    */

你可以看到，缓冲区只包含所需的数据。并且映射是规范中要求的。所有手动和编译器填充都不在缓冲区内。 htons / htonl用于字节顺序转换。

更好的是某种文本序列化，例如xml或json（imho）

如何准备UDP数据报以便发送到服务器

第1步：

第2步：

1 个答案: