native_fs.c

Go to the documentation of this file.

/**
 * @file
 * @brief Provides filesystem helpers for directory creation, recursive copy or removal, and file writes.
 */
 
#include "native_fs.h"
 
#include "native_support.h"
 
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#ifdef _WIN32
#include <direct.h>
#include <io.h>
#include <sys/stat.h>
#define PHAROS_FS_PATH_SEP '\\'
#define pharos_fs_mkdir(path, mode) _mkdir(path)
#define pharos_fs_unlink _unlink
#else
#include <dirent.h>
#include <sys/stat.h>
#include <unistd.h>
#define PHAROS_FS_PATH_SEP '/'
#define pharos_fs_mkdir mkdir
#define pharos_fs_unlink unlink
#endif
 
int ensure_directory(const char *path) {
  char *copy;
  char *cursor;
  if (path == NULL || path[0] == '\0') {
    return 0;
  }
  if (path_is_directory(path)) {
    return 0;
  }
#ifdef _WIN32
  copy = _strdup(path);
#else
  copy = strdup(path);
#endif
  if (copy == NULL) {
    return 69;
  }
  for (cursor = copy + 1; *cursor != '\0'; cursor++) {
    if (*cursor == PHAROS_FS_PATH_SEP) {
      *cursor = '\0';
      if (copy[0] != '\0' && !path_is_directory(copy) && pharos_fs_mkdir(copy, 0755) != 0 && errno != EEXIST) {
        free(copy);
        return 69;
      }
      *cursor = PHAROS_FS_PATH_SEP;
    }
  }
  if (!path_is_directory(copy) && pharos_fs_mkdir(copy, 0755) != 0 && errno != EEXIST) {
    free(copy);
    return 69;
  }
  free(copy);
  return 0;
}
 
int write_text_file(const char *path, const char *content) {
  FILE *file;
  char *dir;
  size_t content_len = content != NULL ? strlen(content) : 0;
  dir = path_dirname(path);
  if (dir == NULL) {
    return 69;
  }
  if (ensure_directory(dir) != 0) {
    free(dir);
    return 69;
  }
  free(dir);
  file = fopen(path, "wb");
  if (file == NULL) {
    return 69;
  }
  if (content_len > 0 && fwrite(content, 1, content_len, file) != content_len) {
    fclose(file);
    return 69;
  }
  if (fclose(file) != 0) {
    return 69;
  }
  return 0;
}
 
int copy_file_binary(const char *source_path, const char *target_path) {
  FILE *source = NULL;
  FILE *target = NULL;
  char *target_dir = NULL;
  char chunk[4096];
  size_t bytes_read;
  int code = 0;
  target_dir = path_dirname(target_path);
  if (target_dir == NULL || ensure_directory(target_dir) != 0) {
    code = 69;
    goto cleanup;
  }
  source = fopen(source_path, "rb");
  if (source == NULL) {
    code = 66;
    goto cleanup;
  }
  target = fopen(target_path, "wb");
  if (target == NULL) {
    code = 69;
    goto cleanup;
  }
  while ((bytes_read = fread(chunk, 1, sizeof(chunk), source)) > 0) {
    if (fwrite(chunk, 1, bytes_read, target) != bytes_read) {
      code = 69;
      goto cleanup;
    }
  }
cleanup:
  if (source != NULL && fclose(source) != 0 && code == 0) {
    code = 69;
  }
  if (target != NULL && fclose(target) != 0 && code == 0) {
    code = 69;
  }
  free(target_dir);
  return code;
}
 
int copy_directory_recursive(const char *source_dir, const char *target_dir) {
#ifndef _WIN32
  DIR *dir;
  struct dirent *entry;
  if (ensure_directory(target_dir) != 0) {
    return 69;
  }
  dir = opendir(source_dir);
  if (dir == NULL) {
    return 66;
  }
  while ((entry = readdir(dir)) != NULL) {
    char *source_path;
    char *target_path;
    int code;
    if (streq(entry->d_name, ".") || streq(entry->d_name, "..")) {
      continue;
    }
    source_path = path_join(source_dir, entry->d_name);
    target_path = path_join(target_dir, entry->d_name);
    if (source_path == NULL || target_path == NULL) {
      free(source_path);
      free(target_path);
      closedir(dir);
      return 69;
    }
    if (path_is_directory(source_path)) {
      code = copy_directory_recursive(source_path, target_path);
    } else {
      code = copy_file_binary(source_path, target_path);
    }
    free(source_path);
    free(target_path);
    if (code != 0) {
      closedir(dir);
      return code;
    }
  }
  closedir(dir);
  return 0;
#else
  (void)source_dir;
  (void)target_dir;
  return 78;
#endif
}
 
int remove_directory_recursive(const char *target_dir) {
#ifndef _WIN32
  DIR *dir;
  struct dirent *entry;
  if (target_dir == NULL || !path_exists(target_dir)) {
    return 0;
  }
  if (!path_is_directory(target_dir)) {
    return pharos_fs_unlink(target_dir) == 0 ? 0 : 69;
  }
  dir = opendir(target_dir);
  if (dir == NULL) {
    return 69;
  }
  while ((entry = readdir(dir)) != NULL) {
    char *child_path;
    int code;
    if (streq(entry->d_name, ".") || streq(entry->d_name, "..")) {
      continue;
    }
    child_path = path_join(target_dir, entry->d_name);
    if (child_path == NULL) {
      closedir(dir);
      return 69;
    }
    if (path_is_directory(child_path)) {
      code = remove_directory_recursive(child_path);
    } else {
      code = pharos_fs_unlink(child_path) == 0 ? 0 : 69;
    }
    free(child_path);
    if (code != 0) {
      closedir(dir);
      return code;
    }
  }
  closedir(dir);
  return rmdir(target_dir) == 0 ? 0 : 69;
#else
  (void)target_dir;
  return 78;
#endif
}