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 45namespace OHOS { 46namespace Telephony { 47const char *PATH = "/etc/telephony/pdp_profile.json"; 48const char *ITEM_OPERATOR_INFOS = "operator_infos"; 49const char *ITEM_OPERATOR_NAME = "operator_name"; 50const char *ITEM_AUTH_USER = "auth_user"; 51const char *ITEM_AUTH_PWD = "auth_pwd"; 52const char *ITEM_AUTH_TYPE = "auth_type"; 53const char *ITEM_MCC = "mcc"; 54const char *ITEM_MNC = "mnc"; 55const char *ITEM_APN = "apn"; 56const char *ITEM_APN_TYPES = "apn_types"; 57const char *ITEM_IP_ADDRESS = "ip_addr"; 58const char *ITEM_MMS_IP_ADDRESS = "mms_ip_addr"; 59const char *ITEM_HOME_URL = "home_url"; 60const char *ITEM_MVNO_TYPE = "mvno_type"; 61const char *ITEM_MVNO_MATCH_DATA = "mvno_match_data"; 62const char *ITEM_EDITED_STATUS = "edited"; 63const char *ITEM_SERVER = "server"; 64const char *ITEM_BEARER = "bearing_system_type"; 65const char *ITEM_IS_ROAMING_APN = "is_roaming_apn"; 66const char *ITEM_APN_PROTOCOL = "apn_protocol"; 67const char *ITEM_ROAMING_PROTOCOL = "apn_roam_protocol"; 68const char *APN_VERSION = "apn_version"; 69const char *OPKEY_INFO_PATH = "etc/telephony/OpkeyInfo.json"; 70const char *ITEM_OPERATOR_ID = "operator_id"; 71const char *ITEM_RULE = "rule"; 72const char *ITEM_MCCMNC = "mcc_mnc"; 73const char *ITEM_GID_ONE = "gid1"; 74const char *ITEM_GID_TWO = "gid2"; 75const char *ITEM_IMSI = "imsi"; 76const char *ITEM_SPN = "spn"; 77const char *ITEM_ICCID = "iccid"; 78const char *ITEM_OPERATOR_NAME_OPKEY = "operator_name"; 79const char *ITEM_OPERATOR_KEY = "operator_key"; 80const char *ITEM_OPERATOR_KEY_EXT = "operator_key_ext"; 81const char *NUM_MATCH_PATH = "etc/telephony/number_match.json"; 82const char *ECC_DATA_PATH = "etc/telephony/ecc_data.json"; 83const char *ITEM_NUM_MATCH_INFOS = "numMatchs"; 84const char *ITEM_NAME = "name"; 85const char *ITEM_NUM_MATCH = "num_match"; 86const char *ITEM_NUM_MATCH_SHORT = "num_match_short"; 87const char *ITEM_NUMERIC = "numeric"; 88const char *ITEM_ECC_WITH_CARD = "ecc_withcard"; 89const char *ITEM_ECC_NO_CARD = "ecc_nocard"; 90const char *ITEM_ECC_FAKE = "ecc_fake"; 91const int BYTE_LEN = 1024 * 1024; 92const int MAX_BYTE_LEN = 10 * 1024 * 1024; 93static constexpr const char *CUST_RULE_PATH_KEY = "const.telephony.rule_path"; 94static constexpr const char *CUST_NETWORK_PATH_KEY = "const.telephony.network_path"; 95const std::string DEFAULT_PREFERENCES_STRING_VALUE = "default_value"; 96const std::string TEMP_SUFFIX = "_temp"; 97 98int 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 105int 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 144void 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 183std::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 191void 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 217int 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 230int 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 265void 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 297int 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 321void 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 335int 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 380void 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 399std::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 409int32_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 417void 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 429int 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 474void 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 495void 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 506int 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 561int 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 571std::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 582int 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 598int 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 623bool 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 638bool 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 658void 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 673void 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