js-dos 0.80.25

package/src/sockdrive/README.md

@@ -0,0 +1,22 @@
+# sockdrive client api sdk
+
+# js
+
+Plain js api ready to use in browser.
+
+Building:
+
+```js
+cd js
+yarn
+yarn run webpack
+```
+
+Js api is in `js/dist/sockdriveFat.js`. The api is node-like fs api.
+
+Testing:
+
+1. Serve dist folder
+2. Open test.html in browser to run tests.
+
+# emscripten asyncify

package/src/sockdrive/SDL2/LRUCache11.hpp

@@ -0,0 +1,240 @@
+/*
+ * LRUCache11 - a templated C++11 based LRU cache class that allows
+ * specification of
+ * key, value and optionally the map container type (defaults to
+ * std::unordered_map)
+ * By using the std::unordered_map and a linked list of keys it allows O(1) insert, delete
+ * and
+ * refresh operations.
+ *
+ * This is a header-only library and all you need is the LRUCache11.hpp file
+ *
+ * Github: https://github.com/mohaps/lrucache11
+ *
+ * This is a follow-up to the LRUCache project -
+ * https://github.com/mohaps/lrucache
+ *
+ * Copyright (c) 2012-22 SAURAV MOHAPATRA <mohaps@gmail.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+#pragma once
+#include <algorithm>
+#include <cstdint>
+#include <list>
+#include <mutex>
+#include <stdexcept>
+#include <thread>
+#include <unordered_map>
+
+namespace lru11 {
+/*
+ * a noop lockable concept that can be used in place of std::mutex
+ */
+class NullLock {
+ public:
+  void lock() {}
+  void unlock() {}
+  bool try_lock() { return true; }
+};
+
+/**
+ * error raised when a key not in cache is passed to get()
+ */
+class KeyNotFound : public std::invalid_argument {
+ public:
+  KeyNotFound() : std::invalid_argument("key_not_found") {}
+};
+
+template <typename K, typename V>
+struct KeyValuePair {
+ public:
+  K key;
+  V value;
+
+  KeyValuePair(K k, V v) : key(std::move(k)), value(std::move(v)) {}
+};
+
+/**
+ *	The LRU Cache class templated by
+ *		Key - key type
+ *		Value - value type
+ *		MapType - an associative container like std::unordered_map
+ *		LockType - a lock type derived from the Lock class (default:
+ *NullLock = no synchronization)
+ *
+ *	The default NullLock based template is not thread-safe, however passing
+ *Lock=std::mutex will make it
+ *	thread-safe
+ */
+template <class Key, class Value, class Lock = NullLock,
+          class Map = std::unordered_map<
+              Key, typename std::list<KeyValuePair<Key, Value>>::iterator>>
+class Cache {
+ public:
+  typedef KeyValuePair<Key, Value> node_type;
+  typedef std::list<KeyValuePair<Key, Value>> list_type;
+  typedef Map map_type;
+  typedef Lock lock_type;
+  using Guard = std::lock_guard<lock_type>;
+  /**
+   * the maxSize is the soft limit of keys and (maxSize + elasticity) is the
+   * hard limit
+   * the cache is allowed to grow till (maxSize + elasticity) and is pruned back
+   * to maxSize keys
+   * set maxSize = 0 for an unbounded cache (but in that case, you're better off
+   * using a std::unordered_map
+   * directly anyway! :)
+   */
+  explicit Cache(size_t maxSize = 64, size_t elasticity = 10)
+      : maxSize_(maxSize), elasticity_(elasticity) {}
+  virtual ~Cache() = default;
+  size_t size() const {
+    Guard g(lock_);
+    return cache_.size();
+  }
+  bool empty() const {
+    Guard g(lock_);
+    return cache_.empty();
+  }
+  void clear() {
+    Guard g(lock_);
+    cache_.clear();
+    keys_.clear();
+  }
+  void insert(const Key& k, uint8_t* ptr) {
+    Guard g(lock_);
+    const auto iter = cache_.find(k);
+    if (iter != cache_.end()) {
+      iter->second->value.reset(ptr);
+      keys_.splice(keys_.begin(), keys_, iter->second);
+      return;
+    }
+
+    keys_.emplace_front(k, std::unique_ptr<uint8_t>(ptr));
+    cache_[k] = keys_.begin();
+    prune();
+  }
+  /**
+    for backward compatibity. redirects to tryGetCopy()
+   */
+  bool tryGet(const Key& kIn, Value& vOut) {
+    return tryGetCopy(kIn, vOut);
+  }
+
+  bool tryGetCopy(const Key& kIn, Value& vOut) {
+    Guard g(lock_);
+    Value tmp;
+    if (!tryGetRef_nolock(kIn, tmp)) { return false; }
+    vOut = tmp;
+    return true;
+  }
+  
+  bool tryGetRef(const Key& kIn, Value& vOut) {
+    Guard g(lock_);
+    return tryGetRef_nolock(kIn, vOut);
+  }
+  /**
+   *	The const reference returned here is only
+   *    guaranteed to be valid till the next insert/delete
+   *  in multi-threaded apps use getCopy() to be threadsafe
+   */
+  const Value& getRef(const Key& k) {
+    Guard g(lock_);
+    return get_nolock(k);
+  }
+
+  /**
+      added for backward compatibility
+   */
+  Value get(const Key& k) {
+    return getCopy();
+  }
+  /**
+   * returns a copy of the stored object (if found)
+   * safe to use/recommended in multi-threaded apps
+   */
+  Value getCopy(const Key& k) {
+    Guard g(lock_);
+    return get_nolock(k);
+  }
+
+  bool remove(const Key& k) {
+    Guard g(lock_);
+    auto iter = cache_.find(k);
+    if (iter == cache_.end()) {
+      return false;
+    }
+    keys_.erase(iter->second);
+    cache_.erase(iter);
+    return true;
+  }
+  bool contains(const Key& k) const {
+    Guard g(lock_);
+    return cache_.find(k) != cache_.end();
+  }
+
+  size_t getMaxSize() const { return maxSize_; }
+  size_t getElasticity() const { return elasticity_; }
+  size_t getMaxAllowedSize() const { return maxSize_ + elasticity_; }
+  template <typename F>
+  void cwalk(F& f) const {
+    Guard g(lock_);
+    std::for_each(keys_.begin(), keys_.end(), f);
+  }
+
+ protected:
+  const Value& get_nolock(const Key& k) {
+    const auto iter = cache_.find(k);
+    if (iter == cache_.end()) {
+        abort();
+    }
+    keys_.splice(keys_.begin(), keys_, iter->second);
+    return iter->second->value;
+  }
+  bool tryGetRef_nolock(const Key& kIn, Value& vOut) {
+    const auto iter = cache_.find(kIn);
+    if (iter == cache_.end()) {
+      return false;
+    }
+    keys_.splice(keys_.begin(), keys_, iter->second);
+    vOut = iter->second->value;
+    return true;
+  }
+  size_t prune() {
+    size_t maxAllowed = maxSize_ + elasticity_;
+    if (maxSize_ == 0 || cache_.size() < maxAllowed) {
+      return 0;
+    }
+    size_t count = 0;
+    while (cache_.size() > maxSize_) {
+      cache_.erase(keys_.back().key);
+      keys_.pop_back();
+      ++count;
+    }
+    return count;
+  }
+
+ private:
+  // Disallow copying.
+  Cache(const Cache&) = delete;
+  Cache& operator=(const Cache&) = delete;
+
+  mutable Lock lock_;
+  Map cache_;
+  list_type keys_;
+  size_t maxSize_;
+  size_t elasticity_;
+};
+
+}  // namespace LRUCache11

