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