Function async_pipe_read

lib/asyncpipe.c:136–223

}

ssize_t async_pipe_read(hamlib_async_pipe_t *pipe, void *buf, size_t count,
                        int timeout)
{
    HANDLE event_handles[1] =
    {
        pipe->read_overlapped.hEvent,
    };
    HANDLE read_handle = pipe->read;
    LPOVERLAPPED overlapped = &pipe->read_overlapped;
    DWORD wait_result;
    int result;
    ssize_t bytes_read = 0;

    result = ReadFile(read_handle, buf, count, NULL, overlapped);

    if (!result)
    {
        result = GetLastError();

        switch (result)
        {
        case ERROR_SUCCESS:
            // No error?
            break;

        case ERROR_IO_PENDING:
            wait_result = WaitForMultipleObjects(1, event_handles, FALSE, timeout);

            switch (wait_result)
            {
            case WAIT_OBJECT_0 + 0:
                break;

            case WAIT_TIMEOUT:
                if (count == 0)
                {
                    // Zero-length reads are used to wait for incoming data,
                    // so the I/O operation needs to be cancelled in case of a timeout
                    CancelIo(read_handle);
                    return -RIG_ETIMEOUT;
                }
                else
                {
                    // Should not happen, as reads with count > 0 are used only when there is data available in the pipe
                    return -RIG_EINTERNAL;
                }

            default:
                result = GetLastError();
                rig_debug(RIG_DEBUG_ERR, "%s: WaitForMultipleObjects() error: %d\n", __func__,
                          result);
                return -RIG_EINTERNAL;
            }

            break;

        default:
            rig_debug(RIG_DEBUG_ERR, "%s: ReadFile() error: %d\n", __func__, result);