Merge pull request emscripten-forge#26 from AnastasiaSliusar/add-error-handling

Add error handling

Author: martinRenou

src/index.ts

@@ -27,24 +27,82 @@ export const extractData = async (data: Uint8Array): Promise<IFileData[]> => {
     console.error('WASM module not initialized.');
     return [];
   }
+
+  /**Since WebAssembly, memory is accessed using pointers 
+    and the first parameter of extract_archive method from unpack.c, which is Uint8Array of file data, should be a pointer 
+    so we have to allocate memory for file data
+  **/
   const inputPtr = wasmModule._malloc(data.length);
   wasmModule.HEAPU8.set(data, inputPtr);
+
+  // fileCountPtr is the pointer to 4 bytes of memory in WebAssembly's heap that holds fileCount value from the ExtractedArchive structure in unpack.c.
   const fileCountPtr = wasmModule._malloc(4);
-  const outputSizePtr = wasmModule._malloc(4);
 
   try {
-    const extractedFilesPtr = wasmModule._extract_archive(
+    const resultPtr = wasmModule._extract_archive(
       inputPtr,
       data.length,
-      outputSizePtr,
       fileCountPtr
     );
 
-    const fileCount = wasmModule.getValue(fileCountPtr, 'i32');
+    /**
+     * Since extract_archive returns a pointer that refers to an instance of the ExtractedArchive in unpack.c
+        typedef struct {
+          FileData* files;
+          size_t fileCount;
+          int status;
+          char* error_message; 
+        } ExtractedArchive;
+
+      its fields are laid out in memory sequentially. Based on this and types each field will take 4 bytes:
+        
+          4 bytes        4 bytes         4 bytes         4 bytes
+      ---------------|---------------|---------------|---------------
+     files            fileCount         status        error_message
+
+      `resultPtr` points to the beginning of the ExtractedArchive structure in WebAssembly memory 
+      and in order to get pointer of statusPtr we need to calculate it as: 0(offset of file pointer) + 4 (offset of fileCount) + 4 (offset for status)
+      'status' field and pointer of `error_message` are 32-bit signed integer
+    */
+    const statusPtr = wasmModule.getValue(resultPtr + 8, 'i32');
+    const errorMessagePtr = wasmModule.getValue(resultPtr + 12, 'i32');
+    console.log('status', statusPtr);
+    console.log('errorMessagePtr', errorMessagePtr);
+    if (statusPtr !== 1) {
+      const errorMessage = wasmModule.UTF8ToString(errorMessagePtr);
+      console.error(
+        'Extraction failed with status:',
+        statusPtr,
+        'Error:',
+        errorMessage
+      );
+      return [];
+    }
+    const filesPtr = wasmModule.getValue(resultPtr, 'i32');
+    const fileCount = wasmModule.getValue(resultPtr + 4, 'i32');
+
     const files: IFileData[] = [];
 
+    /**
+     * FilesPtr is a pointer that refers to an instance of the FileData in unpack.c
+        typedef struct {
+          char* filename;
+          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        
+
+     `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
+    */
+
     for (let i = 0; i < fileCount; i++) {
-      const fileDataPtr = extractedFilesPtr + i * (3 * 4);
+      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');
@@ -61,14 +119,15 @@ export const extractData = async (data: Uint8Array): Promise<IFileData[]> => {
       });
     }
 
-    wasmModule._free(fileCountPtr);
-    wasmModule._free(outputSizePtr);
     wasmModule._free(inputPtr);
-    wasmModule._free(extractedFilesPtr);
+    wasmModule._free(fileCountPtr);
+    wasmModule._free(statusPtr);
+    wasmModule._free(errorMessagePtr);
+    wasmModule._free(resultPtr);
 
     return files;
   } catch (error) {
-    console.error('Error during extracting:', error);
+    console.error('Error during extraction:', error);
     return [];
   }
 };

src/unpack.d.ts

@@ -6,7 +6,6 @@ export interface IWasmModule {
   _extract_archive(
     inputPtr: number,
     inputSize: number,
-    outputSizePtr: number,
     fileCountPtr: number
   ): number;
   getValue(ptr: number, type: string): number;

unpack.c

@@ -11,23 +11,42 @@ typedef struct {
     size_t data_size;
 } FileData;
 
+typedef struct {
+    FileData* files;
+    size_t fileCount;
+    int status;
+    char* error_message;
+} ExtractedArchive;
+
 EMSCRIPTEN_KEEPALIVE
-FileData* extract_archive(uint8_t* inputData, size_t inputSize, size_t* outputSize, size_t* fileCount) {
+ExtractedArchive* extract_archive(uint8_t* inputData, size_t inputSize, size_t* fileCount) {
     struct archive* archive;
     struct archive_entry* entry;
     FileData* files = NULL;
     size_t files_count = 0;
 
+    ExtractedArchive* result = (ExtractedArchive*)malloc(sizeof(ExtractedArchive));
+    if (!result) {
+        result->status = 0;
+        result->error_message = strdup("Memory allocation error for ExtractedArchive.");   
+        return NULL;
+    }
+
+    result->files = NULL;
+    result->fileCount = 0;
+    result->status = 1;
+    result->error_message = NULL;
+
     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) {
-        fprintf(stderr, "Error opening archive: %s\n", archive_error_string(archive));
         archive_read_free(archive);
-        return NULL;
+        result->status = 0;
+        result->error_message = strdup(archive_error_string(archive));
+        return result;
     }
-    printf("Archive opened successfully.\n");
 
     while (archive_read_next_header(archive, &entry) == ARCHIVE_OK) {
         const char* filename = archive_entry_pathname(entry);
@@ -36,47 +55,48 @@ FileData* extract_archive(uint8_t* inputData, size_t inputSize, size_t* outputSi
 
         files = realloc(files, sizeof(FileData) * (files_count + 1));
         if (!files) {
-            fprintf(stderr, "Memory allocation error for FileData array.\n");
             archive_read_free(archive);
-            return NULL;
+            result->status = 0;
+            result->error_message = strdup("Memory allocation error for FileData array.");
+            return result;
         }
 
         files[files_count].filename = strdup(filename);
         files[files_count].data = malloc(entrySize);
-        printf("Setting data_size for file: %s, size: %zu\n", filename, entrySize);
         files[files_count].data_size = entrySize;
 
         if (!files[files_count].data) {
-            fprintf(stderr, "Memory allocation error for file data.\n");
             free(files[files_count].filename);
             archive_read_free(archive);
-            return NULL;
+            result->status = 0;
+            result->error_message = strdup("Memory allocation error for file data.");
+            return result;
         }
 
         size_t bytesRead = 0;
         while (bytesRead < entrySize) {
             ssize_t ret = archive_read_data(archive, files[files_count].data + bytesRead, entrySize - bytesRead);
             if (ret < 0) {
-                fprintf(stderr, "Error reading data for %s: %s\n", filename, archive_error_string(archive));
                 for (size_t i = 0; i <= files_count; i++) {
                     free(files[i].filename);
                     free(files[i].data);
                 }
                 free(files);
                 archive_read_free(archive);
-                return NULL;
+                result->status = 0;
+                result->error_message = strdup(archive_error_string(archive));
+                return result;
             }
             bytesRead += ret;
-            printf("Read %zd bytes for file: %s\n", ret, filename);
         }
         files_count++;
     }
 
     archive_read_free(archive);
-    *outputSize = files_count;
-    *fileCount = files_count;
-
-    return files;
+    result->files = files;
+    result->fileCount = files_count;
+    result->status = 1;
+    return result;
 }