带有套接字数据数组的 C 结构

Question

Programming an application in C, I have the following struct data that I'd like to send over a network socket to another process. My struct definitions are shown below:

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;

I'd like to send the RequestPacket over the network using send / write , but I'm unsure how to handle the array pointer. If I were using a static array in the struct there would be no problem, but it needs to be dynamic since I won't know rows and cols ahead of time. Furthermore, the pointer can't be interpreted by the other process, so I need to send the raw data over the socket.

I've already added the __packed__ attribute to these struct definitions, in an attempt to eliminate padding. That's great, but if I need to pour all of the data into a linear buffer before being able to send it, then what was the point?

I'm asking this question because I'd like to know the best approach in sending this data over the network. Thanks in advance for the help.

Answer 1

Well-perfoming code should minimize copies. The approach below performs no copies in user code, it doesn't rewrite data, and it could be adapted to have a zero-copy path from the network card directly into application memory.

These two structures, as well as the character array, constitute a tree. The objects are tree nodes, the pointers-to-objects are tree edges.

To transmit the tree, you need to traverse it in some order. Whether it's breadth-first or depth-first or some other order is up to you - as long as the transmitter and the receiver both agree on the order.

Send structures in traversal order, without any changes. The receiver ignores the pointers, and leverages the traversal order to rewrite the pointers to correct locations on the receive side.

For example - assuming blocking code, and having written safe_write to properly deal with signals (most code that uses naked write without some wrapper is doing it wrong - POSIX APIs are notoriously hard to use correctly; they lull you into complacency since they appear to work - until they won't).

Let's also decide that our API will correctly deal with NULL pointers - it will skip NULL pointers, and the receiver will not expect anything sent if a NULL pointer was received.

The problem you haven't addressed is versioning: as it is, most objects you defined carry no size, so they cannot be expanded in the future. This may be addressed by adding an explicit length field to each structure, so that the receiver can correctly frame them. It'd simply ignore the additional fields.

The Types

The structure definitions had been made portable between 32- and 64-bit platforms.

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

Sender

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

Receiver

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

Answer 2

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;


request_packet_s *allocreq(uint32_t req, size_t rows. size_t cols);
{
      request_packet_s *p = malloc(sizeof(*p) + rows * cols);
      /* init it - d osomething */
      return p;
}

then you can send /write in one call