Files
logpile/internal/rar5/reader_test.go
T
Mikhail ChusavitinandClaude Opus 5.5 b4b15e58a2 feat(parser): linux-generic content-driven parser and RAR archive support
Field bundles from ad-hoc service scripts (first sample: Giga G894-SD3 .rar
with dmidecode/lscpu/lspci/nvme/lsblk output, no fixed layout). ADL-078:
- linux-generic: recognizes utility output by content, merges records by
  stable key, low detect confidence (20-30) below all vendor parsers
- pciids.LookupByDescription: resolve a textual lspci description back to
  vendor/device IDs and manufacturer/model
- archive: accept .rar via the in-repo internal/rar5 reader (RAR 5 / RAR 7,
  single volume, solid; encrypted, multi-volume, SFX and RAR 4.x rejected),
  same per-file and total limits as tar/zip
- UI: .rar in the upload accept list

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 15:00:38 +03:00

383 lines
11 KiB
Go

package rar5
import (
"bytes"
"errors"
"fmt"
"io"
"os"
"path/filepath"
"testing"
"time"
)
// dumpArchive writes a generated archive to $RAR5_TEST_DUMP_DIR so it can be
// checked against the reference implementation (`unrar t -mt1 <file>`).
func dumpArchive(t *testing.T, archive []byte) {
t.Helper()
dir := os.Getenv("RAR5_TEST_DUMP_DIR")
if dir == "" {
return
}
name := filepath.Join(dir, filepath.Base(t.Name())+".rar")
if err := os.WriteFile(name, archive, 0o600); err != nil {
t.Fatalf("dump archive: %v", err)
}
}
// testText builds deterministic log-like text: mostly short repetitions, plus
// occasional copies of data from far back so matches use long offsets.
func testText(size int) []byte {
words := []string{"error", "link", "width", "speed", "0000:1a:00.0", "DIMM_P0_A0", "Mellanox", "NVMe", "temperature", "serial"}
seed := uint32(42)
next := func(n int) int {
seed = seed*1664525 + 1013904223
return int(seed>>8) % n
}
var out bytes.Buffer
for out.Len() < size {
switch {
case out.Len() > 200_000 && next(40) == 0:
from := out.Len() - 100_000 - next(90_000)
out.Write(bytes.Clone(out.Bytes()[from : from+200+next(400)]))
case next(6) == 0:
fmt.Fprintf(&out, "%08x\n", seed)
default:
out.WriteString(words[next(len(words))])
out.WriteByte(" :\t\n"[next(4)])
}
}
return out.Bytes()[:size]
}
type extracted struct {
header Header
content []byte
}
func readAll(t *testing.T, archive []byte) []extracted {
t.Helper()
r, err := NewReader(bytes.NewReader(archive))
if err != nil {
t.Fatalf("NewReader: %v", err)
}
var out []extracted
for {
h, err := r.Next()
if err == io.EOF {
return out
}
if err != nil {
t.Fatalf("Next: %v", err)
}
content, err := io.ReadAll(r)
if err != nil {
t.Fatalf("read %s: %v", h.Name, err)
}
out = append(out, extracted{header: *h, content: content})
}
}
func TestStoredMembers(t *testing.T) {
mtime := time.Date(2026, 10, 2, 7, 37, 52, 0, time.UTC)
archive := testArchive(0,
testMember{name: "host01", isDir: true},
testMember{name: "host01/System-info.txt", content: []byte("System Information\n"), mtime: mtime},
testMember{name: "host01/empty.txt", content: nil, mtime: mtime.Add(1500 * time.Millisecond), filetime: true},
)
dumpArchive(t, archive)
files := readAll(t, archive)
if len(files) != 3 {
t.Fatalf("expected 3 members, got %d", len(files))
}
if !files[0].header.IsDir || files[0].header.Name != "host01" {
t.Fatalf("unexpected directory entry: %+v", files[0].header)
}
if files[1].header.Name != "host01/System-info.txt" || string(files[1].content) != "System Information\n" ||
files[1].header.UnpackedSize != 19 || !files[1].header.ModTime.Equal(mtime) {
t.Fatalf("unexpected file: %+v %q", files[1].header, files[1].content)
}
if len(files[2].content) != 0 || !files[2].header.ModTime.Equal(mtime.Add(1500*time.Millisecond)) {
t.Fatalf("unexpected FILETIME member: %+v", files[2].header)
}
}
func TestCompressedMember(t *testing.T) {
// Larger than the 256 KiB window, so matches cross the window wrap.
content := testText(900_000)
cases := []struct {
name string
blockLen int
shareTables bool
}{
{name: "large blocks", blockLen: 40000},
{name: "many small blocks", blockLen: 97},
{name: "blocks reusing the first tables", blockLen: 1009, shareTables: true},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
enc := &testEncoder{blockLen: tc.blockLen, shareTables: tc.shareTables}
packed := enc.compress(content, 0, 256<<10)
if len(packed) >= len(content) {
t.Fatalf("test encoder did not compress: %d -> %d", len(content), len(packed))
}
archive := testArchive(0, testMember{name: "log.txt", content: content, packed: packed, dictBits: 1})
dumpArchive(t, archive)
files := readAll(t, archive)
if len(files) != 1 || !bytes.Equal(files[0].content, content) {
t.Fatalf("decoded content differs from the original")
}
})
}
}
func TestCompressedMemberSmallReads(t *testing.T) {
content := testText(300_000)
archive := testArchive(0, testMember{
name: "log.txt", content: content, packed: new(testEncoder).compress(content, 0, 128<<10),
})
r, err := NewReader(iotest{bytes.NewReader(archive)})
if err != nil {
t.Fatalf("NewReader: %v", err)
}
if _, err := r.Next(); err != nil {
t.Fatalf("Next: %v", err)
}
var got bytes.Buffer
buf := make([]byte, 7)
for {
n, err := r.Read(buf)
got.Write(buf[:n])
if err == io.EOF {
break
}
if err != nil {
t.Fatalf("Read: %v", err)
}
}
if !bytes.Equal(got.Bytes(), content) {
t.Fatal("decoded content differs from the original")
}
}
// iotest returns one byte per Read to exercise short reads of the source.
type iotest struct{ r io.Reader }
func (o iotest) Read(p []byte) (int, error) {
if len(p) > 1 {
p = p[:1]
}
return o.r.Read(p)
}
func TestDeltaFilter(t *testing.T) {
// Three interleaved slowly changing channels, like raw sample data.
const channels = 3
content := make([]byte, 30_000)
for i := range content {
content[i] = byte(i/channels/7 + i%channels*40)
}
// Delta-code per channel into planar order: what the decoder undoes.
filtered := make([]byte, 0, len(content))
for c := 0; c < channels; c++ {
var prev byte
for i := c; i < len(content); i += channels {
filtered = append(filtered, prev-content[i])
prev = content[i]
}
}
enc := new(testEncoder)
enc.writeTables()
enc.deltaFilter(len(filtered), channels)
enc.symbols = 1
packed := enc.compressBody(filtered, 0, 128<<10)
archive := testArchive(0, testMember{name: "samples.bin", content: content, packed: packed})
dumpArchive(t, archive)
files := readAll(t, archive)
if len(files) != 1 || !bytes.Equal(files[0].content, content) {
t.Fatal("delta-filtered content differs from the original")
}
}
func solidArchive() (archive []byte, first, second []byte) {
all := testText(500_000)
first, second = all[:300_000], all[300_000:]
enc := new(testEncoder)
packedFirst := enc.compress(first, 0, 512<<10)
packedSecond := enc.compress(all, len(first), 512<<10)
archive = testArchive(archiveIsSolid,
testMember{name: "a.txt", content: first, packed: packedFirst, dictBits: 2},
testMember{name: "b.txt", content: second, packed: packedSecond, dictBits: 2, solid: true},
)
return archive, first, second
}
func TestSolidArchive(t *testing.T) {
archive, first, second := solidArchive()
dumpArchive(t, archive)
files := readAll(t, archive)
if len(files) != 2 || !bytes.Equal(files[0].content, first) || !bytes.Equal(files[1].content, second) {
t.Fatal("solid archive content differs from the original")
}
}
// The second file of a solid archive depends on the first one being decoded,
// even when the caller never reads it.
func TestSolidArchiveSkippedMember(t *testing.T) {
archive, _, second := solidArchive()
r, err := NewReader(bytes.NewReader(archive))
if err != nil {
t.Fatalf("NewReader: %v", err)
}
if _, err := r.Next(); err != nil {
t.Fatalf("Next: %v", err)
}
h, err := r.Next()
if err != nil || h.Name != "b.txt" {
t.Fatalf("Next: %v %+v", err, h)
}
got, err := io.ReadAll(r)
if err != nil || !bytes.Equal(got, second) {
t.Fatalf("skipping a solid member broke the next one: %v", err)
}
}
func TestSkippedMembers(t *testing.T) {
content := testText(50_000)
archive := testArchive(0,
testMember{name: "skip-compressed.txt", content: content, packed: new(testEncoder).compress(content, 0, 128<<10)},
testMember{name: "skip-stored.txt", content: content},
testMember{name: "link", content: nil, extra: append(testVint(2), append(testVint(extraRedirection), 0)...)},
testMember{name: "wanted.txt", content: []byte("wanted")},
)
r, err := NewReader(bytes.NewReader(archive))
if err != nil {
t.Fatalf("NewReader: %v", err)
}
var names []string
var last []byte
for {
h, err := r.Next()
if err == io.EOF {
break
}
if err != nil {
t.Fatalf("Next: %v", err)
}
names = append(names, h.Name)
if h.Name == "wanted.txt" {
if last, err = io.ReadAll(r); err != nil {
t.Fatalf("read: %v", err)
}
}
}
if fmt.Sprint(names) != "[skip-compressed.txt skip-stored.txt wanted.txt]" || string(last) != "wanted" {
t.Fatalf("unexpected members %v, content %q", names, last)
}
}
func TestRejectedArchives(t *testing.T) {
stored := testMember{name: "a.txt", content: []byte("content")}
encrypted := stored
encrypted.extra = append(testVint(2), append(testVint(extraEncryption), 0)...)
split := stored
split.flags = headerSplitAfter
headerEncrypted := append([]byte(signature), testBlock(bytes.Join([][]byte{testVint(blockEncryption), testVint(0), testVint(0)}, nil))...)
cases := []struct {
name string
archive []byte
want error
}{
{name: "not an archive", archive: []byte("PK\x03\x04 this is a zip"), want: ErrNotRAR},
{name: "empty input", archive: nil, want: ErrNotRAR},
{name: "RAR 4 archive", archive: []byte("Rar!\x1a\x07\x00\xcf\x90\x73\x00\x00\x0d\x00"), want: ErrLegacyFormat},
{name: "encrypted file", archive: testArchive(0, encrypted), want: ErrEncrypted},
{name: "encrypted headers", archive: headerEncrypted, want: ErrEncrypted},
{name: "volume of a multi-volume set", archive: testArchive(archiveIsVolume, stored), want: ErrMultiVolume},
{name: "file split across volumes", archive: testArchive(0, split), want: ErrMultiVolume},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
r, err := NewReader(bytes.NewReader(tc.archive))
if err == nil {
_, err = r.Next()
}
if !errors.Is(err, tc.want) {
t.Fatalf("got error %v, want %v", err, tc.want)
}
})
}
}
func TestCorruptArchives(t *testing.T) {
content := testText(20_000)
packed := new(testEncoder).compress(content, 0, 128<<10)
good := testArchive(0, testMember{name: "a.txt", content: content, packed: packed})
flipped := bytes.Clone(good)
flipped[len(flipped)-200] ^= 0x10 // inside the compressed data
badHeader := bytes.Clone(good)
badHeader[len(signature)+5] ^= 0xff // inside the main archive header
cases := []struct {
name string
archive []byte
}{
{name: "wrong file checksum", archive: testArchive(0, testMember{name: "a.txt", content: []byte("content"), badCRC: true})},
{name: "damaged compressed data", archive: flipped},
{name: "truncated archive", archive: good[:len(good)-300]},
{name: "damaged block header", archive: badHeader},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
r, err := NewReader(bytes.NewReader(tc.archive))
if err != nil {
t.Fatalf("NewReader: %v", err)
}
if _, err = r.Next(); err == nil {
_, err = io.ReadAll(r)
}
if err == nil {
t.Fatal("expected an error")
}
})
}
}
// Arbitrary damage must surface as an error, never as a panic or a hang.
func TestDamagedDataNeverPanics(t *testing.T) {
content := testText(20_000)
good := testArchive(0, testMember{
name: "a.txt", content: content, packed: new(testEncoder).compress(content, 0, 128<<10),
})
dataStart := bytes.Index(good, []byte("a.txt")) + len("a.txt")
seed := uint32(7)
for i := 0; i < 400; i++ {
seed = seed*1664525 + 1013904223
damaged := bytes.Clone(good)
pos := dataStart + int(seed>>8)%(len(good)-dataStart-20)
damaged[pos] ^= byte(seed>>3) | 1
r, err := NewReader(bytes.NewReader(damaged))
if err != nil {
continue
}
if _, err := r.Next(); err != nil {
continue
}
io.Copy(io.Discard, io.LimitReader(r, 1<<20))
}
}