1 /*
2  * Copyright (c) 2021-2023 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_service.h"
17 
18 #include <net/if.h>
19 #include <sys/time.h>
20 #include <unistd.h>
21 
22 #include <cinttypes>
23 #include <initializer_list>
24 
25 #include "bpf_stats.h"
26 #include "broadcast_manager.h"
27 #include "common_event_manager.h"
28 #include "common_event_support.h"
29 #include "net_manager_center.h"
30 #include "net_manager_constants.h"
31 #include "net_mgr_log_wrapper.h"
32 #include "net_stats_constants.h"
33 #include "net_stats_database_defines.h"
34 #include "net_stats_service_common.h"
35 #include "netmanager_base_common_utils.h"
36 #include "netmanager_base_permission.h"
37 #include "netmanager_hitrace.h"
38 #include "netsys_controller.h"
39 #include "system_ability_definition.h"
40 
41 namespace OHOS {
42 namespace NetManagerStandard {
43 using namespace NetStatsDatabaseDefines;
44 namespace {
45 constexpr std::initializer_list<NetBearType> BEAR_TYPE_LIST = {
46     NetBearType::BEARER_CELLULAR, NetBearType::BEARER_WIFI, NetBearType::BEARER_BLUETOOTH,
47     NetBearType::BEARER_ETHERNET, NetBearType::BEARER_VPN,  NetBearType::BEARER_WIFI_AWARE,
48 };
49 constexpr uint32_t DAY_SECONDS = 2 * 24 * 60 * 60;
50 constexpr const char* UID = "uid";
51 } // namespace
52 const bool REGISTER_LOCAL_RESULT =
53     SystemAbility::MakeAndRegisterAbility(DelayedSingleton<NetStatsService>::GetInstance().get());
54 
NetStatsService()55 NetStatsService::NetStatsService()
56     : SystemAbility(COMM_NET_STATS_MANAGER_SYS_ABILITY_ID, true), registerToService_(false), state_(STATE_STOPPED)
57 {
58     netStatsCallback_ = std::make_shared<NetStatsCallback>();
59     netStatsCached_ = std::make_unique<NetStatsCached>();
60 }
61 
62 NetStatsService::~NetStatsService() = default;
63 
OnStart()64 void NetStatsService::OnStart()
65 {
66     if (state_ == STATE_RUNNING) {
67         NETMGR_LOG_D("the state is already running");
68         return;
69     }
70     if (!Init()) {
71         NETMGR_LOG_E("init failed");
72         return;
73     }
74     AddSystemAbilityListener(COMMON_EVENT_SERVICE_ID);
75     state_ = STATE_RUNNING;
76     sptr<NetStatsBaseService> baseService = new (std::nothrow) NetStatsServiceCommon();
77     if (baseService == nullptr) {
78         NETMGR_LOG_E("Net stats base service instance create failed");
79         return;
80     }
81     NetManagerCenter::GetInstance().RegisterStatsService(baseService);
82 }
83 
OnStop()84 void NetStatsService::OnStop()
85 {
86     state_ = STATE_STOPPED;
87     registerToService_ = true;
88 }
89 
Dump(int32_t fd,const std::vector<std::u16string> & args)90 int32_t NetStatsService::Dump(int32_t fd, const std::vector<std::u16string> &args)
91 {
92     NETMGR_LOG_D("Start Dump, fd: %{public}d", fd);
93     std::string result;
94     GetDumpMessage(result);
95     int32_t ret = dprintf(fd, "%s\n", result.c_str());
96     return ret < 0 ? STATS_DUMP_MESSAGE_FAIL : NETMANAGER_SUCCESS;
97 }
98 
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)99 void NetStatsService::OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
100 {
101     EventFwk::MatchingSkills matchingSkills;
102     matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED);
103     matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SHUTDOWN);
104     EventFwk::CommonEventSubscribeInfo subscribeInfo(matchingSkills);
105     subscribeInfo.SetPriority(1);
106     subscriber_ = std::make_shared<NetStatsListener>(subscribeInfo);
107     subscriber_->RegisterStatsCallback(EventFwk::CommonEventSupport::COMMON_EVENT_SHUTDOWN,
108                                        [this](const EventFwk::Want &want) { return UpdateStatsData(); });
109     subscriber_->RegisterStatsCallback(
110         EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED,
111         [this](const EventFwk::Want &want) {
112             uint32_t uid = want.GetIntParam(UID, 0);
113             NETMGR_LOG_D("Net Manager delete uid, uid:[%{public}d]", uid);
114             auto handler = std::make_unique<NetStatsDataHandler>();
115             if (handler == nullptr) {
116                 NETMGR_LOG_E("Net Manager package removed, get db handler failed. uid:[%{public}d]", uid);
117                 return static_cast<int32_t>(NETMANAGER_ERR_INTERNAL);
118             }
119             auto ret1 = handler->UpdateStatsFlag(uid, STATS_DATA_FLAG_UNINSTALLED);
120             if (ret1 != NETMANAGER_SUCCESS) {
121                 NETMGR_LOG_E("Net Manager update stats flag failed, uid:[%{public}d]", uid);
122             }
123             auto ret2 = handler->UpdateSimStatsFlag(uid, STATS_DATA_FLAG_UNINSTALLED);
124             if (ret2 != NETMANAGER_SUCCESS) {
125                 NETMGR_LOG_E("Net Manager update sim stats flag failed, uid:[%{public}d]", uid);
126             }
127             netStatsCached_->ForceArchiveStats(uid);
128             return ret1 != NETMANAGER_SUCCESS ? ret1 : ret2;
129         });
130     EventFwk::CommonEventManager::SubscribeCommonEvent(subscriber_);
131 }
132 
GetDumpMessage(std::string & message)133 void NetStatsService::GetDumpMessage(std::string &message)
134 {
135     message.append("Net Stats Info:\n");
136     uint64_t rxBytes = 0;
137     uint64_t txBytes = 0;
138     uint64_t rxPackets = 0;
139     uint64_t txPackets = 0;
140     NetsysController::GetInstance().GetTotalStats(rxBytes, static_cast<uint32_t>(StatsType::STATS_TYPE_RX_BYTES));
141     NetsysController::GetInstance().GetTotalStats(txBytes, static_cast<uint32_t>(StatsType::STATS_TYPE_TX_BYTES));
142     NetsysController::GetInstance().GetTotalStats(rxPackets, static_cast<uint32_t>(StatsType::STATS_TYPE_RX_PACKETS));
143     NetsysController::GetInstance().GetTotalStats(txPackets, static_cast<uint32_t>(StatsType::STATS_TYPE_TX_PACKETS));
144 
145     message.append("\tRxBytes: " + std::to_string(rxBytes) + "\n");
146     message.append("\tTxBytes: " + std::to_string(txBytes) + "\n");
147     message.append("\tRxPackets: " + std::to_string(rxPackets) + "\n");
148     message.append("\tTxPackets: " + std::to_string(txPackets) + "\n");
149     std::for_each(BEAR_TYPE_LIST.begin(), BEAR_TYPE_LIST.end(), [&message, this](const auto &bearType) {
150         std::list<std::string> ifaceNames;
151         if (NetManagerCenter::GetInstance().GetIfaceNames(bearType, ifaceNames)) {
152             return;
153         }
154         uint64_t rx = 0;
155         uint64_t tx = 0;
156         for (const auto &name : ifaceNames) {
157             GetIfaceRxBytes(rx, name);
158             GetIfaceTxBytes(tx, name);
159             message.append("\t" + name + "-TxBytes: " + std::to_string(tx));
160             message.append("\t" + name + "-RxBytes: " + std::to_string(rx));
161         }
162     });
163 }
164 
Init()165 bool NetStatsService::Init()
166 {
167     if (!REGISTER_LOCAL_RESULT) {
168         NETMGR_LOG_E("Register to local sa manager failed");
169         registerToService_ = false;
170         return false;
171     }
172     if (!registerToService_) {
173         if (!Publish(DelayedSingleton<NetStatsService>::GetInstance().get())) {
174             NETMGR_LOG_E("Register to sa manager failed");
175             return false;
176         }
177         registerToService_ = true;
178     }
179     if (nullptr == netStatsCached_) {
180         return false;
181     }
182     netStatsCached_->SetCallbackManager(netStatsCallback_);
183     auto ret = netStatsCached_->StartCached();
184     if (ret != NETMANAGER_SUCCESS) {
185         NETMGR_LOG_E("Start cached failed");
186         return false;
187     }
188 
189     return true;
190 }
191 
RegisterNetStatsCallback(const sptr<INetStatsCallback> & callback)192 int32_t NetStatsService::RegisterNetStatsCallback(const sptr<INetStatsCallback> &callback)
193 {
194     NETMGR_LOG_I("Enter RegisterNetStatsCallback");
195     if (callback == nullptr) {
196         NETMGR_LOG_E("RegisterNetStatsCallback parameter callback is null");
197         return NETMANAGER_ERR_PARAMETER_ERROR;
198     }
199     netStatsCallback_->RegisterNetStatsCallback(callback);
200     return NETMANAGER_SUCCESS;
201 }
202 
UnregisterNetStatsCallback(const sptr<INetStatsCallback> & callback)203 int32_t NetStatsService::UnregisterNetStatsCallback(const sptr<INetStatsCallback> &callback)
204 {
205     NETMGR_LOG_I("Enter UnregisterNetStatsCallback");
206     if (callback == nullptr) {
207         NETMGR_LOG_E("UnregisterNetStatsCallback parameter callback is null");
208         return NETMANAGER_ERR_PARAMETER_ERROR;
209     }
210     netStatsCallback_->UnregisterNetStatsCallback(callback);
211     return NETMANAGER_SUCCESS;
212 }
213 
GetIfaceRxBytes(uint64_t & stats,const std::string & interfaceName)214 int32_t NetStatsService::GetIfaceRxBytes(uint64_t &stats, const std::string &interfaceName)
215 {
216     return NetsysController::GetInstance().GetIfaceStats(stats, static_cast<uint32_t>(StatsType::STATS_TYPE_RX_BYTES),
217                                                          interfaceName);
218 }
219 
GetIfaceTxBytes(uint64_t & stats,const std::string & interfaceName)220 int32_t NetStatsService::GetIfaceTxBytes(uint64_t &stats, const std::string &interfaceName)
221 {
222     return NetsysController::GetInstance().GetIfaceStats(stats, static_cast<uint32_t>(StatsType::STATS_TYPE_TX_BYTES),
223                                                          interfaceName);
224 }
225 
GetCellularRxBytes(uint64_t & stats)226 int32_t NetStatsService::GetCellularRxBytes(uint64_t &stats)
227 {
228     std::list<std::string> ifaceNames;
229     if (!GetIfaceNamesFromManager(ifaceNames)) {
230         return STATS_ERR_GET_IFACE_NAME_FAILED;
231     }
232 
233     for (const auto &name : ifaceNames) {
234         uint64_t totalCellular = 0;
235         auto ret = NetsysController::GetInstance().GetIfaceStats(
236             totalCellular, static_cast<uint32_t>(StatsType::STATS_TYPE_RX_BYTES), name);
237         if (ret != NETMANAGER_SUCCESS) {
238             NETMGR_LOG_E("Get iface stats failed result: %{public}d", ret);
239             return ret;
240         }
241         stats += totalCellular;
242     }
243     return NETMANAGER_SUCCESS;
244 }
245 
GetCellularTxBytes(uint64_t & stats)246 int32_t NetStatsService::GetCellularTxBytes(uint64_t &stats)
247 {
248     std::list<std::string> ifaceNames;
249     if (!GetIfaceNamesFromManager(ifaceNames)) {
250         return STATS_ERR_GET_IFACE_NAME_FAILED;
251     }
252 
253     uint64_t totalCellular = 0;
254     for (const auto &name : ifaceNames) {
255         auto ret = NetsysController::GetInstance().GetIfaceStats(
256             totalCellular, static_cast<uint32_t>(StatsType::STATS_TYPE_TX_BYTES), name);
257         if (ret != NETMANAGER_SUCCESS) {
258             NETMGR_LOG_E("Get iface stats failed result: %{public}d", ret);
259             return ret;
260         }
261         stats += totalCellular;
262     }
263     return NETMANAGER_SUCCESS;
264 }
265 
GetAllRxBytes(uint64_t & stats)266 int32_t NetStatsService::GetAllRxBytes(uint64_t &stats)
267 {
268     NETMGR_LOG_D("Enter GetAllRxBytes");
269     return NetsysController::GetInstance().GetTotalStats(stats, static_cast<uint32_t>(StatsType::STATS_TYPE_RX_BYTES));
270 }
271 
GetAllTxBytes(uint64_t & stats)272 int32_t NetStatsService::GetAllTxBytes(uint64_t &stats)
273 {
274     NETMGR_LOG_D("Enter GetAllTxBytes");
275     return NetsysController::GetInstance().GetTotalStats(stats, static_cast<uint32_t>(StatsType::STATS_TYPE_TX_BYTES));
276 }
277 
GetUidRxBytes(uint64_t & stats,uint32_t uid)278 int32_t NetStatsService::GetUidRxBytes(uint64_t &stats, uint32_t uid)
279 {
280     NETMGR_LOG_D("Enter GetUidRxBytes, uid is %{public}d", uid);
281     return NetsysController::GetInstance().GetUidStats(stats, static_cast<uint32_t>(StatsType::STATS_TYPE_RX_BYTES),
282                                                        uid);
283 }
284 
GetUidTxBytes(uint64_t & stats,uint32_t uid)285 int32_t NetStatsService::GetUidTxBytes(uint64_t &stats, uint32_t uid)
286 {
287     NETMGR_LOG_D("Enter GetUidTxBytes,uid is %{public}d", uid);
288     return NetsysController::GetInstance().GetUidStats(stats, static_cast<uint32_t>(StatsType::STATS_TYPE_TX_BYTES),
289                                                        uid);
290 }
291 
GetIfaceStatsDetail(const std::string & iface,uint64_t start,uint64_t end,NetStatsInfo & statsInfo)292 int32_t NetStatsService::GetIfaceStatsDetail(const std::string &iface, uint64_t start, uint64_t end,
293                                              NetStatsInfo &statsInfo)
294 {
295     // Start of get traffic data by interface name.
296     NETMGR_LOG_D("Enter GetIfaceStatsDetail, iface= %{public}s", iface.c_str());
297     NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService GetIfaceStatsDetail start");
298     if (start > end) {
299         NETMGR_LOG_E("start is after end.");
300         return NETMANAGER_ERR_INVALID_PARAMETER;
301     }
302     std::vector<NetStatsInfo> allInfo;
303     auto history = std::make_unique<NetStatsHistory>();
304     int32_t ret = history->GetHistory(allInfo, iface, start, end);
305 
306     if (netStatsCached_ == nullptr) {
307         NETMGR_LOG_E("netStatsCached_ is fail");
308         return NETMANAGER_ERR_LOCAL_PTR_NULL;
309     }
310     netStatsCached_->GetIfaceStatsCached(allInfo);
311     if (ret != NETMANAGER_SUCCESS) {
312         NETMGR_LOG_E("Get traffic stats data failed");
313         return ret;
314     }
315     std::for_each(allInfo.begin(), allInfo.end(), [&statsInfo, &iface, &start, &end](const auto &info) {
316         if (info.iface_ == iface && info.date_ >= start && info.date_ <= end) {
317             statsInfo += info;
318         }
319     });
320     statsInfo.iface_ = iface;
321     statsInfo.date_ = end;
322     // End of get traffic data by interface name.
323     NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService GetIfaceStatsDetail end");
324     return NETMANAGER_SUCCESS;
325 }
326 
GetUidStatsDetail(const std::string & iface,uint32_t uid,uint64_t start,uint64_t end,NetStatsInfo & statsInfo)327 int32_t NetStatsService::GetUidStatsDetail(const std::string &iface, uint32_t uid, uint64_t start, uint64_t end,
328                                            NetStatsInfo &statsInfo)
329 {
330     // Start of get traffic data by usr id.
331     NETMGR_LOG_D("Enter GetIfaceStatsDetail, iface= %{public}s uid= %{public}d", iface.c_str(), uid);
332     NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService GetUidStatsDetail start");
333     if (start > end) {
334         NETMGR_LOG_E("start is after end.");
335         return NETMANAGER_ERR_INVALID_PARAMETER;
336     }
337     std::vector<NetStatsInfo> allInfo;
338     auto history = std::make_unique<NetStatsHistory>();
339     int32_t ret = history->GetHistory(allInfo, iface, uid, start, end);
340     if (netStatsCached_ == nullptr) {
341         NETMGR_LOG_E("netStatsCached_ is fail");
342         return NETMANAGER_ERR_LOCAL_PTR_NULL;
343     }
344     netStatsCached_->GetUidStatsCached(allInfo);
345     if (ret != NETMANAGER_SUCCESS) {
346         NETMGR_LOG_E("Get traffic stats data failed");
347         return ret;
348     }
349     std::for_each(allInfo.begin(), allInfo.end(), [&statsInfo, &iface, &uid, &start, &end](const auto &info) {
350         if (info.iface_ == iface && info.uid_ == uid && info.date_ >= start && info.date_ <= end) {
351             statsInfo += info;
352         }
353     });
354     statsInfo.uid_ = uid;
355     statsInfo.iface_ = iface;
356     statsInfo.date_ = end;
357     // End of get traffic data by usr id.
358     NetmanagerHiTrace::NetmanagerFinishSyncTrace("NetStatsService GetUidStatsDetail end");
359     return NETMANAGER_SUCCESS;
360 }
361 
UpdateIfacesStats(const std::string & iface,uint64_t start,uint64_t end,const NetStatsInfo & stats)362 int32_t NetStatsService::UpdateIfacesStats(const std::string &iface, uint64_t start, uint64_t end,
363                                            const NetStatsInfo &stats)
364 {
365     // Start of update traffic data by date.
366     NETMGR_LOG_I("UpdateIfacesStats ifaces is %{public}s", iface.c_str());
367     NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService UpdateIfacesStats start");
368     if (start > end) {
369         NETMGR_LOG_E("start is after end.");
370         return NETMANAGER_ERR_INVALID_PARAMETER;
371     }
372     std::vector<NetStatsInfo> infos;
373     infos.push_back(stats);
374     auto handler = std::make_unique<NetStatsDataHandler>();
375     auto ret = handler->DeleteByDate(IFACE_TABLE, start, end);
376     if (ret != NETMANAGER_SUCCESS) {
377         NETMGR_LOG_E("Update ifaces stats failed");
378     }
379     ret = handler->WriteStatsData(infos, IFACE_TABLE);
380     if (ret != NETMANAGER_SUCCESS) {
381         NETMGR_LOG_E("Update ifaces stats failed");
382         return STATS_ERR_WRITE_DATA_FAIL;
383     }
384     // End of update traffic data by date.
385     NetmanagerHiTrace::NetmanagerFinishSyncTrace("NetStatsService UpdateIfacesStats end");
386     return ret;
387 }
388 
UpdateStatsData()389 int32_t NetStatsService::UpdateStatsData()
390 {
391     NETMGR_LOG_D("Enter UpdateStatsData.");
392     if (netStatsCached_ == nullptr) {
393         NETMGR_LOG_E("Cached is nullptr");
394         return NETMANAGER_ERR_LOCAL_PTR_NULL;
395     }
396     netStatsCached_->ForceUpdateStats();
397     NETMGR_LOG_D("End UpdateStatsData.");
398     return NETMANAGER_SUCCESS;
399 }
400 
ResetFactory()401 int32_t NetStatsService::ResetFactory()
402 {
403     auto handler = std::make_unique<NetStatsDataHandler>();
404     return handler->ClearData();
405 }
406 
GetAllStatsInfo(std::vector<NetStatsInfo> & infos)407 int32_t NetStatsService::GetAllStatsInfo(std::vector<NetStatsInfo> &infos)
408 {
409     NETMGR_LOG_D("Enter GetAllStatsInfo.");
410     if (netStatsCached_ != nullptr) {
411         netStatsCached_->GetUidPushStatsCached(infos);
412         netStatsCached_->GetAllPushStatsCached(infos);
413     } else {
414         NETMGR_LOG_E("Cached is nullptr");
415     }
416     return NetsysController::GetInstance().GetAllStatsInfo(infos);
417 }
418 
GetAllSimStatsInfo(std::vector<NetStatsInfo> & infos)419 int32_t NetStatsService::GetAllSimStatsInfo(std::vector<NetStatsInfo> &infos)
420 {
421     NETMGR_LOG_D("Enter GetAllSimStatsInfo.");
422     return NetsysController::GetInstance().GetAllSimStatsInfo(infos);
423 }
424 
GetTrafficStatsByNetwork(std::unordered_map<uint32_t,NetStatsInfo> & infos,const sptr<NetStatsNetwork> & network)425 int32_t NetStatsService::GetTrafficStatsByNetwork(std::unordered_map<uint32_t, NetStatsInfo> &infos,
426                                                   const sptr<NetStatsNetwork> &network)
427 {
428     NETMGR_LOG_D("Enter GetTrafficStatsByNetwork.");
429     NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService GetTrafficStatsByNetwork start");
430     if (netStatsCached_ == nullptr) {
431         return NETMANAGER_ERR_LOCAL_PTR_NULL;
432     }
433     if (network == nullptr || network->startTime_ > network->endTime_) {
434         NETMGR_LOG_E("param network is invalid");
435         return NETMANAGER_ERR_INVALID_PARAMETER;
436     }
437     std::string ident;
438     if (network->type_ == 0) {
439         ident = std::to_string(network->simId_);
440     }
441     uint32_t start = network->startTime_;
442     uint32_t end = network->endTime_;
443     NETMGR_LOG_D("param: ident=%{public}s, start=%{public}u, end=%{public}u", ident.c_str(), start, end);
444     auto history = std::make_unique<NetStatsHistory>();
445     if (history == nullptr) {
446         NETMGR_LOG_E("history is null");
447         return NETMANAGER_ERR_INTERNAL;
448     }
449     std::vector<NetStatsInfo> allInfo;
450     int32_t ret = history->GetHistoryByIdent(allInfo, ident, start, end);
451     if (ret != NETMANAGER_SUCCESS) {
452         NETMGR_LOG_E("get history by ident failed, err code=%{public}d", ret);
453         return ret;
454     }
455     netStatsCached_->GetKernelStats(allInfo);
456     netStatsCached_->GetUidPushStatsCached(allInfo);
457     netStatsCached_->GetUidStatsCached(allInfo);
458     netStatsCached_->GetUidSimStatsCached(allInfo);
459     std::for_each(allInfo.begin(), allInfo.end(), [&infos, &ident, &start, &end](NetStatsInfo &info) {
460         if (ident != info.ident_ || start > info.date_ || end < info.date_) {
461             return;
462         }
463         if (info.flag_ == STATS_DATA_FLAG_UNINSTALLED) {
464             info.uid_ = UNINSTALLED_UID;
465         }
466         auto item = infos.find(info.uid_);
467         if (item == infos.end()) {
468             infos.emplace(info.uid_, info);
469         } else {
470             item->second += info;
471         }
472     });
473     NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService GetTrafficStatsByNetwork end");
474     return NETMANAGER_SUCCESS;
475 }
476 
GetTrafficStatsByUidNetwork(std::vector<NetStatsInfoSequence> & infos,uint32_t uid,const sptr<NetStatsNetwork> & network)477 int32_t NetStatsService::GetTrafficStatsByUidNetwork(std::vector<NetStatsInfoSequence> &infos, uint32_t uid,
478                                                      const sptr<NetStatsNetwork> &network)
479 {
480     NETMGR_LOG_D("Enter GetTrafficStatsByUidNetwork.");
481     NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService GetTrafficStatsByUidNetwork start");
482     if (netStatsCached_ == nullptr) {
483         NETMGR_LOG_E("Cached is nullptr");
484         return NETMANAGER_ERR_LOCAL_PTR_NULL;
485     }
486     if (network == nullptr || network->startTime_ > network->endTime_) {
487         NETMGR_LOG_E("param network is invalid");
488         return NETMANAGER_ERR_INVALID_PARAMETER;
489     }
490     std::string ident;
491     if (network->type_ == 0) {
492         ident = std::to_string(network->simId_);
493     }
494     uint32_t start = network->startTime_;
495     uint32_t end = network->endTime_;
496     NETMGR_LOG_D("GetTrafficStatsByUidNetwork param: "
497         "uid=%{public}u, ident=%{public}s, start=%{public}u, end=%{public}u", uid, ident.c_str(), start, end);
498     auto history = std::make_unique<NetStatsHistory>();
499     if (history == nullptr) {
500         NETMGR_LOG_E("history is null");
501         return NETMANAGER_ERR_INTERNAL;
502     }
503     std::vector<NetStatsInfo> allInfo;
504     int32_t ret = history->GetHistory(allInfo, uid, ident, start, end);
505     if (ret != NETMANAGER_SUCCESS) {
506         NETMGR_LOG_E("get history by uid and ident failed, err code=%{public}d", ret);
507         return ret;
508     }
509     netStatsCached_->GetKernelStats(allInfo);
510     netStatsCached_->GetUidPushStatsCached(allInfo);
511     netStatsCached_->GetUidStatsCached(allInfo);
512     netStatsCached_->GetUidSimStatsCached(allInfo);
513     std::for_each(allInfo.begin(), allInfo.end(), [this, &infos, &uid, &ident, &start, &end](const NetStatsInfo &info) {
514         if (uid != info.uid_ || ident != info.ident_ || start > info.date_ || end < info.date_) {
515             return;
516         }
517         if (info.flag_ == STATS_DATA_FLAG_UNINSTALLED) {
518             return;
519         }
520         MergeTrafficStats(infos, info, end);
521     });
522     NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService GetTrafficStatsByUidNetwork end");
523     return NETMANAGER_SUCCESS;
524 }
525 
SetAppStats(const PushStatsInfo & info)526 int32_t NetStatsService::SetAppStats(const PushStatsInfo &info)
527 {
528     NETMGR_LOG_D("Enter GetTrafficStatsByUidNetwork.");
529     NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService SetAppStats start");
530     if (netStatsCached_ == nullptr) {
531         NETMGR_LOG_E("Cached is nullptr");
532         return NETMANAGER_ERR_LOCAL_PTR_NULL;
533     }
534     netStatsCached_->SetAppStats(info);
535     NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService SetAppStats end");
536     return NETMANAGER_SUCCESS;
537 }
538 
GetCookieRxBytes(uint64_t & stats,uint64_t cookie)539 int32_t NetStatsService::GetCookieRxBytes(uint64_t &stats, uint64_t cookie)
540 {
541     return NetsysController::GetInstance().GetCookieStats(stats, static_cast<uint32_t>(StatsType::STATS_TYPE_RX_BYTES),
542                                                           cookie);
543 }
544 
GetCookieTxBytes(uint64_t & stats,uint64_t cookie)545 int32_t NetStatsService::GetCookieTxBytes(uint64_t &stats, uint64_t cookie)
546 {
547     return NetsysController::GetInstance().GetCookieStats(stats, static_cast<uint32_t>(StatsType::STATS_TYPE_TX_BYTES),
548                                                           cookie);
549 }
550 
MergeTrafficStats(std::vector<NetStatsInfoSequence> & statsInfoSequences,const NetStatsInfo & info,uint32_t currentTimestamp)551 void NetStatsService::MergeTrafficStats(std::vector<NetStatsInfoSequence> &statsInfoSequences, const NetStatsInfo &info,
552                                         uint32_t currentTimestamp)
553 {
554     NetStatsInfoSequence tmp;
555     tmp.startTime_ = info.date_;
556     tmp.endTime_ = info.date_;
557     tmp.info_ = info;
558     uint32_t previousTimestamp = currentTimestamp > DAY_SECONDS ? currentTimestamp - DAY_SECONDS : 0;
559     if (info.date_ > previousTimestamp) {
560         statsInfoSequences.push_back(std::move(tmp));
561         return;
562     }
563     auto findRet = std::find_if(
564         statsInfoSequences.begin(), statsInfoSequences.end(), [&info, previousTimestamp](const auto &item) {
565             return item.endTime_ < previousTimestamp && CommonUtils::IsSameNaturalDay(info.date_, item.endTime_);
566         });
567     if (findRet == statsInfoSequences.end()) {
568         statsInfoSequences.push_back(std::move(tmp));
569         return;
570     }
571     (*findRet).info_ += info;
572 }
573 
GetIfaceNamesFromManager(std::list<std::string> & ifaceNames)574 bool NetStatsService::GetIfaceNamesFromManager(std::list<std::string> &ifaceNames)
575 {
576     int32_t ret = NetManagerCenter::GetInstance().GetIfaceNames(BEARER_CELLULAR, ifaceNames);
577     if (ret != NETMANAGER_SUCCESS || ifaceNames.empty()) {
578         NETMGR_LOG_D("Iface list is empty, ret = %{public}d", ret);
579         return false;
580     }
581     return true;
582 }
583 } // namespace NetManagerStandard
584 } // namespace OHOS
585