Adding upstream version 2:20.4+dfsg.upstream/2%20.4+dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 636 insertions, 0 deletions

diff --git a/xbmc/GUIPassword.cpp b/xbmc/GUIPassword.cpp
new file mode 100644
index 0000000..eaaa042
--- /dev/null
+++ b/xbmc/GUIPassword.cpp
@@ -0,0 +1,636 @@
+/*
+ *  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 "GUIPassword.h"
+
+#include "FileItem.h"
+#include "GUIUserMessages.h"
+#include "ServiceBroker.h"
+#include "Util.h"
+#include "dialogs/GUIDialogGamepad.h"
+#include "dialogs/GUIDialogNumeric.h"
+#include "favourites/FavouritesService.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIKeyboardFactory.h"
+#include "guilib/GUIWindowManager.h"
+#include "guilib/LocalizeStrings.h"
+#include "media/MediaLockState.h"
+#include "messaging/ApplicationMessenger.h"
+#include "messaging/helpers/DialogOKHelper.h"
+#include "profiles/ProfileManager.h"
+#include "profiles/dialogs/GUIDialogLockSettings.h"
+#include "profiles/dialogs/GUIDialogProfileSettings.h"
+#include "settings/MediaSourceSettings.h"
+#include "settings/Settings.h"
+#include "settings/SettingsComponent.h"
+#include "utils/StringUtils.h"
+#include "utils/URIUtils.h"
+#include "utils/Variant.h"
+#include "utils/log.h"
+#include "view/ViewStateSettings.h"
+
+#include <utility>
+
+using namespace KODI::MESSAGING;
+
+CGUIPassword::CGUIPassword(void)
+{
+  iMasterLockRetriesLeft = -1;
+  bMasterUser = false;
+}
+CGUIPassword::~CGUIPassword(void) = default;
+
+template<typename T>
+bool CGUIPassword::IsItemUnlocked(T pItem,
+                                  const std::string& strType,
+                                  const std::string& strLabel,
+                                  const std::string& strHeading)
+{
+  const std::shared_ptr<CProfileManager> profileManager =
+      CServiceBroker::GetSettingsComponent()->GetProfileManager();
+  if (profileManager->GetMasterProfile().getLockMode() == LOCK_MODE_EVERYONE)
+    return true;
+
+  while (pItem->m_iHasLock > LOCK_STATE_LOCK_BUT_UNLOCKED)
+  {
+    const std::string strLockCode = pItem->m_strLockCode;
+    int iResult = 0; // init to user succeeded state, doing this to optimize switch statement below
+    if (!g_passwordManager.bMasterUser) // Check if we are the MasterUser!
+    {
+      if (0 != CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(
+                   CSettings::SETTING_MASTERLOCK_MAXRETRIES) &&
+          pItem->m_iBadPwdCount >= CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(
+                                       CSettings::SETTING_MASTERLOCK_MAXRETRIES))
+      {
+        // user previously exhausted all retries, show access denied error
+        HELPERS::ShowOKDialogText(CVariant{12345}, CVariant{12346});
+        return false;
+      }
+      // show the appropriate lock dialog
+      iResult = VerifyPassword(pItem->m_iLockMode, strLockCode, strHeading);
+    }
+    switch (iResult)
+    {
+    case -1:
+      { // user canceled out
+        return false;
+        break;
+      }
+    case 0:
+      {
+        // password entry succeeded
+        pItem->m_iBadPwdCount = 0;
+        pItem->m_iHasLock = LOCK_STATE_LOCK_BUT_UNLOCKED;
+        g_passwordManager.LockSource(strType, strLabel, false);
+        CMediaSourceSettings::GetInstance().UpdateSource(strType, strLabel, "badpwdcount",
+                                                         std::to_string(pItem->m_iBadPwdCount));
+        CMediaSourceSettings::GetInstance().Save();
+
+        // a mediasource has been unlocked successfully
+        // => refresh favourites due to possible visibility changes
+        CServiceBroker::GetFavouritesService().RefreshFavourites();
+        break;
+      }
+    case 1:
+      {
+        // password entry failed
+        if (0 != CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(
+                     CSettings::SETTING_MASTERLOCK_MAXRETRIES))
+          pItem->m_iBadPwdCount++;
+        CMediaSourceSettings::GetInstance().UpdateSource(strType, strLabel, "badpwdcount",
+                                                         std::to_string(pItem->m_iBadPwdCount));
+        CMediaSourceSettings::GetInstance().Save();
+        break;
+      }
+    default:
+      {
+        // this should never happen, but if it does, do nothing
+        return false;
+        break;
+      }
+    }
+  }
+  return true;
+}
+
+bool CGUIPassword::IsItemUnlocked(CFileItem* pItem, const std::string& strType)
+{
+  const std::string strLabel = pItem->GetLabel();
+  std::string strHeading;
+  if (pItem->m_bIsFolder)
+    strHeading = g_localizeStrings.Get(12325); // "Locked! Enter code..."
+  else
+    strHeading = g_localizeStrings.Get(12348); // "Item locked"
+
+  return IsItemUnlocked<CFileItem*>(pItem, strType, strLabel, strHeading);
+}
+
+bool CGUIPassword::IsItemUnlocked(CMediaSource* pItem, const std::string& strType)
+{
+  const std::string strLabel = pItem->strName;
+  const std::string& strHeading = g_localizeStrings.Get(12325); // "Locked! Enter code..."
+
+  return IsItemUnlocked<CMediaSource*>(pItem, strType, strLabel, strHeading);
+}
+
+bool CGUIPassword::CheckStartUpLock()
+{
+  // prompt user for mastercode if the mastercode was set b4 or by xml
+  int iVerifyPasswordResult = -1;
+
+  const std::string& strHeader = g_localizeStrings.Get(20075); // "Enter master lock code"
+
+  if (iMasterLockRetriesLeft == -1)
+    iMasterLockRetriesLeft = CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(CSettings::SETTING_MASTERLOCK_MAXRETRIES);
+
+  if (g_passwordManager.iMasterLockRetriesLeft == 0)
+    g_passwordManager.iMasterLockRetriesLeft = 1;
+
+  const std::shared_ptr<CProfileManager> profileManager = CServiceBroker::GetSettingsComponent()->GetProfileManager();
+
+  std::string strPassword = profileManager->GetMasterProfile().getLockCode();
+
+  if (profileManager->GetMasterProfile().getLockMode() == 0)
+    iVerifyPasswordResult = 0;
+  else
+  {
+    for (int i=1; i <= g_passwordManager.iMasterLockRetriesLeft; i++)
+    {
+      iVerifyPasswordResult = VerifyPassword(profileManager->GetMasterProfile().getLockMode(), strPassword, strHeader);
+      if (iVerifyPasswordResult != 0 )
+      {
+        std::string strLabel1;
+        strLabel1 = g_localizeStrings.Get(12343); // "retries left"
+        int iLeft = g_passwordManager.iMasterLockRetriesLeft-i;
+        std::string strLabel = StringUtils::Format("{} {}", iLeft, strLabel1);
+
+        // PopUp OK and Display: MasterLock mode has changed but no new Mastercode has been set!
+        HELPERS::ShowOKDialogLines(CVariant{12360}, CVariant{12367}, CVariant{strLabel}, CVariant{""});
+      }
+      else
+        i=g_passwordManager.iMasterLockRetriesLeft;
+    }
+  }
+
+  if (iVerifyPasswordResult == 0)
+  {
+    g_passwordManager.iMasterLockRetriesLeft = CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(CSettings::SETTING_MASTERLOCK_MAXRETRIES);
+    return true;  // OK The MasterCode Accepted! XBMC Can Run!
+  }
+  else
+  {
+    CServiceBroker::GetAppMessenger()->PostMsg(TMSG_SHUTDOWN); // Turn off the box
+    return false;
+  }
+}
+
+bool CGUIPassword::SetMasterLockMode(bool bDetails)
+{
+  const std::shared_ptr<CProfileManager> profileManager = CServiceBroker::GetSettingsComponent()->GetProfileManager();
+
+  CProfile* profile = profileManager->GetProfile(0);
+  if (profile)
+  {
+    CProfile::CLock locks = profile->GetLocks();
+    // prompt user for master lock
+    if (CGUIDialogLockSettings::ShowAndGetLock(locks, 12360, true, bDetails))
+    {
+      profile->SetLocks(locks);
+      return true;
+    }
+  }
+  return false;
+}
+
+bool CGUIPassword::IsProfileLockUnlocked(int iProfile)
+{
+  bool bDummy;
+  return IsProfileLockUnlocked(iProfile,bDummy,true);
+}
+
+bool CGUIPassword::IsProfileLockUnlocked(int iProfile, bool& bCanceled, bool prompt)
+{
+  if (g_passwordManager.bMasterUser)
+    return true;
+
+  const std::shared_ptr<CProfileManager> profileManager = CServiceBroker::GetSettingsComponent()->GetProfileManager();
+
+  int iProfileToCheck = iProfile;
+  if (iProfile == -1)
+    iProfileToCheck = profileManager->GetCurrentProfileIndex();
+
+  if (iProfileToCheck == 0)
+    return IsMasterLockUnlocked(prompt,bCanceled);
+  else
+  {
+    const CProfile *profile = profileManager->GetProfile(iProfileToCheck);
+    if (!profile)
+      return false;
+
+    if (!prompt)
+      return (profile->getLockMode() == LOCK_MODE_EVERYONE);
+
+    if (profile->getDate().empty() &&
+       (profileManager->GetMasterProfile().getLockMode() == LOCK_MODE_EVERYONE ||
+        profile->getLockMode() == LOCK_MODE_EVERYONE))
+    {
+      // user hasn't set a password and this is the first time they've used this account
+      // so prompt for password/settings
+      if (CGUIDialogProfileSettings::ShowForProfile(iProfileToCheck, true))
+        return true;
+    }
+    else
+    {
+      if (profileManager->GetMasterProfile().getLockMode() != LOCK_MODE_EVERYONE)
+        // prompt user for profile lock code
+        return CheckLock(profile->getLockMode(),profile->getLockCode(),20095,bCanceled);
+    }
+  }
+
+  return true;
+}
+
+bool CGUIPassword::IsMasterLockUnlocked(bool bPromptUser)
+{
+  bool bDummy;
+  return IsMasterLockUnlocked(bPromptUser,bDummy);
+}
+
+bool CGUIPassword::IsMasterLockUnlocked(bool bPromptUser, bool& bCanceled)
+{
+  bCanceled = false;
+
+  if (iMasterLockRetriesLeft == -1)
+    iMasterLockRetriesLeft = CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(CSettings::SETTING_MASTERLOCK_MAXRETRIES);
+
+  const std::shared_ptr<CProfileManager> profileManager = CServiceBroker::GetSettingsComponent()->GetProfileManager();
+
+  if ((LOCK_MODE_EVERYONE < profileManager->GetMasterProfile().getLockMode() && !bMasterUser) && !bPromptUser)
+  {
+    // not unlocked, but calling code doesn't want to prompt user
+    return false;
+  }
+
+  if (g_passwordManager.bMasterUser || profileManager->GetMasterProfile().getLockMode() == LOCK_MODE_EVERYONE)
+    return true;
+
+  if (iMasterLockRetriesLeft == 0)
+  {
+    UpdateMasterLockRetryCount(false);
+    return false;
+  }
+
+  // no, unlock since we are allowed to prompt
+  const std::string& strHeading = g_localizeStrings.Get(20075);
+  std::string strPassword = profileManager->GetMasterProfile().getLockCode();
+
+  int iVerifyPasswordResult = VerifyPassword(profileManager->GetMasterProfile().getLockMode(), strPassword, strHeading);
+  if (1 == iVerifyPasswordResult)
+    UpdateMasterLockRetryCount(false);
+
+  if (0 != iVerifyPasswordResult)
+  {
+    bCanceled = true;
+    return false;
+  }
+
+  // user successfully entered mastercode
+  UpdateMasterLockRetryCount(true);
+  return true;
+}
+
+void CGUIPassword::UpdateMasterLockRetryCount(bool bResetCount)
+{
+  // \brief Updates Master Lock status.
+  // \param bResetCount masterlock retry counter is zeroed if true, or incremented and displays an Access Denied dialog if false.
+  if (!bResetCount)
+  {
+    // Bad mastercode entered
+    if (0 < CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(CSettings::SETTING_MASTERLOCK_MAXRETRIES))
+    {
+      // We're keeping track of how many bad passwords are entered
+      if (1 < g_passwordManager.iMasterLockRetriesLeft)
+      {
+        // user still has at least one retry after decrementing
+        g_passwordManager.iMasterLockRetriesLeft--;
+      }
+      else
+      {
+        // user has run out of retry attempts
+        g_passwordManager.iMasterLockRetriesLeft = 0;
+        // Tell the user they ran out of retry attempts
+        HELPERS::ShowOKDialogText(CVariant{12345}, CVariant{12346});
+        return;
+      }
+    }
+    std::string dlgLine1 = "";
+    if (0 < g_passwordManager.iMasterLockRetriesLeft)
+      dlgLine1 = StringUtils::Format("{} {}", g_passwordManager.iMasterLockRetriesLeft,
+                                     g_localizeStrings.Get(12343)); // "retries left"
+    // prompt user for master lock code
+    HELPERS::ShowOKDialogLines(CVariant{20075}, CVariant{12345}, CVariant{std::move(dlgLine1)}, CVariant{0});
+  }
+  else
+    g_passwordManager.iMasterLockRetriesLeft = CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(CSettings::SETTING_MASTERLOCK_MAXRETRIES); // user entered correct mastercode, reset retries to max allowed
+}
+
+bool CGUIPassword::CheckLock(LockType btnType, const std::string& strPassword, int iHeading)
+{
+  bool bDummy;
+  return CheckLock(btnType,strPassword,iHeading,bDummy);
+}
+
+bool CGUIPassword::CheckLock(LockType btnType, const std::string& strPassword, int iHeading, bool& bCanceled)
+{
+  bCanceled = false;
+
+  const std::shared_ptr<CProfileManager> profileManager = CServiceBroker::GetSettingsComponent()->GetProfileManager();
+
+  if (btnType == LOCK_MODE_EVERYONE ||
+      strPassword == "-" ||
+      profileManager->GetMasterProfile().getLockMode() == LOCK_MODE_EVERYONE ||
+      g_passwordManager.bMasterUser)
+  {
+    return true;
+  }
+
+  const std::string& strHeading = g_localizeStrings.Get(iHeading);
+  int iVerifyPasswordResult = VerifyPassword(btnType, strPassword, strHeading);
+
+  if (iVerifyPasswordResult == -1)
+    bCanceled = true;
+
+  return (iVerifyPasswordResult==0);
+}
+
+bool CGUIPassword::CheckSettingLevelLock(const SettingLevel& level, bool enforce /*=false*/)
+{
+  const std::shared_ptr<CProfileManager> profileManager = CServiceBroker::GetSettingsComponent()->GetProfileManager();
+
+  LOCK_LEVEL::SETTINGS_LOCK lockLevel = profileManager->GetCurrentProfile().settingsLockLevel();
+
+  if (lockLevel == LOCK_LEVEL::NONE)
+    return true;
+
+    //check if we are already in settings and in an level that needs unlocking
+  int windowID = CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow();
+  if ((int)lockLevel-1 <= (short)CViewStateSettings::GetInstance().GetSettingLevel() &&
+     (windowID == WINDOW_SETTINGS_MENU ||
+         (windowID >= WINDOW_SCREEN_CALIBRATION &&
+          windowID <= WINDOW_SETTINGS_MYPVR)))
+    return true; //Already unlocked
+
+  else if (lockLevel == LOCK_LEVEL::ALL)
+    return IsMasterLockUnlocked(true);
+  else if ((int)lockLevel-1 <= (short)level)
+  {
+    if (enforce)
+      return IsMasterLockUnlocked(true);
+    else if (!IsMasterLockUnlocked(false))
+    {
+      //Current Setting level is higher than our permission... so lower the viewing level
+      SettingLevel newLevel = (SettingLevel)(short)(lockLevel-2);
+      CViewStateSettings::GetInstance().SetSettingLevel(newLevel);
+    }
+  }
+  return true;
+
+}
+
+bool IsSettingsWindow(int iWindowID)
+{
+  return (iWindowID >= WINDOW_SCREEN_CALIBRATION && iWindowID <= WINDOW_SETTINGS_MYPVR)
+       || iWindowID == WINDOW_SKIN_SETTINGS;
+}
+
+bool CGUIPassword::CheckMenuLock(int iWindowID)
+{
+  bool bCheckPW = false;
+  int iSwitch = iWindowID;
+
+  // check if a settings subcategory was called from other than settings window
+  if (IsSettingsWindow(iWindowID))
+  {
+    int iCWindowID = CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow();
+    if (iCWindowID != WINDOW_SETTINGS_MENU && !IsSettingsWindow(iCWindowID))
+      iSwitch = WINDOW_SETTINGS_MENU;
+  }
+
+  if (iWindowID == WINDOW_MUSIC_NAV)
+  {
+    if (CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow() == WINDOW_HOME)
+      iSwitch = WINDOW_MUSIC_NAV;
+  }
+
+  if (iWindowID == WINDOW_VIDEO_NAV)
+  {
+    if (CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow() == WINDOW_HOME)
+      iSwitch = WINDOW_VIDEO_NAV;
+  }
+
+  const std::shared_ptr<CProfileManager> profileManager = CServiceBroker::GetSettingsComponent()->GetProfileManager();
+
+  switch (iSwitch)
+  {
+    case WINDOW_SETTINGS_MENU:  // Settings
+      return CheckSettingLevelLock(CViewStateSettings::GetInstance().GetSettingLevel());
+      break;
+    case WINDOW_ADDON_BROWSER:  // Addons
+      bCheckPW = profileManager->GetCurrentProfile().addonmanagerLocked();
+      break;
+    case WINDOW_FILES:          // Files
+      bCheckPW = profileManager->GetCurrentProfile().filesLocked();
+      break;
+    case WINDOW_PROGRAMS:       // Programs
+      bCheckPW = profileManager->GetCurrentProfile().programsLocked();
+      break;
+    case WINDOW_MUSIC_NAV:      // Music
+      bCheckPW = profileManager->GetCurrentProfile().musicLocked();
+      if (!bCheckPW && !m_strMediaSourcePath.empty()) // check mediasource by path
+        return g_passwordManager.IsMediaPathUnlocked(profileManager, "music");
+      break;
+    case WINDOW_VIDEO_NAV:      // Video
+      bCheckPW = profileManager->GetCurrentProfile().videoLocked();
+      if (!bCheckPW && !m_strMediaSourcePath.empty()) // check mediasource by path
+        return g_passwordManager.IsMediaPathUnlocked(profileManager, "video");
+      break;
+    case WINDOW_PICTURES:       // Pictures
+      bCheckPW = profileManager->GetCurrentProfile().picturesLocked();
+      break;
+    case WINDOW_GAMES:          // Games
+      bCheckPW = profileManager->GetCurrentProfile().gamesLocked();
+      break;
+    case WINDOW_SETTINGS_PROFILES:
+      bCheckPW = true;
+      break;
+    default:
+      bCheckPW = false;
+      break;
+  }
+  if (bCheckPW)
+    return IsMasterLockUnlocked(true); //Now let's check the PW if we need!
+  else
+    return true;
+}
+
+bool CGUIPassword::LockSource(const std::string& strType, const std::string& strName, bool bState)
+{
+  VECSOURCES* pShares = CMediaSourceSettings::GetInstance().GetSources(strType);
+  bool bResult = false;
+  for (IVECSOURCES it=pShares->begin();it != pShares->end();++it)
+  {
+    if (it->strName == strName)
+    {
+      if (it->m_iHasLock > LOCK_STATE_NO_LOCK)
+      {
+        it->m_iHasLock = bState ? LOCK_STATE_LOCKED : LOCK_STATE_LOCK_BUT_UNLOCKED;
+        bResult = true;
+      }
+      break;
+    }
+  }
+  CGUIMessage msg(GUI_MSG_NOTIFY_ALL,0,0,GUI_MSG_UPDATE_SOURCES);
+  CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg);
+
+  return bResult;
+}
+
+void CGUIPassword::LockSources(bool lock)
+{
+  // lock or unlock all sources (those with locks)
+  const char* strTypes[] = {"programs", "music", "video", "pictures", "files", "games"};
+  for (const char* const strType : strTypes)
+  {
+    VECSOURCES *shares = CMediaSourceSettings::GetInstance().GetSources(strType);
+    for (IVECSOURCES it=shares->begin();it != shares->end();++it)
+      if (it->m_iLockMode != LOCK_MODE_EVERYONE)
+        it->m_iHasLock = lock ? LOCK_STATE_LOCKED : LOCK_STATE_LOCK_BUT_UNLOCKED;
+  }
+  CGUIMessage msg(GUI_MSG_NOTIFY_ALL,0,0,GUI_MSG_UPDATE_SOURCES);
+  CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg);
+}
+
+void CGUIPassword::RemoveSourceLocks()
+{
+  // remove lock from all sources
+  const char* strTypes[] = {"programs", "music", "video", "pictures", "files", "games"};
+  for (const char* const strType : strTypes)
+  {
+    VECSOURCES *shares = CMediaSourceSettings::GetInstance().GetSources(strType);
+    for (IVECSOURCES it=shares->begin();it != shares->end();++it)
+      if (it->m_iLockMode != LOCK_MODE_EVERYONE) // remove old info
+      {
+        it->m_iHasLock = LOCK_STATE_NO_LOCK;
+        it->m_iLockMode = LOCK_MODE_EVERYONE;
+
+        // remove locks from xml
+        CMediaSourceSettings::GetInstance().UpdateSource(strType, it->strName, "lockmode", "0");
+      }
+  }
+  CMediaSourceSettings::GetInstance().Save();
+  CGUIMessage msg(GUI_MSG_NOTIFY_ALL,0,0, GUI_MSG_UPDATE_SOURCES);
+  CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg);
+}
+
+bool CGUIPassword::IsDatabasePathUnlocked(const std::string& strPath, VECSOURCES& vecSources)
+{
+  const std::shared_ptr<CProfileManager> profileManager = CServiceBroker::GetSettingsComponent()->GetProfileManager();
+
+  if (g_passwordManager.bMasterUser || profileManager->GetMasterProfile().getLockMode() == LOCK_MODE_EVERYONE)
+    return true;
+
+  // try to find the best matching source
+  bool bName = false;
+  int iIndex = CUtil::GetMatchingSource(strPath, vecSources, bName);
+
+  if (iIndex > -1 && iIndex < static_cast<int>(vecSources.size()))
+    if (vecSources[iIndex].m_iHasLock < LOCK_STATE_LOCKED)
+      return true;
+
+  return false;
+}
+
+bool CGUIPassword::IsMediaPathUnlocked(const std::shared_ptr<CProfileManager>& profileManager,
+                                       const std::string& strType) const
+{
+  if (!StringUtils::StartsWithNoCase(m_strMediaSourcePath, "root") &&
+      !StringUtils::StartsWithNoCase(m_strMediaSourcePath, "library://"))
+  {
+    if (!g_passwordManager.bMasterUser &&
+        profileManager->GetMasterProfile().getLockMode() != LOCK_MODE_EVERYONE)
+    {
+      VECSOURCES& vecSources = *CMediaSourceSettings::GetInstance().GetSources(strType);
+      bool bName = false;
+      int iIndex = CUtil::GetMatchingSource(m_strMediaSourcePath, vecSources, bName);
+      if (iIndex > -1 && iIndex < static_cast<int>(vecSources.size()))
+      {
+        return g_passwordManager.IsItemUnlocked(&vecSources[iIndex], strType);
+      }
+    }
+  }
+
+  return true;
+}
+
+bool CGUIPassword::IsMediaFileUnlocked(const std::string& type, const std::string& file) const
+{
+  std::vector<CMediaSource>* vecSources = CMediaSourceSettings::GetInstance().GetSources(type);
+
+  if (!vecSources)
+  {
+    CLog::Log(LOGERROR,
+              "{}: CMediaSourceSettings::GetInstance().GetSources(\"{}\") returned nullptr.",
+              __func__, type);
+    return true;
+  }
+
+  // try to find the best matching source for this file
+
+  bool isSourceName{false};
+  const std::string fileBasePath = URIUtils::GetBasePath(file);
+
+  int iIndex = CUtil::GetMatchingSource(fileBasePath, *vecSources, isSourceName);
+
+  if (iIndex > -1 && iIndex < static_cast<int>(vecSources->size()))
+    return (*vecSources)[iIndex].m_iHasLock < LOCK_STATE_LOCKED;
+
+  return true;
+}
+
+void CGUIPassword::OnSettingAction(const std::shared_ptr<const CSetting>& setting)
+{
+  if (setting == NULL)
+    return;
+
+  const std::string &settingId = setting->GetId();
+  if (settingId == CSettings::SETTING_MASTERLOCK_LOCKCODE)
+    SetMasterLockMode();
+}
+
+int CGUIPassword::VerifyPassword(LockType btnType, const std::string& strPassword, const std::string& strHeading)
+{
+  int iVerifyPasswordResult;
+  switch (btnType)
+  {
+  case LOCK_MODE_NUMERIC:
+    iVerifyPasswordResult = CGUIDialogNumeric::ShowAndVerifyPassword(const_cast<std::string&>(strPassword), strHeading, 0);
+    break;
+  case LOCK_MODE_GAMEPAD:
+    iVerifyPasswordResult = CGUIDialogGamepad::ShowAndVerifyPassword(const_cast<std::string&>(strPassword), strHeading, 0);
+    break;
+  case LOCK_MODE_QWERTY:
+    iVerifyPasswordResult = CGUIKeyboardFactory::ShowAndVerifyPassword(const_cast<std::string&>(strPassword), strHeading, 0);
+    break;
+  default:   // must not be supported, treat as unlocked
+    iVerifyPasswordResult = 0;
+    break;
+  }
+
+  return iVerifyPasswordResult;
+}
+