diff options
Diffstat (limited to 'xbmc/platform')
148 files changed, 15759 insertions, 0 deletions
diff --git a/xbmc/platform/CMakeLists.txt b/xbmc/platform/CMakeLists.txt new file mode 100644 index 0000000..4df5326 --- /dev/null +++ b/xbmc/platform/CMakeLists.txt @@ -0,0 +1,10 @@ +set(SOURCES Environment.cpp + xbmc.cpp) + +set(HEADERS Environment.h + Filesystem.h + MessagePrinter.h + Platform.h + xbmc.h) + +core_add_library(platform_common) diff --git a/xbmc/platform/Environment.cpp b/xbmc/platform/Environment.cpp new file mode 100644 index 0000000..4655dcc --- /dev/null +++ b/xbmc/platform/Environment.cpp @@ -0,0 +1,75 @@ +/* + * Copyright (C) 2013-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/** + * \file platform\Environment.cpp + * \brief Implements CEnvironment class functions. + * + * Some ideas were inspired by PostgreSQL's pgwin32_putenv function. + * Refined, updated, enhanced and modified for XBMC by Karlson2k. + */ + +#include "Environment.h" + +#include <stdlib.h> + + +// --------------------- Main Functions --------------------- + +int CEnvironment::setenv(const std::string &name, const std::string &value, int overwrite /*= 1*/) +{ +#ifdef TARGET_WINDOWS + return (win_setenv(name, value, overwrite ? autoDetect : addOnly) == 0) ? 0 : -1; +#else + if (value.empty() && overwrite != 0) + return ::unsetenv(name.c_str()); + return ::setenv(name.c_str(), value.c_str(), overwrite); +#endif +} + +std::string CEnvironment::getenv(const std::string &name) +{ +#ifdef TARGET_WINDOWS + return win_getenv(name); +#else + char * str = ::getenv(name.c_str()); + if (str == NULL) + return ""; + return str; +#endif +} + +int CEnvironment::unsetenv(const std::string &name) +{ +#ifdef TARGET_WINDOWS + return (win_setenv(name, "", deleteVariable)) == 0 ? 0 : -1; +#else + return ::unsetenv(name.c_str()); +#endif +} + +int CEnvironment::putenv(const std::string &envstring) +{ + if (envstring.empty()) + return 0; + size_t pos = envstring.find('='); + if (pos == 0) // '=' is the first character + return -1; + if (pos == std::string::npos) + return unsetenv(envstring); + if (pos == envstring.length()-1) // '=' is in last position + { + std::string name(envstring); + name.erase(name.length()-1, 1); + return unsetenv(name); + } + std::string name(envstring, 0, pos), value(envstring, pos+1); + + return setenv(name, value); +} + diff --git a/xbmc/platform/Environment.h b/xbmc/platform/Environment.h new file mode 100644 index 0000000..a05974c --- /dev/null +++ b/xbmc/platform/Environment.h @@ -0,0 +1,98 @@ +/* + * Copyright (C) 2013-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +/** + * \file utils\Environment.h + * \brief Declares CEnvironment class for platform-independent environment variables manipulations. + * + */ +#include <string> + +/** + * @class CEnvironment + * + * @brief Platform-independent environment variables manipulations. + * + * Provide analog for POSIX functions: + * + setenv + * + unsetenv + * + putenv + * + getenv + * + * You can generally use the functions as you would normally in POSIX-style. + * The differences below are just to make things more convenient through use of std::string (2,3), + * and to also allow the Win32-style of unsetting variables (4,5) if wanted. + * 1. CEnvironment::setenv parameter 'overwrite' is optional, set by default to 1 (allow overwrite). + * 2. CEnvironment::putenv uses copy of provided string (rather than string itself) to change environment, + * so you can free parameter variable right after call of function. + * 3. CEnvironment::getenv returns a copy of environment variable value instead of pointer to value. + * 4. CEnvironment::setenv can be used to unset variables. Just pass empty string for 'value' parameter. + * 5. CEnvironment::putenv can be used to unset variables. Set parameter to 'var=' (Windows style) or + * just 'var' (POSIX style), and 'var' will be unset. + * + * All 'std::string' types are supposed to be in UTF-8 encoding. + * All functions work on all platforms. Special care is taken on Windows platform where Environment is changed for process itself, + * for process runtime library and for all runtime libraries (MSVCRT) loaded by third-party modules. + * Functions internally make all necessary UTF-8 <-> wide conversions.* + */ + +class CEnvironment +{ +public: + /** + * \fn static int CEnvironment::setenv(const std::string &name, const std::string &value, + * int overwrite = 1); + * \brief Sets or unsets environment variable. + * \param name The environment variable name to add/modify/delete. + * \param value The environment variable new value. If set to empty string, variable will be + * deleted from the environment. + * \param overwrite (optional) If set to non-zero, existing variable will be overwritten. If set to zero and + * variable is already present, then variable will be unchanged and function returns success. + * \return Zero on success, non-zero on error. + */ + static int setenv(const std::string &name, const std::string &value, int overwrite = 1); + /** + * \fn static int CEnvironment::unsetenv(const std::string &name); + * \brief Deletes environment variable. + * \param name The environment variable name to delete. + * \return Zero on success, non-zero on error. + */ + static int unsetenv(const std::string &name); + + /** + * \fn static int CEnvironment::putenv(const std::string &envstring); + * \brief Adds/modifies/deletes environment variable. + * \param envstring The variable-value string in form 'var=value'. If set to 'var=' or 'var', then variable + * will be deleted from the environment. + * \return Zero on success, non-zero on error. + */ + static int putenv(const std::string &envstring); + /** + * \fn static std::string CEnvironment::getenv(const std::string &name); + * \brief Gets value of environment variable in UTF-8 encoding. + * \param name The name of environment variable. + * \return Copy of of environment variable value or empty string if variable in not present in environment. + * \sa xbmc_getenvUtf8, xbmc_getenvW + */ + static std::string getenv(const std::string &name); +private: +#ifdef TARGET_WINDOWS + enum updateAction:int + { + addOrUpdateOnly = -2, + deleteVariable = -1, + addOnly = 0, + autoDetect = 1 + }; + static int win_setenv(const std::string &name, const std::string &value = "", updateAction action = autoDetect); + static std::string win_getenv(const std::string &name); +#endif // TARGET_WINDOWS +}; + diff --git a/xbmc/platform/Filesystem.h b/xbmc/platform/Filesystem.h new file mode 100644 index 0000000..732be92 --- /dev/null +++ b/xbmc/platform/Filesystem.h @@ -0,0 +1,33 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include <cstdint> +#include <string> +#include <system_error> +namespace KODI +{ +namespace PLATFORM +{ +namespace FILESYSTEM +{ +struct space_info { + std::uintmax_t capacity; + std::uintmax_t free; + std::uintmax_t available; +}; + +space_info space(const std::string &path, std::error_code &ec); + +std::string temp_directory_path(std::error_code &ec); +std::string create_temp_directory(std::error_code &ec); +std::string temp_file_path(const std::string& suffix, std::error_code& ec); +} +} +} diff --git a/xbmc/platform/MessagePrinter.h b/xbmc/platform/MessagePrinter.h new file mode 100644 index 0000000..f0aa08e --- /dev/null +++ b/xbmc/platform/MessagePrinter.h @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include <string> +#include <utility> +#include <vector> + +class CMessagePrinter +{ +public: + + /*! \brief Display a normal message to the user during startup + * + * \param[in] message message to display + */ + static void DisplayMessage(const std::string& message); + + /*! \brief Display a warning message to the user during startup + * + * \param[in] warning warning to display + */ + static void DisplayWarning(const std::string& warning); + + /*! \brief Display an error message to the user during startup + * + * \param[in] error error to display + */ + static void DisplayError(const std::string& error); + + /*! \brief Display the help message with command line options available + * + * \param[in] help List of commands and explanations, + help.push_back(std::make_pair("--help", "this displays the help)) + */ + static void DisplayHelpMessage(const std::vector<std::pair<std::string, std::string>>& help); +}; diff --git a/xbmc/platform/Platform.h b/xbmc/platform/Platform.h new file mode 100644 index 0000000..ebb441c --- /dev/null +++ b/xbmc/platform/Platform.h @@ -0,0 +1,101 @@ +/* + * Copyright (C) 2016-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "utils/ComponentContainer.h" + +//! \brief Base class for services. +class IPlatformService +{ +public: + virtual ~IPlatformService() = default; +}; + +/**\brief Class for the Platform object + * + * Contains methods to retrieve platform specific information + * and methods for doing platform specific environment preparation/initialisation + */ +class CPlatform : public CComponentContainer<IPlatformService> +{ +public: + /**\brief Creates the Platform object + * + *@return the platform object + */ + static CPlatform *CreateInstance(); + + /**\brief C'tor */ + CPlatform() = default; + + /**\brief D'tor */ + virtual ~CPlatform() = default; + + /**\brief Called at an early stage of application startup + * + * This method can be used to do platform specific environment preparation + * or initialisation (like setting environment variables for example) + */ + virtual bool InitStageOne() { return true; } + + /**\brief Called at a middle stage of application startup + * + * This method can be used for starting platform specific services that + * do not depend on windowing/gui. (eg macos XBMCHelper) + */ + virtual bool InitStageTwo() { return true; } + + /**\brief Called at a late stage of application startup + * + * This method can be used for starting platform specific Window/GUI related + * services/components. (eg , WS-Discovery Daemons) + */ + virtual bool InitStageThree() { return true; } + + /**\brief Called at a late stage of application shutdown + * + * This method should be used to cleanup resources allocated in InitStageOne + */ + virtual void DeinitStageOne() {} + + /**\brief Called at a middle stage of application shutdown + * + * This method should be used to cleanup resources allocated in InitStageTwo + */ + virtual void DeinitStageTwo() {} + + /**\brief Called at an early stage of application shutdown + * + * This method should be used to cleanup resources allocated in InitStageThree + */ + virtual void DeinitStageThree() {} + + /**\brief Flag whether disabled add-ons - installed via packagemanager or manually - should be + * offered for configuration and activation on kodi startup for this platform + */ + virtual bool IsConfigureAddonsAtStartupEnabled() { return false; } + + /**\brief Flag whether this platform supports user installation of binary add-ons. + */ + virtual bool SupportsUserInstalledBinaryAddons() { return true; } + + /**\brief Print platform specific info to log + * + * Logs platform specific system info during application creation startup + */ + virtual void PlatformSyslog() {} + + /**\brief Get a platform service instance. + */ + template<class T> + std::shared_ptr<T> GetService() + { + return this->GetComponent<T>(); + } +}; diff --git a/xbmc/platform/common/speech/CMakeLists.txt b/xbmc/platform/common/speech/CMakeLists.txt new file mode 100644 index 0000000..ac9752b --- /dev/null +++ b/xbmc/platform/common/speech/CMakeLists.txt @@ -0,0 +1,5 @@ +set(SOURCES SpeechRecognitionStub.cpp) + +set(HEADERS SpeechRecognitionStub.h) + +core_add_library(platform_common_speech) diff --git a/xbmc/platform/common/speech/SpeechRecognitionStub.cpp b/xbmc/platform/common/speech/SpeechRecognitionStub.cpp new file mode 100644 index 0000000..2f76863 --- /dev/null +++ b/xbmc/platform/common/speech/SpeechRecognitionStub.cpp @@ -0,0 +1,15 @@ +/* + * Copyright (C) 2012-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "SpeechRecognitionStub.h" + +std::shared_ptr<speech::ISpeechRecognition> speech::ISpeechRecognition::CreateInstance() +{ + // speech recognition not implemented + return {}; +} diff --git a/xbmc/platform/common/speech/SpeechRecognitionStub.h b/xbmc/platform/common/speech/SpeechRecognitionStub.h new file mode 100644 index 0000000..ec44bc5 --- /dev/null +++ b/xbmc/platform/common/speech/SpeechRecognitionStub.h @@ -0,0 +1,22 @@ +/* + * Copyright (C) 2012-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "speech/ISpeechRecognition.h" + +// This is a stub for all platforms without a speech recognition implementation +// Saves us from feature/platform ifdeffery. +class CSpeechRecognitionStub : public speech::ISpeechRecognition +{ +public: + void StartSpeechRecognition( + const std::shared_ptr<speech::ISpeechRecognitionListener>& listener) override + { + } +}; diff --git a/xbmc/platform/freebsd/CMakeLists.txt b/xbmc/platform/freebsd/CMakeLists.txt new file mode 100644 index 0000000..9b8782f --- /dev/null +++ b/xbmc/platform/freebsd/CMakeLists.txt @@ -0,0 +1,28 @@ +set(SOURCES ../linux/AppParamParserLinux.cpp + CPUInfoFreebsd.cpp + OptionalsReg.cpp + ../linux/OptionalsReg.cpp + ../linux/TimeUtils.cpp + MemUtils.cpp + PlatformFreebsd.cpp) + +set(HEADERS ../linux/AppParamParserLinux.cpp + CPUInfoFreebsd.h + OptionalsReg.h + ../linux/OptionalsReg.h + ../linux/TimeUtils.h + PlatformFreebsd.h) + +if(ALSA_FOUND) + list(APPEND SOURCES ../linux/FDEventMonitor.cpp) + list(APPEND HEADERS ../linux/FDEventMonitor.h) +endif() + +if(DBUS_FOUND) + list(APPEND SOURCES ../linux/DBusMessage.cpp + ../linux/DBusUtil.cpp) + list(APPEND HEADERS ../linux/DBusMessage.h + ../linux/DBusUtil.h) +endif() + +core_add_library(freebsdsupport) diff --git a/xbmc/platform/freebsd/CPUInfoFreebsd.cpp b/xbmc/platform/freebsd/CPUInfoFreebsd.cpp new file mode 100644 index 0000000..5128a72 --- /dev/null +++ b/xbmc/platform/freebsd/CPUInfoFreebsd.cpp @@ -0,0 +1,268 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "CPUInfoFreebsd.h" + +#include "utils/Temperature.h" +#include "utils/log.h" + +#include <array> +#include <vector> + +// clang-format off +/* sys/types.h must be included early, esp. before sysy/systl.h, otherwise: + /usr/include/sys/sysctl.h:1117:25: error: unknown type name 'u_int' */ + +#include <sys/types.h> +// clang-format on + +#if defined(__i386__) || defined(__x86_64__) +#include <cpuid.h> +#elif __has_include(<sys/auxv.h>) +#include <sys/auxv.h> +#endif + +#include <sys/resource.h> +#include <sys/sysctl.h> + +namespace +{ + +struct CpuData +{ +public: + std::size_t GetActiveTime() const { return state[CP_USER] + state[CP_NICE] + state[CP_SYS]; } + + std::size_t GetIdleTime() const { return state[CP_INTR] + state[CP_IDLE]; } + + std::size_t GetTotalTime() const { return GetActiveTime() + GetIdleTime(); } + + std::size_t state[CPUSTATES]; +}; + +} // namespace + +std::shared_ptr<CCPUInfo> CCPUInfo::GetCPUInfo() +{ + return std::make_shared<CCPUInfoFreebsd>(); +} + +CCPUInfoFreebsd::CCPUInfoFreebsd() +{ + int count = 0; + size_t countLength = sizeof(count); + if (sysctlbyname("hw.ncpu", &count, &countLength, nullptr, 0) == 0) + m_cpuCount = count; + else + m_cpuCount = 1; + + std::array<char, 512> cpuModel; + size_t length = cpuModel.size(); + if (sysctlbyname("hw.model", cpuModel.data(), &length, nullptr, 0) == 0) + m_cpuModel = cpuModel.data(); + + for (int i = 0; i < m_cpuCount; i++) + { + CoreInfo core; + core.m_id = i; + m_cores.emplace_back(core); + } +#if defined(__i386__) || defined(__x86_64__) + uint32_t eax, ebx, ecx, edx; + + m_cpuVendor.clear(); + + if (__get_cpuid(CPUID_INFOTYPE_MANUFACTURER, &eax, &ebx, &ecx, &edx)) + { + m_cpuVendor.append(reinterpret_cast<const char*>(&ebx), 4); + m_cpuVendor.append(reinterpret_cast<const char*>(&edx), 4); + m_cpuVendor.append(reinterpret_cast<const char*>(&ecx), 4); + } + + if (__get_cpuid(CPUID_INFOTYPE_EXTENDED_IMPLEMENTED, &eax, &ebx, &ecx, &edx)) + { + if (eax >= CPUID_INFOTYPE_PROCESSOR_3) + { + m_cpuModel.clear(); + + if (__get_cpuid(CPUID_INFOTYPE_PROCESSOR_1, &eax, &ebx, &ecx, &edx)) + { + m_cpuModel.append(reinterpret_cast<const char*>(&eax), 4); + m_cpuModel.append(reinterpret_cast<const char*>(&ebx), 4); + m_cpuModel.append(reinterpret_cast<const char*>(&ecx), 4); + m_cpuModel.append(reinterpret_cast<const char*>(&edx), 4); + } + + if (__get_cpuid(CPUID_INFOTYPE_PROCESSOR_2, &eax, &ebx, &ecx, &edx)) + { + m_cpuModel.append(reinterpret_cast<const char*>(&eax), 4); + m_cpuModel.append(reinterpret_cast<const char*>(&ebx), 4); + m_cpuModel.append(reinterpret_cast<const char*>(&ecx), 4); + m_cpuModel.append(reinterpret_cast<const char*>(&edx), 4); + } + + if (__get_cpuid(CPUID_INFOTYPE_PROCESSOR_3, &eax, &ebx, &ecx, &edx)) + { + m_cpuModel.append(reinterpret_cast<const char*>(&eax), 4); + m_cpuModel.append(reinterpret_cast<const char*>(&ebx), 4); + m_cpuModel.append(reinterpret_cast<const char*>(&ecx), 4); + m_cpuModel.append(reinterpret_cast<const char*>(&edx), 4); + } + } + } + + m_cpuModel = m_cpuModel.substr(0, m_cpuModel.find(char(0))); // remove extra null terminations + + if (__get_cpuid(CPUID_INFOTYPE_STANDARD, &eax, &eax, &ecx, &edx)) + { + if (edx & CPUID_00000001_EDX_MMX) + m_cpuFeatures |= CPU_FEATURE_MMX; + + // Set MMX2 when SSE is present as SSE is a superset of MMX2 and Intel doesn't set the MMX2 cap + if (edx & CPUID_00000001_EDX_SSE) + m_cpuFeatures |= (CPU_FEATURE_SSE | CPU_FEATURE_MMX2); + + if (edx & CPUID_00000001_EDX_SSE2) + m_cpuFeatures |= CPU_FEATURE_SSE2; + + if (ecx & CPUID_00000001_ECX_SSE3) + m_cpuFeatures |= CPU_FEATURE_SSE3; + + if (ecx & CPUID_00000001_ECX_SSSE3) + m_cpuFeatures |= CPU_FEATURE_SSSE3; + + if (ecx & CPUID_00000001_ECX_SSE4) + m_cpuFeatures |= CPU_FEATURE_SSE4; + + if (ecx & CPUID_00000001_ECX_SSE42) + m_cpuFeatures |= CPU_FEATURE_SSE42; + } + + if (__get_cpuid(CPUID_INFOTYPE_EXTENDED_IMPLEMENTED, &eax, &eax, &ecx, &edx)) + { + if (eax >= CPUID_INFOTYPE_EXTENDED) + { + if (edx & CPUID_80000001_EDX_MMX) + m_cpuFeatures |= CPU_FEATURE_MMX; + + if (edx & CPUID_80000001_EDX_MMX2) + m_cpuFeatures |= CPU_FEATURE_MMX2; + + if (edx & CPUID_80000001_EDX_3DNOW) + m_cpuFeatures |= CPU_FEATURE_3DNOW; + + if (edx & CPUID_80000001_EDX_3DNOWEXT) + m_cpuFeatures |= CPU_FEATURE_3DNOWEXT; + } + } +#endif + +#if defined(HAS_NEON) +#if defined(__ARM_NEON) + m_cpuFeatures |= CPU_FEATURE_NEON; +#elif __has_include(<sys/auxv.h>) + unsigned long hwcap = 0; + elf_aux_info(AT_HWCAP, &hwcap, sizeof(hwcap)); + if (hwcap & HWCAP_NEON) + m_cpuFeatures |= CPU_FEATURE_NEON; +#endif +#endif +} + +int CCPUInfoFreebsd::GetUsedPercentage() +{ + if (!m_nextUsedReadTime.IsTimePast()) + return m_lastUsedPercentage; + + size_t len = sizeof(long); + + if (sysctlbyname("kern.cp_times", nullptr, &len, nullptr, 0) != 0) + return false; + + std::vector<long> cptimes(len); + size_t cptimesLength = cptimes.size(); + if (sysctlbyname("kern.cp_times", cptimes.data(), &cptimesLength, nullptr, 0) != 0) + return false; + + size_t activeTime{0}; + size_t idleTime{0}; + size_t totalTime{0}; + + std::vector<CpuData> cpuData; + + for (int i = 0; i < m_cpuCount; i++) + { + CpuData info; + + for (size_t state = 0; state < CPUSTATES; state++) + { + info.state[state] = cptimes[i * CPUSTATES + state]; + } + + activeTime += info.GetActiveTime(); + idleTime += info.GetIdleTime(); + totalTime += info.GetTotalTime(); + + cpuData.emplace_back(info); + } + + activeTime -= m_activeTime; + idleTime -= m_idleTime; + totalTime -= m_totalTime; + + m_activeTime += activeTime; + m_idleTime += idleTime; + m_totalTime += totalTime; + + m_lastUsedPercentage = activeTime * 100.0f / totalTime; + m_nextUsedReadTime.Set(MINIMUM_TIME_BETWEEN_READS); + + for (size_t core = 0; core < cpuData.size(); core++) + { + auto activeTime = cpuData[core].GetActiveTime() - m_cores[core].m_activeTime; + auto idleTime = cpuData[core].GetIdleTime() - m_cores[core].m_idleTime; + auto totalTime = cpuData[core].GetTotalTime() - m_cores[core].m_totalTime; + + m_cores[core].m_usagePercent = activeTime * 100.0 / totalTime; + + m_cores[core].m_activeTime += activeTime; + m_cores[core].m_idleTime += idleTime; + m_cores[core].m_totalTime += totalTime; + } + + return static_cast<int>(m_lastUsedPercentage); +} + +float CCPUInfoFreebsd::GetCPUFrequency() +{ + int hz = 0; + size_t len = sizeof(hz); + if (sysctlbyname("dev.cpu.0.freq", &hz, &len, nullptr, 0) != 0) + hz = 0; + + return static_cast<float>(hz); +} + + +bool CCPUInfoFreebsd::GetTemperature(CTemperature& temperature) +{ + if (CheckUserTemperatureCommand(temperature)) + return true; + + int value; + size_t len = sizeof(value); + + /* Temperature is in Kelvin * 10 */ + if (sysctlbyname("dev.cpu.0.temperature", &value, &len, nullptr, 0) != 0) + return false; + + temperature = CTemperature::CreateFromKelvin(static_cast<double>(value) / 10.0); + temperature.SetValid(true); + + return true; +} diff --git a/xbmc/platform/freebsd/CPUInfoFreebsd.h b/xbmc/platform/freebsd/CPUInfoFreebsd.h new file mode 100644 index 0000000..f1743ce --- /dev/null +++ b/xbmc/platform/freebsd/CPUInfoFreebsd.h @@ -0,0 +1,24 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "utils/Temperature.h" + +#include "platform/posix/CPUInfoPosix.h" + +class CCPUInfoFreebsd : public CCPUInfoPosix +{ +public: + CCPUInfoFreebsd(); + ~CCPUInfoFreebsd() = default; + + int GetUsedPercentage() override; + float GetCPUFrequency() override; + bool GetTemperature(CTemperature& temperature) override; +}; diff --git a/xbmc/platform/freebsd/MemUtils.cpp b/xbmc/platform/freebsd/MemUtils.cpp new file mode 100644 index 0000000..de3e42c --- /dev/null +++ b/xbmc/platform/freebsd/MemUtils.cpp @@ -0,0 +1,83 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "utils/MemUtils.h" + +#include <array> +#include <cstdlib> +#include <cstring> +#include <stdio.h> + +#include <unistd.h> /* FreeBSD can't write standalone headers */ +#include <sys/sysctl.h> /* FreeBSD can't write standalone headers */ +#include <sys/types.h> + +namespace KODI +{ +namespace MEMORY +{ + +void* AlignedMalloc(size_t s, size_t alignTo) +{ + void* p; + posix_memalign(&p, alignTo, s); + + return p; +} + +void AlignedFree(void* p) +{ + free(p); +} + +void GetMemoryStatus(MemoryStatus* buffer) +{ + if (!buffer) + return; + + /* sysctl hw.physmem */ + size_t len = 0; + + /* physmem */ + size_t physmem = 0; + len = sizeof(physmem); + if (sysctlbyname("hw.physmem", &physmem, &len, NULL, 0) == 0) + { + buffer->totalPhys = physmem; + } + + /* pagesize */ + size_t pagesize = 0; + len = sizeof(pagesize); + if (sysctlbyname("hw.pagesize", &pagesize, &len, NULL, 0) != 0) + pagesize = 4096; + + /* mem_inactive */ + size_t mem_inactive = 0; + len = sizeof(mem_inactive); + if (sysctlbyname("vm.stats.vm.v_inactive_count", &mem_inactive, &len, NULL, 0) == 0) + mem_inactive *= pagesize; + + /* mem_cache */ + size_t mem_cache = 0; + len = sizeof(mem_cache); + if (sysctlbyname("vm.stats.vm.v_cache_count", &mem_cache, &len, NULL, 0) == 0) + mem_cache *= pagesize; + + /* mem_free */ + size_t mem_free = 0; + len = sizeof(mem_free); + if (sysctlbyname("vm.stats.vm.v_free_count", &mem_free, &len, NULL, 0) == 0) + mem_free *= pagesize; + + /* mem_avail = mem_inactive + mem_cache + mem_free */ + buffer->availPhys = mem_inactive + mem_cache + mem_free; +} + +} +} diff --git a/xbmc/platform/freebsd/OptionalsReg.cpp b/xbmc/platform/freebsd/OptionalsReg.cpp new file mode 100644 index 0000000..ed414f1 --- /dev/null +++ b/xbmc/platform/freebsd/OptionalsReg.cpp @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2005-2019 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "OptionalsReg.h" + + +//----------------------------------------------------------------------------- +// OSS +//----------------------------------------------------------------------------- + +#ifdef HAS_OSS +#include "cores/AudioEngine/Sinks/AESinkOSS.h" +bool OPTIONALS::OSSRegister() +{ + CAESinkOSS::Register(); + return true; +} +#endif diff --git a/xbmc/platform/freebsd/OptionalsReg.h b/xbmc/platform/freebsd/OptionalsReg.h new file mode 100644 index 0000000..36837d0 --- /dev/null +++ b/xbmc/platform/freebsd/OptionalsReg.h @@ -0,0 +1,18 @@ +/* + * Copyright (C) 2005-2019 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +//----------------------------------------------------------------------------- +// OSS +//----------------------------------------------------------------------------- + +namespace OPTIONALS +{ +bool OSSRegister(); +} diff --git a/xbmc/platform/freebsd/PlatformFreebsd.cpp b/xbmc/platform/freebsd/PlatformFreebsd.cpp new file mode 100644 index 0000000..b65501b --- /dev/null +++ b/xbmc/platform/freebsd/PlatformFreebsd.cpp @@ -0,0 +1,124 @@ +/* + * Copyright (C) 2016-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "PlatformFreebsd.h" + +#include "utils/StringUtils.h" + +#include "platform/freebsd/OptionalsReg.h" +#include "platform/linux/powermanagement/LinuxPowerSyscall.h" + +// clang-format off +#if defined(HAS_GLES) +#if defined(HAVE_WAYLAND) +#include "windowing/wayland/WinSystemWaylandEGLContextGLES.h" +#endif +#if defined(HAVE_X11) +#include "windowing/X11/WinSystemX11GLESContext.h" +#endif +#if defined(HAVE_GBM) +#include "windowing/gbm/WinSystemGbmGLESContext.h" +#endif +#endif + +#if defined(HAS_GL) +#if defined(HAVE_WAYLAND) +#include "windowing/wayland/WinSystemWaylandEGLContextGL.h" +#endif +#if defined(HAVE_X11) +#include "windowing/X11/WinSystemX11GLContext.h" +#endif +#if defined(HAVE_GBM) +#include "windowing/gbm/WinSystemGbmGLContext.h" +#endif +#endif +// clang-format on + +#include <cstdlib> + +CPlatform* CPlatform::CreateInstance() +{ + return new CPlatformFreebsd(); +} + +bool CPlatformFreebsd::InitStageOne() +{ + if (!CPlatformPosix::InitStageOne()) + return false; + + setenv("OS", "Linux", true); // for python scripts that check the OS + +#if defined(HAS_GLES) +#if defined(HAVE_WAYLAND) + KODI::WINDOWING::WAYLAND::CWinSystemWaylandEGLContextGLES::Register(); +#endif +#if defined(HAVE_X11) + KODI::WINDOWING::X11::CWinSystemX11GLESContext::Register(); +#endif +#if defined(HAVE_GBM) + KODI::WINDOWING::GBM::CWinSystemGbmGLESContext::Register(); +#endif +#endif + +#if defined(HAS_GL) +#if defined(HAVE_WAYLAND) + KODI::WINDOWING::WAYLAND::CWinSystemWaylandEGLContextGL::Register(); +#endif +#if defined(HAVE_X11) + KODI::WINDOWING::X11::CWinSystemX11GLContext::Register(); +#endif +#if defined(HAVE_GBM) + KODI::WINDOWING::GBM::CWinSystemGbmGLContext::Register(); +#endif +#endif + + CLinuxPowerSyscall::Register(); + + std::string envSink; + if (getenv("KODI_AE_SINK")) + envSink = getenv("KODI_AE_SINK"); + + if (StringUtils::EqualsNoCase(envSink, "ALSA")) + { + OPTIONALS::ALSARegister(); + } + else if (StringUtils::EqualsNoCase(envSink, "PULSE")) + { + OPTIONALS::PulseAudioRegister(); + } + else if (StringUtils::EqualsNoCase(envSink, "OSS")) + { + OPTIONALS::OSSRegister(); + } + else if (StringUtils::EqualsNoCase(envSink, "SNDIO")) + { + OPTIONALS::SndioRegister(); + } + else if (StringUtils::EqualsNoCase(envSink, "ALSA+PULSE")) + { + OPTIONALS::ALSARegister(); + OPTIONALS::PulseAudioRegister(); + } + else + { + if (!OPTIONALS::PulseAudioRegister()) + { + if (!OPTIONALS::ALSARegister()) + { + if (!OPTIONALS::SndioRegister()) + { + OPTIONALS::OSSRegister(); + } + } + } + } + + m_lirc.reset(OPTIONALS::LircRegister()); + + return true; +} diff --git a/xbmc/platform/freebsd/PlatformFreebsd.h b/xbmc/platform/freebsd/PlatformFreebsd.h new file mode 100644 index 0000000..48a4151 --- /dev/null +++ b/xbmc/platform/freebsd/PlatformFreebsd.h @@ -0,0 +1,26 @@ +/* + * Copyright (C) 2016-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "platform/linux/OptionalsReg.h" +#include "platform/posix/PlatformPosix.h" + +#include <memory> + +class CPlatformFreebsd : public CPlatformPosix +{ +public: + CPlatformFreebsd() = default; + ~CPlatformFreebsd() override = default; + + bool InitStageOne() override; + +private: + std::unique_ptr<OPTIONALS::CLircContainer, OPTIONALS::delete_CLircContainer> m_lirc; +}; diff --git a/xbmc/platform/freebsd/network/CMakeLists.txt b/xbmc/platform/freebsd/network/CMakeLists.txt new file mode 100644 index 0000000..25d8ee8 --- /dev/null +++ b/xbmc/platform/freebsd/network/CMakeLists.txt @@ -0,0 +1,4 @@ +set(SOURCES NetworkFreebsd.cpp) +set(HEADERS NetworkFreebsd.h) + +core_add_library(platform_freebsd_network) diff --git a/xbmc/platform/freebsd/network/NetworkFreebsd.cpp b/xbmc/platform/freebsd/network/NetworkFreebsd.cpp new file mode 100644 index 0000000..94a0a41 --- /dev/null +++ b/xbmc/platform/freebsd/network/NetworkFreebsd.cpp @@ -0,0 +1,247 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "NetworkFreebsd.h" + +#include "utils/StringUtils.h" +#include "utils/log.h" + +#include <array> +#include <errno.h> + +#include <arpa/inet.h> +#include <ifaddrs.h> +#include <net/if.h> +#include <net/if_arp.h> +#include <net/if_dl.h> +#include <net/route.h> +#include <netinet/if_ether.h> +#include <netinet/in.h> +#include <resolv.h> +#include <sys/sockio.h> +#include <sys/wait.h> + +CNetworkInterfaceFreebsd::CNetworkInterfaceFreebsd(CNetworkPosix* network, + std::string interfaceName, + char interfaceMacAddrRaw[6]) + : CNetworkInterfacePosix(network, interfaceName, interfaceMacAddrRaw) +{ +} + +std::string CNetworkInterfaceFreebsd::GetCurrentDefaultGateway() const +{ + std::string result; + + size_t needed; + int mib[6]; + char *buf, *next, *lim; + char line[16]; + struct rt_msghdr* rtm; + struct sockaddr* sa; + struct sockaddr_in* sockin; + + mib[0] = CTL_NET; + mib[1] = PF_ROUTE; + mib[2] = 0; + mib[3] = 0; + mib[4] = NET_RT_DUMP; + mib[5] = 0; + if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) + return result; + + if ((buf = (char*)malloc(needed)) == NULL) + return result; + + if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) + { + free(buf); + return result; + } + + lim = buf + needed; + for (next = buf; next < lim; next += rtm->rtm_msglen) + { + rtm = (struct rt_msghdr*)next; + sa = (struct sockaddr*)(rtm + 1); + sa = (struct sockaddr*)(SA_SIZE(sa) + (char*)sa); + sockin = (struct sockaddr_in*)sa; + if (inet_ntop(AF_INET, &sockin->sin_addr.s_addr, line, sizeof(line)) == NULL) + { + free(buf); + return result; + } + result = line; + break; + } + free(buf); + + return result; +} + +bool CNetworkInterfaceFreebsd::GetHostMacAddress(unsigned long host_ip, std::string& mac) const +{ + bool ret = false; + size_t needed; + char *buf, *next; + struct rt_msghdr* rtm; + struct sockaddr_inarp* sin; + struct sockaddr_dl* sdl; + constexpr std::array<int, 6> mib = { + CTL_NET, PF_ROUTE, 0, AF_INET, NET_RT_FLAGS, RTF_LLINFO, + }; + + mac = ""; + + if (sysctl(mib.data(), mib.size(), nullptr, &needed, nullptr, 0) == 0) + { + buf = (char*)malloc(needed); + if (buf) + { + if (sysctl(mib.data(), mib.size(), buf, &needed, nullptr, 0) == 0) + { + for (next = buf; next < buf + needed; next += rtm->rtm_msglen) + { + + rtm = (struct rt_msghdr*)next; + sin = (struct sockaddr_inarp*)(rtm + 1); + sdl = (struct sockaddr_dl*)(sin + 1); + + if (host_ip != sin->sin_addr.s_addr || sdl->sdl_alen < 6) + continue; + + u_char* cp = (u_char*)LLADDR(sdl); + + mac = StringUtils::Format("{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}", cp[0], cp[1], + cp[2], cp[3], cp[4], cp[5]); + ret = true; + break; + } + } + free(buf); + } + } + return ret; +} + +std::unique_ptr<CNetworkBase> CNetworkBase::GetNetwork() +{ + return std::make_unique<CNetworkFreebsd>(); +} + +CNetworkFreebsd::CNetworkFreebsd() : CNetworkPosix() +{ + queryInterfaceList(); +} + +void CNetworkFreebsd::GetMacAddress(const std::string& interfaceName, char rawMac[6]) +{ + memset(rawMac, 0, 6); + +#if !defined(IFT_ETHER) +#define IFT_ETHER 0x6 /* Ethernet CSMACD */ +#endif + const struct sockaddr_dl* dlAddr = NULL; + const uint8_t* base = NULL; + // Query the list of interfaces. + struct ifaddrs* list; + struct ifaddrs* interface; + + if (getifaddrs(&list) < 0) + { + return; + } + + for (interface = list; interface != NULL; interface = interface->ifa_next) + { + if (interfaceName == interface->ifa_name) + { + if ((interface->ifa_addr->sa_family == AF_LINK) && + (((const struct sockaddr_dl*)interface->ifa_addr)->sdl_type == IFT_ETHER)) + { + dlAddr = (const struct sockaddr_dl*)interface->ifa_addr; + base = (const uint8_t*)&dlAddr->sdl_data[dlAddr->sdl_nlen]; + + if (dlAddr->sdl_alen > 5) + { + memcpy(rawMac, base, 6); + } + } + break; + } + } + + freeifaddrs(list); +} + +void CNetworkFreebsd::queryInterfaceList() +{ + char macAddrRaw[6]; + m_interfaces.clear(); + + // Query the list of interfaces. + struct ifaddrs* list; + if (getifaddrs(&list) < 0) + return; + + struct ifaddrs* cur; + for (cur = list; cur != NULL; cur = cur->ifa_next) + { + if (cur->ifa_addr->sa_family != AF_INET) + continue; + + GetMacAddress(cur->ifa_name, macAddrRaw); + + // only add interfaces with non-zero mac addresses + if (macAddrRaw[0] || macAddrRaw[1] || macAddrRaw[2] || macAddrRaw[3] || macAddrRaw[4] || + macAddrRaw[5]) + // Add the interface. + m_interfaces.push_back(new CNetworkInterfaceFreebsd(this, cur->ifa_name, macAddrRaw)); + } + + freeifaddrs(list); +} + +std::vector<std::string> CNetworkFreebsd::GetNameServers() +{ + std::vector<std::string> result; + + res_init(); + + for (int i = 0; i < _res.nscount; i++) + { + std::string ns = inet_ntoa(_res.nsaddr_list[i].sin_addr); + result.push_back(ns); + } + + return result; +} + +bool CNetworkFreebsd::PingHost(unsigned long remote_ip, unsigned int timeout_ms) +{ + char cmd_line[64]; + + struct in_addr host_ip; + host_ip.s_addr = remote_ip; + + sprintf(cmd_line, "ping -c 1 -t %d %s", timeout_ms / 1000 + (timeout_ms % 1000) != 0, + inet_ntoa(host_ip)); + + int status = -1; + status = system(cmd_line); + int result = WIFEXITED(status) ? WEXITSTATUS(status) : -1; + + // http://linux.about.com/od/commands/l/blcmdl8_ping.htm ; + // 0 reply + // 1 no reply + // else some error + + if (result < 0 || result > 1) + CLog::Log(LOGERROR, "Ping fail : status = {}, errno = {} : '{}'", status, errno, cmd_line); + + return result == 0; +} diff --git a/xbmc/platform/freebsd/network/NetworkFreebsd.h b/xbmc/platform/freebsd/network/NetworkFreebsd.h new file mode 100644 index 0000000..92b00d7 --- /dev/null +++ b/xbmc/platform/freebsd/network/NetworkFreebsd.h @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "platform/posix/network/NetworkPosix.h" + +#include <string> +#include <vector> + +class CNetworkInterfaceFreebsd : public CNetworkInterfacePosix +{ +public: + CNetworkInterfaceFreebsd(CNetworkPosix* network, + std::string interfaceName, + char interfaceMacAddrRaw[6]); + ~CNetworkInterfaceFreebsd() override = default; + + std::string GetCurrentDefaultGateway() const override; + bool GetHostMacAddress(unsigned long host, std::string& mac) const override; +}; + +class CNetworkFreebsd : public CNetworkPosix +{ +public: + CNetworkFreebsd(); + ~CNetworkFreebsd() override = default; + + bool PingHost(unsigned long host, unsigned int timeout_ms = 2000) override; + std::vector<std::string> GetNameServers() override; + +private: + void GetMacAddress(const std::string& interfaceName, char macAddrRaw[6]) override; + void queryInterfaceList() override; +}; diff --git a/xbmc/platform/linux/AppParamParserLinux.cpp b/xbmc/platform/linux/AppParamParserLinux.cpp new file mode 100644 index 0000000..3a1adf9 --- /dev/null +++ b/xbmc/platform/linux/AppParamParserLinux.cpp @@ -0,0 +1,93 @@ +/* + * Copyright (C) 2005-2021 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "AppParamParserLinux.h" + +#include "CompileInfo.h" +#include "application/AppParams.h" +#include "utils/StringUtils.h" + +#include <algorithm> +#include <array> +#include <iostream> +#include <vector> + +namespace +{ +std::vector<std::string> availableWindowSystems = CCompileInfo::GetAvailableWindowSystems(); +std::array<std::string, 1> availableLogTargets = {"console"}; + +constexpr const char* windowingText = + R"""( +Selected window system not available: {} + Available window systems: {} +)"""; + +constexpr const char* loggingText = + R"""( +Selected logging target not available: {} + Available log targest: {} +)"""; + +constexpr const char* helpText = + R"""( +Linux Specific Arguments: + --windowing=<system> Select which windowing method to use. + Available window systems are: {} + --logging=<target> Select which log target to use (log file will always be used in conjunction). + Available log targets are: {} +)"""; + + +} // namespace + +CAppParamParserLinux::CAppParamParserLinux() : CAppParamParser() +{ +} + +CAppParamParserLinux::~CAppParamParserLinux() = default; + +void CAppParamParserLinux::ParseArg(const std::string& arg) +{ + CAppParamParser::ParseArg(arg); + + if (arg.substr(0, 12) == "--windowing=") + { + if (std::find(availableWindowSystems.begin(), availableWindowSystems.end(), arg.substr(12)) != + availableWindowSystems.end()) + GetAppParams()->SetWindowing(arg.substr(12)); + else + { + std::cout << StringUtils::Format(windowingText, arg.substr(12), + StringUtils::Join(availableWindowSystems, ", ")); + exit(0); + } + } + else if (arg.substr(0, 10) == "--logging=") + { + if (std::find(availableLogTargets.begin(), availableLogTargets.end(), arg.substr(10)) != + availableLogTargets.end()) + { + GetAppParams()->SetLogTarget(arg.substr(10)); + } + else + { + std::cout << StringUtils::Format(loggingText, arg.substr(10), + StringUtils::Join(availableLogTargets, ", ")); + exit(0); + } + } +} + +void CAppParamParserLinux::DisplayHelp() +{ + CAppParamParser::DisplayHelp(); + + std::cout << StringUtils::Format(helpText, StringUtils::Join(availableWindowSystems, ", "), + StringUtils::Join(availableLogTargets, ", ")); +} diff --git a/xbmc/platform/linux/AppParamParserLinux.h b/xbmc/platform/linux/AppParamParserLinux.h new file mode 100644 index 0000000..ea866ca --- /dev/null +++ b/xbmc/platform/linux/AppParamParserLinux.h @@ -0,0 +1,22 @@ +/* + * Copyright (C) 2005-2021 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "application/AppParamParser.h" + +class CAppParamParserLinux : public CAppParamParser +{ +public: + CAppParamParserLinux(); + ~CAppParamParserLinux(); + +protected: + void ParseArg(const std::string& arg) override; + void DisplayHelp() override; +}; diff --git a/xbmc/platform/linux/CMakeLists.txt b/xbmc/platform/linux/CMakeLists.txt new file mode 100644 index 0000000..31f4cef --- /dev/null +++ b/xbmc/platform/linux/CMakeLists.txt @@ -0,0 +1,32 @@ +set(SOURCES AppParamParserLinux.cpp + CPUInfoLinux.cpp + MemUtils.cpp + OptionalsReg.cpp + PlatformLinux.cpp + SysfsPath.cpp + TimeUtils.cpp) + +set(HEADERS AppParamParserLinux.h + CPUInfoLinux.h + OptionalsReg.h + PlatformLinux.h + SysfsPath.h + TimeUtils.h) + +if(ALSA_FOUND) + list(APPEND SOURCES FDEventMonitor.cpp) + list(APPEND HEADERS FDEventMonitor.h) +endif() + +if(DBUS_FOUND) + list(APPEND SOURCES DBusMessage.cpp + DBusUtil.cpp) + list(APPEND HEADERS DBusMessage.h + DBusUtil.h) +endif() + +if(ADDONS_CONFIGURE_AT_STARTUP) + add_compile_definitions(ADDONS_CONFIGURE_AT_STARTUP) +endif() + +core_add_library(linuxsupport) diff --git a/xbmc/platform/linux/CPUInfoLinux.cpp b/xbmc/platform/linux/CPUInfoLinux.cpp new file mode 100644 index 0000000..ef34bbd --- /dev/null +++ b/xbmc/platform/linux/CPUInfoLinux.cpp @@ -0,0 +1,379 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "CPUInfoLinux.h" + +#include "utils/StringUtils.h" +#include "utils/Temperature.h" + +#include "platform/linux/SysfsPath.h" + +#include <exception> +#include <fstream> +#include <regex> +#include <sstream> +#include <vector> + +#if (defined(__arm__) && defined(HAS_NEON)) || defined(__aarch64__) +#include <asm/hwcap.h> +#include <sys/auxv.h> +#elif defined(__i386__) || defined(__x86_64__) +#include <cpuid.h> +#endif + +#include <unistd.h> + +namespace +{ +enum CpuStates +{ + STATE_USER, + STATE_NICE, + STATE_SYSTEM, + STATE_IDLE, + STATE_IOWAIT, + STATE_IRQ, + STATE_SOFTIRQ, + STATE_STEAL, + STATE_GUEST, + STATE_GUEST_NICE, + STATE_MAX +}; + +struct CpuData +{ +public: + std::size_t GetActiveTime() const + { + return state[STATE_USER] + state[STATE_NICE] + state[STATE_SYSTEM] + state[STATE_IRQ] + + state[STATE_SOFTIRQ] + state[STATE_STEAL] + state[STATE_GUEST] + state[STATE_GUEST_NICE]; + } + + std::size_t GetIdleTime() const { return state[STATE_IDLE] + state[STATE_IOWAIT]; } + + std::size_t GetTotalTime() const { return GetActiveTime() + GetIdleTime(); } + + std::string cpu; + std::size_t state[STATE_MAX]; +}; +} // namespace + +std::shared_ptr<CCPUInfo> CCPUInfo::GetCPUInfo() +{ + return std::make_shared<CCPUInfoLinux>(); +} + +CCPUInfoLinux::CCPUInfoLinux() +{ + CSysfsPath machinePath{"/sys/bus/soc/devices/soc0/machine"}; + if (machinePath.Exists()) + m_cpuHardware = machinePath.Get<std::string>().value_or(""); + + CSysfsPath familyPath{"/sys/bus/soc/devices/soc0/family"}; + if (familyPath.Exists()) + m_cpuSoC = familyPath.Get<std::string>().value_or(""); + + CSysfsPath socPath{"/sys/bus/soc/devices/soc0/soc_id"}; + if (socPath.Exists()) + m_cpuSoC += " " + socPath.Get<std::string>().value_or(""); + + CSysfsPath revisionPath{"/sys/bus/soc/devices/soc0/revision"}; + if (revisionPath.Exists()) + m_cpuRevision = revisionPath.Get<std::string>().value_or(""); + + CSysfsPath serialPath{"/sys/bus/soc/devices/soc0/serial_number"}; + if (serialPath.Exists()) + m_cpuSerial = serialPath.Get<std::string>().value_or(""); + + const std::string freqStr{"/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq"}; + CSysfsPath freqPath{freqStr}; + if (freqPath.Exists()) + m_freqPath = freqStr; + + const std::array<std::string, 4> modules = { + "coretemp", + "k10temp", + "scpi_sensors", + "imx_thermal_zone", + }; + + for (int i = 0; i < 20; i++) + { + CSysfsPath path{"/sys/class/hwmon/hwmon" + std::to_string(i) + "/name"}; + if (!path.Exists()) + continue; + + auto name = path.Get<std::string>(); + + if (!name.has_value()) + continue; + + for (const auto& module : modules) + { + if (module == name) + { + std::string tempStr{"/sys/class/hwmon/hwmon" + std::to_string(i) + "/temp1_input"}; + CSysfsPath tempPath{tempStr}; + if (!tempPath.Exists()) + continue; + + m_tempPath = tempStr; + break; + } + } + + if (!m_tempPath.empty()) + break; + } + + m_cpuCount = sysconf(_SC_NPROCESSORS_ONLN); + + for (int core = 0; core < m_cpuCount; core++) + { + CoreInfo coreInfo; + coreInfo.m_id = core; + m_cores.emplace_back(coreInfo); + } + +#if defined(__i386__) || defined(__x86_64__) + unsigned int eax; + unsigned int ebx; + unsigned int ecx; + unsigned int edx; + + m_cpuVendor.clear(); + + if (__get_cpuid(CPUID_INFOTYPE_MANUFACTURER, &eax, &ebx, &ecx, &edx)) + { + m_cpuVendor.append(reinterpret_cast<const char*>(&ebx), 4); + m_cpuVendor.append(reinterpret_cast<const char*>(&edx), 4); + m_cpuVendor.append(reinterpret_cast<const char*>(&ecx), 4); + } + + if (__get_cpuid(CPUID_INFOTYPE_EXTENDED_IMPLEMENTED, &eax, &ebx, &ecx, &edx)) + { + if (eax >= CPUID_INFOTYPE_PROCESSOR_3) + { + m_cpuModel.clear(); + + if (__get_cpuid(CPUID_INFOTYPE_PROCESSOR_1, &eax, &ebx, &ecx, &edx)) + { + m_cpuModel.append(reinterpret_cast<const char*>(&eax), 4); + m_cpuModel.append(reinterpret_cast<const char*>(&ebx), 4); + m_cpuModel.append(reinterpret_cast<const char*>(&ecx), 4); + m_cpuModel.append(reinterpret_cast<const char*>(&edx), 4); + } + + if (__get_cpuid(CPUID_INFOTYPE_PROCESSOR_2, &eax, &ebx, &ecx, &edx)) + { + m_cpuModel.append(reinterpret_cast<const char*>(&eax), 4); + m_cpuModel.append(reinterpret_cast<const char*>(&ebx), 4); + m_cpuModel.append(reinterpret_cast<const char*>(&ecx), 4); + m_cpuModel.append(reinterpret_cast<const char*>(&edx), 4); + } + + if (__get_cpuid(CPUID_INFOTYPE_PROCESSOR_3, &eax, &ebx, &ecx, &edx)) + { + m_cpuModel.append(reinterpret_cast<const char*>(&eax), 4); + m_cpuModel.append(reinterpret_cast<const char*>(&ebx), 4); + m_cpuModel.append(reinterpret_cast<const char*>(&ecx), 4); + m_cpuModel.append(reinterpret_cast<const char*>(&edx), 4); + } + } + } + + if (__get_cpuid(CPUID_INFOTYPE_STANDARD, &eax, &eax, &ecx, &edx)) + { + if (edx & CPUID_00000001_EDX_MMX) + m_cpuFeatures |= CPU_FEATURE_MMX; + + if (edx & CPUID_00000001_EDX_SSE) + m_cpuFeatures |= CPU_FEATURE_SSE; + + if (edx & CPUID_00000001_EDX_SSE2) + m_cpuFeatures |= CPU_FEATURE_SSE2; + + if (ecx & CPUID_00000001_ECX_SSE3) + m_cpuFeatures |= CPU_FEATURE_SSE3; + + if (ecx & CPUID_00000001_ECX_SSSE3) + m_cpuFeatures |= CPU_FEATURE_SSSE3; + + if (ecx & CPUID_00000001_ECX_SSE4) + m_cpuFeatures |= CPU_FEATURE_SSE4; + + if (ecx & CPUID_00000001_ECX_SSE42) + m_cpuFeatures |= CPU_FEATURE_SSE42; + } + + if (__get_cpuid(CPUID_INFOTYPE_EXTENDED_IMPLEMENTED, &eax, &eax, &ecx, &edx)) + { + if (eax >= CPUID_INFOTYPE_EXTENDED) + { + if (edx & CPUID_80000001_EDX_MMX) + m_cpuFeatures |= CPU_FEATURE_MMX; + + if (edx & CPUID_80000001_EDX_MMX2) + m_cpuFeatures |= CPU_FEATURE_MMX2; + + if (edx & CPUID_80000001_EDX_3DNOW) + m_cpuFeatures |= CPU_FEATURE_3DNOW; + + if (edx & CPUID_80000001_EDX_3DNOWEXT) + m_cpuFeatures |= CPU_FEATURE_3DNOWEXT; + } + } +#else + std::ifstream cpuinfo("/proc/cpuinfo"); + std::regex re(".*: (.*)$"); + + for (std::string line; std::getline(cpuinfo, line);) + { + std::smatch match; + + if (std::regex_match(line, match, re)) + { + if (match.size() == 2) + { + std::ssub_match value = match[1]; + + if (line.find("model name") != std::string::npos) + { + if (m_cpuModel.empty()) + m_cpuModel = value.str(); + } + + if (line.find("BogoMIPS") != std::string::npos) + { + if (m_cpuBogoMips.empty()) + m_cpuBogoMips = value.str(); + } + + if (line.find("Hardware") != std::string::npos) + { + if (m_cpuHardware.empty()) + m_cpuHardware = value.str(); + } + + if (line.find("Serial") != std::string::npos) + { + if (m_cpuSerial.empty()) + m_cpuSerial = value.str(); + } + + if (line.find("Revision") != std::string::npos) + { + if (m_cpuRevision.empty()) + m_cpuRevision = value.str(); + } + } + } + } +#endif + + m_cpuModel = m_cpuModel.substr(0, m_cpuModel.find(char(0))); // remove extra null terminations + +#if defined(HAS_NEON) && defined(__arm__) + if (getauxval(AT_HWCAP) & HWCAP_NEON) + m_cpuFeatures |= CPU_FEATURE_NEON; +#endif + +#if defined(HAS_NEON) && defined(__aarch64__) + if (getauxval(AT_HWCAP) & HWCAP_ASIMD) + m_cpuFeatures |= CPU_FEATURE_NEON; +#endif + + // Set MMX2 when SSE is present as SSE is a superset of MMX2 and Intel doesn't set the MMX2 cap + if (m_cpuFeatures & CPU_FEATURE_SSE) + m_cpuFeatures |= CPU_FEATURE_MMX2; +} + +int CCPUInfoLinux::GetUsedPercentage() +{ + if (!m_nextUsedReadTime.IsTimePast()) + return m_lastUsedPercentage; + + std::vector<CpuData> cpuData; + + std::ifstream infile("/proc/stat"); + + for (std::string line; std::getline(infile, line);) + { + if (line.find("cpu") != std::string::npos) + { + std::istringstream ss(line); + CpuData info; + + ss >> info.cpu; + + for (int i = 0; i < STATE_MAX; i++) + { + ss >> info.state[i]; + } + + cpuData.emplace_back(info); + } + } + + auto activeTime = cpuData.front().GetActiveTime() - m_activeTime; + auto idleTime = cpuData.front().GetIdleTime() - m_idleTime; + auto totalTime = cpuData.front().GetTotalTime() - m_totalTime; + + m_activeTime += activeTime; + m_idleTime += idleTime; + m_totalTime += totalTime; + + m_lastUsedPercentage = activeTime * 100.0f / totalTime; + m_nextUsedReadTime.Set(MINIMUM_TIME_BETWEEN_READS); + + cpuData.erase(cpuData.begin()); + + for (std::size_t core = 0; core < cpuData.size(); core++) + { + auto activeTime = cpuData[core].GetActiveTime() - m_cores[core].m_activeTime; + auto idleTime = cpuData[core].GetIdleTime() - m_cores[core].m_idleTime; + auto totalTime = cpuData[core].GetTotalTime() - m_cores[core].m_totalTime; + + m_cores[core].m_usagePercent = activeTime * 100.0 / totalTime; + + m_cores[core].m_activeTime += activeTime; + m_cores[core].m_idleTime += idleTime; + m_cores[core].m_totalTime += totalTime; + } + + return static_cast<int>(m_lastUsedPercentage); +} + +float CCPUInfoLinux::GetCPUFrequency() +{ + if (m_freqPath.empty()) + return 0; + + auto freq = CSysfsPath(m_freqPath).Get<float>(); + return freq.has_value() ? *freq / 1000.0f : 0.0f; +} + +bool CCPUInfoLinux::GetTemperature(CTemperature& temperature) +{ + if (CheckUserTemperatureCommand(temperature)) + return true; + + if (m_tempPath.empty()) + return false; + + auto temp = CSysfsPath(m_tempPath).Get<double>(); + if (!temp.has_value()) + return false; + + double value = *temp / 1000.0; + + temperature = CTemperature::CreateFromCelsius(value); + temperature.SetValid(true); + + return true; +} diff --git a/xbmc/platform/linux/CPUInfoLinux.h b/xbmc/platform/linux/CPUInfoLinux.h new file mode 100644 index 0000000..ed79afc --- /dev/null +++ b/xbmc/platform/linux/CPUInfoLinux.h @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "utils/Temperature.h" + +#include "platform/posix/CPUInfoPosix.h" + +#include <string> + +class CCPUInfoLinux : public CCPUInfoPosix +{ +public: + CCPUInfoLinux(); + ~CCPUInfoLinux() = default; + + int GetUsedPercentage() override; + float GetCPUFrequency() override; + bool GetTemperature(CTemperature& temperature) override; + +private: + std::string m_freqPath; + std::string m_tempPath; +}; diff --git a/xbmc/platform/linux/DBusMessage.cpp b/xbmc/platform/linux/DBusMessage.cpp new file mode 100644 index 0000000..ab09c3e --- /dev/null +++ b/xbmc/platform/linux/DBusMessage.cpp @@ -0,0 +1,198 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ +#include "DBusMessage.h" + +#include "DBusUtil.h" +#include "settings/AdvancedSettings.h" +#include "utils/log.h" + +CDBusMessage::CDBusMessage(const char *destination, const char *object, const char *interface, const char *method) +{ + m_message.reset(dbus_message_new_method_call(destination, object, interface, method)); + if (!m_message) + { + // Fails only due to memory allocation failure + throw std::runtime_error("dbus_message_new_method_call"); + } + m_haveArgs = false; + + CLog::Log(LOGDEBUG, LOGDBUS, "DBus: Creating message to {} on {} with interface {} and method {}", + destination, object, interface, method); +} + +CDBusMessage::CDBusMessage(const std::string& destination, const std::string& object, const std::string& interface, const std::string& method) +: CDBusMessage(destination.c_str(), object.c_str(), interface.c_str(), method.c_str()) +{ +} + +void DBusMessageDeleter::operator()(DBusMessage* message) const +{ + dbus_message_unref(message); +} + +void CDBusMessage::AppendObjectPath(const char *object) +{ + AppendWithType(DBUS_TYPE_OBJECT_PATH, &object); +} + +template<> +void CDBusMessage::AppendArgument<bool>(const bool arg) +{ + // dbus_bool_t width might not match C++ bool width + dbus_bool_t convArg = (arg == true); + AppendWithType(DBUS_TYPE_BOOLEAN, &convArg); +} + +template<> +void CDBusMessage::AppendArgument<std::string>(const std::string arg) +{ + AppendArgument(arg.c_str()); +} + +void CDBusMessage::AppendArgument(const char **arrayString, unsigned int length) +{ + PrepareArgument(); + DBusMessageIter sub; + if (!dbus_message_iter_open_container(&m_args, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &sub)) + { + throw std::runtime_error("dbus_message_iter_open_container"); + } + + for (unsigned int i = 0; i < length; i++) + { + if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &arrayString[i])) + { + throw std::runtime_error("dbus_message_iter_append_basic"); + } + } + + if (!dbus_message_iter_close_container(&m_args, &sub)) + { + throw std::runtime_error("dbus_message_iter_close_container"); + } +} + +void CDBusMessage::AppendWithType(int type, const void* value) +{ + PrepareArgument(); + if (!dbus_message_iter_append_basic(&m_args, type, value)) + { + throw std::runtime_error("dbus_message_iter_append_basic"); + } +} + +DBusMessageIter * CDBusMessage::GetArgumentIter() { + PrepareArgument(); + return &m_args; +} + +DBusMessage *CDBusMessage::SendSystem() +{ + return Send(DBUS_BUS_SYSTEM); +} + +DBusMessage *CDBusMessage::SendSession() +{ + return Send(DBUS_BUS_SESSION); +} + +DBusMessage *CDBusMessage::SendSystem(CDBusError& error) +{ + return Send(DBUS_BUS_SYSTEM, error); +} + +DBusMessage *CDBusMessage::SendSession(CDBusError& error) +{ + return Send(DBUS_BUS_SESSION, error); +} + +bool CDBusMessage::SendAsyncSystem() +{ + return SendAsync(DBUS_BUS_SYSTEM); +} + +bool CDBusMessage::SendAsyncSession() +{ + return SendAsync(DBUS_BUS_SESSION); +} + +DBusMessage *CDBusMessage::Send(DBusBusType type) +{ + CDBusError error; + CDBusConnection con; + if (!con.Connect(type)) + return nullptr; + + DBusMessage *returnMessage = Send(con, error); + + if (error) + error.Log(); + + return returnMessage; +} + +DBusMessage *CDBusMessage::Send(DBusBusType type, CDBusError& error) +{ + CDBusConnection con; + if (!con.Connect(type, error)) + return nullptr; + + DBusMessage *returnMessage = Send(con, error); + + return returnMessage; +} + +bool CDBusMessage::SendAsync(DBusBusType type) +{ + CDBusConnection con; + if (!con.Connect(type)) + return false; + + return dbus_connection_send(con, m_message.get(), nullptr); +} + +DBusMessage *CDBusMessage::Send(DBusConnection *con, CDBusError& error) +{ + m_reply.reset(dbus_connection_send_with_reply_and_block(con, m_message.get(), -1, error)); + return m_reply.get(); +} + +void CDBusMessage::PrepareArgument() +{ + if (!m_haveArgs) + dbus_message_iter_init_append(m_message.get(), &m_args); + + m_haveArgs = true; +} + +bool CDBusMessage::InitializeReplyIter(DBusMessageIter* iter) +{ + if (!m_reply) + { + throw std::logic_error("Cannot get reply arguments of message that does not have reply"); + } + if (!dbus_message_iter_init(m_reply.get(), iter)) + { + CLog::Log(LOGWARNING, "Tried to obtain reply arguments from message that has zero arguments"); + return false; + } + return true; +} + +bool CDBusMessage::CheckTypeAndGetValue(DBusMessageIter* iter, int expectType, void* dest) +{ + const int haveType = dbus_message_iter_get_arg_type(iter); + if (haveType != expectType) + { + CLog::Log(LOGDEBUG, "DBus argument type mismatch: expected {}, got {}", expectType, haveType); + return false; + } + + dbus_message_iter_get_basic(iter, dest); + return true; +} diff --git a/xbmc/platform/linux/DBusMessage.h b/xbmc/platform/linux/DBusMessage.h new file mode 100644 index 0000000..80c7cd6 --- /dev/null +++ b/xbmc/platform/linux/DBusMessage.h @@ -0,0 +1,149 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include <cstdint> +#include <memory> +#include <string> +#include <type_traits> + +#include <dbus/dbus.h> + +class CDBusError; + +template<typename T> +struct ToDBusType; +template<> struct ToDBusType<bool> { static constexpr int TYPE = DBUS_TYPE_BOOLEAN; }; +template<> struct ToDBusType<char*> { static constexpr int TYPE = DBUS_TYPE_STRING; }; +template<> struct ToDBusType<const char*> { static constexpr int TYPE = DBUS_TYPE_STRING; }; +template<> struct ToDBusType<std::uint8_t> { static constexpr int TYPE = DBUS_TYPE_BYTE; }; +template<> struct ToDBusType<std::int16_t> { static constexpr int TYPE = DBUS_TYPE_INT16; }; +template<> struct ToDBusType<std::uint16_t> { static constexpr int TYPE = DBUS_TYPE_UINT16; }; +template<> struct ToDBusType<std::int32_t> { static constexpr int TYPE = DBUS_TYPE_INT32; }; +template<> struct ToDBusType<std::uint32_t> { static constexpr int TYPE = DBUS_TYPE_UINT32; }; +template<> struct ToDBusType<std::int64_t> { static constexpr int TYPE = DBUS_TYPE_INT64; }; +template<> struct ToDBusType<std::uint64_t> { static constexpr int TYPE = DBUS_TYPE_UINT64; }; +template<> struct ToDBusType<double> { static constexpr int TYPE = DBUS_TYPE_DOUBLE; }; + +template<typename T> +using ToDBusTypeFromPointer = ToDBusType<typename std::remove_pointer<T>::type>; + +struct DBusMessageDeleter +{ + void operator()(DBusMessage* message) const; +}; +using DBusMessagePtr = std::unique_ptr<DBusMessage, DBusMessageDeleter>; + +class CDBusMessage +{ +public: + CDBusMessage(const char *destination, const char *object, const char *interface, const char *method); + CDBusMessage(std::string const& destination, std::string const& object, std::string const& interface, std::string const& method); + + void AppendObjectPath(const char *object); + + template<typename T> + void AppendArgument(const T arg) + { + AppendWithType(ToDBusType<T>::TYPE, &arg); + } + void AppendArgument(const char **arrayString, unsigned int length); + + template<typename TFirst> + void AppendArguments(const TFirst first) + { + AppendArgument(first); + // Recursion end + } + template<typename TFirst, typename... TArgs> + void AppendArguments(const TFirst first, const TArgs... args) + { + AppendArgument(first); + AppendArguments(args...); + } + + DBusMessageIter * GetArgumentIter(); + + /** + * Retrieve simple arguments from DBus reply message + * + * You MUST use the correct fixed-width integer typedefs (e.g. std::uint16_t) + * corresponding to the DBus types for the variables or you will get potentially + * differing behavior between architectures since the DBus argument type detection + * is based on the width of the type. + * + * Complex arguments (arrays, structs) are not supported. + * + * Returned pointers for strings are only valid until the instance of this class + * is deleted. + * + * \throw std::logic_error if the message has no reply + * \return whether all arguments could be retrieved (false on argument type + * mismatch or when more arguments were to be retrieved than there are + * in the message) + */ + template<typename... TArgs> + bool GetReplyArguments(TArgs*... args) + { + DBusMessageIter iter; + if (!InitializeReplyIter(&iter)) + { + return false; + } + return GetReplyArgumentsWithIter(&iter, args...); + } + + DBusMessage *SendSystem(); + DBusMessage *SendSession(); + DBusMessage *SendSystem(CDBusError& error); + DBusMessage *SendSession(CDBusError& error); + + bool SendAsyncSystem(); + bool SendAsyncSession(); + + DBusMessage *Send(DBusBusType type); + DBusMessage *Send(DBusBusType type, CDBusError& error); + DBusMessage *Send(DBusConnection *con, CDBusError& error); +private: + void AppendWithType(int type, const void* value); + bool SendAsync(DBusBusType type); + + void PrepareArgument(); + + bool InitializeReplyIter(DBusMessageIter* iter); + bool CheckTypeAndGetValue(DBusMessageIter* iter, int expectType, void* dest); + template<typename TFirst> + bool GetReplyArgumentsWithIter(DBusMessageIter* iter, TFirst* first) + { + // Recursion end + return CheckTypeAndGetValue(iter, ToDBusTypeFromPointer<TFirst>::TYPE, first); + } + template<typename TFirst, typename... TArgs> + bool GetReplyArgumentsWithIter(DBusMessageIter* iter, TFirst* first, TArgs*... args) + { + if (!CheckTypeAndGetValue(iter, ToDBusTypeFromPointer<TFirst>::TYPE, first)) + { + return false; + } + // Ignore return value, if we try to read past the end of the message this + // will be catched by the type check (past-end type is DBUS_TYPE_INVALID) + dbus_message_iter_next(iter); + return GetReplyArgumentsWithIter(iter, args...); + } + + DBusMessagePtr m_message; + DBusMessagePtr m_reply = nullptr; + DBusMessageIter m_args; + bool m_haveArgs; +}; + +template<> +void CDBusMessage::AppendArgument<bool>(const bool arg); +template<> +void CDBusMessage::AppendArgument<std::string>(const std::string arg); diff --git a/xbmc/platform/linux/DBusUtil.cpp b/xbmc/platform/linux/DBusUtil.cpp new file mode 100644 index 0000000..2efb75c --- /dev/null +++ b/xbmc/platform/linux/DBusUtil.cpp @@ -0,0 +1,296 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ +#include "DBusUtil.h" + +#include "utils/log.h" + +CVariant CDBusUtil::GetVariant(const char *destination, const char *object, const char *interface, const char *property) +{ +//dbus-send --system --print-reply --dest=destination object org.freedesktop.DBus.Properties.Get string:interface string:property + CDBusMessage message(destination, object, "org.freedesktop.DBus.Properties", "Get"); + CVariant result; + + message.AppendArgument(interface); + message.AppendArgument(property); + DBusMessage *reply = message.SendSystem(); + + if (reply) + { + DBusMessageIter iter; + + if (dbus_message_iter_init(reply, &iter)) + { + if (!dbus_message_has_signature(reply, "v")) + CLog::Log(LOGERROR, "DBus: wrong signature on Get - should be \"v\" but was {}", + dbus_message_iter_get_signature(&iter)); + else + result = ParseVariant(&iter); + } + } + + return result; +} + +CVariant CDBusUtil::GetAll(const char *destination, const char *object, const char *interface) +{ + CDBusMessage message(destination, object, "org.freedesktop.DBus.Properties", "GetAll"); + CVariant properties; + message.AppendArgument(interface); + DBusMessage *reply = message.SendSystem(); + if (reply) + { + DBusMessageIter iter; + if (dbus_message_iter_init(reply, &iter)) + { + if (!dbus_message_has_signature(reply, "a{sv}")) + CLog::Log(LOGERROR, "DBus: wrong signature on GetAll - should be \"a{sv}\" but was {}", + dbus_message_iter_get_signature(&iter)); + else + { + do + { + DBusMessageIter sub; + dbus_message_iter_recurse(&iter, &sub); + do + { + DBusMessageIter dict; + dbus_message_iter_recurse(&sub, &dict); + do + { + const char * key = NULL; + + dbus_message_iter_get_basic(&dict, &key); + if (!dbus_message_iter_next(&dict)) + break; + + CVariant value = ParseVariant(&dict); + + if (!value.isNull()) + properties[key] = value; + + } while (dbus_message_iter_next(&dict)); + + } while (dbus_message_iter_next(&sub)); + + } while (dbus_message_iter_next(&iter)); + } + } + } + + return properties; +} + +CVariant CDBusUtil::ParseVariant(DBusMessageIter *itr) +{ + DBusMessageIter variant; + dbus_message_iter_recurse(itr, &variant); + + return ParseType(&variant); +} + +CVariant CDBusUtil::ParseType(DBusMessageIter *itr) +{ + CVariant value; + const char * string = NULL; + dbus_int32_t int32 = 0; + dbus_uint32_t uint32 = 0; + dbus_int64_t int64 = 0; + dbus_uint64_t uint64 = 0; + dbus_bool_t boolean = false; + double doublev = 0; + + int type = dbus_message_iter_get_arg_type(itr); + switch (type) + { + case DBUS_TYPE_OBJECT_PATH: + case DBUS_TYPE_STRING: + dbus_message_iter_get_basic(itr, &string); + value = string; + break; + case DBUS_TYPE_UINT32: + dbus_message_iter_get_basic(itr, &uint32); + value = (uint64_t)uint32; + break; + case DBUS_TYPE_BYTE: + case DBUS_TYPE_INT32: + dbus_message_iter_get_basic(itr, &int32); + value = (int64_t)int32; + break; + case DBUS_TYPE_UINT64: + dbus_message_iter_get_basic(itr, &uint64); + value = (uint64_t)uint64; + break; + case DBUS_TYPE_INT64: + dbus_message_iter_get_basic(itr, &int64); + value = (int64_t)int64; + break; + case DBUS_TYPE_BOOLEAN: + dbus_message_iter_get_basic(itr, &boolean); + value = (bool)boolean; + break; + case DBUS_TYPE_DOUBLE: + dbus_message_iter_get_basic(itr, &doublev); + value = doublev; + break; + case DBUS_TYPE_ARRAY: + DBusMessageIter array; + dbus_message_iter_recurse(itr, &array); + + value = CVariant::VariantTypeArray; + + do + { + CVariant item = ParseType(&array); + if (!item.isNull()) + value.push_back(item); + } while (dbus_message_iter_next(&array)); + break; + } + + return value; +} + +bool CDBusUtil::TryMethodCall(DBusBusType bus, const char* destination, const char* object, const char* interface, const char* method) +{ + CDBusMessage message(destination, object, interface, method); + CDBusError error; + message.Send(bus, error); + if (error) + { + error.Log(LOGDEBUG, std::string("DBus method call to ") + interface + "." + method + " at " + object + " of " + destination + " failed"); + } + return !error; +} + +bool CDBusUtil::TryMethodCall(DBusBusType bus, std::string const& destination, std::string const& object, std::string const& interface, std::string const& method) +{ + return TryMethodCall(bus, destination.c_str(), object.c_str(), interface.c_str(), method.c_str()); +} + +CDBusConnection::CDBusConnection() = default; + +bool CDBusConnection::Connect(DBusBusType bus, bool openPrivate) +{ + CDBusError error; + Connect(bus, error, openPrivate); + if (error) + { + error.Log(LOGWARNING, "DBus connection failed"); + return false; + } + + return true; +} + +bool CDBusConnection::Connect(DBusBusType bus, CDBusError& error, bool openPrivate) +{ + if (m_connection) + { + throw std::logic_error("Cannot reopen connected DBus connection"); + } + + m_connection.get_deleter().closeBeforeUnref = openPrivate; + + if (openPrivate) + { + m_connection.reset(dbus_bus_get_private(bus, error)); + } + else + { + m_connection.reset(dbus_bus_get(bus, error)); + } + + return !!m_connection; +} + +CDBusConnection::operator DBusConnection*() +{ + return m_connection.get(); +} + +void CDBusConnection::DBusConnectionDeleter::operator()(DBusConnection* connection) const +{ + if (closeBeforeUnref) + { + dbus_connection_close(connection); + } + dbus_connection_unref(connection); +} + +void CDBusConnection::Destroy() +{ + m_connection.reset(); +} + + +CDBusError::CDBusError() +{ + dbus_error_init(&m_error); +} + +CDBusError::~CDBusError() +{ + Reset(); +} + +void CDBusError::Reset() +{ + dbus_error_free(&m_error); +} + +CDBusError::operator DBusError*() +{ + return &m_error; +} + +bool CDBusError::IsSet() const +{ + return dbus_error_is_set(&m_error); +} + +CDBusError::operator bool() +{ + return IsSet(); +} + +CDBusError::operator bool() const +{ + return IsSet(); +} + +std::string CDBusError::Name() const +{ + if (!IsSet()) + { + throw std::logic_error("Cannot retrieve name of unset DBus error"); + } + return m_error.name; +} + +std::string CDBusError::Message() const +{ + if (!IsSet()) + { + throw std::logic_error("Cannot retrieve message of unset DBus error"); + } + return m_error.message; +} + +void CDBusError::Log(std::string const& message) const +{ + Log(LOGERROR, message); +} + +void CDBusError::Log(int level, const std::string& message) const +{ + if (!IsSet()) + { + throw std::logic_error("Cannot log unset DBus error"); + } + CLog::Log(level, "{}: {} - {}", message, m_error.name, m_error.message); +} diff --git a/xbmc/platform/linux/DBusUtil.h b/xbmc/platform/linux/DBusUtil.h new file mode 100644 index 0000000..57349ac --- /dev/null +++ b/xbmc/platform/linux/DBusUtil.h @@ -0,0 +1,88 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "DBusMessage.h" +#include "utils/Variant.h" + +#include <memory> +#include <string> + +#include <dbus/dbus.h> + +class CDBusUtil +{ +public: + static CVariant GetAll(const char *destination, const char *object, const char *interface); + static CVariant GetVariant(const char *destination, const char *object, const char *interface, const char *property); + /** + * Try to call a DBus method and return whether the call succeeded + */ + static bool TryMethodCall(DBusBusType bus, const char* destination, const char* object, const char* interface, const char* method); + /** + * Try to call a DBus method and return whether the call succeeded + */ + static bool TryMethodCall(DBusBusType bus, std::string const& destination, std::string const& object, std::string const& interface, std::string const& method); + +private: + static CVariant ParseType(DBusMessageIter *itr); + static CVariant ParseVariant(DBusMessageIter *itr); +}; + +class CDBusConnection +{ +public: + CDBusConnection(); + bool Connect(DBusBusType bus, bool openPrivate = false); + bool Connect(DBusBusType bus, CDBusError& error, bool openPrivate = false); + void Destroy(); + operator DBusConnection*(); + +private: + CDBusConnection(CDBusConnection const& other) = delete; + CDBusConnection& operator=(CDBusConnection const& other) = delete; + + struct DBusConnectionDeleter + { + DBusConnectionDeleter() {} + bool closeBeforeUnref = false; + void operator()(DBusConnection* connection) const; + }; + std::unique_ptr<DBusConnection, DBusConnectionDeleter> m_connection; +}; + +class CDBusError +{ +public: + CDBusError(); + ~CDBusError(); + operator DBusError*(); + bool IsSet() const; + /** + * Reset this error wrapper + * + * If there was an error, it was handled and this error wrapper should be used + * again in a new call, it must be reset before that call. + */ + void Reset(); + // Keep because operator DBusError* would be used for if-statements on + // non-const CDBusError instead + operator bool(); + operator bool() const; + std::string Name() const; + std::string Message() const; + void Log(std::string const& message = "DBus error") const; + void Log(int level, std::string const& message = "DBus error") const; + +private: + CDBusError(CDBusError const& other) = delete; + CDBusError& operator=(CDBusError const& other) = delete; + + DBusError m_error; +}; diff --git a/xbmc/platform/linux/FDEventMonitor.cpp b/xbmc/platform/linux/FDEventMonitor.cpp new file mode 100644 index 0000000..9cd27c1 --- /dev/null +++ b/xbmc/platform/linux/FDEventMonitor.cpp @@ -0,0 +1,243 @@ +/* + * Copyright (C) 2014-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "FDEventMonitor.h" + +#include "threads/SingleLock.h" +#include "utils/log.h" + +#include <errno.h> +#include <mutex> + +#include <poll.h> +#include <sys/eventfd.h> +#include <unistd.h> + +#include "PlatformDefs.h" + +CFDEventMonitor::CFDEventMonitor() : + CThread("FDEventMonitor") +{ +} + +CFDEventMonitor::~CFDEventMonitor() +{ + std::unique_lock<CCriticalSection> lock(m_mutex); + InterruptPoll(); + + if (m_wakeupfd >= 0) + { + /* sets m_bStop */ + StopThread(false); + + /* wake up the poll() call */ + eventfd_write(m_wakeupfd, 1); + + /* Wait for the thread to stop */ + { + CSingleExit exit(m_mutex); + StopThread(true); + } + + close(m_wakeupfd); + } +} + +void CFDEventMonitor::AddFD(const MonitoredFD& monitoredFD, int& id) +{ + std::unique_lock<CCriticalSection> lock(m_mutex); + InterruptPoll(); + + AddFDLocked(monitoredFD, id); + + StartMonitoring(); +} + +void CFDEventMonitor::AddFDs(const std::vector<MonitoredFD>& monitoredFDs, + std::vector<int>& ids) +{ + std::unique_lock<CCriticalSection> lock(m_mutex); + InterruptPoll(); + + for (unsigned int i = 0; i < monitoredFDs.size(); ++i) + { + int id; + AddFDLocked(monitoredFDs[i], id); + ids.push_back(id); + } + + StartMonitoring(); +} + +void CFDEventMonitor::RemoveFD(int id) +{ + std::unique_lock<CCriticalSection> lock(m_mutex); + InterruptPoll(); + + if (m_monitoredFDs.erase(id) != 1) + { + CLog::Log(LOGERROR, "CFDEventMonitor::RemoveFD - Tried to remove non-existing monitoredFD {}", + id); + } + + UpdatePollDescs(); +} + +void CFDEventMonitor::RemoveFDs(const std::vector<int>& ids) +{ + std::unique_lock<CCriticalSection> lock(m_mutex); + InterruptPoll(); + + for (unsigned int i = 0; i < ids.size(); ++i) + { + if (m_monitoredFDs.erase(ids[i]) != 1) + { + CLog::Log(LOGERROR, + "CFDEventMonitor::RemoveFDs - Tried to remove non-existing monitoredFD {} while " + "removing {} FDs", + ids[i], (unsigned)ids.size()); + } + } + + UpdatePollDescs(); +} + +void CFDEventMonitor::Process() +{ + eventfd_t dummy; + + while (!m_bStop) + { + std::unique_lock<CCriticalSection> lock(m_mutex); + std::unique_lock<CCriticalSection> pollLock(m_pollMutex); + + /* + * Leave the main mutex here to allow another thread to + * lock it while we are in poll(). + * By then calling InterruptPoll() the other thread can + * wake up poll and wait for the processing to pause at + * the above lock(m_mutex). + */ + lock.unlock(); + + int err = poll(&m_pollDescs[0], m_pollDescs.size(), -1); + + if (err < 0 && errno != EINTR) + { + CLog::Log(LOGERROR, "CFDEventMonitor::Process - poll() failed, error {}, stopping monitoring", + errno); + StopThread(false); + } + + // Something woke us up - either there is data available or we are being + // paused/stopped via m_wakeupfd. + + for (unsigned int i = 0; i < m_pollDescs.size(); ++i) + { + struct pollfd& pollDesc = m_pollDescs[i]; + int id = m_monitoredFDbyPollDescs[i]; + const MonitoredFD& monitoredFD = m_monitoredFDs[id]; + + if (pollDesc.revents) + { + if (monitoredFD.callback) + { + monitoredFD.callback(id, pollDesc.fd, pollDesc.revents, + monitoredFD.callbackData); + } + + if (pollDesc.revents & (POLLERR | POLLHUP | POLLNVAL)) + { + CLog::Log(LOGERROR, + "CFDEventMonitor::Process - polled fd {} got revents 0x{:x}, removing it", + pollDesc.fd, pollDesc.revents); + + /* Probably would be nice to inform our caller that their FD was + * dropped, but oh well... */ + m_monitoredFDs.erase(id); + UpdatePollDescs(); + } + + pollDesc.revents = 0; + } + } + + /* flush wakeup fd */ + eventfd_read(m_wakeupfd, &dummy); + + } +} + +void CFDEventMonitor::AddFDLocked(const MonitoredFD& monitoredFD, int& id) +{ + id = m_nextID; + + while (m_monitoredFDs.count(id)) + { + ++id; + } + m_nextID = id + 1; + + m_monitoredFDs[id] = monitoredFD; + + AddPollDesc(id, monitoredFD.fd, monitoredFD.events); +} + +void CFDEventMonitor::AddPollDesc(int id, int fd, short events) +{ + struct pollfd newPollFD; + newPollFD.fd = fd; + newPollFD.events = events; + newPollFD.revents = 0; + + m_pollDescs.push_back(newPollFD); + m_monitoredFDbyPollDescs.push_back(id); +} + +void CFDEventMonitor::UpdatePollDescs() +{ + m_monitoredFDbyPollDescs.clear(); + m_pollDescs.clear(); + + for (const auto& it : m_monitoredFDs) + { + AddPollDesc(it.first, it.second.fd, it.second.events); + } +} + +void CFDEventMonitor::StartMonitoring() +{ + if (!IsRunning()) + { + /* Start the monitoring thread */ + + m_wakeupfd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK); + if (m_wakeupfd < 0) + { + CLog::Log(LOGERROR, "CFDEventMonitor::StartMonitoring - Failed to create eventfd, error {}", + errno); + return; + } + + /* Add wakeup fd to the fd list */ + int id; + AddFDLocked(MonitoredFD(m_wakeupfd, POLLIN, NULL, NULL), id); + + Create(false); + } +} + +void CFDEventMonitor::InterruptPoll() +{ + if (m_wakeupfd >= 0) + { + eventfd_write(m_wakeupfd, 1); + /* wait for the poll() result handling (if any) to end */ + std::unique_lock<CCriticalSection> pollLock(m_pollMutex); + } +} diff --git a/xbmc/platform/linux/FDEventMonitor.h b/xbmc/platform/linux/FDEventMonitor.h new file mode 100644 index 0000000..c0b8395 --- /dev/null +++ b/xbmc/platform/linux/FDEventMonitor.h @@ -0,0 +1,74 @@ +/* + * Copyright (C) 2014-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "platform/Platform.h" +#include "threads/CriticalSection.h" +#include "threads/Thread.h" + +#include <map> +#include <vector> + +#include <sys/epoll.h> + +/** + * Monitor a file descriptor with callback on poll() events. + */ +class CFDEventMonitor : public IPlatformService, private CThread +{ +public: + + typedef void (*EventCallback)(int id, int fd, short revents, void *data); + + struct MonitoredFD + { + int fd = -1; /**< File descriptor to be monitored */ + short events = 0; /**< Events to be monitored (see poll(2)) */ + + EventCallback callback = nullptr; /** Callback to be called on events */ + void *callbackData = nullptr; /** data parameter for EventCallback */ + + MonitoredFD(int fd_, short events_, EventCallback callback_, void *callbackData_) : + fd(fd_), events(events_), callback(callback_), callbackData(callbackData_) {} + MonitoredFD() = default; + }; + + CFDEventMonitor(); + ~CFDEventMonitor() override; + + void AddFD(const MonitoredFD& monitoredFD, int& id); + void AddFDs(const std::vector<MonitoredFD>& monitoredFDs, std::vector<int>& ids); + + void RemoveFD(int id); + void RemoveFDs(const std::vector<int>& ids); + +protected: + void Process() override; + +private: + void AddFDLocked(const MonitoredFD& monitoredFD, int& id); + + void AddPollDesc(int id, int fd, short events); + void UpdatePollDescs(); + + void StartMonitoring(); + void InterruptPoll(); + + std::map<int, MonitoredFD> m_monitoredFDs; + + /* these are kept synchronized */ + std::vector<int> m_monitoredFDbyPollDescs; + std::vector<struct pollfd> m_pollDescs; + + int m_nextID = 0; + int m_wakeupfd = -1; + + CCriticalSection m_mutex; + CCriticalSection m_pollMutex; +}; diff --git a/xbmc/platform/linux/MemUtils.cpp b/xbmc/platform/linux/MemUtils.cpp new file mode 100644 index 0000000..09dd22f --- /dev/null +++ b/xbmc/platform/linux/MemUtils.cpp @@ -0,0 +1,79 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "utils/MemUtils.h" + +#include <cstdlib> +#include <fstream> + +namespace KODI +{ +namespace MEMORY +{ + +void* AlignedMalloc(size_t s, size_t alignTo) +{ + void* p = nullptr; + int res = posix_memalign(&p, alignTo, s); + if (res == EINVAL) + { + throw std::runtime_error("Failed to align memory, alignment is not a multiple of 2"); + } + else if (res == ENOMEM) + { + throw std::runtime_error("Failed to align memory, insufficient memory available"); + } + return p; +} + +void AlignedFree(void* p) +{ + if (!p) + return; + + free(p); +} + +void GetMemoryStatus(MemoryStatus* buffer) +{ + if (!buffer) + return; + + std::ifstream file("/proc/meminfo"); + + if (!file.is_open()) + return; + + uint64_t buffers; + uint64_t cached; + uint64_t free; + uint64_t total; + uint64_t reclaimable; + + std::string token; + + while (file >> token) + { + if (token == "Buffers:") + file >> buffers; + if (token == "Cached:") + file >> cached; + if (token == "MemFree:") + file >> free; + if (token == "MemTotal:") + file >> total; + if (token == "SReclaimable:") + file >> reclaimable; + } + + buffer->totalPhys = total * 1024; + buffer->availPhys = (free + cached + reclaimable + buffers) * 1024; +} + +} +} diff --git a/xbmc/platform/linux/OptionalsReg.cpp b/xbmc/platform/linux/OptionalsReg.cpp new file mode 100644 index 0000000..82fb176 --- /dev/null +++ b/xbmc/platform/linux/OptionalsReg.cpp @@ -0,0 +1,114 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "OptionalsReg.h" + + +//----------------------------------------------------------------------------- +// ALSA +//----------------------------------------------------------------------------- + +#ifdef HAS_ALSA +#include "cores/AudioEngine/Sinks/AESinkALSA.h" +bool OPTIONALS::ALSARegister() +{ + CAESinkALSA::Register(); + return true; +} +#else +bool OPTIONALS::ALSARegister() +{ + return false; +} +#endif + +//----------------------------------------------------------------------------- +// PulseAudio +//----------------------------------------------------------------------------- + +#ifdef HAS_PULSEAUDIO +#include "cores/AudioEngine/Sinks/AESinkPULSE.h" +bool OPTIONALS::PulseAudioRegister() +{ + bool ret = CAESinkPULSE::Register(); + return ret; +} +#else +bool OPTIONALS::PulseAudioRegister() +{ + return false; +} +#endif + +//----------------------------------------------------------------------------- +// Pipewire +//----------------------------------------------------------------------------- + +#ifdef HAS_PIPEWIRE +#include "cores/AudioEngine/Sinks/pipewire/AESinkPipewire.h" +bool OPTIONALS::PipewireRegister() +{ + bool ret = AE::SINK::CAESinkPipewire::Register(); + return ret; +} +#else +bool OPTIONALS::PipewireRegister() +{ + return false; +} +#endif + +//----------------------------------------------------------------------------- +// sndio +//----------------------------------------------------------------------------- + +#ifdef HAS_SNDIO +#include "cores/AudioEngine/Sinks/AESinkSNDIO.h" +bool OPTIONALS::SndioRegister() +{ + CAESinkSNDIO::Register(); + return true; +} +#else +bool OPTIONALS::SndioRegister() +{ + return false; +} +#endif + +//----------------------------------------------------------------------------- +// Lirc +//----------------------------------------------------------------------------- + +#ifdef HAS_LIRC +#include "platform/linux/input/LIRC.h" +#include "ServiceBroker.h" +class OPTIONALS::CLircContainer +{ +public: + CLircContainer() + { + m_lirc.Start(); + } +protected: + CLirc m_lirc; +}; +#else +class OPTIONALS::CLircContainer +{ +}; +#endif + +OPTIONALS::CLircContainer* OPTIONALS::LircRegister() +{ + return new CLircContainer(); +} +void OPTIONALS::delete_CLircContainer::operator()(CLircContainer *p) const +{ + delete p; +} diff --git a/xbmc/platform/linux/OptionalsReg.h b/xbmc/platform/linux/OptionalsReg.h new file mode 100644 index 0000000..75fdb6a --- /dev/null +++ b/xbmc/platform/linux/OptionalsReg.h @@ -0,0 +1,59 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +//----------------------------------------------------------------------------- +// ALSA +//----------------------------------------------------------------------------- + +namespace OPTIONALS +{ +bool ALSARegister(); +} + +//----------------------------------------------------------------------------- +// PulseAudio +//----------------------------------------------------------------------------- + +namespace OPTIONALS +{ +bool PulseAudioRegister(); +} + +//----------------------------------------------------------------------------- +// Pipewire +//----------------------------------------------------------------------------- + +namespace OPTIONALS +{ +bool PipewireRegister(); +} + +//----------------------------------------------------------------------------- +// sndio +//----------------------------------------------------------------------------- + +namespace OPTIONALS +{ +bool SndioRegister(); +} + +//----------------------------------------------------------------------------- +// Lirc +//----------------------------------------------------------------------------- + +namespace OPTIONALS +{ +class CLircContainer; +CLircContainer* LircRegister(); +struct delete_CLircContainer +{ + void operator()(CLircContainer *p) const; +}; +} diff --git a/xbmc/platform/linux/PlatformLinux.cpp b/xbmc/platform/linux/PlatformLinux.cpp new file mode 100644 index 0000000..a7af098 --- /dev/null +++ b/xbmc/platform/linux/PlatformLinux.cpp @@ -0,0 +1,163 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "PlatformLinux.h" + +#if defined(HAS_ALSA) +#include "cores/AudioEngine/Sinks/alsa/ALSADeviceMonitor.h" +#include "cores/AudioEngine/Sinks/alsa/ALSAHControlMonitor.h" +#endif + +#include "utils/StringUtils.h" + +#if defined(HAS_ALSA) +#include "platform/linux/FDEventMonitor.h" +#endif + +#include "platform/linux/powermanagement/LinuxPowerSyscall.h" + +// clang-format off +#if defined(HAS_GLES) +#if defined(HAVE_WAYLAND) +#include "windowing/wayland/WinSystemWaylandEGLContextGLES.h" +#endif +#if defined(HAVE_X11) +#include "windowing/X11/WinSystemX11GLESContext.h" +#endif +#if defined(HAVE_GBM) +#include "windowing/gbm/WinSystemGbmGLESContext.h" +#endif +#endif + +#if defined(HAS_GL) +#if defined(HAVE_WAYLAND) +#include "windowing/wayland/WinSystemWaylandEGLContextGL.h" +#endif +#if defined(HAVE_X11) +#include "windowing/X11/WinSystemX11GLContext.h" +#endif +#if defined(HAVE_GBM) +#include "windowing/gbm/WinSystemGbmGLContext.h" +#endif +#endif +// clang-format on + +#include <cstdlib> + +CPlatform* CPlatform::CreateInstance() +{ + return new CPlatformLinux(); +} + +bool CPlatformLinux::InitStageOne() +{ + if (!CPlatformPosix::InitStageOne()) + return false; + + setenv("OS", "Linux", true); // for python scripts that check the OS + +#if defined(HAS_GLES) +#if defined(HAVE_WAYLAND) + KODI::WINDOWING::WAYLAND::CWinSystemWaylandEGLContextGLES::Register(); +#endif +#if defined(HAVE_X11) + KODI::WINDOWING::X11::CWinSystemX11GLESContext::Register(); +#endif +#if defined(HAVE_GBM) + KODI::WINDOWING::GBM::CWinSystemGbmGLESContext::Register(); +#endif +#endif + +#if defined(HAS_GL) +#if defined(HAVE_WAYLAND) + KODI::WINDOWING::WAYLAND::CWinSystemWaylandEGLContextGL::Register(); +#endif +#if defined(HAVE_X11) + KODI::WINDOWING::X11::CWinSystemX11GLContext::Register(); +#endif +#if defined(HAVE_GBM) + KODI::WINDOWING::GBM::CWinSystemGbmGLContext::Register(); +#endif +#endif + + CLinuxPowerSyscall::Register(); + + std::string envSink; + if (getenv("KODI_AE_SINK")) + envSink = getenv("KODI_AE_SINK"); + + if (StringUtils::EqualsNoCase(envSink, "ALSA")) + { + OPTIONALS::ALSARegister(); + } + else if (StringUtils::EqualsNoCase(envSink, "PULSE")) + { + OPTIONALS::PulseAudioRegister(); + } + else if (StringUtils::EqualsNoCase(envSink, "PIPEWIRE")) + { + OPTIONALS::PipewireRegister(); + } + else if (StringUtils::EqualsNoCase(envSink, "SNDIO")) + { + OPTIONALS::SndioRegister(); + } + else if (StringUtils::EqualsNoCase(envSink, "ALSA+PULSE")) + { + OPTIONALS::ALSARegister(); + OPTIONALS::PulseAudioRegister(); + } + else + { + if (!OPTIONALS::PulseAudioRegister()) + { + if (!OPTIONALS::PipewireRegister()) + { + if (!OPTIONALS::ALSARegister()) + { + OPTIONALS::SndioRegister(); + } + } + } + } + + m_lirc.reset(OPTIONALS::LircRegister()); + +#if defined(HAS_ALSA) + RegisterComponent(std::make_shared<CFDEventMonitor>()); +#if defined(HAVE_LIBUDEV) + RegisterComponent(std::make_shared<CALSADeviceMonitor>()); +#endif +#if !defined(HAVE_X11) + RegisterComponent(std::make_shared<CALSAHControlMonitor>()); +#endif +#endif // HAS_ALSA + return true; +} + +void CPlatformLinux::DeinitStageOne() +{ +#if defined(HAS_ALSA) +#if !defined(HAVE_X11) + DeregisterComponent(typeid(CALSAHControlMonitor)); +#endif +#if defined(HAVE_LIBUDEV) + DeregisterComponent(typeid(CALSADeviceMonitor)); +#endif + DeregisterComponent(typeid(CFDEventMonitor)); +#endif // HAS_ALSA +} + +bool CPlatformLinux::IsConfigureAddonsAtStartupEnabled() +{ +#if defined(ADDONS_CONFIGURE_AT_STARTUP) + return true; +#else + return false; +#endif +} diff --git a/xbmc/platform/linux/PlatformLinux.h b/xbmc/platform/linux/PlatformLinux.h new file mode 100644 index 0000000..b74deb6 --- /dev/null +++ b/xbmc/platform/linux/PlatformLinux.h @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "platform/linux/OptionalsReg.h" +#include "platform/posix/PlatformPosix.h" + +#include <memory> + +class CPlatformLinux : public CPlatformPosix +{ +public: + CPlatformLinux() = default; + + ~CPlatformLinux() override = default; + + bool InitStageOne() override; + void DeinitStageOne() override; + + bool IsConfigureAddonsAtStartupEnabled() override; + +private: + std::unique_ptr<OPTIONALS::CLircContainer, OPTIONALS::delete_CLircContainer> m_lirc; +}; diff --git a/xbmc/platform/linux/SysfsPath.cpp b/xbmc/platform/linux/SysfsPath.cpp new file mode 100644 index 0000000..af4f9cb --- /dev/null +++ b/xbmc/platform/linux/SysfsPath.cpp @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2011-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "SysfsPath.h" + +#include <exception> + +bool CSysfsPath::Exists() +{ + std::ifstream file(m_path); + + if (!file.is_open()) + return false; + + return true; +} + +template<> +std::optional<std::string> CSysfsPath::Get() +{ + try + { + std::ifstream file(m_path); + + std::string value; + + std::getline(file, value); + + if (file.bad()) + { + CLog::LogF(LOGERROR, "error reading from '{}'", m_path); + return std::nullopt; + } + + return value; + } + catch (const std::exception& e) + { + CLog::LogF(LOGERROR, "exception reading from '{}': {}", m_path, e.what()); + return std::nullopt; + } +} diff --git a/xbmc/platform/linux/SysfsPath.h b/xbmc/platform/linux/SysfsPath.h new file mode 100644 index 0000000..3c19703 --- /dev/null +++ b/xbmc/platform/linux/SysfsPath.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2011-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "utils/log.h" + +#include <exception> +#include <fstream> +#include <optional> +#include <string> + +class CSysfsPath +{ +public: + CSysfsPath() = default; + CSysfsPath(const std::string& path) : m_path(path) {} + ~CSysfsPath() = default; + + bool Exists(); + + template<typename T> + std::optional<T> Get() + { + try + { + std::ifstream file(m_path); + + T value; + + file >> value; + + if (file.bad()) + { + CLog::LogF(LOGERROR, "error reading from '{}'", m_path); + return std::nullopt; + } + + return value; + } + catch (const std::exception& e) + { + CLog::LogF(LOGERROR, "exception reading from '{}': {}", m_path, e.what()); + return std::nullopt; + } + } + +private: + std::string m_path; +}; + +template<> +std::optional<std::string> CSysfsPath::Get<std::string>(); diff --git a/xbmc/platform/linux/TimeUtils.cpp b/xbmc/platform/linux/TimeUtils.cpp new file mode 100644 index 0000000..55cce92 --- /dev/null +++ b/xbmc/platform/linux/TimeUtils.cpp @@ -0,0 +1,14 @@ +/* + * Copyright (C) 2017-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "TimeUtils.h" + +std::int64_t KODI::LINUX::TimespecDifference(timespec const& start, timespec const& end) +{ + return (end.tv_sec - start.tv_sec) * UINT64_C(1000000000) + (end.tv_nsec - start.tv_nsec); +}
\ No newline at end of file diff --git a/xbmc/platform/linux/TimeUtils.h b/xbmc/platform/linux/TimeUtils.h new file mode 100644 index 0000000..abbeb13 --- /dev/null +++ b/xbmc/platform/linux/TimeUtils.h @@ -0,0 +1,28 @@ +/* + * Copyright (C) 2017-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include <cstdint> +#include <time.h> + +namespace KODI +{ +namespace LINUX +{ + +/** + * Calculate difference between two timespecs in nanoseconds + * \param start earlier time + * \param end later time + * \return (end - start) in nanoseconds + */ +std::int64_t TimespecDifference(timespec const& start, timespec const& end); + +} +} diff --git a/xbmc/platform/linux/input/CMakeLists.txt b/xbmc/platform/linux/input/CMakeLists.txt new file mode 100644 index 0000000..ebb2ccd --- /dev/null +++ b/xbmc/platform/linux/input/CMakeLists.txt @@ -0,0 +1,27 @@ +set(SOURCES "") +set(HEADERS "") + +if(LIRCCLIENT_FOUND) + list(APPEND SOURCES LIRC.cpp) + list(APPEND HEADERS LIRC.h) +endif() + +if("gbm" IN_LIST CORE_PLATFORM_NAME_LC) + if(LIBINPUT_FOUND) + list(APPEND SOURCES LibInputHandler.cpp + LibInputKeyboard.cpp + LibInputPointer.cpp + LibInputSettings.cpp + LibInputTouch.cpp) + + list(APPEND HEADERS LibInputHandler.h + LibInputKeyboard.h + LibInputPointer.h + LibInputSettings.h + LibInputTouch.h) + endif() +endif() + +if(SOURCES) + core_add_library(input_linux) +endif() diff --git a/xbmc/platform/linux/input/LIRC.cpp b/xbmc/platform/linux/input/LIRC.cpp new file mode 100644 index 0000000..6900f5c --- /dev/null +++ b/xbmc/platform/linux/input/LIRC.cpp @@ -0,0 +1,209 @@ +/* + * Copyright (C) 2007-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "LIRC.h" + +#include "ServiceBroker.h" +#include "application/AppInboundProtocol.h" +#include "profiles/ProfileManager.h" +#include "settings/AdvancedSettings.h" +#include "settings/Settings.h" +#include "settings/SettingsComponent.h" +#include "threads/SingleLock.h" +#include "utils/log.h" + +#include <mutex> + +#include <fcntl.h> +#include <lirc/lirc_client.h> +#include <sys/socket.h> +#include <sys/un.h> +#include <unistd.h> + +#include "PlatformDefs.h" + +using namespace std::chrono_literals; + +CLirc::CLirc() : CThread("Lirc") +{ +} + +CLirc::~CLirc() +{ + { + std::unique_lock<CCriticalSection> lock(m_critSection); + if (m_fd > 0) + shutdown(m_fd, SHUT_RDWR); + } + StopThread(); +} + +void CLirc::Start() +{ + Create(); + SetPriority(ThreadPriority::LOWEST); +} + +void CLirc::Process() +{ + auto settingsComponent = CServiceBroker::GetSettingsComponent(); + if (!settingsComponent) + throw std::runtime_error("CSettingsComponent needs to exist before starting CLirc"); + + auto settings = settingsComponent->GetSettings(); + if (!settings) + throw std::runtime_error("CSettings needs to exist before starting CLirc"); + + while (!settings->IsLoaded()) + CThread::Sleep(1000ms); + + m_profileId = settingsComponent->GetProfileManager()->GetCurrentProfileId(); + m_irTranslator.Load("Lircmap.xml"); + + // make sure work-around (CheckDaemon) uses the same socket path as lirc_init + const char* socket_path = getenv("LIRC_SOCKET_PATH"); + socket_path = socket_path ? socket_path : "/var/run/lirc/lircd"; + setenv("LIRC_SOCKET_PATH", socket_path, 0); + + while (!m_bStop) + { + { + std::unique_lock<CCriticalSection> lock(m_critSection); + + // lirc_client is buggy because it does not close socket, if connect fails + // work around by checking if daemon is running before calling lirc_init + if (!CheckDaemon()) + { + CSingleExit lock(m_critSection); + CThread::Sleep(1000ms); + continue; + } + + m_fd = lirc_init(const_cast<char*>("kodi"), 0); + if (m_fd <= 0) + { + CSingleExit lock(m_critSection); + CThread::Sleep(1000ms); + continue; + } + } + + char *code; + while (!m_bStop) + { + int ret = lirc_nextcode(&code); + if (ret < 0) + { + lirc_deinit(); + CThread::Sleep(1000ms); + break; + } + if (code != nullptr) + { + int profileId = settingsComponent->GetProfileManager()->GetCurrentProfileId(); + if (m_profileId != profileId) + { + m_profileId = profileId; + m_irTranslator.Load("Lircmap.xml"); + } + ProcessCode(code); + free(code); + } + } + } + + lirc_deinit(); +} + +void CLirc::ProcessCode(char *buf) +{ + // Parse the result. Sample line: + // 000000037ff07bdd 00 OK mceusb + char scanCode[128]; + char buttonName[128]; + char repeatStr[4]; + char deviceName[128]; + sscanf(buf, "%s %s %s %s", &scanCode[0], &repeatStr[0], &buttonName[0], &deviceName[0]); + + // Some template LIRC configuration have button names in apostrophes or quotes. + // If we got a quoted button name, strip 'em + unsigned int buttonNameLen = strlen(buttonName); + if (buttonNameLen > 2 && + ((buttonName[0] == '\'' && buttonName[buttonNameLen-1] == '\'') || + ((buttonName[0] == '"' && buttonName[buttonNameLen-1] == '"')))) + { + memmove(buttonName, buttonName + 1, buttonNameLen - 2); + buttonName[buttonNameLen - 2] = '\0'; + } + + int button = m_irTranslator.TranslateButton(deviceName, buttonName); + + char *end = nullptr; + long repeat = strtol(repeatStr, &end, 16); + if (!end || *end != 0) + CLog::Log(LOGERROR, "LIRC: invalid non-numeric character in expression {}", repeatStr); + + if (repeat == 0) + { + CLog::Log(LOGDEBUG, "LIRC: - NEW {} {} {} {} ({})", &scanCode[0], &repeatStr[0], &buttonName[0], + &deviceName[0], buttonName); + m_firstClickTime = std::chrono::steady_clock::now(); + + XBMC_Event newEvent = {}; + newEvent.type = XBMC_BUTTON; + newEvent.keybutton.button = button; + newEvent.keybutton.holdtime = 0; + std::shared_ptr<CAppInboundProtocol> appPort = CServiceBroker::GetAppPort(); + if (appPort) + appPort->OnEvent(newEvent); + return; + } + else if (repeat > CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_remoteDelay) + { + XBMC_Event newEvent = {}; + newEvent.type = XBMC_BUTTON; + newEvent.keybutton.button = button; + + auto now = std::chrono::steady_clock::now(); + auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(now - m_firstClickTime); + + newEvent.keybutton.holdtime = duration.count(); + std::shared_ptr<CAppInboundProtocol> appPort = CServiceBroker::GetAppPort(); + if (appPort) + appPort->OnEvent(newEvent); + } +} + +bool CLirc::CheckDaemon() +{ + const char* socket_path = getenv("LIRC_SOCKET_PATH"); + + struct sockaddr_un addr_un; + if (strlen(socket_path) + 1 > sizeof(addr_un.sun_path)) + { + return false; + } + + addr_un.sun_family = AF_UNIX; + strcpy(addr_un.sun_path, socket_path); + + int fd = socket(AF_UNIX, SOCK_STREAM, 0); + if (fd == -1) + { + return false; + } + + if (connect(fd, reinterpret_cast<struct sockaddr*>(&addr_un), sizeof(addr_un)) == -1) + { + close(fd); + return false; + } + + close(fd); + return true; +} diff --git a/xbmc/platform/linux/input/LIRC.h b/xbmc/platform/linux/input/LIRC.h new file mode 100644 index 0000000..f08638d --- /dev/null +++ b/xbmc/platform/linux/input/LIRC.h @@ -0,0 +1,35 @@ +/* + * Copyright (C) 2007-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "input/IRTranslator.h" +#include "threads/CriticalSection.h" +#include "threads/Thread.h" + +#include <chrono> +#include <string> + +class CLirc : CThread +{ +public: + CLirc(); + ~CLirc() override; + void Start(); + +protected: + void Process() override; + void ProcessCode(char *buf); + bool CheckDaemon(); + + int m_fd = -1; + std::chrono::time_point<std::chrono::steady_clock> m_firstClickTime; + CCriticalSection m_critSection; + CIRTranslator m_irTranslator; + int m_profileId; +}; diff --git a/xbmc/platform/linux/input/LibInputHandler.cpp b/xbmc/platform/linux/input/LibInputHandler.cpp new file mode 100644 index 0000000..a8c39f5 --- /dev/null +++ b/xbmc/platform/linux/input/LibInputHandler.cpp @@ -0,0 +1,301 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "LibInputHandler.h" + +#include "LibInputKeyboard.h" +#include "LibInputPointer.h" +#include "LibInputSettings.h" +#include "LibInputTouch.h" +#include "ServiceBroker.h" +#include "interfaces/AnnouncementManager.h" +#include "utils/log.h" + +#include <algorithm> +#include <string.h> + +#include <fcntl.h> +#include <linux/input.h> +#include <sys/epoll.h> +#include <sys/ioctl.h> +#include <unistd.h> + +static int open_restricted(const char *path, int flags, void __attribute__((unused)) *user_data) +{ + int fd = open(path, flags); + + if (fd < 0) + { + CLog::Log(LOGERROR, "{} - failed to open {} ({})", __FUNCTION__, path, strerror(errno)); + return -errno; + } + + auto ret = ioctl(fd, EVIOCGRAB, (void*)1); + if (ret < 0) + { + CLog::Log(LOGDEBUG, "{} - grab requested, but failed for {} ({})", __FUNCTION__, path, + strerror(errno)); + } + + return fd; +} + +static void close_restricted(int fd, void __attribute__((unused)) *user_data) +{ + close(fd); +} + +static const struct libinput_interface m_interface = +{ + open_restricted, + close_restricted, +}; + +static void LogHandler(libinput __attribute__((unused)) *libinput, libinput_log_priority priority, const char *format, va_list args) +{ + if (priority == LIBINPUT_LOG_PRIORITY_DEBUG) + { + char buf[512]; + int n = vsnprintf(buf, sizeof(buf), format, args); + if (n > 0) + CLog::Log(LOGDEBUG, "libinput: {}", buf); + } +} + +CLibInputHandler::CLibInputHandler() : CThread("libinput") +{ + m_udev = udev_new(); + if (!m_udev) + { + CLog::Log(LOGERROR, "CLibInputHandler::{} - failed to get udev context for libinput", + __FUNCTION__); + return; + } + + m_li = libinput_udev_create_context(&m_interface, nullptr, m_udev); + if (!m_li) + { + CLog::Log(LOGERROR, "CLibInputHandler::{} - failed to get libinput context", __FUNCTION__); + return; + } + + libinput_log_set_handler(m_li, LogHandler); + libinput_log_set_priority(m_li, LIBINPUT_LOG_PRIORITY_DEBUG); + + auto ret = libinput_udev_assign_seat(m_li, "seat0"); + if (ret < 0) + CLog::Log(LOGERROR, "CLibInputHandler::{} - failed to assign seat", __FUNCTION__); + + m_liFd = libinput_get_fd(m_li); + + m_keyboard.reset(new CLibInputKeyboard()); + m_pointer.reset(new CLibInputPointer()); + m_touch.reset(new CLibInputTouch()); + m_settings.reset(new CLibInputSettings(this)); + + CServiceBroker::GetAnnouncementManager()->AddAnnouncer(this); +} + +CLibInputHandler::~CLibInputHandler() +{ + CServiceBroker::GetAnnouncementManager()->RemoveAnnouncer(this); + StopThread(); + + libinput_unref(m_li); + udev_unref(m_udev); +} + +void CLibInputHandler::Announce(ANNOUNCEMENT::AnnouncementFlag flag, + const std::string& sender, + const std::string& message, + const CVariant& data) +{ + if (flag & (ANNOUNCEMENT::System)) + { + if (message == "OnSleep") + libinput_suspend(m_li); + else if (message == "OnWake") + { + auto ret = libinput_resume(m_li); + if (ret < 0) + CLog::Log(LOGERROR, "CLibInputHandler::{} - failed to resume monitoring", __FUNCTION__); + } + } +} + +bool CLibInputHandler::SetKeymap(const std::string& layout) +{ + return m_keyboard->SetKeymap(layout); +} + +void CLibInputHandler::Start() +{ + Create(); + SetPriority(ThreadPriority::LOWEST); +} + +void CLibInputHandler::Process() +{ + int epollFd = epoll_create1(EPOLL_CLOEXEC); + if (epollFd < 0) + { + CLog::Log(LOGERROR, "CLibInputHandler::{} - failed to create epoll file descriptor: {}", + __FUNCTION__, strerror(-errno)); + return; + } + + epoll_event event; + event.events = EPOLLIN; + event.data.fd = m_liFd; + + auto ret = epoll_ctl(epollFd, EPOLL_CTL_ADD, m_liFd, &event); + if (ret < 0) + { + CLog::Log(LOGERROR, "CLibInputHandler::{} - failed to add file descriptor to epoll: {}", + __FUNCTION__, strerror(-errno)); + close(epollFd); + return; + } + + while (!m_bStop) + { + epoll_wait(epollFd, &event, 1, 200); + + ret = libinput_dispatch(m_li); + if (ret < 0) + { + CLog::Log(LOGERROR, "CLibInputHandler::{} - libinput_dispatch failed: {}", __FUNCTION__, + strerror(-errno)); + close(epollFd); + return; + } + + libinput_event *ev; + while ((ev = libinput_get_event(m_li)) != nullptr) + { + ProcessEvent(ev); + libinput_event_destroy(ev); + } + } + + ret = close(epollFd); + if (ret < 0) + { + CLog::Log(LOGERROR, "CLibInputHandler::{} - failed to close epoll file descriptor: {}", + __FUNCTION__, strerror(-errno)); + return; + } +} + +void CLibInputHandler::ProcessEvent(libinput_event *ev) +{ + libinput_event_type type = libinput_event_get_type(ev); + libinput_device *dev = libinput_event_get_device(ev); + + switch (type) + { + case LIBINPUT_EVENT_DEVICE_ADDED: + DeviceAdded(dev); + break; + case LIBINPUT_EVENT_DEVICE_REMOVED: + DeviceRemoved(dev); + break; + case LIBINPUT_EVENT_POINTER_BUTTON: + m_pointer->ProcessButton(libinput_event_get_pointer_event(ev)); + break; + case LIBINPUT_EVENT_POINTER_MOTION: + m_pointer->ProcessMotion(libinput_event_get_pointer_event(ev)); + break; + case LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE: + m_pointer->ProcessMotionAbsolute(libinput_event_get_pointer_event(ev)); + break; + case LIBINPUT_EVENT_POINTER_AXIS: + m_pointer->ProcessAxis(libinput_event_get_pointer_event(ev)); + break; + case LIBINPUT_EVENT_KEYBOARD_KEY: + m_keyboard->ProcessKey(libinput_event_get_keyboard_event(ev)); + m_keyboard->UpdateLeds(dev); + break; + case LIBINPUT_EVENT_TOUCH_DOWN: + m_touch->ProcessTouchDown(libinput_event_get_touch_event(ev)); + break; + case LIBINPUT_EVENT_TOUCH_MOTION: + m_touch->ProcessTouchMotion(libinput_event_get_touch_event(ev)); + break; + case LIBINPUT_EVENT_TOUCH_UP: + m_touch->ProcessTouchUp(libinput_event_get_touch_event(ev)); + break; + case LIBINPUT_EVENT_TOUCH_CANCEL: + m_touch->ProcessTouchCancel(libinput_event_get_touch_event(ev)); + break; + case LIBINPUT_EVENT_TOUCH_FRAME: + m_touch->ProcessTouchFrame(libinput_event_get_touch_event(ev)); + break; + + default: + break; + } +} + +void CLibInputHandler::DeviceAdded(libinput_device *dev) +{ + const char *sysname = libinput_device_get_sysname(dev); + const char *name = libinput_device_get_name(dev); + + if (libinput_device_has_capability(dev, LIBINPUT_DEVICE_CAP_TOUCH)) + { + CLog::Log(LOGDEBUG, "CLibInputHandler::{} - touch type device added: {} ({})", __FUNCTION__, + name, sysname); + m_devices.push_back(libinput_device_ref(dev)); + } + + if (libinput_device_has_capability(dev, LIBINPUT_DEVICE_CAP_POINTER)) + { + CLog::Log(LOGDEBUG, "CLibInputHandler::{} - pointer type device added: {} ({})", __FUNCTION__, + name, sysname); + m_devices.push_back(libinput_device_ref(dev)); + } + + if (libinput_device_has_capability(dev, LIBINPUT_DEVICE_CAP_KEYBOARD)) + { + CLog::Log(LOGDEBUG, "CLibInputHandler::{} - keyboard type device added: {} ({})", __FUNCTION__, + name, sysname); + m_devices.push_back(libinput_device_ref(dev)); + m_keyboard->GetRepeat(dev); + } +} + +void CLibInputHandler::DeviceRemoved(libinput_device *dev) +{ + const char *sysname = libinput_device_get_sysname(dev); + const char *name = libinput_device_get_name(dev); + + if (libinput_device_has_capability(dev, LIBINPUT_DEVICE_CAP_TOUCH)) + { + CLog::Log(LOGDEBUG, "CLibInputHandler::{} - touch type device removed: {} ({})", __FUNCTION__, + name, sysname); + auto device = std::find(m_devices.begin(), m_devices.end(), libinput_device_unref(dev)); + m_devices.erase(device); + } + + if (libinput_device_has_capability(dev, LIBINPUT_DEVICE_CAP_POINTER)) + { + CLog::Log(LOGDEBUG, "CLibInputHandler::{} - pointer type device removed: {} ({})", __FUNCTION__, + name, sysname); + auto device = std::find(m_devices.begin(), m_devices.end(), libinput_device_unref(dev)); + m_devices.erase(device); + } + + if (libinput_device_has_capability(dev, LIBINPUT_DEVICE_CAP_KEYBOARD)) + { + CLog::Log(LOGDEBUG, "CLibInputHandler::{} - keyboard type device removed: {} ({})", + __FUNCTION__, name, sysname); + auto device = std::find(m_devices.begin(), m_devices.end(), libinput_device_unref(dev)); + m_devices.erase(device); + } +} diff --git a/xbmc/platform/linux/input/LibInputHandler.h b/xbmc/platform/linux/input/LibInputHandler.h new file mode 100644 index 0000000..659d086 --- /dev/null +++ b/xbmc/platform/linux/input/LibInputHandler.h @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "interfaces/IAnnouncer.h" +#include "threads/Thread.h" + +#include <memory> +#include <vector> + +#include <libinput.h> +#include <libudev.h> + +class CLibInputKeyboard; +class CLibInputPointer; +class CLibInputSettings; +class CLibInputTouch; + +class CLibInputHandler : CThread, public ANNOUNCEMENT::IAnnouncer +{ +public: + CLibInputHandler(); + ~CLibInputHandler() override; + + void Announce(ANNOUNCEMENT::AnnouncementFlag flag, + const std::string& sender, + const std::string& message, + const CVariant& data) override; + + void Start(); + + bool SetKeymap(const std::string& layout); + +private: + void Process() override; + void ProcessEvent(libinput_event *ev); + void DeviceAdded(libinput_device *dev); + void DeviceRemoved(libinput_device *dev); + + udev *m_udev; + libinput *m_li; + int m_liFd; + + std::unique_ptr<CLibInputKeyboard> m_keyboard; + std::unique_ptr<CLibInputPointer> m_pointer; + std::unique_ptr<CLibInputSettings> m_settings; + std::unique_ptr<CLibInputTouch> m_touch; + std::vector<libinput_device*> m_devices; +}; + diff --git a/xbmc/platform/linux/input/LibInputKeyboard.cpp b/xbmc/platform/linux/input/LibInputKeyboard.cpp new file mode 100644 index 0000000..657588a --- /dev/null +++ b/xbmc/platform/linux/input/LibInputKeyboard.cpp @@ -0,0 +1,387 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "LibInputKeyboard.h" + +#include "LibInputSettings.h" +#include "ServiceBroker.h" +#include "application/AppInboundProtocol.h" +#include "settings/Settings.h" +#include "settings/SettingsComponent.h" +#include "utils/log.h" + +#include <algorithm> +#include <map> +#include <string.h> + +#include <fcntl.h> +#include <linux/input.h> +#include <sys/ioctl.h> +#include <unistd.h> +#include <xkbcommon/xkbcommon-keysyms.h> +#include <xkbcommon/xkbcommon-names.h> + +namespace +{ +constexpr int REPEAT_DELAY = 400; +constexpr int REPEAT_RATE = 80; + +static const std::map<xkb_keysym_t, XBMCKey> xkbMap = +{ + // Function keys before start of ASCII printable character range + { XKB_KEY_BackSpace, XBMCK_BACKSPACE }, + { XKB_KEY_Tab, XBMCK_TAB }, + { XKB_KEY_Clear, XBMCK_CLEAR }, + { XKB_KEY_Return, XBMCK_RETURN }, + { XKB_KEY_Pause, XBMCK_PAUSE }, + { XKB_KEY_Escape, XBMCK_ESCAPE }, + + // ASCII printable range - not included here + + // Function keys after end of ASCII printable character range + { XKB_KEY_Delete, XBMCK_DELETE }, + + // Multimedia keys + { XKB_KEY_XF86Back, XBMCK_BROWSER_BACK }, + { XKB_KEY_XF86Forward, XBMCK_BROWSER_FORWARD }, + { XKB_KEY_XF86Refresh, XBMCK_BROWSER_REFRESH }, + { XKB_KEY_XF86Stop, XBMCK_BROWSER_STOP }, + { XKB_KEY_XF86Search, XBMCK_BROWSER_SEARCH }, + // XKB_KEY_XF86Favorites could be XBMCK_BROWSER_FAVORITES or XBMCK_FAVORITES, + // XBMCK_FAVORITES was chosen here because it is more general + { XKB_KEY_XF86HomePage, XBMCK_BROWSER_HOME }, + { XKB_KEY_XF86AudioMute, XBMCK_VOLUME_MUTE }, + { XKB_KEY_XF86AudioLowerVolume, XBMCK_VOLUME_DOWN }, + { XKB_KEY_XF86AudioRaiseVolume, XBMCK_VOLUME_UP }, + { XKB_KEY_XF86AudioNext, XBMCK_MEDIA_NEXT_TRACK }, + { XKB_KEY_XF86AudioPrev, XBMCK_MEDIA_PREV_TRACK }, + { XKB_KEY_XF86AudioStop, XBMCK_MEDIA_STOP }, + { XKB_KEY_XF86AudioPause, XBMCK_MEDIA_PLAY_PAUSE }, + { XKB_KEY_XF86Mail, XBMCK_LAUNCH_MAIL }, + { XKB_KEY_XF86Select, XBMCK_LAUNCH_MEDIA_SELECT }, + { XKB_KEY_XF86Launch0, XBMCK_LAUNCH_APP1 }, + { XKB_KEY_XF86Launch1, XBMCK_LAUNCH_APP2 }, + { XKB_KEY_XF86WWW, XBMCK_LAUNCH_FILE_BROWSER }, + { XKB_KEY_XF86AudioMedia, XBMCK_LAUNCH_MEDIA_CENTER }, + { XKB_KEY_XF86AudioRewind, XBMCK_MEDIA_REWIND }, + { XKB_KEY_XF86AudioForward, XBMCK_MEDIA_FASTFORWARD }, + + // Numeric keypad + { XKB_KEY_KP_0, XBMCK_KP0 }, + { XKB_KEY_KP_1, XBMCK_KP1 }, + { XKB_KEY_KP_2, XBMCK_KP2 }, + { XKB_KEY_KP_3, XBMCK_KP3 }, + { XKB_KEY_KP_4, XBMCK_KP4 }, + { XKB_KEY_KP_5, XBMCK_KP5 }, + { XKB_KEY_KP_6, XBMCK_KP6 }, + { XKB_KEY_KP_7, XBMCK_KP7 }, + { XKB_KEY_KP_8, XBMCK_KP8 }, + { XKB_KEY_KP_9, XBMCK_KP9 }, + { XKB_KEY_KP_Decimal, XBMCK_KP_PERIOD }, + { XKB_KEY_KP_Divide, XBMCK_KP_DIVIDE }, + { XKB_KEY_KP_Multiply, XBMCK_KP_MULTIPLY }, + { XKB_KEY_KP_Subtract, XBMCK_KP_MINUS }, + { XKB_KEY_KP_Add, XBMCK_KP_PLUS }, + { XKB_KEY_KP_Enter, XBMCK_KP_ENTER }, + { XKB_KEY_KP_Equal, XBMCK_KP_EQUALS }, + + // Arrows + Home/End pad + { XKB_KEY_Up, XBMCK_UP }, + { XKB_KEY_Down, XBMCK_DOWN }, + { XKB_KEY_Right, XBMCK_RIGHT }, + { XKB_KEY_Left, XBMCK_LEFT }, + { XKB_KEY_Insert, XBMCK_INSERT }, + { XKB_KEY_Home, XBMCK_HOME }, + { XKB_KEY_End, XBMCK_END }, + { XKB_KEY_Page_Up, XBMCK_PAGEUP }, + { XKB_KEY_Page_Down, XBMCK_PAGEDOWN }, + + // Key state modifier keys + { XKB_KEY_Num_Lock, XBMCK_NUMLOCK }, + { XKB_KEY_Caps_Lock, XBMCK_CAPSLOCK }, + { XKB_KEY_Scroll_Lock, XBMCK_SCROLLOCK }, + { XKB_KEY_Shift_R, XBMCK_RSHIFT }, + { XKB_KEY_Shift_L, XBMCK_LSHIFT }, + { XKB_KEY_Control_R, XBMCK_RCTRL }, + { XKB_KEY_Control_L, XBMCK_LCTRL }, + { XKB_KEY_Alt_R, XBMCK_RALT }, + { XKB_KEY_Alt_L, XBMCK_LALT }, + { XKB_KEY_Meta_R, XBMCK_RMETA }, + { XKB_KEY_Meta_L, XBMCK_LMETA }, + { XKB_KEY_Super_R, XBMCK_RSUPER }, + { XKB_KEY_Super_L, XBMCK_LSUPER }, + // XKB does not have XBMCK_MODE/"Alt Gr" - probably equal to XKB_KEY_Alt_R + { XKB_KEY_Multi_key, XBMCK_COMPOSE }, + + // Miscellaneous function keys + { XKB_KEY_Help, XBMCK_HELP }, + { XKB_KEY_Print, XBMCK_PRINT }, + { XKB_KEY_Sys_Req, XBMCK_SYSREQ}, + { XKB_KEY_Break, XBMCK_BREAK }, + { XKB_KEY_Menu, XBMCK_MENU }, + { XKB_KEY_XF86PowerOff, XBMCK_POWER }, + { XKB_KEY_EcuSign, XBMCK_EURO }, + { XKB_KEY_Undo, XBMCK_UNDO }, + { XKB_KEY_XF86Sleep, XBMCK_SLEEP }, + // Unmapped: XBMCK_GUIDE, XBMCK_SETTINGS, XBMCK_INFO + { XKB_KEY_XF86Red, XBMCK_RED }, + { XKB_KEY_XF86Green, XBMCK_GREEN }, + { XKB_KEY_XF86Yellow, XBMCK_YELLOW }, + { XKB_KEY_XF86Blue, XBMCK_BLUE }, + // Unmapped: XBMCK_ZOOM, XBMCK_TEXT + { XKB_KEY_XF86Favorites, XBMCK_FAVORITES }, + { XKB_KEY_XF86HomePage, XBMCK_HOMEPAGE }, + // Unmapped: XBMCK_CONFIG, XBMCK_EPG + + // Media keys + { XKB_KEY_XF86Eject, XBMCK_EJECT }, + { XKB_KEY_Cancel, XBMCK_STOP }, + { XKB_KEY_XF86AudioRecord, XBMCK_RECORD }, + // XBMCK_REWIND clashes with XBMCK_MEDIA_REWIND + { XKB_KEY_XF86Phone, XBMCK_PHONE }, + { XKB_KEY_XF86AudioPlay, XBMCK_PLAY }, + { XKB_KEY_XF86AudioRandomPlay, XBMCK_SHUFFLE } + // XBMCK_FASTFORWARD clashes with XBMCK_MEDIA_FASTFORWARD +}; +} // namespace + +CLibInputKeyboard::CLibInputKeyboard() + : m_repeatTimer(std::bind(&CLibInputKeyboard::KeyRepeatTimeout, this)) +{ + m_ctx = xkb_context_new(XKB_CONTEXT_NO_FLAGS); + if (!m_ctx) + { + CLog::Log(LOGERROR, "CLibInputKeyboard::{} - failed to create xkb context", __FUNCTION__); + return; + } + + std::string layout = CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CLibInputSettings::SETTING_INPUT_LIBINPUTKEYBOARDLAYOUT); + + if (!SetKeymap(layout)) + { + CLog::Log(LOGERROR, "CLibInputKeyboard::{} - failed set default keymap", __FUNCTION__); + return; + } +} + +CLibInputKeyboard::~CLibInputKeyboard() +{ + xkb_state_unref(m_state); + xkb_keymap_unref(m_keymap); + xkb_context_unref(m_ctx); +} + +bool CLibInputKeyboard::SetKeymap(const std::string& layout) +{ + xkb_state_unref(m_state); + xkb_keymap_unref(m_keymap); + + xkb_rule_names names; + + names.rules = nullptr; + names.model = nullptr; + names.layout = layout.c_str(); + names.variant = nullptr; + names.options = nullptr; + + m_keymap = xkb_keymap_new_from_names(m_ctx, &names, XKB_KEYMAP_COMPILE_NO_FLAGS); + if (!m_keymap) + { + CLog::Log(LOGERROR, "CLibInputKeyboard::{} - failed to compile keymap", __FUNCTION__); + return false; + } + + m_state = xkb_state_new(m_keymap); + if (!m_state) + { + CLog::Log(LOGERROR, "CLibInputKeyboard::{} - failed to create xkb state", __FUNCTION__); + return false; + } + + m_modindex[0] = xkb_keymap_mod_get_index(m_keymap, XKB_MOD_NAME_CTRL); + m_modindex[1] = xkb_keymap_mod_get_index(m_keymap, XKB_MOD_NAME_ALT); + m_modindex[2] = xkb_keymap_mod_get_index(m_keymap, XKB_MOD_NAME_SHIFT); + m_modindex[3] = xkb_keymap_mod_get_index(m_keymap, XKB_MOD_NAME_LOGO); + + m_ledindex[0] = xkb_keymap_led_get_index(m_keymap, XKB_LED_NAME_NUM); + m_ledindex[1] = xkb_keymap_led_get_index(m_keymap, XKB_LED_NAME_CAPS); + m_ledindex[2] = xkb_keymap_led_get_index(m_keymap, XKB_LED_NAME_SCROLL); + + m_leds = 0; + + return true; +} + +void CLibInputKeyboard::ProcessKey(libinput_event_keyboard *e) +{ + if (!m_ctx || !m_keymap || !m_state) + return; + + XBMC_Event event = {}; + + const uint32_t xkbkey = libinput_event_keyboard_get_key(e) + 8; + const bool pressed = libinput_event_keyboard_get_key_state(e) == LIBINPUT_KEY_STATE_PRESSED; + + event.type = pressed ? XBMC_KEYDOWN : XBMC_KEYUP; + xkb_state_update_key(m_state, xkbkey, pressed ? XKB_KEY_DOWN : XKB_KEY_UP); + + const xkb_keysym_t keysym = xkb_state_key_get_one_sym(m_state, xkbkey); + + int mod = XBMCKMOD_NONE; + + xkb_state_component modtype = xkb_state_component(XKB_STATE_MODS_DEPRESSED | XKB_STATE_MODS_LATCHED); + if (xkb_state_mod_index_is_active(m_state, m_modindex[0], modtype) && ((keysym != XBMCK_LCTRL) || !pressed)) + mod |= XBMCKMOD_CTRL; + if (xkb_state_mod_index_is_active(m_state, m_modindex[0], modtype) && ((keysym != XBMCK_RCTRL) || !pressed)) + mod |= XBMCKMOD_CTRL; + if (xkb_state_mod_index_is_active(m_state, m_modindex[1], modtype) && ((keysym != XBMCK_LALT) || !pressed)) + mod |= XBMCKMOD_ALT; + if (xkb_state_mod_index_is_active(m_state, m_modindex[1], modtype) && ((keysym != XBMCK_RALT) || !pressed)) + mod |= XBMCKMOD_ALT; + if (xkb_state_mod_index_is_active(m_state, m_modindex[2], modtype) && ((keysym != XBMCK_LSHIFT) || !pressed)) + mod |= XBMCKMOD_SHIFT; + if (xkb_state_mod_index_is_active(m_state, m_modindex[2], modtype) && ((keysym != XBMCK_RSHIFT) || !pressed)) + mod |= XBMCKMOD_SHIFT; + if (xkb_state_mod_index_is_active(m_state, m_modindex[3], modtype) && ((keysym != XBMCK_LMETA) || !pressed)) + mod |= XBMCKMOD_META; + if (xkb_state_mod_index_is_active(m_state, m_modindex[3], modtype) && ((keysym != XBMCK_RMETA) || !pressed)) + mod |= XBMCKMOD_META; + + m_leds = 0; + + if (xkb_state_led_index_is_active(m_state, m_ledindex[0]) && ((keysym != XBMCK_NUMLOCK) || !pressed)) + { + m_leds |= LIBINPUT_LED_NUM_LOCK; + mod |= XBMCKMOD_NUM; + } + if (xkb_state_led_index_is_active(m_state, m_ledindex[1]) && ((keysym != XBMCK_CAPSLOCK) || !pressed)) + { + m_leds |= LIBINPUT_LED_CAPS_LOCK; + mod |= XBMCKMOD_CAPS; + } + if (xkb_state_led_index_is_active(m_state, m_ledindex[2]) && ((keysym != XBMCK_SCROLLOCK) || !pressed)) + { + m_leds |= LIBINPUT_LED_SCROLL_LOCK; + //mod |= XBMCK_SCROLLOCK; + } + + uint32_t unicode = xkb_state_key_get_utf32(m_state, xkbkey); + if (unicode > std::numeric_limits<std::uint16_t>::max()) + { + // Kodi event system only supports UTF16, so ignore the codepoint if it does not fit + unicode = 0; + } + + uint32_t scancode = libinput_event_keyboard_get_key(e); + if (scancode > std::numeric_limits<unsigned char>::max()) + { + // Kodi scancodes are limited to unsigned char, pretend the scancode is unknown on overflow + scancode = 0; + } + + event.key.keysym.mod = XBMCMod(mod); + event.key.keysym.sym = XBMCKeyForKeysym(keysym, scancode); + event.key.keysym.scancode = scancode; + event.key.keysym.unicode = unicode; + + std::shared_ptr<CAppInboundProtocol> appPort = CServiceBroker::GetAppPort(); + if (appPort) + appPort->OnEvent(event); + + if (pressed && xkb_keymap_key_repeats(m_keymap, xkbkey)) + { + libinput_event *ev = libinput_event_keyboard_get_base_event(e); + libinput_device *dev = libinput_event_get_device(ev); + auto data = m_repeatData.find(dev); + if (data != m_repeatData.end()) + { + CLog::Log(LOGDEBUG, "CLibInputKeyboard::{} - using delay: {}ms repeat: {}ms", __FUNCTION__, + data->second.at(0), data->second.at(1)); + + m_repeatRate = data->second.at(1); + m_repeatTimer.Stop(true); + m_repeatEvent = event; + m_repeatTimer.Start(std::chrono::milliseconds(data->second.at(0)), false); + } + } + else + { + m_repeatTimer.Stop(); + } +} + +XBMCKey CLibInputKeyboard::XBMCKeyForKeysym(xkb_keysym_t sym, uint32_t scancode) +{ + if (sym >= 'A' && sym <= 'Z') + { + return static_cast<XBMCKey> (sym + 'a' - 'A'); + } + else if (sym >= XKB_KEY_space && sym <= XKB_KEY_asciitilde) + { + return static_cast<XBMCKey> (sym); + } + else if (sym >= XKB_KEY_F1 && sym <= XKB_KEY_F15) + { + return static_cast<XBMCKey> (XBMCK_F1 + ((int)sym - XKB_KEY_F1)); + } + + auto xkbmapping = xkbMap.find(sym); + if (xkbmapping != xkbMap.end()) + return xkbmapping->second; + + return XBMCK_UNKNOWN; +} + +void CLibInputKeyboard::KeyRepeatTimeout() +{ + m_repeatTimer.RestartAsync(std::chrono::milliseconds(m_repeatRate)); + + std::shared_ptr<CAppInboundProtocol> appPort = CServiceBroker::GetAppPort(); + if (appPort) + appPort->OnEvent(m_repeatEvent); +} + +void CLibInputKeyboard::UpdateLeds(libinput_device *dev) +{ + libinput_device_led_update(dev, static_cast<libinput_led>(m_leds)); +} + +void CLibInputKeyboard::GetRepeat(libinput_device *dev) +{ + int kbdrep[2] = {REPEAT_DELAY, REPEAT_RATE}; + const char *name = libinput_device_get_name(dev); + const char *sysname = libinput_device_get_sysname(dev); + std::string path("/dev/input/"); + path.append(sysname); + auto fd = open(path.c_str(), O_RDONLY); + + if (fd < 0) + { + CLog::Log(LOGERROR, "CLibInputKeyboard::{} - failed to open {} ({})", __FUNCTION__, sysname, + strerror(errno)); + } + else + { + auto ret = ioctl(fd, EVIOCGREP, &kbdrep); + if (ret < 0) + CLog::Log(LOGDEBUG, "CLibInputKeyboard::{} - could not get key repeat for {} ({})", + __FUNCTION__, sysname, strerror(errno)); + + CLog::Log(LOGDEBUG, "CLibInputKeyboard::{} - delay: {}ms repeat: {}ms for {} ({})", + __FUNCTION__, kbdrep[0], kbdrep[1], name, sysname); + close(fd); + } + + std::vector<int> kbdrepvec(std::begin(kbdrep), std::end(kbdrep)); + + auto data = m_repeatData.find(dev); + if (data == m_repeatData.end()) + { + m_repeatData.insert(std::make_pair(dev, kbdrepvec)); + } +} diff --git a/xbmc/platform/linux/input/LibInputKeyboard.h b/xbmc/platform/linux/input/LibInputKeyboard.h new file mode 100644 index 0000000..76aaeff --- /dev/null +++ b/xbmc/platform/linux/input/LibInputKeyboard.h @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "threads/Timer.h" +#include "windowing/XBMC_events.h" + +#include <map> +#include <vector> + +#include <libinput.h> +#include <xkbcommon/xkbcommon.h> + +class CLibInputKeyboard +{ +public: + CLibInputKeyboard(); + ~CLibInputKeyboard(); + + void ProcessKey(libinput_event_keyboard *e); + void UpdateLeds(libinput_device *dev); + void GetRepeat(libinput_device *dev); + + bool SetKeymap(const std::string& layout); + +private: + XBMCKey XBMCKeyForKeysym(xkb_keysym_t sym, uint32_t scancode); + void KeyRepeatTimeout(); + + xkb_context *m_ctx = nullptr; + xkb_keymap *m_keymap = nullptr; + xkb_state *m_state = nullptr; + xkb_mod_index_t m_modindex[4]; + xkb_led_index_t m_ledindex[3]; + + int m_leds; + + XBMC_Event m_repeatEvent; + std::map<libinput_device*, std::vector<int>> m_repeatData; + CTimer m_repeatTimer; + int m_repeatRate; +}; diff --git a/xbmc/platform/linux/input/LibInputPointer.cpp b/xbmc/platform/linux/input/LibInputPointer.cpp new file mode 100644 index 0000000..42d2bbe --- /dev/null +++ b/xbmc/platform/linux/input/LibInputPointer.cpp @@ -0,0 +1,153 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "LibInputPointer.h" + +#include "ServiceBroker.h" +#include "application/AppInboundProtocol.h" +#include "input/mouse/MouseStat.h" +#include "utils/log.h" +#include "windowing/GraphicContext.h" + +#include <algorithm> +#include <string.h> + +#include <linux/input.h> + +void CLibInputPointer::ProcessButton(libinput_event_pointer *e) +{ + const uint32_t b = libinput_event_pointer_get_button(e); + const bool pressed = libinput_event_pointer_get_button_state(e) == LIBINPUT_BUTTON_STATE_PRESSED; + unsigned char xbmc_button = 0; + + switch (b) + { + case BTN_LEFT: + xbmc_button = XBMC_BUTTON_LEFT; + break; + case BTN_RIGHT: + xbmc_button = XBMC_BUTTON_RIGHT; + break; + case BTN_MIDDLE: + xbmc_button = XBMC_BUTTON_MIDDLE; + break; + case BTN_SIDE: + xbmc_button = XBMC_BUTTON_X1; + break; + case BTN_EXTRA: + xbmc_button = XBMC_BUTTON_X2; + break; + case BTN_FORWARD: + xbmc_button = XBMC_BUTTON_X3; + break; + case BTN_BACK: + xbmc_button = XBMC_BUTTON_X4; + break; + default: + break; + } + + XBMC_Event event = {}; + + event.type = pressed ? XBMC_MOUSEBUTTONDOWN : XBMC_MOUSEBUTTONUP; + event.button.button = xbmc_button; + event.button.x = static_cast<uint16_t>(m_pos.X); + event.button.y = static_cast<uint16_t>(m_pos.Y); + + CLog::Log(LOGDEBUG, + "CLibInputPointer::{} - event.type: {}, event.button.button: {}, event.button.x: {}, " + "event.button.y: {}", + __FUNCTION__, event.type, event.button.button, event.button.x, event.button.y); + + std::shared_ptr<CAppInboundProtocol> appPort = CServiceBroker::GetAppPort(); + if (appPort) + appPort->OnEvent(event); +} + +void CLibInputPointer::ProcessMotion(libinput_event_pointer *e) +{ + const double dx = libinput_event_pointer_get_dx(e); + const double dy = libinput_event_pointer_get_dy(e); + + m_pos.X += static_cast<int>(dx); + m_pos.Y += static_cast<int>(dy); + + // limit the mouse to the screen width + m_pos.X = std::min(CServiceBroker::GetWinSystem()->GetGfxContext().GetWidth(), m_pos.X); + m_pos.X = std::max(0, m_pos.X); + + // limit the mouse to the screen height + m_pos.Y = std::min(CServiceBroker::GetWinSystem()->GetGfxContext().GetHeight(), m_pos.Y); + m_pos.Y = std::max(0, m_pos.Y); + + XBMC_Event event = {}; + + event.type = XBMC_MOUSEMOTION; + event.motion.x = static_cast<uint16_t>(m_pos.X); + event.motion.y = static_cast<uint16_t>(m_pos.Y); + + CLog::Log(LOGDEBUG, + "CLibInputPointer::{} - event.type: {}, event.motion.x: {}, event.motion.y: {}", + __FUNCTION__, event.type, event.motion.x, event.motion.y); + + std::shared_ptr<CAppInboundProtocol> appPort = CServiceBroker::GetAppPort(); + if (appPort) + appPort->OnEvent(event); +} + +void CLibInputPointer::ProcessMotionAbsolute(libinput_event_pointer *e) +{ + m_pos.X = static_cast<int>(libinput_event_pointer_get_absolute_x_transformed(e, CServiceBroker::GetWinSystem()->GetGfxContext().GetWidth())); + m_pos.Y = static_cast<int>(libinput_event_pointer_get_absolute_y_transformed(e, CServiceBroker::GetWinSystem()->GetGfxContext().GetHeight())); + + XBMC_Event event = {}; + event.type = XBMC_MOUSEMOTION; + event.motion.x = static_cast<uint16_t>(m_pos.X); + event.motion.y = static_cast<uint16_t>(m_pos.Y); + + CLog::Log(LOGDEBUG, + "CLibInputPointer::{} - event.type: {}, event.motion.x: {}, event.motion.y: {}", + __FUNCTION__, event.type, event.motion.x, event.motion.y); + + std::shared_ptr<CAppInboundProtocol> appPort = CServiceBroker::GetAppPort(); + if (appPort) + appPort->OnEvent(event); +} + +void CLibInputPointer::ProcessAxis(libinput_event_pointer *e) +{ + unsigned char scroll = 0; + if (!libinput_event_pointer_has_axis(e, LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL)) + return; + + const double v = libinput_event_pointer_get_axis_value(e, LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL); + if (v < 0) + scroll = XBMC_BUTTON_WHEELUP; + else + scroll = XBMC_BUTTON_WHEELDOWN; + + XBMC_Event event = {}; + + event.type = XBMC_MOUSEBUTTONDOWN; + event.button.button = scroll; + event.button.x = static_cast<uint16_t>(m_pos.X); + event.button.y = static_cast<uint16_t>(m_pos.Y); + + CLog::Log(LOGDEBUG, "CLibInputPointer::{} - scroll: {}, event.button.x: {}, event.button.y: {}", + __FUNCTION__, scroll == XBMC_BUTTON_WHEELUP ? "up" : "down", event.button.x, + event.button.y); + + std::shared_ptr<CAppInboundProtocol> appPort = CServiceBroker::GetAppPort(); + if (appPort) + appPort->OnEvent(event); + + event.type = XBMC_MOUSEBUTTONUP; + + if (appPort) + appPort->OnEvent(event); +} diff --git a/xbmc/platform/linux/input/LibInputPointer.h b/xbmc/platform/linux/input/LibInputPointer.h new file mode 100644 index 0000000..608b438 --- /dev/null +++ b/xbmc/platform/linux/input/LibInputPointer.h @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include <libinput.h> + +struct pos +{ + int X; + int Y; +}; + +class CLibInputPointer +{ +public: + CLibInputPointer() = default; + ~CLibInputPointer() = default; + + void ProcessButton(libinput_event_pointer *e); + void ProcessMotion(libinput_event_pointer *e); + void ProcessMotionAbsolute(libinput_event_pointer *e); + void ProcessAxis(libinput_event_pointer *e); + +private: + struct pos m_pos = { 0, 0 }; +}; diff --git a/xbmc/platform/linux/input/LibInputSettings.cpp b/xbmc/platform/linux/input/LibInputSettings.cpp new file mode 100644 index 0000000..25a916e --- /dev/null +++ b/xbmc/platform/linux/input/LibInputSettings.cpp @@ -0,0 +1,169 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "LibInputSettings.h" + +#include "LibInputHandler.h" +#include "ServiceBroker.h" +#include "settings/Settings.h" +#include "settings/SettingsComponent.h" +#include "settings/lib/Setting.h" +#include "settings/lib/SettingDefinitions.h" +#include "settings/lib/SettingsManager.h" +#include "utils/XBMCTinyXML.h" +#include "utils/log.h" + +#include <algorithm> + +const std::string CLibInputSettings::SETTING_INPUT_LIBINPUTKEYBOARDLAYOUT = "input.libinputkeyboardlayout"; +static std::vector<StringSettingOption> layouts; + +namespace +{ + inline bool LayoutSort(const StringSettingOption& i, const StringSettingOption& j) + { + return (i.value < j.value); + } +} // unnamed namespace + +CLibInputSettings::CLibInputSettings(CLibInputHandler *handler) : + m_libInputHandler(handler) +{ + const auto settingsComponent = CServiceBroker::GetSettingsComponent(); + if (!settingsComponent) + return; + + auto settings = settingsComponent->GetSettings(); + if (!settings) + return; + + auto settingsManager = settings->GetSettingsManager(); + if (!settingsManager) + return; + + auto setting = settings->GetSetting(SETTING_INPUT_LIBINPUTKEYBOARDLAYOUT); + if (!setting) + { + CLog::Log(LOGERROR, "Failed to load setting for: {}", SETTING_INPUT_LIBINPUTKEYBOARDLAYOUT); + return; + } + + setting->SetVisible(true); + + std::set<std::string> settingSet; + settingSet.insert(SETTING_INPUT_LIBINPUTKEYBOARDLAYOUT); + settingsManager->RegisterCallback(this, settingSet); + settingsManager->RegisterSettingOptionsFiller("libinputkeyboardlayout", + SettingOptionsKeyboardLayoutsFiller); + + /* load the keyboard layouts from xkeyboard-config */ + std::string xkbFile("/usr/share/X11/xkb/rules/base.xml"); + + CXBMCTinyXML xmlDoc; + if (!xmlDoc.LoadFile(xkbFile)) + { + CLog::Log(LOGWARNING, "CLibInputSettings: unable to open: {}", xkbFile); + return; + } + + const TiXmlElement* rootElement = xmlDoc.RootElement(); + if (!rootElement) + { + CLog::Log(LOGWARNING, "CLibInputSettings: missing or invalid XML root element in: {}", xkbFile); + return; + } + + if (rootElement->ValueStr() != "xkbConfigRegistry") + { + CLog::Log(LOGWARNING, "CLibInputSettings: unexpected XML root element {} in: {}", + rootElement->Value(), xkbFile); + return; + } + + const TiXmlElement* layoutListElement = rootElement->FirstChildElement("layoutList"); + if (!layoutListElement) + { + CLog::Log(LOGWARNING, "CLibInputSettings: unexpected XML child element {} in: {}", + layoutListElement->Value(), xkbFile); + return; + } + + const TiXmlElement* layoutElement = layoutListElement->FirstChildElement("layout"); + while (layoutElement) + { + const TiXmlElement* configElement = layoutElement->FirstChildElement("configItem"); + if (!configElement) + { + CLog::Log(LOGWARNING, "CLibInputSettings: unexpected XML child element {} in: {}", + layoutListElement->Value(), xkbFile); + return; + } + + const TiXmlElement* nameElement = configElement->FirstChildElement("name"); + if (!nameElement) + { + CLog::Log(LOGWARNING, "CLibInputSettings: unexpected XML child element {} in: {}", + configElement->Value(), xkbFile); + return; + } + + const TiXmlElement* descriptionElement = configElement->FirstChildElement("description"); + if (!descriptionElement) + { + CLog::Log(LOGWARNING, "CLibInputSettings: unexpected XML child element {} in: {}", + configElement->Value(), xkbFile); + return; + } + + std::string layout = nameElement->GetText(); + std::string layoutDescription = descriptionElement->GetText(); + + if (!layout.empty() && !layoutDescription.empty()) + layouts.emplace_back(StringSettingOption(layoutDescription, layout)); + + layoutElement = layoutElement->NextSiblingElement(); + } + + std::sort(layouts.begin(), layouts.end(), LayoutSort); +} + +CLibInputSettings::~CLibInputSettings() +{ + const auto settingsComponent = CServiceBroker::GetSettingsComponent(); + if (!settingsComponent) + return; + + const std::shared_ptr<CSettings> settings = settingsComponent->GetSettings(); + if (!settings) + return; + + settings->GetSettingsManager()->UnregisterSettingOptionsFiller("libinputkeyboardlayout"); + settings->GetSettingsManager()->UnregisterCallback(this); +} + +void CLibInputSettings::SettingOptionsKeyboardLayoutsFiller( + const std::shared_ptr<const CSetting>& setting, + std::vector<StringSettingOption>& list, + std::string& current, + void* data) +{ + list = layouts; +} + +void CLibInputSettings::OnSettingChanged(const std::shared_ptr<const CSetting>& setting) +{ + if (setting == nullptr) + return; + + const std::string &settingId = setting->GetId(); + if (settingId == SETTING_INPUT_LIBINPUTKEYBOARDLAYOUT) + { + std::string layout = std::dynamic_pointer_cast<const CSettingString>(setting)->GetValue(); + m_libInputHandler->SetKeymap(layout); + } +} diff --git a/xbmc/platform/linux/input/LibInputSettings.h b/xbmc/platform/linux/input/LibInputSettings.h new file mode 100644 index 0000000..83d5edf --- /dev/null +++ b/xbmc/platform/linux/input/LibInputSettings.h @@ -0,0 +1,35 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "settings/Settings.h" +#include "settings/lib/ISettingCallback.h" +#include "settings/lib/ISettingsHandler.h" + +#include <memory> +#include <vector> + +class CLibInputHandler; +struct StringSettingOption; + +class CLibInputSettings : public ISettingCallback, public ISettingsHandler +{ +public: + static const std::string SETTING_INPUT_LIBINPUTKEYBOARDLAYOUT; + + void OnSettingChanged(const std::shared_ptr<const CSetting>& setting) override; + static void SettingOptionsKeyboardLayoutsFiller(const std::shared_ptr<const CSetting>& setting, + std::vector<StringSettingOption>& list, + std::string& current, + void* data); + + CLibInputSettings(CLibInputHandler *handler); + ~CLibInputSettings() override; + +private: + CLibInputHandler *m_libInputHandler{nullptr}; +}; diff --git a/xbmc/platform/linux/input/LibInputTouch.cpp b/xbmc/platform/linux/input/LibInputTouch.cpp new file mode 100644 index 0000000..545d99a --- /dev/null +++ b/xbmc/platform/linux/input/LibInputTouch.cpp @@ -0,0 +1,109 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "LibInputTouch.h" + +#include "ServiceBroker.h" +#include "input/touch/generic/GenericTouchActionHandler.h" +#include "utils/log.h" +#include "windowing/GraphicContext.h" + +static inline CPoint GetPos(libinput_event_touch *e) +{ + const double x = libinput_event_touch_get_x_transformed(e, CServiceBroker::GetWinSystem()->GetGfxContext().GetWidth()); + const double y = libinput_event_touch_get_y_transformed(e, CServiceBroker::GetWinSystem()->GetGfxContext().GetHeight()); + + CLog::Log(LOGDEBUG, "CLibInputTouch::{} - x: {:f} y: {:f}", __FUNCTION__, x, y); + + return CPoint(x, y); +} + +CLibInputTouch::CLibInputTouch() +{ + m_points.reserve(2); + CGenericTouchInputHandler::GetInstance().RegisterHandler(&CGenericTouchActionHandler::GetInstance()); +} + +void CLibInputTouch::CheckSlot(int slot) +{ + if (slot + 1 > static_cast<int>(m_points.size())) + m_points.resize(slot + 1, std::make_pair(TouchInputUnchanged, CPoint(0, 0))); +} + +TouchInput CLibInputTouch::GetEvent(int slot) +{ + CheckSlot(slot); + return m_points.at(slot).first; +} + +void CLibInputTouch::SetEvent(int slot, TouchInput event) +{ + CheckSlot(slot); + m_points.at(slot).first = event; +} + +void CLibInputTouch::SetPosition(int slot, CPoint point) +{ + CheckSlot(slot); + m_points.at(slot).second = point; +} + +void CLibInputTouch::ProcessTouchDown(libinput_event_touch *e) +{ + int slot = libinput_event_touch_get_seat_slot(e); + + SetPosition(slot, GetPos(e)); + SetEvent(slot, TouchInputDown); + CLog::Log(LOGDEBUG, "CLibInputTouch::{} - touch input down", __FUNCTION__); +} + +void CLibInputTouch::ProcessTouchMotion(libinput_event_touch *e) +{ + int slot = libinput_event_touch_get_seat_slot(e); + uint64_t nanotime = libinput_event_touch_get_time_usec(e) * 1000LL; + + SetPosition(slot, GetPos(e)); + + if (GetEvent(slot) != TouchInputDown) + SetEvent(slot, TouchInputMove); + CLog::Log(LOGDEBUG, "CLibInputTouch::{} - touch input move", __FUNCTION__); + + CGenericTouchInputHandler::GetInstance().UpdateTouchPointer(slot, GetX(slot), GetY(slot), nanotime); +} + +void CLibInputTouch::ProcessTouchUp(libinput_event_touch *e) +{ + int slot = libinput_event_touch_get_seat_slot(e); + + SetEvent(slot, TouchInputUp); + CLog::Log(LOGDEBUG, "CLibInputTouch::{} - touch input up", __FUNCTION__); +} + +void CLibInputTouch::ProcessTouchCancel(libinput_event_touch *e) +{ + int slot = libinput_event_touch_get_seat_slot(e); + uint64_t nanotime = libinput_event_touch_get_time_usec(e) * 1000LL; + + CLog::Log(LOGDEBUG, "CLibInputTouch::{} - touch input cancel", __FUNCTION__); + CGenericTouchInputHandler::GetInstance().HandleTouchInput(TouchInputAbort, GetX(slot), GetY(slot), nanotime, slot); +} + +void CLibInputTouch::ProcessTouchFrame(libinput_event_touch *e) +{ + uint64_t nanotime = libinput_event_touch_get_time_usec(e) * 1000LL; + + for (size_t slot = 0; slot < m_points.size(); ++slot) + { + CLog::Log(LOGDEBUG, "CLibInputTouch::{} - touch input frame: event {}", __FUNCTION__, + GetEvent(slot)); + CLog::Log(LOGDEBUG, "CLibInputTouch::{} - touch input frame: slot {}", __FUNCTION__, slot); + CGenericTouchInputHandler::GetInstance().HandleTouchInput(GetEvent(slot), GetX(slot), GetY(slot), nanotime, slot); + SetEvent(slot, TouchInputUnchanged); + } +} + diff --git a/xbmc/platform/linux/input/LibInputTouch.h b/xbmc/platform/linux/input/LibInputTouch.h new file mode 100644 index 0000000..9805599 --- /dev/null +++ b/xbmc/platform/linux/input/LibInputTouch.h @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "input/touch/generic/GenericTouchInputHandler.h" +#include "utils/Geometry.h" + +#include <vector> + +#include <libinput.h> + +struct libinput_event_touch; +struct libinput_device; + +class CLibInputTouch +{ +public: + CLibInputTouch(); + void ProcessTouchDown(libinput_event_touch *e); + void ProcessTouchMotion(libinput_event_touch *e); + void ProcessTouchUp(libinput_event_touch *e); + void ProcessTouchCancel(libinput_event_touch *e); + void ProcessTouchFrame(libinput_event_touch *e); + +private: + void CheckSlot(int slot); + TouchInput GetEvent(int slot); + void SetEvent(int slot, TouchInput event); + void SetPosition(int slot, CPoint point); + int GetX(int slot) { return m_points.at(slot).second.x; } + int GetY(int slot) { return m_points.at(slot).second.y; } + + std::vector<std::pair<TouchInput, CPoint>> m_points{std::make_pair(TouchInputUnchanged, CPoint(0, 0))}; +}; diff --git a/xbmc/platform/linux/network/CMakeLists.txt b/xbmc/platform/linux/network/CMakeLists.txt new file mode 100644 index 0000000..44aa2e7 --- /dev/null +++ b/xbmc/platform/linux/network/CMakeLists.txt @@ -0,0 +1,4 @@ +set(SOURCES NetworkLinux.cpp) +set(HEADERS NetworkLinux.h) + +core_add_library(platform_linux_network) diff --git a/xbmc/platform/linux/network/NetworkLinux.cpp b/xbmc/platform/linux/network/NetworkLinux.cpp new file mode 100644 index 0000000..e9a936a --- /dev/null +++ b/xbmc/platform/linux/network/NetworkLinux.cpp @@ -0,0 +1,223 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "NetworkLinux.h" + +#include "utils/StringUtils.h" +#include "utils/log.h" + +#include <errno.h> +#include <utility> + +#include <arpa/inet.h> +#include <net/if.h> +#include <net/if_arp.h> +#include <resolv.h> +#include <sys/ioctl.h> + +CNetworkInterfaceLinux::CNetworkInterfaceLinux(CNetworkPosix* network, + std::string interfaceName, + char interfaceMacAddrRaw[6]) + : CNetworkInterfacePosix(network, std::move(interfaceName), interfaceMacAddrRaw) +{ +} + +std::string CNetworkInterfaceLinux::GetCurrentDefaultGateway() const +{ + std::string result; + + FILE* fp = fopen("/proc/net/route", "r"); + if (!fp) + { + // TBD: Error + return result; + } + + char* line = NULL; + char iface[16]; + char dst[128]; + char gateway[128]; + size_t linel = 0; + int n; + int linenum = 0; + while (getdelim(&line, &linel, '\n', fp) > 0) + { + // skip first two lines + if (linenum++ < 1) + continue; + + // search where the word begins + n = sscanf(line, "%15s %127s %127s", iface, dst, gateway); + + if (n < 3) + continue; + + if (strcmp(iface, m_interfaceName.c_str()) == 0 && strcmp(dst, "00000000") == 0 && + strcmp(gateway, "00000000") != 0) + { + unsigned char gatewayAddr[4]; + int len = CNetworkBase::ParseHex(gateway, gatewayAddr); + if (len == 4) + { + struct in_addr in; + in.s_addr = (gatewayAddr[0] << 24) | (gatewayAddr[1] << 16) | (gatewayAddr[2] << 8) | + (gatewayAddr[3]); + result = inet_ntoa(in); + break; + } + } + } + free(line); + fclose(fp); + + return result; +} + +bool CNetworkInterfaceLinux::GetHostMacAddress(unsigned long host_ip, std::string& mac) const +{ + struct arpreq areq; + struct sockaddr_in* sin; + + memset(&areq, 0x0, sizeof(areq)); + + sin = (struct sockaddr_in*)&areq.arp_pa; + sin->sin_family = AF_INET; + sin->sin_addr.s_addr = host_ip; + + sin = (struct sockaddr_in*)&areq.arp_ha; + sin->sin_family = ARPHRD_ETHER; + + strncpy(areq.arp_dev, m_interfaceName.c_str(), sizeof(areq.arp_dev)); + areq.arp_dev[sizeof(areq.arp_dev) - 1] = '\0'; + + int result = ioctl(m_network->GetSocket(), SIOCGARP, (caddr_t)&areq); + + if (result != 0) + { + // CLog::Log(LOGERROR, "{} - GetHostMacAddress/ioctl failed with errno ({})", __FUNCTION__, errno); + return false; + } + + struct sockaddr* res = &areq.arp_ha; + mac = StringUtils::Format("{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}", (uint8_t)res->sa_data[0], + (uint8_t)res->sa_data[1], (uint8_t)res->sa_data[2], + (uint8_t)res->sa_data[3], (uint8_t)res->sa_data[4], + (uint8_t)res->sa_data[5]); + + for (int i = 0; i < 6; ++i) + if (res->sa_data[i]) + return true; + + return false; +} + +std::unique_ptr<CNetworkBase> CNetworkBase::GetNetwork() +{ + return std::make_unique<CNetworkLinux>(); +} + +CNetworkLinux::CNetworkLinux() : CNetworkPosix() +{ + queryInterfaceList(); +} + +void CNetworkLinux::GetMacAddress(const std::string& interfaceName, char rawMac[6]) +{ + memset(rawMac, 0, 6); + + struct ifreq ifr; + strcpy(ifr.ifr_name, interfaceName.c_str()); + if (ioctl(GetSocket(), SIOCGIFHWADDR, &ifr) >= 0) + { + memcpy(rawMac, ifr.ifr_hwaddr.sa_data, 6); + } +} + +void CNetworkLinux::queryInterfaceList() +{ + char macAddrRaw[6]; + m_interfaces.clear(); + + FILE* fp = fopen("/proc/net/dev", "r"); + if (!fp) + { + // TBD: Error + return; + } + + char* line = NULL; + size_t linel = 0; + int n; + char* p; + int linenum = 0; + while (getdelim(&line, &linel, '\n', fp) > 0) + { + // skip first two lines + if (linenum++ < 2) + continue; + + // search where the word begins + p = line; + while (isspace(*p)) + ++p; + + // read word until : + n = strcspn(p, ": \t"); + p[n] = 0; + + // save the result + std::string interfaceName = p; + GetMacAddress(interfaceName, macAddrRaw); + + // only add interfaces with non-zero mac addresses + if (macAddrRaw[0] || macAddrRaw[1] || macAddrRaw[2] || macAddrRaw[3] || macAddrRaw[4] || + macAddrRaw[5]) + m_interfaces.push_back(new CNetworkInterfaceLinux(this, interfaceName, macAddrRaw)); + } + free(line); + fclose(fp); +} + +std::vector<std::string> CNetworkLinux::GetNameServers() +{ + std::vector<std::string> result; + + res_init(); + + for (int i = 0; i < _res.nscount; i++) + { + std::string ns = inet_ntoa(_res.nsaddr_list[i].sin_addr); + result.push_back(ns); + } + return result; +} + +bool CNetworkLinux::PingHost(unsigned long remote_ip, unsigned int timeout_ms) +{ + char cmd_line[64]; + + struct in_addr host_ip; + host_ip.s_addr = remote_ip; + + sprintf(cmd_line, "ping -c 1 -w %d %s", timeout_ms / 1000 + (timeout_ms % 1000) != 0, + inet_ntoa(host_ip)); + + int status = -1; + status = system(cmd_line); + int result = WIFEXITED(status) ? WEXITSTATUS(status) : -1; + + // http://linux.about.com/od/commands/l/blcmdl8_ping.htm ; + // 0 reply + // 1 no reply + // else some error + + if (result < 0 || result > 1) + CLog::Log(LOGERROR, "Ping fail : status = {}, errno = {} : '{}'", status, errno, cmd_line); + + return result == 0; +} diff --git a/xbmc/platform/linux/network/NetworkLinux.h b/xbmc/platform/linux/network/NetworkLinux.h new file mode 100644 index 0000000..dc7b4c6 --- /dev/null +++ b/xbmc/platform/linux/network/NetworkLinux.h @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "platform/posix/network/NetworkPosix.h" + +#include <string> +#include <vector> + +class CNetworkInterfaceLinux : public CNetworkInterfacePosix +{ +public: + CNetworkInterfaceLinux(CNetworkPosix* network, + std::string interfaceName, + char interfaceMacAddrRaw[6]); + ~CNetworkInterfaceLinux() override = default; + + std::string GetCurrentDefaultGateway() const override; + bool GetHostMacAddress(unsigned long host, std::string& mac) const override; +}; + +class CNetworkLinux : public CNetworkPosix +{ +public: + CNetworkLinux(); + ~CNetworkLinux() override = default; + + bool PingHost(unsigned long host, unsigned int timeout_ms = 2000) override; + std::vector<std::string> GetNameServers(void) override; + +private: + void GetMacAddress(const std::string& interfaceName, char macAddrRaw[6]) override; + void queryInterfaceList() override; +}; diff --git a/xbmc/platform/linux/network/zeroconf/CMakeLists.txt b/xbmc/platform/linux/network/zeroconf/CMakeLists.txt new file mode 100644 index 0000000..b31ab73 --- /dev/null +++ b/xbmc/platform/linux/network/zeroconf/CMakeLists.txt @@ -0,0 +1,8 @@ +if(AVAHI_FOUND) + set(SOURCES ZeroconfAvahi.cpp + ZeroconfBrowserAvahi.cpp) + set(HEADERS ZeroconfAvahi.h + ZeroconfBrowserAvahi.h) + + core_add_library(platform_linux_network_zeroconf) +endif() diff --git a/xbmc/platform/linux/network/zeroconf/ZeroconfAvahi.cpp b/xbmc/platform/linux/network/zeroconf/ZeroconfAvahi.cpp new file mode 100644 index 0000000..dea038a --- /dev/null +++ b/xbmc/platform/linux/network/zeroconf/ZeroconfAvahi.cpp @@ -0,0 +1,434 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "ZeroconfAvahi.h" + +#include "utils/log.h" + +#include <cassert> +#include <iostream> +#include <sstream> +#include <string> + +#include <avahi-client/client.h> +#include <avahi-common/alternative.h> +#include <avahi-common/error.h> +#include <avahi-common/malloc.h> +#include <avahi-common/thread-watch.h> +#include <unistd.h> //gethostname + +#include "PlatformDefs.h" + +///helper RAII-struct to block event loop for modifications +struct ScopedEventLoopBlock +{ + explicit ScopedEventLoopBlock(AvahiThreadedPoll* fp_poll):mp_poll(fp_poll) + { + avahi_threaded_poll_lock(mp_poll); + } + + ~ScopedEventLoopBlock() + { + avahi_threaded_poll_unlock(mp_poll); + } +private: + AvahiThreadedPoll* mp_poll; +}; + +///helper to store information on howto create an avahi-group to publish +struct CZeroconfAvahi::ServiceInfo +{ + ServiceInfo(const std::string& fcr_type, const std::string& fcr_name, + unsigned int f_port, AvahiStringList *txt, AvahiEntryGroup* fp_group = 0): + m_type(fcr_type), m_name(fcr_name), m_port(f_port), mp_txt(txt), mp_group(fp_group) + { + } + + std::string m_type; + std::string m_name; + unsigned int m_port; + AvahiStringList* mp_txt; + AvahiEntryGroup* mp_group; +}; + +CZeroconfAvahi::CZeroconfAvahi() +{ + if (! (mp_poll = avahi_threaded_poll_new())) + { + CLog::Log(LOGERROR, "CZeroconfAvahi::CZeroconfAvahi(): Could not create threaded poll object"); + //! @todo throw exception? + return; + } + + if (!createClient()) + { + CLog::Log(LOGERROR, "CZeroconfAvahi::CZeroconfAvahi(): Could not create client"); + //yeah, what if not? but should always succeed + } + + //start event loop thread + if (avahi_threaded_poll_start(mp_poll) < 0) + { + CLog::Log(LOGERROR, "CZeroconfAvahi::CZeroconfAvahi(): Failed to start avahi client thread"); + } +} + +CZeroconfAvahi::~CZeroconfAvahi() +{ + CLog::Log(LOGDEBUG, "CZeroconfAvahi::~CZeroconfAvahi() Going down! cleaning up..."); + + if (mp_poll) + { + //normally we would stop the avahi thread here and do our work, but + //it looks like this does not work -> www.avahi.org/ticket/251 + //so instead of calling + //avahi_threaded_poll_stop(mp_poll); + //we set m_shutdown=true, post an event and wait for it to stop itself + struct timeval tv = { 0, 0 }; //! @todo does tv survive the thread? + AvahiTimeout* lp_timeout; + { + ScopedEventLoopBlock l_block(mp_poll); + const AvahiPoll* cp_apoll = avahi_threaded_poll_get(mp_poll); + m_shutdown = true; + lp_timeout = cp_apoll->timeout_new(cp_apoll, + &tv, + shutdownCallback, + this); + } + + //now wait for the thread to stop + assert(m_thread_id); + pthread_join(m_thread_id, NULL); + avahi_threaded_poll_get(mp_poll)->timeout_free(lp_timeout); + } + + //free the client (frees all browsers, groups, ...) + if (mp_client) + avahi_client_free(mp_client); + if (mp_poll) + avahi_threaded_poll_free(mp_poll); +} + +bool CZeroconfAvahi::doPublishService(const std::string& fcr_identifier, + const std::string& fcr_type, + const std::string& fcr_name, + unsigned int f_port, + const std::vector<std::pair<std::string, std::string> >& txt) +{ + CLog::Log(LOGDEBUG, "CZeroconfAvahi::doPublishService identifier: {} type: {} name:{} port:{}", + fcr_identifier, fcr_type, fcr_name, f_port); + + ScopedEventLoopBlock l_block(mp_poll); + tServiceMap::iterator it = m_services.find(fcr_identifier); + if (it != m_services.end()) + { + //fcr_identifier exists, no update functionality yet, so exit + return false; + } + + //txt records to AvahiStringList + AvahiStringList *txtList = NULL; + for (const auto& it : txt) + { + txtList = avahi_string_list_add_pair(txtList, it.first.c_str(), it.second.c_str()); + } + + //create service info and add it to service map + tServiceMap::mapped_type p_service_info(new CZeroconfAvahi::ServiceInfo(fcr_type, fcr_name, f_port, txtList)); + it = m_services.insert(it, std::make_pair(fcr_identifier, p_service_info)); + + //if client is already running, directly try to add the new service + if ( mp_client && avahi_client_get_state(mp_client) == AVAHI_CLIENT_S_RUNNING ) + { + //client's already running, add this new service + addService(p_service_info, mp_client); + } + else + { + CLog::Log(LOGDEBUG, "CZeroconfAvahi::doPublishService: client not running, queued for publishing"); + } + return true; +} + +bool CZeroconfAvahi::doForceReAnnounceService(const std::string& fcr_identifier) +{ + bool ret = false; + ScopedEventLoopBlock l_block(mp_poll); + tServiceMap::iterator it = m_services.find(fcr_identifier); + if (it != m_services.end() && it->second->mp_group) + { + // to force a reannounce on avahi its enough to reverse the txtrecord list + it->second->mp_txt = avahi_string_list_reverse(it->second->mp_txt); + + // this will trigger the reannouncement + if ((avahi_entry_group_update_service_txt_strlst(it->second->mp_group, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, AvahiPublishFlags(0), + it->second->m_name.c_str(), + it->second->m_type.c_str(), NULL, it->second->mp_txt)) >= 0) + ret = true; + } + + return ret; +} + +bool CZeroconfAvahi::doRemoveService(const std::string& fcr_ident) +{ + CLog::Log(LOGDEBUG, "CZeroconfAvahi::doRemoveService named: {}", fcr_ident); + ScopedEventLoopBlock l_block(mp_poll); + tServiceMap::iterator it = m_services.find(fcr_ident); + if (it == m_services.end()) + { + return false; + } + + if (it->second->mp_group) + { + avahi_entry_group_free(it->second->mp_group); + it->second->mp_group = 0; + } + + if(it->second->mp_txt) + { + avahi_string_list_free(it->second->mp_txt); + it->second->mp_txt = NULL; + } + + m_services.erase(it); + return true; +} + +void CZeroconfAvahi::doStop() +{ + ScopedEventLoopBlock l_block(mp_poll); + for (auto& it : m_services) + { + if (it.second->mp_group) + { + avahi_entry_group_free(it.second->mp_group); + it.second->mp_group = 0; + } + + if (it.second->mp_txt) + { + avahi_string_list_free(it.second->mp_txt); + it.second->mp_txt = nullptr; + } + } + m_services.clear(); +} + +void CZeroconfAvahi::clientCallback(AvahiClient* fp_client, AvahiClientState f_state, void* fp_data) +{ + CZeroconfAvahi* p_instance = static_cast<CZeroconfAvahi*>(fp_data); + + //store our thread ID and check for shutdown -> check details in destructor + p_instance->m_thread_id = pthread_self(); + + if (p_instance->m_shutdown) + { + avahi_threaded_poll_quit(p_instance->mp_poll); + return; + } + switch(f_state) + { + case AVAHI_CLIENT_S_RUNNING: + CLog::Log(LOGDEBUG, "CZeroconfAvahi::clientCallback: client is up and running"); + p_instance->updateServices(fp_client); + break; + + case AVAHI_CLIENT_FAILURE: + CLog::Log(LOGINFO, "CZeroconfAvahi::clientCallback: client failure. avahi-daemon stopped? Recreating client..."); + //We were forced to disconnect from server. now free and recreate the client object + avahi_client_free(fp_client); + p_instance->mp_client = 0; + //freeing the client also frees all groups and browsers, pointers are undefined afterwards, so fix that now + for (auto& it : p_instance->m_services) + { + it.second->mp_group = 0; + } + p_instance->createClient(); + break; + + case AVAHI_CLIENT_S_COLLISION: + case AVAHI_CLIENT_S_REGISTERING: + //HERE WE SHOULD REMOVE ALL OF OUR SERVICES AND "RESCHEDULE" them for later addition + CLog::Log(LOGDEBUG, "CZeroconfAvahi::clientCallback: uiuui; coll or reg, anyways, resetting groups"); + for (const auto& it : p_instance->m_services) + { + if (it.second->mp_group) + avahi_entry_group_reset(it.second->mp_group); + } + break; + + case AVAHI_CLIENT_CONNECTING: + CLog::Log(LOGINFO, "CZeroconfAvahi::clientCallback: avahi server not available. But may become later..."); + break; + } +} + +void CZeroconfAvahi::groupCallback(AvahiEntryGroup *fp_group, AvahiEntryGroupState f_state, void * fp_data) +{ + CZeroconfAvahi* p_instance = static_cast<CZeroconfAvahi*>(fp_data); + //store our thread ID and check for shutdown -> check details in destructor + p_instance->m_thread_id = pthread_self(); + if (p_instance->m_shutdown) + { + avahi_threaded_poll_quit(p_instance->mp_poll); + return; + } + + switch (f_state) + { + case AVAHI_ENTRY_GROUP_ESTABLISHED : + // The entry group has been established successfully + CLog::Log(LOGDEBUG, "CZeroconfAvahi::groupCallback: Service successfully established"); + break; + + case AVAHI_ENTRY_GROUP_COLLISION : + { + //need to find the ServiceInfo struct for this group + tServiceMap::iterator it = p_instance->m_services.begin(); + for(; it != p_instance->m_services.end(); ++it) + { + if (it->second->mp_group == fp_group) + break; + } + if( it != p_instance->m_services.end() ) { + char* alt_name = avahi_alternative_service_name( it->second->m_name.c_str() ); + it->second->m_name = alt_name; + avahi_free(alt_name); + CLog::Log(LOGINFO, "CZeroconfAvahi::groupCallback: Service name collision. Renamed to: {}", + it->second->m_name); + p_instance->addService(it->second, p_instance->mp_client); + } + break; + } + + case AVAHI_ENTRY_GROUP_FAILURE: + CLog::Log(LOGERROR, "CZeroconfAvahi::groupCallback: Entry group failure: {} ", + (fp_group) + ? avahi_strerror(avahi_client_errno(avahi_entry_group_get_client(fp_group))) + : "Unknown"); + //free the group and set to 0 so it may be added later + if (fp_group) + { + //need to find the ServiceInfo struct for this group + for (auto& it : p_instance->m_services) + { + if (it.second->mp_group == fp_group) + { + avahi_entry_group_free(it.second->mp_group); + it.second->mp_group = 0; + if (it.second->mp_txt) + { + avahi_string_list_free(it.second->mp_txt); + it.second->mp_txt = nullptr; + } + break; + } + } + } + break; + + case AVAHI_ENTRY_GROUP_UNCOMMITED: + case AVAHI_ENTRY_GROUP_REGISTERING: + default: + break; + } +} + +void CZeroconfAvahi::shutdownCallback(AvahiTimeout *fp_e, void *fp_data) +{ + CZeroconfAvahi* p_instance = static_cast<CZeroconfAvahi*>(fp_data); + //should only be called on shutdown + if (p_instance->m_shutdown) + { + avahi_threaded_poll_quit(p_instance->mp_poll); + } +} + +bool CZeroconfAvahi::createClient() +{ + if (mp_client) + { + avahi_client_free(mp_client); + } + + int error = 0; + mp_client = avahi_client_new(avahi_threaded_poll_get(mp_poll), + AVAHI_CLIENT_NO_FAIL, &clientCallback,this,&error); + if (!mp_client) + { + CLog::Log(LOGERROR, "CZeroconfAvahi::createClient() failed with {}", error); + return false; + } + return true; +} + +void CZeroconfAvahi::updateServices(AvahiClient* fp_client) +{ + for (const auto& it : m_services) + { + if (!it.second->mp_group) + addService(it.second, fp_client); + } +} + +void CZeroconfAvahi::addService(const tServiceMap::mapped_type& fp_service_info, + AvahiClient* fp_client) +{ + assert(fp_client); + CLog::Log(LOGDEBUG, "CZeroconfAvahi::addService() named: {} type: {} port:{}", + fp_service_info->m_name, fp_service_info->m_type, fp_service_info->m_port); + //create the group if it doesn't exist + if (!fp_service_info->mp_group) + { + if (!(fp_service_info->mp_group = avahi_entry_group_new(fp_client, &CZeroconfAvahi::groupCallback, this))) + { + CLog::Log(LOGDEBUG, "CZeroconfAvahi::addService() avahi_entry_group_new() failed: {}", + avahi_strerror(avahi_client_errno(fp_client))); + fp_service_info->mp_group = 0; + return; + } + } + + + // add entries to the group if it's empty + int ret; + if (avahi_entry_group_is_empty(fp_service_info->mp_group)) + { + if ((ret = avahi_entry_group_add_service_strlst(fp_service_info->mp_group, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, AvahiPublishFlags(0), + fp_service_info->m_name.c_str(), + fp_service_info->m_type.c_str(), NULL, NULL, fp_service_info->m_port, fp_service_info->mp_txt)) < 0) + { + if (ret == AVAHI_ERR_COLLISION) + { + char* alt_name = avahi_alternative_service_name(fp_service_info->m_name.c_str()); + fp_service_info->m_name = alt_name; + avahi_free(alt_name); + CLog::Log(LOGINFO, "CZeroconfAvahi::addService: Service name collision. Renamed to: {}", + fp_service_info->m_name); + addService(fp_service_info, fp_client); + return; + } + CLog::Log(LOGERROR, + "CZeroconfAvahi::addService(): failed to add service named:{}@$(HOSTNAME) type:{} " + "port:{}. Error:{} :/ FIXME!", + fp_service_info->m_name, fp_service_info->m_type, fp_service_info->m_port, + avahi_strerror(ret)); + return; + } + } + + // Tell the server to register the service + if ((ret = avahi_entry_group_commit(fp_service_info->mp_group)) < 0) + { + CLog::Log(LOGERROR, "CZeroconfAvahi::addService(): Failed to commit entry group! Error:{}", + avahi_strerror(ret)); + //! @todo what now? reset the group? free it? + } +} diff --git a/xbmc/platform/linux/network/zeroconf/ZeroconfAvahi.h b/xbmc/platform/linux/network/zeroconf/ZeroconfAvahi.h new file mode 100644 index 0000000..102df9b --- /dev/null +++ b/xbmc/platform/linux/network/zeroconf/ZeroconfAvahi.h @@ -0,0 +1,79 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "network/Zeroconf.h" + +#include <map> +#include <memory> +#include <string> +#include <vector> + +#include <avahi-client/client.h> +#include <avahi-client/publish.h> +#include <avahi-common/defs.h> + +struct AvahiThreadedPoll; + +class CZeroconfAvahi : public CZeroconf +{ +public: + CZeroconfAvahi(); + ~CZeroconfAvahi() override; + +protected: + //implement base CZeroConf interface + bool doPublishService(const std::string& fcr_identifier, + const std::string& fcr_type, + const std::string& fcr_name, + unsigned int f_port, + const std::vector<std::pair<std::string, std::string> >& txt) override; + + bool doForceReAnnounceService(const std::string& fcr_identifier) override; + bool doRemoveService(const std::string& fcr_ident) override; + + void doStop() override; + +private: + ///this is where the client calls us if state changes + static void clientCallback(AvahiClient* fp_client, AvahiClientState f_state, void*); + ///here we get notified of group changes + static void groupCallback(AvahiEntryGroup *fp_group, AvahiEntryGroupState f_state, void *); + //shutdown callback; works around a problem in avahi < 0.6.24 see destructor for details + static void shutdownCallback(AvahiTimeout *fp_e, void *); + + ///creates the avahi client; + ///@return true on success + bool createClient(); + + //don't access stuff below without stopping the client thread + //see http://avahi.org/wiki/RunningAvahiClientAsThread + //and use struct ScopedEventLoopBlock + + //helper struct for holding information about creating a service / AvahiEntryGroup + //we have to hold that as it's needed to recreate the service + struct ServiceInfo; + typedef std::map<std::string, std::shared_ptr<ServiceInfo> > tServiceMap; + + //goes through a list of todos and publishs them (takes the client a param, as it might be called from + // from the callbacks) + void updateServices(AvahiClient* fp_client); + //helper that actually does the work of publishing + void addService(const tServiceMap::mapped_type& fp_service_info, AvahiClient* fp_client); + + AvahiClient* mp_client = 0; + AvahiThreadedPoll* mp_poll = 0; + + //this holds all published and unpublished services including info on howto create them + tServiceMap m_services; + + //2 variables below are needed for workaround of avahi bug (see destructor for details) + bool m_shutdown = false; + pthread_t m_thread_id = 0; +}; diff --git a/xbmc/platform/linux/network/zeroconf/ZeroconfBrowserAvahi.cpp b/xbmc/platform/linux/network/zeroconf/ZeroconfBrowserAvahi.cpp new file mode 100644 index 0000000..491b98b --- /dev/null +++ b/xbmc/platform/linux/network/zeroconf/ZeroconfBrowserAvahi.cpp @@ -0,0 +1,383 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "ZeroconfBrowserAvahi.h" + +#include "GUIUserMessages.h" +#include "ServiceBroker.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIMessage.h" +#include "guilib/GUIWindowManager.h" +#include "utils/log.h" + +#include <avahi-common/error.h> +#include <avahi-common/malloc.h> +namespace +{ +///helper RAII-struct to block event loop for modifications +struct ScopedEventLoopBlock +{ + explicit ScopedEventLoopBlock ( AvahiThreadedPoll* fp_poll ) : mp_poll ( fp_poll ) + { + avahi_threaded_poll_lock ( mp_poll ); + } + + ~ScopedEventLoopBlock() + { + avahi_threaded_poll_unlock ( mp_poll ); + } +private: + AvahiThreadedPoll* mp_poll; +}; +} + +CZeroconfBrowserAvahi::CZeroconfBrowserAvahi() +{ + if ( ! ( mp_poll = avahi_threaded_poll_new() ) ) + { + CLog::Log ( LOGERROR, "CZeroconfAvahi::CZeroconfAvahi(): Could not create threaded poll object" ); + //! @todo throw exception? can this even happen? + return; + } + + if ( !createClient() ) + { + CLog::Log ( LOGERROR, "CZeroconfAvahi::CZeroconfAvahi(): Could not create client" ); + //yeah, what if not? but should always succeed (as client_no_fail or something is passed) + } + + //start event loop thread + if ( avahi_threaded_poll_start ( mp_poll ) < 0 ) + { + CLog::Log ( LOGERROR, "CZeroconfAvahi::CZeroconfAvahi(): Failed to start avahi client thread" ); + } +} + +CZeroconfBrowserAvahi::~CZeroconfBrowserAvahi() +{ + CLog::Log ( LOGDEBUG, "CZeroconfAvahi::~CZeroconfAvahi() Going down! cleaning up..." ); + if ( mp_poll ) + { + //stop avahi polling thread + avahi_threaded_poll_stop(mp_poll); + } + //free the client (frees all browsers, groups, ...) + if ( mp_client ) + avahi_client_free ( mp_client ); + if ( mp_poll ) + avahi_threaded_poll_free ( mp_poll ); +} + +bool CZeroconfBrowserAvahi::doAddServiceType ( const std::string& fcr_service_type ) +{ + ScopedEventLoopBlock lock ( mp_poll ); + tBrowserMap::iterator it = m_browsers.find ( fcr_service_type ); + if ( it != m_browsers.end() ) + return false; + else + it = m_browsers.insert ( std::make_pair ( fcr_service_type, ( AvahiServiceBrowser* ) 0 ) ).first; + + //if the client is running, we directly create a browser for the service here + if ( mp_client && avahi_client_get_state ( mp_client ) == AVAHI_CLIENT_S_RUNNING ) + { + AvahiServiceBrowser* browser = createServiceBrowser ( fcr_service_type, mp_client, this); + if ( !browser ) + { + m_browsers.erase ( it ); + return false; + } + else + { + it->second = browser; + return true; + } + } + else + { + CLog::Log ( LOGINFO, "CZeroconfBrowserAvahi::doAddServiceType client not available. service browsing queued" ); + return true; + } +} + +bool CZeroconfBrowserAvahi::doRemoveServiceType ( const std::string& fcr_service_type ) +{ + ScopedEventLoopBlock lock ( mp_poll ); + tBrowserMap::iterator it = m_browsers.find ( fcr_service_type ); + if ( it == m_browsers.end() ) + return false; + else + { + if ( it->second ) + { + avahi_service_browser_free ( it->second ); + m_all_for_now_browsers.erase ( it->second ); + } + m_browsers.erase ( it ); + //remove this serviceType from the list of discovered services + for (auto itr = m_discovered_services.begin(); itr != m_discovered_services.end();) + { + if (itr->first.GetType() == fcr_service_type) + itr = m_discovered_services.erase(itr); + else + ++itr; + } + } + return true; +} + +std::vector<CZeroconfBrowser::ZeroconfService> CZeroconfBrowserAvahi::doGetFoundServices() +{ + std::vector<CZeroconfBrowser::ZeroconfService> ret; + ScopedEventLoopBlock lock ( mp_poll ); + ret.reserve ( m_discovered_services.size() ); + for (const auto& it : m_discovered_services) + ret.push_back(it.first); + return ret; +} + +bool CZeroconfBrowserAvahi::doResolveService ( CZeroconfBrowser::ZeroconfService& fr_service, double f_timeout ) +{ + { + //wait for lock on event-loop to schedule resolving + ScopedEventLoopBlock lock ( mp_poll ); + //avahi can only resolve already discovered services, as it needs info from there + tDiscoveredServices::const_iterator it = m_discovered_services.find( fr_service ); + if ( it == m_discovered_services.end() ) + { + CLog::Log ( LOGERROR, "CZeroconfBrowserAvahi::doResolveService called with undiscovered service, resolving is NOT possible" ); + return false; + } + //start resolving + m_resolving_service = fr_service; + m_resolved_event.Reset(); + if ( !avahi_service_resolver_new ( mp_client, it->second.interface, it->second.protocol, + it->first.GetName().c_str(), it->first.GetType().c_str(), it->first.GetDomain().c_str(), + AVAHI_PROTO_UNSPEC, AvahiLookupFlags ( 0 ), resolveCallback, this ) ) + { + CLog::Log(LOGERROR, + "CZeroconfBrowserAvahi::doResolveService Failed to resolve service '{}': {}\n", + it->first.GetName(), avahi_strerror(avahi_client_errno(mp_client))); + return false; + } + } // end of this block releases lock of eventloop + + //wait for resolve to return or timeout + m_resolved_event.Wait(std::chrono::duration<double, std::milli>(f_timeout * 1000)); + { + ScopedEventLoopBlock lock ( mp_poll ); + fr_service = m_resolving_service; + return (!fr_service.GetIP().empty()); + } +} + +void CZeroconfBrowserAvahi::clientCallback ( AvahiClient* fp_client, AvahiClientState f_state, void* fp_data ) +{ + CZeroconfBrowserAvahi* p_instance = static_cast<CZeroconfBrowserAvahi*> ( fp_data ); + switch ( f_state ) + { + case AVAHI_CLIENT_S_RUNNING: + { + CLog::Log ( LOGDEBUG, "CZeroconfBrowserAvahi::clientCallback: client is up and running" ); + for (auto& it : p_instance->m_browsers) + { + assert(!it.second); + it.second = createServiceBrowser(it.first, fp_client, fp_data); + } + break; + } + case AVAHI_CLIENT_FAILURE: + { + CLog::Log ( LOGINFO, "CZeroconfBrowserAvahi::clientCallback: client failure. avahi-daemon stopped? Recreating client..." ); + //We were forced to disconnect from server. now free and recreate the client object + avahi_client_free ( fp_client ); + p_instance->mp_client = 0; + //freeing the client also frees all groups and browsers, pointers are undefined afterwards, so fix that now + for (auto& it : p_instance->m_browsers) + it.second = (AvahiServiceBrowser*)0; + //clean the list of discovered services and update gui (if someone is interested) + p_instance->m_discovered_services.clear(); + CGUIMessage message ( GUI_MSG_NOTIFY_ALL, 0, 0, GUI_MSG_UPDATE_PATH ); + message.SetStringParam ( "zeroconf://" ); + CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage ( message ); + p_instance->createClient(); + break; + } + case AVAHI_CLIENT_S_COLLISION: + case AVAHI_CLIENT_S_REGISTERING: + //HERE WE SHOULD REMOVE ALL OF OUR SERVICES AND "RESCHEDULE" them for later addition + CLog::Log ( LOGDEBUG, "CZeroconfBrowserAvahi::clientCallback: This should not happen" ); + break; + + case AVAHI_CLIENT_CONNECTING: + CLog::Log ( LOGINFO, "CZeroconfBrowserAvahi::clientCallback: avahi server not available. But may become later..." ); + break; + } +} +void CZeroconfBrowserAvahi::browseCallback ( + AvahiServiceBrowser *browser, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, + const char *name, const char *type, const char *domain, + AvahiLookupResultFlags flags, void* fp_data ) +{ + CZeroconfBrowserAvahi* p_instance = static_cast<CZeroconfBrowserAvahi*> ( fp_data ); + assert ( browser ); + bool update_gui = false; + /* Called whenever a new services becomes available on the LAN or is removed from the LAN */ + switch ( event ) + { + case AVAHI_BROWSER_FAILURE: + CLog::Log(LOGERROR, "CZeroconfBrowserAvahi::browseCallback error: {}\n", + avahi_strerror(avahi_client_errno(avahi_service_browser_get_client(browser)))); + //! @todo implement + return; + case AVAHI_BROWSER_NEW: + { + CLog::Log( + LOGDEBUG, + "CZeroconfBrowserAvahi::browseCallback NEW: service '{}' of type '{}' in domain '{}'\n", + name, type, domain); + //store the service + ZeroconfService service(name, type, domain); + AvahiSpecificInfos info; + info.interface = interface; + info.protocol = protocol; + p_instance->m_discovered_services.insert ( std::make_pair ( service, info ) ); + //if this browser already sent the all for now message, we need to update the gui now + if( p_instance->m_all_for_now_browsers.find(browser) != p_instance->m_all_for_now_browsers.end() ) + update_gui = true; + break; + } + case AVAHI_BROWSER_REMOVE: + { + //remove the service + ZeroconfService service(name, type, domain); + p_instance->m_discovered_services.erase ( service ); + CLog::Log(LOGDEBUG, + "CZeroconfBrowserAvahi::browseCallback REMOVE: service '{}' of type '{}' in " + "domain '{}'\n", + name, type, domain); + //if this browser already sent the all for now message, we need to update the gui now + if( p_instance->m_all_for_now_browsers.find(browser) != p_instance->m_all_for_now_browsers.end() ) + update_gui = true; + break; + } + case AVAHI_BROWSER_CACHE_EXHAUSTED: + //do we need that? + break; + case AVAHI_BROWSER_ALL_FOR_NOW: + CLog::Log(LOGDEBUG, "CZeroconfBrowserAvahi::browseCallback all for now (service = {})", type); + //if this browser already sent the all for now message, we need to update the gui now + bool success = p_instance->m_all_for_now_browsers.insert(browser).second; + if(!success) + CLog::Log ( LOGDEBUG, "CZeroconfBrowserAvahi::browseCallback AVAHI_BROWSER_ALL_FOR_NOW sent twice?!"); + update_gui = true; + break; + } + if ( update_gui ) + { + CGUIMessage message ( GUI_MSG_NOTIFY_ALL, 0, 0, GUI_MSG_UPDATE_PATH ); + message.SetStringParam ( "zeroconf://" ); + CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage ( message ); + CLog::Log ( LOGDEBUG, "CZeroconfBrowserAvahi::browseCallback sent gui update for path zeroconf://" ); + } +} + +CZeroconfBrowser::ZeroconfService::tTxtRecordMap GetTxtRecords(AvahiStringList *txt) +{ + AvahiStringList *i = NULL; + CZeroconfBrowser::ZeroconfService::tTxtRecordMap recordMap; + + for( i = txt; i; i = i->next ) + { + char *key, *value; + + if( avahi_string_list_get_pair( i, &key, &value, NULL ) < 0 ) + continue; + + recordMap.insert( + std::make_pair( + std::string(key), + std::string(value) + ) + ); + + if( key ) + avahi_free(key); + if( value ) + avahi_free(value); + } + return recordMap; +} + +void CZeroconfBrowserAvahi::resolveCallback( + AvahiServiceResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, + const char *name, const char *type, const char *domain, const char *host_name, + const AvahiAddress *address, uint16_t port, AvahiStringList *txt, AvahiLookupResultFlags flags, void* userdata ) +{ + assert ( r ); + assert ( userdata ); + CZeroconfBrowserAvahi* p_instance = static_cast<CZeroconfBrowserAvahi*> ( userdata ); + switch ( event ) + { + case AVAHI_RESOLVER_FAILURE: + CLog::Log(LOGERROR, + "CZeroconfBrowserAvahi::resolveCallback Failed to resolve service '{}' of type " + "'{}' in domain '{}': {}\n", + name, type, domain, + avahi_strerror(avahi_client_errno(avahi_service_resolver_get_client(r)))); + break; + case AVAHI_RESOLVER_FOUND: + { + char a[AVAHI_ADDRESS_STR_MAX]; + CLog::Log(LOGDEBUG, + "CZeroconfBrowserAvahi::resolveCallback resolved service '{}' of type '{}' in " + "domain '{}':\n", + name, type, domain); + + avahi_address_snprint ( a, sizeof ( a ), address ); + p_instance->m_resolving_service.SetIP(a); + p_instance->m_resolving_service.SetPort(port); + //get txt-record list + p_instance->m_resolving_service.SetTxtRecords(GetTxtRecords(txt)); + break; + } + } + avahi_service_resolver_free ( r ); + p_instance->m_resolved_event.Set(); +} + +bool CZeroconfBrowserAvahi::createClient() +{ + assert ( mp_poll ); + if ( mp_client ) + { + avahi_client_free ( mp_client ); + } + mp_client = avahi_client_new ( avahi_threaded_poll_get ( mp_poll ), + AVAHI_CLIENT_NO_FAIL, &clientCallback, this, 0 ); + if ( !mp_client ) + { + mp_client = 0; + return false; + } + return true; +} + +AvahiServiceBrowser* CZeroconfBrowserAvahi::createServiceBrowser ( const std::string& fcr_service_type, AvahiClient* fp_client, void* fp_userdata) +{ + assert(fp_client); + AvahiServiceBrowser* ret = avahi_service_browser_new ( fp_client, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, fcr_service_type.c_str(), + NULL, ( AvahiLookupFlags ) 0, browseCallback, fp_userdata ); + if ( !ret ) + { + CLog::Log( + LOGERROR, + "CZeroconfBrowserAvahi::createServiceBrowser Failed to create service ({}) browser: {}", + avahi_strerror(avahi_client_errno(fp_client)), fcr_service_type); + } + return ret; +} diff --git a/xbmc/platform/linux/network/zeroconf/ZeroconfBrowserAvahi.h b/xbmc/platform/linux/network/zeroconf/ZeroconfBrowserAvahi.h new file mode 100644 index 0000000..cc8c6c4 --- /dev/null +++ b/xbmc/platform/linux/network/zeroconf/ZeroconfBrowserAvahi.h @@ -0,0 +1,94 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "network/ZeroconfBrowser.h" +#include "threads/CriticalSection.h" +#include "threads/Thread.h" + +#include <map> +#include <memory> +#include <vector> + +#include <avahi-client/client.h> +#include <avahi-client/lookup.h> +#include <avahi-common/defs.h> +#include <avahi-common/thread-watch.h> + +//platform specific implementation of zeroconfbrowser interface using avahi +class CZeroconfBrowserAvahi : public CZeroconfBrowser +{ + public: + CZeroconfBrowserAvahi(); + ~CZeroconfBrowserAvahi() override; + + private: + ///implementation if CZeroconfBrowser interface + ///@{ + bool doAddServiceType(const std::string& fcr_service_type) override; + bool doRemoveServiceType(const std::string& fcr_service_type) override; + + std::vector<CZeroconfBrowser::ZeroconfService> doGetFoundServices() override; + bool doResolveService(CZeroconfBrowser::ZeroconfService& fr_service, double f_timeout) override; + ///@} + + /// avahi callbacks + ///@{ + static void clientCallback(AvahiClient *c, AvahiClientState state, AVAHI_GCC_UNUSED void * userdata); + static void browseCallback( + AvahiServiceBrowser *b, + AvahiIfIndex interface, + AvahiProtocol protocol, + AvahiBrowserEvent event, + const char *name, + const char *type, + const char *domain, + AVAHI_GCC_UNUSED AvahiLookupResultFlags flags, + void* userdata); + static void resolveCallback( + AvahiServiceResolver *r, + AvahiIfIndex interface, + AvahiProtocol protocol, + AvahiResolverEvent event, + const char *name, + const char *type, + const char *domain, + const char *host_name, + const AvahiAddress *address, + uint16_t port, + AvahiStringList *txt, + AvahiLookupResultFlags flags, + AVAHI_GCC_UNUSED void* userdata); + //helpers + bool createClient(); + static AvahiServiceBrowser* createServiceBrowser(const std::string& fcr_service_type, AvahiClient* fp_client, void* fp_userdata); + + //shared variables between avahi thread and interface + AvahiClient* mp_client = 0 ; + AvahiThreadedPoll* mp_poll = 0 ; + // tBrowserMap maps service types the corresponding browser + typedef std::map<std::string, AvahiServiceBrowser*> tBrowserMap; + tBrowserMap m_browsers; + + // if a browser is in this set, it already sent an ALL_FOR_NOW message + // (needed to bundle GUI_MSG_UPDATE_PATH messages + std::set<AvahiServiceBrowser*> m_all_for_now_browsers; + + //this information is needed for avahi to resolve a service, + //so unfortunately we'll only be able to resolve services already discovered + struct AvahiSpecificInfos + { + AvahiIfIndex interface; + AvahiProtocol protocol; + }; + typedef std::map<CZeroconfBrowser::ZeroconfService, AvahiSpecificInfos> tDiscoveredServices; + tDiscoveredServices m_discovered_services; + CZeroconfBrowser::ZeroconfService m_resolving_service; + CEvent m_resolved_event; +}; diff --git a/xbmc/platform/linux/peripherals/CMakeLists.txt b/xbmc/platform/linux/peripherals/CMakeLists.txt new file mode 100644 index 0000000..626aa40 --- /dev/null +++ b/xbmc/platform/linux/peripherals/CMakeLists.txt @@ -0,0 +1,11 @@ +if(UDEV_FOUND) + list(APPEND SOURCES PeripheralBusUSBLibUdev.cpp) + list(APPEND HEADERS PeripheralBusUSBLibUdev.h) +elseif(LIBUSB_FOUND) + list(APPEND SOURCES PeripheralBusUSBLibUSB.cpp) + list(APPEND HEADERS PeripheralBusUSBLibUSB.h) +endif() + +if(SOURCES) + core_add_library(platform_linux_peripherals) +endif() diff --git a/xbmc/platform/linux/peripherals/PeripheralBusUSBLibUSB.cpp b/xbmc/platform/linux/peripherals/PeripheralBusUSBLibUSB.cpp new file mode 100644 index 0000000..5c788bb --- /dev/null +++ b/xbmc/platform/linux/peripherals/PeripheralBusUSBLibUSB.cpp @@ -0,0 +1,78 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "PeripheralBusUSBLibUSB.h" + +#include "peripherals/Peripherals.h" +#include "utils/StringUtils.h" +#include "utils/log.h" + +#include <usb.h> + +using namespace PERIPHERALS; + +CPeripheralBusUSB::CPeripheralBusUSB(CPeripherals& manager) : + CPeripheralBus("PeripBusUSB", manager, PERIPHERAL_BUS_USB) +{ + usb_init(); + usb_find_busses(); + m_busses = usb_get_busses(); + CLog::Log(LOGDEBUG, "{} - using libusb peripheral scanning", __FUNCTION__); +} + +bool CPeripheralBusUSB::PerformDeviceScan(PeripheralScanResults &results) +{ + struct usb_bus *bus; + usb_find_devices(); + for (bus = m_busses; bus; bus = bus->next) + { + struct usb_device *dev; + for (dev = bus->devices; dev; dev = dev->next) + { + PeripheralScanResult result(m_type); + result.m_iVendorId = dev->descriptor.idVendor; + result.m_iProductId = dev->descriptor.idProduct; + result.m_type = (dev->descriptor.bDeviceClass == USB_CLASS_PER_INTERFACE && dev->descriptor.bNumConfigurations > 0 && + dev->config[0].bNumInterfaces > 0 && dev->config[0].interface[0].num_altsetting > 0) ? + GetType(dev->config[0].interface[0].altsetting[0].bInterfaceClass) : + GetType(dev->descriptor.bDeviceClass); +#ifdef TARGET_FREEBSD + result.m_strLocation = std::to_string(dev->filename); +#else + result.m_strLocation = StringUtils::Format("/bus{}/dev{}", bus->dirname, dev->filename); +#endif + result.m_iSequence = GetNumberOfPeripheralsWithId(result.m_iVendorId, result.m_iProductId); + if (!results.ContainsResult(result)) + results.m_results.push_back(result); + } + } + + return true; +} + +const PeripheralType CPeripheralBusUSB::GetType(int iDeviceClass) +{ + switch (iDeviceClass) + { + case USB_CLASS_HID: + return PERIPHERAL_HID; + case USB_CLASS_COMM: + return PERIPHERAL_NIC; + case USB_CLASS_MASS_STORAGE: + return PERIPHERAL_DISK; + case USB_CLASS_PER_INTERFACE: + case USB_CLASS_AUDIO: + case USB_CLASS_PRINTER: + case USB_CLASS_PTP: + case USB_CLASS_HUB: + case USB_CLASS_DATA: + case USB_CLASS_VENDOR_SPEC: + default: + return PERIPHERAL_UNKNOWN; + } +} diff --git a/xbmc/platform/linux/peripherals/PeripheralBusUSBLibUSB.h b/xbmc/platform/linux/peripherals/PeripheralBusUSBLibUSB.h new file mode 100644 index 0000000..d2e7e48 --- /dev/null +++ b/xbmc/platform/linux/peripherals/PeripheralBusUSBLibUSB.h @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "peripherals/bus/PeripheralBus.h" +#include "peripherals/devices/Peripheral.h" + +struct usb_bus; + +namespace PERIPHERALS +{ + class CPeripherals; + + class CPeripheralBusUSB : public CPeripheralBus + { + public: + explicit CPeripheralBusUSB(CPeripherals& manager); + + /*! + * @see PeripheralBus::PerformDeviceScan() + */ + bool PerformDeviceScan(PeripheralScanResults &results); + + protected: + static const PeripheralType GetType(int iDeviceClass); + struct usb_bus *m_busses; + }; +} diff --git a/xbmc/platform/linux/peripherals/PeripheralBusUSBLibUdev.cpp b/xbmc/platform/linux/peripherals/PeripheralBusUSBLibUdev.cpp new file mode 100644 index 0000000..aeb5e71 --- /dev/null +++ b/xbmc/platform/linux/peripherals/PeripheralBusUSBLibUdev.cpp @@ -0,0 +1,254 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "PeripheralBusUSBLibUdev.h" +#include "peripherals/Peripherals.h" +extern "C" { +#include <libudev.h> +} +#include <cassert> +#include <poll.h> +#include "utils/log.h" + +#ifndef USB_CLASS_PER_INTERFACE +#define USB_CLASS_PER_INTERFACE 0 +#endif + +#ifndef USB_CLASS_AUDIO +#define USB_CLASS_AUDIO 1 +#endif + +#ifndef USB_CLASS_COMM +#define USB_CLASS_COMM 2 +#endif + +#ifndef USB_CLASS_HID +#define USB_CLASS_HID 3 +#endif + +#ifndef USB_CLASS_PHYSICAL +#define USB_CLASS_PHYSICAL 5 +#endif + +#ifndef USB_CLASS_PTP +#define USB_CLASS_PTP 6 +#endif + +#ifndef USB_CLASS_PRINTER +#define USB_CLASS_PRINTER 7 +#endif + +#ifndef USB_CLASS_MASS_STORAGE +#define USB_CLASS_MASS_STORAGE 8 +#endif + +#ifndef USB_CLASS_HUB +#define USB_CLASS_HUB 9 +#endif + +#ifndef USB_CLASS_DATA +#define USB_CLASS_DATA 10 +#endif + +#ifndef USB_CLASS_APP_SPEC +#define USB_CLASS_APP_SPEC 0xfe +#endif + +#ifndef USB_CLASS_VENDOR_SPEC +#define USB_CLASS_VENDOR_SPEC 0xff +#endif + +using namespace PERIPHERALS; + +CPeripheralBusUSB::CPeripheralBusUSB(CPeripherals& manager) : + CPeripheralBus("PeripBusUSBUdev", manager, PERIPHERAL_BUS_USB) +{ + /* the Process() method in this class overrides the one in CPeripheralBus, so leave this set to true */ + m_bNeedsPolling = true; + + m_udev = NULL; + m_udevMon = NULL; +} + +CPeripheralBusUSB::~CPeripheralBusUSB(void) +{ + StopThread(true); +} + +bool CPeripheralBusUSB::PerformDeviceScan(PeripheralScanResults &results) +{ + // We don't want this one to be called from outside world + assert(IsCurrentThread()); + + struct udev_enumerate *enumerate; + struct udev_list_entry *devices, *dev_list_entry; + struct udev_device *dev(NULL), *parent(NULL); + enumerate = udev_enumerate_new(m_udev); + udev_enumerate_scan_devices(enumerate); + devices = udev_enumerate_get_list_entry(enumerate); + + bool bContinue(true); + std::string strPath, strClass; + udev_list_entry_foreach(dev_list_entry, devices) + { + strPath = udev_list_entry_get_name(dev_list_entry); + if (strPath.empty()) + bContinue = false; + + if (bContinue) + { + if (!(parent = udev_device_new_from_syspath(m_udev, strPath.c_str()))) + bContinue = false; + } + + if (bContinue) + { + dev = udev_device_get_parent(udev_device_get_parent(parent)); + if (!dev || !udev_device_get_sysattr_value(dev,"idVendor") || !udev_device_get_sysattr_value(dev, "idProduct")) + bContinue = false; + } + + if (bContinue) + { + strClass = udev_device_get_sysattr_value(dev, "bDeviceClass"); + if (strClass.empty()) + bContinue = false; + } + + if (bContinue) + { + int iClass = PeripheralTypeTranslator::HexStringToInt(strClass.c_str()); + if (iClass == USB_CLASS_PER_INTERFACE) + { + //! @todo just assume this is a HID device for now, since the only devices that we're currently + //! interested in are HID devices + iClass = USB_CLASS_HID; + } + + PeripheralScanResult result(m_type); + result.m_iVendorId = PeripheralTypeTranslator::HexStringToInt(udev_device_get_sysattr_value(dev, "idVendor")); + result.m_iProductId = PeripheralTypeTranslator::HexStringToInt(udev_device_get_sysattr_value(dev, "idProduct")); + result.m_type = GetType(iClass); + result.m_strLocation = udev_device_get_syspath(dev); + result.m_iSequence = GetNumberOfPeripheralsWithId(result.m_iVendorId, result.m_iProductId); + if (!results.ContainsResult(result)) + results.m_results.push_back(result); + } + + bContinue = true; + if (parent) + { + /* unref the _parent_ device */ + udev_device_unref(parent); + parent = NULL; + } + } + /* Free the enumerator object */ + udev_enumerate_unref(enumerate); + + return true; +} + +PeripheralType CPeripheralBusUSB::GetType(int iDeviceClass) +{ + switch (iDeviceClass) + { + case USB_CLASS_HID: + return PERIPHERAL_HID; + case USB_CLASS_COMM: + return PERIPHERAL_NIC; + case USB_CLASS_MASS_STORAGE: + return PERIPHERAL_DISK; + case USB_CLASS_PER_INTERFACE: + case USB_CLASS_AUDIO: + case USB_CLASS_PRINTER: + case USB_CLASS_PTP: + case USB_CLASS_HUB: + case USB_CLASS_DATA: + case USB_CLASS_VENDOR_SPEC: + default: + return PERIPHERAL_UNKNOWN; + } +} + +void CPeripheralBusUSB::Process(void) +{ + if (!(m_udev = udev_new())) + { + CLog::Log(LOGERROR, "{} - failed to allocate udev context", __FUNCTION__); + return; + } + + /* set up a devices monitor that listen for any device change */ + m_udevMon = udev_monitor_new_from_netlink(m_udev, "udev"); + + /* filter to only receive usb events */ + if (udev_monitor_filter_add_match_subsystem_devtype(m_udevMon, "usb", nullptr) < 0) + { + CLog::Log(LOGERROR, "Could not limit filter on USB only"); + } + + CLog::Log(LOGDEBUG, "{} - initialised udev monitor", __FUNCTION__); + + udev_monitor_enable_receiving(m_udevMon); + bool bUpdated(false); + ScanForDevices(); + while (!m_bStop) + { + bUpdated = WaitForUpdate(); + if (bUpdated && !m_bStop) + ScanForDevices(); + } + udev_monitor_unref(m_udevMon); + udev_unref(m_udev); +} + +void CPeripheralBusUSB::Clear(void) +{ + StopThread(false); + + CPeripheralBus::Clear(); +} + +bool CPeripheralBusUSB::WaitForUpdate() +{ + int udevFd = udev_monitor_get_fd(m_udevMon); + + if (udevFd < 0) + { + CLog::Log(LOGERROR, "{} - get udev monitor", __FUNCTION__); + return false; + } + + /* poll for udev changes */ + struct pollfd pollFd; + pollFd.fd = udevFd; + pollFd.events = POLLIN; + int iPollResult; + while (!m_bStop && ((iPollResult = poll(&pollFd, 1, 100)) <= 0)) + if (errno != EINTR && iPollResult != 0) + break; + + /* the thread is being stopped, so just return false */ + if (m_bStop) + return false; + + /* we have to read the message from the queue, even though we're not actually using it */ + struct udev_device *dev = udev_monitor_receive_device(m_udevMon); + if (dev) + udev_device_unref(dev); + else + { + CLog::Log(LOGERROR, "{} - failed to get device from udev_monitor_receive_device()", + __FUNCTION__); + Clear(); + return false; + } + + return true; +} diff --git a/xbmc/platform/linux/peripherals/PeripheralBusUSBLibUdev.h b/xbmc/platform/linux/peripherals/PeripheralBusUSBLibUdev.h new file mode 100644 index 0000000..72cb437 --- /dev/null +++ b/xbmc/platform/linux/peripherals/PeripheralBusUSBLibUdev.h @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "peripherals/bus/PeripheralBus.h" +#include "peripherals/devices/Peripheral.h" + +struct udev; +struct udev_monitor; + +namespace PERIPHERALS +{ + class CPeripherals; + + class CPeripheralBusUSB : public CPeripheralBus + { + public: + explicit CPeripheralBusUSB(CPeripherals& manager); + ~CPeripheralBusUSB(void) override; + + void Clear(void) override; + + /*! + * @see PeripheralBus::PerformDeviceScan() + */ + bool PerformDeviceScan(PeripheralScanResults &results) override; + + protected: + static PeripheralType GetType(int iDeviceClass); + + void Process(void) override; + bool WaitForUpdate(void); + + struct udev * m_udev; + struct udev_monitor *m_udevMon; + }; +} diff --git a/xbmc/platform/linux/powermanagement/CMakeLists.txt b/xbmc/platform/linux/powermanagement/CMakeLists.txt new file mode 100644 index 0000000..3694a79 --- /dev/null +++ b/xbmc/platform/linux/powermanagement/CMakeLists.txt @@ -0,0 +1,17 @@ +set(SOURCES LinuxPowerSyscall.cpp) + +set(HEADERS FallbackPowerSyscall.h + LinuxPowerSyscall.h) + +if(DBUS_FOUND) + list(APPEND SOURCES ConsoleUPowerSyscall.cpp + LogindUPowerSyscall.cpp + UPowerSyscall.cpp) + list(APPEND HEADERS ConsoleUPowerSyscall.h + LogindUPowerSyscall.h + UPowerSyscall.h) +endif() + +if(SOURCES) + core_add_library(platform_linux_powermanagement) +endif() diff --git a/xbmc/platform/linux/powermanagement/ConsoleUPowerSyscall.cpp b/xbmc/platform/linux/powermanagement/ConsoleUPowerSyscall.cpp new file mode 100644 index 0000000..6f04dd7 --- /dev/null +++ b/xbmc/platform/linux/powermanagement/ConsoleUPowerSyscall.cpp @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "ConsoleUPowerSyscall.h" + +#include "utils/log.h" + +CConsoleUPowerSyscall::CConsoleUPowerSyscall() +{ + m_CanPowerdown = ConsoleKitMethodCall("CanStop"); + m_CanReboot = ConsoleKitMethodCall("CanRestart"); +} + +bool CConsoleUPowerSyscall::Powerdown() +{ + CDBusMessage message("org.freedesktop.ConsoleKit", "/org/freedesktop/ConsoleKit/Manager", "org.freedesktop.ConsoleKit.Manager", "Stop"); + return message.SendSystem() != NULL; +} + +bool CConsoleUPowerSyscall::Reboot() +{ + CDBusMessage message("org.freedesktop.ConsoleKit", "/org/freedesktop/ConsoleKit/Manager", "org.freedesktop.ConsoleKit.Manager", "Restart"); + return message.SendSystem() != NULL; +} + +bool CConsoleUPowerSyscall::HasConsoleKitAndUPower() +{ + return CDBusUtil::TryMethodCall(DBUS_BUS_SYSTEM, "org.freedesktop.ConsoleKit", "/org/freedesktop/ConsoleKit/Manager", "org.freedesktop.ConsoleKit.Manager", "CanStop") + && HasUPower(); +} + +bool CConsoleUPowerSyscall::ConsoleKitMethodCall(const char *method) +{ + CDBusMessage message("org.freedesktop.ConsoleKit", "/org/freedesktop/ConsoleKit/Manager", "org.freedesktop.ConsoleKit.Manager", method); + DBusMessage *reply = message.SendSystem(); + if (reply) + { + dbus_bool_t boolean = FALSE; + + if (dbus_message_get_args (reply, NULL, DBUS_TYPE_BOOLEAN, &boolean, DBUS_TYPE_INVALID)) + return boolean; + } + + return false; +} diff --git a/xbmc/platform/linux/powermanagement/ConsoleUPowerSyscall.h b/xbmc/platform/linux/powermanagement/ConsoleUPowerSyscall.h new file mode 100644 index 0000000..9fdd157 --- /dev/null +++ b/xbmc/platform/linux/powermanagement/ConsoleUPowerSyscall.h @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "DBusUtil.h" +#include "UPowerSyscall.h" + +class CConsoleUPowerSyscall : public CUPowerSyscall +{ +public: + CConsoleUPowerSyscall(); + bool Powerdown() override; + bool Reboot() override; + static bool HasConsoleKitAndUPower(); +private: + static bool ConsoleKitMethodCall(const char *method); +}; diff --git a/xbmc/platform/linux/powermanagement/FallbackPowerSyscall.h b/xbmc/platform/linux/powermanagement/FallbackPowerSyscall.h new file mode 100644 index 0000000..6988543 --- /dev/null +++ b/xbmc/platform/linux/powermanagement/FallbackPowerSyscall.h @@ -0,0 +1,26 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "powermanagement/IPowerSyscall.h" + +class CFallbackPowerSyscall : public CPowerSyscallWithoutEvents +{ +public: + bool Powerdown() override {return true; } + bool Suspend() override {return false; } + bool Hibernate() override {return false; } + bool Reboot() override {return true; } + + bool CanPowerdown() override {return true; } + bool CanSuspend() override {return false; } + bool CanHibernate() override {return false; } + bool CanReboot() override {return true; } + int BatteryLevel() override {return 0; } +}; diff --git a/xbmc/platform/linux/powermanagement/LinuxPowerSyscall.cpp b/xbmc/platform/linux/powermanagement/LinuxPowerSyscall.cpp new file mode 100644 index 0000000..f3dbcdb --- /dev/null +++ b/xbmc/platform/linux/powermanagement/LinuxPowerSyscall.cpp @@ -0,0 +1,65 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "LinuxPowerSyscall.h" +#include "FallbackPowerSyscall.h" +#if defined(HAS_DBUS) +#include "ConsoleUPowerSyscall.h" +#include "LogindUPowerSyscall.h" +#include "UPowerSyscall.h" +#endif // HAS_DBUS + +#include <functional> +#include <list> +#include <memory> +#include <utility> + +IPowerSyscall* CLinuxPowerSyscall::CreateInstance() +{ +#if defined(HAS_DBUS) + std::unique_ptr<IPowerSyscall> bestPowerManager; + std::unique_ptr<IPowerSyscall> currPowerManager; + int bestCount = -1; + int currCount = -1; + + std::list< std::pair< std::function<bool()>, + std::function<IPowerSyscall*()> > > powerManagers = + { + std::make_pair(CConsoleUPowerSyscall::HasConsoleKitAndUPower, + [] { return new CConsoleUPowerSyscall(); }), + std::make_pair(CLogindUPowerSyscall::HasLogind, + [] { return new CLogindUPowerSyscall(); }), + std::make_pair(CUPowerSyscall::HasUPower, + [] { return new CUPowerSyscall(); }) + }; + for(const auto& powerManager : powerManagers) + { + if (powerManager.first()) + { + currPowerManager.reset(powerManager.second()); + currCount = currPowerManager->CountPowerFeatures(); + if (currCount > bestCount) + { + bestCount = currCount; + bestPowerManager = std::move(currPowerManager); + } + if (bestCount == IPowerSyscall::MAX_COUNT_POWER_FEATURES) + break; + } + } + if (bestPowerManager) + return bestPowerManager.release(); + else +#endif // HAS_DBUS + return new CFallbackPowerSyscall(); +} + +void CLinuxPowerSyscall::Register() +{ + IPowerSyscall::RegisterPowerSyscall(CLinuxPowerSyscall::CreateInstance); +} diff --git a/xbmc/platform/linux/powermanagement/LinuxPowerSyscall.h b/xbmc/platform/linux/powermanagement/LinuxPowerSyscall.h new file mode 100644 index 0000000..b5cc218 --- /dev/null +++ b/xbmc/platform/linux/powermanagement/LinuxPowerSyscall.h @@ -0,0 +1,18 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "powermanagement/IPowerSyscall.h" + +class CLinuxPowerSyscall +{ +public: + static IPowerSyscall* CreateInstance(); + static void Register(); +}; diff --git a/xbmc/platform/linux/powermanagement/LogindUPowerSyscall.cpp b/xbmc/platform/linux/powermanagement/LogindUPowerSyscall.cpp new file mode 100644 index 0000000..bd04197 --- /dev/null +++ b/xbmc/platform/linux/powermanagement/LogindUPowerSyscall.cpp @@ -0,0 +1,342 @@ +/* + * Copyright (C) 2012 Denis Yantarev + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "LogindUPowerSyscall.h" + +#include "utils/StringUtils.h" +#include "utils/log.h" + +#include <string.h> + +#include <unistd.h> + +// logind DBus interface specification: +// http://www.freedesktop.org/wiki/Software/Logind/logind +// +// Inhibitor Locks documentation: +// http://www.freedesktop.org/wiki/Software/Logind/inhibit/ + +#define LOGIND_DEST "org.freedesktop.login1" +#define LOGIND_PATH "/org/freedesktop/login1" +#define LOGIND_IFACE "org.freedesktop.login1.Manager" + +CLogindUPowerSyscall::CLogindUPowerSyscall() +{ + m_lowBattery = false; + + CLog::Log(LOGINFO, "Selected Logind/UPower as PowerSyscall"); + + // Check if we have UPower. If not, we avoid any battery related operations. + CDBusMessage message("org.freedesktop.UPower", "/org/freedesktop/UPower", "org.freedesktop.UPower", "EnumerateDevices"); + m_hasUPower = message.SendSystem() != NULL; + + if (!m_hasUPower) + CLog::Log(LOGINFO, "LogindUPowerSyscall - UPower not found, battery information will not be available"); + + m_canPowerdown = LogindCheckCapability("CanPowerOff"); + m_canReboot = LogindCheckCapability("CanReboot"); + m_canHibernate = LogindCheckCapability("CanHibernate"); + m_canSuspend = LogindCheckCapability("CanSuspend"); + + InhibitDelayLockSleep(); + + m_batteryLevel = 0; + if (m_hasUPower) + UpdateBatteryLevel(); + + if (!m_connection.Connect(DBUS_BUS_SYSTEM, true)) + { + return; + } + + CDBusError error; + dbus_connection_set_exit_on_disconnect(m_connection, false); + dbus_bus_add_match(m_connection, "type='signal',interface='org.freedesktop.login1.Manager',member='PrepareForSleep'", error); + + if (!error && m_hasUPower) + dbus_bus_add_match(m_connection, "type='signal',interface='org.freedesktop.UPower',member='DeviceChanged'", error); + + dbus_connection_flush(m_connection); + + if (error) + { + error.Log("UPowerSyscall: Failed to attach to signal"); + m_connection.Destroy(); + } +} + +CLogindUPowerSyscall::~CLogindUPowerSyscall() +{ + ReleaseDelayLockSleep(); + ReleaseDelayLockShutdown(); +} + +bool CLogindUPowerSyscall::Powerdown() +{ + // delay shutdown so that the app can close properly + InhibitDelayLockShutdown(); + return LogindSetPowerState("PowerOff"); +} + +bool CLogindUPowerSyscall::Reboot() +{ + return LogindSetPowerState("Reboot"); +} + +bool CLogindUPowerSyscall::Suspend() +{ + return LogindSetPowerState("Suspend"); +} + +bool CLogindUPowerSyscall::Hibernate() +{ + return LogindSetPowerState("Hibernate"); +} + +bool CLogindUPowerSyscall::CanPowerdown() +{ + return m_canPowerdown; +} + +bool CLogindUPowerSyscall::CanSuspend() +{ + return m_canSuspend; +} + +bool CLogindUPowerSyscall::CanHibernate() +{ + return m_canHibernate; +} + +bool CLogindUPowerSyscall::CanReboot() +{ + return m_canReboot; +} + +bool CLogindUPowerSyscall::HasLogind() +{ + // recommended method by systemd devs. The seats directory + // doesn't exist unless logind created it and therefore is running. + // see also https://mail.gnome.org/archives/desktop-devel-list/2013-March/msg00092.html + if (access("/run/systemd/seats/", F_OK) >= 0) + return true; + + // on some environments "/run/systemd/seats/" doesn't exist, e.g. on flatpak. Try DBUS instead. + CDBusMessage message(LOGIND_DEST, LOGIND_PATH, LOGIND_IFACE, "ListSeats"); + DBusMessage *reply = message.SendSystem(); + if (!reply) + return false; + + DBusMessageIter arrIter; + if (dbus_message_iter_init(reply, &arrIter) && dbus_message_iter_get_arg_type(&arrIter) == DBUS_TYPE_ARRAY) + { + DBusMessageIter structIter; + dbus_message_iter_recurse(&arrIter, &structIter); + if (dbus_message_iter_get_arg_type(&structIter) == DBUS_TYPE_STRUCT) + { + DBusMessageIter strIter; + dbus_message_iter_recurse(&structIter, &strIter); + if (dbus_message_iter_get_arg_type(&strIter) == DBUS_TYPE_STRING) + { + char *seat; + dbus_message_iter_get_basic(&strIter, &seat); + if (StringUtils::StartsWith(seat, "seat")) + { + CLog::Log(LOGDEBUG, "LogindUPowerSyscall::HasLogind - found seat: {}", seat); + return true; + } + } + } + } + return false; +} + +bool CLogindUPowerSyscall::LogindSetPowerState(const char *state) +{ + CDBusMessage message(LOGIND_DEST, LOGIND_PATH, LOGIND_IFACE, state); + // The user_interaction boolean parameters can be used to control + // whether PolicyKit should interactively ask the user for authentication + // credentials if it needs to. + message.AppendArgument(false); + return message.SendSystem() != NULL; +} + +bool CLogindUPowerSyscall::LogindCheckCapability(const char *capability) +{ + char *arg; + CDBusMessage message(LOGIND_DEST, LOGIND_PATH, LOGIND_IFACE, capability); + DBusMessage *reply = message.SendSystem(); + if(reply && dbus_message_get_args(reply, NULL, DBUS_TYPE_STRING, &arg, DBUS_TYPE_INVALID)) + { + // Returns one of "yes", "no" or "challenge". If "challenge" is + // returned the operation is available, but only after authorization. + return (strcmp(arg, "yes") == 0); + } + return false; +} + +int CLogindUPowerSyscall::BatteryLevel() +{ + return m_batteryLevel; +} + +void CLogindUPowerSyscall::UpdateBatteryLevel() +{ + char** source = NULL; + int length = 0; + double batteryLevelSum = 0; + int batteryCount = 0; + + CDBusMessage message("org.freedesktop.UPower", "/org/freedesktop/UPower", "org.freedesktop.UPower", "EnumerateDevices"); + DBusMessage *reply = message.SendSystem(); + + if (!reply) + return; + + if (!dbus_message_get_args(reply, NULL, DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &source, &length, DBUS_TYPE_INVALID)) + { + CLog::Log(LOGWARNING, "LogindUPowerSyscall: failed to enumerate devices"); + return; + } + + for (int i = 0; i < length; i++) + { + CVariant properties = CDBusUtil::GetAll("org.freedesktop.UPower", source[i], "org.freedesktop.UPower.Device"); + bool isRechargeable = properties["IsRechargeable"].asBoolean(); + + if (isRechargeable) + { + batteryCount++; + batteryLevelSum += properties["Percentage"].asDouble(); + } + } + + dbus_free_string_array(source); + + if (batteryCount > 0) + { + m_batteryLevel = (int)(batteryLevelSum / (double)batteryCount); + m_lowBattery = CDBusUtil::GetVariant("org.freedesktop.UPower", "/org/freedesktop/UPower", "org.freedesktop.UPower", "OnLowBattery").asBoolean(); + } +} + +bool CLogindUPowerSyscall::PumpPowerEvents(IPowerEventsCallback *callback) +{ + bool result = false; + bool releaseLockSleep = false; + + if (m_connection) + { + dbus_connection_read_write(m_connection, 0); + DBusMessagePtr msg(dbus_connection_pop_message(m_connection)); + + if (msg) + { + if (dbus_message_is_signal(msg.get(), "org.freedesktop.login1.Manager", "PrepareForSleep")) + { + dbus_bool_t arg; + // the boolean argument defines whether we are going to sleep (true) or just woke up (false) + dbus_message_get_args(msg.get(), NULL, DBUS_TYPE_BOOLEAN, &arg, DBUS_TYPE_INVALID); + CLog::Log(LOGDEBUG, "LogindUPowerSyscall: Received PrepareForSleep with arg {}", (int)arg); + if (arg) + { + callback->OnSleep(); + releaseLockSleep = true; + } + else + { + callback->OnWake(); + InhibitDelayLockSleep(); + } + + result = true; + } + else if (dbus_message_is_signal(msg.get(), "org.freedesktop.UPower", "DeviceChanged")) + { + bool lowBattery = m_lowBattery; + UpdateBatteryLevel(); + if (m_lowBattery && !lowBattery) + callback->OnLowBattery(); + + result = true; + } + else + CLog::Log(LOGDEBUG, "LogindUPowerSyscall - Received unknown signal {}", + dbus_message_get_member(msg.get())); + } + } + + if (releaseLockSleep) + ReleaseDelayLockSleep(); + + return result; +} + +void CLogindUPowerSyscall::InhibitDelayLockSleep() +{ + m_delayLockSleepFd = InhibitDelayLock("sleep"); +} + +void CLogindUPowerSyscall::InhibitDelayLockShutdown() +{ + m_delayLockShutdownFd = InhibitDelayLock("shutdown"); +} + +int CLogindUPowerSyscall::InhibitDelayLock(const char *what) +{ +#ifdef DBUS_TYPE_UNIX_FD + CDBusMessage message("org.freedesktop.login1", "/org/freedesktop/login1", "org.freedesktop.login1.Manager", "Inhibit"); + message.AppendArgument(what); // what to inhibit + message.AppendArgument("XBMC"); // who + message.AppendArgument(""); // reason + message.AppendArgument("delay"); // mode + + DBusMessage *reply = message.SendSystem(); + + if (!reply) + { + CLog::Log(LOGWARNING, "LogindUPowerSyscall - failed to inhibit {} delay lock", what); + return -1; + } + + int delayLockFd; + if (!dbus_message_get_args(reply, NULL, DBUS_TYPE_UNIX_FD, &delayLockFd, DBUS_TYPE_INVALID)) + { + CLog::Log(LOGWARNING, "LogindUPowerSyscall - failed to get inhibit file descriptor"); + return -1; + } + + CLog::Log(LOGDEBUG, "LogindUPowerSyscall - inhibit lock taken, fd {}", delayLockFd); + return delayLockFd; +#else + CLog::Log(LOGWARNING, "LogindUPowerSyscall - inhibit lock support not compiled in"); + return -1; +#endif +} + +void CLogindUPowerSyscall::ReleaseDelayLockSleep() +{ + ReleaseDelayLock(m_delayLockSleepFd, "sleep"); + m_delayLockSleepFd = -1; +} + +void CLogindUPowerSyscall::ReleaseDelayLockShutdown() +{ + ReleaseDelayLock(m_delayLockShutdownFd, "shutdown"); + m_delayLockShutdownFd = -1; +} + +void CLogindUPowerSyscall::ReleaseDelayLock(int lockFd, const char *what) +{ + if (lockFd != -1) + { + close(lockFd); + CLog::Log(LOGDEBUG, "LogindUPowerSyscall - delay lock {} released", what); + } +} diff --git a/xbmc/platform/linux/powermanagement/LogindUPowerSyscall.h b/xbmc/platform/linux/powermanagement/LogindUPowerSyscall.h new file mode 100644 index 0000000..998e706 --- /dev/null +++ b/xbmc/platform/linux/powermanagement/LogindUPowerSyscall.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2012 Denis Yantarev + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "DBusUtil.h" +#include "powermanagement/IPowerSyscall.h" + +class CLogindUPowerSyscall : public CAbstractPowerSyscall +{ +public: + CLogindUPowerSyscall(); + ~CLogindUPowerSyscall() override; + bool Powerdown() override; + bool Suspend() override; + bool Hibernate() override; + bool Reboot() override; + bool CanPowerdown() override; + bool CanSuspend() override; + bool CanHibernate() override; + bool CanReboot() override; + int BatteryLevel() override; + bool PumpPowerEvents(IPowerEventsCallback *callback) override; + // we don't require UPower because everything except the battery level works fine without it + static bool HasLogind(); +private: + CDBusConnection m_connection; + bool m_canPowerdown; + bool m_canSuspend; + bool m_canHibernate; + bool m_canReboot; + bool m_hasUPower; + bool m_lowBattery; + int m_batteryLevel; + int m_delayLockSleepFd = -1; // file descriptor for the logind sleep delay lock + int m_delayLockShutdownFd = -1; // file descriptor for the logind powerdown delay lock + void UpdateBatteryLevel(); + void InhibitDelayLockSleep(); + void InhibitDelayLockShutdown(); + int InhibitDelayLock(const char *what); + void ReleaseDelayLockSleep(); + void ReleaseDelayLockShutdown(); + void ReleaseDelayLock(int lockFd, const char *what); + static bool LogindSetPowerState(const char *state); + static bool LogindCheckCapability(const char *capability); +}; diff --git a/xbmc/platform/linux/powermanagement/UPowerSyscall.cpp b/xbmc/platform/linux/powermanagement/UPowerSyscall.cpp new file mode 100644 index 0000000..27ed2f4 --- /dev/null +++ b/xbmc/platform/linux/powermanagement/UPowerSyscall.cpp @@ -0,0 +1,207 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "UPowerSyscall.h" + +#include "utils/log.h" + +CUPowerSource::CUPowerSource(const char *powerSource) +{ + if(powerSource == NULL) + m_powerSource = ""; + else + m_powerSource = powerSource; + + CVariant properties = CDBusUtil::GetAll("org.freedesktop.UPower", m_powerSource.c_str(), "org.freedesktop.UPower.Device"); + m_isRechargeable = properties["IsRechargeable"].asBoolean(); + Update(); +} + +CUPowerSource::~CUPowerSource() = default; + +void CUPowerSource::Update() +{ + CVariant properties = CDBusUtil::GetAll("org.freedesktop.UPower", m_powerSource.c_str(), "org.freedesktop.UPower.Device"); + m_batteryLevel = properties["Percentage"].asDouble(); +} + +bool CUPowerSource::IsRechargeable() +{ + return m_isRechargeable; +} + +double CUPowerSource::BatteryLevel() +{ + return m_batteryLevel; +} + +CUPowerSyscall::CUPowerSyscall() +{ + CLog::Log(LOGINFO, "Selected UPower as PowerSyscall"); + + m_lowBattery = false; + + //! @todo do not use dbus_connection_pop_message() that requires the use of a + //! private connection + if (m_connection.Connect(DBUS_BUS_SYSTEM, true)) + { + dbus_connection_set_exit_on_disconnect(m_connection, false); + + CDBusError error; + dbus_bus_add_match(m_connection, "type='signal',interface='org.freedesktop.UPower'", error); + dbus_connection_flush(m_connection); + + if (error) + { + error.Log("UPower: Failed to attach to signal"); + m_connection.Destroy(); + } + } + + m_CanPowerdown = false; + m_CanReboot = false; + + UpdateCapabilities(); + + EnumeratePowerSources(); +} + +bool CUPowerSyscall::Powerdown() +{ + return false; +} + +bool CUPowerSyscall::Suspend() +{ + // UPower 0.9.1 does not signal sleeping unless you tell that its about to sleep... + CDBusMessage aboutToSleepMessage("org.freedesktop.UPower", "/org/freedesktop/UPower", "org.freedesktop.UPower", "AboutToSleep"); + aboutToSleepMessage.SendAsyncSystem(); + + CDBusMessage message("org.freedesktop.UPower", "/org/freedesktop/UPower", "org.freedesktop.UPower", "Suspend"); + return message.SendAsyncSystem(); +} + +bool CUPowerSyscall::Hibernate() +{ + // UPower 0.9.1 does not signal sleeping unless you tell that its about to sleep... + CDBusMessage aboutToSleepMessage("org.freedesktop.UPower", "/org/freedesktop/UPower", "org.freedesktop.UPower", "AboutToSleep"); + aboutToSleepMessage.SendAsyncSystem(); + + CDBusMessage message("org.freedesktop.UPower", "/org/freedesktop/UPower", "org.freedesktop.UPower", "Hibernate"); + return message.SendAsyncSystem(); +} + +bool CUPowerSyscall::Reboot() +{ + return false; +} + +bool CUPowerSyscall::CanPowerdown() +{ + return m_CanPowerdown; +} + +bool CUPowerSyscall::CanSuspend() +{ + return m_CanSuspend; +} + +bool CUPowerSyscall::CanHibernate() +{ + return m_CanHibernate; +} + +bool CUPowerSyscall::CanReboot() +{ + return m_CanReboot; +} + +int CUPowerSyscall::BatteryLevel() +{ + unsigned int nBatteryCount = 0; + double subCapacity = 0; + double batteryLevel = 0; + + for (auto& itr : m_powerSources) + { + itr.Update(); + if (itr.IsRechargeable()) + { + nBatteryCount++; + subCapacity += itr.BatteryLevel(); + } + } + + if(nBatteryCount) + batteryLevel = subCapacity / (double)nBatteryCount; + + return (int) batteryLevel; +} + +void CUPowerSyscall::EnumeratePowerSources() +{ + CDBusMessage message("org.freedesktop.UPower", "/org/freedesktop/UPower", "org.freedesktop.UPower", "EnumerateDevices"); + DBusMessage *reply = message.SendSystem(); + if (reply) + { + char** source = NULL; + int length = 0; + + if (dbus_message_get_args (reply, NULL, DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &source, &length, DBUS_TYPE_INVALID)) + { + for (int i = 0; i < length; i++) + { + m_powerSources.emplace_back(source[i]); + } + + dbus_free_string_array(source); + } + } +} + +bool CUPowerSyscall::HasUPower() +{ + return CDBusUtil::TryMethodCall(DBUS_BUS_SYSTEM, "org.freedesktop.UPower", "/org/freedesktop/UPower", "org.freedesktop.UPower", "EnumerateDevices"); +} + +bool CUPowerSyscall::PumpPowerEvents(IPowerEventsCallback *callback) +{ + bool result = false; + + if (m_connection) + { + dbus_connection_read_write(m_connection, 0); + DBusMessagePtr msg(dbus_connection_pop_message(m_connection)); + + if (msg) + { + result = true; + if (dbus_message_is_signal(msg.get(), "org.freedesktop.UPower", "Sleeping")) + callback->OnSleep(); + else if (dbus_message_is_signal(msg.get(), "org.freedesktop.UPower", "Resuming")) + callback->OnWake(); + else if (dbus_message_is_signal(msg.get(), "org.freedesktop.UPower", "Changed")) + { + bool lowBattery = m_lowBattery; + UpdateCapabilities(); + if (m_lowBattery && !lowBattery) + callback->OnLowBattery(); + } + else + CLog::Log(LOGDEBUG, "UPower: Received an unknown signal {}", + dbus_message_get_member(msg.get())); + } + } + return result; +} + +void CUPowerSyscall::UpdateCapabilities() +{ + m_CanSuspend = CDBusUtil::GetVariant("org.freedesktop.UPower", "/org/freedesktop/UPower", "org.freedesktop.UPower", "CanSuspend").asBoolean(false); + m_CanHibernate = CDBusUtil::GetVariant("org.freedesktop.UPower", "/org/freedesktop/UPower", "org.freedesktop.UPower", "CanHibernate").asBoolean(false); +} diff --git a/xbmc/platform/linux/powermanagement/UPowerSyscall.h b/xbmc/platform/linux/powermanagement/UPowerSyscall.h new file mode 100644 index 0000000..aed08d8 --- /dev/null +++ b/xbmc/platform/linux/powermanagement/UPowerSyscall.h @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "DBusUtil.h" +#include "powermanagement/IPowerSyscall.h" + +#include <list> +#include <string> + +class CUPowerSource +{ +public: + CUPowerSource(const char *powerSource); + ~CUPowerSource(); + + void Update(); + bool IsRechargeable(); + double BatteryLevel(); + +private: + std::string m_powerSource; + bool m_isRechargeable; + double m_batteryLevel; +}; + +class CUPowerSyscall : public CAbstractPowerSyscall +{ +public: + CUPowerSyscall(); + bool Powerdown() override; + bool Suspend() override; + bool Hibernate() override; + bool Reboot() override; + bool CanPowerdown() override; + bool CanSuspend() override; + bool CanHibernate() override; + bool CanReboot() override; + int BatteryLevel() override; + bool PumpPowerEvents(IPowerEventsCallback *callback) override; + static bool HasUPower(); +protected: + bool m_CanPowerdown; + bool m_CanSuspend; + bool m_CanHibernate; + bool m_CanReboot; + + void UpdateCapabilities(); +private: + std::list<CUPowerSource> m_powerSources; + CDBusConnection m_connection; + + bool m_lowBattery; + void EnumeratePowerSources(); +}; diff --git a/xbmc/platform/linux/sse4/CMakeLists.txt b/xbmc/platform/linux/sse4/CMakeLists.txt new file mode 100644 index 0000000..6ec73f1 --- /dev/null +++ b/xbmc/platform/linux/sse4/CMakeLists.txt @@ -0,0 +1,8 @@ +if(HAVE_SSE4_1) + set(SOURCES CopyFrame.cpp) + set(HEADERS DllLibSSE4.h) + + core_add_shared_library(sse4) + set_target_properties(sse4 PROPERTIES FOLDER lib) + target_compile_options(sse4 PRIVATE -msse4.1) +endif() diff --git a/xbmc/platform/linux/sse4/CopyFrame.cpp b/xbmc/platform/linux/sse4/CopyFrame.cpp new file mode 100644 index 0000000..2147c3c --- /dev/null +++ b/xbmc/platform/linux/sse4/CopyFrame.cpp @@ -0,0 +1,102 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: LGPL-2.1-or-later + * See LICENSES/README.md for more information. + */ + +#include <smmintrin.h> + +#define CACHED_BUFFER_SIZE 4096 + +extern "C" +{ + +/* + * http://software.intel.com/en-us/articles/copying-accelerated-video-decode-frame-buffers + * COPIES VIDEO FRAMES FROM USWC MEMORY TO WB SYSTEM MEMORY VIA CACHED BUFFER + * ASSUMES PITCH IS A MULTIPLE OF 64B CACHE LINE SIZE, WIDTH MAY NOT BE + */ +void copy_frame( void * pSrc, void * pDest, void * pCacheBlock, + unsigned int width, unsigned int height, unsigned int pitch ) +{ + __m128i x0, x1, x2, x3; + __m128i *pLoad; + __m128i *pStore; + __m128i *pCache; + unsigned int x, y, yLoad, yStore; + unsigned int rowsPerBlock; + unsigned int width64; + unsigned int extraPitch; + + + rowsPerBlock = CACHED_BUFFER_SIZE / pitch; + width64 = (width + 63) & ~0x03f; + extraPitch = (pitch - width64) / 16; + + pLoad = (__m128i *)pSrc; + pStore = (__m128i *)pDest; + + // COPY THROUGH 4KB CACHED BUFFER + for( y = 0; y < height; y += rowsPerBlock ) + { + // ROWS LEFT TO COPY AT END + if( y + rowsPerBlock > height ) + rowsPerBlock = height - y; + + pCache = (__m128i *)pCacheBlock; + + _mm_mfence(); + + // LOAD ROWS OF PITCH WIDTH INTO CACHED BLOCK + for( yLoad = 0; yLoad < rowsPerBlock; yLoad++ ) + { + // COPY A ROW, CACHE LINE AT A TIME + for( x = 0; x < pitch; x +=64 ) + { + x0 = _mm_stream_load_si128( pLoad +0 ); + x1 = _mm_stream_load_si128( pLoad +1 ); + x2 = _mm_stream_load_si128( pLoad +2 ); + x3 = _mm_stream_load_si128( pLoad +3 ); + + _mm_store_si128( pCache +0, x0 ); + _mm_store_si128( pCache +1, x1 ); + _mm_store_si128( pCache +2, x2 ); + _mm_store_si128( pCache +3, x3 ); + + pCache += 4; + pLoad += 4; + } + } + + _mm_mfence(); + + pCache = (__m128i *)pCacheBlock; + + // STORE ROWS OF FRAME WIDTH FROM CACHED BLOCK + for( yStore = 0; yStore < rowsPerBlock; yStore++ ) + { + // copy a row, cache line at a time + for( x = 0; x < width64; x +=64 ) + { + x0 = _mm_load_si128( pCache ); + x1 = _mm_load_si128( pCache +1 ); + x2 = _mm_load_si128( pCache +2 ); + x3 = _mm_load_si128( pCache +3 ); + + _mm_stream_si128( pStore, x0 ); + _mm_stream_si128( pStore +1, x1 ); + _mm_stream_si128( pStore +2, x2 ); + _mm_stream_si128( pStore +3, x3 ); + + pCache += 4; + pStore += 4; + } + + pCache += extraPitch; + pStore += extraPitch; + } + } +} +} diff --git a/xbmc/platform/linux/sse4/DllLibSSE4.h b/xbmc/platform/linux/sse4/DllLibSSE4.h new file mode 100644 index 0000000..a89f713 --- /dev/null +++ b/xbmc/platform/linux/sse4/DllLibSSE4.h @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "DynamicDll.h" + +extern "C" { + +} + +class DllLibSSE4Interface +{ +public: + virtual ~DllLibSSE4Interface() = default; + virtual void copy_frame(void * pSrc, void * pDest, void * pCacheBlock, unsigned int width, unsigned int height, unsigned int pitch) = 0; +}; + +class DllLibSSE4 : public DllDynamic, DllLibSSE4Interface +{ + DECLARE_DLL_WRAPPER(DllLibSSE4, DLL_PATH_LIBSSE4) + DEFINE_METHOD6(void, copy_frame, (void *p1, void *p2, void *p3, unsigned int p4, unsigned int p5, unsigned int p6)) + + BEGIN_METHOD_RESOLVE() + RESOLVE_METHOD(copy_frame) + END_METHOD_RESOLVE() +}; diff --git a/xbmc/platform/linux/storage/CMakeLists.txt b/xbmc/platform/linux/storage/CMakeLists.txt new file mode 100644 index 0000000..223655a --- /dev/null +++ b/xbmc/platform/linux/storage/CMakeLists.txt @@ -0,0 +1,19 @@ +set(SOURCES LinuxStorageProvider.cpp) + +set(HEADERS LinuxStorageProvider.h) + +if(DBUS_FOUND) + list(APPEND SOURCES UDisksProvider.cpp + UDisks2Provider.cpp) + list(APPEND HEADERS UDisksProvider.h + UDisks2Provider.h) +endif() + +if(UDEV_FOUND) + list(APPEND SOURCES UDevProvider.cpp) + list(APPEND HEADERS UDevProvider.h) +endif() + +if(SOURCES) + core_add_library(platform_linux_storage) +endif() diff --git a/xbmc/platform/linux/storage/LinuxStorageProvider.cpp b/xbmc/platform/linux/storage/LinuxStorageProvider.cpp new file mode 100644 index 0000000..6206466 --- /dev/null +++ b/xbmc/platform/linux/storage/LinuxStorageProvider.cpp @@ -0,0 +1,91 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "LinuxStorageProvider.h" +#include "guilib/LocalizeStrings.h" +#include "UDevProvider.h" +#ifdef HAS_DBUS +#include "UDisksProvider.h" +#include "UDisks2Provider.h" +#endif +#include "platform/posix/PosixMountProvider.h" + +std::unique_ptr<IStorageProvider> IStorageProvider::CreateInstance() +{ + return std::make_unique<CLinuxStorageProvider>(); +} + +CLinuxStorageProvider::CLinuxStorageProvider() +{ + m_instance = NULL; + +#ifdef HAS_DBUS + if (CUDisks2Provider::HasUDisks2()) + m_instance = new CUDisks2Provider(); + else if (CUDisksProvider::HasUDisks()) + m_instance = new CUDisksProvider(); +#endif +#ifdef HAVE_LIBUDEV + if (m_instance == NULL) + m_instance = new CUDevProvider(); +#endif + + if (m_instance == NULL) + m_instance = new CPosixMountProvider(); +} + +CLinuxStorageProvider::~CLinuxStorageProvider() +{ + delete m_instance; +} + +void CLinuxStorageProvider::Initialize() +{ + m_instance->Initialize(); +} + +void CLinuxStorageProvider::Stop() +{ + m_instance->Stop(); +} + +void CLinuxStorageProvider::GetLocalDrives(VECSOURCES &localDrives) +{ + // Home directory + CMediaSource share; + share.strPath = getenv("HOME"); + share.strName = g_localizeStrings.Get(21440); + share.m_ignore = true; + share.m_iDriveType = CMediaSource::SOURCE_TYPE_LOCAL; + localDrives.push_back(share); + share.strPath = "/"; + share.strName = g_localizeStrings.Get(21453); + localDrives.push_back(share); + + m_instance->GetLocalDrives(localDrives); +} + +void CLinuxStorageProvider::GetRemovableDrives(VECSOURCES &removableDrives) +{ + m_instance->GetRemovableDrives(removableDrives); +} + +bool CLinuxStorageProvider::Eject(const std::string& mountpath) +{ + return m_instance->Eject(mountpath); +} + +std::vector<std::string> CLinuxStorageProvider::GetDiskUsage() +{ + return m_instance->GetDiskUsage(); +} + +bool CLinuxStorageProvider::PumpDriveChangeEvents(IStorageEventsCallback *callback) +{ + return m_instance->PumpDriveChangeEvents(callback); +} diff --git a/xbmc/platform/linux/storage/LinuxStorageProvider.h b/xbmc/platform/linux/storage/LinuxStorageProvider.h new file mode 100644 index 0000000..e1c575f --- /dev/null +++ b/xbmc/platform/linux/storage/LinuxStorageProvider.h @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "storage/IStorageProvider.h" + +#include <vector> + +class CLinuxStorageProvider : public IStorageProvider +{ +public: + CLinuxStorageProvider(); + ~CLinuxStorageProvider() override; + + void Initialize() override; + void Stop() override; + void GetLocalDrives(VECSOURCES &localDrives) override; + void GetRemovableDrives(VECSOURCES &removableDrives) override; + bool Eject(const std::string& mountpath) override; + std::vector<std::string> GetDiskUsage() override; + bool PumpDriveChangeEvents(IStorageEventsCallback *callback) override; + +private: + IStorageProvider *m_instance; +}; diff --git a/xbmc/platform/linux/storage/UDevProvider.cpp b/xbmc/platform/linux/storage/UDevProvider.cpp new file mode 100644 index 0000000..7123e87 --- /dev/null +++ b/xbmc/platform/linux/storage/UDevProvider.cpp @@ -0,0 +1,298 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "UDevProvider.h" + +#include "platform/posix/PosixMountProvider.h" +#include "utils/log.h" +#include "utils/URIUtils.h" + +extern "C" { +#include <libudev.h> +#include <poll.h> +} + +static const char *get_mountpoint(const char *devnode) +{ + static char buf[4096]; + const char *delim = " "; + const char *mountpoint = nullptr; + FILE *fp = fopen("/proc/mounts", "r"); + if (!fp) + return nullptr; + + while (fgets(buf, sizeof (buf), fp)) + { + const char *node = strtok(buf, delim); + if (strcmp(node, devnode) == 0) + { + mountpoint = strtok(nullptr, delim); + break; + } + } + + if (mountpoint) + { + // If mount point contain characters like space, it is converted to + // "\040". This situation should be handled. + char *c1, *c2; + for (c1 = c2 = const_cast<char*>(mountpoint); *c2; ++c1) + { + if (*c2 == '\\') + { + *c1 = (((c2[1] - '0') << 6) | ((c2[2] - '0') << 3) | (c2[3] - '0')); + c2 += 4; + continue; + } + if (c1 != c2) + *c1 = *c2; + ++c2; + } + *c1 = *c2; + } + + fclose(fp); + return mountpoint; +} + +CUDevProvider::CUDevProvider() +{ + m_udev = nullptr; + m_udevMon = nullptr; +} + +void CUDevProvider::Initialize() +{ + CLog::Log(LOGDEBUG, "Selected UDev as storage provider"); + + m_udev = udev_new(); + if (!m_udev) + { + CLog::Log(LOGERROR, "{} - failed to allocate udev context", __FUNCTION__); + return; + } + /* set up a devices monitor that listen for any device change */ + m_udevMon = udev_monitor_new_from_netlink(m_udev, "udev"); + udev_monitor_filter_add_match_subsystem_devtype(m_udevMon, "block", "disk"); + udev_monitor_filter_add_match_subsystem_devtype(m_udevMon, "block", "partition"); + udev_monitor_enable_receiving(m_udevMon); + + PumpDriveChangeEvents(nullptr); +} + +void CUDevProvider::Stop() +{ + udev_monitor_unref(m_udevMon); + udev_unref(m_udev); +} + +void CUDevProvider::GetDisks(VECSOURCES& disks, bool removable) +{ + // enumerate existing block devices + struct udev_enumerate *u_enum = udev_enumerate_new(m_udev); + if (!u_enum) + { + fprintf(stderr, "Error: udev_enumerate_new(udev)\n"); + return; + } + + udev_enumerate_add_match_subsystem(u_enum, "block"); + udev_enumerate_add_match_property(u_enum, "DEVTYPE", "disk"); + udev_enumerate_add_match_property(u_enum, "DEVTYPE", "partition"); + udev_enumerate_scan_devices(u_enum); + + struct udev_list_entry *u_list_ent; + struct udev_list_entry *u_first_list_ent; + u_first_list_ent = udev_enumerate_get_list_entry(u_enum); + udev_list_entry_foreach(u_list_ent, u_first_list_ent) + { + const char *name = udev_list_entry_get_name(u_list_ent); + struct udev *context = udev_enumerate_get_udev(u_enum); + struct udev_device *device = udev_device_new_from_syspath(context, name); + if (!device) + continue; + + // filter out devices without devnode + const char* devnode = udev_device_get_devnode(device); + if (!devnode) + { + udev_device_unref(device); + continue; + } + + // filter out devices that are not mounted + const char* mountpoint = get_mountpoint(devnode); + if (!mountpoint) + { + udev_device_unref(device); + continue; + } + + // filter out root partition + if (strcmp(mountpoint, "/") == 0) + { + udev_device_unref(device); + continue; + } + + // filter out things mounted on /tmp + if (strstr(mountpoint, "/tmp")) + { + udev_device_unref(device); + continue; + } + + // look for devices on the usb bus, or mounted on */media/ (sdcards), or optical devices + const char *bus = udev_device_get_property_value(device, "ID_BUS"); + const char *optical = udev_device_get_property_value(device, "ID_CDROM"); // matches also DVD, Blu-ray + bool isRemovable = ((bus && strstr(bus, "usb")) || + (optical && strstr(optical,"1")) || + (mountpoint && strstr(mountpoint, "/media/"))); + + // filter according to requested device type + if (removable != isRemovable) + { + udev_device_unref(device); + continue; + } + + const char *udev_label = udev_device_get_property_value(device, "ID_FS_LABEL"); + std::string label; + if (udev_label) + label = udev_label; + else + label = URIUtils::GetFileName(mountpoint); + + CMediaSource share; + share.strName = label; + share.strPath = mountpoint; + share.m_ignore = true; + if (isRemovable) + { + if (optical) + share.m_iDriveType = CMediaSource::SOURCE_TYPE_DVD; + else + share.m_iDriveType = CMediaSource::SOURCE_TYPE_REMOVABLE; + } + else + share.m_iDriveType = CMediaSource::SOURCE_TYPE_LOCAL; + + disks.push_back(share); + udev_device_unref(device); + } + udev_enumerate_unref(u_enum); +} + +void CUDevProvider::GetLocalDrives(VECSOURCES &localDrives) +{ + GetDisks(localDrives, false); +} + +void CUDevProvider::GetRemovableDrives(VECSOURCES &removableDrives) +{ + GetDisks(removableDrives, true); +} + +bool CUDevProvider::Eject(const std::string& mountpath) +{ + // just go ahead and try to umount the disk + // if it does umount, life is good, if not, no loss. + std::string cmd = "umount \"" + mountpath + "\""; + int status = system(cmd.c_str()); + + if (status == 0) + return true; + + return false; +} + +std::vector<std::string> CUDevProvider::GetDiskUsage() +{ + CPosixMountProvider legacy; + return legacy.GetDiskUsage(); +} + +bool CUDevProvider::PumpDriveChangeEvents(IStorageEventsCallback *callback) +{ + bool changed = false; + + fd_set readfds; + FD_ZERO(&readfds); + FD_SET(udev_monitor_get_fd(m_udevMon), &readfds); + + // non-blocking, check the file descriptor for received data + struct timeval tv = {}; + int count = select(udev_monitor_get_fd(m_udevMon) + 1, &readfds, nullptr, nullptr, &tv); + if (count < 0) + return false; + + if (FD_ISSET(udev_monitor_get_fd(m_udevMon), &readfds)) + { + struct udev_device* dev = udev_monitor_receive_device(m_udevMon); + if (!dev) + return false; + + const char* action = udev_device_get_action(dev); + const char* devnode = udev_device_get_devnode(dev); + if (action && devnode) + { + MEDIA_DETECT::STORAGE::StorageDevice storageDevice; + const char *udev_label = udev_device_get_property_value(dev, "ID_FS_LABEL"); + const char* mountpoint = get_mountpoint(devnode); + if (udev_label) + storageDevice.label = udev_label; + else if (mountpoint) + { + storageDevice.label = URIUtils::GetFileName(mountpoint); + storageDevice.path = mountpoint; + } + + const char *fs_usage = udev_device_get_property_value(dev, "ID_FS_USAGE"); + if (mountpoint && strcmp(action, "add") == 0 && (fs_usage && strcmp(fs_usage, "filesystem") == 0)) + { + CLog::Log(LOGINFO, "UDev: Added {}", mountpoint); + if (callback) + callback->OnStorageAdded(storageDevice); + changed = true; + } + if (strcmp(action, "remove") == 0 && (fs_usage && strcmp(fs_usage, "filesystem") == 0)) + { + if (callback) + callback->OnStorageSafelyRemoved(storageDevice); + changed = true; + } + // browse disk dialog is not wanted for blu-rays + const char *bd = udev_device_get_property_value(dev, "ID_CDROM_MEDIA_BD"); + if (strcmp(action, "change") == 0 && !(bd && strcmp(bd, "1") == 0)) + { + const char *optical = udev_device_get_property_value(dev, "ID_CDROM"); + bool isOptical = optical && (strcmp(optical, "1") != 0); + storageDevice.type = + isOptical ? MEDIA_DETECT::STORAGE::Type::OPTICAL : MEDIA_DETECT::STORAGE::Type::UNKNOWN; + + if (mountpoint && !isOptical) + { + CLog::Log(LOGINFO, "UDev: Changed / Added {}", mountpoint); + if (callback) + callback->OnStorageAdded(storageDevice); + changed = true; + } + const char *eject_request = udev_device_get_property_value(dev, "DISK_EJECT_REQUEST"); + if (eject_request && strcmp(eject_request, "1") == 0) + { + if (callback) + callback->OnStorageSafelyRemoved(storageDevice); + changed = true; + } + } + } + udev_device_unref(dev); + } + + return changed; +} diff --git a/xbmc/platform/linux/storage/UDevProvider.h b/xbmc/platform/linux/storage/UDevProvider.h new file mode 100644 index 0000000..a4c83b3 --- /dev/null +++ b/xbmc/platform/linux/storage/UDevProvider.h @@ -0,0 +1,42 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "storage/IStorageProvider.h" + +#include <string> +#include <vector> + +struct udev; +struct udev_monitor; + +class CUDevProvider : public IStorageProvider +{ +public: + CUDevProvider(); + ~CUDevProvider() override = default; + + void Initialize() override; + void Stop() override; + + void GetLocalDrives(VECSOURCES &localDrives) override; + void GetRemovableDrives(VECSOURCES &removableDrives) override; + + bool Eject(const std::string& mountpath) override; + + std::vector<std::string> GetDiskUsage() override; + + bool PumpDriveChangeEvents(IStorageEventsCallback *callback) override; + +private: + void GetDisks(VECSOURCES& devices, bool removable); + + struct udev *m_udev; + struct udev_monitor *m_udevMon; +}; diff --git a/xbmc/platform/linux/storage/UDisks2Provider.cpp b/xbmc/platform/linux/storage/UDisks2Provider.cpp new file mode 100644 index 0000000..b3431c7 --- /dev/null +++ b/xbmc/platform/linux/storage/UDisks2Provider.cpp @@ -0,0 +1,861 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ +#include "UDisks2Provider.h" + +#include "ServiceBroker.h" +#include "guilib/LocalizeStrings.h" +#include "settings/AdvancedSettings.h" +#include "settings/SettingsComponent.h" +#include "utils/StringUtils.h" +#include "utils/URIUtils.h" +#include "utils/log.h" + +#include "platform/posix/PosixMountProvider.h" + +#include <algorithm> +#include <functional> + +#define BOOL2SZ(b) ((b) ? "true" : "false") + +#define DBUS_INTERFACE_OBJECT_MANAGER "org.freedesktop.DBus.ObjectManager" + +#define UDISKS2_SERVICE_UDISKS2 "org.freedesktop.UDisks2" + +#define UDISKS2_PATH_MANAGER "/org/freedesktop/UDisks2/Manager" +#define UDISKS2_PATH_UDISKS2 "/org/freedesktop/UDisks2" + +#define UDISKS2_INTERFACE_BLOCK "org.freedesktop.UDisks2.Block" +#define UDISKS2_INTERFACE_DRIVE "org.freedesktop.UDisks2.Drive" +#define UDISKS2_INTERFACE_FILESYSTEM "org.freedesktop.UDisks2.Filesystem" +#define UDISKS2_INTERFACE_MANAGER "org.freedesktop.UDisks2.Manager" + +#define UDISKS2_MATCH_RULE "type='signal',sender='" UDISKS2_SERVICE_UDISKS2 "',path_namespace='" UDISKS2_PATH_UDISKS2 "'" + +CUDisks2Provider::Drive::Drive(const char *object) : m_object(object) +{ +} + +bool CUDisks2Provider::Drive::IsOptical() const +{ + return std::any_of(m_mediaCompatibility.begin(), m_mediaCompatibility.end(), + [](const std::string& kind) { return kind.compare(0, 7, "optical") == 0; }); +} + +std::string CUDisks2Provider::Drive::ToString() const +{ + return StringUtils::Format("Drive {}: IsRemovable {} IsOptical {}", m_object, + BOOL2SZ(m_isRemovable), BOOL2SZ(IsOptical())); +} + +CUDisks2Provider::Block::Block(const char *object) : m_object(object) +{ +} + +bool CUDisks2Provider::Block::IsReady() +{ + return m_drive != nullptr; +} + +std::string CUDisks2Provider::Block::ToString() const +{ + return StringUtils::Format("Block device {}: Device {} Label {} IsSystem: {} Drive {}", m_object, + m_device, m_label.empty() ? "none" : m_label, BOOL2SZ(m_isSystem), + m_driveobject.empty() ? "none" : m_driveobject); +} + +CUDisks2Provider::Filesystem::Filesystem(const char *object) : m_object(object) +{ +} + +std::string CUDisks2Provider::Filesystem::ToString() const +{ + return StringUtils::Format("Filesystem {}: IsMounted {} MountPoint {}", m_object, + BOOL2SZ(m_isMounted), m_mountPoint.empty() ? "none" : m_mountPoint); +} + +MEDIA_DETECT::STORAGE::StorageDevice CUDisks2Provider::Filesystem::ToStorageDevice() const +{ + MEDIA_DETECT::STORAGE::StorageDevice device; + device.label = GetDisplayName(); + device.path = GetMountPoint(); + device.type = GetStorageType(); + return device; +} + +bool CUDisks2Provider::Filesystem::IsReady() const +{ + return m_block != nullptr && m_block->IsReady(); +} + +bool CUDisks2Provider::Filesystem::IsOptical() const +{ + return m_block->m_drive->IsOptical(); +} + +MEDIA_DETECT::STORAGE::Type CUDisks2Provider::Filesystem::GetStorageType() const +{ + if (m_block == nullptr || !m_block->IsReady()) + return MEDIA_DETECT::STORAGE::Type::UNKNOWN; + + if (IsOptical()) + return MEDIA_DETECT::STORAGE::Type::OPTICAL; + + return MEDIA_DETECT::STORAGE::Type::UNKNOWN; +} + +std::string CUDisks2Provider::Filesystem::GetMountPoint() const +{ + return m_mountPoint; +} + +std::string CUDisks2Provider::Filesystem::GetObject() const +{ + return m_object; +} + +void CUDisks2Provider::Filesystem::ResetMountPoint() +{ + m_mountPoint.clear(); + m_isMounted = false; +} + +void CUDisks2Provider::Filesystem::SetMountPoint(const std::string& mountPoint) +{ + m_mountPoint = mountPoint; + m_isMounted = true; +} + +bool CUDisks2Provider::Filesystem::IsMounted() const +{ + return m_isMounted; +} + +bool CUDisks2Provider::Filesystem::Mount() +{ + if (m_block->m_isSystem) { + CLog::Log(LOGDEBUG, "UDisks2: Skip mount of system device {}", ToString()); + return false; + } + else if (m_isMounted) + { + CLog::Log(LOGDEBUG, "UDisks2: Skip mount of already mounted device {}", ToString()); + return false; + } + else + { + CLog::Log(LOGDEBUG, "UDisks2: Mounting {}", m_block->m_device); + CDBusMessage message(UDISKS2_SERVICE_UDISKS2, m_object, UDISKS2_INTERFACE_FILESYSTEM, "Mount"); + AppendEmptyOptions(message.GetArgumentIter()); + DBusMessage *reply = message.SendSystem(); + return (reply && dbus_message_get_type(reply) != DBUS_MESSAGE_TYPE_ERROR); + } +} + +bool CUDisks2Provider::Filesystem::Unmount() +{ + if (m_block->m_isSystem) { + CLog::Log(LOGDEBUG, "UDisks2: Skip unmount of system device {}", ToString()); + return false; + } + else if (!m_isMounted) + { + CLog::Log(LOGDEBUG, "UDisks2: Skip unmount of not mounted device {}", ToString()); + return false; + } + else + { + CLog::Log(LOGDEBUG, "UDisks2: Unmounting {}", m_block->m_device); + CDBusMessage message(UDISKS2_SERVICE_UDISKS2, m_object, UDISKS2_INTERFACE_FILESYSTEM, "Unmount"); + AppendEmptyOptions(message.GetArgumentIter()); + DBusMessage *reply = message.SendSystem(); + return (reply && dbus_message_get_type(reply) != DBUS_MESSAGE_TYPE_ERROR); + } +} + +std::string CUDisks2Provider::Filesystem::GetDisplayName() const +{ + if (m_block->m_label.empty()) + { + std::string strSize = StringUtils::SizeToString(m_block->m_size); + return StringUtils::Format("{} {}", strSize, g_localizeStrings.Get(155)); + } + else + return m_block->m_label; +} + +CMediaSource CUDisks2Provider::Filesystem::ToMediaShare() const +{ + CMediaSource source; + source.strPath = m_mountPoint; + source.strName = GetDisplayName(); + if (IsOptical()) + source.m_iDriveType = CMediaSource::SOURCE_TYPE_DVD; + else if (m_block->m_isSystem) + source.m_iDriveType = CMediaSource::SOURCE_TYPE_LOCAL; + else + source.m_iDriveType = CMediaSource::SOURCE_TYPE_REMOVABLE; + source.m_ignore = true; + return source; +} + +bool CUDisks2Provider::Filesystem::IsApproved() const +{ + return IsReady() && + (m_isMounted && m_mountPoint != "/" && m_mountPoint != "/boot" && m_mountPoint.compare(0, 6, "/boot/") != 0) /*|| + m_block->m_drive->m_isOptical*/; +} + +CUDisks2Provider::CUDisks2Provider() +{ + if (!m_connection.Connect(DBUS_BUS_SYSTEM, true)) + { + return; + } + + dbus_connection_set_exit_on_disconnect(m_connection, static_cast<dbus_bool_t>(false)); + + CDBusError error; + dbus_bus_add_match(m_connection, UDISKS2_MATCH_RULE, error); + dbus_connection_flush(m_connection); + + if (error) + { + error.Log("UDisks2: Failed to attach to signal"); + m_connection.Destroy(); + } +} + +CUDisks2Provider::~CUDisks2Provider() +{ + for (auto &elt : m_filesystems) + { + delete elt.second; + } + m_filesystems.clear(); + + for (auto &elt : m_blocks) + { + delete elt.second; + } + m_blocks.clear(); + + for (auto &elt : m_drives) + { + delete elt.second; + } + m_drives.clear(); +} + +void CUDisks2Provider::Initialize() +{ + CLog::Log(LOGDEBUG, "Selected UDisks2 as storage provider"); + m_daemonVersion = CDBusUtil::GetVariant(UDISKS2_SERVICE_UDISKS2, UDISKS2_PATH_MANAGER, UDISKS2_INTERFACE_MANAGER, + "Version").asString(); + CLog::Log(LOGDEBUG, "UDisks2: Daemon version {}", m_daemonVersion); + + CLog::Log(LOGDEBUG, "UDisks2: Querying available devices"); + CDBusMessage message(UDISKS2_SERVICE_UDISKS2, UDISKS2_PATH_UDISKS2, DBUS_INTERFACE_OBJECT_MANAGER, + "GetManagedObjects"); + DBusMessage *reply = message.SendSystem(); + + if (reply && dbus_message_get_type(reply) != DBUS_MESSAGE_TYPE_ERROR) + { + HandleManagedObjects(reply); + } +} + +bool CUDisks2Provider::PumpDriveChangeEvents(IStorageEventsCallback *callback) +{ + if (m_connection) + { + dbus_connection_read_write(m_connection, 0); + DBusMessagePtr msg(dbus_connection_pop_message(m_connection)); + + if (msg) + { + CLog::Log(LOGDEBUG, LOGDBUS, "UDisks2: Message received (interface: {}, member: {})", + dbus_message_get_interface(msg.get()), dbus_message_get_member(msg.get())); + + if (dbus_message_is_signal(msg.get(), DBUS_INTERFACE_OBJECT_MANAGER, "InterfacesAdded")) + { + HandleInterfacesAdded(msg.get()); + return false; + } + else if (dbus_message_is_signal(msg.get(), DBUS_INTERFACE_OBJECT_MANAGER, "InterfacesRemoved")) + { + return HandleInterfacesRemoved(msg.get(), callback); + } + else if (dbus_message_is_signal(msg.get(), DBUS_INTERFACE_PROPERTIES, "PropertiesChanged")) + { + return HandlePropertiesChanged(msg.get(), callback); + } + } + } + return false; +} + +bool CUDisks2Provider::HasUDisks2() +{ + return CDBusUtil::TryMethodCall(DBUS_BUS_SYSTEM, UDISKS2_SERVICE_UDISKS2, UDISKS2_PATH_UDISKS2, DBUS_INTERFACE_PEER, + "Ping"); +} + +bool CUDisks2Provider::Eject(const std::string &mountpath) +{ + std::string path(mountpath); + URIUtils::RemoveSlashAtEnd(path); + + for (const auto &elt: m_filesystems) + { + Filesystem *fs = elt.second; + if (fs->GetMountPoint() == path) + { + return fs->Unmount(); + } + } + + return false; +} + +std::vector<std::string> CUDisks2Provider::GetDiskUsage() +{ + CPosixMountProvider legacy; + return legacy.GetDiskUsage(); +} + +void CUDisks2Provider::GetDisks(VECSOURCES &devices, bool enumerateRemovable) +{ + for (const auto &elt: m_filesystems) + { + Filesystem *fs = elt.second; + if (fs->IsApproved() && fs->m_block->m_isSystem != enumerateRemovable) + devices.push_back(fs->ToMediaShare()); + } +} + +void CUDisks2Provider::DriveAdded(Drive *drive) +{ + CLog::Log(LOGDEBUG, LOGDBUS, "UDisks2: Drive added - {}", drive->ToString()); + + if (m_drives[drive->m_object]) + { + CLog::Log(LOGWARNING, "UDisks2: Inconsistency found! DriveAdded on an indexed drive"); + delete m_drives[drive->m_object]; + } + + m_drives[drive->m_object] = drive; + + for (auto &elt: m_blocks) + { + auto block = elt.second; + if (block->m_driveobject == drive->m_object) + { + block->m_drive = drive; + BlockAdded(block, false); + } + } +} + +bool CUDisks2Provider::DriveRemoved(const std::string& object) +{ + CLog::Log(LOGDEBUG, LOGDBUS, "UDisks2: Drive removed ({})", object); + + if (m_drives.count(object) > 0) + { + delete m_drives[object]; + m_drives.erase(object); + } + + for (auto &elt: m_blocks) + { + auto block = elt.second; + if (block->m_driveobject == object) + { + block->m_drive = nullptr; + } + } + + return false; +} + +void CUDisks2Provider::BlockAdded(Block *block, bool isNew) +{ + if (isNew) + { + CLog::Log(LOGDEBUG, LOGDBUS, "UDisks2: Block added - {}", block->ToString()); + + if (m_drives.count(block->m_driveobject) > 0) + block->m_drive = m_drives[block->m_driveobject]; + + if (m_blocks[block->m_object]) + { + CLog::Log(LOGWARNING, "UDisks2: Inconsistency found! BlockAdded on an indexed block device"); + delete m_blocks[block->m_object]; + } + + m_blocks[block->m_object] = block; + } + + + if (m_filesystems.count(block->m_object) > 0) + { + auto fs = m_filesystems[block->m_object]; + fs->m_block = block; + FilesystemAdded(fs, false); + } +} + +bool CUDisks2Provider::BlockRemoved(const std::string& object) +{ + CLog::Log(LOGDEBUG, LOGDBUS, "UDisks2: Block removed ({})", object); + + if (m_blocks.count(object) > 0) + { + delete m_blocks[object]; + m_blocks.erase(object); + } + + if (m_filesystems.count(object) > 0) + { + m_filesystems[object]->m_block = nullptr; + } + + return false; +} + +void CUDisks2Provider::FilesystemAdded(Filesystem *fs, bool isNew) +{ + if (isNew) + { + CLog::Log(LOGDEBUG, LOGDBUS, "UDisks2: Filesystem added - {}", fs->ToString()); + + if (m_blocks.count(fs->GetObject()) > 0) + fs->m_block = m_blocks[fs->GetObject()]; + + if (m_filesystems[fs->GetObject()]) + { + CLog::Log(LOGWARNING, "UDisks2: Inconsistency found! FilesystemAdded on an indexed filesystem"); + delete m_filesystems[fs->GetObject()]; + } + + m_filesystems[fs->GetObject()] = fs; + } + + if (fs->IsReady() && !fs->IsMounted()) + { + // optical drives should be always mounted by default unless explicitly disabled by the user + if (CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_handleMounting || + (fs->IsOptical() && + CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_autoMountOpticalMedia)) + { + fs->Mount(); + } + } +} + +bool CUDisks2Provider::FilesystemRemoved(const char *object, IStorageEventsCallback *callback) +{ + CLog::Log(LOGDEBUG, LOGDBUS, "UDisks2: Filesystem removed ({})", object); + bool result = false; + if (m_filesystems.count(object) > 0) + { + auto fs = m_filesystems[object]; + if (fs->IsMounted()) + { + callback->OnStorageUnsafelyRemoved(fs->ToStorageDevice()); + result = true; + } + delete m_filesystems[object]; + m_filesystems.erase(object); + } + return result; +} + +void CUDisks2Provider::HandleManagedObjects(DBusMessage *msg) +{ + DBusMessageIter msgIter, dictIter; + dbus_message_iter_init(msg, &msgIter); + dbus_message_iter_recurse(&msgIter, &dictIter); + while (dbus_message_iter_get_arg_type(&dictIter) == DBUS_TYPE_DICT_ENTRY) + { + DBusMessageIter objIter; + dbus_message_iter_recurse(&dictIter, &objIter); + ParseInterfaces(&objIter); + dbus_message_iter_next(&dictIter); + } +} + +void CUDisks2Provider::HandleInterfacesAdded(DBusMessage *msg) +{ + DBusMessageIter msgIter; + dbus_message_iter_init(msg, &msgIter); + ParseInterfaces(&msgIter); +} + +bool CUDisks2Provider::HandleInterfacesRemoved(DBusMessage *msg, IStorageEventsCallback *callback) +{ + DBusMessageIter msgIter, ifaceIter; + const char *path, *iface; + bool result = false; + dbus_message_iter_init(msg, &msgIter); + dbus_message_iter_get_basic(&msgIter, &path); + dbus_message_iter_next(&msgIter); + dbus_message_iter_recurse(&msgIter, &ifaceIter); + while (dbus_message_iter_get_arg_type(&ifaceIter) == DBUS_TYPE_STRING) + { + dbus_message_iter_get_basic(&ifaceIter, &iface); + result |= RemoveInterface(path, iface, callback); + dbus_message_iter_next(&ifaceIter); + } + return result; +} + +bool CUDisks2Provider::HandlePropertiesChanged(DBusMessage *msg, IStorageEventsCallback *callback) +{ + DBusMessageIter msgIter, propsIter; + const char *object = dbus_message_get_path(msg); + const char *iface; + + dbus_message_iter_init(msg, &msgIter); + dbus_message_iter_get_basic(&msgIter, &iface); + dbus_message_iter_next(&msgIter); + dbus_message_iter_recurse(&msgIter, &propsIter); + + if (strcmp(iface, UDISKS2_INTERFACE_DRIVE) == 0) + { + return DrivePropertiesChanged(object, &propsIter); + } + else if (strcmp(iface, UDISKS2_INTERFACE_BLOCK) == 0) + { + return BlockPropertiesChanged(object, &propsIter); + } + else if (strcmp(iface, UDISKS2_INTERFACE_FILESYSTEM) == 0) + { + return FilesystemPropertiesChanged(object, &propsIter, callback); + } + + return false; +} + +bool CUDisks2Provider::DrivePropertiesChanged(const char *object, DBusMessageIter *propsIter) +{ + if (m_drives.count(object) > 0) + { + auto drive = m_drives[object]; + CLog::Log(LOGDEBUG, LOGDBUS, "UDisks2: Before update: {}", drive->ToString()); + auto ParseDriveProperty = std::bind(&CUDisks2Provider::ParseDriveProperty, this, std::placeholders::_1, + std::placeholders::_2, std::placeholders::_3); + ParseProperties(drive, propsIter, ParseDriveProperty); + CLog::Log(LOGDEBUG, LOGDBUS, "UDisks2: After update: {}", drive->ToString()); + } + return false; +} + +bool CUDisks2Provider::BlockPropertiesChanged(const char *object, DBusMessageIter *propsIter) +{ + if (m_blocks.count(object) > 0) + { + auto block = m_blocks[object]; + CLog::Log(LOGDEBUG, LOGDBUS, "UDisks2: Before update: {}", block->ToString()); + auto ParseBlockProperty = std::bind(&CUDisks2Provider::ParseBlockProperty, this, std::placeholders::_1, + std::placeholders::_2, std::placeholders::_3); + ParseProperties(block, propsIter, ParseBlockProperty); + CLog::Log(LOGDEBUG, LOGDBUS, "UDisks2: After update: {}", block->ToString()); + } + return false; +} + +bool CUDisks2Provider::FilesystemPropertiesChanged(const char *object, DBusMessageIter *propsIter, IStorageEventsCallback *callback) +{ + if (m_filesystems.count(object) > 0) + { + auto fs = m_filesystems[object]; + CLog::Log(LOGDEBUG, LOGDBUS, "UDisks2: Before update: {}", fs->ToString()); + bool wasMounted = fs->IsMounted(); + auto ParseFilesystemProperty = std::bind(&CUDisks2Provider::ParseFilesystemProperty, this, + std::placeholders::_1, + std::placeholders::_2, std::placeholders::_3); + ParseProperties(fs, propsIter, ParseFilesystemProperty); + CLog::Log(LOGDEBUG, LOGDBUS, "UDisks2: After update: {}", fs->ToString()); + + if (!wasMounted && fs->IsMounted() && fs->IsApproved()) + { + CLog::Log(LOGINFO, "UDisks2: Added {}", fs->GetMountPoint()); + if (callback) + callback->OnStorageAdded(fs->ToStorageDevice()); + return true; + } + else if (wasMounted && !fs->IsMounted()) + { + CLog::Log(LOGINFO, "UDisks2: Removed {}", fs->m_block->m_device); + if (callback) + callback->OnStorageSafelyRemoved(fs->ToStorageDevice()); + return true; + } + } + return false; +} + +bool CUDisks2Provider::RemoveInterface(const char *path, const char *iface, IStorageEventsCallback *callback) +{ + if (strcmp(iface, UDISKS2_INTERFACE_DRIVE) == 0) + { + return DriveRemoved(path); + } + else if (strcmp(iface, UDISKS2_INTERFACE_BLOCK) == 0) + { + return BlockRemoved(path); + } + else if (strcmp(iface, UDISKS2_INTERFACE_FILESYSTEM) == 0) + { + return FilesystemRemoved(path, callback); + } + else + { + return false; + } +} + + +void CUDisks2Provider::ParseInterfaces(DBusMessageIter *objIter) +{ + DBusMessageIter dictIter; + const char *object; + dbus_message_iter_get_basic(objIter, &object); + dbus_message_iter_next(objIter); + dbus_message_iter_recurse(objIter, &dictIter); + while (dbus_message_iter_get_arg_type(&dictIter) == DBUS_TYPE_DICT_ENTRY) + { + DBusMessageIter ifaceIter, propsIter; + const char *iface; + dbus_message_iter_recurse(&dictIter, &ifaceIter); + dbus_message_iter_get_basic(&ifaceIter, &iface); + dbus_message_iter_next(&ifaceIter); + dbus_message_iter_recurse(&ifaceIter, &propsIter); + ParseInterface(object, iface, &propsIter/*, &discovery*/); + dbus_message_iter_next(&dictIter); + } +} + +void CUDisks2Provider::ParseInterface(const char *object, const char *iface, DBusMessageIter *propsIter) +{ + if (strcmp(iface, UDISKS2_INTERFACE_DRIVE) == 0) + { + auto *drive = new Drive(object); + auto f = std::bind(&CUDisks2Provider::ParseDriveProperty, this, std::placeholders::_1, + std::placeholders::_2, std::placeholders::_3); + ParseProperties(drive, propsIter, f); + DriveAdded(drive); + } + else if (strcmp(iface, UDISKS2_INTERFACE_BLOCK) == 0) + { + auto *block = new Block(object); + auto f = std::bind(&CUDisks2Provider::ParseBlockProperty, this, std::placeholders::_1, + std::placeholders::_2, std::placeholders::_3); + ParseProperties(block, propsIter, f); + BlockAdded(block); + } + else if (strcmp(iface, UDISKS2_INTERFACE_FILESYSTEM) == 0) + { + auto *fs = new Filesystem(object); + auto f = std::bind(&CUDisks2Provider::ParseFilesystemProperty, this, std::placeholders::_1, + std::placeholders::_2, std::placeholders::_3); + ParseProperties(fs, propsIter, f); + FilesystemAdded(fs); + } +} + + +template<class Object, class Function> +void CUDisks2Provider::ParseProperties(Object *ref, DBusMessageIter *propsIter, Function f) +{ + while (dbus_message_iter_get_arg_type(propsIter) == DBUS_TYPE_DICT_ENTRY) + { + DBusMessageIter propIter, varIter; + const char *key; + + dbus_message_iter_recurse(propsIter, &propIter); + + dbus_message_iter_get_basic(&propIter, &key); + dbus_message_iter_next(&propIter); + + dbus_message_iter_recurse(&propIter, &varIter); + + f(ref, key, &varIter); + + dbus_message_iter_next(propsIter); + } + +} + +void CUDisks2Provider::ParseDriveProperty(Drive *drive, const char *key, DBusMessageIter *varIter) +{ + switch (dbus_message_iter_get_arg_type(varIter)) + { + case DBUS_TYPE_BOOLEAN: + { + dbus_bool_t value; + + if (strcmp(key, "Removable") == 0) + { + dbus_message_iter_get_basic(varIter, &value); + drive->m_isRemovable = static_cast<bool>(value); + } + + break; + } + case DBUS_TYPE_ARRAY: + { + DBusMessageIter arrIter; + + if (strcmp(key, "MediaCompatibility") == 0) + { + dbus_message_iter_recurse(varIter, &arrIter); + while (dbus_message_iter_get_arg_type(&arrIter) == DBUS_TYPE_STRING) + { + const char *compatibility; + dbus_message_iter_get_basic(&arrIter, &compatibility); + drive->m_mediaCompatibility.emplace_back(compatibility); + dbus_message_iter_next(&arrIter); + } + } + + break; + } + default: + break; + } +} + + +void CUDisks2Provider::ParseBlockProperty(Block *block, const char *key, DBusMessageIter *varIter) +{ + switch (dbus_message_iter_get_arg_type(varIter)) + { + case DBUS_TYPE_OBJECT_PATH: + { + const char *value; + + if (strcmp(key, "Drive") == 0) + { + dbus_message_iter_get_basic(varIter, &value); + block->m_driveobject.assign(value); + } + + break; + } + case DBUS_TYPE_STRING: + { + const char *value; + + if (strcmp(key, "IdLabel") == 0) + { + dbus_message_iter_get_basic(varIter, &value); + block->m_label.assign(value); + } + + break; + } + case DBUS_TYPE_BOOLEAN: + { + dbus_bool_t value; + + if (strcmp(key, "HintSystem") == 0) + { + dbus_message_iter_get_basic(varIter, &value); + block->m_isSystem = static_cast<bool>(value); + } + + break; + } + case DBUS_TYPE_UINT64: + { + dbus_uint64_t value; + + if (strcmp(key, "Size") == 0) + { + dbus_message_iter_get_basic(varIter, &value); + block->m_size = value; + } + + break; + } + case DBUS_TYPE_ARRAY: + { + DBusMessageIter arrIter; + + if (strcmp(key, "PreferredDevice") == 0) + { + dbus_message_iter_recurse(varIter, &arrIter); + block->m_device.assign(ParseByteArray(&arrIter)); + } + + break; + } + default: + break; + } +} + +void CUDisks2Provider::ParseFilesystemProperty(Filesystem *fs, const char *key, DBusMessageIter *varIter) +{ + switch (dbus_message_iter_get_arg_type(varIter)) + { + case DBUS_TYPE_ARRAY: + { + DBusMessageIter arrIter; + + if (strcmp(key, "MountPoints") == 0) + { + dbus_message_iter_recurse(varIter, &arrIter); + + if (dbus_message_iter_get_arg_type(&arrIter) == DBUS_TYPE_ARRAY) + { + DBusMessageIter valIter; + + dbus_message_iter_recurse(&arrIter, &valIter); + fs->SetMountPoint(ParseByteArray(&valIter)); + + dbus_message_iter_next(&arrIter); + } + else + { + fs->ResetMountPoint(); + } + } + + break; + } + default: + break; + } +} + +std::string CUDisks2Provider::ParseByteArray(DBusMessageIter *arrIter) +{ + std::ostringstream strStream; + + while (dbus_message_iter_get_arg_type(arrIter) == DBUS_TYPE_BYTE) + { + dbus_int16_t value = 0; + dbus_message_iter_get_basic(arrIter, &value); + if (value == 0) + break; + strStream << static_cast<char>(value); + dbus_message_iter_next(arrIter); + } + + return strStream.str(); +} + +void CUDisks2Provider::AppendEmptyOptions(DBusMessageIter *argsIter) +{ + DBusMessageIter dictIter; + dbus_message_iter_open_container(argsIter, DBUS_TYPE_ARRAY, "{sv}", &dictIter); + dbus_message_iter_close_container(argsIter, &dictIter); +} diff --git a/xbmc/platform/linux/storage/UDisks2Provider.h b/xbmc/platform/linux/storage/UDisks2Provider.h new file mode 100644 index 0000000..b4c85ee --- /dev/null +++ b/xbmc/platform/linux/storage/UDisks2Provider.h @@ -0,0 +1,210 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "DBusUtil.h" +#include "storage/IStorageProvider.h" + +#include <string> +#include <vector> + +class CUDisks2Provider : public IStorageProvider +{ + class Drive + { + public: + std::string m_object; + bool m_isRemovable = false; + std::vector<std::string> m_mediaCompatibility; + + explicit Drive(const char *object); + ~Drive() = default; + + /*! \brief Check if the drive is optical + * @return true if the drive is optical, false otherwise + */ + bool IsOptical() const; + + /*! \brief Get a representation of the drive as a readable string + * @return drive as a string + */ + std::string ToString() const; + }; + + class Block + { + public: + Drive *m_drive = nullptr; + std::string m_object; + std::string m_driveobject; + std::string m_label; + std::string m_device; + bool m_isSystem = false; + u_int64_t m_size = 0; + + explicit Block(const char *object); + ~Block() = default; + + bool IsReady(); + + /*! \brief Get a representation of the block as a readable string + * @return block as a string + */ + std::string ToString() const; + }; + + class Filesystem + { + public: + Block *m_block = nullptr; + + explicit Filesystem(const char *object); + ~Filesystem() = default; + + bool Mount(); + bool Unmount(); + + /*! \brief Get the device display name/label + * @return the device display name/label + */ + std::string GetDisplayName() const; + + /*! \brief Check if the device is approved/whitelisted + * @return true if the device is approved/whitelisted, false otherwise + */ + bool IsApproved() const; + + /*! \brief Check if the device is mounted + * @return true if the device is mounted, false otherwise + */ + bool IsMounted() const; + + /*! \brief Check if the device is ready + * @return true if the device is ready, false otherwise + */ + bool IsReady() const; + + /*! \brief Check if the device is optical + * @return true if the device is optical, false otherwise + */ + bool IsOptical() const; + + /*! \brief Get the storage type of this device + * @return the storage type (e.g. OPTICAL) or UNKNOWN if + * the type couldn't be detected + */ + MEDIA_DETECT::STORAGE::Type GetStorageType() const; + + /*! \brief Get the device mount point + * @return the device mount point + */ + std::string GetMountPoint() const; + + /*! \brief Reset the device mount point + */ + void ResetMountPoint(); + + /*! \brief Set the device mount point + * @param mountPoint the device mount point + */ + void SetMountPoint(const std::string& mountPoint); + + /*! \brief Get the device dbus object + * @return the device dbus object + */ + std::string GetObject() const; + + /*! \brief Get a representation of the device as a readable string + * @return device as a string + */ + std::string ToString() const; + + /*! \brief Get a representation of the device as a media share + * @return the media share + */ + CMediaSource ToMediaShare() const; + + /*! \brief Get a representation of the device as a storage device abstraction + * @return the storage device abstraction of the device + */ + MEDIA_DETECT::STORAGE::StorageDevice ToStorageDevice() const; + + private: + bool m_isMounted = false; + std::string m_object; + std::string m_mountPoint; + }; + + typedef std::map<std::string, Drive *> DriveMap; + typedef std::map<std::string, Block *> BlockMap; + typedef std::map<std::string, Filesystem *> FilesystemMap; + +public: + CUDisks2Provider(); + ~CUDisks2Provider() override; + + void Initialize() override; + + bool PumpDriveChangeEvents(IStorageEventsCallback *callback) override; + + static bool HasUDisks2(); + + bool Eject(const std::string &mountpath) override; + + std::vector<std::string> GetDiskUsage() override; + + void GetLocalDrives(VECSOURCES &localDrives) override + { GetDisks(localDrives, false); } + + void GetRemovableDrives(VECSOURCES &removableDrives) override + { GetDisks(removableDrives, true); } + + void Stop() override + {} + +private: + CDBusConnection m_connection; + + DriveMap m_drives; + BlockMap m_blocks; + FilesystemMap m_filesystems; + + std::string m_daemonVersion; + + void GetDisks(VECSOURCES &devices, bool enumerateRemovable); + + void DriveAdded(Drive *drive); + bool DriveRemoved(const std::string& object); + void BlockAdded(Block *block, bool isNew = true); + bool BlockRemoved(const std::string& object); + void FilesystemAdded(Filesystem *fs, bool isNew = true); + bool FilesystemRemoved(const char *object, IStorageEventsCallback *callback); + + bool HandleInterfacesRemoved(DBusMessage *msg, IStorageEventsCallback *callback); + void HandleInterfacesAdded(DBusMessage *msg); + bool HandlePropertiesChanged(DBusMessage *msg, IStorageEventsCallback *callback); + + bool DrivePropertiesChanged(const char *object, DBusMessageIter *propsIter); + bool BlockPropertiesChanged(const char *object, DBusMessageIter *propsIter); + bool FilesystemPropertiesChanged(const char *object, DBusMessageIter *propsIter, IStorageEventsCallback *callback); + + bool RemoveInterface(const char *path, const char *iface, IStorageEventsCallback *callback); + + template<class Object, class Function> + void ParseProperties(Object *ref, DBusMessageIter *dictIter, Function f); + void ParseInterfaces(DBusMessageIter *dictIter); + void ParseDriveProperty(Drive *drive, const char *key, DBusMessageIter *varIter); + void ParseBlockProperty(Block *block, const char *key, DBusMessageIter *varIter); + void ParseFilesystemProperty(Filesystem *fs, const char *key, DBusMessageIter *varIter); + std::string ParseByteArray(DBusMessageIter *arrIter); + void HandleManagedObjects(DBusMessage *msg); + void ParseInterface(const char *object, const char *iface, DBusMessageIter *propsIter); + + static void AppendEmptyOptions(DBusMessageIter *argsIter); +}; diff --git a/xbmc/platform/linux/storage/UDisksProvider.cpp b/xbmc/platform/linux/storage/UDisksProvider.cpp new file mode 100644 index 0000000..7a2a034 --- /dev/null +++ b/xbmc/platform/linux/storage/UDisksProvider.cpp @@ -0,0 +1,412 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ +#include "UDisksProvider.h" + +#include "ServiceBroker.h" +#include "guilib/LocalizeStrings.h" +#include "settings/AdvancedSettings.h" +#include "settings/SettingsComponent.h" +#include "utils/StringUtils.h" +#include "utils/URIUtils.h" +#include "utils/log.h" + +#include "platform/posix/PosixMountProvider.h" + +CUDiskDevice::CUDiskDevice(const char *DeviceKitUDI): + m_DeviceKitUDI(DeviceKitUDI) +{ + m_isMounted = false; + m_isMountedByUs = false; + m_isRemovable = false; + m_isPartition = false; + m_isFileSystem = false; + m_isSystemInternal = false; + m_isOptical = false; + m_PartitionSize = 0; + Update(); +} + +void CUDiskDevice::Update() +{ + CVariant properties = CDBusUtil::GetAll("org.freedesktop.UDisks", m_DeviceKitUDI.c_str(), "org.freedesktop.UDisks.Device"); + + m_isFileSystem = properties["IdUsage"].asString() == "filesystem"; + if (m_isFileSystem) + { + m_UDI = properties["IdUuid"].asString(); + m_Label = properties["IdLabel"].asString(); + m_FileSystem = properties["IdType"].asString(); + } + else + { + m_UDI.clear(); + m_Label.clear(); + m_FileSystem.clear(); + } + + m_isMounted = properties["DeviceIsMounted"].asBoolean(); + if (m_isMounted && !properties["DeviceMountPaths"].empty()) + m_MountPath = properties["DeviceMountPaths"][0].asString(); + else + m_MountPath.clear(); + + m_PartitionSize = properties["PartitionSize"].asUnsignedInteger(); + m_isPartition = properties["DeviceIsPartition"].asBoolean(); + m_isSystemInternal = properties["DeviceIsSystemInternal"].asBoolean(); + m_isOptical = properties["DeviceIsOpticalDisc"].asBoolean(); + if (m_isPartition) + { + CVariant isRemovable = CDBusUtil::GetVariant("org.freedesktop.UDisks", properties["PartitionSlave"].asString().c_str(), "org.freedesktop.UDisks.Device", "DeviceIsRemovable"); + + if ( !isRemovable.isNull() ) + m_isRemovable = isRemovable.asBoolean(); + else + m_isRemovable = false; + } + else + m_isRemovable = properties["DeviceIsRemovable"].asBoolean(); +} + +bool CUDiskDevice::Mount() +{ + if (!m_isMounted && !m_isSystemInternal && m_isFileSystem) + { + CLog::Log(LOGDEBUG, "UDisks: Mounting {}", m_DeviceKitUDI); + CDBusMessage message("org.freedesktop.UDisks", m_DeviceKitUDI.c_str(), "org.freedesktop.UDisks.Device", "FilesystemMount"); + message.AppendArgument(""); + const char *array[] = {}; + message.AppendArgument(array, 0); + + DBusMessage *reply = message.SendSystem(); + if (reply) + { + char *mountPoint; + if (dbus_message_get_args (reply, NULL, DBUS_TYPE_STRING, &mountPoint, DBUS_TYPE_INVALID)) + { + m_MountPath = mountPoint; + CLog::Log(LOGDEBUG, "UDisks: Successfully mounted {} on {}", m_DeviceKitUDI, mountPoint); + m_isMountedByUs = m_isMounted = true; + } + } + + return m_isMounted; + } + else + CLog::Log(LOGDEBUG, "UDisks: Is not able to mount {}", ToString()); + + return false; +} + +bool CUDiskDevice::UnMount() +{ + if (m_isMounted && !m_isSystemInternal && m_isFileSystem) + { + CDBusMessage message("org.freedesktop.UDisks", m_DeviceKitUDI.c_str(), "org.freedesktop.UDisks.Device", "FilesystemUnmount"); + + const char *array[1]; + message.AppendArgument(array, 0); + + DBusMessage *reply = message.SendSystem(); + if (reply) + m_isMountedByUs = m_isMounted = false; + + return !m_isMounted; + } + else + CLog::Log(LOGDEBUG, "UDisks: Is not able to unmount {}", ToString()); + + return false; +} + +CMediaSource CUDiskDevice::ToMediaShare() const +{ + CMediaSource source; + source.strPath = m_MountPath; + if (m_Label.empty()) + { + std::string strSize = StringUtils::SizeToString(m_PartitionSize); + source.strName = StringUtils::Format("{} {}", strSize, g_localizeStrings.Get(155)); + } + else + source.strName = m_Label; + if (m_isOptical) + source.m_iDriveType = CMediaSource::SOURCE_TYPE_DVD; + else if (m_isSystemInternal) + source.m_iDriveType = CMediaSource::SOURCE_TYPE_LOCAL; + else + source.m_iDriveType = CMediaSource::SOURCE_TYPE_REMOVABLE; + source.m_ignore = true; + return source; +} + +bool CUDiskDevice::IsApproved() const +{ + return (m_isFileSystem && m_isMounted && m_UDI.length() > 0 && (m_FileSystem.length() > 0 && m_FileSystem != "swap") + && m_MountPath != "/" && m_MountPath != "/boot") || m_isOptical; +} + +bool CUDiskDevice::IsOptical() const +{ + return m_isOptical; +} + +MEDIA_DETECT::STORAGE::Type CUDiskDevice::GetStorageType() const +{ + if (IsOptical()) + return MEDIA_DETECT::STORAGE::Type::OPTICAL; + + return MEDIA_DETECT::STORAGE::Type::UNKNOWN; +} + +bool CUDiskDevice::IsMounted() const +{ + return m_isMounted; +} + +std::string CUDiskDevice::GetDisplayName() const +{ + return m_Label; +} + +std::string CUDiskDevice::GetMountPoint() const +{ + return m_MountPath; +} + +bool CUDiskDevice::IsSystemInternal() const +{ + return m_isSystemInternal; +} + +MEDIA_DETECT::STORAGE::StorageDevice CUDiskDevice::ToStorageDevice() const +{ + MEDIA_DETECT::STORAGE::StorageDevice device; + device.label = GetDisplayName(); + device.path = GetMountPoint(); + device.type = GetStorageType(); + return device; +} + +#define BOOL2SZ(b) ((b) ? "true" : "false") + +std::string CUDiskDevice::ToString() const +{ + return StringUtils::Format("DeviceUDI {}: IsFileSystem {} HasFileSystem {} " + "IsSystemInternal {} IsMounted {} IsRemovable {} IsPartition {} " + "IsOptical {}", + m_DeviceKitUDI, BOOL2SZ(m_isFileSystem), m_FileSystem, + BOOL2SZ(m_isSystemInternal), BOOL2SZ(m_isMounted), + BOOL2SZ(m_isRemovable), BOOL2SZ(m_isPartition), BOOL2SZ(m_isOptical)); +} + +CUDisksProvider::CUDisksProvider() +{ + //! @todo do not use dbus_connection_pop_message() that requires the use of a + //! private connection + if (!m_connection.Connect(DBUS_BUS_SYSTEM, true)) + { + return; + } + + dbus_connection_set_exit_on_disconnect(m_connection, false); + + CDBusError error; + dbus_bus_add_match(m_connection, "type='signal',interface='org.freedesktop.UDisks'", error); + dbus_connection_flush(m_connection); + + if (error) + { + error.Log("UDisks: Failed to attach to signal"); + m_connection.Destroy(); + } +} + +CUDisksProvider::~CUDisksProvider() +{ + for (auto& itr : m_AvailableDevices) + delete itr.second; + + m_AvailableDevices.clear(); +} + +void CUDisksProvider::Initialize() +{ + CLog::Log(LOGDEBUG, "Selected UDisks as storage provider"); + m_DaemonVersion = atoi(CDBusUtil::GetVariant("org.freedesktop.UDisks", "/org/freedesktop/UDisks", "org.freedesktop.UDisks", "DaemonVersion").asString().c_str()); + CLog::Log(LOGDEBUG, "UDisks: DaemonVersion {}", m_DaemonVersion); + + CLog::Log(LOGDEBUG, "UDisks: Querying available devices"); + std::vector<std::string> devices = EnumerateDisks(); + for (unsigned int i = 0; i < devices.size(); i++) + DeviceAdded(devices[i].c_str(), NULL); +} + +bool CUDisksProvider::Eject(const std::string& mountpath) +{ + std::string path(mountpath); + URIUtils::RemoveSlashAtEnd(path); + + for (auto& itr : m_AvailableDevices) + { + CUDiskDevice* device = itr.second; + if (device->GetMountPoint() == path) + return device->UnMount(); + } + + return false; +} + +std::vector<std::string> CUDisksProvider::GetDiskUsage() +{ + CPosixMountProvider legacy; + return legacy.GetDiskUsage(); +} + +bool CUDisksProvider::PumpDriveChangeEvents(IStorageEventsCallback *callback) +{ + bool result = false; + if (m_connection) + { + dbus_connection_read_write(m_connection, 0); + DBusMessagePtr msg(dbus_connection_pop_message(m_connection)); + + if (msg) + { + char *object; + if (dbus_message_get_args (msg.get(), NULL, DBUS_TYPE_OBJECT_PATH, &object, DBUS_TYPE_INVALID)) + { + result = true; + if (dbus_message_is_signal(msg.get(), "org.freedesktop.UDisks", "DeviceAdded")) + DeviceAdded(object, callback); + else if (dbus_message_is_signal(msg.get(), "org.freedesktop.UDisks", "DeviceRemoved")) + DeviceRemoved(object, callback); + else if (dbus_message_is_signal(msg.get(), "org.freedesktop.UDisks", "DeviceChanged")) + DeviceChanged(object, callback); + } + } + } + return result; +} + +bool CUDisksProvider::HasUDisks() +{ + return CDBusUtil::TryMethodCall(DBUS_BUS_SYSTEM, "org.freedesktop.UDisks", "/org/freedesktop/UDisks", "org.freedesktop.UDisks", "EnumerateDevices"); +} + +void CUDisksProvider::DeviceAdded(const char *object, IStorageEventsCallback *callback) +{ + CLog::Log(LOGDEBUG, LOGDBUS, "UDisks: DeviceAdded ({})", object); + + if (m_AvailableDevices[object]) + { + CLog::Log(LOGWARNING, "UDisks: Inconsistency found! DeviceAdded on an indexed disk"); + delete m_AvailableDevices[object]; + } + + CUDiskDevice *device = NULL; + device = new CUDiskDevice(object); + m_AvailableDevices[object] = device; + + // optical drives should be always mounted by default unless explicitly disabled by the user + if (CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_handleMounting || + (device->IsOptical() && + CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_autoMountOpticalMedia)) + { + device->Mount(); + } + + CLog::Log(LOGDEBUG, LOGDBUS, "UDisks: DeviceAdded - {}", device->ToString()); + + if (device->IsMounted() && device->IsApproved()) + { + CLog::Log(LOGINFO, "UDisks: Added {}", device->GetMountPoint()); + if (callback) + callback->OnStorageAdded(device->ToStorageDevice()); + } +} + +void CUDisksProvider::DeviceRemoved(const char *object, IStorageEventsCallback *callback) +{ + CLog::Log(LOGDEBUG, LOGDBUS, "UDisks: DeviceRemoved ({})", object); + + CUDiskDevice *device = m_AvailableDevices[object]; + if (device) + { + if (device->IsMounted() && callback) + callback->OnStorageUnsafelyRemoved(device->ToStorageDevice()); + + delete m_AvailableDevices[object]; + m_AvailableDevices.erase(object); + } +} + +void CUDisksProvider::DeviceChanged(const char *object, IStorageEventsCallback *callback) +{ + CLog::Log(LOGDEBUG, LOGDBUS, "UDisks: DeviceChanged ({})", object); + + CUDiskDevice *device = m_AvailableDevices[object]; + if (device == NULL) + { + CLog::Log(LOGWARNING, "UDisks: Inconsistency found! DeviceChanged on an unindexed disk"); + DeviceAdded(object, callback); + } + else + { + bool mounted = device->IsMounted(); + // make sure to not silently remount ejected usb thumb drives that user wants to eject + // optical drives should be always mounted by default unless explicitly disabled by the user + const auto advancedSettings = CServiceBroker::GetSettingsComponent()->GetAdvancedSettings(); + if (!mounted && device->IsOptical()) + { + if (advancedSettings->m_handleMounting || advancedSettings->m_autoMountOpticalMedia) + { + device->Mount(); + } + } + + device->Update(); + if (!mounted && device->IsMounted() && callback) + callback->OnStorageAdded(device->ToStorageDevice()); + else if (mounted && !device->IsMounted() && callback) + callback->OnStorageSafelyRemoved(device->ToStorageDevice()); + + CLog::Log(LOGDEBUG, LOGDBUS, "UDisks: DeviceChanged - {}", device->ToString()); + } +} + +std::vector<std::string> CUDisksProvider::EnumerateDisks() +{ + std::vector<std::string> devices; + CDBusMessage message("org.freedesktop.UDisks", "/org/freedesktop/UDisks", "org.freedesktop.UDisks", "EnumerateDevices"); + DBusMessage *reply = message.SendSystem(); + if (reply) + { + char** disks = NULL; + int length = 0; + + if (dbus_message_get_args (reply, NULL, DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &disks, &length, DBUS_TYPE_INVALID)) + { + for (int i = 0; i < length; i++) + devices.emplace_back(disks[i]); + + dbus_free_string_array(disks); + } + } + + return devices; +} + +void CUDisksProvider::GetDisks(VECSOURCES& devices, bool EnumerateRemovable) +{ + for (auto& itr : m_AvailableDevices) + { + CUDiskDevice* device = itr.second; + if (device && device->IsApproved() && device->IsSystemInternal() != EnumerateRemovable) + devices.push_back(device->ToMediaShare()); + } +} diff --git a/xbmc/platform/linux/storage/UDisksProvider.h b/xbmc/platform/linux/storage/UDisksProvider.h new file mode 100644 index 0000000..c5372f8 --- /dev/null +++ b/xbmc/platform/linux/storage/UDisksProvider.h @@ -0,0 +1,131 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "DBusUtil.h" +#include "storage/IStorageProvider.h" + +#include <string> +#include <vector> + +class CUDiskDevice +{ +public: + CUDiskDevice(const char *DeviceKitUDI); + ~CUDiskDevice() = default; + + void Update(); + + bool Mount(); + bool UnMount(); + + /*! \brief Check if the device is approved/whitelisted + * @return true if the device is approved/whitelisted, false otherwise + */ + bool IsApproved() const; + + /*! \brief Get the storage type of this device + * @return the storage type (e.g. OPTICAL) or UNKNOWN if + * the type couldn't be detected + */ + MEDIA_DETECT::STORAGE::Type GetStorageType() const; + + /*! \brief Check if the device is optical + * @return true if the device is optical, false otherwise + */ + bool IsOptical() const; + + /*! \brief Check if the device is mounted + * @return true if the device is mounted, false otherwise + */ + bool IsMounted() const; + + /*! \brief Check if the device is internal to the system + * @return true if the device is internal to the system, false otherwise + */ + bool IsSystemInternal() const; + + /*! \brief Get the device display name/label + * @return the device display name/label + */ + std::string GetDisplayName() const; + + /*! \brief Get the device mount point + * @return the device mount point + */ + std::string GetMountPoint() const; + + /*! \brief Get a representation of the device as a readable string + * @return device as a string + */ + std::string ToString() const; + + /*! \brief Get a representation of the device as a media share + * @return the media share + */ + CMediaSource ToMediaShare() const; + + /*! \brief Get a representation of the device as a storage device abstraction + * @return the storage device abstraction of the device + */ + MEDIA_DETECT::STORAGE::StorageDevice ToStorageDevice() const; + +private: + std::string m_UDI; + std::string m_DeviceKitUDI; + std::string m_MountPath; + std::string m_FileSystem; + std::string m_Label; + bool m_isMounted; + bool m_isMountedByUs; + bool m_isRemovable; + bool m_isPartition; + bool m_isFileSystem; + bool m_isSystemInternal; + bool m_isOptical; + int64_t m_PartitionSize; +}; + +class CUDisksProvider : public IStorageProvider +{ +public: + CUDisksProvider(); + ~CUDisksProvider() override; + + void Initialize() override; + void Stop() override { } + + void GetLocalDrives(VECSOURCES &localDrives) override { GetDisks(localDrives, false); } + void GetRemovableDrives(VECSOURCES &removableDrives) override { GetDisks(removableDrives, true); } + + bool Eject(const std::string& mountpath) override; + + std::vector<std::string> GetDiskUsage() override; + + bool PumpDriveChangeEvents(IStorageEventsCallback *callback) override; + + static bool HasUDisks(); +private: + typedef std::map<std::string, CUDiskDevice *> DeviceMap; + typedef std::pair<std::string, CUDiskDevice *> DevicePair; + + void DeviceAdded(const char *object, IStorageEventsCallback *callback); + void DeviceRemoved(const char *object, IStorageEventsCallback *callback); + void DeviceChanged(const char *object, IStorageEventsCallback *callback); + + std::vector<std::string> EnumerateDisks(); + + void GetDisks(VECSOURCES& devices, bool EnumerateRemovable); + + int m_DaemonVersion; + + DeviceMap m_AvailableDevices; + + CDBusConnection m_connection; +}; diff --git a/xbmc/platform/linux/test/CMakeLists.txt b/xbmc/platform/linux/test/CMakeLists.txt new file mode 100644 index 0000000..1fb0281 --- /dev/null +++ b/xbmc/platform/linux/test/CMakeLists.txt @@ -0,0 +1,3 @@ +list(APPEND SOURCES TestSysfsPath.cpp) + +core_add_test_library(linux_test) diff --git a/xbmc/platform/linux/test/TestSysfsPath.cpp b/xbmc/platform/linux/test/TestSysfsPath.cpp new file mode 100644 index 0000000..91e7763 --- /dev/null +++ b/xbmc/platform/linux/test/TestSysfsPath.cpp @@ -0,0 +1,91 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "platform/linux/SysfsPath.h" +#include "utils/StringUtils.h" + +#include <fstream> +#include <sstream> +#include <string> + +#include <gtest/gtest.h> + +struct TestSysfsPath : public ::testing::Test +{ + std::string GetTestFilePath() + { + std::string tmpdir{"/tmp"}; + const char *test_tmpdir = getenv("TMPDIR"); + + if (test_tmpdir && test_tmpdir[0] != '\0') { + tmpdir.assign(test_tmpdir); + } + + return tmpdir + "/kodi-test-" + StringUtils::CreateUUID(); + } +}; + +TEST_F(TestSysfsPath, SysfsPathTestInt) +{ + std::string filepath = GetTestFilePath(); + std::ofstream m_output(filepath); + + int temp{1234}; + m_output << temp; + m_output.close(); + + CSysfsPath path(filepath); + ASSERT_TRUE(path.Exists()); + EXPECT_EQ(path.Get<int>(), 1234); + EXPECT_EQ(path.Get<float>(), 1234); + EXPECT_EQ(path.Get<double>(), 1234); + EXPECT_EQ(path.Get<uint64_t>(), 1234); + EXPECT_EQ(path.Get<uint16_t>(), 1234); + EXPECT_EQ(path.Get<unsigned int>(), 1234); + EXPECT_EQ(path.Get<unsigned long int>(), 1234); + + std::remove(filepath.c_str()); +} + +TEST_F(TestSysfsPath, SysfsPathTestString) +{ + std::string filepath = GetTestFilePath(); + std::ofstream m_output{filepath}; + + std::string temp{"test"}; + m_output << temp; + m_output.close(); + + CSysfsPath path(filepath); + ASSERT_TRUE(path.Exists()); + EXPECT_EQ(path.Get<std::string>(), "test"); + + std::remove(filepath.c_str()); +} + +TEST_F(TestSysfsPath, SysfsPathTestLongString) +{ + std::string filepath = GetTestFilePath().append("-long"); + std::ofstream m_output{filepath}; + + std::string temp{"test with spaces"}; + m_output << temp; + m_output.close(); + + CSysfsPath path(filepath); + ASSERT_TRUE(path.Exists()); + EXPECT_EQ(path.Get<std::string>(), "test with spaces"); + + std::remove(filepath.c_str()); +} + +TEST_F(TestSysfsPath, SysfsPathTestPathDoesNotExist) +{ + CSysfsPath otherPath{"/thispathdoesnotexist"}; + ASSERT_FALSE(otherPath.Exists()); +} diff --git a/xbmc/platform/linux/threads/CMakeLists.txt b/xbmc/platform/linux/threads/CMakeLists.txt new file mode 100644 index 0000000..b90d55e --- /dev/null +++ b/xbmc/platform/linux/threads/CMakeLists.txt @@ -0,0 +1,4 @@ +set(SOURCES ThreadImplLinux.cpp) +set(HEADERS ThreadImplLinux.h) + +core_add_library(platform_linux_threads) diff --git a/xbmc/platform/linux/threads/ThreadImplLinux.cpp b/xbmc/platform/linux/threads/ThreadImplLinux.cpp new file mode 100644 index 0000000..f4810cf --- /dev/null +++ b/xbmc/platform/linux/threads/ThreadImplLinux.cpp @@ -0,0 +1,171 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "ThreadImplLinux.h" + +#include "utils/Map.h" +#include "utils/log.h" + +#include <algorithm> +#include <array> +#include <limits.h> + +#include <sys/resource.h> +#include <unistd.h> + +#if !defined(TARGET_ANDROID) && (defined(__GLIBC__) || defined(__UCLIBC__)) +#if defined(__UCLIBC__) || !__GLIBC_PREREQ(2, 30) +#include <sys/syscall.h> +#endif +#endif + +namespace +{ + +constexpr auto nativeThreadPriorityMap = make_map<ThreadPriority, int>({ + {ThreadPriority::LOWEST, -1}, + {ThreadPriority::BELOW_NORMAL, -1}, + {ThreadPriority::NORMAL, 0}, + {ThreadPriority::ABOVE_NORMAL, 1}, + {ThreadPriority::HIGHEST, 1}, +}); + +static_assert(static_cast<size_t>(ThreadPriority::PRIORITY_COUNT) == nativeThreadPriorityMap.size(), + "nativeThreadPriorityMap doesn't match the size of ThreadPriority, did you forget to " + "add/remove a mapping?"); + +constexpr int ThreadPriorityToNativePriority(const ThreadPriority& priority) +{ + const auto it = nativeThreadPriorityMap.find(priority); + if (it != nativeThreadPriorityMap.cend()) + { + return it->second; + } + else + { + throw std::range_error("Priority not found"); + } +} + +#if !defined(TARGET_ANDROID) && (defined(__GLIBC__) || defined(__UCLIBC__)) +#if defined(__UCLIBC__) || !__GLIBC_PREREQ(2, 30) +static pid_t gettid() +{ + return syscall(__NR_gettid); +} +#endif +#endif + +} // namespace + +static int s_maxPriority; +static bool s_maxPriorityIsSet{false}; + +// We need to return what the best number than can be passed +// to SetPriority is. It will basically be relative to the +// the main thread's nice level, inverted (since "higher" priority +// nice levels are actually lower numbers). +static int GetUserMaxPriority(int maxPriority) +{ + if (s_maxPriorityIsSet) + return s_maxPriority; + + // if we're root, then we can do anything. So we'll allow + // max priority. + if (geteuid() == 0) + return maxPriority; + + // get user max prio + struct rlimit limit; + if (getrlimit(RLIMIT_NICE, &limit) != 0) + { + // If we fail getting the limit for nice we just assume we can't raise the priority + return 0; + } + + const int appNice = getpriority(PRIO_PROCESS, getpid()); + const int rlimVal = limit.rlim_cur; + + // according to the docs, limit.rlim_cur shouldn't be zero, yet, here we are. + // if a user has no entry in limits.conf rlim_cur is zero. In this case the best + // nice value we can hope to achieve is '0' as a regular user + const int userBestNiceValue = (rlimVal == 0) ? 0 : (20 - rlimVal); + + // running the app with nice -n 10 -> + // e.g. +10 10 - 0 // default non-root user. + // e.g. +30 10 - -20 // if root with rlimits set. + // running the app default -> + // e.g. 0 0 - 0 // default non-root user. + // e.g. +20 0 - -20 // if root with rlimits set. + const int bestUserSetPriority = appNice - userBestNiceValue; // nice is inverted from prio. + + // static because we only need to check this once. + // we shouldn't expect a user to change RLIMIT_NICE while running + // and it won't work anyway for threads that already set their priority. + s_maxPriority = std::min(maxPriority, bestUserSetPriority); + s_maxPriorityIsSet = true; + + return s_maxPriority; +} + +std::unique_ptr<IThreadImpl> IThreadImpl::CreateThreadImpl(std::thread::native_handle_type handle) +{ + return std::make_unique<CThreadImplLinux>(handle); +} + +CThreadImplLinux::CThreadImplLinux(std::thread::native_handle_type handle) + : IThreadImpl(handle), m_threadID(gettid()) +{ +} + +void CThreadImplLinux::SetThreadInfo(const std::string& name) +{ +#if defined(__GLIBC__) + pthread_setname_np(m_handle, name.c_str()); +#endif + + // get user max prio + const int maxPrio = ThreadPriorityToNativePriority(ThreadPriority::HIGHEST); + const int userMaxPrio = GetUserMaxPriority(maxPrio); + + // if the user does not have an entry in limits.conf the following + // call will fail + if (userMaxPrio > 0) + { + // start thread with nice level of application + const int appNice = getpriority(PRIO_PROCESS, getpid()); + if (setpriority(PRIO_PROCESS, m_threadID, appNice) != 0) + CLog::Log(LOGERROR, "[threads] failed to set priority: {}", strerror(errno)); + } +} + +bool CThreadImplLinux::SetPriority(const ThreadPriority& priority) +{ + // keep priority in bounds + const int prio = ThreadPriorityToNativePriority(priority); + const int maxPrio = ThreadPriorityToNativePriority(ThreadPriority::HIGHEST); + const int minPrio = ThreadPriorityToNativePriority(ThreadPriority::LOWEST); + + // get user max prio given max prio (will take the min) + const int userMaxPrio = GetUserMaxPriority(maxPrio); + + // clamp to min and max priorities + const int adjustedPrio = std::clamp(prio, minPrio, userMaxPrio); + + // nice level of application + const int appNice = getpriority(PRIO_PROCESS, getpid()); + const int newNice = appNice - adjustedPrio; + + if (setpriority(PRIO_PROCESS, m_threadID, newNice) != 0) + { + CLog::Log(LOGERROR, "[threads] failed to set priority: {}", strerror(errno)); + return false; + } + + return true; +} diff --git a/xbmc/platform/linux/threads/ThreadImplLinux.h b/xbmc/platform/linux/threads/ThreadImplLinux.h new file mode 100644 index 0000000..986ffe5 --- /dev/null +++ b/xbmc/platform/linux/threads/ThreadImplLinux.h @@ -0,0 +1,26 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "threads/IThreadImpl.h" + +class CThreadImplLinux : public IThreadImpl +{ +public: + CThreadImplLinux(std::thread::native_handle_type handle); + + ~CThreadImplLinux() override = default; + + void SetThreadInfo(const std::string& name) override; + + bool SetPriority(const ThreadPriority& priority) override; + +private: + pid_t m_threadID; +}; diff --git a/xbmc/platform/posix/CMakeLists.txt b/xbmc/platform/posix/CMakeLists.txt new file mode 100644 index 0000000..2d8d4db --- /dev/null +++ b/xbmc/platform/posix/CMakeLists.txt @@ -0,0 +1,21 @@ +set(SOURCES ConvUtils.cpp + CPUInfoPosix.cpp + Filesystem.cpp + MessagePrinter.cpp + PlatformPosix.cpp + PosixMountProvider.cpp + PosixResourceCounter.cpp + PosixTimezone.cpp + XHandle.cpp + XTimeUtils.cpp) + +set(HEADERS ConvUtils.h + CPUInfoPosix.h + PlatformDefs.h + PlatformPosix.h + PosixMountProvider.h + PosixResourceCounter.h + PosixTimezone.h + XHandle.h) + +core_add_library(platform_posix) diff --git a/xbmc/platform/posix/CPUInfoPosix.cpp b/xbmc/platform/posix/CPUInfoPosix.cpp new file mode 100644 index 0000000..9d158d0 --- /dev/null +++ b/xbmc/platform/posix/CPUInfoPosix.cpp @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "CPUInfoPosix.h" + +#include "ServiceBroker.h" +#include "settings/AdvancedSettings.h" +#include "settings/SettingsComponent.h" + +bool CCPUInfoPosix::GetTemperature(CTemperature& temperature) +{ + return CheckUserTemperatureCommand(temperature); +} + +bool CCPUInfoPosix::CheckUserTemperatureCommand(CTemperature& temperature) +{ + temperature.SetValid(false); + + auto settingComponent = CServiceBroker::GetSettingsComponent(); + if (!settingComponent) + return false; + + auto advancedSettings = settingComponent->GetAdvancedSettings(); + if (!advancedSettings) + return false; + + std::string cmd = advancedSettings->m_cpuTempCmd; + + if (cmd.empty()) + return false; + + int value = {}; + char scale = {}; + + auto p = popen(cmd.c_str(), "r"); + if (p) + { + int ret = fscanf(p, "%d %c", &value, &scale); + pclose(p); + + if (ret < 2) + return false; + } + + if (scale == 'C' || scale == 'c') + temperature = CTemperature::CreateFromCelsius(value); + else if (scale == 'F' || scale == 'f') + temperature = CTemperature::CreateFromFahrenheit(value); + else + return false; + + temperature.SetValid(true); + + return true; +} diff --git a/xbmc/platform/posix/CPUInfoPosix.h b/xbmc/platform/posix/CPUInfoPosix.h new file mode 100644 index 0000000..af94b1b --- /dev/null +++ b/xbmc/platform/posix/CPUInfoPosix.h @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "utils/CPUInfo.h" + +class CCPUInfoPosix : public CCPUInfo +{ +public: + virtual bool GetTemperature(CTemperature& temperature) override; + +protected: + CCPUInfoPosix() = default; + virtual ~CCPUInfoPosix() = default; + + bool CheckUserTemperatureCommand(CTemperature& temperature); +}; diff --git a/xbmc/platform/posix/ConvUtils.cpp b/xbmc/platform/posix/ConvUtils.cpp new file mode 100644 index 0000000..6ad3da2 --- /dev/null +++ b/xbmc/platform/posix/ConvUtils.cpp @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include <ctype.h> +#include <errno.h> +#include <stdio.h> + +#include "PlatformDefs.h" + +DWORD GetLastError() +{ + return errno; +} + +void SetLastError(DWORD dwErrCode) +{ + errno = dwErrCode; +} diff --git a/xbmc/platform/posix/ConvUtils.h b/xbmc/platform/posix/ConvUtils.h new file mode 100644 index 0000000..2e7c16a --- /dev/null +++ b/xbmc/platform/posix/ConvUtils.h @@ -0,0 +1,15 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "PlatformDefs.h" // DWORD ... + +DWORD GetLastError(); +void SetLastError(DWORD dwErrCode); + diff --git a/xbmc/platform/posix/Filesystem.cpp b/xbmc/platform/posix/Filesystem.cpp new file mode 100644 index 0000000..0db3af5 --- /dev/null +++ b/xbmc/platform/posix/Filesystem.cpp @@ -0,0 +1,128 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "platform/Filesystem.h" +#include "filesystem/SpecialProtocol.h" +#include "utils/URIUtils.h" + +#if defined(TARGET_LINUX) +#include <sys/statvfs.h> +#elif defined(TARGET_DARWIN) || defined(TARGET_FREEBSD) +#include <sys/param.h> +#include <sys/mount.h> +#elif defined(TARGET_ANDROID) +#include <sys/statfs.h> +#endif + +#include <cstdint> +#include <cstdlib> +#include <limits.h> +#include <string.h> + +#include <unistd.h> + +namespace KODI +{ +namespace PLATFORM +{ +namespace FILESYSTEM +{ + +space_info space(const std::string& path, std::error_code& ec) +{ + ec.clear(); + space_info sp; +#if defined(TARGET_LINUX) + struct statvfs64 fsInfo; + auto result = statvfs64(CSpecialProtocol::TranslatePath(path).c_str(), &fsInfo); +#else + struct statfs fsInfo; + // is 64-bit on android and darwin (10.6SDK + any iOS) + auto result = statfs(CSpecialProtocol::TranslatePath(path).c_str(), &fsInfo); +#endif + + if (result != 0) + { + ec.assign(result, std::system_category()); + sp.available = static_cast<uintmax_t>(-1); + sp.capacity = static_cast<uintmax_t>(-1); + sp.free = static_cast<uintmax_t>(-1); + return sp; + } + sp.available = static_cast<uintmax_t>(fsInfo.f_bavail * fsInfo.f_bsize); + sp.capacity = static_cast<uintmax_t>(fsInfo.f_blocks * fsInfo.f_bsize); + sp.free = static_cast<uintmax_t>(fsInfo.f_bfree * fsInfo.f_bsize); + + return sp; +} + +std::string temp_directory_path(std::error_code &ec) +{ + ec.clear(); + + auto result = getenv("TMPDIR"); + if (result) + return URIUtils::AppendSlash(result); + + return "/tmp/"; +} + +std::string create_temp_directory(std::error_code &ec) +{ + char buf[PATH_MAX]; + + auto path = temp_directory_path(ec); + + strncpy(buf, (path + "xbmctempXXXXXX").c_str(), sizeof(buf) - 1); + buf[sizeof(buf) - 1] = '\0'; + + auto tmp = mkdtemp(buf); + if (!tmp) + { + ec.assign(errno, std::system_category()); + return std::string(); + } + + ec.clear(); + return std::string(tmp); +} + +std::string temp_file_path(const std::string& suffix, std::error_code& ec) +{ + char tmp[PATH_MAX]; + + auto tempPath = create_temp_directory(ec); + if (ec) + return std::string(); + + tempPath = URIUtils::AddFileToFolder(tempPath, "xbmctempfileXXXXXX" + suffix); + if (tempPath.length() >= PATH_MAX) + { + ec.assign(EOVERFLOW, std::system_category()); + return std::string(); + } + + strncpy(tmp, tempPath.c_str(), sizeof(tmp) - 1); + tmp[sizeof(tmp) - 1] = '\0'; + + auto fd = mkstemps(tmp, suffix.length()); + if (fd < 0) + { + ec.assign(errno, std::system_category()); + return std::string(); + } + + close(fd); + + ec.clear(); + return std::string(tmp); +} + +} +} +} diff --git a/xbmc/platform/posix/MessagePrinter.cpp b/xbmc/platform/posix/MessagePrinter.cpp new file mode 100644 index 0000000..6621740 --- /dev/null +++ b/xbmc/platform/posix/MessagePrinter.cpp @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "platform/MessagePrinter.h" + +#include "CompileInfo.h" + +#include <stdio.h> + +void CMessagePrinter::DisplayMessage(const std::string& message) +{ + fprintf(stdout, "%s\n", message.c_str()); +} + +void CMessagePrinter::DisplayWarning(const std::string& warning) +{ + fprintf(stderr, "%s\n", warning.c_str()); +} + +void CMessagePrinter::DisplayError(const std::string& error) +{ + fprintf(stderr,"%s\n", error.c_str()); +} + +void CMessagePrinter::DisplayHelpMessage(const std::vector<std::pair<std::string, std::string>>& help) +{ + //very crude implementation, pretty it up when possible + std::string message; + for (const auto& line : help) + { + message.append(line.first + "\t" + line.second + "\n"); + } + + fprintf(stdout, "%s\n", message.c_str()); +} diff --git a/xbmc/platform/posix/PlatformDefs.h b/xbmc/platform/posix/PlatformDefs.h new file mode 100644 index 0000000..e6e59fe --- /dev/null +++ b/xbmc/platform/posix/PlatformDefs.h @@ -0,0 +1,153 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <unistd.h> +#include <pthread.h> +#include <string.h> +#if defined(TARGET_DARWIN) +#include <stdio.h> +#include <sched.h> +#include <AvailabilityMacros.h> +#ifndef __STDC_FORMAT_MACROS + #define __STDC_FORMAT_MACROS +#endif +#include <sys/sysctl.h> +#include <mach/mach.h> +#if defined(TARGET_DARWIN_OSX) +#include <libkern/OSTypes.h> +#endif + +#elif defined(TARGET_FREEBSD) +#include <stdio.h> +#include <sys/sysctl.h> +#else +#include <sys/sysinfo.h> +#endif + +#include <sys/time.h> +#include <time.h> + +#if defined(__ppc__) || defined(__powerpc__) +#define PIXEL_ASHIFT 0 +#define PIXEL_RSHIFT 8 +#define PIXEL_GSHIFT 16 +#define PIXEL_BSHIFT 24 +#else +#define PIXEL_ASHIFT 24 +#define PIXEL_RSHIFT 16 +#define PIXEL_GSHIFT 8 +#define PIXEL_BSHIFT 0 +#endif + +#include <stdint.h> + +#define _fdopen fdopen +#define _vsnprintf vsnprintf + +#define __stdcall +#define __cdecl +#define WINAPI __stdcall +#undef APIENTRY +struct CXHandle; // forward declaration +typedef CXHandle* HANDLE; + +typedef void* HINSTANCE; +typedef void* HMODULE; + +typedef unsigned int DWORD; +#define INVALID_HANDLE_VALUE ((HANDLE)~0U) + +#define MAXWORD 0xffff + +typedef union _LARGE_INTEGER +{ + struct { + DWORD LowPart; + int32_t HighPart; + } u; + long long QuadPart; +} LARGE_INTEGER, *PLARGE_INTEGER; + + typedef union _ULARGE_INTEGER { + struct { + DWORD LowPart; + DWORD HighPart; + } u; + unsigned long long QuadPart; +} ULARGE_INTEGER; + +// Network +#define SOCKET_ERROR (-1) +#define INVALID_SOCKET (~0) +#define closesocket(s) close(s) +#define ioctlsocket(s, f, v) ioctl(s, f, v) +#define WSAGetLastError() (errno) +#define WSAECONNRESET ECONNRESET + +typedef int SOCKET; + +// Thread +typedef int (*LPTHREAD_START_ROUTINE)(void *); + +// File +#define O_BINARY 0 +#define _O_TRUNC O_TRUNC +#define _O_RDONLY O_RDONLY +#define _O_WRONLY O_WRONLY + +#if defined(TARGET_DARWIN) || defined(TARGET_FREEBSD) + #define stat64 stat + #define __stat64 stat + #define fstat64 fstat + typedef int64_t off64_t; + #if defined(TARGET_FREEBSD) + #define statfs64 statfs + #endif +#else + #define __stat64 stat64 +#endif + +struct _stati64 { + dev_t st_dev; + ino_t st_ino; + unsigned short st_mode; + short st_nlink; + short st_uid; + short st_gid; + dev_t st_rdev; + long long st_size; + time_t _st_atime; + time_t _st_mtime; + time_t _st_ctime; +}; + +#define FILE_BEGIN 0 +#define FILE_CURRENT 1 +#define FILE_END 2 + +#define _S_IFREG S_IFREG +#define _S_IFDIR S_IFDIR +#define MAX_PATH PATH_MAX + +// CreateFile defines +#define FILE_FLAG_NO_BUFFERING 0x20000000 +#define FILE_FLAG_DELETE_ON_CLOSE 0x04000000 + +#define CREATE_NEW 1 +#define CREATE_ALWAYS 2 +#define OPEN_EXISTING 3 +#define OPEN_ALWAYS 4 +#define TRUNCATE_EXISTING 5 + +#define FILE_READ_DATA ( 0x0001 ) +#define FILE_WRITE_DATA ( 0x0002 ) diff --git a/xbmc/platform/posix/PlatformPosix.cpp b/xbmc/platform/posix/PlatformPosix.cpp new file mode 100644 index 0000000..b1caa26 --- /dev/null +++ b/xbmc/platform/posix/PlatformPosix.cpp @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2019 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "PlatformPosix.h" + +#include "filesystem/SpecialProtocol.h" + +#include <cstdlib> +#include <time.h> + +#ifdef HAS_DBUS +#include <dbus/dbus.h> +#endif + +std::atomic_flag CPlatformPosix::ms_signalFlag; + +bool CPlatformPosix::InitStageOne() +{ + + if (!CPlatform::InitStageOne()) + return false; + + // Initialize to "set" state + ms_signalFlag.test_and_set(); + + // Initialize timezone information variables + tzset(); + + // set special://envhome + if (getenv("HOME")) + { + CSpecialProtocol::SetEnvHomePath(getenv("HOME")); + } + else + { + fprintf(stderr, "The HOME environment variable is not set!\n"); + return false; + } + +#ifdef HAS_DBUS + // call 'dbus_threads_init_default' before any other dbus calls in order to + // avoid race conditions with other threads using dbus connections + dbus_threads_init_default(); +#endif + + return true; +} + +bool CPlatformPosix::TestQuitFlag() +{ + // Keep set, return true when it was cleared before + return !ms_signalFlag.test_and_set(); +} + +void CPlatformPosix::RequestQuit() +{ + ms_signalFlag.clear(); +} diff --git a/xbmc/platform/posix/PlatformPosix.h b/xbmc/platform/posix/PlatformPosix.h new file mode 100644 index 0000000..08513b9 --- /dev/null +++ b/xbmc/platform/posix/PlatformPosix.h @@ -0,0 +1,25 @@ +/* + * Copyright (C) 2019 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "platform/Platform.h" + +#include <atomic> + +class CPlatformPosix : public CPlatform +{ +public: + bool InitStageOne() override; + + static bool TestQuitFlag(); + static void RequestQuit(); + +private: + static std::atomic_flag ms_signalFlag; +}; diff --git a/xbmc/platform/posix/PosixMountProvider.cpp b/xbmc/platform/posix/PosixMountProvider.cpp new file mode 100644 index 0000000..d139be1 --- /dev/null +++ b/xbmc/platform/posix/PosixMountProvider.cpp @@ -0,0 +1,144 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "PosixMountProvider.h" + +#include "utils/RegExp.h" +#include "utils/URIUtils.h" +#include "utils/log.h" + +#include <cstdlib> + +CPosixMountProvider::CPosixMountProvider() +{ + m_removableLength = 0; + PumpDriveChangeEvents(NULL); +} + +void CPosixMountProvider::Initialize() +{ + CLog::Log(LOGDEBUG, "Selected Posix mount as storage provider"); +} + +void CPosixMountProvider::GetDrives(VECSOURCES &drives) +{ + std::vector<std::string> result; + + CRegExp reMount; +#if defined(TARGET_DARWIN) || defined(TARGET_FREEBSD) + reMount.RegComp("on (.+) \\(([^,]+)"); +#else + reMount.RegComp("on (.+) type ([^ ]+)"); +#endif + char line[1024]; + + FILE* pipe = popen("mount", "r"); + + if (pipe) + { + while (fgets(line, sizeof(line) - 1, pipe)) + { + if (reMount.RegFind(line) != -1) + { + bool accepted = false; + std::string mountStr = reMount.GetReplaceString("\\1"); + std::string fsStr = reMount.GetReplaceString("\\2"); + const char* mount = mountStr.c_str(); + const char* fs = fsStr.c_str(); + + // Here we choose which filesystems are approved + if (strcmp(fs, "fuseblk") == 0 || strcmp(fs, "vfat") == 0 + || strcmp(fs, "ext2") == 0 || strcmp(fs, "ext3") == 0 + || strcmp(fs, "reiserfs") == 0 || strcmp(fs, "xfs") == 0 + || strcmp(fs, "ntfs-3g") == 0 || strcmp(fs, "iso9660") == 0 + || strcmp(fs, "exfat") == 0 + || strcmp(fs, "fusefs") == 0 || strcmp(fs, "hfs") == 0) + accepted = true; + + // Ignore root + if (strcmp(mount, "/") == 0) + accepted = false; + + if(accepted) + result.emplace_back(mount); + } + } + pclose(pipe); + } + + for (unsigned int i = 0; i < result.size(); i++) + { + CMediaSource share; + share.strPath = result[i]; + share.strName = URIUtils::GetFileName(result[i]); + share.m_ignore = true; + drives.push_back(share); + } +} + +std::vector<std::string> CPosixMountProvider::GetDiskUsage() +{ + std::vector<std::string> result; + char line[1024]; + +#if defined(TARGET_DARWIN) + FILE* pipe = popen("df -hT ufs,cd9660,hfs,udf", "r"); +#elif defined(TARGET_FREEBSD) + FILE* pipe = popen("df -h -t ufs,cd9660,hfs,udf,zfs", "r"); +#else + FILE* pipe = popen("df -h", "r"); +#endif + + static const char* excludes[] = {"rootfs","devtmpfs","tmpfs","none","/dev/loop", "udev", NULL}; + + if (pipe) + { + while (fgets(line, sizeof(line) - 1, pipe)) + { + bool ok=true; + for (int i=0;excludes[i];++i) + { + if (strstr(line,excludes[i])) + { + ok=false; + break; + } + } + if (ok) + result.emplace_back(line); + } + pclose(pipe); + } + + return result; +} + +bool CPosixMountProvider::Eject(const std::string& mountpath) +{ + +#if !defined(TARGET_DARWIN_EMBEDDED) + // just go ahead and try to umount the disk + // if it does umount, life is good, if not, no loss. + std::string cmd = "umount \"" + mountpath + "\""; + int status = system(cmd.c_str()); + + if (status == 0) + return true; +#endif + + return false; +} + +bool CPosixMountProvider::PumpDriveChangeEvents(IStorageEventsCallback *callback) +{ + VECSOURCES drives; + GetRemovableDrives(drives); + bool changed = drives.size() != m_removableLength; + m_removableLength = drives.size(); + return changed; +} diff --git a/xbmc/platform/posix/PosixMountProvider.h b/xbmc/platform/posix/PosixMountProvider.h new file mode 100644 index 0000000..170c644 --- /dev/null +++ b/xbmc/platform/posix/PosixMountProvider.h @@ -0,0 +1,37 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "storage/IStorageProvider.h" + +#include <string> +#include <vector> + +class CPosixMountProvider : public IStorageProvider +{ +public: + CPosixMountProvider(); + ~CPosixMountProvider() override = default; + + void Initialize() override; + void Stop() override { } + + void GetLocalDrives(VECSOURCES &localDrives) override { GetDrives(localDrives); } + void GetRemovableDrives(VECSOURCES &removableDrives) override { /*GetDrives(removableDrives);*/ } + + std::vector<std::string> GetDiskUsage() override; + + bool Eject(const std::string& mountpath) override; + + bool PumpDriveChangeEvents(IStorageEventsCallback *callback) override; +private: + void GetDrives(VECSOURCES &drives); + + unsigned int m_removableLength; +}; diff --git a/xbmc/platform/posix/PosixResourceCounter.cpp b/xbmc/platform/posix/PosixResourceCounter.cpp new file mode 100644 index 0000000..d82ef72 --- /dev/null +++ b/xbmc/platform/posix/PosixResourceCounter.cpp @@ -0,0 +1,71 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "PosixResourceCounter.h" + +#include "utils/log.h" + +#include <errno.h> + +#include "PlatformDefs.h" + +CPosixResourceCounter::CPosixResourceCounter() +{ + Reset(); +} + +CPosixResourceCounter::~CPosixResourceCounter() = default; + +double CPosixResourceCounter::GetCPUUsage() +{ + struct timeval tmNow; + if (gettimeofday(&tmNow, NULL) == -1) + CLog::Log(LOGERROR, "error {} in gettimeofday", errno); + else + { + double dElapsed = ( ((double)tmNow.tv_sec + (double)tmNow.tv_usec / 1000000.0) - + ((double)m_tmLastCheck.tv_sec + (double)m_tmLastCheck.tv_usec / 1000000.0) ); + + if (dElapsed >= 3.0) + { + struct rusage usage; + if (getrusage(RUSAGE_SELF, &usage) == -1) + CLog::Log(LOGERROR, "error {} in getrusage", errno); + else + { + double dUser = ( ((double)usage.ru_utime.tv_sec + (double)usage.ru_utime.tv_usec / 1000000.0) - + ((double)m_usage.ru_utime.tv_sec + (double)m_usage.ru_utime.tv_usec / 1000000.0) ); + double dSys = ( ((double)usage.ru_stime.tv_sec + (double)usage.ru_stime.tv_usec / 1000000.0) - + ((double)m_usage.ru_stime.tv_sec + (double)m_usage.ru_stime.tv_usec / 1000000.0) ); + + m_tmLastCheck = tmNow; + m_usage = usage; + m_dLastUsage = ((dUser+dSys) / dElapsed) * 100.0; + return m_dLastUsage; + } + } + } + + return m_dLastUsage; +} + +void CPosixResourceCounter::Reset() +{ + if (gettimeofday(&m_tmLastCheck, NULL) == -1) + CLog::Log(LOGERROR, "error {} in gettimeofday", errno); + + if (getrusage(RUSAGE_SELF, &m_usage) == -1) + CLog::Log(LOGERROR, "error {} in getrusage", errno); + + m_dLastUsage = 0.0; +} + + + + + diff --git a/xbmc/platform/posix/PosixResourceCounter.h b/xbmc/platform/posix/PosixResourceCounter.h new file mode 100644 index 0000000..ef61b15 --- /dev/null +++ b/xbmc/platform/posix/PosixResourceCounter.h @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include <time.h> + +#include <sys/resource.h> +#include <sys/time.h> +#include <sys/times.h> + +class CPosixResourceCounter +{ +public: + CPosixResourceCounter(); + virtual ~CPosixResourceCounter(); + + double GetCPUUsage(); + void Reset(); + +protected: + struct rusage m_usage; + struct timeval m_tmLastCheck; + double m_dLastUsage; +}; + diff --git a/xbmc/platform/posix/PosixTimezone.cpp b/xbmc/platform/posix/PosixTimezone.cpp new file mode 100644 index 0000000..6f276a3 --- /dev/null +++ b/xbmc/platform/posix/PosixTimezone.cpp @@ -0,0 +1,272 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include <time.h> +#ifdef TARGET_ANDROID +#include "platform/android/bionic_supplement/bionic_supplement.h" +#endif +#include "PlatformDefs.h" +#include "PosixTimezone.h" +#include "utils/SystemInfo.h" + +#include "ServiceBroker.h" +#include "utils/StringUtils.h" +#include "XBDateTime.h" +#include "settings/lib/Setting.h" +#include "settings/lib/SettingDefinitions.h" +#include "settings/Settings.h" +#include "settings/SettingsComponent.h" +#include <stdlib.h> + +#include <algorithm> + +CPosixTimezone::CPosixTimezone() +{ + char* line = NULL; + size_t linelen = 0; + int nameonfourthfield = 0; + std::string s; + std::vector<std::string> tokens; + + // Load timezones + FILE* fp = fopen("/usr/share/zoneinfo/zone.tab", "r"); + if (fp) + { + std::string countryCode; + std::string timezoneName; + + while (getdelim(&line, &linelen, '\n', fp) > 0) + { + tokens.clear(); + s = line; + StringUtils::Trim(s); + + if (s.length() == 0) + continue; + + if (s[0] == '#') + continue; + + StringUtils::Tokenize(s, tokens, " \t"); + if (tokens.size() < 3) + continue; + + countryCode = tokens[0]; + timezoneName = tokens[2]; + + if (m_timezonesByCountryCode.count(countryCode) == 0) + { + std::vector<std::string> timezones; + timezones.push_back(timezoneName); + m_timezonesByCountryCode[countryCode] = timezones; + } + else + { + std::vector<std::string>& timezones = m_timezonesByCountryCode[countryCode]; + timezones.push_back(timezoneName); + } + + m_countriesByTimezoneName[timezoneName] = countryCode; + } + fclose(fp); + } + + if (line) + { + free(line); + line = NULL; + linelen = 0; + } + + // Load countries + fp = fopen("/usr/share/zoneinfo/iso3166.tab", "r"); + if (!fp) + { + fp = fopen("/usr/share/misc/iso3166", "r"); + nameonfourthfield = 1; + } + if (fp) + { + std::string countryCode; + std::string countryName; + + while (getdelim(&line, &linelen, '\n', fp) > 0) + { + s = line; + StringUtils::Trim(s); + + //! @todo STRING_CLEANUP + if (s.length() == 0) + continue; + + if (s[0] == '#') + continue; + + // Search for the first non space from the 2nd character and on + int i = 2; + while (s[i] == ' ' || s[i] == '\t') i++; + + if (nameonfourthfield) + { + // skip three letter + while (s[i] != ' ' && s[i] != '\t') i++; + while (s[i] == ' ' || s[i] == '\t') i++; + // skip number + while (s[i] != ' ' && s[i] != '\t') i++; + while (s[i] == ' ' || s[i] == '\t') i++; + } + + countryCode = s.substr(0, 2); + countryName = s.substr(i); + + m_counties.push_back(countryName); + m_countryByCode[countryCode] = countryName; + m_countryByName[countryName] = countryCode; + } + sort(m_counties.begin(), m_counties.end(), sortstringbyname()); + fclose(fp); + } + free(line); +} + +void CPosixTimezone::OnSettingChanged(const std::shared_ptr<const CSetting>& setting) +{ + if (setting == NULL) + return; + + const std::string &settingId = setting->GetId(); + if (settingId == CSettings::SETTING_LOCALE_TIMEZONE) + { + SetTimezone(std::static_pointer_cast<const CSettingString>(setting)->GetValue()); + + CDateTime::ResetTimezoneBias(); + } + else if (settingId == CSettings::SETTING_LOCALE_TIMEZONECOUNTRY) + { + // nothing to do here. Changing locale.timezonecountry will trigger an + // update of locale.timezone and automatically adjust its value + // and execute OnSettingChanged() for it as well (see above) + } +} + +void CPosixTimezone::OnSettingsLoaded() +{ + SetTimezone(CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_LOCALE_TIMEZONE)); + CDateTime::ResetTimezoneBias(); +} + +std::vector<std::string> CPosixTimezone::GetCounties() +{ + return m_counties; +} + +std::vector<std::string> CPosixTimezone::GetTimezonesByCountry(const std::string& country) +{ + return m_timezonesByCountryCode[m_countryByName[country]]; +} + +std::string CPosixTimezone::GetCountryByTimezone(const std::string& timezone) +{ +#if defined(TARGET_DARWIN) + return "?"; +#else + return m_countryByCode[m_countriesByTimezoneName[timezone]]; +#endif +} + +void CPosixTimezone::SetTimezone(const std::string& timezoneName) +{ +#if !defined(TARGET_DARWIN) + bool use_timezone = true; +#else + bool use_timezone = false; +#endif + + if (use_timezone) + { + static char env_var[255]; + sprintf(env_var, "TZ=:%s", timezoneName.c_str()); + putenv(env_var); + tzset(); + } +} + +std::string CPosixTimezone::GetOSConfiguredTimezone() +{ + char timezoneName[255]; + + // try Slackware approach first + ssize_t rlrc = readlink("/etc/localtime-copied-from" + , timezoneName, sizeof(timezoneName)-1); + + // RHEL and maybe other distros make /etc/localtime a symlink + if (rlrc == -1) + rlrc = readlink("/etc/localtime", timezoneName, sizeof(timezoneName)-1); + + if (rlrc != -1) + { + timezoneName[rlrc] = '\0'; + + char* p = strrchr(timezoneName,'/'); + if (p) + { // we want the previous '/' + char* q = p; + *q = 0; + p = strrchr(timezoneName,'/'); + *q = '/'; + if (p) + p++; + } + return p; + } + + // now try Debian approach + timezoneName[0] = 0; + FILE* fp = fopen("/etc/timezone", "r"); + if (fp) + { + if (fgets(timezoneName, sizeof(timezoneName), fp)) + timezoneName[strlen(timezoneName)-1] = '\0'; + fclose(fp); + } + + return timezoneName; +} + +void CPosixTimezone::SettingOptionsTimezoneCountriesFiller( + const std::shared_ptr<const CSetting>& setting, + std::vector<StringSettingOption>& list, + std::string& current, + void* data) +{ + std::vector<std::string> countries = g_timezone.GetCounties(); + for (unsigned int i = 0; i < countries.size(); i++) + list.emplace_back(countries[i], countries[i]); +} + +void CPosixTimezone::SettingOptionsTimezonesFiller(const std::shared_ptr<const CSetting>& setting, + std::vector<StringSettingOption>& list, + std::string& current, + void* data) +{ + current = std::static_pointer_cast<const CSettingString>(setting)->GetValue(); + bool found = false; + std::vector<std::string> timezones = g_timezone.GetTimezonesByCountry(CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_LOCALE_TIMEZONECOUNTRY)); + for (unsigned int i = 0; i < timezones.size(); i++) + { + if (!found && StringUtils::EqualsNoCase(timezones[i], current)) + found = true; + + list.emplace_back(timezones[i], timezones[i]); + } + + if (!found && !timezones.empty()) + current = timezones[0]; +} + +CPosixTimezone g_timezone; diff --git a/xbmc/platform/posix/PosixTimezone.h b/xbmc/platform/posix/PosixTimezone.h new file mode 100644 index 0000000..076e87f --- /dev/null +++ b/xbmc/platform/posix/PosixTimezone.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "settings/lib/ISettingCallback.h" +#include "settings/lib/ISettingsHandler.h" + +#include <map> +#include <string> +#include <vector> + +class CSetting; +struct StringSettingOption; + +class CPosixTimezone : public ISettingCallback, public ISettingsHandler +{ +public: + CPosixTimezone(); + + void OnSettingChanged(const std::shared_ptr<const CSetting>& setting) override; + + void OnSettingsLoaded() override; + + std::string GetOSConfiguredTimezone(); + + std::vector<std::string> GetCounties(); + std::vector<std::string> GetTimezonesByCountry(const std::string& country); + std::string GetCountryByTimezone(const std::string& timezone); + + void SetTimezone(const std::string& timezone); + int m_IsDST = 0; + + static void SettingOptionsTimezoneCountriesFiller(const std::shared_ptr<const CSetting>& setting, + std::vector<StringSettingOption>& list, + std::string& current, + void* data); + static void SettingOptionsTimezonesFiller(const std::shared_ptr<const CSetting>& setting, + std::vector<StringSettingOption>& list, + std::string& current, + void* data); + +private: + std::vector<std::string> m_counties; + std::map<std::string, std::string> m_countryByCode; + std::map<std::string, std::string> m_countryByName; + + std::map<std::string, std::vector<std::string> > m_timezonesByCountryCode; + std::map<std::string, std::string> m_countriesByTimezoneName; +}; + +extern CPosixTimezone g_timezone; + diff --git a/xbmc/platform/posix/XHandle.cpp b/xbmc/platform/posix/XHandle.cpp new file mode 100644 index 0000000..be7a78b --- /dev/null +++ b/xbmc/platform/posix/XHandle.cpp @@ -0,0 +1,138 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "XHandle.h" + +#include "utils/log.h" + +#include <cassert> +#include <mutex> + +int CXHandle::m_objectTracker[10] = {}; + +HANDLE WINAPI GetCurrentProcess(void) { + return (HANDLE)-1; // -1 a special value - pseudo handle +} + +CXHandle::CXHandle() +{ + Init(); + m_objectTracker[m_type]++; +} + +CXHandle::CXHandle(HandleType nType) +{ + Init(); + m_type=nType; + m_objectTracker[m_type]++; +} + +CXHandle::CXHandle(const CXHandle &src) +{ + // we shouldn't get here EVER. however, if we do - try to make the best. copy what we can + // and most importantly - not share any pointer. + CLog::Log(LOGWARNING, "{}, copy handle.", __FUNCTION__); + + Init(); + + if (src.m_hMutex) + m_hMutex = new CCriticalSection(); + + fd = src.fd; + m_bManualEvent = src.m_bManualEvent; + m_tmCreation = time(NULL); + m_FindFileResults = src.m_FindFileResults; + m_nFindFileIterator = src.m_nFindFileIterator; + m_FindFileDir = src.m_FindFileDir; + m_iOffset = src.m_iOffset; + m_bCDROM = src.m_bCDROM; + m_objectTracker[m_type]++; +} + +CXHandle::~CXHandle() +{ + + m_objectTracker[m_type]--; + + if (RecursionCount > 0) { + CLog::Log(LOGERROR, "{}, destroying handle with recursion count {}", __FUNCTION__, + RecursionCount); + assert(false); + } + + if (m_nRefCount > 1) { + CLog::Log(LOGERROR, "{}, destroying handle with ref count {}", __FUNCTION__, m_nRefCount); + assert(false); + } + + if (m_hMutex) { + delete m_hMutex; + } + + if (m_internalLock) { + delete m_internalLock; + } + + if (m_hCond) { + delete m_hCond; + } + + if ( fd != 0 ) { + close(fd); + } + +} + +void CXHandle::Init() +{ + fd=0; + m_hMutex=NULL; + m_hCond=NULL; + m_type = HND_NULL; + RecursionCount=0; + m_bManualEvent=false; + m_bEventSet=false; + m_nFindFileIterator=0 ; + m_nRefCount=1; + m_tmCreation = time(NULL); + m_internalLock = new CCriticalSection(); +} + +void CXHandle::ChangeType(HandleType newType) { + m_objectTracker[m_type]--; + m_type = newType; + m_objectTracker[m_type]++; +} + +void CXHandle::DumpObjectTracker() { + for (int i=0; i< 10; i++) { + CLog::Log(LOGDEBUG, "object {} --> {} instances", i, m_objectTracker[i]); + } +} + +bool CloseHandle(HANDLE hObject) { + if (!hObject) + return false; + + if (hObject == INVALID_HANDLE_VALUE || hObject == (HANDLE)-1) + return true; + + bool bDelete = false; + { + std::unique_lock<CCriticalSection> lock((*hObject->m_internalLock)); + if (--hObject->m_nRefCount == 0) + bDelete = true; + } + + if (bDelete) + delete hObject; + + return true; +} + + diff --git a/xbmc/platform/posix/XHandle.h b/xbmc/platform/posix/XHandle.h new file mode 100644 index 0000000..158817e --- /dev/null +++ b/xbmc/platform/posix/XHandle.h @@ -0,0 +1,59 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "XHandlePublic.h" +#include "threads/Condition.h" +#include "threads/CriticalSection.h" + +#include <list> +#include <string> +#include <vector> + +#include "PlatformDefs.h" + +struct CXHandle { + +public: + typedef enum { HND_NULL = 0, HND_FILE, HND_EVENT, HND_MUTEX, HND_FIND_FILE } HandleType; + + CXHandle(); + explicit CXHandle(HandleType nType); + CXHandle(const CXHandle &src); + + virtual ~CXHandle(); + void Init(); + inline HandleType GetType() { return m_type; } + void ChangeType(HandleType newType); + + XbmcThreads::ConditionVariable *m_hCond; + std::list<CXHandle*> m_hParents; + + // simulate mutex and critical section + CCriticalSection *m_hMutex; + int RecursionCount; // for mutex - for compatibility with TARGET_WINDOWS critical section + int fd; + bool m_bManualEvent; + time_t m_tmCreation; + std::vector<std::string> m_FindFileResults; + int m_nFindFileIterator; + std::string m_FindFileDir; + off64_t m_iOffset; + bool m_bCDROM; + bool m_bEventSet; + int m_nRefCount; + CCriticalSection *m_internalLock; + + static void DumpObjectTracker(); + +protected: + HandleType m_type; + static int m_objectTracker[10]; + +}; diff --git a/xbmc/platform/posix/XHandlePublic.h b/xbmc/platform/posix/XHandlePublic.h new file mode 100644 index 0000000..6d1f840 --- /dev/null +++ b/xbmc/platform/posix/XHandlePublic.h @@ -0,0 +1,19 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +struct CXHandle; +typedef CXHandle* HANDLE; +typedef HANDLE* LPHANDLE; + +bool CloseHandle(HANDLE hObject); + +#define DUPLICATE_CLOSE_SOURCE 0x00000001 +#define DUPLICATE_SAME_ACCESS 0x00000002 + diff --git a/xbmc/platform/posix/XTimeUtils.cpp b/xbmc/platform/posix/XTimeUtils.cpp new file mode 100644 index 0000000..e78e5cf --- /dev/null +++ b/xbmc/platform/posix/XTimeUtils.cpp @@ -0,0 +1,228 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "utils/XTimeUtils.h" + +#include "PosixTimezone.h" + +#include <errno.h> +#include <mutex> +#include <time.h> + +#include <sys/times.h> + +#if defined(TARGET_ANDROID) && !defined(__LP64__) +#include <time64.h> +#endif + +#define WIN32_TIME_OFFSET ((unsigned long long)(369 * 365 + 89) * 24 * 3600 * 10000000) + +namespace KODI +{ +namespace TIME +{ + +/* + * A Leap year is any year that is divisible by four, but not by 100 unless also + * divisible by 400 + */ +#define IsLeapYear(y) ((!(y % 4)) ? (((!(y % 400)) && (y % 100)) ? 1 : 0) : 0) + +uint32_t GetTimeZoneInformation(TimeZoneInformation* timeZoneInformation) +{ + if (!timeZoneInformation) + return KODI_TIME_ZONE_ID_INVALID; + + struct tm t; + time_t tt = time(NULL); + if (localtime_r(&tt, &t)) + timeZoneInformation->bias = -t.tm_gmtoff / 60; + + timeZoneInformation->standardName = tzname[0]; + timeZoneInformation->daylightName = tzname[1]; + + return KODI_TIME_ZONE_ID_UNKNOWN; +} + +void GetLocalTime(SystemTime* systemTime) +{ + const time_t t = time(NULL); + struct tm now; + + localtime_r(&t, &now); + systemTime->year = now.tm_year + 1900; + systemTime->month = now.tm_mon + 1; + systemTime->dayOfWeek = now.tm_wday; + systemTime->day = now.tm_mday; + systemTime->hour = now.tm_hour; + systemTime->minute = now.tm_min; + systemTime->second = now.tm_sec; + systemTime->milliseconds = 0; + // NOTE: localtime_r() is not required to set this, but we Assume that it's set here. + g_timezone.m_IsDST = now.tm_isdst; +} + +int FileTimeToLocalFileTime(const FileTime* fileTime, FileTime* localFileTime) +{ + ULARGE_INTEGER l; + l.u.LowPart = fileTime->lowDateTime; + l.u.HighPart = fileTime->highDateTime; + + time_t ft; + struct tm tm_ft; + FileTimeToTimeT(fileTime, &ft); + localtime_r(&ft, &tm_ft); + + l.QuadPart += static_cast<unsigned long long>(tm_ft.tm_gmtoff) * 10000000; + + localFileTime->lowDateTime = l.u.LowPart; + localFileTime->highDateTime = l.u.HighPart; + return 1; +} + +int SystemTimeToFileTime(const SystemTime* systemTime, FileTime* fileTime) +{ + static const int dayoffset[12] = {0, 31, 59, 90, 120, 151, 182, 212, 243, 273, 304, 334}; +#if defined(TARGET_DARWIN) + static std::mutex timegm_lock; +#endif + + struct tm sysTime = {}; + sysTime.tm_year = systemTime->year - 1900; + sysTime.tm_mon = systemTime->month - 1; + sysTime.tm_wday = systemTime->dayOfWeek; + sysTime.tm_mday = systemTime->day; + sysTime.tm_hour = systemTime->hour; + sysTime.tm_min = systemTime->minute; + sysTime.tm_sec = systemTime->second; + sysTime.tm_yday = dayoffset[sysTime.tm_mon] + (sysTime.tm_mday - 1); + sysTime.tm_isdst = g_timezone.m_IsDST; + + // If this is a leap year, and we're past the 28th of Feb, increment tm_yday. + if (IsLeapYear(systemTime->year) && (sysTime.tm_yday > 58)) + sysTime.tm_yday++; + +#if defined(TARGET_DARWIN) + std::lock_guard<std::mutex> lock(timegm_lock); +#endif + +#if defined(TARGET_ANDROID) && !defined(__LP64__) + time64_t t = timegm64(&sysTime); +#else + time_t t = timegm(&sysTime); +#endif + + LARGE_INTEGER result; + result.QuadPart = (long long)t * 10000000 + (long long)systemTime->milliseconds * 10000; + result.QuadPart += WIN32_TIME_OFFSET; + + fileTime->lowDateTime = result.u.LowPart; + fileTime->highDateTime = result.u.HighPart; + + return 1; +} + +long CompareFileTime(const FileTime* fileTime1, const FileTime* fileTime2) +{ + ULARGE_INTEGER t1; + t1.u.LowPart = fileTime1->lowDateTime; + t1.u.HighPart = fileTime1->highDateTime; + + ULARGE_INTEGER t2; + t2.u.LowPart = fileTime2->lowDateTime; + t2.u.HighPart = fileTime2->highDateTime; + + if (t1.QuadPart == t2.QuadPart) + return 0; + else if (t1.QuadPart < t2.QuadPart) + return -1; + else + return 1; +} + +int FileTimeToSystemTime(const FileTime* fileTime, SystemTime* systemTime) +{ + LARGE_INTEGER file; + file.u.LowPart = fileTime->lowDateTime; + file.u.HighPart = fileTime->highDateTime; + + file.QuadPart -= WIN32_TIME_OFFSET; + file.QuadPart /= 10000; /* to milliseconds */ + systemTime->milliseconds = file.QuadPart % 1000; + file.QuadPart /= 1000; /* to seconds */ + + time_t ft = file.QuadPart; + + struct tm tm_ft; + gmtime_r(&ft, &tm_ft); + + systemTime->year = tm_ft.tm_year + 1900; + systemTime->month = tm_ft.tm_mon + 1; + systemTime->dayOfWeek = tm_ft.tm_wday; + systemTime->day = tm_ft.tm_mday; + systemTime->hour = tm_ft.tm_hour; + systemTime->minute = tm_ft.tm_min; + systemTime->second = tm_ft.tm_sec; + + return 1; +} + +int LocalFileTimeToFileTime(const FileTime* localFileTime, FileTime* fileTime) +{ + ULARGE_INTEGER l; + l.u.LowPart = localFileTime->lowDateTime; + l.u.HighPart = localFileTime->highDateTime; + + l.QuadPart += (unsigned long long) timezone * 10000000; + + fileTime->lowDateTime = l.u.LowPart; + fileTime->highDateTime = l.u.HighPart; + + return 1; +} + + +int FileTimeToTimeT(const FileTime* localFileTime, time_t* pTimeT) +{ + if (!localFileTime || !pTimeT) + return false; + + ULARGE_INTEGER fileTime; + fileTime.u.LowPart = localFileTime->lowDateTime; + fileTime.u.HighPart = localFileTime->highDateTime; + + fileTime.QuadPart -= WIN32_TIME_OFFSET; + fileTime.QuadPart /= 10000; /* to milliseconds */ + fileTime.QuadPart /= 1000; /* to seconds */ + + time_t ft = fileTime.QuadPart; + + struct tm tm_ft; + localtime_r(&ft, &tm_ft); + + *pTimeT = mktime(&tm_ft); + return 1; +} + +int TimeTToFileTime(time_t timeT, FileTime* localFileTime) +{ + if (!localFileTime) + return false; + + ULARGE_INTEGER result; + result.QuadPart = (unsigned long long) timeT * 10000000; + result.QuadPart += WIN32_TIME_OFFSET; + + localFileTime->lowDateTime = result.u.LowPart; + localFileTime->highDateTime = result.u.HighPart; + + return 1; +} + +} // namespace TIME +} // namespace KODI diff --git a/xbmc/platform/posix/filesystem/CMakeLists.txt b/xbmc/platform/posix/filesystem/CMakeLists.txt new file mode 100644 index 0000000..badb1a8 --- /dev/null +++ b/xbmc/platform/posix/filesystem/CMakeLists.txt @@ -0,0 +1,18 @@ +set(SOURCES PosixDirectory.cpp + PosixFile.cpp) + +set(HEADERS PosixDirectory.h + PosixFile.h) + +if(SMBCLIENT_FOUND) + list(APPEND SOURCES SMBDirectory.cpp + SMBFile.cpp + SMBWSDiscovery.cpp + SMBWSDiscoveryListener.cpp) + list(APPEND HEADERS SMBDirectory.h + SMBFile.h + SMBWSDiscovery.h + SMBWSDiscoveryListener.h) +endif() + +core_add_library(platform_posix_filesystem) diff --git a/xbmc/platform/posix/filesystem/PosixDirectory.cpp b/xbmc/platform/posix/filesystem/PosixDirectory.cpp new file mode 100644 index 0000000..6685c0e --- /dev/null +++ b/xbmc/platform/posix/filesystem/PosixDirectory.cpp @@ -0,0 +1,207 @@ +/* + * Copyright (C) 2014-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "PosixDirectory.h" + +#include "FileItem.h" +#include "URL.h" +#include "utils/AliasShortcutUtils.h" +#include "utils/CharsetConverter.h" +#include "utils/StringUtils.h" +#include "utils/URIUtils.h" +#include "utils/XTimeUtils.h" + +#include <dirent.h> +#include <sys/stat.h> + +using namespace XFILE; + +CPosixDirectory::CPosixDirectory(void) = default; + +CPosixDirectory::~CPosixDirectory(void) = default; + +bool CPosixDirectory::GetDirectory(const CURL& url, CFileItemList &items) +{ + std::string root = url.Get(); + + if (IsAliasShortcut(root, true)) + TranslateAliasShortcut(root); + + DIR *dir = opendir(root.c_str()); + if (!dir) + return false; + + struct dirent* entry; + while ((entry = readdir(dir)) != NULL) + { + if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) + continue; + + std::string itemLabel(entry->d_name); + CCharsetConverter::unknownToUTF8(itemLabel); + CFileItemPtr pItem(new CFileItem(itemLabel)); + std::string itemPath(URIUtils::AddFileToFolder(root, entry->d_name)); + + bool bStat = false; + struct stat buffer; + + // Unix-based readdir implementations may return an incorrect dirent.d_ino value that + // is not equal to the (correct) stat() obtained one. In this case the file type + // could not be determined and the value of dirent.d_type is set to DT_UNKNOWN. + // In order to get a correct value we have to incur the cost of calling stat. + if (entry->d_type == DT_UNKNOWN || entry->d_type == DT_LNK) + { + if (stat(itemPath.c_str(), &buffer) == 0) + bStat = true; + } + + if (entry->d_type == DT_DIR || (bStat && S_ISDIR(buffer.st_mode))) + { + pItem->m_bIsFolder = true; + URIUtils::AddSlashAtEnd(itemPath); + } + else + { + pItem->m_bIsFolder = false; + } + + if (StringUtils::StartsWith(entry->d_name, ".")) + pItem->SetProperty("file:hidden", true); + + pItem->SetPath(itemPath); + + if (!(m_flags & DIR_FLAG_NO_FILE_INFO)) + { + if (bStat || stat(pItem->GetPath().c_str(), &buffer) == 0) + { + KODI::TIME::FileTime fileTime, localTime; + KODI::TIME::TimeTToFileTime(buffer.st_mtime, &fileTime); + KODI::TIME::FileTimeToLocalFileTime(&fileTime, &localTime); + pItem->m_dateTime = localTime; + + if (!pItem->m_bIsFolder) + pItem->m_dwSize = buffer.st_size; + } + } + items.Add(pItem); + } + closedir(dir); + return true; +} + +bool CPosixDirectory::Create(const CURL& url) +{ + if (!Create(url.Get())) + return Exists(url); + + return true; +} + +bool CPosixDirectory::Create(const std::string& path) +{ + if (mkdir(path.c_str(), 0755) != 0) + { + if (errno == ENOENT) + { + auto sep = path.rfind('/'); + if (sep == std::string::npos) + return false; + + if (Create(path.substr(0, sep))) + return Create(path); + } + + return false; + } + return true; +} + +bool CPosixDirectory::Remove(const CURL& url) +{ + if (rmdir(url.Get().c_str()) == 0) + return true; + + return !Exists(url); +} + +bool CPosixDirectory::RemoveRecursive(const CURL& url) +{ + std::string root = url.Get(); + + if (IsAliasShortcut(root, true)) + TranslateAliasShortcut(root); + + DIR *dir = opendir(root.c_str()); + if (!dir) + return false; + + bool success(true); + struct dirent* entry; + while ((entry = readdir(dir)) != NULL) + { + if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) + continue; + + std::string itemLabel(entry->d_name); + CCharsetConverter::unknownToUTF8(itemLabel); + std::string itemPath(URIUtils::AddFileToFolder(root, entry->d_name)); + + bool bStat = false; + struct stat buffer; + + // Unix-based readdir implementations may return an incorrect dirent.d_ino value that + // is not equal to the (correct) stat() obtained one. In this case the file type + // could not be determined and the value of dirent.d_type is set to DT_UNKNOWN. + // In order to get a correct value we have to incur the cost of calling stat. + if (entry->d_type == DT_UNKNOWN || entry->d_type == DT_LNK) + { + if (stat(itemPath.c_str(), &buffer) == 0) + bStat = true; + } + + if (entry->d_type == DT_DIR || (bStat && S_ISDIR(buffer.st_mode))) + { + if (!RemoveRecursive(CURL{ itemPath })) + { + success = false; + break; + } + } + else + { + if (unlink(itemPath.c_str()) != 0) + { + success = false; + break; + } + } + } + + closedir(dir); + + if (success) + { + if (rmdir(root.c_str()) != 0) + success = false; + } + + return success; +} + +bool CPosixDirectory::Exists(const CURL& url) +{ + std::string path = url.Get(); + + if (IsAliasShortcut(path, true)) + TranslateAliasShortcut(path); + + struct stat buffer; + if (stat(path.c_str(), &buffer) != 0) + return false; + return S_ISDIR(buffer.st_mode) ? true : false; +} diff --git a/xbmc/platform/posix/filesystem/PosixDirectory.h b/xbmc/platform/posix/filesystem/PosixDirectory.h new file mode 100644 index 0000000..eb323b6 --- /dev/null +++ b/xbmc/platform/posix/filesystem/PosixDirectory.h @@ -0,0 +1,29 @@ +/* + * Copyright (C) 2014-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "filesystem/IDirectory.h" + +namespace XFILE +{ + +class CPosixDirectory : public IDirectory +{ +public: + CPosixDirectory(void); + ~CPosixDirectory(void) override; + bool GetDirectory(const CURL& url, CFileItemList &items) override; + bool Create(const CURL& url) override; + bool Exists(const CURL& url) override; + bool Remove(const CURL& url) override; + bool RemoveRecursive(const CURL& url) override; +private: + bool Create(const std::string& path); +}; +} diff --git a/xbmc/platform/posix/filesystem/PosixFile.cpp b/xbmc/platform/posix/filesystem/PosixFile.cpp new file mode 100644 index 0000000..3010136 --- /dev/null +++ b/xbmc/platform/posix/filesystem/PosixFile.cpp @@ -0,0 +1,388 @@ +/* + * Copyright (C) 2014-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "PosixFile.h" + +#include "URL.h" +#include "filesystem/File.h" +#include "utils/AliasShortcutUtils.h" +#include "utils/log.h" + +#include <algorithm> +#include <assert.h> +#include <errno.h> +#include <limits.h> +#include <string> + +#include <fcntl.h> +#include <sys/ioctl.h> +#include <sys/stat.h> + +#if defined(HAVE_STATX) // use statx if available to get file birth date +#include <sys/sysmacros.h> +#endif +#include <unistd.h> + +using namespace XFILE; + +CPosixFile::~CPosixFile() +{ + if (m_fd >= 0) + close(m_fd); +} + +// local helper +static std::string getFilename(const CURL& url) +{ + std::string filename(url.GetFileName()); + if (IsAliasShortcut(filename, false)) + TranslateAliasShortcut(filename); + + return filename; +} + + +bool CPosixFile::Open(const CURL& url) +{ + if (m_fd >= 0) + return false; + + const std::string filename(getFilename(url)); + if (filename.empty()) + return false; + + m_fd = open(filename.c_str(), O_RDONLY, S_IRUSR | S_IRGRP | S_IROTH); + m_filePos = 0; + + return m_fd != -1; +} + +bool CPosixFile::OpenForWrite(const CURL& url, bool bOverWrite /* = false*/ ) +{ + if (m_fd >= 0) + return false; + + const std::string filename(getFilename(url)); + if (filename.empty()) + return false; + + m_fd = open(filename.c_str(), O_RDWR | O_CREAT | (bOverWrite ? O_TRUNC : 0), S_IWUSR | S_IRUSR | S_IRGRP | S_IWGRP | S_IROTH); + if (m_fd < 0) + return false; + + m_filePos = 0; + m_allowWrite = true; + + return true; +} + +void CPosixFile::Close() +{ + if (m_fd >= 0) + { + close(m_fd); + m_fd = -1; + m_filePos = -1; + m_lastDropPos = -1; + m_allowWrite = false; + } +} + + +ssize_t CPosixFile::Read(void* lpBuf, size_t uiBufSize) +{ + if (m_fd < 0) + return -1; + + assert(lpBuf != NULL || uiBufSize == 0); + if (lpBuf == NULL && uiBufSize != 0) + return -1; + + if (uiBufSize > SSIZE_MAX) + uiBufSize = SSIZE_MAX; + + const ssize_t res = read(m_fd, lpBuf, uiBufSize); + if (res < 0) + { + Seek(0, SEEK_CUR); // force update file position + return -1; + } + + if (m_filePos >= 0) + { + m_filePos += res; // if m_filePos was known - update it +#if defined(HAVE_POSIX_FADVISE) + // Drop the cache between then last drop and 16 MB behind where we + // are now, to make sure the file doesn't displace everything else. + // However, never throw out the first 16 MB of the file, as it might + // be the header etc., and never ask the OS to drop in chunks of + // less than 1 MB. + const int64_t end_drop = m_filePos - 16 * 1024 * 1024; + if (end_drop >= 17 * 1024 * 1024) + { + const int64_t start_drop = std::max<int64_t>(m_lastDropPos, 16 * 1024 * 1024); + if (end_drop - start_drop >= 1 * 1024 * 1024 && + posix_fadvise(m_fd, start_drop, end_drop - start_drop, POSIX_FADV_DONTNEED) == 0) + m_lastDropPos = end_drop; + } +#endif + } + + return res; +} + +ssize_t CPosixFile::Write(const void* lpBuf, size_t uiBufSize) +{ + if (m_fd < 0) + return -1; + + assert(lpBuf != NULL || uiBufSize == 0); + if ((lpBuf == NULL && uiBufSize != 0) || !m_allowWrite) + return -1; + + if (uiBufSize > SSIZE_MAX) + uiBufSize = SSIZE_MAX; + + const ssize_t res = write(m_fd, lpBuf, uiBufSize); + if (res < 0) + { + Seek(0, SEEK_CUR); // force update file position + return -1; + } + + if (m_filePos >= 0) + m_filePos += res; // if m_filePos was known - update it + + return res; +} + +int64_t CPosixFile::Seek(int64_t iFilePosition, int iWhence /* = SEEK_SET*/) +{ + if (m_fd < 0) + return -1; + +#ifdef TARGET_ANDROID + //! @todo properly support with detection in configure + //! Android special case: Android doesn't substitute off64_t for off_t and similar functions + m_filePos = lseek64(m_fd, (off64_t)iFilePosition, iWhence); +#else // !TARGET_ANDROID + const off_t filePosOffT = (off_t) iFilePosition; + // check for parameter overflow + if (sizeof(int64_t) != sizeof(off_t) && iFilePosition != filePosOffT) + return -1; + + m_filePos = lseek(m_fd, filePosOffT, iWhence); +#endif // !TARGET_ANDROID + + return m_filePos; +} + +int CPosixFile::Truncate(int64_t size) +{ + if (m_fd < 0) + return -1; + + const off_t sizeOffT = (off_t) size; + // check for parameter overflow + if (sizeof(int64_t) != sizeof(off_t) && size != sizeOffT) + return -1; + + return ftruncate(m_fd, sizeOffT); +} + +int64_t CPosixFile::GetPosition() +{ + if (m_fd < 0) + return -1; + + if (m_filePos < 0) + m_filePos = lseek(m_fd, 0, SEEK_CUR); + + return m_filePos; +} + +int64_t CPosixFile::GetLength() +{ + if (m_fd < 0) + return -1; + + struct stat64 st; + if (fstat64(m_fd, &st) != 0) + return -1; + + return st.st_size; +} + +void CPosixFile::Flush() +{ + if (m_fd >= 0) + fsync(m_fd); +} + +int CPosixFile::IoControl(EIoControl request, void* param) +{ + if (m_fd < 0) + return -1; + + if (request == IOCTRL_NATIVE) + { + if(!param) + return -1; + return ioctl(m_fd, ((SNativeIoControl*)param)->request, ((SNativeIoControl*)param)->param); + } + else if (request == IOCTRL_SEEK_POSSIBLE) + { + if (GetPosition() < 0) + return -1; // current position is unknown, can't test seeking + else if (m_filePos > 0) + { + const int64_t orgPos = m_filePos; + // try to seek one byte back + const bool seekPossible = (Seek(orgPos - 1, SEEK_SET) == (orgPos - 1)); + // restore file position + if (Seek(orgPos, SEEK_SET) != orgPos) + return 0; // seeking is not possible + + return seekPossible ? 1 : 0; + } + else + { // m_filePos == 0 + // try to seek one byte forward + const bool seekPossible = (Seek(1, SEEK_SET) == 1); + // restore file position + if (Seek(0, SEEK_SET) != 0) + return 0; // seeking is not possible + + if (seekPossible) + return 1; + + if (GetLength() <= 0) + return -1; // size of file is zero or can be zero, can't test seeking + else + return 0; // size of file is 1 byte or more and seeking not possible + } + } + + return -1; +} + + +bool CPosixFile::Delete(const CURL& url) +{ + const std::string filename(getFilename(url)); + if (filename.empty()) + return false; + + if (unlink(filename.c_str()) == 0) + return true; + + if (errno == EACCES || errno == EPERM) + CLog::LogF(LOGWARNING, "Can't access file \"{}\"", filename); + + return false; +} + +bool CPosixFile::Rename(const CURL& url, const CURL& urlnew) +{ + const std::string name(getFilename(url)), newName(getFilename(urlnew)); + if (name.empty() || newName.empty()) + return false; + + if (name == newName) + return true; + + if (rename(name.c_str(), newName.c_str()) == 0) + return true; + + if (errno == EACCES || errno == EPERM) + CLog::LogF(LOGWARNING, "Can't access file \"{}\" for rename to \"{}\"", name, newName); + + // rename across mount points - need to copy/delete + if (errno == EXDEV) + { + CLog::LogF(LOGDEBUG, + "Source file \"{}\" and target file \"{}\" are located on different filesystems, " + "copy&delete will be used instead of rename", + name, newName); + if (XFILE::CFile::Copy(name, newName)) + { + if (XFILE::CFile::Delete(name)) + return true; + else + XFILE::CFile::Delete(newName); + } + } + + return false; +} + +bool CPosixFile::Exists(const CURL& url) +{ + const std::string filename(getFilename(url)); + if (filename.empty()) + return false; + + struct stat64 st; + return stat64(filename.c_str(), &st) == 0 && !S_ISDIR(st.st_mode); +} + +int CPosixFile::Stat(const CURL& url, struct __stat64* buffer) +{ + assert(buffer != NULL); + const std::string filename(getFilename(url)); + if (filename.empty() || !buffer) + return -1; + +// Use statx to get file creation date (btime) which isn't available with just stat. This fills the +// buffer with the same data as the Windows implementation. Useful for the music library so that +// tags can be updated without changing the date they were added to the library (as m/ctime does) + +#if defined(HAVE_STATX) + int dirfd = AT_FDCWD; + int flags = AT_STATX_SYNC_AS_STAT; + unsigned int mask = STATX_BASIC_STATS | STATX_BTIME; + struct statx stxbuf = {}; + long ret = 0; + ret = statx(dirfd, filename.c_str(), flags, mask, &stxbuf); + if (ret == 0) + { + *buffer = {}; + buffer->st_mtime = stxbuf.stx_mtime.tv_sec; // modification time + if (stxbuf.stx_btime.tv_sec != 0) + buffer->st_ctime = stxbuf.stx_btime.tv_sec; // birth (creation) time + else + buffer->st_ctime = stxbuf.stx_ctime.tv_sec; // change time (of metadata or file) + // fill everything else we might need (statx buffer is slightly different to stat buffer so + // can't just return the statx buffer) Note we might not need all this but lets fill it for + // completeness + buffer->st_atime = stxbuf.stx_atime.tv_sec; + buffer->st_size = stxbuf.stx_size; + buffer->st_blksize = stxbuf.stx_blksize; + buffer->st_blocks = stxbuf.stx_blocks; + buffer->st_ino = stxbuf.stx_ino; + buffer->st_nlink = stxbuf.stx_nlink; + buffer->st_uid = stxbuf.stx_uid; + buffer->st_gid = stxbuf.stx_gid; + buffer->st_mode = stxbuf.stx_mode; + buffer->st_rdev = makedev(stxbuf.stx_rdev_major, stxbuf.stx_rdev_minor); + buffer->st_dev = makedev(stxbuf.stx_dev_major, stxbuf.stx_dev_minor); + } + return ret; +#else + return stat64(filename.c_str(), buffer); +#endif +} + +int CPosixFile::Stat(struct __stat64* buffer) +{ + assert(buffer != NULL); + if (m_fd < 0 || !buffer) + return -1; + + return fstat64(m_fd, buffer); +} diff --git a/xbmc/platform/posix/filesystem/PosixFile.h b/xbmc/platform/posix/filesystem/PosixFile.h new file mode 100644 index 0000000..aa5e0a0 --- /dev/null +++ b/xbmc/platform/posix/filesystem/PosixFile.h @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2014-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "filesystem/IFile.h" + +namespace XFILE +{ + + class CPosixFile : public IFile + { + public: + ~CPosixFile() override; + + bool Open(const CURL& url) override; + bool OpenForWrite(const CURL& url, bool bOverWrite = false) override; + void Close() override; + + ssize_t Read(void* lpBuf, size_t uiBufSize) override; + ssize_t Write(const void* lpBuf, size_t uiBufSize) override; + int64_t Seek(int64_t iFilePosition, int iWhence = SEEK_SET) override; + int Truncate(int64_t size) override; + int64_t GetPosition() override; + int64_t GetLength() override; + void Flush() override; + int IoControl(EIoControl request, void* param) override; + + bool Delete(const CURL& url) override; + bool Rename(const CURL& url, const CURL& urlnew) override; + bool Exists(const CURL& url) override; + int Stat(const CURL& url, struct __stat64* buffer) override; + int Stat(struct __stat64* buffer) override; + + protected: + int m_fd = -1; + int64_t m_filePos = -1; + int64_t m_lastDropPos = -1; + bool m_allowWrite = false; + }; + +} diff --git a/xbmc/platform/posix/filesystem/SMBDirectory.cpp b/xbmc/platform/posix/filesystem/SMBDirectory.cpp new file mode 100644 index 0000000..e2305af --- /dev/null +++ b/xbmc/platform/posix/filesystem/SMBDirectory.cpp @@ -0,0 +1,372 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* +* know bugs: +* - when opening a server for the first time with ip address and the second time +* with server name, access to the server is denied. +* - when browsing entire network, user can't go back one step +* share = smb://, user selects a workgroup, user selects a server. +* doing ".." will go back to smb:// (entire network) and not to workgroup list. +* +* debugging is set to a max of 10 for release builds (see local.h) +*/ + +#include "SMBDirectory.h" + +#include "FileItem.h" +#include "PasswordManager.h" +#include "ServiceBroker.h" +#include "guilib/LocalizeStrings.h" +#include "settings/AdvancedSettings.h" +#include "settings/Settings.h" +#include "settings/SettingsComponent.h" +#include "utils/StringUtils.h" +#include "utils/URIUtils.h" +#include "utils/XTimeUtils.h" +#include "utils/log.h" + +#include "platform/posix/filesystem/SMBWSDiscovery.h" + +#include <mutex> + +#include <libsmbclient.h> + +struct CachedDirEntry +{ + unsigned int type; + std::string name; +}; + +using namespace XFILE; + +CSMBDirectory::CSMBDirectory(void) +{ + smb.AddActiveConnection(); +} + +CSMBDirectory::~CSMBDirectory(void) +{ + smb.AddIdleConnection(); +} + +bool CSMBDirectory::GetDirectory(const CURL& url, CFileItemList &items) +{ + // We accept smb://[[[domain;]user[:password@]]server[/share[/path[/file]]]] + + /* samba isn't thread safe with old interface, always lock */ + std::unique_lock<CCriticalSection> lock(smb); + + smb.Init(); + + //Separate roots for the authentication and the containing items to allow browsing to work correctly + std::string strRoot = url.Get(); + std::string strAuth; + + lock.unlock(); // OpenDir is locked + + // if url provided does not having anything except smb protocol + // Do a WS-Discovery search to find possible smb servers to mimic smbv1 behaviour + if (strRoot == "smb://") + { + auto settingsComponent = CServiceBroker::GetSettingsComponent(); + if (!settingsComponent) + return false; + + auto settings = CServiceBroker::GetSettingsComponent()->GetSettings(); + if (!settings) + return false; + + // Check WS-Discovery daemon enabled, if not return as smb:// cant be handled further + if (settings->GetBool(CSettings::SETTING_SERVICES_WSDISCOVERY)) + { + WSDiscovery::CWSDiscoveryPosix& WSInstance = + dynamic_cast<WSDiscovery::CWSDiscoveryPosix&>(CServiceBroker::GetWSDiscovery()); + return WSInstance.GetServerList(items); + } + else + { + return false; + } + } + + int fd = OpenDir(url, strAuth); + if (fd < 0) + return false; + + URIUtils::AddSlashAtEnd(strRoot); + URIUtils::AddSlashAtEnd(strAuth); + + std::string strFile; + + // need to keep the samba lock for as short as possible. + // so we first cache all directory entries and then go over them again asking for stat + // "stat" is locked each time. that way the lock is freed between stat requests + std::vector<CachedDirEntry> vecEntries; + struct smbc_dirent* dirEnt; + + lock.lock(); + if (!smb.IsSmbValid()) + return false; + while ((dirEnt = smbc_readdir(fd))) + { + CachedDirEntry aDir; + aDir.type = dirEnt->smbc_type; + aDir.name = dirEnt->name; + vecEntries.push_back(aDir); + } + smbc_closedir(fd); + lock.unlock(); + + for (size_t i=0; i<vecEntries.size(); i++) + { + CachedDirEntry aDir = vecEntries[i]; + + // We use UTF-8 internally, as does SMB + strFile = aDir.name; + + if (!strFile.empty() && strFile != "." && strFile != ".." + && strFile != "lost+found" + && aDir.type != SMBC_PRINTER_SHARE && aDir.type != SMBC_IPC_SHARE) + { + int64_t iSize = 0; + bool bIsDir = true; + int64_t lTimeDate = 0; + bool hidden = false; + + if(StringUtils::EndsWith(strFile, "$") && aDir.type == SMBC_FILE_SHARE ) + continue; + + if (StringUtils::StartsWith(strFile, ".")) + hidden = true; + + // only stat files that can give proper responses + if ( aDir.type == SMBC_FILE || + aDir.type == SMBC_DIR ) + { + // set this here to if the stat should fail + bIsDir = (aDir.type == SMBC_DIR); + + struct stat info = {}; + if ((m_flags & DIR_FLAG_NO_FILE_INFO)==0 && CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_sambastatfiles) + { + // make sure we use the authenticated path which contains any default username + const std::string strFullName = strAuth + smb.URLEncode(strFile); + + lock.lock(); + if (!smb.IsSmbValid()) + { + items.ClearItems(); + return false; + } + + if( smbc_stat(strFullName.c_str(), &info) == 0 ) + { + + char value[20]; + // We poll for extended attributes which symbolizes bits but split up into a string. Where 0x02 is hidden and 0x12 is hidden directory. + // According to the libsmbclient.h it returns 0 on success and -1 on error. + // But before Samba 4.17.5 it seems to return the length of the returned value + // (which is 4), see https://bugzilla.samba.org/show_bug.cgi?id=14808. + // Checking for >= 0 should work both for the old erroneous and the correct behaviour. + if (smbc_getxattr(strFullName.c_str(), "system.dos_attr.mode", value, sizeof(value)) >= 0) + { + long longvalue = strtol(value, NULL, 16); + if (longvalue & SMBC_DOS_MODE_HIDDEN) + hidden = true; + } + else + CLog::Log( + LOGERROR, + "Getting extended attributes for the share: '{}'\nunix_err:'{:x}' error: '{}'", + CURL::GetRedacted(strFullName), errno, strerror(errno)); + + bIsDir = S_ISDIR(info.st_mode); + lTimeDate = info.st_mtime; + if(lTimeDate == 0) // if modification date is missing, use create date + lTimeDate = info.st_ctime; + iSize = info.st_size; + } + else + CLog::Log(LOGERROR, "{} - Failed to stat file {}", __FUNCTION__, + CURL::GetRedacted(strFullName)); + + lock.unlock(); + } + } + + KODI::TIME::FileTime fileTime, localTime; + KODI::TIME::TimeTToFileTime(lTimeDate, &fileTime); + KODI::TIME::FileTimeToLocalFileTime(&fileTime, &localTime); + + if (bIsDir) + { + CFileItemPtr pItem(new CFileItem(strFile)); + std::string path(strRoot); + + // needed for network / workgroup browsing + // skip if root if we are given a server + if (aDir.type == SMBC_SERVER) + { + /* create url with same options, user, pass.. but no filename or host*/ + CURL rooturl(strRoot); + rooturl.SetFileName(""); + rooturl.SetHostName(""); + path = smb.URLEncode(rooturl); + } + path = URIUtils::AddFileToFolder(path,aDir.name); + URIUtils::AddSlashAtEnd(path); + pItem->SetPath(path); + pItem->m_bIsFolder = true; + pItem->m_dateTime=localTime; + if (hidden) + pItem->SetProperty("file:hidden", true); + items.Add(pItem); + } + else + { + CFileItemPtr pItem(new CFileItem(strFile)); + pItem->SetPath(strRoot + aDir.name); + pItem->m_bIsFolder = false; + pItem->m_dwSize = iSize; + pItem->m_dateTime=localTime; + if (hidden) + pItem->SetProperty("file:hidden", true); + items.Add(pItem); + } + } + } + + return true; +} + +int CSMBDirectory::Open(const CURL &url) +{ + smb.Init(); + std::string strAuth; + return OpenDir(url, strAuth); +} + +/// \brief Checks authentication against SAMBA share and prompts for username and password if needed +/// \param strAuth The SMB style path +/// \return SMB file descriptor +int CSMBDirectory::OpenDir(const CURL& url, std::string& strAuth) +{ + int fd = -1; + + /* make a writeable copy */ + CURL urlIn = CSMB::GetResolvedUrl(url); + + CPasswordManager::GetInstance().AuthenticateURL(urlIn); + strAuth = smb.URLEncode(urlIn); + + // remove the / or \ at the end. the samba library does not strip them off + // don't do this for smb:// !! + std::string s = strAuth; + int len = s.length(); + if (len > 1 && s.at(len - 2) != '/' && + (s.at(len - 1) == '/' || s.at(len - 1) == '\\')) + { + s.erase(len - 1, 1); + } + + CLog::LogFC(LOGDEBUG, LOGSAMBA, "Using authentication url {}", CURL::GetRedacted(s)); + + { + std::unique_lock<CCriticalSection> lock(smb); + if (!smb.IsSmbValid()) + return -1; + fd = smbc_opendir(s.c_str()); + } + + while (fd < 0) /* only to avoid goto in following code */ + { + std::string cError; + + if (errno == EACCES) + { + if (m_flags & DIR_FLAG_ALLOW_PROMPT) + RequireAuthentication(urlIn); + break; + } + + if (errno == ENODEV || errno == ENOENT) + cError = StringUtils::Format(g_localizeStrings.Get(770), errno); + else + cError = strerror(errno); + + if (m_flags & DIR_FLAG_ALLOW_PROMPT) + SetErrorDialog(257, cError.c_str()); + break; + } + + if (fd < 0) + { + // write error to logfile + CLog::Log( + LOGERROR, + "SMBDirectory->GetDirectory: Unable to open directory : '{}'\nunix_err:'{:x}' error : '{}'", + CURL::GetRedacted(strAuth), errno, strerror(errno)); + } + + return fd; +} + +bool CSMBDirectory::Create(const CURL& url2) +{ + std::unique_lock<CCriticalSection> lock(smb); + smb.Init(); + + CURL url = CSMB::GetResolvedUrl(url2); + CPasswordManager::GetInstance().AuthenticateURL(url); + std::string strFileName = smb.URLEncode(url); + + int result = smbc_mkdir(strFileName.c_str(), 0); + bool success = (result == 0 || EEXIST == errno); + if(!success) + CLog::Log(LOGERROR, "{} - Error( {} )", __FUNCTION__, strerror(errno)); + + return success; +} + +bool CSMBDirectory::Remove(const CURL& url2) +{ + std::unique_lock<CCriticalSection> lock(smb); + smb.Init(); + + CURL url = CSMB::GetResolvedUrl(url2); + CPasswordManager::GetInstance().AuthenticateURL(url); + std::string strFileName = smb.URLEncode(url); + + int result = smbc_rmdir(strFileName.c_str()); + + if(result != 0 && errno != ENOENT) + { + CLog::Log(LOGERROR, "{} - Error( {} )", __FUNCTION__, strerror(errno)); + return false; + } + + return true; +} + +bool CSMBDirectory::Exists(const CURL& url2) +{ + std::unique_lock<CCriticalSection> lock(smb); + smb.Init(); + + CURL url = CSMB::GetResolvedUrl(url2); + CPasswordManager::GetInstance().AuthenticateURL(url); + std::string strFileName = smb.URLEncode(url); + + struct stat info; + if (smbc_stat(strFileName.c_str(), &info) != 0) + return false; + + return S_ISDIR(info.st_mode); +} + diff --git a/xbmc/platform/posix/filesystem/SMBDirectory.h b/xbmc/platform/posix/filesystem/SMBDirectory.h new file mode 100644 index 0000000..cef06d2 --- /dev/null +++ b/xbmc/platform/posix/filesystem/SMBDirectory.h @@ -0,0 +1,33 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "MediaSource.h" +#include "SMBFile.h" +#include "filesystem/IDirectory.h" + +namespace XFILE +{ +class CSMBDirectory : public IDirectory +{ +public: + CSMBDirectory(void); + ~CSMBDirectory(void) override; + bool GetDirectory(const CURL& url, CFileItemList &items) override; + DIR_CACHE_TYPE GetCacheType(const CURL& url) const override { return DIR_CACHE_ONCE; } + bool Create(const CURL& url) override; + bool Exists(const CURL& url) override; + bool Remove(const CURL& url) override; + + int Open(const CURL &url); + +private: + int OpenDir(const CURL &url, std::string& strAuth); +}; +} diff --git a/xbmc/platform/posix/filesystem/SMBFile.cpp b/xbmc/platform/posix/filesystem/SMBFile.cpp new file mode 100644 index 0000000..38a82c3 --- /dev/null +++ b/xbmc/platform/posix/filesystem/SMBFile.cpp @@ -0,0 +1,721 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +// SMBFile.cpp: implementation of the CSMBFile class. +// +////////////////////////////////////////////////////////////////////// + +#include "SMBFile.h" + +#include "PasswordManager.h" +#include "SMBDirectory.h" +#include "ServiceBroker.h" +#include "Util.h" +#include "commons/Exception.h" +#include "filesystem/SpecialProtocol.h" +#include "network/DNSNameCache.h" +#include "settings/AdvancedSettings.h" +#include "settings/Settings.h" +#include "settings/SettingsComponent.h" +#include "utils/StringUtils.h" +#include "utils/TimeUtils.h" +#include "utils/URIUtils.h" +#include "utils/log.h" + +#include <inttypes.h> +#include <mutex> + +#include <libsmbclient.h> + +using namespace XFILE; + +void xb_smbc_log(const char* msg) +{ + CLog::Log(LOGINFO, "{}{}", "smb: ", msg); +} + +void xb_smbc_auth(const char *srv, const char *shr, char *wg, int wglen, + char *un, int unlen, char *pw, int pwlen) +{ +} + +// WTF is this ?, we get the original server cache only +// to set the server cache to this function which call the +// original one anyway. Seems quite silly. +smbc_get_cached_srv_fn orig_cache; +SMBCSRV* xb_smbc_cache(SMBCCTX* c, const char* server, const char* share, const char* workgroup, const char* username) +{ + return orig_cache(c, server, share, workgroup, username); +} + +bool CSMB::IsFirstInit = true; + +CSMB::CSMB() +{ + m_context = NULL; + m_OpenConnections = 0; + m_IdleTimeout = 0; +} + +CSMB::~CSMB() +{ + Deinit(); +} + +void CSMB::Deinit() +{ + std::unique_lock<CCriticalSection> lock(*this); + + /* samba goes loco if deinited while it has some files opened */ + if (m_context) + { + smbc_set_context(NULL); + smbc_free_context(m_context, 1); + m_context = NULL; + } +} + +void CSMB::Init() +{ + std::unique_lock<CCriticalSection> lock(*this); + + if (!m_context) + { + const std::shared_ptr<CSettings> settings = CServiceBroker::GetSettingsComponent()->GetSettings(); + + // force libsmbclient to use our own smb.conf by overriding HOME + std::string truehome(getenv("HOME")); + setenv("HOME", CSpecialProtocol::TranslatePath("special://home").c_str(), 1); + + // Create ~/.kodi/.smb/smb.conf. This file is used by libsmbclient. + // http://us1.samba.org/samba/docs/man/manpages-3/libsmbclient.7.html + // http://us1.samba.org/samba/docs/man/manpages-3/smb.conf.5.html + std::string smb_conf; + std::string home(getenv("HOME")); + URIUtils::RemoveSlashAtEnd(home); + smb_conf = home + "/.smb"; + int result = mkdir(smb_conf.c_str(), 0755); + if (result == 0 || (errno == EEXIST && IsFirstInit)) + { + smb_conf += "/smb.conf"; + FILE* f = fopen(smb_conf.c_str(), "w"); + if (f != NULL) + { + fprintf(f, "[global]\n"); + + fprintf(f, "\tlock directory = %s/.smb/\n", home.c_str()); + + // set minimum smbclient protocol version + if (settings->GetInt(CSettings::SETTING_SMB_MINPROTOCOL) > 0) + { + if (settings->GetInt(CSettings::SETTING_SMB_MINPROTOCOL) == 1) + fprintf(f, "\tclient min protocol = NT1\n"); + else + fprintf(f, "\tclient min protocol = SMB%d\n", settings->GetInt(CSettings::SETTING_SMB_MINPROTOCOL)); + } + + // set maximum smbclient protocol version + if (settings->GetInt(CSettings::SETTING_SMB_MAXPROTOCOL) > 0) + { + if (settings->GetInt(CSettings::SETTING_SMB_MAXPROTOCOL) == 1) + fprintf(f, "\tclient max protocol = NT1\n"); + else + fprintf(f, "\tclient max protocol = SMB%d\n", settings->GetInt(CSettings::SETTING_SMB_MAXPROTOCOL)); + } + + // set legacy security options + if (settings->GetBool(CSettings::SETTING_SMB_LEGACYSECURITY) && (settings->GetInt(CSettings::SETTING_SMB_MAXPROTOCOL) == 1)) + { + fprintf(f, "\tclient NTLMv2 auth = no\n"); + fprintf(f, "\tclient use spnego = no\n"); + } + + // set wins server if there's one. name resolve order defaults to 'lmhosts host wins bcast'. + // if no WINS server has been specified the wins method will be ignored. + if (settings->GetString(CSettings::SETTING_SMB_WINSSERVER).length() > 0 && !StringUtils::EqualsNoCase(settings->GetString(CSettings::SETTING_SMB_WINSSERVER), "0.0.0.0") ) + { + fprintf(f, "\twins server = %s\n", settings->GetString(CSettings::SETTING_SMB_WINSSERVER).c_str()); + fprintf(f, "\tname resolve order = bcast wins host\n"); + } + else + fprintf(f, "\tname resolve order = bcast host\n"); + + // use user-configured charset. if no charset is specified, + // samba tries to use charset 850 but falls back to ASCII in case it is not available + if (CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_sambadoscodepage.length() > 0) + fprintf(f, "\tdos charset = %s\n", CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_sambadoscodepage.c_str()); + + // include users configuration if available + fprintf(f, "\tinclude = %s/.smb/user.conf\n", home.c_str()); + + fclose(f); + } + } + + // reads smb.conf so this MUST be after we create smb.conf + // multiple smbc_init calls are ignored by libsmbclient. + // note: this is important as it initializes the smb old + // interface compatibility. Samba 3.4.0 or higher has the new interface. + // note: we leak the following here once, not sure why yet. + // 48 bytes -> smb_xmalloc_array + // 32 bytes -> set_param_opt + // 16 bytes -> set_param_opt + smbc_init(xb_smbc_auth, 0); + + // setup our context + m_context = smbc_new_context(); + + // restore HOME + setenv("HOME", truehome.c_str(), 1); + +#ifdef DEPRECATED_SMBC_INTERFACE + smbc_setDebug(m_context, CServiceBroker::GetLogging().CanLogComponent(LOGSAMBA) ? 10 : 0); + smbc_setFunctionAuthData(m_context, xb_smbc_auth); + orig_cache = smbc_getFunctionGetCachedServer(m_context); + smbc_setFunctionGetCachedServer(m_context, xb_smbc_cache); + smbc_setOptionOneSharePerServer(m_context, false); + smbc_setOptionBrowseMaxLmbCount(m_context, 0); + smbc_setTimeout(m_context, CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_sambaclienttimeout * 1000); + // we do not need to strdup these, smbc_setXXX below will make their own copies + if (settings->GetString(CSettings::SETTING_SMB_WORKGROUP).length() > 0) + //! @bug libsmbclient < 4.9 isn't const correct + smbc_setWorkgroup(m_context, const_cast<char*>(settings->GetString(CSettings::SETTING_SMB_WORKGROUP).c_str())); + std::string guest = "guest"; + //! @bug libsmbclient < 4.8 isn't const correct + smbc_setUser(m_context, const_cast<char*>(guest.c_str())); +#else + m_context->debug = (CServiceBroker::GetLogging().CanLogComponent(LOGSAMBA) ? 10 : 0); + m_context->callbacks.auth_fn = xb_smbc_auth; + orig_cache = m_context->callbacks.get_cached_srv_fn; + m_context->callbacks.get_cached_srv_fn = xb_smbc_cache; + m_context->options.one_share_per_server = false; + m_context->options.browse_max_lmb_count = 0; + m_context->timeout = CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_sambaclienttimeout * 1000; + // we need to strdup these, they will get free'd on smbc_free_context + if (settings->GetString(CSettings::SETTING_SMB_WORKGROUP).length() > 0) + m_context->workgroup = strdup(settings->GetString(CSettings::SETTING_SMB_WORKGROUP).c_str()); + m_context->user = strdup("guest"); +#endif + + // initialize samba and do some hacking into the settings + if (smbc_init_context(m_context)) + { + // setup context using the smb old interface compatibility + SMBCCTX *old_context = smbc_set_context(m_context); + // free previous context or we leak it, this comes from smbc_init above. + // there is a bug in smbclient (old interface), if we init/set a context + // then set(null)/free it in DeInit above, the next smbc_set_context + // return the already freed previous context, free again and bang, crash. + // so we setup a stic bool to track the first init so we can free the + // context associated with the initial smbc_init. + if (old_context && IsFirstInit) + { + smbc_free_context(old_context, 1); + IsFirstInit = false; + } + } + else + { + smbc_free_context(m_context, 1); + m_context = NULL; + } + } + m_IdleTimeout = 180; +} + +std::string CSMB::URLEncode(const CURL &url) +{ + /* due to smb wanting encoded urls we have to build it manually */ + + std::string flat = "smb://"; + + /* samba messes up of password is set but no username is set. don't know why yet */ + /* probably the url parser that goes crazy */ + if(url.GetUserName().length() > 0 /* || url.GetPassWord().length() > 0 */) + { + if(!url.GetDomain().empty()) + { + flat += URLEncode(url.GetDomain()); + flat += ";"; + } + flat += URLEncode(url.GetUserName()); + if(url.GetPassWord().length() > 0) + { + flat += ":"; + flat += URLEncode(url.GetPassWord()); + } + flat += "@"; + } + flat += URLEncode(url.GetHostName()); + + if (url.HasPort()) + { + flat += StringUtils::Format(":{}", url.GetPort()); + } + + /* okey sadly since a slash is an invalid name we have to tokenize */ + std::vector<std::string> parts; + StringUtils::Tokenize(url.GetFileName(), parts, "/"); + for (const std::string& it : parts) + { + flat += "/"; + flat += URLEncode((it)); + } + + /* okey options should go here, thou current samba doesn't support any */ + + return flat; +} + +std::string CSMB::URLEncode(const std::string &value) +{ + return CURL::Encode(value); +} + +/* This is called from CApplication::ProcessSlow() and is used to tell if smbclient have been idle for too long */ +void CSMB::CheckIfIdle() +{ +/* We check if there are open connections. This is done without a lock to not halt the mainthread. It should be thread safe as + worst case scenario is that m_OpenConnections could read 0 and then changed to 1 if this happens it will enter the if which will lead to another check, which is locked. */ + if (m_OpenConnections == 0) + { /* I've set the the maximum IDLE time to be 1 min and 30 sec. */ + std::unique_lock<CCriticalSection> lock(*this); + if (m_OpenConnections == 0 /* check again - when locked */ && m_context != NULL) + { + if (m_IdleTimeout > 0) + { + m_IdleTimeout--; + } + else + { + CLog::Log(LOGINFO, "Samba is idle. Closing the remaining connections"); + smb.Deinit(); + } + } + } +} + +void CSMB::SetActivityTime() +{ + /* Since we get called every 500ms from ProcessSlow we limit the tick count to 180 */ + /* That means we have 2 ticks per second which equals 180/2 == 90 seconds */ + m_IdleTimeout = 180; +} + +/* The following two function is used to keep track on how many Opened files/directories there are. + This makes the idle timer not count if a movie is paused for example */ +void CSMB::AddActiveConnection() +{ + std::unique_lock<CCriticalSection> lock(*this); + m_OpenConnections++; +} +void CSMB::AddIdleConnection() +{ + std::unique_lock<CCriticalSection> lock(*this); + m_OpenConnections--; + /* If we close a file we reset the idle timer so that we don't have any weird behaviours if a user + leaves the movie paused for a long while and then press stop */ + m_IdleTimeout = 180; +} + +CURL CSMB::GetResolvedUrl(const CURL& url) +{ + CURL tmpUrl(url); + std::string resolvedHostName; + + if (CDNSNameCache::Lookup(tmpUrl.GetHostName(), resolvedHostName)) + tmpUrl.SetHostName(resolvedHostName); + + return tmpUrl; +} + +CSMB smb; + +CSMBFile::CSMBFile() +{ + smb.Init(); + m_fd = -1; + smb.AddActiveConnection(); + m_allowRetry = true; +} + +CSMBFile::~CSMBFile() +{ + Close(); + smb.AddIdleConnection(); +} + +int64_t CSMBFile::GetPosition() +{ + if (m_fd == -1) + return -1; + std::unique_lock<CCriticalSection> lock(smb); + if (!smb.IsSmbValid()) + return -1; + return smbc_lseek(m_fd, 0, SEEK_CUR); +} + +int64_t CSMBFile::GetLength() +{ + if (m_fd == -1) + return -1; + return m_fileSize; +} + +bool CSMBFile::Open(const CURL& url) +{ + Close(); + + // we can't open files like smb://file.f or smb://server/file.f + // if a file matches the if below return false, it can't exist on a samba share. + if (!IsValidFile(url.GetFileName())) + { + CLog::Log(LOGINFO, "SMBFile->Open: Bad URL : '{}'", url.GetRedacted()); + return false; + } + m_url = url; + + // opening a file to another computer share will create a new session + // when opening smb://server xbms will try to find folder.jpg in all shares + // listed, which will create lot's of open sessions. + + std::string strFileName; + m_fd = OpenFile(url, strFileName); + + CLog::Log(LOGDEBUG, "CSMBFile::Open - opened {}, fd={}", url.GetRedacted(), m_fd); + if (m_fd == -1) + { + // write error to logfile + CLog::Log(LOGINFO, "SMBFile->Open: Unable to open file : '{}'\nunix_err:'{:x}' error : '{}'", + CURL::GetRedacted(strFileName), errno, strerror(errno)); + return false; + } + + std::unique_lock<CCriticalSection> lock(smb); + if (!smb.IsSmbValid()) + return false; + struct stat tmpBuffer; + if (smbc_stat(strFileName.c_str(), &tmpBuffer) < 0) + { + smbc_close(m_fd); + m_fd = -1; + return false; + } + + m_fileSize = tmpBuffer.st_size; + + int64_t ret = smbc_lseek(m_fd, 0, SEEK_SET); + if ( ret < 0 ) + { + smbc_close(m_fd); + m_fd = -1; + return false; + } + // We've successfully opened the file! + return true; +} + + +/// \brief Checks authentication against SAMBA share. Reads password cache created in CSMBDirectory::OpenDir(). +/// \param strAuth The SMB style path +/// \return SMB file descriptor +/* +int CSMBFile::OpenFile(std::string& strAuth) +{ + int fd = -1; + + std::string strPath = g_passwordManager.GetSMBAuthFilename(strAuth); + + fd = smbc_open(strPath.c_str(), O_RDONLY, 0); + //! @todo Run a loop here that prompts for our username/password as appropriate? + //! We have the ability to run a file (eg from a button action) without browsing to + //! the directory first. In the case of a password protected share that we do + //! not have the authentication information for, the above smbc_open() will have + //! returned negative, and the file will not be opened. While this is not a particular + //! likely scenario, we might want to implement prompting for the password in this case. + //! The code from SMBDirectory can be used for this. + if(fd >= 0) + strAuth = strPath; + + return fd; +} +*/ + +int CSMBFile::OpenFile(const CURL &url, std::string& strAuth) +{ + int fd = -1; + smb.Init(); + + strAuth = GetAuthenticatedPath(CSMB::GetResolvedUrl(url)); + std::string strPath = strAuth; + + { + std::unique_lock<CCriticalSection> lock(smb); + if (smb.IsSmbValid()) + fd = smbc_open(strPath.c_str(), O_RDONLY, 0); + } + + if (fd >= 0) + strAuth = strPath; + + return fd; +} + +bool CSMBFile::Exists(const CURL& url) +{ + // we can't open files like smb://file.f or smb://server/file.f + // if a file matches the if below return false, it can't exist on a samba share. + if (!IsValidFile(url.GetFileName())) return false; + + smb.Init(); + std::string strFileName = GetAuthenticatedPath(CSMB::GetResolvedUrl(url)); + + struct stat info; + + std::unique_lock<CCriticalSection> lock(smb); + if (!smb.IsSmbValid()) + return false; + int iResult = smbc_stat(strFileName.c_str(), &info); + + if (iResult < 0) return false; + return true; +} + +int CSMBFile::Stat(struct __stat64* buffer) +{ + if (m_fd == -1) + return -1; + + struct stat tmpBuffer = {}; + + std::unique_lock<CCriticalSection> lock(smb); + if (!smb.IsSmbValid()) + return -1; + int iResult = smbc_fstat(m_fd, &tmpBuffer); + CUtil::StatToStat64(buffer, &tmpBuffer); + return iResult; +} + +int CSMBFile::Stat(const CURL& url, struct __stat64* buffer) +{ + smb.Init(); + std::string strFileName = GetAuthenticatedPath(CSMB::GetResolvedUrl(url)); + std::unique_lock<CCriticalSection> lock(smb); + + if (!smb.IsSmbValid()) + return -1; + struct stat tmpBuffer = {}; + int iResult = smbc_stat(strFileName.c_str(), &tmpBuffer); + CUtil::StatToStat64(buffer, &tmpBuffer); + return iResult; +} + +int CSMBFile::Truncate(int64_t size) +{ + if (m_fd == -1) return 0; + /* + * This would force us to be dependant on SMBv3.2 which is GPLv3 + * This is only used by the TagLib writers, which are not currently in use + * So log and warn until we implement TagLib writing & can re-implement this better. + std::unique_lock<CCriticalSection> lock(smb); // Init not called since it has to be "inited" by now + +#if defined(TARGET_ANDROID) + int iResult = 0; +#else + int iResult = smbc_ftruncate(m_fd, size); +#endif +*/ + CLog::Log(LOGWARNING, "{} - Warning(smbc_ftruncate called and not implemented)", __FUNCTION__); + return 0; +} + +ssize_t CSMBFile::Read(void *lpBuf, size_t uiBufSize) +{ + if (uiBufSize > SSIZE_MAX) + uiBufSize = SSIZE_MAX; + + if (m_fd == -1) + return -1; + + // Some external libs (libass) use test read with zero size and + // null buffer pointer to check whether file is readable, but + // libsmbclient always return "-1" if called with null buffer + // regardless of buffer size. + // To overcome this, force return "0" in that case. + if (uiBufSize == 0 && lpBuf == NULL) + return 0; + + std::unique_lock<CCriticalSection> lock( + smb); // Init not called since it has to be "inited" by now + if (!smb.IsSmbValid()) + return -1; + smb.SetActivityTime(); + + ssize_t bytesRead = smbc_read(m_fd, lpBuf, (int)uiBufSize); + + if (m_allowRetry && bytesRead < 0 && errno == EINVAL ) + { + CLog::Log(LOGERROR, "{} - Error( {}, {}, {} ) - Retrying", __FUNCTION__, bytesRead, errno, + strerror(errno)); + bytesRead = smbc_read(m_fd, lpBuf, (int)uiBufSize); + } + + if ( bytesRead < 0 ) + CLog::Log(LOGERROR, "{} - Error( {}, {}, {} )", __FUNCTION__, bytesRead, errno, + strerror(errno)); + + return bytesRead; +} + +int64_t CSMBFile::Seek(int64_t iFilePosition, int iWhence) +{ + if (m_fd == -1) return -1; + + std::unique_lock<CCriticalSection> lock( + smb); // Init not called since it has to be "inited" by now + if (!smb.IsSmbValid()) + return -1; + smb.SetActivityTime(); + int64_t pos = smbc_lseek(m_fd, iFilePosition, iWhence); + + if ( pos < 0 ) + { + CLog::Log(LOGERROR, "{} - Error( {}, {}, {} )", __FUNCTION__, pos, errno, strerror(errno)); + return -1; + } + + return pos; +} + +void CSMBFile::Close() +{ + if (m_fd != -1) + { + CLog::Log(LOGDEBUG, "CSMBFile::Close closing fd {}", m_fd); + std::unique_lock<CCriticalSection> lock(smb); + if (!smb.IsSmbValid()) + return; + smbc_close(m_fd); + } + m_fd = -1; +} + +ssize_t CSMBFile::Write(const void* lpBuf, size_t uiBufSize) +{ + if (m_fd == -1) return -1; + + // lpBuf can be safely casted to void* since xbmc_write will only read from it. + std::unique_lock<CCriticalSection> lock(smb); + if (!smb.IsSmbValid()) + return -1; + + return smbc_write(m_fd, lpBuf, uiBufSize); +} + +bool CSMBFile::Delete(const CURL& url) +{ + smb.Init(); + std::string strFile = GetAuthenticatedPath(CSMB::GetResolvedUrl(url)); + + std::unique_lock<CCriticalSection> lock(smb); + if (!smb.IsSmbValid()) + return false; + + int result = smbc_unlink(strFile.c_str()); + + if(result != 0) + CLog::Log(LOGERROR, "{} - Error( {} )", __FUNCTION__, strerror(errno)); + + return (result == 0); +} + +bool CSMBFile::Rename(const CURL& url, const CURL& urlnew) +{ + smb.Init(); + std::string strFile = GetAuthenticatedPath(CSMB::GetResolvedUrl(url)); + std::string strFileNew = GetAuthenticatedPath(CSMB::GetResolvedUrl(urlnew)); + std::unique_lock<CCriticalSection> lock(smb); + if (!smb.IsSmbValid()) + return false; + + int result = smbc_rename(strFile.c_str(), strFileNew.c_str()); + + if(result != 0) + CLog::Log(LOGERROR, "{} - Error( {} )", __FUNCTION__, strerror(errno)); + + return (result == 0); +} + +bool CSMBFile::OpenForWrite(const CURL& url, bool bOverWrite) +{ + m_fileSize = 0; + + Close(); + + // we can't open files like smb://file.f or smb://server/file.f + // if a file matches the if below return false, it can't exist on a samba share. + if (!IsValidFile(url.GetFileName())) return false; + + std::string strFileName = GetAuthenticatedPath(CSMB::GetResolvedUrl(url)); + std::unique_lock<CCriticalSection> lock(smb); + if (!smb.IsSmbValid()) + return false; + + if (bOverWrite) + { + CLog::Log(LOGWARNING, "SMBFile::OpenForWrite() called with overwriting enabled! - {}", + CURL::GetRedacted(strFileName)); + m_fd = smbc_creat(strFileName.c_str(), 0); + } + else + { + m_fd = smbc_open(strFileName.c_str(), O_RDWR, 0); + } + + if (m_fd == -1) + { + // write error to logfile + CLog::Log(LOGERROR, "SMBFile->Open: Unable to open file : '{}'\nunix_err:'{:x}' error : '{}'", + CURL::GetRedacted(strFileName), errno, strerror(errno)); + return false; + } + + // We've successfully opened the file! + return true; +} + +bool CSMBFile::IsValidFile(const std::string& strFileName) +{ + if (strFileName.find('/') == std::string::npos || /* doesn't have sharename */ + StringUtils::EndsWith(strFileName, "/.") || /* not current folder */ + StringUtils::EndsWith(strFileName, "/..")) /* not parent folder */ + return false; + return true; +} + +std::string CSMBFile::GetAuthenticatedPath(const CURL &url) +{ + CURL authURL(CSMB::GetResolvedUrl(url)); + CPasswordManager::GetInstance().AuthenticateURL(authURL); + return smb.URLEncode(authURL); +} + +int CSMBFile::IoControl(EIoControl request, void* param) +{ + if (request == IOCTRL_SEEK_POSSIBLE) + return 1; + + if (request == IOCTRL_SET_RETRY) + { + m_allowRetry = *(bool*) param; + return 0; + } + + return -1; +} + diff --git a/xbmc/platform/posix/filesystem/SMBFile.h b/xbmc/platform/posix/filesystem/SMBFile.h new file mode 100644 index 0000000..8cc960e --- /dev/null +++ b/xbmc/platform/posix/filesystem/SMBFile.h @@ -0,0 +1,93 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +// SMBFile.h: interface for the CSMBFile class. + +// + +////////////////////////////////////////////////////////////////////// + + +#include "URL.h" +#include "filesystem/IFile.h" +#include "threads/CriticalSection.h" + +#define NT_STATUS_CONNECTION_REFUSED long(0xC0000000 | 0x0236) +#define NT_STATUS_INVALID_HANDLE long(0xC0000000 | 0x0008) +#define NT_STATUS_ACCESS_DENIED long(0xC0000000 | 0x0022) +#define NT_STATUS_OBJECT_NAME_NOT_FOUND long(0xC0000000 | 0x0034) +#define NT_STATUS_INVALID_COMPUTER_NAME long(0xC0000000 | 0x0122) + +struct _SMBCCTX; +typedef _SMBCCTX SMBCCTX; + +class CSMB : public CCriticalSection +{ +public: + CSMB(); + ~CSMB(); + void Init(); + void Deinit(); + /* Makes sense to be called after acquiring the lock */ + bool IsSmbValid() const { return m_context != nullptr; } + void CheckIfIdle(); + void SetActivityTime(); + void AddActiveConnection(); + void AddIdleConnection(); + std::string URLEncode(const std::string &value); + std::string URLEncode(const CURL &url); + + DWORD ConvertUnixToNT(int error); + static CURL GetResolvedUrl(const CURL& url); + +private: + SMBCCTX *m_context; + int m_OpenConnections; + unsigned int m_IdleTimeout; + static bool IsFirstInit; +}; + +extern CSMB smb; + +namespace XFILE +{ +class CSMBFile : public IFile +{ +public: + CSMBFile(); + int OpenFile(const CURL &url, std::string& strAuth); + ~CSMBFile() override; + void Close() override; + int64_t Seek(int64_t iFilePosition, int iWhence = SEEK_SET) override; + ssize_t Read(void* lpBuf, size_t uiBufSize) override; + bool Open(const CURL& url) override; + bool Exists(const CURL& url) override; + int Stat(const CURL& url, struct __stat64* buffer) override; + int Stat(struct __stat64* buffer) override; + int Truncate(int64_t size) override; + int64_t GetLength() override; + int64_t GetPosition() override; + ssize_t Write(const void* lpBuf, size_t uiBufSize) override; + + bool OpenForWrite(const CURL& url, bool bOverWrite = false) override; + bool Delete(const CURL& url) override; + bool Rename(const CURL& url, const CURL& urlnew) override; + int GetChunkSize() override { return 64*1024; } + int IoControl(EIoControl request, void* param) override; + +protected: + CURL m_url; + bool IsValidFile(const std::string& strFileName); + std::string GetAuthenticatedPath(const CURL &url); + int64_t m_fileSize; + int m_fd; + bool m_allowRetry; +}; +} diff --git a/xbmc/platform/posix/filesystem/SMBWSDiscovery.cpp b/xbmc/platform/posix/filesystem/SMBWSDiscovery.cpp new file mode 100644 index 0000000..8bab0aa --- /dev/null +++ b/xbmc/platform/posix/filesystem/SMBWSDiscovery.cpp @@ -0,0 +1,126 @@ +/* + * Copyright (C) 2021- Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "SMBWSDiscovery.h" + +#include "FileItem.h" +#include "ServiceBroker.h" +#include "network/IWSDiscovery.h" +#include "utils/StringUtils.h" +#include "utils/log.h" + +#include "platform/posix/filesystem/SMBWSDiscoveryListener.h" + +#include <algorithm> +#include <chrono> +#include <memory> +#include <mutex> +#include <string> +#include <utility> +#include <vector> + +using namespace std::chrono; +using namespace WSDiscovery; + +namespace WSDiscovery +{ +std::unique_ptr<IWSDiscovery> IWSDiscovery::GetInstance() +{ + return std::make_unique<WSDiscovery::CWSDiscoveryPosix>(); +} + +std::atomic<bool> CWSDiscoveryPosix::m_isInitialized{false}; + +CWSDiscoveryPosix::CWSDiscoveryPosix() +{ + // Set our wsd_instance ID to seconds since epoch + auto epochduration = system_clock::now().time_since_epoch(); + wsd_instance_id = epochduration.count() * system_clock::period::num / system_clock::period::den; + + m_WSDListenerUDP = std::make_unique<CWSDiscoveryListenerUDP>(); + m_isInitialized = true; +} + +CWSDiscoveryPosix::~CWSDiscoveryPosix() +{ + StopServices(); +} + +bool CWSDiscoveryPosix::StopServices() +{ + m_WSDListenerUDP->Stop(); + + return true; +} + +bool CWSDiscoveryPosix::StartServices() +{ + m_WSDListenerUDP->Start(); + + return true; +} + +bool CWSDiscoveryPosix::IsRunning() +{ + return m_WSDListenerUDP->IsRunning(); +} + +bool CWSDiscoveryPosix::GetServerList(CFileItemList& items) +{ + { + std::unique_lock<CCriticalSection> lock(m_critWSD); + + for (const auto& item : m_vecWSDInfo) + { + auto found = item.computer.find('/'); + std::string host; + if (found != std::string::npos) + host = item.computer.substr(0, found); + else + { + if (item.xaddrs_host.empty()) + continue; + host = item.xaddrs_host; + } + + CFileItemPtr pItem = std::make_shared<CFileItem>(host); + pItem->SetPath("smb://" + host + '/'); + pItem->m_bIsFolder = true; + items.Add(pItem); + } + } + return true; +} + +bool CWSDiscoveryPosix::GetCached(const std::string& strHostName, std::string& strIpAddress) +{ + const std::string match = strHostName + "/"; + + std::unique_lock<CCriticalSection> lock(m_critWSD); + for (const auto& item : m_vecWSDInfo) + { + if (!item.computer.empty() && StringUtils::StartsWithNoCase(item.computer, match)) + { + strIpAddress = item.xaddrs_host; + CLog::Log(LOGDEBUG, LOGWSDISCOVERY, "CWSDiscoveryPosix::Lookup - {} -> {}", strHostName, + strIpAddress); + return true; + } + } + + return false; +} + +void CWSDiscoveryPosix::SetItems(std::vector<wsd_req_info> entries) +{ + { + std::unique_lock<CCriticalSection> lock(m_critWSD); + m_vecWSDInfo = std::move(entries); + } +} +} // namespace WSDiscovery diff --git a/xbmc/platform/posix/filesystem/SMBWSDiscovery.h b/xbmc/platform/posix/filesystem/SMBWSDiscovery.h new file mode 100644 index 0000000..139ff11 --- /dev/null +++ b/xbmc/platform/posix/filesystem/SMBWSDiscovery.h @@ -0,0 +1,107 @@ +/* + * Copyright (C) 2021- Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "network/IWSDiscovery.h" +#include "threads/CriticalSection.h" +#include "threads/SingleLock.h" + +#include "platform/posix/filesystem/SMBWSDiscoveryListener.h" + +#include <memory> +#include <string> +#include <vector> + +class CFileItemList; + +namespace WSDiscovery +{ +class CWSDiscoveryListenerUDP; +} + +namespace WSDiscovery +{ +struct wsd_req_info +{ + std::string action; // ToDo: Action probably isnt required to be stored + std::string msgid; + std::string types; // ToDo: Types may not be needed. + std::string address; + std::string xaddrs; + std::string xaddrs_host; + std::string computer; + + bool operator==(const wsd_req_info& item) const + { + return ((item.xaddrs == xaddrs) && (item.address == address)); + } +}; + +class CWSDiscoveryPosix : public WSDiscovery::IWSDiscovery +{ +public: + CWSDiscoveryPosix(); + + // IWSDiscovery interface methods + ~CWSDiscoveryPosix() override; + bool StartServices() override; + bool StopServices() override; + bool IsRunning() override; + + /* + * Get List of smb servers found by WSD + * out (CFileItemList&) List of fileitems populated with smb addresses + * return (bool) true if >0 WSD addresses found + */ + bool GetServerList(CFileItemList& items); + + long long GetInstanceID() const { return wsd_instance_id; } + + /* + * Set List of WSD info request + * out (vector<wsd_req_info>) vector of WSD responses received + * return void + */ + void SetItems(std::vector<WSDiscovery::wsd_req_info> entries); + + /* + * Lookup host name in collected ws-discovery data + * in (const std::string&) Host name + * out (std::string&) IP address if found + * return (bool) true if found + */ + bool GetCached(const std::string& strHostName, std::string& strIpAddress); + + static bool IsInitialized() { return m_isInitialized; } + +private: + CCriticalSection m_critWSD; + + /* + * As per docs - Pg32 - http://specs.xmlsoap.org/ws/2005/04/discovery/ws-discovery.pdf + * MUST be incremented by >= 1 each time the service has gone down, lost state, + * and came back up again. SHOULD NOT be incremented otherwise. Means to set + * this value include, but are not limited to: + * • A counter that is incremented on each 'cold' boot + * • The boot time of the service, expressed as seconds elapsed since midnight + * January 1, 1970 + * + * Our implementation will only set this on creation of the class + * We arent providing services to clients, so this should be ok. + */ + long long wsd_instance_id; + + // WSD UDP daemon + std::unique_ptr<WSDiscovery::CWSDiscoveryListenerUDP> m_WSDListenerUDP; + + std::vector<WSDiscovery::wsd_req_info> m_vecWSDInfo; + + static std::atomic<bool> m_isInitialized; +}; +} // namespace WSDiscovery diff --git a/xbmc/platform/posix/filesystem/SMBWSDiscoveryListener.cpp b/xbmc/platform/posix/filesystem/SMBWSDiscoveryListener.cpp new file mode 100644 index 0000000..d42c19b --- /dev/null +++ b/xbmc/platform/posix/filesystem/SMBWSDiscoveryListener.cpp @@ -0,0 +1,608 @@ +/* + * Copyright (C) 2021- Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "SMBWSDiscoveryListener.h" + +#include "ServiceBroker.h" +#include "filesystem/CurlFile.h" +#include "settings/Settings.h" +#include "settings/SettingsComponent.h" +#include "utils/StringUtils.h" +#include "utils/log.h" + +#include "platform/posix/filesystem/SMBWSDiscovery.h" + +#include <array> +#include <chrono> +#include <mutex> +#include <stdio.h> +#include <string> +#include <utility> + +#include <arpa/inet.h> +#include <fmt/format.h> +#include <sys/select.h> +#include <unistd.h> + +using namespace WSDiscovery; + +namespace WSDiscovery +{ + +// Templates for SOAPXML messages for WS-Discovery messages +static const std::string soap_msg_templ = + "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" + "<soap:Envelope " + "xmlns:soap=\"http://www.w3.org/2003/05/soap-envelope\" " + "xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\" " + "xmlns:wsd=\"http://schemas.xmlsoap.org/ws/2005/04/discovery\" " + "xmlns:wsx=\"http://schemas.xmlsoap.org/ws/2004/09/mex\" " + "xmlns:wsdp=\"http://schemas.xmlsoap.org/ws/2006/02/devprof\" " + "xmlns:un0=\"http://schemas.microsoft.com/windows/pnpx/2005/10\" " + "xmlns:pub=\"http://schemas.microsoft.com/windows/pub/2005/07\">\n" + "<soap:Header>\n" + "<wsa:To>urn:schemas-xmlsoap-org:ws:2005:04:discovery</wsa:To>\n" + "<wsa:Action>{}</wsa:Action>\n" + "<wsa:MessageID>urn:uuid:{}</wsa:MessageID>\n" + "<wsd:AppSequence InstanceId=\"{}\" MessageNumber=\"{}\" />\n" + "{}" + "</soap:Header>\n" + "{}" + "</soap:Envelope>\n"; + +static const std::string hello_body = "<soap:Body>\n" + "<wsd:Hello>\n" + "<wsa:EndpointReference>\n" + "<wsa:Address>urn:uuid:{}</wsa:Address>\n" + "</wsa:EndpointReference>\n" + "<wsd:Types>wsdp:Device pub:Computer</wsd:Types>\n" + "<wsd:MetadataVersion>1</wsd:MetadataVersion>\n" + "</wsd:Hello>\n" + "</soap:Body>\n"; + +static const std::string bye_body = "<soap:Body>\n" + "<wsd:Bye>\n" + "<wsa:EndpointReference>\n" + "<wsa:Address>urn:uuid:{}</wsa:Address>\n" + "</wsa:EndpointReference>\n" + "<wsd:Types>wsdp:Device pub:Computer</wsd:Types>\n" + "<wsd:MetadataVersion>2</wsd:MetadataVersion>\n" + "</wsd:Bye>\n" + "</soap:Body>\n"; + +static const std::string probe_body = "<soap:Body>\n" + "<wsd:Probe>\n" + "<wsd:Types>wsdp:Device</wsd:Types>\n" + "</wsd:Probe>\n" + "</soap:Body>\n"; + +static const std::string resolve_body = "<soap:Body>\n" + "<wsd:Resolve>\n" + "<wsa:EndpointReference>\n" + "<wsa:Address>" + "{}" + "</wsa:Address>\n" + "</wsa:EndpointReference>\n" + "</wsd:Resolve>\n" + "</soap:Body>\n"; + +// These are the only actions we concern ourselves with for our WS-D implementation +static const std::string WSD_ACT_HELLO = "http://schemas.xmlsoap.org/ws/2005/04/discovery/Hello"; +static const std::string WSD_ACT_BYE = "http://schemas.xmlsoap.org/ws/2005/04/discovery/Bye"; +static const std::string WSD_ACT_PROBEMATCH = + "http://schemas.xmlsoap.org/ws/2005/04/discovery/ProbeMatches"; +static const std::string WSD_ACT_PROBE = "http://schemas.xmlsoap.org/ws/2005/04/discovery/Probe"; +static const std::string WSD_ACT_RESOLVE = + "http://schemas.xmlsoap.org/ws/2005/04/discovery/Resolve"; +static const std::string WSD_ACT_RESOLVEMATCHES = + "http://schemas.xmlsoap.org/ws/2005/04/discovery/ResolveMatches"; + + +// These are xml start/finish tags we need info from +static const std::array<std::pair<std::string, std::string>, 2> action_tag{ + {{"<wsa:Action>", "</wsa:Action>"}, + {"<wsa:Action SOAP-ENV:mustUnderstand=\"true\">", "</wsa:Action>"}}}; + +static const std::array<std::pair<std::string, std::string>, 2> msgid_tag{ + {{"<wsa:MessageID>", "</wsa:MessageID>"}, + {"<wsa:MessageID SOAP-ENV:mustUnderstand=\"true\">", "</wsa:MessageID>"}}}; + +static const std::array<std::pair<std::string, std::string>, 1> xaddrs_tag{ + {{"<wsd:XAddrs>", "</wsd:XAddrs>"}}}; + +static const std::array<std::pair<std::string, std::string>, 1> address_tag{ + {{"<wsa:Address>", "</wsa:Address>"}}}; + +static const std::array<std::pair<std::string, std::string>, 1> types_tag{ + {{"<wsd:Types>", "</wsd:Types>"}}}; + +static const std::string get_msg = + "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" + "<soap:Envelope " + "xmlns:pnpx=\"http://schemas.microsoft.com/windows/pnpx/2005/10\" " + "xmlns:pub=\"http://schemas.microsoft.com/windows/pub/2005/07\" " + "xmlns:soap=\"http://www.w3.org/2003/05/soap-envelope\" " + "xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\" " + "xmlns:wsd=\"http://schemas.xmlsoap.org/ws/2005/04/discovery\" " + "xmlns:wsdp=\"http://schemas.xmlsoap.org/ws/2006/02/devprof\" " + "xmlns:wsx=\"http://schemas.xmlsoap.org/ws/2004/09/mex\"> " + "<soap:Header> " + "<wsa:To>{}</wsa:To> " + "<wsa:Action>http://schemas.xmlsoap.org/ws/2004/09/transfer/Get</wsa:Action> " + "<wsa:MessageID>urn:uuid:{}</wsa:MessageID> " + "<wsa:ReplyTo> " + "<wsa:Address>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</wsa:Address> " + "</wsa:ReplyTo> " + "<wsa:From> " + "<wsa:Address>urn:uuid:{}</wsa:Address> " + "</wsa:From> " + "</soap:Header> " + "<soap:Body /> " + "</soap:Envelope>"; + +static const std::array<std::pair<std::string, std::string>, 1> computer_tag{ + {{"<pub:Computer>", "</pub:Computer>"}}}; + +CWSDiscoveryListenerUDP::CWSDiscoveryListenerUDP() + : CThread("WSDiscoveryListenerUDP"), wsd_instance_address(StringUtils::CreateUUID()) +{ +} + +CWSDiscoveryListenerUDP::~CWSDiscoveryListenerUDP() +{ +} + +void CWSDiscoveryListenerUDP::Stop() +{ + StopThread(true); + CLog::Log(LOGINFO, "CWSDiscoveryListenerUDP::Stop - Stopped"); +} + +void CWSDiscoveryListenerUDP::Start() +{ + if (IsRunning()) + return; + + // Clear existing data. We dont know how long service has been down, so we may not + // have correct services that may have sent BYE actions + m_vecWSDInfo.clear(); + CWSDiscoveryPosix& WSInstance = + dynamic_cast<CWSDiscoveryPosix&>(CServiceBroker::GetWSDiscovery()); + WSInstance.SetItems(m_vecWSDInfo); + + // Create thread and set low priority + Create(); + SetPriority(ThreadPriority::LOWEST); + CLog::Log(LOGINFO, "CWSDiscoveryListenerUDP::Start - Started"); +} + +void CWSDiscoveryListenerUDP::Process() +{ + fd = socket(AF_INET, SOCK_DGRAM, 0); + if (fd < 0) + { + CLog::Log(LOGDEBUG, LOGWSDISCOVERY, + "CWSDiscoveryListenerUDP::Process - Socket Creation failed"); + return; + } + + // set socket reuse + int enable = 1; + if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char*)&enable, sizeof(enable)) < 0) + { + CLog::Log(LOGDEBUG, LOGWSDISCOVERY, "CWSDiscoveryListenerUDP::Process - Reuse Option failed"); + Cleanup(true); + return; + } + + // set up destination address + struct sockaddr_in addr; + memset(&addr, 0, sizeof(addr)); + addr.sin_family = AF_INET; + addr.sin_addr.s_addr = htonl(INADDR_ANY); + addr.sin_port = htons(wsdUDP); + + // bind to receive address + if (bind(fd, (struct sockaddr*)&addr, sizeof(addr)) < 0) + { + CLog::Log(LOGDEBUG, LOGWSDISCOVERY, "CWSDiscoveryListenerUDP::Process - Bind failed"); + Cleanup(true); + return; + } + + // use setsockopt() to request join a multicast group on all interfaces + // maybe use firstconnected? + struct ip_mreq mreq; + mreq.imr_multiaddr.s_addr = inet_addr(WDSIPv4MultiGroup); + mreq.imr_interface.s_addr = htonl(INADDR_ANY); + if (setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char*)&mreq, sizeof(mreq)) < 0) + { + CLog::Log(LOGDEBUG, LOGWSDISCOVERY, + "CWSDiscoveryListenerUDP::Process - Multicast Option failed"); + Cleanup(true); + return; + } + + // Disable receiving broadcast messages on loopback + // So we dont receive messages we send. + int disable = 0; + if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP, (char*)&disable, sizeof(disable)) < 0) + { + CLog::Log(LOGDEBUG, LOGWSDISCOVERY, + "CWSDiscoveryListenerUDP::Process - Loopback Disable Option failed"); + Cleanup(true); + return; + } + + std::string bufferoutput; + fd_set rset; + int nready; + struct timeval timeout; + + FD_ZERO(&rset); + + // Send HELLO to the world + AddCommand(WSD_ACT_HELLO); + DispatchCommand(); + + AddCommand(WSD_ACT_PROBE); + DispatchCommand(); + + while (!m_bStop) + { + FD_SET(fd, &rset); + timeout.tv_sec = 3; + timeout.tv_usec = 0; + nready = select((fd + 1), &rset, NULL, NULL, &timeout); + + if (nready < 0) + break; + + if (m_bStop) + break; + + // if udp socket is readable receive the message. + if (FD_ISSET(fd, &rset)) + { + bufferoutput = ""; + char msgbuf[UDPBUFFSIZE]; + socklen_t addrlen = sizeof(addr); + int nbytes = recvfrom(fd, msgbuf, UDPBUFFSIZE, 0, (struct sockaddr*)&addr, &addrlen); + msgbuf[nbytes] = '\0'; + // turn msgbuf into std::string + bufferoutput.append(msgbuf, nbytes); + + ParseBuffer(bufferoutput); + } + // Action any commands queued + while (DispatchCommand()) + { + } + } + + // Be a nice citizen and send BYE to the world + AddCommand(WSD_ACT_BYE); + DispatchCommand(); + Cleanup(false); + return; +} + +void CWSDiscoveryListenerUDP::Cleanup(bool aborted) +{ + close(fd); + + if (aborted) + { + // Thread is stopping due to a failure state + // Update service setting to be disabled + auto settingsComponent = CServiceBroker::GetSettingsComponent(); + if (!settingsComponent) + return; + + auto settings = CServiceBroker::GetSettingsComponent()->GetSettings(); + if (!settings) + return; + + if (settings->GetBool(CSettings::SETTING_SERVICES_WSDISCOVERY)) + { + settings->SetBool(CSettings::SETTING_SERVICES_WSDISCOVERY, false); + settings->Save(); + } + } +} + +bool CWSDiscoveryListenerUDP::DispatchCommand() +{ + Command sendCommand; + { + std::unique_lock<CCriticalSection> lock(crit_commandqueue); + if (m_commandbuffer.size() <= 0) + return false; + + auto it = m_commandbuffer.begin(); + sendCommand = *it; + m_commandbuffer.erase(it); + } + + int ret; + + // As its udp, send multiple messages due to unreliability + // Windows seems to send 4-6 times for reference + for (int i = 0; i < retries; i++) + { + do + { + ret = sendto(fd, sendCommand.commandMsg.c_str(), sendCommand.commandMsg.size(), 0, + (struct sockaddr*)&sendCommand.address, sizeof(sendCommand.address)); + } while (ret == -1 && !m_bStop); + std::chrono::seconds sec(1); + CThread::Sleep(sec); + } + + CLog::Log(LOGDEBUG, LOGWSDISCOVERY, "CWSDiscoveryListenerUDP::DispatchCommand - Command sent"); + + return true; +} + +void CWSDiscoveryListenerUDP::AddCommand(const std::string& message, + const std::string& extraparameter /* = "" */) +{ + + std::unique_lock<CCriticalSection> lock(crit_commandqueue); + + std::string msg{}; + + if (!buildSoapMessage(message, msg, extraparameter)) + { + CLog::Log(LOGDEBUG, LOGWSDISCOVERY, + "CWSDiscoveryListenerUDP::AddCommand - Invalid Soap Message"); + return; + } + + // ToDo: IPv6 + struct sockaddr_in addr; + addr.sin_family = AF_INET; + addr.sin_port = htons(wsdUDP); + + addr.sin_addr.s_addr = inet_addr(WDSIPv4MultiGroup); + memset(&addr.sin_zero, 0, sizeof(addr.sin_zero)); + + Command newCommand{{addr}, {msg}}; + + m_commandbuffer.push_back(newCommand); +} + +void CWSDiscoveryListenerUDP::ParseBuffer(const std::string& buffer) +{ + wsd_req_info info; + + // MUST have an action tag + std::string action = wsd_tag_find(buffer, action_tag); + if (action.empty()) + { + CLog::Log(LOGDEBUG, LOGWSDISCOVERY, + "CWSDiscoveryListenerUDP::ParseBuffer - No Action tag found"); + return; + } + + info.action = action; + + // Only handle actions we need when received + if (!((action == WSD_ACT_HELLO) || (action == WSD_ACT_BYE) || + (action == WSD_ACT_RESOLVEMATCHES) || (action == WSD_ACT_PROBEMATCH))) + { + CLog::Log(LOGDEBUG, LOGWSDISCOVERY, + "CWSDiscoveryListenerUDP::ParseBuffer - Action not supported"); + PrintWSDInfo(info); + return; + } + + // MUST have a msgid tag + std::string msgid = wsd_tag_find(buffer, msgid_tag); + if (msgid.empty()) + { + CLog::Log(LOGDEBUG, LOGWSDISCOVERY, + "CWSDiscoveryListenerUDP::ParseBuffer - No msgid tag found"); + return; + } + + info.msgid = msgid; + + std::string types = wsd_tag_find(buffer, types_tag); + info.types = types; + std::string address = wsd_tag_find(buffer, address_tag); + info.address = address; + std::string xaddrs = wsd_tag_find(buffer, xaddrs_tag); + info.xaddrs = xaddrs; + + if (xaddrs.empty() && (action != WSD_ACT_BYE)) + { + // Do a resolve against address to hopefully receive an xaddrs field= + CLog::Log(LOGDEBUG, LOGWSDISCOVERY, + "CWSDiscoveryListenerUDP::ParseBuffer - Resolve Action dispatched"); + AddCommand(WSD_ACT_RESOLVE, address); + // Discard this message + PrintWSDInfo(info); + return; + } + + const std::string delim1 = "://"; + const std::string delim2 = ":"; + size_t found = info.xaddrs.find(delim1); + if (found != std::string::npos) + { + std::string tmpxaddrs = info.xaddrs.substr(found + delim1.size()); + if (tmpxaddrs[0] != '[') + { + found = std::min(tmpxaddrs.find(delim2), tmpxaddrs.find('/')); + info.xaddrs_host = tmpxaddrs.substr(0, found); + } + } + + { + std::unique_lock<CCriticalSection> lock(crit_wsdqueue); + auto searchitem = std::find_if(m_vecWSDInfo.begin(), m_vecWSDInfo.end(), + [info](const wsd_req_info& item) { return item == info; }); + + if (searchitem == m_vecWSDInfo.end()) + { + CWSDiscoveryPosix& WSInstance = + dynamic_cast<CWSDiscoveryPosix&>(CServiceBroker::GetWSDiscovery()); + if (info.action != WSD_ACT_BYE) + { + // Acceptable request received, add to our server list + CLog::Log(LOGDEBUG, LOGWSDISCOVERY, + "CWSDiscoveryListenerUDP::ParseBuffer - Actionable message"); + UnicastGet(info); + m_vecWSDInfo.emplace_back(info); + WSInstance.SetItems(m_vecWSDInfo); + PrintWSDInfo(info); + return; + } + else + { + // WSD_ACT_BYE does not include an xaddrs tag + // We only want to match the address when receiving a WSD_ACT_BYE message to + // remove from our maintained list + auto searchbye = std::find_if( + m_vecWSDInfo.begin(), m_vecWSDInfo.end(), + [info, this](const wsd_req_info& item) { return equalsAddress(item, info); }); + if (searchbye != m_vecWSDInfo.end()) + { + CLog::Log(LOGDEBUG, LOGWSDISCOVERY, + "CWSDiscoveryListenerUDP::ParseBuffer - BYE action -" + " removing entry"); + m_vecWSDInfo.erase(searchbye); + PrintWSDInfo(info); + WSInstance.SetItems(m_vecWSDInfo); + return; + } + } + } + } + + // Only duplicate items get this far, silently drop + return; +} + +bool CWSDiscoveryListenerUDP::buildSoapMessage(const std::string& action, + std::string& msg, + const std::string& extraparameter) +{ + auto msg_uuid = StringUtils::CreateUUID(); + std::string body; + std::string relatesTo; // Not implemented, may not be needed for our limited usage + int messagenumber = 1; + + CWSDiscoveryPosix& WSInstance = + dynamic_cast<CWSDiscoveryPosix&>(CServiceBroker::GetWSDiscovery()); + long long wsd_instance_id = WSInstance.GetInstanceID(); + + if (action == WSD_ACT_HELLO) + { + body = fmt::format(hello_body, wsd_instance_address); + } + else if (action == WSD_ACT_BYE) + { + body = fmt::format(bye_body, wsd_instance_address); + } + else if (action == WSD_ACT_PROBE) + { + body = probe_body; + } + else if (action == WSD_ACT_RESOLVE) + { + body = fmt::format(resolve_body, extraparameter); + } + if (body.empty()) + { + // May lead to excessive logspam + CLog::Log(LOGDEBUG, LOGWSDISCOVERY, + "CWSDiscoveryListenerUDP::buildSoapMessage unimplemented WSD_ACTION"); + return false; + } + + // Todo: how are fmt exception/failures handled with libfmt? + msg = fmt::format(soap_msg_templ, action, msg_uuid, wsd_instance_id, messagenumber, relatesTo, + body); + + return true; +} + +template<std::size_t SIZE> +const std::string CWSDiscoveryListenerUDP::wsd_tag_find( + const std::string& xml, const std::array<std::pair<std::string, std::string>, SIZE>& tag) +{ + for (const auto& tagpair : tag) + { + std::size_t found1 = xml.find(tagpair.first); + if (found1 != std::string::npos) + { + std::size_t found2 = xml.find(tagpair.second); + if (found2 != std::string::npos) + { + return xml.substr((found1 + tagpair.first.size()), + (found2 - (found1 + tagpair.first.size()))); + } + } + } + return ""; +} + +bool CWSDiscoveryListenerUDP::equalsAddress(const wsd_req_info& lhs, const wsd_req_info& rhs) const +{ + return lhs.address == rhs.address; +} + +void CWSDiscoveryListenerUDP::PrintWSDInfo(const wsd_req_info& info) +{ + CLog::Log(LOGDEBUG, LOGWSDISCOVERY, + "CWSDiscoveryUtils::printstruct - message contents\n" + "\tAction: {}\n" + "\tMsgID: {}\n" + "\tAddress: {}\n" + "\tTypes: {}\n" + "\tXAddrs: {}\n" + "\tComputer: {}\n", + info.action, info.msgid, info.address, info.types, info.xaddrs, info.computer); +} + +void CWSDiscoveryListenerUDP::UnicastGet(wsd_req_info& info) +{ + if (INADDR_NONE == inet_addr(info.xaddrs_host.c_str())) + { + CLog::Log(LOGDEBUG, LOGWSDISCOVERY, "CWSDiscoveryListenerUDP::UnicastGet - No IP address in {}", + info.xaddrs); + return; + } + + std::string msg = + fmt::format(get_msg, info.address, StringUtils::CreateUUID(), wsd_instance_address); + XFILE::CCurlFile file; + file.SetAcceptEncoding("identity"); + file.SetMimeType("application/soap+xml"); + file.SetUserAgent("wsd"); + file.SetRequestHeader("Connection", "Close"); + + std::string html; + if (!file.Post(info.xaddrs, msg, html)) + { + CLog::Log(LOGDEBUG, LOGWSDISCOVERY, + "CWSDiscoveryListenerUDP::UnicastGet - Could not fetch from {}", info.xaddrs); + return; + } + info.computer = wsd_tag_find(html, computer_tag); + if (info.computer.empty()) + { + CLog::Log(LOGDEBUG, LOGWSDISCOVERY, + "CWSDiscoveryListenerUDP::UnicastGet - No computer tag found"); + return; + } +} + +} // namespace WSDiscovery diff --git a/xbmc/platform/posix/filesystem/SMBWSDiscoveryListener.h b/xbmc/platform/posix/filesystem/SMBWSDiscoveryListener.h new file mode 100644 index 0000000..3459973 --- /dev/null +++ b/xbmc/platform/posix/filesystem/SMBWSDiscoveryListener.h @@ -0,0 +1,128 @@ +/* + * Copyright (C) 2021- Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "threads/CriticalSection.h" +#include "threads/Thread.h" + +#include <string> +#include <vector> + +#include <netinet/in.h> + +namespace WSDiscovery +{ +struct wsd_req_info; +} + +namespace WSDiscovery +{ +class CWSDiscoveryListenerUDP : public CThread +{ +public: + CWSDiscoveryListenerUDP(); + ~CWSDiscoveryListenerUDP(); + + void Start(); + void Stop(); + +protected: + // CThread + void Process() override; + +private: + struct Command + { + struct sockaddr_in address; + std::string commandMsg; + }; + + /* + * Dispatch UDP command from command Queue + * return (bool) true if message dispatched + */ + bool DispatchCommand(); + + /* + * Build SOAPXML command and add to command Queue + * in (string) action type + * in (string) extra data field (currently used solely for resolve addresses) + * return (void) + */ + void AddCommand(const std::string& message, const std::string& extraparameter = ""); + + /* + * Process received broadcast messages and add accepted items to + * in (string) SOAPXML Message + * return (void) + */ + void ParseBuffer(const std::string& buffer); + + /* + * Generates an XML SOAP message given a particular action type + * in (string) action type + * in/out (string) created message + * in (string) extra data field (currently used for resolve addresses) + * return (bool) true if full message crafted + */ + bool buildSoapMessage(const std::string& action, + std::string& msg, + const std::string& extraparameter); + + // Closes socket and handles setting state for WS-Discovery + void Cleanup(bool aborted); + + /* + * Use unicast Get to request computer name + * in/out (wsd_req_info&) host info to be updated + * return (void) + */ + void UnicastGet(wsd_req_info& info); + +private: + template<std::size_t SIZE> + const std::string wsd_tag_find(const std::string& xml, + const std::array<std::pair<std::string, std::string>, SIZE>& tag); + + // Debug print WSD packet data + void PrintWSDInfo(const WSDiscovery::wsd_req_info& info); + + // compare WSD entry address + bool equalsAddress(const WSDiscovery::wsd_req_info& lhs, + const WSDiscovery::wsd_req_info& rhs) const; + + // Socket FD for send/recv + int fd; + + std::vector<Command> m_commandbuffer; + + CCriticalSection crit_commandqueue; + CCriticalSection crit_wsdqueue; + + std::vector<WSDiscovery::wsd_req_info> m_vecWSDInfo; + + // GUID that should remain constant for an instance + const std::string wsd_instance_address; + + // Number of sends for UDP messages + const int retries = 4; + + // Max udp packet size (+ UDP header + IP header overhead = 65535) + const int UDPBUFFSIZE = 65507; + + // Port for unicast/multicast WSD traffic + const int wsdUDP = 3702; + + // ipv4 multicast group WSD - https://specs.xmlsoap.org/ws/2005/04/discovery/ws-discovery.pdf + const char* WDSIPv4MultiGroup = "239.255.255.250"; + + // ToDo: ipv6 broadcast address + // const char* WDSIPv6MultiGroup = "FF02::C" +}; +} // namespace WSDiscovery diff --git a/xbmc/platform/posix/main.cpp b/xbmc/platform/posix/main.cpp new file mode 100644 index 0000000..5028aaa --- /dev/null +++ b/xbmc/platform/posix/main.cpp @@ -0,0 +1,75 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#if defined(TARGET_DARWIN_OSX) +// SDL redefines main as SDL_main +#ifdef HAS_SDL +#include <SDL/SDL.h> +#endif +#endif + +#include "PlatformPosix.h" +#include "application/AppEnvironment.h" +#include "application/AppParamParser.h" +#include "platform/xbmc.h" + +#if defined(TARGET_LINUX) || defined(TARGET_FREEBSD) +#include "platform/linux/AppParamParserLinux.h" +#endif + +#include <cstdio> +#include <cstring> +#include <errno.h> +#include <locale.h> +#include <signal.h> + +#include <sys/resource.h> + +namespace +{ +extern "C" void XBMC_POSIX_HandleSignal(int sig) +{ + // Setting an atomic flag is one of the only useful things that is permitted by POSIX + // in signal handlers + CPlatformPosix::RequestQuit(); +} +} // namespace + + +int main(int argc, char* argv[]) +{ +#if defined(_DEBUG) + struct rlimit rlim; + rlim.rlim_cur = rlim.rlim_max = RLIM_INFINITY; + if (setrlimit(RLIMIT_CORE, &rlim) == -1) + fprintf(stderr, "Failed to set core size limit (%s).\n", strerror(errno)); +#endif + + // Set up global SIGINT/SIGTERM handler + struct sigaction signalHandler; + std::memset(&signalHandler, 0, sizeof(signalHandler)); + signalHandler.sa_handler = &XBMC_POSIX_HandleSignal; + signalHandler.sa_flags = SA_RESTART; + sigaction(SIGINT, &signalHandler, nullptr); + sigaction(SIGTERM, &signalHandler, nullptr); + + setlocale(LC_NUMERIC, "C"); + +#if defined(TARGET_LINUX) || defined(TARGET_FREEBSD) + CAppParamParserLinux appParamParser; +#else + CAppParamParser appParamParser; +#endif + appParamParser.Parse(argv, argc); + + CAppEnvironment::SetUp(appParamParser.GetAppParams()); + int status = XBMC_Run(true); + CAppEnvironment::TearDown(); + + return status; +} diff --git a/xbmc/platform/posix/network/CMakeLists.txt b/xbmc/platform/posix/network/CMakeLists.txt new file mode 100644 index 0000000..3f8f850 --- /dev/null +++ b/xbmc/platform/posix/network/CMakeLists.txt @@ -0,0 +1,5 @@ +set(SOURCES NetworkPosix.cpp) + +set(HEADERS NetworkPosix.h) + +core_add_library(platform_posix_network) diff --git a/xbmc/platform/posix/network/NetworkPosix.cpp b/xbmc/platform/posix/network/NetworkPosix.cpp new file mode 100644 index 0000000..003e5d7 --- /dev/null +++ b/xbmc/platform/posix/network/NetworkPosix.cpp @@ -0,0 +1,150 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "NetworkPosix.h" + +#include "utils/StringUtils.h" +#include "utils/log.h" + +#include <utility> + +#include <arpa/inet.h> +#include <net/if.h> +#include <netinet/in.h> +#include <sys/ioctl.h> +#include <sys/socket.h> + +CNetworkInterfacePosix::CNetworkInterfacePosix(CNetworkPosix* network, + std::string interfaceName, + char interfaceMacAddrRaw[6]) + : m_interfaceName(std::move(interfaceName)), + m_interfaceMacAdr(StringUtils::Format("{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}", + (uint8_t)interfaceMacAddrRaw[0], + (uint8_t)interfaceMacAddrRaw[1], + (uint8_t)interfaceMacAddrRaw[2], + (uint8_t)interfaceMacAddrRaw[3], + (uint8_t)interfaceMacAddrRaw[4], + (uint8_t)interfaceMacAddrRaw[5])) +{ + m_network = network; + memcpy(m_interfaceMacAddrRaw, interfaceMacAddrRaw, sizeof(m_interfaceMacAddrRaw)); +} + +bool CNetworkInterfacePosix::IsEnabled() const +{ + struct ifreq ifr; + strcpy(ifr.ifr_name, m_interfaceName.c_str()); + if (ioctl(m_network->GetSocket(), SIOCGIFFLAGS, &ifr) < 0) + return false; + + return ((ifr.ifr_flags & IFF_UP) == IFF_UP); +} + +bool CNetworkInterfacePosix::IsConnected() const +{ + struct ifreq ifr; + int zero = 0; + memset(&ifr, 0, sizeof(struct ifreq)); + strcpy(ifr.ifr_name, m_interfaceName.c_str()); + if (ioctl(m_network->GetSocket(), SIOCGIFFLAGS, &ifr) < 0) + return false; + + // ignore loopback + int iRunning = ((ifr.ifr_flags & IFF_RUNNING) && (!(ifr.ifr_flags & IFF_LOOPBACK))); + + if (ioctl(m_network->GetSocket(), SIOCGIFADDR, &ifr) < 0) + return false; + + // return only interfaces which has ip address + return iRunning && (0 != memcmp(ifr.ifr_addr.sa_data + sizeof(short), &zero, sizeof(int))); +} + +std::string CNetworkInterfacePosix::GetCurrentIPAddress() const +{ + std::string result; + + struct ifreq ifr; + strcpy(ifr.ifr_name, m_interfaceName.c_str()); + ifr.ifr_addr.sa_family = AF_INET; + if (ioctl(m_network->GetSocket(), SIOCGIFADDR, &ifr) >= 0) + { + result = inet_ntoa((*((struct sockaddr_in*)&ifr.ifr_addr)).sin_addr); + } + + return result; +} + +std::string CNetworkInterfacePosix::GetCurrentNetmask() const +{ + std::string result; + + struct ifreq ifr; + strcpy(ifr.ifr_name, m_interfaceName.c_str()); + ifr.ifr_addr.sa_family = AF_INET; + if (ioctl(m_network->GetSocket(), SIOCGIFNETMASK, &ifr) >= 0) + { + result = inet_ntoa((*((struct sockaddr_in*)&ifr.ifr_addr)).sin_addr); + } + + return result; +} + +std::string CNetworkInterfacePosix::GetMacAddress() const +{ + return m_interfaceMacAdr; +} + +void CNetworkInterfacePosix::GetMacAddressRaw(char rawMac[6]) const +{ + memcpy(rawMac, m_interfaceMacAddrRaw, 6); +} + +CNetworkPosix::CNetworkPosix() : CNetworkBase() +{ + m_sock = socket(AF_INET, SOCK_DGRAM, 0); +} + +CNetworkPosix::~CNetworkPosix() +{ + if (m_sock != -1) + close(CNetworkPosix::m_sock); + + std::vector<CNetworkInterface*>::iterator it = m_interfaces.begin(); + while (it != m_interfaces.end()) + { + CNetworkInterface* nInt = *it; + delete nInt; + it = m_interfaces.erase(it); + } +} + +std::vector<CNetworkInterface*>& CNetworkPosix::GetInterfaceList() +{ + return m_interfaces; +} + +//! @bug +//! Overwrite the GetFirstConnectedInterface and requery +//! the interface list if no connected device is found +//! this fixes a bug when no network is available after first start of xbmc +//! and the interface comes up during runtime +CNetworkInterface* CNetworkPosix::GetFirstConnectedInterface() +{ + CNetworkInterface* pNetIf = CNetworkBase::GetFirstConnectedInterface(); + + // no connected Interfaces found? - requeryInterfaceList + if (!pNetIf) + { + CLog::Log(LOGDEBUG, "{} no connected interface found - requery list", __FUNCTION__); + queryInterfaceList(); + //retry finding a connected if + pNetIf = CNetworkBase::GetFirstConnectedInterface(); + } + + return pNetIf; +} diff --git a/xbmc/platform/posix/network/NetworkPosix.h b/xbmc/platform/posix/network/NetworkPosix.h new file mode 100644 index 0000000..68d885e --- /dev/null +++ b/xbmc/platform/posix/network/NetworkPosix.h @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "network/Network.h" + +#include <string> +#include <vector> + +class CNetworkPosix; + +class CNetworkInterfacePosix : public CNetworkInterface +{ +public: + CNetworkInterfacePosix(CNetworkPosix* network, + std::string interfaceName, + char interfaceMacAddrRaw[6]); + virtual ~CNetworkInterfacePosix() override = default; + + bool IsEnabled() const override; + bool IsConnected() const override; + std::string GetCurrentIPAddress() const override; + std::string GetCurrentNetmask() const override; + + std::string GetMacAddress() const override; + void GetMacAddressRaw(char rawMac[6]) const override; + +protected: + std::string m_interfaceName; + CNetworkPosix* m_network; + +private: + std::string m_interfaceMacAdr; + char m_interfaceMacAddrRaw[6]; +}; + +class CNetworkPosix : public CNetworkBase +{ +public: + virtual ~CNetworkPosix() override; + + std::vector<CNetworkInterface*>& GetInterfaceList() override; + CNetworkInterface* GetFirstConnectedInterface() override; + + int GetSocket() { return m_sock; } + +protected: + CNetworkPosix(); + std::vector<CNetworkInterface*> m_interfaces; + +private: + virtual void GetMacAddress(const std::string& interfaceName, char macAddrRaw[6]) = 0; + virtual void queryInterfaceList() = 0; + int m_sock; +}; diff --git a/xbmc/platform/posix/storage/discs/CMakeLists.txt b/xbmc/platform/posix/storage/discs/CMakeLists.txt new file mode 100644 index 0000000..7587043 --- /dev/null +++ b/xbmc/platform/posix/storage/discs/CMakeLists.txt @@ -0,0 +1,7 @@ +if(ENABLE_OPTICAL) + set(SOURCES DiscDriveHandlerPosix.cpp) + + set(HEADERS DiscDriveHandlerPosix.h) + + core_add_library(platform_posix_storage_discs) +endif() diff --git a/xbmc/platform/posix/storage/discs/DiscDriveHandlerPosix.cpp b/xbmc/platform/posix/storage/discs/DiscDriveHandlerPosix.cpp new file mode 100644 index 0000000..1ef288a --- /dev/null +++ b/xbmc/platform/posix/storage/discs/DiscDriveHandlerPosix.cpp @@ -0,0 +1,152 @@ +/* + * Copyright (C) 2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "DiscDriveHandlerPosix.h" + +#include "storage/cdioSupport.h" +#include "utils/log.h" + +#include <memory> + +namespace +{ +constexpr int MAX_OPEN_RETRIES = 3; +} +using namespace MEDIA_DETECT; + +std::shared_ptr<IDiscDriveHandler> IDiscDriveHandler::CreateInstance() +{ + return std::make_shared<CDiscDriveHandlerPosix>(); +} + +DriveState CDiscDriveHandlerPosix::GetDriveState(const std::string& devicePath) +{ + DriveState driveStatus = DriveState::NOT_READY; + const std::shared_ptr<CLibcdio> libCdio = CLibcdio::GetInstance(); + if (!libCdio) + { + CLog::LogF(LOGERROR, "Failed to obtain libcdio handler"); + return driveStatus; + } + + CdIo_t* cdio = libCdio->cdio_open(devicePath.c_str(), DRIVER_UNKNOWN); + if (!cdio) + { + return driveStatus; + } + + CdioTrayStatus status = libCdio->mmc_get_tray_status(cdio); + + switch (status) + { + case CdioTrayStatus::CLOSED: + case CdioTrayStatus::UNKNOWN: + driveStatus = DriveState::CLOSED_MEDIA_UNDEFINED; + break; + + case CdioTrayStatus::OPEN: + driveStatus = DriveState::OPEN; + break; + + case CdioTrayStatus::DRIVER_ERROR: + driveStatus = DriveState::NOT_READY; + break; + + default: + CLog::LogF(LOGWARNING, "Unknown/unhandled drive state interpreted as DRIVE_NOT_READY"); + break; + } + libCdio->cdio_destroy(cdio); + + return driveStatus; +} + +TrayState CDiscDriveHandlerPosix::GetTrayState(const std::string& devicePath) +{ + TrayState trayStatus = TrayState::UNDEFINED; + const std::shared_ptr<CLibcdio> libCdio = CLibcdio::GetInstance(); + if (!libCdio) + { + CLog::LogF(LOGERROR, "Failed to obtain libcdio handler"); + return trayStatus; + } + + discmode_t discmode = CDIO_DISC_MODE_NO_INFO; + CdIo_t* cdio = libCdio->cdio_open(devicePath.c_str(), DRIVER_UNKNOWN); + if (!cdio) + { + return trayStatus; + } + + discmode = libCdio->cdio_get_discmode(cdio); + + if (discmode == CDIO_DISC_MODE_NO_INFO) + { + trayStatus = TrayState::CLOSED_NO_MEDIA; + } + else if (discmode == CDIO_DISC_MODE_ERROR) + { + trayStatus = TrayState::UNDEFINED; + } + else + { + trayStatus = TrayState::CLOSED_MEDIA_PRESENT; + } + libCdio->cdio_destroy(cdio); + + return trayStatus; +} + +void CDiscDriveHandlerPosix::EjectDriveTray(const std::string& devicePath) +{ + const std::shared_ptr<CLibcdio> libCdio = CLibcdio::GetInstance(); + if (!libCdio) + { + CLog::LogF(LOGERROR, "Failed to obtain libcdio handler"); + return; + } + + int retries = MAX_OPEN_RETRIES; + CdIo_t* cdio = libCdio->cdio_open(devicePath.c_str(), DRIVER_UNKNOWN); + while (cdio && retries-- > 0) + { + const driver_return_code_t ret = libCdio->cdio_eject_media(&cdio); + if (ret == DRIVER_OP_SUCCESS) + break; + } + libCdio->cdio_destroy(cdio); +} + +void CDiscDriveHandlerPosix::CloseDriveTray(const std::string& devicePath) +{ + const std::shared_ptr<CLibcdio> libCdio = CLibcdio::GetInstance(); + if (!libCdio) + { + CLog::LogF(LOGERROR, "Failed to obtain libcdio handler"); + return; + } + + const driver_return_code_t ret = libCdio->cdio_close_tray(devicePath.c_str(), nullptr); + if (ret != DRIVER_OP_SUCCESS) + { + CLog::LogF(LOGERROR, "Closing tray failed for device {}: {}", devicePath, + libCdio->cdio_driver_errmsg(ret)); + } +} + +void CDiscDriveHandlerPosix::ToggleDriveTray(const std::string& devicePath) +{ + if (GetDriveState(devicePath) == DriveState::OPEN) + { + CloseDriveTray(devicePath); + } + else + { + EjectDriveTray(devicePath); + } +} diff --git a/xbmc/platform/posix/storage/discs/DiscDriveHandlerPosix.h b/xbmc/platform/posix/storage/discs/DiscDriveHandlerPosix.h new file mode 100644 index 0000000..11c4d9a --- /dev/null +++ b/xbmc/platform/posix/storage/discs/DiscDriveHandlerPosix.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "storage/discs/IDiscDriveHandler.h" + +#include <string> + +class CDiscDriveHandlerPosix : public IDiscDriveHandler +{ +public: + /*! \brief Posix DiscDriveHandler constructor + */ + CDiscDriveHandlerPosix() = default; + + /*! \brief Posix DiscDriveHandler default destructor + */ + ~CDiscDriveHandlerPosix() override = default; + + /*! \brief Get the optical drive state provided its device path + * \param devicePath the path for the device drive (e.g. /dev/sr0) + * \return The drive state + */ + DriveState GetDriveState(const std::string& devicePath) override; + + /*! \brief Get the optical drive tray state provided the drive device path + * \param devicePath the path for the device drive (e.g. /dev/sr0) + * \return The drive state + */ + TrayState GetTrayState(const std::string& devicePath) override; + + /*! \brief Eject the provided drive device + * \param devicePath the path for the device drive (e.g. /dev/sr0) + */ + void EjectDriveTray(const std::string& devicePath) override; + + /*! \brief Close the provided drive device + * \note Some drives support closing appart from opening/eject + * \param devicePath the path for the device drive (e.g. /dev/sr0) + */ + void CloseDriveTray(const std::string& devicePath) override; + + /*! \brief Toggle the state of a given drive device + * + * Will internally call EjectDriveTray or CloseDriveTray depending on + * the internal state of the drive (i.e. if open -> CloseDriveTray / + * if closed -> EjectDriveTray) + * + * \param devicePath the path for the device drive (e.g. /dev/sr0) + */ + void ToggleDriveTray(const std::string& devicePath) override; +}; diff --git a/xbmc/platform/posix/threads/CMakeLists.txt b/xbmc/platform/posix/threads/CMakeLists.txt new file mode 100644 index 0000000..251a7e1 --- /dev/null +++ b/xbmc/platform/posix/threads/CMakeLists.txt @@ -0,0 +1,9 @@ +set(SOURCES RecursiveMutex.cpp) +set(HEADERS RecursiveMutex.h) + +if(NOT CORE_SYSTEM_NAME STREQUAL linux AND NOT CORE_SYSTEM_NAME STREQUAL android) + list(APPEND SOURCES ThreadImplPosix.cpp) + list(APPEND HEADERS ThreadImplPosix.h) +endif() + +core_add_library(platform_posix_threads) diff --git a/xbmc/platform/posix/threads/RecursiveMutex.cpp b/xbmc/platform/posix/threads/RecursiveMutex.cpp new file mode 100644 index 0000000..652bc37 --- /dev/null +++ b/xbmc/platform/posix/threads/RecursiveMutex.cpp @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "RecursiveMutex.h" + +namespace XbmcThreads +{ + +static pthread_mutexattr_t recursiveAttr; + +static bool SetRecursiveAttr() +{ + static bool alreadyCalled = false; + + if (!alreadyCalled) + { + pthread_mutexattr_init(&recursiveAttr); + pthread_mutexattr_settype(&recursiveAttr, PTHREAD_MUTEX_RECURSIVE); +#if !defined(TARGET_ANDROID) + pthread_mutexattr_setprotocol(&recursiveAttr, PTHREAD_PRIO_INHERIT); +#endif + alreadyCalled = true; + } + + return true; // note, we never call destroy. +} + +static bool recursiveAttrSet = SetRecursiveAttr(); + +pthread_mutexattr_t& CRecursiveMutex::getRecursiveAttr() +{ + if (!recursiveAttrSet) // this is only possible in the single threaded startup code + recursiveAttrSet = SetRecursiveAttr(); + + return recursiveAttr; +} + +} // namespace XbmcThreads diff --git a/xbmc/platform/posix/threads/RecursiveMutex.h b/xbmc/platform/posix/threads/RecursiveMutex.h new file mode 100644 index 0000000..eed0fb2 --- /dev/null +++ b/xbmc/platform/posix/threads/RecursiveMutex.h @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include <mutex> + +#include <pthread.h> +namespace XbmcThreads +{ + +/*! + * \brief This class exists purely for the ability to + * set mutex attribute PTHREAD_PRIO_INHERIT. + * Currently there is no way to set this using + * std::recursive_mutex. + * + */ +class CRecursiveMutex +{ +private: + pthread_mutex_t m_mutex; + + static pthread_mutexattr_t& getRecursiveAttr(); + +public: + CRecursiveMutex(const CRecursiveMutex&) = delete; + CRecursiveMutex& operator=(const CRecursiveMutex&) = delete; + + inline CRecursiveMutex() { pthread_mutex_init(&m_mutex, &getRecursiveAttr()); } + + inline ~CRecursiveMutex() { pthread_mutex_destroy(&m_mutex); } + + inline void lock() { pthread_mutex_lock(&m_mutex); } + + inline void unlock() { pthread_mutex_unlock(&m_mutex); } + + inline bool try_lock() { return (pthread_mutex_trylock(&m_mutex) == 0); } + + inline std::recursive_mutex::native_handle_type native_handle() { return &m_mutex; } +}; + +} // namespace XbmcThreads diff --git a/xbmc/platform/posix/threads/ThreadImplPosix.cpp b/xbmc/platform/posix/threads/ThreadImplPosix.cpp new file mode 100644 index 0000000..ae5b849 --- /dev/null +++ b/xbmc/platform/posix/threads/ThreadImplPosix.cpp @@ -0,0 +1,35 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "ThreadImplPosix.h" + +#include "utils/log.h" + +#include <pthread.h> + +std::unique_ptr<IThreadImpl> IThreadImpl::CreateThreadImpl(std::thread::native_handle_type handle) +{ + return std::make_unique<CThreadImplPosix>(handle); +} + +CThreadImplPosix::CThreadImplPosix(std::thread::native_handle_type handle) : IThreadImpl(handle) +{ +} + +void CThreadImplPosix::SetThreadInfo(const std::string& name) +{ +#if defined(TARGET_DARWIN) + pthread_setname_np(name.c_str()); +#endif +} + +bool CThreadImplPosix::SetPriority(const ThreadPriority& priority) +{ + CLog::Log(LOGDEBUG, "[threads] setting priority is not supported on this platform"); + return false; +} diff --git a/xbmc/platform/posix/threads/ThreadImplPosix.h b/xbmc/platform/posix/threads/ThreadImplPosix.h new file mode 100644 index 0000000..7bba5e1 --- /dev/null +++ b/xbmc/platform/posix/threads/ThreadImplPosix.h @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "threads/IThreadImpl.h" + +class CThreadImplPosix : public IThreadImpl +{ +public: + CThreadImplPosix(std::thread::native_handle_type handle); + + ~CThreadImplPosix() override = default; + + void SetThreadInfo(const std::string& name) override; + + bool SetPriority(const ThreadPriority& priority) override; +}; diff --git a/xbmc/platform/posix/utils/CMakeLists.txt b/xbmc/platform/posix/utils/CMakeLists.txt new file mode 100644 index 0000000..8fb2abc --- /dev/null +++ b/xbmc/platform/posix/utils/CMakeLists.txt @@ -0,0 +1,10 @@ +set(SOURCES Mmap.cpp + PosixInterfaceForCLog.cpp + SharedMemory.cpp) + +set(HEADERS FileHandle.h + Mmap.h + PosixInterfaceForCLog.h + SharedMemory.h) + +core_add_library(platform_posix_utils) diff --git a/xbmc/platform/posix/utils/FileHandle.h b/xbmc/platform/posix/utils/FileHandle.h new file mode 100644 index 0000000..e50a357 --- /dev/null +++ b/xbmc/platform/posix/utils/FileHandle.h @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2017-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "utils/ScopeGuard.h" + +#include <unistd.h> + +namespace KODI +{ +namespace UTILS +{ +namespace POSIX +{ + +class CFileHandle : public CScopeGuard<int, -1, decltype(close)> +{ +public: + CFileHandle() noexcept : CScopeGuard(close, -1) {} + explicit CFileHandle(int fd) : CScopeGuard(close, fd) {} +}; + +} +} +} diff --git a/xbmc/platform/posix/utils/Mmap.cpp b/xbmc/platform/posix/utils/Mmap.cpp new file mode 100644 index 0000000..3d40d3c --- /dev/null +++ b/xbmc/platform/posix/utils/Mmap.cpp @@ -0,0 +1,27 @@ +/* + * Copyright (C) 2017-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "Mmap.h" + +#include <system_error> + +using namespace KODI::UTILS::POSIX; + +CMmap::CMmap(void* addr, std::size_t length, int prot, int flags, int fildes, off_t offset) +: m_size{length}, m_memory{mmap(addr, length, prot, flags, fildes, offset)} +{ + if (m_memory == MAP_FAILED) + { + throw std::system_error(errno, std::generic_category(), "mmap failed"); + } +} + +CMmap::~CMmap() +{ + munmap(m_memory, m_size); +}
\ No newline at end of file diff --git a/xbmc/platform/posix/utils/Mmap.h b/xbmc/platform/posix/utils/Mmap.h new file mode 100644 index 0000000..2470d60 --- /dev/null +++ b/xbmc/platform/posix/utils/Mmap.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2017-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include <cstddef> + +#include <sys/mman.h> + +namespace KODI +{ +namespace UTILS +{ +namespace POSIX +{ + +/** + * Wrapper for mapped memory that automatically calls munmap on destruction + */ +class CMmap +{ +public: + /** + * See mmap(3p) for parameter description + */ + CMmap(void* addr, std::size_t length, int prot, int flags, int fildes, off_t offset); + ~CMmap(); + + void* Data() const + { + return m_memory; + } + std::size_t Size() const + { + return m_size; + } + +private: + CMmap(CMmap const& other) = delete; + CMmap& operator=(CMmap const& other) = delete; + + std::size_t m_size; + void* m_memory; +}; + +} +} +} diff --git a/xbmc/platform/posix/utils/PosixInterfaceForCLog.cpp b/xbmc/platform/posix/utils/PosixInterfaceForCLog.cpp new file mode 100644 index 0000000..6b8bf48 --- /dev/null +++ b/xbmc/platform/posix/utils/PosixInterfaceForCLog.cpp @@ -0,0 +1,29 @@ +/* + * Copyright (C) 2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "PosixInterfaceForCLog.h" + +#include "ServiceBroker.h" +#include "application/AppParams.h" + +#include <spdlog/sinks/dist_sink.h> +#include <spdlog/sinks/stdout_color_sinks.h> + +#if !defined(TARGET_ANDROID) && !defined(TARGET_DARWIN) +std::unique_ptr<IPlatformLog> IPlatformLog::CreatePlatformLog() +{ + return std::make_unique<CPosixInterfaceForCLog>(); +} +#endif + +void CPosixInterfaceForCLog::AddSinks( + std::shared_ptr<spdlog::sinks::dist_sink<std::mutex>> distributionSink) const +{ + if (CServiceBroker::GetAppParams()->GetLogTarget() == "console") + distributionSink->add_sink(std::make_shared<spdlog::sinks::stdout_color_sink_st>()); +} diff --git a/xbmc/platform/posix/utils/PosixInterfaceForCLog.h b/xbmc/platform/posix/utils/PosixInterfaceForCLog.h new file mode 100644 index 0000000..0336b16 --- /dev/null +++ b/xbmc/platform/posix/utils/PosixInterfaceForCLog.h @@ -0,0 +1,22 @@ +/* + * Copyright (C) 2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "utils/IPlatformLog.h" + +class CPosixInterfaceForCLog : public IPlatformLog +{ +public: + CPosixInterfaceForCLog() = default; + virtual ~CPosixInterfaceForCLog() override = default; + + spdlog_filename_t GetLogFilename(const std::string& filename) const override { return filename; } + void AddSinks( + std::shared_ptr<spdlog::sinks::dist_sink<std::mutex>> distributionSink) const override; +}; diff --git a/xbmc/platform/posix/utils/SharedMemory.cpp b/xbmc/platform/posix/utils/SharedMemory.cpp new file mode 100644 index 0000000..6c1318e --- /dev/null +++ b/xbmc/platform/posix/utils/SharedMemory.cpp @@ -0,0 +1,118 @@ +/* + * Copyright (C) 2017-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "SharedMemory.h" + +#include <fcntl.h> +#include <sys/mman.h> +#include <unistd.h> + +#if defined(HAVE_LINUX_MEMFD) +#include <linux/memfd.h> +#include <sys/syscall.h> +#endif + +#include <cerrno> +#include <cstdlib> +#include <system_error> + +#include "utils/log.h" + +using namespace KODI::UTILS::POSIX; + +CSharedMemory::CSharedMemory(std::size_t size) +: m_size{size}, m_fd{Open()}, m_mmap(nullptr, m_size, PROT_READ | PROT_WRITE, MAP_SHARED, m_fd, 0) +{ +} + +CFileHandle CSharedMemory::Open() +{ + CFileHandle fd; + try + { + fd = OpenMemfd(); + } + catch (std::system_error const& error) + { + if (error.code() == std::errc::function_not_supported) + { + CLog::Log(LOGDEBUG, "Kernel does not support memfd, falling back to plain shm"); + fd = OpenShm(); + } + else + { + throw; + } + } + + if (ftruncate(fd, m_size) < 0) + { + throw std::system_error(errno, std::generic_category(), "ftruncate"); + } + + return fd; +} + +CFileHandle CSharedMemory::OpenMemfd() +{ +#if defined(SYS_memfd_create) && defined(HAVE_LINUX_MEMFD) + // This is specific to Linux >= 3.17, but preferred over shm_create if available + // because it is race-free + int fd = syscall(SYS_memfd_create, "kodi", MFD_CLOEXEC); + if (fd < 0) + { + throw std::system_error(errno, std::generic_category(), "memfd_create"); + } + + return CFileHandle(fd); +#else + throw std::system_error(std::make_error_code(std::errc::function_not_supported), "memfd_create"); +#endif +} + +CFileHandle CSharedMemory::OpenShm() +{ + char* xdgRuntimeDir = std::getenv("XDG_RUNTIME_DIR"); + if (!xdgRuntimeDir) + { + throw std::runtime_error("XDG_RUNTIME_DIR environment variable must be set"); + } + + std::string tmpFilename(xdgRuntimeDir); + tmpFilename.append("/kodi-shared-XXXXXX"); + + int rawFd; +#if defined(HAVE_MKOSTEMP) + // Opening the file with O_CLOEXEC is preferred since it avoids races where + // other threads might exec() before setting the CLOEXEC flag + rawFd = mkostemp(&tmpFilename[0], O_CLOEXEC); +#else + rawFd = mkstemp(&tmpFilename[0]); +#endif + + if (rawFd < 0) + { + throw std::system_error(errno, std::generic_category(), "mkstemp"); + } + CFileHandle fd(rawFd); + + int flags = fcntl(fd, F_GETFD); + if (flags < 0) + { + throw std::system_error(errno, std::generic_category(), "fcntl F_GETFD"); + } + // Set FD_CLOEXEC if unset + if (!(flags & FD_CLOEXEC) && fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1) + { + throw std::system_error(errno, std::generic_category(), "fcntl F_SETFD FD_CLOEXEC"); + } + + unlink(tmpFilename.c_str()); + + return fd; +}
\ No newline at end of file diff --git a/xbmc/platform/posix/utils/SharedMemory.h b/xbmc/platform/posix/utils/SharedMemory.h new file mode 100644 index 0000000..b556de6 --- /dev/null +++ b/xbmc/platform/posix/utils/SharedMemory.h @@ -0,0 +1,62 @@ +/* + * Copyright (C) 2017-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "FileHandle.h" +#include "Mmap.h" + +#include <memory> + +namespace KODI +{ +namespace UTILS +{ +namespace POSIX +{ + +/** + * Get a chunk of shared memory of specified size + * + * The shared memory is automatically allocated, truncated to the correct size + * and memory-mapped. + */ +class CSharedMemory +{ +public: + explicit CSharedMemory(std::size_t size); + + std::size_t Size() const + { + return m_size; + } + void* Data() const + { + return m_mmap.Data(); + } + int Fd() const + { + return m_fd; + } + +private: + CSharedMemory(CSharedMemory const& other) = delete; + CSharedMemory& operator=(CSharedMemory const& other) = delete; + + CFileHandle Open(); + CFileHandle OpenMemfd(); + CFileHandle OpenShm(); + + std::size_t m_size; + CFileHandle m_fd; + CMmap m_mmap; +}; + +} +} +} diff --git a/xbmc/platform/xbmc.cpp b/xbmc/platform/xbmc.cpp new file mode 100644 index 0000000..a6de8fb --- /dev/null +++ b/xbmc/platform/xbmc.cpp @@ -0,0 +1,79 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "application/Application.h" +#include "platform/MessagePrinter.h" + +#ifdef TARGET_WINDOWS_DESKTOP +#include "platform/win32/IMMNotificationClient.h" +#include <mmdeviceapi.h> +#include <wrl/client.h> +#endif + +#if defined(TARGET_ANDROID) +#include "platform/android/activity/XBMCApp.h" +#endif + +extern "C" int XBMC_Run(bool renderGUI) +{ + int status = -1; + + if (!g_application.Create()) + { + CMessagePrinter::DisplayError("ERROR: Unable to create application. Exiting"); + return status; + } + +#if defined(TARGET_ANDROID) + CXBMCApp::Get().Initialize(); +#endif + + if (renderGUI && !g_application.CreateGUI()) + { + CMessagePrinter::DisplayError("ERROR: Unable to create GUI. Exiting"); + if (g_application.Stop(EXITCODE_QUIT)) + g_application.Cleanup(); + return status; + } + if (!g_application.Initialize()) + { + CMessagePrinter::DisplayError("ERROR: Unable to Initialize. Exiting"); + return status; + } + +#ifdef TARGET_WINDOWS_DESKTOP + Microsoft::WRL::ComPtr<IMMDeviceEnumerator> pEnumerator = nullptr; + CMMNotificationClient cMMNC; + HRESULT hr = CoCreateInstance(CLSID_MMDeviceEnumerator, nullptr, CLSCTX_ALL, IID_IMMDeviceEnumerator, + reinterpret_cast<void**>(pEnumerator.GetAddressOf())); + if (SUCCEEDED(hr)) + { + pEnumerator->RegisterEndpointNotificationCallback(&cMMNC); + pEnumerator = nullptr; + } +#endif + + status = g_application.Run(); + +#ifdef TARGET_WINDOWS_DESKTOP + // the end + hr = CoCreateInstance(CLSID_MMDeviceEnumerator, nullptr, CLSCTX_ALL, IID_IMMDeviceEnumerator, + reinterpret_cast<void**>(pEnumerator.GetAddressOf())); + if (SUCCEEDED(hr)) + { + pEnumerator->UnregisterEndpointNotificationCallback(&cMMNC); + pEnumerator = nullptr; + } +#endif + +#if defined(TARGET_ANDROID) + CXBMCApp::Get().Deinitialize(); +#endif + + return status; +} diff --git a/xbmc/platform/xbmc.h b/xbmc/platform/xbmc.h new file mode 100644 index 0000000..206acdb --- /dev/null +++ b/xbmc/platform/xbmc.h @@ -0,0 +1,15 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include <memory> + +class CAppParams; + +extern "C" int XBMC_Run(bool renderGUI); |