exfat_mkimage.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 "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_mk_block_size     = 512U,    
  k_mk_block_count    = 131072U, 
  k_mk_payload        = 32U,     
  k_mk_alphabet       = 26U,     
  k_mk_path_cap       = 4096U,   
  k_mk_name_cap       = 256U,    
  k_mk_temp_attempts  = 128U,    
  k_mk_decimal_digits = 20U,     
  k_mk_decimal_base   = 10U,     
  k_mk_create_mode    = 0666U,   
} mk_limit_t;

typedef struct {
  uint64_t block_count; 
  uint32_t block_size;  
  int      fd;          
  bool     io_failed;   
} mk_disk_t;

typedef struct {
  char final_name[k_mk_name_cap]; 
  char temp_name[k_mk_name_cap];  
  int  directory_fd;              
  int  image_fd;                  
  bool temp_exists;               
} mk_output_t;

typedef struct {
  const char* path;    
  const char* meaning; 
  bool        is_dir;  
} mk_entry_t;

static const mk_entry_t s_entries[] = {
  {"/\xD0\x9F\xD0\xB0\xD0\xBF\xD0\xBA\xD0\xB0", "Cyrillic directory (Papka)", true},
  {"/\xE4\xBD\xA0\xE5\xA5\xBD", "CJK directory (ni hao)", true},
  {"/Caf\xC3\xA9.txt", "Latin-1 accent (Cafe.txt)", false},
  {"/\xE4\xBD\xA0\xE5\xA5\xBD.txt", "CJK filename", false},
  {"/\xF0\x9F\x98\x80.txt", "astral-plane emoji, a surrogate pair on disk", false},
  {"/\xD0\x9F\xD0\xB0\xD0\xBF\xD0\xBA\xD0\xB0/n\xC3\xB6te.txt",
   "non-ASCII file inside a non-ASCII directory",
   false},
  {"/README.txt", "plain ASCII control", false},
};

RA8_INTERNAL static void internal_log(int fd, const char* text)
{
  size_t offset = 0U;
  size_t length = strlen(text);
  while (offset < length) {
    const ssize_t written = write(fd, &text[offset], length - offset);
    if ((written < 0) && (errno == EINTR)) {
      continue;
    }
    if (written <= 0) {
      return;
    }
    offset += (size_t)written;
  }
}

RA8_INTERNAL static void internal_log_u64(int fd, uint64_t value)
{
  char   reverse[k_mk_decimal_digits];
  char   forward[k_mk_decimal_digits + 1U];
  size_t digits = 0U;
  do {
    reverse[digits++] = (char)('0' + (value % (uint64_t)k_mk_decimal_base));
    value /= (uint64_t)k_mk_decimal_base;
  } while (value != 0U);
  for (size_t i = 0U; i < digits; ++i) {
    forward[i] = reverse[digits - i - 1U];
  }
  forward[digits] = '\0';
  internal_log(fd, 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 mk_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)
{
  mk_disk_t* disk = (mk_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)
{
  mk_disk_t* disk = (mk_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 mk_disk_t* disk = (const mk_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_mk_path_cap], char leaf[k_mk_name_cap])
{
  const size_t length = strlen(path);
  if (length == 0U || length >= (size_t)k_mk_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_mk_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_mk_name_cap], uint64_t process, uint32_t attempt)
{
  static const char s_prefix[] = ".exfat_mkimage.tmp.";
  char              reverse[k_mk_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_mk_decimal_base));
      values[field] /= (uint64_t)k_mk_decimal_base;
    } while (values[field] != 0U);
    if (offset + digits + 2U > (size_t)k_mk_name_cap) {
      return false;
    }
    while (digits > 0U) {
      out[offset++] = reverse[--digits];
    }
    out[offset++] = (field == 0U) ? '.' : '\0';
  }
  return true;
}

RA8_INTERNAL static bool internal_output_begin(const char* path, mk_output_t* output)
{
  *output = (mk_output_t){.directory_fd = -1, .image_fd = -1};
  char parent[k_mk_path_cap];
  if (!internal_split_output(path, parent, output->final_name)) {
    return false;
  }
  output->directory_fd = open(parent, O_RDONLY | O_DIRECTORY | O_CLOEXEC | O_NOFOLLOW);
  if (output->directory_fd < 0) {
    return false;
  }
  for (uint32_t attempt = 0U; attempt < (uint32_t)k_mk_temp_attempts; ++attempt) {
    if (!internal_temp_name(output->temp_name, (uint64_t)getpid(), attempt)) {
      break;
    }
    output->image_fd = openat(output->directory_fd,
                              output->temp_name,
                              O_RDWR | O_CREAT | O_EXCL | O_CLOEXEC | O_NOFOLLOW,
                              (mode_t)k_mk_create_mode);
    if (output->image_fd >= 0 || errno != EEXIST) {
      break;
    }
  }
  if (output->image_fd < 0) {
    (void)close(output->directory_fd);
    output->directory_fd = -1;
    return false;
  }
  output->temp_exists  = true;
  const uint64_t bytes = (uint64_t)k_mk_block_count * (uint64_t)k_mk_block_size;
  if (bytes > (uint64_t)INT64_MAX || ftruncate(output->image_fd, (off_t)bytes) != 0) {
    (void)close(output->image_fd);
    output->image_fd = -1;
    (void)unlinkat(output->directory_fd, output->temp_name, 0);
    output->temp_exists = false;
    (void)close(output->directory_fd);
    output->directory_fd = -1;
    return false;
  }
  return true;
}

