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