diffoscope 330__tar.gz → 332__tar.gz

{diffoscope-330/diffoscope.egg-info → diffoscope-332}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffoscope
-Version: 330
+Version: 332
 Summary: in-depth comparison of files, archives, and directories
 Home-page: https://diffoscope.org/
 Author: Diffoscope developers

{diffoscope-330 → diffoscope-332}/diffoscope/__init__.py

@@ -17,4 +17,4 @@
 # You should have received a copy of the GNU General Public License
 # along with diffoscope.  If not, see <https://www.gnu.org/licenses/>.
 
-VERSION = "330"
+VERSION = "332"

{diffoscope-330 → diffoscope-332}/diffoscope/comparators/__init__.py

@@ -58,6 +58,7 @@ class ComparatorManager:
         ("bzip2.Bzip2File",),
         ("cpio.CpioFile",),
         ("deb.DebFile",),
+        ("nar.NarFile",),
         ("hdf.Hdf5File",),
         ("dex.DexFile",),
         ("elf.ElfFile",),

{diffoscope-330 → diffoscope-332}/diffoscope/comparators/decompile.py

@@ -2,7 +2,7 @@
 # diffoscope: in-depth comparison of files, archives, and directories
 #
 # Copyright © 2020 Jean-Romain Garnier <salsa@jean-romain.com>
-# Copyright © 2020-2022 Chris Lamb <lamby@debian.org>
+# Copyright © 2020-2022, 2026 Chris Lamb <lamby@debian.org>
 #
 # diffoscope is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -242,7 +242,11 @@ class AsmFunction(File):
 
     @property
     def offset(self):
-        return self.data_dict["offset"]
+        try:
+            return self.data_dict["addr"]
+        except KeyError:
+            # Be backwards compatible with version < 5.9.0
+            return self.data_dict["offset"]
 
     @property
     def size(self):

diffoscope-332/diffoscope/comparators/nar.py

