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 
25 using namespace OHOS::Telephony;
26 namespace OHOS {
27 static constexpr uint16_t PDU_BUFFER_MAX_SIZE = 0xFF;
28 bool g_flag = false;
29 
TeleserviceIdDecode(const uint8_t * data,size_t size)30 void 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 
ServiceCategoryDecode(const uint8_t * data,size_t size)52 void 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 
BearerReplyDecode(const uint8_t * data,size_t size)74 void 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 
CauseCodesDecode(const uint8_t * data,size_t size)96 void 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 
AddressParameterDecode(const uint8_t * data,size_t size)118 void 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 
SubaddressDecode(const uint8_t * data,size_t size)140 void 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 
BearerDataDecode(const uint8_t * data,size_t size)162 void 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 
BaseParameterDecode(const uint8_t * data,size_t size)200 void 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 
ReservedParameterDecode(const uint8_t * data,size_t size)222 void 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 
MessageIdDecode(const uint8_t * data,size_t size)243 void 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 
AbsoluteTimeDecode(const uint8_t * data,size_t size)265 void 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 
PriorityIndDecode(const uint8_t * data,size_t size)287 void 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 
PrivacyIndDecode(const uint8_t * data,size_t size)309 void 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 
ReplyOptionDecode(const uint8_t * data,size_t size)331 void 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 
UserDataDecode(const uint8_t * data,size_t size)353 void 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 
CmasDataDecode(const uint8_t * data,size_t size)376 void 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 
AlertPriorityDecode(const uint8_t * data,size_t size)398 void 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 }
LanguageIndDecode(const uint8_t * data,size_t size)419 void 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 }
CallbackNumberDecode(const uint8_t * data,size_t size)440 void 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 }
DepositIndexDecode(const uint8_t * data,size_t size)461 void 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 }
DisplayModeDecode(const uint8_t * data,size_t size)482 void 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 }
MessageStatusDecode(const uint8_t * data,size_t size)503 void 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 }
NumberMessagesDecode(const uint8_t * data,size_t size)524 void 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 }
EnhancedVmnDecode(const uint8_t * data,size_t size)545 void 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 }
EnhancedVmnAckDecode(const uint8_t * data,size_t size)566 void 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 
TransportMessageDecode(const uint8_t * data,size_t size)588 void 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 
ParameterRecordDecode(const uint8_t * data,size_t size)639 void 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 
SubParameterDecode(const uint8_t * data,size_t size)650 void 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 
DoSomethingInterestingWithMyAPI(const uint8_t * data,size_t size)672 void 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 */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)691 extern "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