package/src/sockdrive/SDL2/sockdrive.cpp

@@ -0,0 +1,207 @@
+#include <cstdint>
+#include <cassert>
+#include <unordered_map>
+#include "LRUCache11.hpp"
+
+#include "../include/sockdrive.h"
+#include "../lz4/lz4.h"
+#include "SDL_net.h"
+
+namespace {
+    int SDLNet_TCP_Recv_All(TCPsocket sock, void *data, int maxlen) {
+        auto *start = (uint8_t *) data;
+        auto restlen = maxlen;
+        while (restlen > 0) {
+            auto read = SDLNet_TCP_Recv(sock, start, maxlen);
+            start += read;
+            restlen -= read;
+            // TODO: add sleep
+        }
+        return maxlen;
+    }
+
+    int decode_lz4_block(uint32_t compressedSize, uint32_t decodedSize, char *buffer) {
+        if (compressedSize == decodedSize) {
+            return decodedSize;
+        }
+
+        // 128 * 1024 is for 255 aheadRange (maximum possible)
+        constexpr int compressedBuffer = 128 * 1024;
+        static char compressed[compressedBuffer];
+
+        if (compressedBuffer < compressedSize) {
+            return -1;
+        }
+
+        memcpy(compressed, buffer, compressedSize);
+        auto result = LZ4_decompress_safe(compressed, buffer, compressedSize, decodedSize);
+        return result;
+    }
+
+    class BlockCache {
+        const uint32_t sectorSize;
+        const uint8_t aheadRange;
+        lru11::Cache<uint32_t, std::unique_ptr<uint8_t>> lru;
+
+    public:
+        BlockCache(uint32_t sectorSize, uint8_t aheadRange, uint32_t memoryLimit) :
+                sectorSize(sectorSize), aheadRange(aheadRange), lru(memoryLimit / (aheadRange * sectorSize), 0) {
+        }
+
+        uint8_t *read(uint32_t sector) {
+            const auto origin = getOrigin(sector);
+            if (lru.contains(origin)) {
+                return lru.getRef(origin).get() + (sector - origin) * sectorSize;
+            }
+            return nullptr;
+        }
+
+        bool write(uint32_t sector, uint8_t *buffer) {
+            const auto origin = getOrigin(sector);
+            if (lru.contains(origin)) {
+                memcpy(lru.getRef(origin).get() + (sector - origin) * sectorSize, buffer, sectorSize);
+                return true;
+            }
+            return false;
+        }
+
+        void create(uint32_t origin, uint8_t *buffer) {
+            if (lru.contains(origin)) {
+                memcpy(lru.getRef(origin).get(), buffer, sectorSize * aheadRange);
+            } else {
+                auto copy = new uint8_t[sectorSize * aheadRange];
+                memcpy(copy, buffer, sectorSize * aheadRange);
+                lru.insert(origin, copy);
+            }
+        }
+
+        uint32_t getOrigin(uint32_t sector) const {
+            return sector - sector % aheadRange;
+        }
+
+    };
+
+    class Drive {
+        const uint32_t sectorSize = 512;
+
+        TCPsocket socket;
+        const uint8_t aheadRange;
+        uint8_t *readAheadBuffer;
+        uint32_t aheadSize;
+
+        BlockCache cache;
+
+    public:
+        Drive(TCPsocket socket, uint8_t aheadRange = 255, uint32_t memoryLimit = 32 * 1024 * 1024) :
+                socket(socket), aheadRange(aheadRange), cache(sectorSize, aheadRange, memoryLimit) {
+
+            aheadSize = sectorSize * aheadRange;
+            readAheadBuffer = new uint8_t[aheadSize];
+        }
+
+        ~Drive() {
+            SDLNet_TCP_Close(socket);
+            delete[] readAheadBuffer;
+        }
+
+        uint8_t read(uint32_t sector, uint8_t *buffer) {
+            auto cached = cache.read(sector);
+            if (cached) {
+                memcpy(buffer, cached, sectorSize);
+                return 0;
+            }
+
+            static const uint8_t readCommand = 1;
+            if (SDLNet_TCP_Send(socket, &readCommand, sizeof(uint8_t)) != sizeof(uint8_t)) {
+                return 2;
+            }
+            auto origin = cache.getOrigin(sector);
+            if (SDLNet_TCP_Send(socket, &origin, sizeof(uint32_t)) != sizeof(uint32_t)) {
+                return 3;
+            }
+            if (SDLNet_TCP_Send(socket, &aheadRange, sizeof(uint8_t)) != sizeof(uint8_t)) {
+                return 4;
+            }
+            if (SDLNet_TCP_Recv_All(socket, readAheadBuffer, sizeof(uint32_t)) != sizeof(uint32_t)) {
+                return 5;
+            }
+            uint32_t compressedSize = readAheadBuffer[0] + (readAheadBuffer[1] << 8) + (readAheadBuffer[2] << 16) + (readAheadBuffer[3] << 24);
+            if (SDLNet_TCP_Recv_All(socket, readAheadBuffer, compressedSize) != compressedSize) {
+                return 6;
+            }
+
+            int decodeResult = decode_lz4_block(compressedSize, aheadSize, (char *) readAheadBuffer);
+            if (decodeResult != aheadSize) {
+                return decodeResult;
+            }
+
+            cache.create(origin, readAheadBuffer);
+            memcpy(buffer, readAheadBuffer + (sector - origin) * sectorSize, sectorSize);
+
+            return 0;
+        }
+
+        uint8_t write(uint32_t sector, uint8_t *buffer) {
+            cache.write(sector, buffer);
+            static const uint8_t writeCommand = 2;
+            if (SDLNet_TCP_Send(socket, &writeCommand, sizeof(uint8_t)) != sizeof(uint8_t)) {
+                return 2;
+            }
+            if (SDLNet_TCP_Send(socket, &sector, sizeof(uint32_t)) != sizeof(uint32_t)) {
+                return 3;
+            }
+            if (SDLNet_TCP_Send(socket, buffer, sectorSize) != sectorSize) {
+                return 4;
+            }
+            return 0;
+        }
+    };
+
+}
+
+size_t sockdrive_open(const char* url, const char* owner, const char* name, const char* token) {
+    IPaddress address;
+    if (SDLNet_ResolveHost(&address, url, 8001) == 0) {
+        return reinterpret_cast<size_t>(new Drive(SDLNet_TCP_Open(&address)));
+    }
+
+    return 0;
+}
+
+uint8_t sockdrive_read(size_t handle, uint32_t sector, uint8_t *buffer) {
+    if (!handle) {
+        return 1;
+    }
+
+    return reinterpret_cast<Drive*>(handle)->read(sector, buffer);
+}
+
+uint8_t sockdrive_write(size_t handle, uint32_t sector, uint8_t *buffer) {
+    if (!handle) {
+        return 1;
+    }
+
+    return reinterpret_cast<Drive*>(handle)->write(sector, buffer);
+}
+
+void sockdrive_close(size_t handle) {
+    if (handle) {
+        delete reinterpret_cast<Drive*>(handle);
+    }
+}
+
+uint32_t sockdrive_size(size_t handle) {
+    return 2097152;
+}
+uint32_t sockdrive_heads(size_t handle) {
+    return 128;
+}
+uint32_t sockdrive_sectors(size_t handle) {
+    return 63;
+}
+uint32_t sockdrive_cylinders(size_t handle) {
+    return 520;
+}
+uint32_t sockdrive_sector_size(size_t handle) {
+    return 512;
+}

