1 /*
2 * Copyright (c) 2024-2025 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 "audio_volume_manager.h"
17 using namespace std;
18
19 namespace OHOS {
20 namespace AudioStandard {
21
22 const int32_t NUM_2 = 2;
23 const int32_t SAFE_VOLUME_LIMIT = 100;
24 const int32_t RESTORE_VOLUME_NOTIFICATION_ID = 116000;
25 const int32_t INCREASE_VOLUME_NOTIFICATION_ID = 116001;
26 const uint32_t NOTIFICATION_BANNER_FLAG = 1 << 9;
27 typedef void (*TestPtr)(const uint8_t *, size_t);
28
29 const vector<AudioStreamType> g_testStreamTypes = {
30 STREAM_DEFAULT,
31 STREAM_VOICE_CALL,
32 STREAM_MUSIC,
33 STREAM_RING,
34 STREAM_MEDIA,
35 STREAM_VOICE_ASSISTANT,
36 STREAM_SYSTEM,
37 STREAM_ALARM,
38 STREAM_NOTIFICATION,
39 STREAM_BLUETOOTH_SCO,
40 STREAM_ENFORCED_AUDIBLE,
41 STREAM_DTMF,
42 STREAM_TTS,
43 STREAM_ACCESSIBILITY,
44 STREAM_RECORDING,
45 STREAM_MOVIE,
46 STREAM_GAME,
47 STREAM_SPEECH,
48 STREAM_SYSTEM_ENFORCED,
49 STREAM_ULTRASONIC,
50 STREAM_WAKEUP,
51 STREAM_VOICE_MESSAGE,
52 STREAM_NAVIGATION,
53 STREAM_INTERNAL_FORCE_STOP,
54 STREAM_SOURCE_VOICE_CALL,
55 STREAM_VOICE_COMMUNICATION,
56 STREAM_VOICE_RING,
57 STREAM_VOICE_CALL_ASSISTANT,
58 STREAM_CAMCORDER,
59 STREAM_APP,
60 STREAM_TYPE_MAX,
61 STREAM_ALL,
62 };
63
64 const vector<DeviceType> g_testDeviceTypes = {
65 DEVICE_TYPE_NONE,
66 DEVICE_TYPE_INVALID,
67 DEVICE_TYPE_EARPIECE,
68 DEVICE_TYPE_SPEAKER,
69 DEVICE_TYPE_WIRED_HEADSET,
70 DEVICE_TYPE_WIRED_HEADPHONES,
71 DEVICE_TYPE_BLUETOOTH_SCO,
72 DEVICE_TYPE_BLUETOOTH_A2DP,
73 DEVICE_TYPE_BLUETOOTH_A2DP_IN,
74 DEVICE_TYPE_MIC,
75 DEVICE_TYPE_WAKEUP,
76 DEVICE_TYPE_USB_HEADSET,
77 DEVICE_TYPE_DP,
78 DEVICE_TYPE_REMOTE_CAST,
79 DEVICE_TYPE_USB_DEVICE,
80 DEVICE_TYPE_ACCESSORY,
81 DEVICE_TYPE_REMOTE_DAUDIO,
82 DEVICE_TYPE_HDMI,
83 DEVICE_TYPE_LINE_DIGITAL,
84 DEVICE_TYPE_NEARLINK,
85 DEVICE_TYPE_NEARLINK_IN,
86 DEVICE_TYPE_FILE_SINK,
87 DEVICE_TYPE_FILE_SOURCE,
88 DEVICE_TYPE_EXTERN_CABLE,
89 DEVICE_TYPE_DEFAULT,
90 DEVICE_TYPE_USB_ARM_HEADSET,
91 DEVICE_TYPE_MAX
92 };
93
94 template<class T>
GetArrLength(T & arr)95 uint32_t GetArrLength(T& arr)
96 {
97 if (arr == nullptr) {
98 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
99 return 0;
100 }
101 return sizeof(arr) / sizeof(arr[0]);
102 }
103
AudioVolumeManagerInitSharedVolumeFuzzTest(const uint8_t * rawData,size_t size)104 void AudioVolumeManagerInitSharedVolumeFuzzTest(const uint8_t *rawData, size_t size)
105 {
106 std::shared_ptr<AudioSharedMemory> buffer;
107 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
108
109 audioVolumeManager.InitSharedVolume(buffer);
110 }
111
AudioVolumeManagerSetVoiceRingtoneMuteFuzzTest(const uint8_t * rawData,size_t size)112 void AudioVolumeManagerSetVoiceRingtoneMuteFuzzTest(const uint8_t *rawData, size_t size)
113 {
114 bool isMute = static_cast<bool>(static_cast<uint32_t>(size) % NUM_2);
115 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
116
117 audioVolumeManager.SetVoiceRingtoneMute(isMute);
118 }
119
AudioVolumeManagerHandleAbsBluetoothVolumeFuzzTest(const uint8_t * rawData,size_t size)120 void AudioVolumeManagerHandleAbsBluetoothVolumeFuzzTest(const uint8_t *rawData, size_t size)
121 {
122 std::string macAddress = "11:22:33:44:55:66";
123 int32_t volumeLevel = static_cast<int32_t>(size);
124 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
125 vector<DeviceCategory> testDeviceCategory = {
126 CATEGORY_DEFAULT,
127 BT_HEADPHONE,
128 BT_SOUNDBOX,
129 BT_CAR,
130 BT_GLASSES,
131 BT_WATCH,
132 BT_HEARAID,
133 BT_UNWEAR_HEADPHONE,
134 };
135
136 audioVolumeManager.isBtFirstBoot_ = static_cast<bool>(static_cast<uint32_t>(size) % NUM_2);
137 uint32_t index = static_cast<uint32_t>(size) % testDeviceCategory.size();
138 audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceCategory_ = testDeviceCategory[index];
139
140 audioVolumeManager.HandleAbsBluetoothVolume(macAddress, volumeLevel);
141 }
142
AudioVolumeManagerIsWiredHeadSetFuzzTest(const uint8_t * rawData,size_t size)143 void AudioVolumeManagerIsWiredHeadSetFuzzTest(const uint8_t *rawData, size_t size)
144 {
145 uint32_t index = static_cast<uint32_t>(size) % g_testDeviceTypes.size();
146 DeviceType deviceType = g_testDeviceTypes[index];
147 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
148
149 audioVolumeManager.IsWiredHeadSet(deviceType);
150 }
151
AudioVolumeManagerIsBlueToothFuzzTest(const uint8_t * rawData,size_t size)152 void AudioVolumeManagerIsBlueToothFuzzTest(const uint8_t *rawData, size_t size)
153 {
154 uint32_t index = static_cast<uint32_t>(size) % g_testDeviceTypes.size();
155 DeviceType deviceType = g_testDeviceTypes[index];
156 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
157
158 audioVolumeManager.IsBlueTooth(deviceType);
159 }
160
AudioVolumeManagerCheckMixActiveMusicTimeFuzzTest(const uint8_t * rawData,size_t size)161 void AudioVolumeManagerCheckMixActiveMusicTimeFuzzTest(const uint8_t *rawData, size_t size)
162 {
163 int32_t safeVolume = static_cast<int32_t>(size) % SAFE_VOLUME_LIMIT;
164 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
165
166 audioVolumeManager.activeSafeTimeBt_ = static_cast<int64_t>(size);
167 audioVolumeManager.activeSafeTime_ = static_cast<int64_t>(size);
168 audioVolumeManager.CheckMixActiveMusicTime(safeVolume);
169 }
170
AudioVolumeManagerCheckBlueToothActiveMusicTimeFuzzTest(const uint8_t * rawData,size_t size)171 void AudioVolumeManagerCheckBlueToothActiveMusicTimeFuzzTest(const uint8_t *rawData, size_t size)
172 {
173 int32_t safeVolume = static_cast<int32_t>(size) % SAFE_VOLUME_LIMIT;
174 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
175
176 audioVolumeManager.startSafeTimeBt_ = 0;
177 audioVolumeManager.activeSafeTimeBt_ = static_cast<int64_t>(size);
178 audioVolumeManager.activeSafeTime_ = static_cast<int64_t>(size);
179 audioVolumeManager.CheckBlueToothActiveMusicTime(safeVolume);
180 }
181
AudioVolumeManagerCheckWiredActiveMusicTimeFuzzTest(const uint8_t * rawData,size_t size)182 void AudioVolumeManagerCheckWiredActiveMusicTimeFuzzTest(const uint8_t *rawData, size_t size)
183 {
184 int32_t safeVolume = static_cast<int32_t>(size) % SAFE_VOLUME_LIMIT;
185 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
186
187 audioVolumeManager.startSafeTimeBt_ = 0;
188 audioVolumeManager.activeSafeTimeBt_ = static_cast<int64_t>(size);
189 audioVolumeManager.activeSafeTime_ = static_cast<int64_t>(size);
190 audioVolumeManager.CheckWiredActiveMusicTime(safeVolume);
191 }
192
AudioVolumeManagerRestoreSafeVolumeFuzzTest(const uint8_t * rawData,size_t size)193 void AudioVolumeManagerRestoreSafeVolumeFuzzTest(const uint8_t *rawData, size_t size)
194 {
195 uint32_t index = static_cast<uint32_t>(size) % g_testStreamTypes.size();
196 AudioStreamType streamType = g_testStreamTypes[index];
197 int32_t safeVolume = static_cast<int32_t>(size) % SAFE_VOLUME_LIMIT;
198 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
199
200 audioVolumeManager.RestoreSafeVolume(streamType, safeVolume);
201 }
202
AudioVolumeManagerSetSafeVolumeCallbackFuzzTest(const uint8_t * rawData,size_t size)203 void AudioVolumeManagerSetSafeVolumeCallbackFuzzTest(const uint8_t *rawData, size_t size)
204 {
205 uint32_t index = static_cast<uint32_t>(size) % g_testStreamTypes.size();
206 AudioStreamType streamType = g_testStreamTypes[index];
207 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
208 audioVolumeManager.audioPolicyServerHandler_ = std::make_shared<AudioPolicyServerHandler>();
209
210 audioVolumeManager.SetSafeVolumeCallback(streamType);
211 }
212
AudioVolumeManagerChangeDeviceSafeStatusFuzzTest(const uint8_t * rawData,size_t size)213 void AudioVolumeManagerChangeDeviceSafeStatusFuzzTest(const uint8_t *rawData, size_t size)
214 {
215 vector<SafeStatus> testSafeStatus = {
216 SAFE_UNKNOWN,
217 SAFE_INACTIVE,
218 SAFE_ACTIVE,
219 };
220
221 uint32_t index = static_cast<uint32_t>(size) % testSafeStatus.size();
222 SafeStatus safeStatus = testSafeStatus[index];
223 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
224
225 audioVolumeManager.ChangeDeviceSafeStatus(safeStatus);
226 }
227
AudioVolumeManagerSetAbsVolumeSceneAsyncFuzzTest(const uint8_t * rawData,size_t size)228 void AudioVolumeManagerSetAbsVolumeSceneAsyncFuzzTest(const uint8_t *rawData, size_t size)
229 {
230 std::string macAddress = "11:22:33:44:55:66";
231 bool support = static_cast<bool>(static_cast<uint32_t>(size) % NUM_2);
232 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
233
234 audioVolumeManager.audioActiveDevice_.SetActiveBtDeviceMac(macAddress);
235 audioVolumeManager.SetAbsVolumeSceneAsync(macAddress, support);
236 }
237
AudioVolumeManagerDealWithEventVolumeFuzzTest(const uint8_t * rawData,size_t size)238 void AudioVolumeManagerDealWithEventVolumeFuzzTest(const uint8_t *rawData, size_t size)
239 {
240 vector<int32_t> testNotificationIds = {
241 RESTORE_VOLUME_NOTIFICATION_ID,
242 INCREASE_VOLUME_NOTIFICATION_ID,
243 NOTIFICATION_BANNER_FLAG,
244 };
245 uint32_t index = static_cast<uint32_t>(size) % testNotificationIds.size();
246 int32_t notificationId = testNotificationIds[index];
247 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
248
249 vector<DeviceCategory> testDeviceCategory = {
250 CATEGORY_DEFAULT,
251 BT_HEADPHONE,
252 BT_SOUNDBOX,
253 BT_CAR,
254 BT_GLASSES,
255 BT_WATCH,
256 BT_HEARAID,
257 BT_UNWEAR_HEADPHONE,
258 };
259 index = static_cast<uint32_t>(size) % testDeviceCategory.size();
260 audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceCategory_ = testDeviceCategory[index];
261
262 index = static_cast<uint32_t>(size) % g_testDeviceTypes.size();
263 audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceType_ = g_testDeviceTypes[index];
264
265 audioVolumeManager.DealWithEventVolume(notificationId);
266 }
267
AudioVolumeManagerUpdateSafeVolumeByS4FuzzTest(const uint8_t * rawData,size_t size)268 void AudioVolumeManagerUpdateSafeVolumeByS4FuzzTest(const uint8_t *rawData, size_t size)
269 {
270 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
271
272 audioVolumeManager.UpdateSafeVolumeByS4();
273 }
274
AudioVolumeManagerSetDeviceAbsVolumeSupportedFuzzTest(const uint8_t * rawData,size_t size)275 void AudioVolumeManagerSetDeviceAbsVolumeSupportedFuzzTest(const uint8_t *rawData, size_t size)
276 {
277 std::string macAddress = "11:22:33:44:55:66";
278 bool support = static_cast<bool>(static_cast<uint32_t>(size) % NUM_2);
279 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
280
281 audioVolumeManager.audioActiveDevice_.SetActiveBtDeviceMac(macAddress);
282 audioVolumeManager.SetDeviceAbsVolumeSupported(macAddress, support);
283 }
284
AudioVolumeManagerSetStreamMuteFuzzTest(const uint8_t * rawData,size_t size)285 void AudioVolumeManagerSetStreamMuteFuzzTest(const uint8_t *rawData, size_t size)
286 {
287 vector<StreamUsage> testStreamUsages = {
288 STREAM_USAGE_INVALID,
289 STREAM_USAGE_UNKNOWN,
290 STREAM_USAGE_MEDIA,
291 STREAM_USAGE_MUSIC,
292 STREAM_USAGE_VOICE_COMMUNICATION,
293 STREAM_USAGE_VOICE_ASSISTANT,
294 STREAM_USAGE_ALARM,
295 STREAM_USAGE_VOICE_MESSAGE,
296 STREAM_USAGE_NOTIFICATION_RINGTONE,
297 STREAM_USAGE_RINGTONE,
298 STREAM_USAGE_NOTIFICATION,
299 STREAM_USAGE_ACCESSIBILITY,
300 STREAM_USAGE_SYSTEM,
301 STREAM_USAGE_MOVIE,
302 STREAM_USAGE_GAME,
303 STREAM_USAGE_AUDIOBOOK,
304 STREAM_USAGE_NAVIGATION,
305 STREAM_USAGE_DTMF,
306 STREAM_USAGE_ENFORCED_TONE,
307 STREAM_USAGE_ULTRASONIC,
308 STREAM_USAGE_VIDEO_COMMUNICATION,
309 STREAM_USAGE_RANGING,
310 STREAM_USAGE_VOICE_MODEM_COMMUNICATION,
311 STREAM_USAGE_VOICE_RINGTONE,
312 STREAM_USAGE_VOICE_CALL_ASSISTANT,
313 STREAM_USAGE_MAX,
314 };
315 uint32_t index = static_cast<uint32_t>(size) % g_testStreamTypes.size();
316 AudioVolumeType streamType = g_testStreamTypes[index];
317 bool mute = static_cast<bool>(static_cast<uint32_t>(size) % NUM_2);
318 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
319
320 index = static_cast<uint32_t>(size) % testStreamUsages.size();
321 StreamUsage streamUsage = testStreamUsages[index];
322 index = static_cast<uint32_t>(size) % g_testDeviceTypes.size();
323 DeviceType deviceType = g_testDeviceTypes[index];
324 audioVolumeManager.SetStreamMute(streamType, mute, streamUsage, deviceType);
325 }
326
AudioVolumeManagerGetMaxVolumeLevelFuzzTest(const uint8_t * rawData,size_t size)327 void AudioVolumeManagerGetMaxVolumeLevelFuzzTest(const uint8_t *rawData, size_t size)
328 {
329 uint32_t index = static_cast<uint32_t>(size) % g_testStreamTypes.size();
330 AudioVolumeType streamType = g_testStreamTypes[index];
331 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
332
333 audioVolumeManager.GetMaxVolumeLevel(streamType);
334 }
335
AudioVolumeManagerGetMinVolumeLevelFuzzTest(const uint8_t * rawData,size_t size)336 void AudioVolumeManagerGetMinVolumeLevelFuzzTest(const uint8_t *rawData, size_t size)
337 {
338 uint32_t index = static_cast<uint32_t>(size) % g_testStreamTypes.size();
339 AudioVolumeType streamType = g_testStreamTypes[index];
340 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
341
342 audioVolumeManager.GetMinVolumeLevel(streamType);
343 }
344
AudioVolumeManagerGetAllDeviceVolumeInfoFuzzTest(const uint8_t * rawData,size_t size)345 void AudioVolumeManagerGetAllDeviceVolumeInfoFuzzTest(const uint8_t *rawData, size_t size)
346 {
347 vector<DeviceRole> testDeviceRoles = {
348 DEVICE_ROLE_NONE,
349 INPUT_DEVICE,
350 OUTPUT_DEVICE,
351 DEVICE_ROLE_MAX,
352 };
353 auto audioVolumeManager = std::make_shared<AudioVolumeManager>();
354 uint32_t index = static_cast<uint32_t>(size) % g_testDeviceTypes.size();
355 DeviceType deviceType = g_testDeviceTypes[index];
356 index = static_cast<uint32_t>(size) % testDeviceRoles.size();
357 DeviceRole deviceRole = testDeviceRoles[index];
358
359 std::shared_ptr<AudioDeviceDescriptor> remoteDeviceDescriptor = std::make_shared<AudioDeviceDescriptor>(
360 deviceType, deviceRole);
361 audioVolumeManager->audioConnectedDevice_.AddConnectedDevice(remoteDeviceDescriptor);
362 audioVolumeManager->GetAllDeviceVolumeInfo();
363 }
364
AudioVolumeManagerInitFuzzTest(const uint8_t * rawData,size_t size)365 void AudioVolumeManagerInitFuzzTest(const uint8_t *rawData, size_t size)
366 {
367 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
368 std::shared_ptr<AudioPolicyServerHandler> audioPolicyServerHandler = std::make_shared<AudioPolicyServerHandler>();
369
370 audioVolumeManager.DeInit();
371 audioVolumeManager.Init(audioPolicyServerHandler);
372 }
373
AudioVolumeManagerInitKVStoreFuzzTest(const uint8_t * rawData,size_t size)374 void AudioVolumeManagerInitKVStoreFuzzTest(const uint8_t *rawData, size_t size)
375 {
376 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
377
378 audioVolumeManager.InitKVStore();
379 }
380
AudioVolumeManagerForceVolumeKeyControlTypeFuzzTest(const uint8_t * rawData,size_t size)381 void AudioVolumeManagerForceVolumeKeyControlTypeFuzzTest(const uint8_t *rawData, size_t size)
382 {
383 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
384
385 audioVolumeManager.ForceVolumeKeyControlType(static_cast<AudioVolumeType>(size), size);
386 }
387
388 } // namespace AudioStandard
389 } // namesapce OHOS
390
391 OHOS::AudioStandard::TestPtr g_testPtrs[] = {
392 OHOS::AudioStandard::AudioVolumeManagerInitSharedVolumeFuzzTest,
393 OHOS::AudioStandard::AudioVolumeManagerSetVoiceRingtoneMuteFuzzTest,
394 OHOS::AudioStandard::AudioVolumeManagerHandleAbsBluetoothVolumeFuzzTest,
395 OHOS::AudioStandard::AudioVolumeManagerIsWiredHeadSetFuzzTest,
396 OHOS::AudioStandard::AudioVolumeManagerIsBlueToothFuzzTest,
397 OHOS::AudioStandard::AudioVolumeManagerCheckMixActiveMusicTimeFuzzTest,
398 OHOS::AudioStandard::AudioVolumeManagerCheckBlueToothActiveMusicTimeFuzzTest,
399 OHOS::AudioStandard::AudioVolumeManagerCheckWiredActiveMusicTimeFuzzTest,
400 OHOS::AudioStandard::AudioVolumeManagerRestoreSafeVolumeFuzzTest,
401 OHOS::AudioStandard::AudioVolumeManagerSetSafeVolumeCallbackFuzzTest,
402 OHOS::AudioStandard::AudioVolumeManagerChangeDeviceSafeStatusFuzzTest,
403 OHOS::AudioStandard::AudioVolumeManagerSetAbsVolumeSceneAsyncFuzzTest,
404 OHOS::AudioStandard::AudioVolumeManagerDealWithEventVolumeFuzzTest,
405 OHOS::AudioStandard::AudioVolumeManagerUpdateSafeVolumeByS4FuzzTest,
406 OHOS::AudioStandard::AudioVolumeManagerSetDeviceAbsVolumeSupportedFuzzTest,
407 OHOS::AudioStandard::AudioVolumeManagerSetStreamMuteFuzzTest,
408 OHOS::AudioStandard::AudioVolumeManagerGetMaxVolumeLevelFuzzTest,
409 OHOS::AudioStandard::AudioVolumeManagerGetMinVolumeLevelFuzzTest,
410 OHOS::AudioStandard::AudioVolumeManagerGetAllDeviceVolumeInfoFuzzTest,
411 OHOS::AudioStandard::AudioVolumeManagerInitFuzzTest,
412 OHOS::AudioStandard::AudioVolumeManagerInitKVStoreFuzzTest,
413 OHOS::AudioStandard::AudioVolumeManagerForceVolumeKeyControlTypeFuzzTest,
414 };
415
416 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)417 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
418 {
419 /* Run your code on data */
420 if (data == nullptr || size <= 1) {
421 return 0;
422 }
423 uint32_t len = OHOS::AudioStandard::GetArrLength(g_testPtrs);
424 if (len > 0) {
425 uint8_t firstByte = *data % len;
426 if (firstByte >= len) {
427 return 0;
428 }
429 data = data + 1;
430 size = size - 1;
431 g_testPtrs[firstByte](data, size);
432 }
433 return 0;
434 }