Create virtual-root directory for VirtualRoot

Change-Id: I3a21fa36f9c45fab595e2ed299e43f56c88273f5
Signed-off-by: Duyoung Jang <duyoung.jang@samsung.com>

diff --git a/inc/InstallerDefs.h b/inc/InstallerDefs.h
index afcb8d3..769cab1 100755 (executable)
--- a/inc/InstallerDefs.h
+++ b/inc/InstallerDefs.h
@@ -23,7 +23,7 @@
 
 #include "InstallerUtil.h"
 
-#define OSP_INSTALLER_VERSION "version=[20130624.1]"
+#define OSP_INSTALLER_VERSION "version=[20130625.1]"
 
 #define DIR_BIN                                L"/bin"
 #define DIR_INFO                       L"/info"
@@ -37,6 +37,7 @@
 #define DIR_SHARED_RES         L"/shared/res"
 #define DIR_SHARED_DATA                L"/shared/data"
 #define DIR_SHARED_TRUSTED     L"/shared/trusted"
+#define DIR_VIRTUAL_ROOT               L"/virtual-root"
 
 #define SLP_DIR_BIN                    L"/bin"
 #define SLP_DIR_RES                    L"/res"

diff --git a/src/Manager/CompatibilityManager.cpp b/src/Manager/CompatibilityManager.cpp
index e5400e7..90384f6 100755 (executable)
--- a/src/Manager/CompatibilityManager.cpp
+++ b/src/Manager/CompatibilityManager.cpp
@@ -25,6 +25,7 @@
 #include <errno.h>
 #include <unique_ptr.h>
 
+#include <FIoFile.h>
 #include <FIoDirectory.h>
 #include <FBase_StringConverter.h>
 #include <FSys_EnvironmentImpl.h>
@@ -262,6 +263,102 @@ CompatibilityManager::LinkOspSharePath(const String& rootPath, const PackageId&
 }
 
 bool
+CompatibilityManager::PrepareVirtualRoot(const Tizen::Base::String& rootPath, const Tizen::App::PackageId& packageId)
+{
+       result r = E_SUCCESS;
+       bool res = true;
+       int result = 0;
+       char* pCwd = null;
+       String destPath = rootPath + DIR_VIRTUAL_ROOT;
+       SmackManager smackManager;
+
+       std::unique_ptr<char[]> pVirtualRootPath(_StringConverter::CopyToCharArrayN(destPath));
+       TryCatch(pVirtualRootPath != null, res = false, "The memory is insufficient.");
+
+       pCwd = get_current_dir_name();
+       TryCatch(pCwd != null, res = false, "get_current_dir_name() failed. [errno = %d(%s)]", errno, strerror(errno));
+
+       // appRoot/virtual-root
+       if (File::IsFileExist(destPath) == false)
+       {
+               r = Directory::Create(destPath, false);
+               TryCatch(!IsFailed(r), res = false, "Directory::Create() failed");
+       }
+
+       InstallerUtil::ChangeDirectoryPermission(destPath, PERM_BASE, true);
+
+       result = chdir(pVirtualRootPath.get());
+       TryCatch(result == 0, res = false, "chdir(%s) failed. [errno = %d(%s)]", pVirtualRootPath.get(), errno, strerror(errno));
+
+       res = CreateVirtualRootDirectories();
+       TryCatch(res == true, , "CreateVirtualRootDirectories() failed.");
+
+       smackManager.AddLabelDir(packageId, destPath);
+
+       res = CreateSymbolicLink();
+       TryCatch(res == true, , "CreateSymbolicLink() failed.");
+
+       result = chdir(pCwd);
+       TryCatch(result == 0, res = false, "chdir(%s) failed. [errno = %d(%s)]", pCwd, errno, strerror(errno));
+
+CATCH:
+       if (pCwd)
+       {
+               free(pCwd);
+       }
+
+       AppLog("[Tizen::Io] result  = [%s]", res?"true":"false");
+
+       return res;
+}
+
+bool
+CompatibilityManager::FinalizeVirtualRoot(const String& rootPath)
+{
+       int res = 0;
+       unsigned int i = 0;
+       String destPath = rootPath + DIR_VIRTUAL_ROOT;
+       static const struct _PathInfo mountPath[] =
+       {
+                       { "./bin" },
+                       { "./cache" },
+                       { "./csa" },
+                       { "./data" },
+                       { "./dev" },
+                       { "./etc" },
+                       { "./lib" },
+                       { "./media" },
+                       { "./mnt" },
+                       { "./opt" },
+                       { "./proc" },
+                       { "./run" },
+                       { "./sbin" },
+                       { "./smack" },
+                       { "./srv" },
+                       { "./sys" },
+                       { "./system" },
+                       { "./tmp" },
+                       { "./usr" },
+                       { "./var" }
+       };
+
+       std::unique_ptr<char[]> pVirtualRootPath(_StringConverter::CopyToCharArrayN(destPath));
+       TryReturn(pVirtualRootPath, false, "The memory is insufficient.");
+
+       res = chdir(pVirtualRootPath.get());
+       TryReturn(res == 0, false, "chdir() failed. (%d, %s), path = [%ls]", errno, strerror(errno), destPath.GetPointer());
+
+       for (i = 0; i < sizeof(mountPath) / sizeof(struct _PathInfo); ++i)
+       {
+               res = umount2(mountPath[i].destPath, MNT_DETACH);
+               TryReturn((res == 0) || (errno == EINVAL) || (errno == ENOENT), false, "umount2() failed. (%d, %s), path = [%s]", errno, strerror(errno), mountPath[i].destPath);
+       }
+
+       AppLog("[Tizen::Io] FinalizeVirtualRoot() succeeded, path: %ls", destPath.GetPointer());
+       return true;
+}
+
+bool
 CompatibilityManager::CreateOspInternalDirectories(const String& rootPath, const PackageId& packageId)
 {
        result r = E_SUCCESS;
@@ -450,3 +547,46 @@ CompatibilityManager::CreateSymbolicLink(void)
        AppLog("[Tizen::Io] CreateSymbolicLink() succeeded.");
        return true;
 }
