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 "cdmasmsdecode_fuzzer.h"
17
18#include <sstream>
19
20#include "addsmstoken_fuzzer.h"
21#include "cdma_sms_sub_parameter.h"
22#include "cdma_sms_transport_message.h"
23#include "securec.h"
24
25using namespace OHOS::Telephony;
26namespace OHOS {
27static constexpr uint16_t PDU_BUFFER_MAX_SIZE = 0xFF;
28bool g_flag = false;
29
30void TeleserviceIdDecode(const uint8_t *data, size_t size)
31{
32    uint16_t value;
33    auto parameter = std::make_unique<CdmaSmsTeleserviceId>(value);
34    if (parameter == nullptr) {
35        return;
36    }
37
38    std::string strValue(reinterpret_cast<const char *>(data), size);
39    SmsReadBuffer pdu(strValue);
40    parameter->Decode(pdu);
41
42    std::stringstream ss1;
43    ss1 << static_cast<uint8_t>(CdmaSmsParameterRecord::TELESERVICE_ID);
44    ss1 << static_cast<uint8_t>(size);
45    for (uint8_t i = 0; i < size; i++) {
46        ss1 << data[i];
47    }
48    SmsReadBuffer rBuffer1(ss1.str());
49    parameter->Decode(rBuffer1);
50}
51
52void ServiceCategoryDecode(const uint8_t *data, size_t size)
53{
54    uint16_t value;
55    auto parameter = std::make_unique<CdmaSmsServiceCategory>(value);
56    if (parameter == nullptr) {
57        return;
58    }
59
60    std::string strValue(reinterpret_cast<const char *>(data), size);
61    SmsReadBuffer pdu(strValue);
62    parameter->Decode(pdu);
63
64    std::stringstream ss1;
65    ss1 << static_cast<uint8_t>(CdmaSmsParameterRecord::SERVICE_CATEGORY);
66    ss1 << static_cast<uint8_t>(size);
67    for (uint8_t i = 0; i < size; i++) {
68        ss1 << data[i];
69    }
70    SmsReadBuffer rBuffer1(ss1.str());
71    parameter->Decode(rBuffer1);
72}
73
74void BearerReplyDecode(const uint8_t *data, size_t size)
75{
76    uint8_t value;
77    auto parameter = std::make_unique<CdmaSmsBearerReply>(value);
78    if (parameter == nullptr) {
79        return;
80    }
81
82    std::string strValue(reinterpret_cast<const char *>(data), size);
83    SmsReadBuffer pdu(strValue);
84    parameter->Decode(pdu);
85
86    std::stringstream ss1;
87    ss1 << static_cast<uint8_t>(CdmaSmsParameterRecord::BEARER_REPLY_OPTION);
88    ss1 << static_cast<uint8_t>(size);
89    for (uint8_t i = 0; i < size; i++) {
90        ss1 << data[i];
91    }
92    SmsReadBuffer rBuffer1(ss1.str());
93    parameter->Decode(rBuffer1);
94}
95
96void CauseCodesDecode(const uint8_t *data, size_t size)
97{
98    TransportCauseCode value;
99    auto parameter = std::make_unique<CdmaSmsCauseCodes>(value);
100    if (parameter == nullptr) {
101        return;
102    }
103
104    std::string strValue(reinterpret_cast<const char *>(data), size);
105    SmsReadBuffer pdu(strValue);
106    parameter->Decode(pdu);
107
108    std::stringstream ss1;
109    ss1 << static_cast<uint8_t>(CdmaSmsParameterRecord::CAUSE_CODES);
110    ss1 << static_cast<uint8_t>(size);
111    for (uint8_t i = 0; i < size; i++) {
112        ss1 << data[i];
113    }
114    SmsReadBuffer rBuffer1(ss1.str());
115    parameter->Decode(rBuffer1);
116}
117
118void AddressParameterDecode(const uint8_t *data, size_t size)
119{
120    TransportAddr value;
121    auto parameter = std::make_unique<CdmaSmsAddressParameter>(value, CdmaSmsParameterRecord::ORG_ADDRESS);
122    if (parameter == nullptr) {
123        return;
124    }
125
126    std::string strValue(reinterpret_cast<const char *>(data), size);
127    SmsReadBuffer pdu(strValue);
128    parameter->Decode(pdu);
129
130    std::stringstream ss1;
131    ss1 << static_cast<uint8_t>(CdmaSmsParameterRecord::ORG_ADDRESS);
132    ss1 << static_cast<uint8_t>(size);
133    for (uint8_t i = 0; i < size; i++) {
134        ss1 << data[i];
135    }
136    SmsReadBuffer rBuffer1(ss1.str());
137    parameter->Decode(rBuffer1);
138}
139
140void SubaddressDecode(const uint8_t *data, size_t size)
141{
142    TransportSubAddr value;
143    auto parameter = std::make_unique<CdmaSmsSubaddress>(value, CdmaSmsParameterRecord::ORG_SUB_ADDRESS);
144    if (parameter == nullptr) {
145        return;
146    }
147
148    std::string strValue(reinterpret_cast<const char *>(data), size);
149    SmsReadBuffer pdu(strValue);
150    parameter->Decode(pdu);
151
152    std::stringstream ss1;
153    ss1 << static_cast<uint8_t>(CdmaSmsParameterRecord::ORG_SUB_ADDRESS);
154    ss1 << static_cast<uint8_t>(size);
155    for (uint8_t i = 0; i < size; i++) {
156        ss1 << data[i];
157    }
158    SmsReadBuffer rBuffer1(ss1.str());
159    parameter->Decode(rBuffer1);
160}
161
162void BearerDataDecode(const uint8_t *data, size_t size)
163{
164    std::string strValue(reinterpret_cast<const char *>(data), size);
165    SmsReadBuffer pdu(strValue);
166    pdu.MoveForward();
167    pdu.MoveForward();
168    CdmaTeleserviceMsg value;
169    auto parameter = std::make_unique<CdmaSmsBearerData>(value, pdu);
170    if (parameter == nullptr) {
171        return;
172    }
173    pdu.SetIndex(0);
174    parameter->Decode(pdu);
175
176    std::stringstream ss1;
177    ss1 << static_cast<uint8_t>(CdmaSmsParameterRecord::BEARER_DATA);
178    ss1 << static_cast<uint8_t>(size);
179    for (uint8_t i = 0; i < size; i++) {
180        ss1 << data[i];
181    }
182    SmsReadBuffer rBuffer1(ss1.str());
183    rBuffer1.MoveForward();
184    rBuffer1.MoveForward();
185    auto parameter1 = std::make_unique<CdmaSmsBearerData>(value, rBuffer1);
186    rBuffer1.SetIndex(0);
187    parameter1->Decode(rBuffer1);
188
189    rBuffer1.SetIndex(0);
190    rBuffer1.MoveForward();
191    rBuffer1.MoveForward();
192    auto parameter2 = std::make_unique<CdmaSmsBearerData>(value, rBuffer1, true);
193    if (parameter2 == nullptr) {
194        return;
195    }
196    rBuffer1.SetIndex(0);
197    parameter2->Decode(rBuffer1);
198}
199
200void BaseParameterDecode(const uint8_t *data, size_t size)
201{
202    uint8_t value;
203    auto parameter = std::make_unique<CdmaSmsBaseParameter>(CdmaSmsSubParameter::MESSAGE_IDENTIFIER, value);
204    if (parameter == nullptr) {
205        return;
206    }
207
208    std::string strValue(reinterpret_cast<const char *>(data), size);
209    SmsReadBuffer pdu(strValue);
210    parameter->Decode(pdu);
211
212    std::stringstream ss1;
213    ss1 << static_cast<uint8_t>(CdmaSmsSubParameter::MESSAGE_IDENTIFIER);
214    ss1 << static_cast<uint8_t>(size);
215    for (uint8_t i = 0; i < size; i++) {
216        ss1 << data[i];
217    }
218    SmsReadBuffer rBuffer1(ss1.str());
219    parameter->Decode(rBuffer1);
220}
221
222void ReservedParameterDecode(const uint8_t *data, size_t size)
223{
224    auto parameter = std::make_unique<CdmaSmsReservedParameter>(CdmaSmsSubParameter::MESSAGE_IDENTIFIER);
225    if (parameter == nullptr) {
226        return;
227    }
228
229    std::string strValue(reinterpret_cast<const char *>(data), size);
230    SmsReadBuffer pdu(strValue);
231    parameter->Decode(pdu);
232
233    std::stringstream ss1;
234    ss1 << static_cast<uint8_t>(CdmaSmsSubParameter::MESSAGE_IDENTIFIER);
235    ss1 << static_cast<uint8_t>(size);
236    for (uint8_t i = 0; i < size; i++) {
237        ss1 << data[i];
238    }
239    SmsReadBuffer rBuffer1(ss1.str());
240    parameter->Decode(rBuffer1);
241}
242
243void MessageIdDecode(const uint8_t *data, size_t size)
244{
245    SmsTeleSvcMsgId value;
246    auto parameter = std::make_unique<CdmaSmsMessageId>(value, CdmaSmsTeleserviceMessage::DELIVER);
247    if (parameter == nullptr) {
248        return;
249    }
250
251    std::string strValue(reinterpret_cast<const char *>(data), size);
252    SmsReadBuffer pdu(strValue);
253    parameter->Decode(pdu);
254
255    std::stringstream ss1;
256    ss1 << static_cast<uint8_t>(CdmaSmsSubParameter::MESSAGE_IDENTIFIER);
257    ss1 << static_cast<uint8_t>(size);
258    for (uint8_t i = 0; i < size; i++) {
259        ss1 << data[i];
260    }
261    SmsReadBuffer rBuffer1(ss1.str());
262    parameter->Decode(rBuffer1);
263}
264
265void AbsoluteTimeDecode(const uint8_t *data, size_t size)
266{
267    SmsTimeAbs value;
268    auto parameter = std::make_unique<CdmaSmsAbsoluteTime>(CdmaSmsSubParameter::VALIDITY_PERIOD_ABSOLUTE, value);
269    if (parameter == nullptr) {
270        return;
271    }
272
273    std::string strValue(reinterpret_cast<const char *>(data), size);
274    SmsReadBuffer pdu(strValue);
275    parameter->Decode(pdu);
276
277    std::stringstream ss1;
278    ss1 << static_cast<uint8_t>(CdmaSmsSubParameter::VALIDITY_PERIOD_ABSOLUTE);
279    ss1 << static_cast<uint8_t>(size);
280    for (uint8_t i = 0; i < size; i++) {
281        ss1 << data[i];
282    }
283    SmsReadBuffer rBuffer1(ss1.str());
284    parameter->Decode(rBuffer1);
285}
286
287void PriorityIndDecode(const uint8_t *data, size_t size)
288{
289    SmsPriorityIndicator value;
290    auto parameter = std::make_unique<CdmaSmsPriorityInd>(value);
291    if (parameter == nullptr) {
292        return;
293    }
294
295    std::string strValue(reinterpret_cast<const char *>(data), size);
296    SmsReadBuffer pdu(strValue);
297    parameter->Decode(pdu);
298
299    std::stringstream ss1;
300    ss1 << static_cast<uint8_t>(CdmaSmsSubParameter::PRIORITY_INDICATOR);
301    ss1 << static_cast<uint8_t>(size);
302    for (uint8_t i = 0; i < size; i++) {
303        ss1 << data[i];
304    }
305    SmsReadBuffer rBuffer1(ss1.str());
306    parameter->Decode(rBuffer1);
307}
308
309void PrivacyIndDecode(const uint8_t *data, size_t size)
310{
311    SmsPrivacyIndicator value;
312    auto parameter = std::make_unique<CdmaSmsPrivacyInd>(value);
313    if (parameter == nullptr) {
314        return;
315    }
316
317    std::string strValue(reinterpret_cast<const char *>(data), size);
318    SmsReadBuffer pdu(strValue);
319    parameter->Decode(pdu);
320
321    std::stringstream ss1;
322    ss1 << static_cast<uint8_t>(CdmaSmsSubParameter::PRIVACY_INDICATOR);
323    ss1 << static_cast<uint8_t>(size);
324    for (uint8_t i = 0; i < size; i++) {
325        ss1 << data[i];
326    }
327    SmsReadBuffer rBuffer1(ss1.str());
328    parameter->Decode(rBuffer1);
329}
330
331void ReplyOptionDecode(const uint8_t *data, size_t size)
332{
333    SmsReplyOption value;
334    auto parameter = std::make_unique<CdmaSmsReplyOption>(value);
335    if (parameter == nullptr) {
336        return;
337    }
338
339    std::string strValue(reinterpret_cast<const char *>(data), size);
340    SmsReadBuffer pdu(strValue);
341    parameter->Decode(pdu);
342
343    std::stringstream ss1;
344    ss1 << static_cast<uint8_t>(CdmaSmsSubParameter::REPLY_OPTION);
345    ss1 << static_cast<uint8_t>(size);
346    for (uint8_t i = 0; i < size; i++) {
347        ss1 << data[i];
348    }
349    SmsReadBuffer rBuffer1(ss1.str());
350    parameter->Decode(rBuffer1);
351}
352
353void UserDataDecode(const uint8_t *data, size_t size)
354{
355    SmsTeleSvcUserData value;
356    bool headerInd = false;
357    auto parameter = std::make_unique<CdmaSmsUserData>(value, headerInd);
358    if (parameter == nullptr) {
359        return;
360    }
361
362    std::string strValue(reinterpret_cast<const char *>(data), size);
363    SmsReadBuffer pdu(strValue);
364    parameter->Decode(pdu);
365
366    std::stringstream ss1;
367    ss1 << static_cast<uint8_t>(CdmaSmsSubParameter::USER_DATA);
368    ss1 << static_cast<uint8_t>(size);
369    for (uint8_t i = 0; i < size; i++) {
370        ss1 << data[i];
371    }
372    SmsReadBuffer rBuffer1(ss1.str());
373    parameter->Decode(rBuffer1);
374}
375
376void CmasDataDecode(const uint8_t *data, size_t size)
377{
378    SmsTeleSvcCmasData value;
379    auto parameter = std::make_unique<CdmaSmsCmasData>(value);
380    if (parameter == nullptr) {
381        return;
382    }
383
384    std::string strValue(reinterpret_cast<const char *>(data), size);
385    SmsReadBuffer pdu(strValue);
386    parameter->Decode(pdu);
387
388    std::stringstream ss1;
389    ss1 << static_cast<uint8_t>(CdmaSmsSubParameter::USER_DATA);
390    ss1 << static_cast<uint8_t>(size);
391    for (uint8_t i = 0; i < size; i++) {
392        ss1 << data[i];
393    }
394    SmsReadBuffer rBuffer1(ss1.str());
395    parameter->Decode(rBuffer1);
396}
397
398void AlertPriorityDecode(const uint8_t *data, size_t size)
399{
400    SmsAlertPriority value;
401    auto parameter = std::make_unique<CdmaSmsAlertPriority>(value);
402    if (parameter == nullptr) {
403        return;
404    }
405
406    std::string strValue(reinterpret_cast<const char *>(data), size);
407    SmsReadBuffer pdu(strValue);
408    parameter->Decode(pdu);
409
410    std::stringstream ss1;
411    ss1 << static_cast<uint8_t>(CdmaSmsSubParameter::ALERT_ON_MSG_DELIVERY);
412    ss1 << static_cast<uint8_t>(size);
413    for (uint8_t i = 0; i < size; i++) {
414        ss1 << data[i];
415    }
416    SmsReadBuffer rBuffer1(ss1.str());
417    parameter->Decode(rBuffer1);
418}
419void LanguageIndDecode(const uint8_t *data, size_t size)
420{
421    SmsLanguageType value;
422    auto parameter = std::make_unique<CdmaSmsLanguageInd>(value);
423    if (parameter == nullptr) {
424        return;
425    }
426
427    std::string strValue(reinterpret_cast<const char *>(data), size);
428    SmsReadBuffer pdu(strValue);
429    parameter->Decode(pdu);
430
431    std::stringstream ss1;
432    ss1 << static_cast<uint8_t>(CdmaSmsSubParameter::LANGUAGE_INDICATOR);
433    ss1 << static_cast<uint8_t>(size);
434    for (uint8_t i = 0; i < size; i++) {
435        ss1 << data[i];
436    }
437    SmsReadBuffer rBuffer1(ss1.str());
438    parameter->Decode(rBuffer1);
439}
440void CallbackNumberDecode(const uint8_t *data, size_t size)
441{
442    SmsTeleSvcAddr value;
443    auto parameter = std::make_unique<CdmaSmsCallbackNumber>(value);
444    if (parameter == nullptr) {
445        return;
446    }
447
448    std::string strValue(reinterpret_cast<const char *>(data), size);
449    SmsReadBuffer pdu(strValue);
450    parameter->Decode(pdu);
451
452    std::stringstream ss1;
453    ss1 << static_cast<uint8_t>(CdmaSmsSubParameter::CALLBACK_NUMBER);
454    ss1 << static_cast<uint8_t>(size);
455    for (uint8_t i = 0; i < size; i++) {
456        ss1 << data[i];
457    }
458    SmsReadBuffer rBuffer1(ss1.str());
459    parameter->Decode(rBuffer1);
460}
461void DepositIndexDecode(const uint8_t *data, size_t size)
462{
463    uint16_t value;
464    auto parameter = std::make_unique<CdmaSmsDepositIndex>(value);
465    if (parameter == nullptr) {
466        return;
467    }
468
469    std::string strValue(reinterpret_cast<const char *>(data), size);
470    SmsReadBuffer pdu(strValue);
471    parameter->Decode(pdu);
472
473    std::stringstream ss1;
474    ss1 << static_cast<uint8_t>(CdmaSmsSubParameter::MESSAGE_DEPOSIT_INDEX);
475    ss1 << static_cast<uint8_t>(size);
476    for (uint8_t i = 0; i < size; i++) {
477        ss1 << data[i];
478    }
479    SmsReadBuffer rBuffer1(ss1.str());
480    parameter->Decode(rBuffer1);
481}
482void DisplayModeDecode(const uint8_t *data, size_t size)
483{
484    SmsDisplayMode value;
485    auto parameter = std::make_unique<CdmaSmsDisplayMode>(value);
486    if (parameter == nullptr) {
487        return;
488    }
489
490    std::string strValue(reinterpret_cast<const char *>(data), size);
491    SmsReadBuffer pdu(strValue);
492    parameter->Decode(pdu);
493
494    std::stringstream ss1;
495    ss1 << static_cast<uint8_t>(CdmaSmsSubParameter::MESSAGE_DISPLAY_MODE);
496    ss1 << static_cast<uint8_t>(size);
497    for (uint8_t i = 0; i < size; i++) {
498        ss1 << data[i];
499    }
500    SmsReadBuffer rBuffer1(ss1.str());
501    parameter->Decode(rBuffer1);
502}
503void MessageStatusDecode(const uint8_t *data, size_t size)
504{
505    SmsStatusCode value;
506    auto parameter = std::make_unique<CdmaSmsMessageStatus>(value);
507    if (parameter == nullptr) {
508        return;
509    }
510
511    std::string strValue(reinterpret_cast<const char *>(data), size);
512    SmsReadBuffer pdu(strValue);
513    parameter->Decode(pdu);
514
515    std::stringstream ss1;
516    ss1 << static_cast<uint8_t>(CdmaSmsSubParameter::MESSAGE_STATUS);
517    ss1 << static_cast<uint8_t>(size);
518    for (uint8_t i = 0; i < size; i++) {
519        ss1 << data[i];
520    }
521    SmsReadBuffer rBuffer1(ss1.str());
522    parameter->Decode(rBuffer1);
523}
524void NumberMessagesDecode(const uint8_t *data, size_t size)
525{
526    uint32_t value;
527    auto parameter = std::make_unique<CdmaSmsNumberMessages>(value);
528    if (parameter == nullptr) {
529        return;
530    }
531
532    std::string strValue(reinterpret_cast<const char *>(data), size);
533    SmsReadBuffer pdu(strValue);
534    parameter->Decode(pdu);
535
536    std::stringstream ss1;
537    ss1 << static_cast<uint8_t>(CdmaSmsSubParameter::NUMBER_OF_MESSAGES);
538    ss1 << static_cast<uint8_t>(size);
539    for (uint8_t i = 0; i < size; i++) {
540        ss1 << data[i];
541    }
542    SmsReadBuffer rBuffer1(ss1.str());
543    parameter->Decode(rBuffer1);
544}
545void EnhancedVmnDecode(const uint8_t *data, size_t size)
546{
547    SmsEnhancedVmn value;
548    auto parameter = std::make_unique<CdmaSmsEnhancedVmn>(value);
549    if (parameter == nullptr) {
550        return;
551    }
552
553    std::string strValue(reinterpret_cast<const char *>(data), size);
554    SmsReadBuffer pdu(strValue);
555    parameter->Decode(pdu);
556
557    std::stringstream ss1;
558    ss1 << static_cast<uint8_t>(CdmaSmsSubParameter::ENHANCED_VMN);
559    ss1 << static_cast<uint8_t>(size);
560    for (uint8_t i = 0; i < size; i++) {
561        ss1 << data[i];
562    }
563    SmsReadBuffer rBuffer1(ss1.str());
564    parameter->Decode(rBuffer1);
565}
566void EnhancedVmnAckDecode(const uint8_t *data, size_t size)
567{
568    SmsEnhancedVmnAck value;
569    auto parameter = std::make_unique<CdmaSmsEnhancedVmnAck>(value);
570    if (parameter == nullptr) {
571        return;
572    }
573
574    std::string strValue(reinterpret_cast<const char *>(data), size);
575    SmsReadBuffer pdu(strValue);
576    parameter->Decode(pdu);
577
578    std::stringstream ss1;
579    ss1 << static_cast<uint8_t>(CdmaSmsSubParameter::ENHANCED_VMN_ACK);
580    ss1 << static_cast<uint8_t>(size);
581    for (uint8_t i = 0; i < size; i++) {
582        ss1 << data[i];
583    }
584    SmsReadBuffer rBuffer1(ss1.str());
585    parameter->Decode(rBuffer1);
586}
587
588void TransportMessageDecode(const uint8_t *data, size_t size)
589{
590    std::string strValue(reinterpret_cast<const char *>(data), size);
591    SmsReadBuffer pdu(strValue);
592    CdmaTransportMsg msg;
593    auto message = CdmaSmsTransportMessage::CreateTransportMessage(msg, pdu);
594    if (message == nullptr) {
595        return;
596    }
597    message->Decode(pdu);
598
599    std::stringstream ss1;
600    ss1 << static_cast<uint8_t>(CdmaTransportMsgType::P2P);
601    for (uint8_t i = 0; i < size; i++) {
602        ss1 << data[i];
603    }
604    SmsReadBuffer rBuffer1(ss1.str());
605    memset_s(&msg, sizeof(msg), 0, sizeof(msg));
606    auto message1 = CdmaSmsTransportMessage::CreateTransportMessage(msg, rBuffer1);
607    if (message1 == nullptr) {
608        return;
609    }
610    message1->Decode(rBuffer1);
611
612    std::stringstream ss2;
613    ss2 << static_cast<uint8_t>(CdmaTransportMsgType::BROADCAST);
614    for (uint8_t i = 0; i < size; i++) {
615        ss2 << data[i];
616    }
617    SmsReadBuffer rBuffer2(ss2.str());
618    memset_s(&msg, sizeof(msg), 0, sizeof(msg));
619    auto message2 = CdmaSmsTransportMessage::CreateTransportMessage(msg, rBuffer2);
620    if (message2 == nullptr) {
621        return;
622    }
623    message2->Decode(rBuffer2);
624
625    std::stringstream ss3;
626    ss3 << static_cast<uint8_t>(CdmaTransportMsgType::ACK);
627    for (uint8_t i = 0; i < size; i++) {
628        ss3 << data[i];
629    }
630    SmsReadBuffer rBuffer3(ss3.str());
631    memset_s(&msg, sizeof(msg), 0, sizeof(msg));
632    auto message3 = CdmaSmsTransportMessage::CreateTransportMessage(msg, rBuffer3);
633    if (message3 == nullptr) {
634        return;
635    }
636    message3->Decode(rBuffer3);
637}
638
639void ParameterRecordDecode(const uint8_t *data, size_t size)
640{
641    TeleserviceIdDecode(data, size);
642    ServiceCategoryDecode(data, size);
643    BearerReplyDecode(data, size);
644    CauseCodesDecode(data, size);
645    AddressParameterDecode(data, size);
646    SubaddressDecode(data, size);
647    BearerDataDecode(data, size);
648}
649
650void SubParameterDecode(const uint8_t *data, size_t size)
651{
652    BaseParameterDecode(data, size);
653    ReservedParameterDecode(data, size);
654    MessageIdDecode(data, size);
655    AbsoluteTimeDecode(data, size);
656    PriorityIndDecode(data, size);
657    PrivacyIndDecode(data, size);
658    ReplyOptionDecode(data, size);
659    UserDataDecode(data, size);
660    CmasDataDecode(data, size);
661    AlertPriorityDecode(data, size);
662    LanguageIndDecode(data, size);
663    CallbackNumberDecode(data, size);
664    DepositIndexDecode(data, size);
665    DisplayModeDecode(data, size);
666    MessageStatusDecode(data, size);
667    NumberMessagesDecode(data, size);
668    EnhancedVmnDecode(data, size);
669    EnhancedVmnAckDecode(data, size);
670}
671
672void DoSomethingInterestingWithMyAPI(const uint8_t *data, size_t size)
673{
674    if (data == nullptr || size == 0 || size > PDU_BUFFER_MAX_SIZE) {
675        return;
676    }
677
678    if (g_flag) {
679        return;
680    }
681    g_flag = true;
682
683    TransportMessageDecode(data, size);
684    ParameterRecordDecode(data, size);
685    SubParameterDecode(data, size);
686}
687
688} // namespace OHOS
689
690/* Fuzzer entry point */
691extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
692{
693    /* Run your code on data */
694    OHOS::AddSmsTokenFuzzer token;
695    OHOS::DoSomethingInterestingWithMyAPI(data, size);
696    return 0;
697}
698