dissect.target 3.14.dev29__py3-none-any.whl → 3.15__py3-none-any.whl

dissect/target/plugin.py

@@ -64,7 +64,7 @@ class OperatingSystem(StrEnum):
     ANDROID = "android"
     VYOS = "vyos"
     IOS = "ios"
-    FORTIGATE = "fortigate"
+    FORTIOS = "fortios"
     CITRIX = "citrix-netscaler"
 
 
@@ -215,8 +215,6 @@ class Plugin:
     produce redundant results when used with a wild card
     (browser.* -> browser.history + browser.*.history).
     """
-    __skip__: bool = False
-    """Prevents plugin functions from indexing this plugin at all."""
 
     def __init_subclass__(cls, **kwargs):
         super().__init_subclass__(**kwargs)
@@ -294,18 +292,43 @@ class OSPlugin(Plugin):
     This provides a base class for certain common functions of OS's, which each OS plugin has to implement separately.
 
     For example, it provides an interface for retrieving the hostname and users of a target.
+
+    All derived classes MUST implement ALL the classmethods and exported
+    methods with the same ``@classmethod`` or ``@export(...)`` annotation.
     """
 
+    def __init_subclass__(cls, **kwargs):
+        # Note that cls is the subclass
+        super().__init_subclass__(**kwargs)
+
+        for os_method in get_nonprivate_attributes(OSPlugin):
+            if isinstance(os_method, property):
+                os_method = os_method.fget
+            os_docstring = os_method.__doc__
+
+            method = getattr(cls, os_method.__name__, None)
+            if isinstance(method, property):
+                method = method.fget
+            # This works as None has a __doc__ property (which is None).
+            docstring = method.__doc__
+
+            if method and not docstring:
+                if hasattr(method, "__func__"):
+                    method = method.__func__
+                method.__doc__ = os_docstring
+
     def check_compatible(self) -> bool:
-        """OSPlugin's use a different compatibility check, override the default one."""
+        """OSPlugin's use a different compatibility check, override the one from the :class:`Plugin` class.
+
+        Returns:
+            This function always returns ``True``.
+        """
         return True
 
     @classmethod
     def detect(cls, fs: Filesystem) -> Optional[Filesystem]:
         """Provide detection of this OSPlugin on a given filesystem.
 
-        Note: must be implemented as a classmethod.
-
         Args:
             fs: :class:`~dissect.target.filesystem.Filesystem` to detect the OS on.
 
@@ -318,11 +341,9 @@ class OSPlugin(Plugin):
     def create(cls, target: Target, sysvol: Filesystem) -> OSPlugin:
         """Initiate this OSPlugin with the given target and detected filesystem.
 
-        Note: must be implemented as a classmethod.
-
         Args:
-            target: The Target object.
-            sysvol: The filesystem that was detected in the detect() function.
+            target: The :class:`~dissect.target.target.Target` object.
+            sysvol: The filesystem that was detected in the ``detect()`` function.
 
         Returns:
             An instantiated version of the OSPlugin.
@@ -331,9 +352,7 @@ class OSPlugin(Plugin):
 
     @export(property=True)
     def hostname(self) -> Optional[str]:
-        """Required OS function.
-
-        Implementations must be decorated with ``@export(property=True)``.
+        """Return the target's hostname.
 
         Returns:
             The hostname as string.
@@ -342,9 +361,7 @@ class OSPlugin(Plugin):
 
     @export(property=True)
     def ips(self) -> list[str]:
-        """Required OS function.
-
-        Implementations must be decorated with ``@export(property=True)``.
+        """Return the IP addresses configured in the target.
 
         Returns:
             The IPs as list.
@@ -353,9 +370,7 @@ class OSPlugin(Plugin):
 
     @export(property=True)
     def version(self) -> Optional[str]:
-        """Required OS function.
-
-        Implementations must be decorated with ``@export(property=True)``.
+        """Return the target's OS version.
 
         Returns:
             The OS version as string.
@@ -364,9 +379,7 @@ class OSPlugin(Plugin):
 
     @export(record=EmptyRecord)
     def users(self) -> list[Record]:
-        """Required OS function.
-
-        Implementations must be decorated with @export.
+        """Return the users available in the target.
 
         Returns:
             A list of user records.
@@ -375,9 +388,7 @@ class OSPlugin(Plugin):
 
     @export(property=True)
     def os(self) -> str:
