blob: 2c5f3520ada7e634cb6ac8ef331acb451cf7a5a3 [file] [log] [blame]
Dees Troy3be70a82013-10-22 14:25:12 +00001/*
bigbiff7ba75002020-04-11 20:47:09 -04002 Copyright 2013 to 2020 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>
Dees_Troy51a0e822012-09-05 15:24:24 -040035
Ethan Yonker007de982018-08-31 14:23:16 -050036#include "cutils/properties.h"
bigbiff7b4c7a62015-01-01 19:44:14 -050037#include "libblkid/include/blkid.h"
Dees_Troy51a0e822012-09-05 15:24:24 -040038#include "variables.h"
Dees_Troy2673cec2013-04-02 20:22:16 +000039#include "twcommon.h"
Dees_Troy51a0e822012-09-05 15:24:24 -040040#include "partitions.hpp"
Dees_Troy5bf43922012-09-07 16:07:55 -040041#include "data.hpp"
Dees_Troy43d8b002012-09-17 16:00:01 -040042#include "twrp-functions.hpp"
bigbiff bigbiff9c754052013-01-09 09:09:08 -050043#include "twrpTar.hpp"
Ethan Yonker3fdcda42016-11-30 12:29:37 -060044#include "exclude.hpp"
Ethan Yonker1b7a31b2014-07-03 15:09:22 -050045#include "infomanager.hpp"
Ethan Yonker4b94cfd2014-12-11 10:00:45 -060046#include "set_metadata.h"
Ethan Yonker74db1572015-10-28 12:44:49 -050047#include "gui/gui.hpp"
bigbiffce8f83c2015-12-12 18:30:21 -050048#include "adbbu/libtwadbbu.hpp"
Ethan Yonker98661c12018-10-17 08:39:28 -050049#ifdef TW_INCLUDE_CRYPTO
50 #include "crypto/fde/cryptfs.h"
51 #ifdef TW_INCLUDE_FBE
52 #include "crypto/ext4crypt/Decrypt.h"
53 #endif
54#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,
Matt Mower2416a502016-04-12 19:54:46 -0500136 TWFLAG_FLASHIMG,
137 TWFLAG_FORCEENCRYPT,
138 TWFLAG_FSFLAGS,
139 TWFLAG_IGNOREBLKID,
140 TWFLAG_LENGTH,
141 TWFLAG_MOUNTTODECRYPT,
142 TWFLAG_REMOVABLE,
Matt Mower2416a502016-04-12 19:54:46 -0500143 TWFLAG_SETTINGSSTORAGE,
144 TWFLAG_STORAGE,
145 TWFLAG_STORAGENAME,
146 TWFLAG_SUBPARTITIONOF,
147 TWFLAG_SYMLINK,
148 TWFLAG_USERDATAENCRYPTBACKUP,
149 TWFLAG_USERMRF,
150 TWFLAG_WIPEDURINGFACTORYRESET,
151 TWFLAG_WIPEINGUI,
Ethan Yonker1b190162016-12-05 15:25:19 -0600152 TWFLAG_SLOTSELECT,
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600153 TWFLAG_WAIT,
154 TWFLAG_VERIFY,
155 TWFLAG_CHECK,
156 TWFLAG_ALTDEVICE,
157 TWFLAG_NOTRIM,
158 TWFLAG_VOLDMANAGED,
159 TWFLAG_FORMATTABLE,
160 TWFLAG_RESIZE,
Ethan Yonker93382822018-11-01 15:25:31 -0500161 TWFLAG_KEYDIRECTORY,
Peter Cai28ea7b02019-05-24 11:38:54 +0800162 TWFLAG_WRAPPEDKEY,
Matt Mower2416a502016-04-12 19:54:46 -0500163};
164
165/* Flags without a trailing '=' are considered dual format flags and can be
166 * written as either 'flagname' or 'flagname=', where the character following
167 * the '=' is Y,y,1 for true and false otherwise.
168 */
169const struct flag_list tw_flags[] = {
170 { "andsec", TWFLAG_ANDSEC },
171 { "backup", TWFLAG_BACKUP },
172 { "backupname=", TWFLAG_BACKUPNAME },
173 { "blocksize=", TWFLAG_BLOCKSIZE },
174 { "canbewiped", TWFLAG_CANBEWIPED },
175 { "canencryptbackup", TWFLAG_CANENCRYPTBACKUP },
176 { "defaults", TWFLAG_DEFAULTS },
177 { "display=", TWFLAG_DISPLAY },
178 { "encryptable=", TWFLAG_ENCRYPTABLE },
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500179 { "fileencryption=", TWFLAG_FILEENCRYPTION },
Matt Mower2416a502016-04-12 19:54:46 -0500180 { "flashimg", TWFLAG_FLASHIMG },
181 { "forceencrypt=", TWFLAG_FORCEENCRYPT },
182 { "fsflags=", TWFLAG_FSFLAGS },
183 { "ignoreblkid", TWFLAG_IGNOREBLKID },
184 { "length=", TWFLAG_LENGTH },
185 { "mounttodecrypt", TWFLAG_MOUNTTODECRYPT },
186 { "removable", TWFLAG_REMOVABLE },
Matt Mower2416a502016-04-12 19:54:46 -0500187 { "settingsstorage", TWFLAG_SETTINGSSTORAGE },
188 { "storage", TWFLAG_STORAGE },
189 { "storagename=", TWFLAG_STORAGENAME },
190 { "subpartitionof=", TWFLAG_SUBPARTITIONOF },
191 { "symlink=", TWFLAG_SYMLINK },
192 { "userdataencryptbackup", TWFLAG_USERDATAENCRYPTBACKUP },
193 { "usermrf", TWFLAG_USERMRF },
194 { "wipeduringfactoryreset", TWFLAG_WIPEDURINGFACTORYRESET },
195 { "wipeingui", TWFLAG_WIPEINGUI },
Ethan Yonker1b190162016-12-05 15:25:19 -0600196 { "slotselect", TWFLAG_SLOTSELECT },
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600197 { "wait", TWFLAG_WAIT },
198 { "verify", TWFLAG_VERIFY },
199 { "check", TWFLAG_CHECK },
200 { "altdevice", TWFLAG_ALTDEVICE },
201 { "notrim", TWFLAG_NOTRIM },
202 { "voldmanaged=", TWFLAG_VOLDMANAGED },
203 { "formattable", TWFLAG_FORMATTABLE },
204 { "resize", TWFLAG_RESIZE },
Ethan Yonker93382822018-11-01 15:25:31 -0500205 { "keydirectory=", TWFLAG_KEYDIRECTORY },
Peter Cai28ea7b02019-05-24 11:38:54 +0800206 { "wrappedkey", TWFLAG_WRAPPEDKEY },
Matt Mower2416a502016-04-12 19:54:46 -0500207 { 0, 0 },
208};
209
that9e0593e2014-10-08 00:01:24 +0200210TWPartition::TWPartition() {
Dees_Troy51a0e822012-09-05 15:24:24 -0400211 Can_Be_Mounted = false;
212 Can_Be_Wiped = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500213 Can_Be_Backed_Up = false;
Vojtech Bocek1dc30982013-08-30 21:49:30 +0200214 Use_Rm_Rf = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400215 Wipe_During_Factory_Reset = false;
216 Wipe_Available_in_GUI = false;
217 Is_SubPartition = false;
Dees_Troy2691f9d2012-09-24 11:15:49 -0400218 Has_SubPartition = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400219 SubPartition_Of = "";
220 Symlink_Path = "";
221 Symlink_Mount_Point = "";
222 Mount_Point = "";
Dees_Troye58d5262012-09-21 12:27:57 -0400223 Backup_Path = "";
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600224 Wildcard_Block_Device = false;
225 Sysfs_Entry = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400226 Actual_Block_Device = "";
227 Primary_Block_Device = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400228 Alternate_Block_Device = "";
229 Removable = false;
230 Is_Present = false;
231 Length = 0;
232 Size = 0;
233 Used = 0;
234 Free = 0;
235 Backup_Size = 0;
236 Can_Be_Encrypted = false;
237 Is_Encrypted = false;
238 Is_Decrypted = false;
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600239 Is_FBE = false;
Ethan Yonker253368a2014-11-25 15:00:52 -0600240 Mount_To_Decrypt = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400241 Decrypted_Block_Device = "";
242 Display_Name = "";
Dees_Troya13d74f2013-03-24 08:54:55 -0500243 Backup_Display_Name = "";
244 Storage_Name = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400245 Backup_Name = "";
Dees_Troy63c8df72012-09-10 14:02:05 -0400246 Backup_FileName = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400247 MTD_Name = "";
bigbiffce8f83c2015-12-12 18:30:21 -0500248 Backup_Method = BM_NONE;
Dees_Troy83bd4832013-05-04 12:39:56 +0000249 Can_Encrypt_Backup = false;
250 Use_Userdata_Encryption = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400251 Has_Data_Media = false;
Dees_Troye58d5262012-09-21 12:27:57 -0400252 Has_Android_Secure = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400253 Is_Storage = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500254 Is_Settings_Storage = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400255 Storage_Path = "";
256 Current_File_System = "";
257 Fstab_File_System = "";
Hashcode62bd9e02013-11-19 21:59:42 -0800258 Mount_Flags = 0;
259 Mount_Options = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400260 Format_Block_Size = 0;
Dees_Troy68cab492012-12-12 19:29:35 +0000261 Ignore_Blkid = false;
dianlujitao4879b372018-12-03 18:45:47 +0800262 Crypto_Key_Location = "";
Ethan Yonker726a0202014-12-16 20:01:38 -0600263 MTP_Storage_ID = 0;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600264 Can_Flash_Img = false;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500265 Mount_Read_Only = false;
Ethan Yonker66a19492015-12-10 10:19:45 -0600266 Is_Adopted_Storage = false;
267 Adopted_GUID = "";
Ethan Yonker1b190162016-12-05 15:25:19 -0600268 SlotSelect = false;
Ethan Yonker93382822018-11-01 15:25:31 -0500269 Key_Directory = "";
bigbiffee7b7ff2020-03-23 15:08:27 -0400270 Is_Super = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400271}
272
273TWPartition::~TWPartition(void) {
274 // Do nothing
275}
276
bigbiff8da46fa2020-09-08 16:42:34 -0400277bool 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 -0500278 char full_line[MAX_FSTAB_LINE_LENGTH];
Matt Mower2416a502016-04-12 19:54:46 -0500279 char twflags[MAX_FSTAB_LINE_LENGTH] = "";
Dees_Troy5bf43922012-09-07 16:07:55 -0400280 char* ptr;
Matt Mower2b2dd152016-04-26 11:24:08 -0500281 int line_len = strlen(fstab_line), index = 0, item_index = 0;
Dees_Troya13d74f2013-03-24 08:54:55 -0500282 bool skip = false;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600283 int fstab_version = 1, mount_point_index = 0, fs_index = 1, block_device_index = 2;
284 TWPartition *additional_entry = NULL;
285 std::map<string, Flags_Map>::iterator it;
Dees_Troy5bf43922012-09-07 16:07:55 -0400286
Matt Mower2b2dd152016-04-26 11:24:08 -0500287 strlcpy(full_line, fstab_line, sizeof(full_line));
bigbiffee7b7ff2020-03-23 15:08:27 -0400288
Dees_Troy51127312012-09-08 13:08:49 -0400289 for (index = 0; index < line_len; index++) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500290 if (full_line[index] == 34)
291 skip = !skip;
292 if (!skip && full_line[index] <= 32)
Dees_Troy5bf43922012-09-07 16:07:55 -0400293 full_line[index] = '\0';
Dees_Troy5bf43922012-09-07 16:07:55 -0400294 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600295 if (line_len < 10)
296 return false; // There can't possibly be a valid fstab line that is less than 10 chars
297 if (strncmp(fstab_line, "/dev/", strlen("/dev/")) == 0 || strncmp(fstab_line, "/devices/", strlen("/devices/")) == 0) {
298 fstab_version = 2;
299 block_device_index = 0;
300 mount_point_index = 1;
301 fs_index = 2;
302 }
303
bigbiffee7b7ff2020-03-23 15:08:27 -0400304 Is_Super = PartitionManager.Is_Super_Partition(fstab_line);
305 if (Is_Super) {
306 block_device_index = 0;
307 fstab_version = 2;
308 mount_point_index = 1;
309 fs_index = 2;
310 }
311
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600312 index = 0;
Dees_Troy5bf43922012-09-07 16:07:55 -0400313 while (index < line_len) {
314 while (index < line_len && full_line[index] == '\0')
315 index++;
316 if (index >= line_len)
317 continue;
318 ptr = full_line + index;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600319 if (item_index == mount_point_index) {
320 Mount_Point = ptr;
bigbiffee7b7ff2020-03-23 15:08:27 -0400321 if (fstab_version == 2 && Is_Super == false) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600322 additional_entry = PartitionManager.Find_Partition_By_Path(Mount_Point);
bigbiff8da46fa2020-09-08 16:42:34 -0400323 if (additional_entry) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600324 LOGINFO("Found an additional entry for '%s'\n", Mount_Point.c_str());
325 }
326 }
bigbiff8da46fa2020-09-08 16:42:34 -0400327 LOGINFO("Processing '%s'\n", Mount_Point.c_str());
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600328 Backup_Path = Mount_Point;
329 Storage_Path = Mount_Point;
330 Display_Name = ptr + 1;
331 Backup_Display_Name = Display_Name;
332 Storage_Name = Display_Name;
333 item_index++;
334 } else if (item_index == fs_index) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400335 // File System
336 Fstab_File_System = ptr;
337 Current_File_System = ptr;
338 item_index++;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600339 } else if (item_index == block_device_index) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400340 // Primary Block Device
Dees_Troy38bd7602012-09-14 13:33:53 -0400341 if (Fstab_File_System == "mtd" || Fstab_File_System == "yaffs2") {
Dees_Troy094207a2012-09-26 12:00:39 -0400342 MTD_Name = ptr;
343 Find_MTD_Block_Device(MTD_Name);
Dees_Troy5fcd8f92012-10-16 12:22:05 -0400344 } else if (Fstab_File_System == "bml") {
345 if (Mount_Point == "/boot")
346 MTD_Name = "boot";
347 else if (Mount_Point == "/recovery")
348 MTD_Name = "recovery";
349 Primary_Block_Device = ptr;
350 if (*ptr != '/')
Dees_Troy2673cec2013-04-02 20:22:16 +0000351 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 -0400352 } else if (*ptr != '/') {
bigbiffee7b7ff2020-03-23 15:08:27 -0400353 if (!Is_Super) {
354 if (Display_Error)
355 LOGERR("Invalid block device '%s' in fstab line '%s'", ptr, fstab_line);
356 else
357 LOGINFO("Invalid block device '%s' in fstab line '%s'", ptr, fstab_line);
358 return false;
359 }
Dees_Troy38bd7602012-09-14 13:33:53 -0400360 } else {
361 Primary_Block_Device = ptr;
362 Find_Real_Block_Device(Primary_Block_Device, Display_Error);
Dees_Troy5bf43922012-09-07 16:07:55 -0400363 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400364 item_index++;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600365 } else if (item_index > 2) {
366 if (fstab_version == 2) {
367 if (item_index == 3) {
368 Process_FS_Flags(ptr);
369 if (additional_entry) {
370 additional_entry->Save_FS_Flags(Fstab_File_System, Mount_Flags, Mount_Options);
371 return false; // We save the extra fs flags in the other partition entry and by returning false, this entry will be deleted
372 }
373 } else {
374 strlcpy(twflags, ptr, sizeof(twflags));
375 }
376 item_index++;
377 } else if (*ptr == '/') { // v2 fstab does not allow alternate block devices
Dees_Troy5bf43922012-09-07 16:07:55 -0400378 // Alternate Block Device
379 Alternate_Block_Device = ptr;
380 Find_Real_Block_Device(Alternate_Block_Device, Display_Error);
381 } else if (strlen(ptr) > 7 && strncmp(ptr, "length=", 7) == 0) {
382 // Partition length
383 ptr += 7;
384 Length = atoi(ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400385 } else if (strlen(ptr) > 6 && strncmp(ptr, "flags=", 6) == 0) {
386 // Custom flags, save for later so that new values aren't overwritten by defaults
387 ptr += 6;
Matt Mower2416a502016-04-12 19:54:46 -0500388 strlcpy(twflags, ptr, sizeof(twflags));
Dees_Troy38bd7602012-09-14 13:33:53 -0400389 } else if (strlen(ptr) == 4 && (strncmp(ptr, "NULL", 4) == 0 || strncmp(ptr, "null", 4) == 0 || strncmp(ptr, "null", 4) == 0)) {
390 // Do nothing
Dees_Troy5bf43922012-09-07 16:07:55 -0400391 } else {
392 // Unhandled data
Matt Mower2b2dd152016-04-26 11:24:08 -0500393 LOGINFO("Unhandled fstab information '%s' in fstab line '%s'\n", ptr, fstab_line);
Dees_Troy5bf43922012-09-07 16:07:55 -0400394 }
395 }
396 while (index < line_len && full_line[index] != '\0')
397 index++;
398 }
399
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600400 // override block devices from the v2 fstab with the ones we read from the twrp.flags file in case they are different
401 if (fstab_version == 2 && twrp_flags && twrp_flags->size() > 0) {
402 it = twrp_flags->find(Mount_Point);
403 if (it != twrp_flags->end()) {
404 if (!it->second.Primary_Block_Device.empty()) {
405 Primary_Block_Device = it->second.Primary_Block_Device;
406 Find_Real_Block_Device(Primary_Block_Device, Display_Error);
407 }
408 if (!it->second.Alternate_Block_Device.empty()) {
409 Alternate_Block_Device = it->second.Alternate_Block_Device;
410 Find_Real_Block_Device(Alternate_Block_Device, Display_Error);
411 }
412 }
413 }
414
415 if (strncmp(fstab_line, "/devices/", strlen("/devices/")) == 0) {
416 Sysfs_Entry = Primary_Block_Device;
417 Primary_Block_Device = "";
418 Is_Storage = true;
419 Removable = true;
420 Wipe_Available_in_GUI = true;
421 Wildcard_Block_Device = true;
422 }
423 if (Primary_Block_Device.find("*") != string::npos)
424 Wildcard_Block_Device = true;
425
bigbiff8da46fa2020-09-08 16:42:34 -0400426 if (Mount_Point == "auto") {
427 Mount_Point = "/auto";
428 char autoi[5];
429 sprintf(autoi, "%i", auto_index);
430 Mount_Point += autoi;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600431 Backup_Path = Mount_Point;
432 Storage_Path = Mount_Point;
dianlujitaob76a73a2020-04-30 20:33:20 +0800433 Backup_Name = Mount_Point.substr(1);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600434 auto_index++;
435 Setup_File_System(Display_Error);
436 Display_Name = "Storage";
437 Backup_Display_Name = Display_Name;
438 Storage_Name = Display_Name;
439 Can_Be_Backed_Up = false;
440 Wipe_Available_in_GUI = true;
441 Is_Storage = true;
442 Removable = true;
443 Wipe_Available_in_GUI = true;
444 } else if (!Is_File_System(Fstab_File_System) && !Is_Image(Fstab_File_System)) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400445 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000446 LOGERR("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400447 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000448 LOGINFO("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Matt Mower72c87ce2016-04-26 14:34:56 -0500449 return false;
Dees_Troy5bf43922012-09-07 16:07:55 -0400450 } else if (Is_File_System(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400451 Find_Actual_Block_Device();
Dees_Troy5bf43922012-09-07 16:07:55 -0400452 Setup_File_System(Display_Error);
dianlujitaob76a73a2020-04-30 20:33:20 +0800453 Backup_Name = Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
Chaosmaster3b682732020-01-25 21:09:28 +0100454 if (Mount_Point == "/" || Mount_Point == "/system" || Mount_Point == "/system_root") {
bigbiff8da46fa2020-09-08 16:42:34 -0400455 Mount_Point = PartitionManager.Get_Android_Root_Path();
456 Backup_Path = Mount_Point;
457 Storage_Path = Mount_Point;
Dees_Troy5bf43922012-09-07 16:07:55 -0400458 Display_Name = "System";
dianlujitaob76a73a2020-04-30 20:33:20 +0800459 Backup_Name = "system";
Dees_Troya13d74f2013-03-24 08:54:55 -0500460 Backup_Display_Name = Display_Name;
461 Storage_Name = Display_Name;
bigbiff8da46fa2020-09-08 16:42:34 -0400462 Wipe_Available_in_GUI = false;
463 Can_Be_Backed_Up = false;
464 Can_Be_Wiped = false;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500465 Mount_Read_Only = true;
bigbiff8da46fa2020-09-08 16:42:34 -0400466 Make_Dir(PartitionManager.Get_Android_Root_Path(), true);
Mohd Faraze3948ec2020-08-14 01:40:59 +0000467 } else if (Mount_Point == "/product") {
468 Display_Name = "Product";
469 Backup_Name = "Product";
470 Backup_Display_Name = Display_Name;
471 Storage_Name = Display_Name;
472 Can_Be_Backed_Up = Wipe_Available_in_GUI = Is_Super ? false : true;
473 Mount_Read_Only = true;
474 } else if (Mount_Point == "/odm") {
475 Display_Name = "ODM";
476 Backup_Name = "ODM";
477 Backup_Display_Name = Display_Name;
478 Storage_Name = Display_Name;
479 Can_Be_Backed_Up = Wipe_Available_in_GUI = Is_Super ? false : true;
480 Mount_Read_Only = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400481 } else if (Mount_Point == "/data") {
482 Display_Name = "Data";
Dees_Troya13d74f2013-03-24 08:54:55 -0500483 Backup_Display_Name = Display_Name;
484 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400485 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400486 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500487 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000488 Can_Encrypt_Backup = true;
489 Use_Userdata_Encryption = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400490 } else if (Mount_Point == "/cache") {
491 Display_Name = "Cache";
Dees_Troya13d74f2013-03-24 08:54:55 -0500492 Backup_Display_Name = Display_Name;
493 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400494 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400495 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500496 Can_Be_Backed_Up = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400497 } else if (Mount_Point == "/datadata") {
Dees_Troy51127312012-09-08 13:08:49 -0400498 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400499 Display_Name = "DataData";
Dees_Troya13d74f2013-03-24 08:54:55 -0500500 Backup_Display_Name = Display_Name;
501 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400502 Is_SubPartition = true;
503 SubPartition_Of = "/data";
Dees_Troy5bf43922012-09-07 16:07:55 -0400504 DataManager::SetValue(TW_HAS_DATADATA, 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500505 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000506 Can_Encrypt_Backup = true;
507 Use_Userdata_Encryption = false; // This whole partition should be encrypted
Dees_Troy5bf43922012-09-07 16:07:55 -0400508 } else if (Mount_Point == "/sd-ext") {
Dees_Troy51127312012-09-08 13:08:49 -0400509 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400510 Display_Name = "SD-Ext";
Dees_Troya13d74f2013-03-24 08:54:55 -0500511 Backup_Display_Name = Display_Name;
512 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400513 Wipe_Available_in_GUI = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400514 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500515 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000516 Can_Encrypt_Backup = true;
517 Use_Userdata_Encryption = true;
Dees_Troy2c50e182012-09-26 20:05:28 -0400518 } else if (Mount_Point == "/boot") {
519 Display_Name = "Boot";
Dees_Troya13d74f2013-03-24 08:54:55 -0500520 Backup_Display_Name = Display_Name;
Dees_Troy2c50e182012-09-26 20:05:28 -0400521 DataManager::SetValue("tw_boot_is_mountable", 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500522 Can_Be_Backed_Up = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500523 } else if (Mount_Point == "/vendor") {
524 Display_Name = "Vendor";
525 Backup_Display_Name = Display_Name;
526 Storage_Name = Display_Name;
527 Mount_Read_Only = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400528 }
529#ifdef TW_EXTERNAL_STORAGE_PATH
530 if (Mount_Point == EXPAND(TW_EXTERNAL_STORAGE_PATH)) {
531 Is_Storage = true;
532 Storage_Path = EXPAND(TW_EXTERNAL_STORAGE_PATH);
Dees_Troyc51f1f92012-09-20 15:32:13 -0400533 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500534 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400535#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000536 if (Mount_Point == "/sdcard" || Mount_Point == "/external_sd" || Mount_Point == "/external_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400537 Is_Storage = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400538 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500539 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400540#endif
Dees_Troyb05ddee2013-01-28 20:24:50 +0000541 }
Dees_Troy8170a922012-09-18 15:40:25 -0400542#ifdef TW_INTERNAL_STORAGE_PATH
543 if (Mount_Point == EXPAND(TW_INTERNAL_STORAGE_PATH)) {
544 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500545 Is_Settings_Storage = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400546 Storage_Path = EXPAND(TW_INTERNAL_STORAGE_PATH);
Dees_Troya13d74f2013-03-24 08:54:55 -0500547 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400548 }
549#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000550 if (Mount_Point == "/emmc" || Mount_Point == "/internal_sd" || Mount_Point == "/internal_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400551 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500552 Is_Settings_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500553 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400554 }
555#endif
Dees_Troy5bf43922012-09-07 16:07:55 -0400556 } else if (Is_Image(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400557 Find_Actual_Block_Device();
Ethan Yonker1b190162016-12-05 15:25:19 -0600558 Setup_Image();
Dees_Troya13d74f2013-03-24 08:54:55 -0500559 if (Mount_Point == "/boot") {
560 Display_Name = "Boot";
561 Backup_Display_Name = Display_Name;
562 Can_Be_Backed_Up = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600563 Can_Flash_Img = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500564 } else if (Mount_Point == "/recovery") {
565 Display_Name = "Recovery";
566 Backup_Display_Name = Display_Name;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600567 Can_Flash_Img = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500568 } else if (Mount_Point == "/system_image") {
569 Display_Name = "System Image";
570 Backup_Display_Name = Display_Name;
HashBanged974bb2016-01-30 14:20:09 -0500571 Can_Flash_Img = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500572 Can_Be_Backed_Up = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500573 } else if (Mount_Point == "/vendor_image") {
574 Display_Name = "Vendor Image";
575 Backup_Display_Name = Display_Name;
HashBanged974bb2016-01-30 14:20:09 -0500576 Can_Flash_Img = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500577 Can_Be_Backed_Up = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500578 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400579 }
580
Matt Mower2416a502016-04-12 19:54:46 -0500581 // Process TWRP fstab flags
582 if (strlen(twflags) > 0) {
583 string Prev_Display_Name = Display_Name;
584 string Prev_Storage_Name = Storage_Name;
585 string Prev_Backup_Display_Name = Backup_Display_Name;
586 Display_Name = "";
587 Storage_Name = "";
588 Backup_Display_Name = "";
589
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600590 Process_TW_Flags(twflags, (fstab_version == 1), fstab_version);
591 Save_FS_Flags(Fstab_File_System, Mount_Flags, Mount_Options);
Matt Mower2416a502016-04-12 19:54:46 -0500592
593 bool has_display_name = !Display_Name.empty();
594 bool has_storage_name = !Storage_Name.empty();
595 bool has_backup_name = !Backup_Display_Name.empty();
596 if (!has_display_name) Display_Name = Prev_Display_Name;
597 if (!has_storage_name) Storage_Name = Prev_Storage_Name;
598 if (!has_backup_name) Backup_Display_Name = Prev_Backup_Display_Name;
599
600 if (has_display_name && !has_storage_name)
601 Storage_Name = Display_Name;
602 if (!has_display_name && has_storage_name)
603 Display_Name = Storage_Name;
604 if (has_display_name && !has_backup_name && Backup_Display_Name != "Android Secure")
605 Backup_Display_Name = Display_Name;
606 if (!has_display_name && has_backup_name)
607 Display_Name = Backup_Display_Name;
608 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600609
610 if (fstab_version == 2 && twrp_flags && twrp_flags->size() > 0) {
611 it = twrp_flags->find(Mount_Point);
612 if (it != twrp_flags->end()) {
613 char twrpflags[MAX_FSTAB_LINE_LENGTH] = "";
614 int skip = 0;
615 string Flags = it->second.Flags;
616 strcpy(twrpflags, Flags.c_str());
617 if (strlen(twrpflags) > strlen("flags=") && strncmp(twrpflags, "flags=", strlen("flags=")) == 0)
618 skip += strlen("flags=");
619 char* flagptr = twrpflags;
620 flagptr += skip;
621 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
622 }
623 }
nkk7198fc3992017-12-16 16:26:42 +0200624
625 if (Mount_Point == "/persist" && Can_Be_Mounted) {
626 bool mounted = Is_Mounted();
627 if (mounted || Mount(false)) {
nkk7198fc3992017-12-16 16:26:42 +0200628 TWFunc::Fixup_Time_On_Boot("/persist/time/");
629 if (!mounted)
630 UnMount(false);
631 }
632 }
633
Dees_Troy51127312012-09-08 13:08:49 -0400634 return true;
635}
636
Matt Mower72c87ce2016-04-26 14:34:56 -0500637void TWPartition::Partition_Post_Processing(bool Display_Error) {
638 if (Mount_Point == "/data")
639 Setup_Data_Partition(Display_Error);
640 else if (Mount_Point == "/cache")
641 Setup_Cache_Partition(Display_Error);
642}
643
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600644void TWPartition::ExcludeAll(const string& path) {
645 backup_exclusions.add_absolute_dir(path);
646 wipe_exclusions.add_absolute_dir(path);
647}
648
Matt Mower72c87ce2016-04-26 14:34:56 -0500649void TWPartition::Setup_Data_Partition(bool Display_Error) {
650 if (Mount_Point != "/data")
651 return;
652
653 // Ensure /data is not mounted as tmpfs for qcom hardware decrypt
654 UnMount(false);
655
656#ifdef TW_INCLUDE_CRYPTO
657 if (datamedia)
658 Setup_Data_Media();
659 Can_Be_Encrypted = true;
660 char crypto_blkdev[255];
661 property_get("ro.crypto.fs_crypto_blkdev", crypto_blkdev, "error");
662 if (strcmp(crypto_blkdev, "error") != 0) {
bigbiff7ba75002020-04-11 20:47:09 -0400663 Set_FBE_Status();
Matt Mower72c87ce2016-04-26 14:34:56 -0500664 Decrypted_Block_Device = crypto_blkdev;
665 LOGINFO("Data already decrypted, new block device: '%s'\n", crypto_blkdev);
bigbiff7ba75002020-04-11 20:47:09 -0400666 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
Matt Mower72c87ce2016-04-26 14:34:56 -0500667 } else if (!Mount(false)) {
668 if (Is_Present) {
Ethan Yonker93382822018-11-01 15:25:31 -0500669 if (Key_Directory.empty()) {
bigbiffadc599e2020-05-28 19:36:30 +0000670 set_partition_data(Actual_Block_Device.c_str(), Crypto_Key_Location.c_str(), Fstab_File_System.c_str());
Ethan Yonker93382822018-11-01 15:25:31 -0500671 if (cryptfs_check_footer() == 0) {
672 Is_Encrypted = true;
673 Is_Decrypted = false;
674 Can_Be_Mounted = false;
675 Current_File_System = "emmc";
676 Setup_Image();
Ethan Yonker93382822018-11-01 15:25:31 -0500677 DataManager::SetValue(TW_CRYPTO_PWTYPE, cryptfs_get_password_type());
678 DataManager::SetValue(TW_CRYPTO_PASSWORD, "");
679 DataManager::SetValue("tw_crypto_display", "");
680 } else {
681 gui_err("mount_data_footer=Could not mount /data and unable to find crypto footer.");
682 }
683 } else {
Matt Mower72c87ce2016-04-26 14:34:56 -0500684 Is_Encrypted = true;
685 Is_Decrypted = false;
Matt Mower72c87ce2016-04-26 14:34:56 -0500686 }
Ethan Yonker93382822018-11-01 15:25:31 -0500687 } else if (Key_Directory.empty()) {
bigbiffadc599e2020-05-28 19:36:30 +0000688 LOGERR("Primary block device '%s' for mount point '%s' is not present!\n", Primary_Block_Device.c_str(), Mount_Point.c_str());
Matt Mower72c87ce2016-04-26 14:34:56 -0500689 }
690 } else {
bigbiff7ba75002020-04-11 20:47:09 -0400691 Set_FBE_Status();
mauronofrio9bf73352019-11-23 22:27:34 +0100692 if (!Decrypt_FBE_DE()) {
mauronofriofc79aa62019-11-23 23:13:04 +0100693 char wrappedvalue[PROPERTY_VALUE_MAX];
694 property_get("fbe.data.wrappedkey", wrappedvalue, "");
695 std::string wrappedkeyvalue(wrappedvalue);
696 if (wrappedkeyvalue == "true") {
697 LOGERR("Unable to decrypt FBE device\n");
698 } else {
699 LOGINFO("Trying wrapped key.\n");
700 property_set("fbe.data.wrappedkey", "true");
mauronofrio9bf73352019-11-23 22:27:34 +0100701 if (!Decrypt_FBE_DE()) {
bigbiffd58ba182020-03-23 10:02:29 -0400702 LOGERR("Unable to decrypt FBE device\n");
mauronofrio9bf73352019-11-23 22:27:34 +0100703 }
mauronofriofc79aa62019-11-23 23:13:04 +0100704 }
mauronofrio9bf73352019-11-23 22:27:34 +0100705 }
bigbiff7ba75002020-04-11 20:47:09 -0400706 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
Matt Mower72c87ce2016-04-26 14:34:56 -0500707 }
708 if (datamedia && (!Is_Encrypted || (Is_Encrypted && Is_Decrypted))) {
709 Setup_Data_Media();
bigbiff25d25b92020-06-19 16:07:38 -0400710 Recreate_Media_Folder();
Matt Mower72c87ce2016-04-26 14:34:56 -0500711 }
712#else
713 if (datamedia) {
714 Setup_Data_Media();
715 Recreate_Media_Folder();
716 }
717#endif
718}
719
bigbiff7ba75002020-04-11 20:47:09 -0400720void TWPartition::Set_FBE_Status() {
721 DataManager::SetValue(TW_IS_DECRYPTED, 1);
722 Is_Encrypted = true;
723 Is_Decrypted = true;
724 LOGINFO("Setup_Data_Partition::Key_Directory::%s\n", Key_Directory.c_str());
725 if (Key_Directory.empty()) {
726 Is_FBE = false;
727 DataManager::SetValue(TW_IS_FBE, 0);
728 } else {
729 Is_FBE = true;
730 DataManager::SetValue(TW_IS_FBE, 1);
731 }
732}
733
Ethan Yonker93382822018-11-01 15:25:31 -0500734bool TWPartition::Decrypt_FBE_DE() {
bigbiff7ba75002020-04-11 20:47:09 -0400735 if (TWFunc::Path_Exists("/data/unencrypted/key/version")) {
Captain Throwback87d73d62020-02-17 16:44:50 -0500736 DataManager::SetValue(TW_IS_FBE, 1);
Mohd Faraz815e2402020-09-19 19:31:52 +0530737 DataManager::SetValue(TW_CRYPTO_PWTYPE, "0"); // Set initial value so that recovery will not be confused when using unencrypted data or failed to decrypt data
Ethan Yonker93382822018-11-01 15:25:31 -0500738 LOGINFO("File Based Encryption is present\n");
739#ifdef TW_INCLUDE_FBE
bigbiffadc599e2020-05-28 19:36:30 +0000740 ExcludeAll(Mount_Point + "/convert_fbe");
741 ExcludeAll(Mount_Point + "/unencrypted");
742 //ExcludeAll(Mount_Point + "/system/users/0"); // we WILL need to retain some of this if multiple users are present or we just need to delete more folders for the extra users somewhere else
743 ExcludeAll(Mount_Point + "/misc/vold/user_keys");
bigbiff7ba75002020-04-11 20:47:09 -0400744 ExcludeAll(Mount_Point + "/misc/vold/volume_keys");
bigbiffadc599e2020-05-28 19:36:30 +0000745 //ExcludeAll(Mount_Point + "/system_ce");
746 //ExcludeAll(Mount_Point + "/system_de");
747 //ExcludeAll(Mount_Point + "/misc_ce");
748 //ExcludeAll(Mount_Point + "/misc_de");
749 ExcludeAll(Mount_Point + "/system/gatekeeper.password.key");
750 ExcludeAll(Mount_Point + "/system/gatekeeper.pattern.key");
751 ExcludeAll(Mount_Point + "/system/locksettings.db");
752 //ExcludeAll(Mount_Point + "/system/locksettings.db-shm"); // don't seem to need this one, but the other 2 are needed
753 ExcludeAll(Mount_Point + "/system/locksettings.db-wal");
754 //ExcludeAll(Mount_Point + "/user_de");
755 //ExcludeAll(Mount_Point + "/misc/profiles/cur/0"); // might be important later
756 ExcludeAll(Mount_Point + "/misc/gatekeeper");
757 ExcludeAll(Mount_Point + "/misc/keystore");
758 ExcludeAll(Mount_Point + "/drm/kek.dat");
759 ExcludeAll(Mount_Point + "/system_de/0/spblob"); // contains data needed to decrypt pixel 2
bigbiff7ba75002020-04-11 20:47:09 -0400760 ExcludeAll(Mount_Point + "/per_boot"); // removed each boot by init
761
bigbiffadc599e2020-05-28 19:36:30 +0000762 int retry_count = 3;
763 while (!Decrypt_DE() && --retry_count)
764 usleep(2000);
765 if (retry_count > 0) {
766 property_set("ro.crypto.state", "encrypted");
767 Is_Encrypted = true;
768 Is_Decrypted = false;
769 Is_FBE = true;
770 DataManager::SetValue(TW_IS_FBE, 1);
bigbiffadc599e2020-05-28 19:36:30 +0000771 string filename;
772 int pwd_type = Get_Password_Type(0, filename);
773 if (pwd_type < 0) {
774 LOGERR("This TWRP does not have synthetic password decrypt support\n");
775 pwd_type = 0; // default password
776 }
777 DataManager::SetValue(TW_CRYPTO_PWTYPE, pwd_type);
778 DataManager::SetValue(TW_CRYPTO_PASSWORD, "");
779 DataManager::SetValue("tw_crypto_display", "");
780 return true;
Ethan Yonker93382822018-11-01 15:25:31 -0500781 }
782#else
783 LOGERR("FBE found but FBE support not present in TWRP\n");
784#endif
785 }
Captain Throwback87d73d62020-02-17 16:44:50 -0500786 DataManager::SetValue(TW_IS_FBE, 0);
Ethan Yonker93382822018-11-01 15:25:31 -0500787 return false;
788}
789
Matt Mower72c87ce2016-04-26 14:34:56 -0500790void TWPartition::Setup_Cache_Partition(bool Display_Error __unused) {
791 if (Mount_Point != "/cache")
792 return;
793
794 if (!Mount(true))
795 return;
796
797 if (!TWFunc::Path_Exists("/cache/recovery/.")) {
798 LOGINFO("Recreating /cache/recovery folder\n");
799 if (mkdir("/cache/recovery", S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP) != 0)
800 LOGERR("Could not create /cache/recovery\n");
801 }
802}
803
Matt Mower4ab42b12016-04-21 13:52:18 -0500804void TWPartition::Process_FS_Flags(const char *str) {
805 char *options = strdup(str);
806 char *ptr, *savep;
Hashcode62bd9e02013-11-19 21:59:42 -0800807
Matt Mower4ab42b12016-04-21 13:52:18 -0500808 Mount_Options = "";
Hashcode62bd9e02013-11-19 21:59:42 -0800809
Matt Mower4ab42b12016-04-21 13:52:18 -0500810 // Avoid issues with potentially nested strtok by using strtok_r
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600811 for (ptr = strtok_r(options, ",", &savep); ptr; ptr = strtok_r(NULL, ",", &savep)) {
812 char *equals = strstr(ptr, "=");
813 size_t name_len;
Matt Mower4ab42b12016-04-21 13:52:18 -0500814
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600815 if (!equals)
816 name_len = strlen(ptr);
817 else
818 name_len = equals - ptr;
819
820 // There are some flags that we want to ignore in TWRP
821 bool found_match = false;
822 for (const char** ignored_mount_item = ignored_mount_items; *ignored_mount_item; ignored_mount_item++) {
823 if (strncmp(ptr, *ignored_mount_item, name_len) == 0) {
824 found_match = true;
Hashcode62bd9e02013-11-19 21:59:42 -0800825 break;
826 }
827 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600828 if (found_match)
829 continue;
Hashcode62bd9e02013-11-19 21:59:42 -0800830
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600831 // mount_flags are never postfixed by '='
832 if (!equals) {
833 const struct flag_list* mount_flag = mount_flags;
834 for (; mount_flag->name; mount_flag++) {
835 if (strcmp(ptr, mount_flag->name) == 0) {
836 if (mount_flag->flag == MS_RDONLY)
837 Mount_Read_Only = true;
838 else
839 Mount_Flags |= (unsigned)mount_flag->flag;
840 found_match = true;
841 break;
842 }
843 }
844 if (found_match)
845 continue;
Matt Mower4ab42b12016-04-21 13:52:18 -0500846 }
847
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600848 // If we aren't ignoring this flag and it's not a mount flag, then it must be a mount option
849 if (!Mount_Options.empty())
850 Mount_Options += ",";
851 Mount_Options += ptr;
Matt Mower4ab42b12016-04-21 13:52:18 -0500852 }
853 free(options);
Hashcode62bd9e02013-11-19 21:59:42 -0800854}
855
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600856void TWPartition::Save_FS_Flags(const string& local_File_System, int local_Mount_Flags, const string& local_Mount_Options) {
857 partition_fs_flags_struct flags;
858 flags.File_System = local_File_System;
859 flags.Mount_Flags = local_Mount_Flags;
860 flags.Mount_Options = local_Mount_Options;
861 fs_flags.push_back(flags);
862}
863
Matt Mower2416a502016-04-12 19:54:46 -0500864void TWPartition::Apply_TW_Flag(const unsigned flag, const char* str, const bool val) {
865 switch (flag) {
866 case TWFLAG_ANDSEC:
867 Has_Android_Secure = val;
868 break;
869 case TWFLAG_BACKUP:
870 Can_Be_Backed_Up = val;
871 break;
872 case TWFLAG_BACKUPNAME:
873 Backup_Display_Name = str;
874 break;
875 case TWFLAG_BLOCKSIZE:
876 Format_Block_Size = (unsigned long)(atol(str));
877 break;
878 case TWFLAG_CANBEWIPED:
879 Can_Be_Wiped = val;
880 break;
881 case TWFLAG_CANENCRYPTBACKUP:
882 Can_Encrypt_Backup = val;
883 break;
884 case TWFLAG_DEFAULTS:
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600885 case TWFLAG_WAIT:
886 case TWFLAG_VERIFY:
887 case TWFLAG_CHECK:
888 case TWFLAG_NOTRIM:
889 case TWFLAG_VOLDMANAGED:
890 case TWFLAG_RESIZE:
Matt Mower2416a502016-04-12 19:54:46 -0500891 // Do nothing
892 break;
893 case TWFLAG_DISPLAY:
894 Display_Name = str;
895 break;
896 case TWFLAG_ENCRYPTABLE:
897 case TWFLAG_FORCEENCRYPT:
898 Crypto_Key_Location = str;
899 break;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500900 case TWFLAG_FILEENCRYPTION:
901 // This flag isn't used by TWRP but is needed in 9.0 FBE decrypt
902 // fileencryption=ice:aes-256-heh
903 {
904 std::string FBE = str;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500905 size_t colon_loc = FBE.find(":");
906 if (colon_loc == std::string::npos) {
Ethan Yonker93382822018-11-01 15:25:31 -0500907 property_set("fbe.contents", FBE.c_str());
908 property_set("fbe.filenames", "");
909 LOGINFO("FBE contents '%s', filenames ''\n", FBE.c_str());
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500910 break;
911 }
Ethan Yonker93382822018-11-01 15:25:31 -0500912 std::string FBE_contents, FBE_filenames;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500913 FBE_contents = FBE.substr(0, colon_loc);
914 FBE_filenames = FBE.substr(colon_loc + 1);
915 property_set("fbe.contents", FBE_contents.c_str());
916 property_set("fbe.filenames", FBE_filenames.c_str());
917 LOGINFO("FBE contents '%s', filenames '%s'\n", FBE_contents.c_str(), FBE_filenames.c_str());
918 }
919 break;
Peter Cai28ea7b02019-05-24 11:38:54 +0800920 case TWFLAG_WRAPPEDKEY:
921 // Set fbe.data.wrappedkey to true
922 {
923 property_set("fbe.data.wrappedkey", "true");
924 LOGINFO("FBE wrapped key enabled\n");
925 }
926 break;
Matt Mower2416a502016-04-12 19:54:46 -0500927 case TWFLAG_FLASHIMG:
928 Can_Flash_Img = val;
929 break;
930 case TWFLAG_FSFLAGS:
Matt Mower4ab42b12016-04-21 13:52:18 -0500931 Process_FS_Flags(str);
Matt Mower2416a502016-04-12 19:54:46 -0500932 break;
933 case TWFLAG_IGNOREBLKID:
934 Ignore_Blkid = val;
935 break;
936 case TWFLAG_LENGTH:
937 Length = atoi(str);
938 break;
939 case TWFLAG_MOUNTTODECRYPT:
940 Mount_To_Decrypt = val;
941 break;
942 case TWFLAG_REMOVABLE:
943 Removable = val;
944 break;
Matt Mower2416a502016-04-12 19:54:46 -0500945 case TWFLAG_SETTINGSSTORAGE:
946 Is_Settings_Storage = val;
947 if (Is_Settings_Storage)
948 Is_Storage = true;
949 break;
950 case TWFLAG_STORAGE:
951 Is_Storage = val;
952 break;
953 case TWFLAG_STORAGENAME:
954 Storage_Name = str;
955 break;
956 case TWFLAG_SUBPARTITIONOF:
957 Is_SubPartition = true;
958 SubPartition_Of = str;
959 break;
960 case TWFLAG_SYMLINK:
961 Symlink_Path = str;
962 break;
963 case TWFLAG_USERDATAENCRYPTBACKUP:
964 Use_Userdata_Encryption = val;
965 if (Use_Userdata_Encryption)
966 Can_Encrypt_Backup = true;
967 break;
968 case TWFLAG_USERMRF:
969 Use_Rm_Rf = val;
970 break;
971 case TWFLAG_WIPEDURINGFACTORYRESET:
972 Wipe_During_Factory_Reset = val;
973 if (Wipe_During_Factory_Reset) {
974 Can_Be_Wiped = true;
975 Wipe_Available_in_GUI = true;
976 }
977 break;
978 case TWFLAG_WIPEINGUI:
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600979 case TWFLAG_FORMATTABLE:
Matt Mower2416a502016-04-12 19:54:46 -0500980 Wipe_Available_in_GUI = val;
981 if (Wipe_Available_in_GUI)
982 Can_Be_Wiped = true;
983 break;
Ethan Yonker1b190162016-12-05 15:25:19 -0600984 case TWFLAG_SLOTSELECT:
985 SlotSelect = true;
986 break;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600987 case TWFLAG_ALTDEVICE:
988 Alternate_Block_Device = str;
989 break;
Ethan Yonker93382822018-11-01 15:25:31 -0500990 case TWFLAG_KEYDIRECTORY:
991 Key_Directory = str;
bigbiffd58ba182020-03-23 10:02:29 -0400992 break;
Matt Mower2416a502016-04-12 19:54:46 -0500993 default:
994 // Should not get here
995 LOGINFO("Flag identified for processing, but later unmatched: %i\n", flag);
996 break;
997 }
998}
Dees_Troy51127312012-09-08 13:08:49 -0400999
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001000void TWPartition::Process_TW_Flags(char *flags, bool Display_Error, int fstab_ver) {
Matt Mower2416a502016-04-12 19:54:46 -05001001 char separator[2] = {'\n', 0};
1002 char *ptr, *savep;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001003 char source_separator = ';';
1004
1005 if (fstab_ver == 2)
1006 source_separator = ',';
Matt Mower2416a502016-04-12 19:54:46 -05001007
1008 // Semicolons within double-quotes are not forbidden, so replace
1009 // only the semicolons intended as separators with '\n' for strtok
1010 for (unsigned i = 0, skip = 0; i < strlen(flags); i++) {
1011 if (flags[i] == '\"')
Dees_Troya13d74f2013-03-24 08:54:55 -05001012 skip = !skip;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001013 if (!skip && flags[i] == source_separator)
Matt Mower2416a502016-04-12 19:54:46 -05001014 flags[i] = separator[0];
Dees_Troy51127312012-09-08 13:08:49 -04001015 }
1016
Matt Mower2416a502016-04-12 19:54:46 -05001017 // Avoid issues with potentially nested strtok by using strtok_r
1018 ptr = strtok_r(flags, separator, &savep);
1019 while (ptr) {
1020 int ptr_len = strlen(ptr);
1021 const struct flag_list* tw_flag = tw_flags;
Hashcode62bd9e02013-11-19 21:59:42 -08001022
Matt Mower2416a502016-04-12 19:54:46 -05001023 for (; tw_flag->name; tw_flag++) {
1024 int flag_len = strlen(tw_flag->name);
1025
1026 if (strncmp(ptr, tw_flag->name, flag_len) == 0) {
1027 bool flag_val = false;
1028
1029 if (ptr_len > flag_len && (tw_flag->name)[flag_len-1] != '='
1030 && ptr[flag_len] != '=') {
1031 // Handle flags with same starting string
1032 // (e.g. backup and backupname)
1033 continue;
1034 } else if (ptr_len > flag_len && ptr[flag_len] == '=') {
1035 // Handle flags with dual format: Part 1
1036 // (e.g. backup and backup=y. backup=y handled here)
1037 ptr += flag_len + 1;
1038 TWFunc::Strip_Quotes(ptr);
1039 // Skip flags with empty argument
1040 // (e.g. backup=)
1041 if (strlen(ptr) == 0) {
1042 LOGINFO("Flag missing argument or should not include '=': %s=\n", tw_flag->name);
1043 break;
1044 }
1045 flag_val = strchr("yY1", *ptr) != NULL;
1046 } else if (ptr_len == flag_len
1047 && (tw_flag->name)[flag_len-1] == '=') {
1048 // Skip flags missing argument after =
1049 // (e.g. backupname=)
1050 LOGINFO("Flag missing argument: %s\n", tw_flag->name);
1051 break;
1052 } else if (ptr_len > flag_len
1053 && (tw_flag->name)[flag_len-1] == '=') {
1054 // Handle arguments to flags
1055 // (e.g. backupname="My Stuff")
1056 ptr += flag_len;
1057 TWFunc::Strip_Quotes(ptr);
1058 // Skip flags with empty argument
1059 // (e.g. backupname="")
1060 if (strlen(ptr) == 0) {
1061 LOGINFO("Flag missing argument: %s\n", tw_flag->name);
1062 break;
1063 }
1064 } else if (ptr_len == flag_len) {
1065 // Handle flags with dual format: Part 2
1066 // (e.g. backup and backup=y. backup handled here)
1067 flag_val = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001068 } else {
Matt Mower2416a502016-04-12 19:54:46 -05001069 LOGINFO("Flag matched, but could not be processed: %s\n", ptr);
1070 break;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001071 }
Matt Mower2416a502016-04-12 19:54:46 -05001072
1073 Apply_TW_Flag(tw_flag->flag, ptr, flag_val);
1074 break;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001075 }
Matt Mower2416a502016-04-12 19:54:46 -05001076 }
1077 if (tw_flag->name == 0) {
Dees_Troy51127312012-09-08 13:08:49 -04001078 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001079 LOGERR("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -04001080 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001081 LOGINFO("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -04001082 }
Matt Mower2416a502016-04-12 19:54:46 -05001083 ptr = strtok_r(NULL, separator, &savep);
Dees_Troy51127312012-09-08 13:08:49 -04001084 }
Dees_Troy51a0e822012-09-05 15:24:24 -04001085}
1086
Dees_Troy5bf43922012-09-07 16:07:55 -04001087bool TWPartition::Is_File_System(string File_System) {
1088 if (File_System == "ext2" ||
Dees_Troy63c8df72012-09-10 14:02:05 -04001089 File_System == "ext3" ||
Dees_Troy5bf43922012-09-07 16:07:55 -04001090 File_System == "ext4" ||
1091 File_System == "vfat" ||
1092 File_System == "ntfs" ||
1093 File_System == "yaffs2" ||
bigbiff bigbiff3e146522012-11-14 14:32:59 -05001094 File_System == "exfat" ||
Dees_Troye5017042013-08-29 16:38:55 +00001095 File_System == "f2fs" ||
Erfan Abdib859e912019-02-05 18:18:46 +02001096 File_System == "squashfs" ||
Dees_Troy5bf43922012-09-07 16:07:55 -04001097 File_System == "auto")
1098 return true;
1099 else
1100 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001101}
1102
Dees_Troy5bf43922012-09-07 16:07:55 -04001103bool TWPartition::Is_Image(string File_System) {
Dees_Troy5fcd8f92012-10-16 12:22:05 -04001104 if (File_System == "emmc" || File_System == "mtd" || File_System == "bml")
Dees_Troy5bf43922012-09-07 16:07:55 -04001105 return true;
1106 else
1107 return false;
1108}
1109
Dees_Troy51127312012-09-08 13:08:49 -04001110bool TWPartition::Make_Dir(string Path, bool Display_Error) {
Ethan Yonker93ac7a02016-11-07 22:05:58 -06001111 if (TWFunc::Get_D_Type_From_Stat(Path) != S_IFDIR)
1112 unlink(Path.c_str());
Dees_Troy43d8b002012-09-17 16:00:01 -04001113 if (!TWFunc::Path_Exists(Path)) {
Dees_Troy51127312012-09-08 13:08:49 -04001114 if (mkdir(Path.c_str(), 0777) == -1) {
1115 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001116 gui_msg(Msg(msg::kError, "create_folder_strerr=Can not create '{1}' folder ({2}).")(Path)(strerror(errno)));
Dees_Troy51127312012-09-08 13:08:49 -04001117 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001118 LOGINFO("Can not create '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001119 return false;
1120 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001121 LOGINFO("Created '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001122 return true;
1123 }
1124 }
1125 return true;
1126}
1127
Dees_Troy5bf43922012-09-07 16:07:55 -04001128void TWPartition::Setup_File_System(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001129 Can_Be_Mounted = true;
1130 Can_Be_Wiped = true;
1131
Dees_Troy5bf43922012-09-07 16:07:55 -04001132 // Make the mount point folder if it doesn't exist
Dees_Troy51127312012-09-08 13:08:49 -04001133 Make_Dir(Mount_Point, Display_Error);
bigbiffce8f83c2015-12-12 18:30:21 -05001134 Backup_Method = BM_FILES;
Dees_Troy5bf43922012-09-07 16:07:55 -04001135}
1136
Ethan Yonker1b190162016-12-05 15:25:19 -06001137void TWPartition::Setup_Image() {
Dees_Troy5bf43922012-09-07 16:07:55 -04001138 Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
1139 Backup_Name = Display_Name;
Gary Peck82599a82012-11-21 16:23:12 -08001140 if (Current_File_System == "emmc")
bigbiffce8f83c2015-12-12 18:30:21 -05001141 Backup_Method = BM_DD;
Gary Peck82599a82012-11-21 16:23:12 -08001142 else if (Current_File_System == "mtd" || Current_File_System == "bml")
bigbiffce8f83c2015-12-12 18:30:21 -05001143 Backup_Method = BM_FLASH_UTILS;
Dees_Troy5bf43922012-09-07 16:07:55 -04001144 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001145 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 -04001146}
1147
Dees_Troye58d5262012-09-21 12:27:57 -04001148void TWPartition::Setup_AndSec(void) {
Dees_Troya13d74f2013-03-24 08:54:55 -05001149 Backup_Display_Name = "Android Secure";
Dees_Troye58d5262012-09-21 12:27:57 -04001150 Backup_Name = "and-sec";
Dees_Troya13d74f2013-03-24 08:54:55 -05001151 Can_Be_Backed_Up = true;
Dees_Troye58d5262012-09-21 12:27:57 -04001152 Has_Android_Secure = true;
1153 Symlink_Path = Mount_Point + "/.android_secure";
1154 Symlink_Mount_Point = "/and-sec";
1155 Backup_Path = Symlink_Mount_Point;
1156 Make_Dir("/and-sec", true);
1157 Recreate_AndSec_Folder();
Kjell Braden3126a112016-06-19 16:58:15 +00001158 Mount_Storage_Retry(true);
Dees_Troye58d5262012-09-21 12:27:57 -04001159}
1160
that9e0593e2014-10-08 00:01:24 +02001161void TWPartition::Setup_Data_Media() {
Ethan Yonker6277c792014-09-15 14:54:30 -05001162 LOGINFO("Setting up '%s' as data/media emulated storage.\n", Mount_Point.c_str());
Ethan Yonker66a19492015-12-10 10:19:45 -06001163 if (Storage_Name.empty() || Storage_Name == "Data")
1164 Storage_Name = "Internal Storage";
Ethan Yonker6277c792014-09-15 14:54:30 -05001165 Has_Data_Media = true;
1166 Is_Storage = true;
Ethan Yonker66a19492015-12-10 10:19:45 -06001167 Storage_Path = Mount_Point + "/media";
Ethan Yonker6277c792014-09-15 14:54:30 -05001168 Symlink_Path = Storage_Path;
Ethan Yonker66a19492015-12-10 10:19:45 -06001169 if (Mount_Point == "/data") {
1170 Is_Settings_Storage = true;
1171 if (strcmp(EXPAND(TW_EXTERNAL_STORAGE_PATH), "/sdcard") == 0) {
1172 Make_Dir("/emmc", false);
1173 Symlink_Mount_Point = "/emmc";
1174 } else {
1175 Make_Dir("/sdcard", false);
1176 Symlink_Mount_Point = "/sdcard";
1177 }
1178 if (Mount(false) && TWFunc::Path_Exists(Mount_Point + "/media/0")) {
1179 Storage_Path = Mount_Point + "/media/0";
1180 Symlink_Path = Storage_Path;
1181 DataManager::SetValue(TW_INTERNAL_PATH, Mount_Point + "/media/0");
1182 UnMount(true);
1183 }
1184 DataManager::SetValue("tw_has_internal", 1);
1185 DataManager::SetValue("tw_has_data_media", 1);
Ethan Yonker3fdcda42016-11-30 12:29:37 -06001186 backup_exclusions.add_absolute_dir("/data/data/com.google.android.music/files");
bigbiff25d25b92020-06-19 16:07:38 -04001187 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 +01001188 backup_exclusions.add_absolute_dir("/data/vendor/dumpsys");
bigbiff25d25b92020-06-19 16:07:38 -04001189 backup_exclusions.add_absolute_dir("/data/cache");
Ethan Yonker6355b562017-05-01 09:42:17 -05001190 wipe_exclusions.add_absolute_dir(Mount_Point + "/misc/vold"); // adopted storage keys
Ethan Yonker79f88bd2016-12-09 14:52:12 -06001191 ExcludeAll(Mount_Point + "/system/storage.xml");
Ethan Yonker6277c792014-09-15 14:54:30 -05001192 } else {
Ethan Yonker66a19492015-12-10 10:19:45 -06001193 if (Mount(true) && TWFunc::Path_Exists(Mount_Point + "/media/0")) {
1194 Storage_Path = Mount_Point + "/media/0";
1195 Symlink_Path = Storage_Path;
1196 UnMount(true);
1197 }
Ethan Yonker6277c792014-09-15 14:54:30 -05001198 }
Ethan Yonker79f88bd2016-12-09 14:52:12 -06001199 ExcludeAll(Mount_Point + "/media");
Ethan Yonker6277c792014-09-15 14:54:30 -05001200}
1201
Dees_Troy5bf43922012-09-07 16:07:55 -04001202void TWPartition::Find_Real_Block_Device(string& Block, bool Display_Error) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001203 char device[PATH_MAX], realDevice[PATH_MAX];
Dees_Troy5bf43922012-09-07 16:07:55 -04001204
1205 strcpy(device, Block.c_str());
1206 memset(realDevice, 0, sizeof(realDevice));
1207 while (readlink(device, realDevice, sizeof(realDevice)) > 0)
1208 {
1209 strcpy(device, realDevice);
1210 memset(realDevice, 0, sizeof(realDevice));
1211 }
1212
1213 if (device[0] != '/') {
1214 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001215 LOGERR("Invalid symlink path '%s' found on block device '%s'\n", device, Block.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001216 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001217 LOGINFO("Invalid symlink path '%s' found on block device '%s'\n", device, Block.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001218 return;
Dees_Troy51a0e822012-09-05 15:24:24 -04001219 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -04001220 Block = device;
1221 return;
1222 }
1223}
1224
Kjell Braden3126a112016-06-19 16:58:15 +00001225bool TWPartition::Mount_Storage_Retry(bool Display_Error) {
Dees_Troy8e337f32012-10-13 22:07:49 -04001226 // On some devices, storage doesn't want to mount right away, retry and sleep
Kjell Braden3126a112016-06-19 16:58:15 +00001227 if (!Mount(Display_Error)) {
Dees_Troy8e337f32012-10-13 22:07:49 -04001228 int retry_count = 5;
1229 while (retry_count > 0 && !Mount(false)) {
1230 usleep(500000);
1231 retry_count--;
1232 }
Kjell Braden3126a112016-06-19 16:58:15 +00001233 return Mount(Display_Error);
Dees_Troy8e337f32012-10-13 22:07:49 -04001234 }
Kjell Braden3126a112016-06-19 16:58:15 +00001235 return true;
Dees_Troy8e337f32012-10-13 22:07:49 -04001236}
1237
Dees_Troy38bd7602012-09-14 13:33:53 -04001238bool TWPartition::Find_MTD_Block_Device(string MTD_Name) {
1239 FILE *fp = NULL;
1240 char line[255];
1241
1242 fp = fopen("/proc/mtd", "rt");
1243 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001244 LOGERR("Device does not support /proc/mtd\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001245 return false;
1246 }
1247
1248 while (fgets(line, sizeof(line), fp) != NULL)
1249 {
1250 char device[32], label[32];
1251 unsigned long size = 0;
Dees_Troy38bd7602012-09-14 13:33:53 -04001252 int deviceId;
1253
1254 sscanf(line, "%s %lx %*s %*c%s", device, &size, label);
1255
1256 // Skip header and blank lines
1257 if ((strcmp(device, "dev:") == 0) || (strlen(line) < 8))
1258 continue;
1259
1260 // Strip off the trailing " from the label
1261 label[strlen(label)-1] = '\0';
1262
1263 if (strcmp(label, MTD_Name.c_str()) == 0) {
1264 // We found our device
1265 // Strip off the trailing : from the device
1266 device[strlen(device)-1] = '\0';
1267 if (sscanf(device,"mtd%d", &deviceId) == 1) {
1268 sprintf(device, "/dev/block/mtdblock%d", deviceId);
1269 Primary_Block_Device = device;
Dees_Troy76543db2013-06-19 16:24:30 +00001270 fclose(fp);
1271 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -04001272 }
1273 }
1274 }
1275 fclose(fp);
1276
1277 return false;
1278}
1279
Dees_Troy51127312012-09-08 13:08:49 -04001280bool TWPartition::Get_Size_Via_statfs(bool Display_Error) {
1281 struct statfs st;
1282 string Local_Path = Mount_Point + "/.";
1283
1284 if (!Mount(Display_Error))
1285 return false;
1286
1287 if (statfs(Local_Path.c_str(), &st) != 0) {
1288 if (!Removable) {
1289 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001290 LOGERR("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001291 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001292 LOGINFO("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001293 }
1294 return false;
1295 }
1296 Size = (st.f_blocks * st.f_bsize);
1297 Used = ((st.f_blocks - st.f_bfree) * st.f_bsize);
1298 Free = (st.f_bfree * st.f_bsize);
1299 Backup_Size = Used;
1300 return true;
1301}
1302
1303bool TWPartition::Get_Size_Via_df(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001304 FILE* fp;
1305 char command[255], line[512];
1306 int include_block = 1;
1307 unsigned int min_len;
1308
1309 if (!Mount(Display_Error))
1310 return false;
1311
Dees_Troy38bd7602012-09-14 13:33:53 -04001312 min_len = Actual_Block_Device.size() + 2;
Dees_Troy51127312012-09-08 13:08:49 -04001313 sprintf(command, "df %s > /tmp/dfoutput.txt", Mount_Point.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001314 TWFunc::Exec_Cmd(command);
Dees_Troy51127312012-09-08 13:08:49 -04001315 fp = fopen("/tmp/dfoutput.txt", "rt");
1316 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001317 LOGINFO("Unable to open /tmp/dfoutput.txt.\n");
Dees_Troy5bf43922012-09-07 16:07:55 -04001318 return false;
Dees_Troy51127312012-09-08 13:08:49 -04001319 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001320
1321 while (fgets(line, sizeof(line), fp) != NULL)
1322 {
1323 unsigned long blocks, used, available;
1324 char device[64];
1325 char tmpString[64];
1326
1327 if (strncmp(line, "Filesystem", 10) == 0)
1328 continue;
1329 if (strlen(line) < min_len) {
1330 include_block = 0;
1331 continue;
1332 }
1333 if (include_block) {
1334 sscanf(line, "%s %lu %lu %lu", device, &blocks, &used, &available);
1335 } else {
1336 // The device block string is so long that the df information is on the next line
1337 int space_count = 0;
Dees_Troye58d5262012-09-21 12:27:57 -04001338 sprintf(tmpString, "/dev/block/%s", Actual_Block_Device.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001339 while (tmpString[space_count] == 32)
1340 space_count++;
1341 sscanf(line + space_count, "%lu %lu %lu", &blocks, &used, &available);
1342 }
1343
1344 // Adjust block size to byte size
1345 Size = blocks * 1024ULL;
1346 Used = used * 1024ULL;
1347 Free = available * 1024ULL;
1348 Backup_Size = Used;
1349 }
1350 fclose(fp);
1351 return true;
1352}
1353
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001354unsigned long long TWPartition::IOCTL_Get_Block_Size() {
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001355 Find_Actual_Block_Device();
Ethan Yonker483e9f42016-01-11 22:21:18 -06001356
1357 return TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001358}
1359
Dees_Troy5bf43922012-09-07 16:07:55 -04001360bool TWPartition::Find_Partition_Size(void) {
1361 FILE* fp;
1362 char line[512];
1363 string tmpdevice;
1364
igoriok87e3d932013-01-31 21:03:53 +02001365 fp = fopen("/proc/dumchar_info", "rt");
1366 if (fp != NULL) {
1367 while (fgets(line, sizeof(line), fp) != NULL)
1368 {
1369 char label[32], device[32];
1370 unsigned long size = 0;
1371
thatd43bf2d2014-09-21 23:13:02 +02001372 sscanf(line, "%s %lx %*x %*u %s", label, &size, device);
igoriok87e3d932013-01-31 21:03:53 +02001373
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05001374 // Skip header, annotation and blank lines
igoriok87e3d932013-01-31 21:03:53 +02001375 if ((strncmp(device, "/dev/", 5) != 0) || (strlen(line) < 8))
1376 continue;
1377
1378 tmpdevice = "/dev/";
1379 tmpdevice += label;
1380 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
1381 Size = size;
1382 fclose(fp);
1383 return true;
1384 }
1385 }
1386 }
1387
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001388 unsigned long long ioctl_size = IOCTL_Get_Block_Size();
1389 if (ioctl_size) {
1390 Size = ioctl_size;
1391 return true;
1392 }
1393
Dees_Troy5bf43922012-09-07 16:07:55 -04001394 // In this case, we'll first get the partitions we care about (with labels)
1395 fp = fopen("/proc/partitions", "rt");
1396 if (fp == NULL)
1397 return false;
1398
1399 while (fgets(line, sizeof(line), fp) != NULL)
1400 {
1401 unsigned long major, minor, blocks;
1402 char device[512];
Dees_Troy5bf43922012-09-07 16:07:55 -04001403
Dees_Troy63c8df72012-09-10 14:02:05 -04001404 if (strlen(line) < 7 || line[0] == 'm') continue;
Dees_Troy5bf43922012-09-07 16:07:55 -04001405 sscanf(line + 1, "%lu %lu %lu %s", &major, &minor, &blocks, device);
1406
1407 tmpdevice = "/dev/block/";
1408 tmpdevice += device;
Dees_Troy38bd7602012-09-14 13:33:53 -04001409 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001410 // Adjust block size to byte size
1411 Size = blocks * 1024ULL;
1412 fclose(fp);
1413 return true;
1414 }
1415 }
1416 fclose(fp);
1417 return false;
1418}
1419
Dees_Troy5bf43922012-09-07 16:07:55 -04001420bool TWPartition::Is_Mounted(void) {
1421 if (!Can_Be_Mounted)
1422 return false;
1423
1424 struct stat st1, st2;
1425 string test_path;
1426
1427 // Check to see if the mount point directory exists
1428 test_path = Mount_Point + "/.";
1429 if (stat(test_path.c_str(), &st1) != 0) return false;
1430
1431 // Check to see if the directory above the mount point exists
1432 test_path = Mount_Point + "/../.";
1433 if (stat(test_path.c_str(), &st2) != 0) return false;
1434
1435 // Compare the device IDs -- if they match then we're (probably) using tmpfs instead of an actual device
1436 int ret = (st1.st_dev != st2.st_dev) ? true : false;
Dees_Troy5bf43922012-09-07 16:07:55 -04001437 return ret;
1438}
1439
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05001440bool TWPartition::Is_File_System_Writable(void) {
1441 if (!Is_File_System(Current_File_System) || !Is_Mounted())
1442 return false;
1443
1444 string test_path = Mount_Point + "/.";
1445 return (access(test_path.c_str(), W_OK) == 0);
1446}
1447
Dees_Troy5bf43922012-09-07 16:07:55 -04001448bool TWPartition::Mount(bool Display_Error) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001449 int exfat_mounted = 0;
Martin Dünkelmann6d843782018-12-27 23:40:28 +01001450 unsigned int flags = Mount_Flags;
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001451
Dees_Troy5bf43922012-09-07 16:07:55 -04001452 if (Is_Mounted()) {
1453 return true;
1454 } else if (!Can_Be_Mounted) {
1455 return false;
1456 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001457
1458 Find_Actual_Block_Device();
1459
1460 // Check the current file system before mounting
1461 Check_FS_Type();
bigbiffad58e1b2020-07-06 20:24:34 -04001462 if (Current_File_System == "exfat" && TWFunc::Path_Exists("/system/bin/exfat-fuse")) {
1463 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 +00001464 LOGINFO("cmd: %s\n", cmd.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001465 string result;
bigbiffad58e1b2020-07-06 20:24:34 -04001466 if (TWFunc::Exec_Cmd(cmd, result, false) != 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001467 LOGINFO("exfat-fuse failed to mount with result '%s', trying vfat\n", result.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001468 Current_File_System = "vfat";
1469 } else {
1470#ifdef TW_NO_EXFAT_FUSE
1471 UnMount(false);
1472 // We'll let the kernel handle it but using exfat-fuse to detect if the file system is actually exfat
1473 // Some kernels let us mount vfat as exfat which doesn't work out too well
1474#else
1475 exfat_mounted = 1;
1476#endif
1477 }
1478 }
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001479
Captain Throwback47bf7202020-10-06 17:39:39 -04001480 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 -05001481 string cmd;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001482 string Ntfsmount_Binary = "";
1483
bigbiffad58e1b2020-07-06 20:24:34 -04001484 if (TWFunc::Path_Exists("/system/bin/ntfs-3g"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001485 Ntfsmount_Binary = "ntfs-3g";
bigbiffad58e1b2020-07-06 20:24:34 -04001486 else if (TWFunc::Path_Exists("/system/bin/mount.ntfs"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001487 Ntfsmount_Binary = "mount.ntfs";
1488
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001489 if (Mount_Read_Only)
bigbiffad58e1b2020-07-06 20:24:34 -04001490 cmd = "/system/bin/" + Ntfsmount_Binary + " -o ro " + Actual_Block_Device + " " + Mount_Point;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001491 else
bigbiffad58e1b2020-07-06 20:24:34 -04001492 cmd = "/system/bin/" + Ntfsmount_Binary + " " + Actual_Block_Device + " " + Mount_Point;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001493 LOGINFO("cmd: '%s'\n", cmd.c_str());
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001494
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001495 if (TWFunc::Exec_Cmd(cmd) == 0) {
1496 return true;
1497 } else {
1498 LOGINFO("ntfs-3g failed to mount, trying regular mount method.\n");
1499 }
Captain Throwback47bf7202020-10-06 17:39:39 -04001500 } else {
1501 if (Current_File_System == "ntfs" && TWFunc::Path_Exists("/sys/module/tntfs"))
1502 Current_File_System = "tntfs";
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001503 }
1504
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001505 if (Mount_Read_Only)
1506 flags |= MS_RDONLY;
1507
Dees_Troy22042032012-12-18 21:23:08 +00001508 if (Fstab_File_System == "yaffs2") {
1509 // mount an MTD partition as a YAFFS2 filesystem.
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001510 flags = MS_NOATIME | MS_NODEV | MS_NODIRATIME;
1511 if (Mount_Read_Only)
1512 flags |= MS_RDONLY;
Dees_Troy76543db2013-06-19 16:24:30 +00001513 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags, NULL) < 0) {
1514 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags | MS_RDONLY, NULL) < 0) {
1515 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001516 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy76543db2013-06-19 16:24:30 +00001517 else
1518 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
1519 return false;
1520 } else {
1521 LOGINFO("Mounted '%s' (MTD) as RO\n", Mount_Point.c_str());
1522 return true;
1523 }
1524 } else {
1525 struct stat st;
1526 string test_path = Mount_Point;
1527 if (stat(test_path.c_str(), &st) < 0) {
1528 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001529 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy76543db2013-06-19 16:24:30 +00001530 else
1531 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
1532 return false;
1533 }
1534 mode_t new_mode = st.st_mode | S_IXUSR | S_IXGRP | S_IXOTH;
1535 if (new_mode != st.st_mode) {
1536 LOGINFO("Fixing execute permissions for %s\n", Mount_Point.c_str());
1537 if (chmod(Mount_Point.c_str(), new_mode) < 0) {
1538 if (Display_Error)
1539 LOGERR("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
1540 else
1541 LOGINFO("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
1542 return false;
1543 }
1544 }
Dees_Troy22042032012-12-18 21:23:08 +00001545 return true;
Dees_Troy76543db2013-06-19 16:24:30 +00001546 }
thatc7572eb2015-03-31 18:55:30 +02001547 }
1548
1549 string mount_fs = Current_File_System;
1550 if (Current_File_System == "exfat" && TWFunc::Path_Exists("/sys/module/texfat"))
1551 mount_fs = "texfat";
1552
1553 if (!exfat_mounted &&
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001554 mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), mount_fs.c_str(), flags, Mount_Options.c_str()) != 0 &&
1555 mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), mount_fs.c_str(), flags, NULL) != 0) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001556#ifdef TW_NO_EXFAT_FUSE
1557 if (Current_File_System == "exfat") {
Dees_Troy2673cec2013-04-02 20:22:16 +00001558 LOGINFO("Mounting exfat failed, trying vfat...\n");
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001559 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), "vfat", 0, NULL) != 0) {
Dees_Troy85f44ed2013-01-09 18:42:36 +00001560 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001561 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy85f44ed2013-01-09 18:42:36 +00001562 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001563 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001564 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 +00001565 return false;
Dees_Troy85f44ed2013-01-09 18:42:36 +00001566 }
Dees_Troyb05ddee2013-01-28 20:24:50 +00001567 } else {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001568#endif
bigbiff bigbiff26774a02014-03-29 18:22:00 -04001569 if (!Removable && Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001570 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001571 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001572 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
1573 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 +00001574 return false;
1575#ifdef TW_NO_EXFAT_FUSE
Dees_Troy85f44ed2013-01-09 18:42:36 +00001576 }
1577#endif
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001578 }
Ethan Yonker253368a2014-11-25 15:00:52 -06001579
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001580 if (Removable)
1581 Update_Size(Display_Error);
1582
xiaolu9416f4f2015-06-04 08:22:23 +08001583 if (!Symlink_Mount_Point.empty() && TWFunc::Path_Exists(Symlink_Path)) {
bigbiffad58e1b2020-07-06 20:24:34 -04001584 string Command = "/system/bin/mount -o bind '" + Symlink_Path + "' '" + Symlink_Mount_Point + "'";
Vojtech Bocek05534202013-09-11 08:11:56 +02001585 TWFunc::Exec_Cmd(Command);
Dees_Troy5bf43922012-09-07 16:07:55 -04001586 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001587 return true;
1588}
1589
1590bool TWPartition::UnMount(bool Display_Error) {
1591 if (Is_Mounted()) {
1592 int never_unmount_system;
1593
1594 DataManager::GetValue(TW_DONT_UNMOUNT_SYSTEM, never_unmount_system);
Captain Throwback9d6feb52018-07-27 10:05:24 -04001595 if (never_unmount_system == 1 && Mount_Point == PartitionManager.Get_Android_Root_Path())
Dees_Troy5bf43922012-09-07 16:07:55 -04001596 return true; // Never unmount system if you're not supposed to unmount it
1597
Matt Mowera8e6d832017-02-14 20:20:59 -06001598 if (Is_Storage && MTP_Storage_ID > 0)
Ethan Yonker726a0202014-12-16 20:01:38 -06001599 PartitionManager.Remove_MTP_Storage(MTP_Storage_ID);
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001600
Dees_Troy38bd7602012-09-14 13:33:53 -04001601 if (!Symlink_Mount_Point.empty())
1602 umount(Symlink_Mount_Point.c_str());
1603
Dees_Troyb05ddee2013-01-28 20:24:50 +00001604 umount(Mount_Point.c_str());
1605 if (Is_Mounted()) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001606 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001607 gui_msg(Msg(msg::kError, "fail_unmount=Failed to unmount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy5bf43922012-09-07 16:07:55 -04001608 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001609 LOGINFO("Unable to unmount '%s'\n", Mount_Point.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001610 return false;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001611 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -04001612 return true;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001613 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001614 } else {
1615 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001616 }
1617}
1618
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05001619bool TWPartition::ReMount(bool Display_Error) {
1620 if (UnMount(Display_Error))
1621 return Mount(Display_Error);
1622 return false;
1623}
1624
1625bool TWPartition::ReMount_RW(bool Display_Error) {
1626 // No need to remount if already mounted rw
1627 if (Is_File_System_Writable())
1628 return true;
1629
1630 bool ro = Mount_Read_Only;
1631 int flags = Mount_Flags;
1632
1633 Mount_Read_Only = false;
1634 Mount_Flags &= ~MS_RDONLY;
1635
1636 bool ret = ReMount(Display_Error);
1637
1638 Mount_Read_Only = ro;
1639 Mount_Flags = flags;
1640
1641 return ret;
1642}
1643
Gary Peck43acadf2012-11-21 21:19:01 -08001644bool TWPartition::Wipe(string New_File_System) {
Ethan Yonker726a0202014-12-16 20:01:38 -06001645 bool wiped = false, update_crypt = false, recreate_media = true;
Dees_Troy16c2b312013-01-15 16:51:18 +00001646 int check;
Dees_Troy16c2b312013-01-15 16:51:18 +00001647
Dees_Troy38bd7602012-09-14 13:33:53 -04001648 if (!Can_Be_Wiped) {
Matt Mower3c366972015-12-25 19:28:31 -06001649 gui_msg(Msg(msg::kError, "cannot_wipe=Partition {1} cannot be wiped.")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04001650 return false;
1651 }
1652
Dees_Troyc51f1f92012-09-20 15:32:13 -04001653 if (Mount_Point == "/cache")
Dees_Troy2673cec2013-04-02 20:22:16 +00001654 Log_Offset = 0;
Dees_Troyc51f1f92012-09-20 15:32:13 -04001655
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001656 if (Has_Data_Media && Current_File_System == New_File_System) {
Dees_Troy16c2b312013-01-15 16:51:18 +00001657 wiped = Wipe_Data_Without_Wiping_Media();
bigbiff25d25b92020-06-19 16:07:38 -04001658 if (Mount_Point == "/data" && TWFunc::get_log_dir() == DATA_LOGS_DIR) {
1659 bool created = PartitionManager.Recreate_Logs_Dir();
1660 if (!created)
1661 LOGERR("Unable to create log directory for TWRP\n");
bigbiff7ba75002020-04-11 20:47:09 -04001662 }
Ethan Yonker5eac2222014-06-11 12:22:55 -05001663 recreate_media = false;
Dees_Troy16c2b312013-01-15 16:51:18 +00001664 } else {
Dees_Troy16c2b312013-01-15 16:51:18 +00001665 DataManager::GetValue(TW_RM_RF_VAR, check);
1666
Hashcodedabfd492013-08-29 22:45:30 -07001667 if (check || Use_Rm_Rf)
Dees_Troy16c2b312013-01-15 16:51:18 +00001668 wiped = Wipe_RMRF();
1669 else if (New_File_System == "ext4")
1670 wiped = Wipe_EXT4();
1671 else if (New_File_System == "ext2" || New_File_System == "ext3")
dianlujitao4879b372018-12-03 18:45:47 +08001672 wiped = Wipe_EXTFS(New_File_System);
Dees_Troy16c2b312013-01-15 16:51:18 +00001673 else if (New_File_System == "exfat")
1674 wiped = Wipe_EXFAT();
Captain Throwback47bf7202020-10-06 17:39:39 -04001675 else if (New_File_System == "ntfs" || Current_File_System == "tntfs")
1676 wiped = Wipe_NTFS();
Dees_Troy16c2b312013-01-15 16:51:18 +00001677 else if (New_File_System == "yaffs2")
1678 wiped = Wipe_MTD();
Dees_Troye5017042013-08-29 16:38:55 +00001679 else if (New_File_System == "f2fs")
1680 wiped = Wipe_F2FS();
Captain Throwback47bf7202020-10-06 17:39:39 -04001681 else if (New_File_System == "vfat")
1682 wiped = Wipe_FAT();
Dees_Troy16c2b312013-01-15 16:51:18 +00001683 else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001684 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 +00001685 return false;
1686 }
1687 update_crypt = wiped;
bigbiff7ba75002020-04-11 20:47:09 -04001688 update_crypt = false;
Gary Pecke8bc5d72012-12-21 06:45:25 -08001689 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001690
Gary Pecke8bc5d72012-12-21 06:45:25 -08001691 if (wiped) {
Mohd Faraze1d72622020-06-15 00:28:32 +05301692 if (Mount_Point == "/cache" && TWFunc::get_log_dir() != DATA_LOGS_DIR)
1693 DataManager::Output_Version();
1694
Dees_Troy16c2b312013-01-15 16:51:18 +00001695 if (update_crypt) {
1696 Setup_File_System(false);
1697 if (Is_Encrypted && !Is_Decrypted) {
1698 // just wiped an encrypted partition back to its unencrypted state
1699 Is_Encrypted = false;
1700 Is_Decrypted = false;
1701 Decrypted_Block_Device = "";
1702 if (Mount_Point == "/data") {
1703 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
1704 DataManager::SetValue(TW_IS_DECRYPTED, 0);
1705 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08001706 }
1707 }
Ethan Yonker5eac2222014-06-11 12:22:55 -05001708
bigbiff7ba75002020-04-11 20:47:09 -04001709 // if (Is_Storage && Mount(false))
1710 // PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
Gary Pecke8bc5d72012-12-21 06:45:25 -08001711 }
Matt Mower209c9632016-01-20 12:08:35 -06001712
Gary Pecke8bc5d72012-12-21 06:45:25 -08001713 return wiped;
Dees_Troy51a0e822012-09-05 15:24:24 -04001714}
1715
Gary Peck43acadf2012-11-21 21:19:01 -08001716bool TWPartition::Wipe() {
Gary Peck82599a82012-11-21 16:23:12 -08001717 if (Is_File_System(Current_File_System))
1718 return Wipe(Current_File_System);
1719 else
1720 return Wipe(Fstab_File_System);
Gary Peck43acadf2012-11-21 21:19:01 -08001721}
1722
Dees_Troye58d5262012-09-21 12:27:57 -04001723bool TWPartition::Wipe_AndSec(void) {
1724 if (!Has_Android_Secure)
1725 return false;
1726
Dees_Troye58d5262012-09-21 12:27:57 -04001727 if (!Mount(true))
1728 return false;
1729
Ethan Yonker74db1572015-10-28 12:44:49 -05001730 gui_msg(Msg("wiping=Wiping {1}")(Backup_Display_Name));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001731 TWFunc::removeDir(Mount_Point + "/.android_secure/", true);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001732 return true;
Dees_Troye58d5262012-09-21 12:27:57 -04001733}
1734
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001735bool TWPartition::Can_Repair() {
Ethan Yonkera2719152015-05-28 09:44:41 -05001736 if (Mount_Read_Only)
1737 return