mkbookimg_books.c

Go to the documentation of this file.

 
#include <fcntl.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
 
#include "mkbookimg_internal.h"
#include "mkbookimg_names.h"
#include "ra8_attributes.h"
#include "ra8_fs.h"

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;  
} mkbookimg_input_identity_t;

RA8_INTERNAL static mkbookimg_input_identity_t internal_input_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 (mkbookimg_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_input_same(const mkbookimg_input_identity_t* expected,
                                             const struct stat*                actual)
{
  if (actual->st_size < 0) {
    return false;
  }
  const mkbookimg_input_identity_t observed = internal_input_identity(actual);
  return expected->device == observed.device && expected->inode == observed.inode &&
         expected->size == observed.size && expected->modified_sec == observed.modified_sec &&
         expected->modified_nsec == observed.modified_nsec &&
         expected->changed_sec == observed.changed_sec &&
         expected->changed_nsec == observed.changed_nsec;
}

RA8_INTERNAL static bool internal_identity_equal(const mkbookimg_input_identity_t* left,
                                                 const mkbookimg_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, int* out_fd, mkbookimg_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 > UINT32_MAX) {
    (void)close(fd);
    return false;
  }
  *identity = internal_input_identity(&metadata);
  *out_fd   = fd;
  return true;
}

RA8_INTERNAL static bool internal_stream_book(ra8_fs_mount_t*             mount,
                                              const char*                 name,
                                              const char*                 path,
                                              mkbookimg_input_identity_t* identity)
{
  int input_fd = -1;
  if (!internal_input_open(path, &input_fd, identity)) {
    return false;
  }
  ra8_fs_file_t* card = nullptr;
  if (ra8_fs_open(mount, name, k_ra8_fs_mode_write, &card) != k_ra8_ok) {
    (void)close(input_fd);
    return false;
  }
  uint8_t  chunk[k_stream_chunk_bytes];
  uint64_t offset = 0U;
  bool     ok     = true;
  while (ok && offset < identity->size) {
    size_t take = (size_t)(identity->size - offset);
    if (take > sizeof(chunk)) {
      take = sizeof(chunk);
    }
    ok = priv_mkbookimg_pread_exact(input_fd, offset, chunk, take) &&
         ra8_fs_write(card, chunk, (uint32_t)take) == k_ra8_ok;
    offset += take;
  }
  struct stat after = {};
  if (fstat(input_fd, &after) != 0 || !internal_input_same(identity, &after)) {
    ok = false;
  }
  if (close(input_fd) != 0) {
    ok = false;
  }
  if (ra8_fs_close(card) != k_ra8_ok) {
    ok = false;
  }
  return ok;
}

RA8_INTERNAL static bool internal_verify_book_reopen(ra8_fs_mount_t*                   mount,
                                                     const char*                       name,
                                                     const char*                       path,
                                                     const mkbookimg_input_identity_t* identity,
                                                     int*                              out_input_fd,
                                                     ra8_fs_file_t**                   out_card)
{
  int                        input_fd = -1;
  mkbookimg_input_identity_t again;
  if (!internal_input_open(path, &input_fd, &again)) {
    if (input_fd >= 0) {
      (void)close(input_fd);
    }
    return false;
  }
  if (!internal_identity_equal(identity, &again)) {
    (void)close(input_fd);
    return false;
  }
  ra8_fs_file_t* card = nullptr;
  uint64_t       card_size;
  if (ra8_fs_open(mount, name, k_ra8_fs_mode_read, &card) != k_ra8_ok ||
      ra8_fs_size(card, &card_size) != k_ra8_ok || card_size != identity->size) {
    if (card != nullptr) {
      (void)ra8_fs_close(card);
    }
    (void)close(input_fd);
    return false;
  }
  *out_input_fd = input_fd;
  *out_card     = card;
  return true;
}

