frida 16.2.0 → 16.2.2

package/releng/tomlkit/tomlkit/source.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+from copy import copy
+from typing import Any
+
+from tomlkit.exceptions import ParseError
+from tomlkit.exceptions import UnexpectedCharError
+from tomlkit.toml_char import TOMLChar
+
+
+class _State:
+    def __init__(
+        self,
+        source: Source,
+        save_marker: bool | None = False,
+        restore: bool | None = False,
+    ) -> None:
+        self._source = source
+        self._save_marker = save_marker
+        self.restore = restore
+
+    def __enter__(self) -> _State:
+        # Entering this context manager - save the state
+        self._chars = copy(self._source._chars)
+        self._idx = self._source._idx
+        self._current = self._source._current
+        self._marker = self._source._marker
+
+        return self
+
+    def __exit__(self, exception_type, exception_val, trace):
+        # Exiting this context manager - restore the prior state
+        if self.restore or exception_type:
+            self._source._chars = self._chars
+            self._source._idx = self._idx
+            self._source._current = self._current
+            if self._save_marker:
+                self._source._marker = self._marker
+
+
+class _StateHandler:
+    """
+    State preserver for the Parser.
+    """
+
+    def __init__(self, source: Source) -> None:
+        self._source = source
+        self._states = []
+
+    def __call__(self, *args, **kwargs):
+        return _State(self._source, *args, **kwargs)
+
+    def __enter__(self) -> _State:
+        state = self()
+        self._states.append(state)
+        return state.__enter__()
+
+    def __exit__(self, exception_type, exception_val, trace):
+        state = self._states.pop()
+        return state.__exit__(exception_type, exception_val, trace)
+
+
+class Source(str):
+    EOF = TOMLChar("\0")
+
+    def __init__(self, _: str) -> None:
+        super().__init__()
+
+        # Collection of TOMLChars
+        self._chars = iter([(i, TOMLChar(c)) for i, c in enumerate(self)])
+
+        self._idx = 0
+        self._marker = 0
+        self._current = TOMLChar("")
+
+        self._state = _StateHandler(self)
+
+        self.inc()
+
+    def reset(self):
+        # initialize both idx and current
+        self.inc()
+
+        # reset marker
+        self.mark()
+
+    @property
+    def state(self) -> _StateHandler:
+        return self._state
+
+    @property
+    def idx(self) -> int:
+        return self._idx
+
+    @property
+    def current(self) -> TOMLChar:
+        return self._current
+
+    @property
+    def marker(self) -> int:
+        return self._marker
+
+    def extract(self) -> str:
+        """
+        Extracts the value between marker and index
+        """
+        return self[self._marker : self._idx]
+
+    def inc(self, exception: type[ParseError] | None = None) -> bool:
+        """
+        Increments the parser if the end of the input has not been reached.
+        Returns whether or not it was able to advance.
+        """
+        try:
+            self._idx, self._current = next(self._chars)
+
+            return True
+        except StopIteration:
+            self._idx = len(self)
+            self._current = self.EOF
+            if exception:
+                raise self.parse_error(exception)
+
+            return False
+
+    def inc_n(self, n: int, exception: type[ParseError] | None = None) -> bool:
+        """
+        Increments the parser by n characters
+        if the end of the input has not been reached.
+        """
+        return all(self.inc(exception=exception) for _ in range(n))
+
+    def consume(self, chars, min=0, max=-1):
+        """
+        Consume chars until min/max is satisfied is valid.
+        """
+        while self.current in chars and max != 0:
+            min -= 1
+            max -= 1
+            if not self.inc():
+                break
+
+        # failed to consume minimum number of characters
+        if min > 0:
+            raise self.parse_error(UnexpectedCharError, self.current)
+
+    def end(self) -> bool:
+        """
+        Returns True if the parser has reached the end of the input.
+        """
+        return self._current is self.EOF
+
+    def mark(self) -> None:
+        """
+        Sets the marker to the index's current position
+        """
+        self._marker = self._idx
+
+    def parse_error(
+        self,
+        exception: type[ParseError] = ParseError,
+        *args: Any,
+        **kwargs: Any,
+    ) -> ParseError:
+        """
+        Creates a generic "parse error" at the current position.
+        """
+        line, col = self._to_linecol()
+
+        return exception(line, col, *args, **kwargs)
+
+    def _to_linecol(self) -> tuple[int, int]:
+        cur = 0
+        for i, line in enumerate(self.splitlines()):
+            if cur + len(line) + 1 > self.idx:
+                return (i + 1, self.idx - cur)
+
+            cur += len(line) + 1
+
+        return len(self.splitlines()), 0

