#include "common/parcel/pkginfo_parcelable.hh"
#include "common/parcel/query_parcelable.hh"
#include "common/parcel/result_parcelable.hh"
-#include "logging.hh"
+#include "utils/logging.hh"
#include "pkg_write_type.hh"
#include "db_type.hh"
namespace pcp = pkgmgr_common::parcel;
+namespace {
+
+int ValidateParcelable(
+ std::shared_ptr<pcp::AbstractParcelable> parcel,
+ pcp::ParcelableType parcel_type) {
+ if (parcel == nullptr) {
+ LOG(ERROR) << "Failed to get return parcelable";
+ return PMINFO_R_ERROR;
+ }
+
+ if (parcel->GetType() != parcel_type) {
+ LOG(ERROR) << "Invalid parcelable Type " << parcel->GetType() << ' ' << parcel_type;
+ return PMINFO_R_ERROR;
+ }
+
+ if (parcel->GetRequestResult() != PMINFO_R_OK) {
+ LOG(ERROR) << "Request fail";
+ return parcel->GetRequestResult();
+ }
+
+ return PMINFO_R_OK;
+}
+
+} // namespace
+
extern "C" EXPORT_API int _pkginfo_get_packages(uid_t uid,
pkgmgrinfo_filter_x* filter, int flag, GHashTable* packages) {
std::shared_ptr<pcp::AbstractParcelable> parcelable(
LOG(DEBUG) << "No packages meets given condition for user " << uid;
return PMINFO_R_ENOENT;
}
- for (auto pkginfo : result_list)
- g_hash_table_insert(packages, (gpointer)pkginfo->package,
- (gpointer)pkginfo);
+ for (auto& pkginfo : result_list)
+ g_hash_table_insert(packages, reinterpret_cast<gpointer>(pkginfo->package),
+ reinterpret_cast<gpointer>(pkginfo.get()));
return PMINFO_R_OK;
}
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::DepInfo) {
- LOG(ERROR) << "Invalid parcelable type";
- return PMINFO_R_ERROR;
- }
+ int ret = ValidateParcelable(ptr, pcp::ParcelableType::DepInfo);
+ if (ret != PMINFO_R_OK)
+ return ret;
std::shared_ptr<pcp::DepInfoParcelable> return_parcel(
std::static_pointer_cast<pcp::DepInfoParcelable>(ptr));
std::shared_ptr<pcp::AppInfoParcelable> return_parcel(
std::static_pointer_cast<pcp::AppInfoParcelable>(ptr));
- std::vector<application_x*> result_list = return_parcel->ExtractAppInfo();
- for (application_x* app : result_list)
- g_hash_table_insert(packages, (gpointer)app->appid,
- (gpointer)app);
+ std::vector<std::shared_ptr<application_x>> result_list = return_parcel->ExtractAppInfo();
+ for (auto& app : result_list)
+ g_hash_table_insert(packages, reinterpret_cast<gpointer>(app->appid),
+ reinterpret_cast<gpointer>(app.get()));
return PMINFO_R_OK;
}
pkgmgr_common::DBOperationType::OPERATION_TYPE_READ));
pkgmgr_client::PkgInfoClient client(parcelable, uid,
- pkgmgr_common::ReqType::QUERY);
+ pkgmgr_common::ReqType::READ_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";
+ auto ptr = client.GetResultParcel();
+ if (ValidateParcelable(ptr, pcp::ParcelableType::Result) != PMINFO_R_OK)
return nullptr;
- }
std::shared_ptr<pcp::ResultParcelable> return_parcel(
std::static_pointer_cast<pcp::ResultParcelable>(ptr));
-
- // result_list is vector of string vector
char* label = nullptr;
- auto result_list = return_parcel->GetResult();
+ 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())
- return nullptr;
- label = strdup(result.front().c_str());
+ if (!result.front() || (*result.front()).empty())
+ continue;
+
+ label = strdup((*result.front()).c_str());
if (label == nullptr) {
LOG(ERROR) << "Out of memory";
return nullptr;
}
- return label;
+
+ break;
}
return label;
pkgmgr_common::DBOperationType::OPERATION_TYPE_READ));
pkgmgr_client::PkgInfoClient client(parcelable, uid,
- pkgmgr_common::ReqType::QUERY);
+ pkgmgr_common::ReqType::READ_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;
- }
+ 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 result_list = return_parcel->GetResult();
+ auto& result_list = return_parcel->GetResult();
if (result_list.size() == 0)
return PMINFO_R_ENOENT;
- for (auto& result : result_list) {
- if (result.size() != 2 || result.front().empty() || result.back().empty())
+
+ for (auto it = result_list.rbegin(); it != result_list.rend(); it++) {
+ const auto& result = *it;
+ if (result.size() != 2 || !result.front() || !result.back() ||
+ (*result.front()).empty() || (*result.back()).empty())
+ continue;
+
+ char* tmp_appid = strdup((*result.front()).c_str());
+ if (tmp_appid == nullptr) {
+ LOG(ERROR) << "Out of memory";
return PMINFO_R_ERROR;
- *appid = strdup(result.front().c_str());
- *access = strdup(result.back().c_str());
- if (*appid == nullptr || *access == nullptr) {
+ }
+
+ char* tmp_access = strdup((*result.back()).c_str());
+ if (tmp_access == nullptr) {
LOG(ERROR) << "Out of memory";
+ free(tmp_appid);
return PMINFO_R_ERROR;
}
+
+ *appid = tmp_appid;
+ *access = tmp_access;
+
+ return PMINFO_R_OK;
}
- return PMINFO_R_OK;
+ return PMINFO_R_ENOENT;
}
extern "C" EXPORT_API int _appinfo_get_datacontrol_appid(
pkgmgr_common::DBOperationType::OPERATION_TYPE_READ));
pkgmgr_client::PkgInfoClient client(parcelable, uid,
- pkgmgr_common::ReqType::QUERY);
+ pkgmgr_common::ReqType::READ_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;
- }
+ 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));
- // result_list is vector of string vector
- auto result_list = return_parcel->GetResult();
+ auto& result_list = return_parcel->GetResult();
if (result_list.size() == 0)
return PMINFO_R_ENOENT;
- for (auto& result : result_list) {
- if (result.size() != 1 || result.front().empty())
- return PMINFO_R_ERROR;
- *appid = strdup(result.front().c_str());
+
+ for (auto it = result_list.rbegin(); it != result_list.rend(); it++) {
+ const auto& result = *it;
+ if (result.size() != 1 || !result.front() || (*result.front()).empty())
+ continue;
+
+ *appid = strdup((*result.front()).c_str());
if (*appid == nullptr) {
LOG(ERROR) << "Out of memory";
return PMINFO_R_ERROR;
}
+
+ return PMINFO_R_OK;
}
- return PMINFO_R_OK;
+ return PMINFO_R_ENOENT;
}
extern "C" EXPORT_API int _appinfo_get_datacontrol_trusted_info(
pkgmgr_common::DBOperationType::OPERATION_TYPE_READ));
pkgmgr_client::PkgInfoClient client(parcelable, uid,
- pkgmgr_common::ReqType::QUERY);
+ pkgmgr_common::ReqType::READ_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;
- }
+ 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));
- // result_list is vector of string vector
- auto result_list = return_parcel->GetResult();
+ auto& result_list = return_parcel->GetResult();
if (result_list.size() == 0)
return PMINFO_R_ENOENT;
- for (auto& result : result_list) {
- if (result.size() != 2 || result.front().empty() || result.back().empty())
+
+ for (auto it = result_list.rbegin(); it != result_list.rend(); it++) {
+ const auto& result = *it;
+ if (result.size() != 2 || !result.front() || !result.back() ||
+ (*result.front()).empty() || (*result.back()).empty())
+ continue;
+
+ char* tmp_appid = strdup((*result.front()).c_str());
+ if (tmp_appid == nullptr) {
+ LOG(ERROR) << "Out of memory";
return PMINFO_R_ERROR;
- *appid = strdup(result.front().c_str());
- *trusted = strdup(result.back().c_str());
- if (*appid == nullptr || *trusted == nullptr) {
+ }
+
+ char* tmp_trusted = strdup((*result.back()).c_str());
+ if (tmp_trusted == nullptr) {
LOG(ERROR) << "Out of memory";
+ free(tmp_appid);
return PMINFO_R_ERROR;
}
+
+ *appid = tmp_appid;
+ *trusted = tmp_trusted;
+
+ return PMINFO_R_OK;
}
- return PMINFO_R_OK;
+ return PMINFO_R_ENOENT;
}
extern "C" EXPORT_API int _appinfo_get_datacontrol_privileges(
pkgmgr_common::DBOperationType::OPERATION_TYPE_READ));
pkgmgr_client::PkgInfoClient client(parcelable, uid,
- pkgmgr_common::ReqType::QUERY);
+ pkgmgr_common::ReqType::READ_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;
- }
+ 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));
- // result_list is vector of string vector
- auto result_list = return_parcel->GetResult();
+ auto& result_list = return_parcel->GetResult();
if (result_list.size() == 0)
return PMINFO_R_ENOENT;
for (auto& result : result_list) {
- if (result.size() != 1 || result.front().empty())
+ if (result.size() != 1 || !result.front() || (*result.front()).empty())
return PMINFO_R_ERROR;
- char* privilege = strdup(result.front().c_str());
+
+ char* privilege = strdup((*result.front()).c_str());
if (privilege == nullptr) {
LOG(ERROR) << "Out of memory";
return PMINFO_R_ERROR;
pkgmgr_common::DBOperationType::OPERATION_TYPE_READ));
pkgmgr_client::PkgInfoClient client(parcelable, uid,
- pkgmgr_common::ReqType::QUERY);
+ pkgmgr_common::ReqType::READ_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;
- }
+ 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));
// result_list is vector of string vector
- auto result_list = return_parcel->GetResult();
+ auto& result_list = return_parcel->GetResult();
if (result_list.size() == 0)
return PMINFO_R_ENOENT;
for (auto& result : result_list) {
- if (result.size() != 2 || result.front().empty() || result.back().empty())
+ if (result.size() != 2 || !result.front() || !result.back() ||
+ (*result.front()).empty() || (*result.back()).empty())
return PMINFO_R_ERROR;
- std::stringstream ss(result.front());
+
+ std::stringstream ss((*result.front()));
std::string token;
while (std::getline(ss, token, '|')) {
if (token.compare(std::string(operation))) {
- char* privilege = strdup(result.back().c_str());
+ char* privilege = strdup((*result.back()).c_str());
if (privilege == nullptr) {
LOG(ERROR) << "Out of memory";
return PMINFO_R_ERROR;
pkgmgr_common::DBOperationType::OPERATION_TYPE_READ));
pkgmgr_client::PkgInfoClient client(parcelable, _getuid(),
- pkgmgr_common::ReqType::QUERY);
+ pkgmgr_common::ReqType::READ_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;
- }
+ 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& result_list = return_parcel->GetResult();
+ if (result_list.size() == 0)
+ return PMINFO_R_ENOENT;
+
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;
for (auto& result : result_list) {
if (result.size() != 1) {
g_list_free_full(*list, free);
return PMINFO_R_ERROR;
}
- *list = g_list_append(*list, strdup(result[0].c_str()));
+
+ *list = g_list_append(*list, strdup((*result[0]).c_str()));
}
return PMINFO_R_OK;
*convert_type = PMINFO_UPDATEINFO_OPTIONAL;
else
return -1;
+
return 0;
}
if (update_info->pkgid)
free(reinterpret_cast<void*>(update_info->pkgid));
+
if (update_info->version)
free(reinterpret_cast<void*>(update_info->version));
+
free(reinterpret_cast<void*>(update_info));
}
GSList** update_info_list, uid_t uid) {
int ret;
- std::pair<int, std::vector<std::string>> info;
+ std::pair<int, std::vector<const char*>> info;
if (pkgid == nullptr) {
- info = std::pair<int, std::vector<std::string>>(
+ info = std::pair<int, std::vector<const char*>>(
QUERY_INDEX_GET_PKG_UPDATEINFO_1, {});
} else {
- info = std::pair<int, std::vector<std::string>>(
+ info = std::pair<int, std::vector<const char*>>(
QUERY_INDEX_GET_PKG_UPDATEINFO_2, { pkgid });
}
std::shared_ptr<pcp::AbstractParcelable> parcelable(
- new pcp::QueryParcelable(uid, std::move(info),
+ new pcp::QueryParcelable(uid, info,
pkgmgr_common::DBType::DB_TYPE_FILE_PKGDB,
pkgmgr_common::DBOperationType::OPERATION_TYPE_READ));
pkgmgr_client::PkgInfoClient client(parcelable, uid,
- pkgmgr_common::ReqType::QUERY);
+ pkgmgr_common::ReqType::READ_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;
- }
+ 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));
return PMINFO_R_ERROR;
}
- auto result_list = return_parcel->GetResult();
+ auto& result_list = return_parcel->GetResult();
if (result_list.size() == 0)
return PMINFO_R_ENOENT;
+ GSList* tmp_list = nullptr;
for (auto& result : result_list) {
if (result.size() != 3) {
LOG(ERROR) << "Invalid result";
- g_slist_free_full(*update_info_list, __free_update_info);
+ g_slist_free_full(tmp_list, __free_update_info);
return PMINFO_R_ERROR;
}
+
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());
+
+ 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);
+
+ 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);
+ g_slist_free_full(tmp_list, __free_update_info);
return PMINFO_R_ERROR;
}
+
update_info->type = static_cast<int>(convert_type);
- *update_info_list = g_slist_prepend(*update_info_list,
- update_info);
+ tmp_list = g_slist_append(tmp_list, update_info);
}
+ *update_info_list = tmp_list;
return PMINFO_R_OK;
}
pkgmgr_common::DBOperationType::OPERATION_TYPE_WRITE));
pkgmgr_client::PkgInfoClient client(parcelable, uid,
- pkgmgr_common::ReqType::QUERY);
+ pkgmgr_common::ReqType::WRITE_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;
+ return ValidateParcelable(
+ client.GetResultParcel(), pcp::ParcelableType::Result);
}
extern "C" EXPORT_API int _certinfo_compare_pkg_certinfo(const char* l_pkgid,
pkgmgr_common::DBType::DB_TYPE_FILE_CERTDB,
pkgmgr_common::DBOperationType::OPERATION_TYPE_READ));
pkgmgr_client::PkgInfoClient client(parcelable, 0,
- pkgmgr_common::ReqType::QUERY);
+ pkgmgr_common::ReqType::READ_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;
- }
+ 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();
+ 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();
+ result_map[*certinfo.front()] = *certinfo.back();
auto l_iter = result_map.find(l_pkgid);
auto r_iter = result_map.find(r_pkgid);
pkgmgr_common::DBType::DB_TYPE_FILE_PKGDB,
pkgmgr_common::DBOperationType::OPERATION_TYPE_READ));
pkgmgr_client::PkgInfoClient client(parcelable, uid,
- pkgmgr_common::ReqType::QUERY);
+ pkgmgr_common::ReqType::READ_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;
- }
+ 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();
+ 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()));
+ result_map.insert(make_pair(*pkgid.front(), *pkgid.back()));
auto l_iter = result_map.find(l_appid);
if (l_iter == result_map.end()) {
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<std::string> args;
+ std::vector<const char*> args;
- for (unsigned int i = 0; i < arg_cnt; i++) {
- if (query_args[i])
- args.push_back(query_args[i]);
- else
- args.push_back("");
- }
+ 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::DBOperationType::OPERATION_TYPE_WRITE));
pkgmgr_client::PkgInfoClient client(parcelable, uid,
- pkgmgr_common::ReqType::QUERY);
+ pkgmgr_common::ReqType::WRITE_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;
- }
+ return PMINFO_R_ERROR;
- if (ptr->GetType() != pcp::ParcelableType::Result) {
- LOG(ERROR) << "Invalid parcelable type";
- return -1;
- }
- return 0;
+ 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<std::string>>> queries;
+ std::vector<std::pair<int, std::vector<const char*>>> queries;
for (unsigned int i = 0; i < query_cnt; i++) {
- std::vector<std::string> args;
- for (unsigned int j = 0; j < arg_cnt; j++) {
- if (query_args[i][j])
- args.push_back(query_args[i][j]);
- else
- args.push_back("");
- }
+ 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, std::move(queries),
+ 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::QUERY);
+ pkgmgr_common::ReqType::WRITE_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 PMINFO_R_ERROR;
- return 0;
+ 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<package_x*>{mfx}, pkgmgr_common::PkgWriteType::Insert, false);
+ 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 -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 PMINFO_R_ERROR;
- return 0;
+ 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<package_x*>{mfx}, pkgmgr_common::PkgWriteType::Update, false);
+ 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 -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 PMINFO_R_ERROR;
- return 0;
+ 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<package_x*>{mfx}, pkgmgr_common::PkgWriteType::Delete, false);
+ 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 -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 PMINFO_R_ERROR;
- return 0;
+ return ValidateParcelable(
+ client.GetResultParcel(), pcp::ParcelableType::Result);
}
extern "C" EXPORT_API int _pkginfo_insert_certinfo(const char* pkgid,
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;
+ return ValidateParcelable(
+ client.GetResultParcel(), pcp::ParcelableType::Result);
}
extern "C" EXPORT_API int _pkginfo_get_certinfo(const char* pkgid,
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;
- }
+ 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));
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];
pkgmgr_common::DBOperationType::OPERATION_TYPE_WRITE));
pkgmgr_client::PkgInfoClient client(parcelable, 0,
- pkgmgr_common::ReqType::QUERY);
+ pkgmgr_common::ReqType::WRITE_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;
+ return ValidateParcelable(
+ client.GetResultParcel(), pcp::ParcelableType::Result);
}
-extern "C" EXPORT_API int _parser_clear_cache_memory_db(uid_t uid) {
+extern "C" EXPORT_API int _parser_update_pending_cache(const char* pkgid) {
std::shared_ptr<pcp::AbstractParcelable> parcelable(
- new pcp::CommandParcelable(uid, CommandType::RemoveCache));
+ new pcp::CommandParcelable(_getuid(),
+ CommandType::UpdatePendingCache, { pkgid }));
- pkgmgr_client::PkgInfoClient client(parcelable, uid,
+ pkgmgr_client::PkgInfoClient client(parcelable, _getuid(),
pkgmgr_common::ReqType::COMMAND);
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;
+ return ValidateParcelable(
+ client.GetResultParcel(), pcp::ParcelableType::Result);
}
static int __create_and_initialize_db(uid_t uid) {
pkgmgr_common::ReqType::CREATE_DB);
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 PMINFO_R_ERROR;
- return 0;
+ 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 -1;
+ return PMINFO_R_ERROR;
}
- return 0;
+ return PMINFO_R_OK;
}
projects / platform / core / appfw / pkgmgr-info.git / blobdiff