通过 fifo 写入/读取数据的正确方法

Question

作为作业，我创建了一个模拟邮箱服务器的大项目（仅通过同一台计算机上的进程，因此通过 fifo，这是一个作业）

我无法发布该项目，因为它很大（有很多文件），但我可以说有时我会丢失一些数据或者它不能保持其完整性。

我使用这些代码片段来传输数据，是不是有些错误？Network_IO 是我正在谈论的功能：

#include "Network.h"

int Network_Open(const char* path,int oflag)
{
    return open(path,oflag);
}

ssize_t Network_IO(int fifo,NetworkOpCodes opcode,void* data,size_t dataSize)
{
    ssize_t retsize = 0;
    ssize_t tmpDataSize = (ssize_t)dataSize;
    errno = 0;

    if (tmpDataSize == 0) return 0;

    while ((retsize = (opcode == NetworkOpCode_Write? write(fifo,data,tmpDataSize) : read(fifo,data,tmpDataSize))) != tmpDataSize)
    {
        if (errno != EINTR) break;
    }

    return retsize;
}

Boolean Network_Send(int fifo,const void* data,size_t dataSize)
{
    return ((ssize_t)dataSize) == Network_IO(fifo,NetworkOpCode_Write,(void*)data,dataSize);
}

Boolean Network_Receive(int fifo,void* data,size_t dataSize)
{
    return ((ssize_t)dataSize) == Network_IO(fifo,NetworkOpCode_Read,data,dataSize);
}

Boolean Network_Close(int fifo)
{
    if (fifo >= 0)
        return close(fifo) == 0;
}

编辑 1： 我用来实际测试的代码片段

Boolean Network_IO(int fifo,NetworkOpCodes opcode,void* data,size_t dataSize)
{
    ssize_t retsize = 0;
    ssize_t tmpDataSize = (ssize_t)dataSize;
    ssize_t sentDataSize = 0;
    errno = 0;

    if (tmpDataSize == 0) return True;

    while (sentDataSize < tmpDataSize)
    {
        switch(opcode)
        {
            case NetworkOpCode_Write:
                retsize = write(fifo,data + sentDataSize,tmpDataSize - sentDataSize);
                break;
            case NetworkOpCode_Read:
                retsize = read(fifo,data + sentDataSize,tmpDataSize - sentDataSize);
                break;
        }
        if (retsize < 0)
        {
            if (errno != EINTR) return False;
            else
            {
                errno = 0;
                continue;
            }
        }
        sentDataSize += retsize;
    }

    if (errno != 0)
        return False;

    return sentDataSize == tmpDataSize;
}

Boolean Network_Send(int fifo,const void* data,size_t dataSize)
{
    return Network_IO(fifo,NetworkOpCode_Write,(void*)data,dataSize);
}

Boolean Network_Receive(int fifo,void* data,size_t dataSize)
{
    return Network_IO(fifo,NetworkOpCode_Read,data,dataSize);
}

Answer 1

恕我直言，Network_IO() 函数没有任何作用。它的唯一目的是“多路分解”读/写调用的操作码，这些操作码由 Network_Send() 和 Network_Receive() 函数提供给它。更好的方法是直接在 Network_Send() 和 Network_Receive() 函数中调用 read() 并写入。您选择的返回类型（布尔值）也很奇怪。

read() 和 write() 上的错误条件可能不同，将来可能不仅仅需要在其中之一中处理 EINTR。另外：您的函数阻止，这意味着：在实际发送或接收所需的金额之前，它们不会返回。另请注意，对于管道和 fifo，内核提供的缓冲区空间量非常有限，通常为 1 个内存页。这增加了读取器或写入器阻塞读取或写入的机会，并导致每个传输的数据块（至少）两次上下文切换。

“循环直到完成”方法； Mat 提供的内容是关于做事的标准方式。还要做好读/写返回零的准备。

编辑：Mat 的意思是您需要处理部分读/写：您需要从上次中断的地方开始，发送/接收缓冲区的剩余部分。这是一个开始：

int mywrite(int fd, char *buff, size_t size)
{
int rc;
size_t done, todo;

for (done=0; done < size; ) {
    todo = size - done;
    rc = write (fd, buff+done, todo);
    switch (rc) {
    case -1: /* some read error: check it */
        switch(errno) {
        case EINTR: continue;
        /* ... maybe some other cases you need to handle */
        default: return -1;
            }
        break;
    case 0: /* (in some cases) the other side closed the connection */
        /* handle it here; possibly return error */
        break;
    default: /* the normal case */
        done += rc;
        break;
        }
    }
return done;
}

Answer 2

对于 write 情况，您的代码可以归结为

while ((retsize = write(fifo,data,tmpDataSize)) != tmpDataSize) { ... }

想象一下，在第一个 write 上，仅写入一个字节。如果发生这种情况，您需要下一个 write 尝试从 data+1 开始推送 tmpDataSize-1 字节。但是您现在所做的将重新发送所有内容，包括第一个字节。

在伪代码中，逻辑应该类似于：

while (bytesLeftToSend > 0) {
 sent = write(fifo, data, bytesLeftToSend);
 if (sent == -1) {
   // report error and bail out
 }
 bytesLeftToSend -= sent;
 data += sent;
}

读取情况相同。

顺便说一句，虽然带有赋值和 ?: 构造，但确实很难阅读。