VFS.h

/*
 *  Copyright (C) 2015-2018 Team Kodi
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 *  See LICENSES/README.md for more information.
 */
 
#pragma once
 
#include "../AddonBase.h"
#include "../Filesystem.h"
#include "../c-api/addon-instance/vfs.h"
 
#ifdef __cplusplus
 
namespace kodi
{
namespace addon
{
 
class CInstanceVFS;
 
//==============================================================================
using VFSFileHandle = VFS_FILE_HANDLE;
//------------------------------------------------------------------------------
 
//==============================================================================
class ATTRIBUTE_HIDDEN VFSUrl : public CStructHdl<VFSUrl, VFSURL>
{
  friend class CInstanceVFS;
public:
 
 
  std::string GetURL() const { return m_cStructure->url; }
 
  std::string GetDomain() const { return m_cStructure->domain; }
 
  std::string GetHostname() const { return m_cStructure->hostname; }
 
  std::string GetFilename() const { return m_cStructure->filename; }
 
  unsigned int GetPort() const { return m_cStructure->port; }
 
  std::string GetOptions() const { return m_cStructure->options; }
 
  std::string GetUsername() const { return m_cStructure->username; }
 
  std::string GetPassword() const { return m_cStructure->password; }
 
  std::string GetRedacted() const { return m_cStructure->redacted; }
 
  std::string GetSharename() const { return m_cStructure->sharename; }
 
