mkfontimg_host.c

Go to the documentation of this file.

 
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h> /* POSIX renameat declaration; no hosted stream is used. */
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
 
#include "mkfontimg_internal.h"
#include "ra8_attributes.h"
#include "ra8_err.h"
#include "ra8_fs.h"
 
#ifndef O_CLOEXEC
#define O_CLOEXEC (0)
#endif
 
#ifndef O_DIRECTORY
#define O_DIRECTORY (0)
#endif
 
#ifndef O_NOFOLLOW
#define O_NOFOLLOW (0)
#endif

typedef enum : uint32_t {
  k_host_stream_chunk   = 16U * 1024U, 
  k_host_temp_attempts  = 128U,        
  k_host_decimal_digits = 20U,         
  k_host_decimal_base   = 10U,         
  k_host_create_mode    = 0666U,       
} host_limit_t;

typedef struct {
  dev_t    device;        
  ino_t    inode;         
  uint64_t size;          
  time_t   modified_sec;  
  long     modified_nsec; 
  time_t   changed_sec;   
  long     changed_nsec;  
} host_input_identity_t;
 
RA8_PRIV void priv_mkfontimg_diag(const char* text)
{
  size_t offset = 0U;
  size_t length = strlen(text);
  while (offset < length) {
    const ssize_t written = write(STDERR_FILENO, &text[offset], length - offset);
    if ((written < 0) && (errno == EINTR)) {
      continue;
    }
    if (written <= 0) {
      return;
    }
    offset += (size_t)written;
  }
}
 
RA8_PRIV void priv_mkfontimg_diag_u64(uint64_t value)
{
  char   reverse[k_host_decimal_digits];
  char   forward[k_host_decimal_digits + 1U];
  size_t digits = 0U;
  do {
    reverse[digits++] = (char)('0' + (value % (uint64_t)k_host_decimal_base));
    value /= (uint64_t)k_host_decimal_base;
  } while (value != 0U);
  for (size_t i = 0U; i < digits; ++i) {
    forward[i] = reverse[digits - i - 1U];
  }
  forward[digits] = '\0';
  priv_mkfontimg_diag(forward);
}

RA8_INTERNAL static bool
internal_pread_exact(int fd, uint64_t offset, uint8_t* bytes, size_t length)
{
  if (offset > (uint64_t)INT64_MAX || length > ((uint64_t)INT64_MAX - offset)) {
    return false;
  }
  size_t done = 0U;
  while (done < length) {
    size_t request = length - done;
    if (request > (size_t)SSIZE_MAX) {
      request = (size_t)SSIZE_MAX;
    }
    const ssize_t got = pread(fd, &bytes[done], request, (off_t)(offset + done));
    if ((got < 0) && (errno == EINTR)) {
      continue;
    }
    if (got <= 0) {
      return false;
    }
    done += (size_t)got;
  }
  return true;
}

RA8_INTERNAL static bool
internal_pwrite_exact(int fd, uint64_t offset, const uint8_t* bytes, size_t length)
{
  if (offset > (uint64_t)INT64_MAX || length > ((uint64_t)INT64_MAX - offset)) {
    return false;
  }
  size_t done = 0U;
  while (done < length) {
    size_t request = length - done;
    if (request > (size_t)SSIZE_MAX) {
      request = (size_t)SSIZE_MAX;
    }
    const ssize_t put = pwrite(fd, &bytes[done], request, (off_t)(offset + done));
    if ((put < 0) && (errno == EINTR)) {
      continue;
    }
    if (put <= 0) {
      return false;
    }
    done += (size_t)put;
  }
  return true;
}

