dissect.target 3.25.dev0__tar.gz → 3.25.dev1__tar.gz

{dissect_target-3.25.dev0 → dissect_target-3.25.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dissect.target
-Version: 3.25.dev0
+Version: 3.25.dev1
 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-Expression: AGPL-3.0-or-later

{dissect_target-3.25.dev0 → dissect_target-3.25.dev1}/dissect/target/filesystem.py

@@ -6,6 +6,7 @@ import os
 import pathlib
 import stat
 from collections import defaultdict
+from functools import cache
 from typing import TYPE_CHECKING, Any, BinaryIO, Final
 
 from dissect.target.exceptions import (
@@ -24,6 +25,8 @@ TarFilesystem = import_lazy("dissect.target.filesystems.tar").TarFilesystem
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterator
 
+    from typing_extensions import Self
+
     from dissect.target.target import Target
 
 FILESYSTEMS: list[type[Filesystem]] = []
@@ -191,7 +194,7 @@ class Filesystem:
         """
         return self.get(path).iterdir()
 
-    def scandir(self, path: str) -> Iterator[FilesystemEntry]:
+    def scandir(self, path: str) -> Iterator[DirEntry]:
         """Iterate over the contents of a directory, return them as FilesystemEntry's.
 
         Args:
@@ -222,7 +225,7 @@ class Filesystem:
         Returns:
             A list of FilesystemEntry's.
         """
-        return list(self.scandir(path))
+        return [e.get() for e in self.scandir(path)]
 
     def walk(
         self,
@@ -251,7 +254,7 @@ class Filesystem:
         topdown: bool = True,
         onerror: Callable[[Exception], None] | None = None,
         followlinks: bool = False,
-    ) -> Iterator[tuple[list[FilesystemEntry], list[FilesystemEntry], list[FilesystemEntry]]]:
+    ) -> Iterator[tuple[list[FilesystemEntry], list[DirEntry], list[DirEntry]]]:
         """Recursively walk a directory pointed to by ``path``, returning :class:`FilesystemEntry` of files
         and directories.
 
@@ -266,7 +269,7 @@ class Filesystem:
         """
         return self.get(path).walk_ext(topdown, onerror, followlinks)
 
-    def recurse(self, path: str) -> Iterator[FilesystemEntry]:
+    def recurse(self, path: str) -> Iterator[DirEntry]:
         """Recursively walk a directory and yield contents as :class:`FilesystemEntry`.
 
         Does not follow symbolic links.
@@ -519,7 +522,7 @@ class FilesystemEntry:
     def __str__(self) -> str:
         return str(self.path)
 
-    def _resolve(self, follow_symlinks: bool = True) -> FilesystemEntry:
+    def _resolve(self, follow_symlinks: bool = True) -> Self:
         """Helper method to resolve symbolic links.
 
         If ``follow_symlinks`` is ``False``, this function is effectively a no-op.
@@ -535,7 +538,7 @@ class FilesystemEntry:
             return self.readlink_ext()
         return self
 
-    def get(self, path: str) -> FilesystemEntry:
+    def get(self, path: str) -> Self:
         """Retrieve a :class:`FilesystemEntry` relative to this entry.
 
         Args:
@@ -560,9 +563,10 @@ class FilesystemEntry:
         Returns:
             An iterator of directory entries as path strings.
         """
-        raise NotImplementedError
+        for entry in self.scandir():
+            yield entry.name
 
-    def scandir(self) -> Iterator[FilesystemEntry]:
+    def scandir(self) -> Iterator[DirEntry]:
         """Iterate over the contents of a directory, yields :class:`FilesystemEntry`.
 
         Returns:
@@ -578,13 +582,13 @@ class FilesystemEntry:
         """
         return list(self.iterdir())
 
-    def listdir_ext(self) -> list[FilesystemEntry]:
+    def listdir_ext(self) -> list[Self]:
         """List the contents of a directory as a list of :class:`FilesystemEntry`.
 
         Returns:
             A list of :class:`FilesystemEntry`.
         """
-        return list(self.scandir())
+        return [e.get() for e in self.scandir()]
 
     def walk(
         self,
@@ -615,7 +619,7 @@ class FilesystemEntry:
         topdown: bool = True,
         onerror: Callable[[Exception], None] | None = None,
         followlinks: bool = False,
-    ) -> Iterator[tuple[list[FilesystemEntry], list[FilesystemEntry], list[FilesystemEntry]]]:
+    ) -> Iterator[tuple[list[Self], list[Self], list[Self]]]:
         """Recursively walk a directory and yield its contents as :class:`FilesystemEntry` split in a tuple of
         lists of files, directories and symlinks.
 
@@ -629,13 +633,13 @@ class FilesystemEntry:
         """
         yield from fsutil.walk_ext(self, topdown, onerror, followlinks)
 
-    def recurse(self) -> Iterator[FilesystemEntry]:
-        """Recursively walk a directory and yield its contents as :class:`FilesystemEntry`.
+    def recurse(self) -> Iterator[DirEntry]:
+        """Recursively walk a directory and yield its contents as :class:`DirEntry`.
 
         Does not follow symbolic links.
 
         Returns:
-            An iterator of :class:`FilesystemEntry`.
+            An iterator of :class:`DirEntry`.
         """
         yield from fsutil.recurse(self)
 
@@ -651,7 +655,7 @@ class FilesystemEntry:
         for entry in self.glob_ext(pattern):
             yield entry.path
 
-    def glob_ext(self, pattern: str) -> Iterator[FilesystemEntry]:
+    def glob_ext(self, pattern: str) -> Iterator[Self]:
         """Iterate over the directory part of ``pattern``, returning entries matching
         ``pattern`` as :class:`FilesysmteEntry`.
 
@@ -746,7 +750,7 @@ class FilesystemEntry:
             The path the link points to."""
         raise NotImplementedError
 
-    def readlink_ext(self) -> FilesystemEntry:
+    def readlink_ext(self) -> Self:
         """Read the link where this entry points to, return the resulting path as :class:`FilesystemEntry`.
 
         If it is a symlink and returns the string that corresponds to that path.
@@ -841,14 +845,109 @@ class FilesystemEntry:
         return hashutil.common(self.open())
 
 
+class DirEntry:
+    """Directory entry base class. Closely models ``os.DirEntry``.
+
+    Filesystem implementations are encouraged to subclass this class to provide efficient
+    implementations of the various methods.
+
+    Args:
+        fs: The filesystem the entry belongs to.
+        path: The path of the parent directory.
+        name: The name of the entry.
+        entry: The raw entry backing this directory entry.
+    """
+
+    def __init__(self, fs: Filesystem, path: str, name: str, entry: Any):
+        self.fs = fs
+        """The filesystem the entry belongs to."""
+        self.path = fsutil.join(path, name, alt_separator=self.fs.alt_separator)
+        """The full path of the entry."""
+        self.name = name
+        """The name of the entry."""
+        self.entry = entry
+        """The raw entry backing this directory entry."""
+
+        self.stat = cache(self.stat)
+
+    def __fspath__(self) -> str:
+        return self.path
+
+    def __repr__(self) -> str:
+        return f"<DirEntry {self.name!r}>"
+
+    def get(self) -> FilesystemEntry:
+        """Retrieve the :class:`FilesystemEntry` this directory entry points to.
+
+        Subclasses should override this method to provide an efficient implementation.
+        """
+        return self.fs.get(self.path)
+
+    def is_dir(self, *, follow_symlinks: bool = True) -> bool:
+        """Return whether this entry is a directory or a symbolic link pointing to a directory.
+
+        Subclasses should override this method to provide an efficient implementation.
+        """
+        try:
+            return stat.S_ISDIR(self.stat(follow_symlinks=follow_symlinks).st_mode)
+        except FileNotFoundError:
+            return False
+
+    def is_file(self, *, follow_symlinks: bool = True) -> bool:
+        """Return whether this entry is a file or a symbolic link pointing to a file.
+
+        Subclasses should override this method to provide an efficient implementation.
+        """
+        try:
+            return stat.S_ISREG(self.stat(follow_symlinks=follow_symlinks).st_mode)
+        except FileNotFoundError:
+            return False
+
+    def is_symlink(self) -> bool:
+        """Return whether this entry is a symbolic link.
+
+        Subclasses should override this method to provide an efficient implementation.
+        """
+        return stat.S_ISLNK(self.stat(follow_symlinks=False).st_mode)
+
+    def is_junction(self) -> bool:
+        """Return whether this entry is a junction (only valid for NTFS)."""
+        return False
+
+    def stat(self, *, follow_symlinks: bool = True) -> fsutil.stat_result:
+        """Return the stat information of this entry.
+
+        Subclasses should override this method to provide an efficient implementation.
+
+        Note that this may return slightly different information than a "full" stat on the full filesystem entry,
+        as in most cases this will generate a stat based on the information available in the directory entry only.
+        """
+        return self.fs.stat(self.path, follow_symlinks=follow_symlinks)
+
+    def inode(self) -> int:
+        """Return the inode number of this entry."""
+        return self.stat(follow_symlinks=False).st_ino
+
+
+class VirtualDirEntry(DirEntry):
+    fs: VirtualFilesystem
+    entry: FilesystemEntry
+
+    def get(self) -> FilesystemEntry:
+        return self.entry
+
+    def stat(self, *, follow_symlinks: bool = True) -> fsutil.stat_result:
+        return self.entry.stat(follow_symlinks=follow_symlinks)
+
+
 class VirtualDirectory(FilesystemEntry):
     """Virtual directory implementation. Backed by a dict."""
 
     def __init__(self, fs: VirtualFilesystem, path: str):
         super().__init__(fs, path, None)
         self.up = None
-        self.top = None
-        self.entries = {}
+        self.top: FilesystemEntry | None = None
+        self.entries: dict[str, FilesystemEntry] = {}
 
     def __getitem__(self, item: str) -> FilesystemEntry:
         if not self.fs.case_sensitive:
@@ -879,25 +978,11 @@ class VirtualDirectory(FilesystemEntry):
     def get(self, path: str) -> FilesystemEntry:
         return self.fs.get(path, relentry=self)
 
-    def iterdir(self) -> Iterator[str]:
+    def scandir(self) -> Iterator[DirEntry]:
         yielded = set()
-        for entry in self.entries:
-            yield entry
-            yielded.add(entry)
-
-        # self.top used to be a reference to a filesystem. This is now a reference to
-        # any filesystem entry, usually the root of a filesystem.
-        if self.top:
-            for entry in self.top.iterdir():
-                if entry in yielded or (not self.fs.case_sensitive and entry.lower() in yielded):
-                    continue
-                yield entry
-
-    def scandir(self) -> Iterator[FilesystemEntry]:
-        yielded = set()
-        for entry in self.entries.values():
-            yield entry
-            yielded.add(entry.name)
+        for name, entry in self.entries.items():
+            yield VirtualDirEntry(self.fs, self.path, entry.name, entry)
+            yielded.add(name)
 
         # self.top used to be a reference to a filesystem. This is now a reference to
         # any filesystem entry, usually the root of a filesystem.
@@ -970,10 +1055,7 @@ class VirtualFile(FilesystemEntry):
             return self
         raise NotADirectoryError(f"'{self.path}' is not a directory")
 
-    def iterdir(self) -> Iterator[str]:
-        raise NotADirectoryError(f"'{self.path}' is not a directory")
-
-    def scandir(self) -> Iterator[FilesystemEntry]:
+    def scandir(self) -> Iterator[DirEntry]:
         raise NotADirectoryError(f"'{self.path}' is not a directory")
 
     def open(self) -> BinaryIO:
@@ -1056,10 +1138,7 @@ class VirtualSymlink(FilesystemEntry):
     def get(self, path: str) -> FilesystemEntry:
         return self.fs.get(path, self)
 
-    def iterdir(self) -> Iterator[str]:
-        yield from self.readlink_ext().iterdir()
-
-    def scandir(self) -> Iterator[FilesystemEntry]:
+    def scandir(self) -> Iterator[DirEntry]:
         yield from self.readlink_ext().scandir()
 
     def open(self) -> BinaryIO:
@@ -1517,6 +1596,14 @@ class EntryList(list):
             return object.__getattribute__(self, attr)
 
 
+class LayerDirEntry(DirEntry):
+    fs: LayerFilesystem
+    entry: list[DirEntry]
+
+    def get(self) -> LayerFilesystemEntry:
+        return LayerFilesystemEntry(self.fs, self.path, [e.get() for e in self.entry])
+
+
 class LayerFilesystemEntry(FilesystemEntry):
     def __init__(self, fs: Filesystem, path: str, entry: FilesystemEntry):
         super().__init__(fs, path, EntryList(entry))
@@ -1542,24 +1629,12 @@ class LayerFilesystemEntry(FilesystemEntry):
     def open(self) -> BinaryIO:
         return self._resolve()._exec("open")
 
-    def iterdir(self) -> Iterator[str]:
-        yielded = {".", ".."}
-        selfentry = self._resolve()
-        for fsentry in selfentry.entries:
-            for entry_name in fsentry.iterdir():
-                name = entry_name if selfentry.fs.case_sensitive else entry_name.lower()
-                if name in yielded:
-                    continue
-
-                yield entry_name
-                yielded.add(name)
-
-    def scandir(self) -> Iterator[LayerFilesystemEntry]:
+    def scandir(self) -> Iterator[LayerDirEntry]:
         # Every entry is actually a list of entries from the different
         # overlaying FSes, of which each may implement a different function
         # like .stat() or .open()
         items = defaultdict(list)
-        selfentry = self._resolve()
+        selfentry: LayerFilesystemEntry = self._resolve()
         for fsentry in selfentry.entries:
             for entry in fsentry.scandir():
                 name = entry.name if selfentry.fs.case_sensitive else entry.name.lower()
@@ -1572,9 +1647,7 @@ class LayerFilesystemEntry(FilesystemEntry):
             # The filename for the first entry is taken. Note that in case of
             # non case-sensitive FSes, the different entries from the
             # overlaying FSes may have different casing of the name.
-            entry_name = entries[0].name
-            path = fsutil.join(selfentry.path, entry_name, alt_separator=selfentry.fs.alt_separator)
-            yield LayerFilesystemEntry(selfentry.fs, path, entries)
+            yield DirEntry(selfentry.fs, selfentry.path, entries[0].name, entries)
 
     def is_file(self, follow_symlinks: bool = True) -> bool:
         try:
@@ -1627,6 +1700,15 @@ class RootFilesystem(LayerFilesystem):
         return entry
 
 
+class RootDirEntry(LayerDirEntry):
+    fs: RootFilesystem
+
+    def get(self) -> RootFilesystemEntry:
+        entry = super().get()
+        entry.__class__ = RootFilesystemEntry
+        return entry
+
+
 class RootFilesystemEntry(LayerFilesystemEntry):
     fs: RootFilesystem
 
@@ -1640,14 +1722,10 @@ class RootFilesystemEntry(LayerFilesystemEntry):
         self.fs.target.log.trace("%r::open()", self)
         return super().open()
 
-    def iterdir(self) -> Iterator[str]:
-        self.fs.target.log.trace("%r::iterdir()", self)
-        yield from super().iterdir()
-
-    def scandir(self) -> Iterator[RootFilesystemEntry]:
+    def scandir(self) -> Iterator[DirEntry]:
         self.fs.target.log.trace("%r::scandir()", self)
         for entry in super().scandir():
-            entry.__class__ = RootFilesystemEntry
+            entry.__class__ = RootDirEntry
             yield entry
 
     def is_file(self, follow_symlinks: bool = True) -> bool:

{dissect_target-3.25.dev0 → dissect_target-3.25.dev1}/dissect/target/filesystems/ad1.py

@@ -11,7 +11,7 @@ from dissect.target.exceptions import (
     NotADirectoryError,
     NotASymlinkError,
 )
-from dissect.target.filesystem import Filesystem, FilesystemEntry
+from dissect.target.filesystem import DirEntry, Filesystem, FilesystemEntry
 from dissect.target.helpers import fsutil
 
 if TYPE_CHECKING:
@@ -39,6 +39,17 @@ class AD1Filesystem(Filesystem):
             raise FileNotFoundError(path)
 
 
+class AD1DirEntry(DirEntry):
+    fs: AD1Filesystem
+    entry: ad1.FileEntry
+
+    def get(self) -> AD1FilesystemEntry:
+        return AD1FilesystemEntry(self.fs, self.path, self.entry)
+
+    def stat(self, follow_symlinks: bool = True) -> fsutil.stat_result:
+        return self.get().stat(follow_symlinks=follow_symlinks)
+
+
 class AD1FilesystemEntry(FilesystemEntry):
     def get(self, path: str) -> AD1FilesystemEntry:
         path = fsutil.join(self.path, path, alt_separator=self.alt_separator)
@@ -49,19 +60,12 @@ class AD1FilesystemEntry(FilesystemEntry):
             raise IsADirectoryError(self.path)
         return self.entry.open()
 
-    def iterdir(self) -> Iterator[str]:
-        if not self.is_dir():
-            raise NotADirectoryError(self.path)
-
-        yield from self.entry.listdir().keys()
-
     def scandir(self) -> Iterator[AD1FilesystemEntry]:
         if not self.is_dir():
             raise NotADirectoryError(self.path)
 
-        for fname, file_ in self.entry.listdir().items():
-            path = fsutil.join(self.path, fname, alt_separator=self.alt_separator)
-            yield AD1FilesystemEntry(self.fs, path, file_)
+        for name, entry in self.entry.listdir().items():
+            yield AD1DirEntry(self.fs, self.path, name, entry)
 
     def is_file(self, follow_symlinks: bool = True) -> bool:
         return self.entry.is_file()

{dissect_target-3.25.dev0 → dissect_target-3.25.dev1}/dissect/target/filesystems/btrfs.py

@@ -13,7 +13,7 @@ from dissect.target.exceptions import (
     NotADirectoryError,
     NotASymlinkError,
 )
-from dissect.target.filesystem import Filesystem, FilesystemEntry
+from dissect.target.filesystem import DirEntry, Filesystem, FilesystemEntry
 from dissect.target.helpers import fsutil
 
 if TYPE_CHECKING:
@@ -91,42 +91,40 @@ class BtrfsSubvolumeFilesystem(Filesystem):
             raise FileNotFoundError(path) from e
 
 
+class BtrfsDirEntry(DirEntry):
+    fs: BtrfsSubvolumeFilesystem
+    entry: btrfs.INode
+
+    def get(self) -> BtrfsFilesystemEntry:
+        return BtrfsFilesystemEntry(self.fs, self.path, self.entry)
+
+    def stat(self, *, follow_symlinks: bool = True) -> fsutil.stat_result:
+        return self.get().stat(follow_symlinks=follow_symlinks)
+
+
 class BtrfsFilesystemEntry(FilesystemEntry):
-    fs: BtrfsFilesystem
+    fs: BtrfsSubvolumeFilesystem
     entry: btrfs.INode
 
     def get(self, path: str) -> FilesystemEntry:
-        entry_path = fsutil.join(self.path, path, alt_separator=self.fs.alt_separator)
-        entry = self.fs._get_node(path, self.entry)
-        return BtrfsFilesystemEntry(self.fs, entry_path, entry)
+        path = fsutil.join(self.path, path, alt_separator=self.fs.alt_separator)
+        return BtrfsFilesystemEntry(self.fs, path, self.fs._get_node(path, self.entry))
 
     def open(self) -> BinaryIO:
         if self.is_dir():
             raise IsADirectoryError(self.path)
         return self._resolve().entry.open()
 
-    def _iterdir(self) -> Iterator[btrfs.INode]:
+    def scandir(self) -> Iterator[BtrfsDirEntry]:
         if not self.is_dir():
             raise NotADirectoryError(self.path)
 
-        if self.is_symlink():
-            for entry in self.readlink_ext().iterdir():
-                yield entry
-        else:
-            for name, entry in self.entry.iterdir():
-                if name in (".", ".."):
-                    continue
-
-                yield name, entry
-
-    def iterdir(self) -> Iterator[str]:
-        for name, _ in self._iterdir():
-            yield name
+        for name, entry in self._resolve().entry.iterdir():
+            if name in (".", ".."):
+                continue
 
-    def scandir(self) -> Iterator[FilesystemEntry]:
-        for name, entry in self._iterdir():
-            entry_path = fsutil.join(self.path, name, alt_separator=self.fs.alt_separator)
-            yield BtrfsFilesystemEntry(self.fs, entry_path, entry)
+            # TODO: Separate INodes and DirEntry in dissect.btrfs
+            yield BtrfsDirEntry(self.fs, self.path, name, entry)
 
     def is_dir(self, follow_symlinks: bool = True) -> bool:
         try:

{dissect_target-3.25.dev0 → dissect_target-3.25.dev1}/dissect/target/filesystems/cb.py

@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING, Any, BinaryIO
 from dissect.util import ts
 
 from dissect.target.exceptions import FileNotFoundError, NotADirectoryError
-from dissect.target.filesystem import Filesystem, FilesystemEntry
+from dissect.target.filesystem import DirEntry, Filesystem, FilesystemEntry
 from dissect.target.helpers import fsutil
 
 if TYPE_CHECKING:
@@ -86,6 +86,18 @@ class CbFilesystem(Filesystem):
             raise FileNotFoundError(path)
 
 
+class CbDirEntry(DirEntry):
+    fs: CbFilesystem
+    entry: tuple[dict[str, Any], str]
+
+    def get(self) -> CbFilesystemEntry:
+        entry, cbpath = self.entry
+        return CbFilesystemEntry(self.fs, self.path, entry, cbpath)
+
+    def stat(self, *, follow_symlinks: bool = True) -> fsutil.stat_result:
+        return self.get().stat(follow_symlinks=follow_symlinks)
+
+
 class CbFilesystemEntry(FilesystemEntry):
     def __init__(self, fs: Filesystem, path: str, entry: Any, cbpath: str):
         super().__init__(fs, path, entry)
@@ -100,25 +112,22 @@ class CbFilesystemEntry(FilesystemEntry):
         """Returns file handle (file-like object)."""
         return self.fs.session.get_raw_file(self.cbpath)
 
-    def iterdir(self) -> Iterator[str]:
-        """List the directory contents of a directory. Returns a generator of strings."""
-        for entry in self.scandir():
-            yield entry.name
-
-    def scandir(self) -> Iterator[CbFilesystemEntry]:
+    def scandir(self) -> Iterator[CbDirEntry]:
         """List the directory contents of this directory. Returns a generator of filesystem entries."""
         if not self.is_dir():
-            raise NotADirectoryError(f"'{self.path}' is not a directory")
+            raise NotADirectoryError(self.path)
 
         separator = self.fs.alt_separator or "/"
         for entry in self.fs.session.list_directory(self.cbpath + separator):
-            filename = entry["filename"]
-            if filename in (".", ".."):
+            if entry["filename"] in (".", ".."):
                 continue
 
-            path = fsutil.join(self.path, filename, alt_separator=self.fs.alt_separator)
-            cbpath = separator.join([self.cbpath, filename])
-            yield CbFilesystemEntry(self.fs, path, entry, cbpath)
+            yield CbDirEntry(
+                self.fs,
+                self.path,
+                entry["filename"],
+                (entry, separator.join([self.cbpath, entry["filename"]])),
+            )
 
     def is_dir(self, follow_symlinks: bool = True) -> bool:
         """Return whether this entry is a directory."""

{dissect_target-3.25.dev0 → dissect_target-3.25.dev1}/dissect/target/filesystems/config.py

@@ -5,7 +5,7 @@ import textwrap
 from typing import TYPE_CHECKING, Any, BinaryIO
 
 from dissect.target.exceptions import ConfigurationParsingError, FileNotFoundError
-from dissect.target.filesystem import FilesystemEntry, VirtualFilesystem
+from dissect.target.filesystem import DirEntry, FilesystemEntry, VirtualFilesystem
 from dissect.target.helpers import fsutil
 from dissect.target.helpers.configutil import ConfigurationParser, parse
 from dissect.target.helpers.logging import get_logger
@@ -131,6 +131,17 @@ class ConfigurationFilesystem(VirtualFilesystem):
         return ConfigurationEntry(self, entry.path, entry, config_parser)
 
 
+class ConfigurationDirEntry(DirEntry):
+    fs: ConfigurationFilesystem
+    entry: tuple[FilesystemEntry, dict | ConfigurationParser | str | list | None]
+
+    def get(self) -> ConfigurationEntry:
+        return ConfigurationEntry(self.fs, self.path, self.entry[0], self.entry[1])
+
+    def stat(self, *, follow_symlinks: bool = True) -> fsutil.stat_result:
+        return self.get().stat(follow_symlinks=follow_symlinks)
+
+
 class ConfigurationEntry(FilesystemEntry):
     """A Special filesystem entry.
 
@@ -262,22 +273,17 @@ class ConfigurationEntry(FilesystemEntry):
         output_data = self._write_value_mapping(self.parser_items)
         return io.BytesIO(bytes(output_data, "utf-8"))
 
-    def iterdir(self) -> Iterator[str]:
-        for entry in self.scandir():
-            yield entry.name
-
-    def scandir(self) -> Iterator[ConfigurationEntry]:
-        """Return the items inside :attr:`parser_items` as ``ConfigurationEntries``."""
+    def scandir(self) -> Iterator[ConfigurationDirEntry]:
         if self.is_file():
-            raise NotADirectoryError
+            raise NotADirectoryError(self.path)
 
         if self.parser_items is None and self.entry.is_dir():
             for entry in self.entry.scandir():
-                yield ConfigurationEntry(self.fs, entry.name, entry, None)
+                yield ConfigurationDirEntry(self.fs, self.path, entry.name, (entry.get(), None))
             return
 
         for key, values in self.parser_items.items():
-            yield ConfigurationEntry(self.fs, key, self.entry, values)
+            yield ConfigurationDirEntry(self.fs, self.path, key, (self.entry, values))
 
     def is_file(self, follow_symlinks: bool = True) -> bool:
         return not self.is_dir(follow_symlinks)