  std::string GetProtocol() const { return m_cStructure->protocol; }
 
 
private:
  VFSUrl() = delete;
  VFSUrl(const VFSUrl& channel) = delete;
  VFSUrl(const VFSURL* channel) : CStructHdl(channel) {}
  VFSUrl(VFSURL* channel) : CStructHdl(channel) {}
};
//------------------------------------------------------------------------------
 
//##############################################################################
 
//==============================================================================
//------------------------------------------------------------------------------
class ATTRIBUTE_HIDDEN CInstanceVFS : public IAddonInstance
{
public:
  //============================================================================
  explicit CInstanceVFS(KODI_HANDLE instance, const std::string& kodiVersion = "")
    : IAddonInstance(ADDON_INSTANCE_VFS,
                     !kodiVersion.empty() ? kodiVersion : GetKodiTypeVersion(ADDON_INSTANCE_VFS))
  {
    if (CAddonBase::m_interface->globalSingleInstance != nullptr)
      throw std::logic_error("kodi::addon::CInstanceVFS: Creation of multiple together with single "
                             "instance way is not allowed!");
 
    SetAddonStruct(instance);
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  ~CInstanceVFS() override = default;
  //----------------------------------------------------------------------------
 
  //============================================================================
 
  //============================================================================
 
  //============================================================================
  virtual kodi::addon::VFSFileHandle Open(const kodi::addon::VFSUrl& url) { return nullptr; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual kodi::addon::VFSFileHandle OpenForWrite(const kodi::addon::VFSUrl& url, bool overWrite)
  {
    return nullptr;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool Close(kodi::addon::VFSFileHandle context) { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual ssize_t Read(kodi::addon::VFSFileHandle context, uint8_t* buffer, size_t uiBufSize)
  {
    return -1;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual ssize_t Write(kodi::addon::VFSFileHandle context, const uint8_t* buffer, size_t uiBufSize)
  {
    return -1;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual int64_t Seek(kodi::addon::VFSFileHandle context, int64_t position, int whence)
  {
    return -1;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual int Truncate(kodi::addon::VFSFileHandle context, int64_t size) { return -1; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual int64_t GetLength(kodi::addon::VFSFileHandle context) { return 0; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual int64_t GetPosition(kodi::addon::VFSFileHandle context) { return 0; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual int GetChunkSize(kodi::addon::VFSFileHandle context) { return 1; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool IoControlGetSeekPossible(kodi::addon::VFSFileHandle context) { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool IoControlGetCacheStatus(kodi::addon::VFSFileHandle context,
                                       kodi::vfs::CacheStatus& status)
  {
    return false;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool IoControlSetCacheRate(kodi::addon::VFSFileHandle context, unsigned int rate)
  {
    return false;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool IoControlSetRetry(kodi::addon::VFSFileHandle context, bool retry) { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual int Stat(const kodi::addon::VFSUrl& url, kodi::vfs::FileStatus& buffer) { return 0; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool Exists(const kodi::addon::VFSUrl& url) { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void ClearOutIdle() {}
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void DisconnectAll() {}
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool Delete(const kodi::addon::VFSUrl& url) { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool Rename(const kodi::addon::VFSUrl& url, const kodi::addon::VFSUrl& url2)
  {
    return false;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool DirectoryExists(const kodi::addon::VFSUrl& url) { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool RemoveDirectory(const kodi::addon::VFSUrl& url) { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool CreateDirectory(const kodi::addon::VFSUrl& url) { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  class CVFSCallbacks
  {
  public:
    bool GetKeyboardInput(const std::string& heading, std::string& input, bool hiddenInput = false)
    {
      char* cInput = nullptr;
      bool ret = m_cb->get_keyboard_input(m_cb->ctx, heading.c_str(), &cInput, hiddenInput);
      if (cInput)
      {
        input = cInput;
        ::kodi::addon::CAddonBase::m_interface->toKodi->free_string(
            ::kodi::addon::CAddonBase::m_interface->toKodi->kodiBase, cInput);
      }
      return ret;
    }
 
    void SetErrorDialog(const std::string& heading,
                        const std::string& line1,
                        const std::string& line2 = "",
                        const std::string& line3 = "")
    {
      m_cb->set_error_dialog(m_cb->ctx, heading.c_str(), line1.c_str(), line2.c_str(),
                             line3.c_str());
    }
 
    void RequireAuthentication(const std::string& url)
    {
      m_cb->require_authentication(m_cb->ctx, url.c_str());
    }
 
    explicit CVFSCallbacks(const VFSGetDirectoryCallbacks* cb) : m_cb(cb) {}
 
  private:
    const VFSGetDirectoryCallbacks* m_cb;
  };
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool GetDirectory(const kodi::addon::VFSUrl& url,
                            std::vector<kodi::vfs::CDirEntry>& entries,
                            CVFSCallbacks callbacks)
  {
    return false;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool ContainsFiles(const kodi::addon::VFSUrl& url,
                             std::vector<kodi::vfs::CDirEntry>& entries,
                             std::string& rootPath)
  {
    return false;
  }
  //----------------------------------------------------------------------------
 
private:
  void SetAddonStruct(KODI_HANDLE instance)
  {
    if (instance == nullptr)
      throw std::logic_error("kodi::addon::CInstanceVFS: Creation with empty addon structure not "
                             "allowed, table must be given from Kodi!");
 
    m_instanceData = static_cast<AddonInstance_VFSEntry*>(instance);
    m_instanceData->toAddon->addonInstance = this;
    m_instanceData->toAddon->open = ADDON_Open;
    m_instanceData->toAddon->open_for_write = ADDON_OpenForWrite;
    m_instanceData->toAddon->read = ADDON_Read;
    m_instanceData->toAddon->write = ADDON_Write;
    m_instanceData->toAddon->seek = ADDON_Seek;
    m_instanceData->toAddon->truncate = ADDON_Truncate;
    m_instanceData->toAddon->get_length = ADDON_GetLength;
    m_instanceData->toAddon->get_position = ADDON_GetPosition;
    m_instanceData->toAddon->get_chunk_size = ADDON_GetChunkSize;
    m_instanceData->toAddon->io_control_get_seek_possible = ADDON_IoControlGetSeekPossible;
    m_instanceData->toAddon->io_control_get_cache_status = ADDON_IoControlGetCacheStatus;
    m_instanceData->toAddon->io_control_set_cache_rate = ADDON_IoControlSetCacheRate;
    m_instanceData->toAddon->io_control_set_retry = ADDON_IoControlSetRetry;
    m_instanceData->toAddon->stat = ADDON_Stat;
    m_instanceData->toAddon->close = ADDON_Close;
    m_instanceData->toAddon->exists = ADDON_Exists;
    m_instanceData->toAddon->clear_out_idle = ADDON_ClearOutIdle;
    m_instanceData->toAddon->disconnect_all = ADDON_DisconnectAll;
    m_instanceData->toAddon->delete_it = ADDON_Delete;
    m_instanceData->toAddon->rename = ADDON_Rename;
    m_instanceData->toAddon->directory_exists = ADDON_DirectoryExists;
    m_instanceData->toAddon->remove_directory = ADDON_RemoveDirectory;
    m_instanceData->toAddon->create_directory = ADDON_CreateDirectory;
    m_instanceData->toAddon->get_directory = ADDON_GetDirectory;
    m_instanceData->toAddon->free_directory = ADDON_FreeDirectory;
    m_instanceData->toAddon->contains_files = ADDON_ContainsFiles;
  }
 
  inline static VFS_FILE_HANDLE ADDON_Open(const AddonInstance_VFSEntry* instance,
                                           const VFSURL* url)
  {
    return static_cast<CInstanceVFS*>(instance->toAddon->addonInstance)->Open(url);
  }
 
  inline static VFS_FILE_HANDLE ADDON_OpenForWrite(const AddonInstance_VFSEntry* instance,
                                                   const VFSURL* url,
                                                   bool overWrite)
  {
    return static_cast<CInstanceVFS*>(instance->toAddon->addonInstance)
        ->OpenForWrite(url, overWrite);
  }
 
  inline static ssize_t ADDON_Read(const AddonInstance_VFSEntry* instance,
                                   VFS_FILE_HANDLE context,
                                   uint8_t* buffer,
                                   size_t uiBufSize)
  {
    return static_cast<CInstanceVFS*>(instance->toAddon->addonInstance)
        ->Read(context, buffer, uiBufSize);
  }
 
  inline static ssize_t ADDON_Write(const AddonInstance_VFSEntry* instance,
                                    VFS_FILE_HANDLE context,
                                    const uint8_t* buffer,
                                    size_t uiBufSize)
  {
    return static_cast<CInstanceVFS*>(instance->toAddon->addonInstance)
        ->Write(context, buffer, uiBufSize);
  }
 
  inline static int64_t ADDON_Seek(const AddonInstance_VFSEntry* instance,
                                   VFS_FILE_HANDLE context,
                                   int64_t position,
                                   int whence)
  {
    return static_cast<CInstanceVFS*>(instance->toAddon->addonInstance)
        ->Seek(context, position, whence);
  }
 
  inline static int ADDON_Truncate(const AddonInstance_VFSEntry* instance,
                                   VFS_FILE_HANDLE context,
                                   int64_t size)
  {
    return static_cast<CInstanceVFS*>(instance->toAddon->addonInstance)->Truncate(context, size);
  }
 
  inline static int64_t ADDON_GetLength(const AddonInstance_VFSEntry* instance,
                                        VFS_FILE_HANDLE context)
  {
    return static_cast<CInstanceVFS*>(instance->toAddon->addonInstance)->GetLength(context);
  }
 
  inline static int64_t ADDON_GetPosition(const AddonInstance_VFSEntry* instance,
                                          VFS_FILE_HANDLE context)
  {
    return static_cast<CInstanceVFS*>(instance->toAddon->addonInstance)->GetPosition(context);
  }
 
  inline static int ADDON_GetChunkSize(const AddonInstance_VFSEntry* instance,
                                       VFS_FILE_HANDLE context)
  {
    return static_cast<CInstanceVFS*>(instance->toAddon->addonInstance)->GetChunkSize(context);
  }
 
  inline static bool ADDON_IoControlGetSeekPossible(const AddonInstance_VFSEntry* instance,
                                                    VFS_FILE_HANDLE context)
  {
    return static_cast<CInstanceVFS*>(instance->toAddon->addonInstance)
        ->IoControlGetSeekPossible(context);
  }
 
  inline static bool ADDON_IoControlGetCacheStatus(const struct AddonInstance_VFSEntry* instance,
                                                   VFS_FILE_HANDLE context,
                                                   VFS_CACHE_STATUS_DATA* status)
  {
    kodi::vfs::CacheStatus cppStatus(status);
    return static_cast<CInstanceVFS*>(instance->toAddon->addonInstance)
        ->IoControlGetCacheStatus(context, cppStatus);
  }
 
  inline static bool ADDON_IoControlSetCacheRate(const struct AddonInstance_VFSEntry* instance,
                                                 VFS_FILE_HANDLE context,
                                                 unsigned int rate)
  {
    return static_cast<CInstanceVFS*>(instance->toAddon->addonInstance)
        ->IoControlSetCacheRate(context, rate);
  }
 
  inline static bool ADDON_IoControlSetRetry(const struct AddonInstance_VFSEntry* instance,
                                             VFS_FILE_HANDLE context,
                                             bool retry)
  {
    return static_cast<CInstanceVFS*>(instance->toAddon->addonInstance)
        ->IoControlSetRetry(context, retry);
  }
 
  inline static int ADDON_Stat(const AddonInstance_VFSEntry* instance,
                               const VFSURL* url,
                               struct STAT_STRUCTURE* buffer)
  {
    kodi::vfs::FileStatus cppBuffer(buffer);
    return static_cast<CInstanceVFS*>(instance->toAddon->addonInstance)->Stat(url, cppBuffer);
  }
 
  inline static bool ADDON_Close(const AddonInstance_VFSEntry* instance, VFS_FILE_HANDLE context)
  {
    return static_cast<CInstanceVFS*>(instance->toAddon->addonInstance)->Close(context);
  }
 
  inline static bool ADDON_Exists(const AddonInstance_VFSEntry* instance, const VFSURL* url)
  {
    return static_cast<CInstanceVFS*>(instance->toAddon->addonInstance)->Exists(url);
  }
 
  inline static void ADDON_ClearOutIdle(const AddonInstance_VFSEntry* instance)
  {
    return static_cast<CInstanceVFS*>(instance->toAddon->addonInstance)->ClearOutIdle();
  }
 
  inline static void ADDON_DisconnectAll(const AddonInstance_VFSEntry* instance)
  {
    return static_cast<CInstanceVFS*>(instance->toAddon->addonInstance)->DisconnectAll();
  }
 
  inline static bool ADDON_Delete(const AddonInstance_VFSEntry* instance, const VFSURL* url)
  {
    return static_cast<CInstanceVFS*>(instance->toAddon->addonInstance)->Delete(url);
  }
 
  inline static bool ADDON_Rename(const AddonInstance_VFSEntry* instance,
                                  const VFSURL* url,
                                  const VFSURL* url2)
  {
    return static_cast<CInstanceVFS*>(instance->toAddon->addonInstance)->Rename(url, url2);
  }
 
  inline static bool ADDON_DirectoryExists(const AddonInstance_VFSEntry* instance,
                                           const VFSURL* url)
  {
    return static_cast<CInstanceVFS*>(instance->toAddon->addonInstance)->DirectoryExists(url);
  }
 
  inline static bool ADDON_RemoveDirectory(const AddonInstance_VFSEntry* instance,
                                           const VFSURL* url)
  {
    return static_cast<CInstanceVFS*>(instance->toAddon->addonInstance)->RemoveDirectory(url);
  }
 
  inline static bool ADDON_CreateDirectory(const AddonInstance_VFSEntry* instance,
                                           const VFSURL* url)
  {
    return static_cast<CInstanceVFS*>(instance->toAddon->addonInstance)->CreateDirectory(url);
  }
 
  inline static bool ADDON_GetDirectory(const AddonInstance_VFSEntry* instance,
                                        const VFSURL* url,
                                        VFSDirEntry** retEntries,
                                        int* num_entries,
                                        VFSGetDirectoryCallbacks* callbacks)
  {
    std::vector<kodi::vfs::CDirEntry> addonEntries;
    bool ret = static_cast<CInstanceVFS*>(instance->toAddon->addonInstance)
                   ->GetDirectory(url, addonEntries, CVFSCallbacks(callbacks));
    if (ret)
    {
      VFSDirEntry* entries =
          static_cast<VFSDirEntry*>(malloc(sizeof(VFSDirEntry) * addonEntries.size()));
      for (unsigned int i = 0; i < addonEntries.size(); ++i)
      {
        entries[i].label = strdup(addonEntries[i].Label().c_str());
        entries[i].title = strdup(addonEntries[i].Title().c_str());
        entries[i].path = strdup(addonEntries[i].Path().c_str());
        entries[i].folder = addonEntries[i].IsFolder();
        entries[i].size = addonEntries[i].Size();
        entries[i].date_time = addonEntries[i].DateTime();
 
        entries[i].num_props = 0;
        const std::map<std::string, std::string>& props = addonEntries[i].GetProperties();
        if (!props.empty())
        {
          entries[i].properties =
              static_cast<VFSProperty*>(malloc(sizeof(VFSProperty) * props.size()));
          for (const auto& prop : props)
          {
            entries[i].properties[entries[i].num_props].name = strdup(prop.first.c_str());
            entries[i].properties[entries[i].num_props].val = strdup(prop.second.c_str());
            ++entries[i].num_props;
          }
        }
        else
          entries[i].properties = nullptr;
      }
      *retEntries = entries;
      *num_entries = static_cast<int>(addonEntries.size());
    }
    return ret;
  }
 
  inline static void ADDON_FreeDirectory(const AddonInstance_VFSEntry* instance,
                                         VFSDirEntry* entries,
                                         int num_entries)
  {
    for (int i = 0; i < num_entries; ++i)
    {
      if (entries[i].properties)
      {
        for (unsigned int j = 0; j < entries[i].num_props; ++j)
        {
          free(entries[i].properties[j].name);
          free(entries[i].properties[j].val);
        }
        free(entries[i].properties);
      }
      free(entries[i].label);
      free(entries[i].title);
      free(entries[i].path);
    }
    free(entries);
  }
 
  inline static bool ADDON_ContainsFiles(const AddonInstance_VFSEntry* instance,
                                         const VFSURL* url,
                                         VFSDirEntry** retEntries,
                                         int* num_entries,
                                         char* rootpath)
  {
    std::string cppRootPath;
    std::vector<kodi::vfs::CDirEntry> addonEntries;
    bool ret = static_cast<CInstanceVFS*>(instance->toAddon->addonInstance)
                   ->ContainsFiles(url, addonEntries, cppRootPath);
    if (ret)
    {
      strncpy(rootpath, cppRootPath.c_str(), ADDON_STANDARD_STRING_LENGTH);
 
      VFSDirEntry* entries =
          static_cast<VFSDirEntry*>(malloc(sizeof(VFSDirEntry) * addonEntries.size()));
      for (size_t i = 0; i < addonEntries.size(); ++i)
      {
        entries[i].label = strdup(addonEntries[i].Label().c_str());
        entries[i].title = strdup(addonEntries[i].Title().c_str());
        entries[i].path = strdup(addonEntries[i].Path().c_str());
        entries[i].folder = addonEntries[i].IsFolder();
        entries[i].size = addonEntries[i].Size();
        entries[i].date_time = addonEntries[i].DateTime();
 
        entries[i].num_props = 0;
        const std::map<std::string, std::string>& props = addonEntries[i].GetProperties();
        if (!props.empty())
        {
          entries[i].properties =
              static_cast<VFSProperty*>(malloc(sizeof(VFSProperty) * props.size()));
          for (const auto& prop : props)
          {
            entries[i].properties[entries[i].num_props].name = strdup(prop.first.c_str());
            entries[i].properties[entries[i].num_props].val = strdup(prop.second.c_str());
            ++entries[i].num_props;
          }
        }
        else
          entries[i].properties = nullptr;
      }
      *retEntries = entries;
      *num_entries = static_cast<int>(addonEntries.size());
    }
    return ret;
  }
 
  AddonInstance_VFSEntry* m_instanceData;
};
 
} /* namespace addon */
} /* namespace kodi */
 
#endif /* __cplusplus */