sdbtool 0.3.0__tar.gz → 0.3.2__tar.gz

sdbtool-0.3.2/.github/workflows/python-publish.yml

@@ -0,0 +1,54 @@
+name: Publish Python Package
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  release-build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install the latest version of uv and set the python version
+        uses: astral-sh/setup-uv@v6
+        with:
+          python-version: "3.10"
+
+      - name: Build release distributions
+        run: |
+          uv build
+
+      - name: Upload distributions
+        uses: actions/upload-artifact@v4
+        with:
+          name: release-dists
+          path: dist/
+
+  pypi-publish:
+    runs-on: ubuntu-latest
+    needs:
+      - release-build
+    permissions:
+      id-token: write
+
+    # Dedicated environments with protections for publishing are strongly recommended.
+    # For more information, see: https://docs.github.com/en/actions/deployment/targeting-different-environments/using-environments-for-deployment#deployment-protection-rules
+    environment:
+      name: pypi
+
+    steps:
+      - name: Retrieve release distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: release-dists
+          path: dist/
+
+      - name: Publish release distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist/

{sdbtool-0.3.0 → sdbtool-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sdbtool
-Version: 0.3.0
+Version: 0.3.2
 Summary: Dump SDB file to xml using apphelp.dll
 Project-URL: Homepage, https://pypi.org/project/sdbtool/
 Project-URL: Changelog, https://github.com/learn-more/sdbtool/releases

{sdbtool-0.3.0 → sdbtool-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sdbtool"
-version = "0.3.0"
+version = "0.3.2"
 description = "Dump SDB file to xml using apphelp.dll"
 readme = "README.md"
 license = "MIT"

sdbtool-0.3.2/sdbtool/__init__.py

@@ -0,0 +1,25 @@
+"""
+PROJECT:     sdbtool
+LICENSE:     MIT (https://spdx.org/licenses/MIT)
+PURPOSE:     Entrypoint of the sdbtool tool, which converts SDB files to XML format.
+COPYRIGHT:   Copyright 2025 Mark Jansen <mark.jansen@reactos.org>
+"""
+
+import sdbtool.apphelp as apphelp
+from pathlib import Path
+
+from sdbtool.xml import XmlTagVisitor
+
+
+def sdb2xml(input_file: str, output_stream):
+    with apphelp.SdbDatabase(input_file, apphelp.PathType.DOS_PATH) as db:
+        if not db:
+            print(f"Failed to open database at '{input_file}'")
+            return
+
+        visitor = XmlTagVisitor(output_stream, Path(input_file).name)
+        root = db.root()
+        if root is None:
+            print(f"No root tag found in database '{input_file}'")
+            return
+        root.accept(visitor)

sdbtool-0.3.2/sdbtool/apphelp/__init__.py

@@ -0,0 +1,162 @@
+"""
+PROJECT:     sdbtool
+LICENSE:     MIT (https://spdx.org/licenses/MIT)
+PURPOSE:     High level interface to the AppHelp API for reading SDB files.
+COPYRIGHT:   Copyright 2025 Mark Jansen <mark.jansen@reactos.org>
+"""
+
+from ctypes import c_void_p
+from enum import IntEnum
+import sdbtool.apphelp.winapi as apphelp
+
+
+class PathType(IntEnum):
+    DOS_PATH = 0
+    NT_PATH = 1
+
+
+TAGID_NULL = 0x0
+TAGID_ROOT = 0x0
+_TAGID_ROOT = 12
+
+
+class TagType(IntEnum):
+    """Enumeration of tag types."""
+
+    NULL = 0x1000
+    BYTE = 0x2000
+    WORD = 0x3000
+    DWORD = 0x4000
+    QWORD = 0x5000
+    STRINGREF = 0x6000
+    LIST = 0x7000
+    STRING = 0x8000
+    BINARY = 0x9000
+    MASK = 0xF000
+
+
+TAG_NULL = 0x0
+
+
+def _get_tag_type(tag: int) -> TagType:
+    """Extracts the type from a tag."""
+    return TagType(tag & TagType.MASK)
+
+
+def tag_to_string(tag: int) -> str:
+    """Converts a tag to its string representation."""
+    return apphelp.SdbTagToString(tag)
+
+
+class Tag:
+    def __init__(self, db: "SdbDatabase", tag_id: int):
+        self.db = db
+        self.tag_id = tag_id
+        if tag_id == TAGID_ROOT:
+            self.tag = TAG_NULL
+            self.name = "SDB"
+            self.type = TagType.LIST
+        else:
+            self.tag = apphelp.SdbGetTagFromTagID(self._ensure_db_handle(), tag_id)
+            self.name = apphelp.SdbTagToString(self.tag)
+            self.type = _get_tag_type(self.tag)
+
+    def _ensure_db_handle(self) -> c_void_p:
+        """Ensures that the database handle is initialized."""
+        if self.db._handle is None:
+            raise ValueError("Database handle is not initialized")
+        return self.db._handle
+
+    def tags(self):
+        self._ensure_db_handle()
+        child = apphelp.SdbGetFirstChild(self._ensure_db_handle(), self.tag_id)
+        while child != 0:
+            yield Tag(self.db, child)
+            child = apphelp.SdbGetNextChild(
+                self._ensure_db_handle(), self.tag_id, child
+            )
+
+    def as_word(self, default: int = 0) -> int:
+        """Returns the tag value as a word (16-bit integer)."""
+        if self.type != TagType.WORD:
+            raise ValueError(f"Tag {self.name} is not a WORD type")
+        return apphelp.SdbReadWORDTag(self._ensure_db_handle(), self.tag_id, default)
+
+    def as_dword(self, default: int = 0) -> int:
+        """Returns the tag value as a dword (32-bit integer)."""
+        if self.type != TagType.DWORD:
+            raise ValueError(f"Tag {self.name} is not a DWORD type")
+        return apphelp.SdbReadDWORDTag(self._ensure_db_handle(), self.tag_id, default)
+
+    def as_qword(self, default: int = 0) -> int:
+        """Returns the tag value as a qword (64-bit integer)."""
+        if self.type != TagType.QWORD:
+            raise ValueError(f"Tag {self.name} is not a QWORD type")
+        return apphelp.SdbReadQWORDTag(self._ensure_db_handle(), self.tag_id, default)
+
+    def as_bytes(self) -> bytes:
+        """Returns the tag value as bytes."""
+        if self.type != TagType.BINARY:
+            raise ValueError(f"Tag {self.name} is not a BINARY type")
+        return apphelp.SdbReadBinaryTag(self._ensure_db_handle(), self.tag_id)
+
+    def as_string(self) -> str:
+        """Returns the tag value as a string."""
+        if self.type not in (TagType.STRING, TagType.STRINGREF):
+            raise ValueError(f"Tag {self.name} is not a STRING or STRINGREF type")
+        ptr = apphelp.SdbGetStringTagPtr(self._ensure_db_handle(), self.tag_id)
+        return ptr if ptr is not None else ""
+
+    def accept(self, visitor: "TagVisitor"):
+        """Accepts a visitor for this tag."""
+        if self.type == TagType.LIST:
+            visitor.visit_list_begin(self)
+            for child in self.tags():
+                child.accept(visitor)
+            visitor.visit_list_end(self)
+        else:
+            # For non-list tags, we just visit this tag
+            visitor.visit(self)
+
+
+class TagVisitor:
+    def visit(self, tag: Tag):
+        """Visit a tag. Override this method in subclasses."""
+        raise NotImplementedError("Subclasses must implement visit method")
+
+    def visit_list_begin(self, tag: Tag):
+        """Visit a list tag. Override this method in subclasses."""
+        raise NotImplementedError("Subclasses must implement visit_list_begin method")
+
+    def visit_list_end(self, tag: Tag):
+        """Visit the end of a list tag. Override this method in subclasses."""
+        raise NotImplementedError("Subclasses must implement visit_list_end method")
+
+
+class SdbDatabase:
+    def __init__(self, path: str, path_type: PathType):
+        self.path = path
+        self.path_type = path_type
+        self._handle = apphelp.SdbOpenDatabase(path, path_type)
+        self._root = None
+
+    def root(self) -> Tag | None:
+        if self._root is None and self._handle is not None:
+            self._root = Tag(self, TAGID_ROOT)
+        return self._root
+
+    def close(self):
+        if self._handle:
+            apphelp.SdbCloseDatabase(self._handle)
+            self._handle = None
+
+    def __bool__(self):
+        if self._handle is None:
+            return False
+        return True
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()

sdbtool-0.3.2/sdbtool/apphelp/winapi.py

@@ -0,0 +1,128 @@
+"""
+PROJECT:     sdbtool
+LICENSE:     MIT (https://spdx.org/licenses/MIT)
+PURPOSE:     winapi interface to the AppHelp API for reading SDB files.
+COPYRIGHT:   Copyright 2025 Mark Jansen <mark.jansen@reactos.org>
+"""
+
+from ctypes import (
+    windll,
+    c_void_p,
+    c_uint16,
+    c_uint32,
+    c_wchar_p,
+    POINTER,
+    c_ubyte,
+    c_uint64,
+)
+
+APPHELP = windll.apphelp
+
+# PDB WINAPI SdbOpenDatabase(LPCWSTR path, PATH_TYPE type);
+APPHELP.SdbOpenDatabase.argtypes = [c_wchar_p, c_uint32]
+APPHELP.SdbOpenDatabase.restype = c_void_p
+
+# void WINAPI SdbCloseDatabase(PDB);
+APPHELP.SdbCloseDatabase.argtypes = [c_void_p]
+
+# TAGID WINAPI SdbGetFirstChild(PDB pdb, TAGID parent);
+APPHELP.SdbGetFirstChild.argtypes = [c_void_p, c_uint32]
+APPHELP.SdbGetFirstChild.restype = c_uint32
+
+# TAGID WINAPI SdbGetNextChild(PDB pdb, TAGID parent, TAGID prev_child);
+APPHELP.SdbGetNextChild.argtypes = [c_void_p, c_uint32, c_uint32]
+APPHELP.SdbGetNextChild.restype = c_uint32
+
+# TAG WINAPI SdbGetTagFromTagID(PDB pdb, TAGID tagid);
+APPHELP.SdbGetTagFromTagID.argtypes = [c_void_p, c_uint32]
+APPHELP.SdbGetTagFromTagID.restype = c_uint16
+
+# LPCWSTR WINAPI SdbTagToString(TAG tag);
+APPHELP.SdbTagToString.argtypes = [c_uint16]
+APPHELP.SdbTagToString.restype = c_wchar_p
+
+# WORD WINAPI SdbReadDWORDTag(PDB pdb, TAGID tagid, WORD ret);
+APPHELP.SdbReadWORDTag.argtypes = [c_void_p, c_uint32, c_uint16]
+APPHELP.SdbReadWORDTag.restype = c_uint16
+
+# DWORD WINAPI SdbReadDWORDTag(PDB pdb, TAGID tagid, DWORD ret);
+APPHELP.SdbReadDWORDTag.argtypes = [c_void_p, c_uint32, c_uint32]
+APPHELP.SdbReadDWORDTag.restype = c_uint32
+
+# QWORD WINAPI SdbReadQWORDTag(PDB pdb, TAGID tagid, QWORD ret);
+APPHELP.SdbReadQWORDTag.argtypes = [c_void_p, c_uint32, c_uint64]
+APPHELP.SdbReadQWORDTag.restype = c_uint64
+
+# DWORD WINAPI SdbGetTagDataSize(PDB pdb, TAGID tagid);
+APPHELP.SdbGetTagDataSize.argtypes = [c_void_p, c_uint32]
+APPHELP.SdbGetTagDataSize.restype = c_uint32
+
+# BOOL WINAPI SdbReadBinaryTag(PDB pdb, TAGID tagid, PBYTE buffer, DWORD size);
+APPHELP.SdbReadBinaryTag.argtypes = [c_void_p, c_uint32, POINTER(c_ubyte), c_uint32]
+APPHELP.SdbReadBinaryTag.restype = c_uint32
+
+# LPWSTR WINAPI SdbGetStringTagPtr(PDB pdb, TAGID tagid);
+APPHELP.SdbGetStringTagPtr.argtypes = [c_void_p, c_uint32]
+APPHELP.SdbGetStringTagPtr.restype = c_wchar_p
+
+
+def SdbOpenDatabase(path: str, path_type: int) -> c_void_p:
+    """Open a database at the specified path."""
+    return APPHELP.SdbOpenDatabase(path, path_type)
+
+
+def SdbCloseDatabase(db: c_void_p):
+    """Close the specified database."""
+    APPHELP.SdbCloseDatabase(db)
+
+
+def SdbGetFirstChild(db: c_void_p, parent: int) -> int:
+    """Get the first child tag of the specified parent."""
+    return APPHELP.SdbGetFirstChild(db, parent)
+
+
+def SdbGetNextChild(db: c_void_p, parent: int, prev_child: int) -> int:
+    """Get the next child tag of the specified parent."""
+    return APPHELP.SdbGetNextChild(db, parent, prev_child)
+
+
+def SdbGetTagFromTagID(db: c_void_p, tag_id: int) -> int:
+    """Get the tag from the specified tag ID."""
+    return APPHELP.SdbGetTagFromTagID(db, tag_id)
+
+
+def SdbTagToString(tag: int) -> str:
+    """Convert a tag to its string representation."""
+    return APPHELP.SdbTagToString(tag)
+
+
+def SdbReadWORDTag(db: c_void_p, tag_id: int, default: int = 0) -> int:
+    """Read a WORD tag from the database."""
+    return APPHELP.SdbReadWORDTag(db, tag_id, default)
+
+
+def SdbReadDWORDTag(db: c_void_p, tag_id: int, default: int = 0) -> int:
+    """Read a DWORD tag from the database."""
+    return APPHELP.SdbReadDWORDTag(db, tag_id, default)
+
+
+def SdbReadQWORDTag(db: c_void_p, tag_id: int, default: int = 0) -> int:
+    """Read a QWORD tag from the database."""
+    return APPHELP.SdbReadQWORDTag(db, tag_id, default)
+
+
+def SdbReadBinaryTag(db: c_void_p, tag_id: int) -> bytes:
+    """Read a binary tag from the database."""
+    size = APPHELP.SdbGetTagDataSize(db, tag_id)
+    if size == 0:
+        return b""
+    data = (c_ubyte * size)()
+    result = APPHELP.SdbReadBinaryTag(db, tag_id, data, size)
+    if result == 0:
+        raise ValueError(f"Failed to read binary tag 0x{tag_id:x}")
+    return bytes(data)
+
+
+def SdbGetStringTagPtr(db: c_void_p, tag_id: int) -> str:
+    """Get the string pointer of the specified tag."""
+    return APPHELP.SdbGetStringTagPtr(db, tag_id)

{sdbtool-0.3.0 → sdbtool-0.3.2}/sdbtool/cli.py

@@ -1,4 +1,4 @@
-from sdbtool import convert
+from sdbtool import sdb2xml
 import click
 
 @click.command()
@@ -11,4 +11,4 @@ import click
     help="Path to the output XML file, or '-' for stdout.",
 )
 def cli(input_file, output):
-    convert(input_file, output)
+    sdb2xml(input_file, output)

sdbtool-0.3.2/sdbtool/xml.py

@@ -0,0 +1,139 @@
+"""
+PROJECT:     sdbtool
+LICENSE:     MIT (https://spdx.org/licenses/MIT)
+PURPOSE:     Xml writer + visitor for SDB files.
+COPYRIGHT:   Copyright 2025 Mark Jansen <mark.jansen@reactos.org>
+"""
+
+from sdbtool.apphelp import TagVisitor, Tag, TagType, tag_to_string
+from xml.sax.saxutils import escape, quoteattr
+from base64 import b64encode
+
+INDENT_DEPTH = 2  # Number of spaces for each indentation level in XML output
+
+
+def tagtype_to_xmltype(tag_type: TagType) -> str | None:
+    switch = {
+        TagType.BYTE: "xs:byte",
+        TagType.WORD: "xs:unsignedShort",
+        TagType.DWORD: "xs:unsignedInt",
+        TagType.QWORD: "xs:unsignedLong",
+        TagType.STRINGREF: "xs:string",
+        TagType.STRING: "xs:string",
+        TagType.BINARY: "xs:base64Binary",
+    }
+    return switch.get(tag_type, None)
+
+
+class XmlWriter:
+    def __init__(self, stream):
+        self._stream = stream
+
+    def write_xml_declaration(self):
+        """Write the XML declaration at the start of the document."""
+        self._stream.write('<?xml version="1.0" encoding="utf-8" standalone="yes"?>')
+
+    def indent(self, level):
+        """Return the indentation string for the given level."""
+        self._stream.write("\n")
+        self._stream.write(" " * (level * INDENT_DEPTH))
+        return self
+
+    def open(self, name, attrib=None):
+        """Open an XML tag with the given name and attributes."""
+        self._stream.write(f"<{name}")
+        if attrib:
+            for key, value in attrib.items():
+                self._stream.write(f' {key}={quoteattr(value)}')
+        self._stream.write(">")
+        return self
+
+    def close(self, name):
+        """Close an XML tag with the given name."""
+        self._stream.write(f"</{name}>")
+
+    def empty_tag(self, name):
+        """Write an empty XML tag with the given name and attributes."""
+        self._stream.write(f"<{name} />")
+
+    def write(self, text):
+        """Write text content to the XML stream."""
+        self._stream.write(text)
+
+
+class XmlTagVisitor(TagVisitor):
+    def __init__(self, stream, input_filename: str):
+        """Initialize the XML tag visitor with a filename."""
+        self.writer = XmlWriter(stream)
+        self.writer.write_xml_declaration()
+        self._depth = 0
+        self._input_filename = input_filename
+        self._indent_on_close = False
+
+    def visit_list_begin(self, tag: Tag):
+        """Visit the beginning of a list tag."""
+
+        attrs = None
+        if self._depth == 0:
+            attrs = {
+                "xmlns:xs": "http://www.w3.org/2001/XMLSchema",
+                "file": self._input_filename,
+            }
+
+        self.writer.indent(self._depth).open(tag.name, attrs)
+        self._depth += 1
+        self._indent_on_close = False
+
+    def visit_list_end(self, tag: Tag):
+        """Visit the end of a list tag."""
+        self._depth -= 1
+        if self._indent_on_close:
+            self.writer.indent(self._depth)
+        self.writer.close(tag.name)
+        self._indent_on_close = True
+
+    def visit(self, tag: Tag):
+        """Visit a tag."""
+        self._indent_on_close = True
+        if tag.type == TagType.NULL:
+            self.writer.indent(self._depth).empty_tag(tag.name)
+            return
+
+        attrs = {}
+        if tag.type != TagType.LIST:
+            typename = tagtype_to_xmltype(tag.type)
+            if typename is not None:
+                attrs["type"] = typename
+            else:
+                raise ValueError(f"Unknown tag type: {tag.type} for tag {tag.name}")
+
+        self.writer.indent(self._depth).open(tag.name, attrs)
+        self._write_tag_value(tag)
+        self.writer.close(tag.name)
+
+    def _write_tag_value(self, tag: Tag):
+        """Write the value of a tag based on its type."""
+        if tag.type == TagType.BYTE:
+            self.writer.write(
+                "<!-- UNHANDLED BYTE TAG, please report this at https://github.com/learn-more/sdbtool -->"
+            )
+        elif tag.type == TagType.WORD:
+            value = tag.as_word()
+            self.writer.write(f"{value}")
+            if tag.name in ("INDEX_TAG", "INDEX_KEY"):
+                self.writer.write(f"<!-- {tag_to_string(value)} -->")
+        elif tag.type == TagType.DWORD:
+            self.writer.write(f"{tag.as_dword()}")
+        elif tag.type == TagType.QWORD:
+            self.writer.write(f"{tag.as_qword()}")
+        elif tag.type in (TagType.STRINGREF, TagType.STRING):
+            val = tag.as_string()
+            if val:
+                self.writer.write(f"{escape(val)}")
+        elif tag.type == TagType.BINARY:
+            data = tag.as_bytes()
+            if data:
+                base64_data = b64encode(data).decode("utf-8")
+                self.writer.write(base64_data)
+        else:
+            raise ValueError(f"Unknown tag type: {tag.type} for tag {tag.name}")

sdbtool-0.3.0/sdbtool/__init__.py

@@ -1,131 +0,0 @@
-'''
-PROJECT:     sdbtool
-LICENSE:     MIT (https://spdx.org/licenses/MIT)
-PURPOSE:     Entrypoint of the sdbtool tool, which converts SDB files to XML format.
-COPYRIGHT:   Copyright 2025 Mark Jansen <mark.jansen@reactos.org>
-'''
-import sdbtool.apphelp as apphelp
-from base64 import b64encode
-from xml.sax.saxutils import escape
-
-INDENT_DEPTH = 2
-
-def tagtype_to_xmltype(tag_type: int) -> str|None:
-    switch = {
-        apphelp.TAG_TYPE_BYTE: "xs:byte",
-        apphelp.TAG_TYPE_WORD: "xs:unsignedShort",
-        apphelp.TAG_TYPE_DWORD: "xs:unsignedInt",
-        apphelp.TAG_TYPE_QWORD: "xs:unsignedLong",
-        apphelp.TAG_TYPE_STRINGREF: "xs:string",
-        apphelp.TAG_TYPE_STRING: "xs:string",
-        apphelp.TAG_TYPE_BINARY: "xs:base64Binary",
-    }
-    return switch.get(tag_type, None)
-
-class Xml:
-    def __init__(self, stream, name, indent, attrib=None, xmltag=False):
-        self._stream = stream
-        self.name = name
-        self.indent = indent
-        self.attrib = attrib or {}
-        self._has_children = False
-        self._xmltag = xmltag
-        self._delay = None
-        self._closed = False
-
-    def node(self, name, attrib=None):
-        self._has_children = True
-        return Xml(self._stream, name, self.indent + 1, attrib)
-
-    def flush(self):
-        if self._delay:
-            self._stream.write(self._delay)
-            self._delay = None
-
-    def write(self, text):
-        self.flush()
-        self._stream.write(text)
-
-    def close(self):
-        assert self._delay is not None, "Xml.close() called when tag has content"
-        self._stream.write(" />")
-        self._delay = None
-        self._closed = True
-
-    def __enter__(self):
-        if self._xmltag:
-            self.write('<?xml version="1.0" encoding="utf-8" standalone="yes"?>')
-            self._xmltag = False
-        self.write("\n")
-        if self.indent:
-            self.write(" " * (self.indent*INDENT_DEPTH))
-        self.write(f"<{self.name}")
-        for key, value in self.attrib.items():
-            self.write(f' {key}="{value}"')
-
-        self._delay = ">"
-        return self
-
-    def __exit__(self, exc_type, exc_value, traceback):
-        if self._closed:
-            return
-        if self._has_children:
-            self.write("\n")
-            if self.indent:
-                self.write(" " * (self.indent*INDENT_DEPTH))
-        self.write(f"</{self.name}>")
-
-
-def dump_tag(node, tag):
-    if tag.type == apphelp.TAG_TYPE_LIST:
-        node.flush()
-        for childtag in tag.tags():
-            attrs = {}
-            if childtag.type != apphelp.TAG_TYPE_LIST and childtag.type != apphelp.TAG_TYPE_NULL:
-                typename = tagtype_to_xmltype(childtag.type)
-                assert typename is not None, f"Unknown tag type: {childtag.tag}"
-                attrs["type"] = typename
-            with node.node(childtag.name, attrs) as childnode:
-                dump_tag(childnode, childtag)
-        return
-
-    assert next(tag.tags(), None) is None, f"Tag {tag.name} is not a list but has children"
-
-    if tag.type == apphelp.TAG_TYPE_NULL:
-        node.close()
-    elif tag.type == apphelp.TAG_TYPE_BYTE:
-        node.write("<!-- UNHANDLED BYTE TAG, please report this at https://github.com/learn-more/sdbtool -->")
-    elif tag.type == apphelp.TAG_TYPE_WORD:
-        val = tag.as_word()
-        node.write(f"{val}")
-        if node.name in ("INDEX_TAG", "INDEX_KEY"):
-            node.write(f"<!-- {apphelp.tag_to_string(val)} -->")
-    elif tag.type == apphelp.TAG_TYPE_DWORD:
-        node.write(f"{tag.as_dword()}")
-    elif tag.type == apphelp.TAG_TYPE_QWORD:
-        node.write(f"{tag.as_qword()}")
-    elif tag.type in (apphelp.TAG_TYPE_STRINGREF, apphelp.TAG_TYPE_STRING):
-        val = escape(tag.as_string())
-        node.write(f"{val}")
-    elif tag.type == apphelp.TAG_TYPE_BINARY:
-        data = tag.as_bytes()
-        if not data:
-            node.close()
-        else:
-            base64_data = b64encode(data).decode('utf-8')
-            node.write(base64_data)
-    else:
-        raise ValueError(f"Unknown tag type: {tag.type} for tag {tag.name}")
-
-
-def convert(input_file: str, output_stream):
-    with apphelp.SdbDatabase(input_file, apphelp.PathType.DOS_PATH) as db:
-        if not db:
-            print(f"Failed to open database at '{input_file}'")
-            return
-        attrs = {
-            "xmlns:xs": "http://www.w3.org/2001/XMLSchema",
-            "path": input_file,
-        }
-        with Xml(output_stream, "SDB", 0, attrs, xmltag=True) as node:
-            dump_tag(node, db.root())

sdbtool-0.3.0/sdbtool/apphelp.py

@@ -1,174 +0,0 @@
-'''
-PROJECT:     sdbtool
-LICENSE:     MIT (https://spdx.org/licenses/MIT)
-PURPOSE:     interface to the AppHelp API for reading SDB files.
-COPYRIGHT:   Copyright 2025 Mark Jansen <mark.jansen@reactos.org>
-'''
-from ctypes import windll, c_void_p, c_uint16, c_uint32, c_wchar_p, POINTER, c_ubyte, c_uint64
-from enum import IntEnum
-
-class PathType(IntEnum):
-    DOS_PATH = 0
-    NT_PATH = 1
-
-
-TAGID_NULL = 0x0
-TAGID_ROOT = 0x0
-_TAGID_ROOT = 12
-
-TAG_TYPE_MASK = 0xF000
-
-TAG_TYPE_NULL = 0x1000
-TAG_TYPE_BYTE = 0x2000
-TAG_TYPE_WORD = 0x3000
-TAG_TYPE_DWORD = 0x4000
-TAG_TYPE_QWORD = 0x5000
-TAG_TYPE_STRINGREF = 0x6000
-TAG_TYPE_LIST = 0x7000
-TAG_TYPE_STRING = 0x8000
-TAG_TYPE_BINARY = 0x9000
-TAG_NULL = 0x0
-
-
-APPHELP = windll.apphelp
-
-# PDB WINAPI SdbOpenDatabase(LPCWSTR path, PATH_TYPE type);
-APPHELP.SdbOpenDatabase.argtypes = [c_wchar_p, c_uint32]
-APPHELP.SdbOpenDatabase.restype = c_void_p
-
-# void WINAPI SdbCloseDatabase(PDB);
-APPHELP.SdbCloseDatabase.argtypes = [c_void_p]
-
-# TAGID WINAPI SdbGetFirstChild(PDB pdb, TAGID parent);
-APPHELP.SdbGetFirstChild.argtypes = [c_void_p, c_uint32]
-APPHELP.SdbGetFirstChild.restype = c_uint32
-
-# TAGID WINAPI SdbGetNextChild(PDB pdb, TAGID parent, TAGID prev_child);
-APPHELP.SdbGetNextChild.argtypes = [c_void_p, c_uint32, c_uint32]
-APPHELP.SdbGetNextChild.restype = c_uint32
-
-# TAG WINAPI SdbGetTagFromTagID(PDB pdb, TAGID tagid);
-APPHELP.SdbGetTagFromTagID.argtypes = [c_void_p, c_uint32]
-APPHELP.SdbGetTagFromTagID.restype = c_uint16
-
-# LPCWSTR WINAPI SdbTagToString(TAG tag);
-APPHELP.SdbTagToString.argtypes = [c_uint16]
-APPHELP.SdbTagToString.restype = c_wchar_p
-
-# WORD WINAPI SdbReadDWORDTag(PDB pdb, TAGID tagid, WORD ret);
-APPHELP.SdbReadWORDTag.argtypes = [c_void_p, c_uint32, c_uint16]
-APPHELP.SdbReadWORDTag.restype = c_uint16
-
-# DWORD WINAPI SdbReadDWORDTag(PDB pdb, TAGID tagid, DWORD ret);
-APPHELP.SdbReadDWORDTag.argtypes = [c_void_p, c_uint32, c_uint32]
-APPHELP.SdbReadDWORDTag.restype = c_uint32
-
-# QWORD WINAPI SdbReadQWORDTag(PDB pdb, TAGID tagid, QWORD ret);
-APPHELP.SdbReadQWORDTag.argtypes = [c_void_p, c_uint32, c_uint64]
-APPHELP.SdbReadQWORDTag.restype = c_uint64
-
-# DWORD WINAPI SdbGetTagDataSize(PDB pdb, TAGID tagid);
-APPHELP.SdbGetTagDataSize.argtypes = [c_void_p, c_uint32]
-APPHELP.SdbGetTagDataSize.restype = c_uint32
-
-# BOOL WINAPI SdbReadBinaryTag(PDB pdb, TAGID tagid, PBYTE buffer, DWORD size);
-APPHELP.SdbReadBinaryTag.argtypes = [c_void_p, c_uint32, POINTER(c_ubyte), c_uint32]
-APPHELP.SdbReadBinaryTag.restype = c_uint32
-
-# LPWSTR WINAPI SdbGetStringTagPtr(PDB pdb, TAGID tagid);
-APPHELP.SdbGetStringTagPtr.argtypes = [c_void_p, c_uint32]
-APPHELP.SdbGetStringTagPtr.restype = c_wchar_p
-
-def _get_tag_type(tag: int) -> int:
-    """Extracts the type from a tag."""
-    return tag & TAG_TYPE_MASK
-
-def tag_to_string(tag: int) -> str:
-    """Converts a tag to its string representation."""
-    return APPHELP.SdbTagToString(tag)
-
-class Tag:
-    def __init__(self, db: 'SdbDatabase', tag_id: int):
-        self.db = db
-        self.tag_id = tag_id
-        if tag_id == TAGID_ROOT:
-            self.tag = TAG_NULL
-            self.name = 'SDB'
-            self.type = TAG_TYPE_LIST
-        else:
-            self.tag = APPHELP.SdbGetTagFromTagID(db.handle, tag_id)
-            self.name = APPHELP.SdbTagToString(self.tag)
-            self.type = _get_tag_type(self.tag)
-
-    def tags(self):
-        child = APPHELP.SdbGetFirstChild(self.db.handle, self.tag_id)
-        while child != 0:
-            yield Tag(self.db, child)
-            child = APPHELP.SdbGetNextChild(self.db.handle, self.tag_id, child)
-
-    def as_word(self, default: int = 0) -> int:
-        """Returns the tag value as a word (16-bit integer)."""
-        if self.type != TAG_TYPE_WORD:
-            raise ValueError(f"Tag {self.name} is not a WORD type")
-        return APPHELP.SdbReadWORDTag(self.db.handle, self.tag_id, default)
-
-    def as_dword(self, default: int = 0) -> int:
-        """Returns the tag value as a dword (32-bit integer)."""
-        if self.type != TAG_TYPE_DWORD:
-            raise ValueError(f"Tag {self.name} is not a DWORD type")
-        return APPHELP.SdbReadDWORDTag(self.db.handle, self.tag_id, default)
-
-    def as_qword(self, default: int = 0) -> int:
-        """Returns the tag value as a qword (64-bit integer)."""
-        if self.type != TAG_TYPE_QWORD:
-            raise ValueError(f"Tag {self.name} is not a QWORD type")
-        return APPHELP.SdbReadQWORDTag(self.db.handle, self.tag_id, default)
-
-    def as_bytes(self) -> bytes:
-        """Returns the tag value as bytes."""
-        if self.type != TAG_TYPE_BINARY:
-            raise ValueError(f"Tag {self.name} is not a BINARY type")
-        size = APPHELP.SdbGetTagDataSize(self.db.handle, self.tag_id)
-        if size == 0:
-            return b''
-        data = (c_ubyte * size)()
-        result = APPHELP.SdbReadBinaryTag(self.db.handle, self.tag_id, data, size)
-        if result == 0:
-            raise ValueError(f"Failed to read binary tag {self.name}")
-        return bytes(data)
-
-    def as_string(self) -> str:
-        """Returns the tag value as a string."""
-        if self.type not in (TAG_TYPE_STRING, TAG_TYPE_STRINGREF):
-            raise ValueError(f"Tag {self.name} is not a STRING or STRINGREF type")
-        ptr = APPHELP.SdbGetStringTagPtr(self.db.handle, self.tag_id)
-        return ptr if ptr is not None else ''
-
-
-class SdbDatabase:
-    def __init__(self, path: str, path_type: PathType):
-        self.path = path
-        self.path_type = path_type
-        self.handle = APPHELP.SdbOpenDatabase(path, path_type)
-        self._root = None
-
-    def root(self):
-        if self._root is None and self.handle is not None:
-            self._root = Tag(self, TAGID_ROOT)
-        return self._root
-
-    def close(self):
-        if self.handle:
-            APPHELP.SdbCloseDatabase(self.handle)
-            self.handle = None
-
-    def __bool__(self):
-        if self.handle is None:
-            return False
-        return True
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_value, traceback):
-        self.close()