init: initHEADmaster

1 files changed, 396 insertions, 0 deletions

diff --git a/src/FileProcessor/FileProcessor.c b/src/FileProcessor/FileProcessor.c
new file mode 100644
index 0000000..d856fb4
--- /dev/null
+++ b/src/FileProcessor/FileProcessor.c
@@ -0,0 +1,396 @@
+#define _POSIX_C_SOURCE 200809L
+#define _XOPEN_SOURCE 700
+
+#include "FileProcessor/FileProcessor.h"
+
+#include "Logger/Logger.h"
+#include "LuaEngine/LuaEngine.h"
+#include "Path/Path.h"
+
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <libxml/HTMLparser.h>
+#include <libxml/HTMLtree.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#define COPY_BUFFER_SIZE 16384
+
+static int has_html_extension(const char *path) {
+  const char *extension = strrchr(path, '.');
+
+  return extension != NULL && (strcasecmp(extension, ".html") == 0 ||
+                               strcasecmp(extension, ".htm") == 0);
+}
+
+static void report_copy_error(const char *input_path, const char *output_path,
+                              int error_number) {
+  logger_error("cannot copy %s to %s: %s", input_path, output_path,
+               strerror(error_number));
+}
+
+static int write_all(int file, const char *buffer, size_t length) {
+  size_t offset = 0;
+
+  while (offset < length) {
+    ssize_t written = write(file, buffer + offset, length - offset);
+
+    if (written > 0) {
+      offset += (size_t)written;
+    } else if (written == 0) {
+      errno = EIO;
+      return -1;
+    } else if (errno != EINTR) {
+      return -1;
+    }
+  }
+  return 0;
+}
+
+static int copy_file_data(int input, int output) {
+  char buffer[COPY_BUFFER_SIZE];
+
+  for (;;) {
+    ssize_t count = read(input, buffer, sizeof(buffer));
+
+    if (count > 0 && write_all(output, buffer, (size_t)count) != 0) {
+      return -1;
+    }
+    if (count == 0) {
+      return 0;
+    }
+    if (count < 0 && errno != EINTR) {
+      return -1;
+    }
+  }
+}
+
+static int copy_regular_file(const char *input_path, const char *output_path,
+                             mode_t mode) {
+  int input = open(input_path, O_RDONLY);
+  int output;
+  int result;
+  int error_number;
+
+  logger_debug("copying file %s -> %s", input_path, output_path);
+
+  if (input < 0) {
+    report_copy_error(input_path, output_path, errno);
+    return -1;
+  }
+
+  output = open(output_path, O_WRONLY | O_CREAT | O_TRUNC, mode & 0777);
+  if (output < 0) {
+    error_number = errno;
+    close(input);
+    report_copy_error(input_path, output_path, error_number);
+    return -1;
+  }
+
+  result = copy_file_data(input, output);
+  error_number = result == 0 ? 0 : errno;
+
+  if (close(output) != 0 && result == 0) {
+    result = -1;
+    error_number = errno;
+  }
+  if (close(input) != 0 && result == 0) {
+    result = -1;
+    error_number = errno;
+  }
+
+  if (result != 0) {
+    report_copy_error(input_path, output_path, error_number);
+  }
+  return result;
+}
+
+int process_file(const char *input_path, const char *output_path) {
+  const int parse_options = HTML_PARSE_RECOVER | HTML_PARSE_NONET |
+                            HTML_PARSE_NOERROR | HTML_PARSE_NOWARNING;
+  struct stat status;
+  htmlDocPtr document;
+  int saved;
+
+  if (stat(input_path, &status) != 0) {
+    logger_error("cannot inspect %s: %s", input_path, strerror(errno));
+    return -1;
+  }
+  if (!S_ISREG(status.st_mode)) {
+    logger_error("input is not a regular file: %s", input_path);
+    return -1;
+  }
+
+  logger_info("processing HTML %s -> %s", input_path, output_path);
+  document = htmlReadFile(input_path, NULL, parse_options);
+  if (document == NULL) {
+    logger_error("unable to parse HTML file: %s", input_path);
+    return -1;
+  }
+
+  if (process_html_document(document, input_path) != 0) {
+    xmlFreeDoc(document);
+    return -1;
+  }
+
+  saved = htmlSaveFileFormat(output_path, document, "UTF-8", 1);
+  xmlFreeDoc(document);
+  if (saved < 0) {
+    logger_error("unable to write HTML file: %s", output_path);
+    return -1;
+  }
+  return 0;
+}
+
+static int copy_symlink(const char *input_path, const char *output_path,
+                        const struct stat *status) {
+  size_t capacity = status->st_size > 0 ? (size_t)status->st_size + 1 : 256;
+  char *target = malloc(capacity + 1);
+  ssize_t length = -1;
+
+  logger_debug("copying symbolic link %s -> %s", input_path, output_path);
+
+  if (target == NULL) {
+    logger_error("unable to allocate symbolic-link buffer");
+    return -1;
+  }
+
+  while (length < 0) {
+    ssize_t read_length = readlink(input_path, target, capacity);
+
+    if (read_length < 0) {
+      logger_error("cannot read symbolic link %s: %s", input_path,
+                   strerror(errno));
+      free(target);
+      return -1;
+    }
+    if ((size_t)read_length < capacity) {
+      length = read_length;
+    } else {
+      size_t larger_capacity;
+      char *larger_target;
+
+      if (capacity > (SIZE_MAX - 1) / 2) {
+        logger_error("unable to allocate symbolic-link buffer");
+        free(target);
+        return -1;
+      }
+      larger_capacity = capacity * 2;
+      larger_target = realloc(target, larger_capacity + 1);
+      if (larger_target == NULL) {
+        logger_error("unable to allocate symbolic-link buffer");
+        free(target);
+        return -1;
+      }
+      target = larger_target;
+      capacity = larger_capacity;
+    }
+  }
+
+  target[length] = '\0';
+  if (symlink(target, output_path) != 0) {
+    logger_error("cannot copy symbolic link %s: %s", input_path,
+                 strerror(errno));
+    free(target);
+    return -1;
+  }
+
+  free(target);
+  return 0;
+}
+
+static int copy_tree(const char *input_path, const char *output_path) {
+  struct stat status;
+  DIR *directory;
+  int result = 0;
+
+  if (lstat(input_path, &status) != 0) {
+    logger_error("cannot inspect %s: %s", input_path, strerror(errno));
+    return -1;
+  }
+  if (S_ISLNK(status.st_mode)) {
+    return copy_symlink(input_path, output_path, &status);
+  }
+  if (S_ISREG(status.st_mode)) {
+    return has_html_extension(input_path)
+               ? process_file(input_path, output_path)
+               : copy_regular_file(input_path, output_path, status.st_mode);
+  }
+  if (!S_ISDIR(status.st_mode)) {
+    logger_error("unsupported file type: %s", input_path);
+    return -1;
+  }
+
+  if (mkdir(output_path, status.st_mode & 0777) != 0) {
+    logger_error("cannot create directory %s: %s", output_path,
+                 strerror(errno));
+    return -1;
+  }
+
+  directory = opendir(input_path);
+  if (directory == NULL) {
+    logger_error("cannot open directory %s: %s", input_path, strerror(errno));
+    return -1;
+  }
+
+  while (result == 0) {
+    struct dirent *entry;
+    char *input_child;
+    char *output_child;
+
+    errno = 0;
+    entry = readdir(directory);
+    if (entry == NULL) {
+      if (errno != 0) {
+        logger_error("cannot read directory %s: %s", input_path,
+                     strerror(errno));
+        result = -1;
+      }
+      break;
+    }
+    if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
+      continue;
+    }
+
+    input_child = path_join(input_path, entry->d_name);
+    output_child = path_join(output_path, entry->d_name);
+    if (input_child == NULL || output_child == NULL) {
+      logger_error("unable to allocate child path");
+      result = -1;
+    } else {
+      result = copy_tree(input_child, output_child);
+    }
+    free(input_child);
+    free(output_child);
+  }
+
+  if (closedir(directory) != 0 && result == 0) {
+    logger_error("cannot close directory %s: %s", input_path, strerror(errno));
+    result = -1;
+  }
+  return result;
+}
+
+static int remove_tree(const char *path) {
+  struct stat status;
+  DIR *directory;
+  int result = 0;
+
+  if (lstat(path, &status) != 0) {
+    if (errno == ENOENT) {
+      return 0;
+    }
+    logger_error("cannot inspect output %s: %s", path, strerror(errno));
+    return -1;
+  }
+
+  if (!S_ISDIR(status.st_mode) || S_ISLNK(status.st_mode)) {
+    if (unlink(path) != 0) {
+      logger_error("cannot remove output %s: %s", path, strerror(errno));
+      return -1;
+    }
+    return 0;
+  }
+
+  directory = opendir(path);
+  if (directory == NULL) {
+    logger_error("cannot open output directory %s: %s", path, strerror(errno));
+    return -1;
+  }
+
+  while (result == 0) {
+    struct dirent *entry;
+    char *child;
+
+    errno = 0;
+    entry = readdir(directory);
+    if (entry == NULL) {
+      if (errno != 0) {
+        logger_error("cannot read output directory %s: %s", path,
+                     strerror(errno));
+        result = -1;
+      }
+      break;
+    }
+    if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
+      continue;
+    }
+
+    child = path_join(path, entry->d_name);
+    if (child == NULL) {
+      logger_error("unable to allocate output child path");
+      result = -1;
+    } else {
+      result = remove_tree(child);
+    }
+    free(child);
+  }
+
+  if (closedir(directory) != 0 && result == 0) {
+    logger_error("cannot close output directory %s: %s", path, strerror(errno));
+    result = -1;
+  }
+  if (result == 0 && rmdir(path) != 0) {
+    logger_error("cannot remove output directory %s: %s", path,
+                 strerror(errno));
+    result = -1;
+  }
+  return result;
+}
+
+int process_directory(const char *input_path, const char *output_path,
+                      int overwrite_output) {
+  struct stat status;
+  struct stat output_status;
+  char *resolved_input;
+  char *resolved_output;
+  int result;
+
+  if (stat(input_path, &status) != 0) {
+    logger_error("cannot inspect %s: %s", input_path, strerror(errno));
+    return -1;
+  }
+  if (!S_ISDIR(status.st_mode)) {
+    logger_error("input is not a directory: %s", input_path);
+    return -1;
+  }
+
+  resolved_input = realpath(input_path, NULL);
+  if (lstat(output_path, &output_status) == 0 &&
+      !S_ISLNK(output_status.st_mode)) {
+    resolved_output = realpath(output_path, NULL);
+  } else {
+    resolved_output = path_resolve_new(output_path);
+  }
+  if (resolved_input == NULL || resolved_output == NULL) {
+    logger_error("cannot resolve input or output path");
+    free(resolved_input);
+    free(resolved_output);
+    return -1;
+  }
+
+  if (path_is_within(resolved_input, resolved_output)) {
+    logger_error("output directory cannot be inside input: %s", output_path);
+    result = -1;
+  } else if (overwrite_output &&
+             path_is_within(resolved_output, resolved_input)) {
+    logger_error("output directory cannot contain input: %s", output_path);
+    result = -1;
+  } else if (overwrite_output && remove_tree(output_path) != 0) {
+    result = -1;
+  } else {
+    logger_info("processing directory %s -> %s", input_path, output_path);
+    result = copy_tree(input_path, output_path);
+  }
+
+  free(resolved_input);
+  free(resolved_output);
+  return result;
+}