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
23namespace OHOS {
24namespace Telephony {
25namespace {
26const size_t HEX_WIDTH = 2;
27const size_t MAX_PDU_LEN = 255;
28const size_t MAX_LEN = 100;
29const size_t MAX_CHN_LEN = 50000;
30const int32_t MSG_DEFAULT_INDEX = -1;
31const int32_t BYTE_LEN = 1;
32const int32_t INT_LEN = 4;
33const int32_t NUM_2 = 2;
34const int32_t NUM_3 = 3;
35const int32_t NUM_4 = 4;
36const int32_t NUM_5 = 5;
37const int HEXADECIMAL = 16;
38constexpr const char *COMMA_STR = ",";
39} // namespace
40
41HRilSms::HRilSms(int32_t slotId) : HRilBase(slotId)
42{
43    AddHandlerToMap();
44    AddNotificationToMap();
45}
46
47bool HRilSms::IsSmsRespOrNotify(uint32_t code)
48{
49    return IsSmsResponse(code) || IsSmsNotification(code);
50}
51
52void HRilSms::RegisterSmsFuncs(const HRilSmsReq *smsFuncs)
53{
54    smsFuncs_ = smsFuncs;
55}
56
57void 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
110void 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
130int32_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
137int32_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
143int32_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
166int32_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
185int32_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
208int32_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
225int32_t HRilSms::GetSmscAddr(int32_t serialId)
226{
227    return RequestVendor(serialId, HREQ_SMS_GET_SMSC_ADDR, smsFuncs_, &HRilSmsReq::GetSmscAddr);
228}
229
230int32_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
268bool 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
297void 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
311bool 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
329int32_t HRilSms::GetCBConfig(int32_t serialId)
330{
331    return RequestVendor(serialId, HREQ_SMS_GET_CB_CONFIG, smsFuncs_, &HRilSmsReq::GetCBConfig);
332}
333
334int32_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
352int32_t HRilSms::GetCdmaCBConfig(int32_t serialId)
353{
354    return RequestVendor(serialId, HREQ_SMS_GET_CDMA_CB_CONFIG, smsFuncs_, &HRilSmsReq::GetCdmaCBConfig);
355}
356
357int32_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
364int32_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
384int32_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
398bool 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
443bool 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
478int32_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
497int32_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
514int32_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
522int32_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
530int32_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
537int32_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
543int32_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
549int32_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
555int32_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
579int32_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
585int32_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
608bool 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
639int32_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
645int32_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
665int32_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
673int32_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
679int32_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
686int32_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
692int32_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
698int32_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
723int32_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
735int32_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
762int32_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
790int32_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
797bool HRilSms::IsSmsResponse(uint32_t code)
798{
799    return ((code >= HREQ_SMS_BASE) && (code < HREQ_SIM_BASE));
800}
801
802bool HRilSms::IsSmsNotification(uint32_t code)
803{
804    return ((code >= HNOTI_SMS_BASE) && (code < HNOTI_SIM_BASE));
805}
806
807int32_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
835int32_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
885HDI::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
925HDI::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
949void 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