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
DoSomethingForWindowManagerImpl(WindowManager & windowManager,const uint8_t * data,size_t size)80 bool DoSomethingForWindowManagerImpl(WindowManager& windowManager, const uint8_t* data, size_t size)
81 {
82 if (data == nullptr || size < DATA_MIN_SIZE) {
83 return false;
84 }
85 size_t startPos = 0;
86 uint32_t accessTokenId;
87 bool isShowing;
88 startPos += GetObject<uint32_t>(accessTokenId, data + startPos, size - startPos);
89 startPos += GetObject<bool>(isShowing, data + startPos, size - startPos);
90 windowManager.UpdateCameraFloatWindowStatus(accessTokenId, isShowing);
91
92 Parcel windowVisibilityInfosParcel;
93 if (windowVisibilityInfosParcel.WriteBuffer(data, size)) {
94 std::vector<sptr<WindowVisibilityInfo>> infos;
95 if (MarshallingHelper::UnmarshallingVectorParcelableObj<WindowVisibilityInfo>(windowVisibilityInfosParcel,
96 infos)) {
97 windowManager.GetVisibilityWindowInfo(infos);
98 windowManager.UpdateWindowVisibilityInfo(infos);
99 }
100 }
101
102 DisplayId displayId;
103 SystemBarRegionTints tints;
104 startPos += GetObject<DisplayId>(displayId, data + startPos, size - startPos);
105 GetObject<SystemBarRegionTints>(tints, data + startPos, size - startPos);
106 windowManager.UpdateSystemBarRegionTints(displayId, tints);
107
108 return true;
109 }
110
CheckAccessibilityWindowInfo(WindowManager & windowManager,const uint8_t * data,size_t size)111 void CheckAccessibilityWindowInfo(WindowManager& windowManager, const uint8_t* data, size_t size)
112 {
113 Parcel accessibilityWindowInfosParcel;
114 if (accessibilityWindowInfosParcel.WriteBuffer(data, size)) {
115 std::vector<sptr<AccessibilityWindowInfo>> infos;
116 if (MarshallingHelper::UnmarshallingVectorParcelableObj<AccessibilityWindowInfo>(accessibilityWindowInfosParcel,
117 infos)) {
118 windowManager.GetAccessibilityWindowInfo(infos);
119 WindowUpdateType type;
120 GetObject<WindowUpdateType>(type, data, size);
121 windowManager.NotifyAccessibilityWindowInfo(infos, type);
122 }
123 }
124 }
125
DoSomethingInterestingWithMyAPI(const uint8_t * data,size_t size)126 bool DoSomethingInterestingWithMyAPI(const uint8_t* data, size_t size)
127 {
128 if (data == nullptr || size < DATA_MIN_SIZE) {
129 return false;
130 }
131 WindowManager& windowManager = WindowManager::GetInstance();
132 CheckAccessibilityWindowInfo(windowManager, data, size);
133
134 Parcel focusChangeInfoParcel;
135 if (focusChangeInfoParcel.WriteBuffer(data, size)) {
136 FocusChangeInfo::Unmarshalling(focusChangeInfoParcel);
137 }
138 Parcel parcel;
139 sptr<FocusChangeInfo> focusChangeInfo = new FocusChangeInfo();
140 focusChangeInfo->Marshalling(parcel);
141
142 Parcel windowVisibilityInfoParcel;
143 if (windowVisibilityInfoParcel.WriteBuffer(data, size)) {
144 WindowVisibilityInfo::Unmarshalling(windowVisibilityInfoParcel);
145 }
146 sptr<WindowVisibilityInfo> windowVisibilityInfo = new WindowVisibilityInfo();
147 windowVisibilityInfo->Marshalling(parcel);
148
149 Parcel accessibilityWindowInfoParcel;
150 if (accessibilityWindowInfoParcel.WriteBuffer(data, size)) {
151 AccessibilityWindowInfo::Unmarshalling(accessibilityWindowInfoParcel);
152 }
153 sptr<AccessibilityWindowInfo> accessibilityWindowInfo = new AccessibilityWindowInfo();
154 accessibilityWindowInfo->Marshalling(parcel);
155
156 windowManager.MinimizeAllAppWindows(static_cast<DisplayId>(data[0]));
157 sptr<IFocusChangedListener> focusChangedListener = new FocusChangedListener();
158 windowManager.RegisterFocusChangedListener(focusChangedListener);
159 sptr<ISystemBarChangedListener> systemBarChangedListener = new SystemBarChangedListener();
160 windowManager.RegisterSystemBarChangedListener(systemBarChangedListener);
161 sptr<IVisibilityChangedListener> visibilityChangedListener = new VisibilityChangedListener();
162 windowManager.RegisterVisibilityChangedListener(visibilityChangedListener);
163 sptr<IWindowUpdateListener> windowUpdateListener = new WindowUpdateListener();
164 windowManager.RegisterWindowUpdateListener(windowUpdateListener);
165 sptr<ICameraFloatWindowChangedListener> cameraFloatWindowChanagedListener = new CameraFloatWindowChangedListener();
166 windowManager.RegisterCameraFloatWindowChangedListener(cameraFloatWindowChanagedListener);
167 windowManager.SetWindowLayoutMode(static_cast<WindowLayoutMode>(data[0]));
168 windowManager.UnregisterFocusChangedListener(focusChangedListener);
169 windowManager.UnregisterSystemBarChangedListener(systemBarChangedListener);
170 windowManager.UnregisterVisibilityChangedListener(visibilityChangedListener);
171 windowManager.UnregisterWindowUpdateListener(windowUpdateListener);
172 windowManager.UnregisterCameraFloatWindowChangedListener(cameraFloatWindowChanagedListener);
173 return true;
174 }
175 } // namespace.OHOS
176
177 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)178 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
179 {
180 /* Run your code on data */
181 OHOS::DoSomethingInterestingWithMyAPI(data, size);
182 return 0;
183 }
184
185