1 /*
2 * Copyright (c) 2022 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 #include "audioadapter_fuzzer.h"
16 #include "hdi_service_common.h"
17
18 namespace OHOS {
19 namespace Audio {
20
21 constexpr size_t THRESHOLD = 200;
22 constexpr int32_t OFFSET = 4;
23 uint32_t g_captureId = 0;
24 uint32_t g_renderId = 0;
25 struct AudioDeviceDescriptor g_devDesc;
26 enum AdapterCmdId {
27 AUDIO_ADAPTER_CREAT_RENDER,
28 AUDIO_ADAPTER_DESTORY_RENDER,
29 AUDIO_ADAPTER_CREAT_CAPTURE,
30 AUDIO_ADAPTER_DESTORY_CAPTURE,
31 AUDIO_ADAPTER_GET_PORT_CAPABILITY,
32 AUDIO_ADAPTER_SET_PASSTHROUGH_MODE,
33 AUDIO_ADAPTER_GET_PASSTHROUGH_MODE,
34 };
Convert2Uint32(const uint8_t * ptr)35 static uint32_t Convert2Uint32(const uint8_t *ptr)
36 {
37 if (ptr == nullptr) {
38 return 0;
39 }
40 /*
41 * Move the 0th digit 24 to the left, the first digit 16 to the left, the second digit 8 to the left,
42 * and the third digit no left
43 */
44 return (ptr[BUFFER_INDEX_ZERO] << PCM_24_BIT) | (ptr[BUFFER_INDEX_ONE] << PCM_16_BIT) |
45 (ptr[BUFFER_INDEX_TWO] << PCM_8_BIT) | (ptr[BUFFER_INDEX_THREE]);
46 }
47
InitDevDesc(const struct AudioDeviceDescriptor * devDesc)48 static int32_t InitDevDesc(const struct AudioDeviceDescriptor *devDesc)
49 {
50 if (devDesc == nullptr) {
51 return HDF_FAILURE;
52 }
53
54 g_devDesc.portId = devDesc->portId;
55 g_devDesc.pins = devDesc->pins;
56 g_devDesc.desc = NULL;
57 return HDF_SUCCESS;
58 }
59
AdapterFucSwitch(struct IAudioAdapter * & adapter,uint32_t cmd,const uint8_t * & rawData)60 static void AdapterFucSwitch(struct IAudioAdapter *&adapter, uint32_t cmd, const uint8_t *&rawData)
61 {
62 uint8_t *data = const_cast<uint8_t *>(rawData);
63 switch (cmd) {
64 case AUDIO_ADAPTER_CREAT_RENDER: {
65 struct IAudioRender *render = nullptr;
66 InitDevDesc((const struct AudioDeviceDescriptor *)(rawData));
67 adapter->CreateRender(adapter, &g_devDesc,
68 reinterpret_cast<const struct AudioSampleAttributes *>(rawData), &render, &g_renderId);
69 break;
70 }
71 case AUDIO_ADAPTER_DESTORY_RENDER: {
72 adapter->DestroyRender(adapter, g_renderId);
73 }
74 break;
75 case AUDIO_ADAPTER_CREAT_CAPTURE: {
76 struct IAudioCapture *capture = nullptr;
77 InitDevDesc((const struct AudioDeviceDescriptor *)(rawData));
78 adapter->CreateCapture(adapter, &g_devDesc,
79 reinterpret_cast<const struct AudioSampleAttributes *>(rawData), &capture, &g_captureId);
80 break;
81 }
82 case AUDIO_ADAPTER_DESTORY_CAPTURE: {
83 adapter->DestroyCapture(adapter, g_captureId);
84 }
85 break;
86 case AUDIO_ADAPTER_GET_PORT_CAPABILITY: {
87 struct AudioPortCapability capability = {};
88 struct AudioPort port = {
89 .dir = *(reinterpret_cast<AudioPortDirection *>(data)),
90 .portId = *(reinterpret_cast<uint32_t *>(data)),
91 .portName = reinterpret_cast<char *>(data),
92 };
93 adapter->GetPortCapability(adapter, &port, &capability);
94 break;
95 }
96 case AUDIO_ADAPTER_SET_PASSTHROUGH_MODE: {
97 struct AudioPort port = {
98 .dir = *(reinterpret_cast<AudioPortDirection *>(data)),
99 .portId = *(reinterpret_cast<uint32_t *>(data)),
100 .portName = reinterpret_cast<char *>(data),
101 };
102 adapter->SetPassthroughMode(adapter, &port, *(reinterpret_cast<const AudioPortPassthroughMode *>(rawData)));
103 break;
104 }
105 case AUDIO_ADAPTER_GET_PASSTHROUGH_MODE: {
106 AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM;
107 struct AudioPort port = {
108 .dir = *(reinterpret_cast<AudioPortDirection *>(data)),
109 .portId = *(reinterpret_cast<uint32_t *>(data)),
110 .portName = reinterpret_cast<char *>(data),
111 };
112 adapter->GetPassthroughMode(adapter, &port, &mode);
113 break;
114 }
115 default:
116 return;
117 }
118 }
119
DoSomethingInterestingWithMyAPI(const uint8_t * rawData,size_t size)120 bool DoSomethingInterestingWithMyAPI(const uint8_t *rawData, size_t size)
121 {
122 if (rawData == nullptr) {
123 return false;
124 }
125 uint32_t cmd = Convert2Uint32(rawData);
126 rawData = rawData + OFFSET;
127 struct IAudioManager *manager = IAudioManagerGet(false);
128 if (manager == nullptr) {
129 return false;
130 }
131 struct AudioPort audioPort = {};
132 struct IAudioAdapter *adapter = nullptr;
133 int32_t ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
134 if (ret != HDF_SUCCESS) {
135 return false;
136 }
137 AdapterFucSwitch(adapter, cmd, rawData);
138 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
139 IAudioManagerRelease(manager, false);
140 return true;
141 }
142
143 }
144 }
145
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)146 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
147 {
148 if (size < OHOS::Audio::THRESHOLD) {
149 return 0;
150 }
151 OHOS::Audio::DoSomethingInterestingWithMyAPI(data, size);
152 return 0;
153 }