@@ -0,0 +1,245 @@
+#
+# diffoscope: in-depth comparison of files, archives, and directories
+#
+# Copyright © 2024, 2026 Chris Lamb <lamby@debian.org>
+# Copyright © 2022 Christopher Baines <mail@cbaines.net>
+#
+# diffoscope is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# diffoscope is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with diffoscope.  If not, see <https://www.gnu.org/licenses/>.
+
+import os
+import stat
+import pathlib
+import logging
+import subprocess
+
+from diffoscope.difference import Difference
+from diffoscope.tools import tool_required
+from diffoscope.tempfiles import get_temporary_directory
+
+from .directory import Directory
+from .symlink import Symlink
+
+from .utils.file import File
+from .utils.archive import Archive, ArchiveMember
+
+logger = logging.getLogger(__name__)
+
+# The top-level node of a NAR is unnamed, so use this when referring to it in
+# file listings.
+NAR_ROOT = "."
+
+# "guix archive --extract" would be the obvious way to unpack a NAR, but it
+# insists on connecting to guix-daemon, so use "guix repl" to call the
+# underlying (guix serialization) code directly instead.
+RESTORE_NAR_SCRIPT = str(
+    pathlib.Path(__file__).parent.parent.joinpath("scripts", "restore-nar.scm")
+)
+
+
+class NarMember(ArchiveMember):
+    @property
+    def path(self):
+        # We unpack the archive in one go, so point at the already-extracted
+        # file rather than letting ArchiveMember create a temporary directory
+        # per-member.
+        return self.container.get_member_path(self._name)
+
+
+class NarDirectory(Directory, NarMember):
+    def __init__(self, container, member_name):
+        NarMember.__init__(self, container, member_name)
+
+    def compare(self, other, source=None):
+        return None
+
+    def has_same_content_as(self, other):
+        return False
+
+    def is_directory(self):
+        return True
+
+    def get_member_names(self):
+        raise ValueError("archives are compared as a whole.")  # noqa
+
+    def get_member(self, member_name):
+        raise ValueError("archives are compared as a whole.")  # noqa
+
+
+class NarSymlink(Symlink, NarMember):
+    def __init__(self, container, member_name, destination):
+        NarMember.__init__(self, container, member_name)
+        self._destination = destination
+
+    @property
+    def symlink_destination(self):
+        return self._destination
+
+    def is_symlink(self):
+        return True
+
+
+class NarContainer(Archive):
+    def open_archive(self):
+        return True
+
+    def close_archive(self):
+        pass
+
+    def get_member_names(self):
+        self.ensure_unpacked()
+
+        if not self._root_is_directory:
+            return [self._root_member_name]
+
+        return list(self.walk())
+
+    def get_member(self, member_name):
+        path = self.get_member_path(member_name)
+
+        if os.path.islink(path):
+            return NarSymlink(self, member_name, os.readlink(path))
+
+        if os.path.isdir(path):
+            return NarDirectory(self, member_name)
+
+        return NarMember(self, member_name)
+
+    def get_member_path(self, member_name):
+        self.ensure_unpacked()
+
+        if not self._root_is_directory:
+            if member_name != self._root_member_name:
+                raise KeyError(member_name)
+            return self._root
+
+        path = os.path.join(self._root, member_name)
+        if not os.path.lexists(path):
+            raise KeyError(member_name)
+
+        return path
+
+    def extract(self, member_name, dest_dir):
+        # Ignore dest_dir; the archive is already unpacked in one go.
+        return self.get_member_path(member_name)
+
+    def walk(self, relative_to=""):
+        """
+        Yield the name of every node underneath the top-level directory,
+        relative to it and in the order NAR stores them (ie. sorted), with
+        directories appearing before their contents.
+        """
+
+        directory = os.path.join(self._root, relative_to)
+
+        for name in sorted(os.listdir(directory)):
+            member_name = os.path.join(relative_to, name)
+            yield member_name
+
+            path = os.path.join(self._root, member_name)
+            if not os.path.islink(path) and os.path.isdir(path):
+                yield from self.walk(member_name)
+
+    def listing(self):
+        """
+        Describe the archive in terms of what NAR actually records: the type of
+        each node, whether regular files are executable and where symlinks
+        point.
+        """
+
+        self.ensure_unpacked()
+
+        def describe(name, path):
+            mode = os.lstat(path).st_mode
+
+            if stat.S_ISLNK(mode):
+                return f"symlink     {name} -> {os.readlink(path)}\n"
+            if stat.S_ISDIR(mode):
+                return f"directory   {name}\n"
+            if mode & stat.S_IXUSR:
+                return f"executable  {name}\n"
+
+            return f"regular     {name}\n"
+
+        yield describe(NAR_ROOT, self._root)
+
+        if self._root_is_directory:
+            for member_name in self.walk():
+                yield describe(
+                    member_name, os.path.join(self._root, member_name)
+                )
+
+    def compare(self, other, **kwargs):
+        differences = []
+
+        # Always include the file list; without it, added, removed or
+        # newly-executable files would only show up as a binary diff.
+        if other.source:
+            differences.append(
+                Difference.from_text_readers(
+                    self.listing(),
+                    other.listing(),
+                    self.source.path,
+                    other.source.path,
+                    source="file list",
+                )
+            )
+
+        differences.extend(super().compare(other, **kwargs))
+
+        return differences
+
+    @tool_required("guix")
+    def ensure_unpacked(self):
+        if hasattr(self, "_root"):
+            return
+
+        self._temp_dir_object = get_temporary_directory(suffix="nar")
+        root = os.path.join(self._temp_dir_object.name, "contents")
+
+        logger.debug("Extracting %s to %s", self.source.path, root)
+
+        with open(self.source.path, "rb") as f:
+            subprocess.run(
+                ("guix", "repl", "--", RESTORE_NAR_SCRIPT, root),
+                stdin=f,
+                # The script is tiny, so byte-compiling it would cost more than
+                # it saves (and would need a writable cache directory).
+                env=dict(os.environ, GUILE_AUTO_COMPILE="0"),
+                capture_output=True,
+                check=True,
+            )
+
+        self._root = root
+        self._root_is_directory = not os.path.islink(root) and os.path.isdir(
+            root
+        )
+
+        if self._root_is_directory:
+            # NAR restores directories read-only, which would prevent us from
+            # removing the unpacked files again later.
+            for dirpath, _, _ in os.walk(root):
+                os.chmod(dirpath, os.lstat(dirpath).st_mode | stat.S_IWUSR)
+        else:
+            # A NAR containing a single file or symlink does not record a name
+            # for it, so fall back to naming it after the archive itself.
+            self._root_member_name = self.get_compressed_content_name(".nar")
+
+
+class NarFile(File):
+    DESCRIPTION = "nar files"
+    CONTAINER_CLASSES = [NarContainer]
+
+    FALLBACK_FILE_TYPE_HEADER_PREFIX = (
+        len("nix-archive-1").to_bytes(8, byteorder="little") + b"nix-arch"
+    )

