From ead3702fa815c185b0016d4d533942700a3467ba Mon Sep 17 00:00:00 2001 From: Junghyun Yeon Date: Mon, 15 Mar 2021 16:50:29 +0900 Subject: [PATCH] FIx coding rule of pkginfo_manager.cc Signed-off-by: Junghyun Yeon --- src/manager/pkginfo_manager.cc | 2193 ++++++++++++++++++++-------------------- 1 file changed, 1082 insertions(+), 1111 deletions(-) diff --git a/src/manager/pkginfo_manager.cc b/src/manager/pkginfo_manager.cc index 503a270..5c9ac69 100644 --- a/src/manager/pkginfo_manager.cc +++ b/src/manager/pkginfo_manager.cc @@ -18,16 +18,19 @@ #include +#include +#include + +#include + #include #include - -#include "sqlite3.h" -#include "glib.h" +#include #include "pkgmgr_parser.h" #include "pkgmgrinfo_private.h" -#include "logging.hh" +#include "client/pkginfo_client.hh" #include "common/database/abstract_db_handler.hh" #include "common/database/pkg_set_db_handler.hh" #include "common/parcel/appinfo_parcelable.hh" @@ -38,10 +41,8 @@ #include "common/parcel/pkginfo_parcelable.hh" #include "common/parcel/query_parcelable.hh" #include "common/parcel/result_parcelable.hh" +#include "logging.hh" -#include "client/pkginfo_client.hh" - -#include #ifdef LOG_TAG #undef LOG_TAG @@ -53,578 +54,568 @@ #endif #define EXPORT_API __attribute__((visibility("default"))) +namespace pcp = pkgmgr_common::parcel; +namespace pcd = pkgmgr_common::database; + extern "C" EXPORT_API int _pkginfo_get_packages(uid_t uid, - pkgmgrinfo_filter_x *filter, int flag, GHashTable *packages) { - std::shared_ptr parcelable( - new pkgmgr_common::parcel::FilterParcelable(uid, - static_cast(filter), flag, false)); - - pkgmgr_client::PkgInfoClient client(parcelable, uid, - pkgmgr_common::ReqType::GET_PKG_INFO); - if (!client.SendRequest()) - return PMINFO_R_ERROR; + pkgmgrinfo_filter_x* filter, int flag, GHashTable* packages) { + std::shared_ptr parcelable( + new pcp::FilterParcelable(uid, + static_cast(filter), flag, false)); + + pkgmgr_client::PkgInfoClient client(parcelable, uid, + pkgmgr_common::ReqType::GET_PKG_INFO); + if (!client.SendRequest()) + return PMINFO_R_ERROR; + + auto ptr = client.GetResultParcel(); + if (ptr == nullptr) { + LOG(ERROR) << "Fail to get return parcelable"; + return PMINFO_R_ERROR; + } + + if (ptr->GetRequestResult() != PMINFO_R_OK) { + LOG(ERROR) << "Request fail"; + return ptr->GetRequestResult(); + } + + if (ptr->GetType() != pcp::ParcelableType::PkgInfo) { + LOG(ERROR) << "Invalid parcelable type"; + return PMINFO_R_ERROR; + } - auto ptr = client.GetResultParcel(); - if (ptr == nullptr) { - LOG(ERROR) << "Fail to get return parcelable"; - return PMINFO_R_ERROR; - } - - if (ptr->GetRequestResult() != PMINFO_R_OK) { - LOG(ERROR) << "Request fail"; - return ptr->GetRequestResult(); - } - - if (ptr->GetType() != pkgmgr_common::parcel::ParcelableType::PkgInfo) { - LOG(ERROR) << "Invalid parcelable type"; - return PMINFO_R_ERROR; - } - - std::shared_ptr return_parcel( - std::static_pointer_cast( - ptr)); - - auto result_list = return_parcel->ExtractPkgInfo(); - // TODO: check noentry error has returned if size of result_list is 0 - for (auto& pkginfo : result_list) - g_hash_table_insert(packages, (gpointer)pkginfo->package, - (gpointer)pkginfo); - - return PMINFO_R_OK; + std::shared_ptr return_parcel( + std::static_pointer_cast( + ptr)); + + auto result_list = return_parcel->ExtractPkgInfo(); + // TODO: check noentry error has returned if size of result_list is 0 + for (auto &pkginfo : result_list) + g_hash_table_insert(packages, (gpointer)pkginfo->package, + (gpointer)pkginfo); + + return PMINFO_R_OK; } extern "C" EXPORT_API int _pkginfo_get_depends_on(uid_t uid, - const char *pkgid, GList **dependencies) { - std::shared_ptr parcelable( - new pkgmgr_common::parcel::DepInfoParcelable(std::string(pkgid))); + const char* pkgid, GList** dependencies) { + std::shared_ptr parcelable( + new pcp::DepInfoParcelable(std::string(pkgid))); - pkgmgr_client::PkgInfoClient client(parcelable, uid, - pkgmgr_common::ReqType::GET_PKG_DEP_INFO); - if (!client.SendRequest()) - return PMINFO_R_ERROR; + pkgmgr_client::PkgInfoClient client(parcelable, uid, + pkgmgr_common::ReqType::GET_PKG_DEP_INFO); + if (!client.SendRequest()) + return PMINFO_R_ERROR; - auto ptr = client.GetResultParcel(); - if (ptr == nullptr) { - LOG(ERROR) << "Fail to get return parcelable"; - return PMINFO_R_ERROR; - } - - if (ptr->GetRequestResult() != PMINFO_R_OK) { - LOG(ERROR) << "Request fail"; - return ptr->GetRequestResult(); - } - - if (ptr->GetType() != pkgmgr_common::parcel::ParcelableType::DepInfo) { - LOG(ERROR) << "Invalid parcelable type"; - return PMINFO_R_ERROR; - } - - std::shared_ptr return_parcel( - std::static_pointer_cast( - ptr)); - - auto dependency_list = return_parcel->ExtractDependencyInfo(); - for (auto& dependency : dependency_list) - *dependencies = g_list_prepend(*dependencies, dependency); - return PMINFO_R_OK; + auto ptr = client.GetResultParcel(); + if (ptr == nullptr) { + LOG(ERROR) << "Fail to get return parcelable"; + return PMINFO_R_ERROR; + } + + if (ptr->GetRequestResult() != PMINFO_R_OK) { + LOG(ERROR) << "Request fail"; + return ptr->GetRequestResult(); + } + + if (ptr->GetType() != pcp::ParcelableType::DepInfo) { + LOG(ERROR) << "Invalid parcelable type"; + return PMINFO_R_ERROR; + } + + std::shared_ptr return_parcel( + std::static_pointer_cast(ptr)); + + auto dependency_list = return_parcel->ExtractDependencyInfo(); + for (auto &dependency : dependency_list) + *dependencies = g_list_prepend(*dependencies, dependency); + return PMINFO_R_OK; } // TODO: Need to add target db uid to identify which database to be searched extern "C" EXPORT_API int _appinfo_get_applications(uid_t db_uid, uid_t uid, - pkgmgrinfo_filter_x *filter, int flag, GHashTable *packages) { - std::shared_ptr parcelable( - new pkgmgr_common::parcel::FilterParcelable(uid, - static_cast(filter), flag, false)); + pkgmgrinfo_filter_x* filter, int flag, GHashTable* packages) { + std::shared_ptr parcelable( + new pcp::FilterParcelable(uid, + static_cast(filter), flag, false)); + + pkgmgr_client::PkgInfoClient client( + parcelable, uid, pkgmgr_common::ReqType::GET_APP_INFO); + if (!client.SendRequest()) + return PMINFO_R_ERROR; - pkgmgr_client::PkgInfoClient client(parcelable, uid, pkgmgr_common::ReqType::GET_APP_INFO); - if (!client.SendRequest()) - return PMINFO_R_ERROR; + auto ptr = client.GetResultParcel(); + if (ptr == nullptr) { + LOG(ERROR) << "Fail to get return parcelable"; + return PMINFO_R_ERROR; + } + + int ret = ptr->GetRequestResult(); + if (ret != PMINFO_R_OK) { + if (ret == PMINFO_R_ENOENT) + LOG(DEBUG) << "No such application"; + else + LOG(ERROR) << "Request fail"; + return ret; + } - auto ptr = client.GetResultParcel(); - if (ptr == nullptr) { - LOG(ERROR) << "Fail to get return parcelable"; - return PMINFO_R_ERROR; - } - - int ret = ptr->GetRequestResult(); - if (ret != PMINFO_R_OK) { - if (ret == PMINFO_R_ENOENT) { - LOG(DEBUG) << "No such application"; - } else { - LOG(ERROR) << "Request fail"; - } - return ret; - } - - if (ptr->GetType() != pkgmgr_common::parcel::ParcelableType::AppInfo) { - LOG(ERROR) << "Invalid parcelable type"; - return PMINFO_R_ERROR; - } - - std::shared_ptr return_parcel( - std::static_pointer_cast( - ptr)); - - std::vector result_list = return_parcel->ExtractAppInfo(); - for (application_x *app : result_list) - g_hash_table_insert(packages, (gpointer)app->appid, - (gpointer)app); - - return PMINFO_R_OK; + if (ptr->GetType() != pcp::ParcelableType::AppInfo) { + LOG(ERROR) << "Invalid parcelable type"; + return PMINFO_R_ERROR; + } + + std::shared_ptr return_parcel( + std::static_pointer_cast(ptr)); + + std::vector result_list = return_parcel->ExtractAppInfo(); + for (application_x* app : result_list) + g_hash_table_insert(packages, (gpointer)app->appid, + (gpointer)app); + + return PMINFO_R_OK; } -extern "C" EXPORT_API char *_appinfo_get_localed_label( - const char *appid, const char *locale, uid_t uid) { - char *query = nullptr; - query = sqlite3_mprintf( - "SELECT COALESCE((SELECT app_label FROM package_app_localized_info " - "WHERE app_id=%Q AND app_locale=%Q)," - "(SELECT app_label FROM package_app_localized_info WHERE " - "app_id=%Q AND app_locale='No Locale'))", appid, locale, appid); - if (query == nullptr) { - LOG(ERROR) << "Out of memory"; - return nullptr; - } - - std::shared_ptr parcelable( - new pkgmgr_common::parcel::QueryParcelable(uid, std::string(query), - pkgmgr_common::database::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB, - pkgmgr_common::database::AbstractDBHandler::OperationType::OPERATION_TYPE_READ)); - sqlite3_free(query); - - pkgmgr_client::PkgInfoClient client(parcelable, uid, - pkgmgr_common::ReqType::QUERY); - if (!client.SendRequest()) { - return nullptr; - } - - auto ptr = client.GetResultParcel(); - if (ptr == nullptr) { - LOG(ERROR) << "Fail to get return parcelable"; - return nullptr; - } - - if (ptr->GetRequestResult() != PMINFO_R_OK) { - LOG(ERROR) << "Request fail"; - return nullptr; - } - - if (ptr->GetType() != pkgmgr_common::parcel::ParcelableType::Result) { - LOG(ERROR) << "Invalid parcelable type"; - return nullptr; - } - - std::shared_ptr return_parcel( - std::static_pointer_cast( - ptr)); - - // result_list is vector of string vector - char *label = nullptr; - auto result_list = return_parcel->GetResult(); - for (auto result : result_list) { - // result is string vector - // it only has one string or not. - if (result.front().empty() || result.front().length() == 0) - return nullptr; - label = strdup(result.front().c_str()); - if (label == nullptr) { - LOG(ERROR) << "Out of memory"; - return nullptr; - } - return label; - } - - return label; +extern "C" EXPORT_API char* _appinfo_get_localed_label( + const char* appid, const char* locale, uid_t uid) { + char* query = nullptr; + query = sqlite3_mprintf( + "SELECT COALESCE((SELECT app_label FROM package_app_localized_info " + "WHERE app_id=%Q AND app_locale=%Q)," + "(SELECT app_label FROM package_app_localized_info WHERE " + "app_id=%Q AND app_locale='No Locale'))", + appid, locale, appid); + if (query == nullptr) { + LOG(ERROR) << "Out of memory"; + return nullptr; + } + + std::shared_ptr parcelable( + new pcp::QueryParcelable(uid, std::string(query), + pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB, + pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_READ)); + sqlite3_free(query); + + pkgmgr_client::PkgInfoClient client(parcelable, uid, + pkgmgr_common::ReqType::QUERY); + if (!client.SendRequest()) + return nullptr; + auto ptr = client.GetResultParcel(); + if (ptr == nullptr) { + LOG(ERROR) << "Fail to get return parcelable"; + return nullptr; + } + + if (ptr->GetRequestResult() != PMINFO_R_OK) { + LOG(ERROR) << "Request fail"; + return nullptr; + } + + if (ptr->GetType() != pcp::ParcelableType::Result) { + LOG(ERROR) << "Invalid parcelable type"; + return nullptr; + } + + std::shared_ptr return_parcel( + std::static_pointer_cast(ptr)); + + // result_list is vector of string vector + char* label = nullptr; + auto result_list = return_parcel->GetResult(); + for (auto result : result_list) { + // result is string vector + // it only has one string or not. + if (result.front().empty() || result.front().length() == 0) + return nullptr; + label = strdup(result.front().c_str()); + if (label == nullptr) { + LOG(ERROR) << "Out of memory"; + return nullptr; + } + return label; + } + + return label; } extern "C" EXPORT_API int _appinfo_get_datacontrol_info( - const char *providerid, const char *type, uid_t uid, - char **appid, char **access) { - char *query = nullptr; - query = sqlite3_mprintf("SELECT app_id, access FROM " - "package_app_data_control WHERE " - "providerid=%Q AND type=%Q", providerid, type); - if (query == nullptr) { - LOG(ERROR) << "Out of memory"; - return PMINFO_R_ERROR; - } - - std::shared_ptr parcelable( - new pkgmgr_common::parcel::QueryParcelable(uid, std::string(query), - pkgmgr_common::database::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB, - pkgmgr_common::database::AbstractDBHandler::OperationType::OPERATION_TYPE_READ)); - sqlite3_free(query); - - pkgmgr_client::PkgInfoClient client(parcelable, uid, - pkgmgr_common::ReqType::QUERY); - if (!client.SendRequest()) { - return PMINFO_R_ERROR; - } - - auto ptr = client.GetResultParcel(); - if (ptr == nullptr) { - LOG(ERROR) << "Fail to get return parcelable"; - return PMINFO_R_ERROR; - } - - if (ptr->GetRequestResult() != PMINFO_R_OK) { - LOG(ERROR) << "Request fail"; - return ptr->GetRequestResult(); - } - - if (ptr->GetType() != pkgmgr_common::parcel::ParcelableType::Result) { - LOG(ERROR) << "Invalid parcelable type"; - return PMINFO_R_ERROR; - } - - std::shared_ptr return_parcel( - std::static_pointer_cast( - ptr)); - - // result_list is vector of string vector - auto result_list = return_parcel->GetResult(); - if (result_list.size() == 0) - return PMINFO_R_ENOENT; - for (auto result : result_list) { - if (result.size() != 2) - return PMINFO_R_ERROR; - if (result.front().empty() || result.front().size() == 0 || - result.back().empty() || result.back().size() == 0) - return PMINFO_R_ERROR; - *appid = strdup(result.front().c_str()); - *access = strdup(result.back().c_str()); - if (*appid == nullptr || *access == nullptr) { - LOG(ERROR) << "Out of memory"; - return PMINFO_R_ERROR; - } - } - - return PMINFO_R_OK; + const char* providerid, const char* type, uid_t uid, + char** appid, char** access) { + char* query = nullptr; + query = sqlite3_mprintf("SELECT app_id, access FROM " + "package_app_data_control WHERE " + "providerid=%Q AND type=%Q", + providerid, type); + if (query == nullptr) { + LOG(ERROR) << "Out of memory"; + return PMINFO_R_ERROR; + } + + std::shared_ptr parcelable( + new pcp::QueryParcelable(uid, std::string(query), + pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB, + pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_READ)); + sqlite3_free(query); + + pkgmgr_client::PkgInfoClient client(parcelable, uid, + pkgmgr_common::ReqType::QUERY); + if (!client.SendRequest()) + return PMINFO_R_ERROR; + + auto ptr = client.GetResultParcel(); + if (ptr == nullptr) { + LOG(ERROR) << "Fail to get return parcelable"; + return PMINFO_R_ERROR; + } + + if (ptr->GetRequestResult() != PMINFO_R_OK) { + LOG(ERROR) << "Request fail"; + return ptr->GetRequestResult(); + } + + if (ptr->GetType() != pcp::ParcelableType::Result) { + LOG(ERROR) << "Invalid parcelable type"; + return PMINFO_R_ERROR; + } + + std::shared_ptr return_parcel( + std::static_pointer_cast(ptr)); + + // result_list is vector of string vector + auto result_list = return_parcel->GetResult(); + if (result_list.size() == 0) + return PMINFO_R_ENOENT; + for (auto result : result_list) { + if (result.size() != 2) + return PMINFO_R_ERROR; + if (result.front().empty() || result.front().size() == 0 || + result.back().empty() || result.back().size() == 0) + return PMINFO_R_ERROR; + *appid = strdup(result.front().c_str()); + *access = strdup(result.back().c_str()); + if (*appid == nullptr || *access == nullptr) { + LOG(ERROR) << "Out of memory"; + return PMINFO_R_ERROR; + } + } + + return PMINFO_R_OK; } extern "C" EXPORT_API int _appinfo_get_datacontrol_appid( - const char *providerid, uid_t uid, char **appid) { - char *query = nullptr; - - query = sqlite3_mprintf("SELECT app_id FROM package_app_data_control " - "WHERE providerid=%Q", providerid); - if (query == nullptr) { - LOGE("Out of memory"); - return PMINFO_R_ERROR; - } - std::shared_ptr parcelable( - new pkgmgr_common::parcel::QueryParcelable(uid, std::string(query), - pkgmgr_common::database::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB, - pkgmgr_common::database::AbstractDBHandler::OperationType::OPERATION_TYPE_READ)); - sqlite3_free(query); - - pkgmgr_client::PkgInfoClient client(parcelable, uid, - pkgmgr_common::ReqType::QUERY); - if (!client.SendRequest()) { - return PMINFO_R_ERROR; - } - - auto ptr = client.GetResultParcel(); - if (ptr == nullptr) { - LOG(ERROR) << "Fail to get return parcelable"; - return PMINFO_R_ERROR; - } - - if (ptr->GetRequestResult() != PMINFO_R_OK) { - LOG(ERROR) << "Request fail"; - return ptr->GetRequestResult(); - } - - if (ptr->GetType() != pkgmgr_common::parcel::ParcelableType::Result) { - LOG(ERROR) << "Invalid parcelable type"; - return PMINFO_R_ERROR; - } - - std::shared_ptr return_parcel( - std::static_pointer_cast( - ptr)); - - // result_list is vector of string vector - auto result_list = return_parcel->GetResult(); - if (result_list.size() == 0) - return PMINFO_R_ENOENT; - for (auto result : result_list) { - if (result.size() != 1) - return PMINFO_R_ERROR; - if (result.front().empty() || result.front().size() == 0) - return PMINFO_R_ERROR; - *appid = strdup(result.front().c_str()); - if (*appid == nullptr) { - LOG(ERROR) << "Out of memory"; - return PMINFO_R_ERROR; - } - } - - return PMINFO_R_OK; + const char* providerid, uid_t uid, char** appid) { + char* query = nullptr; + + query = sqlite3_mprintf("SELECT app_id FROM package_app_data_control " + "WHERE providerid=%Q", + providerid); + if (query == nullptr) { + LOGE("Out of memory"); + return PMINFO_R_ERROR; + } + std::shared_ptr parcelable( + new pcp::QueryParcelable(uid, std::string(query), + pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB, + pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_READ)); + sqlite3_free(query); + + pkgmgr_client::PkgInfoClient client(parcelable, uid, + pkgmgr_common::ReqType::QUERY); + if (!client.SendRequest()) + return PMINFO_R_ERROR; + + auto ptr = client.GetResultParcel(); + if (ptr == nullptr) { + LOG(ERROR) << "Fail to get return parcelable"; + return PMINFO_R_ERROR; + } + + if (ptr->GetRequestResult() != PMINFO_R_OK) { + LOG(ERROR) << "Request fail"; + return ptr->GetRequestResult(); + } + + if (ptr->GetType() != pcp::ParcelableType::Result) { + LOG(ERROR) << "Invalid parcelable type"; + return PMINFO_R_ERROR; + } + + std::shared_ptr return_parcel( + std::static_pointer_cast(ptr)); + + // result_list is vector of string vector + auto result_list = return_parcel->GetResult(); + if (result_list.size() == 0) + return PMINFO_R_ENOENT; + for (auto result : result_list) { + if (result.size() != 1) + return PMINFO_R_ERROR; + if (result.front().empty() || result.front().size() == 0) + return PMINFO_R_ERROR; + *appid = strdup(result.front().c_str()); + if (*appid == nullptr) { + LOG(ERROR) << "Out of memory"; + return PMINFO_R_ERROR; + } + } + + return PMINFO_R_OK; } extern "C" EXPORT_API int _appinfo_get_datacontrol_trusted_info( - const char *providerid, const char *type, uid_t uid, - char **appid, char **trusted) { - char *query = nullptr; - query = sqlite3_mprintf( - "SELECT app_id, trusted FROM package_app_data_control " - "WHERE providerid=%Q AND type=%Q", providerid, type); - if (query == nullptr) { - LOGE("Out of memory"); - return PMINFO_R_ERROR; - } - - std::shared_ptr parcelable( - new pkgmgr_common::parcel::QueryParcelable(uid, std::string(query), - pkgmgr_common::database::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB, - pkgmgr_common::database::AbstractDBHandler::OperationType::OPERATION_TYPE_READ)); - sqlite3_free(query); - - pkgmgr_client::PkgInfoClient client(parcelable, uid, - pkgmgr_common::ReqType::QUERY); - if (!client.SendRequest()) { - return PMINFO_R_ERROR; - } - - auto ptr = client.GetResultParcel(); - if (ptr == nullptr) { - LOG(ERROR) << "Fail to get return parcelable"; - return PMINFO_R_ERROR; - } - - if (ptr->GetRequestResult() != PMINFO_R_OK) { - LOG(ERROR) << "Request fail"; - return ptr->GetRequestResult(); - } - - if (ptr->GetType() != pkgmgr_common::parcel::ParcelableType::Result) { - LOG(ERROR) << "Invalid parcelable type"; - return PMINFO_R_ERROR; - } - - std::shared_ptr return_parcel( - std::static_pointer_cast( - ptr)); - - // result_list is vector of string vector - auto result_list = return_parcel->GetResult(); - if (result_list.size() == 0) - return PMINFO_R_ENOENT; - for (auto result : result_list) { - if (result.size() != 2) - return PMINFO_R_ERROR; - if (result.front().empty() || result.front().size() == 0 || - result.back().empty() || result.back().size() == 0) - return PMINFO_R_ERROR; - *appid = strdup(result.front().c_str()); - *trusted = strdup(result.back().c_str()); - if (*appid == nullptr || *trusted == nullptr) { - LOG(ERROR) << "Out of memory"; - return PMINFO_R_ERROR; - } - } - - return PMINFO_R_OK; + const char* providerid, const char* type, uid_t uid, + char** appid, char** trusted) { + char* query = nullptr; + query = sqlite3_mprintf( + "SELECT app_id, trusted FROM package_app_data_control " + "WHERE providerid=%Q AND type=%Q", + providerid, type); + if (query == nullptr) { + LOGE("Out of memory"); + return PMINFO_R_ERROR; + } + + std::shared_ptr parcelable( + new pcp::QueryParcelable(uid, std::string(query), + pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB, + pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_READ)); + sqlite3_free(query); + + pkgmgr_client::PkgInfoClient client(parcelable, uid, + pkgmgr_common::ReqType::QUERY); + if (!client.SendRequest()) + return PMINFO_R_ERROR; + + auto ptr = client.GetResultParcel(); + if (ptr == nullptr) { + LOG(ERROR) << "Fail to get return parcelable"; + return PMINFO_R_ERROR; + } + + if (ptr->GetRequestResult() != PMINFO_R_OK) { + LOG(ERROR) << "Request fail"; + return ptr->GetRequestResult(); + } + + if (ptr->GetType() != pcp::ParcelableType::Result) { + LOG(ERROR) << "Invalid parcelable type"; + return PMINFO_R_ERROR; + } + + std::shared_ptr return_parcel( + std::static_pointer_cast(ptr)); + + // result_list is vector of string vector + auto result_list = return_parcel->GetResult(); + if (result_list.size() == 0) + return PMINFO_R_ENOENT; + for (auto result : result_list) { + if (result.size() != 2) + return PMINFO_R_ERROR; + if (result.front().empty() || result.front().size() == 0 || + result.back().empty() || result.back().size() == 0) + return PMINFO_R_ERROR; + *appid = strdup(result.front().c_str()); + *trusted = strdup(result.back().c_str()); + if (*appid == nullptr || *trusted == nullptr) { + LOG(ERROR) << "Out of memory"; + return PMINFO_R_ERROR; + } + } + + return PMINFO_R_OK; } extern "C" EXPORT_API int _appinfo_get_datacontrol_privileges( - const char *providerid, const char *type, uid_t uid, - GList **privileges) { - char *query = nullptr; - query = sqlite3_mprintf( - "SELECT privilege FROM package_app_data_control_privilege " - "WHERE providerid=%Q AND type=%Q", providerid, type); - if (query == nullptr) { - LOGE("Out of memory"); - return PMINFO_R_ERROR; - } - - std::shared_ptr parcelable( - new pkgmgr_common::parcel::QueryParcelable(uid, std::string(query), - pkgmgr_common::database::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB, - pkgmgr_common::database::AbstractDBHandler::OperationType::OPERATION_TYPE_READ)); - sqlite3_free(query); - - pkgmgr_client::PkgInfoClient client(parcelable, uid, - pkgmgr_common::ReqType::QUERY); - if (!client.SendRequest()) { - return PMINFO_R_ERROR; - } - - auto ptr = client.GetResultParcel(); - if (ptr == nullptr) { - LOG(ERROR) << "Fail to get return parcelable"; - return PMINFO_R_ERROR; - } - - if (ptr->GetRequestResult() != PMINFO_R_OK) { - LOG(ERROR) << "Request fail"; - return ptr->GetRequestResult(); - } - - if (ptr->GetType() != pkgmgr_common::parcel::ParcelableType::Result) { - LOG(ERROR) << "Invalid parcelable type"; - return PMINFO_R_ERROR; - } - - std::shared_ptr return_parcel( - std::static_pointer_cast( - ptr)); - - // result_list is vector of string vector - auto result_list = return_parcel->GetResult(); - if (result_list.size() == 0) - return PMINFO_R_ENOENT; - - for (auto result : result_list) { - if (result.size() != 1) - return PMINFO_R_ERROR; - if (result.front().empty() || result.front().size() == 0) - return PMINFO_R_ERROR; - char *privilege = strdup(result.front().c_str()); - if (privilege == nullptr) { - LOG(ERROR) << "Out of memory"; - return PMINFO_R_ERROR; - } - *privileges = g_list_append(*privileges, privilege); - } - - return PMINFO_R_OK; + const char* providerid, const char* type, uid_t uid, GList** privileges) { + char* query = nullptr; + query = sqlite3_mprintf( + "SELECT privilege FROM package_app_data_control_privilege " + "WHERE providerid=%Q AND type=%Q", + providerid, type); + if (query == nullptr) { + LOGE("Out of memory"); + return PMINFO_R_ERROR; + } + + std::shared_ptr parcelable( + new pcp::QueryParcelable(uid, std::string(query), + pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB, + pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_READ)); + sqlite3_free(query); + + pkgmgr_client::PkgInfoClient client(parcelable, uid, + pkgmgr_common::ReqType::QUERY); + if (!client.SendRequest()) + return PMINFO_R_ERROR; + + auto ptr = client.GetResultParcel(); + if (ptr == nullptr) { + LOG(ERROR) << "Fail to get return parcelable"; + return PMINFO_R_ERROR; + } + + if (ptr->GetRequestResult() != PMINFO_R_OK) { + LOG(ERROR) << "Request fail"; + return ptr->GetRequestResult(); + } + + if (ptr->GetType() != pcp::ParcelableType::Result) { + LOG(ERROR) << "Invalid parcelable type"; + return PMINFO_R_ERROR; + } + + std::shared_ptr return_parcel( + std::static_pointer_cast(ptr)); + + // result_list is vector of string vector + auto result_list = return_parcel->GetResult(); + if (result_list.size() == 0) + return PMINFO_R_ENOENT; + + for (auto result : result_list) { + if (result.size() != 1) + return PMINFO_R_ERROR; + if (result.front().empty() || result.front().size() == 0) + return PMINFO_R_ERROR; + char* privilege = strdup(result.front().c_str()); + if (privilege == nullptr) { + LOG(ERROR) << "Out of memory"; + return PMINFO_R_ERROR; + } + *privileges = g_list_append(*privileges, privilege); + } + + return PMINFO_R_OK; } extern "C" EXPORT_API int _appinfo_get_appcontrol_privileges( - const char *appid, const char *operation, uid_t uid, GList **privileges) { - char *query = nullptr; - query = sqlite3_mprintf( - "SELECT app_control, privilege FROM package_app_app_control_privilege " - "WHERE app_id=%Q", appid); - if (query == nullptr) { - LOG(ERROR) << "Out of memory"; - return PMINFO_R_ERROR; - } - - std::shared_ptr parcelable( - new pkgmgr_common::parcel::QueryParcelable(uid, std::string(query), - pkgmgr_common::database::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB, - pkgmgr_common::database::AbstractDBHandler::OperationType::OPERATION_TYPE_READ)); - sqlite3_free(query); - - pkgmgr_client::PkgInfoClient client(parcelable, uid, - pkgmgr_common::ReqType::QUERY); - if (!client.SendRequest()) { - return PMINFO_R_ERROR; - } - - auto ptr = client.GetResultParcel(); - if (ptr == nullptr) { - LOG(ERROR) << "Fail to get return parcelable"; - return PMINFO_R_ERROR; - } - - if (ptr->GetRequestResult() != PMINFO_R_OK) { - LOG(ERROR) << "Request fail"; - return ptr->GetRequestResult(); - } - - if (ptr->GetType() != pkgmgr_common::parcel::ParcelableType::Result) { - LOG(ERROR) << "Invalid parcelable type"; - return PMINFO_R_ERROR; - } - - std::shared_ptr return_parcel( - std::static_pointer_cast( - ptr)); - - // result_list is vector of string vector - auto result_list = return_parcel->GetResult(); - if (result_list.size() == 0) - return PMINFO_R_ENOENT; - - for (auto result : result_list) { - if (result.size() != 2) - return PMINFO_R_ERROR; - if (result.front().empty() || result.front().size() == 0 || - result.back().empty() || result.back().size() == 0) - return PMINFO_R_ERROR; - std::string app_control = result.front(); - std::stringstream ss(app_control); - std::string token; - while (std::getline(ss, token, '|')) { - if (token.compare(std::string(operation))) { - char *privilege = strdup(result.back().c_str()); - if (privilege == nullptr) { - LOG(ERROR) << "Out of memory"; - return PMINFO_R_ERROR; - } - *privileges = g_list_append(*privileges, privilege); - } - } - } - return PMINFO_R_OK; + const char* appid, const char* operation, uid_t uid, GList** privileges) { + char* query = nullptr; + query = sqlite3_mprintf( + "SELECT app_control, privilege FROM package_app_app_control_privilege " + "WHERE app_id=%Q", appid); + if (query == nullptr) { + LOG(ERROR) << "Out of memory"; + return PMINFO_R_ERROR; + } + + std::shared_ptr parcelable( + new pcp::QueryParcelable(uid, std::string(query), + pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB, + pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_READ)); + sqlite3_free(query); + + pkgmgr_client::PkgInfoClient client(parcelable, uid, + pkgmgr_common::ReqType::QUERY); + if (!client.SendRequest()) + return PMINFO_R_ERROR; + + auto ptr = client.GetResultParcel(); + if (ptr == nullptr) { + LOG(ERROR) << "Fail to get return parcelable"; + return PMINFO_R_ERROR; + } + + if (ptr->GetRequestResult() != PMINFO_R_OK) { + LOG(ERROR) << "Request fail"; + return ptr->GetRequestResult(); + } + + if (ptr->GetType() != pcp::ParcelableType::Result) { + LOG(ERROR) << "Invalid parcelable type"; + return PMINFO_R_ERROR; + } + + std::shared_ptr return_parcel( + std::static_pointer_cast(ptr)); + + // result_list is vector of string vector + auto result_list = return_parcel->GetResult(); + if (result_list.size() == 0) + return PMINFO_R_ENOENT; + + for (auto result : result_list) { + if (result.size() != 2) + return PMINFO_R_ERROR; + if (result.front().empty() || result.front().size() == 0 || + result.back().empty() || result.back().size() == 0) + return PMINFO_R_ERROR; + std::string app_control = result.front(); + std::stringstream ss(app_control); + std::string token; + while (std::getline(ss, token, '|')) { + if (token.compare(std::string(operation))) { + char* privilege = strdup(result.back().c_str()); + if (privilege == nullptr) { + LOG(ERROR) << "Out of memory"; + return PMINFO_R_ERROR; + } + *privileges = g_list_append(*privileges, privilege); + } + } + } + return PMINFO_R_OK; } extern "C" EXPORT_API int _plugininfo_get_appids( - const char *pkgid, const char *plugin_type, - const char *plugin_name, GList **list) { - if (!pkgid || !plugin_type || !plugin_name || !list) { - LOG(ERROR) << "Invalid parameter"; - return PMINFO_R_EINVAL; - } - - char *query = nullptr; - query = sqlite3_mprintf( - "SELECT appid FROM " - "package_plugin_info WHERE pkgid=%Q AND " - "plugin_type=%Q AND plugin_name=%Q", + const char* pkgid, const char* plugin_type, + const char* plugin_name, GList** list) { + if (!pkgid || !plugin_type || !plugin_name || !list) { + LOG(ERROR) << "Invalid parameter"; + return PMINFO_R_EINVAL; + } + + char* query = nullptr; + query = sqlite3_mprintf( + "SELECT appid FROM " + "package_plugin_info WHERE pkgid=%Q AND " + "plugin_type=%Q AND plugin_name=%Q", pkgid, plugin_type, plugin_name); - if (query == nullptr) { - LOG(ERROR) << "Out of memory"; - return PMINFO_R_ERROR; - } - - std::shared_ptr parcelable( - new pkgmgr_common::parcel::QueryParcelable(_getuid(), std::string(query), - pkgmgr_common::database::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB, - pkgmgr_common::database::AbstractDBHandler::OperationType::OPERATION_TYPE_READ)); - sqlite3_free(query); - - pkgmgr_client::PkgInfoClient client(parcelable, _getuid(), - pkgmgr_common::ReqType::QUERY); - if (!client.SendRequest()) { - return PMINFO_R_ERROR; - } - - auto ptr = client.GetResultParcel(); - if (ptr == nullptr) { - LOG(ERROR) << "Fail to get return parcelable"; - return PMINFO_R_ERROR; - } - - if (ptr->GetRequestResult() != PMINFO_R_OK) { - LOG(ERROR) << "Request fail"; - return ptr->GetRequestResult(); - } - - if (ptr->GetType() != pkgmgr_common::parcel::ParcelableType::Result) { - LOG(ERROR) << "Invalid parcelable type"; - return PMINFO_R_ERROR; - } - - std::shared_ptr return_parcel( - std::static_pointer_cast( - ptr)); + if (query == nullptr) { + LOG(ERROR) << "Out of memory"; + return PMINFO_R_ERROR; + } + + std::shared_ptr parcelable( + new pcp::QueryParcelable(_getuid(), std::string(query), + pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB, + pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_READ)); + sqlite3_free(query); + + pkgmgr_client::PkgInfoClient client(parcelable, _getuid(), + pkgmgr_common::ReqType::QUERY); + if (!client.SendRequest()) + return PMINFO_R_ERROR; + + auto ptr = client.GetResultParcel(); + if (ptr == nullptr) { + LOG(ERROR) << "Fail to get return parcelable"; + return PMINFO_R_ERROR; + } + + if (ptr->GetRequestResult() != PMINFO_R_OK) { + LOG(ERROR) << "Request fail"; + return ptr->GetRequestResult(); + } + + if (ptr->GetType() != pcp::ParcelableType::Result) { + LOG(ERROR) << "Invalid parcelable type"; + return PMINFO_R_ERROR; + } + + std::shared_ptr return_parcel( + std::static_pointer_cast(ptr)); if (return_parcel->GetCol() != 1) { LOG(ERROR) << "Invalid result"; return PMINFO_R_ERROR; } - // result_list is vector of string vector - auto& result_list = return_parcel->GetResult(); - if (result_list.size() == 0) - return PMINFO_R_ENOENT; + // result_list is vector of string vector + auto &result_list = return_parcel->GetResult(); + if (result_list.size() == 0) + return PMINFO_R_ENOENT; - for (auto result : result_list) { + for (auto result : result_list) { if (result.size() != 1) { LOG(ERROR) << "Invalid result"; g_list_free_full(*list, free); @@ -636,630 +627,610 @@ extern "C" EXPORT_API int _plugininfo_get_appids( return PMINFO_R_OK; } -static int __convert_update_type(const char *type, pkgmgrinfo_updateinfo_update_type *convert_type) -{ - if (strncasecmp(type, PMINFO_UPDATEINFO_TYPE_NONE, - strlen(PMINFO_UPDATEINFO_TYPE_NONE)) == 0) - *convert_type = PMINFO_UPDATEINFO_NONE; - else if (strncasecmp(type, PMINFO_UPDATEINFO_TYPE_FORCE, - strlen(PMINFO_UPDATEINFO_TYPE_FORCE)) == 0) - *convert_type = PMINFO_UPDATEINFO_FORCE; - else if (strncasecmp(type, PMINFO_UPDATEINFO_TYPE_OPTIONAL, - strlen(PMINFO_UPDATEINFO_TYPE_OPTIONAL)) == 0) - *convert_type = PMINFO_UPDATEINFO_OPTIONAL; - else - return -1; - return 0; +static int __convert_update_type(const char* type, + pkgmgrinfo_updateinfo_update_type* convert_type) { + if (strncasecmp(type, PMINFO_UPDATEINFO_TYPE_NONE, + strlen(PMINFO_UPDATEINFO_TYPE_NONE)) == 0) + *convert_type = PMINFO_UPDATEINFO_NONE; + else if (strncasecmp(type, PMINFO_UPDATEINFO_TYPE_FORCE, + strlen(PMINFO_UPDATEINFO_TYPE_FORCE)) == 0) + *convert_type = PMINFO_UPDATEINFO_FORCE; + else if (strncasecmp(type, PMINFO_UPDATEINFO_TYPE_OPTIONAL, + strlen(PMINFO_UPDATEINFO_TYPE_OPTIONAL)) == 0) + *convert_type = PMINFO_UPDATEINFO_OPTIONAL; + else + return -1; + return 0; } -static void __free_update_info(gpointer data) -{ - updateinfo_x *update_info = (updateinfo_x *)data; - if (update_info == nullptr) - return; - - if (update_info->pkgid) - free((void *)update_info->pkgid); - if (update_info->version) - free((void *)update_info->version); - free((void *)update_info); +static void __free_update_info(gpointer data) { + updateinfo_x* update_info = reinterpret_cast(data); + if (update_info == nullptr) + return; + if (update_info->pkgid) + free(reinterpret_cast(update_info->pkgid)); + if (update_info->version) + free(reinterpret_cast(update_info->version)); + free(reinterpret_cast(update_info)); } -extern "C" EXPORT_API int _get_pkg_updateinfo(const char *pkgid, - GSList **update_info_list, uid_t uid) -{ - char *query = nullptr; - int ret; - - if (pkgid == nullptr) - query = sqlite3_mprintf( - "SELECT package, update_version, update_type " - "FROM package_update_info"); - else - query = sqlite3_mprintf( - "SELECT package, update_version, update_type " - "FROM package_update_info WHERE package=%Q", - pkgid); - if (query == nullptr) { - LOG(ERROR) << "Out of memory"; - return PMINFO_R_ERROR; - } - - std::shared_ptr parcelable( - new pkgmgr_common::parcel::QueryParcelable(uid, std::string(query), - pkgmgr_common::database::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB, - pkgmgr_common::database::AbstractDBHandler::OperationType::OPERATION_TYPE_READ)); - sqlite3_free(query); - - pkgmgr_client::PkgInfoClient client(parcelable, uid, - pkgmgr_common::ReqType::QUERY); - if (!client.SendRequest()) { - return PMINFO_R_ERROR; - } - - auto ptr = client.GetResultParcel(); - if (ptr == nullptr) { - LOG(ERROR) << "Fail to get return parcelable"; - return PMINFO_R_ERROR; - } - - if (ptr->GetRequestResult() != PMINFO_R_OK) { - LOG(ERROR) << "Request fail"; - return ptr->GetRequestResult(); - } - - if (ptr->GetType() != pkgmgr_common::parcel::ParcelableType::Result) { - LOG(ERROR) << "Invalid parcelable type"; - return PMINFO_R_ERROR; - } - - std::shared_ptr return_parcel( - std::static_pointer_cast( - ptr)); +extern "C" EXPORT_API int _get_pkg_updateinfo(const char* pkgid, + GSList** update_info_list, uid_t uid) { + char* query = nullptr; + int ret; + + if (pkgid == nullptr) + query = sqlite3_mprintf( + "SELECT package, update_version, update_type " + "FROM package_update_info"); + else + query = sqlite3_mprintf( + "SELECT package, update_version, update_type " + "FROM package_update_info WHERE package=%Q", + pkgid); + if (query == nullptr) { + LOG(ERROR) << "Out of memory"; + return PMINFO_R_ERROR; + } + + std::shared_ptr parcelable( + new pcp::QueryParcelable(uid, std::string(query), + pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB, + pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_READ)); + sqlite3_free(query); + + pkgmgr_client::PkgInfoClient client(parcelable, uid, + pkgmgr_common::ReqType::QUERY); + if (!client.SendRequest()) + return PMINFO_R_ERROR; + + auto ptr = client.GetResultParcel(); + if (ptr == nullptr) { + LOG(ERROR) << "Fail to get return parcelable"; + return PMINFO_R_ERROR; + } + + if (ptr->GetRequestResult() != PMINFO_R_OK) { + LOG(ERROR) << "Request fail"; + return ptr->GetRequestResult(); + } + + if (ptr->GetType() != pcp::ParcelableType::Result) { + LOG(ERROR) << "Invalid parcelable type"; + return PMINFO_R_ERROR; + } + + std::shared_ptr return_parcel( + std::static_pointer_cast(ptr)); if (return_parcel->GetCol() != 3) { LOG(ERROR) << "Invalid result"; return PMINFO_R_ERROR; } - auto result_list = return_parcel->GetResult(); - if (result_list.size() == 0) - return PMINFO_R_ENOENT; + auto result_list = return_parcel->GetResult(); + if (result_list.size() == 0) + return PMINFO_R_ENOENT; - for (auto result : result_list) { + for (auto result : result_list) { if (result.size() != 3) { LOG(ERROR) << "Invalid result"; g_slist_free_full(*update_info_list, __free_update_info); return PMINFO_R_ERROR; } - updateinfo_x *update_info = reinterpret_cast(calloc(1, sizeof(updateinfo_x))); - if (update_info == nullptr) { - LOG(ERROR) << "Out of memory"; - return PMINFO_R_ERROR; - } + updateinfo_x* update_info = reinterpret_cast( + calloc(1, sizeof(updateinfo_x))); + if (update_info == nullptr) { + LOG(ERROR) << "Out of memory"; + return PMINFO_R_ERROR; + } update_info->pkgid = strdup(result[0].c_str()); update_info->version = strdup(result[1].c_str()); - pkgmgrinfo_updateinfo_update_type convert_type; - ret = __convert_update_type(result[2].c_str(), &convert_type); - if (ret != 0) { - __free_update_info(update_info); + pkgmgrinfo_updateinfo_update_type convert_type; + ret = __convert_update_type(result[2].c_str(), &convert_type); + if (ret != 0) { + __free_update_info(update_info); g_slist_free_full(*update_info_list, __free_update_info); - return PMINFO_R_ERROR; - } - update_info->type = static_cast(convert_type); - *update_info_list = g_slist_prepend(*update_info_list, - update_info); + return PMINFO_R_ERROR; + } + update_info->type = static_cast(convert_type); + *update_info_list = g_slist_prepend(*update_info_list, + update_info); } - return PMINFO_R_OK; + return PMINFO_R_OK; } -extern "C" EXPORT_API int _pkginfo_set_usr_installed_storage(const char *pkgid, - INSTALL_LOCATION location, const char *external_pkg_path, - uid_t uid) -{ - char *query = nullptr; - const char *location_str; - std::vector queries; - - if (location == INSTALL_INTERNAL) - location_str = "installed_internal"; - else if (location == INSTALL_EXTERNAL) - location_str = "installed_external"; - else - location_str = "installed_extended"; - /* pkgcakge_info table */ - query = sqlite3_mprintf( - "update package_info set installed_storage=%Q, external_path=%Q where package=%Q", - location_str, external_pkg_path, pkgid); - queries.emplace_back(query); - sqlite3_free(query); - - /* package_app_info table */ - query = sqlite3_mprintf( - "update package_app_info set app_installed_storage=%Q, app_external_path=%Q where package=%Q", - location_str, external_pkg_path, pkgid); - queries.emplace_back(query); - sqlite3_free(query); - - std::shared_ptr parcelable( - new pkgmgr_common::parcel::QueryParcelable(uid, queries, - pkgmgr_common::database::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB, - pkgmgr_common::database::AbstractDBHandler::OperationType::OPERATION_TYPE_WRITE)); - - pkgmgr_client::PkgInfoClient client(parcelable, uid, - pkgmgr_common::ReqType::QUERY); - if (!client.SendRequest()) { - return PMINFO_R_ERROR; - } - - auto ptr = client.GetResultParcel(); - if (ptr == nullptr) { - LOG(ERROR) << "Fail to get return parcelable"; - return PMINFO_R_ERROR; - } - - if (ptr->GetRequestResult() != PMINFO_R_OK) { - LOG(ERROR) << "Request fail"; - return ptr->GetRequestResult(); - } - - if (ptr->GetType() != pkgmgr_common::parcel::ParcelableType::Result) { - LOG(ERROR) << "Invalid parcelable type"; - return PMINFO_R_ERROR; - } - - return PMINFO_R_OK; +extern "C" EXPORT_API int _pkginfo_set_usr_installed_storage(const char* pkgid, + INSTALL_LOCATION location, const char* external_pkg_path, uid_t uid) { + char* query = nullptr; + const char* location_str; + std::vector queries; + + if (location == INSTALL_INTERNAL) + location_str = "installed_internal"; + else if (location == INSTALL_EXTERNAL) + location_str = "installed_external"; + else + location_str = "installed_extended"; + /* pkgcakge_info table */ + query = sqlite3_mprintf( + "UPDATE package_info SET installed_storage=%Q, external_path=%Q " + "WHERE package=%Q", + location_str, external_pkg_path, pkgid); + queries.emplace_back(query); + sqlite3_free(query); + + /* package_app_info table */ + query = sqlite3_mprintf( + "UPDATE package_app_info SET app_installed_storage=%Q, " + "app_external_path=%Q WGERE package=%Q", + location_str, external_pkg_path, pkgid); + queries.emplace_back(query); + sqlite3_free(query); + + std::shared_ptr parcelable( + new pcp::QueryParcelable(uid, queries, + pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB, + pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_WRITE)); + + pkgmgr_client::PkgInfoClient client(parcelable, uid, + pkgmgr_common::ReqType::QUERY); + if (!client.SendRequest()) + return PMINFO_R_ERROR; + + auto ptr = client.GetResultParcel(); + if (ptr == nullptr) { + LOG(ERROR) << "Fail to get return parcelable"; + return PMINFO_R_ERROR; + } + + if (ptr->GetRequestResult() != PMINFO_R_OK) { + LOG(ERROR) << "Request fail"; + return ptr->GetRequestResult(); + } + + if (ptr->GetType() != pcp::ParcelableType::Result) { + LOG(ERROR) << "Invalid parcelable type"; + return PMINFO_R_ERROR; + } + + return PMINFO_R_OK; } -extern "C" EXPORT_API int _certinfo_compare_pkg_certinfo(const char *l_pkgid, - const char *r_pkgid, pkgmgrinfo_cert_compare_result_type_e *result) { - char *query = sqlite3_mprintf("SELECT package, " - "COALESCE(author_signer_cert, -1) FROM package_cert_info WHERE " - "package IN (%Q, %Q)", l_pkgid, r_pkgid); - if (query == nullptr) { - LOG(ERROR) << "Out of memory"; - return PMINFO_R_ERROR; - } - std::vector queries; - queries.emplace_back(query); - sqlite3_free(query); - - std::shared_ptr parcelable( - new pkgmgr_common::parcel::QueryParcelable(0, queries, - pkgmgr_common::database::AbstractDBHandler::DBType::DB_TYPE_FILE_CERTDB, - pkgmgr_common::database::AbstractDBHandler::OperationType::OPERATION_TYPE_READ)); - pkgmgr_client::PkgInfoClient client(parcelable, 0, - pkgmgr_common::ReqType::QUERY); - if (!client.SendRequest()) { - return PMINFO_R_ERROR; - } - - auto ptr = client.GetResultParcel(); - if (ptr == nullptr) { - LOG(ERROR) << "Fail to get return parcelable"; - return PMINFO_R_ERROR; - } - - if (ptr->GetRequestResult() != PMINFO_R_OK) { - LOG(ERROR) << "Request fail"; - return ptr->GetRequestResult(); - } - - if (ptr->GetType() != pkgmgr_common::parcel::ParcelableType::Result) { - LOG(ERROR) << "Invalid parcelable type"; - return PMINFO_R_ERROR; - } - - std::shared_ptr return_parcel( - std::static_pointer_cast( - ptr)); - - auto certinfo_list = return_parcel->GetResult(); - if (certinfo_list.size() != 2) - return PMINFO_R_ERROR; - - std::map result_map; - for (auto& certinfo : certinfo_list) - result_map.insert(make_pair(certinfo.front(), certinfo.back())); - - if (result_map.find(std::string(l_pkgid))->second == "-1" && - result_map.find(std::string(r_pkgid))->second == "-1") - *result = PMINFO_CERT_COMPARE_BOTH_NO_CERT; - else if (result_map.find(std::string(l_pkgid))->second == "-1") - *result = PMINFO_CERT_COMPARE_LHS_NO_CERT; - else if (result_map.find(std::string(r_pkgid))->second == "-1") - *result = PMINFO_CERT_COMPARE_RHS_NO_CERT; - else if (result_map.find(std::string(l_pkgid))->second == - result_map.find(std::string(r_pkgid))->second) - *result = PMINFO_CERT_COMPARE_MATCH; - else - *result = PMINFO_CERT_COMPARE_MISMATCH; - - return PMINFO_R_OK; +extern "C" EXPORT_API int _certinfo_compare_pkg_certinfo(const char* l_pkgid, + const char* r_pkgid, pkgmgrinfo_cert_compare_result_type_e* result) { + char* query = sqlite3_mprintf("SELECT package, " + "COALESCE(author_signer_cert, -1) FROM package_cert_info WHERE " + "package IN (%Q, %Q)", + l_pkgid, r_pkgid); + if (query == nullptr) { + LOG(ERROR) << "Out of memory"; + return PMINFO_R_ERROR; + } + std::vector queries; + queries.emplace_back(query); + sqlite3_free(query); + + std::shared_ptr parcelable( + new pcp::QueryParcelable(0, queries, + pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_CERTDB, + pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_READ)); + pkgmgr_client::PkgInfoClient client(parcelable, 0, + pkgmgr_common::ReqType::QUERY); + if (!client.SendRequest()) + return PMINFO_R_ERROR; + + auto ptr = client.GetResultParcel(); + if (ptr == nullptr) { + LOG(ERROR) << "Fail to get return parcelable"; + return PMINFO_R_ERROR; + } + + if (ptr->GetRequestResult() != PMINFO_R_OK) { + LOG(ERROR) << "Request fail"; + return ptr->GetRequestResult(); + } + + if (ptr->GetType() != pcp::ParcelableType::Result) { + LOG(ERROR) << "Invalid parcelable type"; + return PMINFO_R_ERROR; + } + + std::shared_ptr return_parcel( + std::static_pointer_cast( + ptr)); + + auto certinfo_list = return_parcel->GetResult(); + if (certinfo_list.size() != 2) + return PMINFO_R_ERROR; + + std::map result_map; + for (auto &certinfo : certinfo_list) + result_map.insert(make_pair(certinfo.front(), certinfo.back())); + + if (result_map.find(std::string(l_pkgid))->second == "-1" && + result_map.find(std::string(r_pkgid))->second == "-1") + *result = PMINFO_CERT_COMPARE_BOTH_NO_CERT; + else if (result_map.find(std::string(l_pkgid))->second == "-1") + *result = PMINFO_CERT_COMPARE_LHS_NO_CERT; + else if (result_map.find(std::string(r_pkgid))->second == "-1") + *result = PMINFO_CERT_COMPARE_RHS_NO_CERT; + else if (result_map.find(std::string(l_pkgid))->second == + result_map.find(std::string(r_pkgid))->second) + *result = PMINFO_CERT_COMPARE_MATCH; + else + *result = PMINFO_CERT_COMPARE_MISMATCH; + + return PMINFO_R_OK; } extern "C" EXPORT_API int _certinfo_compare_app_certinfo(uid_t uid, - const char *l_appid, const char *r_appid, - pkgmgrinfo_cert_compare_result_type_e *result) { - char* query = sqlite3_mprintf("SELECT app_id, package FROM " - "package_app_info WHERE app_id IN (%Q, %Q)", l_appid, r_appid); - if (query == nullptr) { - LOG(ERROR) << "Out of memory"; - return PMINFO_R_ERROR; - } - std::vector queries; - queries.emplace_back(query); - sqlite3_free(query); - - std::shared_ptr parcelable( - new pkgmgr_common::parcel::QueryParcelable(uid, queries, - pkgmgr_common::database::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB, - pkgmgr_common::database::AbstractDBHandler::OperationType::OPERATION_TYPE_READ)); - pkgmgr_client::PkgInfoClient client(parcelable, uid, - pkgmgr_common::ReqType::QUERY); - if (!client.SendRequest()) { - return PMINFO_R_ERROR; - } - - auto ptr = client.GetResultParcel(); - if (ptr == nullptr) { - LOG(ERROR) << "Fail to get return parcelable"; - return PMINFO_R_ERROR; - } - - if (ptr->GetRequestResult() != PMINFO_R_OK) { - LOG(ERROR) << "Request fail"; - return ptr->GetRequestResult(); - } - - if (ptr->GetType() != pkgmgr_common::parcel::ParcelableType::Result) { - LOG(ERROR) << "Invalid parcelable type"; - return PMINFO_R_ERROR; - } - - std::shared_ptr return_parcel( - std::static_pointer_cast( - ptr)); - - auto pkgid_list = return_parcel->GetResult(); - std::map result_map; - for (auto& pkgid : pkgid_list) - result_map.insert(make_pair(pkgid.front(), pkgid.back())); - - if (result_map.find(std::string(l_appid)) == result_map.end()) { - LOG(ERROR) << "Cannot find pkgid of app " << l_appid - << " for uid " << uid; - return PMINFO_R_ENOENT; - } else if (result_map.find(std::string(r_appid)) == result_map.end()) { - LOG(ERROR) << "Cannot find pkgid of app " << r_appid - << " for uid " << uid; - return PMINFO_R_ENOENT; - } - - const char* l_pkgid = result_map.find( - std::string(l_appid))->second.c_str(); - const char* r_pkgid = result_map.find( - std::string(r_appid))->second.c_str(); - - return _certinfo_compare_pkg_certinfo(l_pkgid, r_pkgid, result); + const char* l_appid, const char* r_appid, + pkgmgrinfo_cert_compare_result_type_e* result) { + char* query = sqlite3_mprintf("SELECT app_id, package FROM " + "package_app_info WHERE app_id IN (%Q, %Q)", + l_appid, r_appid); + if (query == nullptr) { + LOG(ERROR) << "Out of memory"; + return PMINFO_R_ERROR; + } + std::vector queries; + queries.emplace_back(query); + sqlite3_free(query); + + std::shared_ptr parcelable( + new pcp::QueryParcelable(uid, queries, + pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB, + pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_READ)); + pkgmgr_client::PkgInfoClient client(parcelable, uid, + pkgmgr_common::ReqType::QUERY); + if (!client.SendRequest()) + return PMINFO_R_ERROR; + + auto ptr = client.GetResultParcel(); + if (ptr == nullptr) { + LOG(ERROR) << "Fail to get return parcelable"; + return PMINFO_R_ERROR; + } + + if (ptr->GetRequestResult() != PMINFO_R_OK) { + LOG(ERROR) << "Request fail"; + return ptr->GetRequestResult(); + } + + if (ptr->GetType() != pcp::ParcelableType::Result) { + LOG(ERROR) << "Invalid parcelable type"; + return PMINFO_R_ERROR; + } + + std::shared_ptr return_parcel( + std::static_pointer_cast(ptr)); + + auto pkgid_list = return_parcel->GetResult(); + std::map result_map; + for (auto &pkgid : pkgid_list) + result_map.insert(make_pair(pkgid.front(), pkgid.back())); + + if (result_map.find(std::string(l_appid)) == result_map.end()) { + LOG(ERROR) << "Cannot find pkgid of app " << l_appid + << " for uid " << uid; + return PMINFO_R_ENOENT; + } else if (result_map.find(std::string(r_appid)) == result_map.end()) { + LOG(ERROR) << "Cannot find pkgid of app " << r_appid + << " for uid " << uid; + return PMINFO_R_ENOENT; + } + + const char* l_pkgid = result_map.find(std::string(l_appid))->second.c_str(); + const char* r_pkgid = result_map.find(std::string(r_appid))->second.c_str(); + + return _certinfo_compare_pkg_certinfo(l_pkgid, r_pkgid, result); } -extern "C" EXPORT_API int _parser_execute_write_query(const char *query, uid_t uid) -{ - std::shared_ptr parcelable( - new pkgmgr_common::parcel::QueryParcelable(uid, query, - pkgmgr_common::database::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB, - pkgmgr_common::database::AbstractDBHandler::OperationType::OPERATION_TYPE_WRITE)); - - pkgmgr_client::PkgInfoClient client(parcelable, uid, - pkgmgr_common::ReqType::QUERY); - if (!client.SendRequest()) { - return -1; - } - - auto ptr = client.GetResultParcel(); - if (ptr == nullptr) { - LOG(ERROR) << "Fail to get return parcelable"; - return -1; - } - - if (ptr->GetRequestResult() != PMINFO_R_OK) { - LOG(ERROR) << "Request fail"; - return -1; - } - - if (ptr->GetType() != pkgmgr_common::parcel::ParcelableType::Result) { - LOG(ERROR) << "Invalid parcelable type"; - return -1; - } - - return 0; +extern "C" EXPORT_API int _parser_execute_write_query( + const char* query, uid_t uid) { + std::shared_ptr parcelable( + new pcp::QueryParcelable(uid, query, + pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB, + pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_WRITE)); + + pkgmgr_client::PkgInfoClient client(parcelable, uid, + pkgmgr_common::ReqType::QUERY); + if (!client.SendRequest()) + return -1; + + auto ptr = client.GetResultParcel(); + if (ptr == nullptr) { + LOG(ERROR) << "Fail to get return parcelable"; + return -1; + } + + if (ptr->GetRequestResult() != PMINFO_R_OK) { + LOG(ERROR) << "Request fail"; + return -1; + } + + if (ptr->GetType() != pcp::ParcelableType::Result) { + LOG(ERROR) << "Invalid parcelable type"; + return -1; + } + + return 0; } -extern "C" EXPORT_API int _parser_execute_write_queries(const char **queries, int len, uid_t uid) -{ - std::vector query_vt; - for (int i = 0; i < len; ++i) - query_vt.emplace_back(queries[i]); - - std::shared_ptr parcelable( - new pkgmgr_common::parcel::QueryParcelable(uid, query_vt, - pkgmgr_common::database::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB, - pkgmgr_common::database::AbstractDBHandler::OperationType::OPERATION_TYPE_WRITE)); - - pkgmgr_client::PkgInfoClient client(parcelable, uid, - pkgmgr_common::ReqType::QUERY); - if (!client.SendRequest()) { - return -1; - } - - auto ptr = client.GetResultParcel(); - if (ptr == nullptr) { - LOG(ERROR) << "Fail to get return parcelable"; - return -1; - } - - if (ptr->GetRequestResult() != PMINFO_R_OK) { - LOG(ERROR) << "Request fail"; - return -1; - } - - if (ptr->GetType() != pkgmgr_common::parcel::ParcelableType::Result) { - LOG(ERROR) << "Invalid parcelable type"; - return -1; - } - - return 0; +extern "C" EXPORT_API int _parser_execute_write_queries( + const char** queries, int len, uid_t uid) { + std::vector query_vt; + for (int i = 0; i < len; ++i) + query_vt.emplace_back(queries[i]); + + std::shared_ptr parcelable( + new pcp::QueryParcelable(uid, query_vt, + pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB, + pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_WRITE)); + + pkgmgr_client::PkgInfoClient client(parcelable, uid, + pkgmgr_common::ReqType::QUERY); + if (!client.SendRequest()) + return -1; + + auto ptr = client.GetResultParcel(); + if (ptr == nullptr) { + LOG(ERROR) << "Fail to get return parcelable"; + return -1; + } + + if (ptr->GetRequestResult() != PMINFO_R_OK) { + LOG(ERROR) << "Request fail"; + return -1; + } + + if (ptr->GetType() != pcp::ParcelableType::Result) { + LOG(ERROR) << "Invalid parcelable type"; + return -1; + } + + return 0; } -extern "C" EXPORT_API int _parser_insert_manifest_info(manifest_x *mfx, uid_t uid) -{ - auto parcelable = - std::make_shared(uid, - std::vector{ mfx }, WriteType::Insert, false); - - pkgmgr_client::PkgInfoClient client(parcelable, uid, - pkgmgr_common::ReqType::SET_PKG_INFO); - if (!client.SendRequest()) { - return -1; - } - - auto ptr = client.GetResultParcel(); - if (ptr == nullptr) { - LOG(ERROR) << "Fail to get return parcelable"; - return -1; - } - - if (ptr->GetRequestResult() != PMINFO_R_OK) { - LOG(ERROR) << "Request fail"; - return -1; - } - - if (ptr->GetType() != pkgmgr_common::parcel::ParcelableType::Result) { - LOG(ERROR) << "Invalid parcelable type"; - return -1; - } - - return 0; +extern "C" EXPORT_API int _parser_insert_manifest_info( + manifest_x* mfx, uid_t uid) { + auto parcelable = + std::make_shared(uid, + std::vector{mfx}, WriteType::Insert, false); + + pkgmgr_client::PkgInfoClient client(parcelable, uid, + pkgmgr_common::ReqType::SET_PKG_INFO); + if (!client.SendRequest()) + return -1; + + auto ptr = client.GetResultParcel(); + if (ptr == nullptr) { + LOG(ERROR) << "Fail to get return parcelable"; + return -1; + } + + if (ptr->GetRequestResult() != PMINFO_R_OK) { + LOG(ERROR) << "Request fail"; + return -1; + } + + if (ptr->GetType() != pcp::ParcelableType::Result) { + LOG(ERROR) << "Invalid parcelable type"; + return -1; + } + + return 0; } -extern "C" EXPORT_API int _parser_update_manifest_info(manifest_x *mfx, uid_t uid) -{ - auto parcelable = - std::make_shared(uid, - std::vector{ mfx }, WriteType::Update, false); - - pkgmgr_client::PkgInfoClient client(parcelable, uid, - pkgmgr_common::ReqType::SET_PKG_INFO); - if (!client.SendRequest()) { - return -1; - } - - auto ptr = client.GetResultParcel(); - if (ptr == nullptr) { - LOG(ERROR) << "Fail to get return parcelable"; - return -1; - } - - if (ptr->GetRequestResult() != PMINFO_R_OK) { - LOG(ERROR) << "Request fail"; - return -1; - } - - if (ptr->GetType() != pkgmgr_common::parcel::ParcelableType::Result) { - LOG(ERROR) << "Invalid parcelable type"; - return -1; - } - - return 0; +extern "C" EXPORT_API int _parser_update_manifest_info( + manifest_x* mfx, uid_t uid) { + auto parcelable = + std::make_shared(uid, + std::vector{mfx}, WriteType::Update, false); + + pkgmgr_client::PkgInfoClient client(parcelable, uid, + pkgmgr_common::ReqType::SET_PKG_INFO); + if (!client.SendRequest()) + return -1; + + auto ptr = client.GetResultParcel(); + if (ptr == nullptr) { + LOG(ERROR) << "Fail to get return parcelable"; + return -1; + } + + if (ptr->GetRequestResult() != PMINFO_R_OK) { + LOG(ERROR) << "Request fail"; + return -1; + } + + if (ptr->GetType() != pcp::ParcelableType::Result) { + LOG(ERROR) << "Invalid parcelable type"; + return -1; + } + + return 0; } -extern "C" EXPORT_API int _parser_delete_manifest_info(manifest_x *mfx, uid_t uid) -{ - auto parcelable = - std::make_shared(uid, - std::vector{ mfx }, WriteType::Delete, false); - - pkgmgr_client::PkgInfoClient client(parcelable, uid, - pkgmgr_common::ReqType::SET_PKG_INFO); - if (!client.SendRequest()) { - return -1; - } - - auto ptr = client.GetResultParcel(); - if (ptr == nullptr) { - LOG(ERROR) << "Fail to get return parcelable"; - return -1; - } - - if (ptr->GetRequestResult() != PMINFO_R_OK) { - LOG(ERROR) << "Request fail"; - return -1; - } - - if (ptr->GetType() != pkgmgr_common::parcel::ParcelableType::Result) { - LOG(ERROR) << "Invalid parcelable type"; - return -1; - } - - return 0; +extern "C" EXPORT_API int _parser_delete_manifest_info( + manifest_x* mfx, uid_t uid) { + auto parcelable = + std::make_shared(uid, + std::vector{mfx}, WriteType::Delete, false); + + pkgmgr_client::PkgInfoClient client(parcelable, uid, + pkgmgr_common::ReqType::SET_PKG_INFO); + if (!client.SendRequest()) + return -1; + + auto ptr = client.GetResultParcel(); + if (ptr == nullptr) { + LOG(ERROR) << "Fail to get return parcelable"; + return -1; + } + + if (ptr->GetRequestResult() != PMINFO_R_OK) { + LOG(ERROR) << "Request fail"; + return -1; + } + + if (ptr->GetType() != pcp::ParcelableType::Result) { + LOG(ERROR) << "Invalid parcelable type"; + return -1; + } + + return 0; } extern "C" EXPORT_API int _pkginfo_insert_certinfo(const char* pkgid, - pkgmgr_certinfo_x* cert, uid_t uid) -{ - std::shared_ptr parcelable( - new pkgmgr_common::parcel::CertInfoParcelable(uid, cert, false)); - - pkgmgr_client::PkgInfoClient client(parcelable, uid, - pkgmgr_common::ReqType::SET_CERT_INFO); - if (!client.SendRequest()) - return PMINFO_R_ERROR; - - auto ptr = client.GetResultParcel(); - if (ptr == nullptr) { - LOG(ERROR) << "Fail to get return parcelable"; - return PMINFO_R_ERROR; - } - - if (ptr->GetRequestResult() != PMINFO_R_OK) { - LOG(ERROR) << "Request fail"; - return ptr->GetRequestResult(); - } - - if (ptr->GetType() != pkgmgr_common::parcel::ParcelableType::Result) { - LOG(ERROR) << "Invalid parcelable type"; - return PMINFO_R_ERROR; - } - - return PMINFO_R_OK; + pkgmgr_certinfo_x* cert, uid_t uid) { + std::shared_ptr parcelable( + new pcp::CertInfoParcelable(uid, cert, false)); + pkgmgr_client::PkgInfoClient client(parcelable, uid, + pkgmgr_common::ReqType::SET_CERT_INFO); + + if (!client.SendRequest()) + return PMINFO_R_ERROR; + + auto ptr = client.GetResultParcel(); + if (ptr == nullptr) { + LOG(ERROR) << "Fail to get return parcelable"; + return PMINFO_R_ERROR; + } + + if (ptr->GetRequestResult() != PMINFO_R_OK) { + LOG(ERROR) << "Request fail"; + return ptr->GetRequestResult(); + } + + if (ptr->GetType() != pcp::ParcelableType::Result) { + LOG(ERROR) << "Invalid parcelable type"; + return PMINFO_R_ERROR; + } + + return PMINFO_R_OK; } -extern "C" EXPORT_API int _pkginfo_get_certinfo(const char *pkgid, - pkgmgr_certinfo_x* cert, uid_t uid) -{ - std::shared_ptr parcelable( - new pkgmgr_common::parcel::CertInfoParcelable(uid, - std::string(pkgid))); - - pkgmgr_client::PkgInfoClient client(parcelable, uid, - pkgmgr_common::ReqType::GET_CERT_INFO); - if (!client.SendRequest()) - return PMINFO_R_ERROR; - - auto ptr = client.GetResultParcel(); - if (ptr == nullptr) { - LOG(ERROR) << "Fail to get return parcelable"; - return PMINFO_R_ERROR; - } - - if (ptr->GetRequestResult() != PMINFO_R_OK) { - LOG(ERROR) << "Request fail"; - return ptr->GetRequestResult(); - } - - if (ptr->GetType() != pkgmgr_common::parcel::ParcelableType::CertInfo) { - LOG(ERROR) << "Invalid parcelable type"; - return PMINFO_R_ERROR; - } - - std::shared_ptr return_parcel( - std::static_pointer_cast( - ptr)); - - pkgmgr_certinfo_x *certinfo = return_parcel->ExtractCertInfo(); - if (certinfo == nullptr) - return PMINFO_R_ERROR; - - cert->for_all_users = certinfo->for_all_users; - cert->pkgid = certinfo->pkgid; - certinfo->pkgid = nullptr; - cert->cert_value = certinfo->cert_value; - certinfo->cert_value = nullptr; - for (int i = 0; i < MAX_CERT_TYPE; i++) { - cert->cert_info[i] = certinfo->cert_info[i]; - certinfo->cert_info[i] = nullptr; - } - for (int i = 0; i < MAX_CERT_TYPE; i++) - cert->cert_id[i] = certinfo->cert_id[i]; - - free(certinfo); - - return PMINFO_R_OK; +extern "C" EXPORT_API int _pkginfo_get_certinfo(const char* pkgid, + pkgmgr_certinfo_x* cert, uid_t uid) { + std::shared_ptr parcelable( + new pcp::CertInfoParcelable(uid, + std::string(pkgid))); + + pkgmgr_client::PkgInfoClient client(parcelable, uid, + pkgmgr_common::ReqType::GET_CERT_INFO); + if (!client.SendRequest()) + return PMINFO_R_ERROR; + + auto ptr = client.GetResultParcel(); + if (ptr == nullptr) { + LOG(ERROR) << "Fail to get return parcelable"; + return PMINFO_R_ERROR; + } + + if (ptr->GetRequestResult() != PMINFO_R_OK) { + LOG(ERROR) << "Request fail"; + return ptr->GetRequestResult(); + } + + if (ptr->GetType() != pcp::ParcelableType::CertInfo) { + LOG(ERROR) << "Invalid parcelable type"; + return PMINFO_R_ERROR; + } + + std::shared_ptr return_parcel( + std::static_pointer_cast(ptr)); + + pkgmgr_certinfo_x* certinfo = return_parcel->ExtractCertInfo(); + if (certinfo == nullptr) + return PMINFO_R_ERROR; + + cert->for_all_users = certinfo->for_all_users; + cert->pkgid = certinfo->pkgid; + certinfo->pkgid = nullptr; + cert->cert_value = certinfo->cert_value; + certinfo->cert_value = nullptr; + for (int i = 0; i < MAX_CERT_TYPE; i++) { + cert->cert_info[i] = certinfo->cert_info[i]; + certinfo->cert_info[i] = nullptr; + } + for (int i = 0; i < MAX_CERT_TYPE; i++) + cert->cert_id[i] = certinfo->cert_id[i]; + + free(certinfo); + + return PMINFO_R_OK; } -extern "C" EXPORT_API int _pkginfo_delete_certinfo(const char *pkgid) -{ - char* query = sqlite3_mprintf("UPDATE package_cert_info SET " - "package_count = package_count - 1 WHERE package=%Q", pkgid); - if (query == nullptr) { - LOG(ERROR) << "Out of memory"; - return PMINFO_R_ERROR; - } - - std::vector queries; - queries.emplace_back(query); - sqlite3_free(query); - - std::shared_ptr parcelable( - new pkgmgr_common::parcel::QueryParcelable(0, queries, - pkgmgr_common::database::AbstractDBHandler::DBType::DB_TYPE_FILE_CERTDB, - pkgmgr_common::database::AbstractDBHandler::OperationType::OPERATION_TYPE_WRITE)); - - pkgmgr_client::PkgInfoClient client(parcelable, 0, - pkgmgr_common::ReqType::QUERY); - if (!client.SendRequest()) { - return PMINFO_R_ERROR; - } - - auto ptr = client.GetResultParcel(); - if (ptr == nullptr) { - LOG(ERROR) << "Fail to get return parcelable"; - return PMINFO_R_ERROR; - } - - if (ptr->GetRequestResult() != PMINFO_R_OK) { - LOG(ERROR) << "Request fail"; - return PMINFO_R_ERROR; - } - - if (ptr->GetType() != pkgmgr_common::parcel::ParcelableType::Result) { - LOG(ERROR) << "Invalid parcelable type"; - return PMINFO_R_ERROR; - } - - return PMINFO_R_OK; +extern "C" EXPORT_API int _pkginfo_delete_certinfo(const char* pkgid) { + char* query = sqlite3_mprintf("UPDATE package_cert_info SET " + "package_count = package_count - 1 WHERE package=%Q", pkgid); + if (query == nullptr) { + LOG(ERROR) << "Out of memory"; + return PMINFO_R_ERROR; + } + + std::vector queries; + queries.emplace_back(query); + sqlite3_free(query); + + std::shared_ptr parcelable( + new pcp::QueryParcelable(0, queries, + pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_CERTDB, + pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_WRITE)); + + pkgmgr_client::PkgInfoClient client(parcelable, 0, + pkgmgr_common::ReqType::QUERY); + if (!client.SendRequest()) + return PMINFO_R_ERROR; + + auto ptr = client.GetResultParcel(); + if (ptr == nullptr) { + LOG(ERROR) << "Fail to get return parcelable"; + return PMINFO_R_ERROR; + } + + if (ptr->GetRequestResult() != PMINFO_R_OK) { + LOG(ERROR) << "Request fail"; + return PMINFO_R_ERROR; + } + + if (ptr->GetType() != pcp::ParcelableType::Result) { + LOG(ERROR) << "Invalid parcelable type"; + return PMINFO_R_ERROR; + } + + return PMINFO_R_OK; } -extern "C" EXPORT_API int _parser_clear_cache_memory_db(uid_t uid) -{ - std::shared_ptr parcelable( - new pkgmgr_common::parcel::CommandParcelable(uid, CommandType::RemoveCache)); +extern "C" EXPORT_API int _parser_clear_cache_memory_db(uid_t uid) { + std::shared_ptr parcelable( + new pcp::CommandParcelable(uid, CommandType::RemoveCache)); - pkgmgr_client::PkgInfoClient client(parcelable, uid, - pkgmgr_common::ReqType::COMMAND); + pkgmgr_client::PkgInfoClient client(parcelable, uid, + pkgmgr_common::ReqType::COMMAND); - if (!client.SendRequest()) { - return PMINFO_R_ERROR; - } + if (!client.SendRequest()) + return PMINFO_R_ERROR; - auto ptr = client.GetResultParcel(); - if (ptr == nullptr) { - LOG(ERROR) << "Fail to get return parcelable"; - return PMINFO_R_ERROR; - } + auto ptr = client.GetResultParcel(); + if (ptr == nullptr) { + LOG(ERROR) << "Fail to get return parcelable"; + return PMINFO_R_ERROR; + } - if (ptr->GetRequestResult() != PMINFO_R_OK) { - LOG(ERROR) << "Request fail"; - return PMINFO_R_ERROR; - } + if (ptr->GetRequestResult() != PMINFO_R_OK) { + LOG(ERROR) << "Request fail"; + return PMINFO_R_ERROR; + } - if (ptr->GetType() != pkgmgr_common::parcel::ParcelableType::Result) { - LOG(ERROR) << "Invalid parcelable type"; - return PMINFO_R_ERROR; - } + if (ptr->GetType() != pcp::ParcelableType::Result) { + LOG(ERROR) << "Invalid parcelable type"; + return PMINFO_R_ERROR; + } - return PMINFO_R_OK; + return PMINFO_R_OK; } -- 2.7.4