Added missing defines and fixed linux loader

Author: KiritoDv

src/port/scripting/loader.cpp

@@ -1,37 +1,27 @@
 #include "loader.h"
 
-#if defined(__linux__)
-#define _GNU_SOURCE
-#endif
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <string>
+#include <stdexcept>
 
 #if defined(_WIN32) || defined(__CYGWIN__)
 #include <windows.h>
 #else
 #include <dlfcn.h>
 #include <unistd.h>
-#endif
-
-#if defined(__linux__)
-#include <sys/mman.h>
-#endif
-
-#include <string>
-#include <stdexcept>
-
-#if defined(_WIN32) || defined(__CYGWIN__)
-#include <windows.h>
-#elif defined(__linux__) || defined(__APPLE__)
 #include <unistd.h>
 #include <fcntl.h>
 #include <cerrno>
 #endif
 
 #if defined(__linux__)
 #include <sys/mman.h>
+#include <sys/stat.h>
+#include <elf.h>
+#include <iostream>
+#include <fstream>
 #endif
 
 std::string ModInstance::GenerateTempFile() {
@@ -50,27 +40,18 @@ std::string ModInstance::GenerateTempFile() {
 
     return std::string(tempFileName);
 
-#elif defined(__linux__)
-    int fd = memfd_create("virtual_mod_lib", 0);
-    if (fd == -1) {
-        throw std::runtime_error("Failed to create memfd: " + std::to_string(errno));
-    }
-
-    // IMPORTANT: We deliberately DO NOT close(fd) here!
-    // A memfd only exists in RAM as long as an open file descriptor points to it.
-    // If we closed it, the file would instantly vanish and the path would become invalid.
-    char path[256];
-    snprintf(path, sizeof(path), "/proc/self/fd/%d", fd);
-    return std::string(path);
-
-#elif defined(__APPLE__)
+#elif defined(__APPLE__) || defined(__linux__)
     char path_template[] = "/tmp/mod_lib_XXXXXX";
 
     int fd = mkstemp(path_template);
     if (fd == -1) {
         throw std::runtime_error("Failed to create temporary file: " + std::to_string(errno));
     }
 
+#ifdef __linux__
+    fchmod(fd, 0755);
+#endif
+
     // mkstemp creates a physical file on the hard drive.
     // We can safely close the FD now; the file will remain on disk for you to open later.
     close(fd);
@@ -81,6 +62,64 @@ std::string ModInstance::GenerateTempFile() {
 #endif
 }
 
+#ifdef __linux__
+void FixELFHeader(const std::string& path) {
+    // 1. Read the file into a buffer
+    std::ifstream in(path, std::ios::binary | std::ios::ate);
+    if (!in.is_open()) return;
+
+    std::streamsize size = in.tellg();
+    in.seekg(0, std::ios::beg);
+
+    std::vector<uint8_t> buffer(size);
+    if (!in.read(reinterpret_cast<char*>(buffer.data()), size)) return;
+    in.close();
+
+    if (buffer.size() < sizeof(Elf64_Ehdr)) return;
+
+    // 2. ELF Surgery
+    Elf64_Ehdr* header = reinterpret_cast<Elf64_Ehdr*>(buffer.data());
+    
+    if (header->e_ident[EI_CLASS] == ELFCLASS64) {
+        Elf64_Phdr* phdr = reinterpret_cast<Elf64_Phdr*>(buffer.data() + header->e_phoff);
+
+        bool patched = false;
+        for (int i = 0; i < header->e_phnum; i++) {
+            // Target PT_NOTE (0x4) OR PT_GNU_EH_FRAME (0x6474e550)
+            // TCC doesn't give us a NOTE, so we hijack the EH_FRAME header.
+            if (phdr[i].p_type == PT_NOTE || phdr[i].p_type == 0x6474e550) {
+                phdr[i].p_type = PT_GNU_STACK; // Change to 0x6474e551
+                phdr[i].p_flags = PF_R | PF_W; // Set to RW (No Execute)
+                phdr[i].p_align = 0x10;
+                patched = true;
+                break; 
+            }
+        }
+
+        if (!patched) {
+            // Last resort: if we can't find either, we'll try to find any 
+            // non-critical segment that isn't LOAD (1) or DYNAMIC (2).
+            for (int i = 0; i < header->e_phnum; i++) {
+                if (phdr[i].p_type != PT_LOAD && phdr[i].p_type != PT_DYNAMIC) {
+                    phdr[i].p_type = PT_GNU_STACK;
+                    phdr[i].p_flags = PF_R | PF_W;
+                    break;
+                }
+            }
+        }
+    }
+
+    // 3. Write it back
+    std::ofstream out(path, std::ios::binary | std::ios::trunc);
+    if (!out.is_open()) return;
+    out.write(reinterpret_cast<const char*>(buffer.data()), buffer.size());
+    out.close();
+
+    // 4. Ensure permissions are set to allow execution of the file
+    chmod(path.c_str(), 0755);
+}
+#endif
+
 void ModInstance::Init(const std::string& path) {
 #if defined(_WIN32) || defined(__CYGWIN__)
     HMODULE handle = LoadLibraryA(path.c_str());
@@ -91,15 +130,10 @@ void ModInstance::Init(const std::string& path) {
     } else {
         throw std::runtime_error("Failed to load library: " + std::to_string(GetLastError()));
     }
-#elif defined(__linux__)
-    void* handle = dlopen(path.c_str(), RTLD_NOW);
-    if (handle) {
-        this->mHandle = handle;
-        return;
-    } else {
-        throw std::runtime_error("Failed to load library: " + std::string(dlerror()));
-    }
-#elif defined(__APPLE__)
+#elif defined(__linux__) || defined(__APPLE__)
+#ifdef __linux__
+    FixELFHeader(path);
+#endif
     void* handle = dlopen(path.c_str(), RTLD_NOW);
     if (handle) {
         this->mHandle = handle;

src/port/scripting/scripting.cpp

@@ -46,6 +46,15 @@ void ScriptingLayer::Load(const std::string& path, const std::shared_ptr<Ship::A
         throw std::runtime_error("Failed to create tcc state");
     }
 
+    tcc_define_symbol(s, "VERSION_US", "1");
+    tcc_define_symbol(s, "ENABLE_RUMBLE", "1");
+    tcc_define_symbol(s, "F3D_OLD", "1");
+    tcc_define_symbol(s, "F3D_GBI", "1");
+    tcc_define_symbol(s, "GBI_FLOATS", "1");
+    tcc_define_symbol(s, "_LANGUAGE_C", "1");
+    tcc_define_symbol(s, "_USE_MATH_DEFINES", "1");
+    tcc_define_symbol(s, "AVOID_UB", "1");
+
     tcc_set_output_type(s, TCC_OUTPUT_DLL);
 
     if (tcc_compile_string(s, reinterpret_cast<const char*>(raw.data())) == -1) {