mirror of
https://github.com/advplyr/audiobookshelf.git
synced 2025-10-29 17:52:24 -04:00
1210 lines
34 KiB
JavaScript
1210 lines
34 KiB
JavaScript
/**
|
|
* @license node-stream-zip | (c) 2020 Antelle | https://github.com/antelle/node-stream-zip/blob/master/LICENSE
|
|
* Portions copyright https://github.com/cthackers/adm-zip | https://raw.githubusercontent.com/cthackers/adm-zip/master/LICENSE
|
|
*/
|
|
|
|
let fs = require('fs');
|
|
const util = require('util');
|
|
const path = require('path');
|
|
const events = require('events');
|
|
const zlib = require('zlib');
|
|
const stream = require('stream');
|
|
|
|
const consts = {
|
|
/* The local file header */
|
|
LOCHDR: 30, // LOC header size
|
|
LOCSIG: 0x04034b50, // "PK\003\004"
|
|
LOCVER: 4, // version needed to extract
|
|
LOCFLG: 6, // general purpose bit flag
|
|
LOCHOW: 8, // compression method
|
|
LOCTIM: 10, // modification time (2 bytes time, 2 bytes date)
|
|
LOCCRC: 14, // uncompressed file crc-32 value
|
|
LOCSIZ: 18, // compressed size
|
|
LOCLEN: 22, // uncompressed size
|
|
LOCNAM: 26, // filename length
|
|
LOCEXT: 28, // extra field length
|
|
|
|
/* The Data descriptor */
|
|
EXTSIG: 0x08074b50, // "PK\007\008"
|
|
EXTHDR: 16, // EXT header size
|
|
EXTCRC: 4, // uncompressed file crc-32 value
|
|
EXTSIZ: 8, // compressed size
|
|
EXTLEN: 12, // uncompressed size
|
|
|
|
/* The central directory file header */
|
|
CENHDR: 46, // CEN header size
|
|
CENSIG: 0x02014b50, // "PK\001\002"
|
|
CENVEM: 4, // version made by
|
|
CENVER: 6, // version needed to extract
|
|
CENFLG: 8, // encrypt, decrypt flags
|
|
CENHOW: 10, // compression method
|
|
CENTIM: 12, // modification time (2 bytes time, 2 bytes date)
|
|
CENCRC: 16, // uncompressed file crc-32 value
|
|
CENSIZ: 20, // compressed size
|
|
CENLEN: 24, // uncompressed size
|
|
CENNAM: 28, // filename length
|
|
CENEXT: 30, // extra field length
|
|
CENCOM: 32, // file comment length
|
|
CENDSK: 34, // volume number start
|
|
CENATT: 36, // internal file attributes
|
|
CENATX: 38, // external file attributes (host system dependent)
|
|
CENOFF: 42, // LOC header offset
|
|
|
|
/* The entries in the end of central directory */
|
|
ENDHDR: 22, // END header size
|
|
ENDSIG: 0x06054b50, // "PK\005\006"
|
|
ENDSIGFIRST: 0x50,
|
|
ENDSUB: 8, // number of entries on this disk
|
|
ENDTOT: 10, // total number of entries
|
|
ENDSIZ: 12, // central directory size in bytes
|
|
ENDOFF: 16, // offset of first CEN header
|
|
ENDCOM: 20, // zip file comment length
|
|
MAXFILECOMMENT: 0xffff,
|
|
|
|
/* The entries in the end of ZIP64 central directory locator */
|
|
ENDL64HDR: 20, // ZIP64 end of central directory locator header size
|
|
ENDL64SIG: 0x07064b50, // ZIP64 end of central directory locator signature
|
|
ENDL64SIGFIRST: 0x50,
|
|
ENDL64OFS: 8, // ZIP64 end of central directory offset
|
|
|
|
/* The entries in the end of ZIP64 central directory */
|
|
END64HDR: 56, // ZIP64 end of central directory header size
|
|
END64SIG: 0x06064b50, // ZIP64 end of central directory signature
|
|
END64SIGFIRST: 0x50,
|
|
END64SUB: 24, // number of entries on this disk
|
|
END64TOT: 32, // total number of entries
|
|
END64SIZ: 40,
|
|
END64OFF: 48,
|
|
|
|
/* Compression methods */
|
|
STORED: 0, // no compression
|
|
SHRUNK: 1, // shrunk
|
|
REDUCED1: 2, // reduced with compression factor 1
|
|
REDUCED2: 3, // reduced with compression factor 2
|
|
REDUCED3: 4, // reduced with compression factor 3
|
|
REDUCED4: 5, // reduced with compression factor 4
|
|
IMPLODED: 6, // imploded
|
|
// 7 reserved
|
|
DEFLATED: 8, // deflated
|
|
ENHANCED_DEFLATED: 9, // deflate64
|
|
PKWARE: 10, // PKWare DCL imploded
|
|
// 11 reserved
|
|
BZIP2: 12, // compressed using BZIP2
|
|
// 13 reserved
|
|
LZMA: 14, // LZMA
|
|
// 15-17 reserved
|
|
IBM_TERSE: 18, // compressed using IBM TERSE
|
|
IBM_LZ77: 19, //IBM LZ77 z
|
|
|
|
/* General purpose bit flag */
|
|
FLG_ENC: 0, // encrypted file
|
|
FLG_COMP1: 1, // compression option
|
|
FLG_COMP2: 2, // compression option
|
|
FLG_DESC: 4, // data descriptor
|
|
FLG_ENH: 8, // enhanced deflation
|
|
FLG_STR: 16, // strong encryption
|
|
FLG_LNG: 1024, // language encoding
|
|
FLG_MSK: 4096, // mask header values
|
|
FLG_ENTRY_ENC: 1,
|
|
|
|
/* 4.5 Extensible data fields */
|
|
EF_ID: 0,
|
|
EF_SIZE: 2,
|
|
|
|
/* Header IDs */
|
|
ID_ZIP64: 0x0001,
|
|
ID_AVINFO: 0x0007,
|
|
ID_PFS: 0x0008,
|
|
ID_OS2: 0x0009,
|
|
ID_NTFS: 0x000a,
|
|
ID_OPENVMS: 0x000c,
|
|
ID_UNIX: 0x000d,
|
|
ID_FORK: 0x000e,
|
|
ID_PATCH: 0x000f,
|
|
ID_X509_PKCS7: 0x0014,
|
|
ID_X509_CERTID_F: 0x0015,
|
|
ID_X509_CERTID_C: 0x0016,
|
|
ID_STRONGENC: 0x0017,
|
|
ID_RECORD_MGT: 0x0018,
|
|
ID_X509_PKCS7_RL: 0x0019,
|
|
ID_IBM1: 0x0065,
|
|
ID_IBM2: 0x0066,
|
|
ID_POSZIP: 0x4690,
|
|
|
|
EF_ZIP64_OR_32: 0xffffffff,
|
|
EF_ZIP64_OR_16: 0xffff,
|
|
};
|
|
|
|
const StreamZip = function (config) {
|
|
let fd, fileSize, chunkSize, op, centralDirectory, closed;
|
|
const ready = false,
|
|
that = this,
|
|
entries = config.storeEntries !== false ? {} : null,
|
|
fileName = config.file,
|
|
textDecoder = config.nameEncoding ? new TextDecoder(config.nameEncoding) : null;
|
|
|
|
open();
|
|
|
|
function open() {
|
|
if (config.fd) {
|
|
fd = config.fd;
|
|
readFile();
|
|
} else {
|
|
fs.open(fileName, 'r', (err, f) => {
|
|
if (err) {
|
|
return that.emit('error', err);
|
|
}
|
|
fd = f;
|
|
readFile();
|
|
});
|
|
}
|
|
}
|
|
|
|
function readFile() {
|
|
fs.fstat(fd, (err, stat) => {
|
|
if (err) {
|
|
return that.emit('error', err);
|
|
}
|
|
fileSize = stat.size;
|
|
chunkSize = config.chunkSize || Math.round(fileSize / 1000);
|
|
chunkSize = Math.max(
|
|
Math.min(chunkSize, Math.min(128 * 1024, fileSize)),
|
|
Math.min(1024, fileSize)
|
|
);
|
|
readCentralDirectory();
|
|
});
|
|
}
|
|
|
|
function readUntilFoundCallback(err, bytesRead) {
|
|
if (err || !bytesRead) {
|
|
return that.emit('error', err || new Error('Archive read error'));
|
|
}
|
|
let pos = op.lastPos;
|
|
let bufferPosition = pos - op.win.position;
|
|
const buffer = op.win.buffer;
|
|
const minPos = op.minPos;
|
|
while (--pos >= minPos && --bufferPosition >= 0) {
|
|
if (buffer.length - bufferPosition >= 4 && buffer[bufferPosition] === op.firstByte) {
|
|
// quick check first signature byte
|
|
if (buffer.readUInt32LE(bufferPosition) === op.sig) {
|
|
op.lastBufferPosition = bufferPosition;
|
|
op.lastBytesRead = bytesRead;
|
|
op.complete();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if (pos === minPos) {
|
|
return that.emit('error', new Error('Bad archive'));
|
|
}
|
|
op.lastPos = pos + 1;
|
|
op.chunkSize *= 2;
|
|
if (pos <= minPos) {
|
|
return that.emit('error', new Error('Bad archive'));
|
|
}
|
|
const expandLength = Math.min(op.chunkSize, pos - minPos);
|
|
op.win.expandLeft(expandLength, readUntilFoundCallback);
|
|
}
|
|
|
|
function readCentralDirectory() {
|
|
const totalReadLength = Math.min(consts.ENDHDR + consts.MAXFILECOMMENT, fileSize);
|
|
op = {
|
|
win: new FileWindowBuffer(fd),
|
|
totalReadLength,
|
|
minPos: fileSize - totalReadLength,
|
|
lastPos: fileSize,
|
|
chunkSize: Math.min(1024, chunkSize),
|
|
firstByte: consts.ENDSIGFIRST,
|
|
sig: consts.ENDSIG,
|
|
complete: readCentralDirectoryComplete,
|
|
};
|
|
op.win.read(fileSize - op.chunkSize, op.chunkSize, readUntilFoundCallback);
|
|
}
|
|
|
|
function readCentralDirectoryComplete() {
|
|
const buffer = op.win.buffer;
|
|
const pos = op.lastBufferPosition;
|
|
try {
|
|
centralDirectory = new CentralDirectoryHeader();
|
|
centralDirectory.read(buffer.slice(pos, pos + consts.ENDHDR));
|
|
centralDirectory.headerOffset = op.win.position + pos;
|
|
if (centralDirectory.commentLength) {
|
|
that.comment = buffer
|
|
.slice(
|
|
pos + consts.ENDHDR,
|
|
pos + consts.ENDHDR + centralDirectory.commentLength
|
|
)
|
|
.toString();
|
|
} else {
|
|
that.comment = null;
|
|
}
|
|
that.entriesCount = centralDirectory.volumeEntries;
|
|
that.centralDirectory = centralDirectory;
|
|
if (
|
|
(centralDirectory.volumeEntries === consts.EF_ZIP64_OR_16 &&
|
|
centralDirectory.totalEntries === consts.EF_ZIP64_OR_16) ||
|
|
centralDirectory.size === consts.EF_ZIP64_OR_32 ||
|
|
centralDirectory.offset === consts.EF_ZIP64_OR_32
|
|
) {
|
|
readZip64CentralDirectoryLocator();
|
|
} else {
|
|
op = {};
|
|
readEntries();
|
|
}
|
|
} catch (err) {
|
|
that.emit('error', err);
|
|
}
|
|
}
|
|
|
|
function readZip64CentralDirectoryLocator() {
|
|
const length = consts.ENDL64HDR;
|
|
if (op.lastBufferPosition > length) {
|
|
op.lastBufferPosition -= length;
|
|
readZip64CentralDirectoryLocatorComplete();
|
|
} else {
|
|
op = {
|
|
win: op.win,
|
|
totalReadLength: length,
|
|
minPos: op.win.position - length,
|
|
lastPos: op.win.position,
|
|
chunkSize: op.chunkSize,
|
|
firstByte: consts.ENDL64SIGFIRST,
|
|
sig: consts.ENDL64SIG,
|
|
complete: readZip64CentralDirectoryLocatorComplete,
|
|
};
|
|
op.win.read(op.lastPos - op.chunkSize, op.chunkSize, readUntilFoundCallback);
|
|
}
|
|
}
|
|
|
|
function readZip64CentralDirectoryLocatorComplete() {
|
|
const buffer = op.win.buffer;
|
|
const locHeader = new CentralDirectoryLoc64Header();
|
|
locHeader.read(
|
|
buffer.slice(op.lastBufferPosition, op.lastBufferPosition + consts.ENDL64HDR)
|
|
);
|
|
const readLength = fileSize - locHeader.headerOffset;
|
|
op = {
|
|
win: op.win,
|
|
totalReadLength: readLength,
|
|
minPos: locHeader.headerOffset,
|
|
lastPos: op.lastPos,
|
|
chunkSize: op.chunkSize,
|
|
firstByte: consts.END64SIGFIRST,
|
|
sig: consts.END64SIG,
|
|
complete: readZip64CentralDirectoryComplete,
|
|
};
|
|
op.win.read(fileSize - op.chunkSize, op.chunkSize, readUntilFoundCallback);
|
|
}
|
|
|
|
function readZip64CentralDirectoryComplete() {
|
|
const buffer = op.win.buffer;
|
|
const zip64cd = new CentralDirectoryZip64Header();
|
|
zip64cd.read(buffer.slice(op.lastBufferPosition, op.lastBufferPosition + consts.END64HDR));
|
|
that.centralDirectory.volumeEntries = zip64cd.volumeEntries;
|
|
that.centralDirectory.totalEntries = zip64cd.totalEntries;
|
|
that.centralDirectory.size = zip64cd.size;
|
|
that.centralDirectory.offset = zip64cd.offset;
|
|
that.entriesCount = zip64cd.volumeEntries;
|
|
op = {};
|
|
readEntries();
|
|
}
|
|
|
|
function readEntries() {
|
|
op = {
|
|
win: new FileWindowBuffer(fd),
|
|
pos: centralDirectory.offset,
|
|
chunkSize,
|
|
entriesLeft: centralDirectory.volumeEntries,
|
|
};
|
|
op.win.read(op.pos, Math.min(chunkSize, fileSize - op.pos), readEntriesCallback);
|
|
}
|
|
|
|
function readEntriesCallback(err, bytesRead) {
|
|
if (err || !bytesRead) {
|
|
return that.emit('error', err || new Error('Entries read error'));
|
|
}
|
|
let bufferPos = op.pos - op.win.position;
|
|
let entry = op.entry;
|
|
const buffer = op.win.buffer;
|
|
const bufferLength = buffer.length;
|
|
try {
|
|
while (op.entriesLeft > 0) {
|
|
if (!entry) {
|
|
entry = new ZipEntry();
|
|
entry.readHeader(buffer, bufferPos);
|
|
entry.headerOffset = op.win.position + bufferPos;
|
|
op.entry = entry;
|
|
op.pos += consts.CENHDR;
|
|
bufferPos += consts.CENHDR;
|
|
}
|
|
const entryHeaderSize = entry.fnameLen + entry.extraLen + entry.comLen;
|
|
const advanceBytes = entryHeaderSize + (op.entriesLeft > 1 ? consts.CENHDR : 0);
|
|
if (bufferLength - bufferPos < advanceBytes) {
|
|
op.win.moveRight(chunkSize, readEntriesCallback, bufferPos);
|
|
op.move = true;
|
|
return;
|
|
}
|
|
entry.read(buffer, bufferPos, textDecoder);
|
|
if (!config.skipEntryNameValidation) {
|
|
entry.validateName();
|
|
}
|
|
if (entries) {
|
|
entries[entry.name] = entry;
|
|
}
|
|
that.emit('entry', entry);
|
|
op.entry = entry = null;
|
|
op.entriesLeft--;
|
|
op.pos += entryHeaderSize;
|
|
bufferPos += entryHeaderSize;
|
|
}
|
|
that.emit('ready');
|
|
} catch (err) {
|
|
that.emit('error', err);
|
|
}
|
|
}
|
|
|
|
function checkEntriesExist() {
|
|
if (!entries) {
|
|
throw new Error('storeEntries disabled');
|
|
}
|
|
}
|
|
|
|
Object.defineProperty(this, 'ready', {
|
|
get() {
|
|
return ready;
|
|
},
|
|
});
|
|
|
|
this.entry = function (name) {
|
|
checkEntriesExist();
|
|
return entries[name];
|
|
};
|
|
|
|
this.entries = function () {
|
|
checkEntriesExist();
|
|
return entries;
|
|
};
|
|
|
|
this.stream = function (entry, callback) {
|
|
return this.openEntry(
|
|
entry,
|
|
(err, entry) => {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
const offset = dataOffset(entry);
|
|
let entryStream = new EntryDataReaderStream(fd, offset, entry.compressedSize);
|
|
if (entry.method === consts.STORED) {
|
|
// nothing to do
|
|
} else if (entry.method === consts.DEFLATED) {
|
|
entryStream = entryStream.pipe(zlib.createInflateRaw());
|
|
} else {
|
|
return callback(new Error('Unknown compression method: ' + entry.method));
|
|
}
|
|
if (canVerifyCrc(entry)) {
|
|
entryStream = entryStream.pipe(
|
|
new EntryVerifyStream(entryStream, entry.crc, entry.size)
|
|
);
|
|
}
|
|
callback(null, entryStream);
|
|
},
|
|
false
|
|
);
|
|
};
|
|
|
|
this.entryDataSync = function (entry) {
|
|
let err = null;
|
|
this.openEntry(
|
|
entry,
|
|
(e, en) => {
|
|
err = e;
|
|
entry = en;
|
|
},
|
|
true
|
|
);
|
|
if (err) {
|
|
throw err;
|
|
}
|
|
let data = Buffer.alloc(entry.compressedSize);
|
|
new FsRead(fd, data, 0, entry.compressedSize, dataOffset(entry), (e) => {
|
|
err = e;
|
|
}).read(true);
|
|
if (err) {
|
|
throw err;
|
|
}
|
|
if (entry.method === consts.STORED) {
|
|
// nothing to do
|
|
} else if (entry.method === consts.DEFLATED || entry.method === consts.ENHANCED_DEFLATED) {
|
|
data = zlib.inflateRawSync(data);
|
|
} else {
|
|
throw new Error('Unknown compression method: ' + entry.method);
|
|
}
|
|
if (data.length !== entry.size) {
|
|
throw new Error('Invalid size');
|
|
}
|
|
if (canVerifyCrc(entry)) {
|
|
const verify = new CrcVerify(entry.crc, entry.size);
|
|
verify.data(data);
|
|
}
|
|
return data;
|
|
};
|
|
|
|
this.openEntry = function (entry, callback, sync) {
|
|
if (typeof entry === 'string') {
|
|
checkEntriesExist();
|
|
entry = entries[entry];
|
|
if (!entry) {
|
|
return callback(new Error('Entry not found'));
|
|
}
|
|
}
|
|
if (!entry.isFile) {
|
|
return callback(new Error('Entry is not file'));
|
|
}
|
|
if (!fd) {
|
|
return callback(new Error('Archive closed'));
|
|
}
|
|
const buffer = Buffer.alloc(consts.LOCHDR);
|
|
new FsRead(fd, buffer, 0, buffer.length, entry.offset, (err) => {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
let readEx;
|
|
try {
|
|
entry.readDataHeader(buffer);
|
|
if (entry.encrypted) {
|
|
readEx = new Error('Entry encrypted');
|
|
}
|
|
} catch (ex) {
|
|
readEx = ex;
|
|
}
|
|
callback(readEx, entry);
|
|
}).read(sync);
|
|
};
|
|
|
|
function dataOffset(entry) {
|
|
return entry.offset + consts.LOCHDR + entry.fnameLen + entry.extraLen;
|
|
}
|
|
|
|
function canVerifyCrc(entry) {
|
|
// if bit 3 (0x08) of the general-purpose flags field is set, then the CRC-32 and file sizes are not known when the header is written
|
|
return (entry.flags & 0x8) !== 0x8;
|
|
}
|
|
|
|
function extract(entry, outPath, callback) {
|
|
that.stream(entry, (err, stm) => {
|
|
if (err) {
|
|
callback(err);
|
|
} else {
|
|
let fsStm, errThrown;
|
|
stm.on('error', (err) => {
|
|
errThrown = err;
|
|
if (fsStm) {
|
|
stm.unpipe(fsStm);
|
|
fsStm.close(() => {
|
|
callback(err);
|
|
});
|
|
}
|
|
});
|
|
fs.open(outPath, 'w', (err, fdFile) => {
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
if (errThrown) {
|
|
fs.close(fd, () => {
|
|
callback(errThrown);
|
|
});
|
|
return;
|
|
}
|
|
fsStm = fs.createWriteStream(outPath, { fd: fdFile });
|
|
fsStm.on('finish', () => {
|
|
that.emit('extract', entry, outPath);
|
|
if (!errThrown) {
|
|
callback();
|
|
}
|
|
});
|
|
stm.pipe(fsStm);
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
function createDirectories(baseDir, dirs, callback) {
|
|
if (!dirs.length) {
|
|
return callback();
|
|
}
|
|
let dir = dirs.shift();
|
|
dir = path.join(baseDir, path.join(...dir));
|
|
fs.mkdir(dir, { recursive: true }, (err) => {
|
|
if (err && err.code !== 'EEXIST') {
|
|
return callback(err);
|
|
}
|
|
createDirectories(baseDir, dirs, callback);
|
|
});
|
|
}
|
|
|
|
function extractFiles(baseDir, baseRelPath, files, callback, extractedCount) {
|
|
if (!files.length) {
|
|
return callback(null, extractedCount);
|
|
}
|
|
const file = files.shift();
|
|
const targetPath = path.join(baseDir, file.name.replace(baseRelPath, ''));
|
|
extract(file, targetPath, (err) => {
|
|
if (err) {
|
|
return callback(err, extractedCount);
|
|
}
|
|
extractFiles(baseDir, baseRelPath, files, callback, extractedCount + 1);
|
|
});
|
|
}
|
|
|
|
this.extract = function (entry, outPath, callback) {
|
|
let entryName = entry || '';
|
|
if (typeof entry === 'string') {
|
|
entry = this.entry(entry);
|
|
if (entry) {
|
|
entryName = entry.name;
|
|
} else {
|
|
if (entryName.length && entryName[entryName.length - 1] !== '/') {
|
|
entryName += '/';
|
|
}
|
|
}
|
|
}
|
|
if (!entry || entry.isDirectory) {
|
|
const files = [],
|
|
dirs = [],
|
|
allDirs = {};
|
|
for (const e in entries) {
|
|
if (
|
|
Object.prototype.hasOwnProperty.call(entries, e) &&
|
|
e.lastIndexOf(entryName, 0) === 0
|
|
) {
|
|
let relPath = e.replace(entryName, '');
|
|
const childEntry = entries[e];
|
|
if (childEntry.isFile) {
|
|
files.push(childEntry);
|
|
relPath = path.dirname(relPath);
|
|
}
|
|
if (relPath && !allDirs[relPath] && relPath !== '.') {
|
|
allDirs[relPath] = true;
|
|
let parts = relPath.split('/').filter((f) => {
|
|
return f;
|
|
});
|
|
if (parts.length) {
|
|
dirs.push(parts);
|
|
}
|
|
while (parts.length > 1) {
|
|
parts = parts.slice(0, parts.length - 1);
|
|
const partsPath = parts.join('/');
|
|
if (allDirs[partsPath] || partsPath === '.') {
|
|
break;
|
|
}
|
|
allDirs[partsPath] = true;
|
|
dirs.push(parts);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
dirs.sort((x, y) => {
|
|
return x.length - y.length;
|
|
});
|
|
if (dirs.length) {
|
|
createDirectories(outPath, dirs, (err) => {
|
|
if (err) {
|
|
callback(err);
|
|
} else {
|
|
extractFiles(outPath, entryName, files, callback, 0);
|
|
}
|
|
});
|
|
} else {
|
|
extractFiles(outPath, entryName, files, callback, 0);
|
|
}
|
|
} else {
|
|
fs.stat(outPath, (err, stat) => {
|
|
if (stat && stat.isDirectory()) {
|
|
extract(entry, path.join(outPath, path.basename(entry.name)), callback);
|
|
} else {
|
|
extract(entry, outPath, callback);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
this.close = function (callback) {
|
|
if (closed || !fd) {
|
|
closed = true;
|
|
if (callback) {
|
|
callback();
|
|
}
|
|
} else {
|
|
closed = true;
|
|
fs.close(fd, (err) => {
|
|
fd = null;
|
|
if (callback) {
|
|
callback(err);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
const originalEmit = events.EventEmitter.prototype.emit;
|
|
this.emit = function (...args) {
|
|
if (!closed) {
|
|
return originalEmit.call(this, ...args);
|
|
}
|
|
};
|
|
};
|
|
|
|
StreamZip.setFs = function (customFs) {
|
|
fs = customFs;
|
|
};
|
|
|
|
StreamZip.debugLog = (...args) => {
|
|
if (StreamZip.debug) {
|
|
// eslint-disable-next-line no-console
|
|
console.log(...args);
|
|
}
|
|
};
|
|
|
|
util.inherits(StreamZip, events.EventEmitter);
|
|
|
|
const propZip = Symbol('zip');
|
|
|
|
StreamZip.async = class StreamZipAsync extends events.EventEmitter {
|
|
constructor(config) {
|
|
super();
|
|
|
|
const zip = new StreamZip(config);
|
|
|
|
zip.on('entry', (entry) => this.emit('entry', entry));
|
|
zip.on('extract', (entry, outPath) => this.emit('extract', entry, outPath));
|
|
|
|
this[propZip] = new Promise((resolve, reject) => {
|
|
zip.on('ready', () => {
|
|
zip.removeListener('error', reject);
|
|
resolve(zip);
|
|
});
|
|
zip.on('error', reject);
|
|
});
|
|
}
|
|
|
|
get entriesCount() {
|
|
return this[propZip].then((zip) => zip.entriesCount);
|
|
}
|
|
|
|
get comment() {
|
|
return this[propZip].then((zip) => zip.comment);
|
|
}
|
|
|
|
async entry(name) {
|
|
const zip = await this[propZip];
|
|
return zip.entry(name);
|
|
}
|
|
|
|
async entries() {
|
|
const zip = await this[propZip];
|
|
return zip.entries();
|
|
}
|
|
|
|
async stream(entry) {
|
|
const zip = await this[propZip];
|
|
return new Promise((resolve, reject) => {
|
|
zip.stream(entry, (err, stm) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(stm);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
async entryData(entry) {
|
|
const stm = await this.stream(entry);
|
|
return new Promise((resolve, reject) => {
|
|
const data = [];
|
|
stm.on('data', (chunk) => data.push(chunk));
|
|
stm.on('end', () => {
|
|
resolve(Buffer.concat(data));
|
|
});
|
|
stm.on('error', (err) => {
|
|
stm.removeAllListeners('end');
|
|
reject(err);
|
|
});
|
|
});
|
|
}
|
|
|
|
async extract(entry, outPath) {
|
|
const zip = await this[propZip];
|
|
return new Promise((resolve, reject) => {
|
|
zip.extract(entry, outPath, (err, res) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(res);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
async close() {
|
|
const zip = await this[propZip];
|
|
return new Promise((resolve, reject) => {
|
|
zip.close((err) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve();
|
|
}
|
|
});
|
|
});
|
|
}
|
|
};
|
|
|
|
class CentralDirectoryHeader {
|
|
read(data) {
|
|
if (data.length !== consts.ENDHDR || data.readUInt32LE(0) !== consts.ENDSIG) {
|
|
throw new Error('Invalid central directory');
|
|
}
|
|
// number of entries on this volume
|
|
this.volumeEntries = data.readUInt16LE(consts.ENDSUB);
|
|
// total number of entries
|
|
this.totalEntries = data.readUInt16LE(consts.ENDTOT);
|
|
// central directory size in bytes
|
|
this.size = data.readUInt32LE(consts.ENDSIZ);
|
|
// offset of first CEN header
|
|
this.offset = data.readUInt32LE(consts.ENDOFF);
|
|
// zip file comment length
|
|
this.commentLength = data.readUInt16LE(consts.ENDCOM);
|
|
}
|
|
}
|
|
|
|
class CentralDirectoryLoc64Header {
|
|
read(data) {
|
|
if (data.length !== consts.ENDL64HDR || data.readUInt32LE(0) !== consts.ENDL64SIG) {
|
|
throw new Error('Invalid zip64 central directory locator');
|
|
}
|
|
// ZIP64 EOCD header offset
|
|
this.headerOffset = readUInt64LE(data, consts.ENDSUB);
|
|
}
|
|
}
|
|
|
|
class CentralDirectoryZip64Header {
|
|
read(data) {
|
|
if (data.length !== consts.END64HDR || data.readUInt32LE(0) !== consts.END64SIG) {
|
|
throw new Error('Invalid central directory');
|
|
}
|
|
// number of entries on this volume
|
|
this.volumeEntries = readUInt64LE(data, consts.END64SUB);
|
|
// total number of entries
|
|
this.totalEntries = readUInt64LE(data, consts.END64TOT);
|
|
// central directory size in bytes
|
|
this.size = readUInt64LE(data, consts.END64SIZ);
|
|
// offset of first CEN header
|
|
this.offset = readUInt64LE(data, consts.END64OFF);
|
|
}
|
|
}
|
|
|
|
class ZipEntry {
|
|
readHeader(data, offset) {
|
|
// data should be 46 bytes and start with "PK 01 02"
|
|
if (data.length < offset + consts.CENHDR || data.readUInt32LE(offset) !== consts.CENSIG) {
|
|
throw new Error('Invalid entry header');
|
|
}
|
|
// version made by
|
|
this.verMade = data.readUInt16LE(offset + consts.CENVEM);
|
|
// version needed to extract
|
|
this.version = data.readUInt16LE(offset + consts.CENVER);
|
|
// encrypt, decrypt flags
|
|
this.flags = data.readUInt16LE(offset + consts.CENFLG);
|
|
// compression method
|
|
this.method = data.readUInt16LE(offset + consts.CENHOW);
|
|
// modification time (2 bytes time, 2 bytes date)
|
|
const timebytes = data.readUInt16LE(offset + consts.CENTIM);
|
|
const datebytes = data.readUInt16LE(offset + consts.CENTIM + 2);
|
|
this.time = parseZipTime(timebytes, datebytes);
|
|
|
|
// uncompressed file crc-32 value
|
|
this.crc = data.readUInt32LE(offset + consts.CENCRC);
|
|
// compressed size
|
|
this.compressedSize = data.readUInt32LE(offset + consts.CENSIZ);
|
|
// uncompressed size
|
|
this.size = data.readUInt32LE(offset + consts.CENLEN);
|
|
// filename length
|
|
this.fnameLen = data.readUInt16LE(offset + consts.CENNAM);
|
|
// extra field length
|
|
this.extraLen = data.readUInt16LE(offset + consts.CENEXT);
|
|
// file comment length
|
|
this.comLen = data.readUInt16LE(offset + consts.CENCOM);
|
|
// volume number start
|
|
this.diskStart = data.readUInt16LE(offset + consts.CENDSK);
|
|
// internal file attributes
|
|
this.inattr = data.readUInt16LE(offset + consts.CENATT);
|
|
// external file attributes
|
|
this.attr = data.readUInt32LE(offset + consts.CENATX);
|
|
// LOC header offset
|
|
this.offset = data.readUInt32LE(offset + consts.CENOFF);
|
|
}
|
|
|
|
readDataHeader(data) {
|
|
// 30 bytes and should start with "PK\003\004"
|
|
if (data.readUInt32LE(0) !== consts.LOCSIG) {
|
|
throw new Error('Invalid local header');
|
|
}
|
|
// version needed to extract
|
|
this.version = data.readUInt16LE(consts.LOCVER);
|
|
// general purpose bit flag
|
|
this.flags = data.readUInt16LE(consts.LOCFLG);
|
|
// compression method
|
|
this.method = data.readUInt16LE(consts.LOCHOW);
|
|
// modification time (2 bytes time ; 2 bytes date)
|
|
const timebytes = data.readUInt16LE(consts.LOCTIM);
|
|
const datebytes = data.readUInt16LE(consts.LOCTIM + 2);
|
|
this.time = parseZipTime(timebytes, datebytes);
|
|
|
|
// uncompressed file crc-32 value
|
|
this.crc = data.readUInt32LE(consts.LOCCRC) || this.crc;
|
|
// compressed size
|
|
const compressedSize = data.readUInt32LE(consts.LOCSIZ);
|
|
if (compressedSize && compressedSize !== consts.EF_ZIP64_OR_32) {
|
|
this.compressedSize = compressedSize;
|
|
}
|
|
// uncompressed size
|
|
const size = data.readUInt32LE(consts.LOCLEN);
|
|
if (size && size !== consts.EF_ZIP64_OR_32) {
|
|
this.size = size;
|
|
}
|
|
// filename length
|
|
this.fnameLen = data.readUInt16LE(consts.LOCNAM);
|
|
// extra field length
|
|
this.extraLen = data.readUInt16LE(consts.LOCEXT);
|
|
}
|
|
|
|
read(data, offset, textDecoder) {
|
|
const nameData = data.slice(offset, (offset += this.fnameLen));
|
|
this.name = textDecoder
|
|
? textDecoder.decode(new Uint8Array(nameData))
|
|
: nameData.toString('utf8');
|
|
const lastChar = data[offset - 1];
|
|
this.isDirectory = lastChar === 47 || lastChar === 92;
|
|
|
|
if (this.extraLen) {
|
|
this.readExtra(data, offset);
|
|
offset += this.extraLen;
|
|
}
|
|
this.comment = this.comLen ? data.slice(offset, offset + this.comLen).toString() : null;
|
|
}
|
|
|
|
validateName() {
|
|
if (/\\|^\w+:|^\/|(^|\/)\.\.(\/|$)/.test(this.name)) {
|
|
throw new Error('Malicious entry: ' + this.name);
|
|
}
|
|
}
|
|
|
|
readExtra(data, offset) {
|
|
let signature, size;
|
|
const maxPos = offset + this.extraLen;
|
|
while (offset < maxPos) {
|
|
signature = data.readUInt16LE(offset);
|
|
offset += 2;
|
|
size = data.readUInt16LE(offset);
|
|
offset += 2;
|
|
if (consts.ID_ZIP64 === signature) {
|
|
this.parseZip64Extra(data, offset, size);
|
|
}
|
|
offset += size;
|
|
}
|
|
}
|
|
|
|
parseZip64Extra(data, offset, length) {
|
|
if (length >= 8 && this.size === consts.EF_ZIP64_OR_32) {
|
|
this.size = readUInt64LE(data, offset);
|
|
offset += 8;
|
|
length -= 8;
|
|
}
|
|
if (length >= 8 && this.compressedSize === consts.EF_ZIP64_OR_32) {
|
|
this.compressedSize = readUInt64LE(data, offset);
|
|
offset += 8;
|
|
length -= 8;
|
|
}
|
|
if (length >= 8 && this.offset === consts.EF_ZIP64_OR_32) {
|
|
this.offset = readUInt64LE(data, offset);
|
|
offset += 8;
|
|
length -= 8;
|
|
}
|
|
if (length >= 4 && this.diskStart === consts.EF_ZIP64_OR_16) {
|
|
this.diskStart = data.readUInt32LE(offset);
|
|
// offset += 4; length -= 4;
|
|
}
|
|
}
|
|
|
|
get encrypted() {
|
|
return (this.flags & consts.FLG_ENTRY_ENC) === consts.FLG_ENTRY_ENC;
|
|
}
|
|
|
|
get isFile() {
|
|
return !this.isDirectory;
|
|
}
|
|
}
|
|
|
|
class FsRead {
|
|
constructor(fd, buffer, offset, length, position, callback) {
|
|
this.fd = fd;
|
|
this.buffer = buffer;
|
|
this.offset = offset;
|
|
this.length = length;
|
|
this.position = position;
|
|
this.callback = callback;
|
|
this.bytesRead = 0;
|
|
this.waiting = false;
|
|
}
|
|
|
|
read(sync) {
|
|
StreamZip.debugLog('read', this.position, this.bytesRead, this.length, this.offset);
|
|
this.waiting = true;
|
|
let err;
|
|
if (sync) {
|
|
let bytesRead = 0;
|
|
try {
|
|
bytesRead = fs.readSync(
|
|
this.fd,
|
|
this.buffer,
|
|
this.offset + this.bytesRead,
|
|
this.length - this.bytesRead,
|
|
this.position + this.bytesRead
|
|
);
|
|
} catch (e) {
|
|
err = e;
|
|
}
|
|
this.readCallback(sync, err, err ? bytesRead : null);
|
|
} else {
|
|
fs.read(
|
|
this.fd,
|
|
this.buffer,
|
|
this.offset + this.bytesRead,
|
|
this.length - this.bytesRead,
|
|
this.position + this.bytesRead,
|
|
this.readCallback.bind(this, sync)
|
|
);
|
|
}
|
|
}
|
|
|
|
readCallback(sync, err, bytesRead) {
|
|
if (typeof bytesRead === 'number') {
|
|
this.bytesRead += bytesRead;
|
|
}
|
|
if (err || !bytesRead || this.bytesRead === this.length) {
|
|
this.waiting = false;
|
|
return this.callback(err, this.bytesRead);
|
|
} else {
|
|
this.read(sync);
|
|
}
|
|
}
|
|
}
|
|
|
|
class FileWindowBuffer {
|
|
constructor(fd) {
|
|
this.position = 0;
|
|
this.buffer = Buffer.alloc(0);
|
|
this.fd = fd;
|
|
this.fsOp = null;
|
|
}
|
|
|
|
checkOp() {
|
|
if (this.fsOp && this.fsOp.waiting) {
|
|
throw new Error('Operation in progress');
|
|
}
|
|
}
|
|
|
|
read(pos, length, callback) {
|
|
this.checkOp();
|
|
if (this.buffer.length < length) {
|
|
this.buffer = Buffer.alloc(length);
|
|
}
|
|
this.position = pos;
|
|
this.fsOp = new FsRead(this.fd, this.buffer, 0, length, this.position, callback).read();
|
|
}
|
|
|
|
expandLeft(length, callback) {
|
|
this.checkOp();
|
|
this.buffer = Buffer.concat([Buffer.alloc(length), this.buffer]);
|
|
this.position -= length;
|
|
if (this.position < 0) {
|
|
this.position = 0;
|
|
}
|
|
this.fsOp = new FsRead(this.fd, this.buffer, 0, length, this.position, callback).read();
|
|
}
|
|
|
|
expandRight(length, callback) {
|
|
this.checkOp();
|
|
const offset = this.buffer.length;
|
|
this.buffer = Buffer.concat([this.buffer, Buffer.alloc(length)]);
|
|
this.fsOp = new FsRead(
|
|
this.fd,
|
|
this.buffer,
|
|
offset,
|
|
length,
|
|
this.position + offset,
|
|
callback
|
|
).read();
|
|
}
|
|
|
|
moveRight(length, callback, shift) {
|
|
this.checkOp();
|
|
if (shift) {
|
|
this.buffer.copy(this.buffer, 0, shift);
|
|
} else {
|
|
shift = 0;
|
|
}
|
|
this.position += shift;
|
|
this.fsOp = new FsRead(
|
|
this.fd,
|
|
this.buffer,
|
|
this.buffer.length - shift,
|
|
shift,
|
|
this.position + this.buffer.length - shift,
|
|
callback
|
|
).read();
|
|
}
|
|
}
|
|
|
|
class EntryDataReaderStream extends stream.Readable {
|
|
constructor(fd, offset, length) {
|
|
super();
|
|
this.fd = fd;
|
|
this.offset = offset;
|
|
this.length = length;
|
|
this.pos = 0;
|
|
this.readCallback = this.readCallback.bind(this);
|
|
}
|
|
|
|
_read(n) {
|
|
const buffer = Buffer.alloc(Math.min(n, this.length - this.pos));
|
|
if (buffer.length) {
|
|
fs.read(this.fd, buffer, 0, buffer.length, this.offset + this.pos, this.readCallback);
|
|
} else {
|
|
this.push(null);
|
|
}
|
|
}
|
|
|
|
readCallback(err, bytesRead, buffer) {
|
|
this.pos += bytesRead;
|
|
if (err) {
|
|
this.emit('error', err);
|
|
this.push(null);
|
|
} else if (!bytesRead) {
|
|
this.push(null);
|
|
} else {
|
|
if (bytesRead !== buffer.length) {
|
|
buffer = buffer.slice(0, bytesRead);
|
|
}
|
|
this.push(buffer);
|
|
}
|
|
}
|
|
}
|
|
|
|
class EntryVerifyStream extends stream.Transform {
|
|
constructor(baseStm, crc, size) {
|
|
super();
|
|
this.verify = new CrcVerify(crc, size);
|
|
baseStm.on('error', (e) => {
|
|
this.emit('error', e);
|
|
});
|
|
}
|
|
|
|
_transform(data, encoding, callback) {
|
|
let err;
|
|
try {
|
|
this.verify.data(data);
|
|
} catch (e) {
|
|
err = e;
|
|
}
|
|
callback(err, data);
|
|
}
|
|
}
|
|
|
|
class CrcVerify {
|
|
constructor(crc, size) {
|
|
this.crc = crc;
|
|
this.size = size;
|
|
this.state = {
|
|
crc: ~0,
|
|
size: 0,
|
|
};
|
|
}
|
|
|
|
data(data) {
|
|
const crcTable = CrcVerify.getCrcTable();
|
|
let crc = this.state.crc;
|
|
let off = 0;
|
|
let len = data.length;
|
|
while (--len >= 0) {
|
|
crc = crcTable[(crc ^ data[off++]) & 0xff] ^ (crc >>> 8);
|
|
}
|
|
this.state.crc = crc;
|
|
this.state.size += data.length;
|
|
if (this.state.size >= this.size) {
|
|
const buf = Buffer.alloc(4);
|
|
buf.writeInt32LE(~this.state.crc & 0xffffffff, 0);
|
|
crc = buf.readUInt32LE(0);
|
|
if (crc !== this.crc) {
|
|
throw new Error('Invalid CRC');
|
|
}
|
|
if (this.state.size !== this.size) {
|
|
throw new Error('Invalid size');
|
|
}
|
|
}
|
|
}
|
|
|
|
static getCrcTable() {
|
|
let crcTable = CrcVerify.crcTable;
|
|
if (!crcTable) {
|
|
CrcVerify.crcTable = crcTable = [];
|
|
const b = Buffer.alloc(4);
|
|
for (let n = 0; n < 256; n++) {
|
|
let c = n;
|
|
for (let k = 8; --k >= 0;) {
|
|
if ((c & 1) !== 0) {
|
|
c = 0xedb88320 ^ (c >>> 1);
|
|
} else {
|
|
c = c >>> 1;
|
|
}
|
|
}
|
|
if (c < 0) {
|
|
b.writeInt32LE(c, 0);
|
|
c = b.readUInt32LE(0);
|
|
}
|
|
crcTable[n] = c;
|
|
}
|
|
}
|
|
return crcTable;
|
|
}
|
|
}
|
|
|
|
function parseZipTime(timebytes, datebytes) {
|
|
const timebits = toBits(timebytes, 16);
|
|
const datebits = toBits(datebytes, 16);
|
|
|
|
const mt = {
|
|
h: parseInt(timebits.slice(0, 5).join(''), 2),
|
|
m: parseInt(timebits.slice(5, 11).join(''), 2),
|
|
s: parseInt(timebits.slice(11, 16).join(''), 2) * 2,
|
|
Y: parseInt(datebits.slice(0, 7).join(''), 2) + 1980,
|
|
M: parseInt(datebits.slice(7, 11).join(''), 2),
|
|
D: parseInt(datebits.slice(11, 16).join(''), 2),
|
|
};
|
|
const dt_str = [mt.Y, mt.M, mt.D].join('-') + ' ' + [mt.h, mt.m, mt.s].join(':') + ' GMT+0';
|
|
return new Date(dt_str).getTime();
|
|
}
|
|
|
|
function toBits(dec, size) {
|
|
let b = (dec >>> 0).toString(2);
|
|
while (b.length < size) {
|
|
b = '0' + b;
|
|
}
|
|
return b.split('');
|
|
}
|
|
|
|
function readUInt64LE(buffer, offset) {
|
|
return buffer.readUInt32LE(offset + 4) * 0x0000000100000000 + buffer.readUInt32LE(offset);
|
|
}
|
|
|
|
module.exports = StreamZip; |