src/common/include/privilege_db.h

   1 /*
   2  * security-manager, database access
   3  *
   4  * Copyright (c) 2000 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
   5  *
   6  * Contact: Rafal Krypa <r.krypa@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 /*
  23  * @file        privilege_db.h
  24  * @author      Krzysztof Sasiak <k.sasiak@samsung.com>
  25  * @author      Rafal Krypa <r.krypa@samsung.com>
  26  * @version     1.0
  27  * @brief       This file contains declaration of the API to privilges database.
  28  */
  29
  30 #include <cstdio>
  31 #include <list>
  32 #include <map>
  33 #include <stdbool.h>
  34 #include <string>
  35
  36 #include <dpl/db/sql_connection.h>
  37 #include <tzplatform_config.h>
  38
  39 #ifndef PRIVILEGE_DB_H_
  40 #define PRIVILEGE_DB_H_
  41
  42 namespace SecurityManager {
  43
  44 const char *const PRIVILEGE_DB_PATH = tzplatform_mkpath(TZ_SYS_DB, ".security-manager.db");
  45
  46 enum class QueryType {
  47     EGetPkgPrivileges,
  48     EAddApplication,
  49     ERemoveApplication,
  50     EAddAppPrivileges,
  51     ERemoveAppPrivileges,
  52     EPkgIdExists,
  53     EGetPkgId,
  54     EGetPrivilegeGroups,
  55     EGetUserApps,
  56 };
  57
  58 class PrivilegeDb {
  59     /**
  60      * PrivilegeDb database class
  61      */
  62
  63 private:
  64     /**
  65      * Constructor
  66      * @exception DB::SqlConnection::Exception::IOError on problems with database access
  67      *
  68      */
  69     PrivilegeDb(const std::string &path = std::string(PRIVILEGE_DB_PATH));
  70
  71     SecurityManager::DB::SqlConnection *mSqlConnection;
  72     const std::map<QueryType, const char * const > Queries = {
  73         { QueryType::EGetPkgPrivileges, "SELECT DISTINCT privilege_name FROM app_privilege_view WHERE pkg_name=? AND uid=? ORDER BY privilege_name"},
  74         { QueryType::EAddApplication, "INSERT INTO app_pkg_view (app_name, pkg_name, uid) VALUES (?, ?, ?)" },
  75         { QueryType::ERemoveApplication, "DELETE FROM app_pkg_view WHERE app_name=? AND uid=?" },
  76         { QueryType::EAddAppPrivileges, "INSERT INTO app_privilege_view (app_name, uid, privilege_name) VALUES (?, ?, ?)" },
  77         { QueryType::ERemoveAppPrivileges, "DELETE FROM app_privilege_view WHERE app_name=? AND uid=?" },
  78         { QueryType::EPkgIdExists, "SELECT * FROM pkg WHERE name=?" },
  79         { QueryType::EGetPkgId, " SELECT pkg_name FROM app_pkg_view WHERE app_name = ?" },
  80         { QueryType::EGetPrivilegeGroups, " SELECT name FROM privilege_group_view WHERE privilege_name = ?" },
  81         { QueryType::EGetUserApps, "SELECT name FROM app WHERE uid=?" },
  82     };
  83
  84     /**
  85      * Container for initialized DataCommands, prepared for binding.
  86      */
  87     std::vector<DB::SqlConnection::DataCommandAutoPtr> m_commands;
  88
  89     /**
  90      * Fills empty m_commands map with sql commands prepared for binding.
  91      *
  92      * Because the "sqlite3_prepare_v2" function takes many cpu cycles, the PrivilegeDb
  93      * is optimized to call it only once for one query type.
  94      * Designed to be used in the singleton contructor.
  95      */
  96     void initDataCommands();
  97
  98     /**
  99      * Check if pkgId is already registered in database
 100      *
 101      * @param pkgId - package identifier
 102      * @exception DB::SqlConnection::Exception::InternalError on internal error
 103      * @return true if pkgId exists in the database
 104      *
 105      */
 106     bool PkgIdExists(const std::string &pkgId);
 107
 108 public:
 109     class Exception
 110     {
 111       public:
 112         DECLARE_EXCEPTION_TYPE(SecurityManager::Exception, Base)
 113         DECLARE_EXCEPTION_TYPE(Base, IOError)
 114         DECLARE_EXCEPTION_TYPE(Base, InternalError)
 115     };
 116
 117     ~PrivilegeDb(void);
 118
 119     static PrivilegeDb &getInstance();
 120
 121     /**
 122      * Begin transaction
 123      * @exception DB::SqlConnection::Exception::InternalError on internal error
 124      *
 125      */
 126     void BeginTransaction(void);
 127
 128     /**
 129      * Commit transaction
 130      * @exception DB::SqlConnection::Exception::InternalError on internal error
 131      *
 132      */
 133     void CommitTransaction(void);
 134
 135     /**
 136      * Rollback transaction
 137      * @exception DB::SqlConnection::Exception::InternalError on internal error
 138      *
 139      */
 140     void RollbackTransaction(void);
 141
 142     /**
 143      * Return package id associated with a given application id
 144      *
 145      * @param appId - application identifier
 146      * @param[out] pkgId - return application's pkgId
 147      * @return true is application exists, false otherwise
 148      * @exception DB::SqlConnection::Exception::InternalError on internal error
 149      */
 150     bool GetAppPkgId(const std::string &appId, std::string &pkgId);
 151
 152     /**
 153      * Retrieve list of privileges assigned to a pkgId
 154      *
 155      * @param pkgId - package identifier
 156      * @param uid - user identifier for whom privileges will be retrieved
 157      * @param[out] currentPrivileges - list of current privileges assigned to pkgId
 158      * @exception DB::SqlConnection::Exception::InternalError on internal error
 159      */
 160     void GetPkgPrivileges(const std::string &pkgId, uid_t uid,
 161             std::vector<std::string> &currentPrivilege);
 162
 163     /**
 164      * Add an application into the database
 165      *
 166      * @param appId - application identifier
 167      * @param pkgId - package identifier
 168      * @param uid - user identifier for whom application is going to be installed
 169      * @param[out] pkgIdIsNew - return info if pkgId is new to the database
 170      * @exception DB::SqlConnection::Exception::InternalError on internal error
 171      */
 172     void AddApplication(const std::string &appId, const std::string &pkgId,
 173             uid_t uid, bool &pkgIdIsNew);
 174
 175     /**
 176      * Remove an application from the database
 177      *
 178      * @param appId - application identifier
 179      * @param uid - user identifier whose application is going to be uninstalled
 180      * @param[out] pkgIdIsNoMore - return info if pkgId is in the database
 181      * @exception DB::SqlConnection::Exception::InternalError on internal error
 182      */
 183     void RemoveApplication(const std::string &appId, uid_t uid, bool &pkgIdIsNoMore);
 184
 185     /**
 186      * Remove privileges assigned to application
 187      *
 188      * @param appId - application identifier
 189      * @param uid - user identifier for whom privileges will be removed
 190      * @exception DB::SqlConnection::Exception::InternalError on internal error
 191      */
 192     void RemoveAppPrivileges(const std::string &appId, uid_t uid);
 193
 194     /**
 195      * Update privileges assigned to application
 196      * To assure data integrity this method must be called inside db transaction.
 197      *
 198      * @param appId - application identifier
 199      * @param uid - user identifier for whom privileges will be updated
 200      * @param privileges - list of privileges to assign
 201      * @exception DB::SqlConnection::Exception::InternalError on internal error
 202      */
 203     void UpdateAppPrivileges(const std::string &appId, uid_t uid,
 204             const std::vector<std::string> &privileges);
 205
 206     /**
 207      * Retrieve list of group ids assigned to a privilege
 208      *
 209      * @param privilege - privilege identifier
 210      * @param[out] grp_names - list of group names assigned to the privilege
 211      * @exception DB::SqlConnection::Exception::InternalError on internal error
 212      */
 213     void GetPrivilegeGroups(const std::string &privilege,
 214         std::vector<std::string> &grp_names);
 215
 216     /**
 217      * Retrieve list of apps assigned to user
 218      *
 219      * @param uid - user identifier
 220      * @param[out] apps - list of apps assigned to user,
 221      *                    this parameter do not need to be empty, but
 222      *                    it is being overwritten during function call.
 223      * @exception DB::SqlConnection::Exception::InternalError on internal error
 224      */
 225     void GetUserApps(uid_t uid, std::vector<std::string> &apps);
 226 };
 227
 228 } //namespace SecurityManager
 229
 230 #endif // PRIVILEGE_DB_H_