src/Filesystem/Manager.cpp

   1 //
   2 // Tizen Web Device API
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 // http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18
  19 #include "Manager.h"
  20
  21 #include <unistd.h>
  22 #include <sys/stat.h>
  23 #include <errno.h>
  24 #include <pcrecpp.h>
  25 #include <ctime>
  26 #include <sstream>
  27 #include <dirent.h>
  28 #include <dpl/scoped_ptr.h>
  29
  30 #include <Commons/Exception.h>
  31 #include <Commons/Regex.h>
  32 #include "PathUtils.h"
  33 #include "StorageProperties.h"
  34 #include "Node.h"
  35 #include "Utils.h"
  36 #include <app.h>
  37 #include <Logger.h>
  38
  39 namespace {
  40 const char* PATH_DOWNLOADS = "/opt/usr/media/Downloads";
  41 const char* PATH_DOCUMENTS = "/opt/usr/media/Documents";
  42 const char* PATH_SOUNDS = "/opt/usr/media/Sounds";
  43 const char* PATH_IMAGES = "/opt/usr/media/Images";
  44 const char* PATH_VIDEOS = "/opt/usr/media/Videos";
  45 const char* PATH_RINGTONE = "/opt/share/settings/Ringtones/";
  46 }
  47
  48 using namespace WrtDeviceApis;
  49 using namespace WrtDeviceApis::Commons;
  50
  51 namespace DeviceAPI {
  52 namespace Filesystem {
  53 Manager::Locations Manager::m_locations;
  54 Manager::RootList Manager::m_rootlist;
  55 Manager::SubRootList Manager::m_subrootlist;
  56 const std::size_t Manager::m_maxPathLength = 256;
  57 NodeList Manager::m_openedNodes;
  58 std::vector<Manager::WatcherPtr> Manager::m_watchers;
  59
  60 bool Manager::fileExists(const std::string &file)
  61 {
  62     errno = 0;
  63     struct stat info;
  64     memset(&info, 0, sizeof(struct stat));
  65     int status = lstat(file.c_str(), &info);
  66     if (status == 0) {
  67         return true;
  68     } else if (errno == ENOENT) {
  69         return false;
  70     }
  71     ThrowMsg(Commons::PlatformException, "Cannot stat file.");
  72 }
  73
  74 bool Manager::getSupportedDeviceCB(int storage, storage_type_e type, storage_state_e state, const char *path, void *user_data)
  75 {
  76         std::vector<StoragePropertiesPtr>* storageVector = (std::vector<StoragePropertiesPtr>*)user_data;
  77         StoragePropertiesPtr storageItem(new StorageProperties());
  78
  79         int size = 12;
  80         char buf[size];
  81         std::string lable;
  82         std::string fullpath(path);
  83         if (type == STORAGE_TYPE_INTERNAL) {
  84                 snprintf(buf, size, "internal%d", storage);
  85                 lable.append(buf);
  86         } else if (type == STORAGE_TYPE_EXTERNAL) {
  87                 snprintf(buf, size, "removable%d", storage);
  88                 lable.append(buf);
  89         }
  90         LoggerD(lable << "state" << state);
  91
  92         storageItem->setId(storage);
  93         storageItem->setLabel(lable);
  94         storageItem->setType((short)type);
  95         storageItem->setState((short)state);
  96         storageItem->setFullPath(fullpath);
  97
  98         storageVector->insert(storageVector->end(), storageItem);
  99
 100         return true;
 101 }
 102
 103 void Manager::storageStateChangedCB(int storage, storage_state_e state, void *user_data)
 104 {
 105         if (user_data != NULL) {
 106                 watcherList* m_watcherList = (watcherList *)user_data;
 107                 watcherList::iterator it = m_watcherList->begin();
 108                 for(; it!= m_watcherList->end(); ++it) {
 109                         (*it)->StorageStateHasChanged(storage, state);
 110                 }
 111         }
 112 }
 113
 114 void Manager::addOpenedNode(const INodePtr& node)
 115 {
 116     NodeListIterator it = m_openedNodes.begin();
 117     for (; it != m_openedNodes.end(); ++it) {
 118         if (node.Get() == (*it).Get()) {
 119             //node is added already
 120             return;
 121         }
 122     }
 123     m_openedNodes.push_back(node);
 124 }
 125
 126 void Manager::removeOpenedNode(const INodePtr& node)
 127 {
 128     NodeListIterator it = m_openedNodes.begin();
 129     for (; it != m_openedNodes.end(); ++it) {
 130         if ((*it).Get() == node.Get()) {
 131             m_openedNodes.erase(it);
 132             break;
 133         }
 134     }
 135 }
 136
 137 bool Manager::checkIfOpened(const IPathPtr& path) const
 138 {
 139     NodeListIterator it = m_openedNodes.begin();
 140     for (; it != m_openedNodes.end(); ++it) {
 141         if (*path == *(*it)->getPath()) {
 142             return true;
 143         }
 144     }
 145     return false;
 146 }
 147
 148 Manager::Manager()
 149 {
 150     static bool initialized = init();
 151     (void) initialized;
 152 }
 153
 154 Manager::~Manager()
 155 {
 156 }
 157
 158 StorageList Manager::getStorageList() const
 159 {
 160     return m_locations;
 161 }
 162
 163 IPathPtr Manager::getBasePath() const
 164 {
 165     Locations::const_iterator it = m_locations.find(m_subrootlist.find(LT_ROOT)->second);
 166     if (it == m_locations.end()) {
 167         ThrowMsg(Commons::PlatformException, "Base path not available.");
 168     }
 169     return it->second;
 170 }
 171
 172 IPathPtr Manager::getLocationPath(LocationType type) const
 173 {
 174     Locations::const_iterator it = m_locations.find(m_subrootlist.find(type)->second);
 175     if (it != m_locations.end()) {
 176         return it->second->clone();
 177     }
 178     return IPathPtr();
 179 }
 180
 181 LocationPaths Manager::getLocationPaths() const
 182 {
 183     LocationPaths result;
 184     Locations::const_iterator it = m_locations.begin();
 185     for (; it != m_locations.end(); ++it) {
 186         result.push_back(it->second->clone());
 187     }
 188     return result;
 189 }
 190
 191 LocationTypes Manager::getLocations() const
 192 {
 193     LocationTypes result;
 194     SubRootList::const_iterator it = m_subrootlist.begin();
 195     for (; it != m_subrootlist.end(); ++it) {
 196         result.push_back(it->first);
 197     }
 198     return result;
 199 }
 200
 201 void Manager::getNode(const EventResolvePtr& event)
 202 {
 203     EventRequestReceiver<EventResolve>::PostRequest(event);
 204 }
 205
 206 void Manager::getStorage(const EventGetStoragePtr& event)
 207 {
 208         EventRequestReceiver<EventGetStorage>::PostRequest(event);
 209 }
 210
 211 void Manager::listStorages(const EventListStoragesPtr& event)
 212 {
 213         EventRequestReceiver<EventListStorages>::PostRequest(event);
 214 }
 215
 216 std::size_t Manager::getMaxPathLength() const
 217 {
 218     return m_maxPathLength;
 219 }
 220
 221 void Manager::copy(const EventCopyPtr& event)
 222 {
 223     EventRequestReceiver<EventCopy>::PostRequest(event);
 224 }
 225
 226 void Manager::move(const EventMovePtr& event)
 227 {
 228     EventRequestReceiver<EventMove>::PostRequest(event);
 229 }
 230
 231 void Manager::create(const EventCreatePtr& event)
 232 {
 233     EventRequestReceiver<EventCreate>::PostRequest(event);
 234 }
 235
 236 void Manager::remove(const EventRemovePtr& event)
 237 {
 238     EventRequestReceiver<EventRemove>::PostRequest(event);
 239 }
 240
 241 void Manager::find(const EventFindPtr& event)
 242 {
 243     EventRequestReceiver<EventFind>::PostRequest(event);
 244 }
 245
 246 void Manager::find(const IPathPtr& path,
 247         const FiltersMap& filters,
 248         NodeList& result,
 249         const EventFindPtr& event)
 250 {
 251     Try {
 252         DIR* dir = opendir(path->getFullPath().c_str());
 253         if (!dir) {
 254             return;
 255         }
 256
 257         errno = 0;
 258         struct dirent* entry = NULL;
 259         while ((entry = readdir(dir))) {
 260             if (event && event->checkCancelled()) {
 261                 break;
 262             }
 263             if (!strcmp(entry->d_name, ".") || !strncmp(entry->d_name, "..", 2)) {
 264                 continue;
 265             }
 266             IPathPtr childPath = *path + entry->d_name;
 267             struct stat info;
 268             memset(&info, 0, sizeof(struct stat));
 269             if (lstat(childPath->getFullPath().c_str(), &info) == 0) {
 270                 if (matchFilters(entry->d_name, info, filters)) {
 271                     result.push_back(Node::resolve(childPath));
 272                 }
 273                 if (S_ISDIR(info.st_mode)) {
 274                     find(childPath, filters, result, event);
 275                 }
 276             }
 277         }
 278
 279         if (errno != 0) {
 280             ThrowMsg(Commons::PlatformException,
 281                      "Error while reading directory.");
 282         }
 283
 284         if (closedir(dir) != 0) {
 285             ThrowMsg(Commons::PlatformException,
 286                      "Could not close platform node.");
 287         }
 288     }
 289     Catch(WrtDeviceApis::Commons::Exception) {
 290     }
 291 }
 292
 293 void Manager::copyElement(
 294         const std::string &src, const std::string &dest, bool recursive) const
 295 {
 296     LoggerD("Copying src: " << src << " to: " << dest);
 297
 298     //element is a file:
 299     if (EINA_TRUE != ecore_file_is_dir(src.c_str())) {
 300         if (EINA_TRUE != ecore_file_cp(src.c_str(), dest.c_str())) {
 301             ThrowMsg(Commons::PlatformException, "Failed to copy file");
 302         }
 303         return;
 304     }
 305     //element is a directory -> create it:
 306     if (EINA_TRUE != ecore_file_is_dir(dest.c_str())) {
 307         if (EINA_TRUE != ecore_file_mkdir(dest.c_str())) {
 308             LoggerD("Failed to create destination directory");
 309             ThrowMsg(Commons::PlatformException, "Failed to copy directory");
 310         }
 311     }
 312     //copy all elements of directory:
 313     if (recursive) {
 314         Eina_List* list = ecore_file_ls(src.c_str());
 315         void* data;
 316         EINA_LIST_FREE(list, data)
 317         {
 318             Try
 319             {
 320                 copyElement((src + '/' + static_cast<char*>(data)).c_str(),
 321                             (dest + '/' + static_cast<char*>(data)).c_str());
 322             }
 323
 324             Catch (Commons::Exception)
 325             {
 326                  //remove rest of the list
 327                 EINA_LIST_FREE(list, data)
 328                 {
 329                     free(data);
 330                 }
 331                 LoggerE("Exception: " << _rethrown_exception.GetMessage());
 332                 ReThrowMsg(Commons::PlatformException, "Failed to copy element");
 333             }
 334             free(data);
 335         }
 336     }
 337
 338 }
 339
 340 /*bool Manager::access(const IPathPtr& path,
 341         int accessType) const
 342 {
 343     int amode = 0;
 344     if (accessType & AT_EXISTS) { amode |= F_OK; }
 345     if (accessType & AT_READ) { amode |= R_OK; }
 346     if (accessType & AT_WRITE) { amode |= W_OK; }
 347     if (accessType & AT_EXEC) { amode |= X_OK; }
 348     return (::access(path->getFullPath().c_str(), amode) == 0);
 349 }*/
 350
 351 long Manager::addStorageStateChangeListener(
 352         const EventStorageStateChangedEmitterPtr& emitter)
 353 {
 354         RootList::const_iterator it = m_rootlist.begin();
 355         WatcherPtr watcher(new Watcher(emitter));
 356         Manager::m_watchers.push_back(watcher);
 357
 358         for (; it != m_rootlist.end(); ++it) {
 359                 storage_set_state_changed_cb(it->second, Manager::storageStateChangedCB, (void *)(&m_watchers));
 360         }
 361
 362         watcher->getCurrentStoargeStateForWatch();
 363         return static_cast<long>(emitter->getId());
 364 }
 365
 366 void Manager::removeStorageStateChangeListener(EventStorageStateChangedEmitter::IdType id)
 367 {
 368         watcherList::iterator itWatcher = Manager::m_watchers.begin();
 369         bool found = false;
 370         for (;itWatcher != Manager::m_watchers.end();) {
 371                 if (id == (*itWatcher)->getEmitter()->getId()) {
 372                         itWatcher = Manager::m_watchers.erase(itWatcher);
 373                         found = true;
 374                         continue;
 375                 }
 376                 ++itWatcher;
 377         }
 378
 379         if (Manager::m_watchers.size() == 0) {
 380                 RootList::const_iterator itRoot;
 381                 for (itRoot = m_rootlist.begin(); itRoot != m_rootlist.end(); ++itRoot) {
 382                         storage_unset_state_changed_cb(itRoot->second);
 383                 }
 384         }
 385
 386         if (found == false) {
 387 //              LoggerD("no exist" << id);
 388                 ThrowMsg(Commons::NotFoundException, "The " << id << "is not exist");
 389         }
 390 }
 391
 392 bool Manager::matchFilters(const std::string& name,
 393         const struct stat& info,
 394         const FiltersMap& filters)
 395 {
 396     FiltersMap::const_iterator it = filters.begin();
 397     for (; it != filters.end(); ++it) {
 398         if (it->first == FF_NAME) {
 399             if (!pcrecpp::RE(it->second).PartialMatch(name)) { return false; }
 400         } else if (it->first == FF_SIZE) {
 401             std::size_t size;
 402             std::stringstream ss(it->second);
 403             ss >> size;
 404             if (!ss ||
 405                 (size != static_cast<size_t>(info.st_size))) { return false; }
 406         } else if (it->first == FF_CREATED) {
 407             std::time_t created;
 408             std::stringstream ss(it->second);
 409             ss >> created;
 410             if (!ss || (created != info.st_ctime)) { return false; }
 411         } else if (it->first == FF_MODIFIED) {
 412             std::time_t modified;
 413             std::stringstream ss(it->second);
 414             ss >> modified;
 415             if (!ss || (modified != info.st_mtime)) { return false; }
 416         }
 417     }
 418     return true;
 419 }
 420
 421 void Manager::OnRequestReceived(const EventResolvePtr& event)
 422 {
 423     try {
 424         event->setResult(Node::resolve(event->getPath()));
 425     }
 426     catch (const Commons::Exception& ex)
 427     {
 428         LoggerE("Exception: " << ex.GetMessage());
 429         event->setExceptionCode(ex.getCode());
 430     }
 431 }
 432
 433 void Manager::OnRequestReceived(const EventGetStoragePtr& event)
 434 {
 435         try {
 436
 437                 StoragePropertiesPtr storage(new StorageProperties());
 438
 439                 RootList::const_iterator it = m_rootlist.find(event->getLabel());
 440                 if (it == m_rootlist.end()) {
 441                         Locations::const_iterator itL = m_locations.find(event->getLabel());
 442                         if (itL == m_locations.end()) {
 443                                 ThrowMsg(Commons::NotFoundException, "Base path not available.");
 444                         } else {
 445                                 storage->setId(0xff);
 446                                 storage->setLabel(event->getLabel());
 447                                 storage->setType(StorageProperties::TYPE_INTERNAL);
 448                                 storage->setState(StorageProperties::STATE_MOUNTED);
 449                         }
 450                 } else {
 451                         int id = it->second;
 452
 453                         storage_type_e currentType;
 454                         storage_state_e currentState;
 455
 456                         storage_get_type(id, &currentType);
 457                         storage_get_state(id, &currentState);
 458
 459                         storage->setId(id);
 460                         storage->setLabel(event->getLabel());
 461                         storage->setType((short)currentType);
 462                         storage->setState((short)currentState);
 463                 }
 464
 465                 event->setResult(storage);
 466     } catch (const Commons::Exception& ex)
 467     {
 468         event->setExceptionCode(ex.getCode());
 469     }
 470 }
 471
 472 void Manager::OnRequestReceived(const EventListStoragesPtr& event)
 473 {
 474         try {
 475                 std::vector<StoragePropertiesPtr> storageList;
 476
 477                 storage_foreach_device_supported(Manager::getSupportedDeviceCB, &storageList);
 478
 479                 SubRootList::const_iterator it = m_subrootlist.begin();
 480                 for (; it != m_subrootlist.end(); ++it) {
 481                         if (it->first == LT_ROOT)
 482                                 continue;
 483                         if (it->first == LT_SDCARD)
 484                                 continue;
 485                         if (it->first == LT_USBHOST)
 486                                 continue;
 487
 488                         addLocalStorage(it->second, storageList);
 489                 }
 490
 491
 492                 event->setResult(storageList);
 493     }   catch (const Commons::Exception& ex)
 494     {
 495         event->setExceptionCode(ex.getCode());
 496     }
 497 }
 498
 499 void Manager::OnRequestReceived(const EventCopyPtr& event)
 500 {
 501     Try {
 502         INodePtr srcNode = Node::resolve(event->getSource());
 503                 LoggerD(std::hex << srcNode->getMode() << " " << std::hex << PM_USER_READ);
 504         if ((srcNode->getMode() & PM_USER_READ/*PERM_READ*/) == 0) {
 505             ThrowMsg(Commons::SecurityException,
 506                      "Not enough permissions to read source node.");
 507         }
 508
 509         IPathPtr src = event->getSource();
 510         IPathPtr dest = event->getDestination();
 511         if (!dest->isAbsolute()) {
 512             dest = src->getPath() + *dest;
 513         }
 514
 515         INodePtr parent;
 516         Try {
 517             parent = Node::resolve(IPath::create(dest->getPath()));
 518         }
 519         Catch(Commons::NotFoundException)
 520         {
 521             event->setExceptionCode(_rethrown_exception.getCode());
 522             ReThrowMsg(Commons::NotFoundException, "could not find a destination path.");
 523         }
 524         Catch (Commons::Exception)
 525         {
 526             event->setExceptionCode(_rethrown_exception.getCode());
 527             ReThrowMsg(Commons::PlatformException,
 528                        "Could not get destination's parent node.");
 529         }
 530
 531         if (parent->getType() != NT_DIRECTORY) {
 532             ThrowMsg(Commons::PlatformException,
 533                      "Destination's parent node is not directory.");
 534         }
 535
 536                 std::string realSrc = src->getFullPath();
 537                 std::string realDest = dest->getFullPath();
 538
 539                 if (realSrc == realDest) {
 540                         ThrowMsg(Commons::PlatformException,
 541                         "Destination is same as source.");
 542                 }
 543
 544
 545         errno = 0;
 546         struct stat info;
 547         memset(&info, 0, sizeof(struct stat));
 548         int status = lstat(realDest.c_str(), &info);
 549         if ((status != 0) && (errno != ENOENT)) {
 550             ThrowMsg(Commons::PlatformException,
 551                      "No access to platform destination node.");
 552         }
 553
 554         if (S_ISDIR(info.st_mode) && srcNode->getType() == NT_FILE) {
 555             dest->append("/" + src->getName());
 556             realDest = dest->getFullPath();
 557             memset(&info, 0, sizeof(struct stat));
 558             status = lstat(realDest.c_str(), &info);
 559             if ((status != 0) && (errno != ENOENT)) {
 560                 ThrowMsg(Commons::PlatformException,
 561                              "No access to platform destination node.");
 562             }
 563         }
 564
 565         if (0 == status) {
 566             //no owerwrite flag setted -> exception
 567             if ((event->getOptions() & OPT_OVERWRITE) == 0) {
 568                 ThrowMsg(Commons::PlatformException, "Overwrite is not set.");
 569             }
 570
 571             if (event->checkCancelled()) {
 572                 //file is not copied yet, so we can cancel it now.
 573                 event->setCancelAllowed(true);
 574                 return;
 575             }
 576
 577             //destination exist. Need to be removed
 578             Try {
 579                 INodePtr node = Node::resolve(dest);
 580
 581                 // only remove if dest is file.
 582                 if (node->getType() == NT_FILE) {
 583                     node->remove(event->getOptions());
 584                 }
 585                 else {
 586                         // destination exist and src & dest are directory and dest path ends with '/'
 587                     if (srcNode->getType() == NT_DIRECTORY && realDest[realDest.length() - 1] == '/') {
 588                         realDest += src->getName();
 589                     }
 590                 }
 591             }
 592             catch (const Commons::Exception& ex)
 593             {
 594                 LoggerE("Exception: " << ex.GetMessage());
 595                 event->setExceptionCode(ex.getCode());
 596              }
 597         }
 598         //Destination is not exist. Start copy now.
 599                 LoggerD(dest->getFullPath().c_str());
 600         copyElement(realSrc, realDest);
 601
 602         event->setResult(Node::resolve(dest));
 603     }
 604     catch (const Commons::Exception& ex)
 605     {
 606         LoggerE("Exception: " << ex.GetMessage());
 607         event->setExceptionCode(ex.getCode());
 608     }
 609     //file is copied already so we don't allow cancelling anymore.
 610     event->setCancelAllowed(false);
 611 }
 612
 613 void Manager::OnRequestReceived(const EventMovePtr& event)
 614 {
 615     try {
 616         IPathPtr src = event->getSource();
 617         IPathPtr dest = event->getDestination();
 618
 619         INodePtr srcNode = Node::resolve(src);
 620                 LoggerD(std::hex << srcNode->getMode() << " " << std::hex << PM_USER_WRITE);
 621         if ((srcNode->getMode() & PM_USER_WRITE/*PERM_WRITE*/) == 0)
 622         {
 623             ThrowMsg(Commons::SecurityException,
 624                      "Not enough permissions to move source node.");
 625         }
 626
 627         if (!dest->isAbsolute()) {
 628             dest = src->getPath() + *dest;
 629         }
 630
 631         if (src == dest) {
 632             ThrowMsg(Commons::PlatformException,
 633                      "Destination is same as source.");
 634         }
 635
 636         INodePtr parent;
 637         Try {
 638             parent = Node::resolve(IPath::create(dest->getPath()));
 639         }
 640
 641         Catch(Commons::NotFoundException)
 642         {
 643             event->setExceptionCode(_rethrown_exception.getCode());
 644             ReThrowMsg(Commons::NotFoundException, "could not find a destination path.");
 645         }
 646         Catch(Commons::Exception)
 647         {
 648             LoggerE("Exception: " << _rethrown_exception.GetMessage());
 649             ReThrowMsg(Commons::PlatformException,
 650                        "Could not get destination's parent node.");
 651         }
 652
 653         if (parent->getType() != NT_DIRECTORY) {
 654             ThrowMsg(Commons::PlatformException,
 655                      "Destination's parent node is not directory.");
 656         }
 657
 658         errno = 0;
 659         struct stat info;
 660         memset(&info, 0, sizeof(info));
 661         int status = lstat(dest->getFullPath().c_str(), &info);
 662         if ((status != 0) && (errno != ENOENT)) {
 663             ThrowMsg(Commons::PlatformException,
 664                      "No access to platform destination node.");
 665         }
 666
 667         LoggerD(dest->getFullPath().c_str());
 668
 669         if (S_ISDIR(info.st_mode) && srcNode->getType() == NT_FILE) {
 670                         dest->append("/" + src->getName());
 671                         memset(&info, 0, sizeof(info));
 672                         status = lstat(dest->getFullPath().c_str(), &info);
 673                         if ((status != 0) && (errno != ENOENT)) {
 674                     ThrowMsg(Commons::PlatformException,
 675                             "No access to platform destination node.");
 676                         }
 677         }
 678
 679                 if (status == 0 && 0 == (event->getOptions() & OPT_OVERWRITE)) {
 680             ThrowMsg(Commons::PlatformException, "Overwrite is not set.");
 681         }
 682
 683         if (event->checkCancelled()) {
 684             //file is not moved yet, so we can cancel it now.
 685             event->setCancelAllowed(true);
 686             return;
 687         }
 688
 689         errno = 0;
 690
 691         LoggerD(dest->getFullPath().c_str());
 692
 693         if (0 != ::rename(src->getFullPath().c_str(), dest->getFullPath().c_str()))
 694         {
 695             int error = errno;
 696             switch (error)
 697             {
 698             case EXDEV:
 699                 {
 700                                         LoggerD(std::hex << srcNode->getMode() << " " << std::hex << PM_USER_READ);
 701                     if ((srcNode->getMode() & PM_USER_READ /*PERM_READ*/) == 0)
 702                     {
 703                         ThrowMsg(Commons::SecurityException,
 704                                  "Not enough permissions to move source node.");
 705                     }
 706                     if (0 == status) {
 707                         //destination exist. Need to be removed
 708                         Try {
 709                             INodePtr node = Node::resolve(dest);
 710                             node->remove(event->getOptions());
 711                         }
 712                         catch (const Commons::Exception& ex)
 713                         {
 714                             LoggerE("Exception: " << ex.GetMessage());
 715                             event->setExceptionCode(ex.getCode());
 716                             LoggerE("Exception while removing dest directory");
 717                         }
 718                     }
 719
 720                     copyElement(src->getFullPath(),
 721                                 dest->getFullPath());
 722                     //remove source files
 723                     Try {
 724                         INodePtr node = Node::resolve(event->getSource());
 725                         node->remove(event->getOptions());
 726                     }
 727                     Catch(Commons::Exception) {
 728                         LoggerE("Exception: "
 729                                  << _rethrown_exception.GetMessage());
 730                     }
 731                     break;
 732                 }
 733             default:
 734                                 // needtofix
 735                 ThrowMsg(Commons::PlatformException,
 736                          "Error on rename: " /*<< DPL::GetErrnoString(error)*/);
 737                 break;
 738             }
 739         }
 740
 741         event->setResult(Node::resolve(dest));
 742     }
 743     catch (const Commons::Exception& ex)
 744     {
 745         LoggerE("Exception: " << ex.GetMessage());
 746         event->setExceptionCode(ex.getCode());
 747     }
 748
 749     event->setCancelAllowed(false);
 750 }
 751
 752 void Manager::OnRequestReceived(const EventCreatePtr& event)
 753 {
 754     Try {
 755     }
 756     catch (const Commons::Exception& ex)
 757     {
 758         LoggerE("Exception: " << ex.GetMessage());
 759         event->setExceptionCode(ex.getCode());
 760     }
 761 }
 762
 763 void Manager::OnRequestReceived(const EventRemovePtr& event)
 764 {
 765     if (!event->checkCancelled()) {
 766         Try {
 767             INodePtr node = Node::resolve(event->getPath());
 768             node->remove(event->getOptions());
 769         }
 770         catch (const Commons::Exception& ex)
 771         {
 772             LoggerE("Exception: " << ex.GetMessage());
 773             event->setExceptionCode(ex.getCode());
 774         }
 775         event->setCancelAllowed(false);
 776     } else {
 777         event->setCancelAllowed(true);
 778     }
 779 }
 780
 781 void Manager::OnRequestReceived(const EventFindPtr& event)
 782 {
 783     try {
 784         NodeList result;
 785         find(event->getPath(), event->getFilters(), result, event);
 786         event->setResult(result);
 787     }
 788     catch (const Commons::Exception& ex) {
 789         LoggerE("Exception: " << ex.GetMessage());
 790         event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
 791     }
 792     event->setCancelAllowed(true);
 793 }
 794
 795 void Manager::addLocalStorage(std::string label, std::vector<StoragePropertiesPtr> &storageList)
 796 {
 797         StoragePropertiesPtr storage(new StorageProperties());
 798         storage->setId(0xff);
 799         storage->setLabel(label);
 800         storage->setType(StorageProperties::TYPE_INTERNAL);
 801
 802         storage_state_e currentState;
 803         storage_get_state(0, &currentState);
 804         storage->setState((short)currentState);
 805
 806         storageList.insert(storageList.end(), storage);
 807 }
 808
 809 void Manager::addWidgetStorage(const std::string &key, const std::string &value)
 810 {
 811         setupLocation(key, value.c_str());
 812
 813         if (key == "wgt-package")
 814         {
 815                 m_subrootlist[LT_WGTPKG] = key;
 816         }
 817         else if (key == "wgt-private")
 818         {
 819                 m_subrootlist[LT_WGTPRV] = key;
 820         }
 821         else if (key == "wgt-private-tmp")
 822         {
 823                 m_subrootlist[LT_WGTPRVTMP] = key;
 824         }
 825 }
 826
 827 bool Manager::init()
 828 {
 829         std::vector<StoragePropertiesPtr> storageList;
 830         storage_foreach_device_supported(Manager::getSupportedDeviceCB, &storageList);
 831
 832         for (size_t i = 0; i < storageList.size(); i++) {
 833                 m_locations[storageList[i]->getLabel()] = IPath::create(storageList[i]->getFullPath());
 834                 m_rootlist[storageList[i]->getLabel()] = storageList[i]->getId();
 835         }
 836
 837         /* for Tizen */
 838         setupLocation("downloads", PATH_DOWNLOADS);
 839         setupLocation("documents", PATH_DOCUMENTS);
 840         setupLocation("music", PATH_SOUNDS);
 841         setupLocation("images", PATH_IMAGES);
 842         setupLocation("videos", PATH_VIDEOS);
 843         setupLocation("ringtones", PATH_RINGTONE);
 844
 845         m_subrootlist[LT_ROOT] = "internal0";
 846         m_subrootlist[LT_SDCARD] = "removable1";
 847         m_subrootlist[LT_USBHOST] = "removable2";
 848         m_subrootlist[LT_DOWNLOADS] = "downloads";
 849         m_subrootlist[LT_DOCUMENTS] = "documents";
 850         m_subrootlist[LT_SOUNDS] = "music";
 851         m_subrootlist[LT_IMAGES] = "images";
 852         m_subrootlist[LT_VIDEOS] = "videos";
 853         m_subrootlist[LT_RINGTONES] = "ringtones";
 854         return true;
 855
 856 }
 857
 858 void Manager::setupLocation(std::string location, const char* path)
 859 {
 860     if (!nodeExists(path)) {
 861         try {
 862             makePath(path, 0755);
 863         }
 864         catch (const Commons::Exception& ex)
 865         {
 866             LoggerE("Exception: " << ex.GetMessage());
 867             return;
 868         }
 869     }
 870     m_locations[location] = IPath::create(path);
 871 }
 872
 873 void Manager::Watcher::getCurrentStoargeStateForWatch()
 874 {
 875         std::string label("");
 876         storage_type_e type;
 877         storage_state_e state;
 878         RootList::const_iterator it = m_rootlist.begin();
 879         for (; it != m_rootlist.end(); ++it) {
 880                 label = it->first;
 881                 if (label.compare("") != 0) {
 882                         StoragePropertiesPtr storageItem(new StorageProperties());
 883
 884                         if (storage_get_type(it->second, &type) != STORAGE_ERROR_NONE) {
 885                                 Throw(Commons::PlatformException);
 886                         }
 887                         if (storage_get_state(it->second, &state) != STORAGE_ERROR_NONE) {
 888                                 Throw(Commons::PlatformException);
 889                         }
 890
 891                         storageItem->setId(it->second);
 892                         storageItem->setLabel(it->first);
 893                         storageItem->setType(static_cast<short>(type));
 894                         storageItem->setState(static_cast<short>(state));
 895
 896                         EventStorageStateChangedPtr event(new EventStorageStateChanged());
 897
 898                         event->setResult(storageItem);
 899                         emit(event);
 900                 }
 901         }
 902 }
 903
 904 void Manager::Watcher::StorageStateHasChanged(int storage, storage_state_e state)
 905 {
 906         StoragePropertiesPtr storageItem(new StorageProperties());
 907
 908         std::string label;
 909         storage_type_e type;
 910
 911         RootList::const_iterator it = m_rootlist.begin();
 912         for (; it != m_rootlist.end(); ++it) {
 913                 if (it->second == storage) {
 914                         label = it->first;
 915                         break;
 916                 }
 917         }
 918
 919         if (storage_get_type(storage, &type) != STORAGE_ERROR_NONE) {
 920                 Throw(Commons::PlatformException);
 921         }
 922
 923         if (label.compare("") != 0) {
 924                 storageItem->setId(storage);
 925                 storageItem->setLabel(label);
 926                 storageItem->setType(static_cast<short>(type));
 927                 storageItem->setState(static_cast<short>(state));
 928
 929                 EventStorageStateChangedPtr event(new EventStorageStateChanged());
 930
 931                 event->setResult(storageItem);
 932                 emit(event);
 933         }
 934 }
 935
 936 }
 937 }