1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "cm_rdb_data_manager.h"
17
18 #include "cm_log.h"
19 #include "cm_rdb_open_callback.h"
20 #include "cm_scope_guard.h"
21
22 namespace OHOS {
23 namespace Security {
24 namespace CertManager {
25 const int32_t CLOSE_RDB_TIME = 20; // delay 20s stop rdbStore
CmRdbDataManager(const RdbConfig & rdbConfig)26 CmRdbDataManager::CmRdbDataManager(const RdbConfig &rdbConfig) : rdbConfig_(rdbConfig) {}
27
~CmRdbDataManager()28 CmRdbDataManager::~CmRdbDataManager()
29 {
30 std::lock_guard<std::mutex> lock(rdbMutex_);
31 rdbStore_ = nullptr;
32 }
33
InsertData(const NativeRdb::ValuesBucket & valuesBucket)34 bool CmRdbDataManager::InsertData(const NativeRdb::ValuesBucket &valuesBucket)
35 {
36 CM_LOG_D("enter CmRdbDataManager InsertData");
37 auto rdbStore = GetRdbStore();
38 if (rdbStore == nullptr) {
39 CM_LOG_E("rdbStore is nullptr");
40 return false;
41 }
42
43 int64_t rowId = -1;
44 auto ret = rdbStore->InsertWithConflictResolution(rowId, rdbConfig_.tableName, valuesBucket,
45 NativeRdb::ConflictResolution::ON_CONFLICT_REPLACE);
46 return ret == NativeRdb::E_OK;
47 }
48
UpdateData(const std::string & primKey,const std::string & keyColumn,const NativeRdb::ValuesBucket & valuesBucket)49 bool CmRdbDataManager::UpdateData(const std::string &primKey, const std::string &keyColumn,
50 const NativeRdb::ValuesBucket &valuesBucket)
51 {
52 CM_LOG_D("enter CmRdbDataManager UpdateData");
53 auto rdbStore = GetRdbStore();
54 if (rdbStore == nullptr) {
55 CM_LOG_E("rdbStore is nullptr");
56 return false;
57 }
58
59 NativeRdb::AbsRdbPredicates updatePredicates(rdbConfig_.tableName);
60 updatePredicates.EqualTo(keyColumn, primKey);
61 int32_t rowId = -1;
62 auto ret = rdbStore->Update(rowId, valuesBucket, updatePredicates);
63 return ret == NativeRdb::E_OK;
64 }
65
DeleteData(const std::string & primKey,const std::string & keyColumn)66 bool CmRdbDataManager::DeleteData(const std::string &primKey, const std::string &keyColumn)
67 {
68 CM_LOG_D("enter CmRdbDataManager DeleteData");
69 auto rdbStore = GetRdbStore();
70 if (rdbStore == nullptr) {
71 CM_LOG_E("rdbStore is nullptr");
72 return false;
73 }
74
75 NativeRdb::AbsRdbPredicates deletePredicates(rdbConfig_.tableName);
76 deletePredicates.EqualTo(keyColumn, primKey);
77 int32_t rowId = -1;
78 auto ret = rdbStore->Delete(rowId, deletePredicates);
79 return ret == NativeRdb::E_OK;
80 }
81
QueryData(const std::string & primKey,const std::string & keyColumn)82 std::shared_ptr<NativeRdb::AbsSharedResultSet> CmRdbDataManager::QueryData(const std::string &primKey,
83 const std::string &keyColumn)
84 {
85 CM_LOG_D("enter CmRdbDataManager QueryData");
86 auto rdbStore = GetRdbStore();
87 if (rdbStore == nullptr) {
88 CM_LOG_E("rdbStore is nullptr");
89 return nullptr;
90 }
91
92 NativeRdb::AbsRdbPredicates queryPredicates(rdbConfig_.tableName);
93 queryPredicates.EqualTo(keyColumn, primKey);
94 std::shared_ptr<NativeRdb::AbsSharedResultSet> absSharedResultSet =
95 rdbStore->Query(queryPredicates, std::vector<std::string>());
96 if (absSharedResultSet == nullptr) {
97 CM_LOG_E("absSharedResultSet is nullptr");
98 return nullptr;
99 }
100 if (!absSharedResultSet->HasBlock()) {
101 CM_LOG_E("absSharedResultSet query failed");
102 absSharedResultSet->Close();
103 return nullptr;
104 }
105 return absSharedResultSet;
106 }
107
CreateTable()108 bool CmRdbDataManager::CreateTable()
109 {
110 CM_LOG_D("enter CmRdbDataManager CreateTable");
111 auto rdbStore = GetRdbStore();
112 if (rdbStore == nullptr) {
113 CM_LOG_E("rdbStore is nullptr");
114 return false;
115 }
116
117 if (rdbConfig_.createTableSql.empty()) {
118 CM_LOG_E("createTableSql is nullptr");
119 return false;
120 }
121
122 int ret = rdbStore->ExecuteSql(rdbConfig_.createTableSql);
123 if (ret != NativeRdb::E_OK) {
124 CM_LOG_E("Failed to create table, ret: %{public}d", ret);
125 return false;
126 }
127 return true;
128 }
129
DelayCloseRdbStore()130 void CmRdbDataManager::DelayCloseRdbStore()
131 {
132 CM_LOG_D("enter CmRdbDataManager DelayCloseRdbStore");
133 std::weak_ptr<CmRdbDataManager> weakPtr = shared_from_this();
134 auto closeTask = [weakPtr]() {
135 CM_LOG_D("DelayCloseRdbStore thread begin");
136 std::this_thread::sleep_for(std::chrono::seconds(CLOSE_RDB_TIME));
137 auto sharedPtr = weakPtr.lock();
138 if (sharedPtr == nullptr) {
139 return;
140 }
141 std::lock_guard<std::mutex> lock(sharedPtr->rdbMutex_);
142 sharedPtr->rdbStore_ = nullptr;
143 CM_LOG_D("DelayCloseRdbStore thread end");
144 };
145 std::thread closeRdbStoreThread(closeTask);
146 closeRdbStoreThread.detach();
147 }
148
ClearCache()149 void CmRdbDataManager::CmRdbDataManager::ClearCache()
150 {
151 NativeRdb::RdbHelper::ClearCache();
152 }
153
GetRdbStore()154 std::shared_ptr<NativeRdb::RdbStore> CmRdbDataManager::GetRdbStore()
155 {
156 CM_LOG_D("enter CmRdbDataManager GetRdbStore");
157 std::lock_guard<std::mutex> lock(rdbMutex_);
158 if (rdbStore_ != nullptr) {
159 return rdbStore_;
160 }
161
162 int32_t errCode = NativeRdb::E_OK;
163 NativeRdb::RdbStoreConfig rdbStoreConfig(rdbConfig_.dbPath + rdbConfig_.dbName);
164 rdbStoreConfig.SetSecurityLevel(NativeRdb::SecurityLevel::S1);
165 CmRdbOpenCallback cmRdbOpenCallback(rdbConfig_);
166 rdbStore_ = NativeRdb::RdbHelper::GetRdbStore(rdbStoreConfig, rdbConfig_.version, cmRdbOpenCallback, errCode);
167 if (rdbStore_ == nullptr) {
168 CM_LOG_E("Failed to init cert manager rdbStore");
169 }
170 DelayCloseRdbStore();
171 return rdbStore_;
172 }
173 } // namespace CertManager
174 } // namespace Security
175 } // namespace OHOS