1 /*
2 * Copyright (c) 2022 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 "net_stats_database_helper.h"
17
18 #include <cstdlib>
19 #include <filesystem>
20
21 #include "net_manager_constants.h"
22 #include "net_mgr_log_wrapper.h"
23 #include "net_stats_constants.h"
24 #include "net_stats_database_defines.h"
25 #include "net_stats_info.h"
26 #include "net_stats_rdb.h"
27
28 namespace OHOS {
29 namespace NetManagerStandard {
30 using namespace NetStatsDatabaseDefines;
31 namespace {
32 [[maybe_unused]] const int32_t RDB_VERSION_0 = 0;
33 const int32_t RDB_VERSION_1 = 1;
34 const int32_t RDB_VERSION_2 = 2;
35 const std::string NETMANAGER_DB_SIMID_STATS_TABLE = "uid_stats_infos";
36 const std::string SQL_TABLE_COLUMS = std::string(
37 "simId INTEGER NOT NULL PRIMARY KEY, "
38 "monthWarningdate INTEGER NOT NULL, dayNontificationdate INTEGER NOT NULL, monthNontificationdate "
39 "INTEGER NOT NULL, monthWarningState INTEGER NOT NULL, dayNontificationState "
40 "INTEGER NOT NULL, monNontificationState INTEGER NOT NULL"
41 );
42 } // namespace
43
OnCreate(NativeRdb::RdbStore & rdbStore)44 int NetStatsRDB::RdbDataOpenCallback::OnCreate(NativeRdb::RdbStore &rdbStore)
45 {
46 return NETMANAGER_SUCCESS;
47 }
48
49
OnUpgrade(NativeRdb::RdbStore & store,int oldVersion,int newVersion)50 int NetStatsRDB::RdbDataOpenCallback::OnUpgrade(NativeRdb::RdbStore &store, int oldVersion, int newVersion)
51 {
52 NETMGR_LOG_I("OnUpgrade, oldVersion: %{public}d, newVersion: %{public}d", oldVersion, newVersion);
53 while (oldVersion < newVersion) {
54 UpgradeDbVersionTo(store, ++oldVersion);
55 }
56 return NETMANAGER_SUCCESS;
57 }
58
59 /* 这里删除了AddIsBreaker */
UpgradeDbVersionTo(NativeRdb::RdbStore & store,int newVersion)60 void NetStatsRDB::RdbDataOpenCallback::UpgradeDbVersionTo(NativeRdb::RdbStore &store, int newVersion)
61 {
62 switch (newVersion) {
63 case RDB_VERSION_1:
64 // When upgrading the rdb version to 1, the is_broker field was added, but some users failed the upgrade.
65 case RDB_VERSION_2:
66 break;
67 default:
68 NETMGR_LOG_E("no such newVersion: %{public}d", newVersion);
69 }
70 }
71
GetRdbStore()72 int32_t NetStatsRDB::GetRdbStore()
73 {
74 std::lock_guard<std::mutex> lock(mutex_);
75 if (rdbStore_ != nullptr) {
76 return NETMANAGER_SUCCESS;
77 }
78
79 int errCode = NETMANAGER_SUCCESS;
80 NativeRdb::RdbStoreConfig config(NOTICE_DATABASE_NAME);
81 NetStatsRDB::RdbDataOpenCallback helper;
82 rdbStore_ = NativeRdb::RdbHelper::GetRdbStore(config, RDB_VERSION_2, helper, errCode);
83 if (rdbStore_ != nullptr) {
84 NETMGR_LOG_E("RDB GetRdbStore success");
85 return NETMANAGER_SUCCESS;
86 }
87 NETMGR_LOG_E("RDB create failed, errCode: %{public}d", errCode);
88 if (errCode == NativeRdb::E_SQLITE_CORRUPT) {
89 int rettmp = NativeRdb::RdbHelper::DeleteRdbStore(config);
90 NETMGR_LOG_E("rdbStore_ DeleteRdbStore ret: %{public}d", rettmp);
91 rdbStore_ = NativeRdb::RdbHelper::GetRdbStore(config, RDB_VERSION_2, helper, errCode);
92 if (rdbStore_ != nullptr) {
93 int restorRet = rdbStore_->Restore(NOTICE_DATABASE_BACK_NAME);
94 NETMGR_LOG_E("RDB Restore restorRet: %{public}d", restorRet);
95 if (restorRet == 0) {
96 NETMGR_LOG_E("RDB rdbStore success");
97 return NETMANAGER_SUCCESS;
98 }
99 }
100 }
101 return NETMANAGER_ERR_IPC_CONNECT_STUB_FAIL;
102 }
103
BackUpNetStatsFreqDB(const std::string & sourceDB,const std::string & targetDB)104 int32_t NetStatsRDB::BackUpNetStatsFreqDB(const std::string &sourceDB, const std::string &targetDB)
105 {
106 NETMGR_LOG_E("RDB rdbStore BackUpNetStatsFreqDB start");
107 if (sourceDB.empty() || targetDB.empty()) {
108 NETMGR_LOG_E("sourceDB or targetDB is empty");
109 return NETMANAGER_ERROR;
110 }
111 int errCode = NETMANAGER_SUCCESS;
112 NativeRdb::RdbStoreConfig config(targetDB);
113 NetStatsRDB::RdbDataOpenCallback helper;
114 auto rdbStore = NativeRdb::RdbHelper::GetRdbStore(config, RDB_VERSION_2, helper, errCode);
115 if (rdbStore == nullptr) {
116 NETMGR_LOG_E("RDB GetRdbStore failed, errCode: %{public}d", errCode);
117 return NETMANAGER_ERROR;
118 }
119 int ret = rdbStore->Restore(sourceDB);
120 NETMGR_LOG_E("RDB rdbStore BackUpNetStatsFreqDB Restore ret: %{public}d", ret);
121 return NETMANAGER_SUCCESS;
122 }
123
InitRdbStore()124 int32_t NetStatsRDB::InitRdbStore()
125 {
126 InitRdbStoreBackupDB();
127 NETMGR_LOG_I("RDB NetStatsRDB InitRdbStore start");
128 int32_t ret = GetRdbStore();
129 if (ret != NETMANAGER_SUCCESS) {
130 NETMGR_LOG_I("RDB NetStatsRDB InitRdbStore NETMANAGER_SUCCESS");
131 return ret;
132 }
133
134 std::string createTable =
135 CREATE_TABLE_IF_NOT_EXISTS + NETMANAGER_DB_SIMID_STATS_TABLE + " (" + SQL_TABLE_COLUMS + ")";
136 int ret0 = rdbStore_->ExecuteSql(createTable);
137 NETMGR_LOG_I("InitRdbStore ret = %{public}d", ret0);
138 return NETMANAGER_SUCCESS;
139 }
140
InitRdbStoreBackupDB()141 int32_t NetStatsRDB::InitRdbStoreBackupDB()
142 {
143 NETMGR_LOG_I("InitRdbStoreBackupDB start");
144 int errCode = NETMANAGER_SUCCESS;
145 NativeRdb::RdbStoreConfig config(NOTICE_DATABASE_BACK_NAME);
146 NetStatsRDB::RdbDataOpenCallback helper;
147 std::shared_ptr<NativeRdb::RdbStore> rdbStore =
148 NativeRdb::RdbHelper::GetRdbStore(config, RDB_VERSION_2, helper, errCode);
149 if (rdbStore == nullptr) {
150 NETMGR_LOG_E("RDB create failed, errCode: %{public}d", errCode);
151 if (errCode == NativeRdb::E_SQLITE_CORRUPT) {
152 NETMGR_LOG_E("RDB create retry");
153 NativeRdb::RdbHelper::DeleteRdbStore(config);
154 rdbStore = NativeRdb::RdbHelper::GetRdbStore(config, RDB_VERSION_2, helper, errCode);
155 if (rdbStore == nullptr) {
156 return NETMANAGER_ERROR;
157 }
158 } else {
159 return NETMANAGER_ERROR;
160 }
161 }
162
163 std::string createTable =
164 CREATE_TABLE_IF_NOT_EXISTS + NETMANAGER_DB_SIMID_STATS_TABLE + " (" + SQL_TABLE_COLUMS + ")";
165 int ret = rdbStore->ExecuteSql(createTable);
166 NETMGR_LOG_I("InitRdbStore ret = %{public}d", ret);
167 return NETMANAGER_SUCCESS;
168 }
169
InsertData(NetStatsData state)170 int32_t NetStatsRDB::InsertData(NetStatsData state)
171 {
172 NETMGR_LOG_I("InsertData");
173 int32_t ret = GetRdbStore();
174 if (ret != NETMANAGER_SUCCESS) {
175 NETMGR_LOG_E("error: rdbStore_ is nullptr");
176 return NETMANAGER_ERROR;
177 }
178
179 NativeRdb::ValuesBucket statsValues;
180 /*simIDd*/
181 statsValues.PutInt(NetStatsRdbFiledConst::FILED_SIMID, state.simId);
182 statsValues.PutInt(NetStatsRdbFiledConst::FILED_MON_W, state.monWarningDate);
183 statsValues.PutInt(NetStatsRdbFiledConst::FILED_DAY_N, state.dayNoticeDate);
184 statsValues.PutInt(NetStatsRdbFiledConst::FILED_MON_N, state.monNoticeDate);
185 statsValues.PutInt(NetStatsRdbFiledConst::FILED_MON_W_S, state.monWarningState);
186 statsValues.PutInt(NetStatsRdbFiledConst::FILED_DAY_N_S, state.dayNoticeState);
187 statsValues.PutInt(NetStatsRdbFiledConst::FILED_MON_N_S, state.monNoticeState);
188 int64_t id = 0;
189 ret = rdbStore_->Insert(id, NETMANAGER_DB_SIMID_STATS_TABLE, statsValues);
190 if (ret != NativeRdb::E_OK) {
191 ret = UpdateBySimId(state.simId, state);
192 if (ret != NETMANAGER_SUCCESS) {
193 NETMGR_LOG_E("Update operation failed, result is %{public}d", ret);
194 return NETMANAGER_ERROR;
195 }
196 }
197
198 return NETMANAGER_SUCCESS;
199 }
200
DeleteBySimId(int32_t simId)201 int32_t NetStatsRDB::DeleteBySimId(int32_t simId)
202 {
203 NETMGR_LOG_I("DeleteBySimId");
204 int32_t ret = GetRdbStore();
205 if (ret != NETMANAGER_SUCCESS) {
206 NETMGR_LOG_E("error: rdbStore_ is nullptr");
207 return NETMANAGER_ERROR;
208 }
209
210 int32_t deletedRows = -1;
211 std::vector<std::string> whereArgs;
212 NativeRdb::RdbPredicates rdbPredicate{NETMANAGER_DB_SIMID_STATS_TABLE};
213 rdbPredicate.EqualTo(NetStatsRdbFiledConst::FILED_SIMID, std::to_string(simId));
214 int32_t result = rdbStore_->Delete(deletedRows, rdbPredicate);
215 if (result != NativeRdb::E_OK) {
216 NETMGR_LOG_E("delete operation failed, result is %{public}d", result);
217 return result;
218 }
219
220 return deletedRows;
221 }
222
UpdateBySimId(int32_t simId,NetStatsData state)223 int32_t NetStatsRDB::UpdateBySimId(int32_t simId, NetStatsData state)
224 {
225 NETMGR_LOG_I("UpdateBySimId, simId:%{public}d", simId);
226 int32_t ret = GetRdbStore();
227 if (ret != NETMANAGER_SUCCESS) {
228 NETMGR_LOG_E("error: rdbStore_ is nullptr");
229 return NETMANAGER_ERROR;
230 }
231
232 NativeRdb::RdbPredicates rdbPredicate{NETMANAGER_DB_SIMID_STATS_TABLE};
233 NETMGR_LOG_I("begin EqualTo");
234 rdbPredicate.EqualTo(NetStatsRdbFiledConst::FILED_SIMID, std::to_string(simId));
235 NETMGR_LOG_I("end EqualTo");
236
237 NativeRdb::ValuesBucket statsValues;
238 statsValues.PutInt(NetStatsRdbFiledConst::FILED_SIMID, simId);
239 statsValues.PutInt(NetStatsRdbFiledConst::FILED_MON_W, state.monWarningDate);
240 statsValues.PutInt(NetStatsRdbFiledConst::FILED_DAY_N, state.dayNoticeDate);
241 statsValues.PutInt(NetStatsRdbFiledConst::FILED_MON_N, state.monNoticeDate);
242 statsValues.PutInt(NetStatsRdbFiledConst::FILED_MON_W_S, state.monWarningState);
243 statsValues.PutInt(NetStatsRdbFiledConst::FILED_DAY_N_S, state.dayNoticeState);
244 statsValues.PutInt(NetStatsRdbFiledConst::FILED_MON_N_S, state.monNoticeState);
245
246 int32_t rowId = -1;
247 int32_t result = rdbStore_->Update(rowId, statsValues, rdbPredicate);
248 if (result != NativeRdb::E_OK) {
249 NETMGR_LOG_E("Update operation failed. Result %{public}d", result);
250 return result;
251 }
252
253 return NETMANAGER_SUCCESS;
254 }
255
QueryAll()256 std::vector<NetStatsData> NetStatsRDB::QueryAll()
257 {
258 NETMGR_LOG_I("QueryAll");
259 std::vector<NetStatsData> result;
260 int32_t ret = GetRdbStore();
261 if (ret != NETMANAGER_SUCCESS) {
262 NETMGR_LOG_E("error: rdbStore_ is nullptr");
263 return result;
264 }
265
266 NativeRdb::RdbPredicates rdbPredicate{NETMANAGER_DB_SIMID_STATS_TABLE};
267 std::vector<std::string> whereArgs;
268 auto queryResultSet = rdbStore_->Query(rdbPredicate, whereArgs);
269 if (queryResultSet == nullptr) {
270 return result;
271 }
272
273 bool isAtLastRow = false;
274 queryResultSet->IsAtLastRow(isAtLastRow);
275 while (!queryResultSet->GoToNextRow()) {
276 NetStatsData stats;
277 queryResultSet->GetInt(NetStatsRdbFiledConst::FILED_COLUMN_INDEX_ZERO, stats.simId);
278 queryResultSet->GetInt(NetStatsRdbFiledConst::FILED_COLUMN_INDEX_ONE, stats.monWarningDate);
279 queryResultSet->GetInt(NetStatsRdbFiledConst::FILED_COLUMN_INDEX_TWO, stats.dayNoticeDate);
280 queryResultSet->GetInt(NetStatsRdbFiledConst::FILED_COLUMN_INDEX_THR, stats.monNoticeDate);
281 queryResultSet->GetInt(NetStatsRdbFiledConst::FILED_COLUMN_INDEX_FUR, stats.monWarningState);
282 queryResultSet->GetInt(NetStatsRdbFiledConst::FILED_COLUMN_INDEX_FW, stats.dayNoticeState);
283 queryResultSet->GetInt(NetStatsRdbFiledConst::FILED_COLUMN_INDEX_SIX, stats.monNoticeState);
284 result.emplace_back(stats);
285 }
286 queryResultSet->Close();
287 return result;
288 }
289
QueryBySimId(int simId,NetStatsData & simStats)290 int32_t NetStatsRDB::QueryBySimId(int simId, NetStatsData& simStats)
291 {
292 NETMGR_LOG_I("QueryBySimId simId:%{public}d", simId);
293 int32_t ret = GetRdbStore();
294 if (ret != NETMANAGER_SUCCESS) {
295 NETMGR_LOG_E("error: rdbStore_ is nullptr");
296 return NETMANAGER_ERROR;
297 }
298
299 NativeRdb::RdbPredicates rdbPredicate{NETMANAGER_DB_SIMID_STATS_TABLE};
300 rdbPredicate.EqualTo(NetStatsRdbFiledConst::FILED_SIMID, simId);
301
302 std::vector<std::string> whereArgs;
303 auto queryResultSet = rdbStore_->Query(rdbPredicate, whereArgs);
304 if (queryResultSet == nullptr) {
305 NETMGR_LOG_E("QueryBySimId error");
306 return NETMANAGER_ERROR;
307 }
308
309 int32_t rowCount = 0;
310 ret = queryResultSet->GetRowCount(rowCount);
311 if (ret != OHOS::NativeRdb::E_OK) {
312 NETMGR_LOG_E("query setting failed, get row count failed, name:%{public}d, ret:%{public}d", simId, ret);
313 queryResultSet->Close();
314 return ret;
315 }
316 if (rowCount == 0) {
317 NETMGR_LOG_E("query setting name:%{public}d, num is 0", simId);
318 queryResultSet->Close();
319 return NETMANAGER_ERROR;
320 }
321
322 while (!queryResultSet->GoToNextRow()) {
323 queryResultSet->GetInt(NetStatsRdbFiledConst::FILED_COLUMN_INDEX_ONE, simStats.monWarningDate);
324 queryResultSet->GetInt(NetStatsRdbFiledConst::FILED_COLUMN_INDEX_TWO, simStats.dayNoticeDate);
325 queryResultSet->GetInt(NetStatsRdbFiledConst::FILED_COLUMN_INDEX_THR, simStats.monNoticeDate);
326 queryResultSet->GetInt(NetStatsRdbFiledConst::FILED_COLUMN_INDEX_FUR, simStats.monWarningState);
327 queryResultSet->GetInt(NetStatsRdbFiledConst::FILED_COLUMN_INDEX_FW, simStats.dayNoticeState);
328 queryResultSet->GetInt(NetStatsRdbFiledConst::FILED_COLUMN_INDEX_SIX, simStats.monNoticeState);
329 if (simStats.simId == simId) {
330 queryResultSet->Close();
331 return NETMANAGER_SUCCESS;
332 }
333 }
334
335 queryResultSet->Close();
336 return NETMANAGER_ERROR;
337 }
338
339 } // namespace NetManagerStandard
340 } // namespace OHOS
341