package/releng/tomlkit/tomlkit/toml_char.py

@@ -0,0 +1,52 @@
+import string
+
+
+class TOMLChar(str):
+    def __init__(self, c):
+        super().__init__()
+
+        if len(self) > 1:
+            raise ValueError("A TOML character must be of length 1")
+
+    BARE = string.ascii_letters + string.digits + "-_"
+    KV = "= \t"
+    NUMBER = string.digits + "+-_.e"
+    SPACES = " \t"
+    NL = "\n\r"
+    WS = SPACES + NL
+
+    def is_bare_key_char(self) -> bool:
+        """
+        Whether the character is a valid bare key name or not.
+        """
+        return self in self.BARE
+
+    def is_kv_sep(self) -> bool:
+        """
+        Whether the character is a valid key/value separator or not.
+        """
+        return self in self.KV
+
+    def is_int_float_char(self) -> bool:
+        """
+        Whether the character if a valid integer or float value character or not.
+        """
+        return self in self.NUMBER
+
+    def is_ws(self) -> bool:
+        """
+        Whether the character is a whitespace character or not.
+        """
+        return self in self.WS
+
+    def is_nl(self) -> bool:
+        """
+        Whether the character is a new line character or not.
+        """
+        return self in self.NL
+
+    def is_spaces(self) -> bool:
+        """
+        Whether the character is a space or not
+        """
+        return self in self.SPACES

package/releng/tomlkit/tomlkit/toml_document.py

@@ -0,0 +1,7 @@
+from tomlkit.container import Container
+
+
+class TOMLDocument(Container):
+    """
+    A TOML document.
+    """

package/releng/tomlkit/tomlkit/toml_file.py

@@ -0,0 +1,58 @@
+import os
+import re
+
+from typing import TYPE_CHECKING
+
+from tomlkit.api import loads
+from tomlkit.toml_document import TOMLDocument
+
+
+if TYPE_CHECKING:
+    from _typeshed import StrPath as _StrPath
+else:
+    from typing import Union
+
+    _StrPath = Union[str, os.PathLike]
+
+
+class TOMLFile:
+    """
+    Represents a TOML file.
+
+    :param path: path to the TOML file
+    """
+
+    def __init__(self, path: _StrPath) -> None:
+        self._path = path
+        self._linesep = os.linesep
+
+    def read(self) -> TOMLDocument:
+        """Read the file content as a :class:`tomlkit.toml_document.TOMLDocument`."""
+        with open(self._path, encoding="utf-8", newline="") as f:
+            content = f.read()
+
+            # check if consistent line endings
+            num_newline = content.count("\n")
+            if num_newline > 0:
+                num_win_eol = content.count("\r\n")
+                if num_win_eol == num_newline:
+                    self._linesep = "\r\n"
+                elif num_win_eol == 0:
+                    self._linesep = "\n"
+                else:
+                    self._linesep = "mixed"
+
+            return loads(content)
+
+    def write(self, data: TOMLDocument) -> None:
+        """Write the TOMLDocument to the file."""
+        content = data.as_string()
+
+        # apply linesep
+        if self._linesep == "\n":
+            content = content.replace("\r\n", "\n")
+        elif self._linesep == "\r\n":
+            content = re.sub(r"(?<!\r)\n", "\r\n", content)
+
+        with open(self._path, "w", encoding="utf-8", newline="") as f:
+            f.write(content)

