c - 套接字上具有数据数组的C结构

Question

我用C编写了一个应用程序，我想将以下struct数据通过网络套接字发送给另一个进程。我的结构定义如下所示:

typedef struct __attribute__((__packed__)) Matrix {
    uint32_t rows;
    uint32_t cols;
    char * matrix;
} matrix_s;

typedef struct __attribute__((__packed__)) RequestPacket {
    uint32_t request_code;
    matrix_s * mat;
} request_packet_s;

我想使用 RequestPacket/ send通过网络发送 write，但是我不确定如何处理数组指针。如果我在结构中使用静态数组将没有问题，但是它必须是动态的，因为我不会提前知道 rows和 cols。此外，指针无法由其他进程解释，因此我需要通过套接字发送原始数据。

我已经在这些结构定义中添加了 __packed__属性，以消除填充。很好，但是如果我需要先将所有数据倒入线性缓冲区中然后再发送，那又有什么用呢？

我问这个问题是因为我想知道通过网络发送此数据的最佳方法。在此先感谢您的帮助。

Answer 1

性能良好的代码应使副本最少。下面的方法在用户代码中不执行任何复制，也不重写数据，并且可以采用从网络卡直接复制到应用程序内存的零复制路径。

这两个结构以及字符数组构成一棵树。对象是树节点，指向对象的指针是树边缘。

要传输树，您需要以某种顺序遍历它。只要发送方和接收方都同意该顺序，是宽度优先，深度优先还是其他顺序取决于您。

按遍历顺序发送结构，无需进行任何更改。接收器忽略指针，并利用遍历顺序将指针重写为接收端的正确位置。

例如-假设阻止了代码，并编写了safe_write来正确处理信号(大多数使用裸write而没有包装的代码都在做错-众所周知，POSIX API很难正确使用;因为它们看起来很有效，它们会让您自满-直到他们不会)。

我们还要确定我们的API将正确处理NULL指针-它将跳过NULL指针，并且如果接收到NULL指针，接收方将不会期望发送任何内容。

您尚 Unresolved 问题是版本控制:实际上，您定义的大多数对象都没有大小，因此将来无法扩展。可以通过向每个结构添加显式长度字段来解决此问题，以便接收器可以正确地对其进行构图。只需忽略其他字段即可。

类型

结构定义已可移植到32位和64位平台之间。

typedef unsigned char BOOL;
enum { FALSE, TRUE };
#define PTR(type, name) union { type *name; uint64_t name##_; }

#define MAX_MATRIX_SIZE 128*128
typedef struct __attribute__((__packed__)) Matrix {
    uint32_t rows;
    uint32_t cols;
    PTR(char, matrix);
} matrix_s;

typedef struct __attribute__((__packed__)) RequestPacket {
    uint32_t request_code;
    PTR(matrix_s, mat);
    PTR(matrix_s, opt_kernel);
} request_packet_s;

#undef PTR

发件人

BOOL safe_write(int fd, void *buf, size_t length) {
  // Returns TRUE if buf is NULL or if writing had succeeded, FALSE on error
  if (!buf) return TRUE;
  assert(length);
  // TODO
  return FALSE;
}

BOOL sendBytes(int fd, char *bytes, size_t length) {
  if (!bytes) return TRUE;
  assert(length); // Sending a non-NULL pointer for a zero-sized block
                  // we shall declare to be a protocol error. Since
                  // this is the send side, this is a bug.
  return safe_write(fd, bytes, length);
}

BOOL sendMatrix(int fd, matrix_s *mat) {
  if (!mat) return TRUE;
  if (!safe_write(fd, mat, sizeof(*mat))) return FALSE;
  return sendBytes(fd, mat->matrix, mat->rows * mat->cols);
}

BOOL sendRequestPacket(int fd, request_packet_s *req) {
  if (!req) return TRUE;
  if (!safe_write(fd, req, sizeof(*req))) return FALSE;
  if (!sendMatrix(fd, req->mat)) return FALSE;
  return sendMatrix(fd, req->opt_kernel);
}

接收者

BOOL safe_read(int fd, void *buf, size_t length) {
  // Returns TRUE if reading had succeeded, FALSE on error
  if (!buf) return TRUE;
  if (!length) return FALSE; // Protocol error on receive: this is a
                             // data validation failure, and must be handled
                             // like any other error.
  // TODO
  return FALSE;
}

static inline BOOL free_read(void **const ptr) {
  free(*ptr);
  *ptr = NULL;
  return FALSE;
}

BOOL malloc_read(int fd, void **const buf, size_t length) {
  // This should be using an arena allocator, really.
  if (!*buf) return TRUE;
  if (!length) return FALSE;
  *buf = malloc(length);
  if (!*buf) return FALSE;
  if (!safe_read(fd, *buf, length)) return free_read(buf);
  return TRUE;
}

BOOL recvMatrix(int fd, matrix_s **const mat) {
  if (!malloc_read(fd, mat, sizeof(**mat))) return FALSE;
  size_t size = (*mat)->rows * (*mat)->cols;
  if (size > MAX_MATRIX_SIZE) goto error;
  if (size)
    if (!malloc_read(fd, &(*mat)->matrix, size)) goto error;
  return TRUE;
error:
  return free_read(mat);
}

BOOL recvRequestPacket(int fd, request_packet_s **const req) {
  if (!malloc_read(fd, req, sizeof(**req))) return FALSE;
  if (!recvMatrix(fd, &(*req)->mat)) goto error1;
  if (!recvMatrix(fd, &(*req)->opt_kernel)) goto error2;
  return TRUE;
error2:
  free_read(&(*req)->mat);
error1:
  return free_read(req);
}