ocran 1.3.17 → 1.4.0

data/src/edicon.c

@@ -0,0 +1,161 @@
+/**
+   Changes the Icon in a PE executable.
+*/
+
+#include <windows.h>
+#include <stdio.h>
+
+#pragma pack(push, 2)
+
+/* Icon file header */
+typedef struct
+{
+   WORD Reserved;
+   WORD ResourceType;
+   WORD ImageCount;
+} IconFileHeader;
+
+/* Icon File directory entry structure */
+typedef struct
+{
+   BYTE Width;
+   BYTE Height;
+   BYTE Colors;
+   BYTE Reserved;
+   WORD Planes;
+   WORD BitsPerPixel;
+   DWORD ImageSize;
+   DWORD ImageOffset;
+} IconDirectoryEntry;
+
+/* Group Icon Resource directory entry structure */
+typedef struct
+{
+   BYTE Width;
+   BYTE Height;
+   BYTE Colors;
+   BYTE Reserved;
+   WORD Planes;
+   WORD BitsPerPixel;
+   DWORD ImageSize;
+   WORD ResourceID;
+} IconDirResEntry, *PIconDirResEntry;
+
+/* Group Icon Structore (RT_GROUP_ICON) */
+typedef struct
+{
+   WORD Reserved;
+   WORD ResourceType;
+   WORD ImageCount;
+   IconDirResEntry Enries[0]; /* Number of these is in ImageCount */
+} GroupIcon;
+
+#pragma pack(pop)
+
+BOOL UpdateIcon(LPTSTR ExecutableFileName, LPTSTR IconFileName)
+{
+   HANDLE h = BeginUpdateResource(ExecutableFileName, FALSE);
+   if (h == INVALID_HANDLE_VALUE)
+   {
+      printf("Failed to BeginUpdateResource\n");
+      return FALSE;
+   }
+
+   /* Read the Icon file */
+   HANDLE hIconFile = CreateFile(IconFileName, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
+   if (hIconFile == INVALID_HANDLE_VALUE)
+   {
+      fprintf(stderr, "Failed to open icon file.\n");
+      return FALSE;
+   }
+   DWORD Size = GetFileSize(hIconFile, NULL);
+   BYTE* Data = LocalAlloc(LMEM_FIXED, Size);
+   DWORD BytesRead;
+   if (!ReadFile(hIconFile, Data, Size, &BytesRead, NULL))
+   {
+      fprintf(stderr, "Failed to read icon file.\n");
+      return FALSE;
+   }
+   CloseHandle(hIconFile);
+   
+   IconFileHeader* header = (IconFileHeader*)Data;
+   IconDirectoryEntry* entries = (IconDirectoryEntry*)(header + 1);
+
+   /* Validate that all directory entries fit within the file */
+   DWORD entriesEnd = sizeof(IconFileHeader) + header->ImageCount * sizeof(IconDirectoryEntry);
+   if (entriesEnd > Size)
+   {
+      fprintf(stderr, "Icon file too small for declared ImageCount.\n");
+      LocalFree(Data);
+      return FALSE;
+   }
+
+   /* Create the RT_ICON resources */
+   int i;
+   for (i = 0; i < header->ImageCount; ++i)
+   {
+      if (entries[i].ImageOffset + entries[i].ImageSize > Size)
+      {
+         fprintf(stderr, "Icon entry %d exceeds file bounds.\n", i);
+         LocalFree(Data);
+         return FALSE;
+      }
+      BOOL b = UpdateResource(h, MAKEINTRESOURCE(RT_ICON), MAKEINTRESOURCE(101 + i), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), Data + entries[i].ImageOffset, entries[i].ImageSize);
+      if (!b)
+      {
+         fprintf(stderr, "failed to UpdateResource %lu\n", GetLastError());
+         return FALSE;
+      }
+   }
+
+   /* Create the RT_GROUP_ICON structure */
+   DWORD GroupIconSize = sizeof(GroupIcon) + header->ImageCount * sizeof(IconDirectoryEntry);
+   GroupIcon* gi = (GroupIcon*)LocalAlloc(LMEM_FIXED, GroupIconSize);
+   gi->Reserved = 0;
+   gi->ResourceType = header->ResourceType;
+   gi->ImageCount = header->ImageCount;
+   for (i = 0; i < header->ImageCount; ++i)
+   {
+      IconDirResEntry* e = &gi->Enries[i];
+      e->Width = entries[i].Width;
+      e->Height = entries[i].Height;
+      e->Colors = entries[i].Colors;
+      e->Reserved = entries[i].Reserved;
+      e->Planes = entries[i].Planes;
+      e->BitsPerPixel = entries[i].BitsPerPixel;
+      e->ImageSize = entries[i].ImageSize;
+      e->ResourceID = 101 + i;
+   }
+
+   /* Save the RT_GROUP_ICON resource */
+   BOOL b = UpdateResource(h, MAKEINTRESOURCE(RT_GROUP_ICON), MAKEINTRESOURCE(100), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), gi, GroupIconSize);
+   if (!b)
+   {
+      fprintf(stderr, "Failed to create group icon.\n");
+      return FALSE;
+   }
+
+   if (!EndUpdateResource(h, FALSE))
+   {
+      fprintf(stderr, "Failed to EndUpdateResource.\n");
+      return FALSE;
+   }
+   
+   return TRUE;
+}
+
+int main(int argc, char* argv[])
+{
+   if (argc == 3)
+   {
+      if (UpdateIcon(argv[1], argv[2]))
+         return 0;
+      else
+         return -1;
+   }
+   else
+   {
+      fprintf(stderr, "Usage: edicon.exe <exefile> <icofile>\n");
+      return -1;
+   }
+}

