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
22 namespace OHOS {
23 namespace NetManagerStandard {
24 namespace {
25 [[maybe_unused]] const int32_t RDB_VERSION_0 = 0;
26 const int32_t RDB_VERSION_1 = 1;
27 const int32_t RDB_VERSION_2 = 2;
28 const std::string DATABASE_NAME = "/data/service/el1/public/netmanager/net_uid_access_policy.db";
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 NETMGR_LOG_E("RDB create failed, errCode: %{public}d", errCode);
84 return NETMANAGER_ERR_IPC_CONNECT_STUB_FAIL;
85 }
86
87 return NETMANAGER_SUCCESS;
88 }
89
InitRdbStore()90 int32_t NetAccessPolicyRDB::InitRdbStore()
91 {
92 int32_t ret = GetRdbStore();
93 if (ret != NETMANAGER_SUCCESS) {
94 return ret;
95 }
96
97 std::string createTable =
98 "CREATE TABLE IF NOT EXISTS " + NETMANAGER_DB_UID_ACCESS_POLICY_TABLE + " (" + SQL_TABLE_COLUMS + ")";
99 rdbStore_->ExecuteSql(createTable);
100
101 NETMGR_LOG_D("InitRdbStore");
102 return NETMANAGER_SUCCESS;
103 }
104
InsertData(NetAccessPolicyData policy)105 int32_t NetAccessPolicyRDB::InsertData(NetAccessPolicyData policy)
106 {
107 NETMGR_LOG_D("InsertData");
108 int32_t ret = GetRdbStore();
109 if (ret != NETMANAGER_SUCCESS) {
110 NETMGR_LOG_E("error: rdbStore_ is nullptr");
111 return NETMANAGER_ERROR;
112 }
113
114 NativeRdb::ValuesBucket policyValues;
115 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_UID, policy.uid);
116 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_WIFI_POLICY, policy.wifiPolicy);
117 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_CELLULAR_POLICY, policy.cellularPolicy);
118 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_SET_FROM_CONFIG_FLAG, policy.setFromConfigFlag);
119 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_IS_BROKER, 0);
120
121 int64_t id = 0;
122 ret = rdbStore_->Insert(id, NETMANAGER_DB_UID_ACCESS_POLICY_TABLE, policyValues);
123 if (ret != NativeRdb::E_OK) {
124 ret = UpdateByUid(policy.uid, policy);
125 if (ret != NETMANAGER_SUCCESS) {
126 NETMGR_LOG_E("Update operation failed, result is %{public}d", ret);
127 return NETMANAGER_ERROR;
128 }
129 }
130
131 return NETMANAGER_SUCCESS;
132 }
133
DeleteByUid(const int32_t uid)134 int32_t NetAccessPolicyRDB::DeleteByUid(const int32_t uid)
135 {
136 NETMGR_LOG_D("DeleteByUid");
137 int32_t ret = GetRdbStore();
138 if (ret != NETMANAGER_SUCCESS) {
139 NETMGR_LOG_E("error: rdbStore_ is nullptr");
140 return NETMANAGER_ERROR;
141 }
142
143 int32_t deletedRows = -1;
144 std::vector<std::string> whereArgs;
145 OHOS::NativeRdb::RdbPredicates rdbPredicate{NETMANAGER_DB_UID_ACCESS_POLICY_TABLE};
146 rdbPredicate.EqualTo(NetAccessPolicyRdbFiledConst::FILED_UID, std::to_string(uid));
147 int32_t result = rdbStore_->Delete(deletedRows, rdbPredicate);
148 if (result != NativeRdb::E_OK) {
149 NETMGR_LOG_E("delete operation failed, result is %{public}d", result);
150 return result;
151 }
152
153 return deletedRows;
154 }
155
UpdateByUid(int32_t uid,NetAccessPolicyData policy)156 int32_t NetAccessPolicyRDB::UpdateByUid(int32_t uid, NetAccessPolicyData policy)
157 {
158 NETMGR_LOG_D("UpdateByUid");
159 int32_t ret = GetRdbStore();
160 if (ret != NETMANAGER_SUCCESS) {
161 NETMGR_LOG_E("error: rdbStore_ is nullptr");
162 return NETMANAGER_ERROR;
163 }
164
165 OHOS::NativeRdb::RdbPredicates rdbPredicate{NETMANAGER_DB_UID_ACCESS_POLICY_TABLE};
166 rdbPredicate.EqualTo(NetAccessPolicyRdbFiledConst::FILED_UID, std::to_string(uid));
167
168 NativeRdb::ValuesBucket policyValues;
169 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_UID, uid);
170 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_WIFI_POLICY, policy.wifiPolicy);
171 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_CELLULAR_POLICY, policy.cellularPolicy);
172 policyValues.PutInt(NetAccessPolicyRdbFiledConst::FILED_SET_FROM_CONFIG_FLAG, policy.setFromConfigFlag);
173
174 int32_t rowId = -1;
175 int32_t result = rdbStore_->Update(rowId, policyValues, rdbPredicate);
176 if (result != NativeRdb::E_OK) {
177 NETMGR_LOG_E("Update operation failed. Result %{public}d", result);
178 return result;
179 }
180
181 return NETMANAGER_SUCCESS;
182 }
183
QueryAll()184 std::vector<NetAccessPolicyData> NetAccessPolicyRDB::QueryAll()
185 {
186 NETMGR_LOG_D("QueryAll");
187 std::vector<NetAccessPolicyData> result;
188 int32_t ret = GetRdbStore();
189 if (ret != NETMANAGER_SUCCESS) {
190 NETMGR_LOG_E("error: rdbStore_ is nullptr");
191 return result;
192 }
193
194 OHOS::NativeRdb::RdbPredicates rdbPredicate{NETMANAGER_DB_UID_ACCESS_POLICY_TABLE};
195 std::vector<std::string> whereArgs;
196 auto queryResultSet = rdbStore_->Query(rdbPredicate, whereArgs);
197 if (queryResultSet == nullptr) {
198 return result;
199 }
200
201 bool isAtLastRow = false;
202 queryResultSet->IsAtLastRow(isAtLastRow);
203 while (!queryResultSet->GoToNextRow()) {
204 NetAccessPolicyData policy;
205 queryResultSet->GetInt(NetAccessPolicyRdbFiledConst::FILED_COLUMN_INDEX_ZERO, policy.uid);
206 queryResultSet->GetInt(NetAccessPolicyRdbFiledConst::FILED_COLUMN_INDEX_ONE, policy.wifiPolicy);
207 queryResultSet->GetInt(NetAccessPolicyRdbFiledConst::FILED_COLUMN_INDEX_TWO, policy.cellularPolicy);
208 queryResultSet->GetInt(NetAccessPolicyRdbFiledConst::FILED_COLUMN_INDEX_THREE, policy.setFromConfigFlag);
209 result.emplace_back(policy);
210 }
211 return result;
212 }
213
QueryByUid(int uid,NetAccessPolicyData & uidPolicy)214 int32_t NetAccessPolicyRDB::QueryByUid(int uid, NetAccessPolicyData& uidPolicy)
215 {
216 NETMGR_LOG_D("QueryByUid uid:%{public}d", uid);
217 int32_t ret = GetRdbStore();
218 if (ret != NETMANAGER_SUCCESS) {
219 NETMGR_LOG_E("error: rdbStore_ is nullptr");
220 return NETMANAGER_ERROR;
221 }
222
223 OHOS::NativeRdb::RdbPredicates rdbPredicate{NETMANAGER_DB_UID_ACCESS_POLICY_TABLE};
224 rdbPredicate.EqualTo(NetAccessPolicyRdbFiledConst::FILED_UID, uid);
225
226 std::vector<std::string> whereArgs;
227 auto queryResultSet = rdbStore_->Query(rdbPredicate, whereArgs);
228 if (queryResultSet == nullptr) {
229 NETMGR_LOG_E("QueryByUid error");
230 return NETMANAGER_ERROR;
231 }
232
233 int32_t rowCount = 0;
234 ret = queryResultSet->GetRowCount(rowCount);
235 if (ret != OHOS::NativeRdb::E_OK) {
236 NETMGR_LOG_E("query setting failed, get row count failed, name:%{public}d, ret:%{public}d", uid, ret);
237 return ret;
238 }
239 if (rowCount == 0) {
240 NETMGR_LOG_E("query setting name:%{public}d, num is 0", uid);
241 return NETMANAGER_ERROR;
242 }
243
244 while (!queryResultSet->GoToNextRow()) {
245 queryResultSet->GetInt(NetAccessPolicyRdbFiledConst::FILED_COLUMN_INDEX_ZERO, uidPolicy.uid);
246 queryResultSet->GetInt(NetAccessPolicyRdbFiledConst::FILED_COLUMN_INDEX_ONE, uidPolicy.wifiPolicy);
247 queryResultSet->GetInt(NetAccessPolicyRdbFiledConst::FILED_COLUMN_INDEX_TWO, uidPolicy.cellularPolicy);
248 queryResultSet->GetInt(NetAccessPolicyRdbFiledConst::FILED_COLUMN_INDEX_THREE, uidPolicy.setFromConfigFlag);
249 if (uidPolicy.uid == uid) {
250 return NETMANAGER_SUCCESS;
251 }
252 }
253
254 return NETMANAGER_ERROR;
255 }
256
257 } // namespace NetManagerStandard
258 } // namespace OHOS
259