package/releng/winenv.py

@@ -0,0 +1,140 @@
+import json
+from operator import attrgetter
+import os
+from pathlib import Path
+import platform
+import subprocess
+from typing import Optional
+if platform.system() == "Windows":
+    import winreg
+
+from .machine_spec import MachineSpec
+
+
+cached_msvs_dir = None
+cached_msvc_dir = None
+cached_winsdk = None
+
+
+def detect_msvs_installation_dir(toolchain_prefix: Optional[Path]) -> Path:
+    global cached_msvs_dir
+    if cached_msvs_dir is None:
+        vswhere = Path(os.environ.get("ProgramFiles(x86)", os.environ["ProgramFiles"])) \
+                / "Microsoft Visual Studio" / "Installer" / "vswhere.exe"
+        if not vswhere.exists():
+            if toolchain_prefix is None:
+                raise MissingDependencyError("unable to locate vswhere.exe")
+            vswhere = toolchain_prefix / "bin" / "vswhere.exe"
+        installations = json.loads(
+            subprocess.run([
+                               vswhere,
+                               "-latest",
+                               "-format", "json",
+                               "-property", "installationPath"
+                           ],
+                           capture_output=True,
+                           encoding="utf-8",
+                           check=True).stdout
+        )
+        if len(installations) == 0:
+            raise MissingDependencyError("Visual Studio is not installed")
+        cached_msvs_dir = Path(installations[0]["installationPath"])
+    return cached_msvs_dir
+
+
+def detect_msvc_tool_dir(toolchain_prefix: Optional[Path]) -> Path:
+    global cached_msvc_dir
+    if cached_msvc_dir is None:
+        msvs_dir = detect_msvs_installation_dir(toolchain_prefix)
+        version = sorted((msvs_dir / "VC" / "Tools" / "MSVC").glob("*.*.*"),
+                         key=attrgetter("name"),
+                         reverse=True)[0].name
+        cached_msvc_dir = msvs_dir / "VC" / "Tools" / "MSVC" / version
+    return cached_msvc_dir
+
+
+def detect_windows_sdk() -> tuple[Path, str]:
+    global cached_winsdk
+    if cached_winsdk is None:
+        try:
+            key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\Microsoft\Windows Kits\Installed Roots")
+            try:
+                (install_dir, _) = winreg.QueryValueEx(key, "KitsRoot10")
+                install_dir = Path(install_dir)
+                version = sorted((install_dir / "Include").glob("*.*.*"),
+                                 key=attrgetter("name"),
+                                 reverse=True)[0].name
+                cached_winsdk = (install_dir, version)
+            finally:
+                winreg.CloseKey(key)
+        except Exception as e:
+            raise MissingDependencyError("Windows 10 SDK is not installed")
+    return cached_winsdk
+
+
+def detect_msvs_tool_path(machine: MachineSpec,
+                          build_machine: MachineSpec,
+                          tool: str,
+                          toolchain_prefix: Optional[Path]) -> Path:
+    return detect_msvc_tool_dir(toolchain_prefix) / "bin" / f"Host{build_machine.msvc_platform}" \
+            / machine.msvc_platform / tool
+
+
+def detect_msvs_runtime_path(machine: MachineSpec,
+                             build_machine: MachineSpec,
+                             toolchain_prefix: Optional[Path]) -> list[Path]:
+    msvc_platform = machine.msvc_platform
+    native_msvc_platform = build_machine.msvc_platform
+
+    msvc_dir = detect_msvc_tool_dir(toolchain_prefix)
+    msvc_bindir = msvc_dir / "bin" / f"Host{native_msvc_platform}" / msvc_platform
+
+    msvc_dll_dirs = []
+    if msvc_platform != native_msvc_platform:
+        msvc_dll_dirs.append(msvc_dir / "bin" / f"Host{native_msvc_platform}" / native_msvc_platform)
+
+    (winsdk_dir, winsdk_version) = detect_windows_sdk()
+    winsdk_bindir = winsdk_dir / "Bin" / winsdk_version / msvc_platform
+
+    return [winsdk_bindir, msvc_bindir] + msvc_dll_dirs
+
+
+def detect_msvs_include_path(toolchain_prefix: Optional[Path]) -> list[Path]:
+    msvc_dir = detect_msvc_tool_dir(toolchain_prefix)
+    vc_dir = detect_msvs_installation_dir(toolchain_prefix) / "VC"
+
+    (winsdk_dir, winsdk_version) = detect_windows_sdk()
+    winsdk_inc_dirs = [
+        winsdk_dir / "Include" / winsdk_version / "um",
+        winsdk_dir / "Include" / winsdk_version / "shared",
+    ]
+
+    return [
+        msvc_dir / "include",
+        msvc_dir / "atlmfc" / "include",
+        vc_dir / "Auxiliary" / "VS" / "include",
+        winsdk_dir / "Include" / winsdk_version / "ucrt",
+    ] + winsdk_inc_dirs
+
+
+def detect_msvs_library_path(machine: MachineSpec,
+                             toolchain_prefix: Optional[Path]) -> list[Path]:
+    msvc_platform = machine.msvc_platform
+
+    msvc_dir = detect_msvc_tool_dir(toolchain_prefix)
+    vc_dir = detect_msvs_installation_dir(toolchain_prefix) / "VC"
+
+    (winsdk_dir, winsdk_version) = detect_windows_sdk()
+    winsdk_lib_dir = winsdk_dir / "Lib" / winsdk_version / "um" / msvc_platform
+
+    return [
+        msvc_dir / "lib" / msvc_platform,
+        msvc_dir / "atlmfc" / "lib" / msvc_platform,
+        vc_dir / "Auxiliary" / "VS" / "lib" / msvc_platform,
+        winsdk_dir / "Lib" / winsdk_version / "ucrt" / msvc_platform,
+        winsdk_lib_dir,
+    ]
+
+
+class MissingDependencyError(Exception):
+    pass