data/src/error.c

@@ -0,0 +1,100 @@
+#ifdef _WIN32
+#include <windows.h>
+#endif
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include "error.h"
+
+static bool debug_mode = false;
+
+// Enable debug mode
+void EnableDebugMode()
+{
+    debug_mode = true;
+}
+
+static bool vformat_message(char *buffer, size_t buffer_size, const char *label,
+                            const char* format, va_list args)
+{
+    if (!buffer || buffer_size < 2) {
+        return false;
+    }
+
+    size_t offset = 0;
+
+    if (label) {
+        int label_needed = snprintf(buffer, buffer_size, "%s: ", label);
+        if (label_needed < 0 || (size_t)label_needed >= buffer_size) {
+            return false;
+        }
+        offset = (size_t)label_needed;
+    }
+
+    int needed = vsnprintf(buffer + offset, buffer_size - offset, format, args);
+    if (needed < 0) {
+        return false;
+    } else if ((size_t)needed >= buffer_size - offset - 2) {
+        offset = buffer_size - 2;
+    } else {
+        offset += (size_t)needed;
+    }
+    buffer[offset++] = '\n';
+    buffer[offset]   = '\0';
+    return true;
+}
+
+static void print_message(const char *label, const char *format, va_list args)
+{
+    char text[4096];
+    if (vformat_message(text, sizeof(text), label, format, args)) {
+        fputs(text, stderr);
+    } else {
+        fputs("log message formatting failed\n", stderr);
+    }
+}
+
+// Prints a fatal error message to stderr.
+void PrintFatalMessage(const char *format, ...)
+{
+    va_list args;
+    va_start(args, format);
+    print_message("FATAL", format, args);
+    va_end(args);
+}
+
+// Displays a fatal error message via a message box.
+#ifdef _WIN32
+void PrintFatalMessageBox(const char *format, ...)
+{
+    char TextBuffer[1024];
+    va_list args;
+    va_start(args, format);
+    vsnprintf(TextBuffer, 1024, format, args);
+    va_end(args);
+    MessageBox(NULL, TextBuffer, "OCRAN", MB_OK | MB_ICONWARNING);
+}
+#endif
+
+// Prints an application level error message to stderr if in debug mode.
+void PrintAppErrorMessage(const char *format, ...)
+{
+    if (!debug_mode) return;
+
+    va_list args;
+    va_start(args, format);
+    print_message("ERROR", format, args);
+    va_end(args);
+}
+
+// Prints a debug message to stderr if in debug mode.
+void PrintDebugMessage(const char *format, ...)
+{
+    if (!debug_mode) return;
+
+    va_list args;
+    va_start(args, format);
+    print_message("DEBUG", format, args);
+    va_end(args);
+}

