1 /*
2 * Copyright (c) 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 #include "medialibraryrefreshmanager.h"
16
17 #include <fstream>
18 #include <fuzzer/FuzzedDataProvider.h>
19
20 #include "albums_refresh_manager.h"
21 #include "ability_context_impl.h"
22 #include "medialibrary_errno.h"
23 #include "medialibrary_kvstore_manager.h"
24 #include "medialibrary_type_const.h"
25 #include "medialibrary_tracer.h"
26 #include "media_log.h"
27 #include "result_set_utils.h"
28 #include "media_file_utils.h"
29 #include "media_file_uri.h"
30 #include "medialibrary_unistore_manager.h"
31 #include "medialibrary_rdb_transaction.h"
32 #include "medialibrary_notify.h"
33 #include "userfilemgr_uri.h"
34 #include "media_refresh_album_column.h"
35 #include "albums_refresh_worker.h"
36 #include "albums_refresh_notify.h"
37 #include "rdb_sql_utils.h"
38 #include "result_set_utils.h"
39 #include "photo_album_column.h"
40 #include "medialibrary_rdb_utils.h"
41 #include "vision_column.h"
42 #include "medialibrary_restore.h"
43 #include "post_event_utils.h"
44 #include "medialibrary_data_manager.h"
45 #include "medialibrary_unistore.h"
46 #include "media_datashare_ext_ability.h"
47 #ifdef HAS_POWER_MANAGER_PART
48 #include "power_mgr_client.h"
49 #endif
50
51 namespace OHOS {
52 using namespace std;
53 using namespace DataShare;
54 using namespace Media;
55 using ChangeType = DataShare::DataShareObserver::ChangeType;
56
57 std::shared_ptr<Media::MediaLibraryRdbStore> g_rdbStore;
58 static const int32_t NUM_BYTES = 8;
59 static const int32_t MAX_BYTE_VALUE = 256;
60 static const int32_t SEED_SIZE = 1024;
61 static const int32_t VAL_ONE = 1;
62 FuzzedDataProvider *provider = nullptr;
63
FuzzUri()64 static inline Uri FuzzUri()
65 {
66 int32_t value = provider->ConsumeIntegralInRange<int32_t>(0,
67 static_cast<uint8_t>(Media::EXTENSION_FUZZER_URI_LISTS.size() - VAL_ONE));
68 return Uri(Media::EXTENSION_FUZZER_URI_LISTS[value]);
69 }
70
FuzzListUri()71 static inline std::list<Uri> FuzzListUri()
72 {
73 std::list<Uri> uri = {FuzzUri()};
74 return uri;
75 }
76
FuzzVector()77 static inline std::vector<std::string> FuzzVector()
78 {
79 return {provider->ConsumeBytesAsString(NUM_BYTES)};
80 }
81
FuzzUnorderedSet()82 static inline std::unordered_set<std::string> FuzzUnorderedSet()
83 {
84 std::unordered_set<std::string> orderset = {provider->ConsumeBytesAsString(NUM_BYTES)};
85 return orderset;
86 }
87
FuzzNotifyTypeCause()88 static inline Media::NotifyType FuzzNotifyTypeCause()
89 {
90 int32_t value = provider->ConsumeIntegralInRange<int32_t>(0,
91 static_cast<int32_t>(Media::NotifyType::NOTIFY_INVALID));
92 return static_cast<Media::NotifyType>(value);
93 }
94
FuzzChangeType()95 static inline ChangeType FuzzChangeType()
96 {
97 int32_t value = provider->ConsumeIntegralInRange<int32_t>(0,
98 static_cast<int32_t>(ChangeType::OTHER));
99 return static_cast<ChangeType>(value);
100 }
101
FuzzForceRefreshTypeCause()102 static inline Media::ForceRefreshType FuzzForceRefreshTypeCause()
103 {
104 int32_t value = provider->ConsumeIntegralInRange<int32_t>(0,
105 static_cast<int32_t>(Media::ForceRefreshType::EXCEPTION));
106 return static_cast<Media::ForceRefreshType>(value);
107 }
108
FuzzCloudSyncNotifyInfo()109 static inline Media::CloudSyncNotifyInfo FuzzCloudSyncNotifyInfo()
110 {
111 Media::CloudSyncNotifyInfo info;
112 const void* infodata = nullptr;
113 ChangeType type = FuzzChangeType();
114 info.uris = FuzzListUri();
115 info.type = type;
116 info.data = infodata;
117 return info;
118 }
119
FuzzSyncNotifyInfo()120 static Media::SyncNotifyInfo FuzzSyncNotifyInfo()
121 {
122 Media::SyncNotifyInfo info;
123 info.taskType = provider->ConsumeIntegralInRange<uint16_t>(0, TIME_IN_SYNC);
124 info.syncType = provider->ConsumeIntegralInRange<uint16_t>(0, TIME_IN_SYNC);
125 info.notifyType = FuzzNotifyTypeCause();
126 info.syncId = provider->ConsumeBytesAsString(NUM_BYTES);
127 info.totalAssets = provider->ConsumeIntegralInRange<uint32_t>(0, INT32_MAX);
128 info.totalAlbums = provider->ConsumeIntegralInRange<uint32_t>(0, INT32_MAX);
129 info.uriType = provider->ConsumeIntegralInRange<uint8_t>(0, OTHER_URI_TYPE);
130 info.reserve = provider->ConsumeIntegralInRange<uint8_t>(0, TIME_IN_SYNC);
131 info.urisSize = provider->ConsumeIntegralInRange<uint16_t>(0, INT16_MAX);
132 info.uris = FuzzListUri();
133 info.extraUris = FuzzListUri();
134 info.uriIds = FuzzUnorderedSet();
135 info.notifyAssets = provider->ConsumeBool();
136 info.notifyAlbums = provider->ConsumeBool();
137 info.refreshResult = provider->ConsumeIntegralInRange<uint32_t>(0, INT32_MAX);
138 info.forceRefreshType = FuzzForceRefreshTypeCause();
139 return info;
140 }
141
RefreshNotifyInfoTest()142 static void RefreshNotifyInfoTest()
143 {
144 Media::SyncNotifyInfo fuzznotifyinfo = FuzzSyncNotifyInfo();
145 Media::CloudSyncNotifyInfo fuzzsyncnotifyinfo = FuzzCloudSyncNotifyInfo();
146 std::vector<std::string> fuzzvector = FuzzVector();
147 Media::AlbumsRefreshManager &instance = Media::AlbumsRefreshManager::GetInstance();
148 std::shared_ptr<Media::AlbumsRefreshWorker> refreshWorker = std::make_shared<Media::AlbumsRefreshWorker>();
149 instance.RefreshPhotoAlbums(fuzznotifyinfo);
150 instance.AddAlbumRefreshTask(fuzznotifyinfo);
151 instance.NotifyPhotoAlbums(fuzznotifyinfo);
152 instance.HasRefreshingSystemAlbums();
153 instance.GetSyncNotifyInfo(fuzzsyncnotifyinfo,
154 provider->ConsumeIntegralInRange<uint8_t>(0, OTHER_URI_TYPE));
155 instance.CovertCloudId2AlbumId(g_rdbStore, fuzzvector);
156 instance.CovertCloudId2FileId(g_rdbStore, fuzzvector);
157 instance.RefreshPhotoAlbumsBySyncNotifyInfo(g_rdbStore, fuzznotifyinfo);
158 refreshWorker->StartConsumerThread();
159 refreshWorker->AddAlbumRefreshTask(fuzznotifyinfo);
160 refreshWorker->GetSystemAlbumIds(fuzznotifyinfo, fuzzvector);
161 refreshWorker->TryDeleteAlbum(fuzznotifyinfo, fuzzvector);
162 }
163
SetTables()164 void SetTables()
165 {
166 vector<string> createTableSqlList = { Media::PhotoColumn::CREATE_PHOTO_TABLE };
167 for (auto &createTableSql : createTableSqlList) {
168 int32_t ret = g_rdbStore->ExecuteSql(createTableSql);
169 if (ret != NativeRdb::E_OK) {
170 MEDIA_ERR_LOG("Execute sql %{private}s failed", createTableSql.c_str());
171 return;
172 }
173 MEDIA_DEBUG_LOG("Execute sql %{private}s success", createTableSql.c_str());
174 }
175 }
176
Init()177 static void Init()
178 {
179 auto stageContext = std::make_shared<AbilityRuntime::ContextImpl>();
180 auto abilityContextImpl = std::make_shared<OHOS::AbilityRuntime::AbilityContextImpl>();
181 abilityContextImpl->SetStageContext(stageContext);
182 int32_t sceneCode = 0;
183 auto ret = Media::MediaLibraryDataManager::GetInstance()->InitMediaLibraryMgr(abilityContextImpl,
184 abilityContextImpl, sceneCode);
185 CHECK_AND_RETURN_LOG(ret == NativeRdb::E_OK, "InitMediaLibraryMgr failed, ret: %{public}d", ret);
186
187 auto rdbStore = Media::MediaLibraryUnistoreManager::GetInstance().GetRdbStore();
188 if (rdbStore == nullptr) {
189 MEDIA_ERR_LOG("rdbStore is nullptr");
190 return;
191 }
192 g_rdbStore = rdbStore;
193 SetTables();
194 }
195
AddSeed()196 static int32_t AddSeed()
197 {
198 char *seedData = new char[OHOS::SEED_SIZE];
199 for (int i = 0; i < OHOS::SEED_SIZE; i++) {
200 seedData[i] = static_cast<char>(i % MAX_BYTE_VALUE);
201 }
202
203 const char* filename = "corpus/seed.txt";
204 std::ofstream file(filename, std::ios::binary | std::ios::trunc);
205 if (!file) {
206 MEDIA_ERR_LOG("Cannot open file filename:%{public}s", filename);
207 delete[] seedData;
208 return Media::E_ERR;
209 }
210 file.write(seedData, OHOS::SEED_SIZE);
211 file.close();
212 delete[] seedData;
213 MEDIA_INFO_LOG("seedData has been successfully written to file filename:%{public}s", filename);
214 return Media::E_OK;
215 }
216
217 } // namespace OHOS
218
LLVMFuzzerInitialize(int * argc,char *** argv)219 extern "C" int LLVMFuzzerInitialize(int *argc, char ***argv)
220 {
221 OHOS::AddSeed();
222 OHOS::Init();
223 return 0;
224 }
225
226 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)227 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
228 {
229 FuzzedDataProvider fdp(data, size);
230 OHOS::provider = &fdp;
231 if (data == nullptr) {
232 return 0;
233 }
234 /* Run your code on data */
235 OHOS::RefreshNotifyInfoTest();
236 OHOS::MediaLibraryKvStoreManager::GetInstance().CloseAllKvStore();
237 return 0;
238 }