1 /*
2  * Copyright (C) 2021 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 "parser_util.h"
17 
18 #include <cstdio>
19 #include <securec.h>
20 #include <unistd.h>
21 
22 #include <fstream>
23 #include <iostream>
24 #include <zlib.h>
25 #include "climits"
26 #include "config_policy_utils.h"
27 #include "cstdint"
28 #include "cstdio"
29 #include "cstdlib"
30 #include "cstring"
31 #include "core_service_client.h"
32 #include "data_storage_errors.h"
33 #include "data_storage_log_wrapper.h"
34 #include "global_params_data.h"
35 #include "memory"
36 #include "new"
37 #include "opkey_data.h"
38 #include "parameters.h"
39 #include "pdp_profile_data.h"
40 #include "telephony_types.h"
41 #include "values_bucket.h"
42 #include "vector"
43 #include "preferences_util.h"
44 
45 namespace OHOS {
46 namespace Telephony {
47 const char *PATH = "/etc/telephony/pdp_profile.json";
48 const char *ITEM_OPERATOR_INFOS = "operator_infos";
49 const char *ITEM_OPERATOR_NAME = "operator_name";
50 const char *ITEM_AUTH_USER = "auth_user";
51 const char *ITEM_AUTH_PWD = "auth_pwd";
52 const char *ITEM_AUTH_TYPE = "auth_type";
53 const char *ITEM_MCC = "mcc";
54 const char *ITEM_MNC = "mnc";
55 const char *ITEM_APN = "apn";
56 const char *ITEM_APN_TYPES = "apn_types";
57 const char *ITEM_IP_ADDRESS = "ip_addr";
58 const char *ITEM_MMS_IP_ADDRESS = "mms_ip_addr";
59 const char *ITEM_HOME_URL = "home_url";
60 const char *ITEM_MVNO_TYPE = "mvno_type";
61 const char *ITEM_MVNO_MATCH_DATA = "mvno_match_data";
62 const char *ITEM_EDITED_STATUS = "edited";
63 const char *ITEM_SERVER = "server";
64 const char *ITEM_BEARER = "bearing_system_type";
65 const char *ITEM_IS_ROAMING_APN = "is_roaming_apn";
66 const char *ITEM_APN_PROTOCOL = "apn_protocol";
67 const char *ITEM_ROAMING_PROTOCOL = "apn_roam_protocol";
68 const char *APN_VERSION = "apn_version";
69 const char *OPKEY_INFO_PATH = "etc/telephony/OpkeyInfo.json";
70 const char *ITEM_OPERATOR_ID = "operator_id";
71 const char *ITEM_RULE = "rule";
72 const char *ITEM_MCCMNC = "mcc_mnc";
73 const char *ITEM_GID_ONE = "gid1";
74 const char *ITEM_GID_TWO = "gid2";
75 const char *ITEM_IMSI = "imsi";
76 const char *ITEM_SPN = "spn";
77 const char *ITEM_ICCID = "iccid";
78 const char *ITEM_OPERATOR_NAME_OPKEY = "operator_name";
79 const char *ITEM_OPERATOR_KEY = "operator_key";
80 const char *ITEM_OPERATOR_KEY_EXT = "operator_key_ext";
81 const char *NUM_MATCH_PATH = "etc/telephony/number_match.json";
82 const char *ECC_DATA_PATH = "etc/telephony/ecc_data.json";
83 const char *ITEM_NUM_MATCH_INFOS = "numMatchs";
84 const char *ITEM_NAME = "name";
85 const char *ITEM_NUM_MATCH = "num_match";
86 const char *ITEM_NUM_MATCH_SHORT = "num_match_short";
87 const char *ITEM_NUMERIC = "numeric";
88 const char *ITEM_ECC_WITH_CARD = "ecc_withcard";
89 const char *ITEM_ECC_NO_CARD = "ecc_nocard";
90 const char *ITEM_ECC_FAKE = "ecc_fake";
91 const int BYTE_LEN = 1024 * 1024;
92 const int MAX_BYTE_LEN = 10 * 1024 * 1024;
93 static constexpr const char *CUST_RULE_PATH_KEY = "const.telephony.rule_path";
94 static constexpr const char *CUST_NETWORK_PATH_KEY = "const.telephony.network_path";
95 const std::string DEFAULT_PREFERENCES_STRING_VALUE = "default_value";
96 const std::string TEMP_SUFFIX = "_temp";
97 
ParserPdpProfileJson(std::vector<PdpProfile> & vec)98 int ParserUtil::ParserPdpProfileJson(std::vector<PdpProfile> &vec)
99 {
100     char buf[MAX_PATH_LEN];
101     char *path = GetOneCfgFile(PATH, buf, MAX_PATH_LEN);
102     return ParserPdpProfileJson(vec, path);
103 }
104 
ParserPdpProfileJson(std::vector<PdpProfile> & vec,const char * path)105 int ParserUtil::ParserPdpProfileJson(std::vector<PdpProfile> &vec, const char *path)
106 {
107     char *content = nullptr;
108     int ret = DATA_STORAGE_SUCCESS;
109     if (path && *path != '\0') {
110         ret = LoaderJsonFile(content, path);
111     }
112     if (ret != DATA_STORAGE_SUCCESS) {
113         DATA_STORAGE_LOGE("ParserUtil::ParserPdpProfileJson LoaderJsonFile is fail!");
114         return ret;
115     }
116     if (content == nullptr) {
117         DATA_STORAGE_LOGE("ParserUtil::content is nullptr!");
118         return static_cast<int>(LoadProFileErrorType::FILE_PARSER_ERROR);
119     }
120 
121     cJSON *root = cJSON_Parse(content);
122     free(content);
123     content = nullptr;
124     if (root == nullptr) {
125         DATA_STORAGE_LOGE("ParserUtil::ParserPdpProfileJson root is error!");
126         return static_cast<int>(LoadProFileErrorType::FILE_PARSER_ERROR);
127     }
128 
129     cJSON *itemRoots = cJSON_GetObjectItem(root, ITEM_OPERATOR_INFOS);
130     if (itemRoots == nullptr || !cJSON_IsArray(itemRoots) || cJSON_GetArraySize(itemRoots) <= 0) {
131         DATA_STORAGE_LOGE("ParserUtil::ParserPdpProfileJson itemRoots size == 0!");
132         cJSON_Delete(root);
133         itemRoots = nullptr;
134         root = nullptr;
135         return static_cast<int>(LoadProFileErrorType::ITEM_SIZE_IS_NULL);
136     }
137     ParserPdpProfileInfos(vec, itemRoots);
138     cJSON_Delete(root);
139     itemRoots = nullptr;
140     root = nullptr;
141     return DATA_STORAGE_SUCCESS;
142 }
143 
ParserPdpProfileInfos(std::vector<PdpProfile> & vec,cJSON * itemRoots)144 void ParserUtil::ParserPdpProfileInfos(std::vector<PdpProfile> &vec, cJSON *itemRoots)
145 {
146     cJSON *itemRoot = nullptr;
147     for (int32_t i = 0; i < cJSON_GetArraySize(itemRoots); i++) {
148         itemRoot = cJSON_GetArrayItem(itemRoots, i);
149         if (itemRoot == nullptr || !IsNeedInsertToTable(itemRoot)) {
150             continue;
151         }
152         PdpProfile bean;
153         bean.profileName = ParseString(cJSON_GetObjectItem(itemRoot, ITEM_OPERATOR_NAME));
154         bean.authUser = ParseString(cJSON_GetObjectItem(itemRoot, ITEM_AUTH_USER));
155         bean.authPwd = ParseString(cJSON_GetObjectItem(itemRoot, ITEM_AUTH_PWD));
156         std::string authTypeStr = ParseString(cJSON_GetObjectItem(itemRoot, ITEM_AUTH_TYPE));
157         bean.authType = authTypeStr.empty() ? 0 : atoi(authTypeStr.c_str());
158         bean.mcc = ParseString(cJSON_GetObjectItem(itemRoot, ITEM_MCC));
159         bean.mnc = ParseString(cJSON_GetObjectItem(itemRoot, ITEM_MNC));
160         bean.apn = ParseString(cJSON_GetObjectItem(itemRoot, ITEM_APN));
161         bean.apnTypes = ParseString(cJSON_GetObjectItem(itemRoot, ITEM_APN_TYPES));
162         bean.mmsIpAddress = ParseString(cJSON_GetObjectItem(itemRoot, ITEM_MMS_IP_ADDRESS));
163         bean.proxyIpAddress = ParseString(cJSON_GetObjectItem(itemRoot, ITEM_IP_ADDRESS));
164         bean.homeUrl = ParseString(cJSON_GetObjectItem(itemRoot, ITEM_HOME_URL));
165         bean.mvnoType = ParseString(cJSON_GetObjectItem(itemRoot, ITEM_MVNO_TYPE));
166         bean.mvnoMatchData = ParseString(cJSON_GetObjectItem(itemRoot, ITEM_MVNO_MATCH_DATA));
167         bean.server = ParseString(cJSON_GetObjectItem(itemRoot, ITEM_SERVER));
168         std::string editedStr = ParseString(cJSON_GetObjectItem(itemRoot, ITEM_EDITED_STATUS));
169         bean.edited = editedStr.empty() ? 0 : atoi(editedStr.c_str());
170         std::string bearingStr = ParseString(cJSON_GetObjectItem(itemRoot, ITEM_BEARER));
171         bean.bearingSystemType = bearingStr.empty() ? 0 : atoi(bearingStr.c_str());
172         std::string isRoamingApnStr = ParseString(cJSON_GetObjectItem(itemRoot, ITEM_IS_ROAMING_APN));
173         bean.isRoamingApn = isRoamingApnStr.empty() ? 0 : atoi(isRoamingApnStr.c_str());
174         std::string pdpProtocolStr = ParseString(cJSON_GetObjectItem(itemRoot, ITEM_APN_PROTOCOL));
175         bean.pdpProtocol = pdpProtocolStr.empty() ? "IP" : pdpProtocolStr;
176         std::string roamPdpProtocolStr = ParseString(cJSON_GetObjectItem(itemRoot, ITEM_ROAMING_PROTOCOL));
177         bean.roamPdpProtocol = roamPdpProtocolStr.empty() ? "IP" : roamPdpProtocolStr;
178         vec.push_back(bean);
179     }
180     itemRoot = nullptr;
181 }
182 
ParseString(const cJSON * value)183 std::string ParserUtil::ParseString(const cJSON *value)
184 {
185     if (value != nullptr && value->type == cJSON_String && value->valuestring != nullptr) {
186         return value->valuestring;
187     }
188     return "";
189 }
190 
ParserPdpProfileToValuesBucket(NativeRdb::ValuesBucket & value,const PdpProfile & bean)191 void ParserUtil::ParserPdpProfileToValuesBucket(NativeRdb::ValuesBucket &value, const PdpProfile &bean)
192 {
193     value.PutString(PdpProfileData::PROFILE_NAME, bean.profileName);
194     value.PutString(PdpProfileData::MCC, bean.mcc);
195     value.PutString(PdpProfileData::MNC, bean.mnc);
196     std::string mccmnc(bean.mcc);
197     mccmnc.append(bean.mnc);
198     value.PutString(PdpProfileData::MCCMNC, mccmnc);
199     value.PutString(PdpProfileData::APN, bean.apn);
200     value.PutInt(PdpProfileData::AUTH_TYPE, bean.authType);
201     value.PutString(PdpProfileData::AUTH_USER, bean.authUser);
202     value.PutString(PdpProfileData::AUTH_PWD, bean.authPwd);
203     value.PutString(PdpProfileData::APN_TYPES, bean.apnTypes);
204     value.PutBool(PdpProfileData::IS_ROAMING_APN, bean.isRoamingApn);
205     value.PutString(PdpProfileData::HOME_URL, bean.homeUrl);
206     value.PutString(PdpProfileData::PROXY_IP_ADDRESS, bean.proxyIpAddress);
207     value.PutString(PdpProfileData::MMS_IP_ADDRESS, bean.mmsIpAddress);
208     value.PutString(PdpProfileData::APN_PROTOCOL, bean.pdpProtocol);
209     value.PutString(PdpProfileData::APN_ROAM_PROTOCOL, bean.roamPdpProtocol);
210     value.PutString(PdpProfileData::MVNO_TYPE, bean.mvnoType);
211     value.PutString(PdpProfileData::MVNO_MATCH_DATA, bean.mvnoMatchData);
212     value.PutInt(PdpProfileData::EDITED_STATUS, bean.edited);
213     value.PutString(PdpProfileData::SERVER, bean.server);
214     value.PutInt(PdpProfileData::BEARING_SYSTEM_TYPE, bean.bearingSystemType);
215 }
216 
GetOpKeyFilePath(std::string & path)217 int ParserUtil::GetOpKeyFilePath(std::string &path)
218 {
219     char buf[MAX_PATH_LEN];
220     std::string file = GetCustFile(OPKEY_INFO_PATH, CUST_RULE_PATH_KEY);
221     char *ret = GetOneCfgFile(file.c_str(), buf, MAX_PATH_LEN);
222     if (ret && *ret != '\0') {
223         path = ret;
224         return OPERATION_OK;
225     }
226     DATA_STORAGE_LOGE("ParserUtil::GetOpKeyFilePath fail");
227     return OPERATION_ERROR;
228 }
229 
ParserOpKeyJson(std::vector<OpKey> & vec,const char * path)230 int ParserUtil::ParserOpKeyJson(std::vector<OpKey> &vec, const char *path)
231 {
232     char *content = nullptr;
233     int ret = LoaderJsonFile(content, path);
234     if (ret != DATA_STORAGE_SUCCESS) {
235         DATA_STORAGE_LOGE("ParserUtil::ParserOpKeyJson LoaderJsonFile is fail!");
236         return ret;
237     }
238     if (content == nullptr) {
239         DATA_STORAGE_LOGE("ParserUtil::content is nullptr!");
240         return static_cast<int>(LoadProFileErrorType::FILE_PARSER_ERROR);
241     }
242 
243     cJSON *root = cJSON_Parse(content);
244     free(content);
245     content = nullptr;
246     if (root == nullptr) {
247         DATA_STORAGE_LOGE("ParserUtil::ParserOpKeyInfos root is error!");
248         return static_cast<int>(LoadProFileErrorType::FILE_PARSER_ERROR);
249     }
250     cJSON *itemRoots = cJSON_GetObjectItem(root, ITEM_OPERATOR_ID);
251     if (itemRoots == nullptr || !cJSON_IsArray(itemRoots) || cJSON_GetArraySize(itemRoots) <= 0) {
252         DATA_STORAGE_LOGE("ParserUtil::ParserOpKeyInfos itemRoots size == 0!");
253         cJSON_Delete(root);
254         itemRoots = nullptr;
255         root = nullptr;
256         return static_cast<int>(LoadProFileErrorType::ITEM_SIZE_IS_NULL);
257     }
258     ParserOpKeyInfos(vec, itemRoots);
259     cJSON_Delete(root);
260     itemRoots = nullptr;
261     root = nullptr;
262     return DATA_STORAGE_SUCCESS;
263 }
264 
ParserOpKeyInfos(std::vector<OpKey> & vec,cJSON * itemRoots)265 void ParserUtil::ParserOpKeyInfos(std::vector<OpKey> &vec, cJSON *itemRoots)
266 {
267     cJSON *itemRoot = nullptr;
268     cJSON *ruleRoot = nullptr;
269     for (int i = 0; i < cJSON_GetArraySize(itemRoots); i++) {
270         itemRoot = cJSON_GetArrayItem(itemRoots, i);
271         if (itemRoot == nullptr) {
272             continue;
273         }
274         OpKey bean;
275         ruleRoot = cJSON_GetObjectItem(itemRoot, ITEM_RULE);
276         if (ruleRoot != nullptr) {
277             bean.mccmnc = ParseString(cJSON_GetObjectItem(ruleRoot, ITEM_MCCMNC));
278             bean.gid1 = ParseString(cJSON_GetObjectItem(ruleRoot, ITEM_GID_ONE));
279             bean.gid2 = ParseString(cJSON_GetObjectItem(ruleRoot, ITEM_GID_TWO));
280             bean.imsi = ParseString(cJSON_GetObjectItem(ruleRoot, ITEM_IMSI));
281             bean.spn = ParseString(cJSON_GetObjectItem(ruleRoot, ITEM_SPN));
282             bean.iccid = ParseString(cJSON_GetObjectItem(ruleRoot, ITEM_ICCID));
283         }
284         bean.operatorName = ParseString(cJSON_GetObjectItem(itemRoot, ITEM_OPERATOR_NAME_OPKEY));
285         if (bean.operatorName.empty()) {
286             bean.operatorName = "COMMON";
287         }
288         bean.operatorKey = ParseString(cJSON_GetObjectItem(itemRoot, ITEM_OPERATOR_KEY));
289         bean.operatorKeyExt = ParseString(cJSON_GetObjectItem(itemRoot, ITEM_OPERATOR_KEY_EXT));
290         bean.ruleId = GetRuleId(bean);
291         vec.push_back(bean);
292     }
293     itemRoot = nullptr;
294     ruleRoot = nullptr;
295 }
296 
GetRuleId(OpKey & bean)297 int ParserUtil::GetRuleId(OpKey &bean)
298 {
299     int ruleId = static_cast<int32_t>(RuleID::RULE_EMPTY);
300     if (!bean.mccmnc.empty()) {
301         ruleId += static_cast<int32_t>(RuleID::RULE_MCCMNC);
302     }
303     if (!bean.iccid.empty()) {
304         ruleId += static_cast<int32_t>(RuleID::RULE_ICCID);
305     }
306     if (!bean.imsi.empty()) {
307         ruleId += static_cast<int32_t>(RuleID::RULE_IMSI);
308     }
309     if (!bean.spn.empty()) {
310         ruleId += static_cast<int32_t>(RuleID::RULE_SPN);
311     }
312     if (!bean.gid1.empty()) {
313         ruleId += static_cast<int32_t>(RuleID::RULE_GID1);
314     }
315     if (!bean.gid2.empty()) {
316         ruleId += static_cast<int32_t>(RuleID::RULE_GID2);
317     }
318     return ruleId;
319 }
320 
ParserOpKeyToValuesBucket(NativeRdb::ValuesBucket & value,const OpKey & bean)321 void ParserUtil::ParserOpKeyToValuesBucket(NativeRdb::ValuesBucket &value, const OpKey &bean)
322 {
323     value.PutString(OpKeyData::MCCMNC, bean.mccmnc);
324     value.PutString(OpKeyData::GID1, bean.gid1);
325     value.PutString(OpKeyData::GID2, bean.gid2);
326     value.PutString(OpKeyData::IMSI, bean.imsi);
327     value.PutString(OpKeyData::SPN, bean.spn);
328     value.PutString(OpKeyData::ICCID, bean.iccid);
329     value.PutString(OpKeyData::OPERATOR_NAME, bean.operatorName);
330     value.PutString(OpKeyData::OPERATOR_KEY, bean.operatorKey);
331     value.PutString(OpKeyData::OPERATOR_KEY_EXT, bean.operatorKeyExt);
332     value.PutInt(OpKeyData::RULE_ID, bean.ruleId);
333 }
334 
ParserNumMatchJson(std::vector<NumMatch> & vec,const bool hashCheck)335 int ParserUtil::ParserNumMatchJson(std::vector<NumMatch> &vec, const bool hashCheck)
336 {
337     char *content = nullptr;
338     char buf[MAX_PATH_LEN];
339     std::string file = GetCustFile(NUM_MATCH_PATH, CUST_NETWORK_PATH_KEY);
340     char *path = GetOneCfgFile(file.c_str(), buf, MAX_PATH_LEN);
341     int ret = DATA_STORAGE_SUCCESS;
342     if (path && *path != '\0') {
343         ParserUtil parser;
344         ret = parser.LoaderJsonFile(content, path);
345     }
346     if (ret != DATA_STORAGE_SUCCESS) {
347         DATA_STORAGE_LOGE("ParserUtil::ParserNumMatchJson LoaderJsonFile is fail!\n");
348         return ret;
349     }
350     if (content == nullptr) {
351         DATA_STORAGE_LOGE("ParserUtil::content is nullptr!");
352         return static_cast<int>(LoadProFileErrorType::FILE_PARSER_ERROR);
353     }
354     if (hashCheck && !IsDigestChanged(path, NUM_MATCH_HASH)) {
355         free(content);
356         return FILE_HASH_NO_CHANGE;
357     }
358     cJSON *root = cJSON_Parse(content);
359     free(content);
360     content = nullptr;
361     if (root == nullptr) {
362         DATA_STORAGE_LOGE("ParserUtil::ParserNumMatchJson root is error!\n");
363         return static_cast<int>(LoadProFileErrorType::FILE_PARSER_ERROR);
364     }
365     cJSON *itemRoots = cJSON_GetObjectItem(root, ITEM_NUM_MATCH_INFOS);
366     if (itemRoots == nullptr || !cJSON_IsArray(itemRoots) || cJSON_GetArraySize(itemRoots) <= 0) {
367         DATA_STORAGE_LOGE("ParserUtil::ParserNumMatchJson itemRoots size == 0!\n");
368         cJSON_Delete(root);
369         itemRoots = nullptr;
370         root = nullptr;
371         return static_cast<int>(LoadProFileErrorType::ITEM_SIZE_IS_NULL);
372     }
373     ParserNumMatchInfos(vec, itemRoots);
374     cJSON_Delete(root);
375     itemRoots = nullptr;
376     root = nullptr;
377     return DATA_STORAGE_SUCCESS;
378 }
379 
ParserNumMatchInfos(std::vector<NumMatch> & vec,cJSON * itemRoots)380 void ParserUtil::ParserNumMatchInfos(std::vector<NumMatch> &vec, cJSON *itemRoots)
381 {
382     cJSON *itemRoot = nullptr;
383     for (int32_t i = 0; i < cJSON_GetArraySize(itemRoots); i++) {
384         itemRoot = cJSON_GetArrayItem(itemRoots, i);
385         if (itemRoot == nullptr) {
386             continue;
387         }
388         NumMatch bean;
389         bean.name = ParseAsString(cJSON_GetObjectItem(itemRoot, ITEM_NAME));
390         bean.mcc = ParseAsString(cJSON_GetObjectItem(itemRoot, ITEM_MCC));
391         bean.mnc = ParseAsString(cJSON_GetObjectItem(itemRoot, ITEM_MNC));
392         bean.numMatch = ParseInt(cJSON_GetObjectItem(itemRoot, ITEM_NUM_MATCH));
393         bean.numMatchShort = ParseInt(cJSON_GetObjectItem(itemRoot, ITEM_NUM_MATCH_SHORT));
394         vec.push_back(bean);
395     }
396     itemRoot = nullptr;
397 }
398 
ParseAsString(const cJSON * value)399 std::string ParserUtil::ParseAsString(const cJSON *value)
400 {
401     if (value != nullptr && value->type == cJSON_String && value->valuestring != nullptr) {
402         return value->valuestring;
403     } else if (value != nullptr && value->type == cJSON_Number) {
404         return std::to_string(static_cast<int64_t>(cJSON_GetNumberValue(value)));
405     }
406     return "";
407 }
408 
ParseInt(const cJSON * value)409 int32_t ParserUtil::ParseInt(const cJSON *value)
410 {
411     if (value != nullptr && value->type == cJSON_Number) {
412         return value->valueint;
413     }
414     return 0;
415 }
416 
ParserNumMatchToValuesBucket(NativeRdb::ValuesBucket & value,const NumMatch & bean)417 void ParserUtil::ParserNumMatchToValuesBucket(NativeRdb::ValuesBucket &value, const NumMatch &bean)
418 {
419     value.PutString(NumMatchData::NAME, bean.name);
420     value.PutString(NumMatchData::MCC, bean.mcc);
421     value.PutString(NumMatchData::MNC, bean.mnc);
422     std::string mccmnc(bean.mcc);
423     mccmnc.append(bean.mnc);
424     value.PutString(NumMatchData::MCCMNC, mccmnc);
425     value.PutInt(NumMatchData::NUM_MATCH, bean.numMatch);
426     value.PutInt(NumMatchData::NUM_MATCH_SHORT, bean.numMatchShort);
427 }
428 
ParserEccDataJson(std::vector<EccNum> & vec,const bool hashCheck)429 int ParserUtil::ParserEccDataJson(std::vector<EccNum> &vec, const bool hashCheck)
430 {
431     char *content = nullptr;
432     char buf[MAX_PATH_LEN];
433     std::string file = GetCustFile(ECC_DATA_PATH, CUST_NETWORK_PATH_KEY);
434     char *path = GetOneCfgFile(file.c_str(), buf, MAX_PATH_LEN);
435     int ret = DATA_STORAGE_SUCCESS;
436     if (path && *path != '\0') {
437         ret = LoaderJsonFile(content, path);
438     }
439     if (ret != DATA_STORAGE_SUCCESS) {
440         DATA_STORAGE_LOGE("ParserUtil::ParserEccDataJson LoaderJsonFile is fail!");
441         return ret;
442     }
443     if (content == nullptr) {
444         DATA_STORAGE_LOGE("ParserUtil::content is nullptr!");
445         return static_cast<int>(LoadProFileErrorType::FILE_PARSER_ERROR);
446     }
447     if (hashCheck && !IsDigestChanged(path, ECC_DATA_HASH)) {
448         free(content);
449         return FILE_HASH_NO_CHANGE;
450     }
451     cJSON *root = cJSON_Parse(content);
452     free(content);
453     content = nullptr;
454     if (root == nullptr) {
455         DATA_STORAGE_LOGE("ParserUtil::ParserEccDataJson root is error!");
456         return static_cast<int>(LoadProFileErrorType::FILE_PARSER_ERROR);
457     }
458 
459     cJSON *itemRoots = cJSON_GetObjectItem(root, ITEM_OPERATOR_INFOS);
460     if (itemRoots == nullptr || !cJSON_IsArray(itemRoots) || cJSON_GetArraySize(itemRoots) <= 0) {
461         DATA_STORAGE_LOGE("ParserUtil::ParserEccDataJson itemRoots size == 0!");
462         cJSON_Delete(root);
463         itemRoots = nullptr;
464         root = nullptr;
465         return static_cast<int>(LoadProFileErrorType::ITEM_SIZE_IS_NULL);
466     }
467     ParserEccDataInfos(vec, itemRoots);
468     cJSON_Delete(root);
469     itemRoots = nullptr;
470     root = nullptr;
471     return DATA_STORAGE_SUCCESS;
472 }
473 
ParserEccDataInfos(std::vector<EccNum> & vec,cJSON * itemRoots)474 void ParserUtil::ParserEccDataInfos(std::vector<EccNum> &vec, cJSON *itemRoots)
475 {
476     cJSON *itemRoot = nullptr;
477     for (int i = 0; i < cJSON_GetArraySize(itemRoots); i++) {
478         itemRoot = cJSON_GetArrayItem(itemRoots, i);
479         if (itemRoot == nullptr) {
480             continue;
481         }
482         EccNum bean;
483         bean.name = ParseAsString(cJSON_GetObjectItem(itemRoot, ITEM_NAME));
484         bean.mcc = ParseAsString(cJSON_GetObjectItem(itemRoot, ITEM_MCC));
485         bean.mnc = ParseAsString(cJSON_GetObjectItem(itemRoot, ITEM_MNC));
486         bean.numeric = ParseAsString(cJSON_GetObjectItem(itemRoot, ITEM_NUMERIC));
487         bean.ecc_withcard = ParseAsString(cJSON_GetObjectItem(itemRoot, ITEM_ECC_WITH_CARD));
488         bean.ecc_nocard = ParseAsString(cJSON_GetObjectItem(itemRoot, ITEM_ECC_NO_CARD));
489         bean.ecc_fake = ParseAsString(cJSON_GetObjectItem(itemRoot, ITEM_ECC_FAKE));
490         vec.push_back(bean);
491     }
492     itemRoot = nullptr;
493 }
494 
ParserEccDataToValuesBucket(NativeRdb::ValuesBucket & value,const EccNum & bean)495 void ParserUtil::ParserEccDataToValuesBucket(NativeRdb::ValuesBucket &value, const EccNum &bean)
496 {
497     value.PutString(EccData::NAME, bean.name);
498     value.PutString(EccData::MCC, bean.mcc);
499     value.PutString(EccData::MNC, bean.mnc);
500     value.PutString(EccData::NUMERIC, bean.numeric);
501     value.PutString(EccData::ECC_WITH_CARD, bean.ecc_withcard);
502     value.PutString(EccData::ECC_NO_CARD, bean.ecc_nocard);
503     value.PutString(EccData::ECC_FAKE, bean.ecc_fake);
504 }
505 
LoaderJsonFile(char * & content,const char * path) const506 int ParserUtil::LoaderJsonFile(char *&content, const char *path) const
507 {
508     long len = 0;
509     char realPath[PATH_MAX] = { 0x00 };
510     if (realpath(path, realPath) == nullptr) {
511         DATA_STORAGE_LOGE("ParserUtil::LoaderJsonFile realpath fail! #PATH: %{public}s", path);
512         return static_cast<int>(LoadProFileErrorType::REALPATH_FAIL);
513     }
514     FILE *f = fopen(realPath, "rb");
515     if (f == nullptr) {
516         DATA_STORAGE_LOGE("ParserUtil::LoaderJsonFile file is null!");
517         return static_cast<int>(LoadProFileErrorType::OPEN_FILE_ERROR);
518     }
519     int ret_seek_end = fseek(f, 0, SEEK_END);
520     if (ret_seek_end != 0) {
521         DATA_STORAGE_LOGE("ParserUtil::LoaderJsonFile ret_seek_end != 0!");
522         CloseFile(f);
523         return static_cast<int>(LoadProFileErrorType::LOAD_FILE_ERROR);
524     }
525     len = ftell(f);
526     int ret_seek_set = fseek(f, 0, SEEK_SET);
527     if (ret_seek_set != 0) {
528         DATA_STORAGE_LOGE("ParserUtil::LoaderJsonFile ret_seek_set != 0!");
529         CloseFile(f);
530         return static_cast<int>(LoadProFileErrorType::LOAD_FILE_ERROR);
531     }
532     if (len == 0 || len > static_cast<long>(MAX_BYTE_LEN)) {
533         DATA_STORAGE_LOGE("ParserUtil::LoaderJsonFile len <= 0 or len > LONG_MAX!");
534         CloseFile(f);
535         return static_cast<int>(LoadProFileErrorType::LOAD_FILE_ERROR);
536     }
537     content = static_cast<char *>(malloc(len + 1));
538     if (content == nullptr) {
539         DATA_STORAGE_LOGE("ParserUtil::LoaderJsonFile malloc content fail!");
540         CloseFile(f);
541         return static_cast<int>(LoadProFileErrorType::LOAD_FILE_ERROR);
542     }
543     if (memset_s(content, len + 1, 0, len + 1) != EOK) {
544         DATA_STORAGE_LOGE("ParserUtil::LoaderJsonFile memset_s failed");
545         free(content);
546         content = nullptr;
547         CloseFile(f);
548         return static_cast<int>(LoadProFileErrorType::LOAD_FILE_ERROR);
549     }
550     size_t ret_read = fread(content, 1, len, f);
551     if (ret_read != static_cast<size_t>(len)) {
552         DATA_STORAGE_LOGE("ParserUtil::LoaderJsonFile ret_read != len!");
553         free(content);
554         content = nullptr;
555         CloseFile(f);
556         return static_cast<int>(LoadProFileErrorType::LOAD_FILE_ERROR);
557     }
558     return CloseFile(f);
559 }
560 
CloseFile(FILE * f) const561 int ParserUtil::CloseFile(FILE *f) const
562 {
563     int ret_close = fclose(f);
564     if (ret_close != 0) {
565         DATA_STORAGE_LOGE("ParserUtil::LoaderJsonFile ret_close != 0!");
566         return static_cast<int>(LoadProFileErrorType::CLOSE_FILE_ERROR);
567     }
568     return DATA_STORAGE_SUCCESS;
569 }
570 
GetCustFile(const char * & file,const char * key)571 std::string ParserUtil::GetCustFile(const char *&file, const char *key)
572 {
573     std::string custFile = system::GetParameter(key, "");
574     if (!custFile.empty()) {
575         custFile.append(file);
576     } else {
577         custFile = file;
578     }
579     return custFile;
580 }
581 
GetPdpProfilePath(int slotId,std::string & path)582 int ParserUtil::GetPdpProfilePath(int slotId, std::string &path)
583 {
584     int mode = MODE_SLOT_0;
585     if (slotId == SimSlotId::SIM_SLOT_1) {
586         mode = MODE_SLOT_1;
587     }
588     char buf[MAX_PATH_LEN];
589     char *ret = GetOneCfgFileEx(PATH, buf, MAX_PATH_LEN, mode, nullptr);
590     if (ret && *ret != '\0') {
591         path = ret;
592         return OPERATION_OK;
593     }
594     DATA_STORAGE_LOGE("ParserUtil::GetPdpProfilePath fail");
595     return OPERATION_ERROR;
596 }
597 
GetFileChecksum(const char * path,std::string & checkSum)598 int ParserUtil::GetFileChecksum(const char *path, std::string &checkSum)
599 {
600     char realPath[PATH_MAX] = {0x00};
601     if (realpath(path, realPath) == nullptr) {
602         DATA_STORAGE_LOGE("ParserUtil::GetFileChecksum Failed to get realPath!");
603         return OPERATION_ERROR;
604     }
605     std::ifstream file(realPath, std::ios::binary);
606     if (!file.is_open()) {
607         DATA_STORAGE_LOGE("ParserUtil::GetFileChecksum Failed to open file!");
608         return OPERATION_ERROR;
609     }
610     std::vector<char> buffer(BYTE_LEN);
611     uint32_t crc32 = crc32_z(0L, Z_NULL, 0);
612     while (file) {
613         file.read(buffer.data(), buffer.size());
614         auto bytesRead = file.gcount();
615         if (bytesRead > 0) {
616             crc32 = crc32_z(crc32, reinterpret_cast<const Bytef *>(buffer.data()), static_cast<uInt>(bytesRead));
617         }
618     }
619     checkSum = std::to_string(crc32);
620     return OPERATION_OK;
621 }
622 
IsNeedInsertToTable(cJSON * value)623 bool ParserUtil::IsNeedInsertToTable(cJSON *value)
624 {
625     if (value == nullptr || cJSON_GetObjectItem(value, ITEM_APN) == nullptr) {
626         return false;
627     }
628     char *tempChar = cJSON_PrintUnformatted(value);
629     if (tempChar == nullptr) {
630         return false;
631     }
632     std::string res = tempChar;
633     free(tempChar);
634     tempChar = nullptr;
635     return DelayedRefSingleton<CoreServiceClient>::GetInstance().IsAllowedInsertApn(res);
636 }
637 
IsDigestChanged(const char * path,const std::string & key)638 bool ParserUtil::IsDigestChanged(const char *path, const std::string &key)
639 {
640     std::string newHash;
641     ParserUtil util;
642     util.GetFileChecksum(path, newHash);
643     auto preferencesUtil = DelayedSingleton<PreferencesUtil>::GetInstance();
644     if (preferencesUtil == nullptr) {
645         DATA_STORAGE_LOGE("ParserUtil::IsDigestChanged preferencesUtil is nullptr!");
646         return true;
647     }
648     std::string oldHash = preferencesUtil->ObtainString(key, DEFAULT_PREFERENCES_STRING_VALUE);
649     if (oldHash.compare(newHash) == 0) {
650         DATA_STORAGE_LOGD("ParserUtil::IsDigestChanged file not changed");
651         return false;
652     }
653     DATA_STORAGE_LOGI("ParserUtil::IsDigestChanged file is changed");
654     preferencesUtil->SaveString(key + TEMP_SUFFIX, newHash);
655     return true;
656 }
657 
RefreshDigest(const std::string & key)658 void ParserUtil::RefreshDigest(const std::string &key)
659 {
660     auto preferencesUtil = DelayedSingleton<PreferencesUtil>::GetInstance();
661     if (preferencesUtil == nullptr) {
662         DATA_STORAGE_LOGE("ParserUtil::RefreshDigest preferencesUtil is nullptr!");
663         return;
664     }
665     std::string tempHash = preferencesUtil->ObtainString(key + TEMP_SUFFIX, DEFAULT_PREFERENCES_STRING_VALUE);
666     if (tempHash != DEFAULT_PREFERENCES_STRING_VALUE) {
667         preferencesUtil->SaveString(key, tempHash);
668         preferencesUtil->RemoveKey(key + TEMP_SUFFIX);
669         preferencesUtil->Refresh();
670     }
671 }
672 
ClearTempDigest(const std::string & key)673 void ParserUtil::ClearTempDigest(const std::string &key)
674 {
675     auto preferencesUtil = DelayedSingleton<PreferencesUtil>::GetInstance();
676     if (preferencesUtil == nullptr) {
677         DATA_STORAGE_LOGE("ParserUtil::ClearTempDigest preferencesUtil is nullptr!");
678         return;
679     }
680     preferencesUtil->RemoveKey(key + TEMP_SUFFIX);
681     preferencesUtil->Refresh();
682 }
683 } // namespace Telephony
684 } // namespace OHOS
685