@@ -59,7 +59,8 @@
            libwayland-dev \
            libx11-xcb-dev \
            libxcb-dri3-dev \
            libxfixes-dev
            libxfixes-dev \
            libxtst-dev
      - name: Build latest libva
        env:
@@ -178,9 +179,14 @@
      - name: Sync Python tools
        run: |
          uv_sync_args=(
          uv sync --locked \
            --python "${PYTHON_VERSION}" \
            --no-python-downloads --no-install-project
            --locked
            --python "${PYTHON_VERSION}"
            --no-python-downloads
            --no-install-project
          )
          # uv.lock pins external artifacts; reviewed local build hooks are required for gcovr.
          uv sync "${uv_sync_args[@]}"  # NOSONAR(githubactions:S8541)
      - name: Run tests
        id: test

@@ -13,13 +13,13 @@
[submodule "third-party/glad"]
	path = third-party/glad
	url = https://github.com/Dav1dde/glad.git
[submodule "third-party/inputtino"]
	path = third-party/inputtino
	url = https://github.com/games-on-whales/inputtino.git
	branch = stable
[submodule "third-party/libdisplaydevice"]
	path = third-party/libdisplaydevice
	url = https://github.com/LizardByte/libdisplaydevice.git
	branch = master
[submodule "third-party/libvirtualhid"]
	path = third-party/libvirtualhid
	url = https://github.com/LizardByte/libvirtualhid.git
	branch = master
[submodule "third-party/lizardbyte-common"]
	path = third-party/lizardbyte-common

@@ -59,6 +59,18 @@
    endif()
endif()
# libvirtualhid
add_subdirectory("${CMAKE_SOURCE_DIR}/third-party/libvirtualhid")
list(APPEND SUNSHINE_EXTERNAL_LIBRARIES libvirtualhid::libvirtualhid)
list(APPEND PLATFORM_TARGET_FILES
        "${CMAKE_SOURCE_DIR}/src/platform/virtualhid_input.h"
        "${CMAKE_SOURCE_DIR}/src/platform/virtualhid_input.cpp")
# build libevdev before the libvirtualhid target when using the ExternalProject fallback
if(EXTERNAL_PROJECT_LIBEVDEV_USED AND TARGET libvirtualhid)
    add_dependencies(libvirtualhid libevdev)
endif()
set(NVENC_PUBLIC_SOURCES
        "${CMAKE_SOURCE_DIR}/src/nvenc/nvenc_config.h"
        "${CMAKE_SOURCE_DIR}/src/nvenc/nvenc_d3d11_interface.h"

@@ -296,24 +296,12 @@
    message(FATAL_ERROR "Couldn't find either cuda, libdrm, libva, kwin, pipewire, portal, wayland or x11")
endif()
# These need to be set before adding the inputtino subdirectory in order for them to be picked up
# These need to be set before common.cmake adds the libvirtualhid subdirectory in order for them to be picked up
set(LIBEVDEV_CUSTOM_INCLUDE_DIR "${EVDEV_INCLUDE_DIR}")
set(LIBEVDEV_CUSTOM_LIBRARY "${EVDEV_LIBRARY}")
if(FREEBSD)
    set(USE_UHID OFF)
endif()
add_subdirectory("${CMAKE_SOURCE_DIR}/third-party/inputtino")
list(APPEND SUNSHINE_EXTERNAL_LIBRARIES inputtino::libinputtino)
file(GLOB_RECURSE INPUTTINO_SOURCES
        ${CMAKE_SOURCE_DIR}/src/platform/linux/input/inputtino*.h
        ${CMAKE_SOURCE_DIR}/src/platform/linux/input/inputtino*.cpp)
list(APPEND PLATFORM_TARGET_FILES ${INPUTTINO_SOURCES})
# build libevdev before the libinputtino target
if(EXTERNAL_PROJECT_LIBEVDEV_USED)
    add_dependencies(libinputtino libevdev)
endif()
list(APPEND PLATFORM_TARGET_FILES
        "${CMAKE_SOURCE_DIR}/src/platform/linux/input/virtualhid.cpp")
# AppImage and Flatpak
if (${SUNSHINE_BUILD_APPIMAGE})

@@ -62,11 +62,6 @@
    INCLUDE_DIRECTORIES ""
)
# ViGEmBus version
set(VIGEMBUS_PACKAGED_V "1.21.442")
set(VIGEMBUS_PACKAGED_V_2 "${VIGEMBUS_PACKAGED_V}.0")
list(APPEND SUNSHINE_DEFINITIONS VIGEMBUS_PACKAGED_VERSION="${VIGEMBUS_PACKAGED_V_2}")
set(PLATFORM_TARGET_FILES
        "${CMAKE_SOURCE_DIR}/src/platform/windows/publish.cpp"
        "${CMAKE_SOURCE_DIR}/src/platform/windows/misc.h"

@@ -36,6 +36,14 @@
        "${CMAKE_CURRENT_BINARY_DIR}/assets/web/images/logo-sunshine.svg"
        COPYONLY)
# Copy the Virtual HID Driver icon for Windows tray notifications.
if(WIN32)
    configure_file(
            "${CMAKE_SOURCE_DIR}/third-party/libvirtualhid/libvirtualhid.svg"
            "${CMAKE_CURRENT_BINARY_DIR}/assets/web/images/logo-libvirtualhid.svg"
            COPYONLY)
endif()
# install built vite assets
install(DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/assets/web"
        DESTINATION "${SUNSHINE_ASSETS_DIR}")

@@ -9,24 +9,6 @@
    install(FILES "${_MINHOOK_DLL}" DESTINATION "." COMPONENT application)
endif()
# ViGEmBus installer
set(SUNSHINE_THIRD_PARTY_DIR "third-party")
set(VIGEMBUS_INSTALLER "${CMAKE_BINARY_DIR}/${SUNSHINE_THIRD_PARTY_DIR}/vigembus_installer.exe")
set(VIGEMBUS_DOWNLOAD_URL_1 "https://github.com/nefarius/ViGEmBus/releases/download")
set(VIGEMBUS_DOWNLOAD_URL_2 "v${VIGEMBUS_PACKAGED_V_2}/ViGEmBus_${VIGEMBUS_PACKAGED_V}_x64_x86_arm64.exe")
file(MAKE_DIRECTORY "${CMAKE_BINARY_DIR}/${SUNSHINE_THIRD_PARTY_DIR}")
file(DOWNLOAD
        "${VIGEMBUS_DOWNLOAD_URL_1}/${VIGEMBUS_DOWNLOAD_URL_2}"
        ${VIGEMBUS_INSTALLER}
        SHOW_PROGRESS
        EXPECTED_HASH SHA256=155c50f1eec07bdc28d2f61a3e3c2c6c132fee7328412de224695f89143316bc
        TIMEOUT 60
)
install(FILES ${VIGEMBUS_INSTALLER}
        DESTINATION "${SUNSHINE_THIRD_PARTY_DIR}"
        RENAME "vigembus_installer.exe"
        COMPONENT gamepad)
# Adding tools
install(TARGETS dxgi-info RUNTIME DESTINATION "tools" COMPONENT dxgi)
install(TARGETS audio-info RUNTIME DESTINATION "tools" COMPONENT audio)
@@ -80,8 +62,6 @@
# Setting components groups and dependencies
set(CPACK_COMPONENT_GROUP_CORE_EXPANDED true)
set(CPACK_COMPONENT_GROUP_THIRDPARTY_DISPLAY_NAME "Third Party")
set(CPACK_COMPONENT_GROUP_THIRDPARTY_DESCRIPTION "Bundled third-party installers and optional components.")
# sunshine binary
set(CPACK_COMPONENT_APPLICATION_DISPLAY_NAME "${CMAKE_PROJECT_NAME}")
@@ -115,11 +95,6 @@
set(CPACK_COMPONENT_FIREWALL_DISPLAY_NAME "Add Firewall Exclusions")
set(CPACK_COMPONENT_FIREWALL_DESCRIPTION "Scripts to enable or disable firewall rules.")
set(CPACK_COMPONENT_FIREWALL_GROUP "Scripts")
# gamepad third-party installer
set(CPACK_COMPONENT_GAMEPAD_DISPLAY_NAME "Virtual Gamepad")
set(CPACK_COMPONENT_GAMEPAD_DESCRIPTION "ViGEmBus installer for virtual gamepad support.")
set(CPACK_COMPONENT_GAMEPAD_GROUP "ThirdParty")
# include specific packaging
include(${CMAKE_MODULE_PATH}/packaging/windows_nsis.cmake)

