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
16#include "setcalltransferinfo_fuzzer.h"
17
18#include <cstddef>
19#include <cstdint>
20#define private public
21#include "addcalltoken_fuzzer.h"
22#include "call_manager_service_stub.h"
23
24using namespace OHOS::Telephony;
25namespace OHOS {
26constexpr int32_t SLOT_NUM = 2;
27constexpr int32_t IMS_CONFIG_ITEM_NUM = 2;
28constexpr int32_t FEATURE_TYPE_NUM = 3;
29
30void IsImsSwitchEnabled(const uint8_t *data, size_t size)
31{
32    if (!IsServiceInited()) {
33        return;
34    }
35
36    int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
37    MessageParcel dataMessageParcel;
38    dataMessageParcel.WriteInt32(slotId);
39    dataMessageParcel.WriteBuffer(data, size);
40    dataMessageParcel.RewindRead(0);
41    MessageParcel reply;
42    DelayedSingleton<CallManagerService>::GetInstance()->OnIsVoLteEnabled(dataMessageParcel, reply);
43}
44
45void GetVoNRState(const uint8_t *data, size_t size)
46{
47    if (!IsServiceInited()) {
48        return;
49    }
50
51    MessageParcel dataMessageParcel;
52    dataMessageParcel.WriteInt32(static_cast<int32_t>(size % SLOT_NUM));
53    dataMessageParcel.WriteBuffer(data, size);
54    dataMessageParcel.RewindRead(0);
55    MessageParcel reply;
56    DelayedSingleton<CallManagerService>::GetInstance()->OnGetVoNRState(dataMessageParcel, reply);
57}
58
59void GetImsConfig(const uint8_t *data, size_t size)
60{
61    if (!IsServiceInited()) {
62        return;
63    }
64
65    int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
66    int32_t item = static_cast<int32_t>(size % IMS_CONFIG_ITEM_NUM);
67    MessageParcel dataMessageParcel;
68    dataMessageParcel.WriteInt32(slotId);
69    dataMessageParcel.WriteInt32(static_cast<ImsConfigItem>(item));
70    dataMessageParcel.WriteBuffer(data, size);
71    dataMessageParcel.RewindRead(0);
72    MessageParcel reply;
73    DelayedSingleton<CallManagerService>::GetInstance()->OnGetImsConfig(dataMessageParcel, reply);
74}
75
76void GetImsFeatureValue(const uint8_t *data, size_t size)
77{
78    if (!IsServiceInited()) {
79        return;
80    }
81
82    int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
83    int32_t type = static_cast<int32_t>(size % FEATURE_TYPE_NUM);
84    MessageParcel dataMessageParcel;
85    dataMessageParcel.WriteInt32(slotId);
86    dataMessageParcel.WriteInt32(static_cast<FeatureType>(type));
87    dataMessageParcel.WriteBuffer(data, size);
88    dataMessageParcel.RewindRead(0);
89    MessageParcel reply;
90    DelayedSingleton<CallManagerService>::GetInstance()->OnGetImsFeatureValue(dataMessageParcel, reply);
91}
92
93void GetCallTransferInfo(const uint8_t *data, size_t size)
94{
95    if (!IsServiceInited()) {
96        return;
97    }
98
99    int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
100    MessageParcel dataMessageParcel;
101    dataMessageParcel.WriteInt32(slotId);
102    dataMessageParcel.WriteInt32(static_cast<int32_t>(size));
103    dataMessageParcel.WriteBuffer(data, size);
104    dataMessageParcel.RewindRead(0);
105    MessageParcel reply;
106    DelayedSingleton<CallManagerService>::GetInstance()->OnGetTransferNumber(dataMessageParcel, reply);
107}
108
109void SetCallTransferInfo(const uint8_t *data, size_t size)
110{
111    if (!IsServiceInited()) {
112        return;
113    }
114
115    int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
116    MessageParcel dataMessageParcel;
117    CallTransferInfo info;
118    (void)memcpy_s(info.transferNum, kMaxNumberLen, reinterpret_cast<const char *>(data), size);
119    info.settingType = CallTransferSettingType::CALL_TRANSFER_ENABLE;
120    info.type = CallTransferType::TRANSFER_TYPE_BUSY;
121    dataMessageParcel.WriteInt32(slotId);
122    dataMessageParcel.WriteRawData((const void *)&info, sizeof(CallTransferInfo));
123    dataMessageParcel.RewindRead(0);
124    MessageParcel reply;
125    DelayedSingleton<CallManagerService>::GetInstance()->OnSetTransferNumber(dataMessageParcel, reply);
126}
127
128void DoSomethingInterestingWithMyAPI(const uint8_t *data, size_t size)
129{
130    if (data == nullptr || size == 0) {
131        return;
132    }
133
134    IsImsSwitchEnabled(data, size);
135    GetVoNRState(data, size);
136    GetImsConfig(data, size);
137    GetImsFeatureValue(data, size);
138    GetCallTransferInfo(data, size);
139    SetCallTransferInfo(data, size);
140}
141} // namespace OHOS
142
143/* Fuzzer entry point */
144extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
145{
146    OHOS::AddCallTokenFuzzer token;
147    /* Run your code on data */
148    OHOS::DoSomethingInterestingWithMyAPI(data, size);
149    return 0;
150}
151