From f05d9fe20298e0dd175f756ce54d57e250788d88 Mon Sep 17 00:00:00 2001 From: Dongeup Ham Date: Sun, 31 Mar 2013 14:42:51 +0900 Subject: [PATCH] RDS implemented Change-Id: I95b5997c9e4e5c5799a9e125628bcdeb8fc41862 Signed-off-by: Dongeup Ham --- CMakeLists.txt | 1 + inc/InstallerDefs.h | 60 +++++++++- src/Context/InstallationContext.cpp | 6 + src/Manager/InstallerManager.cpp | 51 ++++++++- src/Manager/PermissionManager.cpp | 216 ++++++++++++++++++++++++++++++++++++ src/Manager/PermissionManager.h | 3 + src/Step/RdsStep.cpp | 160 ++++++++++++++++++++++++++ src/Step/RdsStep.h | 63 +++++++++++ src/Util/InstallerUtil.cpp | 86 ++++++++++++++ src/Util/InstallerUtil.h | 13 +++ src/backend/backend.cpp | 24 ++++ 11 files changed, 674 insertions(+), 9 deletions(-) create mode 100755 src/Step/RdsStep.cpp create mode 100755 src/Step/RdsStep.h diff --git a/CMakeLists.txt b/CMakeLists.txt index b1f9500..175a325 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -51,6 +51,7 @@ SET (${this_target}_SOURCE_FILES src/Step/LicenseStep.cpp src/Step/ManifestXmlStep.cpp src/Step/PackageCheckStep.cpp + src/Step/RdsStep.cpp src/Step/SignatureStep.cpp src/Step/SystemCheckStep.cpp src/Step/UninstallStep.cpp diff --git a/inc/InstallerDefs.h b/inc/InstallerDefs.h index f87b48e..f9a4ce7 100755 --- a/inc/InstallerDefs.h +++ b/inc/InstallerDefs.h @@ -23,7 +23,7 @@ #include "InstallerUtil.h" -#define OSP_INSTALLER_VERSION "version=[20130328.2]" +#define OSP_INSTALLER_VERSION "version=[20130331.1]" #define DIR_BIN L"/bin" #define DIR_INFO L"/info" @@ -36,7 +36,7 @@ #define DIR_CONTENTS L"/contents" #define DIR_SHARED_RES L"/shared/res" #define DIR_SHARED_DATA L"/shared/data" -#define DIR_SHARED_TRUSTED L"/shared/trusted" +#define DIR_SHARED_TRUSTED L"/shared/trusted" #define SLP_DIR_BIN L"/bin" #define SLP_DIR_RES L"/res" @@ -69,7 +69,7 @@ #define UISCALABILITY_INFO L"1 %ls %ls %ls" -#define CONFIG_PATH L"/usr/etc/installer-config.ini" +#define CONFIG_PATH L"/usr/etc/installer-config.ini" #define UIAPP_LOADER_PATH "/usr/lib/osp/osp-ui-app-loader" // UiApp #define SERVICEAPP_LOADER_PATH "/usr/lib/osp/osp-service-app-loader" // ServiceApp @@ -101,12 +101,27 @@ #define PERM_EXECUTE (S_IXUSR | S_IXGRP | S_IXOTH) #define PERM_WRITE (S_IWUSR | S_IWGRP | S_IWOTH) +#define PERM_OWNER_ROOT 0 +#define PERM_OWNER_APP 1 + +#define PERM_SMACK_0 0 +#define PERM_SMACK_1 1 +#define PERM_SMACK_2 2 +#define PERM_SMACK_3 3 + #define TIZEN_PRIVILEGE_WEB_SERVICE "http://tizen.org/privilege/web.service" #define TIZEN_CATEGORY_IME "http://tizen.org/category/ime" #define TIZEN_CATEGORY_HOMESCREEN "http://tizen.org/category/homescreen" #define TIZEN_CATEGORY_LOCKSCREEN "http://tizen.org/category/lockscreen" #define TIZEN_CATEGORY_MENUSCREEN "http://tizen.org/category/menuscreen" +#define DIR_APPLICATIONS_TMP "/opt/usr/apps/tmp" + +#define INSTALLER_RDS_FILE_NAME ".rds_delta" +#define INSTALLER_RDS_DELETE_STR "delete" +#define INSTALLER_RDS_ADD_STR "add" +#define INSTALLER_RDS_MODIFY_STR "modify" + static const int BLOCK_SIZE = 4096; #define OSP_INSTALLER "osp-installer" @@ -170,6 +185,9 @@ enum InstallationStep INSTALLER_STEP_UNINSTALL, INSTALLER_STEP_END, + INSTALLER_STEP_RDS_INIT, + INSTALLER_STEP_RDS, + INSTALLER_STEP_MAX, }; @@ -231,6 +249,7 @@ enum InstallerOperation { INSTALLER_OPERATION_INSTALL, INSTALLER_OPERATION_UNINSTALL, + INSTALLER_OPERATION_REINSTALL, }; @@ -250,6 +269,7 @@ enum INSTALLER_MODE_INSTALL = 1, INSTALLER_MODE_UNINSTALL = 2, INSTALLER_MODE_RECURSIVE_DIRECTORY_INSTALL = 3, + INSTALLER_MODE_REINSTALL = 4, }; enum CategoryType @@ -268,4 +288,38 @@ enum InstallationStorage }; +enum InstallerRdsState +{ + INSTALLER_RDS_STATE_NONE, + INSTALLER_RDS_STATE_DELETE, + INSTALLER_RDS_STATE_ADD, + INSTALLER_RDS_STATE_MODIFY, + +}; + +typedef struct +{ + const char* pDir; + int dirType; + int ownerIndex; + int modeIndex; + int smackIndex; + +} RdsPermssions; + +enum PermDirType +{ + PERM_DIR_RES = 0, + PERM_DIR_DATA = 1, + PERM_DIR_BIN = 2, + PERM_DIR_INFO = 3, + PERM_DIR_LIB = 4, + PERM_DIR_SETTING = 5, + PERM_DIR_SHARED_RES = 6, + PERM_DIR_SHARED_DATA = 7, + PERM_DIR_SHARED_TRUSTED = 8, + PERM_DIR_SHARED = 9, + PERM_DIR_ROOT = 10, +}; + #endif // _INSTALLER_DEFS_H_ diff --git a/src/Context/InstallationContext.cpp b/src/Context/InstallationContext.cpp index d3453e3..541176f 100755 --- a/src/Context/InstallationContext.cpp +++ b/src/Context/InstallationContext.cpp @@ -28,6 +28,7 @@ #include "DrmStep.h" #include "UninstallStep.h" #include "UnpackStep.h" +#include "RdsStep.h" using namespace Tizen::Base; using namespace Tizen::Base::Collection; @@ -170,6 +171,11 @@ InstallationContext::ChangeStep(InstallationStep step) TryReturn(__pStep, false, "DrmStep is failed."); break; + case INSTALLER_STEP_RDS: + __pStep = new (std::nothrow) RdsStep(); + TryReturn(__pStep, false, "DrmStep is failed."); + break; + case INSTALLER_STEP_END: break; diff --git a/src/Manager/InstallerManager.cpp b/src/Manager/InstallerManager.cpp index 20c6aae..9472e41 100755 --- a/src/Manager/InstallerManager.cpp +++ b/src/Manager/InstallerManager.cpp @@ -109,7 +109,7 @@ InstallerManager::Construct(const String& path, InstallerOperation operation, In AppLog("------------------------------------------"); AppLog("InstallerManager"); AppLog("------------------------------------------"); - AppLog(" # operation = [%s]", (operation == INSTALLER_OPERATION_INSTALL)?"Install":"Uninstall"); + AppLog(" # operation = [%s]", InstallerUtil::GetInstallerOperationString(operation)); AppLog(" # path = [%ls]", path.GetPointer()); AppLog("------------------------------------------"); @@ -159,6 +159,15 @@ InstallerManager::Construct(const String& path, InstallerOperation operation, In __pContext->SetCurrentInstallationStep(INSTALLER_STEP_INIT_UNINSTALL); __pContext->__packageId = newPath; } + else if (operation == INSTALLER_OPERATION_REINSTALL) + { + installerType = INSTALLER_TYPE_INSTALLER; + AppLog("operation is INSTALLER_OPERATION_REINSTALL"); + installerType = INSTALLER_TYPE_DIRECTORY; + + __pContext->SetCurrentInstallationStep(INSTALLER_STEP_RDS_INIT); + __pContext->__packageId = newPath; + } __pContext->SetInstallerOperation(operation); @@ -315,6 +324,11 @@ InstallerManager::Activate(void) error = End(); TryReturn(error == INSTALLER_ERROR_NONE, error, "error is occurred."); } + else if (currentStep == INSTALLER_STEP_RDS) + { + AppLog("currentStep is INSTALLER_STEP_RDS"); + __pContext->SetCurrentInstallationStep(INSTALLER_STEP_NONE); + } if (__pContext->IsContinue() == false) { @@ -345,7 +359,7 @@ InstallerManager::GetContext(void) int InstallerManager::ParseCommandArg(int argc, char **argv, int *mode, char *buf, bool *output) { - const char* pOpts_str = "u:i:r:v"; + const char* pOpts_str = "u:i:r:v:m"; int s = 0; if (mode == NULL) @@ -418,7 +432,7 @@ InstallerManager::ParseCommandArg(int argc, char **argv, int *mode, char *buf, b } AppLog("__osp_installer_parse_options: r"); - *mode = INSTALLER_MODE_RECURSIVE_DIRECTORY_INSTALL; + *mode = INSTALLER_MODE_REINSTALL; strncpy(buf, optarg, BUFSIZE); AppLog("__osp_installer_parse_options: optarg = [%s]", optarg); break; @@ -429,6 +443,18 @@ InstallerManager::ParseCommandArg(int argc, char **argv, int *mode, char *buf, b AppLog("__osp_installer_parse_options: optarg = [%s]", optarg); break; + case 'm': + if (*mode) + { + break; + } + + AppLog("__osp_installer_parse_options: m"); + *mode = INSTALLER_MODE_RECURSIVE_DIRECTORY_INSTALL; + strncpy(buf, optarg, BUFSIZE); + AppLog("__osp_installer_parse_options: optarg = [%s]", optarg); + break; + default: AppLog("Invalid option"); exit(-1); @@ -506,6 +532,10 @@ InstallerManager::ReqeustByTest(void) { errorType = InstallerManager::RequestMove(path, PM_MOVE_TO_INTERNAL); } + else if (readBuf[0] == '#') + { + errorType = InstallerManager::Request(path, INSTALLER_OPERATION_REINSTALL, INSTALLER_OPTION_NORMAL, packageId); + } } CATCH: @@ -516,12 +546,11 @@ void InstallerManager::PrintResult(void) { int errorType = GetErrorType(); - InstallerOperation operation = GetInstallerOperation(); + InstallerOperation operation = __pContext->GetInstallerOperation(); Tizen::System::SystemTime::GetTicks(__endTick); - const char* pOperation = null; - (operation == INSTALLER_OPERATION_INSTALL)? (pOperation = "Install"): (pOperation = "Uninstall"); + const char* pOperation = InstallerUtil::GetInstallerOperationString(operation); const wchar_t* pPackageId = L"Unknown"; if (__pContext && !__pContext->__packageId.IsEmpty()) @@ -903,6 +932,16 @@ InstallerManager::RequestByCommand(int argc, char **argv) } break; + case INSTALLER_MODE_REINSTALL: + { + AppLog("------------------------------------------"); + AppLog(" # Directory = [%s]", buf); + + option = (InstallerOption)(option | INSTALLER_OPTION_FILELOG_ON); + errorType = InstallerManager::Request(buf, INSTALLER_OPERATION_REINSTALL, option, packageId); + } + break; + default: { AppLog("__install_package_by_cmd, Invalid mode"); diff --git a/src/Manager/PermissionManager.cpp b/src/Manager/PermissionManager.cpp index 98784c8..47a8284 100755 --- a/src/Manager/PermissionManager.cpp +++ b/src/Manager/PermissionManager.cpp @@ -254,3 +254,219 @@ PermissionManager::SetSymLink(InstallationContext* pContext) return true; } + +bool +PermissionManager::CopyForRds(InstallationContext* pContext, IList* pFileList, bool& isInstallRequired) +{ + TryReturn(pFileList, false, "pFileList is null."); + + for (int idx = 0; idx < pFileList->GetCount(); idx++) + { + String* pFilePath = static_cast(pFileList->GetAt(idx)); + TryReturn(pFilePath, false, "pFilePath is null."); + + String srcFile = DIR_APPLICATIONS_TMP; + srcFile += L"/" + pContext->__packageId + L"/" + *pFilePath; + String destFile = pContext->__rootPath + L"/" + *pFilePath; + + AppLog("copy file from[%ls] to[%ls]", srcFile.GetPointer(), destFile.GetPointer()); + + int pos = 0; + result r = E_SUCCESS; + String destDir; + + r = destFile.LastIndexOf(L'/', destFile.GetLength() -1, pos); + if (IsFailed(r) == true) + { + AppLog("destFile is invalid[%ls]", destFile.GetPointer()); + continue; + } + destFile.SubString(0, pos, destDir); + + if (File::IsFileExist(destDir) == false) + { + Directory::Create(destDir, true); + } + InstallerUtil::Remove(destFile); + File::Copy(srcFile, destFile, true); + + if (*pFilePath == L"info/manifest.xml") + { + AppLog("Install required, [%ls] is found", pFilePath->GetPointer()); + isInstallRequired = true; + } + else if (pFilePath->StartsWith("setting/setting", 0) == true) + { + AppLog("Install required, [%ls] is found", pFilePath->GetPointer()); + isInstallRequired = true; + } + } + + return true; +} + +bool +PermissionManager::ApplyPermissionForRds(InstallationContext* pContext) +{ + String destPath; + String appRootPath; + SmackManager smackManager; + smackManager.Construct(pContext); + + appRootPath = pContext->__rootPath; + PackageId packageId = pContext->__packageId; + + // appRoot + InstallerUtil::ChangeMode(appRootPath, PERM_BASE | PERM_EXECUTE); + smackManager.AddLabelDir(packageId, appRootPath, true); + + // appRoot/bin + destPath = appRootPath + DIR_BIN; + InstallerUtil::ChangeDirectoryPermission(destPath, PERM_BASE | PERM_EXECUTE, false); + smackManager.AddLabelDir(packageId, destPath); + + // appRoot/info + destPath = appRootPath + DIR_INFO; + InstallerUtil::ChangeDirectoryPermission(destPath, PERM_BASE, false); + smackManager.AddLabelDir(packageId, destPath); + + // appRoot/res + destPath = appRootPath + DIR_RES; + InstallerUtil::ChangeDirectoryPermission(destPath, PERM_BASE, false); + smackManager.AddLabelDir(packageId, destPath); + + // appRoot/lib + destPath = appRootPath + DIR_LIB; + InstallerUtil::ChangeDirectoryPermission(destPath, PERM_BASE | PERM_EXECUTE, false); + smackManager.AddLabelDir(packageId, destPath); + + // appRoot/shared + destPath = appRootPath + DIR_SHARED; + InstallerUtil::ChangeDirectoryPermission(destPath, PERM_BASE, false); + smackManager.AddLabelDir(packageId, destPath); + + // appRoot/shared/res + destPath = appRootPath + DIR_SHARED_RES; + InstallerUtil::ChangeDirectoryPermission(destPath, PERM_BASE, false); + smackManager.AddLabelSharedDir(packageId, destPath); + + // appRoot/shared/data + destPath = appRootPath + DIR_SHARED_DATA; + InstallerUtil::ChangeDirectoryPermission(destPath, PERM_BASE, true); + smackManager.AddLabelSharedDir(packageId, destPath); + + // appRoot/shared/trusted + destPath = appRootPath + DIR_SHARED_TRUSTED; + InstallerUtil::ChangeDirectoryPermission(destPath, PERM_BASE, true); + smackManager.AddLabelSharedDir(packageId, destPath); + + // appRoot/setting + destPath = appRootPath + DIR_SETTING; + InstallerUtil::ChangeDirectoryPermission(destPath, PERM_BASE | PERM_WRITE, false); + smackManager.AddLabelDir(packageId, destPath); + + // appRoot/data + destPath = appRootPath + DIR_DATA; + InstallerUtil::ChangeDirectoryPermission(destPath, PERM_BASE, true); + smackManager.AddLabelDir(packageId, destPath); + + return true; +} + +#if 0 +bool +PermissionManager::ApplyPermission(InstallationContext* pContext, const IList* pFileList) +{ + TryReturn(pContext, false, "pContext is null"); + TryReturn(pFileList, false, "pFileList is null"); + + // dir | type | owner | mode | smack + static RdsPermssions perms[] = + { + {"res", PERM_DIR_RES, PERM_OWNER_ROOT, PERM_BASE, PERM_SMACK_0}, + {"data", PERM_DIR_DATA, PERM_OWNER_APP, PERM_BASE, PERM_SMACK_0}, + {"bin", PERM_DIR_BIN, PERM_OWNER_ROOT, (PERM_BASE | PERM_EXECUTE), PERM_SMACK_0}, + {"info", PERM_DIR_INFO, PERM_OWNER_ROOT, PERM_BASE, PERM_SMACK_0}, + {"lib", PERM_DIR_LIB, PERM_OWNER_ROOT, (PERM_BASE | PERM_EXECUTE), PERM_SMACK_0}, + {"setting", PERM_DIR_SETTING, PERM_OWNER_ROOT, (PERM_BASE | PERM_WRITE), PERM_SMACK_0}, + {"shared/res", PERM_DIR_SHARED_RES, PERM_OWNER_ROOT, PERM_BASE, PERM_SMACK_0}, + {"shared/data", PERM_DIR_SHARED_DATA, PERM_OWNER_APP, PERM_BASE, PERM_SMACK_0}, + {"shared/trusted", PERM_DIR_SHARED_TRUSTED, PERM_OWNER_APP, PERM_BASE, PERM_SMACK_0}, + {"shared", PERM_DIR_SHARED, PERM_OWNER_ROOT, PERM_BASE, PERM_SMACK_0}, + {"author", PERM_DIR_ROOT, PERM_OWNER_ROOT, PERM_BASE, PERM_SMACK_0}, + {"signature", PERM_DIR_ROOT, PERM_OWNER_ROOT, PERM_BASE, PERM_SMACK_0}, + }; + + static int permCount = sizeof(perms) / sizeof(RdsPermssions); + bool isInstallRequired = false; + SmackManager smackManager; + smackManager.Construct(pContext); + + for (int i = 0; i < pFileList->GetCount(); i++) + { + const String *pFilePath = static_cast(pFileList->GetAt(i)); + TryReturn(pFilePath, false, "pFilePath is null"); + + AppLog("pFilePath=(%ls)", pFilePath->GetPointer()); + + int permIdx = 0; + for (permIdx = 0; permIdx < permCount; permIdx++) + { + if (pFilePath->StartsWith(perms[permIdx].pDir, 0) == true) + { + if (perms[permIdx].dirType == PERM_DIR_INFO) + { + if (*pFilePath == L"info/manifest.xml") + { + AppLog("Install required, [%ls] is found", pFilePath->GetPointer()); + isInstallRequired = true; + } + } + else if (perms[permIdx].dirType == PERM_DIR_SETTING) + { + if (pFilePath->StartsWith("setting/setting", 0) == true) + { + AppLog("Install required, [%ls] is found", pFilePath->GetPointer()); + isInstallRequired = true; + } + } + + AppLog("dirType=(%d), owner=(%d), mode=(%d), smack=(%d)", + perms[permIdx].dirType, perms[permIdx].ownerIndex, perms[permIdx].modeIndex, perms[permIdx].smackIndex); + + String srcFile = DIR_APPLICATIONS_TMP; + srcFile += L"/" + pContext->__packageId + L"/" + *pFilePath; + String destFile = pContext->__rootPath + L"/" + *pFilePath; + + AppLog("copy file: from[%ls] to[%ls]", srcFile.GetPointer(), destFile.GetPointer()); + File::Copy(srcFile, destFile, false); + + bool isAppOwner = false; + if (perms[permIdx].ownerIndex == PERM_OWNER_APP) + { + isAppOwner = true; + } + + String destPath; + if (perms[permIdx].dirType != PERM_DIR_ROOT) + { + destPath = pContext->__rootPath + L"/" + perms[permIdx].pDir; + InstallerUtil::ChangeDirectoryPermission(destPath, perms[permIdx].modeIndex, isAppOwner); + } + else + { + destPath = pContext->__rootPath + L"/" + *pFilePath; + InstallerUtil::ChangeMode(*pFilePath, perms[permIdx].modeIndex); + } + smackManager.AddLabelSharedDir(pContext->__packageId, destPath); + + break; + } + } + } + + return true; +} +#endif + + diff --git a/src/Manager/PermissionManager.h b/src/Manager/PermissionManager.h index c173717..f663a11 100755 --- a/src/Manager/PermissionManager.h +++ b/src/Manager/PermissionManager.h @@ -42,6 +42,9 @@ public: static bool SetDirectory(InstallationContext* pContext); static bool SetFile(InstallationContext* pContext); + bool CopyForRds(InstallationContext* pContext, Tizen::Base::Collection::IList* pFileList, bool& isInstallRequired); + bool ApplyPermissionForRds(InstallationContext* pContext); + private: static bool SetSymLink(InstallationContext* pContext); static bool PrepareDataCaging(InstallationContext* pContext); diff --git a/src/Step/RdsStep.cpp b/src/Step/RdsStep.cpp new file mode 100755 index 0000000..1c747db --- /dev/null +++ b/src/Step/RdsStep.cpp @@ -0,0 +1,160 @@ +// +// Open Service Platform +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file RdsStep.cpp + * @brief This is the implementation file for %ApplicationXmlStep class. + */ + +#include + +#include +#include + +#include "InstallationContext.h" +#include "RdsStep.h" +#include "PermissionManager.h" +#include "FAppTypes.h" + +using namespace Tizen::Base; +using namespace Tizen::Base::Collection; +using namespace Tizen::App; +using namespace Tizen::App::Package; +using namespace Tizen::Io; + +RdsStep::RdsStep(void) +:__state(STATE_RDS_PROCESSING) +,__pContext(null) +,__isInstallRequired(false) +{ +} + +RdsStep::~RdsStep(void) +{ +} + +InstallerError +RdsStep::Run(InstallationContext* pContext) +{ + InstallerError error = INSTALLER_ERROR_NONE; + __pContext = pContext; + + while (true) + { + switch (__state) + { + case STATE_RDS_PROCESSING: + error = OnRdsProcessing(); + break; + + case STATE_DONE: + AppLog("[STATE_DONE]"); + error = OnStateDone(); + break; + + default: + break; + } + + if (error != INSTALLER_ERROR_NONE) + { + break; + } + + if (__state > STATE_DONE) + { + break; + } + } + + return error; +} + +void +RdsStep::GoNextState(void) +{ + __state++; +} + +InstallerError +RdsStep::OnRdsProcessing(void) +{ + InstallerError error = INSTALLER_ERROR_NONE; + bool res = false; + + std::unique_ptr pDeletedList(new (std::nothrow) ArrayList()); + TryReturn(pDeletedList, INSTALLER_ERROR_OUT_OF_MEMORY, "pDeletedList is null"); + + std::unique_ptr pAddedList(new (std::nothrow) ArrayList()); + TryReturn(pAddedList, INSTALLER_ERROR_OUT_OF_MEMORY, "pAddedList is null"); + + std::unique_ptr pModifiedList(new (std::nothrow) ArrayList()); + TryReturn(pModifiedList, INSTALLER_ERROR_OUT_OF_MEMORY, "pModifiedList is null"); + + PackageId packageId = __pContext->__packageId; + + res = InstallerUtil::GetRdsList(packageId, pDeletedList.get(), pAddedList.get(), pModifiedList.get()); + TryReturn(res, INSTALLER_ERROR_INTERNAL_STATE, "GetRdsList() failed"); + + PackageInfo* pPackageInfo = _PackageManagerImpl::GetInstance()->GetPackageInfoN(packageId); + TryReturn(pPackageInfo != null, INSTALLER_ERROR_INTERNAL_STATE, "GetPackageInfoN() failed"); + + _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo); + TryReturn(pPackageInfoImpl, INSTALLER_ERROR_INTERNAL_STATE, "GetInstance() failed"); + + String rootPath = pPackageInfoImpl->GetAppRootPath(); + __pContext->__rootPath = rootPath; + + int idx = 0; + for (idx = 0; idx < pDeletedList->GetCount(); idx++) + { + String* pDeletedFile = static_cast(pDeletedList->GetAt(idx)); + String destFile = rootPath + L"/" + *pDeletedFile; + + AppLog("deleted file: %ls", destFile.GetPointer()); + InstallerUtil::Remove(destFile); + } + + PermissionManager permissionMgr; + permissionMgr.CopyForRds(__pContext, pAddedList.get(), __isInstallRequired); + permissionMgr.CopyForRds(__pContext, pModifiedList.get(), __isInstallRequired); + permissionMgr.ApplyPermissionForRds(__pContext); + + GoNextState(); + return error; +} + +InstallerError +RdsStep::OnStateDone(void) +{ + InstallerError error = INSTALLER_ERROR_NONE; + + if (__isInstallRequired == true) + { + __pContext->SetContinue(true); + __pContext->__inputPath = __pContext->__rootPath; + __pContext->__installDir = __pContext->__rootPath; + __pContext->SetInstallerOperation(INSTALLER_OPERATION_INSTALL); + } + else + { + __pContext->SetContinue(false); + } + + GoNextState(); + return error; +} + diff --git a/src/Step/RdsStep.h b/src/Step/RdsStep.h new file mode 100755 index 0000000..a907139 --- /dev/null +++ b/src/Step/RdsStep.h @@ -0,0 +1,63 @@ +// +// Open Service Platform +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file RdsStep.h + * @brief This is the header file for the %RdsStep class. + * + * This header file contains the declarations of the %RdsStep class. + */ +#ifndef _RDS_STEP_H_ +#define _RDS_STEP_H_ + +#include "IInstallationStep.h" + +/** + * @class RdsStep + * @brief This class represents the class of RdsStep. + * @since 1.0 + * + * This class represents the class of RdsStep. + * + */ +class RdsStep + : public IInstallationStep +{ +public: + RdsStep(void); + virtual ~RdsStep(void); + + virtual InstallerError Run(InstallationContext* pContext); + +private: + enum + { + STATE_RDS_PROCESSING, + STATE_DONE + }; + + void GoNextState(void); + InstallerError OnRdsProcessing(void); + InstallerError OnStateDone(void); + +private: + int __state; + InstallationContext* __pContext; + bool __isInstallRequired; + +}; // RdsStep + +#endif //_RDS_STEP_H_ diff --git a/src/Util/InstallerUtil.cpp b/src/Util/InstallerUtil.cpp index 6ee1f6e..36680f9 100755 --- a/src/Util/InstallerUtil.cpp +++ b/src/Util/InstallerUtil.cpp @@ -707,3 +707,89 @@ InstallerUtil::PrintLog(const String& logFile) return true; } + +bool +InstallerUtil::GetRdsList(const PackageId& packageId, IList* pDeletedList, IList* pAddedList, IList* pModifiedList) +{ + FILE* fp = null; + char rdsFilePath[1024] = {0}; + char buffer[1024] = {0}; + InstallerRdsState state = INSTALLER_RDS_STATE_NONE; + + snprintf(rdsFilePath, sizeof(rdsFilePath), "%s/%ls/%s", DIR_APPLICATIONS_TMP, packageId.GetPointer(), INSTALLER_RDS_FILE_NAME); + + fp = fopen(rdsFilePath, "r"); + TryReturn(fp, false, "fp is null."); + AppLog(".rds_delta file"); + int line = 1; + + while (fgets(buffer, sizeof(buffer), fp) != null) + { + if (buffer[0] == '#') + { + if (strcasestr(buffer, INSTALLER_RDS_DELETE_STR)) + { + state = INSTALLER_RDS_STATE_DELETE; + } + else if (strcasestr(buffer, INSTALLER_RDS_ADD_STR)) + { + state = INSTALLER_RDS_STATE_ADD; + } + else if (strcasestr(buffer, INSTALLER_RDS_MODIFY_STR)) + { + state = INSTALLER_RDS_STATE_MODIFY; + } + } + + if (state == INSTALLER_RDS_STATE_NONE) + { + AppLog("Unknown RDS State, INSTALLER_RDS_STATE_NONE"); + continue; + } + + std::unique_ptr pStr(new (std::nothrow) String(buffer)); + TryReturn(pStr, false, "pStr is null."); + TryReturn(pStr->IsEmpty() == false, false, "pStr is empty."); + + pStr->Trim(); + AppLog(".rds_delta: line(%03d)=[%ls]", line, pStr->GetPointer()); + line++; + + if (state == INSTALLER_RDS_STATE_DELETE) + { + pDeletedList->Add(pStr.release()); + } + else if (state == INSTALLER_RDS_STATE_ADD) + { + pAddedList->Add(pStr.release()); + } + else if (state == INSTALLER_RDS_STATE_MODIFY) + { + pModifiedList->Add(pStr.release()); + } + + memset(buffer, 0, sizeof(buffer)); + } + + return true; +} + +const char* +InstallerUtil::GetInstallerOperationString(int operation) +{ + if (operation == INSTALLER_OPERATION_INSTALL) + { + return "Install"; + } + else if (operation == INSTALLER_OPERATION_UNINSTALL) + { + return "Uninstall"; + } + else if (operation == INSTALLER_OPERATION_REINSTALL) + { + return "Reinstall"; + } + + return "Unknown"; +} + diff --git a/src/Util/InstallerUtil.h b/src/Util/InstallerUtil.h index f03034a..042c557 100755 --- a/src/Util/InstallerUtil.h +++ b/src/Util/InstallerUtil.h @@ -23,11 +23,18 @@ #ifndef _INSTALLER_UTIL_H_ #define _INSTALLER_UTIL_H_ +#include + namespace Tizen { namespace Base { class String; }} +namespace Tizen { namespace Base { namespace Collection +{ +class IList; +}}} + /** * @class InstallerUtil * @brief This class represents the class of InstallerUtil. @@ -68,6 +75,12 @@ public: static bool CreateLog(const Tizen::Base::String& logFile); static bool AppendLog(const char* pFunction, int lineNumber, bool fatal, const char* pFormat, ...); static bool PrintLog(const Tizen::Base::String& logFile); + static bool GetRdsList(const Tizen::App::PackageId& packageId, + Tizen::Base::Collection::IList* pDeletedList, + Tizen::Base::Collection::IList* pAddedList, + Tizen::Base::Collection::IList* pModifiedList); + + static const char* GetInstallerOperationString(int operation); private: static char LogChangeHexToStr(int hex); diff --git a/src/backend/backend.cpp b/src/backend/backend.cpp index ece1f6a..1fa368d 100755 --- a/src/backend/backend.cpp +++ b/src/backend/backend.cpp @@ -156,6 +156,30 @@ main(int argc, char **argv) } break; + case PKGMGR_REQ_REINSTALL: + { + PackageId rdsPackageId; + + path.SubString(0, PACKAGE_ID_LENGTH, rdsPackageId); + + AppLog("rdsPackageId = %ls", rdsPackageId.GetPointer()); + ret = InstallerManager::Request(rdsPackageId, INSTALLER_OPERATION_REINSTALL, INSTALLER_OPTION_NORMAL, packageId); + + if (_pi != 0) + { + char resultBuf[128] = {0}; + snprintf(resultBuf, sizeof(resultBuf), "%ls", packageId.GetPointer()); + pkgmgr_installer_send_signal(_pi, "tpk", resultBuf, "start", "install"); + } + else + { + AppLog("_pi is null"); + } + + __osp_installer_report_result(packageId, errorType); + } + break; + case PKGMGR_REQ_MOVE: { if (_pi != 0) -- 2.7.4