js-dos 7.4.9 → 8.1.0

package/src/sockdrive/js/src/fatfs/structs.js

@@ -0,0 +1,255 @@
+// see http://staff.washington.edu/dittrich/misc/fatgen103.pdf
+// and http://www.cse.scu.edu/~tschwarz/COEN252_09/Lectures/FAT.html
+
+const _ = require("struct-fu");
+const __ = require("./helpers.js");
+
+const bootBase = _.struct([
+    _.byte("jmpBoot", 3),
+    _.char("OEMName", 8),
+    _.uint16le("BytsPerSec"),
+    _.uint8("SecPerClus"),
+    _.uint16le("ResvdSecCnt"), // Rsvd in table, but Resvd in calcs…
+    _.uint8("NumFATs"),
+    _.uint16le("RootEntCnt"),
+    _.uint16le("TotSec16"),
+    _.uint8("Media"),
+    _.uint16le("FATSz16"),
+    _.uint16le("SecPerTrk"),
+    _.uint16le("NumHeads"),
+    _.uint32le("HiddSec"),
+    _.uint32le("TotSec32"),
+]);
+
+const bootInfo = _.struct([
+    _.uint8("DrvNum"),
+    _.uint8("Reserved1"),
+    _.uint8("BootSig"),
+    _.uint32le("VolID"),
+    _.char("VolLab", 11),
+    _.char("FilSysType", 8),
+]);
+
+exports.boot16 = _.struct([
+    bootBase,
+    bootInfo,
+]);
+
+exports.boot32 = _.struct([
+    bootBase,
+    _.uint32le("FATSz32"),
+    _.struct("ExtFlags", [
+        _.ubit("NumActiveFAT", 4),
+        _.ubit("_reserved1", 3),
+        _.bool("MirroredFAT"),
+        _.ubit("_reserved2", 8),
+    ].reverse()),
+    _.struct("FSVer", [
+        _.uint8("Major"),
+        _.uint8("Minor"),
+    ]),
+    _.uint32le("RootClus"),
+    _.uint16le("FSInfo"),
+    _.uint16le("BkBootSec"),
+    _.byte("Reserved", 12),
+    bootInfo,
+]);
+
+
+const _time = _.struct([
+    _.ubit("hours", 5),
+    _.ubit("minutes", 6),
+    _.ubit("seconds_2", 5),
+]); const time = {
+    valueFromBytes: function(buf, off) {
+        off || (off = { bytes: 0 });
+
+        const _buf = __.bufferFrom([buf[off.bytes+1], buf[off.bytes+0]]);
+        const val = _time.valueFromBytes(_buf);
+        off.bytes += this.size;
+        return val;
+    },
+    bytesFromValue: function(val, buf, off) {
+        val || (val = { hours: 0, minutes: 0, seconds_2: 0 });
+        buf || (buf = __.allocBuffer(this.size));
+        off || (off = { bytes: 0 });
+
+        const _buf = _time.bytesFromValue(val);
+        buf[off.bytes+1] = _buf[0];
+        buf[off.bytes+0] = _buf[1];
+        off.bytes += this.size;
+        return buf;
+    },
+    size: _time.size,
+};
+
+const _date = _.struct([
+    _.ubit("year", 7),
+    _.ubit("month", 4),
+    _.ubit("day", 5),
+]); const date = {
+    valueFromBytes: function(buf, off) {
+        off || (off = { bytes: 0 });
+
+        const _buf = __.bufferFrom([buf[off.bytes+1], buf[off.bytes+0]]);
+        const val = _date.valueFromBytes(_buf);
+        off.bytes += this.size;
+        return val;
+    },
+    bytesFromValue: function(val, buf, off) {
+        val || (val = { year: 0, month: 0, day: 0 });
+        buf || (buf = __.allocBuffer(this.size));
+        off || (off = { bytes: 0 });
+
+        const _buf = _date.bytesFromValue(val);
+        buf[off.bytes+1] = _buf[0];
+        buf[off.bytes+0] = _buf[1];
+        off.bytes += this.size;
+        return buf;
+    },
+    size: _date.size,
+};
+
+exports.dirEntry = _.struct([
+    _.struct("Name", [
+        _.char("filename", 8),
+        _.char("extension", 3),
+    ]),
+    _.struct("Attr", [
+        _.bool("readonly"),
+        _.bool("hidden"),
+        _.bool("system"),
+        _.bool("volume_id"),
+        _.bool("directory"),
+        _.bool("archive"),
+        _.ubit("reserved", 2),
+    ].reverse()),
+    _.byte("NTRes", 1),
+    _.uint8("CrtTimeTenth"),
+    _.struct("CrtTime", [time]),
+    _.struct("CrtDate", [date]),
+    _.struct("LstAccDate", [date]),
+    _.uint16le("FstClusHI"),
+    _.struct("WrtTime", [time]),
+    _.struct("WrtDate", [date]),
+    _.uint16le("FstClusLO"),
+    _.uint32le("FileSize"),
+]);
+exports.entryDoneFlag = 0x00;
+exports.entryFreeFlag = 0xE5;
+exports.entryIsE5Flag = 0x05;
+
+exports.dirEntry_simple = _.struct([
+    _.struct("Name", [
+        _.char("filename", 8),
+        _.char("extension", 3),
+    ]),
+    _.padTo(exports.dirEntry.size),
+    /*
+    _.uint8('Attr_raw'),
+    _.byte('NTRes', 1),
+    _.byte('Crt_raw', 1+2+2),
+    _.byte('Lst_raw', 2),
+    _.uint16le('FstClusHI'),
+    _.byte('Wrt_raw', 2+2),
+    _.uint16le('FstClusLO'),
+    _.uint32le('FileSize')
+    */
+]);
+
+
+exports.lastLongFlag = 0x40;
+exports.longDirFlag = 0x0F;
+exports.longDirEntry = _.struct([
+    _.uint8("Ord"),
+    _.char16le("Name1", 10),
+    _.uint8("Attr_raw"),
+    _.uint8("Type"),
+    _.uint8("Chksum"),
+    _.char16le("Name2", 12),
+    _.uint16le("FstClusLO"),
+    _.char16le("Name3", 4),
+]);
+
+if (exports.longDirEntry.size !== exports.dirEntry.size) throw Error("Structs ain't right!");
+
+exports.fatField = {
+    "fat12": _.struct("Status", [
+        _.ubit("field0bc", 8),
+        _.ubit("field1c", 4),
+        _.ubit("field0a", 4),
+        _.ubit("field1ab", 8),
+    ]),
+    "fat16": _.uint16le("Status"),
+    "fat32": _.uint32le("Status"), // more properly this 4 bits reserved + uint28le
+};
+
+exports.fatPrefix = {
+    "fat12": 0xF00,
+    "fat16": 0xFF00,
+    "fat32": 0x0FFFFF00,
+};
+
+exports.fatStat = {
+    free: 0x00,
+    _undef: 0x01,
+    rsvMin: 0xF0,
+    bad: 0xF7,
+    eofMin: 0xF8,
+    eof: 0xFF,
+};
+
+exports._I = {
+    RUSR: 0o400,
+    WUSR: 0o200,
+    XUSR: 0o100,
+
+    RGRP: 0o040,
+    WGRP: 0o020,
+    XGRP: 0o010,
+
+    ROTH: 0o004,
+    WOTH: 0o002,
+    XOTH: 0o001,
+
+    SUID: 0o4000,
+    SGID: 0o2000,
+    SVTX: 0o1000,
+
+    FDIR: 0o40000,
+    FREG: 0o100000,
+};
+
+exports._I.RWXU = exports._I.RUSR | exports._I.WUSR | exports._I.XUSR;
+exports._I.RWXG = exports._I.RGRP | exports._I.WGRP | exports._I.XGRP;
+exports._I.RWXO = exports._I.ROTH | exports._I.WOTH | exports._I.XOTH;
+exports._I._sss = exports._I.SUID | exports._I.SGID | exports._I.SVTX;
+exports._I._chmoddable = exports._I.RWXU | exports._I.RWXG | exports._I.RWXO | exports._I._sss;
+
+const _errors = {
+    IO: "Input/output error",
+    NOENT: "No such file or directory",
+    INVAL: "Invalid argument",
+    EXIST: "File exists",
+    NAMETOOLONG: "Filename too long",
+    NOSPC: "No space left on device",
+    NOSYS: "Function not supported",
+    ROFS: "ROFLCopter file system",
+    NOTDIR: "Not a directory",
+    BADF: "Bad file descriptor",
+    EXIST: "File exists",
+    ISDIR: "Is a directory",
+    ACCES: "Permission denied",
+    NOSYS: "Function not implemented",
+    _TODO: "Not implemented yet!",
+};
+
+exports.err = {};
+Object.keys(_errors).forEach(function(sym) {
+    const msg = _errors[sym];
+    exports.err[sym] = function() {
+        const e = new Error(msg);
+        e.code = sym;
+        return e;
+    };
+});

