c - 将结构指针元素传递给 FIFO - C

Question

我正在用 C 语言开发客户端/服务器应用程序，其中多个客户端通过一个公共(public) FIFO 发送请求。

发送到服务器的数据是一个包含多个参数的结构，包括一个指向整数数组 (pref_seat_list) 的指针。

struct request {
  pid_t pid;
  int num_wanted_seats;
  int *pref_seat_list; // <-- where the issue lies
  int pref_seats_size;
};

客户端通过 FIFO 发送数据，但在服务器端，指针指向随机/无效地址(可以理解)。

我可以通过将 pref_seat_list 设为固定大小的数组来解决这个问题

int pref_seat_list[size]

，但它必须表现为在客户端初始化和分配的动态大小数组。

是否有一种变通方法可以让指针以某种方式通过 FIFO 而无需固定其大小？

-------------------------------------------- -- 修复 1 ---------------------------------------------- ----------

• 包括 FAM 概念

结构现在看起来像这样

struct request {
  pid_t pid;
  int num_wanted_seats;
  int pref_seats_size;
  int pref_seat_list[];
};

结构的初始化已经完成://获取 pref_seat_list 的大小，以便我们可以初始化和分配数组

  // CLIENT.C
  int pref_seats_size = count_seats_list(arglist[3]);

  // Allocating space for request struct's pref_seat_list array (flexible array member)
  struct request *req = malloc(sizeof(struct request) + sizeof(int[pref_seats_size]));
  if (req == NULL)
  {
    fprintf(stderr, "Fatal: failed to allocate memory for the struct request");
    exit(0);
  }

填充结构的字段

  // CLIENT.C
  // Getting client's PID
  req->pid = getpid();

  // Getting client's number of wanted seats
  char *end;
  req->num_wanted_seats = strtol(arglist[2], &end, 10);

  // Assigning size of the struct's pref_seat_list array
  req->pref_seats_size = pref_seats_size;

  // Assigning list of seats to struct's pref_seat_list dynamic array
  int i = 0;
  char *token = strtok(arglist[3], " ");
  while (token != NULL)
  {
    req->pref_seat_list[i++] = strtol(token, &end, 10);
    token = strtok(NULL, " ");
  }

预期输出(SERVER.C)

1, 2, 3, 5, 8, 10, 12

实际输出(SERVER.C)——随机值

3250, 0, 0, 123131, 1, 345691, 1

Answer 1

大纲解决方案

您需要将首选座位列表与主结构分开处理。使用 flexible array member来自 C99 及更高版本的 (FAM) 可能是最简单的。 FAM 必须是结构的最后一个成员。

struct request
{
    pid_t pid;
    int num_wanted_seats;
    int pref_seats_size;
    int pref_seat_list[];
};

您为具有 num_prefs 个首选座位的请求分配空间:

struct request *rp = malloc(sizeof(*rp) + num_prefs * sizeof(rp->pref_seat_list[0]));

请注意 sizeof(struct request)(又名 sizeof(*rp))不包括数组的大小(尽管它可能包括一些填充如果 FAM 不存在，则它不会存在，尽管这在这里不是问题)。

检查分配是否成功后，用所需信息填充结构和数组(将 num_prefs 复制到 rp->pref_seats_size)。然后你可以一次写完:

fwrite(rp, sizeof(*rp) + rp->pref_seats_size * sizeof(rp->pref_seat_list[0])), 1, fp);

现在，阅读代码如何处理这个问题？在读取struct record主要信息之前，它不知道要分配多大的空间，所以你不得不咬两口樱桃:

struct request req_hdr;   // No space for the FAM
struct request *rp;

if (fread(&req_hdr, sizeof(req_hdr), 1, fp) != 1)
    …EOF or other problems…
rp = malloc(sizeof(*rp) + req_hdr->pref_seats_size * sizeof(rp->pref_seat_list[0]));
// … error check allocation …
*rp = req_hdr;
if (fread(rp->pref_seat_list, sizeof(rp->pref_seat_list[0]) * rp->pref_seats_size, 1, fp) != 1)
    …Protocol error…

第一次读取得到的是固定大小的数据，这也告诉接收进程接下来要接收多少可变长度的数据。它分配正确的空间，然后将可变长度数据读入分配的结构。

请注意，这确实假定接收端的进程与发送进程具有相同的大小特征。由于您使用的是 FIFO，因此您的 I/O 位于一台机器上，但理论上，如果发送进程是 64 位而接收进程是 32 位，则其他类型可能会出现问题，反之亦然— 除了你正在处理 int 类型(假设 pid_t 是 int 或伪装的 unsigned )这将无论 32 位还是 64 位问题，都可能都是 32 位的。对于其他类型或更复杂的结构，或者如果您使用的是网络连接而不是本地连接，您将不得不更加努力地工作才能在所有情况下准确发送数据。

---

POC代码

此代码可在我的 SOQ 中找到(堆栈溢出问题)GitHub 上的存储库，文件为 send29.c、recv29.c、dumpreq.c 和 request.h 在 src/so-5030-9324子目录。

此代码使用我的标准错误报告函数，这些函数也可以在我的 GitHub 上的 SOQ 存储库中作为文件 stderr.c 和 stderr.h 在 src/libsoq 中找到。子目录。

请求.h

#ifndef REQUEST_H_INCLUDED
#define REQUEST_H_INCLUDED

#define FIFO_NAME "seat-request.fifo"

struct request
{
    int pid;
    int num_wanted_seats;
    int pref_seats_size;
    int pref_seat_list[];
};

extern void dump_request(const char *tag, const struct request *rp);