package/src/sockdrive/include/sockdrive.h

@@ -0,0 +1,23 @@
+//
+// Created by caiii on 30.08.2023.
+//
+
+#ifndef JS_DOS_SOCKDRIVE_H
+#define JS_DOS_SOCKDRIVE_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+extern "C" {
+    size_t sockdrive_open(const char* url, const char* owner, const char* name, const char* token);
+    uint8_t sockdrive_read(size_t handle, uint32_t sector, uint8_t * buffer);
+    uint8_t sockdrive_write(size_t handle, uint32_t sector, uint8_t* buffer);
+    uint32_t sockdrive_size(size_t handle);
+    uint32_t sockdrive_heads(size_t handle);
+    uint32_t sockdrive_sectors(size_t handle);
+    uint32_t sockdrive_cylinders(size_t handle);
+    uint32_t sockdrive_sector_size(size_t handle);
+    void sockdrive_close(size_t handle);
+}
+
+#endif //JS_DOS_SOCKDRIVE_H

package/src/sockdrive/js/.eslintrc.json

@@ -0,0 +1,43 @@
+{
+    "env": {
+        "browser": true,
+        "es2021": true
+    },
+    "extends": [
+        "google"
+    ],
+    "parser": "@typescript-eslint/parser",
+    "parserOptions": {
+        "ecmaVersion": 12,
+        "sourceType": "module"
+    },
+    "plugins": [
+        "@typescript-eslint"
+    ],
+    "rules": {
+        "object-curly-spacing": [
+            "error",
+            "always"
+        ],
+        "require-jsdoc": "off",
+        "quotes": [
+            "error",
+            "double"
+        ],
+        "indent": [
+            "error",
+            4,
+            {
+                "SwitchCase": 1,
+                "FunctionDeclaration": {
+                    "parameters": "first"
+                }
+            }
+        ],
+        "max-len": [
+            "error",
+            120
+        ]
+    },
+    "ignorePatterns": ["dist/**/*"]
+}