package/src/sockdrive/js/src/fatfs/vol.js

@@ -0,0 +1,166 @@
+const S = require("./structs.js");
+const c = require("./chains.js");
+const _ = require("./helpers.js");
+
+exports.init = function(volume, opts, bootSector) {
+    if (bootSector[510] !== 0x55 || bootSector[511] !== 0xAA) throw Error("Invalid volume signature!");
+
+    const isFAT16 = bootSector.readUInt16LE(S.boot16.fields["FATSz16"].offset);
+    const bootStruct = (isFAT16) ? S.boot16 : S.boot32;
+    const BS = bootStruct.valueFromBytes(bootSector);
+    _.log(_.log.DBG, "Boot sector info:", BS);
+    bootSector = null; // allow GC
+    if (!BS.BytsPerSec) throw Error("This looks like an ExFAT volume! (unsupported)");
+    else if (BS.BytsPerSec !== volume.sectorSize) throw Error("Sector size mismatch with FAT table.");
+
+    const FATSz = (isFAT16) ? BS.FATSz16 : BS.FATSz32;
+    const rootDirSectors = Math.ceil((BS.RootEntCnt * 32) / BS.BytsPerSec);
+    const firstDataSector = BS.ResvdSecCnt + (BS.NumFATs * FATSz) + rootDirSectors;
+    const totSec = (BS.TotSec16) ? BS.TotSec16 : BS.TotSec32;
+    const dataSec = totSec - firstDataSector;
+    const countofClusters = Math.floor(dataSec / BS.SecPerClus);
+    // avoid corrupting sectors from other partitions or whatnot
+    if (totSec > volume.numSectors) throw Error("Volume size mismatch!");
+
+    let fatType;
+    if (countofClusters < 4085) {
+        fatType = "fat12";
+    } else if (countofClusters < 65525) {
+        fatType = "fat16";
+    } else {
+        fatType = "fat32";
+    }
+
+    _.log(_.log.DBG, "rootDirSectors", rootDirSectors, "firstDataSector", firstDataSector, "countofClusters", countofClusters, "=>", fatType);
+
+    const vol = {};
+
+    vol.opts = opts;
+
+    vol._sectorSize = BS.BytsPerSec;
+    vol._sectorsPerCluster = BS.SecPerClus;
+    vol._firstSectorOfCluster = function(n) {
+        return firstDataSector + (n-2)*vol._sectorsPerCluster;
+    };
+
+    vol._readSectors = function(secNum, dest, cb) {
+        if (typeof dest === "function") {
+            cb = dest;
+            dest = _.allocBuffer(vol._sectorSize);
+        }
+        _.log(_.log.DBG, "vol._readSectors", secNum, dest.length);
+        if (secNum < volume.numSectors) {
+            volume.readSectors(secNum, dest, function(e) {
+                cb(e, dest);
+            });
+        } else throw Error("Invalid sector number!");
+    };
+
+    vol._writeSectors = function(secNum, data, cb) {
+        _.log(_.log.DBG, "vol._writeSectors", secNum, data.length);
+        // NOTE: these are internal assertions, public API will get proper `S.err`s
+        if (data.length % volume.sectorSize) throw Error("Buffer length not a multiple of sector size");
+        else if (opts.ro) throw Error("Read-only filesystem");
+        else if (secNum < volume.numSectors) volume.writeSectors(secNum, data, cb);
+        else throw Error("Invalid sector number!");
+    };
+
+    function fatInfoForCluster(n) {
+        const entryStruct = S.fatField[fatType];
+        const FATOffset = (fatType === "fat12") ? Math.floor(n/2) * entryStruct.size : n * entryStruct.size;
+        const SecNum = BS.ResvdSecCnt + Math.floor(FATOffset / BS.BytsPerSec);
+        const EntOffset = FATOffset % BS.BytsPerSec;
+        return { sector: SecNum-BS.ResvdSecCnt, offset: EntOffset, struct: entryStruct };
+    }
+
+    // TODO: all this FAT manipulation is crazy inefficient! needs read caching *and* write caching
+    //        …the best place for cache might be in `volume` handler, though. add a `flush` method to that spec?
+    // TODO: how should we handle redundant FATs? mirror every write? just ignore completely? copy-on-eject?
+
+    const fatChain = c.sectorChain(vol, BS.ResvdSecCnt, FATSz);
+    fatChain.cacheAdvice = "RANDOM";
+
+    vol.fetchFromFAT = function(clusterNum, cb) {
+        const info = fatInfoForCluster(clusterNum);
+        fatChain.readFromPosition(info, info.struct.size, function(e, n, d) {
+            if (e) return cb(e);
+            let status = info.struct.valueFromBytes(d); var prefix;
+            if (fatType === "fat12") {
+                if (clusterNum % 2) {
+                    status = (status.field1ab << 4) + status.field1c;
+                } else {
+                    status = (status.field0a << 8) + status.field0bc;
+                }
+            } else if (fatType === "fat32") {
+                status &= 0x0FFFFFFF;
+            }
+
+            var prefix = S.fatPrefix[fatType];
+            if (status === S.fatStat.free) cb(null, "free");
+            else if (status === S.fatStat._undef) cb(null, "-invalid-");
+            else if (status > prefix+S.fatStat.eofMin) cb(null, "eof");
+            else if (status === prefix+S.fatStat.bad) cb(null, "bad");
+            else if (status > prefix+S.fatStat.rsvMin) cb(null, "reserved");
+            else cb(null, status);
+        });
+    };
+
+    vol.storeToFAT = function(clusterNum, status, cb) {
+        if (typeof status === "string") {
+            status = S.fatStat[status];
+            status += S.fatPrefix[fatType];
+        }
+        const info = fatInfoForCluster(clusterNum);
+        // TODO: technically fat32 needs to *preserve* the high 4 bits
+        if (fatType === "fat12") {
+            fatChain.readFromPosition(info, info.struct.size, function(e, n, d) {
+                const value = info.struct.valueFromBytes(d);
+                if (clusterNum % 2) {
+                    value.field1ab = status >>> 4;
+                    value.field1c = status & 0x0F;
+                } else {
+                    value.field0a = status >>> 8;
+                    value.field0bc = status & 0xFF;
+                }
+                const entry = info.struct.bytesFromValue(value);
+                fatChain.writeToPosition(info, entry, cb);
+            });
+        } else {
+            const entry = info.struct.bytesFromValue(status);
+            fatChain.writeToPosition(info, entry, cb);
+        }
+    };
+
+    vol.allocateInFAT = function(hint, cb) {
+        if (typeof hint === "function") {
+            cb = hint;
+            hint = 2; // TODO: cache a better starting point?
+        }
+        function searchForFreeCluster(num, cb) {
+            if (num < countofClusters) {
+                vol.fetchFromFAT(num, function(e, status) {
+                    if (e) cb(e);
+                    else if (status === "free") cb(null, num);
+                    else searchForFreeCluster(num+1, cb);
+                });
+            } else cb(S.err.NOSPC()); // TODO: try searching backwards from hint…
+        }
+        searchForFreeCluster(hint, function(e, clusterNum) {
+            if (e) cb(e);
+            else vol.storeToFAT(clusterNum, "eof", cb.bind(null, null, clusterNum));
+        });
+    };
+
+    vol.rootDirectoryChain = (isFAT16) ?
+        c.sectorChain(vol, firstDataSector - rootDirSectors, rootDirSectors) :
+        c.clusterChain(vol, BS.RootClus);
+    vol.rootDirectoryChain.cacheAdvice = "WILLNEED";
+    vol.chainForCluster = c.clusterChain.bind(c, vol);
+    vol.chainFromJSON = function(d) {
+        return ("numSectors" in d) ?
+            c.sectorChain(vol, d.firstSector, d.numSectors) :
+            c.clusterChain(vol, d.firstCluster);
+    };
+
+    return vol;
+};

