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 <parcel.h>
17
18 #include <securec.h>
19
20 #include "marshalling_helper.h"
21 #include "window_manager.h"
22
23 using namespace OHOS::Rosen;
24
25 namespace OHOS {
26 namespace {
27 constexpr size_t DATA_MIN_SIZE = 2;
28 }
29
30 template<class T>
GetObject(T & object,const uint8_t * data,size_t size)31 size_t GetObject(T &object, const uint8_t *data, size_t size)
32 {
33 size_t objectSize = sizeof(object);
34 if (objectSize > size) {
35 return 0;
36 }
37 return memcpy_s(&object, objectSize, data, objectSize) == EOK ? objectSize : 0;
38 }
39
40 class FocusChangedListener : public IFocusChangedListener {
41 public:
OnFocused(const sptr<FocusChangeInfo> & focusChangeInfo)42 virtual void OnFocused(const sptr<FocusChangeInfo>& focusChangeInfo) override
43 {
44 }
45
OnUnfocused(const sptr<FocusChangeInfo> & focusChangeInfo)46 virtual void OnUnfocused(const sptr<FocusChangeInfo>& focusChangeInfo) override
47 {
48 }
49 };
50
51 class SystemBarChangedListener : public ISystemBarChangedListener {
52 public:
OnSystemBarPropertyChange(DisplayId displayId,const SystemBarRegionTints & tints)53 virtual void OnSystemBarPropertyChange(DisplayId displayId, const SystemBarRegionTints& tints) override
54 {
55 }
56 };
57
58 class VisibilityChangedListener : public IVisibilityChangedListener {
59 public:
OnWindowVisibilityChanged(const std::vector<sptr<WindowVisibilityInfo>> & windowVisibilityInfo)60 virtual void OnWindowVisibilityChanged(const std::vector<sptr<WindowVisibilityInfo>>& windowVisibilityInfo) override
61 {
62 }
63 };
64
65 class WindowUpdateListener : public IWindowUpdateListener {
66 public:
OnWindowUpdate(const std::vector<sptr<AccessibilityWindowInfo>> & infos,WindowUpdateType type)67 virtual void OnWindowUpdate(const std::vector<sptr<AccessibilityWindowInfo>>& infos, WindowUpdateType type) override
68 {
69 }
70 };
71
72 class CameraFloatWindowChangedListener : public ICameraFloatWindowChangedListener {
73 public:
OnCameraFloatWindowChange(uint32_t accessTokenId,bool isShowing)74 void OnCameraFloatWindowChange(uint32_t accessTokenId, bool isShowing) override
75 {
76 }
77 };
78
79 class WaterMarkFlagChangedListener : public IWaterMarkFlagChangedListener {
80 public:
OnWaterMarkFlagUpdate(bool showWaterMark)81 void OnWaterMarkFlagUpdate(bool showWaterMark) override
82 {
83 }
84 };
85
86 class GestureNavigationEnabledChangedListener : public IGestureNavigationEnabledChangedListener {
87 public:
OnGestureNavigationEnabledUpdate(bool enable)88 void OnGestureNavigationEnabledUpdate(bool enable) override
89 {
90 }
91 };
92
DoSomethingForWindowManagerImpl(WindowManager & windowManager,const uint8_t * data,size_t size)93 bool DoSomethingForWindowManagerImpl(WindowManager& windowManager, const uint8_t* data, size_t size)
94 {
95 if (data == nullptr || size < DATA_MIN_SIZE) {
96 return false;
97 }
98 size_t startPos = 0;
99 uint32_t accessTokenId;
100 bool isShowing;
101 startPos += GetObject<uint32_t>(accessTokenId, data + startPos, size - startPos);
102 startPos += GetObject<bool>(isShowing, data + startPos, size - startPos);
103 windowManager.UpdateCameraFloatWindowStatus(accessTokenId, isShowing);
104 bool enable;
105 startPos += GetObject<bool>(enable, data + startPos, size - startPos);
106 windowManager.SetGestureNavigaionEnabled(enable);
107
108 Parcel windowVisibilityInfosParcel;
109 if (windowVisibilityInfosParcel.WriteBuffer(data, size)) {
110 std::vector<sptr<WindowVisibilityInfo>> infos;
111 if (MarshallingHelper::UnmarshallingVectorParcelableObj<WindowVisibilityInfo>(windowVisibilityInfosParcel,
112 infos)) {
113 windowManager.GetVisibilityWindowInfo(infos);
114 windowManager.UpdateWindowVisibilityInfo(infos);
115 }
116 }
117
118 DisplayId displayId;
119 SystemBarRegionTints tints;
120 startPos += GetObject<DisplayId>(displayId, data + startPos, size - startPos);
121 GetObject<SystemBarRegionTints>(tints, data + startPos, size - startPos);
122 windowManager.UpdateSystemBarRegionTints(displayId, tints);
123
124 return true;
125 }
126
CheckAccessibilityWindowInfo(WindowManager & windowManager,const uint8_t * data,size_t size)127 void CheckAccessibilityWindowInfo(WindowManager& windowManager, const uint8_t* data, size_t size)
128 {
129 Parcel accessibilityWindowInfosParcel;
130 if (accessibilityWindowInfosParcel.WriteBuffer(data, size)) {
131 std::vector<sptr<AccessibilityWindowInfo>> infos;
132 if (MarshallingHelper::UnmarshallingVectorParcelableObj<AccessibilityWindowInfo>(accessibilityWindowInfosParcel,
133 infos)) {
134 windowManager.GetAccessibilityWindowInfo(infos);
135 WindowUpdateType type;
136 GetObject<WindowUpdateType>(type, data, size);
137 windowManager.NotifyAccessibilityWindowInfo(infos, type);
138 }
139 }
140 }
141
DoSomethingInterestingWithMyAPI(const uint8_t * data,size_t size)142 bool DoSomethingInterestingWithMyAPI(const uint8_t* data, size_t size)
143 {
144 if (data == nullptr || size < DATA_MIN_SIZE) {
145 return false;
146 }
147 WindowManager& windowManager = WindowManager::GetInstance();
148 CheckAccessibilityWindowInfo(windowManager, data, size);
149 Parcel focusChangeInfoParcel;
150 if (focusChangeInfoParcel.WriteBuffer(data, size)) {
151 FocusChangeInfo::Unmarshalling(focusChangeInfoParcel);
152 }
153 Parcel parcel;
154 sptr<FocusChangeInfo> focusChangeInfo = new FocusChangeInfo();
155 focusChangeInfo->Marshalling(parcel);
156 Parcel windowVisibilityInfoParcel;
157 if (windowVisibilityInfoParcel.WriteBuffer(data, size)) {
158 WindowVisibilityInfo::Unmarshalling(windowVisibilityInfoParcel);
159 }
160 sptr<WindowVisibilityInfo> windowVisibilityInfo = new WindowVisibilityInfo();
161 windowVisibilityInfo->Marshalling(parcel);
162 Parcel accessibilityWindowInfoParcel;
163 if (accessibilityWindowInfoParcel.WriteBuffer(data, size)) {
164 AccessibilityWindowInfo::Unmarshalling(accessibilityWindowInfoParcel);
165 }
166 sptr<AccessibilityWindowInfo> accessibilityWindowInfo = new AccessibilityWindowInfo();
167 accessibilityWindowInfo->Marshalling(parcel);
168 windowManager.MinimizeAllAppWindows(static_cast<DisplayId>(data[0]));
169 sptr<IFocusChangedListener> focusChangedListener = new FocusChangedListener();
170 windowManager.RegisterFocusChangedListener(focusChangedListener);
171 sptr<ISystemBarChangedListener> systemBarChangedListener = new SystemBarChangedListener();
172 windowManager.RegisterSystemBarChangedListener(systemBarChangedListener);
173 sptr<IVisibilityChangedListener> visibilityChangedListener = new VisibilityChangedListener();
174 windowManager.RegisterVisibilityChangedListener(visibilityChangedListener);
175 sptr<IWindowUpdateListener> windowUpdateListener = new WindowUpdateListener();
176 windowManager.RegisterWindowUpdateListener(windowUpdateListener);
177 sptr<ICameraFloatWindowChangedListener> cameraFloatWindowChanagedListener = new CameraFloatWindowChangedListener();
178 windowManager.RegisterCameraFloatWindowChangedListener(cameraFloatWindowChanagedListener);
179 windowManager.SetWindowLayoutMode(static_cast<WindowLayoutMode>(data[0]));
180 windowManager.UnregisterFocusChangedListener(focusChangedListener);
181 windowManager.UnregisterSystemBarChangedListener(systemBarChangedListener);
182 windowManager.UnregisterVisibilityChangedListener(visibilityChangedListener);
183 windowManager.UnregisterWindowUpdateListener(windowUpdateListener);
184 windowManager.UnregisterCameraFloatWindowChangedListener(cameraFloatWindowChanagedListener);
185 sptr<IWaterMarkFlagChangedListener> waterMarkFlagChangedListener = new WaterMarkFlagChangedListener();
186 windowManager.RegisterWaterMarkFlagChangedListener(waterMarkFlagChangedListener);
187 windowManager.UnregisterWaterMarkFlagChangedListener(waterMarkFlagChangedListener);
188 sptr<IGestureNavigationEnabledChangedListener> gestureListener = new GestureNavigationEnabledChangedListener();
189 windowManager.RegisterGestureNavigationEnabledChangedListener(gestureListener);
190 windowManager.UnregisterGestureNavigationEnabledChangedListener(gestureListener);
191 return true;
192 }
193 } // namespace.OHOS
194
195 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)196 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
197 {
198 /* Run your code on data */
199 OHOS::DoSomethingInterestingWithMyAPI(data, size);
200 return 0;
201 }
202
203