xbmc/filesystem/PipeFile.cpp

   1 /*
   2  *  Copyright (C) 2011-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "PipeFile.h"
  10
  11 #include "PipesManager.h"
  12 #include "URL.h"
  13
  14 #include <mutex>
  15
  16 using namespace XFILE;
  17
  18 CPipeFile::CPipeFile() : m_pipe(NULL)
  19 {
  20 }
  21
  22 CPipeFile::~CPipeFile()
  23 {
  24   Close();
  25 }
  26
  27 int64_t CPipeFile::GetPosition()
  28 {
  29   return m_pos;
  30 }
  31
  32 int64_t CPipeFile::GetLength()
  33 {
  34   return m_length;
  35 }
  36
  37 void CPipeFile::SetLength(int64_t len)
  38 {
  39   m_length = len;
  40 }
  41
  42 bool CPipeFile::Open(const CURL& url)
  43 {
  44   std::string name = url.Get();
  45   m_pipe = PipesManager::GetInstance().OpenPipe(name);
  46   if (m_pipe)
  47     m_pipe->AddListener(this);
  48   return (m_pipe != NULL);
  49 }
  50
  51 bool CPipeFile::Exists(const CURL& url)
  52 {
  53   std::string name = url.Get();
  54   return PipesManager::GetInstance().Exists(name);
  55 }
  56
  57 int CPipeFile::Stat(const CURL& url, struct __stat64* buffer)
  58 {
  59   return -1;
  60 }
  61
  62 int CPipeFile::Stat(struct __stat64* buffer)
  63 {
  64   if (!buffer)
  65     return -1;
  66
  67   *buffer = {};
  68   buffer->st_size = m_length;
  69   return 0;
  70 }
  71
  72 ssize_t CPipeFile::Read(void* lpBuf, size_t uiBufSize)
  73 {
  74   if (!m_pipe)
  75     return -1;
  76
  77   if (uiBufSize > SSIZE_MAX)
  78     uiBufSize = SSIZE_MAX;
  79
  80   return m_pipe->Read((char *)lpBuf,(int)uiBufSize);
  81 }
  82
  83 ssize_t CPipeFile::Write(const void* lpBuf, size_t uiBufSize)
  84 {
  85   if (!m_pipe)
  86     return -1;
  87
  88   // m_pipe->Write return bool. either all was written or not.
  89   return m_pipe->Write((const char *)lpBuf,uiBufSize) ? uiBufSize : -1;
  90 }
  91
  92 void CPipeFile::SetEof()
  93 {
  94   if (!m_pipe)
  95     return ;
  96   m_pipe->SetEof();
  97 }
  98
  99 bool CPipeFile::IsEof()
 100 {
 101   if (!m_pipe)
 102     return true;
 103   return m_pipe->IsEof();
 104 }
 105
 106 bool CPipeFile::IsEmpty()
 107 {
 108   if (!m_pipe)
 109     return true;
 110   return m_pipe->IsEmpty();
 111 }
 112
 113 int64_t CPipeFile::Seek(int64_t iFilePosition, int iWhence)
 114 {
 115   return -1;
 116 }
 117
 118 void CPipeFile::Close()
 119 {
 120   if (m_pipe)
 121   {
 122     m_pipe->RemoveListener(this);
 123     PipesManager::GetInstance().ClosePipe(m_pipe);
 124   }
 125   m_pipe = NULL;
 126 }
 127
 128 bool CPipeFile::IsClosed()
 129 {
 130   return (m_pipe == NULL);
 131 }
 132
 133 void CPipeFile::Flush()
 134 {
 135   if (m_pipe)
 136     m_pipe->Flush();
 137 }
 138
 139 bool CPipeFile::OpenForWrite(const CURL& url, bool bOverWrite)
 140 {
 141   std::string name = url.Get();
 142
 143   m_pipe = PipesManager::GetInstance().CreatePipe(name);
 144   if (m_pipe)
 145     m_pipe->AddListener(this);
 146   return (m_pipe != NULL);
 147 }
 148
 149 bool CPipeFile::Delete(const CURL& url)
 150 {
 151   return false;
 152 }
 153
 154 bool CPipeFile::Rename(const CURL& url, const CURL& urlnew)
 155 {
 156   return false;
 157 }
 158
 159 int CPipeFile::IoControl(EIoControl, void* param)
 160 {
 161   return -1;
 162 }
 163
 164 std::string CPipeFile::GetName() const
 165 {
 166   if (!m_pipe)
 167     return "";
 168   return m_pipe->GetName();
 169 }
 170
 171 void CPipeFile::OnPipeOverFlow()
 172 {
 173   std::unique_lock<CCriticalSection> lock(m_lock);
 174   for (size_t l=0; l<m_listeners.size(); l++)
 175     m_listeners[l]->OnPipeOverFlow();
 176 }
 177
 178 int64_t CPipeFile::GetAvailableRead()
 179 {
 180   return m_pipe->GetAvailableRead();
 181 }
 182
 183 void CPipeFile::OnPipeUnderFlow()
 184 {
 185   for (size_t l=0; l<m_listeners.size(); l++)
 186     m_listeners[l]->OnPipeUnderFlow();
 187 }
 188
 189 void CPipeFile::AddListener(IPipeListener *l)
 190 {
 191   std::unique_lock<CCriticalSection> lock(m_lock);
 192   for (size_t i=0; i<m_listeners.size(); i++)
 193   {
 194     if (m_listeners[i] == l)
 195       return;
 196   }
 197   m_listeners.push_back(l);
 198 }
 199
 200 void CPipeFile::RemoveListener(IPipeListener *l)
 201 {
 202   std::unique_lock<CCriticalSection> lock(m_lock);
 203   std::vector<XFILE::IPipeListener *>::iterator i = m_listeners.begin();
 204   while(i != m_listeners.end())
 205   {
 206     if ( (*i) == l)
 207       i = m_listeners.erase(i);
 208     else
 209       ++i;
 210   }
 211 }
 212
 213 void CPipeFile::SetOpenThreshold(int threshold)
 214 {
 215   m_pipe->SetOpenThreshold(threshold);
 216 }
 217