1 /*
2 * Copyright (c) 2021-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 #include "net_policy_file.h"
17
18 #include <fcntl.h>
19 #include <string>
20
21 #include <json/json.h>
22
23 #include "net_manager_center.h"
24 #include "net_mgr_log_wrapper.h"
25 #include "net_policy_inner_define.h"
26 #include "netmanager_base_common_utils.h"
27
28 namespace OHOS {
29 namespace NetManagerStandard {
30 namespace {
CheckFilePath(const std::string & fileName,std::string & realPath)31 bool CheckFilePath(const std::string &fileName, std::string &realPath)
32 {
33 char tmpPath[PATH_MAX] = {0};
34 if (!realpath(fileName.c_str(), tmpPath)) {
35 NETMGR_LOG_E("file name is illegal");
36 return false;
37 }
38 if (strcmp(tmpPath, POLICY_FILE_NAME) != 0) {
39 NETMGR_LOG_E("file path is illegal");
40 return false;
41 }
42 realPath = tmpPath;
43 return true;
44 }
45 } // namespace
46 const std::string MONTH_DEFAULT = "M1";
47
NetPolicyFile()48 NetPolicyFile::NetPolicyFile()
49 {
50 InitPolicy();
51 }
52
53 NetPolicyFile::~NetPolicyFile() = default;
54
FileExists(const std::string & fileName)55 bool NetPolicyFile::FileExists(const std::string &fileName)
56 {
57 struct stat buffer;
58 return (stat(fileName.c_str(), &buffer) == 0);
59 }
60
CreateFile(const std::string & fileName)61 bool NetPolicyFile::CreateFile(const std::string &fileName)
62 {
63 if (fileName.empty() || FileExists(fileName)) {
64 NETMGR_LOG_E("fileName empty or file exists.");
65 return false;
66 }
67 int32_t fd = open(fileName.c_str(), O_CREAT | O_WRONLY, CHOWN_RWX_USR_GRP);
68 if (fd < 0) {
69 NETMGR_LOG_E("open file error.");
70 return false;
71 }
72 close(fd);
73
74 return true;
75 }
76
GetNetPolicies()77 const std::vector<UidPolicy> &NetPolicyFile::GetNetPolicies()
78 {
79 return netPolicy_.uidPolicies;
80 }
81
ParseUidPolicy(const Json::Value & root,NetPolicy & netPolicy)82 void NetPolicyFile::ParseUidPolicy(const Json::Value &root, NetPolicy &netPolicy)
83 {
84 const Json::Value arrayUidPolicy = root[CONFIG_UID_POLICY];
85 uint32_t size = arrayUidPolicy.size();
86 UidPolicy uidPolicy;
87 for (uint32_t i = 0; i < size; i++) {
88 uidPolicy.uid = arrayUidPolicy[i][CONFIG_UID].asString();
89 uidPolicy.policy = arrayUidPolicy[i][CONFIG_POLICY].asString();
90 netPolicy.uidPolicies.push_back(uidPolicy);
91 }
92 }
93
ParseBackgroundPolicy(const Json::Value & root,NetPolicy & netPolicy)94 void NetPolicyFile::ParseBackgroundPolicy(const Json::Value &root, NetPolicy &netPolicy)
95 {
96 const Json::Value mapBackgroundPolicy = root[CONFIG_BACKGROUND_POLICY];
97 netPolicy.backgroundPolicyStatus = mapBackgroundPolicy[CONFIG_BACKGROUND_POLICY_STATUS].asString();
98 }
99
ParseQuotaPolicy(const Json::Value & root,NetPolicy & netPolicy)100 void NetPolicyFile::ParseQuotaPolicy(const Json::Value &root, NetPolicy &netPolicy)
101 {
102 const Json::Value arrayQuotaPolicy = root[CONFIG_QUOTA_POLICY];
103 uint32_t size = arrayQuotaPolicy.size();
104 NetPolicyQuota quotaPolicy;
105 for (uint32_t i = 0; i < size; i++) {
106 quotaPolicy.netType = arrayQuotaPolicy[i][CONFIG_QUOTA_POLICY_NETTYPE].asString();
107 quotaPolicy.iccid = arrayQuotaPolicy[i][CONFIG_QUOTA_POLICY_SUBSCRIBERID].asString();
108 quotaPolicy.periodStartTime = arrayQuotaPolicy[i][CONFIG_QUOTA_POLICY_PERIODSTARTTIME].asString();
109 quotaPolicy.periodDuration = arrayQuotaPolicy[i][CONFIG_QUOTA_POLICY_PERIODDURATION].asString();
110 quotaPolicy.warningBytes = arrayQuotaPolicy[i][CONFIG_QUOTA_POLICY_WARNINGBYTES].asString();
111 quotaPolicy.limitBytes = arrayQuotaPolicy[i][CONFIG_QUOTA_POLICY_LIMITBYTES].asString();
112 quotaPolicy.lastLimitSnooze = arrayQuotaPolicy[i][CONFIG_QUOTA_POLICY_LASTLIMITSNOOZE].asString();
113 quotaPolicy.metered = arrayQuotaPolicy[i][CONFIG_QUOTA_POLICY_METERED].asString();
114 quotaPolicy.source = arrayQuotaPolicy[i][CONFIG_QUOTA_POLICY_SOURCE].asString();
115 netPolicy.netQuotaPolicies.push_back(quotaPolicy);
116 }
117 }
118
ParseCellularPolicy(const Json::Value & root,NetPolicy & netPolicy)119 void NetPolicyFile::ParseCellularPolicy(const Json::Value &root, NetPolicy &netPolicy)
120 {
121 const Json::Value arrayCellularPolicy = root[CONFIG_CELLULAR_POLICY];
122 uint32_t size = arrayCellularPolicy.size();
123 NetPolicyCellular cellularPolicy;
124 for (uint32_t i = 0; i < size; i++) {
125 cellularPolicy.iccid = arrayCellularPolicy[i][CONFIG_CELLULAR_POLICY_SUBSCRIBERID].asString();
126 cellularPolicy.periodStartTime = arrayCellularPolicy[i][CONFIG_CELLULAR_POLICY_PERIODSTARTTIME].asString();
127 cellularPolicy.periodDuration = arrayCellularPolicy[i][CONFIG_CELLULAR_POLICY_PERIODDURATION].asString();
128 cellularPolicy.title = arrayCellularPolicy[i][CONFIG_CELLULAR_POLICY_TITLE].asString();
129 cellularPolicy.summary = arrayCellularPolicy[i][CONFIG_CELLULAR_POLICY_SUMMARY].asString();
130 cellularPolicy.limitBytes = arrayCellularPolicy[i][CONFIG_CELLULAR_POLICY_LIMITBYTES].asString();
131 cellularPolicy.limitAction = arrayCellularPolicy[i][CONFIG_CELLULAR_POLICY_LIMITACTION].asString();
132 cellularPolicy.usedBytes = arrayCellularPolicy[i][CONFIG_CELLULAR_POLICY_USEDBYTES].asString();
133 cellularPolicy.usedTimeDuration = arrayCellularPolicy[i][CONFIG_CELLULAR_POLICY_USEDTIMEDURATION].asString();
134 cellularPolicy.possessor = arrayCellularPolicy[i][CONFIG_CELLULAR_POLICY_POSSESSOR].asString();
135 }
136 }
137
Json2Obj(const std::string & content,NetPolicy & netPolicy)138 bool NetPolicyFile::Json2Obj(const std::string &content, NetPolicy &netPolicy)
139 {
140 if (content.empty()) {
141 return false;
142 }
143
144 Json::Value root;
145 Json::CharReaderBuilder builder;
146 std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
147 JSONCPP_STRING errs;
148
149 bool isSuccess = reader->parse(content.c_str(), content.c_str() + content.length(), &root, &errs);
150 if (isSuccess && errs.size() == 0) {
151 netPolicy.hosVersion = root[CONFIG_HOS_VERSION].asString();
152 if (netPolicy.hosVersion.empty()) {
153 netPolicy.hosVersion = HOS_VERSION;
154 }
155 // parse uid policy from file
156 ParseUidPolicy(root, netPolicy);
157 // parse background policy from file
158 ParseBackgroundPolicy(root, netPolicy);
159 // parse quota policy from file
160 ParseQuotaPolicy(root, netPolicy);
161 // parse cellular policy from file
162 ParseCellularPolicy(root, netPolicy);
163 }
164
165 return true;
166 }
167
ReadFile(const std::string & fileName,std::string & fileContent)168 bool NetPolicyFile::ReadFile(const std::string &fileName, std::string &fileContent)
169 {
170 std::unique_lock<std::mutex> lock(mutex_);
171 if (fileName.empty()) {
172 NETMGR_LOG_E("fileName empty.");
173 return false;
174 }
175
176 if (!FileExists(fileName)) {
177 NETMGR_LOG_E("[%{public}s] not exist.", fileName.c_str());
178 return false;
179 }
180 std::string realPath;
181 if (!CheckFilePath(fileName, realPath)) {
182 NETMGR_LOG_E("file does not exist! ");
183 return false;
184 }
185 std::fstream file(realPath.c_str(), std::fstream::in);
186 if (file.is_open() == false) {
187 NETMGR_LOG_E("fstream failed.");
188 return false;
189 }
190
191 std::stringstream buffer;
192 buffer << file.rdbuf();
193 fileContent = buffer.str();
194 file.close();
195
196 return true;
197 }
198
AppendQuotaPolicy(Json::Value & root)199 void NetPolicyFile::AppendQuotaPolicy(Json::Value &root)
200 {
201 uint32_t size = netPolicy_.netQuotaPolicies.size();
202 for (uint32_t i = 0; i < size; i++) {
203 Json::Value quotaPolicy;
204 quotaPolicy[CONFIG_QUOTA_POLICY_NETTYPE] = netPolicy_.netQuotaPolicies[i].netType;
205 quotaPolicy[CONFIG_QUOTA_POLICY_SUBSCRIBERID] = netPolicy_.netQuotaPolicies[i].iccid;
206 quotaPolicy[CONFIG_QUOTA_POLICY_PERIODSTARTTIME] = netPolicy_.netQuotaPolicies[i].periodStartTime;
207 quotaPolicy[CONFIG_QUOTA_POLICY_PERIODDURATION] = netPolicy_.netQuotaPolicies[i].periodDuration;
208 quotaPolicy[CONFIG_QUOTA_POLICY_WARNINGBYTES] = netPolicy_.netQuotaPolicies[i].warningBytes;
209 quotaPolicy[CONFIG_QUOTA_POLICY_LIMITBYTES] = netPolicy_.netQuotaPolicies[i].limitBytes;
210 quotaPolicy[CONFIG_QUOTA_POLICY_LASTLIMITSNOOZE] = netPolicy_.netQuotaPolicies[i].lastLimitSnooze;
211 quotaPolicy[CONFIG_QUOTA_POLICY_METERED] = netPolicy_.netQuotaPolicies[i].metered;
212 quotaPolicy[CONFIG_QUOTA_POLICY_SOURCE] = netPolicy_.netQuotaPolicies[i].source;
213 root[CONFIG_QUOTA_POLICY].append(quotaPolicy);
214 }
215 }
216
AppendUidPolicy(Json::Value & root)217 void NetPolicyFile::AppendUidPolicy(Json::Value &root)
218 {
219 uint32_t size = netPolicy_.uidPolicies.size();
220 for (uint32_t i = 0; i < size; i++) {
221 Json::Value uidPolicy;
222 uidPolicy[CONFIG_UID] = netPolicy_.uidPolicies[i].uid;
223 uidPolicy[CONFIG_POLICY] = netPolicy_.uidPolicies[i].policy;
224 root[CONFIG_UID_POLICY].append(uidPolicy);
225 }
226 }
227
AppendBackgroundPolicy(Json::Value & root)228 void NetPolicyFile::AppendBackgroundPolicy(Json::Value &root)
229 {
230 Json::Value backgroundPolicy;
231 if (netPolicy_.backgroundPolicyStatus.empty()) {
232 netPolicy_.backgroundPolicyStatus = BACKGROUND_POLICY_ALLOW;
233 }
234 backgroundPolicy[CONFIG_BACKGROUND_POLICY_STATUS] = netPolicy_.backgroundPolicyStatus;
235 root[CONFIG_BACKGROUND_POLICY] = backgroundPolicy;
236 }
237
ArbitrationWritePolicyToFile(uint32_t uid,uint32_t policy)238 uint32_t NetPolicyFile::ArbitrationWritePolicyToFile(uint32_t uid, uint32_t policy)
239 {
240 uint32_t size = netPolicy_.uidPolicies.size();
241 bool haveUidAndPolicy = false;
242 uint32_t oldPolicy;
243 for (uint32_t i = 0; i < size; i++) {
244 auto uidTemp = CommonUtils::StrToUint(netPolicy_.uidPolicies[i].uid.c_str());
245 if (uid == uidTemp) {
246 haveUidAndPolicy = true;
247 oldPolicy = uidTemp;
248 }
249 }
250
251 if (haveUidAndPolicy) {
252 if (oldPolicy != policy && policy == NET_POLICY_NONE) {
253 return NET_POLICY_UID_OP_TYPE_DELETE;
254 }
255
256 if (oldPolicy != policy && policy != NET_POLICY_NONE) {
257 return NET_POLICY_UID_OP_TYPE_UPDATE;
258 }
259
260 return NET_POLICY_UID_OP_TYPE_DO_NOTHING;
261 }
262
263 if (policy == NET_POLICY_NONE) {
264 return NET_POLICY_UID_OP_TYPE_DO_NOTHING;
265 }
266 return NET_POLICY_UID_OP_TYPE_ADD;
267 }
268
WriteFile(uint32_t uid,uint32_t policy)269 void NetPolicyFile::WriteFile(uint32_t uid, uint32_t policy)
270 {
271 uint32_t netUidPolicyOpType = ArbitrationWritePolicyToFile(uid, policy);
272 WriteFile(netUidPolicyOpType, uid, policy);
273 return;
274 }
275
WriteFile(const std::string & fileName)276 bool NetPolicyFile::WriteFile(const std::string &fileName)
277 {
278 std::unique_lock<std::mutex> lock(mutex_);
279 if (fileName.empty()) {
280 NETMGR_LOG_E("fileName is empty.");
281 return false;
282 }
283 Json::Value root;
284 Json::StreamWriterBuilder builder;
285 std::unique_ptr<Json::StreamWriter> streamWriter(builder.newStreamWriter());
286 std::fstream file(fileName.c_str(), std::fstream::out);
287 if (file.is_open() == false) {
288 NETMGR_LOG_E("fstream failed.");
289 return false;
290 }
291
292 if (netPolicy_.hosVersion.empty()) {
293 netPolicy_.hosVersion = HOS_VERSION;
294 }
295
296 root[CONFIG_HOS_VERSION] = Json::Value(netPolicy_.hosVersion);
297 // uid policy
298 AppendUidPolicy(root);
299 // background policy
300 AppendBackgroundPolicy(root);
301 // quota policy
302 AppendQuotaPolicy(root);
303 std::ostringstream out;
304 streamWriter->write(root, &out);
305 file << out.str().c_str();
306 file.close();
307
308 return true;
309 }
310
WriteFile(uint32_t netUidPolicyOpType,uint32_t uid,uint32_t policy)311 bool NetPolicyFile::WriteFile(uint32_t netUidPolicyOpType, uint32_t uid, uint32_t policy)
312 {
313 NETMGR_LOG_D("Write File start, model:[%{public}u]", netUidPolicyOpType);
314
315 for (const auto &i : netPolicy_.uidPolicies) {
316 uint32_t uid = CommonUtils::StrToUint(i.uid.c_str());
317 uint32_t policy = CommonUtils::StrToUint(i.policy.c_str());
318 NETMGR_LOG_D("Struct:uid[%{public}u],policy[%{public}u]", uid, policy);
319 }
320
321 if (netUidPolicyOpType == NetUidPolicyOpType::NET_POLICY_UID_OP_TYPE_UPDATE) {
322 for (auto &uidPolicy : netPolicy_.uidPolicies) {
323 if (uidPolicy.uid == std::to_string(uid)) {
324 uidPolicy.policy = std::to_string(policy);
325 break;
326 }
327 }
328 } else if (netUidPolicyOpType == NetUidPolicyOpType::NET_POLICY_UID_OP_TYPE_DELETE) {
329 for (auto iter = netPolicy_.uidPolicies.begin(); iter != netPolicy_.uidPolicies.end(); ++iter) {
330 if (iter->uid == std::to_string(uid)) {
331 netPolicy_.uidPolicies.erase(iter);
332 break;
333 }
334 }
335 } else if (netUidPolicyOpType == NetUidPolicyOpType::NET_POLICY_UID_OP_TYPE_ADD) {
336 UidPolicy uidPolicy;
337 uidPolicy.uid = std::to_string(uid);
338 uidPolicy.policy = std::to_string(static_cast<uint32_t>(policy));
339 netPolicy_.uidPolicies.push_back(uidPolicy);
340 } else {
341 NETMGR_LOG_I("Need to do nothing!");
342 }
343
344 if (!WriteFile(POLICY_FILE_NAME)) {
345 NETMGR_LOG_E("WriteFile failed");
346 return false;
347 }
348
349 return true;
350 }
351
UpdateQuotaPolicyExist(const NetQuotaPolicy & quotaPolicy)352 bool NetPolicyFile::UpdateQuotaPolicyExist(const NetQuotaPolicy "aPolicy)
353 {
354 if (netPolicy_.netQuotaPolicies.empty()) {
355 NETMGR_LOG_E("UpdateQuotaPolicyExist netQuotaPolicies is empty");
356 return false;
357 }
358
359 for (uint32_t i = 0; i < netPolicy_.netQuotaPolicies.size(); ++i) {
360 if (quotaPolicy.iccid == netPolicy_.netQuotaPolicies[i].iccid &&
361 netPolicy_.netQuotaPolicies[i].netType == std::to_string(quotaPolicy.netType)) {
362 netPolicy_.netQuotaPolicies[i].lastLimitSnooze = std::to_string(quotaPolicy.lastLimitRemind);
363 netPolicy_.netQuotaPolicies[i].limitBytes = std::to_string(quotaPolicy.limitBytes);
364 netPolicy_.netQuotaPolicies[i].metered = std::to_string(quotaPolicy.metered);
365 netPolicy_.netQuotaPolicies[i].netType = std::to_string(quotaPolicy.netType);
366 netPolicy_.netQuotaPolicies[i].periodDuration = quotaPolicy.periodDuration;
367 netPolicy_.netQuotaPolicies[i].periodStartTime = std::to_string(quotaPolicy.periodStartTime);
368 netPolicy_.netQuotaPolicies[i].source = std::to_string(quotaPolicy.source);
369 netPolicy_.netQuotaPolicies[i].iccid = quotaPolicy.iccid;
370 netPolicy_.netQuotaPolicies[i].warningBytes = std::to_string(quotaPolicy.warningBytes);
371 return true;
372 }
373 }
374
375 return false;
376 }
377
WriteFile(const std::vector<NetQuotaPolicy> & quotaPolicies)378 bool NetPolicyFile::WriteFile(const std::vector<NetQuotaPolicy> "aPolicies)
379 {
380 netPolicy_.netQuotaPolicies.clear();
381 uint32_t vSize = quotaPolicies.size();
382 NetPolicyQuota quotaPolicy;
383 for (uint32_t i = 0; i < vSize; i++) {
384 if (UpdateQuotaPolicyExist(quotaPolicies[i])) {
385 NETMGR_LOG_E("quotaPolicies:periodDuration[%{public}s, don't write this quotaPolicies!]",
386 quotaPolicies[i].periodDuration.c_str());
387 continue;
388 }
389 quotaPolicy.lastLimitSnooze = std::to_string(quotaPolicies[i].lastLimitRemind);
390 quotaPolicy.limitBytes = std::to_string(quotaPolicies[i].limitBytes);
391 quotaPolicy.metered = std::to_string(quotaPolicies[i].metered);
392 quotaPolicy.netType = std::to_string(quotaPolicies[i].netType);
393 quotaPolicy.periodDuration = quotaPolicies[i].periodDuration;
394 quotaPolicy.periodStartTime = std::to_string(quotaPolicies[i].periodStartTime);
395 quotaPolicy.iccid = quotaPolicies[i].iccid;
396 quotaPolicy.warningBytes = std::to_string(quotaPolicies[i].warningBytes);
397 netPolicy_.netQuotaPolicies.push_back(quotaPolicy);
398 }
399
400 if (!WriteFile(POLICY_FILE_NAME)) {
401 NETMGR_LOG_E("WriteFile failed");
402 return false;
403 }
404
405 return true;
406 }
407
IsUidPolicyExist(uint32_t uid)408 bool NetPolicyFile::IsUidPolicyExist(uint32_t uid)
409 {
410 uint32_t size = netPolicy_.uidPolicies.size();
411 for (uint32_t i = 0; i < size; i++) {
412 if (CommonUtils::StrToUint(netPolicy_.uidPolicies[i].uid) == uid) {
413 return true;
414 }
415 }
416
417 return false;
418 }
419
GetPolicyByUid(uint32_t uid)420 NetUidPolicy NetPolicyFile::GetPolicyByUid(uint32_t uid)
421 {
422 for (auto &uidPolicy : netPolicy_.uidPolicies) {
423 if (uidPolicy.uid == std::to_string(uid)) {
424 return static_cast<NetUidPolicy>(CommonUtils::StrToUint(uidPolicy.policy));
425 }
426 }
427
428 return NetUidPolicy::NET_POLICY_NONE;
429 }
430
GetUidsByPolicy(uint32_t policy,std::vector<uint32_t> & uids)431 bool NetPolicyFile::GetUidsByPolicy(uint32_t policy, std::vector<uint32_t> &uids)
432 {
433 for (auto &uidPolicy : netPolicy_.uidPolicies) {
434 if (uidPolicy.policy == std::to_string(policy)) {
435 uint32_t uid = CommonUtils::StrToUint(uidPolicy.uid);
436 uids.push_back(uid);
437 }
438 }
439 return uids.size() > 0;
440 }
441
ReadQuotaPolicies(std::vector<NetQuotaPolicy> & quotaPolicies)442 int32_t NetPolicyFile::ReadQuotaPolicies(std::vector<NetQuotaPolicy> "aPolicies)
443 {
444 NetQuotaPolicy quotaPolicyTmp;
445 for (auto "aPolicy : netPolicy_.netQuotaPolicies) {
446 quotaPolicyTmp.lastLimitRemind = CommonUtils::StrToLong(quotaPolicy.lastLimitSnooze);
447 quotaPolicyTmp.limitBytes = CommonUtils::StrToLong(quotaPolicy.limitBytes);
448 quotaPolicyTmp.metered = CommonUtils::StrToBool(quotaPolicy.metered);
449 quotaPolicyTmp.netType = CommonUtils::StrToInt(quotaPolicy.netType);
450 quotaPolicyTmp.periodDuration = quotaPolicy.periodDuration;
451 quotaPolicyTmp.periodStartTime = CommonUtils::StrToLong(quotaPolicy.periodStartTime);
452 quotaPolicyTmp.source = CommonUtils::StrToInt(quotaPolicy.source);
453 quotaPolicyTmp.iccid = quotaPolicy.iccid;
454 quotaPolicyTmp.warningBytes = CommonUtils::StrToLong(quotaPolicy.warningBytes);
455 quotaPolicies.push_back(quotaPolicyTmp);
456 }
457
458 return NETMANAGER_SUCCESS;
459 }
460
GetNetQuotaPolicy(int32_t netType,const std::string & iccid,NetQuotaPolicy & quotaPolicy)461 int32_t NetPolicyFile::GetNetQuotaPolicy(int32_t netType, const std::string &iccid, NetQuotaPolicy "aPolicy)
462 {
463 for (const auto "aPolicyTemp : netPolicy_.netQuotaPolicies) {
464 if (netType == CommonUtils::StrToInt(quotaPolicyTemp.netType) && iccid == quotaPolicyTemp.iccid) {
465 quotaPolicy.lastLimitRemind = CommonUtils::StrToLong(quotaPolicyTemp.lastLimitSnooze);
466 quotaPolicy.limitBytes = CommonUtils::StrToLong(quotaPolicyTemp.limitBytes);
467 quotaPolicy.metered = CommonUtils::StrToBool(quotaPolicyTemp.metered);
468 quotaPolicy.netType = CommonUtils::StrToInt(quotaPolicyTemp.netType);
469 quotaPolicy.periodDuration = quotaPolicyTemp.periodDuration;
470 quotaPolicy.periodStartTime = CommonUtils::StrToLong(quotaPolicyTemp.periodStartTime);
471 quotaPolicy.source = CommonUtils::StrToInt(quotaPolicyTemp.source);
472 quotaPolicy.iccid = quotaPolicyTemp.iccid;
473 quotaPolicy.warningBytes = CommonUtils::StrToLong(quotaPolicyTemp.warningBytes);
474 return NETMANAGER_SUCCESS;
475 }
476 }
477
478 return POLICY_ERR_QUOTA_POLICY_NOT_EXIST;
479 }
480
ResetPolicies(const std::string & iccid)481 int32_t NetPolicyFile::ResetPolicies(const std::string &iccid)
482 {
483 netPolicy_.uidPolicies.clear();
484 netPolicy_.backgroundPolicyStatus = BACKGROUND_POLICY_ALLOW;
485
486 if (iccid.empty()) {
487 netPolicy_.netQuotaPolicies.clear();
488 } else {
489 for (auto iter = netPolicy_.netQuotaPolicies.begin(); iter != netPolicy_.netQuotaPolicies.end(); ++iter) {
490 if (iccid == iter->iccid) {
491 netPolicy_.netQuotaPolicies.erase(iter);
492 break;
493 }
494 }
495 }
496
497 if (!WriteFile(POLICY_FILE_NAME)) {
498 NETMGR_LOG_E("WriteFile failed");
499 return NETMANAGER_ERR_WRITE_DATA_FAIL;
500 }
501
502 return NETMANAGER_SUCCESS;
503 }
504
SetBackgroundPolicy(bool backgroundPolicy)505 int32_t NetPolicyFile::SetBackgroundPolicy(bool backgroundPolicy)
506 {
507 if (backgroundPolicy) {
508 netPolicy_.backgroundPolicyStatus = BACKGROUND_POLICY_ALLOW;
509 } else {
510 netPolicy_.backgroundPolicyStatus = BACKGROUND_POLICY_REJECT;
511 }
512
513 if (!WriteFile(POLICY_FILE_NAME)) {
514 NETMGR_LOG_E("WriteFile failed");
515 return NETMANAGER_ERR_WRITE_DATA_FAIL;
516 }
517
518 return NETMANAGER_SUCCESS;
519 }
520
GetBackgroundPolicy()521 bool NetPolicyFile::GetBackgroundPolicy()
522 {
523 if (netPolicy_.backgroundPolicyStatus == BACKGROUND_POLICY_ALLOW) {
524 return true;
525 }
526 return false;
527 }
528
InitPolicy()529 bool NetPolicyFile::InitPolicy()
530 {
531 NETMGR_LOG_I("InitPolicyFile.");
532 std::string content;
533 if (!ReadFile(POLICY_FILE_NAME, content)) {
534 if (!CreateFile(POLICY_FILE_NAME)) {
535 NETMGR_LOG_D("CreateFile [%{public}s] failed", POLICY_FILE_NAME);
536 return false;
537 }
538 }
539
540 if (!content.empty() && !Json2Obj(content, netPolicy_)) {
541 NETMGR_LOG_E("Analysis fileconfig failed");
542 return false;
543 }
544 return true;
545 }
546 } // namespace NetManagerStandard
547 } // namespace OHOS
548