{diffoscope-330 → diffoscope-332}/diffoscope/external_tools.py

@@ -86,6 +86,7 @@ EXTERNAL_TOOLS = {
         "guix": "gnupg",
     },
     "guestfs": {"debian": "python3-guestfs"},
+    "guix": {"debian": "guix"},
     "gzip": {"debian": "gzip", "arch": "gzip", "guix": "gzip"},
     "h5dump": {"debian": "hdf5-tools", "arch": "hdf5", "guix": "hdf5"},
     "html2text": {"debian": "html2text", "guix": "html2text"},

diffoscope-332/diffoscope/scripts/restore-nar.scm

@@ -0,0 +1,11 @@
+;;; Restore the NAR read from standard input into the directory named
+;;; by the first command-line argument.
+;;;
+;;; We cannot use "guix archive --extract" for this as it handles
+;;; --extract from within a (with-store ...) form, and therefore
+;;; insists on connecting to guix-daemon even though restoring a NAR
+;;; needs nothing from the store.  This should be fixed in the future.
+
+(use-modules (guix serialization))
+
+(restore-file (current-input-port) (cadr (command-line)))

{diffoscope-330 → diffoscope-332/diffoscope.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffoscope
-Version: 330
+Version: 332
 Summary: in-depth comparison of files, archives, and directories
 Home-page: https://diffoscope.org/
 Author: Diffoscope developers

{diffoscope-330 → diffoscope-332}/diffoscope.egg-info/SOURCES.txt

@@ -79,6 +79,7 @@ diffoscope/comparators/lzma.py
 diffoscope/comparators/macho.py
 diffoscope/comparators/missing_file.py
 diffoscope/comparators/mono.py
+diffoscope/comparators/nar.py
 diffoscope/comparators/ocaml.py
 diffoscope/comparators/odt.py
 diffoscope/comparators/ogg.py
@@ -140,6 +141,7 @@ diffoscope/readers/__init__.py
 diffoscope/readers/json.py
 diffoscope/readers/utils.py
 diffoscope/scripts/extract-vmlinux
+diffoscope/scripts/restore-nar.scm
 tests/__init__.py
 tests/conftest.py
 tests/test_diff_mask.py
@@ -204,6 +206,7 @@ tests/comparators/test_lzma.py
 tests/comparators/test_macho.py
 tests/comparators/test_macho_decompiler.py
 tests/comparators/test_mono.py
+tests/comparators/test_nar.py
 tests/comparators/test_ocaml.py
 tests/comparators/test_odt.py
 tests/comparators/test_ogg.py
@@ -380,6 +383,7 @@ tests/data/mo_charsets_expected_diff
 tests/data/mo_expected_diff
 tests/data/mozzip_zipinfo_expected_diff
 tests/data/mp3_expected_diff
+tests/data/nar_listing_expected_diff
 tests/data/no-perms.tar
 tests/data/nupkg_expected_diff
 tests/data/ocaml_expected_diff
@@ -488,6 +492,7 @@ tests/data/test1.macho
 tests/data/test1.mo
 tests/data/test1.mozzip
 tests/data/test1.mp3
+tests/data/test1.nar
 tests/data/test1.nupkg
 tests/data/test1.o
 tests/data/test1.odt
@@ -558,6 +563,7 @@ tests/data/test2.macho
 tests/data/test2.mo
 tests/data/test2.mozzip
 tests/data/test2.mp3
+tests/data/test2.nar
 tests/data/test2.nupkg
 tests/data/test2.o
 tests/data/test2.odt
@@ -587,12 +593,14 @@ tests/data/test2_signed.pgp
 tests/data/test3.apk
 tests/data/test3.changes
 tests/data/test3.gif
+tests/data/test3.nar
 tests/data/test3.pdf
 tests/data/test3.xml
 tests/data/test3.xz
 tests/data/test3.zip
 tests/data/test4.changes
 tests/data/test4.gif
+tests/data/test4.nar
 tests/data/test4.pdf
 tests/data/test4.xml
 tests/data/test4.xz

diffoscope-332/tests/comparators/test_nar.py

@@ -0,0 +1,87 @@
+#
+# diffoscope: in-depth comparison of files, archives, and directories
+#
+# Copyright © 2024, 2026 Chris Lamb <lamby@debian.org>
+# Copyright © 2022 Christopher Baines <mail@cbaines.net>
+#
+# diffoscope is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# diffoscope is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with diffoscope.  If not, see <https://www.gnu.org/licenses/>.
+
+import pytest
+
+from diffoscope.comparators.nar import NarFile
+
+from ..utils.data import load_fixture, assert_diff
+from ..utils.nonexisting import assert_non_existing
+from ..utils.tools import skip_unless_tools_exist
+
+# test1.nar and test2.nar contain a single regular file; test3.nar and
+# test4.nar contain a "dir" directory holding a "text" file and a "link"
+# symlink.
+nar1 = load_fixture("test1.nar")
+nar2 = load_fixture("test2.nar")
+nar3 = load_fixture("test3.nar")
+nar4 = load_fixture("test4.nar")
+
+
+def test_identification(nar1):
+    assert isinstance(nar1, NarFile)
+
+
+def test_no_differences(nar1):
+    difference = nar1.compare(nar1)
+    assert difference is None
+
+
+@pytest.fixture
+def single_file_differences(nar1, nar2):
+    return nar1.compare(nar2).details
+
+
+@pytest.fixture
+def differences(nar3, nar4):
+    return nar3.compare(nar4).details
+
+
+@skip_unless_tools_exist("guix")
+def test_single_file(single_file_differences):
+    # A NAR holding a single file does not record a name for it, so it is
+    # named after the archive itself.
+    assert single_file_differences[0].source1 == "test1"
+    assert single_file_differences[0].source2 == "test2"
+    assert_diff(single_file_differences[0], "text_ascii_expected_diff")
+
+
+@skip_unless_tools_exist("guix")
+def test_listing(differences):
+    assert_diff(differences[0], "nar_listing_expected_diff")
+
+
+@skip_unless_tools_exist("guix")
+def test_symlinks(differences):
+    assert differences[1].source1 == "dir/link"
+    assert differences[1].source2 == "dir/link"
+    assert differences[1].comment == "symlink"
+    assert_diff(differences[1], "symlink_expected_diff")
+
+
+@skip_unless_tools_exist("guix")
+def test_text_file(differences):
+    assert differences[2].source1 == "dir/text"
+    assert differences[2].source2 == "dir/text"
+    assert_diff(differences[2], "text_ascii_expected_diff")
+
+
+@skip_unless_tools_exist("guix")
+def test_compare_non_existing(monkeypatch, nar3):
+    assert_non_existing(monkeypatch, nar3)

diffoscope-332/tests/data/elf_obj_radare2_expected_diff

@@ -0,0 +1,11 @@
+@@ -1,9 +1,9 @@
+ // callconv: rax amd64 (rdi, rsi, rdx, rcx, r8, r9, xmm0, xmm1, xmm2, xmm3, xmm4);
+ void sym.f (void) {
+         push (rbp)    // [01] -r-x section size 11 named .text
+         rbp = rsp
+-        eax = 0x2a    // '*' // 42
++        eax = 0xffffffff // -1
+         rbp = pop ()  // rsp // rsp
+         return
+ }
+

diffoscope-332/tests/data/macho_obj_radare2_expected_diff_main

@@ -0,0 +1,9 @@
+@@ -1,6 +1,6 @@
+ // callconv: rax amd64 (rdi, rsi, rdx, rcx, r8, r9, xmm0, xmm1, xmm2, xmm3, xmm4);
+ int printf (const char *format, ...) {
+-        // CALL XREF from main @ 0x100000f3f(x)
+-        goto loc_qword [reloc.printf] // [0x100001010:8]=0x100000f68 // "h\x0f" // [01] -r-x section size 6 named 1.__TEXT.__stubs
++        // CALL XREF from main @ 0x100000f58(x)
++        goto loc_qword [reloc.printf] // [0x100001010:8]=0x100000f80 "h" // [01] -r-x section size 6 named 1.__TEXT.__stubs
+ }
+ 

diffoscope-332/tests/data/macho_obj_radare2_expected_diff_printf

@@ -0,0 +1,22 @@
+@@ -1,17 +1,16 @@
+ // callconv: rax amd64 (rdi, rsi, rdx, rcx, r8, r9, xmm0, xmm1, xmm2, xmm3, xmm4);
+ int main (int argc, char **argv, char **envp) {
+-        push (rbp)   // [00] -r-x section size 49 named 0.__TEXT.__text
++        push (rbp)   // [00] -r-x section size 42 named 0.__TEXT.__text
+         rbp = rsp
+         rsp -= 0x10
+-        rdi = rip + 0x43 // section.3.__TEXT.__cstring // 0x100000f72 // "%s %s\n"
+-        rsi = rip + 0x43 // str.17:31:50 // 0x100000f79 // "17:31:50"
+-        rdx = rip + 0x45 // str.Wed_Dec__2_17:31:49_2015 // 0x100000f82 // "Wed Dec  2 17:31:49 2015"
++        rdi = rip + 0x3b // section.3.__TEXT.__cstring // 0x100000f8a // "%s\n"
++        rsi = rip + 0x38 // str.15:52:34 // 0x100000f8e // "15:52:34"
+         al = 0
+-        sym.imp.printf () // int printf("%s %s\n", "17:31:50", "Wed Dec  2 17:31:49 2015")
++        sym.imp.printf () // int printf("%s\n", "15:52:34")
+         ecx = 0
+         dword [var_4h] = eax
+         eax = ecx
+         rsp += 0x10
+         rbp = pop ()
+         return       // rsp // rsp
+ }

diffoscope-332/tests/data/nar_listing_expected_diff

@@ -0,0 +1,6 @@
+@@ -1,4 +1,4 @@
+ directory   .
+ directory   dir
+-symlink     dir/link -> broken
++symlink     dir/link -> really-broken
+ regular     dir/text

diffoscope-330/tests/data/elf_obj_radare2_expected_diff

@@ -1,13 +0,0 @@
-@@ -1,11 +1,11 @@
- 
- // This function contains 1 basic blocks and its 11 long.
- function sym.f () {
-     loc_0x8000040:
-     push rbp      //[01] -r-x section size 11 named .text
-     rbp = rsp
--    eax = 0x2a    //'*' ; 42
-+    eax = 0xffffffff //-1
-     //rsp ; rsp
-     return
-     (break)
- }

diffoscope-330/tests/data/macho_obj_radare2_expected_diff_main

@@ -1,33 +0,0 @@
-@@ -1,23 +1,21 @@
- 
--// This function contains 1 basic blocks and its 49 long.
-+// This function contains 1 basic blocks and its 42 long.
- function main () {
--    loc_0x100000f20:
--    push rbp     //[00] -r-x section size 49 named 0.__TEXT.__text
-+    loc_0x100000f40:
-+    push rbp     //[00] -r-x section size 42 named 0.__TEXT.__text
-     rbp = rsp
-     rsp -= 0x10
--    rdi = rip + 0x43 //section.3.__TEXT.__cstring
--    //0x100000f72 ; "%s %s\n"
--    rsi = rip + 0x43 //str.17:31:50
--    //0x100000f79 ; "17:31:50"
--    rdx = rip + 0x45 //str.Wed_Dec__2_17:31:49_2015
--    //0x100000f82 ; "Wed Dec  2 17:31:49 2015"
-+    rdi = rip + 0x3b //section.3.__TEXT.__cstring
-+    //0x100000f8a ; "%s\n"
-+    rsi = rip + 0x38 //str.15:52:34
-+    //0x100000f8e ; "15:52:34"
-     al = 0
--    0x100000f3f
--    int printf("%s %s\n")
-+    0x100000f58
-+    int printf("%s\n")
-     ecx = 0
-     dword [var_4h] = eax
-     eax = ecx
-     rsp += 0x10
-     //rsp ; rsp
-     return
-     (break)

diffoscope-330/tests/data/macho_obj_radare2_expected_diff_printf

@@ -1,12 +0,0 @@
-@@ -1,8 +1,8 @@
- 
- // This function contains 1 basic blocks and its 6 long.
- function sym.imp.printf () {
--    loc_0x100000f52:
--    //CALL XREF from main @ 0x100000f3f
--    goto qword [reloc.printf] //[0x100001010:8]=0x100000f68 "h" ; "h\x0f" ; [01] -r-x section size 6 named 1.__TEXT.__stubs
-+    loc_0x100000f6a:
-+    //CALL XREF from main @ 0x100000f58
-+    goto qword [reloc.printf] //[0x100001010:8]=0x100000f80 "h" ; [01] -r-x section size 6 named 1.__TEXT.__stubs
-     (break)
- }