1 /*
2  * Copyright (C) 2023 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 "gsm_sms_tpdu_encode.h"
17 
18 #include "gsm_pdu_hex_value.h"
19 #include "gsm_user_data_pdu.h"
20 #include "securec.h"
21 #include "telephony_log_wrapper.h"
22 
23 namespace OHOS {
24 namespace Telephony {
25 using namespace std;
26 const std::string CT_SMSC = "10659401";
27 
GsmSmsTpduEncode(std::shared_ptr<GsmUserDataPdu> dataCodec,std::shared_ptr<GsmSmsParamCodec> paramCodec,std::shared_ptr<GsmSmsTpduCodec> tpdu)28 GsmSmsTpduEncode::GsmSmsTpduEncode(std::shared_ptr<GsmUserDataPdu> dataCodec,
29     std::shared_ptr<GsmSmsParamCodec> paramCodec, std::shared_ptr<GsmSmsTpduCodec> tpdu)
30 {
31     uDataCodec_ = dataCodec;
32     paramCodec_ = paramCodec;
33     tpdu_ = tpdu;
34 }
35 
~GsmSmsTpduEncode()36 GsmSmsTpduEncode::~GsmSmsTpduEncode() {}
37 
EncodeSubmitPdu(SmsWriteBuffer & buffer,const struct SmsSubmit * pSubmit)38 bool GsmSmsTpduEncode::EncodeSubmitPdu(SmsWriteBuffer &buffer, const struct SmsSubmit *pSubmit)
39 {
40     if (pSubmit == nullptr || paramCodec_ == nullptr || uDataCodec_ == nullptr) {
41         TELEPHONY_LOGE("nullptr error");
42         return false;
43     }
44     EncodeSubmitTpduType(buffer, *pSubmit);
45 
46     /* TP-MR */
47     if (!buffer.WriteByte(pSubmit->msgRef)) {
48         TELEPHONY_LOGE("write data error.");
49         return false;
50     }
51 
52     /* TP-DA */
53     std::string address;
54     if (!paramCodec_->EncodeAddressPdu(&pSubmit->destAddress, address)) {
55         TELEPHONY_LOGE("encode address fail.");
56         return false;
57     }
58 
59     uint8_t position = address.size();
60     if (buffer.data_ == nullptr || (buffer.GetIndex() + position) > buffer.GetSize()) {
61         TELEPHONY_LOGE("buffer error.");
62         return false;
63     }
64     if (memcpy_s(buffer.data_.get() + buffer.GetIndex(), position, address.data(), position) != EOK) {
65         TELEPHONY_LOGE("memcpy_s error.");
66         return false;
67     }
68     buffer.MoveForward(position);
69     /* TP-PID */
70     if (!buffer.WriteByte(pSubmit->pid)) {
71         TELEPHONY_LOGE("write data error.");
72         return false;
73     }
74     return EncodeSubmitPduPartData(buffer, pSubmit);
75 }
76 
EncodeSubmitPduPartData(SmsWriteBuffer & buffer,const struct SmsSubmit * pSubmit)77 bool GsmSmsTpduEncode::EncodeSubmitPduPartData(SmsWriteBuffer &buffer, const struct SmsSubmit *pSubmit)
78 {
79     /* TP-DCS */
80     std::string dcs;
81     paramCodec_->EncodeDCS(&pSubmit->dcs, dcs);
82     if (buffer.data_ == nullptr || (buffer.GetIndex() + HEX_VALUE_01) > buffer.GetSize()) {
83         TELEPHONY_LOGE("buffer error.");
84         return false;
85     }
86     uint16_t bufferLen = buffer.GetSize() - buffer.GetIndex() - HEX_VALUE_01;
87     if (memcpy_s(buffer.data_.get() + buffer.GetIndex(), bufferLen, dcs.data(), HEX_VALUE_01) != EOK) {
88         TELEPHONY_LOGE("memcpy_s error.");
89         return false;
90     }
91     buffer.MoveForward(HEX_VALUE_01);
92     /* TP-VP */
93     std::string vpTime;
94     if (pSubmit->vpf != SMS_VPF_NOT_PRESENT) {
95         paramCodec_->EncodeTimePdu(&pSubmit->validityPeriod, vpTime);
96         uint8_t position = vpTime.size();
97         if (position > 0) {
98             if (buffer.data_ == nullptr || (buffer.GetIndex() + position) > buffer.GetSize()) {
99                 TELEPHONY_LOGE("buffer error.");
100                 return false;
101             }
102             if (memcpy_s(buffer.data_.get() + buffer.GetIndex(), position, vpTime.data(), position) != EOK) {
103                 TELEPHONY_LOGE("EncodeSubmitPdu vpTime memcpy_s error.");
104                 return false;
105             }
106             buffer.MoveForward(position);
107         }
108     }
109     const struct SmsUDPackage *pUserData = &(pSubmit->userData);
110     std::string addr = pSubmit->destAddress.address;
111     bool ret = uDataCodec_->EncodeUserDataPdu(buffer, pUserData, pSubmit->dcs.codingScheme, addr);
112     return ret;
113 }
114 
EncodeSubmitTpduType(SmsWriteBuffer & buffer,const struct SmsSubmit & pSubmit)115 void GsmSmsTpduEncode::EncodeSubmitTpduType(SmsWriteBuffer &buffer, const struct SmsSubmit &pSubmit)
116 {
117     if (!buffer.InsertByte(HEX_VALUE_01, buffer.GetIndex())) {
118         TELEPHONY_LOGE("write data error.");
119         return;
120     }
121     /* TP-RD */
122     if (pSubmit.bRejectDup) {
123         uint8_t oneByte = 0;
124         if (!buffer.GetTopValue(oneByte)) {
125             TELEPHONY_LOGE("get data error.");
126             return;
127         }
128         if (!buffer.InsertByte(oneByte | HEX_VALUE_04, buffer.GetIndex())) {
129             TELEPHONY_LOGE("write data error.");
130             return;
131         }
132     }
133     EncodeSubmitTypePartData(buffer, pSubmit);
134 }
135 
EncodeSubmitTypePartData(SmsWriteBuffer & buffer,const struct SmsSubmit & pSubmit)136 void GsmSmsTpduEncode::EncodeSubmitTypePartData(SmsWriteBuffer &buffer, const struct SmsSubmit &pSubmit)
137 {
138     uint8_t oneByte = 0;
139     /* TP-VPF */
140     switch (pSubmit.vpf) {
141         case SMS_VPF_NOT_PRESENT:
142             break;
143         case SMS_VPF_ENHANCED:
144             if (!buffer.GetTopValue(oneByte)) {
145                 TELEPHONY_LOGE("get data error.");
146                 return;
147             }
148             if (!buffer.InsertByte(oneByte | HEX_VALUE_08, buffer.GetIndex())) {
149                 TELEPHONY_LOGE("write data error.");
150                 return;
151             }
152             break;
153         case SMS_VPF_RELATIVE:
154             if (!buffer.GetTopValue(oneByte)) {
155                 TELEPHONY_LOGE("get data error.");
156                 return;
157             }
158             if (!buffer.InsertByte(oneByte | HEX_VALUE_10, buffer.GetIndex())) {
159                 TELEPHONY_LOGE("write data error.");
160                 return;
161             }
162             break;
163         case SMS_VPF_ABSOLUTE:
164             if (!buffer.GetTopValue(oneByte)) {
165                 TELEPHONY_LOGE("get data error.");
166                 return;
167             }
168             if (!buffer.InsertByte(oneByte | HEX_VALUE_18, buffer.GetIndex())) {
169                 TELEPHONY_LOGE("write data error.");
170                 return;
171             }
172             break;
173         default:
174             break;
175     }
176     EncodeSubmitTypeData(buffer, pSubmit);
177 }
178 
EncodeSubmitTypeData(SmsWriteBuffer & buffer,const struct SmsSubmit & pSubmit)179 void GsmSmsTpduEncode::EncodeSubmitTypeData(SmsWriteBuffer &buffer, const struct SmsSubmit &pSubmit)
180 {
181     uint8_t oneByte = 0;
182     /* TP-SRR */
183     if (pSubmit.bStatusReport) {
184         if (!buffer.GetTopValue(oneByte)) {
185             TELEPHONY_LOGE("get data error.");
186             return;
187         }
188         if (!buffer.InsertByte(oneByte | HEX_VALUE_20, buffer.GetIndex())) {
189             TELEPHONY_LOGE("write data error.");
190             return;
191         }
192     }
193     /* TP-UDHI */
194     if (pSubmit.bHeaderInd && CT_SMSC.compare(pSubmit.destAddress.address) != 0) {
195         if (!buffer.GetTopValue(oneByte)) {
196             TELEPHONY_LOGE("get data error.");
197             return;
198         }
199         if (!buffer.InsertByte(oneByte | HEX_VALUE_40, buffer.GetIndex())) {
200             TELEPHONY_LOGE("write data error.");
201             return;
202         }
203     }
204     /* TP-RP */
205     if (pSubmit.bReplyPath) {
206         if (!buffer.GetTopValue(oneByte)) {
207             TELEPHONY_LOGE("get data error.");
208             return;
209         }
210         if (!buffer.InsertByte(oneByte | HEX_VALUE_80, buffer.GetIndex())) {
211             TELEPHONY_LOGE("write data error.");
212             return;
213         }
214     }
215     buffer.MoveForward(HEX_VALUE_01);
216 }
217 
EncodeDeliverPdu(SmsWriteBuffer & buffer,const struct SmsDeliver * pDeliver)218 bool GsmSmsTpduEncode::EncodeDeliverPdu(SmsWriteBuffer &buffer, const struct SmsDeliver *pDeliver)
219 {
220     if (pDeliver == nullptr) {
221         TELEPHONY_LOGE("nullptr error.");
222         return false;
223     }
224     /* TP-MTI : 00 */
225     if (!buffer.InsertByte(0x00, buffer.GetIndex())) {
226         TELEPHONY_LOGE("write data error.");
227         return false;
228     }
229 
230     /* TP-MMS */
231     uint8_t oneByte = 0;
232     if (pDeliver->bMoreMsg == false) {
233         if (!buffer.GetTopValue(oneByte)) {
234             TELEPHONY_LOGE("get data error.");
235             return false;
236         }
237         if (!buffer.InsertByte(oneByte | HEX_VALUE_04, buffer.GetIndex())) {
238             TELEPHONY_LOGE("write data error.");
239             return false;
240         }
241     }
242     /* TP-SRI */
243     if (pDeliver->bStatusReport == true) {
244         if (!buffer.GetTopValue(oneByte)) {
245             TELEPHONY_LOGE("get data error.");
246             return false;
247         }
248         if (!buffer.InsertByte(oneByte | HEX_VALUE_20, buffer.GetIndex())) {
249             TELEPHONY_LOGE("write data error.");
250             return false;
251         }
252     }
253     /* TP-UDHI */
254     if (pDeliver->bHeaderInd == true) {
255         if (!buffer.GetTopValue(oneByte)) {
256             TELEPHONY_LOGE("get data error.");
257             return false;
258         }
259         if (!buffer.InsertByte(oneByte | HEX_VALUE_40, buffer.GetIndex())) {
260             TELEPHONY_LOGE("write data error.");
261             return false;
262         }
263     }
264     return EncodeDeliverPartData(buffer, pDeliver);
265 }
266 
EncodeDeliverPartData(SmsWriteBuffer & buffer,const struct SmsDeliver * pDeliver)267 bool GsmSmsTpduEncode::EncodeDeliverPartData(SmsWriteBuffer &buffer, const struct SmsDeliver *pDeliver)
268 {
269     if (paramCodec_ == nullptr) {
270         TELEPHONY_LOGE("nullptr error.");
271         return false;
272     }
273 
274     /* TP-RP */
275     if (pDeliver->bReplyPath == true) {
276         uint8_t oneByte = 0;
277         if (!buffer.GetTopValue(oneByte)) {
278             TELEPHONY_LOGE("get data error.");
279             return false;
280         }
281         if (!buffer.WriteByte(oneByte | HEX_VALUE_80)) {
282             TELEPHONY_LOGE("write data error.");
283             return false;
284         }
285     }
286 
287     /* TP-OA */
288 
289     std::string address;
290     if (!paramCodec_->EncodeAddressPdu(&pDeliver->originAddress, address)) {
291         TELEPHONY_LOGE("encode addr fail.");
292         return false;
293     }
294 
295     uint8_t length = address.size();
296     if (buffer.data_ == nullptr || (buffer.GetIndex() + length) > buffer.GetSize()) {
297         TELEPHONY_LOGE("buffer error.");
298         return false;
299     }
300     if (memcpy_s(buffer.data_.get() + buffer.GetIndex(), length, address.data(), length) != EOK) {
301         TELEPHONY_LOGE("memcpy_s error.");
302         return false;
303     }
304     buffer.MoveForward(length);
305     /* TP-PID */
306     if (!buffer.WriteByte(pDeliver->pid)) {
307         TELEPHONY_LOGE("write data error.");
308         return false;
309     }
310     return EncodeDeliverData(buffer, pDeliver);
311 }
312 
EncodeDeliverData(SmsWriteBuffer & buffer,const struct SmsDeliver * pDeliver)313 bool GsmSmsTpduEncode::EncodeDeliverData(SmsWriteBuffer &buffer, const struct SmsDeliver *pDeliver)
314 {
315     if (uDataCodec_ == nullptr) {
316         TELEPHONY_LOGE("nullptr error.");
317         return false;
318     }
319     /* TP-DCS */
320     std::string dcs;
321     paramCodec_->EncodeDCS(&pDeliver->dcs, dcs);
322     if (buffer.data_ == nullptr || (buffer.GetIndex() + HEX_VALUE_01) > buffer.GetSize()) {
323         TELEPHONY_LOGE("buffer error.");
324         return false;
325     }
326     uint16_t bufferLen = buffer.GetSize() - buffer.GetIndex() - HEX_VALUE_01;
327     if (memcpy_s(buffer.data_.get() + buffer.GetIndex(), bufferLen, dcs.data(), HEX_VALUE_01) != EOK) {
328         TELEPHONY_LOGE("memcpy_s error.");
329         return false;
330     }
331     buffer.MoveForward(1);
332 
333     /* TP-SCTS */
334     std::string scts;
335     paramCodec_->EncodeTimePdu(&pDeliver->timeStamp, scts);
336     uint8_t length = scts.size();
337     if (buffer.data_ == nullptr || (buffer.GetIndex() + length) > buffer.GetSize()) {
338         TELEPHONY_LOGE("buffer error.");
339         return false;
340     }
341     if (memcpy_s(buffer.data_.get() + buffer.GetIndex(), length, scts.data(), length) != EOK) {
342         TELEPHONY_LOGE("memcpy_s error.");
343         return false;
344     }
345     buffer.MoveForward(length);
346 
347     /* TP-UDL & TP-UD */
348     const struct SmsUDPackage *pUserData = &(pDeliver->userData);
349     std::string addr;
350     bool result = uDataCodec_->EncodeUserDataPdu(buffer, pUserData, pDeliver->dcs.codingScheme, addr);
351     return result;
352 }
353 
EncodeDeliverReportPdu(SmsWriteBuffer & buffer,const struct SmsDeliverReport * pDeliverRep)354 bool GsmSmsTpduEncode::EncodeDeliverReportPdu(SmsWriteBuffer &buffer, const struct SmsDeliverReport *pDeliverRep)
355 {
356     if (pDeliverRep == nullptr) {
357         TELEPHONY_LOGE("nullptr error.");
358         return false;
359     }
360 
361     /* TP-MTI : 00 */
362     if (!buffer.InsertByte(0x00, buffer.GetIndex())) {
363         TELEPHONY_LOGE("write data error.");
364         return false;
365     }
366     /* TP-UDHI */
367     if (pDeliverRep->bHeaderInd == true) {
368         uint8_t oneByte = 0;
369         if (!buffer.GetTopValue(oneByte)) {
370             TELEPHONY_LOGE("get data error.");
371             return false;
372         }
373         if (!buffer.InsertByte(oneByte | HEX_VALUE_40, buffer.GetIndex())) {
374             TELEPHONY_LOGE("write data error.");
375             return false;
376         }
377     }
378     buffer.MoveForward(1);
379     /* TP-FCS */
380     if (pDeliverRep->reportType == SMS_REPORT_NEGATIVE) {
381         if (!buffer.WriteByte(pDeliverRep->failCause)) {
382             TELEPHONY_LOGE("write data error.");
383             return false;
384         }
385         TELEPHONY_LOGI("Delivery report : fail cause = [%{public}02x]", pDeliverRep->failCause);
386     }
387     /* TP-PI */
388     if (!buffer.WriteByte(pDeliverRep->paramInd)) {
389         TELEPHONY_LOGE("write data error.");
390         return false;
391     }
392     /* TP-PID */
393     if (pDeliverRep->paramInd & HEX_VALUE_01) {
394         if (!buffer.WriteByte(pDeliverRep->pid)) {
395             TELEPHONY_LOGE("write data error.");
396             return false;
397         }
398     }
399     return EncodeDeliverReportPartData(buffer, pDeliverRep);
400 }
401 
EncodeDeliverReportPartData(SmsWriteBuffer & buffer,const struct SmsDeliverReport * pDeliverRep)402 bool GsmSmsTpduEncode::EncodeDeliverReportPartData(SmsWriteBuffer &buffer, const struct SmsDeliverReport *pDeliverRep)
403 {
404     if (paramCodec_ == nullptr || uDataCodec_ == nullptr) {
405         TELEPHONY_LOGE("nullptr error.");
406         return false;
407     }
408     /* TP-DCS */
409     if (pDeliverRep->paramInd & HEX_VALUE_02) {
410         std::string dcs;
411         paramCodec_->EncodeDCS(&pDeliverRep->dcs, dcs);
412         if (buffer.data_ == nullptr || (buffer.GetIndex() + HEX_VALUE_01) > buffer.GetSize()) {
413             TELEPHONY_LOGE("buffer error.");
414             return false;
415         }
416         uint16_t bufferLen = buffer.GetSize() - buffer.GetIndex() - HEX_VALUE_01;
417         if (memcpy_s(buffer.data_.get() + buffer.GetIndex(), bufferLen, dcs.data(), HEX_VALUE_01) != EOK) {
418             TELEPHONY_LOGE("memcpy_s error.");
419             return false;
420         }
421         buffer.MoveForward(1);
422     }
423     bool result = false;
424     /* TP-UDL & TP-UD */
425     if (pDeliverRep->paramInd & HEX_VALUE_04) {
426         const struct SmsUDPackage *pUserData = &(pDeliverRep->userData);
427         std::string addr;
428         result = uDataCodec_->EncodeUserDataPdu(buffer, pUserData, pDeliverRep->dcs.codingScheme, addr);
429     }
430     return result;
431 }
432 
EncodeStatusReportPdu(SmsWriteBuffer & buffer,const struct SmsStatusReport * pStatusRep)433 bool GsmSmsTpduEncode::EncodeStatusReportPdu(SmsWriteBuffer &buffer, const struct SmsStatusReport *pStatusRep)
434 {
435     if (pStatusRep == nullptr) {
436         TELEPHONY_LOGE("nullptr error.");
437         return false;
438     }
439     /* TP-MTI : 10 */
440     if (!buffer.InsertByte(HEX_VALUE_02, buffer.GetIndex())) {
441         TELEPHONY_LOGE("write data error.");
442         return false;
443     }
444     /* TP-MMS */
445     uint8_t oneByte = 0;
446     if (pStatusRep->bMoreMsg == true) {
447         if (!buffer.GetTopValue(oneByte)) {
448             TELEPHONY_LOGE("get data error.");
449             return false;
450         }
451         if (!buffer.InsertByte(oneByte | HEX_VALUE_04, buffer.GetIndex())) {
452             TELEPHONY_LOGE("write data error.");
453             return false;
454         }
455     }
456     /* TP-SRQ */
457     if (pStatusRep->bStatusReport == true) {
458         if (!buffer.GetTopValue(oneByte)) {
459             TELEPHONY_LOGE("get data error.");
460             return false;
461         }
462         if (!buffer.InsertByte(oneByte | HEX_VALUE_20, buffer.GetIndex())) {
463             TELEPHONY_LOGE("write data error.");
464             return false;
465         }
466     }
467     /* TP-UDHI */
468     if (pStatusRep->bHeaderInd == true) {
469         if (!buffer.GetTopValue(oneByte)) {
470             TELEPHONY_LOGE("get data error.");
471             return false;
472         }
473         if (!buffer.WriteByte(oneByte | HEX_VALUE_40)) {
474             TELEPHONY_LOGE("write data error.");
475             return false;
476         }
477     }
478 
479     /* TP-MR */
480     if (!buffer.WriteByte(pStatusRep->msgRef)) {
481         TELEPHONY_LOGE("write data error.");
482         return false;
483     }
484     return EncodeStatusReportPartData(buffer, pStatusRep);
485 }
486 
EncodeStatusReportPartData(SmsWriteBuffer & buffer,const struct SmsStatusReport * pStatusRep)487 bool GsmSmsTpduEncode::EncodeStatusReportPartData(SmsWriteBuffer &buffer, const struct SmsStatusReport *pStatusRep)
488 {
489     if (paramCodec_ == nullptr) {
490         TELEPHONY_LOGE("nullptr error.");
491         return false;
492     }
493 
494     /* TP-RA */
495     std::string address;
496     if (!paramCodec_->EncodeAddressPdu(&pStatusRep->recipAddress, address)) {
497         TELEPHONY_LOGE("encode addr fail.");
498         return false;
499     }
500 
501     uint8_t length = address.size();
502     if (buffer.data_ == nullptr || (buffer.GetIndex() + length) > buffer.GetSize()) {
503         TELEPHONY_LOGE("buffer error.");
504         return false;
505     }
506     if (memcpy_s(buffer.data_.get() + buffer.GetIndex(), length, address.data(), length) != EOK) {
507         TELEPHONY_LOGE("memcpy_s error.");
508         return false;
509     }
510     buffer.MoveForward(length);
511 
512     /* TP-SCTS */
513     std::string scts;
514 
515     paramCodec_->EncodeTimePdu(&pStatusRep->timeStamp, scts);
516     length = scts.size();
517     if (buffer.data_ == nullptr || (buffer.GetIndex() + length) > buffer.GetSize()) {
518         TELEPHONY_LOGE("buffer error.");
519         return false;
520     }
521     if (memcpy_s(buffer.data_.get() + buffer.GetIndex(), length, scts.data(), length) != EOK) {
522         TELEPHONY_LOGE("memcpy_s error.");
523         return false;
524     }
525     buffer.MoveForward(length);
526 
527     /* TP-DT */
528     std::string dt;
529     paramCodec_->EncodeTimePdu(&pStatusRep->dischargeTime, dt);
530     length = scts.size();
531     if (buffer.data_ == nullptr || (buffer.GetIndex() + length) > buffer.GetSize()) {
532         TELEPHONY_LOGE("buffer error.");
533         return false;
534     }
535     if (memcpy_s(buffer.data_.get() + buffer.GetIndex(), length, dt.data(), length) != EOK) {
536         TELEPHONY_LOGE("memcpy_s error.");
537         return false;
538     }
539     buffer.MoveForward(length);
540     return EncodeStatusReportData(buffer, pStatusRep, length);
541 }
542 
EncodeStatusReportData(SmsWriteBuffer & buffer,const struct SmsStatusReport * pStatusRep,uint8_t length)543 bool GsmSmsTpduEncode::EncodeStatusReportData(
544     SmsWriteBuffer &buffer, const struct SmsStatusReport *pStatusRep, uint8_t length)
545 {
546     if (uDataCodec_ == nullptr) {
547         TELEPHONY_LOGE("nullptr error.");
548         return false;
549     }
550 
551     /* TP-Status */
552     if (!buffer.WriteByte(pStatusRep->status)) {
553         TELEPHONY_LOGE("write data error.");
554         return false;
555     }
556     /* TP-PI */
557     if (!buffer.WriteByte(pStatusRep->paramInd)) {
558         TELEPHONY_LOGE("write data error.");
559         return false;
560     }
561     /* TP-PID */
562     if (pStatusRep->paramInd & HEX_VALUE_01) {
563         if (!buffer.WriteByte(pStatusRep->pid)) {
564             TELEPHONY_LOGE("write data error.");
565             return false;
566         }
567     }
568     /* TP-DCS */
569     if (pStatusRep->paramInd & HEX_VALUE_02) {
570         std::string dcs;
571         paramCodec_->EncodeDCS(&pStatusRep->dcs, dcs);
572         if (buffer.data_ == nullptr || (buffer.GetIndex() + length) > buffer.GetSize()) {
573             TELEPHONY_LOGE("buffer error.");
574             return false;
575         }
576         if (memcpy_s(buffer.data_.get() + buffer.GetIndex(), length, dcs.data(), length) != EOK) {
577             TELEPHONY_LOGE("memcpy_s error.");
578             return false;
579         }
580         buffer.MoveForward(length);
581     }
582     /* TP-UDL & TP-UD */
583     bool result = false;
584     if (pStatusRep->paramInd & HEX_VALUE_04) {
585         const struct SmsUDPackage *pUserData = &(pStatusRep->userData);
586         std::string addr;
587         result = uDataCodec_->EncodeUserDataPdu(buffer, pUserData, pStatusRep->dcs.codingScheme, addr);
588     }
589     return result;
590 }
591 } // namespace Telephony
592 } // namespace OHOS