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 "icc_file_controller.h" 17 18 using namespace std; 19 using namespace OHOS::AppExecFwk; 20 21 namespace OHOS { 22 namespace Telephony { IccFileController(const std::string & name,int slotId)23 IccFileController::IccFileController(const std::string &name, int slotId) : TelEventHandler(name), slotId_(slotId) {} 24 ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)25 void IccFileController::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) 26 { 27 if (event == nullptr) { 28 TELEPHONY_LOGE("event is nullptr!"); 29 return; 30 } 31 uint32_t id = event->GetInnerEventId(); 32 TELEPHONY_LOGD("IccFileController ProcessEvent Id is %{public}d", id); 33 if (ProcessErrorResponse(event)) { 34 return; 35 } 36 switch (id) { 37 case MSG_SIM_OBTAIN_SIZE_OF_LINEAR_ELEMENTARY_FILE_DONE: 38 ProcessLinearRecordSize(event); 39 break; 40 case MSG_SIM_OBTAIN_SIZE_OF_FIXED_ELEMENTARY_FILE_DONE: 41 ProcessRecordSize(event); 42 break; 43 case MSG_SIM_OBTAIN_SIZE_OF_TRANSPARENT_ELEMENTARY_FILE_DONE: 44 ProcessBinarySize(event); 45 break; 46 case MSG_SIM_OBTAIN_FIXED_ELEMENTARY_FILE_DONE: 47 ProcessReadRecord(event); 48 break; 49 case MSG_SIM_OBTAIN_ICON_DONE: 50 case MSG_SIM_UPDATE_LINEAR_FIXED_FILE_DONE: 51 case MSG_SIM_UPDATE_TRANSPARENT_ELEMENTARY_FILE_DONE: 52 case MSG_SIM_OBTAIN_TRANSPARENT_ELEMENTARY_FILE_DONE: 53 ProcessReadBinary(event); 54 break; 55 default: 56 break; 57 } 58 } 59 ProcessLinearRecordSize(const AppExecFwk::InnerEvent::Pointer & event)60 void IccFileController::ProcessLinearRecordSize(const AppExecFwk::InnerEvent::Pointer &event) 61 { 62 std::unique_ptr<IccFromRilMsg> rcvMsg = event->GetUniqueObject<IccFromRilMsg>(); 63 if (rcvMsg == nullptr) { 64 TELEPHONY_LOGE("rcvMsg is nullptr"); 65 return; 66 } 67 IccFileData *result = &(rcvMsg->fileData); 68 std::shared_ptr<IccControllerHolder> hd = rcvMsg->controlHolder; 69 if (result == nullptr || hd == nullptr) { 70 TELEPHONY_LOGE("result or hd is nullptr"); 71 return; 72 } 73 const AppExecFwk::InnerEvent::Pointer &process = hd->fileLoaded; 74 TELEPHONY_LOGI("ProcessLinearRecordSize --- resultData: --- %{public}s", result->resultData.c_str()); 75 int recordLen = 0; 76 int fileSize[] = { 0, 0, 0 }; 77 std::shared_ptr<unsigned char> rawData = SIMUtils::HexStringConvertToBytes(result->resultData, recordLen); 78 if (recordLen > LENGTH_OF_RECORD) { 79 unsigned char *fileData = rawData.get(); 80 ParseFileSize(fileSize, RECORD_NUM, fileData); 81 } 82 SendEfLinearResult(process, fileSize, RECORD_NUM); 83 } 84 ProcessRecordSize(const AppExecFwk::InnerEvent::Pointer & event)85 void IccFileController::ProcessRecordSize(const AppExecFwk::InnerEvent::Pointer &event) 86 { 87 int size = 0; 88 std::unique_ptr<IccFromRilMsg> rcvMsg = event->GetUniqueObject<IccFromRilMsg>(); 89 if (rcvMsg == nullptr) { 90 TELEPHONY_LOGE("rcvMsg is nullptr"); 91 return; 92 } 93 IccFileData *result = &(rcvMsg->fileData); 94 std::shared_ptr<IccControllerHolder> hd = rcvMsg->controlHolder; 95 if (result == nullptr || hd == nullptr) { 96 TELEPHONY_LOGE("result or hd is nullptr"); 97 return; 98 } 99 TELEPHONY_LOGI("ProcessRecordSize --- resultData: --- %{public}s", result->resultData.c_str()); 100 int recordLen = 0; 101 std::shared_ptr<unsigned char> rawData = SIMUtils::HexStringConvertToBytes(result->resultData, recordLen); 102 if (rawData == nullptr) { 103 TELEPHONY_LOGE("rawData is nullptr"); 104 SendResponse(rcvMsg->controlHolder, &(rcvMsg->fileData)); 105 return; 106 } 107 unsigned char *fileData = rawData.get(); 108 std::string path = CheckRightPath(hd->filePath, hd->fileId); 109 if (recordLen > LENGTH_OF_RECORD) { 110 if (!IsValidRecordSizeData(fileData)) { 111 TELEPHONY_LOGE("ProcessRecordSize get error filetype"); 112 SendResponse(rcvMsg->controlHolder, &(rcvMsg->fileData)); 113 return; 114 } 115 GetFileAndDataSize(fileData, hd->fileSize, size); 116 if (hd->fileSize != 0) { 117 hd->countFiles = size / hd->fileSize; 118 } 119 } 120 TELEPHONY_LOGI("ProcessRecordSize fileId:%{public}d %{public}d %{public}d %{public}d", hd->fileId, size, 121 hd->fileSize, hd->countFiles); 122 if (telRilManager_ != nullptr) { 123 SimIoRequestInfo msg; 124 msg.command = CONTROLLER_REQ_READ_RECORD; 125 msg.fileId = hd->fileId; 126 msg.p1 = hd->fileNum; 127 msg.p2 = ICC_FILE_CURRENT_MODE; 128 msg.p3 = hd->fileSize; 129 msg.data = IccFileController::NULLSTR; 130 msg.path = path; 131 msg.pin2 = ""; 132 telRilManager_->GetSimIO(slotId_, msg, BuildCallerInfo(MSG_SIM_OBTAIN_FIXED_ELEMENTARY_FILE_DONE, hd)); 133 } 134 } 135 ProcessBinarySize(const AppExecFwk::InnerEvent::Pointer & event)136 void IccFileController::ProcessBinarySize(const AppExecFwk::InnerEvent::Pointer &event) 137 { 138 std::unique_ptr<IccFromRilMsg> rcvMsg = event->GetUniqueObject<IccFromRilMsg>(); 139 if (rcvMsg == nullptr) { 140 TELEPHONY_LOGE("rcvMsg is nullptr"); 141 return; 142 } 143 IccFileData *result = &(rcvMsg->fileData); 144 std::shared_ptr<IccControllerHolder> hd = rcvMsg->controlHolder; 145 if (result == nullptr || hd == nullptr) { 146 TELEPHONY_LOGE("ProcessBinarySize result or hd is nullptr"); 147 return; 148 } 149 TELEPHONY_LOGI("ProcessBinarySize --- resultData: --- %{public}s", result->resultData.c_str()); 150 int binaryLen = 0; 151 std::shared_ptr<unsigned char> rawData = SIMUtils::HexStringConvertToBytes(result->resultData, binaryLen); 152 if (rawData == nullptr) { 153 TELEPHONY_LOGE("ProcessBinarySize rawData is nullptr"); 154 SendResponse(rcvMsg->controlHolder, &(rcvMsg->fileData)); 155 return; 156 } 157 unsigned char *fileData = rawData.get(); 158 int size = 0; 159 if (binaryLen > STRUCTURE_OF_DATA) { 160 if (!IsValidBinarySizeData(fileData)) { 161 TELEPHONY_LOGE("ProcessBinarySize get error filetype"); 162 SendResponse(rcvMsg->controlHolder, &(rcvMsg->fileData)); 163 return; 164 } 165 GetDataSize(fileData, size); 166 } 167 int fileId = rcvMsg->arg1; 168 TELEPHONY_LOGI("ProcessBinarySize fileId:%{public}d size:%{public}d", fileId, size); 169 const AppExecFwk::InnerEvent::Pointer &evt = hd->fileLoaded; 170 if (evt == nullptr) { 171 TELEPHONY_LOGE("ProcessBinarySize isNull is null pointer"); 172 return; 173 } 174 AppExecFwk::InnerEvent::Pointer process = 175 BuildCallerInfo(MSG_SIM_OBTAIN_TRANSPARENT_ELEMENTARY_FILE_DONE, fileId, 0, evt); 176 if (telRilManager_ != nullptr) { 177 SimIoRequestInfo msg; 178 msg.command = CONTROLLER_REQ_READ_BINARY; 179 msg.fileId = fileId; 180 msg.p1 = 0; 181 msg.p2 = 0; 182 msg.p3 = static_cast<int32_t>(size); 183 msg.data = IccFileController::NULLSTR; 184 msg.path = ObtainElementFilePath(fileId); 185 msg.pin2 = ""; 186 telRilManager_->GetSimIO(slotId_, msg, process); 187 } 188 } 189 ProcessReadRecord(const AppExecFwk::InnerEvent::Pointer & event)190 void IccFileController::ProcessReadRecord(const AppExecFwk::InnerEvent::Pointer &event) 191 { 192 std::string str = IccFileController::NULLSTR; 193 std::string path = IccFileController::NULLSTR; 194 std::unique_ptr<IccFromRilMsg> rcvMsg = event->GetUniqueObject<IccFromRilMsg>(); 195 if (rcvMsg == nullptr || rcvMsg->controlHolder == nullptr) { 196 TELEPHONY_LOGE("rcvMsg is nullptr"); 197 return; 198 } 199 const AppExecFwk::InnerEvent::Pointer &process = rcvMsg->controlHolder->fileLoaded; 200 IccFileData *result = &(rcvMsg->fileData); 201 std::shared_ptr<IccControllerHolder> hd = rcvMsg->controlHolder; 202 if (hd == nullptr) { 203 TELEPHONY_LOGE("hd is nullptr"); 204 return; 205 } 206 TELEPHONY_LOGI("ProcessReadRecord %{public}d %{public}d %{public}d %{public}s", hd->getAllFile, hd->fileNum, 207 hd->countFiles, result->resultData.c_str()); 208 path = CheckRightPath(hd->filePath, hd->fileId); 209 if (hd->getAllFile) { 210 hd->fileResults.push_back(result->resultData); 211 hd->fileNum++; 212 if (hd->fileNum > hd->countFiles) { 213 SendMultiRecordResult(process, hd->fileResults); 214 } else { 215 SimIoRequestInfo msg; 216 msg.command = CONTROLLER_REQ_READ_RECORD; 217 msg.fileId = hd->fileId; 218 msg.p1 = hd->fileNum; 219 msg.p2 = ICC_FILE_CURRENT_MODE; 220 msg.p3 = hd->fileSize; 221 msg.data = IccFileController::NULLSTR; 222 msg.path = path; 223 msg.pin2 = ""; 224 telRilManager_->GetSimIO(slotId_, msg, BuildCallerInfo(MSG_SIM_OBTAIN_FIXED_ELEMENTARY_FILE_DONE, hd)); 225 } 226 } else { 227 SendResponse(rcvMsg->controlHolder, &(rcvMsg->fileData)); 228 } 229 } 230 ProcessReadBinary(const AppExecFwk::InnerEvent::Pointer & event)231 void IccFileController::ProcessReadBinary(const AppExecFwk::InnerEvent::Pointer &event) 232 { 233 TELEPHONY_LOGD("IccFileController MSG_SIM_OBTAIN_TRANSPARENT_ELEMENTARY_FILE_DONE"); 234 std::unique_ptr<IccFromRilMsg> rcvMsg = event->GetUniqueObject<IccFromRilMsg>(); 235 if (rcvMsg == nullptr || rcvMsg->controlHolder == nullptr) { 236 TELEPHONY_LOGE("rcvMsg or rcvMsg->controlHolder is nullptr"); 237 return; 238 } 239 SendResponse(rcvMsg->controlHolder, &(rcvMsg->fileData)); 240 } 241 ObtainElementFileForPublic(int efId)242 std::string IccFileController::ObtainElementFileForPublic(int efId) 243 { 244 std::string mf = MASTER_FILE_SIM; 245 if (efId == ELEMENTARY_FILE_ICCID || efId == ELEMENTARY_FILE_PL) { 246 return mf; 247 } 248 mf.append(DEDICATED_FILE_TELECOM); 249 if (efId == ELEMENTARY_FILE_ADN || efId == ELEMENTARY_FILE_FDN || efId == ELEMENTARY_FILE_MSISDN || 250 efId == ELEMENTARY_FILE_SDN || efId == ELEMENTARY_FILE_EXT1 || efId == ELEMENTARY_FILE_EXT2 || 251 efId == ELEMENTARY_FILE_EXT3) { 252 return mf; 253 } 254 if (efId == ELEMENTARY_FILE_PBR) { 255 mf.append(DEDICATED_FILE_DIALLING_NUMBERS); 256 return mf; 257 } 258 if (efId == ELEMENTARY_FILE_IMG) { 259 mf.append(DEDICATED_FILE_GRAPHICS); 260 return mf; 261 } 262 return IccFileController::NULLSTR; 263 } 264 265 // implementation ObtainBinaryFile ObtainBinaryFile(int fileId,const AppExecFwk::InnerEvent::Pointer & event)266 void IccFileController::ObtainBinaryFile(int fileId, const AppExecFwk::InnerEvent::Pointer &event) 267 { 268 TELEPHONY_LOGD("IccFileController::ObtainBinaryFile start"); 269 AppExecFwk::InnerEvent::Pointer process = 270 BuildCallerInfo(MSG_SIM_OBTAIN_SIZE_OF_TRANSPARENT_ELEMENTARY_FILE_DONE, fileId, 0, event); 271 if (telRilManager_ != nullptr) { 272 SimIoRequestInfo msg; 273 msg.command = CONTROLLER_REQ_GET_RESPONSE; 274 msg.fileId = fileId; 275 msg.p1 = 0; 276 msg.p2 = 0; 277 msg.p3 = GET_RESPONSE_ELEMENTARY_FILE_SIZE_BYTES; 278 msg.data = IccFileController::NULLSTR; 279 msg.path = ObtainElementFilePath(fileId); 280 msg.pin2 = ""; 281 telRilManager_->GetSimIO(slotId_, msg, process); 282 } 283 TELEPHONY_LOGD("IccFileController::ObtainBinaryFile end"); 284 } 285 ObtainBinaryFile(int fileId,int size,const AppExecFwk::InnerEvent::Pointer & event)286 void IccFileController::ObtainBinaryFile(int fileId, int size, const AppExecFwk::InnerEvent::Pointer &event) 287 { 288 AppExecFwk::InnerEvent::Pointer process = 289 BuildCallerInfo(MSG_SIM_OBTAIN_TRANSPARENT_ELEMENTARY_FILE_DONE, fileId, 0, event); 290 if (telRilManager_ != nullptr) { 291 SimIoRequestInfo msg; 292 msg.command = CONTROLLER_REQ_READ_BINARY; 293 msg.fileId = fileId; 294 msg.p1 = 0; 295 msg.p2 = 0; 296 msg.p3 = size; 297 msg.data = IccFileController::NULLSTR; 298 msg.path = ObtainElementFilePath(fileId); 299 msg.pin2 = ""; 300 telRilManager_->GetSimIO(slotId_, msg, process); 301 } 302 } 303 304 // implementation ObtainLinearFixedFile ObtainLinearFixedFile(int fileId,const std::string & path,int fileNum,const AppExecFwk::InnerEvent::Pointer & event)305 void IccFileController::ObtainLinearFixedFile( 306 int fileId, const std::string &path, int fileNum, const AppExecFwk::InnerEvent::Pointer &event) 307 { 308 std::string filePath = CheckRightPath(path, fileId); 309 std::shared_ptr<IccControllerHolder> ctrlHolder = std::make_shared<IccControllerHolder>(fileId, fileNum, filePath); 310 ctrlHolder->fileLoaded = std::move(const_cast<AppExecFwk::InnerEvent::Pointer &>(event)); 311 AppExecFwk::InnerEvent::Pointer process = 312 BuildCallerInfo(MSG_SIM_OBTAIN_SIZE_OF_FIXED_ELEMENTARY_FILE_DONE, ctrlHolder); 313 if (telRilManager_ != nullptr) { 314 SimIoRequestInfo msg; 315 msg.command = CONTROLLER_REQ_GET_RESPONSE; 316 msg.fileId = fileId; 317 msg.p1 = 0; 318 msg.p2 = 0; 319 msg.p3 = GET_RESPONSE_ELEMENTARY_FILE_SIZE_BYTES; 320 msg.data = IccFileController::NULLSTR; 321 msg.path = filePath; 322 msg.pin2 = ""; 323 telRilManager_->GetSimIO(slotId_, msg, process); 324 } 325 } 326 ObtainLinearFixedFile(int fileId,int fileNum,const AppExecFwk::InnerEvent::Pointer & event)327 void IccFileController::ObtainLinearFixedFile(int fileId, int fileNum, const AppExecFwk::InnerEvent::Pointer &event) 328 { 329 ObtainLinearFixedFile(fileId, ObtainElementFilePath(fileId), fileNum, event); 330 } 331 332 // implementation ObtainAllLinearFixedFile ObtainAllLinearFixedFile(int fileId,const std::string & path,const AppExecFwk::InnerEvent::Pointer & event)333 void IccFileController::ObtainAllLinearFixedFile( 334 int fileId, const std::string &path, const AppExecFwk::InnerEvent::Pointer &event) 335 { 336 std::string filePath = CheckRightPath(path, fileId); 337 std::shared_ptr<IccControllerHolder> ctrlHolder = std::make_shared<IccControllerHolder>(fileId, filePath); 338 ctrlHolder->fileLoaded = std::move(const_cast<AppExecFwk::InnerEvent::Pointer &>(event)); 339 AppExecFwk::InnerEvent::Pointer process = 340 BuildCallerInfo(MSG_SIM_OBTAIN_SIZE_OF_FIXED_ELEMENTARY_FILE_DONE, ctrlHolder); 341 if (telRilManager_ != nullptr) { 342 SimIoRequestInfo msg; 343 msg.command = CONTROLLER_REQ_GET_RESPONSE; 344 msg.fileId = fileId; 345 msg.p1 = 0; 346 msg.p2 = 0; 347 msg.p3 = GET_RESPONSE_ELEMENTARY_FILE_SIZE_BYTES; 348 msg.data = IccFileController::NULLSTR; 349 msg.path = filePath; 350 msg.pin2 = ""; 351 telRilManager_->GetSimIO(slotId_, msg, process); 352 } 353 } 354 ObtainAllLinearFixedFile(int fileId,const AppExecFwk::InnerEvent::Pointer & event)355 void IccFileController::ObtainAllLinearFixedFile(int fileId, const AppExecFwk::InnerEvent::Pointer &event) 356 { 357 ObtainAllLinearFixedFile(fileId, ObtainElementFilePath(fileId), event); 358 } 359 ObtainLinearFileSize(int fileId,const std::string & path,const AppExecFwk::InnerEvent::Pointer & event)360 void IccFileController::ObtainLinearFileSize( 361 int fileId, const std::string &path, const AppExecFwk::InnerEvent::Pointer &event) 362 { 363 std::string filePath = CheckRightPath(path, fileId); 364 std::shared_ptr<IccControllerHolder> ctrlHolder = std::make_shared<IccControllerHolder>(fileId, filePath); 365 ctrlHolder->fileLoaded = std::move(const_cast<AppExecFwk::InnerEvent::Pointer &>(event)); 366 AppExecFwk::InnerEvent::Pointer process = 367 BuildCallerInfo(MSG_SIM_OBTAIN_SIZE_OF_LINEAR_ELEMENTARY_FILE_DONE, ctrlHolder); 368 if (telRilManager_ != nullptr) { 369 SimIoRequestInfo msg; 370 msg.command = CONTROLLER_REQ_GET_RESPONSE; 371 msg.fileId = fileId; 372 msg.p1 = 0; 373 msg.p2 = 0; 374 msg.p3 = GET_RESPONSE_ELEMENTARY_FILE_SIZE_BYTES; 375 msg.data = IccFileController::NULLSTR; 376 msg.path = filePath; 377 msg.pin2 = ""; 378 telRilManager_->GetSimIO(slotId_, msg, process); 379 } 380 } 381 ObtainLinearFileSize(int fileId,const AppExecFwk::InnerEvent::Pointer & event)382 void IccFileController::ObtainLinearFileSize(int fileId, const AppExecFwk::InnerEvent::Pointer &event) 383 { 384 ObtainLinearFileSize(fileId, ObtainElementFilePath(fileId), event); 385 } 386 UpdateLinearFixedFile(int fileId,const std::string & path,int fileNum,std::string data,int dataLength,const std::string pin2,const AppExecFwk::InnerEvent::Pointer & onComplete)387 void IccFileController::UpdateLinearFixedFile(int fileId, const std::string &path, int fileNum, std::string data, 388 int dataLength, const std::string pin2, const AppExecFwk::InnerEvent::Pointer &onComplete) 389 { 390 std::string filePath = CheckRightPath(path, fileId); 391 std::shared_ptr<IccControllerHolder> ctrlHolder = std::make_shared<IccControllerHolder>(fileId); 392 ctrlHolder->fileLoaded = std::move(const_cast<AppExecFwk::InnerEvent::Pointer &>(onComplete)); 393 AppExecFwk::InnerEvent::Pointer process = BuildCallerInfo(MSG_SIM_UPDATE_LINEAR_FIXED_FILE_DONE, ctrlHolder); 394 if (telRilManager_ != nullptr) { 395 SimIoRequestInfo msg; 396 msg.command = CONTROLLER_REQ_UPDATE_RECORD; 397 msg.fileId = fileId; 398 msg.p1 = fileNum; 399 msg.p2 = ICC_FILE_CURRENT_MODE; 400 msg.p3 = dataLength; 401 msg.data = data; 402 msg.path = filePath; 403 msg.pin2 = pin2; 404 telRilManager_->GetSimIO(slotId_, msg, process); 405 } 406 } 407 UpdateLinearFixedFile(int fileId,int fileNum,const std::string data,int dataLength,const std::string pin2,const AppExecFwk::InnerEvent::Pointer & onComplete)408 void IccFileController::UpdateLinearFixedFile(int fileId, int fileNum, const std::string data, int dataLength, 409 const std::string pin2, const AppExecFwk::InnerEvent::Pointer &onComplete) 410 { 411 std::shared_ptr<IccControllerHolder> ctrlHolder = std::make_shared<IccControllerHolder>(fileId); 412 ctrlHolder->fileLoaded = std::move(const_cast<AppExecFwk::InnerEvent::Pointer &>(onComplete)); 413 AppExecFwk::InnerEvent::Pointer process = BuildCallerInfo(MSG_SIM_UPDATE_LINEAR_FIXED_FILE_DONE, ctrlHolder); 414 if (telRilManager_ != nullptr) { 415 SimIoRequestInfo msg; 416 msg.command = CONTROLLER_REQ_UPDATE_RECORD; 417 msg.fileId = fileId; 418 msg.p1 = fileNum; 419 msg.p2 = ICC_FILE_CURRENT_MODE; 420 msg.p3 = dataLength; 421 msg.data = data; 422 msg.path = ObtainElementFilePath(fileId); 423 msg.pin2 = pin2; 424 telRilManager_->GetSimIO(slotId_, msg, process); 425 } 426 } 427 UpdateBinaryFile(int fileId,const std::string data,int dataLength,const AppExecFwk::InnerEvent::Pointer & onComplete)428 void IccFileController::UpdateBinaryFile( 429 int fileId, const std::string data, int dataLength, const AppExecFwk::InnerEvent::Pointer &onComplete) 430 { 431 std::shared_ptr<IccControllerHolder> ctrlHolder = std::make_shared<IccControllerHolder>(fileId); 432 ctrlHolder->fileLoaded = std::move(const_cast<AppExecFwk::InnerEvent::Pointer &>(onComplete)); 433 AppExecFwk::InnerEvent::Pointer process = 434 BuildCallerInfo(MSG_SIM_UPDATE_TRANSPARENT_ELEMENTARY_FILE_DONE, ctrlHolder); 435 if (telRilManager_ != nullptr) { 436 SimIoRequestInfo msg; 437 msg.command = CONTROLLER_REQ_UPDATE_BINARY; 438 msg.fileId = fileId; 439 msg.p1 = 0; 440 msg.p2 = 0; 441 msg.p3 = dataLength; 442 msg.data = data; 443 msg.path = ObtainElementFilePath(fileId); 444 msg.pin2 = ""; 445 telRilManager_->GetSimIO(slotId_, msg, process); 446 } 447 } 448 SendResponse(std::shared_ptr<IccControllerHolder> holder,const IccFileData * fd)449 void IccFileController::SendResponse(std::shared_ptr<IccControllerHolder> holder, const IccFileData *fd) 450 { 451 if (holder == nullptr || fd == nullptr) { 452 TELEPHONY_LOGE("IccFileController::SendResponse result is null"); 453 return; 454 } 455 AppExecFwk::InnerEvent::Pointer &response = holder->fileLoaded; 456 bool isNull = (response == nullptr); 457 auto owner = response->GetOwner(); 458 if (owner == nullptr) { 459 TELEPHONY_LOGE("owner is nullptr"); 460 return; 461 } 462 std::unique_ptr<FileToControllerMsg> cmdData = response->GetUniqueObject<FileToControllerMsg>(); 463 uint32_t id = response->GetInnerEventId(); 464 bool needShare = (id == MSG_SIM_OBTAIN_ICC_FILE_DONE); 465 std::unique_ptr<ControllerToFileMsg> objectUnique = nullptr; 466 std::shared_ptr<ControllerToFileMsg> objectShare = nullptr; 467 TELEPHONY_LOGD("IccFileController::SendResponse start response %{public}d %{public}d", isNull, needShare); 468 if (needShare) { 469 objectShare = std::make_shared<ControllerToFileMsg>(cmdData.get(), fd); 470 } else { 471 objectUnique = std::make_unique<ControllerToFileMsg>(cmdData.get(), fd); 472 } 473 474 if ((objectUnique == nullptr) && (objectShare == nullptr)) { 475 TELEPHONY_LOGE("IccFileController::SendResponse create ControllerToFileMsg is null"); 476 return; 477 } 478 479 isNull = (owner == nullptr); 480 TELEPHONY_LOGD("IccFileController::SendResponse owner: %{public}d evtId: %{public}d", isNull, id); 481 SendEvent(owner, id, needShare, objectShare, objectUnique); 482 TELEPHONY_LOGD("IccFileController::SendResponse send end"); 483 } 484 SendEfLinearResult(const AppExecFwk::InnerEvent::Pointer & response,const int val[],int len)485 void IccFileController::SendEfLinearResult(const AppExecFwk::InnerEvent::Pointer &response, const int val[], int len) 486 { 487 if (response == nullptr) { 488 TELEPHONY_LOGE("response is nullptr!"); 489 return; 490 } 491 std::shared_ptr<AppExecFwk::EventHandler> handler = response->GetOwner(); 492 if (handler == nullptr) { 493 TELEPHONY_LOGE("handler is nullptr!"); 494 return; 495 } 496 std::unique_ptr<FileToControllerMsg> cmdData = response->GetUniqueObject<FileToControllerMsg>(); 497 std::shared_ptr<EfLinearResult> object = std::make_shared<EfLinearResult>(cmdData.get()); 498 object->valueData[0] = val[0]; 499 object->valueData[1] = val[1]; 500 object->valueData[MAX_FILE_INDEX] = val[MAX_FILE_INDEX]; 501 uint32_t id = response->GetInnerEventId(); 502 int eventParam = 0; 503 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(id, object, eventParam); 504 if (event == nullptr) { 505 TELEPHONY_LOGE("event is nullptr!"); 506 return; 507 } 508 TelEventHandler::SendTelEvent(handler, event); 509 } 510 SendMultiRecordResult(const AppExecFwk::InnerEvent::Pointer & response,std::vector<std::string> & strValue)511 void IccFileController::SendMultiRecordResult( 512 const AppExecFwk::InnerEvent::Pointer &response, std::vector<std::string> &strValue) 513 { 514 if (response == nullptr) { 515 TELEPHONY_LOGE("response is nullptr!"); 516 return; 517 } 518 std::shared_ptr<AppExecFwk::EventHandler> handler = response->GetOwner(); 519 if (handler == nullptr) { 520 TELEPHONY_LOGE("handler is nullptr!"); 521 return; 522 } 523 std::unique_ptr<FileToControllerMsg> cmdData = response->GetUniqueObject<FileToControllerMsg>(); 524 std::shared_ptr<MultiRecordResult> object = std::make_shared<MultiRecordResult>(cmdData.get()); 525 object->fileResults.assign(strValue.begin(), strValue.end()); 526 object->resultLength = static_cast<int>(strValue.size()); 527 uint32_t id = response->GetInnerEventId(); 528 int eventParam = 0; 529 TELEPHONY_LOGI("IccFileController::SendMultiRecordResult send end"); 530 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(id, object, eventParam); 531 if (event == nullptr) { 532 TELEPHONY_LOGE("event is nullptr!"); 533 return; 534 } 535 TelEventHandler::SendTelEvent(handler, event); 536 } 537 BuildCallerInfo(int eventId,std::shared_ptr<IccControllerHolder> & holderObject)538 AppExecFwk::InnerEvent::Pointer IccFileController::BuildCallerInfo( 539 int eventId, std::shared_ptr<IccControllerHolder> &holderObject) 540 { 541 std::unique_ptr<IccToRilMsg> msgTo = std::make_unique<IccToRilMsg>(holderObject); 542 if (msgTo == nullptr) { 543 TELEPHONY_LOGE("IccFileController::BuildCallerInfo1 create null pointer"); 544 return AppExecFwk::InnerEvent::Pointer(nullptr, nullptr); 545 } 546 int64_t eventParam = 0; 547 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(eventId, msgTo, eventParam); 548 if (event == nullptr) { 549 TELEPHONY_LOGE("event is nullptr!"); 550 return AppExecFwk::InnerEvent::Pointer(nullptr, nullptr); 551 } 552 event->SetOwner(shared_from_this()); 553 return event; 554 } 555 BuildCallerInfo(int eventId,int arg1,int arg2,std::shared_ptr<IccControllerHolder> & holderObject)556 AppExecFwk::InnerEvent::Pointer IccFileController::BuildCallerInfo( 557 int eventId, int arg1, int arg2, std::shared_ptr<IccControllerHolder> &holderObject) 558 { 559 std::unique_ptr<IccToRilMsg> msgTo = std::make_unique<IccToRilMsg>(holderObject); 560 if (msgTo == nullptr) { 561 TELEPHONY_LOGE("IccFileController::BuildCallerInfo2 create null pointer"); 562 return AppExecFwk::InnerEvent::Pointer(nullptr, nullptr); 563 } 564 msgTo->arg1 = arg1; 565 msgTo->arg2 = arg2; 566 int64_t eventParam = 0; 567 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(eventId, msgTo, eventParam); 568 if (event == nullptr) { 569 TELEPHONY_LOGE("event is nullptr!"); 570 return AppExecFwk::InnerEvent::Pointer(nullptr, nullptr); 571 } 572 event->SetOwner(shared_from_this()); 573 return event; 574 } 575 BuildCallerInfo(int eventId,int arg1,int arg2,const AppExecFwk::InnerEvent::Pointer & msg)576 AppExecFwk::InnerEvent::Pointer IccFileController::BuildCallerInfo( 577 int eventId, int arg1, int arg2, const AppExecFwk::InnerEvent::Pointer &msg) 578 { 579 std::shared_ptr<IccControllerHolder> ctrlHolder = std::make_shared<IccControllerHolder>(arg1); 580 if (ctrlHolder == nullptr) { 581 TELEPHONY_LOGE("ctrlHolder is nullptr!"); 582 return AppExecFwk::InnerEvent::Pointer(nullptr, nullptr); 583 } 584 ctrlHolder->fileLoaded = std::move(const_cast<AppExecFwk::InnerEvent::Pointer &>(msg)); 585 if (ctrlHolder->fileLoaded == nullptr) { 586 TELEPHONY_LOGE("ctrlHolder->fileLoaded is nullptr!"); 587 return AppExecFwk::InnerEvent::Pointer(nullptr, nullptr); 588 } 589 bool isNull = ctrlHolder->fileLoaded->GetOwner() == nullptr; 590 TELEPHONY_LOGD("IccFileController::BuildCallerInfo stage init owner: %{public}d", isNull); 591 std::unique_ptr<IccToRilMsg> msgTo = std::make_unique<IccToRilMsg>(ctrlHolder); 592 if (msgTo == nullptr) { 593 TELEPHONY_LOGE("IccFileController::BuildCallerInfo3 create null pointer"); 594 return AppExecFwk::InnerEvent::Pointer(nullptr, nullptr); 595 } 596 TELEPHONY_LOGD("IccFileController::BuildCallerInfo stage end"); 597 msgTo->arg1 = arg1; 598 msgTo->arg2 = arg2; 599 int64_t eventParam = 0; 600 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(eventId, msgTo, eventParam); 601 if (event == nullptr) { 602 TELEPHONY_LOGE("event is nullptr!"); 603 return AppExecFwk::InnerEvent::Pointer(nullptr, nullptr); 604 } 605 event->SetOwner(shared_from_this()); 606 return event; 607 } 608 ParseFileSize(int val[],int len,const unsigned char * data)609 void IccFileController::ParseFileSize(int val[], int len, const unsigned char *data) 610 { 611 if (data == nullptr) { 612 TELEPHONY_LOGE("ParseFileSize null data"); 613 return; 614 } 615 if (len > MAX_FILE_INDEX) { 616 GetFileAndDataSize(data, val[0], val[1]); 617 if (val[0] != 0) { 618 val[MAX_FILE_INDEX] = val[1] / val[0]; 619 } 620 } 621 TELEPHONY_LOGD("ParseFileSize result %{public}d, %{public}d %{public}d", val[0], val[1], val[MAX_FILE_INDEX]); 622 } IsValidRecordSizeData(const unsigned char * data)623 bool IccFileController::IsValidRecordSizeData(const unsigned char *data) 624 { 625 if (data == nullptr) { 626 TELEPHONY_LOGE("IccFileTypeMismatch ERROR nullptr"); 627 return false; 628 } 629 if (ICC_ELEMENTARY_FILE != data[TYPE_OF_FILE]) { 630 TELEPHONY_LOGE("IccFileTypeMismatch ERROR TYPE_OF_FILE"); 631 return false; 632 } 633 if (ELEMENTARY_FILE_TYPE_LINEAR_FIXED != data[STRUCTURE_OF_DATA]) { 634 TELEPHONY_LOGE("IccFileTypeMismatch ERROR STRUCTURE_OF_DATA"); 635 return false; 636 } 637 return true; 638 } IsValidBinarySizeData(const unsigned char * data)639 bool IccFileController::IsValidBinarySizeData(const unsigned char *data) 640 { 641 if (data == nullptr) { 642 TELEPHONY_LOGE("IccFileTypeMismatch ERROR nullptr"); 643 return false; 644 } 645 if (ICC_ELEMENTARY_FILE != data[TYPE_OF_FILE]) { 646 TELEPHONY_LOGE("IccFileTypeMismatch ERROR TYPE_OF_FILE"); 647 return false; 648 } 649 if (ELEMENTARY_FILE_TYPE_TRANSPARENT != data[STRUCTURE_OF_DATA]) { 650 TELEPHONY_LOGE("IccFileTypeMismatch ERROR STRUCTURE_OF_DATA"); 651 return false; 652 } 653 return true; 654 } GetFileAndDataSize(const unsigned char * data,int & fileSize,int & dataSize)655 void IccFileController::GetFileAndDataSize(const unsigned char *data, int &fileSize, int &dataSize) 656 { 657 if (data == nullptr) { 658 TELEPHONY_LOGE("GetFileAndDataSize null data"); 659 return; 660 } 661 fileSize = data[LENGTH_OF_RECORD] & BYTE_NUM; 662 dataSize = ((data[SIZE_ONE_OF_FILE] & BYTE_NUM) << OFFSET) + (data[SIZE_TWO_OF_FILE] & BYTE_NUM); 663 } GetDataSize(const unsigned char * data,int & dataSize)664 void IccFileController::GetDataSize(const unsigned char *data, int &dataSize) 665 { 666 if (data == nullptr) { 667 TELEPHONY_LOGE("GetDataSize null data"); 668 return; 669 } 670 dataSize = ((data[SIZE_ONE_OF_FILE] & BYTE_NUM) << OFFSET) + (data[SIZE_TWO_OF_FILE] & BYTE_NUM); 671 } 672 SetRilManager(std::shared_ptr<Telephony::ITelRilManager> ril)673 void IccFileController::SetRilManager(std::shared_ptr<Telephony::ITelRilManager> ril) 674 { 675 telRilManager_ = ril; 676 if (telRilManager_ == nullptr) { 677 TELEPHONY_LOGE("IccFileController set NULL TelRilManager!!"); 678 } 679 } 680 CheckRightPath(const std::string & path,int fileId)681 std::string IccFileController::CheckRightPath(const std::string &path, int fileId) 682 { 683 if (path.empty()) { 684 return ObtainElementFilePath(fileId); 685 } else { 686 return path; 687 } 688 } 689 ProcessErrorResponse(const AppExecFwk::InnerEvent::Pointer & event)690 bool IccFileController::ProcessErrorResponse(const AppExecFwk::InnerEvent::Pointer &event) 691 { 692 std::shared_ptr<IccFromRilMsg> rcvMsg = event->GetSharedObject<IccFromRilMsg>(); 693 if (rcvMsg == nullptr || rcvMsg->controlHolder == nullptr) { 694 return false; 695 } 696 AppExecFwk::InnerEvent::Pointer &response = rcvMsg->controlHolder->fileLoaded; 697 if (response == nullptr) { 698 return false; 699 } 700 auto owner = response->GetOwner(); 701 if (owner == nullptr) { 702 TELEPHONY_LOGE("owner is nullptr"); 703 return false; 704 } 705 uint32_t id = response->GetInnerEventId(); 706 std::unique_ptr<FileToControllerMsg> cmdData = response->GetUniqueObject<FileToControllerMsg>(); 707 bool needShare = (id == MSG_SIM_OBTAIN_ICC_FILE_DONE); 708 std::unique_ptr<ControllerToFileMsg> objectUnique = nullptr; 709 std::shared_ptr<ControllerToFileMsg> objectShare = nullptr; 710 TELEPHONY_LOGD("ProcessErrorResponse start response %{public}d", needShare); 711 if (needShare) { 712 objectShare = std::make_shared<ControllerToFileMsg>(cmdData.get(), nullptr); 713 if (objectShare == nullptr) { 714 return false; 715 } 716 objectShare->exception = rcvMsg->fileData.exception; 717 } else { 718 objectUnique = std::make_unique<ControllerToFileMsg>(cmdData.get(), nullptr); 719 objectUnique->exception = rcvMsg->fileData.exception; 720 } 721 722 if ((objectUnique == nullptr) && (objectShare == nullptr)) { 723 TELEPHONY_LOGE("ProcessErrorResponse create ControllerToFileMsg is null"); 724 return true; 725 } 726 727 TELEPHONY_LOGI("ProcessErrorResponse owner: evtId: %{public}d", id); 728 SendEvent(owner, id, needShare, objectShare, objectUnique); 729 TELEPHONY_LOGD("ProcessErrorResponse send end"); 730 return true; 731 } 732 SendEvent(std::shared_ptr<AppExecFwk::EventHandler> handler,uint32_t id,bool needShare,std::shared_ptr<ControllerToFileMsg> objectShare,std::unique_ptr<ControllerToFileMsg> & objectUnique)733 void IccFileController::SendEvent(std::shared_ptr<AppExecFwk::EventHandler> handler, uint32_t id, bool needShare, 734 std::shared_ptr<ControllerToFileMsg> objectShare, std::unique_ptr<ControllerToFileMsg> &objectUnique) 735 { 736 if (needShare) { 737 TelEventHandler::SendTelEvent(handler, id, objectShare); 738 return; 739 } 740 TelEventHandler::SendTelEvent(handler, id, objectUnique); 741 } 742 IsFixedNumberType(int efId)743 bool IccFileController::IsFixedNumberType(int efId) 744 { 745 bool fixed = false; 746 switch (efId) { 747 case ELEMENTARY_FILE_ADN: 748 case ELEMENTARY_FILE_FDN: 749 case ELEMENTARY_FILE_USIM_ADN: 750 case ELEMENTARY_FILE_USIM_IAP: 751 fixed = true; 752 return fixed; 753 default: 754 break; 755 } 756 return fixed; 757 } 758 ~IccFileController()759 IccFileController::~IccFileController() {} 760 } // namespace Telephony 761 } // namespace OHOS 762