@push.rocks/smartlinuxrepo 1.1.2 → 1.2.0

package/ts/readers/document.ts

@@ -0,0 +1,136 @@
+import { LinuxRepoError, limitExceeded } from '../shared/errors.js';
+import type { ILinuxPackageLimits } from '../shared/limits.js';
+import type { TLinuxCompression } from '../shared/types.js';
+import { assertBytes } from '../shared/validation.js';
+import { BufferReader, READ_CHUNK_BYTES } from './bytes.js';
+import { withDecompressingReader } from './decompress.js';
+
+/**
+ * The shared parts of the index readers (1.2.0): decoding one index document
+ * into a buffer the reader owns, and the line lexer of the line formats
+ * (Debian `Packages` and `Release`, `APKINDEX`).
+ */
+
+const COMPRESSIONS: ReadonlySet<string> = new Set<TLinuxCompression>(['none', 'gzip', 'xz', 'zstd']);
+const LF = 0x0a;
+
+/** Refuses a reader argument that is not an object (`invalid-input`, `input`). */
+export function assertReaderInput(inputArg: unknown): asserts inputArg is Record<string, unknown> {
+  if (inputArg === null || typeof inputArg !== 'object') {
+    throw new LinuxRepoError('invalid-input', 'input must be an object', { field: 'input' });
+  }
+}
+
+/** Refuses a `bytes` argument that is not a `Uint8Array` (`invalid-input`, `bytes`). */
+export function assertReaderBytes(valueArg: unknown): asserts valueArg is Uint8Array {
+  assertBytes(valueArg, 'bytes');
+}
+
+/** Refuses a compression that is not a `TLinuxCompression` (`invalid-input`, `compression`). */
+export function assertLinuxCompression(valueArg: unknown): asserts valueArg is TLinuxCompression {
+  if (typeof valueArg !== 'string' || !COMPRESSIONS.has(valueArg)) {
+    throw new LinuxRepoError('invalid-input', "compression must be 'none', 'gzip', 'xz' or 'zstd'", {
+      field: 'compression',
+      value: typeof valueArg === 'string' ? valueArg : typeof valueArg,
+    });
+  }
+}
+
+/**
+ * Decodes one index document into a new buffer the reader owns, through
+ * `withDecompressingReader` for every compression (`'none'` passes the input
+ * through and copies it), bounded by `maxIndexBytes`. The decoder's own
+ * mapping applies: a stream that ends early is `truncated`, corrupt data
+ * `malformed-archive`, output past the bound `limit-exceeded`
+ * (`maxIndexBytes`). The result never aliases `bytesArg`.
+ */
+export async function readIndexDocument(
+  bytesArg: Uint8Array,
+  compressionArg: TLinuxCompression,
+  limitsArg: Readonly<ILinuxPackageLimits>,
+): Promise<Uint8Array> {
+  if (compressionArg === 'none' && bytesArg.length > limitsArg.maxIndexBytes) {
+    throw limitExceeded('maxIndexBytes', limitsArg.maxIndexBytes, 'index document');
+  }
+  const chunks: Uint8Array[] = [];
+  let total = 0;
+  await withDecompressingReader(
+    new BufferReader(bytesArg),
+    compressionArg,
+    { maxOutputBytes: limitsArg.maxIndexBytes, outputLimit: 'maxIndexBytes', maxZstdFrames: limitsArg.maxEntries },
+    async (readerArg) => {
+      for (let chunk = await readerArg.read(READ_CHUNK_BYTES); chunk !== null; chunk = await readerArg.read(READ_CHUNK_BYTES)) {
+        chunks.push(chunk);
+        total += chunk.length;
+      }
+    },
+  );
+  const decoded = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    decoded.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return decoded;
+}
+
+/** One line of a line-format document: `[start, end)` without its LF, which sits at `end`. */
+export interface ILine {
+  readonly start: number;
+  readonly end: number;
+}
+
+/**
+ * The common line lexer of the line formats: lines end in LF and the last
+ * line must have one too (`malformed-index`, `detail.value` the offset of
+ * the unterminated line); a line longer than `maxHeaderBytes` (without its
+ * LF) is `limit-exceeded`. CR is an ordinary byte; nothing is trimmed. An
+ * empty document has no lines.
+ */
+export function* lines(bytesArg: Uint8Array, maxLineBytesArg: number, whatArg: string): Generator<ILine> {
+  let start = 0;
+  while (start < bytesArg.length) {
+    const end = bytesArg.indexOf(LF, start);
+    if (end < 0) {
+      if (bytesArg.length - start > maxLineBytesArg) {
+        throw limitExceeded('maxHeaderBytes', maxLineBytesArg, `${whatArg} line`);
+      }
+      throw new LinuxRepoError('malformed-index', `the last line of the ${whatArg} has no line feed`, {
+        field: whatArg,
+        value: start,
+      });
+    }
+    if (end - start > maxLineBytesArg) {
+      throw limitExceeded('maxHeaderBytes', maxLineBytesArg, `${whatArg} line`);
+    }
+    yield { start, end };
+    start = end + 1;
+  }
+}
+
+/** True when the line holds only spaces or tabs (at least one). */
+export function isBlankLine(bytesArg: Uint8Array, lineArg: ILine): boolean {
+  if (lineArg.end === lineArg.start) {
+    return false;
+  }
+  for (let i = lineArg.start; i < lineArg.end; i++) {
+    if (bytesArg[i] !== 0x20 && bytesArg[i] !== 0x09) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/** Counts one more unit of a document against `maxEntries`. */
+export function countUnit(countArg: number, limitsArg: Readonly<ILinuxPackageLimits>, whatArg: string): void {
+  if (countArg > limitsArg.maxEntries) {
+    throw limitExceeded('maxEntries', limitsArg.maxEntries, `${whatArg} count`);
+  }
+}
+
+/** Refuses one unit larger than `maxMetadataBytes`. */
+export function checkUnitBytes(lengthArg: number, limitsArg: Readonly<ILinuxPackageLimits>, whatArg: string): void {
+  if (lengthArg > limitsArg.maxMetadataBytes) {
+    throw limitExceeded('maxMetadataBytes', limitsArg.maxMetadataBytes, whatArg);
+  }
+}

package/ts/rpm/repodata.ts

@@ -23,9 +23,10 @@ import { element, textElement, XML_HEADER } from './xml.js';
  * createrepo_c 1.2.6 `cr_is_primary` (`src/misc.h:111-119`): paths under
  * `/etc/`, exactly `/usr/lib/sendmail`, or containing `bin/` anywhere. It is
  * applied to every file entry, directories and ghosts included
- * (`src/xml_dump.c:206`).
+ * (`src/xml_dump.c:206`). `buildRpmIndex` lists such files in `primary`
+ * besides the executable ones, where Gitea lists only the executable ones.
  */
-export function isPrimaryPath(pathArg: string): boolean {
+export function isRpmPrimaryPath(pathArg: string): boolean {
   return pathArg.startsWith('/etc/') || pathArg === '/usr/lib/sendmail' || pathArg.includes('bin/');
 }
 
@@ -128,7 +129,7 @@ export function renderRepomd(dataArg: IRepomdData[]): string {
 
 function renderPrimaryPackage(recordArg: IRpmPackageRecord): string {
   const metadata = recordArg.metadata;
-  const files = metadata.files.filter((file) => file.isExecutable || isPrimaryPath(file.path));
+  const files = metadata.files.filter((file) => file.isExecutable || isRpmPrimaryPath(file.path));
   return element(
     'package',
     [['type', 'rpm']],