#endif /* REQUEST_H_INCLUDED */

send29.c

#include "request.h"
#include "stderr.h"     /* See https://github.com/jleffler/soq/tree/master/src/libsoq */
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>   /* mkfifo() */
#include <unistd.h>

int main(int argc, char **argv)
{
    if (argc > 0)               // Use argc - avoid unused argument warning
        err_setarg0(argv[0]);

    /* Maybe the other program already created it? */
    if (mkfifo(FIFO_NAME, 0666) != 0 && errno != EEXIST)
        err_syserr("failed to create FIFO %s: ", FIFO_NAME);

    FILE *fp = fopen(FIFO_NAME, "w");
    if (fp == NULL)
        err_syserr("failed to open FIFO %s for writing: ", FIFO_NAME);

    printf("Send: PID %d at work with FIFO %s open for writing\n", (int)getpid(), FIFO_NAME);

    struct request *rp = 0;
    int num_prefs = 10;
    size_t req_size = sizeof(*rp) + num_prefs * sizeof(rp->pref_seat_list[0]);
    rp = malloc(req_size);
    if (rp == 0)
        err_syserr("failed to allocate %zu bytes memory: ", req_size);

    rp->pid = getpid();
    rp->num_wanted_seats = 3;
    rp->pref_seats_size = num_prefs;
    for (int i = 0; i < num_prefs; i++)
        rp->pref_seat_list[i] = 123 + i;

    dump_request("Sender", rp);

    if (fwrite(rp, req_size, 1, fp) != 1)
        err_syserr("failed to write request (%zu bytes) to FIFO %s: ", req_size, FIFO_NAME);

    free(rp);
    fclose(fp);
    unlink(FIFO_NAME);
    printf("Send: PID %d finished writing %zu bytes to FIFO %s\n", (int)getpid(), req_size, FIFO_NAME);
    return 0;
}

recv29.c

#include "request.h"
#include "stderr.h"     /* See https://github.com/jleffler/soq/tree/master/src/libsoq */
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>   /* mkfifo() */
#include <unistd.h>

int main(int argc, char **argv)
{
    if (argc > 0)               // Use argc - avoid unused argument warning
        err_setarg0(argv[0]);

    /* Maybe the other program already created it? */
    if (mkfifo(FIFO_NAME, 0666) != 0 && errno != EEXIST)
        err_syserr("failed to create FIFO %s: ", FIFO_NAME);

    int fd = open(FIFO_NAME, O_RDONLY);
    if (fd < 0)
        err_syserr("failed to open FIFO %s for reading: ", FIFO_NAME);

    printf("Recv: PID %d at work with FIFO %s open for reading\n", (int)getpid(), FIFO_NAME);

    struct request req;
    struct request *rp = 0;
    if (read(fd, &req, sizeof(req)) != sizeof(req))
    {
        /* Marginally dubious error reporting; if the return value is
        ** positive but small, errno has no useful information in it.
        */
        err_syserr("failed to read %zu bytes for head from FIFO %s: ", sizeof(req), FIFO_NAME);
    }
    size_t req_size = sizeof(*rp) + req.pref_seats_size * sizeof(rp->pref_seat_list[0]);
    rp = malloc(req_size);
    if (rp == 0)
        err_syserr("failed to allocate %zu bytes memory: ", req_size);

    *rp = req;

    int nbytes = rp->pref_seats_size * sizeof(rp->pref_seat_list[0]);
    //if (read(fd, &rp->pref_seat_list[0], nbytes) != nbytes)
    if (read(fd, rp->pref_seat_list, nbytes) != nbytes)
        err_syserr("failed to read %d bytes for body from FIFO %s: ", nbytes, FIFO_NAME);

    dump_request("Receiver", rp);

    free(rp);
    close(fd);
    unlink(FIFO_NAME);
    printf("Recv: PID %d finished reading request from FIFO %s\n", (int)getpid(), FIFO_NAME);
    return 0;
}

dumpreq.c

#include "request.h"
#include <stdio.h>

void dump_request(const char *tag, const struct request *rp)
{
    printf("%s:\n", tag);
    printf("- PID requesting seats: %d\n", rp->pid);
    printf("- Number of seats wanted: %d\n", rp->num_wanted_seats);
    printf("- Number of seats in preferred list: %d\n", rp->pref_seats_size);
    for (int i = 0; i < rp->pref_seats_size; i++)
        printf("  %d is seat %d\n", i, rp->pref_seat_list[i]);
    fflush(stdout);
}

sample 运行

$ send29 & recv29
[1] 55896
Send: PID 55896 at work with FIFO seat-request.fifo open for writing
Sender:
- PID requesting seats: 55896
- Number of seats wanted: 3
- Number of seats in preferred list: 10
  0 is seat 123
  1 is seat 124
  2 is seat 125
  3 is seat 126
  4 is seat 127
  5 is seat 128
  6 is seat 129
  7 is seat 130
  8 is seat 131
Recv: PID 55897 at work with FIFO seat-request.fifo open for reading
  9 is seat 132
Receiver:
- PID requesting seats: 55896
- Number of seats wanted: 3
- Number of seats in preferred list: 10
  0 is seat 123
  1 is seat 124
  2 is seat 125
  3 is seat 126
  4 is seat 127
  5 is seat 128
  6 is seat 129
  7 is seat 130
  8 is seat 131
  9 is seat 132
Send: PID 55896 finished writing 52 bytes to FIFO seat-request.fifo
Recv: PID 55897 finished reading request from FIFO seat-request.fifo
[1]+  Done                    send29
$

您可以按任一顺序运行程序(因此 recv29 & send29 也可以)。