void CGUIWindowBoxeeBrowseLocal::UpdateEjectButtonState()
{
#ifndef HAS_EMBEDDED
SET_CONTROL_HIDDEN(BUTTON_EJECT);
SET_CONTROL_HIDDEN(BUTTON_EJECT_USER);
#else
CStdString strPath = ((CLocalBrowseWindowState*)m_windowState)->GetCurrentPath();
if (CUtil::HasSlashAtEnd(strPath))
{
// remove slash at the end
strPath.Delete(strPath.size() - 1);
}
if(!strPath.Equals("afp://") && !strPath.Equals("afp://all") && strPath.Find("afp://") != -1)
{
SET_CONTROL_VISIBLE(BUTTON_EJECT_USER);
SET_CONTROL_HIDDEN(BUTTON_EJECT);
return;
}
if (strPath != "network://protocols" && strPath != "")
{
SET_CONTROL_HIDDEN(BUTTON_EJECT);
SET_CONTROL_HIDDEN(BUTTON_EJECT_USER);
return;
}
VECSOURCES removableDrives;
g_mediaManager.GetRemovableDrives(removableDrives);
if (removableDrives.size() == 0)
{
SET_CONTROL_HIDDEN(BUTTON_EJECT);
SET_CONTROL_HIDDEN(BUTTON_EJECT_USER);
return;
}
SET_CONTROL_HIDDEN(BUTTON_EJECT_USER);
SET_CONTROL_VISIBLE(BUTTON_EJECT);
#endif
}
void URIUtils::RemoveSlashAtEnd(CStdString& strFolder)
{
if (IsURL(strFolder))
{
CURL url(strFolder);
CStdString file = url.GetFileName();
if (!file.IsEmpty() && file != strFolder)
{
RemoveSlashAtEnd(file);
url.SetFileName(file);
strFolder = url.Get();
return;
}
if(url.GetHostName().IsEmpty())
return;
}
while (HasSlashAtEnd(strFolder))
strFolder.Delete(strFolder.size() - 1);
}
CStdString NetworkDriveHelper::ResolveSubstDriveInPath(const CStdString& sPathIn)
{
int iLength = sPathIn.GetLength();
if(iLength < 3 || sPathIn[1] != _T(':') || sPathIn[2] != _T('\\'))
return sPathIn;
CStdString sPathExpanded;
TCHAR* szBuffer = sPathExpanded.GetBuffer(_MAX_PATH);
int iCharCount = QueryDosDevice(sPathIn.Left(2), szBuffer, 1024);
sPathExpanded.ReleaseBuffer();
if(iCharCount == 0 || sPathExpanded.Left(4) != _T("\\??\\"))
return sPathIn;
sPathExpanded.Delete(0, 4);
if(sPathExpanded[1] != _T(':'))
return sPathIn;
return sPathExpanded + sPathIn.Right(iLength - 2);
}
int CEnDeCode::SplitStringWithSeparator(const CStdString &strSource , const CStdString &strSeparator , std::vector<CStdString> &strVector , BOOL bIsIncludeEmpty)
{
CStdString strSourceTemp = strSource ;
CStdString strTemp = _T("") ;
strVector.clear() ;
if ( strSource == _T("") )
{
return 0 ;
}
DWORD dwSeparatorLen = strSeparator.GetLength() ;
int nPostion = strSourceTemp.Find(strSeparator) ;
if (nPostion == -1)
{
strVector.push_back(strSourceTemp) ;
return strVector.size() ;
}
while (nPostion != -1)
{
strTemp = strSourceTemp.Left(nPostion) ;
if ( !strTemp.IsEmpty() || bIsIncludeEmpty)
{
strVector.push_back(strTemp) ;
}
strSourceTemp.Delete(0 , strTemp.GetLength()+dwSeparatorLen) ;
strTemp.Empty();
nPostion = strSourceTemp.Find(strSeparator) ;
}
if ( !strSourceTemp.IsEmpty() || bIsIncludeEmpty)
{
strVector.push_back(strSourceTemp) ;
}
return strVector.size() ;
}
/// \brief Build a directory history string
/// \param pItem Item to build the history string from
/// \param strHistoryString History string build as return value
void CGUIWindowFileManager::GetDirectoryHistoryString(const CFileItem* pItem, CStdString& strHistoryString)
{
if (pItem->m_bIsShareOrDrive)
{
// We are in the virtual directory
// History string of the DVD drive
// must be handel separately
if (pItem->m_iDriveType == CMediaSource::SOURCE_TYPE_DVD)
{
// Remove disc label from item label
// and use as history string, m_strPath
// can change for new discs
CStdString strLabel = pItem->GetLabel();
int nPosOpen = strLabel.Find('(');
int nPosClose = strLabel.ReverseFind(')');
if (nPosOpen > -1 && nPosClose > -1 && nPosClose > nPosOpen)
{
strLabel.Delete(nPosOpen + 1, (nPosClose) - (nPosOpen + 1));
strHistoryString = strLabel;
}
else
strHistoryString = strLabel;
}
else
{
// Other items in virtual directory
strHistoryString = pItem->GetLabel() + pItem->m_strPath;
CUtil::RemoveSlashAtEnd(strHistoryString);
}
}
else
{
// Normal directory items
strHistoryString = pItem->m_strPath;
CUtil::RemoveSlashAtEnd(strHistoryString);
}
}
void CDirectoryCache::ClearDirectory(const CStdString& strPath1)
{
CSingleLock lock (m_cs);
CStdString strPath = _P(strPath1);
if (CUtil::HasSlashAtEnd(strPath))
strPath.Delete(strPath.size() - 1);
ivecCache i = g_directoryCache.m_vecCache.begin();
while (i != g_directoryCache.m_vecCache.end() )
{
CDir* dir = *i;
if (dir->m_strPath == strPath)
{
dir->m_Items->Clear(); // will clean up everything
delete dir->m_Items;
delete dir;
g_directoryCache.m_vecCache.erase(i);
return ;
}
++i;
}
}
bool CDirectoryTuxBox::GetDirectory(const CStdString& strPath, CFileItemList &items)
{
// so we know that we have enigma2
static bool enigma2 = false;
// Detect and delete slash at end
CStdString strRoot = strPath;
if (CUtil::HasSlashAtEnd(strRoot))
strRoot.Delete(strRoot.size() - 1);
//Get the request strings
CStdString strBQRequest;
CStdString strXMLRootString;
CStdString strXMLChildString;
if(!GetRootAndChildString(strRoot, strBQRequest, strXMLRootString, strXMLChildString))
return false;
//Set url Protocol
CURL url(strRoot);
CStdString strFilter;
CStdString protocol = url.GetProtocol();
CStdString strOptions = url.GetOptions();
url.SetProtocol("http");
bool bIsBouquet=false;
int ipoint = strOptions.Find("?path=");
if (ipoint >=0)
{
// send Zap!
return g_tuxbox.ZapToUrl(url, strOptions, ipoint);
}
else
{
ipoint = strOptions.Find("&reference=");
if (ipoint >=0 || enigma2)
{
//List reference
strFilter = strOptions.Right((strOptions.size()-(ipoint+11)));
bIsBouquet = false; //On Empty is Bouquet
if (enigma2)
{
CStdString strPort;
strPort.Format(":%i",url.GetPort());
if (strRoot.Right(strPort.GetLength()) != strPort) // If not root dir, enable Channels
strFilter = "e2"; // Disable Bouquets for Enigma2
GetRootAndChildStringEnigma2(strBQRequest, strXMLRootString, strXMLChildString);
url.SetOptions("");
url.SetFileName(strBQRequest);
}
}
}
if(strFilter.IsEmpty())
{
url.SetOptions(strBQRequest);
bIsBouquet = true;
}
//Open
CFileCurl http;
int iTryConnect = 0;
int iWaitTimer = 20;
bool result = false;
while (iTryConnect < 4)
{
http.SetTimeout(iWaitTimer);
if(http.Open(url))
{
//We are connected!
iTryConnect = 4;
// restore protocol
url.SetProtocol(protocol);
int size_read = 0;
int size_total = (int)http.GetLength();
int data_size = 0;
CStdString data;
data.reserve(size_total);
// read response from server into string buffer
char buffer[16384];
while ((size_read = http.Read(buffer, sizeof(buffer)-1)) > 0)
{
buffer[size_read] = 0;
data += buffer;
data_size += size_read;
}
http.Close();
// parse returned xml
TiXmlDocument doc;
data.Replace("></",">-</"); //FILL EMPTY ELEMENTS WITH "-"!
doc.Parse(data.c_str());
TiXmlElement *root = doc.RootElement();
if(root == NULL)
{
CLog::Log(LOGERROR, "%s - Unable to parse xml", __FUNCTION__);
CLog::Log(LOGERROR, "%s - Sample follows...\n%s", __FUNCTION__, data.c_str());
return false;
}
if( strXMLRootString.Equals(root->Value()) && bIsBouquet)
{
data.Empty();
if (enigma2)
result = g_tuxbox.ParseBouquetsEnigma2(root, items, url, strFilter, strXMLChildString);
else
result = g_tuxbox.ParseBouquets(root, items, url, strFilter, strXMLChildString);
}
else if( strXMLRootString.Equals(root->Value()) && !strFilter.IsEmpty() )
{
data.Empty();
if (enigma2)
result = g_tuxbox.ParseChannelsEnigma2(root, items, url, strFilter, strXMLChildString);
else
result = g_tuxbox.ParseChannels(root, items, url, strFilter, strXMLChildString);
}
else
{
CLog::Log(LOGERROR, "%s - Invalid root xml element for TuxBox", __FUNCTION__);
CLog::Log(LOGERROR, "%s - Sample follows...\n%s", __FUNCTION__, data.c_str());
data.Empty();
result = false;
}
}
else
{
CLog::Log(LOGERROR, "%s - Unable to get XML structure! Try count:%i, Wait Timer:%is",__FUNCTION__, iTryConnect, iWaitTimer);
iTryConnect++;
if (iTryConnect == 2) //try enigma2 instead of enigma1, best entrypoint here i thought
{
enigma2 = true;
GetRootAndChildStringEnigma2(strBQRequest, strXMLRootString, strXMLChildString);
url.SetOptions("");
url.SetFileName(strBQRequest);
// iTryConnect = 0;
iWaitTimer = 20;
}
else
iWaitTimer = iWaitTimer+10;
result = false;
http.Close(); // Close old connections
}
}
return result;
}
bool CPlexDirectory::GetDirectory(const CStdString& strPath, CFileItemList &items)
{
CStdString strRoot = strPath;
if (CUtil::HasSlashAtEnd(strRoot) && strRoot != "plex://")
strRoot.Delete(strRoot.size() - 1);
strRoot.Replace(" ", "%20");
// Start the download thread running.
printf("PlexDirectory::GetDirectory(%s)\n", strRoot.c_str());
m_url = strRoot;
CThread::Create(false, 0);
// Now display progress, look for cancel.
CGUIDialogProgress* dlgProgress = 0;
int time = GetTickCount();
while (m_downloadEvent.WaitMSec(100) == false)
{
// If enough time has passed, display the dialog.
if (GetTickCount() - time > 1000 && m_allowPrompting == true)
{
dlgProgress = (CGUIDialogProgress*)m_gWindowManager.GetWindow(WINDOW_DIALOG_PROGRESS);
if (dlgProgress)
{
dlgProgress->ShowProgressBar(false);
dlgProgress->SetHeading(40203);
dlgProgress->SetLine(0, 40204);
dlgProgress->SetLine(1, "");
dlgProgress->SetLine(2, "");
dlgProgress->StartModal();
}
}
if (dlgProgress)
{
dlgProgress->Progress();
if (dlgProgress->IsCanceled())
{
items.m_wasListingCancelled = true;
m_http.Cancel();
StopThread();
}
}
}
if (dlgProgress)
dlgProgress->Close();
// Wait for the thread to exit.
WaitForThreadExit(INFINITE);
// See if we suceeded.
if (m_bSuccess == false)
return false;
// See if we're supposed to parse the results or not.
if (m_bParseResults == false)
return true;
// Parse returned xml.
TiXmlDocument doc;
doc.Parse(m_data.c_str());
TiXmlElement* root = doc.RootElement();
if (root == 0)
{
CLog::Log(LOGERROR, "%s - Unable to parse XML\n%s", __FUNCTION__, m_data.c_str());
return false;
}
// Get the fanart.
const char* fanart = root->Attribute("art");
string strFanart;
if (fanart && strlen(fanart) > 0)
strFanart = ProcessUrl(strPath, fanart, false);
// Walk the parsed tree.
string strFileLabel = "%N - %T";
string strDirLabel = "%B";
string strSecondDirLabel = "%Y";
Parse(m_url, root, items, strFileLabel, strDirLabel, strSecondDirLabel);
// Set the window titles
const char* title1 = root->Attribute("title1");
const char* title2 = root->Attribute("title2");
if (title1 && strlen(title1) > 0)
items.SetFirstTitle(title1);
if (title2 && strlen(title2) > 0)
items.SetSecondTitle(title2);
// Set fanart on items if they don't have their own.
for (int i=0; i<items.Size(); i++)
{
CFileItemPtr pItem = items[i];
if (strFanart.size() > 0 && pItem->GetQuickFanart().size() == 0)
pItem->SetQuickFanart(strFanart);
// Make sure sort label is lower case.
string sortLabel = pItem->GetLabel();
boost::to_lower(sortLabel);
pItem->SetSortLabel(sortLabel);
}
// Set fanart on directory.
if (strFanart.size() > 0)
items.SetQuickFanart(strFanart);
// Set the view mode.
const char* viewmode = root->Attribute("viewmode");
if (viewmode && strlen(viewmode) > 0)
{
CGUIViewState* viewState = CGUIViewState::GetViewState(0, items);
viewState->SaveViewAsControl(atoi(viewmode));
}
// Override labels.
const char* fileLabel = root->Attribute("filelabel");
if (fileLabel && strlen(fileLabel) > 0)
strFileLabel = fileLabel;
const char* dirLabel = root->Attribute("dirlabel");
if (dirLabel && strlen(dirLabel) > 0)
strDirLabel = dirLabel;
// Add the sort method.
items.AddSortMethod(SORT_METHOD_NONE, 552, LABEL_MASKS(strFileLabel, "%D", strDirLabel, strSecondDirLabel));
// Set the content label.
const char* content = root->Attribute("content");
if (content && strlen(content) > 0)
{
items.SetContent(content);
}
// Check for dialog message attributes
CStdString strMessage = "";
const char* header = root->Attribute("header");
if (header && strlen(header) > 0)
{
const char* message = root->Attribute("message");
if (message && strlen(message) > 0)
strMessage = message;
items.m_displayMessage = true;
items.m_displayMessageTitle = header;
items.m_displayMessageContents = root->Attribute("message");
// Don't cache these.
m_dirCacheType = DIR_CACHE_NEVER;
}
// See if this directory replaces the parent.
const char* replace = root->Attribute("replaceParent");
if (replace && strcmp(replace, "1") == 0)
items.SetReplaceListing(true);
// See if we're saving this into the history or not.
const char* noHistory = root->Attribute("noHistory");
if (noHistory && strcmp(noHistory, "1") == 0)
items.SetSaveInHistory(false);
// See if we're not supposed to cache this directory.
const char* noCache = root->Attribute("nocache");
if (noCache && strcmp(noCache, "1") == 0)
m_dirCacheType = DIR_CACHE_NEVER;
return true;
}
bool PVRIptvData::LoadPlayList(void)
{
if (m_strM3uUrl.IsEmpty())
{
XBMC->Log(LOG_NOTICE, "Playlist file path is not configured. Channels not loaded.");
return false;
}
CStdString strPlaylistContent;
if (!GetCachedFileContents(M3U_FILE_NAME, m_strM3uUrl, strPlaylistContent))
{
XBMC->Log(LOG_ERROR, "Unable to load playlist file '%s': file is missing or empty.", m_strM3uUrl.c_str());
return false;
}
std::stringstream stream(strPlaylistContent);
/* load channels */
bool bFirst = true;
int iUniqueChannelId = 0;
int iUniqueGroupId = 0;
int iCurrentGroupId = 0;
int iChannelNum = 0;
int iEPGTimeShift = 0;
PVRIptvChannel tmpChannel;
tmpChannel.strTvgId = "";
tmpChannel.strChannelName = "";
tmpChannel.strTvgName = "";
tmpChannel.strTvgLogo = "";
tmpChannel.iTvgShift = 0;
char szLine[1024];
while(stream.getline(szLine, 1024))
{
CStdString strLine = "";
strLine.append(szLine);
strLine.TrimRight(" \t\r\n");
strLine.TrimLeft(" \t");
if (strLine.IsEmpty())
{
continue;
}
if (bFirst)
{
bFirst = false;
if (strLine.Left(3) == "\xEF\xBB\xBF")
{
strLine.Delete(0, 3);
}
if (strLine.Left((int)strlen(M3U_START_MARKER)) == M3U_START_MARKER)
{
double fTvgShift = atof(ReadMarkerValue(strLine, TVG_INFO_SHIFT_MARKER));
iEPGTimeShift = (int) (fTvgShift * 3600.0);
continue;
}
else
{
break;
}
}
if (strLine.Left((int)strlen(M3U_INFO_MARKER)) == M3U_INFO_MARKER)
{
bool bRadio = false;
double fTvgShift = 0;
CStdString strChnlName = "";
CStdString strTvgId = "";
CStdString strTvgName = "";
CStdString strTvgLogo = "";
CStdString strGroupName = "";
CStdString strRadio = "";
// parse line
int iColon = (int)strLine.Find(':');
int iComma = (int)strLine.ReverseFind(',');
if (iColon >= 0 && iComma >= 0 && iComma > iColon)
{
// parse name
iComma++;
strChnlName = strLine.Right((int)strLine.size() - iComma).Trim();
tmpChannel.strChannelName = XBMC->UnknownToUTF8(strChnlName);
// parse info
CStdString strInfoLine = strLine.Mid(++iColon, --iComma - iColon);
strTvgId = ReadMarkerValue(strInfoLine, TVG_INFO_ID_MARKER);
strTvgName = ReadMarkerValue(strInfoLine, TVG_INFO_NAME_MARKER);
strTvgLogo = ReadMarkerValue(strInfoLine, TVG_INFO_LOGO_MARKER);
strGroupName = ReadMarkerValue(strInfoLine, GROUP_NAME_MARKER);
strRadio = ReadMarkerValue(strInfoLine, RADIO_MARKER);
fTvgShift = atof(ReadMarkerValue(strInfoLine, TVG_INFO_SHIFT_MARKER));
if (strTvgId.IsEmpty())
{
char buff[255];
sprintf(buff, "%d", atoi(strInfoLine));
strTvgId.append(buff);
}
if (strTvgLogo.IsEmpty())
{
strTvgLogo = strChnlName;
}
bRadio = !strRadio.CompareNoCase("true");
tmpChannel.strTvgId = strTvgId;
tmpChannel.strTvgName = XBMC->UnknownToUTF8(strTvgName);
tmpChannel.strTvgLogo = XBMC->UnknownToUTF8(strTvgLogo);
tmpChannel.iTvgShift = (int)(fTvgShift * 3600.0);
tmpChannel.bRadio = bRadio;
if (tmpChannel.iTvgShift == 0 && iEPGTimeShift != 0)
{
tmpChannel.iTvgShift = iEPGTimeShift;
}
if (!strGroupName.IsEmpty())
{
strGroupName = XBMC->UnknownToUTF8(strGroupName);
PVRIptvChannelGroup * pGroup;
if ((pGroup = FindGroup(strGroupName)) == NULL)
{
PVRIptvChannelGroup group;
group.strGroupName = strGroupName;
group.iGroupId = ++iUniqueGroupId;
group.bRadio = bRadio;
m_groups.push_back(group);
iCurrentGroupId = iUniqueGroupId;
}
else
{
iCurrentGroupId = pGroup->iGroupId;
}
}
}
}
else if (strLine[0] != '#')
{
PVRIptvChannel channel;
channel.iUniqueId = ++iUniqueChannelId;
channel.iChannelNumber = ++iChannelNum;
channel.strTvgId = tmpChannel.strTvgId;
channel.strChannelName = tmpChannel.strChannelName;
channel.strTvgName = tmpChannel.strTvgName;
channel.strTvgLogo = tmpChannel.strTvgLogo;
channel.iTvgShift = tmpChannel.iTvgShift;
channel.bRadio = tmpChannel.bRadio;
channel.strStreamURL = strLine;
channel.iEncryptionSystem = 0;
if (iCurrentGroupId > 0)
{
channel.bRadio = m_groups.at(iCurrentGroupId - 1).bRadio;
m_groups.at(iCurrentGroupId - 1).members.push_back(channel.iChannelNumber);
}
m_channels.push_back(channel);
tmpChannel.strTvgId = "";
tmpChannel.strChannelName = "";
tmpChannel.strTvgName = "";
tmpChannel.strTvgLogo = "";
tmpChannel.iTvgShift = 0;
tmpChannel.bRadio = false;
}
}
stream.clear();
if (m_channels.size() == 0)
{
XBMC->Log(LOG_ERROR, "Unable to load channels from file '%s': file is corrupted.", m_strM3uUrl.c_str());
return false;
}
ApplyChannelsLogos();
XBMC->Log(LOG_NOTICE, "Loaded %d channels.", m_channels.size());
return true;
}
void CURL::Parse(const CStdString& strURL1)
{
Reset();
// start by validating the path
CStdString strURL = CUtil::ValidatePath(strURL1);
// strURL can be one of the following:
// format 1: protocol://[username:password]@hostname[:port]/directoryandfile
// format 2: protocol://file
// format 3: drive:directoryandfile
//
// first need 2 check if this is a protocol or just a normal drive & path
if (!strURL.size()) return ;
if (strURL.Equals("?", true)) return;
// form is format 1 or 2
// format 1: protocol://[domain;][username:password]@hostname[:port]/directoryandfile
// format 2: protocol://file
// decode protocol
int iPos = strURL.Find("://");
if (iPos < 0)
{
// This is an ugly hack that needs some work.
// example: filename /foo/bar.zip/alice.rar/bob.avi
// This should turn into zip://rar:///foo/bar.zip/alice.rar/bob.avi
iPos = 0;
bool is_apk = (strURL.Find(".apk/", iPos) > 0);
while (1)
{
if (is_apk)
iPos = strURL.Find(".apk/", iPos);
else
iPos = strURL.Find(".zip/", iPos);
int extLen = 3;
if (iPos < 0)
{
/* set filename and update extension*/
SetFileName(strURL);
return ;
}
iPos += extLen + 1;
CStdString archiveName = strURL.Left(iPos);
struct __stat64 s;
if (XFILE::CFile::Stat(archiveName, &s) == 0)
{
#ifdef _LINUX
if (!S_ISDIR(s.st_mode))
#else
if (!(s.st_mode & S_IFDIR))
#endif
{
Encode(archiveName);
if (is_apk)
{
CURL c((CStdString)"apk" + "://" + archiveName + '/' + strURL.Right(strURL.size() - iPos - 1));
*this = c;
}
else
{
CURL c((CStdString)"zip" + "://" + archiveName + '/' + strURL.Right(strURL.size() - iPos - 1));
*this = c;
}
return;
}
}
}
}
else
{
SetProtocol(strURL.Left(iPos));
iPos += 3;
}
// virtual protocols
// why not handle all format 2 (protocol://file) style urls here?
// ones that come to mind are iso9660, cdda, musicdb, etc.
// they are all local protocols and have no server part, port number, special options, etc.
// this removes the need for special handling below.
if (
m_strProtocol.Equals("stack") ||
m_strProtocol.Equals("virtualpath") ||
m_strProtocol.Equals("multipath") ||
m_strProtocol.Equals("filereader") ||
m_strProtocol.Equals("special")
)
{
SetFileName(strURL.Mid(iPos));
return;
}
// check for username/password - should occur before first /
if (iPos == -1) iPos = 0;
// for protocols supporting options, chop that part off here
// maybe we should invert this list instead?
int iEnd = strURL.length();
const char* sep = NULL;
//TODO fix all Addon paths
CStdString strProtocol2 = GetTranslatedProtocol();
if(m_strProtocol.Equals("rss") ||
m_strProtocol.Equals("rar") ||
m_strProtocol.Equals("addons") ||
m_strProtocol.Equals("image") ||
m_strProtocol.Equals("videodb") ||
m_strProtocol.Equals("musicdb") ||
m_strProtocol.Equals("androidapp"))
sep = "?";
else
if(strProtocol2.Equals("http")
|| strProtocol2.Equals("https")
|| strProtocol2.Equals("plugin")
|| strProtocol2.Equals("addons")
|| strProtocol2.Equals("hdhomerun")
|| strProtocol2.Equals("rtsp")
|| strProtocol2.Equals("apk")
|| strProtocol2.Equals("zip"))
sep = "?;#|";
else if(strProtocol2.Equals("ftp")
|| strProtocol2.Equals("ftps"))
sep = "?;";
if(sep)
{
int iOptions = strURL.find_first_of(sep, iPos);
if (iOptions >= 0 )
{
// we keep the initial char as it can be any of the above
int iProto = strURL.find_first_of("|",iOptions);
if (iProto >= 0)
{
m_strProtocolOptions = strURL.substr(iProto+1);
m_strOptions = strURL.substr(iOptions,iProto-iOptions);
}
else
m_strOptions = strURL.substr(iOptions);
iEnd = iOptions;
m_options.AddOptions(m_strOptions);
}
}
int iSlash = strURL.Find("/", iPos);
if(iSlash >= iEnd)
iSlash = -1; // was an invalid slash as it was contained in options
if( !m_strProtocol.Equals("iso9660") )
{
int iAlphaSign = strURL.Find("@", iPos);
if (iAlphaSign >= 0 && iAlphaSign < iEnd && (iAlphaSign < iSlash || iSlash < 0))
{
// username/password found
CStdString strUserNamePassword = strURL.Mid(iPos, iAlphaSign - iPos);
// first extract domain, if protocol is smb
if (m_strProtocol.Equals("smb"))
{
int iSemiColon = strUserNamePassword.Find(";");
if (iSemiColon >= 0)
{
m_strDomain = strUserNamePassword.Left(iSemiColon);
strUserNamePassword.Delete(0, iSemiColon + 1);
}
}
// username:password
int iColon = strUserNamePassword.Find(":");
if (iColon >= 0)
{
m_strUserName = strUserNamePassword.Left(iColon);
iColon++;
m_strPassword = strUserNamePassword.Right(strUserNamePassword.size() - iColon);
}
// username
else
{
m_strUserName = strUserNamePassword;
}
iPos = iAlphaSign + 1;
iSlash = strURL.Find("/", iAlphaSign);
if(iSlash >= iEnd)
iSlash = -1;
}
}
// detect hostname:port/
if (iSlash < 0)
{
CStdString strHostNameAndPort = strURL.Mid(iPos, iEnd - iPos);
int iColon = strHostNameAndPort.Find(":");
if (iColon >= 0)
{
m_strHostName = strHostNameAndPort.Left(iColon);
iColon++;
CStdString strPort = strHostNameAndPort.Right(strHostNameAndPort.size() - iColon);
m_iPort = atoi(strPort.c_str());
}
else
{
m_strHostName = strHostNameAndPort;
}
}
else
{
CStdString strHostNameAndPort = strURL.Mid(iPos, iSlash - iPos);
int iColon = strHostNameAndPort.Find(":");
if (iColon >= 0)
{
m_strHostName = strHostNameAndPort.Left(iColon);
iColon++;
CStdString strPort = strHostNameAndPort.Right(strHostNameAndPort.size() - iColon);
m_iPort = atoi(strPort.c_str());
}
else
{
m_strHostName = strHostNameAndPort;
}
iPos = iSlash + 1;
if (iEnd > iPos)
{
m_strFileName = strURL.Mid(iPos, iEnd - iPos);
iSlash = m_strFileName.Find("/");
if(iSlash < 0)
m_strShareName = m_strFileName;
else
m_strShareName = m_strFileName.Left(iSlash);
}
}
// iso9960 doesnt have an hostname;-)
if (m_strProtocol.CompareNoCase("iso9660") == 0
|| m_strProtocol.CompareNoCase("musicdb") == 0
|| m_strProtocol.CompareNoCase("videodb") == 0
|| m_strProtocol.CompareNoCase("sources") == 0
|| m_strProtocol.CompareNoCase("lastfm") == 0
|| m_strProtocol.CompareNoCase("pvr") == 0
|| m_strProtocol.Left(3).CompareNoCase("mem") == 0)
{
if (m_strHostName != "" && m_strFileName != "")
{
CStdString strFileName = m_strFileName;
m_strFileName.Format("%s/%s", m_strHostName.c_str(), strFileName.c_str());
m_strHostName = "";
}
else
{
if (!m_strHostName.IsEmpty() && strURL[iEnd-1]=='/')
m_strFileName = m_strHostName + "/";
else
m_strFileName = m_strHostName;
m_strHostName = "";
}
}
m_strFileName.Replace("\\", "/");
/* update extension */
SetFileName(m_strFileName);
/* decode urlencoding on this stuff */
if(URIUtils::ProtocolHasEncodedHostname(m_strProtocol))
{
Decode(m_strHostName);
// Validate it as it is likely to contain a filename
SetHostName(CUtil::ValidatePath(m_strHostName));
}
Decode(m_strUserName);
Decode(m_strPassword);
}
bool CShoutcastDirectory::GetDirectory(const CStdString& strPath, CFileItemList &items)
{
CStdString strRoot = strPath;
if (CUtil::HasSlashAtEnd(strRoot))
strRoot.Delete(strRoot.size() - 1);
/* for old users wich doesn't have the full url */
if( strRoot.Equals("shout://www.shoutcast.com") )
strRoot = "shout://www.shoutcast.com/sbin/newxml.phtml";
if (g_directoryCache.GetDirectory(strRoot, items))
return true;
CGUIDialogProgress* dlgProgress = (CGUIDialogProgress*)m_gWindowManager.GetWindow(WINDOW_DIALOG_PROGRESS);
if (dlgProgress)
{
dlgProgress->ShowProgressBar(false);
dlgProgress->SetHeading(260);
dlgProgress->SetLine(0, 14003);
dlgProgress->SetLine(1, "");
dlgProgress->SetLine(2, "");
dlgProgress->StartModal();
}
CURL url(strRoot);
CStdString protocol = url.GetProtocol();
url.SetProtocol("http");
CFileCurl http;
//CURL doesn't seem to understand that data is encoded.. odd
// opening as text for now
//http.SetContentEncoding("deflate");
if( !http.Open(url, false) )
{
CLog::Log(LOGERROR, "%s - Unable to get shoutcast dir", __FUNCTION__);
if (dlgProgress) dlgProgress->Close();
return false;
}
/* restore protocol */
url.SetProtocol(protocol);
CStdString content = http.GetContent();
if( !(content.Equals("text/html") || content.Equals("text/xml")
|| content.Equals("text/html;charset=utf-8") || content.Equals("text/xml;charset=utf-8") ))
{
CLog::Log(LOGERROR, "%s - Invalid content type %s", __FUNCTION__, content.c_str());
if (dlgProgress) dlgProgress->Close();
return false;
}
int size_read = 0;
int size_total = (int)http.GetLength();
int data_size = 0;
CStdString data;
data.reserve(size_total);
/* read response from server into string buffer */
char buffer[16384];
while( (size_read = http.Read(buffer, sizeof(buffer)-1)) > 0 )
{
buffer[size_read] = 0;
data += buffer;
data_size += size_read;
dlgProgress->Progress();
if (dlgProgress->IsCanceled())
{
dlgProgress->Close();
return false;
}
}
/* parse returned xml */
TiXmlDocument doc;
doc.Parse(data.c_str());
TiXmlElement *root = doc.RootElement();
if(root == NULL)
{
CLog::Log(LOGERROR, "%s - Unable to parse xml", __FUNCTION__);
CLog::Log(LOGDEBUG, "%s - Sample follows...\n%s", __FUNCTION__, data.c_str());
dlgProgress->Close();
return false;
}
/* clear data to keep memusage down, not needed anymore */
data.Empty();
bool result = false;
if( strcmp(root->Value(), "genrelist") == 0 )
result = ParseGenres(root, items, url);
else if( strcmp(root->Value(), "stationlist") == 0 )
result = ParseStations(root, items, url);
else
{
CLog::Log(LOGERROR, "%s - Invalid root xml element for shoutcast",__FUNCTION__);
CLog::Log(LOGDEBUG, "%s - Sample follows...\n%s", __FUNCTION__, data.c_str());
}
CFileItemList vecCacheItems;
g_directoryCache.ClearDirectory(strRoot);
for( int i = 0; i <items.Size(); i++ )
{
CFileItem* pItem=items[i];
if (!pItem->IsParentFolder())
vecCacheItems.Add(new CFileItem( *pItem ));
}
g_directoryCache.SetDirectory(strRoot, vecCacheItems);
if (dlgProgress) dlgProgress->Close();
return result;
}
CStdString EpgStore::CleanDescription(const CStdString& strDescription)
{
CStdString description = strDescription;
description.Replace(" ", " ");
while (description.Find("<") != -1)
{
int start = description.Find("<");
int end = description.Find(">");
if (end > start)
description.Delete(start, end-start+1);
else
description.Delete(start, description.GetLength() - start);
}
description.Trim();
description.Replace("\\&", "&");
description.Replace(""", "\"");
description.Replace("&", "&");
description.Replace(" ", " ");
description.Replace(">", ">");
description.Replace("<", "<");
int i;
while ((i = description.Find("&#")) >= 0)
{
CStdString src = "&#";
int radix = 10;
i += 2;
if (description[i] == 'x' || description[i] == 'X')
{
src += description[i];
i++;
radix = 16;
}
CStdString numStr;
unsigned long num;
while (description[i] != ';' && numStr.length() <= 6)
{
numStr += description[i];
src += description[i];
i++;
}
// doesn't make sense....abort
if (numStr.length() > 6)
{
break;
}
src += ';';
char* end;
if (numStr.IsEmpty())
break;
num = strtoul(numStr.c_str(), &end, radix);
// doesn't make sense....abort
if (num == 0)
{
break;
}
CStdStringW utf16;
utf16 += (wchar_t) num;
CStdStringA utf8;
g_charsetConverter.wToUTF8(utf16, utf8);
description.Replace(src, utf8);
}
return description;
}
bool CRSSDirectory::GetDirectory(const CStdString& strPath, CFileItemList &items)
{
CLog::Log(LOGDEBUG,"CRSSDirectory::GetDirectory - path [%s]", strPath.c_str());
m_cacheDirectory = DIR_CACHE_ALWAYS;
CStdString strURL = strPath;
CStdString newURL;
CStdString strRoot = strPath;
if (CUtil::HasSlashAtEnd(strRoot))
strRoot.Delete(strRoot.size() - 1);
// If we have the items in the cache, return them
if (g_directoryCache.GetDirectory(strRoot, items))
{
return true;
}
// Remove the rss:// prefix and replace it with http://
if (strURL.Left(7) == "http://")
{
newURL = strURL;
}
else
{
strURL.Delete(0,6);
// if first symbol is '/', we have local file
if (strURL.Left(1) == "/")
{
newURL = "file://";
}
else
{
newURL = "http://";
}
newURL = newURL + strURL;
}
// Remove the last slash
if (CUtil::HasSlashAtEnd(newURL))
{
CUtil::RemoveSlashAtEnd(newURL);
}
// Create new thread and run the feed retreival from it
// In order to allow progress dialog and cancel operation
m_strUrl = newURL;
Crc32 crc;
crc.ComputeFromLowerCase(newURL);
CStdString strLocalFile;
strLocalFile.Format("special://temp/rss-%08x-%lu.xml", (unsigned __int32)crc, CTimeUtils::GetTimeMS());
CLog::Log(LOGDEBUG,"CRSSDirectory::GetDirectory - going to load url [%s] to file [%s]", newURL.c_str(), strLocalFile.c_str());
if (!BOXEE::Boxee::GetInstance().AsyncLoadUrl(newURL, _P(strLocalFile), "rss-load", NULL))
{
CGUIDialogOK::ShowAndGetInput(51014,0,0,0);
return false;
}
SDL_LockMutex(m_pOpFinishedMutex);
int result = SDL_CondWaitTimeout(m_pOpFinishedCond,m_pOpFinishedMutex,REQUEST_WAIT_PERIOD);
SDL_UnlockMutex(m_pOpFinishedMutex);
m_feed.GetItemList(items);
if (result != 0)
{
m_cacheDirectory = DIR_CACHE_NEVER;
// set this property so that the UI will handle the timeout
CLog::Log(LOGDEBUG,"CRSSDirectory::GetDirectory, loading timed out, path [%s] loaded:%d out of %d", strPath.c_str(), items.Size(),items.GetPageContext().m_itemsPerPage);
items.SetProperty("isRequestTimedOut",true);
}
CLog::Log(LOGDEBUG,"CRSSDirectory::GetDirectory - done loading url, got [%d] items (result=[%d])",items.Size(),result);
if (items.Size() == 0)
{
m_cacheDirectory = DIR_CACHE_NEVER;
return true;
}
else
{
CLog::Log(LOGDEBUG,"CRSSDirectory::GetDirectory - Going to add [DefaultSortLabel] property to each item. [path=%s][NumOfItems=%d] (vns)",strPath.c_str(),items.Size());
for(int i=0; i<items.Size(); i++)
{
CFileItemPtr item = items[i];
char pos[5];
sprintf(pos,"%d",i+1);
item->SetProperty("DefaultSortLabel",pos);
//CLog::Log(LOGDEBUG,"CRSSDirectory::GetDirectory - For item [path=%s] set property [DefaultSortLabel=%s] (vns)", (item->m_strPath).c_str(),(item->GetProperty("DefaultSortLabel")).c_str());
}
items.SetProperty("preferredsortmethod", SORT_METHOD_DEFAULT);
items.SetProperty("preferredsortorder", SORT_ORDER_ASC);
}
return true;
}