RA8_INTERNAL static void internal_output_abort(mk_output_t* output)
{
  if (output->image_fd >= 0) {
    (void)close(output->image_fd);
    output->image_fd = -1;
  }
  if (output->temp_exists && output->directory_fd >= 0) {
    (void)unlinkat(output->directory_fd, output->temp_name, 0);
    output->temp_exists = false;
  }
  if (output->directory_fd >= 0) {
    (void)close(output->directory_fd);
    output->directory_fd = -1;
  }
}

RA8_INTERNAL static bool internal_output_commit(mk_output_t* output)
{
  bool ok = fsync(output->image_fd) == 0;
  if (close(output->image_fd) != 0) {
    ok = false;
  }
  output->image_fd = -1;
  if (ok &&
      renameat(output->directory_fd, output->temp_name, output->directory_fd, output->final_name) ==
        0) {
    output->temp_exists = false;
    if (fsync(output->directory_fd) != 0) {
      ok = false;
    }
  } else {
    ok = false;
  }
  if (output->temp_exists) {
    (void)unlinkat(output->directory_fd, output->temp_name, 0);
    output->temp_exists = false;
  }
  if (close(output->directory_fd) != 0) {
    ok = false;
  }
  output->directory_fd = -1;
  return ok;
}

RA8_INTERNAL static ra8_err_t internal_populate(ra8_fs_mount_t* mount)
{
  uint8_t payload[k_mk_payload];
  for (uint32_t i = 0U; i < (uint32_t)k_mk_payload; ++i) {
    payload[i] = (uint8_t)('A' + (i % (uint32_t)k_mk_alphabet));
  }
  for (size_t i = 0U; i < (sizeof(s_entries) / sizeof(s_entries[0])); ++i) {
    const mk_entry_t* entry = &s_entries[i];
    const ra8_err_t   error =
      entry->is_dir ? ra8_fs_mkdir(mount, entry->path)
                    : ra8_fs_write_file(mount, entry->path, payload, (uint32_t)k_mk_payload);
    if (error != k_ra8_ok) {
      internal_log(STDERR_FILENO, "exfat_mkimage: cannot create ");
      internal_log(STDERR_FILENO, entry->meaning);
      internal_log(STDERR_FILENO, " (error ");
      internal_log_u64(STDERR_FILENO, (uint64_t)error);
      internal_log(STDERR_FILENO, ")\n");
      return error;
    }
    internal_log(STDOUT_FILENO, "  created ");
    internal_log(STDOUT_FILENO, entry->path);
    internal_log(STDOUT_FILENO, "  ");
    internal_log(STDOUT_FILENO, entry->meaning);
    internal_log(STDOUT_FILENO, "\n");
  }
  return k_ra8_ok;
}

int main(int argc, char** argv)
{
  if (argc > 2) {
    internal_log(STDERR_FILENO, "usage: exfat_mkimage [output.img]\n");
    return 2;
  }
  const char* out_path = (argc == 2) ? argv[1] : "exfat_showcase.img";
  mk_output_t output;
  if (!internal_output_begin(out_path, &output)) {
    internal_log(STDERR_FILENO, "exfat_mkimage: cannot create safe sibling temporary\n");
    return 1;
  }
  mk_disk_t                  disk    = {.block_count = k_mk_block_count,
                                        .block_size  = k_mk_block_size,
                                        .fd          = output.image_fd};
  const ra8_fs_backend_t     backend = {.read_block   = internal_disk_read,
                                        .write_block  = internal_disk_write,
                                        .get_capacity = internal_disk_capacity,
                                        .ctx          = &disk};
  const ra8_fs_format_opts_t options = {.type = k_ra8_fs_type_exfat, .label = "RA8IMAGE"};
  ra8_fs_mount_t*            mount   = nullptr;
  ra8_err_t                  error   = ra8_fs_format(&backend, &options);
  if (error == k_ra8_ok) {
    error = ra8_fs_mount(&backend, &mount);
  }
  if (error == k_ra8_ok) {
    error = internal_populate(mount);
  }
  if (mount != nullptr && ra8_fs_unmount(mount) != k_ra8_ok) {
    error = k_ra8_fail;
  }
  bool ok = error == k_ra8_ok && !disk.io_failed;
  if (ok) {
    ok = internal_output_commit(&output);
  } else {
    internal_output_abort(&output);
  }
  if (!ok) {
    internal_log(STDERR_FILENO, "exfat_mkimage: generation failed; destination preserved\n");
    return 1;
  }
  internal_log(STDOUT_FILENO, "wrote ");
  internal_log(STDOUT_FILENO, out_path);
  internal_log(STDOUT_FILENO, " (");
  internal_log_u64(STDOUT_FILENO, (uint64_t)k_mk_block_count * (uint64_t)k_mk_block_size);
  internal_log(STDOUT_FILENO, " bytes) -- the card exactly as ra8_fs left it\n");
  return 0;
}