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