Fix style issues and stack space leak

JoeOsborn · JoeOsborn · commit 62987bb51b52 · 2024-11-27T06:52:57.000-08:00
diff --git a/src/library_fetchfs.js b/src/library_fetchfs.js
@@ -8,17 +8,17 @@ addToLibrary({
   $FETCHFS__deps: ['$stringToUTF8OnStack', 'wasmfs_create_fetch_backend', 'wasmfs_fetch_create_manifest', 'wasmfs_fetch_add_to_manifest'],
   $FETCHFS: {
     createBackend(opts) {
-      var manifest = 0;
-      if (opts['manifest']) {
-        manifest = wasmfs_fetch_create_manifest();
-        Object.entries(opts['manifest']).forEach((pair) => {
-          var path = stringToUTF8OnStack(pair[0]);
-          var url = stringToUTF8OnStack(pair[1]);
-          wasmfs_fetch_add_to_manifest(path, url);
-        })
-      }
-      return _wasmfs_create_fetch_backend(stringToUTF8OnStack(opts.base_url), opts.chunkSize | 0, manifest);
-    }
+      return withStackSave(() => {
+        var manifest = 0;
+        if (opts['manifest']) {
+          manifest = wasmfs_fetch_create_manifest();
+          Object.entries(opts['manifest']).forEach(([path, url]) => {
+            wasmfs_fetch_add_to_manifest(stringToUTF8OnStack(path),
+                                         stringToUTF8OnStack(url));
+          });
+        }
+        return _wasmfs_create_fetch_backend(stringToUTF8OnStack(opts.base_url), opts.chunkSize | 0, manifest);
+      });
   },
 });
 
