src/server/database/query_handler.cc

   1 /*
   2  * Copyright (c) 2021 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "query_handler.hh"
  18
  19 #include <shared_mutex>
  20 #include <tuple>
  21 #include <vector>
  22
  23 #include "utils/logging.hh"
  24 #include "cache_flag.hh"
  25 #include "db_handle_provider.hh"
  26
  27 #include "pkgmgrinfo_debug.h"
  28 #include "pkgmgrinfo_internal.h"
  29 #include "pkgmgr_query_index.h"
  30
  31 namespace {
  32
  33 constexpr const char query_appinfo_get_localed_label[] =
  34     "SELECT COALESCE((SELECT app_label FROM package_app_localized_info "
  35     "WHERE app_id=? AND app_locale=?),"
  36     "(SELECT app_label FROM package_app_localized_info WHERE "
  37     "app_id=? AND app_locale='No Locale'))";
  38
  39 constexpr const char query_appinfo_get_datacontrol_info[] =
  40     "SELECT app_id, access FROM "
  41     "package_app_data_control WHERE "
  42     "providerid=? AND type=?";
  43
  44 constexpr const char query_appinfo_get_datacontrol_appid[] =
  45     "SELECT app_id FROM package_app_data_control "
  46     "WHERE providerid=?";
  47
  48 constexpr const char query_appinfo_get_datacontrol_trusted_info[] =
  49     "SELECT app_id, trusted FROM package_app_data_control "
  50     "WHERE providerid=? AND type=?";
  51
  52 constexpr const char query_appinfo_get_datacontrol_privileges[] =
  53     "SELECT privilege FROM package_app_data_control_privilege "
  54     "WHERE providerid=? AND type=?";
  55
  56 constexpr const char query_appinfo_get_appcontrol_privileges[] =
  57     "SELECT app_control, privilege FROM package_app_app_control_privilege "
  58     "WHERE app_id=?";
  59
  60 constexpr const char query_plugininfo_get_appids[] =
  61     "SELECT appid FROM "
  62     "package_plugin_info WHERE pkgid=? AND "
  63     "plugin_type=? AND plugin_name=?";
  64
  65 constexpr const char query_get_pkg_updateinfo_1[] =
  66     "SELECT package, update_version, update_type "
  67     "FROM package_update_info";
  68 constexpr const char query_get_pkg_updateinfo_2[] =
  69     "SELECT package, update_version, update_type "
  70     "FROM package_update_info WHERE package=?";
  71
  72 constexpr const char query_pkginfo_set_usr_installed_storage_1[] =
  73     "UPDATE package_info SET installed_storage=?, external_path=? "
  74     "WHERE package=?";
  75 constexpr const char query_pkginfo_set_usr_installed_storage_2[] =
  76     "UPDATE package_app_info SET app_installed_storage=?, "
  77     "app_external_path=? WHERE package=?";
  78
  79 constexpr const char query_certinfo_compare_pkg_certinfo[] =
  80     "SELECT package, "
  81     "COALESCE(author_signer_cert, -1) FROM package_cert_info WHERE "
  82     "package IN (?, ?)";
  83
  84 constexpr const char query_certinfo_compare_app_certinfo[] =
  85     "SELECT app_id, package FROM "
  86     "package_app_info WHERE app_id IN (?, ?)";
  87
  88 constexpr const char query_pkginfo_delete_certinfo[] =
  89     "UPDATE package_cert_info SET "
  90     "package_count = package_count - 1 WHERE package=?";
  91
  92 // For pkgmgr_parser
  93 constexpr const char query_insert_package_plugin_execution_info[] =
  94     "INSERT INTO package_plugin_info "
  95     "(pkgid, appid, plugin_type, plugin_name) "
  96     "VALUES (?, ?, ?, ?)";
  97
  98 constexpr const char query_delete_package_plugin_execution_info[] =
  99     "DELETE FROM package_plugin_info WHERE pkgid=?";
 100
 101 constexpr const char query_update_global_app_disable[] =
 102     "INSERT OR REPLACE INTO package_app_info_for_uid ("
 103     "  app_id, uid, is_disabled, is_splash_screen_enabled) "
 104     "VALUES (?, ?, ?,"
 105     "  (SELECT app_splash_screen_display FROM package_app_info"
 106     "   WHERE app_id=?))";
 107
 108 constexpr const char query_update_app_disable_info[] =
 109     "UPDATE package_app_info SET app_disable=? "
 110     "WHERE app_id=?";
 111
 112 constexpr const char query_update_pkg_disable_info[] =
 113     "UPDATE package_info SET package_disable=? "
 114     "WHERE package=?";
 115
 116 constexpr const char query_update_global_app_splash_screen_display_info[] =
 117     "INSERT OR REPLACE INTO package_app_info_for_uid("
 118     "  app_id, uid, is_splash_screen_enabled) "
 119     "VALUES (?, ?, ?)";
 120
 121 constexpr const char query_update_app_splash_screen_display_info[] =
 122     "UPDATE package_app_info SET app_splash_screen_display=? "
 123     "WHERE app_id=?";
 124
 125 constexpr const char query_update_app_label_info[] =
 126     "UPDATE package_app_localized_info SET app_label=? "
 127     "WHERE app_id=? AND app_label IS NOT NULL";
 128
 129 constexpr const char query_update_app_icon_info[] =
 130     "UPDATE package_app_localized_info SET app_icon=? "
 131     "WHERE app_id=? AND app_icon IS NOT NULL";
 132
 133 constexpr const char query_update_tep_info[] =
 134     "UPDATE package_info SET package_tep_name=? "
 135     "WHERE package=?";
 136
 137 constexpr const char query_register_pkg_update_info[] =
 138     "UPDATE package_update_info "
 139     "SET update_version=?, update_type=? "
 140     "WHERE package=?";
 141
 142 constexpr const char query_unregister_pkg_update_info[] =
 143     "UPDATE package_update_info "
 144     "SET update_type='none' WHERE package=?";
 145
 146 constexpr const char query_unregister_all_pkg_update_info[] =
 147     "UPDATE package_update_info "
 148     "SET update_type='none'";
 149
 150 class QueryMaker {
 151  public:
 152   using CacheChangeFlag = pkgmgr_server::database::CacheChangeFlag;
 153   std::vector<std::tuple<const char*, CacheChangeFlag, int>> query_raw_ = {
 154     { query_appinfo_get_localed_label, CacheChangeFlag::NONE, 0 },
 155     { query_appinfo_get_datacontrol_info, CacheChangeFlag::NONE, 0 },
 156     { query_appinfo_get_datacontrol_appid, CacheChangeFlag::NONE, 0 },
 157     { query_appinfo_get_datacontrol_trusted_info, CacheChangeFlag::NONE, 0 },
 158     { query_appinfo_get_datacontrol_privileges, CacheChangeFlag::NONE, 0 },
 159     { query_appinfo_get_appcontrol_privileges, CacheChangeFlag::NONE, 0 },
 160     { query_plugininfo_get_appids, CacheChangeFlag::NONE, 0 },
 161     { query_get_pkg_updateinfo_1, CacheChangeFlag::NONE, 0 },
 162     { query_get_pkg_updateinfo_2, CacheChangeFlag::NONE, 0 },
 163     { query_pkginfo_set_usr_installed_storage_1, CacheChangeFlag::PKG, 2 },
 164     { query_pkginfo_set_usr_installed_storage_2, CacheChangeFlag::APPBYPKG, 2 },
 165     { query_certinfo_compare_pkg_certinfo, CacheChangeFlag::NONE, 0 },
 166     { query_certinfo_compare_app_certinfo, CacheChangeFlag::NONE, 0 },
 167     { query_pkginfo_delete_certinfo, CacheChangeFlag::NONE, 0 },
 168
 169     { query_insert_package_plugin_execution_info, CacheChangeFlag::PKG, 0 },
 170     { query_delete_package_plugin_execution_info, CacheChangeFlag::PKG, 0 },
 171     { query_update_global_app_disable, CacheChangeFlag::APP, 0 },
 172     { query_update_app_disable_info, CacheChangeFlag::APP, 1 },
 173     { query_update_pkg_disable_info, CacheChangeFlag::PKG, 1 },
 174     { query_update_global_app_splash_screen_display_info, CacheChangeFlag::APP, 0 },
 175     { query_update_app_splash_screen_display_info, CacheChangeFlag::APP, 1 },
 176     { query_update_app_label_info, CacheChangeFlag::APP, 1 },
 177     { query_update_app_icon_info, CacheChangeFlag::APP, 1 },
 178     { query_update_tep_info, CacheChangeFlag::PKG, 1 },
 179     { query_register_pkg_update_info, CacheChangeFlag::NONE, 0 },
 180     { query_unregister_pkg_update_info, CacheChangeFlag::NONE, 0 },
 181     { query_unregister_all_pkg_update_info, CacheChangeFlag::NONE, 0 },
 182   };
 183
 184   const std::tuple<const char*, CacheChangeFlag, int>& GetQueryInfo(int index) {
 185     return query_raw_[index];
 186   }
 187 };
 188
 189 QueryMaker __query_maker;
 190
 191 }  // namespace
 192
 193 namespace pkgmgr_server {
 194 namespace database {
 195
 196 QueryHandler::QueryHandler(uid_t uid, int pid)
 197     : AbstractDBHandler(uid, pid), uid_(uid) {}
 198
 199 QueryHandler::~QueryHandler() {}
 200
 201 void QueryHandler::SetQueryArgs(
 202     std::vector<pkgmgr_common::parcel::QueryArgs> query_args) {
 203   query_args_ = std::move(query_args);
 204 }
 205
 206 std::string QueryHandler::GetString() { return std::string(); }
 207 int QueryHandler::GetInt() { return 0; }
 208 int QueryHandler::GetRecordCount() { return 0; }
 209
 210 std::vector<pkgmgr_common::parcel::StrArgs> QueryHandler::GetResult() {
 211   return std::move(result_);
 212 }
 213
 214 int QueryHandler::ExecuteReadQuery(const std::vector<std::string>& queries,
 215     const std::vector<std::vector<std::optional<std::string>>>& args_list) {
 216   std::shared_lock<std::shared_mutex> s(lock_);
 217   if (!Connect()) {
 218     LOG(ERROR) << "Failed to connect database";
 219     return PMINFO_R_ERROR;
 220   }
 221
 222   const auto& conn_list = GetConnection();
 223   int ret = PMINFO_R_ERROR;
 224   for (const auto& conn : conn_list) {
 225     int i = 0;
 226     for (auto& q : queries) {
 227       std::vector<std::vector<std::optional<std::string>>> result;
 228       ret = internal::GetQueryResult(conn.first, q, args_list[i++], result);
 229       if (ret == PMINFO_R_ERROR) {
 230         LOG(ERROR) << "Failed to execute query";
 231         return ret;
 232       }
 233
 234       for (auto& r : result) {
 235         result_.push_back(std::move(r));
 236       }
 237     }
 238   }
 239
 240   return ret;
 241 }
 242
 243 int QueryHandler::ExecuteWriteQuery(const std::vector<std::string>& queries,
 244     const std::vector<std::vector<std::optional<std::string>>>& args_list,
 245     const std::vector<std::pair<CacheChangeFlag, std::string>>& changes) {
 246   std::unique_lock<std::shared_mutex> u(lock_);
 247   if (!Connect()) {
 248     LOG(ERROR) << "Failed to connect database";
 249     return PMINFO_R_ERROR;
 250   }
 251
 252   const auto& conn_list = GetConnection();
 253   int ret = PMINFO_R_ERROR;
 254   bool is_writer = DBHandleProvider::IsWriter(GetPID());
 255   for (const auto& conn : conn_list) {
 256     ret = internal::ExecuteWriteQueries(conn.first, queries, args_list);
 257     if (ret != PMINFO_R_OK) {
 258       LOG(ERROR) << "Failed to execute";
 259       break;
 260     }
 261   }
 262
 263   if (ret != PMINFO_R_OK || is_writer || changes.size() == 0 ||
 264       CacheFlag::GetStatus() != CacheFlag::Status::PREPARED)
 265     return ret;
 266
 267   bool success = true;
 268   CacheFlag::SetStatus(CacheFlag::Status::PREPARING);
 269   auto lock = CacheFlag::GetWriterLock();
 270   for (auto& conn : conn_list) {
 271     auto& provider = database::DBHandleProvider::GetInst(conn.second);
 272     for (const auto& [flag, name] : changes) {
 273       switch (flag) {
 274       case CacheChangeFlag::PKG:
 275         success = provider.UpdateCachePkg(conn.first, uid_, name, GetLocale());
 276         break;
 277       case CacheChangeFlag::APP:
 278         success = provider.UpdateCacheApp(conn.first, uid_, name, GetLocale());
 279         break;
 280       case CacheChangeFlag::APPBYPKG:
 281         success =
 282             provider.UpdateCacheAppByPkgid(conn.first, uid_, name, GetLocale());
 283         break;
 284       default:
 285         break;
 286       }
 287
 288       if (!success) {
 289         LOG(ERROR) << "Write query failed. " << static_cast<int>(flag) << ' '
 290                    << name;
 291         break;
 292       }
 293     }
 294
 295     if (!success) {
 296       provider.TrimCache();
 297       break;
 298     }
 299   }
 300
 301   CacheFlag::SetStatus(success ?
 302       CacheFlag::Status::PREPARED : CacheFlag::Status::UNPREPARED);
 303
 304   return PMINFO_R_OK;
 305 }
 306
 307 int QueryHandler::Execute() {
 308   std::vector<std::string> queries;
 309   std::vector<std::vector<std::optional<std::string>>> args_list;
 310   std::vector<std::pair<CacheChangeFlag, std::string>> changes;
 311   for (auto& [queryIndex, args] : query_args_) {
 312     const auto& query_info = __query_maker.GetQueryInfo(queryIndex);
 313     const char* query = std::get<0>(query_info);
 314     if (query == nullptr) {
 315       LOG(ERROR) << "Failed to get query";
 316       return PMINFO_R_ERROR;
 317     }
 318
 319     queries.push_back(query);
 320     args_list.push_back(args);
 321
 322     if (GetOpType() == pkgmgr_common::DBOperationType::OPERATION_TYPE_READ)
 323       continue;
 324
 325     CacheChangeFlag flag = std::get<1>(query_info);
 326     if (flag == CacheChangeFlag::NONE)
 327       continue;
 328
 329     /* Cache changed query steps */
 330     unsigned int idx = std::get<2>(query_info);
 331     if (args.size() <= idx) {
 332       LOG(ERROR) << "Invalid query argument";
 333       return PMINFO_R_ERROR;
 334     }
 335
 336     if (!args[idx])
 337       continue;
 338
 339     changes.emplace_back(std::make_pair(flag, *args[idx]));
 340   }
 341
 342   if (GetOpType() == pkgmgr_common::DBOperationType::OPERATION_TYPE_READ) {
 343     int ret = ExecuteReadQuery(queries, args_list);
 344     return ret;
 345   } else {
 346     int ret = ExecuteWriteQuery(queries, args_list, changes);
 347     return ret;
 348   }
 349 }
 350
 351 }  // namespace database
 352 }  // namespace pkgmgr_server