package/src/sockdrive/js/README.md

@@ -0,0 +1,70 @@
+# ffi library for browser
+
+## Building
+
+Compile it with yarn & webpack:
+
+```
+yarn
+yarn run webpack
+```
+
+You can test by opening dist/test.html, but run dist/test/make-img-linux.sh first.
+
+Types information can be found in src/sockdrive-fat.d.ts
+
+# 3rdparty code
+
+## LZ4
+
+```
+/*
+MiniLZ4: Minimal LZ4 block decoding and encoding.
+
+based off of node-lz4, https://github.com/pierrec/node-lz4
+
+====
+Copyright (c) 2012 Pierre Curto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+====
+
+changes have the same license
+```
+
+## LRU cache
+
+`src/sockdrive/lru.js` is from https://github.com/rsms/js-lru
+Licensed under MIT. Copyright (c) 2010 Rasmus Andersson <http://hunch.se/>
+
+## fatfs (fork)
+
+`src/fatfs` is a fork of https://github.com/natevw/fatfs
+
+License information:
+
+```
+© 2014 Nathan Vander Wilt.
+Funding for this work was provided by Technical Machine, Inc.
+
+Reuse under your choice of:
+
+* BSD-2-Clause
+* Apache 2.0
+```

package/src/sockdrive/js/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "sockdrive-asyncify",
+  "version": "1.0.0",
+  "description": "The sockdrive support for emscripten",
+  "license": "GPLv3",
+  "private": true,
+  "dependencies": {
+    "buffer": "^6.0.3",
+    "fifolock": "^1.0.0",
+    "stream-browserify": "^3.0.0",
+    "struct-fu": "^1.2.1",
+    "typedarray-to-buffer": "^4.0.0",
+    "xok": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.3.6",
+    "@types/mocha": "^10.0.1",
+    "@typescript-eslint/eslint-plugin": "^6.7.2",
+    "@typescript-eslint/parser": "^6.7.2",
+    "eslint": "^8.48.0",
+    "eslint-config-google": "^0.14.0",
+    "eslint-webpack-plugin": "^4.0.1",
+    "process": "^0.11.10",
+    "ts-loader": "^9.4.4",
+    "typescript": "^5.2.2",
+    "webpack": "^5.88.2",
+    "webpack-cli": "^5.1.4"
+  }
+}