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
54namespace Updater {
55using Utils::String2Int;
56using namespace Hpackage;
57using namespace Updater::Utils;
58using namespace std::literals::chrono_literals;
59
60[[maybe_unused]] constexpr int DISPLAY_TIME = 1000 * 1000;
61constexpr 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};
82constexpr float VERIFY_PERCENT = 0.05;
83constexpr double FULL_PERCENT = 100.00;
84
85int 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
96static 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
126static 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
158__attribute__((weak)) int32_t VerifySpecialPkgs([[maybe_unused]]UpdaterParams &upParams)
159{
160    return PKG_SUCCESS;
161}
162
163__attribute__((weak)) void UpdaterVerifyFailEntry(bool verifyret)
164{
165    LOG(INFO) << "pre verify package info process";
166    return;
167}
168
169static 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
218bool 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
243bool 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
275UpdaterStatus 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
308static 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
351static 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
403static 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
447UpdaterStatus 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
481static 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
519static 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
542static void PostSdcardUpdatePackages(UpdaterParams &upParams, bool updateResult)
543{
544    if (Utils::CheckUpdateMode(Updater::SDCARD_INTRAL_MODE)) {
545        PostUpdatePackages(upParams, updateResult);
546    }
547}
548
549UpdaterStatus 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
572UpdaterStatus 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
584UpdaterStatus 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
605UpdaterStatus 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
653std::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
752static 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
797REGISTER_MODE(Updater, "updater.hdc.configfs");
798
799__attribute__((weak)) bool IsNeedWipe()
800{
801    return false;
802}
803
804void 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
822int 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