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_policy_file.h"
17 
18 #include <fcntl.h>
19 #include <string>
20 
21 #include "net_manager_center.h"
22 #include "net_mgr_log_wrapper.h"
23 #include "net_policy_file_event_handler.h"
24 #include "net_policy_inner_define.h"
25 
26 namespace OHOS {
27 namespace NetManagerStandard {
28 namespace {
CheckFilePath(const std::string & fileName,std::string & realPath)29 bool CheckFilePath(const std::string &fileName, std::string &realPath)
30 {
31     char tmpPath[PATH_MAX] = {0};
32     if (!realpath(fileName.c_str(), tmpPath)) {
33         NETMGR_LOG_E("file name is illegal");
34         return false;
35     }
36     if (strcmp(tmpPath, POLICY_FILE_NAME) != 0) {
37         NETMGR_LOG_E("file path is illegal");
38         return false;
39     }
40     realPath = tmpPath;
41     return true;
42 }
43 } // namespace
44 constexpr const char *NET_POLICY_WORK_THREAD = "NET_POLICY_FILE_WORK_THREAD";
45 
NetPolicyFile()46 NetPolicyFile::NetPolicyFile()
47 {
48     InitPolicy();
49 }
50 
51 NetPolicyFile::~NetPolicyFile() = default;
52 
ReadFile(const std::string & fileName)53 bool NetPolicyFile::ReadFile(const std::string &fileName)
54 {
55     NETMGR_LOG_D("read [%{public}s] from disk.", fileName.c_str());
56     struct stat st;
57     if (stat(fileName.c_str(), &st) != 0) {
58         NETMGR_LOG_E("stat file fail");
59         return false;
60     }
61 
62     std::string realPath;
63     if (!CheckFilePath(fileName, realPath)) {
64         NETMGR_LOG_E("file does not exist");
65         return false;
66     }
67 
68     std::fstream file(realPath.c_str(), std::fstream::in);
69     if (!file.is_open()) {
70         NETMGR_LOG_E("file open fail");
71         return false;
72     }
73 
74     std::stringstream buffer;
75     buffer << file.rdbuf();
76     std::string fileContent = buffer.str();
77     file.close();
78     return Json2Obj(fileContent, netPolicy_);
79 }
80 
ReadFile()81 bool NetPolicyFile::ReadFile()
82 {
83     return ReadFile(POLICY_FILE_NAME) || ReadFile(POLICY_FILE_BAK_NAME);
84 }
85 
WriteFile()86 bool NetPolicyFile::WriteFile()
87 {
88     auto data = std::make_shared<PolicyFileEvent>();
89     Obj2Json(netPolicy_, data->json);
90     auto event = AppExecFwk::InnerEvent::Get(NetPolicyFileEventHandler::MSG_POLICY_FILE_WRITE, data);
91     auto handler = GetHandler();
92     if (!handler) {
93         NETMGR_LOG_E("NetPolicyFileEventHandler not existed");
94         return false;
95     }
96     handler->SendWriteEvent(event);
97     return true;
98 }
99 
ReadUidPolicies()100 const std::vector<UidPolicy> &NetPolicyFile::ReadUidPolicies()
101 {
102     return netPolicy_.uidPolicies;
103 }
104 
ParseUidPolicy(const cJSON * const root,NetPolicy & netPolicy)105 void NetPolicyFile::ParseUidPolicy(const cJSON* const root, NetPolicy &netPolicy)
106 {
107     cJSON *netUidPolicy = cJSON_GetObjectItem(root, CONFIG_UID_POLICY);
108     if (netUidPolicy == nullptr) {
109         return;
110     }
111     uint32_t size = cJSON_GetArraySize(netUidPolicy);
112     UidPolicy uidPolicy;
113     for (uint32_t i = 0; i < size; i++) {
114         cJSON *uidPolicyItem = cJSON_GetArrayItem(netUidPolicy, i);
115         if (uidPolicyItem == nullptr) {
116             NETMGR_LOG_E("uidPolicyItem is null");
117             continue;
118         }
119         cJSON *uid = cJSON_GetObjectItem(uidPolicyItem, CONFIG_UID);
120         uidPolicy.uid = cJSON_GetStringValue(uid);
121         NETMGR_LOG_D("uid: %{public}s", uidPolicy.uid.c_str());
122         cJSON *policy = cJSON_GetObjectItem(uidPolicyItem, CONFIG_POLICY);
123         uidPolicy.policy = cJSON_GetStringValue(policy);
124         NETMGR_LOG_D("policy: %{public}s", uidPolicy.policy.c_str());
125         netPolicy.uidPolicies.push_back(uidPolicy);
126     }
127 }
128 
ParseBackgroundPolicy(const cJSON * const root,NetPolicy & netPolicy)129 void NetPolicyFile::ParseBackgroundPolicy(const cJSON* const root, NetPolicy &netPolicy)
130 {
131     cJSON *netBackgroundPolicy = cJSON_GetObjectItem(root, CONFIG_BACKGROUND_POLICY);
132     if (netBackgroundPolicy != nullptr) {
133         cJSON *status = cJSON_GetObjectItem(netBackgroundPolicy, CONFIG_BACKGROUND_POLICY_STATUS);
134         netPolicy.backgroundPolicyStatus = cJSON_GetStringValue(status);
135         NETMGR_LOG_D("backgroundPolicyStatus: %{public}s", netPolicy.backgroundPolicyStatus.c_str());
136     }
137 }
138 
ParseQuotaPolicy(const cJSON * const root,NetPolicy & netPolicy)139 void NetPolicyFile::ParseQuotaPolicy(const cJSON* const root, NetPolicy &netPolicy)
140 {
141     cJSON *netQuotaPolicy = cJSON_GetObjectItem(root, CONFIG_QUOTA_POLICY);
142     if (netQuotaPolicy == nullptr) {
143         return;
144     }
145     NetPolicyQuota quotaPolicy;
146     uint32_t size = cJSON_GetArraySize(netQuotaPolicy);
147     NETMGR_LOG_D("netQuotaPolicy size: %{public}u", size);
148     for (uint32_t i = 0; i < size; i++) {
149         cJSON *quotaPolicyItem = cJSON_GetArrayItem(netQuotaPolicy, i);
150         if (quotaPolicyItem == nullptr) {
151             NETMGR_LOG_E("quotaPolicyItem is null");
152             continue;
153         }
154         cJSON *netType = cJSON_GetObjectItem(quotaPolicyItem, CONFIG_QUOTA_POLICY_NETTYPE);
155         quotaPolicy.netType = cJSON_GetStringValue(netType);
156         cJSON *simId = cJSON_GetObjectItem(quotaPolicyItem, CONFIG_QUOTA_POLICY_SUBSCRIBERID);
157         quotaPolicy.simId = cJSON_GetStringValue(simId);
158         cJSON *periodStartTime = cJSON_GetObjectItem(quotaPolicyItem, CONFIG_QUOTA_POLICY_PERIODSTARTTIME);
159         quotaPolicy.periodStartTime = cJSON_GetStringValue(periodStartTime);
160         cJSON *periodDuration = cJSON_GetObjectItem(quotaPolicyItem, CONFIG_QUOTA_POLICY_PERIODDURATION);
161         quotaPolicy.periodDuration = cJSON_GetStringValue(periodDuration);
162         cJSON *warningBytes = cJSON_GetObjectItem(quotaPolicyItem, CONFIG_QUOTA_POLICY_WARNINGBYTES);
163         quotaPolicy.warningBytes = cJSON_GetStringValue(warningBytes);
164         cJSON *limitBytes = cJSON_GetObjectItem(quotaPolicyItem, CONFIG_QUOTA_POLICY_LIMITBYTES);
165         quotaPolicy.limitBytes = cJSON_GetStringValue(limitBytes);
166         cJSON *lastLimitSnooze = cJSON_GetObjectItem(quotaPolicyItem, CONFIG_QUOTA_POLICY_LASTLIMITSNOOZE);
167         quotaPolicy.lastLimitSnooze = cJSON_GetStringValue(lastLimitSnooze);
168         cJSON *metered = cJSON_GetObjectItem(quotaPolicyItem, CONFIG_QUOTA_POLICY_METERED);
169         quotaPolicy.metered = cJSON_GetStringValue(metered);
170         cJSON *ident = cJSON_GetObjectItem(quotaPolicyItem, CONFIG_QUOTA_POLICY_IDENT);
171         quotaPolicy.ident = cJSON_GetStringValue(ident);
172         NETMGR_LOG_D("netType:%{public}s, simId:%{public}s, perioST:%{public}s, perioDt:%{public}s, ident:%{public}s,\
173                      warningBytes:%{public}s, limitBytes:%{public}s, lastLimitSnooze:%{public}s, metered:%{public}s",
174                      quotaPolicy.netType.c_str(), quotaPolicy.simId.c_str(), quotaPolicy.periodStartTime.c_str(),
175                      quotaPolicy.periodDuration.c_str(), quotaPolicy.ident.c_str(), quotaPolicy.warningBytes.c_str(),
176                      quotaPolicy.limitBytes.c_str(), quotaPolicy.lastLimitSnooze.c_str(), quotaPolicy.metered.c_str());
177         netPolicy.netQuotaPolicies.push_back(quotaPolicy);
178     }
179 }
180 
ParseFirewallRule(const cJSON * const root,NetPolicy & netPolicy)181 void NetPolicyFile::ParseFirewallRule(const cJSON* const root, NetPolicy &netPolicy)
182 {
183     cJSON *netFirewallRules = cJSON_GetObjectItem(root, CONFIG_FIREWALL_RULE);
184     if (netFirewallRules == nullptr) {
185         return;
186     }
187     uint32_t size = cJSON_GetArraySize(netFirewallRules);
188     for (uint32_t i = 0; i < size; i++) {
189         cJSON *firewallRulesItem = cJSON_GetArrayItem(netFirewallRules, i);
190         std::string firewallRulesItemStr = firewallRulesItem->string;
191         uint32_t chainType = CommonUtils::StrToUint(firewallRulesItemStr);
192         cJSON *netDeniedList = cJSON_GetObjectItem(firewallRulesItem, CONFIG_FIREWALL_RULE_DENIEDLIST);
193         cJSON *netAllowedList = cJSON_GetObjectItem(firewallRulesItem, CONFIG_FIREWALL_RULE_ALLOWEDLIST);
194         uint32_t itemSize = cJSON_GetArraySize(netDeniedList);
195         for (uint32_t j = 0; j < itemSize; j++) {
196             cJSON *netDeniedListItem = cJSON_GetArrayItem(netDeniedList, j);
197             std::string netDeniedListItemStr = cJSON_GetStringValue(netDeniedListItem);
198             uint32_t deniedListNumber = CommonUtils::StrToUint(netDeniedListItemStr);
199             NETMGR_LOG_D("netFirewallRules.deniedList: %{public}u", deniedListNumber);
200             netPolicy.netFirewallRules[chainType].deniedList.insert(deniedListNumber);
201         }
202         itemSize = cJSON_GetArraySize(netAllowedList);
203         for (uint32_t j = 0; j < itemSize; j++) {
204             cJSON *netAllowedListItem = cJSON_GetArrayItem(netAllowedList, j);
205             std::string netAllowedListItemStr = cJSON_GetStringValue(netAllowedListItem);
206             uint32_t allowedListNumber = CommonUtils::StrToUint(netAllowedListItemStr);
207             NETMGR_LOG_D("netFirewallRules.allowedList: %{public}u", allowedListNumber);
208             netPolicy.netFirewallRules[chainType].allowedList.insert(allowedListNumber);
209         }
210     }
211 }
212 
Json2Obj(const std::string & content,NetPolicy & netPolicy)213 bool NetPolicyFile::Json2Obj(const std::string &content, NetPolicy &netPolicy)
214 {
215     if (content.empty()) {
216         return false;
217     }
218 
219     cJSON *root = cJSON_Parse(content.c_str());
220     if (root == nullptr) {
221         return false;
222     }
223 
224     cJSON *hosVersion = cJSON_GetObjectItem(root, CONFIG_HOS_VERSION);
225     if (hosVersion == nullptr) {
226         netPolicy.hosVersion = HOS_VERSION;
227     } else {
228         netPolicy.hosVersion = cJSON_GetStringValue(hosVersion);
229         NETMGR_LOG_E("hosVersion: %{public}s", netPolicy.hosVersion.c_str());
230     }
231 
232     // parse uid policy from file
233     ParseUidPolicy(root, netPolicy);
234 
235     // parse background policy from file
236     ParseBackgroundPolicy(root, netPolicy);
237 
238     // parse quota policy from file
239     ParseQuotaPolicy(root, netPolicy);
240 
241     // parse firewall rule from file
242     ParseFirewallRule(root, netPolicy);
243 
244     cJSON_Delete(root);
245     return true;
246 }
247 
Obj2Json(const NetPolicy & netPolicy,std::string & content)248 bool NetPolicyFile::Obj2Json(const NetPolicy &netPolicy, std::string &content)
249 {
250     cJSON *root = cJSON_CreateObject();
251     if (root == nullptr) {
252         return false;
253     }
254 
255     if (netPolicy_.hosVersion.empty()) {
256         netPolicy_.hosVersion = HOS_VERSION;
257     }
258     cJSON_AddItemToObject(root, CONFIG_HOS_VERSION, cJSON_CreateString(netPolicy_.hosVersion.c_str()));
259     AddUidPolicy(root);
260     AddBackgroundPolicy(root);
261     AddQuotaPolicy(root);
262     AddFirewallRule(root);
263     char *jsonStr = cJSON_Print(root);
264     if (jsonStr == nullptr) {
265         NETMGR_LOG_E("jsonStr write fail");
266         cJSON_Delete(root);
267         return false;
268     }
269     content = jsonStr;
270     cJSON_Delete(root);
271     free(jsonStr);
272     NETMGR_LOG_D("content: %{public}s", content.c_str());
273     return true;
274 }
275 
AddQuotaPolicy(cJSON * root)276 void NetPolicyFile::AddQuotaPolicy(cJSON *root)
277 {
278     cJSON *quotaPolicy = cJSON_CreateArray();
279 
280     uint32_t size = netPolicy_.netQuotaPolicies.size();
281     for (uint32_t i = 0; i < size; i++) {
282         cJSON *quotaPolicyItem = cJSON_CreateObject();
283         cJSON_AddItemToObject(quotaPolicyItem, CONFIG_QUOTA_POLICY_NETTYPE,
284                               cJSON_CreateString(netPolicy_.netQuotaPolicies[i].netType.c_str()));
285         cJSON_AddItemToObject(quotaPolicyItem, CONFIG_QUOTA_POLICY_SUBSCRIBERID,
286                               cJSON_CreateString(netPolicy_.netQuotaPolicies[i].simId.c_str()));
287         cJSON_AddItemToObject(quotaPolicyItem, CONFIG_QUOTA_POLICY_PERIODSTARTTIME,
288                               cJSON_CreateString(netPolicy_.netQuotaPolicies[i].periodStartTime.c_str()));
289         cJSON_AddItemToObject(quotaPolicyItem, CONFIG_QUOTA_POLICY_PERIODDURATION,
290                               cJSON_CreateString(netPolicy_.netQuotaPolicies[i].periodDuration.c_str()));
291         cJSON_AddItemToObject(quotaPolicyItem, CONFIG_QUOTA_POLICY_WARNINGBYTES,
292                               cJSON_CreateString(netPolicy_.netQuotaPolicies[i].warningBytes.c_str()));
293         cJSON_AddItemToObject(quotaPolicyItem, CONFIG_QUOTA_POLICY_LIMITBYTES,
294                               cJSON_CreateString(netPolicy_.netQuotaPolicies[i].limitBytes.c_str()));
295         cJSON_AddItemToObject(quotaPolicyItem, CONFIG_QUOTA_POLICY_LASTLIMITSNOOZE,
296                               cJSON_CreateString(netPolicy_.netQuotaPolicies[i].lastLimitSnooze.c_str()));
297         cJSON_AddItemToObject(quotaPolicyItem, CONFIG_QUOTA_POLICY_METERED,
298                               cJSON_CreateString(netPolicy_.netQuotaPolicies[i].metered.c_str()));
299         cJSON_AddItemToObject(quotaPolicyItem, CONFIG_QUOTA_POLICY_IDENT,
300                               cJSON_CreateString(netPolicy_.netQuotaPolicies[i].ident.c_str()));
301         cJSON_AddItemToArray(quotaPolicy, quotaPolicyItem);
302     }
303 
304     cJSON_AddItemToObject(root, CONFIG_QUOTA_POLICY, quotaPolicy);
305 }
306 
AddUidPolicy(cJSON * root)307 void NetPolicyFile::AddUidPolicy(cJSON *root)
308 {
309     cJSON *uidPolicy = cJSON_CreateArray();
310 
311     uint32_t size = netPolicy_.uidPolicies.size();
312     for (uint32_t i = 0; i < size; i++) {
313         cJSON *uidPolicyItem = cJSON_CreateObject();
314         cJSON_AddItemToObject(uidPolicyItem, CONFIG_UID, cJSON_CreateString(netPolicy_.uidPolicies[i].uid.c_str()));
315         cJSON_AddItemToObject(uidPolicyItem, CONFIG_POLICY,
316                               cJSON_CreateString(netPolicy_.uidPolicies[i].policy.c_str()));
317         cJSON_AddItemToArray(uidPolicy, uidPolicyItem);
318     }
319 
320     cJSON_AddItemToObject(root, CONFIG_UID_POLICY, uidPolicy);
321 }
322 
AddBackgroundPolicy(cJSON * root)323 void NetPolicyFile::AddBackgroundPolicy(cJSON *root)
324 {
325     cJSON *backgroundPolicy = cJSON_CreateObject();
326 
327     if (netPolicy_.backgroundPolicyStatus.empty()) {
328         netPolicy_.backgroundPolicyStatus = BACKGROUND_POLICY_ALLOW;
329     }
330     cJSON_AddItemToObject(backgroundPolicy, CONFIG_BACKGROUND_POLICY_STATUS,
331                           cJSON_CreateString(netPolicy_.backgroundPolicyStatus.c_str()));
332     cJSON_AddItemToObject(root, CONFIG_BACKGROUND_POLICY, backgroundPolicy);
333 }
334 
AddFirewallRule(cJSON * root)335 void NetPolicyFile::AddFirewallRule(cJSON *root)
336 {
337     cJSON *firewallRuleObj = cJSON_CreateObject();
338     for (auto &&[k, v] : netPolicy_.netFirewallRules) {
339         NETMGR_LOG_D("read k[%{public}d].", k);
340         cJSON *deniedListArr = cJSON_CreateArray();
341         cJSON *allowedListArr = cJSON_CreateArray();
342         cJSON *firewallRuleItem = cJSON_CreateObject();
343         for (auto &it : v.deniedList) {
344             cJSON_AddItemToArray(deniedListArr, cJSON_CreateString(std::to_string(it).c_str()));
345         }
346         for (auto &it : v.allowedList) {
347             cJSON_AddItemToArray(allowedListArr, cJSON_CreateString(std::to_string(it).c_str()));
348         }
349         cJSON_AddItemToObject(firewallRuleItem, CONFIG_FIREWALL_RULE_DENIEDLIST, deniedListArr);
350         cJSON_AddItemToObject(firewallRuleItem, CONFIG_FIREWALL_RULE_ALLOWEDLIST, allowedListArr);
351         cJSON_AddItemToObject(firewallRuleObj, std::to_string(k).c_str(), firewallRuleItem);
352     }
353     cJSON_AddItemToObject(root, CONFIG_FIREWALL_RULE, firewallRuleObj);
354 }
355 
ArbitrationWritePolicyToFile(uint32_t uid,uint32_t policy)356 uint32_t NetPolicyFile::ArbitrationWritePolicyToFile(uint32_t uid, uint32_t policy)
357 {
358     uint32_t size = netPolicy_.uidPolicies.size();
359     bool haveUidAndPolicy = false;
360     uint32_t oldPolicy;
361     for (uint32_t i = 0; i < size; i++) {
362         auto uidTemp = CommonUtils::StrToUint(netPolicy_.uidPolicies[i].uid.c_str());
363         if (uid == uidTemp) {
364             haveUidAndPolicy = true;
365             oldPolicy = uidTemp;
366         }
367     }
368 
369     if (haveUidAndPolicy) {
370         if (oldPolicy != policy && policy == NET_POLICY_NONE) {
371             return NET_POLICY_UID_OP_TYPE_DELETE;
372         }
373 
374         if (oldPolicy != policy && policy != NET_POLICY_NONE) {
375             return NET_POLICY_UID_OP_TYPE_UPDATE;
376         }
377 
378         return NET_POLICY_UID_OP_TYPE_DO_NOTHING;
379     }
380 
381     if (policy == NET_POLICY_NONE) {
382         return NET_POLICY_UID_OP_TYPE_DO_NOTHING;
383     }
384     return NET_POLICY_UID_OP_TYPE_ADD;
385 }
386 
WritePolicyByUid(uint32_t uid,uint32_t policy)387 void NetPolicyFile::WritePolicyByUid(uint32_t uid, uint32_t policy)
388 {
389     uint32_t netUidPolicyOpType = ArbitrationWritePolicyToFile(uid, policy);
390     WritePolicyByUid(netUidPolicyOpType, uid, policy);
391 }
392 
WritePolicyByUid(uint32_t netUidPolicyOpType,uint32_t uid,uint32_t policy)393 void NetPolicyFile::WritePolicyByUid(uint32_t netUidPolicyOpType, uint32_t uid, uint32_t policy)
394 {
395     NETMGR_LOG_D("Write File start, model:[%{public}u]", netUidPolicyOpType);
396     if (netUidPolicyOpType == NetUidPolicyOpType::NET_POLICY_UID_OP_TYPE_UPDATE) {
397         for (auto &uidPolicy : netPolicy_.uidPolicies) {
398             if (uidPolicy.uid == std::to_string(uid)) {
399                 uidPolicy.policy = std::to_string(policy);
400                 break;
401             }
402         }
403     } else if (netUidPolicyOpType == NetUidPolicyOpType::NET_POLICY_UID_OP_TYPE_DELETE) {
404         for (auto iter = netPolicy_.uidPolicies.begin(); iter != netPolicy_.uidPolicies.end(); ++iter) {
405             if (iter->uid == std::to_string(uid)) {
406                 netPolicy_.uidPolicies.erase(iter);
407                 break;
408             }
409         }
410     } else if (netUidPolicyOpType == NetUidPolicyOpType::NET_POLICY_UID_OP_TYPE_ADD) {
411         UidPolicy uidPolicy;
412         uidPolicy.uid = std::to_string(uid);
413         uidPolicy.policy = std::to_string(static_cast<uint32_t>(policy));
414         netPolicy_.uidPolicies.push_back(uidPolicy);
415     } else {
416         NETMGR_LOG_D("Need to do nothing!");
417     }
418 
419     WriteFile();
420 }
421 
UpdateQuotaPolicyExist(const NetQuotaPolicy & quotaPolicy)422 bool NetPolicyFile::UpdateQuotaPolicyExist(const NetQuotaPolicy &quotaPolicy)
423 {
424     if (netPolicy_.netQuotaPolicies.empty()) {
425         NETMGR_LOG_E("UpdateQuotaPolicyExist netQuotaPolicies is empty");
426         return false;
427     }
428 
429     for (uint32_t i = 0; i < netPolicy_.netQuotaPolicies.size(); ++i) {
430         if (quotaPolicy.networkmatchrule.simId == netPolicy_.netQuotaPolicies[i].simId &&
431             netPolicy_.netQuotaPolicies[i].netType == std::to_string(quotaPolicy.networkmatchrule.netType)) {
432             netPolicy_.netQuotaPolicies[i].lastLimitSnooze = std::to_string(quotaPolicy.quotapolicy.lastLimitRemind);
433             netPolicy_.netQuotaPolicies[i].limitBytes = std::to_string(quotaPolicy.quotapolicy.limitBytes);
434             netPolicy_.netQuotaPolicies[i].metered = std::to_string(quotaPolicy.quotapolicy.metered);
435             netPolicy_.netQuotaPolicies[i].netType = std::to_string(quotaPolicy.networkmatchrule.netType);
436             netPolicy_.netQuotaPolicies[i].periodDuration = quotaPolicy.quotapolicy.periodDuration;
437             netPolicy_.netQuotaPolicies[i].periodStartTime = std::to_string(quotaPolicy.quotapolicy.periodStartTime);
438             netPolicy_.netQuotaPolicies[i].ident = quotaPolicy.networkmatchrule.ident;
439             netPolicy_.netQuotaPolicies[i].simId = quotaPolicy.networkmatchrule.simId;
440             netPolicy_.netQuotaPolicies[i].warningBytes = std::to_string(quotaPolicy.quotapolicy.warningBytes);
441             return true;
442         }
443     }
444 
445     return false;
446 }
447 
WriteQuotaPolicies(const std::vector<NetQuotaPolicy> & quotaPolicies)448 bool NetPolicyFile::WriteQuotaPolicies(const std::vector<NetQuotaPolicy> &quotaPolicies)
449 {
450     netPolicy_.netQuotaPolicies.clear();
451     uint32_t vSize = quotaPolicies.size();
452     NetPolicyQuota quotaPolicy;
453     for (uint32_t i = 0; i < vSize; i++) {
454         if (UpdateQuotaPolicyExist(quotaPolicies[i])) {
455             NETMGR_LOG_E("quotaPolicies:periodDuration[%{public}s], don't write this quotaPolicies!",
456                          quotaPolicies[i].quotapolicy.periodDuration.c_str());
457             continue;
458         }
459         quotaPolicy.lastLimitSnooze = std::to_string(quotaPolicies[i].quotapolicy.lastLimitRemind);
460         quotaPolicy.limitBytes = std::to_string(quotaPolicies[i].quotapolicy.limitBytes);
461         quotaPolicy.metered = std::to_string(quotaPolicies[i].quotapolicy.metered);
462         quotaPolicy.ident = quotaPolicies[i].networkmatchrule.ident;
463         quotaPolicy.netType = std::to_string(quotaPolicies[i].networkmatchrule.netType);
464         quotaPolicy.periodDuration = quotaPolicies[i].quotapolicy.periodDuration;
465         quotaPolicy.periodStartTime = std::to_string(quotaPolicies[i].quotapolicy.periodStartTime);
466         quotaPolicy.simId = quotaPolicies[i].networkmatchrule.simId;
467         quotaPolicy.warningBytes = std::to_string(quotaPolicies[i].quotapolicy.warningBytes);
468         netPolicy_.netQuotaPolicies.push_back(quotaPolicy);
469     }
470 
471     return WriteFile();
472 }
473 
ReadQuotaPolicies(std::vector<NetQuotaPolicy> & quotaPolicies)474 void NetPolicyFile::ReadQuotaPolicies(std::vector<NetQuotaPolicy> &quotaPolicies)
475 {
476     NetQuotaPolicy quotaPolicyTmp;
477     for (const auto &quotaPolicy : netPolicy_.netQuotaPolicies) {
478         ToQuotaPolicy(quotaPolicy, quotaPolicyTmp);
479         quotaPolicies.push_back(quotaPolicyTmp);
480     }
481 }
482 
ReadFirewallRules(uint32_t chainType,std::set<uint32_t> & allowedList,std::set<uint32_t> & deniedList)483 int32_t NetPolicyFile::ReadFirewallRules(uint32_t chainType, std::set<uint32_t> &allowedList,
484                                          std::set<uint32_t> &deniedList)
485 {
486     auto &&w = netPolicy_.netFirewallRules[chainType].allowedList;
487     auto &&b = netPolicy_.netFirewallRules[chainType].deniedList;
488     allowedList.insert(w.begin(), w.end());
489     deniedList.insert(b.begin(), b.end());
490     return NETMANAGER_SUCCESS;
491 }
492 
WriteFirewallRules(uint32_t chainType,const std::set<uint32_t> & allowedList,const std::set<uint32_t> & deniedList)493 void NetPolicyFile::WriteFirewallRules(uint32_t chainType, const std::set<uint32_t> &allowedList,
494                                        const std::set<uint32_t> &deniedList)
495 {
496     netPolicy_.netFirewallRules[chainType].allowedList.clear();
497     netPolicy_.netFirewallRules[chainType].deniedList.clear();
498     netPolicy_.netFirewallRules[chainType].allowedList.insert(allowedList.begin(), allowedList.end());
499     netPolicy_.netFirewallRules[chainType].deniedList.insert(deniedList.begin(), deniedList.end());
500     WriteFile();
501 }
502 
ResetPolicies()503 int32_t NetPolicyFile::ResetPolicies()
504 {
505     netPolicy_.uidPolicies.clear();
506     netPolicy_.backgroundPolicyStatus = BACKGROUND_POLICY_ALLOW;
507     netPolicy_.netQuotaPolicies.clear();
508     netPolicy_.netFirewallRules.clear();
509     WriteFile();
510 
511     return NETMANAGER_SUCCESS;
512 }
513 
WriteBackgroundPolicy(bool backgroundPolicy)514 void NetPolicyFile::WriteBackgroundPolicy(bool backgroundPolicy)
515 {
516     if (backgroundPolicy) {
517         netPolicy_.backgroundPolicyStatus = BACKGROUND_POLICY_ALLOW;
518     } else {
519         netPolicy_.backgroundPolicyStatus = BACKGROUND_POLICY_REJECT;
520     }
521 
522     WriteFile();
523 }
524 
ReadBackgroundPolicy()525 bool NetPolicyFile::ReadBackgroundPolicy()
526 {
527     return netPolicy_.backgroundPolicyStatus == BACKGROUND_POLICY_ALLOW;
528 }
529 
GetHandler()530 std::shared_ptr<NetPolicyFileEventHandler> NetPolicyFile::GetHandler()
531 {
532     static auto handler = [this]() -> std::shared_ptr<NetPolicyFileEventHandler> {
533         return std::make_shared<NetPolicyFileEventHandler>(NET_POLICY_WORK_THREAD);
534     }();
535     return handler;
536 }
537 
InitPolicy()538 bool NetPolicyFile::InitPolicy()
539 {
540     ResetPolicies();
541     return ReadFile();
542 }
543 
RemoveInexistentUid(uint32_t uid)544 void NetPolicyFile::RemoveInexistentUid(uint32_t uid)
545 {
546     WritePolicyByUid(NetUidPolicyOpType::NET_POLICY_UID_OP_TYPE_DELETE, uid, 0);
547 }
548 } // namespace NetManagerStandard
549 } // namespace OHOS
550