通过重叠的IO进行异步命名Windows管道通信

Question

I'm using overlapped IO to read and write a single Windows pipe in C code simultantiously. I want to write a synchronous function to read and write data from seperate threads. If you are using synchronous IO you cannot read and write the pipe simultaniously. My client and my server are using the same write/read functions. Time by time my client sends data that is never received by the server. Does anyone have an idea how this could happen? If I use synchronous IO in the client everything works as expected.

The server pipe is opened by the following cmd:

CreateNamedPipe(pipeName, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED, PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
                                      instances, PIPE_BUF_SIZE, PIPE_BUF_SIZE, 0, NULL); 

The client pipe is opend this way:

CreateFile(pipeName, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);

I'm using these read function:

int readBytesPipeCommChannel(PipeCommChannelData* comm, uint32_t* amount)
    OVERLAPPED osRead;
    memset(&osRead, 0, sizeof(osRead));  
    osRead.hEvent = comm->readAsyncIOEvent;

    int err = 0;
    if(!ReadFile(comm->pipeH, comm->receiveBuffer, sizeof(comm->receiveBuffer), amount, &osRead))
    {   
        err = GetLastError();     
        if (err == ERROR_IO_PENDING)
        {
            if(WaitForSingleObject(osRead.hEvent, INFINITE))
            {
                GetOverlappedResult(comm->pipeH, &osRead, amount, TRUE);
            }
            else
            {
                CancelIo(comm->pipeH);
                return PIPE_EVENT_ERROR;
            }
        }
        else if(err != ERROR_BROKEN_PIPE)
        {
            return PIPE_READ_ERROR;
        }
    }
    if(err == ERROR_BROKEN_PIPE)
        return PIPE_BROKEN_ERR;

    return PIPE_OK;
}

And last but not least the write function:

int sendBytesPipeCommChannel(PipeCommChannelData* comm, const uint8_t* bytes, uint32_t amount)
{
    OVERLAPPED osWrite;
    memset(&osWrite, 0, sizeof(osWrite));  
    osWrite.hEvent = comm->writeAsyncIOEvent;

    uint32_t bytesWritten = 0; 
    for(uint32_t curPos = 0; curPos < amount; curPos += bytesWritten)
    {
        if(!WriteFile(comm->pipeH, &bytes[curPos], (amount - curPos), &bytesWritten, &osWrite))
        {
            if (GetLastError() != ERROR_IO_PENDING)
                return PIPE_WRITE_ERR; 

            if(!WaitForSingleObject(osWrite.hEvent, INFINITE))
            {
                CancelIo(comm->pipeH);
                return PIPE_EVENT_ERROR;
            }
        }
    }
    return PIPE_OK;
}

Answer 1

The documentation for ReadFile says:

If hFile was opened with FILE_FLAG_OVERLAPPED , the following conditions are in effect:

The lpNumberOfBytesRead parameter should be set to NULL . Use the GetOverlappedResult function to get the actual number of bytes read.

This applies even if the operation completes synchronously.