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