RA8_INTERNAL static bool internal_block_range(const mkfontimg_disk_t* disk,
                                              uint64_t                lba,
                                              uint32_t                count,
                                              uint64_t*               out_offset,
                                              size_t*                 out_bytes)
{
  if (lba > disk->block_count || (uint64_t)count > (disk->block_count - lba) ||
      lba > (UINT64_MAX / disk->block_size) || count > (SIZE_MAX / disk->block_size)) {
    return false;
  }
  const uint64_t offset = lba * disk->block_size;
  const size_t   bytes  = (size_t)count * disk->block_size;
  if (offset > (uint64_t)INT64_MAX || bytes > ((uint64_t)INT64_MAX - offset)) {
    return false;
  }
  *out_offset = offset;
  *out_bytes  = bytes;
  return true;
}

RA8_INTERNAL static ra8_err_t
internal_disk_read(void* ctx, uint64_t lba, uint32_t count, uint8_t* buffer)
{
  mkfontimg_disk_t* disk = (mkfontimg_disk_t*)ctx;
  uint64_t          offset;
  size_t            bytes;
  if (disk == nullptr || buffer == nullptr || disk->io_failed ||
      !internal_block_range(disk, lba, count, &offset, &bytes)) {
    return k_ra8_err_out_of_range;
  }
  if (!internal_pread_exact(disk->fd, offset, buffer, bytes)) {
    disk->io_failed = true;
    return k_ra8_fail;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t
internal_disk_write(void* ctx, uint64_t lba, uint32_t count, const uint8_t* buffer)
{
  mkfontimg_disk_t* disk = (mkfontimg_disk_t*)ctx;
  uint64_t          offset;
  size_t            bytes;
  if (disk == nullptr || buffer == nullptr || disk->io_failed ||
      !internal_block_range(disk, lba, count, &offset, &bytes)) {
    return k_ra8_err_out_of_range;
  }
  if (!internal_pwrite_exact(disk->fd, offset, buffer, bytes)) {
    disk->io_failed = true;
    return k_ra8_fail;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t
internal_disk_capacity(void* ctx, uint64_t* block_count, uint32_t* block_size)
{
  const mkfontimg_disk_t* disk = (const mkfontimg_disk_t*)ctx;
  if (disk == nullptr || block_count == nullptr || block_size == nullptr) {
    return k_ra8_err_null_ptr;
  }
  *block_count = disk->block_count;
  *block_size  = disk->block_size;
  return k_ra8_ok;
}

RA8_INTERNAL static bool internal_split_output(const char* path,
                                               char        parent[k_mkfontimg_host_path_cap],
                                               char        leaf[k_mkfontimg_host_name_cap])
{
  const size_t length = strlen(path);
  if (length == 0U || length >= (size_t)k_mkfontimg_host_path_cap) {
    return false;
  }
  size_t slash = length;
  while (slash > 0U && path[slash - 1U] != '/') {
    --slash;
  }
  const size_t leaf_bytes = length - slash;
  if (leaf_bytes == 0U || leaf_bytes >= (size_t)k_mkfontimg_host_name_cap) {
    return false;
  }
  (void)memcpy(leaf, &path[slash], leaf_bytes);
  leaf[leaf_bytes] = '\0';
  if (strcmp(leaf, ".") == 0 || strcmp(leaf, "..") == 0) {
    return false;
  }
  if (slash == 0U) {
    parent[0] = '.';
    parent[1] = '\0';
  } else if (slash == 1U) {
    parent[0] = '/';
    parent[1] = '\0';
  } else {
    const size_t parent_bytes = slash - 1U;
    (void)memcpy(parent, path, parent_bytes);
    parent[parent_bytes] = '\0';
  }
  return true;
}

RA8_INTERNAL static bool
internal_temp_name(char out[k_mkfontimg_host_name_cap], uint64_t process, uint32_t attempt)
{
  static const char s_prefix[] = ".mkfontimg.tmp.";
  char              reverse[k_host_decimal_digits];
  size_t            offset = sizeof(s_prefix) - 1U;
  (void)memcpy(out, s_prefix, offset);
  uint64_t values[2] = {process, attempt};
  for (uint8_t field = 0U; field < 2U; ++field) {
    size_t digits = 0U;
    do {
      reverse[digits++] = (char)('0' + (values[field] % (uint64_t)k_host_decimal_base));
      values[field] /= (uint64_t)k_host_decimal_base;
    } while (values[field] != 0U);
    if (offset + digits + 2U > (size_t)k_mkfontimg_host_name_cap) {
      return false;
    }
    while (digits > 0U) {
      out[offset++] = reverse[--digits];
    }
    out[offset++] = (field == 0U) ? '.' : '\0';
  }
  return true;
}
 
RA8_PRIV bool priv_mkfontimg_host_begin(const char*       final_path,
                                        uint64_t          block_count,
                                        uint32_t          block_size,
                                        mkfontimg_host_t* host)
{
  *host = (mkfontimg_host_t){.directory_fd = -1, .image_fd = -1};
  char parent[k_mkfontimg_host_path_cap];
  if (block_count == 0U || block_size == 0U || block_count > (UINT64_MAX / block_size) ||
      !internal_split_output(final_path, parent, host->final_name)) {
    return false;
  }
  const uint64_t image_bytes = block_count * block_size;
  if (image_bytes > (uint64_t)INT64_MAX) {
    return false;
  }
  host->directory_fd = open(parent, O_RDONLY | O_DIRECTORY | O_CLOEXEC | O_NOFOLLOW);
  if (host->directory_fd < 0) {
    return false;
  }
  for (uint32_t attempt = 0U; attempt < (uint32_t)k_host_temp_attempts; ++attempt) {
    if (!internal_temp_name(host->temp_name, (uint64_t)getpid(), attempt)) {
      break;
    }
    host->image_fd = openat(host->directory_fd,
                            host->temp_name,
                            O_RDWR | O_CREAT | O_EXCL | O_CLOEXEC | O_NOFOLLOW,
                            (mode_t)k_host_create_mode);
    if (host->image_fd >= 0 || errno != EEXIST) {
      break;
    }
  }
  if (host->image_fd < 0) {
    priv_mkfontimg_host_abort(host);
    return false;
  }
  host->temp_exists = true;
  if (ftruncate(host->image_fd, (off_t)image_bytes) != 0) {
    priv_mkfontimg_host_abort(host);
    return false;
  }
  host->disk =
    (mkfontimg_disk_t){.block_count = block_count, .block_size = block_size, .fd = host->image_fd};
  host->backend = (ra8_fs_backend_t){.read_block   = internal_disk_read,
                                     .write_block  = internal_disk_write,
                                     .get_capacity = internal_disk_capacity,
                                     .ctx          = &host->disk};
  return true;
}
 
RA8_PRIV bool
priv_mkfontimg_host_seed(mkfontimg_host_t* host, const uint8_t* bytes, uint32_t length)
{
  if (host == nullptr || bytes == nullptr || host->image_fd < 0 ||
      (uint64_t)length > (host->disk.block_count * host->disk.block_size)) {
    return false;
  }
  if (!internal_pwrite_exact(host->image_fd, 0U, bytes, length)) {
    host->disk.io_failed = true;
    return false;
  }
  return true;
}

RA8_INTERNAL static host_input_identity_t internal_identity(const struct stat* metadata)
{
#ifdef __APPLE__
  const long modified_nsec = metadata->st_mtimespec.tv_nsec;
  const long changed_nsec  = metadata->st_ctimespec.tv_nsec;
#else
  const long modified_nsec = metadata->st_mtim.tv_nsec;
  const long changed_nsec  = metadata->st_ctim.tv_nsec;
#endif
  return (host_input_identity_t){.device        = metadata->st_dev,
                                 .inode         = metadata->st_ino,
                                 .size          = (uint64_t)metadata->st_size,
                                 .modified_sec  = metadata->st_mtime,
                                 .modified_nsec = modified_nsec,
                                 .changed_sec   = metadata->st_ctime,
                                 .changed_nsec  = changed_nsec};
}

RA8_INTERNAL static bool internal_identity_equal(const host_input_identity_t* left,
                                                 const host_input_identity_t* right)
{
  return left->device == right->device && left->inode == right->inode &&
         left->size == right->size && left->modified_sec == right->modified_sec &&
         left->modified_nsec == right->modified_nsec && left->changed_sec == right->changed_sec &&
         left->changed_nsec == right->changed_nsec;
}

RA8_INTERNAL static bool internal_input_open(const char*            path,
                                             uint64_t               minimum_bytes,
                                             uint64_t               maximum_bytes,
                                             int*                   out_fd,
                                             host_input_identity_t* identity)
{
  const int fd = open(path, O_RDONLY | O_CLOEXEC | O_NOFOLLOW);
  if (fd < 0) {
    return false;
  }
  struct stat metadata = {};
  if (fstat(fd, &metadata) != 0 || !S_ISREG(metadata.st_mode) || metadata.st_size < 0 ||
      (uint64_t)metadata.st_size < minimum_bytes || (uint64_t)metadata.st_size > maximum_bytes) {
    (void)close(fd);
    return false;
  }
  *identity = internal_identity(&metadata);
  *out_fd   = fd;
  return true;
}

RA8_INTERNAL static bool
internal_stream(int input_fd, const host_input_identity_t* identity, ra8_fs_file_t* card)
{
  uint8_t  chunk[k_host_stream_chunk];
  uint64_t offset = 0U;
  bool     ok     = true;
  while (ok && offset < identity->size) {
    uint32_t take = (uint32_t)(identity->size - offset);
    if (take > (uint32_t)sizeof(chunk)) {
      take = (uint32_t)sizeof(chunk);
    }
    ok = internal_pread_exact(input_fd, offset, chunk, take) &&
         ra8_fs_write(card, chunk, take) == k_ra8_ok;
    offset += take;
  }
  struct stat after = {};
  if (fstat(input_fd, &after) != 0) {
    ok = false;
  } else {
    const host_input_identity_t observed = internal_identity(&after);
    if (!internal_identity_equal(identity, &observed)) {
      ok = false;
    }
  }
  return ok;
}

RA8_INTERNAL static bool
internal_compare(int input_fd, const host_input_identity_t* identity, ra8_fs_file_t* card)
{
  uint8_t  source[k_host_stream_chunk];
  uint8_t  copied[k_host_stream_chunk];
  uint64_t offset = 0U;
  bool     ok     = true;
  while (ok && offset < identity->size) {
    uint32_t take = (uint32_t)(identity->size - offset);
    if (take > (uint32_t)sizeof(source)) {
      take = (uint32_t)sizeof(source);
    }
    uint32_t got = 0U;
    ok           = internal_pread_exact(input_fd, offset, source, take) &&
                   ra8_fs_read(card, copied, take, &got) == k_ra8_ok && got == take &&
                   memcmp(source, copied, take) == 0;
    offset += take;
  }
  struct stat after = {};
  if (fstat(input_fd, &after) != 0) {
    ok = false;
  } else {
    const host_input_identity_t observed = internal_identity(&after);
    if (!internal_identity_equal(identity, &observed)) {
      ok = false;
    }
  }
  return ok;
}

RA8_INTERNAL static bool internal_mkfontimg_write(ra8_fs_mount_t*        mount,
                                                  const char*            input_path,
                                                  const char*            card_name,
                                                  uint64_t               minimum_bytes,
                                                  uint64_t               maximum_bytes,
                                                  host_input_identity_t* out_identity)
{
  int input_fd = -1;
  if (!internal_input_open(input_path, minimum_bytes, maximum_bytes, &input_fd, out_identity)) {
    return false;
  }
  ra8_fs_file_t* card = nullptr;
  bool           ok   = ra8_fs_open(mount, card_name, k_ra8_fs_mode_write, &card) == k_ra8_ok;
  if (ok) {
    ok = internal_stream(input_fd, out_identity, card);
    if (ra8_fs_close(card) != k_ra8_ok) {
      ok = false;
    }
  }
  if (close(input_fd) != 0) {
    ok = false;
  }
  return ok;
}

RA8_INTERNAL static bool internal_mkfontimg_verify(ra8_fs_mount_t*              mount,
                                                   const char*                  input_path,
                                                   const char*                  card_name,
                                                   uint64_t                     minimum_bytes,
                                                   uint64_t                     maximum_bytes,
                                                   const host_input_identity_t* identity)
{
  int                   input_fd = -1;
  host_input_identity_t again;
  if (!internal_input_open(input_path, minimum_bytes, maximum_bytes, &input_fd, &again) ||
      !internal_identity_equal(identity, &again)) {
    if (input_fd >= 0) {
      (void)close(input_fd);
    }
    return false;
  }
  uint64_t       card_size = 0U;
  ra8_fs_file_t* card      = nullptr;
  bool           ok = ra8_fs_open(mount, card_name, k_ra8_fs_mode_read, &card) == k_ra8_ok &&
                      ra8_fs_size(card, &card_size) == k_ra8_ok && card_size == identity->size;
  if (ok) {
    ok = internal_compare(input_fd, identity, card);
  }
  if (card != nullptr && ra8_fs_close(card) != k_ra8_ok) {
    ok = false;
  }
  if (close(input_fd) != 0) {
    ok = false;
  }
  return ok;
}
 
RA8_PRIV bool priv_mkfontimg_host_copy(const mkfontimg_host_t* host,
                                       ra8_fs_mount_t*         mount,
                                       const char*             input_path,
                                       const char*             card_name,
                                       uint64_t                minimum_bytes,
                                       uint64_t                maximum_bytes,
                                       uint64_t*               out_bytes)
{
  host_input_identity_t identity;
  if (!internal_mkfontimg_write(mount,
                                input_path,
                                card_name,
                                minimum_bytes,
                                maximum_bytes,
                                &identity)) {
    return false;
  }
  bool ok = internal_mkfontimg_verify(mount,
                                      input_path,
                                      card_name,
                                      minimum_bytes,
                                      maximum_bytes,
                                      &identity);
  if (host->disk.io_failed) {
    ok = false;
  }
  if (ok) {
    *out_bytes = identity.size;
  }
  return ok;
}
 
RA8_PRIV bool priv_mkfontimg_host_commit(mkfontimg_host_t* host)
{
  bool ok = !host->disk.io_failed && fsync(host->image_fd) == 0;
  if (close(host->image_fd) != 0) {
    ok = false;
  }
  host->image_fd = -1;
  if (ok &&
      renameat(host->directory_fd, host->temp_name, host->directory_fd, host->final_name) == 0) {
    host->temp_exists = false;
    if (fsync(host->directory_fd) != 0) {
      ok = false;
    }
  } else {
    ok = false;
  }
  if (host->temp_exists) {
    (void)unlinkat(host->directory_fd, host->temp_name, 0);
    host->temp_exists = false;
  }
  if (close(host->directory_fd) != 0) {
    ok = false;
  }
  host->directory_fd = -1;
  return ok;
}
 
RA8_PRIV void priv_mkfontimg_host_abort(mkfontimg_host_t* host)
{
  if (host->image_fd >= 0) {
    (void)close(host->image_fd);
    host->image_fd = -1;
  }
  if (host->temp_exists && host->directory_fd >= 0) {
    (void)unlinkat(host->directory_fd, host->temp_name, 0);
    host->temp_exists = false;
  }
  if (host->directory_fd >= 0) {
    (void)close(host->directory_fd);
    host->directory_fd = -1;
  }
}