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         SysLog(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(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                 { "./srv" },
 800                 { "./sys/kernel/debug" },
 801                 { "./sys" },
 802                 { "./tmp" },
 803                 { "./usr" },
 804                 { "./var/run" },
 805                 { "./var" },
 806
 807                 { "./data/Share" },
 808                 { "./data/Share2" },
 809                 { "./Share" },
 810                 { "./Share2" },
 811                 //{ "./Clipboard" },
 812                 //{ "./NPKI" },
 813                 //{ "./System" },
 814                 //{ "./Tmp" },
 815                 { "./Media" },
 816
 817                 { "./Storagecard/Media" },
 818         { "./ShareExt" },
 819         { "./Share2Ext" },
 820         { "./HomeExt/Share" },
 821         { "./HomeExt/Share2" },
 822         { "./HomeExt" }
 823         };
 824
 825         unique_ptr< char[] > pAppRootPath(_StringConverter::CopyToCharArrayN(appRootPath));
 826         SysTryReturn(NID_IO, pAppRootPath != null, false, E_OUT_OF_MEMORY,
 827                         "[E_OUT_OF_MEMORY] The memory is insufficient.");
 828
 829         SysTryReturn(NID_IO, chdir(pAppRootPath.get()) == 0, false, E_SYSTEM,
 830                         "[E_SYSTEM] chdir() failed (%d, %s), path: %ls", errno, strerror(errno), appRootPath.GetPointer());
 831
 832         for (int i = 0; i < sizeof(mountPath) / sizeof(struct _PathInfo); ++i)
 833         {
 834                 int ret = umount2(mountPath[i].destPath, MNT_DETACH);
 835                 SysTryLog(NID_IO, ret == 0, "umount2() errno: %d (%s)", errno, strerror(errno));
 836                 SysTryReturn(NID_IO, ret == 0 || errno == EINVAL || errno == ENOENT, false, E_SYSTEM,
 837                                 "[E_SYSTEM] umount2() failed (%d, %s), path: %s", errno, strerror(errno), mountPath[i].destPath);
 838         }
 839
 840         char* pkgId = strrchr(pAppRootPath.get(), '/');
 841         char mountFlag[_MAX_PATH_LENGTH] = { 0, };
 842         sprintf(mountFlag, "%s/%s", _INTERNAL_MOUNT_FLAG, ++pkgId);
 843         int res = unlink(mountFlag);
 844         if (res == -1 && errno != ENOENT)
 845         {
 846                 SysLogException(NID_IO, E_SYSTEM, "[E_SYSTEM] Failed to remove mount flag (%s), errno: %d (%s)",
 847                                 mountFlag, errno, strerror(errno));
 848                 return false;
 849         }
 850
 851         memset(mountFlag, 0, _MAX_PATH_LENGTH);
 852         sprintf(mountFlag, "%s/%s", _EXTERNAL_MOUNT_FLAG, pkgId);
 853         res = unlink(mountFlag);
 854         if (res == -1 && errno != ENOENT)
 855         {
 856                 SysLogException(NID_IO, E_SYSTEM, "[E_SYSTEM] Failed to remove mount flag (%s), errno: %d (%s)",
 857                                 mountFlag, errno, strerror(errno));
 858                 return false;
 859         }
 860
 861         SysLog(NID_IO, "[data_caging] FinalizeDataCaging() succeeded, appRootPath: %ls", appRootPath.GetPointer());
 862         return true;
 863 }
 864
 865 int
 866 _FileImpl::GetAvailableUid(void)
 867 {
 868         return _APP_UID;
 869 }
 870
 871 bool
 872 _FileImpl::CreateOspApplicationDirectories(const String& appRootPath, const String& pkgId) // for 2.0 app
 873 {
 874 #if 0
 875         struct _OspDir appSubDir[] =
 876         {
 877                 //{ "./shared\0",                       0755, false },
 878                 //{ "./shared/data\0",          0755, true },
 879                 //{ "./shared/res\0",           0755, false },
 880                 //{ "./shared/trusted\0",       0755, true },
 881                 //{ "./cache\0", 0700, true }
 882         };
 883         int uid = -1;
 884         int ret = 0;
 885         unsigned int i = 0;
 886         result r = E_SUCCESS;
 887 #endif
 888
 889         SysTryReturn(NID_IO, CleanDirectories(appRootPath, pkgId) == true, false, E_SYSTEM,
 890                         "[E_SYSTEM] Failed to clean directories for 2.0 application compatibility.");
 891
 892 #if 0
 893         unique_ptr<char[]> pAppRootPath(_StringConverter::CopyToCharArrayN(appRootPath));
 894         SysTryReturn(NID_IO, pAppRootPath != null, false, E_SYSTEM, "[E_SYSTEM] The memory is insufficient.");
 895
 896         SysTryReturn(NID_IO, chdir(pAppRootPath.get()) == 0, false, E_SYSTEM,
 897                         "[E_SYSTEM] chdir() failed (%d, %s), path: %s", errno, strerror(errno), pAppRootPath.get());
 898
 899         uid = GetAvailableUid();
 900
 901         umask(0000);
 902
 903         for (i = 0; i < sizeof(appSubDir) / sizeof(struct _OspDir); ++i)
 904         {
 905                 ret = mkdir(appSubDir[i].path, appSubDir[i].mode);
 906                 if (ret == -1 && errno != 17) // EEXIST
 907                 {
 908                         SysLog(NID_IO, "[E_SYSTEM] mkdir() failed (%d, %s), path: %s, mode: 0%o",
 909                                         errno, strerror(errno), appSubDir[i].path, appSubDir[i].mode);
 910                         goto CATCH;
 911                 }
 912
 913                 if (appSubDir[i].appPrivilege)
 914                 {
 915                         ret = chown(appSubDir[i].path, uid, uid);
 916                         SysTryCatch(NID_IO, ret == 0, , E_SYSTEM,
 917                                         "[E_SYSTEM] chown() failed (%d, %s), path: %s, uid: %d",
 918                                         errno, strerror(errno), appSubDir[i].path, uid);
 919                 }
 920         }
 921
 922         umask(0022);
 923
 924         SysLog(NID_IO, "_FileImpl::CreateOspApplicationDirectories() succeeded.");
 925         return true;
 926
 927 CATCH:
 928         umask(0022);
 929
 930         return false;
 931 #else
 932         return true;
 933 #endif
 934
 935 }
 936
 937 bool
 938 _FileImpl::CreateOspInternalDirectories(const String& pkgId) // for 2.0 app
 939 {
 940         unsigned int i = 0;
 941         int ret = 0;
 942         int uid = -1;
 943         struct _OspDir appSubDir[] =
 944         {
 945 //              { "./data",                     0700, true },   // It is created by installer.
 946                 { "./shared",           0755, false },
 947                 { "./data/Share",       0000, true },   // mount from /opt/usr/share/.osp-compat/share/{pkgId}
 948                 { "./data/Share2",      0000, true },   // mount from /opt/usr/share/.osp-compat/share2/{pkgId}
 949                 { "./Share",            0000, false },  // mount from /opt/usr/share/.osp-compat/share
 950                 { "./Share2",           0000, false },  // mount from /opt/usr/share/.osp-compat/share2
 951 //              { "./Clipboard",        0000, false },
 952 //              { "./NPKI",                     0000, false },
 953 //              { "./System",           0000, false },
 954 //              { "./Tmp",                      0000, false },
 955                 { "./Media",            0000, false },  // mount from /opt/usr/media
 956                 { "./Storagecard",      0705, false },
 957                 { "./Storagecard/Media", 0000, false }, // mount from /opt/storage/sdcard
 958         };
 959 #if 1
 960         struct _OspDir mediaDir[] =
 961         {
 962                 { "/opt/usr/media/Images", 0777, false },
 963                 { "/opt/usr/media/Sounds", 0777, false },
 964                 { "/opt/usr/media/Videos", 0777, false },
 965                 //{ "/opt/usr/media/Themes", 0777, false },
 966                 { "/opt/usr/media/Others", 0777, false }
 967         };
 968 #endif
 969         String ospCompatSharedPath = _EnvironmentImpl::GetOspCompatSharedPath();
 970         String ospShareAppIdPath(L"share/");
 971         String ospShare2AppIdPath(L"share2/");
 972         result r = E_SUCCESS;
 973
 974         r = ospShareAppIdPath.Insert(ospCompatSharedPath, 0);
 975         SysTryReturn(NID_IO, !IsFailed(r), false, E_SYSTEM,
 976                         "[E_SYSTEM] String::Insert() failed. (error: %s)", GetErrorMessage(r));
 977
 978         r = ospShare2AppIdPath.Insert(ospCompatSharedPath, 0);
 979         SysTryReturn(NID_IO, !IsFailed(r), false, E_SYSTEM,
 980                         "[E_SYSTEM] String::Insert() failed. (error: %s)", GetErrorMessage(r));
 981
 982         uid = GetAvailableUid();
 983
 984         for (i = 0; i < sizeof(appSubDir) / sizeof(struct _OspDir); i++)
 985         {
 986                 ret = mkdir(appSubDir[i].path, appSubDir[i].mode);
 987                 if (ret == -1 && errno != 17) // EEXIST
 988                 {
 989                         SysLog(NID_IO, "mkdir() failed (%s), path: %s, mode: 0%o",
 990                                                 strerror(errno), appSubDir[i].path, appSubDir[i].mode);
 991                         return false;
 992                 }
 993                 if (appSubDir[i].appPrivilege)
 994                 {
 995                         ret = chown(appSubDir[i].path, uid, uid);
 996                         if (ret == -1)
 997                         {
 998                                 SysLog(NID_IO, "chown() failed (%s), path: %s, uid: %d",
 999                                                         strerror(errno), appSubDir[i].path, uid);
1000                                 return false;
1001                         }
1002                 }
1003         }
1004
1005         ospShareAppIdPath.Append(pkgId);
1006         unique_ptr<char[]> pOspShareAppIdPath(_StringConverter::CopyToCharArrayN(ospShareAppIdPath));
1007         SysTryReturn(NID_IO, pOspShareAppIdPath != null, false, E_SYSTEM, "[E_SYSTEM] The memory is insufficient.");
1008         ret = mkdir(pOspShareAppIdPath.get(), 0705);
1009         if (ret == -1 && errno != 17) // EEXIST
1010         {
1011                 SysLog(NID_IO, "mkdir() failed (%s), path: %s, mode: 0%o",
1012                                         strerror(errno), pOspShareAppIdPath.get(), 0705);
1013                 return false;
1014         }
1015         ret = chown(pOspShareAppIdPath.get(), uid, uid);
1016         if (ret == -1)
1017         {
1018                 SysLog(NID_IO, "chown() failed (%s), path: %s, uid: %d",
1019                                         strerror(errno), pOspShareAppIdPath.get(), uid);
1020                 return false;
1021         }
1022
1023         ospShare2AppIdPath.Append(pkgId);
1024         unique_ptr<char[]> pOspShare2AppIdPath(_StringConverter::CopyToCharArrayN(ospShare2AppIdPath));
1025         SysTryReturn(NID_IO, pOspShare2AppIdPath != null, false, E_SYSTEM, "[E_SYSTEM] The memory is insufficient.");
1026         ret = mkdir(pOspShare2AppIdPath.get(), 0705);    // TODO: change to 0770
1027         if (ret == -1 && errno != 17) // EEXIST
1028         {
1029                 SysLog(NID_IO, "mkdir() failed (%s), path: %s, mode: 0%o",
1030                                         strerror(errno), pOspShare2AppIdPath.get(), 0705);
1031                 return false;
1032         }
1033         ret = chown(pOspShare2AppIdPath.get(), uid, uid);
1034         if (ret == -1)
1035         {
1036                 SysLog(NID_IO, "chown() failed (%s), path: %s, uid: %d",
1037                                         strerror(errno), pOspShare2AppIdPath.get(), uid);
1038                 return false;
1039         }
1040
1041 #if 1
1042         for (i = 0; i < sizeof(mediaDir) / sizeof(struct _OspDir); ++i)
1043         {
1044                 ret = mkdir(mediaDir[i].path, mediaDir[i].mode);
1045                 if (ret == -1 && errno != 17) // EEXIST
1046                 {
1047                         SysLog(NID_IO, "mkdir() failed (%s), path: %s, mode: 0%o",
1048                                         strerror(errno), mediaDir[i].path, mediaDir[i].mode);
1049                         return false;
1050                 }
1051                 ret = chown(mediaDir[i].path, 5000, 5000);
1052                 SysTryReturn(NID_IO, ret == 0, false, E_SYSTEM,
1053                                 "[E_SYSTEM] chown() failed (%d, %s), path: %s, uid: 5000, gid: 5000",
1054                                 errno, strerror(errno), mediaDir[i].path);
1055         }
1056 #endif
1057
1058         // XXX: OSP compatible application's data packed in shared/data, shared/trusted directory of SDK
1059         // cannot be delivered.
1060 #if 0
1061         if (access("./shared/data", F_OK) == 0)
1062         {
1063                 char copyCmd[256] = { 0, };
1064                 sprintf(copyCmd, "cp -rf ./shared/data/* /opt/usr/share/.osp-compat/share/%ls/", pkgId.GetPointer());
1065                 ret = system(copyCmd);
1066                 SysTryReturn(NID_IO, ret != -1, false, E_SYSTEM, "Failed to copy command (%s)", copyCmd);
1067
1068                 SysTryReturn(NID_IO, system("rm -rf ./shared/data") != -1, false, E_SYSTEM,
1069                         "[E_SYSTEM] rmdir() failed, path: ./shared/data");
1070
1071                 char chownCmd[256] = { 0, };
1072                 sprintf(chownCmd, "chown -R 5000:5000 /opt/usr/share/.osp-compat/share/%ls/", pkgId.GetPointer());
1073                 SysTryReturn(NID_IO, system(chownCmd) != -1, false, E_SYSTEM, "[E_SYSTEM] chown() failed");
1074         }
1075 #endif
1076         ret = remove("./shared/data");
1077         SysTryReturn(NID_IO, ret == 0 || errno == ENOENT, false, E_SYSTEM,
1078                         "[E_SYSTEM] remove() failed, errno: %d (%s), path: ./shared/data", errno, strerror(errno));
1079         ret = remove("./shared/trusted");
1080         SysTryReturn(NID_IO, ret == 0 || errno == ENOENT, false, E_SYSTEM,
1081                         "[E_SYSTEM] remove() failed, errno: %d (%s), path: ./shared/trusted", errno, strerror(errno));
1082
1083         ret = symlink(pOspShareAppIdPath.get(), "./shared/data");
1084         SysTryReturn(NID_IO, ret == 0, false, E_SYSTEM,
1085                         "[E_SYSTEM] symlink() failed, errno: %d (%s), link: ./shared/data -> %s",
1086                         errno, strerror(errno), pOspShareAppIdPath.get());
1087         ret = symlink(pOspShare2AppIdPath.get(), "./shared/trusted");
1088         SysTryReturn(NID_IO, ret == 0, false, E_SYSTEM,
1089                         "[E_SYSTEM] symlink() failed, errno: %d (%s), link: ./shared/trusted -> %s",
1090                         errno, strerror(errno), pOspShare2AppIdPath.get());
1091
1092         return true;
1093 }
1094
1095 // TODO: Need to test this method.
1096 bool
1097 _FileImpl::CreateOspExternalDirectories(const String& pkgId)
1098 {
1099         unsigned int i = 0;
1100         int ret = 0;
1101         int uid = -1;
1102         struct _OspDir appSubDir[] = { // virtual path
1103 //              { "./data", 0700, true },
1104                 { "./System", 0000, false },                // mount from /opt/apps/com.samsung.osp/system
1105                 { "./Storagecard", 0705, false },
1106                 { "./Storagecard/Media", 0000, false }          // mount from /opt/storage/sdcard
1107         };
1108 #if 0
1109         struct _OspDir mediaDir[] = { // physical path
1110                 { "/opt/usr/media/Images", 0777, false },
1111                 { "/opt/usr/media/Sounds", 0777, false },
1112                 { "/opt/usr/media/Videos", 0777, false },
1113                 //{ "/opt/usr/media/Themes", 0777, false },
1114                 { "/opt/usr/media/Others", 0777, false }
1115         };
1116 #endif
1117
1118         for (i = 0; i < sizeof(appSubDir) / sizeof(struct _OspDir); i++)
1119         {
1120                 ret = mkdir(appSubDir[i].path, appSubDir[i].mode);
1121                 if (ret == -1 && errno != 17) // EEXIST
1122                 {
1123                         SysLog(NID_IO, "mkdir() failed (%s), path: %s, mode: 0%o",
1124                                                 strerror(errno), appSubDir[i].path, appSubDir[i].mode);
1125                         return false;
1126                 }
1127                 if (appSubDir[i].appPrivilege)
1128                 {
1129                         ret = chown(appSubDir[i].path, uid, uid);
1130                         if (ret == -1)
1131                         {
1132                                 SysLog(NID_IO, "chown() failed (%s), path: %s, uid: %d",
1133                                                         strerror(errno), appSubDir[i].path, uid);
1134                                 return false;
1135                         }
1136                 }
1137         }
1138
1139 #if 0
1140         for (i = 0; i < sizeof(mediaDir) / sizeof(struct _OspDir); i++)
1141         {
1142                 ret = mkdir(mediaDir[i].path, mediaDir[i].mode);
1143                 if (ret == -1 && errno != 17) // EEXIST
1144                 {
1145                         SysLog(NID_IO, "mkdir() failed (%s), path: %s, mode: 0%o",
1146                                                 strerror(errno), mediaDir[i].path, mediaDir[i].mode);
1147                         return false;
1148                 }
1149         }
1150 #endif
1151
1152         return true;
1153 }
1154
1155 bool
1156 _FileImpl::CreateSlpDirectories(void)
1157 {
1158         unsigned int i = 0;
1159         int ret = 0;
1160         struct _OspDir slpDir[] = { // virtual path
1161                 //{ "./bin", 0000, false },     // mount from /bin
1162                 //{ "./boot", 0000,     false },
1163                 //{ "./cache", 0000, false },
1164                 { "./csa", 0000, false },
1165                 { "./dev", 0000, false },
1166                 { "./etc", 0000, false },
1167                 { "./lib", 0000, false },
1168                 //{ "./lost+found",     0000, false },
1169                 { "./media", 0000, false },
1170                 { "./mnt", 0000, false },
1171                 { "./opt", 0000, false },
1172                 //{ "./packaging", 0000, false },
1173                 { "./proc", 0000, false },
1174                 { "./sbin", 0000, false },
1175                 { "./srv", 0000, false },
1176                 { "./sys", 0000, false },
1177                 { "./tmp", 0000, false },
1178                 { "./usr", 0000, false },
1179                 { "./var", 0000, false }
1180         };
1181
1182         for (i = 0; i < sizeof(slpDir) / sizeof(struct _OspDir); i++)
1183         {
1184                 ret = mkdir(slpDir[i].path, slpDir[i].mode);
1185                 if (ret == -1 && errno != 17) // EEXIST
1186                 {
1187                         SysLog(NID_IO, "mkdir() failed (%s), path: %s, mode: 0%o",
1188                                                 strerror(errno), slpDir[i].path, slpDir[i].mode);
1189                         return false;
1190                 }
1191         }
1192
1193         return true;
1194 }
1195
1196 bool
1197 _FileImpl::CreateSymbolicLink(void)
1198 {
1199         struct _LinkDir linkDirList[] = {
1200                 { "/opt/home",          "./home" },
1201                 { "/opt/home/root",     "./root" },
1202                 { "/mnt/mmc",           "./sdcard" }
1203         };
1204
1205         for (unsigned int i = 0; i < sizeof(linkDirList) / sizeof(struct _LinkDir); ++i)
1206         {
1207                 int ret = symlink(linkDirList[i].srcPath, linkDirList[i].destPath);
1208                 if (ret == -1 && errno != 17) // EEXIST
1209                 {
1210                         SysLog(NID_IO, "Failed to create symbolic link, errno: %d (%s), src path: %s, dest path: %s",
1211                                         strerror(errno), linkDirList[i].srcPath, linkDirList[i].destPath);
1212                         return false;
1213                 }
1214         }
1215
1216         return true;
1217 }
1218
1219 bool
1220 _FileImpl::VerifyFilePathCompatibility(const String& filePath, bool ospCompat)
1221 {
1222         if (ospCompat == true)
1223         {
1224                 if (filePath[0] != L'/')
1225                 {
1226                         return false;
1227                 }
1228         }
1229         int length = filePath.GetLength();
1230         if (length > 0)
1231         {
1232                 return true;
1233         }
1234         return false;
1235 }
1236
1237 _FileImpl*
1238 _FileImpl::GetInstance(File& file)
1239 {
1240         return file.__pFileImpl;
1241 }
1242
1243 const _FileImpl*
1244 _FileImpl::GetInstance(const File& file)
1245 {
1246         return file.__pFileImpl;
1247 }
1248
1249 result
1250 _FileImpl::ConvertVirtualToPhysicalPath(const String& virtualPath, String& physicalPath) // for 2.0 app
1251 {
1252         SysTryReturnResult(NID_IO, VerifyFilePathCompatibility(virtualPath, _AppInfo::IsOspCompat()) == true,
1253                         E_INVALID_ARG, "[E_INVALID_ARG] %ls is not compatible.", virtualPath.GetPointer());
1254
1255         const wchar_t* virtualPathPrefix[] =
1256         {
1257                 L"/Home/Share2",
1258                 L"/Home/Share",
1259                 L"/Home",
1260                 L"/Res",
1261                 L"/Share2",
1262                 L"/Share/AppControl",
1263                 L"/Share",
1264                 //L"/HomeExt",
1265                 //L"/ShareExt",
1266                 //L"/Share2Ext",
1267                 //L"/NPKI",
1268                 L"/Media",
1269                 L"/Storagecard/Media",
1270                 //L"/Storagecard/NPKI",
1271         };
1272         result r = E_SUCCESS;
1273         int count = sizeof(virtualPathPrefix)/sizeof(wchar_t*);
1274         int i = 0;
1275
1276         for (i = 0; i < count; i++)
1277         {
1278                 SysLog(NID_IO, "[V2P] i: %d, path: %ls", i, virtualPathPrefix[i]);
1279                 if (virtualPath.StartsWith(virtualPathPrefix[i], 0) == true)
1280                 {
1281                         break;
1282                 }
1283         }
1284         SysTryReturnResult(NID_IO, i != count, E_INVALID_ARG, "The path (%ls) is not matched.",
1285                         virtualPath.GetPointer());
1286
1287         int prefixLen = String(virtualPathPrefix[i]).GetLength();
1288         if (virtualPath.GetLength() > prefixLen)
1289         {
1290                 wchar_t ch = '\0';
1291
1292                 r = virtualPath.GetCharAt(prefixLen, ch);
1293                 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] The path (%ls) is not matched.",
1294                                 GetErrorMessage(r), virtualPath.GetPointer());
1295
1296                 if (ch != L'/')
1297                 {
1298                         physicalPath.Clear();
1299                         SysLog(NID_IO, "[E_INVALID_ARG] The path (%ls) is not matched.",
1300                                         virtualPath.GetPointer());
1301
1302                         return E_INVALID_ARG;
1303                 }
1304         }
1305
1306         String subPath;
1307         virtualPath.SubString(wcslen(virtualPathPrefix[i]), subPath);
1308
1309         Tizen::App::App* pApp = Tizen::App::App::GetInstance();
1310         SysTryReturnResult(NID_IO, pApp != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
1311         String homePath = pApp->GetAppRootPath();
1312         String ospCompatSharedPath = _EnvironmentImpl::GetOspCompatSharedPath();
1313
1314         switch (i)
1315         {
1316         case 0:
1317                 physicalPath = homePath + L"data/Share2";
1318                 break;
1319         case 1:
1320                 physicalPath = homePath + L"data/Share";
1321                 break;
1322         case 2:
1323                 physicalPath = homePath + L"data";
1324                 break;
1325         case 3:
1326                 physicalPath = homePath + L"res";
1327                 break;
1328         case 4:
1329                 physicalPath = ospCompatSharedPath + L"share2";
1330                 break;
1331         case 5:
1332                 physicalPath = ospCompatSharedPath + L"share/AppControl";
1333                 break;
1334         case 6:
1335                 physicalPath = ospCompatSharedPath + L"share";
1336                 break;
1337         case 7:
1338                 physicalPath = Tizen::System::Environment::GetMediaPath();
1339                 break;
1340         case 8:
1341                 physicalPath = Tizen::System::Environment::GetExternalStoragePath() + L"Media";
1342                 break;
1343         default:
1344                 SysLog(NID_IO, "[E_INVALID_ARG] The path (%ls) is not matched.",
1345                                 virtualPath.GetPointer());
1346                 return E_INVALID_ARG;
1347         }
1348
1349         if (subPath.IsEmpty() == false)
1350         {
1351                 physicalPath.Append(subPath);
1352         }
1353
1354         return r;
1355 }
1356
1357 result
1358 _FileImpl::ConvertPhysicalToVirtualPath(const String& physicalPath, String& virtualPath) // for 2.0 app
1359 {
1360         result r = E_SUCCESS;
1361         const wchar_t* homeSubDir[] = {
1362                 L"/data/Share2",
1363                 L"/data/Share",
1364                 L"/data",
1365                 L"/res",
1366         };
1367         const wchar_t* ospHomeSubDir[] = {
1368                 L"/share2",
1369                 L"/share/AppControl",
1370                 L"/share",
1371         };
1372         String subPath;
1373         int homeSubDirCount = sizeof(homeSubDir)/sizeof(wchar_t*);
1374         int ospHomeSubDirCount = sizeof(ospHomeSubDir)/sizeof(wchar_t*);
1375         int baseDirLen = 0;
1376         int i = 0;
1377
1378         SysLog(NID_IO, "[P2V] physicalPath: %ls", physicalPath.GetPointer());
1379
1380         Tizen::App::App* pApp = Tizen::App::App::GetInstance();
1381         SysTryReturnResult(NID_IO, pApp != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
1382         String homePath = pApp->GetAppRootPath();
1383         homePath.SetLength(homePath.GetLength() - 1);
1384
1385         String ospCompatSharedPath = _EnvironmentImpl::GetOspCompatSharedPath();
1386         ospCompatSharedPath.SetLength(ospCompatSharedPath.GetLength() - 1);
1387
1388         String mediaPath = Tizen::System::Environment::GetMediaPath();
1389         mediaPath.SetLength(mediaPath.GetLength() - 1);
1390
1391         String externalPath = Tizen::System::Environment::GetExternalStoragePath();
1392         externalPath.SetLength(externalPath.GetLength() - 1);
1393
1394         if (physicalPath.StartsWith(homePath, 0) == true)
1395         {
1396                 physicalPath.SubString(homePath.GetLength(), subPath);
1397
1398                 for (i = 0; i < homeSubDirCount; i++)
1399                 {
1400                         SysLog(NID_IO, "[P2V] i: %d, path: %ls", i, homeSubDir[i]);
1401                         if (subPath.StartsWith(homeSubDir[i], 0) == true)
1402                         {
1403                                 break;
1404                         }
1405                 }
1406                 SysTryReturnResult(NID_IO, i != homeSubDirCount, E_INVALID_ARG, "The path (%ls) is not matched.",
1407                                 physicalPath.GetPointer());
1408
1409                 baseDirLen = homePath.GetLength() + String(homeSubDir[i]).GetLength();
1410
1411                 switch (i)
1412                 {
1413                 case 0:
1414                         virtualPath = L"/Home/Share2";
1415                         break;
1416                 case 1:
1417                         virtualPath = L"/Home/Share";
1418                         break;
1419                 case 2:
1420                         virtualPath = L"/Home";
1421                         break;
1422                 case 3:
1423                         virtualPath = L"/Res";
1424                         break;
1425                 default:
1426                         break;
1427                 }
1428
1429         }
1430         else if (physicalPath.StartsWith(ospCompatSharedPath, 0) == true)
1431         {
1432                 physicalPath.SubString(ospCompatSharedPath.GetLength(), subPath);
1433
1434                 for (i = 0; i < ospHomeSubDirCount; i++)
1435                 {
1436                         SysLog(NID_IO, "[P2V] i: %d, path: %ls", i, ospHomeSubDir[i]);
1437                         if (subPath.StartsWith(ospHomeSubDir[i], 0) == true)
1438                         {
1439                                 break;
1440                         }
1441                 }
1442                 SysTryReturnResult(NID_IO, i != ospHomeSubDirCount, E_INVALID_ARG, "The path (%ls) is not matched.",
1443                                 physicalPath.GetPointer());
1444
1445                 baseDirLen = ospCompatSharedPath.GetLength() + String(ospHomeSubDir[i]).GetLength();
1446
1447                 switch (i)
1448                 {
1449                 case 0:
1450                         virtualPath = L"/Share2";
1451                         break;
1452                 case 1:
1453                         virtualPath = L"/Share/AppControl";
1454                         break;
1455                 case 2:
1456                         virtualPath = L"/Share";
1457                         break;
1458                 default:
1459                         break;
1460                 }
1461         }
1462         else if (physicalPath.StartsWith(mediaPath, 0) == true)
1463         {
1464                 SysLog(NID_IO, "[P2V] media");
1465                 virtualPath = L"/Media";
1466                 baseDirLen = mediaPath.GetLength();
1467         }
1468         else if (physicalPath.StartsWith(externalPath, 0) == true)
1469         {
1470                 SysLog(NID_IO, "[P2V] external media");
1471                 virtualPath = L"/Storagecard/Media";
1472                 baseDirLen = externalPath.GetLength();
1473         }
1474         else
1475         {
1476                 SysLog(NID_IO, "[E_INVALID_ARG] The path (%ls) is not matched.",
1477                                 physicalPath.GetPointer());
1478
1479                 return E_INVALID_ARG;
1480         }
1481
1482         if (physicalPath.GetLength() > baseDirLen)
1483         {
1484                 wchar_t ch = '\0';
1485
1486                 r = physicalPath.GetCharAt(baseDirLen, ch);
1487                 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] The path (%ls) is not matched.",
1488                                 GetErrorMessage(r), physicalPath.GetPointer());
1489
1490                 if (ch != L'/')
1491                 {
1492                         virtualPath.Clear();
1493                         SysLog(NID_IO, "[E_INVALID_ARG] The path (%ls) is not matched.",
1494                                         physicalPath.GetPointer());
1495
1496                         return E_INVALID_ARG;
1497                 }
1498         }
1499
1500         subPath.Clear();
1501         physicalPath.SubString(baseDirLen, subPath);
1502
1503         if (subPath.IsEmpty() == false)
1504         {
1505                 virtualPath.Append(subPath);
1506         }
1507
1508         return r;
1509 }
1510
1511 }} // Tizen::Io