Add C ABI

.github/workflows/cmake.yml

@@ -0,0 +1,36 @@
+name: CMake
+on: [push]
+jobs:
+
+  # Verifies the CMake packaging path (CMakeLists.txt) that builds
+  # libbluetooth-util.so independently of SwiftPM's own build graph,
+  # since soname/symbol-versioning/install-name aren't expressible in
+  # Package.swift. SwiftPM remains the primary build used by the other
+  # workflows; this only guards CMakeLists.txt from silently drifting.
+  cmake:
+    name: CMake
+    strategy:
+      fail-fast: false
+      matrix:
+        # 6.3+ only, unlike the SwiftPM workflows: the C ABI layer this
+        # builds is bound with `@c`, which 6.2 rejects as an unknown
+        # attribute. The rest of the package still builds on 6.2 because
+        # the C ABI targets are off unless SWIFTPM_BLUETOOTH_CABI=1.
+        container: ["swift:6.3.3"]
+    runs-on: ubuntu-latest
+    # noble, not jammy like the other workflows: CMakeLists.txt requires
+    # CMake 3.26+, and jammy's apt only has 3.22. noble ships 3.28.
+    container: ${{ matrix.container }}-noble
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+    - name: Swift Version
+      run: swift --version
+    - name: Install CMake and Ninja
+      run: apt-get update && apt-get install -y cmake ninja-build
+    - name: Configure
+      run: cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=Release
+    - name: Build
+      run: cmake --build build
+    - name: Check exported symbols
+      run: cmake --build build --target check-exports

CMakeLists.txt

