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_sms.h"
17 
18 #include <regex>
19 
20 #include "hril_notification.h"
21 #include "hril_request.h"
22 
23 namespace OHOS {
24 namespace Telephony {
25 namespace {
26 const size_t HEX_WIDTH = 2;
27 const size_t MAX_PDU_LEN = 255;
28 const size_t MAX_LEN = 100;
29 const size_t MAX_CHN_LEN = 50000;
30 const int32_t MSG_DEFAULT_INDEX = -1;
31 const int32_t BYTE_LEN = 1;
32 const int32_t INT_LEN = 4;
33 const int32_t NUM_2 = 2;
34 const int32_t NUM_3 = 3;
35 const int32_t NUM_4 = 4;
36 const int32_t NUM_5 = 5;
37 const int HEXADECIMAL = 16;
38 constexpr const char *COMMA_STR = ",";
39 } // namespace
40 
HRilSms(int32_t slotId)41 HRilSms::HRilSms(int32_t slotId) : HRilBase(slotId)
42 {
43     AddHandlerToMap();
44     AddNotificationToMap();
45 }
46 
IsSmsRespOrNotify(uint32_t code)47 bool HRilSms::IsSmsRespOrNotify(uint32_t code)
48 {
49     return IsSmsResponse(code) || IsSmsNotification(code);
50 }
51 
RegisterSmsFuncs(const HRilSmsReq * smsFuncs)52 void HRilSms::RegisterSmsFuncs(const HRilSmsReq *smsFuncs)
53 {
54     smsFuncs_ = smsFuncs;
55 }
56 
AddHandlerToMap()57 void HRilSms::AddHandlerToMap()
58 {
59     // Response
60     respMemberFuncMap_[HREQ_SMS_SEND_GSM_SMS] =
61         [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
62         size_t responseLen) { return SendGsmSmsResponse(requestNum, responseInfo, response, responseLen); };
63     respMemberFuncMap_[HREQ_SMS_SEND_SMS_MORE_MODE] =
64         [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
65         size_t responseLen) { return SendSmsMoreModeResponse(requestNum, responseInfo, response, responseLen); };
66     respMemberFuncMap_[HREQ_SMS_SEND_SMS_ACK] =
67         [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
68         size_t responseLen) { return SendSmsAckResponse(requestNum, responseInfo, response, responseLen); };
69     respMemberFuncMap_[HREQ_SMS_ADD_SIM_MESSAGE] =
70         [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
71         size_t responseLen) { return AddSimMessageResponse(requestNum, responseInfo, response, responseLen); };
72     respMemberFuncMap_[HREQ_SMS_DEL_SIM_MESSAGE] =
73         [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
74         size_t responseLen) { return DelSimMessageResponse(requestNum, responseInfo, response, responseLen); };
75     respMemberFuncMap_[HREQ_SMS_UPDATE_SIM_MESSAGE] =
76         [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
77         size_t responseLen) { return UpdateSimMessageResponse(requestNum, responseInfo, response, responseLen); };
78     respMemberFuncMap_[HREQ_SMS_SET_SMSC_ADDR] =
79         [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
80         size_t responseLen) { return SetSmscAddrResponse(requestNum, responseInfo, response, responseLen); };
81     respMemberFuncMap_[HREQ_SMS_GET_SMSC_ADDR] =
82         [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
83         size_t responseLen) { return GetSmscAddrResponse(requestNum, responseInfo, response, responseLen); };
84     respMemberFuncMap_[HREQ_SMS_SET_CB_CONFIG] =
85         [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
86         size_t responseLen) { return SetCBConfigResponse(requestNum, responseInfo, response, responseLen); };
87     respMemberFuncMap_[HREQ_SMS_GET_CB_CONFIG] =
88         [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
89         size_t responseLen) { return GetCBConfigResponse(requestNum, responseInfo, response, responseLen); };
90     respMemberFuncMap_[HREQ_SMS_GET_CDMA_CB_CONFIG] =
91         [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
92         size_t responseLen) { return GetCdmaCBConfigResponse(requestNum, responseInfo, response, responseLen); };
93     respMemberFuncMap_[HREQ_SMS_SET_CDMA_CB_CONFIG] =
94         [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
95         size_t responseLen) { return SetCdmaCBConfigResponse(requestNum, responseInfo, response, responseLen); };
96     respMemberFuncMap_[HREQ_SMS_SEND_CDMA_SMS] =
97         [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
98         size_t responseLen) { return SendCdmaSmsResponse(requestNum, responseInfo, response, responseLen); };
99     respMemberFuncMap_[HREQ_SMS_ADD_CDMA_SIM_MESSAGE] =
100         [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
101         size_t responseLen) { return AddCdmaSimMessageResponse(requestNum, responseInfo, response, responseLen); };
102     respMemberFuncMap_[HREQ_SMS_DEL_CDMA_SIM_MESSAGE] =
103         [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
104         size_t responseLen) { return DelCdmaSimMessageResponse(requestNum, responseInfo, response, responseLen); };
105     respMemberFuncMap_[HREQ_SMS_UPDATE_CDMA_SIM_MESSAGE] =
106         [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
107         size_t responseLen) { return UpdateCdmaSimMessageResponse(requestNum, responseInfo, response, responseLen); };
108 }
109 
AddNotificationToMap()110 void HRilSms::AddNotificationToMap()
111 {
112     // Notification
113     notiMemberFuncMap_[HNOTI_SMS_NEW_SMS] =
114         [this](int32_t notifyType, HRilErrNumber error, const void *response,
115         size_t responseLen) { return NewSmsNotify(notifyType, error, response, responseLen); };
116     notiMemberFuncMap_[HNOTI_SMS_NEW_CDMA_SMS] =
117         [this](int32_t notifyType, HRilErrNumber error, const void *response,
118         size_t responseLen) { return NewCdmaSmsNotify(notifyType, error, response, responseLen); };
119     notiMemberFuncMap_[HNOTI_SMS_STATUS_REPORT] =
120         [this](int32_t notifyType, HRilErrNumber error, const void *response,
121         size_t responseLen) { return SmsStatusReportNotify(notifyType, error, response, responseLen); };
122     notiMemberFuncMap_[HNOTI_SMS_NEW_SMS_STORED_ON_SIM] =
123         [this](int32_t notifyType, HRilErrNumber error, const void *response,
124         size_t responseLen) { return NewSmsStoredOnSimNotify(notifyType, error, response, responseLen); };
125     notiMemberFuncMap_[HNOTI_CB_CONFIG_REPORT] =
126         [this](int32_t notifyType, HRilErrNumber error, const void *response,
127         size_t responseLen) { return CBConfigNotify(notifyType, error, response, responseLen); };
128 }
129 
SendGsmSms(int32_t serialId,const OHOS::HDI::Ril::V1_1::GsmSmsMessageInfo & gsmSmsMessageInfo)130 int32_t HRilSms::SendGsmSms(int32_t serialId, const OHOS::HDI::Ril::V1_1::GsmSmsMessageInfo &gsmSmsMessageInfo)
131 {
132     const int32_t COUNT_STRINGS_VALUE = 2;
133     return RequestWithStrings(serialId, HREQ_SMS_SEND_GSM_SMS, COUNT_STRINGS_VALUE, gsmSmsMessageInfo.smscPdu.c_str(),
134         gsmSmsMessageInfo.pdu.c_str());
135 }
136 
SendCdmaSms(int32_t serialId,const OHOS::HDI::Ril::V1_1::SendCdmaSmsMessageInfo & cdmaSmsMessageInfo)137 int32_t HRilSms::SendCdmaSms(int32_t serialId, const OHOS::HDI::Ril::V1_1::SendCdmaSmsMessageInfo &cdmaSmsMessageInfo)
138 {
139     return RequestVendor(serialId, HREQ_SMS_SEND_CDMA_SMS, smsFuncs_, &HRilSmsReq::SendCdmaSms,
140         cdmaSmsMessageInfo.smscPdu.c_str(), cdmaSmsMessageInfo.smscPdu.size());
141 }
142 
AddSimMessage(int32_t serialId,const OHOS::HDI::Ril::V1_1::SmsMessageIOInfo & message)143 int32_t HRilSms::AddSimMessage(int32_t serialId, const OHOS::HDI::Ril::V1_1::SmsMessageIOInfo &message)
144 {
145     HRilSmsWriteSms msg = {};
146     msg.state = message.state;
147     msg.index = MSG_DEFAULT_INDEX;
148     size_t pduLen = message.pdu.length();
149     if (pduLen > MAX_PDU_LEN) {
150         return HRIL_ERR_INVALID_PARAMETER;
151     }
152     CopyToCharPoint(&msg.pdu, message.pdu);
153     size_t smscPduLen = message.smscPdu.length() + 1;
154     if (smscPduLen > MAX_PDU_LEN) {
155         SafeFrees(msg.pdu);
156         return HRIL_ERR_INVALID_PARAMETER;
157     }
158     CopyToCharPoint(&msg.smsc, message.smscPdu);
159     int32_t result = RequestVendor(
160         serialId, HREQ_SMS_ADD_SIM_MESSAGE, smsFuncs_, &HRilSmsReq::AddSimMessage, &msg, sizeof(HRilSmsWriteSms));
161     TELEPHONY_LOGI("AddSimMessage result is: %{public}d", result);
162     SafeFrees(msg.pdu, msg.smsc);
163     return result;
164 }
165 
DelSimMessage(int32_t serialId,int32_t index)166 int32_t HRilSms::DelSimMessage(int32_t serialId, int32_t index)
167 {
168     if ((smsFuncs_ == nullptr) || (smsFuncs_->DelSimMessage == nullptr)) {
169         TELEPHONY_LOGE("smsFuncs_ or smsFuncs_->DelSimMessage is null");
170         return HRIL_ERR_NULL_POINT;
171     }
172     ReqDataInfo *requestInfo = CreateHRilRequest(serialId, HREQ_SMS_DEL_SIM_MESSAGE);
173     if (requestInfo == nullptr) {
174         return HRIL_ERR_INVALID_PARAMETER;
175     }
176     int32_t *pBuff = nullptr;
177     RequestWithInts(&pBuff, requestInfo, 1, index);
178     smsFuncs_->DelSimMessage(requestInfo, pBuff, sizeof(int32_t));
179     if (pBuff != nullptr) {
180         SafeFrees(pBuff);
181     }
182     return HRIL_ERR_SUCCESS;
183 }
184 
UpdateSimMessage(int32_t serialId,const OHOS::HDI::Ril::V1_1::SmsMessageIOInfo & message)185 int32_t HRilSms::UpdateSimMessage(int32_t serialId, const OHOS::HDI::Ril::V1_1::SmsMessageIOInfo &message)
186 {
187     HRilSmsWriteSms msg = {};
188     msg.state = message.state;
189     msg.index = message.index;
190     size_t len = message.pdu.size() + 1;
191     if (len > MAX_PDU_LEN) {
192         return HRIL_ERR_INVALID_PARAMETER;
193     }
194     CopyToCharPoint(&msg.pdu, message.pdu);
195     size_t smscPduLen = message.smscPdu.length() + 1;
196     if (smscPduLen > MAX_PDU_LEN) {
197         SafeFrees(msg.pdu);
198         return HRIL_ERR_INVALID_PARAMETER;
199     }
200     CopyToCharPoint(&msg.smsc, message.smscPdu);
201     int32_t result = RequestVendor(
202         serialId, HREQ_SMS_UPDATE_SIM_MESSAGE, smsFuncs_, &HRilSmsReq::UpdateSimMessage, &msg, sizeof(HRilSmsWriteSms));
203     TELEPHONY_LOGI("UpdateSimMessage result is: %{public}d", result);
204     SafeFrees(msg.pdu, msg.smsc);
205     return result;
206 }
207 
SetSmscAddr(int32_t serialId,const OHOS::HDI::Ril::V1_1::ServiceCenterAddress & serCenterAddress)208 int32_t HRilSms::SetSmscAddr(int32_t serialId, const OHOS::HDI::Ril::V1_1::ServiceCenterAddress &serCenterAddress)
209 {
210     HRilServiceCenterAddress address;
211     size_t len = 0;
212     len = strlen(serCenterAddress.address.c_str()) + 1;
213     address.tosca = serCenterAddress.tosca;
214     if (len > MAX_LEN) {
215         return HRIL_ERR_INVALID_PARAMETER;
216     }
217     CopyToCharPoint(&address.address, serCenterAddress.address);
218     int32_t result = RequestVendor(serialId, HREQ_SMS_SET_SMSC_ADDR, smsFuncs_, &HRilSmsReq::SetSmscAddr, &address,
219         sizeof(HRilServiceCenterAddress));
220     TELEPHONY_LOGI("SetSmscAddr result is: %{public}d", result);
221     SafeFrees(address.address);
222     return result;
223 }
224 
GetSmscAddr(int32_t serialId)225 int32_t HRilSms::GetSmscAddr(int32_t serialId)
226 {
227     return RequestVendor(serialId, HREQ_SMS_GET_SMSC_ADDR, smsFuncs_, &HRilSmsReq::GetSmscAddr);
228 }
229 
SetCBConfig(int32_t serialId,const OHOS::HDI::Ril::V1_1::CBConfigInfo & broadcastInfo)230 int32_t HRilSms::SetCBConfig(int32_t serialId, const OHOS::HDI::Ril::V1_1::CBConfigInfo &broadcastInfo)
231 {
232     size_t midsLen = broadcastInfo.mids.size() + 1;
233     if (midsLen == 0 || midsLen > MAX_CHN_LEN) {
234         return HRIL_ERR_INVALID_PARAMETER;
235     }
236 
237     size_t dcssLen = broadcastInfo.dcss.size();
238     if (dcssLen == 0) {
239         return HRIL_ERR_INVALID_PARAMETER;
240     }
241     int32_t result;
242     std::vector<HRilCBConfigInfo> configInfo;
243     if (!GetHRilCBConfigInfo(configInfo, broadcastInfo)) {
244         return HRIL_ERR_INVALID_PARAMETER;
245     }
246     if (configInfo.size() == 0 || configInfo.size() > MAX_CHN_LEN) {
247         return HRIL_ERR_INVALID_PARAMETER;
248     }
249     HRilCBConfigInfo *info = new HRilCBConfigInfo[configInfo.size()];
250     std::size_t locate = 0;
251     while (locate < configInfo.size()) {
252         info[locate].startOfServiceId = configInfo[locate].startOfServiceId;
253         info[locate].endOfServiceId = configInfo[locate].endOfServiceId;
254         info[locate].startOfCodeScheme = configInfo[locate].startOfCodeScheme;
255         info[locate].endOfCodeScheme = configInfo[locate].endOfCodeScheme;
256         info[locate].selected = configInfo[locate].selected;
257         locate++;
258     }
259     uint32_t len = sizeof(HRilCBConfigInfo) * configInfo.size();
260     result = RequestVendor(serialId, HREQ_SMS_SET_CB_CONFIG, smsFuncs_, &HRilSmsReq::SetCBConfig, info, len);
261     if (result != HRIL_ERR_SUCCESS) {
262         TELEPHONY_LOGE("SetCBConfig fail, result is: %{public}d", result);
263     }
264     delete[] info;
265     return result;
266 }
267 
GetHRilCBConfigInfo(std::vector<HRilCBConfigInfo> & cellBroadcastInfo,const OHOS::HDI::Ril::V1_1::CBConfigInfo & broadcastInfo)268 bool HRilSms::GetHRilCBConfigInfo(
269     std::vector<HRilCBConfigInfo> &cellBroadcastInfo, const OHOS::HDI::Ril::V1_1::CBConfigInfo &broadcastInfo)
270 {
271     std::vector<std::string> mids;
272     SplitMids(broadcastInfo.mids, mids, COMMA_STR);
273     for (auto mid : mids) {
274         std::string startMid;
275         std::string endMid;
276         if (!SplitValue(mid, startMid, endMid, "-")) {
277             TELEPHONY_LOGE("cb channel invalid");
278             return false;
279         }
280         std::string startDcs;
281         std::string endDcs;
282         if (!SplitValue(broadcastInfo.dcss, startDcs, endDcs, "-")) {
283             TELEPHONY_LOGE("cb dcs invalid");
284             return false;
285         }
286         HRilCBConfigInfo info;
287         info.startOfServiceId = std::stoi(startMid);
288         info.endOfServiceId = std::stoi(endMid);
289         info.startOfCodeScheme = std::stoi(startDcs);
290         info.endOfCodeScheme = std::stoi(endDcs);
291         info.selected = broadcastInfo.mode;
292         cellBroadcastInfo.push_back(info);
293     }
294     return true;
295 }
296 
SplitMids(std::string src,std::vector<std::string> & dest,const std::string delimiter)297 void HRilSms::SplitMids(std::string src, std::vector<std::string> &dest, const std::string delimiter)
298 {
299     if (src.empty()) {
300         return;
301     }
302     size_t pos = src.find(delimiter);
303     while (pos != std::string::npos) {
304         dest.push_back(src.substr(0, pos));
305         src.erase(0, pos + delimiter.length());
306         pos = src.find(delimiter);
307     }
308     dest.push_back(src);
309 }
310 
SplitValue(std::string value,std::string & start,std::string & end,const std::string delimiter)311 bool HRilSms::SplitValue(std::string value, std::string &start, std::string &end, const std::string delimiter)
312 {
313     if (value.empty()) {
314         return false;
315     }
316     size_t pos = value.find(delimiter);
317     if (pos == 0 || pos == value.size() - 1) {
318         return false;
319     } else if (pos == std::string::npos) {
320         start = value;
321         end = value;
322         return true;
323     }
324     start = value.substr(0, pos);
325     end = value.substr(pos + 1);
326     return true;
327 }
328 
GetCBConfig(int32_t serialId)329 int32_t HRilSms::GetCBConfig(int32_t serialId)
330 {
331     return RequestVendor(serialId, HREQ_SMS_GET_CB_CONFIG, smsFuncs_, &HRilSmsReq::GetCBConfig);
332 }
333 
SetCdmaCBConfig(int32_t serialId,const OHOS::HDI::Ril::V1_1::CdmaCBConfigInfoList & cellBroadcastInfoList)334 int32_t HRilSms::SetCdmaCBConfig(
335     int32_t serialId, const OHOS::HDI::Ril::V1_1::CdmaCBConfigInfoList &cellBroadcastInfoList)
336 {
337     if ((smsFuncs_ == nullptr) || (smsFuncs_->SetCdmaCBConfig == nullptr)) {
338         TELEPHONY_LOGE("(smsFuncs_ or msFuncs_->SetCdmaCBConfig is null");
339         return HRIL_ERR_NULL_POINT;
340     }
341     ReqDataInfo *requestInfo = CreateHRilRequest(serialId, HREQ_SMS_SET_CDMA_CB_CONFIG);
342     if (requestInfo == nullptr) {
343         return HRIL_ERR_INVALID_PARAMETER;
344     }
345     auto size = cellBroadcastInfoList.size;
346     std::unique_ptr<HRilCdmaCBConfigInfo[]> list = std::make_unique<HRilCdmaCBConfigInfo[]>(size);
347     CopyToHRilCdmaCBConfigInfo(list.get(), cellBroadcastInfoList);
348     smsFuncs_->SetCdmaCBConfig(requestInfo, list.get(), cellBroadcastInfoList.size * sizeof(HRilCdmaCBConfigInfo));
349     return HRIL_ERR_SUCCESS;
350 }
351 
GetCdmaCBConfig(int32_t serialId)352 int32_t HRilSms::GetCdmaCBConfig(int32_t serialId)
353 {
354     return RequestVendor(serialId, HREQ_SMS_GET_CDMA_CB_CONFIG, smsFuncs_, &HRilSmsReq::GetCdmaCBConfig);
355 }
356 
SendSmsMoreMode(int32_t serialId,const OHOS::HDI::Ril::V1_1::GsmSmsMessageInfo & gsmSmsMessageInfo)357 int32_t HRilSms::SendSmsMoreMode(int32_t serialId, const OHOS::HDI::Ril::V1_1::GsmSmsMessageInfo &gsmSmsMessageInfo)
358 {
359     const int32_t COUNT_STRINGS_VALUE = 2;
360     return RequestWithStrings(serialId, HREQ_SMS_SEND_SMS_MORE_MODE, COUNT_STRINGS_VALUE,
361         gsmSmsMessageInfo.smscPdu.c_str(), gsmSmsMessageInfo.pdu.c_str());
362 }
363 
SendSmsAck(int32_t serialId,const OHOS::HDI::Ril::V1_1::ModeData & modeData)364 int32_t HRilSms::SendSmsAck(int32_t serialId, const OHOS::HDI::Ril::V1_1::ModeData &modeData)
365 {
366     if ((smsFuncs_ == nullptr) || (smsFuncs_->SendSmsAck == nullptr)) {
367         TELEPHONY_LOGE("smsFuncs_ or smsFuncs_->SendSmsAck is null");
368         return HRIL_ERR_NULL_POINT;
369     }
370     ReqDataInfo *requestInfo = CreateHRilRequest(serialId, HREQ_SMS_SEND_SMS_ACK);
371     if (requestInfo == nullptr) {
372         return HRIL_ERR_INVALID_PARAMETER;
373     }
374     int32_t *pBuff = nullptr;
375     const int32_t COUNT_INTS_VALUE = 2;
376     RequestWithInts(&pBuff, requestInfo, COUNT_INTS_VALUE, static_cast<int32_t>(modeData.result), modeData.mode);
377     smsFuncs_->SendSmsAck(requestInfo, pBuff, sizeof(int32_t));
378     if (pBuff != nullptr) {
379         SafeFrees(pBuff);
380     }
381     return HRIL_ERR_SUCCESS;
382 }
383 
AddCdmaSimMessage(int32_t serialId,const OHOS::HDI::Ril::V1_1::SmsMessageIOInfo & message)384 int32_t HRilSms::AddCdmaSimMessage(int32_t serialId, const OHOS::HDI::Ril::V1_1::SmsMessageIOInfo &message)
385 {
386     HRilSmsWriteCdmaSms msg = {};
387     msg.state = message.state;
388     if (!CreateCdmaMessageInfo(msg.cdmaMessageInfo, message.pdu)) {
389         TELEPHONY_LOGE("CreateCdmaMessageInfo failed");
390         return HRIL_ERR_INVALID_PARAMETER;
391     }
392     int32_t result = RequestVendor(serialId, HREQ_SMS_ADD_CDMA_SIM_MESSAGE, smsFuncs_, &HRilSmsReq::AddCdmaSimMessageV2,
393         &msg, sizeof(HRilSmsWriteCdmaSms));
394     TELEPHONY_LOGI("AddCdmaSimMessageV2 result is: %{public}d", result);
395     return result;
396 }
397 
CreateCdmaMessageInfo(HRilCdmaSmsMessageInfo & cdmaSmsInfo,const std::string & pdu)398 bool HRilSms::CreateCdmaMessageInfo(HRilCdmaSmsMessageInfo &cdmaSmsInfo, const std::string &pdu)
399 {
400     if (!CheckCdmaPduLength(cdmaSmsInfo, pdu)) {
401         TELEPHONY_LOGE("pdu is invalid");
402         return false;
403     }
404     cdmaSmsInfo.serviceId = stoi(pdu.substr(0, INT_LEN), 0, HEXADECIMAL);
405     cdmaSmsInfo.isExist = stoi(pdu.substr(INT_LEN + BYTE_LEN * NUM_3, BYTE_LEN), 0, HEXADECIMAL);
406     cdmaSmsInfo.type = stoi(pdu.substr(INT_LEN + INT_LEN, INT_LEN), 0, HEXADECIMAL);
407     int32_t index = INT_LEN * NUM_3;
408     // adress
409     cdmaSmsInfo.address.digitMode = stoi(pdu.substr(index, BYTE_LEN), 0, HEXADECIMAL);
410     cdmaSmsInfo.address.mode = stoi(pdu.substr(index + BYTE_LEN, BYTE_LEN), 0, HEXADECIMAL);
411     cdmaSmsInfo.address.type = stoi(pdu.substr(index + BYTE_LEN * NUM_2, BYTE_LEN), 0, HEXADECIMAL);
412     cdmaSmsInfo.address.plan = stoi(pdu.substr(index + BYTE_LEN * NUM_3, BYTE_LEN), 0, HEXADECIMAL);
413     cdmaSmsInfo.address.number = stoi(pdu.substr(index + BYTE_LEN * NUM_4, BYTE_LEN), 0, HEXADECIMAL);
414     std::string addByte = pdu.substr(index + BYTE_LEN * NUM_5, BYTE_LEN * cdmaSmsInfo.address.number);
415     char *addressByte = reinterpret_cast<char *>(cdmaSmsInfo.address.bytes);
416     if (strcpy_s(addressByte, cdmaSmsInfo.address.number + 1, addByte.c_str()) != EOK) {
417         TELEPHONY_LOGE("strcpy_s fail.");
418         return false;
419     }
420     index += BYTE_LEN * NUM_5 + BYTE_LEN * cdmaSmsInfo.address.number;
421     // subAdress
422     cdmaSmsInfo.subAddress.type = stoi(pdu.substr(index, BYTE_LEN), 0, HEXADECIMAL);
423     cdmaSmsInfo.subAddress.odd = stoi(pdu.substr(index + BYTE_LEN, BYTE_LEN), 0, HEXADECIMAL);
424     cdmaSmsInfo.subAddress.number = stoi(pdu.substr(index + BYTE_LEN * NUM_2, BYTE_LEN), 0, HEXADECIMAL);
425     std::string subAddByte = pdu.substr(index + BYTE_LEN * NUM_3, BYTE_LEN * cdmaSmsInfo.subAddress.number);
426     char *subAddressByte = reinterpret_cast<char *>(cdmaSmsInfo.subAddress.bytes);
427     if (strcpy_s(subAddressByte, cdmaSmsInfo.subAddress.number + 1, subAddByte.c_str()) != EOK) {
428         TELEPHONY_LOGE("strcpy_s fail.");
429         return false;
430     }
431     index += BYTE_LEN * NUM_3 + BYTE_LEN * cdmaSmsInfo.subAddress.number;
432     // bearer Data
433     cdmaSmsInfo.size = stoi(pdu.substr(index, BYTE_LEN), 0, HEXADECIMAL);
434     std::string byte = pdu.substr(index + BYTE_LEN, BYTE_LEN * cdmaSmsInfo.size);
435     char *byteInfo = reinterpret_cast<char *>(cdmaSmsInfo.bytes);
436     if (strcpy_s(byteInfo, cdmaSmsInfo.size + 1, byte.c_str()) != EOK) {
437         TELEPHONY_LOGE("strcpy_s fail.");
438         return false;
439     }
440     return true;
441 }
442 
CheckCdmaPduLength(HRilCdmaSmsMessageInfo & cdmaSmsInfo,const std::string & pdu)443 bool HRilSms::CheckCdmaPduLength(HRilCdmaSmsMessageInfo &cdmaSmsInfo, const std::string &pdu)
444 {
445     int32_t index = INT_LEN * NUM_3 + BYTE_LEN * NUM_5;
446     // adress
447     if (pdu.length() < static_cast<size_t>(index)) {
448         TELEPHONY_LOGE("pdu length invalid.");
449         return false;
450     }
451     if (!regex_match(pdu, std::regex("[0-9a-fA-F]+"))) {
452         TELEPHONY_LOGE("pdu invalid.");
453         return false;
454     }
455     cdmaSmsInfo.address.number = stoi(pdu.substr(index - BYTE_LEN, BYTE_LEN), 0, HEXADECIMAL);
456     index += BYTE_LEN * cdmaSmsInfo.address.number + BYTE_LEN * NUM_3;
457     if (pdu.length() < static_cast<size_t>(index)) {
458         TELEPHONY_LOGE("pdu length invalid.");
459         return false;
460     }
461     // subAdress
462     cdmaSmsInfo.subAddress.number = stoi(pdu.substr(index - BYTE_LEN, BYTE_LEN), 0, HEXADECIMAL);
463     index += BYTE_LEN * cdmaSmsInfo.subAddress.number + BYTE_LEN;
464     if (pdu.length() < static_cast<size_t>(index)) {
465         TELEPHONY_LOGE("pdu length invalid.");
466         return false;
467     }
468     // bearer Data
469     cdmaSmsInfo.size = stoi(pdu.substr(index - BYTE_LEN, BYTE_LEN), 0, HEXADECIMAL);
470     index += BYTE_LEN * cdmaSmsInfo.size;
471     if (pdu.length() < static_cast<size_t>(index)) {
472         TELEPHONY_LOGE("pdu length invalid.");
473         return false;
474     }
475     return true;
476 }
477 
DelCdmaSimMessage(int32_t serialId,int32_t index)478 int32_t HRilSms::DelCdmaSimMessage(int32_t serialId, int32_t index)
479 {
480     if ((smsFuncs_ == nullptr) || (smsFuncs_->DelCdmaSimMessage == nullptr)) {
481         TELEPHONY_LOGE("smsFuncs_ or smsFuncs_->DelCdmaSimMessage is null");
482         return HRIL_ERR_NULL_POINT;
483     }
484     ReqDataInfo *requestInfo = CreateHRilRequest(serialId, HREQ_SMS_DEL_CDMA_SIM_MESSAGE);
485     if (requestInfo == nullptr) {
486         return HRIL_ERR_INVALID_PARAMETER;
487     }
488     int32_t *pBuff = nullptr;
489     RequestWithInts(&pBuff, requestInfo, 1, index);
490     smsFuncs_->DelCdmaSimMessage(requestInfo, pBuff, sizeof(int32_t));
491     if (pBuff != nullptr) {
492         SafeFrees(pBuff);
493     }
494     return HRIL_ERR_SUCCESS;
495 }
496 
UpdateCdmaSimMessage(int32_t serialId,const OHOS::HDI::Ril::V1_1::SmsMessageIOInfo & message)497 int32_t HRilSms::UpdateCdmaSimMessage(int32_t serialId, const OHOS::HDI::Ril::V1_1::SmsMessageIOInfo &message)
498 {
499     HRilSmsWriteSms msg = {};
500     size_t len = 0;
501     len = message.pdu.size() + 1;
502     msg.state = message.state;
503     if (len > MAX_CHN_LEN) {
504         return HRIL_ERR_INVALID_PARAMETER;
505     }
506     CopyToCharPoint(&msg.pdu, message.pdu);
507     msg.index = message.index;
508     RequestVendor(serialId, HREQ_SMS_UPDATE_CDMA_SIM_MESSAGE, smsFuncs_, &HRilSmsReq::UpdateCdmaSimMessage, &msg,
509         sizeof(HRilSmsWriteSms));
510     SafeFrees(msg.pdu);
511     return HRIL_ERR_SUCCESS;
512 }
513 
SendGsmSmsResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)514 int32_t HRilSms::SendGsmSmsResponse(
515     int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
516 {
517     HDI::Ril::V1_1::SendSmsResultInfo result =
518         MakeSendSmsResult(responseInfo, responseInfo.serial, response, responseLen);
519     return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SendGsmSmsResponse, result);
520 }
521 
SendCdmaSmsResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)522 int32_t HRilSms::SendCdmaSmsResponse(
523     int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
524 {
525     HDI::Ril::V1_1::SendSmsResultInfo result =
526         MakeSendSmsResult(responseInfo, responseInfo.serial, response, responseLen);
527     return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SendCdmaSmsResponse, result);
528 }
529 
AddSimMessageResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)530 int32_t HRilSms::AddSimMessageResponse(
531     int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
532 {
533     TELEPHONY_LOGI("AddSimMessageResponse send");
534     return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::AddSimMessageResponse);
535 }
536 
DelSimMessageResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)537 int32_t HRilSms::DelSimMessageResponse(
538     int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
539 {
540     return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::DelSimMessageResponse);
541 }
542 
UpdateSimMessageResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)543 int32_t HRilSms::UpdateSimMessageResponse(
544     int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
545 {
546     return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::UpdateSimMessageResponse);
547 }
548 
SetSmscAddrResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)549 int32_t HRilSms::SetSmscAddrResponse(
550     int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
551 {
552     return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetSmscAddrResponse);
553 }
554 
GetSmscAddrResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)555 int32_t HRilSms::GetSmscAddrResponse(
556     int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
557 {
558     HDI::Ril::V1_1::ServiceCenterAddress result;
559     if (response == nullptr || responseLen != sizeof(HRilServiceCenterAddress)) {
560         TELEPHONY_LOGE("Invalid response: response is nullptr");
561         if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
562             responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
563         }
564         result.address = std::string("");
565     } else {
566         const HRilServiceCenterAddress *address = static_cast<const HRilServiceCenterAddress *>(response);
567         result.tosca = address->tosca;
568         if (address->address == nullptr) {
569             result.address = std::string("");
570             TELEPHONY_LOGE("address is nullptr");
571         } else {
572             result.address = std::string(address->address);
573         }
574         TELEPHONY_LOGI("result address:%{private}s, tosca:%{private}d", result.address.c_str(), result.tosca);
575     }
576     return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetSmscAddrResponse, result);
577 }
578 
SetCBConfigResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)579 int32_t HRilSms::SetCBConfigResponse(
580     int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
581 {
582     return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetCBConfigResponse);
583 }
584 
GetCBConfigResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)585 int32_t HRilSms::GetCBConfigResponse(
586     int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
587 {
588     HDI::Ril::V1_1::CBConfigInfo broadcastInfo;
589     if (response == nullptr) {
590         TELEPHONY_LOGE("Invalid response: response is nullptr");
591         broadcastInfo.mode = -1;
592         broadcastInfo.mids = std::string("");
593         broadcastInfo.dcss = std::string("");
594     } else {
595         HRilCBConfigInfo *cellBroadcastInfo = (HRilCBConfigInfo *)response;
596         size_t len = responseLen / sizeof(HRilCBConfigInfo);
597         if (len != 0) {
598             if (!GetCBConfigInfo(cellBroadcastInfo, len, broadcastInfo)) {
599                 TELEPHONY_LOGE("result is invalid");
600             }
601         }
602         TELEPHONY_LOGD("mode:%{public}d, mids:%{public}s, dcss:%{public}s", broadcastInfo.mode,
603             broadcastInfo.mids.c_str(), broadcastInfo.dcss.c_str());
604     }
605     return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetCBConfigResponse, broadcastInfo);
606 }
607 
GetCBConfigInfo(HRilCBConfigInfo * cellBroadcastInfo,size_t len,OHOS::HDI::Ril::V1_1::CBConfigInfo & broadcastInfo)608 bool HRilSms::GetCBConfigInfo(
609     HRilCBConfigInfo *cellBroadcastInfo, size_t len, OHOS::HDI::Ril::V1_1::CBConfigInfo &broadcastInfo)
610 {
611     broadcastInfo.mode = cellBroadcastInfo[0].selected;
612     std::string mids;
613     std::string dcss;
614     for (size_t locate = 0; locate < len; locate++) {
615         if (cellBroadcastInfo[locate].startOfServiceId > cellBroadcastInfo[locate].endOfServiceId) {
616             TELEPHONY_LOGE("result.mids is invalid");
617             return false;
618         } else if (cellBroadcastInfo[locate].startOfServiceId < cellBroadcastInfo[locate].endOfServiceId) {
619             mids += std::to_string(cellBroadcastInfo[locate].startOfServiceId) + "-" +
620                     std::to_string(cellBroadcastInfo[locate].endOfServiceId) + COMMA_STR;
621         } else {
622             mids += std::to_string(cellBroadcastInfo[locate].startOfServiceId) + COMMA_STR;
623         }
624         if (cellBroadcastInfo[locate].startOfCodeScheme > cellBroadcastInfo[locate].endOfCodeScheme) {
625             TELEPHONY_LOGE("result.dcss is invalid");
626             return false;
627         } else if (cellBroadcastInfo[locate].startOfCodeScheme < cellBroadcastInfo[locate].endOfCodeScheme) {
628             dcss += std::to_string(cellBroadcastInfo[locate].startOfCodeScheme) + "-" +
629                     std::to_string(cellBroadcastInfo[locate].endOfCodeScheme) + COMMA_STR;
630         } else {
631             dcss += std::to_string(cellBroadcastInfo[locate].startOfCodeScheme) + COMMA_STR;
632         }
633     }
634     broadcastInfo.mids = mids;
635     broadcastInfo.dcss = dcss;
636     return true;
637 }
638 
SetCdmaCBConfigResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)639 int32_t HRilSms::SetCdmaCBConfigResponse(
640     int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
641 {
642     return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetCdmaCBConfigResponse);
643 }
644 
GetCdmaCBConfigResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)645 int32_t HRilSms::GetCdmaCBConfigResponse(
646     int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
647 {
648     HDI::Ril::V1_1::CdmaCBConfigInfo broadcastInfo;
649     if (response == nullptr || responseLen != sizeof(HRilCdmaCBConfigInfo)) {
650         TELEPHONY_LOGE("Invalid response: response is nullptr");
651         broadcastInfo.checked = -1;
652         broadcastInfo.language = -1;
653         broadcastInfo.service = -1;
654     } else {
655         const HRilCdmaCBConfigInfo *cellBroadcastInfo = static_cast<const HRilCdmaCBConfigInfo *>(response);
656         broadcastInfo.checked = cellBroadcastInfo->checked;
657         broadcastInfo.language = cellBroadcastInfo->language;
658         broadcastInfo.service = cellBroadcastInfo->service;
659         TELEPHONY_LOGE("checked:%{public}c, language:%{public}d, service:%{public}d", cellBroadcastInfo->checked,
660             cellBroadcastInfo->language, cellBroadcastInfo->service);
661     }
662     return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetCdmaCBConfigResponse, broadcastInfo);
663 }
664 
SendSmsMoreModeResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)665 int32_t HRilSms::SendSmsMoreModeResponse(
666     int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
667 {
668     HDI::Ril::V1_1::SendSmsResultInfo result =
669         MakeSendSmsResult(responseInfo, responseInfo.serial, response, responseLen);
670     return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SendSmsMoreModeResponse, result);
671 }
672 
SendSmsAckResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)673 int32_t HRilSms::SendSmsAckResponse(
674     int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
675 {
676     return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SendSmsAckResponse);
677 }
678 
AddCdmaSimMessageResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)679 int32_t HRilSms::AddCdmaSimMessageResponse(
680     int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
681 {
682     TELEPHONY_LOGI("receive response");
683     return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::AddCdmaSimMessageResponse);
684 }
685 
DelCdmaSimMessageResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)686 int32_t HRilSms::DelCdmaSimMessageResponse(
687     int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
688 {
689     return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::DelCdmaSimMessageResponse);
690 }
691 
UpdateCdmaSimMessageResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)692 int32_t HRilSms::UpdateCdmaSimMessageResponse(
693     int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
694 {
695     return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::UpdateCdmaSimMessageResponse);
696 }
697 
SmsStatusReportNotify(int32_t indType,const HRilErrNumber error,const void * response,size_t responseLen)698 int32_t HRilSms::SmsStatusReportNotify(
699     int32_t indType, const HRilErrNumber error, const void *response, size_t responseLen)
700 {
701     if (response == nullptr || responseLen == 0) {
702         TELEPHONY_LOGE("invalid response");
703         return HRIL_ERR_GENERIC_FAILURE;
704     }
705     HDI::Ril::V1_1::SmsMessageInfo smsMessageInfo;
706     uint8_t *bytes = ConvertHexStringToBytes(response, responseLen);
707     if (bytes == nullptr) {
708         TELEPHONY_LOGE("ConvertHexStringToBytes in SmsStatusReportNotify is failed!");
709         return HRIL_ERR_GENERIC_FAILURE;
710     }
711     const size_t MESSAGE_SIZE = responseLen / HEX_WIDTH;
712     smsMessageInfo.size = MESSAGE_SIZE;
713     smsMessageInfo.indicationType = static_cast<int32_t>(ConvertIntToRadioNoticeType(indType));
714     uint8_t *temp = bytes;
715     for (int32_t i = 0; i < smsMessageInfo.size; i++) {
716         smsMessageInfo.pdu.push_back(*temp);
717         temp++;
718     }
719     SafeFrees(bytes);
720     return Notify(indType, error, &HDI::Ril::V1_1::IRilCallback::SmsStatusReportNotify, smsMessageInfo);
721 }
722 
NewSmsStoredOnSimNotify(int32_t indType,const HRilErrNumber error,const void * response,size_t responseLen)723 int32_t HRilSms::NewSmsStoredOnSimNotify(
724     int32_t indType, const HRilErrNumber error, const void *response, size_t responseLen)
725 {
726     if (response == nullptr || responseLen != sizeof(int32_t)) {
727         TELEPHONY_LOGE("invalid response");
728         return HRIL_ERR_SUCCESS;
729     }
730     int32_t recordNumber = *(static_cast<const int32_t *>(response));
731     indType = static_cast<int32_t>(ConvertIntToRadioNoticeType(indType));
732     return Notify(indType, error, &HDI::Ril::V1_1::IRilCallback::NewSmsStoredOnSimNotify, recordNumber, indType);
733 }
734 
NewSmsNotify(int32_t indType,const HRilErrNumber error,const void * response,size_t responseLen)735 int32_t HRilSms::NewSmsNotify(int32_t indType, const HRilErrNumber error, const void *response, size_t responseLen)
736 {
737     HRilSmsResponse *smsResponse = nullptr;
738     if (response == nullptr || responseLen == 0) {
739         TELEPHONY_LOGE("NewSmsNotify: invalid response");
740         return HDF_FAILURE;
741     } else {
742         smsResponse = (HRilSmsResponse *)response;
743     }
744     uint8_t *bytes = ConvertHexStringToBytes(smsResponse->pdu, responseLen);
745     if (bytes == nullptr) {
746         TELEPHONY_LOGE("NewSmsNotify: ConvertHexStringToBytes failed");
747         return HRIL_ERR_GENERIC_FAILURE;
748     }
749     HDI::Ril::V1_1::SmsMessageInfo smsMessageInfo;
750     const size_t NEW_SMS_SIZE = responseLen / HEX_WIDTH;
751     smsMessageInfo.size = NEW_SMS_SIZE;
752     smsMessageInfo.indicationType = indType;
753     uint8_t *temp = bytes;
754     for (int32_t i = 0; i < static_cast<int32_t>(smsMessageInfo.size); i++) {
755         smsMessageInfo.pdu.push_back(*temp);
756         temp++;
757     }
758     SafeFrees(bytes);
759     return Notify(indType, error, &HDI::Ril::V1_1::IRilCallback::NewSmsNotify, smsMessageInfo);
760 }
761 
NewCdmaSmsNotify(int32_t indType,const HRilErrNumber error,const void * response,size_t responseLen)762 int32_t HRilSms::NewCdmaSmsNotify(int32_t indType, const HRilErrNumber error, const void *response, size_t responseLen)
763 {
764     HRilSmsResponse *message = nullptr;
765     if (response == nullptr || responseLen == 0) {
766         TELEPHONY_LOGE("invalid response");
767         return HRIL_ERR_GENERIC_FAILURE;
768     } else {
769         message = (HRilSmsResponse *)response;
770     }
771     HDI::Ril::V1_1::SmsMessageInfo messageInfo;
772     messageInfo.indicationType = indType;
773     if (message->pdu != nullptr) {
774         messageInfo.size = strlen(message->pdu) / HEX_WIDTH;
775         uint8_t *bytes = ConvertHexStringToBytes(message->pdu, strlen(message->pdu));
776         if (bytes == nullptr) {
777             TELEPHONY_LOGE("bytes is nullptr");
778             return HRIL_ERR_GENERIC_FAILURE;
779         }
780         uint8_t *temp = bytes;
781         for (int32_t i = 0; i < messageInfo.size; i++) {
782             messageInfo.pdu.push_back(*temp);
783             temp++;
784         }
785         SafeFrees(bytes);
786     }
787     return Notify(indType, error, &HDI::Ril::V1_1::IRilCallback::NewCdmaSmsNotify, messageInfo);
788 }
789 
CBConfigNotify(int32_t indType,const HRilErrNumber error,const void * response,size_t responseLen)790 int32_t HRilSms::CBConfigNotify(int32_t indType, const HRilErrNumber error, const void *response, size_t responseLen)
791 {
792     HDI::Ril::V1_1::CBConfigReportInfo result = MakeCBConfigResult(response, responseLen);
793     result.indicationType = indType;
794     return Notify(indType, error, &HDI::Ril::V1_1::IRilCallback::CBConfigNotify, result);
795 }
796 
IsSmsResponse(uint32_t code)797 bool HRilSms::IsSmsResponse(uint32_t code)
798 {
799     return ((code >= HREQ_SMS_BASE) && (code < HREQ_SIM_BASE));
800 }
801 
IsSmsNotification(uint32_t code)802 bool HRilSms::IsSmsNotification(uint32_t code)
803 {
804     return ((code >= HNOTI_SMS_BASE) && (code < HNOTI_SIM_BASE));
805 }
806 
RequestWithInts(int32_t ** p,ReqDataInfo * requestInfo,int32_t argCount,...)807 int32_t HRilSms::RequestWithInts(int32_t **p, ReqDataInfo *requestInfo, int32_t argCount, ...)
808 {
809     size_t len = sizeof(int32_t);
810     if (len <= 0 || argCount <= 0) {
811         return false;
812     }
813     *p = static_cast<int32_t *>(malloc(argCount * len));
814     if (*p == nullptr) {
815         TELEPHONY_LOGE("req: [%{public}d,%{public}d,%{public}d], malloc fail", requestInfo->serial,
816             static_cast<int32_t>(requestInfo->slotId), requestInfo->request);
817         return false;
818     }
819     if (memset_s(*p, argCount * len, 0, argCount * len) != EOK) {
820         TELEPHONY_LOGE("RequestWithInts memset_s failed");
821         SafeFrees(*p);
822         return false;
823     }
824     va_list list;
825     va_start(list, argCount);
826     int32_t i = 0;
827     while (i < argCount) {
828         (*p)[i] = va_arg(list, int32_t);
829         i++;
830     }
831     va_end(list);
832     return true;
833 }
834 
RequestWithStrings(int32_t serial,int32_t request,int32_t count,...)835 int32_t HRilSms::RequestWithStrings(int32_t serial, int32_t request, int32_t count, ...)
836 {
837     if ((smsFuncs_ == nullptr) || (smsFuncs_->SendGsmSms == nullptr)) {
838         TELEPHONY_LOGE("smsFuncs_ or smsFuncs_->SendGsmSms is null");
839         return HRIL_ERR_NULL_POINT;
840     }
841     char **pBuff = nullptr;
842     if (count <= 0) {
843         return HRIL_ERR_NULL_POINT;
844     }
845     int32_t len = count * sizeof(char *);
846     pBuff = (char **)malloc(len);
847     if (pBuff == nullptr) {
848         TELEPHONY_LOGE("req: [%{public}d,%{public}d], malloc fail", serial, request);
849         return HRIL_ERR_NULL_POINT;
850     }
851     if (memset_s(pBuff, len, 0, len) != EOK) {
852         TELEPHONY_LOGE("RequestWithInts memset_s failed");
853         SafeFrees(pBuff);
854         return HRIL_ERR_NULL_POINT;
855     }
856     va_list list;
857     va_start(list, count);
858     int32_t i = 0;
859     while (i < count) {
860         const char *str = va_arg(list, const char *);
861         if (!ConvertToString(&pBuff[i], str)) {
862             TELEPHONY_LOGE("ConvertToString in RequestWithStrings is failed!");
863             va_end(list);
864             for (int32_t j = 0; j < i; j++) {
865                 SafeFrees(pBuff[j]);
866             }
867             SafeFrees(pBuff);
868             return HRIL_ERR_NULL_POINT;
869         }
870         i++;
871     }
872     va_end(list);
873     int32_t result = RequestVendor(serial, request, smsFuncs_, &HRilSmsReq::SendGsmSms, pBuff, count);
874     if (pBuff != nullptr) {
875         i = 0;
876         while (i < count) {
877             SafeFrees(pBuff[i]);
878             i++;
879         }
880         SafeFrees(pBuff);
881     }
882     return result;
883 }
884 
MakeCBConfigResult(const void * response,const size_t responseLen)885 HDI::Ril::V1_1::CBConfigReportInfo HRilSms::MakeCBConfigResult(const void *response, const size_t responseLen)
886 {
887     HDI::Ril::V1_1::CBConfigReportInfo result;
888     if (response == nullptr || responseLen != sizeof(HRilCBConfigReportInfo)) {
889         TELEPHONY_LOGE("Invalid response: response is nullptr");
890         result.data = std::string("");
891         result.pdu = std::string("");
892         result.dcs = std::string("");
893     } else {
894         const HRilCBConfigReportInfo *cellBroadcastReportInfo = static_cast<const HRilCBConfigReportInfo *>(response);
895         result.mid = cellBroadcastReportInfo->mid;
896         result.length = cellBroadcastReportInfo->length;
897         result.page = cellBroadcastReportInfo->page;
898         result.pages = cellBroadcastReportInfo->pages;
899         result.sn = cellBroadcastReportInfo->sn;
900         if (cellBroadcastReportInfo->data == nullptr) {
901             result.data = std::string("");
902             TELEPHONY_LOGE("result.data is nullptr");
903         } else {
904             TELEPHONY_LOGI("result.data :%{private}s", cellBroadcastReportInfo->data);
905             result.data = std::string(cellBroadcastReportInfo->data);
906         }
907         if (cellBroadcastReportInfo->pdu == nullptr) {
908             result.pdu = std::string("");
909             TELEPHONY_LOGE("result.pdu is nullptr");
910         } else {
911             TELEPHONY_LOGI("result.pdu :%{private}s", cellBroadcastReportInfo->pdu);
912             result.pdu = StringToHex(cellBroadcastReportInfo->pdu, cellBroadcastReportInfo->length);
913         }
914         if (cellBroadcastReportInfo->dcs == nullptr) {
915             result.dcs = std::string("");
916             TELEPHONY_LOGE("result.dcs is nullptr");
917         } else {
918             TELEPHONY_LOGI("result.dcs :%{private}s", cellBroadcastReportInfo->dcs);
919             result.dcs = std::string(cellBroadcastReportInfo->dcs);
920         }
921     }
922     return result;
923 }
924 
MakeSendSmsResult(HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,int32_t serial,const void * response,const size_t responseLen)925 HDI::Ril::V1_1::SendSmsResultInfo HRilSms::MakeSendSmsResult(
926     HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, int32_t serial, const void *response, const size_t responseLen)
927 {
928     HDI::Ril::V1_1::SendSmsResultInfo result;
929     if (response == nullptr || responseLen != sizeof(HRilSmsResponse)) {
930         TELEPHONY_LOGE("Invalid response: response is nullptr");
931         if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
932             responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
933         }
934         result.pdu = std::string("");
935     } else {
936         const HRilSmsResponse *smsResponse = static_cast<const HRilSmsResponse *>(response);
937         result.msgRef = smsResponse->msgRef;
938         if (smsResponse->pdu == nullptr) {
939             result.pdu = std::string("");
940             TELEPHONY_LOGE("result.pdu is nullptr");
941         } else {
942             result.pdu = std::string(smsResponse->pdu);
943         }
944         result.errCode = smsResponse->errCode;
945     }
946     return result;
947 }
948 
CopyToHRilCdmaCBConfigInfo(HRilCdmaCBConfigInfo * list,OHOS::HDI::Ril::V1_1::CdmaCBConfigInfoList cellBroadcastInfoList)949 void HRilSms::CopyToHRilCdmaCBConfigInfo(
950     HRilCdmaCBConfigInfo *list, OHOS::HDI::Ril::V1_1::CdmaCBConfigInfoList cellBroadcastInfoList)
951 {
952     for (int32_t i = 0; i < cellBroadcastInfoList.size; i++) {
953         list[i].service = cellBroadcastInfoList.list[i].service;
954         list[i].language = cellBroadcastInfoList.list[i].language;
955         list[i].checked = cellBroadcastInfoList.list[i].checked;
956     }
957 }
958 } // namespace Telephony
959 } // namespace OHOS
960