codekingpro/portable-devtools
115k
1"use strict";
2// the PEND/UNPEND stuff tracks whether we're ready to emit end/close yet.
3// but the path reservations are required to avoid race conditions where
4// parallelized unpack ops may mess with one another, due to dependencies
5// (like a Link depending on its target) or destructive operations (like
6// clobbering an fs object to create one of a different type.)
7var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
8 if (k2 === undefined) k2 = k;
9 var desc = Object.getOwnPropertyDescriptor(m, k);
10 if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
11 desc = { enumerable: true, get: function() { return m[k]; } };
12 }
13 Object.defineProperty(o, k2, desc);
14}) : (function(o, m, k, k2) {
15 if (k2 === undefined) k2 = k;
16 o[k2] = m[k];
17}));
18var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
19 Object.defineProperty(o, "default", { enumerable: true, value: v });
20}) : function(o, v) {
21 o["default"] = v;
22});
23var __importStar = (this && this.__importStar) || (function () {
24 var ownKeys = function(o) {
25 ownKeys = Object.getOwnPropertyNames || function (o) {
26 var ar = [];
27 for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
28 return ar;
29 };
30 return ownKeys(o);
31 };
32 return function (mod) {
33 if (mod && mod.__esModule) return mod;
34 var result = {};
35 if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
36 __setModuleDefault(result, mod);
37 return result;
38 };
39})();
40var __importDefault = (this && this.__importDefault) || function (mod) {
41 return (mod && mod.__esModule) ? mod : { "default": mod };
42};
43Object.defineProperty(exports, "__esModule", { value: true });
44exports.UnpackSync = exports.Unpack = void 0;
45const fsm = __importStar(require("@isaacs/fs-minipass"));
46const node_assert_1 = __importDefault(require("node:assert"));
47const node_crypto_1 = require("node:crypto");
48const node_fs_1 = __importDefault(require("node:fs"));
49const node_path_1 = __importDefault(require("node:path"));
50const get_write_flag_js_1 = require("./get-write-flag.js");
51const mkdir_js_1 = require("./mkdir.js");
52const normalize_windows_path_js_1 = require("./normalize-windows-path.js");
53const parse_js_1 = require("./parse.js");
54const strip_absolute_path_js_1 = require("./strip-absolute-path.js");
55const wc = __importStar(require("./winchars.js"));
56const path_reservations_js_1 = require("./path-reservations.js");
57const symlink_error_js_1 = require("./symlink-error.js");
58const process_umask_js_1 = require("./process-umask.js");
59const ONENTRY = Symbol('onEntry');
60const CHECKFS = Symbol('checkFs');
61const CHECKFS2 = Symbol('checkFs2');
62const ISREUSABLE = Symbol('isReusable');
63const MAKEFS = Symbol('makeFs');
64const FILE = Symbol('file');
65const DIRECTORY = Symbol('directory');
66const LINK = Symbol('link');
67const SYMLINK = Symbol('symlink');
68const HARDLINK = Symbol('hardlink');
69const ENSURE_NO_SYMLINK = Symbol('ensureNoSymlink');
70const UNSUPPORTED = Symbol('unsupported');
71const CHECKPATH = Symbol('checkPath');
72const STRIPABSOLUTEPATH = Symbol('stripAbsolutePath');
73const MKDIR = Symbol('mkdir');
74const ONERROR = Symbol('onError');
75const PENDING = Symbol('pending');
76const PEND = Symbol('pend');
77const UNPEND = Symbol('unpend');
78const ENDED = Symbol('ended');
79const MAYBECLOSE = Symbol('maybeClose');
80const SKIP = Symbol('skip');
81const DOCHOWN = Symbol('doChown');
82const UID = Symbol('uid');
83const GID = Symbol('gid');
84const CHECKED_CWD = Symbol('checkedCwd');
85const platform = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform;
86const isWindows = platform === 'win32';
87const DEFAULT_MAX_DEPTH = 1024;
88// Unlinks on Windows are not atomic.
89//
90// This means that if you have a file entry, followed by another
91// file entry with an identical name, and you cannot re-use the file
92// (because it's a hardlink, or because unlink:true is set, or it's
93// Windows, which does not have useful nlink values), then the unlink
94// will be committed to the disk AFTER the new file has been written
95// over the old one, deleting the new file.
96//
97// To work around this, on Windows systems, we rename the file and then
98// delete the renamed file. It's a sloppy kludge, but frankly, I do not
99// know of a better way to do this, given windows' non-atomic unlink
100// semantics.
101//
102// See: https://github.com/npm/node-tar/issues/183
103/* c8 ignore start */
104const unlinkFile = (path, cb) => {
105 if (!isWindows) {
106 return node_fs_1.default.unlink(path, cb);
107 }
108 const name = path + '.DELETE.' + (0, node_crypto_1.randomBytes)(16).toString('hex');
109 node_fs_1.default.rename(path, name, er => {
110 if (er) {
111 return cb(er);
112 }
113 node_fs_1.default.unlink(name, cb);
114 });
115};
116/* c8 ignore stop */
117/* c8 ignore start */
118const unlinkFileSync = (path) => {
119 if (!isWindows) {
120 return node_fs_1.default.unlinkSync(path);
121 }
122 const name = path + '.DELETE.' + (0, node_crypto_1.randomBytes)(16).toString('hex');
123 node_fs_1.default.renameSync(path, name);
124 node_fs_1.default.unlinkSync(name);
125};
126/* c8 ignore stop */
127// this.gid, entry.gid, this.processUid
128const uint32 = (a, b, c) => a !== undefined && a === a >>> 0 ? a
129 : b !== undefined && b === b >>> 0 ? b
130 : c;
131class Unpack extends parse_js_1.Parser {
132 [ENDED] = false;
133 [CHECKED_CWD] = false;
134 [PENDING] = 0;
135 reservations = new path_reservations_js_1.PathReservations();
136 transform;
137 writable = true;
138 readable = false;
139 uid;
140 gid;
141 setOwner;
142 preserveOwner;
143 processGid;
144 processUid;
145 maxDepth;
146 forceChown;
147 win32;
148 newer;
149 keep;
150 noMtime;
151 preservePaths;
152 unlink;
153 cwd;
154 strip;
155 processUmask;
156 umask;
157 dmode;
158 fmode;
159 chmod;
160 constructor(opt = {}) {
161 opt.ondone = () => {
162 this[ENDED] = true;
163 this[MAYBECLOSE]();
164 };
165 super(opt);
166 this.transform = opt.transform;
167 this.chmod = !!opt.chmod;
168 if (typeof opt.uid === 'number' || typeof opt.gid === 'number') {
169 // need both or neither
170 if (typeof opt.uid !== 'number' || typeof opt.gid !== 'number') {
171 throw new TypeError('cannot set owner without number uid and gid');
172 }
173 if (opt.preserveOwner) {
174 throw new TypeError('cannot preserve owner in archive and also set owner explicitly');
175 }
176 this.uid = opt.uid;
177 this.gid = opt.gid;
178 this.setOwner = true;
179 }
180 else {
181 this.uid = undefined;
182 this.gid = undefined;
183 this.setOwner = false;
184 }
185 // default true for root
186 this.preserveOwner =
187 opt.preserveOwner === undefined && typeof opt.uid !== 'number' ?
188 !!(process.getuid && process.getuid() === 0)
189 : !!opt.preserveOwner;
190 this.processUid =
191 (this.preserveOwner || this.setOwner) && process.getuid ?
192 process.getuid()
193 : undefined;
194 this.processGid =
195 (this.preserveOwner || this.setOwner) && process.getgid ?
196 process.getgid()
197 : undefined;
198 // prevent excessively deep nesting of subfolders
199 // set to `Infinity` to remove this restriction
200 this.maxDepth =
201 typeof opt.maxDepth === 'number' ? opt.maxDepth : DEFAULT_MAX_DEPTH;
202 // mostly just for testing, but useful in some cases.
203 // Forcibly trigger a chown on every entry, no matter what
204 this.forceChown = opt.forceChown === true;
205 // turn ><?| in filenames into 0xf000-higher encoded forms
206 this.win32 = !!opt.win32 || isWindows;
207 // do not unpack over files that are newer than what's in the archive
208 this.newer = !!opt.newer;
209 // do not unpack over ANY files
210 this.keep = !!opt.keep;
211 // do not set mtime/atime of extracted entries
212 this.noMtime = !!opt.noMtime;
213 // allow .., absolute path entries, and unpacking through symlinks
214 // without this, warn and skip .., relativize absolutes, and error
215 // on symlinks in extraction path
216 this.preservePaths = !!opt.preservePaths;
217 // unlink files and links before writing. This breaks existing hard
218 // links, and removes symlink directories rather than erroring
219 this.unlink = !!opt.unlink;
220 this.cwd = (0, normalize_windows_path_js_1.normalizeWindowsPath)(node_path_1.default.resolve(opt.cwd || process.cwd()));
221 this.strip = Number(opt.strip) || 0;
222 // if we're not chmodding, then we don't need the process umask
223 this.processUmask =
224 !this.chmod ? 0
225 : typeof opt.processUmask === 'number' ? opt.processUmask
226 : (0, process_umask_js_1.umask)();
227 this.umask =
228 typeof opt.umask === 'number' ? opt.umask : this.processUmask;
229 // default mode for dirs created as parents
230 this.dmode = opt.dmode || 0o0777 & ~this.umask;
231 this.fmode = opt.fmode || 0o0666 & ~this.umask;
232 this.on('entry', entry => this[ONENTRY](entry));
233 }
234 // a bad or damaged archive is a warning for Parser, but an error
235 // when extracting. Mark those errors as unrecoverable, because
236 // the Unpack contract cannot be met.
237 warn(code, msg, data = {}) {
238 if (code === 'TAR_BAD_ARCHIVE' || code === 'TAR_ABORT') {
239 data.recoverable = false;
240 }
241 return super.warn(code, msg, data);
242 }
243 [MAYBECLOSE]() {
244 if (this[ENDED] && this[PENDING] === 0) {
245 this.emit('prefinish');
246 this.emit('finish');
247 this.emit('end');
248 }
249 }
250 // return false if we need to skip this file
251 // return true if the field was successfully sanitized
252 [STRIPABSOLUTEPATH](entry, field) {
253 const p = entry[field];
254 const { type } = entry;
255 if (!p || this.preservePaths)
256 return true;
257 // strip off the root
258 const [root, stripped] = (0, strip_absolute_path_js_1.stripAbsolutePath)(p);
259 const parts = stripped.replaceAll(/\\/g, '/').split('/');
260 if (parts.includes('..') ||
261 /* c8 ignore next */
262 (isWindows && /^[a-z]:\.\.$/i.test(parts[0] ?? ''))) {
263 // For linkpath, check if the resolved path escapes cwd rather than
264 // just rejecting any path with '..' - relative symlinks like
265 // '../sibling/file' are valid if they resolve within the cwd.
266 // For paths, they just simply may not ever use .. at all.
267 if (field === 'path' || type === 'Link') {
268 this.warn('TAR_ENTRY_ERROR', `${field} contains '..'`, {
269 entry,
270 [field]: p,
271 });
272 // not ok!
273 return false;
274 }
275 // Resolve linkpath relative to the entry's directory.
276 // `path.posix` is safe to use because we're operating on
277 // tar paths, not a filesystem.
278 const entryDir = node_path_1.default.posix.dirname(entry.path);
279 const resolved = node_path_1.default.posix.normalize(node_path_1.default.posix.join(entryDir, parts.join('/')));
280 // If the resolved path escapes (starts with ..), reject it
281 if (resolved.startsWith('../') || resolved === '..') {
282 this.warn('TAR_ENTRY_ERROR', `${field} escapes extraction directory`, {
283 entry,
284 [field]: p,
285 });
286 return false;
287 }
288 }
289 if (root) {
290 // ok, but triggers warning about stripping root
291 entry[field] = String(stripped);
292 this.warn('TAR_ENTRY_INFO', `stripping ${root} from absolute ${field}`, {
293 entry,
294 [field]: p,
295 });
296 }
297 return true;
298 }
299 // no IO, just string checking for absolute indicators
300 [CHECKPATH](entry) {
301 const p = (0, normalize_windows_path_js_1.normalizeWindowsPath)(entry.path);
302 const parts = p.split('/');
303 if (this.strip) {
304 if (parts.length < this.strip) {
305 return false;
306 }
307 if (entry.type === 'Link') {
308 const linkparts = (0, normalize_windows_path_js_1.normalizeWindowsPath)(String(entry.linkpath)).split('/');
309 if (linkparts.length >= this.strip) {
310 entry.linkpath = linkparts.slice(this.strip).join('/');
311 }
312 else {
313 return false;
314 }
315 }
316 parts.splice(0, this.strip);
317 entry.path = parts.join('/');
318 }
319 if (isFinite(this.maxDepth) && parts.length > this.maxDepth) {
320 this.warn('TAR_ENTRY_ERROR', 'path excessively deep', {
321 entry,
322 path: p,
323 depth: parts.length,
324 maxDepth: this.maxDepth,
325 });
326 return false;
327 }
328 if (!this[STRIPABSOLUTEPATH](entry, 'path') ||
329 !this[STRIPABSOLUTEPATH](entry, 'linkpath')) {
330 return false;
331 }
332 entry.absolute =
333 node_path_1.default.isAbsolute(entry.path) ?
334 (0, normalize_windows_path_js_1.normalizeWindowsPath)(node_path_1.default.resolve(entry.path))
335 : (0, normalize_windows_path_js_1.normalizeWindowsPath)(node_path_1.default.resolve(this.cwd, entry.path));
336 // if we somehow ended up with a path that escapes the cwd, and we are
337 // not in preservePaths mode, then something is fishy! This should have
338 // been prevented above, so ignore this for coverage.
339 /* c8 ignore start - defense in depth */
340 if (!this.preservePaths &&
341 typeof entry.absolute === 'string' &&
342 entry.absolute.indexOf(this.cwd + '/') !== 0 &&
343 entry.absolute !== this.cwd) {
344 this.warn('TAR_ENTRY_ERROR', 'path escaped extraction target', {
345 entry,
346 path: (0, normalize_windows_path_js_1.normalizeWindowsPath)(entry.path),
347 resolvedPath: entry.absolute,
348 cwd: this.cwd,
349 });
350 return false;
351 }
352 /* c8 ignore stop */
353 // an archive can set properties on the extraction directory, but it
354 // may not replace the cwd with a different kind of thing entirely.
355 if (entry.absolute === this.cwd &&
356 entry.type !== 'Directory' &&
357 entry.type !== 'GNUDumpDir') {
358 return false;
359 }
360 // only encode : chars that aren't drive letter indicators
361 if (this.win32) {
362 const { root: aRoot } = node_path_1.default.win32.parse(String(entry.absolute));
363 entry.absolute =
364 aRoot + wc.encode(String(entry.absolute).slice(aRoot.length));
365 const { root: pRoot } = node_path_1.default.win32.parse(entry.path);
366 entry.path = pRoot + wc.encode(entry.path.slice(pRoot.length));
367 }
368 return true;
369 }
370 [ONENTRY](entry) {
371 if (!this[CHECKPATH](entry)) {
372 return entry.resume();
373 }
374 node_assert_1.default.equal(typeof entry.absolute, 'string');
375 switch (entry.type) {
376 case 'Directory':
377 case 'GNUDumpDir':
378 if (entry.mode) {
379 entry.mode = entry.mode | 0o700;
380 }
381 // eslint-disable-next-line no-fallthrough
382 case 'File':
383 case 'OldFile':
384 case 'ContiguousFile':
385 case 'Link':
386 case 'SymbolicLink':
387 return this[CHECKFS](entry);
388 case 'CharacterDevice':
389 case 'BlockDevice':
390 case 'FIFO':
391 default:
392 return this[UNSUPPORTED](entry);
393 }
394 }
395 [ONERROR](er, entry) {
396 // Cwd has to exist, or else nothing works. That's serious.
397 // Other errors are warnings, which raise the error in strict
398 // mode, but otherwise continue on.
399 if (er.name === 'CwdError') {
400 this.emit('error', er);
401 }
402 else {
403 this.warn('TAR_ENTRY_ERROR', er, { entry });
404 this[UNPEND]();
405 entry.resume();
406 }
407 }
408 [MKDIR](dir, mode, cb) {
409 (0, mkdir_js_1.mkdir)((0, normalize_windows_path_js_1.normalizeWindowsPath)(dir), {
410 uid: this.uid,
411 gid: this.gid,
412 processUid: this.processUid,
413 processGid: this.processGid,
414 umask: this.processUmask,
415 preserve: this.preservePaths,
416 unlink: this.unlink,
417 cwd: this.cwd,
418 mode: mode,
419 }, cb);
420 }
421 [DOCHOWN](entry) {
422 // in preserve owner mode, chown if the entry doesn't match process
423 // in set owner mode, chown if setting doesn't match process
424 return (this.forceChown ||
425 (this.preserveOwner &&
426 ((typeof entry.uid === 'number' &&
427 entry.uid !== this.processUid) ||
428 (typeof entry.gid === 'number' &&
429 entry.gid !== this.processGid))) ||
430 (typeof this.uid === 'number' && this.uid !== this.processUid) ||
431 (typeof this.gid === 'number' && this.gid !== this.processGid));
432 }
433 [UID](entry) {
434 return uint32(this.uid, entry.uid, this.processUid);
435 }
436 [GID](entry) {
437 return uint32(this.gid, entry.gid, this.processGid);
438 }
439 [FILE](entry, fullyDone) {
440 const mode = typeof entry.mode === 'number' ? entry.mode & 0o7777 : this.fmode;
441 const stream = new fsm.WriteStream(String(entry.absolute), {
442 // slight lie, but it can be numeric flags
443 flags: (0, get_write_flag_js_1.getWriteFlag)(entry.size),
444 mode: mode,
445 autoClose: false,
446 });
447 stream.on('error', (er) => {
448 if (stream.fd) {
449 node_fs_1.default.close(stream.fd, () => { });
450 }
451 // flush all the data out so that we aren't left hanging
452 // if the error wasn't actually fatal. otherwise the parse
453 // is blocked, and we never proceed.
454 stream.write = () => true;
455 this[ONERROR](er, entry);
456 fullyDone();
457 });
458 let actions = 1;
459 const done = (er) => {
460 if (er) {
461 /* c8 ignore start - we should always have a fd by now */
462 if (stream.fd) {
463 node_fs_1.default.close(stream.fd, () => { });
464 }
465 /* c8 ignore stop */
466 this[ONERROR](er, entry);
467 fullyDone();
468 return;
469 }
470 if (--actions === 0) {
471 if (stream.fd !== undefined) {
472 node_fs_1.default.close(stream.fd, er => {
473 if (er) {
474 this[ONERROR](er, entry);
475 }
476 else {
477 this[UNPEND]();
478 }
479 fullyDone();
480 });
481 }
482 }
483 };
484 stream.on('finish', () => {
485 // if futimes fails, try utimes
486 // if utimes fails, fail with the original error
487 // same for fchown/chown
488 const abs = String(entry.absolute);
489 const fd = stream.fd;
490 if (typeof fd === 'number' && entry.mtime && !this.noMtime) {
491 actions++;
492 const atime = entry.atime || new Date();
493 const mtime = entry.mtime;
494 node_fs_1.default.futimes(fd, atime, mtime, er => er ?
495 node_fs_1.default.utimes(abs, atime, mtime, er2 => done(er2 && er))
496 : done());
497 }
498 if (typeof fd === 'number' && this[DOCHOWN](entry)) {
499 actions++;
500 const uid = this[UID](entry);
501 const gid = this[GID](entry);
502 if (typeof uid === 'number' && typeof gid === 'number') {
503 node_fs_1.default.fchown(fd, uid, gid, er => er ? node_fs_1.default.chown(abs, uid, gid, er2 => done(er2 && er)) : done());
504 }
505 }
506 done();
507 });
508 const tx = this.transform ? this.transform(entry) || entry : entry;
509 if (tx !== entry) {
510 tx.on('error', er => {
511 this[ONERROR](er, entry);
512 fullyDone();
513 });
514 entry.pipe(tx);
515 }
516 tx.pipe(stream);
517 }
518 [DIRECTORY](entry, fullyDone) {
519 const mode = typeof entry.mode === 'number' ? entry.mode & 0o7777 : this.dmode;
520 this[MKDIR](String(entry.absolute), mode, er => {
521 if (er) {
522 this[ONERROR](er, entry);
523 fullyDone();
524 return;
525 }
526 let actions = 1;
527 const done = () => {
528 if (--actions === 0) {
529 fullyDone();
530 this[UNPEND]();
531 entry.resume();
532 }
533 };
534 if (entry.mtime && !this.noMtime) {
535 actions++;
536 node_fs_1.default.utimes(String(entry.absolute), entry.atime || new Date(), entry.mtime, done);
537 }
538 if (this[DOCHOWN](entry)) {
539 actions++;
540 node_fs_1.default.chown(String(entry.absolute), Number(this[UID](entry)), Number(this[GID](entry)), done);
541 }
542 done();
543 });
544 }
545 [UNSUPPORTED](entry) {
546 entry.unsupported = true;
547 this.warn('TAR_ENTRY_UNSUPPORTED', `unsupported entry type: ${entry.type}`, { entry });
548 entry.resume();
549 }
550 [SYMLINK](entry, done) {
551 const parts = (0, normalize_windows_path_js_1.normalizeWindowsPath)(node_path_1.default.relative(this.cwd, node_path_1.default.resolve(node_path_1.default.dirname(String(entry.absolute)), String(entry.linkpath)))).split('/');
552 this[ENSURE_NO_SYMLINK](entry, this.cwd, parts, () => this[LINK](entry, String(entry.linkpath), 'symlink', done), er => {
553 this[ONERROR](er, entry);
554 done();
555 });
556 }
557 [HARDLINK](entry, done) {
558 const linkpath = (0, normalize_windows_path_js_1.normalizeWindowsPath)(node_path_1.default.resolve(this.cwd, String(entry.linkpath)));
559 const parts = (0, normalize_windows_path_js_1.normalizeWindowsPath)(String(entry.linkpath)).split('/');
560 this[ENSURE_NO_SYMLINK](entry, this.cwd, parts, () => this[LINK](entry, linkpath, 'link', done), er => {
561 this[ONERROR](er, entry);
562 done();
563 });
564 }
565 [ENSURE_NO_SYMLINK](entry, cwd, parts, done, onError) {
566 const p = parts.shift();
567 if (this.preservePaths || p === undefined)
568 return done();
569 const t = node_path_1.default.resolve(cwd, p);
570 node_fs_1.default.lstat(t, (er, st) => {
571 if (er)
572 return done();
573 if (st?.isSymbolicLink()) {
574 return onError(new symlink_error_js_1.SymlinkError(t, node_path_1.default.resolve(t, parts.join('/'))));
575 }
576 this[ENSURE_NO_SYMLINK](entry, t, parts, done, onError);
577 });
578 }
579 [PEND]() {
580 this[PENDING]++;
581 }
582 [UNPEND]() {
583 this[PENDING]--;
584 this[MAYBECLOSE]();
585 }
586 [SKIP](entry) {
587 this[UNPEND]();
588 entry.resume();
589 }
590 // Check if we can reuse an existing filesystem entry safely and
591 // overwrite it, rather than unlinking and recreating
592 // Windows doesn't report a useful nlink, so we just never reuse entries
593 [ISREUSABLE](entry, st) {
594 return (entry.type === 'File' &&
595 !this.unlink &&
596 st.isFile() &&
597 st.nlink <= 1 &&
598 !isWindows);
599 }
600 // check if a thing is there, and if so, try to clobber it
601 [CHECKFS](entry) {
602 this[PEND]();
603 const paths = [entry.path];
604 if (entry.linkpath) {
605 paths.push(entry.linkpath);
606 }
607 this.reservations.reserve(paths, done => this[CHECKFS2](entry, done));
608 }
609 [CHECKFS2](entry, fullyDone) {
610 const done = (er) => {
611 fullyDone(er);
612 };
613 const checkCwd = () => {
614 this[MKDIR](this.cwd, this.dmode, er => {
615 if (er) {
616 this[ONERROR](er, entry);
617 done();
618 return;
619 }
620 this[CHECKED_CWD] = true;
621 start();
622 });
623 };
624 const start = () => {
625 if (entry.absolute !== this.cwd) {
626 const parent = (0, normalize_windows_path_js_1.normalizeWindowsPath)(node_path_1.default.dirname(String(entry.absolute)));
627 if (parent !== this.cwd) {
628 return this[MKDIR](parent, this.dmode, er => {
629 if (er) {
630 this[ONERROR](er, entry);
631 done();
632 return;
633 }
634 afterMakeParent();
635 });
636 }
637 }
638 afterMakeParent();
639 };
640 const afterMakeParent = () => {
641 node_fs_1.default.lstat(String(entry.absolute), (lstatEr, st) => {
642 if (st &&
643 (this.keep ||
644 /* c8 ignore next */
645 (this.newer && st.mtime > (entry.mtime ?? st.mtime)))) {
646 this[SKIP](entry);
647 done();
648 return;
649 }
650 if (lstatEr || this[ISREUSABLE](entry, st)) {
651 return this[MAKEFS](null, entry, done);
652 }
653 if (st.isDirectory()) {
654 if (entry.type === 'Directory') {
655 const needChmod = this.chmod && entry.mode && (st.mode & 0o7777) !== entry.mode;
656 const afterChmod = (er) => this[MAKEFS](er ?? null, entry, done);
657 if (!needChmod) {
658 return afterChmod();
659 }
660 return node_fs_1.default.chmod(String(entry.absolute), Number(entry.mode), afterChmod);
661 }
662 // Not a dir entry, have to remove it.
663 // NB: the only way to end up with an entry that is the cwd
664 // itself, in such a way that == does not detect, is a
665 // tricky windows absolute path with UNC or 8.3 parts (and
666 // preservePaths:true, or else it will have been stripped).
667 // In that case, the user has opted out of path protections
668 // explicitly, so if they blow away the cwd, c'est la vie.
669 if (entry.absolute !== this.cwd) {
670 return node_fs_1.default.rmdir(String(entry.absolute), (er) => this[MAKEFS](er ?? null, entry, done));
671 }
672 }
673 // not a dir, and not reusable
674 // don't remove if the cwd, we want that error
675 if (entry.absolute === this.cwd) {
676 return this[MAKEFS](null, entry, done);
677 }
678 unlinkFile(String(entry.absolute), er => this[MAKEFS](er ?? null, entry, done));
679 });
680 };
681 if (this[CHECKED_CWD]) {
682 start();
683 }
684 else {
685 checkCwd();
686 }
687 }
688 [MAKEFS](er, entry, done) {
689 if (er) {
690 this[ONERROR](er, entry);
691 done();
692 return;
693 }
694 switch (entry.type) {
695 case 'File':
696 case 'OldFile':
697 case 'ContiguousFile':
698 return this[FILE](entry, done);
699 case 'Link':
700 return this[HARDLINK](entry, done);
701 case 'SymbolicLink':
702 return this[SYMLINK](entry, done);
703 case 'Directory':
704 case 'GNUDumpDir':
705 return this[DIRECTORY](entry, done);
706 }
707 }
708 [LINK](entry, linkpath, link, done) {
709 node_fs_1.default[link](linkpath, String(entry.absolute), er => {
710 if (er) {
711 this[ONERROR](er, entry);
712 }
713 else {
714 this[UNPEND]();
715 entry.resume();
716 }
717 done();
718 });
719 }
720}
721exports.Unpack = Unpack;
722const callSync = (fn) => {
723 try {
724 return [null, fn()];
725 }
726 catch (er) {
727 return [er, null];
728 }
729};
730class UnpackSync extends Unpack {
731 sync = true;
732 [MAKEFS](er, entry) {
733 return super[MAKEFS](er, entry, () => { });
734 }
735 [CHECKFS](entry) {
736 if (!this[CHECKED_CWD]) {
737 const er = this[MKDIR](this.cwd, this.dmode);
738 if (er) {
739 return this[ONERROR](er, entry);
740 }
741 this[CHECKED_CWD] = true;
742 }
743 // don't bother to make the parent if the current entry is the cwd,
744 // we've already checked it.
745 if (entry.absolute !== this.cwd) {
746 const parent = (0, normalize_windows_path_js_1.normalizeWindowsPath)(node_path_1.default.dirname(String(entry.absolute)));
747 if (parent !== this.cwd) {
748 const mkParent = this[MKDIR](parent, this.dmode);
749 if (mkParent) {
750 return this[ONERROR](mkParent, entry);
751 }
752 }
753 }
754 const [lstatEr, st] = callSync(() => node_fs_1.default.lstatSync(String(entry.absolute)));
755 if (st &&
756 (this.keep ||
757 /* c8 ignore next */
758 (this.newer && st.mtime > (entry.mtime ?? st.mtime)))) {
759 return this[SKIP](entry);
760 }
761 if (lstatEr || this[ISREUSABLE](entry, st)) {
762 return this[MAKEFS](null, entry);
763 }
764 if (st.isDirectory()) {
765 if (entry.type === 'Directory') {
766 const needChmod = this.chmod && entry.mode && (st.mode & 0o7777) !== entry.mode;
767 const [er] = needChmod ?
768 callSync(() => {
769 node_fs_1.default.chmodSync(String(entry.absolute), Number(entry.mode));
770 })
771 : [];
772 return this[MAKEFS](er, entry);
773 }
774 // not a dir entry, have to remove it
775 const [er] = callSync(() => node_fs_1.default.rmdirSync(String(entry.absolute)));
776 this[MAKEFS](er, entry);
777 }
778 // not a dir, and not reusable.
779 // don't remove if it's the cwd, since we want that error.
780 const [er] = entry.absolute === this.cwd ?
781 []
782 : callSync(() => unlinkFileSync(String(entry.absolute)));
783 this[MAKEFS](er, entry);
784 }
785 [FILE](entry, done) {
786 const mode = typeof entry.mode === 'number' ? entry.mode & 0o7777 : this.fmode;
787 const oner = (er) => {
788 let closeError;
789 try {
790 node_fs_1.default.closeSync(fd);
791 }
792 catch (e) {
793 closeError = e;
794 }
795 if (er || closeError) {
796 this[ONERROR](er || closeError, entry);
797 }
798 done();
799 };
800 let fd;
801 try {
802 fd = node_fs_1.default.openSync(String(entry.absolute), (0, get_write_flag_js_1.getWriteFlag)(entry.size), mode);
803 /* c8 ignore start - This is only a problem if the file was successfully
804 * statted, BUT failed to open. Testing this is annoying, and we
805 * already have ample testint for other uses of oner() methods.
806 */
807 }
808 catch (er) {
809 return oner(er);
810 }
811 /* c8 ignore stop */
812 const tx = this.transform ? this.transform(entry) || entry : entry;
813 if (tx !== entry) {
814 tx.on('error', er => this[ONERROR](er, entry));
815 entry.pipe(tx);
816 }
817 tx.on('data', (chunk) => {
818 try {
819 node_fs_1.default.writeSync(fd, chunk, 0, chunk.length);
820 }
821 catch (er) {
822 oner(er);
823 }
824 });
825 tx.on('end', () => {
826 let er = null;
827 // try both, falling futimes back to utimes
828 // if either fails, handle the first error
829 if (entry.mtime && !this.noMtime) {
830 const atime = entry.atime || new Date();
831 const mtime = entry.mtime;
832 try {
833 node_fs_1.default.futimesSync(fd, atime, mtime);
834 }
835 catch (futimeser) {
836 try {
837 node_fs_1.default.utimesSync(String(entry.absolute), atime, mtime);
838 }
839 catch {
840 er = futimeser;
841 }
842 }
843 }
844 if (this[DOCHOWN](entry)) {
845 const uid = this[UID](entry);
846 const gid = this[GID](entry);
847 try {
848 node_fs_1.default.fchownSync(fd, Number(uid), Number(gid));
849 }
850 catch (fchowner) {
851 try {
852 node_fs_1.default.chownSync(String(entry.absolute), Number(uid), Number(gid));
853 }
854 catch {
855 er = er || fchowner;
856 }
857 }
858 }
859 oner(er);
860 });
861 }
862 [DIRECTORY](entry, done) {
863 const mode = typeof entry.mode === 'number' ? entry.mode & 0o7777 : this.dmode;
864 const er = this[MKDIR](String(entry.absolute), mode);
865 if (er) {
866 this[ONERROR](er, entry);
867 done();
868 return;
869 }
870 if (entry.mtime && !this.noMtime) {
871 try {
872 node_fs_1.default.utimesSync(String(entry.absolute), entry.atime || new Date(), entry.mtime);
873 /* c8 ignore next */
874 }
875 catch { }
876 }
877 if (this[DOCHOWN](entry)) {
878 try {
879 node_fs_1.default.chownSync(String(entry.absolute), Number(this[UID](entry)), Number(this[GID](entry)));
880 }
881 catch { }
882 }
883 done();
884 entry.resume();
885 }
886 [MKDIR](dir, mode) {
887 try {
888 return (0, mkdir_js_1.mkdirSync)((0, normalize_windows_path_js_1.normalizeWindowsPath)(dir), {
889 uid: this.uid,
890 gid: this.gid,
891 processUid: this.processUid,
892 processGid: this.processGid,
893 umask: this.processUmask,
894 preserve: this.preservePaths,
895 unlink: this.unlink,
896 cwd: this.cwd,
897 mode: mode,
898 });
899 }
900 catch (er) {
901 return er;
902 }
903 }
904 [ENSURE_NO_SYMLINK](_entry, cwd, parts, done, onError) {
905 if (this.preservePaths || parts.length === 0)
906 return done();
907 let t = cwd;
908 for (const p of parts) {
909 t = node_path_1.default.resolve(t, p);
910 const [er, st] = callSync(() => node_fs_1.default.lstatSync(t));
911 if (er)
912 return done();
913 if (st.isSymbolicLink()) {
914 return onError(new symlink_error_js_1.SymlinkError(t, node_path_1.default.resolve(cwd, parts.join('/'))));
915 }
916 }
917 done();
918 }
919 [LINK](entry, linkpath, link, done) {
920 const linkSync = `${link}Sync`;
921 try {
922 node_fs_1.default[linkSync](linkpath, String(entry.absolute));
923 done();
924 entry.resume();
925 }
926 catch (er) {
927 return this[ONERROR](er, entry);
928 }
929 }
930}
931exports.UnpackSync = UnpackSync;
932//# sourceMappingURL=unpack.js.map