diff --git a/src/library_wasmfs_fetch.js b/src/library_wasmfs_fetch.js
@@ -31,7 +31,8 @@ addToLibrary({
         try {
           var u = new URL(fileUrl, self.location.origin);
           url = u.toString();
-        } catch (e) {
+        } catch(_e) {
+          throw {status: 404};
         }
       }
       var chunkSize = __wasmfs_fetch_get_chunk_size(file);
@@ -41,15 +42,15 @@ addToLibrary({
       var lastChunk = ((offset+len) / chunkSize) | 0;
       if (!(file in wasmFS$JSMemoryRanges)) {
         var fileInfo = await fetch(url,{method:"HEAD", headers:{"Range": "bytes=0-"}});
-        if(fileInfo.ok &&
+        if (fileInfo.ok &&
            fileInfo.headers.has("Content-Length") &&
            fileInfo.headers.get("Accept-Ranges") == "bytes" &&
            (parseInt(fileInfo.headers.get("Content-Length")) > chunkSize*2)) {
           wasmFS$JSMemoryRanges[file] = {size:parseInt(fileInfo.headers.get("Content-Length")), chunks:[], chunkSize:chunkSize};
         } else {
           // may as well/forced to download the whole file
           var wholeFileReq = await fetch(url);
-          if(!wholeFileReq.ok) {
+          if (!wholeFileReq.ok) {
             throw wholeFileReq;
           }
           var wholeFileData = new Uint8Array(await wholeFileReq.arrayBuffer());
@@ -60,11 +61,11 @@ addToLibrary({
       }
       var allPresent = true;
       var i;
-      if(lastChunk * chunkSize < offset+len) {
+      if (lastChunk * chunkSize < offset+len) {
         lastChunk += 1;
       }
-      for(i = firstChunk; i < lastChunk; i++) {
-        if(!wasmFS$JSMemoryRanges[file].chunks[i]) {
+      for (i = firstChunk; i < lastChunk; i++) {
+        if (!wasmFS$JSMemoryRanges[file].chunks[i]) {
           allPresent = false;
           break;
         }
@@ -78,14 +79,13 @@ addToLibrary({
       var start = firstChunk*chunkSize;
       var end = lastChunk*chunkSize;
       var response = await fetch(url, {headers:{"Range": `bytes=${start}-${end-1}`}});
-      if (response.ok) {
-        var bytes = new Uint8Array(await response['arrayBuffer']());
-        for (i = firstChunk; i < lastChunk; i++) {
-          wasmFS$JSMemoryRanges[file].chunks[i] = bytes.slice(i*chunkSize-start,(i+1)*chunkSize-start);
-        }
-      } else {
+      if (!response.ok) {
         throw response;
       }
+      var bytes = new Uint8Array(await response['arrayBuffer']());
+      for (i = firstChunk; i < lastChunk; i++) {
+        wasmFS$JSMemoryRanges[file].chunks[i] = bytes.slice(i*chunkSize-start,(i+1)*chunkSize-start);
+      }
       return Promise.resolve();
     }
 
@@ -110,24 +110,21 @@ addToLibrary({
       read: async (file, buffer, length, offset) => {
         try {
           await getFileRange(file, offset || 0, length);
-        } catch (response) {
-          return response.status === 404 ? -{{{ cDefs.ENOENT }}} : -{{{ cDefs.EBADF }}};
+        } catch (failedResponse) {
+          return failedResponse.status === 404 ? -{{{ cDefs.ENOENT }}} : -{{{ cDefs.EBADF }}};
         }
         var fileInfo = wasmFS$JSMemoryRanges[file];
         var fileData = fileInfo.chunks;
         var chunkSize = fileInfo.chunkSize;
         var firstChunk = (offset / chunkSize) | 0;
         var lastChunk = ((offset+length) / chunkSize) | 0;
-        if(offset + length > lastChunk * chunkSize) {
+        if (offset + length > lastChunk * chunkSize) {
           lastChunk += 1;
         }
         var readLength = 0;
         for (var i = firstChunk; i < lastChunk; i++) {
           var chunk = fileData[i];
           var start = Math.max(i*chunkSize, offset);
-          if(!chunk) {
-            throw [fileData.length, firstChunk, lastChunk, i];
-          }
           var chunkStart = i*chunkSize;
           var end = Math.min(chunkStart+chunkSize, offset+length);
           HEAPU8.set(chunk.subarray(start-chunkStart, end-chunkStart), buffer+(start-offset));
@@ -138,7 +135,7 @@ addToLibrary({
       getSize: async (file) => {
         try {
           await getFileRange(file, 0, 0);
-        } catch (response) {
+        } catch (failedResponse) {
           return 0;
         }
         return wasmFS$JSMemoryRanges[file].size;
diff --git a/system/include/emscripten/wasmfs.h b/system/include/emscripten/wasmfs.h
@@ -57,10 +57,18 @@ backend_t wasmfs_create_memory_backend(void);
 //
 // TODO: Add an async version of this function that will work on the main
 // thread.
-backend_t wasmfs_create_fetch_backend(const char* base_url __attribute__((nonnull)), uint32_t, void *);
+backend_t wasmfs_create_fetch_backend(const char* base_url __attribute__((nonnull)),
+                                      uint32_t chunkSize,
+                                      void *manifest);
 
+// Create a FetchFS manifest record that can be populated and passed into
+// wasmfs_fetch_create_backend.
 void *wasmfs_fetch_create_manifest();
-void wasmfs_fetch_add_to_manifest(void *, const char *, const char *);
+
+// Add a path to URL mapping to the given manifest.
+void wasmfs_fetch_add_to_manifest(void *manifest __attribute__((nonnull)),
+                                  const char *path __attribute__((nonnull)),
+                                  const char *url __attribute__((nonnull)));
 
 backend_t wasmfs_create_node_backend(const char* root __attribute__((nonnull)));
 
diff --git a/system/lib/wasmfs/backends/fetch_backend.cpp b/system/lib/wasmfs/backends/fetch_backend.cpp
@@ -112,6 +112,7 @@ const std::string FetchBackend::getFileURL(const std::string& filePath) {
   }
   return baseUrl + "/" + filePath;
 }
+
 uint32_t FetchBackend::getChunkSize() {
   return chunkSize;
 }
@@ -124,27 +125,30 @@ extern "C" {
          "Cannot safely create fetch backend on main browser thread");
   return wasmFS.addBackend(std::make_unique<FetchBackend>(
     base_url ? base_url : "",
-    chunkSize != 0 ? chunkSize : DEFAULT_CHUNK_SIZE,
+    chunkSize ? chunkSize : DEFAULT_CHUNK_SIZE,
     manifest,
     [](backend_t backend) { _wasmfs_create_fetch_backend_js(backend); }));
   }
 
-const char* EMSCRIPTEN_KEEPALIVE _wasmfs_fetch_get_file_path(void* ptr) {
+const char* _wasmfs_fetch_get_file_path(void* ptr) {
   auto* file = reinterpret_cast<wasmfs::FetchFile*>(ptr);
   return file ? file->getPath().data() : nullptr;
 }
-const char* EMSCRIPTEN_KEEPALIVE _wasmfs_fetch_get_file_url(void* ptr) {
+
+const char* _wasmfs_fetch_get_file_url(void* ptr) {
   auto* file = reinterpret_cast<wasmfs::FetchFile*>(ptr);
   return file ? file->getURL().data() : nullptr;
 }
-uint32_t EMSCRIPTEN_KEEPALIVE _wasmfs_fetch_get_chunk_size(void* ptr) {
+
+uint32_t _wasmfs_fetch_get_chunk_size(void* ptr) {
   auto* file = reinterpret_cast<wasmfs::FetchFile*>(ptr);
   return file ? file->getChunkSize() : DEFAULT_CHUNK_SIZE;
 }
 
 void *EMSCRIPTEN_KEEPALIVE wasmfs_fetch_create_manifest() {
   return new FetchManifest();
 }
+
 void EMSCRIPTEN_KEEPALIVE wasmfs_fetch_add_to_manifest(void *manifest_ptr, const char *path, const char *url) {
   auto* manifest = reinterpret_cast<FetchManifest *>(manifest_ptr);
   auto path_str = std::string(path);
diff --git a/system/lib/wasmfs/backends/fetch_backend.h b/system/lib/wasmfs/backends/fetch_backend.h
@@ -6,6 +6,6 @@
 #include "wasmfs.h"
 
 extern "C" {
-  // See library_wasmfs_fetch.js
-  void _wasmfs_create_fetch_backend_js(wasmfs::backend_t);
+// See library_wasmfs_fetch.js
+void _wasmfs_create_fetch_backend_js(wasmfs::backend_t);
 }
diff --git a/test/common.py b/test/common.py
@@ -1938,7 +1938,7 @@ def send_head(self):
         f = open(path, 'rb')
         fs = os.fstat(f.fileno())
       except IOError:
-        self.send_error(404, "File not found: " + path)
+        self.send_error(404, f'File not found {path}')
         return None
       if self.path.endswith('.js'):
         self.send_response(200)
@@ -1947,16 +1947,16 @@ def send_head(self):
         self.send_header('Content-length', fs[6])
         self.end_headers()
         return f
-      elif self.headers.get("Range"):
+      elif self.headers.get('Range'):
         self.send_response(206)
         ctype = self.guess_type(path)
         self.send_header('Content-Type', ctype)
-        pieces = self.headers.get("Range").split("=")[1].split("-")
+        pieces = self.headers.get('Range').split('=')[1].split('-')
         start = int(pieces[0]) if pieces[0] != '' else 0
         end = int(pieces[1]) if pieces[1] != '' else fs[6] - 1
         end = min(fs[6] - 1, end)
         length = end - start + 1
-        self.send_header('Content-Range', "bytes " + str(start) + "-" + str(end) + "/" + str(fs[6]))
+        self.send_header('Content-Range', f'bytes {start}-{end}/{fs[6]}')
         self.send_header('Content-Length', str(length))
         self.end_headers()
         return f
@@ -2060,19 +2060,19 @@ def do_GET(self):
         # Use SimpleHTTPServer default file serving operation for GET.
         if DEBUG:
           print('[simple HTTP serving:', unquote_plus(self.path), ']')
-        if self.headers.get("Range"):
+        if self.headers.get('Range'):
           self.send_response(206)
           path = self.translate_path(self.path)
           data = read_binary(path)
           ctype = self.guess_type(path)
           self.send_header('Content-type', ctype)
-          pieces = self.headers.get("range").split("=")[1].split("-")
+          pieces = self.headers.get('Range').split('=')[1].split('-')
           start = int(pieces[0]) if pieces[0] != '' else 0
           end = int(pieces[1]) if pieces[1] != '' else len(data) - 1
           end = min(len(data) - 1, end)
           length = end - start + 1
           self.send_header('Content-Length', str(length))
-          self.send_header('Content-Range', "bytes " + str(start) + "-" + str(end) + "/" + str(len(data)))
+          self.send_header('Content-Range', f'bytes {start}-{end}/{len(data)}')
           self.end_headers()
           self.wfile.write(data[start:end + 1])
         else:

Original file line number	Diff line number	Diff line change
`@@ -112,6 +112,7 @@ const std::string FetchBackend::getFileURL(const std::string& filePath) {`
`112`	`112`	`}`
`113`	`113`	`return baseUrl + "/" + filePath;`
`114`	`114`	`}`
	`115`	`+`
`115`	`116`	`uint32_t FetchBackend::getChunkSize() {`
`116`	`117`	`return chunkSize;`
`117`	`118`	`}`
`@@ -124,27 +125,30 @@ extern "C" {`
`124`	`125`	`"Cannot safely create fetch backend on main browser thread");`
`125`	`126`	`return wasmFS.addBackend(std::make_unique<FetchBackend>(`
`126`	`127`	`base_url ? base_url : "",`
`127`		`- chunkSize != 0 ? chunkSize : DEFAULT_CHUNK_SIZE,`
	`128`	`+ chunkSize ? chunkSize : DEFAULT_CHUNK_SIZE,`
`128`	`129`	`manifest,`
`129`	`130`	`[](backend_t backend) { _wasmfs_create_fetch_backend_js(backend); }));`
`130`	`131`	`}`
`131`	`132`
`132`		`-const char* EMSCRIPTEN_KEEPALIVE _wasmfs_fetch_get_file_path(void* ptr) {`
	`133`	`+const char* _wasmfs_fetch_get_file_path(void* ptr) {`
`133`	`134`	`auto* file = reinterpret_cast<wasmfs::FetchFile*>(ptr);`
`134`	`135`	`return file ? file->getPath().data() : nullptr;`
`135`	`136`	`}`
`136`		`-const char* EMSCRIPTEN_KEEPALIVE _wasmfs_fetch_get_file_url(void* ptr) {`
	`137`	`+`
	`138`	`+const char* _wasmfs_fetch_get_file_url(void* ptr) {`
`137`	`139`	`auto* file = reinterpret_cast<wasmfs::FetchFile*>(ptr);`
`138`	`140`	`return file ? file->getURL().data() : nullptr;`
`139`	`141`	`}`
`140`		`-uint32_t EMSCRIPTEN_KEEPALIVE _wasmfs_fetch_get_chunk_size(void* ptr) {`
	`142`	`+`
	`143`	`+uint32_t _wasmfs_fetch_get_chunk_size(void* ptr) {`
`141`	`144`	`auto* file = reinterpret_cast<wasmfs::FetchFile*>(ptr);`
`142`	`145`	`return file ? file->getChunkSize() : DEFAULT_CHUNK_SIZE;`
`143`	`146`	`}`
`144`	`147`
`145`	`148`	`void *EMSCRIPTEN_KEEPALIVE wasmfs_fetch_create_manifest() {`
`146`	`149`	`return new FetchManifest();`
`147`	`150`	`}`
	`151`	`+`
`148`	`152`	`void EMSCRIPTEN_KEEPALIVE wasmfs_fetch_add_to_manifest(void manifest_ptr, const char path, const char *url) {`
`149`	`153`	`auto* manifest = reinterpret_cast<FetchManifest *>(manifest_ptr);`
`150`	`154`	`auto path_str = std::string(path);`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,6 @@`
`6`	`6`	`#include "wasmfs.h"`
`7`	`7`
`8`	`8`	`extern "C" {`
`9`		`- // See library_wasmfs_fetch.js`
`10`		`- void _wasmfs_create_fetch_backend_js(wasmfs::backend_t);`
	`9`	`+// See library_wasmfs_fetch.js`
	`10`	`+void _wasmfs_create_fetch_backend_js(wasmfs::backend_t);`
`11`	`11`	`}`