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 #include "fuzztest_utils.h"
17 
18 #include "if_system_ability_manager.h"
19 #include "sam_mock_permission.h"
20 #include "system_ability_manager.h"
21 #include "iservice_registry.h"
22 #include "hisysevent_adapter.h"
23 
24 #include <cinttypes>
25 #include <unistd.h>
26 #include <cstdlib>
27 #include <fcntl.h>
28 
29 namespace OHOS {
30 namespace Samgr {
31 
32 namespace {
33     constexpr int32_t INIT_TIME = 3;
34     constexpr int32_t RETRY_TIME_OUT_NUMBER = 10;
35     constexpr int32_t SLEEP_INTERVAL_TIME = 200000;
36     constexpr int32_t DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID = 4802;
37     unsigned int g_dumpLevel = 0;
38     const std::u16string SAMGR_INTERFACE_TOKEN = u"ohos.samgr.accessToken";
39     bool g_flag = false;
40 }
41 
IsDmReady()42 bool FuzzTestUtils::IsDmReady()
43 {
44     auto dmProxy = SystemAbilityManager::GetInstance()->CheckSystemAbility(
45         DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID);
46     if (dmProxy != nullptr) {
47         IPCObjectProxy* proxy = reinterpret_cast<IPCObjectProxy*>(dmProxy.GetRefPtr());
48         if (proxy != nullptr && !proxy->IsObjectDead()) {
49             return true;
50         }
51     }
52     HILOGE("samgrFuzz:DM isn't ready");
53     return false;
54 }
55 
AddDeviceManager()56 void FuzzTestUtils::AddDeviceManager()
57 {
58     if (IsDmReady()) {
59         return;
60     }
61     sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
62     if (sm == nullptr) {
63         HILOGE("samgrFuzz:GetSystemAbilityManager fail");
64         return;
65     }
66     int32_t timeout = RETRY_TIME_OUT_NUMBER;
67     int64_t begin = OHOS::GetTickCount();
68     sptr<IRemoteObject> dmAbility = nullptr;
69     do {
70         dmAbility = sm->CheckSystemAbility(DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID);
71         if (dmAbility != nullptr) {
72             break;
73         }
74         usleep(SLEEP_INTERVAL_TIME);
75     } while (timeout--);
76     HILOGI("samgrFuzz:Add DM spend %{public}" PRId64 " ms", OHOS::GetTickCount() - begin);
77     if (dmAbility == nullptr) {
78         HILOGE("samgrFuzz:dmAbility is null");
79         return;
80     }
81     sptr<SystemAbilityManager> fuzzSAManager = SystemAbilityManager::GetInstance();
82     ISystemAbilityManager::SAExtraProp saExtra(false, g_dumpLevel, u"", u"");
83     int32_t ret = fuzzSAManager->AddSystemAbility(DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID, dmAbility, saExtra);
84     if (ret == ERR_OK) {
85         HILOGI("samgrFuzz:Add DM sucess");
86         return;
87     }
88     HILOGE("samgrFuzz:Add DM fail");
89 }
90 
FuzzTestRemoteRequest(const uint8_t * rawData,size_t size,uint32_t code)91 void FuzzTestUtils::FuzzTestRemoteRequest(const uint8_t *rawData, size_t size, uint32_t code)
92 {
93     SamMockPermission::MockPermission();
94     MessageParcel data;
95     data.WriteInterfaceToken(SAMGR_INTERFACE_TOKEN);
96     data.WriteBuffer(rawData, size);
97     data.RewindRead(0);
98     MessageParcel reply;
99     MessageOption option;
100     sptr<SystemAbilityManager> manager = SystemAbilityManager::GetInstance();
101     if (!g_flag) {
102         HILOGI("TestRequest=%{public}u:Init", code);
103         manager->Init();
104         g_flag = true;
105         HILOGI("TestRequest=%{public}u:Init AddDeviceManager", code);
106         AddDeviceManager();
107         sleep(INIT_TIME);
108         if (!IsDmReady()) {
109             HILOGE("TestRequest=%{public}u:Init CleanFfrt", code);
110             manager->CleanFfrt();
111             return;
112         }
113     } else {
114         HILOGI("TestRequest=%{public}u:AddDeviceManager", code);
115         AddDeviceManager();
116         if (!IsDmReady()) {
117             HILOGE("TestRequest=%{public}u:dm no ready,return", code);
118             return;
119         }
120         HILOGI("TestRequest=%{public}u:SetFfrt", code);
121         manager->SetFfrt();
122     }
123     int32_t ret = manager->OnRemoteRequest(code, data, reply, option);
124     HILOGI("TestRequest=%{public}u: ret=%{public}u", code, ret);
125     manager->CleanFfrt();
126 }
127 
FuzzTestRemoteRequest(MessageParcel & data,uint32_t code)128 void FuzzTestUtils::FuzzTestRemoteRequest(MessageParcel& data, uint32_t code)
129 {
130     SamMockPermission::MockPermission();
131     MessageParcel reply;
132     MessageOption option;
133     sptr<SystemAbilityManager> manager = SystemAbilityManager::GetInstance();
134     if (!g_flag) {
135         HILOGI("FuzzTestRequest=%{public}u:Init", code);
136         manager->Init();
137         g_flag = true;
138         HILOGI("FuzzTestRequest=%{public}u:Init AddDeviceManager", code);
139         AddDeviceManager();
140         sleep(INIT_TIME);
141         if (!IsDmReady()) {
142             HILOGE("FuzzTestRequest=%{public}u:Init CleanFfrt", code);
143             manager->CleanFfrt();
144             return;
145         }
146     } else {
147         HILOGI("FuzzTestRequest=%{public}u:AddDeviceManager", code);
148         AddDeviceManager();
149         if (!IsDmReady()) {
150             HILOGE("FuzzTestRequest=%{public}u:dm no ready,return", code);
151             return;
152         }
153         HILOGI("FuzzTestRequest=%{public}u:SetFfrt", code);
154         manager->SetFfrt();
155     }
156     int32_t ret = manager->OnRemoteRequest(code, data, reply, option);
157     HILOGI("FuzzTestRequest=%{public}u: ret=%{public}u", code, ret);
158     manager->CleanFfrt();
159 }
160 }
161 } // namespace OHOS
162