• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #define private public
17 #define protected public
18 #include "vendormanager_fuzzer.h"
19 #include "fuzzer/FuzzedDataProvider.h"
20 #include "print_log.h"
21 #include "print_constant.h"
22 #include "vendor_manager.h"
23 #include "vendor_driver_base.h"
24 #include "vendor_wlan_group.h"
25 #include "vendor_ppd_driver.h"
26 #include "print_service_ability.h"
27 #include "print_service_ability_mock_permission.h"
28 
29 
30 namespace OHOS {
31 namespace Print {
32 constexpr uint8_t MAX_STRING_LENGTH = 20;
33 constexpr int MAX_SET_NUMBER = 128;
34 constexpr size_t U32_AT_SIZE = 4;
35 static const std::string DEFAULT_VENDOR_NAME = "testVendorName";
36 static ConnectMethod METHOD_DEFAULT = ID_AUTO;
37 static const std::string DEFAULT_PROTOCOL = "ipp";
38 static const int32_t DEFAULT_TIMEOUT = 0;
39 
TestWlanGroupDiscoverPrinterActions(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)40 void TestWlanGroupDiscoverPrinterActions(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
41 {
42     VendorManager vendorManager;
43     vendorManager.Init(PrintServiceAbility::GetInstance());
44     auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
45 
46     std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
47     PrinterInfo printerInfo;
48     printerInfo.SetPrinterId(printerId);
49     printerInfo.SetPrinterName(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
50     printerInfo.SetUri(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
51     printerInfo.SetPrinterMake(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
52     printerInfo.SetOption(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
53 
54     vendorWlanGroup->OnPrinterDiscovered(DEFAULT_VENDOR_NAME, printerInfo);
55     printerInfo.SetPrinterName(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
56     printerInfo.SetUri(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
57     vendorWlanGroup->OnUpdatePrinterToDiscovery(DEFAULT_VENDOR_NAME, printerInfo);
58     vendorWlanGroup->OnPrinterRemoved(DEFAULT_VENDOR_NAME, printerId);
59 
60     vendorWlanGroup->vendorManager = nullptr;
61     vendorWlanGroup->parentVendorManager = nullptr;
62     vendorWlanGroup->OnPrinterDiscovered(DEFAULT_VENDOR_NAME, printerInfo);
63     vendorWlanGroup->OnUpdatePrinterToDiscovery(DEFAULT_VENDOR_NAME, printerInfo);
64     vendorWlanGroup->OnPrinterRemoved(DEFAULT_VENDOR_NAME, printerId);
65 }
66 
TestWlanGroupConnectPrinterActions(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)67 void TestWlanGroupConnectPrinterActions(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
68 {
69     VendorManager vendorManager;
70     vendorManager.Init(PrintServiceAbility::GetInstance());
71     auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
72 
73     std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
74     PrinterInfo printerInfo;
75     printerInfo.SetPrinterId(printerId);
76     printerInfo.SetPrinterName(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
77     std::string printerUri = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
78     printerInfo.SetUri(printerUri);
79     printerInfo.SetPrinterMake(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
80     printerInfo.SetOption(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
81     vendorWlanGroup->OnPrinterDiscovered(DEFAULT_VENDOR_NAME, printerInfo);
82 
83     vendorWlanGroup->SetConnectingPrinter(METHOD_DEFAULT, printerId);
84     vendorWlanGroup->IsGroupDriver(printerId);
85     vendorWlanGroup->IsConnectingPrinter(printerId, printerUri);
86     vendorWlanGroup->OnQueryCapability(printerId, DEFAULT_TIMEOUT);
87     vendorWlanGroup->OnQueryCapabilityByIp(printerUri, DEFAULT_PROTOCOL);
88 
89     vendorWlanGroup->vendorManager = nullptr;
90     vendorWlanGroup->parentVendorManager = nullptr;
91     vendorWlanGroup->SetConnectingPrinter(METHOD_DEFAULT, printerId);
92     vendorWlanGroup->IsGroupDriver(printerId);
93     vendorWlanGroup->IsConnectingPrinter(printerId, printerUri);
94     vendorWlanGroup->OnQueryCapability(printerId, DEFAULT_TIMEOUT);
95     vendorWlanGroup->OnQueryCapabilityByIp(printerUri, DEFAULT_PROTOCOL);
96 }
97 
TestWlanGroupOtherFunction(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)98 void TestWlanGroupOtherFunction(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
99 {
100     VendorManager vendorManager;
101     vendorManager.Init(PrintServiceAbility::GetInstance());
102     auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
103 
104     std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
105     std::string printerBsuriId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
106     std::string ppdData = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
107     PrinterInfo printerInfo;
108     printerInfo.SetPrinterId(printerId);
109     printerInfo.SetPrinterName(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
110     printerInfo.SetUri(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
111     printerInfo.SetPrinterMake(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
112     printerInfo.SetOption(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
113     std::string vendorName = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
114 
115     // other function
116     vendorWlanGroup->OnPrinterPpdQueried(DEFAULT_VENDOR_NAME, printerId, ppdData);
117     vendorWlanGroup->ConvertGroupDriver(printerId, vendorName);
118     vendorWlanGroup->ConvertGroupGlobalPrinterId(printerId);
119     vendorWlanGroup->GetGroupPrinterId(printerId);
120     vendorWlanGroup->UpdateGroupPrinter(printerId, printerBsuriId);
121     vendorWlanGroup->ExtractPrinterIdByPrinterInfo(printerInfo);
122 
123     // other function without vendorManager
124     vendorWlanGroup->vendorManager = nullptr;
125     vendorWlanGroup->parentVendorManager = nullptr;
126     vendorWlanGroup->OnPrinterPpdQueried(DEFAULT_VENDOR_NAME, printerId, ppdData);
127     vendorWlanGroup->ConvertGroupDriver(printerId, vendorName);
128     vendorWlanGroup->ConvertGroupGlobalPrinterId(printerId);
129     vendorWlanGroup->GetGroupPrinterId(printerId);
130     vendorWlanGroup->UpdateGroupPrinter(printerId, printerBsuriId);
131     vendorWlanGroup->ExtractPrinterIdByPrinterInfo(printerInfo);
132 }
133 
TestPpdDriverConnectPrinterActions(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)134 void TestPpdDriverConnectPrinterActions(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
135 {
136     VendorManager vendorManager;
137     vendorManager.Init(PrintServiceAbility::GetInstance());
138     auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
139     auto vendorPpdDriver = vendorManager.FindDriverByVendorName(VENDOR_PPD_DRIVER);
140     if (vendorPpdDriver == nullptr) {
141         return;
142     }
143 
144     std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
145     PrinterInfo printerInfo;
146     printerInfo.SetPrinterId(printerId);
147     printerInfo.SetPrinterName(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
148     std::string printerUri = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
149     printerInfo.SetPrinterMake(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
150     printerInfo.SetUri(printerUri);
151     printerInfo.SetOption(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
152     vendorWlanGroup->OnPrinterDiscovered(DEFAULT_VENDOR_NAME, printerInfo);
153 
154     auto propertyKeys = std::vector<std::string>(1, printerInfo.GetPrinterMake());
155     vendorPpdDriver->OnQueryProperties(printerId, propertyKeys);
156     vendorPpdDriver->OnQueryCapability(printerId, DEFAULT_TIMEOUT);
157 
158     vendorPpdDriver->vendorManager = nullptr;
159     vendorPpdDriver->OnQueryProperties(printerId, propertyKeys);
160     vendorPpdDriver->OnQueryCapability(printerId, DEFAULT_TIMEOUT);
161 }
162 
TestPpdDriverOtherFunction(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)163 void TestPpdDriverOtherFunction(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
164 {
165     VendorManager vendorManager;
166     vendorManager.Init(PrintServiceAbility::GetInstance());
167     auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
168     auto vendorPpdDriver = std::make_shared<VendorPpdDriver>();
169     vendorPpdDriver->Init(&vendorManager);
170     if (vendorPpdDriver == nullptr) {
171         return;
172     }
173 
174     std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
175     std::string ppdData = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
176     PrinterInfo printerInfo;
177     printerInfo.SetPrinterId(printerId);
178     printerInfo.SetPrinterName(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
179     printerInfo.SetUri(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
180     printerInfo.SetPrinterMake(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
181     printerInfo.SetOption(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
182     auto info = make_shared<PrinterInfo>(printerInfo);
183 
184     // other function
185     vendorPpdDriver->AddPrinterToCups(printerId, ppdData);
186     vendorPpdDriver->QueryPrinterCapabilityFromPpd(printerId, ppdData);
187     vendorPpdDriver->UpdateCapability(info);
188 
189     // other function without vendorManager
190     vendorPpdDriver->vendorManager = nullptr;
191     vendorPpdDriver->AddPrinterToCups(printerId, ppdData);
192     vendorPpdDriver->QueryPrinterCapabilityFromPpd(printerId, ppdData);
193     vendorPpdDriver->UpdateCapability(info);
194 }
195 
TestVendorWlanGroup(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)196 void TestVendorWlanGroup(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
197 {
198     TestWlanGroupDiscoverPrinterActions(data, size, dataProvider);
199     TestWlanGroupConnectPrinterActions(data, size, dataProvider);
200     TestWlanGroupOtherFunction(data, size, dataProvider);
201 }
202 
TestVendorPpdDriver(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)203 void TestVendorPpdDriver(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
204 {
205     TestPpdDriverConnectPrinterActions(data, size, dataProvider);
206     TestPpdDriverOtherFunction(data, size, dataProvider);
207 }
208 
209 }  // namespace Print
210 }  // namespace OHOS
211 
212 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)213 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
214 {
215     /* Run your code on data */
216     if (data == nullptr) {
217         return 0;
218     }
219 
220     if (size < OHOS::Print::U32_AT_SIZE) {
221     }
222 
223     FuzzedDataProvider dataProvider(data, size);
224     OHOS::Print::PrintServiceAbilityMockPermission::MockPermission();
225     OHOS::Print::TestVendorWlanGroup(data, size, &dataProvider);
226     OHOS::Print::TestVendorPpdDriver(data, size, &dataProvider);
227     return 0;
228 }
229 
230