• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022-2025 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 #ifndef OHOS_FILEMGMT_BACKUP_BACKUP_EXT_EXTENSION_H
17 #define OHOS_FILEMGMT_BACKUP_BACKUP_EXT_EXTENSION_H
18 
19 #include <chrono>
20 #include <shared_mutex>
21 #include <string>
22 #include <vector>
23 #include <tuple>
24 
25 #include <sys/stat.h>
26 
27 #include "b_json/b_json_entity_extension_config.h"
28 #include "b_json/b_json_entity_ext_manage.h"
29 #include "b_json/b_report_entity.h"
30 #include "b_radar/b_radar.h"
31 #include "ext_backup_js.h"
32 #include "ext_extension_stub.h"
33 #include "i_service.h"
34 #include "tar_file.h"
35 #include "thread_pool.h"
36 #include "timer.h"
37 #include "unique_fd.h"
38 #include "untar_file.h"
39 
40 namespace OHOS::FileManagement::Backup {
41 using CompareFilesResult = tuple<map<string, struct ReportFileInfo>,
42                                  map<string, struct ReportFileInfo>,
43                                  map<string, struct ReportFileInfo>>;
44 class BackupExtExtension : public ExtExtensionStub {
45 public:
46     UniqueFd GetFileHandle(const std::string &fileName, int32_t &errCode) override;
47     ErrCode HandleClear() override;
48     ErrCode PublishFile(const std::string &fileName) override;
49     ErrCode HandleBackup(bool isClearData) override;
50     ErrCode HandleRestore(bool isClearData) override;
51     std::tuple<ErrCode, UniqueFd, UniqueFd> GetIncrementalFileHandle(const std::string &fileName) override;
52     ErrCode PublishIncrementalFile(const std::string &fileName) override;
53     ErrCode HandleIncrementalBackup(UniqueFd incrementalFd, UniqueFd manifestFd) override;
54     ErrCode IncrementalOnBackup(bool isClearData) override;
55     std::tuple<UniqueFd, UniqueFd> GetIncrementalBackupFileHandle() override;
56     ErrCode GetBackupInfo(std::string &result) override;
57     ErrCode UpdateFdSendRate(std::string &bundleName, int32_t sendRate) override;
58     void AsyncTaskRestoreForUpgrade(void);
59     void ExtClear(void);
60     void AsyncTaskIncrementalRestoreForUpgrade(void);
61     ErrCode User0OnBackup() override;
62 
63 public:
BackupExtExtension(const std::shared_ptr<Backup::ExtBackup> & extension,const std::string & bundleName)64     explicit BackupExtExtension(const std::shared_ptr<Backup::ExtBackup> &extension,
65         const std::string &bundleName) : extension_(extension)
66     {
67         if (extension_ != nullptr) {
68             extension_->SetBackupExtExtension(this);
69         }
70         bundleName_ = bundleName;
71         threadPool_.Start(BConstants::EXTENSION_THREAD_POOL_COUNT);
72         onProcessTaskPool_.Start(BConstants::EXTENSION_THREAD_POOL_COUNT);
73         reportOnProcessRetPool_.Start(BConstants::EXTENSION_THREAD_POOL_COUNT);
74         SetStagingPathProperties();
75     }
~BackupExtExtension()76     ~BackupExtExtension()
77     {
78         onProcessTimeoutTimer_.Shutdown();
79         threadPool_.Stop();
80         onProcessTaskPool_.Stop();
81         reportOnProcessRetPool_.Stop();
82         if (callJsOnProcessThread_.joinable()) {
83             callJsOnProcessThread_.join();
84         }
85     }
86 
87 private:
88     /**
89      * @brief verify caller uid
90      *
91      */
92     void VerifyCaller();
93 
94     /**
95      * @brief backup
96      *
97      * @param bigFileInfo bigfiles to be backup
98      * @param smallFiles smallfiles to be backup
99      * @param includesNum sizeof includes
100      * @param excludesNum sizeof excludes
101      */
102     int DoBackup(TarMap &bigFileInfo, map<string, size_t> &smallFiles, uint32_t includesNum, uint32_t excludesNum);
103 
104     /**
105      * @brief restore
106      *
107      * @param fileName name of the file that to be untar
108      */
109     int DoRestore(const string &fileName, const off_t fileSize);
110 
111     /**
112      * @brief incremental restore
113      *
114      */
115     int DoIncrementalRestore();
116 
117     /** @brief clear backup restore data */
118     void DoClear();
119 
120     /**
121      * @brief extension backup restore is done
122      *
123      * @param errCode
124      */
125     void AppDone(ErrCode errCode);
126 
127     /**
128      * @brief extension backup restore is done
129      *
130      * @param restoreRetInfo app restore reportInfo
131      */
132     void AppResultReport(const std::string restoreRetInfo, BackupRestoreScenario scenario,
133         ErrCode errCode = 0);
134 
135     /**
136      * @brief extension process Info
137      *
138      * @param restoreRetInfo app processInfo
139      * @param scenario backup or restore
140      */
141     void ReportAppProcessInfo(const std::string processInfo, BackupRestoreScenario scenario);
142 
143     /**
144      * @brief Executing Backup Tasks Asynchronously
145      *
146      * @param extAction action
147      *
148      * @param config user configure
149      */
150     void AsyncTaskBackup(const std::string config);
151 
152     /**
153      * @brief Executing Restoration Tasks Asynchronously
154      *
155      */
156     void AsyncTaskRestore(std::set<std::string> fileSet, const std::vector<ExtManageInfo> extManageInfo);
157 
158     /**
159      * @brief Executing Incremental Restoration Tasks Asynchronously
160      *
161      */
162     void AsyncTaskIncrementalRestore();
163 
164     /**
165      * @brief Executing Incremental Restoration Tasks Asynchronously for special clone & cloud
166      *
167      */
168     void AsyncTaskIncreRestoreSpecialVersion();
169 
170     void AsyncTaskOnBackup();
171 
172     bool IfAllowToBackupRestore();
173 
174     void AsyncTaskUser0Backup();
175 
176     void DoUser0Backup(const BJsonEntityExtensionConfig &usrConfig);
177 
178     int User0DoBackup(const BJsonEntityExtensionConfig &usrConfig);
179 
180     int DoIncrementalBackup(const std::vector<struct ReportFileInfo> &allFiles,
181                             const std::vector<struct ReportFileInfo> &smallFiles,
182                             const std::vector<struct ReportFileInfo> &bigFiles);
183 
184     void FillFileInfos(UniqueFd incrementalFd,
185                        UniqueFd manifestFd,
186                        vector<struct ReportFileInfo> &allFiles,
187                        vector<struct ReportFileInfo> &smallFiles,
188                        vector<struct ReportFileInfo> &bigFiles);
189     void FillFileInfosWithoutCmp(vector<struct ReportFileInfo> &allFiles,
190                                  vector<struct ReportFileInfo> &smallFiles,
191                                  vector<struct ReportFileInfo> &bigFiles,
192                                  UniqueFd incrementalFd);
193     void FillFileInfosWithCmp(vector<struct ReportFileInfo> &allFiles,
194                               vector<struct ReportFileInfo> &smallFiles,
195                               vector<struct ReportFileInfo> &bigFiles,
196                               const unordered_map<string, struct ReportFileInfo> &cloudFiles,
197                               UniqueFd incrementalFd);
198     void CompareFiles(vector<struct ReportFileInfo> &allFiles,
199                       vector<struct ReportFileInfo> &smallFiles,
200                       vector<struct ReportFileInfo> &bigFiles,
201                       const unordered_map<string, struct ReportFileInfo> &cloudFiles,
202                       unordered_map<string, struct ReportFileInfo> &localFilesInfo);
203 
204     void AsyncTaskDoIncrementalBackup(UniqueFd incrementalFd, UniqueFd manifestFd);
205     void AsyncTaskOnIncrementalBackup();
206     int DoIncrementalBackupTask(UniqueFd incrementalFd, UniqueFd manifestFd);
207     ErrCode IncrementalBigFileReady(TarMap &pkgInfo, const vector<struct ReportFileInfo> &bigInfos,
208         sptr<IService> proxy);
209     ErrCode BigFileReady(TarMap &bigFileInfo, sptr<IService> proxy);
210     void WaitToSendFd(std::chrono::system_clock::time_point &startTime, int &fdSendNum);
211     void RefreshTimeInfo(std::chrono::system_clock::time_point &startTime, int &fdSendNum);
212     void IncrementalPacket(const vector<struct ReportFileInfo> &infos, TarMap &tar, sptr<IService> proxy);
213     void DoPacket(const map<string, size_t> &srcFiles, TarMap &tar, sptr<IService> proxy);
214     void CheckTmpDirFileInfos(bool isSpecialVersion = false);
215     std::map<std::string, off_t> GetIdxFileInfos(bool isSpecialVersion = false);
216     tuple<bool, vector<string>> CheckRestoreFileInfos();
217     /**
218      * @brief extension incremental backup restore is done
219      *
220      * @param errCode
221      */
222     void AppIncrementalDone(ErrCode errCode);
223 
224     /**
225      * @brief start extension timer by ipc
226      *
227      * @param result
228      */
229     void StartExtTimer(bool &isExtStart);
230 
231     /**
232      * @brief start fwk timer by ipc
233      *
234      * @param errCode
235      */
236     void StartFwkTimer(bool &isFwkStart);
237 
238     /**
239      * @brief stop ext timer by ipc
240      */
241     bool StopExtTimer();
242 
243     /**
244      * @brief refresh datasize
245      *
246      * @param totalSize backup totalSize
247      */
248     bool RefreshDataSize(int64_t totalSize);
249 
250     /**
251      * @brief scanning files and calculate datasize
252      *
253      * @param usrConfig usrConfig
254      * @param totalSize totalSize
255      * @param bigFileInfo bigFileInfo
256      * @param smallFiles smallFiles info
257      */
258     tuple<ErrCode, uint32_t, uint32_t> CalculateDataSize(const BJsonEntityExtensionConfig &usrConfig,
259         int64_t &totalSize, TarMap &bigFileInfo, map<string, size_t> &smallFiles);
260 
261     /**
262      * @brief get increCallbackEx for execute onRestore with string param
263      *
264      * @param obj
265      */
266     std::function<void(ErrCode, const std::string)> IncreOnRestoreExCallback(wptr<BackupExtExtension> obj);
267 
268     /**
269      * @brief get increCallback for execute onRestore with string param
270      *
271      * @param obj
272      */
273     std::function<void(ErrCode, const std::string)> IncreOnRestoreCallback(wptr<BackupExtExtension> obj);
274 
275     /**
276      * @brief get callback for execute onRestore with string param
277      *
278      * @param obj
279      */
280     std::function<void(ErrCode, std::string)> OnRestoreCallback(wptr<BackupExtExtension> obj);
281 
282     /**
283      * @brief get callbackEx for execute onRestore with string param
284      *
285      * @param obj
286      */
287     std::function<void(ErrCode, std::string)> OnRestoreExCallback(wptr<BackupExtExtension> obj);
288 
289     /**
290      * @brief get callbackEx for execute appDone
291      */
292     std::function<void(ErrCode, std::string)> AppDoneCallbackEx(wptr<BackupExtExtension> obj);
293 
294     std::function<void(ErrCode, const std::string)> IncOnBackupExCallback(wptr<BackupExtExtension> obj);
295     std::function<void(ErrCode, const std::string)> IncOnBackupCallback(wptr<BackupExtExtension> obj);
296 
297     std::function<void(ErrCode, const std::string)> OnBackupExCallback(wptr<BackupExtExtension> obj);
298     std::function<void(ErrCode, const std::string)> OnBackupCallback(wptr<BackupExtExtension> obj);
299 
300     void HandleSpecialVersionRestore();
301     void DeleteBackupIncrementalIdxFile();
302     void DeleteBackupIdxFile();
303     void DeleteBackupIncrementalTars(const string &tarName);
304     void SetClearDataFlag(bool isClearData);
305     std::string GetBundlePath();
306     std::vector<ExtManageInfo> GetExtManageInfo(bool isSpecialVersion = false);
307     ErrCode RestoreFilesForSpecialCloneCloud();
308     void RestoreBigFilesForSpecialCloneCloud(const ExtManageInfo &item);
309     ErrCode RestoreTarForSpecialCloneCloud(const ExtManageInfo &item);
310     void RestoreBigFiles(bool appendTargetPath);
311     void FillEndFileInfos(const std::string &path, const unordered_map<string, struct ReportFileInfo> &result);
312     void RestoreBigFileAfter(const string &filePath, const struct stat &sta);
313     int DealIncreUnPacketResult(const off_t tarFileSize, const std::string &tarFileName,
314         const std::tuple<int, EndFileInfo, ErrFileInfo> &result);
315 
316     ErrCode StartOnProcessTaskThread(wptr<BackupExtExtension> obj, BackupRestoreScenario scenario);
317     void FinishOnProcessTask();
318     void ExecCallOnProcessTask(wptr<BackupExtExtension> obj, BackupRestoreScenario scenario);
319     void AsyncCallJsOnProcessTask(wptr<BackupExtExtension> obj, BackupRestoreScenario scenario);
320     void SyncCallJsOnProcessTask(wptr<BackupExtExtension> obj, BackupRestoreScenario scenario);
321     void StartOnProcessTimeOutTimer(wptr<BackupExtExtension> obj, BackupRestoreScenario scenario);
322     void CloseOnProcessTimeOutTimer();
323     void UpdateOnStartTime();
324     int32_t GetOnStartTimeCost();
325     bool SetStagingPathProperties();
326 
327     std::function<void(std::string, int)> ReportErrFileByProc(wptr<BackupExtExtension> obj,
328         BackupRestoreScenario scenario);
329     std::tuple<ErrCode, UniqueFd, UniqueFd> GetIncreFileHandleForNormalVersion(const std::string &fileName);
330     void RestoreOneBigFile(const std::string &path, const ExtManageInfo &item, const bool appendTargetPath);
331     int DealIncreRestoreBigAndTarFile();
332     ErrCode IncrementalTarFileReady(const TarMap &bigFileInfo, const vector<struct ReportFileInfo> &srcFiles,
333         sptr<IService> proxy);
334     ErrCode IncrementalAllFileReady(const TarMap &pkgInfo, const vector<struct ReportFileInfo> &srcFiles,
335         sptr<IService> proxy);
336     void ClearNoPermissionFiles(TarMap &pkgInfo, vector<std::string> &noPermissionFiles);
337     std::function<void(ErrCode, std::string)> ReportOnProcessResultCallback(wptr<BackupExtExtension> obj,
338         BackupRestoreScenario scenario);
339     bool IfCloudSpecialRestore(std::string tarName);
340     ErrCode CloudSpecialRestore(std::string tarName, std::string untarPath, off_t tarFileSize);
341     void GetTarIncludes(const string &tarName, unordered_map<string, struct ReportFileInfo> &infos);
342     void DeleteIndexAndRpFile();
343     tuple<ErrCode, UniqueFd, UniqueFd> GetIncreFileHandleForSpecialVersion(const string &fileName);
344     void RmBigFileReportForSpecialCloneCloud(const std::string &srcFile);
345     string GetReportFileName(const string &fileName);
346 private:
347     std::shared_mutex lock_;
348     std::shared_ptr<ExtBackup> extension_;
349     std::string backupInfo_;
350     OHOS::ThreadPool threadPool_;
351     std::mutex updateSendRateLock_;
352     std::condition_variable startSendFdRateCon_;
353     std::condition_variable waitSendFdCon_;
354     std::mutex startSendMutex_;
355     std::mutex waitTimeLock_;
356     std::string bundleName_;
357     int32_t sendRate_ = BConstants::DEFAULT_FD_SEND_RATE;
358     bool isClearData_ {true};
359     bool isDebug_ {true};
360     std::map<std::string, off_t> endFileInfos_;
361     std::map<std::string, std::vector<ErrCode>> errFileInfos_;
362     bool isRpValid_ {false};
363 
364     std::thread callJsOnProcessThread_;
365     Utils::Timer onProcessTimeoutTimer_ {"onProcessTimeoutTimer_"};
366     uint32_t onProcessTimeoutTimerId_ { 0 };
367     std::atomic<int> onProcessTimeoutCnt_ { 0 };
368     std::atomic<bool> stopCallJsOnProcess_ {false};
369     std::condition_variable execOnProcessCon_;
370     std::mutex onProcessLock_;
371     std::atomic<bool> onProcessTimeout_ {false};
372     std::chrono::time_point<std::chrono::system_clock> g_onStart;
373     std::mutex onStartTimeLock_;
374     AppRadar::DoRestoreInfo radarRestoreInfo_ { 0 };
375     OHOS::ThreadPool onProcessTaskPool_;
376     std::atomic<bool> isFirstCallOnProcess_ {false};
377     std::atomic<bool> isExecAppDone_ {false};
378     OHOS::ThreadPool reportOnProcessRetPool_;
379 
380     std::mutex reportHashLock_;
381     std::map<std::string, std::string> reportHashSrcPathMap_;
382 
383     BackupRestoreScenario curScenario_ { BackupRestoreScenario::FULL_BACKUP };
384 };
385 } // namespace OHOS::FileManagement::Backup
386 
387 #endif // OHOS_FILEMGMT_BACKUP_BACKUP_EXT_EXTENSION_H