-        """Required OS function.
-
-        Implementations must be decorated with ``@export(property=True)``.
+        """Return a slug of the target's OS name.
 
         Returns:
             A slug of the OS name, e.g. 'windows' or 'linux'.
@@ -386,9 +397,7 @@ class OSPlugin(Plugin):
 
     @export(property=True)
     def architecture(self) -> Optional[str]:
-        """Required OS function.
-
-        Implementations must be decorated with ``@export(property=True)``.
+        """Return a slug of the target's OS architecture.
 
         Returns:
             A slug of the OS architecture, e.g. 'x86_32-unix', 'MIPS-linux' or
@@ -472,16 +481,8 @@ def register(plugincls: Type[Plugin]) -> None:
         elif issubclass(plugincls, ChildTargetPlugin):
             special_key = "_child"
 
-        if special_key not in root:
-            root[special_key] = []
-        else:
-            plugins = [obj for obj in root[special_key] if obj["class"] == plugincls.__name__]
-            if len(plugins):
-                return
-
-        special_root = {}
-        root[special_key].append(special_root)
-        root = special_root
+        root[special_key] = {}
+        root = root[special_key]
 
     # Check if the plugin was already registered
     if "class" in root and root["class"] == plugincls.__name__:
@@ -494,6 +495,7 @@ def register(plugincls: Type[Plugin]) -> None:
     root["exports"] = plugincls.__exports__
     root["namespace"] = plugincls.__namespace__
     root["fullname"] = ".".join((plugincls.__module__, plugincls.__qualname__))
+    root["is_osplugin"] = issubclass(plugincls, OSPlugin)
 
 
 def internal(*args, **kwargs) -> Callable:
@@ -540,74 +542,166 @@ def arg(*args, **kwargs) -> Callable:
     return decorator
 
 
-def plugins(osfilter: Optional[type[OSPlugin]] = None) -> Iterator[PluginDescriptor]:
-    """Retrieve all plugin descriptors.
+def plugins(
+    osfilter: Optional[type[OSPlugin]] = None,
+    special_keys: set[str] = set(),
+    only_special_keys: bool = False,
+) -> Iterator[PluginDescriptor]:
+    """Walk the ``PLUGINS`` tree and return plugins.
 
-    Args:
-        osfilter: The ``OSPlugin`` to use as template to find os specific plugins for.
+    If ``osfilter`` is specified, only plugins related to the provided
+    OSPlugin, or plugins with no OS relation are returned.
+    If ``osfilter`` is ``None``, all plugins will be returned.
 
-    Returns:
-        An iterator of all plugin descriptors, optionally filtered on OS.
-    """
+    One exception to this is if the ``osfilter`` is a (sub-)class of
+    DefaultPlugin, then plugins are returned as if no ``osfilter`` was
+    specified.
 
-    def _walk(osfilter: str = None, root: dict = None) -> Iterator[PluginDescriptor]:
-        for key, obj in root.items():
-            if key.startswith("_"):
-                continue
+    Another exeption to this are plugins in the ``PLUGINS`` tree which are
+    under a key that starts with a '_'. Those are only returned if their exact
+    key is specified in ``special_keys``.
 
-            if "functions" not in obj:
-                for plugin_desc in _walk(osfilter, obj):
-                    yield plugin_desc
-            else:
-                if osfilter and obj["module"].startswith("os") and not obj["module"].startswith(osfilter):
-                    continue
+    An exception to these exceptions is in the case of ``OSPlugin`` (sub-)class
+    plugins and ``os_filter`` is not ``None``. These plugins live in the
+    ``PLUGINS`` tree under the ``_os`` special key. Those plugins are only
+    returned if they fully match the provided ``osfilter``.
 
-                yield obj
+    The ``only_special_keys`` option returns only the plugins which are under a
+    special key that is defined in ``special_keys``. All filtering here will
+    happen as stated in the above cases.
 
-    if (
-        osfilter
-        and isinstance(osfilter, type)
-        and issubclass(osfilter, OSPlugin)
-        and not issubclass(osfilter, general.default.DefaultPlugin)
-        and osfilter.__module__.startswith(MODULE_PATH)
-    ):
-        osfilter, _, _ = osfilter.__module__.replace(MODULE_PATH, "", 1).strip(".").rpartition(".")
-
-        # Continue walking up the OS filter tree until we hit the second level
-        # As an example, it walk os.unix.debian, followed by os.unix, then exit
-        os_parts = osfilter.split(".")
-        while len(os_parts) >= 2:
-            yield from _walk(".".join(os_parts), _get_plugins())
-            os_parts.pop()
-    else:
-        yield from _walk(None, _get_plugins())
+    Args:
+        osfilter: The optional OSPlugin to filter the returned plugins on.
+        special_keys: Also return plugins which are under the special ('_') keys in this set.
+        only_special_keys: Only return the plugins under the keys in ``special_keys`` and no others.
 
+    Yields:
+        Plugins in the ``PLUGINS`` tree based on the given filter criteria.
+    """
 
