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[0] << 24) | (ptr[1] << 16) | (ptr[2] << 8) | (ptr[3]);
45 }
46 
InitDevDesc(const struct AudioDeviceDescriptor * devDesc)47 static int32_t InitDevDesc(const struct AudioDeviceDescriptor *devDesc)
48 {
49     if (devDesc == nullptr) {
50         return HDF_FAILURE;
51     }
52 
53     g_devDesc.portId = devDesc->portId;
54     g_devDesc.pins = devDesc->pins;
55     g_devDesc.desc = NULL;
56     return HDF_SUCCESS;
57 }
58 
AdapterFucSwitch(struct IAudioAdapter * & adapter,uint32_t cmd,const uint8_t * & rawData)59 static void AdapterFucSwitch(struct IAudioAdapter *&adapter, uint32_t cmd, const uint8_t *&rawData)
60 {
61     uint8_t *data = const_cast<uint8_t *>(rawData);
62     switch (cmd) {
63         case AUDIO_ADAPTER_CREAT_RENDER: {
64             struct IAudioRender *render = nullptr;
65             InitDevDesc((const struct AudioDeviceDescriptor *)(rawData));
66             adapter->CreateRender(adapter, &g_devDesc,
67                 reinterpret_cast<const struct AudioSampleAttributes *>(rawData), &render, &g_renderId);
68             break;
69         }
70         case AUDIO_ADAPTER_DESTORY_RENDER: {
71             adapter->DestroyRender(adapter, g_renderId);
72         }
73             break;
74         case AUDIO_ADAPTER_CREAT_CAPTURE: {
75             struct IAudioCapture *capture = nullptr;
76             InitDevDesc((const struct AudioDeviceDescriptor *)(rawData));
77             adapter->CreateCapture(adapter, &g_devDesc,
78                 reinterpret_cast<const struct AudioSampleAttributes *>(rawData), &capture, &g_captureId);
79             break;
80         }
81         case AUDIO_ADAPTER_DESTORY_CAPTURE: {
82             adapter->DestroyCapture(adapter, g_captureId);
83         }
84             break;
85         case AUDIO_ADAPTER_GET_PORT_CAPABILITY: {
86             struct AudioPortCapability capability = {};
87             struct AudioPort port = {
88                 .dir = *(reinterpret_cast<AudioPortDirection *>(data)),
89                 .portId = *(reinterpret_cast<uint32_t *>(data)),
90                 .portName = reinterpret_cast<char *>(data),
91             };
92             adapter->GetPortCapability(adapter, &port, &capability);
93             break;
94         }
95         case AUDIO_ADAPTER_SET_PASSTHROUGH_MODE: {
96             struct AudioPort port = {
97                 .dir = *(reinterpret_cast<AudioPortDirection *>(data)),
98                 .portId = *(reinterpret_cast<uint32_t *>(data)),
99                 .portName = reinterpret_cast<char *>(data),
100             };
101             adapter->SetPassthroughMode(adapter, &port, *(reinterpret_cast<const AudioPortPassthroughMode *>(rawData)));
102             break;
103         }
104         case AUDIO_ADAPTER_GET_PASSTHROUGH_MODE: {
105             AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM;
106             struct AudioPort port = {
107                 .dir = *(reinterpret_cast<AudioPortDirection *>(data)),
108                 .portId = *(reinterpret_cast<uint32_t *>(data)),
109                 .portName = reinterpret_cast<char *>(data),
110             };
111             adapter->GetPassthroughMode(adapter, &port, &mode);
112             break;
113         }
114         default:
115             return;
116     }
117 }
118 
DoSomethingInterestingWithMyAPI(const uint8_t * rawData,size_t size)119 bool DoSomethingInterestingWithMyAPI(const uint8_t *rawData, size_t size)
120 {
121     if (rawData == nullptr) {
122         return false;
123     }
124     uint32_t cmd = Convert2Uint32(rawData);
125     rawData = rawData + OFFSET;
126     struct IAudioManager *manager = IAudioManagerGet(false);
127     if (manager == nullptr) {
128         return false;
129     }
130     struct AudioPort audioPort = {};
131     struct IAudioAdapter *adapter = nullptr;
132     int32_t ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
133     if (ret != HDF_SUCCESS) {
134         return false;
135     }
136     AdapterFucSwitch(adapter, cmd, rawData);
137     manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
138     IAudioManagerRelease(manager, false);
139     return true;
140 }
141 
142 }
143 }
144 
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)145 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
146 {
147     if (size < OHOS::Audio::THRESHOLD) {
148         return 0;
149     }
150     OHOS::Audio::DoSomethingInterestingWithMyAPI(data, size);
151     return 0;
152 }