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_user_data_pdu.h"
17 
18 #include "gsm_pdu_hex_value.h"
19 #include "gsm_sms_common_utils.h"
20 #include "gsm_user_data_decode.h"
21 #include "gsm_user_data_encode.h"
22 #include "securec.h"
23 #include "telephony_log_wrapper.h"
24 
25 namespace OHOS {
26 namespace Telephony {
27 using namespace std;
28 static constexpr uint8_t NORMAL_BYTE_BITS = 8;
29 static constexpr uint8_t SLIDE_DATA_STEP = 2;
30 
EncodeUserDataPdu(SmsWriteBuffer & buffer,const struct SmsUDPackage * (& userData),DataCodingScheme scheme,std::string & destAddr)31 bool GsmUserDataPdu::EncodeUserDataPdu(
32     SmsWriteBuffer &buffer, const struct SmsUDPackage *(&userData), DataCodingScheme scheme, std::string &destAddr)
33 {
34     if (userData == nullptr) {
35         TELEPHONY_LOGE("nullptr error.");
36         return false;
37     }
38     auto encodePdu = std::make_shared<GsmUserDataEncode>(shared_from_this());
39     if (encodePdu == nullptr) {
40         TELEPHONY_LOGE("nullptr error.");
41         return false;
42     }
43 
44     bool result = false;
45     switch (scheme) {
46         case DATA_CODING_7BIT:
47             result = encodePdu->EncodeGsmPdu(buffer, userData);
48             break;
49         case DATA_CODING_8BIT:
50             result = encodePdu->Encode8bitPdu(buffer, userData, destAddr);
51             break;
52         case DATA_CODING_UCS2:
53             result = encodePdu->EncodeUcs2Pdu(buffer, userData);
54             break;
55         default:
56             break;
57     }
58     TELEPHONY_LOGI("userData encode result:%{public}d", result);
59     return result;
60 }
61 
DecodeUserDataPdu(SmsReadBuffer & buffer,bool bHeaderInd,DataCodingScheme scheme,struct SmsUDPackage * userData)62 bool GsmUserDataPdu::DecodeUserDataPdu(
63     SmsReadBuffer &buffer, bool bHeaderInd, DataCodingScheme scheme, struct SmsUDPackage *userData)
64 {
65     if (userData == nullptr) {
66         TELEPHONY_LOGE("nullptr error.");
67         return false;
68     }
69 
70     if (memset_s(userData, sizeof(struct SmsUDPackage), 0x00, sizeof(struct SmsUDPackage)) != EOK) {
71         TELEPHONY_LOGE("memset_s error.");
72         return false;
73     }
74 
75     auto decodePdu = std::make_shared<GsmUserDataDecode>(shared_from_this());
76     if (decodePdu == nullptr) {
77         TELEPHONY_LOGE("nullptr error.");
78         return false;
79     }
80 
81     bool result = false;
82     switch (scheme) {
83         case DATA_CODING_7BIT:
84             result = decodePdu->DecodeGsmPdu(buffer, bHeaderInd, userData, nullptr);
85             break;
86         case DATA_CODING_8BIT:
87             result = decodePdu->Decode8bitPdu(buffer, bHeaderInd, userData, nullptr);
88             break;
89         case DATA_CODING_UCS2:
90             result = decodePdu->DecodeUcs2Pdu(buffer, bHeaderInd, userData, nullptr);
91             break;
92         default:
93             break;
94     }
95     TELEPHONY_LOGI("userData decode result:%{public}d", result);
96     return result;
97 }
98 
DecodeUserDataPdu(SmsReadBuffer & buffer,bool bHeaderInd,DataCodingScheme scheme,struct SmsUDPackage * userData,struct SmsTpud * pTPUD)99 bool GsmUserDataPdu::DecodeUserDataPdu(SmsReadBuffer &buffer, bool bHeaderInd, DataCodingScheme scheme,
100     struct SmsUDPackage *userData, struct SmsTpud *pTPUD)
101 {
102     if (userData == nullptr || pTPUD == nullptr) {
103         TELEPHONY_LOGE("nullptr error.");
104         return false;
105     }
106 
107     if (memset_s(userData, sizeof(struct SmsUDPackage), 0x00, sizeof(struct SmsUDPackage)) != EOK) {
108         TELEPHONY_LOGE("memset_s error.");
109         return false;
110     }
111 
112     auto decodePdu = std::make_shared<GsmUserDataDecode>(shared_from_this());
113     if (decodePdu == nullptr) {
114         TELEPHONY_LOGE("nullptr error.");
115         return false;
116     }
117 
118     bool result = false;
119     switch (scheme) {
120         case DATA_CODING_7BIT:
121             result = decodePdu->DecodeGsmPdu(buffer, bHeaderInd, userData, pTPUD);
122             break;
123         case DATA_CODING_8BIT:
124             result = decodePdu->Decode8bitPdu(buffer, bHeaderInd, userData, pTPUD);
125             break;
126         case DATA_CODING_UCS2:
127             result = decodePdu->DecodeUcs2Pdu(buffer, bHeaderInd, userData, pTPUD);
128             break;
129         case DATA_CODING_EUCKR:
130             result = decodePdu->DecodeUcs2Pdu(buffer, bHeaderInd, userData, pTPUD);
131             break;
132         default:
133             break;
134     }
135     if (!result) {
136         TELEPHONY_LOGE("userData decode fail.");
137     }
138     return result;
139 }
140 
ResetUserData(struct SmsUDPackage & userData)141 void GsmUserDataPdu::ResetUserData(struct SmsUDPackage &userData)
142 {
143     userData.length = 0;
144     if (memset_s(userData.data, sizeof(userData.data), 0x00, sizeof(userData.data)) != EOK) {
145         TELEPHONY_LOGE("memset_s error!");
146         return;
147     }
148 }
149 
GetHeaderCnt(SmsReadBuffer & buffer,struct SmsUDPackage * userData,uint8_t & udhl,uint16_t i)150 bool GsmUserDataPdu::GetHeaderCnt(SmsReadBuffer &buffer, struct SmsUDPackage *userData, uint8_t &udhl, uint16_t i)
151 {
152     if (i >= MAX_UD_HEADER_NUM) {
153         TELEPHONY_LOGE("index invalid.");
154         return false;
155     }
156     uint16_t headerLen = 0;
157     uint16_t current = buffer.GetIndex();
158     if (!DecodeHeader(buffer, userData->header[i], headerLen)) {
159         TELEPHONY_LOGE("memset_s fail.");
160         return false;
161     }
162 
163     if (headerLen == 0) {
164         userData->length = 0;
165         if (memset_s(userData->data, sizeof(userData->data), 0x00, sizeof(userData->data)) != EOK) {
166             TELEPHONY_LOGE("memset_s fail.");
167         }
168         return false;
169     }
170     if ((buffer.GetIndex() - current) > (udhl + SLIDE_DATA_STEP)) {
171         userData->length = 0;
172         if (memset_s(userData->data, sizeof(userData->data), 0x00, sizeof(userData->data)) != EOK) {
173             TELEPHONY_LOGE("memset_s fail.");
174         }
175         return false;
176     }
177     userData->headerCnt++;
178     return true;
179 }
180 
EncodeHeader(SmsWriteBuffer & buffer,const struct SmsUDH header)181 void GsmUserDataPdu::EncodeHeader(SmsWriteBuffer &buffer, const struct SmsUDH header)
182 {
183     switch (header.udhType) {
184         case UDH_CONCAT_8BIT:
185         case UDH_CONCAT_16BIT:
186             EncodeHeaderConcat(buffer, header);
187             break;
188         case UDH_APP_PORT_8BIT:
189             EncodeHeaderAppPort8bit(buffer, header);
190             break;
191         case UDH_APP_PORT_16BIT:
192             EncodeHeaderAppPort16bit(buffer, header);
193             break;
194         case UDH_ALTERNATE_REPLY_ADDRESS:
195             EncodeHeaderReplyAddress(buffer, header);
196             break;
197         case UDH_SINGLE_SHIFT:
198             if (!buffer.WriteByte(UDH_SINGLE_SHIFT)) {
199                 TELEPHONY_LOGE("write data error.");
200                 return;
201             }
202             if (!buffer.WriteByte(HEX_VALUE_01)) {
203                 TELEPHONY_LOGE("write data error.");
204                 return;
205             }
206             if (!buffer.WriteByte(header.udh.singleShift.langId)) {
207                 TELEPHONY_LOGE("write data error.");
208                 return;
209             }
210             break;
211         case UDH_LOCKING_SHIFT:
212             if (!buffer.WriteByte(UDH_LOCKING_SHIFT)) {
213                 TELEPHONY_LOGE("write data error.");
214                 return;
215             }
216             if (!buffer.WriteByte(HEX_VALUE_01)) {
217                 TELEPHONY_LOGE("write data error.");
218                 return;
219             }
220             if (!buffer.WriteByte(header.udh.lockingShift.langId)) {
221                 TELEPHONY_LOGE("write data error.");
222                 return;
223             }
224             break;
225         default:
226             break;
227     }
228 }
229 
EncodeHeaderAppPort8bit(SmsWriteBuffer & buffer,const struct SmsUDH header)230 void GsmUserDataPdu::EncodeHeaderAppPort8bit(SmsWriteBuffer &buffer, const struct SmsUDH header)
231 {
232     if (!buffer.WriteByte(UDH_APP_PORT_8BIT)) {
233         TELEPHONY_LOGE("write data error.");
234         return;
235     }
236     if (!buffer.WriteByte(HEX_VALUE_02)) {
237         TELEPHONY_LOGE("write data error.");
238         return;
239     }
240     if (!buffer.WriteByte(header.udh.appPort8bit.destPort)) {
241         TELEPHONY_LOGE("write data error.");
242         return;
243     }
244     if (!buffer.WriteByte(header.udh.appPort8bit.originPort)) {
245         TELEPHONY_LOGE("write data error.");
246         return;
247     }
248 }
249 
EncodeHeaderAppPort16bit(SmsWriteBuffer & buffer,const struct SmsUDH header)250 void GsmUserDataPdu::EncodeHeaderAppPort16bit(SmsWriteBuffer &buffer, const struct SmsUDH header)
251 {
252     if (!buffer.WriteByte(UDH_APP_PORT_16BIT)) {
253         TELEPHONY_LOGE("write data error.");
254         return;
255     }
256     if (!buffer.WriteByte(HEX_VALUE_04)) {
257         TELEPHONY_LOGE("write data error.");
258         return;
259     }
260     if (!buffer.WriteByte(static_cast<uint8_t>(header.udh.appPort16bit.destPort >> NORMAL_BYTE_BITS))) {
261         TELEPHONY_LOGE("write data error.");
262         return;
263     }
264     if (!buffer.WriteByte(static_cast<uint8_t>(header.udh.appPort16bit.destPort & HEX_VALUE_00FF))) {
265         TELEPHONY_LOGE("write data error.");
266         return;
267     }
268     if (!buffer.WriteByte(static_cast<uint8_t>(header.udh.appPort16bit.originPort >> NORMAL_BYTE_BITS))) {
269         TELEPHONY_LOGE("write data error.");
270         return;
271     }
272     if (!buffer.WriteByte(static_cast<uint8_t>(header.udh.appPort16bit.originPort & HEX_VALUE_00FF))) {
273         TELEPHONY_LOGE("write data error.");
274         return;
275     }
276 }
277 
EncodeHeaderReplyAddress(SmsWriteBuffer & buffer,const struct SmsUDH header)278 void GsmUserDataPdu::EncodeHeaderReplyAddress(SmsWriteBuffer &buffer, const struct SmsUDH header)
279 {
280     if (!buffer.WriteByte(UDH_ALTERNATE_REPLY_ADDRESS)) {
281         TELEPHONY_LOGE("write data error.");
282         return;
283     }
284 
285     std::string encodedAddr;
286     GsmSmsParamCodec codec;
287     if (!codec.EncodeAddressPdu(&(header.udh.alternateAddress), encodedAddr)) {
288         TELEPHONY_LOGE("EncodeHeader EncodeAddressPdu fail");
289         return;
290     }
291     uint8_t addrLen = encodedAddr.size();
292     if (!buffer.WriteByte(addrLen)) {
293         TELEPHONY_LOGE("write data error.");
294         return;
295     }
296     if (buffer.data_ == nullptr || (buffer.GetIndex() + addrLen) > buffer.GetSize()) {
297         TELEPHONY_LOGE("buffer data error.");
298         return;
299     }
300     if (memcpy_s(buffer.data_.get() + buffer.GetIndex(), addrLen, encodedAddr.data(), addrLen) != EOK) {
301         TELEPHONY_LOGE("EncodeHeader memcpy_s error");
302         return;
303     }
304 }
305 
EncodeHeaderConcat(SmsWriteBuffer & buffer,const struct SmsUDH header)306 void GsmUserDataPdu::EncodeHeaderConcat(SmsWriteBuffer &buffer, const struct SmsUDH header)
307 {
308     switch (header.udhType) {
309         case UDH_CONCAT_8BIT:
310             EncodeHeaderConcat8Bit(buffer, header);
311             break;
312         case UDH_CONCAT_16BIT:
313             EncodeHeaderConcat16Bit(buffer, header);
314             break;
315         case UDH_NONE:
316         default:
317             break;
318     }
319 }
320 
EncodeHeaderConcat8Bit(SmsWriteBuffer & buffer,const struct SmsUDH & header)321 void GsmUserDataPdu::EncodeHeaderConcat8Bit(SmsWriteBuffer &buffer, const struct SmsUDH &header)
322 {
323     if (!buffer.WriteByte(UDH_CONCAT_8BIT)) {
324         TELEPHONY_LOGE("write data error.");
325         return;
326     }
327     if (!buffer.WriteByte(HEX_VALUE_03)) {
328         TELEPHONY_LOGE("write data error.");
329         return;
330     }
331     if (!buffer.WriteByte(header.udh.concat8bit.msgRef)) {
332         TELEPHONY_LOGE("write data error.");
333         return;
334     }
335     if (!buffer.WriteByte(header.udh.concat8bit.totalSeg)) {
336         TELEPHONY_LOGE("write data error.");
337         return;
338     }
339     if (!buffer.WriteByte(header.udh.concat8bit.seqNum)) {
340         TELEPHONY_LOGE("write data error.");
341         return;
342     }
343 }
344 
EncodeHeaderConcat16Bit(SmsWriteBuffer & buffer,const struct SmsUDH & header)345 void GsmUserDataPdu::EncodeHeaderConcat16Bit(SmsWriteBuffer &buffer, const struct SmsUDH &header)
346 {
347     if (!buffer.WriteByte(UDH_CONCAT_16BIT)) {
348         TELEPHONY_LOGE("write data error.");
349         return;
350     }
351     if (!buffer.WriteByte(HEX_VALUE_04)) {
352         TELEPHONY_LOGE("write data error.");
353         return;
354     }
355     if (!buffer.WriteByte(static_cast<uint8_t>(header.udh.concat16bit.msgRef >> NORMAL_BYTE_BITS))) {
356         TELEPHONY_LOGE("write data error.");
357         return;
358     }
359     if (!buffer.WriteByte(header.udh.concat16bit.msgRef & HEX_VALUE_00FF)) {
360         TELEPHONY_LOGE("write data error.");
361         return;
362     }
363     if (!buffer.WriteByte(header.udh.concat16bit.totalSeg)) {
364         TELEPHONY_LOGE("write data error.");
365         return;
366     }
367     if (!buffer.WriteByte(header.udh.concat16bit.seqNum)) {
368         TELEPHONY_LOGE("write data error.");
369         return;
370     }
371 }
372 
DecodeHeader(SmsReadBuffer & buffer,struct SmsUDH & pHeader,uint16_t & headerLen)373 bool GsmUserDataPdu::DecodeHeader(SmsReadBuffer &buffer, struct SmsUDH &pHeader, uint16_t &headerLen)
374 {
375     headerLen = buffer.GetIndex();
376     uint8_t oneByte = 0;
377     if (!buffer.ReadByte(oneByte)) {
378         TELEPHONY_LOGE("get data error.");
379         return false;
380     }
381     pHeader.udhType = oneByte;
382     switch (pHeader.udhType) {
383         case UDH_CONCAT_8BIT:
384             if (!DecodeHeaderConcat8Bit(buffer, pHeader)) {
385                 TELEPHONY_LOGE("decode fail.");
386                 return false;
387             }
388             break;
389         case UDH_CONCAT_16BIT:
390             if (!DecodeHeaderConcat16Bit(buffer, pHeader)) {
391                 TELEPHONY_LOGE("decode fail.");
392                 return false;
393             }
394             break;
395         case UDH_APP_PORT_8BIT:
396             if (!DecodeHeaderAppPort8Bit(buffer, pHeader)) {
397                 TELEPHONY_LOGE("decode fail.");
398                 return false;
399             }
400             break;
401         case UDH_APP_PORT_16BIT:
402             if (!DecodeHeaderAppPort16Bit(buffer, pHeader)) {
403                 TELEPHONY_LOGE("decode fail.");
404                 return false;
405             }
406             break;
407         default: {
408             if (!DecodeHeaderPartData(buffer, pHeader, oneByte)) {
409                 TELEPHONY_LOGE("decode fail.");
410                 return false;
411             }
412         }
413     }
414     if (buffer.GetIndex() > headerLen) {
415         headerLen = buffer.GetIndex() - headerLen;
416     } else {
417         headerLen = 0;
418     }
419 
420     return true;
421 }
422 
DecodeHeaderPartData(SmsReadBuffer & buffer,struct SmsUDH & pHeader,uint8_t oneByte)423 bool GsmUserDataPdu::DecodeHeaderPartData(SmsReadBuffer &buffer, struct SmsUDH &pHeader, uint8_t oneByte)
424 {
425     pHeader.udhType = oneByte;
426     switch (pHeader.udhType) {
427         case UDH_SPECIAL_SMS:
428             if (!DecodeHeaderSpecialSms(buffer, pHeader)) {
429                 TELEPHONY_LOGE("decode fail.");
430                 return false;
431             }
432             break;
433         case UDH_ALTERNATE_REPLY_ADDRESS:
434             if (!DecodeHeaderReplyAddress(buffer, pHeader)) {
435                 TELEPHONY_LOGE("decode fail.");
436                 return false;
437             }
438             break;
439         case UDH_SINGLE_SHIFT:
440             if (!DecodeHeaderSingleShift(buffer, pHeader)) {
441                 TELEPHONY_LOGE("decode fail.");
442                 return false;
443             }
444             break;
445         case UDH_LOCKING_SHIFT:
446             if (!DecodeHeaderLockingShift(buffer, pHeader)) {
447                 TELEPHONY_LOGE("decode fail.");
448                 return false;
449             }
450             break;
451         default: {
452             if (!DecodeHeaderDefaultCase(buffer, pHeader)) {
453                 TELEPHONY_LOGE("decode fail.");
454                 return false;
455             }
456             break;
457         }
458     }
459     return true;
460 }
461 
DecodeHeaderConcat8Bit(SmsReadBuffer & buffer,struct SmsUDH & pHeader)462 bool GsmUserDataPdu::DecodeHeaderConcat8Bit(SmsReadBuffer &buffer, struct SmsUDH &pHeader)
463 {
464     uint8_t oneByte = 0;
465     if (!buffer.ReadByte(oneByte)) {
466         TELEPHONY_LOGE("get data error.");
467         return false;
468     }
469     if (oneByte == 0) {
470         return false;
471     }
472     if (!buffer.ReadByte(oneByte)) {
473         TELEPHONY_LOGE("get data error.");
474         return false;
475     }
476     pHeader.udh.concat8bit.msgRef = oneByte;
477 
478     if (!buffer.ReadByte(oneByte)) {
479         TELEPHONY_LOGE("get data error.");
480         return false;
481     }
482     pHeader.udh.concat8bit.totalSeg = oneByte;
483 
484     if (!buffer.ReadByte(oneByte)) {
485         TELEPHONY_LOGE("get data error.");
486         return false;
487     }
488     pHeader.udh.concat8bit.seqNum = oneByte;
489     DebugDecodeHeader(pHeader);
490     return true;
491 }
492 
DecodeHeaderConcat16Bit(SmsReadBuffer & buffer,struct SmsUDH & pHeader)493 bool GsmUserDataPdu::DecodeHeaderConcat16Bit(SmsReadBuffer &buffer, struct SmsUDH &pHeader)
494 {
495     uint8_t oneByte = 0;
496     if (!buffer.ReadByte(oneByte)) {
497         TELEPHONY_LOGE("get data error.");
498         return false;
499     }
500     if (oneByte == 0) {
501         return false;
502     }
503     if (!buffer.ReadByte(oneByte)) {
504         TELEPHONY_LOGE("get data error.");
505         return false;
506     }
507     pHeader.udh.concat16bit.msgRef = oneByte;
508 
509     if (!buffer.ReadByte(oneByte)) {
510         TELEPHONY_LOGE("get data error.");
511         return false;
512     }
513     oneByte |= pHeader.udh.concat16bit.msgRef << NORMAL_BYTE_BITS;
514     pHeader.udh.concat16bit.msgRef = static_cast<uint16_t>(oneByte);
515 
516     if (!buffer.ReadByte(oneByte)) {
517         TELEPHONY_LOGE("get data error.");
518         return false;
519     }
520     pHeader.udh.concat16bit.totalSeg = oneByte;
521 
522     if (!buffer.ReadByte(oneByte)) {
523         TELEPHONY_LOGE("get data error.");
524         return false;
525     }
526     pHeader.udh.concat16bit.seqNum = oneByte;
527     DebugDecodeHeader(pHeader);
528     return true;
529 }
530 
DecodeHeaderAppPort8Bit(SmsReadBuffer & buffer,struct SmsUDH & pHeader)531 bool GsmUserDataPdu::DecodeHeaderAppPort8Bit(SmsReadBuffer &buffer, struct SmsUDH &pHeader)
532 {
533     uint8_t oneByte = 0;
534     if (!buffer.ReadByte(oneByte)) {
535         TELEPHONY_LOGE("get data error.");
536         return false;
537     }
538     if (oneByte == 0) {
539         TELEPHONY_LOGE("oneByte 0.");
540         return false;
541     }
542 
543     if (!buffer.ReadByte(oneByte)) {
544         TELEPHONY_LOGE("get data error.");
545         return false;
546     }
547     pHeader.udh.appPort8bit.destPort = oneByte;
548 
549     if (!buffer.ReadByte(oneByte)) {
550         TELEPHONY_LOGE("get data error.");
551         return false;
552     }
553     pHeader.udh.appPort8bit.originPort = oneByte;
554     DebugDecodeHeader(pHeader);
555     return true;
556 }
557 
DecodeHeaderAppPort16Bit(SmsReadBuffer & buffer,struct SmsUDH & pHeader)558 bool GsmUserDataPdu::DecodeHeaderAppPort16Bit(SmsReadBuffer &buffer, struct SmsUDH &pHeader)
559 {
560     uint8_t oneByte = 0;
561     if (!buffer.ReadByte(oneByte)) {
562         TELEPHONY_LOGE("get data error.");
563         return false;
564     }
565 
566     if (oneByte == 0) {
567         TELEPHONY_LOGE("pickByte 0.");
568         return false;
569     }
570 
571     if (!buffer.ReadByte(oneByte)) {
572         TELEPHONY_LOGE("get data error.");
573         return false;
574     }
575     pHeader.udh.appPort16bit.destPort = oneByte;
576 
577     if (!buffer.ReadByte(oneByte)) {
578         TELEPHONY_LOGE("get data error.");
579         return false;
580     }
581     uint16_t port = oneByte;
582     port |= pHeader.udh.appPort16bit.destPort << NORMAL_BYTE_BITS;
583     pHeader.udh.appPort16bit.destPort = static_cast<uint16_t>(port);
584 
585     if (!buffer.ReadByte(oneByte)) {
586         TELEPHONY_LOGE("get data error.");
587         return false;
588     }
589     pHeader.udh.appPort16bit.originPort = oneByte;
590 
591     if (!buffer.ReadByte(oneByte)) {
592         TELEPHONY_LOGE("get data error.");
593         return false;
594     }
595 
596     port = oneByte;
597     port |= pHeader.udh.appPort16bit.originPort << NORMAL_BYTE_BITS;
598     pHeader.udh.appPort16bit.originPort = static_cast<uint16_t>(port);
599     DebugDecodeHeader(pHeader);
600     return true;
601 }
602 
DecodeHeaderSpecialSms(SmsReadBuffer & buffer,struct SmsUDH & pHeader)603 bool GsmUserDataPdu::DecodeHeaderSpecialSms(SmsReadBuffer &buffer, struct SmsUDH &pHeader)
604 {
605     uint8_t oneByte = 0;
606     if (!buffer.ReadByte(oneByte)) {
607         TELEPHONY_LOGE("get data error.");
608         return false;
609     }
610     if (oneByte != HEX_VALUE_02) {
611         return false;
612     }
613     TELEPHONY_LOGI("Decoding special sms udh.");
614     uint8_t pickByte = 0;
615     if (!buffer.PickOneByte(pickByte)) {
616         TELEPHONY_LOGE("get data error.");
617         return false;
618     }
619     pHeader.udh.specialInd.bStore = static_cast<bool>(pickByte & HEX_VALUE_80);
620 
621     if (!buffer.ReadByte(oneByte)) {
622         TELEPHONY_LOGE("get data error.");
623         return false;
624     }
625     pHeader.udh.specialInd.msgInd = static_cast<uint16_t>(oneByte & HEX_VALUE_7F);
626 
627     if (!buffer.PickOneByte(pickByte)) {
628         TELEPHONY_LOGE("get data error.");
629         return false;
630     }
631     pHeader.udh.specialInd.waitMsgNum = pickByte;
632     return true;
633 }
634 
DecodeHeaderReplyAddress(SmsReadBuffer & buffer,struct SmsUDH & pHeader)635 bool GsmUserDataPdu::DecodeHeaderReplyAddress(SmsReadBuffer &buffer, struct SmsUDH &pHeader)
636 {
637     uint8_t oneByte = 0;
638     if (!buffer.ReadByte(oneByte)) {
639         TELEPHONY_LOGE("get data error.");
640         return false;
641     }
642     if (oneByte == 0) {
643         return false;
644     }
645     GsmSmsParamCodec codec;
646     if (!codec.DecodeAddressPdu(buffer, &(pHeader.udh.alternateAddress))) {
647         return false;
648     }
649     TELEPHONY_LOGI("alternate reply address [%{private}s]", pHeader.udh.alternateAddress.address);
650     return true;
651 }
652 
DecodeHeaderSingleShift(SmsReadBuffer & buffer,struct SmsUDH & pHeader)653 bool GsmUserDataPdu::DecodeHeaderSingleShift(SmsReadBuffer &buffer, struct SmsUDH &pHeader)
654 {
655     uint8_t oneByte = 0;
656     if (!buffer.ReadByte(oneByte)) {
657         TELEPHONY_LOGE("get data error.");
658         return false;
659     }
660     if (oneByte == 0) {
661         return false;
662     }
663 
664     if (!buffer.ReadByte(oneByte)) {
665         TELEPHONY_LOGE("get data error.");
666         return false;
667     }
668     pHeader.udh.singleShift.langId = oneByte;
669     TELEPHONY_LOGI("singleShift.langId [%{public}02x]", pHeader.udh.singleShift.langId);
670     return true;
671 }
672 
DecodeHeaderLockingShift(SmsReadBuffer & buffer,struct SmsUDH & pHeader)673 bool GsmUserDataPdu::DecodeHeaderLockingShift(SmsReadBuffer &buffer, struct SmsUDH &pHeader)
674 {
675     uint8_t oneByte = 0;
676     if (!buffer.ReadByte(oneByte)) {
677         TELEPHONY_LOGE("get data error.");
678         return false;
679     }
680     if (oneByte == 0) {
681         return false;
682     }
683     if (!buffer.ReadByte(oneByte)) {
684         TELEPHONY_LOGE("get data error.");
685         return false;
686     }
687     pHeader.udh.lockingShift.langId = oneByte;
688     TELEPHONY_LOGI("lockingShift.langId [%{public}02x]", pHeader.udh.lockingShift.langId);
689     return true;
690 }
691 
DecodeHeaderDefaultCase(SmsReadBuffer & buffer,struct SmsUDH & pHeader)692 bool GsmUserDataPdu::DecodeHeaderDefaultCase(SmsReadBuffer &buffer, struct SmsUDH &pHeader)
693 {
694     uint8_t oneByte = 0;
695     TELEPHONY_LOGI("Not Supported Header Type [%{public}02x]", pHeader.udhType);
696     if (!buffer.ReadByte(oneByte)) {
697         TELEPHONY_LOGE("get data error.");
698         return false;
699     }
700     TELEPHONY_LOGI("IEDL [%{public}u]", oneByte);
701     buffer.MoveForward(oneByte);
702     return true;
703 }
704 
DebugDecodeHeader(const struct SmsUDH & pHeader)705 void GsmUserDataPdu::DebugDecodeHeader(const struct SmsUDH &pHeader)
706 {
707     switch (pHeader.udhType) {
708         case UDH_CONCAT_8BIT: {
709             TELEPHONY_LOGI("concat8bit.seqNum [%{public}02x]", pHeader.udh.concat8bit.seqNum);
710             break;
711         }
712         case UDH_CONCAT_16BIT: {
713             TELEPHONY_LOGI("concat16bit.seqNum [%{public}02x]", pHeader.udh.concat16bit.seqNum);
714             break;
715         }
716         case UDH_APP_PORT_8BIT: {
717             TELEPHONY_LOGI("appPort8bit.destPort [%{public}02x]", pHeader.udh.appPort8bit.destPort);
718             TELEPHONY_LOGI("appPort8bit.originPort [%{public}02x]", pHeader.udh.appPort8bit.originPort);
719             break;
720         }
721         case UDH_APP_PORT_16BIT: {
722             TELEPHONY_LOGI("appPort16bit.destPort [%{public}04x]", pHeader.udh.appPort16bit.destPort);
723             TELEPHONY_LOGI("appPort16bit.originPort [%{public}04x]", pHeader.udh.appPort16bit.originPort);
724             break;
725         }
726         case UDH_SPECIAL_SMS: {
727             TELEPHONY_LOGI("Decoding special sms udh.");
728             break;
729         }
730         case UDH_ALTERNATE_REPLY_ADDRESS:
731             break;
732         case UDH_SINGLE_SHIFT: {
733             TELEPHONY_LOGI("singleShift.langId [%{public}02x]", pHeader.udh.singleShift.langId);
734             break;
735         }
736         case UDH_LOCKING_SHIFT: {
737             TELEPHONY_LOGI("lockingShift.langId [%{public}02x]", pHeader.udh.lockingShift.langId);
738             break;
739         }
740         default:
741             break;
742     }
743 }
744 } // namespace Telephony
745 } // namespace OHOS