data/src/error.h

@@ -0,0 +1,66 @@
+#include <stdarg.h>
+
+// Exit code definitions
+#define EXIT_CODE_SUCCESS (0)
+#define EXIT_CODE_FAILURE (-1)
+
+/**
+ * EnableDebugMode - Enable debug mode
+ *
+ * This function enables debug mode and attaches a console for debug output.
+ */
+void EnableDebugMode();
+
+/**
+ * PrintFatalMessage - Prints a fatal error message to stderr.
+ *
+ * This function prints a formatted error message to stderr. The message is
+ * prefixed with "FATAL: ".
+ *
+ * @param format The format of the error message to be displayed. This is a printf-like
+ * format string followed by additional arguments.
+ */
+void PrintFatalMessage(const char *format, ...);
+
+/**
+ * PrintFatalMessageBox - Displays a fatal error message via a message box.
+ *
+ * This function displays a formatted error message in a message box with the
+ * caption 'OCRAN' and an icon of MB_ICONWARNING.
+ *
+ * @param format The format of the error message to be displayed. This is a printf-like
+ * format string followed by additional arguments.
+ */
+#ifdef _WIN32
+void PrintFatalMessageBox(const char *format, ...);
+#endif
+
+#if defined(_CONSOLE) || !defined(_WIN32)
+#define FATAL(...) PrintFatalMessage(__VA_ARGS__)
+#else
+#define FATAL(...) PrintFatalMessageBox(__VA_ARGS__)
+#endif
+
+/**
+ * PrintAppErrorMessage - Prints an application level error message to stderr if in debug mode.
+ *
+ * This function prints a formatted error message to stderr. The message is
+ * prefixed with "ERROR: ".
+ *
+ * @param format The format of the error message to be displayed. This is a printf-like
+ * format string followed by additional arguments.
+ */
+void PrintAppErrorMessage(const char *format, ...);
+#define APP_ERROR(...) PrintAppErrorMessage(__VA_ARGS__)
+
+/**
+ * PrintDebugMessage - Prints a debug message to stderr if in debug mode.
+ *
+ * This function prints a formatted debug message to stderr. The message is
+ * prefixed with "DEBUG: ".
+ *
+ * @param format The format of the debug message to be displayed. This is a printf-like
+ * format string followed by additional arguments.
+ */
+void PrintDebugMessage(const char *format, ...);
+#define DEBUG(...) PrintDebugMessage(__VA_ARGS__)

data/src/inst_dir.c

