#include "pkgmgr-info.h"
#include "pkgmgrinfo_debug.h"
#include "pkgmgrinfo_internal.h"
-#include "pkgmgrinfo_internal.hh"
#include "pkgmgrinfo_private.h"
#ifdef LOG_TAG
return true;
}
-static const std::string global_parser_memdb_path =
- "file:parserdb?mode=memory&cache=shared";
-
-static const std::string cert_memdb_path =
- "file:certdb?mode=memory&cache=shared";
-
} // namespace
namespace pkgmgr_server {
std::unordered_map<uid_t, std::unique_ptr<DBHandleProvider>>
DBHandleProvider::provider_map_;
-bool DBHandleProvider::is_global_memdb_set_ = false;
-std::unique_ptr<sqlite3, decltype(sqlite3_close_v2)*>
- DBHandleProvider::global_parser_memdb_handle_(nullptr,
- sqlite3_close_v2);
-std::unique_ptr<sqlite3, decltype(sqlite3_close_v2)*>
- DBHandleProvider::cert_memdb_handle_(nullptr, sqlite3_close_v2);
std::string DBHandleProvider::global_parser_filedb_path_;
std::string DBHandleProvider::cert_filedb_path_;
std::unordered_set<pid_t> DBHandleProvider::writer_pid_list_;
-std::recursive_mutex DBHandleProvider::lock_;
std::shared_mutex DBHandleProvider::pid_list_lock_;
-DBHandleProvider::DBHandleProvider(uid_t uid)
- : uid_(uid),
- is_user_memdb_set_(false),
- parser_memdb_handle_(nullptr, sqlite3_close_v2) {
+DBHandleProvider::DBHandleProvider(uid_t uid) : uid_(uid) {
char* tmp_path;
if (global_parser_filedb_path_.empty()) {
tmp_path = getUserPkgParserDBPathUID(uid_);
user_parser_filedb_path_ = tmp_path;
free(tmp_path);
-
- user_parser_memdb_path_ = "file:parserdb" +
- std::to_string(static_cast<int>(uid_)) +
- "?mode=memory&cache=shared";
}
DBHandleProvider& DBHandleProvider::GetInst(uid_t uid) {
return *prov;
}
-bool DBHandleProvider::IsCrashedWriteRequest() {
+std::unordered_set<pid_t> DBHandleProvider::CrashedWriteRequestPIDs() {
std::unique_lock<std::shared_mutex> u(pid_list_lock_);
if (writer_pid_list_.empty())
- return false;
+ return {};
- bool ret = true;
LOG(DEBUG) << "Check process count : " << writer_pid_list_.size();
- std::vector<pid_t> remove_pids;
+ std::unordered_set<pid_t> remove_pids;
for (pid_t pid : writer_pid_list_) {
std::string status_path = "/proc/" + std::to_string(pid) + "/status";
int fd = open(status_path.c_str(), O_RDONLY);
if (fd < 0) {
LOG(ERROR) << "Process is crashed : " << pid;
- remove_pids.push_back(pid);
+ remove_pids.emplace(pid);
} else {
- ret = false;
close(fd);
}
}
- for (pid_t pid : remove_pids)
- writer_pid_list_.erase(pid);
-
- return ret;
+ return remove_pids;
}
-std::vector<std::pair<std::string, uid_t>> DBHandleProvider::GetParserDBPath(
- pid_t pid, bool write) {
- std::unique_lock<std::recursive_mutex> u(lock_);
+std::vector<std::pair<std::string, uid_t>> DBHandleProvider::GetParserDBPath() {
std::vector<std::pair<std::string, uid_t>> db_path_list;
- if (is_user_memdb_set_ != is_global_memdb_set_)
- is_global_memdb_set_ ? SetMemoryMode(pid) : UnsetMemoryMode(pid);
+ if (uid_ > REGULAR_USER)
+ db_path_list.emplace_back(std::make_pair(user_parser_filedb_path_, uid_));
- if (IsMemoryDBActive(pid, write)) {
- if (uid_ > REGULAR_USER)
- db_path_list.emplace_back(std::make_pair(user_parser_memdb_path_, uid_));
-
- db_path_list.emplace_back(
- std::make_pair(global_parser_memdb_path, GetGlobalUID()));
- } else {
- if (uid_ > REGULAR_USER)
- db_path_list.emplace_back(std::make_pair(user_parser_filedb_path_, uid_));
-
- db_path_list.emplace_back(
- std::make_pair(global_parser_filedb_path_, GetGlobalUID()));
- }
+ db_path_list.emplace_back(
+ std::make_pair(global_parser_filedb_path_, GetGlobalUID()));
if (db_path_list.size() == 1) {
LOG(DEBUG) << "global db path : " << db_path_list[0].first;
return db_path_list;
}
-std::string DBHandleProvider::GetCertDBPath(pid_t pid, bool write) {
- std::unique_lock<std::recursive_mutex> u(lock_);
- if (is_user_memdb_set_ != is_global_memdb_set_)
- is_global_memdb_set_ ? SetMemoryMode(pid) : UnsetMemoryMode(pid);
-
- if (IsMemoryDBActive(pid, write))
- return cert_memdb_path;
- else
- return cert_filedb_path_;
-}
-
-sqlite3* DBHandleProvider::CreateMemoryDBHandle(const std::string& filedb_path,
- const std::string& memorydb_path) {
- sqlite3* memorydb = nullptr;
- sqlite3* filedb = nullptr;
- int ret = sqlite3_open_v2(memorydb_path.c_str(), &memorydb,
- SQLITE_OPEN_READONLY | SQLITE_OPEN_URI, nullptr);
- if (ret != SQLITE_OK) {
- LOG(ERROR) << "Failed to open memory DB " << ret << ": " << memorydb_path;
- return nullptr;
- }
-
- ret = sqlite3_open_v2(filedb_path.c_str(), &filedb, SQLITE_OPEN_READONLY,
- nullptr);
- if (ret != SQLITE_OK) {
- LOG(ERROR) << "Failed to open file DB " << ret << ": " << filedb_path;
- sqlite3_close_v2(memorydb);
- return nullptr;
- }
-
- sqlite3_backup* backup =
- sqlite3_backup_init(memorydb, "main", filedb, "main");
- if (backup == nullptr) {
- LOG(ERROR) << "Failed to backup for memory DB";
- sqlite3_close_v2(memorydb);
- sqlite3_close_v2(filedb);
- return nullptr;
- }
-
- sqlite3_backup_step(backup, -1);
- sqlite3_backup_finish(backup);
- sqlite3_close_v2(filedb);
- return memorydb;
-}
-
-void DBHandleProvider::SetMemoryMode(pid_t pid) {
- std::unique_lock<std::recursive_mutex> u(lock_);
- if (is_global_memdb_set_ && is_user_memdb_set_)
- return;
-
- sqlite3* parser_db =
- CreateMemoryDBHandle(user_parser_filedb_path_, user_parser_memdb_path_);
- if (parser_db != nullptr)
- parser_memdb_handle_.reset(parser_db);
-
- if (is_user_memdb_set_ == is_global_memdb_set_) {
- sqlite3* global_parser_file_db = CreateMemoryDBHandle(
- global_parser_filedb_path_, global_parser_memdb_path);
- if (global_parser_file_db)
- global_parser_memdb_handle_.reset(global_parser_file_db);
-
- sqlite3* cert_db =
- CreateMemoryDBHandle(cert_filedb_path_, cert_memdb_path);
- if (cert_db != nullptr)
- cert_memdb_handle_.reset(cert_db);
-
- InsertPID(pid);
- }
-
- is_user_memdb_set_ = true;
- is_global_memdb_set_ = true;
- LOG(DEBUG) << "Set Memory mode : Memory";
-}
-
-void DBHandleProvider::UnsetMemoryMode(pid_t pid) {
- std::unique_lock<std::recursive_mutex> u(lock_);
- if (!is_global_memdb_set_ && !is_user_memdb_set_)
- return;
-
- parser_memdb_handle_.reset(nullptr);
- cert_memdb_handle_.reset(nullptr);
- global_parser_memdb_handle_.reset(nullptr);
-
- if (!ErasePID(pid))
- LOG(ERROR) << "Given pid is not exists in pid list : " << pid;
-
- is_user_memdb_set_ = false;
- is_global_memdb_set_ = false;
-
- TrimCache();
-
- LOG(DEBUG) << "Set Memory mode : File";
-}
-
-bool DBHandleProvider::IsMemoryDBActive(pid_t pid, bool write) {
- std::unique_lock<std::shared_mutex> u(pid_list_lock_);
- if (!is_user_memdb_set_)
- return false;
-
- if (write)
- return false;
-
- if (writer_pid_list_.find(pid) != writer_pid_list_.end())
- return false;
-
- return true;
+std::string DBHandleProvider::GetCertDBPath() {
+ return cert_filedb_path_;
}
void DBHandleProvider::TrimCache() {
- std::unique_lock<std::recursive_mutex> u(lock_);
if (!released_)
ReleaseCache();
}
app_map_.clear();
pkg_map_.clear();
+ pending_pkg_.clear();
+ pkg_app_map_.clear();
CacheFlag::SetStatus(CacheFlag::Status::UNPREPARED);
released_ = true;
return writer_pid_list_.find(pid) != writer_pid_list_.end();
}
-int DBHandleProvider::UpdateCache(sqlite3* db, pid_t pid, uid_t uid, bool write,
- const std::string& locale) {
+int DBHandleProvider::UpdateCache(const tizen_base::Database& db, pid_t pid,
+ uid_t uid, bool write, const std::string& locale) {
pkg_map_.clear();
app_map_.clear();
+ pending_pkg_.clear();
+ pkg_app_map_.clear();
- const char* dbpath = sqlite3_db_filename(db, "main");
- bool is_inmemory_db = false;
- if (dbpath == nullptr || strlen(dbpath) == 0) {
- LOG(INFO) << "database is inmemory db";
- is_inmemory_db = true;
- }
+ const char* dbpath = sqlite3_db_filename(db.GetRaw(), "main");
timespec start_time = { 0, };
timespec end_time = { 0, };
- if (!is_inmemory_db && !GetModifiedTime(dbpath, &start_time))
+ if (!GetModifiedTime(dbpath, &start_time))
return PMINFO_R_ERROR;
- GHashTable* list = g_hash_table_new(g_str_hash, g_str_equal);
- if (list == nullptr) {
- LOG(ERROR) << "Out of memory";
- return PMINFO_R_ERROR;
- }
-
pkgmgrinfo_filter_x tmp_filter = { 0, };
tmp_filter.cache_flag = true;
- int ret = pkginfo_internal_filter_get_list(db, &tmp_filter, uid_,
- locale.c_str(), list);
+ std::map<std::string, std::shared_ptr<package_x>> pkgs;
+ int ret = internal::GetPkgInfo(db, &tmp_filter, uid_, locale, pkgs);
if (ret == PMINFO_R_OK) {
- GHashTableIter iter;
- gpointer value;
- g_hash_table_iter_init(&iter, list);
- while (g_hash_table_iter_next(&iter, nullptr, &value)) {
- auto* pkg = reinterpret_cast<package_x*>(value);
- std::string pkgid = pkg->package;
- AddPackage(std::move(pkgid), pkg);
- }
+ for (auto& [key, val] : pkgs)
+ AddPackage(std::move(val));
}
- g_hash_table_destroy(list);
- if (ret == PMINFO_R_ERROR)
- return ret;
-
- if (!is_inmemory_db && !GetModifiedTime(dbpath, &end_time))
+ if (!GetModifiedTime(dbpath, &end_time))
return PMINFO_R_ERROR;
if (start_time.tv_sec != end_time.tv_sec ||
}
std::vector<std::shared_ptr<application_x>> app_list;
- ret = pkgmgr_server::internal::appinfo_internal_filter_get_list(db,
- &tmp_filter, uid_, uid, locale.c_str(), app_list);
+ ret = internal::GetAppInfo(db, &tmp_filter, uid_, uid, locale, app_list);
- if (!is_inmemory_db && !GetModifiedTime(dbpath, &end_time))
+ if (!GetModifiedTime(dbpath, &end_time))
return PMINFO_R_ERROR;
if (start_time.tv_sec != end_time.tv_sec ||
if (ret == PMINFO_R_OK) {
for (auto& app : app_list) {
- if (pkg_map_.find(app->package) == pkg_map_.end()) {
+ auto it = pkg_map_.find(app->package);
+ if (it == pkg_map_.end()) {
LOG(ERROR) << "Can not find package from pkg_map";
return PMINFO_R_ERROR;
}
- app->privileges = pkg_map_[app->package].front()->privileges;
- std::string appid = app->appid;
- AddApplication(std::move(appid), std::move(app));
+ app->privileges = it->second->privileges;
+ AddApplication(std::move(app));
}
}
return ret;
}
+inline bool CheckMetadataFilter(GList* metadata_list,
+ const std::unordered_map<std::string, std::string>& metadata_map) {
+ for (auto* it = metadata_list; it != nullptr; it = g_list_next(it)) {
+ auto* node = reinterpret_cast<metadata_x*>(it->data);
+ if (node->key != nullptr) {
+ auto metadata = metadata_map.find(node->key);
+ if (metadata == metadata_map.end())
+ continue;
+
+ if (metadata->second.empty() ||
+ strcmp(node->value ? node->value : "", metadata->second.c_str()) == 0)
+ return true;
+ }
+ }
+ return false;
+}
+
+inline bool CheckPkgFilters(pkgmgrinfo_filter_x* filter,
+ const std::shared_ptr<package_x>& info,
+ const std::unordered_map<std::string, std::string>& metadata_map) {
+ for (auto* it = filter->list; it != nullptr; it = g_slist_next(it)) {
+ auto node = reinterpret_cast<pkgmgrinfo_node_x*>(it->data);
+ auto* checker = FilterCheckerProvider::GetInst().
+ GetPkgFilterChecker(node->prop);
+ if (!checker->CheckFilter(node, info.get()))
+ return false;
+ }
+
+ bool pass = true;
+ if (!metadata_map.empty())
+ pass = CheckMetadataFilter(info->metadata, metadata_map);
+
+ return pass;
+}
+
std::vector<std::shared_ptr<package_x>> DBHandleProvider::GetPackages(
pid_t pid, pkgmgrinfo_filter_x* filter,
const std::string& package) {
std::vector<std::shared_ptr<package_x>> ret;
- auto map_it = pkg_map_.find(package);
- if (map_it == pkg_map_.end())
- return ret;
- if (__check_package_storage_status(filter)) {
+ /* make metadata filter map */
+ std::unordered_map<std::string, std::string> metadata_map;
+ for (auto* it = filter->list_pkg_metadata; it != nullptr;
+ it = g_slist_next(it)) {
+ auto node = reinterpret_cast<pkgmgrinfo_metadata_node_x*>(it->data);
+ if (node->key == nullptr)
+ continue;
+ LOG(ERROR) << "add metadata filter";
+ metadata_map[node->key] = (node->value ? node->value : "");
+ }
+
+ if (internal::CheckPackageStorageStatus(filter)) {
if (pkgmgrinfo_pkginfo_filter_add_bool(filter,
PMINFO_PKGINFO_PROP_PACKAGE_CHECK_STORAGE, true) != PMINFO_R_OK) {
LOG(ERROR) << "Fail to add check storage value to filter";
return {};
}
}
-
- for (auto& info : map_it->second) {
- bool pass = true;
- for (auto* it = filter->list; it != nullptr; it = g_slist_next(it)) {
- auto node = reinterpret_cast<pkgmgrinfo_node_x*>(it->data);
- auto* checker = FilterCheckerProvider::GetInst().
- GetPkgFilterChecker(node->prop);
- if (!checker->CheckFilter(node, info.get())) {
- pass = false;
- break;
- }
+ if (package.empty()) {
+ for (auto& info : pkg_map_) {
+ if (CheckPkgFilters(filter, info.second, metadata_map))
+ ret.push_back(info.second);
}
- if (pass)
- ret.push_back(info);
+ } else {
+ auto map_it = pkg_map_.find(package);
+ if (map_it != pkg_map_.end() && CheckPkgFilters(filter, map_it->second,
+ metadata_map))
+ ret.push_back(map_it->second);
}
return ret;
}
-void DBHandleProvider::AddPackage(std::string package, package_x* info) {
- auto ptr = std::shared_ptr<package_x>(info, pkgmgrinfo_basic_free_package);
- pkg_map_[package].push_back(ptr);
- pkg_map_[""].push_back(std::move(ptr));
+void DBHandleProvider::AddPackage(std::shared_ptr<package_x> info) {
+ pkg_map_[info->package] = std::move(info);
+}
+
+void DBHandleProvider::AddApplication(std::shared_ptr<application_x> info) {
+ std::string appid = info->appid;
+ std::string pkgid = info->package;
+ app_map_[appid] = std::move(info);
+ pkg_app_map_[pkgid].emplace(std::move(appid));
+}
+
+void DBHandleProvider::ErasePackage(const std::string& pkgid) {
+ auto it = pkg_app_map_.find(pkgid);
+ if (it != pkg_app_map_.end()) {
+ for (const auto& app : it->second)
+ app_map_.erase(app);
+ pkg_app_map_.erase(it);
+ }
+
+ pkg_map_.erase(pkgid);
+}
+
+inline bool CheckAppFilters(pkgmgrinfo_filter_x* filter,
+ const std::shared_ptr<application_x>& app_info,
+ const std::shared_ptr<package_x>& pkg_info,
+ const std::unordered_map<std::string, std::string>& metadata_map) {
+ for (auto* it = filter->list; it != nullptr; it = g_slist_next(it)) {
+ auto node = reinterpret_cast<pkgmgrinfo_node_x*>(it->data);
+ auto* checker = FilterCheckerProvider::GetInst().
+ GetAppFilterChecker(node->prop);
+ if (!checker->CheckFilter(node, app_info.get(), pkg_info.get()))
+ return false;
+ }
+
+ bool pass = true;
+ if (!metadata_map.empty())
+ pass = CheckMetadataFilter(app_info->metadata, metadata_map);
+ return pass;
+}
+
+std::shared_ptr<package_x> DBHandleProvider::GetPackageByApp(
+ const char* appid) {
+ auto it = pkg_map_.find(appid);
+ if (it == pkg_map_.end())
+ return nullptr;
+
+ return it->second;
}
std::vector<std::shared_ptr<application_x>> DBHandleProvider::GetApplications(
}
std::vector<std::shared_ptr<application_x>> ret;
- auto map_it = app_map_.find(app);
- if (map_it == app_map_.end())
- return ret;
-
- if (pkgmgr_server::internal::check_app_storage_status(filter)) {
+ if (internal::CheckAppStorageStatus(filter)) {
if (pkgmgrinfo_appinfo_filter_add_bool(filter,
PMINFO_APPINFO_PROP_APP_CHECK_STORAGE, true) != PMINFO_R_OK) {
LOG(ERROR) << "Fail to add check storage value to filter";
}
}
- for (auto& info : map_it->second) {
- bool pass = true;
- for (auto* it = filter->list; it != nullptr; it = g_slist_next(it)) {
- auto node = reinterpret_cast<pkgmgrinfo_node_x*>(it->data);
- auto* checker = FilterCheckerProvider::GetInst().
- GetAppFilterChecker(node->prop);
- if (!checker->CheckFilter(node, info.get())) {
- pass = false;
- break;
+ if (app.empty()) {
+ for (auto& info : app_map_) {
+ if (CheckAppFilters(filter, info.second,
+ GetPackageByApp(info.second->package), metadata_map))
+ ret.push_back(info.second);
+ }
+ } else {
+ auto map_it = app_map_.find(app);
+ if (map_it != app_map_.end() &&
+ CheckAppFilters(filter, map_it->second,
+ GetPackageByApp(map_it->second->package), metadata_map))
+ ret.push_back(map_it->second);
+ }
+
+ return ret;
+}
+
+void DBHandleProvider::InsertWriterPID(pid_t pid) {
+ std::unique_lock<std::shared_mutex> u(pid_list_lock_);
+
+ writer_pid_list_.insert(pid);
+}
+
+bool DBHandleProvider::EraseWriterPID(pid_t pid) {
+ std::unique_lock<std::shared_mutex> u(pid_list_lock_);
+
+ return writer_pid_list_.erase(pid) == 1;
+}
+
+void DBHandleProvider::RegisterPendingPackageInfo(
+ const tizen_base::Database& db, package_x* info, pid_t pid, uid_t uid,
+ const std::string& locale, pkgmgr_common::PkgWriteType write_type) {
+ if (!info || !info->package)
+ return;
+
+ InsertWriterPID(pid);
+
+ if (write_type != pkgmgr_common::PkgWriteType::Delete) {
+ pkgmgrinfo_filter_x tmp_filter = { 0, };
+ pkgmgrinfo_node_x node = {
+ .prop = E_PMINFO_PKGINFO_PROP_PACKAGE_ID
+ };
+ tmp_filter.cache_flag = true;
+ tmp_filter.list = g_slist_append(tmp_filter.list, (gpointer)&node);
+ std::map<std::string, std::shared_ptr<package_x>> pkgs;
+
+ node.value = const_cast<char*>(info->package);
+ internal::GetPkgInfo(db, &tmp_filter, uid_, locale, pkgs);
+ node.prop = E_PMINFO_APPINFO_PROP_APP_PACKAGE;
+ for (auto& [pkgid, pkg_handle] : pkgs) {
+ node.value = const_cast<char*>(pkgid.c_str());
+ std::vector<std::shared_ptr<application_x>> app_list;
+ internal::GetAppInfo(db, &tmp_filter, uid_, uid, locale, app_list);
+
+ for (auto& app : app_list) {
+ app->privileges = pkg_handle->privileges;
+ pending_app_[pkgid].emplace_back(std::move(app));
}
+
+ pending_pkg_[pkgid] = std::make_pair(pid, std::move(pkg_handle));
}
- if (!pass)
+
+ g_slist_free(tmp_filter.list);
+ } else {
+ pending_pkg_[info->package] = std::make_pair(pid, nullptr);
+ pending_app_.erase(info->package);
+ }
+}
+
+void DBHandleProvider::UpdatePendingPackageInfo(
+ const std::vector<std::string>& pkgids) {
+ for (const auto& pkgid : pkgids) {
+ auto pkg_it = pending_pkg_.find(pkgid);
+ if (pkg_it == pending_pkg_.end())
continue;
- if (!metadata_map.empty()) {
- pass = false;
- for (auto* it = info->metadata; it != nullptr; it = g_list_next(it)) {
- auto* node = reinterpret_cast<metadata_x*>(it->data);
- if (node->key != nullptr) {
- auto metadata = metadata_map.find(node->key);
- if (metadata == metadata_map.end())
- continue;
-
- if (metadata->second.empty() ||
- strcmp(node->value ? node->value : "",
- metadata->second.c_str()) == 0) {
- pass = true;
- break;
- }
- }
- }
+ ErasePackage(pkgid);
+ auto app_it = pending_app_.find(pkgid);
+ if (app_it != pending_app_.end()) {
+ for (auto& app : app_it->second)
+ AddApplication(std::move(app));
+ pending_app_.erase(app_it);
}
- if (pass)
- ret.push_back(info);
+ if (pkg_it->second.second)
+ AddPackage(std::move(pkg_it->second.second));
+
+ EraseWriterPID(pkg_it->second.first);
+ pending_pkg_.erase(pkg_it);
}
- return ret;
}
-void DBHandleProvider::AddApplication(std::string app, std::shared_ptr<application_x> info) {
- app_map_[app].push_back(info);
- app_map_[""].push_back(std::move(info));
+void DBHandleProvider::UpdateCrashedWriterPackageInfo(
+ const std::unordered_set<pid_t>& pids) {
+ for (auto it = pending_pkg_.begin(); it != pending_pkg_.end();) {
+ pid_t pid = it->second.first;
+ if (pids.find(pid) == pids.end()) {
+ it++;
+ continue;
+ }
+
+ const auto& pkgid = it->first;
+ auto old_app_it = pkg_app_map_.find(pkgid);
+ if (old_app_it != pkg_app_map_.end()) {
+ for (const auto& app : old_app_it->second)
+ app_map_.erase(app);
+
+ pkg_app_map_.erase(old_app_it);
+ }
+
+ auto app_it = pending_app_.find(pkgid);
+ if (app_it != pending_app_.end()) {
+ for (auto& app : app_it->second)
+ AddApplication(std::move(app));
+ pending_app_.erase(app_it);
+ }
+
+ if (it->second.second)
+ AddPackage(std::move(it->second.second));
+
+ EraseWriterPID(it->second.first);
+ it = pending_pkg_.erase(it);
+ }
}
-void DBHandleProvider::InsertPID(pid_t pid) {
- std::unique_lock<std::shared_mutex> u(pid_list_lock_);
+bool DBHandleProvider::UpdateCachePkg(const tizen_base::Database& db, uid_t uid,
+ const std::string& pkgid, const std::string& locale) {
+ pkgmgrinfo_filter_x tmp_filter = { 0, };
+ pkgmgrinfo_node_x node = {
+ .prop = E_PMINFO_PKGINFO_PROP_PACKAGE_ID,
+ .value = const_cast<char*>(pkgid.c_str())
+ };
+ tmp_filter.cache_flag = true;
+ tmp_filter.list = g_slist_append(tmp_filter.list, (gpointer)&node);
+ std::map<std::string, std::shared_ptr<package_x>> pkgs;
+ internal::GetPkgInfo(db, &tmp_filter, uid_, locale, pkgs);
+ for (auto& [key, val] : pkgs) {
+ AddPackage(val);
+ for (auto& appid : pkg_app_map_[key])
+ app_map_.erase(appid);
+
+ pkg_app_map_.erase(key);
+ std::vector<std::shared_ptr<application_x>> app_list;
+ node.prop = E_PMINFO_APPINFO_PROP_APP_PACKAGE;
+ node.value = const_cast<char*>(key.c_str());
+ internal::GetAppInfo(db, &tmp_filter, uid_, uid, locale, app_list);
+ for (auto& app : app_list) {
+ app->privileges = val->privileges;
+ AddApplication(std::move(app));
+ }
+ }
- writer_pid_list_.insert(pid);
+ return true;
}
-bool DBHandleProvider::ErasePID(pid_t pid) {
- std::unique_lock<std::shared_mutex> u(pid_list_lock_);
+bool DBHandleProvider::UpdateCacheApp(const tizen_base::Database& db, uid_t uid,
+ const std::string& appid, const std::string& locale) {
+ pkgmgrinfo_filter_x tmp_filter = { 0, };
+ pkgmgrinfo_node_x node = {
+ .prop = E_PMINFO_APPINFO_PROP_APP_ID,
+ .value = const_cast<char*>(appid.c_str())
+ };
+ tmp_filter.cache_flag = true;
+ tmp_filter.list = g_slist_append(tmp_filter.list, (gpointer)&node);
- return writer_pid_list_.erase(pid) == 1;
+ std::vector<std::shared_ptr<application_x>> app_list;
+ app_map_.erase(appid);
+ internal::GetAppInfo(db, &tmp_filter, uid_, uid, locale, app_list);
+ g_slist_free(tmp_filter.list);
+
+ for (auto& app : app_list) {
+ auto it = pkg_map_.find(app->package);
+ if (it == pkg_map_.end()) {
+ LOG(ERROR) << "Can not find package from pkg_map";
+ return false;
+ }
+
+ pkg_app_map_[app->package].erase(app->appid);
+ app->privileges = it->second->privileges;
+ AddApplication(std::move(app));
+ }
+
+ return true;
+}
+
+bool DBHandleProvider::UpdateCacheAppByPkgid(const tizen_base::Database& db,
+ uid_t uid, const std::string& pkgid, const std::string& locale) {
+ auto it = pkg_map_.find(pkgid);
+ if (it == pkg_map_.end()) {
+ LOG(ERROR) << "Can not find package from pkg_map";
+ return false;
+ }
+
+ auto& pkg = it->second;
+ pkgmgrinfo_filter_x tmp_filter = { 0, };
+ pkgmgrinfo_node_x node = {
+ .prop = E_PMINFO_APPINFO_PROP_APP_PACKAGE,
+ .value = pkg->package
+ };
+
+ tmp_filter.cache_flag = true;
+ tmp_filter.list = g_slist_append(tmp_filter.list, (gpointer)&node);
+
+ std::vector<std::shared_ptr<application_x>> app_list;
+ internal::GetAppInfo(db, &tmp_filter, uid_, uid, locale, app_list);
+
+ for (auto& appid : pkg_app_map_[pkgid]) {
+ app_map_.erase(appid);
+ }
+ pkg_app_map_.erase(pkgid);
+
+ for (auto& app : app_list) {
+ app->privileges = pkg->privileges;
+ AddApplication(std::move(app));
+ }
+
+ g_slist_free(tmp_filter.list);
+ return true;
}
} // namespace database