RA8_INTERNAL static bool internal_verify_book(ra8_fs_mount_t*                   mount,
                                              const char*                       name,
                                              const char*                       path,
                                              const mkbookimg_input_identity_t* identity)
{
  int            input_fd = -1;
  ra8_fs_file_t* card     = nullptr;
  if (!internal_verify_book_reopen(mount, name, path, identity, &input_fd, &card)) {
    return false;
  }
  uint8_t  source[k_stream_chunk_bytes];
  uint8_t  copied[k_stream_chunk_bytes];
  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           = priv_mkbookimg_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 || !internal_input_same(identity, &after)) {
    ok = false;
  }
  if (close(input_fd) != 0 || ra8_fs_close(card) != k_ra8_ok) {
    ok = false;
  }
  return ok;
}

RA8_INTERNAL static bool internal_duplicate_name(char** arguments, int index)
{
  const char* name = mkbookimg_basename(arguments[2 + index]);
  for (int prior = 0; prior < index; ++prior) {
    if (strcmp(name, mkbookimg_basename(arguments[2 + prior])) == 0) {
      return true;
    }
  }
  return false;
}

RA8_INTERNAL static bool internal_format_mount(const ra8_fs_backend_t* backend,
                                               ra8_fs_mount_t**        mount)
{
  const ra8_fs_format_opts_t options = {.type = k_ra8_fs_type_fat32, .label = "RABOOKS"};
  if (ra8_fs_format(backend, &options) != k_ra8_ok) {
    priv_mkbookimg_diag("mkbookimg: ra8_fs_format failed\n");
    return false;
  }
  if (ra8_fs_mount(backend, mount) != k_ra8_ok) {
    priv_mkbookimg_diag("mkbookimg: ra8_fs_mount failed\n");
    return false;
  }
  return true;
}

RA8_INTERNAL static bool
internal_write_books(ra8_fs_mount_t* mount, char** arguments, int book_count)
{
  for (int index = 0; index < book_count; ++index) {
    char name[k_mkbookimg_name_cap];
    if (!mkbookimg_dest_name(arguments[2 + index], name, sizeof(name))) {
      priv_mkbookimg_diag("mkbookimg: unusable card name for ");
      priv_mkbookimg_diag(arguments[2 + index]);
      priv_mkbookimg_diag("\n");
      return false;
    }
    if (internal_duplicate_name(arguments, index)) {
      priv_mkbookimg_diag("mkbookimg: duplicate card name ");
      priv_mkbookimg_diag(name);
      priv_mkbookimg_diag("\n");
      return false;
    }
    mkbookimg_input_identity_t identity;
    if (!internal_stream_book(mount, name, arguments[2 + index], &identity) ||
        !internal_verify_book(mount, name, arguments[2 + index], &identity)) {
      priv_mkbookimg_diag("mkbookimg: input changed or could not be copied exactly: ");
      priv_mkbookimg_diag(arguments[2 + index]);
      priv_mkbookimg_diag("\n");
      return false;
    }
    priv_mkbookimg_diag("mkbookimg: + ");
    priv_mkbookimg_diag(name);
    priv_mkbookimg_diag("  (");
    priv_mkbookimg_diag_u64(identity.size);
    priv_mkbookimg_diag(" bytes)  <- ");
    priv_mkbookimg_diag(arguments[2 + index]);
    priv_mkbookimg_diag("\n");
  }
  return true;
}
 
RA8_PRIV
bool priv_mkbookimg_build_image(const ra8_fs_backend_t* backend,
                                char**                  argv,
                                int                     book_count,
                                const mkbookimg_disk_t* disk)
{
  ra8_fs_mount_t* mount = nullptr;
  bool            ok    = internal_format_mount(backend, &mount);
  if (ok) {
    ok = internal_write_books(mount, argv, book_count);
    if (ra8_fs_unmount(mount) != k_ra8_ok) {
      ok = false;
    }
  }
  if (disk->io_failed) {
    ok = false;
  }
  return ok;
}