@@ -0,0 +1,310 @@
+##
+##  CMakeLists.txt
+##  Bluetooth
+##
+##  Builds `libbluetooth-util.so.0` — the non-socket half of the
+##  libbluetooth ABI (the `bluetooth.c` entry points plus the `bt_uuid_*`
+##  family), implemented in Swift.
+##
+##  SwiftPM drives development and the test suites; CMake exists because
+##  soname, symbol versioning and install name are not expressible in
+##  `Package.swift`. The socket half, and the drop-in
+##  `libbluetooth.so.3` itself, are built by PureSwift/BluetoothLinux,
+##  which links the static archives produced here.
+##
+##  Note this library ships `bt_uuid_*` as real exported symbols, which
+##  upstream BlueZ has never done — there they exist only inside
+##  `libbluetooth-internal.a`. Consumers that want the UUID helpers as a
+##  shared library are the reason this target exists standalone.
+##
+##  The Ninja generator is required — CMake does not support the Swift
+##  language with Makefiles.
+##
+##  Usage:
+##      cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=Release
+##      cmake --build build
+##      cmake --build build --target check-exports
+##      cmake --install build --prefix /usr/local
+##
+
+cmake_minimum_required(VERSION 3.26)
+
+if(NOT CMAKE_GENERATOR MATCHES "Ninja")
+    message(FATAL_ERROR
+        "The Ninja generator is required for Swift targets; "
+        "re-run with -G Ninja.")
+endif()
+
+project(BluetoothABI
+    VERSION 0.1.0
+    DESCRIPTION "Swift implementation of the libbluetooth C ABI"
+    LANGUAGES C Swift)
+
+# ---------------------------------------------------------------------
+# Options
+# ---------------------------------------------------------------------
+
+option(BLUETOOTH_ABI_SHARED
+    "Build the shared library (off builds the static archives only)" ON)
+
+option(BLUETOOTH_ABI_STATIC_STDLIB
+    "Statically link the Swift runtime into the shared library" OFF)
+
+option(BLUETOOTH_ABI_INSTALL_HEADERS
+    "Install the vendored BlueZ headers under <prefix>/include/bluetooth" ON)
+
+# The soname of this library is independent of BlueZ's: it is a new
+# library, not a replacement for one. BluetoothLinux sets 3 / 3.19.x for
+# the drop-in `libbluetooth.so.3`.
+set(BLUETOOTH_UTIL_SOVERSION 0)
+set(BLUETOOTH_UTIL_VERSION 0.1.0)
+
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+    set(CMAKE_BUILD_TYPE Release CACHE STRING "" FORCE)
+endif()
+
+include(GNUInstallDirs)
+
+# ---------------------------------------------------------------------
+# CBluetooth — the C surface
+# ---------------------------------------------------------------------
+#
+# `include/` holds the two headers vendored verbatim from BlueZ; they are
+# GPL-2.0-or-later, unlike the rest of this repository. See
+# Sources/CBluetooth/README.md.
+
+add_library(CBluetooth STATIC
+    Sources/CBluetooth/cbt_printf.c
+    Sources/CBluetooth/cbt_alloc.c
+    Sources/CBluetooth/cbt_scan.c)
+
+target_include_directories(CBluetooth PUBLIC
+    "${CMAKE_CURRENT_SOURCE_DIR}/Sources/CBluetooth/include")
+
+# ---------------------------------------------------------------------
+# Generated definitions
+# ---------------------------------------------------------------------
+#
+# `Sources/Bluetooth` references assigned-number definitions (e.g.
+# `CompanyIdentifier.apple`) that the SwiftPM `GenerateBluetoothDefinitions`
+# plugin emits at build time. CMake has no plugin mechanism, so it runs
+# the same generator executable directly, via SwiftPM.
+#
+# Set BLUETOOTH_GENERATED_DIR to reuse definitions generated elsewhere
+# and skip the SwiftPM invocation entirely.
+
+set(BLUETOOTH_GENERATED_DIR "" CACHE PATH
+    "Directory of pre-generated definitions (empty: generate them here)")
+
+set(BLUETOOTH_GENERATED_FILES
+    CompanyIdentifiers
+    UnitIdentifiers
+    CharacteristicUUID
+    DeclarationUUID
+    DescriptorUUID
+    MemberUUID
+    ServiceUUID)
+
+# The generator's subcommand for each output file.
+set(BLUETOOTH_GENERATE_CompanyIdentifiers   companyIdentifier)
+set(BLUETOOTH_GENERATE_UnitIdentifiers      unitIdentifier)
+set(BLUETOOTH_GENERATE_CharacteristicUUID   "uuid;Characteristic")
+set(BLUETOOTH_GENERATE_DeclarationUUID      "uuid;Declaration")
+set(BLUETOOTH_GENERATE_DescriptorUUID       "uuid;Descriptor")
+set(BLUETOOTH_GENERATE_MemberUUID           "uuid;Member")
+set(BLUETOOTH_GENERATE_ServiceUUID          "uuid;Service")
+
+if(BLUETOOTH_GENERATED_DIR)
+    foreach(name IN LISTS BLUETOOTH_GENERATED_FILES)
+        set(generated "${BLUETOOTH_GENERATED_DIR}/${name}.swift")
+        if(NOT EXISTS "${generated}")
+            message(FATAL_ERROR
+                "BLUETOOTH_GENERATED_DIR set but ${generated} is missing.")
+        endif()
+        list(APPEND BLUETOOTH_GENERATED_SOURCES "${generated}")
+    endforeach()
+else()
+    find_program(SWIFT_EXECUTABLE swift REQUIRED)
+
+    set(BLUETOOTH_GENERATED_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/generated")
+    file(MAKE_DIRECTORY "${BLUETOOTH_GENERATED_OUTPUT}")
+
+    # One `swift build` up front, so the per-file commands below cannot
+    # race each other over SwiftPM's build lock.
+    add_custom_command(
+        OUTPUT "${BLUETOOTH_GENERATED_OUTPUT}/.generator-built"
+        COMMAND "${CMAKE_COMMAND}" -E env
+                SWIFTPM_BLUETOOTH_CABI=0
+                "${SWIFT_EXECUTABLE}" build --product GenerateBluetooth
+                --package-path "${CMAKE_CURRENT_SOURCE_DIR}"
+        COMMAND "${CMAKE_COMMAND}" -E touch
+                "${BLUETOOTH_GENERATED_OUTPUT}/.generator-built"
+        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+        COMMENT "Building GenerateBluetooth"
+        VERBATIM)
+
+    foreach(name IN LISTS BLUETOOTH_GENERATED_FILES)
+        set(generated "${BLUETOOTH_GENERATED_OUTPUT}/${name}.swift")
+        add_custom_command(
+            OUTPUT "${generated}"
+            COMMAND "${CMAKE_COMMAND}" -E env
+                    SWIFTPM_BLUETOOTH_CABI=0
+                    "${SWIFT_EXECUTABLE}" run --skip-build
+                    --package-path "${CMAKE_CURRENT_SOURCE_DIR}"
+                    GenerateBluetooth
+                    ${BLUETOOTH_GENERATE_${name}} "${generated}"
+            DEPENDS "${BLUETOOTH_GENERATED_OUTPUT}/.generator-built"
+            WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+            COMMENT "Generating ${name}.swift"
+            VERBATIM)
+        list(APPEND BLUETOOTH_GENERATED_SOURCES "${generated}")
+    endforeach()
+endif()
+
+# ---------------------------------------------------------------------
+# Bluetooth — the Swift engine
+# ---------------------------------------------------------------------
+#
+# BluetoothMetadata is deliberately absent: it loads its JSON through
+# SwiftPM's `Bundle.module`, which does not exist here. Every use of it
+# in `Sources/Bluetooth` is `canImport`-guarded, and the ABI layer needs
+# none of it — the company-identifier table `bt_compidtostr` returns is
+# baked in ahead of time by Scripts/generate-company-names.py.
+
+file(GLOB BLUETOOTH_SOURCES CONFIGURE_DEPENDS
+    "${CMAKE_CURRENT_SOURCE_DIR}/Sources/Bluetooth/*.swift"
+    "${CMAKE_CURRENT_SOURCE_DIR}/Sources/Bluetooth/Extensions/*.swift")
+
+add_library(Bluetooth STATIC
+    ${BLUETOOTH_SOURCES}
+    ${BLUETOOTH_GENERATED_SOURCES})
+
+set_target_properties(Bluetooth PROPERTIES
+    Swift_MODULE_NAME Bluetooth)
+
+# `package`-level declarations in Sources/Bluetooth are visible to the
+# ABI layer only if both modules share a package name, as they do under
+# SwiftPM.
+target_compile_options(Bluetooth PRIVATE
+    "SHELL:-package-name Bluetooth")
+
+# ---------------------------------------------------------------------
+# BluetoothABI — the Swift implementations of the C entry points
+# ---------------------------------------------------------------------
+#
+# Includes the 75 pure `sdp_*` symbols (data model, PDU codec, attribute
+# accessors) alongside the rest of the C ABI — they ship in the same
+# shared object, so there's no separate BluetoothSDP target here.
+
+file(GLOB BLUETOOTH_ABI_SOURCES CONFIGURE_DEPENDS
+    "${CMAKE_CURRENT_SOURCE_DIR}/Sources/BluetoothABI/*.swift"
+    "${CMAKE_CURRENT_SOURCE_DIR}/Sources/BluetoothABI/gen/*.swift")
+
+add_library(BluetoothABI STATIC ${BLUETOOTH_ABI_SOURCES})
+
+set_target_properties(BluetoothABI PROPERTIES
+    Swift_MODULE_NAME BluetoothABI)
+
+target_compile_options(BluetoothABI PRIVATE
+    "SHELL:-package-name Bluetooth")
+
+target_link_libraries(BluetoothABI PUBLIC Bluetooth CBluetooth)
+
+# ---------------------------------------------------------------------
+# libbluetooth-util.so.0 — the installable artifact
+# ---------------------------------------------------------------------
+
+if(BLUETOOTH_ABI_SHARED)
+    set(BLUETOOTH_UTIL_VERSION_SCRIPT
+        "${CMAKE_CURRENT_SOURCE_DIR}/cmake/libbluetooth-util.map")
+
+    # A shared library needs at least one of its own objects; the Swift
+    # and C implementations arrive through --whole-archive below.
+    add_library(bluetooth-util SHARED cmake/empty.c)
+
+    set_target_properties(bluetooth-util PROPERTIES
+        OUTPUT_NAME bluetooth-util
+        SOVERSION ${BLUETOOTH_UTIL_SOVERSION}
+        VERSION ${BLUETOOTH_UTIL_VERSION}
+        # The link is driven by swiftc (the target pulls in Swift
+        # archives), and `bluetooth-util` is not a valid Swift
+        # identifier, so name the vestigial module explicitly.
+        Swift_MODULE_NAME bluetooth_util)
+
+    # Every entry point is referenced only from outside, so the archives
+    # holding them must be linked whole or the linker drops the lot.
+    #
+    # The archives are named explicitly through `LINKER:` (which expands
+    # to `-Xlinker` here) rather than via `$<LINK_LIBRARY:WHOLE_ARCHIVE>`:
+    # the link is driven by swiftc, whose driver silently discards bare
+    # `.a` arguments, so the result would be a shared library with no
+    # symbols in it. `add_dependencies` below restores the build ordering
+    # that naming targets directly would have given us.
+    target_link_options(bluetooth-util PRIVATE
+        "LINKER:--whole-archive"
+        "LINKER:$<TARGET_FILE:BluetoothABI>"
+        "LINKER:$<TARGET_FILE:CBluetooth>"
+        "LINKER:--no-whole-archive")
+
+    add_dependencies(bluetooth-util BluetoothABI CBluetooth)
+
+    # Linked normally: only the parts of the engine actually referenced.
+    target_link_libraries(bluetooth-util PRIVATE Bluetooth)
+
+    # Pin the export list. Upstream libbluetooth exports everything; we
+    # do not, so that the ABI surface is asserted rather than incidental.
+    target_link_options(bluetooth-util PRIVATE
+        "LINKER:--version-script=${BLUETOOTH_UTIL_VERSION_SCRIPT}")
+    set_target_properties(bluetooth-util PROPERTIES
+        LINK_DEPENDS "${BLUETOOTH_UTIL_VERSION_SCRIPT}")
+
+    if(BLUETOOTH_ABI_STATIC_STDLIB)
+        # Any process loading this library otherwise pulls in
+        # libswiftCore; static linking trades size for isolation.
+        target_link_options(bluetooth-util PRIVATE "-static-stdlib")
+    endif()
+
+    # pkg-config, so `pkg-config --libs bluetooth-util` works.
+    configure_file(
+        "${CMAKE_CURRENT_SOURCE_DIR}/cmake/bluetooth-util.pc.in"
+        "${CMAKE_CURRENT_BINARY_DIR}/bluetooth-util.pc"
+        @ONLY)
+
+    install(TARGETS bluetooth-util
+        LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}")
+
+    install(FILES "${CMAKE_CURRENT_BINARY_DIR}/bluetooth-util.pc"
+        DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+endif()
+
+if(BLUETOOTH_ABI_INSTALL_HEADERS)
+    # hci.h is vendored only because sdp_lib.h includes it; it declares
+    # nothing this library implements, but the reference package installs
+    # it too, so consumers that include it directly keep working.
+    file(GLOB CBLUETOOTH_HEADERS
+        "${CMAKE_CURRENT_SOURCE_DIR}/Sources/CBluetooth/include/bluetooth/*.h")
+    install(FILES ${CBLUETOOTH_HEADERS}
+        DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/bluetooth")
+endif()
+
+# ---------------------------------------------------------------------
+# Export verification
+# ---------------------------------------------------------------------
+#
+# `check-exports` diffs the built library's dynamic symbol table against
+# cmake/symbols.txt. Both a missing and an extra symbol fail, so the
+# export surface cannot drift silently.
+
+if(BLUETOOTH_ABI_SHARED)
+    add_custom_target(check-exports
+        COMMAND "${CMAKE_CURRENT_SOURCE_DIR}/Scripts/check-exports.sh"
+                "$<TARGET_FILE:bluetooth-util>"
+                "${CMAKE_CURRENT_SOURCE_DIR}/cmake/symbols.txt"
+        DEPENDS bluetooth-util
+        COMMENT "Checking exported symbols against cmake/symbols.txt"
+        VERBATIM)
+endif()