blob: d67344a8aa28ff85541cd2be95ca6fe994e94d33 [file] [log] [blame]
Dees Troy3be70a82013-10-22 14:25:12 +00001/*
bigbiffaed1bdf2021-08-03 18:21:39 -04002 Copyright 2013 to 2021 TeamWin
Dees Troy3be70a82013-10-22 14:25:12 +00003 This file is part of TWRP/TeamWin Recovery Project.
4
5 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.
9
10 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/>.
17*/
Dees_Troy51a0e822012-09-05 15:24:24 -040018
19#include <stdio.h>
20#include <stdlib.h>
21#include <string.h>
bigbiff7ba75002020-04-11 20:47:09 -040022
Dees_Troy5bf43922012-09-07 16:07:55 -040023#include <sys/mount.h>
bigbiff7ba75002020-04-11 20:47:09 -040024#include <sys/param.h>
25#include <sys/stat.h>
26#include <sys/types.h>
27#include <sys/vfs.h>
Dees_Troy51a0e822012-09-05 15:24:24 -040028#include <unistd.h>
Dees_Troy51127312012-09-08 13:08:49 -040029#include <dirent.h>
Ethan Yonker472f5062016-02-25 13:47:30 -060030#include <fcntl.h>
bigbiff7ba75002020-04-11 20:47:09 -040031#include <iostream>
32#include <libgen.h>
bigbiff7ba75002020-04-11 20:47:09 -040033#include <zlib.h>
34#include <sstream>
bigbiffcfa875c2021-06-20 16:20:27 -040035#include <android-base/properties.h>
36#include <libsnapshot/snapshot.h>
Dees_Troy51a0e822012-09-05 15:24:24 -040037
Ethan Yonker007de982018-08-31 14:23:16 -050038#include "cutils/properties.h"
bigbiff7b4c7a62015-01-01 19:44:14 -050039#include "libblkid/include/blkid.h"
Dees_Troy51a0e822012-09-05 15:24:24 -040040#include "variables.h"
Dees_Troy2673cec2013-04-02 20:22:16 +000041#include "twcommon.h"
Dees_Troy51a0e822012-09-05 15:24:24 -040042#include "partitions.hpp"
Dees_Troy5bf43922012-09-07 16:07:55 -040043#include "data.hpp"
Dees_Troy43d8b002012-09-17 16:00:01 -040044#include "twrp-functions.hpp"
bigbiff bigbiff9c754052013-01-09 09:09:08 -050045#include "twrpTar.hpp"
Ethan Yonker3fdcda42016-11-30 12:29:37 -060046#include "exclude.hpp"
Ethan Yonker1b7a31b2014-07-03 15:09:22 -050047#include "infomanager.hpp"
Ethan Yonker4b94cfd2014-12-11 10:00:45 -060048#include "set_metadata.h"
Ethan Yonker74db1572015-10-28 12:44:49 -050049#include "gui/gui.hpp"
bigbiffce8f83c2015-12-12 18:30:21 -050050#include "adbbu/libtwadbbu.hpp"
Ethan Yonker98661c12018-10-17 08:39:28 -050051#ifdef TW_INCLUDE_CRYPTO
52 #include "crypto/fde/cryptfs.h"
bigbiffa957f072021-03-07 18:20:29 -050053 #include "Decrypt.h"
Ethan Yonker98661c12018-10-17 08:39:28 -050054#else
55 #define CRYPT_FOOTER_OFFSET 0x4000
56#endif
Dees_Troy5bf43922012-09-07 16:07:55 -040057extern "C" {
Dees_Troy38bd7602012-09-14 13:33:53 -040058 #include "mtdutils/mtdutils.h"
59 #include "mtdutils/mounts.h"
Dees_Troya95f55c2013-08-17 13:14:43 +000060#ifdef USE_EXT4
Ethan Yonker8373cfe2017-09-08 06:50:54 -050061 // #include "make_ext4fs.h" TODO need ifdef for android8
62 #include <ext4_utils/make_ext4fs.h>
Dees_Troya95f55c2013-08-17 13:14:43 +000063#endif
Ethan Yonker71413f42014-02-26 13:36:08 -060064#ifdef TW_INCLUDE_CRYPTO
Ethan Yonker66a19492015-12-10 10:19:45 -060065 #include "gpt/gpt.h"
Ethan Yonker71413f42014-02-26 13:36:08 -060066#endif
Dees_Troy5bf43922012-09-07 16:07:55 -040067}
Matt Mower87413642017-01-17 21:14:46 -060068#include <selinux/selinux.h>
Ethan Yonkerf27497f2014-02-09 11:48:33 -060069#include <selinux/label.h>
Dees Troy4159aed2014-02-28 17:24:43 +000070#ifdef HAVE_CAPABILITIES
71#include <sys/capability.h>
72#include <sys/xattr.h>
73#include <linux/xattr.h>
74#endif
HashBanged974bb2016-01-30 14:20:09 -050075#include <sparse_format.h>
Ethan Yonker472f5062016-02-25 13:47:30 -060076#include "progresstracking.hpp"
Dees_Troy51a0e822012-09-05 15:24:24 -040077
bigbiff bigbiff9c754052013-01-09 09:09:08 -050078using namespace std;
79
Ethan Yonker6e8c27a2016-12-22 17:55:57 -060080static int auto_index = 0; // v2 fstab allows you to specify a mount point of "auto" with no /. These items are given a mount point of /auto* where * == auto_index
81
Dees_Troya95f55c2013-08-17 13:14:43 +000082extern struct selabel_handle *selinux_handle;
Ethan Yonker6277c792014-09-15 14:54:30 -050083extern bool datamedia;
Dees_Troya95f55c2013-08-17 13:14:43 +000084
Hashcode62bd9e02013-11-19 21:59:42 -080085struct flag_list {
86 const char *name;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -060087 unsigned long flag;
Hashcode62bd9e02013-11-19 21:59:42 -080088};
89
Matt Mower4ab42b12016-04-21 13:52:18 -050090const struct flag_list mount_flags[] = {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -060091 { "noatime", MS_NOATIME },
92 { "noexec", MS_NOEXEC },
93 { "nosuid", MS_NOSUID },
94 { "nodev", MS_NODEV },
95 { "nodiratime", MS_NODIRATIME },
96 { "ro", MS_RDONLY },
97 { "rw", 0 },
98 { "remount", MS_REMOUNT },
99 { "bind", MS_BIND },
100 { "rec", MS_REC },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000101#ifdef MS_UNBINDABLE
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600102 { "unbindable", MS_UNBINDABLE },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000103#endif
104#ifdef MS_PRIVATE
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600105 { "private", MS_PRIVATE },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000106#endif
107#ifdef MS_SLAVE
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600108 { "slave", MS_SLAVE },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000109#endif
110#ifdef MS_SHARED
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600111 { "shared", MS_SHARED },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000112#endif
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600113 { "sync", MS_SYNCHRONOUS },
114 { 0, 0 },
115};
116
117const char *ignored_mount_items[] = {
118 "defaults=",
119 "errors=",
Ethan Yonker93382822018-11-01 15:25:31 -0500120 "latemount",
121 "sysfs_path=",
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600122 NULL
Hashcode62bd9e02013-11-19 21:59:42 -0800123};
124
Matt Mower2416a502016-04-12 19:54:46 -0500125enum TW_FSTAB_FLAGS {
126 TWFLAG_DEFAULTS, // Retain position
127 TWFLAG_ANDSEC,
128 TWFLAG_BACKUP,
129 TWFLAG_BACKUPNAME,
130 TWFLAG_BLOCKSIZE,
131 TWFLAG_CANBEWIPED,
132 TWFLAG_CANENCRYPTBACKUP,
133 TWFLAG_DISPLAY,
134 TWFLAG_ENCRYPTABLE,
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500135 TWFLAG_FILEENCRYPTION,
Captain Throwback32bcdcd2022-02-08 12:45:01 -0500136 TWFLAG_METADATA_ENCRYPTION,
Matt Mower2416a502016-04-12 19:54:46 -0500137 TWFLAG_FLASHIMG,
138 TWFLAG_FORCEENCRYPT,
139 TWFLAG_FSFLAGS,
140 TWFLAG_IGNOREBLKID,
141 TWFLAG_LENGTH,
142 TWFLAG_MOUNTTODECRYPT,
143 TWFLAG_REMOVABLE,
Matt Mower2416a502016-04-12 19:54:46 -0500144 TWFLAG_SETTINGSSTORAGE,
145 TWFLAG_STORAGE,
146 TWFLAG_STORAGENAME,
147 TWFLAG_SUBPARTITIONOF,
148 TWFLAG_SYMLINK,
149 TWFLAG_USERDATAENCRYPTBACKUP,
150 TWFLAG_USERMRF,
151 TWFLAG_WIPEDURINGFACTORYRESET,
152 TWFLAG_WIPEINGUI,
Ethan Yonker1b190162016-12-05 15:25:19 -0600153 TWFLAG_SLOTSELECT,
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600154 TWFLAG_WAIT,
155 TWFLAG_VERIFY,
156 TWFLAG_CHECK,
157 TWFLAG_ALTDEVICE,
158 TWFLAG_NOTRIM,
159 TWFLAG_VOLDMANAGED,
160 TWFLAG_FORMATTABLE,
161 TWFLAG_RESIZE,
Ethan Yonker93382822018-11-01 15:25:31 -0500162 TWFLAG_KEYDIRECTORY,
Peter Cai28ea7b02019-05-24 11:38:54 +0800163 TWFLAG_WRAPPEDKEY,
Peter Cai439d60c2019-10-17 08:49:10 +0800164 TWFLAG_ADOPTED_MOUNT_DELAY,
Peter Caid68e6412019-11-02 19:22:38 +0800165 TWFLAG_DM_USE_ORIGINAL_PATH,
bigbiff998f8392021-08-06 19:19:33 -0400166 TWFLAG_LOGICAL,
Matt Mower2416a502016-04-12 19:54:46 -0500167};
168
169/* Flags without a trailing '=' are considered dual format flags and can be
170 * written as either 'flagname' or 'flagname=', where the character following
171 * the '=' is Y,y,1 for true and false otherwise.
172 */
173const struct flag_list tw_flags[] = {
174 { "andsec", TWFLAG_ANDSEC },
175 { "backup", TWFLAG_BACKUP },
176 { "backupname=", TWFLAG_BACKUPNAME },
177 { "blocksize=", TWFLAG_BLOCKSIZE },
178 { "canbewiped", TWFLAG_CANBEWIPED },
179 { "canencryptbackup", TWFLAG_CANENCRYPTBACKUP },
180 { "defaults", TWFLAG_DEFAULTS },
181 { "display=", TWFLAG_DISPLAY },
182 { "encryptable=", TWFLAG_ENCRYPTABLE },
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500183 { "fileencryption=", TWFLAG_FILEENCRYPTION },
Captain Throwback32bcdcd2022-02-08 12:45:01 -0500184 { "metadata_encryption=", TWFLAG_METADATA_ENCRYPTION },
Matt Mower2416a502016-04-12 19:54:46 -0500185 { "flashimg", TWFLAG_FLASHIMG },
186 { "forceencrypt=", TWFLAG_FORCEENCRYPT },
187 { "fsflags=", TWFLAG_FSFLAGS },
188 { "ignoreblkid", TWFLAG_IGNOREBLKID },
189 { "length=", TWFLAG_LENGTH },
190 { "mounttodecrypt", TWFLAG_MOUNTTODECRYPT },
191 { "removable", TWFLAG_REMOVABLE },
Matt Mower2416a502016-04-12 19:54:46 -0500192 { "settingsstorage", TWFLAG_SETTINGSSTORAGE },
193 { "storage", TWFLAG_STORAGE },
194 { "storagename=", TWFLAG_STORAGENAME },
195 { "subpartitionof=", TWFLAG_SUBPARTITIONOF },
196 { "symlink=", TWFLAG_SYMLINK },
197 { "userdataencryptbackup", TWFLAG_USERDATAENCRYPTBACKUP },
198 { "usermrf", TWFLAG_USERMRF },
199 { "wipeduringfactoryreset", TWFLAG_WIPEDURINGFACTORYRESET },
200 { "wipeingui", TWFLAG_WIPEINGUI },
Ethan Yonker1b190162016-12-05 15:25:19 -0600201 { "slotselect", TWFLAG_SLOTSELECT },
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600202 { "wait", TWFLAG_WAIT },
203 { "verify", TWFLAG_VERIFY },
204 { "check", TWFLAG_CHECK },
205 { "altdevice", TWFLAG_ALTDEVICE },
206 { "notrim", TWFLAG_NOTRIM },
207 { "voldmanaged=", TWFLAG_VOLDMANAGED },
208 { "formattable", TWFLAG_FORMATTABLE },
209 { "resize", TWFLAG_RESIZE },
Ethan Yonker93382822018-11-01 15:25:31 -0500210 { "keydirectory=", TWFLAG_KEYDIRECTORY },
Peter Cai28ea7b02019-05-24 11:38:54 +0800211 { "wrappedkey", TWFLAG_WRAPPEDKEY },
Peter Cai439d60c2019-10-17 08:49:10 +0800212 { "adopted_mount_delay=", TWFLAG_ADOPTED_MOUNT_DELAY },
Peter Caid68e6412019-11-02 19:22:38 +0800213 { "dm_use_original_path", TWFLAG_DM_USE_ORIGINAL_PATH },
bigbiff998f8392021-08-06 19:19:33 -0400214 { "logical", TWFLAG_LOGICAL },
Matt Mower2416a502016-04-12 19:54:46 -0500215 { 0, 0 },
216};
217
that9e0593e2014-10-08 00:01:24 +0200218TWPartition::TWPartition() {
Dees_Troy51a0e822012-09-05 15:24:24 -0400219 Can_Be_Mounted = false;
220 Can_Be_Wiped = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500221 Can_Be_Backed_Up = false;
Vojtech Bocek1dc30982013-08-30 21:49:30 +0200222 Use_Rm_Rf = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400223 Wipe_During_Factory_Reset = false;
224 Wipe_Available_in_GUI = false;
225 Is_SubPartition = false;
Dees_Troy2691f9d2012-09-24 11:15:49 -0400226 Has_SubPartition = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400227 SubPartition_Of = "";
228 Symlink_Path = "";
229 Symlink_Mount_Point = "";
230 Mount_Point = "";
Dees_Troye58d5262012-09-21 12:27:57 -0400231 Backup_Path = "";
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600232 Wildcard_Block_Device = false;
233 Sysfs_Entry = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400234 Actual_Block_Device = "";
235 Primary_Block_Device = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400236 Alternate_Block_Device = "";
237 Removable = false;
238 Is_Present = false;
239 Length = 0;
240 Size = 0;
241 Used = 0;
242 Free = 0;
243 Backup_Size = 0;
244 Can_Be_Encrypted = false;
245 Is_Encrypted = false;
246 Is_Decrypted = false;
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600247 Is_FBE = false;
Ethan Yonker253368a2014-11-25 15:00:52 -0600248 Mount_To_Decrypt = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400249 Decrypted_Block_Device = "";
250 Display_Name = "";
Dees_Troya13d74f2013-03-24 08:54:55 -0500251 Backup_Display_Name = "";
252 Storage_Name = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400253 Backup_Name = "";
Dees_Troy63c8df72012-09-10 14:02:05 -0400254 Backup_FileName = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400255 MTD_Name = "";
bigbiffce8f83c2015-12-12 18:30:21 -0500256 Backup_Method = BM_NONE;
Dees_Troy83bd4832013-05-04 12:39:56 +0000257 Can_Encrypt_Backup = false;
258 Use_Userdata_Encryption = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400259 Has_Data_Media = false;
Dees_Troye58d5262012-09-21 12:27:57 -0400260 Has_Android_Secure = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400261 Is_Storage = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500262 Is_Settings_Storage = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400263 Storage_Path = "";
264 Current_File_System = "";
265 Fstab_File_System = "";
Hashcode62bd9e02013-11-19 21:59:42 -0800266 Mount_Flags = 0;
267 Mount_Options = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400268 Format_Block_Size = 0;
Dees_Troy68cab492012-12-12 19:29:35 +0000269 Ignore_Blkid = false;
dianlujitao4879b372018-12-03 18:45:47 +0800270 Crypto_Key_Location = "";
Ethan Yonker726a0202014-12-16 20:01:38 -0600271 MTP_Storage_ID = 0;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600272 Can_Flash_Img = false;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500273 Mount_Read_Only = false;
Ethan Yonker66a19492015-12-10 10:19:45 -0600274 Is_Adopted_Storage = false;
275 Adopted_GUID = "";
Ethan Yonker1b190162016-12-05 15:25:19 -0600276 SlotSelect = false;
Ethan Yonker93382822018-11-01 15:25:31 -0500277 Key_Directory = "";
bigbiffee7b7ff2020-03-23 15:08:27 -0400278 Is_Super = false;
Peter Cai439d60c2019-10-17 08:49:10 +0800279 Adopted_Mount_Delay = 0;
Peter Caid68e6412019-11-02 19:22:38 +0800280 Original_Path = "";
281 Use_Original_Path = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400282}
283
284TWPartition::~TWPartition(void) {
285 // Do nothing
286}
287
bigbiff8da46fa2020-09-08 16:42:34 -0400288bool TWPartition::Process_Fstab_Line(const char *fstab_line, bool Display_Error, std::map<string, Flags_Map> *twrp_flags) {
Matt Mower2b2dd152016-04-26 11:24:08 -0500289 char full_line[MAX_FSTAB_LINE_LENGTH];
Matt Mower2416a502016-04-12 19:54:46 -0500290 char twflags[MAX_FSTAB_LINE_LENGTH] = "";
Dees_Troy5bf43922012-09-07 16:07:55 -0400291 char* ptr;
Matt Mower2b2dd152016-04-26 11:24:08 -0500292 int line_len = strlen(fstab_line), index = 0, item_index = 0;
Dees_Troya13d74f2013-03-24 08:54:55 -0500293 bool skip = false;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600294 int fstab_version = 1, mount_point_index = 0, fs_index = 1, block_device_index = 2;
295 TWPartition *additional_entry = NULL;
296 std::map<string, Flags_Map>::iterator it;
Dees_Troy5bf43922012-09-07 16:07:55 -0400297
Matt Mower2b2dd152016-04-26 11:24:08 -0500298 strlcpy(full_line, fstab_line, sizeof(full_line));
bigbiffee7b7ff2020-03-23 15:08:27 -0400299
Dees_Troy51127312012-09-08 13:08:49 -0400300 for (index = 0; index < line_len; index++) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500301 if (full_line[index] == 34)
302 skip = !skip;
303 if (!skip && full_line[index] <= 32)
Dees_Troy5bf43922012-09-07 16:07:55 -0400304 full_line[index] = '\0';
Dees_Troy5bf43922012-09-07 16:07:55 -0400305 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600306 if (line_len < 10)
307 return false; // There can't possibly be a valid fstab line that is less than 10 chars
bigbiff998f8392021-08-06 19:19:33 -0400308 if (fstab_line[0] == '#')
309 return false; // skip comments
310
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600311 if (strncmp(fstab_line, "/dev/", strlen("/dev/")) == 0 || strncmp(fstab_line, "/devices/", strlen("/devices/")) == 0) {
312 fstab_version = 2;
313 block_device_index = 0;
314 mount_point_index = 1;
315 fs_index = 2;
316 }
317
bigbiff998f8392021-08-06 19:19:33 -0400318 if (fstab_line[0] != '/') {
bigbiffee7b7ff2020-03-23 15:08:27 -0400319 block_device_index = 0;
320 fstab_version = 2;
321 mount_point_index = 1;
322 fs_index = 2;
323 }
324
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600325 index = 0;
Dees_Troy5bf43922012-09-07 16:07:55 -0400326 while (index < line_len) {
327 while (index < line_len && full_line[index] == '\0')
328 index++;
329 if (index >= line_len)
330 continue;
331 ptr = full_line + index;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600332 if (item_index == mount_point_index) {
333 Mount_Point = ptr;
bigbiffee7b7ff2020-03-23 15:08:27 -0400334 if (fstab_version == 2 && Is_Super == false) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600335 additional_entry = PartitionManager.Find_Partition_By_Path(Mount_Point);
bigbiff8da46fa2020-09-08 16:42:34 -0400336 if (additional_entry) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600337 LOGINFO("Found an additional entry for '%s'\n", Mount_Point.c_str());
338 }
339 }
bigbiff8da46fa2020-09-08 16:42:34 -0400340 LOGINFO("Processing '%s'\n", Mount_Point.c_str());
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600341 Backup_Path = Mount_Point;
342 Storage_Path = Mount_Point;
343 Display_Name = ptr + 1;
344 Backup_Display_Name = Display_Name;
345 Storage_Name = Display_Name;
346 item_index++;
347 } else if (item_index == fs_index) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400348 // File System
349 Fstab_File_System = ptr;
350 Current_File_System = ptr;
351 item_index++;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600352 } else if (item_index == block_device_index) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400353 // Primary Block Device
Dees_Troy38bd7602012-09-14 13:33:53 -0400354 if (Fstab_File_System == "mtd" || Fstab_File_System == "yaffs2") {
Dees_Troy094207a2012-09-26 12:00:39 -0400355 MTD_Name = ptr;
356 Find_MTD_Block_Device(MTD_Name);
Dees_Troy5fcd8f92012-10-16 12:22:05 -0400357 } else if (Fstab_File_System == "bml") {
358 if (Mount_Point == "/boot")
359 MTD_Name = "boot";
360 else if (Mount_Point == "/recovery")
361 MTD_Name = "recovery";
362 Primary_Block_Device = ptr;
363 if (*ptr != '/')
Dees_Troy2673cec2013-04-02 20:22:16 +0000364 LOGERR("Until we get better BML support, you will have to find and provide the full block device path to the BML devices e.g. /dev/block/bml9 instead of the partition name\n");
Dees_Troy38bd7602012-09-14 13:33:53 -0400365 } else {
366 Primary_Block_Device = ptr;
bigbiff998f8392021-08-06 19:19:33 -0400367 if (*ptr == '/')
368 Find_Real_Block_Device(Primary_Block_Device, Display_Error);
Dees_Troy5bf43922012-09-07 16:07:55 -0400369 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400370 item_index++;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600371 } else if (item_index > 2) {
372 if (fstab_version == 2) {
373 if (item_index == 3) {
374 Process_FS_Flags(ptr);
375 if (additional_entry) {
376 additional_entry->Save_FS_Flags(Fstab_File_System, Mount_Flags, Mount_Options);
377 return false; // We save the extra fs flags in the other partition entry and by returning false, this entry will be deleted
378 }
379 } else {
380 strlcpy(twflags, ptr, sizeof(twflags));
381 }
382 item_index++;
383 } else if (*ptr == '/') { // v2 fstab does not allow alternate block devices
Dees_Troy5bf43922012-09-07 16:07:55 -0400384 // Alternate Block Device
385 Alternate_Block_Device = ptr;
386 Find_Real_Block_Device(Alternate_Block_Device, Display_Error);
387 } else if (strlen(ptr) > 7 && strncmp(ptr, "length=", 7) == 0) {
388 // Partition length
389 ptr += 7;
390 Length = atoi(ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400391 } else if (strlen(ptr) > 6 && strncmp(ptr, "flags=", 6) == 0) {
392 // Custom flags, save for later so that new values aren't overwritten by defaults
393 ptr += 6;
Matt Mower2416a502016-04-12 19:54:46 -0500394 strlcpy(twflags, ptr, sizeof(twflags));
Dees_Troy38bd7602012-09-14 13:33:53 -0400395 } else if (strlen(ptr) == 4 && (strncmp(ptr, "NULL", 4) == 0 || strncmp(ptr, "null", 4) == 0 || strncmp(ptr, "null", 4) == 0)) {
396 // Do nothing
Dees_Troy5bf43922012-09-07 16:07:55 -0400397 } else {
398 // Unhandled data
Matt Mower2b2dd152016-04-26 11:24:08 -0500399 LOGINFO("Unhandled fstab information '%s' in fstab line '%s'\n", ptr, fstab_line);
Dees_Troy5bf43922012-09-07 16:07:55 -0400400 }
401 }
402 while (index < line_len && full_line[index] != '\0')
403 index++;
404 }
405
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600406 // override block devices from the v2 fstab with the ones we read from the twrp.flags file in case they are different
407 if (fstab_version == 2 && twrp_flags && twrp_flags->size() > 0) {
408 it = twrp_flags->find(Mount_Point);
409 if (it != twrp_flags->end()) {
410 if (!it->second.Primary_Block_Device.empty()) {
411 Primary_Block_Device = it->second.Primary_Block_Device;
412 Find_Real_Block_Device(Primary_Block_Device, Display_Error);
413 }
414 if (!it->second.Alternate_Block_Device.empty()) {
415 Alternate_Block_Device = it->second.Alternate_Block_Device;
416 Find_Real_Block_Device(Alternate_Block_Device, Display_Error);
417 }
418 }
419 }
420
421 if (strncmp(fstab_line, "/devices/", strlen("/devices/")) == 0) {
422 Sysfs_Entry = Primary_Block_Device;
423 Primary_Block_Device = "";
424 Is_Storage = true;
425 Removable = true;
426 Wipe_Available_in_GUI = true;
427 Wildcard_Block_Device = true;
428 }
429 if (Primary_Block_Device.find("*") != string::npos)
430 Wildcard_Block_Device = true;
431
bigbiff8da46fa2020-09-08 16:42:34 -0400432 if (Mount_Point == "auto") {
433 Mount_Point = "/auto";
434 char autoi[5];
435 sprintf(autoi, "%i", auto_index);
436 Mount_Point += autoi;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600437 Backup_Path = Mount_Point;
438 Storage_Path = Mount_Point;
dianlujitaob76a73a2020-04-30 20:33:20 +0800439 Backup_Name = Mount_Point.substr(1);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600440 auto_index++;
441 Setup_File_System(Display_Error);
442 Display_Name = "Storage";
443 Backup_Display_Name = Display_Name;
444 Storage_Name = Display_Name;
445 Can_Be_Backed_Up = false;
446 Wipe_Available_in_GUI = true;
447 Is_Storage = true;
448 Removable = true;
449 Wipe_Available_in_GUI = true;
450 } else if (!Is_File_System(Fstab_File_System) && !Is_Image(Fstab_File_System)) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400451 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000452 LOGERR("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400453 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000454 LOGINFO("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Matt Mower72c87ce2016-04-26 14:34:56 -0500455 return false;
Dees_Troy5bf43922012-09-07 16:07:55 -0400456 } else if (Is_File_System(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400457 Find_Actual_Block_Device();
Dees_Troy5bf43922012-09-07 16:07:55 -0400458 Setup_File_System(Display_Error);
dianlujitaob76a73a2020-04-30 20:33:20 +0800459 Backup_Name = Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
Chaosmaster3b682732020-01-25 21:09:28 +0100460 if (Mount_Point == "/" || Mount_Point == "/system" || Mount_Point == "/system_root") {
bigbiff8da46fa2020-09-08 16:42:34 -0400461 Mount_Point = PartitionManager.Get_Android_Root_Path();
462 Backup_Path = Mount_Point;
463 Storage_Path = Mount_Point;
Dees_Troy5bf43922012-09-07 16:07:55 -0400464 Display_Name = "System";
dianlujitaob76a73a2020-04-30 20:33:20 +0800465 Backup_Name = "system";
Dees_Troya13d74f2013-03-24 08:54:55 -0500466 Backup_Display_Name = Display_Name;
467 Storage_Name = Display_Name;
bigbiff8da46fa2020-09-08 16:42:34 -0400468 Wipe_Available_in_GUI = false;
469 Can_Be_Backed_Up = false;
470 Can_Be_Wiped = false;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500471 Mount_Read_Only = true;
bigbiff8da46fa2020-09-08 16:42:34 -0400472 Make_Dir(PartitionManager.Get_Android_Root_Path(), true);
Mohd Faraze3948ec2020-08-14 01:40:59 +0000473 } else if (Mount_Point == "/product") {
474 Display_Name = "Product";
475 Backup_Name = "Product";
476 Backup_Display_Name = Display_Name;
477 Storage_Name = Display_Name;
478 Can_Be_Backed_Up = Wipe_Available_in_GUI = Is_Super ? false : true;
479 Mount_Read_Only = true;
480 } else if (Mount_Point == "/odm") {
481 Display_Name = "ODM";
482 Backup_Name = "ODM";
483 Backup_Display_Name = Display_Name;
484 Storage_Name = Display_Name;
485 Can_Be_Backed_Up = Wipe_Available_in_GUI = Is_Super ? false : true;
486 Mount_Read_Only = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400487 } else if (Mount_Point == "/data") {
488 Display_Name = "Data";
Dees_Troya13d74f2013-03-24 08:54:55 -0500489 Backup_Display_Name = Display_Name;
490 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400491 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400492 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500493 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000494 Can_Encrypt_Backup = true;
495 Use_Userdata_Encryption = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400496 } else if (Mount_Point == "/cache") {
497 Display_Name = "Cache";
Dees_Troya13d74f2013-03-24 08:54:55 -0500498 Backup_Display_Name = Display_Name;
499 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400500 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400501 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500502 Can_Be_Backed_Up = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400503 } else if (Mount_Point == "/datadata") {
Dees_Troy51127312012-09-08 13:08:49 -0400504 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400505 Display_Name = "DataData";
Dees_Troya13d74f2013-03-24 08:54:55 -0500506 Backup_Display_Name = Display_Name;
507 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400508 Is_SubPartition = true;
509 SubPartition_Of = "/data";
Dees_Troy5bf43922012-09-07 16:07:55 -0400510 DataManager::SetValue(TW_HAS_DATADATA, 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500511 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000512 Can_Encrypt_Backup = true;
513 Use_Userdata_Encryption = false; // This whole partition should be encrypted
Dees_Troy5bf43922012-09-07 16:07:55 -0400514 } else if (Mount_Point == "/sd-ext") {
Dees_Troy51127312012-09-08 13:08:49 -0400515 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400516 Display_Name = "SD-Ext";
Dees_Troya13d74f2013-03-24 08:54:55 -0500517 Backup_Display_Name = Display_Name;
518 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400519 Wipe_Available_in_GUI = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400520 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500521 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000522 Can_Encrypt_Backup = true;
523 Use_Userdata_Encryption = true;
Dees_Troy2c50e182012-09-26 20:05:28 -0400524 } else if (Mount_Point == "/boot") {
525 Display_Name = "Boot";
Dees_Troya13d74f2013-03-24 08:54:55 -0500526 Backup_Display_Name = Display_Name;
Dees_Troy2c50e182012-09-26 20:05:28 -0400527 DataManager::SetValue("tw_boot_is_mountable", 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500528 Can_Be_Backed_Up = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500529 } else if (Mount_Point == "/vendor") {
530 Display_Name = "Vendor";
531 Backup_Display_Name = Display_Name;
532 Storage_Name = Display_Name;
533 Mount_Read_Only = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400534 }
535#ifdef TW_EXTERNAL_STORAGE_PATH
536 if (Mount_Point == EXPAND(TW_EXTERNAL_STORAGE_PATH)) {
537 Is_Storage = true;
538 Storage_Path = EXPAND(TW_EXTERNAL_STORAGE_PATH);
Dees_Troyc51f1f92012-09-20 15:32:13 -0400539 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500540 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400541#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000542 if (Mount_Point == "/sdcard" || Mount_Point == "/external_sd" || Mount_Point == "/external_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400543 Is_Storage = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400544 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500545 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400546#endif
Dees_Troyb05ddee2013-01-28 20:24:50 +0000547 }
Dees_Troy8170a922012-09-18 15:40:25 -0400548#ifdef TW_INTERNAL_STORAGE_PATH
549 if (Mount_Point == EXPAND(TW_INTERNAL_STORAGE_PATH)) {
550 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500551 Is_Settings_Storage = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400552 Storage_Path = EXPAND(TW_INTERNAL_STORAGE_PATH);
Dees_Troya13d74f2013-03-24 08:54:55 -0500553 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400554 }
555#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000556 if (Mount_Point == "/emmc" || Mount_Point == "/internal_sd" || Mount_Point == "/internal_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400557 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500558 Is_Settings_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500559 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400560 }
561#endif
Dees_Troy5bf43922012-09-07 16:07:55 -0400562 } else if (Is_Image(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400563 Find_Actual_Block_Device();
Ethan Yonker1b190162016-12-05 15:25:19 -0600564 Setup_Image();
Dees_Troya13d74f2013-03-24 08:54:55 -0500565 if (Mount_Point == "/boot") {
566 Display_Name = "Boot";
567 Backup_Display_Name = Display_Name;
568 Can_Be_Backed_Up = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600569 Can_Flash_Img = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500570 } else if (Mount_Point == "/recovery") {
571 Display_Name = "Recovery";
572 Backup_Display_Name = Display_Name;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600573 Can_Flash_Img = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500574 } else if (Mount_Point == "/system_image") {
575 Display_Name = "System Image";
576 Backup_Display_Name = Display_Name;
HashBanged974bb2016-01-30 14:20:09 -0500577 Can_Flash_Img = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500578 Can_Be_Backed_Up = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500579 } else if (Mount_Point == "/vendor_image") {
580 Display_Name = "Vendor Image";
581 Backup_Display_Name = Display_Name;
HashBanged974bb2016-01-30 14:20:09 -0500582 Can_Flash_Img = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500583 Can_Be_Backed_Up = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500584 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400585 }
586
Matt Mower2416a502016-04-12 19:54:46 -0500587 // Process TWRP fstab flags
588 if (strlen(twflags) > 0) {
589 string Prev_Display_Name = Display_Name;
590 string Prev_Storage_Name = Storage_Name;
591 string Prev_Backup_Display_Name = Backup_Display_Name;
592 Display_Name = "";
593 Storage_Name = "";
594 Backup_Display_Name = "";
595
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600596 Process_TW_Flags(twflags, (fstab_version == 1), fstab_version);
597 Save_FS_Flags(Fstab_File_System, Mount_Flags, Mount_Options);
Matt Mower2416a502016-04-12 19:54:46 -0500598
599 bool has_display_name = !Display_Name.empty();
600 bool has_storage_name = !Storage_Name.empty();
601 bool has_backup_name = !Backup_Display_Name.empty();
602 if (!has_display_name) Display_Name = Prev_Display_Name;
603 if (!has_storage_name) Storage_Name = Prev_Storage_Name;
604 if (!has_backup_name) Backup_Display_Name = Prev_Backup_Display_Name;
605
606 if (has_display_name && !has_storage_name)
607 Storage_Name = Display_Name;
608 if (!has_display_name && has_storage_name)
609 Display_Name = Storage_Name;
610 if (has_display_name && !has_backup_name && Backup_Display_Name != "Android Secure")
611 Backup_Display_Name = Display_Name;
612 if (!has_display_name && has_backup_name)
613 Display_Name = Backup_Display_Name;
614 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600615
616 if (fstab_version == 2 && twrp_flags && twrp_flags->size() > 0) {
617 it = twrp_flags->find(Mount_Point);
618 if (it != twrp_flags->end()) {
619 char twrpflags[MAX_FSTAB_LINE_LENGTH] = "";
620 int skip = 0;
621 string Flags = it->second.Flags;
622 strcpy(twrpflags, Flags.c_str());
623 if (strlen(twrpflags) > strlen("flags=") && strncmp(twrpflags, "flags=", strlen("flags=")) == 0)
624 skip += strlen("flags=");
625 char* flagptr = twrpflags;
626 flagptr += skip;
627 Process_TW_Flags(flagptr, Display_Error, 1); // Forcing the fstab to ver 1 because this data is coming from the /etc/twrp.flags which should be using the TWRP v1 flags format
628 }
629 }
nkk7198fc3992017-12-16 16:26:42 +0200630
631 if (Mount_Point == "/persist" && Can_Be_Mounted) {
632 bool mounted = Is_Mounted();
633 if (mounted || Mount(false)) {
nkk7198fc3992017-12-16 16:26:42 +0200634 TWFunc::Fixup_Time_On_Boot("/persist/time/");
635 if (!mounted)
636 UnMount(false);
637 }
638 }
639
Dees_Troy51127312012-09-08 13:08:49 -0400640 return true;
641}
642
Matt Mower72c87ce2016-04-26 14:34:56 -0500643void TWPartition::Partition_Post_Processing(bool Display_Error) {
644 if (Mount_Point == "/data")
645 Setup_Data_Partition(Display_Error);
646 else if (Mount_Point == "/cache")
647 Setup_Cache_Partition(Display_Error);
648}
649
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600650void TWPartition::ExcludeAll(const string& path) {
651 backup_exclusions.add_absolute_dir(path);
652 wipe_exclusions.add_absolute_dir(path);
653}
654
Matt Mower72c87ce2016-04-26 14:34:56 -0500655void TWPartition::Setup_Data_Partition(bool Display_Error) {
656 if (Mount_Point != "/data")
657 return;
658
659 // Ensure /data is not mounted as tmpfs for qcom hardware decrypt
660 UnMount(false);
661
662#ifdef TW_INCLUDE_CRYPTO
Matt Mower72c87ce2016-04-26 14:34:56 -0500663 Can_Be_Encrypted = true;
664 char crypto_blkdev[255];
665 property_get("ro.crypto.fs_crypto_blkdev", crypto_blkdev, "error");
666 if (strcmp(crypto_blkdev, "error") != 0) {
bigbiff7ba75002020-04-11 20:47:09 -0400667 Set_FBE_Status();
Matt Mower72c87ce2016-04-26 14:34:56 -0500668 Decrypted_Block_Device = crypto_blkdev;
669 LOGINFO("Data already decrypted, new block device: '%s'\n", crypto_blkdev);
bigbiffcda15882021-12-30 17:01:44 -0500670 if (datamedia)
671 Setup_Data_Media();
bigbiff7ba75002020-04-11 20:47:09 -0400672 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
Matt Mower72c87ce2016-04-26 14:34:56 -0500673 } else if (!Mount(false)) {
674 if (Is_Present) {
Ethan Yonker93382822018-11-01 15:25:31 -0500675 if (Key_Directory.empty()) {
Peter Caid68e6412019-11-02 19:22:38 +0800676 set_partition_data(Use_Original_Path ? Original_Path.c_str() : Actual_Block_Device.c_str(), Crypto_Key_Location.c_str(),
Noah Jacobson81d638d2019-04-28 00:10:07 -0400677 Fstab_File_System.c_str());
Ethan Yonker93382822018-11-01 15:25:31 -0500678 if (cryptfs_check_footer() == 0) {
679 Is_Encrypted = true;
680 Is_Decrypted = false;
681 Can_Be_Mounted = false;
682 Current_File_System = "emmc";
683 Setup_Image();
Ethan Yonker93382822018-11-01 15:25:31 -0500684 DataManager::SetValue(TW_CRYPTO_PWTYPE, cryptfs_get_password_type());
Noah Jacobson81d638d2019-04-28 00:10:07 -0400685 DataManager::SetValue("tw_crypto_pwtype_0", cryptfs_get_password_type());
Ethan Yonker93382822018-11-01 15:25:31 -0500686 DataManager::SetValue(TW_CRYPTO_PASSWORD, "");
687 DataManager::SetValue("tw_crypto_display", "");
bigbiffcda15882021-12-30 17:01:44 -0500688 if (datamedia)
689 Setup_Data_Media();
Ethan Yonker93382822018-11-01 15:25:31 -0500690 } else {
691 gui_err("mount_data_footer=Could not mount /data and unable to find crypto footer.");
692 }
693 } else {
Matt Mower72c87ce2016-04-26 14:34:56 -0500694 Is_Encrypted = true;
695 Is_Decrypted = false;
Matt Mower72c87ce2016-04-26 14:34:56 -0500696 }
Ethan Yonker93382822018-11-01 15:25:31 -0500697 } else if (Key_Directory.empty()) {
Noah Jacobson81d638d2019-04-28 00:10:07 -0400698 LOGERR("Primary block device '%s' for mount point '%s' is not present!\n",
699 Primary_Block_Device.c_str(), Mount_Point.c_str());
Matt Mower72c87ce2016-04-26 14:34:56 -0500700 }
701 } else {
bigbiffcda15882021-12-30 17:01:44 -0500702 if (Is_Mounted())
703 UnMount(true);
bigbiff7ba75002020-04-11 20:47:09 -0400704 Set_FBE_Status();
Captain Throwbackacc7f0f2020-12-29 15:54:33 -0500705 int is_device_fbe;
706 DataManager::GetValue(TW_IS_FBE, is_device_fbe);
Captain Throwback8a8e56c2021-10-01 15:12:24 -0400707 char crypto_state[255];
708 property_get("ro.crypto.state", crypto_state, "error");
709 if (!Decrypt_FBE_DE() && strcmp(crypto_state, "error") != 0) {
710 if (is_device_fbe == 1)
711 LOGERR("Unable to decrypt FBE device\n");
712 } else {
713 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
bigbiffcda15882021-12-30 17:01:44 -0500714 if (datamedia)
715 Setup_Data_Media();
716
mauronofrio9bf73352019-11-23 22:27:34 +0100717 }
Matt Mower72c87ce2016-04-26 14:34:56 -0500718 }
719 if (datamedia && (!Is_Encrypted || (Is_Encrypted && Is_Decrypted))) {
720 Setup_Data_Media();
bigbiff25d25b92020-06-19 16:07:38 -0400721 Recreate_Media_Folder();
Matt Mower72c87ce2016-04-26 14:34:56 -0500722 }
723#else
724 if (datamedia) {
725 Setup_Data_Media();
726 Recreate_Media_Folder();
727 }
728#endif
729}
730
bigbiff7ba75002020-04-11 20:47:09 -0400731void TWPartition::Set_FBE_Status() {
732 DataManager::SetValue(TW_IS_DECRYPTED, 1);
733 Is_Encrypted = true;
734 Is_Decrypted = true;
bigbiff7ba75002020-04-11 20:47:09 -0400735 if (Key_Directory.empty()) {
736 Is_FBE = false;
737 DataManager::SetValue(TW_IS_FBE, 0);
738 } else {
Captain Throwbackb5af4f82020-12-29 16:01:10 -0500739 LOGINFO("Setup_Data_Partition::Key_Directory::%s\n", Key_Directory.c_str());
bigbiff7ba75002020-04-11 20:47:09 -0400740 Is_FBE = true;
741 DataManager::SetValue(TW_IS_FBE, 1);
742 }
743}
744
Ethan Yonker93382822018-11-01 15:25:31 -0500745bool TWPartition::Decrypt_FBE_DE() {
bigbiff7ba75002020-04-11 20:47:09 -0400746 if (TWFunc::Path_Exists("/data/unencrypted/key/version")) {
Captain Throwback87d73d62020-02-17 16:44:50 -0500747 DataManager::SetValue(TW_IS_FBE, 1);
Captain Throwback37c3aef2021-10-06 11:38:18 -0400748 PartitionManager.Set_Crypto_State();
749 PartitionManager.Set_Crypto_Type("file");
Ethan Yonker93382822018-11-01 15:25:31 -0500750 LOGINFO("File Based Encryption is present\n");
751#ifdef TW_INCLUDE_FBE
Noah Jacobson81d638d2019-04-28 00:10:07 -0400752 Is_FBE = true;
753 ExcludeAll(Mount_Point + "/convert_fbe");
754 ExcludeAll(Mount_Point + "/unencrypted");
755 ExcludeAll(Mount_Point + "/misc/vold/user_keys");
756 ExcludeAll(Mount_Point + "/misc/vold/volume_keys");
757 ExcludeAll(Mount_Point + "/system/gatekeeper.password.key");
758 ExcludeAll(Mount_Point + "/system/gatekeeper.pattern.key");
759 ExcludeAll(Mount_Point + "/system/locksettings.db");
760 ExcludeAll(Mount_Point + "/system/locksettings.db-wal");
761 ExcludeAll(Mount_Point + "/misc/gatekeeper");
762 ExcludeAll(Mount_Point + "/misc/keystore");
763 ExcludeAll(Mount_Point + "/drm/kek.dat");
bigbiffa957f072021-03-07 18:20:29 -0500764 ExcludeAll(Mount_Point + "/system_de/0/spblob"); // contains data needed to decrypt synthetic password
micky3872ec1df42021-10-14 14:53:06 +0200765 ExcludeAll(Mount_Point + "/system/users/0/gatekeeper.password.key");
766 ExcludeAll(Mount_Point + "/system/users/0/gatekeeper.pattern.key");
Noah Jacobson81d638d2019-04-28 00:10:07 -0400767 ExcludeAll(Mount_Point + "/cache");
768 ExcludeAll(Mount_Point + "/per_boot"); // removed each boot by init
bigbiffa15d02f2021-06-29 20:04:54 -0400769 ExcludeAll(Mount_Point + "/gsi"); // cow devices
770
Noah Jacobson81d638d2019-04-28 00:10:07 -0400771 int retry_count = 3;
772 while (!Decrypt_DE() && --retry_count)
773 usleep(2000);
774 if (retry_count > 0) {
Captain Throwback37c3aef2021-10-06 11:38:18 -0400775 PartitionManager.Set_Crypto_State();
Noah Jacobson81d638d2019-04-28 00:10:07 -0400776 Is_Encrypted = true;
777 Is_Decrypted = false;
778 DataManager::SetValue(TW_IS_ENCRYPTED, 1);
779 string filename;
780 int pwd_type = Get_Password_Type(0, filename);
781 if (pwd_type < 0) {
782 LOGERR("This TWRP does not have synthetic password decrypt support\n");
783 pwd_type = 0; // default password
Ethan Yonker93382822018-11-01 15:25:31 -0500784 }
Noah Jacobson81d638d2019-04-28 00:10:07 -0400785 PartitionManager.Parse_Users(); // after load_all_de_keys() to parse_users
786 std::vector<users_struct>::iterator iter;
787 std::vector<users_struct>* userList = PartitionManager.Get_Users_List();
788 for (iter = userList->begin(); iter != userList->end(); iter++) {
789 if (atoi((*iter).userId.c_str()) != 0) {
790 ExcludeAll(Mount_Point + "/system_de/" + (*iter).userId + "/spblob");
791 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/gatekeeper.password.key");
792 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/gatekeeper.pattern.key");
793 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/locksettings.db");
794 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/locksettings.db-wal");
795 }
796 }
797 DataManager::SetValue(TW_CRYPTO_PWTYPE, pwd_type);
798 DataManager::SetValue("tw_crypto_pwtype_0", pwd_type);
799 DataManager::SetValue(TW_CRYPTO_PASSWORD, "");
800 DataManager::SetValue("tw_crypto_display", "");
801 return true;
802 }
Ethan Yonker93382822018-11-01 15:25:31 -0500803#else
804 LOGERR("FBE found but FBE support not present in TWRP\n");
805#endif
806 }
Captain Throwback87d73d62020-02-17 16:44:50 -0500807 DataManager::SetValue(TW_IS_FBE, 0);
Ethan Yonker93382822018-11-01 15:25:31 -0500808 return false;
809}
810
Matt Mower72c87ce2016-04-26 14:34:56 -0500811void TWPartition::Setup_Cache_Partition(bool Display_Error __unused) {
812 if (Mount_Point != "/cache")
813 return;
814
815 if (!Mount(true))
816 return;
817
818 if (!TWFunc::Path_Exists("/cache/recovery/.")) {
819 LOGINFO("Recreating /cache/recovery folder\n");
820 if (mkdir("/cache/recovery", S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP) != 0)
821 LOGERR("Could not create /cache/recovery\n");
822 }
823}
824
Matt Mower4ab42b12016-04-21 13:52:18 -0500825void TWPartition::Process_FS_Flags(const char *str) {
826 char *options = strdup(str);
827 char *ptr, *savep;
Hashcode62bd9e02013-11-19 21:59:42 -0800828
Matt Mower4ab42b12016-04-21 13:52:18 -0500829 Mount_Options = "";
Hashcode62bd9e02013-11-19 21:59:42 -0800830
Matt Mower4ab42b12016-04-21 13:52:18 -0500831 // Avoid issues with potentially nested strtok by using strtok_r
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600832 for (ptr = strtok_r(options, ",", &savep); ptr; ptr = strtok_r(NULL, ",", &savep)) {
833 char *equals = strstr(ptr, "=");
834 size_t name_len;
Matt Mower4ab42b12016-04-21 13:52:18 -0500835
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600836 if (!equals)
837 name_len = strlen(ptr);
838 else
839 name_len = equals - ptr;
840
841 // There are some flags that we want to ignore in TWRP
842 bool found_match = false;
843 for (const char** ignored_mount_item = ignored_mount_items; *ignored_mount_item; ignored_mount_item++) {
844 if (strncmp(ptr, *ignored_mount_item, name_len) == 0) {
845 found_match = true;
Hashcode62bd9e02013-11-19 21:59:42 -0800846 break;
847 }
848 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600849 if (found_match)
850 continue;
Hashcode62bd9e02013-11-19 21:59:42 -0800851
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600852 // mount_flags are never postfixed by '='
853 if (!equals) {
854 const struct flag_list* mount_flag = mount_flags;
855 for (; mount_flag->name; mount_flag++) {
856 if (strcmp(ptr, mount_flag->name) == 0) {
857 if (mount_flag->flag == MS_RDONLY)
858 Mount_Read_Only = true;
859 else
860 Mount_Flags |= (unsigned)mount_flag->flag;
861 found_match = true;
862 break;
863 }
864 }
865 if (found_match)
866 continue;
Matt Mower4ab42b12016-04-21 13:52:18 -0500867 }
868
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600869 // If we aren't ignoring this flag and it's not a mount flag, then it must be a mount option
870 if (!Mount_Options.empty())
871 Mount_Options += ",";
872 Mount_Options += ptr;
Matt Mower4ab42b12016-04-21 13:52:18 -0500873 }
874 free(options);
Hashcode62bd9e02013-11-19 21:59:42 -0800875}
876
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600877void TWPartition::Save_FS_Flags(const string& local_File_System, int local_Mount_Flags, const string& local_Mount_Options) {
878 partition_fs_flags_struct flags;
879 flags.File_System = local_File_System;
880 flags.Mount_Flags = local_Mount_Flags;
881 flags.Mount_Options = local_Mount_Options;
882 fs_flags.push_back(flags);
883}
884
Matt Mower2416a502016-04-12 19:54:46 -0500885void TWPartition::Apply_TW_Flag(const unsigned flag, const char* str, const bool val) {
886 switch (flag) {
887 case TWFLAG_ANDSEC:
888 Has_Android_Secure = val;
889 break;
890 case TWFLAG_BACKUP:
891 Can_Be_Backed_Up = val;
892 break;
893 case TWFLAG_BACKUPNAME:
894 Backup_Display_Name = str;
895 break;
896 case TWFLAG_BLOCKSIZE:
897 Format_Block_Size = (unsigned long)(atol(str));
898 break;
899 case TWFLAG_CANBEWIPED:
900 Can_Be_Wiped = val;
901 break;
902 case TWFLAG_CANENCRYPTBACKUP:
903 Can_Encrypt_Backup = val;
904 break;
905 case TWFLAG_DEFAULTS:
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600906 case TWFLAG_WAIT:
907 case TWFLAG_VERIFY:
908 case TWFLAG_CHECK:
909 case TWFLAG_NOTRIM:
910 case TWFLAG_VOLDMANAGED:
911 case TWFLAG_RESIZE:
Matt Mower2416a502016-04-12 19:54:46 -0500912 // Do nothing
913 break;
914 case TWFLAG_DISPLAY:
915 Display_Name = str;
916 break;
917 case TWFLAG_ENCRYPTABLE:
918 case TWFLAG_FORCEENCRYPT:
919 Crypto_Key_Location = str;
920 break;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500921 case TWFLAG_FILEENCRYPTION:
922 // This flag isn't used by TWRP but is needed in 9.0 FBE decrypt
923 // fileencryption=ice:aes-256-heh
924 {
925 std::string FBE = str;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500926 size_t colon_loc = FBE.find(":");
927 if (colon_loc == std::string::npos) {
Ethan Yonker93382822018-11-01 15:25:31 -0500928 property_set("fbe.contents", FBE.c_str());
929 property_set("fbe.filenames", "");
930 LOGINFO("FBE contents '%s', filenames ''\n", FBE.c_str());
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500931 break;
932 }
Ethan Yonker93382822018-11-01 15:25:31 -0500933 std::string FBE_contents, FBE_filenames;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500934 FBE_contents = FBE.substr(0, colon_loc);
935 FBE_filenames = FBE.substr(colon_loc + 1);
936 property_set("fbe.contents", FBE_contents.c_str());
937 property_set("fbe.filenames", FBE_filenames.c_str());
938 LOGINFO("FBE contents '%s', filenames '%s'\n", FBE_contents.c_str(), FBE_filenames.c_str());
939 }
940 break;
Captain Throwback32bcdcd2022-02-08 12:45:01 -0500941 case TWFLAG_METADATA_ENCRYPTION:
942 // This flag isn't used by TWRP but is needed for FBEv2 metadata decryption
943 // metadata_encryption=aes-256-xts:wrappedkey_v0
944 {
945 std::string META = str;
946 size_t colon_loc = META.find(":");
947 if (colon_loc == std::string::npos) {
948 property_set("metadata.contents", META.c_str());
949 property_set("metadata.filenames", "");
950 LOGINFO("Metadata contents '%s', filenames ''\n", META.c_str());
951 break;
952 }
953 std::string META_contents, META_filenames;
954 META_contents = META.substr(0, colon_loc);
955 META_filenames = META.substr(colon_loc + 1);
956 property_set("metadata.contents", META_contents.c_str());
957 property_set("metadata.filenames", META_filenames.c_str());
958 LOGINFO("Metadata contents '%s', filenames '%s'\n", META_contents.c_str(), META_filenames.c_str());
959 }
960 break;
Peter Cai28ea7b02019-05-24 11:38:54 +0800961 case TWFLAG_WRAPPEDKEY:
bigbiff437d86f2021-09-26 16:57:14 -0400962 // no more processing needed. leaving it here in case we want to do something in the future
Peter Cai28ea7b02019-05-24 11:38:54 +0800963 break;
Matt Mower2416a502016-04-12 19:54:46 -0500964 case TWFLAG_FLASHIMG:
965 Can_Flash_Img = val;
966 break;
967 case TWFLAG_FSFLAGS:
Matt Mower4ab42b12016-04-21 13:52:18 -0500968 Process_FS_Flags(str);
Matt Mower2416a502016-04-12 19:54:46 -0500969 break;
970 case TWFLAG_IGNOREBLKID:
971 Ignore_Blkid = val;
972 break;
973 case TWFLAG_LENGTH:
974 Length = atoi(str);
975 break;
976 case TWFLAG_MOUNTTODECRYPT:
977 Mount_To_Decrypt = val;
978 break;
979 case TWFLAG_REMOVABLE:
980 Removable = val;
981 break;
Matt Mower2416a502016-04-12 19:54:46 -0500982 case TWFLAG_SETTINGSSTORAGE:
983 Is_Settings_Storage = val;
984 if (Is_Settings_Storage)
985 Is_Storage = true;
986 break;
987 case TWFLAG_STORAGE:
988 Is_Storage = val;
989 break;
990 case TWFLAG_STORAGENAME:
991 Storage_Name = str;
992 break;
993 case TWFLAG_SUBPARTITIONOF:
994 Is_SubPartition = true;
995 SubPartition_Of = str;
996 break;
997 case TWFLAG_SYMLINK:
998 Symlink_Path = str;
999 break;
1000 case TWFLAG_USERDATAENCRYPTBACKUP:
1001 Use_Userdata_Encryption = val;
1002 if (Use_Userdata_Encryption)
1003 Can_Encrypt_Backup = true;
1004 break;
1005 case TWFLAG_USERMRF:
1006 Use_Rm_Rf = val;
1007 break;
1008 case TWFLAG_WIPEDURINGFACTORYRESET:
1009 Wipe_During_Factory_Reset = val;
1010 if (Wipe_During_Factory_Reset) {
1011 Can_Be_Wiped = true;
1012 Wipe_Available_in_GUI = true;
1013 }
1014 break;
1015 case TWFLAG_WIPEINGUI:
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001016 case TWFLAG_FORMATTABLE:
Matt Mower2416a502016-04-12 19:54:46 -05001017 Wipe_Available_in_GUI = val;
1018 if (Wipe_Available_in_GUI)
1019 Can_Be_Wiped = true;
1020 break;
Ethan Yonker1b190162016-12-05 15:25:19 -06001021 case TWFLAG_SLOTSELECT:
1022 SlotSelect = true;
1023 break;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001024 case TWFLAG_ALTDEVICE:
1025 Alternate_Block_Device = str;
1026 break;
Peter Cai439d60c2019-10-17 08:49:10 +08001027 case TWFLAG_ADOPTED_MOUNT_DELAY:
1028 Adopted_Mount_Delay = atoi(str);
1029 break;
Ethan Yonker93382822018-11-01 15:25:31 -05001030 case TWFLAG_KEYDIRECTORY:
1031 Key_Directory = str;
bigbiffa957f072021-03-07 18:20:29 -05001032 LOGINFO("setting Key_Directory to: %s\n", Key_Directory.c_str());
bigbiffd58ba182020-03-23 10:02:29 -04001033 break;
Peter Caid68e6412019-11-02 19:22:38 +08001034 case TWFLAG_DM_USE_ORIGINAL_PATH:
1035 Use_Original_Path = true;
1036 break;
bigbiff998f8392021-08-06 19:19:33 -04001037 case TWFLAG_LOGICAL:
1038 Is_Super = true;
1039 break;
Matt Mower2416a502016-04-12 19:54:46 -05001040 default:
1041 // Should not get here
1042 LOGINFO("Flag identified for processing, but later unmatched: %i\n", flag);
1043 break;
1044 }
1045}
Dees_Troy51127312012-09-08 13:08:49 -04001046
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001047void TWPartition::Process_TW_Flags(char *flags, bool Display_Error, int fstab_ver) {
Matt Mower2416a502016-04-12 19:54:46 -05001048 char separator[2] = {'\n', 0};
1049 char *ptr, *savep;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001050 char source_separator = ';';
1051
1052 if (fstab_ver == 2)
1053 source_separator = ',';
Matt Mower2416a502016-04-12 19:54:46 -05001054
1055 // Semicolons within double-quotes are not forbidden, so replace
1056 // only the semicolons intended as separators with '\n' for strtok
1057 for (unsigned i = 0, skip = 0; i < strlen(flags); i++) {
1058 if (flags[i] == '\"')
Dees_Troya13d74f2013-03-24 08:54:55 -05001059 skip = !skip;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001060 if (!skip && flags[i] == source_separator)
Matt Mower2416a502016-04-12 19:54:46 -05001061 flags[i] = separator[0];
Dees_Troy51127312012-09-08 13:08:49 -04001062 }
1063
Matt Mower2416a502016-04-12 19:54:46 -05001064 // Avoid issues with potentially nested strtok by using strtok_r
1065 ptr = strtok_r(flags, separator, &savep);
1066 while (ptr) {
1067 int ptr_len = strlen(ptr);
1068 const struct flag_list* tw_flag = tw_flags;
Hashcode62bd9e02013-11-19 21:59:42 -08001069
Matt Mower2416a502016-04-12 19:54:46 -05001070 for (; tw_flag->name; tw_flag++) {
1071 int flag_len = strlen(tw_flag->name);
1072
1073 if (strncmp(ptr, tw_flag->name, flag_len) == 0) {
1074 bool flag_val = false;
1075
1076 if (ptr_len > flag_len && (tw_flag->name)[flag_len-1] != '='
1077 && ptr[flag_len] != '=') {
1078 // Handle flags with same starting string
1079 // (e.g. backup and backupname)
1080 continue;
1081 } else if (ptr_len > flag_len && ptr[flag_len] == '=') {
1082 // Handle flags with dual format: Part 1
1083 // (e.g. backup and backup=y. backup=y handled here)
1084 ptr += flag_len + 1;
1085 TWFunc::Strip_Quotes(ptr);
1086 // Skip flags with empty argument
1087 // (e.g. backup=)
1088 if (strlen(ptr) == 0) {
1089 LOGINFO("Flag missing argument or should not include '=': %s=\n", tw_flag->name);
1090 break;
1091 }
1092 flag_val = strchr("yY1", *ptr) != NULL;
1093 } else if (ptr_len == flag_len
1094 && (tw_flag->name)[flag_len-1] == '=') {
1095 // Skip flags missing argument after =
1096 // (e.g. backupname=)
1097 LOGINFO("Flag missing argument: %s\n", tw_flag->name);
1098 break;
1099 } else if (ptr_len > flag_len
1100 && (tw_flag->name)[flag_len-1] == '=') {
1101 // Handle arguments to flags
1102 // (e.g. backupname="My Stuff")
1103 ptr += flag_len;
1104 TWFunc::Strip_Quotes(ptr);
1105 // Skip flags with empty argument
1106 // (e.g. backupname="")
1107 if (strlen(ptr) == 0) {
1108 LOGINFO("Flag missing argument: %s\n", tw_flag->name);
1109 break;
1110 }
1111 } else if (ptr_len == flag_len) {
1112 // Handle flags with dual format: Part 2
1113 // (e.g. backup and backup=y. backup handled here)
1114 flag_val = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001115 } else {
Matt Mower2416a502016-04-12 19:54:46 -05001116 LOGINFO("Flag matched, but could not be processed: %s\n", ptr);
1117 break;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001118 }
Matt Mower2416a502016-04-12 19:54:46 -05001119
1120 Apply_TW_Flag(tw_flag->flag, ptr, flag_val);
1121 break;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001122 }
Matt Mower2416a502016-04-12 19:54:46 -05001123 }
1124 if (tw_flag->name == 0) {
Dees_Troy51127312012-09-08 13:08:49 -04001125 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001126 LOGERR("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -04001127 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001128 LOGINFO("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -04001129 }
Matt Mower2416a502016-04-12 19:54:46 -05001130 ptr = strtok_r(NULL, separator, &savep);
Dees_Troy51127312012-09-08 13:08:49 -04001131 }
Dees_Troy51a0e822012-09-05 15:24:24 -04001132}
1133
Dees_Troy5bf43922012-09-07 16:07:55 -04001134bool TWPartition::Is_File_System(string File_System) {
1135 if (File_System == "ext2" ||
Dees_Troy63c8df72012-09-10 14:02:05 -04001136 File_System == "ext3" ||
Dees_Troy5bf43922012-09-07 16:07:55 -04001137 File_System == "ext4" ||
1138 File_System == "vfat" ||
1139 File_System == "ntfs" ||
1140 File_System == "yaffs2" ||
bigbiff bigbiff3e146522012-11-14 14:32:59 -05001141 File_System == "exfat" ||
Dees_Troye5017042013-08-29 16:38:55 +00001142 File_System == "f2fs" ||
GarfieldHand0b854b2021-11-21 23:46:20 +08001143 File_System == "erofs" ||
Erfan Abdib859e912019-02-05 18:18:46 +02001144 File_System == "squashfs" ||
Dees_Troy5bf43922012-09-07 16:07:55 -04001145 File_System == "auto")
1146 return true;
1147 else
1148 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001149}
1150
Dees_Troy5bf43922012-09-07 16:07:55 -04001151bool TWPartition::Is_Image(string File_System) {
Dees_Troy5fcd8f92012-10-16 12:22:05 -04001152 if (File_System == "emmc" || File_System == "mtd" || File_System == "bml")
Dees_Troy5bf43922012-09-07 16:07:55 -04001153 return true;
1154 else
1155 return false;
1156}
1157
Dees_Troy51127312012-09-08 13:08:49 -04001158bool TWPartition::Make_Dir(string Path, bool Display_Error) {
Ethan Yonker93ac7a02016-11-07 22:05:58 -06001159 if (TWFunc::Get_D_Type_From_Stat(Path) != S_IFDIR)
1160 unlink(Path.c_str());
Dees_Troy43d8b002012-09-17 16:00:01 -04001161 if (!TWFunc::Path_Exists(Path)) {
Dees_Troy51127312012-09-08 13:08:49 -04001162 if (mkdir(Path.c_str(), 0777) == -1) {
1163 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001164 gui_msg(Msg(msg::kError, "create_folder_strerr=Can not create '{1}' folder ({2}).")(Path)(strerror(errno)));
Dees_Troy51127312012-09-08 13:08:49 -04001165 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001166 LOGINFO("Can not create '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001167 return false;
1168 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001169 LOGINFO("Created '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001170 return true;
1171 }
1172 }
1173 return true;
1174}
1175
Dees_Troy5bf43922012-09-07 16:07:55 -04001176void TWPartition::Setup_File_System(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001177 Can_Be_Mounted = true;
1178 Can_Be_Wiped = true;
1179
Dees_Troy5bf43922012-09-07 16:07:55 -04001180 // Make the mount point folder if it doesn't exist
Dees_Troy51127312012-09-08 13:08:49 -04001181 Make_Dir(Mount_Point, Display_Error);
bigbiffce8f83c2015-12-12 18:30:21 -05001182 Backup_Method = BM_FILES;
Dees_Troy5bf43922012-09-07 16:07:55 -04001183}
1184
Ethan Yonker1b190162016-12-05 15:25:19 -06001185void TWPartition::Setup_Image() {
Dees_Troy5bf43922012-09-07 16:07:55 -04001186 Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
1187 Backup_Name = Display_Name;
Gary Peck82599a82012-11-21 16:23:12 -08001188 if (Current_File_System == "emmc")
bigbiffce8f83c2015-12-12 18:30:21 -05001189 Backup_Method = BM_DD;
Gary Peck82599a82012-11-21 16:23:12 -08001190 else if (Current_File_System == "mtd" || Current_File_System == "bml")
bigbiffce8f83c2015-12-12 18:30:21 -05001191 Backup_Method = BM_FLASH_UTILS;
Dees_Troy5bf43922012-09-07 16:07:55 -04001192 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001193 LOGINFO("Unhandled file system '%s' on image '%s'\n", Current_File_System.c_str(), Display_Name.c_str());
Dees_Troy51a0e822012-09-05 15:24:24 -04001194}
1195
Dees_Troye58d5262012-09-21 12:27:57 -04001196void TWPartition::Setup_AndSec(void) {
Dees_Troya13d74f2013-03-24 08:54:55 -05001197 Backup_Display_Name = "Android Secure";
Dees_Troye58d5262012-09-21 12:27:57 -04001198 Backup_Name = "and-sec";
Dees_Troya13d74f2013-03-24 08:54:55 -05001199 Can_Be_Backed_Up = true;
Dees_Troye58d5262012-09-21 12:27:57 -04001200 Has_Android_Secure = true;
1201 Symlink_Path = Mount_Point + "/.android_secure";
1202 Symlink_Mount_Point = "/and-sec";
1203 Backup_Path = Symlink_Mount_Point;
1204 Make_Dir("/and-sec", true);
1205 Recreate_AndSec_Folder();
Kjell Braden3126a112016-06-19 16:58:15 +00001206 Mount_Storage_Retry(true);
Dees_Troye58d5262012-09-21 12:27:57 -04001207}
1208
that9e0593e2014-10-08 00:01:24 +02001209void TWPartition::Setup_Data_Media() {
Ethan Yonker6277c792014-09-15 14:54:30 -05001210 LOGINFO("Setting up '%s' as data/media emulated storage.\n", Mount_Point.c_str());
Ethan Yonker66a19492015-12-10 10:19:45 -06001211 if (Storage_Name.empty() || Storage_Name == "Data")
1212 Storage_Name = "Internal Storage";
Ethan Yonker6277c792014-09-15 14:54:30 -05001213 Has_Data_Media = true;
1214 Is_Storage = true;
Ethan Yonker66a19492015-12-10 10:19:45 -06001215 Storage_Path = Mount_Point + "/media";
Ethan Yonker6277c792014-09-15 14:54:30 -05001216 Symlink_Path = Storage_Path;
Ethan Yonker66a19492015-12-10 10:19:45 -06001217 if (Mount_Point == "/data") {
1218 Is_Settings_Storage = true;
1219 if (strcmp(EXPAND(TW_EXTERNAL_STORAGE_PATH), "/sdcard") == 0) {
1220 Make_Dir("/emmc", false);
1221 Symlink_Mount_Point = "/emmc";
1222 } else {
1223 Make_Dir("/sdcard", false);
1224 Symlink_Mount_Point = "/sdcard";
1225 }
bigbiffcda15882021-12-30 17:01:44 -05001226 Mount(false);
1227 if (TWFunc::Path_Exists(Mount_Point + "/media/0")) {
Ethan Yonker66a19492015-12-10 10:19:45 -06001228 Storage_Path = Mount_Point + "/media/0";
1229 Symlink_Path = Storage_Path;
1230 DataManager::SetValue(TW_INTERNAL_PATH, Mount_Point + "/media/0");
1231 UnMount(true);
1232 }
1233 DataManager::SetValue("tw_has_internal", 1);
1234 DataManager::SetValue("tw_has_data_media", 1);
Ethan Yonker3fdcda42016-11-30 12:29:37 -06001235 backup_exclusions.add_absolute_dir("/data/data/com.google.android.music/files");
bigbiff25d25b92020-06-19 16:07:38 -04001236 backup_exclusions.add_absolute_dir("/data/per_boot"); // DJ9,14Jan2020 - exclude this dir to prevent "error 255" on AOSP ROMs that create and lock it
DarthJabba943d70f42020-08-04 10:31:27 +01001237 backup_exclusions.add_absolute_dir("/data/vendor/dumpsys");
bigbiff25d25b92020-06-19 16:07:38 -04001238 backup_exclusions.add_absolute_dir("/data/cache");
nijel880c92d92022-01-14 10:01:32 -05001239 backup_exclusions.add_absolute_dir("/data/misc/apexdata/com.android.art"); // exclude this dir to prevent "error 255" on AOSP Android 12
Ethan Yonker6355b562017-05-01 09:42:17 -05001240 wipe_exclusions.add_absolute_dir(Mount_Point + "/misc/vold"); // adopted storage keys
Ethan Yonker79f88bd2016-12-09 14:52:12 -06001241 ExcludeAll(Mount_Point + "/system/storage.xml");
Ethan Yonker6277c792014-09-15 14:54:30 -05001242 } else {
nkk713c1e35f2017-03-24 18:28:03 +02001243 int i;
1244 string path;
1245 for (i = 2; i <= 9; i++) {
1246 path = "/sdcard" + TWFunc::to_string(i);
1247 if (!TWFunc::Path_Exists(path)) {
1248 Make_Dir(path, false);
1249 Symlink_Mount_Point = path;
1250 LOGINFO("'%s' data/media emulated storage symlinked to %s.\n", Mount_Point.c_str(), Symlink_Mount_Point.c_str());
1251 break;
1252 }
1253 }
Ethan Yonker66a19492015-12-10 10:19:45 -06001254 if (Mount(true) && TWFunc::Path_Exists(Mount_Point + "/media/0")) {
1255 Storage_Path = Mount_Point + "/media/0";
1256 Symlink_Path = Storage_Path;
1257 UnMount(true);
1258 }
Ethan Yonker6277c792014-09-15 14:54:30 -05001259 }
Ethan Yonker79f88bd2016-12-09 14:52:12 -06001260 ExcludeAll(Mount_Point + "/media");
Ethan Yonker6277c792014-09-15 14:54:30 -05001261}
1262
Dees_Troy5bf43922012-09-07 16:07:55 -04001263void TWPartition::Find_Real_Block_Device(string& Block, bool Display_Error) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001264 char device[PATH_MAX], realDevice[PATH_MAX];
Dees_Troy5bf43922012-09-07 16:07:55 -04001265
Peter Caid68e6412019-11-02 19:22:38 +08001266 Original_Path = Block;
1267
Dees_Troy5bf43922012-09-07 16:07:55 -04001268 strcpy(device, Block.c_str());
1269 memset(realDevice, 0, sizeof(realDevice));
1270 while (readlink(device, realDevice, sizeof(realDevice)) > 0)
1271 {
1272 strcpy(device, realDevice);
1273 memset(realDevice, 0, sizeof(realDevice));
1274 }
1275
bigbiff998f8392021-08-06 19:19:33 -04001276 Block = device;
1277 return;
Dees_Troy5bf43922012-09-07 16:07:55 -04001278}
1279
Kjell Braden3126a112016-06-19 16:58:15 +00001280bool TWPartition::Mount_Storage_Retry(bool Display_Error) {
Dees_Troy8e337f32012-10-13 22:07:49 -04001281 // On some devices, storage doesn't want to mount right away, retry and sleep
Kjell Braden3126a112016-06-19 16:58:15 +00001282 if (!Mount(Display_Error)) {
Dees_Troy8e337f32012-10-13 22:07:49 -04001283 int retry_count = 5;
1284 while (retry_count > 0 && !Mount(false)) {
1285 usleep(500000);
1286 retry_count--;
1287 }
Kjell Braden3126a112016-06-19 16:58:15 +00001288 return Mount(Display_Error);
Dees_Troy8e337f32012-10-13 22:07:49 -04001289 }
Kjell Braden3126a112016-06-19 16:58:15 +00001290 return true;
Dees_Troy8e337f32012-10-13 22:07:49 -04001291}
1292
Dees_Troy38bd7602012-09-14 13:33:53 -04001293bool TWPartition::Find_MTD_Block_Device(string MTD_Name) {
1294 FILE *fp = NULL;
1295 char line[255];
1296
1297 fp = fopen("/proc/mtd", "rt");
1298 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001299 LOGERR("Device does not support /proc/mtd\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001300 return false;
1301 }
1302
1303 while (fgets(line, sizeof(line), fp) != NULL)
1304 {
1305 char device[32], label[32];
1306 unsigned long size = 0;
Dees_Troy38bd7602012-09-14 13:33:53 -04001307 int deviceId;
1308
1309 sscanf(line, "%s %lx %*s %*c%s", device, &size, label);
1310
1311 // Skip header and blank lines
1312 if ((strcmp(device, "dev:") == 0) || (strlen(line) < 8))
1313 continue;
1314
1315 // Strip off the trailing " from the label
1316 label[strlen(label)-1] = '\0';
1317
1318 if (strcmp(label, MTD_Name.c_str()) == 0) {
1319 // We found our device
1320 // Strip off the trailing : from the device
1321 device[strlen(device)-1] = '\0';
1322 if (sscanf(device,"mtd%d", &deviceId) == 1) {
1323 sprintf(device, "/dev/block/mtdblock%d", deviceId);
1324 Primary_Block_Device = device;
Dees_Troy76543db2013-06-19 16:24:30 +00001325 fclose(fp);
1326 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -04001327 }
1328 }
1329 }
1330 fclose(fp);
1331
1332 return false;
1333}
1334
Dees_Troy51127312012-09-08 13:08:49 -04001335bool TWPartition::Get_Size_Via_statfs(bool Display_Error) {
1336 struct statfs st;
1337 string Local_Path = Mount_Point + "/.";
1338
1339 if (!Mount(Display_Error))
1340 return false;
1341
1342 if (statfs(Local_Path.c_str(), &st) != 0) {
1343 if (!Removable) {
1344 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001345 LOGERR("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001346 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001347 LOGINFO("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001348 }
1349 return false;
1350 }
1351 Size = (st.f_blocks * st.f_bsize);
1352 Used = ((st.f_blocks - st.f_bfree) * st.f_bsize);
1353 Free = (st.f_bfree * st.f_bsize);
1354 Backup_Size = Used;
1355 return true;
1356}
1357
1358bool TWPartition::Get_Size_Via_df(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001359 FILE* fp;
1360 char command[255], line[512];
1361 int include_block = 1;
1362 unsigned int min_len;
1363
1364 if (!Mount(Display_Error))
1365 return false;
1366
Dees_Troy38bd7602012-09-14 13:33:53 -04001367 min_len = Actual_Block_Device.size() + 2;
Dees_Troy51127312012-09-08 13:08:49 -04001368 sprintf(command, "df %s > /tmp/dfoutput.txt", Mount_Point.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001369 TWFunc::Exec_Cmd(command);
Dees_Troy51127312012-09-08 13:08:49 -04001370 fp = fopen("/tmp/dfoutput.txt", "rt");
1371 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001372 LOGINFO("Unable to open /tmp/dfoutput.txt.\n");
Dees_Troy5bf43922012-09-07 16:07:55 -04001373 return false;
Dees_Troy51127312012-09-08 13:08:49 -04001374 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001375
1376 while (fgets(line, sizeof(line), fp) != NULL)
1377 {
1378 unsigned long blocks, used, available;
1379 char device[64];
1380 char tmpString[64];
1381
1382 if (strncmp(line, "Filesystem", 10) == 0)
1383 continue;
1384 if (strlen(line) < min_len) {
1385 include_block = 0;
1386 continue;
1387 }
1388 if (include_block) {
1389 sscanf(line, "%s %lu %lu %lu", device, &blocks, &used, &available);
1390 } else {
1391 // The device block string is so long that the df information is on the next line
1392 int space_count = 0;
Dees_Troye58d5262012-09-21 12:27:57 -04001393 sprintf(tmpString, "/dev/block/%s", Actual_Block_Device.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001394 while (tmpString[space_count] == 32)
1395 space_count++;
1396 sscanf(line + space_count, "%lu %lu %lu", &blocks, &used, &available);
1397 }
1398
1399 // Adjust block size to byte size
1400 Size = blocks * 1024ULL;
1401 Used = used * 1024ULL;
1402 Free = available * 1024ULL;
1403 Backup_Size = Used;
1404 }
1405 fclose(fp);
1406 return true;
1407}
1408
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001409unsigned long long TWPartition::IOCTL_Get_Block_Size() {
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001410 Find_Actual_Block_Device();
Ethan Yonker483e9f42016-01-11 22:21:18 -06001411
1412 return TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001413}
1414
Dees_Troy5bf43922012-09-07 16:07:55 -04001415bool TWPartition::Find_Partition_Size(void) {
1416 FILE* fp;
1417 char line[512];
1418 string tmpdevice;
1419
igoriok87e3d932013-01-31 21:03:53 +02001420 fp = fopen("/proc/dumchar_info", "rt");
1421 if (fp != NULL) {
1422 while (fgets(line, sizeof(line), fp) != NULL)
1423 {
1424 char label[32], device[32];
1425 unsigned long size = 0;
1426
thatd43bf2d2014-09-21 23:13:02 +02001427 sscanf(line, "%s %lx %*x %*u %s", label, &size, device);
igoriok87e3d932013-01-31 21:03:53 +02001428
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05001429 // Skip header, annotation and blank lines
igoriok87e3d932013-01-31 21:03:53 +02001430 if ((strncmp(device, "/dev/", 5) != 0) || (strlen(line) < 8))
1431 continue;
1432
1433 tmpdevice = "/dev/";
1434 tmpdevice += label;
1435 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
1436 Size = size;
1437 fclose(fp);
1438 return true;
1439 }
1440 }
1441 }
1442
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001443 unsigned long long ioctl_size = IOCTL_Get_Block_Size();
1444 if (ioctl_size) {
1445 Size = ioctl_size;
1446 return true;
1447 }
1448
Dees_Troy5bf43922012-09-07 16:07:55 -04001449 // In this case, we'll first get the partitions we care about (with labels)
1450 fp = fopen("/proc/partitions", "rt");
1451 if (fp == NULL)
1452 return false;
1453
1454 while (fgets(line, sizeof(line), fp) != NULL)
1455 {
1456 unsigned long major, minor, blocks;
1457 char device[512];
Dees_Troy5bf43922012-09-07 16:07:55 -04001458
Dees_Troy63c8df72012-09-10 14:02:05 -04001459 if (strlen(line) < 7 || line[0] == 'm') continue;
Dees_Troy5bf43922012-09-07 16:07:55 -04001460 sscanf(line + 1, "%lu %lu %lu %s", &major, &minor, &blocks, device);
1461
1462 tmpdevice = "/dev/block/";
1463 tmpdevice += device;
Dees_Troy38bd7602012-09-14 13:33:53 -04001464 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001465 // Adjust block size to byte size
1466 Size = blocks * 1024ULL;
1467 fclose(fp);
1468 return true;
1469 }
1470 }
1471 fclose(fp);
1472 return false;
1473}
1474
Dees_Troy5bf43922012-09-07 16:07:55 -04001475bool TWPartition::Is_Mounted(void) {
1476 if (!Can_Be_Mounted)
1477 return false;
1478
1479 struct stat st1, st2;
1480 string test_path;
1481
1482 // Check to see if the mount point directory exists
1483 test_path = Mount_Point + "/.";
1484 if (stat(test_path.c_str(), &st1) != 0) return false;
1485
1486 // Check to see if the directory above the mount point exists
1487 test_path = Mount_Point + "/../.";
1488 if (stat(test_path.c_str(), &st2) != 0) return false;
1489
1490 // Compare the device IDs -- if they match then we're (probably) using tmpfs instead of an actual device
1491 int ret = (st1.st_dev != st2.st_dev) ? true : false;
Dees_Troy5bf43922012-09-07 16:07:55 -04001492 return ret;
1493}
1494
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05001495bool TWPartition::Is_File_System_Writable(void) {
1496 if (!Is_File_System(Current_File_System) || !Is_Mounted())
1497 return false;
1498
1499 string test_path = Mount_Point + "/.";
1500 return (access(test_path.c_str(), W_OK) == 0);
1501}
1502
Dees_Troy5bf43922012-09-07 16:07:55 -04001503bool TWPartition::Mount(bool Display_Error) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001504 int exfat_mounted = 0;
Martin Dünkelmann6d843782018-12-27 23:40:28 +01001505 unsigned int flags = Mount_Flags;
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001506
Dees_Troy5bf43922012-09-07 16:07:55 -04001507 if (Is_Mounted()) {
1508 return true;
1509 } else if (!Can_Be_Mounted) {
1510 return false;
1511 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001512
1513 Find_Actual_Block_Device();
1514
1515 // Check the current file system before mounting
1516 Check_FS_Type();
bigbiffad58e1b2020-07-06 20:24:34 -04001517 if (Current_File_System == "exfat" && TWFunc::Path_Exists("/system/bin/exfat-fuse")) {
1518 string cmd = "/system/bin/exfat-fuse -o big_writes,max_read=131072,max_write=131072 " + Actual_Block_Device + " " + Mount_Point;
Dees_Troy2673cec2013-04-02 20:22:16 +00001519 LOGINFO("cmd: %s\n", cmd.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001520 string result;
bigbiffad58e1b2020-07-06 20:24:34 -04001521 if (TWFunc::Exec_Cmd(cmd, result, false) != 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001522 LOGINFO("exfat-fuse failed to mount with result '%s', trying vfat\n", result.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001523 Current_File_System = "vfat";
1524 } else {
1525#ifdef TW_NO_EXFAT_FUSE
1526 UnMount(false);
1527 // We'll let the kernel handle it but using exfat-fuse to detect if the file system is actually exfat
1528 // Some kernels let us mount vfat as exfat which doesn't work out too well
1529#else
1530 exfat_mounted = 1;
1531#endif
1532 }
1533 }
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001534
Captain Throwback47bf7202020-10-06 17:39:39 -04001535 if (Current_File_System == "ntfs" && !TWFunc::Path_Exists("/sys/module/tntfs") && (TWFunc::Path_Exists("/system/bin/ntfs-3g") || TWFunc::Path_Exists("/system/bin/mount.ntfs"))) {
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001536 string cmd;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001537 string Ntfsmount_Binary = "";
1538
bigbiffad58e1b2020-07-06 20:24:34 -04001539 if (TWFunc::Path_Exists("/system/bin/ntfs-3g"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001540 Ntfsmount_Binary = "ntfs-3g";
bigbiffad58e1b2020-07-06 20:24:34 -04001541 else if (TWFunc::Path_Exists("/system/bin/mount.ntfs"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001542 Ntfsmount_Binary = "mount.ntfs";
1543
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001544 if (Mount_Read_Only)
bigbiffad58e1b2020-07-06 20:24:34 -04001545 cmd = "/system/bin/" + Ntfsmount_Binary + " -o ro " + Actual_Block_Device + " " + Mount_Point;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001546 else
bigbiffad58e1b2020-07-06 20:24:34 -04001547 cmd = "/system/bin/" + Ntfsmount_Binary + " " + Actual_Block_Device + " " + Mount_Point;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001548 LOGINFO("cmd: '%s'\n", cmd.c_str());
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001549
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001550 if (TWFunc::Exec_Cmd(cmd) == 0) {
1551 return true;
1552 } else {
1553 LOGINFO("ntfs-3g failed to mount, trying regular mount method.\n");
1554 }
Captain Throwback47bf7202020-10-06 17:39:39 -04001555 } else {
1556 if (Current_File_System == "ntfs" && TWFunc::Path_Exists("/sys/module/tntfs"))
1557 Current_File_System = "tntfs";
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001558 }
1559
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001560 if (Mount_Read_Only)
1561 flags |= MS_RDONLY;
1562
Dees_Troy22042032012-12-18 21:23:08 +00001563 if (Fstab_File_System == "yaffs2") {
1564 // mount an MTD partition as a YAFFS2 filesystem.
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001565 flags = MS_NOATIME | MS_NODEV | MS_NODIRATIME;
1566 if (Mount_Read_Only)
1567 flags |= MS_RDONLY;
Dees_Troy76543db2013-06-19 16:24:30 +00001568 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags, NULL) < 0) {
1569 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags | MS_RDONLY, NULL) < 0) {
1570 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001571 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy76543db2013-06-19 16:24:30 +00001572 else
1573 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
1574 return false;
1575 } else {
1576 LOGINFO("Mounted '%s' (MTD) as RO\n", Mount_Point.c_str());
1577 return true;
1578 }
1579 } else {
1580 struct stat st;
1581 string test_path = Mount_Point;
1582 if (stat(test_path.c_str(), &st) < 0) {
1583 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001584 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy76543db2013-06-19 16:24:30 +00001585 else
1586 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
1587 return false;
1588 }
1589 mode_t new_mode = st.st_mode | S_IXUSR | S_IXGRP | S_IXOTH;
1590 if (new_mode != st.st_mode) {
1591 LOGINFO("Fixing execute permissions for %s\n", Mount_Point.c_str());
1592 if (chmod(Mount_Point.c_str(), new_mode) < 0) {
1593 if (Display_Error)
1594 LOGERR("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
1595 else
1596 LOGINFO("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
1597 return false;
1598 }
1599 }
Dees_Troy22042032012-12-18 21:23:08 +00001600 return true;
Dees_Troy76543db2013-06-19 16:24:30 +00001601 }
thatc7572eb2015-03-31 18:55:30 +02001602 }
1603
1604 string mount_fs = Current_File_System;
1605 if (Current_File_System == "exfat" && TWFunc::Path_Exists("/sys/module/texfat"))
1606 mount_fs = "texfat";
1607
1608 if (!exfat_mounted &&
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001609 mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), mount_fs.c_str(), flags, Mount_Options.c_str()) != 0 &&
1610 mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), mount_fs.c_str(), flags, NULL) != 0) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001611#ifdef TW_NO_EXFAT_FUSE
1612 if (Current_File_System == "exfat") {
Dees_Troy2673cec2013-04-02 20:22:16 +00001613 LOGINFO("Mounting exfat failed, trying vfat...\n");
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001614 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), "vfat", 0, NULL) != 0) {
Dees_Troy85f44ed2013-01-09 18:42:36 +00001615 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001616 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy85f44ed2013-01-09 18:42:36 +00001617 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001618 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001619 LOGINFO("Actual block device: '%s', current file system: '%s', flags: 0x%8x, options: '%s'\n", Actual_Block_Device.c_str(), Current_File_System.c_str(), flags, Mount_Options.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001620 return false;
Dees_Troy85f44ed2013-01-09 18:42:36 +00001621 }
Dees_Troyb05ddee2013-01-28 20:24:50 +00001622 } else {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001623#endif
bigbiff bigbiff26774a02014-03-29 18:22:00 -04001624 if (!Removable && Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001625 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001626 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001627 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
1628 LOGINFO("Actual block device: '%s', current file system: '%s'\n", Actual_Block_Device.c_str(), Current_File_System.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001629 return false;
1630#ifdef TW_NO_EXFAT_FUSE
Dees_Troy85f44ed2013-01-09 18:42:36 +00001631 }
1632#endif
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001633 }
Ethan Yonker253368a2014-11-25 15:00:52 -06001634
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001635 if (Removable)
1636 Update_Size(Display_Error);
1637
bigbiffcda15882021-12-30 17:01:44 -05001638 if (!Symlink_Mount_Point.empty()) {
bigbiffbe4f46c2021-04-24 11:48:54 -04001639 if (!Bind_Mount(false))
1640 return false;
1641 }
1642 return true;
1643}
1644
1645bool TWPartition::Bind_Mount(bool Display_Error) {
1646 if (TWFunc::Path_Exists(Symlink_Path)) {
1647 if (mount(Symlink_Path.c_str(), Symlink_Mount_Point.c_str(), "", MS_BIND, NULL) < 0) {
1648 return false;
1649 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001650 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001651 return true;
1652}
1653
1654bool TWPartition::UnMount(bool Display_Error) {
1655 if (Is_Mounted()) {
1656 int never_unmount_system;
1657
1658 DataManager::GetValue(TW_DONT_UNMOUNT_SYSTEM, never_unmount_system);
Captain Throwback9d6feb52018-07-27 10:05:24 -04001659 if (never_unmount_system == 1 && Mount_Point == PartitionManager.Get_Android_Root_Path())
Dees_Troy5bf43922012-09-07 16:07:55 -04001660 return true; // Never unmount system if you're not supposed to unmount it
1661
Matt Mowera8e6d832017-02-14 20:20:59 -06001662 if (Is_Storage && MTP_Storage_ID > 0)
Ethan Yonker726a0202014-12-16 20:01:38 -06001663 PartitionManager.Remove_MTP_Storage(MTP_Storage_ID);
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001664
Dees_Troy38bd7602012-09-14 13:33:53 -04001665 if (!Symlink_Mount_Point.empty())
1666 umount(Symlink_Mount_Point.c_str());
1667
Dees_Troyb05ddee2013-01-28 20:24:50 +00001668 umount(Mount_Point.c_str());
1669 if (Is_Mounted()) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001670 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001671 gui_msg(Msg(msg::kError, "fail_unmount=Failed to unmount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy5bf43922012-09-07 16:07:55 -04001672 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001673 LOGINFO("Unable to unmount '%s'\n", Mount_Point.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001674 return false;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001675 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -04001676 return true;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001677 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001678 } else {
1679 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001680 }
1681}
1682
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05001683bool TWPartition::ReMount(bool Display_Error) {
1684 if (UnMount(Display_Error))
1685 return Mount(Display_Error);
1686 return false;
1687}
1688
1689bool TWPartition::ReMount_RW(bool Display_Error) {
1690 // No need to remount if already mounted rw
1691 if (Is_File_System_Writable())
1692 return true;
1693
1694 bool ro = Mount_Read_Only;
1695 int flags = Mount_Flags;
1696
1697 Mount_Read_Only = false;
1698 Mount_Flags &= ~MS_RDONLY;
1699
1700 bool ret = ReMount(Display_Error);
1701
1702 Mount_Read_Only = ro;
1703 Mount_Flags = flags;
1704
1705 return ret;
1706}
1707
Gary Peck43acadf2012-11-21 21:19:01 -08001708bool TWPartition::Wipe(string New_File_System) {
Ethan Yonker726a0202014-12-16 20:01:38 -06001709 bool wiped = false, update_crypt = false, recreate_media = true;
Dees_Troy16c2b312013-01-15 16:51:18 +00001710 int check;
Dees_Troy16c2b312013-01-15 16:51:18 +00001711
Dees_Troy38bd7602012-09-14 13:33:53 -04001712 if (!Can_Be_Wiped) {
Matt Mower3c366972015-12-25 19:28:31 -06001713 gui_msg(Msg(msg::kError, "cannot_wipe=Partition {1} cannot be wiped.")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04001714 return false;
1715 }
1716
Dees_Troyc51f1f92012-09-20 15:32:13 -04001717 if (Mount_Point == "/cache")
Dees_Troy2673cec2013-04-02 20:22:16 +00001718 Log_Offset = 0;
Dees_Troyc51f1f92012-09-20 15:32:13 -04001719
bigbiff4a60bee2021-01-23 14:08:03 -05001720 if (Mount_Point == PartitionManager.Get_Android_Root_Path()) {
1721 if (tw_get_default_metadata(PartitionManager.Get_Android_Root_Path().c_str()) != 0) {
1722 gui_msg(Msg(msg::kWarning, "restore_system_context=Unable to get default context for {1} -- Android may not boot.")(PartitionManager.Get_Android_Root_Path()));
1723 }
1724 }
1725
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001726 if (Has_Data_Media && Current_File_System == New_File_System) {
Dees_Troy16c2b312013-01-15 16:51:18 +00001727 wiped = Wipe_Data_Without_Wiping_Media();
bigbiff25d25b92020-06-19 16:07:38 -04001728 if (Mount_Point == "/data" && TWFunc::get_log_dir() == DATA_LOGS_DIR) {
1729 bool created = PartitionManager.Recreate_Logs_Dir();
1730 if (!created)
1731 LOGERR("Unable to create log directory for TWRP\n");
bigbiff7ba75002020-04-11 20:47:09 -04001732 }
Ethan Yonker5eac2222014-06-11 12:22:55 -05001733 recreate_media = false;
Dees_Troy16c2b312013-01-15 16:51:18 +00001734 } else {
Dees_Troy16c2b312013-01-15 16:51:18 +00001735 DataManager::GetValue(TW_RM_RF_VAR, check);
Hashcodedabfd492013-08-29 22:45:30 -07001736 if (check || Use_Rm_Rf)
Dees_Troy16c2b312013-01-15 16:51:18 +00001737 wiped = Wipe_RMRF();
1738 else if (New_File_System == "ext4")
1739 wiped = Wipe_EXT4();
1740 else if (New_File_System == "ext2" || New_File_System == "ext3")
dianlujitao4879b372018-12-03 18:45:47 +08001741 wiped = Wipe_EXTFS(New_File_System);
Dees_Troy16c2b312013-01-15 16:51:18 +00001742 else if (New_File_System == "exfat")
1743 wiped = Wipe_EXFAT();
Captain Throwback47bf7202020-10-06 17:39:39 -04001744 else if (New_File_System == "ntfs" || Current_File_System == "tntfs")
1745 wiped = Wipe_NTFS();
Dees_Troy16c2b312013-01-15 16:51:18 +00001746 else if (New_File_System == "yaffs2")
1747 wiped = Wipe_MTD();
Dees_Troye5017042013-08-29 16:38:55 +00001748 else if (New_File_System == "f2fs")
1749 wiped = Wipe_F2FS();
Captain Throwback47bf7202020-10-06 17:39:39 -04001750 else if (New_File_System == "vfat")
1751 wiped = Wipe_FAT();
Dees_Troy16c2b312013-01-15 16:51:18 +00001752 else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001753 LOGERR("Unable to wipe '%s' -- unknown file system '%s'\n", Mount_Point.c_str(), New_File_System.c_str());
Dees_Troy16c2b312013-01-15 16:51:18 +00001754 return false;
1755 }
1756 update_crypt = wiped;
bigbiff7ba75002020-04-11 20:47:09 -04001757 update_crypt = false;
Gary Pecke8bc5d72012-12-21 06:45:25 -08001758 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001759
Gary Pecke8bc5d72012-12-21 06:45:25 -08001760 if (wiped) {
Mohd Faraze1d72622020-06-15 00:28:32 +05301761 if (Mount_Point == "/cache" && TWFunc::get_log_dir() != DATA_LOGS_DIR)
1762 DataManager::Output_Version();
1763
bigbiff4a60bee2021-01-23 14:08:03 -05001764 if (Mount_Point == PartitionManager.Get_Android_Root_Path()) {
1765 tw_set_default_metadata(PartitionManager.Get_Android_Root_Path().c_str());
1766 }
Dees_Troy16c2b312013-01-15 16:51:18 +00001767 if (update_crypt) {
1768 Setup_File_System(false);
1769 if (Is_Encrypted && !Is_Decrypted) {
1770 // just wiped an encrypted partition back to its unencrypted state
1771 Is_Encrypted = false;
1772 Is_Decrypted = false;
1773 Decrypted_Block_Device = "";
1774 if (Mount_Point == "/data") {
1775 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
1776 DataManager::SetValue(TW_IS_DECRYPTED, 0);
1777 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08001778 }
1779 }
Ethan Yonker5eac2222014-06-11 12:22:55 -05001780
Captain Throwback63573b52021-10-02 20:47:33 -04001781 if (Is_Storage && Mount(false) && !Is_FBE)
bigbiffbe4f46c2021-04-24 11:48:54 -04001782 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
Gary Pecke8bc5d72012-12-21 06:45:25 -08001783 }
Matt Mower209c9632016-01-20 12:08:35 -06001784
Gary Pecke8bc5d72012-12-21 06:45:25 -08001785 return wiped;
Dees_Troy51a0e822012-09-05 15:24:24 -04001786}
1787
Gary Peck43acadf2012-11-21 21:19:01 -08001788bool TWPartition::Wipe() {
Gary Peck82599a82012-11-21 16:23:12 -08001789 if (Is_File_System(Current_File_System))
1790 return Wipe(Current_File_System);
1791 else
1792 return Wipe(Fstab_File_System);
Gary Peck43acadf2012-11-21 21:19:01 -08001793}
1794
Dees_Troye58d5262012-09-21 12:27:57 -04001795bool TWPartition::Wipe_AndSec(void) {
1796 if (!Has_Android_Secure)
1797 return false;
1798
Dees_Troye58d5262012-09-21 12:27:57 -04001799 if (!Mount(true))
1800 return false;
1801
Ethan Yonker74db1572015-10-28 12:44:49 -05001802 gui_msg(Msg("wiping=Wiping {1}")(Backup_Display_Name));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001803 TWFunc::removeDir(Mount_Point + "/.android_secure/", true);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001804 return true;
Dees_Troye58d5262012-09-21 12:27:57 -04001805}
1806
bigbiffaed1bdf2021-08-03 18:21:39 -04001807bool TWPartition::Wipe_Data_Cache(void) {
1808 if (!Mount(true))
1809 return false;
1810 gui_msg(Msg("wiping=Wiping {1}")(Mount_Point + "/cache/"));
1811 TWFunc::removeDir(Mount_Point + "/cache/", true);
1812 return true;
1813}
1814
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001815bool TWPartition::Can_Repair() {
Ethan Yonkera2719152015-05-28 09:44:41 -05001816 if (Mount_Read_Only)
1817 return false;
bigbiffad58e1b2020-07-06 20:24:34 -04001818 if (Current_File_System == "vfat" && TWFunc::Path_Exists("/system/bin/fsck.fat"))
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001819 return true;
bigbiffad58e1b2020-07-06 20:24:34 -04001820 else if ((Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") && TWFunc::Path_Exists("/system/bin/e2fsck"))
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001821 return true;
bigbiffad58e1b2020-07-06 20:24:34 -04001822 else if (Current_File_System == "exfat" && TWFunc::Path_Exists("/system/bin/fsck.exfat"))
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001823 return true;
bigbiffad58e1b2020-07-06 20:24:34 -04001824 else if (Current_File_System == "f2fs" && TWFunc::Path_Exists("/system/bin/fsck.f2fs"))
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001825 return true;
Captain Throwback47bf7202020-10-06 17:39:39 -04001826 else if ((Current_File_System == "ntfs" || Current_File_System == "tntfs") && (TWFunc::Path_Exists("/system/bin/ntfsfix") || TWFunc::Path_Exists("/system/bin/fsck.ntfs")))
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001827 return true;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001828 return false;
1829}
1830
1831bool TWPartition::Repair() {
1832 string command;
1833
1834 if (Current_File_System == "vfat") {
bigbiffad58e1b2020-07-06 20:24:34 -04001835 if (!TWFunc::Path_Exists("/system/bin/fsck.fat")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001836 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.fat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001837 return false;
1838 }
1839 if (!UnMount(true))
1840 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001841 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.fat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001842 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001843 command = "/system/bin/fsck.fat -y " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001844 LOGINFO("Repair command: %s\n", command.c_str());
1845 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001846 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001847 return true;
1848 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001849 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001850 return false;
1851 }
1852 }
1853 if (Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") {
bigbiffad58e1b2020-07-06 20:24:34 -04001854 if (!TWFunc::Path_Exists("/system/bin/e2fsck")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001855 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("e2fsck"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001856 return false;
1857 }
1858 if (!UnMount(true))
1859 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001860 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("e2fsck"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001861 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001862 command = "/system/bin/e2fsck -fp " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001863 LOGINFO("Repair command: %s\n", command.c_str());
1864 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001865 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001866 return true;
1867 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001868 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001869 return false;
1870 }
1871 }
1872 if (Current_File_System == "exfat") {
bigbiffad58e1b2020-07-06 20:24:34 -04001873 if (!TWFunc::Path_Exists("/system/bin/fsck.exfat")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001874 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.exfat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001875 return false;
1876 }
1877 if (!UnMount(true))
1878 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001879 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.exfat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001880 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001881 command = "/system/bin/fsck.exfat " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001882 LOGINFO("Repair command: %s\n", command.c_str());
1883 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001884 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001885 return true;
1886 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001887 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001888 return false;
1889 }
1890 }
1891 if (Current_File_System == "f2fs") {
bigbiffad58e1b2020-07-06 20:24:34 -04001892 if (!TWFunc::Path_Exists("/system/bin/fsck.f2fs")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001893 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.f2fs"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001894 return false;
1895 }
1896 if (!UnMount(true))
1897 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001898 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.f2fs"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001899 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001900 command = "/system/bin/fsck.f2fs " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001901 LOGINFO("Repair command: %s\n", command.c_str());
1902 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001903 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001904 return true;
1905 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001906 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001907 return false;
1908 }
1909 }
Captain Throwback47bf7202020-10-06 17:39:39 -04001910 if (Current_File_System == "ntfs" || Current_File_System == "tntfs") {
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001911 string Ntfsfix_Binary;
bigbiffad58e1b2020-07-06 20:24:34 -04001912 if (TWFunc::Path_Exists("/system/bin/ntfsfix"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001913 Ntfsfix_Binary = "ntfsfix";
bigbiffad58e1b2020-07-06 20:24:34 -04001914 else if (TWFunc::Path_Exists("/system/bin/fsck.ntfs"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001915 Ntfsfix_Binary = "fsck.ntfs";
1916 else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001917 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("ntfsfix"));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001918 return false;
1919 }
1920 if (!UnMount(true))
1921 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001922 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)(Ntfsfix_Binary));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001923 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001924 command = "/system/bin/" + Ntfsfix_Binary + " " + Actual_Block_Device;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001925 LOGINFO("Repair command: %s\n", command.c_str());
1926 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001927 gui_msg("done=Done.");
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001928 return true;
1929 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001930 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001931 return false;
1932 }
1933 }
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001934 return false;
1935}
1936
Ethan Yonkera2719152015-05-28 09:44:41 -05001937bool TWPartition::Can_Resize() {
1938 if (Mount_Read_Only)
1939 return false;
bigbiffad58e1b2020-07-06 20:24:34 -04001940 if ((Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") && TWFunc::Path_Exists("/system/bin/resize2fs"))
Ethan Yonkera2719152015-05-28 09:44:41 -05001941 return true;
1942 return false;
1943}
1944
1945bool TWPartition::Resize() {
1946 string command;
1947
1948 if (Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") {
1949 if (!Can_Repair()) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001950 LOGINFO("Cannot resize %s because %s cannot be repaired before resizing.\n", Display_Name.c_str(), Display_Name.c_str());
1951 gui_msg(Msg(msg::kError, "cannot_resize=Cannot resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001952 return false;
1953 }
bigbiffad58e1b2020-07-06 20:24:34 -04001954 if (!TWFunc::Path_Exists("/system/bin/resize2fs")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001955 LOGINFO("resize2fs does not exist! Cannot resize!\n");
1956 gui_msg(Msg(msg::kError, "cannot_resize=Cannot resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001957 return false;
1958 }
1959 // Repair will unmount so no need to do it twice
Ethan Yonker74db1572015-10-28 12:44:49 -05001960 gui_msg(Msg("repair_resize=Repairing {1} before resizing.")( Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001961 if (!Repair())
1962 return false;
Ethan Yonker74db1572015-10-28 12:44:49 -05001963 gui_msg(Msg("resizing=Resizing {1} using {2}...")(Display_Name)("resize2fs"));
Ethan Yonkera2719152015-05-28 09:44:41 -05001964 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001965 command = "/system/bin/resize2fs " + Actual_Block_Device;
Ethan Yonkera2719152015-05-28 09:44:41 -05001966 if (Length != 0) {
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001967 unsigned long long Actual_Size = IOCTL_Get_Block_Size();
1968 if (Actual_Size == 0)
1969 return false;
Ethan Yonkera2719152015-05-28 09:44:41 -05001970
Ethan Yonkera2719152015-05-28 09:44:41 -05001971 unsigned long long Block_Count;
1972 if (Length < 0) {
1973 // Reduce overall size by this length
1974 Block_Count = (Actual_Size / 1024LLU) - ((unsigned long long)(Length * -1) / 1024LLU);
1975 } else {
1976 // This is the size, not a size reduction
1977 Block_Count = ((unsigned long long)(Length) / 1024LLU);
1978 }
1979 char temp[256];
1980 sprintf(temp, "%llu", Block_Count);
1981 command += " ";
1982 command += temp;
1983 command += "K";
1984 }
1985 LOGINFO("Resize command: %s\n", command.c_str());
1986 if (TWFunc::Exec_Cmd(command) == 0) {
1987 Update_Size(true);
Ethan Yonker74db1572015-10-28 12:44:49 -05001988 gui_msg("done=Done.");
Ethan Yonkera2719152015-05-28 09:44:41 -05001989 return true;
1990 } else {
1991 Update_Size(true);
Ethan Yonker74db1572015-10-28 12:44:49 -05001992 gui_msg(Msg(msg::kError, "unable_resize=Unable to resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001993 return false;
1994 }
1995 }
1996 return false;
1997}
1998
bigbiffce8f83c2015-12-12 18:30:21 -05001999bool TWPartition::Backup(PartitionSettings *part_settings, pid_t *tar_fork_pid) {
2000 if (Backup_Method == BM_FILES)
2001 return Backup_Tar(part_settings, tar_fork_pid);
2002 else if (Backup_Method == BM_DD)
2003 return Backup_Image(part_settings);
2004 else if (Backup_Method == BM_FLASH_UTILS)
2005 return Backup_Dump_Image(part_settings);
Dees_Troy2673cec2013-04-02 20:22:16 +00002006 LOGERR("Unknown backup method for '%s'\n", Mount_Point.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04002007 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04002008}
2009
bigbiffce8f83c2015-12-12 18:30:21 -05002010bool TWPartition::Restore(PartitionSettings *part_settings) {
Matt Mower3c366972015-12-25 19:28:31 -06002011 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Display_Name, gui_parse_text("{@restoring_hdr}"));
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002012 LOGINFO("Restore filename is: %s/%s\n", part_settings->Backup_Folder.c_str(), Backup_FileName.c_str());
Gary Peck43acadf2012-11-21 21:19:01 -08002013
bigbiffce8f83c2015-12-12 18:30:21 -05002014 string Restore_File_System = Get_Restore_File_System(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002015
2016 if (Is_File_System(Restore_File_System))
bigbiffce8f83c2015-12-12 18:30:21 -05002017 return Restore_Tar(part_settings);
2018 else if (Is_Image(Restore_File_System))
2019 return Restore_Image(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002020
2021 LOGERR("Unknown restore method for '%s'\n", Mount_Point.c_str());
2022 return false;
2023}
2024
bigbiffce8f83c2015-12-12 18:30:21 -05002025string TWPartition::Get_Restore_File_System(PartitionSettings *part_settings) {
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002026 size_t first_period, second_period;
2027 string Restore_File_System;
2028
Gary Peck43acadf2012-11-21 21:19:01 -08002029 // Parse backup filename to extract the file system before wiping
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002030 first_period = Backup_FileName.find(".");
Gary Peck43acadf2012-11-21 21:19:01 -08002031 if (first_period == string::npos) {
Dees_Troy2673cec2013-04-02 20:22:16 +00002032 LOGERR("Unable to find file system (first period).\n");
thatd43bf2d2014-09-21 23:13:02 +02002033 return string();
Gary Peck43acadf2012-11-21 21:19:01 -08002034 }
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002035 Restore_File_System = Backup_FileName.substr(first_period + 1, Backup_FileName.size() - first_period - 1);
Gary Peck43acadf2012-11-21 21:19:01 -08002036 second_period = Restore_File_System.find(".");
2037 if (second_period == string::npos) {
Dees_Troy2673cec2013-04-02 20:22:16 +00002038 LOGERR("Unable to find file system (second period).\n");
thatd43bf2d2014-09-21 23:13:02 +02002039 return string();
Gary Peck43acadf2012-11-21 21:19:01 -08002040 }
2041 Restore_File_System.resize(second_period);
Matt Mowera0cd91d2016-12-30 18:21:42 -06002042 LOGINFO("Restore file system is: '%s'.\n", Restore_File_System.c_str());
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002043 return Restore_File_System;
Dees_Troy51a0e822012-09-05 15:24:24 -04002044}
2045
2046string TWPartition::Backup_Method_By_Name() {
bigbiffce8f83c2015-12-12 18:30:21 -05002047 if (Backup_Method == BM_NONE)
Dees_Troy38bd7602012-09-14 13:33:53 -04002048 return "none";
bigbiffce8f83c2015-12-12 18:30:21 -05002049 else if (Backup_Method == BM_FILES)
Dees_Troy38bd7602012-09-14 13:33:53 -04002050 return "files";
bigbiffce8f83c2015-12-12 18:30:21 -05002051 else if (Backup_Method == BM_DD)
Dees_Troy38bd7602012-09-14 13:33:53 -04002052 return "dd";
bigbiffce8f83c2015-12-12 18:30:21 -05002053 else if (Backup_Method == BM_FLASH_UTILS)
Dees_Troy38bd7602012-09-14 13:33:53 -04002054 return "flash_utils";
2055 else
2056 return "undefined";
2057 return "ERROR!";
Dees_Troy51a0e822012-09-05 15:24:24 -04002058}
2059
2060bool TWPartition::Decrypt(string Password) {
Dees_Troy2673cec2013-04-02 20:22:16 +00002061 LOGINFO("STUB TWPartition::Decrypt, password: '%s'\n", Password.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04002062 // Is this needed?
Dees_Troy51a0e822012-09-05 15:24:24 -04002063 return 1;
2064}
2065
2066bool TWPartition::Wipe_Encryption() {
Dees_Troy38bd7602012-09-14 13:33:53 -04002067 bool Save_Data_Media = Has_Data_Media;
Ethan Yonker93382822018-11-01 15:25:31 -05002068 bool ret = false;
2069 BasePartition* base_partition = make_partition();
2070
2071 if (!base_partition->PreWipeEncryption())
2072 goto exit;
Dees_Troy38bd7602012-09-14 13:33:53 -04002073
dianlujitao4879b372018-12-03 18:45:47 +08002074 Find_Actual_Block_Device();
2075 if (!Is_Present) {
2076 LOGINFO("Block device not present, cannot format %s.\n", Display_Name.c_str());
2077 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2078 return false;
2079 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002080
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06002081#ifdef TW_INCLUDE_CRYPTO
bigbiff7ba75002020-04-11 20:47:09 -04002082 if (!UnMount(true))
2083 return false;
Ethan Yonker1b190162016-12-05 15:25:19 -06002084 if (Is_Decrypted && !Decrypted_Block_Device.empty()) {
Matt Mower2b18a532015-02-20 16:58:05 -06002085 if (delete_crypto_blk_dev((char*)("userdata")) != 0) {
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06002086 LOGERR("Error deleting crypto block device, continuing anyway.\n");
2087 }
2088 }
2089#endif
dianlujitao4879b372018-12-03 18:45:47 +08002090 Has_Data_Media = false;
Ethan Yonker93382822018-11-01 15:25:31 -05002091 Decrypted_Block_Device = "";
Dees_Troy74fb2e92013-04-15 14:35:47 +00002092 Is_Decrypted = false;
2093 Is_Encrypted = false;
Gary Pecke8bc5d72012-12-21 06:45:25 -08002094 if (Wipe(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002095 Has_Data_Media = Save_Data_Media;
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06002096 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
Ethan Yonker83e82572014-04-04 10:59:28 -05002097#ifndef TW_OEM_BUILD
bigbiff25d25b92020-06-19 16:07:38 -04002098 gui_msg("format_data_msg=You may need to reboot recovery to be able to use /data again.");
Ethan Yonker83e82572014-04-04 10:59:28 -05002099#endif
bigbiff2d548672021-07-09 20:08:44 -04002100 if (Is_FBE) {
2101 gui_msg(Msg(msg::kWarning, "data_media_fbe_msg=TWRP will not recreate /data/media on an FBE device. Please reboot into your rom to create /data/media."));
Captain Throwback63573b52021-10-02 20:47:33 -04002102 } else {
2103 if (Has_Data_Media && !Symlink_Mount_Point.empty()) {
2104 if (Mount(false))
2105 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
2106 }
bigbiff2d548672021-07-09 20:08:44 -04002107 }
2108
Ethan Yonker93382822018-11-01 15:25:31 -05002109 ret = true;
2110 if (!Key_Directory.empty())
2111 ret = PartitionManager.Wipe_By_Path(Key_Directory);
2112 if (ret)
2113 ret = base_partition->PostWipeEncryption();
2114 goto exit;
Dees_Troy38bd7602012-09-14 13:33:53 -04002115 } else {
2116 Has_Data_Media = Save_Data_Media;
Ethan Yonker74db1572015-10-28 12:44:49 -05002117 gui_err("format_data_err=Unable to format to remove encryption.");
Ethan Yonker726a0202014-12-16 20:01:38 -06002118 if (Has_Data_Media && Mount(false))
2119 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
Ethan Yonker93382822018-11-01 15:25:31 -05002120 goto exit;
Dees_Troy38bd7602012-09-14 13:33:53 -04002121 }
Ethan Yonker93382822018-11-01 15:25:31 -05002122exit:
2123 delete base_partition;
2124 return ret;
Dees_Troy51a0e822012-09-05 15:24:24 -04002125}
2126
2127void TWPartition::Check_FS_Type() {
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002128 const char* type;
2129 blkid_probe pr;
Dees_Troy5bf43922012-09-07 16:07:55 -04002130
Dees_Troy68cab492012-12-12 19:29:35 +00002131 if (Fstab_File_System == "yaffs2" || Fstab_File_System == "mtd" || Fstab_File_System == "bml" || Ignore_Blkid)
2132 return; // Running blkid on some mtd devices causes a massive crash or needs to be skipped
Dees_Troy5bf43922012-09-07 16:07:55 -04002133
Dees_Troy38bd7602012-09-14 13:33:53 -04002134 Find_Actual_Block_Device();
Dees_Troy8170a922012-09-18 15:40:25 -04002135 if (!Is_Present)
2136 return;
Dees_Troy51127312012-09-08 13:08:49 -04002137
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002138 pr = blkid_new_probe_from_filename(Actual_Block_Device.c_str());
2139 if (blkid_do_fullprobe(pr)) {
2140 blkid_free_probe(pr);
Dees_Troy2673cec2013-04-02 20:22:16 +00002141 LOGINFO("Can't probe device %s\n", Actual_Block_Device.c_str());
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002142 return;
Dees_Troy5bf43922012-09-07 16:07:55 -04002143 }
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02002144
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05002145 if (blkid_probe_lookup_value(pr, "TYPE", &type, NULL) < 0) {
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002146 blkid_free_probe(pr);
Dees_Troy2673cec2013-04-02 20:22:16 +00002147 LOGINFO("can't find filesystem on device %s\n", Actual_Block_Device.c_str());
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002148 return;
2149 }
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02002150
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002151 Current_File_System = type;
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02002152 blkid_free_probe(pr);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002153 if (fs_flags.size() > 1) {
2154 std::vector<partition_fs_flags_struct>::iterator iter;
2155 std::vector<partition_fs_flags_struct>::iterator found = fs_flags.begin();
2156
2157 for (iter = fs_flags.begin(); iter != fs_flags.end(); iter++) {
2158 if (iter->File_System == Current_File_System) {
2159 found = iter;
2160 break;
2161 }
2162 }
2163 // If we don't find a match, we default the flags to the first set of flags that we received from the fstab
2164 if (Mount_Flags != found->Mount_Flags || Mount_Options != found->Mount_Options) {
2165 Mount_Flags = found->Mount_Flags;
2166 Mount_Options = found->Mount_Options;
2167 LOGINFO("Mount_Flags: %i, Mount_Options: %s\n", Mount_Flags, Mount_Options.c_str());
2168 }
2169 }
Dees_Troy51a0e822012-09-05 15:24:24 -04002170}
2171
dianlujitao4879b372018-12-03 18:45:47 +08002172bool TWPartition::Wipe_EXTFS(string File_System) {
bigbiff7ba75002020-04-11 20:47:09 -04002173 if (!UnMount(true))
2174 return false;
2175
dianlujitao4879b372018-12-03 18:45:47 +08002176#if PLATFORM_SDK_VERSION < 28
bigbiffad58e1b2020-07-06 20:24:34 -04002177 if (!TWFunc::Path_Exists("/system/bin/mke2fs"))
dianlujitao4879b372018-12-03 18:45:47 +08002178#else
bigbiffad58e1b2020-07-06 20:24:34 -04002179 if (!TWFunc::Path_Exists("/system/bin/mke2fs") || !TWFunc::Path_Exists("/system/bin/e2fsdroid"))
dianlujitao4879b372018-12-03 18:45:47 +08002180#endif
Dees_Troy38bd7602012-09-14 13:33:53 -04002181 return Wipe_RMRF();
2182
dianlujitao4879b372018-12-03 18:45:47 +08002183 int ret;
2184 bool NeedPreserveFooter = true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002185
Ethan Yonker25f20c12014-10-14 09:04:43 -05002186 Find_Actual_Block_Device();
2187 if (!Is_Present) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002188 LOGINFO("Block device not present, cannot wipe %s.\n", Display_Name.c_str());
2189 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Ethan Yonker25f20c12014-10-14 09:04:43 -05002190 return false;
2191 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002192
dianlujitao4879b372018-12-03 18:45:47 +08002193 /**
2194 * On decrypted devices, IOCTL_Get_Block_Size calculates size on device mapper,
2195 * so there's no need to preserve footer.
2196 */
2197 if ((Is_Decrypted && !Decrypted_Block_Device.empty()) ||
2198 Crypto_Key_Location != "footer") {
2199 NeedPreserveFooter = false;
2200 }
2201
2202 unsigned long long dev_sz = TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
2203 if (!dev_sz)
2204 return false;
2205
2206 if (NeedPreserveFooter)
2207 Length < 0 ? dev_sz += Length : dev_sz -= CRYPT_FOOTER_OFFSET;
2208
Dees Troy9a4d7402019-03-21 14:17:28 -04002209 char dout[16];
2210 sprintf(dout, "%llu", dev_sz / 4096);
2211
2212 //string size_str =to_string(dev_sz / 4096);
2213 string size_str = dout;
dianlujitao4879b372018-12-03 18:45:47 +08002214 string Command;
2215
2216 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mke2fs"));
2217
2218 // Execute mke2fs to create empty ext4 filesystem
2219 Command = "mke2fs -t " + File_System + " -b 4096 " + Actual_Block_Device + " " + size_str;
2220 LOGINFO("mke2fs command: %s\n", Command.c_str());
2221 ret = TWFunc::Exec_Cmd(Command);
2222 if (ret) {
2223 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2224 return false;
2225 }
2226
bigbiffad58e1b2020-07-06 20:24:34 -04002227 if (TWFunc::Path_Exists("/system/bin/e2fsdroid")) {
dianlujitao3cf05a52019-05-15 15:33:27 +08002228 const string& File_Contexts_Entry = (Mount_Point == "/system_root" ? "/" : Mount_Point);
2229 char *secontext = NULL;
2230 if (!selinux_handle || selabel_lookup(selinux_handle, &secontext, File_Contexts_Entry.c_str(), S_IFDIR) < 0) {
2231 LOGINFO("Cannot lookup security context for '%s'\n", Mount_Point.c_str());
2232 } else {
2233 // Execute e2fsdroid to initialize selinux context
bigbiff5b911ca2020-07-18 10:46:09 -04002234 if (Mount_Point == "/persist") {
2235 Mount(true);
2236 TWFunc::removeDir("/persist/lost+found", false);
2237 UnMount(true);
2238 }
dianlujitao3cf05a52019-05-15 15:33:27 +08002239 Command = "e2fsdroid -e -S /file_contexts -a " + File_Contexts_Entry + " " + Actual_Block_Device;
2240 LOGINFO("e2fsdroid command: %s\n", Command.c_str());
2241 ret = TWFunc::Exec_Cmd(Command);
2242 if (ret) {
2243 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2244 return false;
2245 }
dianlujitao4879b372018-12-03 18:45:47 +08002246 }
2247 } else {
2248 LOGINFO("e2fsdroid not present\n");
2249 }
2250
2251 if (NeedPreserveFooter)
2252 Wipe_Crypto_Key();
2253 Current_File_System = File_System;
2254 Recreate_AndSec_Folder();
2255 gui_msg("done=Done.");
2256 return true;
2257}
2258
2259bool TWPartition::Wipe_EXT4() {
2260#ifdef USE_EXT4
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002261 int ret;
dianlujitao4879b372018-12-03 18:45:47 +08002262 bool NeedPreserveFooter = true;
2263
bigbiff7ba75002020-04-11 20:47:09 -04002264 if (!UnMount(true))
2265 return false;
2266
dianlujitao4879b372018-12-03 18:45:47 +08002267 Find_Actual_Block_Device();
2268 if (!Is_Present) {
2269 LOGINFO("Block device not present, cannot wipe %s.\n", Display_Name.c_str());
2270 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2271 return false;
2272 }
dianlujitao4879b372018-12-03 18:45:47 +08002273
2274 /**
2275 * On decrypted devices, IOCTL_Get_Block_Size calculates size on device mapper,
2276 * so there's no need to preserve footer.
2277 */
2278 if ((Is_Decrypted && !Decrypted_Block_Device.empty()) ||
2279 Crypto_Key_Location != "footer") {
2280 NeedPreserveFooter = false;
2281 }
2282
2283 unsigned long long dev_sz = TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
2284 if (!dev_sz)
2285 return false;
2286
2287 if (NeedPreserveFooter)
2288 Length < 0 ? dev_sz += Length : dev_sz -= CRYPT_FOOTER_OFFSET;
2289
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002290 char *secontext = NULL;
2291
Greg Wallace4b44fef2015-12-29 15:33:24 -05002292 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("make_ext4fs"));
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002293
Dees Troy99c8dbf2014-03-10 16:53:58 +00002294 if (!selinux_handle || selabel_lookup(selinux_handle, &secontext, Mount_Point.c_str(), S_IFDIR) < 0) {
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002295 LOGINFO("Cannot lookup security context for '%s'\n", Mount_Point.c_str());
dianlujitao4879b372018-12-03 18:45:47 +08002296 ret = make_ext4fs(Actual_Block_Device.c_str(), dev_sz, Mount_Point.c_str(), NULL);
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002297 } else {
dianlujitao4879b372018-12-03 18:45:47 +08002298 ret = make_ext4fs(Actual_Block_Device.c_str(), dev_sz, Mount_Point.c_str(), selinux_handle);
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002299 }
2300 if (ret != 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002301 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troya95f55c2013-08-17 13:14:43 +00002302 return false;
2303 } else {
dianlujitao4879b372018-12-03 18:45:47 +08002304 if (NeedPreserveFooter)
2305 Wipe_Crypto_Key();
bigbiff bigbiffc49d7062013-10-11 20:28:00 -04002306 string sedir = Mount_Point + "/lost+found";
2307 PartitionManager.Mount_By_Path(sedir.c_str(), true);
2308 rmdir(sedir.c_str());
2309 mkdir(sedir.c_str(), S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP);
Dees_Troya95f55c2013-08-17 13:14:43 +00002310 return true;
2311 }
2312#else
dianlujitao4879b372018-12-03 18:45:47 +08002313 return Wipe_EXTFS("ext4");
Dees_Troya95f55c2013-08-17 13:14:43 +00002314#endif
Dees_Troy51a0e822012-09-05 15:24:24 -04002315}
2316
2317bool TWPartition::Wipe_FAT() {
Vojtech Bocek05534202013-09-11 08:11:56 +02002318 string command;
Dees_Troy38bd7602012-09-14 13:33:53 -04002319
bigbiff7ba75002020-04-11 20:47:09 -04002320 if (!UnMount(true))
2321 return false;
Dees_Troy38bd7602012-09-14 13:33:53 -04002322
bigbiffad58e1b2020-07-06 20:24:34 -04002323 if (TWFunc::Path_Exists("/system/bin/mkfs.fat")) {
Greg Wallace4b44fef2015-12-29 15:33:24 -05002324 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mkfs.fat"));
Dees_Troy38bd7602012-09-14 13:33:53 -04002325 Find_Actual_Block_Device();
Matt Mower18794c82015-11-11 16:22:45 -06002326 command = "mkfs.fat " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02002327 if (TWFunc::Exec_Cmd(command) == 0) {
Gary Pecke8bc5d72012-12-21 06:45:25 -08002328 Current_File_System = "vfat";
Dees_Troye58d5262012-09-21 12:27:57 -04002329 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002330 gui_msg("done=Done.");
Dees_Troy38bd7602012-09-14 13:33:53 -04002331 return true;
2332 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002333 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04002334 return false;
2335 }
2336 return true;
2337 }
2338 else
2339 return Wipe_RMRF();
2340
2341 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04002342}
2343
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002344bool TWPartition::Wipe_EXFAT() {
Vojtech Bocek05534202013-09-11 08:11:56 +02002345 string command;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002346
bigbiff7ba75002020-04-11 20:47:09 -04002347 if (!UnMount(true))
2348 return false;
bigbiffad58e1b2020-07-06 20:24:34 -04002349 if (TWFunc::Path_Exists("/system/bin/mkexfatfs")) {
Greg Wallace4b44fef2015-12-29 15:33:24 -05002350 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mkexfatfs"));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002351 Find_Actual_Block_Device();
2352 command = "mkexfatfs " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02002353 if (TWFunc::Exec_Cmd(command) == 0) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002354 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002355 gui_msg("done=Done.");
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002356 return true;
2357 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002358 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002359 return false;
2360 }
2361 return true;
2362 }
2363 return false;
2364}
2365
Dees_Troy38bd7602012-09-14 13:33:53 -04002366bool TWPartition::Wipe_MTD() {
2367 if (!UnMount(true))
2368 return false;
2369
Greg Wallace4b44fef2015-12-29 15:33:24 -05002370 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("MTD"));
Dees_Troy38bd7602012-09-14 13:33:53 -04002371
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002372 mtd_scan_partitions();
2373 const MtdPartition* mtd = mtd_find_partition_by_name(MTD_Name.c_str());
2374 if (mtd == NULL) {
2375 LOGERR("No mtd partition named '%s'", MTD_Name.c_str());
2376 return false;
2377 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002378
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002379 MtdWriteContext* ctx = mtd_write_partition(mtd);
2380 if (ctx == NULL) {
2381 LOGERR("Can't write '%s', failed to format.", MTD_Name.c_str());
2382 return false;
2383 }
2384 if (mtd_erase_blocks(ctx, -1) == -1) {
2385 mtd_write_close(ctx);
2386 LOGERR("Failed to format '%s'", MTD_Name.c_str());
2387 return false;
2388 }
2389 if (mtd_write_close(ctx) != 0) {
2390 LOGERR("Failed to close '%s'", MTD_Name.c_str());
2391 return false;
2392 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08002393 Current_File_System = "yaffs2";
Dees_Troye58d5262012-09-21 12:27:57 -04002394 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002395 gui_msg("done=Done.");
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002396 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002397}
2398
2399bool TWPartition::Wipe_RMRF() {
Dees_Troy38bd7602012-09-14 13:33:53 -04002400 if (!Mount(true))
2401 return false;
Ethan Yonker726a0202014-12-16 20:01:38 -06002402 // This is the only wipe that leaves the partition mounted, so we
2403 // must manually remove the partition from MTP if it is a storage
2404 // partition.
2405 if (Is_Storage)
2406 PartitionManager.Remove_MTP_Storage(MTP_Storage_ID);
Dees_Troy38bd7602012-09-14 13:33:53 -04002407
Ethan Yonker74db1572015-10-28 12:44:49 -05002408 gui_msg(Msg("remove_all=Removing all files under '{1}'")(Mount_Point));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002409 TWFunc::removeDir(Mount_Point, true);
Dees_Troye58d5262012-09-21 12:27:57 -04002410 Recreate_AndSec_Folder();
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002411 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002412}
2413
Dees_Troye5017042013-08-29 16:38:55 +00002414bool TWPartition::Wipe_F2FS() {
systemaddb475c92021-08-12 20:33:20 +02002415 std::string f2fs_command;
Dees_Troye5017042013-08-29 16:38:55 +00002416
bigbiff7ba75002020-04-11 20:47:09 -04002417 if (!UnMount(true))
2418 return false;
dianlujitao4879b372018-12-03 18:45:47 +08002419
bigbiffad58e1b2020-07-06 20:24:34 -04002420 if (TWFunc::Path_Exists("/system/bin/mkfs.f2fs"))
systemaddb475c92021-08-12 20:33:20 +02002421 f2fs_command = "/system/bin/mkfs.f2fs";
bigbiffad58e1b2020-07-06 20:24:34 -04002422 else if (TWFunc::Path_Exists("/system/bin/make_f2fs"))
systemaddb475c92021-08-12 20:33:20 +02002423 f2fs_command = "/system/bin/make_f2fs -g android";
bigbiff7ba75002020-04-11 20:47:09 -04002424 else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002425 LOGINFO("mkfs.f2fs binary not found, using rm -rf to wipe.\n");
Dees_Troye5017042013-08-29 16:38:55 +00002426 return Wipe_RMRF();
2427 }
bigbiff7ba75002020-04-11 20:47:09 -04002428
2429 bool NeedPreserveFooter = true;
systemaddb475c92021-08-12 20:33:20 +02002430 bool needs_casefold = false;
2431 bool needs_projid = false;
bigbiff7ba75002020-04-11 20:47:09 -04002432
2433 Find_Actual_Block_Device();
2434 if (!Is_Present) {
2435 LOGINFO("Block device not present, cannot wipe %s.\n", Display_Name.c_str());
2436 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2437 return false;
2438 }
systemaddb475c92021-08-12 20:33:20 +02002439
2440 needs_casefold = android::base::GetBoolProperty("external_storage.casefold.enabled", false);
2441 needs_projid = android::base::GetBoolProperty("external_storage.projid.enabled", false);
bigbiff7ba75002020-04-11 20:47:09 -04002442 unsigned long long dev_sz = TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
2443 if (!dev_sz)
2444 return false;
2445
2446 if (NeedPreserveFooter)
2447 Length < 0 ? dev_sz += Length : dev_sz -= CRYPT_FOOTER_OFFSET;
bigbiff7ba75002020-04-11 20:47:09 -04002448 char dev_sz_str[48];
2449 sprintf(dev_sz_str, "%llu", (dev_sz / 4096));
systemaddb475c92021-08-12 20:33:20 +02002450 if(needs_projid)
2451 f2fs_command += " -O project_quota,extra_attr";
2452
2453 if(needs_casefold)
2454 f2fs_command += " -O casefold -C utf8";
2455
2456 f2fs_command += " " + Actual_Block_Device + " " + dev_sz_str;
2457
bigbiffad58e1b2020-07-06 20:24:34 -04002458 if (TWFunc::Path_Exists("/system/bin/sload.f2fs")) {
systemaddb475c92021-08-12 20:33:20 +02002459 f2fs_command += " && sload.f2fs -t /data " + Actual_Block_Device;
bigbiff7ba75002020-04-11 20:47:09 -04002460 }
2461
2462 /**
2463 * On decrypted devices, IOCTL_Get_Block_Size calculates size on device mapper,
2464 * so there's no need to preserve footer.
2465 */
2466 if ((Is_Decrypted && !Decrypted_Block_Device.empty()) ||
2467 Crypto_Key_Location != "footer") {
2468 NeedPreserveFooter = false;
2469 }
systemaddb475c92021-08-12 20:33:20 +02002470 LOGINFO("mkfs.f2fs command: %s\n", f2fs_command.c_str());
2471 if (TWFunc::Exec_Cmd(f2fs_command) == 0) {
bigbiff7ba75002020-04-11 20:47:09 -04002472 if (NeedPreserveFooter)
2473 Wipe_Crypto_Key();
2474 Recreate_AndSec_Folder();
2475 gui_msg("done=Done.");
2476 return true;
2477 } else {
2478 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2479 return false;
2480 }
2481 return true;
Dees_Troye5017042013-08-29 16:38:55 +00002482}
2483
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002484bool TWPartition::Wipe_NTFS() {
2485 string command;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002486 string Ntfsmake_Binary;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002487
bigbiff7ba75002020-04-11 20:47:09 -04002488 if (!UnMount(true))
2489 return false;
2490
bigbiffad58e1b2020-07-06 20:24:34 -04002491 if (TWFunc::Path_Exists("/system/bin/mkntfs"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002492 Ntfsmake_Binary = "mkntfs";
bigbiffad58e1b2020-07-06 20:24:34 -04002493 else if (TWFunc::Path_Exists("/system/bin/mkfs.ntfs"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002494 Ntfsmake_Binary = "mkfs.ntfs";
2495 else
2496 return false;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002497
Greg Wallace4b44fef2015-12-29 15:33:24 -05002498 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)(Ntfsmake_Binary));
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002499 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04002500 command = "/system/bin/" + Ntfsmake_Binary + " " + Actual_Block_Device;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002501 if (TWFunc::Exec_Cmd(command) == 0) {
2502 Recreate_AndSec_Folder();
2503 gui_msg("done=Done.");
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002504 return true;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002505 } else {
2506 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2507 return false;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002508 }
2509 return false;
2510}
2511
Dees_Troy51a0e822012-09-05 15:24:24 -04002512bool TWPartition::Wipe_Data_Without_Wiping_Media() {
Ethan Yonker83e82572014-04-04 10:59:28 -05002513#ifdef TW_OEM_BUILD
2514 // In an OEM Build we want to do a full format
2515 return Wipe_Encryption();
2516#else
Ethan Yonker66a19492015-12-10 10:19:45 -06002517 bool ret = false;
Dees_Troy38bd7602012-09-14 13:33:53 -04002518
Dees_Troy38bd7602012-09-14 13:33:53 -04002519 if (!Mount(true))
2520 return false;
2521
Ethan Yonker74db1572015-10-28 12:44:49 -05002522 gui_msg("wiping_data=Wiping data without wiping /data/media ...");
Ethan Yonker66a19492015-12-10 10:19:45 -06002523 ret = Wipe_Data_Without_Wiping_Media_Func(Mount_Point + "/");
2524 if (ret)
2525 gui_msg("done=Done.");
2526 return ret;
2527#endif // ifdef TW_OEM_BUILD
2528}
2529
2530bool TWPartition::Wipe_Data_Without_Wiping_Media_Func(const string& parent __unused) {
2531 string dir;
Dees_Troy38bd7602012-09-14 13:33:53 -04002532
2533 DIR* d;
Ethan Yonker66a19492015-12-10 10:19:45 -06002534 d = opendir(parent.c_str());
Dees_Troy16b74352012-11-14 22:27:31 +00002535 if (d != NULL) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002536 struct dirent* de;
2537 while ((de = readdir(d)) != NULL) {
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05002538 if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) continue;
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05002539
Ethan Yonker66a19492015-12-10 10:19:45 -06002540 dir = parent;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002541 dir.append(de->d_name);
Ethan Yonker3fdcda42016-11-30 12:29:37 -06002542 if (wipe_exclusions.check_skip_dirs(dir)) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002543 LOGINFO("skipped '%s'\n", dir.c_str());
2544 continue;
2545 }
Dees_Troyce675462013-01-09 19:48:21 +00002546 if (de->d_type == DT_DIR) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002547 dir.append("/");
2548 if (!Wipe_Data_Without_Wiping_Media_Func(dir)) {
2549 closedir(d);
2550 return false;
2551 }
2552 rmdir(dir.c_str());
bigbiff bigbiff98f1f902013-01-19 18:46:13 -05002553 } else if (de->d_type == DT_REG || de->d_type == DT_LNK || de->d_type == DT_FIFO || de->d_type == DT_SOCK) {
nkk719efbe762017-06-13 19:49:05 +03002554 if (unlink(dir.c_str()) != 0)
Ethan Yonker79f88bd2016-12-09 14:52:12 -06002555 LOGINFO("Unable to unlink '%s': %s\n", dir.c_str(), strerror(errno));
Dees_Troyce675462013-01-09 19:48:21 +00002556 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002557 }
2558 closedir(d);
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05002559
Dees_Troy16b74352012-11-14 22:27:31 +00002560 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -04002561 }
Ethan Yonker74db1572015-10-28 12:44:49 -05002562 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy16b74352012-11-14 22:27:31 +00002563 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04002564}
2565
dianlujitao4879b372018-12-03 18:45:47 +08002566void TWPartition::Wipe_Crypto_Key() {
2567 Find_Actual_Block_Device();
2568 if (Crypto_Key_Location.empty())
2569 return;
2570 else if (Crypto_Key_Location == "footer") {
2571 int fd = open(Actual_Block_Device.c_str(), O_RDWR);
2572 if (fd < 0) {
2573 gui_print_color("warning", "Unable to open '%s' to wipe crypto key\n", Actual_Block_Device.c_str());
2574 return;
2575 }
2576
2577 unsigned int block_count;
2578 if ((ioctl(fd, BLKGETSIZE, &block_count)) == -1) {
2579 gui_print_color("warning", "Unable to get block size for wiping crypto footer.\n");
2580 } else {
2581 int newlen = Length < 0 ? -Length : CRYPT_FOOTER_OFFSET;
2582 off64_t offset = ((off64_t)block_count * 512) - newlen;
2583 if (lseek64(fd, offset, SEEK_SET) == -1) {
2584 gui_print_color("warning", "Unable to lseek64 for wiping crypto footer.\n");
2585 } else {
2586 void* buffer = malloc(newlen);
2587 if (!buffer) {
2588 gui_print_color("warning", "Failed to malloc for wiping crypto footer.\n");
2589 } else {
2590 memset(buffer, 0, newlen);
2591 int ret = write(fd, buffer, newlen);
2592 if (ret != newlen) {
2593 gui_print_color("warning", "Failed to wipe crypto footer.\n");
2594 } else {
2595 LOGINFO("Successfully wiped crypto footer.\n");
2596 }
2597 free(buffer);
2598 }
2599 }
2600 }
2601 close(fd);
2602 } else {
2603 if (TWFunc::IOCTL_Get_Block_Size(Crypto_Key_Location.c_str()) >= 16384LLU) {
2604 string Command = "dd of='" + Crypto_Key_Location + "' if=/dev/zero bs=16384 count=1";
2605 TWFunc::Exec_Cmd(Command);
2606 } else {
2607 LOGINFO("Crypto key location reports size < 16K so not wiping crypto footer.\n");
2608 }
2609 }
2610}
2611
bigbiffce8f83c2015-12-12 18:30:21 -05002612bool TWPartition::Backup_Tar(PartitionSettings *part_settings, pid_t *tar_fork_pid) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002613 string Full_FileName;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002614 twrpTar tar;
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -05002615
Dees_Troy43d8b002012-09-17 16:00:01 -04002616 if (!Mount(true))
2617 return false;
2618
Ian Macdonalda3b25a32019-06-16 22:39:14 +02002619 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Backup_Display_Name, gui_parse_text("{@backing}"));
Ethan Yonker74db1572015-10-28 12:44:49 -05002620 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002621
Ethan Yonker472f5062016-02-25 13:47:30 -06002622 DataManager::GetValue(TW_USE_COMPRESSION_VAR, tar.use_compression);
Matt Mowerbb81e5d2014-03-20 18:05:41 -05002623
Dees_Troy83bd4832013-05-04 12:39:56 +00002624#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
Ethan Yonker472f5062016-02-25 13:47:30 -06002625 if (Can_Encrypt_Backup) {
2626 DataManager::GetValue("tw_encrypt_backup", tar.use_encryption);
2627 if (tar.use_encryption) {
2628 if (Use_Userdata_Encryption)
2629 tar.userdata_encryption = tar.use_encryption;
2630 string Password;
2631 DataManager::GetValue("tw_backup_password", Password);
2632 tar.setpassword(Password);
2633 } else {
2634 tar.use_encryption = 0;
2635 }
Dees_Troy83bd4832013-05-04 12:39:56 +00002636 }
2637#endif
Dees_Troy43d8b002012-09-17 16:00:01 -04002638
Ethan Yonker472f5062016-02-25 13:47:30 -06002639 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002640 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Ethan Yonker01f4e032017-02-03 15:30:52 -06002641 if (Has_Data_Media)
2642 gui_msg(Msg(msg::kWarning, "backup_storage_warning=Backups of {1} do not include any files in internal storage such as pictures or downloads.")(Display_Name));
Noah Jacobson81d638d2019-04-28 00:10:07 -04002643 if (Mount_Point == "/data" && DataManager::GetIntValue(TW_IS_FBE)) {
2644 std::vector<users_struct>::iterator iter;
2645 std::vector<users_struct>* userList = PartitionManager.Get_Users_List();
2646 for (iter = userList->begin(); iter != userList->end(); iter++) {
2647 if (!(*iter).isDecrypted && (*iter).userId != "0") {
2648 gui_msg(Msg(msg::kWarning,
2649 "backup_storage_undecrypt_warning=Backup will not include some files from user {1} "
2650 "because the user is not decrypted.")((*iter).userId));
2651 backup_exclusions.add_absolute_dir("/data/system_ce/" + (*iter).userId);
2652 backup_exclusions.add_absolute_dir("/data/misc_ce/" + (*iter).userId);
2653 backup_exclusions.add_absolute_dir("/data/vendor_ce/" + (*iter).userId);
2654 backup_exclusions.add_absolute_dir("/data/media/" + (*iter).userId);
2655 backup_exclusions.add_absolute_dir("/data/user/" + (*iter).userId);
2656 }
2657 }
2658 }
bigbiffce8f83c2015-12-12 18:30:21 -05002659 tar.part_settings = part_settings;
Ethan Yonker3fdcda42016-11-30 12:29:37 -06002660 tar.backup_exclusions = &backup_exclusions;
Dees Troye0a433a2013-12-02 04:10:37 +00002661 tar.setdir(Backup_Path);
2662 tar.setfn(Full_FileName);
2663 tar.setsize(Backup_Size);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002664 tar.partition_name = Backup_Name;
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002665 tar.backup_folder = part_settings->Backup_Folder;
bigbiffce8f83c2015-12-12 18:30:21 -05002666 if (tar.createTarFork(tar_fork_pid) != 0)
Dees Troye0a433a2013-12-02 04:10:37 +00002667 return false;
Dees_Troy43d8b002012-09-17 16:00:01 -04002668 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002669}
2670
bigbiffce8f83c2015-12-12 18:30:21 -05002671bool TWPartition::Backup_Image(PartitionSettings *part_settings) {
2672 string Full_FileName, adb_file_name;
igoriok87e3d932013-01-31 21:03:53 +02002673
Ethan Yonker74db1572015-10-28 12:44:49 -05002674 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, gui_parse_text("{@backing}"));
2675 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002676
Ethan Yonker472f5062016-02-25 13:47:30 -06002677 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
Dees_Troy43d8b002012-09-17 16:00:01 -04002678
bigbiffce8f83c2015-12-12 18:30:21 -05002679 if (part_settings->adbbackup) {
2680 Full_FileName = TW_ADB_BACKUP;
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002681 adb_file_name = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002682 }
2683 else
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002684 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002685
2686 part_settings->total_restore_size = Backup_Size;
2687
2688 if (part_settings->adbbackup) {
2689 if (!twadbbu::Write_TWIMG(adb_file_name, Backup_Size))
2690 return false;
2691 }
2692
2693 if (!Raw_Read_Write(part_settings))
Ethan Yonker472f5062016-02-25 13:47:30 -06002694 return false;
2695
bigbiffce8f83c2015-12-12 18:30:21 -05002696 if (part_settings->adbbackup) {
2697 if (!twadbbu::Write_TWEOF())
2698 return false;
Dees_Troy7c2dec82012-09-26 09:49:14 -04002699 }
Dees_Troy43d8b002012-09-17 16:00:01 -04002700 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002701}
2702
bigbiffce8f83c2015-12-12 18:30:21 -05002703bool TWPartition::Raw_Read_Write(PartitionSettings *part_settings) {
2704 unsigned long long RW_Block_Size, Remain = Backup_Size;
2705 int src_fd = -1, dest_fd = -1;
2706 ssize_t bs;
Ethan Yonker472f5062016-02-25 13:47:30 -06002707 bool ret = false;
2708 void* buffer = NULL;
2709 unsigned long long backedup_size = 0;
bigbiffce8f83c2015-12-12 18:30:21 -05002710 string srcfn, destfn;
Ethan Yonker472f5062016-02-25 13:47:30 -06002711
bigbiffce8f83c2015-12-12 18:30:21 -05002712 if (part_settings->PM_Method == PM_BACKUP) {
2713 srcfn = Actual_Block_Device;
2714 if (part_settings->adbbackup)
2715 destfn = TW_ADB_BACKUP;
bigbiff bigbiff38b83c12017-12-28 19:58:52 -05002716 else {
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002717 destfn = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiff bigbiff38b83c12017-12-28 19:58:52 -05002718 }
bigbiffce8f83c2015-12-12 18:30:21 -05002719 }
2720 else {
2721 destfn = Actual_Block_Device;
2722 if (part_settings->adbbackup) {
2723 srcfn = TW_ADB_RESTORE;
2724 } else {
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002725 srcfn = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002726 Remain = TWFunc::Get_File_Size(srcfn);
2727 }
2728 }
Ethan Yonker472f5062016-02-25 13:47:30 -06002729
bigbiffce8f83c2015-12-12 18:30:21 -05002730 src_fd = open(srcfn.c_str(), O_RDONLY | O_LARGEFILE);
Ethan Yonker472f5062016-02-25 13:47:30 -06002731 if (src_fd < 0) {
bigbiffce8f83c2015-12-12 18:30:21 -05002732 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(srcfn.c_str())(strerror(errno)));
Ethan Yonker472f5062016-02-25 13:47:30 -06002733 return false;
2734 }
bigbiffce8f83c2015-12-12 18:30:21 -05002735
2736 dest_fd = open(destfn.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_LARGEFILE, S_IRUSR | S_IWUSR);
Ethan Yonker472f5062016-02-25 13:47:30 -06002737 if (dest_fd < 0) {
bigbiffce8f83c2015-12-12 18:30:21 -05002738 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(destfn.c_str())(strerror(errno)));
Ethan Yonker472f5062016-02-25 13:47:30 -06002739 goto exit;
2740 }
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04002741
bigbiffce8f83c2015-12-12 18:30:21 -05002742 LOGINFO("Reading '%s', writing '%s'\n", srcfn.c_str(), destfn.c_str());
2743
2744 if (part_settings->adbbackup) {
2745 RW_Block_Size = MAX_ADB_READ;
2746 bs = MAX_ADB_READ;
2747 }
2748 else {
2749 RW_Block_Size = 1048576LLU; // 1MB
2750 bs = (ssize_t)(RW_Block_Size);
2751 }
2752
Ethan Yonker472f5062016-02-25 13:47:30 -06002753 buffer = malloc((size_t)bs);
2754 if (!buffer) {
2755 LOGINFO("Raw_Read_Write failed to malloc\n");
2756 goto exit;
2757 }
bigbiffce8f83c2015-12-12 18:30:21 -05002758
2759 if (part_settings->progress)
2760 part_settings->progress->SetPartitionSize(part_settings->total_restore_size);
2761
Ethan Yonker472f5062016-02-25 13:47:30 -06002762 while (Remain > 0) {
2763 if (Remain < RW_Block_Size)
bigbiffce8f83c2015-12-12 18:30:21 -05002764 bs = (ssize_t)(Remain);
Matt Mowera8a89d12016-12-30 18:10:37 -06002765 if (read(src_fd, buffer, bs) != bs) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002766 LOGINFO("Error reading source fd (%s)\n", strerror(errno));
2767 goto exit;
2768 }
2769 if (write(dest_fd, buffer, bs) != bs) {
2770 LOGINFO("Error writing destination fd (%s)\n", strerror(errno));
2771 goto exit;
2772 }
2773 backedup_size += (unsigned long long)(bs);
Matt Mower029a82d2017-01-08 13:12:38 -06002774 Remain -= (unsigned long long)(bs);
bigbiffce8f83c2015-12-12 18:30:21 -05002775 if (part_settings->progress)
2776 part_settings->progress->UpdateSize(backedup_size);
Ethan Yonker472f5062016-02-25 13:47:30 -06002777 if (PartitionManager.Check_Backup_Cancel() != 0)
2778 goto exit;
2779 }
bigbiffce8f83c2015-12-12 18:30:21 -05002780 if (part_settings->progress)
2781 part_settings->progress->UpdateDisplayDetails(true);
Ethan Yonker472f5062016-02-25 13:47:30 -06002782 fsync(dest_fd);
nailyka083dc62016-11-11 21:41:28 +01002783
2784 if (!part_settings->adbbackup && part_settings->PM_Method == PM_BACKUP) {
2785 tw_set_default_metadata(destfn.c_str());
2786 LOGINFO("Restored default metadata for %s\n", destfn.c_str());
2787 }
2788
Ethan Yonker472f5062016-02-25 13:47:30 -06002789 ret = true;
2790exit:
2791 if (src_fd >= 0)
2792 close(src_fd);
2793 if (dest_fd >= 0)
2794 close(dest_fd);
2795 if (buffer)
2796 free(buffer);
2797 return ret;
2798}
2799
bigbiffce8f83c2015-12-12 18:30:21 -05002800bool TWPartition::Backup_Dump_Image(PartitionSettings *part_settings) {
Vojtech Bocek05534202013-09-11 08:11:56 +02002801 string Full_FileName, Command;
Dees_Troy43d8b002012-09-17 16:00:01 -04002802
Ethan Yonker74db1572015-10-28 12:44:49 -05002803 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, gui_parse_text("{@backing}"));
2804 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002805
bigbiffce8f83c2015-12-12 18:30:21 -05002806 if (part_settings->progress)
2807 part_settings->progress->SetPartitionSize(Backup_Size);
Dees_Troy43d8b002012-09-17 16:00:01 -04002808
Ethan Yonker472f5062016-02-25 13:47:30 -06002809 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002810 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Dees_Troy43d8b002012-09-17 16:00:01 -04002811
2812 Command = "dump_image " + MTD_Name + " '" + Full_FileName + "'";
bigbiffce8f83c2015-12-12 18:30:21 -05002813
Dees_Troy2673cec2013-04-02 20:22:16 +00002814 LOGINFO("Backup command: '%s'\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02002815 TWFunc::Exec_Cmd(Command);
Ethan Yonker4b94cfd2014-12-11 10:00:45 -06002816 tw_set_default_metadata(Full_FileName.c_str());
Dees_Troy7c2dec82012-09-26 09:49:14 -04002817 if (TWFunc::Get_File_Size(Full_FileName) == 0) {
2818 // Actual size may not match backup size due to bad blocks on MTD devices so just check for 0 bytes
Matt Mower3c366972015-12-25 19:28:31 -06002819 gui_msg(Msg(msg::kError, "backup_size=Backup file size for '{1}' is 0 bytes.")(Full_FileName));
Dees_Troy7c2dec82012-09-26 09:49:14 -04002820 return false;
2821 }
bigbiffce8f83c2015-12-12 18:30:21 -05002822 if (part_settings->progress)
2823 part_settings->progress->UpdateSize(Backup_Size);
2824
Dees_Troy43d8b002012-09-17 16:00:01 -04002825 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002826}
2827
bigbiffce8f83c2015-12-12 18:30:21 -05002828unsigned long long TWPartition::Get_Restore_Size(PartitionSettings *part_settings) {
2829 if (!part_settings->adbbackup) {
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002830 InfoManager restore_info(part_settings->Backup_Folder + "/" + Backup_Name + ".info");
bigbiffce8f83c2015-12-12 18:30:21 -05002831 if (restore_info.LoadValues() == 0) {
2832 if (restore_info.GetValue("backup_size", Restore_Size) == 0) {
2833 LOGINFO("Read info file, restore size is %llu\n", Restore_Size);
2834 return Restore_Size;
2835 }
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002836 }
2837 }
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002838
Matt Mower029a82d2017-01-08 13:12:38 -06002839 string Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
2840 string Restore_File_System = Get_Restore_File_System(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002841
2842 if (Is_Image(Restore_File_System)) {
2843 Restore_Size = TWFunc::Get_File_Size(Full_FileName);
2844 return Restore_Size;
2845 }
2846
2847 twrpTar tar;
2848 tar.setdir(Backup_Path);
2849 tar.setfn(Full_FileName);
bigbiffce8f83c2015-12-12 18:30:21 -05002850 tar.backup_name = Full_FileName;
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002851#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
2852 string Password;
2853 DataManager::GetValue("tw_restore_password", Password);
2854 if (!Password.empty())
2855 tar.setpassword(Password);
2856#endif
2857 tar.partition_name = Backup_Name;
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002858 tar.backup_folder = part_settings->Backup_Folder;
bigbiffce8f83c2015-12-12 18:30:21 -05002859 tar.part_settings = part_settings;
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002860 Restore_Size = tar.get_size();
2861 return Restore_Size;
2862}
2863
bigbiffce8f83c2015-12-12 18:30:21 -05002864bool TWPartition::Restore_Tar(PartitionSettings *part_settings) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002865 string Full_FileName;
Dees Troy4159aed2014-02-28 17:24:43 +00002866 bool ret = false;
bigbiffce8f83c2015-12-12 18:30:21 -05002867 string Restore_File_System = Get_Restore_File_System(part_settings);
Dees_Troy43d8b002012-09-17 16:00:01 -04002868
Dees_Troye58d5262012-09-21 12:27:57 -04002869 if (Has_Android_Secure) {
Dees_Troye58d5262012-09-21 12:27:57 -04002870 if (!Wipe_AndSec())
2871 return false;
Gary Peck43acadf2012-11-21 21:19:01 -08002872 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002873 gui_msg(Msg("wiping=Wiping {1}")(Backup_Display_Name));
Ethan Yonker5eac2222014-06-11 12:22:55 -05002874 if (Has_Data_Media && Mount_Point == "/data" && Restore_File_System != Current_File_System) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002875 gui_msg(Msg(msg::kWarning, "datamedia_fs_restore=WARNING: This /data backup was made with {1} file system! The backup may not boot unless you change back to {1}.")(Restore_File_System));
Ethan Yonker5eac2222014-06-11 12:22:55 -05002876 if (!Wipe_Data_Without_Wiping_Media())
2877 return false;
2878 } else {
2879 if (!Wipe(Restore_File_System))
2880 return false;
2881 }
Dees_Troye58d5262012-09-21 12:27:57 -04002882 }
Matt Mower3c366972015-12-25 19:28:31 -06002883 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Backup_Display_Name, gui_parse_text("{@restoring_hdr}"));
Ethan Yonker74db1572015-10-28 12:44:49 -05002884 gui_msg(Msg("restoring=Restoring {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002885
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05002886 // Remount as read/write as needed so we can restore the backup
2887 if (!ReMount_RW(true))
Dees_Troy43d8b002012-09-17 16:00:01 -04002888 return false;
2889
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002890 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Ethan Yonker87af5632014-02-10 11:56:35 -06002891 twrpTar tar;
bigbiffce8f83c2015-12-12 18:30:21 -05002892 tar.part_settings = part_settings;
Ethan Yonker87af5632014-02-10 11:56:35 -06002893 tar.setdir(Backup_Path);
2894 tar.setfn(Full_FileName);
2895 tar.backup_name = Backup_Name;
2896#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
2897 string Password;
2898 DataManager::GetValue("tw_restore_password", Password);
2899 if (!Password.empty())
2900 tar.setpassword(Password);
2901#endif
bigbiffce8f83c2015-12-12 18:30:21 -05002902 part_settings->progress->SetPartitionSize(Get_Restore_Size(part_settings));
2903 if (tar.extractTarFork() != 0)
Dees Troy4159aed2014-02-28 17:24:43 +00002904 ret = false;
2905 else
2906 ret = true;
2907#ifdef HAVE_CAPABILITIES
2908 // Restore capabilities to the run-as binary
Captain Throwback9d6feb52018-07-27 10:05:24 -04002909 if (Mount_Point == PartitionManager.Get_Android_Root_Path() && Mount(true) && TWFunc::Path_Exists("/system/bin/run-as")) {
Dees Troy4159aed2014-02-28 17:24:43 +00002910 struct vfs_cap_data cap_data;
2911 uint64_t capabilities = (1 << CAP_SETUID) | (1 << CAP_SETGID);
2912
2913 memset(&cap_data, 0, sizeof(cap_data));
2914 cap_data.magic_etc = VFS_CAP_REVISION | VFS_CAP_FLAGS_EFFECTIVE;
2915 cap_data.data[0].permitted = (uint32_t) (capabilities & 0xffffffff);
2916 cap_data.data[0].inheritable = 0;
2917 cap_data.data[1].permitted = (uint32_t) (capabilities >> 32);
2918 cap_data.data[1].inheritable = 0;
2919 if (setxattr("/system/bin/run-as", XATTR_NAME_CAPS, &cap_data, sizeof(cap_data), 0) < 0) {
2920 LOGINFO("Failed to reset capabilities of /system/bin/run-as binary.\n");
2921 } else {
2922 LOGINFO("Reset capabilities of /system/bin/run-as binary successful.\n");
2923 }
2924 }
2925#endif
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05002926 if (Mount_Read_Only || Mount_Flags & MS_RDONLY)
2927 // Remount as read only when restoration is complete
2928 ReMount(true);
2929
Dees Troy4159aed2014-02-28 17:24:43 +00002930 return ret;
Dees_Troy51a0e822012-09-05 15:24:24 -04002931}
2932
bigbiffce8f83c2015-12-12 18:30:21 -05002933bool TWPartition::Restore_Image(PartitionSettings *part_settings) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06002934 string Full_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002935 string Restore_File_System = Get_Restore_File_System(part_settings);
Dees_Troy43d8b002012-09-17 16:00:01 -04002936
Matt Mower3c366972015-12-25 19:28:31 -06002937 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Backup_Display_Name, gui_parse_text("{@restoring_hdr}"));
Ethan Yonker74db1572015-10-28 12:44:49 -05002938 gui_msg(Msg("restoring=Restoring {1}...")(Backup_Display_Name));
bigbiffce8f83c2015-12-12 18:30:21 -05002939
2940 if (part_settings->adbbackup)
2941 Full_FileName = TW_ADB_RESTORE;
2942 else
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002943 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Gary Peck15e623d2012-11-21 21:07:58 -08002944
Ethan Yonker96af84a2015-01-05 14:58:36 -06002945 if (Restore_File_System == "emmc") {
bigbiffce8f83c2015-12-12 18:30:21 -05002946 if (!part_settings->adbbackup)
2947 part_settings->total_restore_size = (uint64_t)(TWFunc::Get_File_Size(Full_FileName));
2948 if (!Raw_Read_Write(part_settings))
Ethan Yonker96af84a2015-01-05 14:58:36 -06002949 return false;
2950 } else if (Restore_File_System == "mtd" || Restore_File_System == "bml") {
bigbiffce8f83c2015-12-12 18:30:21 -05002951 if (!Flash_Image_FI(Full_FileName, part_settings->progress))
2952 return false;
2953 }
2954
2955 if (part_settings->adbbackup) {
2956 if (!twadbbu::Write_TWEOF())
Ethan Yonker96af84a2015-01-05 14:58:36 -06002957 return false;
Gary Peck15e623d2012-11-21 21:07:58 -08002958 }
Dees_Troy43d8b002012-09-17 16:00:01 -04002959 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002960}
Dees_Troy5bf43922012-09-07 16:07:55 -04002961
2962bool TWPartition::Update_Size(bool Display_Error) {
Dees_Troy0550cfb2012-10-13 11:56:13 -04002963 bool ret = false, Was_Already_Mounted = false;
Dees_Troy51127312012-09-08 13:08:49 -04002964
Ethan Yonker1b190162016-12-05 15:25:19 -06002965 Find_Actual_Block_Device();
2966
bigbiffee7b7ff2020-03-23 15:08:27 -04002967 if (Actual_Block_Device.empty())
2968 return false;
2969
Ethan Yonker1b190162016-12-05 15:25:19 -06002970 if (!Can_Be_Mounted && !Is_Encrypted) {
2971 if (TWFunc::Path_Exists(Actual_Block_Device) && Find_Partition_Size()) {
2972 Used = Size;
2973 Backup_Size = Size;
2974 return true;
2975 }
Dees_Troy5bf43922012-09-07 16:07:55 -04002976 return false;
Ethan Yonker1b190162016-12-05 15:25:19 -06002977 }
Dees_Troy5bf43922012-09-07 16:07:55 -04002978
Dees_Troy0550cfb2012-10-13 11:56:13 -04002979 Was_Already_Mounted = Is_Mounted();
bigbiffee7b7ff2020-03-23 15:08:27 -04002980
Dees_Troy38bd7602012-09-14 13:33:53 -04002981 if (Removable || Is_Encrypted) {
2982 if (!Mount(false))
2983 return true;
2984 } else if (!Mount(Display_Error))
Dees_Troy5bf43922012-09-07 16:07:55 -04002985 return false;
Dees_Troy51127312012-09-08 13:08:49 -04002986
2987 ret = Get_Size_Via_statfs(Display_Error);
Dees_Troy0550cfb2012-10-13 11:56:13 -04002988 if (!ret || Size == 0) {
2989 if (!Get_Size_Via_df(Display_Error)) {
2990 if (!Was_Already_Mounted)
2991 UnMount(false);
Dees_Troy51127312012-09-08 13:08:49 -04002992 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04002993 }
2994 }
Dees_Troy51127312012-09-08 13:08:49 -04002995
Dees_Troy5bf43922012-09-07 16:07:55 -04002996 if (Has_Data_Media) {
2997 if (Mount(Display_Error)) {
Ethan Yonker3fdcda42016-11-30 12:29:37 -06002998 Used = backup_exclusions.Get_Folder_Size(Mount_Point);
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05002999 Backup_Size = Used;
3000 int bak = (int)(Used / 1048576LLU);
Dees_Troy51127312012-09-08 13:08:49 -04003001 int fre = (int)(Free / 1048576LLU);
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05003002 LOGINFO("Data backup size is %iMB, free: %iMB.\n", bak, fre);
Dees_Troy0550cfb2012-10-13 11:56:13 -04003003 } else {
3004 if (!Was_Already_Mounted)
3005 UnMount(false);
Dees_Troy5bf43922012-09-07 16:07:55 -04003006 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04003007 }
Dees_Troye58d5262012-09-21 12:27:57 -04003008 } else if (Has_Android_Secure) {
3009 if (Mount(Display_Error))
Ethan Yonker3fdcda42016-11-30 12:29:37 -06003010 Backup_Size = backup_exclusions.Get_Folder_Size(Backup_Path);
Dees_Troy0550cfb2012-10-13 11:56:13 -04003011 else {
3012 if (!Was_Already_Mounted)
3013 UnMount(false);
Dees_Troye58d5262012-09-21 12:27:57 -04003014 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04003015 }
Dees_Troy5bf43922012-09-07 16:07:55 -04003016 }
Dees_Troy0550cfb2012-10-13 11:56:13 -04003017 if (!Was_Already_Mounted)
3018 UnMount(false);
Dees_Troy5bf43922012-09-07 16:07:55 -04003019 return true;
Dees_Troy51127312012-09-08 13:08:49 -04003020}
Dees_Troy38bd7602012-09-14 13:33:53 -04003021
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06003022bool TWPartition::Find_Wildcard_Block_Devices(const string& Device) {
3023 int mount_point_index = 0; // we will need to create separate mount points for each partition found and we use this index to name each one
3024 string Path = TWFunc::Get_Path(Device);
3025 string Dev = TWFunc::Get_Filename(Device);
3026 size_t wildcard_index = Dev.find("*");
3027 if (wildcard_index != string::npos)
3028 Dev = Dev.substr(0, wildcard_index);
3029 wildcard_index = Dev.size();
3030 DIR* d = opendir(Path.c_str());
3031 if (d == NULL) {
3032 LOGINFO("Error opening '%s': %s\n", Path.c_str(), strerror(errno));
3033 return false;
3034 }
3035 struct dirent* de;
3036 while ((de = readdir(d)) != NULL) {
3037 if (de->d_type != DT_BLK || strlen(de->d_name) <= wildcard_index || strncmp(de->d_name, Dev.c_str(), wildcard_index) != 0)
3038 continue;
3039
3040 string item = Path + "/";
3041 item.append(de->d_name);
3042 if (PartitionManager.Find_Partition_By_Block_Device(item))
3043 continue;
3044 TWPartition *part = new TWPartition;
3045 char buffer[MAX_FSTAB_LINE_LENGTH];
3046 sprintf(buffer, "%s %s-%i auto defaults defaults", item.c_str(), Mount_Point.c_str(), ++mount_point_index);
bigbiff8da46fa2020-09-08 16:42:34 -04003047 part->Process_Fstab_Line(buffer, false, NULL);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06003048 char display[MAX_FSTAB_LINE_LENGTH];
3049 sprintf(display, "%s %i", Storage_Name.c_str(), mount_point_index);
3050 part->Storage_Name = display;
3051 part->Display_Name = display;
3052 part->Primary_Block_Device = item;
3053 part->Wildcard_Block_Device = false;
3054 part->Is_SubPartition = true;
3055 part->SubPartition_Of = Mount_Point;
3056 part->Is_Storage = Is_Storage;
3057 part->Can_Be_Mounted = true;
3058 part->Removable = true;
3059 part->Can_Be_Wiped = Can_Be_Wiped;
3060 part->Wipe_Available_in_GUI = Wipe_Available_in_GUI;
3061 part->Find_Actual_Block_Device();
3062 part->Update_Size(false);
3063 Has_SubPartition = true;
3064 PartitionManager.Output_Partition(part);
3065 PartitionManager.Add_Partition(part);
3066 }
3067 closedir(d);
3068 return (mount_point_index > 0);
3069}
3070
Dees_Troy38bd7602012-09-14 13:33:53 -04003071void TWPartition::Find_Actual_Block_Device(void) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06003072 if (!Sysfs_Entry.empty() && Primary_Block_Device.empty() && Decrypted_Block_Device.empty()) {
3073 /* Sysfs_Entry.empty() indicates if this is a sysfs entry that begins with /device/
3074 * If we have a syfs entry then we are looking for this device from a uevent add.
3075 * The uevent add will set the primary block device based on the data we receive from
3076 * after checking for adopted storage. If the device ends up being adopted, then the
3077 * decrypted block device will be set instead of the primary block device. */
3078 Is_Present = false;
3079 return;
3080 }
3081 if (Wildcard_Block_Device && !Is_Adopted_Storage) {
3082 Is_Present = false;
3083 Actual_Block_Device = "";
3084 Can_Be_Mounted = false;
3085 if (!Find_Wildcard_Block_Devices(Primary_Block_Device)) {
3086 string Dev = Primary_Block_Device.substr(0, Primary_Block_Device.find("*"));
3087 if (TWFunc::Path_Exists(Dev)) {
3088 Is_Present = true;
3089 Can_Be_Mounted = true;
3090 Actual_Block_Device = Dev;
3091 }
3092 }
3093 return;
3094 } else if (Is_Decrypted && !Decrypted_Block_Device.empty()) {
Dees_Troy38bd7602012-09-14 13:33:53 -04003095 Actual_Block_Device = Decrypted_Block_Device;
Ethan Yonker1b190162016-12-05 15:25:19 -06003096 if (TWFunc::Path_Exists(Decrypted_Block_Device)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04003097 Is_Present = true;
Ethan Yonker1b190162016-12-05 15:25:19 -06003098 return;
3099 }
3100 } else if (SlotSelect && TWFunc::Path_Exists(Primary_Block_Device + PartitionManager.Get_Active_Slot_Suffix())) {
3101 Actual_Block_Device = Primary_Block_Device + PartitionManager.Get_Active_Slot_Suffix();
3102 unlink(Primary_Block_Device.c_str());
3103 symlink(Actual_Block_Device.c_str(), Primary_Block_Device.c_str()); // we create a non-slot symlink pointing to the currently selected slot which may assist zips with installing
3104 Is_Present = true;
3105 return;
Dees_Troy43d8b002012-09-17 16:00:01 -04003106 } else if (TWFunc::Path_Exists(Primary_Block_Device)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04003107 Is_Present = true;
3108 Actual_Block_Device = Primary_Block_Device;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003109 return;
3110 }
Ethan Yonker1b190162016-12-05 15:25:19 -06003111 if (!Alternate_Block_Device.empty() && TWFunc::Path_Exists(Alternate_Block_Device)) {
Dees_Troy3f04d032012-10-07 18:20:09 -04003112 Actual_Block_Device = Alternate_Block_Device;
Dees_Troy38bd7602012-09-14 13:33:53 -04003113 Is_Present = true;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003114 } else {
Dees_Troy38bd7602012-09-14 13:33:53 -04003115 Is_Present = false;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003116 }
Dees_Troy38bd7602012-09-14 13:33:53 -04003117}
3118
3119void TWPartition::Recreate_Media_Folder(void) {
3120 string Command;
Ethan Yonker66a19492015-12-10 10:19:45 -06003121 string Media_Path = Mount_Point + "/media";
Dees_Troy38bd7602012-09-14 13:33:53 -04003122
Ethan Yonkerbd7492d2016-12-07 13:55:01 -06003123 if (Is_FBE) {
3124 LOGINFO("Not recreating media folder on FBE\n");
3125 return;
3126 }
Dees_Troy38bd7602012-09-14 13:33:53 -04003127 if (!Mount(true)) {
Ethan Yonker66a19492015-12-10 10:19:45 -06003128 gui_msg(Msg(msg::kError, "recreate_folder_err=Unable to recreate {1} folder.")(Media_Path));
3129 } else if (!TWFunc::Path_Exists(Media_Path)) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003130 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Ethan Yonker66a19492015-12-10 10:19:45 -06003131 LOGINFO("Recreating %s folder.\n", Media_Path.c_str());
3132 mkdir(Media_Path.c_str(), 0770);
xiaolu9416f4f2015-06-04 08:22:23 +08003133 string Internal_path = DataManager::GetStrValue("tw_internal_path");
3134 if (!Internal_path.empty()) {
3135 LOGINFO("Recreating %s folder.\n", Internal_path.c_str());
3136 mkdir(Internal_path.c_str(), 0770);
3137 }
3138#ifdef TW_INTERNAL_STORAGE_PATH
3139 mkdir(EXPAND(TW_INTERNAL_STORAGE_PATH), 0770);
3140#endif
Matt Mower87413642017-01-17 21:14:46 -06003141
thata3d31fb2014-12-21 22:27:40 +01003142 // Afterwards, we will try to set the
3143 // default metadata that we were hopefully able to get during
3144 // early boot.
Ethan Yonker66a19492015-12-10 10:19:45 -06003145 tw_set_default_metadata(Media_Path.c_str());
xiaolu9416f4f2015-06-04 08:22:23 +08003146 if (!Internal_path.empty())
3147 tw_set_default_metadata(Internal_path.c_str());
Matt Mower87413642017-01-17 21:14:46 -06003148
Ethan Yonker5eac2222014-06-11 12:22:55 -05003149 // Toggle mount to ensure that "internal sdcard" gets mounted
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003150 PartitionManager.UnMount_By_Path(Symlink_Mount_Point, true);
Ethan Yonker5eac2222014-06-11 12:22:55 -05003151 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Dees_Troy38bd7602012-09-14 13:33:53 -04003152 }
Dees_Troy43d8b002012-09-17 16:00:01 -04003153}
Dees_Troye58d5262012-09-21 12:27:57 -04003154
3155void TWPartition::Recreate_AndSec_Folder(void) {
Dees_Troye58d5262012-09-21 12:27:57 -04003156 if (!Has_Android_Secure)
3157 return;
Dees_Troy2673cec2013-04-02 20:22:16 +00003158 LOGINFO("Creating %s: %s\n", Backup_Display_Name.c_str(), Symlink_Path.c_str());
Dees_Troye58d5262012-09-21 12:27:57 -04003159 if (!Mount(true)) {
Ethan Yonker74db1572015-10-28 12:44:49 -05003160 gui_msg(Msg(msg::kError, "recreate_folder_err=Unable to recreate {1} folder.")(Backup_Name));
Dees_Troye58d5262012-09-21 12:27:57 -04003161 } else if (!TWFunc::Path_Exists(Symlink_Path)) {
Dees_Troy2673cec2013-04-02 20:22:16 +00003162 LOGINFO("Recreating %s folder.\n", Backup_Name.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003163 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05003164 mkdir(Symlink_Path.c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003165 PartitionManager.UnMount_By_Path(Symlink_Mount_Point, true);
Dees_Troye58d5262012-09-21 12:27:57 -04003166 }
3167}
bigbiff7cb4c332014-11-26 20:36:07 -05003168
3169uint64_t TWPartition::Get_Max_FileSize() {
3170 uint64_t maxFileSize = 0;
3171 const uint64_t constGB = (uint64_t) 1024 * 1024 * 1024;
3172 const uint64_t constTB = (uint64_t) constGB * 1024;
3173 const uint64_t constPB = (uint64_t) constTB * 1024;
bigbiff0c532032014-12-21 13:41:26 -05003174 if (Current_File_System == "ext4")
3175 maxFileSize = 16 * constTB; //16 TB
3176 else if (Current_File_System == "vfat")
3177 maxFileSize = 4 * constGB; //4 GB
Captain Throwback47bf7202020-10-06 17:39:39 -04003178 else if (Current_File_System == "ntfs" || Current_File_System == "tntfs")
bigbiff0c532032014-12-21 13:41:26 -05003179 maxFileSize = 256 * constTB; //256 TB
3180 else if (Current_File_System == "exfat")
3181 maxFileSize = 16 * constPB; //16 PB
3182 else if (Current_File_System == "ext3")
3183 maxFileSize = 2 * constTB; //2 TB
3184 else if (Current_File_System == "f2fs")
3185 maxFileSize = 3.94 * constTB; //3.94 TB
bigbiff7cb4c332014-11-26 20:36:07 -05003186 else
3187 maxFileSize = 100000000L;
3188 return maxFileSize - 1;
3189}
3190
bigbiffce8f83c2015-12-12 18:30:21 -05003191bool TWPartition::Flash_Image(PartitionSettings *part_settings) {
3192 string Restore_File_System, full_filename;
Ethan Yonker96af84a2015-01-05 14:58:36 -06003193
Ethan Yonkere080c1f2016-09-19 13:50:25 -05003194 full_filename = part_settings->Backup_Folder + "/" + Backup_FileName;
Ethan Yonker96af84a2015-01-05 14:58:36 -06003195
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05003196 LOGINFO("Image filename is: %s\n", Backup_FileName.c_str());
bigbiffce8f83c2015-12-12 18:30:21 -05003197
3198 if (Backup_Method == BM_FILES) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06003199 LOGERR("Cannot flash images to file systems\n");
3200 return false;
3201 } else if (!Can_Flash_Img) {
3202 LOGERR("Cannot flash images to partitions %s\n", Display_Name.c_str());
3203 return false;
3204 } else {
3205 if (!Find_Partition_Size()) {
3206 LOGERR("Unable to find partition size for '%s'\n", Mount_Point.c_str());
3207 return false;
3208 }
bigbiffce8f83c2015-12-12 18:30:21 -05003209 unsigned long long image_size = TWFunc::Get_File_Size(full_filename);
Ethan Yonker96af84a2015-01-05 14:58:36 -06003210 if (image_size > Size) {
Ethan Yonker74db1572015-10-28 12:44:49 -05003211 LOGINFO("Size (%llu bytes) of image '%s' is larger than target device '%s' (%llu bytes)\n",
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05003212 image_size, Backup_FileName.c_str(), Actual_Block_Device.c_str(), Size);
Ethan Yonker74db1572015-10-28 12:44:49 -05003213 gui_err("img_size_err=Size of image is larger than target device");
Ethan Yonker96af84a2015-01-05 14:58:36 -06003214 return false;
3215 }
bigbiffce8f83c2015-12-12 18:30:21 -05003216 if (Backup_Method == BM_DD) {
3217 if (!part_settings->adbbackup) {
3218 if (Is_Sparse_Image(full_filename)) {
3219 return Flash_Sparse_Image(full_filename);
3220 }
Ethan Yonker472f5062016-02-25 13:47:30 -06003221 }
bigbiffce8f83c2015-12-12 18:30:21 -05003222 return Raw_Read_Write(part_settings);
3223 } else if (Backup_Method == BM_FLASH_UTILS) {
3224 return Flash_Image_FI(full_filename, NULL);
Ethan Yonker472f5062016-02-25 13:47:30 -06003225 }
Ethan Yonker96af84a2015-01-05 14:58:36 -06003226 }
3227
3228 LOGERR("Unknown flash method for '%s'\n", Mount_Point.c_str());
3229 return false;
3230}
3231
Ethan Yonker472f5062016-02-25 13:47:30 -06003232bool TWPartition::Is_Sparse_Image(const string& Filename) {
HashBanged974bb2016-01-30 14:20:09 -05003233 uint32_t magic = 0;
3234 int fd = open(Filename.c_str(), O_RDONLY);
3235 if (fd < 0) {
3236 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Filename)(strerror(errno)));
3237 return false;
3238 }
bigbiffce8f83c2015-12-12 18:30:21 -05003239
HashBanged974bb2016-01-30 14:20:09 -05003240 if (read(fd, &magic, sizeof(magic)) != sizeof(magic)) {
3241 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Filename)(strerror(errno)));
3242 close(fd);
3243 return false;
3244 }
3245 close(fd);
Ethan Yonker472f5062016-02-25 13:47:30 -06003246 if (magic == SPARSE_HEADER_MAGIC)
3247 return true;
3248 return false;
3249}
3250
3251bool TWPartition::Flash_Sparse_Image(const string& Filename) {
3252 string Command;
3253
3254 gui_msg(Msg("flashing=Flashing {1}...")(Display_Name));
3255
3256 Command = "simg2img '" + Filename + "' '" + Actual_Block_Device + "'";
Ethan Yonker96af84a2015-01-05 14:58:36 -06003257 LOGINFO("Flash command: '%s'\n", Command.c_str());
3258 TWFunc::Exec_Cmd(Command);
3259 return true;
3260}
3261
Ethan Yonker472f5062016-02-25 13:47:30 -06003262bool TWPartition::Flash_Image_FI(const string& Filename, ProgressTracking *progress) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06003263 string Command;
Ethan Yonker472f5062016-02-25 13:47:30 -06003264 unsigned long long file_size;
Ethan Yonker96af84a2015-01-05 14:58:36 -06003265
Ethan Yonker74db1572015-10-28 12:44:49 -05003266 gui_msg(Msg("flashing=Flashing {1}...")(Display_Name));
Ethan Yonker472f5062016-02-25 13:47:30 -06003267 if (progress) {
3268 file_size = (unsigned long long)(TWFunc::Get_File_Size(Filename));
3269 progress->SetPartitionSize(file_size);
3270 }
Ethan Yonker96af84a2015-01-05 14:58:36 -06003271 // Sometimes flash image doesn't like to flash due to the first 2KB matching, so we erase first to ensure that it flashes
3272 Command = "erase_image " + MTD_Name;
3273 LOGINFO("Erase command: '%s'\n", Command.c_str());
3274 TWFunc::Exec_Cmd(Command);
3275 Command = "flash_image " + MTD_Name + " '" + Filename + "'";
3276 LOGINFO("Flash command: '%s'\n", Command.c_str());
3277 TWFunc::Exec_Cmd(Command);
Ethan Yonker472f5062016-02-25 13:47:30 -06003278 if (progress)
3279 progress->UpdateSize(file_size);
Ethan Yonker96af84a2015-01-05 14:58:36 -06003280 return true;
3281}
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05003282
3283void TWPartition::Change_Mount_Read_Only(bool new_value) {
3284 Mount_Read_Only = new_value;
3285}
3286
bigbiffce8f83c2015-12-12 18:30:21 -05003287bool TWPartition::Is_Read_Only() {
3288 return Mount_Read_Only;
3289}
3290
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05003291int TWPartition::Check_Lifetime_Writes() {
3292 bool original_read_only = Mount_Read_Only;
3293 int ret = 1;
3294
3295 Mount_Read_Only = true;
3296 if (Mount(false)) {
3297 Find_Actual_Block_Device();
Ethan Yonker54970bb2019-01-17 16:19:24 -06003298 string temp = Actual_Block_Device;
3299 Find_Real_Block_Device(temp, false);
3300 string block = basename(temp.c_str());
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05003301 string file = "/sys/fs/" + Current_File_System + "/" + block + "/lifetime_write_kbytes";
3302 string result;
3303 if (TWFunc::Path_Exists(file)) {
3304 if (TWFunc::read_file(file, result) != 0) {
3305 LOGINFO("Check_Lifetime_Writes of '%s' failed to read_file\n", file.c_str());
3306 } else {
3307 LOGINFO("Check_Lifetime_Writes result: '%s'\n", result.c_str());
3308 if (result == "0") {
3309 ret = 0;
3310 }
3311 }
3312 } else {
3313 LOGINFO("Check_Lifetime_Writes file does not exist '%s'\n", file.c_str());
3314 }
3315 UnMount(true);
3316 } else {
3317 LOGINFO("Check_Lifetime_Writes failed to mount '%s'\n", Mount_Point.c_str());
3318 }
3319 Mount_Read_Only = original_read_only;
3320 return ret;
3321}
Ethan Yonker66a19492015-12-10 10:19:45 -06003322
3323int TWPartition::Decrypt_Adopted() {
3324#ifdef TW_INCLUDE_CRYPTO
3325 int ret = 1;
3326 Is_Adopted_Storage = false;
3327 string Adopted_Key_File = "";
3328
3329 if (!Removable)
3330 return ret;
3331
3332 int fd = open(Alternate_Block_Device.c_str(), O_RDONLY);
3333 if (fd < 0) {
3334 LOGINFO("failed to open '%s'\n", Alternate_Block_Device.c_str());
3335 return ret;
3336 }
3337 char type_guid[80];
3338 char part_guid[80];
3339
nkk713c1e35f2017-03-24 18:28:03 +02003340 uint32_t p_num;
3341 size_t last_digit = Primary_Block_Device.find_last_not_of("0123456789");
3342 if ((last_digit != string::npos) && (last_digit != Primary_Block_Device.length()-1))
3343 p_num = atoi(Primary_Block_Device.substr(last_digit + 1).c_str()) + 1;
3344 else
3345 p_num = 2;
3346
3347 if (gpt_disk_get_partition_info(fd, p_num, type_guid, part_guid) == 0) {
Ethan Yonker66a19492015-12-10 10:19:45 -06003348 LOGINFO("type: '%s'\n", type_guid);
3349 LOGINFO("part: '%s'\n", part_guid);
3350 Adopted_GUID = part_guid;
3351 LOGINFO("Adopted_GUID '%s'\n", Adopted_GUID.c_str());
3352 if (strcmp(type_guid, TWGptAndroidExpand) == 0) {
3353 LOGINFO("android_expand found\n");
3354 Adopted_Key_File = "/data/misc/vold/expand_";
3355 Adopted_Key_File += part_guid;
3356 Adopted_Key_File += ".key";
3357 if (TWFunc::Path_Exists(Adopted_Key_File)) {
3358 Is_Adopted_Storage = true;
3359 /* Until we find a use case for this, I think it is safe
3360 * to disable USB Mass Storage whenever adopted storage
3361 * is present.
3362 */
nkk713c1e35f2017-03-24 18:28:03 +02003363 if (p_num == 2) {
3364 // TODO: Properly detect mixed vs fully adopted storage. Maybe this
3365 // should be moved to partitionmanager instead, and disable after
3366 // checking all partitions. Also the presence of adopted storage does
3367 // not necessarily mean it's being used as Internal Storage
3368 LOGINFO("Detected adopted storage, disabling USB mass storage mode\n");
3369 DataManager::SetValue("tw_has_usb_storage", 0);
3370 }
Ethan Yonker66a19492015-12-10 10:19:45 -06003371 }
3372 }
3373 }
3374
3375 if (Is_Adopted_Storage) {
nkk713c1e35f2017-03-24 18:28:03 +02003376 string Adopted_Block_Device = Alternate_Block_Device + "p" + TWFunc::to_string(p_num);
Ethan Yonker66a19492015-12-10 10:19:45 -06003377 if (!TWFunc::Path_Exists(Adopted_Block_Device)) {
nkk713c1e35f2017-03-24 18:28:03 +02003378 Adopted_Block_Device = Alternate_Block_Device + TWFunc::to_string(p_num);
Ethan Yonker66a19492015-12-10 10:19:45 -06003379 if (!TWFunc::Path_Exists(Adopted_Block_Device)) {
3380 LOGINFO("Adopted block device does not exist\n");
3381 goto exit;
3382 }
3383 }
3384 LOGINFO("key file is '%s', block device '%s'\n", Adopted_Key_File.c_str(), Adopted_Block_Device.c_str());
3385 char crypto_blkdev[MAXPATHLEN];
3386 std::string thekey;
3387 int fdkey = open(Adopted_Key_File.c_str(), O_RDONLY);
3388 if (fdkey < 0) {
3389 LOGINFO("failed to open key file\n");
3390 goto exit;
3391 }
3392 char buf[512];
3393 ssize_t n;
3394 while ((n = read(fdkey, &buf[0], sizeof(buf))) > 0) {
3395 thekey.append(buf, n);
3396 }
3397 close(fdkey);
3398 unsigned char* key = (unsigned char*) thekey.data();
3399 cryptfs_revert_ext_volume(part_guid);
3400
3401 ret = cryptfs_setup_ext_volume(part_guid, Adopted_Block_Device.c_str(), key, thekey.size(), crypto_blkdev);
3402 if (ret == 0) {
3403 LOGINFO("adopted storage new block device: '%s'\n", crypto_blkdev);
3404 Decrypted_Block_Device = crypto_blkdev;
3405 Is_Decrypted = true;
3406 Is_Encrypted = true;
3407 Find_Actual_Block_Device();
Kjell Braden3126a112016-06-19 16:58:15 +00003408 if (!Mount_Storage_Retry(false)) {
Ethan Yonker66a19492015-12-10 10:19:45 -06003409 LOGERR("Failed to mount decrypted adopted storage device\n");
3410 Is_Decrypted = false;
3411 Is_Encrypted = false;
3412 cryptfs_revert_ext_volume(part_guid);
3413 ret = 1;
3414 } else {
Ethan Yonkerfcf3f242016-02-16 12:30:26 -06003415 UnMount(false);
3416 Has_Android_Secure = false;
3417 Symlink_Path = "";
3418 Symlink_Mount_Point = "";
3419 Backup_Name = Mount_Point.substr(1);
3420 Backup_Path = Mount_Point;
3421 TWPartition* sdext = PartitionManager.Find_Partition_By_Path("/sd-ext");
3422 if (sdext && sdext->Actual_Block_Device == Adopted_Block_Device) {
3423 LOGINFO("Removing /sd-ext from partition list due to adopted storage\n");
3424 PartitionManager.Remove_Partition_By_Path("/sd-ext");
3425 }
Ethan Yonker66a19492015-12-10 10:19:45 -06003426 Setup_Data_Media();
Ethan Yonker66a19492015-12-10 10:19:45 -06003427 Wipe_Available_in_GUI = true;
3428 Wipe_During_Factory_Reset = true;
3429 Can_Be_Backed_Up = true;
3430 Can_Encrypt_Backup = true;
3431 Use_Userdata_Encryption = true;
3432 Is_Storage = true;
3433 Storage_Name = "Adopted Storage";
3434 Is_SubPartition = true;
3435 SubPartition_Of = "/data";
3436 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
3437 DataManager::SetValue("tw_has_adopted_storage", 1);
3438 }
3439 } else {
3440 LOGERR("Failed to setup adopted storage decryption\n");
3441 }
3442 }
3443exit:
Matt Mower06543e32017-01-06 15:25:26 -06003444 close(fd);
Ethan Yonker66a19492015-12-10 10:19:45 -06003445 return ret;
3446#else
3447 LOGINFO("Decrypt_Adopted: no crypto support\n");
3448 return 1;
3449#endif
3450}
3451
3452void TWPartition::Revert_Adopted() {
3453#ifdef TW_INCLUDE_CRYPTO
3454 if (!Adopted_GUID.empty()) {
3455 PartitionManager.Remove_MTP_Storage(Mount_Point);
3456 UnMount(false);
3457 cryptfs_revert_ext_volume(Adopted_GUID.c_str());
3458 Is_Adopted_Storage = false;
3459 Is_Encrypted = false;
3460 Is_Decrypted = false;
3461 Decrypted_Block_Device = "";
3462 Find_Actual_Block_Device();
3463 Wipe_During_Factory_Reset = false;
3464 Can_Be_Backed_Up = false;
3465 Can_Encrypt_Backup = false;
3466 Use_Userdata_Encryption = false;
3467 Is_SubPartition = false;
3468 SubPartition_Of = "";
3469 Has_Data_Media = false;
3470 Storage_Path = Mount_Point;
3471 if (!Symlink_Mount_Point.empty()) {
3472 TWPartition* Dat = PartitionManager.Find_Partition_By_Path("/data");
3473 if (Dat) {
3474 Dat->UnMount(false);
3475 Dat->Symlink_Mount_Point = Symlink_Mount_Point;
3476 }
3477 Symlink_Mount_Point = "";
3478 }
3479 }
3480#else
3481 LOGINFO("Revert_Adopted: no crypto support\n");
3482#endif
3483}
bigbiff bigbiffb5ecaad2017-03-20 18:53:53 -04003484
3485void TWPartition::Set_Backup_FileName(string fname) {
3486 Backup_FileName = fname;
3487}
3488
3489string TWPartition::Get_Backup_Name() {
3490 return Backup_Name;
3491}
bigbiffee7b7ff2020-03-23 15:08:27 -04003492
3493string TWPartition::Get_Mount_Point() {
3494 return Mount_Point;
3495}
3496
3497void TWPartition::Set_Block_Device(std::string block_device) {
3498 Primary_Block_Device = Actual_Block_Device = block_device;
3499}
3500
3501bool TWPartition::Get_Super_Status() {
3502 return Is_Super;
3503}
3504
3505void TWPartition::Set_Can_Be_Backed_Up(bool val) {
3506 Can_Be_Backed_Up = val;
3507}
3508
3509void TWPartition::Set_Can_Be_Wiped(bool val) {
3510 Can_Be_Wiped = val;
3511 Wipe_Available_in_GUI = val;
bigbiffad58e1b2020-07-06 20:24:34 -04003512}
3513
3514std::string TWPartition::Get_Backup_FileName() {
3515 return Backup_FileName;
3516}
3517
3518std::string TWPartition::Get_Display_Name() {
3519 return Display_Name;
3520}
3521
3522bool TWPartition::Is_SlotSelect() {
3523 return SlotSelect;
Mohd Faraz815e2402020-09-19 19:31:52 +05303524}