blob: dcc57640f33f4986b481f21e923920ba6a1ec795 [file] [log] [blame]
Dees_Troya449a6f2013-04-07 17:50:11 -05001/*
bigbiffdf8436b2020-08-30 16:22:34 -04002 Copyright 2012-2020 TeamWin
3 This file is part of TWRP/TeamWin Recovery Project.
Dees_Troya449a6f2013-04-07 17:50:11 -05004
bigbiffdf8436b2020-08-30 16:22:34 -04005 TWRP is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation, either version 3 of the License, or
8 (at your option) any later version.
Dees_Troya449a6f2013-04-07 17:50:11 -05009
bigbiffdf8436b2020-08-30 16:22:34 -040010 TWRP is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with TWRP. If not, see <http://www.gnu.org/licenses/>.
Dees_Troya449a6f2013-04-07 17:50:11 -050017*/
18
19#include <stdio.h>
20#include <stdlib.h>
Ethan Yonker74db1572015-10-28 12:44:49 -050021#include <string>
Dees_Troya449a6f2013-04-07 17:50:11 -050022#include <sys/stat.h>
23#include <sys/types.h>
24#include <time.h>
25#include <unistd.h>
Ethan Yonkerf9f99bc2014-12-29 09:10:34 -060026#include <signal.h>
Ethan Yonker74db1572015-10-28 12:44:49 -050027#include "gui/twmsg.h"
Dees_Troya449a6f2013-04-07 17:50:11 -050028
29#include "cutils/properties.h"
Dees_Troya449a6f2013-04-07 17:50:11 -050030
31#ifdef ANDROID_RB_RESTART
32#include "cutils/android_reboot.h"
33#else
34#include <sys/reboot.h>
35#endif
36
37extern "C" {
38#include "gui/gui.h"
39}
Ethan Yonkerf1179622016-08-25 15:32:21 -050040#include "set_metadata.h"
Ethan Yonker74db1572015-10-28 12:44:49 -050041#include "gui/gui.hpp"
42#include "gui/pages.hpp"
43#include "gui/objects.hpp"
Dees_Troya449a6f2013-04-07 17:50:11 -050044#include "twcommon.h"
45#include "twrp-functions.hpp"
46#include "data.hpp"
bigbiff22851b92021-09-01 16:46:57 -040047#include "kernel_module_loader.hpp"
Dees_Troya449a6f2013-04-07 17:50:11 -050048#include "partitions.hpp"
Mohd Faraz0d9a62e2020-02-20 00:10:26 +053049#ifdef __ANDROID_API_N__
50#include <android-base/strings.h>
51#else
52#include <base/strings.h>
53#endif
Dees_Troya449a6f2013-04-07 17:50:11 -050054#include "openrecoveryscript.hpp"
55#include "variables.h"
bigbiffdf8436b2020-08-30 16:22:34 -040056#include "startupArgs.hpp"
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -040057#include "twrpAdbBuFifo.hpp"
Ethan Yonkerc798c9c2015-10-09 11:15:26 -050058#ifdef TW_USE_NEW_MINADBD
bigbiffd58ba182020-03-23 10:02:29 -040059// #include "minadbd/minadbd.h"
Ethan Yonkerc798c9c2015-10-09 11:15:26 -050060#else
61extern "C" {
Ethan Yonker84d61ce2017-05-10 16:11:35 -050062#include "minadbd21/adb.h"
Ethan Yonkerc798c9c2015-10-09 11:15:26 -050063}
64#endif
Dees_Troya449a6f2013-04-07 17:50:11 -050065
Ethan Yonker8373cfe2017-09-08 06:50:54 -050066//extern int adb_server_main(int is_daemon, int server_port, int /* reply_fd */);
Ethan Yonker534d4e02016-08-26 10:05:03 -050067
Dees_Troya449a6f2013-04-07 17:50:11 -050068TWPartitionManager PartitionManager;
69int Log_Offset;
Ethan Yonker6277c792014-09-15 14:54:30 -050070bool datamedia;
Dees_Troya449a6f2013-04-07 17:50:11 -050071
72static void Print_Prop(const char *key, const char *name, void *cookie) {
73 printf("%s=%s\n", key, name);
74}
75
bigbiff7ba75002020-04-11 20:47:09 -040076static void Decrypt_Page(bool SkipDecryption, bool datamedia) {
77 // Offer to decrypt if the device is encrypted
78 if (DataManager::GetIntValue(TW_IS_ENCRYPTED) != 0) {
79 if (SkipDecryption) {
80 LOGINFO("Skipping decryption\n");
Captain Throwback89b56a12021-02-10 18:25:07 -050081 PartitionManager.Update_System_Details();
Mohd Faraz815e2402020-09-19 19:31:52 +053082 } else if (DataManager::GetIntValue(TW_CRYPTO_PWTYPE) != 0) {
bigbiff7ba75002020-04-11 20:47:09 -040083 LOGINFO("Is encrypted, do decrypt page first\n");
Mohd Faraze3948ec2020-08-14 01:40:59 +000084 if (DataManager::GetIntValue(TW_IS_FBE))
85 DataManager::SetValue("tw_crypto_user_id", "0");
bigbiff7ba75002020-04-11 20:47:09 -040086 if (gui_startPage("decrypt", 1, 1) != 0) {
87 LOGERR("Failed to start decrypt GUI page.\n");
bigbiff7ba75002020-04-11 20:47:09 -040088 }
89 }
90 } else if (datamedia) {
Captain Throwback89b56a12021-02-10 18:25:07 -050091 PartitionManager.Update_System_Details();
bigbiff7ba75002020-04-11 20:47:09 -040092 if (tw_get_default_metadata(DataManager::GetSettingsStoragePath().c_str()) != 0) {
93 LOGINFO("Failed to get default contexts and file mode for storage files.\n");
94 } else {
95 LOGINFO("Got default contexts and file mode for storage files.\n");
96 }
97 }
98}
99
bigbiff22851b92021-09-01 16:46:57 -0400100static void process_fastbootd_mode() {
101 LOGINFO("starting fastboot\n");
Ctapchukaefc2ab2021-10-29 14:40:52 +0700102
103#ifdef TW_LOAD_VENDOR_MODULES
bigbiff22851b92021-09-01 16:46:57 -0400104 printf("=> Linking mtab\n");
105 symlink("/proc/mounts", "/etc/mtab");
106 std::string fstab_filename = "/etc/twrp.fstab";
107 if (!TWFunc::Path_Exists(fstab_filename)) {
108 fstab_filename = "/etc/recovery.fstab";
109 }
110 printf("=> Processing %s\n", fstab_filename.c_str());
111 if (!PartitionManager.Process_Fstab(fstab_filename, 1, false)) {
112 LOGERR("Failing out of recovery due to problem with fstab.\n");
113 return;
114 }
115 TWPartition* ven = PartitionManager.Find_Partition_By_Path("/vendor");
116 PartitionManager.Setup_Super_Devices();
117 PartitionManager.Prepare_Super_Volume(ven);
bigbiff850fa282021-10-09 12:37:29 -0400118 KernelModuleLoader::Load_Vendor_Modules();
119 if (android::base::GetBoolProperty("ro.virtual_ab.enabled", false)) {
120 PartitionManager.Unmap_Super_Devices();
121 }
bigbiff22851b92021-09-01 16:46:57 -0400122#endif
bigbiff850fa282021-10-09 12:37:29 -0400123
bigbiff22851b92021-09-01 16:46:57 -0400124 gui_msg(Msg("fastboot_console_msg=Entered Fastboot mode..."));
MD Raza9124c932021-12-07 22:05:08 +0000125 // Check for and run startup script if script exists
126 TWFunc::check_and_run_script("/system/bin/runatboot.sh", "boot");
127 TWFunc::check_and_run_script("/system/bin/postfastboot.sh", "fastboot");
bigbiff22851b92021-09-01 16:46:57 -0400128 if (gui_startPage("fastboot", 1, 1) != 0) {
129 LOGERR("Failed to start fastbootd page.\n");
130 }
131}
132
bigbiffdf8436b2020-08-30 16:22:34 -0400133static void process_recovery_mode(twrpAdbBuFifo* adb_bu_fifo, bool skip_decryption) {
Vojtech Bocek0fc15732014-07-04 01:09:50 +0200134 char crash_prop_val[PROPERTY_VALUE_MAX];
135 int crash_counter;
bigbiff22851b92021-09-01 16:46:57 -0400136 std::string cmdline;
137 if (TWFunc::read_file("/proc/cmdline", cmdline) != 0) {
138 LOGINFO("Unable to read cmdline for fastboot mode\n");
139 }
140
Vojtech Bocek0fc15732014-07-04 01:09:50 +0200141 property_get("twrp.crash_counter", crash_prop_val, "-1");
142 crash_counter = atoi(crash_prop_val) + 1;
143 snprintf(crash_prop_val, sizeof(crash_prop_val), "%d", crash_counter);
144 property_set("twrp.crash_counter", crash_prop_val);
145
bigbiffdf8436b2020-08-30 16:22:34 -0400146 if (crash_counter == 0) {
147 property_list(Print_Prop, NULL);
148 printf("\n");
149 } else {
150 printf("twrp.crash_counter=%d\n", crash_counter);
151 }
Dees_Troya449a6f2013-04-07 17:50:11 -0500152
Dees_Troya449a6f2013-04-07 17:50:11 -0500153 printf("=> Linking mtab\n");
154 symlink("/proc/mounts", "/etc/mtab");
Ethan Yonker53273ec2018-03-09 11:22:54 -0600155 std::string fstab_filename = "/etc/twrp.fstab";
156 if (!TWFunc::Path_Exists(fstab_filename)) {
157 fstab_filename = "/etc/recovery.fstab";
Dees_Troy329383e2013-08-29 14:16:06 +0000158 }
Ethan Yonker53273ec2018-03-09 11:22:54 -0600159 printf("=> Processing %s\n", fstab_filename.c_str());
bigbiff22851b92021-09-01 16:46:57 -0400160 if (!PartitionManager.Process_Fstab(fstab_filename, 1, true)) {
Ethan Yonker53273ec2018-03-09 11:22:54 -0600161 LOGERR("Failing out of recovery due to problem with fstab.\n");
bigbiffdf8436b2020-08-30 16:22:34 -0400162 return;
Dees_Troya449a6f2013-04-07 17:50:11 -0500163 }
bigbiffee7b7ff2020-03-23 15:08:27 -0400164
bigbiff22851b92021-09-01 16:46:57 -0400165#ifdef TW_LOAD_VENDOR_MODULES
166 bool fastboot_mode = cmdline.find("twrpfastboot=1") != std::string::npos;
167 if (fastboot_mode)
bigbiff850fa282021-10-09 12:37:29 -0400168 KernelModuleLoader::Load_Vendor_Modules();
bigbiff22851b92021-09-01 16:46:57 -0400169 else
bigbiff850fa282021-10-09 12:37:29 -0400170 KernelModuleLoader::Load_Vendor_Modules();
bigbiff22851b92021-09-01 16:46:57 -0400171#endif
172
Captain Throwbackdc0823c2020-09-06 13:07:23 -0400173// We are doing this here to allow super partition to be set up prior to overriding properties
174#if defined(TW_INCLUDE_LIBRESETPROP) && defined(TW_OVERRIDE_SYSTEM_PROPS)
Captain Throwback1483a8e2022-01-03 09:52:06 -0500175 stringstream override_props(EXPAND(TW_OVERRIDE_SYSTEM_PROPS));
176 string current_prop;
Captain Throwback2b9ea722021-12-31 21:35:52 -0500177
Captain Throwback1483a8e2022-01-03 09:52:06 -0500178 std::vector<std::string> partition_list;
179 partition_list.push_back (PartitionManager.Get_Android_Root_Path().c_str());
180#ifdef TW_OVERRIDE_PROPS_ADDITIONAL_PARTITIONS
181 std::vector<std::string> additional_partition_list = TWFunc::Split_String(TW_OVERRIDE_PROPS_ADDITIONAL_PARTITIONS, " ");
182 partition_list.insert(partition_list.end(), additional_partition_list.begin(), additional_partition_list.end());
183#endif
184 std::vector<std::string> build_prop_list = {"build.prop"};
185#ifdef TW_SYSTEM_BUILD_PROP_ADDITIONAL_PATHS
186 std::vector<std::string> additional_build_prop_list = TWFunc::Split_String(TW_SYSTEM_BUILD_PROP_ADDITIONAL_PATHS, ";");
187 build_prop_list.insert(build_prop_list.end(), additional_build_prop_list.begin(), additional_build_prop_list.end());
188#endif
189 while (getline(override_props, current_prop, ';')) {
190 string other_prop;
191 if (current_prop.find("=") != string::npos) {
192 other_prop = current_prop.substr(current_prop.find("=") + 1);
193 current_prop = current_prop.substr(0, current_prop.find("="));
194 } else {
195 other_prop = current_prop;
196 }
197 other_prop = android::base::Trim(other_prop);
198 current_prop = android::base::Trim(current_prop);
199
200 for (auto&& partition_mount_point:partition_list) {
Captain Throwback2b9ea722021-12-31 21:35:52 -0500201 for (auto&& prop_file:build_prop_list) {
Captain Throwback1483a8e2022-01-03 09:52:06 -0500202 string sys_val = TWFunc::Partition_Property_Get(other_prop, PartitionManager, partition_mount_point.c_str(), prop_file);
Captain Throwback2b9ea722021-12-31 21:35:52 -0500203 if (!sys_val.empty()) {
Captain Throwback1483a8e2022-01-03 09:52:06 -0500204 if (partition_mount_point == "/system_root") {
205 LOGINFO("Overriding %s with value: \"%s\" from property %s in /system/%s\n", current_prop.c_str(), sys_val.c_str(), other_prop.c_str(),
206 prop_file.c_str());
207 } else {
208 LOGINFO("Overriding %s with value: \"%s\" from property %s in /%s/%s\n", current_prop.c_str(), sys_val.c_str(), other_prop.c_str(),
209 partition_mount_point.c_str(), prop_file.c_str());
210 }
Captain Throwback2b9ea722021-12-31 21:35:52 -0500211 int error = TWFunc::Property_Override(current_prop, sys_val);
212 if (error) {
213 LOGERR("Failed overriding property %s, error_code: %d\n", current_prop.c_str(), error);
214 }
Captain Throwback1483a8e2022-01-03 09:52:06 -0500215 if (partition_mount_point == partition_list.back()) {
216 PartitionManager.UnMount_By_Path(partition_mount_point, false);
217 }
218 goto exit;
Captain Throwback2b9ea722021-12-31 21:35:52 -0500219 } else {
Captain Throwback1483a8e2022-01-03 09:52:06 -0500220 if (partition_mount_point == "/system_root") {
221 LOGINFO("Unable to override property %s: property not found in /system/%s\n", current_prop.c_str(), prop_file.c_str());
222 } else {
223 LOGINFO("Unable to override property %s: property not found in /%s/%s\n", current_prop.c_str(), partition_mount_point.c_str(), prop_file.c_str());
224 }
Captain Throwbackdc0823c2020-09-06 13:07:23 -0400225 }
Captain Throwbackdc0823c2020-09-06 13:07:23 -0400226 }
Captain Throwback1483a8e2022-01-03 09:52:06 -0500227 PartitionManager.UnMount_By_Path(partition_mount_point, false);
Captain Throwbackdc0823c2020-09-06 13:07:23 -0400228 }
Captain Throwback1483a8e2022-01-03 09:52:06 -0500229 exit:
230 continue;
Captain Throwbackdc0823c2020-09-06 13:07:23 -0400231 }
232#endif
233
Dees_Troya449a6f2013-04-07 17:50:11 -0500234 // Check for and run startup script if script exists
bigbiffad58e1b2020-07-06 20:24:34 -0400235 TWFunc::check_and_run_script("/system/bin/runatboot.sh", "boot");
Captain Throwback3345ceb2021-12-10 15:31:48 -0500236 TWFunc::check_and_run_script("/system/bin/postrecoveryboot.sh", "recovery");
Dees_Troya449a6f2013-04-07 17:50:11 -0500237
238#ifdef TW_INCLUDE_INJECTTWRP
239 // Back up TWRP Ramdisk if needed:
240 TWPartition* Boot = PartitionManager.Find_Partition_By_Path("/boot");
Dees_Troya449a6f2013-04-07 17:50:11 -0500241 LOGINFO("Backing up TWRP ramdisk...\n");
242 if (Boot == NULL || Boot->Current_File_System != "emmc")
Vojtech Bocek05534202013-09-11 08:11:56 +0200243 TWFunc::Exec_Cmd("injecttwrp --backup /tmp/backup_recovery_ramdisk.img");
Dees_Troya449a6f2013-04-07 17:50:11 -0500244 else {
245 string injectcmd = "injecttwrp --backup /tmp/backup_recovery_ramdisk.img bd=" + Boot->Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +0200246 TWFunc::Exec_Cmd(injectcmd);
Dees_Troya449a6f2013-04-07 17:50:11 -0500247 }
248 LOGINFO("Backup of TWRP ramdisk done.\n");
249#endif
250
bigbiffdf8436b2020-08-30 16:22:34 -0400251 Decrypt_Page(skip_decryption, datamedia);
bigbiff83298f52021-10-13 19:24:42 -0400252 // Check for and load custom theme if present
253 TWFunc::check_selinux_support();
254 gui_loadCustomResources();
Captain Throwback89b56a12021-02-10 18:25:07 -0500255 PartitionManager.Output_Partition_Logging();
Dees_Troya449a6f2013-04-07 17:50:11 -0500256
Vojtech Bocek2005a842014-03-11 19:40:34 +0100257 // Fixup the RTC clock on devices which require it
bigbiffadc599e2020-05-28 19:36:30 +0000258 if (crash_counter == 0)
259 TWFunc::Fixup_Time_On_Boot();
Vojtech Bocek2005a842014-03-11 19:40:34 +0100260
epicXa721f952021-01-04 13:01:31 +0530261 DataManager::LoadTWRPFolderInfo();
Ian Macdonald1e0474a2020-09-09 02:43:13 +0200262 DataManager::ReadSettingsFile();
bigbiff bigbiff19874f12019-01-08 20:06:57 -0500263
Dees_Troya449a6f2013-04-07 17:50:11 -0500264 // Run any outstanding OpenRecoveryScript
bigbiff25d25b92020-06-19 16:07:38 -0400265 std::string cacheDir = TWFunc::get_log_dir();
266 if (cacheDir == DATA_LOGS_DIR)
267 cacheDir = "/data/cache";
bigbiff bigbiff19874f12019-01-08 20:06:57 -0500268 std::string orsFile = cacheDir + "/recovery/openrecoveryscript";
bigbiffdf8436b2020-08-30 16:22:34 -0400269 if ((DataManager::GetIntValue(TW_IS_ENCRYPTED) == 0 || skip_decryption) && (TWFunc::Path_Exists(SCRIPT_FILE_TMP) || TWFunc::Path_Exists(orsFile))) {
Dees_Troya449a6f2013-04-07 17:50:11 -0500270 OpenRecoveryScript::Run_OpenRecoveryScript();
271 }
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +0100272
Ethan Yonker6f49e112014-09-03 21:42:49 -0500273#ifdef TW_HAS_MTP
Ethan Yonker6f49e112014-09-03 21:42:49 -0500274 char mtp_crash_check[PROPERTY_VALUE_MAX];
275 property_get("mtp.crash_check", mtp_crash_check, "0");
Matt Mower653a1702017-02-16 10:38:52 -0600276 if (DataManager::GetIntValue("tw_mtp_enabled")
277 && !strcmp(mtp_crash_check, "0") && !crash_counter
278 && (!DataManager::GetIntValue(TW_IS_ENCRYPTED) || DataManager::GetIntValue(TW_IS_DECRYPTED))) {
Ethan Yonker6f49e112014-09-03 21:42:49 -0500279 property_set("mtp.crash_check", "1");
Matt Mower653a1702017-02-16 10:38:52 -0600280 LOGINFO("Starting MTP\n");
281 if (!PartitionManager.Enable_MTP())
Ethan Yonkerdf7abac2014-12-29 10:48:17 -0600282 PartitionManager.Disable_MTP();
Matt Mower653a1702017-02-16 10:38:52 -0600283 else
284 gui_msg("mtp_enabled=MTP Enabled");
Ethan Yonker6f49e112014-09-03 21:42:49 -0500285 property_set("mtp.crash_check", "0");
Matt Mower653a1702017-02-16 10:38:52 -0600286 } else if (strcmp(mtp_crash_check, "0")) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500287 gui_warn("mtp_crash=MTP Crashed, not starting MTP on boot.");
Ethan Yonker12055fa2014-09-04 08:06:53 -0500288 DataManager::SetValue("tw_mtp_enabled", 0);
Ethan Yonkerdf7abac2014-12-29 10:48:17 -0600289 PartitionManager.Disable_MTP();
Matt Mower653a1702017-02-16 10:38:52 -0600290 } else if (crash_counter == 1) {
291 LOGINFO("TWRP crashed; disabling MTP as a precaution.\n");
292 PartitionManager.Disable_MTP();
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -0400293 }
Ethan Yonker6f49e112014-09-03 21:42:49 -0500294#endif
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -0400295
Ethan Yonker89583ef2015-08-26 09:01:59 -0500296#ifndef TW_OEM_BUILD
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500297 // Check if system has never been changed
Captain Throwback9d6feb52018-07-27 10:05:24 -0400298 TWPartition* sys = PartitionManager.Find_Partition_By_Path(PartitionManager.Get_Android_Root_Path());
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500299 TWPartition* ven = PartitionManager.Find_Partition_By_Path("/vendor");
Ethan Yonker0e2c6572015-06-04 11:30:02 -0500300 if (sys) {
bigbiffee7b7ff2020-03-23 15:08:27 -0400301 if (sys->Get_Super_Status()) {
bigbiff7ba75002020-04-11 20:47:09 -0400302#ifdef TW_INCLUDE_CRYPTO
bigbiff25d25b92020-06-19 16:07:38 -0400303 std::string recoveryLogDir(DATA_LOGS_DIR);
304 recoveryLogDir += "/recovery";
305 if (!TWFunc::Path_Exists(recoveryLogDir)) {
306 bool created = PartitionManager.Recreate_Logs_Dir();
307 if (!created)
308 LOGERR("Unable to create log directory for TWRP\n");
309 }
bigbiff7ba75002020-04-11 20:47:09 -0400310 DataManager::ReadSettingsFile();
311#endif
bigbiffee7b7ff2020-03-23 15:08:27 -0400312 } else {
313 if ((DataManager::GetIntValue("tw_mount_system_ro") == 0 && sys->Check_Lifetime_Writes() == 0) || DataManager::GetIntValue("tw_mount_system_ro") == 2) {
314 if (DataManager::GetIntValue("tw_never_show_system_ro_page") == 0) {
315 DataManager::SetValue("tw_back", "main");
316 if (gui_startPage("system_readonly", 1, 1) != 0) {
317 LOGERR("Failed to start system_readonly GUI page.\n");
318 }
319 } else if (DataManager::GetIntValue("tw_mount_system_ro") == 0) {
320 sys->Change_Mount_Read_Only(false);
321 if (ven)
322 ven->Change_Mount_Read_Only(false);
Ethan Yonker0e2c6572015-06-04 11:30:02 -0500323 }
bigbiffee7b7ff2020-03-23 15:08:27 -0400324 } else if (DataManager::GetIntValue("tw_mount_system_ro") == 1) {
325 // Do nothing, user selected to leave system read only
326 } else {
Ethan Yonker0e2c6572015-06-04 11:30:02 -0500327 sys->Change_Mount_Read_Only(false);
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500328 if (ven)
329 ven->Change_Mount_Read_Only(false);
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500330 }
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500331 }
332 }
Ethan Yonker89583ef2015-08-26 09:01:59 -0500333#endif
bigbiff7ba75002020-04-11 20:47:09 -0400334
bigbiffaac58612020-08-30 11:18:39 -0400335 TWFunc::Update_Log_File();
336
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -0400337 adb_bu_fifo->threadAdbBuFifo();
338
Ethan Yonker89583ef2015-08-26 09:01:59 -0500339#ifndef TW_OEM_BUILD
Ethan Yonker9132d912015-02-02 10:32:49 -0600340 // Disable flashing of stock recovery
341 TWFunc::Disable_Stock_Recovery_Replace();
Ethan Yonker89583ef2015-08-26 09:01:59 -0500342#endif
bigbiffdf8436b2020-08-30 16:22:34 -0400343}
Dees_Troya449a6f2013-04-07 17:50:11 -0500344
bigbiffdf8436b2020-08-30 16:22:34 -0400345static void reboot() {
Ethan Yonker74db1572015-10-28 12:44:49 -0500346 gui_msg(Msg("rebooting=Rebooting..."));
bigbiffdf8436b2020-08-30 16:22:34 -0400347 TWFunc::Update_Log_File();
Dees_Troya449a6f2013-04-07 17:50:11 -0500348 string Reboot_Arg;
bigbiffdf8436b2020-08-30 16:22:34 -0400349
Dees_Troya449a6f2013-04-07 17:50:11 -0500350 DataManager::GetValue("tw_reboot_arg", Reboot_Arg);
351 if (Reboot_Arg == "recovery")
352 TWFunc::tw_reboot(rb_recovery);
353 else if (Reboot_Arg == "poweroff")
354 TWFunc::tw_reboot(rb_poweroff);
355 else if (Reboot_Arg == "bootloader")
356 TWFunc::tw_reboot(rb_bootloader);
357 else if (Reboot_Arg == "download")
358 TWFunc::tw_reboot(rb_download);
mauronofrioe9a49ef2018-10-03 13:38:16 +0200359 else if (Reboot_Arg == "edl")
360 TWFunc::tw_reboot(rb_edl);
bigbiffdf8436b2020-08-30 16:22:34 -0400361 else if (Reboot_Arg == "fastboot")
362 TWFunc::tw_reboot(rb_fastboot);
Dees_Troya449a6f2013-04-07 17:50:11 -0500363 else
364 TWFunc::tw_reboot(rb_system);
bigbiffdf8436b2020-08-30 16:22:34 -0400365}
366
367int main(int argc, char **argv) {
368 // Recovery needs to install world-readable files, so clear umask
369 // set by init
370 umask(0);
bigbiffdf8436b2020-08-30 16:22:34 -0400371 Log_Offset = 0;
372
373 // Set up temporary log file (/tmp/recovery.log)
374 freopen(TMP_LOG_FILE, "a", stdout);
375 setbuf(stdout, NULL);
376 freopen(TMP_LOG_FILE, "a", stderr);
377 setbuf(stderr, NULL);
378
379 signal(SIGPIPE, SIG_IGN);
380
381 // Handle ADB sideload
382 if (argc == 3 && strcmp(argv[1], "--adbd") == 0) {
383 property_set("ctl.stop", "adbd");
384#ifdef TW_USE_NEW_MINADBD
385 //adb_server_main(0, DEFAULT_ADB_PORT, -1); TODO fix this for android8
386 // minadbd_main();
387#else
388 adb_main(argv[2]);
389#endif
390 return 0;
391 }
392
393#ifdef RECOVERY_SDCARD_ON_DATA
394 datamedia = true;
395#endif
396
397 property_set("ro.twrp.boot", "1");
398 property_set("ro.twrp.version", TW_VERSION_STR);
399
DarthJabba97cd3abb2021-11-28 01:09:44 +0530400#ifdef TARGET_OTA_ASSERT_DEVICE
401 property_set("ro.twrp.target.devices", TARGET_OTA_ASSERT_DEVICE);
402#endif
403
bigbiffdf8436b2020-08-30 16:22:34 -0400404 time_t StartupTime = time(NULL);
405 printf("Starting TWRP %s-%s on %s (pid %d)\n", TW_VERSION_STR, TW_GIT_REVISION, ctime(&StartupTime), getpid());
406
407 // Load default values to set DataManager constants and handle ifdefs
408 DataManager::SetDefaultValues();
409 printf("Starting the UI...\n");
410 gui_init();
411
412 // Load up all the resources
413 gui_loadResources();
414
bigbiffdf8436b2020-08-30 16:22:34 -0400415 startupArgs startup;
416 startup.parse(&argc, &argv);
417 twrpAdbBuFifo *adb_bu_fifo = new twrpAdbBuFifo();
418 TWFunc::Clear_Bootloader_Message();
419
420 if (startup.Get_Fastboot_Mode()) {
bigbiff22851b92021-09-01 16:46:57 -0400421 process_fastbootd_mode();
bigbiffdf8436b2020-08-30 16:22:34 -0400422 delete adb_bu_fifo;
423 TWFunc::Update_Intent_File(startup.Get_Intent());
bigbiffdf8436b2020-08-30 16:22:34 -0400424 reboot();
425 return 0;
426 } else {
427 process_recovery_mode(adb_bu_fifo, startup.Should_Skip_Decryption());
428 }
429
Ian Macdonalda9910222020-10-27 18:02:21 +0100430 PageManager::LoadLanguage(DataManager::GetStrValue("tw_language"));
431 GUIConsole::Translate_Now();
432
epicX271bb3a2020-12-30 01:03:18 +0530433 TWFunc::checkforapp(); //Checking compatibility for TWRP app
434
bigbiffdf8436b2020-08-30 16:22:34 -0400435 // Launch the main GUI
436 gui_start();
437 delete adb_bu_fifo;
438 TWFunc::Update_Intent_File(startup.Get_Intent());
bigbiffdf8436b2020-08-30 16:22:34 -0400439 reboot();
Dees_Troya449a6f2013-04-07 17:50:11 -0500440
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200441 return 0;
Dees_Troya449a6f2013-04-07 17:50:11 -0500442}