• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #ifndef NET_STATS_CACHED_H
17 #define NET_STATS_CACHED_H
18 
19 #include <algorithm>
20 #include <map>
21 #include <mutex>
22 #include <vector>
23 
24 #include "ffrt.h"
25 #include "net_bundle.h"
26 #include "net_push_stats_info.h"
27 #include "net_stats_callback.h"
28 #include "net_stats_constants.h"
29 #include "net_stats_info.h"
30 #include "netmanager_base_common_utils.h"
31 #include "safe_map.h"
32 #ifdef SUPPORT_NETWORK_SHARE
33 #include "network_sharing.h"
34 #endif // SUPPORT_NETWORK_SHARE
35 
36 #include "ffrt_timer.h"
37 
38 namespace OHOS {
39 namespace NetManagerStandard {
40 class NetStatsCached {
41 public:
42     NetStatsCached();
43     ~NetStatsCached() = default;
44     void ForceUpdateStats();
45     void ForceUpdateStatsAndBackupDB(const std::string &sourceDb, const std::string &backupDb);
46 
47     ffrt::task_handle ForceArchiveStats(uint32_t uid);
48 
49     void ForceCachedStats();
50 
51     int32_t StartCached();
52 
53     int32_t CreatNetStatsTables(const std::string &tableName);
54 
55     void SetCycleThreshold(uint32_t threshold);
56 
57     void GetUidStatsCached(std::vector<NetStatsInfo> &uidStatsInfo);
58 
59     void GetUidSimStatsCached(std::vector<NetStatsInfo> &uidSimStatsInfo);
60 
61     void GetUidPushStatsCached(std::vector<NetStatsInfo> &uidPushStatsInfo);
62 
63     void GetAllPushStatsCached(std::vector<NetStatsInfo> &uidPushStatsInfo);
64 
65     void GetIfaceStatsCached(std::vector<NetStatsInfo> &ifaceStatsInfo);
66 
67     void SetAppStats(const PushStatsInfo &info);
68 
69     void GetKernelStats(std::vector<NetStatsInfo> &statsInfo);
70 
71 #ifdef SUPPORT_NETWORK_SHARE
72     void GetIptablesStatsCached(std::vector<NetStatsInfo> &iptablesStatsInfo);
73 
74     void GetIptablesStatsIncrease(std::vector<NetStatsInfo> &InfosVec);
75 #endif
76     void SaveSharingTraffic(const NetStatsInfo &infos);
77 
SetTrafficThreshold(uint64_t threshold)78     inline void SetTrafficThreshold(uint64_t threshold)
79     {
80         trafficThreshold_ = threshold;
81     }
82 
SetDateThreshold(uint64_t threshold)83     inline void SetDateThreshold(uint64_t threshold)
84     {
85         cycleThreshold_ = threshold;
86     }
87 
SetCallbackManager(const std::shared_ptr<NetStatsCallback> & callbackManager)88     inline void SetCallbackManager(const std::shared_ptr<NetStatsCallback> &callbackManager)
89     {
90         stats_.SetNotifier(callbackManager);
91     }
92 
93     int32_t GetCurPrivateUserId();
94 
95     void SetCurPrivateUserId(int32_t userId);
96 
97     int32_t GetCurDefaultUserId();
98 
99     void SetCurDefaultUserId(int32_t userId);
100 
101     void Reset();
102 
103     void SetUidSimSampleBundle(uint32_t uid, const SampleBundleInfo &info);
104 
105     void DeleteUidSimSampleBundle(uint32_t uid);
106 
107     std::optional<SampleBundleInfo> GetUidSimSampleBundle(uint32_t uid);
108 
109     uint32_t GetUidSimSampleBundlesSize();
110 
111     void SetUidStatsFlag(std::unordered_map<uint32_t, SampleBundleInfo> &sampleBundleMap);
112 
113     void DeleteUidStatsFlag(uint32_t uid);
114 
115     void DeleteUidSimStatsWithFlag(uint32_t uid, uint32_t flag);
116 
117     void ClearUidStatsFlag();
118 
119 #ifdef SUPPORT_NETWORK_SHARE
120     void DeleteIptablesStats();
121 
122     uint64_t GetWriteDateTime();
123 #endif
124 
125 private:
126     class CachedInfo {
127     public:
PushUidStats(NetStatsInfo & info)128         void PushUidStats(NetStatsInfo &info)
129         {
130             if (info.HasNoData()) {
131                 return;
132             }
133             info.date_ = CommonUtils::GetCurrentSecond();
134             uidStatsInfo_.push_back(info);
135             currentUidStats_ += info.GetStats();
136             if (netStatsCallbackManager_ != nullptr) {
137                 netStatsCallbackManager_->NotifyNetUidStatsChanged(info.iface_, info.uid_);
138             }
139         }
140 
PushUidSimStats(NetStatsInfo & info)141         void PushUidSimStats(NetStatsInfo &info)
142         {
143             if (info.HasNoData()) {
144                 return;
145             }
146             info.date_ = CommonUtils::GetCurrentSecond();
147             uidSimStatsInfo_.push_back(info);
148             currentUidSimStats_ += info.GetStats();
149             if (netStatsCallbackManager_ != nullptr) {
150                 netStatsCallbackManager_->NotifyNetUidStatsChanged(info.iface_, info.uid_);
151             }
152         }
153 
PushIfaceStats(NetStatsInfo & info)154         void PushIfaceStats(NetStatsInfo &info)
155         {
156             if (info.HasNoData()) {
157                 return;
158             }
159             info.date_ = CommonUtils::GetCurrentSecond();
160             ifaceStatsInfo_.push_back(info);
161             currentIfaceStats_ += info.GetStats();
162             if (netStatsCallbackManager_ != nullptr) {
163                 netStatsCallbackManager_->NotifyNetIfaceStatsChanged(info.iface_);
164             }
165         }
166 
167 #ifdef SUPPORT_NETWORK_SHARE
PushIptablesStats(NetStatsInfo & info)168         void PushIptablesStats(NetStatsInfo &info)
169         {
170             if (info.HasNoData()) {
171                 return;
172             }
173             info.date_ = CommonUtils::GetCurrentSecond();
174             iptablesStatsInfo_.push_back(info);
175             currentIptablesStats_ += info.GetStats();
176             if (netStatsCallbackManager_ != nullptr) {
177                 netStatsCallbackManager_->NotifyNetUidStatsChanged(info.iface_, info.uid_);
178             }
179         }
180 #endif
181 
GetUidStatsInfo()182         inline std::vector<NetStatsInfo> &GetUidStatsInfo()
183         {
184             return uidStatsInfo_;
185         }
186 
GetUidSimStatsInfo()187         inline std::vector<NetStatsInfo> &GetUidSimStatsInfo()
188         {
189             return uidSimStatsInfo_;
190         }
191 
GetIfaceStatsInfo()192         inline std::vector<NetStatsInfo> &GetIfaceStatsInfo()
193         {
194             return ifaceStatsInfo_;
195         }
196 
197 #ifdef SUPPORT_NETWORK_SHARE
GetIptablesStatsInfo()198         inline std::vector<NetStatsInfo> &GetIptablesStatsInfo()
199         {
200             return iptablesStatsInfo_;
201         }
202 #endif
203 
GetCurrentUidStats()204         inline uint64_t GetCurrentUidStats() const
205         {
206             return currentUidStats_;
207         }
208 
GetCurrentUidSimStats()209         inline uint64_t GetCurrentUidSimStats() const
210         {
211             return currentUidSimStats_;
212         }
213 
GetCurrentIfaceStats()214         inline uint64_t GetCurrentIfaceStats() const
215         {
216             return currentIfaceStats_;
217         }
218 
219 #ifdef SUPPORT_NETWORK_SHARE
GetCurrentIptablesStats()220         inline uint64_t GetCurrentIptablesStats() const
221         {
222             return currentIptablesStats_;
223         }
224 #endif
225 
ResetUidStats()226         void ResetUidStats()
227         {
228             uidStatsInfo_.clear();
229             currentUidStats_ = 0;
230         }
231 
ResetUidStats(uint32_t uid)232         void ResetUidStats(uint32_t uid)
233         {
234             for (const auto &item : uidStatsInfo_) {
235                 if (item.uid_ == uid) {
236                     currentUidStats_ -= item.GetStats();
237                 }
238             }
239             uidStatsInfo_.erase(std::remove_if(uidStatsInfo_.begin(), uidStatsInfo_.end(),
240                                                [uid](const auto &item) { return item.uid_ == uid; }),
241                                 uidStatsInfo_.end());
242         }
243 
ResetUidSimStats()244         void ResetUidSimStats()
245         {
246             uidSimStatsInfo_.clear();
247             currentUidSimStats_ = 0;
248         }
249 
ResetUidSimStats(uint32_t uid)250         void ResetUidSimStats(uint32_t uid)
251         {
252             for (const auto &item : uidSimStatsInfo_) {
253                 if (item.uid_ == uid) {
254                     currentUidSimStats_ -= item.GetStats();
255                 }
256             }
257             uidSimStatsInfo_.erase(std::remove_if(uidSimStatsInfo_.begin(), uidSimStatsInfo_.end(),
258                                                   [uid](const auto &item) { return item.uid_ == uid; }),
259                                    uidSimStatsInfo_.end());
260         }
261 
ResetIfaceStats()262         void ResetIfaceStats()
263         {
264             ifaceStatsInfo_.clear();
265             currentIfaceStats_ = 0;
266         }
267 
268 #ifdef SUPPORT_NETWORK_SHARE
ResetIptablesStats()269         void ResetIptablesStats()
270         {
271             iptablesStatsInfo_.clear();
272             currentIptablesStats_ = 0;
273         }
274 #endif
275 
SetNotifier(const std::shared_ptr<NetStatsCallback> & callbackManager)276         inline void SetNotifier(const std::shared_ptr<NetStatsCallback> &callbackManager)
277         {
278             netStatsCallbackManager_ = callbackManager;
279         }
280 
281     private:
282         uint64_t currentUidStats_ = 0;
283         uint64_t currentUidSimStats_ = 0;
284         uint64_t currentIfaceStats_ = 0;
285         std::vector<NetStatsInfo> uidStatsInfo_;
286         std::vector<NetStatsInfo> uidSimStatsInfo_;
287         std::vector<NetStatsInfo> ifaceStatsInfo_;
288         std::shared_ptr<NetStatsCallback> netStatsCallbackManager_ = nullptr;
289 #ifdef SUPPORT_NETWORK_SHARE
290         uint64_t currentIptablesStats_ = 0;
291         std::vector<NetStatsInfo> iptablesStatsInfo_;
292 #endif
293     };
294 
295     static constexpr uint32_t DEFAULT_CACHE_CYCLE_MS = 30 * 60 * 1000;
296     static constexpr uint64_t DEFAULT_TRAFFIC_STATISTICS_THRESHOLD_BYTES = 2 * 1024 * 1024;
297     static constexpr uint64_t DEFAULT_DATA_CYCLE_S = 180 * 24 * 60 * 60;
298     static constexpr uint64_t CACHE_DATE_TIME_S = 1 * 24 * 60 * 60;
299     static constexpr uint64_t STATS_PACKET_CYCLE_MS = 1 * 60 * 60 * 1000;
300 
301     CachedInfo stats_;
302     ffrt::mutex lock_;
303     std::mutex mutex_ {};
304     std::atomic<bool> isForce_ = false;
305     std::atomic<bool> isExec_ = false;
306     std::atomic<bool> isExecBackUp_ = false;
307     std::unique_ptr<FfrtTimer> cacheTimer_ = nullptr;
308     std::unique_ptr<FfrtTimer> writeTimer_ = nullptr;
309     uint32_t cycleThreshold_ = DEFAULT_CACHE_CYCLE_MS;
310     uint64_t trafficThreshold_ = DEFAULT_TRAFFIC_STATISTICS_THRESHOLD_BYTES;
311     uint64_t dateCycle_ = DEFAULT_DATA_CYCLE_S;
312     std::vector<NetStatsInfo> uidPushStatsInfo_;
313     std::vector<NetStatsInfo> allPushStatsInfo_;
314     std::vector<NetStatsInfo> lastUidStatsInfo_;
315     std::vector<NetStatsInfo> lastUidSimStatsInfo_;
316     std::map<std::string, NetStatsInfo> lastIfaceStatsMap_;
317     std::atomic<int64_t> uninstalledUid_ = -1;
318     SafeMap<std::string, std::string> ifaceNameIdentMap_;
319     SafeMap<uint32_t, NetStatsDataFlag> uidStatsFlagMap_;
320     SafeMap<uint32_t, SampleBundleInfo> uidSimSampleBundleMap_;
321     bool isDisplayTrafficAncoList = false;
322     int32_t curPrivateUserId_ = -1;
323     int32_t curDefaultUserId_ = -1;
324 #ifdef SUPPORT_NETWORK_SHARE
325     std::vector<NetStatsInfo> lastIptablesStatsInfo_;
326     uint64_t writeDate_ = 0;
327 #endif
328 
329     void LoadIfaceNameIdentMaps();
330     NetStatsDataFlag GetUidStatsFlag(uint32_t uid);
331     void IsExistInUidSimSampleBundleMap(bool &isExistSim, bool &isExistSim2);
332     std::optional<SampleBundleInfo> GetEarlySampleBundleInfo();
333 
334     void CacheStats();
335     void CacheUidStats();
336     void CacheUidSimStats();
337     void CacheIfaceStats();
338     void CacheAppStats();
339     void GetKernelUidStats(std::vector<NetStatsInfo> &statsInfo);
340     void GetKernelUidSimStats(std::vector<NetStatsInfo> &statsInfo);
341     void DeleteUidStats(uint32_t uid);
342     void DeleteUidSimStats(uint32_t uid);
343 
344     void WriteStats();
345     void WriteUidStats();
346     void WriteUidSimStats();
347     void WriteIfaceStats();
348 #ifdef SUPPORT_NETWORK_SHARE
349     void CacheIptablesStats();
350     void CacheIptablesStatsService(nmd::NetworkSharingTraffic &traffic, std::string &ifaceName);
351     void WriteIptablesStats();
352 #endif
353 
354     void GetUpIfaceName(std::string &downIface, std::string &upIface);
355 
356     NetStatsInfo GetIncreasedStats(const NetStatsInfo &info);
357 
358     NetStatsInfo GetIncreasedSimStats(const NetStatsInfo &info);
359 
CheckUidStor()360     inline bool CheckUidStor()
361     {
362         return stats_.GetCurrentUidStats() >= trafficThreshold_;
363     }
364 
CheckUidSimStor()365     inline bool CheckUidSimStor()
366     {
367         return stats_.GetCurrentUidSimStats() >= trafficThreshold_;
368     }
369 
CheckIfaceStor()370     inline bool CheckIfaceStor()
371     {
372         return stats_.GetCurrentIfaceStats() >= trafficThreshold_;
373     }
374 
375 #ifdef SUPPORT_NETWORK_SHARE
CheckIptablesStor()376     inline bool CheckIptablesStor()
377     {
378         return stats_.GetCurrentIptablesStats() >= trafficThreshold_;
379     }
380 #endif
381 };
382 } // namespace NetManagerStandard
383 } // namespace OHOS
384 
385 #endif // NET_STATS_CACHED_H
386