dissect.target 3.19.dev47__tar.gz → 3.19.dev49__tar.gz

{dissect_target-3.19.dev47/dissect.target.egg-info → dissect_target-3.19.dev49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dissect.target
-Version: 3.19.dev47
+Version: 3.19.dev49
 Summary: This module ties all other Dissect modules together, it provides a programming API and command line tools which allow easy access to various data sources inside disk images or file collections (a.k.a. targets)
 Author-email: Dissect Team <dissect@fox-it.com>
 License: Affero General Public License v3

{dissect_target-3.19.dev47 → dissect_target-3.19.dev49}/dissect/target/filesystem.py

@@ -753,7 +753,7 @@ class FilesystemEntry:
         """
         log.debug("%r::readlink_ext()", self)
         # Default behavior, resolve link own filesystem.
-        return fsutil.resolve_link(fs=self.fs, entry=self)
+        return fsutil.resolve_link(self.fs, self.readlink(), self.path, alt_separator=self.fs.alt_separator)
 
     def stat(self, follow_symlinks: bool = True) -> fsutil.stat_result:
         """Determine the stat information of this entry.
@@ -1467,10 +1467,15 @@ class LayerFilesystem(Filesystem):
         """Get a :class:`FilesystemEntry` relative to a specific entry."""
         parts = path.split("/")
 
-        for part in parts:
+        for i, part in enumerate(parts):
             if entry.is_symlink():
                 # Resolve using the RootFilesystem instead of the entry's Filesystem
-                entry = fsutil.resolve_link(fs=self, entry=entry)
+                entry = fsutil.resolve_link(
+                    self,
+                    entry.readlink(),
+                    "/".join(parts[:i]),
+                    alt_separator=entry.fs.alt_separator,
+                )
             entry = entry.get(part)
 
         return entry

{dissect_target-3.19.dev47 → dissect_target-3.19.dev49}/dissect/target/filesystems/itunes.py

@@ -94,7 +94,7 @@ class ITunesFilesystemEntry(VirtualFile):
     def readlink_ext(self) -> FilesystemEntry:
         """Read the link if this entry is a symlink. Returns a filesystem entry."""
         # Can't use the one in VirtualFile as it overrides the FilesystemEntry
-        return fsutil.resolve_link(fs=self.fs, entry=self)
+        return fsutil.resolve_link(self.fs, self.readlink(), self.path, alt_separator=self.fs.alt_separator)
 
     def stat(self, follow_symlinks: bool = True) -> fsutil.stat_result:
         """Return the stat information of this entry."""

{dissect_target-3.19.dev47 → dissect_target-3.19.dev49}/dissect/target/filesystems/tar.py

@@ -121,7 +121,7 @@ class TarFilesystemEntry(VirtualFile):
     def readlink_ext(self) -> FilesystemEntry:
         """Read the link if this entry is a symlink. Returns a filesystem entry."""
         # Can't use the one in VirtualFile as it overrides the FilesystemEntry
-        return fsutil.resolve_link(fs=self.fs, entry=self)
+        return fsutil.resolve_link(self.fs, self.readlink(), self.path, alt_separator=self.fs.alt_separator)
 
     def stat(self, follow_symlinks: bool = True) -> fsutil.stat_result:
         """Return the stat information of this entry."""

{dissect_target-3.19.dev47 → dissect_target-3.19.dev49}/dissect/target/helpers/fsutil.py

@@ -440,15 +440,20 @@ def has_glob_magic(s) -> bool:
 
 
 def resolve_link(
-    fs: filesystem.Filesystem, entry: filesystem.FilesystemEntry, previous_links: set[str] = None
+    fs: filesystem.Filesystem,
+    link: str,
+    path: str,
+    *,
+    alt_separator: str = "",
+    previous_links: set[str] | None = None,
 ) -> filesystem.FilesystemEntry:
     """Resolves a symlink to its actual path.
 
     It stops resolving once it detects an infinite recursion loop.
     """
 
-    link = normalize(entry.readlink(), alt_separator=entry.fs.alt_separator)
-    path = normalize(entry.path, alt_separator=entry.fs.alt_separator)
+    link = normalize(link, alt_separator=alt_separator)
+    path = normalize(path, alt_separator=alt_separator)
 
     # Create hash for entry based on path and link
     link_id = f"{path}{link}"
@@ -471,7 +476,13 @@ def resolve_link(
     entry = fs.get(link)
 
     if entry.is_symlink():
-        entry = resolve_link(fs, entry, previous_links)
+        entry = resolve_link(
+            fs,
+            entry.readlink(),
+            link,
+            alt_separator=entry.fs.alt_separator,
+            previous_links=previous_links,
+        )
 
     return entry
 

{dissect_target-3.19.dev47 → dissect_target-3.19.dev49}/dissect/target/tools/shell.py

@@ -9,6 +9,7 @@ import itertools
 import logging
 import os
 import pathlib
+import platform
 import pydoc
 import random
 import re
@@ -1442,6 +1443,20 @@ def main() -> None:
     if args.quiet:
         logging.getLogger("dissect").setLevel(level=logging.ERROR)
 
+    # PyPy < 3.10.14 readline is stuck in Python 2.7
+    if platform.python_implementation() == "PyPy":
+        major, minor, patch = tuple(map(int, platform.python_version_tuple()))
+        if major <= 3 and minor <= 10 and patch < 14:
+            print(
+                "\n".join(
+                    [
+                        "Note for users of PyPy < 3.10.14:",
+                        "Autocomplete might not work due to an outdated version of pyrepl/readline.py",
+                        "To fix this, please update your version of PyPy.",
+                    ]
+                )
+            )
+
     try:
         open_shell(args.targets, args.python, args.registry)
     except TargetError as e:

{dissect_target-3.19.dev47 → dissect_target-3.19.dev49/dissect.target.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dissect.target
-Version: 3.19.dev47
+Version: 3.19.dev49
 Summary: This module ties all other Dissect modules together, it provides a programming API and command line tools which allow easy access to various data sources inside disk images or file collections (a.k.a. targets)
 Author-email: Dissect Team <dissect@fox-it.com>
 License: Affero General Public License v3

{dissect_target-3.19.dev47 → dissect_target-3.19.dev49}/tests/test_filesystem.py

@@ -12,7 +12,7 @@ from unittest.mock import Mock, patch
 import pytest
 from dissect.util import ts
 
-from dissect.target import Target, filesystem
+from dissect.target import filesystem
 from dissect.target.exceptions import (
     FileNotFoundError,
     NotADirectoryError,
@@ -91,7 +91,9 @@ def test_get(vfs: VirtualFilesystem) -> None:
     assert vfs.get("filelink2").stat() == vfs.get("/path/to/some/file").stat()
 
 
-def test_symlink_across_layers(target_bare: Target) -> None:
+def test_symlink_across_layers() -> None:
+    lfs = LayerFilesystem()
+
     vfs1 = VirtualFilesystem()
     vfs1.makedirs("/path/to/symlink/")
     vfs1.symlink("../target", "/path/to/symlink/target")
@@ -99,18 +101,20 @@ def test_symlink_across_layers(target_bare: Target) -> None:
     vfs2 = VirtualFilesystem()
     target_dir = vfs2.makedirs("/path/to/target")
 
-    layer1 = target_bare.fs.append_layer()
+    layer1 = lfs.append_layer()
     layer1.mount("/", vfs1)
 
-    layer2 = target_bare.fs.append_layer()
+    layer2 = lfs.append_layer()
     layer2.mount("/", vfs2)
 
-    target_entry = target_bare.fs.get("/path/to/symlink/target").readlink_ext()
+    target_entry = lfs.get("/path/to/symlink/target").readlink_ext()
 
     assert target_dir.stat() == target_entry.entries[0].stat()
 
 
-def test_symlink_files_across_layers(target_bare: Target) -> None:
+def test_symlink_files_across_layers() -> None:
+    lfs = LayerFilesystem()
+
     vfs1 = VirtualFilesystem()
     vfs1.makedirs("/path/to/symlink/")
     vfs1.symlink("../target", "/path/to/symlink/target")
@@ -118,19 +122,21 @@ def test_symlink_files_across_layers(target_bare: Target) -> None:
     vfs2 = VirtualFilesystem()
     target_dir = vfs2.makedirs("/path/to/target/derp")
 
-    layer1 = target_bare.fs.append_layer()
+    layer1 = lfs.append_layer()
     layer1.mount("/", vfs1)
 
-    layer2 = target_bare.fs.append_layer()
+    layer2 = lfs.append_layer()
     layer2.mount("/", vfs2)
 
-    target_entry = target_bare.fs.get("/path/to/symlink/target/derp")
+    target_entry = lfs.get("/path/to/symlink/target/derp")
 
     assert len(target_entry.entries) != 0
     assert target_dir.stat() == target_entry.stat()
 
 
-def test_symlink_to_symlink_across_layers(target_bare: Target) -> None:
+def test_symlink_to_symlink_across_layers() -> None:
+    lfs = LayerFilesystem()
+
     vfs1 = VirtualFilesystem()
     vfs1.makedirs("/path/to/symlink/")
     target_dir = vfs1.makedirs("/path/target")
@@ -139,18 +145,20 @@ def test_symlink_to_symlink_across_layers(target_bare: Target) -> None:
     vfs2 = VirtualFilesystem()
     vfs2.symlink("../target", "/path/to/target")
 
-    layer1 = target_bare.fs.append_layer()
+    layer1 = lfs.append_layer()
     layer1.mount("/", vfs1)
 
-    layer2 = target_bare.fs.append_layer()
+    layer2 = lfs.append_layer()
     layer2.mount("/", vfs2)
 
-    target_entry = target_bare.fs.get("/path/to/symlink/target/").readlink_ext()
+    target_entry = lfs.get("/path/to/symlink/target/").readlink_ext()
 
     assert target_dir.stat() == target_entry.stat()
 
 
-def test_recursive_symlink_across_layers(target_bare: Target) -> None:
+def test_recursive_symlink_across_layers() -> None:
+    lfs = LayerFilesystem()
+
     vfs1 = VirtualFilesystem()
     vfs1.makedirs("/path/to/symlink/")
     vfs1.symlink("../target", "/path/to/symlink/target")
@@ -158,17 +166,19 @@ def test_recursive_symlink_across_layers(target_bare: Target) -> None:
     vfs2 = VirtualFilesystem()
     vfs2.symlink("symlink/target", "/path/to/target")
 
-    layer1 = target_bare.fs.append_layer()
+    layer1 = lfs.append_layer()
     layer1.mount("/", vfs1)
 
-    layer2 = target_bare.fs.append_layer()
+    layer2 = lfs.append_layer()
     layer2.mount("/", vfs2)
 
     with pytest.raises(SymlinkRecursionError):
-        target_bare.fs.get("/path/to/symlink/target/").readlink_ext()
+        lfs.get("/path/to/symlink/target/").readlink_ext()
 
 
-def test_symlink_across_3_layers(target_bare: Target) -> None:
+def test_symlink_across_3_layers() -> None:
+    lfs = LayerFilesystem()
+
     vfs1 = VirtualFilesystem()
     vfs1.makedirs("/path/to/symlink/")
     vfs1.symlink("../target", "/path/to/symlink/target")
@@ -179,24 +189,26 @@ def test_symlink_across_3_layers(target_bare: Target) -> None:
     vfs3 = VirtualFilesystem()
     target_dir = vfs3.makedirs("/path/target")
 
-    layer1 = target_bare.fs.append_layer()
+    layer1 = lfs.append_layer()
     layer1.mount("/", vfs1)
 
-    layer2 = target_bare.fs.append_layer()
+    layer2 = lfs.append_layer()
     layer2.mount("/", vfs2)
 
-    layer3 = target_bare.fs.append_layer()
+    layer3 = lfs.append_layer()
     layer3.mount("/", vfs3)
 
-    target_entry = target_bare.fs.get("/path/to/symlink/target/").readlink_ext()
+    target_entry = lfs.get("/path/to/symlink/target/").readlink_ext()
 
     assert target_dir.stat() == target_entry.stat()
-    stat_b = target_bare.fs.get("/path/to/symlink/target/").stat()
-    stat_a = target_bare.fs.get("/path/to/target/").stat()
+    stat_b = lfs.get("/path/to/symlink/target/").stat()
+    stat_a = lfs.get("/path/to/target/").stat()
     assert stat_a == stat_b
 
 
-def test_recursive_symlink_open_across_layers(target_bare: Target) -> None:
+def test_recursive_symlink_open_across_layers() -> None:
+    lfs = LayerFilesystem()
+
     vfs1 = VirtualFilesystem()
     vfs1.makedirs("/path/to/symlink/")
     vfs1.symlink("../target", "/path/to/symlink/target")
@@ -204,22 +216,24 @@ def test_recursive_symlink_open_across_layers(target_bare: Target) -> None:
     vfs2 = VirtualFilesystem()
     vfs2.symlink("symlink/target", "/path/to/target")
 
-    layer1 = target_bare.fs.append_layer()
+    layer1 = lfs.append_layer()
     layer1.mount("/", vfs1)
 
-    layer2 = target_bare.fs.append_layer()
+    layer2 = lfs.append_layer()
     layer2.mount("/", vfs2)
 
     with pytest.raises(SymlinkRecursionError):
-        target_bare.fs.get("/path/to/symlink/target/").open()
+        lfs.get("/path/to/symlink/target/").open()
+
 
+def test_recursive_symlink_dev() -> None:
+    lfs = LayerFilesystem()
 
-def test_recursive_symlink_dev(target_bare: Target) -> None:
     fs1 = ExtFilesystem(fh=open(absolute_path("_data/filesystems/symlink_disk.ext4"), "rb"))
-    target_bare.fs.mount(fs=fs1, path="/")
+    lfs.mount(fs=fs1, path="/")
 
     with pytest.raises(SymlinkRecursionError):
-        target_bare.fs.get("/path/to/symlink/target/").readlink_ext()
+        lfs.get("/path/to/symlink/target/").readlink_ext()
 
 
 @pytest.mark.parametrize(
@@ -1224,3 +1238,16 @@ def test_layer_filesystem_mount() -> None:
     assert sorted(lfs.listdir("/vfs")) == ["file1", "file2"]
     assert lfs.path("/vfs/file1").read_text() == "value1"
     assert lfs.path("/vfs/file2").read_text() == "value2"
+
+
+def test_layer_filesystem_relative_link() -> None:
+    """test relative symlinks from a filesystem mounted at a subdirectory"""
+    lfs = LayerFilesystem()
+
+    vfs = VirtualFilesystem()
+    vfs.map_file_fh("dir/hello/world", BytesIO("o/".encode()))
+    vfs.symlink("dir/hello", "bye")
+
+    lfs.mount("/mnt", vfs)
+
+    assert lfs.path("/mnt/bye/world").read_text() == "o/"