• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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     responseInfo = (ResponseInfo *)malloc(sizeof(ResponseInfo));
204     if (responseInfo == NULL) {
205         err = HRIL_ERR_GENERIC_FAILURE;
206     }
207     err = SendCommandLock("AT+COPS?", "COPS?", 0, &responseInfo);
208     if (err != 0 || (responseInfo != NULL && !responseInfo->success)) {
209         TELEPHONY_LOGE("AT+COPS? send failed");
210         HandlerSmsResult(&response, &reportInfo, requestInfo, &err, responseInfo);
211         FreeResponseInfo(responseInfo);
212         return;
213     }
214     err = SendCommandLock("AT$QCMGF=0", "$QCMGF=0", 0, &responseInfo);
215     if (err != 0 || responseInfo == NULL || !responseInfo->success) {
216         response.msgRef = HRIL_ERR_GENERIC_FAILURE;
217         reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
218         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
219         FreeResponseInfo(responseInfo);
220         return;
221     }
222     if (responseInfo->head != NULL) {
223         result = responseInfo->head->data;
224         SkipATPrefix(&result);
225         NextInt(&result, &response.msgRef);
226     } else {
227         response.msgRef = 1;
228     }
229     reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
230     OnSmsReport(GetSlotId(requestInfo), reportInfo, (const uint8_t *)&response, sizeof(HRilSmsResponse));
231     FreeResponseInfo(responseInfo);
232 }
233 
ReqSendCdmaSmsAck(const ReqDataInfo * requestInfo,const char * data,size_t dataLen)234 void ReqSendCdmaSmsAck(const ReqDataInfo *requestInfo, const char *data, size_t dataLen)
235 {
236     int32_t err = HRIL_ERR_SUCCESS;
237     if (err > 0) {
238         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
239         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
240         return;
241     }
242     struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
243     OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
244 }
245 
SimMessageError(struct ReportInfo * reportInfo,const ReqDataInfo * requestInfo,int32_t * err,ResponseInfo * responseInfo)246 static void SimMessageError(
247     struct ReportInfo *reportInfo, const ReqDataInfo *requestInfo, int32_t *err, ResponseInfo *responseInfo)
248 {
249     if (reportInfo == NULL || err == NULL) {
250         return;
251     }
252     *reportInfo = CreateReportInfo(requestInfo, *err, HRIL_RESPONSE, 0);
253     OnSmsReport(GetSlotId(requestInfo), *reportInfo, NULL, 0);
254     FreeResponseInfo(responseInfo);
255 }
256 
WriteSimMessage(const ReqDataInfo * requestInfo,const HRilSmsWriteSms * data,size_t dataLen)257 static void WriteSimMessage(const ReqDataInfo *requestInfo, const HRilSmsWriteSms *data, size_t dataLen)
258 {
259     char cmd[MAX_CMD_LENGTH] = { 0 };
260     char smsPdu[MAX_CMD_LENGTH] = { 0 };
261     int32_t err;
262     HRilSmsWriteSms *msg = NULL;
263     ResponseInfo *responseInfo = NULL;
264     struct ReportInfo reportInfo = {0};
265     if (data == NULL) {
266         TELEPHONY_LOGE("data is nullptr");
267         reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_GENERIC_FAILURE, HRIL_RESPONSE, 0);
268         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
269         FreeResponseInfo(responseInfo);
270         return;
271     }
272     msg = ((HRilSmsWriteSms *)data);
273     if (msg->smsc == NULL || (strcmp(msg->smsc, "") == 0)) {
274         msg->smsc = (char *)malloc(strlen("00") + 1);
275         if (strcpy_s(msg->smsc, strlen("00") + 1, "00") != EOK) {
276             TELEPHONY_LOGE("Set smsc failed");
277             reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_GENERIC_FAILURE, HRIL_RESPONSE, 0);
278             OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
279             FreeResponseInfo(responseInfo);
280             return;
281         }
282     }
283     int32_t ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CMGW=%d,%d", strlen(msg->pdu) / g_cmdLength, msg->state);
284     if (ret < 0) {
285         TELEPHONY_LOGE("GenerateCommand failed, err = %{public}d\n", ret);
286         SimMessageError(&reportInfo, requestInfo, &ret, responseInfo);
287         return;
288     }
289     int32_t tmp = GenerateCommand(smsPdu, MAX_CMD_LENGTH, "%s%s", msg->smsc, msg->pdu);
290     if (tmp < 0) {
291         TELEPHONY_LOGE("GenerateCommand failed, err = %{public}d\n", tmp);
292         SimMessageError(&reportInfo, requestInfo, &tmp, responseInfo);
293         return;
294     }
295     err = SendCommandSmsLock(cmd, smsPdu, "+CMGW:", 0, &responseInfo);
296     ret = memset_s(cmd, MAX_CMD_LENGTH, 0, MAX_CMD_LENGTH);
297     if (err != 0 || (responseInfo != NULL && !responseInfo->success) || ret != EOK) {
298         TELEPHONY_LOGE("ExecuteCommand failed");
299         err = HRIL_ERR_GENERIC_FAILURE;
300         SimMessageError(&reportInfo, requestInfo, &err, responseInfo);
301         return;
302     }
303     reportInfo = CreateReportInfo(requestInfo, VENDOR_SUCCESS, HRIL_RESPONSE, 0);
304     OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
305     FreeResponseInfo(responseInfo);
306 }
307 
UpdateSimMessage(const ReqDataInfo * requestInfo,const HRilSmsWriteSms * data,size_t dataLen)308 static void UpdateSimMessage(const ReqDataInfo *requestInfo, const HRilSmsWriteSms *data, size_t dataLen)
309 {
310     char cmd[MAX_CMD_LENGTH] = {0};
311     char smsPdu[MAX_CMD_LENGTH] = { 0 };
312     HRilSmsWriteSms *msg = NULL;
313     ResponseInfo *responseInfo = NULL;
314     struct ReportInfo reportInfo = {0};
315     if (!CheckSimMessageValid(requestInfo, data, dataLen, msg)) {
316         TELEPHONY_LOGE("sim message data error");
317         return;
318     }
319     msg = ((HRilSmsWriteSms *)data);
320     int32_t err = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CMGW=%zu,%d", strlen(msg->pdu) / g_cmdLength, msg->state);
321     if (err < 0) {
322         TELEPHONY_LOGE("GenerateCommand failed, err = %{public}d\n", err);
323         SimMessageError(&reportInfo, requestInfo, &err, responseInfo);
324         return;
325     }
326     err = GenerateCommand(smsPdu, MAX_CMD_LENGTH, "%s%s", msg->smsc, msg->pdu);
327     if (err < 0) {
328         TELEPHONY_LOGE("GenerateCommand failed, err = %{public}d\n", err);
329         SimMessageError(&reportInfo, requestInfo, &err, responseInfo);
330         return;
331     }
332     err = SendCommandSmsLock(cmd, smsPdu, "+CMGW:", 0, &responseInfo);
333     if (err != 0 || (responseInfo != NULL && !responseInfo->success)) {
334         TELEPHONY_LOGE("ExecuteCommand failed");
335         err = HRIL_ERR_GENERIC_FAILURE;
336         SimMessageError(&reportInfo, requestInfo, &err, responseInfo);
337         return;
338     }
339     int32_t res = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CMGD=%d", msg->index);
340     if (res < 0) {
341         TELEPHONY_LOGE("GenerateCommand failed, err = %{public}d\n", res);
342         SimMessageError(&reportInfo, requestInfo, &err, responseInfo);
343         return;
344     }
345     err = SendCommandLock(cmd, "+CMGD:", 0, &responseInfo);
346     int32_t ret = memset_s(cmd, MAX_CMD_LENGTH, 0, MAX_CMD_LENGTH);
347     if (err != 0 || (responseInfo != NULL && !responseInfo->success) || ret != EOK) {
348         err = HRIL_ERR_GENERIC_FAILURE;
349         SimMessageError(&reportInfo, requestInfo, &err, responseInfo);
350         return;
351     }
352     reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
353     OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
354     FreeResponseInfo(responseInfo);
355 }
356 
CheckSimMessageValid(const ReqDataInfo * requestInfo,const HRilSmsWriteSms * data,size_t dataLen,HRilSmsWriteSms * msg)357 bool CheckSimMessageValid(
358     const ReqDataInfo *requestInfo, const HRilSmsWriteSms *data, size_t dataLen, HRilSmsWriteSms *msg)
359 {
360     if (data == NULL) {
361         TELEPHONY_LOGE("data is nullptr");
362         ReportInfo reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_GENERIC_FAILURE, HRIL_RESPONSE, 0);
363         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
364         return false;
365     }
366     msg = ((HRilSmsWriteSms *)data);
367     if (msg == NULL) {
368         TELEPHONY_LOGE("msg is nullptr");
369         return false;
370     }
371     if (msg->smsc == NULL || (strcmp(msg->smsc, "") == 0)) {
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     cellBroadcast[locate].startOfServiceId = atoi(startMid);
603     cellBroadcast[locate].endOfServiceId = atoi(endMid);
604     if (!dcssEmpty) {
605         cellBroadcast[locate].startOfCodeScheme = atoi(startDcs);
606         cellBroadcast[locate].endOfCodeScheme = atoi(endDcs);
607     }
608     cellBroadcast[locate].selected = mode;
609 }
610 
GetCBConfigData(char * token,char * dcss,int32_t mode,HRilCBConfigInfo * cellBroadcast,int32_t locate)611 int32_t GetCBConfigData(char *token, char *dcss, int32_t mode, HRilCBConfigInfo *cellBroadcast, int32_t locate)
612 {
613     char *ttoken;
614     char ddelimiter[] = "-";
615     char ccopy[MAX_LENGTH] = { 0 };
616     if (strcpy_s(ccopy, MAX_LENGTH, token) != EOK) {
617         return MAX_LENGTH;
618     }
619     char *startMid = NULL;
620     char *endMid = NULL;
621     char *p = NULL;
622     ttoken = strtok_r(ccopy, ddelimiter, &p);
623     for (int32_t index = 0; ttoken != NULL; index++) {
624         if (index == 0) {
625             startMid = ttoken;
626             endMid = ttoken;
627         } else {
628             endMid = ttoken;
629             break;
630         }
631         ttoken = strtok_r(NULL, ddelimiter, &p);
632     }
633     char copyDcs[MAX_LENGTH] = { 0 };
634     bool dcssEmpty = (dcss == NULL || dcss[0] == '\0');
635     if (strcpy_s(copyDcs, MAX_LENGTH, dcss) != EOK) {
636         return MAX_LENGTH;
637     }
638     char *startDcs = NULL;
639     char *endDcs = NULL;
640     char delimiterDcs[] = "-";
641     char *tokenDcs;
642     char *q = NULL;
643     tokenDcs = strtok_r(copyDcs, delimiterDcs, &q);
644     for (int32_t index = 0; !dcssEmpty && tokenDcs != NULL; index++) {
645         if (index == 0) {
646             startDcs = tokenDcs;
647             endDcs = tokenDcs;
648         } else {
649             endDcs = tokenDcs;
650             break;
651         }
652         tokenDcs = strtok_r(NULL, delimiterDcs, &q);
653     }
654     if (locate < MAX_LENGTH) {
655         SetCellBroadcastInfo(cellBroadcast, locate, startMid, endMid, startDcs, endDcs, dcssEmpty, mode);
656     }
657     locate++;
658     return locate;
659 }
660 
UpdataMids(int32_t locate,char * mids,char * start,char * end)661 bool UpdataMids(int32_t locate, char *mids, char *start, char *end)
662 {
663     if (locate == 0) {
664         if (strcpy_s(mids, MAX_LENGTH, start) != EOK) {
665             return false;
666         }
667     } else {
668         if (strcat_s(mids, MAX_LENGTH, g_commaStr) != EOK) {
669             return false;
670         }
671         if (strcat_s(mids, MAX_LENGTH, start) != EOK) {
672             return false;
673         }
674     }
675     if (strcat_s(mids, MAX_LENGTH, g_hyphenStr) != EOK) {
676         return false;
677     }
678     if (strcat_s(mids, MAX_LENGTH, end) != EOK) {
679         return false;
680     }
681     return true;
682 }
683 
UpdataMidValues(int32_t locate,char * mids,char * start)684 bool UpdataMidValues(int32_t locate, char *mids, char *start)
685 {
686     if (locate == 0) {
687         if (strcpy_s(mids, MAX_LENGTH, start) != EOK) {
688             return false;
689         }
690     } else {
691         if (strcat_s(mids, MAX_LENGTH, g_commaStr) != EOK) {
692             return false;
693         }
694         if (strcat_s(mids, MAX_LENGTH, start) != EOK) {
695             return false;
696         }
697     }
698     return true;
699 }
700 
GetDcss(const HRilCBConfigInfo * data,int32_t len,char * dcss)701 bool GetDcss(const HRilCBConfigInfo *data, int32_t len, char *dcss)
702 {
703     for (int32_t locate = 0; locate < len && (locate + 1) * (CHNL_LEN + CHNL_LEN + 1) < MAX_LENGTH; locate++) {
704         if (data[locate].startOfCodeScheme > data[locate].endOfCodeScheme) {
705             TELEPHONY_LOGE("result.dcss is invalid");
706             return false;
707         } else if (data[locate].startOfCodeScheme < data[locate].endOfCodeScheme) {
708             char start[CHNL_LEN] = { 0 };
709             sprintf_s(start, CHNL_LEN, "%d", data[locate].startOfCodeScheme);
710             char end[CHNL_LEN] = { 0 };
711             sprintf_s(end, CHNL_LEN, "%d", data[locate].endOfCodeScheme);
712             if (locate != 0) {
713                 break;
714             }
715             if (strcpy_s(dcss, MAX_LENGTH, start) != EOK) {
716                 return false;
717             }
718             if (strcat_s(dcss, MAX_LENGTH, g_hyphenStr) != EOK) {
719                 return false;
720             }
721             if (strcat_s(dcss, MAX_LENGTH, end) != EOK) {
722                 return false;
723             }
724         } else {
725             char start[CHNL_LEN] = { 0 };
726             sprintf_s(start, CHNL_LEN, "%d", data[locate].startOfCodeScheme);
727             if (locate != 0) {
728                 break;
729             }
730             if (strcpy_s(dcss, MAX_LENGTH, start) != EOK) {
731                 return false;
732             }
733         }
734     }
735     return true;
736 }
737 
GetMidsAndDcss(const HRilCBConfigInfo * data,int32_t len,char * mids,char * dcss)738 bool GetMidsAndDcss(const HRilCBConfigInfo *data, int32_t len, char *mids, char *dcss)
739 {
740     for (int32_t locate = 0; locate < len && (locate + 1) * (CHNL_LEN + CHNL_LEN + 1) < MAX_LENGTH; locate++) {
741         if (data[locate].startOfServiceId < data[locate].endOfServiceId) {
742             char start[CHNL_LEN] = { 0 };
743             sprintf_s(start, CHNL_LEN, "%d", data[locate].startOfServiceId);
744             char end[CHNL_LEN] = { 0 };
745             sprintf_s(end, CHNL_LEN, "%d", data[locate].endOfServiceId);
746             if (!UpdataMids(locate, mids, start, end)) {
747                 return false;
748             }
749         } else {
750             char start[CHNL_LEN] = { 0 };
751             sprintf_s(start, CHNL_LEN, "%d", data[locate].startOfServiceId);
752             if (UpdataMidValues(locate, mids, start)) {
753                 return false;
754             }
755         }
756         if (!GetDcss(data, len, dcss)) {
757             return false;
758         }
759     }
760     return true;
761 }
762 
ReqSetCBConfig(const ReqDataInfo * requestInfo,const HRilCBConfigInfo * data,size_t dataLen)763 void ReqSetCBConfig(const ReqDataInfo *requestInfo, const HRilCBConfigInfo *data, size_t dataLen)
764 {
765     char cmd[MAX_CMD_LENGTH] = { 0 };
766     int32_t err;
767     int32_t ret;
768     ResponseInfo *responseInfo = NULL;
769     int32_t len = (int32_t)(dataLen / sizeof(HRilCBConfigInfo));
770     if (data == NULL || len == 0) {
771         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_GENERIC_FAILURE, HRIL_RESPONSE, 0);
772         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
773         FreeResponseInfo(responseInfo);
774         return;
775     }
776     int32_t mode = data[0].selected;
777     char mids[MAX_LENGTH] = { 0 };
778     char dcss[MAX_LENGTH] = { 0 };
779     if (!GetMidsAndDcss(data, len, mids, dcss)) {
780         return;
781     }
782     if (strcmp(mids, "") && !strcmp(dcss, "")) {
783         ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CSCB=%d,\"%s\"", mode, mids);
784     } else if (strcmp(mids, "") && strcmp(dcss, "")) {
785         ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CSCB=%d,\"%s\",\"%s\"", mode, mids, dcss);
786     } else if (strcmp(dcss, "") && !strcmp(mids, "")) {
787         ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CSCB=%d,,\"%s\"", mode, dcss);
788     } else {
789         ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CSCB=%d", mode);
790     }
791     if (ret < 0) {
792         TELEPHONY_LOGE("GenerateCommand failed, err = %{public}d\n", ret);
793         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, AT_ERR_GENERIC, HRIL_RESPONSE, 0);
794         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
795         FreeResponseInfo(responseInfo);
796         return;
797     }
798     err = SendCommandLock(cmd, "+CSCB:", 0, &responseInfo);
799     if (err != 0 || (responseInfo != NULL && !responseInfo->success)) {
800         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, AT_ERR_GENERIC, HRIL_RESPONSE, 0);
801         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
802         FreeResponseInfo(responseInfo);
803         return;
804     }
805     struct ReportInfo reportInfo = CreateReportInfo(requestInfo, VENDOR_SUCCESS, HRIL_RESPONSE, 0);
806     OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
807     FreeResponseInfo(responseInfo);
808 }
809 
ReqGetCdmaCBConfig(const ReqDataInfo * requestInfo)810 void ReqGetCdmaCBConfig(const ReqDataInfo *requestInfo)
811 {
812     char checked = '0';
813     char lineBuff[MAX_CMD_LENGTH] = {0};
814     char *line = lineBuff;
815     int32_t err = HRIL_ERR_SUCCESS;
816     int32_t service = 1;
817     int32_t language = 1;
818     ResponseInfo *responseInfo = NULL;
819     HRilCdmaCBConfigInfo cdmaCBConfig = {0};
820 
821     int32_t ret = GenerateCommand(lineBuff, MAX_CMD_LENGTH, "AT:%d,%d,%c", service, language, checked);
822     if (ret < 0) {
823         TELEPHONY_LOGE("GenerateCommand failed, err = %{public}d\n", ret);
824         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
825         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
826         FreeResponseInfo(responseInfo);
827         return;
828     }
829     SkipATPrefix(&line);
830     err = NextInt(&line, &cdmaCBConfig.service);
831     if (err > 0) {
832         err = HRIL_ERR_GENERIC_FAILURE;
833         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
834         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
835         FreeResponseInfo(responseInfo);
836         return;
837     }
838     err = NextInt(&line, &cdmaCBConfig.language);
839     if (err > 0) {
840         err = HRIL_ERR_GENERIC_FAILURE;
841         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
842         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
843         FreeResponseInfo(responseInfo);
844         return;
845     }
846     char *tmp = NULL;
847     err = NextStr(&line, &tmp);
848     if (err > 0 || tmp == NULL || tmp[0] == '\0') {
849         err = HRIL_ERR_GENERIC_FAILURE;
850         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
851         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
852         FreeResponseInfo(responseInfo);
853         return;
854     }
855     cdmaCBConfig.checked = tmp[0];
856     struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
857     OnSmsReport(GetSlotId(requestInfo), reportInfo, (const uint8_t *)&cdmaCBConfig, sizeof(HRilCdmaCBConfigInfo));
858     FreeResponseInfo(responseInfo);
859 }
860 
ReqSetCdmaCBConfig(const ReqDataInfo * requestInfo,const HRilCdmaCBConfigInfo * data,size_t dataLen)861 void ReqSetCdmaCBConfig(const ReqDataInfo *requestInfo, const HRilCdmaCBConfigInfo *data, size_t dataLen)
862 {
863     int32_t err;
864     ResponseInfo *responseInfo = NULL;
865 
866     if (data == NULL) {
867         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_GENERIC_FAILURE, HRIL_RESPONSE, 0);
868         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
869         FreeResponseInfo(responseInfo);
870         return;
871     }
872     int32_t size = dataLen / sizeof(HRilCdmaCBConfigInfo);
873     if (size <= 0) {
874         err = HRIL_ERR_GENERIC_FAILURE;
875         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
876         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
877         FreeResponseInfo(responseInfo);
878         return;
879     }
880     err = HRIL_ERR_SUCCESS;
881     struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
882     OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
883     FreeResponseInfo(responseInfo);
884 }
885 
ReqAddCdmaSimMessage(const ReqDataInfo * requestInfo,const HRilSmsWriteCdmaSms * data,size_t dataLen)886 void ReqAddCdmaSimMessage(const ReqDataInfo *requestInfo, const HRilSmsWriteCdmaSms *data, size_t dataLen)
887 {
888     if (data == NULL) {
889         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_GENERIC_FAILURE, HRIL_RESPONSE, 0);
890         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
891         return;
892     }
893     HRilSmsWriteCdmaSms *cdmaSms = (HRilSmsWriteCdmaSms *)data;
894     HRilCdmaSmsMessageInfo *cdmaMsg = &cdmaSms->cdmaMessageInfo;
895     TELEPHONY_LOGD(
896         "CreateCdmaPdu = %{public}x, %{public}x, %{public}x", cdmaMsg->serviceId, cdmaMsg->isExist, cdmaMsg->type);
897     TELEPHONY_LOGD("CreateCdmaPdu2 = %{public}x, %{public}x, %{public}x", cdmaMsg->address.digitMode,
898         cdmaMsg->address.mode, cdmaMsg->address.type);
899     TELEPHONY_LOGD("CreateCdmaPdu3 = %{public}x, %{public}x, %{public}s", cdmaMsg->address.plan,
900         cdmaMsg->address.number, cdmaMsg->address.bytes);
901     struct ReportInfo reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_SUCCESS, HRIL_RESPONSE, 0);
902     OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
903 }
904 
ReqDelCdmaSimMessage(const ReqDataInfo * requestInfo,const int32_t * data,size_t dataLen)905 void ReqDelCdmaSimMessage(const ReqDataInfo *requestInfo, const int32_t *data, size_t dataLen)
906 {
907     char cmd[MAX_CMD_LENGTH] = {0};
908     int32_t err;
909     int32_t index;
910     ResponseInfo *responseInfo = NULL;
911     if (data == NULL || dataLen == 0) {
912         TELEPHONY_LOGE("data error");
913         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_GENERIC_FAILURE, HRIL_RESPONSE, 0);
914         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
915         FreeResponseInfo(responseInfo);
916         return;
917     }
918     index = ((int32_t *)data)[0] - 1;
919     if (index < 0) {
920         TELEPHONY_LOGE("invalid index:%d", index);
921         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_GENERIC_FAILURE, HRIL_RESPONSE, 0);
922         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
923         FreeResponseInfo(responseInfo);
924         return;
925     }
926     err = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CMGD=%d", index);
927     if (err < 0) {
928         TELEPHONY_LOGE("GenerateCommand failed, err = %{public}d\n", err);
929         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
930         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
931         FreeResponseInfo(responseInfo);
932         return;
933     }
934     err = SendCommandLock(cmd, "+CMGD:", 0, &responseInfo);
935     if (err != 0 || (responseInfo != NULL && !responseInfo->success)) {
936         err = HRIL_ERR_GENERIC_FAILURE;
937         struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
938         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
939         FreeResponseInfo(responseInfo);
940         return;
941     }
942     struct ReportInfo reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_SUCCESS, HRIL_RESPONSE, 0);
943     OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
944     FreeResponseInfo(responseInfo);
945 }
946 
ReqUpdateCdmaSimMessage(const ReqDataInfo * requestInfo,const HRilSmsWriteSms * data,size_t dataLen)947 void ReqUpdateCdmaSimMessage(const ReqDataInfo *requestInfo, const HRilSmsWriteSms *data, size_t dataLen)
948 {
949     char cmd[MAX_CMD_LENGTH] = {0};
950     int32_t err;
951     HRilSmsWriteSms *cdmaMsg = NULL;
952     ResponseInfo *responseInfo = NULL;
953     struct ReportInfo reportInfo = {0};
954     if (data == NULL) {
955         reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_GENERIC_FAILURE, HRIL_RESPONSE, 0);
956         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
957         FreeResponseInfo(responseInfo);
958         return;
959     }
960     cdmaMsg = ((HRilSmsWriteSms *)data);
961     err = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CPMS=%d,%d%s", cdmaMsg->index, cdmaMsg->state, cdmaMsg->pdu);
962     if (err < 0) {
963         TELEPHONY_LOGE("GenerateCommand failed, err = %{public}d\n", err);
964         reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
965         OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
966         FreeResponseInfo(responseInfo);
967         return;
968     }
969     err = SendCommandLock(cmd, "+CPMS:", 0, &responseInfo);
970     if (err != 0 || (responseInfo != NULL && !responseInfo->success)) {
971         err = HRIL_ERR_GENERIC_FAILURE;
972         SimMessageError(&reportInfo, requestInfo, &err, responseInfo);
973         return;
974     }
975     reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
976     OnSmsReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
977     FreeResponseInfo(responseInfo);
978 }
979