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