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 "hril_sim.h"
17
18 #include "hril_notification.h"
19 #include "hril_request.h"
20 namespace OHOS {
21 namespace Telephony {
HRilSim(int32_t slotId)22 HRilSim::HRilSim(int32_t slotId) : HRilBase(slotId)
23 {
24 AddNotificationHandlerToMap();
25 AddBasicHandlerToMap();
26 AddSimLockHandlerToMap();
27 AddStkHandlerToMap();
28 }
29
IsSimRespOrNotify(uint32_t code)30 bool HRilSim::IsSimRespOrNotify(uint32_t code)
31 {
32 return IsSimResponse(code) || IsSimNotification(code);
33 }
34
RegisterSimFuncs(const HRilSimReq * simFuncs)35 void HRilSim::RegisterSimFuncs(const HRilSimReq *simFuncs)
36 {
37 simFuncs_ = simFuncs;
38 }
39
AddBasicHandlerToMap()40 void HRilSim::AddBasicHandlerToMap()
41 {
42 // response
43 respMemberFuncMap_[HREQ_SIM_GET_SIM_IO] =
44 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
45 size_t responseLen) { return GetSimIOResponse(requestNum, responseInfo, response, responseLen); };
46 respMemberFuncMap_[HREQ_SIM_GET_SIM_STATUS] =
47 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
48 size_t responseLen) { return GetSimCardStatusResponse(requestNum, responseInfo, response, responseLen); };
49 respMemberFuncMap_[HREQ_SIM_GET_IMSI] =
50 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
51 size_t responseLen) { return GetImsiResponse(requestNum, responseInfo, response, responseLen); };
52 respMemberFuncMap_[HREQ_SIM_SET_ACTIVE_SIM] =
53 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
54 size_t responseLen) { return SetActiveSimResponse(requestNum, responseInfo, response, responseLen); };
55 respMemberFuncMap_[HREQ_SIM_GET_RADIO_PROTOCOL] =
56 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
57 size_t responseLen) { return GetRadioProtocolResponse(requestNum, responseInfo, response, responseLen); };
58 respMemberFuncMap_[HREQ_SIM_SET_RADIO_PROTOCOL] =
59 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
60 size_t responseLen) { return SetRadioProtocolResponse(requestNum, responseInfo, response, responseLen); };
61 respMemberFuncMap_[HREQ_SIM_OPEN_LOGICAL_CHANNEL] =
62 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
63 size_t responseLen) { return SimOpenLogicalChannelResponse(requestNum, responseInfo, response, responseLen); };
64 respMemberFuncMap_[HREQ_SIM_CLOSE_LOGICAL_CHANNEL] =
65 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
66 size_t responseLen) { return SimCloseLogicalChannelResponse(requestNum, responseInfo, response, responseLen); };
67 respMemberFuncMap_[HREQ_SIM_TRANSMIT_APDU_LOGICAL_CHANNEL] = [this](int32_t requestNum,
68 HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen) {
69 return SimTransmitApduLogicalChannelResponse(requestNum, responseInfo, response, responseLen);
70 };
71 respMemberFuncMap_[HREQ_SIM_TRANSMIT_APDU_BASIC_CHANNEL] = [this](int32_t requestNum,
72 HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen) {
73 return SimTransmitApduBasicChannelResponse(requestNum, responseInfo, response, responseLen);
74 };
75 respMemberFuncMap_[HREQ_SIM_SEND_NCFG_OPER_INFO] = [this](int32_t requestNum,
76 HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen) {
77 return SendSimMatchedOperatorInfoResponse(requestNum, responseInfo, response, responseLen);
78 };
79 }
80
AddSimLockHandlerToMap()81 void HRilSim::AddSimLockHandlerToMap()
82 {
83 respMemberFuncMap_[HREQ_SIM_GET_SIM_LOCK_STATUS] =
84 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
85 size_t responseLen) { return GetSimLockStatusResponse(requestNum, responseInfo, response, responseLen); };
86 respMemberFuncMap_[HREQ_SIM_SET_SIM_LOCK] =
87 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
88 size_t responseLen) { return SetSimLockResponse(requestNum, responseInfo, response, responseLen); };
89 respMemberFuncMap_[HREQ_SIM_CHANGE_SIM_PASSWORD] =
90 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
91 size_t responseLen) { return ChangeSimPasswordResponse(requestNum, responseInfo, response, responseLen); };
92 respMemberFuncMap_[HREQ_SIM_UNLOCK_PIN] =
93 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
94 size_t responseLen) { return UnlockPinResponse(requestNum, responseInfo, response, responseLen); };
95 respMemberFuncMap_[HREQ_SIM_UNLOCK_PUK] =
96 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
97 size_t responseLen) { return UnlockPukResponse(requestNum, responseInfo, response, responseLen); };
98 respMemberFuncMap_[HREQ_SIM_UNLOCK_PIN2] =
99 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
100 size_t responseLen) { return UnlockPin2Response(requestNum, responseInfo, response, responseLen); };
101 respMemberFuncMap_[HREQ_SIM_UNLOCK_PUK2] =
102 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
103 size_t responseLen) { return UnlockPuk2Response(requestNum, responseInfo, response, responseLen); };
104 respMemberFuncMap_[HREQ_SIM_AUTHENTICATION] =
105 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
106 size_t responseLen) { return SimAuthenticationResponse(requestNum, responseInfo, response, responseLen); };
107 respMemberFuncMap_[HREQ_SIM_UNLOCK_SIM_LOCK] =
108 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
109 size_t responseLen) { return UnlockSimLockResponse(requestNum, responseInfo, response, responseLen); };
110 }
111
AddStkHandlerToMap()112 void HRilSim::AddStkHandlerToMap()
113 {
114 respMemberFuncMap_[HREQ_SIM_STK_SEND_TERMINAL_RESPONSE] = [this](int32_t requestNum,
115 HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen) {
116 return SimStkSendTerminalResponseResponse(requestNum, responseInfo, response, responseLen);
117 };
118 respMemberFuncMap_[HREQ_SIM_STK_SEND_ENVELOPE] =
119 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
120 size_t responseLen) { return SimStkSendEnvelopeResponse(requestNum, responseInfo, response, responseLen); };
121 respMemberFuncMap_[HREQ_SIM_STK_SEND_CALL_SETUP_REQUEST_RESULT] = [this](int32_t requestNum,
122 HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen) {
123 return SimStkSendCallSetupRequestResultResponse(requestNum, responseInfo, response, responseLen);
124 };
125 respMemberFuncMap_[HREQ_SIM_STK_IS_READY] =
126 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
127 size_t responseLen) { return SimStkIsReadyResponse(requestNum, responseInfo, response, responseLen); };
128 }
129
AddNotificationHandlerToMap()130 void HRilSim::AddNotificationHandlerToMap()
131 {
132 // Notification
133 notiMemberFuncMap_[HNOTI_SIM_STATUS_CHANGED] =
134 [this](int32_t notifyType, HRilErrNumber error, const void *response,
135 size_t responseLen) { return SimStateUpdated(notifyType, error, response, responseLen); };
136 notiMemberFuncMap_[HNOTI_SIM_STK_SESSION_END_NOTIFY] =
137 [this](int32_t notifyType, HRilErrNumber error, const void *response,
138 size_t responseLen) { return SimStkSessionEndNotify(notifyType, error, response, responseLen); };
139 notiMemberFuncMap_[HNOTI_SIM_STK_PROACTIVE_NOTIFY] =
140 [this](int32_t notifyType, HRilErrNumber error, const void *response,
141 size_t responseLen) { return SimStkProactiveNotify(notifyType, error, response, responseLen); };
142 notiMemberFuncMap_[HNOTI_SIM_STK_ALPHA_NOTIFY] =
143 [this](int32_t notifyType, HRilErrNumber error, const void *response,
144 size_t responseLen) { return SimStkAlphaNotify(notifyType, error, response, responseLen); };
145 notiMemberFuncMap_[HNOTI_SIM_STK_EVENT_NOTIFY] =
146 [this](int32_t notifyType, HRilErrNumber error, const void *response,
147 size_t responseLen) { return SimStkEventNotify(notifyType, error, response, responseLen); };
148 notiMemberFuncMap_[HNOTI_SIM_STK_CALL_SETUP_NOTIFY] =
149 [this](int32_t notifyType, HRilErrNumber error, const void *response,
150 size_t responseLen) { return SimStkCallSetupNotify(notifyType, error, response, responseLen); };
151 notiMemberFuncMap_[HNOTI_SIM_REFRESH_NOTIFY] =
152 [this](int32_t notifyType, HRilErrNumber error, const void *response,
153 size_t responseLen) { return SimRefreshNotify(notifyType, error, response, responseLen); };
154 notiMemberFuncMap_[HNOTI_SIM_RADIO_PROTOCOL_UPDATED] =
155 [this](int32_t notifyType, HRilErrNumber error, const void *response,
156 size_t responseLen) { return SimRadioProtocolUpdated(notifyType, error, response, responseLen); };
157 }
158
GetSimIO(int32_t serialId,const OHOS::HDI::Ril::V1_1::SimIoRequestInfo & simIO)159 int32_t HRilSim::GetSimIO(int32_t serialId, const OHOS::HDI::Ril::V1_1::SimIoRequestInfo &simIO)
160 {
161 std::unique_ptr<HRilSimIO> rilSimIO = std::make_unique<HRilSimIO>();
162 CopyToHRilSimIO(rilSimIO, simIO);
163 int32_t ret = RequestVendor(
164 serialId, HREQ_SIM_GET_SIM_IO, simFuncs_, &HRilSimReq::GetSimIO, rilSimIO.get(), sizeof(*rilSimIO));
165 SafeFrees(rilSimIO->data, rilSimIO->pathid, rilSimIO->pin2);
166 return ret;
167 }
168
GetSimStatus(int32_t serialId)169 int32_t HRilSim::GetSimStatus(int32_t serialId)
170 {
171 return RequestVendor(serialId, HREQ_SIM_GET_SIM_STATUS, simFuncs_, &HRilSimReq::GetSimStatus);
172 }
173
GetImsi(int32_t serialId)174 int32_t HRilSim::GetImsi(int32_t serialId)
175 {
176 return RequestVendor(serialId, HREQ_SIM_GET_IMSI, simFuncs_, &HRilSimReq::GetSimImsi);
177 }
178
GetSimLockStatus(int32_t serialId,const OHOS::HDI::Ril::V1_1::SimLockInfo & simLockInfo)179 int32_t HRilSim::GetSimLockStatus(int32_t serialId, const OHOS::HDI::Ril::V1_1::SimLockInfo &simLockInfo)
180 {
181 std::unique_ptr<HRilSimClock> rilSimLock = std::make_unique<HRilSimClock>();
182 CopyToHRilSimLock(rilSimLock, simLockInfo);
183 int32_t ret = RequestVendor(serialId, HREQ_SIM_GET_SIM_LOCK_STATUS, simFuncs_, &HRilSimReq::GetSimLockStatus,
184 rilSimLock.get(), sizeof(*rilSimLock));
185 SafeFrees(rilSimLock->fac, rilSimLock->passwd);
186 return ret;
187 }
188
SetSimLock(int32_t serialId,const OHOS::HDI::Ril::V1_1::SimLockInfo & simLockInfo)189 int32_t HRilSim::SetSimLock(int32_t serialId, const OHOS::HDI::Ril::V1_1::SimLockInfo &simLockInfo)
190 {
191 std::unique_ptr<HRilSimClock> rilSimLock = std::make_unique<HRilSimClock>();
192 CopyToHRilSimLock(rilSimLock, simLockInfo);
193 int32_t ret = RequestVendor(
194 serialId, HREQ_SIM_SET_SIM_LOCK, simFuncs_, &HRilSimReq::SetSimLock, rilSimLock.get(), sizeof(*rilSimLock));
195 SafeFrees(rilSimLock->fac, rilSimLock->passwd);
196 return ret;
197 }
198
ChangeSimPassword(int32_t serialId,const OHOS::HDI::Ril::V1_1::SimPasswordInfo & simPassword)199 int32_t HRilSim::ChangeSimPassword(int32_t serialId, const OHOS::HDI::Ril::V1_1::SimPasswordInfo &simPassword)
200 {
201 std::unique_ptr<HRilSimPassword> rilSimPassword = std::make_unique<HRilSimPassword>();
202 CopyToHRilSimPassword(rilSimPassword, simPassword);
203 int32_t ret = RequestVendor(serialId, HREQ_SIM_CHANGE_SIM_PASSWORD, simFuncs_, &HRilSimReq::ChangeSimPassword,
204 rilSimPassword.get(), sizeof(*rilSimPassword));
205 SafeFrees(rilSimPassword->fac, rilSimPassword->oldPassword, rilSimPassword->newPassword);
206 return ret;
207 }
208
UnlockPin(int32_t serialId,const std::string & pin)209 int32_t HRilSim::UnlockPin(int32_t serialId, const std::string &pin)
210 {
211 char *pinPoint = nullptr;
212 CopyToCharPoint(&pinPoint, pin);
213 int32_t ret = RequestVendor(serialId, HREQ_SIM_UNLOCK_PIN, simFuncs_, &HRilSimReq::UnlockPin, pinPoint);
214 SafeFrees(pinPoint);
215 return ret;
216 }
217
UnlockPuk(int32_t serialId,const std::string & puk,const std::string & pin)218 int32_t HRilSim::UnlockPuk(int32_t serialId, const std::string &puk, const std::string &pin)
219 {
220 char *pukPoint = nullptr;
221 CopyToCharPoint(&pukPoint, puk);
222 char *pinPoint = nullptr;
223 CopyToCharPoint(&pinPoint, pin);
224 int32_t ret = RequestVendor(serialId, HREQ_SIM_UNLOCK_PUK, simFuncs_, &HRilSimReq::UnlockPuk, pukPoint, pinPoint);
225 SafeFrees(pukPoint, pinPoint);
226 return ret;
227 }
228
UnlockPin2(int32_t serialId,const std::string & pin2)229 int32_t HRilSim::UnlockPin2(int32_t serialId, const std::string &pin2)
230 {
231 char *pin2Point = nullptr;
232 CopyToCharPoint(&pin2Point, pin2);
233 int32_t ret = RequestVendor(serialId, HREQ_SIM_UNLOCK_PIN2, simFuncs_, &HRilSimReq::UnlockPin2, pin2Point);
234 SafeFrees(pin2Point);
235 return ret;
236 }
237
UnlockPuk2(int32_t serialId,const std::string & puk2,const std::string & pin2)238 int32_t HRilSim::UnlockPuk2(int32_t serialId, const std::string &puk2, const std::string &pin2)
239 {
240 char *puk2Point = nullptr;
241 CopyToCharPoint(&puk2Point, puk2);
242 char *pin2Point = nullptr;
243 CopyToCharPoint(&pin2Point, pin2);
244 int32_t ret =
245 RequestVendor(serialId, HREQ_SIM_UNLOCK_PUK2, simFuncs_, &HRilSimReq::UnlockPuk2, puk2Point, pin2Point);
246 SafeFrees(puk2Point, pin2Point);
247 return ret;
248 }
249
SetActiveSim(int32_t serialId,int32_t index,int32_t enable)250 int32_t HRilSim::SetActiveSim(int32_t serialId, int32_t index, int32_t enable)
251 {
252 return RequestVendor(serialId, HREQ_SIM_SET_ACTIVE_SIM, simFuncs_, &HRilSimReq::SetActiveSim, index, enable);
253 }
254
SimStkSendTerminalResponse(int32_t serialId,const std::string & strCmd)255 int32_t HRilSim::SimStkSendTerminalResponse(int32_t serialId, const std::string &strCmd)
256 {
257 char *strCmdPoint = nullptr;
258 CopyToCharPoint(&strCmdPoint, strCmd);
259 int32_t ret = RequestVendor(
260 serialId, HREQ_SIM_STK_SEND_TERMINAL_RESPONSE, simFuncs_, &HRilSimReq::SimStkSendTerminalResponse, strCmdPoint);
261 SafeFrees(strCmdPoint);
262 return ret;
263 }
264
SimStkSendEnvelope(int32_t serialId,const std::string & strCmd)265 int32_t HRilSim::SimStkSendEnvelope(int32_t serialId, const std::string &strCmd)
266 {
267 char *strCmdPoint = nullptr;
268 CopyToCharPoint(&strCmdPoint, strCmd);
269 int32_t ret =
270 RequestVendor(serialId, HREQ_SIM_STK_SEND_ENVELOPE, simFuncs_, &HRilSimReq::SimStkSendEnvelope, strCmdPoint);
271 SafeFrees(strCmdPoint);
272 return ret;
273 }
274
SimStkSendCallSetupRequestResult(int32_t serialId,int32_t accept)275 int32_t HRilSim::SimStkSendCallSetupRequestResult(int32_t serialId, int32_t accept)
276 {
277 return RequestVendor(serialId, HREQ_SIM_STK_SEND_CALL_SETUP_REQUEST_RESULT, simFuncs_,
278 &HRilSimReq::SimStkSendCallSetupRequestResult, accept);
279 }
280
SimStkIsReady(int32_t serialId)281 int32_t HRilSim::SimStkIsReady(int32_t serialId)
282 {
283 return RequestVendor(serialId, HREQ_SIM_STK_IS_READY, simFuncs_, &HRilSimReq::SimStkIsReady);
284 }
285
GetRadioProtocol(int32_t serialId)286 int32_t HRilSim::GetRadioProtocol(int32_t serialId)
287 {
288 TELEPHONY_LOGI("HRilSim::GetRadioProtocol slotId:%{public}d", GetSlotId());
289 return RequestVendor(serialId, HREQ_SIM_GET_RADIO_PROTOCOL, simFuncs_, &HRilSimReq::GetRadioProtocol);
290 }
291
SetRadioProtocol(int32_t serialId,const HDI::Ril::V1_1::RadioProtocol & radioProtocol)292 int32_t HRilSim::SetRadioProtocol(int32_t serialId, const HDI::Ril::V1_1::RadioProtocol &radioProtocol)
293 {
294 HRilRadioProtocol hrilRadioProtocol = {};
295 hrilRadioProtocol.sessionId = radioProtocol.sessionId;
296 hrilRadioProtocol.phase = static_cast<HRilRadioProtocolPhase>(radioProtocol.phase);
297 hrilRadioProtocol.technology = radioProtocol.technology;
298 hrilRadioProtocol.modemId = radioProtocol.modemId;
299 hrilRadioProtocol.status = static_cast<HRilRadioProtocolStatus>(radioProtocol.status);
300 TELEPHONY_LOGI("HRilSim::SetRadioProtocol slotId:%{public}d, serialId:%{public}d"
301 "sessionId:%{public}d, phase:%{public}d, technology:%{public}d, modemId:%{public}d, status:%{public}d",
302 GetSlotId(), serialId, hrilRadioProtocol.sessionId, hrilRadioProtocol.phase, hrilRadioProtocol.technology,
303 hrilRadioProtocol.modemId, hrilRadioProtocol.status);
304 return RequestVendor(serialId, HREQ_SIM_SET_RADIO_PROTOCOL, simFuncs_,
305 &HRilSimReq::SetRadioProtocol, &hrilRadioProtocol);
306 }
307
SimOpenLogicalChannel(int32_t serialId,const std::string & appID,int32_t p2)308 int32_t HRilSim::SimOpenLogicalChannel(int32_t serialId, const std::string &appID, int32_t p2)
309 {
310 char *appIDPoint = nullptr;
311 CopyToCharPoint(&appIDPoint, appID);
312 int32_t ret = RequestVendor(
313 serialId, HREQ_SIM_OPEN_LOGICAL_CHANNEL, simFuncs_, &HRilSimReq::SimOpenLogicalChannel, appIDPoint, p2);
314 SafeFrees(appIDPoint);
315 return ret;
316 }
317
SimCloseLogicalChannel(int32_t serialId,int32_t channelId)318 int32_t HRilSim::SimCloseLogicalChannel(int32_t serialId, int32_t channelId)
319 {
320 return RequestVendor(
321 serialId, HREQ_SIM_CLOSE_LOGICAL_CHANNEL, simFuncs_, &HRilSimReq::SimCloseLogicalChannel, channelId);
322 }
323
SimTransmitApduLogicalChannel(int32_t serialId,const OHOS::HDI::Ril::V1_1::ApduSimIORequestInfo & apduSimIO)324 int32_t HRilSim::SimTransmitApduLogicalChannel(
325 int32_t serialId, const OHOS::HDI::Ril::V1_1::ApduSimIORequestInfo &apduSimIO)
326 {
327 std::unique_ptr<HRilApduSimIO> rilApduSimIO = std::make_unique<HRilApduSimIO>();
328 CopyToHRilApduSimIO(rilApduSimIO, apduSimIO);
329 int32_t ret = RequestVendor(serialId, HREQ_SIM_TRANSMIT_APDU_LOGICAL_CHANNEL, simFuncs_,
330 &HRilSimReq::SimTransmitApduLogicalChannel, rilApduSimIO.get(), sizeof(*rilApduSimIO));
331 SafeFrees(rilApduSimIO->data);
332 return ret;
333 }
334
SimTransmitApduBasicChannel(int32_t serialId,const OHOS::HDI::Ril::V1_1::ApduSimIORequestInfo & apduSimIO)335 int32_t HRilSim::SimTransmitApduBasicChannel(
336 int32_t serialId, const OHOS::HDI::Ril::V1_1::ApduSimIORequestInfo &apduSimIO)
337 {
338 std::unique_ptr<HRilApduSimIO> rilApduSimIO = std::make_unique<HRilApduSimIO>();
339 CopyToHRilApduSimIO(rilApduSimIO, apduSimIO);
340 int32_t ret = RequestVendor(serialId, HREQ_SIM_TRANSMIT_APDU_BASIC_CHANNEL, simFuncs_,
341 &HRilSimReq::SimTransmitApduBasicChannel, rilApduSimIO.get(), sizeof(*rilApduSimIO));
342 SafeFrees(rilApduSimIO->data);
343 return ret;
344 }
345
SimAuthentication(int32_t serialId,const OHOS::HDI::Ril::V1_1::SimAuthenticationRequestInfo & simAuthInfo)346 int32_t HRilSim::SimAuthentication(
347 int32_t serialId, const OHOS::HDI::Ril::V1_1::SimAuthenticationRequestInfo &simAuthInfo)
348 {
349 std::unique_ptr<HRilSimAuthenticationRequestInfo> rilSimAuthInfo =
350 std::make_unique<HRilSimAuthenticationRequestInfo>();
351 CopyToHRilSimAuthentication(rilSimAuthInfo, simAuthInfo);
352 int32_t ret = RequestVendor(serialId, HREQ_SIM_AUTHENTICATION, simFuncs_, &HRilSimReq::SimAuthentication,
353 rilSimAuthInfo.get(), sizeof(*rilSimAuthInfo));
354 SafeFrees(rilSimAuthInfo->aid, rilSimAuthInfo->data);
355 return ret;
356 }
357
UnlockSimLock(int32_t serialId,int32_t lockType,const std::string & key)358 int32_t HRilSim::UnlockSimLock(int32_t serialId, int32_t lockType, const std::string &key)
359 {
360 char *keyPoint = nullptr;
361 CopyToCharPoint(&keyPoint, key);
362 int32_t ret =
363 RequestVendor(serialId, HREQ_SIM_UNLOCK_SIM_LOCK, simFuncs_, &HRilSimReq::UnlockSimLock, lockType, keyPoint);
364 SafeFrees(keyPoint);
365 return ret;
366 }
367
SendSimMatchedOperatorInfo(int32_t serialId,const OHOS::HDI::Ril::V1_2::NcfgOperatorInfo & ncfgOperatorInfo)368 int32_t HRilSim::SendSimMatchedOperatorInfo(
369 int32_t serialId, const OHOS::HDI::Ril::V1_2::NcfgOperatorInfo &ncfgOperatorInfo)
370 {
371 std::unique_ptr<HRilNcfgOperatorInfo> rilNcfgOperatorInfo =
372 std::make_unique<HRilNcfgOperatorInfo>();
373 CopyToHRilNcfgOperatorInfo(rilNcfgOperatorInfo, ncfgOperatorInfo);
374 int32_t ret = RequestVendor(serialId, HREQ_SIM_SEND_NCFG_OPER_INFO, simFuncs_,
375 &HRilSimReq::SendSimMatchedOperatorInfo, rilNcfgOperatorInfo.get(), sizeof(*rilNcfgOperatorInfo));
376 SafeFrees(rilNcfgOperatorInfo->operName, rilNcfgOperatorInfo->operKey, rilNcfgOperatorInfo->reserve);
377 return ret;
378 }
379
GetSimIOResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)380 int32_t HRilSim::GetSimIOResponse(
381 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
382 {
383 HDI::Ril::V1_1::IccIoResultInfo result = {};
384 int32_t ret = BuildSimIOResp(result, responseInfo, response, responseLen);
385 if (ret != HRIL_ERR_SUCCESS) {
386 return ret;
387 }
388 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetSimIOResponse, result);
389 }
390
GetSimCardStatusResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)391 int32_t HRilSim::GetSimCardStatusResponse(
392 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
393 {
394 HDI::Ril::V1_3::SimCardStatusInfo rilCardStatus = {};
395 if ((response == nullptr && responseLen != 0) ||
396 (response != nullptr && responseLen != sizeof(HRilCardState))) {
397 TELEPHONY_LOGE("Invalid response: Vendor exception!");
398 return HRIL_ERR_INVALID_PARAMETER;
399 }
400 if (response == nullptr && responseLen == 0) {
401 TELEPHONY_LOGE("response is null");
402 if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
403 responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
404 }
405 return Response(responseInfo, &HDI::Ril::V1_3::IRilCallback::GetSimCardStatusResponse, rilCardStatus);
406 }
407 const HRilCardState *curPtr = static_cast<const HRilCardState *>(response);
408 if (curPtr != nullptr) {
409 rilCardStatus.index = curPtr->index;
410 rilCardStatus.simType = curPtr->simType;
411 rilCardStatus.simState = curPtr->simState;
412 rilCardStatus.iccid = (curPtr->iccid == nullptr) ? "" : curPtr->iccid;
413 }
414 return Response(responseInfo, &HDI::Ril::V1_3::IRilCallback::GetSimCardStatusResponse, rilCardStatus);
415 }
416
GetImsiResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)417 int32_t HRilSim::GetImsiResponse(
418 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
419 {
420 int32_t ret = CheckCharData(response, responseLen);
421 if (ret != HRIL_ERR_SUCCESS) {
422 return ret;
423 }
424 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetImsiResponse, (const char *)response);
425 }
426
GetSimLockStatusResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)427 int32_t HRilSim::GetSimLockStatusResponse(
428 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
429 {
430 int32_t simLockStatus = 0;
431 if (response == nullptr || responseLen != sizeof(int32_t)) {
432 TELEPHONY_LOGE("GetSimStatusResponse: Invalid response");
433 if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
434 responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
435 }
436 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetSimLockStatusResponse, simLockStatus);
437 }
438 simLockStatus = *(static_cast<const int32_t *>(response));
439 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetSimLockStatusResponse, simLockStatus);
440 }
441
SetSimLockResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)442 int32_t HRilSim::SetSimLockResponse(
443 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
444 {
445 HDI::Ril::V1_1::LockStatusResp result = {};
446 ResponseLockStatus(result, responseInfo, response, responseLen);
447 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetSimLockResponse, result);
448 }
449
ChangeSimPasswordResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)450 int32_t HRilSim::ChangeSimPasswordResponse(
451 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
452 {
453 HDI::Ril::V1_1::LockStatusResp result = {};
454 ResponseLockStatus(result, responseInfo, response, responseLen);
455 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::ChangeSimPasswordResponse, result);
456 }
457
UnlockPinResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)458 int32_t HRilSim::UnlockPinResponse(
459 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
460 {
461 HDI::Ril::V1_1::LockStatusResp result = {};
462 ResponseLockStatus(result, responseInfo, response, responseLen);
463 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::UnlockPinResponse, result);
464 }
465
UnlockPukResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)466 int32_t HRilSim::UnlockPukResponse(
467 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
468 {
469 HDI::Ril::V1_1::LockStatusResp result = {};
470 ResponseLockStatus(result, responseInfo, response, responseLen);
471 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::UnlockPukResponse, result);
472 }
473
UnlockPin2Response(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)474 int32_t HRilSim::UnlockPin2Response(
475 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
476 {
477 HDI::Ril::V1_1::LockStatusResp result = {};
478 ResponseLockStatus(result, responseInfo, response, responseLen);
479 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::UnlockPin2Response, result);
480 }
481
UnlockPuk2Response(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)482 int32_t HRilSim::UnlockPuk2Response(
483 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
484 {
485 HDI::Ril::V1_1::LockStatusResp result = {};
486 ResponseLockStatus(result, responseInfo, response, responseLen);
487 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::UnlockPuk2Response, result);
488 }
489
SetActiveSimResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)490 int32_t HRilSim::SetActiveSimResponse(
491 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
492 {
493 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetActiveSimResponse);
494 }
495
SimStkSendTerminalResponseResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)496 int32_t HRilSim::SimStkSendTerminalResponseResponse(
497 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
498 {
499 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SimStkSendTerminalResponseResponse);
500 }
501
SimStkSendEnvelopeResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)502 int32_t HRilSim::SimStkSendEnvelopeResponse(
503 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
504 {
505 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SimStkSendEnvelopeResponse);
506 }
507
SimStkSendCallSetupRequestResultResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)508 int32_t HRilSim::SimStkSendCallSetupRequestResultResponse(
509 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
510 {
511 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SimStkSendCallSetupRequestResultResponse);
512 }
513
SimStkIsReadyResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)514 int32_t HRilSim::SimStkIsReadyResponse(
515 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
516 {
517 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SimStkIsReadyResponse);
518 }
519
GetRadioProtocolResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)520 int32_t HRilSim::GetRadioProtocolResponse(
521 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
522 {
523 HDI::Ril::V1_1::RadioProtocol radioProtocol = {};
524 if (response == nullptr || responseLen != sizeof(HRilRadioProtocol)) {
525 TELEPHONY_LOGE("GetRadioProtocolResponse response is invalid");
526 if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
527 responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
528 }
529 } else {
530 BuildRadioProtocol(radioProtocol, response);
531 TELEPHONY_LOGI("HRilSim::GetRadioProtocolResponse slotId:%{public}d, serial:%{public}d"
532 "sessionId:%{public}d, phase:%{public}d, technology:%{public}d, modemId:%{public}d, status:%{public}d",
533 GetSlotId(), responseInfo.serial, radioProtocol.sessionId, radioProtocol.phase, radioProtocol.technology,
534 radioProtocol.modemId, radioProtocol.status);
535 }
536 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetRadioProtocolResponse, radioProtocol);
537 }
538
SetRadioProtocolResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)539 int32_t HRilSim::SetRadioProtocolResponse(
540 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
541 {
542 HDI::Ril::V1_1::RadioProtocol radioProtocol = {};
543 if (response == nullptr || responseLen != sizeof(HRilRadioProtocol)) {
544 TELEPHONY_LOGE("SetRadioProtocolResponse response is invalid");
545 if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
546 responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
547 }
548 } else {
549 BuildRadioProtocol(radioProtocol, response);
550 TELEPHONY_LOGI("HRilSim::SetRadioProtocolResponse slotId:%{public}d, serial:%{public}d"
551 "sessionId:%{public}d, phase:%{public}d, technology:%{public}d, modemId:%{public}d, status:%{public}d",
552 GetSlotId(), responseInfo.serial, radioProtocol.sessionId, radioProtocol.phase, radioProtocol.technology,
553 radioProtocol.modemId, radioProtocol.status);
554 }
555 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetRadioProtocolResponse, radioProtocol);
556 }
557
SimOpenLogicalChannelResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)558 int32_t HRilSim::SimOpenLogicalChannelResponse(
559 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
560 {
561 HDI::Ril::V1_1::OpenLogicalChannelResponse pOpenLogicalChannelResponse = {};
562 if (response == nullptr || responseLen != sizeof(HRilOpenLogicalChannelResponse)) {
563 TELEPHONY_LOGE("Invalid response: response is nullptr");
564 return HRIL_ERR_INVALID_PARAMETER;
565 }
566 const HRilOpenLogicalChannelResponse *pRilResponse = static_cast<const HRilOpenLogicalChannelResponse *>(response);
567 pOpenLogicalChannelResponse.sw1 = pRilResponse->sw1;
568 pOpenLogicalChannelResponse.sw2 = pRilResponse->sw2;
569 pOpenLogicalChannelResponse.channelId = pRilResponse->channelId;
570 pOpenLogicalChannelResponse.response = (pRilResponse->response == nullptr) ? "" : pRilResponse->response;
571 return Response(
572 responseInfo, &HDI::Ril::V1_1::IRilCallback::SimOpenLogicalChannelResponse, pOpenLogicalChannelResponse);
573 }
574
SimCloseLogicalChannelResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)575 int32_t HRilSim::SimCloseLogicalChannelResponse(
576 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
577 {
578 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SimCloseLogicalChannelResponse);
579 }
580
SimTransmitApduLogicalChannelResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)581 int32_t HRilSim::SimTransmitApduLogicalChannelResponse(
582 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
583 {
584 HDI::Ril::V1_1::IccIoResultInfo result = {};
585 int32_t ret = BuildSimIOResp(result, responseInfo, response, responseLen);
586 if (ret != HRIL_ERR_SUCCESS) {
587 return ret;
588 }
589 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SimTransmitApduLogicalChannelResponse, result);
590 }
591
SimTransmitApduBasicChannelResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)592 int32_t HRilSim::SimTransmitApduBasicChannelResponse(
593 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
594 {
595 HDI::Ril::V1_1::IccIoResultInfo result = {};
596 int32_t ret = BuildSimIOResp(result, responseInfo, response, responseLen);
597 if (ret != HRIL_ERR_SUCCESS) {
598 return ret;
599 }
600 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SimTransmitApduBasicChannelResponse, result);
601 }
602
SimAuthenticationResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)603 int32_t HRilSim::SimAuthenticationResponse(
604 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
605 {
606 HDI::Ril::V1_1::IccIoResultInfo result = {};
607 int32_t ret = BuildSimIOResp(result, responseInfo, response, responseLen);
608 if (ret != HRIL_ERR_SUCCESS) {
609 return ret;
610 }
611 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SimAuthenticationResponse, result);
612 }
613
UnlockSimLockResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)614 int32_t HRilSim::UnlockSimLockResponse(
615 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
616 {
617 HDI::Ril::V1_1::LockStatusResp result = {};
618 ResponseLockStatus(result, responseInfo, response, responseLen);
619 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::UnlockSimLockResponse, result);
620 }
621
ProcessIccIoResponse(HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)622 HDI::Ril::V1_1::IccIoResultInfo HRilSim::ProcessIccIoResponse(
623 HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
624 {
625 HDI::Ril::V1_1::IccIoResultInfo result = {};
626 if (response == nullptr || responseLen != sizeof(HRilSimIOResponse)) {
627 if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
628 responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
629 }
630 result.response = std::string("");
631 return result;
632 }
633 const HRilSimIOResponse *resp = static_cast<const HRilSimIOResponse *>(response);
634 result.sw1 = resp->sw1;
635 result.sw2 = resp->sw2;
636 result.response = (resp->response == nullptr) ? "" : std::string(resp->response);
637 return result;
638 }
639
SendSimMatchedOperatorInfoResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)640 int32_t HRilSim::SendSimMatchedOperatorInfoResponse(
641 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
642 {
643 return Response(responseInfo, &HDI::Ril::V1_2::IRilCallback::SendSimMatchedOperatorInfoResponse);
644 }
645
SimStateUpdated(int32_t notifyType,const HRilErrNumber error,const void * response,size_t responseLen)646 int32_t HRilSim::SimStateUpdated(
647 int32_t notifyType, const HRilErrNumber error, const void *response, size_t responseLen)
648 {
649 return Notify(notifyType, error, &HDI::Ril::V1_1::IRilCallback::SimStateUpdated);
650 }
651
SimStkSessionEndNotify(int32_t notifyType,const HRilErrNumber error,const void * response,size_t responseLen)652 int32_t HRilSim::SimStkSessionEndNotify(
653 int32_t notifyType, const HRilErrNumber error, const void *response, size_t responseLen)
654 {
655 return Notify(notifyType, error, &HDI::Ril::V1_1::IRilCallback::SimStkSessionEndNotify);
656 }
657
SimStkProactiveNotify(int32_t notifyType,const HRilErrNumber error,const void * response,size_t responseLen)658 int32_t HRilSim::SimStkProactiveNotify(
659 int32_t notifyType, const HRilErrNumber error, const void *response, size_t responseLen)
660 {
661 int32_t ret = CheckCharData(response, responseLen);
662 if (ret != HRIL_ERR_SUCCESS) {
663 return ret;
664 }
665 return Notify(notifyType, error, &HDI::Ril::V1_1::IRilCallback::SimStkProactiveNotify, (const char *)response);
666 }
667
SimStkAlphaNotify(int32_t notifyType,const HRilErrNumber error,const void * response,size_t responseLen)668 int32_t HRilSim::SimStkAlphaNotify(
669 int32_t notifyType, const HRilErrNumber error, const void *response, size_t responseLen)
670 {
671 int32_t ret = CheckCharData(response, responseLen);
672 if (ret != HRIL_ERR_SUCCESS) {
673 return ret;
674 }
675 return Notify(notifyType, error, &HDI::Ril::V1_1::IRilCallback::SimStkAlphaNotify, (const char *)response);
676 }
677
SimStkEventNotify(int32_t notifyType,const HRilErrNumber error,const void * response,size_t responseLen)678 int32_t HRilSim::SimStkEventNotify(
679 int32_t notifyType, const HRilErrNumber error, const void *response, size_t responseLen)
680 {
681 int32_t ret = CheckCharData(response, responseLen);
682 if (ret != HRIL_ERR_SUCCESS) {
683 return ret;
684 }
685 return Notify(notifyType, error, &HDI::Ril::V1_1::IRilCallback::SimStkEventNotify, (const char *)response);
686 }
687
SimStkCallSetupNotify(int32_t notifyType,const HRilErrNumber error,const void * response,size_t responseLen)688 int32_t HRilSim::SimStkCallSetupNotify(
689 int32_t notifyType, const HRilErrNumber error, const void *response, size_t responseLen)
690 {
691 return Notify(notifyType, error, &HDI::Ril::V1_1::IRilCallback::SimStkCallSetupNotify);
692 }
693
SimRefreshNotify(int32_t notifyType,const HRilErrNumber error,const void * response,size_t responseLen)694 int32_t HRilSim::SimRefreshNotify(
695 int32_t notifyType, const HRilErrNumber error, const void *response, size_t responseLen)
696 {
697 return Notify(notifyType, error, &HDI::Ril::V1_1::IRilCallback::SimRefreshNotify);
698 }
699
SimRadioProtocolUpdated(int32_t notifyType,const HRilErrNumber error,const void * response,size_t responseLen)700 int32_t HRilSim::SimRadioProtocolUpdated(
701 int32_t notifyType, const HRilErrNumber error, const void *response, size_t responseLen)
702 {
703 if (response == nullptr || responseLen != sizeof(HRilRadioProtocol)) {
704 TELEPHONY_LOGE("SimRadioProtocolUpdated response is invalid");
705 return HRIL_ERR_INVALID_PARAMETER;
706 }
707 HDI::Ril::V1_1::RadioProtocol radioProtocol = {};
708 BuildRadioProtocol(radioProtocol, response);
709 TELEPHONY_LOGI("SimRadioProtocolUpdated slotId:%{public}d, sessionId:%{public}d, phase:%{public}d, "
710 "technology:%{public}d, modemId:%{public}d, status:%{public}d",
711 radioProtocol.slotId, radioProtocol.sessionId, static_cast<int32_t>(radioProtocol.phase),
712 radioProtocol.technology, radioProtocol.modemId, static_cast<int32_t>(radioProtocol.status));
713 return Notify(notifyType, error, &HDI::Ril::V1_1::IRilCallback::SimRadioProtocolUpdated, radioProtocol);
714 }
715
IsSimResponse(uint32_t code)716 bool HRilSim::IsSimResponse(uint32_t code)
717 {
718 return ((code >= HREQ_SIM_BASE) && (code < HREQ_DATA_BASE));
719 }
720
IsSimNotification(uint32_t code)721 bool HRilSim::IsSimNotification(uint32_t code)
722 {
723 return ((code >= HNOTI_SIM_BASE) && (code < HNOTI_DATA_BASE));
724 }
725
CopyToHRilSimIO(std::unique_ptr<HRilSimIO> & rilSimIO,const OHOS::HDI::Ril::V1_1::SimIoRequestInfo & simIO)726 void HRilSim::CopyToHRilSimIO(std::unique_ptr<HRilSimIO> &rilSimIO, const OHOS::HDI::Ril::V1_1::SimIoRequestInfo &simIO)
727 {
728 rilSimIO->command = simIO.command;
729 rilSimIO->fileid = simIO.fileId;
730 rilSimIO->p1 = simIO.p1;
731 rilSimIO->p2 = simIO.p2;
732 rilSimIO->p3 = simIO.p3;
733 TELEPHONY_LOGD("CopyToHRilSimIO.data: %{public}zu, path: %{public}zu, pin2: %{public}zu", simIO.data.length(),
734 simIO.path.length(), simIO.pin2.length());
735 CopyToCharPoint(&(rilSimIO->data), simIO.data);
736 CopyToCharPoint(&(rilSimIO->pathid), simIO.path);
737 CopyToCharPoint(&(rilSimIO->pin2), simIO.pin2);
738 }
739
CopyToHRilSimLock(std::unique_ptr<HRilSimClock> & rilSimLock,const OHOS::HDI::Ril::V1_1::SimLockInfo & simLockInfo)740 void HRilSim::CopyToHRilSimLock(
741 std::unique_ptr<HRilSimClock> &rilSimLock, const OHOS::HDI::Ril::V1_1::SimLockInfo &simLockInfo)
742 {
743 rilSimLock->mode = simLockInfo.mode;
744 rilSimLock->status = simLockInfo.status;
745 rilSimLock->classx = simLockInfo.classx;
746 CopyToCharPoint(&(rilSimLock->fac), simLockInfo.fac);
747 CopyToCharPoint(&(rilSimLock->passwd), simLockInfo.passwd);
748 }
749
CopyToHRilSimPassword(std::unique_ptr<HRilSimPassword> & rilSimPassword,const OHOS::HDI::Ril::V1_1::SimPasswordInfo & simPassword)750 void HRilSim::CopyToHRilSimPassword(
751 std::unique_ptr<HRilSimPassword> &rilSimPassword, const OHOS::HDI::Ril::V1_1::SimPasswordInfo &simPassword)
752 {
753 CopyToCharPoint(&(rilSimPassword->fac), simPassword.fac);
754 CopyToCharPoint(&(rilSimPassword->oldPassword), simPassword.oldPassword);
755 CopyToCharPoint(&(rilSimPassword->newPassword), simPassword.newPassword);
756 rilSimPassword->passwordLength = simPassword.passwordLength;
757 }
758
CopyToHRilApduSimIO(std::unique_ptr<HRilApduSimIO> & rilApduSimIO,const OHOS::HDI::Ril::V1_1::ApduSimIORequestInfo & apduSimIO)759 void HRilSim::CopyToHRilApduSimIO(
760 std::unique_ptr<HRilApduSimIO> &rilApduSimIO, const OHOS::HDI::Ril::V1_1::ApduSimIORequestInfo &apduSimIO)
761 {
762 rilApduSimIO->channelId = apduSimIO.channelId;
763 rilApduSimIO->type = apduSimIO.type;
764 rilApduSimIO->instruction = apduSimIO.instruction;
765 rilApduSimIO->p1 = apduSimIO.p1;
766 rilApduSimIO->p2 = apduSimIO.p2;
767 rilApduSimIO->p3 = apduSimIO.p3;
768 CopyToCharPoint(&(rilApduSimIO->data), apduSimIO.data);
769 }
770
CopyToHRilSimAuthentication(std::unique_ptr<HRilSimAuthenticationRequestInfo> & rilSimAuthInfo,const OHOS::HDI::Ril::V1_1::SimAuthenticationRequestInfo & simAuthInfo)771 void HRilSim::CopyToHRilSimAuthentication(std::unique_ptr<HRilSimAuthenticationRequestInfo> &rilSimAuthInfo,
772 const OHOS::HDI::Ril::V1_1::SimAuthenticationRequestInfo &simAuthInfo)
773 {
774 rilSimAuthInfo->serial = simAuthInfo.serial;
775 CopyToCharPoint(&(rilSimAuthInfo->aid), simAuthInfo.aid);
776 CopyToCharPoint(&(rilSimAuthInfo->data), simAuthInfo.authData);
777 }
778
CopyToHRilNcfgOperatorInfo(std::unique_ptr<HRilNcfgOperatorInfo> & rilNcfgOperatorInfo,const OHOS::HDI::Ril::V1_2::NcfgOperatorInfo & ncfgOperatorInfo)779 void HRilSim::CopyToHRilNcfgOperatorInfo(std::unique_ptr<HRilNcfgOperatorInfo> &rilNcfgOperatorInfo,
780 const OHOS::HDI::Ril::V1_2::NcfgOperatorInfo &ncfgOperatorInfo)
781 {
782 CopyToCharPoint(&(rilNcfgOperatorInfo->operName), ncfgOperatorInfo.operName);
783 CopyToCharPoint(&(rilNcfgOperatorInfo->operKey), ncfgOperatorInfo.operKey);
784 rilNcfgOperatorInfo->state = ncfgOperatorInfo.state;
785 CopyToCharPoint(&(rilNcfgOperatorInfo->reserve), ncfgOperatorInfo.reserve);
786 }
787
BuildLockStatusResp(const void * response,size_t responseLen,HDI::Ril::V1_1::LockStatusResp & lockStatus)788 bool HRilSim::BuildLockStatusResp(const void *response, size_t responseLen, HDI::Ril::V1_1::LockStatusResp &lockStatus)
789 {
790 if (response == nullptr || responseLen != sizeof(HRilLockStatus)) {
791 return false;
792 }
793 const HRilLockStatus *resp = static_cast<const HRilLockStatus *>(response);
794 lockStatus.result = resp->result;
795 lockStatus.remain = resp->remain;
796 return true;
797 }
798
ResponseLockStatus(HDI::Ril::V1_1::LockStatusResp & lockStatus,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)799 void HRilSim::ResponseLockStatus(HDI::Ril::V1_1::LockStatusResp &lockStatus,
800 HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
801 {
802 if (!BuildLockStatusResp(response, responseLen, lockStatus)) {
803 TELEPHONY_LOGE("Invalid ResponseLockStatus: response is error");
804 if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
805 responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
806 }
807 }
808 }
809
BuildSimIOResp(HDI::Ril::V1_1::IccIoResultInfo & result,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)810 int32_t HRilSim::BuildSimIOResp(HDI::Ril::V1_1::IccIoResultInfo &result,
811 HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
812 {
813 if ((response == nullptr && responseLen != 0) ||
814 (response != nullptr && responseLen != sizeof(HRilSimIOResponse))) {
815 TELEPHONY_LOGE("Invalid BuildSimIOResp: Vendor exception!");
816 return HRIL_ERR_INVALID_PARAMETER;
817 }
818 if (response == nullptr && responseLen == 0) {
819 TELEPHONY_LOGE("BuildSimIOResp response is null");
820 if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
821 responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
822 }
823 }
824 result = ProcessIccIoResponse(responseInfo, response, responseLen);
825 return HRIL_ERR_SUCCESS;
826 }
827
CheckCharData(const void * response,size_t responseLen)828 int32_t HRilSim::CheckCharData(const void *response, size_t responseLen)
829 {
830 if ((response == nullptr && responseLen != 0) || (responseLen % sizeof(char)) != 0) {
831 TELEPHONY_LOGE("Invalid parameter, responseLen:%{public}zu", responseLen);
832 return HRIL_ERR_INVALID_PARAMETER;
833 }
834 if (response == nullptr && responseLen == 0) {
835 TELEPHONY_LOGE("response is null");
836 return HRIL_ERR_NULL_POINT;
837 }
838 return HRIL_ERR_SUCCESS;
839 }
840
BuildRadioProtocol(HDI::Ril::V1_1::RadioProtocol & radioProtocol,const void * response)841 void HRilSim::BuildRadioProtocol(HDI::Ril::V1_1::RadioProtocol &radioProtocol, const void *response)
842 {
843 const HRilRadioProtocol *hrilRadioProtocol = static_cast<const HRilRadioProtocol *>(response);
844 radioProtocol.slotId = GetSlotId();
845 radioProtocol.sessionId = hrilRadioProtocol->sessionId;
846 radioProtocol.phase = static_cast<HDI::Ril::V1_1::RadioProtocolPhase>(hrilRadioProtocol->phase);
847 radioProtocol.technology = ConvertRadioProtocolTech(hrilRadioProtocol->technology);
848 radioProtocol.modemId = hrilRadioProtocol->modemId;
849 radioProtocol.status = static_cast<HDI::Ril::V1_1::RadioProtocolStatus>(hrilRadioProtocol->status);
850 }
851
ConvertRadioProtocolTech(int32_t tech)852 int32_t HRilSim::ConvertRadioProtocolTech(int32_t tech)
853 {
854 uint32_t radioProtocolTech = HRIL_RADIO_PROTOCOL_TECH_UNKNOWN;
855 for (uint32_t radioTech = RADIO_TECHNOLOGY_GSM; radioTech <= RADIO_TECHNOLOGY_NR; radioTech++) {
856 uint32_t protocolTech = 1 << radioTech;
857 if ((static_cast<uint32_t>(tech) & protocolTech) != 0) {
858 radioProtocolTech |= protocolTech;
859 }
860 }
861 return static_cast<int32_t>(radioProtocolTech);
862 }
863 } // namespace Telephony
864 } // namespace OHOS
865