Correct way to write/read data over a fifo - c

Question

I've created, as an homework, a big project which simulate a mailbox server (only through process on the same computer, so through fifo, it's a homework)
I can't post the project because is big (there are a lot of files), but I can say that sometimes I lost some data or it doesn't preserve it's integrity.
I use these code snippet to transmit data, is it somewhat wrong?Network_IO is the function I'm talking about:
#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;
}
Edit 1: Code snippet which I'm using to test actually
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

IMHO the Network_IO() function serves no purpose. It's only purpose is to 'demultiplex' the opcodes for read/write calls, that were given to it by the Network_Send() and Network_Receive() functions. Better would be to call read() and write directly in the Network_Send() and Network_Receive() functions. Your choice of return type (Boolean) is also strange.
The error conditions on read() and write() could be different, in the future maybe more than just EINTR needs to be handled in one of them. Also: your functions block, that means: they don't return until the desired amount has actually been sent or received. Also note that for pipes and fifos, the amount of bufferspace supplied by the kernel is very limited, typically 1 memory page. This increases the chance of the reader or writer blocking in reads or writes, and results in (at least) two context switches per block of data transferred.
The "loop until done" method; as supplied by Mat is about the standard way of doing things. Also be be prepared for read/write returning zero.
EDIT: what Mat meant is that you need to handle partial reads/writes: you need to start over where you left off, sending/receiving the remaining part of the buffer. Here is a start:
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

For the write case, your code boils down to
while ((retsize = write(fifo,data,tmpDataSize)) != tmpDataSize) { ... }
Imagine that on the first write, only one byte gets written. If that happens, you need the next write to attempt to push tmpDataSize-1 bytes, starting at data+1. But what you do now will resend everything, including that first byte.
In pseudo-code, the logic should be something like:
while (bytesLeftToSend > 0) {
sent = write(fifo, data, bytesLeftToSend);
if (sent == -1) {
// report error and bail out
}
bytesLeftToSend -= sent;
data += sent;
}
Same thing for the read case.
BTW, that while with an assignment and a ?: construct is really hard to read.