From 3e8b6c23ed7e533fa97a04c9756c195b2b6300c4 Mon Sep 17 00:00:00 2001 From: Ilho Kim Date: Wed, 27 Mar 2024 10:14:27 +0900 Subject: [PATCH] Refactor slp-pkgmgr with tidl Change-Id: I54b9824ed7fe3fa08661e368a30208eb04e950e3 Signed-off-by: Ilho Kim --- CMakeLists.txt | 35 +- client/CMakeLists.txt | 36 +- client/include/package-manager.h | 2 +- client/src/api_stub.cc | 1809 ++++++++++++++ client/src/connection_event_listener.hh | 62 + client/src/connector.cc | 357 +++ client/src/connector.hh | 105 + client/src/internal.cc | 111 + client/src/internal.hh | 33 + client/src/log.hh | 40 + client/src/pkgmgr.c | 3262 ------------------------- client/src/pkgmgr_client_connection.c | 466 ---- client/src/pkgmgr_client_debug.h | 91 - client/src/pkgmgr_client_internal.c | 198 -- client/src/pkgmgr_client_internal.h | 91 - client/src/signal_receiver.cc | 192 ++ client/src/signal_receiver.hh | 94 + cmake/Modules/ApplyPkgConfig.cmake | 35 + installer/CMakeLists.txt | 62 +- installer/pkgmgr-installer.pc.in | 2 +- installer/pkgmgr_installer.c | 1446 ----------- installer/pkgmgr_installer_signal_agent.c | 337 --- installer/pkgmgr_installer_signal_agent.cc | 384 +++ installer/src/api_stub.cc | 453 ++++ installer/src/control.cc | 741 ++++++ installer/src/control.hh | 70 + installer/{ => src}/pkgmgr_installer.h | 2 +- installer/{ => src}/pkgmgr_installer_config.h | 0 installer/{ => src}/pkgmgr_installer_debug.h | 12 +- installer/{ => src}/pkgmgr_installer_error.h | 0 installer/{ => src}/pkgmgr_installer_info.h | 0 installer/{ => src}/pkgmgr_installer_type.h | 0 installer/src/request.cc | 136 ++ installer/src/request.hh | 94 + packaging/pkgmgr.changes | 18 - packaging/pkgmgr.spec | 52 + test/CMakeLists.txt | 1 + test/unit_tests/CMakeLists.txt | 33 + test/unit_tests/main.cc | 25 + test/unit_tests/mock/app_event_mock.cc | 37 + test/unit_tests/mock/app_event_mock.hh | 36 + test/unit_tests/mock/mock_hook.hh | 42 + test/unit_tests/mock/module_mock.hh | 25 + test/unit_tests/mock/rpc_port_mock.cc | 54 + test/unit_tests/mock/rpc_port_mock.hh | 68 + test/unit_tests/mock/test_fixture.cc | 21 + test/unit_tests/mock/test_fixture.hh | 54 + test/unit_tests/test_client.cc | 958 ++++++++ tidl/PkgMgr.tidl | 69 + tidl/PkgSignal.tidl | 28 + tidl/prebuild.sh | 5 + 51 files changed, 6312 insertions(+), 5972 deletions(-) create mode 100644 client/src/api_stub.cc create mode 100644 client/src/connection_event_listener.hh create mode 100644 client/src/connector.cc create mode 100644 client/src/connector.hh create mode 100644 client/src/internal.cc create mode 100644 client/src/internal.hh create mode 100644 client/src/log.hh delete mode 100644 client/src/pkgmgr.c delete mode 100644 client/src/pkgmgr_client_connection.c delete mode 100644 client/src/pkgmgr_client_debug.h delete mode 100644 client/src/pkgmgr_client_internal.c delete mode 100644 client/src/pkgmgr_client_internal.h create mode 100644 client/src/signal_receiver.cc create mode 100644 client/src/signal_receiver.hh create mode 100644 cmake/Modules/ApplyPkgConfig.cmake delete mode 100644 installer/pkgmgr_installer.c delete mode 100644 installer/pkgmgr_installer_signal_agent.c create mode 100644 installer/pkgmgr_installer_signal_agent.cc create mode 100644 installer/src/api_stub.cc create mode 100644 installer/src/control.cc create mode 100644 installer/src/control.hh rename installer/{ => src}/pkgmgr_installer.h (99%) rename installer/{ => src}/pkgmgr_installer_config.h (100%) rename installer/{ => src}/pkgmgr_installer_debug.h (76%) rename installer/{ => src}/pkgmgr_installer_error.h (100%) rename installer/{ => src}/pkgmgr_installer_info.h (100%) rename installer/{ => src}/pkgmgr_installer_type.h (100%) create mode 100644 installer/src/request.cc create mode 100644 installer/src/request.hh delete mode 100644 packaging/pkgmgr.changes create mode 100644 test/CMakeLists.txt create mode 100644 test/unit_tests/CMakeLists.txt create mode 100644 test/unit_tests/main.cc create mode 100644 test/unit_tests/mock/app_event_mock.cc create mode 100644 test/unit_tests/mock/app_event_mock.hh create mode 100644 test/unit_tests/mock/mock_hook.hh create mode 100644 test/unit_tests/mock/module_mock.hh create mode 100644 test/unit_tests/mock/rpc_port_mock.cc create mode 100644 test/unit_tests/mock/rpc_port_mock.hh create mode 100644 test/unit_tests/mock/test_fixture.cc create mode 100644 test/unit_tests/mock/test_fixture.hh create mode 100644 test/unit_tests/test_client.cc create mode 100755 tidl/PkgMgr.tidl create mode 100644 tidl/PkgSignal.tidl create mode 100755 tidl/prebuild.sh diff --git a/CMakeLists.txt b/CMakeLists.txt index 5a6fbfa..2cbea2f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,24 +1,41 @@ -CMAKE_MINIMUM_REQUIRED(VERSION 2.6) -SET(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS true) -SET(CMAKE_SKIP_BUILD_RPATH true) +CMAKE_MINIMUM_REQUIRED(VERSION 2.8) -PROJECT(package-manager C) -INCLUDE(TizenCommon) +PROJECT(package-manager) SET(PREFIX ${CMAKE_INSTALL_PREFIX}) SET(EXEC_PREFIX "\${prefix}") SET(LIBDIR ${LIB_INSTALL_DIR}) SET(INCLUDEDIR "\${prefix}/include") +SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/") SET(PKGMGR_CLIENT "pkgmgr-client") +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wl,-zdefs -fvisibility=hidden -g -Wall -fpic ") +SET(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS} -std=c++17 ") +SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed") -SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden -g -Wall") - +INCLUDE(TizenCommon) INCLUDE_DIRECTORIES(include) -INCLUDE_DIRECTORIES(comm) - INCLUDE(FindPkgConfig) +INCLUDE(ApplyPkgConfig) + +PKG_CHECK_MODULES(BUNDLE_DEPS REQUIRED bundle) +PKG_CHECK_MODULES(DLOG_DEPS REQUIRED dlog) +PKG_CHECK_MODULES(GMOCK_DEPS REQUIRED gmock) +PKG_CHECK_MODULES(GLIB_DEPS REQUIRED glib-2.0) +PKG_CHECK_MODULES(GIO_DEPS REQUIRED gio-2.0) +PKG_CHECK_MODULES(RPC_PORT_DEPS REQUIRED rpc-port) +PKG_CHECK_MODULES(CAPI_APPFW_EVENT_DEPS REQUIRED capi-appfw-event) +PKG_CHECK_MODULES(PKGMGR_PARSER_DEPS REQUIRED pkgmgr-parser) +PKG_CHECK_MODULES(PKGMGR_INFO_DEPS REQUIRED pkgmgr-info) +PKG_CHECK_MODULES(INIPARSER_DEPS REQUIRED iniparser) +PKG_CHECK_MODULES(XDGMIME_DEPS REQUIRED xdgmime) +PKG_CHECK_MODULES(PLATFORM_CONFIG_DEPS REQUIRED libtzplatform-config) +PKG_CHECK_MODULES(MINIZIP_DEPS REQUIRED minizip) ADD_SUBDIRECTORY(installer) ADD_SUBDIRECTORY(client) ADD_SUBDIRECTORY(types) + +ENABLE_TESTING() +SET(TARGET_PKGMGR_UNIT_TEST "pkgmgr-unit-test") +ADD_SUBDIRECTORY(test) diff --git a/client/CMakeLists.txt b/client/CMakeLists.txt index a59ff50..fe06c79 100644 --- a/client/CMakeLists.txt +++ b/client/CMakeLists.txt @@ -2,30 +2,28 @@ AUX_SOURCE_DIRECTORY(src SRCS) -pkg_check_modules(CLIENT_DEPS REQUIRED - glib-2.0 - gio-2.0 - dlog - pkgmgr-parser - pkgmgr-info - iniparser - xdgmime - libtzplatform-config - minizip) -FOREACH(CLIENT_FLAGS ${CLIENT_DEPS_CFLAGS}) - SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CLIENT_FLAGS}") -ENDFOREACH(CLIENT_FLAGS) - INCLUDE_DIRECTORIES(include) -SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC") - ADD_LIBRARY(${PKGMGR_CLIENT} SHARED ${SRCS}) +TARGET_INCLUDE_DIRECTORIES(${PKGMGR_CLIENT} PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/../") SET_TARGET_PROPERTIES(${PKGMGR_CLIENT} PROPERTIES SOVERSION ${MAJORVER}) SET_TARGET_PROPERTIES(${PKGMGR_CLIENT} PROPERTIES VERSION ${FULLVER}) -TARGET_LINK_LIBRARIES(${PKGMGR_CLIENT} - pkgmgr-info - ${CLIENT_DEPS_LDFLAGS}) + +APPLY_PKG_CONFIG(${PKGMGR_CLIENT} PUBLIC + GLIB_DEPS + GIO_DEPS + DLOG_DEPS + BUNDLE_DEPS + PKGMGR_PARSER_DEPS + PKGMGR_INFO_DEPS + INIPARSER_DEPS + XDGMIME_DEPS + PLATFORM_CONFIG_DEPS + MINIZIP_DEPS + RPC_PORT_DEPS + CAPI_APPFW_EVENT_DEPS +) +TARGET_LINK_LIBRARIES(${PKGMGR_CLIENT} PUBLIC "dl") CONFIGURE_FILE(pkgmgr.pc.in pkgmgr.pc @ONLY) CONFIGURE_FILE(pkg_path.conf.in pkg_path.conf @ONLY) diff --git a/client/include/package-manager.h b/client/include/package-manager.h index 9c0604a..5f26051 100644 --- a/client/include/package-manager.h +++ b/client/include/package-manager.h @@ -193,7 +193,7 @@ typedef struct { typedef struct _pkgmgr_res_event_info_t { int error_code; - GList *path_states; + void *path_states; } pkgmgr_res_event_info_t; typedef struct _res_event_path_state_t { diff --git a/client/src/api_stub.cc b/client/src/api_stub.cc new file mode 100644 index 0000000..a6760cf --- /dev/null +++ b/client/src/api_stub.cc @@ -0,0 +1,1809 @@ +/* + * Copyright (c) 2022 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. + */ + +#include +#include +#include + +#include "include/package-manager-types.h" +#include "include/package-manager-plugin.h" + +#include "client/include/package-manager.h" +#include "client/src/connector.hh" +#include "client/src/log.hh" +#include "client/src/internal.hh" + +#ifdef API +#undef API +#endif +#define API __attribute__ ((visibility("default"))) + +#define CONNECTION_RETRY_MAX 5 +#define CONNECTION_WAIT_USEC (1000000 / 2) /* 0.5 sec */ +#define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER) +#define REGULAR_USER 5000 + +using pkgmgr::client::Connector; + +namespace { + +static int GetDelayedResult(pkgmgr_client *pc, const std::string& req_key) { + if (pc == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_REQUEST) { + _E("client type is not PC_REQUEST"); + return PKGMGR_R_EINVAL; + } + + auto* proxy = con->GetDelayedResultProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + int retry_cnt = 0; + int ret = 0; + do { + if (proxy->GetResult(req_key, ret) == PKGMGR_R_OK) + return ret; + + _E("Failed to get result sleep and retry[%d/%d]", + retry_cnt, CONNECTION_RETRY_MAX); + usleep(CONNECTION_WAIT_USEC); + retry_cnt++; + } while (retry_cnt <= CONNECTION_RETRY_MAX); + + _E("Failed to get result"); + return PKGMGR_R_ERROR; +} + +static int ResultGetSizeSync(pkgmgr_client *pc, const std::string& req_key) { + if (pc == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_REQUEST) { + _E("client type is not PC_REQUEST"); + return PKGMGR_R_EINVAL; + } + + auto* proxy = con->GetInfoProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + int retry_cnt = 0; + int ret = PKGMGR_R_ECOMM; + long long size_info = 0; + do { + if (proxy->GetSizeSyncResult(req_key, ret, size_info) == PKGMGR_R_OK) { + if (ret != PKGMGR_R_OK) { + _E("request result failed: %d", ret); + return ret; + } + + if (size_info < 0) { + _E("invalid size_info=(%lld)", size_info); + return -1; + } + + _D("size_info(%lld), return size(%d)", size_info, ret); + return size_info; + } + + _E("Failed to get result sleep and retry[%d/%d]", + retry_cnt, CONNECTION_RETRY_MAX); + usleep(CONNECTION_WAIT_USEC); + retry_cnt++; + } while (retry_cnt <= CONNECTION_RETRY_MAX); + + _E("Failed to get result"); + return ret; +} + +static int GetGenerateLicenseResult(pkgmgr_client *pc, + const std::string& req_key, std::string &reqData, std::string &licenseUrl) { + if (pc == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_REQUEST) { + _E("client type is not PC_REQUEST"); + return PKGMGR_R_EINVAL; + } + + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + int retry_cnt = 0; + int ret = PKGMGR_R_ECOMM; + do { + if (proxy->GetGenerateLicenseResult(req_key, + ret, reqData, licenseUrl) == PKGMGR_R_OK) + return ret; + + _E("Failed to get result sleep and retry[%d/%d]", + retry_cnt, CONNECTION_RETRY_MAX); + usleep(CONNECTION_WAIT_USEC); + retry_cnt++; + } while (retry_cnt <= CONNECTION_RETRY_MAX); + + _E("Failed to get result"); + return ret; +} + +static inline uid_t GetUid() { + uid_t uid = getuid(); + + if (uid < REGULAR_USER) + return GLOBAL_USER; + else + return uid; +} + +} + +API pkgmgr_client* pkgmgr_client_new(pkgmgr_client_type pc_type) { + if (pc_type != PC_REQUEST && pc_type != PC_LISTENING) { + _E("invalid parameter(%d)", pc_type); + return nullptr; + } + + return new Connector(pc_type); +} + +API int pkgmgr_client_free(pkgmgr_client* pc) { + if (pc == nullptr) { + _E("invalid argument"); + return PKGMGR_R_EINVAL; + } + + Connector* con = static_cast(pc); + delete con; + + return PKGMGR_R_OK; +} + +API int pkgmgr_client_set_tep_path(pkgmgr_client *pc, const char *tep_path, + bool tep_move) { + if (pc == nullptr || tep_path == nullptr) { + _E("invalied parameter"); + return PKGMGR_R_EINVAL; + } + + Connector* con = static_cast(pc); + con->SetTep(tep_path, tep_move); + return PKGMGR_R_OK; +} + +API int pkgmgr_client_usr_install_packages(pkgmgr_client *pc, + const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb, + void *data, uid_t uid) { + if (pc == nullptr || pkg_paths == nullptr || n_pkgs < 1) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_REQUEST) { + _E("client type is not PC_REQUEST"); + return PKGMGR_R_EINVAL; + } + + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + std::string req_key; + std::vector pkgs; + for (int i = 0; i < n_pkgs; i++) + pkgs.push_back(pkg_paths[i]); + + const auto& receiver = con->GetSignalReceiver(); + int ret = proxy->InstallPkgs(uid, pkgs, con->GetArgv(), + con->GenerateRequestId(), req_key); + if (ret != PKGMGR_R_OK) + return ret; + + return receiver->AddEventHandler(req_key, event_cb, data); +} + +API int pkgmgr_client_install_packages(pkgmgr_client *pc, + const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb, + void *data) { + return pkgmgr_client_usr_install_packages(pc, pkg_paths, n_pkgs, + event_cb, data, getuid()); +} + +API int pkgmgr_client_install(pkgmgr_client *pc, const char *pkg_type, + const char *descriptor_path, const char *pkg_path, + const char *optional_data, pkgmgr_mode mode, + pkgmgr_handler event_cb, void *data) { + return pkgmgr_client_usr_install(pc, pkg_type, descriptor_path, pkg_path, + optional_data, mode, event_cb, data, getuid()); +} + +API int pkgmgr_client_usr_install(pkgmgr_client *pc, const char *pkg_type, + const char *descriptor_path, const char *pkg_path, + const char *optional_data, pkgmgr_mode mode, + pkgmgr_handler event_cb, void *data, uid_t uid) { + if (pc == nullptr || pkg_path == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_REQUEST) { + _E("client type is not PC_REQUEST"); + return PKGMGR_R_EINVAL; + } + + if (access(pkg_path, F_OK) != 0) { + _E("failed to access: %s", pkg_path); + return PKGMGR_R_EINVAL; + } + + if (!con->GetTepPath().empty()) { + if (access(con->GetTepPath().c_str(), F_OK) != 0) { + _E("failed to access: %s", con->GetTepPath().c_str()); + return PKGMGR_R_EINVAL; + } + + con->SetTepArgs(); + } + + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + const auto& receiver = con->GetSignalReceiver(); + std::string req_key; + int ret = proxy->Install(uid, pkg_type ? pkg_type : "", pkg_path, con->GetArgv(), + con->GenerateRequestId(), req_key); + if (ret != PKGMGR_R_OK) + return ret; + + return receiver->AddEventHandler(req_key, event_cb, data); +} + +API int pkgmgr_client_reinstall(pkgmgr_client *pc, const char *pkg_type, + const char *pkgid, const char *optional_data, pkgmgr_mode mode, + pkgmgr_handler event_cb, void *data) { + return pkgmgr_client_usr_reinstall(pc, pkg_type, pkgid, optional_data, + mode, event_cb, data, getuid()); +} + +API int pkgmgr_client_usr_reinstall(pkgmgr_client *pc, const char *pkg_type, + const char *pkgid, const char *optional_data, pkgmgr_mode mode, + pkgmgr_handler event_cb, void *data, uid_t uid) { + if (pc == nullptr || pkgid == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_REQUEST) { + _E("client type is not PC_REQUEST"); + return PKGMGR_R_EINVAL; + } + + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + const auto& receiver = con->GetSignalReceiver(); + std::string req_key; + int ret = proxy->Reinstall(uid, pkgid, req_key); + if (ret != PKGMGR_R_OK) + return ret; + + return receiver->AddEventHandler(req_key, event_cb, data); +} + +API int pkgmgr_client_uninstall_packages(pkgmgr_client *pc, + const char **pkgids, int n_pkgs, pkgmgr_handler event_cb, + void *data) { + return pkgmgr_client_usr_uninstall_packages(pc, pkgids, n_pkgs, + event_cb, data, getuid()); +} + +API int pkgmgr_client_usr_uninstall_packages(pkgmgr_client *pc, + const char **pkgids, int n_pkgs, pkgmgr_handler event_cb, + void *data, uid_t uid) { + if (pc == nullptr || pkgids == nullptr || n_pkgs < 1) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_REQUEST) { + _E("client type is not PC_REQUEST"); + return PKGMGR_R_EINVAL; + } + + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + std::string req_key; + std::vector pkgs; + for (int i = 0; i < n_pkgs; i++) + pkgs.push_back(pkgids[i]); + + const auto& receiver = con->GetSignalReceiver(); + int ret = proxy->UninstallPkgs(uid, pkgs, req_key); + if (ret != PKGMGR_R_OK) + return ret; + + return receiver->AddEventHandler(req_key, event_cb, data); +} + +API int pkgmgr_client_uninstall(pkgmgr_client *pc, const char *pkg_type, + const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb, + void *data) { + return pkgmgr_client_usr_uninstall(pc, pkg_type, pkgid, mode, event_cb, + data, getuid()); +} + +API int pkgmgr_client_usr_uninstall(pkgmgr_client *pc, const char *pkg_type, + const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb, + void *data, uid_t uid) { + if (pc == nullptr || pkgid == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_REQUEST) { + _E("client type is not PC_REQUEST"); + return PKGMGR_R_EINVAL; + } + + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + const auto& receiver = con->GetSignalReceiver(); + std::string req_key; + int ret = proxy->Uninstall(uid, pkgid, req_key); + if (ret != PKGMGR_R_OK) + return ret; + + return receiver->AddEventHandler(req_key, event_cb, data); +} + +API int pkgmgr_client_listen_res_status(pkgmgr_client *pc, + pkgmgr_res_handler event_cb, void *data) { + Connector* con = static_cast(pc); + if (con->GetPcType() != PC_LISTENING) { + _E("client->pc_type is not PC_LISTENING"); + return PKGMGR_R_EINVAL; + } + + try { + const auto& receiver = con->GetSignalReceiver(); + return receiver->AddEventHandler("", event_cb, data); + } catch (...) { + _E("exception occured"); + return PKGMGR_R_ERROR; + } +} + +API int pkgmgr_client_listen_pkg_upgrade_status(pkgmgr_client *pc, + pkgmgr_pkg_upgrade_handler event_cb, void *data) { + //TODO + return PKGMGR_R_OK; +} + +API int pkgmgr_client_usr_mount_install_packages(pkgmgr_client *pc, + const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb, + void *data, uid_t uid) { + if (pc == nullptr || pkg_paths == nullptr || n_pkgs < 1) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_REQUEST) { + _E("client type is not PC_REQUEST"); + return PKGMGR_R_EINVAL; + } + + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + std::string req_key; + std::vector pkgs; + for (int i = 0; i < n_pkgs; i++) { + if (access(pkg_paths[i], F_OK) != 0) { + _E("failed to access: %s", pkg_paths[i]); + return PKGMGR_R_EINVAL; + } + + pkgs.push_back(pkg_paths[i]); + } + + const auto& receiver = con->GetSignalReceiver(); + int ret = proxy->MountInstallPkgs(uid, pkgs, con->GenerateRequestId(), + req_key); + if (ret != PKGMGR_R_OK) + return ret; + + return receiver->AddEventHandler(req_key, event_cb, data); +} + +API int pkgmgr_client_mount_install_packages(pkgmgr_client *pc, + const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb, + void *data) { + return pkgmgr_client_usr_mount_install_packages(pc, pkg_paths, n_pkgs, + event_cb, data, getuid()); +} + +API int pkgmgr_client_mount_install(pkgmgr_client *pc, const char *pkg_type, + const char *descriptor_path, const char *pkg_path, + const char *optional_data, pkgmgr_mode mode, + pkgmgr_handler event_cb, void *data) { + return pkgmgr_client_usr_mount_install(pc, pkg_type, descriptor_path, + pkg_path, optional_data, mode, event_cb, data, + getuid()); +} + +API int pkgmgr_client_usr_mount_install(pkgmgr_client *pc, const char *pkg_type, + const char *descriptor_path, const char *pkg_path, + const char *optional_data, pkgmgr_mode mode, + pkgmgr_handler event_cb, void *data, uid_t uid) { + if (pc == nullptr || pkg_path == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_REQUEST) { + _E("client type is not PC_REQUEST"); + return PKGMGR_R_EINVAL; + } + + if (access(pkg_path, F_OK) != 0) { + _E("failed to access: %s", pkg_path); + return PKGMGR_R_EINVAL; + } + + if (!con->GetTepPath().empty()) { + if (access(con->GetTepPath().c_str(), F_OK) != 0) { + _E("failed to access: %s", con->GetTepPath().c_str()); + return PKGMGR_R_EINVAL; + } + + con->SetTepArgs(); + } + + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + const auto& receiver = con->GetSignalReceiver(); + std::string req_key; + int ret = proxy->MountInstall(uid, pkg_type ? pkg_type : "", pkg_path, + con->GetArgv(), con->GenerateRequestId(), req_key); + if (ret != PKGMGR_R_OK) + return ret; + + return receiver->AddEventHandler(req_key, event_cb, data); +} + +API int pkgmgr_client_move(pkgmgr_client *pc, const char *pkg_type, + const char *pkgid, pkgmgr_move_type move_type, + pkgmgr_handler event_cb, void *data) { + return pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type, + event_cb, data, getuid()); +} + +API int pkgmgr_client_usr_move(pkgmgr_client *pc, const char *pkg_type, + const char *pkgid, pkgmgr_move_type move_type, + pkgmgr_handler event_cb, void *data, uid_t uid) { + if (pc == nullptr || pkgid == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + if ((move_type < PM_MOVE_TO_INTERNAL) || + (move_type > PM_MOVE_TO_EXTENDED)) + return PKGMGR_R_EINVAL; + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_REQUEST) { + _E("client type is not PC_REQUEST"); + return PKGMGR_R_EINVAL; + } + + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + const auto& receiver = con->GetSignalReceiver(); + std::string req_key; + int ret = proxy->Move(uid, pkgid, move_type, req_key); + if (ret != PKGMGR_R_OK) + return ret; + + return receiver->AddEventHandler(req_key, event_cb, data); +} + +API int pkgmgr_client_register_pkg_update_info(pkgmgr_client *pc, + pkg_update_info_t *update_info) { + return pkgmgr_client_usr_register_pkg_update_info(pc, update_info, + getuid()); +} + +API int pkgmgr_client_usr_register_pkg_update_info(pkgmgr_client *pc, + pkg_update_info_t *update_info, uid_t uid) { + if (pc == nullptr || update_info == nullptr || update_info->pkgid == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_REQUEST) { + _E("client type is not PC_REQUEST"); + return PKGMGR_R_EINVAL; + } + + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + std::string req_key; + int ret = proxy->RegisterPkgUpdateInfo(uid, update_info->pkgid, + update_info->pkgid, update_info->type, req_key); + if (ret != 0) { + _E("Request fail"); + return ret; + } + + return GetDelayedResult(pc, req_key); +} + +API int pkgmgr_client_usr_unregister_pkg_update_info(pkgmgr_client *pc, + const char *pkgid, uid_t uid) { + if (pc == nullptr || pkgid == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_REQUEST) { + _E("client type is not PC_REQUEST"); + return PKGMGR_R_EINVAL; + } + + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + std::string req_key; + int ret = proxy->UnregisterPkgUpdateInfo(uid, pkgid, req_key); + + if (ret != 0) { + _E("Request fail"); + return ret; + } + + return GetDelayedResult(pc, req_key); +} + +API int pkgmgr_client_unregister_pkg_update_info(pkgmgr_client *pc, + const char *pkgid) { + return pkgmgr_client_usr_unregister_pkg_update_info(pc, pkgid, getuid()); +} + +API int pkgmgr_client_usr_unregister_all_pkg_update_info(pkgmgr_client *pc, + uid_t uid) { + if (pc == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_REQUEST) { + _E("client type is not PC_REQUEST"); + return PKGMGR_R_EINVAL; + } + + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + std::string req_key; + return proxy->UnregisterAllPkgUpdateInfo(uid, req_key); +} + +API int pkgmgr_client_unregister_all_pkg_update_info(pkgmgr_client *pc) { + return pkgmgr_client_usr_unregister_all_pkg_update_info(pc, getuid()); +} + +API int pkgmgr_client_usr_activate(pkgmgr_client *pc, const char *pkg_type, + const char *pkgid, uid_t uid) { + if (pc == nullptr || pkgid == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + std::string req_key; + return proxy->EnablePkgs(uid, { pkgid }, req_key); +} + +API int pkgmgr_client_activate(pkgmgr_client *pc, const char *pkg_type, + const char *pkgid) { + return pkgmgr_client_usr_activate(pc, pkg_type, pkgid, getuid()); +} + +API int pkgmgr_client_usr_activate_packages(pkgmgr_client *pc, + const char *pkg_type, const char **pkgids, int n_pkgs, + pkgmgr_handler event_cb, void *data, uid_t uid) { + if (pc == nullptr || pkgids == nullptr || n_pkgs < 1) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_REQUEST) { + _E("client type is not PC_REQUEST"); + return PKGMGR_R_EINVAL; + } + + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + std::string req_key; + std::vector vec; + for (int i = 0; i < n_pkgs; i++) { + vec.push_back(pkgids[i]); + } + + const auto& receiver = con->GetSignalReceiver(); + int ret = proxy->EnablePkgs(uid, std::move(vec), req_key); + if (ret != PKGMGR_R_OK) + return ret; + + return receiver->AddEventHandler(req_key, event_cb, data); +} + +API int pkgmgr_client_activate_packages(pkgmgr_client *pc, + const char *pkg_type, const char **pkgids, int n_pkgs, + pkgmgr_handler event_cb, void *data) { + return pkgmgr_client_usr_activate_packages(pc, pkg_type, + pkgids, n_pkgs, event_cb, data, getuid()); +} + +API int pkgmgr_client_usr_deactivate(pkgmgr_client *pc, const char *pkg_type, + const char *pkgid, uid_t uid) { + if (pc == nullptr || pkgid == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + std::string req_key; + return proxy->DisablePkgs(uid, { pkgid }, req_key); +} + +API int pkgmgr_client_deactivate(pkgmgr_client *pc, const char *pkg_type, + const char *pkgid) { + return pkgmgr_client_usr_deactivate(pc, pkg_type, pkgid, getuid()); +} + +API int pkgmgr_client_usr_deactivate_packages(pkgmgr_client *pc, + const char *pkg_type, const char **pkgids, int n_pkgs, + pkgmgr_handler event_cb, void *data, uid_t uid) { + if (pc == nullptr || pkgids == nullptr || n_pkgs < 1) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_REQUEST) { + _E("client type is not PC_REQUEST"); + return PKGMGR_R_EINVAL; + } + + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + std::string req_key; + std::vector vec; + for (int i = 0; i < n_pkgs; i++) { + vec.push_back(pkgids[i]); + } + const auto& receiver = con->GetSignalReceiver(); + int ret = proxy->DisablePkgs(uid, std::move(vec), req_key); + if (ret != PKGMGR_R_OK) + return ret; + + return receiver->AddEventHandler(req_key, event_cb, data); +} + +API int pkgmgr_client_deactivate_packages(pkgmgr_client *pc, + const char *pkg_type, const char **pkgids, int n_pkgs, + pkgmgr_handler event_cb, void *data) { + return pkgmgr_client_usr_deactivate_packages(pc, pkg_type, + pkgids, n_pkgs, event_cb, data, getuid()); +} + +API int pkgmgr_client_usr_activate_app(pkgmgr_client *pc, const char *appid, + pkgmgr_app_handler app_event_cb, void *data, uid_t uid) { + if (pc == nullptr || appid == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + const auto& receiver = con->GetSignalReceiver(); + std::string req_key; + int ret = proxy->EnableApp(uid, appid, req_key); + if (ret != PKGMGR_R_OK) + return ret; + + return receiver->AddEventHandler(req_key, app_event_cb, data); +} + +API int pkgmgr_client_activate_app(pkgmgr_client *pc, const char *appid, + pkgmgr_app_handler app_event_cb, void *data) { + return pkgmgr_client_usr_activate_app(pc, appid, app_event_cb, + data, getuid()); +} + +API int pkgmgr_client_usr_activate_apps(pkgmgr_client *pc, const char **appids, + int n_apps, pkgmgr_app_handler app_event_cb, void *data, uid_t uid) { + if (pc == nullptr || appids == nullptr || n_apps < 1) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_REQUEST) { + _E("client type is not PC_REQUEST"); + return PKGMGR_R_EINVAL; + } + + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + std::string req_key; + std::vector vec; + for (int i = 0; i < n_apps; i++) { + vec.push_back(appids[i]); + } + + const auto& receiver = con->GetSignalReceiver(); + int ret = proxy->EnableApps(uid, std::move(vec), req_key); + if (ret != PKGMGR_R_OK) + return ret; + + return receiver->AddEventHandler(req_key, app_event_cb, data); +} + +API int pkgmgr_client_activate_apps(pkgmgr_client *pc, const char **appids, + int n_apps, pkgmgr_app_handler app_event_cb, void *data) { + return pkgmgr_client_usr_activate_apps(pc, appids, n_apps, + app_event_cb, data, getuid()); +} + +API int pkgmgr_client_activate_global_app_for_uid(pkgmgr_client *pc, + const char *appid, pkgmgr_app_handler app_event_cb, void *data, uid_t uid) { + if (pc == nullptr || appid == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + const auto& receiver = con->GetSignalReceiver(); + std::string req_key; + int ret = proxy->EnableGlobalAppForUid(uid, appid, req_key); + if (ret != PKGMGR_R_OK) + return ret; + + return receiver->AddEventHandler(req_key, app_event_cb, data); +} + +API int pkgmgr_client_usr_deactivate_app(pkgmgr_client *pc, const char *appid, + pkgmgr_app_handler app_event_cb, void *data, uid_t uid) { + if (pc == nullptr || appid == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + const auto& receiver = con->GetSignalReceiver(); + std::string req_key; + int ret = proxy->DisableApp(uid, appid, req_key); + if (ret != PKGMGR_R_OK) + return ret; + + return receiver->AddEventHandler(req_key, app_event_cb, data); +} + +API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid, + pkgmgr_app_handler app_event_cb, void *data) { + return pkgmgr_client_usr_deactivate_app(pc, appid, app_event_cb, data, + getuid()); +} + +API int pkgmgr_client_usr_deactivate_apps(pkgmgr_client *pc, + const char **appids, int n_apps, + pkgmgr_app_handler app_event_cb, void *data, uid_t uid) { + if (pc == nullptr || appids == nullptr || n_apps < 1) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_REQUEST) { + _E("client type is not PC_REQUEST"); + return PKGMGR_R_EINVAL; + } + + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + std::string req_key; + std::vector vec; + for (int i = 0; i < n_apps; i++) { + vec.push_back(appids[i]); + } + + const auto& receiver = con->GetSignalReceiver(); + int ret = proxy->DisableApps(uid, std::move(vec), req_key); + if (ret != PKGMGR_R_OK) + return ret; + + return receiver->AddEventHandler(req_key, app_event_cb, data); +} + +API int pkgmgr_client_deactivate_apps(pkgmgr_client *pc, const char **appids, + int n_apps, pkgmgr_app_handler app_event_cb, void *data) { + return pkgmgr_client_usr_deactivate_apps(pc, appids, n_apps, + app_event_cb, data, getuid()); +} + +API int pkgmgr_client_deactivate_global_app_for_uid(pkgmgr_client *pc, + const char *appid, pkgmgr_app_handler app_event_cb, void *data, uid_t uid) { + if (pc == nullptr || appid == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + const auto& receiver = con->GetSignalReceiver(); + std::string req_key; + int ret = proxy->DisableGlobalAppForUid(uid, appid, req_key); + if (ret != PKGMGR_R_OK) + return ret; + + return receiver->AddEventHandler(req_key, app_event_cb, data); +} + +API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type, + const char *pkgid, pkgmgr_mode mode) { + return pkgmgr_client_usr_clear_user_data(pc, pkg_type, pkgid, mode, + getuid()); +} + +API int pkgmgr_client_usr_clear_user_data(pkgmgr_client *pc, + const char *pkg_type, const char *pkgid, pkgmgr_mode mode, + uid_t uid) { + if (pc == nullptr || pkgid == nullptr || uid == GLOBAL_USER) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_REQUEST) { + _E("client type is not PC_REQUEST"); + return PKGMGR_R_EINVAL; + } + + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + return proxy->ClearData(uid, pkgid); +} + +API int pkgmgr_client_usr_clear_user_data_with_path(pkgmgr_client *pc, + const char *pkg_type, const char *pkgid, const char *file_path, + pkgmgr_mode mode, uid_t uid) +{ + if (!pc || !pkgid || !file_path || uid == GLOBAL_USER) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_REQUEST) { + _E("client type is not PC_REQUEST"); + return PKGMGR_R_EINVAL; + } + + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + return proxy->ClearDataWithPath(uid, pkgid, file_path); +} + +API int pkgmgr_client_clear_user_data_with_path(pkgmgr_client *pc, const char *pkg_type, + const char *pkgid, const char *file_path, pkgmgr_mode mode) +{ + return pkgmgr_client_usr_clear_user_data_with_path(pc, pkg_type, pkgid, + file_path, mode, GetUid()); +} + +API int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type) { + //TODO + return PKGMGR_R_OK; +} + +API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb, + void *data) { + if (pc == nullptr || event_cb == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_LISTENING) { + _E("client->pc_type is not PC_LISTENING"); + return PKGMGR_R_EINVAL; + } + + try { + const auto& receiver = con->GetSignalReceiver(); + return receiver->AddEventHandler("", event_cb, data); + } catch (...) { + _E("exception occured"); + return PKGMGR_R_ERROR; + } +} + +API int pkgmgr_client_listen_app_status(pkgmgr_client *pc, + pkgmgr_app_handler app_event_cb, void *data) { + if (pc == nullptr || app_event_cb == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_LISTENING) { + _E("client->pc_type is not PC_LISTENING"); + return PKGMGR_R_EINVAL; + } + + try { + const auto& receiver = con->GetSignalReceiver(); + return receiver->AddEventHandler("", app_event_cb, data); + } catch (...) { + _E("exception occured"); + return PKGMGR_R_ERROR; + } +} + +API int pkgmgr_client_remove_listen_status(pkgmgr_client *pc) { + //TODO + return PKGMGR_R_OK; +} + +API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type, + const char *pkgid, const char *key, const char *val) { + /* client cannot broadcast signal */ + return PKGMGR_R_OK; +} + +/* TODO: deprecate(or remove) */ +API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type, + int service_mode, pkgmgr_client *pc, const char *pkg_type, + const char *pkgid, const char *custom_info, + pkgmgr_handler event_cb, void *data) { + return pkgmgr_client_usr_request_service(service_type, service_mode, + pc, pkg_type, pkgid, getuid(), custom_info, event_cb, + data); +} + +API int pkgmgr_client_usr_request_service( + pkgmgr_request_service_type service_type, int service_mode, + pkgmgr_client *pc, const char *pkg_type, const char *pkgid, + uid_t uid, const char *custom_info, pkgmgr_handler event_cb, + void *data) { + switch (service_type) { + case PM_REQUEST_MOVE: { + return pkgmgr_client_usr_move(pc, pkg_type, pkgid, + static_cast(service_mode), + event_cb, data, uid); + } + case PM_REQUEST_GET_SIZE: { + auto* con = static_cast(pc); + auto* proxy = con->GetInfoProxy(); + std::string req_key; + int ret = proxy->GetSizeSync(uid, pkgid, service_mode, req_key); + if (ret != PKGMGR_R_OK) + return ret; + + return ResultGetSizeSync(pc, req_key); + } + case PM_REQUEST_KILL_APP: { + auto* con = static_cast(pc); + auto* proxy = con->GetAdminProxy(); + int pid = 0; + int ret = proxy->Kill(uid, pkgid, pid); + *(int *)data = pid; + + return ret; + } + case PM_REQUEST_CHECK_APP: { + auto* con = static_cast(pc); + auto* proxy = con->GetInfoProxy(); + int pid = 0; + int ret = proxy->Check(uid, pkgid, pid); + *(int *)data = pid; + + return ret; + } + default: + _E("Wrong Request"); + break; + } + return 0; +} + +API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid) { + if (!pkgid) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = new Connector(PC_REQUEST); + auto* proxy = con->GetCacheProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + int ret = proxy->ClearCache(uid, pkgid); + delete con; + + return ret; +} + +API int pkgmgr_client_clear_cache_dir(const char *pkgid) { + return pkgmgr_client_usr_clear_cache_dir(pkgid, getuid()); +} + +API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid) { + return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid); +} + +API int pkgmgr_client_clear_all_cache_dir() { + return pkgmgr_client_usr_clear_cache_dir( + PKG_CLEAR_ALL_CACHE, getuid()); +} + +API int pkgmgr_client_get_size(pkgmgr_client *pc, const char *pkgid, + pkgmgr_getsize_type get_type, pkgmgr_handler event_cb, + void *data) { + return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data, + getuid()); +} + +/* TODO: deprecate(or remove) */ +API int pkgmgr_client_usr_get_size(pkgmgr_client *pc, const char *pkgid, + pkgmgr_getsize_type get_type, pkgmgr_handler event_cb, + void *data, uid_t uid) { + if (pc == nullptr || pkgid == nullptr || event_cb == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0) + get_type = PM_GET_TOTAL_PKG_SIZE_INFO; + else + get_type = PM_GET_PKG_SIZE_INFO; + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_REQUEST) { + _E("client type is not PC_REQUEST"); + return PKGMGR_R_EINVAL; + } + + auto* proxy = con->GetInfoProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + const auto& receiver = con->GetSignalReceiver(); + std::string req_key; + int ret = proxy->GetSize(uid, pkgid, get_type, req_key); + if (ret != PKGMGR_R_OK) + return ret; + + return receiver->AddEventHandler(req_key, event_cb, data); +} + +API int pkgmgr_client_get_package_size_info(pkgmgr_client *pc, + const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb, + void *user_data) { + return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb, + user_data, getuid()); +} + +API int pkgmgr_client_usr_get_total_package_size_info(pkgmgr_client *pc, + pkgmgr_total_pkg_size_info_receive_cb event_cb, + void *user_data, uid_t uid) { + return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL, + (pkgmgr_pkg_size_info_receive_cb)event_cb, + user_data, uid); +} + +API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc, + pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data) { + return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL, + (pkgmgr_pkg_size_info_receive_cb)event_cb, + user_data, getuid()); +} + +API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc, + const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb, + void *user_data, uid_t uid) { + if (pc == nullptr || pkgid == nullptr || event_cb == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + int get_type; + if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0) + get_type = PM_GET_TOTAL_PKG_SIZE_INFO; + else + get_type = PM_GET_PKG_SIZE_INFO; + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_REQUEST) { + _E("client type is not PC_REQUEST"); + return PKGMGR_R_EINVAL; + } + + auto* proxy = con->GetInfoProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + const auto& receiver = con->GetSignalReceiver(); + std::string req_key; + int ret = proxy->GetSize(uid, pkgid, get_type, req_key); + if (ret != PKGMGR_R_OK) + return ret; + + receiver->AddEventHandler(req_key, event_cb, pc, user_data); + + return PKGMGR_R_OK; +} + +API int pkgmgr_client_generate_license_request(pkgmgr_client *pc, + const char *resp_data, char **req_data, char **license_url) { + if (pc == nullptr || resp_data == nullptr || req_data == nullptr || + license_url == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_REQUEST) { + _E("client type is not PC_REQUEST"); + return PKGMGR_R_EINVAL; + } + + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + std::string data; + std::string url; + std::string req_key; + int ret = proxy->GenerateLicenseRequest(resp_data, req_key); + if (ret != PKGMGR_R_OK) + return ret; + + ret = GetGenerateLicenseResult(pc, req_key, data, url); + if (ret != PKGMGR_R_OK) + return ret; + + *req_data = strdup(data.c_str()); + *license_url = strdup(url.c_str()); + return PKGMGR_R_OK; +} + +API int pkgmgr_client_register_license(pkgmgr_client *pc, const char *resp_data) { + if (pc == nullptr || resp_data == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_REQUEST) { + _E("client type is not PC_REQUEST"); + return PKGMGR_R_EINVAL; + } + + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + std::string req_key; + int ret = proxy->RegisterLicense(resp_data, req_key); + + if (ret != 0) { + _E("Request fail"); + return ret; + } + + return GetDelayedResult(pc, req_key); +} + +API int pkgmgr_client_decrypt_package(pkgmgr_client *pc, + const char *drm_file_path, const char *decrypted_file_path) { + if (pc == nullptr || drm_file_path == nullptr || + decrypted_file_path == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + if (con->GetPcType() != PC_REQUEST) { + _E("client type is not PC_REQUEST"); + return PKGMGR_R_EINVAL; + } + + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + std::string req_key; + int ret = proxy->DecryptPackage(drm_file_path, decrypted_file_path, req_key); + + if (ret != 0) { + _E("Request fail"); + return ret; + } + + return GetDelayedResult(pc, req_key); +} + +API int pkgmgr_client_enable_splash_screen(pkgmgr_client *pc, const char *appid) { + return pkgmgr_client_usr_enable_splash_screen(pc, appid, getuid()); +} + +API int pkgmgr_client_usr_enable_splash_screen(pkgmgr_client *pc, + const char *appid, uid_t uid) { + if (pc == nullptr || appid == nullptr) { + _E("Invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + return proxy->EnableAppSplashScreen(uid, appid); +} + +API int pkgmgr_client_disable_splash_screen(pkgmgr_client *pc, + const char *appid) { + return pkgmgr_client_usr_disable_splash_screen(pc, appid, + getuid()); +} + +API int pkgmgr_client_usr_disable_splash_screen(pkgmgr_client *pc, + const char *appid, uid_t uid) { + if (pc == nullptr || appid == nullptr) { + _E("Invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + return proxy->DisableAppSplashScreen(uid, appid); +} + +API int pkgmgr_client_usr_set_pkg_restriction_mode(pkgmgr_client *pc, + const char *pkgid, int mode, uid_t uid) { + if (pc == nullptr || pkgid == nullptr || strlen(pkgid) == 0 || mode <= 0) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + return PKGMGR_R_OK; +} + +API int pkgmgr_client_set_pkg_restriction_mode(pkgmgr_client *pc, + const char *pkgid, int mode) { + return pkgmgr_client_usr_set_pkg_restriction_mode(pc, pkgid, mode, + getuid()); +} + +API int pkgmgr_client_usr_unset_pkg_restriction_mode(pkgmgr_client *pc, + const char *pkgid, int mode, uid_t uid) { + if (pc == nullptr || pkgid == nullptr || strlen(pkgid) == 0 || mode <= 0) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + return PKGMGR_R_OK; +} + +API int pkgmgr_client_unset_pkg_restriction_mode(pkgmgr_client *pc, + const char *pkgid, int mode) { + return pkgmgr_client_usr_unset_pkg_restriction_mode(pc, pkgid, mode, + getuid()); +} + +API int pkgmgr_client_usr_get_pkg_restriction_mode(pkgmgr_client *pc, + const char *pkgid, int *mode, uid_t uid) { + if (pc == nullptr || pkgid == nullptr || strlen(pkgid) == 0) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + return PKGMGR_R_OK; +} + +API int pkgmgr_client_get_pkg_restriction_mode(pkgmgr_client *pc, + const char *pkgid, int *mode) { + return pkgmgr_client_usr_get_pkg_restriction_mode(pc, pkgid, mode, + getuid()); +} + +API int pkgmgr_client_usr_set_restriction_mode(pkgmgr_client *pc, int mode, + uid_t uid) { + if (pc == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + return PKGMGR_R_OK; +} + +API int pkgmgr_client_set_restriction_mode(pkgmgr_client *pc, int mode) { + return pkgmgr_client_usr_set_restriction_mode(pc, mode, getuid()); +} + +API int pkgmgr_client_usr_unset_restriction_mode(pkgmgr_client *pc, int mode, + uid_t uid) { + if (pc == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + return PKGMGR_R_OK; +} + +API int pkgmgr_client_unset_restriction_mode(pkgmgr_client *pc, int mode) { + return pkgmgr_client_usr_unset_restriction_mode(pc, mode, getuid()); +} + +API int pkgmgr_client_usr_get_restriction_mode(pkgmgr_client *pc, + int *mode, uid_t uid) { + if (pc == nullptr || mode == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + *mode = 0; + + return PKGMGR_R_OK; +} + +API int pkgmgr_client_get_restriction_mode(pkgmgr_client *pc, int *mode) { + return pkgmgr_client_usr_get_restriction_mode(pc, mode, getuid()); +} + +API pkgmgr_info *pkgmgr_client_check_pkginfo_from_file(const char *pkg_path) { + if (pkg_path == nullptr) { + _E("invalid parameter"); + return nullptr; + } + + std::string type = pkgmgr::client::GetTypeFromPath(pkg_path); + if (type.empty()) { + _E("invalid package type"); + return nullptr; + } + + pkg_plugin_set* plugin_set = pkgmgr::client::LoadPluginSet(type); + if (!plugin_set) { + _E("failed to load library for %s", type.c_str()); + return nullptr; + } + + package_manager_pkg_detail_info_t* info = + reinterpret_cast( + calloc(1, sizeof(package_manager_pkg_detail_info_t))); + if (!info) { + _E("out of memory"); + return nullptr; + } + + int r = plugin_set->get_pkg_detail_info_from_package(pkg_path, info); + if (r) { + _E("failed to get package detail info"); + free(info); + return nullptr; + } + + return info; +} + +API int pkgmgr_client_free_pkginfo(pkgmgr_info *info) { + package_manager_pkg_detail_info_t *pkg_info = + reinterpret_cast(info); + if (pkg_info == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + g_list_free_full(pkg_info->privilege_list, free); + free(pkg_info->icon_buf); + free(pkg_info); + + return PKGMGR_R_OK; +} + +API int pkgmgr_client_usr_set_app_label(pkgmgr_client *pc, char *appid, + char *label, uid_t uid) { + if (pc == nullptr || appid == nullptr || label == nullptr) { + _E("Invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + std::string req_key; + int ret = proxy->SetAppLabel(uid, appid, label, req_key); + + if (ret != 0) { + _E("Request fail"); + return ret; + } + + return GetDelayedResult(pc, req_key); +} + +API int pkgmgr_client_set_app_label(pkgmgr_client *pc, char *appid, char *label) { + return pkgmgr_client_usr_set_app_label(pc, appid, label, getuid()); +} + +API int pkgmgr_client_usr_set_app_icon(pkgmgr_client *pc, char *appid, + char *icon_path, uid_t uid) { + if (pc == nullptr || appid == nullptr || icon_path == nullptr) { + _E("Invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + std::string req_key; + int ret = proxy->SetAppIcon(uid, appid, icon_path, req_key); + + if (ret != 0) { + _E("Request fail"); + return ret; + } + + return GetDelayedResult(pc, req_key); +} + +API int pkgmgr_client_set_app_icon(pkgmgr_client *pc, char *appid, char *icon_path) { + return pkgmgr_client_usr_set_app_icon(pc, appid, icon_path, getuid()); +} + +API int pkgmgr_client_set_debug_mode(pkgmgr_client *pc, bool debug_mode) { + if (pc == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + if (debug_mode) + con->SetDebugMode(); + + return PKGMGR_R_OK; +} + +API int pkgmgr_client_set_skip_optimization(pkgmgr_client *pc, bool skip_optimization) { + if (pc == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + if (skip_optimization) + con->SetSkipOptimization(); + + return PKGMGR_R_OK; +} + +API int pkgmgr_client_usr_migrate_external_image(pkgmgr_client *pc, + const char *pkgid, uid_t uid) { + if (pc == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + return proxy->MigrateExternalImage(uid, pkgid); +} + +API int pkgmgr_client_add_res_copy_path(pkgmgr_client *pc, + const char *src_path, const char *dest_path) { + if (pc == nullptr || src_path == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + con->GetResCopyPath().emplace_back(src_path, dest_path ? dest_path: ""); + + return PKGMGR_R_OK; +} + +API int pkgmgr_client_res_copy(pkgmgr_client *pc, + pkgmgr_res_handler event_cb, void *user_data) { + if (pc == nullptr || event_cb == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + const auto& receiver = con->GetSignalReceiver(); + + std::string req_key; + int ret = proxy->ResCopy(con->GetResCopyPath(), req_key); + if (ret != PKGMGR_R_OK) + return ret; + + return receiver->AddEventHandler(req_key, event_cb, user_data); +} + +API int pkgmgr_client_add_res_create_dir_path(pkgmgr_client *pc, + const char *dir_path) { + if (pc == nullptr || dir_path == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + con->GetResCreateDir().emplace_back(dir_path); + + return PKGMGR_R_OK; +} + +API int pkgmgr_client_res_create_dir(pkgmgr_client *pc, + pkgmgr_res_handler event_cb, void *user_data) { + if (pc == nullptr || event_cb == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + const auto& receiver = con->GetSignalReceiver(); + + std::string req_key; + int ret = proxy->ResCreateDir(con->GetResCreateDir(), req_key); + if (ret != PKGMGR_R_OK) + return ret; + + return receiver->AddEventHandler(req_key, event_cb, user_data); +} + +API int pkgmgr_client_add_res_remove_path(pkgmgr_client *pc, + const char *res_path) { + if (pc == nullptr || res_path == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + con->GetResRemovePath().push_back(res_path); + + return PKGMGR_R_OK; +} + +API int pkgmgr_client_res_remove(pkgmgr_client *pc, + pkgmgr_res_handler event_cb, void *user_data) { + if (pc == nullptr || event_cb == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + const auto& receiver = con->GetSignalReceiver(); + + std::string req_key; + int ret = proxy->ResRemove(con->GetResRemovePath(), req_key); + if (ret != PKGMGR_R_OK) + return ret; + + return receiver->AddEventHandler(req_key, event_cb, user_data); +} + +API int pkgmgr_client_res_uninstall(pkgmgr_client *pc, const char *pkgid) { + return pkgmgr_client_res_usr_uninstall(pc, pkgid, getuid()); +} + +API int pkgmgr_client_res_usr_uninstall(pkgmgr_client *pc, const char *pkgid, + uid_t uid) { + if (pc == nullptr || pkgid == nullptr) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + auto* con = static_cast(pc); + auto* proxy = con->GetAdminProxy(); + if (proxy == nullptr) + return PKGMGR_R_EIO; + + std::string req_key; + return proxy->ResUninstall(uid, pkgid, req_key); +} + +API pkgmgr_res_event_info *pkgmgr_res_event_info_new() { + pkgmgr_res_event_info* info = + reinterpret_cast( + new rpc_port::PkgSignal::ExtraData); + if (!info) { + _E("Out of memory"); + return nullptr; + } + return info; +} + +API int pkgmgr_res_event_info_free(pkgmgr_res_event_info *info) { + if (!info) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + rpc_port::PkgSignal::ExtraData* event_info = + reinterpret_cast(info); + delete event_info; + + return PKGMGR_R_OK; +} + +API int pkgmgr_res_event_info_set_error_code(pkgmgr_res_event_info *handle, int error_code) { + if (!handle) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + rpc_port::PkgSignal::ExtraData* event_info = + reinterpret_cast(handle); + event_info->SetErrCode(error_code); + + return PKGMGR_R_OK; +} + +API int pkgmgr_res_event_info_get_error_code(pkgmgr_res_event_info *handle, int *error_code) { + if (!handle) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + rpc_port::PkgSignal::ExtraData* event_info = + reinterpret_cast(handle); + *error_code = event_info->GetErrCode(); + + return PKGMGR_R_OK; +} + +API int pkgmgr_res_event_info_add_path_state(pkgmgr_res_event_info *handle, + const char *path, pkgmgr_res_event_path_state state) { + if (!handle || !path) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + rpc_port::PkgSignal::ExtraData* event_info = + reinterpret_cast(handle); + + auto paths = event_info->GetPaths(); + paths.emplace_back(path, state); + event_info->SetPaths(std::move(paths)); + + return PKGMGR_R_OK; +} + +API int pkgmgr_res_event_info_foreach_path(pkgmgr_res_event_info *handle, + pkgmgr_res_event_path_cb callback, void *user_data) { + if (!handle || !callback) { + _E("invalid parameter"); + return PKGMGR_R_EINVAL; + } + + rpc_port::PkgSignal::ExtraData* event_info = + reinterpret_cast(handle); + + for (const auto& p : event_info->GetPaths()) { + if (callback(p.GetPath().c_str(), + static_cast(p.GetState()), user_data) < 0) + return PKGMGR_R_OK; + } + + return PKGMGR_R_OK; +} diff --git a/client/src/connection_event_listener.hh b/client/src/connection_event_listener.hh new file mode 100644 index 0000000..35a8a5d --- /dev/null +++ b/client/src/connection_event_listener.hh @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2022 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. + */ + + +#ifndef CLIENT_SRC_CONNECTION_EVENT_LISTENER_H_ +#define CLIENT_SRC_CONNECTION_EVENT_LISTENER_H_ + +#include +#include + +#include "PkgMgrProxy.h" + +namespace pkgmgr { +namespace client { + +enum class ConnectionState { + NotRequested, + Connected, + Disconnected, + Rejected, +}; + +template +class ConnectionEventListener : public T::IEventListener { + public: + void OnConnected() override { + state_ = ConnectionState::Connected; + } + + void OnDisconnected() override { + state_ = ConnectionState::Disconnected; + } + + void OnRejected() override { + state_ = ConnectionState::Rejected; + } + + ConnectionState GetState() const { + return state_; + } + + private: + ConnectionState state_ = ConnectionState::NotRequested; +}; + +} // namespace client +} // namespace pkgmgr + +#endif // CLIENT_SRC_CONNECTION_EVENT_LISTENER_H_ \ No newline at end of file diff --git a/client/src/connector.cc b/client/src/connector.cc new file mode 100644 index 0000000..a7a950f --- /dev/null +++ b/client/src/connector.cc @@ -0,0 +1,357 @@ +/* + * Copyright (c) 2022 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. + */ + +#include "connector.hh" + +#include +#include +#include +#include + +#include "log.hh" + +#define REGULAR_USER 5000 + +namespace { + +constexpr const char SERVER_PROC_NAME[] = "org.tizen.appfw.pkgmgr"; +constexpr const char PACKAGE_MANAGER_SOCKET_PATH[] = "/run/package-manager"; + +static int _is_system_user(void) +{ + uid_t uid = getuid(); + + if (uid < REGULAR_USER) + return 1; + else + return 0; +} + +static bool __is_system_type(pkgmgr_client_type type) +{ + if (type == PC_REQUEST || _is_system_user()) + return true; + else + return false; +} + +} + +namespace pkgmgr { +namespace client { + +Connector::~Connector() = default; + +std::string Connector::GenerateRequestId() const { + struct timeval tv; + gettimeofday(&tv, NULL); + long curtime = tv.tv_sec * 1000000 + tv.tv_usec; + + return std::to_string(getpid()) + "_" + std::to_string(curtime); +} + +void Connector::SetTep(std::string tep_path, bool tep_move) { + tep_path_ = std::move(tep_path); + tep_move_ = tep_move; +} + +void Connector::SetTepArgs() { + argv_.push_back("-e"); + argv_.push_back(tep_path_); + argv_.push_back("-M"); + argv_.push_back(tep_move_ ? "tep_move" : "tep_copy"); +} + +void Connector::SetDebugMode() { + argv_.push_back("-G"); +} + +void Connector::SetSkipOptimization() { + argv_.push_back("-S"); +} + +const std::vector& Connector::GetArgv() const { + return argv_; +} + +pkg_proxy::PkgMgrAdmin* Connector::GetAdminProxy() { + if (!ConnectForAdmin()) + return nullptr; + + return admin_proxy_.get(); +} + +pkg_proxy::PkgMgr* Connector::GetInfoProxy() { + if (!ConnectForInfo()) + return nullptr; + + return info_proxy_.get(); +} + +pkg_proxy::PkgMgrForClearCache* Connector::GetCacheProxy() { + if (!ConnectForCache()) + return nullptr; + + return cache_proxy_.get(); +} + +pkg_proxy::DelayedResult* Connector::GetDelayedResultProxy() { + if (!ConnectForDelayedResult()) + return nullptr; + + return delayed_result_proxy_.get(); +} + +bool Connector::ConnectForAdmin() { + if (!admin_proxy_) { + admin_proxy_.reset(new pkg_proxy::PkgMgrAdmin(&conn_admin_listener_, + SERVER_PROC_NAME)); + } + + if (conn_admin_listener_.GetState() == ConnectionState::Connected) + return true; + + if (!activator_.Connect()) + return false; + + try { + admin_proxy_->Connect(true); + } catch (const pkg_proxy::Exception& e) { + return false; + } + + return true; +} + +bool Connector::ConnectForInfo() { + if (!info_proxy_) { + info_proxy_.reset(new pkg_proxy::PkgMgr(&conn_info_listener_, + SERVER_PROC_NAME)); + } + + if (conn_info_listener_.GetState() == ConnectionState::Connected) + return true; + + if (!activator_.Connect()) + return false; + + try { + info_proxy_->Connect(true); + } catch (const pkg_proxy::Exception& e) { + return false; + } + + return true; +} + +bool Connector::ConnectForCache() { + if (!cache_proxy_) { + cache_proxy_.reset(new pkg_proxy::PkgMgrForClearCache(&conn_cache_listener_, + SERVER_PROC_NAME)); + } + + if (conn_cache_listener_.GetState() == ConnectionState::Connected) + return true; + + if (!activator_.Connect()) + return false; + + try { + cache_proxy_->Connect(true); + } catch (const pkg_proxy::Exception& e) { + return false; + } + + return true; +} + +bool Connector::ConnectForDelayedResult() { + if (!delayed_result_proxy_) { + delayed_result_proxy_.reset(new pkg_proxy::DelayedResult( + &conn_delayed_result_listener_, SERVER_PROC_NAME)); + } + + if (conn_delayed_result_listener_.GetState() == ConnectionState::Connected) + return true; + + if (!activator_.Connect()) + return false; + + try { + delayed_result_proxy_->Connect(true); + } catch (const pkg_proxy::Exception& e) { + return false; + } + + return true; +} + +const std::unique_ptr& Connector::GetSignalReceiver() { + if (!signal_receiver_) + signal_receiver_.reset(new SignalReceiver(__is_system_type(pc_type_))); + + return signal_receiver_; +} + +pkgmgr_client_type Connector::GetPcType() const { + return pc_type_; +} + +std::vector& Connector::GetResRemovePath() { + return res_remove_path_; +} + +std::vector& Connector::GetResCreateDir() { + return res_create_dir_; +} + +std::vector& Connector::GetResCopyPath() { + return res_copy_path_; +} + +const std::string& Connector::GetTepPath() { + return tep_path_; +} + +bool Connector::GetTepMove() { + return tep_move_; +} + +bool Connector::Activator::Connect() { + if (!Create()) + return false; + + SetTimeout(60 * 1000); + + int retry_cnt = 3; + do { + int ret = TryConnect(); + if (ret == 0) { + break; + } else if (ret < -1) { + _E("Maybe peer not launched or peer dead. path: %s, fd: %d", + PACKAGE_MANAGER_SOCKET_PATH, fd_); + // If requester is root, don't wait + if (getuid() == 0) + return false; + + usleep(100 * 1000); + --retry_cnt; + } else if (ret < 0) { + _E("Failed to connect to socket: %s, fd: %d", + PACKAGE_MANAGER_SOCKET_PATH, fd_); + return false; + } + } while (retry_cnt > 0); + + if (retry_cnt == 0) { + _E("Failed to connect with server"); + return false; + } + + return ReceiveReady(); +} + +bool Connector::Activator::Create() { + if (fd_ != -1) + return true; + + fd_ = ::socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0); + if (fd_ < 0) { + _E("socket() is failed. errno: %d", errno); + return false; + } + + addr_.sun_family = AF_UNIX; + snprintf(addr_.sun_path, sizeof(addr_.sun_path), "%s", + PACKAGE_MANAGER_SOCKET_PATH); + return true; +} + +void Connector::Activator::SetTimeout(int timeout_msec) { + if (timeout_msec < 0) { + _E("Invalid timeout parameter"); + return; + } + + timeval timeout = { + .tv_sec = static_cast(timeout_msec / 1000), + .tv_usec = static_cast(timeout_msec % 1000) * 1000 + }; + if (setsockopt(fd_, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) < 0) + _E("setsockopt() is failed, fd: %d, errno : %d", fd_, errno); +} + +int Connector::Activator::TryConnect() { + int ret = connect(fd_, reinterpret_cast(&addr_), sizeof(addr_)); + _E("ret = %d", ret); + if (ret < 0) { + if (errno != EAGAIN && errno != EINPROGRESS) + return -2; + } + + return 0; +} + + +bool Connector::Activator::ReceiveReady() { + bool is_blocking; + if (fcntl(fd_, F_GETFL, 0) & O_NONBLOCK) + is_blocking = false; + else + is_blocking = true; + + int retry_count = 20; + size_t len = 1; + char buffer[2] = {0,}; + while (len) { + ssize_t bytes = recv(fd_, buffer, len, 0); + if (bytes == 0) { + _W("EOF. fd(%d)", fd_); + return -ECOMM; + } + + if (bytes < 0) { + if (errno == EINTR || errno == EAGAIN) { + if (is_blocking && errno == EAGAIN) { + _E("Timed out. fd(%d)", fd_); + return -EAGAIN; + } + + if (retry_count > 0) { + usleep(100 * 1000); + retry_count--; + continue; + } + } + + _E("recv() is failed. fd(%d), errno(%d)", fd_, errno); + return -ECOMM; + } + _E("bytes: %d\n", bytes); + len -= bytes; + } + + _E("Received: %s\n", buffer); + + close(fd_); + fd_ = -1; + + return true; +} + +} // namespace client +} // namespace pkgmgr diff --git a/client/src/connector.hh b/client/src/connector.hh new file mode 100644 index 0000000..aa359a4 --- /dev/null +++ b/client/src/connector.hh @@ -0,0 +1,105 @@ +/* + * Copyright (c) 2022 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. + */ + + +#ifndef CLIENT_SRC_CONNECTOR_H_ +#define CLIENT_SRC_CONNECTOR_H_ + +#include + +#include +#include +#include + +#include "PkgMgrProxy.h" + +#include "connection_event_listener.hh" +#include "signal_receiver.hh" + +namespace pkgmgr { +namespace client { + +namespace pkg_proxy = rpc_port::PkgMgrProxy::proxy; +namespace pp = rpc_port::PkgMgrProxy; + +class Connector { + public: + Connector(pkgmgr_client_type pc_type) : pc_type_(pc_type) {} + virtual ~Connector(); + + virtual pkg_proxy::PkgMgrAdmin* GetAdminProxy(); + virtual pkg_proxy::PkgMgr* GetInfoProxy(); + virtual pkg_proxy::PkgMgrForClearCache* GetCacheProxy(); + virtual pkg_proxy::DelayedResult* GetDelayedResultProxy(); + virtual const std::unique_ptr& GetSignalReceiver(); + std::string GenerateRequestId() const; + void SetTep(std::string tep_path, bool tep_move); + void SetTepArgs(); + void SetDebugMode(); + void SetSkipOptimization(); + const std::vector& GetArgv() const; + pkgmgr_client_type GetPcType() const; + std::vector& GetResRemovePath(); + std::vector& GetResCreateDir(); + std::vector& GetResCopyPath(); + const std::string& GetTepPath(); + bool GetTepMove(); + + private: + bool ConnectForAdmin(); + bool ConnectForInfo(); + bool ConnectForCache(); + bool ConnectForDelayedResult(); + + private: + class Activator { + public: + Activator() : fd_(-1), addr_{} {} + + bool Connect(); + bool Create(); + void SetTimeout(int timeout_msec); + int TryConnect(); + bool ReceiveReady(); + + private: + int fd_; + sockaddr_un addr_; + }; + + pkgmgr_client_type pc_type_; + std::unique_ptr info_proxy_; + std::unique_ptr cache_proxy_; + std::unique_ptr admin_proxy_; + std::unique_ptr delayed_result_proxy_; + std::vector argv_; + ConnectionEventListener conn_admin_listener_; + ConnectionEventListener conn_info_listener_; + ConnectionEventListener conn_cache_listener_; + ConnectionEventListener conn_delayed_result_listener_; + std::unique_ptr signal_receiver_; + std::vector res_remove_path_; + std::vector res_create_dir_; + std::vector res_copy_path_; + std::string tep_path_; + bool tep_move_ = false; + Activator activator_; +}; + +} // namespace client +} // namespace pkgmgr + +#endif // CLIENT_SRC_CONNECTOR_H_ \ No newline at end of file diff --git a/client/src/internal.cc b/client/src/internal.cc new file mode 100644 index 0000000..a02ec3a --- /dev/null +++ b/client/src/internal.cc @@ -0,0 +1,111 @@ +/* + * Copyright (c) 2023 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. + */ + +#include "client/src/internal.hh" + +#include +#include +#include +#include +#include + +#include +#include + +#include "include/package-manager-plugin.h" +#include "log.hh" + +namespace { + +// TODO: Add rpk type +const std::map kTypeMap = { + {"res/wgt/config.xml", "wgt"}, + {"config.xml", "wgt"}, + {"tizen-manifest.xml", "tpk"}, +}; +const char kPkgLibPath[] = "/etc/package-manager/backendlib/"; + +static pkg_plugin_set* plugin_set_list[24] = { 0, }; + +} // namespace + +namespace pkgmgr { +namespace client { + +std::string GetTypeFromPath(const std::string& path) { + unzFile uf = unzOpen(path.c_str()); + if (uf == nullptr) { + _E("failed to open zip file %s", path.c_str()); + return ""; + } + + std::string type; + for (const auto& kv : kTypeMap) { + if (unzLocateFile(uf, kv.first.c_str(), 0) == UNZ_OK) { + _D("pkgtype of %s: [%s]", path.c_str(), kv.first.c_str()); + type = kv.second; + break; + } + } + unzClose(uf); + + return type; +} + +pkg_plugin_set* LoadPluginSet(const std::string& type) { + int i; + for (i = 0; plugin_set_list[i]; i++) { + if (strcmp(plugin_set_list[i]->pkg_type, type.c_str()) == 0) { + _D("already loaded for [%s]", type.c_str()); + return plugin_set_list[i]; + } + } + + std::string lib_path = kPkgLibPath + type + ".so"; + void* handle = dlopen(lib_path.c_str(), RTLD_LAZY); + if (!handle) { + _E("failed to load library %s", lib_path.c_str()); + return nullptr; + } + + bool (*on_load)(pkg_plugin_set* plugin); + on_load = reinterpret_cast( + dlsym(handle, "pkg_plugin_on_load")); + if (!on_load || dlerror()) { + _E("can not find symbol"); + dlclose(handle); + return nullptr; + } + + if (on_load(plugin_set_list[i]) != 0) { + _E("pkg_plugin_on_load failed"); + free(plugin_set_list[i]); + dlclose(handle); + plugin_set_list[i] = nullptr; + return nullptr; + } + + plugin_set_list[i]->plugin_handle = handle; + snprintf(plugin_set_list[i]->pkg_type, sizeof(plugin_set_list[i]->pkg_type), + "%s", type.c_str()); + + _D("library [%s] is loaded", lib_path.c_str()); + + return plugin_set_list[i]; +} + +} // namespace pkgmgr +} // namespace client diff --git a/client/src/internal.hh b/client/src/internal.hh new file mode 100644 index 0000000..edc78f3 --- /dev/null +++ b/client/src/internal.hh @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2023 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. + */ + +#ifndef CLIENT_SRC_INTERNAL_HH_ +#define CLIENT_SRC_INTERNAL_HH_ + +#include + +#include "include/package-manager-plugin.h" + +namespace pkgmgr { +namespace client { + +std::string GetTypeFromPath(const std::string& path); +pkg_plugin_set* LoadPluginSet(const std::string& type); + +} // namespace client +} // namespace pkgmgr + +#endif // CLIENT_SRC_INTERNAL_HH_ \ No newline at end of file diff --git a/client/src/log.hh b/client/src/log.hh new file mode 100644 index 0000000..5668dd6 --- /dev/null +++ b/client/src/log.hh @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2022 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. + */ + + +#ifndef SRC_LOG_H_ +#define SRC_LOG_H_ + +#include + +#ifdef LOG_TAG +#undef LOG_TAG +#endif /* LOG_TAG */ +#define LOG_TAG "PKGMGR_CLIENT" + +#undef _E +#define _E LOGE + +#undef _W +#define _W LOGW + +#undef _I +#define _I LOGI + +#undef _D +#define _D LOGD + +#endif // SRC_LOG_H_ \ No newline at end of file diff --git a/client/src/pkgmgr.c b/client/src/pkgmgr.c deleted file mode 100644 index 3887f55..0000000 --- a/client/src/pkgmgr.c +++ /dev/null @@ -1,3262 +0,0 @@ -/* - * slp-pkgmgr - * - * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. - * - * Contact: Jayoun Lee , Sewook Park , - * Jaeho Lee , Shobhit Srivastava - * - * 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. - * - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include - -#include -#include -/* For multi-user support */ -#include - -#include "package-manager.h" -#include "package-manager-types.h" -#include "pkgmgr_client_debug.h" -#include "pkgmgr_client_internal.h" - -/* API export macro */ -#ifndef API -#define API __attribute__ ((visibility("default"))) -#endif - -#define BINSH_NAME "/bin/sh" -#define BINSH_SIZE 7 - -#define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER) -#define REGULAR_USER 5000 - -static GList *jobs_to_free; -static pthread_mutex_t __mutex = PTHREAD_MUTEX_INITIALIZER; - -static inline uid_t _getuid(void) -{ - uid_t uid = getuid(); - - if (uid < REGULAR_USER) - return GLOBAL_USER; - else - return uid; -} - -static int _get_internal_request_id() -{ - static int internal_req_id = 1; - - return internal_req_id++; -} - -static char *_generate_request_id(void) -{ - struct timeval tv; - long curtime; - char buf[BUFMAX]; - - gettimeofday(&tv, NULL); - curtime = tv.tv_sec * 1000000 + tv.tv_usec; - - snprintf(buf, sizeof(buf), "%d_%ld", getpid(), curtime); - - return strdup(buf); -} - -static struct cb_info *__create_event_cb_info(struct pkgmgr_client_t *client, - pkgmgr_handler event_cb, void *data, const char *req_key) -{ - struct cb_info *cb_info; - - cb_info = calloc(1, sizeof(struct cb_info)); - if (cb_info == NULL) { - ERR("out of memory"); - return NULL; - } - cb_info->client = client; - cb_info->event_cb = event_cb; - cb_info->data = data; - cb_info->req_id = _get_internal_request_id(); - if (req_key != NULL) { - cb_info->req_key = strdup(req_key); - if (cb_info->req_key == NULL) { - ERR("out of memory"); - free(cb_info); - return NULL; - } - } - - return cb_info; -} - -static struct cb_info *__create_app_event_cb_info( - struct pkgmgr_client_t *client, pkgmgr_app_handler app_event_cb, - void *data, const char *req_key) -{ - struct cb_info *cb_info; - - cb_info = calloc(1, sizeof(struct cb_info)); - if (cb_info == NULL) { - ERR("out of memory"); - return NULL; - } - cb_info->client = client; - cb_info->app_event_cb = app_event_cb; - cb_info->data = data; - cb_info->req_id = _get_internal_request_id(); - if (req_key != NULL) { - cb_info->req_key = strdup(req_key); - if (cb_info->req_key == NULL) { - ERR("out of memory"); - free(cb_info); - return NULL; - } - } - - return cb_info; -} - -static struct cb_info *__create_res_event_cb_info( - struct pkgmgr_client_t *client, - pkgmgr_res_handler res_event_cb, - void *data, const char *req_key) -{ - struct cb_info *cb_info; - - cb_info = calloc(1, sizeof(struct cb_info)); - if (cb_info == NULL) { - ERR("out of memory"); - return NULL; - } - - cb_info->client = client; - cb_info->res_event_cb = res_event_cb; - cb_info->data = data; - cb_info->req_id = _get_internal_request_id(); - if (req_key == NULL) - return cb_info; - - cb_info->req_key = strdup(req_key); - if (cb_info->req_key == NULL) { - ERR("out of memory"); - free(cb_info); - return NULL; - } - - return cb_info; -} - -static struct cb_info *__create_upgrade_event_cb_info( - struct pkgmgr_client_t *client, - pkgmgr_pkg_upgrade_handler upgrade_event_cb, - void *data, const char *req_key) -{ - struct cb_info *cb_info; - - cb_info = calloc(1, sizeof(struct cb_info)); - if (cb_info == NULL) { - ERR("out of memory"); - return NULL; - } - - cb_info->client = client; - cb_info->upgrade_event_cb = upgrade_event_cb; - cb_info->data = data; - cb_info->req_id = _get_internal_request_id(); - if (req_key == NULL) - return cb_info; - - cb_info->req_key = strdup(req_key); - if (cb_info->req_key == NULL) { - ERR("out of memory"); - free(cb_info); - return NULL; - } - - return cb_info; -} - -static struct cb_info *__create_size_info_cb_info( - struct pkgmgr_client_t *client, - pkgmgr_pkg_size_info_receive_cb size_info_cb, - void *data, const char *req_key) -{ - struct cb_info *cb_info; - - cb_info = calloc(1, sizeof(struct cb_info)); - if (cb_info == NULL) { - ERR("out of memory"); - return NULL; - } - cb_info->client = client; - cb_info->size_info_cb = size_info_cb; - cb_info->data = data; - cb_info->req_id = _get_internal_request_id(); - if (req_key != NULL) { - cb_info->req_key = strdup(req_key); - if (cb_info->req_key == NULL) { - ERR("out of memory"); - free(cb_info); - return NULL; - } - } - - return cb_info; -} - -static int __jobs_to_free_add(gpointer data) -{ - pthread_mutex_lock(&__mutex); - if (g_list_find(jobs_to_free, data)) { - pthread_mutex_unlock(&__mutex); - return -1; - } - - jobs_to_free = g_list_append(jobs_to_free, data); - pthread_mutex_unlock(&__mutex); - return 0; -} - -static void __jobs_to_free_remove(gpointer data) -{ - pthread_mutex_lock(&__mutex); - jobs_to_free = g_list_remove(jobs_to_free, data); - pthread_mutex_unlock(&__mutex); -} - -static void __do_free_cb_info(gpointer data) -{ - struct cb_info *cb_info = (struct cb_info *)data; - - g_list_free(cb_info->sid_list); - free(cb_info->req_key); - free(cb_info); -} - -static void __free_cb_info_cb(gpointer data) -{ - g_idle_remove_by_data(data); - __do_free_cb_info(data); -} - -__attribute__((destructor)) static void __free_cb_info_at_destructor(void) -{ - pthread_mutex_lock(&__mutex); - g_list_free_full(jobs_to_free, __free_cb_info_cb); - pthread_mutex_unlock(&__mutex); -} - -static gboolean __free_cb_info_at_idle(gpointer data) -{ - __jobs_to_free_remove(data); - __do_free_cb_info(data); - - return G_SOURCE_REMOVE; -} - -static void __free_cb_info(struct cb_info *cb_info) -{ - if (__jobs_to_free_add(cb_info) < 0) - return; - - g_idle_add(__free_cb_info_at_idle, cb_info); -} - -static int __get_size_process(pkgmgr_client *pc, const char *pkgid, uid_t uid, - pkgmgr_getsize_type get_type, pkgmgr_handler event_cb, - void *data) -{ - GVariant *result; - int ret = PKGMGR_R_ECOMM; - long long size_info = 0; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (pc == NULL || pkgid == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->pc_type != PC_REQUEST) { - ERR("client->pc_type is not PC_REQUEST"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, "getsize_sync", - g_variant_new("(usi)", uid, pkgid, get_type), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(ix)", &ret, &size_info); - if (ret != PKGMGR_R_OK) { - ERR("request result failed: %d", ret); - g_variant_unref(result); - return ret; - } - - if (size_info < 0) { - ERR("invalid size_info=(%lld)", size_info); - ret = -1; - } else { - ret = (int)size_info; - DBG("size_info(%lld), return size(%d)", size_info, ret); - } - - g_variant_unref(result); - - return ret; -} - -static int __move_pkg_process(pkgmgr_client *pc, const char *pkgid, - const char *pkg_type, uid_t uid, pkgmgr_move_type move_type, - pkgmgr_handler event_cb, void *data) -{ - int ret; - - ret = pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type, event_cb, data, uid); - if (ret < 0) { - ERR("move request failed"); - return ret; - } - - return ret; -} - -static int __check_app_process(pkgmgr_request_service_type service_type, - pkgmgr_client *pc, const char *pkgid, uid_t uid, void *data) -{ - GVariant *result; - int ret = PKGMGR_R_ECOMM; - pkgmgrinfo_pkginfo_h handle; - int pid = -1; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - retvm_if(client->pc_type != PC_REQUEST, PKGMGR_R_EINVAL, "client->pc_type is not PC_REQUEST\n"); - - ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle); - if (ret != PMINFO_R_OK) { - ERR("pkgmgrinfo_pkginfo_get_pkginfo failed"); - pkgmgrinfo_pkginfo_destroy_pkginfo(handle); - return PKGMGR_R_ERROR; - } - - if (service_type == PM_REQUEST_KILL_APP) { - ret = pkgmgr_client_connection_send_request(client, "kill", - g_variant_new("(us)", uid, pkgid), &result); - } else if (service_type == PM_REQUEST_CHECK_APP) { - ret = pkgmgr_client_connection_send_request(client, "check", - g_variant_new("(us)", uid, pkgid), &result); - } else { - ERR("unexpected service type: %d", service_type); - ret = PKGMGR_R_ERROR; - } - - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - pkgmgrinfo_pkginfo_destroy_pkginfo(handle); - return ret; - } - - g_variant_get(result, "(ii)", &ret, &pid); - g_variant_unref(result); - if (ret != PKGMGR_R_OK) { - ERR("request failed, ret=%d", ret); - pkgmgrinfo_pkginfo_destroy_pkginfo(handle); - return ret; - } - - *(int *)data = pid; - - pkgmgrinfo_pkginfo_destroy_pkginfo(handle); - - return ret; - -} - -API pkgmgr_client *pkgmgr_client_new(pkgmgr_client_type pc_type) -{ - struct pkgmgr_client_t *client; - - if (pc_type == PC_BROADCAST) { - ERR("broadcast type is not supported"); - return NULL; - } - - if (pc_type != PC_REQUEST && pc_type != PC_LISTENING) { - ERR("invalid parameter"); - return NULL; - } - - client = calloc(1, sizeof(struct pkgmgr_client_t)); - if (client == NULL) { - ERR("out of memory"); - return NULL; - } - - client->pc_type = pc_type; - client->status_type = PKGMGR_CLIENT_STATUS_ALL; - - if (pkgmgr_client_connection_connect(client) != PKGMGR_R_OK) { - free(client); - return NULL; - } - - return (pkgmgr_client *)client; -} - -API int pkgmgr_client_free(pkgmgr_client *pc) -{ - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (pc == NULL) { - ERR("invalid argument"); - return PKGMGR_R_EINVAL; - } - - pkgmgr_client_remove_listen_status(client); - pkgmgr_client_connection_disconnect(client); - if (client->tep_path) - free(client->tep_path); - if (client->res_copy_builder) - g_variant_builder_unref(client->res_copy_builder); - if (client->res_remove_builder) - g_variant_builder_unref(client->res_remove_builder); - if (client->res_create_dir_builder) - g_variant_builder_unref(client->res_create_dir_builder); - free(client); - - return PKGMGR_R_OK; -} - -struct manifest_and_type type_map[] = { - { "res/wgt/config.xml", "wgt" }, - { "config.xml", "wgt" }, - { "tizen-manifest.xml", "tpk" }, - { NULL, NULL } -}; - -static char *__get_type_from_path(const char *pkg_path) -{ - const char *type = NULL; - unzFile uf; - int i; - - uf = unzOpen(pkg_path); - if (uf == NULL) { - ERR("failed to open zip file %s", pkg_path); - return NULL; - } - - for (i = 0; type_map[i].manifest != NULL; i++) { - if (unzLocateFile(uf, type_map[i].manifest, 0) == UNZ_OK) { - DBG("pkgtype of %s: [%s]", pkg_path, type_map[i].type); - type = type_map[i].type; - break; - } - } - unzClose(uf); - - return type ? strdup(type) : NULL; -} - -API int pkgmgr_client_set_tep_path(pkgmgr_client *pc, const char *tep_path, - bool tep_move) -{ - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *) pc; - - if (pc == NULL || tep_path == NULL) { - ERR("invalied parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->tep_path) - free(client->tep_path); - - client->tep_path = strdup(tep_path); - client->tep_move = tep_move; - - return PKGMGR_R_OK; -} - -API int pkgmgr_client_usr_install_packages(pkgmgr_client *pc, - const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb, - void *data, uid_t uid) -{ - GVariant *result; - GVariantBuilder *pkgs_builder; - GVariant *pkgs; - GVariantBuilder *args_builder; - GVariant *args; - int ret; - char *req_key = NULL; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - struct cb_info *cb_info; - int i; - char *request_id = NULL; - - if (pc == NULL || pkg_paths == NULL || n_pkgs < 1) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->pc_type != PC_REQUEST) { - ERR("client type is not PC_REQUEST"); - return PKGMGR_R_EINVAL; - } - - for (i = 0; i < n_pkgs; i++) { - if (access(pkg_paths[i], F_OK) != 0) { - ERR("failed to access: %s", pkg_paths[i]); - return PKGMGR_R_EINVAL; - } - } - - pkgs_builder = g_variant_builder_new(G_VARIANT_TYPE("as")); - for (i = 0; i < n_pkgs; i++) - g_variant_builder_add(pkgs_builder, "s", pkg_paths[i]); - pkgs = g_variant_new("as", pkgs_builder); - g_variant_builder_unref(pkgs_builder); - - args_builder = g_variant_builder_new(G_VARIANT_TYPE("as")); - if (client->debug_mode) - g_variant_builder_add(args_builder, "s", "-G"); - if (client->skip_optimization) - g_variant_builder_add(args_builder, "s", "-S"); - args = g_variant_new("as", args_builder); - g_variant_builder_unref(args_builder); - - request_id = _generate_request_id(); - ret = pkgmgr_client_connection_send_request(client, "install_pkgs", - g_variant_new("(u@as@ass)", uid, pkgs, args, - request_id), - &result); - free(request_id); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i&s)", &ret, &req_key); - if (req_key == NULL) { - g_variant_unref(result); - return PKGMGR_R_ECOMM; - } - if (ret != PKGMGR_R_OK) { - g_variant_unref(result); - return ret; - } - - cb_info = __create_event_cb_info(client, event_cb, data, req_key); - if (cb_info == NULL) { - g_variant_unref(result); - return PKGMGR_R_ERROR; - } - g_variant_unref(result); - ret = pkgmgr_client_connection_set_callback(client, cb_info); - if (ret != PKGMGR_R_OK) { - __free_cb_info(cb_info); - return ret; - } - client->cb_info_list = g_list_append(client->cb_info_list, cb_info); - - return cb_info->req_id; -} - -API int pkgmgr_client_install_packages(pkgmgr_client *pc, - const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb, - void *data) -{ - return pkgmgr_client_usr_install_packages(pc, pkg_paths, n_pkgs, - event_cb, data, _getuid()); -} - -API int pkgmgr_client_usr_install(pkgmgr_client *pc, const char *pkg_type, - const char *descriptor_path, const char *pkg_path, - const char *optional_data, pkgmgr_mode mode, - pkgmgr_handler event_cb, void *data, uid_t uid) -{ - GVariant *result; - int ret = PKGMGR_R_ECOMM; - char *req_key = NULL; - GVariantBuilder *builder = NULL; - GVariant *args = NULL; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - struct cb_info *cb_info; - char *request_id = NULL; - - if (pc == NULL || pkg_path == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->pc_type != PC_REQUEST) { - ERR("client type is not PC_REQUEST"); - return PKGMGR_R_EINVAL; - } - - if (access(pkg_path, F_OK) != 0) { - ERR("failed to access: %s", pkg_path); - return PKGMGR_R_EINVAL; - } - - if (client->tep_path != NULL && access(client->tep_path, F_OK) != 0) { - ERR("failed to access: %s", client->tep_path); - return PKGMGR_R_EINVAL; - } - - /* build arguments */ - builder = g_variant_builder_new(G_VARIANT_TYPE("as")); - if (client->tep_path) { - g_variant_builder_add(builder, "s", "-e"); - g_variant_builder_add(builder, "s", client->tep_path); - g_variant_builder_add(builder, "s", "-M"); - /* TODO: revise tep_move */ - g_variant_builder_add(builder, "s", - client->tep_move ? "tep_move" : "tep_copy"); - } - if (client->debug_mode) - g_variant_builder_add(builder, "s", "-G"); - if (client->skip_optimization) - g_variant_builder_add(builder, "s", "-S"); - - args = g_variant_new("as", builder); - g_variant_builder_unref(builder); - - request_id = _generate_request_id(); - ret = pkgmgr_client_connection_send_request(client, "install", - g_variant_new("(uss@ass)", uid, pkg_type ? pkg_type : "", - pkg_path, args, request_id), - &result); - free(request_id); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i&s)", &ret, &req_key); - if (req_key == NULL) { - g_variant_unref(result); - return PKGMGR_R_ECOMM; - } - if (ret != PKGMGR_R_OK) { - g_variant_unref(result); - return ret; - } - - cb_info = __create_event_cb_info(client, event_cb, data, req_key); - if (cb_info == NULL) { - g_variant_unref(result); - return PKGMGR_R_ENOMEM; - } - g_variant_unref(result); - ret = pkgmgr_client_connection_set_callback(client, cb_info); - if (ret != PKGMGR_R_OK) { - __free_cb_info(cb_info); - return ret; - } - client->cb_info_list = g_list_append(client->cb_info_list, cb_info); - return cb_info->req_id; -} - -API int pkgmgr_client_install(pkgmgr_client *pc, const char *pkg_type, - const char *descriptor_path, const char *pkg_path, - const char *optional_data, pkgmgr_mode mode, - pkgmgr_handler event_cb, void *data) -{ - return pkgmgr_client_usr_install(pc, pkg_type, descriptor_path, - pkg_path, optional_data, mode, event_cb, data, - _getuid()); -} - -API int pkgmgr_client_reinstall(pkgmgr_client *pc, const char *pkg_type, - const char *pkgid, const char *optional_data, pkgmgr_mode mode, - pkgmgr_handler event_cb, void *data) -{ - return pkgmgr_client_usr_reinstall(pc, pkg_type, pkgid, optional_data, - mode, event_cb, data, _getuid()); -} - -API int pkgmgr_client_usr_reinstall(pkgmgr_client *pc, const char *pkg_type, - const char *pkgid, const char *optional_data, pkgmgr_mode mode, - pkgmgr_handler event_cb, void *data, uid_t uid) -{ - GVariant *result; - int ret = PKGMGR_R_ECOMM; - char *req_key = NULL; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - struct cb_info *cb_info; - - if (pc == NULL || pkgid == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->pc_type != PC_REQUEST) { - ERR("client->pc_type is not PC_REQUEST"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, "reinstall", - g_variant_new("(us)", uid, pkgid), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i&s)", &ret, &req_key); - if (req_key == NULL) { - g_variant_unref(result); - return PKGMGR_R_ECOMM; - } - if (ret != PKGMGR_R_OK) { - g_variant_unref(result); - return ret; - } - - cb_info = __create_event_cb_info(client, event_cb, data, req_key); - if (cb_info == NULL) { - g_variant_unref(result); - return PKGMGR_R_ENOMEM; - } - g_variant_unref(result); - ret = pkgmgr_client_connection_set_callback(client, cb_info); - if (ret != PKGMGR_R_OK) { - __free_cb_info(cb_info); - return ret; - } - client->cb_info_list = g_list_append(client->cb_info_list, cb_info); - - return cb_info->req_id; -} - -API int pkgmgr_client_usr_mount_install_packages(pkgmgr_client *pc, - const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb, - void *data, uid_t uid) -{ - GVariant *result; - GVariantBuilder *pkgs_builder; - GVariant *pkgs; - int ret = PKGMGR_R_ECOMM; - char *req_key = NULL; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - struct cb_info *cb_info; - int i; - char *request_id = NULL; - - if (pc == NULL || pkg_paths == NULL || n_pkgs < 1) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->pc_type != PC_REQUEST) { - ERR("client->pc_type is not PC_REQUEST"); - return PKGMGR_R_EINVAL; - } - - for (i = 0; i < n_pkgs; i++) { - if (access(pkg_paths[i], F_OK) != 0) { - ERR("failed to access: %s", pkg_paths[i]); - return PKGMGR_R_EINVAL; - } - } - - pkgs_builder = g_variant_builder_new(G_VARIANT_TYPE("as")); - for (i = 0; i < n_pkgs; i++) - g_variant_builder_add(pkgs_builder, "s", pkg_paths[i]); - pkgs = g_variant_new("as", pkgs_builder); - g_variant_builder_unref(pkgs_builder); - - request_id = _generate_request_id(); - ret = pkgmgr_client_connection_send_request(client, - "mount_install_pkgs", - g_variant_new("(u@ass)", uid, pkgs, request_id), - &result); - free(request_id); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i&s)", &ret, &req_key); - if (req_key == NULL) { - g_variant_unref(result); - return PKGMGR_R_ECOMM; - } - if (ret != PKGMGR_R_OK) { - g_variant_unref(result); - return ret; - } - - cb_info = __create_event_cb_info(client, event_cb, data, req_key); - if (cb_info == NULL) { - g_variant_unref(result); - return PKGMGR_R_ENOMEM; - } - g_variant_unref(result); - ret = pkgmgr_client_connection_set_callback(client, cb_info); - if (ret != PKGMGR_R_OK) { - __free_cb_info(cb_info); - return ret; - } - client->cb_info_list = g_list_append(client->cb_info_list, cb_info); - - return cb_info->req_id; -} - -API int pkgmgr_client_mount_install_packages(pkgmgr_client *pc, - const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb, - void *data) -{ - return pkgmgr_client_usr_mount_install_packages(pc, pkg_paths, n_pkgs, - event_cb, data, _getuid()); -} - -API int pkgmgr_client_usr_mount_install(pkgmgr_client *pc, const char *pkg_type, - const char *descriptor_path, const char *pkg_path, - const char *optional_data, pkgmgr_mode mode, - pkgmgr_handler event_cb, void *data, uid_t uid) -{ - GVariant *result; - int ret = PKGMGR_R_ECOMM; - char *req_key = NULL; - GVariantBuilder *builder = NULL; - GVariant *args = NULL; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - struct cb_info *cb_info; - char *request_id = NULL; - - if (pc == NULL || pkg_path == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->pc_type != PC_REQUEST) { - ERR("client->pc_type is not PC_REQUEST"); - return PKGMGR_R_EINVAL; - } - - if (access(pkg_path, F_OK) != 0) { - ERR("failed to access: %s", pkg_path); - return PKGMGR_R_EINVAL; - } - - if (client->tep_path != NULL && access(client->tep_path, F_OK) != 0) { - ERR("failed to access: %s", client->tep_path); - return PKGMGR_R_EINVAL; - } - - /* build arguments */ - builder = g_variant_builder_new(G_VARIANT_TYPE("as")); - if (client->tep_path) { - g_variant_builder_add(builder, "s", "-e"); - g_variant_builder_add(builder, "s", client->tep_path); - g_variant_builder_add(builder, "s", "-M"); - /* TODO: revise tep_move */ - g_variant_builder_add(builder, "s", - client->tep_move ? "tep_move" : "tep_copy"); - } - - args = g_variant_new("as", builder); - g_variant_builder_unref(builder); - - request_id = _generate_request_id(); - ret = pkgmgr_client_connection_send_request(client, "mount_install", - g_variant_new("(uss@ass)", uid, - pkg_type ? pkg_type : "", pkg_path, - args, request_id), - &result); - free(request_id); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i&s)", &ret, &req_key); - if (req_key == NULL) { - g_variant_unref(result); - return PKGMGR_R_ECOMM; - } - if (ret != PKGMGR_R_OK) { - g_variant_unref(result); - return ret; - } - - cb_info = __create_event_cb_info(client, event_cb, data, req_key); - if (cb_info == NULL) { - g_variant_unref(result); - return PKGMGR_R_ENOMEM; - } - g_variant_unref(result); - ret = pkgmgr_client_connection_set_callback(client, cb_info); - if (ret != PKGMGR_R_OK) { - __free_cb_info(cb_info); - return ret; - } - client->cb_info_list = g_list_append(client->cb_info_list, cb_info); - - return cb_info->req_id; -} - -API int pkgmgr_client_mount_install(pkgmgr_client *pc, const char *pkg_type, - const char *descriptor_path, const char *pkg_path, - const char *optional_data, pkgmgr_mode mode, - pkgmgr_handler event_cb, void *data) -{ - return pkgmgr_client_usr_mount_install(pc, pkg_type, descriptor_path, - pkg_path, optional_data, mode, event_cb, data, - _getuid()); -} - -API int pkgmgr_client_usr_uninstall_packages(pkgmgr_client *pc, - const char **pkgids, int n_pkgs, pkgmgr_handler event_cb, - void *data, uid_t uid) -{ - GVariant *result; - GVariantBuilder *pkgs_builder; - GVariant *pkgs; - int ret = PKGMGR_R_ECOMM; - char *req_key = NULL; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - struct cb_info *cb_info; - int i; - - if (pc == NULL || pkgids == NULL || n_pkgs < 1) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->pc_type != PC_REQUEST) { - ERR("client->pc_type is not PC_REQUEST"); - return PKGMGR_R_EINVAL; - } - - pkgs_builder = g_variant_builder_new(G_VARIANT_TYPE("as")); - for (i = 0; i < n_pkgs; i++) - g_variant_builder_add(pkgs_builder, "s", pkgids[i]); - pkgs = g_variant_new("as", pkgs_builder); - g_variant_builder_unref(pkgs_builder); - - ret = pkgmgr_client_connection_send_request(client, "uninstall_pkgs", - g_variant_new("(u@as)", uid, pkgs), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i&s)", &ret, &req_key); - if (req_key == NULL) { - g_variant_unref(result); - return PKGMGR_R_ECOMM; - } - if (ret != PKGMGR_R_OK) { - g_variant_unref(result); - return ret; - } - - cb_info = __create_event_cb_info(client, event_cb, data, req_key); - if (cb_info == NULL) { - g_variant_unref(result); - return PKGMGR_R_ENOMEM; - } - g_variant_unref(result); - ret = pkgmgr_client_connection_set_callback(client, cb_info); - if (ret != PKGMGR_R_OK) { - __free_cb_info(cb_info); - return ret; - } - client->cb_info_list = g_list_append(client->cb_info_list, cb_info); - - return cb_info->req_id; -} - -API int pkgmgr_client_uninstall_packages(pkgmgr_client *pc, - const char **pkgids, int n_pkgs, pkgmgr_handler event_cb, - void *data) -{ - return pkgmgr_client_usr_uninstall_packages(pc, pkgids, n_pkgs, - event_cb, data, _getuid()); -} - -API int pkgmgr_client_uninstall(pkgmgr_client *pc, const char *pkg_type, - const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb, - void *data) -{ - return pkgmgr_client_usr_uninstall(pc, pkg_type, pkgid, mode, event_cb, - data, _getuid()); -} - -API int pkgmgr_client_usr_uninstall(pkgmgr_client *pc, const char *pkg_type, - const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb, - void *data, uid_t uid) -{ - GVariant *result; - int ret = PKGMGR_R_ECOMM; - char *req_key = NULL; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - struct cb_info *cb_info; - - if (pc == NULL || pkgid == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->pc_type != PC_REQUEST) { - ERR("client->pc_type is not PC_REQUEST"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, "uninstall", - g_variant_new("(us)", uid, pkgid), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i&s)", &ret, &req_key); - if (req_key == NULL) { - g_variant_unref(result); - return PKGMGR_R_ECOMM; - } - if (ret != PKGMGR_R_OK) { - g_variant_unref(result); - return ret; - } - - cb_info = __create_event_cb_info(client, event_cb, data, req_key); - if (cb_info == NULL) { - g_variant_unref(result); - return PKGMGR_R_ENOMEM; - } - g_variant_unref(result); - ret = pkgmgr_client_connection_set_callback(client, cb_info); - if (ret != PKGMGR_R_OK) { - __free_cb_info(cb_info); - return ret; - } - client->cb_info_list = g_list_append(client->cb_info_list, cb_info); - - return cb_info->req_id; -} - -API int pkgmgr_client_move(pkgmgr_client *pc, const char *pkg_type, - const char *pkgid, pkgmgr_move_type move_type, - pkgmgr_handler event_cb, void *data) -{ - return pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type, - event_cb, data, _getuid()); -} -API int pkgmgr_client_usr_move(pkgmgr_client *pc, const char *pkg_type, - const char *pkgid, pkgmgr_move_type move_type, - pkgmgr_handler event_cb, void *data, uid_t uid) -{ - GVariant *result; - int ret = PKGMGR_R_ECOMM; - char *req_key = NULL; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - struct cb_info *cb_info; - - if (pc == NULL || pkgid == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if ((move_type < PM_MOVE_TO_INTERNAL) || - (move_type > PM_MOVE_TO_EXTENDED)) - return PKGMGR_R_EINVAL; - - if (client->pc_type != PC_REQUEST) { - ERR("client->pc_type is not PC_REQUEST"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, "move", - g_variant_new("(usi)", uid, pkgid, move_type), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i&s)", &ret, &req_key); - if (req_key == NULL) { - g_variant_unref(result); - return PKGMGR_R_ECOMM; - } - if (ret != PKGMGR_R_OK) { - g_variant_unref(result); - return ret; - } - - cb_info = __create_event_cb_info(client, event_cb, data, req_key); - if (cb_info == NULL) { - g_variant_unref(result); - return PKGMGR_R_ERROR; - } - g_variant_unref(result); - ret = pkgmgr_client_connection_set_callback(client, cb_info); - if (ret != PKGMGR_R_OK) { - __free_cb_info(cb_info); - return ret; - } - client->cb_info_list = g_list_append(client->cb_info_list, cb_info); - - return cb_info->req_id; -} - -API int pkgmgr_client_usr_register_pkg_update_info(pkgmgr_client *pc, - pkg_update_info_t *update_info, uid_t uid) -{ - int ret; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - GVariant *result; - - if (pc == NULL || update_info == NULL || update_info->pkgid == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->pc_type != PC_REQUEST) { - ERR("client->pc_type is not PC_REQUEST"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, "register_pkg_update_info", - g_variant_new("(ussi)", uid, update_info->pkgid, update_info->version, - update_info->type), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i)", &ret); - if (ret != PKGMGR_R_OK) { - g_variant_unref(result); - return ret; - } - g_variant_unref(result); - - return PKGMGR_R_OK; -} - -API int pkgmgr_client_register_pkg_update_info(pkgmgr_client *pc, - pkg_update_info_t *update_info) -{ - return pkgmgr_client_usr_register_pkg_update_info(pc, update_info, - _getuid()); -} - -API int pkgmgr_client_usr_unregister_pkg_update_info(pkgmgr_client *pc, - const char *pkgid, uid_t uid) -{ - int ret; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - GVariant *result; - - if (pc == NULL || pkgid == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->pc_type != PC_REQUEST) { - ERR("client->pc_type is not PC_REQUEST"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, - "unregister_pkg_update_info", - g_variant_new("(us)", uid, pkgid), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i)", &ret); - if (ret != PKGMGR_R_OK) { - g_variant_unref(result); - return ret; - } - g_variant_unref(result); - - return PKGMGR_R_OK; -} - -API int pkgmgr_client_unregister_pkg_update_info(pkgmgr_client *pc, - const char *pkgid) -{ - return pkgmgr_client_usr_unregister_pkg_update_info(pc, pkgid, _getuid()); -} - -API int pkgmgr_client_usr_unregister_all_pkg_update_info(pkgmgr_client *pc, - uid_t uid) -{ - int ret; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - GVariant *result; - - if (pc == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->pc_type != PC_REQUEST) { - ERR("client->pc_type is not PC_REQUEST"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, - "unregister_all_pkg_update_info", - g_variant_new("(u)", uid), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i)", &ret); - if (ret != PKGMGR_R_OK) { - g_variant_unref(result); - return ret; - } - g_variant_unref(result); - - return PKGMGR_R_OK; -} - -API int pkgmgr_client_unregister_all_pkg_update_info(pkgmgr_client *pc) -{ - return pkgmgr_client_usr_unregister_all_pkg_update_info(pc, _getuid()); -} - -API int pkgmgr_client_usr_activate(pkgmgr_client *pc, const char *pkg_type, - const char *pkgid, uid_t uid) -{ - GVariant *result; - int ret = PKGMGR_R_ECOMM; - GVariantBuilder *builder; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (pc == NULL || pkgid == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - builder = g_variant_builder_new(G_VARIANT_TYPE("as")); - g_variant_builder_add(builder, "s", pkgid); - - ret = pkgmgr_client_connection_send_request(client, "enable_pkgs", - g_variant_new("(uas)", uid, builder), &result); - g_variant_builder_unref(builder); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(is)", &ret, NULL); - g_variant_unref(result); - - return ret; -} - -API int pkgmgr_client_activate(pkgmgr_client *pc, const char *pkg_type, - const char *pkgid) -{ - return pkgmgr_client_usr_activate(pc, pkg_type, pkgid, _getuid()); -} - -API int pkgmgr_client_usr_activate_packages(pkgmgr_client *pc, - const char *pkg_type, const char **pkgids, int n_pkgs, - pkgmgr_handler event_cb, void *data, uid_t uid) -{ - GVariant *result; - GVariantBuilder *builder; - int ret = PKGMGR_R_ECOMM; - char *req_key = NULL; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - struct cb_info *cb_info; - int i; - - if (pc == NULL || pkgids == NULL || n_pkgs < 1) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->pc_type != PC_REQUEST) { - ERR("client type is not PC_REQUEST"); - return PKGMGR_R_EINVAL; - } - - builder = g_variant_builder_new(G_VARIANT_TYPE("as")); - for (i = 0; i < n_pkgs; i++) - g_variant_builder_add(builder, "s", pkgids[i]); - - ret = pkgmgr_client_connection_send_request(client, "enable_pkgs", - g_variant_new("(uas)", uid, builder), &result); - g_variant_builder_unref(builder); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i&s)", &ret, &req_key); - if (req_key == NULL) { - g_variant_unref(result); - return PKGMGR_R_ECOMM; - } - if (ret != PKGMGR_R_OK) { - g_variant_unref(result); - return ret; - } - - cb_info = __create_event_cb_info(client, event_cb, data, req_key); - if (cb_info == NULL) { - g_variant_unref(result); - return PKGMGR_R_ERROR; - } - g_variant_unref(result); - ret = pkgmgr_client_connection_set_callback(client, cb_info); - if (ret != PKGMGR_R_OK) { - __free_cb_info(cb_info); - return ret; - } - client->cb_info_list = g_list_append(client->cb_info_list, cb_info); - - return cb_info->req_id; -} - -API int pkgmgr_client_activate_packages(pkgmgr_client *pc, - const char *pkg_type, const char **pkgids, int n_pkgs, - pkgmgr_handler event_cb, void *data) -{ - return pkgmgr_client_usr_activate_packages(pc, pkg_type, - pkgids, n_pkgs, event_cb, data, _getuid()); -} - -API int pkgmgr_client_usr_deactivate(pkgmgr_client *pc, const char *pkg_type, - const char *pkgid, uid_t uid) -{ - GVariant *result; - GVariantBuilder *builder; - int ret = PKGMGR_R_ECOMM; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (pc == NULL || pkgid == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - builder = g_variant_builder_new(G_VARIANT_TYPE("as")); - g_variant_builder_add(builder, "s", pkgid); - - ret = pkgmgr_client_connection_send_request(client, "disable_pkgs", - g_variant_new("(uas)", uid, builder), &result); - g_variant_builder_unref(builder); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(is)", &ret, NULL); - g_variant_unref(result); - - return ret; -} - -API int pkgmgr_client_deactivate(pkgmgr_client *pc, const char *pkg_type, - const char *pkgid) -{ - return pkgmgr_client_usr_deactivate(pc, pkg_type, pkgid, _getuid()); -} - -API int pkgmgr_client_usr_deactivate_packages(pkgmgr_client *pc, - const char *pkg_type, const char **pkgids, int n_pkgs, - pkgmgr_handler event_cb, void *data, uid_t uid) -{ - GVariant *result; - GVariantBuilder *builder; - int ret = PKGMGR_R_ECOMM; - char *req_key = NULL; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - struct cb_info *cb_info; - int i; - - if (pc == NULL || pkgids == NULL || n_pkgs < 1) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->pc_type != PC_REQUEST) { - ERR("client type is not PC_REQUEST"); - return PKGMGR_R_EINVAL; - } - - builder = g_variant_builder_new(G_VARIANT_TYPE("as")); - for (i = 0; i < n_pkgs; i++) - g_variant_builder_add(builder, "s", pkgids[i]); - - ret = pkgmgr_client_connection_send_request(client, "disable_pkgs", - g_variant_new("(uas)", uid, builder), &result); - g_variant_builder_unref(builder); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i&s)", &ret, &req_key); - if (req_key == NULL) { - g_variant_unref(result); - return PKGMGR_R_ECOMM; - } - if (ret != PKGMGR_R_OK) { - g_variant_unref(result); - return ret; - } - - cb_info = __create_event_cb_info(client, event_cb, data, req_key); - if (cb_info == NULL) { - g_variant_unref(result); - return PKGMGR_R_ERROR; - } - g_variant_unref(result); - ret = pkgmgr_client_connection_set_callback(client, cb_info); - if (ret != PKGMGR_R_OK) { - __free_cb_info(cb_info); - return ret; - } - client->cb_info_list = g_list_append(client->cb_info_list, cb_info); - - return cb_info->req_id; -} - -API int pkgmgr_client_deactivate_packages(pkgmgr_client *pc, - const char *pkg_type, const char **pkgids, int n_pkgs, - pkgmgr_handler event_cb, void *data) -{ - return pkgmgr_client_usr_deactivate_packages(pc, pkg_type, - pkgids, n_pkgs, event_cb, data, _getuid()); -} - -API int pkgmgr_client_usr_activate_app(pkgmgr_client *pc, const char *appid, - pkgmgr_app_handler app_event_cb, void *data, uid_t uid) -{ - GVariant *result; - int ret = PKGMGR_R_ECOMM; - char *req_key = NULL; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - struct cb_info *cb_info; - - if (pc == NULL || appid == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, "enable_app", - g_variant_new("(us)", uid, appid), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i&s)", &ret, &req_key); - if (req_key == NULL) { - g_variant_unref(result); - return PKGMGR_R_ECOMM; - } - if (ret != PKGMGR_R_OK) { - g_variant_unref(result); - return ret; - } - - cb_info = __create_app_event_cb_info(client, app_event_cb, data, - req_key); - if (cb_info == NULL) { - g_variant_unref(result); - return PKGMGR_R_ENOMEM; - } - g_variant_unref(result); - ret = pkgmgr_client_connection_set_callback(client, cb_info); - if (ret != PKGMGR_R_OK) { - __free_cb_info(cb_info); - return ret; - } - client->cb_info_list = g_list_append(client->cb_info_list, cb_info); - - return cb_info->req_id; -} - -API int pkgmgr_client_activate_app(pkgmgr_client *pc, const char *appid, - pkgmgr_app_handler app_event_cb, void *data) -{ - return pkgmgr_client_usr_activate_app(pc, appid, app_event_cb, - data, _getuid()); -} - -API int pkgmgr_client_usr_activate_apps(pkgmgr_client *pc, const char **appids, - int n_apps, pkgmgr_app_handler app_event_cb, void *data, uid_t uid) -{ - GVariant *result; - GVariantBuilder *builder; - int ret = PKGMGR_R_ECOMM; - char *req_key = NULL; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - struct cb_info *cb_info; - int i; - - if (pc == NULL || appids == NULL || n_apps < 1) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->pc_type != PC_REQUEST) { - ERR("client type is not PC_REQUEST"); - return PKGMGR_R_EINVAL; - } - - builder = g_variant_builder_new(G_VARIANT_TYPE("as")); - for (i = 0; i < n_apps; i++) - g_variant_builder_add(builder, "s", appids[i]); - - ret = pkgmgr_client_connection_send_request(client, "enable_apps", - g_variant_new("(uas)", uid, builder), &result); - g_variant_builder_unref(builder); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i&s)", &ret, &req_key); - if (req_key == NULL) { - g_variant_unref(result); - return PKGMGR_R_ECOMM; - } - if (ret != PKGMGR_R_OK) { - g_variant_unref(result); - return ret; - } - - cb_info = __create_app_event_cb_info(client, app_event_cb, data, req_key); - if (cb_info == NULL) { - g_variant_unref(result); - return PKGMGR_R_ERROR; - } - g_variant_unref(result); - ret = pkgmgr_client_connection_set_callback(client, cb_info); - if (ret != PKGMGR_R_OK) { - __free_cb_info(cb_info); - return ret; - } - client->cb_info_list = g_list_append(client->cb_info_list, cb_info); - - return cb_info->req_id; -} - -API int pkgmgr_client_activate_apps(pkgmgr_client *pc, const char **appids, - int n_apps, pkgmgr_app_handler app_event_cb, void *data) -{ - return pkgmgr_client_usr_activate_apps(pc, appids, n_apps, - app_event_cb, data, _getuid()); -} - -API int pkgmgr_client_activate_global_app_for_uid(pkgmgr_client *pc, - const char *appid, pkgmgr_app_handler app_event_cb, void *data, uid_t uid) -{ - GVariant *result; - int ret = PKGMGR_R_ECOMM; - char *req_key = NULL; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - struct cb_info *cb_info; - - if (pc == NULL || appid == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, - "enable_global_app_for_uid", - g_variant_new("(us)", uid, appid), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i&s)", &ret, &req_key); - if (req_key == NULL) { - g_variant_unref(result); - return PKGMGR_R_ECOMM; - } - if (ret != PKGMGR_R_OK) { - g_variant_unref(result); - return ret; - } - - cb_info = __create_app_event_cb_info(client, app_event_cb, data, - req_key); - if (cb_info == NULL) { - g_variant_unref(result); - return PKGMGR_R_ENOMEM; - } - g_variant_unref(result); - ret = pkgmgr_client_connection_set_callback(client, cb_info); - if (ret != PKGMGR_R_OK) { - __free_cb_info(cb_info); - return ret; - } - client->cb_info_list = g_list_append(client->cb_info_list, cb_info); - - return cb_info->req_id; -} - -API int pkgmgr_client_usr_deactivate_app(pkgmgr_client *pc, const char *appid, - pkgmgr_app_handler app_event_cb, void *data, uid_t uid) -{ - GVariant *result; - int ret = PKGMGR_R_ECOMM; - char *req_key = NULL; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - struct cb_info *cb_info; - - if (pc == NULL || appid == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, "disable_app", - g_variant_new("(us)", uid, appid), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i&s)", &ret, &req_key); - if (req_key == NULL) { - g_variant_unref(result); - return PKGMGR_R_ECOMM; - } - if (ret != PKGMGR_R_OK) { - g_variant_unref(result); - return ret; - } - - cb_info = __create_app_event_cb_info(client, app_event_cb, data, - req_key); - if (cb_info == NULL) { - g_variant_unref(result); - return PKGMGR_R_ENOMEM; - } - g_variant_unref(result); - ret = pkgmgr_client_connection_set_callback(client, cb_info); - if (ret != PKGMGR_R_OK) { - __free_cb_info(cb_info); - return ret; - } - client->cb_info_list = g_list_append(client->cb_info_list, cb_info); - - return cb_info->req_id; -} - -API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid, - pkgmgr_app_handler app_event_cb, void *data) -{ - return pkgmgr_client_usr_deactivate_app(pc, appid, app_event_cb, data, - _getuid()); -} - -API int pkgmgr_client_usr_deactivate_apps(pkgmgr_client *pc, - const char **appids, int n_apps, - pkgmgr_app_handler app_event_cb, void *data, uid_t uid) -{ - GVariant *result; - GVariantBuilder *builder; - int ret = PKGMGR_R_ECOMM; - char *req_key = NULL; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - struct cb_info *cb_info; - int i; - - if (pc == NULL || appids == NULL || n_apps < 1) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->pc_type != PC_REQUEST) { - ERR("client type is not PC_REQUEST"); - return PKGMGR_R_EINVAL; - } - - builder = g_variant_builder_new(G_VARIANT_TYPE("as")); - for (i = 0; i < n_apps; i++) - g_variant_builder_add(builder, "s", appids[i]); - - ret = pkgmgr_client_connection_send_request(client, "disable_apps", - g_variant_new("(uas)", uid, builder), &result); - g_variant_builder_unref(builder); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i&s)", &ret, &req_key); - if (req_key == NULL) { - g_variant_unref(result); - return PKGMGR_R_ECOMM; - } - if (ret != PKGMGR_R_OK) { - g_variant_unref(result); - return ret; - } - - cb_info = __create_app_event_cb_info(client, app_event_cb, data, req_key); - if (cb_info == NULL) { - g_variant_unref(result); - return PKGMGR_R_ERROR; - } - g_variant_unref(result); - ret = pkgmgr_client_connection_set_callback(client, cb_info); - if (ret != PKGMGR_R_OK) { - __free_cb_info(cb_info); - return ret; - } - client->cb_info_list = g_list_append(client->cb_info_list, cb_info); - - return cb_info->req_id; -} - -API int pkgmgr_client_deactivate_apps(pkgmgr_client *pc, const char **appids, - int n_apps, pkgmgr_app_handler app_event_cb, void *data) -{ - return pkgmgr_client_usr_deactivate_apps(pc, appids, n_apps, - app_event_cb, data, _getuid()); -} - -API int pkgmgr_client_deactivate_global_app_for_uid(pkgmgr_client *pc, - const char *appid, pkgmgr_app_handler app_event_cb, void *data, uid_t uid) -{ - GVariant *result; - int ret = PKGMGR_R_ECOMM; - char *req_key = NULL; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - struct cb_info *cb_info; - - if (pc == NULL || appid == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, - "disable_global_app_for_uid", - g_variant_new("(us)", uid, appid), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i&s)", &ret, &req_key); - if (req_key == NULL) { - g_variant_unref(result); - return PKGMGR_R_ECOMM; - } - if (ret != PKGMGR_R_OK) { - g_variant_unref(result); - return ret; - } - - cb_info = __create_app_event_cb_info(client, app_event_cb, data, - req_key); - if (cb_info == NULL) { - g_variant_unref(result); - return PKGMGR_R_ENOMEM; - } - g_variant_unref(result); - ret = pkgmgr_client_connection_set_callback(client, cb_info); - if (ret != PKGMGR_R_OK) { - __free_cb_info(cb_info); - return ret; - } - client->cb_info_list = g_list_append(client->cb_info_list, cb_info); - - return cb_info->req_id; -} - -API int pkgmgr_client_usr_clear_user_data(pkgmgr_client *pc, - const char *pkg_type, const char *pkgid, pkgmgr_mode mode, - uid_t uid) -{ - GVariant *result; - int ret; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (pc == NULL || pkgid == NULL || uid == GLOBAL_USER) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->pc_type != PC_REQUEST) { - ERR("client->pc_type is not PC_REQUEST"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, "cleardata", - g_variant_new("(us)", uid, pkgid), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i)", &ret); - g_variant_unref(result); - - return ret; -} - -API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type, - const char *pkgid, pkgmgr_mode mode) -{ - return pkgmgr_client_usr_clear_user_data(pc, pkg_type, pkgid, mode, - _getuid()); -} - -API int pkgmgr_client_usr_clear_user_data_with_path(pkgmgr_client *pc, - const char *pkg_type, const char *pkgid, const char *file_path, - pkgmgr_mode mode, uid_t uid) -{ - GVariant *result; - int ret; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (!pc || !pkgid || !file_path || uid == GLOBAL_USER) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->pc_type != PC_REQUEST) { - ERR("client->pc_type is not PC_REQUEST"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, "cleardata_with_path", - g_variant_new("(uss)", uid, pkgid, file_path), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i)", &ret); - g_variant_unref(result); - - return ret; -} - -API int pkgmgr_client_clear_user_data_with_path(pkgmgr_client *pc, const char *pkg_type, - const char *pkgid, const char *file_path, pkgmgr_mode mode) -{ - return pkgmgr_client_usr_clear_user_data_with_path(pc, pkg_type, pkgid, - file_path, mode, _getuid()); -} - -API int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type) -{ - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (pc == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - client->status_type = status_type; - - return PKGMGR_R_OK; -} - -API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb, - void *data) -{ - int ret; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - struct cb_info *cb_info; - - if (pc == NULL || event_cb == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->pc_type != PC_LISTENING) { - ERR("client->pc_type is not PC_LISTENING"); - return PKGMGR_R_EINVAL; - } - - cb_info = __create_event_cb_info(client, event_cb, data, NULL); - if (cb_info == NULL) - return PKGMGR_R_ENOMEM; - cb_info->status_type = client->status_type; - ret = pkgmgr_client_connection_set_callback(client, cb_info); - if (ret != PKGMGR_R_OK) { - __free_cb_info(cb_info); - return ret; - } - client->cb_info_list = g_list_append(client->cb_info_list, cb_info); - - return cb_info->req_id; -} - -API int pkgmgr_client_listen_app_status(pkgmgr_client *pc, - pkgmgr_app_handler app_event_cb, void *data) -{ - int ret; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - struct cb_info *cb_info; - - if (pc == NULL || app_event_cb == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->pc_type != PC_LISTENING) { - ERR("client->pc_type is not PC_LISTENING"); - return PKGMGR_R_EINVAL; - } - - cb_info = __create_app_event_cb_info(client, app_event_cb, data, NULL); - if (cb_info == NULL) - return PKGMGR_R_ENOMEM; - cb_info->status_type = client->status_type; - ret = pkgmgr_client_connection_set_callback(client, cb_info); - if (ret != PKGMGR_R_OK) { - __free_cb_info(cb_info); - return ret; - } - client->cb_info_list = g_list_append(client->cb_info_list, cb_info); - - return cb_info->req_id; -} - -API int pkgmgr_client_listen_res_status(pkgmgr_client *pc, - pkgmgr_res_handler event_cb, void *data) -{ - int ret; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - struct cb_info *cb_info; - - if (pc == NULL || event_cb == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->pc_type != PC_LISTENING) { - ERR("client->pc_type is not PC_LISTENING"); - return PKGMGR_R_EINVAL; - } - - cb_info = __create_res_event_cb_info(client, event_cb, data, NULL); - if (cb_info == NULL) - return PKGMGR_R_ENOMEM; - cb_info->status_type = client->status_type; - ret = pkgmgr_client_connection_set_callback(client, cb_info); - if (ret != PKGMGR_R_OK) { - __free_cb_info(cb_info); - return ret; - } - client->cb_info_list = g_list_append(client->cb_info_list, cb_info); - - return cb_info->req_id; -} - -API int pkgmgr_client_listen_pkg_upgrade_status(pkgmgr_client *pc, - pkgmgr_pkg_upgrade_handler event_cb, void *data) -{ - int ret; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - struct cb_info *cb_info; - - if (pc == NULL || event_cb == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->pc_type != PC_LISTENING) { - ERR("client->pc_type is not PC_LISTENING"); - return PKGMGR_R_EINVAL; - } - - cb_info = __create_upgrade_event_cb_info(client, event_cb, data, NULL); - if (cb_info == NULL) - return PKGMGR_R_ENOMEM; - cb_info->status_type = client->status_type; - ret = pkgmgr_client_connection_set_callback(client, cb_info); - if (ret != PKGMGR_R_OK) { - __free_cb_info(cb_info); - return ret; - } - client->cb_info_list = g_list_append(client->cb_info_list, cb_info); - - return cb_info->req_id; -} - -API int pkgmgr_client_remove_listen_status(pkgmgr_client *pc) -{ - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - GList *tmp; - GList *next; - struct cb_info *cb_info; - - if (pc == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - /* unset all callback */ - tmp = client->cb_info_list; - while (tmp != NULL) { - next = tmp->next; - cb_info = (struct cb_info *)tmp->data; - pkgmgr_client_connection_unset_callback(pc, cb_info); - client->cb_info_list = g_list_delete_link(client->cb_info_list, - tmp); - __free_cb_info(cb_info); - tmp = next; - } - - return PKGMGR_R_OK; -} - -API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type, - const char *pkgid, const char *key, const char *val) -{ - /* client cannot broadcast signal */ - return PKGMGR_R_OK; -} - -/* TODO: deprecate(or remove) */ -API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type, - int service_mode, pkgmgr_client *pc, const char *pkg_type, - const char *pkgid, const char *custom_info, - pkgmgr_handler event_cb, void *data) -{ - return pkgmgr_client_usr_request_service(service_type, service_mode, - pc, pkg_type, pkgid, _getuid(), custom_info, event_cb, - data); -} - -API int pkgmgr_client_usr_request_service( - pkgmgr_request_service_type service_type, int service_mode, - pkgmgr_client *pc, const char *pkg_type, const char *pkgid, - uid_t uid, const char *custom_info, pkgmgr_handler event_cb, - void *data) -{ - int ret = 0; - - /* Check for NULL value of service type */ - retvm_if(service_type > PM_REQUEST_MAX, PKGMGR_R_EINVAL, "service type is not defined\n"); - retvm_if(service_type < 0, PKGMGR_R_EINVAL, "service type is error\n"); - - switch (service_type) { - case PM_REQUEST_MOVE: - tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n"); - tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n"); - tryvm_if((service_mode < PM_MOVE_TO_INTERNAL) || (service_mode > PM_MOVE_TO_EXTENDED), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n"); - - ret = __move_pkg_process(pc, pkgid, pkg_type, uid, (pkgmgr_move_type)service_mode, event_cb, data); - break; - - case PM_REQUEST_GET_SIZE: - tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n"); - tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n"); - tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode >= PM_GET_MAX), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n"); - - ret = __get_size_process(pc, pkgid, uid, (pkgmgr_getsize_type)service_mode, event_cb, data); - break; - - case PM_REQUEST_KILL_APP: - case PM_REQUEST_CHECK_APP: - tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n"); - tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n"); - - ret = __check_app_process(service_type, pc, pkgid, uid, data); - if (ret < 0) - ERR("__check_app_process fail \n"); - else - ret = PKGMGR_R_OK; - - break; - - default: - ERR("Wrong Request\n"); - ret = -1; - break; - } - -catch: - - return ret; -} - -API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid) -{ - GVariant *result; - int ret; - struct pkgmgr_client_t *client; - - if (pkgid == NULL || uid == GLOBAL_USER) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - client = pkgmgr_client_new(PC_REQUEST); - if (client == NULL) { - ERR("out of memory"); - return PKGMGR_R_ENOMEM; - } - - ret = pkgmgr_client_connection_send_request(client, "clearcache", - g_variant_new("(us)", uid, pkgid), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - pkgmgr_client_free(client); - return ret; - } - - g_variant_get(result, "(i)", &ret); - g_variant_unref(result); - pkgmgr_client_free(client); - - return ret; -} - -API int pkgmgr_client_clear_cache_dir(const char *pkgid) -{ - return pkgmgr_client_usr_clear_cache_dir(pkgid, _getuid()); -} - -API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid) -{ - return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid); -} - -API int pkgmgr_client_clear_all_cache_dir(void) -{ - return pkgmgr_client_usr_clear_cache_dir( - PKG_CLEAR_ALL_CACHE, _getuid()); -} - -API int pkgmgr_client_get_size(pkgmgr_client *pc, const char *pkgid, - pkgmgr_getsize_type get_type, pkgmgr_handler event_cb, - void *data) -{ - return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data, - _getuid()); -} - -/* TODO: deprecate(or remove) */ -API int pkgmgr_client_usr_get_size(pkgmgr_client *pc, const char *pkgid, - pkgmgr_getsize_type get_type, pkgmgr_handler event_cb, - void *data, uid_t uid) -{ - GVariant *result; - int ret = PKGMGR_R_ECOMM; - char *req_key = NULL; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - struct cb_info *cb_info; - - if (pc == NULL || pkgid == NULL || event_cb == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->pc_type != PC_REQUEST) { - ERR("client->pc_type is not PC_REQUEST"); - return PKGMGR_R_EINVAL; - } - - /* FIXME */ - if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0) - get_type = PM_GET_TOTAL_PKG_SIZE_INFO; - else - get_type = PM_GET_PKG_SIZE_INFO; - - ret = pkgmgr_client_connection_send_request(client, "getsize", - g_variant_new("(usi)", uid, pkgid, get_type), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i&s)", &ret, &req_key); - if (req_key == NULL) { - g_variant_unref(result); - return PKGMGR_R_ECOMM; - } - if (ret != PKGMGR_R_OK) { - g_variant_unref(result); - return ret; - } - - cb_info = __create_event_cb_info(client, event_cb, data, req_key); - if (cb_info == NULL) { - g_variant_unref(result); - return PKGMGR_R_ENOMEM; - } - g_variant_unref(result); - ret = pkgmgr_client_connection_set_callback(client, cb_info); - if (ret != PKGMGR_R_OK) { - __free_cb_info(cb_info); - return ret; - } - client->cb_info_list = g_list_append(client->cb_info_list, cb_info); - - return PKGMGR_R_OK; -} - -API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc, - const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb, - void *user_data, uid_t uid) -{ - GVariant *result; - int ret = PKGMGR_R_ECOMM; - char *req_key = NULL; - int get_type; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - struct cb_info *cb_info; - - if (pc == NULL || pkgid == NULL || event_cb == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->pc_type != PC_REQUEST) { - ERR("client->pc_type is not PC_REQUEST"); - return PKGMGR_R_EINVAL; - } - - if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0) - get_type = PM_GET_TOTAL_PKG_SIZE_INFO; - else - get_type = PM_GET_PKG_SIZE_INFO; - - ret = pkgmgr_client_connection_send_request(client, "getsize", - g_variant_new("(usi)", uid, pkgid, get_type), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i&s)", &ret, &req_key); - if (req_key == NULL) { - g_variant_unref(result); - return PKGMGR_R_ECOMM; - } - if (ret != PKGMGR_R_OK) { - g_variant_unref(result); - return ret; - } - - cb_info = __create_size_info_cb_info(client, event_cb, user_data, - req_key); - if (cb_info == NULL) { - g_variant_unref(result); - return PKGMGR_R_ENOMEM; - } - g_variant_unref(result); - ret = pkgmgr_client_connection_set_callback(client, cb_info); - if (ret != PKGMGR_R_OK) { - __free_cb_info(cb_info); - return ret; - } - client->cb_info_list = g_list_append(client->cb_info_list, cb_info); - - return PKGMGR_R_OK; -} - -API int pkgmgr_client_get_package_size_info(pkgmgr_client *pc, - const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb, - void *user_data) -{ - return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb, - user_data, _getuid()); -} - -API int pkgmgr_client_usr_get_total_package_size_info(pkgmgr_client *pc, - pkgmgr_total_pkg_size_info_receive_cb event_cb, - void *user_data, uid_t uid) -{ /* total package size info */ - return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL, - (pkgmgr_pkg_size_info_receive_cb)event_cb, - user_data, uid); -} - -API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc, - pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data) -{ - return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL, - (pkgmgr_pkg_size_info_receive_cb)event_cb, - user_data, _getuid()); -} - -API int pkgmgr_client_generate_license_request(pkgmgr_client *pc, - const char *resp_data, char **req_data, char **license_url) -{ - GVariant *result; - int ret; - char *data; - char *url; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (pc == NULL || resp_data == NULL || req_data == NULL || - license_url == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->pc_type != PC_REQUEST) { - ERR("client->pc_type is not PC_REQUEST"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, - "generate_license_request", - g_variant_new("(s)", resp_data), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i&s&s)", &ret, &data, &url); - if (ret != PKGMGR_R_OK) { - ERR("generate_license_request failed: %d", ret); - g_variant_unref(result); - return ret; - } - - *req_data = strdup(data); - *license_url = strdup(url); - - g_variant_unref(result); - - return PKGMGR_R_OK; -} - -API int pkgmgr_client_register_license(pkgmgr_client *pc, const char *resp_data) -{ - GVariant *result; - int ret; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (pc == NULL || resp_data == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->pc_type != PC_REQUEST) { - ERR("client->pc_type is not PC_REQUEST"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, "register_license", - g_variant_new("(s)", resp_data), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i)", &ret); - g_variant_unref(result); - if (ret != PKGMGR_R_OK) - ERR("register license failed: %d", ret); - - return ret; -} - -API int pkgmgr_client_decrypt_package(pkgmgr_client *pc, - const char *drm_file_path, const char *decrypted_file_path) -{ - GVariant *result; - int ret; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (pc == NULL || drm_file_path == NULL || - decrypted_file_path == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->pc_type != PC_REQUEST) { - ERR("client->pc_type is not PC_REQUEST"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, "decrypt_package", - g_variant_new("(ss)", drm_file_path, - decrypted_file_path), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i)", &ret); - g_variant_unref(result); - if (ret != PKGMGR_R_OK) - ERR("decrypt_package failed: %d", ret); - - return ret; -} - -API int pkgmgr_client_enable_splash_screen(pkgmgr_client *pc, const char *appid) -{ - return pkgmgr_client_usr_enable_splash_screen(pc, appid, _getuid()); -} - -API int pkgmgr_client_usr_enable_splash_screen(pkgmgr_client *pc, - const char *appid, uid_t uid) -{ - int ret; - GVariant *result; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (pc == NULL || appid == NULL) { - ERR("Invalid parameter"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, - "enable_app_splash_screen", - g_variant_new("(us)", uid, appid), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i)", &ret); - g_variant_unref(result); - if (ret != PKGMGR_R_OK) - ERR("enable splash screen failed: %d", ret); - - return ret; -} - -API int pkgmgr_client_disable_splash_screen(pkgmgr_client *pc, - const char *appid) -{ - return pkgmgr_client_usr_disable_splash_screen(pc, appid, - _getuid()); -} - -API int pkgmgr_client_usr_disable_splash_screen(pkgmgr_client *pc, - const char *appid, uid_t uid) -{ - int ret; - GVariant *result; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (pc == NULL || appid == NULL) { - ERR("Invalid parameter"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, - "disable_app_splash_screen", - g_variant_new("(us)", uid, appid), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i)", &ret); - g_variant_unref(result); - if (ret != PKGMGR_R_OK) - ERR("disable splash screen failed: %d", ret); - - return ret; -} - -static int __set_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid, - int mode, uid_t uid) -{ - GVariant *result; - int ret = PKGMGR_R_ECOMM; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, - "set_restriction_mode", - g_variant_new("(usi)", uid, pkgid, mode), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i)", &ret); - g_variant_unref(result); - - return ret; -} - -API int pkgmgr_client_usr_set_pkg_restriction_mode(pkgmgr_client *pc, - const char *pkgid, int mode, uid_t uid) -{ - return __set_pkg_restriction_mode(pc, pkgid, mode, uid); -} - -API int pkgmgr_client_set_pkg_restriction_mode(pkgmgr_client *pc, - const char *pkgid, int mode) -{ - return pkgmgr_client_usr_set_pkg_restriction_mode(pc, pkgid, mode, - _getuid()); -} - -static int __unset_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid, - int mode, uid_t uid) -{ - GVariant *result; - int ret = PKGMGR_R_ECOMM; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, - "unset_restriction_mode", - g_variant_new("(usi)", uid, pkgid, mode), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i)", &ret); - g_variant_unref(result); - - return ret; - -} - -API int pkgmgr_client_usr_unset_pkg_restriction_mode(pkgmgr_client *pc, - const char *pkgid, int mode, uid_t uid) -{ - return __unset_pkg_restriction_mode(pc, pkgid, mode, uid); -} - -API int pkgmgr_client_unset_pkg_restriction_mode(pkgmgr_client *pc, - const char *pkgid, int mode) -{ - return pkgmgr_client_usr_unset_pkg_restriction_mode(pc, pkgid, mode, - _getuid()); -} - -static int __get_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid, - int *mode, uid_t uid) -{ - GVariant *result; - int ret = PKGMGR_R_ECOMM; - gint m; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, - "get_restriction_mode", - g_variant_new("(us)", uid, pkgid), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(ii)", &m, &ret); - g_variant_unref(result); - if (ret != PKGMGR_R_OK) - return ret; - - *mode = m; - - return PKGMGR_R_OK; -} - -API int pkgmgr_client_usr_get_pkg_restriction_mode(pkgmgr_client *pc, - const char *pkgid, int *mode, uid_t uid) -{ - return __get_pkg_restriction_mode(pc, pkgid, mode, uid); -} - -API int pkgmgr_client_get_pkg_restriction_mode(pkgmgr_client *pc, - const char *pkgid, int *mode) -{ - return pkgmgr_client_usr_get_pkg_restriction_mode(pc, pkgid, mode, - _getuid()); -} - -API int pkgmgr_client_usr_set_restriction_mode(pkgmgr_client *pc, int mode, - uid_t uid) -{ - GVariant *result; - int ret = PKGMGR_R_ECOMM; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (pc == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, - "set_restriction_mode", - g_variant_new("(usi)", uid, "", mode), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i)", &ret); - g_variant_unref(result); - - return ret; -} - -API int pkgmgr_client_set_restriction_mode(pkgmgr_client *pc, int mode) -{ - return pkgmgr_client_usr_set_restriction_mode(pc, mode, _getuid()); -} - -API int pkgmgr_client_usr_unset_restriction_mode(pkgmgr_client *pc, int mode, - uid_t uid) -{ - GVariant *result; - int ret = PKGMGR_R_ECOMM; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (pc == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, - "unset_restriction_mode", - g_variant_new("(usi)", uid, "", mode), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i)", &ret); - g_variant_unref(result); - - return ret; -} - -API int pkgmgr_client_unset_restriction_mode(pkgmgr_client *pc, int mode) -{ - return pkgmgr_client_usr_unset_restriction_mode(pc, mode, _getuid()); -} - -API int pkgmgr_client_usr_get_restriction_mode(pkgmgr_client *pc, - int *mode, uid_t uid) -{ - GVariant *result; - int ret = PKGMGR_R_ECOMM; - gint m; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (pc == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, - "get_restriction_mode", - g_variant_new("(us)", uid, ""), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(ii)", &m, &ret); - g_variant_unref(result); - if (ret != PKGMGR_R_OK) - return ret; - - *mode = m; - - return PKGMGR_R_OK; -} - -API int pkgmgr_client_get_restriction_mode(pkgmgr_client *pc, int *mode) -{ - return pkgmgr_client_usr_get_restriction_mode(pc, mode, _getuid()); -} - -API pkgmgr_info *pkgmgr_client_check_pkginfo_from_file(const char *pkg_path) -{ - int ret; - pkg_plugin_set *plugin_set; - package_manager_pkg_detail_info_t *info; - char *pkg_type; - - if (pkg_path == NULL) { - ERR("invalid parameter"); - return NULL; - } - - pkg_type = __get_type_from_path(pkg_path); - if (pkg_type == NULL) { - ERR("cannot get pkg type"); - return NULL; - } - - plugin_set = _package_manager_load_library(pkg_type); - if (plugin_set == NULL) { - ERR("failed to load library for %s", pkg_type); - free(pkg_type); - return NULL; - } - - info = calloc(1, sizeof(package_manager_pkg_detail_info_t)); - if (info == NULL) { - ERR("out of memory"); - free(pkg_type); - return NULL; - } - - ret = plugin_set->get_pkg_detail_info_from_package(pkg_path, info); - if (ret) { - ERR("get_pkg_detail_info_from_package failed"); - free(info); - free(pkg_type); - return NULL; - } - - free(pkg_type); - - return (pkgmgr_info *)info; -} - -API int pkgmgr_client_free_pkginfo(pkgmgr_info *info) -{ - package_manager_pkg_detail_info_t *pkg_info = - (package_manager_pkg_detail_info_t *)info; - - if (info == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - g_list_free_full(pkg_info->privilege_list, free); - free(pkg_info->icon_buf); - free(pkg_info); - - return PKGMGR_R_OK; -} - -API int pkgmgr_client_usr_set_app_label(pkgmgr_client *pc, char *appid, - char *label, uid_t uid) -{ - GVariant *result; - int ret = -1; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (pc == NULL || appid == NULL || label == NULL) { - ERR("Invalid parameter"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, - "set_app_label", - g_variant_new("(uss)", uid, appid, label), &result); - if (ret != PKGMGR_R_OK) { - ERR("Request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i)", &ret); - g_variant_unref(result); - - return ret; -} - -API int pkgmgr_client_set_app_label(pkgmgr_client *pc, char *appid, char *label) -{ - return pkgmgr_client_usr_set_app_label(pc, appid, label, _getuid()); -} - -API int pkgmgr_client_usr_set_app_icon(pkgmgr_client *pc, char *appid, - char *icon_path, uid_t uid) -{ - GVariant *result; - int ret = -1; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (pc == NULL || appid == NULL || icon_path == NULL) { - ERR("Invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (access(icon_path, F_OK) != 0) { - ERR("failed to access: %s", icon_path); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, - "set_app_icon", - g_variant_new("(uss)", uid, appid, icon_path), &result); - if (ret != PKGMGR_R_OK) { - ERR("Request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i)", &ret); - g_variant_unref(result); - - return ret; -} - -API int pkgmgr_client_set_app_icon(pkgmgr_client *pc, char *appid, char *icon_path) -{ - return pkgmgr_client_usr_set_app_icon(pc, appid, icon_path, _getuid()); -} - -API int pkgmgr_client_set_debug_mode(pkgmgr_client *pc, bool debug_mode) -{ - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (pc == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - client->debug_mode = debug_mode; - - return PKGMGR_R_OK; -} - -API int pkgmgr_client_set_skip_optimization(pkgmgr_client *pc, bool skip_optimization) -{ - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (pc == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - client->skip_optimization = skip_optimization; - - return PKGMGR_R_OK; -} - -API int pkgmgr_client_usr_migrate_external_image(pkgmgr_client *pc, - const char *pkgid, uid_t uid) -{ - GVariant *result; - int ret = PKGMGR_R_ECOMM; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (pc == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, - "migrate_external_image", - g_variant_new("(us)", uid, pkgid), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i)", &ret); - g_variant_unref(result); - - return ret; -} - -API int pkgmgr_client_add_res_copy_path(pkgmgr_client *pc, - const char *src_path, const char *dest_path) -{ - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (pc == NULL || src_path == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->res_copy_builder == NULL) { - client->res_copy_builder = - g_variant_builder_new(G_VARIANT_TYPE("a(ss)")); - if (client->res_copy_builder == NULL) { - ERR("out of memory"); - return PKGMGR_R_ENOMEM; - } - } - - g_variant_builder_add(client->res_copy_builder, "(ss)", - src_path, dest_path ? dest_path : ""); - - return PKGMGR_R_OK; -} - -API int pkgmgr_client_res_copy(pkgmgr_client *pc, - pkgmgr_res_handler event_cb, void *user_data) -{ - GVariant *result; - int ret; - char *req_key = NULL; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - struct cb_info *cb_info; - - if (pc == NULL || event_cb == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, - "res_copy", - g_variant_new("(a(ss))", - client->res_copy_builder), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i&s)", &ret, &req_key); - if (req_key == NULL) { - g_variant_unref(result); - return PKGMGR_R_ECOMM; - } - if (ret != PKGMGR_R_OK) { - g_variant_unref(result); - return ret; - } - - cb_info = __create_res_event_cb_info(client, - event_cb, user_data, req_key); - g_variant_unref(result); - if (cb_info == NULL) - return PKGMGR_R_ENOMEM; - - ret = pkgmgr_client_connection_set_callback(client, cb_info); - if (ret != PKGMGR_R_OK) { - __free_cb_info(cb_info); - return ret; - } - client->cb_info_list = g_list_append(client->cb_info_list, cb_info); - - return cb_info->req_id; -} - -API int pkgmgr_client_add_res_create_dir_path(pkgmgr_client *pc, - const char *dir_path) -{ - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (pc == NULL || dir_path == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->res_create_dir_builder == NULL) { - client->res_create_dir_builder = - g_variant_builder_new(G_VARIANT_TYPE("as")); - if (client->res_create_dir_builder == NULL) { - ERR("out of memory"); - return PKGMGR_R_ENOMEM; - } - } - - g_variant_builder_add(client->res_create_dir_builder, "s", dir_path); - - return PKGMGR_R_OK; -} - -API int pkgmgr_client_res_create_dir(pkgmgr_client *pc, - pkgmgr_res_handler event_cb, void *user_data) -{ - GVariant *result; - int ret; - char *req_key = NULL; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - struct cb_info *cb_info; - - if (pc == NULL || event_cb == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, - "res_create_dir", - g_variant_new("(as)", - client->res_create_dir_builder), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i&s)", &ret, &req_key); - if (req_key == NULL) { - g_variant_unref(result); - return PKGMGR_R_ECOMM; - } - if (ret != PKGMGR_R_OK) { - g_variant_unref(result); - return ret; - } - - cb_info = __create_res_event_cb_info(client, - event_cb, user_data, req_key); - g_variant_unref(result); - if (cb_info == NULL) - return PKGMGR_R_ENOMEM; - - ret = pkgmgr_client_connection_set_callback(client, cb_info); - if (ret != PKGMGR_R_OK) { - __free_cb_info(cb_info); - return ret; - } - client->cb_info_list = g_list_append(client->cb_info_list, cb_info); - - return cb_info->req_id; -} - -API int pkgmgr_client_add_res_remove_path(pkgmgr_client *pc, - const char *res_path) -{ - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (pc == NULL || res_path == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - if (client->res_remove_builder == NULL) { - client->res_remove_builder = - g_variant_builder_new(G_VARIANT_TYPE("as")); - if (client->res_remove_builder == NULL) { - ERR("out of memory"); - return PKGMGR_R_ENOMEM; - } - } - - g_variant_builder_add(client->res_remove_builder, "s", res_path); - - return PKGMGR_R_OK; -} - -API int pkgmgr_client_res_remove(pkgmgr_client *pc, - pkgmgr_res_handler event_cb, void *user_data) -{ - GVariant *result; - int ret; - char *req_key = NULL; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - struct cb_info *cb_info; - - if (pc == NULL || event_cb == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, - "res_remove", - g_variant_new("(as)", - client->res_remove_builder), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i&s)", &ret, &req_key); - if (req_key == NULL) { - g_variant_unref(result); - return PKGMGR_R_ECOMM; - } - if (ret != PKGMGR_R_OK) { - g_variant_unref(result); - return ret; - } - - cb_info = __create_res_event_cb_info(client, - event_cb, user_data, req_key); - g_variant_unref(result); - if (cb_info == NULL) - return PKGMGR_R_ENOMEM; - - ret = pkgmgr_client_connection_set_callback(client, cb_info); - if (ret != PKGMGR_R_OK) { - __free_cb_info(cb_info); - return ret; - } - client->cb_info_list = g_list_append(client->cb_info_list, cb_info); - - return cb_info->req_id; -} - -API int pkgmgr_client_res_uninstall(pkgmgr_client *pc, const char *pkgid) -{ - return pkgmgr_client_res_usr_uninstall(pc, pkgid, _getuid()); -} - -API int pkgmgr_client_res_usr_uninstall(pkgmgr_client *pc, const char *pkgid, - uid_t uid) -{ - GVariant *result; - int ret = PKGMGR_R_ECOMM; - struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc; - - if (pc == NULL || pkgid == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - ret = pkgmgr_client_connection_send_request(client, - "res_uninstall", - g_variant_new("(us)", uid, pkgid), &result); - if (ret != PKGMGR_R_OK) { - ERR("request failed: %d", ret); - return ret; - } - - g_variant_get(result, "(i)", &ret); - g_variant_unref(result); - - return ret; -} - -API pkgmgr_res_event_info *pkgmgr_res_event_info_new() -{ - pkgmgr_res_event_info_t *info; - - info = calloc(1, sizeof(pkgmgr_res_event_info_t)); - if (info == NULL) { - ERR("out of memory"); - return NULL; - } - - return (pkgmgr_res_event_info *)info; -} - -static void __free_path_states(gpointer data) -{ - res_event_path_state_t *path_state = (res_event_path_state_t *)data; - - if (path_state == NULL) - return; - if (path_state->path) - free(path_state->path); - free(path_state); -} - -API int pkgmgr_res_event_info_free(pkgmgr_res_event_info *info) -{ - pkgmgr_res_event_info_t *event_info = - (pkgmgr_res_event_info_t *)info; - - if (event_info == NULL) { - ERR("invalid argument"); - return PKGMGR_R_EINVAL; - } - - if (event_info->path_states) - g_list_free_full(event_info->path_states, __free_path_states); - free(event_info); - - return PKGMGR_R_OK; -} - -API int pkgmgr_res_event_info_set_error_code(pkgmgr_res_event_info *handle, int error_code) -{ - pkgmgr_res_event_info_t *info = handle; - if (info == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - info->error_code = error_code; - return PKGMGR_R_OK; -} - -API int pkgmgr_res_event_info_get_error_code(pkgmgr_res_event_info *handle, int *error_code) -{ - pkgmgr_res_event_info_t *info = handle; - if (info == NULL || error_code == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - *error_code = info->error_code; - return PKGMGR_R_OK; -} - -API int pkgmgr_res_event_info_add_path_state(pkgmgr_res_event_info *handle, - const char *path, pkgmgr_res_event_path_state state) -{ - pkgmgr_res_event_info_t *info = handle; - res_event_path_state_t *path_state; - - if (info == NULL || path == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - path_state = calloc(1, sizeof(res_event_path_state_t)); - if (path_state == NULL) { - ERR("out of memory"); - return PKGMGR_R_ENOMEM; - } - - path_state->path = strdup(path); - if (path_state->path == NULL) { - ERR("out of memory"); - free(path_state); - return PKGMGR_R_ENOMEM; - } - path_state->state = state; - - info->path_states = g_list_prepend(info->path_states , path_state); - return PKGMGR_R_OK; -} - -API int pkgmgr_res_event_info_foreach_path(pkgmgr_res_event_info *handle, - pkgmgr_res_event_path_cb callback, void *user_data) -{ - pkgmgr_res_event_info_t *info = handle; - GList *list; - res_event_path_state_t *path_state; - - if (info == NULL) { - ERR("invalid parameter"); - return PKGMGR_R_EINVAL; - } - - for (list = info->path_states; list != NULL; list = list->next) { - path_state = (res_event_path_state_t *)list->data; - if (callback(path_state->path, path_state->state, - user_data) < 0) - return PKGMGR_R_OK; - } - - return PKGMGR_R_OK; -} diff --git a/client/src/pkgmgr_client_connection.c b/client/src/pkgmgr_client_connection.c deleted file mode 100644 index 0c7d471..0000000 --- a/client/src/pkgmgr_client_connection.c +++ /dev/null @@ -1,466 +0,0 @@ -/* - * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved. - * - * 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. - * - */ - -#include -#include -#include -#include - -#include -#include - -#include "package-manager.h" -#include "pkgmgr_client_debug.h" -#include "pkgmgr_client_internal.h" -#include "../../installer/pkgmgr_installer.h" -#include "../../installer/pkgmgr_installer_config.h" - -#define CONNECTION_RETRY_MAX 5 -#define CONNECTION_WAIT_USEC (1000000 / 2) /* 0.5 sec */ -#define CONNECTION_TIMEOUT_MSEC 5000 /* 5 sec */ -#define REGULAR_USER 5000 - -static int _is_system_user(void) -{ - uid_t uid = getuid(); - - if (uid < REGULAR_USER) - return 1; - else - return 0; -} - -static GBusType __get_bus_type(pkgmgr_client_type type) -{ - if (type == PC_REQUEST || _is_system_user()) - return G_BUS_TYPE_SYSTEM; - else - return G_BUS_TYPE_SESSION; -} - -int pkgmgr_client_connection_connect(struct pkgmgr_client_t *pc) -{ - GError *error = NULL; - GBusType bus_type; - -#if !GLIB_CHECK_VERSION(2, 35, 0) - g_type_init(); -#endif - bus_type = __get_bus_type(pc->pc_type); - pc->conn = g_bus_get_sync(bus_type, NULL, &error); - if (error) { - ERR("gdbus connection error (%s)", error->message); - g_error_free(error); - return PKGMGR_R_ECOMM; - } - - return PKGMGR_R_OK; -} - -void pkgmgr_client_connection_disconnect(struct pkgmgr_client_t *pc) -{ - /* flush remaining buffer: blocking mode */ - g_dbus_connection_flush_sync(pc->conn, NULL, NULL); - g_object_unref(pc->conn); - pc->conn = NULL; -} - -struct signal_map { - const char *signal_str; - int signal_type; -}; - -struct signal_map map[] = { - {PKGMGR_INSTALLER_INSTALL_EVENT_STR, PKGMGR_CLIENT_STATUS_INSTALL}, - {PKGMGR_INSTALLER_UNINSTALL_EVENT_STR, PKGMGR_CLIENT_STATUS_UNINSTALL}, - {PKGMGR_INSTALLER_UPGRADE_EVENT_STR, PKGMGR_CLIENT_STATUS_UPGRADE}, - {PKGMGR_INSTALLER_CLEAR_EVENT_STR, PKGMGR_CLIENT_STATUS_CLEAR_DATA}, - {PKGMGR_INSTALLER_MOVE_EVENT_STR, PKGMGR_CLIENT_STATUS_MOVE}, - {PKGMGR_INSTALLER_INSTALL_PERCENT_KEY_STR, - PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS}, - {PKGMGR_INSTALLER_GET_SIZE_KEY_STR, PKGMGR_CLIENT_STATUS_GET_SIZE}, - {PKGMGR_INSTALLER_CLEAR_CACHE_KEY_STR, - PKGMGR_CLIENT_STATUS_CLEAR_CACHE}, - {PKGMGR_INSTALLER_APP_ENABLE_EVENT_STR, - PKGMGR_CLIENT_STATUS_ENABLE_APP}, - {PKGMGR_INSTALLER_APP_DISABLE_EVENT_STR, - PKGMGR_CLIENT_STATUS_DISABLE_APP}, - {PKGMGR_INSTALLER_APP_ENABLE_SPLASH_SCREEN_EVENT_STR, - PKGMGR_CLIENT_STATUS_ENABLE_APP_SPLASH_SCREEN}, - {PKGMGR_INSTALLER_APP_DISABLE_SPLASH_SCREEN_EVENT_STR, - PKGMGR_CLIENT_STATUS_DISABLE_APP_SPLASH_SCREEN}, - {PKGMGR_INSTALLER_RES_COPY_EVENT_STR, PKGMGR_CLIENT_STATUS_RES_COPY}, - {PKGMGR_INSTALLER_RES_CREATE_DIR_EVENT_STR, - PKGMGR_CLIENT_STATUS_RES_CREATE_DIR}, - {PKGMGR_INSTALLER_RES_REMOVE_EVENT_STR, - PKGMGR_CLIENT_STATUS_RES_REMOVE}, - {PKGMGR_INSTALLER_RES_UNINSTALL_EVENT_STR, - PKGMGR_CLIENT_STATUS_RES_UNINSTALL}, - {NULL, -1} -}; - -static int __get_signal_type(const char *name) -{ - int i; - - if (name == NULL) - return -1; - - for (i = 0; map[i].signal_str != NULL; i++) { - if (strcmp(map[i].signal_str, name) == 0) - return map[i].signal_type; - } - - return -1; -} - -static void __handle_size_info_callback(struct cb_info *cb_info, - const char *pkgid, const char *val) -{ - pkg_size_info_t size_info; - char buf[BUFMAX]; - char *saveptr; - char *token; - pkgmgr_total_pkg_size_info_receive_cb callback; - - snprintf(buf, sizeof(buf), "%s", val); - - DBG("%s, %s", pkgid, val); - - token = strtok_r(buf, ":", &saveptr); - if (token == NULL) { - ERR("failed to parse size info"); - return; - } - size_info.data_size = atoll(token); - token = strtok_r(NULL, ":", &saveptr); - if (token == NULL) { - ERR("failed to parse size info"); - return; - } - size_info.cache_size = atoll(token); - token = strtok_r(NULL, ":", &saveptr); - if (token == NULL) { - ERR("failed to parse size info"); - return; - } - size_info.app_size = atoll(token); - token = strtok_r(NULL, ":", &saveptr); - if (token == NULL) { - ERR("failed to parse size info"); - return; - } - size_info.ext_data_size = atoll(token); - token = strtok_r(NULL, ":", &saveptr); - if (token == NULL) { - ERR("failed to parse size info"); - return; - } - size_info.ext_cache_size = atoll(token); - token = strtok_r(NULL, ":", &saveptr); - if (token == NULL) { - ERR("failed to parse size info"); - return; - } - size_info.ext_app_size = atoll(token); - - DBG("data: %lld, cache: %lld, app: %lld, ext_data: %lld, " - "ext_cache: %lld, ext_app: %lld", - size_info.data_size, size_info.cache_size, - size_info.app_size, size_info.ext_data_size, - size_info.ext_cache_size, size_info.ext_app_size); - - if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0) { - callback = (pkgmgr_total_pkg_size_info_receive_cb) - cb_info->size_info_cb; - callback(cb_info->client, &size_info, cb_info->data); - } else { - cb_info->size_info_cb(cb_info->client, pkgid, &size_info, - cb_info->data); - } -} - -static void __handle_pkg_signal(const gchar *signal_name, - GVariant *parameters, gpointer user_data) -{ - uid_t target_uid; - char *req_id; - char *pkg_type = NULL; - char *appid = NULL; - char *pkgid = NULL; - char *key = NULL; - char *val = NULL; - struct cb_info *cb_info = (struct cb_info *)user_data; - GVariantIter *iter = NULL; - int signal_type; - - g_variant_get(parameters, "(u&sa(sss)&s&s)", &target_uid, &req_id, &iter, - &key, &val); - while (g_variant_iter_loop(iter, "(&s&s&s)", &pkgid, &appid, &pkg_type)) { - if (cb_info->req_key) { - if (strcmp(cb_info->req_key, req_id) != 0) - continue; - } else { - signal_type = __get_signal_type(signal_name); - if (signal_type < 0 || !(cb_info->status_type & signal_type)) { - g_variant_iter_free(iter); - return; - } - } - - /* each cb_data can only has one callback */ - if (cb_info->event_cb) { - cb_info->event_cb(target_uid, cb_info->req_id, - pkg_type, pkgid, key, val, NULL, cb_info->data); - } else if (cb_info->app_event_cb && strcmp(appid, "") != 0) { - cb_info->app_event_cb(target_uid, cb_info->req_id, - pkg_type, pkgid, appid, key, val, NULL, - cb_info->data); - } else if (cb_info->size_info_cb) { - __handle_size_info_callback(cb_info, pkgid, val); - } - - /* TODO: unsubscribe request callback */ - } - g_variant_iter_free(iter); -} - -static void __handle_res_event_signal(const gchar *signal_name, - GVariant *parameters, gpointer user_data) -{ - uid_t target_uid; - char *req_id; - char *pkgid = NULL; - char *status = NULL; - char *path = NULL; - pkgmgr_res_event_path_state state; - struct cb_info *cb_info = (struct cb_info *)user_data; - int signal_type; - GVariant *extra_param = NULL; - pkgmgr_res_event_info_t *event_info; - GVariantIter *iter; - - if (!cb_info->res_event_cb) - return; - - g_variant_get(parameters, "(u&s&s&sv)", &target_uid, &req_id, &pkgid, &status, &extra_param); - if (!g_variant_type_equal(G_VARIANT_TYPE("(ia(si))"), - g_variant_get_type(extra_param))) { - ERR("invalid extra parameter"); - g_variant_unref(extra_param); - return; - } - if (cb_info->req_key) { - if (strcmp(cb_info->req_key, req_id) != 0) { - g_variant_unref(extra_param); - return; - } - } else { - signal_type = __get_signal_type(signal_name); - if (signal_type < 0 || !(cb_info->status_type & signal_type)) { - g_variant_unref(extra_param); - return; - } - } - - event_info = pkgmgr_res_event_info_new(); - if (event_info == NULL) { - ERR("out of memory"); - g_variant_unref(extra_param); - return; - } - - g_variant_get(extra_param, "(ia(si))", &event_info->error_code, &iter); - - while (g_variant_iter_loop(iter, "(&si)", &path, &state)) { - if (pkgmgr_res_event_info_add_path_state(event_info, - path, state) != PKGMGR_R_OK) { - ERR("Fail to add path state"); - g_variant_unref(extra_param); - g_variant_iter_free(iter); - pkgmgr_res_event_info_free(event_info); - return; - } - } - cb_info->res_event_cb(target_uid, cb_info->req_id, pkgid, signal_name, - status, event_info, cb_info->data); - g_variant_unref(extra_param); - g_variant_iter_free(iter); - pkgmgr_res_event_info_free(event_info); -} - -static void __handle_pkg_upgrade_event_signal(const gchar *signal_name, - GVariant *parameters, gpointer user_data) -{ - guint32 progress; - struct cb_info *cb_info = (struct cb_info *)user_data; - - if (!cb_info->upgrade_event_cb) - return; - - if (strcmp(signal_name, PKGMGR_INSTALLER_PKG_UPGRADE_EVENT_STR) != 0) { - return; - } - - g_variant_get(parameters, "(u)", &progress); - cb_info->upgrade_event_cb(progress, cb_info->data); -} - -static void __signal_handler(GDBusConnection *conn, const gchar *sender_name, - const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, - gpointer user_data) -{ - if (g_variant_type_equal(G_VARIANT_TYPE("(usa(sss)ss)"), - g_variant_get_type(parameters))) { - __handle_pkg_signal(signal_name, parameters, user_data); - } else if (!strcmp(signal_name, PKGMGR_INSTALLER_RES_COPY_EVENT_STR) || - !strcmp(signal_name, PKGMGR_INSTALLER_RES_REMOVE_EVENT_STR) || - !strcmp(signal_name, PKGMGR_INSTALLER_RES_UNINSTALL_EVENT_STR) || - !strcmp(signal_name, PKGMGR_INSTALLER_RES_CREATE_DIR_EVENT_STR)) { - __handle_res_event_signal(signal_name, parameters, user_data); - } else if (!strcmp(signal_name, PKGMGR_INSTALLER_PKG_UPGRADE_EVENT_STR)) { - __handle_pkg_upgrade_event_signal(signal_name, parameters, user_data); - } -} - -static void __set_signal_list(int event, GList **signal_list) -{ - int i; - if (event == PKGMGR_CLIENT_STATUS_ALL) - return; - - for (i = 0; map[i].signal_str != NULL; i++) { - if (event & map[i].signal_type) - *signal_list = g_list_append(*signal_list, - (char *)map[i].signal_str); - } -} - -static int __subscribe_signal(struct pkgmgr_client_t *pc, - struct cb_info *cb_info, const char *signal) -{ - guint sid = g_dbus_connection_signal_subscribe(pc->conn, NULL, - PKGMGR_INSTALLER_DBUS_INTERFACE, signal, - PKGMGR_INSTALLER_DBUS_OBJECT_PATH, NULL, - G_DBUS_SIGNAL_FLAGS_NONE, __signal_handler, - (gpointer)cb_info, NULL); - if (!sid) { - ERR("failed to subscribe singal"); - return PKGMGR_R_ERROR; - } - cb_info->sid_list = g_list_append(cb_info->sid_list, - GUINT_TO_POINTER(sid)); - - return PKGMGR_R_OK; -} - -int pkgmgr_client_connection_set_callback(struct pkgmgr_client_t *pc, - struct cb_info *cb_info) -{ - GList *signal_list = NULL; - GList *tmp_list = NULL; - int ret; - char *signal_type; - __set_signal_list(pc->status_type, &signal_list); - - if (g_list_length(signal_list) == 0) - return __subscribe_signal(pc, cb_info, NULL); - - for (tmp_list = signal_list; tmp_list != NULL; - tmp_list = g_list_next(tmp_list)) { - signal_type = (char *)tmp_list->data; - ret = __subscribe_signal(pc, cb_info, signal_type); - if (ret != 0) { - g_list_free(signal_list); - return PKGMGR_R_ERROR; - } - } - - g_list_free(signal_list); - return PKGMGR_R_OK; -} - -void pkgmgr_client_connection_unset_callback(struct pkgmgr_client_t *pc, - struct cb_info *cb_info) -{ - GList *tmp = NULL; - guint tmp_sid; - for (tmp = cb_info->sid_list; tmp != NULL; tmp = g_list_next(tmp)) { - tmp_sid = GPOINTER_TO_UINT(tmp->data); - g_dbus_connection_signal_unsubscribe(pc->conn, tmp_sid); - } -} - -int pkgmgr_client_connection_send_request(struct pkgmgr_client_t *pc, - const char *method, GVariant *params, GVariant **result) -{ - GError *error = NULL; - GDBusProxy *proxy; - GVariant *r = NULL; - int retry_cnt = 0; - int ret = PKGMGR_R_ECOMM; - - /* convert floating ref into normal ref */ - g_variant_ref_sink(params); - - do { - proxy = g_dbus_proxy_new_sync(pc->conn, - G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, - NULL, PKGMGR_DBUS_SERVICE, - PKGMGR_DBUS_OBJECT_PATH, - PKGMGR_DBUS_INTERFACE, NULL, &error); - if (proxy == NULL) { - ERR("failed to get proxy object, sleep and retry[%s]", - error->message); - g_error_free(error); - error = NULL; - usleep(CONNECTION_WAIT_USEC); - retry_cnt++; - continue; - } - - r = g_dbus_proxy_call_sync(proxy, method, params, - G_DBUS_CALL_FLAGS_NONE, - CONNECTION_TIMEOUT_MSEC, NULL, &error); - g_object_unref(proxy); - if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED) { - ERR("failed to send request, privilege denied[%s]", - error->message); - g_error_free(error); - ret = PKGMGR_R_EPRIV; - break; - } - if (r) { - *result = r; - ret = PKGMGR_R_OK; - break; - } - - ERR("failed to send request, sleep and retry[%s]", - error->message); - g_error_free(error); - error = NULL; - usleep(CONNECTION_WAIT_USEC); - retry_cnt++; - } while (retry_cnt <= CONNECTION_RETRY_MAX); - - /* decrease ref count to 0 to free resource */ - g_variant_unref(params); - - return ret; -} diff --git a/client/src/pkgmgr_client_debug.h b/client/src/pkgmgr_client_debug.h deleted file mode 100644 index b81f948..0000000 --- a/client/src/pkgmgr_client_debug.h +++ /dev/null @@ -1,91 +0,0 @@ -/* - * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. - * - * Contact: junsuk. oh - * - * 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. - * - */ - -#ifndef __PKGMGR_CLIENT_DEBUG_H__ -#define __PKGMGR_CLIENT_DEBUG_H__ - -#include - -#ifdef LOG_TAG -#undef LOG_TAG -#endif /* LOG_TAG */ -#define LOG_TAG "PKGMGR" - -#ifndef ERR -#define ERR(fmt, args...) LOGE("[%s:%d] "fmt"\n", __func__, __LINE__, ##args) -#endif - -#ifndef DBG -#define DBG(fmt, args...) LOGD("[%s:%d] "fmt"\n", __func__, __LINE__, ##args) -#endif - -#ifndef INFO -#define INFO(fmt, args...) LOGI("[%s:%d] "fmt"\n", __func__, __LINE__, ##args) -#endif - -#define ret_if(expr) \ - do { \ - if (expr) { \ - ERR("(%s) ", #expr); \ - return; \ - } \ - } while (0) - -#define retm_if(expr, fmt, arg...) \ - do { \ - if (expr) { \ - ERR("(%s) "fmt, #expr, ##arg); \ - return; \ - } \ - } while (0) - -#define retv_if(expr, val) \ - do { \ - if (expr) { \ - ERR("(%s) ", #expr); \ - return (val); \ - } \ - } while (0) - -#define retvm_if(expr, val, fmt, arg...) \ - do { \ - if (expr) { \ - ERR("(%s) "fmt, #expr, ##arg); \ - return (val); \ - } \ - } while (0) - -#define trym_if(expr, fmt, arg...) \ - do { \ - if (expr) { \ - ERR("(%s) "fmt, #expr, ##arg); \ - goto catch; \ - } \ - } while (0) - -#define tryvm_if(expr, val, fmt, arg...) \ - do { \ - if (expr) { \ - ERR("(%s) "fmt, #expr, ##arg); \ - val; \ - goto catch; \ - } \ - } while (0) - -#endif /* __PKGMGR_CLIENT_DEBUG_H__ */ diff --git a/client/src/pkgmgr_client_internal.c b/client/src/pkgmgr_client_internal.c deleted file mode 100644 index da4d5a7..0000000 --- a/client/src/pkgmgr_client_internal.c +++ /dev/null @@ -1,198 +0,0 @@ -/* - * slp-pkgmgr - * - * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. - * - * Contact: Jayoun Lee , Sewook Park , - * Jaeho Lee , Shobhit Srivastava - * - * 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. - * - */ - - - - - -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include - -#include "package-manager.h" -#include "pkgmgr_client_debug.h" -#include "pkgmgr_client_internal.h" - -#define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER) - -#define IS_WHITESPACE(CHAR) \ - ((CHAR == ' ' || CHAR == '\t' || CHAR == '\r' || CHAR == '\n') ? \ - true : false) - -void _app_str_trim(char *input) -{ - char *trim_str = input; - - if (input == NULL) - return; - - while (*input != 0) { - if (!IS_WHITESPACE(*input)) { - *trim_str = *input; - trim_str++; - } - input++; - } - - *trim_str = 0; - return; -} - -static pkg_plugin_set *plugin_set_list[24] = { 0, }; - -pkg_plugin_set *_pkg_plugin_load_library(const char *pkg_type, - const char *library_path) -{ - void *library_handle; - int i; - bool (*on_load)(pkg_plugin_set *plugin); - - if (library_path == NULL || pkg_type == NULL) { - ERR("invalid parameter"); - return NULL; - } - - for (i = 0; plugin_set_list[i]; i++) { - if (strcmp(plugin_set_list[i]->pkg_type, pkg_type) == 0) { - DBG("already loaded [%s]", library_path); - return plugin_set_list[i]; - } - } - - if ((library_handle = dlopen(library_path, RTLD_LAZY)) == NULL) { - ERR("dlopen is failed library_path[%s]", library_path); - return NULL; - } - - if ((on_load = dlsym(library_handle, "pkg_plugin_on_load")) == NULL || - dlerror() != NULL) { - ERR("can not find symbol"); - dlclose(library_handle); - return NULL; - } - - plugin_set_list[i] = (pkg_plugin_set *)calloc(1, sizeof(pkg_plugin_set)); - if (plugin_set_list[i] == NULL) { - ERR("malloc of the plugin_set_list element is failed"); - dlclose(library_handle); - return NULL; - } - - if (on_load(plugin_set_list[i]) != 0) { - ERR("pkg_plugin_on_load failed"); - free(plugin_set_list[i]); - dlclose(library_handle); - plugin_set_list[i] = NULL; - return NULL; - } - - plugin_set_list[i]->plugin_handle = library_handle; - snprintf(plugin_set_list[i]->pkg_type, - sizeof(plugin_set_list[i]->pkg_type), "%s", pkg_type); - - DBG("library [%s] is loaded", library_path); - - return plugin_set_list[i]; -} - -int _pkg_plugin_get_library_path(const char *pkg_type, char *library_path) -{ - FILE *fp = NULL; - char buffer[1024] = { 0 }; - - if (pkg_type == NULL || library_path == NULL) { - ERR("invalid argument\n"); - return -1; - } - - fp = fopen(PKG_CONF_PATH, "r"); - if (fp == NULL) { - ERR("no matching backendlib\n"); - return PKGMGR_R_ERROR; - } - - char *path = NULL; - while (fgets(buffer, 1024, fp) != NULL) { - if (buffer[0] == '#') - continue; - - _app_str_trim(buffer); - - if ((path = strstr(buffer, PKG_BACKENDLIB)) != NULL) { - DBG("[%s]\n", buffer); - DBG("[%s]\n", path); - path = path + strlen(PKG_BACKENDLIB); - DBG("[%s]\n", path); - - break; - } - - memset(buffer, 0x00, 1024); - } - - if (fp != NULL) - fclose(fp); - - if (path == NULL) { - ERR("no matching backendlib\n"); - return PKGMGR_R_ERROR; - } - - snprintf(library_path, 1024, "%slib%s.so", path, pkg_type); - - return PKGMGR_R_OK; - -} - -pkg_plugin_set *_package_manager_load_library(const char *pkg_type) -{ - char package_path[1024] = { 0, }; - pkg_plugin_set *plugin_set; - - if (pkg_type == NULL) { - ERR("cannot load library - pkg_type is null"); - return NULL; - } - - if (_pkg_plugin_get_library_path(pkg_type, package_path) != - PKGMGR_R_OK) { - ERR("cannot find path"); - return NULL; - } - - plugin_set = _pkg_plugin_load_library(pkg_type, package_path); - if (plugin_set == NULL) { - ERR("cannot load library"); - return NULL; - } - - return plugin_set; -} diff --git a/client/src/pkgmgr_client_internal.h b/client/src/pkgmgr_client_internal.h deleted file mode 100644 index db659d4..0000000 --- a/client/src/pkgmgr_client_internal.h +++ /dev/null @@ -1,91 +0,0 @@ -/* - * slp-pkgmgr - * - * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. - * - * Contact: Jayoun Lee , Sewook Park , - * Jaeho Lee , Shobhit Srivastava - * - * 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. - * - */ - -#ifndef __PKGMGR_CLIENT_INTERNAL_H__ -#define __PKGMGR_CLIENT_INTERNAL_H__ - -#include -#include - -#include -#include - -#include "package-manager-plugin.h" -#include "package-manager.h" - -#define BUFMAX 4096 - -struct cb_info { - int req_id; - char *req_key; - int status_type; - pkgmgr_handler event_cb; - pkgmgr_app_handler app_event_cb; - pkgmgr_pkg_size_info_receive_cb size_info_cb; - pkgmgr_res_handler res_event_cb; - pkgmgr_pkg_upgrade_handler upgrade_event_cb; - void *data; - struct pkgmgr_client_t *client; - GList *sid_list; -}; - -struct pkgmgr_client_t { - pkgmgr_client_type pc_type; - int status_type; - GDBusConnection *conn; - GList *cb_info_list; - GVariantBuilder *res_copy_builder; - GVariantBuilder *res_remove_builder; - GVariantBuilder *res_create_dir_builder; - char *tep_path; - bool tep_move; - bool debug_mode; - bool skip_optimization; -}; - -struct manifest_and_type { - const char *manifest; - const char *type; -}; - -int pkgmgr_client_connection_connect(struct pkgmgr_client_t *pc); -void pkgmgr_client_connection_disconnect(struct pkgmgr_client_t *pc); -int pkgmgr_client_connection_set_callback(struct pkgmgr_client_t *pc, - struct cb_info *cb_info); -void pkgmgr_client_connection_unset_callback(struct pkgmgr_client_t *pc, - struct cb_info *cb_info); -int pkgmgr_client_connection_send_request(struct pkgmgr_client_t *pc, - const char *method, GVariant *params, GVariant **result); - -pkg_plugin_set *_pkg_plugin_load_library(const char *pkg_type, - const char *library_path); - -int _pkg_plugin_get_library_path(const char *pkg_type, char *library_path); - -pkg_plugin_set *_package_manager_load_library(const char *pkg_type); - -#define PKG_BACKENDLIB "backendlib:" -#define PKG_CONF_PATH "/etc/package-manager/pkg_path.conf" - -void _app_str_trim(char *input); - -#endif /* __PKGMGR_CLIENT_INTERNAL_H__ */ diff --git a/client/src/signal_receiver.cc b/client/src/signal_receiver.cc new file mode 100644 index 0000000..c95bcea --- /dev/null +++ b/client/src/signal_receiver.cc @@ -0,0 +1,192 @@ +/* + * Copyright (c) 2022 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. + */ + +#include + +#include "signal_receiver.hh" + +namespace pkgmgr { +namespace client { + +#define AGENT_APPID "signal_agent" + +SignalReceiver::SignalReceiver(bool is_system) + : PkgSignal(is_system ? "" : AGENT_APPID, is_system) { +} + +SignalReceiver::~SignalReceiver() { +} + +void SignalReceiver::OnAsyncResult(std::string signal, int targetUid, + std::string reqId, std::vector pkgs, + std::string key, std::string val) { + HandleHandler(targetUid, reqId, pkgs, key, val); + HandleGlobalHandler(targetUid, reqId, pkgs, key, val); + HandleSizeInfoHandler(reqId, pkgs, key, val); +} + +void SignalReceiver::HandleHandler(int targetUid, + const std::string& reqId, const std::vector& pkgs, + const std::string& key, const std::string& val) const { + const auto it = handlers_.find(reqId); + if (it == handlers_.end()) + return; + const auto& [id, cb, app_cb, data] = it->second; + + for (auto& i : pkgs) { + if (cb) { + cb(targetUid, id, i.GetPkgType().c_str(), i.GetPkgid().c_str(), + key.c_str(), val.c_str(), nullptr, data); + } else { + app_cb(targetUid, id, i.GetPkgType().c_str(), i.GetPkgid().c_str(), + i.GetAppid().c_str(), key.c_str(), val.c_str(), nullptr, data); + } + } +} + +void SignalReceiver::HandleGlobalHandler(int targetUid, + const std::string& reqId, const std::vector& pkgs, + const std::string& key, const std::string& val) const { + for (auto& i : pkgs) { + for (const auto& [id, cb, app_cb, data] : global_handlers_) { + if (cb) { + cb(targetUid, id, i.GetPkgType().c_str(), i.GetPkgid().c_str(), + key.c_str(), val.c_str(), nullptr, data); + } else { + app_cb(targetUid, id, i.GetPkgType().c_str(), i.GetPkgid().c_str(), + i.GetAppid().c_str(), key.c_str(), val.c_str(), nullptr, data); + } + } + } +} + +void SignalReceiver::HandleSizeInfoHandler( + const std::string& reqId, const std::vector& pkgs, + const std::string& key, const std::string& val) const { + auto it = size_info_handlers_.find(reqId); + if (it == size_info_handlers_.end()) + return; + const auto& [id, cb, pc, data] = it->second; + + std::vector tokens; + std::istringstream ss(val); + std::string token; + + while (std::getline(ss, token, ':')) { + tokens.push_back(token); + } + + if (tokens.size() != 6) { + return; + } + + pkg_size_info_t size_info{ + std::stoll(tokens[0]), + std::stoll(tokens[1]), + std::stoll(tokens[2]), + std::stoll(tokens[3]), + std::stoll(tokens[4]), + std::stoll(tokens[5]), + }; + + for (auto& i : pkgs) { + if (i.GetPkgid() == std::string(PKG_SIZE_INFO_TOTAL)) { + pkgmgr_total_pkg_size_info_receive_cb callback; + callback = (pkgmgr_total_pkg_size_info_receive_cb)cb; + callback(pc, &size_info, data); + } else { + cb(pc, i.GetPkgid().c_str(), &size_info, data); + } + } +} + +void SignalReceiver::OnAsyncResultForResource(std::string signal, + int targetUid, std::string reqId, std::string pkgid, + std::string status, pkg_signal::ExtraData extra) { + HandleResHandler(signal, targetUid, reqId, pkgid, status, extra); + HandleGlobalResHandler(signal, targetUid, reqId, pkgid, status, extra); +} + +void SignalReceiver::HandleResHandler(const std::string& signal, + int targetUid, const std::string& reqId, const std::string& pkgid, + const std::string& status, pkg_signal::ExtraData& extra) const { + auto it = res_handlers_.find(reqId); + if (it == res_handlers_.end()) + return; + const auto& [id, cb, data] = it->second; + + cb(targetUid, id, pkgid.c_str(), signal.c_str(), status.c_str(), + static_cast(&extra), data); +} + +void SignalReceiver::HandleGlobalResHandler(const std::string& signal, + int targetUid, const std::string& reqId, const std::string& pkgid, + const std::string& status, pkg_signal::ExtraData& extra) const { + for (const auto& [id, cb, data] : global_res_handlers_) { + cb(targetUid, id, pkgid.c_str(), signal.c_str(), status.c_str(), + static_cast(&extra), data); + } +} + + +int SignalReceiver::AddEventHandler(std::string req_key, + pkgmgr_handler event_cb, void* data) { + return AddEventHandler(std::move(req_key), event_cb, nullptr, data); +} + +int SignalReceiver::AddEventHandler(std::string req_key, + pkgmgr_app_handler app_event_cb, void* data) { + return AddEventHandler(std::move(req_key), nullptr, app_event_cb, data); +} + +int SignalReceiver::AddEventHandler(std::string req_key, + pkgmgr_pkg_size_info_receive_cb event_cb, void* pc, void* data) { + int sId = SignalReceiver::GetRequestId(); + if (req_key.empty()) + global_size_info_handlers_.emplace_back(sId, event_cb, pc, data); + else + size_info_handlers_[req_key] = { sId, event_cb, pc, data }; + return sId; +} + +int SignalReceiver::AddEventHandler(std::string req_key, + pkgmgr_handler event_cb, pkgmgr_app_handler app_event_cb, void* data) { + int sId = SignalReceiver::GetRequestId(); + if (req_key.empty()) + global_handlers_.emplace_back(sId, event_cb, app_event_cb, data); + else + handlers_[req_key] = { sId, event_cb, app_event_cb, data }; + return sId; +} + +int SignalReceiver::AddEventHandler(std::string req_key, + pkgmgr_res_handler event_cb, void* data) { + int sId = SignalReceiver::GetRequestId(); + if (req_key.empty()) + global_res_handlers_.emplace_back(sId, event_cb, data); + else + res_handlers_[req_key] = { sId, event_cb, data }; + return sId; +} + + +int SignalReceiver::GetRequestId() { + return ++request_id_; +} + +} // namespace client +} // namespace pkgmgr + diff --git a/client/src/signal_receiver.hh b/client/src/signal_receiver.hh new file mode 100644 index 0000000..b6cf64b --- /dev/null +++ b/client/src/signal_receiver.hh @@ -0,0 +1,94 @@ +/* + * Copyright (c) 2022 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. + */ + + +#ifndef CLIENT_SRC_SIGNAL_RECEIVER_H_ +#define CLIENT_SRC_SIGNAL_RECEIVER_H_ + +#include "package-manager.h" + +#include +#include +#include +#include + +#include "PkgSignal.h" + + +namespace pkgmgr { +namespace client { + +namespace pkg_group = rpc_port::PkgSignal::group; +namespace pkg_signal = rpc_port::PkgSignal; + +class SignalReceiver : public pkg_group::PkgSignal { + public: + SignalReceiver(bool is_system); + virtual ~SignalReceiver(); + + void OnAsyncResult(std::string signal, int targetUid, std::string reqId, + std::vector pkgs, std::string key, + std::string val) override; + + void OnAsyncResultForResource(std::string signal, int targetUid, + std::string reqId, std::string pkgid, std::string status, + pkg_signal::ExtraData extra) override; + + int AddEventHandler(std::string req_key, pkgmgr_handler event_cb, void* data); + int AddEventHandler(std::string req_key, pkgmgr_app_handler app_event_cb, + void* data); + int AddEventHandler(std::string req_key, + pkgmgr_pkg_size_info_receive_cb event_cb, void* pc, void* data); + int AddEventHandler(std::string req_key, pkgmgr_res_handler event_cb, + void* data); + + private: + static int GetRequestId(); + int AddEventHandler(std::string req_key, pkgmgr_handler event_cb, + pkgmgr_app_handler app_event_cb, void* data); + void HandleHandler(int targetUid, const std::string& reqId, + const std::vector& pkgs, const std::string& key, + const std::string& val) const; + void HandleGlobalHandler(int targetUid, const std::string& reqId, + const std::vector& pkgs, const std::string& key, + const std::string& val) const; + void HandleResHandler(const std::string& signal, int targetUid, + const std::string& reqId, const std::string& pkgid, + const std::string& status, pkg_signal::ExtraData& extra) const; + void HandleGlobalResHandler(const std::string& signal, int targetUid, + const std::string& reqId, const std::string& pkgid, + const std::string& status, pkg_signal::ExtraData& extra) const; + void HandleSizeInfoHandler(const std::string& reqId, + const std::vector& pkgs, + const std::string& key, const std::string& val) const; + + private: + static inline int request_id_; + std::map> handlers_; + std::list> global_handlers_; + std::map> res_handlers_; + std::list> global_res_handlers_; + std::map> size_info_handlers_; + std::list> global_size_info_handlers_; +}; + +} // namespace client +} // namespace pkgmgr + +#endif // CLIENT_SRC_CONNECTOR_H_ \ No newline at end of file diff --git a/cmake/Modules/ApplyPkgConfig.cmake b/cmake/Modules/ApplyPkgConfig.cmake new file mode 100644 index 0000000..97679d7 --- /dev/null +++ b/cmake/Modules/ApplyPkgConfig.cmake @@ -0,0 +1,35 @@ +# Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +# +# This function applies external (out of source tree) dependencies +# to given target. Arguments are: +# TARGET - valid cmake target +# PRIVACY - dependency can be inherited by dependent targets or not: +# PUBLIC - this should be used by default, cause compile/link flags passing +# PRIVATE - do not passes any settings to dependent targets, +# may be usefull for static libraries from the inside of the project +# Argument ARGV2 and following are supposed to be names of checked pkg config +# packages. This function will use variables created by check_pkg_modules(). +# - ${DEP_NAME}_LIBRARIES +# - ${DEP_NAME}_INCLUDE_DIRS +# - ${DEP_NAME}_CFLAGS +# +FUNCTION(APPLY_PKG_CONFIG TARGET PRIVACY) + MATH(EXPR DEST_INDEX "${ARGC}-1") + FOREACH(I RANGE 2 ${DEST_INDEX}) + IF(NOT ${ARGV${I}}_FOUND) + MESSAGE(FATAL_ERROR "Not found dependency - ${ARGV${I}}_FOUND") + ENDIF(NOT ${ARGV${I}}_FOUND) + TARGET_LINK_LIBRARIES(${TARGET} ${PRIVACY} "${${ARGV${I}}_LIBRARIES}") + TARGET_INCLUDE_DIRECTORIES(${TARGET} ${PRIVACY} SYSTEM "${${ARGV${I}}_INCLUDE_DIRS}") + STRING(REPLACE ";" " " CFLAGS_STR "${${ARGV${I}}_CFLAGS}") + SET(CFLAGS_LIST ${CFLAGS_STR}) + SEPARATE_ARGUMENTS(CFLAGS_LIST) + FOREACH(OPTION ${CFLAGS_LIST}) + TARGET_COMPILE_OPTIONS(${TARGET} ${PRIVACY} ${OPTION}) + ENDFOREACH(OPTION) + SET_TARGET_PROPERTIES(${TARGET} PROPERTIES SKIP_BUILD_RPATH true) + ENDFOREACH(I RANGE 2 ${DEST_INDEX}) +ENDFUNCTION(APPLY_PKG_CONFIG TARGET PRIVACY) diff --git a/installer/CMakeLists.txt b/installer/CMakeLists.txt index 9c734d0..8e3c230 100644 --- a/installer/CMakeLists.txt +++ b/installer/CMakeLists.txt @@ -1,48 +1,58 @@ -### Description -# Communication modules for pkg-mgr client lib and server process -# By Youmin Ha - -cmake_minimum_required(VERSION 2.6) -#set(CMAKE_SKIP_BUILD_RPATH true) -set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS true) - -### Get required CFLAGS, LDFLAGS from pkg-config - include(FindPkgConfig) -pkg_check_modules(installer_pkgs REQUIRED glib-2.0 gio-2.0 dlog pkgmgr-info libtzplatform-config) -foreach(flag ${installer_pkgs_CFLAGS}) - set(installer_pkgs_CFLAGS_str "${installer_pkgs_CFLAGS_str} ${flag}") -endforeach() -PKG_CHECK_MODULES(AGENT_DEPS REQUIRED glib-2.0 gio-2.0 dlog libsystemd) +AUX_SOURCE_DIRECTORY(src SRCS) + +PKG_CHECK_MODULES(INSTALLER_DEPS REQUIRED + glib-2.0 + gio-2.0 + dlog + pkgmgr-info + libtzplatform-config + rpc-port + capi-appfw-event +) + +FOREACH(FLAGS ${INSTALLER_DEPS_CFLAGS}) + SET(INSTALLER_CFLAGS "${INSTALLER_CFLAGS} ${FLAGS}") +ENDFOREACH(FLAGS) + +PKG_CHECK_MODULES(AGENT_DEPS REQUIRED + aul + glib-2.0 + gio-2.0 + dlog + libsystemd +) FOREACH(FLAG ${AGENT_DEPS_CFLAGS}) SET(AGENT_CFLAGS "${AGENT_CFLAGS} ${FLAG}") ENDFOREACH() -### Build modules +SET(CMAKE_C_FLAGS "${INSTALLER_CFLAGS}") +SET(CMAKE_CXX_FLAGS "${INSTALLER_CFLAGS} -std=c++17 -fPIC") + +INCLUDE_DIRECTORIES(include) -## pkgmgr_installer object (by youmin.ha) -# This library is for installer backend -add_library(pkgmgr_installer SHARED pkgmgr_installer.c) +### Build modules +add_library(pkgmgr_installer SHARED ${SRCS}) set_target_properties(pkgmgr_installer PROPERTIES SOVERSION ${MAJORVER}) set_target_properties(pkgmgr_installer PROPERTIES VERSION ${FULLVER}) -set_target_properties(pkgmgr_installer PROPERTIES COMPILE_FLAGS "${installer_pkgs_CFLAGS_str} -fPIC") -target_link_libraries(pkgmgr_installer ${installer_pkgs_LDFLAGS}) +target_link_libraries(pkgmgr_installer ${INSTALLER_DEPS_LDFLAGS}) ### Create pc file configure_file(pkgmgr-installer.pc.in ${CMAKE_CURRENT_BINARY_DIR}/pkgmgr-installer.pc @ONLY) ## Install INSTALL(TARGETS pkgmgr_installer DESTINATION ${LIB_INSTALL_DIR} COMPONENT RuntimeLibraries) -INSTALL(FILES pkgmgr_installer.h DESTINATION include/pkgmgr) -INSTALL(FILES pkgmgr_installer_info.h DESTINATION include/pkgmgr) -INSTALL(FILES pkgmgr_installer_error.h DESTINATION include/pkgmgr) -INSTALL(FILES pkgmgr_installer_type.h DESTINATION include/pkgmgr) +INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/src/pkgmgr_installer.h DESTINATION include/pkgmgr) +INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/src/pkgmgr_installer_info.h DESTINATION include/pkgmgr) +INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/src/pkgmgr_installer_error.h DESTINATION include/pkgmgr) +INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/src/pkgmgr_installer_type.h DESTINATION include/pkgmgr) INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/pkgmgr-installer.pc DESTINATION ${LIB_INSTALL_DIR}/pkgconfig) ## pkgmgr_installer_signal_agent -ADD_EXECUTABLE(pkgmgr-installer-signal-agent pkgmgr_installer_signal_agent.c) +ADD_EXECUTABLE(pkgmgr-installer-signal-agent pkgmgr_installer_signal_agent.cc) SET_TARGET_PROPERTIES(pkgmgr-installer-signal-agent PROPERTIES COMPILE_FLAGS "${AGENT_CFLAGS} -fPIE") +TARGET_LINK_LIBRARIES(pkgmgr-installer-signal-agent PRIVATE pkgmgr_installer) TARGET_LINK_LIBRARIES(pkgmgr-installer-signal-agent ${AGENT_DEPS_LDFLAGS} "-pie") INSTALL(TARGETS pkgmgr-installer-signal-agent DESTINATION ${CMAKE_INSTALL_PREFIX}/bin) diff --git a/installer/pkgmgr-installer.pc.in b/installer/pkgmgr-installer.pc.in index f812a3b..fe02345 100644 --- a/installer/pkgmgr-installer.pc.in +++ b/installer/pkgmgr-installer.pc.in @@ -11,6 +11,6 @@ includedir=@INCLUDEDIR@ Name: package manager installer library Description: SLP package manager's installer lib for each backends Version: @FULLVER@ -Requires: +Requires: capi-appfw-event Libs: -L${libdir} -lpkgmgr_installer Cflags: -I${includedir}/pkgmgr diff --git a/installer/pkgmgr_installer.c b/installer/pkgmgr_installer.c deleted file mode 100644 index fd8a09f..0000000 --- a/installer/pkgmgr_installer.c +++ /dev/null @@ -1,1446 +0,0 @@ -/* - * slp-pkgmgr - * - * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. - * - * Contact: Jayoun Lee , Sewook Park , - * Jaeho Lee , Shobhit Srivastava - * - * 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. - * - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include - -#include "package-manager.h" -#include "pkgmgr_installer.h" -#include "pkgmgr_installer_config.h" -#include "pkgmgr_installer_debug.h" -#include "pkgmgr_installer_info.h" -#include "pkgmgr_installer_error.h" -#include "package-manager-types.h" - -#include - -/* API export macro */ -#ifndef API -#define API __attribute__ ((visibility("default"))) -#endif - -#define MAX_STRLEN 1024 -#define MAX_QUERY_LEN 4096 - -#define CHK_PI_RET(r) \ - do { if (NULL == pi) return (r); } while (0) - -#define OPTVAL_PRELOAD 1000 -#define OPTVAL_FORCE_REMOVAL 1001 -#define OPTVAL_PRELOAD_RW 1002 -#define OPTVAL_NO_REMOVAL 1003 -#define OPTVAL_KEEP_RWDATA 1004 -#define OPTVAL_PARTIAL_RW 1005 -#define OPTVAL_MIGRATE_EXTIMG 1006 -#define OPTVAL_SKIP_CHECK_REFERENCE 1007 -#define OPTVAL_RECOVER_DB 1008 -#define OPTVAL_RECOVERY_CLEANUP 1009 - -/* Supported options */ -const char *short_opts = "k:l:i:d:c:m:t:o:r:p:s:b:e:M:y:u:w:D:A:qGS"; -const struct option long_opts[] = { - { "session-id", 1, NULL, 'k' }, - { "license-path", 1, NULL, 'l' }, - { "install", 1, NULL, 'i' }, - { "uninstall", 1, NULL, 'd' }, - { "clear", 1, NULL, 'c' }, - { "move", 1, NULL, 'm' }, - { "move-type", 1, NULL, 't' }, - { "optional-data", 0, NULL, 'o' }, - { "reinstall", 0, NULL, 'r' }, - { "caller-pkgid", 1, NULL, 'p' }, - { "tep-path", 1, NULL, 'e' }, - { "tep-move", 1, NULL, 'M' }, - { "smack", 1, NULL, 's' }, - { "manifest-direct-install", 1, NULL, 'y' }, - { "mount-install", 1, NULL, 'w' }, - { "recovery", 1, NULL, 'b' }, - { "debug-mode", 0, NULL, 'G' }, - { "skip-optimization", 0, NULL, 'S' }, - { "preload", 0, NULL, OPTVAL_PRELOAD }, /* for preload RO */ - { "force-remove", 0, NULL, OPTVAL_FORCE_REMOVAL }, /* for preload RO/RW */ - { "preload-rw", 0, NULL, OPTVAL_PRELOAD_RW }, /* for preload RW */ - { "no-remove", 0, NULL, OPTVAL_NO_REMOVAL }, /* for preload RW */ - { "keep-rwdata", 0, NULL, OPTVAL_KEEP_RWDATA }, /* for preload RW */ - { "partial-rw", 0, NULL, OPTVAL_PARTIAL_RW }, /* for preload RO */ - { "migrate-extimg", 1, NULL, OPTVAL_MIGRATE_EXTIMG }, - { "skip-check-reference", 0, NULL, OPTVAL_SKIP_CHECK_REFERENCE }, - { "recover-db", 1, NULL, OPTVAL_RECOVER_DB }, - { "recovery-cleanup", 0, NULL, OPTVAL_RECOVERY_CLEANUP }, - { 0, 0, 0, 0 } /* sentinel */ -}; - -struct pkgmgr_installer { - int request_type; - int move_type; - int is_upgrade; - char *pkgmgr_info; - char *session_id; - char *license_path; - char *optional_data; - char *caller_pkgid; - uid_t target_uid; - char *tep_path; - int tep_move; - int is_tep_included; - int is_preload; - int force_removal; - int is_preload_rw; - int no_removal; - int keep_rwdata; - int partial_rw; - int debug_mode; - int skip_check_reference; - int skip_optimization; - int recovery_cleanup; - GDBusConnection *conn; - GHashTable *pkg_list; - GList *pkgs; -}; - -typedef struct pkg_signal_info { - char *pkgid; - char *pkg_type; -} pkg_signal_info; - -static uid_t g_target_uid; -static int g_debug_mode; -static int g_skip_optimization; -static pkgmgr_privilege_level g_privilege_level = PM_PRIVILEGE_UNKNOWN; - -static const char *__get_signal_name(pkgmgr_installer *pi, const char *key, - const char *pkg_type) -{ - if (strcmp(key, PKGMGR_INSTALLER_INSTALL_PERCENT_KEY_STR) == 0) - return key; - else if (strcmp(key, PKGMGR_INSTALLER_GET_SIZE_KEY_STR) == 0) - return key; - else if (strcmp(key, PKGMGR_INSTALLER_APPID_KEY_STR) == 0) - return PKGMGR_INSTALLER_UNINSTALL_EVENT_STR; - else if (strcmp(pkg_type, PKGMGR_INSTALLER_CLEAR_CACHE_KEY_STR) == 0) - return pkg_type; - else if (pi->is_upgrade) - return PKGMGR_INSTALLER_UPGRADE_EVENT_STR; - - - switch (pi->request_type) { - case PKGMGR_REQ_INSTALL: - case PKGMGR_REQ_MANIFEST_DIRECT_INSTALL: - case PKGMGR_REQ_MOUNT_INSTALL: - case PKGMGR_REQ_REINSTALL: - case PKGMGR_REQ_ENABLE_PKG: - case PKGMGR_REQ_RECOVER: - return PKGMGR_INSTALLER_INSTALL_EVENT_STR; - case PKGMGR_REQ_UNINSTALL: - case PKGMGR_REQ_DISABLE_PKG: - return PKGMGR_INSTALLER_UNINSTALL_EVENT_STR; - case PKGMGR_REQ_UPGRADE: - return PKGMGR_INSTALLER_UPGRADE_EVENT_STR; - case PKGMGR_REQ_MOVE: - return PKGMGR_INSTALLER_MOVE_EVENT_STR; - case PKGMGR_REQ_ENABLE_APP: - return PKGMGR_INSTALLER_APP_ENABLE_EVENT_STR; - case PKGMGR_REQ_DISABLE_APP: - return PKGMGR_INSTALLER_APP_DISABLE_EVENT_STR; - case PKGMGR_REQ_ENABLE_APP_SPLASH_SCREEN: - return PKGMGR_INSTALLER_APP_ENABLE_SPLASH_SCREEN_EVENT_STR; - case PKGMGR_REQ_DISABLE_APP_SPLASH_SCREEN: - return PKGMGR_INSTALLER_APP_DISABLE_SPLASH_SCREEN_EVENT_STR; - case PKGMGR_REQ_CLEAR: - return PKGMGR_INSTALLER_CLEAR_EVENT_STR; - case PKGMGR_REQ_GETSIZE: - return PKGMGR_INSTALLER_GET_SIZE_KEY_STR; - case PKGMGR_REQ_RES_COPY: - return PKGMGR_INSTALLER_RES_COPY_EVENT_STR; - case PKGMGR_REQ_RES_CREATE_DIR: - return PKGMGR_INSTALLER_RES_CREATE_DIR_EVENT_STR; - case PKGMGR_REQ_RES_REMOVE: - return PKGMGR_INSTALLER_RES_REMOVE_EVENT_STR; - case PKGMGR_REQ_RES_UNINSTALL: - return PKGMGR_INSTALLER_RES_UNINSTALL_EVENT_STR; - } - - ERR("cannot find type"); - - return NULL; -} - -static int __send_signal_for_event(pkgmgr_installer *pi, const char *pkg_type, - const char *pkgid, const char *appid, const char *key, - const char *val) -{ - char *sid; - const char *tmp_appid = appid; - const char *signal_name; - GVariant *v; - GVariantBuilder *builder; - GError *err = NULL; - - if (!pi || pi->conn == NULL) - return -1; - - sid = pi->session_id; - if (!sid) - sid = ""; - - signal_name = __get_signal_name(pi, key, pkg_type); - if (!signal_name) { - ERR("unknown signal type"); - return -1; - } - - builder = g_variant_builder_new(G_VARIANT_TYPE("a(sss)")); - g_variant_builder_add(builder, "(sss)", pkgid, - (tmp_appid ? tmp_appid : ""), pkg_type); - v = g_variant_new("(usa(sss)ss)", - pi->target_uid, sid, builder, key, val); - g_variant_builder_unref(builder); - if (g_dbus_connection_emit_signal(pi->conn, NULL, - PKGMGR_INSTALLER_DBUS_OBJECT_PATH, - PKGMGR_INSTALLER_DBUS_INTERFACE, signal_name, - v, &err) != TRUE) { - ERR("failed to send dbus signal"); - if (err) { - ERR("err: %s", err->message); - g_error_free(err); - } - return -1; - } - - return 0; -} - -static int __send_signal_to_agent(uid_t uid, void *data, size_t len) -{ - int fd; - struct sockaddr_un sa; - int r; - - fd = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0); - if (fd == -1) { - ERR("failed to create socket: %d", errno); - return -1; - } - - sa.sun_family = AF_UNIX; - snprintf(sa.sun_path, sizeof(sa.sun_path), "/run/pkgmgr/agent/%d", uid); - - r = connect(fd, (struct sockaddr *)&sa, sizeof(sa)); - if (r == -1) { - ERR("failed to connect socket(%s): %d", sa.sun_path, errno); - close(fd); - return -1; - } - - r = send(fd, data, len, MSG_NOSIGNAL); - if (r < 0) { - ERR("failed to send data: %d", errno); - close(fd); - return -1; - } - - close(fd); - - return 0; -} - -static int __send_signal_for_event_for_uid(pkgmgr_installer *pi, uid_t uid, - const char *pkg_type, const char *pkgid, const char *appid, - const char *key, const char *val) -{ - char *sid; - const char *signal_name; - const char *tmp_appid = appid; - size_t name_size; - GVariantBuilder *builder; - GVariant *gv; - gsize gv_len; - gpointer gv_data; - void *data; - void *ptr; - size_t data_len; - - if (!pi || pi->conn == NULL) - return -1; - - sid = pi->session_id; - if (!sid) - sid = ""; - - data_len = sizeof(size_t) + sizeof(gsize); - - signal_name = __get_signal_name(pi, key, pkg_type); - if (!signal_name) { - ERR("unknown signal name"); - return -1; - } - - /* including null byte */ - name_size = strlen(signal_name) + 1; - data_len += name_size; - - builder = g_variant_builder_new(G_VARIANT_TYPE("a(sss)")); - g_variant_builder_add(builder, "(sss)", pkgid, - (tmp_appid ? tmp_appid : ""), pkg_type); - gv = g_variant_new("(usa(sss)ss)", pi->target_uid, sid, - builder, key, val); - g_variant_builder_unref(builder); - if (gv == NULL) { - ERR("failed to create GVariant instance"); - return -1; - } - gv_len = g_variant_get_size(gv); - gv_data = g_malloc(gv_len); - g_variant_store(gv, gv_data); - g_variant_unref(gv); - data_len += gv_len; - - data = malloc(data_len); - if (data == NULL) { - ERR("out of memory"); - g_free(gv_data); - return -1; - } - ptr = data; - memcpy(ptr, &name_size, sizeof(size_t)); - ptr += sizeof(size_t); - memcpy(ptr, &gv_len, sizeof(gsize)); - ptr += sizeof(gsize); - memcpy(ptr, signal_name, name_size); - ptr += name_size; - memcpy(ptr, gv_data, gv_len); - g_free(gv_data); - - if (__send_signal_to_agent(uid, data, data_len)) { - ERR("failed to send signal to agent"); - free(data); - return -1; - } - - free(data); - - return 0; -} - -static void __free_pkg_list(gpointer data) -{ - pkg_signal_info *info = (pkg_signal_info *)data; - free(info->pkgid); - free(info->pkg_type); - free(info); -} - -API pkgmgr_installer *pkgmgr_installer_new(void) -{ - pkgmgr_installer *pi; - GError *err = NULL; - - pi = calloc(1, sizeof(struct pkgmgr_installer)); - if (pi == NULL) - return NULL; - - pi->conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err); - if (pi->conn == NULL) { - ERR("failed to get bus: %s", err->message); - g_error_free(err); - free(pi); - return NULL; - } - - pi->tep_path = NULL; - pi->tep_move = 0; - pi->request_type = PKGMGR_REQ_INVALID; - pi->pkg_list = g_hash_table_new_full( - g_str_hash, g_str_equal, NULL, __free_pkg_list); - return pi; -} - -API pkgmgr_installer *pkgmgr_installer_offline_new(void) -{ - pkgmgr_installer *pi; - - pi = calloc(1, sizeof(struct pkgmgr_installer)); - if (pi == NULL) - return NULL; - - pi->tep_path = NULL; - pi->tep_move = 0; - pi->request_type = PKGMGR_REQ_INVALID; - - return pi; -} - -API int pkgmgr_installer_free(pkgmgr_installer *pi) -{ - CHK_PI_RET(-EINVAL); - - /* free members */ - if (pi->pkgmgr_info) - free(pi->pkgmgr_info); - if (pi->session_id) - free(pi->session_id); - if (pi->optional_data) - free(pi->optional_data); - if (pi->caller_pkgid) - free(pi->caller_pkgid); - if (pi->tep_path) - free(pi->tep_path); - - if (pi->conn) { - g_dbus_connection_flush_sync(pi->conn, NULL, NULL); - g_object_unref(pi->conn); - } - - if (pi->pkgs) - g_list_free_full(pi->pkgs, free); - - if (pi->pkg_list) - g_hash_table_destroy(pi->pkg_list); - - free(pi); - - return 0; -} - -static void __parse_multiple_pkgs(pkgmgr_installer *pi, int argc, char **argv) -{ - while ((optind <= argc) && (*argv[optind - 1] != '-')) { - pi->pkgs = g_list_append(pi->pkgs, strdup(argv[optind - 1])); - optind++; - } - optind--; -} - -API int -pkgmgr_installer_receive_request(pkgmgr_installer *pi, - const int argc, char **argv) -{ - CHK_PI_RET(-EINVAL); - - int r = 0; - - /* Parse argv */ - optind = 1; /* Initialize optind to clear prev. index */ - int opt_idx = 0; - int c; - int mode = 0; - - pi->target_uid = getuid(); - g_target_uid = pi->target_uid; - g_debug_mode = 0; - g_skip_optimization = 0; - - if (pi->pkgs) { - g_list_free_full(pi->pkgs, free); - pi->pkgs = NULL; - } - - while (1) { - c = getopt_long(argc, argv, short_opts, long_opts, &opt_idx); - /* printf("c=%d %c\n", c, c); //debug */ - if (-1 == c) - break; /* Parse is end */ - switch (c) { - case OPTVAL_PRELOAD: /* request for preload app */ - pi->is_preload = 1; - DBG("preload request [%d]", pi->is_preload); - break; - case OPTVAL_FORCE_REMOVAL: /* request for force-remove */ - pi->force_removal = 1; - DBG("force-remove request [%d]", pi->force_removal); - break; - case OPTVAL_PRELOAD_RW: /* request for preload-rw app */ - pi->is_preload_rw = 1; - DBG("preload-rw request [%d]", pi->is_preload_rw); - break; - case OPTVAL_NO_REMOVAL: /* request for no-remove */ - pi->no_removal = 1; - DBG("no-remove request [%d]", pi->no_removal); - break; - case OPTVAL_KEEP_RWDATA: /* request for keep-rwdata */ - pi->keep_rwdata = 1; - DBG("keep-rwdata request [%d]", pi->keep_rwdata); - break; - case OPTVAL_PARTIAL_RW: /* request for partial-rw */ - pi->partial_rw = 1; - DBG("partial-rw request [%d]", pi->partial_rw); - break; - case OPTVAL_MIGRATE_EXTIMG: - /* request for legacy extimg migration */ - if (mode) { - r = -EINVAL; - goto RET; - } - mode = OPTVAL_MIGRATE_EXTIMG; - pi->request_type = PKGMGR_REQ_MIGRATE_EXTIMG; - if (pi->pkgmgr_info) - free(pi->pkgmgr_info); - pi->pkgmgr_info = strndup(optarg, MAX_STRLEN); - __parse_multiple_pkgs(pi, argc, argv); - DBG("legacy extimg migration requested"); - break; - case OPTVAL_SKIP_CHECK_REFERENCE: - pi->skip_check_reference = 1; - break; - case OPTVAL_RECOVER_DB: - pi->request_type = PKGMGR_REQ_RECOVER_DB; - pi->pkgmgr_info = strndup(optarg, MAX_STRLEN); - __parse_multiple_pkgs(pi, argc, argv); - break; - case OPTVAL_RECOVERY_CLEANUP: - pi->recovery_cleanup = 1; - break; - case 'k': /* session id */ - if (pi->session_id) - free(pi->session_id); - pi->session_id = strndup(optarg, MAX_STRLEN); - break; - - case 'l': /* license path */ - if (pi->license_path) - free(pi->license_path); - pi->license_path = strndup(optarg, MAX_STRLEN); - break; - - case 'i': /* install */ - if (mode) { - r = -EINVAL; - goto RET; - } - mode = 'i'; - pi->request_type = PKGMGR_REQ_INSTALL; - if (pi->pkgmgr_info) - free(pi->pkgmgr_info); - pi->pkgmgr_info = strndup(optarg, MAX_STRLEN); - __parse_multiple_pkgs(pi, argc, argv); - DBG("option is [i] pkgid[%s]", pi->pkgmgr_info); - if (pi->pkgmgr_info && strlen(pi->pkgmgr_info) == 0) { - free(pi->pkgmgr_info); - pi->pkgmgr_info = NULL; - } else { - mode = 'i'; - } - break; - - case 'e': /* install */ - if (pi->tep_path) - free(pi->tep_path); - pi->tep_path = strndup(optarg, MAX_STRLEN); - pi->is_tep_included = 1; - DBG("option is [e] tep_path[%s]", pi->tep_path); - break; - - case 'M': /* install */ - if (strcmp(optarg, "tep_move") == 0) - pi->tep_move = 1; - else - pi->tep_move = 0; - DBG("option is [M] tep_move[%d]", pi->tep_move); - break; - - case 'd': /* uninstall */ - if (mode) { - r = -EINVAL; - goto RET; - } - mode = 'd'; - pi->request_type = PKGMGR_REQ_UNINSTALL; - if (pi->pkgmgr_info) - free(pi->pkgmgr_info); - pi->pkgmgr_info = strndup(optarg, MAX_STRLEN); - __parse_multiple_pkgs(pi, argc, argv); - break; - - - case 'c': /* clear */ - if (mode) { - r = -EINVAL; - goto RET; - } - mode = 'c'; - pi->request_type = PKGMGR_REQ_CLEAR; - if (pi->pkgmgr_info) - free(pi->pkgmgr_info); - pi->pkgmgr_info = strndup(optarg, MAX_STRLEN); - __parse_multiple_pkgs(pi, argc, argv); - break; - - case 'm': /* move */ - if (mode) { - r = -EINVAL; - goto RET; - } - mode = 'm'; - pi->request_type = PKGMGR_REQ_MOVE; - if (pi->pkgmgr_info) - free(pi->pkgmgr_info); - pi->pkgmgr_info = strndup(optarg, MAX_STRLEN); - __parse_multiple_pkgs(pi, argc, argv); - break; - - case 'r': /* reinstall */ - if (mode) { - r = -EINVAL; - goto RET; - } - mode = 'r'; - pi->request_type = PKGMGR_REQ_REINSTALL; - if (pi->pkgmgr_info) - free(pi->pkgmgr_info); - pi->pkgmgr_info = strndup(optarg, MAX_STRLEN); - __parse_multiple_pkgs(pi, argc, argv); - break; - - case 't': /* move type*/ - pi->move_type = atoi(optarg); - break; - - case 'p': /* caller pkgid*/ - if (pi->caller_pkgid) - free(pi->caller_pkgid); - pi->caller_pkgid = strndup(optarg, MAX_STRLEN); - - break; - - case 's': /* smack */ - if (mode) { - r = -EINVAL; - goto RET; - } - mode = 's'; - pi->request_type = PKGMGR_REQ_SMACK; - if (pi->pkgmgr_info) - free(pi->pkgmgr_info); - pi->pkgmgr_info = strndup(optarg, MAX_STRLEN); - __parse_multiple_pkgs(pi, argc, argv); - break; - - case 'o': /* optional data*/ - pi->optional_data = strndup(optarg, MAX_STRLEN); - break; - - case 'y': /* pkgid for direct manifest installation */ - mode = 'y'; - pi->request_type = PKGMGR_REQ_MANIFEST_DIRECT_INSTALL; - pi->pkgmgr_info = strndup(optarg, MAX_STRLEN); - __parse_multiple_pkgs(pi, argc, argv); - break; - - case 'w': /* pkgid for mount installation */ - mode = 'w'; - pi->request_type = PKGMGR_REQ_MOUNT_INSTALL; - pi->pkgmgr_info = strndup(optarg, MAX_STRLEN); - __parse_multiple_pkgs(pi, argc, argv); - break; - - case 'b': /* recovery */ - if (mode) { - r = -EINVAL; - goto RET; - } - mode = 'b'; - pi->request_type = PKGMGR_REQ_RECOVER; - if (pi->pkgmgr_info) - free(pi->pkgmgr_info); - pi->pkgmgr_info = strndup(optarg, MAX_STRLEN); - __parse_multiple_pkgs(pi, argc, argv); - break; - - case 'D': /* disable pkg */ - pi->request_type = PKGMGR_REQ_DISABLE_PKG; - if (pi->pkgmgr_info) - free(pi->pkgmgr_info); - pi->pkgmgr_info = strndup(optarg, MAX_STRLEN); - __parse_multiple_pkgs(pi, argc, argv); - break; - - case 'A': /* enable pkg */ - pi->request_type = PKGMGR_REQ_ENABLE_PKG; - if (pi->pkgmgr_info) - free(pi->pkgmgr_info); - pi->pkgmgr_info = strndup(optarg, MAX_STRLEN); - __parse_multiple_pkgs(pi, argc, argv); - break; - - case 'u': /* uid */ - g_target_uid = (uid_t)atoi(optarg); - pi->target_uid = (uid_t)atoi(optarg); - break; - - case 'G': /* debug mode */ - pi->debug_mode = 1; - g_debug_mode = 1; - break; - - case 'S': /* skip optimization */ - pi->skip_optimization = 1; - g_skip_optimization = 1; - break; - - /* Otherwise */ - case '?': /* Not an option */ - break; - - case ':': /* */ - break; - - } - } - - /* if target user is not set, set as tizenglobalapp user */ - if (pi->target_uid == 0) { - pi->target_uid = tzplatform_getuid(TZ_SYS_GLOBALAPP_USER); - g_target_uid = pi->target_uid; - } - RET: - return r; -} - -API int pkgmgr_installer_get_request_type(pkgmgr_installer *pi) -{ - CHK_PI_RET(PKGMGR_REQ_INVALID); - return pi->request_type; -} - -API uid_t pkgmgr_installer_get_uid(pkgmgr_installer *pi) -{ - CHK_PI_RET(PKGMGR_REQ_INVALID); - return pi->target_uid; -} - -API const char *pkgmgr_installer_get_request_info(pkgmgr_installer *pi) -{ - CHK_PI_RET(PKGMGR_REQ_INVALID); - return pi->pkgmgr_info; -} - -API const char *pkgmgr_installer_get_request_info_at(pkgmgr_installer *pi, - int at) -{ - CHK_PI_RET(PKGMGR_REQ_INVALID); - return (const char *)g_list_nth_data(pi->pkgs, at); -} - -API int pkgmgr_installer_get_request_info_count(pkgmgr_installer *pi) -{ - CHK_PI_RET(PKGMGR_REQ_INVALID); - return g_list_length(pi->pkgs); -} - -API const char *pkgmgr_installer_get_tep_path(pkgmgr_installer *pi) -{ - CHK_PI_RET(PKGMGR_REQ_INVALID); - return pi->tep_path; -} - -API int pkgmgr_installer_get_tep_move_type(pkgmgr_installer *pi) -{ - CHK_PI_RET(PKGMGR_REQ_INVALID); - return pi->tep_move; -} - -API const char *pkgmgr_installer_get_session_id(pkgmgr_installer *pi) -{ - CHK_PI_RET(PKGMGR_REQ_INVALID); - return pi->session_id; -} - -API const char *pkgmgr_installer_get_license_path(pkgmgr_installer *pi) -{ - CHK_PI_RET(PKGMGR_REQ_INVALID); - return pi->license_path; -} - -API const char *pkgmgr_installer_get_optional_data(pkgmgr_installer *pi) -{ - CHK_PI_RET(PKGMGR_REQ_INVALID); - return pi->optional_data; -} - -API int pkgmgr_installer_is_quiet(pkgmgr_installer *pi) -{ - return 1; -} - -API int pkgmgr_installer_get_move_type(pkgmgr_installer *pi) -{ - CHK_PI_RET(PKGMGR_REQ_INVALID); - return pi->move_type; -} - -API const char *pkgmgr_installer_get_caller_pkgid(pkgmgr_installer *pi) -{ - CHK_PI_RET(PKGMGR_REQ_INVALID); - return pi->caller_pkgid; -} - -API int pkgmgr_installer_get_is_preload(pkgmgr_installer *pi) -{ - CHK_PI_RET(PKGMGR_REQ_INVALID); - return pi->is_preload; -} - -API int pkgmgr_installer_get_force_removal(pkgmgr_installer *pi) -{ - CHK_PI_RET(PKGMGR_REQ_INVALID); - return pi->force_removal; -} - -API int pkgmgr_installer_get_is_preload_rw(pkgmgr_installer *pi) -{ - CHK_PI_RET(PKGMGR_REQ_INVALID); - return pi->is_preload_rw; -} - -API int pkgmgr_installer_get_no_removal(pkgmgr_installer *pi) -{ - CHK_PI_RET(PKGMGR_REQ_INVALID); - return pi->no_removal; -} - -API int pkgmgr_installer_get_keep_rwdata(pkgmgr_installer *pi) -{ - CHK_PI_RET(PKGMGR_REQ_INVALID); - return pi->keep_rwdata; -} - -API int pkgmgr_installer_get_partial_rw(pkgmgr_installer *pi) -{ - CHK_PI_RET(PKGMGR_REQ_INVALID); - return pi->partial_rw; -} - -API int pkgmgr_installer_get_debug_mode(pkgmgr_installer *pi) -{ - CHK_PI_RET(PKGMGR_REQ_INVALID); - return pi->debug_mode; -} - -API int pkgmgr_installer_get_skip_check_reference(pkgmgr_installer *pi) -{ - CHK_PI_RET(PKGMGR_REQ_INVALID); - return pi->skip_check_reference; -} - -API int pkgmgr_installer_get_skip_optimization(pkgmgr_installer *pi) -{ - CHK_PI_RET(PKGMGR_REQ_INVALID); - return pi->skip_optimization; -} - -API int pkgmgr_installer_get_recovery_cleanup(pkgmgr_installer *pi) -{ - CHK_PI_RET(PKGMGR_REQ_INVALID); - return pi->recovery_cleanup; -} - -API int pkgmgr_installer_send_app_uninstall_signal(pkgmgr_installer *pi, - const char *pkg_type, - const char *pkgid, - const char *val) -{ - int ret = 0; - ret = __send_signal_for_event(pi, pkg_type, pkgid, NULL, - PKGMGR_INSTALLER_APPID_KEY_STR, val); - return ret; -} - -API int pkgmgr_installer_send_app_uninstall_signal_for_uid( - pkgmgr_installer *pi, uid_t uid, const char *pkg_type, - const char *pkgid, const char *val) -{ - int ret = 0; - ret = __send_signal_for_event_for_uid(pi, uid, pkg_type, pkgid, NULL, - PKGMGR_INSTALLER_APPID_KEY_STR, val); - return ret; -} - -API int pkgmgr_installer_set_uid(pkgmgr_installer *pi, uid_t uid) -{ - if (pi == NULL) - return -1; - - pi->target_uid = uid; - g_target_uid = pi->target_uid; - - return 0; -} - -API int -pkgmgr_installer_send_app_signal(pkgmgr_installer *pi, - const char *pkg_type, - const char *pkgid, - const char *appid, - const char *key, const char *val) -{ - int r = 0; - - if (!pi->conn) { - ERR("connection is NULL"); - return -1; - } - - r = __send_signal_for_event(pi, pkg_type, pkgid, appid, key, val); - - return r; -} - -API int -pkgmgr_installer_send_signal(pkgmgr_installer *pi, - const char *pkg_type, - const char *pkgid, - const char *key, const char *val) -{ - int r = 0; - - if (!pi->conn) { - ERR("connection is NULL"); - return -1; - } - - r = __send_signal_for_event(pi, pkg_type, pkgid, NULL, key, val); - - return r; -} - -API int pkgmgr_installer_send_app_signal_for_uid(pkgmgr_installer *pi, - uid_t uid, const char *pkg_type, const char *pkgid, - const char *appid, const char *key, const char *val) -{ - int r = 0; - - if (!pi->conn) { - ERR("connection is NULL"); - return -1; - } - - r = __send_signal_for_event_for_uid(pi, uid, pkg_type, pkgid, appid, - key, val); - - return r; -} - -API int pkgmgr_installer_send_signal_for_uid(pkgmgr_installer *pi, - uid_t uid, const char *pkg_type, const char *pkgid, - const char *key, const char *val) -{ - int r = 0; - - if (!pi->conn) { - ERR("connection is NULL"); - return -1; - } - - r = __send_signal_for_event_for_uid(pi, uid, pkg_type, pkgid, NULL, - key, val); - - return r; -} - -API int pkgmgr_installer_set_request_type(pkgmgr_installer *pi, int request_type) -{ - if (pi == NULL) - return -1; - - pi->request_type = request_type; - return 0; -} - -API int pkgmgr_installer_set_session_id(pkgmgr_installer *pi, const char *session_id) -{ - if (pi == NULL || session_id == NULL) - return -1; - - pi->session_id = strndup(session_id, MAX_STRLEN); - return 0; -} - -API int pkgmgr_installer_create_certinfo_set_handle(pkgmgr_instcertinfo_h *handle) -{ - int ret = 0; - ret = pkgmgrinfo_create_certinfo_set_handle(handle); - return ret; -} - -API int pkgmgr_installer_set_cert_value(pkgmgr_instcertinfo_h handle, pkgmgr_instcert_type cert_type, char *cert_value) -{ - int ret = 0; - ret = pkgmgrinfo_set_cert_value(handle, cert_type, cert_value); - return ret; -} - -API int pkgmgr_installer_save_certinfo(const char *pkgid, pkgmgr_instcertinfo_h handle, uid_t uid) -{ - int ret = 0; - ret = pkgmgrinfo_save_certinfo(pkgid, handle, uid); - return ret; -} - -API int pkgmgr_installer_destroy_certinfo_set_handle(pkgmgr_instcertinfo_h handle) -{ - int ret = 0; - ret = pkgmgrinfo_destroy_certinfo_set_handle(handle); - return ret; -} - -API int pkgmgr_installer_delete_certinfo(const char *pkgid) -{ - int ret = 0; - ret = pkgmgrinfo_delete_certinfo(pkgid); - return ret; -} - -API int pkgmgr_installer_set_privilege_level(pkgmgr_privilege_level level) -{ - g_privilege_level = level; - - return 0; -} - -API int pkgmgr_installer_info_get_target_uid(uid_t *uid) -{ - *uid = g_target_uid; - - return 0; -} - -API int pkgmgr_installer_info_get_privilege_level(pkgmgr_privilege_level *level) -{ - *level = g_privilege_level; - - return 0; -} - -API int pkgmgr_installer_info_get_debug_mode(int *debug_mode) -{ - *debug_mode = g_debug_mode; - return 0; -} - -API int pkgmgr_installer_info_get_skip_optimization(int *skip_optimization) -{ - *skip_optimization = g_skip_optimization; - return 0; -} - -#define CASE_TO_STR(ERRCODE) case ERRCODE: return ERRCODE##_STR -API const char *pkgmgr_installer_error_to_string(int error_code) -{ - switch (error_code) { - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_UNDEFINED_ERROR); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_GLOBALSYMLINK_ERROR); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_GRANT_PERMISSION_ERROR); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_IMAGE_ERROR); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_UNZIP_ERROR); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_SECURITY_ERROR); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_REGISTER_ERROR); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_PRIVILEGE_ERROR); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_PARSE_ERROR); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_RECOVERY_ERROR); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_DELTA_ERROR); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_APP_DIR_ERROR); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_CONFIG_ERROR); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_SIGNATURE_ERROR); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_SIGNATURE_INVALID); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_CERT_ERROR); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_AUTHOR_CERT_NOT_MATCH); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_AUTHOR_CERT_NOT_FOUND); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_ICON_ERROR); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_ICON_NOT_FOUND); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_MANIFEST_ERROR); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_MANIFEST_NOT_FOUND); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_PACKAGE_NOT_FOUND); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_OPERATION_NOT_ALLOWED); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_OUT_OF_SPACE); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_INVALID_VALUE); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_ERROR); - CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_OK); - default: - return PKGMGR_INSTALLER_ERRCODE_UNDEFINED_ERROR_STR; - } -} - -API int pkgmgr_installer_add_pkg(pkgmgr_installer *pi, - const char *pkgid, const char *pkg_type) -{ - pkg_signal_info *info; - if (!pi || !pkgid || !pkg_type) { - ERR("invalid argument"); - return -1; - } - - info = calloc(1, sizeof(pkg_signal_info)); - if (!info) { - ERR("out of memory"); - return -1; - } - - info->pkgid = strdup(pkgid); - info->pkg_type = strdup(pkg_type); - if (!info->pkgid || !info->pkg_type) { - ERR("out of memory"); - free(info->pkgid); - free(info->pkg_type); - free(info); - return -1; - } - g_hash_table_insert(pi->pkg_list, (gpointer)info->pkgid, (gpointer)info); - - return 0; -} - -static void __build_multi_signal(gpointer key, gpointer value, - gpointer user_data) -{ - GVariantBuilder *builder = (GVariantBuilder *)user_data; - pkg_signal_info *info = (pkg_signal_info *)value; - - g_variant_builder_add(builder, "(sss)", info->pkgid, "", info->pkg_type); -} - -API int pkgmgr_installer_send_signals(pkgmgr_installer *pi, - const char *key, const char *val) -{ - char *sid; - const char *signal_name; - GError *err = NULL; - GVariantBuilder *builder; - - if (!pi || !key || !val) { - ERR("invalid argument"); - return -1; - } - - sid = pi->session_id; - if (!sid) - sid = ""; - - signal_name = __get_signal_name(pi, key, ""); - if (!signal_name) { - ERR("unknown signal type"); - return -1; - } - - builder = g_variant_builder_new(G_VARIANT_TYPE("a(sss)")); - g_hash_table_foreach(pi->pkg_list, __build_multi_signal, builder); - if (g_dbus_connection_emit_signal(pi->conn, NULL, - PKGMGR_INSTALLER_DBUS_OBJECT_PATH, - PKGMGR_INSTALLER_DBUS_INTERFACE, signal_name, - g_variant_new("(usa(sss)ss)", - pi->target_uid, sid, builder, key, - val), &err) != TRUE) { - ERR("failed to send dbus signal"); - if (err) { - ERR("err: %s", err->message); - g_error_free(err); - } - g_variant_builder_unref(builder); - return -1; - } - g_variant_builder_unref(builder); - - return 0; -} - -API int pkgmgr_installer_send_signals_for_uid(pkgmgr_installer *pi, uid_t uid, - const char *key, const char *val) -{ - char *sid; - size_t data_len; - size_t name_size; - GVariant *gv; - GVariantBuilder *builder; - gsize gv_len; - gpointer gv_data; - void *data; - void *ptr; - const char *signal_name; - - if (!pi || !pi->conn) { - ERR("connection is NULL"); - return -1; - } - - sid = pi->session_id; - if (!sid) - sid = ""; - - data_len = sizeof(size_t) + sizeof(gsize); - - /* including null byte */ - signal_name = __get_signal_name(pi, key, ""); - if (!signal_name) { - ERR("unknown signal type"); - return -1; - } - name_size = strlen(signal_name) + 1; - data_len += name_size; - - builder = g_variant_builder_new(G_VARIANT_TYPE("a(sss)")); - g_hash_table_foreach(pi->pkg_list, __build_multi_signal, builder); - - gv = g_variant_new("(usa(sss)ss)", uid, sid, builder, key, val); - g_variant_builder_unref(builder); - if (gv == NULL) { - ERR("failed to create GVariant instance"); - return -1; - } - - gv_len = g_variant_get_size(gv); - gv_data = g_malloc(gv_len); - g_variant_store(gv, gv_data); - g_variant_unref(gv); - data_len += gv_len; - - data = malloc(data_len); - if (data == NULL) { - ERR("out of memory"); - g_free(gv_data); - return -1; - } - ptr = data; - memcpy(ptr, &name_size, sizeof(size_t)); - ptr += sizeof(size_t); - memcpy(ptr, &gv_len, sizeof(gsize)); - ptr += sizeof(gsize); - memcpy(ptr, signal_name, name_size); - ptr += name_size; - memcpy(ptr, gv_data, gv_len); - g_free(gv_data); - - if (__send_signal_to_agent(uid, data, data_len)) { - ERR("failed to send signal to agent"); - free(data); - return -1; - } - - free(data); - - return 0; -} - -API int pkgmgr_installer_set_is_upgrade(pkgmgr_installer *pi, int is_upgrade) { - if (pi == NULL) - return -1; - - pi->is_upgrade = is_upgrade; - return 0; -} - -static GVariant *__get_gvariant_from_event_info(pkgmgr_res_event_info *event_info) -{ - pkgmgr_res_event_info_t *info = event_info; - GVariantBuilder *builder; - GVariant *result; - GList *path_states; - res_event_path_state_t *path_state; - - builder = g_variant_builder_new(G_VARIANT_TYPE("a(si)")); - if (builder == NULL) { - ERR("out of memory"); - return NULL; - } - - for (path_states = info->path_states; path_states != NULL; - path_states = path_states->next) { - path_state = (res_event_path_state_t *)path_states->data; - g_variant_builder_add(builder, "(si)", - path_state->path, path_state->state); - } - - result = g_variant_new("(ia(si))", info->error_code, builder); - g_variant_builder_unref(builder); - - if (result == NULL) { - ERR("Fail to create extra data"); - return NULL; - } - - return result; -} - -API int pkgmgr_installer_send_res_signal(pkgmgr_installer *pi, - const char *pkgid, const char *status, - pkgmgr_res_event_info *event_info) -{ - char *sid; - const char *signal_name; - GError *err = NULL; - GVariant *extra_param; - - if (!pi || !pkgid || !status) { - ERR("invalid argument"); - return -1; - } - - sid = pi->session_id; - if (!sid) - sid = ""; - - signal_name = __get_signal_name(pi, "", ""); - if (!signal_name) { - ERR("unknown signal type"); - return -1; - } - - extra_param = __get_gvariant_from_event_info(event_info); - if (extra_param == NULL) { - ERR("Fail to get extra parameter"); - return -1; - } - - if (g_dbus_connection_emit_signal(pi->conn, NULL, - PKGMGR_INSTALLER_DBUS_OBJECT_PATH, - PKGMGR_INSTALLER_DBUS_INTERFACE, signal_name, - g_variant_new("(usssv)", pi->target_uid, sid, - pkgid, status, extra_param), - &err) != TRUE) { - ERR("failed to send dbus signal"); - if (err) { - ERR("err: %s", err->message); - g_error_free(err); - } - return -1; - } - - return 0; -} - -API int pkgmgr_installer_send_res_signal_for_uid(pkgmgr_installer *pi, - uid_t uid, const char *pkgid, const char *status, - pkgmgr_res_event_info *event_info) -{ - char *sid; - size_t data_len; - size_t name_size; - GVariant *gv; - gsize gv_len; - gpointer gv_data; - void *data; - void *ptr; - const char *signal_name; - GVariant *extra_param; - - if (!pi || !pi->conn) { - ERR("connection is NULL"); - return -1; - } - - sid = pi->session_id; - if (!sid) - sid = ""; - - data_len = sizeof(size_t) + sizeof(gsize); - - /* including null byte */ - signal_name = __get_signal_name(pi, "", ""); - if (!signal_name) { - ERR("unknown signal type"); - return -1; - } - name_size = strlen(signal_name) + 1; - data_len += name_size; - - extra_param = __get_gvariant_from_event_info(event_info); - if (extra_param == NULL) { - ERR("Fail to get extra parameter"); - return -1; - } - - gv = g_variant_new("(usssv)", pi->target_uid, sid, - pkgid, status, extra_param); - if (gv == NULL) { - ERR("failed to create GVariant instance"); - return -1; - } - - gv_len = g_variant_get_size(gv); - gv_data = g_malloc(gv_len); - g_variant_store(gv, gv_data); - g_variant_unref(gv); - data_len += gv_len; - - data = malloc(data_len); - if (data == NULL) { - ERR("out of memory"); - g_free(gv_data); - return -1; - } - ptr = data; - memcpy(ptr, &name_size, sizeof(size_t)); - ptr += sizeof(size_t); - memcpy(ptr, &gv_len, sizeof(gsize)); - ptr += sizeof(gsize); - memcpy(ptr, signal_name, name_size); - ptr += name_size; - memcpy(ptr, gv_data, gv_len); - g_free(gv_data); - - if (__send_signal_to_agent(uid, data, data_len)) { - ERR("failed to send signal to agent"); - free(data); - return -1; - } - - free(data); - - return 0; -} - -API int pkgmgr_installer_send_pkg_upgrade_signal(pkgmgr_installer *pi, - unsigned int progress) -{ - const char *signal_name; - GError *err = NULL; - - if (!pi) { - ERR("invalid argument"); - return -1; - } - - signal_name = PKGMGR_INSTALLER_PKG_UPGRADE_EVENT_STR; - if (g_dbus_connection_emit_signal(pi->conn, NULL, - PKGMGR_INSTALLER_DBUS_OBJECT_PATH, - PKGMGR_INSTALLER_DBUS_INTERFACE, signal_name, - g_variant_new("(u)", progress), - &err) != TRUE) { - ERR("failed to send dbus signal"); - if (err) { - ERR("err: %s", err->message); - g_error_free(err); - } - return -1; - } - - return 0; -} diff --git a/installer/pkgmgr_installer_signal_agent.c b/installer/pkgmgr_installer_signal_agent.c deleted file mode 100644 index 19c5b44..0000000 --- a/installer/pkgmgr_installer_signal_agent.c +++ /dev/null @@ -1,337 +0,0 @@ -/* - * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved. - * - * 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. - * - */ - -#define _GNU_SOURCE - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include - -#include - -#include "pkgmgr_installer_config.h" -#include "pkgmgr_installer_type.h" - -#ifdef LOG_TAG -#undef LOG_TAG -#endif -#define LOG_TAG "PKGMGR_INSTALLER_SIGNAL_AGENT" - -#define BUFMAX 4096 -#define PWBUFSIZE sysconf(_SC_GETPW_R_SIZE_MAX) -#define APPFW_USERNAME "app_fw" - -static int server_fd = -1; -static GMainLoop *loop; -static guint sid; -static guint tid; -static GDBusConnection *conn; - -static int __create_server_socket(const char *path) -{ - int r; - int fd; - struct sockaddr_un sa; - - fd = socket(AF_UNIX, SOCK_STREAM, 0); - if (fd == -1) { - LOGE("socket create failed: %d", errno); - return -1; - } - - memset(&sa, 0, sizeof(sa)); - sa.sun_family = AF_UNIX; - snprintf(sa.sun_path, sizeof(sa.sun_path), "%s", path); - - r = unlink(sa.sun_path); - if (r == -1 && errno != ENOENT) { - LOGE("unlink(%s) failed: %d", sa.sun_path, errno); - close(fd); - return -1; - } - - r = bind(fd, (struct sockaddr *)&sa, sizeof(sa)); - if (r == -1) { - LOGE("bind(%s) failed: %d", sa.sun_path, errno); - close(fd); - return -1; - } - - r = chmod(sa.sun_path, 0660); - if (r == -1) - LOGW("chmod(%s) failed: %d", sa.sun_path, errno); - - r = listen(fd, SOMAXCONN); - if (r == -1) { - LOGE("listen(%s) failed: %d", sa.sun_path, errno); - close(fd); - return -1; - } - - return fd; -} - -static int __get_server_socket(const char *path) -{ - int i; - int n; - int r; - int fd = -1; - - n = sd_listen_fds(0); - if (n < 0) { - LOGE("sd_listen_fds: %d", n); - return -1; - } else if (n == 0) { - return __create_server_socket(path); - } - - for (i = SD_LISTEN_FDS_START; i < SD_LISTEN_FDS_START + n; i++) { - r = sd_is_socket_unix(i, SOCK_STREAM, -1, path, 0); - if (r > 0) { - fd = i; - break; - } - } - - if (fd == -1) { - LOGE("socket is not passed, create server socket"); - return __create_server_socket(path); - } - - return fd; -} - -static void __emit_signal(const char *name, GVariant *gv) -{ - GError *err = NULL; - - if (g_dbus_connection_emit_signal(conn, NULL, - PKGMGR_INSTALLER_DBUS_OBJECT_PATH, - PKGMGR_INSTALLER_DBUS_INTERFACE, - name, gv, &err) != TRUE) { - LOGE("g_dbus_connection_emit_signal failed: %s", err->message); - g_error_free(err); - } -} - -static gboolean __quit(gpointer user_data) -{ - g_main_loop_quit(loop); - return FALSE; -} - -static int __check_authority(int fd) -{ - int r; - struct ucred cr; - socklen_t len; - struct passwd pwd; - struct passwd *pwd_r; - char buf[PWBUFSIZE]; - - len = sizeof(struct ucred); - r = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &cr, &len); - if (r != 0) { - LOGE("getsockopt failed: %d", errno); - return -1; - } - - /* allow root user */ - if (cr.uid == 0) - return 0; - - r = getpwuid_r(cr.uid, &pwd, buf, sizeof(buf), &pwd_r); - if (r != 0 || pwd_r == NULL) { - LOGE("getpwuid failed: %d", r); - return -1; - } - - /* only app_fw user can send signal to agent */ - if (strcmp(pwd_r->pw_name, APPFW_USERNAME) != 0) { - LOGE("unauthorized client"); - return -1; - } - - return 0; -} - -/** - * packet format: - * +----------------+-------------+-----------+-------------------+ - * |signal name size|GVariant size|signal name|serialized GVariant| - * +----------------+-------------+-----------+-------------------+ - */ -static gboolean __handle_signal(gint fd, GIOCondition cond, gpointer user_data) -{ - int r; - unsigned char buf[BUFMAX]; - int clifd; - struct sockaddr_un sa; - socklen_t s = sizeof(sa); - size_t type_len; - char *type_name; - gsize data_len; - gpointer data; - GVariant *gv; - - clifd = accept(fd, (struct sockaddr *)&sa, &s); - if (clifd == -1) { - LOGE("accept failed: %d", errno); - return FALSE; - } - - if (__check_authority(clifd)) { - close(clifd); - return TRUE; - } - - r = recv(clifd, buf, sizeof(size_t) + sizeof(gsize), 0); - if (r < 0) { - LOGE("recv failed: %d", errno); - close(clifd); - return FALSE; - } else if (r == 0) { - LOGE("client fd already closed"); - close(clifd); - return FALSE; - } - - memcpy(&type_len, buf, sizeof(size_t)); - memcpy(&data_len, buf + sizeof(size_t), sizeof(gsize)); - - if (type_len > BUFMAX || data_len > BUFMAX || - (type_len + data_len) > BUFMAX) { - LOGE("received size is too large: %zu %zu", type_len, data_len); - close(clifd); - return FALSE; - } - - r = recv(clifd, buf, type_len + data_len, 0); - if (r < 0) { - LOGE("recv failed: %d", errno); - close(clifd); - return FALSE; - } else if (r == 0) { - LOGE("client fd already closed"); - close(clifd); - return FALSE; - } - - if (type_len == 0) { - LOGE("invalid type_len"); - close(clifd); - return FALSE; - } - - /* get signal name (including terminating null byte) */ - type_name = malloc(type_len); - memcpy(type_name, buf, type_len); - - /* get data */ - data = malloc(data_len); - memcpy(data, buf + type_len, data_len); - - /* floating type GVariant instance */ - if (!strcmp(type_name, PKGMGR_INSTALLER_RES_COPY_EVENT_STR) || - !strcmp(type_name, PKGMGR_INSTALLER_RES_CREATE_DIR_EVENT_STR) || - !strcmp(type_name, PKGMGR_INSTALLER_RES_REMOVE_EVENT_STR) || - !strcmp(type_name, PKGMGR_INSTALLER_RES_UNINSTALL_EVENT_STR)) { - gv = g_variant_new_from_data(G_VARIANT_TYPE("(usssv)"), - data, data_len, TRUE, NULL, NULL); - } else { - gv = g_variant_new_from_data(G_VARIANT_TYPE("(usa(sss)ss)"), - data, data_len, TRUE, NULL, NULL); - } - __emit_signal(type_name, gv); - - free(data); - free(type_name); - close(clifd); - - /* renew timeout */ - g_source_remove(tid); - tid = g_timeout_add_seconds(10, __quit, NULL); - - return TRUE; -} - -static int __init(void) -{ - char path[PATH_MAX]; - GError *err = NULL; - - snprintf(path, sizeof(path), "/run/pkgmgr/agent/%d", getuid()); - server_fd = __get_server_socket(path); - if (server_fd < 0) { - LOGE("server init failed"); - return -1; - } - - conn = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, &err); - if (conn == NULL) { - LOGE("g_bus_get_sync failed: %s", err->message); - g_error_free(err); - close(server_fd); - return -1; - } - - loop = g_main_loop_new(NULL, FALSE); - sid = g_unix_fd_add(server_fd, G_IO_IN, __handle_signal, NULL); - tid = g_timeout_add_seconds(10, __quit, NULL); - - return 0; -} - -static void __fini(void) -{ - if (sid > 0) - g_source_remove(sid); - if (loop) - g_main_loop_unref(loop); - if (conn) - g_object_unref(conn); - if (server_fd > 0) - close(server_fd); -} - -int main(int argc, char *argv[]) -{ - int r; - - r = __init(); - if (r < 0) - return -1; - - g_main_loop_run(loop); - - __fini(); - - return 0; -} diff --git a/installer/pkgmgr_installer_signal_agent.cc b/installer/pkgmgr_installer_signal_agent.cc new file mode 100644 index 0000000..be1d656 --- /dev/null +++ b/installer/pkgmgr_installer_signal_agent.cc @@ -0,0 +1,384 @@ +/* + * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved. + * + * 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. + * + */ + +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +#include +#include + +#include "src/pkgmgr_installer_type.h" +#include "src/PkgSignal.h" + +#ifdef LOG_TAG +#undef LOG_TAG +#endif +#define LOG_TAG "PKGMGR_INSTALLER_SIGNAL_AGENT" + +#define BUFMAX 4096 +#define PWBUFSIZE sysconf(_SC_GETPW_R_SIZE_MAX) +#define APPFW_USERNAME "app_fw" +#define AGENT_APPID "signal_agent" + +namespace pkg_group = rpc_port::PkgSignal::group; +namespace pkg_signal = rpc_port::PkgSignal; + +static int server_fd = -1; +static GMainLoop* loop; +static guint sid; +static guint tid; +static std::unique_ptr signal_sender; + +static int __create_server_socket(const char* path) { + int r; + int fd; + struct sockaddr_un sa; + + fd = socket(AF_UNIX, SOCK_STREAM, 0); + if (fd == -1) { + LOGE("socket create failed: %d", errno); + return -1; + } + + memset(&sa, 0, sizeof(sa)); + sa.sun_family = AF_UNIX; + snprintf(sa.sun_path, sizeof(sa.sun_path), "%s", path); + + r = unlink(sa.sun_path); + if (r == -1 && errno != ENOENT) { + LOGE("unlink(%s) failed: %d", sa.sun_path, errno); + close(fd); + return -1; + } + + r = bind(fd, (struct sockaddr*)&sa, sizeof(sa)); + if (r == -1) { + LOGE("bind(%s) failed: %d", sa.sun_path, errno); + close(fd); + return -1; + } + + r = chmod(sa.sun_path, 0660); + if (r == -1) + LOGW("chmod(%s) failed: %d", sa.sun_path, errno); + + r = listen(fd, SOMAXCONN); + if (r == -1) { + LOGE("listen(%s) failed: %d", sa.sun_path, errno); + close(fd); + return -1; + } + + return fd; +} + +static int __get_server_socket(const char* path) { + int i; + int n; + int r; + int fd = -1; + + n = sd_listen_fds(0); + if (n < 0) { + LOGE("sd_listen_fds: %d", n); + return -1; + } else if (n == 0) { + return __create_server_socket(path); + } + + for (i = SD_LISTEN_FDS_START; i < SD_LISTEN_FDS_START + n; i++) { + r = sd_is_socket_unix(i, SOCK_STREAM, -1, path, 0); + if (r > 0) { + fd = i; + break; + } + } + + if (fd == -1) { + LOGE("socket is not passed, create server socket"); + return __create_server_socket(path); + } + + return fd; +} + +static void __emit_signal_for_res_event(const char* signal, GVariant* gv) { + uid_t target_uid; + char* req_id; + char* pkgid = NULL; + char* status = NULL; + char* path = NULL; + int state; + int signal_type; + int error_code; + GVariant* extra_param = NULL; + GVariantIter* iter; + + g_variant_get(gv, "(u&s&s&sv)", &target_uid, &req_id, &pkgid, &status, &extra_param); + if (!g_variant_type_equal(G_VARIANT_TYPE("(ia(si))"), + g_variant_get_type(extra_param))) { + LOGE("invalid extra parameter"); + g_variant_unref(extra_param); + return; + } + + std::vector path_info; + + g_variant_get(extra_param, "(ia(si))", &error_code, &iter); + while (g_variant_iter_loop(iter, "(&si)", &path, &state)) + path_info.emplace_back(path, state); + + signal_sender->AsyncResultForResource(signal, target_uid, req_id, pkgid, status, + pkg_signal::ExtraData(error_code, std::move(path_info))); + g_variant_unref(extra_param); + g_variant_iter_free(iter); +} + +static void __emit_signal_for_pkg_event(GVariant* gv) { + uid_t target_uid; + char* req_id; + char* pkg_type = NULL; + char* appid = NULL; + char* pkgid = NULL; + char* key = NULL; + char* val = NULL; + GVariantIter* iter = NULL; + int signal_type; + + g_variant_get(gv, "(u&sa(sss)&s&s)", &target_uid, &req_id, &iter, + &key, &val); + std::vector pkgs; + while (g_variant_iter_loop(iter, "(&s&s&s)", &pkgid, &appid, &pkg_type)) + pkgs.emplace_back(pkg_signal::PkgInfo(pkgid, appid, pkg_type)); + signal_sender->AsyncResult("", target_uid, req_id, std::move(pkgs), key, val); + g_variant_iter_free(iter); +} + +static gboolean __quit(gpointer user_data) { + g_main_loop_quit(loop); + return FALSE; +} + +static int __check_authority(int fd) { + int r; + struct ucred cr; + socklen_t len; + struct passwd pwd; + struct passwd* pwd_r; + char buf[PWBUFSIZE]; + + len = sizeof(struct ucred); + r = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &cr, &len); + if (r != 0) { + LOGE("getsockopt failed: %d", errno); + return -1; + } + + /* allow root user */ + if (cr.uid == 0) + return 0; + + r = getpwuid_r(cr.uid, &pwd, buf, sizeof(buf), &pwd_r); + if (r != 0 || pwd_r == NULL) { + LOGE("getpwuid failed: %d", r); + return -1; + } + + /* only app_fw user can send signal to agent */ + if (strcmp(pwd_r->pw_name, APPFW_USERNAME) != 0) { + LOGE("unauthorized client"); + return -1; + } + + return 0; +} + +/** + * packet format: + * +----------------+-------------+-----------+-------------------+ + * |signal name size|GVariant size|signal name|serialized GVariant| + * +----------------+-------------+-----------+-------------------+ + */ +static gboolean __handle_signal(gint fd, + GIOCondition cond, gpointer user_data) { + int r; + unsigned char buf[BUFMAX]; + int clifd; + struct sockaddr_un sa; + socklen_t s = sizeof(sa); + size_t type_len; + char* type_name; + gsize data_len; + gpointer data; + GVariant* gv; + + clifd = accept(fd, (struct sockaddr*)&sa, &s); + if (clifd == -1) { + LOGE("accept failed: %d", errno); + return FALSE; + } + + if (__check_authority(clifd)) { + close(clifd); + return TRUE; + } + + r = recv(clifd, buf, sizeof(size_t) + sizeof(gsize), 0); + if (r < 0) { + LOGE("recv failed: %d", errno); + close(clifd); + return FALSE; + } else if (r == 0) { + LOGE("client fd already closed"); + close(clifd); + return FALSE; + } + + memcpy(&type_len, buf, sizeof(size_t)); + memcpy(&data_len, buf + sizeof(size_t), sizeof(gsize)); + + if (type_len > BUFMAX || data_len > BUFMAX || + (type_len + data_len) > BUFMAX) { + LOGE("received size is too large: %zu %zu", type_len, data_len); + close(clifd); + return FALSE; + } + + r = recv(clifd, buf, type_len + data_len, 0); + if (r < 0) { + LOGE("recv failed: %d", errno); + close(clifd); + return FALSE; + } else if (r == 0) { + LOGE("client fd already closed"); + close(clifd); + return FALSE; + } + + if (type_len == 0) { + LOGE("invalid type_len"); + close(clifd); + return FALSE; + } + + /* get signal name (including terminating null byte) */ + type_name = static_cast(malloc(type_len)); + memcpy(type_name, buf, type_len); + + /* get data */ + data = malloc(data_len); + memcpy(data, buf + type_len, data_len); + + /* floating type GVariant instance */ + if (!strcmp(type_name, PKGMGR_INSTALLER_RES_COPY_EVENT_STR) || + !strcmp(type_name, PKGMGR_INSTALLER_RES_CREATE_DIR_EVENT_STR) || + !strcmp(type_name, PKGMGR_INSTALLER_RES_REMOVE_EVENT_STR) || + !strcmp(type_name, PKGMGR_INSTALLER_RES_UNINSTALL_EVENT_STR)) { + gv = g_variant_new_from_data(G_VARIANT_TYPE("(usssv)"), + data, data_len, TRUE, NULL, NULL); + __emit_signal_for_res_event(type_name, gv); + } else { + gv = g_variant_new_from_data(G_VARIANT_TYPE("(usa(sss)ss)"), + data, data_len, TRUE, NULL, NULL); + __emit_signal_for_pkg_event(gv); + } + g_variant_unref(gv); + + free(data); + free(type_name); + close(clifd); + + /* renew timeout */ + g_source_remove(tid); + tid = g_timeout_add_seconds(10, __quit, NULL); + + return TRUE; +} + +static int __init(void) { + char path[PATH_MAX]; + GError* err = NULL; + + snprintf(path, sizeof(path), "/run/pkgmgr/agent/%d", getuid()); + server_fd = __get_server_socket(path); + if (server_fd < 0) { + LOGE("server init failed"); + return -1; + } + + if (aul_proc_register(AGENT_APPID, NULL) != AUL_R_OK) { + LOGE("aul_proc_register fail"); + return -1; + } + + try { + signal_sender = std::make_unique(AGENT_APPID, false); + } catch(...) { + LOGE("Exception occured"); + return -1; + } + + loop = g_main_loop_new(NULL, FALSE); + sid = g_unix_fd_add(server_fd, G_IO_IN, __handle_signal, NULL); + tid = g_timeout_add_seconds(10, __quit, NULL); + + return 0; +} + +static void __fini(void) { + if (sid > 0) + g_source_remove(sid); + if (loop) + g_main_loop_unref(loop); + if (server_fd > 0) + close(server_fd); + aul_proc_deregister(); +} + +int main(int argc, char* argv[]) { + int r; + + r = __init(); + if (r < 0) + return -1; + + g_main_loop_run(loop); + + __fini(); + + return 0; +} diff --git a/installer/src/api_stub.cc b/installer/src/api_stub.cc new file mode 100644 index 0000000..8925d28 --- /dev/null +++ b/installer/src/api_stub.cc @@ -0,0 +1,453 @@ +/* +* Copyright (c) 2022 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. +*/ + + +#include "pkgmgr_installer.h" +#include "pkgmgr_installer_debug.h" +#include "pkgmgr_installer_info.h" + +#include +#include + +#include "control.hh" + +#include + +#ifdef API +#undef API +#endif +#define API __attribute__ ((visibility("default"))) + +#define CHK_PI_RET(r) \ + do { if (nullptr == pi) return (r); } while (0) + +static uid_t g_target_uid; + +API pkgmgr_installer* pkgmgr_installer_new() { + try { + return new pkgmgr::installer::Control(); + } catch (...) { + _E("pkgmgr_installer_new fail"); + return nullptr; + } + + return nullptr; +} + +API pkgmgr_installer* pkgmgr_installer_offline_new() { + return new pkgmgr::installer::Control(true); +} + +API int pkgmgr_installer_free(pkgmgr_installer* pi) { + auto* cls = static_cast(pi); + delete cls; + return 0; +} + +API int pkgmgr_installer_receive_request(pkgmgr_installer *pi, + const int argc, char **argv) { + auto* cls = static_cast(pi); + + int ret = cls->SetRequestFromArgv(argc, argv); + if (ret < 0) + return ret; + + /* if target user is not set, set as tizenglobalapp user */ + if (cls->GetRequest()->GetUid() == 0) + cls->GetRequest()->SetUid(tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)); + + g_target_uid = cls->GetRequest()->GetUid(); + + return 0; +} + +API int pkgmgr_installer_get_request_type(pkgmgr_installer *pi) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return PKGMGR_REQ_INVALID; + return cls->GetRequest()->GetRequestType(); +} + +API uid_t pkgmgr_installer_get_uid(pkgmgr_installer *pi) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return PKGMGR_REQ_INVALID; + return cls->GetRequest()->GetUid(); +} + +API const char* pkgmgr_installer_get_request_info(pkgmgr_installer *pi) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return nullptr; + return cls->GetRequest()->GetRequestInfo().c_str(); +} + +API const char* pkgmgr_installer_get_request_info_at(pkgmgr_installer *pi, + int at) { + CHK_PI_RET(nullptr); + auto* cls = static_cast(pi); + auto& rq = cls->GetRequest(); + if (!rq) + return nullptr; + + const auto& requests = rq->GetRequests(); + if (requests.size() <= at) + return nullptr; + + return requests[at].c_str(); +} + +API int pkgmgr_installer_get_request_info_count(pkgmgr_installer *pi) { + CHK_PI_RET(PKGMGR_REQ_INVALID); + auto* cls = static_cast(pi); + auto& rq = cls->GetRequest(); + if (!rq) + return PKGMGR_REQ_INVALID; + + return rq->GetRequests().size(); +} + +API const char *pkgmgr_installer_get_tep_path(pkgmgr_installer *pi) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return nullptr; + return cls->GetRequest()->GetTepPath().c_str(); +} + +API int pkgmgr_installer_get_tep_move_type(pkgmgr_installer *pi) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return PKGMGR_REQ_INVALID; + return cls->GetRequest()->IsTepMove() ? 1 : 0; +} + +API const char* pkgmgr_installer_get_session_id(pkgmgr_installer *pi) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return nullptr; + return cls->GetRequest()->GetSessionId().c_str(); +} + +API const char* pkgmgr_installer_get_license_path(pkgmgr_installer *pi) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return nullptr; + return cls->GetRequest()->GetLicensePath().c_str(); +} + +API const char* pkgmgr_installer_get_optional_data(pkgmgr_installer *pi) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return nullptr; + return cls->GetRequest()->GetOptionalData().c_str(); +} + +API int pkgmgr_installer_is_quiet(pkgmgr_installer *pi) { + return 1; +} + +API int pkgmgr_installer_get_move_type(pkgmgr_installer *pi) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return PKGMGR_REQ_INVALID; + return cls->GetRequest()->GetMoveType(); +} + +API const char *pkgmgr_installer_get_caller_pkgid(pkgmgr_installer *pi) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return nullptr; + return cls->GetRequest()->GetCallerPkgid().c_str(); +} + +API int pkgmgr_installer_get_is_preload(pkgmgr_installer *pi) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return PKGMGR_REQ_INVALID; + return cls->GetRequest()->IsPreload() ? 1 : 0; +} + +API int pkgmgr_installer_get_force_removal(pkgmgr_installer *pi) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return PKGMGR_REQ_INVALID; + return cls->GetRequest()->IsForceRemoval() ? 1 : 0; +} + +API int pkgmgr_installer_get_is_preload_rw(pkgmgr_installer *pi) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return PKGMGR_REQ_INVALID; + return cls->GetRequest()->IsPreloadRw() ? 1 : 0; +} + +API int pkgmgr_installer_get_no_removal(pkgmgr_installer *pi) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return PKGMGR_REQ_INVALID; + return cls->GetRequest()->IsNoRemoval() ? 1 : 0; +} + +API int pkgmgr_installer_get_keep_rwdata(pkgmgr_installer *pi) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return PKGMGR_REQ_INVALID; + return cls->GetRequest()->IsKeepRwData() ? 1 : 0; +} + +API int pkgmgr_installer_get_partial_rw(pkgmgr_installer *pi) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return PKGMGR_REQ_INVALID; + return cls->GetRequest()->IsPartialRw() ? 1 : 0; +} + +API int pkgmgr_installer_get_debug_mode(pkgmgr_installer *pi) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return PKGMGR_REQ_INVALID; + return cls->GetRequest()->IsDebugMode() ? 1 : 0; +} + +API int pkgmgr_installer_get_skip_check_reference(pkgmgr_installer *pi) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return PKGMGR_REQ_INVALID; + return cls->GetRequest()->IsSkipCheckReference() ? 1 : 0; +} + +API int pkgmgr_installer_get_skip_optimization(pkgmgr_installer *pi) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return PKGMGR_REQ_INVALID; + return cls->GetRequest()->IsSkipOptimization() ? 1 : 0; +} + +API int pkgmgr_installer_get_recovery_cleanup(pkgmgr_installer *pi) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return PKGMGR_REQ_INVALID; + return cls->GetRequest()->IsRecoveryCleanup() ? 1 : 0; +} + +API int pkgmgr_installer_send_app_uninstall_signal(pkgmgr_installer *pi, + const char *pkg_type, const char *pkgid, const char *val) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return -1; + return cls->SendSignal(pkg_type, pkgid, "", PKGMGR_INSTALLER_APPID_KEY_STR, val); +} + +API int pkgmgr_installer_send_app_uninstall_signal_for_uid( + pkgmgr_installer *pi, uid_t uid, const char *pkg_type, + const char *pkgid, const char *val) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return -1; + return cls->SendSignalForUid(uid, pkg_type, pkgid, "", PKGMGR_INSTALLER_APPID_KEY_STR, val); +} + +API int pkgmgr_installer_set_uid(pkgmgr_installer *pi, uid_t uid) { + if (pi == NULL) + return -1; + + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return -1; + + cls->GetRequest()->SetUid(uid); + + g_target_uid = uid; + + return 0; +} + +API int pkgmgr_installer_send_app_signal(pkgmgr_installer *pi, + const char *pkg_type, const char *pkgid, const char *appid, + const char *key, const char *val) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return -1; + return cls->SendSignal(pkg_type, pkgid, appid, key, val); +} + +API int pkgmgr_installer_send_signal(pkgmgr_installer *pi, + const char *pkg_type, const char *pkgid, const char *key, + const char *val) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return -1; + return cls->SendSignal(pkg_type, pkgid, "", key, val); +} + +API int pkgmgr_installer_send_app_signal_for_uid(pkgmgr_installer *pi, + uid_t uid, const char *pkg_type, const char *pkgid, + const char *appid, const char *key, const char *val) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return -1; + return cls->SendSignalForUid(uid, pkg_type, pkgid, appid, key, val); +} + +API int pkgmgr_installer_send_signal_for_uid(pkgmgr_installer *pi, + uid_t uid, const char *pkg_type, const char *pkgid, + const char *key, const char *val) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return -1; + return cls->SendSignalForUid(uid, pkg_type, pkgid, "", key, val); +} + +API int pkgmgr_installer_set_request_type(pkgmgr_installer *pi, + int request_type) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return -1; + cls->GetRequest()->SetRequestType(request_type); + return 0; +} + +API int pkgmgr_installer_set_session_id(pkgmgr_installer *pi, + const char *session_id) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return -1; + cls->GetRequest()->SetSessionId(std::string(session_id)); + return 0; +} + +API int pkgmgr_installer_create_certinfo_set_handle( + pkgmgr_instcertinfo_h *handle) { + return pkgmgrinfo_create_certinfo_set_handle(handle); +} + +API int pkgmgr_installer_set_cert_value(pkgmgr_instcertinfo_h handle, + pkgmgr_instcert_type cert_type, char *cert_value) { + return pkgmgrinfo_set_cert_value(handle, static_cast(cert_type), cert_value); +} + +API int pkgmgr_installer_save_certinfo(const char *pkgid, + pkgmgr_instcertinfo_h handle, uid_t uid) { + return pkgmgrinfo_save_certinfo(pkgid, handle, uid); +} + +API int pkgmgr_installer_destroy_certinfo_set_handle( + pkgmgr_instcertinfo_h handle) { + return pkgmgrinfo_destroy_certinfo_set_handle(handle); +} + +API int pkgmgr_installer_delete_certinfo(const char *pkgid) { + return pkgmgrinfo_delete_certinfo(pkgid); +} + +API int pkgmgr_installer_set_privilege_level(pkgmgr_privilege_level level) { + //TODO + return 0; +} + +API int pkgmgr_installer_info_get_target_uid(uid_t *uid) { + *uid = g_target_uid; + + return 0; +} + +API int pkgmgr_installer_info_get_privilege_level( + pkgmgr_privilege_level *level) { + //TODO + return 0; +} + +API int pkgmgr_installer_info_get_debug_mode(int *debug_mode) { + //TODO + return 0; +} + +API int pkgmgr_installer_info_get_skip_optimization(int *skip_optimization) { + //TODO + return 0; +} + +API const char* pkgmgr_installer_error_to_string(int error_code) { + //TODO + return nullptr; +} + +API int pkgmgr_installer_add_pkg(pkgmgr_installer *pi, + const char *pkgid, const char *pkg_type) { + auto* cls = static_cast(pi); + cls->AddPkg(pkgid, pkg_type); + + return 0; +} + +API int pkgmgr_installer_send_signals(pkgmgr_installer *pi, + const char *key, const char *val) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return -1; + return cls->SendSignals(key, val); +} + +API int pkgmgr_installer_send_signals_for_uid(pkgmgr_installer *pi, uid_t uid, + const char *key, const char *val) { + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return -1; + return cls->SendSignalsForUid(uid, key, val); +} + +API int pkgmgr_installer_set_is_upgrade(pkgmgr_installer *pi, int is_upgrade) { + //TODO + return 0; +} + +API int pkgmgr_installer_send_res_signal(pkgmgr_installer *pi, + const char *pkgid, const char *status, + pkgmgr_res_event_info *event_info) { + if (!pi || !pkgid || !status || !event_info) { + _E("invalid argument"); + return -1; + } + + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return -1; + + return cls->SendSignalForResource(pkgid, status, + reinterpret_cast(event_info)); +} + +API int pkgmgr_installer_send_res_signal_for_uid(pkgmgr_installer *pi, + uid_t uid, const char *pkgid, const char *status, + pkgmgr_res_event_info *event_info) { + if (!pi || !pkgid || !status || !event_info) { + _E("invalid argument"); + return -1; + } + + auto* cls = static_cast(pi); + if (!cls->GetRequest()) + return -1; + + return cls->SendSignalForResourceForUid(uid, pkgid, status, + reinterpret_cast(event_info)); +} + +API int pkgmgr_installer_send_pkg_upgrade_signal(pkgmgr_installer *pi, + unsigned int progress) { + //TODO + return 0; +} diff --git a/installer/src/control.cc b/installer/src/control.cc new file mode 100644 index 0000000..8c0e8f0 --- /dev/null +++ b/installer/src/control.cc @@ -0,0 +1,741 @@ +/* + * Copyright (c) 2022 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. + */ + + +#include "control.hh" + +#include +#include +#include +#include +#include + +#include + +#include "pkgmgr_installer.h" +#include "pkgmgr_installer_debug.h" +#include "pkgmgr_installer_type.h" + +namespace { + +constexpr int OPTVAL_PRELOAD = 1000; +constexpr int OPTVAL_FORCE_REMOVAL = 1001; +constexpr int OPTVAL_PRELOAD_RW = 1002; +constexpr int OPTVAL_NO_REMOVAL = 1003; +constexpr int OPTVAL_KEEP_RWDATA = 1004; +constexpr int OPTVAL_PARTIAL_RW = 1005; +constexpr int OPTVAL_MIGRATE_EXTIMG = 1006; +constexpr int OPTVAL_SKIP_CHECK_REFERENCE = 1007; +constexpr int OPTVAL_RECOVER_DB = 1008; +constexpr int OPTVAL_RECOVERY_CLEANUP = 1009; + +constexpr const char short_opts[] = "k:l:i:d:c:m:t:o:r:p:s:b:e:M:y:u:w:D:A:qGS"; +constexpr const struct option long_opts[] = { + { "session-id", 1, nullptr, 'k' }, + { "license-path", 1, nullptr, 'l' }, + { "install", 1, nullptr, 'i' }, + { "uninstall", 1, nullptr, 'd' }, + { "clear", 1, nullptr, 'c' }, + { "move", 1, nullptr, 'm' }, + { "move-type", 1, nullptr, 't' }, + { "optional-data", 0, nullptr, 'o' }, + { "reinstall", 0, nullptr, 'r' }, + { "caller-pkgid", 1, nullptr, 'p' }, + { "tep-path", 1, nullptr, 'e' }, + { "tep-move", 1, nullptr, 'M' }, + { "smack", 1, nullptr, 's' }, + { "manifest-direct-install", 1, nullptr, 'y' }, + { "mount-install", 1, nullptr, 'w' }, + { "recovery", 1, nullptr, 'b' }, + { "debug-mode", 0, nullptr, 'G' }, + { "skip-optimization", 0, nullptr, 'S' }, + { "preload", 0, nullptr, OPTVAL_PRELOAD }, + { "force-remove", 0, nullptr, OPTVAL_FORCE_REMOVAL }, + { "preload-rw", 0, nullptr, OPTVAL_PRELOAD_RW }, + { "no-remove", 0, nullptr, OPTVAL_NO_REMOVAL }, + { "keep-rwdata", 0, nullptr, OPTVAL_KEEP_RWDATA }, + { "partial-rw", 0, nullptr, OPTVAL_PARTIAL_RW }, + { "migrate-extimg", 1, nullptr, OPTVAL_MIGRATE_EXTIMG }, + { "skip-check-reference", 0, nullptr, OPTVAL_SKIP_CHECK_REFERENCE }, + { "recover-db", 1, nullptr, OPTVAL_RECOVER_DB }, + { "recovery-cleanup", 0, nullptr, OPTVAL_RECOVERY_CLEANUP }, + { 0, 0, 0, 0 } +}; + +static const char* __get_signal_name( + const std::unique_ptr& req, + const char* key, const char* pkg_type) { + if (strcmp(key, PKGMGR_INSTALLER_INSTALL_PERCENT_KEY_STR) == 0) + return key; + else if (strcmp(key, PKGMGR_INSTALLER_GET_SIZE_KEY_STR) == 0) + return key; + else if (strcmp(key, PKGMGR_INSTALLER_APPID_KEY_STR) == 0) + return PKGMGR_INSTALLER_UNINSTALL_EVENT_STR; + else if (strcmp(pkg_type, PKGMGR_INSTALLER_CLEAR_CACHE_KEY_STR) == 0) + return pkg_type; + else if (req->IsUpgrade()) + return PKGMGR_INSTALLER_UPGRADE_EVENT_STR; + + + switch (req->GetRequestType()) { + case PKGMGR_REQ_INSTALL: + case PKGMGR_REQ_MANIFEST_DIRECT_INSTALL: + case PKGMGR_REQ_MOUNT_INSTALL: + case PKGMGR_REQ_REINSTALL: + case PKGMGR_REQ_ENABLE_PKG: + case PKGMGR_REQ_RECOVER: + return PKGMGR_INSTALLER_INSTALL_EVENT_STR; + case PKGMGR_REQ_UNINSTALL: + case PKGMGR_REQ_DISABLE_PKG: + return PKGMGR_INSTALLER_UNINSTALL_EVENT_STR; + case PKGMGR_REQ_UPGRADE: + return PKGMGR_INSTALLER_UPGRADE_EVENT_STR; + case PKGMGR_REQ_MOVE: + return PKGMGR_INSTALLER_MOVE_EVENT_STR; + case PKGMGR_REQ_ENABLE_APP: + return PKGMGR_INSTALLER_APP_ENABLE_EVENT_STR; + case PKGMGR_REQ_DISABLE_APP: + return PKGMGR_INSTALLER_APP_DISABLE_EVENT_STR; + case PKGMGR_REQ_ENABLE_APP_SPLASH_SCREEN: + return PKGMGR_INSTALLER_APP_ENABLE_SPLASH_SCREEN_EVENT_STR; + case PKGMGR_REQ_DISABLE_APP_SPLASH_SCREEN: + return PKGMGR_INSTALLER_APP_DISABLE_SPLASH_SCREEN_EVENT_STR; + case PKGMGR_REQ_CLEAR: + return PKGMGR_INSTALLER_CLEAR_EVENT_STR; + case PKGMGR_REQ_GETSIZE: + return PKGMGR_INSTALLER_GET_SIZE_KEY_STR; + case PKGMGR_REQ_RES_COPY: + return PKGMGR_INSTALLER_RES_COPY_EVENT_STR; + case PKGMGR_REQ_RES_CREATE_DIR: + return PKGMGR_INSTALLER_RES_CREATE_DIR_EVENT_STR; + case PKGMGR_REQ_RES_REMOVE: + return PKGMGR_INSTALLER_RES_REMOVE_EVENT_STR; + case PKGMGR_REQ_RES_UNINSTALL: + return PKGMGR_INSTALLER_RES_UNINSTALL_EVENT_STR; + } + + _E("cannot find type"); + + return NULL; +} + +} + +namespace pkgmgr { +namespace installer { + +Control::Control(bool offline) { + if (!offline) { + signal_.reset(new pkg_group::PkgSignal("", true)); + } + + request_ = std::make_unique(); + + option_map_[OPTVAL_PRELOAD] = [](const std::unique_ptr& req) { + req->is_preload_ = true; + _D("preload request [%d]", req->is_preload_); + return 0; + }; + + option_map_[OPTVAL_FORCE_REMOVAL] = [](const std::unique_ptr& req) { + req->force_removal_ = true; + _D("force-remove request [%d]", req->force_removal_); + return 0; + }; + + option_map_[OPTVAL_PRELOAD_RW] = [](const std::unique_ptr& req) { + req->is_preload_rw_ = true; + _D("preload-rw request [%d]", req->is_preload_rw_); + return 0; + }; + + option_map_[OPTVAL_NO_REMOVAL] = [](const std::unique_ptr& req) { + req->no_removal_ = true; + _D("no-remove request [%d]", req->no_removal_); + return 0; + }; + + option_map_[OPTVAL_KEEP_RWDATA] = [](const std::unique_ptr& req) { + req->keep_rwdata_ = true; + _D("keep-rwdata request [%d]", req->keep_rwdata_); + return 0; + }; + + option_map_[OPTVAL_PARTIAL_RW] = [](const std::unique_ptr& req) { + req->partial_rw_ = true; + _D("partial-rw request [%d]", req->partial_rw_); + return 0; + }; + + option_map_[OPTVAL_MIGRATE_EXTIMG] = [this](const std::unique_ptr& req) { + if (mode_) + return -EINVAL; + mode_ = OPTVAL_MIGRATE_EXTIMG; + req->request_type_ = PKGMGR_REQ_MIGRATE_EXTIMG; + req->pkgmgr_info_ = optarg; + ParseMultiplePkgs(req); + _D("legacy extimg migration requested"); + return 0; + }; + + option_map_[OPTVAL_SKIP_CHECK_REFERENCE] = [](const std::unique_ptr& req) { + req->skip_check_reference_ = true; + return 0; + }; + + option_map_[OPTVAL_RECOVER_DB] = [this](const std::unique_ptr& req) { + req->request_type_ = PKGMGR_REQ_RECOVER_DB; + req->pkgmgr_info_ = optarg; + ParseMultiplePkgs(req); + return 0; + }; + + option_map_[OPTVAL_RECOVERY_CLEANUP] = [](const std::unique_ptr& req) { + req->recovery_cleanup_ = true; + return 0; + }; + + option_map_['k'] = [](const std::unique_ptr& req) { + req->session_id_ = optarg; + return 0; + }; + + option_map_['l'] = [](const std::unique_ptr& req) { + req->license_path_ = optarg; + return 0; + }; + + option_map_['i'] = [this](const std::unique_ptr& req) { + if (mode_) + return -EINVAL; + mode_ = 'i'; + req->request_type_ = PKGMGR_REQ_INSTALL; + req->pkgmgr_info_ = optarg; + ParseMultiplePkgs(req); + _D("option is [i] pkgid[%s]", req->pkgmgr_info_.c_str()); + return 0; + }; + + option_map_['e'] = [](const std::unique_ptr& req) { + req->tep_path_ = optarg; + _D("option is [e] tep_path[%s]", req->tep_path_.c_str()); + return 0; + }; + + option_map_['M'] = [](const std::unique_ptr& req) { + if (strcmp(optarg, "tep_move") == 0) + req->tep_move_ = true; + else + req->tep_move_ = false; + _D("option is [M] tep_move[%d]", req->tep_move_); + return 0; + }; + + option_map_['d'] = [this](const std::unique_ptr& req) { + if (mode_) + return -EINVAL; + mode_ = 'd'; + req->request_type_ = PKGMGR_REQ_UNINSTALL; + req->pkgmgr_info_ = optarg; + ParseMultiplePkgs(req); + return 0; + }; + + option_map_['c'] = [this](const std::unique_ptr& req) { + if (mode_) + return -EINVAL; + mode_ = 'c'; + req->request_type_ = PKGMGR_REQ_CLEAR; + req->pkgmgr_info_ = optarg; + ParseMultiplePkgs(req); + return 0; + }; + + option_map_['m'] = [this](const std::unique_ptr& req) { + if (mode_) + return -EINVAL; + mode_ = 'm'; + req->request_type_ = PKGMGR_REQ_MOVE; + req->pkgmgr_info_ = optarg; + ParseMultiplePkgs(req); + return 0; + }; + + option_map_['r'] = [this](const std::unique_ptr& req) { + if (mode_) + return -EINVAL; + mode_ = 'r'; + req->request_type_ = PKGMGR_REQ_REINSTALL; + req->pkgmgr_info_ = optarg; + ParseMultiplePkgs(req); + return 0; + }; + + option_map_['t'] = [](const std::unique_ptr& req) { + req->move_type_ = atoi(optarg); + return 0; + }; + + option_map_['p'] = [](const std::unique_ptr& req) { + req->caller_pkgid_ = optarg; + return 0; + }; + + option_map_['s'] = [this](const std::unique_ptr& req) { + if (mode_) + return -EINVAL; + mode_ = 's'; + req->request_type_ = PKGMGR_REQ_SMACK; + req->pkgmgr_info_ = optarg; + ParseMultiplePkgs(req); + return 0; + }; + + option_map_['o'] = [](const std::unique_ptr& req) { + req->optional_data_ = optarg; + return 0; + }; + + option_map_['y'] = [this](const std::unique_ptr& req) { + req->request_type_ = PKGMGR_REQ_MANIFEST_DIRECT_INSTALL; + req->pkgmgr_info_ = optarg; + ParseMultiplePkgs(req); + return 0; + }; + + option_map_['w'] = [this](const std::unique_ptr& req) { + req->request_type_ = PKGMGR_REQ_MOUNT_INSTALL; + req->pkgmgr_info_ = optarg; + ParseMultiplePkgs(req); + return 0; + }; + + option_map_['b'] = [this](const std::unique_ptr& req) { + if (mode_) + return -EINVAL; + mode_ = 'b'; + req->request_type_ = PKGMGR_REQ_RECOVER; + req->pkgmgr_info_ = optarg; + ParseMultiplePkgs(req); + return 0; + }; + + option_map_['D'] = [this](const std::unique_ptr& req) { + req->request_type_ = PKGMGR_REQ_DISABLE_PKG; + req->pkgmgr_info_ = optarg; + ParseMultiplePkgs(req); + return 0; + }; + + option_map_['A'] = [this](const std::unique_ptr& req) { + req->request_type_ = PKGMGR_REQ_ENABLE_PKG; + req->pkgmgr_info_ = optarg; + ParseMultiplePkgs(req); + return 0; + }; + + option_map_['u'] = [](const std::unique_ptr& req) { + req->target_uid_ = (uid_t)atoi(optarg); + return 0; + }; + + option_map_['G'] = [](const std::unique_ptr& req) { + req->debug_mode_ = true; + return 0; + }; + + option_map_['S'] = [](const std::unique_ptr& req) { + req->skip_optimization_ = true; + return 0; + }; +} + +Control::~Control() = default; + +void Control::ParseMultiplePkgs(const std::unique_ptr& req) { + while ((optind <= argc_) && (*argv_[optind - 1] != '-')) { + req->pkgs_.push_back(argv_[optind - 1]); + optind++; + } + optind--; +} + +const std::unique_ptr& Control::GetRequest() const { + return request_; +} + +int Control::SendSignal(std::string pkg_type, std::string pkgid, + std::string appid, std::string key, std::string val) { + if (!signal_) { + _E("offline mode"); + return -1; + } + auto& req = GetRequest(); + std::vector pkgs; + pkgs.emplace_back(std::move(pkgid), std::move(appid), std::move(pkg_type)); + signal_->AsyncResult("", req->GetUid(), req->GetSessionId(), std::move(pkgs), + key, val); + return 0; +} + +int Control::SendSignals(std::string key, std::string val) { + if (!signal_) { + _E("offline mode"); + return -1; + } + auto& req = GetRequest(); + signal_->AsyncResult("", req->GetUid(), req->GetSessionId(), pkgs_, key, val); + return 0; +} + +int Control::SendSignalForResource(std::string pkgid, std::string status, + rpc_port::PkgSignal::ExtraData* event_info) { + if (!signal_) { + _E("offline mode"); + return -1; + } + + auto& req = GetRequest(); + const char* signal_name = __get_signal_name(req, "", ""); + if (!signal_name) { + _E("unknown signal type"); + return -1; + } + + signal_->AsyncResultForResource(signal_name, req->GetUid(), + req->GetSessionId(), std::move(pkgid), std::move(status), *event_info); + return 0; +} + +static int __send_signal_to_agent(uid_t uid, void* data, size_t len) { + int fd; + struct sockaddr_un sa; + int r; + + fd = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0); + if (fd == -1) { + _E("failed to create socket: %d", errno); + return -1; + } + + sa.sun_family = AF_UNIX; + snprintf(sa.sun_path, sizeof(sa.sun_path), "/run/pkgmgr/agent/%d", uid); + + r = connect(fd, (struct sockaddr*)&sa, sizeof(sa)); + if (r == -1) { + _E("failed to connect socket(%s): %d", sa.sun_path, errno); + close(fd); + return -1; + } + + r = send(fd, data, len, MSG_NOSIGNAL); + if (r < 0) { + _E("failed to send data: %d", errno); + close(fd); + return -1; + } + + close(fd); + + return 0; +} + +int Control::SendSignalForUid(uid_t uid, std::string pkg_type, + std::string pkgid, std::string appid, std::string key, std::string val) { + if (!signal_) { + _E("offline mode"); + return -1; + } + + const auto& req = GetRequest(); + const char* sid = req->GetSessionId().c_str(); + + const char* signal_name; + size_t name_size; + GVariantBuilder* builder; + GVariant* gv; + gsize gv_len; + gpointer gv_data; + void* data; + void* ptr; + size_t data_len; + + data_len = sizeof(size_t) + sizeof(gsize); + + signal_name = __get_signal_name(req, key.c_str(), pkg_type.c_str()); + if (!signal_name) { + _E("unknown signal name"); + return -1; + } + + /* including null byte */ + name_size = strlen(signal_name) + 1; + data_len += name_size; + + builder = g_variant_builder_new(G_VARIANT_TYPE("a(sss)")); + g_variant_builder_add(builder, "(sss)", pkgid.c_str(), + appid.c_str(), pkg_type.c_str()); + gv = g_variant_new("(usa(sss)ss)", req->GetUid(), sid, + builder, key.c_str(), val.c_str()); + g_variant_builder_unref(builder); + if (gv == NULL) { + _E("failed to create GVariant instance"); + return -1; + } + gv_len = g_variant_get_size(gv); + gv_data = g_malloc(gv_len); + g_variant_store(gv, gv_data); + g_variant_unref(gv); + data_len += gv_len; + + data = malloc(data_len); + if (data == NULL) { + _E("out of memory"); + g_free(gv_data); + return -1; + } + ptr = data; + memcpy(ptr, &name_size, sizeof(size_t)); + ptr += sizeof(size_t); + memcpy(ptr, &gv_len, sizeof(gsize)); + ptr += sizeof(gsize); + memcpy(ptr, signal_name, name_size); + ptr += name_size; + memcpy(ptr, gv_data, gv_len); + g_free(gv_data); + + if (__send_signal_to_agent(uid, data, data_len)) { + _E("failed to send signal to agent"); + free(data); + return -1; + } + + free(data); + + return 0; +} + +int Control::SendSignalsForUid(uid_t uid, std::string key, std::string val) { + if (!signal_) { + _E("offline mode"); + return -1; + } + + const auto& req = GetRequest(); + const char* sid = req->GetSessionId().c_str(); + + const char* signal_name; + size_t name_size; + GVariantBuilder* builder; + GVariant* gv; + gsize gv_len; + gpointer gv_data; + void* data; + void* ptr; + size_t data_len; + + data_len = sizeof(size_t) + sizeof(gsize); + + signal_name = __get_signal_name(req, key.c_str(), ""); + if (!signal_name) { + _E("unknown signal name"); + return -1; + } + + /* including null byte */ + name_size = strlen(signal_name) + 1; + data_len += name_size; + + builder = g_variant_builder_new(G_VARIANT_TYPE("a(sss)")); + for (const auto& pkg : pkgs_) + g_variant_builder_add(builder, "(sss)", pkg.GetPkgid().c_str(), + pkg.GetAppid().c_str(), pkg.GetPkgType().c_str()); + gv = g_variant_new("(usa(sss)ss)", req->GetUid(), sid, + builder, key.c_str(), val.c_str()); + g_variant_builder_unref(builder); + if (gv == NULL) { + _E("failed to create GVariant instance"); + return -1; + } + gv_len = g_variant_get_size(gv); + gv_data = g_malloc(gv_len); + g_variant_store(gv, gv_data); + g_variant_unref(gv); + data_len += gv_len; + + data = malloc(data_len); + if (data == NULL) { + _E("out of memory"); + g_free(gv_data); + return -1; + } + ptr = data; + memcpy(ptr, &name_size, sizeof(size_t)); + ptr += sizeof(size_t); + memcpy(ptr, &gv_len, sizeof(gsize)); + ptr += sizeof(gsize); + memcpy(ptr, signal_name, name_size); + ptr += name_size; + memcpy(ptr, gv_data, gv_len); + g_free(gv_data); + + if (__send_signal_to_agent(uid, data, data_len)) { + _E("failed to send signal to agent"); + free(data); + return -1; + } + + free(data); + + return 0; +} + +static GVariant* __get_gvariant_from_event_info( + pkgmgr_res_event_info* event_info) { + rpc_port::PkgSignal::ExtraData* info = + reinterpret_cast(event_info); + GVariantBuilder* builder; + GVariant* result; + GList* path_states; + res_event_path_state_t* path_state; + + builder = g_variant_builder_new(G_VARIANT_TYPE("a(si)")); + if (builder == NULL) { + _E("out of memory"); + return NULL; + } + + for (const auto& p : info->GetPaths()) + g_variant_builder_add(builder, "(si)", p.GetPath(), p.GetState()); + + result = g_variant_new("(ia(si))", info->GetErrCode(), builder); + g_variant_builder_unref(builder); + + if (result == NULL) { + _E("Fail to create extra data"); + return NULL; + } + + return result; +} + +int Control::SendSignalForResourceForUid(uid_t uid, std::string pkgid, + std::string status, rpc_port::PkgSignal::ExtraData* event_info) { + if (!signal_) { + _E("offline mode"); + return -1; + } + + const auto& req = GetRequest(); + const char* sid = req->GetSessionId().c_str(); + + const char* signal_name; + size_t name_size; + GVariant* gv; + gsize gv_len; + gpointer gv_data; + void* data; + void* ptr; + size_t data_len; + GVariant* extra_param; + + data_len = sizeof(size_t) + sizeof(gsize); + + signal_name = __get_signal_name(req, "", ""); + if (!signal_name) { + _E("unknown signal name"); + return -1; + } + + /* including null byte */ + name_size = strlen(signal_name) + 1; + data_len += name_size; + + extra_param = __get_gvariant_from_event_info(event_info); + if (extra_param == NULL) { + _E("Fail to get extra parameter"); + return -1; + } + + gv = g_variant_new("(usssv)", req->GetUid(), sid, + pkgid.c_str(), status.c_str(), extra_param); + if (gv == NULL) { + _E("failed to create GVariant instance"); + return -1; + } + + gv_len = g_variant_get_size(gv); + gv_data = g_malloc(gv_len); + g_variant_store(gv, gv_data); + g_variant_unref(gv); + data_len += gv_len; + + data = malloc(data_len); + if (data == NULL) { + _E("out of memory"); + g_free(gv_data); + return -1; + } + ptr = data; + memcpy(ptr, &name_size, sizeof(size_t)); + ptr += sizeof(size_t); + memcpy(ptr, &gv_len, sizeof(gsize)); + ptr += sizeof(gsize); + memcpy(ptr, signal_name, name_size); + ptr += name_size; + memcpy(ptr, gv_data, gv_len); + g_free(gv_data); + + if (__send_signal_to_agent(uid, data, data_len)) { + _E("failed to send signal to agent"); + free(data); + return -1; + } + + free(data); + + return 0; +} + +void Control::AddPkg(std::string pkgid, std::string pkg_type) { + pkgs_.emplace_back(rpc_port::PkgSignal::PkgInfo(std::move(pkgid), + "", std::move(pkg_type))); +} + +int Control::SetRequestFromArgv(const int argc, char** argv) { + int opt_idx = 0; + optind = 1; + argc_ = argc; + argv_ = argv; + mode_ = 0; + + while (true) { + int c = getopt_long(argc, argv, short_opts, long_opts, &opt_idx); + if (c == -1) + break; + + if (option_map_.find(c) != option_map_.end()) { + int ret = option_map_[c](request_); + if (ret < 0) + return ret; + } + } + + return 0; +} + +} // namespace installer +} // namespace pkgmgr diff --git a/installer/src/control.hh b/installer/src/control.hh new file mode 100644 index 0000000..6258a4f --- /dev/null +++ b/installer/src/control.hh @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2022 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. + */ + + +#ifndef INSTALLER_SRC_CONTROL_H_ +#define INSTALLER_SRC_CONTROL_H_ + +#include +#include +#include +#include +#include + +#include "PkgSignal.h" +#include "request.hh" + +namespace pkgmgr { +namespace installer { + +namespace pkg_group = rpc_port::PkgSignal::group; + +class Control { + public: + Control(bool offline = false); + virtual ~Control(); + int SetRequestFromArgv(const int argc, char** argv); + const std::unique_ptr& GetRequest() const; + int SendSignal(std::string pkg_type, std::string pkgid, + std::string appid, std::string key, std::string val); + int SendSignals(std::string key, std::string val); + int SendSignalForResource(std::string pkgid, std::string status, + rpc_port::PkgSignal::ExtraData* event_info); + int SendSignalForUid(uid_t uid, std::string pkg_type, std::string pkgid, + std::string appid, std::string key, std::string val); + int SendSignalsForUid(uid_t uid, std::string key, std::string val); + int SendSignalForResourceForUid(uid_t uid, std::string pkgid, + std::string status, rpc_port::PkgSignal::ExtraData* event_info); + void AddPkg(std::string pkgid, std::string pkg_type); + + private: + void ParseMultiplePkgs(const std::unique_ptr& req); + + private: + std::unique_ptr request_; + std::unique_ptr signal_; + std::map&)>> + option_map_; + std::vector pkgs_; + int argc_ = 0; + char** argv_ = nullptr; + int mode_ = 0; +}; + +} // namespace installer +} // namespace pkgmgr + +#endif // INSTALLER_SRC_CONTROL_H_ \ No newline at end of file diff --git a/installer/pkgmgr_installer.h b/installer/src/pkgmgr_installer.h similarity index 99% rename from installer/pkgmgr_installer.h rename to installer/src/pkgmgr_installer.h index 07b2e5e..af71836 100644 --- a/installer/pkgmgr_installer.h +++ b/installer/src/pkgmgr_installer.h @@ -43,7 +43,7 @@ extern "C" { /** * pkgmgr_installer is an opaque type for an object */ -typedef struct pkgmgr_installer pkgmgr_installer; +typedef void pkgmgr_installer; typedef void *pkgmgr_instcertinfo_h; /** diff --git a/installer/pkgmgr_installer_config.h b/installer/src/pkgmgr_installer_config.h similarity index 100% rename from installer/pkgmgr_installer_config.h rename to installer/src/pkgmgr_installer_config.h diff --git a/installer/pkgmgr_installer_debug.h b/installer/src/pkgmgr_installer_debug.h similarity index 76% rename from installer/pkgmgr_installer_debug.h rename to installer/src/pkgmgr_installer_debug.h index 26df677..a92a883 100644 --- a/installer/pkgmgr_installer_debug.h +++ b/installer/src/pkgmgr_installer_debug.h @@ -25,16 +25,16 @@ #endif /* LOG_TAG */ #define LOG_TAG "PKGMGR_INSTALLER" -#ifndef ERR -#define ERR(fmt, args...) LOGE("[%s:%d] "fmt"\n", __func__, __LINE__, ##args) +#ifndef _E +#define _E LOGE #endif -#ifndef DBG -#define DBG(fmt, args...) LOGD("[%s:%d] "fmt"\n", __func__, __LINE__, ##args) +#ifndef _D +#define _D LOGD #endif -#ifndef INFO -#define INFO(fmt, args...) LOGI("[%s:%d] "fmt"\n", __func__, __LINE__, ##args) +#ifndef _I +#define _I LOGI #endif #endif /* __PKGMGR_INSTALLER_DEBUG_H__ */ diff --git a/installer/pkgmgr_installer_error.h b/installer/src/pkgmgr_installer_error.h similarity index 100% rename from installer/pkgmgr_installer_error.h rename to installer/src/pkgmgr_installer_error.h diff --git a/installer/pkgmgr_installer_info.h b/installer/src/pkgmgr_installer_info.h similarity index 100% rename from installer/pkgmgr_installer_info.h rename to installer/src/pkgmgr_installer_info.h diff --git a/installer/pkgmgr_installer_type.h b/installer/src/pkgmgr_installer_type.h similarity index 100% rename from installer/pkgmgr_installer_type.h rename to installer/src/pkgmgr_installer_type.h diff --git a/installer/src/request.cc b/installer/src/request.cc new file mode 100644 index 0000000..51ba2e4 --- /dev/null +++ b/installer/src/request.cc @@ -0,0 +1,136 @@ +/* + * Copyright (c) 2022 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. + */ + + +#include "request.hh" + +#include + +namespace pkgmgr { +namespace installer { + +Request::Request() { + target_uid_ = getuid(); +} + +Request::~Request() = default; + +int Request::GetRequestType() const { + return request_type_; +} + +int Request::GetMoveType() const { + return move_type_; +} + +void Request::SetUpgrade(bool is_upgrade) { + is_upgrade_ = is_upgrade; +} + +const std::string& Request::GetRequestInfo() const { + return pkgmgr_info_; +} + +const std::string& Request::GetSessionId() const { + return session_id_; +} + +const std::string& Request::GetLicensePath() const { + return license_path_; +} + +const std::string& Request::GetOptionalData() const { + return optional_data_; +} + +const std::string& Request::GetCallerPkgid() const { + return caller_pkgid_; +} + +void Request::SetUid(uid_t uid) { + target_uid_ = uid; +} + +void Request::SetRequestType(int type) { + request_type_ = type; +} + +void Request::SetSessionId(std::string id) { + session_id_ = id; +} + +uid_t Request::GetUid() const { + return target_uid_; +} + +const std::string& Request::GetTepPath() const { + return tep_path_; +} + +bool Request::IsUpgrade() const { + return is_upgrade_; +} + +bool Request::IsTepMove() const { + return tep_move_; +} + +bool Request::IsPreload() const { + return is_preload_; +} + +bool Request::IsForceRemoval() const { + return force_removal_; +} + +bool Request::IsPreloadRw() const { + return is_preload_rw_; +} + +bool Request::IsNoRemoval() const { + return no_removal_; +} + +bool Request::IsKeepRwData() const { + return keep_rwdata_; +} + +bool Request::IsPartialRw() const { + return partial_rw_; +} + +bool Request::IsDebugMode() const { + return debug_mode_; +} + +bool Request::IsSkipCheckReference() const { + return skip_check_reference_; +} + +bool Request::IsSkipOptimization() const { + return skip_optimization_; +} + +bool Request::IsRecoveryCleanup() const { + return recovery_cleanup_; +} + +const std::vector& Request::GetRequests() const { + return pkgs_; +} + +} // namespace installer +} // namespace pkgmgr diff --git a/installer/src/request.hh b/installer/src/request.hh new file mode 100644 index 0000000..d8e49ad --- /dev/null +++ b/installer/src/request.hh @@ -0,0 +1,94 @@ +/* + * Copyright (c) 2022 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. + */ + + +#ifndef INSTALLER_SRC_REQUEST_H_ +#define INSTALLER_SRC_REQUEST_H_ + +#include +#include +#include +#include +#include + +#include "PkgSignal.h" + +namespace pkgmgr { +namespace installer { + +class Control; +class Request { + public: + Request(); + virtual ~Request(); + + int GetRequestType() const; + int GetMoveType() const; + void SetUpgrade(bool is_upgrade); + const std::string& GetRequestInfo() const; + const std::string& GetSessionId() const; + const std::string& GetLicensePath() const; + const std::string& GetOptionalData() const; + const std::string& GetCallerPkgid() const; + void SetUid(uid_t uid); + void SetRequestType(int type); + void SetSessionId(std::string id); + uid_t GetUid() const; + const std::string& GetTepPath() const; + bool IsUpgrade() const; + bool IsTepMove() const; + bool IsPreload() const; + bool IsForceRemoval() const; + bool IsPreloadRw() const; + bool IsNoRemoval() const; + bool IsKeepRwData() const; + bool IsPartialRw() const; + bool IsDebugMode() const; + bool IsSkipCheckReference() const; + bool IsSkipOptimization() const; + bool IsRecoveryCleanup() const; + const std::vector& GetRequests() const; + + private: + friend class Control; + int request_type_ = 0; + int move_type_ = 0; + bool is_upgrade_ = false; + std::string pkgmgr_info_; + std::string session_id_; + std::string license_path_; + std::string optional_data_; + std::string caller_pkgid_; + uid_t target_uid_ = 0; + std::string tep_path_; + bool tep_move_ = false; + bool is_preload_ = false; + bool force_removal_ = false; + bool is_preload_rw_ = false; + bool no_removal_ = false; + bool keep_rwdata_ = false; + bool partial_rw_ = false; + bool debug_mode_ = false; + bool skip_check_reference_ = false; + bool skip_optimization_ = false; + bool recovery_cleanup_ = false; + std::vector pkgs_; +}; + +} // namespace installer +} // namespace pkgmgr + +#endif // INSTALLER_SRC_REQUEST_H_ \ No newline at end of file diff --git a/packaging/pkgmgr.changes b/packaging/pkgmgr.changes deleted file mode 100644 index 101d179..0000000 --- a/packaging/pkgmgr.changes +++ /dev/null @@ -1,18 +0,0 @@ -* Tue Jul 02 2013 Junfeng Dong accepted/tizen/20130603.181624@c6b4eaa -- Link pkgmgr-info after pkgmgr-parse to fix the build error in mobile. - -* Thu Jun 27 2013 Anas Nashif accepted/tizen/20130603.181624@3e413f3 -- Spec file clean up, install configs in /etc - -* Mon Jun 03 2013 Anas Nashif submit/tizen/20130601.183631@fff80e8 -- Fixed build on 64 bit systems - -* Sat Jun 01 2013 Anas Nashif submit/tizen/20130517.185027@a8c5788 -- Remove license/group placeholders - -* Mon May 20 2013 Rusty Lynch accepted/tizen/20130520.103548@a8c5788 -- Fix install of package in a buildroot environment - -* Fri May 17 2013 Anas Nashif submit/tizen/20130517.044823@933748f -- do not exclude binaries, just delete them - diff --git a/packaging/pkgmgr.spec b/packaging/pkgmgr.spec index 69cea51..fb5d042 100644 --- a/packaging/pkgmgr.spec +++ b/packaging/pkgmgr.spec @@ -20,6 +20,7 @@ Requires(post): capi-system-info BuildRequires: cmake BuildRequires: unzip BuildRequires: gettext-tools +BuildRequires: pkgconfig(aul) BuildRequires: pkgconfig(glib-2.0) BuildRequires: pkgconfig(gio-2.0) BuildRequires: pkgconfig(dlog) @@ -32,13 +33,29 @@ BuildRequires: pkgconfig(db-util) BuildRequires: pkgconfig(libsmack) BuildRequires: pkgconfig(libsystemd) BuildRequires: pkgconfig(minizip) +BuildRequires: pkgconfig(rpc-port) +BuildRequires: pkgconfig(capi-appfw-event) +BuildRequires: pkgconfig(gmock) BuildRequires: pkgmgr-info-parser-devel BuildRequires: pkgmgr-info-parser BuildRequires: fdupes +BuildRequires: tidl + +%if 0%{?gcov:1} +BuildRequires: lcov +%endif %description Packager Manager client library package for packaging +%if 0%{?gcov:1} +%package gcov +Summary: Packager Manager library (gcov) +Group: Application Framework/Testing + +%description gcov +Packager Manager library gcov objects +%endif %package client Summary: Package Manager client library develpoment package @@ -86,15 +103,37 @@ Package Manager client types develpoment package for packaging %prep %setup -q cp %{SOURCE1001} %{SOURCE1002} %{SOURCE1003} %{SOURCE1004} %{SOURCE1005} %{SOURCE1006} . +tidlc -p -l C++ -i ./tidl/PkgMgr.tidl -o PkgMgrProxy +mv PkgMgrProxy.* ./client/src/ +tidlc -g -l C++ -i ./tidl/PkgSignal.tidl -o PkgSignal +cp PkgSignal.* ./client/src/ +mv PkgSignal.* ./installer/src/ %build +%if 0%{?gcov:1} +export CFLAGS+=" -fprofile-arcs -ftest-coverage" +export CXXFLAGS+=" -fprofile-arcs -ftest-coverage" +export FFLAGS+=" -fprofile-arcs -ftest-coverage" +export LDFLAGS+=" -lgcov" +%endif MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'` %cmake . -DFULLVER=%{version} -DMAJORVER=${MAJORVER} %__make %{?_smp_mflags} +%if 0%{?gcov:1} +mkdir -p gcov-obj +find . -name '*.gcno' -exec cp '{}' gcov-obj ';' +%endif + %install %make_install + +%if 0%{?gcov:1} +mkdir -p %{buildroot}%{_datadir}/gcov/obj/%{name} +install -m 0644 gcov-obj/* %{buildroot}%{_datadir}/gcov/obj/%{name} +%endif + rm -f %{buildroot}%{_bindir}/pkgmgr_backend_sample rm -f %{buildroot}%{_libdir}/libpkgmgr_backend_lib_sample.so rm -f %{buildroot}%{_libdir}/libpkgmgr_parser_lib_sample.so @@ -118,6 +157,14 @@ chmod 755 %{buildroot}%{_sysconfdir}/package-manager/backend/pkgmgr touch %{buildroot}%{_sysconfdir}/package-manager/backend/pkgtool chmod 755 %{buildroot}%{_sysconfdir}/package-manager/backend/pkgtool +%check +export LD_LIBRARY_PATH=../../client +##ctest -V + +%if 0%{?gcov:1} +lcov -c --ignore-errors graph --no-external -b . -d . -o %{name}.info +genhtml %{name}.info -o out --legend --show-details +%endif %fdupes %{buildroot} @@ -215,3 +262,8 @@ rm -rf %{_sysconfdir}/package-manager/pkgmgr-label-initial-image.sh %defattr(-,root,root,-) %{_includedir}/package-manager-*.h %{_libdir}/pkgconfig/pkgmgr-types.pc + +%if 0%{?gcov:1} +%files gcov +%{_datadir}/gcov/* +%endif diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt new file mode 100644 index 0000000..c90fac8 --- /dev/null +++ b/test/CMakeLists.txt @@ -0,0 +1 @@ +ADD_SUBDIRECTORY(unit_tests) diff --git a/test/unit_tests/CMakeLists.txt b/test/unit_tests/CMakeLists.txt new file mode 100644 index 0000000..d328392 --- /dev/null +++ b/test/unit_tests/CMakeLists.txt @@ -0,0 +1,33 @@ +AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/ UNIT_TESTS_SRCS) +AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/mock UNIT_TESTS_MOCK_SRCS) +AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../../client/src CLIENT_SRCS) +ADD_EXECUTABLE(${TARGET_PKGMGR_UNIT_TEST} + ${UNIT_TESTS_SRCS} + ${UNIT_TESTS_MOCK_SRCS} + ${CLIENT_SRCS} +) + +TARGET_INCLUDE_DIRECTORIES(${TARGET_PKGMGR_UNIT_TEST} PUBLIC + "${CMAKE_CURRENT_SOURCE_DIR}/../../client/src/" + "${CMAKE_CURRENT_SOURCE_DIR}/../../clinet/include/" + "${CMAKE_CURRENT_SOURCE_DIR}/../" + "${CMAKE_CURRENT_SOURCE_DIR}/../../" +) + +APPLY_PKG_CONFIG(${TARGET_PKGMGR_UNIT_TEST} PUBLIC + GMOCK_DEPS + GLIB_DEPS + RPC_PORT_DEPS + CAPI_APPFW_EVENT_DEPS + DLOG_DEPS + BUNDLE_DEPS +) + +TARGET_LINK_LIBRARIES(${TARGET_PKGMGR_UNIT_TEST} PUBLIC ${PKGMGR_CLIENT}) +SET_TARGET_PROPERTIES(${TARGET_PKGMGR_UNIT_TEST} PROPERTIES COMPILE_FLAGS "-fPIE") +SET_TARGET_PROPERTIES(${TARGET_PKGMGR_UNIT_TEST} PROPERTIES LINK_FLAGS "-pie") + +ADD_TEST( + NAME ${TARGET_PKGMGR_UNIT_TEST} + COMMAND ${TARGET_PKGMGR_UNIT_TEST} +) diff --git a/test/unit_tests/main.cc b/test/unit_tests/main.cc new file mode 100644 index 0000000..5f340cd --- /dev/null +++ b/test/unit_tests/main.cc @@ -0,0 +1,25 @@ +// Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved +// Use of this source code is governed by a apache 2.0 license that can be +// found in the LICENSE file. + +#include +#include + +int main(int argc, char** argv) { + int ret = -1; + try { + testing::InitGoogleTest(&argc, argv); + } catch(...) { + std::cout << "Exception occurred" << std::endl; + } + + try { + ret = RUN_ALL_TESTS(); + } catch (const ::testing::internal::GoogleTestFailureException& e) { + ret = -1; + std::cout << "GoogleTestFailureException was thrown:" << e.what() + << std::endl; + } + + return ret; +} diff --git a/test/unit_tests/mock/app_event_mock.cc b/test/unit_tests/mock/app_event_mock.cc new file mode 100644 index 0000000..165caa3 --- /dev/null +++ b/test/unit_tests/mock/app_event_mock.cc @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2022 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. + */ + + +#include "mock/app_event_mock.hh" +#include "mock/mock_hook.hh" +#include "mock/test_fixture.hh" + +extern "C" int event_add_event_handler(const char *event_name, + event_cb callback, void *user_data, event_handler_h *event_handler) { + return MOCK_HOOK_P4(AppEventMock, event_add_event_handler, + event_name, callback, user_data, event_handler); +} + +extern "C" int event_remove_event_handler(event_handler_h event_handler) { + return MOCK_HOOK_P1(AppEventMock, event_remove_event_handler, + event_handler); +} + +extern "C" int event_publish_app_event(const char *event_name, + bundle *event_data) { + return MOCK_HOOK_P2(AppEventMock, event_publish_app_event, + event_name, event_data); +} diff --git a/test/unit_tests/mock/app_event_mock.hh b/test/unit_tests/mock/app_event_mock.hh new file mode 100644 index 0000000..fe6af4b --- /dev/null +++ b/test/unit_tests/mock/app_event_mock.hh @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2022 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. + */ + +#ifndef UNIT_TESTS_MOCK_APP_EVENT_MOCK_HH_ +#define UNIT_TESTS_MOCK_APP_EVENT_MOCK_HH_ + +#include +#include + +#include "mock/module_mock.hh" + +class AppEventMock : public virtual ModuleMock { + public: + AppEventMock() {} + virtual ~AppEventMock() {} + + MOCK_METHOD(int, event_add_event_handler, (const char*, + event_cb, void*, event_handler_h*)); + MOCK_METHOD(int, event_remove_event_handler, (event_handler_h)); + MOCK_METHOD(int, event_publish_app_event, (const char*, bundle*)); +}; + +#endif // UNIT_TESTS_MOCK_APP_EVENT_MOCK_HH_ diff --git a/test/unit_tests/mock/mock_hook.hh b/test/unit_tests/mock/mock_hook.hh new file mode 100644 index 0000000..2980460 --- /dev/null +++ b/test/unit_tests/mock/mock_hook.hh @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef UNIT_TESTS_MOCK_MOCK_HOOK_HH_ +#define UNIT_TESTS_MOCK_MOCK_HOOK_HH_ + +#define MOCK_HOOK_P0(MOCK_CLASS, f) \ + TestFixture::GetMock().f() +#define MOCK_HOOK_P1(MOCK_CLASS, f, p1) \ + TestFixture::GetMock().f(p1) +#define MOCK_HOOK_P2(MOCK_CLASS, f, p1, p2) \ + TestFixture::GetMock().f(p1, p2) +#define MOCK_HOOK_P3(MOCK_CLASS, f, p1, p2, p3) \ + TestFixture::GetMock().f(p1, p2, p3) +#define MOCK_HOOK_P4(MOCK_CLASS, f, p1, p2, p3, p4) \ + TestFixture::GetMock().f(p1, p2, p3, p4) +#define MOCK_HOOK_P5(MOCK_CLASS, f, p1, p2, p3, p4, p5) \ + TestFixture::GetMock().f(p1, p2, p3, p4, p5) +#define MOCK_HOOK_P6(MOCK_CLASS, f, p1, p2, p3, p4, p5, p6) \ + TestFixture::GetMock().f(p1, p2, p3, p4, p5, p6) +#define MOCK_HOOK_P7(MOCK_CLASS, f, p1, p2, p3, p4, p5, p6, p7) \ + TestFixture::GetMock().f(p1, p2, p3, p4, p5, p6, p7) +#define MOCK_HOOK_P8(MOCK_CLASS, f, p1, p2, p3, p4, p5, p6, p7, p8) \ + TestFixture::GetMock().f(p1, p2, p3, p4, p5, p6, p7, p8) +#define MOCK_HOOK_P10(MOCK_CLASS, f, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) \ + TestFixture::GetMock().f( \ + p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) + +#endif // UNIT_TESTS_MOCK_MOCK_HOOK_HH_ diff --git a/test/unit_tests/mock/module_mock.hh b/test/unit_tests/mock/module_mock.hh new file mode 100644 index 0000000..a79584e --- /dev/null +++ b/test/unit_tests/mock/module_mock.hh @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef UNIT_TESTS_MOCK_MODULE_MOCK_HH_ +#define UNIT_TESTS_MOCK_MODULE_MOCK_HH_ + +class ModuleMock { + public: + virtual ~ModuleMock() {} +}; + +#endif // UNIT_TESTS_MOCK_MODULE_MOCK_HH_ diff --git a/test/unit_tests/mock/rpc_port_mock.cc b/test/unit_tests/mock/rpc_port_mock.cc new file mode 100644 index 0000000..5295674 --- /dev/null +++ b/test/unit_tests/mock/rpc_port_mock.cc @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2022 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. + */ + +#include "mock/rpc_port_mock.hh" +#include "mock/mock_hook.hh" +#include "mock/test_fixture.hh" + +RpcPortMock::~RpcPortMock() = default; + +extern "C" int rpc_port_proxy_connect_sync(rpc_port_proxy_h h, + const char *appid, const char *port_name) { + return MOCK_HOOK_P3(RpcPortMock, rpc_port_proxy_connect_sync, + h, appid, port_name); +} + +extern "C" int rpc_port_read(rpc_port_h h, void *buf, unsigned int size) { + return MOCK_HOOK_P3(RpcPortMock, rpc_port_read, + h, buf, size); +} + +extern "C" int rpc_port_write(rpc_port_h h, const void *buf, unsigned int size) { + return MOCK_HOOK_P3(RpcPortMock, rpc_port_write, + h, buf, size); +} + +extern "C" int rpc_port_proxy_add_connected_event_cb(rpc_port_proxy_h h, + rpc_port_proxy_connected_event_cb cb, void *user_data) { + return MOCK_HOOK_P3(RpcPortMock, rpc_port_proxy_add_connected_event_cb, + h, cb, user_data); +} + +extern "C" int rpc_port_parcel_create_from_port(rpc_port_parcel_h* h, + rpc_port_h port) { + return MOCK_HOOK_P2(RpcPortMock, rpc_port_parcel_create_from_port, + h, port); +} + +extern "C" int rpc_port_parcel_send(rpc_port_parcel_h h, rpc_port_h port) { + return MOCK_HOOK_P2(RpcPortMock, rpc_port_parcel_send, + h, port); +} diff --git a/test/unit_tests/mock/rpc_port_mock.hh b/test/unit_tests/mock/rpc_port_mock.hh new file mode 100644 index 0000000..2536d5a --- /dev/null +++ b/test/unit_tests/mock/rpc_port_mock.hh @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2022 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. + */ + +#ifndef UNIT_TESTS_MOCK_RPC_PORT_MOCK_HH_ +#define UNIT_TESTS_MOCK_RPC_PORT_MOCK_HH_ + +#include +#include +#include + +#include "mock/module_mock.hh" + +class RpcPortMock : public virtual ModuleMock { + public: + RpcPortMock() { + using ::testing::_; + using ::testing::Invoke; + + ON_CALL(*this, rpc_port_proxy_add_connected_event_cb(_, _, _)) + .WillByDefault(Invoke([&](rpc_port_proxy_h h, + rpc_port_proxy_connected_event_cb cb, void* data) { + connected_event_cb_ = cb; + connected_event_data_ = data; + return 0; + })); + ON_CALL(*this, rpc_port_proxy_connect_sync(_, _, _)) + .WillByDefault(Invoke([&](rpc_port_proxy_h, const char*, const char*) { + if (connected_event_cb_) { + static int dummy; + rpc_port_h port = (rpc_port_h)&dummy; + connected_event_cb_("pkgmgr-server", "mockport", port, + connected_event_data_); + } + return 0; + })); + } + + virtual ~RpcPortMock(); + + MOCK_METHOD(int, rpc_port_proxy_connect_sync, (rpc_port_proxy_h, + const char*, const char*)); + MOCK_METHOD(int, rpc_port_read, (rpc_port_h, void*, unsigned int)); + MOCK_METHOD(int, rpc_port_write, (rpc_port_h, const void*, unsigned int)); + MOCK_METHOD(int, rpc_port_proxy_add_connected_event_cb, + (rpc_port_proxy_h, rpc_port_proxy_connected_event_cb, void*)); + MOCK_METHOD(int, rpc_port_parcel_create_from_port, + (rpc_port_parcel_h*, rpc_port_h)); + MOCK_METHOD(int, rpc_port_parcel_send, (rpc_port_parcel_h, rpc_port_h)); + + private: + rpc_port_proxy_connected_event_cb connected_event_cb_ = nullptr; + void* connected_event_data_ = nullptr; +}; + +#endif // UNIT_TESTS_MOCK_RPC_PORT_MOCK_HH_ diff --git a/test/unit_tests/mock/test_fixture.cc b/test/unit_tests/mock/test_fixture.cc new file mode 100644 index 0000000..23f907d --- /dev/null +++ b/test/unit_tests/mock/test_fixture.cc @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2021 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. + */ + +#include + +#include "unit_tests/mock/test_fixture.hh" + +std::unique_ptr TestFixture::mock_; diff --git a/test/unit_tests/mock/test_fixture.hh b/test/unit_tests/mock/test_fixture.hh new file mode 100644 index 0000000..8351374 --- /dev/null +++ b/test/unit_tests/mock/test_fixture.hh @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef UNIT_TESTS_MOCK_TEST_FIXTURE_HH_ +#define UNIT_TESTS_MOCK_TEST_FIXTURE_HH_ + +#include + +#include +#include +#include +#include + +#include "unit_tests/mock/module_mock.hh" + +class TestFixture : public ::testing::Test { + public: + explicit TestFixture(std::unique_ptr mock) { + mock_ = std::move(mock); + } + + virtual ~TestFixture() {} + + virtual void SetUp() {} + virtual void TearDown() {} + + template + static T& GetMock() { + auto ptr = dynamic_cast(mock_.get()); + if (ptr == nullptr) { + throw std::invalid_argument("The test does not provide mock of \"" + + std::string(typeid(T).name()) + "\""); + } + + return *ptr; + } + + static std::unique_ptr mock_; +}; + +#endif // UNIT_TESTS_MOCK_TEST_FIXTURE_HH_ diff --git a/test/unit_tests/test_client.cc b/test/unit_tests/test_client.cc new file mode 100644 index 0000000..c5fb6e7 --- /dev/null +++ b/test/unit_tests/test_client.cc @@ -0,0 +1,958 @@ +#include "package-manager.h" + +#include +#include + +#include "unit_tests/mock/rpc_port_mock.hh" +#include "unit_tests/mock/app_event_mock.hh" +#include "unit_tests/mock/test_fixture.hh" + +using ::testing::_; +using ::testing::Invoke; + +namespace { +class Mocks : public ::testing::NiceMock, + virtual public ::testing::NiceMock {}; + +} // namespace + +class ClientTest : public TestFixture { + public: + ClientTest() : TestFixture(std::make_unique<::Mocks>()) {} + + virtual void SetUp() { + handle_ = pkgmgr_client_new(PC_REQUEST); + listen_handle_ = pkgmgr_client_new(PC_LISTENING); + handler_ = [](uid_t target_uid, int req_id, + const char* pkg_type, const char* pkgid, const char* key, + const char* val, const void* pmsg, void* data) { + return 0; + }; + app_handler_ = [](uid_t target_uid, int req_id, const char *pkg_type, + const char *pkgid, const char *appid, const char *key, + const char *val, const void *pmsg, void *data) { + return 0; + }; + pkg_size_handler_ = [](pkgmgr_client *pc, const char *pkgid, + const pkg_size_info_t *size_info, void *user_data) { + }; + + ON_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .WillByDefault(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) { + rpc_port_parcel_h parcel; + rpc_port_parcel_create(&parcel); + rpc_port_parcel_write_int32(parcel, 0); // __Result + rpc_port_parcel_write_string(parcel, "req_key"); + rpc_port_parcel_write_int32(parcel, 0); + *h = parcel; + return 0; + })); + } + + virtual void TearDown() { + if (handle_) + pkgmgr_client_free(handle_); + } + + pkgmgr_client* GetHandle() { + return handle_; + } + + pkgmgr_client* GetListenHandle() { + return listen_handle_; + } + + pkgmgr_handler GetDefaultHandler() { + return handler_; + } + + pkgmgr_app_handler GetDefaultAppHandler() { + return app_handler_; + } + + pkgmgr_pkg_size_info_receive_cb GetDefaultPkgSizeHandler() { + return pkg_size_handler_; + } + + private: + pkgmgr_client* handle_ = nullptr; + pkgmgr_client* listen_handle_ = nullptr; + pkgmgr_handler handler_ = nullptr; + pkgmgr_app_handler app_handler_ = nullptr; + pkgmgr_pkg_size_info_receive_cb pkg_size_handler_ = nullptr; +}; + +TEST_F(ClientTest, pkgmgr_client_set_tep_path) { + int ret = pkgmgr_client_set_tep_path(GetHandle(), "/tmp/test.tep", true); + EXPECT_TRUE(ret == PKGMGR_R_OK); +} + +TEST_F(ClientTest, pkgmgr_client_set_tep_path_n) { + int ret = pkgmgr_client_set_tep_path(GetHandle(), nullptr, true); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_install_packages) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(1); + + const char* paths[3] = { "/tmp/a.tpk", "/tmp/b.tpk", "/tmp/c.tpk" }; + int ret = pkgmgr_client_install_packages(GetHandle(), paths, 3, + GetDefaultHandler(), nullptr); + EXPECT_TRUE(ret > 0); +} + +TEST_F(ClientTest, pkgmgr_client_install_packages_n) { + int ret = pkgmgr_client_install_packages(GetHandle(), nullptr, 0, + GetDefaultHandler(), nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_install) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(1); + + int ret = pkgmgr_client_install(GetHandle(), "tpk", "/tmp/desc" + , "/tmp/test.tpk", "", PM_DEFAULT, GetDefaultHandler(), nullptr); + EXPECT_TRUE(ret > 0); +} + +TEST_F(ClientTest, pkgmgr_client_install_n) { + int ret = pkgmgr_client_install(GetHandle(), "tpk", "/tmp/desc" + , nullptr, "", PM_DEFAULT, GetDefaultHandler(), nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_reinstall) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(1); + + int ret = pkgmgr_client_reinstall(GetHandle(), "tpk", "org.tizen.test" + ,"", PM_DEFAULT, GetDefaultHandler(), nullptr); + EXPECT_TRUE(ret > 0); +} + + +TEST_F(ClientTest, pkgmgr_client_reinstall_n) { + int ret = pkgmgr_client_reinstall(GetHandle(), "tpk", nullptr, + "", PM_DEFAULT, GetDefaultHandler(), nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_uninstall_packages) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(1); + + const char* pkgs[3] = { "/tmp/a.tpk", "/tmp/b.tpk", "/tmp/c.tpk" }; + int ret = pkgmgr_client_uninstall_packages(GetHandle(), pkgs, 3, + GetDefaultHandler(), nullptr); + EXPECT_TRUE(ret > 0); +} + +TEST_F(ClientTest, pkgmgr_client_uninstall_packages_n) { + int ret = pkgmgr_client_uninstall_packages(GetHandle(), nullptr, 0, + GetDefaultHandler(), nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_uninstall) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(1); + + int ret = pkgmgr_client_uninstall(GetHandle(), "tpk", "org.tizen.test", + PM_DEFAULT, GetDefaultHandler(), nullptr); + EXPECT_TRUE(ret > 0); +} + +TEST_F(ClientTest, pkgmgr_client_uninstall_n) { + int ret = pkgmgr_client_uninstall(GetHandle(), "tpk", nullptr, + PM_DEFAULT, GetDefaultHandler(), nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_move) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(1); + + int ret = pkgmgr_client_move(GetHandle(), "tpk", "org.tizen.test", + PM_MOVE_TO_SDCARD, GetDefaultHandler(), nullptr); + EXPECT_TRUE(ret > 0); +} + +TEST_F(ClientTest, pkgmgr_client_move_n) { + int ret = pkgmgr_client_move(GetHandle(), "tpk", nullptr, + PM_MOVE_TO_SDCARD, GetDefaultHandler(), nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_mount_install) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(1); + + int ret = pkgmgr_client_mount_install(GetHandle(), "tpk", "/tmp", + "/tmp/test.tpk", "", PM_DEFAULT, GetDefaultHandler(), nullptr); + EXPECT_TRUE(ret > 0); +} + +TEST_F(ClientTest, pkgmgr_client_mount_install_n) { + int ret = pkgmgr_client_mount_install(GetHandle(), "tpk", "/tmp", + nullptr, "", PM_DEFAULT, GetDefaultHandler(), nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_mount_install_packages) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(1); + + const char* paths[3] = { "/tmp/a.tpk", "/tmp/b.tpk", "/tmp/c.tpk" }; + int ret = pkgmgr_client_mount_install_packages(GetHandle(), paths, 3, + GetDefaultHandler(), nullptr); + EXPECT_TRUE(ret > 0); +} + +TEST_F(ClientTest, pkgmgr_client_mount_install_packages_n) { + int ret = pkgmgr_client_mount_install_packages(GetHandle(), nullptr, 0, + GetDefaultHandler(), nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_register_pkg_update_info) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(2); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(2); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(2) + .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) { + rpc_port_parcel_h parcel; + rpc_port_parcel_create(&parcel); + rpc_port_parcel_write_int32(parcel, 0); // __Result + rpc_port_parcel_write_string(parcel, "req_key"); + rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK); + *h = parcel; + return 0; + })) + .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) { + rpc_port_parcel_h parcel; + rpc_port_parcel_create(&parcel); + rpc_port_parcel_write_int32(parcel, 0); // __Result + rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK); + rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK); + *h = parcel; + return 0; + })); + + pkg_update_info_t info = { + .pkgid = const_cast("org.tizen.test"), + .version = const_cast("1.0.0"), + .type = PM_UPDATEINFO_TYPE_FORCE + }; + int ret = pkgmgr_client_register_pkg_update_info(GetHandle(), &info); + EXPECT_TRUE(ret == PKGMGR_R_OK); +} + +TEST_F(ClientTest, pkgmgr_client_register_pkg_update_info_n) { + int ret = pkgmgr_client_register_pkg_update_info(GetHandle(), nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_unregister_pkg_update_info) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(2); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(2); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(2) + .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) { + rpc_port_parcel_h parcel; + rpc_port_parcel_create(&parcel); + rpc_port_parcel_write_int32(parcel, 0); // __Result + rpc_port_parcel_write_string(parcel, "req_key"); + rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK); + *h = parcel; + return 0; + })) + .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) { + rpc_port_parcel_h parcel; + rpc_port_parcel_create(&parcel); + rpc_port_parcel_write_int32(parcel, 0); // __Result + rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK); + rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK); + *h = parcel; + return 0; + })); + + int ret = pkgmgr_client_unregister_pkg_update_info(GetHandle(), + "org.tizen.test"); + EXPECT_TRUE(ret == PKGMGR_R_OK); +} + +TEST_F(ClientTest, pkgmgr_client_unregister_pkg_update_info_n) { + int ret = pkgmgr_client_unregister_pkg_update_info(GetHandle(), + nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_unregister_all_pkg_update_info) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(1) + .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) { + rpc_port_parcel_h parcel; + rpc_port_parcel_create(&parcel); + rpc_port_parcel_write_int32(parcel, 0); // __Result + rpc_port_parcel_write_string(parcel, "req_key"); + rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK); + *h = parcel; + return 0; + })); + + int ret = pkgmgr_client_unregister_all_pkg_update_info(GetHandle()); + EXPECT_TRUE(ret == PKGMGR_R_OK); +} + +TEST_F(ClientTest, pkgmgr_client_unregister_all_pkg_update_info_n) { + int ret = pkgmgr_client_unregister_all_pkg_update_info(nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_activate) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(1); + + int ret = pkgmgr_client_activate(GetHandle(), "tpk", "org.tizen.test"); + EXPECT_TRUE(ret == PKGMGR_R_OK); +} + +TEST_F(ClientTest, pkgmgr_client_activate_n) { + int ret = pkgmgr_client_activate(GetHandle(), "tpk", nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_activate_packages) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(1); + + const char* pkgs[3] = { "org.tizen.test1", "org.tizen.test2", + "org.tizen.test3" }; + int ret = pkgmgr_client_activate_packages(GetHandle(), "tpk", pkgs, 3, + GetDefaultHandler(), nullptr); + EXPECT_TRUE(ret > 0); +} + +TEST_F(ClientTest, pkgmgr_client_activate_packages_n) { + int ret = pkgmgr_client_activate_packages(GetHandle(), "tpk", nullptr, 3, + GetDefaultHandler(), nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_deactivate) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(1); + + int ret = pkgmgr_client_deactivate(GetHandle(), "tpk", "org.tizen.test1"); + EXPECT_TRUE(ret == PKGMGR_R_OK); +} + +TEST_F(ClientTest, pkgmgr_client_deactivate_n) { + int ret = pkgmgr_client_deactivate(GetHandle(), "tpk", nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_deactivate_packages) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(1); + + const char* pkgs[3] = { "org.tizen.test1", "org.tizen.test2", + "org.tizen.test3" }; + int ret = pkgmgr_client_deactivate_packages(GetHandle(), "tpk", pkgs, 3, + GetDefaultHandler(), nullptr); + EXPECT_TRUE(ret > 0); +} + +TEST_F(ClientTest, pkgmgr_client_deactivate_packages_n) { + int ret = pkgmgr_client_deactivate_packages(GetHandle(), "tpk", nullptr, 3, + GetDefaultHandler(), nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_activate_app) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(1); + + int ret = pkgmgr_client_activate_app(GetHandle(), "org.tizen.test", + GetDefaultAppHandler(), nullptr); + EXPECT_TRUE(ret > 0); +} + +TEST_F(ClientTest, pkgmgr_client_activate_app_n) { + int ret = pkgmgr_client_activate_app(GetHandle(), nullptr, + GetDefaultAppHandler(), nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_activate_apps) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(1); + + const char* apps[3] = { "org.tizen.test1", "org.tizen.test2", + "org.tizen.test3" }; + int ret = pkgmgr_client_activate_apps(GetHandle(), apps, 3, + GetDefaultAppHandler(), nullptr); + EXPECT_TRUE(ret > 0); +} + +TEST_F(ClientTest, pkgmgr_client_activate_apps_n) { + int ret = pkgmgr_client_activate_apps(GetHandle(), nullptr, 3, + GetDefaultAppHandler(), nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_activate_global_app_for_uid) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(1); + + int ret = pkgmgr_client_activate_global_app_for_uid(GetHandle(), + "org.tizen.test1", GetDefaultAppHandler(), nullptr, 0); + EXPECT_TRUE(ret > 0); +} + +TEST_F(ClientTest, pkgmgr_client_activate_global_app_for_uid_n) { + int ret = pkgmgr_client_activate_global_app_for_uid(GetHandle(), nullptr, + GetDefaultAppHandler(), nullptr, 0); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_deactivate_app) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(1); + + int ret = pkgmgr_client_deactivate_app(GetHandle(), "org.tizen.test", + GetDefaultAppHandler(), nullptr); + EXPECT_TRUE(ret > 0); +} + +TEST_F(ClientTest, pkgmgr_client_deactivate_app_n) { + int ret = pkgmgr_client_deactivate_app(GetHandle(), nullptr, + GetDefaultAppHandler(), nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_deactivate_apps) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(1); + + const char* apps[3] = { "org.tizen.test1", "org.tizen.test2", + "org.tizen.test3" }; + int ret = pkgmgr_client_deactivate_apps(GetHandle(), apps, 3, + GetDefaultAppHandler(), nullptr); + EXPECT_TRUE(ret > 0); +} + +TEST_F(ClientTest, pkgmgr_client_deactivate_apps_n) { + int ret = pkgmgr_client_deactivate_apps(GetHandle(), nullptr, 3, + GetDefaultAppHandler(), nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_deactivate_global_app_for_uid) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(1); + + int ret = pkgmgr_client_deactivate_global_app_for_uid(GetHandle(), + "org.tizen.test1", GetDefaultAppHandler(), nullptr, 0); + EXPECT_TRUE(ret > 0); +} + +TEST_F(ClientTest, pkgmgr_client_deactivate_global_app_for_uid_n) { + int ret = pkgmgr_client_deactivate_global_app_for_uid(GetHandle(), nullptr, + GetDefaultAppHandler(), nullptr, 0); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_clear_user_data) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(1) + .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) { + rpc_port_parcel_h parcel; + rpc_port_parcel_create(&parcel); + rpc_port_parcel_write_int32(parcel, 0); // __Result + rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK); + *h = parcel; + return 0; + })); + + int ret = pkgmgr_client_clear_user_data(GetHandle(), "tpk", + "org.tizen.test1", PM_DEFAULT); + EXPECT_TRUE(ret == PKGMGR_R_OK); +} + +TEST_F(ClientTest, pkgmgr_client_clear_user_data_n) { + int ret = pkgmgr_client_clear_user_data(GetHandle(), "tpk", + nullptr, PM_DEFAULT); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_listen_status) { + int ret = pkgmgr_client_listen_status(GetListenHandle(), GetDefaultHandler(), nullptr); + EXPECT_TRUE(ret > 0); +} + +TEST_F(ClientTest, pkgmgr_client_listen_status_n) { + int ret = pkgmgr_client_listen_status(nullptr, GetDefaultHandler(), nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_listen_app_status) { + int ret = pkgmgr_client_listen_app_status(GetListenHandle(), GetDefaultAppHandler(), nullptr); + EXPECT_TRUE(ret > 0); +} + +TEST_F(ClientTest, pkgmgr_client_listen_app_status_n) { + int ret = pkgmgr_client_listen_app_status(nullptr, GetDefaultAppHandler(), nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_get_size) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(1); + + int ret = pkgmgr_client_get_size(GetHandle(), "org.tizen.test", + PM_GET_PKG_SIZE_INFO, GetDefaultHandler(), nullptr); + EXPECT_TRUE(ret > 0); +} + +TEST_F(ClientTest, pkgmgr_client_get_size_n) { + int ret = pkgmgr_client_get_size(GetHandle(), nullptr, + PM_GET_PKG_SIZE_INFO, GetDefaultHandler(), nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_get_package_size_info) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(1); + + int ret = pkgmgr_client_get_package_size_info(GetHandle(), "org.tizen.test", + GetDefaultPkgSizeHandler(), nullptr); + EXPECT_TRUE(ret > 0); +} + +TEST_F(ClientTest, pkgmgr_client_get_package_size_info_n) { + int ret = pkgmgr_client_get_package_size_info(GetHandle(), nullptr, + GetDefaultPkgSizeHandler(), nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_generate_license_request) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(2); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(2) + .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) { + rpc_port_parcel_h parcel; + rpc_port_parcel_create(&parcel); + rpc_port_parcel_write_int32(parcel, 0); // __Result + rpc_port_parcel_write_string(parcel, "req_key"); + rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK); + *h = parcel; + return 0; + })) + .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) { + rpc_port_parcel_h parcel; + rpc_port_parcel_create(&parcel); + rpc_port_parcel_write_int32(parcel, 0); // __Result + rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK); + rpc_port_parcel_write_string(parcel, "req_data"); + rpc_port_parcel_write_string(parcel, "license_url"); + rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK); + *h = parcel; + return 0; + })); + + char* req_data = nullptr; + char* license_url = nullptr; + int ret = pkgmgr_client_generate_license_request(GetHandle(), "data", + &req_data, &license_url); + EXPECT_TRUE(ret == PKGMGR_R_OK); + free(req_data); + free(license_url); +} + +TEST_F(ClientTest, pkgmgr_client_generate_license_request_n) { + int ret = pkgmgr_client_generate_license_request(GetHandle(), nullptr, + nullptr, nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_register_license) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(2); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(2); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(2) + .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) { + rpc_port_parcel_h parcel; + rpc_port_parcel_create(&parcel); + rpc_port_parcel_write_int32(parcel, 0); // __Result + rpc_port_parcel_write_string(parcel, "req_key"); + rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK); + *h = parcel; + return 0; + })) + .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) { + rpc_port_parcel_h parcel; + rpc_port_parcel_create(&parcel); + rpc_port_parcel_write_int32(parcel, 0); // __Result + rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK); + rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK); + *h = parcel; + return 0; + })); + + int ret = pkgmgr_client_register_license(GetHandle(), "data"); + EXPECT_TRUE(ret == PKGMGR_R_OK); +} + +TEST_F(ClientTest, pkgmgr_client_register_license_n) { + int ret = pkgmgr_client_register_license(GetHandle(), nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_decrypt_package) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(2); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(2); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(2) + .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) { + rpc_port_parcel_h parcel; + rpc_port_parcel_create(&parcel); + rpc_port_parcel_write_int32(parcel, 0); // __Result + rpc_port_parcel_write_string(parcel, "req_key"); + rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK); + *h = parcel; + return 0; + })) + .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) { + rpc_port_parcel_h parcel; + rpc_port_parcel_create(&parcel); + rpc_port_parcel_write_int32(parcel, 0); // __Result + rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK); + rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK); + *h = parcel; + return 0; + })); + + int ret = pkgmgr_client_decrypt_package(GetHandle(), "path1", "path2"); + EXPECT_TRUE(ret == PKGMGR_R_OK); +} + +TEST_F(ClientTest, pkgmgr_client_decrypt_package_n) { + int ret = pkgmgr_client_decrypt_package(GetHandle(), nullptr, nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_enable_splash_screen) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(1) + .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) { + rpc_port_parcel_h parcel; + rpc_port_parcel_create(&parcel); + rpc_port_parcel_write_int32(parcel, 0); // __Result + rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK); + *h = parcel; + return 0; + })); + + int ret = pkgmgr_client_enable_splash_screen(GetHandle(), "org.tizen.test1"); + EXPECT_TRUE(ret == PKGMGR_R_OK); +} + +TEST_F(ClientTest, pkgmgr_client_enable_splash_screen_n) { + int ret = pkgmgr_client_enable_splash_screen(GetHandle(), nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_disable_splash_screen) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(1) + .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) { + rpc_port_parcel_h parcel; + rpc_port_parcel_create(&parcel); + rpc_port_parcel_write_int32(parcel, 0); // __Result + rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK); + *h = parcel; + return 0; + })); + + int ret = pkgmgr_client_disable_splash_screen(GetHandle(), "org.tizen.test1"); + EXPECT_TRUE(ret == PKGMGR_R_OK); +} + +TEST_F(ClientTest, pkgmgr_client_disable_splash_screen_n) { + int ret = pkgmgr_client_disable_splash_screen(GetHandle(), nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_set_pkg_restriction_mode) { + int ret = pkgmgr_client_set_pkg_restriction_mode(GetHandle(), "org.tizen.test1", 1); + EXPECT_TRUE(ret == PKGMGR_R_OK); +} + +TEST_F(ClientTest, pkgmgr_client_set_pkg_restriction_mode_n) { + int ret = pkgmgr_client_set_pkg_restriction_mode(GetHandle(), nullptr, 0); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_unset_pkg_restriction_mode) { + int ret = pkgmgr_client_unset_pkg_restriction_mode(GetHandle(), "org.tizen.test1", 1); + EXPECT_TRUE(ret == PKGMGR_R_OK); +} + +TEST_F(ClientTest, pkgmgr_client_unset_pkg_restriction_mode_n) { + int ret = pkgmgr_client_unset_pkg_restriction_mode(GetHandle(), nullptr, 0); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_get_pkg_restriction_mode) { + int mode = 0; + int ret = pkgmgr_client_get_pkg_restriction_mode(GetHandle(), + "org.tizen.test1", &mode); + EXPECT_TRUE(ret == PKGMGR_R_OK); +} + +TEST_F(ClientTest, pkgmgr_client_get_pkg_restriction_mode_n) { + int mode; + int ret = pkgmgr_client_get_pkg_restriction_mode(GetHandle(), nullptr, &mode); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_set_restriction_mode) { + int ret = pkgmgr_client_set_restriction_mode(GetHandle(), 2); + EXPECT_TRUE(ret == PKGMGR_R_OK); +} + +TEST_F(ClientTest, pkgmgr_client_set_restriction_mode_n) { + int ret = pkgmgr_client_set_restriction_mode(nullptr, 2); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_unset_restriction_mode) { + int ret = pkgmgr_client_unset_restriction_mode(GetHandle(), 2); + EXPECT_TRUE(ret == PKGMGR_R_OK); +} + +TEST_F(ClientTest, pkgmgr_client_unset_restriction_mode_n) { + int ret = pkgmgr_client_unset_restriction_mode(nullptr, 2); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_get_restriction_mode) { + int mode = 0; + int ret = pkgmgr_client_get_restriction_mode(GetHandle(), &mode); + EXPECT_TRUE(ret == PKGMGR_R_OK); +} + +TEST_F(ClientTest, pkgmgr_client_get_restriction_mode_n) { + int mode = 0; + int ret = pkgmgr_client_get_restriction_mode(nullptr, &mode); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_set_app_label) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(2); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(2); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(2) + .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) { + rpc_port_parcel_h parcel; + rpc_port_parcel_create(&parcel); + rpc_port_parcel_write_int32(parcel, 0); // __Result + rpc_port_parcel_write_string(parcel, "req_key"); + rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK); + *h = parcel; + return 0; + })) + .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) { + rpc_port_parcel_h parcel; + rpc_port_parcel_create(&parcel); + rpc_port_parcel_write_int32(parcel, 0); // __Result + rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK); + rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK); + *h = parcel; + return 0; + })); + + int ret = pkgmgr_client_set_app_label(GetHandle(), + const_cast("org.tizen.test1"), const_cast("test1")); + EXPECT_TRUE(ret == PKGMGR_R_OK); +} + +TEST_F(ClientTest, pkgmgr_client_set_app_label_n) { + int ret = pkgmgr_client_set_app_label(nullptr, nullptr, nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_set_app_icon) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(2); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(2); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(2) + .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) { + rpc_port_parcel_h parcel; + rpc_port_parcel_create(&parcel); + rpc_port_parcel_write_int32(parcel, 0); // __Result + rpc_port_parcel_write_string(parcel, "req_key"); + rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK); + *h = parcel; + return 0; + })) + .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) { + rpc_port_parcel_h parcel; + rpc_port_parcel_create(&parcel); + rpc_port_parcel_write_int32(parcel, 0); // __Result + rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK); + rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK); + *h = parcel; + return 0; + })); + + int ret = pkgmgr_client_set_app_icon(GetHandle(), + const_cast("org.tizen.test1"), const_cast("path")); + EXPECT_TRUE(ret == PKGMGR_R_OK); +} + +TEST_F(ClientTest, pkgmgr_client_set_app_icon_n) { + int ret = pkgmgr_client_set_app_icon(nullptr, nullptr, nullptr); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} + +TEST_F(ClientTest, pkgmgr_client_usr_migrate_external_image) { + EXPECT_CALL(GetMock(), rpc_port_proxy_connect_sync(_, _, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_send(_, _)) + .Times(1); + EXPECT_CALL(GetMock(), rpc_port_parcel_create_from_port(_, _)) + .Times(1) + .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) { + rpc_port_parcel_h parcel; + rpc_port_parcel_create(&parcel); + rpc_port_parcel_write_int32(parcel, 0); // __Result + rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK); + *h = parcel; + return 0; + })); + + int ret = pkgmgr_client_usr_migrate_external_image(GetHandle(), + "org.tizen.test1", 0); + EXPECT_TRUE(ret == PKGMGR_R_OK); +} + +TEST_F(ClientTest, pkgmgr_client_usr_migrate_external_image_n) { + int ret = pkgmgr_client_usr_migrate_external_image(nullptr, + "org.tizen.test1", 0); + EXPECT_TRUE(ret == PKGMGR_R_EINVAL); +} diff --git a/tidl/PkgMgr.tidl b/tidl/PkgMgr.tidl new file mode 100755 index 0000000..bb5b49c --- /dev/null +++ b/tidl/PkgMgr.tidl @@ -0,0 +1,69 @@ +// tidlc -s -l C++ -i PkgMgr.tidl -o PkgMgrStub +// tidlc -p -l C++ -i PkgMgr.tidl -o PkgMgrProxy + +struct ResPath +{ + string From; + string To; +} + +[privilege="http://tizen.org/privilege/packagemanager.clearcache"] +interface PkgMgrForClearCache +{ + int ClearCache(int uid, string pkgid); +} + +[privilege="http://tizen.org/privilege/packagemanager.info"] +interface PkgMgr +{ + int GetSize(int uid, string pkgid, int getType, out string reqKey); + int GetSizeSync(int uid, string pkgid, int getType, out string ReqKey); + int GetSizeSyncResult(string reqKey, out int result, out long sizeInfo); + int Check(int uid, string pkgid, out int pid); +} + +[privilege = "http://tizen.org/privilege/packagemanager.admin"] +interface PkgMgrAdmin +{ + int Install(int uid, string pkgType, string pkgPath, array args, string reqId, out string reqKey); + int InstallPkgs(int uid, array pkgs, array args, string reqId, out string reqKey); + int Reinstall(int uid, string pkgid, out string reqKey); + int MountInstall(int uid, string pkgType, string pkgPath, array args, string reqId, out string reqKey); + int MountInstallPkgs(int uid, array pkgs, string reqId, out string reqKey); + int Uninstall(int uid, string pkgid, out string reqKey); + int UninstallPkgs(int uid, array pkgs, out string reqKey); + int Move(int uid, string pkgId, int moveType, out string reqKey); + int EnablePkgs(int uid, array pkgIds, out string reqKey); + int DisablePkgs(int uid, array pkgIds, out string reqKey); + int RegisterPkgUpdateInfo(int uid, string pkgid, string version, int type, out string delayedReqKey); + int UnregisterPkgUpdateInfo(int uid, string pkgid, out string delayedReqKey); + int UnregisterAllPkgUpdateInfo(int uid, out string delayedReqKey); + int EnableApp(int uid, string appid, out string reqKey); + int DisableApp(int uid, string appid, out string reqKey); + int EnableApps(int uid, array appIds, out string reqKey); + int DisableApps(int uid, array appIds, out string reqKey); + int EnableGlobalAppForUid(int uid, string appid, out string reqKey); + int DisableGlobalAppForUid(int uid, string appid, out string reqKey); + int Kill(int uid, string pkgid, out int pid); + int GenerateLicenseRequest(string respData, out string delayedReqKey); + int GetGenerateLicenseResult(string reqKey, out int result, out string reqData, out string licenseUrl); + int RegisterLicense(string respData, out string delayedReqKey); + int DecryptPackage(string drmFilePath, string decryptedFilePath, out string delayedReqKey); + int EnableAppSplashScreen(int uid, string appid); + int DisableAppSplashScreen(int uid, string appid); + int SetAppLabel(int uid, string appid, string label, out string delayedReqKey); + int SetAppIcon(int uid, string appid, string iconPath, out string delayedReqKey); + int MigrateExternalImage(int uid, string pkgid); + int ResCopy(array copyPathsPair, out string reqKey); + int ResCreateDir(array createDirPaths, out string reqKey); + int ResRemove(array removePaths, out string reqKey); + int ResUninstall(int uid, string pkgid, out string delayedReqKey); + int ClearData(int uid, string pkgid); + int ClearDataWithPath(int uid, string pkgid, string filePath); +} + +interface DelayedResult +{ + int GetResult(string reqKey, out int result); +} + diff --git a/tidl/PkgSignal.tidl b/tidl/PkgSignal.tidl new file mode 100644 index 0000000..a944c6f --- /dev/null +++ b/tidl/PkgSignal.tidl @@ -0,0 +1,28 @@ +// tidlc -g -l C++ -i PkgSignal.tidl -o PkgSignal + +struct PkgInfo +{ + string Pkgid; + string Appid; + string PkgType; +} + +struct PathInfo +{ + string Path; + int State; +} + +struct ExtraData +{ + int ErrCode; + array Paths; +} + +interface PkgSignal +{ + void AsyncResult(string signal, int targetUid, string reqId, array pkgs, string key, string val) async; + void AsyncResultForResource(string signal, int targetUid, string reqId, string pkgid, string status, ExtraData extra) async; +} + + diff --git a/tidl/prebuild.sh b/tidl/prebuild.sh new file mode 100755 index 0000000..2670821 --- /dev/null +++ b/tidl/prebuild.sh @@ -0,0 +1,5 @@ +#!/bin/bash +tidlc -p -l C++ -i PkgMgr.tidl -o PkgMgrProxy +tidlc -g -l C++ -i PkgSignal.tidl -o PkgSignal + + -- 2.7.4