chore: switched Buffer usage to Uint8Arrays

Author: aryanjassal

src/Generator.ts

@@ -5,21 +5,20 @@ import * as utils from './utils';
 import * as constants from './constants';
 
 // Computes the checksum by summing up all the bytes in the header
-function computeChecksum(header: Buffer): number {
-  if (!header.subarray(148, 156).every((byte) => byte === 32)) {
+function computeChecksum(header: Uint8Array): number {
+  if (!header.slice(148, 156).every((byte) => byte === 32)) {
     throw new errors.ErrorVirtualTarInvalidHeader(
       'Checksum field is not properly initialized with spaces',
     );
   }
   return header.reduce((sum, byte) => sum + byte, 0);
 }
 
-// TODO: Should logging be included?
 function createHeader(
   filePath: string,
   stat: FileStat,
   type: EntryType,
-): Buffer {
+): Uint8Array {
   // TODO: implement long-file-name headers
   if (filePath.length < 1 || filePath.length > 255) {
     throw new errors.ErrorVirtualTarInvalidFileName(
@@ -48,7 +47,7 @@ function createHeader(
 
   // Make sure to initialise the header with zeros to avoid writing nullish
   // blocks.
-  const header = Buffer.alloc(constants.BLOCK_SIZE, 0);
+  const header = new Uint8Array(constants.BLOCK_SIZE);
 
   // The TAR headers follow this structure
   // Start    Size    Description
@@ -71,97 +70,95 @@ function createHeader(
   // 345      155     File name (last 155 bytes, total 255 bytes, null-padded)
   // 500      12      '\0' (unused)
   //
-  // Note that all values are in ASCII format, which is different from the
-  // default formatting of UTF-8 for Buffer.write(). All numbers are also in
-  // octal format as opposed to decimal or hexadecimal.
+  // Note that all numbers are in stringified octal format.
 
   // The first half of the file name (upto 100 bytes) is stored here.
-  header.write(
+  utils.writeBytesToArray(
+    header,
     utils.splitFileName(filePath, 0, HeaderSize.FILE_NAME),
     HeaderOffset.FILE_NAME,
     HeaderSize.FILE_NAME,
-    constants.TEXT_ENCODING,
   );
 
   // The file permissions, or the mode, is stored in the next chunk. This is
   // stored in an octal number format.
-  header.write(
+  utils.writeBytesToArray(
+    header,
     utils.pad(stat.mode ?? '', HeaderSize.FILE_MODE, '0', '\0'),
     HeaderOffset.FILE_MODE,
     HeaderSize.FILE_MODE,
-    constants.TEXT_ENCODING,
   );
 
   // The owner UID is stored in this chunk
-  header.write(
+  utils.writeBytesToArray(
+    header,
     utils.pad(stat.uid ?? '', HeaderSize.OWNER_UID, '0', '\0'),
     HeaderOffset.OWNER_UID,
     HeaderSize.OWNER_UID,
-    constants.TEXT_ENCODING,
   );
 
   // The owner GID is stored in this chunk
-  header.write(
+  utils.writeBytesToArray(
+    header,
     utils.pad(stat.gid ?? '', HeaderSize.OWNER_GID, '0', '\0'),
     HeaderOffset.OWNER_GID,
     HeaderSize.OWNER_GID,
-    constants.TEXT_ENCODING,
   );
 
   // The file size is stored in this chunk. The file size must be zero for
   // directories, and it must be set for files.
-  header.write(
+  utils.writeBytesToArray(
+    header,
     utils.pad(size ?? '', HeaderSize.FILE_SIZE, '0', '\0'),
     HeaderOffset.FILE_SIZE,
     HeaderSize.FILE_SIZE,
-    constants.TEXT_ENCODING,
   );
 
   // The file mtime is stored in this chunk. As the mtime is not modified when
   // extracting a TAR file, the mtime can be preserved while still getting
   // deterministic archives.
-  header.write(
+  utils.writeBytesToArray(
+    header,
     utils.pad(time, HeaderSize.FILE_MTIME, '0', '\0'),
     HeaderOffset.FILE_MTIME,
     HeaderSize.FILE_MTIME,
-    constants.TEXT_ENCODING,
   );
 
   // The checksum is calculated as the sum of all bytes in the header. It is
   // padded using ASCII spaces, as we currently don't have all the data yet.
-  header.write(
+  utils.writeBytesToArray(
+    header,
     utils.pad('', HeaderSize.CHECKSUM, ' '),
     HeaderOffset.CHECKSUM,
     HeaderSize.CHECKSUM,
-    constants.TEXT_ENCODING,
   );
 
   // The type of file is written as a single byte in the header.
-  header.write(
+  utils.writeBytesToArray(
+    header,
     type,
     HeaderOffset.TYPE_FLAG,
     HeaderSize.TYPE_FLAG,
-    constants.TEXT_ENCODING,
   );
 
   // File owner name will be null, as regular stat-ing cannot extract that
   // information.
 
   // This value is the USTAR magic string which makes this file appear as
   // a tar file. Without this, the file cannot be parsed and extracted.
-  header.write(
+  utils.writeBytesToArray(
+    header,
     constants.USTAR_NAME,
     HeaderOffset.USTAR_NAME,
     HeaderSize.USTAR_NAME,
-    constants.TEXT_ENCODING,
   );
 
   // This chunk stores the version of USTAR, which is '00' in this case.
-  header.write(
+  utils.writeBytesToArray(
+    header,
     constants.USTAR_VERSION,
     HeaderOffset.USTAR_VERSION,
     HeaderSize.USTAR_VERSION,
-    constants.TEXT_ENCODING,
   );
 
   // Owner user name will be null, as regular stat-ing cannot extract this
@@ -178,15 +175,15 @@ function createHeader(
 
   // The second half of the file name is entered here. This chunk handles file
   // names ranging 100 to 255 characters.
-  header.write(
+  utils.writeBytesToArray(
+    header,
     utils.splitFileName(
       filePath,
       HeaderSize.FILE_NAME,
       HeaderSize.FILE_NAME_EXTRA,
     ),
     HeaderOffset.FILE_NAME_EXTRA,
     HeaderSize.FILE_NAME_EXTRA,
-    constants.TEXT_ENCODING,
   );
 
   // Updating with the new checksum
@@ -195,11 +192,11 @@ function createHeader(
   // Note the extra space in the padding for the checksum value. It is
   // intentionally placed there. The padding for checksum is ASCII spaces
   // instead of null, which is why it is used like this here.
-  header.write(
+  utils.writeBytesToArray(
+    header,
     utils.pad(checksum, HeaderSize.CHECKSUM, '0', '\0 '),
     HeaderOffset.CHECKSUM,
     HeaderSize.CHECKSUM,
-    constants.TEXT_ENCODING,
   );
 
   return header;
@@ -209,7 +206,10 @@ function createHeader(
 // bytes filled with nulls. This aligns with the tar end-of-archive marker
 // being two null-filled blocks.
 function generateEndMarker() {
-  return [Buffer.alloc(512, 0), Buffer.alloc(512, 0)];
+  return [
+    new Uint8Array(constants.BLOCK_SIZE),
+    new Uint8Array(constants.BLOCK_SIZE),
+  ];
 }
 
 export { createHeader, generateEndMarker };

src/Parser.ts

@@ -8,15 +8,14 @@ class Parser {
   protected state: ParserState = 'ready';
   protected remainingBytes = 0;
 
-  write(data: ArrayBuffer): Header | Data | End | undefined {
+  write(data: Uint8Array): Header | Data | End | undefined {
     if (data.byteLength !== constants.BLOCK_SIZE) {
       throw new errors.ErrorVirtualTarBlockSize(
         `Expected block size ${constants.BLOCK_SIZE} but received ${data.byteLength}`,
       );
     }
 
-    // TODO: test if the first block is header by checking magic value
-    const view = new DataView(data, 0, constants.BLOCK_SIZE);
+    const view = new DataView(data.buffer, 0, constants.BLOCK_SIZE);
 
     switch (this.state) {
       case 'ready': {
@@ -53,23 +52,23 @@ class Parser {
           HeaderOffset.OWNER_UID,
           HeaderSize.OWNER_UID,
         );
-        const ownerName = utils.extractChars(
+        const ownerName = utils.extractString(
           view,
           HeaderOffset.OWNER_NAME,
           HeaderSize.OWNER_NAME,
         );
-        const ownerGroupName = utils.extractChars(
+        const ownerGroupName = utils.extractString(
           view,
           HeaderOffset.OWNER_GROUPNAME,
           HeaderSize.OWNER_GROUPNAME,
         );
-        const ownerUserName = utils.extractChars(
+        const ownerUserName = utils.extractString(
           view,
           HeaderOffset.OWNER_USERNAME,
           HeaderSize.OWNER_USERNAME,
         );
         const fileType =
-          utils.extractChars(
+          utils.extractString(
             view,
             HeaderOffset.TYPE_FLAG,
             HeaderSize.TYPE_FLAG,

src/constants.ts

@@ -1,4 +1,3 @@
 export const BLOCK_SIZE = 512;
 export const USTAR_NAME = 'ustar\0';
 export const USTAR_VERSION = '00';
-export const TEXT_ENCODING = 'ascii';

src/utils.ts

@@ -36,7 +36,16 @@ function dateToUnixTime(date: Date): number {
 
 // PARSER
 
-const decoder = new TextDecoder(constants.TEXT_ENCODING);
+const decoder = new TextDecoder('ascii');
+
+// WARN: redundant?
+function dataViewToUint8Array(dataView: DataView): Uint8Array {
+  return new Uint8Array(
+    dataView.buffer,
+    dataView.byteOffset,
+    dataView.byteLength,
+  );
+}
 
 function extractBytes(
   view: DataView,
@@ -46,7 +55,7 @@ function extractBytes(
   return new Uint8Array(view.buffer, offset, length);
 }
 
-function extractChars(
+function extractString(
   view: DataView,
   offset?: number,
   length?: number,
@@ -61,17 +70,17 @@ function extractOctal(
   offset?: number,
   length?: number,
 ): number {
-  const value = extractChars(view, offset, length);
+  const value = extractString(view, offset, length);
   return value.length > 0 ? parseInt(value, 8) : 0;
 }
 
 function parseFileName(view: DataView) {
-  const fileNameLower = extractChars(
+  const fileNameLower = extractString(
     view,
     HeaderOffset.FILE_NAME,
     HeaderSize.FILE_NAME,
   );
-  const fileNameUpper = extractChars(
+  const fileNameUpper = extractString(
     view,
     HeaderOffset.FILE_NAME_EXTRA,
     HeaderSize.FILE_NAME_EXTRA,
@@ -86,14 +95,37 @@ function checkNullView(view: DataView): boolean {
   return true;
 }
 
+function writeBytesToArray(
+  array: Uint8Array,
+  bytes: string | ArrayLike<number>,
+  offset: number,
+  length: number,
+): number {
+  // Ensure indices are within valid bounds
+  const start = Math.max(0, Math.min(offset, array.length));
+  const end = Math.min(array.length, start + Math.max(0, length));
+  const maxLength = end - start;
+
+  let i = 0;
+  for (; i < bytes.length && i < maxLength; i++) {
+    array[start + i] =
+      typeof bytes === 'string' ? bytes.charCodeAt(i) : bytes[i];
+  }
+
+  // Return number of bytes written
+  return i;
+}
+
 export {
   never,
   pad,
   splitFileName,
   dateToUnixTime,
+  dataViewToUint8Array,
   extractBytes,
-  extractChars,
+  extractString,
   extractOctal,
   parseFileName,
   checkNullView,
+  writeBytesToArray,
 };

tests/index.test.ts

@@ -6,15 +6,15 @@ import Parser from '@/Parser';
 import { EntryType } from '@/types';
 
 // TODO: actually write tests
-describe('index', () => {
-  test('test', async () => {
+describe('local test', () => {
+  test('gen', async () => {
     if (process.env['CI'] != null) {
       // Skip this test if on CI
       expect(true).toEqual(true);
     } else {
       // Otherwise, run the test which creates a test archive
 
-      const walkDir = async (walkPath: string, tokens: Array<Buffer>) => {
+      const walkDir = async (walkPath: string, tokens: Array<Uint8Array>) => {
         const dirContent = await fs.promises.readdir(walkPath);
 
         for (const dirPath of dirContent) {
@@ -78,19 +78,19 @@ describe('index', () => {
       ).toResolve();
     }
   }, 60000);
-  test.only('parsing', async () => {
-    if (process.env['CI']) expect(true).toBeTruthy();
+  test('parsing', async () => {
+    if (process.env['CI'] != null) expect(true).toBeTruthy();
     const file = '/home/aryanj/Downloads/dir/archive.tar';
 
     const fileHandle = await fs.promises.open(file, 'r');
-    const buffer = Buffer.alloc(512, 0);
+    const buffer = new Uint8Array(512);
     const parser = new Parser();
     let writeHandle: fs.promises.FileHandle | undefined = undefined;
     const root = '/home/aryanj/Downloads/dir';
 
     while (true) {
       await fileHandle.read(buffer);
-      const output = parser.write(buffer.buffer);
+      const output = parser.write(buffer);
 
       if (output == null) continue;
 
@@ -117,7 +117,5 @@ describe('index', () => {
       }
     }
     await fileHandle.close();
-    // Console.log(output);
-    // expect(output).toBeObject();
   });
 });