src/standards/Tizen/Filesystem/FilesystemUtils.cpp

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18 #include <map>
  19 #include <string>
  20 #include <dpl/log/log.h>
  21 #include <dpl/assert.h>
  22 #include <Commons/Exception.h>
  23 #include <API/Filesystem/Enums.h>
  24 #include <API/Filesystem/IManager.h>
  25 #include <Commons/WrtAccess/WrtAccess.h>
  26 #include <WidgetDB/WidgetDBMgr.h>
  27 #include "FilesystemUtils.h"
  28
  29 using namespace TizenApis::Api::Filesystem;
  30 using namespace WrtDeviceApis;
  31 using namespace WrtDeviceApis::Commons;
  32
  33 namespace {
  34 const std::string PATH_INVALID_COMPONENT_PARENT_DIR("..");
  35 const std::string PATH_INVALID_COMPONENT_CURRENT_DIR(".");
  36
  37 typedef std::map<std::string, std::string> RootToPathMap;
  38 typedef RootToPathMap::const_iterator RootToPathMapIterator;
  39 typedef std::map<std::string, std::string> PathToRootMap;
  40 typedef PathToRootMap::const_iterator PathToRootMapIterator;
  41 }
  42
  43 namespace TizenApis {
  44 namespace Tizen1_0 {
  45 namespace Utils {
  46 const RootToPathMap& getRootToPathMap()
  47 {
  48         static RootToPathMap result;
  49         if (result.empty()) {
  50         IManager& manager = IManager::getInstance();
  51                 std::map<std::string, Api::Filesystem::IPathPtr> locations = manager.getStorageList();
  52
  53                 std::map<std::string, Api::Filesystem::IPathPtr>::const_iterator it;
  54
  55                 for (it = locations.begin(); it != locations.end(); ++it) {
  56                         result[it->first] = it->second->getFullPath();
  57                 }
  58         }
  59         return result;
  60 }
  61
  62 const PathToRootMap& getPathToRootMap()
  63 {
  64         static PathToRootMap result;
  65         if (result.empty()) {
  66                 IManager& manager = IManager::getInstance();
  67                 std::map<std::string, Api::Filesystem::IPathPtr> locations = manager.getStorageList();
  68
  69                 std::map<std::string, Api::Filesystem::IPathPtr>::const_iterator it;
  70
  71                 for (it = locations.begin(); it != locations.end(); ++it) {
  72                         result[it->second->getFullPath()] = it->first;
  73                 }
  74         }
  75         return result;
  76 }
  77
  78 IPathPtr fromVirtualPath(JSContextRef context,
  79                          const std::string& arg)
  80 {
  81         LogDebug("arg:[" << arg << "]");
  82
  83         if (!isPathValid(arg)) {
  84                 LogDebug("virtual path is invalid:[" << arg << "]");
  85                 ThrowMsg(Commons::ConversionException, "Not found path component.");
  86         }
  87
  88         std::string root;
  89         std::string tail;
  90         std::string::size_type separatorPosition = arg.find(IPath::getSeparator());
  91         if (separatorPosition != std::string::npos) {
  92                 root = arg.substr(0, separatorPosition);
  93                 tail = arg.substr(separatorPosition + 1, arg.size() - 1);
  94         } else {
  95                 root = arg;
  96         }
  97
  98 /*    int widgetId = WrtAccessSingleton::Instance().getWidgetId();
  99       WidgetDB::Api::IWidgetDBPtr widgetDB =
 100         WidgetDB::Api::getWidgetDB(widgetId);*/
 101
 102         RootToPathMap rootToPath = getRootToPathMap();
 103 /*      rootToPath["wgt-package"] = widgetDB->getWidgetInstallationPath();
 104         rootToPath["wgt-private"] = widgetDB->getWidgetPersistentStoragePath();
 105         rootToPath["wgt-private-tmp"] = widgetDB->getWidgetTemporaryStoragePath();*/
 106         RootToPathMapIterator it = rootToPath.find(root);
 107         if (it == rootToPath.end()) {
 108                 ThrowMsg(Commons::NotFoundException, "Location not found.");
 109         }
 110         IPathPtr result = IPath::create(it->second);
 111
 112         if (!tail.empty()) {
 113                 result->append(tail);
 114         }
 115
 116         return result;
 117 }
 118
 119 std::string toVirtualPath(JSContextRef context, const std::string& arg) {
 120
 121     int widgetId = WrtAccessSingleton::Instance().getWidgetId();
 122     WidgetDB::Api::IWidgetDBPtr widgetDB =
 123         WidgetDB::Api::getWidgetDB(widgetId);
 124
 125         PathToRootMap pathToRoot = getPathToRootMap();
 126         pathToRoot[widgetDB->getWidgetInstallationPath()] = "wgt-package";
 127         pathToRoot[widgetDB->getWidgetPersistentStoragePath()] = "wgt-private";
 128         pathToRoot[widgetDB->getWidgetTemporaryStoragePath()] = "wgt-private-tmp";
 129
 130         std::string path = arg;
 131         std::string::size_type pos = path.size();
 132         while (std::string::npos != (pos = path.rfind(IPath::getSeparator(), pos))) {
 133                 PathToRootMapIterator it = pathToRoot.find(path);
 134                 if (pathToRoot.end() != it) {
 135                         return it->second + arg.substr(path.size());
 136                 }
 137                 path.erase(pos, path.size());
 138         }
 139         ThrowMsg(Commons::ConversionException, "Path doesn't contain a valid location type.");
 140 }
 141
 142 bool isPathValid(const std::string& path) {
 143         static const std::string currentDirBegin(PATH_INVALID_COMPONENT_CURRENT_DIR + Api::Filesystem::IPath::getSeparator());
 144         static const std::string parentDirBegin(PATH_INVALID_COMPONENT_PARENT_DIR +
 145                 Api::Filesystem::IPath::getSeparator());
 146         static const std::string currentDirMiddle(Api::Filesystem::IPath::getSeparator() +
 147                 PATH_INVALID_COMPONENT_CURRENT_DIR +Api::Filesystem::IPath::getSeparator());
 148         static const std::string parentDirMiddle(Api::Filesystem::IPath::getSeparator() +
 149                 PATH_INVALID_COMPONENT_PARENT_DIR +Api::Filesystem::IPath::getSeparator());
 150
 151         if (path.find(parentDirBegin) == 0 ||
 152                         path.find(currentDirBegin) == 0 ||
 153                 path.find(parentDirMiddle) != std::string::npos ||
 154                 path.find(currentDirMiddle) != std::string::npos) {
 155                 return false;
 156         }
 157
 158         return true;
 159 }
 160
 161 }
 162 }
 163 }