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 "at_sms.h"
17 
18 #include <string.h>
19 
20 #include "hril_notification.h"
21 #include "vendor_report.h"
22 
23 static int32_t g_cmdLength = 2;
24 char *g_commaStr = ",";
25 char *g_hyphenStr = "-";
26 #define MAX_LENGTH 100
27 #define MAX_DIMEN_LENGTH 20
28 #define CHNL_LEN 6
29 
ProcessCellBroadcast(char * pBuff,HRilCBConfigReportInfo * response)30 int32_t ProcessCellBroadcast(char *pBuff, HRilCBConfigReportInfo *response)
31 {
32     char *tmp = NULL;
33     int32_t ret;
34     int32_t count = 0;
35 
36     if (pBuff == NULL || response == NULL) {
37         return -1;
38     }
39     tmp = pBuff;
40     while (*tmp != '\0' && tmp != NULL) {
41         if (*tmp == ',') {
42             count++;
43         }
44         tmp++;
45     }
46     SkipATPrefix(&pBuff);
47     if (count > 1) {
48         ret = NextInt(&pBuff, &response->sn);
49         if (ret == -1) {
50             TELEPHONY_LOGE("sn is null");
51         }
52         ret = NextInt(&pBuff, &response->mid);
53         if (ret == -1) {
54             TELEPHONY_LOGE("mid is null");
55         }
56         ret = NextInt(&pBuff, &response->page);
57         if (ret == -1) {
58             TELEPHONY_LOGE("page is null");
59         }
60         ret = NextInt(&pBuff, &response->pages);
61         if (ret == -1) {
62             TELEPHONY_LOGE("pages is null");
63         }
64         ret = NextStr(&pBuff, &response->dcs);
65         if (ret == -1) {
66             TELEPHONY_LOGE("dcs is null");
67         }
68     } else {
69         ret = NextInt(&pBuff, &response->length);
70         if (ret == -1) {
71             TELEPHONY_LOGE("mode is null");
72         }
73     }
74     return count;
75 }
76 
HandlerSmsResult(HRilSmsResponse * response,struct ReportInfo * reportInfo,const ReqDataInfo * requestInfo,int32_t * err,ResponseInfo * responseInfo)77 static void HandlerSmsResult(HRilSmsResponse *response, struct ReportInfo *reportInfo, const ReqDataInfo *requestInfo,
78     int32_t *err, ResponseInfo *responseInfo)
79 {
80     if (reportInfo == NULL || err == NULL) {
81         return;
82     }
83     char *pLine = NULL;
84     *err = HRIL_ERR_GENERIC_FAILURE;
85     if (responseInfo && responseInfo->result) {
86         pLine = responseInfo->result;
87         SkipATPrefix(&pLine);
88         NextInt(&pLine, err);
89     }
90     if (*err == -1) {
91         *err = HRIL_ERR_INVALID_RESPONSE;
92     }
93     *reportInfo = CreateReportInfo(requestInfo, *err, HRIL_RESPONSE, 0);
94     OnSmsReport(GetSlotId(requestInfo), *reportInfo, NULL, 0);
95     FreeResponseInfo(responseInfo);
96 }
97 
HandleResult(int32_t * err,char * result,const ResponseInfo * responseInfo,HRilSmsResponse * response)98 static void HandleResult(int32_t *err, char *result, const ResponseInfo *responseInfo, HRilSmsResponse *response)
99 {
100     if (response == NULL || err == NULL || responseInfo == NULL) {
101         TELEPHONY_LOGE("response is NULL");
102         return;
103     }
104     if (responseInfo->head != NULL) {
105         result = responseInfo->head->data;
106         SkipATPrefix(&result);
107         *err = NextInt(&result, &response->msgRef);
108         if (*err != 0) {
109             TELEPHONY_LOGE("NextInt in ReqSendGsmSms is failed!");
110         }
111     } else {
112         response->msgRef = 1;
113     }
114 }
115 
ReqSendGsmSms(const ReqDataInfo * requestInfo,const char * const * data,size_t dataLen)116 void ReqSendGsmSms(const ReqDataInfo *requestInfo, const char *const *data, size_t dataLen)
117 {
118     if (data == NULL || dataLen <= 1) {
119         TELEPHONY_LOGE("data error");
120         return;
121     }
122     char *smsc = NULL;
123     char smscTemp[MAX_CMD_LENGTH] = {0};
124     const char *pdu = NULL;
125     char cmd[MAX_CMD_LENGTH] = {0};
126     char smsPdu[MAX_CMD_LENGTH] = {0};
127     char *result = NULL;
128     int32_t err;
129     struct ReportInfo reportInfo = {0};
130     ResponseInfo *responseInfo = NULL;
131     HRilSmsResponse response = {0};
132     smsc = ((char **)data)[0];
133 
134     if (smsc == NULL) {
135         err = GenerateCommand(smscTemp, MAX_CMD_LENGTH, "%s", "00");
136         if (err < 0) {
137             TELEPHONY_LOGE("GenerateCommand failed, err = %{public}d\n", err);
138             HandlerSmsResult(&response, &reportInfo, requestInfo, &err, responseInfo);
139         }
140         smsc = smscTemp;
141     }
142     pdu = ((const char **)data)[1];
143     err = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CMGS=%d", strlen(pdu) / g_cmdLength);
144     if (err < 0) {
145         TELEPHONY_LOGE("GenerateCommand failed, err = %{public}d\n", err);
146         HandlerSmsResult(&response, &reportInfo, requestInfo, &err, responseInfo);
147         return;
148     }
149     err = GenerateCommand(smsPdu, MAX_CMD_LENGTH, "%s%s", smsc, pdu);
150     if (err < 0) {
151         TELEPHONY_LOGE("GenerateCommand failed, err = %{public}d\n", err);
152         HandlerSmsResult(&response, &reportInfo, requestInfo, &err, responseInfo);
153         return;
154     }
155     err = SendCommandSmsLock(cmd, smsPdu, "+CMGS:", 0, &responseInfo);
156     if (err != 0 || (responseInfo != NULL && !responseInfo->success)) {
157         HandlerSmsResult(&response, &reportInfo, requestInfo, &err, responseInfo);
158         return;
159     }
160     HandleResult(&err, result, responseInfo, &response);
161     reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
162     OnSmsReport(GetSlotId(requestInfo), reportInfo, (const uint8_t *)&response, sizeof(HRilSmsResponse));
163     FreeResponseInfo(responseInfo);
164 }
165 
ReqSendSmsAck(const ReqDataInfo * requestInfo,const int32_t * data,size_t dataLen)166 void ReqSendSmsAck(const ReqDataInfo *requestInfo, const int32_t *data, size_t dataLen)
167 {
168     int32_t ackFlag;
169     int32_t err;
170     if (data == NULL || dataLen == 0) {
171         TELEPHONY_LOGE("data error");
172         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_INVALID_RESPONSE, HRIL_RESPONSE, 0);
173         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
174         return;
175     }
176     ackFlag = ((int32_t *)data)[0];
177     if (ackFlag == 1) {
178         err = SendCommandLock("AT+CNMA=1", NULL, 0, NULL);
179     } else if (ackFlag == 0) {
180         err = SendCommandLock("AT+CNMA=2", NULL, 0, NULL);
181     } else {
182         TELEPHONY_LOGE("unsupported arg to HREQ_SMS_SEND_SMS_ACKNOWLEDGE\n");
183         err = HRIL_ERR_GENERIC_FAILURE;
184     }
185     struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
186     OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
187 }
188 
ReqSendCdmaSms(const ReqDataInfo * requestInfo,const char * data,size_t dataLen)189 void ReqSendCdmaSms(const ReqDataInfo *requestInfo, const char *data, size_t dataLen)
190 {
191     char *result = NULL;
192     int32_t err;
193     ResponseInfo *responseInfo = NULL;
194     struct ReportInfo reportInfo = {0};
195     HRilSmsResponse response = {0};
196 
197     if (data == NULL) {
198         reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_GENERIC_FAILURE, HRIL_RESPONSE, 0);
199         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
200         FreeResponseInfo(responseInfo);
201         return;
202     }
203     err = SendCommandLock("AT+COPS?", "COPS?", 0, &responseInfo);
204     if (err != 0 || (responseInfo != NULL && !responseInfo->success)) {
205         TELEPHONY_LOGE("AT+COPS? send failed");
206         HandlerSmsResult(&response, &reportInfo, requestInfo, &err, responseInfo);
207         // responseInfo freed in HandlerSmsResult
208         return;
209     }
210     err = SendCommandLock("AT$QCMGF=0", "$QCMGF=0", 0, &responseInfo);
211     if (err != 0 || responseInfo == NULL || !responseInfo->success) {
212         response.msgRef = HRIL_ERR_GENERIC_FAILURE;
213         reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
214         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
215         FreeResponseInfo(responseInfo);
216         return;
217     }
218     if (responseInfo->head != NULL) {
219         result = responseInfo->head->data;
220         SkipATPrefix(&result);
221         NextInt(&result, &response.msgRef);
222     } else {
223         response.msgRef = 1;
224     }
225     reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
226     OnSmsReport(GetSlotId(requestInfo), reportInfo, (const uint8_t *)&response, sizeof(HRilSmsResponse));
227     FreeResponseInfo(responseInfo);
228 }
229 
ReqSendCdmaSmsAck(const ReqDataInfo * requestInfo,const char * data,size_t dataLen)230 void ReqSendCdmaSmsAck(const ReqDataInfo *requestInfo, const char *data, size_t dataLen)
231 {
232     int32_t err = HRIL_ERR_SUCCESS;
233     if (err > 0) {
234         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
235         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
236         return;
237     }
238     struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
239     OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
240 }
241 
SimMessageError(struct ReportInfo * reportInfo,const ReqDataInfo * requestInfo,int32_t * err,ResponseInfo * responseInfo)242 static void SimMessageError(
243     struct ReportInfo *reportInfo, const ReqDataInfo *requestInfo, int32_t *err, ResponseInfo *responseInfo)
244 {
245     if (reportInfo == NULL || err == NULL) {
246         return;
247     }
248     *reportInfo = CreateReportInfo(requestInfo, *err, HRIL_RESPONSE, 0);
249     OnSmsReport(GetSlotId(requestInfo), *reportInfo, NULL, 0);
250     FreeResponseInfo(responseInfo);
251 }
252 
WriteSimMessage(const ReqDataInfo * requestInfo,const HRilSmsWriteSms * data,size_t dataLen)253 static void WriteSimMessage(const ReqDataInfo *requestInfo, const HRilSmsWriteSms *data, size_t dataLen)
254 {
255     char cmd[MAX_CMD_LENGTH] = { 0 };
256     char smsPdu[MAX_CMD_LENGTH] = { 0 };
257     int32_t err;
258     HRilSmsWriteSms *msg = NULL;
259     ResponseInfo *responseInfo = NULL;
260     struct ReportInfo reportInfo = {0};
261     if (data == NULL) {
262         TELEPHONY_LOGE("data is nullptr");
263         reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_GENERIC_FAILURE, HRIL_RESPONSE, 0);
264         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
265         FreeResponseInfo(responseInfo);
266         return;
267     }
268     msg = ((HRilSmsWriteSms *)data);
269     if (msg->smsc == NULL || (strcmp(msg->smsc, "") == 0)) {
270         if (msg->smsc != NULL) {
271             free(msg->smsc);
272         }
273         msg->smsc = (char *)malloc(strlen("00") + 1);
274         if (strcpy_s(msg->smsc, strlen("00") + 1, "00") != EOK) {
275             TELEPHONY_LOGE("Set smsc failed");
276             reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_GENERIC_FAILURE, HRIL_RESPONSE, 0);
277             OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
278             FreeResponseInfo(responseInfo);
279             return;
280         }
281     }
282     int32_t ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CMGW=%d,%d", strlen(msg->pdu) / g_cmdLength, msg->state);
283     if (ret < 0) {
284         TELEPHONY_LOGE("GenerateCommand failed, err = %{public}d\n", ret);
285         SimMessageError(&reportInfo, requestInfo, &ret, responseInfo);
286         return;
287     }
288     int32_t tmp = GenerateCommand(smsPdu, MAX_CMD_LENGTH, "%s%s", msg->smsc, msg->pdu);
289     if (tmp < 0) {
290         SimMessageError(&reportInfo, requestInfo, &tmp, responseInfo);
291         return;
292     }
293     err = SendCommandSmsLock(cmd, smsPdu, "+CMGW:", 0, &responseInfo);
294     ret = memset_s(cmd, MAX_CMD_LENGTH, 0, MAX_CMD_LENGTH);
295     if (err != 0 || (responseInfo != NULL && !responseInfo->success) || ret != EOK) {
296         err = HRIL_ERR_GENERIC_FAILURE;
297         SimMessageError(&reportInfo, requestInfo, &err, responseInfo);
298         return;
299     }
300     reportInfo = CreateReportInfo(requestInfo, VENDOR_SUCCESS, HRIL_RESPONSE, 0);
301     OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
302     FreeResponseInfo(responseInfo);
303 }
304 
UpdateSimMessage(const ReqDataInfo * requestInfo,const HRilSmsWriteSms * data,size_t dataLen)305 static void UpdateSimMessage(const ReqDataInfo *requestInfo, const HRilSmsWriteSms *data, size_t dataLen)
306 {
307     char cmd[MAX_CMD_LENGTH] = {0};
308     char smsPdu[MAX_CMD_LENGTH] = { 0 };
309     HRilSmsWriteSms *msg = NULL;
310     ResponseInfo *responseInfo = NULL;
311     struct ReportInfo reportInfo = {0};
312     if (!CheckSimMessageValid(requestInfo, data, dataLen, msg)) {
313         TELEPHONY_LOGE("sim message data error");
314         return;
315     }
316     msg = ((HRilSmsWriteSms *)data);
317     int32_t err = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CMGW=%zu,%d", strlen(msg->pdu) / g_cmdLength, msg->state);
318     if (err < 0) {
319         TELEPHONY_LOGE("GenerateCommand failed, err = %{public}d\n", err);
320         SimMessageError(&reportInfo, requestInfo, &err, responseInfo);
321         return;
322     }
323     err = GenerateCommand(smsPdu, MAX_CMD_LENGTH, "%s%s", msg->smsc, msg->pdu);
324     if (err < 0) {
325         TELEPHONY_LOGE("GenerateCommand failed, err = %{public}d\n", err);
326         SimMessageError(&reportInfo, requestInfo, &err, responseInfo);
327         return;
328     }
329     err = SendCommandSmsLock(cmd, smsPdu, "+CMGW:", 0, &responseInfo);
330     if (err != 0 || (responseInfo != NULL && !responseInfo->success)) {
331         TELEPHONY_LOGE("ExecuteCommand failed");
332         err = HRIL_ERR_GENERIC_FAILURE;
333         SimMessageError(&reportInfo, requestInfo, &err, responseInfo);
334         return;
335     }
336     int32_t res = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CMGD=%d", msg->index);
337     if (res < 0) {
338         TELEPHONY_LOGE("GenerateCommand failed, err = %{public}d\n", res);
339         SimMessageError(&reportInfo, requestInfo, &err, responseInfo);
340         return;
341     }
342     err = SendCommandLock(cmd, "+CMGD:", 0, &responseInfo);
343     int32_t ret = memset_s(cmd, MAX_CMD_LENGTH, 0, MAX_CMD_LENGTH);
344     if (err != 0 || (responseInfo != NULL && !responseInfo->success) || ret != EOK) {
345         err = HRIL_ERR_GENERIC_FAILURE;
346         SimMessageError(&reportInfo, requestInfo, &err, responseInfo);
347         return;
348     }
349     reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
350     OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
351     FreeResponseInfo(responseInfo);
352 }
353 
CheckSimMessageValid(const ReqDataInfo * requestInfo,const HRilSmsWriteSms * data,size_t dataLen,HRilSmsWriteSms * msg)354 bool CheckSimMessageValid(
355     const ReqDataInfo *requestInfo, const HRilSmsWriteSms *data, size_t dataLen, HRilSmsWriteSms *msg)
356 {
357     if (data == NULL) {
358         TELEPHONY_LOGE("data is nullptr");
359         ReportInfo reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_GENERIC_FAILURE, HRIL_RESPONSE, 0);
360         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
361         return false;
362     }
363     msg = ((HRilSmsWriteSms *)data);
364     if (msg == NULL) {
365         TELEPHONY_LOGE("msg is nullptr");
366         return false;
367     }
368     if (msg->smsc == NULL || (strcmp(msg->smsc, "") == 0)) {
369         if (msg->smsc != NULL) {
370             free(msg->smsc);
371         }
372         msg->smsc = (char *)malloc(strlen("00") + 1);
373         if (strcpy_s(msg->smsc, strlen("00") + 1, "00") != EOK) {
374             TELEPHONY_LOGE("Set smsc failed");
375             ReportInfo reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_GENERIC_FAILURE, HRIL_RESPONSE, 0);
376             OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
377             return false;
378         }
379     }
380     return true;
381 }
382 
ReqWriteSimMessage(const ReqDataInfo * requestInfo,const HRilSmsWriteSms * data,size_t dataLen)383 void ReqWriteSimMessage(const ReqDataInfo *requestInfo, const HRilSmsWriteSms *data, size_t dataLen)
384 {
385     HRilSmsWriteSms *msg = NULL;
386     ResponseInfo *responseInfo = NULL;
387 
388     if (data == NULL) {
389         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_GENERIC_FAILURE, HRIL_RESPONSE, 0);
390         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
391         FreeResponseInfo(responseInfo);
392         return;
393     }
394     msg = ((HRilSmsWriteSms *)data);
395     if (msg->index < 0) {
396         WriteSimMessage(requestInfo, data, dataLen);
397     } else {
398         UpdateSimMessage(requestInfo, data, dataLen);
399     }
400 }
401 
ReqDelSimMessage(const ReqDataInfo * requestInfo,const int32_t * data,size_t dataLen)402 void ReqDelSimMessage(const ReqDataInfo *requestInfo, const int32_t *data, size_t dataLen)
403 {
404     ResponseInfo *responseInfo = NULL;
405     if (data == NULL || dataLen == 0) {
406         TELEPHONY_LOGE("data error");
407         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_GENERIC_FAILURE, HRIL_RESPONSE, 0);
408         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
409         FreeResponseInfo(responseInfo);
410         return;
411     }
412     int32_t index = ((int32_t *)data)[0] - 1;
413     if (index < 0) {
414         TELEPHONY_LOGE("invalid index:%d", index);
415         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_GENERIC_FAILURE, HRIL_RESPONSE, 0);
416         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
417         FreeResponseInfo(responseInfo);
418         return;
419     }
420     char cmd[MAX_CMD_LENGTH] = { 0 };
421     int32_t err = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CMGD=%d", index);
422     if (err < 0) {
423         TELEPHONY_LOGE("GenerateCommand failed, err = %{public}d\n", err);
424         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
425         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
426         FreeResponseInfo(responseInfo);
427         return;
428     }
429 
430     err = SendCommandLock(cmd, "+CMGD:", 0, &responseInfo);
431     if (err != 0 || (responseInfo != NULL && !responseInfo->success)) {
432         err = HRIL_ERR_GENERIC_FAILURE;
433         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
434         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
435         FreeResponseInfo(responseInfo);
436         return;
437     }
438     struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
439     OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
440     FreeResponseInfo(responseInfo);
441 }
442 
ReqSetSmscAddr(const ReqDataInfo * requestInfo,const HRilServiceCenterAddress * data,size_t dataLen)443 void ReqSetSmscAddr(const ReqDataInfo *requestInfo, const HRilServiceCenterAddress *data, size_t dataLen)
444 {
445     char cmd[MAX_CMD_LENGTH] = {0};
446     int32_t err;
447     HRilServiceCenterAddress *address = NULL;
448     ResponseInfo *responseInfo = NULL;
449 
450     if (data == NULL) {
451         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_GENERIC_FAILURE, HRIL_RESPONSE, 0);
452         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
453         FreeResponseInfo(responseInfo);
454         return;
455     }
456     address = ((HRilServiceCenterAddress *)data);
457 
458     if (address->tosca == 0) {
459         err = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CSCA=\"%s\"", address->address);
460     } else {
461         err = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CSCA=\"%s\",%d", address->address, address->tosca);
462     }
463     if (err < 0) {
464         TELEPHONY_LOGE("GenerateCommand failed, err = %{public}d\n", err);
465         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
466         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
467         FreeResponseInfo(responseInfo);
468         return;
469     }
470     err = SendCommandLock(cmd, "+CSCA:", 0, &responseInfo);
471     if (err != 0 || (responseInfo != NULL && !responseInfo->success)) {
472         err = HRIL_ERR_GENERIC_FAILURE;
473         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
474         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
475         FreeResponseInfo(responseInfo);
476         return;
477     }
478     struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
479     OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
480     FreeResponseInfo(responseInfo);
481 }
482 
ReqGetSmscAddr(const ReqDataInfo * requestInfo)483 void ReqGetSmscAddr(const ReqDataInfo *requestInfo)
484 {
485     char *result = NULL;
486     int32_t err;
487     ResponseInfo *responseInfo = NULL;
488     HRilServiceCenterAddress response;
489 
490     err = SendCommandLock("AT+CSCA?", "+CSCA:", 0, &responseInfo);
491     if (err != 0 || responseInfo == NULL || !responseInfo->success) {
492         err = HRIL_ERR_GENERIC_FAILURE;
493         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
494         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
495         FreeResponseInfo(responseInfo);
496         return;
497     }
498     if (responseInfo->head != NULL) {
499         result = responseInfo->head->data;
500     }
501     if (result == NULL) {
502         TELEPHONY_LOGE("ReqGetSmscAddr result is null");
503     } else {
504         SkipATPrefix(&result);
505         err = NextStr(&result, &response.address);
506         if (err == -1) {
507             TELEPHONY_LOGE("NextStr in ReqGetSmscAddr is failed!");
508             if (strcpy_s(response.address, strlen("") + 1, "") != EOK) {
509                 return;
510             }
511         }
512         err = NextInt(&result, &response.tosca);
513         if (err == -1) {
514             TELEPHONY_LOGE("NextInt in ReqGetSmscAddr is failed!");
515             response.tosca = 0;
516         }
517     }
518     struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
519     OnSmsReport(GetSlotId(requestInfo), reportInfo, (const uint8_t *)&response, sizeof(HRilServiceCenterAddress));
520     FreeResponseInfo(responseInfo);
521 }
522 
ReqGetCBConfigInfo(const ReqDataInfo * requestInfo,ResponseInfo * responseInfo,HRilCBConfigInfo * cellBroadcast,char * mids,char * dcss,int32_t mode)523 void ReqGetCBConfigInfo(const ReqDataInfo *requestInfo, ResponseInfo *responseInfo, HRilCBConfigInfo *cellBroadcast,
524     char *mids, char *dcss, int32_t mode)
525 {
526     struct ReportInfo reportInfo = CreateReportInfo(requestInfo, VENDOR_SUCCESS, HRIL_RESPONSE, 0);
527     bool midsEmpty = (mids == NULL || mids[0] == '\0');
528     char *token;
529     char copy[MAX_LENGTH] = { 0 };
530     if (strcpy_s(copy, MAX_LENGTH, mids) != EOK) {
531         FreeResponseInfo(responseInfo);
532         return;
533     }
534     char delimiter[] = ",";
535     char *p = NULL;
536     token = strtok_r(copy, delimiter, &p);
537     int32_t position = 0;
538     char midsTotal[MAX_LENGTH][MAX_DIMEN_LENGTH] = { 0 };
539     while (!midsEmpty && token != NULL && position < MAX_LENGTH) {
540         size_t length = strlen(token);
541         size_t place = 0;
542         while (place < length && place < MAX_DIMEN_LENGTH && token[place] != '\0') {
543             midsTotal[position][place] = token[place];
544             place++;
545         }
546         position++;
547         token = strtok_r(NULL, delimiter, &p);
548     }
549     int32_t index = 0;
550     int32_t locate = 0;
551     while (index < position) {
552         locate = GetCBConfigData(midsTotal[index], dcss, mode, cellBroadcast, locate);
553         index++;
554     }
555     OnSmsReport(GetSlotId(requestInfo), reportInfo, (const uint8_t *)&cellBroadcast, sizeof(HRilCBConfigInfo) * locate);
556     FreeResponseInfo(responseInfo);
557 }
558 
ReqGetCBConfig(const ReqDataInfo * requestInfo)559 void ReqGetCBConfig(const ReqDataInfo *requestInfo)
560 {
561     ResponseInfo *responseInfo = NULL;
562     HRilCBConfigInfo cellBroadcast[MAX_LENGTH] = { 0 };
563     int32_t err = SendCommandLock("AT+CSCB?", "+CSCB:", 0, &responseInfo);
564     if (err != 0 || responseInfo == NULL || !responseInfo->success || responseInfo->head == NULL) {
565         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, AT_ERR_GENERIC, HRIL_RESPONSE, 0);
566         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
567         FreeResponseInfo(responseInfo);
568         return;
569     }
570     char *line = responseInfo->head->data;
571     SkipATPrefix(&line);
572     int32_t mode;
573     err = NextInt(&line, &mode);
574     if (err > 0) {
575         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, AT_ERR_GENERIC, HRIL_RESPONSE, 0);
576         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
577         FreeResponseInfo(responseInfo);
578         return;
579     }
580     char *mids;
581     err = NextStr(&line, &mids);
582     if (err > 0) {
583         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, AT_ERR_GENERIC, HRIL_RESPONSE, 0);
584         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
585         FreeResponseInfo(responseInfo);
586         return;
587     }
588     char *dcss;
589     err = NextStr(&line, &dcss);
590     if (err > 0) {
591         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, AT_ERR_GENERIC, HRIL_RESPONSE, 0);
592         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
593         FreeResponseInfo(responseInfo);
594         return;
595     }
596     ReqGetCBConfigInfo(requestInfo, responseInfo, cellBroadcast, mids, dcss, mode);
597 }
598 
SetCellBroadcastInfo(HRilCBConfigInfo * cellBroadcast,int32_t locate,char * startMid,char * endMid,char * startDcs,char * endDcs,bool dcssEmpty,int32_t mode)599 void SetCellBroadcastInfo(HRilCBConfigInfo *cellBroadcast, int32_t locate, char *startMid, char *endMid, char *startDcs,
600     char *endDcs, bool dcssEmpty, int32_t mode)
601 {
602     if (cellBroadcast == NULL || locate < 0) {
603         TELEPHONY_LOGE("cellBroadcast is null");
604         return;
605     }
606     if (startMid == NULL || endMid == NULL) {
607         TELEPHONY_LOGE("startMid or endMid is null");
608         return;
609     }
610     cellBroadcast[locate].startOfServiceId = atoi(startMid);
611     cellBroadcast[locate].endOfServiceId = atoi(endMid);
612     if (!dcssEmpty) {
613         if (startDcs == NULL || endDcs == NULL) {
614             TELEPHONY_LOGE("startDcs or endDcs is null");
615             return;
616         }
617         cellBroadcast[locate].startOfCodeScheme = atoi(startDcs);
618         cellBroadcast[locate].endOfCodeScheme = atoi(endDcs);
619     }
620     cellBroadcast[locate].selected = mode;
621 }
622 
GetCBConfigData(char * token,char * dcss,int32_t mode,HRilCBConfigInfo * cellBroadcast,int32_t locate)623 int32_t GetCBConfigData(char *token, char *dcss, int32_t mode, HRilCBConfigInfo *cellBroadcast, int32_t locate)
624 {
625     char *ttoken;
626     char ddelimiter[] = "-";
627     char ccopy[MAX_LENGTH] = { 0 };
628     if (strcpy_s(ccopy, MAX_LENGTH, token) != EOK) {
629         return MAX_LENGTH;
630     }
631     char *startMid = NULL;
632     char *endMid = NULL;
633     char *p = NULL;
634     ttoken = strtok_r(ccopy, ddelimiter, &p);
635     for (int32_t index = 0; ttoken != NULL; index++) {
636         if (index == 0) {
637             startMid = ttoken;
638             endMid = ttoken;
639         } else {
640             endMid = ttoken;
641             break;
642         }
643         ttoken = strtok_r(NULL, ddelimiter, &p);
644     }
645     char copyDcs[MAX_LENGTH] = { 0 };
646     bool dcssEmpty = (dcss == NULL || dcss[0] == '\0');
647     if (strcpy_s(copyDcs, MAX_LENGTH, dcss) != EOK) {
648         return MAX_LENGTH;
649     }
650     char *startDcs = NULL;
651     char *endDcs = NULL;
652     char delimiterDcs[] = "-";
653     char *tokenDcs;
654     char *q = NULL;
655     tokenDcs = strtok_r(copyDcs, delimiterDcs, &q);
656     for (int32_t index = 0; !dcssEmpty && tokenDcs != NULL; index++) {
657         if (index == 0) {
658             startDcs = tokenDcs;
659             endDcs = tokenDcs;
660         } else {
661             endDcs = tokenDcs;
662             break;
663         }
664         tokenDcs = strtok_r(NULL, delimiterDcs, &q);
665     }
666     if (locate < MAX_LENGTH) {
667         SetCellBroadcastInfo(cellBroadcast, locate, startMid, endMid, startDcs, endDcs, dcssEmpty, mode);
668     }
669     locate++;
670     return locate;
671 }
672 
UpdataMids(int32_t locate,char * mids,char * start,char * end)673 bool UpdataMids(int32_t locate, char *mids, char *start, char *end)
674 {
675     if (locate == 0) {
676         if (strcpy_s(mids, MAX_LENGTH, start) != EOK) {
677             return false;
678         }
679     } else {
680         if (strcat_s(mids, MAX_LENGTH, g_commaStr) != EOK) {
681             return false;
682         }
683         if (strcat_s(mids, MAX_LENGTH, start) != EOK) {
684             return false;
685         }
686     }
687     if (strcat_s(mids, MAX_LENGTH, g_hyphenStr) != EOK) {
688         return false;
689     }
690     if (strcat_s(mids, MAX_LENGTH, end) != EOK) {
691         return false;
692     }
693     return true;
694 }
695 
UpdataMidValues(int32_t locate,char * mids,char * start)696 bool UpdataMidValues(int32_t locate, char *mids, char *start)
697 {
698     if (locate == 0) {
699         if (strcpy_s(mids, MAX_LENGTH, start) != EOK) {
700             return false;
701         }
702     } else {
703         if (strcat_s(mids, MAX_LENGTH, g_commaStr) != EOK) {
704             return false;
705         }
706         if (strcat_s(mids, MAX_LENGTH, start) != EOK) {
707             return false;
708         }
709     }
710     return true;
711 }
712 
GetDcss(const HRilCBConfigInfo * data,int32_t len,char * dcss)713 bool GetDcss(const HRilCBConfigInfo *data, int32_t len, char *dcss)
714 {
715     for (int32_t locate = 0; locate < len && (locate + 1) * (CHNL_LEN + CHNL_LEN + 1) < MAX_LENGTH; locate++) {
716         if (data[locate].startOfCodeScheme > data[locate].endOfCodeScheme) {
717             TELEPHONY_LOGE("result.dcss is invalid");
718             return false;
719         } else if (data[locate].startOfCodeScheme < data[locate].endOfCodeScheme) {
720             char start[CHNL_LEN] = { 0 };
721             sprintf_s(start, CHNL_LEN, "%d", data[locate].startOfCodeScheme);
722             char end[CHNL_LEN] = { 0 };
723             sprintf_s(end, CHNL_LEN, "%d", data[locate].endOfCodeScheme);
724             if (locate != 0) {
725                 break;
726             }
727             if (strcpy_s(dcss, MAX_LENGTH, start) != EOK) {
728                 return false;
729             }
730             if (strcat_s(dcss, MAX_LENGTH, g_hyphenStr) != EOK) {
731                 return false;
732             }
733             if (strcat_s(dcss, MAX_LENGTH, end) != EOK) {
734                 return false;
735             }
736         } else {
737             char start[CHNL_LEN] = { 0 };
738             sprintf_s(start, CHNL_LEN, "%d", data[locate].startOfCodeScheme);
739             if (locate != 0) {
740                 break;
741             }
742             if (strcpy_s(dcss, MAX_LENGTH, start) != EOK) {
743                 return false;
744             }
745         }
746     }
747     return true;
748 }
749 
GetMidsAndDcss(const HRilCBConfigInfo * data,int32_t len,char * mids,char * dcss)750 bool GetMidsAndDcss(const HRilCBConfigInfo *data, int32_t len, char *mids, char *dcss)
751 {
752     for (int32_t locate = 0; locate < len && (locate + 1) * (CHNL_LEN + CHNL_LEN + 1) < MAX_LENGTH; locate++) {
753         if (data[locate].startOfServiceId < data[locate].endOfServiceId) {
754             char start[CHNL_LEN] = { 0 };
755             sprintf_s(start, CHNL_LEN, "%d", data[locate].startOfServiceId);
756             char end[CHNL_LEN] = { 0 };
757             sprintf_s(end, CHNL_LEN, "%d", data[locate].endOfServiceId);
758             if (!UpdataMids(locate, mids, start, end)) {
759                 return false;
760             }
761         } else {
762             char start[CHNL_LEN] = { 0 };
763             sprintf_s(start, CHNL_LEN, "%d", data[locate].startOfServiceId);
764             if (UpdataMidValues(locate, mids, start)) {
765                 return false;
766             }
767         }
768         if (!GetDcss(data, len, dcss)) {
769             return false;
770         }
771     }
772     return true;
773 }
774 
ReqSetCBConfig(const ReqDataInfo * requestInfo,const HRilCBConfigInfo * data,size_t dataLen)775 void ReqSetCBConfig(const ReqDataInfo *requestInfo, const HRilCBConfigInfo *data, size_t dataLen)
776 {
777     char cmd[MAX_CMD_LENGTH] = { 0 };
778     int32_t err;
779     int32_t ret;
780     ResponseInfo *responseInfo = NULL;
781     int32_t len = (int32_t)(dataLen / sizeof(HRilCBConfigInfo));
782     if (data == NULL || len == 0) {
783         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_GENERIC_FAILURE, HRIL_RESPONSE, 0);
784         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
785         FreeResponseInfo(responseInfo);
786         return;
787     }
788     int32_t mode = data[0].selected;
789     char mids[MAX_LENGTH] = { 0 };
790     char dcss[MAX_LENGTH] = { 0 };
791     if (!GetMidsAndDcss(data, len, mids, dcss)) {
792         return;
793     }
794     if (strcmp(mids, "") && !strcmp(dcss, "")) {
795         ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CSCB=%d,\"%s\"", mode, mids);
796     } else if (strcmp(mids, "") && strcmp(dcss, "")) {
797         ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CSCB=%d,\"%s\",\"%s\"", mode, mids, dcss);
798     } else if (strcmp(dcss, "") && !strcmp(mids, "")) {
799         ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CSCB=%d,,\"%s\"", mode, dcss);
800     } else {
801         ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CSCB=%d", mode);
802     }
803     if (ret < 0) {
804         TELEPHONY_LOGE("GenerateCommand failed, err = %{public}d\n", ret);
805         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, AT_ERR_GENERIC, HRIL_RESPONSE, 0);
806         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
807         FreeResponseInfo(responseInfo);
808         return;
809     }
810     err = SendCommandLock(cmd, "+CSCB:", 0, &responseInfo);
811     if (err != 0 || (responseInfo != NULL && !responseInfo->success)) {
812         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, AT_ERR_GENERIC, HRIL_RESPONSE, 0);
813         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
814         FreeResponseInfo(responseInfo);
815         return;
816     }
817     struct ReportInfo reportInfo = CreateReportInfo(requestInfo, VENDOR_SUCCESS, HRIL_RESPONSE, 0);
818     OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
819     FreeResponseInfo(responseInfo);
820 }
821 
ReqGetCdmaCBConfig(const ReqDataInfo * requestInfo)822 void ReqGetCdmaCBConfig(const ReqDataInfo *requestInfo)
823 {
824     char checked = '0';
825     char lineBuff[MAX_CMD_LENGTH] = {0};
826     char *line = lineBuff;
827     int32_t err = HRIL_ERR_SUCCESS;
828     int32_t service = 1;
829     int32_t language = 1;
830     ResponseInfo *responseInfo = NULL;
831     HRilCdmaCBConfigInfo cdmaCBConfig = {0};
832 
833     int32_t ret = GenerateCommand(lineBuff, MAX_CMD_LENGTH, "AT:%d,%d,%c", service, language, checked);
834     if (ret < 0) {
835         TELEPHONY_LOGE("GenerateCommand failed, err = %{public}d\n", ret);
836         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
837         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
838         FreeResponseInfo(responseInfo);
839         return;
840     }
841     SkipATPrefix(&line);
842     err = NextInt(&line, &cdmaCBConfig.service);
843     if (err > 0) {
844         err = HRIL_ERR_GENERIC_FAILURE;
845         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
846         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
847         FreeResponseInfo(responseInfo);
848         return;
849     }
850     err = NextInt(&line, &cdmaCBConfig.language);
851     if (err > 0) {
852         err = HRIL_ERR_GENERIC_FAILURE;
853         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
854         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
855         FreeResponseInfo(responseInfo);
856         return;
857     }
858     char *tmp = NULL;
859     err = NextStr(&line, &tmp);
860     if (err > 0 || tmp == NULL || tmp[0] == '\0') {
861         err = HRIL_ERR_GENERIC_FAILURE;
862         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
863         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
864         FreeResponseInfo(responseInfo);
865         return;
866     }
867     cdmaCBConfig.checked = tmp[0];
868     struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
869     OnSmsReport(GetSlotId(requestInfo), reportInfo, (const uint8_t *)&cdmaCBConfig, sizeof(HRilCdmaCBConfigInfo));
870     FreeResponseInfo(responseInfo);
871 }
872 
ReqSetCdmaCBConfig(const ReqDataInfo * requestInfo,const HRilCdmaCBConfigInfo * data,size_t dataLen)873 void ReqSetCdmaCBConfig(const ReqDataInfo *requestInfo, const HRilCdmaCBConfigInfo *data, size_t dataLen)
874 {
875     int32_t err;
876     ResponseInfo *responseInfo = NULL;
877 
878     if (data == NULL) {
879         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_GENERIC_FAILURE, HRIL_RESPONSE, 0);
880         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
881         FreeResponseInfo(responseInfo);
882         return;
883     }
884     int32_t size = dataLen / sizeof(HRilCdmaCBConfigInfo);
885     if (size <= 0) {
886         err = HRIL_ERR_GENERIC_FAILURE;
887         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
888         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
889         FreeResponseInfo(responseInfo);
890         return;
891     }
892     err = HRIL_ERR_SUCCESS;
893     struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
894     OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
895     FreeResponseInfo(responseInfo);
896 }
897 
ReqAddCdmaSimMessage(const ReqDataInfo * requestInfo,const HRilSmsWriteCdmaSms * data,size_t dataLen)898 void ReqAddCdmaSimMessage(const ReqDataInfo *requestInfo, const HRilSmsWriteCdmaSms *data, size_t dataLen)
899 {
900     if (data == NULL) {
901         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_GENERIC_FAILURE, HRIL_RESPONSE, 0);
902         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
903         return;
904     }
905     HRilSmsWriteCdmaSms *cdmaSms = (HRilSmsWriteCdmaSms *)data;
906     HRilCdmaSmsMessageInfo *cdmaMsg = &cdmaSms->cdmaMessageInfo;
907     TELEPHONY_LOGD(
908         "CreateCdmaPdu = %{public}x, %{public}x, %{public}x", cdmaMsg->serviceId, cdmaMsg->isExist, cdmaMsg->type);
909     TELEPHONY_LOGD("CreateCdmaPdu2 = %{public}x, %{public}x, %{public}x", cdmaMsg->address.digitMode,
910         cdmaMsg->address.mode, cdmaMsg->address.type);
911     TELEPHONY_LOGD("CreateCdmaPdu3 = %{public}x, %{public}x, %{public}s", cdmaMsg->address.plan,
912         cdmaMsg->address.number, cdmaMsg->address.bytes);
913     struct ReportInfo reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_SUCCESS, HRIL_RESPONSE, 0);
914     OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
915 }
916 
ReqDelCdmaSimMessage(const ReqDataInfo * requestInfo,const int32_t * data,size_t dataLen)917 void ReqDelCdmaSimMessage(const ReqDataInfo *requestInfo, const int32_t *data, size_t dataLen)
918 {
919     char cmd[MAX_CMD_LENGTH] = {0};
920     int32_t err;
921     int32_t index;
922     ResponseInfo *responseInfo = NULL;
923     if (data == NULL || dataLen == 0) {
924         TELEPHONY_LOGE("data error");
925         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_GENERIC_FAILURE, HRIL_RESPONSE, 0);
926         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
927         FreeResponseInfo(responseInfo);
928         return;
929     }
930     index = ((int32_t *)data)[0] - 1;
931     if (index < 0) {
932         TELEPHONY_LOGE("invalid index:%d", index);
933         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_GENERIC_FAILURE, HRIL_RESPONSE, 0);
934         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
935         FreeResponseInfo(responseInfo);
936         return;
937     }
938     err = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CMGD=%d", index);
939     if (err < 0) {
940         TELEPHONY_LOGE("GenerateCommand failed, err = %{public}d\n", err);
941         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
942         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
943         FreeResponseInfo(responseInfo);
944         return;
945     }
946     err = SendCommandLock(cmd, "+CMGD:", 0, &responseInfo);
947     if (err != 0 || (responseInfo != NULL && !responseInfo->success)) {
948         err = HRIL_ERR_GENERIC_FAILURE;
949         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
950         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
951         FreeResponseInfo(responseInfo);
952         return;
953     }
954     struct ReportInfo reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_SUCCESS, HRIL_RESPONSE, 0);
955     OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
956     FreeResponseInfo(responseInfo);
957 }
958 
ReqUpdateCdmaSimMessage(const ReqDataInfo * requestInfo,const HRilSmsWriteSms * data,size_t dataLen)959 void ReqUpdateCdmaSimMessage(const ReqDataInfo *requestInfo, const HRilSmsWriteSms *data, size_t dataLen)
960 {
961     char cmd[MAX_CMD_LENGTH] = {0};
962     int32_t err;
963     HRilSmsWriteSms *cdmaMsg = NULL;
964     ResponseInfo *responseInfo = NULL;
965     struct ReportInfo reportInfo = {0};
966     if (data == NULL) {
967         reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_GENERIC_FAILURE, HRIL_RESPONSE, 0);
968         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
969         FreeResponseInfo(responseInfo);
970         return;
971     }
972     cdmaMsg = ((HRilSmsWriteSms *)data);
973     err = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CPMS=%d,%d%s", cdmaMsg->index, cdmaMsg->state, cdmaMsg->pdu);
974     if (err < 0) {
975         TELEPHONY_LOGE("GenerateCommand failed, err = %{public}d\n", err);
976         reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
977         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
978         FreeResponseInfo(responseInfo);
979         return;
980     }
981     err = SendCommandLock(cmd, "+CPMS:", 0, &responseInfo);
982     if (err != 0 || (responseInfo != NULL && !responseInfo->success)) {
983         err = HRIL_ERR_GENERIC_FAILURE;
984         SimMessageError(&reportInfo, requestInfo, &err, responseInfo);
985         return;
986     }
987     reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
988     OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
989     FreeResponseInfo(responseInfo);
990 }
991