+
+ updateinfo_x* update_info = reinterpret_cast<updateinfo_x*>(
+ calloc(1, sizeof(updateinfo_x)));
+ if (update_info == nullptr) {
+ LOG(ERROR) << "Out of memory";
+ g_slist_free_full(tmp_list, __free_update_info);
+ 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);
+ g_slist_free_full(tmp_list, __free_update_info);
+ return PMINFO_R_ERROR;
+ }
+
+ update_info->type = static_cast<int>(convert_type);
+ tmp_list = g_slist_append(tmp_list, update_info);
+ }
+
+ *update_info_list = tmp_list;
+ 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) {
+ const char* location_str;
+
+ if (location == INSTALL_INTERNAL)
+ location_str = "installed_internal";
+ else if (location == INSTALL_EXTERNAL)
+ location_str = "installed_external";
+ else
+ location_str = "installed_extended";
+
+ std::shared_ptr<pcp::AbstractParcelable> parcelable(
+ new pcp::QueryParcelable(uid, { {
+ QUERY_INDEX_PKGINFO_SET_USR_INSTALLED_STORAGE_1, {
+ location_str,
+ external_pkg_path,
+ pkgid
+ }
+ }, {
+ QUERY_INDEX_PKGINFO_SET_USR_INSTALLED_STORAGE_2, {
+ location_str,
+ external_pkg_path,
+ pkgid
+ }
+ },
+ },
+ pkgmgr_common::DBType::DB_TYPE_FILE_PKGDB,
+ pkgmgr_common::DBOperationType::OPERATION_TYPE_WRITE));
+
+ pkgmgr_client::PkgInfoClient client(parcelable, uid,
+ pkgmgr_common::ReqType::WRITE_QUERY);
+ if (!client.SendRequest())
+ return PMINFO_R_ERROR;
+
+ return ValidateParcelable(
+ client.GetResultParcel(), pcp::ParcelableType::Result);
+}
+
+extern "C" EXPORT_API int _certinfo_compare_pkg_certinfo(const char* l_pkgid,
+ const char* r_pkgid, pkgmgrinfo_cert_compare_result_type_e* result) {
+ std::shared_ptr<pcp::AbstractParcelable> parcelable(
+ new pcp::QueryParcelable(0,
+ { QUERY_INDEX_CERTINFO_COMPARE_PKG_CERTINFO, { l_pkgid, r_pkgid } },
+ pkgmgr_common::DBType::DB_TYPE_FILE_CERTDB,
+ pkgmgr_common::DBOperationType::OPERATION_TYPE_READ));
+ pkgmgr_client::PkgInfoClient client(parcelable, 0,
+ pkgmgr_common::ReqType::READ_QUERY);
+ if (!client.SendRequest())
+ return PMINFO_R_ERROR;
+
+ auto ptr = client.GetResultParcel();
+ int ret = ValidateParcelable(ptr, pcp::ParcelableType::Result);
+ if (ret != PMINFO_R_OK)
+ return ret;
+
+ std::shared_ptr<pcp::ResultParcelable> return_parcel(
+ std::static_pointer_cast<pcp::ResultParcelable>(
+ ptr));
+
+ auto& certinfo_list = return_parcel->GetResult();
+
+ std::map<std::string, std::string> result_map;
+ result_map.insert(make_pair(std::string(l_pkgid), "-1"));
+ result_map.insert(make_pair(std::string(r_pkgid), "-1"));
+
+ for (auto& certinfo : certinfo_list)
+ result_map[*certinfo.front()] = *certinfo.back();
+
+ auto l_iter = result_map.find(l_pkgid);
+ auto r_iter = result_map.find(r_pkgid);
+ if (l_iter->second == "-1" && r_iter->second == "-1")
+ *result = PMINFO_CERT_COMPARE_BOTH_NO_CERT;
+ else if (l_iter->second == "-1")
+ *result = PMINFO_CERT_COMPARE_LHS_NO_CERT;
+ else if (r_iter->second == "-1")
+ *result = PMINFO_CERT_COMPARE_RHS_NO_CERT;
+ else if (l_iter->second == r_iter->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) {
+ std::shared_ptr<pcp::AbstractParcelable> parcelable(
+ new pcp::QueryParcelable(uid,
+ { QUERY_INDEX_CERTINFO_COMPARE_APP_CERTINFO, { l_appid, r_appid } },
+ pkgmgr_common::DBType::DB_TYPE_FILE_PKGDB,
+ pkgmgr_common::DBOperationType::OPERATION_TYPE_READ));
+ pkgmgr_client::PkgInfoClient client(parcelable, uid,
+ pkgmgr_common::ReqType::READ_QUERY);
+ if (!client.SendRequest())
+ return PMINFO_R_ERROR;
+
+ auto ptr = client.GetResultParcel();
+ int ret = ValidateParcelable(ptr, pcp::ParcelableType::Result);
+ if (ret != PMINFO_R_OK)
+ return ret;
+
+ std::shared_ptr<pcp::ResultParcelable> return_parcel(
+ std::static_pointer_cast<pcp::ResultParcelable>(ptr));
+
+ auto& pkgid_list = return_parcel->GetResult();
+ std::map<std::string, std::string> result_map;
+ for (auto& pkgid : pkgid_list)
+ result_map.insert(make_pair(*pkgid.front(), *pkgid.back()));
+
+ auto l_iter = result_map.find(l_appid);
+ if (l_iter == result_map.end()) {
+ LOG(ERROR) << "Cannot find pkgid of app " << l_appid
+ << " for uid " << uid;
+ return PMINFO_R_ENOENT;
+ }
+ auto r_iter = result_map.find(r_appid);
+ if (r_iter == result_map.end()) {
+ LOG(ERROR) << "Cannot find pkgid of app " << r_appid
+ << " for uid " << uid;
+ return PMINFO_R_ENOENT;
+ }
+
+ const char* l_pkgid = l_iter->second.c_str();
+ const char* r_pkgid = r_iter->second.c_str();
+
+ return _certinfo_compare_pkg_certinfo(l_pkgid, r_pkgid, result);
+}
+
+extern "C" EXPORT_API int _parser_execute_write_query(
+ int query_index, const char** query_args, unsigned int arg_cnt, uid_t uid) {
+ std::vector<const char*> args;
+
+ for (unsigned int i = 0; i < arg_cnt; i++)
+ args.push_back(query_args[i]);
+
+ std::shared_ptr<pcp::AbstractParcelable> parcelable(
+ new pcp::QueryParcelable(uid, { query_index, std::move(args) },
+ pkgmgr_common::DBType::DB_TYPE_FILE_PKGDB,
+ pkgmgr_common::DBOperationType::OPERATION_TYPE_WRITE));
+
+ pkgmgr_client::PkgInfoClient client(parcelable, uid,
+ pkgmgr_common::ReqType::WRITE_QUERY);
+ if (!client.SendRequest())
+ return PMINFO_R_ERROR;
+
+ return ValidateParcelable(
+ client.GetResultParcel(), pcp::ParcelableType::Result);
+}
+
+extern "C" EXPORT_API int _parser_execute_write_queries(
+ int query_index, const char*** query_args, unsigned int arg_cnt,
+ unsigned int query_cnt, uid_t uid) {
+ std::vector<std::pair<int, std::vector<const char*>>> queries;
+
+ for (unsigned int i = 0; i < query_cnt; i++) {
+ std::vector<const char*> args;
+ for (unsigned int j = 0; j < arg_cnt; j++)
+ args.push_back(query_args[i][j]);
+ queries.push_back({ query_index, std::move(args) });