2 * Copyright (C) 2005-2013 Team XBMC
5 * This Program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2, or (at your option)
10 * This Program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with XBMC; see the file COPYING. If not, see
17 * <http://www.gnu.org/licenses/>.
20 #include "network/Network.h"
21 #include "threads/SystemClock.h"
23 #if defined(TARGET_DARWIN)
24 #include <sys/param.h>
25 #include <mach-o/dyld.h>
28 #if defined(TARGET_FREEBSD)
29 #include <sys/param.h>
30 #include <sys/sysctl.h>
34 #include <sys/types.h>
39 #if defined(TARGET_ANDROID)
40 #include "android/bionic_supplement/bionic_supplement.h"
44 #include "Application.h"
46 #include "addons/Addon.h"
47 #include "filesystem/PVRDirectory.h"
48 #include "filesystem/Directory.h"
49 #include "filesystem/StackDirectory.h"
50 #include "filesystem/MultiPathDirectory.h"
51 #include "filesystem/SpecialProtocol.h"
52 #include "filesystem/RSSDirectory.h"
53 #ifdef HAS_FILESYSTEM_RAR
54 #include "filesystem/RarManager.h"
56 #include "filesystem/MythDirectory.h"
58 #include "filesystem/UPnPDirectory.h"
60 #include "profiles/ProfilesManager.h"
61 #include "utils/RegExp.h"
62 #include "guilib/GraphicContext.h"
63 #include "guilib/TextureManager.h"
64 #include "utils/fstrcmp.h"
65 #include "storage/MediaManager.h"
67 #include "utils/CharsetConverter.h"
69 #include "WIN32Util.h"
71 #if defined(TARGET_DARWIN)
72 #include "osx/DarwinUtils.h"
74 #include "GUIUserMessages.h"
75 #include "filesystem/File.h"
76 #include "settings/MediaSettings.h"
77 #include "settings/Settings.h"
78 #include "utils/StringUtils.h"
79 #include "settings/AdvancedSettings.h"
80 #ifdef HAS_IRSERVERSUITE
81 #include "input/windows/IRServerSuite.h"
83 #include "guilib/LocalizeStrings.h"
84 #include "utils/md5.h"
85 #include "utils/TimeUtils.h"
86 #include "utils/URIUtils.h"
87 #include "utils/log.h"
88 #include "utils/Environment.h"
90 #include "cores/dvdplayer/DVDSubtitles/DVDSubtitleTagSami.h"
91 #include "cores/dvdplayer/DVDSubtitles/DVDSubtitleStream.h"
93 #include "utils/LangCodeExpander.h"
95 #include <sys/capability.h>
98 #include "cores/dvdplayer/DVDDemuxers/DVDDemux.h"
103 #define clamp(x) (x) > 255.f ? 255 : ((x) < 0 ? 0 : (BYTE)(x+0.5f)) // Valid ranges: brightness[-1 -> 1 (0 is default)] contrast[0 -> 2 (1 is default)] gamma[0.5 -> 3.5 (1 is default)] default[ramp is linear]
104 static const int64_t SECS_BETWEEN_EPOCHS = 11644473600LL;
105 static const int64_t SECS_TO_100NS = 10000000;
107 using namespace XFILE;
108 using namespace PLAYLIST;
111 static D3DGAMMARAMP oldramp, flashramp;
112 #elif defined(HAS_SDL_2D)
113 static uint16_t oldrampRed[256];
114 static uint16_t oldrampGreen[256];
115 static uint16_t oldrampBlue[256];
116 static uint16_t flashrampRed[256];
117 static uint16_t flashrampGreen[256];
118 static uint16_t flashrampBlue[256];
121 #if !defined(TARGET_WINDOWS)
122 unsigned int CUtil::s_randomSeed = time(NULL);
132 CStdString CUtil::GetTitleFromPath(const CStdString& strFileNameAndPath, bool bIsFolder /* = false */)
134 // use above to get the filename
135 CStdString path(strFileNameAndPath);
136 URIUtils::RemoveSlashAtEnd(path);
137 CStdString strFilename = URIUtils::GetFileName(path);
139 CURL url(strFileNameAndPath);
140 CStdString strHostname = url.GetHostName();
144 if (url.GetProtocol() == "upnp")
145 strFilename = CUPnPDirectory::GetFriendlyName(strFileNameAndPath.c_str());
148 if (url.GetProtocol() == "rss")
152 if(dir.GetDirectory(strFileNameAndPath, items) && !items.m_strTitle.empty())
153 return items.m_strTitle;
157 else if (url.GetProtocol() == "shout")
159 const int genre = strFileNameAndPath.find_first_of('=');
161 strFilename = g_localizeStrings.Get(260);
163 strFilename = g_localizeStrings.Get(260) + " - " + strFileNameAndPath.substr(genre+1).c_str();
166 // Windows SMB Network (SMB)
167 else if (url.GetProtocol() == "smb" && strFilename.empty())
169 if (url.GetHostName().empty())
171 strFilename = g_localizeStrings.Get(20171);
175 strFilename = url.GetHostName();
178 // iTunes music share (DAAP)
179 else if (url.GetProtocol() == "daap" && strFilename.empty())
180 strFilename = g_localizeStrings.Get(20174);
183 else if (url.GetProtocol() == "hdhomerun" && strFilename.empty())
184 strFilename = "HDHomerun Devices";
187 else if (url.GetProtocol() == "sling")
188 strFilename = "Slingbox";
191 else if (url.GetProtocol() == "rtv")
192 strFilename = "ReplayTV Devices";
194 // HTS Tvheadend client
195 else if (url.GetProtocol() == "htsp")
196 strFilename = g_localizeStrings.Get(20256);
198 // VDR Streamdev client
199 else if (url.GetProtocol() == "vtp")
200 strFilename = g_localizeStrings.Get(20257);
203 else if (url.GetProtocol() == "myth")
204 strFilename = g_localizeStrings.Get(20258);
207 else if (url.GetProtocol() == "sap" && strFilename.empty())
208 strFilename = "SAP Streams";
211 else if (url.GetProtocol() == "sources")
212 strFilename = g_localizeStrings.Get(744);
215 else if (StringUtils::StartsWithNoCase(path, "special://musicplaylists"))
216 strFilename = g_localizeStrings.Get(136);
219 else if (StringUtils::StartsWithNoCase(path, "special://videoplaylists"))
220 strFilename = g_localizeStrings.Get(136);
222 else if (URIUtils::ProtocolHasParentInHostname(url.GetProtocol()) && strFilename.empty())
223 strFilename = URIUtils::GetFileName(url.GetHostName());
225 // now remove the extension if needed
226 if (!CSettings::Get().GetBool("filelists.showextensions") && !bIsFolder)
228 URIUtils::RemoveExtension(strFilename);
232 // URLDecode since the original path may be an URL
233 strFilename = CURL::Decode(strFilename);
237 void CUtil::CleanString(const CStdString& strFileName, CStdString& strTitle, CStdString& strTitleAndYear, CStdString& strYear, bool bRemoveExtension /* = false */, bool bCleanChars /* = true */)
239 strTitleAndYear = strFileName;
241 if (strFileName.Equals(".."))
244 const CStdStringArray ®exps = g_advancedSettings.m_videoCleanStringRegExps;
246 CRegExp reTags(true, CRegExp::autoUtf8);
247 CRegExp reYear(false, CRegExp::autoUtf8);
249 if (!reYear.RegComp(g_advancedSettings.m_videoCleanDateTimeRegExp))
251 CLog::Log(LOGERROR, "%s: Invalid datetime clean RegExp:'%s'", __FUNCTION__, g_advancedSettings.m_videoCleanDateTimeRegExp.c_str());
255 if (reYear.RegFind(strTitleAndYear.c_str()) >= 0)
257 strTitleAndYear = reYear.GetMatch(1);
258 strYear = reYear.GetMatch(2);
262 URIUtils::RemoveExtension(strTitleAndYear);
264 for (unsigned int i = 0; i < regexps.size(); i++)
266 if (!reTags.RegComp(regexps[i].c_str()))
267 { // invalid regexp - complain in logs
268 CLog::Log(LOGERROR, "%s: Invalid string clean RegExp:'%s'", __FUNCTION__, regexps[i].c_str());
272 if ((j=reTags.RegFind(strTitleAndYear.c_str())) > 0)
273 strTitleAndYear = strTitleAndYear.substr(0, j);
276 // final cleanup - special characters used instead of spaces:
277 // all '_' tokens should be replaced by spaces
278 // if the file contains no spaces, all '.' tokens should be replaced by
279 // spaces - one possibility of a mistake here could be something like:
280 // "Dr..StrangeLove" - hopefully no one would have anything like this.
283 bool initialDots = true;
284 bool alreadyContainsSpace = (strTitleAndYear.find(' ') != std::string::npos);
286 for (size_t i = 0; i < strTitleAndYear.size(); i++)
288 char c = strTitleAndYear[i];
293 if ((c == '_') || ((!alreadyContainsSpace) && !initialDots && (c == '.')))
295 strTitleAndYear[i] = ' ';
300 StringUtils::Trim(strTitleAndYear);
301 strTitle = strTitleAndYear;
304 if (!strYear.empty())
305 strTitleAndYear = strTitle + " (" + strYear + ")";
307 // restore extension if needed
308 if (!bRemoveExtension)
309 strTitleAndYear += URIUtils::GetExtension(strFileName);
312 void CUtil::GetQualifiedFilename(const CStdString &strBasePath, CStdString &strFilename)
314 // Check if the filename is a fully qualified URL such as protocol://path/to/file
315 CURL plItemUrl(strFilename);
316 if (!plItemUrl.GetProtocol().empty())
319 // If the filename starts "x:", "\\" or "/" it's already fully qualified so return
320 if (strFilename.size() > 1)
322 if ( (strFilename[1] == ':') || (strFilename[0] == '/') )
324 if ( strFilename[1] == ':' || (strFilename[0] == '\\' && strFilename[1] == '\\'))
328 // add to base path and then clean
329 strFilename = URIUtils::AddFileToFolder(strBasePath, strFilename);
331 // get rid of any /./ or \.\ that happen to be there
332 StringUtils::Replace(strFilename, "\\.\\", "\\");
333 StringUtils::Replace(strFilename, "/./", "/");
335 // now find any "\\..\\" and remove them via GetParentPath
337 while ((pos = strFilename.find("/../")) != std::string::npos)
339 CStdString basePath = strFilename.substr(0, pos + 1);
340 strFilename.erase(0, pos + 4);
341 basePath = URIUtils::GetParentPath(basePath);
342 strFilename = URIUtils::AddFileToFolder(basePath, strFilename);
344 while ((pos = strFilename.find("\\..\\")) != std::string::npos)
346 CStdString basePath = strFilename.substr(0, pos + 1);
347 strFilename.erase(0, pos + 4);
348 basePath = URIUtils::GetParentPath(basePath);
349 strFilename = URIUtils::AddFileToFolder(basePath, strFilename);
354 bool CUtil::TestGetQualifiedFilename()
356 CStdString file = "../foo"; GetQualifiedFilename("smb://", file);
357 if (file != "foo") return false;
358 file = "C:\\foo\\bar"; GetQualifiedFilename("smb://", file);
359 if (file != "C:\\foo\\bar") return false;
360 file = "../foo/./bar"; GetQualifiedFilename("smb://my/path", file);
361 if (file != "smb://my/foo/bar") return false;
362 file = "smb://foo/bar/"; GetQualifiedFilename("upnp://", file);
363 if (file != "smb://foo/bar/") return false;
367 bool CUtil::TestMakeLegalPath()
370 #ifdef TARGET_WINDOWS
371 path = "C:\\foo\\bar"; path = MakeLegalPath(path);
372 if (path != "C:\\foo\\bar") return false;
373 path = "C:\\foo:\\bar\\"; path = MakeLegalPath(path);
374 if (path != "C:\\foo_\\bar\\") return false;
376 path = "/foo/bar/"; path = MakeLegalPath(path);
377 if (path != "/foo/bar/") return false;
378 path = "/foo?/bar"; path = MakeLegalPath(path);
379 if (path != "/foo_/bar") return false;
381 path = "smb://foo/bar"; path = MakeLegalPath(path);
382 if (path != "smb://foo/bar") return false;
383 path = "smb://foo/bar?/"; path = MakeLegalPath(path);
384 if (path != "smb://foo/bar_/") return false;
389 void CUtil::RunShortcut(const char* szShortcutPath)
393 void CUtil::GetHomePath(CStdString& strPath, const CStdString& strTarget)
395 strPath = CEnvironment::getenv(strTarget);
397 #ifdef TARGET_WINDOWS
398 if (strPath.find("..") != std::string::npos)
400 //expand potential relative path to full path
401 CStdStringW strPathW;
402 g_charsetConverter.utf8ToW(strPath, strPathW, false);
403 CWIN32Util::AddExtraLongPathPrefix(strPathW);
404 const unsigned int bufSize = GetFullPathNameW(strPathW, 0, NULL, NULL);
407 wchar_t * buf = new wchar_t[bufSize];
408 if (GetFullPathNameW(strPathW, bufSize, buf, NULL) <= bufSize-1)
410 std::wstring expandedPathW(buf);
411 CWIN32Util::RemoveExtraLongPathPrefix(expandedPathW);
412 g_charsetConverter.wToUTF8(expandedPathW, strPath);
422 CStdString strHomePath = ResolveExecutablePath();
423 #if defined(TARGET_DARWIN)
425 char given_path[2*MAXPATHLEN];
426 uint32_t path_size =2*MAXPATHLEN;
428 result = GetDarwinExecutablePath(given_path, &path_size);
431 // Move backwards to last /.
432 for (int n=strlen(given_path)-1; given_path[n] != '/'; n--)
433 given_path[n] = '\0';
435 #if defined(TARGET_DARWIN_IOS)
436 strcat(given_path, "/XBMCData/XBMCHome/");
438 // Assume local path inside application bundle.
439 strcat(given_path, "../Resources/XBMC/");
442 // Convert to real path.
443 char real_path[2*MAXPATHLEN];
444 if (realpath(given_path, real_path) != NULL)
451 size_t last_sep = strHomePath.find_last_of(PATH_SEPARATOR_CHAR);
452 if (last_sep != string::npos)
453 strPath = strHomePath.substr(0, last_sep);
455 strPath = strHomePath;
458 #if defined(TARGET_POSIX) && !defined(TARGET_DARWIN)
459 /* Change strPath accordingly when target is XBMC_HOME and when INSTALL_PATH
460 * and BIN_INSTALL_PATH differ
462 CStdString installPath = INSTALL_PATH;
463 CStdString binInstallPath = BIN_INSTALL_PATH;
464 if (!strTarget.compare("XBMC_HOME") && installPath.compare(binInstallPath))
466 int pos = strPath.length() - binInstallPath.length();
467 CStdString tmp = strPath;
469 if (!tmp.compare(binInstallPath))
471 strPath.erase(pos, strPath.length());
472 strPath.append(installPath);
478 bool CUtil::IsPVR(const CStdString& strFile)
480 return StringUtils::StartsWithNoCase(strFile, "pvr:");
483 bool CUtil::IsHTSP(const CStdString& strFile)
485 return StringUtils::StartsWithNoCase(strFile, "htsp:");
488 bool CUtil::IsLiveTV(const CStdString& strFile)
490 if (StringUtils::StartsWithNoCase(strFile, "pvr://channels"))
493 if(URIUtils::IsTuxBox(strFile)
494 || URIUtils::IsVTP(strFile)
495 || URIUtils::IsHDHomeRun(strFile)
496 || URIUtils::IsHTSP(strFile)
497 || StringUtils::StartsWithNoCase(strFile, "sap:"))
500 if (URIUtils::IsMythTV(strFile) && CMythDirectory::IsLiveTV(strFile))
506 bool CUtil::IsTVRecording(const CStdString& strFile)
508 return StringUtils::StartsWithNoCase(strFile, "pvr://recording");
511 bool CUtil::IsPicture(const CStdString& strFile)
513 return URIUtils::HasExtension(strFile,
514 g_advancedSettings.m_pictureExtensions + "|.tbn|.dds");
517 bool CUtil::ExcludeFileOrFolder(const CStdString& strFileOrFolder, const CStdStringArray& regexps)
519 if (strFileOrFolder.empty())
522 CRegExp regExExcludes(true, CRegExp::autoUtf8); // case insensitive regex
524 for (unsigned int i = 0; i < regexps.size(); i++)
526 if (!regExExcludes.RegComp(regexps[i].c_str()))
527 { // invalid regexp - complain in logs
528 CLog::Log(LOGERROR, "%s: Invalid exclude RegExp:'%s'", __FUNCTION__, regexps[i].c_str());
531 if (regExExcludes.RegFind(strFileOrFolder) > -1)
533 CLog::Log(LOGDEBUG, "%s: File '%s' excluded. (Matches exclude rule RegExp:'%s')", __FUNCTION__, strFileOrFolder.c_str(), regexps[i].c_str());
540 void CUtil::GetFileAndProtocol(const CStdString& strURL, CStdString& strDir)
543 if (!URIUtils::IsRemote(strURL)) return ;
544 if (URIUtils::IsDVD(strURL)) return ;
547 strDir = StringUtils::Format("%s://%s", url.GetProtocol().c_str(), url.GetFileName().c_str());
550 int CUtil::GetDVDIfoTitle(const CStdString& strFile)
552 CStdString strFilename = URIUtils::GetFileName(strFile);
553 if (strFilename.Equals("video_ts.ifo")) return 0;
555 return atoi(strFilename.substr(4, 2).c_str());
558 CStdString CUtil::GetFileMD5(const CStdString& strPath)
562 if (file.Open(strPath))
570 read = file.Read(temp,1024);
572 md5.append(temp,read);
574 md5.getDigest(result);
581 bool CUtil::GetDirectoryName(const CStdString& strFileName, CStdString& strDescription)
583 CStdString strFName = URIUtils::GetFileName(strFileName);
584 strDescription = URIUtils::GetDirectory(strFileName);
585 URIUtils::RemoveSlashAtEnd(strDescription);
587 size_t iPos = strDescription.find_last_of("/\\");
588 if (iPos != std::string::npos)
589 strDescription = strDescription.substr(iPos + 1);
590 else if (strDescription.size() <= 0)
591 strDescription = strFName;
595 void CUtil::GetDVDDriveIcon( const CStdString& strPath, CStdString& strIcon )
597 if ( !g_mediaManager.IsDiscInDrive() )
599 strIcon = "DefaultDVDEmpty.png";
603 if ( URIUtils::IsDVD(strPath) )
606 CCdInfo* pInfo = g_mediaManager.GetCdInfo();
608 if ( pInfo != NULL && pInfo->IsUDFX( 1 ) )
610 strIcon = "DefaultXboxDVD.png";
614 strIcon = "DefaultDVDRom.png";
618 if ( URIUtils::IsISO9660(strPath) )
621 CCdInfo* pInfo = g_mediaManager.GetCdInfo();
622 if ( pInfo != NULL && pInfo->IsVideoCd( 1 ) )
624 strIcon = "DefaultVCD.png";
628 strIcon = "DefaultDVDRom.png";
632 if ( URIUtils::IsCDDA(strPath) )
634 strIcon = "DefaultCDDA.png";
639 void CUtil::RemoveTempFiles()
641 CStdString searchPath = CProfilesManager::Get().GetDatabaseFolder();
643 if (!XFILE::CDirectory::GetDirectory(searchPath, items, ".tmp", DIR_FLAG_NO_FILE_DIRS))
646 for (int i = 0; i < items.Size(); ++i)
648 if (items[i]->m_bIsFolder)
650 XFILE::CFile::Delete(items[i]->GetPath());
654 void CUtil::ClearSubtitles()
658 CDirectory::GetDirectory("special://temp/",items);
659 for( int i=0;i<items.Size();++i)
661 if (!items[i]->m_bIsFolder)
663 if (items[i]->GetPath().find("subtitle") != std::string::npos ||
664 items[i]->GetPath().find("vobsub_queue") != std::string::npos)
666 CLog::Log(LOGDEBUG, "%s - Deleting temporary subtitle %s", __FUNCTION__, items[i]->GetPath().c_str());
667 CFile::Delete(items[i]->GetPath());
673 void CUtil::ClearTempFonts()
675 CStdString searchPath = "special://temp/fonts/";
677 if (!CFile::Exists(searchPath))
681 CDirectory::GetDirectory(searchPath, items, "", DIR_FLAG_NO_FILE_DIRS | DIR_FLAG_BYPASS_CACHE);
683 for (int i=0; i<items.Size(); ++i)
685 if (items[i]->m_bIsFolder)
687 CFile::Delete(items[i]->GetPath());
691 static const char * sub_exts[] = { ".utf", ".utf8", ".utf-8", ".sub", ".srt", ".smi", ".rt", ".txt", ".ssa", ".aqt", ".jss", ".ass", ".idx", NULL};
693 int64_t CUtil::ToInt64(uint32_t high, uint32_t low)
702 CStdString CUtil::GetNextFilename(const CStdString &fn_template, int max)
704 if (fn_template.find("%03d") == std::string::npos)
707 CStdString searchPath = URIUtils::GetDirectory(fn_template);
708 CStdString mask = URIUtils::GetExtension(fn_template);
709 CStdString name = StringUtils::Format(fn_template.c_str(), 0);
712 if (!CDirectory::GetDirectory(searchPath, items, mask, DIR_FLAG_NO_FILE_DIRS))
715 items.SetFastLookup(true);
716 for (int i = 0; i <= max; i++)
718 CStdString name = StringUtils::Format(fn_template.c_str(), i);
719 if (!items.Get(name))
725 CStdString CUtil::GetNextPathname(const CStdString &path_template, int max)
727 if (path_template.find("%04d") == std::string::npos)
730 for (int i = 0; i <= max; i++)
732 CStdString name = StringUtils::Format(path_template.c_str(), i);
733 if (!CFile::Exists(name))
739 void CUtil::StatToStatI64(struct _stati64 *result, struct stat *stat)
741 result->st_dev = stat->st_dev;
742 result->st_ino = stat->st_ino;
743 result->st_mode = stat->st_mode;
744 result->st_nlink = stat->st_nlink;
745 result->st_uid = stat->st_uid;
746 result->st_gid = stat->st_gid;
747 result->st_rdev = stat->st_rdev;
748 result->st_size = (int64_t)stat->st_size;
751 result->st_atime = (long)(stat->st_atime & 0xFFFFFFFF);
752 result->st_mtime = (long)(stat->st_mtime & 0xFFFFFFFF);
753 result->st_ctime = (long)(stat->st_ctime & 0xFFFFFFFF);
755 result->_st_atime = (long)(stat->st_atime & 0xFFFFFFFF);
756 result->_st_mtime = (long)(stat->st_mtime & 0xFFFFFFFF);
757 result->_st_ctime = (long)(stat->st_ctime & 0xFFFFFFFF);
761 void CUtil::Stat64ToStatI64(struct _stati64 *result, struct __stat64 *stat)
763 result->st_dev = stat->st_dev;
764 result->st_ino = stat->st_ino;
765 result->st_mode = stat->st_mode;
766 result->st_nlink = stat->st_nlink;
767 result->st_uid = stat->st_uid;
768 result->st_gid = stat->st_gid;
769 result->st_rdev = stat->st_rdev;
770 result->st_size = stat->st_size;
772 result->st_atime = (long)(stat->st_atime & 0xFFFFFFFF);
773 result->st_mtime = (long)(stat->st_mtime & 0xFFFFFFFF);
774 result->st_ctime = (long)(stat->st_ctime & 0xFFFFFFFF);
776 result->_st_atime = (long)(stat->st_atime & 0xFFFFFFFF);
777 result->_st_mtime = (long)(stat->st_mtime & 0xFFFFFFFF);
778 result->_st_ctime = (long)(stat->st_ctime & 0xFFFFFFFF);
782 void CUtil::StatI64ToStat64(struct __stat64 *result, struct _stati64 *stat)
784 result->st_dev = stat->st_dev;
785 result->st_ino = stat->st_ino;
786 result->st_mode = stat->st_mode;
787 result->st_nlink = stat->st_nlink;
788 result->st_uid = stat->st_uid;
789 result->st_gid = stat->st_gid;
790 result->st_rdev = stat->st_rdev;
791 result->st_size = stat->st_size;
793 result->st_atime = stat->st_atime;
794 result->st_mtime = stat->st_mtime;
795 result->st_ctime = stat->st_ctime;
797 result->st_atime = stat->_st_atime;
798 result->st_mtime = stat->_st_mtime;
799 result->st_ctime = stat->_st_ctime;
803 void CUtil::Stat64ToStat(struct stat *result, struct __stat64 *stat)
805 result->st_dev = stat->st_dev;
806 result->st_ino = stat->st_ino;
807 result->st_mode = stat->st_mode;
808 result->st_nlink = stat->st_nlink;
809 result->st_uid = stat->st_uid;
810 result->st_gid = stat->st_gid;
811 result->st_rdev = stat->st_rdev;
813 if (stat->st_size <= LONG_MAX)
814 result->st_size = (_off_t)stat->st_size;
816 if (sizeof(stat->st_size) <= sizeof(result->st_size) )
817 result->st_size = stat->st_size;
822 CLog::Log(LOGWARNING, "WARNING: File is larger than 32bit stat can handle, file size will be reported as 0 bytes");
824 result->st_atime = (time_t)(stat->st_atime & 0xFFFFFFFF);
825 result->st_mtime = (time_t)(stat->st_mtime & 0xFFFFFFFF);
826 result->st_ctime = (time_t)(stat->st_ctime & 0xFFFFFFFF);
829 #ifdef TARGET_WINDOWS
830 void CUtil::Stat64ToStat64i32(struct _stat64i32 *result, struct __stat64 *stat)
832 result->st_dev = stat->st_dev;
833 result->st_ino = stat->st_ino;
834 result->st_mode = stat->st_mode;
835 result->st_nlink = stat->st_nlink;
836 result->st_uid = stat->st_uid;
837 result->st_gid = stat->st_gid;
838 result->st_rdev = stat->st_rdev;
840 if (stat->st_size <= LONG_MAX)
841 result->st_size = (_off_t)stat->st_size;
843 if (sizeof(stat->st_size) <= sizeof(result->st_size) )
844 result->st_size = stat->st_size;
849 CLog::Log(LOGWARNING, "WARNING: File is larger than 32bit stat can handle, file size will be reported as 0 bytes");
852 result->st_atime = stat->st_atime;
853 result->st_mtime = stat->st_mtime;
854 result->st_ctime = stat->st_ctime;
856 result->st_atime = stat->_st_atime;
857 result->st_mtime = stat->_st_mtime;
858 result->st_ctime = stat->_st_ctime;
863 bool CUtil::CreateDirectoryEx(const CStdString& strPath)
865 // Function to create all directories at once instead
866 // of calling CreateDirectory for every subdir.
867 // Creates the directory and subdirectories if needed.
869 // return true if directory already exist
870 if (CDirectory::Exists(strPath)) return true;
872 // we currently only allow HD and smb, nfs and afp paths
873 if (!URIUtils::IsHD(strPath) && !URIUtils::IsSmb(strPath) && !URIUtils::IsNfs(strPath) && !URIUtils::IsAfp(strPath))
875 CLog::Log(LOGERROR,"%s called with an unsupported path: %s", __FUNCTION__, strPath.c_str());
879 CStdStringArray dirs = URIUtils::SplitPath(strPath);
880 CStdString dir(dirs.front());
881 URIUtils::AddSlashAtEnd(dir);
882 for (CStdStringArray::iterator it = dirs.begin() + 1; it != dirs.end(); it ++)
884 dir = URIUtils::AddFileToFolder(dir, *it);
885 CDirectory::Create(dir);
888 // was the final destination directory successfully created ?
889 if (!CDirectory::Exists(strPath)) return false;
893 CStdString CUtil::MakeLegalFileName(const CStdString &strFile, int LegalType)
895 CStdString result = strFile;
897 StringUtils::Replace(result, '/', '_');
898 StringUtils::Replace(result, '\\', '_');
899 StringUtils::Replace(result, '?', '_');
901 if (LegalType == LEGAL_WIN32_COMPAT)
903 // just filter out some illegal characters on windows
904 StringUtils::Replace(result, ':', '_');
905 StringUtils::Replace(result, '*', '_');
906 StringUtils::Replace(result, '?', '_');
907 StringUtils::Replace(result, '\"', '_');
908 StringUtils::Replace(result, '<', '_');
909 StringUtils::Replace(result, '>', '_');
910 StringUtils::Replace(result, '|', '_');
911 StringUtils::TrimRight(result, ". ");
916 // legalize entire path
917 CStdString CUtil::MakeLegalPath(const CStdString &strPathAndFile, int LegalType)
919 if (URIUtils::IsStack(strPathAndFile))
920 return MakeLegalPath(CStackDirectory::GetFirstStackedFile(strPathAndFile));
921 if (URIUtils::IsMultiPath(strPathAndFile))
922 return MakeLegalPath(CMultiPathDirectory::GetFirstPath(strPathAndFile));
923 if (!URIUtils::IsHD(strPathAndFile) && !URIUtils::IsSmb(strPathAndFile) && !URIUtils::IsNfs(strPathAndFile) && !URIUtils::IsAfp(strPathAndFile))
924 return strPathAndFile; // we don't support writing anywhere except HD, SMB, NFS and AFP - no need to legalize path
926 bool trailingSlash = URIUtils::HasSlashAtEnd(strPathAndFile);
927 CStdStringArray dirs = URIUtils::SplitPath(strPathAndFile);
928 // we just add first token to path and don't legalize it - possible values:
929 // "X:" (local win32), "" (local unix - empty string before '/') or
930 // "protocol://domain"
931 CStdString dir(dirs.front());
932 URIUtils::AddSlashAtEnd(dir);
933 for (CStdStringArray::iterator it = dirs.begin() + 1; it != dirs.end(); it ++)
934 dir = URIUtils::AddFileToFolder(dir, MakeLegalFileName(*it, LegalType));
935 if (trailingSlash) URIUtils::AddSlashAtEnd(dir);
939 CStdString CUtil::ValidatePath(const CStdString &path, bool bFixDoubleSlashes /* = false */)
941 CStdString result = path;
943 // Don't do any stuff on URLs containing %-characters or protocols that embed
944 // filenames. NOTE: Don't use IsInZip or IsInRar here since it will infinitely
945 // recurse and crash XBMC
946 if (URIUtils::IsURL(path) &&
947 (path.find('%') != std::string::npos ||
948 StringUtils::StartsWithNoCase(path, "apk:") ||
949 StringUtils::StartsWithNoCase(path, "zip:") ||
950 StringUtils::StartsWithNoCase(path, "rar:") ||
951 StringUtils::StartsWithNoCase(path, "stack:") ||
952 StringUtils::StartsWithNoCase(path, "bluray:") ||
953 StringUtils::StartsWithNoCase(path, "multipath:") ))
956 // check the path for incorrect slashes
957 #ifdef TARGET_WINDOWS
958 if (URIUtils::IsDOSPath(path))
960 StringUtils::Replace(result, '/', '\\');
961 /* The double slash correction should only be used when *absolutely*
962 necessary! This applies to certain DLLs or use from Python DLLs/scripts
963 that incorrectly generate double (back) slashes.
965 if (bFixDoubleSlashes && !result.empty())
967 // Fixup for double back slashes (but ignore the \\ of unc-paths)
968 for (size_t x = 1; x < result.size() - 1; x++)
970 if (result[x] == '\\' && result[x+1] == '\\')
975 else if (path.find("://") != std::string::npos || path.find(":\\\\") != std::string::npos)
978 StringUtils::Replace(result, '\\', '/');
979 /* The double slash correction should only be used when *absolutely*
980 necessary! This applies to certain DLLs or use from Python DLLs/scripts
981 that incorrectly generate double (back) slashes.
983 if (bFixDoubleSlashes && !result.empty())
985 // Fixup for double forward slashes(/) but don't touch the :// of URLs
986 for (size_t x = 2; x < result.size() - 1; x++)
988 if ( result[x] == '/' && result[x + 1] == '/' && !(result[x - 1] == ':' || (result[x - 1] == '/' && result[x - 2] == ':')) )
996 bool CUtil::IsUsingTTFSubtitles()
998 return URIUtils::HasExtension(CSettings::Get().GetString("subtitles.font"), ".ttf");
1002 bool CUtil::TestSplitExec()
1004 CStdString function;
1005 vector<CStdString> params;
1006 CUtil::SplitExecFunction("ActivateWindow(Video, \"C:\\test\\foo\")", function, params);
1007 if (function != "ActivateWindow" || params.size() != 2 || params[0] != "Video" || params[1] != "C:\\test\\foo")
1010 CUtil::SplitExecFunction("ActivateWindow(Video, \"C:\\test\\foo\\\")", function, params);
1011 if (function != "ActivateWindow" || params.size() != 2 || params[0] != "Video" || params[1] != "C:\\test\\foo\"")
1013 CUtil::SplitExecFunction("ActivateWindow(Video, \"C:\\\\test\\\\foo\\\\\")", function, params);
1014 if (function != "ActivateWindow" || params.size() != 2 || params[0] != "Video" || params[1] != "C:\\test\\foo\\")
1016 CUtil::SplitExecFunction("ActivateWindow(Video, \"C:\\\\\\\\test\\\\\\foo\\\\\")", function, params);
1017 if (function != "ActivateWindow" || params.size() != 2 || params[0] != "Video" || params[1] != "C:\\\\test\\\\foo\\")
1019 CUtil::SplitExecFunction("SetProperty(Foo,\"\")", function, params);
1020 if (function != "SetProperty" || params.size() != 2 || params[0] != "Foo" || params[1] != "")
1022 CUtil::SplitExecFunction("SetProperty(foo,ba(\"ba black )\",sheep))", function, params);
1023 if (function != "SetProperty" || params.size() != 2 || params[0] != "foo" || params[1] != "ba(\"ba black )\",sheep)")
1029 void CUtil::SplitExecFunction(const CStdString &execString, CStdString &function, vector<CStdString> ¶meters)
1031 CStdString paramString;
1033 size_t iPos = execString.find("(");
1034 size_t iPos2 = execString.rfind(")");
1035 if (iPos != std::string::npos && iPos2 != std::string::npos)
1037 paramString = execString.substr(iPos + 1, iPos2 - iPos - 1);
1038 function = execString.substr(0, iPos);
1041 function = execString;
1043 // remove any whitespace, and the standard prefix (if it exists)
1044 StringUtils::Trim(function);
1045 if( StringUtils::StartsWithNoCase(function, "xbmc.") )
1046 function.erase(0, 5);
1048 SplitParams(paramString, parameters);
1051 void CUtil::SplitParams(const CStdString ¶mString, std::vector<CStdString> ¶meters)
1053 bool inQuotes = false;
1054 bool lastEscaped = false; // only every second character can be escaped
1056 size_t whiteSpacePos = 0;
1057 CStdString parameter;
1059 for (size_t pos = 0; pos < paramString.size(); pos++)
1061 char ch = paramString[pos];
1062 bool escaped = (pos > 0 && paramString[pos - 1] == '\\' && !lastEscaped);
1063 lastEscaped = escaped;
1065 { // if we're in a quote, we accept everything until the closing quote
1066 if (ch == '"' && !escaped)
1067 { // finished a quote - no need to add the end quote to our string
1072 { // not in a quote, so check if we should be starting one
1073 if (ch == '"' && !escaped)
1074 { // start of quote - no need to add the quote to our string
1077 if (inFunction && ch == ')')
1078 { // end of a function
1082 { // start of function
1085 if (!inFunction && ch == ',')
1086 { // not in a function, so a comma signfies the end of this parameter
1088 parameter = parameter.substr(0, whiteSpacePos);
1089 // trim off start and end quotes
1090 if (parameter.length() > 1 && parameter[0] == '"' && parameter[parameter.length() - 1] == '"')
1091 parameter = parameter.substr(1, parameter.length() - 2);
1092 else if (parameter.length() > 3 && parameter[parameter.length() - 1] == '"')
1094 // check name="value" style param.
1095 size_t quotaPos = parameter.find('"');
1096 if (quotaPos > 1 && quotaPos < parameter.length() - 1 && parameter[quotaPos - 1] == '=')
1098 parameter.erase(parameter.length() - 1);
1099 parameter.erase(quotaPos);
1102 parameters.push_back(parameter);
1108 if ((ch == '"' || ch == '\\') && escaped)
1109 { // escaped quote or backslash
1110 parameter[parameter.size()-1] = ch;
1113 // whitespace handling - we skip any whitespace at the left or right of an unquoted parameter
1114 if (ch == ' ' && !inQuotes)
1116 if (parameter.empty()) // skip whitespace on left
1118 if (!whiteSpacePos) // make a note of where whitespace starts on the right
1119 whiteSpacePos = parameter.size();
1125 if (inFunction || inQuotes)
1126 CLog::Log(LOGWARNING, "%s(%s) - end of string while searching for ) or \"", __FUNCTION__, paramString.c_str());
1128 parameter.erase(whiteSpacePos);
1129 // trim off start and end quotes
1130 if (parameter.size() > 1 && parameter[0] == '"' && parameter[parameter.size() - 1] == '"')
1131 parameter = parameter.substr(1,parameter.size() - 2);
1132 else if (parameter.size() > 3 && parameter[parameter.size() - 1] == '"')
1134 // check name="value" style param.
1135 size_t quotaPos = parameter.find('"');
1136 if (quotaPos > 1 && quotaPos < parameter.length() - 1 && parameter[quotaPos - 1] == '=')
1138 parameter.erase(parameter.length() - 1);
1139 parameter.erase(quotaPos);
1142 if (!parameter.empty() || parameters.size())
1143 parameters.push_back(parameter);
1146 int CUtil::GetMatchingSource(const CStdString& strPath1, VECSOURCES& VECSOURCES, bool& bIsSourceName)
1148 if (strPath1.empty())
1151 // copy as we may change strPath
1152 CStdString strPath = strPath1;
1154 // Check for special protocols
1155 CURL checkURL(strPath);
1157 if (StringUtils::StartsWith(strPath, "special://skin/"))
1161 if (checkURL.GetProtocol() == "stack")
1162 strPath.erase(0, 8); // remove the stack protocol
1164 if (checkURL.GetProtocol() == "shout")
1165 strPath = checkURL.GetHostName();
1166 if (checkURL.GetProtocol() == "tuxbox")
1168 if (checkURL.GetProtocol() == "plugin")
1170 if (checkURL.GetProtocol() == "multipath")
1171 strPath = CMultiPathDirectory::GetFirstPath(strPath);
1173 bIsSourceName = false;
1176 // we first test the NAME of a source
1177 for (int i = 0; i < (int)VECSOURCES.size(); ++i)
1179 CMediaSource share = VECSOURCES.at(i);
1180 CStdString strName = share.strName;
1182 // special cases for dvds
1183 if (URIUtils::IsOnDVD(share.strPath))
1185 if (URIUtils::IsOnDVD(strPath))
1188 // not a path, so we need to modify the source name
1189 // since we add the drive status and disc name to the source
1190 // "Name (Drive Status/Disc Name)"
1191 size_t iPos = strName.rfind('(');
1192 if (iPos != std::string::npos && iPos > 1)
1193 strName = strName.substr(0, iPos - 1);
1195 if (strPath.Equals(strName))
1197 bIsSourceName = true;
1202 // now test the paths
1204 // remove user details, and ensure path only uses forward slashes
1205 // and ends with a trailing slash so as not to match a substring
1206 CURL urlDest(strPath);
1207 urlDest.SetOptions("");
1208 CStdString strDest = urlDest.GetWithoutUserDetails();
1209 ForceForwardSlashes(strDest);
1210 if (!URIUtils::HasSlashAtEnd(strDest))
1214 size_t iLenPath = strDest.size();
1215 for (int i = 0; i < (int)VECSOURCES.size(); ++i)
1217 CMediaSource share = VECSOURCES.at(i);
1219 // does it match a source name?
1220 if (share.strPath.substr(0,8) == "shout://")
1222 CURL url(share.strPath);
1223 if (strPath.Equals(url.GetHostName()))
1227 // doesnt match a name, so try the source path
1228 vector<CStdString> vecPaths;
1230 // add any concatenated paths if they exist
1231 if (share.vecPaths.size() > 0)
1232 vecPaths = share.vecPaths;
1234 // add the actual share path at the front of the vector
1235 vecPaths.insert(vecPaths.begin(), share.strPath);
1238 for (int j = 0; j < (int)vecPaths.size(); ++j)
1240 // remove user details, and ensure path only uses forward slashes
1241 // and ends with a trailing slash so as not to match a substring
1242 CURL urlShare(vecPaths[j]);
1243 urlShare.SetOptions("");
1244 CStdString strShare = urlShare.GetWithoutUserDetails();
1245 ForceForwardSlashes(strShare);
1246 if (!URIUtils::HasSlashAtEnd(strShare))
1248 size_t iLenShare = strShare.size();
1250 if ((iLenPath >= iLenShare) && StringUtils::StartsWithNoCase(strDest, strShare) && (iLenShare > iLength))
1252 // if exact match, return it immediately
1253 if (iLenPath == iLenShare)
1255 // if the path EXACTLY matches an item in a concatentated path
1256 // set source name to true to load the full virtualpath
1257 bIsSourceName = false;
1258 if (vecPaths.size() > 1)
1259 bIsSourceName = true;
1263 iLength = iLenShare;
1268 // return the index of the share with the longest match
1272 // rar:// and zip://
1273 // if archive wasn't mounted, look for a matching share for the archive instead
1274 if( StringUtils::StartsWithNoCase(strPath, "rar://") || StringUtils::StartsWithNoCase(strPath, "zip://") )
1276 // get the hostname portion of the url since it contains the archive file
1277 strPath = checkURL.GetHostName();
1279 bIsSourceName = false;
1281 return GetMatchingSource(strPath, VECSOURCES, bDummy);
1284 CLog::Log(LOGDEBUG,"CUtil::GetMatchingSource: no matching source found for [%s]", strPath1.c_str());
1289 CStdString CUtil::TranslateSpecialSource(const CStdString &strSpecial)
1291 if (!strSpecial.empty() && strSpecial[0] == '$')
1293 if (StringUtils::StartsWithNoCase(strSpecial, "$home"))
1294 return URIUtils::AddFileToFolder("special://home/", strSpecial.substr(5));
1295 else if (StringUtils::StartsWithNoCase(strSpecial, "$subtitles"))
1296 return URIUtils::AddFileToFolder("special://subtitles/", strSpecial.substr(10));
1297 else if (StringUtils::StartsWithNoCase(strSpecial, "$userdata"))
1298 return URIUtils::AddFileToFolder("special://userdata/", strSpecial.substr(9));
1299 else if (StringUtils::StartsWithNoCase(strSpecial, "$database"))
1300 return URIUtils::AddFileToFolder("special://database/", strSpecial.substr(9));
1301 else if (StringUtils::StartsWithNoCase(strSpecial, "$thumbnails"))
1302 return URIUtils::AddFileToFolder("special://thumbnails/", strSpecial.substr(11));
1303 else if (StringUtils::StartsWithNoCase(strSpecial, "$recordings"))
1304 return URIUtils::AddFileToFolder("special://recordings/", strSpecial.substr(11));
1305 else if (StringUtils::StartsWithNoCase(strSpecial, "$screenshots"))
1306 return URIUtils::AddFileToFolder("special://screenshots/", strSpecial.substr(12));
1307 else if (StringUtils::StartsWithNoCase(strSpecial, "$musicplaylists"))
1308 return URIUtils::AddFileToFolder("special://musicplaylists/", strSpecial.substr(15));
1309 else if (StringUtils::StartsWithNoCase(strSpecial, "$videoplaylists"))
1310 return URIUtils::AddFileToFolder("special://videoplaylists/", strSpecial.substr(15));
1311 else if (StringUtils::StartsWithNoCase(strSpecial, "$cdrips"))
1312 return URIUtils::AddFileToFolder("special://cdrips/", strSpecial.substr(7));
1313 // this one will be removed post 2.0
1314 else if (StringUtils::StartsWithNoCase(strSpecial, "$playlists"))
1315 return URIUtils::AddFileToFolder(CSettings::Get().GetString("system.playlistspath"), strSpecial.substr(10));
1320 CStdString CUtil::MusicPlaylistsLocation()
1322 vector<CStdString> vec;
1323 vec.push_back(URIUtils::AddFileToFolder(CSettings::Get().GetString("system.playlistspath"), "music"));
1324 vec.push_back(URIUtils::AddFileToFolder(CSettings::Get().GetString("system.playlistspath"), "mixed"));
1325 return XFILE::CMultiPathDirectory::ConstructMultiPath(vec);
1328 CStdString CUtil::VideoPlaylistsLocation()
1330 vector<CStdString> vec;
1331 vec.push_back(URIUtils::AddFileToFolder(CSettings::Get().GetString("system.playlistspath"), "video"));
1332 vec.push_back(URIUtils::AddFileToFolder(CSettings::Get().GetString("system.playlistspath"), "mixed"));
1333 return XFILE::CMultiPathDirectory::ConstructMultiPath(vec);
1336 void CUtil::DeleteMusicDatabaseDirectoryCache()
1338 CUtil::DeleteDirectoryCache("mdb-");
1339 CUtil::DeleteDirectoryCache("sp-"); // overkill as it will delete video smartplaylists, but as we can't differentiate based on URL...
1342 void CUtil::DeleteVideoDatabaseDirectoryCache()
1344 CUtil::DeleteDirectoryCache("vdb-");
1345 CUtil::DeleteDirectoryCache("sp-"); // overkill as it will delete music smartplaylists, but as we can't differentiate based on URL...
1348 void CUtil::DeleteDirectoryCache(const CStdString &prefix)
1350 CStdString searchPath = "special://temp/";
1351 CFileItemList items;
1352 if (!XFILE::CDirectory::GetDirectory(searchPath, items, ".fi", DIR_FLAG_NO_FILE_DIRS))
1355 for (int i = 0; i < items.Size(); ++i)
1357 if (items[i]->m_bIsFolder)
1359 CStdString fileName = URIUtils::GetFileName(items[i]->GetPath());
1360 if (StringUtils::StartsWith(fileName, prefix))
1361 XFILE::CFile::Delete(items[i]->GetPath());
1366 void CUtil::GetRecursiveListing(const CStdString& strPath, CFileItemList& items, const CStdString& strMask, bool bUseFileDirectories)
1368 CFileItemList myItems;
1369 int flags = DIR_FLAG_DEFAULTS;
1370 if (!bUseFileDirectories)
1371 flags |= DIR_FLAG_NO_FILE_DIRS;
1372 CDirectory::GetDirectory(strPath,myItems,strMask,flags);
1373 for (int i=0;i<myItems.Size();++i)
1375 if (myItems[i]->m_bIsFolder)
1376 CUtil::GetRecursiveListing(myItems[i]->GetPath(),items,strMask,bUseFileDirectories);
1378 items.Add(myItems[i]);
1382 void CUtil::GetRecursiveDirsListing(const CStdString& strPath, CFileItemList& item)
1384 CFileItemList myItems;
1385 CDirectory::GetDirectory(strPath,myItems,"",DIR_FLAG_NO_FILE_DIRS);
1386 for (int i=0;i<myItems.Size();++i)
1388 if (myItems[i]->m_bIsFolder && !myItems[i]->GetPath().Equals(".."))
1390 item.Add(myItems[i]);
1391 CUtil::GetRecursiveDirsListing(myItems[i]->GetPath(),item);
1396 void CUtil::ForceForwardSlashes(CStdString& strPath)
1398 size_t iPos = strPath.rfind('\\');
1399 while (iPos != string::npos)
1401 strPath.at(iPos) = '/';
1402 iPos = strPath.rfind('\\');
1406 double CUtil::AlbumRelevance(const CStdString& strAlbumTemp1, const CStdString& strAlbum1, const CStdString& strArtistTemp1, const CStdString& strArtist1)
1408 // case-insensitive fuzzy string comparison on the album and artist for relevance
1409 // weighting is identical, both album and artist are 50% of the total relevance
1410 // a missing artist means the maximum relevance can only be 0.50
1411 CStdString strAlbumTemp = strAlbumTemp1;
1412 StringUtils::ToLower(strAlbumTemp);
1413 CStdString strAlbum = strAlbum1;
1414 StringUtils::ToLower(strAlbum);
1415 double fAlbumPercentage = fstrcmp(strAlbumTemp, strAlbum, 0.0f);
1416 double fArtistPercentage = 0.0f;
1417 if (!strArtist1.empty())
1419 CStdString strArtistTemp = strArtistTemp1;
1420 StringUtils::ToLower(strArtistTemp);
1421 CStdString strArtist = strArtist1;
1422 StringUtils::ToLower(strArtist);
1423 fArtistPercentage = fstrcmp(strArtistTemp, strArtist, 0.0f);
1425 double fRelevance = fAlbumPercentage * 0.5f + fArtistPercentage * 0.5f;
1429 bool CUtil::MakeShortenPath(CStdString StrInput, CStdString& StrOutput, size_t iTextMaxLength)
1431 size_t iStrInputSize = StrInput.size();
1432 if(iStrInputSize <= 0 || iTextMaxLength >= iStrInputSize)
1436 size_t nGreaterDelim, nPos;
1438 nPos = StrInput.find_last_of( '\\' );
1439 if (nPos != std::string::npos)
1443 nPos = StrInput.find_last_of( '/' );
1444 if (nPos != std::string::npos)
1447 if ( cDelim == '\0' )
1450 if (nPos == StrInput.size() - 1)
1452 StrInput.erase(StrInput.size() - 1);
1453 nPos = StrInput.find_last_of(cDelim);
1455 while( iTextMaxLength < iStrInputSize )
1457 nPos = StrInput.find_last_of( cDelim, nPos );
1458 nGreaterDelim = nPos;
1459 if ( nPos != std::string::npos )
1460 nPos = StrInput.find_last_of( cDelim, nPos - 1 );
1461 if ( nPos == CStdString::npos ) break;
1462 if ( nGreaterDelim > nPos ) StrInput.replace( nPos + 1, nGreaterDelim - nPos - 1, ".." );
1463 iStrInputSize = StrInput.size();
1465 // replace any additional /../../ with just /../ if necessary
1466 CStdString replaceDots = StringUtils::Format("..%c..", cDelim);
1467 while (StrInput.size() > (unsigned int)iTextMaxLength)
1468 if (!StringUtils::Replace(StrInput, replaceDots, ".."))
1470 // finally, truncate our string to force inside our max text length,
1471 // replacing the last 2 characters with ".."
1474 // "smb://../Playboy Swimsuit Cal.."
1475 if (iTextMaxLength > 2 && StrInput.size() > (unsigned int)iTextMaxLength)
1477 StrInput.erase(iTextMaxLength - 2);
1480 StrOutput = StrInput;
1484 bool CUtil::SupportsWriteFileOperations(const CStdString& strPath)
1486 // currently only hd, smb, nfs, afp and dav support delete and rename
1487 if (URIUtils::IsHD(strPath))
1489 if (URIUtils::IsSmb(strPath))
1491 if (CUtil::IsTVRecording(strPath))
1492 return CPVRDirectory::SupportsWriteFileOperations(strPath);
1493 if (URIUtils::IsNfs(strPath))
1495 if (URIUtils::IsAfp(strPath))
1497 if (URIUtils::IsDAV(strPath))
1499 if (URIUtils::IsMythTV(strPath))
1502 * Can't use CFile::Exists() to check whether the myth:// path supports file operations because
1503 * it hits the directory cache on the way through, which has the Live Channels and Guide
1506 return CMythDirectory::SupportsWriteFileOperations(strPath);
1508 if (URIUtils::IsStack(strPath))
1509 return SupportsWriteFileOperations(CStackDirectory::GetFirstStackedFile(strPath));
1510 if (URIUtils::IsMultiPath(strPath))
1511 return CMultiPathDirectory::SupportsWriteFileOperations(strPath);
1516 bool CUtil::SupportsReadFileOperations(const CStdString& strPath)
1518 if (URIUtils::IsVideoDb(strPath))
1524 CStdString CUtil::GetDefaultFolderThumb(const CStdString &folderThumb)
1526 if (g_TextureManager.HasTexture(folderThumb))
1531 void CUtil::GetSkinThemes(vector<CStdString>& vecTheme)
1533 CStdString strPath = URIUtils::AddFileToFolder(g_graphicsContext.GetMediaDir(), "media");
1534 CFileItemList items;
1535 CDirectory::GetDirectory(strPath, items);
1536 // Search for Themes in the Current skin!
1537 for (int i = 0; i < items.Size(); ++i)
1539 CFileItemPtr pItem = items[i];
1540 if (!pItem->m_bIsFolder)
1542 CStdString strExtension = URIUtils::GetExtension(pItem->GetPath());
1543 if ((strExtension == ".xpr" && !StringUtils::EqualsNoCase(pItem->GetLabel(), "Textures.xpr")) ||
1544 (strExtension == ".xbt" && !StringUtils::EqualsNoCase(pItem->GetLabel(), "Textures.xbt")))
1546 CStdString strLabel = pItem->GetLabel();
1547 vecTheme.push_back(strLabel.substr(0, strLabel.size() - 4));
1551 sort(vecTheme.begin(), vecTheme.end(), sortstringbyname());
1554 void CUtil::InitRandomSeed()
1558 now = CurrentHostCounter();
1559 unsigned int seed = (unsigned int)now;
1560 // CLog::Log(LOGDEBUG, "%s - Initializing random seed with %u", __FUNCTION__, seed);
1565 bool CUtil::RunCommandLine(const CStdString& cmdLine, bool waitExit)
1567 CStdStringArray args;
1569 StringUtils::SplitString(cmdLine, ",", args);
1571 // Strip quotes and whitespace around the arguments, or exec will fail.
1572 // This allows the python invocation to be written more naturally with any amount of whitespace around the args.
1573 // But it's still limited, for example quotes inside the strings are not expanded, etc.
1574 // TODO: Maybe some python library routine can parse this more properly ?
1575 for (CStdStringArray::iterator it = args.begin(); it != args.end(); ++it)
1578 pos = it->find_first_not_of(" \t\n\"'");
1579 if (pos != std::string::npos)
1584 pos = it->find_last_not_of(" \t\n\"'"); // if it returns npos we'll end up with an empty string which is OK
1586 it->erase(++pos, it->size());
1590 return Command(args, waitExit);
1594 // FIXME, this should be merged with the function below.
1596 bool CUtil::Command(const CStdStringArray& arrArgs, bool waitExit)
1599 printf("Executing: ");
1600 for (size_t i=0; i<arrArgs.size(); i++)
1601 printf("%s ", arrArgs[i].c_str());
1605 pid_t child = fork();
1611 // fork again in order not to leave a zombie process
1615 else if (child != 0)
1621 if (arrArgs.size() > 0)
1623 char **args = (char **)alloca(sizeof(char *) * (arrArgs.size() + 3));
1624 memset(args, 0, (sizeof(char *) * (arrArgs.size() + 3)));
1625 for (size_t i=0; i<arrArgs.size(); i++)
1626 args[i] = (char *)arrArgs[i].c_str();
1627 execvp(args[0], args);
1632 waitpid(child, &n, 0);
1635 return (waitExit) ? (WEXITSTATUS(n) == 0) : true;
1638 bool CUtil::SudoCommand(const CStdString &strCommand)
1640 CLog::Log(LOGDEBUG, "Executing sudo command: <%s>", strCommand.c_str());
1641 pid_t child = fork();
1645 close(0); // close stdin to avoid sudo request password
1648 CStdStringArray arrArgs;
1649 StringUtils::SplitString(strCommand, " ", arrArgs);
1650 if (arrArgs.size() > 0)
1652 char **args = (char **)alloca(sizeof(char *) * (arrArgs.size() + 3));
1653 memset(args, 0, (sizeof(char *) * (arrArgs.size() + 3)));
1654 args[0] = (char *)"/usr/bin/sudo";
1655 args[1] = (char *)"-S";
1656 for (size_t i=0; i<arrArgs.size(); i++)
1658 args[i+2] = (char *)arrArgs[i].c_str();
1660 execvp("/usr/bin/sudo", args);
1664 waitpid(child, &n, 0);
1666 return WEXITSTATUS(n) == 0;
1670 int CUtil::LookupRomanDigit(char roman_digit)
1672 switch (roman_digit)
1700 int CUtil::TranslateRomanNumeral(const char* roman_numeral)
1705 if (roman_numeral && roman_numeral[0])
1712 while (*roman_numeral)
1714 int digit = CUtil::LookupRomanDigit(*roman_numeral);
1717 // General sanity checks
1719 // numeral not in LUT
1726 // N = 10^n may not precede (N+1) > 10^(N+1)
1727 if (test == 1 && digit > last * 10)
1730 // N = 5*10^n may not precede (N+1) >= N
1731 if (test == 5 && digit >= last)
1734 // End general sanity checks
1738 // smaller numerals may not repeat before a larger one
1747 else if (last == digit)
1756 decimal += 2 * last - temp_sum;
1758 decimal += temp_sum;
1765 // Post general sanity checks
1767 // numerals may not repeat more than thrice
1776 decimal += temp_sum;
1778 decimal += 2 * last - temp_sum;
1783 CStdString CUtil::ResolveExecutablePath()
1785 CStdString strExecutablePath;
1786 #ifdef TARGET_WINDOWS
1787 static const size_t bufSize = MAX_PATH * 2;
1788 wchar_t* buf = new wchar_t[bufSize];
1790 ::GetModuleFileNameW(0, buf, bufSize);
1792 g_charsetConverter.wToUTF8(buf,strExecutablePath);
1794 #elif defined(TARGET_DARWIN)
1795 char given_path[2*MAXPATHLEN];
1796 uint32_t path_size =2*MAXPATHLEN;
1798 GetDarwinExecutablePath(given_path, &path_size);
1799 strExecutablePath = given_path;
1800 #elif defined(TARGET_FREEBSD)
1807 mib[2] = KERN_PROC_PATHNAME;
1810 buflen = sizeof(buf) - 1;
1811 if(sysctl(mib, 4, buf, &buflen, NULL, 0) < 0)
1812 strExecutablePath = "";
1814 strExecutablePath = buf;
1816 /* Get our PID and build the name of the link in /proc */
1817 pid_t pid = getpid();
1818 char linkname[64]; /* /proc/<pid>/exe */
1819 snprintf(linkname, sizeof(linkname), "/proc/%i/exe", pid);
1821 /* Now read the symbolic link */
1822 char buf[PATH_MAX + 1];
1825 int ret = readlink(linkname, buf, sizeof(buf) - 1);
1829 strExecutablePath = buf;
1831 return strExecutablePath;
1834 CStdString CUtil::GetFrameworksPath(bool forPython)
1836 CStdString strFrameworksPath;
1837 #if defined(TARGET_DARWIN)
1838 char given_path[2*MAXPATHLEN];
1839 uint32_t path_size =2*MAXPATHLEN;
1841 GetDarwinFrameworkPath(forPython, given_path, &path_size);
1842 strFrameworksPath = given_path;
1844 return strFrameworksPath;
1847 void CUtil::ScanForExternalSubtitles(const CStdString& strMovie, std::vector<CStdString>& vecSubtitles )
1849 unsigned int startTimer = XbmcThreads::SystemClockMillis();
1851 // new array for commons sub dirs
1852 const char * common_sub_dirs[] = {"subs",
1866 vector<CStdString> vecExtensionsCached;
1868 CFileItem item(strMovie, false);
1869 if ( item.IsInternetStream()
1870 || item.IsHDHomeRun()
1871 || item.IsSlingbox()
1872 || item.IsPlayList()
1877 vector<CStdString> strLookInPaths;
1879 CStdString strMovieFileName;
1882 URIUtils::Split(strMovie, strPath, strMovieFileName);
1883 CStdString strMovieFileNameNoExt(URIUtils::ReplaceExtension(strMovieFileName, ""));
1884 strLookInPaths.push_back(strPath);
1886 if (!CMediaSettings::Get().GetAdditionalSubtitleDirectoryChecked() && !CSettings::Get().GetString("subtitles.custompath").empty()) // to avoid checking non-existent directories (network) every time..
1888 if (!g_application.getNetwork().IsAvailable() && !URIUtils::IsHD(CSettings::Get().GetString("subtitles.custompath")))
1890 CLog::Log(LOGINFO,"CUtil::CacheSubtitles: disabling alternate subtitle directory for this session, it's nonaccessible");
1891 CMediaSettings::Get().SetAdditionalSubtitleDirectoryChecked(-1); // disabled
1893 else if (!CDirectory::Exists(CSettings::Get().GetString("subtitles.custompath")))
1895 CLog::Log(LOGINFO,"CUtil::CacheSubtitles: disabling alternate subtitle directory for this session, it's nonexistant");
1896 CMediaSettings::Get().SetAdditionalSubtitleDirectoryChecked(-1); // disabled
1899 CMediaSettings::Get().SetAdditionalSubtitleDirectoryChecked(1);
1902 if (StringUtils::StartsWith(strMovie, "rar://")) // <--- if this is found in main path then ignore it!
1905 CStdString strArchive = url.GetHostName();
1906 URIUtils::Split(strArchive, strPath, strMovieFileName);
1907 strLookInPaths.push_back(strPath);
1910 int iSize = strLookInPaths.size();
1911 for (int i=0; i<iSize; ++i)
1913 CStdStringArray directories;
1914 int nTokens = StringUtils::SplitString( strLookInPaths[i], "/", directories );
1916 StringUtils::SplitString( strLookInPaths[i], "\\", directories );
1918 // if it's inside a cdX dir, add parent path
1919 if (directories.size() >= 2 && directories[directories.size()-2].size() == 3 && StringUtils::StartsWithNoCase(directories[directories.size()-2], "cd")) // SplitString returns empty token as last item, hence size-2
1921 CStdString strPath2;
1922 URIUtils::GetParentPath(strLookInPaths[i], strPath2);
1923 strLookInPaths.push_back(strPath2);
1927 // checking if any of the common subdirs exist ..
1928 iSize = strLookInPaths.size();
1929 for (int i=0;i<iSize;++i)
1931 for (int j=0; common_sub_dirs[j]; j++)
1933 CStdString strPath2 = URIUtils::AddFileToFolder(strLookInPaths[i],common_sub_dirs[j]);
1934 URIUtils::AddSlashAtEnd(strPath2);
1935 if (CDirectory::Exists(strPath2))
1936 strLookInPaths.push_back(strPath2);
1939 // .. done checking for common subdirs
1941 // check if there any cd-directories in the paths we have added so far
1942 iSize = strLookInPaths.size();
1943 for (int i=0;i<9;++i) // 9 cd's
1945 CStdString cdDir = StringUtils::Format("cd%i",i+1);
1946 for (int i=0;i<iSize;++i)
1948 CStdString strPath2 = URIUtils::AddFileToFolder(strLookInPaths[i],cdDir);
1949 URIUtils::AddSlashAtEnd(strPath2);
1950 bool pathAlreadyAdded = false;
1951 for (unsigned int i=0; i<strLookInPaths.size(); i++)
1953 // if movie file is inside cd-dir, this directory can exist in vector already
1954 if (strLookInPaths[i].Equals( strPath2 ) )
1955 pathAlreadyAdded = true;
1957 if (CDirectory::Exists(strPath2) && !pathAlreadyAdded)
1958 strLookInPaths.push_back(strPath2);
1961 // .. done checking for cd-dirs
1963 // this is last because we dont want to check any common subdirs or cd-dirs in the alternate <subtitles> dir.
1964 if (CMediaSettings::Get().GetAdditionalSubtitleDirectoryChecked() == 1)
1966 strPath = CSettings::Get().GetString("subtitles.custompath");
1967 URIUtils::AddSlashAtEnd(strPath);
1968 strLookInPaths.push_back(strPath);
1975 // 2 steps for movie directory and alternate subtitles directory
1976 CLog::Log(LOGDEBUG,"%s: Searching for subtitles...", __FUNCTION__);
1977 for (unsigned int step = 0; step < strLookInPaths.size(); step++)
1979 if (strLookInPaths[step].length() != 0)
1981 CFileItemList items;
1983 CDirectory::GetDirectory(strLookInPaths[step], items, g_advancedSettings.m_subtitlesExtensions, DIR_FLAG_NO_FILE_DIRS);
1985 for (int j = 0; j < items.Size(); j++)
1987 URIUtils::Split(items[j]->GetPath(), strPath, strItem);
1989 if (StringUtils::StartsWithNoCase(strItem, strMovieFileNameNoExt))
1991 // is this a rar or zip-file
1992 if (URIUtils::IsRAR(strItem) || URIUtils::IsZIP(strItem))
1994 // zip-file name equals strMovieFileNameNoExt, don't check in zip-file
1995 ScanArchiveForSubtitles( items[j]->GetPath(), "", vecSubtitles );
1997 else // not a rar/zip file
1999 for (int i = 0; sub_exts[i]; i++)
2001 //Cache subtitle with same name as movie
2002 if (URIUtils::HasExtension(strItem, sub_exts[i]))
2004 vecSubtitles.push_back( items[j]->GetPath() );
2005 CLog::Log(LOGINFO, "%s: found subtitle file %s\n", __FUNCTION__, items[j]->GetPath().c_str() );
2012 // is this a rar or zip-file
2013 if (URIUtils::IsRAR(strItem) || URIUtils::IsZIP(strItem))
2015 // check strMovieFileNameNoExt in zip-file
2016 ScanArchiveForSubtitles( items[j]->GetPath(), strMovieFileNameNoExt, vecSubtitles );
2023 iSize = vecSubtitles.size();
2024 for (int i = 0; i < iSize; i++)
2026 if (URIUtils::HasExtension(vecSubtitles[i], ".smi"))
2028 //Cache multi-language sami subtitle
2029 CDVDSubtitleStream* pStream = new CDVDSubtitleStream();
2030 if(pStream->Open(vecSubtitles[i]))
2032 CDVDSubtitleTagSami TagConv;
2033 TagConv.LoadHead(pStream);
2034 if (TagConv.m_Langclass.size() >= 2)
2036 for (unsigned int k = 0; k < TagConv.m_Langclass.size(); k++)
2038 strDest = StringUtils::Format("special://temp/subtitle.%s.%d.smi", TagConv.m_Langclass[k].Name.c_str(), i);
2039 if (CFile::Cache(vecSubtitles[i], strDest))
2041 CLog::Log(LOGINFO, " cached subtitle %s->%s\n", vecSubtitles[i].c_str(), strDest.c_str());
2042 vecSubtitles.push_back(strDest);
2050 CLog::Log(LOGDEBUG,"%s: END (total time: %i ms)", __FUNCTION__, (int)(XbmcThreads::SystemClockMillis() - startTimer));
2053 int CUtil::ScanArchiveForSubtitles( const CStdString& strArchivePath, const CStdString& strMovieFileNameNoExt, std::vector<CStdString>& vecSubtitles )
2055 int nSubtitlesAdded = 0;
2056 CFileItemList ItemList;
2058 // zip only gets the root dir
2059 if (URIUtils::HasExtension(strArchivePath, ".zip"))
2061 CStdString strZipPath;
2062 URIUtils::CreateArchivePath(strZipPath,"zip",strArchivePath,"");
2063 if (!CDirectory::GetDirectory(strZipPath,ItemList,"",DIR_FLAG_NO_FILE_DIRS))
2068 #ifdef HAS_FILESYSTEM_RAR
2069 // get _ALL_files in the rar, even those located in subdirectories because we set the bMask to false.
2070 // so now we dont have to find any subdirs anymore, all files in the rar is checked.
2071 if( !g_RarManager.GetFilesInRar(ItemList, strArchivePath, false, "") )
2077 for (int it= 0 ; it <ItemList.Size();++it)
2079 CStdString strPathInRar = ItemList[it]->GetPath();
2080 CStdString strExt = URIUtils::GetExtension(strPathInRar);
2082 CLog::Log(LOGDEBUG, "ScanArchiveForSubtitles:: Found file %s", strPathInRar.c_str());
2083 // always check any embedded rar archives
2084 // checking for embedded rars, I moved this outside the sub_ext[] loop. We only need to check this once for each file.
2085 if (URIUtils::IsRAR(strPathInRar) || URIUtils::IsZIP(strPathInRar))
2087 CStdString strRarInRar;
2088 if (strExt == ".rar")
2089 URIUtils::CreateArchivePath(strRarInRar, "rar", strArchivePath, strPathInRar);
2091 URIUtils::CreateArchivePath(strRarInRar, "zip", strArchivePath, strPathInRar);
2092 ScanArchiveForSubtitles(strRarInRar,strMovieFileNameNoExt,vecSubtitles);
2094 // done checking if this is a rar-in-rar
2096 // check that the found filename matches the movie filename
2097 int fnl = strMovieFileNameNoExt.size();
2098 if (fnl && !StringUtils::StartsWithNoCase(URIUtils::GetFileName(strPathInRar), strMovieFileNameNoExt))
2102 while (sub_exts[iPos])
2104 if (StringUtils::EqualsNoCase(strExt, sub_exts[iPos]))
2106 CStdString strSourceUrl;
2107 if (URIUtils::HasExtension(strArchivePath, ".rar"))
2108 URIUtils::CreateArchivePath(strSourceUrl, "rar", strArchivePath, strPathInRar);
2110 strSourceUrl = strPathInRar;
2112 CLog::Log(LOGINFO, "%s: found subtitle file %s\n", __FUNCTION__, strSourceUrl.c_str() );
2113 vecSubtitles.push_back( strSourceUrl );
2121 return nSubtitlesAdded;
2124 void CUtil::GetExternalStreamDetailsFromFilename(const CStdString& strVideo, const CStdString& strStream, ExternalStreamInfo& info)
2126 CStdString videoBaseName = URIUtils::GetFileName(strVideo);
2127 URIUtils::RemoveExtension(videoBaseName);
2129 CStdString toParse = URIUtils::GetFileName(strStream);
2130 URIUtils::RemoveExtension(toParse);
2132 // we check left part - if it's same as video base name - strip it
2133 if (StringUtils::StartsWithNoCase(toParse, videoBaseName))
2134 toParse = toParse.substr(videoBaseName.length());
2136 // trim any non-alphanumeric char in the begining
2137 std::string::iterator result = std::find_if(toParse.begin(), toParse.end(), ::isalnum);
2140 if (result != toParse.end()) // if we have anything to parse
2142 std::string inputString(result, toParse.end());
2143 std::string delimiters(" .-");
2144 std::vector<std::string> tokens;
2145 StringUtils::Tokenize(inputString, tokens, delimiters);
2147 for (std::vector<std::string>::iterator it = tokens.begin(); it != tokens.end(); ++it)
2149 if (info.language.empty())
2151 CStdString langTmp(*it);
2152 CStdString langCode;
2153 // try to recognize language
2154 if (g_LangCodeExpander.ConvertToThreeCharCode(langCode, langTmp))
2156 info.language = langCode;
2161 // try to recognize a flag
2162 std::string flag_tmp(*it);
2163 StringUtils::ToLower(flag_tmp);
2164 if (!flag_tmp.compare("none"))
2166 info.flag |= CDemuxStream::FLAG_NONE;
2169 else if (!flag_tmp.compare("default"))
2171 info.flag |= CDemuxStream::FLAG_DEFAULT;
2174 else if (!flag_tmp.compare("forced"))
2176 info.flag |= CDemuxStream::FLAG_FORCED;
2180 name += " " + (*it);
2184 name += g_localizeStrings.Get(21602); // External
2185 StringUtils::Trim(name);
2186 info.name = StringUtils::RemoveDuplicatedSpacesAndTabs(name);
2188 info.flag = CDemuxStream::FLAG_NONE;
2190 CLog::Log(LOGDEBUG, "%s - Language = '%s' / Name = '%s' / Flag = '%u' from %s", __FUNCTION__, info.language.c_str(), info.name.c_str(), info.flag, strStream.c_str());
2193 /*! \brief in a vector of subtitles finds the corresponding .sub file for a given .idx file
2195 bool CUtil::FindVobSubPair( const std::vector<CStdString>& vecSubtitles, const CStdString& strIdxPath, CStdString& strSubPath )
2197 if (URIUtils::HasExtension(strIdxPath, ".idx"))
2199 CStdString strIdxFile;
2200 CStdString strIdxDirectory;
2201 URIUtils::Split(strIdxPath, strIdxDirectory, strIdxFile);
2202 for (unsigned int j=0; j < vecSubtitles.size(); j++)
2204 CStdString strSubFile;
2205 CStdString strSubDirectory;
2206 URIUtils::Split(vecSubtitles[j], strSubDirectory, strSubFile);
2207 if (URIUtils::IsInArchive(vecSubtitles[j]))
2208 strSubDirectory = CURL::Decode(strSubDirectory);
2209 if (URIUtils::HasExtension(strSubFile, ".sub") &&
2210 (URIUtils::ReplaceExtension(strIdxFile,"").Equals(URIUtils::ReplaceExtension(strSubFile,"")) ||
2211 (strSubDirectory.size() >= 11 &&
2212 StringUtils::EqualsNoCase(strSubDirectory.substr(6, strSubDirectory.length()-11), URIUtils::ReplaceExtension(strIdxPath,"")))))
2214 strSubPath = vecSubtitles[j];
2222 /*! \brief checks if in the vector of subtitles the given .sub file has a corresponding idx and hence is a vobsub file
2224 bool CUtil::IsVobSub( const std::vector<CStdString>& vecSubtitles, const CStdString& strSubPath )
2226 if (URIUtils::HasExtension(strSubPath, ".sub"))
2228 CStdString strSubFile;
2229 CStdString strSubDirectory;
2230 URIUtils::Split(strSubPath, strSubDirectory, strSubFile);
2231 if (URIUtils::IsInArchive(strSubPath))
2232 strSubDirectory = CURL::Decode(strSubDirectory);
2233 for (unsigned int j=0; j < vecSubtitles.size(); j++)
2235 CStdString strIdxFile;
2236 CStdString strIdxDirectory;
2237 URIUtils::Split(vecSubtitles[j], strIdxDirectory, strIdxFile);
2238 if (URIUtils::HasExtension(strIdxFile, ".idx") &&
2239 (URIUtils::ReplaceExtension(strIdxFile,"").Equals(URIUtils::ReplaceExtension(strSubFile,"")) ||
2240 (strSubDirectory.size() >= 11 &&
2241 StringUtils::EqualsNoCase(strSubDirectory.substr(6, strSubDirectory.length()-11), URIUtils::ReplaceExtension(vecSubtitles[j],"")))))
2248 bool CUtil::CanBindPrivileged()
2253 return true; //root user can always bind to privileged ports
2257 //check if CAP_NET_BIND_SERVICE is enabled, this allows non-root users to bind to privileged ports
2258 bool canbind = false;
2259 cap_t capabilities = cap_get_proc();
2262 cap_flag_value_t value;
2263 if (cap_get_flag(capabilities, CAP_NET_BIND_SERVICE, CAP_EFFECTIVE, &value) == 0)
2266 cap_free(capabilities);
2275 #endif //HAVE_LIBCAP
2277 #else //TARGET_POSIX
2281 #endif //TARGET_POSIX
2284 bool CUtil::ValidatePort(int port)
2286 // check that it's a valid port
2288 if (!CUtil::CanBindPrivileged() && (port < 1024 || port > 65535))
2292 if (port <= 0 || port > 65535)
2298 int CUtil::GetRandomNumber()
2300 #ifdef TARGET_WINDOWS
2301 unsigned int number;
2302 if (rand_s(&number) == 0)
2305 return rand_r(&s_randomSeed);