-def _special_plugins(special_key: str) -> Iterator[PluginDescriptor]:
-    """Retrieve plugin descriptors stored under ``special_key``."""
+    if osfilter is not None:
+        # The PLUGINS tree does not include the hierarchy up to the plugins
+        # directory (dissect.target.plugins) for the built-in plugins. For the
+        # plugins in the directory specified in --plugin-path, the hierarchy
+        # starts at that directory.
+        #
+        # Built-in OSPlugins do have the dissect.target.plugins path in their
+        # module name, so it needs to be stripped, e.g.:
+        #   dissect.target.plugins.general.default -> general.default
+        #   dissect.target.plugins.windows._os -> plugins.windows._os
+        #
+        # The module name of OSPlugins from --plugin-path starts at the
+        # directory specified in that option, e.g.:
+        # --plugin-path=/some/path/, with a file foo/baros/_os.py
+        # will have a module name of: foo.baros._os
+        filter_path = _modulepath(osfilter).split(".")
+
+        # If an OSPlugin is not defined in a file called _os.py, an extra `_os`
+        # part is added to the PLUGINS tree.
+        # For example the default OS plugin with module name general.default
+        # (after stripping of the build-in hierarchy) will be added at:
+        # general
+        #        \- default
+        #                  \- _os
+        # However the `_os` part is not in the module name. Modules that are
+        # defined in an _os.py file have the `_os` part in their module name.
+        # It is stripped out, so the filter is similar for both types of
+        # OSPlugin files.
+        if filter_path[-1] == "_os":
+            filter_path = filter_path[:-1]
+    else:
+        filter_path = []
 
-    def _walk(root=None):
+    def _walk(
+        root: dict,
+        special_keys: set[str] = set(),
+        only_special_keys: bool = False,
+        prev_module_path: list[str] = [],
+    ):
         for key, obj in root.items():
-            if key == special_key:
-                yield from obj
-
-            elif key.startswith("_"):
-                continue
-
-            elif "functions" not in obj:
-                yield from _walk(obj)
+            module_path = prev_module_path.copy()
+            module_path.append(key)
+
+            # A branch in the PLUGINS tree is traversed to the next level if:
+            # - there are no filters (which in effect means all plugins are
+            # returned including all _os plugins).
+            # - the osfilter is the default plugin (which means all normal plugins but
+            # only the default _os plugin is returned).
+            # - there is no _os plugin on the next level (we're traversing a
+            # "normal" plugin branch or already jumped into an OS specific
+            # branch because of a filter_path match)
+            # - the current module_path fully matches the (beginning of) the
+            # filter path (this allows traversing into the specific os branch
+            # for the given os filter and any sub branches which are not os
+            # branches (of a sub-os) themselves).
+            if (
+                not filter_path
+                or issubclass(osfilter, general.default.DefaultPlugin)
+                or "_os" not in obj
+                or module_path == filter_path[: len(module_path)]
+            ):
+                if key.startswith("_"):
+                    if key in special_keys:
+                        # OSPlugins are treated special and are only returned
+                        # if their module_path matches the full filter_path.
+                        #
+                        # Note that the module_path includes the `_os` part,
+                        # which may have been explicitly added in the
+                        # hierarchy. This part needs to be stripped out when
+                        # matching against the filter_path, where it was either
+                        # not present or stripped out.
+                        if key != "_os" or (
+                            key == "_os" and (not filter_path or (filter_path and module_path[:-1] == filter_path))
+                        ):
+                            # If the special key is a leaf-node, we just give it back.
+                            # If it is a branch, we give back the full branch,
+                            # not just the special_keys if only_special_keys
+                            # was set to True.
+                            if "functions" in obj:
+                                yield obj
+                            else:
+                                yield from _walk(
+                                    obj,
+                                    special_keys=special_keys,
+                                    only_special_keys=False,
+                                    prev_module_path=module_path,
+                                )
+                        else:
+                            continue
+                    else:
+                        continue
 
