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 "net_access_policy_rdb.h"
17 #include <unistd.h>
18
19 #include "net_manager_constants.h"
20 #include "net_mgr_log_wrapper.h"
21 #include "rdb_errno.h"
22
23 namespace OHOS {
24 namespace NetManagerStandard {
25 namespace {
26 [[maybe_unused]] const int32_t RDB_VERSION_0 = 0;
27 const int32_t RDB_VERSION_1 = 1;
28 const int32_t RDB_VERSION_2 = 2;
29 const std::string NETMANAGER_DB_UID_ACCESS_POLICY_TABLE = "uid_access_policy_infos";
30 const std::string SQL_TABLE_COLUMS = std::string(
31 "uid INTEGER NOT NULL PRIMARY KEY, "
32 "wifiPolicy INTEGER NOT NULL, cellularPolicy INTEGER NOT NULL, setFromConfigFlag INTEGER NOT NULL, isBroker "
33 "INTEGER NOT NULL");
34 } // namespace
35
OnCreate(NativeRdb::RdbStore & rdbStore)36 int NetAccessPolicyRDB::RdbDataOpenCallback::OnCreate(NativeRdb::RdbStore &rdbStore)
37 {
38 return NETMANAGER_SUCCESS;
39 }
40
OnUpgrade(NativeRdb::RdbStore & store,int oldVersion,int newVersion)41 int NetAccessPolicyRDB::RdbDataOpenCallback::OnUpgrade(NativeRdb::RdbStore &store, int oldVersion, int newVersion)
42 {
43 NETMGR_LOG_I("OnUpgrade, oldVersion: %{public}d, newVersion: %{public}d", oldVersion, newVersion);
44 while (oldVersion < newVersion) {
45 UpgradeDbVersionTo(store, ++oldVersion);
46 }
47 return NETMANAGER_SUCCESS;
48 }
49
UpgradeDbVersionTo(NativeRdb::RdbStore & store,int newVersion)50 void NetAccessPolicyRDB::RdbDataOpenCallback::UpgradeDbVersionTo(NativeRdb::RdbStore &store, int newVersion)
51 {
52 switch (newVersion) {
53 case RDB_VERSION_1:
54 // When upgrading the rdb version to 1, the is_broker field was added, but some users failed the upgrade.
55 case RDB_VERSION_2:
56 AddIsBroker(store, newVersion);
57 break;
58 default:
59 NETMGR_LOG_E("no such newVersion: %{public}d", newVersion);
60 }
61 }
62
AddIsBroker(NativeRdb::RdbStore & store,int newVersion)63 void NetAccessPolicyRDB::RdbDataOpenCallback::AddIsBroker(NativeRdb::RdbStore &store, int newVersion)
64 {
65 std::string NewVersionModify = "ALTER TABLE uid_access_policy_infos ADD COLUMN isBroker INTEGER";
66 int ret = store.ExecuteSql(NewVersionModify);
67 if (ret != 0) {
68 NETMGR_LOG_E("OnUpgrade failed, ret: %{public}d, newVersion: %{public}d", ret, newVersion);
69 }
70 }
71
GetRdbStore()72 int32_t NetAccessPolicyRDB::GetRdbStore()
73 {
74 if (rdbStore_ != nullptr) {
75 return NETMANAGER_SUCCESS;
76 }
77
78 int errCode = NETMANAGER_SUCCESS;
79 NativeRdb::RdbStoreConfig config(DATABASE_NAME);
80 NetAccessPolicyRDB::RdbDataOpenCallback helper;
81 rdbStore_ = NativeRdb::RdbHelper::GetRdbStore(config, RDB_VERSION_2, helper, errCode);
82 if (rdbStore_ != nullptr) {
83 return NETMANAGER_SUCCESS;
84 }
85 NETMGR_LOG_E("RDB create failed, errCode: %{public}d", errCode);
86 if (errCode == NativeRdb::E_SQLITE_CORRUPT) {
87 int ret = NativeRdb::RdbHelper::DeleteRdbStore(config);
88 NETMGR_LOG_E("RDB DeleteRdbStore ret: %{public}d", ret);
89 rdbStore_ = NativeRdb::RdbHelper::GetRdbStore(config, RDB_VERSION_2, helper, errCode);
90 if (rdbStore_ != nullptr) {
91 ret = rdbStore_->Restore(DATABASE_BACK_NAME);
92 NETMGR_LOG_E("RDB Restore ret: %{public}d", ret);
93 if (ret == 0) {
94 return NETMANAGER_SUCCESS;
95 }
96 }
97 }
98 return NETMANAGER_ERR_IPC_CONNECT_STUB_FAIL;
99 }
100
GetBackUpRdbStore()101 int32_t NetAccessPolicyRDB::GetBackUpRdbStore()
102 {
103 if (backupRdbStore_ != nullptr) {
104 return NETMANAGER_SUCCESS;
105 }
106
107 int errCode = NETMANAGER_SUCCESS;
108 NativeRdb::RdbStoreConfig config(DATABASE_BACK_NAME);
109 NetAccessPolicyRDB::RdbDataOpenCallback helper;
110 backupRdbStore_ = NativeRdb::RdbHelper::GetRdbStore(config, RDB_VERSION_2, helper, errCode);
111 if (backupRdbStore_ != nullptr) {
112 return NETMANAGER_SUCCESS;
113 }
114 NETMGR_LOG_E("backup RDB create failed, errCode: %{public}d", errCode);
115 if (errCode == NativeRdb::E_SQLITE_CORRUPT) {
116 int ret = NativeRdb::RdbHelper::DeleteRdbStore(config);
117 NETMGR_LOG_E("RDB DeleteRdbStore ret: %{public}d", ret);
118 backupRdbStore_ = NativeRdb::RdbHelper::GetRdbStore(config, RDB_VERSION_2, helper, errCode);
119 if (backupRdbStore_ != nullptr) {
120 return NETMANAGER_SUCCESS;
121 }
122 }
123 return NETMANAGER_ERROR;
124 }
125
InitRdbStore()126 int32_t NetAccessPolicyRDB::InitRdbStore()
127 {
128 InitRdbStoreBackupDB();
129 int32_t ret = GetRdbStore();
130 if (ret != NETMANAGER_SUCCESS) {
131 return ret;
132 }
133
134 std::string createTable =
135 CREATE_TABLE_IF_NOT_EXISTS + NETMANAGER_DB_UID_ACCESS_POLICY_TABLE + " (" + SQL_TABLE_COLUMS + ")";
136 rdbStore_->ExecuteSql(createTable);
137
138 NETMGR_LOG_D("InitRdbStore");
139 return NETMANAGER_SUCCESS;
140 }
141
InitRdbStoreBackupDB()142 int32_t NetAccessPolicyRDB::InitRdbStoreBackupDB()
143 {
144 NETMGR_LOG_I("InitRdbStoreBackupDB start");
145 int32_t ret = GetBackUpRdbStore();
146 if (ret != NETMANAGER_SUCCESS) {
147 return ret;
148 }
149
150 std::string createTable =
151 CREATE_TABLE_IF_NOT_EXISTS + NETMANAGER_DB_UID_ACCESS_POLICY_TABLE + " (" + SQL_TABLE_COLUMS + ")";
152 backupRdbStore_->ExecuteSql(createTable);
153
154 NETMGR_LOG_I("InitRdbStoreBackupDB end");
155 return NETMANAGER_SUCCESS;
156 }
157
InsertData(NetAccessPolicyData policy)158 int32_t NetAccessPolicyRDB::InsertData(NetAccessPolicyData policy)
159 {
160 NETMGR_LOG_D("InsertData");
161 int32_t ret = GetRdbStore();
162 if (ret != NETMANAGER_SUCCESS) {
163 NETMGR_LOG_E("error: rdbStore_ is nullptr");
164 return NETMANAGER_ERROR;
165 }
166
167 NativeRdb::ValuesBucket policyValues;
168 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_UID, policy.uid);
169 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_WIFI_POLICY, policy.wifiPolicy);
170 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_CELLULAR_POLICY, policy.cellularPolicy);
171 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_SET_FROM_CONFIG_FLAG, policy.setFromConfigFlag);
172 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_IS_BROKER, 0);
173
174 int64_t id = 0;
175 ret = rdbStore_->Insert(id, NETMANAGER_DB_UID_ACCESS_POLICY_TABLE, policyValues);
176 if (ret != NativeRdb::E_OK) {
177 ret = UpdateByUid(policy.uid, policy);
178 if (ret != NETMANAGER_SUCCESS) {
179 NETMGR_LOG_E("Update operation failed, result is %{public}d", ret);
180 return NETMANAGER_ERROR;
181 }
182 }
183 InsertDataToBackDB(policy);
184 return NETMANAGER_SUCCESS;
185 }
186
InsertDataToBackDB(NetAccessPolicyData policy)187 int32_t NetAccessPolicyRDB::InsertDataToBackDB(NetAccessPolicyData policy)
188 {
189 NETMGR_LOG_D("InsertDataToBackDB");
190 int32_t ret = GetBackUpRdbStore();
191 if (ret != NETMANAGER_SUCCESS) {
192 return ret;
193 }
194
195 int64_t id = 0;
196 NativeRdb::ValuesBucket policyValues;
197 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_UID, policy.uid);
198 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_WIFI_POLICY, policy.wifiPolicy);
199 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_CELLULAR_POLICY, policy.cellularPolicy);
200 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_SET_FROM_CONFIG_FLAG, policy.setFromConfigFlag);
201 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_IS_BROKER, 0);
202 int insertRet = backupRdbStore_->Insert(id, NETMANAGER_DB_UID_ACCESS_POLICY_TABLE, policyValues);
203 if (ret != NativeRdb::E_OK) {
204 ret = UpdateByUidToBackDB(policy.uid, policy);
205 if (ret != NETMANAGER_SUCCESS) {
206 NETMGR_LOG_E("Update operation failed, result is %{public}d", ret);
207 return NETMANAGER_ERROR;
208 }
209 }
210
211 return NETMANAGER_SUCCESS;
212 }
213
BackUpPolicyDB(const std::string & sourceDB,const std::string & targetDB)214 int32_t NetAccessPolicyRDB::BackUpPolicyDB(const std::string &sourceDB, const std::string &targetDB)
215 {
216 NETMGR_LOG_I("rdbStore BackUpPolicyDB start");
217 if (sourceDB.empty() || targetDB.empty()) {
218 NETMGR_LOG_E("sourceDB or targetDB is empty");
219 return NETMANAGER_ERROR;
220 }
221 int errCode = NETMANAGER_SUCCESS;
222 NativeRdb::RdbStoreConfig config(targetDB);
223 NetAccessPolicyRDB::RdbDataOpenCallback helper;
224 auto rdbStore = NativeRdb::RdbHelper::GetRdbStore(config, RDB_VERSION_2, helper, errCode);
225 if (rdbStore == nullptr) {
226 NETMGR_LOG_E("RDB GetRdbStore failed, errCode: %{public}d", errCode);
227 return NETMANAGER_ERROR;
228 }
229 int ret = rdbStore->Restore(sourceDB);
230 NETMGR_LOG_I("rdbStore BackUpPolicyDB Restore ret: %{public}d", ret);
231 return NETMANAGER_SUCCESS;
232 }
233
DeleteByUid(const int32_t uid)234 int32_t NetAccessPolicyRDB::DeleteByUid(const int32_t uid)
235 {
236 NETMGR_LOG_I("DeleteByUid");
237 int32_t ret = GetRdbStore();
238 if (ret != NETMANAGER_SUCCESS) {
239 NETMGR_LOG_E("error: rdbStore_ is nullptr");
240 return NETMANAGER_ERROR;
241 }
242
243 int32_t deletedRows = -1;
244 std::vector<std::string> whereArgs;
245 OHOS::NativeRdb::RdbPredicates rdbPredicate{NETMANAGER_DB_UID_ACCESS_POLICY_TABLE};
246 rdbPredicate.EqualTo(NetAccessPolicyRdbFiledConst::FILED_UID, std::to_string(uid));
247 int32_t result = rdbStore_->Delete(deletedRows, rdbPredicate);
248 if (result != NativeRdb::E_OK) {
249 NETMGR_LOG_E("delete operation failed, result is %{public}d", result);
250 return result;
251 }
252 DeleteByUidToBackDB(uid);
253 return deletedRows;
254 }
255
DeleteByUidToBackDB(const int32_t uid)256 int32_t NetAccessPolicyRDB::DeleteByUidToBackDB(const int32_t uid)
257 {
258 NETMGR_LOG_I("DeleteByUidToBackDB");
259 int32_t ret = GetBackUpRdbStore();
260 if (ret != NETMANAGER_SUCCESS) {
261 return ret;
262 }
263
264 int32_t deletedRows = -1;
265 std::vector<std::string> whereArgs;
266 OHOS::NativeRdb::RdbPredicates rdbPredicate{NETMANAGER_DB_UID_ACCESS_POLICY_TABLE};
267 rdbPredicate.EqualTo(NetAccessPolicyRdbFiledConst::FILED_UID, std::to_string(uid));
268 int32_t result = backupRdbStore_->Delete(deletedRows, rdbPredicate);
269 if (result != NativeRdb::E_OK) {
270 NETMGR_LOG_E("delete operation failed, result is %{public}d", result);
271 return result;
272 }
273
274 return deletedRows;
275 }
276
UpdateByUid(int32_t uid,NetAccessPolicyData policy)277 int32_t NetAccessPolicyRDB::UpdateByUid(int32_t uid, NetAccessPolicyData policy)
278 {
279 NETMGR_LOG_D("UpdateByUid");
280 int32_t ret = GetRdbStore();
281 if (ret != NETMANAGER_SUCCESS) {
282 NETMGR_LOG_E("error: rdbStore_ is nullptr");
283 return NETMANAGER_ERROR;
284 }
285
286 OHOS::NativeRdb::RdbPredicates rdbPredicate{NETMANAGER_DB_UID_ACCESS_POLICY_TABLE};
287 rdbPredicate.EqualTo(NetAccessPolicyRdbFiledConst::FILED_UID, std::to_string(uid));
288
289 NativeRdb::ValuesBucket policyValues;
290 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_UID, uid);
291 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_WIFI_POLICY, policy.wifiPolicy);
292 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_CELLULAR_POLICY, policy.cellularPolicy);
293 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_SET_FROM_CONFIG_FLAG, policy.setFromConfigFlag);
294
295 int32_t rowId = -1;
296 int32_t result = rdbStore_->Update(rowId, policyValues, rdbPredicate);
297 if (result != NativeRdb::E_OK) {
298 NETMGR_LOG_E("Update operation failed. Result %{public}d", result);
299 return result;
300 }
301 UpdateByUidToBackDB(uid, policy);
302 return NETMANAGER_SUCCESS;
303 }
304
UpdateByUidToBackDB(int32_t uid,NetAccessPolicyData policy)305 int32_t NetAccessPolicyRDB::UpdateByUidToBackDB(int32_t uid, NetAccessPolicyData policy)
306 {
307 NETMGR_LOG_D("UpdateByUidToBackDB");
308 int32_t ret = GetBackUpRdbStore();
309 if (ret != NETMANAGER_SUCCESS) {
310 return ret;
311 }
312 OHOS::NativeRdb::RdbPredicates rdbPredicate{NETMANAGER_DB_UID_ACCESS_POLICY_TABLE};
313 rdbPredicate.EqualTo(NetAccessPolicyRdbFiledConst::FILED_UID, std::to_string(uid));
314
315 NativeRdb::ValuesBucket policyValues;
316 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_UID, uid);
317 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_WIFI_POLICY, policy.wifiPolicy);
318 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_CELLULAR_POLICY, policy.cellularPolicy);
319 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_SET_FROM_CONFIG_FLAG, policy.setFromConfigFlag);
320
321 int32_t rowId = -1;
322 int32_t result = backupRdbStore_->Update(rowId, policyValues, rdbPredicate);
323 if (result != NativeRdb::E_OK) {
324 NETMGR_LOG_E("Update operation failed. Result %{public}d", result);
325 return result;
326 }
327
328 return NETMANAGER_SUCCESS;
329 }
330
QueryAll()331 std::vector<NetAccessPolicyData> NetAccessPolicyRDB::QueryAll()
332 {
333 NETMGR_LOG_D("QueryAll");
334 std::vector<NetAccessPolicyData> result;
335 int32_t ret = GetRdbStore();
336 if (ret != NETMANAGER_SUCCESS) {
337 NETMGR_LOG_E("error: rdbStore_ is nullptr");
338 return result;
339 }
340
341 OHOS::NativeRdb::RdbPredicates rdbPredicate{NETMANAGER_DB_UID_ACCESS_POLICY_TABLE};
342 std::vector<std::string> whereArgs;
343 auto queryResultSet = rdbStore_->Query(rdbPredicate, whereArgs);
344 if (queryResultSet == nullptr) {
345 return result;
346 }
347
348 bool isAtLastRow = false;
349 queryResultSet->IsAtLastRow(isAtLastRow);
350 while (!queryResultSet->GoToNextRow()) {
351 NetAccessPolicyData policy;
352 queryResultSet->GetInt(NetAccessPolicyRdbFiledConst::FILED_COLUMN_INDEX_ZERO, policy.uid);
353 queryResultSet->GetInt(NetAccessPolicyRdbFiledConst::FILED_COLUMN_INDEX_ONE, policy.wifiPolicy);
354 queryResultSet->GetInt(NetAccessPolicyRdbFiledConst::FILED_COLUMN_INDEX_TWO, policy.cellularPolicy);
355 queryResultSet->GetInt(NetAccessPolicyRdbFiledConst::FILED_COLUMN_INDEX_THREE, policy.setFromConfigFlag);
356 result.emplace_back(policy);
357 }
358 queryResultSet->Close();
359 return result;
360 }
361
QueryByUid(int uid,NetAccessPolicyData & uidPolicy)362 int32_t NetAccessPolicyRDB::QueryByUid(int uid, NetAccessPolicyData& uidPolicy)
363 {
364 NETMGR_LOG_D("QueryByUid uid:%{public}d", uid);
365 int32_t ret = GetRdbStore();
366 if (ret != NETMANAGER_SUCCESS) {
367 NETMGR_LOG_E("error: rdbStore_ is nullptr");
368 return NETMANAGER_ERROR;
369 }
370
371 OHOS::NativeRdb::RdbPredicates rdbPredicate{NETMANAGER_DB_UID_ACCESS_POLICY_TABLE};
372 rdbPredicate.EqualTo(NetAccessPolicyRdbFiledConst::FILED_UID, uid);
373
374 std::vector<std::string> whereArgs;
375 auto queryResultSet = rdbStore_->Query(rdbPredicate, whereArgs);
376 if (queryResultSet == nullptr) {
377 NETMGR_LOG_E("QueryByUid error");
378 return NETMANAGER_ERROR;
379 }
380
381 int32_t rowCount = 0;
382 ret = queryResultSet->GetRowCount(rowCount);
383 if (ret != OHOS::NativeRdb::E_OK) {
384 NETMGR_LOG_E("query setting failed, get row count failed, name:%{public}d, ret:%{public}d", uid, ret);
385 queryResultSet->Close();
386 return ret;
387 }
388 if (rowCount == 0) {
389 NETMGR_LOG_I("query setting name:%{public}d, num is 0", uid);
390 queryResultSet->Close();
391 return NETMANAGER_ERROR;
392 }
393
394 while (!queryResultSet->GoToNextRow()) {
395 queryResultSet->GetInt(NetAccessPolicyRdbFiledConst::FILED_COLUMN_INDEX_ZERO, uidPolicy.uid);
396 queryResultSet->GetInt(NetAccessPolicyRdbFiledConst::FILED_COLUMN_INDEX_ONE, uidPolicy.wifiPolicy);
397 queryResultSet->GetInt(NetAccessPolicyRdbFiledConst::FILED_COLUMN_INDEX_TWO, uidPolicy.cellularPolicy);
398 queryResultSet->GetInt(NetAccessPolicyRdbFiledConst::FILED_COLUMN_INDEX_THREE, uidPolicy.setFromConfigFlag);
399 if (uidPolicy.uid == uid) {
400 queryResultSet->Close();
401 return NETMANAGER_SUCCESS;
402 }
403 }
404
405 queryResultSet->Close();
406 return NETMANAGER_ERROR;
407 }
408
409 } // namespace NetManagerStandard
410 } // namespace OHOS
411