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