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