@@ -1,7 +1,8 @@
cmake_minimum_required(VERSION 3.20)
cmake_minimum_required(VERSION 3.24)
# `CMAKE_CUDA_ARCHITECTURES` requires 3.18
# `set_source_files_properties` requires 3.18
# `cmake_path(CONVERT ... TO_NATIVE_PATH_LIST ...)` requires 3.20
# `third-party/libvirtualhid` requires 3.24
# todo - set this conditionally
project(Sunshine VERSION 0.0.0

@@ -94,10 +94,7 @@
## POST /api/restart
@copydoc confighttp::restart()
## GET /api/vigembus/status
@copydoc confighttp::getViGEmBusStatus()
## POST /api/vigembus/install
@copydoc confighttp::installViGEmBus()
## GET /api/virtual-input/status
@copydoc confighttp::getVirtualInputStatus()
<div class="section_buttons">

@@ -317,6 +317,7 @@
        <td>Description</td>
        <td colspan="2">
            The type of gamepad to emulate on the host.
            @note{This option applies to FreeBSD, Linux, and Windows.}
        </td>
    </tr>
    <tr>
@@ -332,29 +333,32 @@
            @endcode</td>
    </tr>
    <tr>
        <td rowspan="7">Choices</td>
        <td rowspan="6">Choices</td>
        <td>generic</td>
        <td>Generic HID gamepad</td>
    </tr>
    <tr>
        <td>ds4</td>
        <td>DualShock 4 controller (PS4)
            @note{This option applies to Windows only.}</td>
        <td>DualShock 4 controller (PS4)</td>
    </tr>
    <tr>
        <td>ds5</td>
        <td>DualShock 5 controller (PS5)</td>
        <td>DualShock 5 controller (PS5)
            @note{This option applies to FreeBSD and Linux only.}</td>
    </tr>
    <tr>
        <td>switch</td>
        <td>Switch Pro controller
            @note{This option applies to FreeBSD and Linux only.}</td>
        <td>Switch Pro controller</td>
    </tr>
    <tr>
        <td>x360</td>
        <td>Xbox 360 controller</td>
        <td>Xbox 360 controller
            @note{This option applies to Windows only.}</td>
    </tr>
    <tr>
        <td>xone</td>
        <td>Xbox One controller</td>
    </tr>
    <tr>
        <td>xseries</td>
        <td>Xbox One controller
            @note{This option applies to FreeBSD and Linux only.}</td>
        <td>Xbox Series controller</td>
    </tr>
</table>
@@ -365,9 +369,9 @@
    <tr>
        <td>Description</td>
        <td colspan="2">
            Allow Select/Back inputs to also trigger a PlayStation-style gamepad touchpad click. Useful
            for clients looking to emulate touchpad click on XInput devices.
            @hint{Applies to ds4, ds5, and automatically selected PlayStation-style gamepads.}
            Allow Select/Back inputs to also trigger DS4 touchpad click. Useful for clients looking to
            emulate touchpad click on Xinput devices.
            @hint{Only applies when gamepad is set to ds4 manually. Unused in other gamepad modes.}
        </td>
    </tr>
    <tr>
@@ -391,7 +395,7 @@
        <td>Description</td>
        <td colspan="2">
            If a client reports that a connected gamepad has motion sensor support, emulate it on the
            host as a DS4 controller.
            host as a PlayStation-style controller.
            <br>
            <br>
            When disabled, motion sensors will not be taken into account during gamepad type selection.
@@ -418,8 +422,8 @@
    <tr>
        <td>Description</td>
        <td colspan="2">
            If a client reports that a connected gamepad has a touchpad, emulate it on the host
            as a DS4 controller.
            If a client reports that a connected gamepad has a touchpad, emulate it on the host as a
            PlayStation-style controller.
            <br>
            <br>
            When disabled, touchpad presence will not be taken into account during gamepad type selection.
@@ -440,14 +444,13 @@
    </tr>
</table>
### virtualhid_randomize_mac
### ds5_inputtino_randomize_mac
<table>
    <tr>
        <td>Description</td>
        <td colspan="2">
            Randomize the MAC-Address for the generated virtual controller.
            @hint{Only applies on linux for gamepads created as PS5-style controllers}
            Randomize the MAC address for PlayStation-style virtual controllers created by libvirtualhid.
        </td>
    </tr>
    <tr>
@@ -459,7 +462,7 @@
    <tr>
        <td>Example</td>
        <td colspan="2">@code{}
            ds5_inputtino_randomize_mac = enabled
            virtualhid_randomize_mac = enabled
            @endcode</td>
    </tr>
</table>

@@ -474,10 +474,20 @@
> Gamepads are not currently supported.
### Windows
Sunshine uses libvirtualhid for virtual gamepads on Windows. You must install the
[Virtual HID Driver](https://github.com/LizardByte/libvirtualhid/releases/latest) separately for full virtual gamepad
support. ViGEmBus is detected only as a limited fallback for Xbox 360 and DualShock 4 gamepads when libvirtualhid is
unavailable.
Compared with the ViGEmBus fallback, Virtual HID Driver can create Xbox One, Xbox Series, DualSense, Nintendo Switch
Pro, and Generic gamepads in addition to Xbox 360 and DualShock 4. It can also expose controller-specific features such
as motion, touchpads, LEDs, and adaptive triggers when supported. Virtual HID Driver is actively developed and
supported by the LizardByte team.
The Virtual HID Driver also requires an active machine license. Sunshine shows the current license status and actions
In order for virtual gamepads to work, you must install ViGEmBus. You can do this from the troubleshooting tab
in the web UI, as long as you are running Sunshine as a service or as an administrator. After installation, it is
recommended to restart your computer.
on the Web UI Troubleshooting page and in the **Virtual HID Driver** system tray submenu. When Sunshine starts on an
unactivated machine, select its tray notification to open the activation and purchase options in the Web UI.
![ViGEmBus Installation](images/vigembus-installer.png)
After installing or updating virtual input drivers, it is recommended to restart your computer.
## Usage
@@ -612,7 +622,8 @@
  The following are known limitations.
  * Only X11 and Wayland capture are supported
  * Gamepads use libvirtualhid's uinput backend, so descriptor-driven features such as motion, touchpad input,
  * DualSense/DS5 emulation is not available due to missing uhid features
    battery state, RGB LEDs, adaptive triggers, and raw HID output reports are unavailable
### HDR Support

@@ -205,6 +205,6 @@
When the seat is not `seat0`, Sunshine appends the seat name to its virtual device names, for example:
- Keyboard passthrough (seat1)
- Sunshine PS5 (virtual) pad (seat1)
- Sunshine (libvirtualhid) PS5 Controller (seat1)
Sunshine creates two mouse devices: a relative one and an absolute one.
@@ -290,9 +290,18 @@
## Windows
### No gamepad detected
Sunshine uses libvirtualhid for virtual gamepads on Windows. Install the
[Virtual HID Driver](https://github.com/LizardByte/libvirtualhid/releases/latest) separately for full virtual gamepad
support. ViGEmBus is detected only as a limited fallback for Xbox 360 and DualShock 4 gamepads when libvirtualhid is
unavailable. If you use the [ViGEmBus fallback](https://github.com/nefarius/ViGEmBus/releases/latest), you must use
version 1.17 or newer.
Virtual HID Driver adds Xbox One, Xbox Series, DualSense, Nintendo Switch Pro, and Generic gamepads, plus advanced
You must install ViGEmBus to use virtual gamepads. You can install this from the troubleshooting tab of the web UI.
controller features such as motion, touchpads, LEDs, and adaptive triggers when supported. Unlike the discontinued
ViGEmBus project, Virtual HID Driver is actively developed and supported by the LizardByte team.
Alternatively, you can manually install it from
[ViGEmBus releases](https://github.com/nefarius/ViGEmBus/releases/latest). You must use version 1.17 or newer.
An active Virtual HID Driver machine license is required before Sunshine can create libvirtualhid gamepads. Follow
the warning on the Web UI home page, the startup tray notification, or the **Virtual HID Driver** tray submenu to open
the license section on the Troubleshooting page, where you can activate a key or follow the purchase link.
After installation, it is recommended to restart your computer.

@@ -30,6 +30,5 @@
    Sunshine emulates an Xbox, PlayStation, or Nintendo Switch controller.
    Use nearly any controller on your Moonlight client!
    <br><small><ul>
    <li>Nintendo Switch emulation is only available on Linux.</li>
    <li>Gamepad emulation is not currently supported on macOS.</li>
    </ul></small>

@@ -53,42 +53,59 @@
        </td>
    </tr>
    <tr>
        <td>Generic</td>
        <td>🟡<sup>1</sup></td>
        <td>✅</td>
        <td>❌</td>
        <td>✅</td>
    </tr>
    <tr>
        <td>DualShock / DS4 (PlayStation 4)</td>
        <td>🟡<sup>1</sup></td>
        <td>✅</td>
        <td>➖</td>
        <td>➖</td>
        <td>❌</td>
        <td>✅</td>
    </tr>
    <tr>
        <td>DualSense / DS5 (PlayStation 5)</td>
        <td>🟡<sup>1</sup></td>
        <td>✅</td>
        <td>❌</td>
        <td>✅</td>
        <td>❌</td>
        <td>❌</td>
    </tr>
    <tr>
        <td>Nintendo Switch Pro</td>
        <td>✅</td>
        <td>🟡<sup>1</sup></td>
        <td>✅</td>
        <td>❌</td>
        <td>✅</td>
        <td>❌</td>
    </tr>
    <tr>
        <td>Xbox 360</td>
        <td>🟡<sup>1</sup></td>
        <td>✅</td>
        <td>➖</td>
        <td>➖</td>
        <td>❌</td>
        <td>✅</td>
    </tr>
    <tr>
        <td>Xbox One</td>
        <td>Xbox One/Series</td>
        <td>✅</td>
        <td>🟡<sup>1</sup></td>
        <td>✅</td>
        <td>❌</td>
        <td>✅</td>
    </tr>
    <tr>
        <td>Xbox Series</td>
        <td>🟡<sup>1</sup></td>
        <td>✅</td>
        <td>❌</td>
        <td>✅</td>
    </tr>
</table>
> [!NOTE]
> <sup>1</sup> Missing motion, touchpad input, battery state, RGB LEDs, adaptive triggers, and raw HID output reports.
<table>
    <caption id="encoding_api">Encoding API</caption>
    <tr>
@@ -381,7 +398,7 @@
    </tr>
    <tr>
        <td rowspan="6">OS</td>
        <td>FreeBSD: 15.1+</td>
        <td>FreeBSD: 14.4+</td>
    </tr>
    <tr>
        <td>Linux/Debian: 13+ (trixie)</td>
@@ -396,7 +413,7 @@
        <td>macOS: 14.2+</td>
    </tr>
    <tr>
        <td>Windows: 11+ (Windows Server does not support virtual gamepads)</td>
        <td>Windows: 11+</td>
    </tr>
    <tr>
        <td rowspan="2">Network</td>

@@ -54,7 +54,7 @@
      2,
      1,
      1,
      platf::speaker::map_stereo,
      platf::speaker::map_stereo.data(),
      96000,
    },
    {
@@ -62,7 +62,7 @@
      2,
      1,
      1,
      platf::speaker::map_stereo,
      platf::speaker::map_stereo.data(),
      512000,
    },
    {
@@ -70,7 +70,7 @@
      6,
      4,
      2,
      platf::speaker::map_surround51.data(),
      platf::speaker::map_surround51,
      256000,
    },
    {
@@ -78,7 +78,7 @@
      6,
      6,
      0,
      platf::speaker::map_surround51,
      platf::speaker::map_surround51.data(),
      1536000,
    },
    {
@@ -86,7 +86,7 @@
      8,
      5,
      3,
      platf::speaker::map_surround71,
      platf::speaker::map_surround71.data(),
      450000,
    },
    {
@@ -94,7 +94,7 @@
      8,
      8,
      0,
      platf::speaker::map_surround71.data(),
      platf::speaker::map_surround71,
      2048000,
    },
  };

@@ -33,6 +33,15 @@
  #include <shellapi.h>
#endif
#if defined(_WIN32) && !defined(DOXYGEN)
  #ifdef _GLIBCXX_USE_C99_INTTYPES
    #undef _GLIBCXX_USE_C99_INTTYPES
  #endif
  #include <AMF/components/VideoEncoderAV1.h>
  #include <AMF/components/VideoEncoderHEVC.h>
  #include <AMF/components/VideoEncoderVCE.h>
#endif
#if !defined(__ANDROID__) && !defined(__APPLE__)
  // For NVENC legacy constants
  #include <ffnvcodec/nvEncodeAPI.h>
@@ -140,13 +149,6 @@
    constexpr int AMF_VIDEO_ENCODER_UNDEFINED = 0;  ///< Fallback AMF enum value for undefined.
    constexpr int AMF_VIDEO_ENCODER_CABAC = 1;  ///< Fallback AMF enum value for cabac.
    constexpr int AMF_VIDEO_ENCODER_CALV = 2;  ///< Fallback AMF enum value for calv.
#else
  #ifdef _GLIBCXX_USE_C99_INTTYPES
    #undef _GLIBCXX_USE_C99_INTTYPES
  #endif
  #include <AMF/components/VideoEncoderAV1.h>
  #include <AMF/components/VideoEncoderHEVC.h>
  #include <AMF/components/VideoEncoderVCE.h>
#endif
    /**
@@ -847,10 +849,10 @@
      platf::supported_gamepads(nullptr).front().name.data(),
      platf::supported_gamepads(nullptr).front().name.size(),
    },  // Default gamepad
    true,  // back as touchpad click enabled for PlayStation-style gamepads
    true,  // client gamepads with motion events use PlayStation-style emulation
    true,  // client gamepads with touchpads use PlayStation-style emulation
    true,  // back as touchpad click enabled (manual DS4 only)
    true,  // client gamepads with motion events are emulated as DS4
    true,  // client gamepads with touchpads are emulated as DS4
    true,  // ds5_inputtino_randomize_mac
    true,  // virtualhid_randomize_mac
    true,  // keyboard enabled
    true,  // mouse enabled
@@ -1164,6 +1166,23 @@
  }
  /**
   * @brief Parse a decimal or hexadecimal integer configuration value.
   *
   * @param value Raw configuration value, optionally surrounded by quotes.
   * @return Parsed integer value.
   */
  int parse_config_integer(std::string_view value) {
    if (value.size() >= 2 && value.front() == '"') {
      value = value.substr(1, value.size() - 2);
    }
    if (value.starts_with("0x"sv)) {
      return util::from_hex<int>(value.substr(2));
    }
    return static_cast<int>(util::from_view(value));
  }
  /**
   * @brief Consume an integer setting from decimal or hexadecimal configuration text.
   *
   * @param vars Parsed configuration entries; consumed keys are erased.
@@ -1175,21 +1194,8 @@
    if (it == std::end(vars)) {
      return;
    }
    std::string_view val = it->second;
    // If value is something like: "756" instead of 756
    if (val.size() >= 2 && val[0] == '"') {
      val = val.substr(1, val.size() - 2);
    }
    // If that integer is in hexadecimal
    if (val.size() >= 2 && val.substr(0, 2) == "0x"sv) {
      input = util::from_hex<int>(val.substr(2));
    } else {
      input = (int) util::from_view(val);
    }
    input = parse_config_integer(it->second);
    vars.erase(it);
  }
@@ -1207,20 +1213,7 @@
    if (it == std::end(vars)) {
      return;
    }
    std::string_view val = it->second;
    // If value is something like: "756" instead of 756
    if (val.size() >= 2 && val[0] == '"') {
      val = val.substr(1, val.size() - 2);
    }
    // If that integer is in hexadecimal
    if (val.size() >= 2 && val.substr(0, 2) == "0x"sv) {
      input = util::from_hex<int>(val.substr(2));
    } else {
      input = util::from_view(val);
    input = parse_config_integer(it->second);
    }
    vars.erase(it);
  }
@@ -1792,7 +1785,7 @@
    bool_f(vars, "ds4_back_as_touchpad_click", input.ds4_back_as_touchpad_click);
    bool_f(vars, "motion_as_ds4", input.motion_as_ds4);
    bool_f(vars, "touchpad_as_ds4", input.touchpad_as_ds4);
    bool_f(vars, "ds5_inputtino_randomize_mac", input.ds5_inputtino_randomize_mac);
    bool_f(vars, "virtualhid_randomize_mac", input.virtualhid_randomize_mac);
    bool_f(vars, "mouse", input.mouse);
    bool_f(vars, "keyboard", input.keyboard);

@@ -275,10 +275,10 @@
    std::chrono::duration<double> key_repeat_period;  ///< Interval between repeated keyboard key events.
    std::string gamepad;  ///< Virtual controller backend selected by configuration.
    bool ds4_back_as_touchpad_click;  ///< Map the DS4 Back button to a touchpad click.
    bool motion_as_ds4;  ///< Expose motion controls through the DS4 protocol.
    bool touchpad_as_ds4;  ///< Expose touchpad input through the DS4 protocol.
    bool ds5_inputtino_randomize_mac;  ///< Randomize the inputtino DualSense MAC address.
    bool ds4_back_as_touchpad_click;  ///< Map Back/Select to touchpad click for PlayStation-style gamepads.
    bool motion_as_ds4;  ///< Prefer PlayStation-style emulation for client gamepads with motion controls.
    bool touchpad_as_ds4;  ///< Prefer PlayStation-style emulation for client gamepads with touchpad input.
    bool virtualhid_randomize_mac;  ///< Randomize the libvirtualhid virtual controller MAC address.
    bool keyboard;  ///< Enable keyboard input from clients.
    bool key_rightalt_to_key_win;  ///< Map the client Right Alt key to the Windows key.

@@ -8,22 +8,29 @@
// standard includes
#include <algorithm>
#include <charconv>
#include <filesystem>
#include <format>
#include <fstream>
#include <new>
#include <optional>
#include <string_view>
#include <utility>
#include <vector>
// lib includes
#include <boost/algorithm/string.hpp>
#include <boost/asio/ssl/context.hpp>
#include <boost/filesystem.hpp>
#include <lizardbyte/common/env.h>
#include <nlohmann/json.hpp>
#include <Simple-Web-Server/crypto.hpp>
#include <Simple-Web-Server/server_https.hpp>
#ifdef _WIN32
  #include "platform/virtualhid_input.h"
  #include "platform/windows/misc.h"
  #include "platform/windows/utf_utils.h"
  #include <vector>
  #include <Windows.h>
#endif
@@ -42,5 +49,6 @@
#include "platform/common.h"
#include "process.h"
#include "rtsp.h"
#include "system_tray.h"
#include "utility.h"
#include "uuid.h"
@@ -72,6 +80,28 @@
   */
  using https_handler_t = std::function<void(resp_https_t, req_https_t)>;
  namespace {
    using license_status_provider_t = std::function<lvh::LicenseResult()>;  ///< Provider for the current libvirtualhid license status.
    /**
     * @brief Return the current libvirtualhid license status provider.
     *
     * Unit-test builds expose a mutable provider so the HTTP fixture can avoid
     * contacting an installed Windows broker. Production builds keep the
     * provider const and always call libvirtualhid directly.
     *
     * @return License status provider for the current build.
     */
    auto &virtual_input_license_status_provider() {
#ifdef SUNSHINE_TESTS
      static license_status_provider_t status_provider = lvh::get_license_status;
#else
      static const license_status_provider_t status_provider = lvh::get_license_status;
#endif
      return status_provider;
    }
  }  // namespace
  /**
   * @brief Client certificate operations accepted by the configuration API.
   */
@@ -80,6 +110,48 @@
    REMOVE  ///< Remove client
  };
  /**
   * @brief Overwrite a request-local sensitive string when leaving scope.
   */
  class scoped_sensitive_string_clear_t {
  public:
    /**
     * @brief Register a sensitive string for best-effort clearing.
     *
     * @param value Mutable sensitive string.
     */
    explicit scoped_sensitive_string_clear_t(std::string &value):
        value_ {value} {}
    scoped_sensitive_string_clear_t(const scoped_sensitive_string_clear_t &) = delete;
    scoped_sensitive_string_clear_t &operator=(const scoped_sensitive_string_clear_t &) = delete;
    /**
     * @brief Overwrite and clear the registered string.
     */
    ~scoped_sensitive_string_clear_t() {
      std::fill(value_.begin(), value_.end(), '\0');
      value_.clear();
    }
  private:
    std::string &value_;  ///< Sensitive request-local string.
  };
#ifdef SUNSHINE_TESTS
  void set_virtual_input_license_status_provider_for_testing(virtual_input_license_status_provider_t status_provider) {
    virtual_input_license_status_provider() = std::move(status_provider);
  }
  void reset_virtual_input_license_status_provider_for_testing() {
    virtual_input_license_status_provider() = lvh::get_license_status;
  }
  void clear_sensitive_string_for_testing(std::string &value) {
    const scoped_sensitive_string_clear_t clear_value {value};
  }
#endif
  // CSRF token management
  /**
   * @brief CSRF token value and its expiration deadline.
@@ -101,8 +173,304 @@
   * @brief Amount of time a generated CSRF token remains valid.
   */
  constexpr auto CSRF_TOKEN_LIFETIME = std::chrono::hours(1);  // Tokens valid for 1 hour
  constexpr auto LIBVIRTUALHID_MINIMUM_VERSION = ""sv;  ///< Minimum supported libvirtualhid driver version; empty means any version.
  constexpr auto VIGEMBUS_MINIMUM_VERSION = "1.17.0.0"sv;  ///< Minimum supported ViGEmBus fallback driver version.  // NOSONAR(cpp:S1313): not an IP address
  /**
   * @brief Parse one dotted driver-version component.
   *
   * @param part Version component text.
   * @return Parsed component value, or empty when invalid.
   */
  std::optional<unsigned int> parse_driver_version_part(std::string_view part) {
    if (part.empty()) {
      return std::nullopt;
    }
    unsigned int value = 0;
    const auto *begin = part.data();
    const auto *end = part.data() + part.size();
    const auto [ptr, ec] = std::from_chars(begin, end, value);
    if (ec != std::errc {} || ptr != end) {
      return std::nullopt;
    }
    return value;
  }
  /**
   * @brief Parse a dotted driver version into numeric components.
   *
   * @param version Driver version text.
   * @return Parsed version parts, or empty when invalid.
   */
  std::optional<std::vector<unsigned int>> parse_driver_version(std::string_view version) {
    if (version.empty()) {
      return std::nullopt;
    }
    std::vector<unsigned int> parts;
    std::size_t start = 0;
    while (start <= version.size()) {
      const auto dot = version.find('.', start);
      const auto length = dot == std::string_view::npos ? std::string_view::npos : dot - start;
      const auto part = parse_driver_version_part(version.substr(start, length));
      if (!part.has_value()) {
        return std::nullopt;
      }
      parts.push_back(*part);
      if (dot == std::string_view::npos) {
        break;
      }
      start = dot + 1;
    }
    return parts;
  }
  bool is_driver_version_supported(std::string_view version, std::string_view minimum_version) {
    if (minimum_version.empty()) {
      return true;
    }
    const auto version_parts = parse_driver_version(version);
    const auto minimum_parts = parse_driver_version(minimum_version);
    if (!version_parts || !minimum_parts) {
      return false;
    }
    const auto part_count = std::max(version_parts->size(), minimum_parts->size());
    for (std::size_t i = 0; i < part_count; ++i) {
      const auto version_part = i < version_parts->size() ? (*version_parts)[i] : 0U;
      const auto minimum_part = i < minimum_parts->size() ? (*minimum_parts)[i] : 0U;
      if (version_part != minimum_part) {
        return version_part > minimum_part;
      }
    }
    return true;
  }
  nlohmann::json build_driver_status(bool installed, const std::string &version, std::string_view minimum_version) {
    const auto minimum_version_text = std::string {minimum_version};
    nlohmann::json output_tree;
    output_tree["installed"] = installed;
    output_tree["version"] = version;
    output_tree["minimum_version"] = minimum_version_text;
    output_tree["supported_versions"] = minimum_version.empty() ? "Any" : std::format(">= {}", minimum_version_text);
    output_tree["version_compatible"] = installed && is_driver_version_supported(version, minimum_version);
    return output_tree;
  }
  /**
   * @brief Return a stable Web UI name for a libvirtualhid license state.
   *
   * @param state License state.
   * @return Lowercase state name.
   */
  std::string_view virtualhid_license_state_name(lvh::LicenseState state) {
    using enum lvh::LicenseState;
    switch (state) {
      case unlicensed:
        return "unlicensed";
      case licensed:
        return "licensed";
      case expired:
        return "expired";
      case disabled:
        return "disabled";
      case invalid:
        return "invalid";
      case unavailable:
      default:
        return "unavailable";
    }
  }
  nlohmann::json build_virtualhid_license_status(const lvh::LicenseResult &result) {
    const auto &license = result.license;
    nlohmann::json output_tree;
    output_tree["operation_ok"] = result.status.ok();
    output_tree["service_available"] = license.service_available;
    output_tree["state"] = virtualhid_license_state_name(license.state);
    output_tree["licensed"] = license.licensed();
    output_tree["active_devices"] = license.active_devices;
    output_tree["activation_limit"] = license.activation_limit;
    output_tree["activation_usage"] = license.activation_usage;
    output_tree["plan_name"] = license.plan_name;
    output_tree["customer_email"] = license.customer_email;
    output_tree["expires_at"] = license.expires_at;
    output_tree["message"] = license.message;
    output_tree["purchase_url"] = license.purchase_url;
    output_tree["manage_account_url"] = license.manage_account_url;
    output_tree["error"] = result.status.ok() ? "" : result.status.message();
    return output_tree;
  }
  namespace {
    /**
     * @brief Handle a virtual-input license request using the configured status provider.
     *
     * @param response HTTP response object.
     * @param request Authenticated HTTP request.
     */
    void get_virtual_input_license(const resp_https_t &response, const req_https_t &request) {
      if (!authenticate(response, request)) {
        return;
      }
      print_req(request);
      send_response(response, build_virtualhid_license_status(virtual_input_license_status_provider()()));
    }
  }  // namespace
#ifdef _WIN32
  /**
   * @brief RAII wrapper for a Windows registry key handle.
   */
  class registry_key_t {
  public:
    /**
     * @brief Construct an empty registry key wrapper.
     */
    registry_key_t() = default;
    /**
     * @brief Copy construction is disabled because the wrapper owns a handle.
     */
    registry_key_t(const registry_key_t &) = delete;
    /**
     * @brief Copy assignment is disabled because the wrapper owns a handle.
     *
     * @return This registry key wrapper.
     */
    registry_key_t &operator=(const registry_key_t &) = delete;
    /**
     * @brief Close the owned registry key handle.
     */
    ~registry_key_t() {
      close();
    }
    /**
     * @brief Get the owned registry key handle.
     *
     * @return Registry key handle.
     */
    HKEY get() const {
      return handle;
    }
    /**
     * @brief Prepare the wrapper to receive a registry key handle.
     *
     * @return Address of the wrapped handle.
     */
    HKEY *put() {
      close();
      return &handle;
    }
  private:
    /**
     * @brief Close the owned registry key handle if one is open.
     */
    void close() {
      if (handle) {
        RegCloseKey(handle);
        handle = nullptr;
      }
    }
    HKEY handle = nullptr;  ///< Owned Windows registry key handle.
  };
  /**
   * @brief Read a string value from a Windows registry key.
   *
   * @param key Registry key to query.
   * @param value_name Registry value name.
   * @return Registry string value, or empty when unavailable.
   */
  std::optional<std::wstring> read_registry_string_value(HKEY key, const wchar_t *value_name) {
    DWORD value_type = 0;
    DWORD value_size = 0;
    if (RegGetValueW(key, nullptr, value_name, RRF_RT_REG_SZ, &value_type, nullptr, &value_size) != ERROR_SUCCESS || value_size == 0) {
      return std::nullopt;
    }
    std::wstring value(value_size / sizeof(wchar_t), L'\0');
    if (RegGetValueW(key, nullptr, value_name, RRF_RT_REG_SZ, &value_type, value.data(), &value_size) != ERROR_SUCCESS) {
      return std::nullopt;
    }
    while (!value.empty() && value.back() == L'\0') {
      value.pop_back();
    }
    return value;
  }
  /**
   * @brief Read the installed libvirtualhid driver version from the Windows device registry.
   *
   * @return Driver version string, or empty when unavailable.
   */
  std::string read_libvirtualhid_driver_version() {
    registry_key_t root_key;
    if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SYSTEM\\CurrentControlSet\\Enum\\ROOT\\LIBVIRTUALHID", 0, KEY_READ, root_key.put()) != ERROR_SUCCESS) {
      return {};
    }
    for (DWORD index = 0;; ++index) {
      std::wstring subkey_name(256, L'\0');
      auto subkey_name_size = static_cast<DWORD>(subkey_name.size());
      const auto enum_status = RegEnumKeyExW(root_key.get(), index, subkey_name.data(), &subkey_name_size, nullptr, nullptr, nullptr, nullptr);
      if (enum_status == ERROR_NO_MORE_ITEMS) {
        break;
      }
      if (enum_status != ERROR_SUCCESS) {
        continue;
      }
      std::wstring device_key_path = L"SYSTEM\\CurrentControlSet\\Enum\\ROOT\\LIBVIRTUALHID\\";
      device_key_path.append(subkey_name, 0, subkey_name_size);
      registry_key_t device_key;
      if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, device_key_path.c_str(), 0, KEY_READ, device_key.put()) != ERROR_SUCCESS) {
        continue;
      }
      const auto driver_key_suffix = read_registry_string_value(device_key.get(), L"Driver");
      if (!driver_key_suffix) {
        continue;
      }
      std::wstring driver_key_path = L"SYSTEM\\CurrentControlSet\\Control\\Class\\";
      driver_key_path += *driver_key_suffix;
      registry_key_t driver_key;
      if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, driver_key_path.c_str(), 0, KEY_READ, driver_key.put()) != ERROR_SUCCESS) {
        continue;
      }
      if (const auto version = read_registry_string_value(driver_key.get(), L"DriverVersion")) {
        return utf_utils::to_utf8(*version);
      }
    }
    return {};
  }
