blob: 71af84908aa2d4595e8c038c608f4edc10b78f6c [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,
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,
Peter Cai439d60c2019-10-17 08:49:10 +0800163 TWFLAG_ADOPTED_MOUNT_DELAY,
Peter Caid68e6412019-11-02 19:22:38 +0800164 TWFLAG_DM_USE_ORIGINAL_PATH,
bigbiff998f8392021-08-06 19:19:33 -0400165 TWFLAG_LOGICAL,
Matt Mower2416a502016-04-12 19:54:46 -0500166};
167
168/* Flags without a trailing '=' are considered dual format flags and can be
169 * written as either 'flagname' or 'flagname=', where the character following
170 * the '=' is Y,y,1 for true and false otherwise.
171 */
172const struct flag_list tw_flags[] = {
173 { "andsec", TWFLAG_ANDSEC },
174 { "backup", TWFLAG_BACKUP },
175 { "backupname=", TWFLAG_BACKUPNAME },
176 { "blocksize=", TWFLAG_BLOCKSIZE },
177 { "canbewiped", TWFLAG_CANBEWIPED },
178 { "canencryptbackup", TWFLAG_CANENCRYPTBACKUP },
179 { "defaults", TWFLAG_DEFAULTS },
180 { "display=", TWFLAG_DISPLAY },
181 { "encryptable=", TWFLAG_ENCRYPTABLE },
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500182 { "fileencryption=", TWFLAG_FILEENCRYPTION },
Matt Mower2416a502016-04-12 19:54:46 -0500183 { "flashimg", TWFLAG_FLASHIMG },
184 { "forceencrypt=", TWFLAG_FORCEENCRYPT },
185 { "fsflags=", TWFLAG_FSFLAGS },
186 { "ignoreblkid", TWFLAG_IGNOREBLKID },
187 { "length=", TWFLAG_LENGTH },
188 { "mounttodecrypt", TWFLAG_MOUNTTODECRYPT },
189 { "removable", TWFLAG_REMOVABLE },
Matt Mower2416a502016-04-12 19:54:46 -0500190 { "settingsstorage", TWFLAG_SETTINGSSTORAGE },
191 { "storage", TWFLAG_STORAGE },
192 { "storagename=", TWFLAG_STORAGENAME },
193 { "subpartitionof=", TWFLAG_SUBPARTITIONOF },
194 { "symlink=", TWFLAG_SYMLINK },
195 { "userdataencryptbackup", TWFLAG_USERDATAENCRYPTBACKUP },
196 { "usermrf", TWFLAG_USERMRF },
197 { "wipeduringfactoryreset", TWFLAG_WIPEDURINGFACTORYRESET },
198 { "wipeingui", TWFLAG_WIPEINGUI },
Ethan Yonker1b190162016-12-05 15:25:19 -0600199 { "slotselect", TWFLAG_SLOTSELECT },
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600200 { "wait", TWFLAG_WAIT },
201 { "verify", TWFLAG_VERIFY },
202 { "check", TWFLAG_CHECK },
203 { "altdevice", TWFLAG_ALTDEVICE },
204 { "notrim", TWFLAG_NOTRIM },
205 { "voldmanaged=", TWFLAG_VOLDMANAGED },
206 { "formattable", TWFLAG_FORMATTABLE },
207 { "resize", TWFLAG_RESIZE },
Ethan Yonker93382822018-11-01 15:25:31 -0500208 { "keydirectory=", TWFLAG_KEYDIRECTORY },
Peter Cai28ea7b02019-05-24 11:38:54 +0800209 { "wrappedkey", TWFLAG_WRAPPEDKEY },
Peter Cai439d60c2019-10-17 08:49:10 +0800210 { "adopted_mount_delay=", TWFLAG_ADOPTED_MOUNT_DELAY },
Peter Caid68e6412019-11-02 19:22:38 +0800211 { "dm_use_original_path", TWFLAG_DM_USE_ORIGINAL_PATH },
bigbiff998f8392021-08-06 19:19:33 -0400212 { "logical", TWFLAG_LOGICAL },
Matt Mower2416a502016-04-12 19:54:46 -0500213 { 0, 0 },
214};
215
that9e0593e2014-10-08 00:01:24 +0200216TWPartition::TWPartition() {
Dees_Troy51a0e822012-09-05 15:24:24 -0400217 Can_Be_Mounted = false;
218 Can_Be_Wiped = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500219 Can_Be_Backed_Up = false;
Vojtech Bocek1dc30982013-08-30 21:49:30 +0200220 Use_Rm_Rf = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400221 Wipe_During_Factory_Reset = false;
222 Wipe_Available_in_GUI = false;
223 Is_SubPartition = false;
Dees_Troy2691f9d2012-09-24 11:15:49 -0400224 Has_SubPartition = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400225 SubPartition_Of = "";
226 Symlink_Path = "";
227 Symlink_Mount_Point = "";
228 Mount_Point = "";
Dees_Troye58d5262012-09-21 12:27:57 -0400229 Backup_Path = "";
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600230 Wildcard_Block_Device = false;
231 Sysfs_Entry = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400232 Actual_Block_Device = "";
233 Primary_Block_Device = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400234 Alternate_Block_Device = "";
235 Removable = false;
236 Is_Present = false;
237 Length = 0;
238 Size = 0;
239 Used = 0;
240 Free = 0;
241 Backup_Size = 0;
242 Can_Be_Encrypted = false;
243 Is_Encrypted = false;
244 Is_Decrypted = false;
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600245 Is_FBE = false;
Ethan Yonker253368a2014-11-25 15:00:52 -0600246 Mount_To_Decrypt = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400247 Decrypted_Block_Device = "";
248 Display_Name = "";
Dees_Troya13d74f2013-03-24 08:54:55 -0500249 Backup_Display_Name = "";
250 Storage_Name = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400251 Backup_Name = "";
Dees_Troy63c8df72012-09-10 14:02:05 -0400252 Backup_FileName = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400253 MTD_Name = "";
bigbiffce8f83c2015-12-12 18:30:21 -0500254 Backup_Method = BM_NONE;
Dees_Troy83bd4832013-05-04 12:39:56 +0000255 Can_Encrypt_Backup = false;
256 Use_Userdata_Encryption = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400257 Has_Data_Media = false;
Dees_Troye58d5262012-09-21 12:27:57 -0400258 Has_Android_Secure = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400259 Is_Storage = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500260 Is_Settings_Storage = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400261 Storage_Path = "";
262 Current_File_System = "";
263 Fstab_File_System = "";
Hashcode62bd9e02013-11-19 21:59:42 -0800264 Mount_Flags = 0;
265 Mount_Options = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400266 Format_Block_Size = 0;
Dees_Troy68cab492012-12-12 19:29:35 +0000267 Ignore_Blkid = false;
dianlujitao4879b372018-12-03 18:45:47 +0800268 Crypto_Key_Location = "";
Ethan Yonker726a0202014-12-16 20:01:38 -0600269 MTP_Storage_ID = 0;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600270 Can_Flash_Img = false;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500271 Mount_Read_Only = false;
Ethan Yonker66a19492015-12-10 10:19:45 -0600272 Is_Adopted_Storage = false;
273 Adopted_GUID = "";
Ethan Yonker1b190162016-12-05 15:25:19 -0600274 SlotSelect = false;
Ethan Yonker93382822018-11-01 15:25:31 -0500275 Key_Directory = "";
bigbiffee7b7ff2020-03-23 15:08:27 -0400276 Is_Super = false;
Peter Cai439d60c2019-10-17 08:49:10 +0800277 Adopted_Mount_Delay = 0;
Peter Caid68e6412019-11-02 19:22:38 +0800278 Original_Path = "";
279 Use_Original_Path = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400280}
281
282TWPartition::~TWPartition(void) {
283 // Do nothing
284}
285
bigbiff8da46fa2020-09-08 16:42:34 -0400286bool 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 -0500287 char full_line[MAX_FSTAB_LINE_LENGTH];
Matt Mower2416a502016-04-12 19:54:46 -0500288 char twflags[MAX_FSTAB_LINE_LENGTH] = "";
Dees_Troy5bf43922012-09-07 16:07:55 -0400289 char* ptr;
Matt Mower2b2dd152016-04-26 11:24:08 -0500290 int line_len = strlen(fstab_line), index = 0, item_index = 0;
Dees_Troya13d74f2013-03-24 08:54:55 -0500291 bool skip = false;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600292 int fstab_version = 1, mount_point_index = 0, fs_index = 1, block_device_index = 2;
293 TWPartition *additional_entry = NULL;
294 std::map<string, Flags_Map>::iterator it;
Dees_Troy5bf43922012-09-07 16:07:55 -0400295
Matt Mower2b2dd152016-04-26 11:24:08 -0500296 strlcpy(full_line, fstab_line, sizeof(full_line));
bigbiffee7b7ff2020-03-23 15:08:27 -0400297
Dees_Troy51127312012-09-08 13:08:49 -0400298 for (index = 0; index < line_len; index++) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500299 if (full_line[index] == 34)
300 skip = !skip;
301 if (!skip && full_line[index] <= 32)
Dees_Troy5bf43922012-09-07 16:07:55 -0400302 full_line[index] = '\0';
Dees_Troy5bf43922012-09-07 16:07:55 -0400303 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600304 if (line_len < 10)
305 return false; // There can't possibly be a valid fstab line that is less than 10 chars
bigbiff998f8392021-08-06 19:19:33 -0400306 if (fstab_line[0] == '#')
307 return false; // skip comments
308
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600309 if (strncmp(fstab_line, "/dev/", strlen("/dev/")) == 0 || strncmp(fstab_line, "/devices/", strlen("/devices/")) == 0) {
310 fstab_version = 2;
311 block_device_index = 0;
312 mount_point_index = 1;
313 fs_index = 2;
314 }
315
bigbiff998f8392021-08-06 19:19:33 -0400316 if (fstab_line[0] != '/') {
bigbiffee7b7ff2020-03-23 15:08:27 -0400317 block_device_index = 0;
318 fstab_version = 2;
319 mount_point_index = 1;
320 fs_index = 2;
321 }
322
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600323 index = 0;
Dees_Troy5bf43922012-09-07 16:07:55 -0400324 while (index < line_len) {
325 while (index < line_len && full_line[index] == '\0')
326 index++;
327 if (index >= line_len)
328 continue;
329 ptr = full_line + index;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600330 if (item_index == mount_point_index) {
331 Mount_Point = ptr;
bigbiffee7b7ff2020-03-23 15:08:27 -0400332 if (fstab_version == 2 && Is_Super == false) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600333 additional_entry = PartitionManager.Find_Partition_By_Path(Mount_Point);
bigbiff8da46fa2020-09-08 16:42:34 -0400334 if (additional_entry) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600335 LOGINFO("Found an additional entry for '%s'\n", Mount_Point.c_str());
336 }
337 }
bigbiff8da46fa2020-09-08 16:42:34 -0400338 LOGINFO("Processing '%s'\n", Mount_Point.c_str());
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600339 Backup_Path = Mount_Point;
340 Storage_Path = Mount_Point;
341 Display_Name = ptr + 1;
342 Backup_Display_Name = Display_Name;
343 Storage_Name = Display_Name;
344 item_index++;
345 } else if (item_index == fs_index) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400346 // File System
347 Fstab_File_System = ptr;
348 Current_File_System = ptr;
349 item_index++;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600350 } else if (item_index == block_device_index) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400351 // Primary Block Device
Dees_Troy38bd7602012-09-14 13:33:53 -0400352 if (Fstab_File_System == "mtd" || Fstab_File_System == "yaffs2") {
Dees_Troy094207a2012-09-26 12:00:39 -0400353 MTD_Name = ptr;
354 Find_MTD_Block_Device(MTD_Name);
Dees_Troy5fcd8f92012-10-16 12:22:05 -0400355 } else if (Fstab_File_System == "bml") {
356 if (Mount_Point == "/boot")
357 MTD_Name = "boot";
358 else if (Mount_Point == "/recovery")
359 MTD_Name = "recovery";
360 Primary_Block_Device = ptr;
361 if (*ptr != '/')
Dees_Troy2673cec2013-04-02 20:22:16 +0000362 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 -0400363 } else {
364 Primary_Block_Device = ptr;
bigbiff998f8392021-08-06 19:19:33 -0400365 if (*ptr == '/')
366 Find_Real_Block_Device(Primary_Block_Device, Display_Error);
Dees_Troy5bf43922012-09-07 16:07:55 -0400367 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400368 item_index++;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600369 } else if (item_index > 2) {
370 if (fstab_version == 2) {
371 if (item_index == 3) {
372 Process_FS_Flags(ptr);
373 if (additional_entry) {
374 additional_entry->Save_FS_Flags(Fstab_File_System, Mount_Flags, Mount_Options);
375 return false; // We save the extra fs flags in the other partition entry and by returning false, this entry will be deleted
376 }
377 } else {
378 strlcpy(twflags, ptr, sizeof(twflags));
379 }
380 item_index++;
381 } else if (*ptr == '/') { // v2 fstab does not allow alternate block devices
Dees_Troy5bf43922012-09-07 16:07:55 -0400382 // Alternate Block Device
383 Alternate_Block_Device = ptr;
384 Find_Real_Block_Device(Alternate_Block_Device, Display_Error);
385 } else if (strlen(ptr) > 7 && strncmp(ptr, "length=", 7) == 0) {
386 // Partition length
387 ptr += 7;
388 Length = atoi(ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400389 } else if (strlen(ptr) > 6 && strncmp(ptr, "flags=", 6) == 0) {
390 // Custom flags, save for later so that new values aren't overwritten by defaults
391 ptr += 6;
Matt Mower2416a502016-04-12 19:54:46 -0500392 strlcpy(twflags, ptr, sizeof(twflags));
Dees_Troy38bd7602012-09-14 13:33:53 -0400393 } else if (strlen(ptr) == 4 && (strncmp(ptr, "NULL", 4) == 0 || strncmp(ptr, "null", 4) == 0 || strncmp(ptr, "null", 4) == 0)) {
394 // Do nothing
Dees_Troy5bf43922012-09-07 16:07:55 -0400395 } else {
396 // Unhandled data
Matt Mower2b2dd152016-04-26 11:24:08 -0500397 LOGINFO("Unhandled fstab information '%s' in fstab line '%s'\n", ptr, fstab_line);
Dees_Troy5bf43922012-09-07 16:07:55 -0400398 }
399 }
400 while (index < line_len && full_line[index] != '\0')
401 index++;
402 }
403
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600404 // override block devices from the v2 fstab with the ones we read from the twrp.flags file in case they are different
405 if (fstab_version == 2 && twrp_flags && twrp_flags->size() > 0) {
406 it = twrp_flags->find(Mount_Point);
407 if (it != twrp_flags->end()) {
408 if (!it->second.Primary_Block_Device.empty()) {
409 Primary_Block_Device = it->second.Primary_Block_Device;
410 Find_Real_Block_Device(Primary_Block_Device, Display_Error);
411 }
412 if (!it->second.Alternate_Block_Device.empty()) {
413 Alternate_Block_Device = it->second.Alternate_Block_Device;
414 Find_Real_Block_Device(Alternate_Block_Device, Display_Error);
415 }
416 }
417 }
418
419 if (strncmp(fstab_line, "/devices/", strlen("/devices/")) == 0) {
420 Sysfs_Entry = Primary_Block_Device;
421 Primary_Block_Device = "";
422 Is_Storage = true;
423 Removable = true;
424 Wipe_Available_in_GUI = true;
425 Wildcard_Block_Device = true;
426 }
427 if (Primary_Block_Device.find("*") != string::npos)
428 Wildcard_Block_Device = true;
429
bigbiff8da46fa2020-09-08 16:42:34 -0400430 if (Mount_Point == "auto") {
431 Mount_Point = "/auto";
432 char autoi[5];
433 sprintf(autoi, "%i", auto_index);
434 Mount_Point += autoi;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600435 Backup_Path = Mount_Point;
436 Storage_Path = Mount_Point;
dianlujitaob76a73a2020-04-30 20:33:20 +0800437 Backup_Name = Mount_Point.substr(1);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600438 auto_index++;
439 Setup_File_System(Display_Error);
440 Display_Name = "Storage";
441 Backup_Display_Name = Display_Name;
442 Storage_Name = Display_Name;
443 Can_Be_Backed_Up = false;
444 Wipe_Available_in_GUI = true;
445 Is_Storage = true;
446 Removable = true;
447 Wipe_Available_in_GUI = true;
448 } else if (!Is_File_System(Fstab_File_System) && !Is_Image(Fstab_File_System)) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400449 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000450 LOGERR("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400451 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000452 LOGINFO("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Matt Mower72c87ce2016-04-26 14:34:56 -0500453 return false;
Dees_Troy5bf43922012-09-07 16:07:55 -0400454 } else if (Is_File_System(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400455 Find_Actual_Block_Device();
Dees_Troy5bf43922012-09-07 16:07:55 -0400456 Setup_File_System(Display_Error);
dianlujitaob76a73a2020-04-30 20:33:20 +0800457 Backup_Name = Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
Chaosmaster3b682732020-01-25 21:09:28 +0100458 if (Mount_Point == "/" || Mount_Point == "/system" || Mount_Point == "/system_root") {
bigbiff8da46fa2020-09-08 16:42:34 -0400459 Mount_Point = PartitionManager.Get_Android_Root_Path();
460 Backup_Path = Mount_Point;
461 Storage_Path = Mount_Point;
Dees_Troy5bf43922012-09-07 16:07:55 -0400462 Display_Name = "System";
dianlujitaob76a73a2020-04-30 20:33:20 +0800463 Backup_Name = "system";
Dees_Troya13d74f2013-03-24 08:54:55 -0500464 Backup_Display_Name = Display_Name;
465 Storage_Name = Display_Name;
bigbiff8da46fa2020-09-08 16:42:34 -0400466 Wipe_Available_in_GUI = false;
467 Can_Be_Backed_Up = false;
468 Can_Be_Wiped = false;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500469 Mount_Read_Only = true;
bigbiff8da46fa2020-09-08 16:42:34 -0400470 Make_Dir(PartitionManager.Get_Android_Root_Path(), true);
Mohd Faraze3948ec2020-08-14 01:40:59 +0000471 } else if (Mount_Point == "/product") {
472 Display_Name = "Product";
473 Backup_Name = "Product";
474 Backup_Display_Name = Display_Name;
475 Storage_Name = Display_Name;
476 Can_Be_Backed_Up = Wipe_Available_in_GUI = Is_Super ? false : true;
477 Mount_Read_Only = true;
478 } else if (Mount_Point == "/odm") {
479 Display_Name = "ODM";
480 Backup_Name = "ODM";
481 Backup_Display_Name = Display_Name;
482 Storage_Name = Display_Name;
483 Can_Be_Backed_Up = Wipe_Available_in_GUI = Is_Super ? false : true;
484 Mount_Read_Only = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400485 } else if (Mount_Point == "/data") {
486 Display_Name = "Data";
Dees_Troya13d74f2013-03-24 08:54:55 -0500487 Backup_Display_Name = Display_Name;
488 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400489 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400490 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500491 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000492 Can_Encrypt_Backup = true;
493 Use_Userdata_Encryption = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400494 } else if (Mount_Point == "/cache") {
495 Display_Name = "Cache";
Dees_Troya13d74f2013-03-24 08:54:55 -0500496 Backup_Display_Name = Display_Name;
497 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400498 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400499 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500500 Can_Be_Backed_Up = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400501 } else if (Mount_Point == "/datadata") {
Dees_Troy51127312012-09-08 13:08:49 -0400502 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400503 Display_Name = "DataData";
Dees_Troya13d74f2013-03-24 08:54:55 -0500504 Backup_Display_Name = Display_Name;
505 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400506 Is_SubPartition = true;
507 SubPartition_Of = "/data";
Dees_Troy5bf43922012-09-07 16:07:55 -0400508 DataManager::SetValue(TW_HAS_DATADATA, 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500509 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000510 Can_Encrypt_Backup = true;
511 Use_Userdata_Encryption = false; // This whole partition should be encrypted
Dees_Troy5bf43922012-09-07 16:07:55 -0400512 } else if (Mount_Point == "/sd-ext") {
Dees_Troy51127312012-09-08 13:08:49 -0400513 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400514 Display_Name = "SD-Ext";
Dees_Troya13d74f2013-03-24 08:54:55 -0500515 Backup_Display_Name = Display_Name;
516 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400517 Wipe_Available_in_GUI = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400518 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500519 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000520 Can_Encrypt_Backup = true;
521 Use_Userdata_Encryption = true;
Dees_Troy2c50e182012-09-26 20:05:28 -0400522 } else if (Mount_Point == "/boot") {
523 Display_Name = "Boot";
Dees_Troya13d74f2013-03-24 08:54:55 -0500524 Backup_Display_Name = Display_Name;
Dees_Troy2c50e182012-09-26 20:05:28 -0400525 DataManager::SetValue("tw_boot_is_mountable", 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500526 Can_Be_Backed_Up = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500527 } else if (Mount_Point == "/vendor") {
528 Display_Name = "Vendor";
529 Backup_Display_Name = Display_Name;
530 Storage_Name = Display_Name;
531 Mount_Read_Only = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400532 }
533#ifdef TW_EXTERNAL_STORAGE_PATH
534 if (Mount_Point == EXPAND(TW_EXTERNAL_STORAGE_PATH)) {
535 Is_Storage = true;
536 Storage_Path = EXPAND(TW_EXTERNAL_STORAGE_PATH);
Dees_Troyc51f1f92012-09-20 15:32:13 -0400537 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500538 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400539#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000540 if (Mount_Point == "/sdcard" || Mount_Point == "/external_sd" || Mount_Point == "/external_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400541 Is_Storage = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400542 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500543 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400544#endif
Dees_Troyb05ddee2013-01-28 20:24:50 +0000545 }
Dees_Troy8170a922012-09-18 15:40:25 -0400546#ifdef TW_INTERNAL_STORAGE_PATH
547 if (Mount_Point == EXPAND(TW_INTERNAL_STORAGE_PATH)) {
548 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500549 Is_Settings_Storage = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400550 Storage_Path = EXPAND(TW_INTERNAL_STORAGE_PATH);
Dees_Troya13d74f2013-03-24 08:54:55 -0500551 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400552 }
553#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000554 if (Mount_Point == "/emmc" || Mount_Point == "/internal_sd" || Mount_Point == "/internal_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400555 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500556 Is_Settings_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500557 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400558 }
559#endif
Dees_Troy5bf43922012-09-07 16:07:55 -0400560 } else if (Is_Image(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400561 Find_Actual_Block_Device();
Ethan Yonker1b190162016-12-05 15:25:19 -0600562 Setup_Image();
Dees_Troya13d74f2013-03-24 08:54:55 -0500563 if (Mount_Point == "/boot") {
564 Display_Name = "Boot";
565 Backup_Display_Name = Display_Name;
566 Can_Be_Backed_Up = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600567 Can_Flash_Img = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500568 } else if (Mount_Point == "/recovery") {
569 Display_Name = "Recovery";
570 Backup_Display_Name = Display_Name;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600571 Can_Flash_Img = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500572 } else if (Mount_Point == "/system_image") {
573 Display_Name = "System Image";
574 Backup_Display_Name = Display_Name;
HashBanged974bb2016-01-30 14:20:09 -0500575 Can_Flash_Img = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500576 Can_Be_Backed_Up = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500577 } else if (Mount_Point == "/vendor_image") {
578 Display_Name = "Vendor Image";
579 Backup_Display_Name = Display_Name;
HashBanged974bb2016-01-30 14:20:09 -0500580 Can_Flash_Img = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500581 Can_Be_Backed_Up = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500582 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400583 }
584
Matt Mower2416a502016-04-12 19:54:46 -0500585 // Process TWRP fstab flags
586 if (strlen(twflags) > 0) {
587 string Prev_Display_Name = Display_Name;
588 string Prev_Storage_Name = Storage_Name;
589 string Prev_Backup_Display_Name = Backup_Display_Name;
590 Display_Name = "";
591 Storage_Name = "";
592 Backup_Display_Name = "";
593
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600594 Process_TW_Flags(twflags, (fstab_version == 1), fstab_version);
595 Save_FS_Flags(Fstab_File_System, Mount_Flags, Mount_Options);
Matt Mower2416a502016-04-12 19:54:46 -0500596
597 bool has_display_name = !Display_Name.empty();
598 bool has_storage_name = !Storage_Name.empty();
599 bool has_backup_name = !Backup_Display_Name.empty();
600 if (!has_display_name) Display_Name = Prev_Display_Name;
601 if (!has_storage_name) Storage_Name = Prev_Storage_Name;
602 if (!has_backup_name) Backup_Display_Name = Prev_Backup_Display_Name;
603
604 if (has_display_name && !has_storage_name)
605 Storage_Name = Display_Name;
606 if (!has_display_name && has_storage_name)
607 Display_Name = Storage_Name;
608 if (has_display_name && !has_backup_name && Backup_Display_Name != "Android Secure")
609 Backup_Display_Name = Display_Name;
610 if (!has_display_name && has_backup_name)
611 Display_Name = Backup_Display_Name;
612 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600613
614 if (fstab_version == 2 && twrp_flags && twrp_flags->size() > 0) {
615 it = twrp_flags->find(Mount_Point);
616 if (it != twrp_flags->end()) {
617 char twrpflags[MAX_FSTAB_LINE_LENGTH] = "";
618 int skip = 0;
619 string Flags = it->second.Flags;
620 strcpy(twrpflags, Flags.c_str());
621 if (strlen(twrpflags) > strlen("flags=") && strncmp(twrpflags, "flags=", strlen("flags=")) == 0)
622 skip += strlen("flags=");
623 char* flagptr = twrpflags;
624 flagptr += skip;
625 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
626 }
627 }
nkk7198fc3992017-12-16 16:26:42 +0200628
629 if (Mount_Point == "/persist" && Can_Be_Mounted) {
630 bool mounted = Is_Mounted();
631 if (mounted || Mount(false)) {
nkk7198fc3992017-12-16 16:26:42 +0200632 TWFunc::Fixup_Time_On_Boot("/persist/time/");
633 if (!mounted)
634 UnMount(false);
635 }
636 }
637
Dees_Troy51127312012-09-08 13:08:49 -0400638 return true;
639}
640
Matt Mower72c87ce2016-04-26 14:34:56 -0500641void TWPartition::Partition_Post_Processing(bool Display_Error) {
642 if (Mount_Point == "/data")
643 Setup_Data_Partition(Display_Error);
644 else if (Mount_Point == "/cache")
645 Setup_Cache_Partition(Display_Error);
646}
647
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600648void TWPartition::ExcludeAll(const string& path) {
649 backup_exclusions.add_absolute_dir(path);
650 wipe_exclusions.add_absolute_dir(path);
651}
652
Matt Mower72c87ce2016-04-26 14:34:56 -0500653void TWPartition::Setup_Data_Partition(bool Display_Error) {
654 if (Mount_Point != "/data")
655 return;
656
657 // Ensure /data is not mounted as tmpfs for qcom hardware decrypt
658 UnMount(false);
659
660#ifdef TW_INCLUDE_CRYPTO
661 if (datamedia)
662 Setup_Data_Media();
663 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);
bigbiff7ba75002020-04-11 20:47:09 -0400670 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
Matt Mower72c87ce2016-04-26 14:34:56 -0500671 } else if (!Mount(false)) {
672 if (Is_Present) {
Ethan Yonker93382822018-11-01 15:25:31 -0500673 if (Key_Directory.empty()) {
Peter Caid68e6412019-11-02 19:22:38 +0800674 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 -0400675 Fstab_File_System.c_str());
Ethan Yonker93382822018-11-01 15:25:31 -0500676 if (cryptfs_check_footer() == 0) {
677 Is_Encrypted = true;
678 Is_Decrypted = false;
679 Can_Be_Mounted = false;
680 Current_File_System = "emmc";
681 Setup_Image();
Ethan Yonker93382822018-11-01 15:25:31 -0500682 DataManager::SetValue(TW_CRYPTO_PWTYPE, cryptfs_get_password_type());
Noah Jacobson81d638d2019-04-28 00:10:07 -0400683 DataManager::SetValue("tw_crypto_pwtype_0", cryptfs_get_password_type());
Ethan Yonker93382822018-11-01 15:25:31 -0500684 DataManager::SetValue(TW_CRYPTO_PASSWORD, "");
685 DataManager::SetValue("tw_crypto_display", "");
686 } else {
687 gui_err("mount_data_footer=Could not mount /data and unable to find crypto footer.");
688 }
689 } else {
Matt Mower72c87ce2016-04-26 14:34:56 -0500690 Is_Encrypted = true;
691 Is_Decrypted = false;
Matt Mower72c87ce2016-04-26 14:34:56 -0500692 }
Ethan Yonker93382822018-11-01 15:25:31 -0500693 } else if (Key_Directory.empty()) {
Noah Jacobson81d638d2019-04-28 00:10:07 -0400694 LOGERR("Primary block device '%s' for mount point '%s' is not present!\n",
695 Primary_Block_Device.c_str(), Mount_Point.c_str());
Matt Mower72c87ce2016-04-26 14:34:56 -0500696 }
697 } else {
bigbiff7ba75002020-04-11 20:47:09 -0400698 Set_FBE_Status();
Captain Throwbackacc7f0f2020-12-29 15:54:33 -0500699 int is_device_fbe;
700 DataManager::GetValue(TW_IS_FBE, is_device_fbe);
Captain Throwback8a8e56c2021-10-01 15:12:24 -0400701 char crypto_state[255];
702 property_get("ro.crypto.state", crypto_state, "error");
703 if (!Decrypt_FBE_DE() && strcmp(crypto_state, "error") != 0) {
704 if (is_device_fbe == 1)
705 LOGERR("Unable to decrypt FBE device\n");
706 } else {
707 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
mauronofrio9bf73352019-11-23 22:27:34 +0100708 }
Matt Mower72c87ce2016-04-26 14:34:56 -0500709 }
710 if (datamedia && (!Is_Encrypted || (Is_Encrypted && Is_Decrypted))) {
711 Setup_Data_Media();
bigbiff25d25b92020-06-19 16:07:38 -0400712 Recreate_Media_Folder();
Matt Mower72c87ce2016-04-26 14:34:56 -0500713 }
714#else
715 if (datamedia) {
716 Setup_Data_Media();
717 Recreate_Media_Folder();
718 }
719#endif
720}
721
bigbiff7ba75002020-04-11 20:47:09 -0400722void TWPartition::Set_FBE_Status() {
723 DataManager::SetValue(TW_IS_DECRYPTED, 1);
724 Is_Encrypted = true;
725 Is_Decrypted = true;
bigbiff7ba75002020-04-11 20:47:09 -0400726 if (Key_Directory.empty()) {
727 Is_FBE = false;
728 DataManager::SetValue(TW_IS_FBE, 0);
729 } else {
Captain Throwbackb5af4f82020-12-29 16:01:10 -0500730 LOGINFO("Setup_Data_Partition::Key_Directory::%s\n", Key_Directory.c_str());
bigbiff7ba75002020-04-11 20:47:09 -0400731 Is_FBE = true;
732 DataManager::SetValue(TW_IS_FBE, 1);
733 }
734}
735
Ethan Yonker93382822018-11-01 15:25:31 -0500736bool TWPartition::Decrypt_FBE_DE() {
bigbiff7ba75002020-04-11 20:47:09 -0400737 if (TWFunc::Path_Exists("/data/unencrypted/key/version")) {
Captain Throwback87d73d62020-02-17 16:44:50 -0500738 DataManager::SetValue(TW_IS_FBE, 1);
Mohd Faraz815e2402020-09-19 19:31:52 +0530739 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
Captain Throwback37c3aef2021-10-06 11:38:18 -0400740 PartitionManager.Set_Crypto_State();
741 PartitionManager.Set_Crypto_Type("file");
Ethan Yonker93382822018-11-01 15:25:31 -0500742 LOGINFO("File Based Encryption is present\n");
743#ifdef TW_INCLUDE_FBE
Noah Jacobson81d638d2019-04-28 00:10:07 -0400744 Is_FBE = true;
745 ExcludeAll(Mount_Point + "/convert_fbe");
746 ExcludeAll(Mount_Point + "/unencrypted");
747 ExcludeAll(Mount_Point + "/misc/vold/user_keys");
748 ExcludeAll(Mount_Point + "/misc/vold/volume_keys");
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-wal");
753 ExcludeAll(Mount_Point + "/misc/gatekeeper");
754 ExcludeAll(Mount_Point + "/misc/keystore");
755 ExcludeAll(Mount_Point + "/drm/kek.dat");
bigbiffa957f072021-03-07 18:20:29 -0500756 ExcludeAll(Mount_Point + "/system_de/0/spblob"); // contains data needed to decrypt synthetic password
micky3872ec1df42021-10-14 14:53:06 +0200757 ExcludeAll(Mount_Point + "/system/users/0/gatekeeper.password.key");
758 ExcludeAll(Mount_Point + "/system/users/0/gatekeeper.pattern.key");
Noah Jacobson81d638d2019-04-28 00:10:07 -0400759 ExcludeAll(Mount_Point + "/cache");
760 ExcludeAll(Mount_Point + "/per_boot"); // removed each boot by init
bigbiffa15d02f2021-06-29 20:04:54 -0400761 ExcludeAll(Mount_Point + "/gsi"); // cow devices
762
Noah Jacobson81d638d2019-04-28 00:10:07 -0400763 int retry_count = 3;
764 while (!Decrypt_DE() && --retry_count)
765 usleep(2000);
766 if (retry_count > 0) {
Captain Throwback37c3aef2021-10-06 11:38:18 -0400767 PartitionManager.Set_Crypto_State();
Noah Jacobson81d638d2019-04-28 00:10:07 -0400768 Is_Encrypted = true;
769 Is_Decrypted = false;
770 DataManager::SetValue(TW_IS_ENCRYPTED, 1);
771 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
Ethan Yonker93382822018-11-01 15:25:31 -0500776 }
Noah Jacobson81d638d2019-04-28 00:10:07 -0400777 PartitionManager.Parse_Users(); // after load_all_de_keys() to parse_users
778 std::vector<users_struct>::iterator iter;
779 std::vector<users_struct>* userList = PartitionManager.Get_Users_List();
780 for (iter = userList->begin(); iter != userList->end(); iter++) {
781 if (atoi((*iter).userId.c_str()) != 0) {
782 ExcludeAll(Mount_Point + "/system_de/" + (*iter).userId + "/spblob");
783 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/gatekeeper.password.key");
784 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/gatekeeper.pattern.key");
785 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/locksettings.db");
786 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/locksettings.db-wal");
787 }
788 }
789 DataManager::SetValue(TW_CRYPTO_PWTYPE, pwd_type);
790 DataManager::SetValue("tw_crypto_pwtype_0", pwd_type);
791 DataManager::SetValue(TW_CRYPTO_PASSWORD, "");
792 DataManager::SetValue("tw_crypto_display", "");
793 return true;
794 }
Ethan Yonker93382822018-11-01 15:25:31 -0500795#else
796 LOGERR("FBE found but FBE support not present in TWRP\n");
797#endif
798 }
Captain Throwback87d73d62020-02-17 16:44:50 -0500799 DataManager::SetValue(TW_IS_FBE, 0);
Ethan Yonker93382822018-11-01 15:25:31 -0500800 return false;
801}
802
Matt Mower72c87ce2016-04-26 14:34:56 -0500803void TWPartition::Setup_Cache_Partition(bool Display_Error __unused) {
804 if (Mount_Point != "/cache")
805 return;
806
807 if (!Mount(true))
808 return;
809
810 if (!TWFunc::Path_Exists("/cache/recovery/.")) {
811 LOGINFO("Recreating /cache/recovery folder\n");
812 if (mkdir("/cache/recovery", S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP) != 0)
813 LOGERR("Could not create /cache/recovery\n");
814 }
815}
816
Matt Mower4ab42b12016-04-21 13:52:18 -0500817void TWPartition::Process_FS_Flags(const char *str) {
818 char *options = strdup(str);
819 char *ptr, *savep;
Hashcode62bd9e02013-11-19 21:59:42 -0800820
Matt Mower4ab42b12016-04-21 13:52:18 -0500821 Mount_Options = "";
Hashcode62bd9e02013-11-19 21:59:42 -0800822
Matt Mower4ab42b12016-04-21 13:52:18 -0500823 // Avoid issues with potentially nested strtok by using strtok_r
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600824 for (ptr = strtok_r(options, ",", &savep); ptr; ptr = strtok_r(NULL, ",", &savep)) {
825 char *equals = strstr(ptr, "=");
826 size_t name_len;
Matt Mower4ab42b12016-04-21 13:52:18 -0500827
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600828 if (!equals)
829 name_len = strlen(ptr);
830 else
831 name_len = equals - ptr;
832
833 // There are some flags that we want to ignore in TWRP
834 bool found_match = false;
835 for (const char** ignored_mount_item = ignored_mount_items; *ignored_mount_item; ignored_mount_item++) {
836 if (strncmp(ptr, *ignored_mount_item, name_len) == 0) {
837 found_match = true;
Hashcode62bd9e02013-11-19 21:59:42 -0800838 break;
839 }
840 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600841 if (found_match)
842 continue;
Hashcode62bd9e02013-11-19 21:59:42 -0800843
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600844 // mount_flags are never postfixed by '='
845 if (!equals) {
846 const struct flag_list* mount_flag = mount_flags;
847 for (; mount_flag->name; mount_flag++) {
848 if (strcmp(ptr, mount_flag->name) == 0) {
849 if (mount_flag->flag == MS_RDONLY)
850 Mount_Read_Only = true;
851 else
852 Mount_Flags |= (unsigned)mount_flag->flag;
853 found_match = true;
854 break;
855 }
856 }
857 if (found_match)
858 continue;
Matt Mower4ab42b12016-04-21 13:52:18 -0500859 }
860
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600861 // If we aren't ignoring this flag and it's not a mount flag, then it must be a mount option
862 if (!Mount_Options.empty())
863 Mount_Options += ",";
864 Mount_Options += ptr;
Matt Mower4ab42b12016-04-21 13:52:18 -0500865 }
866 free(options);
Hashcode62bd9e02013-11-19 21:59:42 -0800867}
868
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600869void TWPartition::Save_FS_Flags(const string& local_File_System, int local_Mount_Flags, const string& local_Mount_Options) {
870 partition_fs_flags_struct flags;
871 flags.File_System = local_File_System;
872 flags.Mount_Flags = local_Mount_Flags;
873 flags.Mount_Options = local_Mount_Options;
874 fs_flags.push_back(flags);
875}
876
Matt Mower2416a502016-04-12 19:54:46 -0500877void TWPartition::Apply_TW_Flag(const unsigned flag, const char* str, const bool val) {
878 switch (flag) {
879 case TWFLAG_ANDSEC:
880 Has_Android_Secure = val;
881 break;
882 case TWFLAG_BACKUP:
883 Can_Be_Backed_Up = val;
884 break;
885 case TWFLAG_BACKUPNAME:
886 Backup_Display_Name = str;
887 break;
888 case TWFLAG_BLOCKSIZE:
889 Format_Block_Size = (unsigned long)(atol(str));
890 break;
891 case TWFLAG_CANBEWIPED:
892 Can_Be_Wiped = val;
893 break;
894 case TWFLAG_CANENCRYPTBACKUP:
895 Can_Encrypt_Backup = val;
896 break;
897 case TWFLAG_DEFAULTS:
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600898 case TWFLAG_WAIT:
899 case TWFLAG_VERIFY:
900 case TWFLAG_CHECK:
901 case TWFLAG_NOTRIM:
902 case TWFLAG_VOLDMANAGED:
903 case TWFLAG_RESIZE:
Matt Mower2416a502016-04-12 19:54:46 -0500904 // Do nothing
905 break;
906 case TWFLAG_DISPLAY:
907 Display_Name = str;
908 break;
909 case TWFLAG_ENCRYPTABLE:
910 case TWFLAG_FORCEENCRYPT:
911 Crypto_Key_Location = str;
912 break;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500913 case TWFLAG_FILEENCRYPTION:
914 // This flag isn't used by TWRP but is needed in 9.0 FBE decrypt
915 // fileencryption=ice:aes-256-heh
916 {
917 std::string FBE = str;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500918 size_t colon_loc = FBE.find(":");
919 if (colon_loc == std::string::npos) {
Ethan Yonker93382822018-11-01 15:25:31 -0500920 property_set("fbe.contents", FBE.c_str());
921 property_set("fbe.filenames", "");
922 LOGINFO("FBE contents '%s', filenames ''\n", FBE.c_str());
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500923 break;
924 }
Ethan Yonker93382822018-11-01 15:25:31 -0500925 std::string FBE_contents, FBE_filenames;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500926 FBE_contents = FBE.substr(0, colon_loc);
927 FBE_filenames = FBE.substr(colon_loc + 1);
928 property_set("fbe.contents", FBE_contents.c_str());
929 property_set("fbe.filenames", FBE_filenames.c_str());
930 LOGINFO("FBE contents '%s', filenames '%s'\n", FBE_contents.c_str(), FBE_filenames.c_str());
931 }
932 break;
Peter Cai28ea7b02019-05-24 11:38:54 +0800933 case TWFLAG_WRAPPEDKEY:
bigbiff437d86f2021-09-26 16:57:14 -0400934 // no more processing needed. leaving it here in case we want to do something in the future
Peter Cai28ea7b02019-05-24 11:38:54 +0800935 break;
Matt Mower2416a502016-04-12 19:54:46 -0500936 case TWFLAG_FLASHIMG:
937 Can_Flash_Img = val;
938 break;
939 case TWFLAG_FSFLAGS:
Matt Mower4ab42b12016-04-21 13:52:18 -0500940 Process_FS_Flags(str);
Matt Mower2416a502016-04-12 19:54:46 -0500941 break;
942 case TWFLAG_IGNOREBLKID:
943 Ignore_Blkid = val;
944 break;
945 case TWFLAG_LENGTH:
946 Length = atoi(str);
947 break;
948 case TWFLAG_MOUNTTODECRYPT:
949 Mount_To_Decrypt = val;
950 break;
951 case TWFLAG_REMOVABLE:
952 Removable = val;
953 break;
Matt Mower2416a502016-04-12 19:54:46 -0500954 case TWFLAG_SETTINGSSTORAGE:
955 Is_Settings_Storage = val;
956 if (Is_Settings_Storage)
957 Is_Storage = true;
958 break;
959 case TWFLAG_STORAGE:
960 Is_Storage = val;
961 break;
962 case TWFLAG_STORAGENAME:
963 Storage_Name = str;
964 break;
965 case TWFLAG_SUBPARTITIONOF:
966 Is_SubPartition = true;
967 SubPartition_Of = str;
968 break;
969 case TWFLAG_SYMLINK:
970 Symlink_Path = str;
971 break;
972 case TWFLAG_USERDATAENCRYPTBACKUP:
973 Use_Userdata_Encryption = val;
974 if (Use_Userdata_Encryption)
975 Can_Encrypt_Backup = true;
976 break;
977 case TWFLAG_USERMRF:
978 Use_Rm_Rf = val;
979 break;
980 case TWFLAG_WIPEDURINGFACTORYRESET:
981 Wipe_During_Factory_Reset = val;
982 if (Wipe_During_Factory_Reset) {
983 Can_Be_Wiped = true;
984 Wipe_Available_in_GUI = true;
985 }
986 break;
987 case TWFLAG_WIPEINGUI:
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600988 case TWFLAG_FORMATTABLE:
Matt Mower2416a502016-04-12 19:54:46 -0500989 Wipe_Available_in_GUI = val;
990 if (Wipe_Available_in_GUI)
991 Can_Be_Wiped = true;
992 break;
Ethan Yonker1b190162016-12-05 15:25:19 -0600993 case TWFLAG_SLOTSELECT:
994 SlotSelect = true;
995 break;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600996 case TWFLAG_ALTDEVICE:
997 Alternate_Block_Device = str;
998 break;
Peter Cai439d60c2019-10-17 08:49:10 +0800999 case TWFLAG_ADOPTED_MOUNT_DELAY:
1000 Adopted_Mount_Delay = atoi(str);
1001 break;
Ethan Yonker93382822018-11-01 15:25:31 -05001002 case TWFLAG_KEYDIRECTORY:
1003 Key_Directory = str;
bigbiffa957f072021-03-07 18:20:29 -05001004 LOGINFO("setting Key_Directory to: %s\n", Key_Directory.c_str());
bigbiffd58ba182020-03-23 10:02:29 -04001005 break;
Peter Caid68e6412019-11-02 19:22:38 +08001006 case TWFLAG_DM_USE_ORIGINAL_PATH:
1007 Use_Original_Path = true;
1008 break;
bigbiff998f8392021-08-06 19:19:33 -04001009 case TWFLAG_LOGICAL:
1010 Is_Super = true;
1011 break;
Matt Mower2416a502016-04-12 19:54:46 -05001012 default:
1013 // Should not get here
1014 LOGINFO("Flag identified for processing, but later unmatched: %i\n", flag);
1015 break;
1016 }
1017}
Dees_Troy51127312012-09-08 13:08:49 -04001018
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001019void TWPartition::Process_TW_Flags(char *flags, bool Display_Error, int fstab_ver) {
Matt Mower2416a502016-04-12 19:54:46 -05001020 char separator[2] = {'\n', 0};
1021 char *ptr, *savep;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001022 char source_separator = ';';
1023
1024 if (fstab_ver == 2)
1025 source_separator = ',';
Matt Mower2416a502016-04-12 19:54:46 -05001026
1027 // Semicolons within double-quotes are not forbidden, so replace
1028 // only the semicolons intended as separators with '\n' for strtok
1029 for (unsigned i = 0, skip = 0; i < strlen(flags); i++) {
1030 if (flags[i] == '\"')
Dees_Troya13d74f2013-03-24 08:54:55 -05001031 skip = !skip;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001032 if (!skip && flags[i] == source_separator)
Matt Mower2416a502016-04-12 19:54:46 -05001033 flags[i] = separator[0];
Dees_Troy51127312012-09-08 13:08:49 -04001034 }
1035
Matt Mower2416a502016-04-12 19:54:46 -05001036 // Avoid issues with potentially nested strtok by using strtok_r
1037 ptr = strtok_r(flags, separator, &savep);
1038 while (ptr) {
1039 int ptr_len = strlen(ptr);
1040 const struct flag_list* tw_flag = tw_flags;
Hashcode62bd9e02013-11-19 21:59:42 -08001041
Matt Mower2416a502016-04-12 19:54:46 -05001042 for (; tw_flag->name; tw_flag++) {
1043 int flag_len = strlen(tw_flag->name);
1044
1045 if (strncmp(ptr, tw_flag->name, flag_len) == 0) {
1046 bool flag_val = false;
1047
1048 if (ptr_len > flag_len && (tw_flag->name)[flag_len-1] != '='
1049 && ptr[flag_len] != '=') {
1050 // Handle flags with same starting string
1051 // (e.g. backup and backupname)
1052 continue;
1053 } else if (ptr_len > flag_len && ptr[flag_len] == '=') {
1054 // Handle flags with dual format: Part 1
1055 // (e.g. backup and backup=y. backup=y handled here)
1056 ptr += flag_len + 1;
1057 TWFunc::Strip_Quotes(ptr);
1058 // Skip flags with empty argument
1059 // (e.g. backup=)
1060 if (strlen(ptr) == 0) {
1061 LOGINFO("Flag missing argument or should not include '=': %s=\n", tw_flag->name);
1062 break;
1063 }
1064 flag_val = strchr("yY1", *ptr) != NULL;
1065 } else if (ptr_len == flag_len
1066 && (tw_flag->name)[flag_len-1] == '=') {
1067 // Skip flags missing argument after =
1068 // (e.g. backupname=)
1069 LOGINFO("Flag missing argument: %s\n", tw_flag->name);
1070 break;
1071 } else if (ptr_len > flag_len
1072 && (tw_flag->name)[flag_len-1] == '=') {
1073 // Handle arguments to flags
1074 // (e.g. backupname="My Stuff")
1075 ptr += flag_len;
1076 TWFunc::Strip_Quotes(ptr);
1077 // Skip flags with empty argument
1078 // (e.g. backupname="")
1079 if (strlen(ptr) == 0) {
1080 LOGINFO("Flag missing argument: %s\n", tw_flag->name);
1081 break;
1082 }
1083 } else if (ptr_len == flag_len) {
1084 // Handle flags with dual format: Part 2
1085 // (e.g. backup and backup=y. backup handled here)
1086 flag_val = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001087 } else {
Matt Mower2416a502016-04-12 19:54:46 -05001088 LOGINFO("Flag matched, but could not be processed: %s\n", ptr);
1089 break;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001090 }
Matt Mower2416a502016-04-12 19:54:46 -05001091
1092 Apply_TW_Flag(tw_flag->flag, ptr, flag_val);
1093 break;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001094 }
Matt Mower2416a502016-04-12 19:54:46 -05001095 }
1096 if (tw_flag->name == 0) {
Dees_Troy51127312012-09-08 13:08:49 -04001097 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001098 LOGERR("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -04001099 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001100 LOGINFO("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -04001101 }
Matt Mower2416a502016-04-12 19:54:46 -05001102 ptr = strtok_r(NULL, separator, &savep);
Dees_Troy51127312012-09-08 13:08:49 -04001103 }
Dees_Troy51a0e822012-09-05 15:24:24 -04001104}
1105
Dees_Troy5bf43922012-09-07 16:07:55 -04001106bool TWPartition::Is_File_System(string File_System) {
1107 if (File_System == "ext2" ||
Dees_Troy63c8df72012-09-10 14:02:05 -04001108 File_System == "ext3" ||
Dees_Troy5bf43922012-09-07 16:07:55 -04001109 File_System == "ext4" ||
1110 File_System == "vfat" ||
1111 File_System == "ntfs" ||
1112 File_System == "yaffs2" ||
bigbiff bigbiff3e146522012-11-14 14:32:59 -05001113 File_System == "exfat" ||
Dees_Troye5017042013-08-29 16:38:55 +00001114 File_System == "f2fs" ||
GarfieldHand0b854b2021-11-21 23:46:20 +08001115 File_System == "erofs" ||
Erfan Abdib859e912019-02-05 18:18:46 +02001116 File_System == "squashfs" ||
Dees_Troy5bf43922012-09-07 16:07:55 -04001117 File_System == "auto")
1118 return true;
1119 else
1120 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001121}
1122
Dees_Troy5bf43922012-09-07 16:07:55 -04001123bool TWPartition::Is_Image(string File_System) {
Dees_Troy5fcd8f92012-10-16 12:22:05 -04001124 if (File_System == "emmc" || File_System == "mtd" || File_System == "bml")
Dees_Troy5bf43922012-09-07 16:07:55 -04001125 return true;
1126 else
1127 return false;
1128}
1129
Dees_Troy51127312012-09-08 13:08:49 -04001130bool TWPartition::Make_Dir(string Path, bool Display_Error) {
Ethan Yonker93ac7a02016-11-07 22:05:58 -06001131 if (TWFunc::Get_D_Type_From_Stat(Path) != S_IFDIR)
1132 unlink(Path.c_str());
Dees_Troy43d8b002012-09-17 16:00:01 -04001133 if (!TWFunc::Path_Exists(Path)) {
Dees_Troy51127312012-09-08 13:08:49 -04001134 if (mkdir(Path.c_str(), 0777) == -1) {
1135 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001136 gui_msg(Msg(msg::kError, "create_folder_strerr=Can not create '{1}' folder ({2}).")(Path)(strerror(errno)));
Dees_Troy51127312012-09-08 13:08:49 -04001137 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001138 LOGINFO("Can not create '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001139 return false;
1140 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001141 LOGINFO("Created '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001142 return true;
1143 }
1144 }
1145 return true;
1146}
1147
Dees_Troy5bf43922012-09-07 16:07:55 -04001148void TWPartition::Setup_File_System(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001149 Can_Be_Mounted = true;
1150 Can_Be_Wiped = true;
1151
Dees_Troy5bf43922012-09-07 16:07:55 -04001152 // Make the mount point folder if it doesn't exist
Dees_Troy51127312012-09-08 13:08:49 -04001153 Make_Dir(Mount_Point, Display_Error);
bigbiffce8f83c2015-12-12 18:30:21 -05001154 Backup_Method = BM_FILES;
Dees_Troy5bf43922012-09-07 16:07:55 -04001155}
1156
Ethan Yonker1b190162016-12-05 15:25:19 -06001157void TWPartition::Setup_Image() {
Dees_Troy5bf43922012-09-07 16:07:55 -04001158 Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
1159 Backup_Name = Display_Name;
Gary Peck82599a82012-11-21 16:23:12 -08001160 if (Current_File_System == "emmc")
bigbiffce8f83c2015-12-12 18:30:21 -05001161 Backup_Method = BM_DD;
Gary Peck82599a82012-11-21 16:23:12 -08001162 else if (Current_File_System == "mtd" || Current_File_System == "bml")
bigbiffce8f83c2015-12-12 18:30:21 -05001163 Backup_Method = BM_FLASH_UTILS;
Dees_Troy5bf43922012-09-07 16:07:55 -04001164 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001165 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 -04001166}
1167
Dees_Troye58d5262012-09-21 12:27:57 -04001168void TWPartition::Setup_AndSec(void) {
Dees_Troya13d74f2013-03-24 08:54:55 -05001169 Backup_Display_Name = "Android Secure";
Dees_Troye58d5262012-09-21 12:27:57 -04001170 Backup_Name = "and-sec";
Dees_Troya13d74f2013-03-24 08:54:55 -05001171 Can_Be_Backed_Up = true;
Dees_Troye58d5262012-09-21 12:27:57 -04001172 Has_Android_Secure = true;
1173 Symlink_Path = Mount_Point + "/.android_secure";
1174 Symlink_Mount_Point = "/and-sec";
1175 Backup_Path = Symlink_Mount_Point;
1176 Make_Dir("/and-sec", true);
1177 Recreate_AndSec_Folder();
Kjell Braden3126a112016-06-19 16:58:15 +00001178 Mount_Storage_Retry(true);
Dees_Troye58d5262012-09-21 12:27:57 -04001179}
1180
that9e0593e2014-10-08 00:01:24 +02001181void TWPartition::Setup_Data_Media() {
Ethan Yonker6277c792014-09-15 14:54:30 -05001182 LOGINFO("Setting up '%s' as data/media emulated storage.\n", Mount_Point.c_str());
Ethan Yonker66a19492015-12-10 10:19:45 -06001183 if (Storage_Name.empty() || Storage_Name == "Data")
1184 Storage_Name = "Internal Storage";
Ethan Yonker6277c792014-09-15 14:54:30 -05001185 Has_Data_Media = true;
1186 Is_Storage = true;
Ethan Yonker66a19492015-12-10 10:19:45 -06001187 Storage_Path = Mount_Point + "/media";
Ethan Yonker6277c792014-09-15 14:54:30 -05001188 Symlink_Path = Storage_Path;
Ethan Yonker66a19492015-12-10 10:19:45 -06001189 if (Mount_Point == "/data") {
1190 Is_Settings_Storage = true;
1191 if (strcmp(EXPAND(TW_EXTERNAL_STORAGE_PATH), "/sdcard") == 0) {
1192 Make_Dir("/emmc", false);
1193 Symlink_Mount_Point = "/emmc";
1194 } else {
1195 Make_Dir("/sdcard", false);
1196 Symlink_Mount_Point = "/sdcard";
1197 }
1198 if (Mount(false) && TWFunc::Path_Exists(Mount_Point + "/media/0")) {
1199 Storage_Path = Mount_Point + "/media/0";
1200 Symlink_Path = Storage_Path;
1201 DataManager::SetValue(TW_INTERNAL_PATH, Mount_Point + "/media/0");
1202 UnMount(true);
1203 }
1204 DataManager::SetValue("tw_has_internal", 1);
1205 DataManager::SetValue("tw_has_data_media", 1);
Ethan Yonker3fdcda42016-11-30 12:29:37 -06001206 backup_exclusions.add_absolute_dir("/data/data/com.google.android.music/files");
bigbiff25d25b92020-06-19 16:07:38 -04001207 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 +01001208 backup_exclusions.add_absolute_dir("/data/vendor/dumpsys");
bigbiff25d25b92020-06-19 16:07:38 -04001209 backup_exclusions.add_absolute_dir("/data/cache");
Ethan Yonker6355b562017-05-01 09:42:17 -05001210 wipe_exclusions.add_absolute_dir(Mount_Point + "/misc/vold"); // adopted storage keys
Ethan Yonker79f88bd2016-12-09 14:52:12 -06001211 ExcludeAll(Mount_Point + "/system/storage.xml");
Ethan Yonker6277c792014-09-15 14:54:30 -05001212 } else {
nkk713c1e35f2017-03-24 18:28:03 +02001213 int i;
1214 string path;
1215 for (i = 2; i <= 9; i++) {
1216 path = "/sdcard" + TWFunc::to_string(i);
1217 if (!TWFunc::Path_Exists(path)) {
1218 Make_Dir(path, false);
1219 Symlink_Mount_Point = path;
1220 LOGINFO("'%s' data/media emulated storage symlinked to %s.\n", Mount_Point.c_str(), Symlink_Mount_Point.c_str());
1221 break;
1222 }
1223 }
Ethan Yonker66a19492015-12-10 10:19:45 -06001224 if (Mount(true) && TWFunc::Path_Exists(Mount_Point + "/media/0")) {
1225 Storage_Path = Mount_Point + "/media/0";
1226 Symlink_Path = Storage_Path;
1227 UnMount(true);
1228 }
Ethan Yonker6277c792014-09-15 14:54:30 -05001229 }
Ethan Yonker79f88bd2016-12-09 14:52:12 -06001230 ExcludeAll(Mount_Point + "/media");
Ethan Yonker6277c792014-09-15 14:54:30 -05001231}
1232
Dees_Troy5bf43922012-09-07 16:07:55 -04001233void TWPartition::Find_Real_Block_Device(string& Block, bool Display_Error) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001234 char device[PATH_MAX], realDevice[PATH_MAX];
Dees_Troy5bf43922012-09-07 16:07:55 -04001235
Peter Caid68e6412019-11-02 19:22:38 +08001236 Original_Path = Block;
1237
Dees_Troy5bf43922012-09-07 16:07:55 -04001238 strcpy(device, Block.c_str());
1239 memset(realDevice, 0, sizeof(realDevice));
1240 while (readlink(device, realDevice, sizeof(realDevice)) > 0)
1241 {
1242 strcpy(device, realDevice);
1243 memset(realDevice, 0, sizeof(realDevice));
1244 }
1245
bigbiff998f8392021-08-06 19:19:33 -04001246 Block = device;
1247 return;
Dees_Troy5bf43922012-09-07 16:07:55 -04001248}
1249
Kjell Braden3126a112016-06-19 16:58:15 +00001250bool TWPartition::Mount_Storage_Retry(bool Display_Error) {
Dees_Troy8e337f32012-10-13 22:07:49 -04001251 // On some devices, storage doesn't want to mount right away, retry and sleep
Kjell Braden3126a112016-06-19 16:58:15 +00001252 if (!Mount(Display_Error)) {
Dees_Troy8e337f32012-10-13 22:07:49 -04001253 int retry_count = 5;
1254 while (retry_count > 0 && !Mount(false)) {
1255 usleep(500000);
1256 retry_count--;
1257 }
Kjell Braden3126a112016-06-19 16:58:15 +00001258 return Mount(Display_Error);
Dees_Troy8e337f32012-10-13 22:07:49 -04001259 }
Kjell Braden3126a112016-06-19 16:58:15 +00001260 return true;
Dees_Troy8e337f32012-10-13 22:07:49 -04001261}
1262
Dees_Troy38bd7602012-09-14 13:33:53 -04001263bool TWPartition::Find_MTD_Block_Device(string MTD_Name) {
1264 FILE *fp = NULL;
1265 char line[255];
1266
1267 fp = fopen("/proc/mtd", "rt");
1268 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001269 LOGERR("Device does not support /proc/mtd\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001270 return false;
1271 }
1272
1273 while (fgets(line, sizeof(line), fp) != NULL)
1274 {
1275 char device[32], label[32];
1276 unsigned long size = 0;
Dees_Troy38bd7602012-09-14 13:33:53 -04001277 int deviceId;
1278
1279 sscanf(line, "%s %lx %*s %*c%s", device, &size, label);
1280
1281 // Skip header and blank lines
1282 if ((strcmp(device, "dev:") == 0) || (strlen(line) < 8))
1283 continue;
1284
1285 // Strip off the trailing " from the label
1286 label[strlen(label)-1] = '\0';
1287
1288 if (strcmp(label, MTD_Name.c_str()) == 0) {
1289 // We found our device
1290 // Strip off the trailing : from the device
1291 device[strlen(device)-1] = '\0';
1292 if (sscanf(device,"mtd%d", &deviceId) == 1) {
1293 sprintf(device, "/dev/block/mtdblock%d", deviceId);
1294 Primary_Block_Device = device;
Dees_Troy76543db2013-06-19 16:24:30 +00001295 fclose(fp);
1296 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -04001297 }
1298 }
1299 }
1300 fclose(fp);
1301
1302 return false;
1303}
1304
Dees_Troy51127312012-09-08 13:08:49 -04001305bool TWPartition::Get_Size_Via_statfs(bool Display_Error) {
1306 struct statfs st;
1307 string Local_Path = Mount_Point + "/.";
1308
1309 if (!Mount(Display_Error))
1310 return false;
1311
1312 if (statfs(Local_Path.c_str(), &st) != 0) {
1313 if (!Removable) {
1314 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001315 LOGERR("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001316 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001317 LOGINFO("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001318 }
1319 return false;
1320 }
1321 Size = (st.f_blocks * st.f_bsize);
1322 Used = ((st.f_blocks - st.f_bfree) * st.f_bsize);
1323 Free = (st.f_bfree * st.f_bsize);
1324 Backup_Size = Used;
1325 return true;
1326}
1327
1328bool TWPartition::Get_Size_Via_df(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001329 FILE* fp;
1330 char command[255], line[512];
1331 int include_block = 1;
1332 unsigned int min_len;
1333
1334 if (!Mount(Display_Error))
1335 return false;
1336
Dees_Troy38bd7602012-09-14 13:33:53 -04001337 min_len = Actual_Block_Device.size() + 2;
Dees_Troy51127312012-09-08 13:08:49 -04001338 sprintf(command, "df %s > /tmp/dfoutput.txt", Mount_Point.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001339 TWFunc::Exec_Cmd(command);
Dees_Troy51127312012-09-08 13:08:49 -04001340 fp = fopen("/tmp/dfoutput.txt", "rt");
1341 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001342 LOGINFO("Unable to open /tmp/dfoutput.txt.\n");
Dees_Troy5bf43922012-09-07 16:07:55 -04001343 return false;
Dees_Troy51127312012-09-08 13:08:49 -04001344 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001345
1346 while (fgets(line, sizeof(line), fp) != NULL)
1347 {
1348 unsigned long blocks, used, available;
1349 char device[64];
1350 char tmpString[64];
1351
1352 if (strncmp(line, "Filesystem", 10) == 0)
1353 continue;
1354 if (strlen(line) < min_len) {
1355 include_block = 0;
1356 continue;
1357 }
1358 if (include_block) {
1359 sscanf(line, "%s %lu %lu %lu", device, &blocks, &used, &available);
1360 } else {
1361 // The device block string is so long that the df information is on the next line
1362 int space_count = 0;
Dees_Troye58d5262012-09-21 12:27:57 -04001363 sprintf(tmpString, "/dev/block/%s", Actual_Block_Device.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001364 while (tmpString[space_count] == 32)
1365 space_count++;
1366 sscanf(line + space_count, "%lu %lu %lu", &blocks, &used, &available);
1367 }
1368
1369 // Adjust block size to byte size
1370 Size = blocks * 1024ULL;
1371 Used = used * 1024ULL;
1372 Free = available * 1024ULL;
1373 Backup_Size = Used;
1374 }
1375 fclose(fp);
1376 return true;
1377}
1378
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001379unsigned long long TWPartition::IOCTL_Get_Block_Size() {
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001380 Find_Actual_Block_Device();
Ethan Yonker483e9f42016-01-11 22:21:18 -06001381
1382 return TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001383}
1384
Dees_Troy5bf43922012-09-07 16:07:55 -04001385bool TWPartition::Find_Partition_Size(void) {
1386 FILE* fp;
1387 char line[512];
1388 string tmpdevice;
1389
igoriok87e3d932013-01-31 21:03:53 +02001390 fp = fopen("/proc/dumchar_info", "rt");
1391 if (fp != NULL) {
1392 while (fgets(line, sizeof(line), fp) != NULL)
1393 {
1394 char label[32], device[32];
1395 unsigned long size = 0;
1396
thatd43bf2d2014-09-21 23:13:02 +02001397 sscanf(line, "%s %lx %*x %*u %s", label, &size, device);
igoriok87e3d932013-01-31 21:03:53 +02001398
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05001399 // Skip header, annotation and blank lines
igoriok87e3d932013-01-31 21:03:53 +02001400 if ((strncmp(device, "/dev/", 5) != 0) || (strlen(line) < 8))
1401 continue;
1402
1403 tmpdevice = "/dev/";
1404 tmpdevice += label;
1405 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
1406 Size = size;
1407 fclose(fp);
1408 return true;
1409 }
1410 }
1411 }
1412
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001413 unsigned long long ioctl_size = IOCTL_Get_Block_Size();
1414 if (ioctl_size) {
1415 Size = ioctl_size;
1416 return true;
1417 }
1418
Dees_Troy5bf43922012-09-07 16:07:55 -04001419 // In this case, we'll first get the partitions we care about (with labels)
1420 fp = fopen("/proc/partitions", "rt");
1421 if (fp == NULL)
1422 return false;
1423
1424 while (fgets(line, sizeof(line), fp) != NULL)
1425 {
1426 unsigned long major, minor, blocks;
1427 char device[512];
Dees_Troy5bf43922012-09-07 16:07:55 -04001428
Dees_Troy63c8df72012-09-10 14:02:05 -04001429 if (strlen(line) < 7 || line[0] == 'm') continue;
Dees_Troy5bf43922012-09-07 16:07:55 -04001430 sscanf(line + 1, "%lu %lu %lu %s", &major, &minor, &blocks, device);
1431
1432 tmpdevice = "/dev/block/";
1433 tmpdevice += device;
Dees_Troy38bd7602012-09-14 13:33:53 -04001434 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001435 // Adjust block size to byte size
1436 Size = blocks * 1024ULL;
1437 fclose(fp);
1438 return true;
1439 }
1440 }
1441 fclose(fp);
1442 return false;
1443}
1444
Dees_Troy5bf43922012-09-07 16:07:55 -04001445bool TWPartition::Is_Mounted(void) {
1446 if (!Can_Be_Mounted)
1447 return false;
1448
1449 struct stat st1, st2;
1450 string test_path;
1451
1452 // Check to see if the mount point directory exists
1453 test_path = Mount_Point + "/.";
1454 if (stat(test_path.c_str(), &st1) != 0) return false;
1455
1456 // Check to see if the directory above the mount point exists
1457 test_path = Mount_Point + "/../.";
1458 if (stat(test_path.c_str(), &st2) != 0) return false;
1459
1460 // Compare the device IDs -- if they match then we're (probably) using tmpfs instead of an actual device
1461 int ret = (st1.st_dev != st2.st_dev) ? true : false;
Dees_Troy5bf43922012-09-07 16:07:55 -04001462 return ret;
1463}
1464
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05001465bool TWPartition::Is_File_System_Writable(void) {
1466 if (!Is_File_System(Current_File_System) || !Is_Mounted())
1467 return false;
1468
1469 string test_path = Mount_Point + "/.";
1470 return (access(test_path.c_str(), W_OK) == 0);
1471}
1472
Dees_Troy5bf43922012-09-07 16:07:55 -04001473bool TWPartition::Mount(bool Display_Error) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001474 int exfat_mounted = 0;
Martin Dünkelmann6d843782018-12-27 23:40:28 +01001475 unsigned int flags = Mount_Flags;
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001476
Dees_Troy5bf43922012-09-07 16:07:55 -04001477 if (Is_Mounted()) {
1478 return true;
1479 } else if (!Can_Be_Mounted) {
1480 return false;
1481 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001482
1483 Find_Actual_Block_Device();
1484
1485 // Check the current file system before mounting
1486 Check_FS_Type();
bigbiffad58e1b2020-07-06 20:24:34 -04001487 if (Current_File_System == "exfat" && TWFunc::Path_Exists("/system/bin/exfat-fuse")) {
1488 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 +00001489 LOGINFO("cmd: %s\n", cmd.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001490 string result;
bigbiffad58e1b2020-07-06 20:24:34 -04001491 if (TWFunc::Exec_Cmd(cmd, result, false) != 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001492 LOGINFO("exfat-fuse failed to mount with result '%s', trying vfat\n", result.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001493 Current_File_System = "vfat";
1494 } else {
1495#ifdef TW_NO_EXFAT_FUSE
1496 UnMount(false);
1497 // We'll let the kernel handle it but using exfat-fuse to detect if the file system is actually exfat
1498 // Some kernels let us mount vfat as exfat which doesn't work out too well
1499#else
1500 exfat_mounted = 1;
1501#endif
1502 }
1503 }
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001504
Captain Throwback47bf7202020-10-06 17:39:39 -04001505 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 -05001506 string cmd;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001507 string Ntfsmount_Binary = "";
1508
bigbiffad58e1b2020-07-06 20:24:34 -04001509 if (TWFunc::Path_Exists("/system/bin/ntfs-3g"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001510 Ntfsmount_Binary = "ntfs-3g";
bigbiffad58e1b2020-07-06 20:24:34 -04001511 else if (TWFunc::Path_Exists("/system/bin/mount.ntfs"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001512 Ntfsmount_Binary = "mount.ntfs";
1513
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001514 if (Mount_Read_Only)
bigbiffad58e1b2020-07-06 20:24:34 -04001515 cmd = "/system/bin/" + Ntfsmount_Binary + " -o ro " + Actual_Block_Device + " " + Mount_Point;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001516 else
bigbiffad58e1b2020-07-06 20:24:34 -04001517 cmd = "/system/bin/" + Ntfsmount_Binary + " " + Actual_Block_Device + " " + Mount_Point;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001518 LOGINFO("cmd: '%s'\n", cmd.c_str());
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001519
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001520 if (TWFunc::Exec_Cmd(cmd) == 0) {
1521 return true;
1522 } else {
1523 LOGINFO("ntfs-3g failed to mount, trying regular mount method.\n");
1524 }
Captain Throwback47bf7202020-10-06 17:39:39 -04001525 } else {
1526 if (Current_File_System == "ntfs" && TWFunc::Path_Exists("/sys/module/tntfs"))
1527 Current_File_System = "tntfs";
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001528 }
1529
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001530 if (Mount_Read_Only)
1531 flags |= MS_RDONLY;
1532
Dees_Troy22042032012-12-18 21:23:08 +00001533 if (Fstab_File_System == "yaffs2") {
1534 // mount an MTD partition as a YAFFS2 filesystem.
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001535 flags = MS_NOATIME | MS_NODEV | MS_NODIRATIME;
1536 if (Mount_Read_Only)
1537 flags |= MS_RDONLY;
Dees_Troy76543db2013-06-19 16:24:30 +00001538 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags, NULL) < 0) {
1539 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags | MS_RDONLY, NULL) < 0) {
1540 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001541 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy76543db2013-06-19 16:24:30 +00001542 else
1543 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
1544 return false;
1545 } else {
1546 LOGINFO("Mounted '%s' (MTD) as RO\n", Mount_Point.c_str());
1547 return true;
1548 }
1549 } else {
1550 struct stat st;
1551 string test_path = Mount_Point;
1552 if (stat(test_path.c_str(), &st) < 0) {
1553 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001554 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy76543db2013-06-19 16:24:30 +00001555 else
1556 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
1557 return false;
1558 }
1559 mode_t new_mode = st.st_mode | S_IXUSR | S_IXGRP | S_IXOTH;
1560 if (new_mode != st.st_mode) {
1561 LOGINFO("Fixing execute permissions for %s\n", Mount_Point.c_str());
1562 if (chmod(Mount_Point.c_str(), new_mode) < 0) {
1563 if (Display_Error)
1564 LOGERR("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
1565 else
1566 LOGINFO("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
1567 return false;
1568 }
1569 }
Dees_Troy22042032012-12-18 21:23:08 +00001570 return true;
Dees_Troy76543db2013-06-19 16:24:30 +00001571 }
thatc7572eb2015-03-31 18:55:30 +02001572 }
1573
1574 string mount_fs = Current_File_System;
1575 if (Current_File_System == "exfat" && TWFunc::Path_Exists("/sys/module/texfat"))
1576 mount_fs = "texfat";
1577
1578 if (!exfat_mounted &&
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001579 mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), mount_fs.c_str(), flags, Mount_Options.c_str()) != 0 &&
1580 mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), mount_fs.c_str(), flags, NULL) != 0) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001581#ifdef TW_NO_EXFAT_FUSE
1582 if (Current_File_System == "exfat") {
Dees_Troy2673cec2013-04-02 20:22:16 +00001583 LOGINFO("Mounting exfat failed, trying vfat...\n");
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001584 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), "vfat", 0, NULL) != 0) {
Dees_Troy85f44ed2013-01-09 18:42:36 +00001585 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001586 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy85f44ed2013-01-09 18:42:36 +00001587 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001588 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001589 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 +00001590 return false;
Dees_Troy85f44ed2013-01-09 18:42:36 +00001591 }
Dees_Troyb05ddee2013-01-28 20:24:50 +00001592 } else {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001593#endif
bigbiff bigbiff26774a02014-03-29 18:22:00 -04001594 if (!Removable && Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001595 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001596 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001597 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
1598 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 +00001599 return false;
1600#ifdef TW_NO_EXFAT_FUSE
Dees_Troy85f44ed2013-01-09 18:42:36 +00001601 }
1602#endif
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001603 }
Ethan Yonker253368a2014-11-25 15:00:52 -06001604
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001605 if (Removable)
1606 Update_Size(Display_Error);
1607
bigbiff36cb2ad2021-12-09 19:24:45 -05001608 if (!Symlink_Mount_Point.empty() && Symlink_Mount_Point != "/sdcard") {
bigbiffbe4f46c2021-04-24 11:48:54 -04001609 if (!Bind_Mount(false))
1610 return false;
1611 }
1612 return true;
1613}
1614
1615bool TWPartition::Bind_Mount(bool Display_Error) {
1616 if (TWFunc::Path_Exists(Symlink_Path)) {
1617 if (mount(Symlink_Path.c_str(), Symlink_Mount_Point.c_str(), "", MS_BIND, NULL) < 0) {
1618 return false;
1619 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001620 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001621 return true;
1622}
1623
1624bool TWPartition::UnMount(bool Display_Error) {
1625 if (Is_Mounted()) {
1626 int never_unmount_system;
1627
1628 DataManager::GetValue(TW_DONT_UNMOUNT_SYSTEM, never_unmount_system);
Captain Throwback9d6feb52018-07-27 10:05:24 -04001629 if (never_unmount_system == 1 && Mount_Point == PartitionManager.Get_Android_Root_Path())
Dees_Troy5bf43922012-09-07 16:07:55 -04001630 return true; // Never unmount system if you're not supposed to unmount it
1631
Matt Mowera8e6d832017-02-14 20:20:59 -06001632 if (Is_Storage && MTP_Storage_ID > 0)
Ethan Yonker726a0202014-12-16 20:01:38 -06001633 PartitionManager.Remove_MTP_Storage(MTP_Storage_ID);
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001634
Dees_Troy38bd7602012-09-14 13:33:53 -04001635 if (!Symlink_Mount_Point.empty())
1636 umount(Symlink_Mount_Point.c_str());
1637
Dees_Troyb05ddee2013-01-28 20:24:50 +00001638 umount(Mount_Point.c_str());
1639 if (Is_Mounted()) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001640 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001641 gui_msg(Msg(msg::kError, "fail_unmount=Failed to unmount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy5bf43922012-09-07 16:07:55 -04001642 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001643 LOGINFO("Unable to unmount '%s'\n", Mount_Point.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001644 return false;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001645 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -04001646 return true;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001647 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001648 } else {
1649 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001650 }
1651}
1652
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05001653bool TWPartition::ReMount(bool Display_Error) {
1654 if (UnMount(Display_Error))
1655 return Mount(Display_Error);
1656 return false;
1657}
1658
1659bool TWPartition::ReMount_RW(bool Display_Error) {
1660 // No need to remount if already mounted rw
1661 if (Is_File_System_Writable())
1662 return true;
1663
1664 bool ro = Mount_Read_Only;
1665 int flags = Mount_Flags;
1666
1667 Mount_Read_Only = false;
1668 Mount_Flags &= ~MS_RDONLY;
1669
1670 bool ret = ReMount(Display_Error);
1671
1672 Mount_Read_Only = ro;
1673 Mount_Flags = flags;
1674
1675 return ret;
1676}
1677
Gary Peck43acadf2012-11-21 21:19:01 -08001678bool TWPartition::Wipe(string New_File_System) {
Ethan Yonker726a0202014-12-16 20:01:38 -06001679 bool wiped = false, update_crypt = false, recreate_media = true;
Dees_Troy16c2b312013-01-15 16:51:18 +00001680 int check;
Dees_Troy16c2b312013-01-15 16:51:18 +00001681
Dees_Troy38bd7602012-09-14 13:33:53 -04001682 if (!Can_Be_Wiped) {
Matt Mower3c366972015-12-25 19:28:31 -06001683 gui_msg(Msg(msg::kError, "cannot_wipe=Partition {1} cannot be wiped.")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04001684 return false;
1685 }
1686
Dees_Troyc51f1f92012-09-20 15:32:13 -04001687 if (Mount_Point == "/cache")
Dees_Troy2673cec2013-04-02 20:22:16 +00001688 Log_Offset = 0;
Dees_Troyc51f1f92012-09-20 15:32:13 -04001689
bigbiff4a60bee2021-01-23 14:08:03 -05001690 if (Mount_Point == PartitionManager.Get_Android_Root_Path()) {
1691 if (tw_get_default_metadata(PartitionManager.Get_Android_Root_Path().c_str()) != 0) {
1692 gui_msg(Msg(msg::kWarning, "restore_system_context=Unable to get default context for {1} -- Android may not boot.")(PartitionManager.Get_Android_Root_Path()));
1693 }
1694 }
1695
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001696 if (Has_Data_Media && Current_File_System == New_File_System) {
Dees_Troy16c2b312013-01-15 16:51:18 +00001697 wiped = Wipe_Data_Without_Wiping_Media();
bigbiff25d25b92020-06-19 16:07:38 -04001698 if (Mount_Point == "/data" && TWFunc::get_log_dir() == DATA_LOGS_DIR) {
1699 bool created = PartitionManager.Recreate_Logs_Dir();
1700 if (!created)
1701 LOGERR("Unable to create log directory for TWRP\n");
bigbiff7ba75002020-04-11 20:47:09 -04001702 }
Ethan Yonker5eac2222014-06-11 12:22:55 -05001703 recreate_media = false;
Dees_Troy16c2b312013-01-15 16:51:18 +00001704 } else {
Dees_Troy16c2b312013-01-15 16:51:18 +00001705 DataManager::GetValue(TW_RM_RF_VAR, check);
Hashcodedabfd492013-08-29 22:45:30 -07001706 if (check || Use_Rm_Rf)
Dees_Troy16c2b312013-01-15 16:51:18 +00001707 wiped = Wipe_RMRF();
1708 else if (New_File_System == "ext4")
1709 wiped = Wipe_EXT4();
1710 else if (New_File_System == "ext2" || New_File_System == "ext3")
dianlujitao4879b372018-12-03 18:45:47 +08001711 wiped = Wipe_EXTFS(New_File_System);
Dees_Troy16c2b312013-01-15 16:51:18 +00001712 else if (New_File_System == "exfat")
1713 wiped = Wipe_EXFAT();
Captain Throwback47bf7202020-10-06 17:39:39 -04001714 else if (New_File_System == "ntfs" || Current_File_System == "tntfs")
1715 wiped = Wipe_NTFS();
Dees_Troy16c2b312013-01-15 16:51:18 +00001716 else if (New_File_System == "yaffs2")
1717 wiped = Wipe_MTD();
Dees_Troye5017042013-08-29 16:38:55 +00001718 else if (New_File_System == "f2fs")
1719 wiped = Wipe_F2FS();
Captain Throwback47bf7202020-10-06 17:39:39 -04001720 else if (New_File_System == "vfat")
1721 wiped = Wipe_FAT();
Dees_Troy16c2b312013-01-15 16:51:18 +00001722 else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001723 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 +00001724 return false;
1725 }
1726 update_crypt = wiped;
bigbiff7ba75002020-04-11 20:47:09 -04001727 update_crypt = false;
Gary Pecke8bc5d72012-12-21 06:45:25 -08001728 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001729
Gary Pecke8bc5d72012-12-21 06:45:25 -08001730 if (wiped) {
Mohd Faraze1d72622020-06-15 00:28:32 +05301731 if (Mount_Point == "/cache" && TWFunc::get_log_dir() != DATA_LOGS_DIR)
1732 DataManager::Output_Version();
1733
bigbiff4a60bee2021-01-23 14:08:03 -05001734 if (Mount_Point == PartitionManager.Get_Android_Root_Path()) {
1735 tw_set_default_metadata(PartitionManager.Get_Android_Root_Path().c_str());
1736 }
Dees_Troy16c2b312013-01-15 16:51:18 +00001737 if (update_crypt) {
1738 Setup_File_System(false);
1739 if (Is_Encrypted && !Is_Decrypted) {
1740 // just wiped an encrypted partition back to its unencrypted state
1741 Is_Encrypted = false;
1742 Is_Decrypted = false;
1743 Decrypted_Block_Device = "";
1744 if (Mount_Point == "/data") {
1745 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
1746 DataManager::SetValue(TW_IS_DECRYPTED, 0);
1747 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08001748 }
1749 }
Ethan Yonker5eac2222014-06-11 12:22:55 -05001750
Captain Throwback63573b52021-10-02 20:47:33 -04001751 if (Is_Storage && Mount(false) && !Is_FBE)
bigbiffbe4f46c2021-04-24 11:48:54 -04001752 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
Gary Pecke8bc5d72012-12-21 06:45:25 -08001753 }
Matt Mower209c9632016-01-20 12:08:35 -06001754
Gary Pecke8bc5d72012-12-21 06:45:25 -08001755 return wiped;
Dees_Troy51a0e822012-09-05 15:24:24 -04001756}
1757
Gary Peck43acadf2012-11-21 21:19:01 -08001758bool TWPartition::Wipe() {
Gary Peck82599a82012-11-21 16:23:12 -08001759 if (Is_File_System(Current_File_System))
1760 return Wipe(Current_File_System);
1761 else
1762 return Wipe(Fstab_File_System);
Gary Peck43acadf2012-11-21 21:19:01 -08001763}
1764
Dees_Troye58d5262012-09-21 12:27:57 -04001765bool TWPartition::Wipe_AndSec(void) {
1766 if (!Has_Android_Secure)
1767 return false;
1768
Dees_Troye58d5262012-09-21 12:27:57 -04001769 if (!Mount(true))
1770 return false;
1771
Ethan Yonker74db1572015-10-28 12:44:49 -05001772 gui_msg(Msg("wiping=Wiping {1}")(Backup_Display_Name));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001773 TWFunc::removeDir(Mount_Point + "/.android_secure/", true);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001774 return true;
Dees_Troye58d5262012-09-21 12:27:57 -04001775}
1776
bigbiffaed1bdf2021-08-03 18:21:39 -04001777bool TWPartition::Wipe_Data_Cache(void) {
1778 if (!Mount(true))
1779 return false;
1780 gui_msg(Msg("wiping=Wiping {1}")(Mount_Point + "/cache/"));
1781 TWFunc::removeDir(Mount_Point + "/cache/", true);
1782 return true;
1783}
1784
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001785bool TWPartition::Can_Repair() {
Ethan Yonkera2719152015-05-28 09:44:41 -05001786 if (Mount_Read_Only)
1787 return false;
bigbiffad58e1b2020-07-06 20:24:34 -04001788 if (Current_File_System == "vfat" && TWFunc::Path_Exists("/system/bin/fsck.fat"))
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001789 return true;
bigbiffad58e1b2020-07-06 20:24:34 -04001790 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 -05001791 return true;
bigbiffad58e1b2020-07-06 20:24:34 -04001792 else if (Current_File_System == "exfat" && TWFunc::Path_Exists("/system/bin/fsck.exfat"))
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001793 return true;
bigbiffad58e1b2020-07-06 20:24:34 -04001794 else if (Current_File_System == "f2fs" && TWFunc::Path_Exists("/system/bin/fsck.f2fs"))
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001795 return true;
Captain Throwback47bf7202020-10-06 17:39:39 -04001796 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 -05001797 return true;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001798 return false;
1799}
1800
1801bool TWPartition::Repair() {
1802 string command;
1803
1804 if (Current_File_System == "vfat") {
bigbiffad58e1b2020-07-06 20:24:34 -04001805 if (!TWFunc::Path_Exists("/system/bin/fsck.fat")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001806 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.fat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001807 return false;
1808 }
1809 if (!UnMount(true))
1810 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001811 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.fat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001812 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001813 command = "/system/bin/fsck.fat -y " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001814 LOGINFO("Repair command: %s\n", command.c_str());
1815 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001816 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001817 return true;
1818 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001819 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001820 return false;
1821 }
1822 }
1823 if (Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") {
bigbiffad58e1b2020-07-06 20:24:34 -04001824 if (!TWFunc::Path_Exists("/system/bin/e2fsck")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001825 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("e2fsck"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001826 return false;
1827 }
1828 if (!UnMount(true))
1829 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001830 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("e2fsck"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001831 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001832 command = "/system/bin/e2fsck -fp " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001833 LOGINFO("Repair command: %s\n", command.c_str());
1834 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001835 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001836 return true;
1837 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001838 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001839 return false;
1840 }
1841 }
1842 if (Current_File_System == "exfat") {
bigbiffad58e1b2020-07-06 20:24:34 -04001843 if (!TWFunc::Path_Exists("/system/bin/fsck.exfat")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001844 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.exfat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001845 return false;
1846 }
1847 if (!UnMount(true))
1848 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001849 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.exfat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001850 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001851 command = "/system/bin/fsck.exfat " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001852 LOGINFO("Repair command: %s\n", command.c_str());
1853 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001854 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001855 return true;
1856 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001857 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001858 return false;
1859 }
1860 }
1861 if (Current_File_System == "f2fs") {
bigbiffad58e1b2020-07-06 20:24:34 -04001862 if (!TWFunc::Path_Exists("/system/bin/fsck.f2fs")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001863 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.f2fs"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001864 return false;
1865 }
1866 if (!UnMount(true))
1867 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001868 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.f2fs"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001869 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001870 command = "/system/bin/fsck.f2fs " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001871 LOGINFO("Repair command: %s\n", command.c_str());
1872 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001873 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001874 return true;
1875 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001876 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001877 return false;
1878 }
1879 }
Captain Throwback47bf7202020-10-06 17:39:39 -04001880 if (Current_File_System == "ntfs" || Current_File_System == "tntfs") {
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001881 string Ntfsfix_Binary;
bigbiffad58e1b2020-07-06 20:24:34 -04001882 if (TWFunc::Path_Exists("/system/bin/ntfsfix"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001883 Ntfsfix_Binary = "ntfsfix";
bigbiffad58e1b2020-07-06 20:24:34 -04001884 else if (TWFunc::Path_Exists("/system/bin/fsck.ntfs"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001885 Ntfsfix_Binary = "fsck.ntfs";
1886 else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001887 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("ntfsfix"));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001888 return false;
1889 }
1890 if (!UnMount(true))
1891 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001892 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)(Ntfsfix_Binary));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001893 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001894 command = "/system/bin/" + Ntfsfix_Binary + " " + Actual_Block_Device;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001895 LOGINFO("Repair command: %s\n", command.c_str());
1896 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001897 gui_msg("done=Done.");
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001898 return true;
1899 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001900 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001901 return false;
1902 }
1903 }
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001904 return false;
1905}
1906
Ethan Yonkera2719152015-05-28 09:44:41 -05001907bool TWPartition::Can_Resize() {
1908 if (Mount_Read_Only)
1909 return false;
bigbiffad58e1b2020-07-06 20:24:34 -04001910 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 -05001911 return true;
1912 return false;
1913}
1914
1915bool TWPartition::Resize() {
1916 string command;
1917
1918 if (Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") {
1919 if (!Can_Repair()) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001920 LOGINFO("Cannot resize %s because %s cannot be repaired before resizing.\n", Display_Name.c_str(), Display_Name.c_str());
1921 gui_msg(Msg(msg::kError, "cannot_resize=Cannot resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001922 return false;
1923 }
bigbiffad58e1b2020-07-06 20:24:34 -04001924 if (!TWFunc::Path_Exists("/system/bin/resize2fs")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001925 LOGINFO("resize2fs does not exist! Cannot resize!\n");
1926 gui_msg(Msg(msg::kError, "cannot_resize=Cannot resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001927 return false;
1928 }
1929 // Repair will unmount so no need to do it twice
Ethan Yonker74db1572015-10-28 12:44:49 -05001930 gui_msg(Msg("repair_resize=Repairing {1} before resizing.")( Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001931 if (!Repair())
1932 return false;
Ethan Yonker74db1572015-10-28 12:44:49 -05001933 gui_msg(Msg("resizing=Resizing {1} using {2}...")(Display_Name)("resize2fs"));
Ethan Yonkera2719152015-05-28 09:44:41 -05001934 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001935 command = "/system/bin/resize2fs " + Actual_Block_Device;
Ethan Yonkera2719152015-05-28 09:44:41 -05001936 if (Length != 0) {
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001937 unsigned long long Actual_Size = IOCTL_Get_Block_Size();
1938 if (Actual_Size == 0)
1939 return false;
Ethan Yonkera2719152015-05-28 09:44:41 -05001940
Ethan Yonkera2719152015-05-28 09:44:41 -05001941 unsigned long long Block_Count;
1942 if (Length < 0) {
1943 // Reduce overall size by this length
1944 Block_Count = (Actual_Size / 1024LLU) - ((unsigned long long)(Length * -1) / 1024LLU);
1945 } else {
1946 // This is the size, not a size reduction
1947 Block_Count = ((unsigned long long)(Length) / 1024LLU);
1948 }
1949 char temp[256];
1950 sprintf(temp, "%llu", Block_Count);
1951 command += " ";
1952 command += temp;
1953 command += "K";
1954 }
1955 LOGINFO("Resize command: %s\n", command.c_str());
1956 if (TWFunc::Exec_Cmd(command) == 0) {
1957 Update_Size(true);
Ethan Yonker74db1572015-10-28 12:44:49 -05001958 gui_msg("done=Done.");
Ethan Yonkera2719152015-05-28 09:44:41 -05001959 return true;
1960 } else {
1961 Update_Size(true);
Ethan Yonker74db1572015-10-28 12:44:49 -05001962 gui_msg(Msg(msg::kError, "unable_resize=Unable to resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001963 return false;
1964 }
1965 }
1966 return false;
1967}
1968
bigbiffce8f83c2015-12-12 18:30:21 -05001969bool TWPartition::Backup(PartitionSettings *part_settings, pid_t *tar_fork_pid) {
1970 if (Backup_Method == BM_FILES)
1971 return Backup_Tar(part_settings, tar_fork_pid);
1972 else if (Backup_Method == BM_DD)
1973 return Backup_Image(part_settings);
1974 else if (Backup_Method == BM_FLASH_UTILS)
1975 return Backup_Dump_Image(part_settings);
Dees_Troy2673cec2013-04-02 20:22:16 +00001976 LOGERR("Unknown backup method for '%s'\n", Mount_Point.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001977 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001978}
1979
bigbiffce8f83c2015-12-12 18:30:21 -05001980bool TWPartition::Restore(PartitionSettings *part_settings) {
Matt Mower3c366972015-12-25 19:28:31 -06001981 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Display_Name, gui_parse_text("{@restoring_hdr}"));
Ethan Yonkere080c1f2016-09-19 13:50:25 -05001982 LOGINFO("Restore filename is: %s/%s\n", part_settings->Backup_Folder.c_str(), Backup_FileName.c_str());
Gary Peck43acadf2012-11-21 21:19:01 -08001983
bigbiffce8f83c2015-12-12 18:30:21 -05001984 string Restore_File_System = Get_Restore_File_System(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001985
1986 if (Is_File_System(Restore_File_System))
bigbiffce8f83c2015-12-12 18:30:21 -05001987 return Restore_Tar(part_settings);
1988 else if (Is_Image(Restore_File_System))
1989 return Restore_Image(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001990
1991 LOGERR("Unknown restore method for '%s'\n", Mount_Point.c_str());
1992 return false;
1993}
1994
bigbiffce8f83c2015-12-12 18:30:21 -05001995string TWPartition::Get_Restore_File_System(PartitionSettings *part_settings) {
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001996 size_t first_period, second_period;
1997 string Restore_File_System;
1998
Gary Peck43acadf2012-11-21 21:19:01 -08001999 // Parse backup filename to extract the file system before wiping
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002000 first_period = Backup_FileName.find(".");
Gary Peck43acadf2012-11-21 21:19:01 -08002001 if (first_period == string::npos) {
Dees_Troy2673cec2013-04-02 20:22:16 +00002002 LOGERR("Unable to find file system (first period).\n");
thatd43bf2d2014-09-21 23:13:02 +02002003 return string();
Gary Peck43acadf2012-11-21 21:19:01 -08002004 }
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002005 Restore_File_System = Backup_FileName.substr(first_period + 1, Backup_FileName.size() - first_period - 1);
Gary Peck43acadf2012-11-21 21:19:01 -08002006 second_period = Restore_File_System.find(".");
2007 if (second_period == string::npos) {
Dees_Troy2673cec2013-04-02 20:22:16 +00002008 LOGERR("Unable to find file system (second period).\n");
thatd43bf2d2014-09-21 23:13:02 +02002009 return string();
Gary Peck43acadf2012-11-21 21:19:01 -08002010 }
2011 Restore_File_System.resize(second_period);
Matt Mowera0cd91d2016-12-30 18:21:42 -06002012 LOGINFO("Restore file system is: '%s'.\n", Restore_File_System.c_str());
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002013 return Restore_File_System;
Dees_Troy51a0e822012-09-05 15:24:24 -04002014}
2015
2016string TWPartition::Backup_Method_By_Name() {
bigbiffce8f83c2015-12-12 18:30:21 -05002017 if (Backup_Method == BM_NONE)
Dees_Troy38bd7602012-09-14 13:33:53 -04002018 return "none";
bigbiffce8f83c2015-12-12 18:30:21 -05002019 else if (Backup_Method == BM_FILES)
Dees_Troy38bd7602012-09-14 13:33:53 -04002020 return "files";
bigbiffce8f83c2015-12-12 18:30:21 -05002021 else if (Backup_Method == BM_DD)
Dees_Troy38bd7602012-09-14 13:33:53 -04002022 return "dd";
bigbiffce8f83c2015-12-12 18:30:21 -05002023 else if (Backup_Method == BM_FLASH_UTILS)
Dees_Troy38bd7602012-09-14 13:33:53 -04002024 return "flash_utils";
2025 else
2026 return "undefined";
2027 return "ERROR!";
Dees_Troy51a0e822012-09-05 15:24:24 -04002028}
2029
2030bool TWPartition::Decrypt(string Password) {
Dees_Troy2673cec2013-04-02 20:22:16 +00002031 LOGINFO("STUB TWPartition::Decrypt, password: '%s'\n", Password.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04002032 // Is this needed?
Dees_Troy51a0e822012-09-05 15:24:24 -04002033 return 1;
2034}
2035
2036bool TWPartition::Wipe_Encryption() {
Dees_Troy38bd7602012-09-14 13:33:53 -04002037 bool Save_Data_Media = Has_Data_Media;
Ethan Yonker93382822018-11-01 15:25:31 -05002038 bool ret = false;
2039 BasePartition* base_partition = make_partition();
2040
2041 if (!base_partition->PreWipeEncryption())
2042 goto exit;
Dees_Troy38bd7602012-09-14 13:33:53 -04002043
dianlujitao4879b372018-12-03 18:45:47 +08002044 Find_Actual_Block_Device();
2045 if (!Is_Present) {
2046 LOGINFO("Block device not present, cannot format %s.\n", Display_Name.c_str());
2047 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2048 return false;
2049 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002050
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06002051#ifdef TW_INCLUDE_CRYPTO
bigbiff7ba75002020-04-11 20:47:09 -04002052 if (!UnMount(true))
2053 return false;
Ethan Yonker1b190162016-12-05 15:25:19 -06002054 if (Is_Decrypted && !Decrypted_Block_Device.empty()) {
Matt Mower2b18a532015-02-20 16:58:05 -06002055 if (delete_crypto_blk_dev((char*)("userdata")) != 0) {
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06002056 LOGERR("Error deleting crypto block device, continuing anyway.\n");
2057 }
2058 }
2059#endif
dianlujitao4879b372018-12-03 18:45:47 +08002060 Has_Data_Media = false;
Ethan Yonker93382822018-11-01 15:25:31 -05002061 Decrypted_Block_Device = "";
Dees_Troy74fb2e92013-04-15 14:35:47 +00002062 Is_Decrypted = false;
2063 Is_Encrypted = false;
Gary Pecke8bc5d72012-12-21 06:45:25 -08002064 if (Wipe(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002065 Has_Data_Media = Save_Data_Media;
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06002066 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
Ethan Yonker83e82572014-04-04 10:59:28 -05002067#ifndef TW_OEM_BUILD
bigbiff25d25b92020-06-19 16:07:38 -04002068 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 -05002069#endif
bigbiff2d548672021-07-09 20:08:44 -04002070 if (Is_FBE) {
2071 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 -04002072 } else {
2073 if (Has_Data_Media && !Symlink_Mount_Point.empty()) {
2074 if (Mount(false))
2075 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
2076 }
bigbiff2d548672021-07-09 20:08:44 -04002077 }
2078
Ethan Yonker93382822018-11-01 15:25:31 -05002079 ret = true;
2080 if (!Key_Directory.empty())
2081 ret = PartitionManager.Wipe_By_Path(Key_Directory);
2082 if (ret)
2083 ret = base_partition->PostWipeEncryption();
2084 goto exit;
Dees_Troy38bd7602012-09-14 13:33:53 -04002085 } else {
2086 Has_Data_Media = Save_Data_Media;
Ethan Yonker74db1572015-10-28 12:44:49 -05002087 gui_err("format_data_err=Unable to format to remove encryption.");
Ethan Yonker726a0202014-12-16 20:01:38 -06002088 if (Has_Data_Media && Mount(false))
2089 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
Ethan Yonker93382822018-11-01 15:25:31 -05002090 goto exit;
Dees_Troy38bd7602012-09-14 13:33:53 -04002091 }
Ethan Yonker93382822018-11-01 15:25:31 -05002092exit:
2093 delete base_partition;
2094 return ret;
Dees_Troy51a0e822012-09-05 15:24:24 -04002095}
2096
2097void TWPartition::Check_FS_Type() {
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002098 const char* type;
2099 blkid_probe pr;
Dees_Troy5bf43922012-09-07 16:07:55 -04002100
Dees_Troy68cab492012-12-12 19:29:35 +00002101 if (Fstab_File_System == "yaffs2" || Fstab_File_System == "mtd" || Fstab_File_System == "bml" || Ignore_Blkid)
2102 return; // Running blkid on some mtd devices causes a massive crash or needs to be skipped
Dees_Troy5bf43922012-09-07 16:07:55 -04002103
Dees_Troy38bd7602012-09-14 13:33:53 -04002104 Find_Actual_Block_Device();
Dees_Troy8170a922012-09-18 15:40:25 -04002105 if (!Is_Present)
2106 return;
Dees_Troy51127312012-09-08 13:08:49 -04002107
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002108 pr = blkid_new_probe_from_filename(Actual_Block_Device.c_str());
2109 if (blkid_do_fullprobe(pr)) {
2110 blkid_free_probe(pr);
Dees_Troy2673cec2013-04-02 20:22:16 +00002111 LOGINFO("Can't probe device %s\n", Actual_Block_Device.c_str());
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002112 return;
Dees_Troy5bf43922012-09-07 16:07:55 -04002113 }
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02002114
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05002115 if (blkid_probe_lookup_value(pr, "TYPE", &type, NULL) < 0) {
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002116 blkid_free_probe(pr);
Dees_Troy2673cec2013-04-02 20:22:16 +00002117 LOGINFO("can't find filesystem on device %s\n", Actual_Block_Device.c_str());
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002118 return;
2119 }
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02002120
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002121 Current_File_System = type;
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02002122 blkid_free_probe(pr);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002123 if (fs_flags.size() > 1) {
2124 std::vector<partition_fs_flags_struct>::iterator iter;
2125 std::vector<partition_fs_flags_struct>::iterator found = fs_flags.begin();
2126
2127 for (iter = fs_flags.begin(); iter != fs_flags.end(); iter++) {
2128 if (iter->File_System == Current_File_System) {
2129 found = iter;
2130 break;
2131 }
2132 }
2133 // If we don't find a match, we default the flags to the first set of flags that we received from the fstab
2134 if (Mount_Flags != found->Mount_Flags || Mount_Options != found->Mount_Options) {
2135 Mount_Flags = found->Mount_Flags;
2136 Mount_Options = found->Mount_Options;
2137 LOGINFO("Mount_Flags: %i, Mount_Options: %s\n", Mount_Flags, Mount_Options.c_str());
2138 }
2139 }
Dees_Troy51a0e822012-09-05 15:24:24 -04002140}
2141
dianlujitao4879b372018-12-03 18:45:47 +08002142bool TWPartition::Wipe_EXTFS(string File_System) {
bigbiff7ba75002020-04-11 20:47:09 -04002143 if (!UnMount(true))
2144 return false;
2145
dianlujitao4879b372018-12-03 18:45:47 +08002146#if PLATFORM_SDK_VERSION < 28
bigbiffad58e1b2020-07-06 20:24:34 -04002147 if (!TWFunc::Path_Exists("/system/bin/mke2fs"))
dianlujitao4879b372018-12-03 18:45:47 +08002148#else
bigbiffad58e1b2020-07-06 20:24:34 -04002149 if (!TWFunc::Path_Exists("/system/bin/mke2fs") || !TWFunc::Path_Exists("/system/bin/e2fsdroid"))
dianlujitao4879b372018-12-03 18:45:47 +08002150#endif
Dees_Troy38bd7602012-09-14 13:33:53 -04002151 return Wipe_RMRF();
2152
dianlujitao4879b372018-12-03 18:45:47 +08002153 int ret;
2154 bool NeedPreserveFooter = true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002155
Ethan Yonker25f20c12014-10-14 09:04:43 -05002156 Find_Actual_Block_Device();
2157 if (!Is_Present) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002158 LOGINFO("Block device not present, cannot wipe %s.\n", Display_Name.c_str());
2159 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Ethan Yonker25f20c12014-10-14 09:04:43 -05002160 return false;
2161 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002162
dianlujitao4879b372018-12-03 18:45:47 +08002163 /**
2164 * On decrypted devices, IOCTL_Get_Block_Size calculates size on device mapper,
2165 * so there's no need to preserve footer.
2166 */
2167 if ((Is_Decrypted && !Decrypted_Block_Device.empty()) ||
2168 Crypto_Key_Location != "footer") {
2169 NeedPreserveFooter = false;
2170 }
2171
2172 unsigned long long dev_sz = TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
2173 if (!dev_sz)
2174 return false;
2175
2176 if (NeedPreserveFooter)
2177 Length < 0 ? dev_sz += Length : dev_sz -= CRYPT_FOOTER_OFFSET;
2178
Dees Troy9a4d7402019-03-21 14:17:28 -04002179 char dout[16];
2180 sprintf(dout, "%llu", dev_sz / 4096);
2181
2182 //string size_str =to_string(dev_sz / 4096);
2183 string size_str = dout;
dianlujitao4879b372018-12-03 18:45:47 +08002184 string Command;
2185
2186 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mke2fs"));
2187
2188 // Execute mke2fs to create empty ext4 filesystem
2189 Command = "mke2fs -t " + File_System + " -b 4096 " + Actual_Block_Device + " " + size_str;
2190 LOGINFO("mke2fs command: %s\n", Command.c_str());
2191 ret = TWFunc::Exec_Cmd(Command);
2192 if (ret) {
2193 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2194 return false;
2195 }
2196
bigbiffad58e1b2020-07-06 20:24:34 -04002197 if (TWFunc::Path_Exists("/system/bin/e2fsdroid")) {
dianlujitao3cf05a52019-05-15 15:33:27 +08002198 const string& File_Contexts_Entry = (Mount_Point == "/system_root" ? "/" : Mount_Point);
2199 char *secontext = NULL;
2200 if (!selinux_handle || selabel_lookup(selinux_handle, &secontext, File_Contexts_Entry.c_str(), S_IFDIR) < 0) {
2201 LOGINFO("Cannot lookup security context for '%s'\n", Mount_Point.c_str());
2202 } else {
2203 // Execute e2fsdroid to initialize selinux context
bigbiff5b911ca2020-07-18 10:46:09 -04002204 if (Mount_Point == "/persist") {
2205 Mount(true);
2206 TWFunc::removeDir("/persist/lost+found", false);
2207 UnMount(true);
2208 }
dianlujitao3cf05a52019-05-15 15:33:27 +08002209 Command = "e2fsdroid -e -S /file_contexts -a " + File_Contexts_Entry + " " + Actual_Block_Device;
2210 LOGINFO("e2fsdroid command: %s\n", Command.c_str());
2211 ret = TWFunc::Exec_Cmd(Command);
2212 if (ret) {
2213 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2214 return false;
2215 }
dianlujitao4879b372018-12-03 18:45:47 +08002216 }
2217 } else {
2218 LOGINFO("e2fsdroid not present\n");
2219 }
2220
2221 if (NeedPreserveFooter)
2222 Wipe_Crypto_Key();
2223 Current_File_System = File_System;
2224 Recreate_AndSec_Folder();
2225 gui_msg("done=Done.");
2226 return true;
2227}
2228
2229bool TWPartition::Wipe_EXT4() {
2230#ifdef USE_EXT4
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002231 int ret;
dianlujitao4879b372018-12-03 18:45:47 +08002232 bool NeedPreserveFooter = true;
2233
bigbiff7ba75002020-04-11 20:47:09 -04002234 if (!UnMount(true))
2235 return false;
2236
dianlujitao4879b372018-12-03 18:45:47 +08002237 Find_Actual_Block_Device();
2238 if (!Is_Present) {
2239 LOGINFO("Block device not present, cannot wipe %s.\n", Display_Name.c_str());
2240 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2241 return false;
2242 }
dianlujitao4879b372018-12-03 18:45:47 +08002243
2244 /**
2245 * On decrypted devices, IOCTL_Get_Block_Size calculates size on device mapper,
2246 * so there's no need to preserve footer.
2247 */
2248 if ((Is_Decrypted && !Decrypted_Block_Device.empty()) ||
2249 Crypto_Key_Location != "footer") {
2250 NeedPreserveFooter = false;
2251 }
2252
2253 unsigned long long dev_sz = TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
2254 if (!dev_sz)
2255 return false;
2256
2257 if (NeedPreserveFooter)
2258 Length < 0 ? dev_sz += Length : dev_sz -= CRYPT_FOOTER_OFFSET;
2259
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002260 char *secontext = NULL;
2261
Greg Wallace4b44fef2015-12-29 15:33:24 -05002262 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("make_ext4fs"));
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002263
Dees Troy99c8dbf2014-03-10 16:53:58 +00002264 if (!selinux_handle || selabel_lookup(selinux_handle, &secontext, Mount_Point.c_str(), S_IFDIR) < 0) {
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002265 LOGINFO("Cannot lookup security context for '%s'\n", Mount_Point.c_str());
dianlujitao4879b372018-12-03 18:45:47 +08002266 ret = make_ext4fs(Actual_Block_Device.c_str(), dev_sz, Mount_Point.c_str(), NULL);
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002267 } else {
dianlujitao4879b372018-12-03 18:45:47 +08002268 ret = make_ext4fs(Actual_Block_Device.c_str(), dev_sz, Mount_Point.c_str(), selinux_handle);
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002269 }
2270 if (ret != 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002271 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troya95f55c2013-08-17 13:14:43 +00002272 return false;
2273 } else {
dianlujitao4879b372018-12-03 18:45:47 +08002274 if (NeedPreserveFooter)
2275 Wipe_Crypto_Key();
bigbiff bigbiffc49d7062013-10-11 20:28:00 -04002276 string sedir = Mount_Point + "/lost+found";
2277 PartitionManager.Mount_By_Path(sedir.c_str(), true);
2278 rmdir(sedir.c_str());
2279 mkdir(sedir.c_str(), S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP);
Dees_Troya95f55c2013-08-17 13:14:43 +00002280 return true;
2281 }
2282#else
dianlujitao4879b372018-12-03 18:45:47 +08002283 return Wipe_EXTFS("ext4");
Dees_Troya95f55c2013-08-17 13:14:43 +00002284#endif
Dees_Troy51a0e822012-09-05 15:24:24 -04002285}
2286
2287bool TWPartition::Wipe_FAT() {
Vojtech Bocek05534202013-09-11 08:11:56 +02002288 string command;
Dees_Troy38bd7602012-09-14 13:33:53 -04002289
bigbiff7ba75002020-04-11 20:47:09 -04002290 if (!UnMount(true))
2291 return false;
Dees_Troy38bd7602012-09-14 13:33:53 -04002292
bigbiffad58e1b2020-07-06 20:24:34 -04002293 if (TWFunc::Path_Exists("/system/bin/mkfs.fat")) {
Greg Wallace4b44fef2015-12-29 15:33:24 -05002294 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mkfs.fat"));
Dees_Troy38bd7602012-09-14 13:33:53 -04002295 Find_Actual_Block_Device();
Matt Mower18794c82015-11-11 16:22:45 -06002296 command = "mkfs.fat " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02002297 if (TWFunc::Exec_Cmd(command) == 0) {
Gary Pecke8bc5d72012-12-21 06:45:25 -08002298 Current_File_System = "vfat";
Dees_Troye58d5262012-09-21 12:27:57 -04002299 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002300 gui_msg("done=Done.");
Dees_Troy38bd7602012-09-14 13:33:53 -04002301 return true;
2302 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002303 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04002304 return false;
2305 }
2306 return true;
2307 }
2308 else
2309 return Wipe_RMRF();
2310
2311 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04002312}
2313
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002314bool TWPartition::Wipe_EXFAT() {
Vojtech Bocek05534202013-09-11 08:11:56 +02002315 string command;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002316
bigbiff7ba75002020-04-11 20:47:09 -04002317 if (!UnMount(true))
2318 return false;
bigbiffad58e1b2020-07-06 20:24:34 -04002319 if (TWFunc::Path_Exists("/system/bin/mkexfatfs")) {
Greg Wallace4b44fef2015-12-29 15:33:24 -05002320 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mkexfatfs"));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002321 Find_Actual_Block_Device();
2322 command = "mkexfatfs " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02002323 if (TWFunc::Exec_Cmd(command) == 0) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002324 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002325 gui_msg("done=Done.");
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002326 return true;
2327 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002328 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002329 return false;
2330 }
2331 return true;
2332 }
2333 return false;
2334}
2335
Dees_Troy38bd7602012-09-14 13:33:53 -04002336bool TWPartition::Wipe_MTD() {
2337 if (!UnMount(true))
2338 return false;
2339
Greg Wallace4b44fef2015-12-29 15:33:24 -05002340 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("MTD"));
Dees_Troy38bd7602012-09-14 13:33:53 -04002341
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002342 mtd_scan_partitions();
2343 const MtdPartition* mtd = mtd_find_partition_by_name(MTD_Name.c_str());
2344 if (mtd == NULL) {
2345 LOGERR("No mtd partition named '%s'", MTD_Name.c_str());
2346 return false;
2347 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002348
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002349 MtdWriteContext* ctx = mtd_write_partition(mtd);
2350 if (ctx == NULL) {
2351 LOGERR("Can't write '%s', failed to format.", MTD_Name.c_str());
2352 return false;
2353 }
2354 if (mtd_erase_blocks(ctx, -1) == -1) {
2355 mtd_write_close(ctx);
2356 LOGERR("Failed to format '%s'", MTD_Name.c_str());
2357 return false;
2358 }
2359 if (mtd_write_close(ctx) != 0) {
2360 LOGERR("Failed to close '%s'", MTD_Name.c_str());
2361 return false;
2362 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08002363 Current_File_System = "yaffs2";
Dees_Troye58d5262012-09-21 12:27:57 -04002364 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002365 gui_msg("done=Done.");
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002366 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002367}
2368
2369bool TWPartition::Wipe_RMRF() {
Dees_Troy38bd7602012-09-14 13:33:53 -04002370 if (!Mount(true))
2371 return false;
Ethan Yonker726a0202014-12-16 20:01:38 -06002372 // This is the only wipe that leaves the partition mounted, so we
2373 // must manually remove the partition from MTP if it is a storage
2374 // partition.
2375 if (Is_Storage)
2376 PartitionManager.Remove_MTP_Storage(MTP_Storage_ID);
Dees_Troy38bd7602012-09-14 13:33:53 -04002377
Ethan Yonker74db1572015-10-28 12:44:49 -05002378 gui_msg(Msg("remove_all=Removing all files under '{1}'")(Mount_Point));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002379 TWFunc::removeDir(Mount_Point, true);
Dees_Troye58d5262012-09-21 12:27:57 -04002380 Recreate_AndSec_Folder();
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002381 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002382}
2383
Dees_Troye5017042013-08-29 16:38:55 +00002384bool TWPartition::Wipe_F2FS() {
systemaddb475c92021-08-12 20:33:20 +02002385 std::string f2fs_command;
Dees_Troye5017042013-08-29 16:38:55 +00002386
bigbiff7ba75002020-04-11 20:47:09 -04002387 if (!UnMount(true))
2388 return false;
dianlujitao4879b372018-12-03 18:45:47 +08002389
bigbiffad58e1b2020-07-06 20:24:34 -04002390 if (TWFunc::Path_Exists("/system/bin/mkfs.f2fs"))
systemaddb475c92021-08-12 20:33:20 +02002391 f2fs_command = "/system/bin/mkfs.f2fs";
bigbiffad58e1b2020-07-06 20:24:34 -04002392 else if (TWFunc::Path_Exists("/system/bin/make_f2fs"))
systemaddb475c92021-08-12 20:33:20 +02002393 f2fs_command = "/system/bin/make_f2fs -g android";
bigbiff7ba75002020-04-11 20:47:09 -04002394 else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002395 LOGINFO("mkfs.f2fs binary not found, using rm -rf to wipe.\n");
Dees_Troye5017042013-08-29 16:38:55 +00002396 return Wipe_RMRF();
2397 }
bigbiff7ba75002020-04-11 20:47:09 -04002398
2399 bool NeedPreserveFooter = true;
systemaddb475c92021-08-12 20:33:20 +02002400 bool needs_casefold = false;
2401 bool needs_projid = false;
bigbiff7ba75002020-04-11 20:47:09 -04002402
2403 Find_Actual_Block_Device();
2404 if (!Is_Present) {
2405 LOGINFO("Block device not present, cannot wipe %s.\n", Display_Name.c_str());
2406 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2407 return false;
2408 }
systemaddb475c92021-08-12 20:33:20 +02002409
2410 needs_casefold = android::base::GetBoolProperty("external_storage.casefold.enabled", false);
2411 needs_projid = android::base::GetBoolProperty("external_storage.projid.enabled", false);
bigbiff7ba75002020-04-11 20:47:09 -04002412 unsigned long long dev_sz = TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
2413 if (!dev_sz)
2414 return false;
2415
2416 if (NeedPreserveFooter)
2417 Length < 0 ? dev_sz += Length : dev_sz -= CRYPT_FOOTER_OFFSET;
bigbiff7ba75002020-04-11 20:47:09 -04002418 char dev_sz_str[48];
2419 sprintf(dev_sz_str, "%llu", (dev_sz / 4096));
systemaddb475c92021-08-12 20:33:20 +02002420 if(needs_projid)
2421 f2fs_command += " -O project_quota,extra_attr";
2422
2423 if(needs_casefold)
2424 f2fs_command += " -O casefold -C utf8";
2425
2426 f2fs_command += " " + Actual_Block_Device + " " + dev_sz_str;
2427
bigbiffad58e1b2020-07-06 20:24:34 -04002428 if (TWFunc::Path_Exists("/system/bin/sload.f2fs")) {
systemaddb475c92021-08-12 20:33:20 +02002429 f2fs_command += " && sload.f2fs -t /data " + Actual_Block_Device;
bigbiff7ba75002020-04-11 20:47:09 -04002430 }
2431
2432 /**
2433 * On decrypted devices, IOCTL_Get_Block_Size calculates size on device mapper,
2434 * so there's no need to preserve footer.
2435 */
2436 if ((Is_Decrypted && !Decrypted_Block_Device.empty()) ||
2437 Crypto_Key_Location != "footer") {
2438 NeedPreserveFooter = false;
2439 }
systemaddb475c92021-08-12 20:33:20 +02002440 LOGINFO("mkfs.f2fs command: %s\n", f2fs_command.c_str());
2441 if (TWFunc::Exec_Cmd(f2fs_command) == 0) {
bigbiff7ba75002020-04-11 20:47:09 -04002442 if (NeedPreserveFooter)
2443 Wipe_Crypto_Key();
2444 Recreate_AndSec_Folder();
2445 gui_msg("done=Done.");
2446 return true;
2447 } else {
2448 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2449 return false;
2450 }
2451 return true;
Dees_Troye5017042013-08-29 16:38:55 +00002452}
2453
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002454bool TWPartition::Wipe_NTFS() {
2455 string command;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002456 string Ntfsmake_Binary;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002457
bigbiff7ba75002020-04-11 20:47:09 -04002458 if (!UnMount(true))
2459 return false;
2460
bigbiffad58e1b2020-07-06 20:24:34 -04002461 if (TWFunc::Path_Exists("/system/bin/mkntfs"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002462 Ntfsmake_Binary = "mkntfs";
bigbiffad58e1b2020-07-06 20:24:34 -04002463 else if (TWFunc::Path_Exists("/system/bin/mkfs.ntfs"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002464 Ntfsmake_Binary = "mkfs.ntfs";
2465 else
2466 return false;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002467
Greg Wallace4b44fef2015-12-29 15:33:24 -05002468 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)(Ntfsmake_Binary));
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002469 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04002470 command = "/system/bin/" + Ntfsmake_Binary + " " + Actual_Block_Device;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002471 if (TWFunc::Exec_Cmd(command) == 0) {
2472 Recreate_AndSec_Folder();
2473 gui_msg("done=Done.");
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002474 return true;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002475 } else {
2476 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2477 return false;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002478 }
2479 return false;
2480}
2481
Dees_Troy51a0e822012-09-05 15:24:24 -04002482bool TWPartition::Wipe_Data_Without_Wiping_Media() {
Ethan Yonker83e82572014-04-04 10:59:28 -05002483#ifdef TW_OEM_BUILD
2484 // In an OEM Build we want to do a full format
2485 return Wipe_Encryption();
2486#else
Ethan Yonker66a19492015-12-10 10:19:45 -06002487 bool ret = false;
Dees_Troy38bd7602012-09-14 13:33:53 -04002488
Dees_Troy38bd7602012-09-14 13:33:53 -04002489 if (!Mount(true))
2490 return false;
2491
Ethan Yonker74db1572015-10-28 12:44:49 -05002492 gui_msg("wiping_data=Wiping data without wiping /data/media ...");
Ethan Yonker66a19492015-12-10 10:19:45 -06002493 ret = Wipe_Data_Without_Wiping_Media_Func(Mount_Point + "/");
2494 if (ret)
2495 gui_msg("done=Done.");
2496 return ret;
2497#endif // ifdef TW_OEM_BUILD
2498}
2499
2500bool TWPartition::Wipe_Data_Without_Wiping_Media_Func(const string& parent __unused) {
2501 string dir;
Dees_Troy38bd7602012-09-14 13:33:53 -04002502
2503 DIR* d;
Ethan Yonker66a19492015-12-10 10:19:45 -06002504 d = opendir(parent.c_str());
Dees_Troy16b74352012-11-14 22:27:31 +00002505 if (d != NULL) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002506 struct dirent* de;
2507 while ((de = readdir(d)) != NULL) {
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05002508 if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) continue;
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05002509
Ethan Yonker66a19492015-12-10 10:19:45 -06002510 dir = parent;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002511 dir.append(de->d_name);
Ethan Yonker3fdcda42016-11-30 12:29:37 -06002512 if (wipe_exclusions.check_skip_dirs(dir)) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002513 LOGINFO("skipped '%s'\n", dir.c_str());
2514 continue;
2515 }
Dees_Troyce675462013-01-09 19:48:21 +00002516 if (de->d_type == DT_DIR) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002517 dir.append("/");
2518 if (!Wipe_Data_Without_Wiping_Media_Func(dir)) {
2519 closedir(d);
2520 return false;
2521 }
2522 rmdir(dir.c_str());
bigbiff bigbiff98f1f902013-01-19 18:46:13 -05002523 } 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 +03002524 if (unlink(dir.c_str()) != 0)
Ethan Yonker79f88bd2016-12-09 14:52:12 -06002525 LOGINFO("Unable to unlink '%s': %s\n", dir.c_str(), strerror(errno));
Dees_Troyce675462013-01-09 19:48:21 +00002526 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002527 }
2528 closedir(d);
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05002529
Dees_Troy16b74352012-11-14 22:27:31 +00002530 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -04002531 }
Ethan Yonker74db1572015-10-28 12:44:49 -05002532 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy16b74352012-11-14 22:27:31 +00002533 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04002534}
2535
dianlujitao4879b372018-12-03 18:45:47 +08002536void TWPartition::Wipe_Crypto_Key() {
2537 Find_Actual_Block_Device();
2538 if (Crypto_Key_Location.empty())
2539 return;
2540 else if (Crypto_Key_Location == "footer") {
2541 int fd = open(Actual_Block_Device.c_str(), O_RDWR);
2542 if (fd < 0) {
2543 gui_print_color("warning", "Unable to open '%s' to wipe crypto key\n", Actual_Block_Device.c_str());
2544 return;
2545 }
2546
2547 unsigned int block_count;
2548 if ((ioctl(fd, BLKGETSIZE, &block_count)) == -1) {
2549 gui_print_color("warning", "Unable to get block size for wiping crypto footer.\n");
2550 } else {
2551 int newlen = Length < 0 ? -Length : CRYPT_FOOTER_OFFSET;
2552 off64_t offset = ((off64_t)block_count * 512) - newlen;
2553 if (lseek64(fd, offset, SEEK_SET) == -1) {
2554 gui_print_color("warning", "Unable to lseek64 for wiping crypto footer.\n");
2555 } else {
2556 void* buffer = malloc(newlen);
2557 if (!buffer) {
2558 gui_print_color("warning", "Failed to malloc for wiping crypto footer.\n");
2559 } else {
2560 memset(buffer, 0, newlen);
2561 int ret = write(fd, buffer, newlen);
2562 if (ret != newlen) {
2563 gui_print_color("warning", "Failed to wipe crypto footer.\n");
2564 } else {
2565 LOGINFO("Successfully wiped crypto footer.\n");
2566 }
2567 free(buffer);
2568 }
2569 }
2570 }
2571 close(fd);
2572 } else {
2573 if (TWFunc::IOCTL_Get_Block_Size(Crypto_Key_Location.c_str()) >= 16384LLU) {
2574 string Command = "dd of='" + Crypto_Key_Location + "' if=/dev/zero bs=16384 count=1";
2575 TWFunc::Exec_Cmd(Command);
2576 } else {
2577 LOGINFO("Crypto key location reports size < 16K so not wiping crypto footer.\n");
2578 }
2579 }
2580}
2581
bigbiffce8f83c2015-12-12 18:30:21 -05002582bool TWPartition::Backup_Tar(PartitionSettings *part_settings, pid_t *tar_fork_pid) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002583 string Full_FileName;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002584 twrpTar tar;
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -05002585
Dees_Troy43d8b002012-09-17 16:00:01 -04002586 if (!Mount(true))
2587 return false;
2588
Ian Macdonalda3b25a32019-06-16 22:39:14 +02002589 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Backup_Display_Name, gui_parse_text("{@backing}"));
Ethan Yonker74db1572015-10-28 12:44:49 -05002590 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002591
Ethan Yonker472f5062016-02-25 13:47:30 -06002592 DataManager::GetValue(TW_USE_COMPRESSION_VAR, tar.use_compression);
Matt Mowerbb81e5d2014-03-20 18:05:41 -05002593
Dees_Troy83bd4832013-05-04 12:39:56 +00002594#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
Ethan Yonker472f5062016-02-25 13:47:30 -06002595 if (Can_Encrypt_Backup) {
2596 DataManager::GetValue("tw_encrypt_backup", tar.use_encryption);
2597 if (tar.use_encryption) {
2598 if (Use_Userdata_Encryption)
2599 tar.userdata_encryption = tar.use_encryption;
2600 string Password;
2601 DataManager::GetValue("tw_backup_password", Password);
2602 tar.setpassword(Password);
2603 } else {
2604 tar.use_encryption = 0;
2605 }
Dees_Troy83bd4832013-05-04 12:39:56 +00002606 }
2607#endif
Dees_Troy43d8b002012-09-17 16:00:01 -04002608
Ethan Yonker472f5062016-02-25 13:47:30 -06002609 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002610 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Ethan Yonker01f4e032017-02-03 15:30:52 -06002611 if (Has_Data_Media)
2612 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 -04002613 if (Mount_Point == "/data" && DataManager::GetIntValue(TW_IS_FBE)) {
2614 std::vector<users_struct>::iterator iter;
2615 std::vector<users_struct>* userList = PartitionManager.Get_Users_List();
2616 for (iter = userList->begin(); iter != userList->end(); iter++) {
2617 if (!(*iter).isDecrypted && (*iter).userId != "0") {
2618 gui_msg(Msg(msg::kWarning,
2619 "backup_storage_undecrypt_warning=Backup will not include some files from user {1} "
2620 "because the user is not decrypted.")((*iter).userId));
2621 backup_exclusions.add_absolute_dir("/data/system_ce/" + (*iter).userId);
2622 backup_exclusions.add_absolute_dir("/data/misc_ce/" + (*iter).userId);
2623 backup_exclusions.add_absolute_dir("/data/vendor_ce/" + (*iter).userId);
2624 backup_exclusions.add_absolute_dir("/data/media/" + (*iter).userId);
2625 backup_exclusions.add_absolute_dir("/data/user/" + (*iter).userId);
2626 }
2627 }
2628 }
bigbiffce8f83c2015-12-12 18:30:21 -05002629 tar.part_settings = part_settings;
Ethan Yonker3fdcda42016-11-30 12:29:37 -06002630 tar.backup_exclusions = &backup_exclusions;
Dees Troye0a433a2013-12-02 04:10:37 +00002631 tar.setdir(Backup_Path);
2632 tar.setfn(Full_FileName);
2633 tar.setsize(Backup_Size);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002634 tar.partition_name = Backup_Name;
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002635 tar.backup_folder = part_settings->Backup_Folder;
bigbiffce8f83c2015-12-12 18:30:21 -05002636 if (tar.createTarFork(tar_fork_pid) != 0)
Dees Troye0a433a2013-12-02 04:10:37 +00002637 return false;
Dees_Troy43d8b002012-09-17 16:00:01 -04002638 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002639}
2640
bigbiffce8f83c2015-12-12 18:30:21 -05002641bool TWPartition::Backup_Image(PartitionSettings *part_settings) {
2642 string Full_FileName, adb_file_name;
igoriok87e3d932013-01-31 21:03:53 +02002643
Ethan Yonker74db1572015-10-28 12:44:49 -05002644 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, gui_parse_text("{@backing}"));
2645 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002646
Ethan Yonker472f5062016-02-25 13:47:30 -06002647 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
Dees_Troy43d8b002012-09-17 16:00:01 -04002648
bigbiffce8f83c2015-12-12 18:30:21 -05002649 if (part_settings->adbbackup) {
2650 Full_FileName = TW_ADB_BACKUP;
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002651 adb_file_name = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002652 }
2653 else
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002654 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002655
2656 part_settings->total_restore_size = Backup_Size;
2657
2658 if (part_settings->adbbackup) {
2659 if (!twadbbu::Write_TWIMG(adb_file_name, Backup_Size))
2660 return false;
2661 }
2662
2663 if (!Raw_Read_Write(part_settings))
Ethan Yonker472f5062016-02-25 13:47:30 -06002664 return false;
2665
bigbiffce8f83c2015-12-12 18:30:21 -05002666 if (part_settings->adbbackup) {
2667 if (!twadbbu::Write_TWEOF())
2668 return false;
Dees_Troy7c2dec82012-09-26 09:49:14 -04002669 }
Dees_Troy43d8b002012-09-17 16:00:01 -04002670 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002671}
2672
bigbiffce8f83c2015-12-12 18:30:21 -05002673bool TWPartition::Raw_Read_Write(PartitionSettings *part_settings) {
2674 unsigned long long RW_Block_Size, Remain = Backup_Size;
2675 int src_fd = -1, dest_fd = -1;
2676 ssize_t bs;
Ethan Yonker472f5062016-02-25 13:47:30 -06002677 bool ret = false;
2678 void* buffer = NULL;
2679 unsigned long long backedup_size = 0;
bigbiffce8f83c2015-12-12 18:30:21 -05002680 string srcfn, destfn;
Ethan Yonker472f5062016-02-25 13:47:30 -06002681
bigbiffce8f83c2015-12-12 18:30:21 -05002682 if (part_settings->PM_Method == PM_BACKUP) {
2683 srcfn = Actual_Block_Device;
2684 if (part_settings->adbbackup)
2685 destfn = TW_ADB_BACKUP;
bigbiff bigbiff38b83c12017-12-28 19:58:52 -05002686 else {
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002687 destfn = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiff bigbiff38b83c12017-12-28 19:58:52 -05002688 }
bigbiffce8f83c2015-12-12 18:30:21 -05002689 }
2690 else {
2691 destfn = Actual_Block_Device;
2692 if (part_settings->adbbackup) {
2693 srcfn = TW_ADB_RESTORE;
2694 } else {
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002695 srcfn = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002696 Remain = TWFunc::Get_File_Size(srcfn);
2697 }
2698 }
Ethan Yonker472f5062016-02-25 13:47:30 -06002699
bigbiffce8f83c2015-12-12 18:30:21 -05002700 src_fd = open(srcfn.c_str(), O_RDONLY | O_LARGEFILE);
Ethan Yonker472f5062016-02-25 13:47:30 -06002701 if (src_fd < 0) {
bigbiffce8f83c2015-12-12 18:30:21 -05002702 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(srcfn.c_str())(strerror(errno)));
Ethan Yonker472f5062016-02-25 13:47:30 -06002703 return false;
2704 }
bigbiffce8f83c2015-12-12 18:30:21 -05002705
2706 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 -06002707 if (dest_fd < 0) {
bigbiffce8f83c2015-12-12 18:30:21 -05002708 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(destfn.c_str())(strerror(errno)));
Ethan Yonker472f5062016-02-25 13:47:30 -06002709 goto exit;
2710 }
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04002711
bigbiffce8f83c2015-12-12 18:30:21 -05002712 LOGINFO("Reading '%s', writing '%s'\n", srcfn.c_str(), destfn.c_str());
2713
2714 if (part_settings->adbbackup) {
2715 RW_Block_Size = MAX_ADB_READ;
2716 bs = MAX_ADB_READ;
2717 }
2718 else {
2719 RW_Block_Size = 1048576LLU; // 1MB
2720 bs = (ssize_t)(RW_Block_Size);
2721 }
2722
Ethan Yonker472f5062016-02-25 13:47:30 -06002723 buffer = malloc((size_t)bs);
2724 if (!buffer) {
2725 LOGINFO("Raw_Read_Write failed to malloc\n");
2726 goto exit;
2727 }
bigbiffce8f83c2015-12-12 18:30:21 -05002728
2729 if (part_settings->progress)
2730 part_settings->progress->SetPartitionSize(part_settings->total_restore_size);
2731
Ethan Yonker472f5062016-02-25 13:47:30 -06002732 while (Remain > 0) {
2733 if (Remain < RW_Block_Size)
bigbiffce8f83c2015-12-12 18:30:21 -05002734 bs = (ssize_t)(Remain);
Matt Mowera8a89d12016-12-30 18:10:37 -06002735 if (read(src_fd, buffer, bs) != bs) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002736 LOGINFO("Error reading source fd (%s)\n", strerror(errno));
2737 goto exit;
2738 }
2739 if (write(dest_fd, buffer, bs) != bs) {
2740 LOGINFO("Error writing destination fd (%s)\n", strerror(errno));
2741 goto exit;
2742 }
2743 backedup_size += (unsigned long long)(bs);
Matt Mower029a82d2017-01-08 13:12:38 -06002744 Remain -= (unsigned long long)(bs);
bigbiffce8f83c2015-12-12 18:30:21 -05002745 if (part_settings->progress)
2746 part_settings->progress->UpdateSize(backedup_size);
Ethan Yonker472f5062016-02-25 13:47:30 -06002747 if (PartitionManager.Check_Backup_Cancel() != 0)
2748 goto exit;
2749 }
bigbiffce8f83c2015-12-12 18:30:21 -05002750 if (part_settings->progress)
2751 part_settings->progress->UpdateDisplayDetails(true);
Ethan Yonker472f5062016-02-25 13:47:30 -06002752 fsync(dest_fd);
nailyka083dc62016-11-11 21:41:28 +01002753
2754 if (!part_settings->adbbackup && part_settings->PM_Method == PM_BACKUP) {
2755 tw_set_default_metadata(destfn.c_str());
2756 LOGINFO("Restored default metadata for %s\n", destfn.c_str());
2757 }
2758
Ethan Yonker472f5062016-02-25 13:47:30 -06002759 ret = true;
2760exit:
2761 if (src_fd >= 0)
2762 close(src_fd);
2763 if (dest_fd >= 0)
2764 close(dest_fd);
2765 if (buffer)
2766 free(buffer);
2767 return ret;
2768}
2769
bigbiffce8f83c2015-12-12 18:30:21 -05002770bool TWPartition::Backup_Dump_Image(PartitionSettings *part_settings) {
Vojtech Bocek05534202013-09-11 08:11:56 +02002771 string Full_FileName, Command;
Dees_Troy43d8b002012-09-17 16:00:01 -04002772
Ethan Yonker74db1572015-10-28 12:44:49 -05002773 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, gui_parse_text("{@backing}"));
2774 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002775
bigbiffce8f83c2015-12-12 18:30:21 -05002776 if (part_settings->progress)
2777 part_settings->progress->SetPartitionSize(Backup_Size);
Dees_Troy43d8b002012-09-17 16:00:01 -04002778
Ethan Yonker472f5062016-02-25 13:47:30 -06002779 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002780 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Dees_Troy43d8b002012-09-17 16:00:01 -04002781
2782 Command = "dump_image " + MTD_Name + " '" + Full_FileName + "'";
bigbiffce8f83c2015-12-12 18:30:21 -05002783
Dees_Troy2673cec2013-04-02 20:22:16 +00002784 LOGINFO("Backup command: '%s'\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02002785 TWFunc::Exec_Cmd(Command);
Ethan Yonker4b94cfd2014-12-11 10:00:45 -06002786 tw_set_default_metadata(Full_FileName.c_str());
Dees_Troy7c2dec82012-09-26 09:49:14 -04002787 if (TWFunc::Get_File_Size(Full_FileName) == 0) {
2788 // 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 -06002789 gui_msg(Msg(msg::kError, "backup_size=Backup file size for '{1}' is 0 bytes.")(Full_FileName));
Dees_Troy7c2dec82012-09-26 09:49:14 -04002790 return false;
2791 }
bigbiffce8f83c2015-12-12 18:30:21 -05002792 if (part_settings->progress)
2793 part_settings->progress->UpdateSize(Backup_Size);
2794
Dees_Troy43d8b002012-09-17 16:00:01 -04002795 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002796}
2797
bigbiffce8f83c2015-12-12 18:30:21 -05002798unsigned long long TWPartition::Get_Restore_Size(PartitionSettings *part_settings) {
2799 if (!part_settings->adbbackup) {
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002800 InfoManager restore_info(part_settings->Backup_Folder + "/" + Backup_Name + ".info");
bigbiffce8f83c2015-12-12 18:30:21 -05002801 if (restore_info.LoadValues() == 0) {
2802 if (restore_info.GetValue("backup_size", Restore_Size) == 0) {
2803 LOGINFO("Read info file, restore size is %llu\n", Restore_Size);
2804 return Restore_Size;
2805 }
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002806 }
2807 }
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002808
Matt Mower029a82d2017-01-08 13:12:38 -06002809 string Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
2810 string Restore_File_System = Get_Restore_File_System(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002811
2812 if (Is_Image(Restore_File_System)) {
2813 Restore_Size = TWFunc::Get_File_Size(Full_FileName);
2814 return Restore_Size;
2815 }
2816
2817 twrpTar tar;
2818 tar.setdir(Backup_Path);
2819 tar.setfn(Full_FileName);
bigbiffce8f83c2015-12-12 18:30:21 -05002820 tar.backup_name = Full_FileName;
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002821#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
2822 string Password;
2823 DataManager::GetValue("tw_restore_password", Password);
2824 if (!Password.empty())
2825 tar.setpassword(Password);
2826#endif
2827 tar.partition_name = Backup_Name;
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002828 tar.backup_folder = part_settings->Backup_Folder;
bigbiffce8f83c2015-12-12 18:30:21 -05002829 tar.part_settings = part_settings;
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002830 Restore_Size = tar.get_size();
2831 return Restore_Size;
2832}
2833
bigbiffce8f83c2015-12-12 18:30:21 -05002834bool TWPartition::Restore_Tar(PartitionSettings *part_settings) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002835 string Full_FileName;
Dees Troy4159aed2014-02-28 17:24:43 +00002836 bool ret = false;
bigbiffce8f83c2015-12-12 18:30:21 -05002837 string Restore_File_System = Get_Restore_File_System(part_settings);
Dees_Troy43d8b002012-09-17 16:00:01 -04002838
Dees_Troye58d5262012-09-21 12:27:57 -04002839 if (Has_Android_Secure) {
Dees_Troye58d5262012-09-21 12:27:57 -04002840 if (!Wipe_AndSec())
2841 return false;
Gary Peck43acadf2012-11-21 21:19:01 -08002842 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002843 gui_msg(Msg("wiping=Wiping {1}")(Backup_Display_Name));
Ethan Yonker5eac2222014-06-11 12:22:55 -05002844 if (Has_Data_Media && Mount_Point == "/data" && Restore_File_System != Current_File_System) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002845 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 -05002846 if (!Wipe_Data_Without_Wiping_Media())
2847 return false;
2848 } else {
2849 if (!Wipe(Restore_File_System))
2850 return false;
2851 }
Dees_Troye58d5262012-09-21 12:27:57 -04002852 }
Matt Mower3c366972015-12-25 19:28:31 -06002853 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Backup_Display_Name, gui_parse_text("{@restoring_hdr}"));
Ethan Yonker74db1572015-10-28 12:44:49 -05002854 gui_msg(Msg("restoring=Restoring {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002855
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05002856 // Remount as read/write as needed so we can restore the backup
2857 if (!ReMount_RW(true))
Dees_Troy43d8b002012-09-17 16:00:01 -04002858 return false;
2859
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002860 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Ethan Yonker87af5632014-02-10 11:56:35 -06002861 twrpTar tar;
bigbiffce8f83c2015-12-12 18:30:21 -05002862 tar.part_settings = part_settings;
Ethan Yonker87af5632014-02-10 11:56:35 -06002863 tar.setdir(Backup_Path);
2864 tar.setfn(Full_FileName);
2865 tar.backup_name = Backup_Name;
2866#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
2867 string Password;
2868 DataManager::GetValue("tw_restore_password", Password);
2869 if (!Password.empty())
2870 tar.setpassword(Password);
2871#endif
bigbiffce8f83c2015-12-12 18:30:21 -05002872 part_settings->progress->SetPartitionSize(Get_Restore_Size(part_settings));
2873 if (tar.extractTarFork() != 0)
Dees Troy4159aed2014-02-28 17:24:43 +00002874 ret = false;
2875 else
2876 ret = true;
2877#ifdef HAVE_CAPABILITIES
2878 // Restore capabilities to the run-as binary
Captain Throwback9d6feb52018-07-27 10:05:24 -04002879 if (Mount_Point == PartitionManager.Get_Android_Root_Path() && Mount(true) && TWFunc::Path_Exists("/system/bin/run-as")) {
Dees Troy4159aed2014-02-28 17:24:43 +00002880 struct vfs_cap_data cap_data;
2881 uint64_t capabilities = (1 << CAP_SETUID) | (1 << CAP_SETGID);
2882
2883 memset(&cap_data, 0, sizeof(cap_data));
2884 cap_data.magic_etc = VFS_CAP_REVISION | VFS_CAP_FLAGS_EFFECTIVE;
2885 cap_data.data[0].permitted = (uint32_t) (capabilities & 0xffffffff);
2886 cap_data.data[0].inheritable = 0;
2887 cap_data.data[1].permitted = (uint32_t) (capabilities >> 32);
2888 cap_data.data[1].inheritable = 0;
2889 if (setxattr("/system/bin/run-as", XATTR_NAME_CAPS, &cap_data, sizeof(cap_data), 0) < 0) {
2890 LOGINFO("Failed to reset capabilities of /system/bin/run-as binary.\n");
2891 } else {
2892 LOGINFO("Reset capabilities of /system/bin/run-as binary successful.\n");
2893 }
2894 }
2895#endif
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05002896 if (Mount_Read_Only || Mount_Flags & MS_RDONLY)
2897 // Remount as read only when restoration is complete
2898 ReMount(true);
2899
Dees Troy4159aed2014-02-28 17:24:43 +00002900 return ret;
Dees_Troy51a0e822012-09-05 15:24:24 -04002901}
2902
bigbiffce8f83c2015-12-12 18:30:21 -05002903bool TWPartition::Restore_Image(PartitionSettings *part_settings) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06002904 string Full_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002905 string Restore_File_System = Get_Restore_File_System(part_settings);
Dees_Troy43d8b002012-09-17 16:00:01 -04002906
Matt Mower3c366972015-12-25 19:28:31 -06002907 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Backup_Display_Name, gui_parse_text("{@restoring_hdr}"));
Ethan Yonker74db1572015-10-28 12:44:49 -05002908 gui_msg(Msg("restoring=Restoring {1}...")(Backup_Display_Name));
bigbiffce8f83c2015-12-12 18:30:21 -05002909
2910 if (part_settings->adbbackup)
2911 Full_FileName = TW_ADB_RESTORE;
2912 else
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002913 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Gary Peck15e623d2012-11-21 21:07:58 -08002914
Ethan Yonker96af84a2015-01-05 14:58:36 -06002915 if (Restore_File_System == "emmc") {
bigbiffce8f83c2015-12-12 18:30:21 -05002916 if (!part_settings->adbbackup)
2917 part_settings->total_restore_size = (uint64_t)(TWFunc::Get_File_Size(Full_FileName));
2918 if (!Raw_Read_Write(part_settings))
Ethan Yonker96af84a2015-01-05 14:58:36 -06002919 return false;
2920 } else if (Restore_File_System == "mtd" || Restore_File_System == "bml") {
bigbiffce8f83c2015-12-12 18:30:21 -05002921 if (!Flash_Image_FI(Full_FileName, part_settings->progress))
2922 return false;
2923 }
2924
2925 if (part_settings->adbbackup) {
2926 if (!twadbbu::Write_TWEOF())
Ethan Yonker96af84a2015-01-05 14:58:36 -06002927 return false;
Gary Peck15e623d2012-11-21 21:07:58 -08002928 }
Dees_Troy43d8b002012-09-17 16:00:01 -04002929 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002930}
Dees_Troy5bf43922012-09-07 16:07:55 -04002931
2932bool TWPartition::Update_Size(bool Display_Error) {
Dees_Troy0550cfb2012-10-13 11:56:13 -04002933 bool ret = false, Was_Already_Mounted = false;
Dees_Troy51127312012-09-08 13:08:49 -04002934
Ethan Yonker1b190162016-12-05 15:25:19 -06002935 Find_Actual_Block_Device();
2936
bigbiffee7b7ff2020-03-23 15:08:27 -04002937 if (Actual_Block_Device.empty())
2938 return false;
2939
Ethan Yonker1b190162016-12-05 15:25:19 -06002940 if (!Can_Be_Mounted && !Is_Encrypted) {
2941 if (TWFunc::Path_Exists(Actual_Block_Device) && Find_Partition_Size()) {
2942 Used = Size;
2943 Backup_Size = Size;
2944 return true;
2945 }
Dees_Troy5bf43922012-09-07 16:07:55 -04002946 return false;
Ethan Yonker1b190162016-12-05 15:25:19 -06002947 }
Dees_Troy5bf43922012-09-07 16:07:55 -04002948
Dees_Troy0550cfb2012-10-13 11:56:13 -04002949 Was_Already_Mounted = Is_Mounted();
bigbiffee7b7ff2020-03-23 15:08:27 -04002950
Dees_Troy38bd7602012-09-14 13:33:53 -04002951 if (Removable || Is_Encrypted) {
2952 if (!Mount(false))
2953 return true;
2954 } else if (!Mount(Display_Error))
Dees_Troy5bf43922012-09-07 16:07:55 -04002955 return false;
Dees_Troy51127312012-09-08 13:08:49 -04002956
2957 ret = Get_Size_Via_statfs(Display_Error);
Dees_Troy0550cfb2012-10-13 11:56:13 -04002958 if (!ret || Size == 0) {
2959 if (!Get_Size_Via_df(Display_Error)) {
2960 if (!Was_Already_Mounted)
2961 UnMount(false);
Dees_Troy51127312012-09-08 13:08:49 -04002962 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04002963 }
2964 }
Dees_Troy51127312012-09-08 13:08:49 -04002965
Dees_Troy5bf43922012-09-07 16:07:55 -04002966 if (Has_Data_Media) {
2967 if (Mount(Display_Error)) {
Ethan Yonker3fdcda42016-11-30 12:29:37 -06002968 Used = backup_exclusions.Get_Folder_Size(Mount_Point);
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05002969 Backup_Size = Used;
2970 int bak = (int)(Used / 1048576LLU);
Dees_Troy51127312012-09-08 13:08:49 -04002971 int fre = (int)(Free / 1048576LLU);
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05002972 LOGINFO("Data backup size is %iMB, free: %iMB.\n", bak, fre);
Dees_Troy0550cfb2012-10-13 11:56:13 -04002973 } else {
2974 if (!Was_Already_Mounted)
2975 UnMount(false);
Dees_Troy5bf43922012-09-07 16:07:55 -04002976 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04002977 }
Dees_Troye58d5262012-09-21 12:27:57 -04002978 } else if (Has_Android_Secure) {
2979 if (Mount(Display_Error))
Ethan Yonker3fdcda42016-11-30 12:29:37 -06002980 Backup_Size = backup_exclusions.Get_Folder_Size(Backup_Path);
Dees_Troy0550cfb2012-10-13 11:56:13 -04002981 else {
2982 if (!Was_Already_Mounted)
2983 UnMount(false);
Dees_Troye58d5262012-09-21 12:27:57 -04002984 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04002985 }
Dees_Troy5bf43922012-09-07 16:07:55 -04002986 }
Dees_Troy0550cfb2012-10-13 11:56:13 -04002987 if (!Was_Already_Mounted)
2988 UnMount(false);
Dees_Troy5bf43922012-09-07 16:07:55 -04002989 return true;
Dees_Troy51127312012-09-08 13:08:49 -04002990}
Dees_Troy38bd7602012-09-14 13:33:53 -04002991
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002992bool TWPartition::Find_Wildcard_Block_Devices(const string& Device) {
2993 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
2994 string Path = TWFunc::Get_Path(Device);
2995 string Dev = TWFunc::Get_Filename(Device);
2996 size_t wildcard_index = Dev.find("*");
2997 if (wildcard_index != string::npos)
2998 Dev = Dev.substr(0, wildcard_index);
2999 wildcard_index = Dev.size();
3000 DIR* d = opendir(Path.c_str());
3001 if (d == NULL) {
3002 LOGINFO("Error opening '%s': %s\n", Path.c_str(), strerror(errno));
3003 return false;
3004 }
3005 struct dirent* de;
3006 while ((de = readdir(d)) != NULL) {
3007 if (de->d_type != DT_BLK || strlen(de->d_name) <= wildcard_index || strncmp(de->d_name, Dev.c_str(), wildcard_index) != 0)
3008 continue;
3009
3010 string item = Path + "/";
3011 item.append(de->d_name);
3012 if (PartitionManager.Find_Partition_By_Block_Device(item))
3013 continue;
3014 TWPartition *part = new TWPartition;
3015 char buffer[MAX_FSTAB_LINE_LENGTH];
3016 sprintf(buffer, "%s %s-%i auto defaults defaults", item.c_str(), Mount_Point.c_str(), ++mount_point_index);
bigbiff8da46fa2020-09-08 16:42:34 -04003017 part->Process_Fstab_Line(buffer, false, NULL);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06003018 char display[MAX_FSTAB_LINE_LENGTH];
3019 sprintf(display, "%s %i", Storage_Name.c_str(), mount_point_index);
3020 part->Storage_Name = display;
3021 part->Display_Name = display;
3022 part->Primary_Block_Device = item;
3023 part->Wildcard_Block_Device = false;
3024 part->Is_SubPartition = true;
3025 part->SubPartition_Of = Mount_Point;
3026 part->Is_Storage = Is_Storage;
3027 part->Can_Be_Mounted = true;
3028 part->Removable = true;
3029 part->Can_Be_Wiped = Can_Be_Wiped;
3030 part->Wipe_Available_in_GUI = Wipe_Available_in_GUI;
3031 part->Find_Actual_Block_Device();
3032 part->Update_Size(false);
3033 Has_SubPartition = true;
3034 PartitionManager.Output_Partition(part);
3035 PartitionManager.Add_Partition(part);
3036 }
3037 closedir(d);
3038 return (mount_point_index > 0);
3039}
3040
Dees_Troy38bd7602012-09-14 13:33:53 -04003041void TWPartition::Find_Actual_Block_Device(void) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06003042 if (!Sysfs_Entry.empty() && Primary_Block_Device.empty() && Decrypted_Block_Device.empty()) {
3043 /* Sysfs_Entry.empty() indicates if this is a sysfs entry that begins with /device/
3044 * If we have a syfs entry then we are looking for this device from a uevent add.
3045 * The uevent add will set the primary block device based on the data we receive from
3046 * after checking for adopted storage. If the device ends up being adopted, then the
3047 * decrypted block device will be set instead of the primary block device. */
3048 Is_Present = false;
3049 return;
3050 }
3051 if (Wildcard_Block_Device && !Is_Adopted_Storage) {
3052 Is_Present = false;
3053 Actual_Block_Device = "";
3054 Can_Be_Mounted = false;
3055 if (!Find_Wildcard_Block_Devices(Primary_Block_Device)) {
3056 string Dev = Primary_Block_Device.substr(0, Primary_Block_Device.find("*"));
3057 if (TWFunc::Path_Exists(Dev)) {
3058 Is_Present = true;
3059 Can_Be_Mounted = true;
3060 Actual_Block_Device = Dev;
3061 }
3062 }
3063 return;
3064 } else if (Is_Decrypted && !Decrypted_Block_Device.empty()) {
Dees_Troy38bd7602012-09-14 13:33:53 -04003065 Actual_Block_Device = Decrypted_Block_Device;
Ethan Yonker1b190162016-12-05 15:25:19 -06003066 if (TWFunc::Path_Exists(Decrypted_Block_Device)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04003067 Is_Present = true;
Ethan Yonker1b190162016-12-05 15:25:19 -06003068 return;
3069 }
3070 } else if (SlotSelect && TWFunc::Path_Exists(Primary_Block_Device + PartitionManager.Get_Active_Slot_Suffix())) {
3071 Actual_Block_Device = Primary_Block_Device + PartitionManager.Get_Active_Slot_Suffix();
3072 unlink(Primary_Block_Device.c_str());
3073 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
3074 Is_Present = true;
3075 return;
Dees_Troy43d8b002012-09-17 16:00:01 -04003076 } else if (TWFunc::Path_Exists(Primary_Block_Device)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04003077 Is_Present = true;
3078 Actual_Block_Device = Primary_Block_Device;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003079 return;
3080 }
Ethan Yonker1b190162016-12-05 15:25:19 -06003081 if (!Alternate_Block_Device.empty() && TWFunc::Path_Exists(Alternate_Block_Device)) {
Dees_Troy3f04d032012-10-07 18:20:09 -04003082 Actual_Block_Device = Alternate_Block_Device;
Dees_Troy38bd7602012-09-14 13:33:53 -04003083 Is_Present = true;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003084 } else {
Dees_Troy38bd7602012-09-14 13:33:53 -04003085 Is_Present = false;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003086 }
Dees_Troy38bd7602012-09-14 13:33:53 -04003087}
3088
3089void TWPartition::Recreate_Media_Folder(void) {
3090 string Command;
Ethan Yonker66a19492015-12-10 10:19:45 -06003091 string Media_Path = Mount_Point + "/media";
Dees_Troy38bd7602012-09-14 13:33:53 -04003092
Ethan Yonkerbd7492d2016-12-07 13:55:01 -06003093 if (Is_FBE) {
3094 LOGINFO("Not recreating media folder on FBE\n");
3095 return;
3096 }
Dees_Troy38bd7602012-09-14 13:33:53 -04003097 if (!Mount(true)) {
Ethan Yonker66a19492015-12-10 10:19:45 -06003098 gui_msg(Msg(msg::kError, "recreate_folder_err=Unable to recreate {1} folder.")(Media_Path));
3099 } else if (!TWFunc::Path_Exists(Media_Path)) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003100 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Ethan Yonker66a19492015-12-10 10:19:45 -06003101 LOGINFO("Recreating %s folder.\n", Media_Path.c_str());
3102 mkdir(Media_Path.c_str(), 0770);
xiaolu9416f4f2015-06-04 08:22:23 +08003103 string Internal_path = DataManager::GetStrValue("tw_internal_path");
3104 if (!Internal_path.empty()) {
3105 LOGINFO("Recreating %s folder.\n", Internal_path.c_str());
3106 mkdir(Internal_path.c_str(), 0770);
3107 }
3108#ifdef TW_INTERNAL_STORAGE_PATH
3109 mkdir(EXPAND(TW_INTERNAL_STORAGE_PATH), 0770);
3110#endif
Matt Mower87413642017-01-17 21:14:46 -06003111
thata3d31fb2014-12-21 22:27:40 +01003112 // Afterwards, we will try to set the
3113 // default metadata that we were hopefully able to get during
3114 // early boot.
Ethan Yonker66a19492015-12-10 10:19:45 -06003115 tw_set_default_metadata(Media_Path.c_str());
xiaolu9416f4f2015-06-04 08:22:23 +08003116 if (!Internal_path.empty())
3117 tw_set_default_metadata(Internal_path.c_str());
Matt Mower87413642017-01-17 21:14:46 -06003118
Ethan Yonker5eac2222014-06-11 12:22:55 -05003119 // Toggle mount to ensure that "internal sdcard" gets mounted
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003120 PartitionManager.UnMount_By_Path(Symlink_Mount_Point, true);
Ethan Yonker5eac2222014-06-11 12:22:55 -05003121 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Dees_Troy38bd7602012-09-14 13:33:53 -04003122 }
Dees_Troy43d8b002012-09-17 16:00:01 -04003123}
Dees_Troye58d5262012-09-21 12:27:57 -04003124
3125void TWPartition::Recreate_AndSec_Folder(void) {
Dees_Troye58d5262012-09-21 12:27:57 -04003126 if (!Has_Android_Secure)
3127 return;
Dees_Troy2673cec2013-04-02 20:22:16 +00003128 LOGINFO("Creating %s: %s\n", Backup_Display_Name.c_str(), Symlink_Path.c_str());
Dees_Troye58d5262012-09-21 12:27:57 -04003129 if (!Mount(true)) {
Ethan Yonker74db1572015-10-28 12:44:49 -05003130 gui_msg(Msg(msg::kError, "recreate_folder_err=Unable to recreate {1} folder.")(Backup_Name));
Dees_Troye58d5262012-09-21 12:27:57 -04003131 } else if (!TWFunc::Path_Exists(Symlink_Path)) {
Dees_Troy2673cec2013-04-02 20:22:16 +00003132 LOGINFO("Recreating %s folder.\n", Backup_Name.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003133 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05003134 mkdir(Symlink_Path.c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003135 PartitionManager.UnMount_By_Path(Symlink_Mount_Point, true);
Dees_Troye58d5262012-09-21 12:27:57 -04003136 }
3137}
bigbiff7cb4c332014-11-26 20:36:07 -05003138
3139uint64_t TWPartition::Get_Max_FileSize() {
3140 uint64_t maxFileSize = 0;
3141 const uint64_t constGB = (uint64_t) 1024 * 1024 * 1024;
3142 const uint64_t constTB = (uint64_t) constGB * 1024;
3143 const uint64_t constPB = (uint64_t) constTB * 1024;
bigbiff0c532032014-12-21 13:41:26 -05003144 if (Current_File_System == "ext4")
3145 maxFileSize = 16 * constTB; //16 TB
3146 else if (Current_File_System == "vfat")
3147 maxFileSize = 4 * constGB; //4 GB
Captain Throwback47bf7202020-10-06 17:39:39 -04003148 else if (Current_File_System == "ntfs" || Current_File_System == "tntfs")
bigbiff0c532032014-12-21 13:41:26 -05003149 maxFileSize = 256 * constTB; //256 TB
3150 else if (Current_File_System == "exfat")
3151 maxFileSize = 16 * constPB; //16 PB
3152 else if (Current_File_System == "ext3")
3153 maxFileSize = 2 * constTB; //2 TB
3154 else if (Current_File_System == "f2fs")
3155 maxFileSize = 3.94 * constTB; //3.94 TB
bigbiff7cb4c332014-11-26 20:36:07 -05003156 else
3157 maxFileSize = 100000000L;
3158 return maxFileSize - 1;
3159}
3160
bigbiffce8f83c2015-12-12 18:30:21 -05003161bool TWPartition::Flash_Image(PartitionSettings *part_settings) {
3162 string Restore_File_System, full_filename;
Ethan Yonker96af84a2015-01-05 14:58:36 -06003163
Ethan Yonkere080c1f2016-09-19 13:50:25 -05003164 full_filename = part_settings->Backup_Folder + "/" + Backup_FileName;
Ethan Yonker96af84a2015-01-05 14:58:36 -06003165
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05003166 LOGINFO("Image filename is: %s\n", Backup_FileName.c_str());
bigbiffce8f83c2015-12-12 18:30:21 -05003167
3168 if (Backup_Method == BM_FILES) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06003169 LOGERR("Cannot flash images to file systems\n");
3170 return false;
3171 } else if (!Can_Flash_Img) {
3172 LOGERR("Cannot flash images to partitions %s\n", Display_Name.c_str());
3173 return false;
3174 } else {
3175 if (!Find_Partition_Size()) {
3176 LOGERR("Unable to find partition size for '%s'\n", Mount_Point.c_str());
3177 return false;
3178 }
bigbiffce8f83c2015-12-12 18:30:21 -05003179 unsigned long long image_size = TWFunc::Get_File_Size(full_filename);
Ethan Yonker96af84a2015-01-05 14:58:36 -06003180 if (image_size > Size) {
Ethan Yonker74db1572015-10-28 12:44:49 -05003181 LOGINFO("Size (%llu bytes) of image '%s' is larger than target device '%s' (%llu bytes)\n",
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05003182 image_size, Backup_FileName.c_str(), Actual_Block_Device.c_str(), Size);
Ethan Yonker74db1572015-10-28 12:44:49 -05003183 gui_err("img_size_err=Size of image is larger than target device");
Ethan Yonker96af84a2015-01-05 14:58:36 -06003184 return false;
3185 }
bigbiffce8f83c2015-12-12 18:30:21 -05003186 if (Backup_Method == BM_DD) {
3187 if (!part_settings->adbbackup) {
3188 if (Is_Sparse_Image(full_filename)) {
3189 return Flash_Sparse_Image(full_filename);
3190 }
Ethan Yonker472f5062016-02-25 13:47:30 -06003191 }
bigbiffce8f83c2015-12-12 18:30:21 -05003192 return Raw_Read_Write(part_settings);
3193 } else if (Backup_Method == BM_FLASH_UTILS) {
3194 return Flash_Image_FI(full_filename, NULL);
Ethan Yonker472f5062016-02-25 13:47:30 -06003195 }
Ethan Yonker96af84a2015-01-05 14:58:36 -06003196 }
3197
3198 LOGERR("Unknown flash method for '%s'\n", Mount_Point.c_str());
3199 return false;
3200}
3201
Ethan Yonker472f5062016-02-25 13:47:30 -06003202bool TWPartition::Is_Sparse_Image(const string& Filename) {
HashBanged974bb2016-01-30 14:20:09 -05003203 uint32_t magic = 0;
3204 int fd = open(Filename.c_str(), O_RDONLY);
3205 if (fd < 0) {
3206 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Filename)(strerror(errno)));
3207 return false;
3208 }
bigbiffce8f83c2015-12-12 18:30:21 -05003209
HashBanged974bb2016-01-30 14:20:09 -05003210 if (read(fd, &magic, sizeof(magic)) != sizeof(magic)) {
3211 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Filename)(strerror(errno)));
3212 close(fd);
3213 return false;
3214 }
3215 close(fd);
Ethan Yonker472f5062016-02-25 13:47:30 -06003216 if (magic == SPARSE_HEADER_MAGIC)
3217 return true;
3218 return false;
3219}
3220
3221bool TWPartition::Flash_Sparse_Image(const string& Filename) {
3222 string Command;
3223
3224 gui_msg(Msg("flashing=Flashing {1}...")(Display_Name));
3225
3226 Command = "simg2img '" + Filename + "' '" + Actual_Block_Device + "'";
Ethan Yonker96af84a2015-01-05 14:58:36 -06003227 LOGINFO("Flash command: '%s'\n", Command.c_str());
3228 TWFunc::Exec_Cmd(Command);
3229 return true;
3230}
3231
Ethan Yonker472f5062016-02-25 13:47:30 -06003232bool TWPartition::Flash_Image_FI(const string& Filename, ProgressTracking *progress) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06003233 string Command;
Ethan Yonker472f5062016-02-25 13:47:30 -06003234 unsigned long long file_size;
Ethan Yonker96af84a2015-01-05 14:58:36 -06003235
Ethan Yonker74db1572015-10-28 12:44:49 -05003236 gui_msg(Msg("flashing=Flashing {1}...")(Display_Name));
Ethan Yonker472f5062016-02-25 13:47:30 -06003237 if (progress) {
3238 file_size = (unsigned long long)(TWFunc::Get_File_Size(Filename));
3239 progress->SetPartitionSize(file_size);
3240 }
Ethan Yonker96af84a2015-01-05 14:58:36 -06003241 // Sometimes flash image doesn't like to flash due to the first 2KB matching, so we erase first to ensure that it flashes
3242 Command = "erase_image " + MTD_Name;
3243 LOGINFO("Erase command: '%s'\n", Command.c_str());
3244 TWFunc::Exec_Cmd(Command);
3245 Command = "flash_image " + MTD_Name + " '" + Filename + "'";
3246 LOGINFO("Flash command: '%s'\n", Command.c_str());
3247 TWFunc::Exec_Cmd(Command);
Ethan Yonker472f5062016-02-25 13:47:30 -06003248 if (progress)
3249 progress->UpdateSize(file_size);
Ethan Yonker96af84a2015-01-05 14:58:36 -06003250 return true;
3251}
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05003252
3253void TWPartition::Change_Mount_Read_Only(bool new_value) {
3254 Mount_Read_Only = new_value;
3255}
3256
bigbiffce8f83c2015-12-12 18:30:21 -05003257bool TWPartition::Is_Read_Only() {
3258 return Mount_Read_Only;
3259}
3260
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05003261int TWPartition::Check_Lifetime_Writes() {
3262 bool original_read_only = Mount_Read_Only;
3263 int ret = 1;
3264
3265 Mount_Read_Only = true;
3266 if (Mount(false)) {
3267 Find_Actual_Block_Device();
Ethan Yonker54970bb2019-01-17 16:19:24 -06003268 string temp = Actual_Block_Device;
3269 Find_Real_Block_Device(temp, false);
3270 string block = basename(temp.c_str());
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05003271 string file = "/sys/fs/" + Current_File_System + "/" + block + "/lifetime_write_kbytes";
3272 string result;
3273 if (TWFunc::Path_Exists(file)) {
3274 if (TWFunc::read_file(file, result) != 0) {
3275 LOGINFO("Check_Lifetime_Writes of '%s' failed to read_file\n", file.c_str());
3276 } else {
3277 LOGINFO("Check_Lifetime_Writes result: '%s'\n", result.c_str());
3278 if (result == "0") {
3279 ret = 0;
3280 }
3281 }
3282 } else {
3283 LOGINFO("Check_Lifetime_Writes file does not exist '%s'\n", file.c_str());
3284 }
3285 UnMount(true);
3286 } else {
3287 LOGINFO("Check_Lifetime_Writes failed to mount '%s'\n", Mount_Point.c_str());
3288 }
3289 Mount_Read_Only = original_read_only;
3290 return ret;
3291}
Ethan Yonker66a19492015-12-10 10:19:45 -06003292
3293int TWPartition::Decrypt_Adopted() {
3294#ifdef TW_INCLUDE_CRYPTO
3295 int ret = 1;
3296 Is_Adopted_Storage = false;
3297 string Adopted_Key_File = "";
3298
3299 if (!Removable)
3300 return ret;
3301
3302 int fd = open(Alternate_Block_Device.c_str(), O_RDONLY);
3303 if (fd < 0) {
3304 LOGINFO("failed to open '%s'\n", Alternate_Block_Device.c_str());
3305 return ret;
3306 }
3307 char type_guid[80];
3308 char part_guid[80];
3309
nkk713c1e35f2017-03-24 18:28:03 +02003310 uint32_t p_num;
3311 size_t last_digit = Primary_Block_Device.find_last_not_of("0123456789");
3312 if ((last_digit != string::npos) && (last_digit != Primary_Block_Device.length()-1))
3313 p_num = atoi(Primary_Block_Device.substr(last_digit + 1).c_str()) + 1;
3314 else
3315 p_num = 2;
3316
3317 if (gpt_disk_get_partition_info(fd, p_num, type_guid, part_guid) == 0) {
Ethan Yonker66a19492015-12-10 10:19:45 -06003318 LOGINFO("type: '%s'\n", type_guid);
3319 LOGINFO("part: '%s'\n", part_guid);
3320 Adopted_GUID = part_guid;
3321 LOGINFO("Adopted_GUID '%s'\n", Adopted_GUID.c_str());
3322 if (strcmp(type_guid, TWGptAndroidExpand) == 0) {
3323 LOGINFO("android_expand found\n");
3324 Adopted_Key_File = "/data/misc/vold/expand_";
3325 Adopted_Key_File += part_guid;
3326 Adopted_Key_File += ".key";
3327 if (TWFunc::Path_Exists(Adopted_Key_File)) {
3328 Is_Adopted_Storage = true;
3329 /* Until we find a use case for this, I think it is safe
3330 * to disable USB Mass Storage whenever adopted storage
3331 * is present.
3332 */
nkk713c1e35f2017-03-24 18:28:03 +02003333 if (p_num == 2) {
3334 // TODO: Properly detect mixed vs fully adopted storage. Maybe this
3335 // should be moved to partitionmanager instead, and disable after
3336 // checking all partitions. Also the presence of adopted storage does
3337 // not necessarily mean it's being used as Internal Storage
3338 LOGINFO("Detected adopted storage, disabling USB mass storage mode\n");
3339 DataManager::SetValue("tw_has_usb_storage", 0);
3340 }
Ethan Yonker66a19492015-12-10 10:19:45 -06003341 }
3342 }
3343 }
3344
3345 if (Is_Adopted_Storage) {
nkk713c1e35f2017-03-24 18:28:03 +02003346 string Adopted_Block_Device = Alternate_Block_Device + "p" + TWFunc::to_string(p_num);
Ethan Yonker66a19492015-12-10 10:19:45 -06003347 if (!TWFunc::Path_Exists(Adopted_Block_Device)) {
nkk713c1e35f2017-03-24 18:28:03 +02003348 Adopted_Block_Device = Alternate_Block_Device + TWFunc::to_string(p_num);
Ethan Yonker66a19492015-12-10 10:19:45 -06003349 if (!TWFunc::Path_Exists(Adopted_Block_Device)) {
3350 LOGINFO("Adopted block device does not exist\n");
3351 goto exit;
3352 }
3353 }
3354 LOGINFO("key file is '%s', block device '%s'\n", Adopted_Key_File.c_str(), Adopted_Block_Device.c_str());
3355 char crypto_blkdev[MAXPATHLEN];
3356 std::string thekey;
3357 int fdkey = open(Adopted_Key_File.c_str(), O_RDONLY);
3358 if (fdkey < 0) {
3359 LOGINFO("failed to open key file\n");
3360 goto exit;
3361 }
3362 char buf[512];
3363 ssize_t n;
3364 while ((n = read(fdkey, &buf[0], sizeof(buf))) > 0) {
3365 thekey.append(buf, n);
3366 }
3367 close(fdkey);
3368 unsigned char* key = (unsigned char*) thekey.data();
3369 cryptfs_revert_ext_volume(part_guid);
3370
3371 ret = cryptfs_setup_ext_volume(part_guid, Adopted_Block_Device.c_str(), key, thekey.size(), crypto_blkdev);
3372 if (ret == 0) {
3373 LOGINFO("adopted storage new block device: '%s'\n", crypto_blkdev);
3374 Decrypted_Block_Device = crypto_blkdev;
3375 Is_Decrypted = true;
3376 Is_Encrypted = true;
3377 Find_Actual_Block_Device();
Kjell Braden3126a112016-06-19 16:58:15 +00003378 if (!Mount_Storage_Retry(false)) {
Ethan Yonker66a19492015-12-10 10:19:45 -06003379 LOGERR("Failed to mount decrypted adopted storage device\n");
3380 Is_Decrypted = false;
3381 Is_Encrypted = false;
3382 cryptfs_revert_ext_volume(part_guid);
3383 ret = 1;
3384 } else {
Ethan Yonkerfcf3f242016-02-16 12:30:26 -06003385 UnMount(false);
3386 Has_Android_Secure = false;
3387 Symlink_Path = "";
3388 Symlink_Mount_Point = "";
3389 Backup_Name = Mount_Point.substr(1);
3390 Backup_Path = Mount_Point;
3391 TWPartition* sdext = PartitionManager.Find_Partition_By_Path("/sd-ext");
3392 if (sdext && sdext->Actual_Block_Device == Adopted_Block_Device) {
3393 LOGINFO("Removing /sd-ext from partition list due to adopted storage\n");
3394 PartitionManager.Remove_Partition_By_Path("/sd-ext");
3395 }
Ethan Yonker66a19492015-12-10 10:19:45 -06003396 Setup_Data_Media();
Ethan Yonker66a19492015-12-10 10:19:45 -06003397 Wipe_Available_in_GUI = true;
3398 Wipe_During_Factory_Reset = true;
3399 Can_Be_Backed_Up = true;
3400 Can_Encrypt_Backup = true;
3401 Use_Userdata_Encryption = true;
3402 Is_Storage = true;
3403 Storage_Name = "Adopted Storage";
3404 Is_SubPartition = true;
3405 SubPartition_Of = "/data";
3406 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
3407 DataManager::SetValue("tw_has_adopted_storage", 1);
3408 }
3409 } else {
3410 LOGERR("Failed to setup adopted storage decryption\n");
3411 }
3412 }
3413exit:
Matt Mower06543e32017-01-06 15:25:26 -06003414 close(fd);
Ethan Yonker66a19492015-12-10 10:19:45 -06003415 return ret;
3416#else
3417 LOGINFO("Decrypt_Adopted: no crypto support\n");
3418 return 1;
3419#endif
3420}
3421
3422void TWPartition::Revert_Adopted() {
3423#ifdef TW_INCLUDE_CRYPTO
3424 if (!Adopted_GUID.empty()) {
3425 PartitionManager.Remove_MTP_Storage(Mount_Point);
3426 UnMount(false);
3427 cryptfs_revert_ext_volume(Adopted_GUID.c_str());
3428 Is_Adopted_Storage = false;
3429 Is_Encrypted = false;
3430 Is_Decrypted = false;
3431 Decrypted_Block_Device = "";
3432 Find_Actual_Block_Device();
3433 Wipe_During_Factory_Reset = false;
3434 Can_Be_Backed_Up = false;
3435 Can_Encrypt_Backup = false;
3436 Use_Userdata_Encryption = false;
3437 Is_SubPartition = false;
3438 SubPartition_Of = "";
3439 Has_Data_Media = false;
3440 Storage_Path = Mount_Point;
3441 if (!Symlink_Mount_Point.empty()) {
3442 TWPartition* Dat = PartitionManager.Find_Partition_By_Path("/data");
3443 if (Dat) {
3444 Dat->UnMount(false);
3445 Dat->Symlink_Mount_Point = Symlink_Mount_Point;
3446 }
3447 Symlink_Mount_Point = "";
3448 }
3449 }
3450#else
3451 LOGINFO("Revert_Adopted: no crypto support\n");
3452#endif
3453}
bigbiff bigbiffb5ecaad2017-03-20 18:53:53 -04003454
3455void TWPartition::Set_Backup_FileName(string fname) {
3456 Backup_FileName = fname;
3457}
3458
3459string TWPartition::Get_Backup_Name() {
3460 return Backup_Name;
3461}
bigbiffee7b7ff2020-03-23 15:08:27 -04003462
3463string TWPartition::Get_Mount_Point() {
3464 return Mount_Point;
3465}
3466
3467void TWPartition::Set_Block_Device(std::string block_device) {
3468 Primary_Block_Device = Actual_Block_Device = block_device;
3469}
3470
3471bool TWPartition::Get_Super_Status() {
3472 return Is_Super;
3473}
3474
3475void TWPartition::Set_Can_Be_Backed_Up(bool val) {
3476 Can_Be_Backed_Up = val;
3477}
3478
3479void TWPartition::Set_Can_Be_Wiped(bool val) {
3480 Can_Be_Wiped = val;
3481 Wipe_Available_in_GUI = val;
bigbiffad58e1b2020-07-06 20:24:34 -04003482}
3483
3484std::string TWPartition::Get_Backup_FileName() {
3485 return Backup_FileName;
3486}
3487
3488std::string TWPartition::Get_Display_Name() {
3489 return Display_Name;
3490}
3491
3492bool TWPartition::Is_SlotSelect() {
3493 return SlotSelect;
Mohd Faraz815e2402020-09-19 19:31:52 +05303494}