+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) });
+ }
+
+ std::shared_ptr<pcp::AbstractParcelable> parcelable(
+ new pcp::QueryParcelable(uid, queries,
+ 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_insert_manifest_info(
+ manifest_x* mfx, uid_t uid) {
+ auto parcelable =
+ std::make_shared<pcp::PkgInfoParcelable>(uid,
+ std::vector<std::shared_ptr<package_x>>(1,
+ std::shared_ptr<package_x>(mfx, [] (package_x*) -> void {})),
+ pkgmgr_common::PkgWriteType::Insert, false);
+
+ pkgmgr_client::PkgInfoClient client(parcelable, uid,
+ pkgmgr_common::ReqType::SET_PKG_INFO);
+ if (!client.SendRequest())
+ return PMINFO_R_ERROR;
+
+ return ValidateParcelable(
+ client.GetResultParcel(), pcp::ParcelableType::Result);
+}
+
+extern "C" EXPORT_API int _parser_update_manifest_info(
+ manifest_x* mfx, uid_t uid) {
+ auto parcelable =
+ std::make_shared<pcp::PkgInfoParcelable>(uid,
+ std::vector<std::shared_ptr<package_x>>(1,
+ std::shared_ptr<package_x>(mfx, [] (package_x*) -> void {})),
+ pkgmgr_common::PkgWriteType::Update, false);
+
+ pkgmgr_client::PkgInfoClient client(parcelable, uid,
+ pkgmgr_common::ReqType::SET_PKG_INFO);
+ if (!client.SendRequest())
+ return PMINFO_R_ERROR;
+
+ return ValidateParcelable(
+ client.GetResultParcel(), pcp::ParcelableType::Result);
+}
+
+extern "C" EXPORT_API int _parser_delete_manifest_info(
+ manifest_x* mfx, uid_t uid) {
+ auto parcelable =
+ std::make_shared<pcp::PkgInfoParcelable>(uid,
+ std::vector<std::shared_ptr<package_x>>(1,
+ std::shared_ptr<package_x>(mfx, [] (package_x*) -> void {})),
+ pkgmgr_common::PkgWriteType::Delete, false);
+
+ pkgmgr_client::PkgInfoClient client(parcelable, uid,
+ pkgmgr_common::ReqType::SET_PKG_INFO);
+ if (!client.SendRequest())
+ return PMINFO_R_ERROR;
+
+ return ValidateParcelable(
+ client.GetResultParcel(), pcp::ParcelableType::Result);
+}
+
+extern "C" EXPORT_API int _pkginfo_insert_certinfo(const char* pkgid,
+ pkgmgr_certinfo_x* cert, uid_t uid) {
+ std::shared_ptr<pcp::AbstractParcelable> 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;
+
+ return ValidateParcelable(
+ client.GetResultParcel(), pcp::ParcelableType::Result);
+}
+
+extern "C" EXPORT_API int _pkginfo_get_certinfo(const char* pkgid,
+ pkgmgr_certinfo_x* cert, uid_t uid) {
+ std::shared_ptr<pcp::AbstractParcelable> 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();
+ int ret = ValidateParcelable(ptr, pcp::ParcelableType::CertInfo);
+ if (ret != PMINFO_R_OK)
+ return ret;
+
+ std::shared_ptr<pcp::CertInfoParcelable> return_parcel(
+ std::static_pointer_cast<pcp::CertInfoParcelable>(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) {
+ std::shared_ptr<pcp::AbstractParcelable> parcelable(
+ new pcp::QueryParcelable(0,
+ { QUERY_INDEX_PKGINFO_DELETE_CERTINFO, { pkgid } },
+ pkgmgr_common::DBType::DB_TYPE_FILE_CERTDB,
+ pkgmgr_common::DBOperationType::OPERATION_TYPE_WRITE));
+
+ pkgmgr_client::PkgInfoClient client(parcelable, 0,
+ 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_update_pending_cache(const char* pkgid) {
+ std::shared_ptr<pcp::AbstractParcelable> parcelable(
+ new pcp::CommandParcelable(_getuid(),
+ CommandType::UpdatePendingCache, { pkgid }));
+
+ pkgmgr_client::PkgInfoClient client(parcelable, _getuid(),
+ pkgmgr_common::ReqType::COMMAND);
+
+ if (!client.SendRequest())
+ return PMINFO_R_ERROR;
+
+ return ValidateParcelable(
+ client.GetResultParcel(), pcp::ParcelableType::Result);
+}
+
+static int __create_and_initialize_db(uid_t uid) {
+ std::shared_ptr<pcp::AbstractParcelable> parcelable(
+ new pcp::CreateDBParcelable(uid));
+
+ pkgmgr_client::PkgInfoClient client(parcelable, _getuid(),
+ pkgmgr_common::ReqType::CREATE_DB);
+
+ if (!client.SendRequest())
+ return PMINFO_R_ERROR;
+
+ return ValidateParcelable(
+ client.GetResultParcel(), pcp::ParcelableType::Result);
+}
+
+extern "C" EXPORT_API int _parser_create_and_initialize_db(uid_t uid) {
+ if (__create_and_initialize_db(uid) < 0) {
+ LOG(ERROR) << "Fail to initialize db";
+ return PMINFO_R_ERROR;
+ }
+
+ return PMINFO_R_OK;