1 /*
2  * Copyright (c) 2021-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 "updater_main.h"
16 #include <chrono>
17 #include <dirent.h>
18 #include <fcntl.h>
19 #include <getopt.h>
20 #include <libgen.h>
21 #include <string>
22 #include <sys/mount.h>
23 #include <sys/reboot.h>
24 #include <sys/stat.h>
25 #include <sys/statvfs.h>
26 #include <sys/syscall.h>
27 #include <thread>
28 #include <unistd.h>
29 #include <vector>
30 #include "applypatch/partition_record.h"
31 #include "cert_verify.h"
32 #include "flashd/flashd.h"
33 #include "fs_manager/mount.h"
34 #include "include/updater/updater.h"
35 #include "json_node.h"
36 #include "language/language_ui.h"
37 #include "log/dump.h"
38 #include "log/log.h"
39 #include "misc_info/misc_info.h"
40 #include "package/pkg_manager.h"
41 #include "pkg_manager.h"
42 #include "pkg_utils.h"
43 #include "ptable_parse/ptable_process.h"
44 #include "sdcard_update/sdcard_update.h"
45 #include "securec.h"
46 #include "updater/updater_const.h"
47 #include "updater/hwfault_retry.h"
48 #include "updater/updater_preprocess.h"
49 #include "updater_ui_stub.h"
50 #include "utils.h"
51 #include "factory_reset/factory_reset.h"
52 #include "write_state/write_state.h"
53 
54 namespace Updater {
55 using Utils::String2Int;
56 using namespace Hpackage;
57 using namespace Updater::Utils;
58 using namespace std::literals::chrono_literals;
59 
60 [[maybe_unused]] constexpr int DISPLAY_TIME = 1000 * 1000;
61 constexpr struct option OPTIONS[] = {
62     { "update_package", required_argument, nullptr, 0 },
63     { "retry_count", required_argument, nullptr, 0 },
64     { "factory_wipe_data", no_argument, nullptr, 0 },
65     { "user_wipe_data", no_argument, nullptr, 0 },
66     { "menu_wipe_data", no_argument, nullptr, 0 },
67     { "sdcard_update", no_argument, nullptr, 0 },
68     { "upgraded_pkg_num", required_argument, nullptr, 0 },
69     { "force_update_action", required_argument, nullptr, 0 },
70     { "night_update", no_argument, nullptr, 0 },
71     { USB_MODE, no_argument, nullptr, 0 },
72     { "UPDATE:MAINIMG", no_argument, nullptr, 0 },
73     { "update_protect", no_argument, nullptr, 0 },
74     { "factory_sd_update", no_argument, nullptr, 0 },
75     { "UPDATE:SD", no_argument, nullptr, 0 },
76     { "UPDATE:SDFROMDEV", no_argument, nullptr, 0 },
77     { "sdcard_intral_update", optional_argument, nullptr, 0},
78     {"wipe_data_factory_lowlevel", no_argument, nullptr, 0},
79     { "wipe_data_at_factoryreset_0", no_argument, nullptr, 0 },
80     { nullptr, 0, nullptr, 0 },
81 };
82 constexpr float VERIFY_PERCENT = 0.05;
83 constexpr double FULL_PERCENT = 100.00;
84 
FactoryReset(FactoryResetMode mode, const std::string &path)85 int FactoryReset(FactoryResetMode mode, const std::string &path)
86 {
87     UpdaterInit::GetInstance().InvokeEvent(FACTORY_RESET_INIT_EVENT);
88     auto ret = FactoryResetProcess::GetInstance().FactoryResetFunc(mode, path);
89     if (ret == 0) {
90         LOG(INFO) << "restorecon for " << path;
91         RestoreconPath(path); // restore selinux context for /data after factory reset success
92     }
93     return ret;
94 }
95 
OtaUpdatePreCheck(PkgManager::PkgManagerPtr pkgManager, const std::string &packagePath)96 static int OtaUpdatePreCheck(PkgManager::PkgManagerPtr pkgManager, const std::string &packagePath)
97 {
98     UPDATER_INIT_RECORD;
99     if (pkgManager == nullptr) {
100         LOG(ERROR) << "pkgManager is nullptr";
101         UPDATER_LAST_WORD(PKG_INVALID_FILE);
102         return UPDATE_CORRUPT;
103     }
104     char realPath[PATH_MAX + 1] = {0};
105     if (realpath(packagePath.c_str(), realPath) == nullptr) {
106         LOG(ERROR) << "realpath error";
107         UPDATER_LAST_WORD(PKG_INVALID_FILE);
108         return PKG_INVALID_FILE;
109     }
110     if (access(realPath, F_OK) != 0) {
111         LOG(ERROR) << "package does not exist!";
112         UPDATER_LAST_WORD(PKG_INVALID_FILE);
113         return PKG_INVALID_FILE;
114     }
115 
116     int32_t ret = pkgManager->VerifyOtaPackage(packagePath);
117     if (ret != PKG_SUCCESS) {
118         LOG(INFO) << "VerifyOtaPackage fail ret :"<< ret;
119         UPDATER_LAST_WORD("sign", ret);
120         return ret;
121     }
122 
123     return UPDATE_SUCCESS;
124 }
125 
UpdatePreCheck(UpdaterParams &upParams, const std::string pkgPath)126 static UpdaterStatus UpdatePreCheck(UpdaterParams &upParams, const std::string pkgPath)
127 {
128     UPDATER_INIT_RECORD;
129     int32_t ret = PreProcess::GetInstance().DoUpdateAuth(pkgPath);
130     if (ret != 0) {
131         return UPDATE_ERROR;
132     }
133 
134     PkgManager::PkgManagerPtr pkgManager = PkgManager::CreatePackageInstance();
135     if (pkgManager == nullptr) {
136         LOG(ERROR) << "CreatePackageInstance fail";
137         return UPDATE_ERROR;
138     }
139     if (GetUpdatePackageInfo(pkgManager, pkgPath) != PKG_SUCCESS) {
140         PkgManager::ReleasePackageInstance(pkgManager);
141         LOG(ERROR) << "Verify update bin file Fail!";
142         UPDATER_LAST_WORD(UPDATE_ERROR);
143         return UPDATE_ERROR;
144     }
145     if (PreProcess::GetInstance().DoUpdatePreProcess(upParams, pkgManager) != PKG_SUCCESS) {
146         PkgManager::ReleasePackageInstance(pkgManager);
147         LOG(ERROR) << "Version Check Fail!";
148         UPDATER_LAST_WORD(UPDATE_ERROR);
149         return UPDATE_ERROR;
150     }
151     if (PreProcess::GetInstance().DoUpdateClear() != 0) {
152         LOG(ERROR) << "DoUpdateClear Fail!";
153     }
154     PkgManager::ReleasePackageInstance(pkgManager);
155     return UPDATE_SUCCESS;
156 }
157 
VerifySpecialPkgs([[maybe_unused]]UpdaterParams &upParams)158 __attribute__((weak)) int32_t VerifySpecialPkgs([[maybe_unused]]UpdaterParams &upParams)
159 {
160     return PKG_SUCCESS;
161 }
162 
UpdaterVerifyFailEntry(bool verifyret)163 __attribute__((weak)) void UpdaterVerifyFailEntry(bool verifyret)
164 {
165     LOG(INFO) << "pre verify package info process";
166     return;
167 }
168 
VerifyPackages(UpdaterParams &upParams)169 static UpdaterStatus VerifyPackages(UpdaterParams &upParams)
170 {
171     LOG(INFO) << "Verify packages start...";
172     UPDATER_UI_INSTANCE.ShowProgressPage();
173     UPDATER_UI_INSTANCE.ShowUpdInfo(TR(UPD_VERIFYPKG));
174 
175     if (upParams.callbackProgress == nullptr) {
176         UPDATER_UI_INSTANCE.ShowUpdInfo(TR(UPD_VERIFYPKGFAIL), true);
177         UPDATER_LAST_WORD(UPDATE_CORRUPT);
178         return UPDATE_CORRUPT;
179     }
180     upParams.callbackProgress(0.0);
181     upParams.installTime.resize(upParams.updatePackage.size(), std::chrono::duration<double>(0));
182     ReadInstallTime(upParams);
183     for (unsigned int i = upParams.pkgLocation; i < upParams.updatePackage.size(); i++) {
184         LOG(INFO) << "Verify package:" << upParams.updatePackage[i];
185         auto startTime = std::chrono::system_clock::now();
186         PkgManager::PkgManagerPtr manager = PkgManager::CreatePackageInstance();
187         if (manager == nullptr) {
188             LOG(ERROR) << "CreatePackageInstance fail";
189             return UPDATE_ERROR;
190         }
191         int32_t verifyret = OtaUpdatePreCheck(manager, upParams.updatePackage[i]);
192         PkgManager::ReleasePackageInstance(manager);
193         if (verifyret == UPDATE_SUCCESS) {
194             verifyret = UpdatePreCheck(upParams, upParams.updatePackage[i]);
195         }
196 
197         if (verifyret != UPDATE_SUCCESS) {
198             UpdaterVerifyFailEntry((verifyret == PKG_INVALID_DIGEST) && (upParams.updateMode == HOTA_UPDATE));
199             upParams.pkgLocation = i;
200             UPDATER_UI_INSTANCE.ShowUpdInfo(TR(UPD_VERIFYPKGFAIL), true);
201             auto endTime = std::chrono::system_clock::now();
202             upParams.installTime[i] = endTime - startTime;
203             return UPDATE_CORRUPT;
204         }
205         auto endTime = std::chrono::system_clock::now();
206         upParams.installTime[i] = endTime - startTime;
207     }
208     if (VerifySpecialPkgs(upParams) != PKG_SUCCESS) {
209         UPDATER_LAST_WORD(UPDATE_CORRUPT);
210         return UPDATE_CORRUPT;
211     }
212     ProgressSmoothHandler(UPDATER_UI_INSTANCE.GetCurrentPercent(),
213         UPDATER_UI_INSTANCE.GetCurrentPercent() + static_cast<int>(VERIFY_PERCENT * FULL_PERCENT_PROGRESS));
214     LOG(INFO) << "Verify packages successfull...";
215     return UPDATE_SUCCESS;
216 }
217 
GetBatteryCapacity(int &capacity)218 bool GetBatteryCapacity(int &capacity)
219 {
220     const static std::vector<const char *> vec = {
221         "/sys/class/power_supply/battery/capacity",
222         "/sys/class/power_supply/Battery/capacity"
223     };
224     for (auto &it : vec) {
225         std::ifstream ifs { it };
226         if (!ifs.is_open()) {
227             continue;
228         }
229 
230         int tmpCapacity = 0;
231         ifs >> tmpCapacity;
232         if ((ifs.fail()) || (ifs.bad())) {
233             continue;
234         }
235 
236         capacity = tmpCapacity;
237         return true;
238     }
239 
240     return false;
241 }
242 
IsBatteryCapacitySufficient()243 bool IsBatteryCapacitySufficient()
244 {
245     if (Utils::CheckUpdateMode(OTA_MODE)) {
246         LOG(INFO) << "this is OTA update, on need to determine the battery";
247         return true;
248     }
249     static constexpr auto levelIdx = "lowBatteryLevel";
250     static constexpr auto jsonPath = "/etc/product_cfg.json";
251 
252     int capacity = 0;
253     bool ret = GetBatteryCapacity(capacity);
254     if (!ret) {
255         return true; /* maybe no battery or err value return default true */
256     }
257 
258     JsonNode node { Fs::path { jsonPath }};
259     auto item = node[levelIdx].As<int>();
260     if (!item.has_value()) {
261         return true; /* maybe no value return default true */
262     }
263 
264     int lowLevel = *item;
265     if (lowLevel > 100 || lowLevel < 0) { /* full percent is 100 */
266         LOG(ERROR) << "load battery level error:" << lowLevel;
267         return false; /* config err not allow to update */
268     }
269 
270     LOG(INFO) << "current capacity:" << capacity << ", low level:" << lowLevel;
271 
272     return capacity >= lowLevel;
273 }
274 
InstallUpdaterPackage(UpdaterParams &upParams, PkgManager::PkgManagerPtr manager)275 UpdaterStatus InstallUpdaterPackage(UpdaterParams &upParams, PkgManager::PkgManagerPtr manager)
276 {
277     UpdaterStatus status = UPDATE_UNKNOWN;
278     STAGE(UPDATE_STAGE_BEGIN) << "Install package";
279     if (upParams.retryCount == 0) {
280         // First time enter updater, record retryCount in case of abnormal reset.
281         if (!PartitionRecord::GetInstance().ClearRecordPartitionOffset()) {
282             LOG(ERROR) << "ClearRecordPartitionOffset failed";
283             UPDATER_LAST_WORD(UPDATE_ERROR);
284             return UPDATE_ERROR;
285         }
286         SetMessageToMisc(upParams.miscCmd, upParams.retryCount + 1, "retry_count");
287     }
288     if (upParams.updateMode == SDCARD_UPDATE) {
289         status = DoInstallUpdaterPackage(manager, upParams, SDCARD_UPDATE);
290     } else {
291         status = DoInstallUpdaterPackage(manager, upParams, HOTA_UPDATE);
292     }
293     if (status != UPDATE_SUCCESS) {
294         UPDATER_UI_INSTANCE.Sleep(UI_SHOW_DURATION);
295         UPDATER_UI_INSTANCE.ShowLog(TR(LOG_UPDFAIL));
296         STAGE(UPDATE_STAGE_FAIL) << "Install failed";
297         if (status == UPDATE_RETRY) {
298             HwFaultRetry::GetInstance().DoRetryAction();
299             UPDATER_UI_INSTANCE.ShowFailedPage();
300         }
301     } else {
302         LOG(INFO) << "Install package success.";
303         STAGE(UPDATE_STAGE_SUCCESS) << "Install package";
304     }
305     return status;
306 }
307 
CalcProgress(const UpdaterParams &upParams, std::vector<double> &pkgStartPosition, double &updateStartPosition)308 static UpdaterStatus CalcProgress(const UpdaterParams &upParams,
309     std::vector<double> &pkgStartPosition, double &updateStartPosition)
310 {
311     UPDATER_INIT_RECORD;
312     int64_t allPkgSize = 0;
313     std::vector<int64_t> everyPkgSize;
314     if (upParams.pkgLocation == upParams.updatePackage.size()) {
315         updateStartPosition = VERIFY_PERCENT;
316         return UPDATE_SUCCESS;
317     }
318     for (const auto &path : upParams.updatePackage) {
319         char realPath[PATH_MAX + 1] = {0};
320         if (realpath(path.c_str(), realPath) == nullptr) {
321             LOG(WARNING) << "Can not find updatePackage : " << path;
322             everyPkgSize.push_back(0);
323             continue;
324         }
325         struct stat st {};
326         if (stat(realPath, &st) == 0) {
327             everyPkgSize.push_back(st.st_size);
328             allPkgSize += st.st_size;
329             LOG(INFO) << "pkg " << path << " size is:" << st.st_size;
330         }
331     }
332     pkgStartPosition.push_back(VERIFY_PERCENT);
333     if (allPkgSize == 0) {
334         LOG(ERROR) << "All packages's size is 0.";
335         UPDATER_LAST_WORD(UPDATE_ERROR);
336         return UPDATE_ERROR;
337     }
338     int64_t startSize = 0;
339     for (auto size : everyPkgSize) {
340         startSize += size;
341         float percent = static_cast<double>(startSize) / static_cast<double>(allPkgSize) + VERIFY_PERCENT;
342         percent = (percent > 1.0) ? 1.0 : percent; // 1.0 : 100%
343         LOG(INFO) << "percent is:" << percent;
344         pkgStartPosition.push_back(percent);
345     }
346 
347     updateStartPosition = pkgStartPosition[upParams.pkgLocation];
348     return UPDATE_SUCCESS;
349 }
350 
PreUpdatePackages(UpdaterParams &upParams)351 static UpdaterStatus PreUpdatePackages(UpdaterParams &upParams)
352 {
353     UPDATER_INIT_RECORD;
354     LOG(INFO) << "start to update packages, start index:" << upParams.pkgLocation;
355 
356     UpdaterStatus status = UPDATE_UNKNOWN;
357 
358     upParams.installTime.resize(upParams.updatePackage.size(), std::chrono::duration<double>(0));
359     if (SetupPartitions() != 0) {
360         UPDATER_UI_INSTANCE.ShowUpdInfo(TR(UPD_SETPART_FAIL), true);
361         UPDATER_LAST_WORD(UPDATE_ERROR);
362         return UPDATE_ERROR;
363     }
364     const std::string resultPath = std::string(UPDATER_PATH) + "/" + std::string(UPDATER_RESULT_FILE);
365     if (access(resultPath.c_str(), F_OK) != -1) {
366         (void)DeleteFile(resultPath);
367         LOG(INFO) << "delete last upgrade file";
368     }
369 
370     if (upParams.pkgLocation == upParams.updatePackage.size()) {
371         LOG(WARNING) << "all package has been upgraded, skip pre process";
372         return UPDATE_SUCCESS;
373     }
374 
375     // verify packages first
376     if (VerifyPackages(upParams) != UPDATE_SUCCESS) {
377         return UPDATE_CORRUPT; // verify package failed must return UPDATE_CORRUPT, ux need it !!!
378     }
379 
380     // Only handle UPATE_ERROR and UPDATE_SUCCESS here.Let package verify handle others.
381     if (IsSpaceCapacitySufficient(upParams) == UPDATE_ERROR) {
382         UPDATER_LAST_WORD(status);
383         return status;
384     }
385     if (upParams.retryCount == 0 && !IsBatteryCapacitySufficient()) {
386         UPDATER_UI_INSTANCE.ShowUpdInfo(TR(LOG_LOWPOWER));
387         UPDATER_UI_INSTANCE.Sleep(UI_SHOW_DURATION);
388         UPDATER_LAST_WORD(UPDATE_ERROR);
389         LOG(ERROR) << "Battery is not sufficient for install package.";
390         return UPDATE_SKIP;
391     }
392 
393 #ifdef UPDATER_USE_PTABLE
394     if (!PtablePreProcess::GetInstance().DoPtableProcess(upParams)) {
395         LOG(ERROR) << "DoPtableProcess failed";
396         UPDATER_LAST_WORD(UPDATE_ERROR);
397         return UPDATE_ERROR;
398     }
399 #endif
400     return UPDATE_SUCCESS;
401 }
402 
DoInstallPackages(UpdaterParams &upParams, std::vector<double> &pkgStartPosition)403 static UpdaterStatus DoInstallPackages(UpdaterParams &upParams, std::vector<double> &pkgStartPosition)
404 {
405     UpdaterStatus status = UPDATE_UNKNOWN;
406     if (upParams.pkgLocation == upParams.updatePackage.size()) {
407         LOG(WARNING) << "all packages has been installed, directly return success";
408         upParams.callbackProgress(FULL_PERCENT_PROGRESS);
409         return UPDATE_SUCCESS;
410     }
411     for (; upParams.pkgLocation < upParams.updatePackage.size(); upParams.pkgLocation++) {
412         PkgManager::PkgManagerPtr manager = PkgManager::CreatePackageInstance();
413         if (manager == nullptr) {
414             LOG(ERROR) << "CreatePackageInstance fail";
415             return UPDATE_ERROR;
416         }
417         auto startTime = std::chrono::system_clock::now();
418         upParams.initialProgress = ((UPDATER_UI_INSTANCE.GetCurrentPercent() / FULL_PERCENT) >
419             pkgStartPosition[upParams.pkgLocation]) ?
420             (UPDATER_UI_INSTANCE.GetCurrentPercent() / FULL_PERCENT) : pkgStartPosition[upParams.pkgLocation];
421         upParams.currentPercentage = pkgStartPosition[upParams.pkgLocation + 1] - upParams.initialProgress;
422         LOG(INFO) << "InstallUpdaterPackage pkg is " << upParams.updatePackage[upParams.pkgLocation] <<
423             " percent:" << upParams.initialProgress << "~" << pkgStartPosition[upParams.pkgLocation + 1];
424 
425         status = InstallUpdaterPackage(upParams, manager);
426         auto endTime = std::chrono::system_clock::now();
427         upParams.installTime[upParams.pkgLocation] = upParams.installTime[upParams.pkgLocation] + endTime - startTime;
428         WriteInstallTime(upParams);
429         if (status != UPDATE_SUCCESS) {
430             LOG(ERROR) << "InstallUpdaterPackage failed! Pkg is " << upParams.updatePackage[upParams.pkgLocation];
431             if (!CheckResultFail()) {
432                 UPDATER_LAST_WORD(status);
433             }
434             PkgManager::ReleasePackageInstance(manager);
435             return status;
436         }
437         ProgressSmoothHandler(
438             static_cast<int>(upParams.initialProgress * FULL_PERCENT_PROGRESS +
439             upParams.currentPercentage * GetTmpProgressValue()),
440             static_cast<int>(pkgStartPosition[upParams.pkgLocation + 1] * FULL_PERCENT_PROGRESS));
441         SetMessageToMisc(upParams.miscCmd, upParams.pkgLocation + 1, "upgraded_pkg_num");
442         PkgManager::ReleasePackageInstance(manager);
443     }
444     return status;
445 }
446 
DoUpdatePackages(UpdaterParams &upParams)447 UpdaterStatus DoUpdatePackages(UpdaterParams &upParams)
448 {
449     UPDATER_INIT_RECORD;
450     UpdaterStatus status = UPDATE_UNKNOWN;
451     std::vector<double> pkgStartPosition {};
452     double updateStartPosition = 0.0;
453     status = CalcProgress(upParams, pkgStartPosition, updateStartPosition);
454     if (status != UPDATE_SUCCESS) {
455         UPDATER_LAST_WORD(status);
456         return status;
457     }
458     for (unsigned int i = 0; i < upParams.updatePackage.size(); i++) {
459         LOG(INFO) << "package " << i << ":" << upParams.updatePackage[i] <<
460             " percent:" << upParams.currentPercentage;
461     }
462     if (upParams.callbackProgress == nullptr) {
463         LOG(ERROR) << "CallbackProgress is nullptr";
464         return UPDATE_CORRUPT;
465     }
466     float value = (UPDATER_UI_INSTANCE.GetCurrentPercent() > (updateStartPosition * FULL_PERCENT_PROGRESS)) ?
467         UPDATER_UI_INSTANCE.GetCurrentPercent() : (updateStartPosition * FULL_PERCENT_PROGRESS);
468     upParams.callbackProgress(value);
469     status = DoInstallPackages(upParams, pkgStartPosition);
470     if (status != UPDATE_SUCCESS) {
471         UPDATER_LAST_WORD(status);
472         return status;
473     }
474     if (upParams.forceUpdate) {
475         UPDATER_UI_INSTANCE.ShowLogRes(TR(LABEL_UPD_OK_SHUTDOWN));
476     }
477     UPDATER_UI_INSTANCE.ShowSuccessPage();
478     return status;
479 }
480 
PostUpdatePackages(UpdaterParams &upParams, bool updateResult)481 static void PostUpdatePackages(UpdaterParams &upParams, bool updateResult)
482 {
483     std::string writeBuffer;
484     std::string buf;
485     std::string time;
486     if (!updateResult) {
487         const std::string resultPath = std::string(UPDATER_PATH) + "/" + std::string(UPDATER_RESULT_FILE);
488         std::ifstream fin {resultPath};
489         if (!fin.is_open() || !std::getline(fin, buf)) {
490             LOG(ERROR) << "read result file error " << resultPath;
491             buf = "fail|";
492         }
493     } else {
494         buf = "pass|";
495         upParams.pkgLocation = upParams.pkgLocation == 0 ? upParams.pkgLocation : (upParams.pkgLocation - 1);
496     }
497 
498     for (unsigned int i = 0; i < upParams.pkgLocation; i++) {
499         time = DurationToString(upParams.installTime, i);
500         writeBuffer += upParams.updatePackage.size() < i + 1 ? "" : upParams.updatePackage[i];
501         writeBuffer += "|pass||install_time=" + time + "|\n";
502     }
503     time = DurationToString(upParams.installTime, upParams.pkgLocation);
504 
505     writeBuffer += upParams.updatePackage.size() < upParams.pkgLocation + 1 ? "" :
506         upParams.updatePackage[upParams.pkgLocation];
507     writeBuffer += "|" + buf + "|install_time=" + time + "|\n";
508     for (unsigned int i = upParams.pkgLocation + 1; i < upParams.updatePackage.size(); i++) {
509         writeBuffer += upParams.updatePackage[i] + "\n";
510     }
511     if (writeBuffer != "") {
512         writeBuffer.pop_back();
513     }
514     LOG(INFO) << "post over, writeBuffer = " << writeBuffer;
515     WriteDumpResult(writeBuffer, UPDATER_RESULT_FILE);
516     DeleteInstallTimeFile();
517 }
518 
519 static UpdaterStatus PreSdcardUpdatePackages(UpdaterParams &upParams)
520 {
521     upParams.installTime.resize(upParams.updatePackage.size(), std::chrono::duration<double>(0));
522     // verify packages first
523     if (upParams.retryCount == 0 && !IsBatteryCapacitySufficient()) {
524         UPDATER_UI_INSTANCE.ShowUpdInfo(TR(LOG_LOWPOWER));
525         UPDATER_UI_INSTANCE.Sleep(UI_SHOW_DURATION);
526         LOG(ERROR) << "Battery is not sufficient for install package.";
527         return UPDATE_SKIP;
528     }
529 
530     if (VerifyPackages(upParams) != UPDATE_SUCCESS) {
531         return UPDATE_CORRUPT; // verify package failed must return UPDATE_CORRUPT, ux need it !!!
532     }
533 #ifdef UPDATER_USE_PTABLE
534     if (!PtablePreProcess::GetInstance().DoPtableProcess(upParams)) {
535         LOG(ERROR) << "DoPtableProcess failed";
536         return UPDATE_ERROR;
537     }
538 #endif
539     return UPDATE_SUCCESS;
540 }
541 
542 static void PostSdcardUpdatePackages(UpdaterParams &upParams, bool updateResult)
543 {
544     if (Utils::CheckUpdateMode(Updater::SDCARD_INTRAL_MODE)) {
545         PostUpdatePackages(upParams, updateResult);
546     }
547 }
548 
549 UpdaterStatus UpdaterFromSdcard(UpdaterParams &upParams)
550 {
551     UPDATER_INIT_RECORD;
552     upParams.callbackProgress = [] (float value) { UPDATER_UI_INSTANCE.ShowProgress(value); };
553     SetMessageToMisc(upParams.miscCmd, 0, "sdcard_update");
554     if (CheckSdcardPkgs(upParams) != UPDATE_SUCCESS) {
555         LOG(ERROR) << "can not find sdcard packages";
556         return UPDATE_ERROR;
557     }
558     UpdaterStatus status = PreSdcardUpdatePackages(upParams);
559     if (status == UPDATE_SUCCESS) {
560         upParams.initialProgress += VERIFY_PERCENT;
561         upParams.currentPercentage -= VERIFY_PERCENT;
562 
563         STAGE(UPDATE_STAGE_BEGIN) << "UpdaterFromSdcard";
564         LOG(INFO) << "UpdaterFromSdcard start, sdcard updaterPath : " << upParams.updatePackage[upParams.pkgLocation];
565         UPDATER_UI_INSTANCE.ShowLog(TR(LOG_SDCARD_NOTMOVE));
566         status = DoUpdatePackages(upParams);
567     }
568     PostSdcardUpdatePackages(upParams, status == UPDATE_SUCCESS);
569     return status;
570 }
571 
572 UpdaterStatus InstallUpdaterPackages(UpdaterParams &upParams)
573 {
574     UpdaterInit::GetInstance().InvokeEvent(UPDATER_PRE_UPDATE_PACKAGE_EVENT);
575     UpdaterStatus status = PreUpdatePackages(upParams);
576     if (status == UPDATE_SUCCESS) {
577         status = DoUpdatePackages(upParams);
578     }
579     PostUpdatePackages(upParams, status == UPDATE_SUCCESS);
580     UpdaterInit::GetInstance().InvokeEvent(UPDATER_POST_UPDATE_PACKAGE_EVENT);
581     return status;
582 }
583 
584 UpdaterStatus StartUpdaterEntry(UpdaterParams &upParams)
585 {
586     UpdaterStatus status = UPDATE_UNKNOWN;
587     status = PreStartUpdaterEntry(upParams, status);
588     if (status != UPDATE_SUCCESS) {
589         LOG(ERROR) << "PreStartUpdaterEntry failed";
590         return status;
591     }
592 
593     status = DoUpdaterEntry(upParams);
594     if (status != UPDATE_SUCCESS) {
595         LOG(WARNING) << "DoUpdaterEntry failed";
596     }
597 
598     status = PostStartUpdaterEntry(upParams, status);
599     if (status != UPDATE_SUCCESS) {
600         LOG(ERROR) << "PostStartUpdaterEntry failed";
601     }
602     return status;
603 }
604 
605 UpdaterStatus DoUpdaterEntry(UpdaterParams &upParams)
606 {
607     UpdaterStatus status = UPDATE_UNKNOWN;
608     if (upParams.updateMode == SDCARD_UPDATE) {
609         LOG(INFO) << "start sdcard update";
610         UPDATER_UI_INSTANCE.ShowProgressPage();
611         status = UpdaterFromSdcard(upParams);
612         return status;
613     } else if (upParams.updatePackage.size() > 0) {
614         UPDATER_UI_INSTANCE.ShowProgressPage();
615         status = InstallUpdaterPackages(upParams);
616     } else if (upParams.factoryResetMode == "factory_wipe_data") {
617         UPDATER_UI_INSTANCE.ShowProgressPage();
618         LOG(INFO) << "Factory level FactoryReset begin";
619         status = UPDATE_SUCCESS;
620 #if !defined(UPDATER_UT) && defined(UPDATER_UI_SUPPORT)
621         DoProgress();
622 #endif
623         if (FactoryReset(FACTORY_WIPE_DATA, "/data") != 0) {
624             LOG(ERROR) << "FactoryReset factory level failed";
625             status = UPDATE_ERROR;
626         }
627         UPDATER_UI_INSTANCE.ShowLogRes(
628             (status != UPDATE_SUCCESS) ? TR(LOGRES_FACTORY_FAIL) : TR(LOGRES_FACTORY_DONE));
629     } else if (upParams.factoryResetMode == "user_wipe_data" || upParams.factoryResetMode == "menu_wipe_data") {
630         UPDATER_UI_INSTANCE.ShowProgressPage();
631         LOG(INFO) << "User level FactoryReset begin";
632         status = UPDATE_SUCCESS;
633 #if !defined(UPDATER_UT) && defined(UPDATER_UI_SUPPORT)
634         DoProgress();
635 #endif
636         if (FactoryReset(upParams.factoryResetMode == "user_wipe_data" ?
637             USER_WIPE_DATA : MENU_WIPE_DATA, "/data") != 0) {
638             LOG(ERROR) << "FactoryReset user level failed";
639             status = UPDATE_ERROR;
640         }
641         if (status != UPDATE_SUCCESS) {
642             UPDATER_UI_INSTANCE.ShowLogRes(TR(LOGRES_WIPE_FAIL));
643         } else {
644             UPDATER_UI_INSTANCE.ShowSuccessPage();
645             UPDATER_UI_INSTANCE.ShowLogRes(TR(LOGRES_WIPE_FINISH));
646             ClearUpdaterParaMisc();
647             std::this_thread::sleep_for(std::chrono::milliseconds(UI_SHOW_DURATION));
648         }
649     }
650     return status;
651 }
652 
653 std::unordered_map<std::string, std::function<void ()>> InitOptionsFuncTab(char* &optarg,
654     PackageUpdateMode &mode, UpdaterParams &upParams)
655 {
656     std::unordered_map<std::string, std::function<void ()>> optionsFuncTab {
657         {"update_package", [&]() -> void
658         {
659             upParams.updatePackage.push_back(optarg);
660             (void)UPDATER_UI_INSTANCE.SetMode(UPDATERMODE_OTA);
661             mode = HOTA_UPDATE;
662         }},
663         {"retry_count", [&]() -> void
664         {
665             upParams.retryCount = atoi(optarg);
666             HwFaultRetry::GetInstance().SetRetryCount(upParams.retryCount);
667         }},
668         {"factory_wipe_data", [&]() -> void
669         {
670             (void)UPDATER_UI_INSTANCE.SetMode(UPDATERMODE_REBOOTFACTORYRST);
671             upParams.factoryResetMode = "factory_wipe_data";
672         }},
673         {"wipe_data_at_factoryreset_0", [&]() -> void
674         {
675             (void)UPDATER_UI_INSTANCE.SetMode(UPDATERMODE_ATFACTORYRST);
676             upParams.factoryResetMode = "factory_wipe_data";
677         }},
678         {"user_wipe_data", [&]() -> void
679         {
680             (void)UPDATER_UI_INSTANCE.SetMode(UPDATERMODE_REBOOTFACTORYRST);
681             upParams.factoryResetMode = "user_wipe_data";
682         }},
683         {"wipe_data_factory_lowlevel", [&]() -> void
684         {
685             (void)UPDATER_UI_INSTANCE.SetMode(UPDATERMODE_REBOOTFACTORYRST);
686             upParams.factoryResetMode = "user_wipe_data";
687         }},
688         {"menu_wipe_data", [&]() -> void
689         {
690             (void)UPDATER_UI_INSTANCE.SetMode(UPDATERMODE_REBOOTFACTORYRST);
691             upParams.factoryResetMode = "menu_wipe_data";
692         }},
693         {"upgraded_pkg_num", [&]() -> void
694         {
695             upParams.pkgLocation = static_cast<unsigned int>(atoi(optarg));
696         }},
697         {"sdcard_update", [&]() -> void
698         {
699             upParams.updateMode = SDCARD_UPDATE;
700         }},
701         {"UPDATE:MAINIMG", [&]() -> void
702         {
703             upParams.updateMode = SDCARD_UPDATE;
704             upParams.sdExtMode = SDCARD_MAINIMG;
705         }},
706         {"factory_sd_update", [&]() -> void
707         {
708             upParams.updateMode = SDCARD_UPDATE;
709             upParams.sdExtMode = SDCARD_NORMAL_UPDATE;
710         }},
711         {"UPDATE:SD", [&]() -> void
712         {
713             upParams.updateMode = SDCARD_UPDATE;
714             upParams.sdExtMode = SDCARD_NORMAL_UPDATE;
715         }},
716         {"UPDATE:SDFROMDEV", [&]() -> void
717         {
718             upParams.updateMode = SDCARD_UPDATE;
719             upParams.sdExtMode = SDCARD_UPDATE_FROM_DEV;
720         }},
721         {"force_update_action", [&]() -> void
722         {
723             if (std::string(optarg) == POWEROFF) {
724                 upParams.forceUpdate = true;
725             }
726         }},
727         {"night_update", [&]() -> void
728         {
729             (void)UPDATER_UI_INSTANCE.SetMode(UPDATERMODE_NIGHTUPDATE);
730             upParams.forceReboot = true;
731         }},
732         {"sdcard_intral_update", [&]() -> void
733         {
734             upParams.updateMode = SDCARD_UPDATE;
735         }}
736     };
737     return optionsFuncTab;
738 }
739 
740 __attribute__((weak)) bool IsSupportOption([[maybe_unused]] const std::string &option)
741 {
742     LOG(INFO) << "option: " << option;
743     return false;
744 }
745 
746 __attribute__((weak)) UpdaterStatus ProcessOtherOption([[maybe_unused]] const std::string &option,
747     [[maybe_unused]] UpdaterParams &upParams, PackageUpdateMode &mode)
748 {
749     return UPDATE_UNKNOWN;
750 }
751 
752 static UpdaterStatus StartUpdater(const std::vector<std::string> &args,
753     char **argv, PackageUpdateMode &mode, UpdaterParams &upParams)
754 {
755     std::vector<char *> extractedArgs;
756     int rc;
757     int optionIndex;
758     auto optionsFuncTab = InitOptionsFuncTab(optarg, mode, upParams);
759 
760     for (const auto &arg : args) {
761         extractedArgs.push_back(const_cast<char *>(arg.c_str()));
762         STAGE(UPDATE_STAGE_OUT) << "option:" << arg;
763         LOG(INFO) << "option:" << arg;
764     }
765     extractedArgs.push_back(nullptr);
766     extractedArgs.insert(extractedArgs.begin(), argv[0]);
767     while ((rc = getopt_long(extractedArgs.size() - 1, extractedArgs.data(), "", OPTIONS, &optionIndex)) != -1) {
768         switch (rc) {
769             case 0: {
770                 std::string option = OPTIONS[optionIndex].name;
771                 if (optionsFuncTab.find(option) != optionsFuncTab.end()) {
772                     auto optionsFunc = optionsFuncTab.at(option);
773                     optionsFunc();
774                 } else if (IsSupportOption(option)) {
775                     return ProcessOtherOption(option, upParams, mode);
776                 }
777                 break;
778             }
779             default:
780                 LOG(ERROR) << "Invalid argument.";
781                 break;
782         }
783     }
784     optind = 1;
785     if (upParams.pkgLocation == 0) {
786         DeleteInstallTimeFile();
787     }
788     // Sanity checks
789     if (upParams.updateMode == SDCARD_UPDATE) {
790         (void)UPDATER_UI_INSTANCE.SetMode(UPDATERMODE_SDCARD);
791         mode = SDCARD_UPDATE;
792     }
793     return StartUpdaterEntry(upParams);
794 }
795 
796 // add updater mode
797 REGISTER_MODE(Updater, "updater.hdc.configfs");
798 
799 __attribute__((weak)) bool IsNeedWipe()
800 {
801     return false;
802 }
803 
804 void RebootAfterUpdateSuccess(const UpdaterParams &upParams)
805 {
806     if (IsNeedWipe() ||
807         upParams.sdExtMode == SDCARD_UPDATE_FROM_DEV ||
808         upParams.sdExtMode == SDCARD_UPDATE_FROM_DATA) {
809         Utils::UpdaterDoReboot("updater", "Updater wipe data after upgrade success", "--user_wipe_data");
810         return;
811     }
812     if (upParams.factoryResetMode == "factory_wipe_data") {
813         Utils::SetParameter("odm.factory.updater.succssful_flg", "1");
814         LOG(INFO) << "factory wipe data, sleep...";
815         Utils::UsSleep(120 * DISPLAY_TIME); // 120 : 120s
816     }
817     upParams.forceUpdate || upParams.factoryResetMode == "factory_wipe_data" ?
818         Utils::DoShutdown("Updater update success go shut down") :
819             Utils::UpdaterDoReboot("", "Updater update success");
820 }
821 
822 int UpdaterMain(int argc, char **argv)
823 {
824     [[maybe_unused]] UpdaterStatus status = UPDATE_UNKNOWN;
825     UpdaterParams upParams;
826     upParams.callbackProgress = [] (float value) { UPDATER_UI_INSTANCE.ShowProgress(value); };
827     UpdaterInit::GetInstance().InvokeEvent(UPDATER_PRE_INIT_EVENT);
828     std::vector<std::string> args = ParseParams(argc, argv);
829 
830     LOG(INFO) << "Ready to start";
831 #if !defined(UPDATER_UT) && defined(UPDATER_UI_SUPPORT)
832     UPDATER_UI_INSTANCE.InitEnv();
833 #endif
834     UpdaterInit::GetInstance().InvokeEvent(UPDATER_INIT_EVENT);
835     PackageUpdateMode mode = UNKNOWN_UPDATE;
836     status = StartUpdater(args, argv, mode, upParams);
837 #if !defined(UPDATER_UT) && defined(UPDATER_UI_SUPPORT)
838     UPDATER_UI_INSTANCE.Sleep(UI_SHOW_DURATION);
839     if (status != UPDATE_SUCCESS && status != UPDATE_SKIP) {
840         if (mode == HOTA_UPDATE) {
841             UPDATER_UI_INSTANCE.ShowFailedPage();
842             UpdaterInit::GetInstance().InvokeEvent(UPDATER_POST_INIT_EVENT);
843             if (upParams.forceReboot) {
844                 Utils::UsSleep(5 * DISPLAY_TIME); // 5 : 5s
845                 PostUpdater(true);
846                 Utils::UpdaterDoReboot("", "Updater night update fail");
847                 return 0;
848             }
849         } else if (mode == SDCARD_UPDATE) {
850             UPDATER_UI_INSTANCE.ShowLogRes(
851                 status == UPDATE_CORRUPT ? TR(LOGRES_VERIFY_FAILED) : TR(LOGRES_UPDATE_FAILED));
852             UPDATER_UI_INSTANCE.ShowFailedPage();
853         } else if (upParams.factoryResetMode == "user_wipe_data" ||
854             upParams.factoryResetMode == "menu_wipe_data" || upParams.factoryResetMode == "factory_wipe_data") {
855             UPDATER_UI_INSTANCE.ShowFailedPage();
856         } else if (CheckUpdateMode(USB_UPDATE_FAIL)) {
857             (void)UPDATER_UI_INSTANCE.SetMode(UPDATERMODE_USBUPDATE);
858             UPDATER_UI_INSTANCE.ShowFailedPage();
859         } else {
860             UPDATER_UI_INSTANCE.ShowMainpage();
861             UPDATER_UI_INSTANCE.SaveScreen();
862         }
863         // Wait for user input
864         while (true) {
865             Utils::UsSleep(DISPLAY_TIME);
866         }
867         return 0;
868     }
869 #endif
870     PostUpdater(true);
871     RebootAfterUpdateSuccess(upParams);
872     return 0;
873 }
874 } // Updater
875