package/scripts/adjust-version.py

@@ -0,0 +1,19 @@
+from pathlib import Path
+import re
+import sys
+
+
+def main(argv: list[str]):
+    version = argv[1]
+    inpkg = Path(argv[2])
+    outpkg = Path(argv[3])
+
+    vanilla_pkg = inpkg.read_text(encoding="utf-8")
+    adjusted_pkg = re.sub(r'(?P<prefix>"version": ")[^"]+(?P<suffix>")',
+                          f"\\g<prefix>{version}\\g<suffix>",
+                          vanilla_pkg)
+    outpkg.write_text(adjusted_pkg, encoding="utf-8")
+
+
+if __name__ == "__main__":
+    main(sys.argv)

package/scripts/detect-version.py

@@ -0,0 +1,40 @@
+import json
+import os
+from pathlib import Path
+import sys
+from typing import Iterator
+
+
+SOURCE_ROOT = Path(__file__).resolve().parent.parent
+
+
+def detect_version() -> str:
+    pkg = json.loads((SOURCE_ROOT / "package.json").read_text(encoding="utf-8"))
+    version = pkg["version"]
+    if version == "0.0.0":
+        releng_location = next(enumerate_releng_locations(), None)
+        if releng_location is not None:
+            sys.path.insert(0, str(releng_location.parent))
+            from releng.frida_version import detect
+            version = detect(SOURCE_ROOT).name
+    return version
+
+
+def enumerate_releng_locations() -> Iterator[Path]:
+    val = os.environ.get("MESON_SOURCE_ROOT")
+    if val is not None:
+        parent_releng = Path(val) / "releng"
+        if releng_location_exists(parent_releng):
+            yield parent_releng
+
+    local_releng = SOURCE_ROOT / "releng"
+    if releng_location_exists(local_releng):
+        yield local_releng
+
+
+def releng_location_exists(location: Path) -> bool:
+    return (location / "frida_version.py").exists()
+
+
+if __name__ == "__main__":
+    print(detect_version())