diff --git a/.github/workflows/builds.yml b/.github/workflows/builds.yml index 90fe8934f..67c08528d 100644 --- a/.github/workflows/builds.yml +++ b/.github/workflows/builds.yml @@ -161,7 +161,7 @@ jobs: ninja - windows-cmake: + windows-cmake-msvc: runs-on: windows-latest @@ -175,6 +175,10 @@ jobs: choco install ninja pip3 install meson refreshenv + - name: Set up MSVC developer environment + uses: TheMrMilchmann/setup-msvc-dev@v4 + with: + arch: x64 - name: Configure CMake MSVC shell: cmd run: | @@ -209,13 +213,11 @@ jobs: - name: Configure CMake NMake MSVC shell: cmd run: | - call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat" cmake -G"NMake Makefiles" -B build\nmake -S hidapisrc -DCMAKE_BUILD_TYPE=RelWithDebInfo -DHIDAPI_WITH_TESTS=ON -DHIDAPI_BUILD_PP_DATA_DUMP=ON -DHIDAPI_ENABLE_ASAN=ON -DCMAKE_INSTALL_PREFIX=install\nmake -DHIDAPI_BUILD_HIDTEST=ON "-DCMAKE_C_FLAGS=%MSVC_COMPILE_FLAGS%" - name: Build CMake NMake MSVC working-directory: build\nmake shell: cmd run: | - call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat" nmake install - name: Check artifacts CMake NMake MSVC uses: andstor/file-existence-action@v2 @@ -228,7 +230,6 @@ jobs: - name: Check CMake NMake MSVC Export Package shell: cmd run: | - call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat" cmake ^ -G"NMake Makefiles" ^ -B build\nmake_test ^ @@ -245,13 +246,11 @@ jobs: - name: Configure CMake NMake ClangCL shell: cmd run: | - call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat" cmake -G"NMake Makefiles" -B build\clang_cl -S hidapisrc -D CMAKE_C_COMPILER=clang-cl -DCMAKE_BUILD_TYPE=RelWithDebInfo -DHIDAPI_WITH_TESTS=ON -DHIDAPI_BUILD_PP_DATA_DUMP=ON -DHIDAPI_ENABLE_ASAN=OFF -DCMAKE_INSTALL_PREFIX=install\clang_cl -DHIDAPI_BUILD_HIDTEST=ON "-DCMAKE_C_FLAGS=%MSVC_COMPILE_FLAGS%" - name: Build CMake NMake ClangCL working-directory: build\clang_cl shell: cmd run: | - call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat" nmake install - name: Check artifacts CMake NMake ClangCL uses: andstor/file-existence-action@v2 @@ -264,7 +263,6 @@ jobs: - name: Check CMake NMake ClangCL Export Package shell: cmd run: | - call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat" cmake ^ -G"NMake Makefiles" ^ -B build\clang_cl_test ^ @@ -280,6 +278,25 @@ jobs: working-directory: build/clang_cl run: ctest -C RelWithDebInfo --no-compress-output --output-on-failure + - name: Check Meson build + shell: cmd + run: | + meson setup build_meson hidapisrc + cd build_meson + ninja + + + windows-cmake-mingw: + + runs-on: windows-latest + + steps: + - uses: actions/checkout@v3 + with: + path: hidapisrc + # MinGW builds with gcc and runs in its own job, deliberately without the + # MSVC developer environment (which would otherwise make CMake's "MinGW + # Makefiles" generator pick up cl). - name: Configure CMake MinGW shell: cmd run: | @@ -311,14 +328,6 @@ jobs: working-directory: build\mingw run: ctest --no-compress-output --output-on-failure - - name: Check Meson build - shell: cmd - run: | - call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat" - meson setup build_meson hidapisrc - cd build_meson - ninja - windows-msbuild: diff --git a/.gitignore b/.gitignore index 048900e28..ee128dbaf 100644 --- a/.gitignore +++ b/.gitignore @@ -30,3 +30,9 @@ CMakeLists.txt.user # doxgen output doxygen/html/ + +# Visual Studio Code + CMake +.vscode/ + +# Local build directory +build/ diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml new file mode 100644 index 000000000..6811548e2 --- /dev/null +++ b/.gitlab-ci.yml @@ -0,0 +1,209 @@ +.shared_windows_runners: + tags: + - shared-windows + - windows + - windows-1809 + +stages: + - build + +variables: + GIT_DEPTH: 0 + +before_script: + - echo "started by ${GITLAB_USER_NAME}" + +#-----------------------------------------------------------# +# OpenRGB Common Debian Build Steps # +#-----------------------------------------------------------# +.hidden_deb_script: &debian_script_steps + stage: build + image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:$TGT_DEB-$TGT_ARCH + tags: + - linux + - $TGT_ARCH + script: + - dpkg-architecture -l + - rm -f ../*.deb + - dpkg-buildpackage -us -B + - mv -v ../*.deb ./ + + artifacts: + name: "${CI_PROJECT_NAME}_Linux_${TGT_ARCH}_deb_${CI_COMMIT_SHORT_SHA}" + paths: + - libhidapi-hotplug-libusb0*.deb + - libhidapi-hotplug-hidraw0*.deb + - libhidapi-hotplug-dev*.deb + exclude: + - libhidapi-hotplug-libusb0-dbgsym*.deb + - libhidapi-hotplug-hidraw0-dbgsym*.deb + expire_in: 30 days + +#-----------------------------------------------------------# +# Linux (.deb) Debian Bookworm i386 Build Target # +#-----------------------------------------------------------# +"Linux i386 .deb (Debian Bookworm)": + variables: + TGT_ARCH: "i386" + TGT_DEB: "bookworm" + <<: *debian_script_steps + +#-----------------------------------------------------------# +# Linux (.deb) Debian Trixie i386 Build Target # +#-----------------------------------------------------------# +"Linux i386 .deb (Debian Trixie)": + variables: + TGT_ARCH: "i386" + TGT_DEB: "trixie" + <<: *debian_script_steps + +#-----------------------------------------------------------# +# Linux (.deb) Debian Bookworm amd64 Build Target # +#-----------------------------------------------------------# +"Linux amd64 .deb (Debian Bookworm)": + variables: + TGT_ARCH: "amd64" + TGT_DEB: "bookworm" + <<: *debian_script_steps + +#-----------------------------------------------------------# +# Linux (.deb) Debian Trixie amd64 Build Target # +#-----------------------------------------------------------# +"Linux amd64 .deb (Debian Trixie)": + variables: + TGT_ARCH: "amd64" + TGT_DEB: "trixie" + <<: *debian_script_steps + +#-----------------------------------------------------------# +# Linux (.deb) Debian Bookworm armhf Build Target # +#-----------------------------------------------------------# +"Linux armhf .deb (Debian Bookworm)": + variables: + TGT_ARCH: "armhf" + TGT_DEB: "bookworm" + <<: *debian_script_steps + +#-----------------------------------------------------------# +# Linux (.deb) Debian Trixie armhf Build Target # +#-----------------------------------------------------------# +"Linux armhf .deb (Debian Trixie)": + variables: + TGT_ARCH: "armhf" + TGT_DEB: "trixie" + <<: *debian_script_steps + +#-----------------------------------------------------------# +# Linux (.deb) Debian Bookworm arm64 Build Target # +#-----------------------------------------------------------# +"Linux arm64 .deb (Debian Bookworm)": + variables: + TGT_ARCH: "arm64" + TGT_DEB: "bookworm" + <<: *debian_script_steps + +#-----------------------------------------------------------# +# Linux (.deb) Debian Trixie arm64 Build Target # +#-----------------------------------------------------------# +"Linux arm64 .deb (Debian Trixie)": + variables: + TGT_ARCH: "arm64" + TGT_DEB: "trixie" + <<: *debian_script_steps + +#-----------------------------------------------------------# +# Linux (.rpm, F43) amd64 Build Target # +#-----------------------------------------------------------# +"Linux amd64 F43 rpm": + image: fedora:43 + stage: build + script: + - dnf install rpmdevtools dnf-plugins-core libcurl-devel qt5-qtbase-devel git -y + - rpmdev-setuptree + - cp fedora/hidapi-hotplug.spec /root/rpmbuild/SPECS + - cp -rp . /root/rpmbuild/SOURCES/hidapi-hotplug + - cd /root/rpmbuild + - dnf builddep SPECS/hidapi-hotplug.spec -y + - rpmbuild -ba SPECS/hidapi-hotplug.spec + - cd RPMS/x86_64/ + - mv hidapi-hotplug*.rpm ${CI_PROJECT_DIR}/ + - cd ${CI_PROJECT_DIR} + + artifacts: + name: "${CI_PROJECT_NAME}_Linux_amd64_rpm_${CI_COMMIT_SHORT_SHA}" + paths: + - hidapi-hotplug*.rpm + expire_in: 30 days + +#-----------------------------------------------------------# +# Linux (.rpm, F43) arm64 Build Target # +#-----------------------------------------------------------# +"Linux arm64 F43 rpm": + image: fedora:43 + tags: + - linux + - arm64 + stage: build + script: + - dnf install rpmdevtools dnf-plugins-core libcurl-devel qt5-qtbase-devel git -y + - rpmdev-setuptree + - cp fedora/hidapi-hotplug.spec /root/rpmbuild/SPECS + - cp -rp . /root/rpmbuild/SOURCES/hidapi-hotplug + - cd /root/rpmbuild + - dnf builddep SPECS/hidapi-hotplug.spec -y + - rpmbuild -ba SPECS/hidapi-hotplug.spec + - cd RPMS/aarch64/ + - mv hidapi-hotplug*.rpm ${CI_PROJECT_DIR}/ + - cd ${CI_PROJECT_DIR} + + artifacts: + name: "${CI_PROJECT_NAME}_Linux_arm64_rpm_${CI_COMMIT_SHORT_SHA}" + paths: + - hidapi-hotplug*.rpm + expire_in: 30 days + +#-----------------------------------------------------------# +# Windows (32-bit) Build Target # +#-----------------------------------------------------------# +"Windows 32": + extends: + - .shared_windows_runners + stage: build + script: + - $ErrorActionPreference = "SilentlyContinue" ; Set-MpPreference -DisableRealtimeMonitoring $true ; $ErrorActionPreference = "Stop" + - Push-Location "C:/Program Files (x86)/Microsoft Visual Studio/2022/BuildTools/VC/Auxiliary/Build" + - '& cmd.exe /C "vcvarsall.bat x86 & set" | Foreach-Object { if ($_ -match "(.*?)=(.*)") { Set-Item -force -path "Env:\$($matches[1])" -value "$($matches[2])" } }' + - Pop-Location + - mkdir build + - cd build + - cmake -G "Ninja" .. + - ninja + artifacts: + name: "${CI_PROJECT_NAME}_Windows_32_${CI_COMMIT_SHORT_SHA}" + paths: + - 'build\src\windows\hidapi-hotplug.dll' + - 'build\src\windows\hidapi-hotplug.lib' + expire_in: 30 days + +#-----------------------------------------------------------# +# Windows (64-bit) Build Target # +#-----------------------------------------------------------# +"Windows 64": + extends: + - .shared_windows_runners + stage: build + script: + - $ErrorActionPreference = "SilentlyContinue" ; Set-MpPreference -DisableRealtimeMonitoring $true ; $ErrorActionPreference = "Stop" + - Push-Location "C:/Program Files (x86)/Microsoft Visual Studio/2022/BuildTools/VC/Auxiliary/Build" + - '& cmd.exe /C "vcvarsall.bat x64 & set" | Foreach-Object { if ($_ -match "(.*?)=(.*)") { Set-Item -force -path "Env:\$($matches[1])" -value "$($matches[2])" } }' + - Pop-Location + - mkdir build + - cd build + - cmake -G "Ninja" .. + - ninja + artifacts: + name: "${CI_PROJECT_NAME}_Windows_64_${CI_COMMIT_SHORT_SHA}" + paths: + - 'build\src\windows\hidapi-hotplug.dll' + - 'build\src\windows\hidapi-hotplug.lib' + expire_in: 30 days \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt index d7086813c..6c02de065 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -31,7 +31,7 @@ endif() unset(_build_type_index) # -project(hidapi LANGUAGES C) +project(hidapi-hotplug LANGUAGES C) if(APPLE) if(NOT CMAKE_VERSION VERSION_LESS "3.15") diff --git a/debian/changelog b/debian/changelog new file mode 100644 index 000000000..7e1538e43 --- /dev/null +++ b/debian/changelog @@ -0,0 +1,5 @@ +hidapi-hotplug (0.15.0-1) unstable; urgency=medium + + * hidapi patched with hotplug support + + -- Adam Honse Thu, 06 Aug 2026 22:55:09 -0600 \ No newline at end of file diff --git a/debian/control b/debian/control new file mode 100644 index 000000000..424ca4c70 --- /dev/null +++ b/debian/control @@ -0,0 +1,56 @@ +Source: hidapi-hotplug +Priority: optional +Maintainer: Adam Honse +Build-Depends: + debhelper-compat (= 13), + cmake, + libudev-dev [linux-any], + libusb-1.0-0-dev, + pkgconf, +Standards-Version: 4.7.2 +Section: libs +Homepage: https://gitlab.com/OpenRGBDevelopers/hidapi-hotplug.git +Rules-Requires-Root: no + +Package: libhidapi-hotplug-dev +Section: libdevel +Architecture: any +Multi-Arch: same +Depends: + libhidapi-hotplug-hidraw0 (= ${binary:Version}) [linux-any], + libhidapi-hotplug-libusb0 (= ${binary:Version}), + ${misc:Depends}, +Description: Multi-Platform library for communication with HID devices with hotplug support (development files) + HIDAPI is a multi-platform library enabling applications to easily + interface with Bluetooth and USB HID-class devices. + . + This package contains the files needed to compile and link programs which + use HIDAPI. + +Package: libhidapi-hotplug-libusb0 +Architecture: any +Multi-Arch: same +Pre-Depends: + ${misc:Pre-Depends}, +Depends: + ${misc:Depends}, + ${shlibs:Depends}, +Description: Multi-Platform library for communication with HID devices with hotplug support (libusb backend) + HIDAPI is a multi-platform library enabling applications to easily + interface with Bluetooth and USB HID-class devices. + . + This package contains the libusb-based implementation of HIDAPI. + +Package: libhidapi-hotplug-hidraw0 +Architecture: linux-any +Multi-Arch: same +Pre-Depends: + ${misc:Pre-Depends}, +Depends: + ${misc:Depends}, + ${shlibs:Depends}, +Description: Multi-Platform library for communication with HID devices with hotplug support (hidraw backend) + HIDAPI is a multi-platform library enabling applications to easily + interface with Bluetooth and USB HID-class devices. + . + This package contains the hidraw-based implementation of HIDAPI. diff --git a/debian/libhidapi-hotplug-dev.install b/debian/libhidapi-hotplug-dev.install new file mode 100644 index 000000000..7df81cd9f --- /dev/null +++ b/debian/libhidapi-hotplug-dev.install @@ -0,0 +1,3 @@ +usr/include/* +usr/lib/*/lib*.so +usr/lib/*/pkgconfig/* diff --git a/debian/libhidapi-hotplug-hidraw0.install b/debian/libhidapi-hotplug-hidraw0.install new file mode 100644 index 000000000..7a34b22ea --- /dev/null +++ b/debian/libhidapi-hotplug-hidraw0.install @@ -0,0 +1 @@ +usr/lib/*/libhidapi-hotplug-hidraw.so.* diff --git a/debian/libhidapi-hotplug-libusb0.install b/debian/libhidapi-hotplug-libusb0.install new file mode 100644 index 000000000..84a982f76 --- /dev/null +++ b/debian/libhidapi-hotplug-libusb0.install @@ -0,0 +1 @@ +usr/lib/*/libhidapi-hotplug-libusb.so.* diff --git a/debian/libhidapi-hotplug0.install b/debian/libhidapi-hotplug0.install new file mode 100644 index 000000000..7c7c9f85a --- /dev/null +++ b/debian/libhidapi-hotplug0.install @@ -0,0 +1 @@ +usr/lib/*/libhidapi-hotplug.so.* diff --git a/debian/not-installed b/debian/not-installed new file mode 100644 index 000000000..c8526ccdd --- /dev/null +++ b/debian/not-installed @@ -0,0 +1,4 @@ +usr/share/doc/hidapi/AUTHORS.txt +usr/share/doc/hidapi/LICENSE*.txt +usr/share/doc/hidapi/README.md +usr/lib/*/cmake diff --git a/debian/rules b/debian/rules new file mode 100755 index 000000000..994fc025a --- /dev/null +++ b/debian/rules @@ -0,0 +1,8 @@ +#!/usr/bin/make -f + +export DEB_BUILD_MAINT_OPTIONS = hardening=+all + +%: + dh $@ --buildsystem=cmake --without autoreconf + + diff --git a/debian/source/format b/debian/source/format new file mode 100644 index 000000000..89ae9db8f --- /dev/null +++ b/debian/source/format @@ -0,0 +1 @@ +3.0 (native) diff --git a/fedora/hidapi-hotplug.spec b/fedora/hidapi-hotplug.spec new file mode 100644 index 000000000..958247777 --- /dev/null +++ b/fedora/hidapi-hotplug.spec @@ -0,0 +1,234 @@ +%global _name hidapi-hotplug + +Name: hidapi-hotplug +Version: 0.15.0 +Release: 3%{?dist} +Summary: Library for communicating with USB and Bluetooth HID devices (hotplug enabled) + +License: GPL-3.0-only OR BSD-3-Clause +URL: https://gitlab.com/OpenRGBDevelopers/hidapi-hotplug + +BuildRequires: cmake +BuildRequires: gcc +BuildRequires: libudev-devel +BuildRequires: libusb1-devel + +BuildRequires: mingw32-filesystem >= 95 +BuildRequires: mingw32-gcc +BuildRequires: mingw32-binutils + +BuildRequires: mingw64-filesystem >= 95 +BuildRequires: mingw64-gcc +BuildRequires: mingw64-binutils + +%global _description %{expand: +HIDAPI is a multi-platform library which allows an application to interface +with USB and Bluetooth HID-class devices on Windows, Linux, FreeBSD and Mac OS +X. On Linux, either the hidraw or the libusb back-end can be used. There are +trade-offs and the functionality supported is slightly different.} + +%description %_description + +%prep +cp -r %{_sourcedir}/%{_name}/. %{_builddir} + +%define _unpackaged_files_terminate_build 0 + +%package devel +Summary: Development files for hidapi-hotplug +Requires: %{name}%{?_isa} = %{version}-%{release} + +%description -n hidapi-hotplug-devel +This package contains development files for hidapi-hotplug which provides access to +USB and Bluetooth HID-class devices. + +%package -n mingw32-hidapi-hotplug +Summary: %{summary} +Obsoletes: mingw32-hidapi-hotplug-static < 0.11.2-6 + +%description -n mingw32-hidapi-hotplug %_description + +%package -n mingw64-hidapi-hotplug +Summary: %{summary} +Obsoletes: mingw64-hidapi-hotplug-static < 0.11.2-6 + +%description -n mingw64-hidapi-hotplug %_description + +%{?mingw_debug_package} + +%build +%cmake +%cmake_build + +%mingw_cmake +%mingw_make_build + + +%install +%cmake_install + +%mingw_make_install +%mingw_debug_install_post + + +%files +%doc AUTHORS.txt README.md LICENSE*.txt +%{_libdir}/libhidapi-*.so.* + +%files devel +%{_includedir}/hidapi-hotplug +%{_libdir}/cmake/hidapi-hotplug +%{_libdir}/libhidapi-hotplug-hidraw.so +%{_libdir}/libhidapi-hotplug-libusb.so +%{_libdir}/pkgconfig/hidapi-hotplug-hidraw.pc +%{_libdir}/pkgconfig/hidapi-hotplug-libusb.pc + +%files -n mingw32-hidapi-hotplug +%doc AUTHORS.txt README.md LICENSE*.txt +%{mingw32_libdir}/cmake/hidapi-hotplug +%{mingw32_bindir}/libhidapi-hotplug.dll +%{mingw32_libdir}/libhidapi-hotplug.dll.a +%{mingw32_libdir}/pkgconfig/hidapi-hotplug.pc +%{mingw32_includedir}/hidapi-hotplug + +%files -n mingw64-hidapi-hotplug +%doc AUTHORS.txt README.md LICENSE*.txt +%{mingw64_libdir}/cmake/hidapi-hotplug +%{mingw64_bindir}/libhidapi-hotplug.dll +%{mingw64_libdir}/libhidapi-hotplug.dll.a +%{mingw64_libdir}/pkgconfig/hidapi-hotplug.pc +%{mingw64_includedir}/hidapi-hotplug + +%changelog +* Wed Jan 21 2026 Adam Honse - 0.15.0-1 +- Forked existing hidapi spec to build hidapi-hotplug + +* Fri Jan 16 2026 Fedora Release Engineering - 0.15.0-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_44_Mass_Rebuild + +* Thu Jul 24 2025 Fedora Release Engineering - 0.15.0-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_43_Mass_Rebuild + +* Wed May 21 2025 Scott Talbert - 0.15.0-1 +- Update to new upstream release 0.15.0 (#2367105) + +* Fri Jan 17 2025 Fedora Release Engineering - 0.14.0-7 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_42_Mass_Rebuild + +* Wed Jul 31 2024 Scott Talbert - 0.14.0-6 +- Update License tag to use SPDX identifiers + +* Thu Jul 18 2024 Fedora Release Engineering - 0.14.0-5 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_41_Mass_Rebuild + +* Wed Jan 24 2024 Fedora Release Engineering - 0.14.0-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_40_Mass_Rebuild + +* Sat Jan 20 2024 Fedora Release Engineering - 0.14.0-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_40_Mass_Rebuild + +* Thu Jul 20 2023 Fedora Release Engineering - 0.14.0-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_39_Mass_Rebuild + +* Tue May 23 2023 Scott Talbert - 0.14.0-1 +- Update to new upstream release 0.14.0 (#2209190) + +* Thu Feb 02 2023 Scott Talbert - 0.13.1-1 +- Update to new upstream release 0.13.1 (#2159139) + +* Wed Feb 01 2023 Scott Talbert - 0.12.0-4 +- Add mingw subpackages + +* Thu Jan 19 2023 Fedora Release Engineering - 0.12.0-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_38_Mass_Rebuild + +* Thu Jul 21 2022 Fedora Release Engineering - 0.12.0-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_37_Mass_Rebuild + +* Thu Jun 16 2022 Scott Talbert - 0.12.0-1 +- Update to new upstream release 0.12.0 (#2081598) + +* Thu Jan 20 2022 Fedora Release Engineering - 0.11.2-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_36_Mass_Rebuild + +* Mon Jan 03 2022 Scott Talbert - 0.11.2-1 +- Update to new upstream release 0.11.2 (#2036738) + +* Mon Oct 04 2021 Scott Talbert - 0.11.0-1 +- Update to new upstream release 0.11.0 (#2008570) + +* Thu Jul 22 2021 Fedora Release Engineering - 0.10.1-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_35_Mass_Rebuild + +* Tue Jan 26 2021 Fedora Release Engineering - 0.10.1-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_34_Mass_Rebuild + +* Thu Dec 31 19:56:21 EST 2020 Scott Talbert - 0.10.1-2 +- Fix FTBFS with autoconf 2.70 + +* Tue Nov 24 21:26:02 EST 2020 Scott Talbert - 0.10.1-1 +- Update to new upstream release 0.10.1 (#1901388) +- Remove BR on gcc-c++ (no longer needed) + +* Mon Oct 26 2020 Scott Talbert - 0.10.0-1 +- Update to new upstream release 0.10.0 (#1891375) + +* Tue Jul 28 2020 Fedora Release Engineering - 0.9.0-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_33_Mass_Rebuild + +* Wed Jan 29 2020 Fedora Release Engineering - 0.9.0-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_32_Mass_Rebuild + +* Thu Jul 25 2019 Fedora Release Engineering - 0.9.0-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_31_Mass_Rebuild + +* Wed Jul 10 2019 Scott Talbert - 0.9.0-1 +- Switch to new upstream at libusb organization + +* Fri Feb 01 2019 Fedora Release Engineering - 0.8.0-0.11.d17db57 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_30_Mass_Rebuild + +* Sun Jul 15 2018 Scott Talbert - 0.8.0-0.10.d17db57 +- Add missing BR for gcc-c++, fixes mass rebuild FTBFS + +* Fri Jul 13 2018 Fedora Release Engineering - 0.8.0-0.9.d17db57 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_29_Mass_Rebuild + +* Mon Feb 19 2018 Scott Talbert - 0.8.0-0.8.d17db57 +- Add missing BR for gcc + +* Wed Feb 07 2018 Fedora Release Engineering - 0.8.0-0.7.d17db57 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_28_Mass_Rebuild + +* Sat Feb 03 2018 Igor Gnatenko - 0.8.0-0.6.d17db57 +- Switch to %%ldconfig_scriptlets + +* Wed Aug 02 2017 Fedora Release Engineering - 0.8.0-0.5.d17db57 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Binutils_Mass_Rebuild + +* Wed Jul 26 2017 Fedora Release Engineering - 0.8.0-0.4.d17db57 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Mass_Rebuild + +* Fri Feb 10 2017 Fedora Release Engineering - 0.8.0-0.3.d17db57 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_26_Mass_Rebuild + +* Wed Feb 03 2016 Fedora Release Engineering - 0.8.0-0.2.d17db57 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_24_Mass_Rebuild + +* Tue Sep 01 2015 Scott Talbert - 0.8.0-0.1.d17db57 +- Update to latest upstream commit d17db57 + +* Wed Jun 17 2015 Fedora Release Engineering - 0.7.0-5.a88c724 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_23_Mass_Rebuild + +* Sat Aug 16 2014 Fedora Release Engineering - 0.7.0-4.a88c724 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_21_22_Mass_Rebuild + +* Sat Jun 07 2014 Fedora Release Engineering - 0.7.0-3.a88c724 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_21_Mass_Rebuild + +* Tue Oct 29 2013 Scott Talbert - 0.7.0-2.a88c724 +- Incorporate review comments + +* Wed Oct 23 2013 Scott Talbert - 0.7.0-1.a88c724 +- Initial packaging of hidapi library diff --git a/hidapi/hidapi.h b/hidapi-hotplug/hidapi.h similarity index 61% rename from hidapi/hidapi.h rename to hidapi-hotplug/hidapi.h index c101d55b8..5a634cdd1 100644 --- a/hidapi/hidapi.h +++ b/hidapi-hotplug/hidapi.h @@ -144,6 +144,13 @@ extern "C" { Specifications: https://www.microsoft.com/download/details.aspx?id=103325 */ HID_API_BUS_SPI = 0x04, + + /** Virtual device + E.g.: https://elixir.bootlin.com/linux/v4.0/source/include/uapi/linux/input.h#L955 + + Since version 0.16.0, @ref HID_API_VERSION >= HID_API_MAKE_VERSION(0, 16, 0) + */ + HID_API_BUS_VIRTUAL = 0x05, } hid_bus_type; /** hidapi info structure */ @@ -254,6 +261,324 @@ extern "C" { */ void HID_API_EXPORT HID_API_CALL hid_free_enumeration(struct hid_device_info *devs); + /** @brief Callback handle. + + Since version 0.16.0, @ref HID_API_VERSION >= HID_API_MAKE_VERSION(0, 16, 0) + + Callback handles are generated by hid_hotplug_register_callback() + and can be used to deregister callbacks. Callback handles are + unique and are not reused while the library remains initialized, + so it is safe to call hid_hotplug_deregister_callback() on an + already deregistered callback: it fails with -1 and never + affects another callback. + + A valid callback handle is always a positive value; + 0 is never a valid handle and may be used as a sentinel. + + @ingroup API + */ + typedef int hid_hotplug_callback_handle; + + /** @brief Hotplug events. + + Since version 0.16.0, @ref HID_API_VERSION >= HID_API_MAKE_VERSION(0, 16, 0) + + @ingroup API + */ + typedef enum { + /** A device has been plugged in and may be opened. + Opening can still fail, e.g. due to insufficient permissions + or if the device has already disconnected again. */ + HID_API_HOTPLUG_EVENT_DEVICE_ARRIVED = (1 << 0), + + /** A device has left and is no longer available. + If the application holds an open handle to the device, it is + still the application's responsibility to close it with + hid_close(). + */ + HID_API_HOTPLUG_EVENT_DEVICE_LEFT = (1 << 1) + } hid_hotplug_event; + + /** @brief Hotplug flags. + + Since version 0.16.0, @ref HID_API_VERSION >= HID_API_MAKE_VERSION(0, 16, 0) + + @ingroup API + */ + typedef enum { + /** Arm the callback and fire it for all matching devices that are + already connected at registration time. + + hid_hotplug_register_callback() takes a snapshot of the + matching connected devices, and the callback is invoked + asynchronously, on the same internal event context that + delivers live events (see #hid_hotplug_callback_fn), once + for each device in that snapshot. Devices whose arrival is + detected after the snapshot is taken are reported as regular + live events: each device connection is reported to the + callback exactly once - either by the initial pass or as a + live event, never both and never neither. (A device that + disconnects and reconnects is a new connection and is + reported again.) + + The initial pass is delivered before any live events for + this callback. In particular, a callback registered with + this flag for both event types never observes a + #HID_API_HOTPLUG_EVENT_DEVICE_LEFT for a matching device + whose arrival it has not been told about first. + + These synthetic "arrived" events are delivered only when + #HID_API_HOTPLUG_EVENT_DEVICE_ARRIVED is present in the + requested events mask. + + hid_hotplug_register_callback() returning does not imply + the initial pass has been delivered yet: the synthetic + events may fire before or after it returns. */ + HID_API_HOTPLUG_ENUMERATE = (1 << 0) + } hid_hotplug_flag; + + /** @brief Hotplug callback function type. + + Since version 0.16.0, @ref HID_API_VERSION >= HID_API_MAKE_VERSION(0, 16, 0) + + Called by HIDAPI when a device matching the registration filter + is connected or disconnected. See #hid_hotplug_register_callback. + + @par Execution context + + The callback is only ever invoked on HIDAPI's internal event + context, never on an application thread (including the + application's main thread). This includes the synthetic + "arrived" events requested with #HID_API_HOTPLUG_ENUMERATE: + they are delivered asynchronously on that same context and are + never delivered from within the hid_hotplug_register_callback() + call itself. (When a hotplug callback itself registers a new + callback with #HID_API_HOTPLUG_ENUMERATE, the new registration's + synthetic events are delivered later, on this same event + context.) + + Every callback invocation holds an internal hotplug mutex for + its duration: any other thread calling + hid_hotplug_register_callback() or + hid_hotplug_deregister_callback() will block until the callback + returns. The mutex is re-entrant: calling those functions from + within the callback itself (i.e. on the event context, which + already holds the mutex) does not block and cannot deadlock - + that is what makes them safe to call from inside the callback + (see below). Keep the callback short. + + When multiple callbacks are registered, each event is delivered + to every matching callback sequentially, in the order the + callbacks were registered. + + @par What the callback may call + + The hotplug API itself is thread-safe (see "Thread safety" under + #hid_hotplug_register_callback) and the following calls are always + safe from within the callback: + + - hid_hotplug_register_callback() + - hid_hotplug_deregister_callback() (including on its own handle) + - hid_error(dev) with a non-NULL device handle, provided no + other thread uses that same handle concurrently + + HIDAPI calls made from within the callback do not update the + global error string: the callback runs on HIDAPI's internal + event context, and internal contexts never write that string + (an application has no way to serialize against them, so writing + it there would be a use-after-free waiting to happen). Failures + are still reported through return values as usual, and + hid_error(dev) still works for a device handle - only + hid_error(NULL) is left untouched by calls made from the + callback. + + Any other HIDAPI function follows HIDAPI's general thread-safety + rule (see the Multi-threading Notes in the project wiki): it is + the application's responsibility to serialize hid_init / hid_exit / + hid_enumerate / hid_open* / hid_close / hid_error(NULL) across all + threads, including the hotplug callback thread (hid_exit() + additionally must never be called from within the callback + itself - see below). If your application + already calls those functions only from one thread, calling them + from the hotplug callback adds a second thread and is therefore + UNSAFE unless the application adds synchronisation itself. The + recommended pattern is to copy the needed fields of @p device out + of the callback and handle open/close on your own thread. + + Calling hid_exit() from within the callback has undefined behavior: + hid_exit() joins the hotplug thread, which would be joining itself. + + @par The device parameter + + The @p device pointer is owned by HIDAPI and is valid only for the + duration of the call. To keep any of its fields (path, + serial_number, manufacturer_string, etc.) beyond the callback, + copy them out; pointer fields must be deep-copied, as all strings + are owned by HIDAPI. + + The @p device->next pointer is always NULL. Each callback + invocation describes exactly one device; compound or composite + devices that expose multiple interfaces produce multiple callback + invocations (typically delivered in quick succession). + + For #HID_API_HOTPLUG_EVENT_DEVICE_LEFT events @p device points to + a copy captured when the device arrived (or was enumerated): all + fields, including the strings, are valid and describe the device + as it was while connected. A "left" event is delivered for any + matching device that disconnects while the callback is + registered, including devices that were already connected + before the registration (their arrival is reported to this + callback only if #HID_API_HOTPLUG_ENUMERATE was used). When the + callback has observed the device's arrival, the path field + matches the one reported then and may be used to correlate the + two events. + + @par Return value + + Return 0 to keep the callback registered. Return any non-zero + value to have HIDAPI deregister the callback; no further events + for this handle will be delivered, and the handle is freed as if + hid_hotplug_deregister_callback() had been called. This applies + to both live events and to the synthetic "arrived" events of + #HID_API_HOTPLUG_ENUMERATE: a non-zero return during the + initial pass stops the remainder of that pass and deregisters + the callback. + + @ingroup API + + @param callback_handle The handle of this callback. + @param device The hid_device_info of the device this event occurred on. + @param event Event that occurred: exactly one value (not a mask) + of \ref hid_hotplug_event. + @param user_data User data provided when this callback was registered + (may be NULL). + + @returns + 0 to stay registered; any non-zero value to be deregistered. + */ + typedef int (HID_API_CALL *hid_hotplug_callback_fn)( + hid_hotplug_callback_handle callback_handle, + struct hid_device_info *device, + hid_hotplug_event event, + void *user_data); + + /** @brief Register a HID hotplug callback function. + + Since version 0.16.0, @ref HID_API_VERSION >= HID_API_MAKE_VERSION(0, 16, 0) + + If @p vendor_id is set to 0 then any vendor matches. + If @p product_id is set to 0 then any product matches. + If @p vendor_id and @p product_id are both set to 0, then all HID devices will be notified. + + If HIDAPI is not initialized yet, this function initializes it + implicitly (as if by hid_init()). On some backends this binds + HIDAPI's device-monitoring facilities to the calling thread (for + example, the macOS backend schedules its run loop there). An + application that cares which thread owns those facilities should + call hid_init() explicitly from that thread first, rather than + relying on the implicit initialization performed here. + + When #HID_API_HOTPLUG_ENUMERATE is set, the synthetic "arrived" + events are delivered asynchronously on HIDAPI's internal event + context (see #hid_hotplug_flag): they may fire before or after + this function returns, but never from within this call itself, + and never on an application thread. + @p callback_handle (when non-NULL) is written before any events + can be delivered, and the callback always receives its own + handle as a parameter, so the callback may deregister itself + even during that initial pass. + + @par Thread safety + + hid_hotplug_register_callback() and hid_hotplug_deregister_callback() + are thread-safe with respect to each other and to HIDAPI's + internal hotplug machinery. They may be called from any thread, + including from within a hotplug callback. This is a deliberate + exception to HIDAPI's general "not thread-safe" rule (see the + Multi-threading Notes in the project wiki). + + The one caveat is the global error string: on failure these two + functions set it, like every other HIDAPI function that reports + an error via hid_error(NULL). They therefore have to be + serialized against hid_error(NULL) - which the application is + already required to serialize across all threads - even though + they need no serialization against each other. HIDAPI's own + internal threads never write the global error string, so an + application that serializes its own hid_error(NULL) calls + against its other HIDAPI calls is safe. + + The first successful call to hid_hotplug_register_callback() + starts HIDAPI's internal hotplug machinery (on most platforms an + internal thread), which runs until either (a) the last callback + is deregistered, or (b) hid_exit() is called. hid_exit() + deregisters any callbacks that are still registered and + invalidates their handles. hid_exit() must not be called from + within a hotplug callback (see #hid_hotplug_callback_fn). + + @ingroup API + + @param vendor_id The Vendor ID (VID) of the types of device to notify about. + @param product_id The Product ID (PID) of the types of device to notify about. + @param events Bitwise or of hotplug events that will trigger this callback. + See \ref hid_hotplug_event. + @param flags Bitwise or of hotplug flags that affect registration. + See \ref hid_hotplug_flag. + @param callback The callback function that will be called on device connection/disconnection. + See \ref hid_hotplug_callback_fn. + @param user_data The user data you wanted to provide to your callback function. + @param callback_handle Pointer to store the handle of the allocated callback + (Optionally NULL). On failure, *callback_handle (when + non-NULL) is set to 0. + + @returns + This function returns 0 on success or -1 on error. + Call hid_error(NULL) to get the failure reason. + Registration fails if @p callback is NULL, if @p events + contains no valid #hid_hotplug_event bit, or if @p events + or @p flags contain unknown bits. When more than one argument + is invalid, which one the failure string names is + unspecified and may differ between backends; only the -1 + return and the zeroed @p callback_handle are guaranteed. + + @note On backends without hotplug support (e.g. NetBSD) + this function always returns -1. + */ + int HID_API_EXPORT HID_API_CALL hid_hotplug_register_callback(unsigned short vendor_id, unsigned short product_id, int events, int flags, hid_hotplug_callback_fn callback, void *user_data, hid_hotplug_callback_handle *callback_handle); + + /** @brief Deregister a callback from a HID hotplug. + + Since version 0.16.0, @ref HID_API_VERSION >= HID_API_MAKE_VERSION(0, 16, 0) + + Thread-safe. May be called from any thread, including from within + a hotplug callback (on its own handle or on another callback's + handle). Calling it on a handle that was already deregistered, + or on a handle that was never valid, is safe: it has no effect + and returns -1. + + When called from any thread other than HIDAPI's internal event + context, this function does not return until an in-progress + invocation of the callback (if any) has completed; once it + returns, the callback will not be invoked again - including any + undelivered synthetic events of #HID_API_HOTPLUG_ENUMERATE - + and it is safe to release any resources the callback uses + (e.g. whatever @p user_data points to). When called from within + a hotplug callback, the deregistered callback will not be + invoked once the currently executing invocation returns. + + See "Thread safety" on #hid_hotplug_register_callback for the + full thread-safety contract of the hotplug API. + + @ingroup API + + @param callback_handle The handle of the callback to deregister. + + @returns + This function returns 0 when the callback was found and + deregistered, or -1 on error (including when + @p callback_handle is not a registered handle). + */ + int HID_API_EXPORT HID_API_CALL hid_hotplug_deregister_callback(hid_hotplug_callback_handle callback_handle); + /** @brief Open a HID device using a Vendor ID (VID), Product ID (PID) and optionally a serial number. diff --git a/hidtest/test.c b/hidtest/test.c index eb01d88e0..d63cb193a 100644 --- a/hidtest/test.c +++ b/hidtest/test.c @@ -19,13 +19,17 @@ #include #include #include +#include // for "tolower()" #include -// Headers needed for sleeping. +// Headers needed for sleeping and console management (wait for a keypress) #ifdef _WIN32 #include + #include #else + #include + #include #include #endif @@ -50,8 +54,46 @@ #if defined(USING_HIDAPI_LIBUSB) && HID_API_VERSION >= HID_API_MAKE_VERSION(0, 12, 0) #include #endif + +// +// A function that waits for a key to be pressed and reports it's code +// Used for immediate response in interactive subroutines +// Taken from: +// https://cboard.cprogramming.com/c-programming/63166-kbhit-linux.html +int waitkey(void) +{ +#ifdef _WIN32 + return _getch(); +#else + struct termios oldt, newt; + int ch; + int oldf; + + tcgetattr(STDIN_FILENO, &oldt); + newt = oldt; + newt.c_lflag &= ~(ICANON | ECHO); + tcsetattr(STDIN_FILENO, TCSANOW, &newt); + oldf = fcntl(STDIN_FILENO, F_GETFL, 0); + fcntl(STDIN_FILENO, F_SETFL, oldf | O_NONBLOCK); + + do + { + usleep(1); + ch = getchar(); + } + while (EOF == ch); + + tcsetattr(STDIN_FILENO, TCSANOW, &oldt); + fcntl(STDIN_FILENO, F_SETFL, oldf); + + return ch; +#endif +} + // +// +// Report Device info const char *hid_bus_name(hid_bus_type bus_type) { static const char *const HidBusTypeName[] = { "Unknown", @@ -130,58 +172,29 @@ void print_devices_with_descriptor(struct hid_device_info *cur_dev) { } } -int main(int argc, char* argv[]) +// +// Default static testing +void test_static(void) { - (void)argc; - (void)argv; + struct hid_device_info *devs; - /* --- HIDAPI R&D: this is just to force the compiler to ensure - each of those functions are implemented (even as a stub) - by each backend. --- */ - (void)&hid_open; - (void)&hid_open_path; - (void)&hid_read_timeout; - (void)&hid_get_input_report; -#if HID_API_VERSION >= HID_API_MAKE_VERSION(0, 15, 0) - (void)&hid_send_output_report; -#endif - (void)&hid_get_feature_report; - (void)&hid_send_feature_report; -#if HID_API_VERSION >= HID_API_MAKE_VERSION(0, 14, 0) - (void)&hid_get_report_descriptor; -#endif - /* --- */ + devs = hid_enumerate(0x0, 0x0); + print_devices_with_descriptor(devs); + hid_free_enumeration(devs); +} + +// +// Fixed device testing +void test_device(void) +{ int res; unsigned char buf[256]; - #define MAX_STR 255 +#define MAX_STR 255 wchar_t wstr[MAX_STR]; hid_device *handle; int i; - struct hid_device_info *devs; - - printf("hidapi test/example tool. Compiled with hidapi version %s, runtime version %s.\n", HID_API_VERSION_STR, hid_version_str()); - if (HID_API_VERSION == HID_API_MAKE_VERSION(hid_version()->major, hid_version()->minor, hid_version()->patch)) { - printf("Compile-time version matches runtime version of hidapi.\n\n"); - } - else { - printf("Compile-time version is different than runtime version of hidapi.\n]n"); - } - - if (hid_init()) - return -1; - -#if defined(__APPLE__) && HID_API_VERSION >= HID_API_MAKE_VERSION(0, 12, 0) - // To work properly needs to be called before hid_open/hid_open_path after hid_init. - // Best/recommended option - call it right after hid_init. - hid_darwin_set_open_exclusive(0); -#endif - - devs = hid_enumerate(0x0, 0x0); - print_devices_with_descriptor(devs); - hid_free_enumeration(devs); - // Set up the command buffer. memset(buf,0x00,sizeof(buf)); buf[0] = 0x01; @@ -194,8 +207,7 @@ int main(int argc, char* argv[]) handle = hid_open(0x4d8, 0x3f, NULL); if (!handle) { printf("unable to open device\n"); - hid_exit(); - return 1; + return; } #if defined(_WIN32) && HID_API_VERSION >= HID_API_MAKE_VERSION(0, 15, 0) @@ -336,13 +348,221 @@ int main(int argc, char* argv[]) } hid_close(handle); +} - /* Free static HIDAPI objects. */ - hid_exit(); +// +// Normal hotplug testing +int device_callback( + hid_hotplug_callback_handle callback_handle, + struct hid_device_info* device, + hid_hotplug_event event, + void* user_data) +{ + (void)user_data; -#ifdef _WIN32 - system("pause"); + if (event & HID_API_HOTPLUG_EVENT_DEVICE_ARRIVED) + printf("Handle %d: New device is connected: %s.\n", callback_handle, device->path); + else + printf("Handle %d: Device was disconnected: %s.\n", callback_handle, device->path); + + printf("type: %04hx %04hx\n serial_number: %ls", device->vendor_id, device->product_id, device->serial_number); + printf("\n"); + printf(" Manufacturer: %ls\n", device->manufacturer_string); + printf(" Product: %ls\n", device->product_string); + printf(" Release: %hx\n", device->release_number); + printf(" Interface: %d\n", device->interface_number); + printf(" Usage (page): 0x%hx (0x%hx)\n", device->usage, device->usage_page); + printf("(Press Q to exit the test)\n"); + printf("\n"); + + return 0; +} + + +void test_hotplug(void) +{ + printf("Starting the Hotplug test\n"); + printf("(Press Q to exit the test)\n"); + + hid_hotplug_callback_handle token1, token2; + + hid_hotplug_register_callback(0, 0, HID_API_HOTPLUG_EVENT_DEVICE_ARRIVED | HID_API_HOTPLUG_EVENT_DEVICE_LEFT, HID_API_HOTPLUG_ENUMERATE, device_callback, NULL, &token1); + hid_hotplug_register_callback(0x054c, 0x0ce6, HID_API_HOTPLUG_EVENT_DEVICE_ARRIVED | HID_API_HOTPLUG_EVENT_DEVICE_LEFT, HID_API_HOTPLUG_ENUMERATE, device_callback, NULL, &token2); + + while (1) + { + int command = tolower(waitkey()); + if ('q' == command) + { + break; + } + } + + hid_hotplug_deregister_callback(token2); + hid_hotplug_deregister_callback(token1); + + printf("\n\nHotplug test stopped\n"); +} + +// +// Stress-testing weird edge cases in hotplugs +int cb1_handle; +int cb2_handle; +int cb_test1_triggered; + +int cb2_func(hid_hotplug_callback_handle callback_handle, + struct hid_device_info *device, + hid_hotplug_event event, + void *user_data) +{ + (void) callback_handle; + (void) device; + (void) event; + (void) user_data; + // TIP: only perform the test once + if(cb_test1_triggered) + { + return 1; + } + + printf("Callback 2 fired\n"); + + // Deregister the first callback + // It should be placed in the list at an index prior to the current one, which will make the pointer to the current one invalid on some implementations + hid_hotplug_deregister_callback(cb1_handle); + + cb_test1_triggered = 1; + + // As long as we are inside this callback, nothing goes wrong; however, returning from here will cause a use-after-free error on flawed implementations + // as to retrieve the next element (or to check for it's presence) it will look those dereference a pointer located in an already freed area + // Undefined behavior + return 1; +} + +int cb1_func(hid_hotplug_callback_handle callback_handle, + struct hid_device_info *device, + hid_hotplug_event event, + void *user_data) +{ + (void) callback_handle; + (void) device; + (void) event; + (void) user_data; + + // TIP: only perform the test once + if(cb_test1_triggered) + { + return 1; + } + + printf("Callback 1 fired\n"); + + // Register the second callback and make it be called immediately by enumeration attempt + // Will cause a deadlock on Linux immediately + hid_hotplug_register_callback(0, 0, HID_API_HOTPLUG_EVENT_DEVICE_ARRIVED | HID_API_HOTPLUG_EVENT_DEVICE_LEFT, HID_API_HOTPLUG_ENUMERATE, cb2_func, NULL, &cb2_handle); + return 1; +} + +void test_hotplug_deadlocks(void) +{ + cb_test1_triggered = 0; + printf("Starting the Hotplug callbacks deadlocks test\n"); + printf("TIP: if you don't see a message that it succeeded, it means the test failed and the system is now deadlocked\n"); + // Register the first callback and make it be called immediately by enumeration attempt (if at least 1 device is present) + hid_hotplug_register_callback(0, 0, HID_API_HOTPLUG_EVENT_DEVICE_ARRIVED | HID_API_HOTPLUG_EVENT_DEVICE_LEFT, HID_API_HOTPLUG_ENUMERATE, cb1_func, NULL, &cb1_handle); + + printf("Test finished successfully (at least no deadlocks were found)\n"); + + // Intentionally leave a callback registered to test how hid_exit handles it + //hid_hotplug_deregister_callback(cb2_handle); +} + + +// +// CLI + +void print_version_check(void) +{ + printf("hidapi test/example tool. Compiled with hidapi version %s, runtime version %s.\n", HID_API_VERSION_STR, hid_version_str()); + if (HID_API_VERSION == HID_API_MAKE_VERSION(hid_version()->major, hid_version()->minor, hid_version()->patch)) { + printf("Compile-time version matches runtime version of hidapi.\n\n"); + } + else { + printf("Compile-time version is different than runtime version of hidapi.\n\n"); + } +} + +void interactive_loop(void) +{ + int command = 0; + + print_version_check(); + + do { + printf("Interactive HIDAPI testing utility\n"); + printf(" 1: List connected devices\n"); + printf(" 2: Dynamic hotplug test\n"); + printf(" 3: Test specific device [04d8:003f]\n"); + printf(" 4: Test hotplug callback management deadlocking scenario\n"); + printf(" Q: Quit\n"); + printf("Please enter command:"); + + /* Printed data might not show on the screen when the command is done - force it out */ + fflush(stdout); + + command = toupper(waitkey()); + + printf("%c\n\n========================================\n\n", command); + + // GET COMMAND + switch (command) { + case '1': + test_static(); + break; + case '2': + test_hotplug(); + break; + case '3': + test_device(); + break; + case '4': + test_hotplug_deadlocks(); + break; + case 'Q': + printf("Quitting.\n"); + return; + default: + printf("Command not recognized\n"); + break; + } + + /* Printed data might not show on the screen when the command is done - force it out */ + fflush(stdout); + + printf("\n\n========================================\n\n"); + } while(command != 'Q'); +} + +// +// Main +int main(int argc, char* argv[]) +{ + (void)argc; + (void)argv; + + if (hid_init()) + return -1; + +#if defined(__APPLE__) && HID_API_VERSION >= HID_API_MAKE_VERSION(0, 12, 0) + // To work properly needs to be called before hid_open/hid_open_path after hid_init. + // Best/recommended option - call it right after hid_init. + hid_darwin_set_open_exclusive(0); #endif + interactive_loop(); + + /* Free static HIDAPI objects. */ + hid_exit(); + return 0; } diff --git a/libusb/CMakeLists.txt b/libusb/CMakeLists.txt index 4c458c569..5b7e70a8b 100644 --- a/libusb/CMakeLists.txt +++ b/libusb/CMakeLists.txt @@ -85,7 +85,7 @@ endif() set_target_properties(hidapi_libusb PROPERTIES EXPORT_NAME "libusb" - OUTPUT_NAME "hidapi-libusb" + OUTPUT_NAME "hidapi-hotplug-libusb" VERSION ${PROJECT_VERSION} SOVERSION ${PROJECT_VERSION_MAJOR} PUBLIC_HEADER "${HIDAPI_PUBLIC_HEADERS}" @@ -97,11 +97,11 @@ add_library(hidapi::libusb ALIAS hidapi_libusb) add_library(hidapi-libusb ALIAS hidapi_libusb) if(HIDAPI_INSTALL_TARGETS) - install(TARGETS hidapi_libusb EXPORT hidapi + install(TARGETS hidapi_libusb EXPORT hidapi-hotplug LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}" ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}" - PUBLIC_HEADER DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/hidapi" + PUBLIC_HEADER DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/hidapi-hotplug" ) endif() -hidapi_configure_pc("${PROJECT_ROOT}/pc/hidapi-libusb.pc.in") +hidapi_configure_pc("${PROJECT_ROOT}/pc/hidapi-hotplug-libusb.pc.in") diff --git a/libusb/hid.c b/libusb/hid.c index d2ceef5d3..3575fadfa 100644 --- a/libusb/hid.c +++ b/libusb/hid.c @@ -55,6 +55,10 @@ #endif #include HIDAPI_THREAD_MODEL_INCLUDE +/* The value of the first callback handle to be given upon registration */ +/* Can be any arbitrary positive integer */ +#define FIRST_HOTPLUG_CALLBACK_HANDLE 1 + #ifdef __cplusplus extern "C" { #endif @@ -133,6 +137,48 @@ static struct hid_api_version api_version = { static libusb_context *usb_context = NULL; +struct hid_hotplug_queue { + libusb_device* device; + int event; /* Arrived or removed */ + struct hid_hotplug_queue* next; +}; + +static struct hid_hotplug_context { + /* A separate libusb context for hotplug events: helps avoid mutual blocking with read_thread's */ + libusb_context * context; + + /* libusb callback handle */ + libusb_hotplug_callback_handle callback_handle; + + /* HIDAPI unique callback handle counter */ + hid_hotplug_callback_handle next_handle; + + /* A thread that fills the event queue */ + hidapi_thread_state libusb_thread; + + /* A separate thread which processes hidapi's internal event queue */ + hidapi_thread_state callback_thread; + + /* This mutex prevents changes to the callback list */ + pthread_mutex_t mutex; + + /* Boolean flags */ + unsigned char mutex_ready; + unsigned char mutex_in_use; + unsigned char cb_list_dirty; + + struct hid_hotplug_queue* queue; + + /* Linked list of the hotplug callbacks */ + struct hid_hotplug_callback *hotplug_cbs; + + /* Linked list of the device infos (mandatory when the device is disconnected). + * Protected by `mutex`: all reads, writes and the final free during teardown + * are performed while holding it. The teardown free runs in + * hid_internal_hotplug_cleanup() after the hotplug threads have been joined. */ + struct hid_device_info *devs; +} hid_hotplug_context; /* zero-initialized (static storage); next_handle set on first init */ + uint16_t get_usb_code_for_current_locale(void); static int return_data(hid_device *dev, unsigned char *data, size_t length); @@ -483,6 +529,110 @@ HID_API_EXPORT const char* HID_API_CALL hid_version_str(void) return HID_API_VERSION_STR; } +struct hid_hotplug_callback +{ + unsigned short vendor_id; + unsigned short product_id; + hid_hotplug_callback_fn callback; + void* user_data; + int events; + struct hid_hotplug_callback* next; + + hid_hotplug_callback_handle handle; +}; + +static void hid_internal_hotplug_remove_postponed() +{ + /* Unregister the callbacks whose removal was postponed */ + /* This function is always called inside a locked mutex */ + /* However, any actions are only allowed if the mutex is NOT in use and if the DIRTY flag is set */ + if (!hid_hotplug_context.mutex_ready || hid_hotplug_context.mutex_in_use || !hid_hotplug_context.cb_list_dirty) { + return; + } + + /* Traverse the list of callbacks and check if any were marked for removal */ + struct hid_hotplug_callback **current = &hid_hotplug_context.hotplug_cbs; + while (*current) { + struct hid_hotplug_callback *callback = *current; + if (!callback->events) { + *current = (*current)->next; + free(callback); + continue; + } + current = &callback->next; + } + + /* Clear the flag so we don't start the cycle unless necessary */ + hid_hotplug_context.cb_list_dirty = 0; +} + +static void hid_internal_hotplug_cleanup() +{ + if (!hid_hotplug_context.mutex_ready || hid_hotplug_context.mutex_in_use) { + return; + } + + /* Before checking if the list is empty, clear any entries whose removal was postponed first */ + hid_internal_hotplug_remove_postponed(); + + if (hid_hotplug_context.hotplug_cbs != NULL) { + return; + } + + /* Wait for both threads to stop */ + hidapi_thread_join(&hid_hotplug_context.libusb_thread); + + /* Both hotplug threads have exited: we now have exclusive access to `devs` + * (the caller holds `mutex` and no hotplug event can reach process_hotplug_event). */ + hid_free_enumeration(hid_hotplug_context.devs); + hid_hotplug_context.devs = NULL; +} + +static void hid_internal_hotplug_init() +{ + if (!hid_hotplug_context.mutex_ready) { + hidapi_thread_state_init(&hid_hotplug_context.libusb_thread); + hidapi_thread_state_init(&hid_hotplug_context.callback_thread); + + /* Initialize the mutex as recursive */ + pthread_mutexattr_t attr; + pthread_mutexattr_init(&attr); + pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); + pthread_mutex_init(&hid_hotplug_context.mutex, &attr); + pthread_mutexattr_destroy(&attr); + + /* Set state to Ready */ + hid_hotplug_context.mutex_ready = 1; + hid_hotplug_context.mutex_in_use = 0; + hid_hotplug_context.cb_list_dirty = 0; + if (hid_hotplug_context.next_handle < FIRST_HOTPLUG_CALLBACK_HANDLE) + hid_hotplug_context.next_handle = FIRST_HOTPLUG_CALLBACK_HANDLE; + } +} + +static void hid_internal_hotplug_exit() +{ + if (!hid_hotplug_context.mutex_ready) { + return; + } + + pthread_mutex_lock(&hid_hotplug_context.mutex); + struct hid_hotplug_callback **current = &hid_hotplug_context.hotplug_cbs; + /* Remove all callbacks from the list */ + while (*current) { + struct hid_hotplug_callback* next = (*current)->next; + free(*current); + *current = next; + } + hid_internal_hotplug_cleanup(); + pthread_mutex_unlock(&hid_hotplug_context.mutex); + hid_hotplug_context.mutex_ready = 0; + pthread_mutex_destroy(&hid_hotplug_context.mutex); + + hidapi_thread_state_destroy(&hid_hotplug_context.callback_thread); + hidapi_thread_state_destroy(&hid_hotplug_context.libusb_thread); +} + int HID_API_EXPORT hid_init(void) { if (!usb_context) { @@ -506,11 +656,17 @@ int HID_API_EXPORT hid_exit(void) if (usb_context) { libusb_exit(usb_context); usb_context = NULL; + hid_internal_hotplug_exit(); } return 0; } +static int hid_internal_match_device_id(unsigned short vendor_id, unsigned short product_id, unsigned short expected_vendor_id, unsigned short expected_product_id) +{ + return (expected_vendor_id == 0x0 || vendor_id == expected_vendor_id) && (expected_product_id == 0x0 || product_id == expected_product_id); +} + static int hid_get_report_descriptor_libusb(libusb_device_handle *handle, int interface_num, uint16_t expected_report_descriptor_size, unsigned char *buf, size_t buf_size) { unsigned char tmp[HID_API_MAX_REPORT_DESCRIPTOR_SIZE]; @@ -787,112 +943,134 @@ static int should_enumerate_interface(unsigned short vendor_id, const struct lib return 0; } -struct hid_device_info HID_API_EXPORT *hid_enumerate(unsigned short vendor_id, unsigned short product_id) +static struct hid_device_info* hid_enumerate_from_libusb(libusb_device *dev, unsigned short vendor_id, unsigned short product_id) { - libusb_device **devs; - libusb_device *dev; - libusb_device_handle *handle = NULL; - ssize_t num_devs; - int i = 0; - struct hid_device_info *root = NULL; /* return object */ struct hid_device_info *cur_dev = NULL; + struct libusb_device_descriptor desc; + struct libusb_config_descriptor *conf_desc = NULL; + libusb_device_handle *handle = NULL; + int j, k; - if(hid_init() < 0) - return NULL; - - num_devs = libusb_get_device_list(usb_context, &devs); - if (num_devs < 0) + int res = libusb_get_device_descriptor(dev, &desc); + if (res < 0) return NULL; - while ((dev = devs[i++]) != NULL) { - struct libusb_device_descriptor desc; - struct libusb_config_descriptor *conf_desc = NULL; - int j, k; - int res = libusb_get_device_descriptor(dev, &desc); - if (res < 0) - continue; + unsigned short dev_vid = desc.idVendor; + unsigned short dev_pid = desc.idProduct; - unsigned short dev_vid = desc.idVendor; - unsigned short dev_pid = desc.idProduct; + if ((vendor_id != 0x0 && vendor_id != dev_vid) || + (product_id != 0x0 && product_id != dev_pid)) { + return NULL; + } - if ((vendor_id != 0x0 && vendor_id != dev_vid) || - (product_id != 0x0 && product_id != dev_pid)) { - continue; - } + res = libusb_get_active_config_descriptor(dev, &conf_desc); + if (res < 0) + libusb_get_config_descriptor(dev, 0, &conf_desc); + if (conf_desc) { + for (j = 0; j < conf_desc->bNumInterfaces; j++) { + const struct libusb_interface *intf = &conf_desc->interface[j]; + for (k = 0; k < intf->num_altsetting; k++) { + const struct libusb_interface_descriptor *intf_desc; + intf_desc = &intf->altsetting[k]; + if (should_enumerate_interface(dev_vid, intf_desc)) { + struct hid_device_info *tmp; - res = libusb_get_active_config_descriptor(dev, &conf_desc); - if (res < 0) - libusb_get_config_descriptor(dev, 0, &conf_desc); - if (conf_desc) { - for (j = 0; j < conf_desc->bNumInterfaces; j++) { - const struct libusb_interface *intf = &conf_desc->interface[j]; - for (k = 0; k < intf->num_altsetting; k++) { - const struct libusb_interface_descriptor *intf_desc; - intf_desc = &intf->altsetting[k]; - if (should_enumerate_interface(dev_vid, intf_desc)) { - struct hid_device_info *tmp; - - res = libusb_open(dev, &handle); + res = libusb_open(dev, &handle); #ifdef __ANDROID__ - if (handle) { - /* There is (a potential) libusb Android backend, in which - device descriptor is not accurate up until the device is opened. - https://github.com/libusb/libusb/pull/874#discussion_r632801373 - A workaround is to re-read the descriptor again. - Even if it is not going to be accepted into libusb master, - having it here won't do any harm, since reading the device descriptor - is as cheap as copy 18 bytes of data. */ - libusb_get_device_descriptor(dev, &desc); - } + if (handle) { + /* There is (a potential) libusb Android backend, in which + device descriptor is not accurate up until the device is opened. + https://github.com/libusb/libusb/pull/874#discussion_r632801373 + A workaround is to re-read the descriptor again. + Even if it is not going to be accepted into libusb master, + having it here won't do any harm, since reading the device descriptor + is as cheap as copy 18 bytes of data. */ + libusb_get_device_descriptor(dev, &desc); + } #endif - tmp = create_device_info_for_device(dev, handle, &desc, conf_desc->bConfigurationValue, intf_desc->bInterfaceNumber); - if (tmp) { + tmp = create_device_info_for_device(dev, handle, &desc, conf_desc->bConfigurationValue, intf_desc->bInterfaceNumber); + if (tmp) { #ifdef INVASIVE_GET_USAGE - /* TODO: have a runtime check for this section. */ - - /* - This section is removed because it is too - invasive on the system. Getting a Usage Page - and Usage requires parsing the HID Report - descriptor. Getting a HID Report descriptor - involves claiming the interface. Claiming the - interface involves detaching the kernel driver. - Detaching the kernel driver is hard on the system - because it will unclaim interfaces (if another - app has them claimed) and the re-attachment of - the driver will sometimes change /dev entry names. - It is for these reasons that this section is - optional. For composite devices, use the interface - field in the hid_device_info struct to distinguish - between interfaces. */ - if (handle) { - uint16_t report_descriptor_size = get_report_descriptor_size_from_interface_descriptors(intf_desc); - - invasive_fill_device_info_usage(tmp, handle, intf_desc->bInterfaceNumber, report_descriptor_size); - } -#endif /* INVASIVE_GET_USAGE */ + /* TODO: have a runtime check for this section. */ + + /* + This section is removed because it is too + invasive on the system. Getting a Usage Page + and Usage requires parsing the HID Report + descriptor. Getting a HID Report descriptor + involves claiming the interface. Claiming the + interface involves detaching the kernel driver. + Detaching the kernel driver is hard on the system + because it will unclaim interfaces (if another + app has them claimed) and the re-attachment of + the driver will sometimes change /dev entry names. + It is for these reasons that this section is + optional. For composite devices, use the interface + field in the hid_device_info struct to distinguish + between interfaces. */ + if (handle) { + uint16_t report_descriptor_size = get_report_descriptor_size_from_interface_descriptors(intf_desc); - if (cur_dev) { - cur_dev->next = tmp; - } - else { - root = tmp; - } - cur_dev = tmp; + invasive_fill_device_info_usage(tmp, handle, intf_desc->bInterfaceNumber, report_descriptor_size); } +#endif /* INVASIVE_GET_USAGE */ - if (res >= 0) { - libusb_close(handle); - handle = NULL; + if (cur_dev) { + cur_dev->next = tmp; + } + else { + root = tmp; } - break; + cur_dev = tmp; + } + + if (res >= 0) { + libusb_close(handle); + handle = NULL; } - } /* altsettings */ - } /* interfaces */ - libusb_free_config_descriptor(conf_desc); + break; + } + } /* altsettings */ + } /* interfaces */ + libusb_free_config_descriptor(conf_desc); + } + return root; +} + +struct hid_device_info HID_API_EXPORT *hid_enumerate(unsigned short vendor_id, unsigned short product_id) +{ + libusb_device **devs; + libusb_device *dev; + ssize_t num_devs; + int i = 0; + + struct hid_device_info *root = NULL; /* return object */ + struct hid_device_info *cur_dev = NULL; + + if (hid_init() < 0) + return NULL; + + num_devs = libusb_get_device_list(usb_context, &devs); + if (num_devs < 0) + return NULL; + + while ((dev = devs[i++]) != NULL) { + struct hid_device_info *tmp = hid_enumerate_from_libusb(dev, vendor_id, product_id); + if (cur_dev) { + cur_dev->next = tmp; + } + else { + root = tmp; + cur_dev = tmp; + } + /* Traverse to the end of newly attached tail */ + if (cur_dev) { + while (cur_dev->next) { + cur_dev = cur_dev->next; + } } } @@ -915,6 +1093,354 @@ void HID_API_EXPORT hid_free_enumeration(struct hid_device_info *devs) } } +static int match_libusb_to_info(libusb_device *device, struct hid_device_info* info) +{ + /* make a path from this libusb device, but leave the last 2 fields as 0 */ + char pseudo_path[64]; + get_path(&pseudo_path, device, 0, 0); + int len = strlen(pseudo_path) - sizeof("0.0"); + /* If the path on this HID device matches the template, aside from the last 2 fields, */ + /* we assume the HID device is located on this libusb device */ + return !strncmp(info->path, pseudo_path, len); +} + +static void hid_internal_invoke_callbacks(struct hid_device_info* info, hid_hotplug_event event) +{ + pthread_mutex_lock(&hid_hotplug_context.mutex); + hid_hotplug_context.mutex_in_use = 1; + + struct hid_hotplug_callback **current = &hid_hotplug_context.hotplug_cbs; + while (*current) { + struct hid_hotplug_callback *callback = *current; + if ((callback->events & event) && hid_internal_match_device_id(info->vendor_id, info->product_id, callback->vendor_id, callback->product_id)) { + int result = callback->callback(callback->handle, info, event, callback->user_data); + /* If the result is non-zero, we mark the callback for removal and proceed */ + if (result) { + (*current)->events = 0; + hid_hotplug_context.cb_list_dirty = 1; + continue; + } + } + current = &callback->next; + } + + hid_hotplug_context.mutex_in_use = 0; + hid_internal_hotplug_remove_postponed(); + pthread_mutex_unlock(&hid_hotplug_context.mutex); +} + +static int hid_libusb_hotplug_callback(libusb_context *ctx, libusb_device *device, libusb_hotplug_event event, void * user_data) +{ + (void)ctx; + (void)user_data; + + /* Make sure we HOLD the device until we are done with it - otherwise libusb would delete it the moment we exit this function */ + libusb_ref_device(device); + + struct hid_hotplug_queue* msg = (struct hid_hotplug_queue*) calloc(1, sizeof(struct hid_hotplug_queue)); + if (NULL == msg) { + libusb_unref_device(device); + return 0; + } + + msg->device = device; + msg->event = event; + msg->next = NULL; + + /* Use callback_thread's mutex to protect the queue and signal it */ + hidapi_thread_mutex_lock(&hid_hotplug_context.callback_thread); + struct hid_hotplug_queue* end = hid_hotplug_context.queue; + if (end) { + while (end->next) { + end = end->next; + } + end->next = msg; + } else { + hid_hotplug_context.queue = msg; + } + + /* Wake up the callback thread so it can react to the new message immediately */ + hidapi_thread_cond_signal(&hid_hotplug_context.callback_thread); + hidapi_thread_mutex_unlock(&hid_hotplug_context.callback_thread); + + return 0; +} + +static void process_hotplug_event(struct hid_hotplug_queue* msg) +{ + /* Lock the mutex to avoid race conditions with hid_hotplug_register_callback(), + * which may iterate devs during HID_API_HOTPLUG_ENUMERATE while holding this mutex. + * The mutex is recursive, so hid_internal_invoke_callbacks() can safely re-acquire it. */ + pthread_mutex_lock(&hid_hotplug_context.mutex); + + if (msg->event == LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED) { + struct hid_device_info* info = hid_enumerate_from_libusb(msg->device, 0, 0); + struct hid_device_info* info_cur = info; + while (info_cur) { + /* For each device, call all matching callbacks */ + /* TODO: possibly make the `next` field NULL to match the behavior on other systems */ + hid_internal_invoke_callbacks(info_cur, HID_API_HOTPLUG_EVENT_DEVICE_ARRIVED); + info_cur = info_cur->next; + } + + /* Append all we got to the end of the device list */ + if (info) { + if (hid_hotplug_context.devs != NULL) { + struct hid_device_info* last = hid_hotplug_context.devs; + while (last->next != NULL) { + last = last->next; + } + last->next = info; + } + else { + hid_hotplug_context.devs = info; + } + } + } + else if (msg->event == LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT) { + for (struct hid_device_info **current = &hid_hotplug_context.devs; *current;) { + struct hid_device_info* info = *current; + if (match_libusb_to_info(msg->device, *current)) { + /* If the libusb device that's left matches this HID device, we detach it from the list */ + *current = (*current)->next; + info->next = NULL; + hid_internal_invoke_callbacks(info, HID_API_HOTPLUG_EVENT_DEVICE_LEFT); + /* Free every removed device (and its internal allocations) */ + hid_free_enumeration(info); + } else { + current = &info->next; + } + } + } + + pthread_mutex_unlock(&hid_hotplug_context.mutex); + + /* Release the libusb device - we are done with it */ + libusb_unref_device(msg->device); + + /* Cleanup note: this function is called inside a thread that the clenup function would be waiting to finish */ + /* Any callbacks that await removal are removed in hid_internal_invoke_callbacks */ + /* No further cleaning is needed */ +} + +static void* callback_thread(void* user_data) +{ + (void) user_data; + + hidapi_thread_mutex_lock(&hid_hotplug_context.callback_thread); + + /* We stop the thread if by the moment there are no events left in the queue there are no callbacks left */ + while (1) { + /* Wait for events to arrive or shutdown signal */ + while (!hid_hotplug_context.queue && hid_hotplug_context.hotplug_cbs) { + hidapi_thread_cond_wait(&hid_hotplug_context.callback_thread); + } + + /* Process all pending events from the queue */ + while (hid_hotplug_context.queue) { + struct hid_hotplug_queue *cur_event = hid_hotplug_context.queue; + hid_hotplug_context.queue = cur_event->next; + + /* Release the lock while processing to avoid blocking event producers */ + hidapi_thread_mutex_unlock(&hid_hotplug_context.callback_thread); + process_hotplug_event(cur_event); + free(cur_event); + hidapi_thread_mutex_lock(&hid_hotplug_context.callback_thread); + } + + if (!hid_hotplug_context.hotplug_cbs) { + break; + } + } + + hidapi_thread_mutex_unlock(&hid_hotplug_context.callback_thread); + + return NULL; +} + +static void* hotplug_thread(void* user_data) +{ + (void) user_data; + + hidapi_thread_create(&hid_hotplug_context.callback_thread, callback_thread, NULL); + + /* 5 msec timeout seems reasonable; don't set too low to avoid high CPU usage */ + /* This timeout only affects how much time it takes to stop the thread */ + struct timeval tv; + tv.tv_sec = 0; + tv.tv_usec = 5000; + + while (hid_hotplug_context.hotplug_cbs) { + /* This will allow libusb to call the callbacks, which will fill up the queue */ + libusb_handle_events_timeout_completed(hid_hotplug_context.context, &tv, NULL); + } + + /* Disarm the libusb listener */ + libusb_hotplug_deregister_callback(hid_hotplug_context.context, hid_hotplug_context.callback_handle); + libusb_exit(hid_hotplug_context.context); + + /* hotplug_cbs is already NULL here (the loop above exited because of that). + * Signal callback_thread under the mutex so it can observe the NULL hotplug_cbs + * and exit cleanly, rather than waiting indefinitely in cond_wait. */ + hidapi_thread_mutex_lock(&hid_hotplug_context.callback_thread); + hidapi_thread_cond_signal(&hid_hotplug_context.callback_thread); + hidapi_thread_mutex_unlock(&hid_hotplug_context.callback_thread); + + hidapi_thread_join(&hid_hotplug_context.callback_thread); + + return NULL; +} + +int HID_API_EXPORT HID_API_CALL hid_hotplug_register_callback(unsigned short vendor_id, unsigned short product_id, int events, int flags, hid_hotplug_callback_fn callback, void *user_data, hid_hotplug_callback_handle *callback_handle) +{ + if (!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG)) { + return -1; + } + + /* Check params */ + if (events == 0 + || (events & ~(HID_API_HOTPLUG_EVENT_DEVICE_ARRIVED | HID_API_HOTPLUG_EVENT_DEVICE_LEFT)) + || (flags & ~(HID_API_HOTPLUG_ENUMERATE)) + || callback == NULL) { + return -1; + } + + struct hid_hotplug_callback* hotplug_cb = (struct hid_hotplug_callback*)calloc(1, sizeof(struct hid_hotplug_callback)); + + if (hotplug_cb == NULL) { + return -1; + } + + /* Fill out the record */ + hotplug_cb->next = NULL; + hotplug_cb->vendor_id = vendor_id; + hotplug_cb->product_id = product_id; + hotplug_cb->events = events; + hotplug_cb->user_data = user_data; + hotplug_cb->callback = callback; + + /* Ensure we are ready to actually use the mutex */ + hid_internal_hotplug_init(); + + /* Lock the mutex to avoid race itions */ + pthread_mutex_lock(&hid_hotplug_context.mutex); + + hotplug_cb->handle = hid_hotplug_context.next_handle++; + + /* handle the unlikely case of handle overflow */ + if (hid_hotplug_context.next_handle < 0) + { + hid_hotplug_context.next_handle = 1; + } + + /* Return allocated handle */ + if (callback_handle != NULL) { + *callback_handle = hotplug_cb->handle; + } + /* Append a new callback to the end */ + if (hid_hotplug_context.hotplug_cbs != NULL) { + struct hid_hotplug_callback *last = hid_hotplug_context.hotplug_cbs; + while (last->next != NULL) { + last = last->next; + } + last->next = hotplug_cb; + } + else { + /* Fill already connected devices so we can use this info in disconnection notification */ + if (libusb_init(&hid_hotplug_context.context)) { + free(hotplug_cb); + pthread_mutex_unlock(&hid_hotplug_context.mutex); + return -1; + } + + hid_hotplug_context.devs = hid_enumerate(0, 0); + hid_hotplug_context.hotplug_cbs = hotplug_cb; + + /* Arm a global callback to receive ALL notifications for HID class devices */ + if (libusb_hotplug_register_callback(hid_hotplug_context.context, + LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED | LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT, + 0, LIBUSB_HOTPLUG_MATCH_ANY, LIBUSB_HOTPLUG_MATCH_ANY, LIBUSB_HOTPLUG_MATCH_ANY, &hid_libusb_hotplug_callback, NULL, + &hid_hotplug_context.callback_handle)) { + /* Major malfunction, failed to register a callback. + * No hotplug thread was started, so we must unwind `devs` ourselves + * (hid_internal_hotplug_cleanup() would try to join a non-existent thread). */ + libusb_exit(hid_hotplug_context.context); + hid_free_enumeration(hid_hotplug_context.devs); + hid_hotplug_context.devs = NULL; + free(hotplug_cb); + hid_hotplug_context.hotplug_cbs = NULL; + pthread_mutex_unlock(&hid_hotplug_context.mutex); + return -1; + } + + /* Initialization succeeded! We run the threads now */ + hidapi_thread_create(&hid_hotplug_context.libusb_thread, hotplug_thread, NULL); + } + + /* Mark the mutex as IN USE, to prevent callback removal from inside a callback */ + unsigned char old_state = hid_hotplug_context.mutex_in_use; + hid_hotplug_context.mutex_in_use = 1; + + if ((flags & HID_API_HOTPLUG_ENUMERATE) && (events & HID_API_HOTPLUG_EVENT_DEVICE_ARRIVED)) { + struct hid_device_info* device = hid_hotplug_context.devs; + /* Notify about already connected devices, if asked so */ + while (device != NULL) { + if (hid_internal_match_device_id(device->vendor_id, device->product_id, hotplug_cb->vendor_id, hotplug_cb->product_id)) { + (*hotplug_cb->callback)(hotplug_cb->handle, device, HID_API_HOTPLUG_EVENT_DEVICE_ARRIVED, hotplug_cb->user_data); + } + + device = device->next; + } + } + + hid_hotplug_context.mutex_in_use = old_state; + + hid_internal_hotplug_cleanup(); + + pthread_mutex_unlock(&hid_hotplug_context.mutex); + + return 0; +} + +int HID_API_EXPORT HID_API_CALL hid_hotplug_deregister_callback(hid_hotplug_callback_handle callback_handle) +{ + if (!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG) || !hid_hotplug_context.mutex_ready || callback_handle <= 0) { + return -1; + } + + pthread_mutex_lock(&hid_hotplug_context.mutex); + + if (hid_hotplug_context.hotplug_cbs == NULL) { + pthread_mutex_unlock(&hid_hotplug_context.mutex); + return -1; + } + + int result = -1; + + /* Remove this notification */ + for (struct hid_hotplug_callback **current = &hid_hotplug_context.hotplug_cbs; *current != NULL; current = &(*current)->next) { + if ((*current)->handle == callback_handle) { + /* Check if we were already in a locked state, as we are NOT allowed to remove any callbacks if we are */ + if (hid_hotplug_context.mutex_in_use) { + (*current)->events = 0; + hid_hotplug_context.cb_list_dirty = 1; + } else { + struct hid_hotplug_callback *next = (*current)->next; + free(*current); + *current = next; + } + result = 0; + break; + } + } + + hid_internal_hotplug_cleanup(); + + pthread_mutex_unlock(&hid_hotplug_context.mutex); + + return result; +} + hid_device * hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number) { struct hid_device_info *devs, *cur_dev; @@ -1041,10 +1567,10 @@ static void *read_thread(void *param) /* Make the first submission. Further submissions are made from inside read_callback() */ res = libusb_submit_transfer(dev->transfer); - if(res < 0) { - LOG("libusb_submit_transfer failed: %d %s. Stopping read_thread from running\n", res, libusb_error_name(res)); - dev->shutdown_thread = 1; - dev->transfer_loop_finished = 1; + if (res < 0) { + LOG("libusb_submit_transfer failed: %d %s. Stopping read_thread from running\n", res, libusb_error_name(res)); + dev->shutdown_thread = 1; + dev->transfer_loop_finished = 1; } /* Notify the main thread that the read thread is up and running. */ @@ -1106,7 +1632,7 @@ static void init_xbox360(libusb_device_handle *device_handle, unsigned short idV /* The HORIPAD FPS for Nintendo Switch requires this to enable input reports. This VID/PID is also shared with other HORI controllers, but they all seem to be fine with this as well. - */ + */ memset(data, 0, sizeof(data)); libusb_control_transfer(device_handle, 0xC1, 0x01, 0x100, 0x0, data, sizeof(data), 100); } @@ -1132,7 +1658,7 @@ static void init_xboxone(libusb_device_handle *device_handle, unsigned short idV /* Newer Microsoft Xbox One controllers have a high speed alternate setting */ if (idVendor == vendor_microsoft && - intf_desc->bInterfaceNumber == 0 && intf_desc->bAlternateSetting == 1) { + intf_desc->bInterfaceNumber == 0 && intf_desc->bAlternateSetting == 1) { bSetAlternateSetting = 1; } else if (intf_desc->bInterfaceNumber != 0 && intf_desc->bAlternateSetting == 0) { bSetAlternateSetting = 1; @@ -1231,13 +1757,13 @@ static int hidapi_initialize_device(hid_device *dev, const struct libusb_interfa endpoint. */ int is_interrupt = (ep->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK) - == LIBUSB_TRANSFER_TYPE_INTERRUPT; + == LIBUSB_TRANSFER_TYPE_INTERRUPT; int is_output = (ep->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK) - == LIBUSB_ENDPOINT_OUT; + == LIBUSB_ENDPOINT_OUT; int is_input = (ep->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK) - == LIBUSB_ENDPOINT_IN; + == LIBUSB_ENDPOINT_IN; /* Decide whether to use it for input or output. */ if (dev->input_endpoint == 0 && @@ -1271,7 +1797,7 @@ hid_device * HID_API_EXPORT hid_open_path(const char *path) int d = 0; int good_open = 0; - if(hid_init() < 0) + if (hid_init() < 0) return NULL; dev = new_hid_device(); @@ -1346,7 +1872,7 @@ HID_API_EXPORT hid_device * HID_API_CALL hid_libusb_wrap_sys_device(intptr_t sys int res = 0; int j = 0, k = 0; - if(hid_init() < 0) + if (hid_init() < 0) return NULL; dev = new_hid_device(); diff --git a/linux/CMakeLists.txt b/linux/CMakeLists.txt index 9c627087f..7f38ab997 100644 --- a/linux/CMakeLists.txt +++ b/linux/CMakeLists.txt @@ -16,7 +16,7 @@ target_link_libraries(hidapi_hidraw PRIVATE PkgConfig::libudev Threads::Threads) set_target_properties(hidapi_hidraw PROPERTIES EXPORT_NAME "hidraw" - OUTPUT_NAME "hidapi-hidraw" + OUTPUT_NAME "hidapi-hotplug-hidraw" VERSION ${PROJECT_VERSION} SOVERSION ${PROJECT_VERSION_MAJOR} PUBLIC_HEADER "${HIDAPI_PUBLIC_HEADERS}" @@ -28,11 +28,11 @@ add_library(hidapi::hidraw ALIAS hidapi_hidraw) add_library(hidapi-hidraw ALIAS hidapi_hidraw) if(HIDAPI_INSTALL_TARGETS) - install(TARGETS hidapi_hidraw EXPORT hidapi + install(TARGETS hidapi_hidraw EXPORT hidapi-hotplug LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}" ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}" - PUBLIC_HEADER DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/hidapi" + PUBLIC_HEADER DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/hidapi-hotplug" ) endif() -hidapi_configure_pc("${PROJECT_ROOT}/pc/hidapi-hidraw.pc.in") +hidapi_configure_pc("${PROJECT_ROOT}/pc/hidapi-hotplug-hidraw.pc.in") diff --git a/linux/hid.c b/linux/hid.c index 148e48848..4ebf1e6eb 100644 --- a/linux/hid.c +++ b/linux/hid.c @@ -35,6 +35,7 @@ #include #include #include +#include /* Linux */ #include @@ -71,6 +72,10 @@ #define HIDIOCSOUTPUT(len) _IOC(_IOC_WRITE|_IOC_READ, 'H', 0x0B, len) #endif +/* The value of the first callback handle to be given upon registration */ +/* Can be any arbitrary positive integer */ +#define FIRST_HOTPLUG_CALLBACK_HANDLE 1 + struct hid_device_ { int device_handle; int blocking; @@ -683,6 +688,7 @@ static struct hid_device_info * create_device_info_for_device(struct udev_device case BUS_I2C: case BUS_USB: case BUS_SPI: + case BUS_VIRTUAL: break; default: @@ -779,6 +785,14 @@ static struct hid_device_info * create_device_info_for_device(struct udev_device break; + case BUS_VIRTUAL: + cur_dev->manufacturer_string = wcsdup(L""); + cur_dev->product_string = utf8_to_wchar_t(product_name_utf8); + + cur_dev->bus_type = HID_API_BUS_VIRTUAL; + + break; + default: /* Unknown device type - this should never happen, as we * check for USB and Bluetooth devices above */ @@ -896,6 +910,129 @@ HID_API_EXPORT const char* HID_API_CALL hid_version_str(void) return HID_API_VERSION_STR; } +static struct hid_hotplug_context { + /* UDEV context that handles the monitor */ + struct udev* udev_ctx; + + /* UDEV monitor that receives events */ + struct udev_monitor* mon; + + /* File descriptor for the UDEV monitor that allows to check for new events with select() */ + int monitor_fd; + + /* Thread for the UDEV monitor */ + pthread_t thread; + + pthread_mutex_t mutex; + + /* Boolean flags */ + unsigned char mutex_ready; + unsigned char mutex_in_use; + unsigned char cb_list_dirty; + + /* HIDAPI unique callback handle counter */ + hid_hotplug_callback_handle next_handle; + + /* Linked list of the hotplug callbacks */ + struct hid_hotplug_callback *hotplug_cbs; + + /* Linked list of the device infos (mandatory when the device is disconnected) */ + struct hid_device_info *devs; +} hid_hotplug_context; /* zero-initialized (static storage); next_handle/monitor_fd set on first init */ + +struct hid_hotplug_callback { + hid_hotplug_callback_handle handle; + unsigned short vendor_id; + unsigned short product_id; + int events; /* bitmask of hid_hotplug_event */ + void *user_data; + hid_hotplug_callback_fn callback; + + /* Pointer to the next notification */ + struct hid_hotplug_callback *next; +}; + +static void hid_internal_hotplug_remove_postponed() +{ + /* Unregister the callbacks whose removal was postponed */ + /* This function is always called inside a locked mutex */ + /* However, any actions are only allowed if the mutex is NOT in use and if the DIRTY flag is set */ + if (!hid_hotplug_context.mutex_ready || hid_hotplug_context.mutex_in_use || !hid_hotplug_context.cb_list_dirty) { + return; + } + + /* Traverse the list of callbacks and check if any were marked for removal */ + struct hid_hotplug_callback **current = &hid_hotplug_context.hotplug_cbs; + while (*current) { + struct hid_hotplug_callback *callback = *current; + if (!callback->events) { + *current = (*current)->next; + free(callback); + continue; + } + current = &callback->next; + } + + /* Clear the flag so we don't start the cycle unless necessary */ + hid_hotplug_context.cb_list_dirty = 0; +} + +static void hid_internal_hotplug_cleanup() +{ + if (!hid_hotplug_context.mutex_ready || hid_hotplug_context.mutex_in_use) { + return; + } + + /* Before checking if the list is empty, clear any entries whose removal was postponed first */ + hid_internal_hotplug_remove_postponed(); + + if (hid_hotplug_context.hotplug_cbs != NULL) { + return; + } + + pthread_join(hid_hotplug_context.thread, NULL); +} + +static void hid_internal_hotplug_init() +{ + if (!hid_hotplug_context.mutex_ready) { + /* Initialize the mutex as recursive */ + pthread_mutexattr_t attr; + pthread_mutexattr_init(&attr); + pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); + pthread_mutex_init(&hid_hotplug_context.mutex, &attr); + pthread_mutexattr_destroy(&attr); + + /* Set state to Ready */ + hid_hotplug_context.mutex_ready = 1; + hid_hotplug_context.mutex_in_use = 0; + hid_hotplug_context.cb_list_dirty = 0; + hid_hotplug_context.monitor_fd = -1; + if (hid_hotplug_context.next_handle < FIRST_HOTPLUG_CALLBACK_HANDLE) + hid_hotplug_context.next_handle = FIRST_HOTPLUG_CALLBACK_HANDLE; + } +} + +static void hid_internal_hotplug_exit() +{ + if (!hid_hotplug_context.mutex_ready) { + return; + } + + pthread_mutex_lock(&hid_hotplug_context.mutex); + struct hid_hotplug_callback **current = &hid_hotplug_context.hotplug_cbs; + /* Remove all callbacks from the list */ + while (*current) { + struct hid_hotplug_callback* next = (*current)->next; + free(*current); + *current = next; + } + hid_internal_hotplug_cleanup(); + pthread_mutex_unlock(&hid_hotplug_context.mutex); + hid_hotplug_context.mutex_ready = 0; + pthread_mutex_destroy(&hid_hotplug_context.mutex); +} + int HID_API_EXPORT hid_init(void) { const char *locale; @@ -911,14 +1048,22 @@ int HID_API_EXPORT hid_init(void) return 0; } + int HID_API_EXPORT hid_exit(void) { /* Free global error message */ register_global_error(NULL); + hid_internal_hotplug_exit(); + return 0; } +static int hid_internal_match_device_id(unsigned short vendor_id, unsigned short product_id, unsigned short expected_vendor_id, unsigned short expected_product_id) +{ + return (expected_vendor_id == 0x0 || vendor_id == expected_vendor_id) && (expected_product_id == 0x0 || product_id == expected_product_id); +} + struct hid_device_info HID_API_EXPORT *hid_enumerate(unsigned short vendor_id, unsigned short product_id) { struct udev *udev; @@ -1020,6 +1165,276 @@ void HID_API_EXPORT hid_free_enumeration(struct hid_device_info *devs) } } +static void hid_internal_invoke_callbacks(struct hid_device_info *info, hid_hotplug_event event) +{ + pthread_mutex_lock(&hid_hotplug_context.mutex); + hid_hotplug_context.mutex_in_use = 1; + + struct hid_hotplug_callback **current = &hid_hotplug_context.hotplug_cbs; + while (*current) { + struct hid_hotplug_callback *callback = *current; + if ((callback->events & event) && hid_internal_match_device_id(info->vendor_id, info->product_id, + callback->vendor_id, callback->product_id)) { + int result = callback->callback(callback->handle, info, event, callback->user_data); + /* If the result is non-zero, we mark the callback for removal and proceed */ + if (result) { + (*current)->events = 0; + hid_hotplug_context.cb_list_dirty = 1; + continue; + } + } + current = &callback->next; + } + + hid_hotplug_context.mutex_in_use = 0; + hid_internal_hotplug_remove_postponed(); + pthread_mutex_unlock(&hid_hotplug_context.mutex); +} + +static int match_udev_to_info(struct udev_device* raw_dev, struct hid_device_info *info) +{ + const char *path = udev_device_get_devnode(raw_dev); + if (!strcmp(path, info->path)) { + return 1; + } + return 0; +} + +static void* hotplug_thread(void* user_data) +{ + (void) user_data; + + /* Note: the cleanup sequence is always executed with the mutex locked, so we shoud never lock the mutex without checking if we need to stop */ + + while (hid_hotplug_context.monitor_fd > 0) { + fd_set fds; + struct timeval tv; + int ret; + + /* On every iteration, check if we still have any callbacks left and leave if none are left */ + /* NOTE: the check is performed UNLOCKED and the value CAN change in the background */ + if (!hid_hotplug_context.hotplug_cbs) { + break; + } + + FD_ZERO(&fds); + FD_SET(hid_hotplug_context.monitor_fd, &fds); + /* 5 msec timeout seems reasonable; don't set too low to avoid high CPU usage */ + /* This timeout only affects how much time it takes to stop the thread */ + tv.tv_sec = 0; + tv.tv_usec = 5000; + + ret = select(hid_hotplug_context.monitor_fd+1, &fds, NULL, NULL, &tv); + + /* An extra check, just in case within those 5msec the thread was told to stop */ + if (!hid_hotplug_context.hotplug_cbs) { + break; + } + + /* Check if our file descriptor has received data. */ + if (ret > 0 && FD_ISSET(hid_hotplug_context.monitor_fd, &fds)) { + + /* Make the call to receive the device. + select() ensured that this will not block. */ + struct udev_device *raw_dev = udev_monitor_receive_device(hid_hotplug_context.mon); + if (raw_dev) { + pthread_mutex_lock(&hid_hotplug_context.mutex); + const char* action = udev_device_get_action(raw_dev); + if (!strcmp(action, "add")) { + // We create a list of all usages on this UDEV device + struct hid_device_info *info = create_device_info_for_device(raw_dev); + struct hid_device_info *info_cur = info; + while (info_cur) { + /* For each device, call all matching callbacks */ + /* TODO: possibly make the `next` field NULL to match the behavior on other systems */ + hid_internal_invoke_callbacks(info_cur, HID_API_HOTPLUG_EVENT_DEVICE_ARRIVED); + info_cur = info_cur->next; + } + + /* Append all we got to the end of the device list */ + if (info) { + if (hid_hotplug_context.devs != NULL) { + struct hid_device_info *last = hid_hotplug_context.devs; + while (last->next != NULL) { + last = last->next; + } + last->next = info; + } else { + hid_hotplug_context.devs = info; + } + } + } else if (!strcmp(action, "remove")) { + for (struct hid_device_info **current = &hid_hotplug_context.devs; *current;) { + struct hid_device_info* info = *current; + if (match_udev_to_info(raw_dev, *current)) { + /* If the libusb device that's left matches this HID device, we detach it from the list */ + *current = (*current)->next; + info->next = NULL; + hid_internal_invoke_callbacks(info, HID_API_HOTPLUG_EVENT_DEVICE_LEFT); + /* Free every removed device */ + hid_free_enumeration(info); + } else { + current = &info->next; + } + } + } + udev_device_unref(raw_dev); + pthread_mutex_unlock(&hid_hotplug_context.mutex); + } + } + } + + /* Cleanup connected device list */ + hid_free_enumeration(hid_hotplug_context.devs); + hid_hotplug_context.devs = NULL; + /* Disarm the udev monitor */ + udev_monitor_unref(hid_hotplug_context.mon); + udev_unref(hid_hotplug_context.udev_ctx); + + return NULL; +} + +int HID_API_EXPORT HID_API_CALL hid_hotplug_register_callback(unsigned short vendor_id, unsigned short product_id, int events, int flags, hid_hotplug_callback_fn callback, void *user_data, hid_hotplug_callback_handle *callback_handle) +{ + struct hid_hotplug_callback* hotplug_cb; + + /* Check params */ + if (events == 0 + || (events & ~(HID_API_HOTPLUG_EVENT_DEVICE_ARRIVED | HID_API_HOTPLUG_EVENT_DEVICE_LEFT)) + || (flags & ~(HID_API_HOTPLUG_ENUMERATE)) + || callback == NULL) { + return -1; + } + + hotplug_cb = (struct hid_hotplug_callback*)calloc(1, sizeof(struct hid_hotplug_callback)); + + if (hotplug_cb == NULL) { + return -1; + } + + /* Fill out the record */ + hotplug_cb->next = NULL; + hotplug_cb->vendor_id = vendor_id; + hotplug_cb->product_id = product_id; + hotplug_cb->events = events; + hotplug_cb->user_data = user_data; + hotplug_cb->callback = callback; + + /* Ensure we are ready to actually use the mutex */ + hid_internal_hotplug_init(); + + /* Lock the mutex to avoid race conditions */ + pthread_mutex_lock(&hid_hotplug_context.mutex); + + hotplug_cb->handle = hid_hotplug_context.next_handle++; + + /* handle the unlikely case of handle overflow */ + if (hid_hotplug_context.next_handle < 0) + { + hid_hotplug_context.next_handle = 1; + } + + /* Return allocated handle */ + if (callback_handle != NULL) { + *callback_handle = hotplug_cb->handle; + } + + /* Append a new callback to the end */ + if (hid_hotplug_context.hotplug_cbs != NULL) { + struct hid_hotplug_callback *last = hid_hotplug_context.hotplug_cbs; + while (last->next != NULL) { + last = last->next; + } + last->next = hotplug_cb; + } + else { + // Prepare a UDEV context to run monitoring on + hid_hotplug_context.udev_ctx = udev_new(); + if (!hid_hotplug_context.udev_ctx) + { + pthread_mutex_unlock(&hid_hotplug_context.mutex); + return -1; + } + + hid_hotplug_context.mon = udev_monitor_new_from_netlink(hid_hotplug_context.udev_ctx, "udev"); + udev_monitor_filter_add_match_subsystem_devtype(hid_hotplug_context.mon, "hidraw", NULL); + udev_monitor_enable_receiving(hid_hotplug_context.mon); + hid_hotplug_context.monitor_fd = udev_monitor_get_fd(hid_hotplug_context.mon); + + /* After monitoring is all set up, enumerate all devices */ + hid_hotplug_context.devs = hid_enumerate(0, 0); + + /* Don't forget to actually register the callback */ + hid_hotplug_context.hotplug_cbs = hotplug_cb; + + /* Start the thread that will be doing the event scanning */ + pthread_create(&hid_hotplug_context.thread, NULL, &hotplug_thread, NULL); + } + + /* Mark the mutex as IN USE, to prevent callback removal from inside a callback */ + unsigned char old_state = hid_hotplug_context.mutex_in_use; + hid_hotplug_context.mutex_in_use = 1; + + if ((flags & HID_API_HOTPLUG_ENUMERATE) && (events & HID_API_HOTPLUG_EVENT_DEVICE_ARRIVED)) { + struct hid_device_info* device = hid_hotplug_context.devs; + /* Notify about already connected devices, if asked so */ + while (device != NULL) { + if (hid_internal_match_device_id(device->vendor_id, device->product_id, hotplug_cb->vendor_id, hotplug_cb->product_id)) { + (*hotplug_cb->callback)(hotplug_cb->handle, device, HID_API_HOTPLUG_EVENT_DEVICE_ARRIVED, hotplug_cb->user_data); + } + + device = device->next; + } + } + + hid_hotplug_context.mutex_in_use = old_state; + + hid_internal_hotplug_cleanup(); + + pthread_mutex_unlock(&hid_hotplug_context.mutex); + + return 0; +} + +int HID_API_EXPORT HID_API_CALL hid_hotplug_deregister_callback(hid_hotplug_callback_handle callback_handle) +{ + if (!hid_hotplug_context.mutex_ready || callback_handle <= 0) { + return -1; + } + + pthread_mutex_lock(&hid_hotplug_context.mutex); + + if (hid_hotplug_context.hotplug_cbs == NULL) { + pthread_mutex_unlock(&hid_hotplug_context.mutex); + return -1; + } + + int result = -1; + + /* Remove this notification */ + for (struct hid_hotplug_callback **current = &hid_hotplug_context.hotplug_cbs; *current != NULL; current = &(*current)->next) { + if ((*current)->handle == callback_handle) { + /* Check if we were already in a locked state, as we are NOT allowed to remove any callbacks if we are */ + if (hid_hotplug_context.mutex_in_use) { + (*current)->events = 0; + hid_hotplug_context.cb_list_dirty = 1; + } else { + struct hid_hotplug_callback *next = (*current)->next; + free(*current); + *current = next; + } + result = 0; + break; + } + } + + hid_internal_hotplug_cleanup(); + + pthread_mutex_unlock(&hid_hotplug_context.mutex); + + return result; +} + hid_device * hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number) { struct hid_device_info *devs, *cur_dev; @@ -1200,7 +1615,6 @@ int HID_API_EXPORT hid_set_nonblocking(hid_device *dev, int nonblock) return 0; /* Success */ } - int HID_API_EXPORT hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length) { int res; diff --git a/mac/CMakeLists.txt b/mac/CMakeLists.txt index 1ff862bd7..b82349b3d 100644 --- a/mac/CMakeLists.txt +++ b/mac/CMakeLists.txt @@ -18,7 +18,7 @@ target_link_libraries(hidapi_darwin set_target_properties(hidapi_darwin PROPERTIES EXPORT_NAME "darwin" - OUTPUT_NAME "hidapi" + OUTPUT_NAME "hidapi-hotplug" VERSION ${PROJECT_VERSION} SOVERSION ${PROJECT_VERSION_MAJOR} FRAMEWORK_VERSION ${PROJECT_VERSION_MAJOR} @@ -49,11 +49,11 @@ add_library(hidapi ALIAS hidapi_darwin) set(PUBLIC_HEADER_DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}") if(NOT CMAKE_FRAMEWORK) - set(PUBLIC_HEADER_DESTINATION "${PUBLIC_HEADER_DESTINATION}/hidapi") + set(PUBLIC_HEADER_DESTINATION "${PUBLIC_HEADER_DESTINATION}/hidapi-hotplug") endif() if(HIDAPI_INSTALL_TARGETS) - install(TARGETS hidapi_darwin EXPORT hidapi + install(TARGETS hidapi_darwin EXPORT hidapi-hotplug LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}" ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}" FRAMEWORK DESTINATION "${CMAKE_INSTALL_LIBDIR}" @@ -61,4 +61,4 @@ if(HIDAPI_INSTALL_TARGETS) ) endif() -hidapi_configure_pc("${PROJECT_ROOT}/pc/hidapi.pc.in") +hidapi_configure_pc("${PROJECT_ROOT}/pc/hidapi-hotplug.pc.in") diff --git a/mac/hid.c b/mac/hid.c index a91bc1902..36da881af 100644 --- a/mac/hid.c +++ b/mac/hid.c @@ -38,6 +38,10 @@ #include "hidapi_darwin.h" +/* The value of the first callback handle to be given upon registration */ +/* Can be any arbitrary positive integer */ +#define FIRST_HOTPLUG_CALLBACK_HANDLE 1 + /* Barrier implementation because Mac OSX doesn't have pthread_barrier. It also doesn't have clock_gettime(). So much for POSIX and SUSv2. This implementation came from Brent Priddy and was posted on @@ -461,6 +465,147 @@ HID_API_EXPORT const char* HID_API_CALL hid_version_str(void) return HID_API_VERSION_STR; } +struct hid_hotplug_callback { + hid_hotplug_callback_handle handle; + unsigned short vendor_id; + unsigned short product_id; + int events; /* bitmask of hid_hotplug_event */ + void *user_data; + hid_hotplug_callback_fn callback; + + /* Pointer to the next notification */ + struct hid_hotplug_callback *next; +}; + +/* When a HID device is removed, we are no longer able to generate a path for it, but we can still match io_service_t */ +struct hid_device_info_ex +{ + struct hid_device_info info; + io_service_t service; +}; + +static struct hid_hotplug_context { + /* MacOS specific notification handles */ + IOHIDManagerRef manager; + + /* Thread and RunLoop for the manager to work in */ + pthread_t thread; + CFRunLoopRef run_loop; + CFRunLoopSourceRef source; + CFStringRef run_loop_mode; + pthread_barrier_t startup_barrier; /* Ensures correct startup sequence */ + int thread_state; /* 0 = starting (events ignored), 1 = running (events processed), 2 = shutting down */ + + /* HIDAPI unique callback handle counter */ + hid_hotplug_callback_handle next_handle; + + pthread_mutex_t mutex; + + /* Boolean flags */ + unsigned char mutex_ready; + unsigned char mutex_in_use; + unsigned char cb_list_dirty; + + /* Linked list of the hotplug callbacks */ + struct hid_hotplug_callback *hotplug_cbs; + + /* Linked list of the device infos (mandatory when the device is disconnected) */ + struct hid_device_info *devs; +} hid_hotplug_context; /* zero-initialized (static storage); next_handle set on first init */ + +static void hid_internal_hotplug_remove_postponed(void) +{ + /* Unregister the callbacks whose removal was postponed */ + /* This function is always called inside a locked mutex */ + /* However, any actions are only allowed if the mutex is NOT in use and if the DIRTY flag is set */ + if (!hid_hotplug_context.mutex_ready || hid_hotplug_context.mutex_in_use || !hid_hotplug_context.cb_list_dirty) { + return; + } + + /* Traverse the list of callbacks and check if any were marked for removal */ + struct hid_hotplug_callback **current = &hid_hotplug_context.hotplug_cbs; + while (*current) { + struct hid_hotplug_callback *callback = *current; + if (!callback->events) { + *current = (*current)->next; + free(callback); + continue; + } + current = &callback->next; + } + + /* Clear the flag so we don't start the cycle unless necessary */ + hid_hotplug_context.cb_list_dirty = 0; +} + +static void hid_internal_hotplug_cleanup(void) +{ + if (!hid_hotplug_context.mutex_ready || hid_hotplug_context.mutex_in_use) { + return; + } + + /* Before checking if the list is empty, clear any entries whose removal was postponed first */ + hid_internal_hotplug_remove_postponed(); + + if (hid_hotplug_context.hotplug_cbs != NULL) { + return; + } + + /* Cleanup connected device list */ + hid_free_enumeration(hid_hotplug_context.devs); + hid_hotplug_context.devs = NULL; + + /* Cause hotplug_thread() to stop. */ + hid_hotplug_context.thread_state = 2; + + /* Wake up the run thread's event loop so that the thread can exit. */ + CFRunLoopSourceSignal(hid_hotplug_context.source); + CFRunLoopWakeUp(hid_hotplug_context.run_loop); + + /* Wait for read_thread() to end. */ + pthread_join(hid_hotplug_context.thread, NULL); +} + +static void hid_internal_hotplug_init(void) +{ + if (!hid_hotplug_context.mutex_ready) { + /* Initialize the mutex as recursive */ + pthread_mutexattr_t attr; + pthread_mutexattr_init(&attr); + pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); + pthread_mutex_init(&hid_hotplug_context.mutex, &attr); + pthread_mutexattr_destroy(&attr); + + /* Set state to Ready */ + hid_hotplug_context.mutex_ready = 1; + hid_hotplug_context.mutex_in_use = 0; + hid_hotplug_context.cb_list_dirty = 0; + if (hid_hotplug_context.next_handle < FIRST_HOTPLUG_CALLBACK_HANDLE) + hid_hotplug_context.next_handle = FIRST_HOTPLUG_CALLBACK_HANDLE; + } +} + +static void hid_internal_hotplug_exit(void) +{ + if (!hid_hotplug_context.mutex_ready) { + return; + } + + pthread_mutex_lock(&hid_hotplug_context.mutex); + struct hid_hotplug_callback** current = &hid_hotplug_context.hotplug_cbs; + + /* Remove all callbacks from the list */ + while (*current) { + struct hid_hotplug_callback* next = (*current)->next; + free(*current); + *current = next; + } + hid_internal_hotplug_cleanup(); + pthread_mutex_unlock(&hid_hotplug_context.mutex); + hid_hotplug_context.mutex_ready = 0; + pthread_mutex_destroy(&hid_hotplug_context.mutex); +} + /* Initialize the IOHIDManager if necessary. This is the public function, and it is safe to call this function repeatedly. Return 0 for success and -1 for failure. */ @@ -471,9 +616,9 @@ int HID_API_EXPORT hid_init(void) if (!hid_mgr) { is_macos_10_10_or_greater = (kCFCoreFoundationVersionNumber >= 1151.16); /* kCFCoreFoundationVersionNumber10_10 */ hid_darwin_set_open_exclusive(1); /* Backward compatibility */ + return init_hid_manager(); } - /* Already initialized. */ return 0; } @@ -485,6 +630,7 @@ int HID_API_EXPORT hid_exit(void) IOHIDManagerClose(hid_mgr, kIOHIDOptionsTypeNone); CFRelease(hid_mgr); hid_mgr = NULL; + hid_internal_hotplug_exit(); } /* Free global error message */ @@ -493,11 +639,17 @@ int HID_API_EXPORT hid_exit(void) return 0; } -static void process_pending_events(void) { +static int hid_internal_match_device_id(unsigned short vendor_id, unsigned short product_id, unsigned short expected_vendor_id, unsigned short expected_product_id) +{ + return (expected_vendor_id == 0x0 || vendor_id == expected_vendor_id) && (expected_product_id == 0x0 || product_id == expected_product_id); +} + +static void process_pending_events(void) +{ SInt32 res; do { res = CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.001, FALSE); - } while(res != kCFRunLoopRunFinished && res != kCFRunLoopRunTimedOut); + } while (res != kCFRunLoopRunFinished && res != kCFRunLoopRunTimedOut); } static int read_usb_interface_from_hid_service_parent(io_service_t hid_service) @@ -548,6 +700,7 @@ static struct hid_device_info *create_device_info_with_usage(IOHIDDeviceRef dev, wchar_t buf[BUF_LEN]; CFTypeRef transport_prop; + struct hid_device_info_ex *cur_dev_ex; struct hid_device_info *cur_dev; io_service_t hid_service; kern_return_t res; @@ -557,10 +710,12 @@ static struct hid_device_info *create_device_info_with_usage(IOHIDDeviceRef dev, return NULL; } - cur_dev = (struct hid_device_info *)calloc(1, sizeof(struct hid_device_info)); - if (cur_dev == NULL) { + /* A small trick to store an io_service_t tag along with hid_device_info for matching info with unplugged device */ + cur_dev_ex = (struct hid_device_info_ex *)calloc(1, sizeof(struct hid_device_info_ex)); + if (cur_dev_ex == NULL) { return NULL; } + cur_dev = &(cur_dev_ex->info); dev_vid = get_vendor_id(dev); dev_pid = get_product_id(dev); @@ -576,6 +731,7 @@ static struct hid_device_info *create_device_info_with_usage(IOHIDDeviceRef dev, hid_service = IOHIDDeviceGetService(dev); if (hid_service != MACH_PORT_NULL) { res = IORegistryEntryGetRegistryEntryID(hid_service, &entry_id); + cur_dev_ex->service = hid_service; } else { res = KERN_INVALID_ARGUMENT; @@ -808,6 +964,331 @@ void HID_API_EXPORT hid_free_enumeration(struct hid_device_info *devs) } } +static void hid_internal_invoke_callbacks(struct hid_device_info *info, hid_hotplug_event event) +{ + pthread_mutex_lock(&hid_hotplug_context.mutex); + hid_hotplug_context.mutex_in_use = 1; + + struct hid_hotplug_callback **current = &hid_hotplug_context.hotplug_cbs; + while (*current) { + struct hid_hotplug_callback *callback = *current; + if ((callback->events & event) && hid_internal_match_device_id(info->vendor_id, info->product_id, + callback->vendor_id, callback->product_id)) { + int result = callback->callback(callback->handle, info, event, callback->user_data); + /* If the result is non-zero, we mark the callback for removal and proceed */ + /* Do not use the deregister call as it locks the mutex, and we are currently in a lock */ + if (result) { + (*current)->events = 0; + hid_hotplug_context.cb_list_dirty = 1; + continue; + } + } + current = &callback->next; + } + + hid_hotplug_context.mutex_in_use = 0; + hid_internal_hotplug_remove_postponed(); + pthread_mutex_unlock(&hid_hotplug_context.mutex); +} + +static void hid_internal_hotplug_connect_callback(void *context, IOReturn result, void *sender, IOHIDDeviceRef device) +{ + (void) context; + (void) result; + (void) sender; + + struct hid_device_info* info = create_device_info(device); + if (!info) { + return; + } + struct hid_device_info* info_cur = info; + + /* NOTE: we don't call any callbacks and we don't lock the mutex during initialization: the mutex is held by the main thread, but it's waiting by a barrier */ + if (hid_hotplug_context.thread_state > 0) + { + /* Lock the mutex to avoid race conditions */ + pthread_mutex_lock(&hid_hotplug_context.mutex); + + /* Invoke all callbacks */ + while (info_cur) + { + hid_internal_invoke_callbacks(info_cur, HID_API_HOTPLUG_EVENT_DEVICE_ARRIVED); + info_cur = info_cur->next; + } + } + + /* Append all we got to the end of the device list */ + if (info) { + if (hid_hotplug_context.devs != NULL) { + struct hid_device_info* last = hid_hotplug_context.devs; + while (last->next != NULL) { + last = last->next; + } + last->next = info; + } + else { + hid_hotplug_context.devs = info; + } + } + + if (hid_hotplug_context.thread_state > 0) + { + pthread_mutex_unlock(&hid_hotplug_context.mutex); + } +} + +static int match_ref_to_info(IOHIDDeviceRef device, struct hid_device_info *info) +{ + if (!device || !info) { + return 0; + } + + struct hid_device_info_ex* ex = (struct hid_device_info_ex*)info; + io_service_t service = IOHIDDeviceGetService(device); + + return (service == ex->service); +} + +static void hid_internal_hotplug_disconnect_callback(void *context, IOReturn result, void *sender, IOHIDDeviceRef device) +{ + (void) context; + (void) result; + (void) sender; + + /* NOTE: we don't call any callbacks and we don't lock the mutex during initialization: the mutex is held by the main thread, but it's waiting by a barrier*/ + if (hid_hotplug_context.thread_state > 0) + { + pthread_mutex_lock(&hid_hotplug_context.mutex); + } + + for (struct hid_device_info **current = &hid_hotplug_context.devs; *current;) { + struct hid_device_info* info = *current; + if (match_ref_to_info(device, *current)) { + /* If the IOHIDDeviceRef device that's left matches this HID device, we detach it from the list */ + *current = (*current)->next; + info->next = NULL; + hid_internal_invoke_callbacks(info, HID_API_HOTPLUG_EVENT_DEVICE_LEFT); + /* Free every removed device */ + hid_free_enumeration(info); + } else { + current = &info->next; + } + } + + if (hid_hotplug_context.thread_state > 0) + { + /* Clean up if the last callback was removed */ + hid_internal_hotplug_cleanup(); + pthread_mutex_unlock(&hid_hotplug_context.mutex); + } +} + +static void hotplug_stop_callback(void* context) +{ + (void) context; + CFRunLoopStop(hid_hotplug_context.run_loop); +} + +static void* hotplug_thread(void* user_data) +{ + (void) user_data; + + hid_hotplug_context.thread_state = 0; + hid_hotplug_context.manager = IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone); + + if (!hid_hotplug_context.run_loop_mode) { + const char *str = "HIDAPI_hotplug"; + hid_hotplug_context.run_loop_mode = CFStringCreateWithCString(NULL, str, kCFStringEncodingASCII); + } + + /* Ensure the manager runs in this thread */ + IOHIDManagerScheduleWithRunLoop(hid_hotplug_context.manager, CFRunLoopGetCurrent(), hid_hotplug_context.run_loop_mode); + /* Store a reference to this runloop if we ever need to stop it - e.g. if we have no callbacks left or hid_exit was called */ + hid_hotplug_context.run_loop = CFRunLoopGetCurrent(); + + /* Create the RunLoopSource which is used to signal the + event loop to stop when hid_internal_hotplug_cleanup() is called. */ + CFRunLoopSourceContext ctx; + memset(&ctx, 0, sizeof(ctx)); + ctx.version = 0; + ctx.perform = &hotplug_stop_callback; + hid_hotplug_context.source = CFRunLoopSourceCreate(kCFAllocatorDefault, 0/*order*/, &ctx); + CFRunLoopAddSource(hid_hotplug_context.run_loop, hid_hotplug_context.source, hid_hotplug_context.run_loop_mode); + + /* Set the manager to receive events for ALL HID devices */ + IOHIDManagerSetDeviceMatching(hid_hotplug_context.manager, NULL); + + /* Install callbacks */ + IOHIDManagerRegisterDeviceMatchingCallback(hid_hotplug_context.manager, + hid_internal_hotplug_connect_callback, + NULL); + + IOHIDManagerRegisterDeviceRemovalCallback(hid_hotplug_context.manager, + hid_internal_hotplug_disconnect_callback, + NULL); + + /* After monitoring is all set up, enumerate all devices */ + /* Opening the manager should result in the internal callback being called for all connected devices */ + IOHIDManagerOpen(hid_hotplug_context.manager, kIOHIDOptionsTypeNone); + + /* TODO: We need to flush all events from the runloop to ensure the already connected devices don't send any unwanted events */ + process_pending_events(); + + /* Now that all events are flushed, we are ready to notify the main thread that we are ready */ + hid_hotplug_context.thread_state = 1; + pthread_barrier_wait(&hid_hotplug_context.startup_barrier); + + while (hid_hotplug_context.thread_state != 2) { + int code = CFRunLoopRunInMode(hid_hotplug_context.run_loop_mode, 1000/*sec*/, FALSE); + /* If runloop stopped for whatever reason, exit the thread */ + if (code != kCFRunLoopRunTimedOut && + code != kCFRunLoopRunHandledSource) { + hid_hotplug_context.thread_state = 2; + break; + } + } + + /* Kill the manager */ + IOHIDManagerClose(hid_hotplug_context.manager, kIOHIDOptionsTypeNone); + + IOHIDManagerUnscheduleFromRunLoop(hid_hotplug_context.manager, hid_hotplug_context.run_loop, hid_hotplug_context.run_loop_mode); + + CFRelease(hid_hotplug_context.manager); + hid_hotplug_context.manager = NULL; + + return NULL; +} + +int HID_API_EXPORT HID_API_CALL hid_hotplug_register_callback(unsigned short vendor_id, unsigned short product_id, int events, int flags, hid_hotplug_callback_fn callback, void *user_data, hid_hotplug_callback_handle *callback_handle) +{ + struct hid_hotplug_callback* hotplug_cb; + + /* Check params */ + if (events == 0 + || (events & ~(HID_API_HOTPLUG_EVENT_DEVICE_ARRIVED | HID_API_HOTPLUG_EVENT_DEVICE_LEFT)) + || (flags & ~(HID_API_HOTPLUG_ENUMERATE)) + || callback == NULL) { + return -1; + } + + hotplug_cb = (struct hid_hotplug_callback*)calloc(1, sizeof(struct hid_hotplug_callback)); + + + if (hotplug_cb == NULL) { + return -1; + } + + /* Fill out the record */ + hotplug_cb->next = NULL; + hotplug_cb->vendor_id = vendor_id; + hotplug_cb->product_id = product_id; + hotplug_cb->events = events; + hotplug_cb->user_data = user_data; + hotplug_cb->callback = callback; + + /* Ensure we are ready to actually use the mutex */ + hid_internal_hotplug_init(); + + /* Lock the mutex to avoid race conditions */ + pthread_mutex_lock(&hid_hotplug_context.mutex); + + hotplug_cb->handle = hid_hotplug_context.next_handle++; + + /* handle the unlikely case of handle overflow */ + if (hid_hotplug_context.next_handle < 0) + { + hid_hotplug_context.next_handle = 1; + } + + /* Return allocated handle */ + if (callback_handle != NULL) { + *callback_handle = hotplug_cb->handle; + } + + /* Append a new callback to the end */ + if (hid_hotplug_context.hotplug_cbs != NULL) { + struct hid_hotplug_callback *last = hid_hotplug_context.hotplug_cbs; + while (last->next != NULL) { + last = last->next; + } + last->next = hotplug_cb; + } + else { + pthread_barrier_init(&hid_hotplug_context.startup_barrier, NULL, 2); + pthread_create(&hid_hotplug_context.thread, NULL, hotplug_thread, NULL); + + /* Wait for the thread to finish setting up - without it the callback may be registered too early*/ + + pthread_barrier_wait(&hid_hotplug_context.startup_barrier); + + /* Don't forget to actually register the callback */ + hid_hotplug_context.hotplug_cbs = hotplug_cb; + } + + /* Mark the mutex as IN USE, to prevent callback removal from inside a callback */ + unsigned char old_state = hid_hotplug_context.mutex_in_use; + hid_hotplug_context.mutex_in_use = 1; + + if ((flags & HID_API_HOTPLUG_ENUMERATE) && (events & HID_API_HOTPLUG_EVENT_DEVICE_ARRIVED)) { + struct hid_device_info* device = hid_hotplug_context.devs; + /* Notify about already connected devices, if asked so */ + while (device != NULL) { + if (hid_internal_match_device_id(device->vendor_id, device->product_id, hotplug_cb->vendor_id, hotplug_cb->product_id)) { + (*hotplug_cb->callback)(hotplug_cb->handle, device, HID_API_HOTPLUG_EVENT_DEVICE_ARRIVED, hotplug_cb->user_data); + } + + device = device->next; + } + } + + hid_hotplug_context.mutex_in_use = old_state; + + hid_internal_hotplug_cleanup(); + + pthread_mutex_unlock(&hid_hotplug_context.mutex); + + return 0; +} + +int HID_API_EXPORT HID_API_CALL hid_hotplug_deregister_callback(hid_hotplug_callback_handle callback_handle) +{ + if (!hid_hotplug_context.mutex_ready) { + return -1; + } + + pthread_mutex_lock(&hid_hotplug_context.mutex); + + if (hid_hotplug_context.hotplug_cbs == NULL) { + pthread_mutex_unlock(&hid_hotplug_context.mutex); + return -1; + } + + int result = -1; + + /* Remove this notification */ + for (struct hid_hotplug_callback **current = &hid_hotplug_context.hotplug_cbs; *current != NULL; current = &(*current)->next) { + if ((*current)->handle == callback_handle) { + /* Check if we were already in a locked state, as we are NOT allowed to remove any callbacks if we are */ + if (hid_hotplug_context.mutex_in_use) { + (*current)->events = 0; + hid_hotplug_context.cb_list_dirty = 1; + } else { + struct hid_hotplug_callback *next = (*current)->next; + free(*current); + *current = next; + } + result = 0; + break; + } + } + + hid_internal_hotplug_cleanup(); + + pthread_mutex_unlock(&hid_hotplug_context.mutex); + + return result; +} + hid_device * HID_API_EXPORT hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number) { /* This function is identical to the Linux version. Platform independent. */ diff --git a/netbsd/CMakeLists.txt b/netbsd/CMakeLists.txt index 3b3e4d049..437be62cf 100644 --- a/netbsd/CMakeLists.txt +++ b/netbsd/CMakeLists.txt @@ -13,7 +13,7 @@ target_link_libraries(hidapi_netbsd PRIVATE Threads::Threads) set_target_properties(hidapi_netbsd PROPERTIES EXPORT_NAME "netbsd" - OUTPUT_NAME "hidapi-netbsd" + OUTPUT_NAME "hidapi-hotplug-netbsd" VERSION ${PROJECT_VERSION} SOVERSION ${PROJECT_VERSION_MAJOR} PUBLIC_HEADER "${HIDAPI_PUBLIC_HEADERS}" @@ -32,4 +32,4 @@ if(HIDAPI_INSTALL_TARGETS) ) endif() -hidapi_configure_pc("${PROJECT_ROOT}/pc/hidapi-netbsd.pc.in") +hidapi_configure_pc("${PROJECT_ROOT}/pc/hidapi-hotplug-netbsd.pc.in") diff --git a/netbsd/hid.c b/netbsd/hid.c index ec5319a18..a9eb9f7ae 100644 --- a/netbsd/hid.c +++ b/netbsd/hid.c @@ -755,6 +755,28 @@ void HID_API_EXPORT HID_API_CALL hid_free_enumeration(struct hid_device_info *de } } +int HID_API_EXPORT HID_API_CALL hid_hotplug_register_callback(unsigned short vendor_id, unsigned short product_id, int events, int flags, hid_hotplug_callback_fn callback, void *user_data, hid_hotplug_callback_handle *callback_handle) +{ + /* Stub */ + (void)vendor_id; + (void)product_id; + (void)events; + (void)flags; + (void)callback; + (void)user_data; + (void)callback_handle; + + return -1; +} + +int HID_API_EXPORT HID_API_CALL hid_hotplug_deregister_callback(hid_hotplug_callback_handle callback_handle) +{ + /* Stub */ + (void)callback_handle; + + return -1; +} + HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number) { struct hid_device_info *devs; diff --git a/pc/hidapi-hidraw.pc.in b/pc/hidapi-hotplug-hidraw.pc.in similarity index 71% rename from pc/hidapi-hidraw.pc.in rename to pc/hidapi-hotplug-hidraw.pc.in index 28b9fe681..eaf3f0c04 100644 --- a/pc/hidapi-hidraw.pc.in +++ b/pc/hidapi-hotplug-hidraw.pc.in @@ -3,9 +3,9 @@ exec_prefix=@exec_prefix@ libdir=@libdir@ includedir=@includedir@ -Name: hidapi-hidraw +Name: hidapi-hotplug-hidraw Description: C Library for USB/Bluetooth HID device access from Linux, Mac OS X, FreeBSD, and Windows. This is the hidraw implementation. URL: https://github.com/libusb/hidapi Version: @VERSION@ -Libs: -L${libdir} -lhidapi-hidraw -Cflags: -I${includedir}/hidapi +Libs: -L${libdir} -lhidapi-hotplug-hidraw +Cflags: -I${includedir}/hidapi-hotplug diff --git a/pc/hidapi-libusb.pc.in b/pc/hidapi-hotplug-libusb.pc.in similarity index 71% rename from pc/hidapi-libusb.pc.in rename to pc/hidapi-hotplug-libusb.pc.in index d51e98f2b..fba8d5cf0 100644 --- a/pc/hidapi-libusb.pc.in +++ b/pc/hidapi-hotplug-libusb.pc.in @@ -3,9 +3,9 @@ exec_prefix=@exec_prefix@ libdir=@libdir@ includedir=@includedir@ -Name: hidapi-libusb +Name: hidapi-hotplug-libusb Description: C Library for USB HID device access from Linux, Mac OS X, FreeBSD, and Windows. This is the libusb implementation. URL: https://github.com/libusb/hidapi Version: @VERSION@ -Libs: -L${libdir} -lhidapi-libusb -Cflags: -I${includedir}/hidapi +Libs: -L${libdir} -lhidapi-hotplug-libusb +Cflags: -I${includedir}/hidapi-hotplug diff --git a/pc/hidapi-netbsd.pc.in b/pc/hidapi-hotplug-netbsd.pc.in similarity index 71% rename from pc/hidapi-netbsd.pc.in rename to pc/hidapi-hotplug-netbsd.pc.in index fcb5ca215..bd17577b2 100644 --- a/pc/hidapi-netbsd.pc.in +++ b/pc/hidapi-hotplug-netbsd.pc.in @@ -3,9 +3,9 @@ exec_prefix=@exec_prefix@ libdir=@libdir@ includedir=@includedir@ -Name: hidapi-netbsd +Name: hidapi-hotplug-netbsd Description: C Library for USB/Bluetooth HID device access from Linux, Mac OS X, FreeBSD, and Windows. This is the netbsd implementation. URL: https://github.com/libusb/hidapi Version: @VERSION@ -Libs: -L${libdir} -lhidapi-netbsd -Cflags: -I${includedir}/hidapi +Libs: -L${libdir} -lhidapi-hotplug-netbsd +Cflags: -I${includedir}/hidapi-hotplug diff --git a/pc/hidapi.pc.in b/pc/hidapi-hotplug.pc.in similarity index 71% rename from pc/hidapi.pc.in rename to pc/hidapi-hotplug.pc.in index 75b11a5dd..8820b3a9b 100644 --- a/pc/hidapi.pc.in +++ b/pc/hidapi-hotplug.pc.in @@ -3,9 +3,9 @@ exec_prefix=@exec_prefix@ libdir=@libdir@ includedir=@includedir@ -Name: hidapi +Name: hidapi-hotplug Description: C Library for USB/Bluetooth HID device access from Linux, Mac OS X, FreeBSD, and Windows. URL: https://github.com/libusb/hidapi Version: @VERSION@ -Libs: -L${libdir} -lhidapi -Cflags: -I${includedir}/hidapi +Libs: -L${libdir} -lhidapi-hotplug +Cflags: -I${includedir}/hidapi-hotplug diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index e663c3fd6..08bb483fa 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -22,7 +22,7 @@ if(DEFINED HIDAPI_PRINT_VERSION AND HIDAPI_PRINT_VERSION) message(STATUS "${HIDAPI_PRINT_VERSION}") endif() -project(hidapi VERSION "${VERSION}" LANGUAGES C) +project(hidapi-hotplug VERSION "${VERSION}" LANGUAGES C) # Defaults and required options @@ -81,22 +81,22 @@ endif() add_library(hidapi_include INTERFACE) target_include_directories(hidapi_include INTERFACE - "$" + "$" ) if(APPLE AND CMAKE_FRAMEWORK) # FIXME: https://github.com/libusb/hidapi/issues/492: it is untrivial to set the include path for Framework correctly else() target_include_directories(hidapi_include INTERFACE - "$" + "$" ) endif() set_target_properties(hidapi_include PROPERTIES EXPORT_NAME "include") -set(HIDAPI_PUBLIC_HEADERS "${PROJECT_ROOT}/hidapi/hidapi.h") +set(HIDAPI_PUBLIC_HEADERS "${PROJECT_ROOT}/hidapi-hotplug/hidapi.h") add_library(hidapi::include ALIAS hidapi_include) if(HIDAPI_INSTALL_TARGETS) - install(TARGETS hidapi_include EXPORT hidapi) + install(TARGETS hidapi_include EXPORT hidapi-hotplug) endif() set(EXPORT_ALIAS) @@ -179,28 +179,28 @@ else() endif() endif() -add_library(hidapi::hidapi ALIAS hidapi_${EXPORT_ALIAS}) +add_library(hidapi-hotplug::hidapi-hotplug ALIAS hidapi_${EXPORT_ALIAS}) if(HIDAPI_INSTALL_TARGETS) include(CMakePackageConfigHelpers) set(EXPORT_DENERATED_LOCATION "${CMAKE_BINARY_DIR}/export_generated") - set(EXPORT_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/hidapi") - write_basic_package_version_file("${EXPORT_DENERATED_LOCATION}/hidapi-config-version.cmake" + set(EXPORT_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/hidapi-hotplug") + write_basic_package_version_file("${EXPORT_DENERATED_LOCATION}/hidapi-hotplug-config-version.cmake" COMPATIBILITY SameMajorVersion ) - configure_package_config_file("cmake/hidapi-config.cmake.in" "${EXPORT_DENERATED_LOCATION}/hidapi-config.cmake" + configure_package_config_file("cmake/hidapi-hotplug-config.cmake.in" "${EXPORT_DENERATED_LOCATION}/hidapi-hotplug-config.cmake" INSTALL_DESTINATION "${EXPORT_DESTINATION}" NO_SET_AND_CHECK_MACRO ) - install(EXPORT hidapi + install(EXPORT hidapi-hotplug DESTINATION "${EXPORT_DESTINATION}" - NAMESPACE hidapi:: - FILE "libhidapi.cmake" + NAMESPACE hidapi-hotplug:: + FILE "libhidapi-hotplug.cmake" ) install(FILES - "${EXPORT_DENERATED_LOCATION}/hidapi-config-version.cmake" - "${EXPORT_DENERATED_LOCATION}/hidapi-config.cmake" + "${EXPORT_DENERATED_LOCATION}/hidapi-hotplug-config-version.cmake" + "${EXPORT_DENERATED_LOCATION}/hidapi-hotplug-config.cmake" DESTINATION "${EXPORT_DESTINATION}" ) endif() diff --git a/src/cmake/hidapi-config.cmake.in b/src/cmake/hidapi-hotplug-config.cmake.in similarity index 80% rename from src/cmake/hidapi-config.cmake.in rename to src/cmake/hidapi-hotplug-config.cmake.in index 4226c8cd8..d342aadc3 100644 --- a/src/cmake/hidapi-config.cmake.in +++ b/src/cmake/hidapi-hotplug-config.cmake.in @@ -41,21 +41,21 @@ if(HIDAPI_NEED_EXPORT_ICONV) endif() endif() -include("${CMAKE_CURRENT_LIST_DIR}/libhidapi.cmake") +include("${CMAKE_CURRENT_LIST_DIR}/libhidapi-hotplug.cmake") set(hidapi_FOUND TRUE) foreach(_component @EXPORT_COMPONENTS@) - if(TARGET hidapi::${_component}) + if(TARGET hidapi-hotplug::${_component}) set(hidapi_${_component}_FOUND TRUE) endif() endforeach() -check_required_components(hidapi) +check_required_components(hidapi-hotplug) -if(NOT TARGET hidapi::hidapi) - add_library(hidapi::hidapi INTERFACE IMPORTED) - set_target_properties(hidapi::hidapi PROPERTIES - INTERFACE_LINK_LIBRARIES hidapi::@EXPORT_ALIAS@ +if(NOT TARGET hidapi-hotplug::hidapi-hotplug) + add_library(hidapi-hotplug::hidapi-hotplug INTERFACE IMPORTED) + set_target_properties(hidapi-hotplug::hidapi-hotplug PROPERTIES + INTERFACE_LINK_LIBRARIES hidapi-hotplug::@EXPORT_ALIAS@ ) endif() diff --git a/windows/CMakeLists.txt b/windows/CMakeLists.txt index c8228bc84..251746dd8 100644 --- a/windows/CMakeLists.txt +++ b/windows/CMakeLists.txt @@ -33,7 +33,7 @@ endif() set_target_properties(hidapi_winapi PROPERTIES EXPORT_NAME "winapi" - OUTPUT_NAME "hidapi" + OUTPUT_NAME "hidapi-hotplug" VERSION ${PROJECT_VERSION} PUBLIC_HEADER "${HIDAPI_PUBLIC_HEADERS}" ) @@ -44,15 +44,15 @@ add_library(hidapi::winapi ALIAS hidapi_winapi) add_library(hidapi ALIAS hidapi_winapi) if(HIDAPI_INSTALL_TARGETS) - install(TARGETS hidapi_winapi EXPORT hidapi + install(TARGETS hidapi_winapi EXPORT hidapi-hotplug RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}" ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}" - PUBLIC_HEADER DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/hidapi" + PUBLIC_HEADER DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/hidapi-hotplug" ) endif() -hidapi_configure_pc("${PROJECT_ROOT}/pc/hidapi.pc.in") +hidapi_configure_pc("${PROJECT_ROOT}/pc/hidapi-hotplug.pc.in") if(HIDAPI_WITH_TESTS) add_subdirectory(test) diff --git a/windows/hid.c b/windows/hid.c index e87854764..bd747671c 100644 --- a/windows/hid.c +++ b/windows/hid.c @@ -48,6 +48,7 @@ typedef LONG NTSTATUS; #include #include #define _wcsdup wcsdup +#define _stricmp strcasecmp #endif /*#define HIDAPI_USE_DDK*/ @@ -78,6 +79,10 @@ typedef LONG NTSTATUS; #define MAX_STRING_WCHARS_USB 126 +/* The value of the first callback handle to be given upon registration */ +/* Can be any arbitrary positive integer */ +#define FIRST_HOTPLUG_CALLBACK_HANDLE 1 + static struct hid_api_version api_version = { .major = HID_API_VERSION_MAJOR, .minor = HID_API_VERSION_MINOR, @@ -111,6 +116,8 @@ static CM_Get_DevNode_PropertyW_ CM_Get_DevNode_PropertyW = NULL; static CM_Get_Device_Interface_PropertyW_ CM_Get_Device_Interface_PropertyW = NULL; static CM_Get_Device_Interface_List_SizeW_ CM_Get_Device_Interface_List_SizeW = NULL; static CM_Get_Device_Interface_ListW_ CM_Get_Device_Interface_ListW = NULL; +static CM_Register_Notification_ CM_Register_Notification = NULL; +static CM_Unregister_Notification_ CM_Unregister_Notification = NULL; static HMODULE hid_lib_handle = NULL; static HMODULE cfgmgr32_lib_handle = NULL; @@ -165,6 +172,8 @@ static int lookup_functions() RESOLVE(cfgmgr32_lib_handle, CM_Get_Device_Interface_PropertyW); RESOLVE(cfgmgr32_lib_handle, CM_Get_Device_Interface_List_SizeW); RESOLVE(cfgmgr32_lib_handle, CM_Get_Device_Interface_ListW); + RESOLVE(cfgmgr32_lib_handle, CM_Register_Notification); + RESOLVE(cfgmgr32_lib_handle, CM_Unregister_Notification); #undef RESOLVE #if defined(__GNUC__) @@ -198,6 +207,28 @@ struct hid_device_ { DWORD write_timeout_ms; }; +static struct hid_hotplug_context { + /* Win32 notification handle */ + HCMNOTIFICATION notify_handle; + + /* Critical section (faster mutex substitute), for both cached device list and callback list changes */ + CRITICAL_SECTION critical_section; + + /* Boolean flags */ + unsigned char mutex_ready; + unsigned char mutex_in_use; + unsigned char cb_list_dirty; + + /* HIDAPI unique callback handle counter */ + hid_hotplug_callback_handle next_handle; + + /* Linked list of the hotplug callbacks */ + struct hid_hotplug_callback *hotplug_cbs; + + /* Linked list of the device infos (mandatory when the device is disconnected) */ + struct hid_device_info *devs; +} hid_hotplug_context; /* zero-initialized (static storage); next_handle set on first init */ + static hid_device *new_hid_device() { hid_device *dev = (hid_device*) calloc(1, sizeof(hid_device)); @@ -292,7 +323,7 @@ static void register_winapi_error_to_buffer(wchar_t **error_buffer, const WCHAR /* Get rid of the CR and LF that FormatMessage() sticks at the end of the message. Thanks Microsoft! */ - while(msg[msg_len-1] == L'\r' || msg[msg_len-1] == L'\n' || msg[msg_len-1] == L' ') + while (msg[msg_len-1] == L'\r' || msg[msg_len-1] == L'\n' || msg[msg_len-1] == L' ') { msg[msg_len-1] = L'\0'; msg_len--; @@ -371,9 +402,24 @@ HID_API_EXPORT const char* HID_API_CALL hid_version_str(void) return HID_API_VERSION_STR; } +static void hid_internal_hotplug_init() +{ + if (!hid_hotplug_context.mutex_ready) { + InitializeCriticalSection(&hid_hotplug_context.critical_section); + + /* Set state to Ready */ + hid_hotplug_context.mutex_ready = 1; + hid_hotplug_context.mutex_in_use = 0; + hid_hotplug_context.cb_list_dirty = 0; + if (hid_hotplug_context.next_handle < FIRST_HOTPLUG_CALLBACK_HANDLE) + hid_hotplug_context.next_handle = FIRST_HOTPLUG_CALLBACK_HANDLE; + } +} + int HID_API_EXPORT hid_init(void) { register_global_error(NULL); + #ifndef HIDAPI_USE_DDK if (!hidapi_initialized) { if (lookup_functions() < 0) { @@ -383,16 +429,108 @@ int HID_API_EXPORT hid_init(void) hidapi_initialized = TRUE; } #endif + return 0; } +struct hid_hotplug_callback { + hid_hotplug_callback_handle handle; + unsigned short vendor_id; + unsigned short product_id; + int events; /* bitmask of hid_hotplug_event */ + void *user_data; + hid_hotplug_callback_fn callback; + + /* Pointer to the next notification */ + struct hid_hotplug_callback *next; +}; + +static void hid_internal_hotplug_remove_postponed() +{ + /* Unregister the callbacks whose removal was postponed */ + /* This function is always called inside a locked mutex */ + /* However, any actions are only allowed if the mutex is NOT in use and if the DIRTY flag is set */ + if (!hid_hotplug_context.mutex_ready || hid_hotplug_context.mutex_in_use || !hid_hotplug_context.cb_list_dirty) { + return; + } + + /* Traverse the list of callbacks and check if any were marked for removal */ + struct hid_hotplug_callback **current = &hid_hotplug_context.hotplug_cbs; + while (*current) { + struct hid_hotplug_callback *callback = *current; + if (!callback->events) { + *current = (*current)->next; + free(callback); + continue; + } + current = &callback->next; + } + + /* Clear the flag so we don't start the cycle unless necessary */ + hid_hotplug_context.cb_list_dirty = 0; +} + +static void hid_internal_hotplug_cleanup() +{ + if (!hid_hotplug_context.mutex_ready || hid_hotplug_context.mutex_in_use) { + return; + } + + /* Before checking if the list is empty, clear any entries whose removal was postponed first */ + hid_internal_hotplug_remove_postponed(); + + /* Unregister the HID device connection notification when removing the last callback */ + /* This function is always called inside a locked mutex */ + if (hid_hotplug_context.hotplug_cbs != NULL) { + return; + } + + if (hid_hotplug_context.devs) { + /* Cleanup connected device list */ + hid_free_enumeration(hid_hotplug_context.devs); + hid_hotplug_context.devs = NULL; + } + + if (hid_hotplug_context.notify_handle) { + if (CM_Unregister_Notification(hid_hotplug_context.notify_handle) != CR_SUCCESS) { + /* We mark an error, but we proceed with the cleanup */ + register_global_error(L"CM_Unregister_Notification failed for Hotplug notification"); + } + } + + hid_hotplug_context.notify_handle = NULL; +} + +static void hid_internal_hotplug_exit() +{ + if (!hid_hotplug_context.mutex_ready) { + /* If the critical section is not initialized, we are safe to assume nothing else is */ + return; + } + EnterCriticalSection(&hid_hotplug_context.critical_section); + struct hid_hotplug_callback **current = &hid_hotplug_context.hotplug_cbs; + /* Remove all callbacks from the list */ + while (*current) { + struct hid_hotplug_callback *next = (*current)->next; + free(*current); + *current = next; + } + hid_internal_hotplug_cleanup(); + LeaveCriticalSection(&hid_hotplug_context.critical_section); + hid_hotplug_context.mutex_ready = 0; + DeleteCriticalSection(&hid_hotplug_context.critical_section); +} + int HID_API_EXPORT hid_exit(void) { + hid_internal_hotplug_exit(); + #ifndef HIDAPI_USE_DDK free_library_handles(); hidapi_initialized = FALSE; #endif register_global_error(NULL); + return 0; } @@ -607,6 +745,11 @@ static void hid_internal_get_ble_info(struct hid_device_info* dev, DEVINST dev_n } } +static int hid_internal_match_device_id(unsigned short vendor_id, unsigned short product_id, unsigned short expected_vendor_id, unsigned short expected_product_id) +{ + return (expected_vendor_id == 0x0 || vendor_id == expected_vendor_id) && (expected_product_id == 0x0 || product_id == expected_product_id); +} + /* Unfortunately, HID_API_BUS_xxx constants alone aren't enough to distinguish between BLUETOOTH and BLE */ #define HID_API_BUS_FLAG_BLE 0x01 @@ -804,6 +947,7 @@ static struct hid_device_info *hid_internal_get_device_info(const wchar_t *path, case HID_API_BUS_UNKNOWN: case HID_API_BUS_SPI: case HID_API_BUS_I2C: + case HID_API_BUS_VIRTUAL: /* shut down -Wswitch */ break; } @@ -880,9 +1024,7 @@ struct hid_device_info HID_API_EXPORT * HID_API_CALL hid_enumerate(unsigned shor /* Check the VID/PID to see if we should add this device to the enumeration list. */ - if ((vendor_id == 0x0 || attrib.VendorID == vendor_id) && - (product_id == 0x0 || attrib.ProductID == product_id)) { - + if (hid_internal_match_device_id(attrib.VendorID, attrib.ProductID, vendor_id, product_id)) { /* VID/PID match. Create the record. */ struct hid_device_info *tmp = hid_internal_get_device_info(device_interface, device_handle); @@ -932,6 +1074,256 @@ void HID_API_EXPORT HID_API_CALL hid_free_enumeration(struct hid_device_info *d } } +DWORD WINAPI hid_internal_notify_callback(HCMNOTIFICATION notify, PVOID context, CM_NOTIFY_ACTION action, PCM_NOTIFY_EVENT_DATA event_data, DWORD event_data_size) +{ + struct hid_device_info *device = NULL; + hid_hotplug_event hotplug_event = (hid_hotplug_event)0; + + (void)notify; + (void)context; + (void)event_data_size; + + if (event_data == NULL || event_data->FilterType != CM_NOTIFY_FILTER_TYPE_DEVICEINTERFACE) { + return ERROR_SUCCESS; + } + + /* Lock the mutex to avoid race conditions */ + EnterCriticalSection(&hid_hotplug_context.critical_section); + + if (action == CM_NOTIFY_ACTION_DEVICEINTERFACEARRIVAL) { + HANDLE read_handle; + + hotplug_event = HID_API_HOTPLUG_EVENT_DEVICE_ARRIVED; + + /* Open read-only handle to the device */ + read_handle = open_device(event_data->u.DeviceInterface.SymbolicLink, FALSE); + + /* Check validity of read_handle. */ + if (read_handle != INVALID_HANDLE_VALUE) { + device = hid_internal_get_device_info(event_data->u.DeviceInterface.SymbolicLink, read_handle); + + /* Append to the end of the device list */ + if (hid_hotplug_context.devs != NULL) { + struct hid_device_info *last = hid_hotplug_context.devs; + while (last->next != NULL) { + last = last->next; + } + last->next = device; + } else { + hid_hotplug_context.devs = device; + } + + CloseHandle(read_handle); + } + } else if (action == CM_NOTIFY_ACTION_DEVICEINTERFACEREMOVAL) { + char *path; + + hotplug_event = HID_API_HOTPLUG_EVENT_DEVICE_LEFT; + + path = hid_internal_UTF16toUTF8(event_data->u.DeviceInterface.SymbolicLink); + + if (path != NULL) { + /* Get and remove this device from the device list */ + for (struct hid_device_info **current = &hid_hotplug_context.devs; *current; current = &(*current)->next) { + /* Case-independent path comparison is mandatory */ + if (_stricmp((*current)->path, path) == 0) { + struct hid_device_info *next = (*current)->next; + device = *current; + device->next = NULL; + *current = next; + break; + } + } + + free(path); + } + } + + if (device) { + /* Mark the critical section as IN USE, to prevent callback removal from inside a callback */ + hid_hotplug_context.mutex_in_use = 1; + + /* Call the notifications for the device */ + struct hid_hotplug_callback **current = &hid_hotplug_context.hotplug_cbs; + while (*current) { + struct hid_hotplug_callback *callback = *current; + if ((callback->events & hotplug_event) && hid_internal_match_device_id(device->vendor_id, device->product_id, callback->vendor_id, callback->product_id)) { + int result = (callback->callback)(callback->handle, device, hotplug_event, callback->user_data); + + /* If the result is non-zero, we MARK the callback for future removal and proceed */ + /* We avoid changing the list until we are done calling the callbacks to simplify the process */ + if (result) { + callback->events = 0; + hid_hotplug_context.cb_list_dirty = 1; + } + } + current = &callback->next; + } + + hid_hotplug_context.mutex_in_use = 0; + + /* Free removed device */ + if (hotplug_event == HID_API_HOTPLUG_EVENT_DEVICE_LEFT) { + hid_free_enumeration(device); + } + + /* Remove any callbacks that were marked for removal and stop the notification if none are left */ + hid_internal_hotplug_cleanup(); + } + + LeaveCriticalSection(&hid_hotplug_context.critical_section); + + return ERROR_SUCCESS; +} + +int HID_API_EXPORT HID_API_CALL hid_hotplug_register_callback(unsigned short vendor_id, unsigned short product_id, int events, int flags, hid_hotplug_callback_fn callback, void* user_data, hid_hotplug_callback_handle* callback_handle) +{ + struct hid_hotplug_callback* hotplug_cb; + + /* Check params */ + if (events == 0 + || (events & ~(HID_API_HOTPLUG_EVENT_DEVICE_ARRIVED | HID_API_HOTPLUG_EVENT_DEVICE_LEFT)) + || (flags & ~(HID_API_HOTPLUG_ENUMERATE)) + || callback == NULL) { + return -1; + } + + hotplug_cb = (struct hid_hotplug_callback*)calloc(1, sizeof(struct hid_hotplug_callback)); + + if (hotplug_cb == NULL) { + return -1; + } + + /* Fill out the record */ + hotplug_cb->next = NULL; + hotplug_cb->vendor_id = vendor_id; + hotplug_cb->product_id = product_id; + hotplug_cb->events = events; + hotplug_cb->user_data = user_data; + hotplug_cb->callback = callback; + + /* Ensure we are ready to actually use the mutex */ + hid_internal_hotplug_init(); + + /* Lock the mutex to avoid race conditions */ + EnterCriticalSection(&hid_hotplug_context.critical_section); + + hotplug_cb->handle = hid_hotplug_context.next_handle++; + + /* handle the unlikely case of handle overflow */ + if (hid_hotplug_context.next_handle < 0) + { + hid_hotplug_context.next_handle = 1; + } + + /* Return allocated handle */ + if (callback_handle != NULL) { + *callback_handle = hotplug_cb->handle; + } + + /* Append a new callback to the end */ + if (hid_hotplug_context.hotplug_cbs != NULL) { + struct hid_hotplug_callback *last = hid_hotplug_context.hotplug_cbs; + while (last->next != NULL) { + last = last->next; + } + last->next = hotplug_cb; + } + else { + GUID interface_class_guid; + CM_NOTIFY_FILTER notify_filter = { 0 }; + + /* Fill already connected devices so we can use this info in disconnection notification */ + hid_hotplug_context.devs = hid_enumerate(0, 0); + + hid_hotplug_context.hotplug_cbs = hotplug_cb; + + if (hid_hotplug_context.notify_handle != NULL) { + register_global_error(L"Device notification have already been registered"); + LeaveCriticalSection(&hid_hotplug_context.critical_section); + return -1; + } + + /* Retrieve HID Interface Class GUID + https://docs.microsoft.com/windows-hardware/drivers/install/guid-devinterface-hid */ + HidD_GetHidGuid(&interface_class_guid); + + notify_filter.cbSize = sizeof(notify_filter); + notify_filter.FilterType = CM_NOTIFY_FILTER_TYPE_DEVICEINTERFACE; + notify_filter.u.DeviceInterface.ClassGuid = interface_class_guid; + + /* Register for a HID device notification when adding the first callback */ + if (CM_Register_Notification(¬ify_filter, NULL, hid_internal_notify_callback, &hid_hotplug_context.notify_handle) != CR_SUCCESS) { + register_global_error(L"hid_hotplug_register_callback/CM_Register_Notification"); + LeaveCriticalSection(&hid_hotplug_context.critical_section); + return -1; + } + } + + /* Mark the critical section as IN USE, to prevent callback removal from inside a callback */ + unsigned char old_state = hid_hotplug_context.mutex_in_use; + hid_hotplug_context.mutex_in_use = 1; + + if ((flags & HID_API_HOTPLUG_ENUMERATE) && (events & HID_API_HOTPLUG_EVENT_DEVICE_ARRIVED)) { + struct hid_device_info* device = hid_hotplug_context.devs; + /* Notify about already connected devices, if asked so */ + while (device != NULL) { + if (hid_internal_match_device_id(device->vendor_id, device->product_id, hotplug_cb->vendor_id, hotplug_cb->product_id)) { + (*hotplug_cb->callback)(hotplug_cb->handle, device, HID_API_HOTPLUG_EVENT_DEVICE_ARRIVED, hotplug_cb->user_data); + } + + device = device->next; + } + } + + hid_hotplug_context.mutex_in_use = old_state; + + /* Remove any callbacks that were marked for removal and stop the notification if none are left */ + hid_internal_hotplug_cleanup(); + + LeaveCriticalSection(&hid_hotplug_context.critical_section); + + return 0; +} + +int HID_API_EXPORT HID_API_CALL hid_hotplug_deregister_callback(hid_hotplug_callback_handle callback_handle) +{ + if (callback_handle <= 0 || !hid_hotplug_context.mutex_ready) { + return -1; + } + + /* Lock the mutex to avoid race conditions */ + EnterCriticalSection(&hid_hotplug_context.critical_section); + + if (!hid_hotplug_context.hotplug_cbs) { + LeaveCriticalSection(&hid_hotplug_context.critical_section); + return -1; + } + + /* Remove this notification */ + for (struct hid_hotplug_callback **current = &hid_hotplug_context.hotplug_cbs; *current != NULL; current = &(*current)->next) { + if ((*current)->handle == callback_handle) { + /* Check if we were already in the critical section, as we are NOT allowed to remove any callbacks if we are */ + if (hid_hotplug_context.mutex_in_use) { + /* If we are not allowed to remove the callback, we mark it as pending removal */ + (*current)->events = 0; + hid_hotplug_context.cb_list_dirty = 1; + } else { + struct hid_hotplug_callback *next = (*current)->next; + free(*current); + *current = next; + } + break; + } + } + + hid_internal_hotplug_cleanup(); + + LeaveCriticalSection(&hid_hotplug_context.critical_section); + + return 0; +} + HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number) { /* TODO: Merge this functions with the Linux version. This function should be platform independent. */ diff --git a/windows/hidapi_cfgmgr32.h b/windows/hidapi_cfgmgr32.h index 638512a8b..460b2e583 100644 --- a/windows/hidapi_cfgmgr32.h +++ b/windows/hidapi_cfgmgr32.h @@ -57,6 +57,73 @@ typedef CONFIGRET(__stdcall* CM_Get_Device_Interface_PropertyW_)(LPCWSTR pszDevi typedef CONFIGRET(__stdcall* CM_Get_Device_Interface_List_SizeW_)(PULONG pulLen, LPGUID InterfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags); typedef CONFIGRET(__stdcall* CM_Get_Device_Interface_ListW_)(LPGUID InterfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR Buffer, ULONG BufferLen, ULONG ulFlags); +DECLARE_HANDLE(HCMNOTIFICATION); +typedef HCMNOTIFICATION* PHCMNOTIFICATION; + +typedef enum _CM_NOTIFY_FILTER_TYPE { + CM_NOTIFY_FILTER_TYPE_DEVICEINTERFACE = 0, + CM_NOTIFY_FILTER_TYPE_DEVICEHANDLE, + CM_NOTIFY_FILTER_TYPE_DEVICEINSTANCE, + CM_NOTIFY_FILTER_TYPE_MAX +} CM_NOTIFY_FILTER_TYPE, * PCM_NOTIFY_FILTER_TYPE; + +typedef struct _CM_NOTIFY_FILTER { + DWORD cbSize; + DWORD Flags; + CM_NOTIFY_FILTER_TYPE FilterType; + DWORD Reserved; + union { + struct { + GUID ClassGuid; + } DeviceInterface; + struct { + HANDLE hTarget; + } DeviceHandle; + struct { + WCHAR InstanceId[200]; + } DeviceInstance; + } u; +} CM_NOTIFY_FILTER, * PCM_NOTIFY_FILTER; + +typedef enum _CM_NOTIFY_ACTION { + CM_NOTIFY_ACTION_DEVICEINTERFACEARRIVAL = 0, + CM_NOTIFY_ACTION_DEVICEINTERFACEREMOVAL, + CM_NOTIFY_ACTION_DEVICEQUERYREMOVE, + CM_NOTIFY_ACTION_DEVICEQUERYREMOVEFAILED, + CM_NOTIFY_ACTION_DEVICEREMOVEPENDING, + CM_NOTIFY_ACTION_DEVICEREMOVECOMPLETE, + CM_NOTIFY_ACTION_DEVICECUSTOMEVENT, + CM_NOTIFY_ACTION_DEVICEINSTANCEENUMERATED, + CM_NOTIFY_ACTION_DEVICEINSTANCESTARTED, + CM_NOTIFY_ACTION_DEVICEINSTANCEREMOVED, + CM_NOTIFY_ACTION_MAX +} CM_NOTIFY_ACTION, * PCM_NOTIFY_ACTION; + +typedef struct _CM_NOTIFY_EVENT_DATA { + CM_NOTIFY_FILTER_TYPE FilterType; + DWORD Reserved; + union { + struct { + GUID ClassGuid; + WCHAR SymbolicLink[ANYSIZE_ARRAY]; + } DeviceInterface; + struct { + GUID EventGuid; + LONG NameOffset; + DWORD DataSize; + BYTE Data[ANYSIZE_ARRAY]; + } DeviceHandle; + struct { + WCHAR InstanceId[ANYSIZE_ARRAY]; + } DeviceInstance; + } u; +} CM_NOTIFY_EVENT_DATA, * PCM_NOTIFY_EVENT_DATA; + +typedef DWORD(CALLBACK* PCM_NOTIFY_CALLBACK)(HCMNOTIFICATION hNotify, PVOID Context, CM_NOTIFY_ACTION Action, PCM_NOTIFY_EVENT_DATA EventData, DWORD EventDataSize); + +typedef CONFIGRET(__stdcall* CM_Register_Notification_)(PCM_NOTIFY_FILTER pFilter, PVOID pContext, PCM_NOTIFY_CALLBACK pCallback, PHCMNOTIFICATION pNotifyContext); +typedef CONFIGRET(__stdcall* CM_Unregister_Notification_)(HCMNOTIFICATION NotifyContext); + // from devpkey.h DEFINE_DEVPROPKEY(DEVPKEY_NAME, 0xb725f130, 0x47ef, 0x101a, 0xa5, 0xf1, 0x02, 0x60, 0x8c, 0x9e, 0xeb, 0xac, 10); // DEVPROP_TYPE_STRING DEFINE_DEVPROPKEY(DEVPKEY_Device_Manufacturer, 0xa45c254e, 0xdf1c, 0x4efd, 0x80, 0x20, 0x67, 0xd1, 0x46, 0xa8, 0x50, 0xe0, 13); // DEVPROP_TYPE_STRING