js-dos 8.1.5 → 8.1.6

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

@@ -1,255 +0,0 @@
-// 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

@@ -1,166 +0,0 @@
-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

@@ -1,56 +0,0 @@
-import { LRUMap } from "./lru";
-
-export interface Cache {
-    read(sector: number, originReadMode: boolean): 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, originReadMode: boolean): Uint8Array | null {
-        const origin = this.getOrigin(sector);
-        const cached = this.lru.get(origin) as Uint8Array;
-        if (cached) {
-            if (originReadMode) {
-                return cached;
-            } else {
-                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;
-    }
-}