package/src/sockdrive/js/src/sockdrive/cache.ts

@@ -0,0 +1,133 @@
+import { LRUMap } from "./lru";
+
+export interface Cache {
+    read(sector: number): Uint8Array | null;
+    write(sector: number, buffer: Uint8Array): boolean;
+    create(origin: number, buffer: Uint8Array): void;
+    getOrigin(sector: number): number;
+    memUsed(): number;
+}
+
+export class BlockCache implements Cache {
+    aheadRange: number;
+    sectorSize: number;
+    lru: LRUMap;
+
+    constructor(sectorSize: number, aheadRange: number, memoryLimit: number) {
+        this.aheadRange = aheadRange;
+        this.sectorSize = sectorSize;
+        this.lru = new LRUMap(Math.floor(memoryLimit / (aheadRange * sectorSize)));
+    }
+
+    public read(sector: number): Uint8Array | null {
+        const origin = this.getOrigin(sector);
+        const cached = this.lru.get(origin) as Uint8Array;
+        if (cached) {
+            const offset = sector - origin;
+            return cached.slice(offset * this.sectorSize, (offset + 1) * this.sectorSize);
+        }
+        return null;
+    }
+
+    public write(sector: number, buffer: Uint8Array) {
+        const origin = this.getOrigin(sector);
+        const cached = this.lru.get(origin);
+        if (cached) {
+            cached.set(buffer, (sector - origin) * this.sectorSize);
+        }
+        return cached !== undefined;
+    }
+
+    public create(origin: number, buffer: Uint8Array) {
+        this.lru.set(origin, buffer.slice(0));
+    }
+
+    public getOrigin(sector: number) {
+        return sector - sector % this.aheadRange;
+    }
+
+    public memUsed() {
+        return this.lru.size * this.aheadRange * this.sectorSize;
+    }
+}
+
+export class SimpleCache implements Cache {
+    aheadRange: number;
+    sectorSize: number;
+    lru: LRUMap;
+
+    constructor(sectorSize: number, aheadRange: number, memoryLimit: number) {
+        this.aheadRange = aheadRange;
+        this.sectorSize = sectorSize;
+        this.lru = new LRUMap(Math.floor(memoryLimit / sectorSize));
+    }
+
+    public read(sector: number): Uint8Array | null {
+        const cached = this.lru.get(sector) as Uint8Array;
+        if (cached) {
+            return cached;
+        }
+        return null;
+    }
+
+    public write(sector: number, buffer: Uint8Array) {
+        this.lru.set(sector, buffer);
+        return true;
+    }
+
+    public create(sector: number, buffer: Uint8Array) {
+        for (let i = 0; i < this.aheadRange; ++i) {
+            this.lru.set(sector + i, buffer.slice(i * this.sectorSize, (i + 1) * this.sectorSize));
+        }
+    }
+
+    public getOrigin(sector: number) {
+        return sector;
+    }
+
+    public memUsed() {
+        return this.lru.size * this.sectorSize;
+    }
+}
+
+export class BlockAndWriteCache implements Cache {
+    aheadRange: number;
+    sectorSize: number;
+    blockCache: BlockCache;
+    writeCache: SimpleCache;
+
+    constructor(sectorSize: number, aheadRange: number, memoryLimit: number) {
+        this.aheadRange = aheadRange;
+        this.sectorSize = sectorSize;
+        this.blockCache = new BlockCache(sectorSize, aheadRange, memoryLimit);
+        this.writeCache = new SimpleCache(sectorSize, aheadRange, Math.floor(memoryLimit / 10));
+    }
+
+    read(sector: number) {
+        return this.blockCache.read(sector) || this.writeCache.read(sector);
+    }
+
+    write(sector: number, buffer: Uint8Array) {
+        if (!this.blockCache.write(sector, buffer)) {
+            this.writeCache.write(sector, buffer);
+        }
+        return true;
+    }
+
+    create(origin: number, buffer: Uint8Array): void {
+        this.blockCache.create(origin, buffer);
+        for (let i = 0; i < this.aheadRange; ++i) {
+            if (this.writeCache.read(origin + i) != null) {
+                this.writeCache.write(origin + i, buffer.slice(i * this.sectorSize, (i + 1) * this.sectorSize));
+            }
+        }
+    }
+
+    getOrigin(sector: number): number {
+        return this.blockCache.getOrigin(sector);
+    }
+
+    memUsed(): number {
+        return this.blockCache.memUsed() + this.writeCache.memUsed();
+    }
+}