Support validating sof-bin against Debian (.deb) and RPM (.rpm) packages

Author: lrgirdwo

README.md

@@ -122,6 +122,15 @@ sudo ./validate_sof_install.py --version v2.14.1 --platform tgl --fix
 # Validate an offline rootfs (e.g. PXE NFS mount)
 ./validate_sof_install.py --version v2.12 --platform tgl --target-root /srv/nfs/spider-rootfs
 
+# Validate Debian (.deb) package against SOF v2.14.1
+./validate_sof_install.py --deb firmware-sof-signed_2.14.1_all.deb --version v2.14.1
+
+# Validate RPM (.rpm) package against SOF v2.14.1
+./validate_sof_install.py --rpm alsa-sof-firmware-2.14.1.rpm --version v2.14.1
+
+# Auto-identify SOF release versions inside a package archive
+./validate_sof_install.py --pkg firmware-sof-signed.deb --identify
+
 # Generate a standalone md5sum manifest
 ./validate_sof_install.py --version v2.14.1 --generate-md5 /tmp/v2.14.1-md5.txt
 ```

tests/test_validate_sof_install.py

@@ -475,5 +475,234 @@ def test_format_fix_record_transitions(self):
         self.assertTrue(any("Manifest: Host (missing) -> Expected [ver v2.14.1, built 2025-12-18]" in l for l in lines_missing))
 
 
+class TestPackageValidation(unittest.TestCase):
+    """Test Debian (.deb) and RPM (.rpm) package extraction, inspection, and validation."""
+
+    def setUp(self):
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.base = Path(self.temp_dir.name)
+
+    def tearDown(self):
+        self.temp_dir.cleanup()
+
+    def _build_test_deb(self, data_files: Dict[str, bytes], control_fields: Dict[str, str], out_path: Path) -> Path:
+        """Create a standard Debian .deb package (ar archive containing debian-binary, control.tar.gz, data.tar.gz)."""
+        import io
+        import tarfile
+
+        # 1. debian-binary
+        deb_bin = b"2.0\n"
+
+        # 2. control.tar.gz
+        ctrl_buf = io.BytesIO()
+        with tarfile.open(fileobj=ctrl_buf, mode="w:gz") as tar:
+            ctrl_text = "".join(f"{k}: {v}\n" for k, v in control_fields.items()).encode("utf-8")
+            ti = tarfile.TarInfo(name="control")
+            ti.size = len(ctrl_text)
+            ti.mode = 0o644
+            tar.addfile(ti, io.BytesIO(ctrl_text))
+        ctrl_data = ctrl_buf.getvalue()
+
+        # 3. data.tar.gz
+        data_buf = io.BytesIO()
+        with tarfile.open(fileobj=data_buf, mode="w:gz") as tar:
+            for rel_path, content in data_files.items():
+                ti = tarfile.TarInfo(name=rel_path)
+                ti.size = len(content)
+                ti.mode = 0o644
+                tar.addfile(ti, io.BytesIO(content))
+        data_bytes = data_buf.getvalue()
+
+        def make_ar_member(name: str, payload: bytes) -> bytes:
+            hdr = f"{name:<16}{1700000000:<12}{0:<6}{0:<6}{100644:<8}{len(payload):<10}\x60\n".encode("ascii")
+            pad = b"\n" if len(payload) % 2 == 1 else b""
+            return hdr + payload + pad
+
+        ar_data = b"!<arch>\n"
+        ar_data += make_ar_member("debian-binary", deb_bin)
+        ar_data += make_ar_member("control.tar.gz", ctrl_data)
+        ar_data += make_ar_member("data.tar.gz", data_bytes)
+
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        out_path.write_bytes(ar_data)
+        return out_path
+
+    def test_extract_deb_package(self):
+        from validate_sof_install import extract_deb
+
+        deb_path = self.base / "firmware-sof-signed_2.14.1_all.deb"
+        self._build_test_deb(
+            data_files={
+                "lib/firmware/intel/sof-ipc4/tgl/community/sof-tgl.ri": b"TEST_TGL_FW_DATA",
+                "lib/firmware/intel/sof-ipc4-tplg/sof-tgl-nocodec.tplg": b"TEST_TPLG_DATA",
+            },
+            control_fields={
+                "Package": "firmware-sof-signed",
+                "Version": "2.14.1-1",
+                "Architecture": "all",
+                "Description": "Sound Open Firmware binary release",
+            },
+            out_path=deb_path,
+        )
+
+        dest_dir = self.base / "extracted_deb"
+        dest_dir.mkdir()
+        meta = extract_deb(deb_path, dest_dir)
+
+        self.assertEqual(meta.get("package"), "firmware-sof-signed")
+        self.assertEqual(meta.get("version"), "2.14.1-1")
+        self.assertEqual(meta.get("architecture"), "all")
+
+        extracted_files = [str(p.relative_to(dest_dir)) for p in dest_dir.rglob("*") if p.is_file()]
+        self.assertIn("lib/firmware/intel/sof-ipc4/tgl/community/sof-tgl.ri", extracted_files)
+        self.assertIn("lib/firmware/intel/sof-ipc4-tplg/sof-tgl-nocodec.tplg", extracted_files)
+
+    def test_collect_packages(self):
+        from validate_sof_install import collect_packages
+
+        deb1 = self.base / "pkg1.deb"
+        deb2 = self.base / "pkg2.deb"
+        deb1.write_bytes(b"dummy1")
+        deb2.write_bytes(b"dummy2")
+
+        # Comma-separated list
+        res = collect_packages([f"{deb1},{deb2}"])
+        self.assertEqual(res, [deb1.resolve(), deb2.resolve()])
+
+        # Directory containing packages
+        pkg_dir = self.base / "pkgs"
+        pkg_dir.mkdir()
+        (pkg_dir / "a.deb").write_bytes(b"a")
+        (pkg_dir / "b.rpm").write_bytes(b"b")
+
+        dir_res = collect_packages([str(pkg_dir)])
+        self.assertEqual(len(dir_res), 2)
+
+        # Missing file error
+        with self.assertRaises(FileNotFoundError):
+            collect_packages([str(self.base / "nonexistent.deb")])
+
+    def test_package_target_validation_and_identify(self):
+        from validate_sof_install import PackageTarget, SofBinRepo, SofValidator, Status
+
+        # 1. Create mock sof-bin repo with v2.99
+        repo_dir = self.base / "sof-bin"
+        vdir = repo_dir / "v2.99.x"
+        fw_dir = vdir / "sof-ipc4-v2.99" / "tgl" / "community"
+        tplg_dir = vdir / "sof-ipc4-tplg-v2.99"
+        fw_dir.mkdir(parents=True)
+        tplg_dir.mkdir(parents=True)
+
+        fw_content = b"IDENTICAL_FW_DATA_FOR_VALIDATION"
+        tplg_content = b"IDENTICAL_TPLG_DATA_FOR_VALIDATION"
+
+        (fw_dir / "sof-tgl.ri").write_bytes(fw_content)
+        (tplg_dir / "sof-tgl-hdmi.tplg").write_bytes(tplg_content)
+
+        repo = SofBinRepo(repo_dir)
+
+        # 2. Build test deb matching repo contents
+        deb_path = self.base / "firmware-sof_2.99_all.deb"
+        self._build_test_deb(
+            data_files={
+                "lib/firmware/intel/sof-ipc4/tgl/community/sof-tgl.ri": fw_content,
+                "lib/firmware/intel/sof-ipc4-tplg/sof-tgl-hdmi.tplg": tplg_content,
+            },
+            control_fields={"Package": "firmware-sof", "Version": "2.99-1", "Architecture": "all"},
+            out_path=deb_path,
+        )
+
+        # 3. Validate PackageTarget against v2.99
+        target = PackageTarget([deb_path])
+        try:
+            validator = SofValidator(
+                repo=repo,
+                target=target,
+                platform_filter={"tgl"},
+            )
+
+            records = validator.validate_installation("v2.99")
+            self.assertGreater(len(records), 0)
+            self.assertTrue(all(r.status in (Status.MATCH, Status.SYMLINK_MATCH) for r in records))
+
+            # 4. Identify mode on PackageTarget
+            identified = validator.identify_installed()
+            self.assertEqual(len(identified), 2)
+            self.assertTrue(all(item["installed_version"] == "v2.99" for item in identified))
+        finally:
+            target.cleanup()
+
+    def test_rpm_package_target(self):
+        import shutil
+        import subprocess
+        from validate_sof_install import PackageTarget, SofBinRepo, SofValidator, Status
+
+        if not shutil.which("rpmbuild") or not shutil.which("rpm2cpio"):
+            self.skipTest("rpmbuild or rpm2cpio not installed")
+
+        # 1. Create mock repo
+        repo_dir = self.base / "sof-bin-rpm"
+        vdir = repo_dir / "v2.99.x"
+        fw_dir = vdir / "sof-ipc4-v2.99" / "tgl" / "community"
+        fw_dir.mkdir(parents=True)
+        fw_content = b"RPM_TGL_FW_TEST_PAYLOAD"
+        (fw_dir / "sof-tgl.ri").write_bytes(fw_content)
+        repo = SofBinRepo(repo_dir)
+
+        # 2. Build minimal test RPM
+        topdir = self.base / "rpmbuild_test"
+        for sub in ["BUILD", "RPMS", "SOURCES", "SPECS", "SRPMS"]:
+            (topdir / sub).mkdir(parents=True)
+
+        payload_dir = self.base / "payload"
+        (payload_dir / "lib/firmware/intel/sof-ipc4/tgl/community").mkdir(parents=True)
+        (payload_dir / "lib/firmware/intel/sof-ipc4/tgl/community/sof-tgl.ri").write_bytes(fw_content)
+
+        spec = f"""
+Name: test-sof-firmware
+Version: 2.99
+Release: 1
+Summary: Test SOF Firmware Package
+License: BSD
+BuildArch: noarch
+
+%description
+Test package
+
+%install
+mkdir -p %{{buildroot}}/lib/firmware/intel/sof-ipc4/tgl/community
+cp {payload_dir}/lib/firmware/intel/sof-ipc4/tgl/community/sof-tgl.ri %{{buildroot}}/lib/firmware/intel/sof-ipc4/tgl/community/
+
+%files
+/lib/firmware/intel/sof-ipc4/tgl/community/sof-tgl.ri
+"""
+        spec_file = self.base / "test.spec"
+        spec_file.write_text(spec)
+
+        subprocess.run(
+            ["rpmbuild", "-bb", "--define", f"_topdir {topdir}", str(spec_file)],
+            check=True,
+            capture_output=True,
+        )
+
+        rpm_files = list((topdir / "RPMS").rglob("*.rpm"))
+        self.assertTrue(len(rpm_files) > 0)
+        rpm_file = rpm_files[0]
+
+        # 3. Validate with PackageTarget
+        target = PackageTarget([rpm_file])
+        try:
+            validator = SofValidator(repo=repo, target=target, platform_filter={"tgl"})
+            records = validator.validate_installation("v2.99")
+            self.assertEqual(len(records), 1)
+            self.assertEqual(records[0].status, Status.MATCH)
+
+            identified = validator.identify_installed()
+            self.assertEqual(len(identified), 1)
+            self.assertEqual(identified[0]["installed_version"], "v2.99")
+        finally:
+            target.cleanup()
+
+
 if __name__ == "__main__":
     unittest.main()