xbmc/filesystem/NFSDirectory.cpp

   1 /*
   2  *  Copyright (C) 2011-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #ifdef TARGET_WINDOWS
  10 #include <mutex>
  11
  12 #include <sys\stat.h>
  13 #endif
  14
  15 #include "FileItem.h"
  16 #include "NFSDirectory.h"
  17 #include "utils/StringUtils.h"
  18 #include "utils/URIUtils.h"
  19 #include "utils/XTimeUtils.h"
  20 #include "utils/log.h"
  21
  22 #ifdef TARGET_WINDOWS
  23 #include <sys\stat.h>
  24 #endif
  25
  26 using namespace XFILE;
  27 #include <limits.h>
  28 #include <nfsc/libnfs.h>
  29 #include <nfsc/libnfs-raw-nfs.h>
  30
  31 #if defined(TARGET_WINDOWS)
  32 #define S_IFLNK 0120000
  33 #define S_ISBLK(m) (0)
  34 #define S_ISSOCK(m) (0)
  35 #define S_ISLNK(m) ((m & S_IFLNK) != 0)
  36 #define S_ISCHR(m) ((m & _S_IFCHR) != 0)
  37 #define S_ISDIR(m) ((m & _S_IFDIR) != 0)
  38 #define S_ISFIFO(m) ((m & _S_IFIFO) != 0)
  39 #define S_ISREG(m) ((m & _S_IFREG) != 0)
  40 #endif
  41
  42 CNFSDirectory::CNFSDirectory(void)
  43 {
  44   gNfsConnection.AddActiveConnection();
  45 }
  46
  47 CNFSDirectory::~CNFSDirectory(void)
  48 {
  49   gNfsConnection.AddIdleConnection();
  50 }
  51
  52 bool CNFSDirectory::GetDirectoryFromExportList(const std::string& strPath, CFileItemList &items)
  53 {
  54   CURL url(strPath);
  55   std::string nonConstStrPath(strPath);
  56   std::list<std::string> exportList=gNfsConnection.GetExportList(url);
  57
  58   for (const std::string& it : exportList)
  59   {
  60     const std::string& currentExport(it);
  61     URIUtils::RemoveSlashAtEnd(nonConstStrPath);
  62
  63     CFileItemPtr pItem(new CFileItem(currentExport));
  64     std::string path(nonConstStrPath + currentExport);
  65     URIUtils::AddSlashAtEnd(path);
  66     pItem->SetPath(path);
  67     pItem->m_dateTime = 0;
  68
  69     pItem->m_bIsFolder = true;
  70     items.Add(pItem);
  71   }
  72
  73   return exportList.empty() ? false : true;
  74 }
  75
  76 bool CNFSDirectory::GetServerList(CFileItemList &items)
  77 {
  78   struct nfs_server_list *srvrs;
  79   struct nfs_server_list *srv;
  80   bool ret = false;
  81
  82   srvrs = nfs_find_local_servers();
  83
  84   for (srv=srvrs; srv; srv = srv->next)
  85   {
  86       std::string currentExport(srv->addr);
  87
  88       CFileItemPtr pItem(new CFileItem(currentExport));
  89       std::string path("nfs://" + currentExport);
  90       URIUtils::AddSlashAtEnd(path);
  91       pItem->m_dateTime=0;
  92
  93       pItem->SetPath(path);
  94       pItem->m_bIsFolder = true;
  95       items.Add(pItem);
  96       ret = true; //added at least one entry
  97   }
  98   free_nfs_srvr_list(srvrs);
  99
 100   return ret;
 101 }
 102
 103 bool CNFSDirectory::ResolveSymlink( const std::string &dirName, struct nfsdirent *dirent, CURL &resolvedUrl)
 104 {
 105   std::unique_lock<CCriticalSection> lock(gNfsConnection);
 106   int ret = 0;
 107   bool retVal = true;
 108   std::string fullpath = dirName;
 109   char resolvedLink[MAX_PATH];
 110
 111   URIUtils::AddSlashAtEnd(fullpath);
 112   fullpath.append(dirent->name);
 113
 114   resolvedUrl.Reset();
 115   resolvedUrl.SetPort(2049);
 116   resolvedUrl.SetProtocol("nfs");
 117   resolvedUrl.SetHostName(gNfsConnection.GetConnectedIp());
 118
 119   ret = nfs_readlink(gNfsConnection.GetNfsContext(), fullpath.c_str(), resolvedLink, MAX_PATH);
 120
 121   if(ret == 0)
 122   {
 123     nfs_stat_64 tmpBuffer = {};
 124     fullpath = dirName;
 125     URIUtils::AddSlashAtEnd(fullpath);
 126     fullpath.append(resolvedLink);
 127
 128     //special case - if link target is absolute it could be even another export
 129     //intervolume symlinks baby ...
 130     if(resolvedLink[0] == '/')
 131     {
 132       //use the special stat function for using an extra context
 133       //because we are inside of a dir traversal
 134       //and just can't change the global nfs context here
 135       //without destroying something...
 136       fullpath = resolvedLink;
 137       resolvedUrl.SetFileName(fullpath);
 138       ret = gNfsConnection.stat(resolvedUrl, &tmpBuffer);
 139     }
 140     else
 141     {
 142       ret = nfs_stat64(gNfsConnection.GetNfsContext(), fullpath.c_str(), &tmpBuffer);
 143       resolvedUrl.SetFileName(gNfsConnection.GetConnectedExport() + fullpath);
 144     }
 145
 146     if (ret != 0)
 147     {
 148       CLog::Log(LOGERROR, "NFS: Failed to stat({}) on link resolve {}", fullpath,
 149                 nfs_get_error(gNfsConnection.GetNfsContext()));
 150       retVal = false;
 151     }
 152     else
 153     {
 154       dirent->inode = tmpBuffer.nfs_ino;
 155       dirent->mode = tmpBuffer.nfs_mode;
 156       dirent->size = tmpBuffer.nfs_size;
 157       dirent->atime.tv_sec = tmpBuffer.nfs_atime;
 158       dirent->mtime.tv_sec = tmpBuffer.nfs_mtime;
 159       dirent->ctime.tv_sec = tmpBuffer.nfs_ctime;
 160
 161       //map stat mode to nf3type
 162       if (S_ISBLK(tmpBuffer.nfs_mode))
 163       {
 164         dirent->type = NF3BLK;
 165       }
 166       else if (S_ISCHR(tmpBuffer.nfs_mode))
 167       {
 168         dirent->type = NF3CHR;
 169       }
 170       else if (S_ISDIR(tmpBuffer.nfs_mode))
 171       {
 172         dirent->type = NF3DIR;
 173       }
 174       else if (S_ISFIFO(tmpBuffer.nfs_mode))
 175       {
 176         dirent->type = NF3FIFO;
 177       }
 178       else if (S_ISREG(tmpBuffer.nfs_mode))
 179       {
 180         dirent->type = NF3REG;
 181       }
 182       else if (S_ISLNK(tmpBuffer.nfs_mode))
 183       {
 184         dirent->type = NF3LNK;
 185       }
 186       else if (S_ISSOCK(tmpBuffer.nfs_mode))
 187       {
 188         dirent->type = NF3SOCK;
 189       }
 190     }
 191   }
 192   else
 193   {
 194     CLog::Log(LOGERROR, "Failed to readlink({}) {}", fullpath,
 195               nfs_get_error(gNfsConnection.GetNfsContext()));
 196     retVal = false;
 197   }
 198   return retVal;
 199 }
 200
 201 bool CNFSDirectory::GetDirectory(const CURL& url, CFileItemList &items)
 202 {
 203   // We accept nfs://server/path[/file]]]]
 204   int ret = 0;
 205   KODI::TIME::FileTime fileTime, localTime;
 206   std::unique_lock<CCriticalSection> lock(gNfsConnection);
 207   std::string strDirName="";
 208   std::string myStrPath(url.Get());
 209   URIUtils::AddSlashAtEnd(myStrPath); //be sure the dir ends with a slash
 210
 211   if(!gNfsConnection.Connect(url,strDirName))
 212   {
 213     //connect has failed - so try to get the exported filesystems if no path is given to the url
 214     if(url.GetShareName().empty())
 215     {
 216       if(url.GetHostName().empty())
 217       {
 218         return GetServerList(items);
 219       }
 220       else
 221       {
 222         return GetDirectoryFromExportList(myStrPath, items);
 223       }
 224     }
 225     else
 226     {
 227       return false;
 228     }
 229   }
 230
 231   struct nfsdir *nfsdir = NULL;
 232   struct nfsdirent *nfsdirent = NULL;
 233
 234   ret = nfs_opendir(gNfsConnection.GetNfsContext(), strDirName.c_str(), &nfsdir);
 235
 236   if(ret != 0)
 237   {
 238     CLog::Log(LOGERROR, "Failed to open({}) {}", strDirName,
 239               nfs_get_error(gNfsConnection.GetNfsContext()));
 240     return false;
 241   }
 242   lock.unlock();
 243
 244   while((nfsdirent = nfs_readdir(gNfsConnection.GetNfsContext(), nfsdir)) != NULL)
 245   {
 246     struct nfsdirent tmpDirent = *nfsdirent;
 247     std::string strName = tmpDirent.name;
 248     std::string path(myStrPath + strName);
 249     int64_t iSize = 0;
 250     bool bIsDir = false;
 251     int64_t lTimeDate = 0;
 252
 253     //reslove symlinks
 254     if(tmpDirent.type == NF3LNK)
 255     {
 256       CURL linkUrl;
 257       //resolve symlink changes tmpDirent and strName
 258       if(!ResolveSymlink(strDirName,&tmpDirent,linkUrl))
 259       {
 260         continue;
 261       }
 262
 263       path = linkUrl.Get();
 264     }
 265
 266     iSize = tmpDirent.size;
 267     bIsDir = tmpDirent.type == NF3DIR;
 268     lTimeDate = tmpDirent.mtime.tv_sec;
 269
 270     if (!StringUtils::EqualsNoCase(strName,".") && !StringUtils::EqualsNoCase(strName,"..")
 271         && !StringUtils::EqualsNoCase(strName,"lost+found"))
 272     {
 273       if(lTimeDate == 0) // if modification date is missing, use create date
 274       {
 275         lTimeDate = tmpDirent.ctime.tv_sec;
 276       }
 277
 278       long long ll = lTimeDate & 0xffffffff;
 279       ll *= 10000000ll;
 280       ll += 116444736000000000ll;
 281       fileTime.lowDateTime = (DWORD)(ll & 0xffffffff);
 282       fileTime.highDateTime = (DWORD)(ll >> 32);
 283       KODI::TIME::FileTimeToLocalFileTime(&fileTime, &localTime);
 284
 285       CFileItemPtr pItem(new CFileItem(tmpDirent.name));
 286       pItem->m_dateTime=localTime;
 287       pItem->m_dwSize = iSize;
 288
 289       if (bIsDir)
 290       {
 291         URIUtils::AddSlashAtEnd(path);
 292         pItem->m_bIsFolder = true;
 293       }
 294       else
 295       {
 296         pItem->m_bIsFolder = false;
 297       }
 298
 299       if (strName[0] == '.')
 300       {
 301         pItem->SetProperty("file:hidden", true);
 302       }
 303       pItem->SetPath(path);
 304       items.Add(pItem);
 305     }
 306   }
 307
 308   lock.lock();
 309   nfs_closedir(gNfsConnection.GetNfsContext(), nfsdir);//close the dir
 310   lock.unlock();
 311   return true;
 312 }
 313
 314 bool CNFSDirectory::Create(const CURL& url2)
 315 {
 316   int ret = 0;
 317   bool success=true;
 318
 319   std::unique_lock<CCriticalSection> lock(gNfsConnection);
 320   std::string folderName(url2.Get());
 321   URIUtils::RemoveSlashAtEnd(folderName);//mkdir fails if a slash is at the end!!!
 322   CURL url(folderName);
 323   folderName = "";
 324
 325   if(!gNfsConnection.Connect(url,folderName))
 326     return false;
 327
 328   ret = nfs_mkdir(gNfsConnection.GetNfsContext(), folderName.c_str());
 329
 330   success = (ret == 0 || -EEXIST == ret);
 331   if(!success)
 332     CLog::Log(LOGERROR, "NFS: Failed to create({}) {}", folderName,
 333               nfs_get_error(gNfsConnection.GetNfsContext()));
 334   return success;
 335 }
 336
 337 bool CNFSDirectory::Remove(const CURL& url2)
 338 {
 339   int ret = 0;
 340
 341   std::unique_lock<CCriticalSection> lock(gNfsConnection);
 342   std::string folderName(url2.Get());
 343   URIUtils::RemoveSlashAtEnd(folderName);//rmdir fails if a slash is at the end!!!
 344   CURL url(folderName);
 345   folderName = "";
 346
 347   if(!gNfsConnection.Connect(url,folderName))
 348     return false;
 349
 350   ret = nfs_rmdir(gNfsConnection.GetNfsContext(), folderName.c_str());
 351
 352   if(ret != 0 && errno != ENOENT)
 353   {
 354     CLog::Log(LOGERROR, "{} - Error( {} )", __FUNCTION__,
 355               nfs_get_error(gNfsConnection.GetNfsContext()));
 356     return false;
 357   }
 358   return true;
 359 }
 360
 361 bool CNFSDirectory::Exists(const CURL& url2)
 362 {
 363   int ret = 0;
 364
 365   std::unique_lock<CCriticalSection> lock(gNfsConnection);
 366   std::string folderName(url2.Get());
 367   URIUtils::RemoveSlashAtEnd(folderName);//remove slash at end or URIUtils::GetFileName won't return what we want...
 368   CURL url(folderName);
 369   folderName = "";
 370
 371   if(!gNfsConnection.Connect(url,folderName))
 372     return false;
 373
 374   nfs_stat_64 info;
 375   ret = nfs_stat64(gNfsConnection.GetNfsContext(), folderName.c_str(), &info);
 376
 377   if (ret != 0)
 378   {
 379     return false;
 380   }
 381   return S_ISDIR(info.nfs_mode) ? true : false;
 382 }