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