xbmc/platform/posix/Filesystem.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 "platform/Filesystem.h"
  10 #include "filesystem/SpecialProtocol.h"
  11 #include "utils/URIUtils.h"
  12
  13 #if defined(TARGET_LINUX)
  14 #include <sys/statvfs.h>
  15 #elif defined(TARGET_DARWIN) || defined(TARGET_FREEBSD)
  16 #include <sys/param.h>
  17 #include <sys/mount.h>
  18 #elif defined(TARGET_ANDROID)
  19 #include <sys/statfs.h>
  20 #endif
  21
  22 #include <cstdint>
  23 #include <cstdlib>
  24 #include <limits.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27
  28 namespace KODI
  29 {
  30 namespace PLATFORM
  31 {
  32 namespace FILESYSTEM
  33 {
  34
  35 space_info space(const std::string& path, std::error_code& ec)
  36 {
  37   ec.clear();
  38   space_info sp;
  39 #if defined(TARGET_LINUX)
  40   struct statvfs64 fsInfo;
  41   auto result = statvfs64(CSpecialProtocol::TranslatePath(path).c_str(), &fsInfo);
  42 #else
  43   struct statfs fsInfo;
  44   // is 64-bit on android and darwin (10.6SDK + any iOS)
  45   auto result = statfs(CSpecialProtocol::TranslatePath(path).c_str(), &fsInfo);
  46 #endif
  47
  48   if (result != 0)
  49   {
  50     ec.assign(result, std::system_category());
  51     sp.available = static_cast<uintmax_t>(-1);
  52     sp.capacity = static_cast<uintmax_t>(-1);
  53     sp.free = static_cast<uintmax_t>(-1);
  54     return sp;
  55   }
  56   sp.available = static_cast<uintmax_t>(fsInfo.f_bavail * fsInfo.f_bsize);
  57   sp.capacity = static_cast<uintmax_t>(fsInfo.f_blocks * fsInfo.f_bsize);
  58   sp.free = static_cast<uintmax_t>(fsInfo.f_bfree * fsInfo.f_bsize);
  59
  60   return sp;
  61 }
  62
  63 std::string temp_directory_path(std::error_code &ec)
  64 {
  65   ec.clear();
  66
  67   auto result = getenv("TMPDIR");
  68   if (result)
  69     return URIUtils::AppendSlash(result);
  70
  71   return "/tmp/";
  72 }
  73
  74 std::string create_temp_directory(std::error_code &ec)
  75 {
  76   char buf[PATH_MAX];
  77
  78   auto path = temp_directory_path(ec);
  79
  80   strncpy(buf, (path + "xbmctempXXXXXX").c_str(), sizeof(buf) - 1);
  81   buf[sizeof(buf) - 1] = '\0';
  82
  83   auto tmp = mkdtemp(buf);
  84   if (!tmp)
  85   {
  86     ec.assign(errno, std::system_category());
  87     return std::string();
  88   }
  89
  90   ec.clear();
  91   return std::string(tmp);
  92 }
  93
  94 std::string temp_file_path(const std::string& suffix, std::error_code& ec)
  95 {
  96   char tmp[PATH_MAX];
  97
  98   auto tempPath = create_temp_directory(ec);
  99   if (ec)
 100     return std::string();
 101
 102   tempPath = URIUtils::AddFileToFolder(tempPath, "xbmctempfileXXXXXX" + suffix);
 103   if (tempPath.length() >= PATH_MAX)
 104   {
 105     ec.assign(EOVERFLOW, std::system_category());
 106     return std::string();
 107   }
 108
 109   strncpy(tmp, tempPath.c_str(), sizeof(tmp) - 1);
 110   tmp[sizeof(tmp) - 1] = '\0';
 111
 112   auto fd = mkstemps(tmp, suffix.length());
 113   if (fd < 0)
 114   {
 115     ec.assign(errno, std::system_category());
 116     return std::string();
 117   }
 118
 119   close(fd);
 120
 121   ec.clear();
 122   return std::string(tmp);
 123 }
 124
 125 }
 126 }
 127 }