+
+bool
+CompatibilityManager::CreateVirtualRootDirectories(void)
+{
+       unsigned int i = 0;
+       int ret = 0;
+       struct _OspDir virtualRootDir[] =
+       {
+                       { "./bin", 0000, false },
+                       { "./cache", 0000, false },
+                       { "./csa", 0000, false },
+                       { "./data", 0000, false },
+                       { "./dev", 0000, false },
+                       { "./etc", 0000, false },
+                       { "./lib", 0000, false },
+                       { "./media", 0000, false },
+                       { "./mnt", 0000, false },
+                       { "./opt", 0000, false },
+                       { "./proc", 0000, false },
+                       { "./run", 0000, false },
+                       { "./sbin", 0000, false },
+                       { "./smack", 0000, false },
+                       { "./srv", 0000, false },
+                       { "./sys", 0000, false },
+                       { "./system", 0000, false },
+                       { "./tmp", 0000, false },
+                       { "./usr", 0000, false },
+                       { "./var", 0000, false }
+       };
+
+       for (i = 0; i < sizeof(virtualRootDir) / sizeof(struct _OspDir); i++)
+       {
+               ret = mkdir(virtualRootDir[i].path, virtualRootDir[i].mode);
+               if (ret == -1 && errno != 17) // EEXIST
+               {
+                       AppLog("mkdir() failed (%s), path: %s, mode: 0%o", strerror(errno), virtualRootDir[i].path, virtualRootDir[i].mode);
+                       return false;
+               }
+       }
+
+       AppLog("[Tizen::Io] CreateVirtualRootDirectories() succeeded.");
+       return true;
+}

diff --git a/src/Manager/CompatibilityManager.h b/src/Manager/CompatibilityManager.h
index 97f0b6c..e31596e 100755 (executable)
--- a/src/Manager/CompatibilityManager.h
+++ b/src/Manager/CompatibilityManager.h
@@ -44,6 +44,9 @@ public:
 
        static bool LinkOspSharePath(const Tizen::Base::String& rootPath, const Tizen::App::PackageId& packageId);
 
+       static bool PrepareVirtualRoot(const Tizen::Base::String& rootPath, const Tizen::App::PackageId& packageId);
+       static bool FinalizeVirtualRoot(const Tizen::Base::String& rootPath);
+
 private:
        CompatibilityManager(const CompatibilityManager& value);
        CompatibilityManager& operator =(const CompatibilityManager& source);
@@ -51,6 +54,7 @@ private:
        static bool CreateOspInternalDirectories(const Tizen::Base::String& rootPath, const Tizen::App::PackageId& packageId);
        static bool CreateSlpDirectories(void);
        static bool CreateSymbolicLink(void);
+       static bool CreateVirtualRootDirectories(void);
 
 private:
 

