Added somewhat decent dyn library loading

GAMINGNOOBdev · GAMINGNOOBdev · commit ee44d1e0c779 · 2025-01-26T01:21:07.000+01:00
diff --git a/source/boot/limine.cfg b/source/boot/limine.cfg
@@ -21,7 +21,7 @@ TERM_FONT=boot:///iso.f16
     COMMENT=This mode randomize the memory location where the kernel is loaded. Architecture: ${ARCH}
     PROTOCOL=limine
 
-    # MODULE_PATH=${FDMold}
+    MODULE_PATH=${FDMold}
     MODULE_PATH=${FDM}
  
     # Path to the kernel to boot. boot:/// represents the partition on which limine.cfg is located.
@@ -35,7 +35,7 @@ TERM_FONT=boot:///iso.f16
     # Disable KASLR (it is enabled by default for relocatable kernels)
     KASLR=no
 
-    # MODULE_PATH=${FDMold}
+    MODULE_PATH=${FDMold}
     MODULE_PATH=${FDM}
  
     KERNEL_PATH=${WING_KERNEL}
diff --git a/source/includes/fdlfcn.h b/source/includes/fdlfcn.h
@@ -12,9 +12,11 @@ typedef struct
     Elf64_Rela* relocations;
 
     int symtab_index;
+    void* string_table_data;
     void* text_section_data;
     void* data_section_data;
     void* rodata_section_data;
+    void* symtab_str_section_data;
 
     Elf64_Shdr* text_section_header;
     Elf64_Shdr* data_section_header;
diff --git a/source/kernel/C/fdlfcn.c b/source/kernel/C/fdlfcn.c
@@ -1,17 +1,19 @@
+#include <graphics.h>
 #include <memory2.h>
 #include <fdlfcn.h>
 #include <stdint.h>
 #include <stddef.h>
 #include <heap.h>
 #include <elf.h>
 