#endif
  /**
   * @brief Log the request details.
   * @param request The HTTP request object.
   */
@@ -1431,131 +1799,162 @@
  }
  /**
   * @brief Build libvirtualhid driver version and installation status.
   * @brief Get ViGEmBus driver version and installation status.
   * @param response The HTTP response object.
   * @param request The HTTP request object.
   *
   * @api_examples{/api/vigembus/status| GET| null}
   * @return libvirtualhid driver status JSON.
   */
  void getViGEmBusStatus(const resp_https_t &response, const req_https_t &request) {
    if (!authenticate(response, request)) {
      return;
  nlohmann::json get_virtualhid_driver_status() {
#ifdef _WIN32
    const auto version_str = read_libvirtualhid_driver_version();
    auto output_tree = build_driver_status(false, version_str, LIBVIRTUALHID_MINIMUM_VERSION);
    bool requires_installed_driver = true;
    std::string backend_name;
    std::string runtime_error_message;
    try {
      const auto runtime = platf::virtualhid::create_runtime();
      if (runtime) {
        const auto &capabilities = runtime->capabilities();
        backend_name = capabilities.backend_name;
        requires_installed_driver = capabilities.requires_installed_driver;
        output_tree = build_driver_status(capabilities.supports_gamepad, version_str, LIBVIRTUALHID_MINIMUM_VERSION);
      }
    } catch (const std::bad_alloc &exception) {
      runtime_error_message = exception.what();
    }
    output_tree["backend_name"] = backend_name;
    output_tree["requires_installed_driver"] = requires_installed_driver;
    if (!runtime_error_message.empty()) {
    print_req(request);
      output_tree["error"] = runtime_error_message;
    }
#else
    auto output_tree = build_driver_status(false, "", LIBVIRTUALHID_MINIMUM_VERSION);
    output_tree["error"] = "libvirtualhid driver status is only available on Windows";
    output_tree["backend_name"] = "";
    output_tree["requires_installed_driver"] = false;
#endif
    nlohmann::json output_tree;
    return output_tree;
  }
  /**
   * @brief Build ViGEmBus fallback driver version and installation status.
   *
   * @return ViGEmBus fallback driver status JSON.
   */
  nlohmann::json get_vigembus_driver_status() {
#ifdef _WIN32
    std::string version_str;
    bool installed = false;
    bool version_compatible = false;
    // Check if ViGEmBus driver exists
    std::filesystem::path driver_path = std::filesystem::path(std::getenv("SystemRoot") ? std::getenv("SystemRoot") : "C:\\Windows") / "System32" / "drivers" / "ViGEmBus.sys";
    if (std::filesystem::exists(driver_path)) {
    std::string system_root;
    if (!lizardbyte::common::get_env("SystemRoot", system_root)) {
      system_root = "C:\\Windows";
    }
    const std::filesystem::path driver_path = std::filesystem::path(system_root) / "System32" / "drivers" / "ViGEmBus.sys";
    const auto installed = std::filesystem::exists(driver_path);
    if (installed) {
      platf::getFileVersionInfo(driver_path, version_str);
      installed = platf::getFileVersionInfo(driver_path, version_str);
      if (installed) {
        // Parse version string to check compatibility (>= 1.17.0.0)
        std::vector<std::string> version_parts;
        std::stringstream ss(version_str);
        std::string part;
        while (std::getline(ss, part, '.')) {
          version_parts.push_back(part);
        }
        if (version_parts.size() >= 2) {
          int major = std::stoi(version_parts[0]);
          int minor = std::stoi(version_parts[1]);
          version_compatible = (major > 1) || (major == 1 && minor >= 17);
        }
      }
    }
    output_tree["installed"] = installed;
    output_tree["version"] = version_str;
    output_tree["version_compatible"] = version_compatible;
    output_tree["packaged_version"] = VIGEMBUS_PACKAGED_VERSION;
    auto output_tree = build_driver_status(installed, version_str, VIGEMBUS_MINIMUM_VERSION);
#else
    auto output_tree = build_driver_status(false, "", VIGEMBUS_MINIMUM_VERSION);
    output_tree["error"] = "ViGEmBus is only available on Windows";
    output_tree["installed"] = false;
    output_tree["version"] = "";
    output_tree["version_compatible"] = false;
    output_tree["packaged_version"] = "";
#endif
    send_response(response, output_tree);
    return output_tree;
  }
  /**
   * @brief Get virtual input driver version and installation status.
   * @brief Install ViGEmBus driver with elevated permissions.
   * @param response The HTTP response object.
   * @param request The HTTP request object.
   *
   * @api_examples{/api/vigembus/install| POST| null}
   * @api_examples{/api/virtual-input/status| GET| null}
   */
  void installViGEmBus(const resp_https_t &response, const req_https_t &request) {
  void getVirtualInputStatus(const resp_https_t &response, const req_https_t &request) {
    if (!authenticate(response, request)) {
      return;
    }
    std::string client_id = get_client_id(request);
    if (!validate_csrf_token(response, request, client_id)) {
      return;
    }
    print_req(request);
    nlohmann::json output_tree;
    output_tree["virtualhid"] = get_virtualhid_driver_status();
    output_tree["vigembus"] = get_vigembus_driver_status();
    send_response(response, output_tree);
  }
#ifdef _WIN32
    // Get the path to the packaged ViGEmBus installer.
    const std::filesystem::path installer_path = platf::appdata().parent_path() / "third-party" / "vigembus_installer.exe";
  /**
   * @brief Get the current libvirtualhid machine license status.
   *
   * @param response HTTP response object.
   * @param request Authenticated HTTP request.
   *
   * @api_examples{/api/virtual-input/license| GET| null}
   */
  void getVirtualInputLicense(const resp_https_t &response, const req_https_t &request) {
    get_virtual_input_license(response, request);
  }
  /**
   * @brief Activate, validate, or deactivate the libvirtualhid machine license.
    if (!std::filesystem::exists(installer_path)) {
   *
   * Submitted license keys are used only for the synchronous broker call. They are
   * never logged or saved in Sunshine's configuration, and extracted mutable copies
   * are overwritten before the handler returns.
   *
   * @param response HTTP response object.
   * @param request Authenticated HTTP request with a JSON action.
   *
   * @api_examples{/api/virtual-input/license| POST| {"action":"validate"}}
   */
  void updateVirtualInputLicense(const resp_https_t &response, const req_https_t &request) {
    if (!authenticate(response, request)) {
      output_tree["status"] = false;
      output_tree["error"] = "ViGEmBus installer not found";
      send_response(response, output_tree);
      return;
    }
    // Run the installer with elevated permissions
    std::error_code ec;
    boost::filesystem::path working_dir = boost::filesystem::path(installer_path.string()).parent_path();
    boost::process::v1::environment env = boost::this_process::environment();
    // Run with elevated permissions, non-interactive
    const std::string install_cmd = std::format("{} /quiet", installer_path.string());
    auto child = platf::run_command(true, false, install_cmd, working_dir, env, nullptr, ec, nullptr);
    if (ec) {
      output_tree["status"] = false;
      output_tree["error"] = "Failed to start installer: " + ec.message();
      send_response(response, output_tree);
    const auto client_id = get_client_id(request);
    if (!validate_csrf_token(response, request, client_id)) {
      return;
    }
    print_req(request);
    try {
      std::stringstream content;
      content << request->content.rdbuf();
      auto input_tree = nlohmann::json::parse(content);
    // Wait for the installer to complete
    child.wait(ec);
      const auto action = input_tree.value("action", "");
      lvh::LicenseResult result;
      if (action == "activate") {
        auto license_key = input_tree.value("license_key", "");
        input_tree["license_key"] = "";
        if (license_key.empty()) {
          bad_request(response, request, "License key is required");
          return;
        }
        const scoped_sensitive_string_clear_t clear_license_key {license_key};
    if (ec) {
      output_tree["status"] = false;
      output_tree["error"] = "Installer failed: " + ec.message();
    } else {
      int exit_code = child.exit_code();
      output_tree["status"] = (exit_code == 0);
      output_tree["exit_code"] = exit_code;
      if (exit_code != 0) {
        output_tree["error"] = std::format("Installer exited with code {}", exit_code);
        result = lvh::activate_license(license_key);
      } else if (action == "validate") {
        result = lvh::validate_license();
      } else if (action == "deactivate") {
        result = lvh::deactivate_license();
      } else {
        bad_request(response, request, "Unknown license action");
        return;
      }
#if defined(_WIN32) && defined(SUNSHINE_TRAY) && SUNSHINE_TRAY >= 1
      system_tray::update_tray_virtualhid_license(result.license, false);
#endif
      send_response(response, build_virtualhid_license_status(result));
    } catch (const nlohmann::json::exception &) {
      bad_request(response, request, "Invalid license request");
    }
#else
    output_tree["status"] = false;
    output_tree["error"] = "ViGEmBus installation is only available on Windows";
#endif
    send_response(response, output_tree);
  }
  /**
@@ -1812,8 +2211,9 @@
    server.resource["^/api/logs$"]["GET"] = getLogs;
    server.resource["^/api/reset-display-device-persistence$"]["POST"] = resetDisplayDevicePersistence;
    server.resource["^/api/restart$"]["POST"] = restart;
    server.resource["^/api/vigembus/status$"]["GET"] = getViGEmBusStatus;
    server.resource["^/api/vigembus/install$"]["POST"] = installViGEmBus;
    server.resource["^/api/virtual-input/license$"]["GET"] = getVirtualInputLicense;
    server.resource["^/api/virtual-input/license$"]["POST"] = updateVirtualInputLicense;
    server.resource["^/api/virtual-input/status$"]["GET"] = getVirtualInputStatus;
    // static/dynamic resources
    server.resource["^/images/sunshine.ico$"]["GET"] = getFaviconImage;

@@ -6,9 +6,12 @@
// standard includes
#include <filesystem>
#include <functional>
#include <memory>
#include <string>
#include <string_view>
// lib includes
#include <libvirtualhid/license.hpp>
#include <nlohmann/json.hpp>
#include <Simple-Web-Server/server_https.hpp>
@@ -74,6 +77,79 @@
  void browseDirectory(const resp_https_t &response, const req_https_t &request);
  void getLocale(const resp_https_t &response, const req_https_t &request);
  void getCSRFToken(const resp_https_t &response, const req_https_t &request);
  /**
   * @brief Check whether a detected driver version satisfies a minimum version.
   *
   * Empty minimum versions accept any detected version. Non-empty minimum versions
   * require a fully numeric dotted version string.
   *
   * @param version Detected driver version.
   * @param minimum_version Minimum supported driver version, or empty for any version.
   * @return True when the driver version is supported.
   */
  bool is_driver_version_supported(std::string_view version, std::string_view minimum_version);
  /**
   * @brief Build a standard driver status response.
   *
   * @param installed Whether the driver was detected.
   * @param version Detected driver version.
   * @param minimum_version Minimum supported driver version, or empty for any version.
   * @return Driver status JSON object.
   */
  nlohmann::json build_driver_status(bool installed, const std::string &version, std::string_view minimum_version);
  /**
   * @brief Convert a libvirtualhid license result into a Web UI response.
   *
   * @param result License operation result.
   * @return License status JSON object without the submitted license key.
   */
  nlohmann::json build_virtualhid_license_status(const lvh::LicenseResult &result);
  /**
   * @brief Build libvirtualhid driver version and installation status.
   *
   * @return libvirtualhid driver status JSON.
   */
  nlohmann::json get_virtualhid_driver_status();
  /**
   * @brief Build ViGEmBus fallback driver version and installation status.
   *
   * @return ViGEmBus fallback driver status JSON.
   */
  nlohmann::json get_vigembus_driver_status();
  void getVirtualInputStatus(const resp_https_t &response, const req_https_t &request);
  void getVirtualInputLicense(const resp_https_t &response, const req_https_t &request);
  void updateVirtualInputLicense(const resp_https_t &response, const req_https_t &request);
#ifdef SUNSHINE_TESTS
  using virtual_input_license_status_provider_t = std::function<lvh::LicenseResult()>;  ///< Test provider for current libvirtualhid license status.
  /**
   * @brief Replace the virtual-input license status provider for unit tests.
   *
   * @param status_provider Provider returning the license status for the response.
   */
  void set_virtual_input_license_status_provider_for_testing(virtual_input_license_status_provider_t status_provider);
  /**
   * @brief Restore the production virtual-input license status provider after a unit test.
   */
  void reset_virtual_input_license_status_provider_for_testing();
  /**
   * @brief Exercise request-local sensitive string clearing for unit tests.
   *
   * @param value Mutable sensitive string to overwrite and clear.
   */
  void clear_sensitive_string_for_testing(std::string &value);
#endif
  // Browse helper functions (also exposed for unit testing)
  /**

@@ -9,9 +9,15 @@
}
// standard includes
#include <algorithm>
#include <bitset>
#include <chrono>
#include <cmath>
#include <functional>
#include <list>
#include <memory>
#include <mutex>
#include <string>
#include <string_view>
#include <thread>
#include <unordered_map>
@@ -186,8 +192,12 @@
    ~gamepad_t() {
      if (id >= 0) {
        task_pool.push([id = this->id]() {
          free_gamepad(platf_input, id);
        });
        if (task_pool.running()) {
          task_pool.push([id = this->id]() {
            ::input::free_gamepad(platf_input, id);
          });
        } else {
          ::input::free_gamepad(platf_input, id);
        }
      }
    }
@@ -265,6 +275,117 @@
  };
  /**
   * @brief Hash string-like session identifiers without allocating temporary strings.
   */
  struct transparent_string_hash_t {
    using is_transparent = void;  ///< Enable heterogeneous unordered-map lookup.
    /**
     * @brief Hash a string view.
     *
     * @param value Session identifier to hash.
     * @return Hash value for the supplied identifier.
     */
    std::size_t operator()(const std::string_view value) const noexcept {
      return std::hash<std::string_view> {}(value);
    }
  };
  using retained_input_map_t = std::unordered_map<
    std::string,
    std::shared_ptr<input_t>,
    transparent_string_hash_t,
    std::equal_to<>>;  ///< Retained inputs keyed by paired-client identity.
  /**
   * @brief Synchronized storage for retained input sessions.
   */
  struct retained_input_state_t {
    std::mutex mutex;  ///< Synchronizes retained session access across transport threads.
    retained_input_map_t inputs;  ///< Paused input sessions keyed by paired-client identity.
  };
  /**
   * @brief Access process-wide retained input session storage.
   *
   * @return Mutable retained input session state.
   */
  retained_input_state_t &retained_input_state() {
    static retained_input_state_t state;
    return state;
  }
  /**
   * @brief Execute lifecycle work on the input task thread when it is running.
   *
   * @tparam Function Callable type.
   * @param function Lifecycle operation to execute.
   */
  template<typename Function>
  void dispatch_input_task(Function &&function) {
    if (task_pool.running()) {
      task_pool.push(std::forward<Function>(function));
    } else {
      std::forward<Function>(function)();
    }
  }
  /**
   * @brief Destroy the virtual gamepads owned by retained input sessions.
   *
   * @param input Retained input session whose gamepads should be destroyed.
   */
  void destroy_gamepads(const std::shared_ptr<input_t> &input) {
    for (auto &gamepad : input->gamepads) {
      if (gamepad.back_timeout_id) {
        task_pool.cancel(gamepad.back_timeout_id);
        gamepad.back_timeout_id = nullptr;
      }
      if (gamepad.id >= 0) {
        ::input::free_gamepad(platf_input, gamepad.id);
        gamepad.id = -1;
      }
      gamepad.gamepad_state = {};
      gamepad.back_button_state = button_state_e::NONE;
    }
  }
  /**
   * @brief Destroy the virtual gamepads owned by retained input sessions.
   *
   * @param inputs Retained input sessions whose gamepads should be destroyed.
   */
  void destroy_gamepads(const retained_input_map_t &inputs) {
    for (const auto &[session_id, input] : inputs) {
      static_cast<void>(session_id);
      destroy_gamepads(input);
    }
  }
  /**
   * @brief Rebind retained input state to a resumed stream mailbox.
   *
   * @param input Retained input state.
   * @param mail Mailbox for the resumed stream connection.
   */
  void rebind_input(const std::shared_ptr<input_t> &input, const safe::mail_t &mail) {
    input->touch_port_event = mail->event<input::touch_port_t>(mail::touch_port);
    input->feedback_queue = mail->queue<platf::gamepad_feedback_msg_t>(mail::gamepad_feedback);
    for (int client_index = 0; client_index < input->gamepads.size(); ++client_index) {
      auto &gamepad = input->gamepads[client_index];
      if (gamepad.id < 0) {
        continue;
      }
      if (platf::rebind_gamepad(platf_input, {gamepad.id, static_cast<std::uint8_t>(client_index)}, input->feedback_queue) != 0) {
        free_id(gamepadMask, gamepad.id);
        gamepad.id = -1;
      }
    }
  }
  /**
   * @brief Apply shortcut based on VKEY
   * @param keyCode The VKEY code
   * @return 0 if no shortcut applied, > 0 if shortcut applied.
@@ -610,8 +731,8 @@
    This final operation is a bit weird and has been brought about with lots of trial and error. A better
    way to do this may exist.
    Basically, this is what makes the touchscreen map to the coordinates inputtino expects properly.
    Since inputtino's dimensions are now logical (because scaling breaks everything otherwise), using the previous
    Basically, this is what makes the touchscreen map to the logical virtual input coordinates properly.
    Since the virtual input dimensions are logical (because scaling breaks everything otherwise), using the previous
    x and y coordinates would be incorrect when screens are scaled, because the touch port is smaller (or larger)
    by a factor (that factor is touch_port.scalar_tpcoords), and that factor must be used to account for that difference
    when moving the cursor. Otherwise, it will move either slower or faster than your finger proportionally to
@@ -1037,7 +1158,7 @@
   *
   * @param packet Protocol packet being processed.
   */
  void passthrough(PNV_UNICODE_PACKET packet) {
  void passthrough(const NV_UNICODE_PACKET *packet) {
    if (!config::input.keyboard) {
      return;
    }
@@ -1047,6 +1168,40 @@
  }
  /**
   * @brief Allocate a virtual gamepad for a client-relative controller slot.
   *
   * @param input Stream input state.
   * @param client_index Client-relative controller index.
   * @param arrival Client-reported controller metadata.
   * @return Assigned global gamepad slot, or -1 when allocation fails.
   */
  int alloc_gamepad(std::shared_ptr<input_t> &input, int client_index, const platf::gamepad_arrival_t &arrival) {
    if (client_index < 0 || client_index >= input->gamepads.size()) {
      BOOST_LOG(warning) << "ControllerNumber out of range ["sv << client_index << ']';
      return -1;
    }
    auto &gamepad = input->gamepads[client_index];
    if (gamepad.id >= 0) {
      BOOST_LOG(warning) << "ControllerNumber already allocated ["sv << client_index << ']';
      return gamepad.id;
    }
    const auto id = alloc_id(gamepadMask);
    if (id < 0) {
      return -1;
    }
    if (platf::alloc_gamepad(platf_input, {id, static_cast<std::uint8_t>(client_index)}, arrival, input->feedback_queue)) {
      free_id(gamepadMask, id);
      return -1;
    }
    gamepad.id = id;
    return id;
  }
  /**
   * @brief Called to pass a controller arrival message to the platform backend.
   * @param input The input context pointer.
   * @param packet The controller arrival packet.
@@ -1056,34 +1211,12 @@
      return;
    }
    if (packet->controllerNumber < 0 || packet->controllerNumber >= input->gamepads.size()) {
      BOOST_LOG(warning) << "ControllerNumber out of range ["sv << packet->controllerNumber << ']';
      return;
    }
    if (input->gamepads[packet->controllerNumber].id >= 0) {
      BOOST_LOG(warning) << "ControllerNumber already allocated ["sv << packet->controllerNumber << ']';
      return;
    }
    platf::gamepad_arrival_t arrival {
      packet->type,
      util::endian::little(packet->capabilities),
      util::endian::little(packet->supportedButtonFlags),
    };
    static_cast<void>(alloc_gamepad(input, packet->controllerNumber, arrival));
    auto id = alloc_id(gamepadMask);
    if (id < 0) {
      return;
    }
    // Allocate a new gamepad
    if (platf::alloc_gamepad(platf_input, {id, packet->controllerNumber}, arrival, input->feedback_queue)) {
      free_id(gamepadMask, id);
      return;
    }
    input->gamepads[packet->controllerNumber].id = id;
  }
  /**
@@ -1112,54 +1245,81 @@
  }
  /**
   * @brief Shared normalized data prepared for a touch or pen event.
   */
  struct absolute_pointer_data_t {
    platf::touch_port_t touch_port;  ///< Monitor-local touch port.
    std::pair<float, float> coords;  ///< Normalized monitor-local coordinates.
    std::uint16_t rotation;  ///< Normalized rotation in degrees.
    std::pair<float, float> contact_area;  ///< Scaled major and minor contact axes.
  };
  /**
   * @brief Normalize the fields shared by touch and pen packets.
   * @brief Called to pass a touch message to the platform backend.
   * @param input The input context pointer.
   * @param packet The touch packet.
   *
   * @tparam Packet Pointer type for a Moonlight touch or pen packet.
   * @param input Input context that supplies the current touch-port metadata.
   * @param packet Touch or pen packet to normalize.
   * @return Normalized pointer data, or `std::nullopt` when input is disabled or dimensions are invalid.
   */
  void passthrough(std::shared_ptr<input_t> &input, PSS_TOUCH_PACKET packet) {
  template<typename Packet>
  std::optional<absolute_pointer_data_t> prepare_absolute_pointer_data(std::shared_ptr<input_t> &input, Packet packet) {
    if (!config::input.mouse) {
      return std::nullopt;
      return;
    }
    auto coords = client_to_touchport(
      input,
    // Convert the client normalized coordinates to touchport coordinates
    auto coords = client_to_touchport(input, {from_clamped_netfloat(packet->x, 0.0f, 1.0f) * 65535.f, from_clamped_netfloat(packet->y, 0.0f, 1.0f) * 65535.f}, {65535.f, 65535.f});
      {from_clamped_netfloat(packet->x, 0.0f, 1.0f) * 65535.f, from_clamped_netfloat(packet->y, 0.0f, 1.0f) * 65535.f},
      {65535.f, 65535.f}
    );
    if (!coords) {
      return;
      return std::nullopt;
    }
    auto touch_port = monitor_touch_port(input->touch_port, *coords);
    auto &touch_port = input->touch_port;
    auto abs_port = monitor_touch_port(touch_port, *coords);
    if (!abs_port) {
      return;
    if (!touch_port) {
      return std::nullopt;
    }
    // Normalize rotation value to 0-359 degree range
    auto rotation = util::endian::little(packet->rotation);
    if (rotation != LI_ROT_UNKNOWN) {
      rotation %= 360;
    }
    // Normalize the contact area based on the touchport
    auto contact_area = scale_client_contact_area(
    const auto contact_area = scale_client_contact_area(
      {from_clamped_netfloat(packet->contactAreaMajor, 0.0f, 1.0f) * 65535.f,
       from_clamped_netfloat(packet->contactAreaMinor, 0.0f, 1.0f) * 65535.f},
      rotation,
      {abs_port->width / 65535.f, abs_port->height / 65535.f}
      {touch_port->width / 65535.f, touch_port->height / 65535.f}
    );
    return absolute_pointer_data_t {*touch_port, *coords, rotation, contact_area};
  }
  /**
   * @brief Called to pass a touch message to the platform backend.
   * @param input The input context pointer.
   * @param packet The touch packet.
   */
  void passthrough(std::shared_ptr<input_t> &input, PSS_TOUCH_PACKET packet) {
    const auto pointer_data = prepare_absolute_pointer_data(input, packet);
    if (!pointer_data) {
      return;
    }
    platf::touch_input_t touch {
      packet->eventType,
      rotation,
      pointer_data->rotation,
      util::endian::little(packet->pointerId),
      coords->first,
      coords->second,
      pointer_data->coords.first,
      pointer_data->coords.second,
      from_clamped_netfloat(packet->pressureOrDistance, 0.0f, 1.0f),
      contact_area.first,
      contact_area.second,
      pointer_data->contact_area.first,
      pointer_data->contact_area.second,
    };
    platf::touch_update(input->client_context.get(), pointer_data->touch_port, touch);
    platf::touch_update(input->client_context.get(), *abs_port, touch);
  }
  /**
@@ -1168,51 +1328,25 @@
   * @param packet The pen packet.
   */
  void passthrough(std::shared_ptr<input_t> &input, PSS_PEN_PACKET packet) {
    if (!config::input.mouse) {
      return;
    }
    // Convert the client normalized coordinates to touchport coordinates
    auto coords = client_to_touchport(input, {from_clamped_netfloat(packet->x, 0.0f, 1.0f) * 65535.f, from_clamped_netfloat(packet->y, 0.0f, 1.0f) * 65535.f}, {65535.f, 65535.f});
    if (!coords) {
      return;
    }
    auto &touch_port = input->touch_port;
    auto abs_port = monitor_touch_port(touch_port, *coords);
    if (!abs_port) {
    const auto pointer_data = prepare_absolute_pointer_data(input, packet);
    if (!pointer_data) {
      return;
    }
    // Normalize rotation value to 0-359 degree range
    auto rotation = util::endian::little(packet->rotation);
    if (rotation != LI_ROT_UNKNOWN) {
      rotation %= 360;
    }
    // Normalize the contact area based on the touchport
    auto contact_area = scale_client_contact_area(
      {from_clamped_netfloat(packet->contactAreaMajor, 0.0f, 1.0f) * 65535.f,
       from_clamped_netfloat(packet->contactAreaMinor, 0.0f, 1.0f) * 65535.f},
      rotation,
      {abs_port->width / 65535.f, abs_port->height / 65535.f}
    );
    platf::pen_input_t pen {
      packet->eventType,
      packet->toolType,
      packet->penButtons,
      packet->tilt,
      rotation,
      coords->first,
      coords->second,
      pointer_data->rotation,
      pointer_data->coords.first,
      pointer_data->coords.second,
      from_clamped_netfloat(packet->pressureOrDistance, 0.0f, 1.0f),
      pointer_data->contact_area.first,
      pointer_data->contact_area.second,
      contact_area.first,
      contact_area.second,
    };
    platf::pen_update(input->client_context.get(), *abs_port, pen);
    platf::pen_update(input->client_context.get(), pointer_data->touch_port, pen);
  }
  /**
@@ -1332,20 +1466,12 @@
    // If this is an event for a new gamepad, create the gamepad now. Ideally, the client would
    // send a controller arrival instead of this but it's still supported for legacy clients.
    if ((packet->activeGamepadMask & (1 << packet->controllerNumber)) && gamepad.id < 0) {
      auto id = alloc_id(gamepadMask);
      if (id < 0) {
        return;
      }
      if (platf::alloc_gamepad(platf_input, {id, (uint8_t) packet->controllerNumber}, {}, input->feedback_queue)) {
        free_id(gamepadMask, id);
      if (alloc_gamepad(input, packet->controllerNumber, {}) < 0) {
        return;
      }
      gamepad.id = id;
    } else if (!(packet->activeGamepadMask & (1 << packet->controllerNumber)) && gamepad.id >= 0) {
      // If this is the final event for a gamepad being removed, free the gamepad and return.
      free_gamepad(platf_input, gamepad.id);
      ::input::free_gamepad(platf_input, gamepad.id);
      gamepad.id = -1;
      return;
    }
@@ -1782,7 +1908,7 @@
        passthrough(input, (PNV_KEYBOARD_PACKET) payload);
        break;
      case UTF8_TEXT_EVENT_MAGIC:
        passthrough((PNV_UNICODE_PACKET) payload);
        passthrough(static_cast<const NV_UNICODE_PACKET *>(static_cast<const void *>(payload)));
        break;
      case MULTI_CONTROLLER_MAGIC_GEN5:
        passthrough(input, (PNV_MULTI_CONTROLLER_PACKET) payload);
@@ -1822,6 +1948,65 @@
  }
  /**
   * @brief Release every pressed mouse button tracked by Sunshine.
   */
  void reset_mouse_buttons() {
    for (int button = 0; button < mouse_press.size(); ++button) {
      if (mouse_press[button]) {
        platf::button_mouse(platf_input, button, true);
        mouse_press[button] = false;
      }
    }
  }
  /**
   * @brief Release every pressed keyboard key tracked by Sunshine.
   */
  void reset_keyboard_keys() {
    for (auto &[key, pressed] : key_press) {
      if (pressed) {
        platf::keyboard_update(platf_input, vk_from_kpid(key) & 0x00FF, true, flags_from_kpid(key));
        pressed = false;
      }
    }
  }
  /**
   * @brief Neutralize retained gamepads without destroying their virtual devices.
   *
   * @param input Retained stream input state to neutralize.
   */
  void reset_gamepads(const std::shared_ptr<input_t> &input) {
    for (int client_index = 0; client_index < input->gamepads.size(); ++client_index) {
      auto &gamepad = input->gamepads[client_index];
      if (gamepad.back_timeout_id) {
        task_pool.cancel(gamepad.back_timeout_id);
        gamepad.back_timeout_id = nullptr;
      }
      if (gamepad.id >= 0) {
        platf::gamepad_update(platf_input, gamepad.id, {});
        platf::gamepad_touch(
          platf_input,
          {{gamepad.id, static_cast<std::uint8_t>(client_index)}, LI_TOUCH_EVENT_CANCEL_ALL, 0, 0.0F, 0.0F, 0.0F}
        );
      }
      gamepad.gamepad_state = {};
      gamepad.back_button_state = button_state_e::NONE;
    }
  }
  /**
   * @brief Reset all pressed input state for a disconnected stream.
   *
   * @param input Retained stream input state to reset.
   */
  void reset_input_state(const std::shared_ptr<input_t> &input) {
    reset_mouse_buttons();
    reset_keyboard_keys();
    reset_gamepads(input);
  }
  /**
   * @brief Reset the object to its initial empty state.
   */
  void reset(std::shared_ptr<input_t> &input) {
@@ -1829,21 +2014,39 @@
    task_pool.cancel(input->mouse_left_button_timeout);
    // Ensure input is synchronous, by using the task_pool
    task_pool.push([]() {
      for (int x = 0; x < mouse_press.size(); ++x) {
        if (mouse_press[x]) {
          platf::button_mouse(platf_input, x, true);
          mouse_press[x] = false;
        }
    task_pool.push(reset_input_state, input);
  }
      }
  void terminate_gamepads() {
    retained_input_map_t inputs;
    {
      auto &state = retained_input_state();
      std::lock_guard lock {state.mutex};
      state.inputs.swap(inputs);
    }
      for (auto &kp : key_press) {
        if (!kp.second) {
          // already released
          continue;
        }
        platf::keyboard_update(platf_input, vk_from_kpid(kp.first) & 0x00FF, true, flags_from_kpid(kp.first));
        key_press[kp.first] = false;
    if (!inputs.empty()) {
      dispatch_input_task([inputs = std::move(inputs)]() {
        destroy_gamepads(inputs);
      });
    }
  }
  void terminate_gamepads(const std::string_view session_id) {
    std::shared_ptr<input_t> input;
    {
      auto &state = retained_input_state();
      std::lock_guard lock {state.mutex};
      const auto iter = state.inputs.find(session_id);
      if (iter == state.inputs.end()) {
        return;
      }
      input = std::move(iter->second);
      state.inputs.erase(iter);
    }
    dispatch_input_task([input = std::move(input)]() {
      destroy_gamepads(input);
    });
  }
@@ -1857,6 +2060,13 @@
     * @brief Destroy the input subsystem deinitializer.
     */
    ~deinit_t() override {
      retained_input_map_t inputs;
      {
        auto &state = retained_input_state();
        std::lock_guard lock {state.mutex};
        state.inputs.swap(inputs);
      }
      destroy_gamepads(inputs);
      platf_input.reset();
    }
  };
@@ -1874,24 +2084,39 @@
   * @brief Probe connected gamepads and update input capability state.
   */
  bool probe_gamepads() {
    const auto &gamepads = platf::supported_gamepads(std::addressof(platf_input));
    auto input = static_cast<platf::input_t *>(platf_input.get());
    const auto gamepads = platf::supported_gamepads(input);
    for (auto &gamepad : gamepads) {
      if (gamepad.is_enabled && gamepad.name != "auto") {
        return false;
      }
    }
    return true;
    return std::ranges::none_of(gamepads, [](const auto &gamepad) {
      return gamepad.is_enabled && gamepad.name != "auto";
    });
  }
  /**
   * @brief Allocate and initialize platform input state for a stream.
   */
  std::shared_ptr<input_t> alloc(safe::mail_t mail, std::string session_id) {
    std::shared_ptr<input_t> input;
    bool resumed = false;
    {
      auto &state = retained_input_state();
      std::lock_guard lock {state.mutex};
      const auto iter = state.inputs.find(session_id);
      if (iter != state.inputs.end()) {
        input = iter->second;
        resumed = true;
      } else {
        input = std::make_shared<input_t>(
          mail->event<input::touch_port_t>(mail::touch_port),
          mail->queue<platf::gamepad_feedback_msg_t>(mail::gamepad_feedback)
        );
        state.inputs.try_emplace(std::move(session_id), input);
      }
    }
    if (resumed) {
  std::shared_ptr<input_t> alloc(safe::mail_t mail) {
    auto input = std::make_shared<input_t>(
      mail->event<input::touch_port_t>(mail::touch_port),
      mail->queue<platf::gamepad_feedback_msg_t>(mail::gamepad_feedback)
      dispatch_input_task([input, mail = std::move(mail)]() {
        rebind_input(input, mail);
      });
    }
    );
    // Workaround to ensure new frames will be captured when a client connects
    task_pool.pushDelayed([]() {
@@ -1902,4 +2127,25 @@
    return input;
  }
#ifdef SUNSHINE_TESTS
  namespace testing {
    void set_platform_input(platf::input_t input) {
      terminate_gamepads();
      platf_input = std::move(input);
      gamepadMask.reset();
    }
    int alloc_gamepad(std::shared_ptr<input_t> &input, std::uint8_t client_index, const platf::gamepad_arrival_t &metadata) {
      return ::input::alloc_gamepad(input, client_index, metadata);
    }
    int gamepad_id(const std::shared_ptr<input_t> &input, std::uint8_t client_index) {
      if (!input || client_index >= input->gamepads.size()) {
        return -1;
      }
      return input->gamepads[client_index].id;
    }
  }  // namespace testing
#endif
}  // namespace input