xbmc/utils/URIUtils.cpp

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "network/Network.h"
  10 #include "URIUtils.h"
  11 #include "FileItem.h"
  12 #include "filesystem/MultiPathDirectory.h"
  13 #include "filesystem/SpecialProtocol.h"
  14 #include "filesystem/StackDirectory.h"
  15 #include "network/DNSNameCache.h"
  16 #include "pvr/channels/PVRChannelsPath.h"
  17 #include "settings/AdvancedSettings.h"
  18 #include "URL.h"
  19 #include "utils/FileExtensionProvider.h"
  20 #include "ServiceBroker.h"
  21 #include "StringUtils.h"
  22 #include "utils/log.h"
  23
  24 #if defined(TARGET_WINDOWS)
  25 #include "platform/win32/CharsetConverter.h"
  26 #endif
  27
  28 #include <algorithm>
  29 #include <cassert>
  30 #include <netinet/in.h>
  31 #include <arpa/inet.h>
  32
  33 using namespace PVR;
  34 using namespace XFILE;
  35
  36 const CAdvancedSettings* URIUtils::m_advancedSettings = nullptr;
  37
  38 void URIUtils::RegisterAdvancedSettings(const CAdvancedSettings& advancedSettings)
  39 {
  40   m_advancedSettings = &advancedSettings;
  41 }
  42
  43 void URIUtils::UnregisterAdvancedSettings()
  44 {
  45   m_advancedSettings = nullptr;
  46 }
  47
  48 /* returns filename extension including period of filename */
  49 std::string URIUtils::GetExtension(const CURL& url)
  50 {
  51   return URIUtils::GetExtension(url.GetFileName());
  52 }
  53
  54 std::string URIUtils::GetExtension(const std::string& strFileName)
  55 {
  56   if (IsURL(strFileName))
  57   {
  58     CURL url(strFileName);
  59     return GetExtension(url.GetFileName());
  60   }
  61
  62   size_t period = strFileName.find_last_of("./\\");
  63   if (period == std::string::npos || strFileName[period] != '.')
  64     return std::string();
  65
  66   return strFileName.substr(period);
  67 }
  68
  69 bool URIUtils::HasPluginPath(const CFileItem& item)
  70 {
  71   return IsPlugin(item.GetPath()) || IsPlugin(item.GetDynPath());
  72 }
  73
  74 bool URIUtils::HasExtension(const std::string& strFileName)
  75 {
  76   if (IsURL(strFileName))
  77   {
  78     CURL url(strFileName);
  79     return HasExtension(url.GetFileName());
  80   }
  81
  82   size_t iPeriod = strFileName.find_last_of("./\\");
  83   return iPeriod != std::string::npos && strFileName[iPeriod] == '.';
  84 }
  85
  86 bool URIUtils::HasExtension(const CURL& url, const std::string& strExtensions)
  87 {
  88   return HasExtension(url.GetFileName(), strExtensions);
  89 }
  90
  91 bool URIUtils::HasExtension(const std::string& strFileName, const std::string& strExtensions)
  92 {
  93   if (IsURL(strFileName))
  94   {
  95     const CURL url(strFileName);
  96     return HasExtension(url.GetFileName(), strExtensions);
  97   }
  98
  99   const size_t pos = strFileName.find_last_of("./\\");
 100   if (pos == std::string::npos || strFileName[pos] != '.')
 101     return false;
 102
 103   const std::string extensionLower = StringUtils::ToLower(strFileName.substr(pos));
 104
 105   const std::vector<std::string> extensionsLower =
 106       StringUtils::Split(StringUtils::ToLower(strExtensions), '|');
 107
 108   for (const auto& ext : extensionsLower)
 109   {
 110     if (StringUtils::EndsWith(ext, extensionLower))
 111       return true;
 112   }
 113
 114   return false;
 115 }
 116
 117 void URIUtils::RemoveExtension(std::string& strFileName)
 118 {
 119   if(IsURL(strFileName))
 120   {
 121     CURL url(strFileName);
 122     strFileName = url.GetFileName();
 123     RemoveExtension(strFileName);
 124     url.SetFileName(strFileName);
 125     strFileName = url.Get();
 126     return;
 127   }
 128
 129   size_t period = strFileName.find_last_of("./\\");
 130   if (period != std::string::npos && strFileName[period] == '.')
 131   {
 132     std::string strExtension = strFileName.substr(period);
 133     StringUtils::ToLower(strExtension);
 134     strExtension += "|";
 135
 136     std::string strFileMask;
 137     strFileMask = CServiceBroker::GetFileExtensionProvider().GetPictureExtensions();
 138     strFileMask += "|" + CServiceBroker::GetFileExtensionProvider().GetMusicExtensions();
 139     strFileMask += "|" + CServiceBroker::GetFileExtensionProvider().GetVideoExtensions();
 140     strFileMask += "|" + CServiceBroker::GetFileExtensionProvider().GetSubtitleExtensions();
 141 #if defined(TARGET_DARWIN)
 142     strFileMask += "|.py|.xml|.milk|.xbt|.cdg|.app|.applescript|.workflow";
 143 #else
 144     strFileMask += "|.py|.xml|.milk|.xbt|.cdg";
 145 #endif
 146     strFileMask += "|";
 147
 148     if (strFileMask.find(strExtension) != std::string::npos)
 149       strFileName.erase(period);
 150   }
 151 }
 152
 153 std::string URIUtils::ReplaceExtension(const std::string& strFile,
 154                                       const std::string& strNewExtension)
 155 {
 156   if(IsURL(strFile))
 157   {
 158     CURL url(strFile);
 159     url.SetFileName(ReplaceExtension(url.GetFileName(), strNewExtension));
 160     return url.Get();
 161   }
 162
 163   std::string strChangedFile;
 164   std::string strExtension = GetExtension(strFile);
 165   if ( strExtension.size() )
 166   {
 167     strChangedFile = strFile.substr(0, strFile.size() - strExtension.size()) ;
 168     strChangedFile += strNewExtension;
 169   }
 170   else
 171   {
 172     strChangedFile = strFile;
 173     strChangedFile += strNewExtension;
 174   }
 175   return strChangedFile;
 176 }
 177
 178 std::string URIUtils::GetFileName(const CURL& url)
 179 {
 180   return GetFileName(url.GetFileName());
 181 }
 182
 183 /* returns a filename given an url */
 184 /* handles both / and \, and options in urls*/
 185 std::string URIUtils::GetFileName(const std::string& strFileNameAndPath)
 186 {
 187   if(IsURL(strFileNameAndPath))
 188   {
 189     CURL url(strFileNameAndPath);
 190     return GetFileName(url.GetFileName());
 191   }
 192
 193   /* find the last slash */
 194   const size_t slash = strFileNameAndPath.find_last_of("/\\");
 195   return strFileNameAndPath.substr(slash+1);
 196 }
 197
 198 void URIUtils::Split(const std::string& strFileNameAndPath,
 199                      std::string& strPath, std::string& strFileName)
 200 {
 201   //Splits a full filename in path and file.
 202   //ex. smb://computer/share/directory/filename.ext -> strPath:smb://computer/share/directory/ and strFileName:filename.ext
 203   //Trailing slash will be preserved
 204   strFileName = "";
 205   strPath = "";
 206   int i = strFileNameAndPath.size() - 1;
 207   while (i > 0)
 208   {
 209     char ch = strFileNameAndPath[i];
 210     // Only break on ':' if it's a drive separator for DOS (ie d:foo)
 211     if (ch == '/' || ch == '\\' || (ch == ':' && i == 1)) break;
 212     else i--;
 213   }
 214   if (i == 0)
 215     i--;
 216
 217   // take left including the directory separator
 218   strPath = strFileNameAndPath.substr(0, i+1);
 219   // everything to the right of the directory separator
 220   strFileName = strFileNameAndPath.substr(i+1);
 221
 222   // if actual uri, ignore options
 223   if (IsURL(strFileNameAndPath))
 224   {
 225     i = strFileName.size() - 1;
 226     while (i > 0)
 227     {
 228       char ch = strFileName[i];
 229       if (ch == '?' || ch == '|') break;
 230       else i--;
 231     }
 232     if (i > 0)
 233       strFileName = strFileName.substr(0, i);
 234   }
 235 }
 236
 237 std::vector<std::string> URIUtils::SplitPath(const std::string& strPath)
 238 {
 239   CURL url(strPath);
 240
 241   // silly std::string can't take a char in the constructor
 242   std::string sep(1, url.GetDirectorySeparator());
 243
 244   // split the filename portion of the URL up into separate dirs
 245   std::vector<std::string> dirs = StringUtils::Split(url.GetFileName(), sep);
 246
 247   // we start with the root path
 248   std::string dir = url.GetWithoutFilename();
 249
 250   if (!dir.empty())
 251     dirs.insert(dirs.begin(), dir);
 252
 253   // we don't need empty token on the end
 254   if (dirs.size() > 1 && dirs.back().empty())
 255     dirs.erase(dirs.end() - 1);
 256
 257   return dirs;
 258 }
 259
 260 void URIUtils::GetCommonPath(std::string& strParent, const std::string& strPath)
 261 {
 262   // find the common path of parent and path
 263   unsigned int j = 1;
 264   while (j <= std::min(strParent.size(), strPath.size()) &&
 265          StringUtils::CompareNoCase(strParent, strPath, j) == 0)
 266     j++;
 267   strParent.erase(j - 1);
 268   // they should at least share a / at the end, though for things such as path/cd1 and path/cd2 there won't be
 269   if (!HasSlashAtEnd(strParent))
 270   {
 271     strParent = GetDirectory(strParent);
 272     AddSlashAtEnd(strParent);
 273   }
 274 }
 275
 276 bool URIUtils::HasParentInHostname(const CURL& url)
 277 {
 278   return url.IsProtocol("zip") || url.IsProtocol("apk") || url.IsProtocol("bluray") ||
 279          url.IsProtocol("udf") || url.IsProtocol("iso9660") || url.IsProtocol("xbt") ||
 280          (CServiceBroker::IsAddonInterfaceUp() &&
 281           CServiceBroker::GetFileExtensionProvider().EncodedHostName(url.GetProtocol()));
 282 }
 283
 284 bool URIUtils::HasEncodedHostname(const CURL& url)
 285 {
 286   return HasParentInHostname(url)
 287       || url.IsProtocol("musicsearch")
 288       || url.IsProtocol( "image");
 289 }
 290
 291 bool URIUtils::HasEncodedFilename(const CURL& url)
 292 {
 293   const std::string prot2 = url.GetTranslatedProtocol();
 294
 295   // For now assume only (quasi) http internet streams use URL encoding
 296   return CURL::IsProtocolEqual(prot2, "http")  ||
 297          CURL::IsProtocolEqual(prot2, "https");
 298 }
 299
 300 std::string URIUtils::GetParentPath(const std::string& strPath)
 301 {
 302   std::string strReturn;
 303   GetParentPath(strPath, strReturn);
 304   return strReturn;
 305 }
 306
 307 bool URIUtils::GetParentPath(const std::string& strPath, std::string& strParent)
 308 {
 309   strParent.clear();
 310
 311   CURL url(strPath);
 312   std::string strFile = url.GetFileName();
 313   if ( URIUtils::HasParentInHostname(url) && strFile.empty())
 314   {
 315     strFile = url.GetHostName();
 316     return GetParentPath(strFile, strParent);
 317   }
 318   else if (url.IsProtocol("stack"))
 319   {
 320     CStackDirectory dir;
 321     CFileItemList items;
 322     if (!dir.GetDirectory(url, items))
 323       return false;
 324     CURL url2(GetDirectory(items[0]->GetPath()));
 325     if (HasParentInHostname(url2))
 326       GetParentPath(url2.Get(), strParent);
 327     else
 328       strParent = url2.Get();
 329     for( int i=1;i<items.Size();++i)
 330     {
 331       items[i]->m_strDVDLabel = GetDirectory(items[i]->GetPath());
 332       if (HasParentInHostname(url2))
 333         items[i]->SetPath(GetParentPath(items[i]->m_strDVDLabel));
 334       else
 335         items[i]->SetPath(items[i]->m_strDVDLabel);
 336
 337       GetCommonPath(strParent,items[i]->GetPath());
 338     }
 339     return true;
 340   }
 341   else if (url.IsProtocol("multipath"))
 342   {
 343     // get the parent path of the first item
 344     return GetParentPath(CMultiPathDirectory::GetFirstPath(strPath), strParent);
 345   }
 346   else if (url.IsProtocol("plugin"))
 347   {
 348     if (!url.GetOptions().empty())
 349     {
 350       //! @todo Make a new python call to get the plugin content type and remove this temporary hack
 351       // When a plugin provides multiple types, it has "plugin://addon.id/?content_type=xxx" root URL
 352       if (url.GetFileName().empty() && url.HasOption("content_type") && url.GetOptions().find('&') == std::string::npos)
 353         url.SetHostName("");
 354       //
 355       url.SetOptions("");
 356       strParent = url.Get();
 357       return true;
 358     }
 359     if (!url.GetFileName().empty())
 360     {
 361       url.SetFileName("");
 362       strParent = url.Get();
 363       return true;
 364     }
 365     if (!url.GetHostName().empty())
 366     {
 367       url.SetHostName("");
 368       strParent = url.Get();
 369       return true;
 370     }
 371     return true;  // already at root
 372   }
 373   else if (url.IsProtocol("special"))
 374   {
 375     if (HasSlashAtEnd(strFile))
 376       strFile.erase(strFile.size() - 1);
 377     if(strFile.rfind('/') == std::string::npos)
 378       return false;
 379   }
 380   else if (strFile.empty())
 381   {
 382     if (!url.GetHostName().empty())
 383     {
 384       // we have an share with only server or workgroup name
 385       // set hostname to "" and return true to get back to root
 386       url.SetHostName("");
 387       strParent = url.Get();
 388       return true;
 389     }
 390     return false;
 391   }
 392
 393   if (HasSlashAtEnd(strFile) )
 394   {
 395     strFile.erase(strFile.size() - 1);
 396   }
 397
 398   size_t iPos = strFile.rfind('/');
 399 #ifndef TARGET_POSIX
 400   if (iPos == std::string::npos)
 401   {
 402     iPos = strFile.rfind('\\');
 403   }
 404 #endif
 405   if (iPos == std::string::npos)
 406   {
 407     url.SetFileName("");
 408     strParent = url.Get();
 409     return true;
 410   }
 411
 412   strFile.erase(iPos);
 413
 414   AddSlashAtEnd(strFile);
 415
 416   url.SetFileName(strFile);
 417   strParent = url.Get();
 418   return true;
 419 }
 420
 421 std::string URIUtils::GetBasePath(const std::string& strPath)
 422 {
 423   std::string strCheck(strPath);
 424   if (IsStack(strPath))
 425     strCheck = CStackDirectory::GetFirstStackedFile(strPath);
 426
 427   std::string strDirectory = GetDirectory(strCheck);
 428   if (IsInRAR(strCheck))
 429   {
 430     std::string strPath=strDirectory;
 431     GetParentPath(strPath, strDirectory);
 432   }
 433   if (IsStack(strPath))
 434   {
 435     strCheck = strDirectory;
 436     RemoveSlashAtEnd(strCheck);
 437     if (GetFileName(strCheck).size() == 3 && StringUtils::StartsWithNoCase(GetFileName(strCheck), "cd"))
 438       strDirectory = GetDirectory(strCheck);
 439   }
 440   return strDirectory;
 441 }
 442
 443 std::string URLEncodePath(const std::string& strPath)
 444 {
 445   std::vector<std::string> segments = StringUtils::Split(strPath, "/");
 446   for (std::vector<std::string>::iterator i = segments.begin(); i != segments.end(); ++i)
 447     *i = CURL::Encode(*i);
 448
 449   return StringUtils::Join(segments, "/");
 450 }
 451
 452 std::string URLDecodePath(const std::string& strPath)
 453 {
 454   std::vector<std::string> segments = StringUtils::Split(strPath, "/");
 455   for (std::vector<std::string>::iterator i = segments.begin(); i != segments.end(); ++i)
 456     *i = CURL::Decode(*i);
 457
 458   return StringUtils::Join(segments, "/");
 459 }
 460
 461 std::string URIUtils::ChangeBasePath(const std::string &fromPath, const std::string &fromFile, const std::string &toPath, const bool &bAddPath /* = true */)
 462 {
 463   std::string toFile = fromFile;
 464
 465   // Convert back slashes to forward slashes, if required
 466   if (IsDOSPath(fromPath) && !IsDOSPath(toPath))
 467     StringUtils::Replace(toFile, "\\", "/");
 468
 469   // Handle difference in URL encoded vs. not encoded
 470   if ( HasEncodedFilename(CURL(fromPath))
 471    && !HasEncodedFilename(CURL(toPath)) )
 472   {
 473     toFile = URLDecodePath(toFile); // Decode path
 474   }
 475   else if (!HasEncodedFilename(CURL(fromPath))
 476          && HasEncodedFilename(CURL(toPath)) )
 477   {
 478     toFile = URLEncodePath(toFile); // Encode path
 479   }
 480
 481   // Convert forward slashes to back slashes, if required
 482   if (!IsDOSPath(fromPath) && IsDOSPath(toPath))
 483     StringUtils::Replace(toFile, "/", "\\");
 484
 485   if (bAddPath)
 486     return AddFileToFolder(toPath, toFile);
 487
 488   return toFile;
 489 }
 490
 491 CURL URIUtils::SubstitutePath(const CURL& url, bool reverse /* = false */)
 492 {
 493   const std::string pathToUrl = url.Get();
 494   return CURL(SubstitutePath(pathToUrl, reverse));
 495 }
 496
 497 std::string URIUtils::SubstitutePath(const std::string& strPath, bool reverse /* = false */)
 498 {
 499   if (!m_advancedSettings)
 500   {
 501     // path substitution not needed / not working during Kodi bootstrap.
 502     return strPath;
 503   }
 504
 505   for (const auto& pathPair : m_advancedSettings->m_pathSubstitutions)
 506   {
 507     const std::string fromPath = reverse ? pathPair.second : pathPair.first;
 508     std::string toPath = reverse ? pathPair.first : pathPair.second;
 509
 510     if (strncmp(strPath.c_str(), fromPath.c_str(), HasSlashAtEnd(fromPath) ? fromPath.size() - 1 : fromPath.size()) == 0)
 511     {
 512       if (strPath.size() > fromPath.size())
 513       {
 514         std::string strSubPathAndFileName = strPath.substr(fromPath.size());
 515         return ChangeBasePath(fromPath, strSubPathAndFileName, toPath); // Fix encoding + slash direction
 516       }
 517       else
 518       {
 519         return toPath;
 520       }
 521     }
 522   }
 523   return strPath;
 524 }
 525
 526 bool URIUtils::IsProtocol(const std::string& url, const std::string &type)
 527 {
 528   return StringUtils::StartsWithNoCase(url, type + "://");
 529 }
 530
 531 bool URIUtils::PathHasParent(std::string path, std::string parent, bool translate /* = false */)
 532 {
 533   if (translate)
 534   {
 535     path = CSpecialProtocol::TranslatePath(path);
 536     parent = CSpecialProtocol::TranslatePath(parent);
 537   }
 538
 539   if (parent.empty())
 540     return false;
 541
 542   if (path == parent)
 543     return true;
 544
 545   // Make sure parent has a trailing slash
 546   AddSlashAtEnd(parent);
 547
 548   return StringUtils::StartsWith(path, parent);
 549 }
 550
 551 bool URIUtils::PathEquals(std::string path1, std::string path2, bool ignoreTrailingSlash /* = false */, bool ignoreURLOptions /* = false */)
 552 {
 553   if (ignoreURLOptions)
 554   {
 555     path1 = CURL(path1).GetWithoutOptions();
 556     path2 = CURL(path2).GetWithoutOptions();
 557   }
 558
 559   if (ignoreTrailingSlash)
 560   {
 561     RemoveSlashAtEnd(path1);
 562     RemoveSlashAtEnd(path2);
 563   }
 564
 565   return (path1 == path2);
 566 }
 567
 568 bool URIUtils::IsRemote(const std::string& strFile)
 569 {
 570   if (IsCDDA(strFile) || IsISO9660(strFile))
 571     return false;
 572
 573   if (IsStack(strFile))
 574     return IsRemote(CStackDirectory::GetFirstStackedFile(strFile));
 575
 576   if (IsSpecial(strFile))
 577     return IsRemote(CSpecialProtocol::TranslatePath(strFile));
 578
 579   if(IsMultiPath(strFile))
 580   { // virtual paths need to be checked separately
 581     std::vector<std::string> paths;
 582     if (CMultiPathDirectory::GetPaths(strFile, paths))
 583     {
 584       for (unsigned int i = 0; i < paths.size(); i++)
 585         if (IsRemote(paths[i])) return true;
 586     }
 587     return false;
 588   }
 589
 590   CURL url(strFile);
 591   if(HasParentInHostname(url))
 592     return IsRemote(url.GetHostName());
 593
 594   if (IsAddonsPath(strFile))
 595     return false;
 596
 597   if (IsSourcesPath(strFile))
 598     return false;
 599
 600   if (IsVideoDb(strFile) || IsMusicDb(strFile))
 601     return false;
 602
 603   if (IsLibraryFolder(strFile))
 604     return false;
 605
 606   if (IsPlugin(strFile))
 607     return false;
 608
 609   if (IsAndroidApp(strFile))
 610     return false;
 611
 612   if (!url.IsLocal())
 613     return true;
 614
 615   return false;
 616 }
 617
 618 bool URIUtils::IsOnDVD(const std::string& strFile)
 619 {
 620   if (IsProtocol(strFile, "dvd"))
 621     return true;
 622
 623   if (IsProtocol(strFile, "udf"))
 624     return true;
 625
 626   if (IsProtocol(strFile, "iso9660"))
 627     return true;
 628
 629   if (IsProtocol(strFile, "cdda"))
 630     return true;
 631
 632 #if defined(TARGET_WINDOWS_STORE)
 633   CLog::Log(LOGDEBUG, "{} is not implemented", __FUNCTION__);
 634 #elif defined(TARGET_WINDOWS_DESKTOP)
 635   using KODI::PLATFORM::WINDOWS::ToW;
 636   if (strFile.size() >= 2 && strFile.substr(1, 1) == ":")
 637     return (GetDriveType(ToW(strFile.substr(0, 3)).c_str()) == DRIVE_CDROM);
 638 #endif
 639   return false;
 640 }
 641
 642 bool URIUtils::IsOnLAN(const std::string& strPath)
 643 {
 644   if(IsMultiPath(strPath))
 645     return IsOnLAN(CMultiPathDirectory::GetFirstPath(strPath));
 646
 647   if(IsStack(strPath))
 648     return IsOnLAN(CStackDirectory::GetFirstStackedFile(strPath));
 649
 650   if(IsSpecial(strPath))
 651     return IsOnLAN(CSpecialProtocol::TranslatePath(strPath));
 652
 653   if(IsPlugin(strPath))
 654     return false;
 655
 656   if(IsUPnP(strPath))
 657     return true;
 658
 659   CURL url(strPath);
 660   if (HasParentInHostname(url))
 661     return IsOnLAN(url.GetHostName());
 662
 663   if(!IsRemote(strPath))
 664     return false;
 665
 666   const std::string& host = url.GetHostName();
 667
 668   return IsHostOnLAN(host);
 669 }
 670
 671 static bool addr_match(uint32_t addr, const char* target, const char* submask)
 672 {
 673   uint32_t addr2 = ntohl(inet_addr(target));
 674   uint32_t mask = ntohl(inet_addr(submask));
 675   return (addr & mask) == (addr2 & mask);
 676 }
 677
 678 bool URIUtils::IsHostOnLAN(const std::string& host, bool offLineCheck)
 679 {
 680   if(host.length() == 0)
 681     return false;
 682
 683   // assume a hostname without dot's
 684   // is local (smb netbios hostnames)
 685   if(host.find('.') == std::string::npos)
 686     return true;
 687
 688   uint32_t address = ntohl(inet_addr(host.c_str()));
 689   if(address == INADDR_NONE)
 690   {
 691     std::string ip;
 692     if(CDNSNameCache::Lookup(host, ip))
 693       address = ntohl(inet_addr(ip.c_str()));
 694   }
 695
 696   if(address != INADDR_NONE)
 697   {
 698     if (offLineCheck) // check if in private range, ref https://en.wikipedia.org/wiki/Private_network
 699     {
 700       if (
 701         addr_match(address, "192.168.0.0", "255.255.0.0") ||
 702         addr_match(address, "10.0.0.0", "255.0.0.0") ||
 703         addr_match(address, "172.16.0.0", "255.240.0.0")
 704         )
 705         return true;
 706     }
 707     // check if we are on the local subnet
 708     if (!CServiceBroker::GetNetwork().GetFirstConnectedInterface())
 709       return false;
 710
 711     if (CServiceBroker::GetNetwork().HasInterfaceForIP(address))
 712       return true;
 713   }
 714
 715   return false;
 716 }
 717
 718 bool URIUtils::IsMultiPath(const std::string& strPath)
 719 {
 720   return IsProtocol(strPath, "multipath");
 721 }
 722
 723 bool URIUtils::IsHD(const std::string& strFileName)
 724 {
 725   CURL url(strFileName);
 726
 727   if (IsStack(strFileName))
 728     return IsHD(CStackDirectory::GetFirstStackedFile(strFileName));
 729
 730   if (IsSpecial(strFileName))
 731     return IsHD(CSpecialProtocol::TranslatePath(strFileName));
 732
 733   if (HasParentInHostname(url))
 734     return IsHD(url.GetHostName());
 735
 736   return url.GetProtocol().empty() || url.IsProtocol("file") || url.IsProtocol("win-lib");
 737 }
 738
 739 bool URIUtils::IsDVD(const std::string& strFile)
 740 {
 741   std::string strFileLow = strFile;
 742   StringUtils::ToLower(strFileLow);
 743   if (strFileLow.find("video_ts.ifo") != std::string::npos && IsOnDVD(strFile))
 744     return true;
 745
 746 #if defined(TARGET_WINDOWS)
 747   if (IsProtocol(strFile, "dvd"))
 748     return true;
 749
 750   if(strFile.size() < 2 || (strFile.substr(1) != ":\\" && strFile.substr(1) != ":"))
 751     return false;
 752
 753 #ifndef TARGET_WINDOWS_STORE
 754   if(GetDriveType(KODI::PLATFORM::WINDOWS::ToW(strFile).c_str()) == DRIVE_CDROM)
 755     return true;
 756 #endif
 757 #else
 758   if (strFileLow == "iso9660://" || strFileLow == "udf://" || strFileLow == "dvd://1" )
 759     return true;
 760 #endif
 761
 762   return false;
 763 }
 764
 765 bool URIUtils::IsStack(const std::string& strFile)
 766 {
 767   return IsProtocol(strFile, "stack");
 768 }
 769
 770 bool URIUtils::IsFavourite(const std::string& strFile)
 771 {
 772   return IsProtocol(strFile, "favourites");
 773 }
 774
 775 bool URIUtils::IsRAR(const std::string& strFile)
 776 {
 777   std::string strExtension = GetExtension(strFile);
 778
 779   if (strExtension == ".001" && !StringUtils::EndsWithNoCase(strFile, ".ts.001"))
 780     return true;
 781
 782   if (StringUtils::EqualsNoCase(strExtension, ".cbr"))
 783     return true;
 784
 785   if (StringUtils::EqualsNoCase(strExtension, ".rar"))
 786     return true;
 787
 788   return false;
 789 }
 790
 791 bool URIUtils::IsInArchive(const std::string &strFile)
 792 {
 793   CURL url(strFile);
 794
 795   bool archiveProto = url.IsProtocol("archive") && !url.GetFileName().empty();
 796   return archiveProto || IsInZIP(strFile) || IsInRAR(strFile) || IsInAPK(strFile);
 797 }
 798
 799 bool URIUtils::IsInAPK(const std::string& strFile)
 800 {
 801   CURL url(strFile);
 802
 803   return url.IsProtocol("apk") && !url.GetFileName().empty();
 804 }
 805
 806 bool URIUtils::IsInZIP(const std::string& strFile)
 807 {
 808   CURL url(strFile);
 809
 810   if (url.GetFileName().empty())
 811     return false;
 812
 813   if (url.IsProtocol("archive"))
 814     return IsZIP(url.GetHostName());
 815
 816   return url.IsProtocol("zip");
 817 }
 818
 819 bool URIUtils::IsInRAR(const std::string& strFile)
 820 {
 821   CURL url(strFile);
 822
 823   if (url.GetFileName().empty())
 824     return false;
 825
 826   if (url.IsProtocol("archive"))
 827     return IsRAR(url.GetHostName());
 828
 829   return url.IsProtocol("rar");
 830 }
 831
 832 bool URIUtils::IsAPK(const std::string& strFile)
 833 {
 834   return HasExtension(strFile, ".apk");
 835 }
 836
 837 bool URIUtils::IsZIP(const std::string& strFile) // also checks for comic books!
 838 {
 839   return HasExtension(strFile, ".zip|.cbz");
 840 }
 841
 842 bool URIUtils::IsArchive(const std::string& strFile)
 843 {
 844   return HasExtension(strFile, ".zip|.rar|.apk|.cbz|.cbr");
 845 }
 846
 847 bool URIUtils::IsSpecial(const std::string& strFile)
 848 {
 849   if (IsStack(strFile))
 850     return IsSpecial(CStackDirectory::GetFirstStackedFile(strFile));
 851
 852   return IsProtocol(strFile, "special");
 853 }
 854
 855 bool URIUtils::IsPlugin(const std::string& strFile)
 856 {
 857   CURL url(strFile);
 858   return url.IsProtocol("plugin");
 859 }
 860
 861 bool URIUtils::IsScript(const std::string& strFile)
 862 {
 863   CURL url(strFile);
 864   return url.IsProtocol("script");
 865 }
 866
 867 bool URIUtils::IsAddonsPath(const std::string& strFile)
 868 {
 869   CURL url(strFile);
 870   return url.IsProtocol("addons");
 871 }
 872
 873 bool URIUtils::IsSourcesPath(const std::string& strPath)
 874 {
 875   CURL url(strPath);
 876   return url.IsProtocol("sources");
 877 }
 878
 879 bool URIUtils::IsCDDA(const std::string& strFile)
 880 {
 881   return IsProtocol(strFile, "cdda");
 882 }
 883
 884 bool URIUtils::IsISO9660(const std::string& strFile)
 885 {
 886   return IsProtocol(strFile, "iso9660");
 887 }
 888
 889 bool URIUtils::IsSmb(const std::string& strFile)
 890 {
 891   if (IsStack(strFile))
 892     return IsSmb(CStackDirectory::GetFirstStackedFile(strFile));
 893
 894   if (IsSpecial(strFile))
 895     return IsSmb(CSpecialProtocol::TranslatePath(strFile));
 896
 897   CURL url(strFile);
 898   if (HasParentInHostname(url))
 899     return IsSmb(url.GetHostName());
 900
 901   return IsProtocol(strFile, "smb");
 902 }
 903
 904 bool URIUtils::IsURL(const std::string& strFile)
 905 {
 906   return strFile.find("://") != std::string::npos;
 907 }
 908
 909 bool URIUtils::IsFTP(const std::string& strFile)
 910 {
 911   if (IsStack(strFile))
 912     return IsFTP(CStackDirectory::GetFirstStackedFile(strFile));
 913
 914   if (IsSpecial(strFile))
 915     return IsFTP(CSpecialProtocol::TranslatePath(strFile));
 916
 917   CURL url(strFile);
 918   if (HasParentInHostname(url))
 919     return IsFTP(url.GetHostName());
 920
 921   return IsProtocol(strFile, "ftp") ||
 922          IsProtocol(strFile, "ftps");
 923 }
 924
 925 bool URIUtils::IsHTTP(const std::string& strFile, bool bTranslate /* = false */)
 926 {
 927   if (IsStack(strFile))
 928     return IsHTTP(CStackDirectory::GetFirstStackedFile(strFile));
 929
 930   if (IsSpecial(strFile))
 931     return IsHTTP(CSpecialProtocol::TranslatePath(strFile));
 932
 933   CURL url(strFile);
 934   if (HasParentInHostname(url))
 935     return IsHTTP(url.GetHostName());
 936
 937   const std::string strProtocol = (bTranslate ? url.GetTranslatedProtocol() : url.GetProtocol());
 938
 939   return (strProtocol == "http" || strProtocol == "https");
 940 }
 941
 942 bool URIUtils::IsUDP(const std::string& strFile)
 943 {
 944   if (IsStack(strFile))
 945     return IsUDP(CStackDirectory::GetFirstStackedFile(strFile));
 946
 947   return IsProtocol(strFile, "udp");
 948 }
 949
 950 bool URIUtils::IsTCP(const std::string& strFile)
 951 {
 952   if (IsStack(strFile))
 953     return IsTCP(CStackDirectory::GetFirstStackedFile(strFile));
 954
 955   return IsProtocol(strFile, "tcp");
 956 }
 957
 958 bool URIUtils::IsPVR(const std::string& strFile)
 959 {
 960   if (IsStack(strFile))
 961     return IsPVR(CStackDirectory::GetFirstStackedFile(strFile));
 962
 963   return IsProtocol(strFile, "pvr");
 964 }
 965
 966 bool URIUtils::IsPVRChannel(const std::string& strFile)
 967 {
 968   if (IsStack(strFile))
 969     return IsPVRChannel(CStackDirectory::GetFirstStackedFile(strFile));
 970
 971   return IsProtocol(strFile, "pvr") && CPVRChannelsPath(strFile).IsChannel();
 972 }
 973
 974 bool URIUtils::IsPVRChannelGroup(const std::string& strFile)
 975 {
 976   if (IsStack(strFile))
 977     return IsPVRChannelGroup(CStackDirectory::GetFirstStackedFile(strFile));
 978
 979   return IsProtocol(strFile, "pvr") && CPVRChannelsPath(strFile).IsChannelGroup();
 980 }
 981
 982 bool URIUtils::IsPVRGuideItem(const std::string& strFile)
 983 {
 984   if (IsStack(strFile))
 985     return IsPVRGuideItem(CStackDirectory::GetFirstStackedFile(strFile));
 986
 987   return StringUtils::StartsWithNoCase(strFile, "pvr://guide");
 988 }
 989
 990 bool URIUtils::IsDAV(const std::string& strFile)
 991 {
 992   if (IsStack(strFile))
 993     return IsDAV(CStackDirectory::GetFirstStackedFile(strFile));
 994
 995   if (IsSpecial(strFile))
 996     return IsDAV(CSpecialProtocol::TranslatePath(strFile));
 997
 998   CURL url(strFile);
 999   if (HasParentInHostname(url))
1000     return IsDAV(url.GetHostName());
1001
1002   return IsProtocol(strFile, "dav") ||
1003          IsProtocol(strFile, "davs");
1004 }
1005
1006 bool URIUtils::IsInternetStream(const std::string &path, bool bStrictCheck /* = false */)
1007 {
1008   const CURL pathToUrl(path);
1009   return IsInternetStream(pathToUrl, bStrictCheck);
1010 }
1011
1012 bool URIUtils::IsInternetStream(const CURL& url, bool bStrictCheck /* = false */)
1013 {
1014   if (url.GetProtocol().empty())
1015     return false;
1016
1017   // there's nothing to stop internet streams from being stacked
1018   if (url.IsProtocol("stack"))
1019     return IsInternetStream(CStackDirectory::GetFirstStackedFile(url.Get()), bStrictCheck);
1020
1021   // Only consider "streamed" filesystems internet streams when being strict
1022   if (bStrictCheck && IsStreamedFilesystem(url.Get()))
1023     return true;
1024
1025   // Check for true internetstreams
1026   const std::string& protocol = url.GetProtocol();
1027   if (CURL::IsProtocolEqual(protocol, "http") || CURL::IsProtocolEqual(protocol, "https") ||
1028       CURL::IsProtocolEqual(protocol, "tcp") || CURL::IsProtocolEqual(protocol, "udp") ||
1029       CURL::IsProtocolEqual(protocol, "rtp") || CURL::IsProtocolEqual(protocol, "sdp") ||
1030       CURL::IsProtocolEqual(protocol, "mms") || CURL::IsProtocolEqual(protocol, "mmst") ||
1031       CURL::IsProtocolEqual(protocol, "mmsh") || CURL::IsProtocolEqual(protocol, "rtsp") ||
1032       CURL::IsProtocolEqual(protocol, "rtmp") || CURL::IsProtocolEqual(protocol, "rtmpt") ||
1033       CURL::IsProtocolEqual(protocol, "rtmpe") || CURL::IsProtocolEqual(protocol, "rtmpte") ||
1034       CURL::IsProtocolEqual(protocol, "rtmps") || CURL::IsProtocolEqual(protocol, "shout") ||
1035       CURL::IsProtocolEqual(protocol, "rss") || CURL::IsProtocolEqual(protocol, "rsss"))
1036     return true;
1037
1038   return false;
1039 }
1040
1041 bool URIUtils::IsStreamedFilesystem(const std::string& strPath)
1042 {
1043   CURL url(strPath);
1044
1045   if (url.GetProtocol().empty())
1046     return false;
1047
1048   if (url.IsProtocol("stack"))
1049     return IsStreamedFilesystem(CStackDirectory::GetFirstStackedFile(strPath));
1050
1051   if (IsUPnP(strPath) || IsFTP(strPath) || IsHTTP(strPath, true))
1052     return true;
1053
1054   //! @todo sftp/ssh special case has to be handled by vfs addon
1055   if (url.IsProtocol("sftp") || url.IsProtocol("ssh"))
1056     return true;
1057
1058   return false;
1059 }
1060
1061 bool URIUtils::IsNetworkFilesystem(const std::string& strPath)
1062 {
1063   CURL url(strPath);
1064
1065   if (url.GetProtocol().empty())
1066     return false;
1067
1068   if (url.IsProtocol("stack"))
1069     return IsNetworkFilesystem(CStackDirectory::GetFirstStackedFile(strPath));
1070
1071   if (IsStreamedFilesystem(strPath))
1072     return true;
1073
1074   if (IsSmb(strPath) || IsNfs(strPath))
1075     return true;
1076
1077   return false;
1078 }
1079
1080 bool URIUtils::IsUPnP(const std::string& strFile)
1081 {
1082   return IsProtocol(strFile, "upnp");
1083 }
1084
1085 bool URIUtils::IsLiveTV(const std::string& strFile)
1086 {
1087   std::string strFileWithoutSlash(strFile);
1088   RemoveSlashAtEnd(strFileWithoutSlash);
1089
1090   if (StringUtils::EndsWithNoCase(strFileWithoutSlash, ".pvr") &&
1091       !StringUtils::StartsWith(strFileWithoutSlash, "pvr://recordings"))
1092     return true;
1093
1094   return false;
1095 }
1096
1097 bool URIUtils::IsPVRRecording(const std::string& strFile)
1098 {
1099   std::string strFileWithoutSlash(strFile);
1100   RemoveSlashAtEnd(strFileWithoutSlash);
1101
1102   return StringUtils::EndsWithNoCase(strFileWithoutSlash, ".pvr") &&
1103          StringUtils::StartsWith(strFile, "pvr://recordings");
1104 }
1105
1106 bool URIUtils::IsPVRRecordingFileOrFolder(const std::string& strFile)
1107 {
1108   return StringUtils::StartsWith(strFile, "pvr://recordings");
1109 }
1110
1111 bool URIUtils::IsPVRTVRecordingFileOrFolder(const std::string& strFile)
1112 {
1113   return StringUtils::StartsWith(strFile, "pvr://recordings/tv");
1114 }
1115
1116 bool URIUtils::IsPVRRadioRecordingFileOrFolder(const std::string& strFile)
1117 {
1118   return StringUtils::StartsWith(strFile, "pvr://recordings/radio");
1119 }
1120
1121 bool URIUtils::IsMusicDb(const std::string& strFile)
1122 {
1123   return IsProtocol(strFile, "musicdb");
1124 }
1125
1126 bool URIUtils::IsNfs(const std::string& strFile)
1127 {
1128   if (IsStack(strFile))
1129     return IsNfs(CStackDirectory::GetFirstStackedFile(strFile));
1130
1131   if (IsSpecial(strFile))
1132     return IsNfs(CSpecialProtocol::TranslatePath(strFile));
1133
1134   CURL url(strFile);
1135   if (HasParentInHostname(url))
1136     return IsNfs(url.GetHostName());
1137
1138   return IsProtocol(strFile, "nfs");
1139 }
1140
1141 bool URIUtils::IsVideoDb(const std::string& strFile)
1142 {
1143   return IsProtocol(strFile, "videodb");
1144 }
1145
1146 bool URIUtils::IsBluray(const std::string& strFile)
1147 {
1148   return IsProtocol(strFile, "bluray");
1149 }
1150
1151 bool URIUtils::IsAndroidApp(const std::string &path)
1152 {
1153   return IsProtocol(path, "androidapp");
1154 }
1155
1156 bool URIUtils::IsLibraryFolder(const std::string& strFile)
1157 {
1158   CURL url(strFile);
1159   return url.IsProtocol("library");
1160 }
1161
1162 bool URIUtils::IsLibraryContent(const std::string &strFile)
1163 {
1164   return (IsProtocol(strFile, "library") ||
1165           IsProtocol(strFile, "videodb") ||
1166           IsProtocol(strFile, "musicdb") ||
1167           StringUtils::EndsWith(strFile, ".xsp"));
1168 }
1169
1170 bool URIUtils::IsDOSPath(const std::string &path)
1171 {
1172   if (path.size() > 1 && path[1] == ':' && isalpha(path[0]))
1173     return true;
1174
1175   // windows network drives
1176   if (path.size() > 1 && path[0] == '\\' && path[1] == '\\')
1177     return true;
1178
1179   return false;
1180 }
1181
1182 std::string URIUtils::AppendSlash(std::string strFolder)
1183 {
1184   AddSlashAtEnd(strFolder);
1185   return strFolder;
1186 }
1187
1188 void URIUtils::AddSlashAtEnd(std::string& strFolder)
1189 {
1190   if (IsURL(strFolder))
1191   {
1192     CURL url(strFolder);
1193     std::string file = url.GetFileName();
1194     if(!file.empty() && file != strFolder)
1195     {
1196       AddSlashAtEnd(file);
1197       url.SetFileName(file);
1198       strFolder = url.Get();
1199     }
1200     return;
1201   }
1202
1203   if (!HasSlashAtEnd(strFolder))
1204   {
1205     if (IsDOSPath(strFolder))
1206       strFolder += '\\';
1207     else
1208       strFolder += '/';
1209   }
1210 }
1211
1212 bool URIUtils::HasSlashAtEnd(const std::string& strFile, bool checkURL /* = false */)
1213 {
1214   if (strFile.empty()) return false;
1215   if (checkURL && IsURL(strFile))
1216   {
1217     CURL url(strFile);
1218     const std::string& file = url.GetFileName();
1219     return file.empty() || HasSlashAtEnd(file, false);
1220   }
1221   char kar = strFile.c_str()[strFile.size() - 1];
1222
1223   if (kar == '/' || kar == '\\')
1224     return true;
1225
1226   return false;
1227 }
1228
1229 void URIUtils::RemoveSlashAtEnd(std::string& strFolder)
1230 {
1231   // performance optimization. pvr guide items are mass objects, uri never has a slash at end, and this method is quite expensive...
1232   if (IsPVRGuideItem(strFolder))
1233     return;
1234
1235   if (IsURL(strFolder))
1236   {
1237     CURL url(strFolder);
1238     std::string file = url.GetFileName();
1239     if (!file.empty() && file != strFolder)
1240     {
1241       RemoveSlashAtEnd(file);
1242       url.SetFileName(file);
1243       strFolder = url.Get();
1244       return;
1245     }
1246     if(url.GetHostName().empty())
1247       return;
1248   }
1249
1250   while (HasSlashAtEnd(strFolder))
1251     strFolder.erase(strFolder.size()-1, 1);
1252 }
1253
1254 bool URIUtils::CompareWithoutSlashAtEnd(const std::string& strPath1, const std::string& strPath2)
1255 {
1256   std::string strc1 = strPath1, strc2 = strPath2;
1257   RemoveSlashAtEnd(strc1);
1258   RemoveSlashAtEnd(strc2);
1259   return StringUtils::EqualsNoCase(strc1, strc2);
1260 }
1261
1262
1263 std::string URIUtils::FixSlashesAndDups(const std::string& path, const char slashCharacter /* = '/' */, const size_t startFrom /*= 0*/)
1264 {
1265   const size_t len = path.length();
1266   if (startFrom >= len)
1267     return path;
1268
1269   std::string result(path, 0, startFrom);
1270   result.reserve(len);
1271
1272   const char* const str = path.c_str();
1273   size_t pos = startFrom;
1274   do
1275   {
1276     if (str[pos] == '\\' || str[pos] == '/')
1277     {
1278       result.push_back(slashCharacter);  // append one slash
1279       pos++;
1280       // skip any following slashes
1281       while (str[pos] == '\\' || str[pos] == '/') // str is null-terminated, no need to check for buffer overrun
1282         pos++;
1283     }
1284     else
1285       result.push_back(str[pos++]);   // append current char and advance pos to next char
1286
1287   } while (pos < len);
1288
1289   return result;
1290 }
1291
1292
1293 std::string URIUtils::CanonicalizePath(const std::string& path, const char slashCharacter /*= '\\'*/)
1294 {
1295   assert(slashCharacter == '\\' || slashCharacter == '/');
1296
1297   if (path.empty())
1298     return path;
1299
1300   const std::string slashStr(1, slashCharacter);
1301   std::vector<std::string> pathVec, resultVec;
1302   StringUtils::Tokenize(path, pathVec, slashStr);
1303
1304   for (std::vector<std::string>::const_iterator it = pathVec.begin(); it != pathVec.end(); ++it)
1305   {
1306     if (*it == ".")
1307     { /* skip - do nothing */ }
1308     else if (*it == ".." && !resultVec.empty() && resultVec.back() != "..")
1309       resultVec.pop_back();
1310     else
1311       resultVec.push_back(*it);
1312   }
1313
1314   std::string result;
1315   if (path[0] == slashCharacter)
1316     result.push_back(slashCharacter); // add slash at the begin
1317
1318   result += StringUtils::Join(resultVec, slashStr);
1319
1320   if (path[path.length() - 1] == slashCharacter  && !result.empty() && result[result.length() - 1] != slashCharacter)
1321     result.push_back(slashCharacter); // add slash at the end if result isn't empty and result isn't "/"
1322
1323   return result;
1324 }
1325
1326 std::string URIUtils::AddFileToFolder(const std::string& strFolder,
1327                                 const std::string& strFile)
1328 {
1329   if (IsURL(strFolder))
1330   {
1331     CURL url(strFolder);
1332     if (url.GetFileName() != strFolder)
1333     {
1334       url.SetFileName(AddFileToFolder(url.GetFileName(), strFile));
1335       return url.Get();
1336     }
1337   }
1338
1339   std::string strResult = strFolder;
1340   if (!strResult.empty())
1341     AddSlashAtEnd(strResult);
1342
1343   // Remove any slash at the start of the file
1344   if (strFile.size() && (strFile[0] == '/' || strFile[0] == '\\'))
1345     strResult += strFile.substr(1);
1346   else
1347     strResult += strFile;
1348
1349   // correct any slash directions
1350   if (!IsDOSPath(strFolder))
1351     StringUtils::Replace(strResult, '\\', '/');
1352   else
1353     StringUtils::Replace(strResult, '/', '\\');
1354
1355   return strResult;
1356 }
1357
1358 std::string URIUtils::GetDirectory(const std::string &strFilePath)
1359 {
1360   // Will from a full filename return the directory the file resides in.
1361   // Keeps the final slash at end and possible |option=foo options.
1362
1363   size_t iPosSlash = strFilePath.find_last_of("/\\");
1364   if (iPosSlash == std::string::npos)
1365     return ""; // No slash, so no path (ignore any options)
1366
1367   size_t iPosBar = strFilePath.rfind('|');
1368   if (iPosBar == std::string::npos)
1369     return strFilePath.substr(0, iPosSlash + 1); // Only path
1370
1371   return strFilePath.substr(0, iPosSlash + 1) + strFilePath.substr(iPosBar); // Path + options
1372 }
1373
1374 CURL URIUtils::CreateArchivePath(const std::string& type,
1375                                  const CURL& archiveUrl,
1376                                  const std::string& pathInArchive,
1377                                  const std::string& password)
1378 {
1379   CURL url;
1380   url.SetProtocol(type);
1381   if (!password.empty())
1382     url.SetUserName(password);
1383   url.SetHostName(archiveUrl.Get());
1384
1385   /* NOTE: on posix systems, the replacement of \ with / is incorrect.
1386      Ideally this would not be done. We need to check that the ZipManager
1387      code (and elsewhere) doesn't pass in non-posix paths.
1388    */
1389   std::string strBuffer(pathInArchive);
1390   StringUtils::Replace(strBuffer, '\\', '/');
1391   StringUtils::TrimLeft(strBuffer, "/");
1392   url.SetFileName(strBuffer);
1393
1394   return url;
1395 }
1396
1397 std::string URIUtils::GetRealPath(const std::string &path)
1398 {
1399   if (path.empty())
1400     return path;
1401
1402   CURL url(path);
1403   url.SetHostName(GetRealPath(url.GetHostName()));
1404   url.SetFileName(resolvePath(url.GetFileName()));
1405
1406   return url.Get();
1407 }
1408
1409 std::string URIUtils::resolvePath(const std::string &path)
1410 {
1411   if (path.empty())
1412     return path;
1413
1414   size_t posSlash = path.find('/');
1415   size_t posBackslash = path.find('\\');
1416   std::string delim = posSlash < posBackslash ? "/" : "\\";
1417   std::vector<std::string> parts = StringUtils::Split(path, delim);
1418   std::vector<std::string> realParts;
1419
1420   for (std::vector<std::string>::const_iterator part = parts.begin(); part != parts.end(); ++part)
1421   {
1422     if (part->empty() || part->compare(".") == 0)
1423       continue;
1424
1425     // go one level back up
1426     if (part->compare("..") == 0)
1427     {
1428       if (!realParts.empty())
1429         realParts.pop_back();
1430       continue;
1431     }
1432
1433     realParts.push_back(*part);
1434   }
1435
1436   std::string realPath;
1437   // re-add any / or \ at the beginning
1438   for (std::string::const_iterator itPath = path.begin(); itPath != path.end(); ++itPath)
1439   {
1440     if (*itPath != delim.at(0))
1441       break;
1442
1443     realPath += delim;
1444   }
1445   // put together the path
1446   realPath += StringUtils::Join(realParts, delim);
1447   // re-add any / or \ at the end
1448   if (path.at(path.size() - 1) == delim.at(0) &&
1449       realPath.size() > 0 && realPath.at(realPath.size() - 1) != delim.at(0))
1450     realPath += delim;
1451
1452   return realPath;
1453 }
1454
1455 bool URIUtils::UpdateUrlEncoding(std::string &strFilename)
1456 {
1457   if (strFilename.empty())
1458     return false;
1459
1460   CURL url(strFilename);
1461   // if this is a stack:// URL we need to work with its filename
1462   if (URIUtils::IsStack(strFilename))
1463   {
1464     std::vector<std::string> files;
1465     if (!CStackDirectory::GetPaths(strFilename, files))
1466       return false;
1467
1468     for (std::vector<std::string>::iterator file = files.begin(); file != files.end(); ++file)
1469       UpdateUrlEncoding(*file);
1470
1471     std::string stackPath;
1472     if (!CStackDirectory::ConstructStackPath(files, stackPath))
1473       return false;
1474
1475     url.Parse(stackPath);
1476   }
1477   // if the protocol has an encoded hostname we need to work with its hostname
1478   else if (URIUtils::HasEncodedHostname(url))
1479   {
1480     std::string hostname = url.GetHostName();
1481     UpdateUrlEncoding(hostname);
1482     url.SetHostName(hostname);
1483   }
1484   else
1485     return false;
1486
1487   std::string newFilename = url.Get();
1488   if (newFilename == strFilename)
1489     return false;
1490
1491   strFilename = newFilename;
1492   return true;
1493 }