-    yield from _walk(_get_plugins())
+                else:
+                    if "functions" in obj:
+                        if not (special_keys and only_special_keys):
+                            yield obj
+                    else:
+                        yield from _walk(
+                            obj,
+                            special_keys=special_keys,
+                            only_special_keys=only_special_keys,
+                            prev_module_path=module_path,
+                        )
+
+    yield from sorted(
+        _walk(
+            _get_plugins(),
+            special_keys=special_keys,
+            only_special_keys=only_special_keys,
+        ),
+        key=lambda plugin: len(plugin["module"]),
+        reverse=True,
+    )
 
 
 def os_plugins() -> Iterator[PluginDescriptor]:
     """Retrieve all OS plugin descriptors."""
-    yield from _special_plugins("_os")
+    yield from plugins(special_keys={"_os"}, only_special_keys=True)
 
 
 def child_plugins() -> Iterator[PluginDescriptor]:
     """Retrieve all child plugin descriptors."""
-    yield from _special_plugins("_child")
+    yield from plugins(special_keys={"_child"}, only_special_keys=True)
 
 
 def lookup(func_name: str, osfilter: Optional[type[OSPlugin]] = None) -> Iterator[PluginDescriptor]:
@@ -645,7 +739,7 @@ def get_plugins_by_namespace(namespace: str, osfilter: Optional[type[OSPlugin]]
             yield plugin_desc
 
 
-def load(plugin_desc: dict) -> Type[Plugin]:
+def load(plugin_desc: PluginDescriptor) -> Type[Plugin]:
     """Helper function that loads a plugin from a given plugin description.
 
     Args:
@@ -729,7 +823,7 @@ def load_module_from_name(module_path: str) -> None:
         # This will trigger the __init__subclass__() of the Plugin subclasses in the module.
         importlib.import_module(module_path)
     except Exception as e:
-        log.error("Unable to import %s", module_path)
+        log.info("Unable to import %s", module_path)
         log.debug("Error while trying to import module %s", module_path, exc_info=e)
         save_plugin_import_failure(module_path)
 
@@ -815,7 +909,8 @@ def _traverse(key: str, obj: dict[str, Any]) -> dict[str, Any]:
 
 def _modulepath(cls) -> str:
     """Returns the module path of a :class:`Plugin` relative to ``dissect.target.plugins``."""
-    return cls.__module__.replace(MODULE_PATH, "").lstrip(".")
+    module = getattr(cls, "__module__", "")
+    return module.replace(MODULE_PATH, "").lstrip(".")
 
 
 # These need to be at the bottom of the module because __init_subclass__ requires everything
@@ -860,6 +955,10 @@ class NamespacePlugin(Plugin):
         # the direct subclass of NamespacePlugin
         cls.__nsplugin__.SUBPLUGINS.add(cls.__namespace__)
 
+        # Generate a tuple of class names for which we do not want to add subplugin functions, which is the
+        # namespaceplugin and all of its superclasses (minus the base object).
+        reserved_cls_names = tuple({_class.__name__ for _class in cls.__nsplugin__.mro() if _class is not object})
+
         # Collect the public attrs of the subplugin
         for subplugin_func_name in cls.__exports__:
             subplugin_func = inspect.getattr_static(cls, subplugin_func_name)
@@ -872,12 +971,15 @@ class NamespacePlugin(Plugin):
             if getattr(subplugin_func, "__output__", None) != "record":
                 continue
 
-            # The method needs to be part of the current subclass and not a parent
-            if not subplugin_func.__qualname__.startswith(cls.__name__):
+            # The method may not be part of a parent class.
+            if subplugin_func.__qualname__.startswith(reserved_cls_names):
                 continue
 
             # If we already have an aggregate method, skip
             if existing_aggregator := getattr(cls.__nsplugin__, subplugin_func_name, None):
+                if not hasattr(existing_aggregator, "__subplugins__"):
+                    # This is not an aggregator, but a re-implementation of a subclass function by the subplugin.
+                    continue
                 existing_aggregator.__subplugins__.append(cls.__namespace__)
                 continue
 
@@ -887,10 +989,12 @@ class NamespacePlugin(Plugin):
                     for entry in aggregator.__subplugins__:
                         try:
                             subplugin = getattr(self.target, entry)
-                            for item in getattr(subplugin, method_name)():
-                                yield item
-                        except Exception:
+                            yield from getattr(subplugin, method_name)()
+                        except UnsupportedPluginError:
                             continue
+                        except Exception as e:
+                            self.target.log.error("Subplugin: %s raised an exception for: %s", entry, method_name)
+                            self.target.log.debug("Exception: %s", e, exc_info=e)
 
                 # Holds the subplugins that share this method
                 aggregator.__subplugins__ = []
@@ -973,54 +1077,65 @@ class PluginFunction:
     output_type: str
     class_object: type[Plugin]
     method_name: str
-    plugin_desc: dict = field(hash=False)
+    plugin_desc: PluginDescriptor = field(hash=False)
 
 
-def plugin_function_index(target: Target) -> tuple[dict[str, Any], set[str]]:
+def plugin_function_index(target: Optional[Target]) -> tuple[dict[str, PluginDescriptor], set[str]]:
     """Returns an index-list for plugins.
 
     This list is used to match CLI expressions against to find the desired plugin.
     Also returns the roots to determine whether a CLI expression has to be compared
     to the plugin tree or parsed using legacy rules.
     """
+
+    if target is None:
+        os_type = None
+    elif target._os_plugin is None:
+        os_type = general.default.DefaultPlugin
+    elif isinstance(target._os_plugin, type) and issubclass(target._os_plugin, OSPlugin):
+        os_type = target._os_plugin
+    elif isinstance(target._os_plugin, OSPlugin):
+        os_type = type(target._os_plugin)
+    else:
+        raise TypeError(
+            "target must be None or target._os_plugin must be either None, "
+            "a subclass of OSPlugin or an instance of OSPlugin"
+        )
+
     index = {}
     rootset = set()
 
-    def all_plugins():
-        # Filter out plugins based on the target os
-        os_type = type(target._os) if target._os and target._os.os != "default" else None
+    all_plugins = plugins(osfilter=os_type, special_keys={"_child", "_os"})
 
-        yield from plugins(os_type)
-        yield from os_plugins()
-        yield from child_plugins()  # Doesn't export anything but added for completeness.
-
-    for available_original in all_plugins():
+    for available_original in all_plugins:
         # Prevent modifying the global PLUGINS dict, otherwise -f os.windows._os.users fails for instance.
         available = available_original.copy()
+
+        modulepath = available["module"]
+        rootset.add(modulepath.split(".")[0])
+
         if "get_all_records" in available["exports"]:
+            # The get_all_records does not only need to be not present in the
+            # index, it also needs to be removed from the exports list, else
+            # the 'plugins' plugin will still display them.
             available["exports"].remove("get_all_records")
-        modulepath = available["module"]
 
-        if modulepath.endswith("._os"):
-            if not target._os:
-                # if no target available add a namespaceless section
+        for exported in available["exports"]:
+            if available["is_osplugin"] and os_type == general.default.DefaultPlugin:
+                # This makes the os plugin exports listed under the special
+                # "OS plugins" header by the 'plugins' plugin.
                 available["module"] = ""
-            elif target._os.__class__.__name__ != available["class"]:
-                continue
-            rootset.add(modulepath.split(".")[0])
-            for exported in available["exports"]:
-                index[f"{modulepath}.{exported}"] = available
-                index[exported] = available
-        else:
-            rootset.add(modulepath.split(".")[0])
-            for exported in available["exports"]:
-                index[f"{modulepath}.{exported}"] = available
+
+            index[f"{modulepath}.{exported}"] = available
 
     return index, rootset
 
 
 def find_plugin_functions(
-    target: Target, patterns: str, compatibility: bool = False, **kwargs
+    target: Optional[Target],
+    patterns: str,
+    compatibility: bool = False,
+    **kwargs,
 ) -> tuple[list[PluginFunction], set[str]]:
     """Finds plugins that match the target and the patterns.
 
@@ -1030,10 +1145,6 @@ def find_plugin_functions(
     """
     result = []
 
-    def add_to_result(func: PluginFunction) -> None:
-        if func not in result and not func.class_object.__skip__:
-            result.append(func)
-
     functions, rootset = plugin_function_index(target)
 
     invalid_funcs = set()
@@ -1041,29 +1152,45 @@ def find_plugin_functions(
     ignore_load_errors = kwargs.get("ignore_load_errors", False)
 
     for pattern in patterns.split(","):
-        # backward compatibility fix for namespace-level plugins (i.e. chrome)
+        # Backward compatibility fix for namespace-level plugins (i.e. chrome)
+        # If an exact namespace match is found, the pattern is changed to the tree to that namespace.
+        # Examples:
+        #     -f browser -> apps.browser.browser
+        #     -f iexplore -> apps.browser.iexplore
+        namespace_match = False
         for index_name, func in functions.items():
             if func["namespace"] == pattern:
-                pattern = func["module"] + "*"
+                pattern = func["module"]
+                namespace_match = True
+                break
 
         wildcard = any(char in pattern for char in ["*", "!", "?", "[", "]"])
         treematch = pattern.split(".")[0] in rootset and pattern != "os"
         exact_match = pattern in functions
 
-        # Allow for exact matches, otherwise you cannot reach documented namespace plugins like
-        # browsers.browser.downloads. You can *always* run these using the namespace/classic-style like:
-        # browser.downloads (but -l lists them in the tree for documentation purposes so it would be misleading
-        # not to allow tree access as well). Note that these tree items will never respond to wildcards though
-        # (browsers.browser.* won't work) to avoid duplicate results.
-        if exact_match:
+        # Allow for exact and namespace matches even if the plugin does not want to be found, otherwise you cannot
+        # reach documented namespace plugins like apps.browser.browser.downloads.
+        # You can *always* run these using the namespace/classic-style like: browser.downloads (but -l lists them
+        # in the tree for documentation purposes so it would be misleading not to allow tree access as well).
+        #
+        # Note that these tree items will never respond to wildcards though to avoid duplicate results, e.g. when
+        # querying apps.browser.*, this also means apps.browser.browser.* won't work.
+        if exact_match or namespace_match:
             show_hidden = True
 
-        if treematch and not wildcard and not exact_match:
-            # Examples:
-            #     -f browsers -> browsers* (the whole package)
-            #     -f apps.webservers.iis -> apps.webservers.iis* (logs etc)
-            # We do not include  a dot because that does not work if the full path is given:
-            #     -f apps.webservers.iis.logs != apps.webservers.iis.logs.* (does not work)
+        # Change the treematch pattern into an fnmatch-able pattern to give back all functions from the sub-tree
+        # (if there is a subtree).
+        #
+        # Examples:
+        #     -f browser -> apps.browser.browser* (the whole package, due to a namespace match)
+        #     -f apps.webservers.iis -> apps.webservers.iis* (logs etc)
+        #     -f apps.webservers.iis.logs -> apps.webservers.iis.logs* (only the logs, there is no subtree)
+        # We do not include a dot because that does not work if the full path is given:
+        #     -f apps.webservers.iis.logs != apps.webservers.iis.logs.* (does not work)
+        #
+        # In practice a namespace_match would almost always also be a treematch, except when the namespace plugin
+        # is in the root of the plugin tree.
+        if (treematch or namespace_match) and not wildcard and not exact_match:
             pattern += "*"
 
         if wildcard or treematch:
@@ -1086,6 +1213,8 @@ def find_plugin_functions(
                 fobject = inspect.getattr_static(loaded_plugin_object, method_name)
 
                 if compatibility:
+                    if target is None:
+                        continue
                     try:
                         if not loaded_plugin_object(target).is_compatible():
                             continue
@@ -1093,7 +1222,7 @@ def find_plugin_functions(
                         continue
 
                 matches = True
-                add_to_result(
+                result.append(
                     PluginFunction(
                         name=f"{func['namespace']}.{method_name}" if func["namespace"] else method_name,
                         path=index_name,
@@ -1116,9 +1245,9 @@ def find_plugin_functions(
                 namespace = None
 
             plugin_descriptions = []
-            for _, func in functions.items():
-                nsmatch = namespace and func["namespace"] == namespace and funcname in func["exports"]
-                fmatch = not namespace and not func["namespace"] and funcname in func["exports"]
+            for func_path, func in functions.items():
+                nsmatch = namespace and func["namespace"] == namespace and func_path.split(".")[-1] == funcname
+                fmatch = not namespace and not func["namespace"] and func_path.split(".")[-1] == funcname
                 if nsmatch or fmatch:
                     plugin_descriptions.append(func)
 
@@ -1138,7 +1267,7 @@ def find_plugin_functions(
                 if compatibility and not loaded_plugin_object(target).is_compatible():
                     continue
 
-                add_to_result(
+                result.append(
                     PluginFunction(
                         name=f"{description['namespace']}.{funcname}" if description["namespace"] else funcname,
                         path=f"{description['module']}.{funcname}",