@@ -0,0 +1,334 @@
+#include <stdlib.h>
+#include <string.h>
+#ifndef _WIN32
+#include <unistd.h>
+#include <errno.h>
+#endif
+#include "error.h"
+#include "system_utils.h"
+#include "inst_dir.h"
+
+// Static variable to hold the installation directory path.
+static char *InstDir = NULL;
+
+/**
+ * @brief Checks whether the installation directory is configured.
+ *
+ * @return true if InstDir is non-NULL and not empty; false otherwise.
+ */
+static inline bool IsInstDirSet(void)
+{
+    return InstDir != NULL && InstDir[0] != '\0';
+}
+
+// Creates an installation directory with a unique name in the specified target directory.
+static char *create_uniq_dir(const char *target_dir)
+{
+    char *base_path = JoinPath(target_dir, "ocran" "XXXXXX");
+    if (!base_path) {
+        APP_ERROR("Failed to construct a base path");
+        return NULL;
+    }
+    return CreateUniqueDirectory(base_path);
+}
+
+// Creates a debug installation directory next to the executable.
+static char *create_debug_extract_inst_dir(void)
+{
+    char *image_path = GetImagePath();
+    if (!image_path) {
+        APP_ERROR("Failed to get executable name");
+        return NULL;
+    }
+
+    char *image_dir = GetParentPath(image_path);
+    free(image_path);
+    if (!image_dir) {
+        APP_ERROR("Failed to obtain the directory path of the executable file");
+        return NULL;
+    }
+
+    char *inst_dir = create_uniq_dir(image_dir);
+    
+    if (!inst_dir) {
+        APP_ERROR("Failed to create installation directory in '%s'", image_dir);
+        free(image_dir);
+        return NULL;
+    }
+
+    free(image_dir);
+    return inst_dir;
+}
+
+// Creates a temporary installation directory in the system's temp directory.
+static char *create_temporary_inst_dir(void)
+{
+    char *temp_dir = GetTempDirectoryPath();
+    if (!temp_dir) {
+        APP_ERROR("Failed to obtain the temporary directory path");
+        return NULL;
+    }
+
+    char *inst_dir = create_uniq_dir(temp_dir);
+    if (!inst_dir) {
+        APP_ERROR("Failed to create installation directory in '%s'", temp_dir);
+        free(temp_dir);
+        return NULL;
+    }
+
+    free(temp_dir);
+    return inst_dir;
+}
+
+const char *CreateInstDir(bool is_extract_to_exe_dir)
+{
+    if (InstDir != NULL) {
+        APP_ERROR("Installation directory has already been set");
+        return NULL;
+    }
+
+    char *inst_dir = NULL;
+
+    if (is_extract_to_exe_dir) {
+        inst_dir = create_debug_extract_inst_dir();
+    } else {
+        inst_dir = create_temporary_inst_dir();
+    }
+    if (!inst_dir) {
+        return NULL;
+    }
+
+    InstDir = inst_dir;
+    return inst_dir;
+}
+
+// Frees the allocated memory for the installation directory path.
+void FreeInstDir(void)
+{
+    free(InstDir);
+    InstDir = NULL;
+}
+
+// Returns the path to the installation directory.
+const char *GetInstDir()
+{
+    if (!IsInstDirSet()) {
+        APP_ERROR("Installation directory has not been set");
+        return NULL;
+    }
+
+    return InstDir;
+}
+
+// Concatenates the installation directory path with a relative path.
+char *ExpandInstDirPath(const char *rel_path)
+{
+    if (!IsInstDirSet()) {
+        APP_ERROR("Installation directory has not been set");
+        return NULL;
+    }
+
+    if (!rel_path || !*rel_path) {
+        APP_ERROR("relative path is NULL or empty");
+        return NULL;
+    }
+
+    if (!IsCleanRelativePath(rel_path)) {
+        APP_ERROR("invalid relative path '%s'", rel_path);
+        return NULL;
+    }
+
+    char *full_path = JoinPath(InstDir, rel_path);
+    if (!full_path) {
+        APP_ERROR("Failed to build full path");
+    }
+    return full_path;
+}
+
+// Deletes the installation directory and all its contents.
+bool DeleteInstDir(void)
+{
+    if (!IsInstDirSet()) {
+        APP_ERROR("Installation directory has not been set");
+        return false;
+    }
+
+    return DeleteRecursively(InstDir);
+}
+
+// Replaces placeholders in a string with the installation directory path.
+char *ReplaceInstDirPlaceholder(const char *tmpl)
+{
+    if (!IsInstDirSet()) {
+        APP_ERROR("Installation directory has not been set");
+        return NULL;
+    }
+
+    const char *replacement = InstDir;
+    size_t replacement_len = strlen(replacement);
+    size_t c = 0;
+
+    for (const char *p = tmpl; *p; p++) { if (*p == PLACEHOLDER) c++; }
+    size_t replaced_len = strlen(tmpl) - c + replacement_len * c + 1;
+    char *replaced = calloc(replaced_len, sizeof(*replaced));
+    if (!replaced) {
+        APP_ERROR("Memory allocation failed for placeholder replacement");
+        return NULL;
+    }
+
+    char *out = replaced;
+    for (const char *in = tmpl; *in; in++) {
+        if (*in == PLACEHOLDER) {
+            memcpy(out, replacement, replacement_len);
+            out += replacement_len;
+        } else {
+            *out = *in;
+            out++;
+        }
+    }
+    *out = '\0';
+
+    return replaced;
+}
+
+bool CreateDirectoryUnderInstDir(const char *rel_path)
+{
+    if (!IsInstDirSet()) {
+        APP_ERROR("Installation directory has not been set");
+        return false;
+    }
+
+    if (!rel_path) {
+        APP_ERROR("relative path is NULL");
+        return false;
+    }
+
+    /* Treat empty string as a no-op and return success */
+    if (rel_path[0] == '\0') {
+        return true;
+    }
+
+    char *dir = ExpandInstDirPath(rel_path);
+    if (!dir) {
+        APP_ERROR("Failed to build full path");
+        return false;
+    }
+
+    bool result = CreateDirectoriesRecursively(dir);
+    if (!result) {
+        APP_ERROR(
+            "Failed to create directory under installation directory: '%s'",
+            dir
+        );
+    }
+
+    free(dir);
+    return result;
+}
+
+bool ExportFileToInstDir(const char *rel_path, const void *buf, size_t len)
+{
+    bool  result = false;
+    char *path   = NULL;
+
+    if (!IsInstDirSet()) {
+        APP_ERROR("Installation directory has not been set");
+        goto cleanup;
+    }
+
+    if (rel_path == NULL || *rel_path == '\0') {
+        APP_ERROR("Relative path is null or empty");
+        goto cleanup;
+    }
+
+    DEBUG("ExportFileToInstDir: rel_path=\"%s\", len=%zu", rel_path, len);
+
+    if (len > 0 && buf == NULL) {
+        APP_ERROR("Buffer pointer is NULL for non-zero length");
+        goto cleanup;
+    }
+
+    path = ExpandInstDirPath(rel_path);
+    if (!path) {
+        goto cleanup;
+    }
+
+    if (!ExportFile(path, buf, len)) {
+        APP_ERROR("Failed to export file: %s", path);
+        goto cleanup;
+    }
+
+    result = true;
+
+cleanup:
+    if (path) {
+        free(path);
+    }
+    return result;
+}
+
+#ifndef _WIN32
+bool CreateSymlinkUnderInstDir(const char *rel_link_path, const char *target)
+{
+    if (!IsInstDirSet()) {
+        APP_ERROR("Installation directory has not been set");
+        return false;
+    }
+
+    if (!rel_link_path || !*rel_link_path) {
+        APP_ERROR("rel_link_path is NULL or empty");
+        return false;
+    }
+
+    if (!target || !*target) {
+        APP_ERROR("target is NULL or empty");
+        return false;
+    }
+
+    char *link_path = ExpandInstDirPath(rel_link_path);
+    if (!link_path) {
+        return false;
+    }
+
+    bool result = false;
+    char *parent = GetParentPath(link_path);
+    if (parent && *parent && !CreateDirectoriesRecursively(parent)) {
+        APP_ERROR("Failed to create parent directory for symlink '%s'", link_path);
+        goto cleanup;
+    }
+
+    if (symlink(target, link_path) < 0) {
+        APP_ERROR("Failed to create symlink '%s' -> '%s': %s", link_path, target, strerror(errno));
+        goto cleanup;
+    }
+
+    DEBUG("CreateSymlinkUnderInstDir: '%s' -> '%s'", link_path, target);
+    result = true;
+
+cleanup:
+    if (parent) {
+        free(parent);
+    }
+    free(link_path);
+    return result;
+}
+#endif /* _WIN32 */
+
+bool SetEnvWithInstDir(const char *name, const char *value)
+{
+    char *replaced_value = ReplaceInstDirPlaceholder(value);
+    if (!replaced_value) {
+        APP_ERROR("Failed to replace the value placeholder");
+        return false;
+    }
+
+    DEBUG("SetEnv(%s, %s)", name, replaced_value);
+
+    bool result = SetEnvVar(name, replaced_value);
+    if (!result) {
+        APP_ERROR("Failed to set environment variable: %s", name);
+    }
+
+    free(replaced_value);
+    return result;
+}