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