-#define READ_FROM_MEMORY(dest, base, offset, size) memcpy(dest, (void*)( (uint8_t*)base + offset ), size)
+#define READ_FROM_MEMORY(dest, base, offset, size) printf("reading at address 0x%x", (uint64_t)base + (uint64_t)offset); memcpy(dest, (void*)( (uint64_t)base + (uint64_t)offset ), size)
 
 void* fdl_load_section(void* filedata, Elf64_Shdr* section_header)
 {
     void* section_data = malloc(section_header->sh_size);
-    if (section_data == NULL) {
-        error("fdlopen: malloc failed for section");
+    if (section_data == NULL)
+    {
+        error("fdlopen: malloc failed for section", __FILE__);
         return NULL;
     }
 
@@ -22,94 +24,111 @@ void* fdl_load_section(void* filedata, Elf64_Shdr* section_header)
 
 int fdl_apply_relocations(fdlfcn_handle* lib, int reloc_section_index)
 {
+    if (lib == NULL || reloc_section_index == -1)
+        return 1;
+
     Elf64_Ehdr* elf_header = &lib->ehdr;
     Elf64_Shdr* section_headers = lib->shdrs;
     Elf64_Sym* symbols = lib->symbols;
     Elf64_Rela* relocations = lib->relocations;
 
-    // Get number of relocations
     int num_relocations = section_headers[reloc_section_index].sh_size / sizeof(Elf64_Rela); 
 
-    for (int i = 0; i < num_relocations; i++) {
+    for (int i = 0; i < num_relocations; i++)
+    {
         Elf64_Rela* reloc = &relocations[i]; 
 
-        // Get symbol index
         int sym_index = ELF64_R_SYM(reloc->r_info); 
         Elf64_Sym* sym = &symbols[sym_index];
 
-        // Get relocation type
         int reloc_type = ELF64_R_TYPE(reloc->r_info);
-
-        // Get target address
         uintptr_t target_addr = 0; 
 
-        // Determine target address based on relocation type
-        switch (reloc_type) {
-            case R_X86_64_64: 
-                target_addr = (uintptr_t)sym->st_value; 
-                break;
-            case R_X86_64_PC32: 
-                target_addr = (uintptr_t)sym->st_value - (uintptr_t)(lib->address + reloc->r_offset + 4); 
-                break;
-            case R_X86_64_PLT32: 
-                // Simplified handling - Adjust based on actual PLT implementation
-                target_addr = (uintptr_t)sym->st_value; 
-                break;
-            case R_X86_64_GOTPCREL: 
-                // Simplified handling - Adjust based on actual GOT implementation
-                target_addr = (uintptr_t)sym->st_value; 
-                break;
-            default:
-                error("fdlopen: Unsupported relocation type: %d", reloc_type);
-                return -1; 
+        if (reloc_type == R_X86_64_64)
+            target_addr = (uintptr_t)sym->st_value; 
+        else if (reloc_type == R_X86_64_PC32)
+            target_addr = (uintptr_t)sym->st_value - (uintptr_t)(lib->address + reloc->r_offset + 4);
+        else if (reloc_type == R_X86_64_PLT32)
+            target_addr = (uintptr_t)sym->st_value;
+        else if (reloc_type == R_X86_64_GOTPCREL)
+            target_addr = (uintptr_t)sym->st_value; 
+        else
+        {
+            printf("fdlopen: Unsupported relocation type: %d: %s", reloc_type, __FILE__);
+            return -1;
         }
 
-        // Apply relocation
         uintptr_t* ptr = (uintptr_t*)(lib->address + reloc->r_offset); 
         *ptr += target_addr + reloc->r_addend; 
     }
 
-    return 0; // Relocation successful
+    return 0;
 }
 
 void* fdlsym(fdlfcn_handle* handle, const char* symbol_name)
 {
-    for (int i = 0; i < handle->ehdr.e_shnum; i++) {
-        if (strcmp(handle->shdrs[i].sh_name, ".symtab") == 0) {
-            Elf64_Shdr symtab_section = handle->shdrs[i];
-            Elf64_Sym* symbols = handle->symbols;
-
-            for (int j = 0; j < symtab_section.sh_size / sizeof(Elf64_Sym); j++) {
-                char* symbol_name_str = (char*)((Elf64_Shdr*)((char*)handle->shdrs + handle->ehdr.e_shstrndx))->sh_addr + symbols[j].st_name;
-                if (strcmp(symbol_name_str, symbol_name) == 0) {
-                    // Handle symbol versioning (if needed)
-                    // ...
-
-                    // Calculate symbol address
-                    uintptr_t symbol_address = (uintptr_t)handle->address + symbols[j].st_value; 
-                    return (void*)symbol_address;
-                }
-            }
+    if (handle == NULL)
+        return NULL;
+
+    Elf64_Sym* symbols = handle->symbols;
+
+    int symtab_index = -1;
+    for (int i = 0; i < handle->ehdr.e_shnum; i++)
+    {
+        if (handle->shdrs[i].sh_type == SHT_SYMTAB)
+        {
+            symtab_index = i;
             break;
         }
     }
 
-    error("fdlsym: Symbol '%s' not found", symbol_name);
+    if (symtab_index == -1)
+    {
+        printf("Symbol '%s' not found", symbol_name);
+        return NULL;
+    }
+
+    Elf64_Shdr symtab_section = handle->shdrs[symtab_index];
+
+    for (int j = 0; j < symtab_section.sh_size / sizeof(Elf64_Sym); j++)
+    {
+        char* symbol_name_str = (char*)((uint64_t)handle->symtab_str_section_data + symbols[j].st_name); 
+        if (strcmp(symbol_name_str, symbol_name) == 0 && ELF64_ST_BIND(symbols[j].st_info) != STB_LOCAL)
+        {
+            uintptr_t symbol_address = (uintptr_t)handle->text_section_data + symbols[j].st_value;
+            printf("Found symbol '%s'", symbol_name);
+            return (void*)symbol_address;
+        }
+    }
+
+    printf("fdlsym: Symbol '%s' not found", symbol_name);
     return NULL;
 }
 
 int fdlclose(fdlfcn_handle* handle)
 {
-    if (handle->text_section_data)
+    if (handle == NULL)
+        return 1;
+
+    return 0; /// TODO: somehow all the free calls cause a gp fault, fix that
+
+    if (handle->text_section_data != NULL)
         free(handle->text_section_data);
-    if (handle->data_section_data)
+    if (handle->data_section_data != NULL)
         free(handle->data_section_data);
-    if (handle->rodata_section_data)
+    if (handle->rodata_section_data != NULL)
         free(handle->rodata_section_data);
+    if (handle->string_table_data != NULL)
+        free(handle->string_table_data);
+    if (handle->symtab_str_section_data != NULL)
+        free(handle->symtab_str_section_data);
+    if (handle->shdrs != NULL)
+        free(handle->shdrs);
+    if (handle->symbols != NULL)
+        free(handle->symbols);
+    if (handle->relocations != NULL)
+        free(handle->relocations);
 
-    free(handle->shdrs);
-    free(handle->symbols);
-    free(handle->relocations);
     free(handle);
 
     return 0;
@@ -123,30 +142,41 @@ fdlfcn_handle* fdlopen(void* filedata, int flags)
     fdlfcn_handle* handle = malloc(sizeof(fdlfcn_handle));
     if (handle == NULL)
     {
-        error("Could not allocate memory for shared object file handle");
+        error("Could not allocate memory for shared object file handle", __FILE__);
         return NULL;
     }
     memset(handle, 0, sizeof(fdlfcn_handle));
 
-    // Read ELF header
     Elf64_Ehdr elf_header;
     memcpy(&elf_header, filedata, sizeof(Elf64_Ehdr));
 
-    // Read section headers
+    if (memcmp(&elf_header.e_ident[EI_MAG0], ELFMAG, SELFMAG) != 0 || elf_header.e_ident[EI_CLASS] != ELFCLASS64 || elf_header.e_type != ET_DYN ||
+        elf_header.e_machine != EM_X86_64 || elf_header.e_version != EV_CURRENT)
+    {
+        error("Not a valid .so file", __FILE__);
+        free(handle);
+        return NULL;
+    }
+
     Elf64_Shdr* section_headers = malloc(elf_header.e_shnum * sizeof(Elf64_Shdr));
+    if (section_headers == NULL)
+    {
+        free(handle);
+        return NULL;
+    }
     READ_FROM_MEMORY(section_headers, filedata, elf_header.e_shoff, elf_header.e_shnum * sizeof(Elf64_Shdr));
 
-    // Find important section indices
     int strtab_index = elf_header.e_shstrndx;
     int symtab_index = -1;
     int text_section_index = -1;
     int data_section_index = -1;
     int rodata_section_index = -1;
     int reloc_section_index = -1;
 
+    void* strtableAddr = fdl_load_section(filedata, &section_headers[strtab_index]);
     for (int i = 0; i < elf_header.e_shnum; i++)
     {
-        char* section_name = (char*)((Elf64_Shdr*)((char*)section_headers + strtab_index))->sh_addr + section_headers[i].sh_name;
+        char* section_name = (char*)strtableAddr + section_headers[i].sh_name;
         if (strcmp(section_name, ".text") == 0)
             text_section_index = i;
         else if (strcmp(section_name, ".data") == 0)
@@ -161,10 +191,10 @@ fdlfcn_handle* fdlopen(void* filedata, int flags)
             reloc_section_index = i;
     }
 
-    // Load sections into memory
     void* text_section_data = NULL;
     void* data_section_data = NULL;
     void* rodata_section_data = NULL;
+    void* symtab_str_section_data = NULL;
 
     if (text_section_index != -1)
     {
@@ -204,37 +234,52 @@ fdlfcn_handle* fdlopen(void* filedata, int flags)
         }
     }
 
-    // Read symbol table
     if (symtab_index != -1)
     {
         Elf64_Shdr symtab_section = section_headers[symtab_index];
         handle->symbols = malloc(symtab_section.sh_size);
         READ_FROM_MEMORY(handle->symbols, filedata, symtab_section.sh_offset, symtab_section.sh_size);
-    } else {
-        handle->symbols = NULL; 
+        symtab_str_section_data = fdl_load_section(filedata, &section_headers[symtab_section.sh_link]);
     }
+    else
+        handle->symbols = NULL; 
 
-    // Read relocation entries
-    if (reloc_section_index != -1) {
+    if (reloc_section_index != -1)
+    {
         Elf64_Shdr reloc_section = section_headers[reloc_section_index];
         handle->relocations = malloc(reloc_section.sh_size);
         READ_FROM_MEMORY(handle->relocations, filedata, reloc_section.sh_offset, reloc_section.sh_size);
-    } else {
-        handle->relocations = NULL; 
     }
+    else
+        handle->relocations = NULL; 
 
-    handle->address = (void*)section_headers[text_section_index].sh_addr; 
+    handle->address = text_section_data;
+    handle->text_section_data = text_section_data;
+    handle->symtab_str_section_data = symtab_str_section_data;
+    handle->text_section_header = &section_headers[text_section_index];
+    handle->data_section_data = data_section_data;
+    handle->data_section_header = &section_headers[data_section_index];
+    handle->rodata_section_data = rodata_section_data;
+    handle->rodata_section_header = &section_headers[rodata_section_index];
+    handle->string_table_data = strtableAddr;
+    handle->ehdr = elf_header;
+    handle->shdrs = section_headers;
+    handle->symtab_index = symtab_index;
 
-    if (fdl_apply_relocations(handle, reloc_section_index) != 0)
+    if (fdl_apply_relocations(handle, reloc_section_index) != 0 && reloc_section_index != -1)
     {
-        error("fdlopen: Relocation failed");
+        error("fdlopen: Relocation failed", __FILE__);
 
         if (text_section_data)
             free(text_section_data);
         if (data_section_data)
             free(data_section_data);
         if (rodata_section_data)
             free(rodata_section_data);
+        if (strtableAddr)
+            free(strtableAddr);
+        if (symtab_str_section_data)
+            free(symtab_str_section_data);
 
         free(section_headers);
         free(handle->symbols);
@@ -243,16 +288,7 @@ fdlfcn_handle* fdlopen(void* filedata, int flags)
         return NULL;
     }
 
-    handle->text_section_data = text_section_data;
-    handle->text_section_header = &section_headers[text_section_index];
-    handle->data_section_data = data_section_data;
-    handle->data_section_header = &section_headers[data_section_index];
-    handle->rodata_section_data = rodata_section_data;
-    handle->rodata_section_header = &section_headers[rodata_section_index];
-
-    handle->ehdr = elf_header;
-    handle->shdrs = section_headers; 
-    handle->symtab_index = symtab_index; // Store symtab index for later use
+    info("fdlopen: Successfully loaded .so file", __FILE__);
 
     return handle;
 }
diff --git a/source/kernel/C/kernel.c b/source/kernel/C/kernel.c
@@ -381,16 +381,21 @@ void main(void) {
     // int* test3 = malloc(sizeof(int));
     // int* test4 = malloc(sizeof(int));
 
-    // void* file_addr = module_request.response->modules[0]->address;
-    // elf_load_from_memory(file_addr);
-    // fdlfcn_handle* handle = fdlopen(file_addr, FDL_IMMEDIATE);
-    // if (handle != NULL)
-    //     info("IT'S WORKING", __FILE__);
+    void* file_addr = module_request.response->modules[0]->address;
+    elf_load_from_memory(file_addr);
+    fdlfcn_handle* handle = fdlopen(file_addr, FDL_IMMEDIATE);
+    void* startFunction = fdlsym(handle, "frostedwm_create_context");
+    if (startFunction != NULL)
+        info("Successfully loaded function from .so file", __FILE__);
+    fdlclose(handle);
 
     int failed_attempts = 0;
 
-    int (*execute_binary)() = (int (*)())module_request.response->modules[1]->address;
+    // void* binaddress = module_request.response->modules[1]->address;
+    // printf("binary addr: 0x%x", binaddress);
+    // int (*execute_binary)(void) = binaddress;
     // int status_code = execute_binary();
+    // printf("return code: 0x%x", status_code);
 
     // glCreateContext();
     // glCreateContextCustom(front_buffer, framebuffer->width, framebuffer->height);
diff --git a/source/kernel/C/strings.c b/source/kernel/C/strings.c
