1 /*
2 * Copyright (c) 2024 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 #ifndef FUZZ_DATA_GENERATOR_H
17 #define FUZZ_DATA_GENERATOR_H
18
19 #include <cstdint>
20 #include <string>
21 #include <vector>
22
23 #include "parcel.h"
24
25 class DataGenerator {
26 public:
Write(const uint8_t * data,size_t size)27 static void Write(const uint8_t *data, size_t size)
28 {
29 DataGenerator::parcel_.WriteBuffer(data, size);
30 DataGenerator::parcel_.RewindRead(0);
31 }
32
Clear()33 static void Clear()
34 {
35 DataGenerator::parcel_.FlushBuffer();
36 }
37
GetInstance()38 static OHOS::Parcel &GetInstance()
39 {
40 return DataGenerator::parcel_;
41 }
42
43 private:
44 static inline OHOS::Parcel parcel_;
45 };
46
47 template <typename T>
GenerateFromList(T & value,const std::vector<T> & candidateValues)48 inline bool GenerateFromList(T &value, const std::vector<T> &candidateValues)
49 {
50 if (candidateValues.empty()) {
51 return false;
52 }
53 uint8_t rawData = 0;
54 if (!DataGenerator::GetInstance().ReadUint8(rawData)) {
55 return false;
56 }
57 value = candidateValues[rawData % candidateValues.size()];
58 return true;
59 }
60
GenerateBool(bool & value)61 inline bool GenerateBool(bool &value)
62 {
63 return DataGenerator::GetInstance().ReadBool(value);
64 }
65
GenerateInt8(int8_t & value)66 inline bool GenerateInt8(int8_t &value)
67 {
68 return DataGenerator::GetInstance().ReadInt8(value);
69 }
70
GenerateInt16(int16_t & value)71 inline bool GenerateInt16(int16_t &value)
72 {
73 return DataGenerator::GetInstance().ReadInt16(value);
74 }
75
GenerateInt32(int32_t & value)76 inline bool GenerateInt32(int32_t &value)
77 {
78 return DataGenerator::GetInstance().ReadInt32(value);
79 }
80
GenerateInt64(int64_t & value)81 inline bool GenerateInt64(int64_t &value)
82 {
83 return DataGenerator::GetInstance().ReadInt64(value);
84 }
85
GenerateUint8(uint8_t & value)86 inline bool GenerateUint8(uint8_t &value)
87 {
88 return DataGenerator::GetInstance().ReadUint8(value);
89 }
90
GenerateUint16(uint16_t & value)91 inline bool GenerateUint16(uint16_t &value)
92 {
93 return DataGenerator::GetInstance().ReadUint16(value);
94 }
95
GenerateUint32(uint32_t & value)96 inline bool GenerateUint32(uint32_t &value)
97 {
98 return DataGenerator::GetInstance().ReadUint32(value);
99 }
100
GenerateUint64(uint64_t & value)101 inline bool GenerateUint64(uint64_t &value)
102 {
103 return DataGenerator::GetInstance().ReadUint64(value);
104 }
105
GenerateFloat(float & value)106 inline bool GenerateFloat(float &value)
107 {
108 return DataGenerator::GetInstance().ReadFloat(value);
109 }
110
GenerateDouble(double & value)111 inline bool GenerateDouble(double &value)
112 {
113 return DataGenerator::GetInstance().ReadDouble(value);
114 }
115
GenerateString(std::string & value)116 inline bool GenerateString(std::string &value)
117 {
118 return DataGenerator::GetInstance().ReadString(value);
119 }
120
121 inline bool GeneratePayload(std::vector<uint8_t> &payload, const std::vector<uint8_t> &prefix = {})
122 {
123 uint8_t len = 0;
124 if (!DataGenerator::GetInstance().ReadUint8(len)) {
125 return false;
126 }
127 size_t readableSize = DataGenerator::GetInstance().GetReadableBytes();
128 len = (readableSize == 0) ? 0 : (len % readableSize);
129 payload.push_back(len + prefix.size());
130 payload.insert(payload.end(), prefix.begin(), prefix.end());
131 for (uint8_t i = 0; i < len; ++i) {
132 payload.push_back(DataGenerator::GetInstance().ReadUint8());
133 }
134 return true;
135 }
136
137 #endif // FUZZ_DATA_GENERATOR_H
138