blob: 343ccb27319f28e7adc4b19454bd0ed9b69ee5b2 [file] [log] [blame]
Dees Troy3be70a82013-10-22 14:25:12 +00001/*
bigbiff7ba75002020-04-11 20:47:09 -04002 Copyright 2013 to 2020 TeamWin
Dees Troy3be70a82013-10-22 14:25:12 +00003 This file is part of TWRP/TeamWin Recovery Project.
4
5 TWRP is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation, either version 3 of the License, or
8 (at your option) any later version.
9
10 TWRP is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with TWRP. If not, see <http://www.gnu.org/licenses/>.
17*/
Dees_Troy51a0e822012-09-05 15:24:24 -040018
19#include <stdio.h>
20#include <stdlib.h>
21#include <string.h>
bigbiff7ba75002020-04-11 20:47:09 -040022
Dees_Troy5bf43922012-09-07 16:07:55 -040023#include <sys/mount.h>
bigbiff7ba75002020-04-11 20:47:09 -040024#include <sys/param.h>
25#include <sys/stat.h>
26#include <sys/types.h>
27#include <sys/vfs.h>
Dees_Troy51a0e822012-09-05 15:24:24 -040028#include <unistd.h>
Dees_Troy51127312012-09-08 13:08:49 -040029#include <dirent.h>
Ethan Yonker472f5062016-02-25 13:47:30 -060030#include <fcntl.h>
bigbiff7ba75002020-04-11 20:47:09 -040031#include <iostream>
32#include <libgen.h>
bigbiff7ba75002020-04-11 20:47:09 -040033#include <zlib.h>
34#include <sstream>
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,
Matt Mower2416a502016-04-12 19:54:46 -0500165};
166
167/* Flags without a trailing '=' are considered dual format flags and can be
168 * written as either 'flagname' or 'flagname=', where the character following
169 * the '=' is Y,y,1 for true and false otherwise.
170 */
171const struct flag_list tw_flags[] = {
172 { "andsec", TWFLAG_ANDSEC },
173 { "backup", TWFLAG_BACKUP },
174 { "backupname=", TWFLAG_BACKUPNAME },
175 { "blocksize=", TWFLAG_BLOCKSIZE },
176 { "canbewiped", TWFLAG_CANBEWIPED },
177 { "canencryptbackup", TWFLAG_CANENCRYPTBACKUP },
178 { "defaults", TWFLAG_DEFAULTS },
179 { "display=", TWFLAG_DISPLAY },
180 { "encryptable=", TWFLAG_ENCRYPTABLE },
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500181 { "fileencryption=", TWFLAG_FILEENCRYPTION },
Matt Mower2416a502016-04-12 19:54:46 -0500182 { "flashimg", TWFLAG_FLASHIMG },
183 { "forceencrypt=", TWFLAG_FORCEENCRYPT },
184 { "fsflags=", TWFLAG_FSFLAGS },
185 { "ignoreblkid", TWFLAG_IGNOREBLKID },
186 { "length=", TWFLAG_LENGTH },
187 { "mounttodecrypt", TWFLAG_MOUNTTODECRYPT },
188 { "removable", TWFLAG_REMOVABLE },
Matt Mower2416a502016-04-12 19:54:46 -0500189 { "settingsstorage", TWFLAG_SETTINGSSTORAGE },
190 { "storage", TWFLAG_STORAGE },
191 { "storagename=", TWFLAG_STORAGENAME },
192 { "subpartitionof=", TWFLAG_SUBPARTITIONOF },
193 { "symlink=", TWFLAG_SYMLINK },
194 { "userdataencryptbackup", TWFLAG_USERDATAENCRYPTBACKUP },
195 { "usermrf", TWFLAG_USERMRF },
196 { "wipeduringfactoryreset", TWFLAG_WIPEDURINGFACTORYRESET },
197 { "wipeingui", TWFLAG_WIPEINGUI },
Ethan Yonker1b190162016-12-05 15:25:19 -0600198 { "slotselect", TWFLAG_SLOTSELECT },
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600199 { "wait", TWFLAG_WAIT },
200 { "verify", TWFLAG_VERIFY },
201 { "check", TWFLAG_CHECK },
202 { "altdevice", TWFLAG_ALTDEVICE },
203 { "notrim", TWFLAG_NOTRIM },
204 { "voldmanaged=", TWFLAG_VOLDMANAGED },
205 { "formattable", TWFLAG_FORMATTABLE },
206 { "resize", TWFLAG_RESIZE },
Ethan Yonker93382822018-11-01 15:25:31 -0500207 { "keydirectory=", TWFLAG_KEYDIRECTORY },
Peter Cai28ea7b02019-05-24 11:38:54 +0800208 { "wrappedkey", TWFLAG_WRAPPEDKEY },
Peter Cai439d60c2019-10-17 08:49:10 +0800209 { "adopted_mount_delay=", TWFLAG_ADOPTED_MOUNT_DELAY },
Peter Caid68e6412019-11-02 19:22:38 +0800210 { "dm_use_original_path", TWFLAG_DM_USE_ORIGINAL_PATH },
Matt Mower2416a502016-04-12 19:54:46 -0500211 { 0, 0 },
212};
213
that9e0593e2014-10-08 00:01:24 +0200214TWPartition::TWPartition() {
Dees_Troy51a0e822012-09-05 15:24:24 -0400215 Can_Be_Mounted = false;
216 Can_Be_Wiped = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500217 Can_Be_Backed_Up = false;
Vojtech Bocek1dc30982013-08-30 21:49:30 +0200218 Use_Rm_Rf = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400219 Wipe_During_Factory_Reset = false;
220 Wipe_Available_in_GUI = false;
221 Is_SubPartition = false;
Dees_Troy2691f9d2012-09-24 11:15:49 -0400222 Has_SubPartition = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400223 SubPartition_Of = "";
224 Symlink_Path = "";
225 Symlink_Mount_Point = "";
226 Mount_Point = "";
Dees_Troye58d5262012-09-21 12:27:57 -0400227 Backup_Path = "";
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600228 Wildcard_Block_Device = false;
229 Sysfs_Entry = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400230 Actual_Block_Device = "";
231 Primary_Block_Device = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400232 Alternate_Block_Device = "";
233 Removable = false;
234 Is_Present = false;
235 Length = 0;
236 Size = 0;
237 Used = 0;
238 Free = 0;
239 Backup_Size = 0;
240 Can_Be_Encrypted = false;
241 Is_Encrypted = false;
242 Is_Decrypted = false;
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600243 Is_FBE = false;
Ethan Yonker253368a2014-11-25 15:00:52 -0600244 Mount_To_Decrypt = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400245 Decrypted_Block_Device = "";
246 Display_Name = "";
Dees_Troya13d74f2013-03-24 08:54:55 -0500247 Backup_Display_Name = "";
248 Storage_Name = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400249 Backup_Name = "";
Dees_Troy63c8df72012-09-10 14:02:05 -0400250 Backup_FileName = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400251 MTD_Name = "";
bigbiffce8f83c2015-12-12 18:30:21 -0500252 Backup_Method = BM_NONE;
Dees_Troy83bd4832013-05-04 12:39:56 +0000253 Can_Encrypt_Backup = false;
254 Use_Userdata_Encryption = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400255 Has_Data_Media = false;
Dees_Troye58d5262012-09-21 12:27:57 -0400256 Has_Android_Secure = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400257 Is_Storage = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500258 Is_Settings_Storage = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400259 Storage_Path = "";
260 Current_File_System = "";
261 Fstab_File_System = "";
Hashcode62bd9e02013-11-19 21:59:42 -0800262 Mount_Flags = 0;
263 Mount_Options = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400264 Format_Block_Size = 0;
Dees_Troy68cab492012-12-12 19:29:35 +0000265 Ignore_Blkid = false;
dianlujitao4879b372018-12-03 18:45:47 +0800266 Crypto_Key_Location = "";
Ethan Yonker726a0202014-12-16 20:01:38 -0600267 MTP_Storage_ID = 0;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600268 Can_Flash_Img = false;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500269 Mount_Read_Only = false;
Ethan Yonker66a19492015-12-10 10:19:45 -0600270 Is_Adopted_Storage = false;
271 Adopted_GUID = "";
Ethan Yonker1b190162016-12-05 15:25:19 -0600272 SlotSelect = false;
Ethan Yonker93382822018-11-01 15:25:31 -0500273 Key_Directory = "";
bigbiffee7b7ff2020-03-23 15:08:27 -0400274 Is_Super = false;
Peter Cai439d60c2019-10-17 08:49:10 +0800275 Adopted_Mount_Delay = 0;
Peter Caid68e6412019-11-02 19:22:38 +0800276 Original_Path = "";
277 Use_Original_Path = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400278}
279
280TWPartition::~TWPartition(void) {
281 // Do nothing
282}
283
bigbiff8da46fa2020-09-08 16:42:34 -0400284bool 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 -0500285 char full_line[MAX_FSTAB_LINE_LENGTH];
Matt Mower2416a502016-04-12 19:54:46 -0500286 char twflags[MAX_FSTAB_LINE_LENGTH] = "";
Dees_Troy5bf43922012-09-07 16:07:55 -0400287 char* ptr;
Matt Mower2b2dd152016-04-26 11:24:08 -0500288 int line_len = strlen(fstab_line), index = 0, item_index = 0;
Dees_Troya13d74f2013-03-24 08:54:55 -0500289 bool skip = false;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600290 int fstab_version = 1, mount_point_index = 0, fs_index = 1, block_device_index = 2;
291 TWPartition *additional_entry = NULL;
292 std::map<string, Flags_Map>::iterator it;
Dees_Troy5bf43922012-09-07 16:07:55 -0400293
Matt Mower2b2dd152016-04-26 11:24:08 -0500294 strlcpy(full_line, fstab_line, sizeof(full_line));
bigbiffee7b7ff2020-03-23 15:08:27 -0400295
Dees_Troy51127312012-09-08 13:08:49 -0400296 for (index = 0; index < line_len; index++) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500297 if (full_line[index] == 34)
298 skip = !skip;
299 if (!skip && full_line[index] <= 32)
Dees_Troy5bf43922012-09-07 16:07:55 -0400300 full_line[index] = '\0';
Dees_Troy5bf43922012-09-07 16:07:55 -0400301 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600302 if (line_len < 10)
303 return false; // There can't possibly be a valid fstab line that is less than 10 chars
304 if (strncmp(fstab_line, "/dev/", strlen("/dev/")) == 0 || strncmp(fstab_line, "/devices/", strlen("/devices/")) == 0) {
305 fstab_version = 2;
306 block_device_index = 0;
307 mount_point_index = 1;
308 fs_index = 2;
309 }
310
bigbiffee7b7ff2020-03-23 15:08:27 -0400311 Is_Super = PartitionManager.Is_Super_Partition(fstab_line);
312 if (Is_Super) {
313 block_device_index = 0;
314 fstab_version = 2;
315 mount_point_index = 1;
316 fs_index = 2;
317 }
318
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600319 index = 0;
Dees_Troy5bf43922012-09-07 16:07:55 -0400320 while (index < line_len) {
321 while (index < line_len && full_line[index] == '\0')
322 index++;
323 if (index >= line_len)
324 continue;
325 ptr = full_line + index;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600326 if (item_index == mount_point_index) {
327 Mount_Point = ptr;
bigbiffee7b7ff2020-03-23 15:08:27 -0400328 if (fstab_version == 2 && Is_Super == false) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600329 additional_entry = PartitionManager.Find_Partition_By_Path(Mount_Point);
bigbiff8da46fa2020-09-08 16:42:34 -0400330 if (additional_entry) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600331 LOGINFO("Found an additional entry for '%s'\n", Mount_Point.c_str());
332 }
333 }
bigbiff8da46fa2020-09-08 16:42:34 -0400334 LOGINFO("Processing '%s'\n", Mount_Point.c_str());
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600335 Backup_Path = Mount_Point;
336 Storage_Path = Mount_Point;
337 Display_Name = ptr + 1;
338 Backup_Display_Name = Display_Name;
339 Storage_Name = Display_Name;
340 item_index++;
341 } else if (item_index == fs_index) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400342 // File System
343 Fstab_File_System = ptr;
344 Current_File_System = ptr;
345 item_index++;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600346 } else if (item_index == block_device_index) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400347 // Primary Block Device
Dees_Troy38bd7602012-09-14 13:33:53 -0400348 if (Fstab_File_System == "mtd" || Fstab_File_System == "yaffs2") {
Dees_Troy094207a2012-09-26 12:00:39 -0400349 MTD_Name = ptr;
350 Find_MTD_Block_Device(MTD_Name);
Dees_Troy5fcd8f92012-10-16 12:22:05 -0400351 } else if (Fstab_File_System == "bml") {
352 if (Mount_Point == "/boot")
353 MTD_Name = "boot";
354 else if (Mount_Point == "/recovery")
355 MTD_Name = "recovery";
356 Primary_Block_Device = ptr;
357 if (*ptr != '/')
Dees_Troy2673cec2013-04-02 20:22:16 +0000358 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 -0400359 } else if (*ptr != '/') {
bigbiffee7b7ff2020-03-23 15:08:27 -0400360 if (!Is_Super) {
361 if (Display_Error)
362 LOGERR("Invalid block device '%s' in fstab line '%s'", ptr, fstab_line);
363 else
364 LOGINFO("Invalid block device '%s' in fstab line '%s'", ptr, fstab_line);
365 return false;
366 }
Dees_Troy38bd7602012-09-14 13:33:53 -0400367 } else {
368 Primary_Block_Device = ptr;
369 Find_Real_Block_Device(Primary_Block_Device, Display_Error);
Dees_Troy5bf43922012-09-07 16:07:55 -0400370 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400371 item_index++;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600372 } else if (item_index > 2) {
373 if (fstab_version == 2) {
374 if (item_index == 3) {
375 Process_FS_Flags(ptr);
376 if (additional_entry) {
377 additional_entry->Save_FS_Flags(Fstab_File_System, Mount_Flags, Mount_Options);
378 return false; // We save the extra fs flags in the other partition entry and by returning false, this entry will be deleted
379 }
380 } else {
381 strlcpy(twflags, ptr, sizeof(twflags));
382 }
383 item_index++;
384 } else if (*ptr == '/') { // v2 fstab does not allow alternate block devices
Dees_Troy5bf43922012-09-07 16:07:55 -0400385 // Alternate Block Device
386 Alternate_Block_Device = ptr;
387 Find_Real_Block_Device(Alternate_Block_Device, Display_Error);
388 } else if (strlen(ptr) > 7 && strncmp(ptr, "length=", 7) == 0) {
389 // Partition length
390 ptr += 7;
391 Length = atoi(ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400392 } else if (strlen(ptr) > 6 && strncmp(ptr, "flags=", 6) == 0) {
393 // Custom flags, save for later so that new values aren't overwritten by defaults
394 ptr += 6;
Matt Mower2416a502016-04-12 19:54:46 -0500395 strlcpy(twflags, ptr, sizeof(twflags));
Dees_Troy38bd7602012-09-14 13:33:53 -0400396 } else if (strlen(ptr) == 4 && (strncmp(ptr, "NULL", 4) == 0 || strncmp(ptr, "null", 4) == 0 || strncmp(ptr, "null", 4) == 0)) {
397 // Do nothing
Dees_Troy5bf43922012-09-07 16:07:55 -0400398 } else {
399 // Unhandled data
Matt Mower2b2dd152016-04-26 11:24:08 -0500400 LOGINFO("Unhandled fstab information '%s' in fstab line '%s'\n", ptr, fstab_line);
Dees_Troy5bf43922012-09-07 16:07:55 -0400401 }
402 }
403 while (index < line_len && full_line[index] != '\0')
404 index++;
405 }
406
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600407 // override block devices from the v2 fstab with the ones we read from the twrp.flags file in case they are different
408 if (fstab_version == 2 && twrp_flags && twrp_flags->size() > 0) {
409 it = twrp_flags->find(Mount_Point);
410 if (it != twrp_flags->end()) {
411 if (!it->second.Primary_Block_Device.empty()) {
412 Primary_Block_Device = it->second.Primary_Block_Device;
413 Find_Real_Block_Device(Primary_Block_Device, Display_Error);
414 }
415 if (!it->second.Alternate_Block_Device.empty()) {
416 Alternate_Block_Device = it->second.Alternate_Block_Device;
417 Find_Real_Block_Device(Alternate_Block_Device, Display_Error);
418 }
419 }
420 }
421
422 if (strncmp(fstab_line, "/devices/", strlen("/devices/")) == 0) {
423 Sysfs_Entry = Primary_Block_Device;
424 Primary_Block_Device = "";
425 Is_Storage = true;
426 Removable = true;
427 Wipe_Available_in_GUI = true;
428 Wildcard_Block_Device = true;
429 }
430 if (Primary_Block_Device.find("*") != string::npos)
431 Wildcard_Block_Device = true;
432
bigbiff8da46fa2020-09-08 16:42:34 -0400433 if (Mount_Point == "auto") {
434 Mount_Point = "/auto";
435 char autoi[5];
436 sprintf(autoi, "%i", auto_index);
437 Mount_Point += autoi;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600438 Backup_Path = Mount_Point;
439 Storage_Path = Mount_Point;
dianlujitaob76a73a2020-04-30 20:33:20 +0800440 Backup_Name = Mount_Point.substr(1);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600441 auto_index++;
442 Setup_File_System(Display_Error);
443 Display_Name = "Storage";
444 Backup_Display_Name = Display_Name;
445 Storage_Name = Display_Name;
446 Can_Be_Backed_Up = false;
447 Wipe_Available_in_GUI = true;
448 Is_Storage = true;
449 Removable = true;
450 Wipe_Available_in_GUI = true;
451 } else if (!Is_File_System(Fstab_File_System) && !Is_Image(Fstab_File_System)) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400452 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000453 LOGERR("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400454 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000455 LOGINFO("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Matt Mower72c87ce2016-04-26 14:34:56 -0500456 return false;
Dees_Troy5bf43922012-09-07 16:07:55 -0400457 } else if (Is_File_System(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400458 Find_Actual_Block_Device();
Dees_Troy5bf43922012-09-07 16:07:55 -0400459 Setup_File_System(Display_Error);
dianlujitaob76a73a2020-04-30 20:33:20 +0800460 Backup_Name = Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
Chaosmaster3b682732020-01-25 21:09:28 +0100461 if (Mount_Point == "/" || Mount_Point == "/system" || Mount_Point == "/system_root") {
bigbiff8da46fa2020-09-08 16:42:34 -0400462 Mount_Point = PartitionManager.Get_Android_Root_Path();
463 Backup_Path = Mount_Point;
464 Storage_Path = Mount_Point;
Dees_Troy5bf43922012-09-07 16:07:55 -0400465 Display_Name = "System";
dianlujitaob76a73a2020-04-30 20:33:20 +0800466 Backup_Name = "system";
Dees_Troya13d74f2013-03-24 08:54:55 -0500467 Backup_Display_Name = Display_Name;
468 Storage_Name = Display_Name;
bigbiff8da46fa2020-09-08 16:42:34 -0400469 Wipe_Available_in_GUI = false;
470 Can_Be_Backed_Up = false;
471 Can_Be_Wiped = false;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500472 Mount_Read_Only = true;
bigbiff8da46fa2020-09-08 16:42:34 -0400473 Make_Dir(PartitionManager.Get_Android_Root_Path(), true);
Mohd Faraze3948ec2020-08-14 01:40:59 +0000474 } else if (Mount_Point == "/product") {
475 Display_Name = "Product";
476 Backup_Name = "Product";
477 Backup_Display_Name = Display_Name;
478 Storage_Name = Display_Name;
479 Can_Be_Backed_Up = Wipe_Available_in_GUI = Is_Super ? false : true;
480 Mount_Read_Only = true;
481 } else if (Mount_Point == "/odm") {
482 Display_Name = "ODM";
483 Backup_Name = "ODM";
484 Backup_Display_Name = Display_Name;
485 Storage_Name = Display_Name;
486 Can_Be_Backed_Up = Wipe_Available_in_GUI = Is_Super ? false : true;
487 Mount_Read_Only = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400488 } else if (Mount_Point == "/data") {
489 Display_Name = "Data";
Dees_Troya13d74f2013-03-24 08:54:55 -0500490 Backup_Display_Name = Display_Name;
491 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400492 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400493 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500494 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000495 Can_Encrypt_Backup = true;
496 Use_Userdata_Encryption = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400497 } else if (Mount_Point == "/cache") {
498 Display_Name = "Cache";
Dees_Troya13d74f2013-03-24 08:54:55 -0500499 Backup_Display_Name = Display_Name;
500 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400501 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400502 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500503 Can_Be_Backed_Up = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400504 } else if (Mount_Point == "/datadata") {
Dees_Troy51127312012-09-08 13:08:49 -0400505 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400506 Display_Name = "DataData";
Dees_Troya13d74f2013-03-24 08:54:55 -0500507 Backup_Display_Name = Display_Name;
508 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400509 Is_SubPartition = true;
510 SubPartition_Of = "/data";
Dees_Troy5bf43922012-09-07 16:07:55 -0400511 DataManager::SetValue(TW_HAS_DATADATA, 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500512 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000513 Can_Encrypt_Backup = true;
514 Use_Userdata_Encryption = false; // This whole partition should be encrypted
Dees_Troy5bf43922012-09-07 16:07:55 -0400515 } else if (Mount_Point == "/sd-ext") {
Dees_Troy51127312012-09-08 13:08:49 -0400516 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400517 Display_Name = "SD-Ext";
Dees_Troya13d74f2013-03-24 08:54:55 -0500518 Backup_Display_Name = Display_Name;
519 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400520 Wipe_Available_in_GUI = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400521 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500522 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000523 Can_Encrypt_Backup = true;
524 Use_Userdata_Encryption = true;
Dees_Troy2c50e182012-09-26 20:05:28 -0400525 } else if (Mount_Point == "/boot") {
526 Display_Name = "Boot";
Dees_Troya13d74f2013-03-24 08:54:55 -0500527 Backup_Display_Name = Display_Name;
Dees_Troy2c50e182012-09-26 20:05:28 -0400528 DataManager::SetValue("tw_boot_is_mountable", 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500529 Can_Be_Backed_Up = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500530 } else if (Mount_Point == "/vendor") {
531 Display_Name = "Vendor";
532 Backup_Display_Name = Display_Name;
533 Storage_Name = Display_Name;
534 Mount_Read_Only = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400535 }
536#ifdef TW_EXTERNAL_STORAGE_PATH
537 if (Mount_Point == EXPAND(TW_EXTERNAL_STORAGE_PATH)) {
538 Is_Storage = true;
539 Storage_Path = EXPAND(TW_EXTERNAL_STORAGE_PATH);
Dees_Troyc51f1f92012-09-20 15:32:13 -0400540 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500541 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400542#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000543 if (Mount_Point == "/sdcard" || Mount_Point == "/external_sd" || Mount_Point == "/external_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400544 Is_Storage = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400545 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500546 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400547#endif
Dees_Troyb05ddee2013-01-28 20:24:50 +0000548 }
Dees_Troy8170a922012-09-18 15:40:25 -0400549#ifdef TW_INTERNAL_STORAGE_PATH
550 if (Mount_Point == EXPAND(TW_INTERNAL_STORAGE_PATH)) {
551 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500552 Is_Settings_Storage = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400553 Storage_Path = EXPAND(TW_INTERNAL_STORAGE_PATH);
Dees_Troya13d74f2013-03-24 08:54:55 -0500554 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400555 }
556#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000557 if (Mount_Point == "/emmc" || Mount_Point == "/internal_sd" || Mount_Point == "/internal_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400558 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500559 Is_Settings_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500560 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400561 }
562#endif
Dees_Troy5bf43922012-09-07 16:07:55 -0400563 } else if (Is_Image(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400564 Find_Actual_Block_Device();
Ethan Yonker1b190162016-12-05 15:25:19 -0600565 Setup_Image();
Dees_Troya13d74f2013-03-24 08:54:55 -0500566 if (Mount_Point == "/boot") {
567 Display_Name = "Boot";
568 Backup_Display_Name = Display_Name;
569 Can_Be_Backed_Up = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600570 Can_Flash_Img = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500571 } else if (Mount_Point == "/recovery") {
572 Display_Name = "Recovery";
573 Backup_Display_Name = Display_Name;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600574 Can_Flash_Img = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500575 } else if (Mount_Point == "/system_image") {
576 Display_Name = "System Image";
577 Backup_Display_Name = Display_Name;
HashBanged974bb2016-01-30 14:20:09 -0500578 Can_Flash_Img = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500579 Can_Be_Backed_Up = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500580 } else if (Mount_Point == "/vendor_image") {
581 Display_Name = "Vendor Image";
582 Backup_Display_Name = Display_Name;
HashBanged974bb2016-01-30 14:20:09 -0500583 Can_Flash_Img = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500584 Can_Be_Backed_Up = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500585 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400586 }
587
Matt Mower2416a502016-04-12 19:54:46 -0500588 // Process TWRP fstab flags
589 if (strlen(twflags) > 0) {
590 string Prev_Display_Name = Display_Name;
591 string Prev_Storage_Name = Storage_Name;
592 string Prev_Backup_Display_Name = Backup_Display_Name;
593 Display_Name = "";
594 Storage_Name = "";
595 Backup_Display_Name = "";
596
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600597 Process_TW_Flags(twflags, (fstab_version == 1), fstab_version);
598 Save_FS_Flags(Fstab_File_System, Mount_Flags, Mount_Options);
Matt Mower2416a502016-04-12 19:54:46 -0500599
600 bool has_display_name = !Display_Name.empty();
601 bool has_storage_name = !Storage_Name.empty();
602 bool has_backup_name = !Backup_Display_Name.empty();
603 if (!has_display_name) Display_Name = Prev_Display_Name;
604 if (!has_storage_name) Storage_Name = Prev_Storage_Name;
605 if (!has_backup_name) Backup_Display_Name = Prev_Backup_Display_Name;
606
607 if (has_display_name && !has_storage_name)
608 Storage_Name = Display_Name;
609 if (!has_display_name && has_storage_name)
610 Display_Name = Storage_Name;
611 if (has_display_name && !has_backup_name && Backup_Display_Name != "Android Secure")
612 Backup_Display_Name = Display_Name;
613 if (!has_display_name && has_backup_name)
614 Display_Name = Backup_Display_Name;
615 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600616
617 if (fstab_version == 2 && twrp_flags && twrp_flags->size() > 0) {
618 it = twrp_flags->find(Mount_Point);
619 if (it != twrp_flags->end()) {
620 char twrpflags[MAX_FSTAB_LINE_LENGTH] = "";
621 int skip = 0;
622 string Flags = it->second.Flags;
623 strcpy(twrpflags, Flags.c_str());
624 if (strlen(twrpflags) > strlen("flags=") && strncmp(twrpflags, "flags=", strlen("flags=")) == 0)
625 skip += strlen("flags=");
626 char* flagptr = twrpflags;
627 flagptr += skip;
628 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
629 }
630 }
nkk7198fc3992017-12-16 16:26:42 +0200631
632 if (Mount_Point == "/persist" && Can_Be_Mounted) {
633 bool mounted = Is_Mounted();
634 if (mounted || Mount(false)) {
nkk7198fc3992017-12-16 16:26:42 +0200635 TWFunc::Fixup_Time_On_Boot("/persist/time/");
636 if (!mounted)
637 UnMount(false);
638 }
639 }
640
Dees_Troy51127312012-09-08 13:08:49 -0400641 return true;
642}
643
Matt Mower72c87ce2016-04-26 14:34:56 -0500644void TWPartition::Partition_Post_Processing(bool Display_Error) {
645 if (Mount_Point == "/data")
646 Setup_Data_Partition(Display_Error);
647 else if (Mount_Point == "/cache")
648 Setup_Cache_Partition(Display_Error);
649}
650
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600651void TWPartition::ExcludeAll(const string& path) {
652 backup_exclusions.add_absolute_dir(path);
653 wipe_exclusions.add_absolute_dir(path);
654}
655
Matt Mower72c87ce2016-04-26 14:34:56 -0500656void TWPartition::Setup_Data_Partition(bool Display_Error) {
657 if (Mount_Point != "/data")
658 return;
659
660 // Ensure /data is not mounted as tmpfs for qcom hardware decrypt
661 UnMount(false);
662
663#ifdef TW_INCLUDE_CRYPTO
664 if (datamedia)
665 Setup_Data_Media();
666 Can_Be_Encrypted = true;
667 char crypto_blkdev[255];
668 property_get("ro.crypto.fs_crypto_blkdev", crypto_blkdev, "error");
669 if (strcmp(crypto_blkdev, "error") != 0) {
bigbiff7ba75002020-04-11 20:47:09 -0400670 Set_FBE_Status();
Matt Mower72c87ce2016-04-26 14:34:56 -0500671 Decrypted_Block_Device = crypto_blkdev;
672 LOGINFO("Data already decrypted, new block device: '%s'\n", crypto_blkdev);
bigbiff7ba75002020-04-11 20:47:09 -0400673 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
Matt Mower72c87ce2016-04-26 14:34:56 -0500674 } else if (!Mount(false)) {
675 if (Is_Present) {
Ethan Yonker93382822018-11-01 15:25:31 -0500676 if (Key_Directory.empty()) {
Peter Caid68e6412019-11-02 19:22:38 +0800677 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 -0400678 Fstab_File_System.c_str());
Ethan Yonker93382822018-11-01 15:25:31 -0500679 if (cryptfs_check_footer() == 0) {
680 Is_Encrypted = true;
681 Is_Decrypted = false;
682 Can_Be_Mounted = false;
683 Current_File_System = "emmc";
684 Setup_Image();
Ethan Yonker93382822018-11-01 15:25:31 -0500685 DataManager::SetValue(TW_CRYPTO_PWTYPE, cryptfs_get_password_type());
Noah Jacobson81d638d2019-04-28 00:10:07 -0400686 DataManager::SetValue("tw_crypto_pwtype_0", cryptfs_get_password_type());
Ethan Yonker93382822018-11-01 15:25:31 -0500687 DataManager::SetValue(TW_CRYPTO_PASSWORD, "");
688 DataManager::SetValue("tw_crypto_display", "");
689 } else {
690 gui_err("mount_data_footer=Could not mount /data and unable to find crypto footer.");
691 }
692 } else {
Matt Mower72c87ce2016-04-26 14:34:56 -0500693 Is_Encrypted = true;
694 Is_Decrypted = false;
Matt Mower72c87ce2016-04-26 14:34:56 -0500695 }
Ethan Yonker93382822018-11-01 15:25:31 -0500696 } else if (Key_Directory.empty()) {
Noah Jacobson81d638d2019-04-28 00:10:07 -0400697 LOGERR("Primary block device '%s' for mount point '%s' is not present!\n",
698 Primary_Block_Device.c_str(), Mount_Point.c_str());
Matt Mower72c87ce2016-04-26 14:34:56 -0500699 }
700 } else {
bigbiff7ba75002020-04-11 20:47:09 -0400701 Set_FBE_Status();
Captain Throwbackacc7f0f2020-12-29 15:54:33 -0500702 int is_device_fbe;
703 DataManager::GetValue(TW_IS_FBE, is_device_fbe);
704 if (!Decrypt_FBE_DE() && is_device_fbe == 1) {
mauronofriofc79aa62019-11-23 23:13:04 +0100705 char wrappedvalue[PROPERTY_VALUE_MAX];
706 property_get("fbe.data.wrappedkey", wrappedvalue, "");
707 std::string wrappedkeyvalue(wrappedvalue);
708 if (wrappedkeyvalue == "true") {
709 LOGERR("Unable to decrypt FBE device\n");
710 } else {
711 LOGINFO("Trying wrapped key.\n");
712 property_set("fbe.data.wrappedkey", "true");
mauronofrio9bf73352019-11-23 22:27:34 +0100713 if (!Decrypt_FBE_DE()) {
bigbiffd58ba182020-03-23 10:02:29 -0400714 LOGERR("Unable to decrypt FBE device\n");
mauronofrio9bf73352019-11-23 22:27:34 +0100715 }
mauronofriofc79aa62019-11-23 23:13:04 +0100716 }
mauronofrio9bf73352019-11-23 22:27:34 +0100717 }
bigbiff7ba75002020-04-11 20:47:09 -0400718 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
Matt Mower72c87ce2016-04-26 14:34:56 -0500719 }
720 if (datamedia && (!Is_Encrypted || (Is_Encrypted && Is_Decrypted))) {
721 Setup_Data_Media();
bigbiff25d25b92020-06-19 16:07:38 -0400722 Recreate_Media_Folder();
Matt Mower72c87ce2016-04-26 14:34:56 -0500723 }
724#else
725 if (datamedia) {
726 Setup_Data_Media();
727 Recreate_Media_Folder();
728 }
729#endif
730}
731
bigbiff7ba75002020-04-11 20:47:09 -0400732void TWPartition::Set_FBE_Status() {
733 DataManager::SetValue(TW_IS_DECRYPTED, 1);
734 Is_Encrypted = true;
735 Is_Decrypted = true;
bigbiff7ba75002020-04-11 20:47:09 -0400736 if (Key_Directory.empty()) {
737 Is_FBE = false;
738 DataManager::SetValue(TW_IS_FBE, 0);
739 } else {
Captain Throwbackb5af4f82020-12-29 16:01:10 -0500740 LOGINFO("Setup_Data_Partition::Key_Directory::%s\n", Key_Directory.c_str());
bigbiff7ba75002020-04-11 20:47:09 -0400741 Is_FBE = true;
742 DataManager::SetValue(TW_IS_FBE, 1);
743 }
744}
745
Ethan Yonker93382822018-11-01 15:25:31 -0500746bool TWPartition::Decrypt_FBE_DE() {
bigbiff7ba75002020-04-11 20:47:09 -0400747 if (TWFunc::Path_Exists("/data/unencrypted/key/version")) {
Captain Throwback87d73d62020-02-17 16:44:50 -0500748 DataManager::SetValue(TW_IS_FBE, 1);
Mohd Faraz815e2402020-09-19 19:31:52 +0530749 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
nebrassy57f210d2020-12-16 10:35:25 +0100750 property_set("ro.crypto.state", "encrypted");
nebrassyf74255e2020-10-24 21:08:20 +0200751 property_set("ro.crypto.type", "file");
Ethan Yonker93382822018-11-01 15:25:31 -0500752 LOGINFO("File Based Encryption is present\n");
753#ifdef TW_INCLUDE_FBE
Noah Jacobson81d638d2019-04-28 00:10:07 -0400754 Is_FBE = true;
755 ExcludeAll(Mount_Point + "/convert_fbe");
756 ExcludeAll(Mount_Point + "/unencrypted");
757 ExcludeAll(Mount_Point + "/misc/vold/user_keys");
758 ExcludeAll(Mount_Point + "/misc/vold/volume_keys");
759 ExcludeAll(Mount_Point + "/system/gatekeeper.password.key");
760 ExcludeAll(Mount_Point + "/system/gatekeeper.pattern.key");
761 ExcludeAll(Mount_Point + "/system/locksettings.db");
762 ExcludeAll(Mount_Point + "/system/locksettings.db-wal");
763 ExcludeAll(Mount_Point + "/misc/gatekeeper");
764 ExcludeAll(Mount_Point + "/misc/keystore");
765 ExcludeAll(Mount_Point + "/drm/kek.dat");
bigbiffa957f072021-03-07 18:20:29 -0500766 ExcludeAll(Mount_Point + "/system_de/0/spblob"); // contains data needed to decrypt synthetic password
767 // ExcludeAll(Mount_Point + "/system/users/0/gatekeeper.password.key");
768 // ExcludeAll(Mount_Point + "/system/users/0/gatekeeper.pattern.key");
Noah Jacobson81d638d2019-04-28 00:10:07 -0400769 ExcludeAll(Mount_Point + "/cache");
bigbiffa957f072021-03-07 18:20:29 -0500770 ExcludeAll(Mount_Point + "/system/users/0");
Noah Jacobson81d638d2019-04-28 00:10:07 -0400771 ExcludeAll(Mount_Point + "/per_boot"); // removed each boot by init
bigbiffa15d02f2021-06-29 20:04:54 -0400772 ExcludeAll(Mount_Point + "/gsi"); // cow devices
773
Noah Jacobson81d638d2019-04-28 00:10:07 -0400774 int retry_count = 3;
775 while (!Decrypt_DE() && --retry_count)
776 usleep(2000);
777 if (retry_count > 0) {
778 property_set("ro.crypto.state", "encrypted");
779 Is_Encrypted = true;
780 Is_Decrypted = false;
781 DataManager::SetValue(TW_IS_ENCRYPTED, 1);
782 string filename;
783 int pwd_type = Get_Password_Type(0, filename);
784 if (pwd_type < 0) {
785 LOGERR("This TWRP does not have synthetic password decrypt support\n");
786 pwd_type = 0; // default password
Ethan Yonker93382822018-11-01 15:25:31 -0500787 }
Noah Jacobson81d638d2019-04-28 00:10:07 -0400788 PartitionManager.Parse_Users(); // after load_all_de_keys() to parse_users
789 std::vector<users_struct>::iterator iter;
790 std::vector<users_struct>* userList = PartitionManager.Get_Users_List();
791 for (iter = userList->begin(); iter != userList->end(); iter++) {
792 if (atoi((*iter).userId.c_str()) != 0) {
793 ExcludeAll(Mount_Point + "/system_de/" + (*iter).userId + "/spblob");
794 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/gatekeeper.password.key");
795 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/gatekeeper.pattern.key");
796 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/locksettings.db");
797 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/locksettings.db-wal");
798 }
799 }
800 DataManager::SetValue(TW_CRYPTO_PWTYPE, pwd_type);
801 DataManager::SetValue("tw_crypto_pwtype_0", pwd_type);
802 DataManager::SetValue(TW_CRYPTO_PASSWORD, "");
803 DataManager::SetValue("tw_crypto_display", "");
804 return true;
805 }
Ethan Yonker93382822018-11-01 15:25:31 -0500806#else
807 LOGERR("FBE found but FBE support not present in TWRP\n");
808#endif
809 }
Captain Throwback87d73d62020-02-17 16:44:50 -0500810 DataManager::SetValue(TW_IS_FBE, 0);
Ethan Yonker93382822018-11-01 15:25:31 -0500811 return false;
812}
813
Matt Mower72c87ce2016-04-26 14:34:56 -0500814void TWPartition::Setup_Cache_Partition(bool Display_Error __unused) {
815 if (Mount_Point != "/cache")
816 return;
817
818 if (!Mount(true))
819 return;
820
821 if (!TWFunc::Path_Exists("/cache/recovery/.")) {
822 LOGINFO("Recreating /cache/recovery folder\n");
823 if (mkdir("/cache/recovery", S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP) != 0)
824 LOGERR("Could not create /cache/recovery\n");
825 }
826}
827
Matt Mower4ab42b12016-04-21 13:52:18 -0500828void TWPartition::Process_FS_Flags(const char *str) {
829 char *options = strdup(str);
830 char *ptr, *savep;
Hashcode62bd9e02013-11-19 21:59:42 -0800831
Matt Mower4ab42b12016-04-21 13:52:18 -0500832 Mount_Options = "";
Hashcode62bd9e02013-11-19 21:59:42 -0800833
Matt Mower4ab42b12016-04-21 13:52:18 -0500834 // Avoid issues with potentially nested strtok by using strtok_r
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600835 for (ptr = strtok_r(options, ",", &savep); ptr; ptr = strtok_r(NULL, ",", &savep)) {
836 char *equals = strstr(ptr, "=");
837 size_t name_len;
Matt Mower4ab42b12016-04-21 13:52:18 -0500838
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600839 if (!equals)
840 name_len = strlen(ptr);
841 else
842 name_len = equals - ptr;
843
844 // There are some flags that we want to ignore in TWRP
845 bool found_match = false;
846 for (const char** ignored_mount_item = ignored_mount_items; *ignored_mount_item; ignored_mount_item++) {
847 if (strncmp(ptr, *ignored_mount_item, name_len) == 0) {
848 found_match = true;
Hashcode62bd9e02013-11-19 21:59:42 -0800849 break;
850 }
851 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600852 if (found_match)
853 continue;
Hashcode62bd9e02013-11-19 21:59:42 -0800854
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600855 // mount_flags are never postfixed by '='
856 if (!equals) {
857 const struct flag_list* mount_flag = mount_flags;
858 for (; mount_flag->name; mount_flag++) {
859 if (strcmp(ptr, mount_flag->name) == 0) {
860 if (mount_flag->flag == MS_RDONLY)
861 Mount_Read_Only = true;
862 else
863 Mount_Flags |= (unsigned)mount_flag->flag;
864 found_match = true;
865 break;
866 }
867 }
868 if (found_match)
869 continue;
Matt Mower4ab42b12016-04-21 13:52:18 -0500870 }
871
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600872 // If we aren't ignoring this flag and it's not a mount flag, then it must be a mount option
873 if (!Mount_Options.empty())
874 Mount_Options += ",";
875 Mount_Options += ptr;
Matt Mower4ab42b12016-04-21 13:52:18 -0500876 }
877 free(options);
Hashcode62bd9e02013-11-19 21:59:42 -0800878}
879
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600880void TWPartition::Save_FS_Flags(const string& local_File_System, int local_Mount_Flags, const string& local_Mount_Options) {
881 partition_fs_flags_struct flags;
882 flags.File_System = local_File_System;
883 flags.Mount_Flags = local_Mount_Flags;
884 flags.Mount_Options = local_Mount_Options;
885 fs_flags.push_back(flags);
886}
887
Matt Mower2416a502016-04-12 19:54:46 -0500888void TWPartition::Apply_TW_Flag(const unsigned flag, const char* str, const bool val) {
889 switch (flag) {
890 case TWFLAG_ANDSEC:
891 Has_Android_Secure = val;
892 break;
893 case TWFLAG_BACKUP:
894 Can_Be_Backed_Up = val;
895 break;
896 case TWFLAG_BACKUPNAME:
897 Backup_Display_Name = str;
898 break;
899 case TWFLAG_BLOCKSIZE:
900 Format_Block_Size = (unsigned long)(atol(str));
901 break;
902 case TWFLAG_CANBEWIPED:
903 Can_Be_Wiped = val;
904 break;
905 case TWFLAG_CANENCRYPTBACKUP:
906 Can_Encrypt_Backup = val;
907 break;
908 case TWFLAG_DEFAULTS:
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600909 case TWFLAG_WAIT:
910 case TWFLAG_VERIFY:
911 case TWFLAG_CHECK:
912 case TWFLAG_NOTRIM:
913 case TWFLAG_VOLDMANAGED:
914 case TWFLAG_RESIZE:
Matt Mower2416a502016-04-12 19:54:46 -0500915 // Do nothing
916 break;
917 case TWFLAG_DISPLAY:
918 Display_Name = str;
919 break;
920 case TWFLAG_ENCRYPTABLE:
921 case TWFLAG_FORCEENCRYPT:
922 Crypto_Key_Location = str;
923 break;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500924 case TWFLAG_FILEENCRYPTION:
925 // This flag isn't used by TWRP but is needed in 9.0 FBE decrypt
926 // fileencryption=ice:aes-256-heh
927 {
928 std::string FBE = str;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500929 size_t colon_loc = FBE.find(":");
930 if (colon_loc == std::string::npos) {
Ethan Yonker93382822018-11-01 15:25:31 -0500931 property_set("fbe.contents", FBE.c_str());
932 property_set("fbe.filenames", "");
933 LOGINFO("FBE contents '%s', filenames ''\n", FBE.c_str());
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500934 break;
935 }
Ethan Yonker93382822018-11-01 15:25:31 -0500936 std::string FBE_contents, FBE_filenames;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500937 FBE_contents = FBE.substr(0, colon_loc);
938 FBE_filenames = FBE.substr(colon_loc + 1);
939 property_set("fbe.contents", FBE_contents.c_str());
940 property_set("fbe.filenames", FBE_filenames.c_str());
941 LOGINFO("FBE contents '%s', filenames '%s'\n", FBE_contents.c_str(), FBE_filenames.c_str());
942 }
943 break;
Peter Cai28ea7b02019-05-24 11:38:54 +0800944 case TWFLAG_WRAPPEDKEY:
Captain Throwbackdbc37b72020-12-29 16:46:16 -0500945 // Set wrappedkey props to true for data and/or metadata
Peter Cai28ea7b02019-05-24 11:38:54 +0800946 {
Captain Throwbackdbc37b72020-12-29 16:46:16 -0500947 size_t slash_loc = Mount_Point.find('/');
948 std::string partition = Mount_Point.substr(slash_loc + 1);
949 if (Mount_Point == "/data" || Mount_Point == "/metadata") {
950 std::string wrapped_prop = "fbe." + partition + ".wrappedkey";
951 property_set(wrapped_prop.c_str(), "true");
952 LOGINFO("FBE wrapped key enabled for %s\n", Mount_Point.c_str());
953 }
Peter Cai28ea7b02019-05-24 11:38:54 +0800954 }
955 break;
Matt Mower2416a502016-04-12 19:54:46 -0500956 case TWFLAG_FLASHIMG:
957 Can_Flash_Img = val;
958 break;
959 case TWFLAG_FSFLAGS:
Matt Mower4ab42b12016-04-21 13:52:18 -0500960 Process_FS_Flags(str);
Matt Mower2416a502016-04-12 19:54:46 -0500961 break;
962 case TWFLAG_IGNOREBLKID:
963 Ignore_Blkid = val;
964 break;
965 case TWFLAG_LENGTH:
966 Length = atoi(str);
967 break;
968 case TWFLAG_MOUNTTODECRYPT:
969 Mount_To_Decrypt = val;
970 break;
971 case TWFLAG_REMOVABLE:
972 Removable = val;
973 break;
Matt Mower2416a502016-04-12 19:54:46 -0500974 case TWFLAG_SETTINGSSTORAGE:
975 Is_Settings_Storage = val;
976 if (Is_Settings_Storage)
977 Is_Storage = true;
978 break;
979 case TWFLAG_STORAGE:
980 Is_Storage = val;
981 break;
982 case TWFLAG_STORAGENAME:
983 Storage_Name = str;
984 break;
985 case TWFLAG_SUBPARTITIONOF:
986 Is_SubPartition = true;
987 SubPartition_Of = str;
988 break;
989 case TWFLAG_SYMLINK:
990 Symlink_Path = str;
991 break;
992 case TWFLAG_USERDATAENCRYPTBACKUP:
993 Use_Userdata_Encryption = val;
994 if (Use_Userdata_Encryption)
995 Can_Encrypt_Backup = true;
996 break;
997 case TWFLAG_USERMRF:
998 Use_Rm_Rf = val;
999 break;
1000 case TWFLAG_WIPEDURINGFACTORYRESET:
1001 Wipe_During_Factory_Reset = val;
1002 if (Wipe_During_Factory_Reset) {
1003 Can_Be_Wiped = true;
1004 Wipe_Available_in_GUI = true;
1005 }
1006 break;
1007 case TWFLAG_WIPEINGUI:
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001008 case TWFLAG_FORMATTABLE:
Matt Mower2416a502016-04-12 19:54:46 -05001009 Wipe_Available_in_GUI = val;
1010 if (Wipe_Available_in_GUI)
1011 Can_Be_Wiped = true;
1012 break;
Ethan Yonker1b190162016-12-05 15:25:19 -06001013 case TWFLAG_SLOTSELECT:
1014 SlotSelect = true;
1015 break;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001016 case TWFLAG_ALTDEVICE:
1017 Alternate_Block_Device = str;
1018 break;
Peter Cai439d60c2019-10-17 08:49:10 +08001019 case TWFLAG_ADOPTED_MOUNT_DELAY:
1020 Adopted_Mount_Delay = atoi(str);
1021 break;
Ethan Yonker93382822018-11-01 15:25:31 -05001022 case TWFLAG_KEYDIRECTORY:
1023 Key_Directory = str;
bigbiffa957f072021-03-07 18:20:29 -05001024 LOGINFO("setting Key_Directory to: %s\n", Key_Directory.c_str());
bigbiffd58ba182020-03-23 10:02:29 -04001025 break;
Peter Caid68e6412019-11-02 19:22:38 +08001026 case TWFLAG_DM_USE_ORIGINAL_PATH:
1027 Use_Original_Path = true;
1028 break;
Matt Mower2416a502016-04-12 19:54:46 -05001029 default:
1030 // Should not get here
1031 LOGINFO("Flag identified for processing, but later unmatched: %i\n", flag);
1032 break;
1033 }
1034}
Dees_Troy51127312012-09-08 13:08:49 -04001035
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001036void TWPartition::Process_TW_Flags(char *flags, bool Display_Error, int fstab_ver) {
Matt Mower2416a502016-04-12 19:54:46 -05001037 char separator[2] = {'\n', 0};
1038 char *ptr, *savep;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001039 char source_separator = ';';
1040
1041 if (fstab_ver == 2)
1042 source_separator = ',';
Matt Mower2416a502016-04-12 19:54:46 -05001043
1044 // Semicolons within double-quotes are not forbidden, so replace
1045 // only the semicolons intended as separators with '\n' for strtok
1046 for (unsigned i = 0, skip = 0; i < strlen(flags); i++) {
1047 if (flags[i] == '\"')
Dees_Troya13d74f2013-03-24 08:54:55 -05001048 skip = !skip;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001049 if (!skip && flags[i] == source_separator)
Matt Mower2416a502016-04-12 19:54:46 -05001050 flags[i] = separator[0];
Dees_Troy51127312012-09-08 13:08:49 -04001051 }
1052
Matt Mower2416a502016-04-12 19:54:46 -05001053 // Avoid issues with potentially nested strtok by using strtok_r
1054 ptr = strtok_r(flags, separator, &savep);
1055 while (ptr) {
1056 int ptr_len = strlen(ptr);
1057 const struct flag_list* tw_flag = tw_flags;
Hashcode62bd9e02013-11-19 21:59:42 -08001058
Matt Mower2416a502016-04-12 19:54:46 -05001059 for (; tw_flag->name; tw_flag++) {
1060 int flag_len = strlen(tw_flag->name);
1061
1062 if (strncmp(ptr, tw_flag->name, flag_len) == 0) {
1063 bool flag_val = false;
1064
1065 if (ptr_len > flag_len && (tw_flag->name)[flag_len-1] != '='
1066 && ptr[flag_len] != '=') {
1067 // Handle flags with same starting string
1068 // (e.g. backup and backupname)
1069 continue;
1070 } else if (ptr_len > flag_len && ptr[flag_len] == '=') {
1071 // Handle flags with dual format: Part 1
1072 // (e.g. backup and backup=y. backup=y handled here)
1073 ptr += flag_len + 1;
1074 TWFunc::Strip_Quotes(ptr);
1075 // Skip flags with empty argument
1076 // (e.g. backup=)
1077 if (strlen(ptr) == 0) {
1078 LOGINFO("Flag missing argument or should not include '=': %s=\n", tw_flag->name);
1079 break;
1080 }
1081 flag_val = strchr("yY1", *ptr) != NULL;
1082 } else if (ptr_len == flag_len
1083 && (tw_flag->name)[flag_len-1] == '=') {
1084 // Skip flags missing argument after =
1085 // (e.g. backupname=)
1086 LOGINFO("Flag missing argument: %s\n", tw_flag->name);
1087 break;
1088 } else if (ptr_len > flag_len
1089 && (tw_flag->name)[flag_len-1] == '=') {
1090 // Handle arguments to flags
1091 // (e.g. backupname="My Stuff")
1092 ptr += flag_len;
1093 TWFunc::Strip_Quotes(ptr);
1094 // Skip flags with empty argument
1095 // (e.g. backupname="")
1096 if (strlen(ptr) == 0) {
1097 LOGINFO("Flag missing argument: %s\n", tw_flag->name);
1098 break;
1099 }
1100 } else if (ptr_len == flag_len) {
1101 // Handle flags with dual format: Part 2
1102 // (e.g. backup and backup=y. backup handled here)
1103 flag_val = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001104 } else {
Matt Mower2416a502016-04-12 19:54:46 -05001105 LOGINFO("Flag matched, but could not be processed: %s\n", ptr);
1106 break;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001107 }
Matt Mower2416a502016-04-12 19:54:46 -05001108
1109 Apply_TW_Flag(tw_flag->flag, ptr, flag_val);
1110 break;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001111 }
Matt Mower2416a502016-04-12 19:54:46 -05001112 }
1113 if (tw_flag->name == 0) {
Dees_Troy51127312012-09-08 13:08:49 -04001114 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001115 LOGERR("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -04001116 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001117 LOGINFO("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -04001118 }
Matt Mower2416a502016-04-12 19:54:46 -05001119 ptr = strtok_r(NULL, separator, &savep);
Dees_Troy51127312012-09-08 13:08:49 -04001120 }
Dees_Troy51a0e822012-09-05 15:24:24 -04001121}
1122
Dees_Troy5bf43922012-09-07 16:07:55 -04001123bool TWPartition::Is_File_System(string File_System) {
1124 if (File_System == "ext2" ||
Dees_Troy63c8df72012-09-10 14:02:05 -04001125 File_System == "ext3" ||
Dees_Troy5bf43922012-09-07 16:07:55 -04001126 File_System == "ext4" ||
1127 File_System == "vfat" ||
1128 File_System == "ntfs" ||
1129 File_System == "yaffs2" ||
bigbiff bigbiff3e146522012-11-14 14:32:59 -05001130 File_System == "exfat" ||
Dees_Troye5017042013-08-29 16:38:55 +00001131 File_System == "f2fs" ||
Erfan Abdib859e912019-02-05 18:18:46 +02001132 File_System == "squashfs" ||
Dees_Troy5bf43922012-09-07 16:07:55 -04001133 File_System == "auto")
1134 return true;
1135 else
1136 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001137}
1138
Dees_Troy5bf43922012-09-07 16:07:55 -04001139bool TWPartition::Is_Image(string File_System) {
Dees_Troy5fcd8f92012-10-16 12:22:05 -04001140 if (File_System == "emmc" || File_System == "mtd" || File_System == "bml")
Dees_Troy5bf43922012-09-07 16:07:55 -04001141 return true;
1142 else
1143 return false;
1144}
1145
Dees_Troy51127312012-09-08 13:08:49 -04001146bool TWPartition::Make_Dir(string Path, bool Display_Error) {
Ethan Yonker93ac7a02016-11-07 22:05:58 -06001147 if (TWFunc::Get_D_Type_From_Stat(Path) != S_IFDIR)
1148 unlink(Path.c_str());
Dees_Troy43d8b002012-09-17 16:00:01 -04001149 if (!TWFunc::Path_Exists(Path)) {
Dees_Troy51127312012-09-08 13:08:49 -04001150 if (mkdir(Path.c_str(), 0777) == -1) {
1151 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001152 gui_msg(Msg(msg::kError, "create_folder_strerr=Can not create '{1}' folder ({2}).")(Path)(strerror(errno)));
Dees_Troy51127312012-09-08 13:08:49 -04001153 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001154 LOGINFO("Can not create '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001155 return false;
1156 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001157 LOGINFO("Created '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001158 return true;
1159 }
1160 }
1161 return true;
1162}
1163
Dees_Troy5bf43922012-09-07 16:07:55 -04001164void TWPartition::Setup_File_System(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001165 Can_Be_Mounted = true;
1166 Can_Be_Wiped = true;
1167
Dees_Troy5bf43922012-09-07 16:07:55 -04001168 // Make the mount point folder if it doesn't exist
Dees_Troy51127312012-09-08 13:08:49 -04001169 Make_Dir(Mount_Point, Display_Error);
bigbiffce8f83c2015-12-12 18:30:21 -05001170 Backup_Method = BM_FILES;
Dees_Troy5bf43922012-09-07 16:07:55 -04001171}
1172
Ethan Yonker1b190162016-12-05 15:25:19 -06001173void TWPartition::Setup_Image() {
Dees_Troy5bf43922012-09-07 16:07:55 -04001174 Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
1175 Backup_Name = Display_Name;
Gary Peck82599a82012-11-21 16:23:12 -08001176 if (Current_File_System == "emmc")
bigbiffce8f83c2015-12-12 18:30:21 -05001177 Backup_Method = BM_DD;
Gary Peck82599a82012-11-21 16:23:12 -08001178 else if (Current_File_System == "mtd" || Current_File_System == "bml")
bigbiffce8f83c2015-12-12 18:30:21 -05001179 Backup_Method = BM_FLASH_UTILS;
Dees_Troy5bf43922012-09-07 16:07:55 -04001180 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001181 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 -04001182}
1183
Dees_Troye58d5262012-09-21 12:27:57 -04001184void TWPartition::Setup_AndSec(void) {
Dees_Troya13d74f2013-03-24 08:54:55 -05001185 Backup_Display_Name = "Android Secure";
Dees_Troye58d5262012-09-21 12:27:57 -04001186 Backup_Name = "and-sec";
Dees_Troya13d74f2013-03-24 08:54:55 -05001187 Can_Be_Backed_Up = true;
Dees_Troye58d5262012-09-21 12:27:57 -04001188 Has_Android_Secure = true;
1189 Symlink_Path = Mount_Point + "/.android_secure";
1190 Symlink_Mount_Point = "/and-sec";
1191 Backup_Path = Symlink_Mount_Point;
1192 Make_Dir("/and-sec", true);
1193 Recreate_AndSec_Folder();
Kjell Braden3126a112016-06-19 16:58:15 +00001194 Mount_Storage_Retry(true);
Dees_Troye58d5262012-09-21 12:27:57 -04001195}
1196
that9e0593e2014-10-08 00:01:24 +02001197void TWPartition::Setup_Data_Media() {
Ethan Yonker6277c792014-09-15 14:54:30 -05001198 LOGINFO("Setting up '%s' as data/media emulated storage.\n", Mount_Point.c_str());
Ethan Yonker66a19492015-12-10 10:19:45 -06001199 if (Storage_Name.empty() || Storage_Name == "Data")
1200 Storage_Name = "Internal Storage";
Ethan Yonker6277c792014-09-15 14:54:30 -05001201 Has_Data_Media = true;
1202 Is_Storage = true;
Ethan Yonker66a19492015-12-10 10:19:45 -06001203 Storage_Path = Mount_Point + "/media";
Ethan Yonker6277c792014-09-15 14:54:30 -05001204 Symlink_Path = Storage_Path;
Ethan Yonker66a19492015-12-10 10:19:45 -06001205 if (Mount_Point == "/data") {
1206 Is_Settings_Storage = true;
1207 if (strcmp(EXPAND(TW_EXTERNAL_STORAGE_PATH), "/sdcard") == 0) {
1208 Make_Dir("/emmc", false);
1209 Symlink_Mount_Point = "/emmc";
1210 } else {
1211 Make_Dir("/sdcard", false);
1212 Symlink_Mount_Point = "/sdcard";
1213 }
1214 if (Mount(false) && TWFunc::Path_Exists(Mount_Point + "/media/0")) {
1215 Storage_Path = Mount_Point + "/media/0";
1216 Symlink_Path = Storage_Path;
1217 DataManager::SetValue(TW_INTERNAL_PATH, Mount_Point + "/media/0");
1218 UnMount(true);
1219 }
1220 DataManager::SetValue("tw_has_internal", 1);
1221 DataManager::SetValue("tw_has_data_media", 1);
Ethan Yonker3fdcda42016-11-30 12:29:37 -06001222 backup_exclusions.add_absolute_dir("/data/data/com.google.android.music/files");
bigbiff25d25b92020-06-19 16:07:38 -04001223 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 +01001224 backup_exclusions.add_absolute_dir("/data/vendor/dumpsys");
bigbiff25d25b92020-06-19 16:07:38 -04001225 backup_exclusions.add_absolute_dir("/data/cache");
Ethan Yonker6355b562017-05-01 09:42:17 -05001226 wipe_exclusions.add_absolute_dir(Mount_Point + "/misc/vold"); // adopted storage keys
Ethan Yonker79f88bd2016-12-09 14:52:12 -06001227 ExcludeAll(Mount_Point + "/system/storage.xml");
Ethan Yonker6277c792014-09-15 14:54:30 -05001228 } else {
Ethan Yonker66a19492015-12-10 10:19:45 -06001229 if (Mount(true) && TWFunc::Path_Exists(Mount_Point + "/media/0")) {
1230 Storage_Path = Mount_Point + "/media/0";
1231 Symlink_Path = Storage_Path;
1232 UnMount(true);
1233 }
Ethan Yonker6277c792014-09-15 14:54:30 -05001234 }
Ethan Yonker79f88bd2016-12-09 14:52:12 -06001235 ExcludeAll(Mount_Point + "/media");
Ethan Yonker6277c792014-09-15 14:54:30 -05001236}
1237
Dees_Troy5bf43922012-09-07 16:07:55 -04001238void TWPartition::Find_Real_Block_Device(string& Block, bool Display_Error) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001239 char device[PATH_MAX], realDevice[PATH_MAX];
Dees_Troy5bf43922012-09-07 16:07:55 -04001240
Peter Caid68e6412019-11-02 19:22:38 +08001241 Original_Path = Block;
1242
Dees_Troy5bf43922012-09-07 16:07:55 -04001243 strcpy(device, Block.c_str());
1244 memset(realDevice, 0, sizeof(realDevice));
1245 while (readlink(device, realDevice, sizeof(realDevice)) > 0)
1246 {
1247 strcpy(device, realDevice);
1248 memset(realDevice, 0, sizeof(realDevice));
1249 }
1250
1251 if (device[0] != '/') {
1252 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001253 LOGERR("Invalid symlink path '%s' found on block device '%s'\n", device, Block.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001254 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001255 LOGINFO("Invalid symlink path '%s' found on block device '%s'\n", device, Block.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001256 return;
Dees_Troy51a0e822012-09-05 15:24:24 -04001257 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -04001258 Block = device;
1259 return;
1260 }
1261}
1262
Kjell Braden3126a112016-06-19 16:58:15 +00001263bool TWPartition::Mount_Storage_Retry(bool Display_Error) {
Dees_Troy8e337f32012-10-13 22:07:49 -04001264 // On some devices, storage doesn't want to mount right away, retry and sleep
Kjell Braden3126a112016-06-19 16:58:15 +00001265 if (!Mount(Display_Error)) {
Dees_Troy8e337f32012-10-13 22:07:49 -04001266 int retry_count = 5;
1267 while (retry_count > 0 && !Mount(false)) {
1268 usleep(500000);
1269 retry_count--;
1270 }
Kjell Braden3126a112016-06-19 16:58:15 +00001271 return Mount(Display_Error);
Dees_Troy8e337f32012-10-13 22:07:49 -04001272 }
Kjell Braden3126a112016-06-19 16:58:15 +00001273 return true;
Dees_Troy8e337f32012-10-13 22:07:49 -04001274}
1275
Dees_Troy38bd7602012-09-14 13:33:53 -04001276bool TWPartition::Find_MTD_Block_Device(string MTD_Name) {
1277 FILE *fp = NULL;
1278 char line[255];
1279
1280 fp = fopen("/proc/mtd", "rt");
1281 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001282 LOGERR("Device does not support /proc/mtd\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001283 return false;
1284 }
1285
1286 while (fgets(line, sizeof(line), fp) != NULL)
1287 {
1288 char device[32], label[32];
1289 unsigned long size = 0;
Dees_Troy38bd7602012-09-14 13:33:53 -04001290 int deviceId;
1291
1292 sscanf(line, "%s %lx %*s %*c%s", device, &size, label);
1293
1294 // Skip header and blank lines
1295 if ((strcmp(device, "dev:") == 0) || (strlen(line) < 8))
1296 continue;
1297
1298 // Strip off the trailing " from the label
1299 label[strlen(label)-1] = '\0';
1300
1301 if (strcmp(label, MTD_Name.c_str()) == 0) {
1302 // We found our device
1303 // Strip off the trailing : from the device
1304 device[strlen(device)-1] = '\0';
1305 if (sscanf(device,"mtd%d", &deviceId) == 1) {
1306 sprintf(device, "/dev/block/mtdblock%d", deviceId);
1307 Primary_Block_Device = device;
Dees_Troy76543db2013-06-19 16:24:30 +00001308 fclose(fp);
1309 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -04001310 }
1311 }
1312 }
1313 fclose(fp);
1314
1315 return false;
1316}
1317
Dees_Troy51127312012-09-08 13:08:49 -04001318bool TWPartition::Get_Size_Via_statfs(bool Display_Error) {
1319 struct statfs st;
1320 string Local_Path = Mount_Point + "/.";
1321
1322 if (!Mount(Display_Error))
1323 return false;
1324
1325 if (statfs(Local_Path.c_str(), &st) != 0) {
1326 if (!Removable) {
1327 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001328 LOGERR("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001329 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001330 LOGINFO("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001331 }
1332 return false;
1333 }
1334 Size = (st.f_blocks * st.f_bsize);
1335 Used = ((st.f_blocks - st.f_bfree) * st.f_bsize);
1336 Free = (st.f_bfree * st.f_bsize);
1337 Backup_Size = Used;
1338 return true;
1339}
1340
1341bool TWPartition::Get_Size_Via_df(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001342 FILE* fp;
1343 char command[255], line[512];
1344 int include_block = 1;
1345 unsigned int min_len;
1346
1347 if (!Mount(Display_Error))
1348 return false;
1349
Dees_Troy38bd7602012-09-14 13:33:53 -04001350 min_len = Actual_Block_Device.size() + 2;
Dees_Troy51127312012-09-08 13:08:49 -04001351 sprintf(command, "df %s > /tmp/dfoutput.txt", Mount_Point.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001352 TWFunc::Exec_Cmd(command);
Dees_Troy51127312012-09-08 13:08:49 -04001353 fp = fopen("/tmp/dfoutput.txt", "rt");
1354 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001355 LOGINFO("Unable to open /tmp/dfoutput.txt.\n");
Dees_Troy5bf43922012-09-07 16:07:55 -04001356 return false;
Dees_Troy51127312012-09-08 13:08:49 -04001357 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001358
1359 while (fgets(line, sizeof(line), fp) != NULL)
1360 {
1361 unsigned long blocks, used, available;
1362 char device[64];
1363 char tmpString[64];
1364
1365 if (strncmp(line, "Filesystem", 10) == 0)
1366 continue;
1367 if (strlen(line) < min_len) {
1368 include_block = 0;
1369 continue;
1370 }
1371 if (include_block) {
1372 sscanf(line, "%s %lu %lu %lu", device, &blocks, &used, &available);
1373 } else {
1374 // The device block string is so long that the df information is on the next line
1375 int space_count = 0;
Dees_Troye58d5262012-09-21 12:27:57 -04001376 sprintf(tmpString, "/dev/block/%s", Actual_Block_Device.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001377 while (tmpString[space_count] == 32)
1378 space_count++;
1379 sscanf(line + space_count, "%lu %lu %lu", &blocks, &used, &available);
1380 }
1381
1382 // Adjust block size to byte size
1383 Size = blocks * 1024ULL;
1384 Used = used * 1024ULL;
1385 Free = available * 1024ULL;
1386 Backup_Size = Used;
1387 }
1388 fclose(fp);
1389 return true;
1390}
1391
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001392unsigned long long TWPartition::IOCTL_Get_Block_Size() {
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001393 Find_Actual_Block_Device();
Ethan Yonker483e9f42016-01-11 22:21:18 -06001394
1395 return TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001396}
1397
Dees_Troy5bf43922012-09-07 16:07:55 -04001398bool TWPartition::Find_Partition_Size(void) {
1399 FILE* fp;
1400 char line[512];
1401 string tmpdevice;
1402
igoriok87e3d932013-01-31 21:03:53 +02001403 fp = fopen("/proc/dumchar_info", "rt");
1404 if (fp != NULL) {
1405 while (fgets(line, sizeof(line), fp) != NULL)
1406 {
1407 char label[32], device[32];
1408 unsigned long size = 0;
1409
thatd43bf2d2014-09-21 23:13:02 +02001410 sscanf(line, "%s %lx %*x %*u %s", label, &size, device);
igoriok87e3d932013-01-31 21:03:53 +02001411
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05001412 // Skip header, annotation and blank lines
igoriok87e3d932013-01-31 21:03:53 +02001413 if ((strncmp(device, "/dev/", 5) != 0) || (strlen(line) < 8))
1414 continue;
1415
1416 tmpdevice = "/dev/";
1417 tmpdevice += label;
1418 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
1419 Size = size;
1420 fclose(fp);
1421 return true;
1422 }
1423 }
1424 }
1425
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001426 unsigned long long ioctl_size = IOCTL_Get_Block_Size();
1427 if (ioctl_size) {
1428 Size = ioctl_size;
1429 return true;
1430 }
1431
Dees_Troy5bf43922012-09-07 16:07:55 -04001432 // In this case, we'll first get the partitions we care about (with labels)
1433 fp = fopen("/proc/partitions", "rt");
1434 if (fp == NULL)
1435 return false;
1436
1437 while (fgets(line, sizeof(line), fp) != NULL)
1438 {
1439 unsigned long major, minor, blocks;
1440 char device[512];
Dees_Troy5bf43922012-09-07 16:07:55 -04001441
Dees_Troy63c8df72012-09-10 14:02:05 -04001442 if (strlen(line) < 7 || line[0] == 'm') continue;
Dees_Troy5bf43922012-09-07 16:07:55 -04001443 sscanf(line + 1, "%lu %lu %lu %s", &major, &minor, &blocks, device);
1444
1445 tmpdevice = "/dev/block/";
1446 tmpdevice += device;
Dees_Troy38bd7602012-09-14 13:33:53 -04001447 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001448 // Adjust block size to byte size
1449 Size = blocks * 1024ULL;
1450 fclose(fp);
1451 return true;
1452 }
1453 }
1454 fclose(fp);
1455 return false;
1456}
1457
Dees_Troy5bf43922012-09-07 16:07:55 -04001458bool TWPartition::Is_Mounted(void) {
1459 if (!Can_Be_Mounted)
1460 return false;
1461
1462 struct stat st1, st2;
1463 string test_path;
1464
1465 // Check to see if the mount point directory exists
1466 test_path = Mount_Point + "/.";
1467 if (stat(test_path.c_str(), &st1) != 0) return false;
1468
1469 // Check to see if the directory above the mount point exists
1470 test_path = Mount_Point + "/../.";
1471 if (stat(test_path.c_str(), &st2) != 0) return false;
1472
1473 // Compare the device IDs -- if they match then we're (probably) using tmpfs instead of an actual device
1474 int ret = (st1.st_dev != st2.st_dev) ? true : false;
Dees_Troy5bf43922012-09-07 16:07:55 -04001475 return ret;
1476}
1477
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05001478bool TWPartition::Is_File_System_Writable(void) {
1479 if (!Is_File_System(Current_File_System) || !Is_Mounted())
1480 return false;
1481
1482 string test_path = Mount_Point + "/.";
1483 return (access(test_path.c_str(), W_OK) == 0);
1484}
1485
Dees_Troy5bf43922012-09-07 16:07:55 -04001486bool TWPartition::Mount(bool Display_Error) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001487 int exfat_mounted = 0;
Martin Dünkelmann6d843782018-12-27 23:40:28 +01001488 unsigned int flags = Mount_Flags;
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001489
Dees_Troy5bf43922012-09-07 16:07:55 -04001490 if (Is_Mounted()) {
1491 return true;
1492 } else if (!Can_Be_Mounted) {
1493 return false;
1494 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001495
1496 Find_Actual_Block_Device();
1497
1498 // Check the current file system before mounting
1499 Check_FS_Type();
bigbiffad58e1b2020-07-06 20:24:34 -04001500 if (Current_File_System == "exfat" && TWFunc::Path_Exists("/system/bin/exfat-fuse")) {
1501 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 +00001502 LOGINFO("cmd: %s\n", cmd.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001503 string result;
bigbiffad58e1b2020-07-06 20:24:34 -04001504 if (TWFunc::Exec_Cmd(cmd, result, false) != 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001505 LOGINFO("exfat-fuse failed to mount with result '%s', trying vfat\n", result.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001506 Current_File_System = "vfat";
1507 } else {
1508#ifdef TW_NO_EXFAT_FUSE
1509 UnMount(false);
1510 // We'll let the kernel handle it but using exfat-fuse to detect if the file system is actually exfat
1511 // Some kernels let us mount vfat as exfat which doesn't work out too well
1512#else
1513 exfat_mounted = 1;
1514#endif
1515 }
1516 }
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001517
Captain Throwback47bf7202020-10-06 17:39:39 -04001518 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 -05001519 string cmd;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001520 string Ntfsmount_Binary = "";
1521
bigbiffad58e1b2020-07-06 20:24:34 -04001522 if (TWFunc::Path_Exists("/system/bin/ntfs-3g"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001523 Ntfsmount_Binary = "ntfs-3g";
bigbiffad58e1b2020-07-06 20:24:34 -04001524 else if (TWFunc::Path_Exists("/system/bin/mount.ntfs"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001525 Ntfsmount_Binary = "mount.ntfs";
1526
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001527 if (Mount_Read_Only)
bigbiffad58e1b2020-07-06 20:24:34 -04001528 cmd = "/system/bin/" + Ntfsmount_Binary + " -o ro " + Actual_Block_Device + " " + Mount_Point;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001529 else
bigbiffad58e1b2020-07-06 20:24:34 -04001530 cmd = "/system/bin/" + Ntfsmount_Binary + " " + Actual_Block_Device + " " + Mount_Point;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001531 LOGINFO("cmd: '%s'\n", cmd.c_str());
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001532
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001533 if (TWFunc::Exec_Cmd(cmd) == 0) {
1534 return true;
1535 } else {
1536 LOGINFO("ntfs-3g failed to mount, trying regular mount method.\n");
1537 }
Captain Throwback47bf7202020-10-06 17:39:39 -04001538 } else {
1539 if (Current_File_System == "ntfs" && TWFunc::Path_Exists("/sys/module/tntfs"))
1540 Current_File_System = "tntfs";
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001541 }
1542
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001543 if (Mount_Read_Only)
1544 flags |= MS_RDONLY;
1545
Dees_Troy22042032012-12-18 21:23:08 +00001546 if (Fstab_File_System == "yaffs2") {
1547 // mount an MTD partition as a YAFFS2 filesystem.
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001548 flags = MS_NOATIME | MS_NODEV | MS_NODIRATIME;
1549 if (Mount_Read_Only)
1550 flags |= MS_RDONLY;
Dees_Troy76543db2013-06-19 16:24:30 +00001551 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags, NULL) < 0) {
1552 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags | MS_RDONLY, NULL) < 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 } else {
1559 LOGINFO("Mounted '%s' (MTD) as RO\n", Mount_Point.c_str());
1560 return true;
1561 }
1562 } else {
1563 struct stat st;
1564 string test_path = Mount_Point;
1565 if (stat(test_path.c_str(), &st) < 0) {
1566 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001567 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy76543db2013-06-19 16:24:30 +00001568 else
1569 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
1570 return false;
1571 }
1572 mode_t new_mode = st.st_mode | S_IXUSR | S_IXGRP | S_IXOTH;
1573 if (new_mode != st.st_mode) {
1574 LOGINFO("Fixing execute permissions for %s\n", Mount_Point.c_str());
1575 if (chmod(Mount_Point.c_str(), new_mode) < 0) {
1576 if (Display_Error)
1577 LOGERR("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
1578 else
1579 LOGINFO("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
1580 return false;
1581 }
1582 }
Dees_Troy22042032012-12-18 21:23:08 +00001583 return true;
Dees_Troy76543db2013-06-19 16:24:30 +00001584 }
thatc7572eb2015-03-31 18:55:30 +02001585 }
1586
1587 string mount_fs = Current_File_System;
1588 if (Current_File_System == "exfat" && TWFunc::Path_Exists("/sys/module/texfat"))
1589 mount_fs = "texfat";
1590
1591 if (!exfat_mounted &&
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001592 mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), mount_fs.c_str(), flags, Mount_Options.c_str()) != 0 &&
1593 mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), mount_fs.c_str(), flags, NULL) != 0) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001594#ifdef TW_NO_EXFAT_FUSE
1595 if (Current_File_System == "exfat") {
Dees_Troy2673cec2013-04-02 20:22:16 +00001596 LOGINFO("Mounting exfat failed, trying vfat...\n");
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001597 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), "vfat", 0, NULL) != 0) {
Dees_Troy85f44ed2013-01-09 18:42:36 +00001598 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001599 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy85f44ed2013-01-09 18:42:36 +00001600 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001601 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001602 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 +00001603 return false;
Dees_Troy85f44ed2013-01-09 18:42:36 +00001604 }
Dees_Troyb05ddee2013-01-28 20:24:50 +00001605 } else {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001606#endif
bigbiff bigbiff26774a02014-03-29 18:22:00 -04001607 if (!Removable && Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001608 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001609 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001610 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
1611 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 +00001612 return false;
1613#ifdef TW_NO_EXFAT_FUSE
Dees_Troy85f44ed2013-01-09 18:42:36 +00001614 }
1615#endif
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001616 }
Ethan Yonker253368a2014-11-25 15:00:52 -06001617
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001618 if (Removable)
1619 Update_Size(Display_Error);
1620
bigbiffbe4f46c2021-04-24 11:48:54 -04001621 if (!Symlink_Mount_Point.empty()) {
1622 if (!Bind_Mount(false))
1623 return false;
1624 }
1625 return true;
1626}
1627
1628bool TWPartition::Bind_Mount(bool Display_Error) {
1629 if (TWFunc::Path_Exists(Symlink_Path)) {
1630 if (mount(Symlink_Path.c_str(), Symlink_Mount_Point.c_str(), "", MS_BIND, NULL) < 0) {
1631 return false;
1632 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001633 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001634 return true;
1635}
1636
1637bool TWPartition::UnMount(bool Display_Error) {
1638 if (Is_Mounted()) {
1639 int never_unmount_system;
1640
1641 DataManager::GetValue(TW_DONT_UNMOUNT_SYSTEM, never_unmount_system);
Captain Throwback9d6feb52018-07-27 10:05:24 -04001642 if (never_unmount_system == 1 && Mount_Point == PartitionManager.Get_Android_Root_Path())
Dees_Troy5bf43922012-09-07 16:07:55 -04001643 return true; // Never unmount system if you're not supposed to unmount it
1644
Matt Mowera8e6d832017-02-14 20:20:59 -06001645 if (Is_Storage && MTP_Storage_ID > 0)
Ethan Yonker726a0202014-12-16 20:01:38 -06001646 PartitionManager.Remove_MTP_Storage(MTP_Storage_ID);
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001647
Dees_Troy38bd7602012-09-14 13:33:53 -04001648 if (!Symlink_Mount_Point.empty())
1649 umount(Symlink_Mount_Point.c_str());
1650
Dees_Troyb05ddee2013-01-28 20:24:50 +00001651 umount(Mount_Point.c_str());
1652 if (Is_Mounted()) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001653 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001654 gui_msg(Msg(msg::kError, "fail_unmount=Failed to unmount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy5bf43922012-09-07 16:07:55 -04001655 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001656 LOGINFO("Unable to unmount '%s'\n", Mount_Point.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001657 return false;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001658 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -04001659 return true;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001660 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001661 } else {
1662 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001663 }
1664}
1665
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05001666bool TWPartition::ReMount(bool Display_Error) {
1667 if (UnMount(Display_Error))
1668 return Mount(Display_Error);
1669 return false;
1670}
1671
1672bool TWPartition::ReMount_RW(bool Display_Error) {
1673 // No need to remount if already mounted rw
1674 if (Is_File_System_Writable())
1675 return true;
1676
1677 bool ro = Mount_Read_Only;
1678 int flags = Mount_Flags;
1679
1680 Mount_Read_Only = false;
1681 Mount_Flags &= ~MS_RDONLY;
1682
1683 bool ret = ReMount(Display_Error);
1684
1685 Mount_Read_Only = ro;
1686 Mount_Flags = flags;
1687
1688 return ret;
1689}
1690
Gary Peck43acadf2012-11-21 21:19:01 -08001691bool TWPartition::Wipe(string New_File_System) {
Ethan Yonker726a0202014-12-16 20:01:38 -06001692 bool wiped = false, update_crypt = false, recreate_media = true;
Dees_Troy16c2b312013-01-15 16:51:18 +00001693 int check;
Dees_Troy16c2b312013-01-15 16:51:18 +00001694
Dees_Troy38bd7602012-09-14 13:33:53 -04001695 if (!Can_Be_Wiped) {
Matt Mower3c366972015-12-25 19:28:31 -06001696 gui_msg(Msg(msg::kError, "cannot_wipe=Partition {1} cannot be wiped.")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04001697 return false;
1698 }
1699
Dees_Troyc51f1f92012-09-20 15:32:13 -04001700 if (Mount_Point == "/cache")
Dees_Troy2673cec2013-04-02 20:22:16 +00001701 Log_Offset = 0;
Dees_Troyc51f1f92012-09-20 15:32:13 -04001702
bigbiff4a60bee2021-01-23 14:08:03 -05001703 if (Mount_Point == PartitionManager.Get_Android_Root_Path()) {
1704 if (tw_get_default_metadata(PartitionManager.Get_Android_Root_Path().c_str()) != 0) {
1705 gui_msg(Msg(msg::kWarning, "restore_system_context=Unable to get default context for {1} -- Android may not boot.")(PartitionManager.Get_Android_Root_Path()));
1706 }
1707 }
1708
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001709 if (Has_Data_Media && Current_File_System == New_File_System) {
Dees_Troy16c2b312013-01-15 16:51:18 +00001710 wiped = Wipe_Data_Without_Wiping_Media();
bigbiff25d25b92020-06-19 16:07:38 -04001711 if (Mount_Point == "/data" && TWFunc::get_log_dir() == DATA_LOGS_DIR) {
1712 bool created = PartitionManager.Recreate_Logs_Dir();
1713 if (!created)
1714 LOGERR("Unable to create log directory for TWRP\n");
bigbiff7ba75002020-04-11 20:47:09 -04001715 }
Ethan Yonker5eac2222014-06-11 12:22:55 -05001716 recreate_media = false;
Dees_Troy16c2b312013-01-15 16:51:18 +00001717 } else {
Dees_Troy16c2b312013-01-15 16:51:18 +00001718 DataManager::GetValue(TW_RM_RF_VAR, check);
Hashcodedabfd492013-08-29 22:45:30 -07001719 if (check || Use_Rm_Rf)
Dees_Troy16c2b312013-01-15 16:51:18 +00001720 wiped = Wipe_RMRF();
1721 else if (New_File_System == "ext4")
1722 wiped = Wipe_EXT4();
1723 else if (New_File_System == "ext2" || New_File_System == "ext3")
dianlujitao4879b372018-12-03 18:45:47 +08001724 wiped = Wipe_EXTFS(New_File_System);
Dees_Troy16c2b312013-01-15 16:51:18 +00001725 else if (New_File_System == "exfat")
1726 wiped = Wipe_EXFAT();
Captain Throwback47bf7202020-10-06 17:39:39 -04001727 else if (New_File_System == "ntfs" || Current_File_System == "tntfs")
1728 wiped = Wipe_NTFS();
Dees_Troy16c2b312013-01-15 16:51:18 +00001729 else if (New_File_System == "yaffs2")
1730 wiped = Wipe_MTD();
Dees_Troye5017042013-08-29 16:38:55 +00001731 else if (New_File_System == "f2fs")
1732 wiped = Wipe_F2FS();
Captain Throwback47bf7202020-10-06 17:39:39 -04001733 else if (New_File_System == "vfat")
1734 wiped = Wipe_FAT();
Dees_Troy16c2b312013-01-15 16:51:18 +00001735 else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001736 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 +00001737 return false;
1738 }
1739 update_crypt = wiped;
bigbiff7ba75002020-04-11 20:47:09 -04001740 update_crypt = false;
Gary Pecke8bc5d72012-12-21 06:45:25 -08001741 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001742
Gary Pecke8bc5d72012-12-21 06:45:25 -08001743 if (wiped) {
Mohd Faraze1d72622020-06-15 00:28:32 +05301744 if (Mount_Point == "/cache" && TWFunc::get_log_dir() != DATA_LOGS_DIR)
1745 DataManager::Output_Version();
1746
bigbiff4a60bee2021-01-23 14:08:03 -05001747 if (Mount_Point == PartitionManager.Get_Android_Root_Path()) {
1748 tw_set_default_metadata(PartitionManager.Get_Android_Root_Path().c_str());
1749 }
Dees_Troy16c2b312013-01-15 16:51:18 +00001750 if (update_crypt) {
1751 Setup_File_System(false);
1752 if (Is_Encrypted && !Is_Decrypted) {
1753 // just wiped an encrypted partition back to its unencrypted state
1754 Is_Encrypted = false;
1755 Is_Decrypted = false;
1756 Decrypted_Block_Device = "";
1757 if (Mount_Point == "/data") {
1758 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
1759 DataManager::SetValue(TW_IS_DECRYPTED, 0);
1760 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08001761 }
1762 }
Ethan Yonker5eac2222014-06-11 12:22:55 -05001763
bigbiffbe4f46c2021-04-24 11:48:54 -04001764 if (Is_Storage && Mount(false))
1765 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
Gary Pecke8bc5d72012-12-21 06:45:25 -08001766 }
Matt Mower209c9632016-01-20 12:08:35 -06001767
Gary Pecke8bc5d72012-12-21 06:45:25 -08001768 return wiped;
Dees_Troy51a0e822012-09-05 15:24:24 -04001769}
1770
Gary Peck43acadf2012-11-21 21:19:01 -08001771bool TWPartition::Wipe() {
Gary Peck82599a82012-11-21 16:23:12 -08001772 if (Is_File_System(Current_File_System))
1773 return Wipe(Current_File_System);
1774 else
1775 return Wipe(Fstab_File_System);
Gary Peck43acadf2012-11-21 21:19:01 -08001776}
1777
Dees_Troye58d5262012-09-21 12:27:57 -04001778bool TWPartition::Wipe_AndSec(void) {
1779 if (!Has_Android_Secure)
1780 return false;
1781
Dees_Troye58d5262012-09-21 12:27:57 -04001782 if (!Mount(true))
1783 return false;
1784
Ethan Yonker74db1572015-10-28 12:44:49 -05001785 gui_msg(Msg("wiping=Wiping {1}")(Backup_Display_Name));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001786 TWFunc::removeDir(Mount_Point + "/.android_secure/", true);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001787 return true;
Dees_Troye58d5262012-09-21 12:27:57 -04001788}
1789
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001790bool TWPartition::Can_Repair() {
Ethan Yonkera2719152015-05-28 09:44:41 -05001791 if (Mount_Read_Only)
1792 return false;
bigbiffad58e1b2020-07-06 20:24:34 -04001793 if (Current_File_System == "vfat" && TWFunc::Path_Exists("/system/bin/fsck.fat"))
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001794 return true;
bigbiffad58e1b2020-07-06 20:24:34 -04001795 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 -05001796 return true;
bigbiffad58e1b2020-07-06 20:24:34 -04001797 else if (Current_File_System == "exfat" && TWFunc::Path_Exists("/system/bin/fsck.exfat"))
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001798 return true;
bigbiffad58e1b2020-07-06 20:24:34 -04001799 else if (Current_File_System == "f2fs" && TWFunc::Path_Exists("/system/bin/fsck.f2fs"))
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001800 return true;
Captain Throwback47bf7202020-10-06 17:39:39 -04001801 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 -05001802 return true;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001803 return false;
1804}
1805
1806bool TWPartition::Repair() {
1807 string command;
1808
1809 if (Current_File_System == "vfat") {
bigbiffad58e1b2020-07-06 20:24:34 -04001810 if (!TWFunc::Path_Exists("/system/bin/fsck.fat")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001811 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.fat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001812 return false;
1813 }
1814 if (!UnMount(true))
1815 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001816 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.fat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001817 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001818 command = "/system/bin/fsck.fat -y " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001819 LOGINFO("Repair command: %s\n", command.c_str());
1820 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001821 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001822 return true;
1823 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001824 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001825 return false;
1826 }
1827 }
1828 if (Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") {
bigbiffad58e1b2020-07-06 20:24:34 -04001829 if (!TWFunc::Path_Exists("/system/bin/e2fsck")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001830 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("e2fsck"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001831 return false;
1832 }
1833 if (!UnMount(true))
1834 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001835 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("e2fsck"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001836 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001837 command = "/system/bin/e2fsck -fp " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001838 LOGINFO("Repair command: %s\n", command.c_str());
1839 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001840 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001841 return true;
1842 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001843 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001844 return false;
1845 }
1846 }
1847 if (Current_File_System == "exfat") {
bigbiffad58e1b2020-07-06 20:24:34 -04001848 if (!TWFunc::Path_Exists("/system/bin/fsck.exfat")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001849 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.exfat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001850 return false;
1851 }
1852 if (!UnMount(true))
1853 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001854 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.exfat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001855 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001856 command = "/system/bin/fsck.exfat " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001857 LOGINFO("Repair command: %s\n", command.c_str());
1858 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001859 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001860 return true;
1861 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001862 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001863 return false;
1864 }
1865 }
1866 if (Current_File_System == "f2fs") {
bigbiffad58e1b2020-07-06 20:24:34 -04001867 if (!TWFunc::Path_Exists("/system/bin/fsck.f2fs")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001868 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.f2fs"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001869 return false;
1870 }
1871 if (!UnMount(true))
1872 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001873 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.f2fs"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001874 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001875 command = "/system/bin/fsck.f2fs " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001876 LOGINFO("Repair command: %s\n", command.c_str());
1877 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001878 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001879 return true;
1880 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001881 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001882 return false;
1883 }
1884 }
Captain Throwback47bf7202020-10-06 17:39:39 -04001885 if (Current_File_System == "ntfs" || Current_File_System == "tntfs") {
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001886 string Ntfsfix_Binary;
bigbiffad58e1b2020-07-06 20:24:34 -04001887 if (TWFunc::Path_Exists("/system/bin/ntfsfix"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001888 Ntfsfix_Binary = "ntfsfix";
bigbiffad58e1b2020-07-06 20:24:34 -04001889 else if (TWFunc::Path_Exists("/system/bin/fsck.ntfs"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001890 Ntfsfix_Binary = "fsck.ntfs";
1891 else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001892 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("ntfsfix"));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001893 return false;
1894 }
1895 if (!UnMount(true))
1896 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001897 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)(Ntfsfix_Binary));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001898 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001899 command = "/system/bin/" + Ntfsfix_Binary + " " + Actual_Block_Device;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001900 LOGINFO("Repair command: %s\n", command.c_str());
1901 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001902 gui_msg("done=Done.");
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001903 return true;
1904 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001905 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001906 return false;
1907 }
1908 }
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001909 return false;
1910}
1911
Ethan Yonkera2719152015-05-28 09:44:41 -05001912bool TWPartition::Can_Resize() {
1913 if (Mount_Read_Only)
1914 return false;
bigbiffad58e1b2020-07-06 20:24:34 -04001915 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 -05001916 return true;
1917 return false;
1918}
1919
1920bool TWPartition::Resize() {
1921 string command;
1922
1923 if (Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") {
1924 if (!Can_Repair()) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001925 LOGINFO("Cannot resize %s because %s cannot be repaired before resizing.\n", Display_Name.c_str(), Display_Name.c_str());
1926 gui_msg(Msg(msg::kError, "cannot_resize=Cannot resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001927 return false;
1928 }
bigbiffad58e1b2020-07-06 20:24:34 -04001929 if (!TWFunc::Path_Exists("/system/bin/resize2fs")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001930 LOGINFO("resize2fs does not exist! Cannot resize!\n");
1931 gui_msg(Msg(msg::kError, "cannot_resize=Cannot resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001932 return false;
1933 }
1934 // Repair will unmount so no need to do it twice
Ethan Yonker74db1572015-10-28 12:44:49 -05001935 gui_msg(Msg("repair_resize=Repairing {1} before resizing.")( Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001936 if (!Repair())
1937 return false;
Ethan Yonker74db1572015-10-28 12:44:49 -05001938 gui_msg(Msg("resizing=Resizing {1} using {2}...")(Display_Name)("resize2fs"));
Ethan Yonkera2719152015-05-28 09:44:41 -05001939 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001940 command = "/system/bin/resize2fs " + Actual_Block_Device;
Ethan Yonkera2719152015-05-28 09:44:41 -05001941 if (Length != 0) {
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001942 unsigned long long Actual_Size = IOCTL_Get_Block_Size();
1943 if (Actual_Size == 0)
1944 return false;
Ethan Yonkera2719152015-05-28 09:44:41 -05001945
Ethan Yonkera2719152015-05-28 09:44:41 -05001946 unsigned long long Block_Count;
1947 if (Length < 0) {
1948 // Reduce overall size by this length
1949 Block_Count = (Actual_Size / 1024LLU) - ((unsigned long long)(Length * -1) / 1024LLU);
1950 } else {
1951 // This is the size, not a size reduction
1952 Block_Count = ((unsigned long long)(Length) / 1024LLU);
1953 }
1954 char temp[256];
1955 sprintf(temp, "%llu", Block_Count);
1956 command += " ";
1957 command += temp;
1958 command += "K";
1959 }
1960 LOGINFO("Resize command: %s\n", command.c_str());
1961 if (TWFunc::Exec_Cmd(command) == 0) {
1962 Update_Size(true);
Ethan Yonker74db1572015-10-28 12:44:49 -05001963 gui_msg("done=Done.");
Ethan Yonkera2719152015-05-28 09:44:41 -05001964 return true;
1965 } else {
1966 Update_Size(true);
Ethan Yonker74db1572015-10-28 12:44:49 -05001967 gui_msg(Msg(msg::kError, "unable_resize=Unable to resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001968 return false;
1969 }
1970 }
1971 return false;
1972}
1973
bigbiffce8f83c2015-12-12 18:30:21 -05001974bool TWPartition::Backup(PartitionSettings *part_settings, pid_t *tar_fork_pid) {
1975 if (Backup_Method == BM_FILES)
1976 return Backup_Tar(part_settings, tar_fork_pid);
1977 else if (Backup_Method == BM_DD)
1978 return Backup_Image(part_settings);
1979 else if (Backup_Method == BM_FLASH_UTILS)
1980 return Backup_Dump_Image(part_settings);
Dees_Troy2673cec2013-04-02 20:22:16 +00001981 LOGERR("Unknown backup method for '%s'\n", Mount_Point.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001982 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001983}
1984
bigbiffce8f83c2015-12-12 18:30:21 -05001985bool TWPartition::Restore(PartitionSettings *part_settings) {
Matt Mower3c366972015-12-25 19:28:31 -06001986 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Display_Name, gui_parse_text("{@restoring_hdr}"));
Ethan Yonkere080c1f2016-09-19 13:50:25 -05001987 LOGINFO("Restore filename is: %s/%s\n", part_settings->Backup_Folder.c_str(), Backup_FileName.c_str());
Gary Peck43acadf2012-11-21 21:19:01 -08001988
bigbiffce8f83c2015-12-12 18:30:21 -05001989 string Restore_File_System = Get_Restore_File_System(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001990
1991 if (Is_File_System(Restore_File_System))
bigbiffce8f83c2015-12-12 18:30:21 -05001992 return Restore_Tar(part_settings);
1993 else if (Is_Image(Restore_File_System))
1994 return Restore_Image(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001995
1996 LOGERR("Unknown restore method for '%s'\n", Mount_Point.c_str());
1997 return false;
1998}
1999
bigbiffce8f83c2015-12-12 18:30:21 -05002000string TWPartition::Get_Restore_File_System(PartitionSettings *part_settings) {
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002001 size_t first_period, second_period;
2002 string Restore_File_System;
2003
Gary Peck43acadf2012-11-21 21:19:01 -08002004 // Parse backup filename to extract the file system before wiping
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002005 first_period = Backup_FileName.find(".");
Gary Peck43acadf2012-11-21 21:19:01 -08002006 if (first_period == string::npos) {
Dees_Troy2673cec2013-04-02 20:22:16 +00002007 LOGERR("Unable to find file system (first period).\n");
thatd43bf2d2014-09-21 23:13:02 +02002008 return string();
Gary Peck43acadf2012-11-21 21:19:01 -08002009 }
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002010 Restore_File_System = Backup_FileName.substr(first_period + 1, Backup_FileName.size() - first_period - 1);
Gary Peck43acadf2012-11-21 21:19:01 -08002011 second_period = Restore_File_System.find(".");
2012 if (second_period == string::npos) {
Dees_Troy2673cec2013-04-02 20:22:16 +00002013 LOGERR("Unable to find file system (second period).\n");
thatd43bf2d2014-09-21 23:13:02 +02002014 return string();
Gary Peck43acadf2012-11-21 21:19:01 -08002015 }
2016 Restore_File_System.resize(second_period);
Matt Mowera0cd91d2016-12-30 18:21:42 -06002017 LOGINFO("Restore file system is: '%s'.\n", Restore_File_System.c_str());
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002018 return Restore_File_System;
Dees_Troy51a0e822012-09-05 15:24:24 -04002019}
2020
2021string TWPartition::Backup_Method_By_Name() {
bigbiffce8f83c2015-12-12 18:30:21 -05002022 if (Backup_Method == BM_NONE)
Dees_Troy38bd7602012-09-14 13:33:53 -04002023 return "none";
bigbiffce8f83c2015-12-12 18:30:21 -05002024 else if (Backup_Method == BM_FILES)
Dees_Troy38bd7602012-09-14 13:33:53 -04002025 return "files";
bigbiffce8f83c2015-12-12 18:30:21 -05002026 else if (Backup_Method == BM_DD)
Dees_Troy38bd7602012-09-14 13:33:53 -04002027 return "dd";
bigbiffce8f83c2015-12-12 18:30:21 -05002028 else if (Backup_Method == BM_FLASH_UTILS)
Dees_Troy38bd7602012-09-14 13:33:53 -04002029 return "flash_utils";
2030 else
2031 return "undefined";
2032 return "ERROR!";
Dees_Troy51a0e822012-09-05 15:24:24 -04002033}
2034
2035bool TWPartition::Decrypt(string Password) {
Dees_Troy2673cec2013-04-02 20:22:16 +00002036 LOGINFO("STUB TWPartition::Decrypt, password: '%s'\n", Password.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04002037 // Is this needed?
Dees_Troy51a0e822012-09-05 15:24:24 -04002038 return 1;
2039}
2040
2041bool TWPartition::Wipe_Encryption() {
Dees_Troy38bd7602012-09-14 13:33:53 -04002042 bool Save_Data_Media = Has_Data_Media;
Ethan Yonker93382822018-11-01 15:25:31 -05002043 bool ret = false;
2044 BasePartition* base_partition = make_partition();
2045
2046 if (!base_partition->PreWipeEncryption())
2047 goto exit;
Dees_Troy38bd7602012-09-14 13:33:53 -04002048
dianlujitao4879b372018-12-03 18:45:47 +08002049 Find_Actual_Block_Device();
2050 if (!Is_Present) {
2051 LOGINFO("Block device not present, cannot format %s.\n", Display_Name.c_str());
2052 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2053 return false;
2054 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002055
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06002056#ifdef TW_INCLUDE_CRYPTO
bigbiff7ba75002020-04-11 20:47:09 -04002057 if (!UnMount(true))
2058 return false;
Ethan Yonker1b190162016-12-05 15:25:19 -06002059 if (Is_Decrypted && !Decrypted_Block_Device.empty()) {
Matt Mower2b18a532015-02-20 16:58:05 -06002060 if (delete_crypto_blk_dev((char*)("userdata")) != 0) {
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06002061 LOGERR("Error deleting crypto block device, continuing anyway.\n");
2062 }
2063 }
2064#endif
dianlujitao4879b372018-12-03 18:45:47 +08002065 Has_Data_Media = false;
Ethan Yonker93382822018-11-01 15:25:31 -05002066 Decrypted_Block_Device = "";
Dees_Troy74fb2e92013-04-15 14:35:47 +00002067 Is_Decrypted = false;
2068 Is_Encrypted = false;
Gary Pecke8bc5d72012-12-21 06:45:25 -08002069 if (Wipe(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002070 Has_Data_Media = Save_Data_Media;
bigbiffbe4f46c2021-04-24 11:48:54 -04002071 if (Has_Data_Media && !Symlink_Mount_Point.empty()) {
2072 if (Mount(false))
2073 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
2074 }
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06002075 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
Ethan Yonker83e82572014-04-04 10:59:28 -05002076#ifndef TW_OEM_BUILD
bigbiff25d25b92020-06-19 16:07:38 -04002077 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 -05002078#endif
bigbiff2d548672021-07-09 20:08:44 -04002079 if (Is_FBE) {
2080 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."));
2081 }
2082
Ethan Yonker93382822018-11-01 15:25:31 -05002083 ret = true;
2084 if (!Key_Directory.empty())
2085 ret = PartitionManager.Wipe_By_Path(Key_Directory);
2086 if (ret)
2087 ret = base_partition->PostWipeEncryption();
2088 goto exit;
Dees_Troy38bd7602012-09-14 13:33:53 -04002089 } else {
2090 Has_Data_Media = Save_Data_Media;
Ethan Yonker74db1572015-10-28 12:44:49 -05002091 gui_err("format_data_err=Unable to format to remove encryption.");
Ethan Yonker726a0202014-12-16 20:01:38 -06002092 if (Has_Data_Media && Mount(false))
2093 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
Ethan Yonker93382822018-11-01 15:25:31 -05002094 goto exit;
Dees_Troy38bd7602012-09-14 13:33:53 -04002095 }
Ethan Yonker93382822018-11-01 15:25:31 -05002096exit:
2097 delete base_partition;
2098 return ret;
Dees_Troy51a0e822012-09-05 15:24:24 -04002099}
2100
2101void TWPartition::Check_FS_Type() {
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002102 const char* type;
2103 blkid_probe pr;
Dees_Troy5bf43922012-09-07 16:07:55 -04002104
Dees_Troy68cab492012-12-12 19:29:35 +00002105 if (Fstab_File_System == "yaffs2" || Fstab_File_System == "mtd" || Fstab_File_System == "bml" || Ignore_Blkid)
2106 return; // Running blkid on some mtd devices causes a massive crash or needs to be skipped
Dees_Troy5bf43922012-09-07 16:07:55 -04002107
Dees_Troy38bd7602012-09-14 13:33:53 -04002108 Find_Actual_Block_Device();
Dees_Troy8170a922012-09-18 15:40:25 -04002109 if (!Is_Present)
2110 return;
Dees_Troy51127312012-09-08 13:08:49 -04002111
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002112 pr = blkid_new_probe_from_filename(Actual_Block_Device.c_str());
2113 if (blkid_do_fullprobe(pr)) {
2114 blkid_free_probe(pr);
Dees_Troy2673cec2013-04-02 20:22:16 +00002115 LOGINFO("Can't probe device %s\n", Actual_Block_Device.c_str());
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002116 return;
Dees_Troy5bf43922012-09-07 16:07:55 -04002117 }
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02002118
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05002119 if (blkid_probe_lookup_value(pr, "TYPE", &type, NULL) < 0) {
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002120 blkid_free_probe(pr);
Dees_Troy2673cec2013-04-02 20:22:16 +00002121 LOGINFO("can't find filesystem on device %s\n", Actual_Block_Device.c_str());
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002122 return;
2123 }
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02002124
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002125 Current_File_System = type;
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02002126 blkid_free_probe(pr);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002127 if (fs_flags.size() > 1) {
2128 std::vector<partition_fs_flags_struct>::iterator iter;
2129 std::vector<partition_fs_flags_struct>::iterator found = fs_flags.begin();
2130
2131 for (iter = fs_flags.begin(); iter != fs_flags.end(); iter++) {
2132 if (iter->File_System == Current_File_System) {
2133 found = iter;
2134 break;
2135 }
2136 }
2137 // If we don't find a match, we default the flags to the first set of flags that we received from the fstab
2138 if (Mount_Flags != found->Mount_Flags || Mount_Options != found->Mount_Options) {
2139 Mount_Flags = found->Mount_Flags;
2140 Mount_Options = found->Mount_Options;
2141 LOGINFO("Mount_Flags: %i, Mount_Options: %s\n", Mount_Flags, Mount_Options.c_str());
2142 }
2143 }
Dees_Troy51a0e822012-09-05 15:24:24 -04002144}
2145
dianlujitao4879b372018-12-03 18:45:47 +08002146bool TWPartition::Wipe_EXTFS(string File_System) {
bigbiff7ba75002020-04-11 20:47:09 -04002147 if (!UnMount(true))
2148 return false;
2149
dianlujitao4879b372018-12-03 18:45:47 +08002150#if PLATFORM_SDK_VERSION < 28
bigbiffad58e1b2020-07-06 20:24:34 -04002151 if (!TWFunc::Path_Exists("/system/bin/mke2fs"))
dianlujitao4879b372018-12-03 18:45:47 +08002152#else
bigbiffad58e1b2020-07-06 20:24:34 -04002153 if (!TWFunc::Path_Exists("/system/bin/mke2fs") || !TWFunc::Path_Exists("/system/bin/e2fsdroid"))
dianlujitao4879b372018-12-03 18:45:47 +08002154#endif
Dees_Troy38bd7602012-09-14 13:33:53 -04002155 return Wipe_RMRF();
2156
dianlujitao4879b372018-12-03 18:45:47 +08002157 int ret;
2158 bool NeedPreserveFooter = true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002159
Ethan Yonker25f20c12014-10-14 09:04:43 -05002160 Find_Actual_Block_Device();
2161 if (!Is_Present) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002162 LOGINFO("Block device not present, cannot wipe %s.\n", Display_Name.c_str());
2163 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Ethan Yonker25f20c12014-10-14 09:04:43 -05002164 return false;
2165 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002166
dianlujitao4879b372018-12-03 18:45:47 +08002167 /**
2168 * On decrypted devices, IOCTL_Get_Block_Size calculates size on device mapper,
2169 * so there's no need to preserve footer.
2170 */
2171 if ((Is_Decrypted && !Decrypted_Block_Device.empty()) ||
2172 Crypto_Key_Location != "footer") {
2173 NeedPreserveFooter = false;
2174 }
2175
2176 unsigned long long dev_sz = TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
2177 if (!dev_sz)
2178 return false;
2179
2180 if (NeedPreserveFooter)
2181 Length < 0 ? dev_sz += Length : dev_sz -= CRYPT_FOOTER_OFFSET;
2182
Dees Troy9a4d7402019-03-21 14:17:28 -04002183 char dout[16];
2184 sprintf(dout, "%llu", dev_sz / 4096);
2185
2186 //string size_str =to_string(dev_sz / 4096);
2187 string size_str = dout;
dianlujitao4879b372018-12-03 18:45:47 +08002188 string Command;
2189
2190 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mke2fs"));
2191
2192 // Execute mke2fs to create empty ext4 filesystem
2193 Command = "mke2fs -t " + File_System + " -b 4096 " + Actual_Block_Device + " " + size_str;
2194 LOGINFO("mke2fs command: %s\n", Command.c_str());
2195 ret = TWFunc::Exec_Cmd(Command);
2196 if (ret) {
2197 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2198 return false;
2199 }
2200
bigbiffad58e1b2020-07-06 20:24:34 -04002201 if (TWFunc::Path_Exists("/system/bin/e2fsdroid")) {
dianlujitao3cf05a52019-05-15 15:33:27 +08002202 const string& File_Contexts_Entry = (Mount_Point == "/system_root" ? "/" : Mount_Point);
2203 char *secontext = NULL;
2204 if (!selinux_handle || selabel_lookup(selinux_handle, &secontext, File_Contexts_Entry.c_str(), S_IFDIR) < 0) {
2205 LOGINFO("Cannot lookup security context for '%s'\n", Mount_Point.c_str());
2206 } else {
2207 // Execute e2fsdroid to initialize selinux context
bigbiff5b911ca2020-07-18 10:46:09 -04002208 if (Mount_Point == "/persist") {
2209 Mount(true);
2210 TWFunc::removeDir("/persist/lost+found", false);
2211 UnMount(true);
2212 }
dianlujitao3cf05a52019-05-15 15:33:27 +08002213 Command = "e2fsdroid -e -S /file_contexts -a " + File_Contexts_Entry + " " + Actual_Block_Device;
2214 LOGINFO("e2fsdroid command: %s\n", Command.c_str());
2215 ret = TWFunc::Exec_Cmd(Command);
2216 if (ret) {
2217 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2218 return false;
2219 }
dianlujitao4879b372018-12-03 18:45:47 +08002220 }
2221 } else {
2222 LOGINFO("e2fsdroid not present\n");
2223 }
2224
2225 if (NeedPreserveFooter)
2226 Wipe_Crypto_Key();
2227 Current_File_System = File_System;
2228 Recreate_AndSec_Folder();
2229 gui_msg("done=Done.");
2230 return true;
2231}
2232
2233bool TWPartition::Wipe_EXT4() {
2234#ifdef USE_EXT4
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002235 int ret;
dianlujitao4879b372018-12-03 18:45:47 +08002236 bool NeedPreserveFooter = true;
2237
bigbiff7ba75002020-04-11 20:47:09 -04002238 if (!UnMount(true))
2239 return false;
2240
dianlujitao4879b372018-12-03 18:45:47 +08002241 Find_Actual_Block_Device();
2242 if (!Is_Present) {
2243 LOGINFO("Block device not present, cannot wipe %s.\n", Display_Name.c_str());
2244 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2245 return false;
2246 }
dianlujitao4879b372018-12-03 18:45:47 +08002247
2248 /**
2249 * On decrypted devices, IOCTL_Get_Block_Size calculates size on device mapper,
2250 * so there's no need to preserve footer.
2251 */
2252 if ((Is_Decrypted && !Decrypted_Block_Device.empty()) ||
2253 Crypto_Key_Location != "footer") {
2254 NeedPreserveFooter = false;
2255 }
2256
2257 unsigned long long dev_sz = TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
2258 if (!dev_sz)
2259 return false;
2260
2261 if (NeedPreserveFooter)
2262 Length < 0 ? dev_sz += Length : dev_sz -= CRYPT_FOOTER_OFFSET;
2263
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002264 char *secontext = NULL;
2265
Greg Wallace4b44fef2015-12-29 15:33:24 -05002266 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("make_ext4fs"));
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002267
Dees Troy99c8dbf2014-03-10 16:53:58 +00002268 if (!selinux_handle || selabel_lookup(selinux_handle, &secontext, Mount_Point.c_str(), S_IFDIR) < 0) {
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002269 LOGINFO("Cannot lookup security context for '%s'\n", Mount_Point.c_str());
dianlujitao4879b372018-12-03 18:45:47 +08002270 ret = make_ext4fs(Actual_Block_Device.c_str(), dev_sz, Mount_Point.c_str(), NULL);
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002271 } else {
dianlujitao4879b372018-12-03 18:45:47 +08002272 ret = make_ext4fs(Actual_Block_Device.c_str(), dev_sz, Mount_Point.c_str(), selinux_handle);
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002273 }
2274 if (ret != 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002275 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troya95f55c2013-08-17 13:14:43 +00002276 return false;
2277 } else {
dianlujitao4879b372018-12-03 18:45:47 +08002278 if (NeedPreserveFooter)
2279 Wipe_Crypto_Key();
bigbiff bigbiffc49d7062013-10-11 20:28:00 -04002280 string sedir = Mount_Point + "/lost+found";
2281 PartitionManager.Mount_By_Path(sedir.c_str(), true);
2282 rmdir(sedir.c_str());
2283 mkdir(sedir.c_str(), S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP);
Dees_Troya95f55c2013-08-17 13:14:43 +00002284 return true;
2285 }
2286#else
dianlujitao4879b372018-12-03 18:45:47 +08002287 return Wipe_EXTFS("ext4");
Dees_Troya95f55c2013-08-17 13:14:43 +00002288#endif
Dees_Troy51a0e822012-09-05 15:24:24 -04002289}
2290
2291bool TWPartition::Wipe_FAT() {
Vojtech Bocek05534202013-09-11 08:11:56 +02002292 string command;
Dees_Troy38bd7602012-09-14 13:33:53 -04002293
bigbiff7ba75002020-04-11 20:47:09 -04002294 if (!UnMount(true))
2295 return false;
Dees_Troy38bd7602012-09-14 13:33:53 -04002296
bigbiffad58e1b2020-07-06 20:24:34 -04002297 if (TWFunc::Path_Exists("/system/bin/mkfs.fat")) {
Greg Wallace4b44fef2015-12-29 15:33:24 -05002298 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mkfs.fat"));
Dees_Troy38bd7602012-09-14 13:33:53 -04002299 Find_Actual_Block_Device();
Matt Mower18794c82015-11-11 16:22:45 -06002300 command = "mkfs.fat " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02002301 if (TWFunc::Exec_Cmd(command) == 0) {
Gary Pecke8bc5d72012-12-21 06:45:25 -08002302 Current_File_System = "vfat";
Dees_Troye58d5262012-09-21 12:27:57 -04002303 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002304 gui_msg("done=Done.");
Dees_Troy38bd7602012-09-14 13:33:53 -04002305 return true;
2306 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002307 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04002308 return false;
2309 }
2310 return true;
2311 }
2312 else
2313 return Wipe_RMRF();
2314
2315 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04002316}
2317
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002318bool TWPartition::Wipe_EXFAT() {
Vojtech Bocek05534202013-09-11 08:11:56 +02002319 string command;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002320
bigbiff7ba75002020-04-11 20:47:09 -04002321 if (!UnMount(true))
2322 return false;
bigbiffad58e1b2020-07-06 20:24:34 -04002323 if (TWFunc::Path_Exists("/system/bin/mkexfatfs")) {
Greg Wallace4b44fef2015-12-29 15:33:24 -05002324 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mkexfatfs"));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002325 Find_Actual_Block_Device();
2326 command = "mkexfatfs " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02002327 if (TWFunc::Exec_Cmd(command) == 0) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002328 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002329 gui_msg("done=Done.");
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002330 return true;
2331 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002332 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002333 return false;
2334 }
2335 return true;
2336 }
2337 return false;
2338}
2339
Dees_Troy38bd7602012-09-14 13:33:53 -04002340bool TWPartition::Wipe_MTD() {
2341 if (!UnMount(true))
2342 return false;
2343
Greg Wallace4b44fef2015-12-29 15:33:24 -05002344 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("MTD"));
Dees_Troy38bd7602012-09-14 13:33:53 -04002345
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002346 mtd_scan_partitions();
2347 const MtdPartition* mtd = mtd_find_partition_by_name(MTD_Name.c_str());
2348 if (mtd == NULL) {
2349 LOGERR("No mtd partition named '%s'", MTD_Name.c_str());
2350 return false;
2351 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002352
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002353 MtdWriteContext* ctx = mtd_write_partition(mtd);
2354 if (ctx == NULL) {
2355 LOGERR("Can't write '%s', failed to format.", MTD_Name.c_str());
2356 return false;
2357 }
2358 if (mtd_erase_blocks(ctx, -1) == -1) {
2359 mtd_write_close(ctx);
2360 LOGERR("Failed to format '%s'", MTD_Name.c_str());
2361 return false;
2362 }
2363 if (mtd_write_close(ctx) != 0) {
2364 LOGERR("Failed to close '%s'", MTD_Name.c_str());
2365 return false;
2366 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08002367 Current_File_System = "yaffs2";
Dees_Troye58d5262012-09-21 12:27:57 -04002368 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002369 gui_msg("done=Done.");
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002370 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002371}
2372
2373bool TWPartition::Wipe_RMRF() {
Dees_Troy38bd7602012-09-14 13:33:53 -04002374 if (!Mount(true))
2375 return false;
Ethan Yonker726a0202014-12-16 20:01:38 -06002376 // This is the only wipe that leaves the partition mounted, so we
2377 // must manually remove the partition from MTP if it is a storage
2378 // partition.
2379 if (Is_Storage)
2380 PartitionManager.Remove_MTP_Storage(MTP_Storage_ID);
Dees_Troy38bd7602012-09-14 13:33:53 -04002381
Ethan Yonker74db1572015-10-28 12:44:49 -05002382 gui_msg(Msg("remove_all=Removing all files under '{1}'")(Mount_Point));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002383 TWFunc::removeDir(Mount_Point, true);
Dees_Troye58d5262012-09-21 12:27:57 -04002384 Recreate_AndSec_Folder();
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002385 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002386}
2387
Dees_Troye5017042013-08-29 16:38:55 +00002388bool TWPartition::Wipe_F2FS() {
bigbiff7ba75002020-04-11 20:47:09 -04002389 std::string command;
2390 std::string f2fs_bin;
Dees_Troye5017042013-08-29 16:38:55 +00002391
bigbiff7ba75002020-04-11 20:47:09 -04002392 if (!UnMount(true))
2393 return false;
dianlujitao4879b372018-12-03 18:45:47 +08002394
bigbiffad58e1b2020-07-06 20:24:34 -04002395 if (TWFunc::Path_Exists("/system/bin/mkfs.f2fs"))
2396 f2fs_bin = "/system/bin/mkfs.f2fs";
2397 else if (TWFunc::Path_Exists("/system/bin/make_f2fs"))
2398 f2fs_bin = "/system/bin/make_f2fs";
bigbiff7ba75002020-04-11 20:47:09 -04002399 else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002400 LOGINFO("mkfs.f2fs binary not found, using rm -rf to wipe.\n");
Dees_Troye5017042013-08-29 16:38:55 +00002401 return Wipe_RMRF();
2402 }
bigbiff7ba75002020-04-11 20:47:09 -04002403
2404 bool NeedPreserveFooter = true;
2405
2406 Find_Actual_Block_Device();
2407 if (!Is_Present) {
2408 LOGINFO("Block device not present, cannot wipe %s.\n", Display_Name.c_str());
2409 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2410 return false;
2411 }
2412
2413 unsigned long long dev_sz = TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
2414 if (!dev_sz)
2415 return false;
2416
2417 if (NeedPreserveFooter)
2418 Length < 0 ? dev_sz += Length : dev_sz -= CRYPT_FOOTER_OFFSET;
2419
2420 char dev_sz_str[48];
2421 sprintf(dev_sz_str, "%llu", (dev_sz / 4096));
2422 command = f2fs_bin + " -d1 -f -O encrypt -O quota -O verity -w 4096 " + Actual_Block_Device + " " + dev_sz_str;
bigbiffad58e1b2020-07-06 20:24:34 -04002423 if (TWFunc::Path_Exists("/system/bin/sload.f2fs")) {
bigbiff7ba75002020-04-11 20:47:09 -04002424 command += " && sload.f2fs -t /data " + Actual_Block_Device;
2425 }
2426
2427 /**
2428 * On decrypted devices, IOCTL_Get_Block_Size calculates size on device mapper,
2429 * so there's no need to preserve footer.
2430 */
2431 if ((Is_Decrypted && !Decrypted_Block_Device.empty()) ||
2432 Crypto_Key_Location != "footer") {
2433 NeedPreserveFooter = false;
2434 }
2435 LOGINFO("mkfs.f2fs command: %s\n", f2fs_bin.c_str());
2436 if (TWFunc::Exec_Cmd(command) == 0) {
2437 if (NeedPreserveFooter)
2438 Wipe_Crypto_Key();
2439 Recreate_AndSec_Folder();
2440 gui_msg("done=Done.");
2441 return true;
2442 } else {
2443 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2444 return false;
2445 }
2446 return true;
Dees_Troye5017042013-08-29 16:38:55 +00002447}
2448
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002449bool TWPartition::Wipe_NTFS() {
2450 string command;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002451 string Ntfsmake_Binary;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002452
bigbiff7ba75002020-04-11 20:47:09 -04002453 if (!UnMount(true))
2454 return false;
2455
bigbiffad58e1b2020-07-06 20:24:34 -04002456 if (TWFunc::Path_Exists("/system/bin/mkntfs"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002457 Ntfsmake_Binary = "mkntfs";
bigbiffad58e1b2020-07-06 20:24:34 -04002458 else if (TWFunc::Path_Exists("/system/bin/mkfs.ntfs"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002459 Ntfsmake_Binary = "mkfs.ntfs";
2460 else
2461 return false;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002462
Greg Wallace4b44fef2015-12-29 15:33:24 -05002463 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)(Ntfsmake_Binary));
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002464 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04002465 command = "/system/bin/" + Ntfsmake_Binary + " " + Actual_Block_Device;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002466 if (TWFunc::Exec_Cmd(command) == 0) {
2467 Recreate_AndSec_Folder();
2468 gui_msg("done=Done.");
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002469 return true;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002470 } else {
2471 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2472 return false;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002473 }
2474 return false;
2475}
2476
Dees_Troy51a0e822012-09-05 15:24:24 -04002477bool TWPartition::Wipe_Data_Without_Wiping_Media() {
Ethan Yonker83e82572014-04-04 10:59:28 -05002478#ifdef TW_OEM_BUILD
2479 // In an OEM Build we want to do a full format
2480 return Wipe_Encryption();
2481#else
Ethan Yonker66a19492015-12-10 10:19:45 -06002482 bool ret = false;
Dees_Troy38bd7602012-09-14 13:33:53 -04002483
Dees_Troy38bd7602012-09-14 13:33:53 -04002484 if (!Mount(true))
2485 return false;
2486
Ethan Yonker74db1572015-10-28 12:44:49 -05002487 gui_msg("wiping_data=Wiping data without wiping /data/media ...");
Ethan Yonker66a19492015-12-10 10:19:45 -06002488 ret = Wipe_Data_Without_Wiping_Media_Func(Mount_Point + "/");
2489 if (ret)
2490 gui_msg("done=Done.");
2491 return ret;
2492#endif // ifdef TW_OEM_BUILD
2493}
2494
2495bool TWPartition::Wipe_Data_Without_Wiping_Media_Func(const string& parent __unused) {
2496 string dir;
Dees_Troy38bd7602012-09-14 13:33:53 -04002497
2498 DIR* d;
Ethan Yonker66a19492015-12-10 10:19:45 -06002499 d = opendir(parent.c_str());
Dees_Troy16b74352012-11-14 22:27:31 +00002500 if (d != NULL) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002501 struct dirent* de;
2502 while ((de = readdir(d)) != NULL) {
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05002503 if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) continue;
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05002504
Ethan Yonker66a19492015-12-10 10:19:45 -06002505 dir = parent;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002506 dir.append(de->d_name);
Ethan Yonker3fdcda42016-11-30 12:29:37 -06002507 if (wipe_exclusions.check_skip_dirs(dir)) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002508 LOGINFO("skipped '%s'\n", dir.c_str());
2509 continue;
2510 }
Dees_Troyce675462013-01-09 19:48:21 +00002511 if (de->d_type == DT_DIR) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002512 dir.append("/");
2513 if (!Wipe_Data_Without_Wiping_Media_Func(dir)) {
2514 closedir(d);
2515 return false;
2516 }
2517 rmdir(dir.c_str());
bigbiff bigbiff98f1f902013-01-19 18:46:13 -05002518 } 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 +03002519 if (unlink(dir.c_str()) != 0)
Ethan Yonker79f88bd2016-12-09 14:52:12 -06002520 LOGINFO("Unable to unlink '%s': %s\n", dir.c_str(), strerror(errno));
Dees_Troyce675462013-01-09 19:48:21 +00002521 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002522 }
2523 closedir(d);
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05002524
Dees_Troy16b74352012-11-14 22:27:31 +00002525 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -04002526 }
Ethan Yonker74db1572015-10-28 12:44:49 -05002527 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy16b74352012-11-14 22:27:31 +00002528 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04002529}
2530
dianlujitao4879b372018-12-03 18:45:47 +08002531void TWPartition::Wipe_Crypto_Key() {
2532 Find_Actual_Block_Device();
2533 if (Crypto_Key_Location.empty())
2534 return;
2535 else if (Crypto_Key_Location == "footer") {
2536 int fd = open(Actual_Block_Device.c_str(), O_RDWR);
2537 if (fd < 0) {
2538 gui_print_color("warning", "Unable to open '%s' to wipe crypto key\n", Actual_Block_Device.c_str());
2539 return;
2540 }
2541
2542 unsigned int block_count;
2543 if ((ioctl(fd, BLKGETSIZE, &block_count)) == -1) {
2544 gui_print_color("warning", "Unable to get block size for wiping crypto footer.\n");
2545 } else {
2546 int newlen = Length < 0 ? -Length : CRYPT_FOOTER_OFFSET;
2547 off64_t offset = ((off64_t)block_count * 512) - newlen;
2548 if (lseek64(fd, offset, SEEK_SET) == -1) {
2549 gui_print_color("warning", "Unable to lseek64 for wiping crypto footer.\n");
2550 } else {
2551 void* buffer = malloc(newlen);
2552 if (!buffer) {
2553 gui_print_color("warning", "Failed to malloc for wiping crypto footer.\n");
2554 } else {
2555 memset(buffer, 0, newlen);
2556 int ret = write(fd, buffer, newlen);
2557 if (ret != newlen) {
2558 gui_print_color("warning", "Failed to wipe crypto footer.\n");
2559 } else {
2560 LOGINFO("Successfully wiped crypto footer.\n");
2561 }
2562 free(buffer);
2563 }
2564 }
2565 }
2566 close(fd);
2567 } else {
2568 if (TWFunc::IOCTL_Get_Block_Size(Crypto_Key_Location.c_str()) >= 16384LLU) {
2569 string Command = "dd of='" + Crypto_Key_Location + "' if=/dev/zero bs=16384 count=1";
2570 TWFunc::Exec_Cmd(Command);
2571 } else {
2572 LOGINFO("Crypto key location reports size < 16K so not wiping crypto footer.\n");
2573 }
2574 }
2575}
2576
bigbiffce8f83c2015-12-12 18:30:21 -05002577bool TWPartition::Backup_Tar(PartitionSettings *part_settings, pid_t *tar_fork_pid) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002578 string Full_FileName;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002579 twrpTar tar;
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -05002580
Dees_Troy43d8b002012-09-17 16:00:01 -04002581 if (!Mount(true))
2582 return false;
2583
Ian Macdonalda3b25a32019-06-16 22:39:14 +02002584 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Backup_Display_Name, gui_parse_text("{@backing}"));
Ethan Yonker74db1572015-10-28 12:44:49 -05002585 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002586
Ethan Yonker472f5062016-02-25 13:47:30 -06002587 DataManager::GetValue(TW_USE_COMPRESSION_VAR, tar.use_compression);
Matt Mowerbb81e5d2014-03-20 18:05:41 -05002588
Dees_Troy83bd4832013-05-04 12:39:56 +00002589#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
Ethan Yonker472f5062016-02-25 13:47:30 -06002590 if (Can_Encrypt_Backup) {
2591 DataManager::GetValue("tw_encrypt_backup", tar.use_encryption);
2592 if (tar.use_encryption) {
2593 if (Use_Userdata_Encryption)
2594 tar.userdata_encryption = tar.use_encryption;
2595 string Password;
2596 DataManager::GetValue("tw_backup_password", Password);
2597 tar.setpassword(Password);
2598 } else {
2599 tar.use_encryption = 0;
2600 }
Dees_Troy83bd4832013-05-04 12:39:56 +00002601 }
2602#endif
Dees_Troy43d8b002012-09-17 16:00:01 -04002603
Ethan Yonker472f5062016-02-25 13:47:30 -06002604 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002605 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Ethan Yonker01f4e032017-02-03 15:30:52 -06002606 if (Has_Data_Media)
2607 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 -04002608 if (Mount_Point == "/data" && DataManager::GetIntValue(TW_IS_FBE)) {
2609 std::vector<users_struct>::iterator iter;
2610 std::vector<users_struct>* userList = PartitionManager.Get_Users_List();
2611 for (iter = userList->begin(); iter != userList->end(); iter++) {
2612 if (!(*iter).isDecrypted && (*iter).userId != "0") {
2613 gui_msg(Msg(msg::kWarning,
2614 "backup_storage_undecrypt_warning=Backup will not include some files from user {1} "
2615 "because the user is not decrypted.")((*iter).userId));
2616 backup_exclusions.add_absolute_dir("/data/system_ce/" + (*iter).userId);
2617 backup_exclusions.add_absolute_dir("/data/misc_ce/" + (*iter).userId);
2618 backup_exclusions.add_absolute_dir("/data/vendor_ce/" + (*iter).userId);
2619 backup_exclusions.add_absolute_dir("/data/media/" + (*iter).userId);
2620 backup_exclusions.add_absolute_dir("/data/user/" + (*iter).userId);
2621 }
2622 }
2623 }
bigbiffce8f83c2015-12-12 18:30:21 -05002624 tar.part_settings = part_settings;
Ethan Yonker3fdcda42016-11-30 12:29:37 -06002625 tar.backup_exclusions = &backup_exclusions;
Dees Troye0a433a2013-12-02 04:10:37 +00002626 tar.setdir(Backup_Path);
2627 tar.setfn(Full_FileName);
2628 tar.setsize(Backup_Size);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002629 tar.partition_name = Backup_Name;
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002630 tar.backup_folder = part_settings->Backup_Folder;
bigbiffce8f83c2015-12-12 18:30:21 -05002631 if (tar.createTarFork(tar_fork_pid) != 0)
Dees Troye0a433a2013-12-02 04:10:37 +00002632 return false;
Dees_Troy43d8b002012-09-17 16:00:01 -04002633 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002634}
2635
bigbiffce8f83c2015-12-12 18:30:21 -05002636bool TWPartition::Backup_Image(PartitionSettings *part_settings) {
2637 string Full_FileName, adb_file_name;
igoriok87e3d932013-01-31 21:03:53 +02002638
Ethan Yonker74db1572015-10-28 12:44:49 -05002639 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, gui_parse_text("{@backing}"));
2640 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002641
Ethan Yonker472f5062016-02-25 13:47:30 -06002642 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
Dees_Troy43d8b002012-09-17 16:00:01 -04002643
bigbiffce8f83c2015-12-12 18:30:21 -05002644 if (part_settings->adbbackup) {
2645 Full_FileName = TW_ADB_BACKUP;
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002646 adb_file_name = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002647 }
2648 else
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002649 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002650
2651 part_settings->total_restore_size = Backup_Size;
2652
2653 if (part_settings->adbbackup) {
2654 if (!twadbbu::Write_TWIMG(adb_file_name, Backup_Size))
2655 return false;
2656 }
2657
2658 if (!Raw_Read_Write(part_settings))
Ethan Yonker472f5062016-02-25 13:47:30 -06002659 return false;
2660
bigbiffce8f83c2015-12-12 18:30:21 -05002661 if (part_settings->adbbackup) {
2662 if (!twadbbu::Write_TWEOF())
2663 return false;
Dees_Troy7c2dec82012-09-26 09:49:14 -04002664 }
Dees_Troy43d8b002012-09-17 16:00:01 -04002665 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002666}
2667
bigbiffce8f83c2015-12-12 18:30:21 -05002668bool TWPartition::Raw_Read_Write(PartitionSettings *part_settings) {
2669 unsigned long long RW_Block_Size, Remain = Backup_Size;
2670 int src_fd = -1, dest_fd = -1;
2671 ssize_t bs;
Ethan Yonker472f5062016-02-25 13:47:30 -06002672 bool ret = false;
2673 void* buffer = NULL;
2674 unsigned long long backedup_size = 0;
bigbiffce8f83c2015-12-12 18:30:21 -05002675 string srcfn, destfn;
Ethan Yonker472f5062016-02-25 13:47:30 -06002676
bigbiffce8f83c2015-12-12 18:30:21 -05002677 if (part_settings->PM_Method == PM_BACKUP) {
2678 srcfn = Actual_Block_Device;
2679 if (part_settings->adbbackup)
2680 destfn = TW_ADB_BACKUP;
bigbiff bigbiff38b83c12017-12-28 19:58:52 -05002681 else {
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002682 destfn = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiff bigbiff38b83c12017-12-28 19:58:52 -05002683 }
bigbiffce8f83c2015-12-12 18:30:21 -05002684 }
2685 else {
2686 destfn = Actual_Block_Device;
2687 if (part_settings->adbbackup) {
2688 srcfn = TW_ADB_RESTORE;
2689 } else {
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002690 srcfn = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002691 Remain = TWFunc::Get_File_Size(srcfn);
2692 }
2693 }
Ethan Yonker472f5062016-02-25 13:47:30 -06002694
bigbiffce8f83c2015-12-12 18:30:21 -05002695 src_fd = open(srcfn.c_str(), O_RDONLY | O_LARGEFILE);
Ethan Yonker472f5062016-02-25 13:47:30 -06002696 if (src_fd < 0) {
bigbiffce8f83c2015-12-12 18:30:21 -05002697 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(srcfn.c_str())(strerror(errno)));
Ethan Yonker472f5062016-02-25 13:47:30 -06002698 return false;
2699 }
bigbiffce8f83c2015-12-12 18:30:21 -05002700
2701 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 -06002702 if (dest_fd < 0) {
bigbiffce8f83c2015-12-12 18:30:21 -05002703 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(destfn.c_str())(strerror(errno)));
Ethan Yonker472f5062016-02-25 13:47:30 -06002704 goto exit;
2705 }
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04002706
bigbiffce8f83c2015-12-12 18:30:21 -05002707 LOGINFO("Reading '%s', writing '%s'\n", srcfn.c_str(), destfn.c_str());
2708
2709 if (part_settings->adbbackup) {
2710 RW_Block_Size = MAX_ADB_READ;
2711 bs = MAX_ADB_READ;
2712 }
2713 else {
2714 RW_Block_Size = 1048576LLU; // 1MB
2715 bs = (ssize_t)(RW_Block_Size);
2716 }
2717
Ethan Yonker472f5062016-02-25 13:47:30 -06002718 buffer = malloc((size_t)bs);
2719 if (!buffer) {
2720 LOGINFO("Raw_Read_Write failed to malloc\n");
2721 goto exit;
2722 }
bigbiffce8f83c2015-12-12 18:30:21 -05002723
2724 if (part_settings->progress)
2725 part_settings->progress->SetPartitionSize(part_settings->total_restore_size);
2726
Ethan Yonker472f5062016-02-25 13:47:30 -06002727 while (Remain > 0) {
2728 if (Remain < RW_Block_Size)
bigbiffce8f83c2015-12-12 18:30:21 -05002729 bs = (ssize_t)(Remain);
Matt Mowera8a89d12016-12-30 18:10:37 -06002730 if (read(src_fd, buffer, bs) != bs) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002731 LOGINFO("Error reading source fd (%s)\n", strerror(errno));
2732 goto exit;
2733 }
2734 if (write(dest_fd, buffer, bs) != bs) {
2735 LOGINFO("Error writing destination fd (%s)\n", strerror(errno));
2736 goto exit;
2737 }
2738 backedup_size += (unsigned long long)(bs);
Matt Mower029a82d2017-01-08 13:12:38 -06002739 Remain -= (unsigned long long)(bs);
bigbiffce8f83c2015-12-12 18:30:21 -05002740 if (part_settings->progress)
2741 part_settings->progress->UpdateSize(backedup_size);
Ethan Yonker472f5062016-02-25 13:47:30 -06002742 if (PartitionManager.Check_Backup_Cancel() != 0)
2743 goto exit;
2744 }
bigbiffce8f83c2015-12-12 18:30:21 -05002745 if (part_settings->progress)
2746 part_settings->progress->UpdateDisplayDetails(true);
Ethan Yonker472f5062016-02-25 13:47:30 -06002747 fsync(dest_fd);
nailyka083dc62016-11-11 21:41:28 +01002748
2749 if (!part_settings->adbbackup && part_settings->PM_Method == PM_BACKUP) {
2750 tw_set_default_metadata(destfn.c_str());
2751 LOGINFO("Restored default metadata for %s\n", destfn.c_str());
2752 }
2753
Ethan Yonker472f5062016-02-25 13:47:30 -06002754 ret = true;
2755exit:
2756 if (src_fd >= 0)
2757 close(src_fd);
2758 if (dest_fd >= 0)
2759 close(dest_fd);
2760 if (buffer)
2761 free(buffer);
2762 return ret;
2763}
2764
bigbiffce8f83c2015-12-12 18:30:21 -05002765bool TWPartition::Backup_Dump_Image(PartitionSettings *part_settings) {
Vojtech Bocek05534202013-09-11 08:11:56 +02002766 string Full_FileName, Command;
Dees_Troy43d8b002012-09-17 16:00:01 -04002767
Ethan Yonker74db1572015-10-28 12:44:49 -05002768 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, gui_parse_text("{@backing}"));
2769 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002770
bigbiffce8f83c2015-12-12 18:30:21 -05002771 if (part_settings->progress)
2772 part_settings->progress->SetPartitionSize(Backup_Size);
Dees_Troy43d8b002012-09-17 16:00:01 -04002773
Ethan Yonker472f5062016-02-25 13:47:30 -06002774 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002775 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Dees_Troy43d8b002012-09-17 16:00:01 -04002776
2777 Command = "dump_image " + MTD_Name + " '" + Full_FileName + "'";
bigbiffce8f83c2015-12-12 18:30:21 -05002778
Dees_Troy2673cec2013-04-02 20:22:16 +00002779 LOGINFO("Backup command: '%s'\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02002780 TWFunc::Exec_Cmd(Command);
Ethan Yonker4b94cfd2014-12-11 10:00:45 -06002781 tw_set_default_metadata(Full_FileName.c_str());
Dees_Troy7c2dec82012-09-26 09:49:14 -04002782 if (TWFunc::Get_File_Size(Full_FileName) == 0) {
2783 // 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 -06002784 gui_msg(Msg(msg::kError, "backup_size=Backup file size for '{1}' is 0 bytes.")(Full_FileName));
Dees_Troy7c2dec82012-09-26 09:49:14 -04002785 return false;
2786 }
bigbiffce8f83c2015-12-12 18:30:21 -05002787 if (part_settings->progress)
2788 part_settings->progress->UpdateSize(Backup_Size);
2789
Dees_Troy43d8b002012-09-17 16:00:01 -04002790 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002791}
2792
bigbiffce8f83c2015-12-12 18:30:21 -05002793unsigned long long TWPartition::Get_Restore_Size(PartitionSettings *part_settings) {
2794 if (!part_settings->adbbackup) {
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002795 InfoManager restore_info(part_settings->Backup_Folder + "/" + Backup_Name + ".info");
bigbiffce8f83c2015-12-12 18:30:21 -05002796 if (restore_info.LoadValues() == 0) {
2797 if (restore_info.GetValue("backup_size", Restore_Size) == 0) {
2798 LOGINFO("Read info file, restore size is %llu\n", Restore_Size);
2799 return Restore_Size;
2800 }
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002801 }
2802 }
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002803
Matt Mower029a82d2017-01-08 13:12:38 -06002804 string Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
2805 string Restore_File_System = Get_Restore_File_System(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002806
2807 if (Is_Image(Restore_File_System)) {
2808 Restore_Size = TWFunc::Get_File_Size(Full_FileName);
2809 return Restore_Size;
2810 }
2811
2812 twrpTar tar;
2813 tar.setdir(Backup_Path);
2814 tar.setfn(Full_FileName);
bigbiffce8f83c2015-12-12 18:30:21 -05002815 tar.backup_name = Full_FileName;
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002816#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
2817 string Password;
2818 DataManager::GetValue("tw_restore_password", Password);
2819 if (!Password.empty())
2820 tar.setpassword(Password);
2821#endif
2822 tar.partition_name = Backup_Name;
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002823 tar.backup_folder = part_settings->Backup_Folder;
bigbiffce8f83c2015-12-12 18:30:21 -05002824 tar.part_settings = part_settings;
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002825 Restore_Size = tar.get_size();
2826 return Restore_Size;
2827}
2828
bigbiffce8f83c2015-12-12 18:30:21 -05002829bool TWPartition::Restore_Tar(PartitionSettings *part_settings) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002830 string Full_FileName;
Dees Troy4159aed2014-02-28 17:24:43 +00002831 bool ret = false;
bigbiffce8f83c2015-12-12 18:30:21 -05002832 string Restore_File_System = Get_Restore_File_System(part_settings);
Dees_Troy43d8b002012-09-17 16:00:01 -04002833
Dees_Troye58d5262012-09-21 12:27:57 -04002834 if (Has_Android_Secure) {
Dees_Troye58d5262012-09-21 12:27:57 -04002835 if (!Wipe_AndSec())
2836 return false;
Gary Peck43acadf2012-11-21 21:19:01 -08002837 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002838 gui_msg(Msg("wiping=Wiping {1}")(Backup_Display_Name));
Ethan Yonker5eac2222014-06-11 12:22:55 -05002839 if (Has_Data_Media && Mount_Point == "/data" && Restore_File_System != Current_File_System) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002840 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 -05002841 if (!Wipe_Data_Without_Wiping_Media())
2842 return false;
2843 } else {
2844 if (!Wipe(Restore_File_System))
2845 return false;
2846 }
Dees_Troye58d5262012-09-21 12:27:57 -04002847 }
Matt Mower3c366972015-12-25 19:28:31 -06002848 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Backup_Display_Name, gui_parse_text("{@restoring_hdr}"));
Ethan Yonker74db1572015-10-28 12:44:49 -05002849 gui_msg(Msg("restoring=Restoring {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002850
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05002851 // Remount as read/write as needed so we can restore the backup
2852 if (!ReMount_RW(true))
Dees_Troy43d8b002012-09-17 16:00:01 -04002853 return false;
2854
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002855 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Ethan Yonker87af5632014-02-10 11:56:35 -06002856 twrpTar tar;
bigbiffce8f83c2015-12-12 18:30:21 -05002857 tar.part_settings = part_settings;
Ethan Yonker87af5632014-02-10 11:56:35 -06002858 tar.setdir(Backup_Path);
2859 tar.setfn(Full_FileName);
2860 tar.backup_name = Backup_Name;
2861#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
2862 string Password;
2863 DataManager::GetValue("tw_restore_password", Password);
2864 if (!Password.empty())
2865 tar.setpassword(Password);
2866#endif
bigbiffce8f83c2015-12-12 18:30:21 -05002867 part_settings->progress->SetPartitionSize(Get_Restore_Size(part_settings));
2868 if (tar.extractTarFork() != 0)
Dees Troy4159aed2014-02-28 17:24:43 +00002869 ret = false;
2870 else
2871 ret = true;
2872#ifdef HAVE_CAPABILITIES
2873 // Restore capabilities to the run-as binary
Captain Throwback9d6feb52018-07-27 10:05:24 -04002874 if (Mount_Point == PartitionManager.Get_Android_Root_Path() && Mount(true) && TWFunc::Path_Exists("/system/bin/run-as")) {
Dees Troy4159aed2014-02-28 17:24:43 +00002875 struct vfs_cap_data cap_data;
2876 uint64_t capabilities = (1 << CAP_SETUID) | (1 << CAP_SETGID);
2877
2878 memset(&cap_data, 0, sizeof(cap_data));
2879 cap_data.magic_etc = VFS_CAP_REVISION | VFS_CAP_FLAGS_EFFECTIVE;
2880 cap_data.data[0].permitted = (uint32_t) (capabilities & 0xffffffff);
2881 cap_data.data[0].inheritable = 0;
2882 cap_data.data[1].permitted = (uint32_t) (capabilities >> 32);
2883 cap_data.data[1].inheritable = 0;
2884 if (setxattr("/system/bin/run-as", XATTR_NAME_CAPS, &cap_data, sizeof(cap_data), 0) < 0) {
2885 LOGINFO("Failed to reset capabilities of /system/bin/run-as binary.\n");
2886 } else {
2887 LOGINFO("Reset capabilities of /system/bin/run-as binary successful.\n");
2888 }
2889 }
2890#endif
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05002891 if (Mount_Read_Only || Mount_Flags & MS_RDONLY)
2892 // Remount as read only when restoration is complete
2893 ReMount(true);
2894
Dees Troy4159aed2014-02-28 17:24:43 +00002895 return ret;
Dees_Troy51a0e822012-09-05 15:24:24 -04002896}
2897
bigbiffce8f83c2015-12-12 18:30:21 -05002898bool TWPartition::Restore_Image(PartitionSettings *part_settings) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06002899 string Full_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002900 string Restore_File_System = Get_Restore_File_System(part_settings);
Dees_Troy43d8b002012-09-17 16:00:01 -04002901
Matt Mower3c366972015-12-25 19:28:31 -06002902 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Backup_Display_Name, gui_parse_text("{@restoring_hdr}"));
Ethan Yonker74db1572015-10-28 12:44:49 -05002903 gui_msg(Msg("restoring=Restoring {1}...")(Backup_Display_Name));
bigbiffce8f83c2015-12-12 18:30:21 -05002904
2905 if (part_settings->adbbackup)
2906 Full_FileName = TW_ADB_RESTORE;
2907 else
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002908 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Gary Peck15e623d2012-11-21 21:07:58 -08002909
Ethan Yonker96af84a2015-01-05 14:58:36 -06002910 if (Restore_File_System == "emmc") {
bigbiffce8f83c2015-12-12 18:30:21 -05002911 if (!part_settings->adbbackup)
2912 part_settings->total_restore_size = (uint64_t)(TWFunc::Get_File_Size(Full_FileName));
2913 if (!Raw_Read_Write(part_settings))
Ethan Yonker96af84a2015-01-05 14:58:36 -06002914 return false;
2915 } else if (Restore_File_System == "mtd" || Restore_File_System == "bml") {
bigbiffce8f83c2015-12-12 18:30:21 -05002916 if (!Flash_Image_FI(Full_FileName, part_settings->progress))
2917 return false;
2918 }
2919
2920 if (part_settings->adbbackup) {
2921 if (!twadbbu::Write_TWEOF())
Ethan Yonker96af84a2015-01-05 14:58:36 -06002922 return false;
Gary Peck15e623d2012-11-21 21:07:58 -08002923 }
Dees_Troy43d8b002012-09-17 16:00:01 -04002924 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002925}
Dees_Troy5bf43922012-09-07 16:07:55 -04002926
2927bool TWPartition::Update_Size(bool Display_Error) {
Dees_Troy0550cfb2012-10-13 11:56:13 -04002928 bool ret = false, Was_Already_Mounted = false;
Dees_Troy51127312012-09-08 13:08:49 -04002929
Ethan Yonker1b190162016-12-05 15:25:19 -06002930 Find_Actual_Block_Device();
2931
bigbiffee7b7ff2020-03-23 15:08:27 -04002932 if (Actual_Block_Device.empty())
2933 return false;
2934
Ethan Yonker1b190162016-12-05 15:25:19 -06002935 if (!Can_Be_Mounted && !Is_Encrypted) {
2936 if (TWFunc::Path_Exists(Actual_Block_Device) && Find_Partition_Size()) {
2937 Used = Size;
2938 Backup_Size = Size;
2939 return true;
2940 }
Dees_Troy5bf43922012-09-07 16:07:55 -04002941 return false;
Ethan Yonker1b190162016-12-05 15:25:19 -06002942 }
Dees_Troy5bf43922012-09-07 16:07:55 -04002943
Dees_Troy0550cfb2012-10-13 11:56:13 -04002944 Was_Already_Mounted = Is_Mounted();
bigbiffee7b7ff2020-03-23 15:08:27 -04002945
Dees_Troy38bd7602012-09-14 13:33:53 -04002946 if (Removable || Is_Encrypted) {
2947 if (!Mount(false))
2948 return true;
2949 } else if (!Mount(Display_Error))
Dees_Troy5bf43922012-09-07 16:07:55 -04002950 return false;
Dees_Troy51127312012-09-08 13:08:49 -04002951
2952 ret = Get_Size_Via_statfs(Display_Error);
Dees_Troy0550cfb2012-10-13 11:56:13 -04002953 if (!ret || Size == 0) {
2954 if (!Get_Size_Via_df(Display_Error)) {
2955 if (!Was_Already_Mounted)
2956 UnMount(false);
Dees_Troy51127312012-09-08 13:08:49 -04002957 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04002958 }
2959 }
Dees_Troy51127312012-09-08 13:08:49 -04002960
Dees_Troy5bf43922012-09-07 16:07:55 -04002961 if (Has_Data_Media) {
2962 if (Mount(Display_Error)) {
Ethan Yonker3fdcda42016-11-30 12:29:37 -06002963 Used = backup_exclusions.Get_Folder_Size(Mount_Point);
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05002964 Backup_Size = Used;
2965 int bak = (int)(Used / 1048576LLU);
Dees_Troy51127312012-09-08 13:08:49 -04002966 int fre = (int)(Free / 1048576LLU);
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05002967 LOGINFO("Data backup size is %iMB, free: %iMB.\n", bak, fre);
Dees_Troy0550cfb2012-10-13 11:56:13 -04002968 } else {
2969 if (!Was_Already_Mounted)
2970 UnMount(false);
Dees_Troy5bf43922012-09-07 16:07:55 -04002971 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04002972 }
Dees_Troye58d5262012-09-21 12:27:57 -04002973 } else if (Has_Android_Secure) {
2974 if (Mount(Display_Error))
Ethan Yonker3fdcda42016-11-30 12:29:37 -06002975 Backup_Size = backup_exclusions.Get_Folder_Size(Backup_Path);
Dees_Troy0550cfb2012-10-13 11:56:13 -04002976 else {
2977 if (!Was_Already_Mounted)
2978 UnMount(false);
Dees_Troye58d5262012-09-21 12:27:57 -04002979 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04002980 }
Dees_Troy5bf43922012-09-07 16:07:55 -04002981 }
Dees_Troy0550cfb2012-10-13 11:56:13 -04002982 if (!Was_Already_Mounted)
2983 UnMount(false);
Dees_Troy5bf43922012-09-07 16:07:55 -04002984 return true;
Dees_Troy51127312012-09-08 13:08:49 -04002985}
Dees_Troy38bd7602012-09-14 13:33:53 -04002986
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002987bool TWPartition::Find_Wildcard_Block_Devices(const string& Device) {
2988 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
2989 string Path = TWFunc::Get_Path(Device);
2990 string Dev = TWFunc::Get_Filename(Device);
2991 size_t wildcard_index = Dev.find("*");
2992 if (wildcard_index != string::npos)
2993 Dev = Dev.substr(0, wildcard_index);
2994 wildcard_index = Dev.size();
2995 DIR* d = opendir(Path.c_str());
2996 if (d == NULL) {
2997 LOGINFO("Error opening '%s': %s\n", Path.c_str(), strerror(errno));
2998 return false;
2999 }
3000 struct dirent* de;
3001 while ((de = readdir(d)) != NULL) {
3002 if (de->d_type != DT_BLK || strlen(de->d_name) <= wildcard_index || strncmp(de->d_name, Dev.c_str(), wildcard_index) != 0)
3003 continue;
3004
3005 string item = Path + "/";
3006 item.append(de->d_name);
3007 if (PartitionManager.Find_Partition_By_Block_Device(item))
3008 continue;
3009 TWPartition *part = new TWPartition;
3010 char buffer[MAX_FSTAB_LINE_LENGTH];
3011 sprintf(buffer, "%s %s-%i auto defaults defaults", item.c_str(), Mount_Point.c_str(), ++mount_point_index);
bigbiff8da46fa2020-09-08 16:42:34 -04003012 part->Process_Fstab_Line(buffer, false, NULL);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06003013 char display[MAX_FSTAB_LINE_LENGTH];
3014 sprintf(display, "%s %i", Storage_Name.c_str(), mount_point_index);
3015 part->Storage_Name = display;
3016 part->Display_Name = display;
3017 part->Primary_Block_Device = item;
3018 part->Wildcard_Block_Device = false;
3019 part->Is_SubPartition = true;
3020 part->SubPartition_Of = Mount_Point;
3021 part->Is_Storage = Is_Storage;
3022 part->Can_Be_Mounted = true;
3023 part->Removable = true;
3024 part->Can_Be_Wiped = Can_Be_Wiped;
3025 part->Wipe_Available_in_GUI = Wipe_Available_in_GUI;
3026 part->Find_Actual_Block_Device();
3027 part->Update_Size(false);
3028 Has_SubPartition = true;
3029 PartitionManager.Output_Partition(part);
3030 PartitionManager.Add_Partition(part);
3031 }
3032 closedir(d);
3033 return (mount_point_index > 0);
3034}
3035
Dees_Troy38bd7602012-09-14 13:33:53 -04003036void TWPartition::Find_Actual_Block_Device(void) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06003037 if (!Sysfs_Entry.empty() && Primary_Block_Device.empty() && Decrypted_Block_Device.empty()) {
3038 /* Sysfs_Entry.empty() indicates if this is a sysfs entry that begins with /device/
3039 * If we have a syfs entry then we are looking for this device from a uevent add.
3040 * The uevent add will set the primary block device based on the data we receive from
3041 * after checking for adopted storage. If the device ends up being adopted, then the
3042 * decrypted block device will be set instead of the primary block device. */
3043 Is_Present = false;
3044 return;
3045 }
3046 if (Wildcard_Block_Device && !Is_Adopted_Storage) {
3047 Is_Present = false;
3048 Actual_Block_Device = "";
3049 Can_Be_Mounted = false;
3050 if (!Find_Wildcard_Block_Devices(Primary_Block_Device)) {
3051 string Dev = Primary_Block_Device.substr(0, Primary_Block_Device.find("*"));
3052 if (TWFunc::Path_Exists(Dev)) {
3053 Is_Present = true;
3054 Can_Be_Mounted = true;
3055 Actual_Block_Device = Dev;
3056 }
3057 }
3058 return;
3059 } else if (Is_Decrypted && !Decrypted_Block_Device.empty()) {
Dees_Troy38bd7602012-09-14 13:33:53 -04003060 Actual_Block_Device = Decrypted_Block_Device;
Ethan Yonker1b190162016-12-05 15:25:19 -06003061 if (TWFunc::Path_Exists(Decrypted_Block_Device)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04003062 Is_Present = true;
Ethan Yonker1b190162016-12-05 15:25:19 -06003063 return;
3064 }
3065 } else if (SlotSelect && TWFunc::Path_Exists(Primary_Block_Device + PartitionManager.Get_Active_Slot_Suffix())) {
3066 Actual_Block_Device = Primary_Block_Device + PartitionManager.Get_Active_Slot_Suffix();
3067 unlink(Primary_Block_Device.c_str());
3068 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
3069 Is_Present = true;
3070 return;
Dees_Troy43d8b002012-09-17 16:00:01 -04003071 } else if (TWFunc::Path_Exists(Primary_Block_Device)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04003072 Is_Present = true;
3073 Actual_Block_Device = Primary_Block_Device;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003074 return;
3075 }
Ethan Yonker1b190162016-12-05 15:25:19 -06003076 if (!Alternate_Block_Device.empty() && TWFunc::Path_Exists(Alternate_Block_Device)) {
Dees_Troy3f04d032012-10-07 18:20:09 -04003077 Actual_Block_Device = Alternate_Block_Device;
Dees_Troy38bd7602012-09-14 13:33:53 -04003078 Is_Present = true;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003079 } else {
Dees_Troy38bd7602012-09-14 13:33:53 -04003080 Is_Present = false;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003081 }
Dees_Troy38bd7602012-09-14 13:33:53 -04003082}
3083
3084void TWPartition::Recreate_Media_Folder(void) {
3085 string Command;
Ethan Yonker66a19492015-12-10 10:19:45 -06003086 string Media_Path = Mount_Point + "/media";
Dees_Troy38bd7602012-09-14 13:33:53 -04003087
Ethan Yonkerbd7492d2016-12-07 13:55:01 -06003088 if (Is_FBE) {
3089 LOGINFO("Not recreating media folder on FBE\n");
3090 return;
3091 }
Dees_Troy38bd7602012-09-14 13:33:53 -04003092 if (!Mount(true)) {
Ethan Yonker66a19492015-12-10 10:19:45 -06003093 gui_msg(Msg(msg::kError, "recreate_folder_err=Unable to recreate {1} folder.")(Media_Path));
3094 } else if (!TWFunc::Path_Exists(Media_Path)) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003095 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Ethan Yonker66a19492015-12-10 10:19:45 -06003096 LOGINFO("Recreating %s folder.\n", Media_Path.c_str());
3097 mkdir(Media_Path.c_str(), 0770);
xiaolu9416f4f2015-06-04 08:22:23 +08003098 string Internal_path = DataManager::GetStrValue("tw_internal_path");
3099 if (!Internal_path.empty()) {
3100 LOGINFO("Recreating %s folder.\n", Internal_path.c_str());
3101 mkdir(Internal_path.c_str(), 0770);
3102 }
3103#ifdef TW_INTERNAL_STORAGE_PATH
3104 mkdir(EXPAND(TW_INTERNAL_STORAGE_PATH), 0770);
3105#endif
Matt Mower87413642017-01-17 21:14:46 -06003106
thata3d31fb2014-12-21 22:27:40 +01003107 // Afterwards, we will try to set the
3108 // default metadata that we were hopefully able to get during
3109 // early boot.
Ethan Yonker66a19492015-12-10 10:19:45 -06003110 tw_set_default_metadata(Media_Path.c_str());
xiaolu9416f4f2015-06-04 08:22:23 +08003111 if (!Internal_path.empty())
3112 tw_set_default_metadata(Internal_path.c_str());
Matt Mower87413642017-01-17 21:14:46 -06003113
Ethan Yonker5eac2222014-06-11 12:22:55 -05003114 // Toggle mount to ensure that "internal sdcard" gets mounted
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003115 PartitionManager.UnMount_By_Path(Symlink_Mount_Point, true);
Ethan Yonker5eac2222014-06-11 12:22:55 -05003116 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Dees_Troy38bd7602012-09-14 13:33:53 -04003117 }
Dees_Troy43d8b002012-09-17 16:00:01 -04003118}
Dees_Troye58d5262012-09-21 12:27:57 -04003119
3120void TWPartition::Recreate_AndSec_Folder(void) {
Dees_Troye58d5262012-09-21 12:27:57 -04003121 if (!Has_Android_Secure)
3122 return;
Dees_Troy2673cec2013-04-02 20:22:16 +00003123 LOGINFO("Creating %s: %s\n", Backup_Display_Name.c_str(), Symlink_Path.c_str());
Dees_Troye58d5262012-09-21 12:27:57 -04003124 if (!Mount(true)) {
Ethan Yonker74db1572015-10-28 12:44:49 -05003125 gui_msg(Msg(msg::kError, "recreate_folder_err=Unable to recreate {1} folder.")(Backup_Name));
Dees_Troye58d5262012-09-21 12:27:57 -04003126 } else if (!TWFunc::Path_Exists(Symlink_Path)) {
Dees_Troy2673cec2013-04-02 20:22:16 +00003127 LOGINFO("Recreating %s folder.\n", Backup_Name.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003128 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05003129 mkdir(Symlink_Path.c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003130 PartitionManager.UnMount_By_Path(Symlink_Mount_Point, true);
Dees_Troye58d5262012-09-21 12:27:57 -04003131 }
3132}
bigbiff7cb4c332014-11-26 20:36:07 -05003133
3134uint64_t TWPartition::Get_Max_FileSize() {
3135 uint64_t maxFileSize = 0;
3136 const uint64_t constGB = (uint64_t) 1024 * 1024 * 1024;
3137 const uint64_t constTB = (uint64_t) constGB * 1024;
3138 const uint64_t constPB = (uint64_t) constTB * 1024;
bigbiff0c532032014-12-21 13:41:26 -05003139 if (Current_File_System == "ext4")
3140 maxFileSize = 16 * constTB; //16 TB
3141 else if (Current_File_System == "vfat")
3142 maxFileSize = 4 * constGB; //4 GB
Captain Throwback47bf7202020-10-06 17:39:39 -04003143 else if (Current_File_System == "ntfs" || Current_File_System == "tntfs")
bigbiff0c532032014-12-21 13:41:26 -05003144 maxFileSize = 256 * constTB; //256 TB
3145 else if (Current_File_System == "exfat")
3146 maxFileSize = 16 * constPB; //16 PB
3147 else if (Current_File_System == "ext3")
3148 maxFileSize = 2 * constTB; //2 TB
3149 else if (Current_File_System == "f2fs")
3150 maxFileSize = 3.94 * constTB; //3.94 TB
bigbiff7cb4c332014-11-26 20:36:07 -05003151 else
3152 maxFileSize = 100000000L;
3153 return maxFileSize - 1;
3154}
3155
bigbiffce8f83c2015-12-12 18:30:21 -05003156bool TWPartition::Flash_Image(PartitionSettings *part_settings) {
3157 string Restore_File_System, full_filename;
Ethan Yonker96af84a2015-01-05 14:58:36 -06003158
Ethan Yonkere080c1f2016-09-19 13:50:25 -05003159 full_filename = part_settings->Backup_Folder + "/" + Backup_FileName;
Ethan Yonker96af84a2015-01-05 14:58:36 -06003160
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05003161 LOGINFO("Image filename is: %s\n", Backup_FileName.c_str());
bigbiffce8f83c2015-12-12 18:30:21 -05003162
3163 if (Backup_Method == BM_FILES) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06003164 LOGERR("Cannot flash images to file systems\n");
3165 return false;
3166 } else if (!Can_Flash_Img) {
3167 LOGERR("Cannot flash images to partitions %s\n", Display_Name.c_str());
3168 return false;
3169 } else {
3170 if (!Find_Partition_Size()) {
3171 LOGERR("Unable to find partition size for '%s'\n", Mount_Point.c_str());
3172 return false;
3173 }
bigbiffce8f83c2015-12-12 18:30:21 -05003174 unsigned long long image_size = TWFunc::Get_File_Size(full_filename);
Ethan Yonker96af84a2015-01-05 14:58:36 -06003175 if (image_size > Size) {
Ethan Yonker74db1572015-10-28 12:44:49 -05003176 LOGINFO("Size (%llu bytes) of image '%s' is larger than target device '%s' (%llu bytes)\n",
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05003177 image_size, Backup_FileName.c_str(), Actual_Block_Device.c_str(), Size);
Ethan Yonker74db1572015-10-28 12:44:49 -05003178 gui_err("img_size_err=Size of image is larger than target device");
Ethan Yonker96af84a2015-01-05 14:58:36 -06003179 return false;
3180 }
bigbiffce8f83c2015-12-12 18:30:21 -05003181 if (Backup_Method == BM_DD) {
3182 if (!part_settings->adbbackup) {
3183 if (Is_Sparse_Image(full_filename)) {
3184 return Flash_Sparse_Image(full_filename);
3185 }
Ethan Yonker472f5062016-02-25 13:47:30 -06003186 }
bigbiffce8f83c2015-12-12 18:30:21 -05003187 return Raw_Read_Write(part_settings);
3188 } else if (Backup_Method == BM_FLASH_UTILS) {
3189 return Flash_Image_FI(full_filename, NULL);
Ethan Yonker472f5062016-02-25 13:47:30 -06003190 }
Ethan Yonker96af84a2015-01-05 14:58:36 -06003191 }
3192
3193 LOGERR("Unknown flash method for '%s'\n", Mount_Point.c_str());
3194 return false;
3195}
3196
Ethan Yonker472f5062016-02-25 13:47:30 -06003197bool TWPartition::Is_Sparse_Image(const string& Filename) {
HashBanged974bb2016-01-30 14:20:09 -05003198 uint32_t magic = 0;
3199 int fd = open(Filename.c_str(), O_RDONLY);
3200 if (fd < 0) {
3201 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Filename)(strerror(errno)));
3202 return false;
3203 }
bigbiffce8f83c2015-12-12 18:30:21 -05003204
HashBanged974bb2016-01-30 14:20:09 -05003205 if (read(fd, &magic, sizeof(magic)) != sizeof(magic)) {
3206 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Filename)(strerror(errno)));
3207 close(fd);
3208 return false;
3209 }
3210 close(fd);
Ethan Yonker472f5062016-02-25 13:47:30 -06003211 if (magic == SPARSE_HEADER_MAGIC)
3212 return true;
3213 return false;
3214}
3215
3216bool TWPartition::Flash_Sparse_Image(const string& Filename) {
3217 string Command;
3218
3219 gui_msg(Msg("flashing=Flashing {1}...")(Display_Name));
3220
3221 Command = "simg2img '" + Filename + "' '" + Actual_Block_Device + "'";
Ethan Yonker96af84a2015-01-05 14:58:36 -06003222 LOGINFO("Flash command: '%s'\n", Command.c_str());
3223 TWFunc::Exec_Cmd(Command);
3224 return true;
3225}
3226
Ethan Yonker472f5062016-02-25 13:47:30 -06003227bool TWPartition::Flash_Image_FI(const string& Filename, ProgressTracking *progress) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06003228 string Command;
Ethan Yonker472f5062016-02-25 13:47:30 -06003229 unsigned long long file_size;
Ethan Yonker96af84a2015-01-05 14:58:36 -06003230
Ethan Yonker74db1572015-10-28 12:44:49 -05003231 gui_msg(Msg("flashing=Flashing {1}...")(Display_Name));
Ethan Yonker472f5062016-02-25 13:47:30 -06003232 if (progress) {
3233 file_size = (unsigned long long)(TWFunc::Get_File_Size(Filename));
3234 progress->SetPartitionSize(file_size);
3235 }
Ethan Yonker96af84a2015-01-05 14:58:36 -06003236 // Sometimes flash image doesn't like to flash due to the first 2KB matching, so we erase first to ensure that it flashes
3237 Command = "erase_image " + MTD_Name;
3238 LOGINFO("Erase command: '%s'\n", Command.c_str());
3239 TWFunc::Exec_Cmd(Command);
3240 Command = "flash_image " + MTD_Name + " '" + Filename + "'";
3241 LOGINFO("Flash command: '%s'\n", Command.c_str());
3242 TWFunc::Exec_Cmd(Command);
Ethan Yonker472f5062016-02-25 13:47:30 -06003243 if (progress)
3244 progress->UpdateSize(file_size);
Ethan Yonker96af84a2015-01-05 14:58:36 -06003245 return true;
3246}
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05003247
3248void TWPartition::Change_Mount_Read_Only(bool new_value) {
3249 Mount_Read_Only = new_value;
3250}
3251
bigbiffce8f83c2015-12-12 18:30:21 -05003252bool TWPartition::Is_Read_Only() {
3253 return Mount_Read_Only;
3254}
3255
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05003256int TWPartition::Check_Lifetime_Writes() {
3257 bool original_read_only = Mount_Read_Only;
3258 int ret = 1;
3259
3260 Mount_Read_Only = true;
3261 if (Mount(false)) {
3262 Find_Actual_Block_Device();
Ethan Yonker54970bb2019-01-17 16:19:24 -06003263 string temp = Actual_Block_Device;
3264 Find_Real_Block_Device(temp, false);
3265 string block = basename(temp.c_str());
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05003266 string file = "/sys/fs/" + Current_File_System + "/" + block + "/lifetime_write_kbytes";
3267 string result;
3268 if (TWFunc::Path_Exists(file)) {
3269 if (TWFunc::read_file(file, result) != 0) {
3270 LOGINFO("Check_Lifetime_Writes of '%s' failed to read_file\n", file.c_str());
3271 } else {
3272 LOGINFO("Check_Lifetime_Writes result: '%s'\n", result.c_str());
3273 if (result == "0") {
3274 ret = 0;
3275 }
3276 }
3277 } else {
3278 LOGINFO("Check_Lifetime_Writes file does not exist '%s'\n", file.c_str());
3279 }
3280 UnMount(true);
3281 } else {
3282 LOGINFO("Check_Lifetime_Writes failed to mount '%s'\n", Mount_Point.c_str());
3283 }
3284 Mount_Read_Only = original_read_only;
3285 return ret;
3286}
Ethan Yonker66a19492015-12-10 10:19:45 -06003287
3288int TWPartition::Decrypt_Adopted() {
3289#ifdef TW_INCLUDE_CRYPTO
3290 int ret = 1;
3291 Is_Adopted_Storage = false;
3292 string Adopted_Key_File = "";
3293
3294 if (!Removable)
3295 return ret;
3296
3297 int fd = open(Alternate_Block_Device.c_str(), O_RDONLY);
3298 if (fd < 0) {
3299 LOGINFO("failed to open '%s'\n", Alternate_Block_Device.c_str());
3300 return ret;
3301 }
3302 char type_guid[80];
3303 char part_guid[80];
3304
3305 if (gpt_disk_get_partition_info(fd, 2, type_guid, part_guid) == 0) {
3306 LOGINFO("type: '%s'\n", type_guid);
3307 LOGINFO("part: '%s'\n", part_guid);
3308 Adopted_GUID = part_guid;
3309 LOGINFO("Adopted_GUID '%s'\n", Adopted_GUID.c_str());
3310 if (strcmp(type_guid, TWGptAndroidExpand) == 0) {
3311 LOGINFO("android_expand found\n");
3312 Adopted_Key_File = "/data/misc/vold/expand_";
3313 Adopted_Key_File += part_guid;
3314 Adopted_Key_File += ".key";
3315 if (TWFunc::Path_Exists(Adopted_Key_File)) {
3316 Is_Adopted_Storage = true;
3317 /* Until we find a use case for this, I think it is safe
3318 * to disable USB Mass Storage whenever adopted storage
3319 * is present.
3320 */
3321 LOGINFO("Detected adopted storage, disabling USB mass storage mode\n");
3322 DataManager::SetValue("tw_has_usb_storage", 0);
3323 }
3324 }
3325 }
3326
3327 if (Is_Adopted_Storage) {
3328 string Adopted_Block_Device = Alternate_Block_Device + "p2";
3329 if (!TWFunc::Path_Exists(Adopted_Block_Device)) {
3330 Adopted_Block_Device = Alternate_Block_Device + "2";
3331 if (!TWFunc::Path_Exists(Adopted_Block_Device)) {
3332 LOGINFO("Adopted block device does not exist\n");
3333 goto exit;
3334 }
3335 }
3336 LOGINFO("key file is '%s', block device '%s'\n", Adopted_Key_File.c_str(), Adopted_Block_Device.c_str());
3337 char crypto_blkdev[MAXPATHLEN];
3338 std::string thekey;
3339 int fdkey = open(Adopted_Key_File.c_str(), O_RDONLY);
3340 if (fdkey < 0) {
3341 LOGINFO("failed to open key file\n");
3342 goto exit;
3343 }
3344 char buf[512];
3345 ssize_t n;
3346 while ((n = read(fdkey, &buf[0], sizeof(buf))) > 0) {
3347 thekey.append(buf, n);
3348 }
3349 close(fdkey);
3350 unsigned char* key = (unsigned char*) thekey.data();
3351 cryptfs_revert_ext_volume(part_guid);
3352
3353 ret = cryptfs_setup_ext_volume(part_guid, Adopted_Block_Device.c_str(), key, thekey.size(), crypto_blkdev);
3354 if (ret == 0) {
3355 LOGINFO("adopted storage new block device: '%s'\n", crypto_blkdev);
3356 Decrypted_Block_Device = crypto_blkdev;
3357 Is_Decrypted = true;
3358 Is_Encrypted = true;
3359 Find_Actual_Block_Device();
Kjell Braden3126a112016-06-19 16:58:15 +00003360 if (!Mount_Storage_Retry(false)) {
Ethan Yonker66a19492015-12-10 10:19:45 -06003361 LOGERR("Failed to mount decrypted adopted storage device\n");
3362 Is_Decrypted = false;
3363 Is_Encrypted = false;
3364 cryptfs_revert_ext_volume(part_guid);
3365 ret = 1;
3366 } else {
Ethan Yonkerfcf3f242016-02-16 12:30:26 -06003367 UnMount(false);
3368 Has_Android_Secure = false;
3369 Symlink_Path = "";
3370 Symlink_Mount_Point = "";
3371 Backup_Name = Mount_Point.substr(1);
3372 Backup_Path = Mount_Point;
3373 TWPartition* sdext = PartitionManager.Find_Partition_By_Path("/sd-ext");
3374 if (sdext && sdext->Actual_Block_Device == Adopted_Block_Device) {
3375 LOGINFO("Removing /sd-ext from partition list due to adopted storage\n");
3376 PartitionManager.Remove_Partition_By_Path("/sd-ext");
3377 }
Ethan Yonker66a19492015-12-10 10:19:45 -06003378 Setup_Data_Media();
Ethan Yonker66a19492015-12-10 10:19:45 -06003379 Wipe_Available_in_GUI = true;
3380 Wipe_During_Factory_Reset = true;
3381 Can_Be_Backed_Up = true;
3382 Can_Encrypt_Backup = true;
3383 Use_Userdata_Encryption = true;
3384 Is_Storage = true;
3385 Storage_Name = "Adopted Storage";
3386 Is_SubPartition = true;
3387 SubPartition_Of = "/data";
3388 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
3389 DataManager::SetValue("tw_has_adopted_storage", 1);
3390 }
3391 } else {
3392 LOGERR("Failed to setup adopted storage decryption\n");
3393 }
3394 }
3395exit:
Matt Mower06543e32017-01-06 15:25:26 -06003396 close(fd);
Ethan Yonker66a19492015-12-10 10:19:45 -06003397 return ret;
3398#else
3399 LOGINFO("Decrypt_Adopted: no crypto support\n");
3400 return 1;
3401#endif
3402}
3403
3404void TWPartition::Revert_Adopted() {
3405#ifdef TW_INCLUDE_CRYPTO
3406 if (!Adopted_GUID.empty()) {
3407 PartitionManager.Remove_MTP_Storage(Mount_Point);
3408 UnMount(false);
3409 cryptfs_revert_ext_volume(Adopted_GUID.c_str());
3410 Is_Adopted_Storage = false;
3411 Is_Encrypted = false;
3412 Is_Decrypted = false;
3413 Decrypted_Block_Device = "";
3414 Find_Actual_Block_Device();
3415 Wipe_During_Factory_Reset = false;
3416 Can_Be_Backed_Up = false;
3417 Can_Encrypt_Backup = false;
3418 Use_Userdata_Encryption = false;
3419 Is_SubPartition = false;
3420 SubPartition_Of = "";
3421 Has_Data_Media = false;
3422 Storage_Path = Mount_Point;
3423 if (!Symlink_Mount_Point.empty()) {
3424 TWPartition* Dat = PartitionManager.Find_Partition_By_Path("/data");
3425 if (Dat) {
3426 Dat->UnMount(false);
3427 Dat->Symlink_Mount_Point = Symlink_Mount_Point;
3428 }
3429 Symlink_Mount_Point = "";
3430 }
3431 }
3432#else
3433 LOGINFO("Revert_Adopted: no crypto support\n");
3434#endif
3435}
bigbiff bigbiffb5ecaad2017-03-20 18:53:53 -04003436
3437void TWPartition::Set_Backup_FileName(string fname) {
3438 Backup_FileName = fname;
3439}
3440
3441string TWPartition::Get_Backup_Name() {
3442 return Backup_Name;
3443}
bigbiffee7b7ff2020-03-23 15:08:27 -04003444
3445string TWPartition::Get_Mount_Point() {
3446 return Mount_Point;
3447}
3448
3449void TWPartition::Set_Block_Device(std::string block_device) {
3450 Primary_Block_Device = Actual_Block_Device = block_device;
3451}
3452
3453bool TWPartition::Get_Super_Status() {
3454 return Is_Super;
3455}
3456
3457void TWPartition::Set_Can_Be_Backed_Up(bool val) {
3458 Can_Be_Backed_Up = val;
3459}
3460
3461void TWPartition::Set_Can_Be_Wiped(bool val) {
3462 Can_Be_Wiped = val;
3463 Wipe_Available_in_GUI = val;
bigbiffad58e1b2020-07-06 20:24:34 -04003464}
3465
3466std::string TWPartition::Get_Backup_FileName() {
3467 return Backup_FileName;
3468}
3469
3470std::string TWPartition::Get_Display_Name() {
3471 return Display_Name;
3472}
3473
3474bool TWPartition::Is_SlotSelect() {
3475 return SlotSelect;
Mohd Faraz815e2402020-09-19 19:31:52 +05303476}
bigbiffcfa875c2021-06-20 16:20:27 -04003477
3478bool TWPartition::Check_Pending_Merges() {
3479 auto sm = android::snapshot::SnapshotManager::NewForFirstStageMount();
3480 if (!sm) {
3481 LOGERR("Unable to call snapshot manager\n");
3482 return false;
3483 }
3484
3485 auto callback = [&]() -> void {
3486 double progress;
3487 sm->GetUpdateState(&progress);
3488 LOGINFO("waiting for merge to complete: %.2f\n", progress);
3489 };
3490
3491 LOGINFO("checking for merges\n");
3492 if (!sm->HandleImminentDataWipe(callback)) {
3493 LOGERR("Unable to check merge status\n");
3494 return false;
3495 }
3496 return true;
3497}