Symlink support

Author: martinRenou

src/index.ts

@@ -74,15 +74,16 @@ export const initUntarJS = async (locateWasm?: (file: string) => string): Promis
      * FilesPtr is a pointer that refers to an instance of the FileData in unpack.c
         typedef struct {
           char* filename;
+          char* symlink;
           uint8_t* data;
           size_t data_size;
         } FileData;
 
       and its fields are laid out in memory sequentially too so each field take 4 bytes:
 
-          4 bytes        4 bytes         4 bytes
-      ---------------|---------------|---------------
-    filename            data         data_size
+          4 bytes        4 bytes         4 bytes         4 bytes
+      ---------------|---------------|---------------|---------------
+      filename            symlink          data          data_size
 
     `filesPtr + i * 12` calculates the memory address of the i-th FileData element in the array
       where `12` is the size of each FileData structure in memory in bytes: 4 + 4 + 4
@@ -91,16 +92,23 @@ export const initUntarJS = async (locateWasm?: (file: string) => string): Promis
     for (let i = 0; i < fileCount; i++) {
       const fileDataPtr = filesPtr + i * 12;
       const filenamePtr = wasmModule.getValue(fileDataPtr, 'i32');
-      const dataSize = wasmModule.getValue(fileDataPtr + 8, 'i32');
-      const dataPtr = wasmModule.getValue(fileDataPtr + 4, 'i32');
+      const symlinkPtr = wasmModule.getValue(fileDataPtr + 4, 'i32');
+      const dataPtr = wasmModule.getValue(fileDataPtr + 8, 'i32');
+      const dataSize = wasmModule.getValue(fileDataPtr + 12, 'i32');
       const filename = wasmModule.UTF8ToString(filenamePtr);
-      const fileData = new Uint8Array(
-        wasmModule.HEAPU8.buffer,
-        dataPtr,
-        dataSize
-      );
-      const fileDataCopy = fileData.slice(0);
-      files[filename] = fileDataCopy;
+      const symlink = wasmModule.UTF8ToString(symlinkPtr);
+
+      if (symlink) {
+        files[filename] = symlink;
+      } else {
+        const fileData = new Uint8Array(
+          wasmModule.HEAPU8.buffer,
+          dataPtr,
+          dataSize
+        );
+        const fileDataCopy = fileData.slice(0);
+        files[filename] = fileDataCopy;
+      }
     }
 
     wasmModule._free(inputPtr);

src/types.ts

@@ -1,4 +1,6 @@
-export type FilesData = { [filename: string]: Uint8Array };
+export type Symlink = string;
+
+export type FilesData = { [filename: string]: Uint8Array | Symlink };
 
 export interface IUnpackJSAPI {
   extractData: (data: Uint8Array, decompressionOnly?: boolean) => Promise<FilesData>;

unpack.c

@@ -8,6 +8,7 @@
 
 typedef struct {
     char* filename;
+    char* symlink;
     uint8_t* data;
     size_t data_size;
 } FileData;
@@ -57,13 +58,27 @@ ExtractedArchive* extract_archive(uint8_t* inputData, size_t inputSize ) {
     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); 
+        return error_handler(result,archive_error_string(archive), archive);
     }
     files = malloc(sizeof(FileData) * files_struct_length);
 
     while (archive_read_next_header(archive, &entry) == ARCHIVE_OK) {
         const char* filename = archive_entry_pathname(entry);
         size_t entrySize = archive_entry_size(entry);
+
+        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++;
+
+            continue;
+        }
+
+
         if (files_count + 1 > files_struct_length) {
             files_struct_length *= 2; // double the length
             FileData* oldfiles = files;
@@ -73,9 +88,10 @@ ExtractedArchive* extract_archive(uint8_t* inputData, size_t inputSize ) {
                 result->files = oldfiles; // otherwise memory is lost, alternatively also everything can be freed.
                 error_message = "Memory allocation error for file data.";
                 return error_handler(result, error_message, archive);
-            }     
+            }
         }
         files[files_count].filename = strdup(filename);
+        files[files_count].symlink = strdup("");
         files[files_count].data = malloc(entrySize);
         files[files_count].data_size = entrySize;
 
@@ -150,7 +166,7 @@ ExtractedArchive* decompression(uint8_t* inputData, size_t inputSize) {
 
     const size_t buffsize = 64 * 1024;
     char buff[buffsize];
-    size_t total_size = 0; 
+    size_t total_size = 0;
     const char *error_message;
 
     FileData* files = malloc(sizeof(FileData) * (files_count + 1));
@@ -159,7 +175,7 @@ ExtractedArchive* decompression(uint8_t* inputData, size_t inputSize) {
         printf("Failed to allocate memory for files array\n");
         return NULL;
     }
-    
+
     ExtractedArchive* result = (ExtractedArchive*)malloc(sizeof(ExtractedArchive));
     if (!result) {
         free(files);
@@ -194,6 +210,7 @@ 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;
 
@@ -259,4 +276,4 @@ void free_extracted_archive(ExtractedArchive* archive) {
     }
     free(archive->files);
     free(archive);
-}
+}