BREAKING(tar/unstable): fix handling of mode, uid, and gid (#6440)

Co-authored-by: Yohe-Am <[email protected]>

Author: BlackAsLight

tar/tar_stream.ts

@@ -68,17 +68,17 @@ type TarStreamInputInternal =
 export interface TarStreamOptions {
   /**
    * An octal literal.
-   * Defaults to 755 for directories and 644 for files.
+   * Defaults to 0o755 for directories and 0o644 for files.
    */
   mode?: number;
   /**
    * An octal literal.
-   * @default {0}
+   * @default {0o0}
    */
   uid?: number;
   /**
    * An octal literal.
-   * @default {0}
+   * @default {0o0}
    */
   gid?: number;
   /**
@@ -208,9 +208,9 @@ export class TarStream implements TransformStream<TarStreamInput, Uint8Array> {
         const header = new Uint8Array(512);
         const size = "size" in chunk ? chunk.size : 0;
         const options: Required<TarStreamOptions> = {
-          mode: typeflag === "5" ? 755 : 644,
-          uid: 0,
-          gid: 0,
+          mode: typeflag === "5" ? 0o755 : 0o644,
+          uid: 0o0,
+          gid: 0o0,
           mtime: Math.floor(Date.now() / 1000),
           uname: "",
           gname: "",
@@ -222,9 +222,9 @@ export class TarStream implements TransformStream<TarStreamInput, Uint8Array> {
         header.set(name); // name
         header.set(
           encoder.encode(
-            options.mode.toString().padStart(6, "0") + " \0" + // mode
-              options.uid.toString().padStart(6, "0") + " \0" + //uid
-              options.gid.toString().padStart(6, "0") + " \0" + // gid
+            options.mode.toString(8).padStart(6, "0") + " \0" + // mode
+              options.uid.toString(8).padStart(6, "0") + " \0" + //uid
+              options.gid.toString(8).padStart(6, "0") + " \0" + // gid
               size.toString(8).padStart(size < 8 ** 11 ? 11 : 12, "0") +
               (size < 8 ** 11 ? " " : "") + // size
               options.mtime.toString(8).padStart(11, "0") + " " + // mtime
@@ -508,21 +508,15 @@ export function assertValidPath(path: string) {
  * ```
  */
 export function assertValidTarStreamOptions(options: TarStreamOptions) {
-  if (
-    options.mode &&
-    (options.mode.toString().length > 6 ||
-      !/^[0-7]*$/.test(options.mode.toString()))
-  ) throw new TypeError("Cannot add to the tar archive: Invalid Mode provided");
-  if (
-    options.uid &&
-    (options.uid.toString().length > 6 ||
-      !/^[0-7]*$/.test(options.uid.toString()))
-  ) throw new TypeError("Cannot add to the tar archive: Invalid UID provided");
-  if (
-    options.gid &&
-    (options.gid.toString().length > 6 ||
-      !/^[0-7]*$/.test(options.gid.toString()))
-  ) throw new TypeError("Cannot add to the tar archive: Invalid GID provided");
+  if (options.mode && (options.mode.toString(8).length > 6)) {
+    throw new TypeError("Cannot add to the tar archive: Invalid Mode provided");
+  }
+  if (options.uid && (options.uid.toString(8).length > 6)) {
+    throw new TypeError("Cannot add to the tar archive: Invalid UID provided");
+  }
+  if (options.gid && (options.gid.toString(8).length > 6)) {
+    throw new TypeError("Cannot add to the tar archive: Invalid GID provided");
+  }
   if (
     options.mtime != undefined &&
     (options.mtime.toString(8).length > 11 ||

tar/tar_stream_test.ts

@@ -204,109 +204,94 @@ Deno.test("parsePath()", async () => {
 Deno.test("validTarStreamOptions()", () => {
   assertValidTarStreamOptions({});
 
-  assertValidTarStreamOptions({ mode: 0 });
+  assertValidTarStreamOptions({ mode: 0o0 });
   assertThrows(
-    () => assertValidTarStreamOptions({ mode: 8 }),
+    () => assertValidTarStreamOptions({ mode: 0o1111111 }),
     TypeError,
-    "Invalid Mode provided",
-  );
-  assertThrows(
-    () => assertValidTarStreamOptions({ mode: 1111111 }),
-    TypeError,
-    "Invalid Mode provided",
+    "Cannot add to the tar archive: Invalid Mode provided",
   );
 
-  assertValidTarStreamOptions({ uid: 0 });
+  assertValidTarStreamOptions({ uid: 0o0 });
   assertThrows(
-    () => assertValidTarStreamOptions({ uid: 8 }),
+    () => assertValidTarStreamOptions({ uid: 0o1111111 }),
     TypeError,
-    "Invalid UID provided",
-  );
-  assertThrows(
-    () => assertValidTarStreamOptions({ uid: 1111111 }),
-    TypeError,
-    "Invalid UID provided",
+    "Cannot add to the tar archive: Invalid UID provided",
   );
 
-  assertValidTarStreamOptions({ gid: 0 });
-  assertThrows(
-    () => assertValidTarStreamOptions({ gid: 8 }),
-    TypeError,
-    "Invalid GID provided",
-  );
+  assertValidTarStreamOptions({ gid: 0o0 });
   assertThrows(
-    () => assertValidTarStreamOptions({ gid: 1111111 }),
+    () => assertValidTarStreamOptions({ gid: 0o1111111 }),
     TypeError,
-    "Invalid GID provided",
+    "Cannot add to the tar archive: Invalid GID provided",
   );
 
-  assertValidTarStreamOptions({ mtime: 0 });
+  assertValidTarStreamOptions({ mtime: 0o0 });
   assertThrows(
     () => assertValidTarStreamOptions({ mtime: NaN }),
     TypeError,
-    "Invalid MTime provided",
+    "Cannot add to the tar archive: Invalid MTime provided",
   );
   assertValidTarStreamOptions({
     mtime: Math.floor(new Date().getTime() / 1000),
   });
   assertThrows(
     () => assertValidTarStreamOptions({ mtime: new Date().getTime() }),
     TypeError,
-    "Invalid MTime provided",
+    "Cannot add to the tar archive: Invalid MTime provided",
   );
 
   assertValidTarStreamOptions({ uname: "" });
   assertValidTarStreamOptions({ uname: "abcdef" });
   assertThrows(
     () => assertValidTarStreamOptions({ uname: "å-abcdef" }),
     TypeError,
-    "Invalid UName provided",
+    "Cannot add to the tar archive: Invalid UName provided",
   );
   assertThrows(
     () => assertValidTarStreamOptions({ uname: "a".repeat(100) }),
     TypeError,
-    "Invalid UName provided",
+    "Cannot add to the tar archive: Invalid UName provided",
   );
 
   assertValidTarStreamOptions({ gname: "" });
   assertValidTarStreamOptions({ gname: "abcdef" });
   assertThrows(
     () => assertValidTarStreamOptions({ gname: "å-abcdef" }),
     TypeError,
-    "Invalid GName provided",
+    "Cannot add to the tar archive: Invalid GName provided",
   );
   assertThrows(
     () => assertValidTarStreamOptions({ gname: "a".repeat(100) }),
     TypeError,
-    "Invalid GName provided",
+    "Cannot add to the tar archive: Invalid GName provided",
   );
 
   assertValidTarStreamOptions({ devmajor: "" });
   assertValidTarStreamOptions({ devmajor: "1234" });
   assertThrows(
     () => assertValidTarStreamOptions({ devmajor: "123456789" }),
     TypeError,
-    "Invalid DevMajor provided",
+    "Cannot add to the tar archive: Invalid DevMajor provided",
   );
 
   assertValidTarStreamOptions({ devminor: "" });
   assertValidTarStreamOptions({ devminor: "1234" });
   assertThrows(
     () => assertValidTarStreamOptions({ devminor: "123456789" }),
     TypeError,
-    "Invalid DevMinor provided",
+    "Cannot add to the tar archive: Invalid DevMinor provided",
   );
 });
 
 Deno.test("TarStream() with invalid options", async () => {
   const readable = ReadableStream.from<TarStreamInput>([
-    { type: "directory", path: "potato", options: { mode: 9 } },
+    { type: "directory", path: "potato", options: { mode: 0o1111111 } },
   ]).pipeThrough(new TarStream());
 
   await assertRejects(
     () => Array.fromAsync(readable),
     TypeError,
-    "Invalid Mode provided",
+    "Cannot add to the tar archive: Invalid Mode provided",
   );
 });
 

tar/untar_stream.ts

@@ -246,9 +246,9 @@ export class UntarStream
       // Decode Header
       let header: OldStyleFormat | PosixUstarFormat = {
         name: decoder.decode(value.subarray(0, 100)).split("\0")[0]!,
-        mode: parseInt(decoder.decode(value.subarray(100, 108 - 2))),
-        uid: parseInt(decoder.decode(value.subarray(108, 116 - 2))),
-        gid: parseInt(decoder.decode(value.subarray(116, 124 - 2))),
+        mode: parseInt(decoder.decode(value.subarray(100, 108)), 8),
+        uid: parseInt(decoder.decode(value.subarray(108, 116)), 8),
+        gid: parseInt(decoder.decode(value.subarray(116, 124)), 8),
         size: parseInt(decoder.decode(value.subarray(124, 136)).trimEnd(), 8),
         mtime: parseInt(decoder.decode(value.subarray(136, 148 - 1)), 8),
         typeflag: decoder.decode(value.subarray(156, 157)),

tar/untar_stream_test.ts

@@ -18,9 +18,9 @@ Deno.test("expandTarArchiveCheckingHeaders", async () => {
       type: "directory",
       path: "./potato",
       options: {
-        mode: 111111,
-        uid: 12,
-        gid: 21,
+        mode: 0o111111,
+        uid: 0o12,
+        gid: 0o21,
         mtime: seconds,
         uname: "potato",
         gname: "cake",
@@ -46,9 +46,9 @@ Deno.test("expandTarArchiveCheckingHeaders", async () => {
   }
   assertEquals(headers, [{
     name: "./potato",
-    mode: 111111,
-    uid: 12,
-    gid: 21,
+    mode: 0o111111,
+    uid: 0o12,
+    gid: 0o21,
     mtime: seconds,
     uname: "potato",
     gname: "cake",
@@ -62,9 +62,9 @@ Deno.test("expandTarArchiveCheckingHeaders", async () => {
     prefix: "",
   }, {
     name: "./text.txt",
-    mode: 644,
-    uid: 0,
-    gid: 0,
+    mode: 0o644,
+    uid: 0o0,
+    gid: 0o0,
     mtime: seconds,
     uname: "",
     gname: "",