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