diff --git a/src/Manager/PermissionManager.cpp b/src/Manager/PermissionManager.cpp
index 186799e..f956744 100755 (executable)
--- a/src/Manager/PermissionManager.cpp
+++ b/src/Manager/PermissionManager.cpp
@@ -53,6 +53,7 @@ bool
 PermissionManager::SetDirectory(InstallationContext* pContext)
 {
        result r = E_SUCCESS;
+       bool res = true;
 
        String destPath;
        String appRootPath;
@@ -173,11 +174,8 @@ PermissionManager::SetDirectory(InstallationContext* pContext)
        {
                AppLog("[Tizen::Io] OSP 2.0 application");
 
-               if (CompatibilityManager::PrepareDataCaging(appRootPath, packageId) == false)
-               {
-                       AppLog("[Tizen::Io] CompatibilityManager::PrepareDataCaging() failed.");
-                       return false;
-               }
+               res = CompatibilityManager::PrepareDataCaging(appRootPath, packageId);
+               TryReturn(res == true, false, "[Tizen::Io] CompatibilityManager::PrepareDataCaging() failed.");
 
                SetSymLink(pContext);
        }
@@ -185,36 +183,17 @@ PermissionManager::SetDirectory(InstallationContext* pContext)
        {
                AppLog("[Tizen::Io] apiVersion is equal to or greater than Tizen 2.0");
 
-               if (CompatibilityManager::CleanDirectories(appRootPath, packageId) == false)
-               {
-                       AppLog("[Tizen::Io] CompatibilityManager::CleanDirectories() failed.");
-                       return false;
-               }
+               res = CompatibilityManager::CleanDirectories(appRootPath, packageId);
+               TryReturn(res == true, false, "[Tizen::Io] CompatibilityManager::CleanDirectories() failed.");
 
-               if (CompatibilityManager::LinkOspSharePath(appRootPath, packageId) == false)
-               {
-                       AppLog("[Tizen::Io] CompatibilityManager::LinkOspSharePath() failed.");
-                       return false;
-               }
+               res = CompatibilityManager::LinkOspSharePath(appRootPath, packageId);
+               TryReturn(res == true, false, "[Tizen::Io] CompatibilityManager::LinkOspSharePath() failed.");
        }
 
        if (pContext->__isVirtualRoot == true)
        {
-               if (pContext->__pSymbolicLinkList->GetCount() > 0)
-               {
-                       std::unique_ptr< IMapEnumeratorT<String*, String*> > pEnum(pContext->__pSymbolicLinkList->GetMapEnumeratorN());
-                       TryReturn(pEnum, false, "pSymbolicLinkList->GetMapEnumeratorN() failed.");
-                       while (pEnum->MoveNext() == E_SUCCESS)
-                       {
-                               String* pKey = null;
-                               String* pValue = null;
-
-                               pEnum->GetKey(pKey);
-                               pEnum->GetValue(pValue);
-
-                               AppLog("SymbolicLink - Src = [%ls], Des = [%ls]", pKey->GetPointer(), pValue->GetPointer());
-                       }
-               }
+               res = CompatibilityManager::PrepareVirtualRoot(appRootPath, packageId);
+               TryReturn(res == true, false, "[Tizen::Io] CompatibilityManager::PrepareVirtualRoot() failed.");
        }
        AppLog("------------------------------------------");
 

diff --git a/src/Step/UninstallStep.cpp b/src/Step/UninstallStep.cpp
index 6ebf052..46d101d 100755 (executable)
--- a/src/Step/UninstallStep.cpp
+++ b/src/Step/UninstallStep.cpp
@@ -234,6 +234,7 @@ InstallerError
 UninstallStep::OnStateRemoveDir(void)
 {
        InstallerError error = INSTALLER_ERROR_NONE;
+       bool res = true;
 
        String rootPath;
        rootPath = __pContext->__rootPath;
@@ -245,8 +246,6 @@ UninstallStep::OnStateRemoveDir(void)
        result r = GetLastResult();
        if (r == E_SUCCESS && ospCompat == true)
        {
-               PackageId packageId = __pContext->__packageId;
-
                if (CompatibilityManager::FinalizeDataCaging(rootPath) == false)
                {
                        AppLog("[Tizen::Io] Failed to unmount directories for 2.0 application, appRootPath: %ls",
@@ -262,6 +261,13 @@ UninstallStep::OnStateRemoveDir(void)
 
        CompatibilityManager::CleanDirectories(rootPath, __pContext->__packageId);
 
+       String virtualRoot = rootPath + DIR_VIRTUAL_ROOT;
+       if (File::IsFileExist(virtualRoot) == true)
+       {
+               res = CompatibilityManager::FinalizeVirtualRoot(rootPath);
+               TryReturn(res == true, INSTALLER_ERROR_UNMOUNT_FAILED, "CompatibilityManager::FinalizeVirtualRoot(%ls) failed.", rootPath.GetPointer());
+       }
+
        AppLog("Directory::Remove - START");
 
        if (__pContext->__isHybridService == true)