default.h

Go to the documentation of this file.

 
#ifndef LELY_IO_INTERN_DEFAULT_H_
#define LELY_IO_INTERN_DEFAULT_H_
 
#include "handle.h"
#include "io.h"
#include <lely/util/errnum.h>
 
#include <assert.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#if defined(_WIN32) || _POSIX_C_SOURCE >= 200112L
 
static inline void default_fini(struct io_handle *handle);
static inline int default_flags(struct io_handle *handle, int flags);
static inline ssize_t default_read(
                struct io_handle *handle, void *buf, size_t nbytes);
static inline ssize_t default_write(
                struct io_handle *handle, const void *buf, size_t nbytes);
 
static inline void
default_fini(struct io_handle *handle)
{
        assert(handle);
 
        if (!(handle->flags & IO_FLAG_NO_CLOSE))
#ifdef _WIN32
                CloseHandle(handle->fd);
#else
                close(handle->fd);
#endif
}
 
static inline int
default_flags(struct io_handle *handle, int flags)
{
        assert(handle);
 
#ifdef _WIN32
        (void)handle;
        (void)flags;
 
        return 0;
#else
        int arg = fcntl(handle->fd, F_GETFL, 0);
        if (__unlikely(arg == -1))
                return -1;
 
        if ((flags & IO_FLAG_NONBLOCK) && !(arg & O_NONBLOCK))
                return fcntl(handle->fd, F_SETFL, arg | O_NONBLOCK);
        else if (!(flags & IO_FLAG_NONBLOCK) && (arg & O_NONBLOCK))
                return fcntl(handle->fd, F_SETFL, arg & ~O_NONBLOCK);
        return 0;
#endif
}
 
static inline ssize_t
default_read(struct io_handle *handle, void *buf, size_t nbytes)
{
        assert(handle);
 
#ifdef _WIN32
        DWORD dwErrCode = GetLastError();
 
        OVERLAPPED overlapped = { 0 };
        overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
        if (__unlikely(!overlapped.hEvent)) {
                dwErrCode = GetLastError();
                goto error_CreateEvent;
        }
 
        DWORD dwNumberOfBytesRead = 0;
 
retry:
        io_handle_lock(handle);
        int flags = handle->flags;
        io_handle_unlock(handle);
 
        // clang-format off
        if (ReadFile(handle->fd, buf, nbytes, &dwNumberOfBytesRead,
                        &overlapped))
                // clang-format on
                goto done;
 
        switch (GetLastError()) {
        case ERROR_IO_PENDING: break;
        case ERROR_OPERATION_ABORTED:
                if (__likely(ClearCommError(handle->fd, NULL, NULL)))
                        goto retry;
                // ... falls through ...
        default: dwErrCode = GetLastError(); goto error_ReadFile;
        }
 
        // clang-format off
        if ((flags & IO_FLAG_NONBLOCK) && __unlikely(!CancelIoEx(handle->fd,
                        &overlapped) && GetLastError() == ERROR_NOT_FOUND)) {
                // clang-format on
                dwErrCode = GetLastError();
                goto error_CancelIoEx;
        }
 
        // clang-format off
        if (__unlikely(!GetOverlappedResult(handle->fd, &overlapped,
                        &dwNumberOfBytesRead, TRUE))) {
                // clang-format on
                dwErrCode = GetLastError();
                goto error_GetOverlappedResult;
        }
 
        if (__unlikely(nbytes && !dwNumberOfBytesRead)) {
                if (!(flags & IO_FLAG_NONBLOCK))
                        goto retry;
                dwErrCode = errnum2c(ERRNUM_AGAIN);
                goto error_dwNumberOfBytesRead;
        }
 
done:
        CloseHandle(overlapped.hEvent);
        SetLastError(dwErrCode);
        return dwNumberOfBytesRead;
 
error_dwNumberOfBytesRead:
error_GetOverlappedResult:
error_CancelIoEx:
error_ReadFile:
        CloseHandle(overlapped.hEvent);
error_CreateEvent:
        SetLastError(dwErrCode);
        return -1;
#else
        ssize_t result;
        int errsv = errno;
        do {
                errno = errsv;
                result = read(handle->fd, buf, nbytes);
        } while (__unlikely(result == -1 && errno == EINTR));
        return result;
#endif
}
 
static inline ssize_t
default_write(struct io_handle *handle, const void *buf, size_t nbytes)
{
        assert(handle);
 
#ifdef _WIN32
        DWORD dwErrCode = GetLastError();
 
        OVERLAPPED overlapped = { 0 };
        overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
        if (__unlikely(!overlapped.hEvent)) {
                dwErrCode = GetLastError();
                goto error_CreateEvent;
        }
 
        DWORD dwNumberOfBytesWritten = 0;
 
retry:
        io_handle_lock(handle);
        int flags = handle->flags;
        io_handle_unlock(handle);
 
        // clang-format off
        if (WriteFile(handle->fd, buf, nbytes, &dwNumberOfBytesWritten,
                        &overlapped))
                // clang-format on
                goto done;
 
        switch (GetLastError()) {
        case ERROR_IO_PENDING: break;
        case ERROR_OPERATION_ABORTED:
                if (__likely(ClearCommError(handle->fd, NULL, NULL)))
                        goto retry;
                // ... falls through ...
        default: dwErrCode = GetLastError(); goto error_WriteFile;
        }
 
        // clang-format off
        if ((flags & IO_FLAG_NONBLOCK) && __unlikely(!CancelIoEx(handle->fd,
                        &overlapped) && GetLastError() == ERROR_NOT_FOUND)) {
                // clang-format on
                dwErrCode = GetLastError();
                goto error_CancelIoEx;
        }
 
        // clang-format off
        if (__unlikely(!GetOverlappedResult(handle->fd, &overlapped,
                        &dwNumberOfBytesWritten, TRUE))) {
                // clang-format on
                dwErrCode = GetLastError();
                goto error_GetOverlappedResult;
        }
 
        if (__unlikely(nbytes && !dwNumberOfBytesWritten)) {
                if (!(flags & IO_FLAG_NONBLOCK))
                        goto retry;
                dwErrCode = errnum2c(ERRNUM_AGAIN);
                goto error_dwNumberOfBytesWritten;
        }
 
done:
        CloseHandle(overlapped.hEvent);
        SetLastError(dwErrCode);
        return dwNumberOfBytesWritten;
 
error_dwNumberOfBytesWritten:
error_GetOverlappedResult:
error_CancelIoEx:
error_WriteFile:
        CloseHandle(overlapped.hEvent);
error_CreateEvent:
        SetLastError(dwErrCode);
        return -1;
#else
        ssize_t result;
        int errsv = errno;
        do {
                errno = errsv;
                result = write(handle->fd, buf, nbytes);
        } while (__unlikely(result == -1 && errno == EINTR));
        return result;
#endif
}
 
#endif // _WIN32 || _POSIX_C_SOURCE >= 200112L
 
#ifdef __cplusplus
}
#endif
 
#endif // !LELY_IO_INTERN_DEFAULT_H_