Question

请考虑以下代码：

writer.c

mkfifo("/tmp/myfifo", 0660);

int fd = open("/tmp/myfifo", O_WRONLY);

char *foo, *bar;

...

write(fd, foo, strlen(foo)*sizeof(char));
write(fd, bar, strlen(bar)*sizeof(char));

reader.c

int fd = open("/tmp/myfifo", O_RDONLY);

char buf[100];
read(fd, buf, ??);

我的问题是：

由于事先不知道foo和bar有多少字节，我怎么知道从reader.c读取多少字节？因为，例如，如果我在阅读器中读取10个字节，而foo和bar一起读取的字节少于10个字节，我将把它们放在同一个变量中并且我不想要它。
理想情况下，我会为每个变量都有一个读取函数，但我不知道手头有多少字节我想在write.c中使用分隔符在write for foo和bar之间添加另一个写指令，然后我就没有问题从reader.c解码它。这是怎么回事呢？

感谢。

Answer 1

许多其他答案提到为您的数据使用某种协议，我相信这是正确的方法。该协议可以根据需要简单或复杂。我提供了一些您可能会发现有用的示例¹。

在一个简单的例子中，您可能只有一个长度字节后跟数据字节（即C字符串）。

+--------------+
| length byte  |
+--------------+
| data byte(s) |
+--------------+

<强>编剧：

uint8_t foo[UCHAR_MAX+1];
uint8_t len;
int fd;

mkfifo("/tmp/myfifo", 0660);
fd = open("/tmp/myfifo", O_WRONLY);

memset(foo, UCHAR_MAX+1, 0);
len = (uint8_t)snprintf((char *)foo, UCHAR_MAX, "Hello World!");

/* The length byte is written first followed by the data. */
write(fd, len, 1);
write(fd, foo, strlen(foo));

<强>阅读器：

uint8_t buf[UCHAR_MAX+1];
uint8_t len;
int fd;

fd = open("/tmp/myfifo", O_RDONLY);

memset(buf, UCHAR_MAX+1, 0);

/* The length byte is read first followed by a read 
 * for the specified number of data bytes.
 */
read(fd, len, 1);
read(fd, buf, len);

在更复杂的情况下，您可能有一个长度字节，后跟包含多个简单C字符串的数据字节。

+----------------+
|  length byte   |
+----------------+
| data type byte |
+----------------+
|  data byte(s)  |
+----------------+

Common Header：

#define FOO_TYPE 100
#define BAR_TYPE 200

typedef struct {
    uint8_t type;
    uint32_t flags;
    int8_t msg[20];
} __attribute__((aligned, packed)) foo_t;

typedef struct {
    uint8_t type;
    uint16_t flags;
    int32_t value;
} __attribute__((aligned, packed)) bar_t;

<强>编剧：

foo_t foo;
unsigned char len;
int fd;

mkfifo("/tmp/myfifo", 0660);
fd = open("/tmp/myfifo", O_WRONLY);

memset(&foo, sizeof(foo), 0);
foo.type = FOO_TYPE;
foo.flags = 0xDEADBEEF;
snprintf(foo.msg, 20-1, "Hello World!");

/* The length byte is written first followed by the data. */
len = sizeof(foo);
write(fd, len, 1);
write(fd, foo, sizeof(foo));

<强>阅读器：

uint8_t buf[UCHAR_MAX+1];
uint8_t len;
uint16_t type;
union data {
    foo_t * foo;
    bar_t * bar;
}
int fd;

fd = open("/tmp/myfifo", O_RDONLY);

memset(buf, UCHAR_MAX+1, 0);

/* The length byte is read first followed by a read 
 * for the specified number of data bytes.
 */
read(fd, len, 1);
read(fd, buf, len);

/* Retrieve the message type from the beginning of the buffer. */
memcpy(&type, buf, sizeof(type));

/* Process the data depending on the type. */
switch(type) {
    case FOO_TYPE:
        data.foo = (foo_t)buf;
        printf("0x%08X: %s\n", data.foo.flags, data.foo.msg); 
        break;
    case BAR_TYPE:
        data.bar = (bar_t)buf;
        printf("0x%04X: %d\n", data.bar.flags, data.bar.value); 
        break;
    default:
        printf("unrecognized type\n");
}

_{1 - 此代码是从内存中编写的，未经测试。}

Answer 2

分隔符是一种方法，只要您知道数据的顺序，并且只使用分隔符作为分隔符，并且永远不会将其作为数据的一部分，这样就可以正常工作。

另一种方法是在每次写入管道之前，使用固定宽度的字节数。因此，您将知道有多少数据即将进入管道。使用固定的宽度，因此您可以确切地知道宽度字段的长度，因此您知道何时开始和停止读取每个数据块。

Answer 3

分隔符实际上是一种方法 - 而且很方便，C字符串带有这样的分隔符 - 字符串末尾的nul-terminator。

如果您更改了write()来电，那么他们也会写出nul-terminator（请注意sizeof(char)定义为1，因此可以省略）：

write(fd, foo, strlen(foo) + 1);
write(fd, bar, strlen(bar) + 1);

然后你可以在读取它们之后将它们分开（你仍然需要将它们读入一个缓冲区，然后将它们分开，除非你一次读取它们。）

Answer 4

为了略微概括WhirlWind的答案，你必须建立一个多种协议。正如你所指出的那样，必须对你发送的内容进行排序，否则你就不知道从底部开始。

WhirlWind的两个建议都有效。您还可以在管道或FIFO之上实现自定义（或标准）协议，以便将代码移植到具有不同系统的更分散的环境中，并在以后更轻松地完成任务。然而，问题的关键在于，在你能够进行实际沟通之前，你必须设置RULES进行沟通。

Answer 5

您必须定义某种线路协议或序列化/反序列化格式，以便您的读者知道如何解释它从fifo读取的数据。使用分隔符是解决此问题的最简单方法，但如果分隔符作为编写器数据输出的一部分出现，则会遇到问题。

在复杂程度上稍微远一些，您的协议可能会定义分隔符和指示您要发送的数据的每个“部分”或“消息”的长度的方式。

最后，通过编写序列化消息可以更彻底地解决这个问题，然后您的编写器将在接收后反序列化。您可能有兴趣使用Protocol Buffers或Thrift之类的东西来实现这一目标（还有一个额外的好处，即您可以使用多种不同的编程语言实现您的读者或作者，而无需修改您的协议）。

FIFO的实施

5 个答案: