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 <vector>
  21
  22 #include "pkgmgrinfo_debug.h"
  23 #include "pkgmgrinfo_internal.h"
  24 #include "pkgmgr_query_index.h"
  25
  26 namespace {
  27
  28 constexpr const char query_appinfo_get_localed_label[] =
  29     "SELECT COALESCE((SELECT app_label FROM package_app_localized_info "
  30     "WHERE app_id=? AND app_locale=?),"
  31     "(SELECT app_label FROM package_app_localized_info WHERE "
  32     "app_id=? AND app_locale='No Locale'))";
  33
  34 constexpr const char query_appinfo_get_datacontrol_info[] =
  35     "SELECT app_id, access FROM "
  36     "package_app_data_control WHERE "
  37     "providerid=? AND type=?";
  38
  39 constexpr const char query_appinfo_get_datacontrol_appid[] =
  40     "SELECT app_id FROM package_app_data_control "
  41     "WHERE providerid=?";
  42
  43 constexpr const char query_appinfo_get_datacontrol_trusted_info[] =
  44     "SELECT app_id, trusted FROM package_app_data_control "
  45     "WHERE providerid=? AND type=?";
  46
  47 constexpr const char query_appinfo_get_datacontrol_privileges[] =
  48     "SELECT privilege FROM package_app_data_control_privilege "
  49     "WHERE providerid=? AND type=?";
  50
  51 constexpr const char query_appinfo_get_appcontrol_privileges[] =
  52     "SELECT app_control, privilege FROM package_app_app_control_privilege "
  53     "WHERE app_id=?";
  54
  55 constexpr const char query_plugininfo_get_appids[] =
  56     "SELECT appid FROM "
  57     "package_plugin_info WHERE pkgid=? AND "
  58     "plugin_type=? AND plugin_name=?";
  59
  60 constexpr const char query_get_pkg_updateinfo_1[] =
  61     "SELECT package, update_version, update_type "
  62     "FROM package_update_info";
  63 constexpr const char query_get_pkg_updateinfo_2[] =
  64     "SELECT package, update_version, update_type "
  65     "FROM package_update_info WHERE package=?";
  66
  67 constexpr const char query_pkginfo_set_usr_installed_storage_1[] =
  68     "UPDATE package_info SET installed_storage=?, external_path=? "
  69     "WHERE package=?";
  70 constexpr const char query_pkginfo_set_usr_installed_storage_2[] =
  71     "UPDATE package_app_info SET app_installed_storage=?, "
  72     "app_external_path=? WHERE package=?";
  73
  74 constexpr const char query_certinfo_compare_pkg_certinfo[] =
  75     "SELECT package, "
  76     "COALESCE(author_signer_cert, -1) FROM package_cert_info WHERE "
  77     "package IN (?, ?)";
  78
  79 constexpr const char query_certinfo_compare_app_certinfo[] =
  80     "SELECT app_id, package FROM "
  81     "package_app_info WHERE app_id IN (?, ?)";
  82
  83 constexpr const char query_pkginfo_delete_certinfo[] =
  84     "UPDATE package_cert_info SET "
  85     "package_count = package_count - 1 WHERE package=?";
  86
  87 // For pkgmgr_parser
  88 constexpr const char query_insert_package_plugin_execution_info[] =
  89     "INSERT INTO package_plugin_info "
  90     "(pkgid, appid, plugin_type, plugin_name) "
  91     "VALUES (?, ?, ?, ?)";
  92
  93 constexpr const char query_delete_package_plugin_execution_info[] =
  94     "DELETE FROM package_plugin_info WHERE pkgid=?";
  95
  96 constexpr const char query_update_global_app_disable[] =
  97     "INSERT OR REPLACE INTO package_app_info_for_uid ("
  98     "  app_id, uid, is_disabled, is_splash_screen_enabled) "
  99     "VALUES (?, ?, ?,"
 100     "  (SELECT app_splash_screen_display FROM package_app_info"
 101     "   WHERE app_id=?))";
 102
 103 constexpr const char query_update_app_disable_info[] =
 104     "UPDATE package_app_info SET app_disable=? "
 105     "WHERE app_id=?";
 106
 107 constexpr const char query_update_pkg_disable_info[] =
 108     "UPDATE package_info SET package_disable=? "
 109     "WHERE package=?";
 110
 111 constexpr const char query_update_global_app_splash_screen_display_info[] =
 112     "INSERT OR REPLACE INTO package_app_info_for_uid("
 113     "  app_id, uid, is_splash_screen_enabled) "
 114     "VALUES (?, ?, ?)";
 115
 116 constexpr const char query_update_app_splash_screen_display_info[] =
 117     "UPDATE package_app_info SET app_splash_screen_display=? "
 118     "WHERE app_id=?";
 119
 120 constexpr const char query_update_app_label_info[] =
 121     "UPDATE package_app_localized_info SET app_label=? "
 122     "WHERE app_id=? AND app_label IS NOT NULL";
 123
 124 constexpr const char query_update_app_icon_info[] =
 125     "UPDATE package_app_localized_info SET app_icon=? "
 126     "WHERE app_id=? AND app_icon IS NOT NULL";
 127
 128 constexpr const char query_update_tep_info[] =
 129     "UPDATE package_info SET package_tep_name=? "
 130     "WHERE package=?";
 131
 132 constexpr const char query_register_pkg_update_info[] =
 133     "UPDATE package_update_info "
 134     "SET update_version=?, update_type=? "
 135     "WHERE package=?";
 136
 137 constexpr const char query_unregister_pkg_update_info[] =
 138     "UPDATE package_update_info "
 139     "SET update_type='none' WHERE package=?";
 140
 141 constexpr const char query_unregister_all_pkg_update_info[] =
 142     "UPDATE package_update_info "
 143     "SET update_type='none'";
 144
 145 class QueryMaker {
 146  public:
 147   std::vector<const char*> query_raw_ = {
 148     query_appinfo_get_localed_label,
 149     query_appinfo_get_datacontrol_info,
 150     query_appinfo_get_datacontrol_appid,
 151     query_appinfo_get_datacontrol_trusted_info,
 152     query_appinfo_get_datacontrol_privileges,
 153     query_appinfo_get_appcontrol_privileges,
 154     query_plugininfo_get_appids,
 155     query_get_pkg_updateinfo_1,
 156     query_get_pkg_updateinfo_2,
 157     query_pkginfo_set_usr_installed_storage_1,
 158     query_pkginfo_set_usr_installed_storage_2,
 159     query_certinfo_compare_pkg_certinfo,
 160     query_certinfo_compare_app_certinfo,
 161     query_pkginfo_delete_certinfo,
 162
 163     query_insert_package_plugin_execution_info,
 164     query_delete_package_plugin_execution_info,
 165     query_update_global_app_disable,
 166     query_update_app_disable_info,
 167     query_update_pkg_disable_info,
 168     query_update_global_app_splash_screen_display_info,
 169     query_update_app_splash_screen_display_info,
 170     query_update_app_label_info,
 171     query_update_app_icon_info,
 172     query_update_tep_info,
 173     query_register_pkg_update_info,
 174     query_unregister_pkg_update_info,
 175     query_unregister_all_pkg_update_info,
 176   };
 177
 178   const char* GetQuery(int index) {
 179     return query_raw_[index];
 180   }
 181 };
 182
 183 QueryMaker __query_maker;
 184
 185 void __free_argument(gpointer data) {
 186   query_args* args = (query_args*)data;
 187   g_list_free(args->argument);
 188   free(args);
 189 }
 190
 191 void __free_query_list(GList* queries, GList* args_list) {
 192   g_list_free(queries);
 193   g_list_free_full(args_list, __free_argument);
 194 }
 195
 196 }  // namespace
 197
 198 namespace pkgmgr_server {
 199 namespace database {
 200
 201 QueryHandler::QueryHandler(uid_t uid, int pid)
 202     : AbstractDBHandler(uid, pid), uid_(uid) {}
 203
 204 QueryHandler::~QueryHandler() {}
 205
 206 void QueryHandler::SetQueryArgs(
 207     std::vector<std::pair<int, std::vector<std::string>>> query_args) {
 208   query_args_ = std::move(query_args);
 209 }
 210
 211 std::string QueryHandler::GetString() { return std::string(); }
 212 int QueryHandler::GetInt() { return 0; }
 213 int QueryHandler::GetRecordCount() { return 0; }
 214
 215 std::vector<std::vector<std::string>> QueryHandler::GetResult() {
 216   return std::move(result_);
 217 }
 218
 219 int QueryHandler::Execute() {
 220   std::shared_lock<std::shared_timed_mutex> s(lock_);
 221   if (!Connect()) {
 222     _LOGE("Failed to connect database");
 223     return PMINFO_R_ERROR;
 224   }
 225
 226   GList* queries = nullptr;
 227   GList* args_list = nullptr;
 228   for (auto& i : query_args_) {
 229     const char* query = __query_maker.GetQuery(i.first);
 230     if (query == nullptr) {
 231       _LOGE("Failed to get query");
 232       __free_query_list(queries, args_list);
 233       return PMINFO_R_ERROR;
 234     }
 235
 236     queries = g_list_append(queries, (gpointer)query);
 237     query_args* arg = (query_args*)calloc(1, sizeof(query_args));
 238     if (arg == nullptr) {
 239       _LOGE("Out of memory");
 240       __free_query_list(queries, args_list);
 241       return PMINFO_R_ERROR;
 242     }
 243     arg->len = i.second.size();
 244     for (auto& argument : i.second)
 245       arg->argument = g_list_append(arg->argument, (gpointer)argument.c_str());
 246
 247     args_list = g_list_append(args_list, arg);
 248   }
 249
 250   std::vector<std::pair<sqlite3*, uid_t>> conn_list = GetConnection();
 251   int ret;
 252   if (GetOpType() == pkgmgr_common::DBOperationType::OPERATION_TYPE_READ) {
 253     for (auto& conn : conn_list) {
 254       for (GList* it = args_list; it; it = it->next) {
 255         GList* list = nullptr;
 256         int row = 0;
 257         int col = 0;
 258
 259         query_args* params = (query_args*)it->data;
 260         ret = get_query_result(conn.first, (const char *)queries->data,
 261             params->argument, &list, &row, &col);
 262         if (ret == PMINFO_R_ERROR) {
 263           _LOGE("Failed to execute query");
 264           __free_query_list(queries, args_list);
 265           return ret;
 266         }
 267
 268         GList* tmp = list;
 269         for (int i = 0; i < row; ++i) {
 270           std::vector<std::string> vt;
 271           for (int j = 0; j < col; ++j) {
 272             vt.emplace_back(reinterpret_cast<char *>(tmp->data));
 273             tmp = tmp->next;
 274           }
 275           result_.emplace_back(std::move(vt));
 276         }
 277
 278         g_list_free_full(list, free);
 279       }
 280     }
 281     __free_query_list(queries, args_list);
 282
 283     return ret;
 284   } else {
 285     for (auto& conn : conn_list) {
 286       ret = execute_write_queries(conn.first, queries, args_list);
 287       if (ret != PMINFO_R_OK) {
 288         _LOGE("Failed to execute");
 289         break;
 290       }
 291     }
 292     __free_query_list(queries, args_list);
 293     return ret;
 294
 295   }
 296   return ret;
 297 }
 298
 299 }  // namespace database
 300 }  // namespace pkgmgr_server