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_data_handler.h"
17
18 #include "net_mgr_log_wrapper.h"
19 #include "net_stats_database_defines.h"
20 #include "net_stats_database_helper.h"
21 #include "net_stats_constants.h"
22 #include "net_manager_constants.h"
23 #include "netmanager_base_common_utils.h"
24
25 namespace OHOS {
26 namespace NetManagerStandard {
27 using namespace NetStatsDatabaseDefines;
28
NetStatsDataHandler()29 NetStatsDataHandler::NetStatsDataHandler()
30 {
31 isDisplayTrafficAncoList = CommonUtils::IsNeedDisplayTrafficAncoList();
32 }
33
ReadStatsData(std::vector<NetStatsInfo> & infos,uint64_t start,uint64_t end)34 int32_t NetStatsDataHandler::ReadStatsData(std::vector<NetStatsInfo> &infos, uint64_t start, uint64_t end)
35 {
36 auto helper = std::make_unique<NetStatsDatabaseHelper>(NET_STATS_DATABASE_PATH);
37 if (helper == nullptr) {
38 NETMGR_LOG_E("db helper instance is nullptr");
39 return NETMANAGER_ERR_INTERNAL;
40 }
41 return helper->SelectData(infos, UID_TABLE, start, end);
42 }
43
ReadStatsData(std::vector<NetStatsInfo> & infos,uint64_t uid,uint64_t start,uint64_t end)44 int32_t NetStatsDataHandler::ReadStatsData(std::vector<NetStatsInfo> &infos, uint64_t uid, uint64_t start, uint64_t end)
45 {
46 auto helper = std::make_unique<NetStatsDatabaseHelper>(NET_STATS_DATABASE_PATH);
47 if (helper == nullptr) {
48 NETMGR_LOG_E("db helper instance is nullptr");
49 return NETMANAGER_ERR_INTERNAL;
50 }
51 return helper->SelectData(uid, start, end, infos);
52 }
53
ReadStatsData(std::vector<NetStatsInfo> & infos,const std::string & iface,uint64_t start,uint64_t end)54 int32_t NetStatsDataHandler::ReadStatsData(std::vector<NetStatsInfo> &infos, const std::string &iface, uint64_t start,
55 uint64_t end)
56 {
57 if (iface.empty()) {
58 NETMGR_LOG_E("Param is invalid");
59 return NETMANAGER_ERR_PARAMETER_ERROR;
60 }
61 auto helper = std::make_unique<NetStatsDatabaseHelper>(NET_STATS_DATABASE_PATH);
62 if (helper == nullptr) {
63 NETMGR_LOG_E("db helper instance is nullptr");
64 return NETMANAGER_ERR_INTERNAL;
65 }
66 return helper->SelectData(iface, start, end, infos);
67 }
68
ReadStatsData(std::vector<NetStatsInfo> & infos,const std::string & iface,const uint32_t uid,uint64_t start,uint64_t end)69 int32_t NetStatsDataHandler::ReadStatsData(std::vector<NetStatsInfo> &infos, const std::string &iface,
70 const uint32_t uid, uint64_t start, uint64_t end)
71 {
72 if (iface.empty()) {
73 NETMGR_LOG_E("Param is invalid");
74 return NETMANAGER_ERR_PARAMETER_ERROR;
75 }
76 auto helper = std::make_unique<NetStatsDatabaseHelper>(NET_STATS_DATABASE_PATH);
77 if (helper == nullptr) {
78 NETMGR_LOG_E("db helper instance is nullptr");
79 return NETMANAGER_ERR_INTERNAL;
80 }
81 return helper->SelectData(iface, uid, start, end, infos);
82 }
83
ReadStatsDataByIdent(std::vector<NetStatsInfo> & infos,const std::string & ident,uint64_t start,uint64_t end)84 int32_t NetStatsDataHandler::ReadStatsDataByIdent(std::vector<NetStatsInfo> &infos, const std::string &ident,
85 uint64_t start, uint64_t end)
86 {
87 auto helper = std::make_unique<NetStatsDatabaseHelper>(NET_STATS_DATABASE_PATH);
88 if (helper == nullptr) {
89 NETMGR_LOG_E("db helper instance is nullptr");
90 return NETMANAGER_ERR_INTERNAL;
91 }
92 int32_t ret1;
93 int32_t ret2;
94 std::vector<NetStatsInfo> uidSimTableInfos;
95 ret1 = helper->QueryData(UID_TABLE, ident, start, end, infos);
96 ret2 = helper->QueryData(UID_SIM_TABLE, ident, start, end, uidSimTableInfos);
97 uidSimTableInfos.erase(std::remove_if(uidSimTableInfos.begin(), uidSimTableInfos.end(), [](const auto &item) {
98 return item.flag_ <= STATS_DATA_FLAG_DEFAULT || item.flag_ >= STATS_DATA_FLAG_LIMIT;
99 }),
100 uidSimTableInfos.end());
101 std::for_each(uidSimTableInfos.begin(), uidSimTableInfos.end(), [this](NetStatsInfo &info) {
102 if (!isDisplayTrafficAncoList) {
103 if (info.flag_ == STATS_DATA_FLAG_SIM2) {
104 info.uid_ = SIM2_UID;
105 } else if (info.flag_ == STATS_DATA_FLAG_SIM) {
106 info.uid_ = Sim_UID;
107 }
108 } else {
109 if (info.flag_ == STATS_DATA_FLAG_SIM_BASIC) {
110 info.uid_ = Sim_UID;
111 } else if (info.flag_ == STATS_DATA_FLAG_SIM2_BASIC) {
112 info.uid_ = SIM2_UID;
113 }
114 }
115 });
116 if (ret1 != NETMANAGER_SUCCESS || ret2 != NETMANAGER_SUCCESS) {
117 NETMGR_LOG_E("QueryData wrong, ret1=%{public}d, ret2=%{public}d", ret1, ret2);
118 return ret1 != NETMANAGER_SUCCESS ? ret1 : ret2;
119 }
120 infos.insert(infos.end(), uidSimTableInfos.begin(), uidSimTableInfos.end());
121 return NETMANAGER_SUCCESS;
122 }
123
ReadStatsData(std::vector<NetStatsInfo> & infos,uint32_t uid,const std::string & ident,uint64_t start,uint64_t end)124 int32_t NetStatsDataHandler::ReadStatsData(std::vector<NetStatsInfo> &infos, uint32_t uid, const std::string &ident,
125 uint64_t start, uint64_t end)
126 {
127 auto helper = std::make_unique<NetStatsDatabaseHelper>(NET_STATS_DATABASE_PATH);
128 if (helper == nullptr) {
129 NETMGR_LOG_E("db helper instance is nullptr");
130 return NETMANAGER_ERR_INTERNAL;
131 }
132 int32_t ret1;
133 int32_t ret2;
134 std::vector<NetStatsInfo> uidSimTableInfos;
135 ret1 = helper->QueryData(UID_TABLE, uid, ident, start, end, infos);
136 if (uid == Sim_UID || uid == SIM2_UID) {
137 ret2 = helper->QueryData(UID_SIM_TABLE, ident, start, end, uidSimTableInfos);
138 uidSimTableInfos.erase(std::remove_if(uidSimTableInfos.begin(), uidSimTableInfos.end(), [](const auto &item) {
139 return item.flag_ <= STATS_DATA_FLAG_DEFAULT || item.flag_ >= STATS_DATA_FLAG_LIMIT;
140 }),
141 uidSimTableInfos.end());
142 std::for_each(uidSimTableInfos.begin(), uidSimTableInfos.end(), [this](NetStatsInfo &info) {
143 if (!isDisplayTrafficAncoList) {
144 if (info.flag_ == STATS_DATA_FLAG_SIM2) {
145 info.uid_ = SIM2_UID;
146 } else if (info.flag_ == STATS_DATA_FLAG_SIM) {
147 info.uid_ = Sim_UID;
148 }
149 } else {
150 if (info.flag_ == STATS_DATA_FLAG_SIM_BASIC) {
151 info.uid_ = Sim_UID;
152 } else if (info.flag_ == STATS_DATA_FLAG_SIM2_BASIC) {
153 info.uid_ = SIM2_UID;
154 }
155 }
156 });
157 } else {
158 ret2 = helper->QueryData(UID_SIM_TABLE, uid, ident, start, end, uidSimTableInfos);
159 if (!uidSimTableInfos.empty() && isDisplayTrafficAncoList) {
160 uidSimTableInfos.erase(std::remove_if(uidSimTableInfos.begin(), uidSimTableInfos.end(),
161 [](const auto &item) {
162 return item.flag_ != STATS_DATA_FLAG_SIM && item.flag_ != STATS_DATA_FLAG_SIM2;
163 }),
164 uidSimTableInfos.end());
165 }
166 }
167 if (ret1 != NETMANAGER_SUCCESS || ret2 != NETMANAGER_SUCCESS) {
168 NETMGR_LOG_E("QueryData wrong, ret1=%{public}d, ret2=%{public}d", ret1, ret2);
169 return ret1 != NETMANAGER_SUCCESS ? ret1 : ret2;
170 }
171 infos.insert(infos.end(), uidSimTableInfos.begin(), uidSimTableInfos.end());
172 return NETMANAGER_SUCCESS;
173 }
174
ReadStatsDataByIdentAndUserId(std::vector<NetStatsInfo> & infos,const std::string & ident,const int32_t userId,uint64_t start,uint64_t end)175 int32_t NetStatsDataHandler::ReadStatsDataByIdentAndUserId(std::vector<NetStatsInfo> &infos,
176 const std::string &ident, const int32_t userId, uint64_t start, uint64_t end)
177 {
178 auto helper = std::make_unique<NetStatsDatabaseHelper>(NET_STATS_DATABASE_PATH);
179 if (helper == nullptr) {
180 NETMGR_LOG_E("db helper instance is nullptr");
181 return NETMANAGER_ERR_INTERNAL;
182 }
183 int32_t ret1;
184 int32_t ret2;
185 std::vector<NetStatsInfo> uidSimTableInfos;
186 ret1 = helper->QueryData(UID_TABLE, ident, userId, start, end, infos);
187 ret2 = helper->QueryData(UID_SIM_TABLE, ident, userId, start, end, uidSimTableInfos);
188 uidSimTableInfos.erase(std::remove_if(uidSimTableInfos.begin(), uidSimTableInfos.end(), [](const auto &item) {
189 return item.flag_ <= STATS_DATA_FLAG_DEFAULT || item.flag_ >= STATS_DATA_FLAG_LIMIT;
190 }),
191 uidSimTableInfos.end());
192 std::for_each(uidSimTableInfos.begin(), uidSimTableInfos.end(), [this](NetStatsInfo &info) {
193 if (!isDisplayTrafficAncoList) {
194 if (info.flag_ == STATS_DATA_FLAG_SIM2) {
195 info.uid_ = SIM2_UID;
196 } else if (info.flag_ == STATS_DATA_FLAG_SIM) {
197 info.uid_ = Sim_UID;
198 }
199 } else {
200 if (info.flag_ == STATS_DATA_FLAG_SIM_BASIC) {
201 info.uid_ = Sim_UID;
202 } else if (info.flag_ == STATS_DATA_FLAG_SIM2_BASIC) {
203 info.uid_ = SIM2_UID;
204 }
205 }
206 });
207 if (ret1 != NETMANAGER_SUCCESS || ret2 != NETMANAGER_SUCCESS) {
208 NETMGR_LOG_E("QueryData wrong, ret1=%{public}d, ret2=%{public}d", ret1, ret2);
209 return ret1 != NETMANAGER_SUCCESS ? ret1 : ret2;
210 }
211 infos.insert(infos.end(), uidSimTableInfos.begin(), uidSimTableInfos.end());
212 return NETMANAGER_SUCCESS;
213 }
214
WriteStatsData(const std::vector<NetStatsInfo> & infos,const std::string & tableName)215 int32_t NetStatsDataHandler::WriteStatsData(const std::vector<NetStatsInfo> &infos, const std::string &tableName)
216 {
217 NETMGR_LOG_I("WriteStatsData enter tableName:%{public}s", tableName.c_str());
218 if (infos.empty() || tableName.empty()) {
219 NETMGR_LOG_I("Param wrong, info: %{public}zu, tableName: %{public}zu", infos.size(), tableName.size());
220 return NETMANAGER_ERR_PARAMETER_ERROR;
221 }
222 auto helper = std::make_unique<NetStatsDatabaseHelper>(NET_STATS_DATABASE_PATH);
223 if (helper == nullptr) {
224 NETMGR_LOG_E("db helper instance is nullptr");
225 return NETMANAGER_ERR_INTERNAL;
226 }
227 if (tableName == UID_TABLE) {
228 std::for_each(infos.begin(), infos.end(),
229 [&helper](const auto &info) { helper->InsertData(UID_TABLE, UID_TABLE_PARAM_LIST, info); });
230 return NETMANAGER_SUCCESS;
231 }
232 if (tableName == IFACE_TABLE) {
233 std::for_each(infos.begin(), infos.end(),
234 [&helper](const auto &info) { helper->InsertData(IFACE_TABLE, IFACE_TABLE_PARAM_LIST, info); });
235 return NETMANAGER_SUCCESS;
236 }
237 if (tableName == UID_SIM_TABLE) {
238 std::for_each(infos.begin(), infos.end(), [&helper](const auto &info) {
239 helper->InsertData(UID_SIM_TABLE, UID_SIM_TABLE_PARAM_LIST, info);
240 });
241 return NETMANAGER_SUCCESS;
242 }
243 return NETMANAGER_ERR_PARAMETER_ERROR;
244 }
245
DeleteByUid(uint64_t uid)246 int32_t NetStatsDataHandler::DeleteByUid(uint64_t uid)
247 {
248 auto helper = std::make_unique<NetStatsDatabaseHelper>(NET_STATS_DATABASE_PATH);
249 if (helper == nullptr) {
250 NETMGR_LOG_E("db helper instance is nullptr");
251 return NETMANAGER_ERR_INTERNAL;
252 }
253 return helper->DeleteData(UID_TABLE, uid);
254 }
255
DeleteSimStatsByUid(uint64_t uid)256 int32_t NetStatsDataHandler::DeleteSimStatsByUid(uint64_t uid)
257 {
258 auto helper = std::make_unique<NetStatsDatabaseHelper>(NET_STATS_DATABASE_PATH);
259 if (helper == nullptr) {
260 NETMGR_LOG_E("db helper instance is nullptr");
261 return NETMANAGER_ERR_INTERNAL;
262 }
263 return helper->DeleteData(UID_SIM_TABLE, uid);
264 }
265
DeleteByDate(const std::string & tableName,uint64_t start,uint64_t end)266 int32_t NetStatsDataHandler::DeleteByDate(const std::string &tableName, uint64_t start, uint64_t end)
267 {
268 auto helper = std::make_unique<NetStatsDatabaseHelper>(NET_STATS_DATABASE_PATH);
269 if (helper == nullptr) {
270 NETMGR_LOG_E("db helper instance is nullptr");
271 return NETMANAGER_ERR_INTERNAL;
272 }
273 return helper->DeleteData(tableName, start, end);
274 }
275
UpdateStatsFlag(uint32_t uid,uint32_t flag)276 int32_t NetStatsDataHandler::UpdateStatsFlag(uint32_t uid, uint32_t flag)
277 {
278 auto helper = std::make_unique<NetStatsDatabaseHelper>(NET_STATS_DATABASE_PATH);
279 if (helper == nullptr) {
280 NETMGR_LOG_E("db helper instance is nullptr");
281 return NETMANAGER_ERR_INTERNAL;
282 }
283 return helper->UpdateStatsFlag(UID_TABLE, uid, flag);
284 }
285
UpdateStatsFlagByUserId(int32_t userId,uint32_t flag)286 int32_t NetStatsDataHandler::UpdateStatsFlagByUserId(int32_t userId, uint32_t flag)
287 {
288 auto helper = std::make_unique<NetStatsDatabaseHelper>(NET_STATS_DATABASE_PATH);
289 if (helper == nullptr) {
290 NETMGR_LOG_E("db helper instance is nullptr");
291 return NETMANAGER_ERR_INTERNAL;
292 }
293 return helper->UpdateStatsFlagByUserId(UID_TABLE, userId, flag);
294 }
295
UpdateStatsUserIdByUserId(int32_t userId,int32_t newUserId)296 int32_t NetStatsDataHandler::UpdateStatsUserIdByUserId(int32_t userId, int32_t newUserId)
297 {
298 auto helper = std::make_unique<NetStatsDatabaseHelper>(NET_STATS_DATABASE_PATH);
299 if (helper == nullptr) {
300 NETMGR_LOG_E("db helper instance is nullptr");
301 return NETMANAGER_ERR_INTERNAL;
302 }
303 return helper->UpdateStatsUserIdByUserId(UID_TABLE, userId, newUserId);
304 }
305
UpdateSimStatsUserIdByUserId(int32_t userId,int32_t newUserId)306 int32_t NetStatsDataHandler::UpdateSimStatsUserIdByUserId(int32_t userId, int32_t newUserId)
307 {
308 auto helper = std::make_unique<NetStatsDatabaseHelper>(NET_STATS_DATABASE_PATH);
309 if (helper == nullptr) {
310 NETMGR_LOG_E("db helper instance is nullptr");
311 return NETMANAGER_ERR_INTERNAL;
312 }
313 return helper->UpdateStatsUserIdByUserId(UID_TABLE, userId, newUserId);
314 }
315
UpdateSimStatsFlagByUserId(int32_t userId,uint32_t flag)316 int32_t NetStatsDataHandler::UpdateSimStatsFlagByUserId(int32_t userId, uint32_t flag)
317 {
318 auto helper = std::make_unique<NetStatsDatabaseHelper>(NET_STATS_DATABASE_PATH);
319 if (helper == nullptr) {
320 NETMGR_LOG_E("db helper instance is nullptr");
321 return NETMANAGER_ERR_INTERNAL;
322 }
323 return helper->UpdateStatsFlag(UID_SIM_TABLE, userId, flag);
324 }
325
UpdateSimStatsFlag(uint32_t uid,uint32_t flag)326 int32_t NetStatsDataHandler::UpdateSimStatsFlag(uint32_t uid, uint32_t flag)
327 {
328 auto helper = std::make_unique<NetStatsDatabaseHelper>(NET_STATS_DATABASE_PATH);
329 if (helper == nullptr) {
330 NETMGR_LOG_E("db helper instance is nullptr");
331 return NETMANAGER_ERR_INTERNAL;
332 }
333 return helper->UpdateStatsFlag(UID_SIM_TABLE, uid, flag);
334 }
335
UpdateSimDataFlag(uint32_t oldFlag,uint32_t newFlag)336 int32_t NetStatsDataHandler::UpdateSimDataFlag(uint32_t oldFlag, uint32_t newFlag)
337 {
338 auto helper = std::make_unique<NetStatsDatabaseHelper>(NET_STATS_DATABASE_PATH);
339 if (helper == nullptr) {
340 NETMGR_LOG_E("db helper instance is nullptr");
341 return NETMANAGER_ERR_INTERNAL;
342 }
343 return helper->UpdateDataFlag(UID_SIM_TABLE, oldFlag, newFlag);
344 }
345
ClearData()346 int32_t NetStatsDataHandler::ClearData()
347 {
348 auto helper = std::make_unique<NetStatsDatabaseHelper>(NET_STATS_DATABASE_PATH);
349 if (helper == nullptr) {
350 NETMGR_LOG_E("db helper instance is nullptr");
351 return NETMANAGER_ERR_INTERNAL;
352 }
353 int32_t ifaceDataRet = helper->ClearData(IFACE_TABLE);
354 int32_t uidDataRet = helper->ClearData(UID_TABLE);
355 int32_t uidSimDataRet = helper->ClearData(UID_SIM_TABLE);
356 if (ifaceDataRet != NETMANAGER_SUCCESS || uidDataRet != NETMANAGER_SUCCESS || uidSimDataRet != NETMANAGER_SUCCESS) {
357 return NETMANAGER_ERROR;
358 }
359 return NETMANAGER_SUCCESS;
360 }
361
BackupNetStatsData(const std::string & sourceDb,const std::string & backupDb)362 int32_t NetStatsDataHandler::BackupNetStatsData(const std::string &sourceDb, const std::string &backupDb)
363 {
364 auto helper = std::make_unique<NetStatsDatabaseHelper>(NET_STATS_DATABASE_PATH);
365 if (helper == nullptr) {
366 NETMGR_LOG_E("db helper instance is nullptr");
367 return NETMANAGER_ERR_INTERNAL;
368 }
369 bool ret = helper->BackupNetStatsDataDB(sourceDb, backupDb);
370 if (!ret) {
371 return NETMANAGER_ERROR;
372 }
373 return NETMANAGER_SUCCESS;
374 }
375 } // namespace NetManagerStandard
376 } // namespace OHOS
377