ra8_io_stream_posix.c

Go to the documentation of this file.

 
#ifndef RA8_OFF_TARGET
#error "port/posix is host-only and must never be compiled or linked into target firmware."
#endif
 
#include "ra8_io_stream_posix.h"
 
#include <errno.h>
#include <stdint.h> // ra8-keep-include: `uint8_t` used directly
#include <unistd.h>
 
#include "ra8_attributes.h" // ra8-keep-include: `RA8_INTERNAL` and `RA8_PRIV` used directly
#include "ra8_err.h"        // ra8-keep-include: `ra8_err_t` used directly
#include "ra8_io_stream_backend.h"
#include "ra8_io_stream_posix_internal.h"

typedef enum : uint32_t {
  k_posix_write_interrupt_limit = 16U, 
} ra8_io_stream_posix_const_t;

RA8_INTERNAL static ra8_err_t internal_map_errno(int error_number)
{
  if (error_number == 0) {
    return k_ra8_err_protocol_error;
  }
  if (error_number == EAGAIN
#if defined(EWOULDBLOCK) && (EWOULDBLOCK != EAGAIN)
      || error_number == EWOULDBLOCK
#endif
  ) {
    return k_ra8_err_would_block;
  }
  if (error_number == EBADF) {
    return k_ra8_err_invalid_state;
  }
  if (error_number == ENOSPC || error_number == EDQUOT) {
    return k_ra8_err_no_mem;
  }
  if (error_number == EACCES || error_number == EPERM) {
    return k_ra8_err_access_denied;
  }
  if (error_number == EFBIG || error_number == EOVERFLOW) {
    return k_ra8_err_invalid_size;
  }
  if (error_number == EINVAL) {
    return k_ra8_err_invalid_arg;
  }
  if (error_number == EPIPE || error_number == EIO) {
    return k_ra8_err_comm_error;
  }
  return k_ra8_fail;
}

RA8_INTERNAL static ra8_err_t internal_write_loop_step(int                            fd,
                                                       const uint8_t*                 bytes,
                                                       uint32_t                       length,
                                                       uint32_t*                      done,
                                                       uint32_t*                      interrupts,
                                                       ra8_io_stream_posix_write_fn_t writer,
                                                       void* writer_context)
{
  int           error_number = 0;
  const int64_t result = writer(writer_context, fd, &bytes[*done], length - *done, &error_number);
  if (result < 0) {
    if (error_number == EINTR) {
      ++*interrupts;
      if (*interrupts > (uint32_t)k_posix_write_interrupt_limit) {
        return k_ra8_err_retry_limit;
      }
      return k_ra8_ok;
    }
    return internal_map_errno(error_number);
  }
  if ((result == 0) || ((uint64_t)result > (uint64_t)(length - *done))) {
    return k_ra8_err_protocol_error;
  }
  *done += (uint32_t)result;
  return k_ra8_ok;
}
 
RA8_PRIV ra8_err_t priv_ra8_io_stream_posix_write_loop(int                            fd,
                                                       const uint8_t*                 bytes,
                                                       uint32_t                       length,
                                                       uint32_t*                      out_written,
                                                       ra8_io_stream_posix_write_fn_t writer,
                                                       void* writer_context)
{
  if ((bytes == nullptr) || (out_written == nullptr) || (writer == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  *out_written        = 0U;
  uint32_t done       = 0U;
  uint32_t interrupts = 0U;
  RA8_LOOP_BOUND(UINT32_MAX);
  while (done < length) {
    const ra8_err_t err =
      internal_write_loop_step(fd, bytes, length, &done, &interrupts, writer, writer_context);
    if (err != k_ra8_ok) {
      *out_written = done;
      return err;
    }
  }
  *out_written = done;
  return k_ra8_ok;
}

RA8_INTERNAL static int64_t
internal_native_write(void* context, int fd, const uint8_t* bytes, uint32_t length, int* out_errno)
{
  (void)context;
  const ssize_t result = write(fd, bytes, (size_t)length);
  *out_errno           = (result < 0) ? errno : 0;
  return (int64_t)result;
}

RA8_INTERNAL static ra8_err_t
internal_posix_write(void* context, const uint8_t* bytes, uint32_t length, uint32_t* out_written)
{
  const ra8_io_stream_posix_state_t* state = (const ra8_io_stream_posix_state_t*)context;
  return priv_ra8_io_stream_posix_write_loop(state->fd,
                                             bytes,
                                             length,
                                             out_written,
                                             internal_native_write,
                                             nullptr);
}

static const ra8_io_stream_iface_t s_posix_stream_iface = {
  .write = internal_posix_write,
  .flush = nullptr,
};
 
ra8_err_t
ra8_io_stream_posix_init(ra8_io_stream_t* stream, ra8_io_stream_posix_state_t* state, int fd)
{
  if ((stream == nullptr) || (state == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if (fd < 0) {
    return k_ra8_err_invalid_arg;
  }
  ra8_io_stream_posix_state_t candidate = {.fd = fd};
  const ra8_err_t             error     = ra8_io_stream_bind(stream, &s_posix_stream_iface, state);
  if (error != k_ra8_ok) {
    return error;
  }
  *state = candidate;
  return k_ra8_ok;
}