Handle symlinks take two

Author: martinRenou

unpack.c

@@ -8,7 +8,6 @@
 
 typedef struct {
     char* filename;
-    char* symlink;
     uint8_t* data;
     size_t data_size;
 } FileData;
@@ -42,6 +41,7 @@ ExtractedArchive* extract_archive(uint8_t* inputData, size_t inputSize ) {
     FileData* files = NULL;
     size_t files_count = 0;
     const char *error_message;
+    bool hasSymLinks = false;
 
     ExtractedArchive* result = (ExtractedArchive*)malloc(sizeof(ExtractedArchive));
     if (!result) {
@@ -66,19 +66,12 @@ ExtractedArchive* extract_archive(uint8_t* inputData, size_t inputSize ) {
         const char* filename = archive_entry_pathname(entry);
         size_t entrySize = archive_entry_size(entry);
 
+        // Ignore symbolic links for now
         if (archive_entry_filetype(entry) == AE_IFLNK) {
-            // It's a symbolic link
-            const char* target = archive_entry_symlink(entry);
-
-            files[files_count].filename = strdup(filename);
-            files[files_count].symlink = strdup(target);
-
-            files_count++;
-
+            hasSymLinks = true;
             continue;
         }
 
-
         if (files_count + 1 > files_struct_length) {
             files_struct_length *= 2; // double the length
             FileData* oldfiles = files;
@@ -90,9 +83,8 @@ ExtractedArchive* extract_archive(uint8_t* inputData, size_t inputSize ) {
                 return error_handler(result, error_message, archive);
             }
         }
+
         files[files_count].filename = strdup(filename);
-        free(files[files_count].symlink);
-        files[files_count].symlink = NULL;
         files[files_count].data = malloc(entrySize);
         files[files_count].data_size = entrySize;
 
@@ -122,6 +114,77 @@ ExtractedArchive* extract_archive(uint8_t* inputData, size_t inputSize ) {
         files_count++;
     }
 
+    // Resolve symlinks
+    if (hasSymLinks) {
+        // Rewind and reopen the archive to iterate over symlinks
+        archive_read_free(archive);
+        archive = archive_read_new();
+        archive_read_support_filter_all(archive);
+        archive_read_support_format_all(archive);
+
+        if (archive_read_open_memory(archive, inputData, inputSize) != ARCHIVE_OK) {
+            return error_handler(result, archive_error_string(archive), archive);
+        }
+
+        struct archive_entry *symlink_entry;
+        while (archive_read_next_header(archive, &symlink_entry) == ARCHIVE_OK) {
+            // Process only symlinks this time
+            if (archive_entry_filetype(symlink_entry) != AE_IFLNK) {
+                continue;
+            }
+
+            const char *linkname = archive_entry_pathname(symlink_entry);
+            const char *target = archive_entry_symlink(symlink_entry);
+
+            // Target not found
+            if (!target) {
+                continue;
+            }
+
+            // Find the target file in the already populated files[]
+            size_t target_index = (size_t)-1;
+            for (size_t i = 0; i < files_count; i++) {
+                if (strcmp(files[i].filename, target) == 0) {
+                    target_index = i;
+                    break;
+                }
+            }
+
+            // Target not found in the processed files
+            if (target_index == (size_t)-1 || !files[target_index].data) {
+                continue;
+            }
+
+            // Add the symlink entry
+            if (files_count + 1 > files_struct_length) {
+                files_struct_length *= 2;
+                FileData *oldfiles = files;
+                files = realloc(files, sizeof(FileData) * files_struct_length);
+                if (!files) {
+                    result->fileCount = files_count;
+                    result->files = oldfiles;
+                    error_message = "Memory allocation error for symlink data.";
+                    return error_handler(result, error_message, archive);
+                }
+            }
+
+            files[files_count].filename = strdup(linkname);
+            files[files_count].data_size = files[target_index].data_size;
+            files[files_count].data = malloc(files[target_index].data_size);
+            if (!files[files_count].data) {
+                free(files[files_count].filename);
+                files[files_count].filename = NULL;
+                result->fileCount = files_count;
+                result->files = files;
+                error_message = "Memory allocation error for symlink target data.";
+                return error_handler(result, error_message, archive);
+            }
+            memcpy(files[files_count].data, files[target_index].data, files[target_index].data_size);
+
+            files_count++;
+        }
+    }
+
     archive_read_free(archive);
     result->files = files;
     result->fileCount = files_count;
@@ -211,7 +274,6 @@ ExtractedArchive* decompression(uint8_t* inputData, size_t inputSize) {
         if (!filename) filename = "decompression";
 
         files[files_count].filename = strdup(filename);
-        files[files_count].symlink = strdup("");
         files[files_count].data = NULL;
         files[files_count].data_size = 0;
 
@@ -273,7 +335,6 @@ void free_extracted_archive(ExtractedArchive* archive) {
     }
     for (size_t i = 0; i < archive->fileCount; i++) {
         free(archive->files[i].filename);
-        free(archive->files[i].symlink);
         free(archive->files[i].data);
     }
     free(archive->files);