src/io/FIo_FileImpl.cpp

   1 //
   2 // Open Service Platform
   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  * @file        FIo_FileImpl.cpp
  20  * @brief       This is the implementation file for %_FileImpl class.
  21  */
  22
  23 #include <stdlib.h>
  24 #include <unistd.h>
  25 #include <string.h>
  26 #include <sys/stat.h>
  27 #include <sys/types.h>
  28 #include <sys/mount.h>
  29 #include <limits.h>
  30 #include <errno.h>
  31 #include <new>
  32 #include <unique_ptr.h>
  33 #include <fcntl.h>
  34
  35 #include <FBaseSysLog.h>
  36 #include <FAppPkgPackageInfo.h>
  37 #include <FIoDirectory.h>
  38 #include <FIoFile.h>
  39 #include <FAppApp.h>
  40 #include <FSysEnvironment.h>
  41
  42 #include <FBase_StringConverter.h>
  43 #include <FApp_AppInfo.h>
  44 #include <FAppPkg_PackageInfoImpl.h>
  45 #include <FSys_EnvironmentImpl.h>
  46 #include <FBase_NativeError.h>
  47
  48 #include "FIo_FileImpl.h"
  49 #include "FIo_NormalFile.h"
  50 #include "FIo_DirectoryImpl.h"
  51 #include "FIo_SecureFile.h"
  52 #include "FIo_SecureIoUtil.h"
  53 #include "FIo_IFileCore.h"
  54 #include "FIo_FileUtil.h"
  55 #include "FIo_FileLockImpl.h"
  56
  57 using namespace std;
  58 using namespace Tizen::Base;
  59 using namespace Tizen::App;
  60 using namespace Tizen::System;
  61
  62 namespace Tizen { namespace Io
  63 {
  64
  65 static const int _MAX_PATH_LENGTH = 128;
  66 static const int _APP_UID = 5000;
  67 static const size_t _MAX_FILE_OPENMODE_LENGTH = 3;
  68 static const char _INTERNAL_MOUNT_FLAG[] = "/tmp/osp-compat/mount/internal";
  69 static const char _EXTERNAL_MOUNT_FLAG[] = "/tmp/osp-compat/mount/external";
  70
  71 struct _OspDir
  72 {
  73         char path[_MAX_PATH_LENGTH];
  74         mode_t mode;
  75         bool appPrivilege; // false: root privilege
  76 };
  77
  78 struct _LinkDir
  79 {
  80         char srcPath[_MAX_PATH_LENGTH];
  81         char destPath[_MAX_PATH_LENGTH];
  82 };
  83
  84 struct _PathInfo
  85 {
  86     char destPath[_MAX_PATH_LENGTH];
  87 };
  88
  89 _FileImpl::_FileImpl(void)
  90         : __pCore(null)
  91         , __read(false)
  92         , __write(false)
  93         , __truncate(false)
  94         , __append(false)
  95         , __pFileLockImpl(null)
  96 {
  97 }
  98
  99 _FileImpl::~_FileImpl(void)
 100 {
 101         delete __pCore;
 102         if (__pFileLockImpl != null)
 103         {
 104                 __pFileLockImpl->__pFileImpl = null;
 105         }
 106 }
 107
 108 _FileImpl::_FileImpl(const _FileImpl& fileImpl)
 109         : __pCore(null)
 110         , __read(false)
 111         , __write(false)
 112         , __truncate(false)
 113         , __append(false)
 114 {
 115         SysAssertf(false, "_FileImpl class does not support copy constructor.\n");
 116 }
 117
 118 _FileImpl&
 119 _FileImpl::operator =(const _FileImpl& fileImpl)
 120 {
 121         SysAssertf(false, "_FileImpl class does not support '=' operator.\n");
 122
 123         if (&fileImpl == this)
 124         {
 125                 return *this;
 126         }
 127
 128         return *this;
 129 }
 130
 131 bool
 132 _FileImpl::VerifyFileOpenMode(const char* pOpenMode)
 133 {
 134         if (pOpenMode == null)
 135         {
 136                 SysLog(NID_IO, "[E_INVALID_ARG] The specified openMode is null.");
 137                 return false;
 138         }
 139
 140         if (strlen(pOpenMode) > _MAX_FILE_OPENMODE_LENGTH)
 141         {
 142                 SysLog(NID_IO, "[E_INVALID_ARG] The specified openMode (%s) is invalid.", pOpenMode);
 143                 return false;
 144         }
 145
 146         switch (pOpenMode[0])
 147         {
 148         case 'r':
 149                 __read = true;
 150                 break;
 151         case 'w':
 152                 __write = true;
 153                 __truncate = true;
 154                 break;
 155         case 'a':
 156                 __write = true;
 157                 __append = true;
 158                 break;
 159         default:
 160                 SysLog(NID_IO, "[E_INVALID_ARG] The specified openMode (%s) is invalid.", pOpenMode);
 161                 return false;
 162         }
 163
 164         switch (pOpenMode[1])
 165         {
 166         case '\0':
 167                 break;
 168         case '+':
 169                 if (pOpenMode[2] == '\0' || pOpenMode[2] == 'b')
 170                 {
 171                         __read = true;
 172                         __write = true;
 173                         break;
 174                 }
 175                 else
 176                 {
 177                         SysLog(NID_IO, "[E_INVALID_ARG] The specified openMode (%s) is invalid.", pOpenMode);
 178                         return false;
 179                 }
 180         case 'b':
 181                 if (pOpenMode[2] == '\0')
 182                 {
 183                         break;
 184                 }
 185                 else if (pOpenMode[2] == '+')
 186                 {
 187                         __read = true;
 188                         __write = true;
 189                         break;
 190                 }
 191                 else
 192                 {
 193                         SysLog(NID_IO, "[E_INVALID_ARG] The specified openMode (%s) is invalid.", pOpenMode);
 194                         return false;
 195                 }
 196         default:
 197                 SysLog(NID_IO, "[E_INVALID_ARG] The specified openMode (%s) is invalid.", pOpenMode);
 198                 return false;
 199         }
 200
 201         return true;
 202 }
 203
 204 result
 205 _FileImpl::Construct(const String& filePath, const String& openMode, bool createParentDirsToo, const ByteBuffer* pSecretKey)
 206 {
 207         SysAssertf(__pCore == null, "Already constructed. Calling Construct() twice or more on a same instance is not allowed for this class\n");
 208         result r = E_SUCCESS;
 209
 210         if (openMode.Contains(L'r') == true)
 211         {
 212                 SysTryReturnResult(NID_IO, !createParentDirsToo, E_INVALID_ARG,
 213                                 "The specified createParentDirsToo cannot be used without file creation mode.");
 214         }
 215
 216         if (createParentDirsToo == true)
 217         {
 218                 String dirPath;
 219                 int position = 0;
 220
 221                 r = filePath.LastIndexOf(L'/', filePath.GetLength() - 1, position);
 222                 SysTryReturnResult(NID_IO, r != E_OBJ_NOT_FOUND, E_INVALID_ARG, "The specified filePath is invalid.");
 223                 SysTryReturnResult(NID_IO, !(position == 0), E_INVALID_ARG, "The specified filePath is invalid.");
 224
 225                 r = filePath.SubString(0, position, dirPath);
 226                 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to extract dir path.", GetErrorMessage(r));
 227
 228                 r = Directory::Create(dirPath, true);
 229                 if (IsFailed(r))
 230                 {
 231                         if (r == E_FILE_ALREADY_EXIST)
 232                         {
 233                                 r = E_SUCCESS;
 234                         }
 235                         else
 236                         {
 237                                 SysPropagate(NID_IO, r);
 238                                 return r;
 239                         }
 240                 }
 241         }
 242
 243         unique_ptr<char[]> pOpenMode(_StringConverter::CopyToCharArrayN(openMode));
 244         SysTryReturnResult(NID_IO, pOpenMode != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 245
 246         return Construct(filePath, pOpenMode.get(), pSecretKey);
 247 }
 248
 249 result
 250 _FileImpl::Construct(const String& filePath, const char* pOpenMode, const ByteBuffer* pSecretKey)
 251 {
 252         SysAssertf(__pCore == null, "Already constructed. Calling Construct() twice or more on a same instance is not allowed for this class\n");
 253         result r = E_SUCCESS;
 254
 255         bool isValidOpenMode = VerifyFileOpenMode(pOpenMode);
 256         SysTryReturnResult(NID_IO, isValidOpenMode == true, E_INVALID_ARG, "The specified openMode is invalid. (%s)", pOpenMode);
 257
 258         SysTryReturnResult(NID_IO, VerifyFilePathCompatibility(filePath, _AppInfo::IsOspCompat()) == true,
 259                         E_INVALID_ARG, " [%ls] is not compatible.", filePath.GetPointer());
 260
 261         if (!__truncate && IsFileExist(filePath))
 262         {
 263                 r = _SecureIoUtil::CheckSecureFileHeader(filePath, pSecretKey);
 264                 if (r == E_END_OF_FILE)
 265                 {
 266                         r = E_IO; //for security error
 267                 }
 268                 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Propagated.", GetErrorMessage(r));
 269         }
 270
 271         if (pSecretKey == null)
 272         {
 273                 unique_ptr<_NormalFile> pNormalFile(new (std::nothrow) _NormalFile());
 274                 SysTryReturnResult(NID_IO, pNormalFile, E_OUT_OF_MEMORY, "The memory is insufficient.");
 275
 276                 r = pNormalFile->Construct(filePath, pOpenMode);
 277                 SysTryReturn(NID_IO, !IsFailed(r), r , r, "[%s] Propagated.", GetErrorMessage(r));
 278                 __pCore = pNormalFile.release();
 279         }
 280         else
 281         {
 282                 unique_ptr<_SecureFile> pSecureFile(new (std::nothrow) _SecureFile(__read, __write, __truncate, __append));
 283                 SysTryReturnResult(NID_IO, pSecureFile, E_OUT_OF_MEMORY, "The memory is insufficient.");
 284
 285                 r = pSecureFile->Construct(filePath, pOpenMode, pSecretKey);
 286                 SysTryReturn(NID_IO, !IsFailed(r), r , r, "[%s] Propagated.", GetErrorMessage(r));
 287                 __pCore = pSecureFile.release();
 288         }
 289
 290         return E_SUCCESS;
 291 }
 292
 293 result
 294 _FileImpl::ReadN(char** buffer, int& length)
 295 {
 296         result r = E_SUCCESS;
 297         if (__pCore != null)
 298         {
 299                 _NormalFile* pNormalFile = dynamic_cast< _NormalFile* > (__pCore);
 300                 if (pNormalFile != null)
 301                 {
 302                         r = pNormalFile->ReadN(buffer, length);
 303                 }
 304         }
 305         else
 306         {
 307                 r = E_INVALID_OPERATION;
 308         }
 309
 310         return r;
 311 }
 312
 313 result
 314 _FileImpl::Read(ByteBuffer& buffer)
 315 {
 316         SysAssertf(__pCore != null, "Not yet constructed. Construct() should be called before use.\n");
 317         SysTryReturnResult(NID_IO, __read == true, E_ILLEGAL_ACCESS, "File is not opened for reading.");
 318         return __pCore->Read(buffer);
 319 }
 320
 321 int
 322 _FileImpl::Read(void* buffer, int length)
 323 {
 324         SysAssertf(__pCore != null, "Not yet constructed. Construct() should be called before use.\n");
 325         SysTryReturn(NID_IO, __read == true, 0, E_ILLEGAL_ACCESS, "[E_ILLEGAL_ACCESS] File is not opened for reading.");
 326         return __pCore->Read(buffer, length);
 327 }
 328
 329 result
 330 _FileImpl::Read(String& buffer)
 331 {
 332         SysAssertf(__pCore != null, "Not yet constructed. Construct() should be called before use.\n");
 333         SysTryReturnResult(NID_IO, __read == true, E_ILLEGAL_ACCESS, "File is not opened for reading.");
 334         return __pCore->Read(buffer);
 335 }
 336
 337 result
 338 _FileImpl::Write(const ByteBuffer& buffer)
 339 {
 340         SysAssertf(__pCore != null, "Not yet constructed. Construct() should be called before use.\n");
 341         SysTryReturnResult(NID_IO, __write == true, E_ILLEGAL_ACCESS, "File is not opened for writing.");
 342         return __pCore->Write(buffer);
 343 }
 344
 345 result
 346 _FileImpl::Write(const void* buffer, int length)
 347 {
 348         SysAssertf(__pCore != null, "Not yet constructed. Construct() should be called before use.\n");
 349         SysTryReturnResult(NID_IO, __write == true, E_ILLEGAL_ACCESS, "File is not opened for writing.");
 350         return __pCore->Write(buffer, length);
 351 }
 352
 353 result
 354 _FileImpl::Write(const String& buffer)
 355 {
 356         SysAssertf(__pCore != null, "Not yet constructed. Construct() should be called before use.\n");
 357         SysTryReturnResult(NID_IO, __write == true, E_ILLEGAL_ACCESS, "File is not opened for writing.");
 358         return __pCore->Write(buffer);
 359 }
 360
 361 result
 362 _FileImpl::Flush(void)
 363 {
 364         SysAssertf(__pCore != null, "Not yet constructed. Construct() should be called before use.\n");
 365         return __pCore->Flush();
 366 }
 367
 368 int
 369 _FileImpl::Tell(void) const
 370 {
 371         SysTryReturnResult(NID_IO, __pCore != null, -1, "File is not constructed! Construct destined file first! ");
 372         return __pCore->Tell();
 373 }
 374
 375 result
 376 _FileImpl::Seek(FileSeekPosition position, long offset)
 377 {
 378         SysAssertf(__pCore != null, "Not yet constructed. Construct() should be called before use.\n");
 379         return __pCore->Seek(position, offset);
 380 }
 381
 382 result
 383 _FileImpl::Truncate(int length)
 384 {
 385         SysAssertf(__pCore != null, "Not yet constructed. Construct() should be called before use.\n");
 386         SysTryReturnResult(NID_IO, __write == true, E_ILLEGAL_ACCESS, "File is not opened for writing.");
 387         return __pCore->Truncate(length);
 388 }
 389
 390 String
 391 _FileImpl::GetName(void) const
 392 {
 393         SysAssertf(__pCore != null, "Not yet constructed. Construct() should be called before use.\n");
 394         return __pCore->GetName();
 395 }
 396
 397 FILE*
 398 _FileImpl::GetFilePointer(void) const
 399 {
 400         SysAssertf(__pCore != null, "Not yet constructed. Construct() should be called before use.\n");
 401         return __pCore->GetFilePointer();
 402 }
 403
 404 FileLock*
 405 _FileImpl::LockN(FileLockType lockType)
 406 {
 407         SysAssertf(__pCore != null, "Not yet constructed. Construct() should be called before use.\n");
 408         return LockN(lockType, FILE_LOCK_MODE_BLOCKING, 0, 0);
 409 }
 410
 411 FileLock*
 412 _FileImpl::LockN(FileLockType lockType, int offset, int length)
 413 {
 414         SysAssertf(__pCore != null, "Not yet constructed. Construct() should be called before use.\n");
 415         return LockN(lockType, FILE_LOCK_MODE_BLOCKING, offset, length);
 416 }
 417
 418 FileLock*
 419 _FileImpl::TryToLockN(FileLockType lockType)
 420 {
 421         SysAssertf(__pCore != null, "Not yet constructed. Construct() should be called before use.\n");
 422         return LockN(lockType, FILE_LOCK_MODE_NON_BLOCKING, 0, 0);
 423 }
 424
 425 FileLock*
 426 _FileImpl::TryToLockN(FileLockType lockType, int offset, int length)
 427 {
 428         SysAssertf(__pCore != null, "Not yet constructed. Construct() should be called before use.\n");
 429         return LockN(lockType, FILE_LOCK_MODE_NON_BLOCKING, offset, length);
 430 }
 431
 432 FileLock*
 433 _FileImpl::LockN(FileLockType lockType, _FileLockMode lockMode, int offset, int length)
 434 {
 435         SysAssertf(__pCore != null, "Not yet constructed. Construct() should be called before use.\n");
 436         SysTryReturn(NID_IO, offset >= 0, null, E_INVALID_ARG, "[E_INVALID_ARG] The specified offset is negative.");
 437         SysTryReturn(NID_IO, length >= 0, null, E_INVALID_ARG, "[E_INVALID_ARG] The specified length is negative.");
 438
 439         struct flock lock;
 440         switch (lockType)
 441         {
 442         case FILE_LOCK_SHARED:
 443                 SysTryReturn(NID_IO, __read == true, null, E_INVALID_OPERATION, "[E_INVALID_OPERATION] File is not opened for reading.");
 444                 lock.l_type = F_RDLCK;
 445                 break;
 446         case FILE_LOCK_EXCLUSIVE:
 447                 SysTryReturn(NID_IO, __write == true, null, E_INVALID_OPERATION, "[E_INVALID_OPERATION] File is not opened for writing.");
 448                 lock.l_type = F_WRLCK;
 449                 break;
 450         default:
 451                 SysLogException(NID_IO, E_INVALID_ARG, "[E_INVALID_ARG] The specified lock type is invalid.");
 452                 return null;
 453         }
 454
 455         int fd = fileno(this->GetFilePointer());
 456         int lockCommand = -1;
 457         int ret = -1;
 458         switch (lockMode)
 459         {
 460         case FILE_LOCK_MODE_BLOCKING:
 461                 lockCommand = F_SETLKW;
 462                 break;
 463         case FILE_LOCK_MODE_NON_BLOCKING:
 464         {
 465                 lockCommand = F_SETLK;
 466                 break;
 467         }
 468         default:
 469                 SysLogException(NID_IO, E_INVALID_ARG, "[E_INVALID_ARG] The specified lock mode is invalid.");
 470                 return null;
 471         }
 472
 473         lock.l_whence = SEEK_SET;
 474         lock.l_start = offset;
 475         lock.l_len = length;
 476         lock.l_pid = getpid();
 477
 478         ret = fcntl(fd, lockCommand, &lock);
 479         if (ret != 0)
 480         {
 481                 result r = E_SUCCESS;
 482                 switch (errno)
 483                 {
 484                 case ENOLCK:
 485                         r = E_MAX_EXCEEDED;
 486                         break;
 487                 case EDEADLK:
 488                 {
 489                         if (lockMode == FILE_LOCK_MODE_BLOCKING)
 490                         {
 491                                 r = E_WOULD_DEADLOCK;
 492                         }
 493                         else
 494                         {
 495                                 r = E_SYSTEM;
 496                         }
 497                         break;
 498                 }
 499                 case EAGAIN:
 500                         // fall through
 501                 case EACCES:
 502                         if (lockMode == FILE_LOCK_MODE_NON_BLOCKING)
 503                         {
 504                                 r = E_OBJECT_LOCKED;
 505                                 break;
 506                         }
 507                         // else fall through
 508                 case EFAULT:
 509                         // fall through
 510                 case EBADF:
 511                         r = E_SYSTEM;
 512                         break;
 513                 default:
 514                         r = _NativeError::ConvertNativeErrorToResult(errno, true);
 515                         break;
 516                 }
 517
 518                 SysLogException(NID_IO, r, "[%s] Aquiring file lock of type (%d) is failed, errno: %d (%s)", GetErrorMessage(r), lockType, errno, strerror(errno));
 519                 return null;
 520         }
 521
 522         unique_ptr<FileLock> pFileLock(_FileLockImpl::CreateFileLockInstanceN(this, lockType, lock.l_start, lock.l_len, lock.l_pid));
 523         SysTryReturn(NID_IO, pFileLock != null, null, GetLastResult(), "[%s] Propagating to caller....", GetErrorMessage(GetLastResult()));
 524         __pFileLockImpl = _FileLockImpl::GetInstance(*pFileLock);
 525         SetLastResult(E_SUCCESS);
 526         return pFileLock.release();
 527 }
 528
 529 result
 530 _FileImpl::Remove(const String& filePath)
 531 {
 532         SysTryReturnResult(NID_IO, VerifyFilePathCompatibility(filePath, _AppInfo::IsOspCompat()) == true,
 533                                           E_INVALID_ARG, " [%ls] is not compatible.", filePath.GetPointer());
 534         return _FileUtil::Remove(filePath);
 535 }
 536
 537 result
 538 _FileImpl::Move(const String& oldFilePath, const String& newFilePath)
 539 {
 540         SysTryReturnResult(NID_IO, VerifyFilePathCompatibility(oldFilePath, _AppInfo::IsOspCompat()) == true,
 541                                           E_INVALID_ARG, " [%ls] is not compatible.", oldFilePath.GetPointer());
 542
 543         SysTryReturnResult(NID_IO, VerifyFilePathCompatibility(newFilePath, _AppInfo::IsOspCompat()) == true,
 544                                           E_INVALID_ARG, " [%ls] is not compatible.", newFilePath.GetPointer());
 545         return _FileUtil::Move(oldFilePath, newFilePath);
 546 }
 547
 548 result
 549 _FileImpl::Copy(const String& srcFilePath, const String& destFilePath, bool failIfExist)
 550 {
 551         SysTryReturnResult(NID_IO, VerifyFilePathCompatibility(srcFilePath, _AppInfo::IsOspCompat()) == true,
 552                                           E_INVALID_ARG, " [%ls] is not compatible.", srcFilePath.GetPointer());
 553
 554         SysTryReturnResult(NID_IO, VerifyFilePathCompatibility(destFilePath, _AppInfo::IsOspCompat()) == true,
 555                                           E_INVALID_ARG, " [%ls] is not compatible.", destFilePath.GetPointer());
 556         return _FileUtil::Copy(srcFilePath, destFilePath, failIfExist);
 557 }
 558
 559 result
 560 _FileImpl::GetAttributes(const String& filePath, FileAttributes& attribute)
 561 {
 562         SysTryReturnResult(NID_IO, VerifyFilePathCompatibility(filePath, _AppInfo::IsOspCompat()) == true,
 563                                           E_INVALID_ARG, " [%ls] is not compatible.", filePath.GetPointer());
 564         return _FileUtil::GetAttributes(filePath, attribute);
 565 }
 566
 567 String
 568 _FileImpl::GetFileName(const String& filePath)
 569 {
 570         String fileName;
 571         SysTryReturn(NID_IO, VerifyFilePathCompatibility(filePath, _AppInfo::IsOspCompat()) == true, fileName, E_INVALID_ARG,
 572                         "[E_INVALID_ARG] The length of the specified filePath (%ls) is zero or exceeds system limitations.",
 573                         filePath.GetPointer());
 574
 575         return _FileUtil::GetFileName(filePath);
 576 }
 577
 578 String
 579 _FileImpl::GetFileExtension(const String& filePath)
 580 {
 581         String extName;
 582         SysTryReturn(NID_IO, VerifyFilePathCompatibility(filePath, _AppInfo::IsOspCompat()) == true, extName, E_INVALID_ARG,
 583                         "[E_INVALID_ARG] The length of the specified filePath (%ls) is zero or exceeds system limitations.",
 584                         filePath.GetPointer());
 585
 586         return _FileUtil::GetFileExtension(filePath);
 587 }
 588
 589 bool
 590 _FileImpl::IsFileExist(const String& filePath)
 591 {
 592         SysTryReturn(NID_IO, VerifyFilePathCompatibility(filePath, _AppInfo::IsOspCompat()) == true,
 593                         false, E_INVALID_ARG, "[E_INVALID_ARG] The specified filePath (%ls) is invalid.", filePath.GetPointer());
 594
 595         return _FileUtil::IsFileExist(filePath);
 596 }
 597
 598 result
 599 _FileImpl::ConvertToSecureFile(const String& plainFilePath, const String& secureFilePath,
 600                                                            const ByteBuffer& key)
 601 {
 602         return _FileUtil::ConvertToSecureFile(plainFilePath, secureFilePath, &key);
 603 }
 604
 605 bool
 606 _FileImpl::IsAppPath(const String& filePath)
 607 {
 608         SysTryReturn(NID_IO, VerifyFilePathCompatibility(filePath, _AppInfo::IsOspCompat()) == true,
 609                         false, E_INVALID_ARG, "[E_INVALID_ARG] The specified filePath (%ls) is invalid.", filePath.GetPointer());
 610
 611         return _FileUtil::IsAppPath(filePath);
 612 }
 613
 614 bool
 615 _FileImpl::IsMediaPath(const String& filePath)
 616 {
 617         SysTryReturn(NID_IO, VerifyFilePathCompatibility(filePath, _AppInfo::IsOspCompat()) == true,
 618                         false, E_INVALID_ARG, "[E_INVALID_ARG] The specified filePath (%ls) is invalid.", filePath.GetPointer());
 619
 620         return _FileUtil::IsMediaPath(filePath);
 621 }
 622
 623 bool
 624 _FileImpl::IsSystemPath(const String& filePath)
 625 {
 626         SysTryReturn(NID_IO, VerifyFilePathCompatibility(filePath, _AppInfo::IsOspCompat()) == true,
 627                         false, E_INVALID_ARG, "[E_INVALID_ARG] The specified filePath (%ls) is invalid.", filePath.GetPointer());
 628
 629         return _FileUtil::IsSystemPath(filePath);
 630 }
 631
 632 bool
 633 _FileImpl::VerifyFilePath(const String& filePath, _FilePathType pathType)
 634 {
 635         return _FileUtil::VerifyFilePath(filePath, pathType);
 636 }
 637
 638 bool
 639 _FileImpl::CleanDirectories(const String& appRootPath, const String& pkgId)
 640 {
 641         char removeCmd[PATH_MAX] = {0, };
 642         int ret = 0;
 643
 644         String ospSharePkgIdPath = _EnvironmentImpl::GetOspCompatSharedPath();
 645         ospSharePkgIdPath.Append(L"share/");
 646         ospSharePkgIdPath.Append(pkgId);
 647
 648         String ospShare2PkgIdPath = _EnvironmentImpl::GetOspCompatSharedPath();
 649         ospShare2PkgIdPath.Append(L"share2/");
 650         ospShare2PkgIdPath.Append(pkgId);
 651
 652 #if 0
 653         r = Directory::Remove(ospSharePkgIdPath, true);
 654         SysTryReturn(NID_IO, !IsFailed(r), false, E_SYSTEM, "[%s] Failed to remove directory (%ls)",
 655                         GetErrorMessage(r), ospSharePkgIdPath.GetPointer());
 656
 657         r = Directory::Remove(ospShare2PkgIdPath, true);
 658         SysTryReturn(NID_IO, !IsFailed(r), false, E_SYSTEM, "[%s] Failed to remove directory (%ls)",
 659                         GetErrorMessage(r), ospShare2PkgIdPath.GetPointer());
 660 #else
 661         sprintf(removeCmd, "rm -rf %ls", ospSharePkgIdPath.GetPointer());
 662         ret = system(removeCmd);
 663         SysTryReturn(NID_IO, ret != -1, false, E_SYSTEM, "Failed to remove directory (%ls)",
 664                         ospSharePkgIdPath.GetPointer());
 665
 666         memset(removeCmd, 0, PATH_MAX);
 667
 668         sprintf(removeCmd, "rm -rf %ls", ospShare2PkgIdPath.GetPointer());
 669         ret = system(removeCmd);
 670         SysTryReturn(NID_IO, ret != -1, false, E_SYSTEM, "Failed to remove directory (%ls)",
 671                         ospShare2PkgIdPath.GetPointer());
 672 #endif
 673
 674         return true;
 675 }
 676
 677 // This method is called by package installer backend.
 678 bool
 679 _FileImpl::PrepareDataCaging(const String& appRootPath, const String& pkgId)
 680 {
 681         int index = 0;
 682         char* pCwd = null;
 683         bool internalInstalled = true;
 684         result r = E_SUCCESS;
 685
 686         SysSecureLog(NID_IO, "[data_caging] PrepareDataCaging() was called by installer backend, appRootPath: %ls, packageId: %ls",
 687                         appRootPath.GetPointer(), pkgId.GetPointer());
 688
 689         if (CleanDirectories(appRootPath, pkgId) == false)
 690         {
 691                 SysLog(NID_IO, "CleanDirectories() failed.");
 692                 return false;
 693         }
 694
 695         pCwd = get_current_dir_name();
 696         SysTryCatch(NID_IO, pCwd != null, r = E_SYSTEM, E_SYSTEM,
 697                            "[E_SYSTEM] get_current_dir_name() was failed, errno: %d (%s).", errno, strerror(errno));
 698
 699         // Check whether package is installed on internal storage or not
 700         r = appRootPath.IndexOf("/opt/storage/sdcard", 0, index);
 701         if (r == E_SUCCESS)
 702         {
 703                 internalInstalled = false;
 704         }
 705         else
 706         {
 707                 internalInstalled = true;
 708         }
 709
 710         umask(0000);
 711
 712         if (internalInstalled == true)
 713         {
 714                 unique_ptr<char[]> pAppRootPath(_StringConverter::CopyToCharArrayN(appRootPath));
 715                 SysTryCatch(NID_IO, pAppRootPath != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] The memory is insufficient.");
 716
 717                 SysTryCatch(NID_IO, chdir(pAppRootPath.get()) == 0, r = E_SYSTEM, E_SYSTEM,
 718                                 "[E_SYSTEM] chdir() was failed (%s), path: %s", strerror(errno), pAppRootPath.get());
 719
 720                 SysTryCatch(NID_IO, CreateOspInternalDirectories(appRootPath, pkgId) == true, r = E_SYSTEM, E_SYSTEM,
 721                                 "[E_SYSTEM] fail to create OSP Internal directories");
 722         }
 723         else
 724         {
 725                 String appExRootPath(appRootPath);
 726
 727                 int ret = 0;
 728
 729                 appExRootPath.Append(pkgId);
 730                 unique_ptr<char[]> pAppExRootPath(_StringConverter::CopyToCharArrayN(appExRootPath));
 731                 SysTryCatch(NID_IO, pAppExRootPath != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] The memory is insufficient.");
 732
 733                 ret = mkdir(pAppExRootPath.get(), 0705);
 734                 if (ret == -1 && errno != 17) // EEXIST
 735                 {
 736                         SysLog(NID_IO, "mkdir() failed (%s), path: %s, mode: 0%o",
 737                                                 strerror(errno), pAppExRootPath.get(), 0705);
 738                         goto CATCH;
 739                 }
 740
 741                 SysTryCatch(NID_IO, chdir(pAppExRootPath.get()) == 0, r = E_SYSTEM, E_SYSTEM,
 742                                 "[E_SYSTEM] chdir() was failed (%s), path: %s", strerror(errno), pAppExRootPath.get());
 743                 SysTryCatch(NID_IO, CreateOspExternalDirectories(pkgId) == true, r = E_SYSTEM, E_SYSTEM,
 744                                 "[E_SYSTEM] fail to create OSP External directories");
 745         }
 746
 747         SysTryCatch(NID_IO, CreateSlpDirectories() == true, r = E_SYSTEM, E_SYSTEM,
 748                         "[E_SYSTEM] fail to create SLP directories");
 749         SysTryCatch(NID_IO, CreateSymbolicLink() == true, r = E_SYSTEM, E_SYSTEM,
 750                         "[E_SYSTEM] Fail to create symbolic link.");
 751         SysTryCatch(NID_IO, chdir(pCwd) == 0, r = E_SYSTEM, E_SYSTEM,
 752                         "[E_SYSTEM] chdir() was failed (%s), path: %s", strerror(errno), pCwd);
 753
 754         r = E_SUCCESS;
 755         SysLog(NID_IO, "[data_caging] PrepareDataCaging() succeeded.");
 756
 757         // fall thru
 758 CATCH:
 759         if (pCwd != null)
 760         {
 761                 free(pCwd);
 762         }
 763
 764         umask(0022);
 765
 766         if (IsFailed(r))
 767         {
 768                 SysLog(NID_IO, "[data_caging] PrepareDataCaging() failed.");
 769                 return false;
 770         }
 771
 772         return true;
 773 }
 774
 775 bool
 776 _FileImpl::FinalizeDataCaging(const String& appRootPath) // for 2.0 app
 777 {
 778         static const struct _PathInfo mountPath[] =
 779         {
 780                 //{ "./bin" },
 781                 //{ "./boot" },
 782                 //{ "./cache" },
 783                 { "./csa" },
 784                 { "./dev/pts" },
 785                 { "./dev/shm" },
 786                 { "./dev" },
 787                 { "./etc" },
 788                 { "./lib" },
 789                 //{ "./lost+found" },
 790                 { "./media" },
 791                 { "./mnt" },
 792                 { "./opt/usr" },
 793                 { "./opt/var/kdb/db" },
 794                 { "./opt/storage/sdcard" },
 795                 { "./opt" },
 796                 //{ "./packaging" },
 797                 { "./proc" },
 798                 { "./sbin" },
 799                 { "./smack" },
 800                 { "./srv" },
 801                 { "./sys/kernel/debug" },
 802                 { "./sys" },
 803                 { "./tmp" },
 804                 { "./usr" },
 805                 { "./var/run" },
 806                 { "./var" },
 807
 808                 { "./data/Share" },
 809                 { "./data/Share2" },
 810                 { "./Share" },
 811                 { "./Share2" },
 812                 //{ "./Clipboard" },
 813                 //{ "./NPKI" },
 814                 //{ "./System" },
 815                 //{ "./Tmp" },
 816                 { "./Media" },
 817
 818                 { "./Storagecard/Media" },
 819         { "./ShareExt" },
 820         { "./Share2Ext" },
 821         { "./HomeExt/Share" },
 822         { "./HomeExt/Share2" },
 823         { "./HomeExt" }
 824         };
 825
 826         unique_ptr< char[] > pAppRootPath(_StringConverter::CopyToCharArrayN(appRootPath));
 827         SysTryReturn(NID_IO, pAppRootPath != null, false, E_OUT_OF_MEMORY,
 828                         "[E_OUT_OF_MEMORY] The memory is insufficient.");
 829
 830         SysTryReturn(NID_IO, chdir(pAppRootPath.get()) == 0, false, E_SYSTEM,
 831                         "[E_SYSTEM] chdir() failed (%d, %s), path: %ls", errno, strerror(errno), appRootPath.GetPointer());
 832
 833         for (int i = 0; i < sizeof(mountPath) / sizeof(struct _PathInfo); ++i)
 834         {
 835                 int ret = umount2(mountPath[i].destPath, MNT_DETACH);
 836                 SysTryLog(NID_IO, ret == 0, "umount2() errno: %d (%s)", errno, strerror(errno));
 837                 SysTryReturn(NID_IO, ret == 0 || errno == EINVAL || errno == ENOENT, false, E_SYSTEM,
 838                                 "[E_SYSTEM] umount2() failed (%d, %s), path: %s", errno, strerror(errno), mountPath[i].destPath);
 839         }
 840
 841         char* pkgId = strrchr(pAppRootPath.get(), '/');
 842         char mountFlag[_MAX_PATH_LENGTH] = { 0, };
 843         sprintf(mountFlag, "%s/%s", _INTERNAL_MOUNT_FLAG, ++pkgId);
 844         int res = unlink(mountFlag);
 845         if (res == -1 && errno != ENOENT)
 846         {
 847                 SysLogException(NID_IO, E_SYSTEM, "[E_SYSTEM] Failed to remove mount flag (%s), errno: %d (%s)",
 848                                 mountFlag, errno, strerror(errno));
 849                 return false;
 850         }
 851
 852         memset(mountFlag, 0, _MAX_PATH_LENGTH);
 853         sprintf(mountFlag, "%s/%s", _EXTERNAL_MOUNT_FLAG, pkgId);
 854         res = unlink(mountFlag);
 855         if (res == -1 && errno != ENOENT)
 856         {
 857                 SysLogException(NID_IO, E_SYSTEM, "[E_SYSTEM] Failed to remove mount flag (%s), errno: %d (%s)",
 858                                 mountFlag, errno, strerror(errno));
 859                 return false;
 860         }
 861
 862         SysLog(NID_IO, "[data_caging] FinalizeDataCaging() succeeded, appRootPath: %ls", appRootPath.GetPointer());
 863         return true;
 864 }
 865
 866 int
 867 _FileImpl::GetAvailableUid(void)
 868 {
 869         return _APP_UID;
 870 }
 871
 872 bool
 873 _FileImpl::CreateOspApplicationDirectories(const String& appRootPath, const String& pkgId) // for 2.0 app
 874 {
 875 #if 0
 876         struct _OspDir appSubDir[] =
 877         {
 878                 //{ "./shared\0",                       0755, false },
 879                 //{ "./shared/data\0",          0755, true },
 880                 //{ "./shared/res\0",           0755, false },
 881                 //{ "./shared/trusted\0",       0755, true },
 882                 //{ "./cache\0", 0700, true }
 883         };
 884         int uid = -1;
 885         int ret = 0;
 886         unsigned int i = 0;
 887         result r = E_SUCCESS;
 888 #endif
 889
 890         SysTryReturn(NID_IO, CleanDirectories(appRootPath, pkgId) == true, false, E_SYSTEM,
 891                         "[E_SYSTEM] Failed to clean directories for 2.0 application compatibility.");
 892
 893 #if 0
 894         unique_ptr<char[]> pAppRootPath(_StringConverter::CopyToCharArrayN(appRootPath));
 895         SysTryReturn(NID_IO, pAppRootPath != null, false, E_SYSTEM, "[E_SYSTEM] The memory is insufficient.");
 896
 897         SysTryReturn(NID_IO, chdir(pAppRootPath.get()) == 0, false, E_SYSTEM,
 898                         "[E_SYSTEM] chdir() failed (%d, %s), path: %s", errno, strerror(errno), pAppRootPath.get());
 899
 900         uid = GetAvailableUid();
 901
 902         umask(0000);
 903
 904         for (i = 0; i < sizeof(appSubDir) / sizeof(struct _OspDir); ++i)
 905         {
 906                 ret = mkdir(appSubDir[i].path, appSubDir[i].mode);
 907                 if (ret == -1 && errno != 17) // EEXIST
 908                 {
 909                         SysLog(NID_IO, "[E_SYSTEM] mkdir() failed (%d, %s), path: %s, mode: 0%o",
 910                                         errno, strerror(errno), appSubDir[i].path, appSubDir[i].mode);
 911                         goto CATCH;
 912                 }
 913
 914                 if (appSubDir[i].appPrivilege)
 915                 {
 916                         ret = chown(appSubDir[i].path, uid, uid);
 917                         SysTryCatch(NID_IO, ret == 0, , E_SYSTEM,
 918                                         "[E_SYSTEM] chown() failed (%d, %s), path: %s, uid: %d",
 919                                         errno, strerror(errno), appSubDir[i].path, uid);
 920                 }
 921         }
 922
 923         umask(0022);
 924
 925         SysLog(NID_IO, "_FileImpl::CreateOspApplicationDirectories() succeeded.");
 926         return true;
 927
 928 CATCH:
 929         umask(0022);
 930
 931         return false;
 932 #else
 933         return true;
 934 #endif
 935
 936 }
 937
 938 bool
 939 _FileImpl::CreateOspInternalDirectories(const String& appRootPath, const String& pkgId) // for 2.0 app
 940 {
 941         unsigned int i = 0;
 942         int ret = 0;
 943         int uid = -1;
 944         struct _OspDir appSubDir[] =
 945         {
 946 //              { "./data",                     0700, true },   // It is created by installer.
 947                 { "./shared",           0755, false },
 948                 { "./data/Share",       0000, true },   // mount from /opt/usr/share/.osp-compat/share/{pkgId}
 949                 { "./data/Share2",      0000, true },   // mount from /opt/usr/share/.osp-compat/share2/{pkgId}
 950                 { "./Share",            0000, false },  // mount from /opt/usr/share/.osp-compat/share
 951                 { "./Share2",           0000, false },  // mount from /opt/usr/share/.osp-compat/share2
 952 //              { "./Clipboard",        0000, false },
 953 //              { "./NPKI",                     0000, false },
 954 //              { "./System",           0000, false },
 955 //              { "./Tmp",                      0000, false },
 956                 { "./Media",            0000, false },  // mount from /opt/usr/media
 957                 { "./Storagecard",      0705, false },
 958                 { "./Storagecard/Media", 0000, false }, // mount from /opt/storage/sdcard
 959         };
 960 #if 1
 961         struct _OspDir mediaDir[] =
 962         {
 963                 { "/opt/usr/media/Images", 0777, false },
 964                 { "/opt/usr/media/Sounds", 0777, false },
 965                 { "/opt/usr/media/Videos", 0777, false },
 966                 //{ "/opt/usr/media/Themes", 0777, false },
 967                 { "/opt/usr/media/Others", 0777, false }
 968         };
 969 #endif
 970         String ospCompatSharedPath = _EnvironmentImpl::GetOspCompatSharedPath();
 971         String ospShareAppIdPath(L"share/");
 972         String ospShare2AppIdPath(L"share2/");
 973         result r = E_SUCCESS;
 974
 975         r = ospShareAppIdPath.Insert(ospCompatSharedPath, 0);
 976         SysTryReturn(NID_IO, !IsFailed(r), false, E_SYSTEM,
 977                         "[E_SYSTEM] String::Insert() failed. (error: %s)", GetErrorMessage(r));
 978
 979         r = ospShare2AppIdPath.Insert(ospCompatSharedPath, 0);
 980         SysTryReturn(NID_IO, !IsFailed(r), false, E_SYSTEM,
 981                         "[E_SYSTEM] String::Insert() failed. (error: %s)", GetErrorMessage(r));
 982
 983         uid = GetAvailableUid();
 984
 985         for (i = 0; i < sizeof(appSubDir) / sizeof(struct _OspDir); i++)
 986         {
 987                 ret = mkdir(appSubDir[i].path, appSubDir[i].mode);
 988                 if (ret == -1 && errno != 17) // EEXIST
 989                 {
 990                         SysLog(NID_IO, "mkdir() failed (%s), path: %s, mode: 0%o",
 991                                                 strerror(errno), appSubDir[i].path, appSubDir[i].mode);
 992                         return false;
 993                 }
 994                 if (appSubDir[i].appPrivilege)
 995                 {
 996                         ret = chown(appSubDir[i].path, uid, uid);
 997                         if (ret == -1)
 998                         {
 999                                 SysLog(NID_IO, "chown() failed (%s), path: %s, uid: %d",
1000                                                         strerror(errno), appSubDir[i].path, uid);
1001                                 return false;
1002                         }
1003                 }
1004         }
1005
1006         ospShareAppIdPath.Append(pkgId);
1007         unique_ptr<char[]> pOspShareAppIdPath(_StringConverter::CopyToCharArrayN(ospShareAppIdPath));
1008         SysTryReturn(NID_IO, pOspShareAppIdPath != null, false, E_SYSTEM, "[E_SYSTEM] The memory is insufficient.");
1009         ret = mkdir(pOspShareAppIdPath.get(), 0705);
1010         if (ret == -1 && errno != 17) // EEXIST
1011         {
1012                 SysLog(NID_IO, "mkdir() failed (%s), path: %s, mode: 0%o",
1013                                         strerror(errno), pOspShareAppIdPath.get(), 0705);
1014                 return false;
1015         }
1016         ret = chown(pOspShareAppIdPath.get(), uid, uid);
1017         if (ret == -1)
1018         {
1019                 SysLog(NID_IO, "chown() failed (%s), path: %s, uid: %d",
1020                                         strerror(errno), pOspShareAppIdPath.get(), uid);
1021                 return false;
1022         }
1023
1024         ospShare2AppIdPath.Append(pkgId);
1025         unique_ptr<char[]> pOspShare2AppIdPath(_StringConverter::CopyToCharArrayN(ospShare2AppIdPath));
1026         SysTryReturn(NID_IO, pOspShare2AppIdPath != null, false, E_SYSTEM, "[E_SYSTEM] The memory is insufficient.");
1027         ret = mkdir(pOspShare2AppIdPath.get(), 0705);    // TODO: change to 0770
1028         if (ret == -1 && errno != 17) // EEXIST
1029         {
1030                 SysLog(NID_IO, "mkdir() failed (%s), path: %s, mode: 0%o",
1031                                         strerror(errno), pOspShare2AppIdPath.get(), 0705);
1032                 return false;
1033         }
1034         ret = chown(pOspShare2AppIdPath.get(), uid, uid);
1035         if (ret == -1)
1036         {
1037                 SysLog(NID_IO, "chown() failed (%s), path: %s, uid: %d",
1038                                         strerror(errno), pOspShare2AppIdPath.get(), uid);
1039                 return false;
1040         }
1041
1042 #if 1
1043         for (i = 0; i < sizeof(mediaDir) / sizeof(struct _OspDir); ++i)
1044         {
1045                 ret = mkdir(mediaDir[i].path, mediaDir[i].mode);
1046                 if (ret == -1 && errno != 17) // EEXIST
1047                 {
1048                         SysLog(NID_IO, "mkdir() failed (%s), path: %s, mode: 0%o",
1049                                         strerror(errno), mediaDir[i].path, mediaDir[i].mode);
1050                         return false;
1051                 }
1052                 ret = chown(mediaDir[i].path, 5000, 5000);
1053                 SysTryReturn(NID_IO, ret == 0, false, E_SYSTEM,
1054                                 "[E_SYSTEM] chown() failed (%d, %s), path: %s, uid: 5000, gid: 5000",
1055                                 errno, strerror(errno), mediaDir[i].path);
1056         }
1057 #endif
1058
1059         // XXX: OSP compatible application's data packed in shared/data, shared/trusted directory of SDK
1060         // cannot be delivered.
1061 #if 0
1062         if (access("./shared/data", F_OK) == 0)
1063         {
1064                 char copyCmd[256] = { 0, };
1065                 sprintf(copyCmd, "cp -rf ./shared/data/* /opt/usr/share/.osp-compat/share/%ls/", pkgId.GetPointer());
1066                 ret = system(copyCmd);
1067                 SysTryReturn(NID_IO, ret != -1, false, E_SYSTEM, "Failed to copy command (%s)", copyCmd);
1068
1069                 SysTryReturn(NID_IO, system("rm -rf ./shared/data") != -1, false, E_SYSTEM,
1070                         "[E_SYSTEM] rmdir() failed, path: ./shared/data");
1071
1072                 char chownCmd[256] = { 0, };
1073                 sprintf(chownCmd, "chown -R 5000:5000 /opt/usr/share/.osp-compat/share/%ls/", pkgId.GetPointer());
1074                 SysTryReturn(NID_IO, system(chownCmd) != -1, false, E_SYSTEM, "[E_SYSTEM] chown() failed");
1075         }
1076 #endif
1077         String appSharedDataPath(appRootPath);
1078         appSharedDataPath.Append(L"/shared/data");
1079
1080         String appSharedTrustedPath(appRootPath);
1081         appSharedTrustedPath.Append(L"/shared/trusted");
1082
1083         SysTryReturn(NID_IO, Directory::Remove(appSharedDataPath, true) == E_SUCCESS, false, E_SYSTEM,
1084                         "[E_SYSTEM] Failed to remove path (%ls)", appSharedDataPath.GetPointer());
1085         SysTryReturn(NID_IO, Directory::Remove(appSharedTrustedPath, true) == E_SUCCESS, false, E_SYSTEM,
1086                         "[E_SYSTEM] Failed to remove path (%ls)", appSharedTrustedPath.GetPointer());
1087
1088         ret = symlink(pOspShareAppIdPath.get(), "./shared/data");
1089         SysTryReturn(NID_IO, ret == 0, false, E_SYSTEM,
1090                         "[E_SYSTEM] symlink() failed, errno: %d (%s), link: ./shared/data -> %s",
1091                         errno, strerror(errno), pOspShareAppIdPath.get());
1092         ret = symlink(pOspShare2AppIdPath.get(), "./shared/trusted");
1093         SysTryReturn(NID_IO, ret == 0, false, E_SYSTEM,
1094                         "[E_SYSTEM] symlink() failed, errno: %d (%s), link: ./shared/trusted -> %s",
1095                         errno, strerror(errno), pOspShare2AppIdPath.get());
1096
1097         return true;
1098 }
1099
1100 // TODO: Need to test this method.
1101 bool
1102 _FileImpl::CreateOspExternalDirectories(const String& pkgId)
1103 {
1104         unsigned int i = 0;
1105         int ret = 0;
1106         int uid = -1;
1107         struct _OspDir appSubDir[] = { // virtual path
1108 //              { "./data", 0700, true },
1109                 { "./System", 0000, false },                // mount from /opt/apps/com.samsung.osp/system
1110                 { "./Storagecard", 0705, false },
1111                 { "./Storagecard/Media", 0000, false }          // mount from /opt/storage/sdcard
1112         };
1113 #if 0
1114         struct _OspDir mediaDir[] = { // physical path
1115                 { "/opt/usr/media/Images", 0777, false },
1116                 { "/opt/usr/media/Sounds", 0777, false },
1117                 { "/opt/usr/media/Videos", 0777, false },
1118                 //{ "/opt/usr/media/Themes", 0777, false },
1119                 { "/opt/usr/media/Others", 0777, false }
1120         };
1121 #endif
1122
1123         for (i = 0; i < sizeof(appSubDir) / sizeof(struct _OspDir); i++)
1124         {
1125                 ret = mkdir(appSubDir[i].path, appSubDir[i].mode);
1126                 if (ret == -1 && errno != 17) // EEXIST
1127                 {
1128                         SysLog(NID_IO, "mkdir() failed (%s), path: %s, mode: 0%o",
1129                                                 strerror(errno), appSubDir[i].path, appSubDir[i].mode);
1130                         return false;
1131                 }
1132                 if (appSubDir[i].appPrivilege)
1133                 {
1134                         ret = chown(appSubDir[i].path, uid, uid);
1135                         if (ret == -1)
1136                         {
1137                                 SysLog(NID_IO, "chown() failed (%s), path: %s, uid: %d",
1138                                                         strerror(errno), appSubDir[i].path, uid);
1139                                 return false;
1140                         }
1141                 }
1142         }
1143
1144 #if 0
1145         for (i = 0; i < sizeof(mediaDir) / sizeof(struct _OspDir); i++)
1146         {
1147                 ret = mkdir(mediaDir[i].path, mediaDir[i].mode);
1148                 if (ret == -1 && errno != 17) // EEXIST
1149                 {
1150                         SysLog(NID_IO, "mkdir() failed (%s), path: %s, mode: 0%o",
1151                                                 strerror(errno), mediaDir[i].path, mediaDir[i].mode);
1152                         return false;
1153                 }
1154         }
1155 #endif
1156
1157         return true;
1158 }
1159
1160 bool
1161 _FileImpl::CreateSlpDirectories(void)
1162 {
1163         unsigned int i = 0;
1164         int ret = 0;
1165         struct _OspDir slpDir[] = { // virtual path
1166                 //{ "./bin", 0000, false },     // mount from /bin
1167                 //{ "./boot", 0000,     false },
1168                 //{ "./cache", 0000, false },
1169                 { "./csa", 0000, false },
1170                 { "./dev", 0000, false },
1171                 { "./etc", 0000, false },
1172                 { "./lib", 0000, false },
1173                 //{ "./lost+found",     0000, false },
1174                 { "./media", 0000, false },
1175                 { "./mnt", 0000, false },
1176                 { "./opt", 0000, false },
1177                 //{ "./packaging", 0000, false },
1178                 { "./proc", 0000, false },
1179                 { "./sbin", 0000, false },
1180                 { "./smack", 0000, false },
1181                 { "./srv", 0000, false },
1182                 { "./sys", 0000, false },
1183                 { "./tmp", 0000, false },
1184                 { "./usr", 0000, false },
1185                 { "./var", 0000, false }
1186         };
1187
1188         for (i = 0; i < sizeof(slpDir) / sizeof(struct _OspDir); i++)
1189         {
1190                 ret = mkdir(slpDir[i].path, slpDir[i].mode);
1191                 if (ret == -1 && errno != 17) // EEXIST
1192                 {
1193                         SysLog(NID_IO, "mkdir() failed (%s), path: %s, mode: 0%o",
1194                                                 strerror(errno), slpDir[i].path, slpDir[i].mode);
1195                         return false;
1196                 }
1197         }
1198
1199         return true;
1200 }
1201
1202 bool
1203 _FileImpl::CreateSymbolicLink(void)
1204 {
1205         struct _LinkDir linkDirList[] = {
1206                 { "/opt/home",          "./home" },
1207                 { "/opt/home/root",     "./root" },
1208                 { "/mnt/mmc",           "./sdcard" }
1209         };
1210
1211         for (unsigned int i = 0; i < sizeof(linkDirList) / sizeof(struct _LinkDir); ++i)
1212         {
1213                 int ret = symlink(linkDirList[i].srcPath, linkDirList[i].destPath);
1214                 if (ret == -1 && errno != 17) // EEXIST
1215                 {
1216                         SysLog(NID_IO, "Failed to create symbolic link, errno: %d (%s), src path: %s, dest path: %s",
1217                                         strerror(errno), linkDirList[i].srcPath, linkDirList[i].destPath);
1218                         return false;
1219                 }
1220         }
1221
1222         return true;
1223 }
1224
1225 bool
1226 _FileImpl::VerifyFilePathCompatibility(const String& filePath, bool ospCompat)
1227 {
1228         if (ospCompat == true)
1229         {
1230                 if (filePath[0] != L'/')
1231                 {
1232                         return false;
1233                 }
1234         }
1235         int length = filePath.GetLength();
1236         if (length > 0)
1237         {
1238                 return true;
1239         }
1240         return false;
1241 }
1242
1243 _FileImpl*
1244 _FileImpl::GetInstance(File& file)
1245 {
1246         return file.__pFileImpl;
1247 }
1248
1249 const _FileImpl*
1250 _FileImpl::GetInstance(const File& file)
1251 {
1252         return file.__pFileImpl;
1253 }
1254
1255 result
1256 _FileImpl::ConvertVirtualToPhysicalPath(const String& virtualPath, String& physicalPath) // for 2.0 app
1257 {
1258         SysTryReturnResult(NID_IO, VerifyFilePathCompatibility(virtualPath, _AppInfo::IsOspCompat()) == true,
1259                         E_INVALID_ARG, "[E_INVALID_ARG] %ls is not compatible.", virtualPath.GetPointer());
1260
1261         const wchar_t* virtualPathPrefix[] =
1262         {
1263                 L"/Home/Share2",
1264                 L"/Home/Share",
1265                 L"/Home",
1266                 L"/Res",
1267                 L"/Share2",
1268                 L"/Share/AppControl",
1269                 L"/Share",
1270                 //L"/HomeExt",
1271                 //L"/ShareExt",
1272                 //L"/Share2Ext",
1273                 //L"/NPKI",
1274                 L"/Media",
1275                 L"/Storagecard/Media",
1276                 //L"/Storagecard/NPKI",
1277         };
1278         result r = E_SUCCESS;
1279         int count = sizeof(virtualPathPrefix)/sizeof(wchar_t*);
1280         int i = 0;
1281
1282         for (i = 0; i < count; i++)
1283         {
1284                 SysLog(NID_IO, "[V2P] i: %d, path: %ls", i, virtualPathPrefix[i]);
1285                 if (virtualPath.StartsWith(virtualPathPrefix[i], 0) == true)
1286                 {
1287                         break;
1288                 }
1289         }
1290         SysTryReturnResult(NID_IO, i != count, E_INVALID_ARG, "The path (%ls) is not matched.",
1291                         virtualPath.GetPointer());
1292
1293         int prefixLen = String(virtualPathPrefix[i]).GetLength();
1294         if (virtualPath.GetLength() > prefixLen)
1295         {
1296                 wchar_t ch = '\0';
1297
1298                 r = virtualPath.GetCharAt(prefixLen, ch);
1299                 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] The path (%ls) is not matched.",
1300                                 GetErrorMessage(r), virtualPath.GetPointer());
1301
1302                 if (ch != L'/')
1303                 {
1304                         physicalPath.Clear();
1305                         SysLog(NID_IO, "[E_INVALID_ARG] The path (%ls) is not matched.",
1306                                         virtualPath.GetPointer());
1307
1308                         return E_INVALID_ARG;
1309                 }
1310         }
1311
1312         String subPath;
1313         virtualPath.SubString(wcslen(virtualPathPrefix[i]), subPath);
1314
1315         Tizen::App::App* pApp = Tizen::App::App::GetInstance();
1316         SysTryReturnResult(NID_IO, pApp != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
1317         String homePath = pApp->GetAppRootPath();
1318         String ospCompatSharedPath = _EnvironmentImpl::GetOspCompatSharedPath();
1319
1320         switch (i)
1321         {
1322         case 0:
1323                 physicalPath = homePath + L"data/Share2";
1324                 break;
1325         case 1:
1326                 physicalPath = homePath + L"data/Share";
1327                 break;
1328         case 2:
1329                 physicalPath = homePath + L"data";
1330                 break;
1331         case 3:
1332                 physicalPath = homePath + L"res";
1333                 break;
1334         case 4:
1335                 physicalPath = ospCompatSharedPath + L"share2";
1336                 break;
1337         case 5:
1338                 physicalPath = ospCompatSharedPath + L"share/AppControl";
1339                 break;
1340         case 6:
1341                 physicalPath = ospCompatSharedPath + L"share";
1342                 break;
1343         case 7:
1344                 physicalPath = Tizen::System::Environment::GetMediaPath();
1345                 break;
1346         case 8:
1347                 physicalPath = Tizen::System::Environment::GetExternalStoragePath() + L"Media";
1348                 break;
1349         default:
1350                 SysLog(NID_IO, "[E_INVALID_ARG] The path (%ls) is not matched.",
1351                                 virtualPath.GetPointer());
1352                 return E_INVALID_ARG;
1353         }
1354
1355         if (subPath.IsEmpty() == false)
1356         {
1357                 physicalPath.Append(subPath);
1358         }
1359
1360         return r;
1361 }
1362
1363 result
1364 _FileImpl::ConvertPhysicalToVirtualPath(const String& physicalPath, String& virtualPath) // for 2.0 app
1365 {
1366         result r = E_SUCCESS;
1367         const wchar_t* homeSubDir[] = {
1368                 L"/data/Share2",
1369                 L"/data/Share",
1370                 L"/data",
1371                 L"/res",
1372         };
1373         const wchar_t* ospHomeSubDir[] = {
1374                 L"/share2",
1375                 L"/share/AppControl",
1376                 L"/share",
1377         };
1378         String subPath;
1379         int homeSubDirCount = sizeof(homeSubDir)/sizeof(wchar_t*);
1380         int ospHomeSubDirCount = sizeof(ospHomeSubDir)/sizeof(wchar_t*);
1381         int baseDirLen = 0;
1382         int i = 0;
1383
1384         SysLog(NID_IO, "[P2V] physicalPath: %ls", physicalPath.GetPointer());
1385
1386         Tizen::App::App* pApp = Tizen::App::App::GetInstance();
1387         SysTryReturnResult(NID_IO, pApp != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
1388         String homePath = pApp->GetAppRootPath();
1389         homePath.SetLength(homePath.GetLength() - 1);
1390
1391         String ospCompatSharedPath = _EnvironmentImpl::GetOspCompatSharedPath();
1392         ospCompatSharedPath.SetLength(ospCompatSharedPath.GetLength() - 1);
1393
1394         String mediaPath = Tizen::System::Environment::GetMediaPath();
1395         mediaPath.SetLength(mediaPath.GetLength() - 1);
1396
1397         String externalPath = Tizen::System::Environment::GetExternalStoragePath();
1398         externalPath.SetLength(externalPath.GetLength() - 1);
1399
1400         if (physicalPath.StartsWith(homePath, 0) == true)
1401         {
1402                 physicalPath.SubString(homePath.GetLength(), subPath);
1403
1404                 for (i = 0; i < homeSubDirCount; i++)
1405                 {
1406                         SysLog(NID_IO, "[P2V] i: %d, path: %ls", i, homeSubDir[i]);
1407                         if (subPath.StartsWith(homeSubDir[i], 0) == true)
1408                         {
1409                                 break;
1410                         }
1411                 }
1412                 SysTryReturnResult(NID_IO, i != homeSubDirCount, E_INVALID_ARG, "The path (%ls) is not matched.",
1413                                 physicalPath.GetPointer());
1414
1415                 baseDirLen = homePath.GetLength() + String(homeSubDir[i]).GetLength();
1416
1417                 switch (i)
1418                 {
1419                 case 0:
1420                         virtualPath = L"/Home/Share2";
1421                         break;
1422                 case 1:
1423                         virtualPath = L"/Home/Share";
1424                         break;
1425                 case 2:
1426                         virtualPath = L"/Home";
1427                         break;
1428                 case 3:
1429                         virtualPath = L"/Res";
1430                         break;
1431                 default:
1432                         break;
1433                 }
1434
1435         }
1436         else if (physicalPath.StartsWith(ospCompatSharedPath, 0) == true)
1437         {
1438                 physicalPath.SubString(ospCompatSharedPath.GetLength(), subPath);
1439
1440                 for (i = 0; i < ospHomeSubDirCount; i++)
1441                 {
1442                         SysLog(NID_IO, "[P2V] i: %d, path: %ls", i, ospHomeSubDir[i]);
1443                         if (subPath.StartsWith(ospHomeSubDir[i], 0) == true)
1444                         {
1445                                 break;
1446                         }
1447                 }
1448                 SysTryReturnResult(NID_IO, i != ospHomeSubDirCount, E_INVALID_ARG, "The path (%ls) is not matched.",
1449                                 physicalPath.GetPointer());
1450
1451                 baseDirLen = ospCompatSharedPath.GetLength() + String(ospHomeSubDir[i]).GetLength();
1452
1453                 switch (i)
1454                 {
1455                 case 0:
1456                         virtualPath = L"/Share2";
1457                         break;
1458                 case 1:
1459                         virtualPath = L"/Share/AppControl";
1460                         break;
1461                 case 2:
1462                         virtualPath = L"/Share";
1463                         break;
1464                 default:
1465                         break;
1466                 }
1467         }
1468         else if (physicalPath.StartsWith(mediaPath, 0) == true)
1469         {
1470                 SysLog(NID_IO, "[P2V] media");
1471                 virtualPath = L"/Media";
1472                 baseDirLen = mediaPath.GetLength();
1473         }
1474         else if (physicalPath.StartsWith(externalPath, 0) == true)
1475         {
1476                 SysLog(NID_IO, "[P2V] external media");
1477                 virtualPath = L"/Storagecard/Media";
1478                 baseDirLen = externalPath.GetLength();
1479         }
1480         else
1481         {
1482                 SysLog(NID_IO, "[E_INVALID_ARG] The path (%ls) is not matched.",
1483                                 physicalPath.GetPointer());
1484
1485                 return E_INVALID_ARG;
1486         }
1487
1488         if (physicalPath.GetLength() > baseDirLen)
1489         {
1490                 wchar_t ch = '\0';
1491
1492                 r = physicalPath.GetCharAt(baseDirLen, ch);
1493                 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] The path (%ls) is not matched.",
1494                                 GetErrorMessage(r), physicalPath.GetPointer());
1495
1496                 if (ch != L'/')
1497                 {
1498                         virtualPath.Clear();
1499                         SysLog(NID_IO, "[E_INVALID_ARG] The path (%ls) is not matched.",
1500                                         physicalPath.GetPointer());
1501
1502                         return E_INVALID_ARG;
1503                 }
1504         }
1505
1506         subPath.Clear();
1507         physicalPath.SubString(baseDirLen, subPath);
1508
1509         if (subPath.IsEmpty() == false)
1510         {
1511                 virtualPath.Append(subPath);
1512         }
1513
1514         return r;
1515 }
1516
1517 }} // Tizen::Io