Function readExactFile

packages/storage/src/memory-bundle-io.ts:732–782

(path: string, label: string, maxBytes: number)

}

async function readExactFile(path: string, label: string, maxBytes: number): Promise<Buffer> {
  let metadata;
  try {
    metadata = await lstat(path, { bigint: true });
  } catch (error) {
    if (isNodeError(error, 'ENOENT')) throw error;
    throw memoryBundleIoFailed(`${label} could not be inspected`, error);
  }
  if (!metadata.isFile() || metadata.isSymbolicLink()) {
    throw invalidMemoryDocument(`${label} must be a regular file`);
  }
  if (metadata.size > BigInt(maxBytes)) {
    throw invalidMemoryDocument(`${label} exceeds its ${maxBytes} byte scan limit`);
  }

  const flags =
    process.platform === 'win32'
      ? constants.O_RDONLY
      : constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK;
  let handle: Awaited<ReturnType<typeof open>>;
  try {
    handle = await open(path, flags);
  } catch (error) {
    if (process.platform !== 'win32' && isNodeError(error, 'ELOOP')) {
      throw invalidMemoryDocument(`${label} must not be a symbolic link`, error);
    }
    throw error;
  }
  try {
    const opened = await handle.stat({ bigint: true });
    if (!opened.isFile() || opened.size > BigInt(maxBytes)) {
      throw invalidMemoryDocument(`${label} is not a bounded regular file`);
    }
    const chunks: Buffer[] = [];
    let total = 0;
    for (;;) {
      const remaining = maxBytes + 1 - total;
      if (remaining <= 0) {
        throw invalidMemoryDocument(`${label} exceeds its ${maxBytes} byte scan limit`);
      }
      const buffer = Buffer.allocUnsafe(Math.min(READ_CHUNK_BYTES, remaining));
      const { bytesRead } = await handle.read(buffer, 0, buffer.length, total);
      if (bytesRead === 0) break;
      total += bytesRead;
      chunks.push(buffer.subarray(0, bytesRead));
    }
    return Buffer.concat(chunks, total);
  } finally {
    await handle.close();
  }
}

async function readBackupCandidate(
  directory: DirectoryBinding,