1 /*
2 * Copyright (c) 2022-2023 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 "notification_constant.h"
17 #include "notification_content.h"
18 #include "notification_normal_content.h"
19 #include "refbase.h"
20 #include <memory>
21 #include <new>
22 #include <string>
23 #include <vector>
24 #define private public
25 #define protected public
26 #include "ans_manager_proxy.h"
27 #include "ans_manager_stub.h"
28 #include "ans_subscriber_stub.h"
29 #undef private
30 #undef protected
31 #include "ansmanagerstub_fuzzer.h"
32 #include "notification_request.h"
33 #include "ans_permission_def.h"
34
35 constexpr uint8_t SLOT_TYPE_NUM = 5;
36
37 namespace OHOS {
DoSomethingInterestingWithMyAPI(FuzzData fuzzData)38 bool DoSomethingInterestingWithMyAPI(FuzzData fuzzData)
39 {
40 std::string stringData = fuzzData.GenerateRandomString();
41 int32_t intData = fuzzData.GenerateRandomInt32();
42 bool boolData = fuzzData.GenerateRandomBool();
43 Notification::AnsManagerStub ansManagerStub;
44 MessageParcel datas;
45 MessageParcel reply;
46 MessageOption flags;
47 // test HandleIsNeedSilentInDoNotDisturbMode function
48 ansManagerStub.HandleIsNeedSilentInDoNotDisturbMode(datas, reply);
49 // test HandleRegisterSwingCallback function
50 #ifdef NOTIFICATION_SMART_REMINDER_SUPPORTED
51 ansManagerStub.HandleRegisterSwingCallback(datas, reply);
52 #endif
53 ansManagerStub.OnRemoteRequest(0, datas, reply, flags);
54 ansManagerStub.OnRemoteRequest((int) Notification::NotificationInterfaceCode::PUBLISH_NOTIFICATION,
55 datas, reply, flags);
56 sptr<Notification::NotificationRequest> notification = new Notification::NotificationRequest();
57 notification->SetOwnerUid(fuzzData.GenerateRandomInt32());
58 notification->SetCreatorUid(fuzzData.GenerateRandomInt32());
59 notification->SetSlotType(Notification::NotificationConstant::SlotType::LIVE_VIEW);
60 auto content = std::make_shared<Notification::NotificationLiveViewContent>();
61 notification->SetContent(std::make_shared<Notification::NotificationContent>(content));
62
63 sptr<Notification::NotificationBundleOption> bundleOption = new Notification::NotificationBundleOption();
64 bundleOption->SetBundleName(fuzzData.GenerateRandomString());
65 bundleOption->SetUid(fuzzData.GenerateRandomInt32());
66
67 sptr<Notification::NotificationButtonOption> buttonOption = new Notification::NotificationButtonOption();
68
69 sptr<Notification::AnsSubscriberStub> subscriber = new Notification::AnsSubscriberStub();
70 sptr<Notification::NotificationSubscribeInfo> info = new Notification::NotificationSubscribeInfo();
71
72 sptr<Notification::NotificationSlot> slot = new Notification::NotificationSlot();
73 std::vector<sptr<Notification::NotificationSlot>> slots {slot};
74
75 uint8_t type = fuzzData.GetData<uint8_t>() % SLOT_TYPE_NUM;
76
77 sptr<Notification::NotificationDoNotDisturbDate> distribuDate = new Notification::NotificationDoNotDisturbDate();
78
79 datas.WriteString(stringData);
80 datas.WriteParcelable(notification);
81 ansManagerStub.HandlePublish(datas, reply);
82 datas.WriteInt32(intData);
83 datas.WriteString(stringData);
84 datas.WriteInt32(intData);
85 ansManagerStub.HandleCancelAsBundle(datas, reply);
86 datas.WriteParcelable(bundleOption);
87 datas.WriteInt32(intData);
88 ansManagerStub.HandleCancelAsBundleOption(datas, reply);
89 datas.WriteInt32(intData);
90 ansManagerStub.HandleCancelAll(datas, reply);
91 datas.WriteInt32(intData);
92 datas.WriteString(stringData);
93 datas.WriteInt32(intData);
94 ansManagerStub.HandleCancel(datas, reply);
95 datas.WriteParcelable(bundleOption);
96 datas.WriteInt32(intData);
97 datas.WriteInt32(intData);
98 ansManagerStub.HandleCancelAsBundleAndUser(datas, reply);
99 datas.WriteInt32(type);
100 ansManagerStub.HandleAddSlotByType(datas, reply);
101 ansManagerStub.HandleAddSlots(datas, reply);
102 datas.WriteInt32(type);
103 ansManagerStub.HandleRemoveSlotByType(datas, reply);
104 ansManagerStub.HandleRemoveAllSlots(datas, reply);
105 ansManagerStub.HandleGetSlots(datas, reply);
106 datas.WriteInt32(type);
107 ansManagerStub.HandleGetSlotByType(datas, reply);
108 datas.WriteParcelable(bundleOption);
109 ansManagerStub.HandleGetSlotNumAsBundle(datas, reply);
110 datas.WriteParcelable(bundleOption);
111 datas.WriteInt32(intData);
112 ansManagerStub.HandleSetSlotFlagsAsBundle(datas, reply);
113 datas.WriteParcelable(bundleOption);
114 ansManagerStub.HandleGetSlotFlagsAsBundle(datas, reply);
115 datas.WriteInt32(intData);
116 ansManagerStub.HandleGetActiveNotifications(datas, reply);
117 ansManagerStub.HandleGetActiveNotificationNums(datas, reply);
118 ansManagerStub.HandleGetAllActiveNotifications(datas, reply);
119 std::vector<std::string> stringVector { stringData };
120 datas.WriteStringVector(stringVector);
121 ansManagerStub.HandleGetSpecialActiveNotifications(datas, reply);
122 datas.WriteParcelable(bundleOption);
123 datas.WriteInt32(intData);
124 datas.WriteString(stringData);
125 datas.WriteStringVector(stringVector);
126 ansManagerStub.HandleGetActiveNotificationByFilter(datas, reply);
127 datas.WriteString(stringData);
128 ansManagerStub.HandleSetNotificationAgent(datas, reply);
129 ansManagerStub.HandleGetNotificationAgent(datas, reply);
130 datas.WriteString(stringData);
131 ansManagerStub.HandleCanPublishAsBundle(datas, reply);
132 datas.WriteParcelable(notification);
133 datas.WriteString(stringData);
134 ansManagerStub.HandlePublishAsBundle(datas, reply);
135 datas.WriteInt32(intData);
136 ansManagerStub.HandleSetNotificationBadgeNum(datas, reply);
137 ansManagerStub.HandleGetBundleImportance(datas, reply);
138 datas.WriteParcelable(distribuDate);
139 ansManagerStub.HandleSetDoNotDisturbDate(datas, reply);
140 ansManagerStub.HandleGetDoNotDisturbDate(datas, reply);
141 ansManagerStub.HandleDoesSupportDoNotDisturbMode(datas, reply);
142 datas.WriteParcelable(notification);
143 datas.WriteInt32(intData);
144 ansManagerStub.HandlePublishContinuousTaskNotification(datas, reply);
145 datas.WriteString(stringData);
146 datas.WriteInt32(intData);
147 ansManagerStub.HandleCancelContinuousTaskNotification(datas, reply);
148 ansManagerStub.HandleIsNotificationPolicyAccessGranted(datas, reply);
149 datas.WriteParcelable(bundleOption);
150 datas.WriteInt32(intData);
151 datas.WriteParcelable(buttonOption);
152 ansManagerStub.HandleTriggerLocalLiveView(datas, reply);
153 datas.WriteParcelable(bundleOption);
154 datas.WriteInt32(intData);
155 datas.WriteString(stringData);
156 datas.WriteInt32(intData);
157 ansManagerStub.HandleRemoveNotification(datas, reply);
158 ansManagerStub.HandleRemoveAllNotifications(datas, reply);
159 datas.WriteInt32(intData);
160 datas.WriteStringVector(stringVector);
161 datas.WriteInt32(intData);
162 ansManagerStub.HandleRemoveNotifications(datas, reply);
163 datas.WriteString(stringData);
164 datas.WriteInt32(intData);
165 ansManagerStub.HandleDelete(datas, reply);
166 datas.WriteParcelable(bundleOption);
167 ansManagerStub.HandleDeleteByBundle(datas, reply);
168 ansManagerStub.HandleDeleteAll(datas, reply);
169 datas.WriteParcelable(bundleOption);
170 datas.WriteInt32(intData);
171 ansManagerStub.HandleGetSlotByBundle(datas, reply);
172 ansManagerStub.HandleGetSlotsByBundle(datas, reply);
173 datas.WriteParcelable(bundleOption);
174 ansManagerStub.HandleUpdateSlots(datas, reply);
175 datas.WriteString(stringData);
176 datas.WriteRemoteObject(subscriber);
177 datas.WriteBool(boolData);
178 if (boolData) {
179 datas.WriteRemoteObject(subscriber);
180 }
181 ansManagerStub.HandleRequestEnableNotification(datas, reply);
182 datas.WriteString(stringData);
183 datas.WriteBool(boolData);
184 ansManagerStub.HandleSetNotificationsEnabledForBundle(datas, reply);
185 datas.WriteString(stringData);
186 datas.WriteBool(boolData);
187 ansManagerStub.HandleSetNotificationsEnabledForAllBundles(datas, reply);
188 datas.WriteString(stringData);
189 datas.WriteParcelable(bundleOption);
190 datas.WriteBool(boolData);
191 ansManagerStub.HandleSetNotificationsEnabledForSpecialBundle(datas, reply);
192 datas.WriteParcelable(bundleOption);
193 datas.WriteBool(boolData);
194 ansManagerStub.HandleSetShowBadgeEnabledForBundle(datas, reply);
195 datas.WriteParcelable(bundleOption);
196 ansManagerStub.HandleGetShowBadgeEnabledForBundle(datas, reply);
197 ansManagerStub.HandleGetShowBadgeEnabled(datas, reply);
198 datas.WriteRemoteObject(subscriber);
199 datas.WriteBool(boolData);
200 if (boolData) {
201 datas.WriteParcelable(info);
202 }
203 ansManagerStub.HandleSubscribe(datas, reply);
204 datas.WriteRemoteObject(subscriber);
205 ansManagerStub.HandleSubscribeSelf(datas, reply);
206 datas.WriteRemoteObject(subscriber);
207 datas.WriteBool(boolData);
208 if (boolData) {
209 datas.WriteParcelable(info);
210 }
211 datas.WriteBool(boolData);
212 ansManagerStub.HandleSubscribeLocalLiveView(datas, reply);
213 datas.WriteRemoteObject(subscriber);
214 datas.WriteBool(boolData);
215 if (boolData) {
216 datas.WriteParcelable(info);
217 }
218 ansManagerStub.HandleUnsubscribe(datas, reply);
219 ansManagerStub.HandleIsAllowedNotify(datas, reply);
220 ansManagerStub.HandleIsAllowedNotifySelf(datas, reply);
221 datas.WriteRemoteObject(subscriber);
222 ansManagerStub.HandleCanPopEnableNotificationDialog(datas, reply);
223 datas.WriteParcelable(bundleOption);
224 ansManagerStub.HandleIsSpecialBundleAllowedNotify(datas, reply);
225 datas.WriteString(stringData);
226 datas.WriteInt32(intData);
227 ansManagerStub.HandleCancelGroup(datas, reply);
228 datas.WriteParcelable(bundleOption);
229 datas.WriteString(stringData);
230 ansManagerStub.HandleRemoveGroupByBundle(datas, reply);
231 ansManagerStub.HandleIsDistributedEnabled(datas, reply);
232 datas.WriteBool(boolData);
233 ansManagerStub.HandleEnableDistributed(datas, reply);
234 datas.WriteParcelable(bundleOption);
235 datas.WriteBool(boolData);
236 ansManagerStub.HandleEnableDistributedByBundle(datas, reply);
237 datas.WriteBool(boolData);
238 ansManagerStub.HandleEnableDistributedSelf(datas, reply);
239 datas.WriteParcelable(bundleOption);
240 ansManagerStub.HandleIsDistributedEnableByBundle(datas, reply);
241 ansManagerStub.HandleGetDeviceRemindType(datas, reply);
242 datas.WriteString(stringData);
243 datas.WriteString(stringData);
244 datas.WriteInt32(intData);
245 datas.WriteInt32(intData);
246 ansManagerStub.HandleShellDump(datas, reply);
247 ansManagerStub.HandlePublishReminder(datas, reply);
248 datas.WriteInt32(intData);
249 ansManagerStub.HandleCancelReminder(datas, reply);
250 ansManagerStub.HandleCancelAllReminders(datas, reply);
251 ansManagerStub.HandleGetValidReminders(datas, reply);
252 datas.WriteInt32(intData);
253 datas.WriteUint64(intData);
254 ansManagerStub.HandleAddExcludeDate(datas, reply);
255 datas.WriteInt32(intData);
256 ansManagerStub.HandleDelExcludeDates(datas, reply);
257 datas.WriteInt32(intData);
258 ansManagerStub.HandleGetExcludeDates(datas, reply);
259 datas.WriteString(stringData);
260 ansManagerStub.HandleIsSupportTemplate(datas, reply);
261 datas.WriteInt32(intData);
262 ansManagerStub.HandleIsSpecialUserAllowedNotifyByUser(datas, reply);
263 datas.WriteInt32(intData);
264 datas.WriteBool(boolData);
265 ansManagerStub.HandleSetNotificationsEnabledByUser(datas, reply);
266 datas.WriteInt32(intData);
267 ansManagerStub.HandleDeleteAllByUser(datas, reply);
268 datas.WriteInt32(intData);
269 datas.WriteParcelable(distribuDate);
270 ansManagerStub.HandleSetDoNotDisturbDateByUser(datas, reply);
271 datas.WriteInt32(intData);
272 ansManagerStub.HandleGetDoNotDisturbDateByUser(datas, reply);
273 datas.WriteParcelable(bundleOption);
274 datas.WriteInt32(type);
275 datas.WriteBool(boolData);
276 datas.WriteBool(boolData);
277 ansManagerStub.HandleSetEnabledForBundleSlot(datas, reply);
278 datas.WriteParcelable(bundleOption);
279 datas.WriteInt32(type);
280 ansManagerStub.HandleGetEnabledForBundleSlot(datas, reply);
281 datas.WriteInt32(type);
282 ansManagerStub.HandleGetEnabledForBundleSlotSelf(datas, reply);
283 datas.WriteInt32(intData);
284 datas.WriteBool(boolData);
285 ansManagerStub.HandleDistributedSetEnabledWithoutApp(datas, reply);
286 datas.WriteInt32(intData);
287 ansManagerStub.HandleDistributedGetEnabledWithoutApp(datas, reply);
288 datas.WriteInt32(intData);
289 datas.WriteInt32(intData);
290 ansManagerStub.HandleSetBadgeNumber(datas, reply);
291 datas.WriteParcelable(bundleOption);
292 datas.WriteInt32(intData);
293 ansManagerStub.HandleSetBadgeNumberByBundle(datas, reply);
294 ansManagerStub.HandleGetAllNotificationEnableStatus(datas, reply);
295 ansManagerStub.HandleRegisterPushCallback(datas, reply);
296 ansManagerStub.HandleUnregisterPushCallback(datas, reply);
297 ansManagerStub.HandleAddDoNotDisturbProfiles(datas, reply);
298 datas.WriteParcelable(bundleOption);
299 datas.WriteString(stringData);
300 datas.WriteBool(boolData);
301 ansManagerStub.HandleSetDistributedEnabledByBundle(datas, reply);
302 ansManagerStub.HandleRemoveDoNotDisturbProfiles(datas, reply);
303 datas.WriteParcelable(bundleOption);
304 datas.WriteString(stringData);
305 ansManagerStub.HandleIsDistributedEnabledByBundle(datas, reply);
306 datas.WriteString(stringData);
307 datas.WriteBool(boolData);
308 ansManagerStub.HandleSetSmartReminderEnabled(datas, reply);
309 datas.WriteString(stringData);
310 ansManagerStub.HandleIsSmartReminderEnabled(datas, reply);
311 datas.WriteString(stringData);
312 datas.WriteString(stringData);
313 ansManagerStub.HandleSetAdditionConfig(datas, reply);
314 datas.WriteParcelable(bundleOption);
315 datas.WriteInt32(intData);
316 ansManagerStub.HandleCancelAsBundleWithAgent(datas, reply);
317 datas.WriteString(stringData);
318 datas.WriteInt32(intData);
319 ansManagerStub.HandleSetTargetDeviceStatus(datas, reply);
320 datas.WriteInt32(intData);
321 datas.WriteBool(boolData);
322 ansManagerStub.HandleUpdateNotificationTimerByUid(datas, reply);
323 sptr<Notification::NotificationRequest> notification2 = new Notification::NotificationRequest();
324 notification2->SetOwnerUid(fuzzData.GenerateRandomInt32());
325 notification2->SetCreatorUid(fuzzData.GenerateRandomInt32());
326 notification2->SetSlotType(Notification::NotificationConstant::SlotType::SOCIAL_COMMUNICATION);
327 auto content2 = std::make_shared<Notification::NotificationNormalContent>();
328 notification2->SetContent(std::make_shared<Notification::NotificationContent>(content2));
329 ansManagerStub.Publish(stringData, notification2);
330 int notificationId = fuzzData.GetData<int>();
331 ansManagerStub.Cancel(notificationId, stringData, 0);
332 ansManagerStub.CancelAll(0);
333 int32_t userId = fuzzData.GetData<int32_t>();
334 ansManagerStub.CancelAsBundle(notificationId, stringData, userId);
335 Notification::NotificationConstant::SlotType slotType = Notification::NotificationConstant::SlotType(type);
336 ansManagerStub.AddSlotByType(slotType);
337 ansManagerStub.AddSlots(slots);
338 ansManagerStub.RemoveSlotByType(slotType);
339 ansManagerStub.RemoveAllSlots();
340 ansManagerStub.GetSlotByType(slotType, slot);
341 ansManagerStub.GetSlots(slots);
342 uint64_t num = fuzzData.GetData<uint64_t>();
343 ansManagerStub.GetSlotNumAsBundle(bundleOption, num);
344 std::vector<sptr<Notification::NotificationRequest>> notifications;
345 ansManagerStub.GetActiveNotifications(notifications, 0);
346 ansManagerStub.GetActiveNotificationNums(num);
347 std::vector<sptr<Notification::Notification>> notificationss;
348 ansManagerStub.GetAllActiveNotifications(notificationss);
349 std::vector<std::string> key;
350 ansManagerStub.GetSpecialActiveNotifications(key, notificationss);
351 ansManagerStub.SetNotificationAgent(stringData);
352 ansManagerStub.GetNotificationAgent(stringData);
353 bool canPublish = fuzzData.GenerateRandomBool();
354 ansManagerStub.CanPublishAsBundle(stringData, canPublish);
355 ansManagerStub.PublishAsBundle(notification, stringData);
356 ansManagerStub.SetNotificationBadgeNum(num);
357 int importance = fuzzData.GetData<int>();
358 ansManagerStub.GetBundleImportance(importance);
359 bool granted = fuzzData.GenerateRandomBool();
360 ansManagerStub.HasNotificationPolicyAccessPermission(granted);
361 int32_t removeReason = fuzzData.GetData<int32_t>();
362 ansManagerStub.RemoveNotification(bundleOption, notificationId, stringData, removeReason);
363 ansManagerStub.RemoveAllNotifications(bundleOption);
364 ansManagerStub.Delete(stringData, removeReason);
365 ansManagerStub.DeleteByBundle(bundleOption);
366 ansManagerStub.DeleteAll();
367 ansManagerStub.GetSlotsByBundle(bundleOption, slots);
368 ansManagerStub.UpdateSlots(bundleOption, slots);
369 sptr<Notification::AnsDialogCallback> dialogCallback = nullptr;
370 sptr<IRemoteObject> callerToken = nullptr;
371 ansManagerStub.RequestEnableNotification(stringData, dialogCallback, callerToken);
372 bool enabled = fuzzData.GenerateRandomBool();
373 ansManagerStub.SetNotificationsEnabledForBundle(stringData, enabled);
374 ansManagerStub.SetNotificationsEnabledForSpecialBundle(stringData, bundleOption, enabled);
375 ansManagerStub.SetShowBadgeEnabledForBundle(bundleOption, enabled);
376 ansManagerStub.GetShowBadgeEnabledForBundle(bundleOption, enabled);
377 ansManagerStub.GetShowBadgeEnabled(enabled);
378 bool allowed = fuzzData.GenerateRandomBool();
379 ansManagerStub.IsAllowedNotify(allowed);
380 ansManagerStub.IsSpecialBundleAllowedNotify(bundleOption, allowed);
381 ansManagerStub.CancelGroup(stringData, 0);
382 ansManagerStub.RemoveGroupByBundle(bundleOption, stringData);
383 sptr<Notification::NotificationDoNotDisturbDate> date = new Notification::NotificationDoNotDisturbDate();
384 ansManagerStub.SetDoNotDisturbDate(date);
385 ansManagerStub.GetDoNotDisturbDate(date);
386 bool doesSupport = fuzzData.GenerateRandomBool();
387 ansManagerStub.DoesSupportDoNotDisturbMode(doesSupport);
388 ansManagerStub.IsDistributedEnabled(enabled);
389 ansManagerStub.EnableDistributedByBundle(bundleOption, enabled);
390 ansManagerStub.EnableDistributedSelf(enabled);
391 ansManagerStub.IsDistributedEnableByBundle(bundleOption, enabled);
392 Notification::NotificationConstant::RemindType remindType;
393 ansManagerStub.GetDeviceRemindType(remindType);
394 sptr<Notification::NotificationRequest> request = new Notification::NotificationRequest();
395 ansManagerStub.PublishContinuousTaskNotification(request);
396 ansManagerStub.CancelContinuousTaskNotification(stringData, notificationId);
397 sptr<Notification::ReminderRequest> reminder = new Notification::ReminderRequest();
398 ansManagerStub.PublishReminder(reminder);
399 int32_t reminderId = fuzzData.GetData<int32_t>();
400 ansManagerStub.CancelReminder(reminderId);
401 std::vector<sptr<Notification::ReminderRequest>> reminders;
402 ansManagerStub.GetValidReminders(reminders);
403 ansManagerStub.CancelAllReminders();
404 uint64_t excludeDate = fuzzData.GetData<uint64_t>();
405 ansManagerStub.AddExcludeDate(reminderId, excludeDate);
406 ansManagerStub.DelExcludeDates(reminderId);
407 std::vector<uint64_t> excludeDates;
408 ansManagerStub.GetExcludeDates(reminderId, excludeDates);
409 bool support = fuzzData.GenerateRandomBool();
410 ansManagerStub.IsSupportTemplate(stringData, support);
411 ansManagerStub.IsSpecialUserAllowedNotify(userId, allowed);
412 int32_t deviceIds = fuzzData.GetData<int32_t>();
413 ansManagerStub.SetNotificationsEnabledByUser(deviceIds, enabled);
414 ansManagerStub.DeleteAllByUser(userId);
415 ansManagerStub.SetDoNotDisturbDate(date);
416 ansManagerStub.GetDoNotDisturbDate(date);
417 ansManagerStub.SetEnabledForBundleSlot(bundleOption, slotType, enabled, false);
418 ansManagerStub.GetEnabledForBundleSlot(bundleOption, slotType, enabled);
419 std::vector<std::string> dumpInfo;
420 ansManagerStub.ShellDump(stringData, stringData, userId, userId, dumpInfo);
421 ansManagerStub.SetSyncNotificationEnabledWithoutApp(userId, enabled);
422 ansManagerStub.GetSyncNotificationEnabledWithoutApp(userId, enabled);
423 return true;
424 }
425 }
426
427 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)428 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
429 {
430 /* Run your code on data */
431 if (data != nullptr && size >= GetU32Size()) {
432 OHOS::FuzzData fuzzData(data, size);
433 std::vector<std::string> requestPermission = {
434 OHOS::Notification::OHOS_PERMISSION_NOTIFICATION_CONTROLLER,
435 OHOS::Notification::OHOS_PERMISSION_NOTIFICATION_AGENT_CONTROLLER,
436 OHOS::Notification::OHOS_PERMISSION_SET_UNREMOVABLE_NOTIFICATION
437 };
438 NativeTokenGet(requestPermission);
439 OHOS::DoSomethingInterestingWithMyAPI(fuzzData);
440 }
441 return 0;
442 }
443