blob: f04062050c35319a3d1edbd14bf0d3e845595e15 [file] [log] [blame]
Dees Troy3be70a82013-10-22 14:25:12 +00001/*
bigbiffaed1bdf2021-08-03 18:21:39 -04002 Copyright 2013 to 2021 TeamWin
Dees Troy3be70a82013-10-22 14:25:12 +00003 This file is part of TWRP/TeamWin Recovery Project.
4
5 TWRP is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation, either version 3 of the License, or
8 (at your option) any later version.
9
10 TWRP is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with TWRP. If not, see <http://www.gnu.org/licenses/>.
17*/
Dees_Troy51a0e822012-09-05 15:24:24 -040018
19#include <stdio.h>
20#include <stdlib.h>
21#include <string.h>
bigbiff7ba75002020-04-11 20:47:09 -040022
Dees_Troy5bf43922012-09-07 16:07:55 -040023#include <sys/mount.h>
bigbiff7ba75002020-04-11 20:47:09 -040024#include <sys/param.h>
25#include <sys/stat.h>
26#include <sys/types.h>
27#include <sys/vfs.h>
Dees_Troy51a0e822012-09-05 15:24:24 -040028#include <unistd.h>
Dees_Troy51127312012-09-08 13:08:49 -040029#include <dirent.h>
Ethan Yonker472f5062016-02-25 13:47:30 -060030#include <fcntl.h>
bigbiff7ba75002020-04-11 20:47:09 -040031#include <iostream>
32#include <libgen.h>
bigbiff7ba75002020-04-11 20:47:09 -040033#include <zlib.h>
34#include <sstream>
bigbiffcfa875c2021-06-20 16:20:27 -040035#include <android-base/properties.h>
36#include <libsnapshot/snapshot.h>
Dees_Troy51a0e822012-09-05 15:24:24 -040037
Ethan Yonker007de982018-08-31 14:23:16 -050038#include "cutils/properties.h"
bigbiff7b4c7a62015-01-01 19:44:14 -050039#include "libblkid/include/blkid.h"
Dees_Troy51a0e822012-09-05 15:24:24 -040040#include "variables.h"
Dees_Troy2673cec2013-04-02 20:22:16 +000041#include "twcommon.h"
Dees_Troy51a0e822012-09-05 15:24:24 -040042#include "partitions.hpp"
Dees_Troy5bf43922012-09-07 16:07:55 -040043#include "data.hpp"
Dees_Troy43d8b002012-09-17 16:00:01 -040044#include "twrp-functions.hpp"
bigbiff bigbiff9c754052013-01-09 09:09:08 -050045#include "twrpTar.hpp"
Ethan Yonker3fdcda42016-11-30 12:29:37 -060046#include "exclude.hpp"
Ethan Yonker1b7a31b2014-07-03 15:09:22 -050047#include "infomanager.hpp"
Ethan Yonker4b94cfd2014-12-11 10:00:45 -060048#include "set_metadata.h"
Ethan Yonker74db1572015-10-28 12:44:49 -050049#include "gui/gui.hpp"
bigbiffce8f83c2015-12-12 18:30:21 -050050#include "adbbu/libtwadbbu.hpp"
Ethan Yonker98661c12018-10-17 08:39:28 -050051#ifdef TW_INCLUDE_CRYPTO
52 #include "crypto/fde/cryptfs.h"
bigbiffa957f072021-03-07 18:20:29 -050053 #include "Decrypt.h"
Ethan Yonker98661c12018-10-17 08:39:28 -050054#else
55 #define CRYPT_FOOTER_OFFSET 0x4000
56#endif
Dees_Troy5bf43922012-09-07 16:07:55 -040057extern "C" {
Dees_Troy38bd7602012-09-14 13:33:53 -040058 #include "mtdutils/mtdutils.h"
59 #include "mtdutils/mounts.h"
Dees_Troya95f55c2013-08-17 13:14:43 +000060#ifdef USE_EXT4
Ethan Yonker8373cfe2017-09-08 06:50:54 -050061 // #include "make_ext4fs.h" TODO need ifdef for android8
62 #include <ext4_utils/make_ext4fs.h>
Dees_Troya95f55c2013-08-17 13:14:43 +000063#endif
Ethan Yonker71413f42014-02-26 13:36:08 -060064#ifdef TW_INCLUDE_CRYPTO
Ethan Yonker66a19492015-12-10 10:19:45 -060065 #include "gpt/gpt.h"
Ethan Yonker71413f42014-02-26 13:36:08 -060066#endif
Dees_Troy5bf43922012-09-07 16:07:55 -040067}
Matt Mower87413642017-01-17 21:14:46 -060068#include <selinux/selinux.h>
Ethan Yonkerf27497f2014-02-09 11:48:33 -060069#include <selinux/label.h>
Dees Troy4159aed2014-02-28 17:24:43 +000070#ifdef HAVE_CAPABILITIES
71#include <sys/capability.h>
72#include <sys/xattr.h>
73#include <linux/xattr.h>
74#endif
HashBanged974bb2016-01-30 14:20:09 -050075#include <sparse_format.h>
Ethan Yonker472f5062016-02-25 13:47:30 -060076#include "progresstracking.hpp"
Dees_Troy51a0e822012-09-05 15:24:24 -040077
bigbiff bigbiff9c754052013-01-09 09:09:08 -050078using namespace std;
79
Ethan Yonker6e8c27a2016-12-22 17:55:57 -060080static int auto_index = 0; // v2 fstab allows you to specify a mount point of "auto" with no /. These items are given a mount point of /auto* where * == auto_index
81
Dees_Troya95f55c2013-08-17 13:14:43 +000082extern struct selabel_handle *selinux_handle;
Ethan Yonker6277c792014-09-15 14:54:30 -050083extern bool datamedia;
Dees_Troya95f55c2013-08-17 13:14:43 +000084
Hashcode62bd9e02013-11-19 21:59:42 -080085struct flag_list {
86 const char *name;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -060087 unsigned long flag;
Hashcode62bd9e02013-11-19 21:59:42 -080088};
89
Matt Mower4ab42b12016-04-21 13:52:18 -050090const struct flag_list mount_flags[] = {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -060091 { "noatime", MS_NOATIME },
92 { "noexec", MS_NOEXEC },
93 { "nosuid", MS_NOSUID },
94 { "nodev", MS_NODEV },
95 { "nodiratime", MS_NODIRATIME },
96 { "ro", MS_RDONLY },
97 { "rw", 0 },
98 { "remount", MS_REMOUNT },
99 { "bind", MS_BIND },
100 { "rec", MS_REC },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000101#ifdef MS_UNBINDABLE
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600102 { "unbindable", MS_UNBINDABLE },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000103#endif
104#ifdef MS_PRIVATE
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600105 { "private", MS_PRIVATE },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000106#endif
107#ifdef MS_SLAVE
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600108 { "slave", MS_SLAVE },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000109#endif
110#ifdef MS_SHARED
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600111 { "shared", MS_SHARED },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000112#endif
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600113 { "sync", MS_SYNCHRONOUS },
114 { 0, 0 },
115};
116
117const char *ignored_mount_items[] = {
118 "defaults=",
119 "errors=",
Ethan Yonker93382822018-11-01 15:25:31 -0500120 "latemount",
121 "sysfs_path=",
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600122 NULL
Hashcode62bd9e02013-11-19 21:59:42 -0800123};
124
Matt Mower2416a502016-04-12 19:54:46 -0500125enum TW_FSTAB_FLAGS {
126 TWFLAG_DEFAULTS, // Retain position
127 TWFLAG_ANDSEC,
128 TWFLAG_BACKUP,
129 TWFLAG_BACKUPNAME,
130 TWFLAG_BLOCKSIZE,
131 TWFLAG_CANBEWIPED,
132 TWFLAG_CANENCRYPTBACKUP,
133 TWFLAG_DISPLAY,
134 TWFLAG_ENCRYPTABLE,
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500135 TWFLAG_FILEENCRYPTION,
Captain Throwback32bcdcd2022-02-08 12:45:01 -0500136 TWFLAG_METADATA_ENCRYPTION,
Matt Mower2416a502016-04-12 19:54:46 -0500137 TWFLAG_FLASHIMG,
138 TWFLAG_FORCEENCRYPT,
139 TWFLAG_FSFLAGS,
140 TWFLAG_IGNOREBLKID,
141 TWFLAG_LENGTH,
142 TWFLAG_MOUNTTODECRYPT,
Captain Throwbacke848afc2022-02-08 15:31:44 -0500143 TWFLAG_QUOTA,
Matt Mower2416a502016-04-12 19:54:46 -0500144 TWFLAG_REMOVABLE,
Matt Mower2416a502016-04-12 19:54:46 -0500145 TWFLAG_SETTINGSSTORAGE,
146 TWFLAG_STORAGE,
147 TWFLAG_STORAGENAME,
148 TWFLAG_SUBPARTITIONOF,
149 TWFLAG_SYMLINK,
150 TWFLAG_USERDATAENCRYPTBACKUP,
151 TWFLAG_USERMRF,
152 TWFLAG_WIPEDURINGFACTORYRESET,
153 TWFLAG_WIPEINGUI,
Ethan Yonker1b190162016-12-05 15:25:19 -0600154 TWFLAG_SLOTSELECT,
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600155 TWFLAG_WAIT,
156 TWFLAG_VERIFY,
157 TWFLAG_CHECK,
158 TWFLAG_ALTDEVICE,
159 TWFLAG_NOTRIM,
160 TWFLAG_VOLDMANAGED,
161 TWFLAG_FORMATTABLE,
162 TWFLAG_RESIZE,
Ethan Yonker93382822018-11-01 15:25:31 -0500163 TWFLAG_KEYDIRECTORY,
Peter Cai28ea7b02019-05-24 11:38:54 +0800164 TWFLAG_WRAPPEDKEY,
Peter Cai439d60c2019-10-17 08:49:10 +0800165 TWFLAG_ADOPTED_MOUNT_DELAY,
Peter Caid68e6412019-11-02 19:22:38 +0800166 TWFLAG_DM_USE_ORIGINAL_PATH,
bigbiff998f8392021-08-06 19:19:33 -0400167 TWFLAG_LOGICAL,
Matt Mower2416a502016-04-12 19:54:46 -0500168};
169
170/* Flags without a trailing '=' are considered dual format flags and can be
171 * written as either 'flagname' or 'flagname=', where the character following
172 * the '=' is Y,y,1 for true and false otherwise.
173 */
174const struct flag_list tw_flags[] = {
175 { "andsec", TWFLAG_ANDSEC },
176 { "backup", TWFLAG_BACKUP },
177 { "backupname=", TWFLAG_BACKUPNAME },
178 { "blocksize=", TWFLAG_BLOCKSIZE },
179 { "canbewiped", TWFLAG_CANBEWIPED },
180 { "canencryptbackup", TWFLAG_CANENCRYPTBACKUP },
181 { "defaults", TWFLAG_DEFAULTS },
182 { "display=", TWFLAG_DISPLAY },
183 { "encryptable=", TWFLAG_ENCRYPTABLE },
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500184 { "fileencryption=", TWFLAG_FILEENCRYPTION },
Captain Throwback32bcdcd2022-02-08 12:45:01 -0500185 { "metadata_encryption=", TWFLAG_METADATA_ENCRYPTION },
Matt Mower2416a502016-04-12 19:54:46 -0500186 { "flashimg", TWFLAG_FLASHIMG },
187 { "forceencrypt=", TWFLAG_FORCEENCRYPT },
188 { "fsflags=", TWFLAG_FSFLAGS },
189 { "ignoreblkid", TWFLAG_IGNOREBLKID },
190 { "length=", TWFLAG_LENGTH },
191 { "mounttodecrypt", TWFLAG_MOUNTTODECRYPT },
Captain Throwbacke848afc2022-02-08 15:31:44 -0500192 { "quota", TWFLAG_QUOTA },
Matt Mower2416a502016-04-12 19:54:46 -0500193 { "removable", TWFLAG_REMOVABLE },
Matt Mower2416a502016-04-12 19:54:46 -0500194 { "settingsstorage", TWFLAG_SETTINGSSTORAGE },
195 { "storage", TWFLAG_STORAGE },
196 { "storagename=", TWFLAG_STORAGENAME },
197 { "subpartitionof=", TWFLAG_SUBPARTITIONOF },
198 { "symlink=", TWFLAG_SYMLINK },
199 { "userdataencryptbackup", TWFLAG_USERDATAENCRYPTBACKUP },
200 { "usermrf", TWFLAG_USERMRF },
201 { "wipeduringfactoryreset", TWFLAG_WIPEDURINGFACTORYRESET },
202 { "wipeingui", TWFLAG_WIPEINGUI },
Ethan Yonker1b190162016-12-05 15:25:19 -0600203 { "slotselect", TWFLAG_SLOTSELECT },
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600204 { "wait", TWFLAG_WAIT },
205 { "verify", TWFLAG_VERIFY },
206 { "check", TWFLAG_CHECK },
207 { "altdevice", TWFLAG_ALTDEVICE },
208 { "notrim", TWFLAG_NOTRIM },
209 { "voldmanaged=", TWFLAG_VOLDMANAGED },
210 { "formattable", TWFLAG_FORMATTABLE },
211 { "resize", TWFLAG_RESIZE },
Ethan Yonker93382822018-11-01 15:25:31 -0500212 { "keydirectory=", TWFLAG_KEYDIRECTORY },
Peter Cai28ea7b02019-05-24 11:38:54 +0800213 { "wrappedkey", TWFLAG_WRAPPEDKEY },
Peter Cai439d60c2019-10-17 08:49:10 +0800214 { "adopted_mount_delay=", TWFLAG_ADOPTED_MOUNT_DELAY },
Peter Caid68e6412019-11-02 19:22:38 +0800215 { "dm_use_original_path", TWFLAG_DM_USE_ORIGINAL_PATH },
bigbiff998f8392021-08-06 19:19:33 -0400216 { "logical", TWFLAG_LOGICAL },
Matt Mower2416a502016-04-12 19:54:46 -0500217 { 0, 0 },
218};
219
that9e0593e2014-10-08 00:01:24 +0200220TWPartition::TWPartition() {
Dees_Troy51a0e822012-09-05 15:24:24 -0400221 Can_Be_Mounted = false;
222 Can_Be_Wiped = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500223 Can_Be_Backed_Up = false;
Vojtech Bocek1dc30982013-08-30 21:49:30 +0200224 Use_Rm_Rf = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400225 Wipe_During_Factory_Reset = false;
226 Wipe_Available_in_GUI = false;
227 Is_SubPartition = false;
Dees_Troy2691f9d2012-09-24 11:15:49 -0400228 Has_SubPartition = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400229 SubPartition_Of = "";
230 Symlink_Path = "";
231 Symlink_Mount_Point = "";
232 Mount_Point = "";
Dees_Troye58d5262012-09-21 12:27:57 -0400233 Backup_Path = "";
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600234 Wildcard_Block_Device = false;
235 Sysfs_Entry = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400236 Actual_Block_Device = "";
237 Primary_Block_Device = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400238 Alternate_Block_Device = "";
239 Removable = false;
240 Is_Present = false;
241 Length = 0;
242 Size = 0;
243 Used = 0;
244 Free = 0;
245 Backup_Size = 0;
246 Can_Be_Encrypted = false;
247 Is_Encrypted = false;
248 Is_Decrypted = false;
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600249 Is_FBE = false;
Ethan Yonker253368a2014-11-25 15:00:52 -0600250 Mount_To_Decrypt = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400251 Decrypted_Block_Device = "";
252 Display_Name = "";
Dees_Troya13d74f2013-03-24 08:54:55 -0500253 Backup_Display_Name = "";
254 Storage_Name = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400255 Backup_Name = "";
Dees_Troy63c8df72012-09-10 14:02:05 -0400256 Backup_FileName = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400257 MTD_Name = "";
bigbiffce8f83c2015-12-12 18:30:21 -0500258 Backup_Method = BM_NONE;
Dees_Troy83bd4832013-05-04 12:39:56 +0000259 Can_Encrypt_Backup = false;
260 Use_Userdata_Encryption = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400261 Has_Data_Media = false;
Dees_Troye58d5262012-09-21 12:27:57 -0400262 Has_Android_Secure = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400263 Is_Storage = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500264 Is_Settings_Storage = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400265 Storage_Path = "";
266 Current_File_System = "";
267 Fstab_File_System = "";
Hashcode62bd9e02013-11-19 21:59:42 -0800268 Mount_Flags = 0;
269 Mount_Options = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400270 Format_Block_Size = 0;
Dees_Troy68cab492012-12-12 19:29:35 +0000271 Ignore_Blkid = false;
dianlujitao4879b372018-12-03 18:45:47 +0800272 Crypto_Key_Location = "";
Ethan Yonker726a0202014-12-16 20:01:38 -0600273 MTP_Storage_ID = 0;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600274 Can_Flash_Img = false;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500275 Mount_Read_Only = false;
Ethan Yonker66a19492015-12-10 10:19:45 -0600276 Is_Adopted_Storage = false;
277 Adopted_GUID = "";
Ethan Yonker1b190162016-12-05 15:25:19 -0600278 SlotSelect = false;
Ethan Yonker93382822018-11-01 15:25:31 -0500279 Key_Directory = "";
bigbiffee7b7ff2020-03-23 15:08:27 -0400280 Is_Super = false;
Peter Cai439d60c2019-10-17 08:49:10 +0800281 Adopted_Mount_Delay = 0;
Peter Caid68e6412019-11-02 19:22:38 +0800282 Original_Path = "";
283 Use_Original_Path = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400284}
285
286TWPartition::~TWPartition(void) {
287 // Do nothing
288}
289
bigbiff8da46fa2020-09-08 16:42:34 -0400290bool 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 -0500291 char full_line[MAX_FSTAB_LINE_LENGTH];
Matt Mower2416a502016-04-12 19:54:46 -0500292 char twflags[MAX_FSTAB_LINE_LENGTH] = "";
Dees_Troy5bf43922012-09-07 16:07:55 -0400293 char* ptr;
Matt Mower2b2dd152016-04-26 11:24:08 -0500294 int line_len = strlen(fstab_line), index = 0, item_index = 0;
Dees_Troya13d74f2013-03-24 08:54:55 -0500295 bool skip = false;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600296 int fstab_version = 1, mount_point_index = 0, fs_index = 1, block_device_index = 2;
297 TWPartition *additional_entry = NULL;
298 std::map<string, Flags_Map>::iterator it;
Dees_Troy5bf43922012-09-07 16:07:55 -0400299
Matt Mower2b2dd152016-04-26 11:24:08 -0500300 strlcpy(full_line, fstab_line, sizeof(full_line));
bigbiffee7b7ff2020-03-23 15:08:27 -0400301
Dees_Troy51127312012-09-08 13:08:49 -0400302 for (index = 0; index < line_len; index++) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500303 if (full_line[index] == 34)
304 skip = !skip;
305 if (!skip && full_line[index] <= 32)
Dees_Troy5bf43922012-09-07 16:07:55 -0400306 full_line[index] = '\0';
Dees_Troy5bf43922012-09-07 16:07:55 -0400307 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600308 if (line_len < 10)
309 return false; // There can't possibly be a valid fstab line that is less than 10 chars
bigbiff998f8392021-08-06 19:19:33 -0400310 if (fstab_line[0] == '#')
311 return false; // skip comments
312
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600313 if (strncmp(fstab_line, "/dev/", strlen("/dev/")) == 0 || strncmp(fstab_line, "/devices/", strlen("/devices/")) == 0) {
314 fstab_version = 2;
315 block_device_index = 0;
316 mount_point_index = 1;
317 fs_index = 2;
318 }
319
bigbiff998f8392021-08-06 19:19:33 -0400320 if (fstab_line[0] != '/') {
bigbiffee7b7ff2020-03-23 15:08:27 -0400321 block_device_index = 0;
322 fstab_version = 2;
323 mount_point_index = 1;
324 fs_index = 2;
325 }
326
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600327 index = 0;
Dees_Troy5bf43922012-09-07 16:07:55 -0400328 while (index < line_len) {
329 while (index < line_len && full_line[index] == '\0')
330 index++;
331 if (index >= line_len)
332 continue;
333 ptr = full_line + index;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600334 if (item_index == mount_point_index) {
335 Mount_Point = ptr;
bigbiffee7b7ff2020-03-23 15:08:27 -0400336 if (fstab_version == 2 && Is_Super == false) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600337 additional_entry = PartitionManager.Find_Partition_By_Path(Mount_Point);
bigbiff8da46fa2020-09-08 16:42:34 -0400338 if (additional_entry) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600339 LOGINFO("Found an additional entry for '%s'\n", Mount_Point.c_str());
340 }
341 }
bigbiff8da46fa2020-09-08 16:42:34 -0400342 LOGINFO("Processing '%s'\n", Mount_Point.c_str());
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600343 Backup_Path = Mount_Point;
344 Storage_Path = Mount_Point;
345 Display_Name = ptr + 1;
346 Backup_Display_Name = Display_Name;
347 Storage_Name = Display_Name;
348 item_index++;
349 } else if (item_index == fs_index) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400350 // File System
351 Fstab_File_System = ptr;
352 Current_File_System = ptr;
353 item_index++;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600354 } else if (item_index == block_device_index) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400355 // Primary Block Device
Dees_Troy38bd7602012-09-14 13:33:53 -0400356 if (Fstab_File_System == "mtd" || Fstab_File_System == "yaffs2") {
Dees_Troy094207a2012-09-26 12:00:39 -0400357 MTD_Name = ptr;
358 Find_MTD_Block_Device(MTD_Name);
Dees_Troy5fcd8f92012-10-16 12:22:05 -0400359 } else if (Fstab_File_System == "bml") {
360 if (Mount_Point == "/boot")
361 MTD_Name = "boot";
362 else if (Mount_Point == "/recovery")
363 MTD_Name = "recovery";
364 Primary_Block_Device = ptr;
365 if (*ptr != '/')
Dees_Troy2673cec2013-04-02 20:22:16 +0000366 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 -0400367 } else {
368 Primary_Block_Device = ptr;
bigbiff998f8392021-08-06 19:19:33 -0400369 if (*ptr == '/')
370 Find_Real_Block_Device(Primary_Block_Device, Display_Error);
Dees_Troy5bf43922012-09-07 16:07:55 -0400371 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400372 item_index++;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600373 } else if (item_index > 2) {
374 if (fstab_version == 2) {
375 if (item_index == 3) {
376 Process_FS_Flags(ptr);
377 if (additional_entry) {
378 additional_entry->Save_FS_Flags(Fstab_File_System, Mount_Flags, Mount_Options);
379 return false; // We save the extra fs flags in the other partition entry and by returning false, this entry will be deleted
380 }
381 } else {
382 strlcpy(twflags, ptr, sizeof(twflags));
383 }
384 item_index++;
385 } else if (*ptr == '/') { // v2 fstab does not allow alternate block devices
Dees_Troy5bf43922012-09-07 16:07:55 -0400386 // Alternate Block Device
387 Alternate_Block_Device = ptr;
388 Find_Real_Block_Device(Alternate_Block_Device, Display_Error);
389 } else if (strlen(ptr) > 7 && strncmp(ptr, "length=", 7) == 0) {
390 // Partition length
391 ptr += 7;
392 Length = atoi(ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400393 } else if (strlen(ptr) > 6 && strncmp(ptr, "flags=", 6) == 0) {
394 // Custom flags, save for later so that new values aren't overwritten by defaults
395 ptr += 6;
Matt Mower2416a502016-04-12 19:54:46 -0500396 strlcpy(twflags, ptr, sizeof(twflags));
Dees_Troy38bd7602012-09-14 13:33:53 -0400397 } else if (strlen(ptr) == 4 && (strncmp(ptr, "NULL", 4) == 0 || strncmp(ptr, "null", 4) == 0 || strncmp(ptr, "null", 4) == 0)) {
398 // Do nothing
Dees_Troy5bf43922012-09-07 16:07:55 -0400399 } else {
400 // Unhandled data
Matt Mower2b2dd152016-04-26 11:24:08 -0500401 LOGINFO("Unhandled fstab information '%s' in fstab line '%s'\n", ptr, fstab_line);
Dees_Troy5bf43922012-09-07 16:07:55 -0400402 }
403 }
404 while (index < line_len && full_line[index] != '\0')
405 index++;
406 }
407
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600408 // override block devices from the v2 fstab with the ones we read from the twrp.flags file in case they are different
409 if (fstab_version == 2 && twrp_flags && twrp_flags->size() > 0) {
410 it = twrp_flags->find(Mount_Point);
411 if (it != twrp_flags->end()) {
412 if (!it->second.Primary_Block_Device.empty()) {
413 Primary_Block_Device = it->second.Primary_Block_Device;
414 Find_Real_Block_Device(Primary_Block_Device, Display_Error);
415 }
416 if (!it->second.Alternate_Block_Device.empty()) {
417 Alternate_Block_Device = it->second.Alternate_Block_Device;
418 Find_Real_Block_Device(Alternate_Block_Device, Display_Error);
419 }
420 }
421 }
422
423 if (strncmp(fstab_line, "/devices/", strlen("/devices/")) == 0) {
424 Sysfs_Entry = Primary_Block_Device;
425 Primary_Block_Device = "";
426 Is_Storage = true;
427 Removable = true;
428 Wipe_Available_in_GUI = true;
429 Wildcard_Block_Device = true;
430 }
431 if (Primary_Block_Device.find("*") != string::npos)
432 Wildcard_Block_Device = true;
433
bigbiff8da46fa2020-09-08 16:42:34 -0400434 if (Mount_Point == "auto") {
435 Mount_Point = "/auto";
436 char autoi[5];
437 sprintf(autoi, "%i", auto_index);
438 Mount_Point += autoi;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600439 Backup_Path = Mount_Point;
440 Storage_Path = Mount_Point;
dianlujitaob76a73a2020-04-30 20:33:20 +0800441 Backup_Name = Mount_Point.substr(1);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600442 auto_index++;
443 Setup_File_System(Display_Error);
444 Display_Name = "Storage";
445 Backup_Display_Name = Display_Name;
446 Storage_Name = Display_Name;
447 Can_Be_Backed_Up = false;
448 Wipe_Available_in_GUI = true;
449 Is_Storage = true;
450 Removable = true;
451 Wipe_Available_in_GUI = true;
452 } else if (!Is_File_System(Fstab_File_System) && !Is_Image(Fstab_File_System)) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400453 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000454 LOGERR("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400455 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000456 LOGINFO("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Matt Mower72c87ce2016-04-26 14:34:56 -0500457 return false;
Dees_Troy5bf43922012-09-07 16:07:55 -0400458 } else if (Is_File_System(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400459 Find_Actual_Block_Device();
Dees_Troy5bf43922012-09-07 16:07:55 -0400460 Setup_File_System(Display_Error);
dianlujitaob76a73a2020-04-30 20:33:20 +0800461 Backup_Name = Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
Chaosmaster3b682732020-01-25 21:09:28 +0100462 if (Mount_Point == "/" || Mount_Point == "/system" || Mount_Point == "/system_root") {
bigbiff8da46fa2020-09-08 16:42:34 -0400463 Mount_Point = PartitionManager.Get_Android_Root_Path();
464 Backup_Path = Mount_Point;
465 Storage_Path = Mount_Point;
Dees_Troy5bf43922012-09-07 16:07:55 -0400466 Display_Name = "System";
dianlujitaob76a73a2020-04-30 20:33:20 +0800467 Backup_Name = "system";
Dees_Troya13d74f2013-03-24 08:54:55 -0500468 Backup_Display_Name = Display_Name;
469 Storage_Name = Display_Name;
bigbiff8da46fa2020-09-08 16:42:34 -0400470 Wipe_Available_in_GUI = false;
471 Can_Be_Backed_Up = false;
472 Can_Be_Wiped = false;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500473 Mount_Read_Only = true;
bigbiff8da46fa2020-09-08 16:42:34 -0400474 Make_Dir(PartitionManager.Get_Android_Root_Path(), true);
Mohd Faraze3948ec2020-08-14 01:40:59 +0000475 } else if (Mount_Point == "/product") {
476 Display_Name = "Product";
477 Backup_Name = "Product";
478 Backup_Display_Name = Display_Name;
479 Storage_Name = Display_Name;
480 Can_Be_Backed_Up = Wipe_Available_in_GUI = Is_Super ? false : true;
481 Mount_Read_Only = true;
482 } else if (Mount_Point == "/odm") {
483 Display_Name = "ODM";
484 Backup_Name = "ODM";
485 Backup_Display_Name = Display_Name;
486 Storage_Name = Display_Name;
487 Can_Be_Backed_Up = Wipe_Available_in_GUI = Is_Super ? false : true;
488 Mount_Read_Only = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400489 } else if (Mount_Point == "/data") {
490 Display_Name = "Data";
Dees_Troya13d74f2013-03-24 08:54:55 -0500491 Backup_Display_Name = Display_Name;
492 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400493 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400494 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500495 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000496 Can_Encrypt_Backup = true;
497 Use_Userdata_Encryption = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400498 } else if (Mount_Point == "/cache") {
499 Display_Name = "Cache";
Dees_Troya13d74f2013-03-24 08:54:55 -0500500 Backup_Display_Name = Display_Name;
501 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400502 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400503 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500504 Can_Be_Backed_Up = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400505 } else if (Mount_Point == "/datadata") {
Dees_Troy51127312012-09-08 13:08:49 -0400506 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400507 Display_Name = "DataData";
Dees_Troya13d74f2013-03-24 08:54:55 -0500508 Backup_Display_Name = Display_Name;
509 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400510 Is_SubPartition = true;
511 SubPartition_Of = "/data";
Dees_Troy5bf43922012-09-07 16:07:55 -0400512 DataManager::SetValue(TW_HAS_DATADATA, 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500513 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000514 Can_Encrypt_Backup = true;
515 Use_Userdata_Encryption = false; // This whole partition should be encrypted
Dees_Troy5bf43922012-09-07 16:07:55 -0400516 } else if (Mount_Point == "/sd-ext") {
Dees_Troy51127312012-09-08 13:08:49 -0400517 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400518 Display_Name = "SD-Ext";
Dees_Troya13d74f2013-03-24 08:54:55 -0500519 Backup_Display_Name = Display_Name;
520 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400521 Wipe_Available_in_GUI = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400522 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500523 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000524 Can_Encrypt_Backup = true;
525 Use_Userdata_Encryption = true;
Dees_Troy2c50e182012-09-26 20:05:28 -0400526 } else if (Mount_Point == "/boot") {
527 Display_Name = "Boot";
Dees_Troya13d74f2013-03-24 08:54:55 -0500528 Backup_Display_Name = Display_Name;
Dees_Troy2c50e182012-09-26 20:05:28 -0400529 DataManager::SetValue("tw_boot_is_mountable", 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500530 Can_Be_Backed_Up = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500531 } else if (Mount_Point == "/vendor") {
532 Display_Name = "Vendor";
533 Backup_Display_Name = Display_Name;
534 Storage_Name = Display_Name;
535 Mount_Read_Only = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400536 }
537#ifdef TW_EXTERNAL_STORAGE_PATH
538 if (Mount_Point == EXPAND(TW_EXTERNAL_STORAGE_PATH)) {
539 Is_Storage = true;
540 Storage_Path = EXPAND(TW_EXTERNAL_STORAGE_PATH);
Dees_Troyc51f1f92012-09-20 15:32:13 -0400541 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500542 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400543#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000544 if (Mount_Point == "/sdcard" || Mount_Point == "/external_sd" || Mount_Point == "/external_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400545 Is_Storage = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400546 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500547 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400548#endif
Dees_Troyb05ddee2013-01-28 20:24:50 +0000549 }
Dees_Troy8170a922012-09-18 15:40:25 -0400550#ifdef TW_INTERNAL_STORAGE_PATH
551 if (Mount_Point == EXPAND(TW_INTERNAL_STORAGE_PATH)) {
552 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500553 Is_Settings_Storage = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400554 Storage_Path = EXPAND(TW_INTERNAL_STORAGE_PATH);
Dees_Troya13d74f2013-03-24 08:54:55 -0500555 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400556 }
557#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000558 if (Mount_Point == "/emmc" || Mount_Point == "/internal_sd" || Mount_Point == "/internal_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400559 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500560 Is_Settings_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500561 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400562 }
563#endif
Dees_Troy5bf43922012-09-07 16:07:55 -0400564 } else if (Is_Image(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400565 Find_Actual_Block_Device();
Ethan Yonker1b190162016-12-05 15:25:19 -0600566 Setup_Image();
Dees_Troya13d74f2013-03-24 08:54:55 -0500567 if (Mount_Point == "/boot") {
568 Display_Name = "Boot";
569 Backup_Display_Name = Display_Name;
570 Can_Be_Backed_Up = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600571 Can_Flash_Img = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500572 } else if (Mount_Point == "/recovery") {
573 Display_Name = "Recovery";
574 Backup_Display_Name = Display_Name;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600575 Can_Flash_Img = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500576 } else if (Mount_Point == "/system_image") {
577 Display_Name = "System Image";
578 Backup_Display_Name = Display_Name;
HashBanged974bb2016-01-30 14:20:09 -0500579 Can_Flash_Img = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500580 Can_Be_Backed_Up = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500581 } else if (Mount_Point == "/vendor_image") {
582 Display_Name = "Vendor Image";
583 Backup_Display_Name = Display_Name;
HashBanged974bb2016-01-30 14:20:09 -0500584 Can_Flash_Img = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500585 Can_Be_Backed_Up = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500586 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400587 }
588
Matt Mower2416a502016-04-12 19:54:46 -0500589 // Process TWRP fstab flags
590 if (strlen(twflags) > 0) {
591 string Prev_Display_Name = Display_Name;
592 string Prev_Storage_Name = Storage_Name;
593 string Prev_Backup_Display_Name = Backup_Display_Name;
594 Display_Name = "";
595 Storage_Name = "";
596 Backup_Display_Name = "";
597
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600598 Process_TW_Flags(twflags, (fstab_version == 1), fstab_version);
599 Save_FS_Flags(Fstab_File_System, Mount_Flags, Mount_Options);
Matt Mower2416a502016-04-12 19:54:46 -0500600
601 bool has_display_name = !Display_Name.empty();
602 bool has_storage_name = !Storage_Name.empty();
603 bool has_backup_name = !Backup_Display_Name.empty();
604 if (!has_display_name) Display_Name = Prev_Display_Name;
605 if (!has_storage_name) Storage_Name = Prev_Storage_Name;
606 if (!has_backup_name) Backup_Display_Name = Prev_Backup_Display_Name;
607
608 if (has_display_name && !has_storage_name)
609 Storage_Name = Display_Name;
610 if (!has_display_name && has_storage_name)
611 Display_Name = Storage_Name;
612 if (has_display_name && !has_backup_name && Backup_Display_Name != "Android Secure")
613 Backup_Display_Name = Display_Name;
614 if (!has_display_name && has_backup_name)
615 Display_Name = Backup_Display_Name;
616 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600617
618 if (fstab_version == 2 && twrp_flags && twrp_flags->size() > 0) {
619 it = twrp_flags->find(Mount_Point);
620 if (it != twrp_flags->end()) {
621 char twrpflags[MAX_FSTAB_LINE_LENGTH] = "";
622 int skip = 0;
623 string Flags = it->second.Flags;
624 strcpy(twrpflags, Flags.c_str());
625 if (strlen(twrpflags) > strlen("flags=") && strncmp(twrpflags, "flags=", strlen("flags=")) == 0)
626 skip += strlen("flags=");
627 char* flagptr = twrpflags;
628 flagptr += skip;
629 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
630 }
631 }
nkk7198fc3992017-12-16 16:26:42 +0200632
633 if (Mount_Point == "/persist" && Can_Be_Mounted) {
634 bool mounted = Is_Mounted();
635 if (mounted || Mount(false)) {
nkk7198fc3992017-12-16 16:26:42 +0200636 TWFunc::Fixup_Time_On_Boot("/persist/time/");
637 if (!mounted)
638 UnMount(false);
639 }
640 }
641
Dees_Troy51127312012-09-08 13:08:49 -0400642 return true;
643}
644
Matt Mower72c87ce2016-04-26 14:34:56 -0500645void TWPartition::Partition_Post_Processing(bool Display_Error) {
646 if (Mount_Point == "/data")
647 Setup_Data_Partition(Display_Error);
648 else if (Mount_Point == "/cache")
649 Setup_Cache_Partition(Display_Error);
650}
651
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600652void TWPartition::ExcludeAll(const string& path) {
653 backup_exclusions.add_absolute_dir(path);
654 wipe_exclusions.add_absolute_dir(path);
655}
656
Matt Mower72c87ce2016-04-26 14:34:56 -0500657void TWPartition::Setup_Data_Partition(bool Display_Error) {
658 if (Mount_Point != "/data")
659 return;
660
661 // Ensure /data is not mounted as tmpfs for qcom hardware decrypt
662 UnMount(false);
663
664#ifdef TW_INCLUDE_CRYPTO
Matt Mower72c87ce2016-04-26 14:34:56 -0500665 Can_Be_Encrypted = true;
666 char crypto_blkdev[255];
667 property_get("ro.crypto.fs_crypto_blkdev", crypto_blkdev, "error");
668 if (strcmp(crypto_blkdev, "error") != 0) {
bigbiff7ba75002020-04-11 20:47:09 -0400669 Set_FBE_Status();
Matt Mower72c87ce2016-04-26 14:34:56 -0500670 Decrypted_Block_Device = crypto_blkdev;
671 LOGINFO("Data already decrypted, new block device: '%s'\n", crypto_blkdev);
bigbiffcda15882021-12-30 17:01:44 -0500672 if (datamedia)
673 Setup_Data_Media();
bigbiff7ba75002020-04-11 20:47:09 -0400674 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
Matt Mower72c87ce2016-04-26 14:34:56 -0500675 } else if (!Mount(false)) {
676 if (Is_Present) {
Ethan Yonker93382822018-11-01 15:25:31 -0500677 if (Key_Directory.empty()) {
Peter Caid68e6412019-11-02 19:22:38 +0800678 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 -0400679 Fstab_File_System.c_str());
Ethan Yonker93382822018-11-01 15:25:31 -0500680 if (cryptfs_check_footer() == 0) {
681 Is_Encrypted = true;
682 Is_Decrypted = false;
683 Can_Be_Mounted = false;
684 Current_File_System = "emmc";
685 Setup_Image();
Ethan Yonker93382822018-11-01 15:25:31 -0500686 DataManager::SetValue(TW_CRYPTO_PWTYPE, cryptfs_get_password_type());
Noah Jacobson81d638d2019-04-28 00:10:07 -0400687 DataManager::SetValue("tw_crypto_pwtype_0", cryptfs_get_password_type());
Ethan Yonker93382822018-11-01 15:25:31 -0500688 DataManager::SetValue(TW_CRYPTO_PASSWORD, "");
689 DataManager::SetValue("tw_crypto_display", "");
bigbiffcda15882021-12-30 17:01:44 -0500690 if (datamedia)
691 Setup_Data_Media();
Ethan Yonker93382822018-11-01 15:25:31 -0500692 } else {
693 gui_err("mount_data_footer=Could not mount /data and unable to find crypto footer.");
694 }
695 } else {
Matt Mower72c87ce2016-04-26 14:34:56 -0500696 Is_Encrypted = true;
697 Is_Decrypted = false;
bigbiffbee26852022-02-09 20:49:00 -0500698 if (datamedia)
699 Setup_Data_Media();
Matt Mower72c87ce2016-04-26 14:34:56 -0500700 }
Ethan Yonker93382822018-11-01 15:25:31 -0500701 } else if (Key_Directory.empty()) {
Noah Jacobson81d638d2019-04-28 00:10:07 -0400702 LOGERR("Primary block device '%s' for mount point '%s' is not present!\n",
703 Primary_Block_Device.c_str(), Mount_Point.c_str());
Matt Mower72c87ce2016-04-26 14:34:56 -0500704 }
705 } else {
bigbiff7ba75002020-04-11 20:47:09 -0400706 Set_FBE_Status();
Captain Throwbackacc7f0f2020-12-29 15:54:33 -0500707 int is_device_fbe;
708 DataManager::GetValue(TW_IS_FBE, is_device_fbe);
Captain Throwback8a8e56c2021-10-01 15:12:24 -0400709 char crypto_state[255];
710 property_get("ro.crypto.state", crypto_state, "error");
711 if (!Decrypt_FBE_DE() && strcmp(crypto_state, "error") != 0) {
712 if (is_device_fbe == 1)
713 LOGERR("Unable to decrypt FBE device\n");
714 } else {
715 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
bigbiffcda15882021-12-30 17:01:44 -0500716 if (datamedia)
717 Setup_Data_Media();
718
mauronofrio9bf73352019-11-23 22:27:34 +0100719 }
Matt Mower72c87ce2016-04-26 14:34:56 -0500720 }
721 if (datamedia && (!Is_Encrypted || (Is_Encrypted && Is_Decrypted))) {
722 Setup_Data_Media();
bigbiff25d25b92020-06-19 16:07:38 -0400723 Recreate_Media_Folder();
Matt Mower72c87ce2016-04-26 14:34:56 -0500724 }
725#else
726 if (datamedia) {
727 Setup_Data_Media();
728 Recreate_Media_Folder();
729 }
730#endif
731}
732
bigbiff7ba75002020-04-11 20:47:09 -0400733void TWPartition::Set_FBE_Status() {
734 DataManager::SetValue(TW_IS_DECRYPTED, 1);
735 Is_Encrypted = true;
736 Is_Decrypted = true;
bigbiff7ba75002020-04-11 20:47:09 -0400737 if (Key_Directory.empty()) {
738 Is_FBE = false;
739 DataManager::SetValue(TW_IS_FBE, 0);
740 } else {
Captain Throwbackb5af4f82020-12-29 16:01:10 -0500741 LOGINFO("Setup_Data_Partition::Key_Directory::%s\n", Key_Directory.c_str());
bigbiff7ba75002020-04-11 20:47:09 -0400742 Is_FBE = true;
743 DataManager::SetValue(TW_IS_FBE, 1);
744 }
745}
746
Ethan Yonker93382822018-11-01 15:25:31 -0500747bool TWPartition::Decrypt_FBE_DE() {
bigbiff7ba75002020-04-11 20:47:09 -0400748 if (TWFunc::Path_Exists("/data/unencrypted/key/version")) {
Captain Throwback87d73d62020-02-17 16:44:50 -0500749 DataManager::SetValue(TW_IS_FBE, 1);
Captain Throwback37c3aef2021-10-06 11:38:18 -0400750 PartitionManager.Set_Crypto_State();
751 PartitionManager.Set_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
micky3872ec1df42021-10-14 14:53:06 +0200767 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");
770 ExcludeAll(Mount_Point + "/per_boot"); // removed each boot by init
bigbiffa15d02f2021-06-29 20:04:54 -0400771 ExcludeAll(Mount_Point + "/gsi"); // cow devices
772
Noah Jacobson81d638d2019-04-28 00:10:07 -0400773 int retry_count = 3;
774 while (!Decrypt_DE() && --retry_count)
775 usleep(2000);
776 if (retry_count > 0) {
Captain Throwback37c3aef2021-10-06 11:38:18 -0400777 PartitionManager.Set_Crypto_State();
Noah Jacobson81d638d2019-04-28 00:10:07 -0400778 Is_Encrypted = true;
779 Is_Decrypted = false;
780 DataManager::SetValue(TW_IS_ENCRYPTED, 1);
781 string filename;
782 int pwd_type = Get_Password_Type(0, filename);
783 if (pwd_type < 0) {
784 LOGERR("This TWRP does not have synthetic password decrypt support\n");
785 pwd_type = 0; // default password
Ethan Yonker93382822018-11-01 15:25:31 -0500786 }
Noah Jacobson81d638d2019-04-28 00:10:07 -0400787 PartitionManager.Parse_Users(); // after load_all_de_keys() to parse_users
788 std::vector<users_struct>::iterator iter;
789 std::vector<users_struct>* userList = PartitionManager.Get_Users_List();
790 for (iter = userList->begin(); iter != userList->end(); iter++) {
791 if (atoi((*iter).userId.c_str()) != 0) {
792 ExcludeAll(Mount_Point + "/system_de/" + (*iter).userId + "/spblob");
793 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/gatekeeper.password.key");
794 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/gatekeeper.pattern.key");
795 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/locksettings.db");
796 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/locksettings.db-wal");
797 }
798 }
799 DataManager::SetValue(TW_CRYPTO_PWTYPE, pwd_type);
800 DataManager::SetValue("tw_crypto_pwtype_0", pwd_type);
801 DataManager::SetValue(TW_CRYPTO_PASSWORD, "");
802 DataManager::SetValue("tw_crypto_display", "");
803 return true;
804 }
Ethan Yonker93382822018-11-01 15:25:31 -0500805#else
806 LOGERR("FBE found but FBE support not present in TWRP\n");
807#endif
808 }
Captain Throwback87d73d62020-02-17 16:44:50 -0500809 DataManager::SetValue(TW_IS_FBE, 0);
Ethan Yonker93382822018-11-01 15:25:31 -0500810 return false;
811}
812
Matt Mower72c87ce2016-04-26 14:34:56 -0500813void TWPartition::Setup_Cache_Partition(bool Display_Error __unused) {
814 if (Mount_Point != "/cache")
815 return;
816
817 if (!Mount(true))
818 return;
819
820 if (!TWFunc::Path_Exists("/cache/recovery/.")) {
821 LOGINFO("Recreating /cache/recovery folder\n");
822 if (mkdir("/cache/recovery", S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP) != 0)
823 LOGERR("Could not create /cache/recovery\n");
824 }
825}
826
Matt Mower4ab42b12016-04-21 13:52:18 -0500827void TWPartition::Process_FS_Flags(const char *str) {
828 char *options = strdup(str);
829 char *ptr, *savep;
Hashcode62bd9e02013-11-19 21:59:42 -0800830
Matt Mower4ab42b12016-04-21 13:52:18 -0500831 Mount_Options = "";
Hashcode62bd9e02013-11-19 21:59:42 -0800832
Matt Mower4ab42b12016-04-21 13:52:18 -0500833 // Avoid issues with potentially nested strtok by using strtok_r
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600834 for (ptr = strtok_r(options, ",", &savep); ptr; ptr = strtok_r(NULL, ",", &savep)) {
835 char *equals = strstr(ptr, "=");
836 size_t name_len;
Matt Mower4ab42b12016-04-21 13:52:18 -0500837
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600838 if (!equals)
839 name_len = strlen(ptr);
840 else
841 name_len = equals - ptr;
842
843 // There are some flags that we want to ignore in TWRP
844 bool found_match = false;
845 for (const char** ignored_mount_item = ignored_mount_items; *ignored_mount_item; ignored_mount_item++) {
846 if (strncmp(ptr, *ignored_mount_item, name_len) == 0) {
847 found_match = true;
Hashcode62bd9e02013-11-19 21:59:42 -0800848 break;
849 }
850 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600851 if (found_match)
852 continue;
Hashcode62bd9e02013-11-19 21:59:42 -0800853
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600854 // mount_flags are never postfixed by '='
855 if (!equals) {
856 const struct flag_list* mount_flag = mount_flags;
857 for (; mount_flag->name; mount_flag++) {
858 if (strcmp(ptr, mount_flag->name) == 0) {
859 if (mount_flag->flag == MS_RDONLY)
860 Mount_Read_Only = true;
861 else
862 Mount_Flags |= (unsigned)mount_flag->flag;
863 found_match = true;
864 break;
865 }
866 }
867 if (found_match)
868 continue;
Matt Mower4ab42b12016-04-21 13:52:18 -0500869 }
870
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600871 // If we aren't ignoring this flag and it's not a mount flag, then it must be a mount option
872 if (!Mount_Options.empty())
873 Mount_Options += ",";
874 Mount_Options += ptr;
Matt Mower4ab42b12016-04-21 13:52:18 -0500875 }
876 free(options);
Hashcode62bd9e02013-11-19 21:59:42 -0800877}
878
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600879void TWPartition::Save_FS_Flags(const string& local_File_System, int local_Mount_Flags, const string& local_Mount_Options) {
880 partition_fs_flags_struct flags;
881 flags.File_System = local_File_System;
882 flags.Mount_Flags = local_Mount_Flags;
883 flags.Mount_Options = local_Mount_Options;
884 fs_flags.push_back(flags);
885}
886
Matt Mower2416a502016-04-12 19:54:46 -0500887void TWPartition::Apply_TW_Flag(const unsigned flag, const char* str, const bool val) {
888 switch (flag) {
889 case TWFLAG_ANDSEC:
890 Has_Android_Secure = val;
891 break;
892 case TWFLAG_BACKUP:
893 Can_Be_Backed_Up = val;
894 break;
895 case TWFLAG_BACKUPNAME:
896 Backup_Display_Name = str;
897 break;
898 case TWFLAG_BLOCKSIZE:
899 Format_Block_Size = (unsigned long)(atol(str));
900 break;
901 case TWFLAG_CANBEWIPED:
902 Can_Be_Wiped = val;
903 break;
904 case TWFLAG_CANENCRYPTBACKUP:
905 Can_Encrypt_Backup = val;
906 break;
907 case TWFLAG_DEFAULTS:
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600908 case TWFLAG_WAIT:
909 case TWFLAG_VERIFY:
910 case TWFLAG_CHECK:
911 case TWFLAG_NOTRIM:
912 case TWFLAG_VOLDMANAGED:
913 case TWFLAG_RESIZE:
Matt Mower2416a502016-04-12 19:54:46 -0500914 // Do nothing
915 break;
916 case TWFLAG_DISPLAY:
917 Display_Name = str;
918 break;
919 case TWFLAG_ENCRYPTABLE:
920 case TWFLAG_FORCEENCRYPT:
921 Crypto_Key_Location = str;
922 break;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500923 case TWFLAG_FILEENCRYPTION:
924 // This flag isn't used by TWRP but is needed in 9.0 FBE decrypt
925 // fileencryption=ice:aes-256-heh
926 {
927 std::string FBE = str;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500928 size_t colon_loc = FBE.find(":");
929 if (colon_loc == std::string::npos) {
Ethan Yonker93382822018-11-01 15:25:31 -0500930 property_set("fbe.contents", FBE.c_str());
931 property_set("fbe.filenames", "");
932 LOGINFO("FBE contents '%s', filenames ''\n", FBE.c_str());
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500933 break;
934 }
Ethan Yonker93382822018-11-01 15:25:31 -0500935 std::string FBE_contents, FBE_filenames;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500936 FBE_contents = FBE.substr(0, colon_loc);
937 FBE_filenames = FBE.substr(colon_loc + 1);
938 property_set("fbe.contents", FBE_contents.c_str());
939 property_set("fbe.filenames", FBE_filenames.c_str());
940 LOGINFO("FBE contents '%s', filenames '%s'\n", FBE_contents.c_str(), FBE_filenames.c_str());
941 }
942 break;
Captain Throwback32bcdcd2022-02-08 12:45:01 -0500943 case TWFLAG_METADATA_ENCRYPTION:
944 // This flag isn't used by TWRP but is needed for FBEv2 metadata decryption
945 // metadata_encryption=aes-256-xts:wrappedkey_v0
946 {
947 std::string META = str;
948 size_t colon_loc = META.find(":");
949 if (colon_loc == std::string::npos) {
950 property_set("metadata.contents", META.c_str());
951 property_set("metadata.filenames", "");
952 LOGINFO("Metadata contents '%s', filenames ''\n", META.c_str());
953 break;
954 }
955 std::string META_contents, META_filenames;
956 META_contents = META.substr(0, colon_loc);
957 META_filenames = META.substr(colon_loc + 1);
958 property_set("metadata.contents", META_contents.c_str());
959 property_set("metadata.filenames", META_filenames.c_str());
960 LOGINFO("Metadata contents '%s', filenames '%s'\n", META_contents.c_str(), META_filenames.c_str());
961 }
962 break;
Peter Cai28ea7b02019-05-24 11:38:54 +0800963 case TWFLAG_WRAPPEDKEY:
bigbiff437d86f2021-09-26 16:57:14 -0400964 // no more processing needed. leaving it here in case we want to do something in the future
Peter Cai28ea7b02019-05-24 11:38:54 +0800965 break;
Matt Mower2416a502016-04-12 19:54:46 -0500966 case TWFLAG_FLASHIMG:
967 Can_Flash_Img = val;
968 break;
969 case TWFLAG_FSFLAGS:
Matt Mower4ab42b12016-04-21 13:52:18 -0500970 Process_FS_Flags(str);
Matt Mower2416a502016-04-12 19:54:46 -0500971 break;
972 case TWFLAG_IGNOREBLKID:
973 Ignore_Blkid = val;
974 break;
975 case TWFLAG_LENGTH:
976 Length = atoi(str);
977 break;
978 case TWFLAG_MOUNTTODECRYPT:
979 Mount_To_Decrypt = val;
980 break;
Captain Throwbacke848afc2022-02-08 15:31:44 -0500981 case TWFLAG_QUOTA:
982 // Filesystem flag - TWRP does not need to process
983 break;
Matt Mower2416a502016-04-12 19:54:46 -0500984 case TWFLAG_REMOVABLE:
985 Removable = val;
986 break;
Matt Mower2416a502016-04-12 19:54:46 -0500987 case TWFLAG_SETTINGSSTORAGE:
988 Is_Settings_Storage = val;
989 if (Is_Settings_Storage)
990 Is_Storage = true;
991 break;
992 case TWFLAG_STORAGE:
993 Is_Storage = val;
994 break;
995 case TWFLAG_STORAGENAME:
996 Storage_Name = str;
997 break;
998 case TWFLAG_SUBPARTITIONOF:
999 Is_SubPartition = true;
1000 SubPartition_Of = str;
1001 break;
1002 case TWFLAG_SYMLINK:
1003 Symlink_Path = str;
1004 break;
1005 case TWFLAG_USERDATAENCRYPTBACKUP:
1006 Use_Userdata_Encryption = val;
1007 if (Use_Userdata_Encryption)
1008 Can_Encrypt_Backup = true;
1009 break;
1010 case TWFLAG_USERMRF:
1011 Use_Rm_Rf = val;
1012 break;
1013 case TWFLAG_WIPEDURINGFACTORYRESET:
1014 Wipe_During_Factory_Reset = val;
1015 if (Wipe_During_Factory_Reset) {
1016 Can_Be_Wiped = true;
1017 Wipe_Available_in_GUI = true;
1018 }
1019 break;
1020 case TWFLAG_WIPEINGUI:
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001021 case TWFLAG_FORMATTABLE:
Matt Mower2416a502016-04-12 19:54:46 -05001022 Wipe_Available_in_GUI = val;
1023 if (Wipe_Available_in_GUI)
1024 Can_Be_Wiped = true;
1025 break;
Ethan Yonker1b190162016-12-05 15:25:19 -06001026 case TWFLAG_SLOTSELECT:
1027 SlotSelect = true;
1028 break;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001029 case TWFLAG_ALTDEVICE:
1030 Alternate_Block_Device = str;
1031 break;
Peter Cai439d60c2019-10-17 08:49:10 +08001032 case TWFLAG_ADOPTED_MOUNT_DELAY:
1033 Adopted_Mount_Delay = atoi(str);
1034 break;
Ethan Yonker93382822018-11-01 15:25:31 -05001035 case TWFLAG_KEYDIRECTORY:
1036 Key_Directory = str;
bigbiffa957f072021-03-07 18:20:29 -05001037 LOGINFO("setting Key_Directory to: %s\n", Key_Directory.c_str());
bigbiffd58ba182020-03-23 10:02:29 -04001038 break;
Peter Caid68e6412019-11-02 19:22:38 +08001039 case TWFLAG_DM_USE_ORIGINAL_PATH:
1040 Use_Original_Path = true;
1041 break;
bigbiff998f8392021-08-06 19:19:33 -04001042 case TWFLAG_LOGICAL:
1043 Is_Super = true;
1044 break;
Matt Mower2416a502016-04-12 19:54:46 -05001045 default:
1046 // Should not get here
1047 LOGINFO("Flag identified for processing, but later unmatched: %i\n", flag);
1048 break;
1049 }
1050}
Dees_Troy51127312012-09-08 13:08:49 -04001051
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001052void TWPartition::Process_TW_Flags(char *flags, bool Display_Error, int fstab_ver) {
Matt Mower2416a502016-04-12 19:54:46 -05001053 char separator[2] = {'\n', 0};
1054 char *ptr, *savep;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001055 char source_separator = ';';
1056
1057 if (fstab_ver == 2)
1058 source_separator = ',';
Matt Mower2416a502016-04-12 19:54:46 -05001059
1060 // Semicolons within double-quotes are not forbidden, so replace
1061 // only the semicolons intended as separators with '\n' for strtok
1062 for (unsigned i = 0, skip = 0; i < strlen(flags); i++) {
1063 if (flags[i] == '\"')
Dees_Troya13d74f2013-03-24 08:54:55 -05001064 skip = !skip;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001065 if (!skip && flags[i] == source_separator)
Matt Mower2416a502016-04-12 19:54:46 -05001066 flags[i] = separator[0];
Dees_Troy51127312012-09-08 13:08:49 -04001067 }
1068
Matt Mower2416a502016-04-12 19:54:46 -05001069 // Avoid issues with potentially nested strtok by using strtok_r
1070 ptr = strtok_r(flags, separator, &savep);
1071 while (ptr) {
1072 int ptr_len = strlen(ptr);
1073 const struct flag_list* tw_flag = tw_flags;
Hashcode62bd9e02013-11-19 21:59:42 -08001074
Matt Mower2416a502016-04-12 19:54:46 -05001075 for (; tw_flag->name; tw_flag++) {
1076 int flag_len = strlen(tw_flag->name);
1077
1078 if (strncmp(ptr, tw_flag->name, flag_len) == 0) {
1079 bool flag_val = false;
1080
1081 if (ptr_len > flag_len && (tw_flag->name)[flag_len-1] != '='
1082 && ptr[flag_len] != '=') {
1083 // Handle flags with same starting string
1084 // (e.g. backup and backupname)
1085 continue;
1086 } else if (ptr_len > flag_len && ptr[flag_len] == '=') {
1087 // Handle flags with dual format: Part 1
1088 // (e.g. backup and backup=y. backup=y handled here)
1089 ptr += flag_len + 1;
1090 TWFunc::Strip_Quotes(ptr);
1091 // Skip flags with empty argument
1092 // (e.g. backup=)
1093 if (strlen(ptr) == 0) {
1094 LOGINFO("Flag missing argument or should not include '=': %s=\n", tw_flag->name);
1095 break;
1096 }
1097 flag_val = strchr("yY1", *ptr) != NULL;
1098 } else if (ptr_len == flag_len
1099 && (tw_flag->name)[flag_len-1] == '=') {
1100 // Skip flags missing argument after =
1101 // (e.g. backupname=)
1102 LOGINFO("Flag missing argument: %s\n", tw_flag->name);
1103 break;
1104 } else if (ptr_len > flag_len
1105 && (tw_flag->name)[flag_len-1] == '=') {
1106 // Handle arguments to flags
1107 // (e.g. backupname="My Stuff")
1108 ptr += flag_len;
1109 TWFunc::Strip_Quotes(ptr);
1110 // Skip flags with empty argument
1111 // (e.g. backupname="")
1112 if (strlen(ptr) == 0) {
1113 LOGINFO("Flag missing argument: %s\n", tw_flag->name);
1114 break;
1115 }
1116 } else if (ptr_len == flag_len) {
1117 // Handle flags with dual format: Part 2
1118 // (e.g. backup and backup=y. backup handled here)
1119 flag_val = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001120 } else {
Matt Mower2416a502016-04-12 19:54:46 -05001121 LOGINFO("Flag matched, but could not be processed: %s\n", ptr);
1122 break;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001123 }
Matt Mower2416a502016-04-12 19:54:46 -05001124
1125 Apply_TW_Flag(tw_flag->flag, ptr, flag_val);
1126 break;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001127 }
Matt Mower2416a502016-04-12 19:54:46 -05001128 }
1129 if (tw_flag->name == 0) {
Dees_Troy51127312012-09-08 13:08:49 -04001130 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001131 LOGERR("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -04001132 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001133 LOGINFO("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -04001134 }
Matt Mower2416a502016-04-12 19:54:46 -05001135 ptr = strtok_r(NULL, separator, &savep);
Dees_Troy51127312012-09-08 13:08:49 -04001136 }
Dees_Troy51a0e822012-09-05 15:24:24 -04001137}
1138
Dees_Troy5bf43922012-09-07 16:07:55 -04001139bool TWPartition::Is_File_System(string File_System) {
1140 if (File_System == "ext2" ||
Dees_Troy63c8df72012-09-10 14:02:05 -04001141 File_System == "ext3" ||
Dees_Troy5bf43922012-09-07 16:07:55 -04001142 File_System == "ext4" ||
1143 File_System == "vfat" ||
1144 File_System == "ntfs" ||
1145 File_System == "yaffs2" ||
bigbiff bigbiff3e146522012-11-14 14:32:59 -05001146 File_System == "exfat" ||
Dees_Troye5017042013-08-29 16:38:55 +00001147 File_System == "f2fs" ||
GarfieldHand0b854b2021-11-21 23:46:20 +08001148 File_System == "erofs" ||
Erfan Abdib859e912019-02-05 18:18:46 +02001149 File_System == "squashfs" ||
Dees_Troy5bf43922012-09-07 16:07:55 -04001150 File_System == "auto")
1151 return true;
1152 else
1153 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001154}
1155
Dees_Troy5bf43922012-09-07 16:07:55 -04001156bool TWPartition::Is_Image(string File_System) {
Dees_Troy5fcd8f92012-10-16 12:22:05 -04001157 if (File_System == "emmc" || File_System == "mtd" || File_System == "bml")
Dees_Troy5bf43922012-09-07 16:07:55 -04001158 return true;
1159 else
1160 return false;
1161}
1162
Dees_Troy51127312012-09-08 13:08:49 -04001163bool TWPartition::Make_Dir(string Path, bool Display_Error) {
Ethan Yonker93ac7a02016-11-07 22:05:58 -06001164 if (TWFunc::Get_D_Type_From_Stat(Path) != S_IFDIR)
1165 unlink(Path.c_str());
Dees_Troy43d8b002012-09-17 16:00:01 -04001166 if (!TWFunc::Path_Exists(Path)) {
Dees_Troy51127312012-09-08 13:08:49 -04001167 if (mkdir(Path.c_str(), 0777) == -1) {
1168 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001169 gui_msg(Msg(msg::kError, "create_folder_strerr=Can not create '{1}' folder ({2}).")(Path)(strerror(errno)));
Dees_Troy51127312012-09-08 13:08:49 -04001170 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001171 LOGINFO("Can not create '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001172 return false;
1173 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001174 LOGINFO("Created '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001175 return true;
1176 }
1177 }
1178 return true;
1179}
1180
Dees_Troy5bf43922012-09-07 16:07:55 -04001181void TWPartition::Setup_File_System(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001182 Can_Be_Mounted = true;
1183 Can_Be_Wiped = true;
1184
Dees_Troy5bf43922012-09-07 16:07:55 -04001185 // Make the mount point folder if it doesn't exist
Dees_Troy51127312012-09-08 13:08:49 -04001186 Make_Dir(Mount_Point, Display_Error);
bigbiffce8f83c2015-12-12 18:30:21 -05001187 Backup_Method = BM_FILES;
Dees_Troy5bf43922012-09-07 16:07:55 -04001188}
1189
Ethan Yonker1b190162016-12-05 15:25:19 -06001190void TWPartition::Setup_Image() {
Dees_Troy5bf43922012-09-07 16:07:55 -04001191 Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
1192 Backup_Name = Display_Name;
Gary Peck82599a82012-11-21 16:23:12 -08001193 if (Current_File_System == "emmc")
bigbiffce8f83c2015-12-12 18:30:21 -05001194 Backup_Method = BM_DD;
Gary Peck82599a82012-11-21 16:23:12 -08001195 else if (Current_File_System == "mtd" || Current_File_System == "bml")
bigbiffce8f83c2015-12-12 18:30:21 -05001196 Backup_Method = BM_FLASH_UTILS;
Dees_Troy5bf43922012-09-07 16:07:55 -04001197 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001198 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 -04001199}
1200
Dees_Troye58d5262012-09-21 12:27:57 -04001201void TWPartition::Setup_AndSec(void) {
Dees_Troya13d74f2013-03-24 08:54:55 -05001202 Backup_Display_Name = "Android Secure";
Dees_Troye58d5262012-09-21 12:27:57 -04001203 Backup_Name = "and-sec";
Dees_Troya13d74f2013-03-24 08:54:55 -05001204 Can_Be_Backed_Up = true;
Dees_Troye58d5262012-09-21 12:27:57 -04001205 Has_Android_Secure = true;
1206 Symlink_Path = Mount_Point + "/.android_secure";
1207 Symlink_Mount_Point = "/and-sec";
1208 Backup_Path = Symlink_Mount_Point;
1209 Make_Dir("/and-sec", true);
1210 Recreate_AndSec_Folder();
Kjell Braden3126a112016-06-19 16:58:15 +00001211 Mount_Storage_Retry(true);
Dees_Troye58d5262012-09-21 12:27:57 -04001212}
1213
that9e0593e2014-10-08 00:01:24 +02001214void TWPartition::Setup_Data_Media() {
Ethan Yonker6277c792014-09-15 14:54:30 -05001215 LOGINFO("Setting up '%s' as data/media emulated storage.\n", Mount_Point.c_str());
Ethan Yonker66a19492015-12-10 10:19:45 -06001216 if (Storage_Name.empty() || Storage_Name == "Data")
1217 Storage_Name = "Internal Storage";
Ethan Yonker6277c792014-09-15 14:54:30 -05001218 Has_Data_Media = true;
1219 Is_Storage = true;
Ethan Yonker66a19492015-12-10 10:19:45 -06001220 Storage_Path = Mount_Point + "/media";
Ethan Yonker6277c792014-09-15 14:54:30 -05001221 Symlink_Path = Storage_Path;
Ethan Yonker66a19492015-12-10 10:19:45 -06001222 if (Mount_Point == "/data") {
1223 Is_Settings_Storage = true;
1224 if (strcmp(EXPAND(TW_EXTERNAL_STORAGE_PATH), "/sdcard") == 0) {
1225 Make_Dir("/emmc", false);
1226 Symlink_Mount_Point = "/emmc";
1227 } else {
1228 Make_Dir("/sdcard", false);
1229 Symlink_Mount_Point = "/sdcard";
1230 }
bigbiffcda15882021-12-30 17:01:44 -05001231 Mount(false);
1232 if (TWFunc::Path_Exists(Mount_Point + "/media/0")) {
Ethan Yonker66a19492015-12-10 10:19:45 -06001233 Storage_Path = Mount_Point + "/media/0";
1234 Symlink_Path = Storage_Path;
1235 DataManager::SetValue(TW_INTERNAL_PATH, Mount_Point + "/media/0");
1236 UnMount(true);
1237 }
1238 DataManager::SetValue("tw_has_internal", 1);
1239 DataManager::SetValue("tw_has_data_media", 1);
Ethan Yonker3fdcda42016-11-30 12:29:37 -06001240 backup_exclusions.add_absolute_dir("/data/data/com.google.android.music/files");
bigbiff25d25b92020-06-19 16:07:38 -04001241 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 +01001242 backup_exclusions.add_absolute_dir("/data/vendor/dumpsys");
bigbiff25d25b92020-06-19 16:07:38 -04001243 backup_exclusions.add_absolute_dir("/data/cache");
nijel880c92d92022-01-14 10:01:32 -05001244 backup_exclusions.add_absolute_dir("/data/misc/apexdata/com.android.art"); // exclude this dir to prevent "error 255" on AOSP Android 12
Ethan Yonker6355b562017-05-01 09:42:17 -05001245 wipe_exclusions.add_absolute_dir(Mount_Point + "/misc/vold"); // adopted storage keys
Ethan Yonker79f88bd2016-12-09 14:52:12 -06001246 ExcludeAll(Mount_Point + "/system/storage.xml");
Ethan Yonker6277c792014-09-15 14:54:30 -05001247 } else {
nkk713c1e35f2017-03-24 18:28:03 +02001248 int i;
1249 string path;
1250 for (i = 2; i <= 9; i++) {
1251 path = "/sdcard" + TWFunc::to_string(i);
1252 if (!TWFunc::Path_Exists(path)) {
1253 Make_Dir(path, false);
1254 Symlink_Mount_Point = path;
1255 LOGINFO("'%s' data/media emulated storage symlinked to %s.\n", Mount_Point.c_str(), Symlink_Mount_Point.c_str());
1256 break;
1257 }
1258 }
Ethan Yonker66a19492015-12-10 10:19:45 -06001259 if (Mount(true) && TWFunc::Path_Exists(Mount_Point + "/media/0")) {
1260 Storage_Path = Mount_Point + "/media/0";
1261 Symlink_Path = Storage_Path;
1262 UnMount(true);
1263 }
Ethan Yonker6277c792014-09-15 14:54:30 -05001264 }
Ethan Yonker79f88bd2016-12-09 14:52:12 -06001265 ExcludeAll(Mount_Point + "/media");
Ethan Yonker6277c792014-09-15 14:54:30 -05001266}
1267
Dees_Troy5bf43922012-09-07 16:07:55 -04001268void TWPartition::Find_Real_Block_Device(string& Block, bool Display_Error) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001269 char device[PATH_MAX], realDevice[PATH_MAX];
Dees_Troy5bf43922012-09-07 16:07:55 -04001270
Peter Caid68e6412019-11-02 19:22:38 +08001271 Original_Path = Block;
1272
Dees_Troy5bf43922012-09-07 16:07:55 -04001273 strcpy(device, Block.c_str());
1274 memset(realDevice, 0, sizeof(realDevice));
1275 while (readlink(device, realDevice, sizeof(realDevice)) > 0)
1276 {
1277 strcpy(device, realDevice);
1278 memset(realDevice, 0, sizeof(realDevice));
1279 }
1280
bigbiff998f8392021-08-06 19:19:33 -04001281 Block = device;
1282 return;
Dees_Troy5bf43922012-09-07 16:07:55 -04001283}
1284
Kjell Braden3126a112016-06-19 16:58:15 +00001285bool TWPartition::Mount_Storage_Retry(bool Display_Error) {
Dees_Troy8e337f32012-10-13 22:07:49 -04001286 // On some devices, storage doesn't want to mount right away, retry and sleep
Kjell Braden3126a112016-06-19 16:58:15 +00001287 if (!Mount(Display_Error)) {
Dees_Troy8e337f32012-10-13 22:07:49 -04001288 int retry_count = 5;
1289 while (retry_count > 0 && !Mount(false)) {
1290 usleep(500000);
1291 retry_count--;
1292 }
Kjell Braden3126a112016-06-19 16:58:15 +00001293 return Mount(Display_Error);
Dees_Troy8e337f32012-10-13 22:07:49 -04001294 }
Kjell Braden3126a112016-06-19 16:58:15 +00001295 return true;
Dees_Troy8e337f32012-10-13 22:07:49 -04001296}
1297
Dees_Troy38bd7602012-09-14 13:33:53 -04001298bool TWPartition::Find_MTD_Block_Device(string MTD_Name) {
1299 FILE *fp = NULL;
1300 char line[255];
1301
1302 fp = fopen("/proc/mtd", "rt");
1303 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001304 LOGERR("Device does not support /proc/mtd\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001305 return false;
1306 }
1307
1308 while (fgets(line, sizeof(line), fp) != NULL)
1309 {
1310 char device[32], label[32];
1311 unsigned long size = 0;
Dees_Troy38bd7602012-09-14 13:33:53 -04001312 int deviceId;
1313
1314 sscanf(line, "%s %lx %*s %*c%s", device, &size, label);
1315
1316 // Skip header and blank lines
1317 if ((strcmp(device, "dev:") == 0) || (strlen(line) < 8))
1318 continue;
1319
1320 // Strip off the trailing " from the label
1321 label[strlen(label)-1] = '\0';
1322
1323 if (strcmp(label, MTD_Name.c_str()) == 0) {
1324 // We found our device
1325 // Strip off the trailing : from the device
1326 device[strlen(device)-1] = '\0';
1327 if (sscanf(device,"mtd%d", &deviceId) == 1) {
1328 sprintf(device, "/dev/block/mtdblock%d", deviceId);
1329 Primary_Block_Device = device;
Dees_Troy76543db2013-06-19 16:24:30 +00001330 fclose(fp);
1331 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -04001332 }
1333 }
1334 }
1335 fclose(fp);
1336
1337 return false;
1338}
1339
Dees_Troy51127312012-09-08 13:08:49 -04001340bool TWPartition::Get_Size_Via_statfs(bool Display_Error) {
1341 struct statfs st;
1342 string Local_Path = Mount_Point + "/.";
1343
1344 if (!Mount(Display_Error))
1345 return false;
1346
1347 if (statfs(Local_Path.c_str(), &st) != 0) {
1348 if (!Removable) {
1349 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001350 LOGERR("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001351 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001352 LOGINFO("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001353 }
1354 return false;
1355 }
1356 Size = (st.f_blocks * st.f_bsize);
1357 Used = ((st.f_blocks - st.f_bfree) * st.f_bsize);
1358 Free = (st.f_bfree * st.f_bsize);
1359 Backup_Size = Used;
1360 return true;
1361}
1362
1363bool TWPartition::Get_Size_Via_df(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001364 FILE* fp;
1365 char command[255], line[512];
1366 int include_block = 1;
1367 unsigned int min_len;
1368
1369 if (!Mount(Display_Error))
1370 return false;
1371
Dees_Troy38bd7602012-09-14 13:33:53 -04001372 min_len = Actual_Block_Device.size() + 2;
Dees_Troy51127312012-09-08 13:08:49 -04001373 sprintf(command, "df %s > /tmp/dfoutput.txt", Mount_Point.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001374 TWFunc::Exec_Cmd(command);
Dees_Troy51127312012-09-08 13:08:49 -04001375 fp = fopen("/tmp/dfoutput.txt", "rt");
1376 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001377 LOGINFO("Unable to open /tmp/dfoutput.txt.\n");
Dees_Troy5bf43922012-09-07 16:07:55 -04001378 return false;
Dees_Troy51127312012-09-08 13:08:49 -04001379 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001380
1381 while (fgets(line, sizeof(line), fp) != NULL)
1382 {
1383 unsigned long blocks, used, available;
1384 char device[64];
1385 char tmpString[64];
1386
1387 if (strncmp(line, "Filesystem", 10) == 0)
1388 continue;
1389 if (strlen(line) < min_len) {
1390 include_block = 0;
1391 continue;
1392 }
1393 if (include_block) {
1394 sscanf(line, "%s %lu %lu %lu", device, &blocks, &used, &available);
1395 } else {
1396 // The device block string is so long that the df information is on the next line
1397 int space_count = 0;
Dees_Troye58d5262012-09-21 12:27:57 -04001398 sprintf(tmpString, "/dev/block/%s", Actual_Block_Device.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001399 while (tmpString[space_count] == 32)
1400 space_count++;
1401 sscanf(line + space_count, "%lu %lu %lu", &blocks, &used, &available);
1402 }
1403
1404 // Adjust block size to byte size
1405 Size = blocks * 1024ULL;
1406 Used = used * 1024ULL;
1407 Free = available * 1024ULL;
1408 Backup_Size = Used;
1409 }
1410 fclose(fp);
1411 return true;
1412}
1413
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001414unsigned long long TWPartition::IOCTL_Get_Block_Size() {
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001415 Find_Actual_Block_Device();
Ethan Yonker483e9f42016-01-11 22:21:18 -06001416
1417 return TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001418}
1419
Dees_Troy5bf43922012-09-07 16:07:55 -04001420bool TWPartition::Find_Partition_Size(void) {
1421 FILE* fp;
1422 char line[512];
1423 string tmpdevice;
1424
igoriok87e3d932013-01-31 21:03:53 +02001425 fp = fopen("/proc/dumchar_info", "rt");
1426 if (fp != NULL) {
1427 while (fgets(line, sizeof(line), fp) != NULL)
1428 {
1429 char label[32], device[32];
1430 unsigned long size = 0;
1431
thatd43bf2d2014-09-21 23:13:02 +02001432 sscanf(line, "%s %lx %*x %*u %s", label, &size, device);
igoriok87e3d932013-01-31 21:03:53 +02001433
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05001434 // Skip header, annotation and blank lines
igoriok87e3d932013-01-31 21:03:53 +02001435 if ((strncmp(device, "/dev/", 5) != 0) || (strlen(line) < 8))
1436 continue;
1437
1438 tmpdevice = "/dev/";
1439 tmpdevice += label;
1440 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
1441 Size = size;
1442 fclose(fp);
1443 return true;
1444 }
1445 }
1446 }
1447
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001448 unsigned long long ioctl_size = IOCTL_Get_Block_Size();
1449 if (ioctl_size) {
1450 Size = ioctl_size;
1451 return true;
1452 }
1453
Dees_Troy5bf43922012-09-07 16:07:55 -04001454 // In this case, we'll first get the partitions we care about (with labels)
1455 fp = fopen("/proc/partitions", "rt");
1456 if (fp == NULL)
1457 return false;
1458
1459 while (fgets(line, sizeof(line), fp) != NULL)
1460 {
1461 unsigned long major, minor, blocks;
1462 char device[512];
Dees_Troy5bf43922012-09-07 16:07:55 -04001463
Dees_Troy63c8df72012-09-10 14:02:05 -04001464 if (strlen(line) < 7 || line[0] == 'm') continue;
Dees_Troy5bf43922012-09-07 16:07:55 -04001465 sscanf(line + 1, "%lu %lu %lu %s", &major, &minor, &blocks, device);
1466
1467 tmpdevice = "/dev/block/";
1468 tmpdevice += device;
Dees_Troy38bd7602012-09-14 13:33:53 -04001469 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001470 // Adjust block size to byte size
1471 Size = blocks * 1024ULL;
1472 fclose(fp);
1473 return true;
1474 }
1475 }
1476 fclose(fp);
1477 return false;
1478}
1479
Dees_Troy5bf43922012-09-07 16:07:55 -04001480bool TWPartition::Is_Mounted(void) {
1481 if (!Can_Be_Mounted)
1482 return false;
1483
1484 struct stat st1, st2;
1485 string test_path;
1486
1487 // Check to see if the mount point directory exists
1488 test_path = Mount_Point + "/.";
1489 if (stat(test_path.c_str(), &st1) != 0) return false;
1490
1491 // Check to see if the directory above the mount point exists
1492 test_path = Mount_Point + "/../.";
1493 if (stat(test_path.c_str(), &st2) != 0) return false;
1494
1495 // Compare the device IDs -- if they match then we're (probably) using tmpfs instead of an actual device
1496 int ret = (st1.st_dev != st2.st_dev) ? true : false;
Dees_Troy5bf43922012-09-07 16:07:55 -04001497 return ret;
1498}
1499
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05001500bool TWPartition::Is_File_System_Writable(void) {
1501 if (!Is_File_System(Current_File_System) || !Is_Mounted())
1502 return false;
1503
1504 string test_path = Mount_Point + "/.";
1505 return (access(test_path.c_str(), W_OK) == 0);
1506}
1507
Dees_Troy5bf43922012-09-07 16:07:55 -04001508bool TWPartition::Mount(bool Display_Error) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001509 int exfat_mounted = 0;
Martin Dünkelmann6d843782018-12-27 23:40:28 +01001510 unsigned int flags = Mount_Flags;
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001511
Dees_Troy5bf43922012-09-07 16:07:55 -04001512 if (Is_Mounted()) {
1513 return true;
1514 } else if (!Can_Be_Mounted) {
1515 return false;
1516 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001517
1518 Find_Actual_Block_Device();
1519
1520 // Check the current file system before mounting
1521 Check_FS_Type();
bigbiffad58e1b2020-07-06 20:24:34 -04001522 if (Current_File_System == "exfat" && TWFunc::Path_Exists("/system/bin/exfat-fuse")) {
1523 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 +00001524 LOGINFO("cmd: %s\n", cmd.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001525 string result;
bigbiffad58e1b2020-07-06 20:24:34 -04001526 if (TWFunc::Exec_Cmd(cmd, result, false) != 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001527 LOGINFO("exfat-fuse failed to mount with result '%s', trying vfat\n", result.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001528 Current_File_System = "vfat";
1529 } else {
1530#ifdef TW_NO_EXFAT_FUSE
1531 UnMount(false);
1532 // We'll let the kernel handle it but using exfat-fuse to detect if the file system is actually exfat
1533 // Some kernels let us mount vfat as exfat which doesn't work out too well
1534#else
1535 exfat_mounted = 1;
1536#endif
1537 }
1538 }
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001539
Captain Throwback47bf7202020-10-06 17:39:39 -04001540 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 -05001541 string cmd;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001542 string Ntfsmount_Binary = "";
1543
bigbiffad58e1b2020-07-06 20:24:34 -04001544 if (TWFunc::Path_Exists("/system/bin/ntfs-3g"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001545 Ntfsmount_Binary = "ntfs-3g";
bigbiffad58e1b2020-07-06 20:24:34 -04001546 else if (TWFunc::Path_Exists("/system/bin/mount.ntfs"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001547 Ntfsmount_Binary = "mount.ntfs";
1548
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001549 if (Mount_Read_Only)
bigbiffad58e1b2020-07-06 20:24:34 -04001550 cmd = "/system/bin/" + Ntfsmount_Binary + " -o ro " + Actual_Block_Device + " " + Mount_Point;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001551 else
bigbiffad58e1b2020-07-06 20:24:34 -04001552 cmd = "/system/bin/" + Ntfsmount_Binary + " " + Actual_Block_Device + " " + Mount_Point;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001553 LOGINFO("cmd: '%s'\n", cmd.c_str());
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001554
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001555 if (TWFunc::Exec_Cmd(cmd) == 0) {
1556 return true;
1557 } else {
1558 LOGINFO("ntfs-3g failed to mount, trying regular mount method.\n");
1559 }
Captain Throwback47bf7202020-10-06 17:39:39 -04001560 } else {
1561 if (Current_File_System == "ntfs" && TWFunc::Path_Exists("/sys/module/tntfs"))
1562 Current_File_System = "tntfs";
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001563 }
1564
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001565 if (Mount_Read_Only)
1566 flags |= MS_RDONLY;
1567
Dees_Troy22042032012-12-18 21:23:08 +00001568 if (Fstab_File_System == "yaffs2") {
1569 // mount an MTD partition as a YAFFS2 filesystem.
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001570 flags = MS_NOATIME | MS_NODEV | MS_NODIRATIME;
1571 if (Mount_Read_Only)
1572 flags |= MS_RDONLY;
Dees_Troy76543db2013-06-19 16:24:30 +00001573 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags, NULL) < 0) {
1574 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags | MS_RDONLY, NULL) < 0) {
1575 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001576 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy76543db2013-06-19 16:24:30 +00001577 else
1578 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
1579 return false;
1580 } else {
1581 LOGINFO("Mounted '%s' (MTD) as RO\n", Mount_Point.c_str());
1582 return true;
1583 }
1584 } else {
1585 struct stat st;
1586 string test_path = Mount_Point;
1587 if (stat(test_path.c_str(), &st) < 0) {
1588 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001589 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy76543db2013-06-19 16:24:30 +00001590 else
1591 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
1592 return false;
1593 }
1594 mode_t new_mode = st.st_mode | S_IXUSR | S_IXGRP | S_IXOTH;
1595 if (new_mode != st.st_mode) {
1596 LOGINFO("Fixing execute permissions for %s\n", Mount_Point.c_str());
1597 if (chmod(Mount_Point.c_str(), new_mode) < 0) {
1598 if (Display_Error)
1599 LOGERR("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
1600 else
1601 LOGINFO("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
1602 return false;
1603 }
1604 }
Dees_Troy22042032012-12-18 21:23:08 +00001605 return true;
Dees_Troy76543db2013-06-19 16:24:30 +00001606 }
thatc7572eb2015-03-31 18:55:30 +02001607 }
1608
1609 string mount_fs = Current_File_System;
1610 if (Current_File_System == "exfat" && TWFunc::Path_Exists("/sys/module/texfat"))
1611 mount_fs = "texfat";
1612
1613 if (!exfat_mounted &&
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001614 mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), mount_fs.c_str(), flags, Mount_Options.c_str()) != 0 &&
1615 mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), mount_fs.c_str(), flags, NULL) != 0) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001616#ifdef TW_NO_EXFAT_FUSE
1617 if (Current_File_System == "exfat") {
Dees_Troy2673cec2013-04-02 20:22:16 +00001618 LOGINFO("Mounting exfat failed, trying vfat...\n");
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001619 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), "vfat", 0, NULL) != 0) {
Dees_Troy85f44ed2013-01-09 18:42:36 +00001620 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001621 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy85f44ed2013-01-09 18:42:36 +00001622 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001623 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001624 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 +00001625 return false;
Dees_Troy85f44ed2013-01-09 18:42:36 +00001626 }
Dees_Troyb05ddee2013-01-28 20:24:50 +00001627 } else {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001628#endif
bigbiff bigbiff26774a02014-03-29 18:22:00 -04001629 if (!Removable && Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001630 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001631 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001632 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
1633 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 +00001634 return false;
1635#ifdef TW_NO_EXFAT_FUSE
Dees_Troy85f44ed2013-01-09 18:42:36 +00001636 }
1637#endif
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001638 }
Ethan Yonker253368a2014-11-25 15:00:52 -06001639
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001640 if (Removable)
1641 Update_Size(Display_Error);
1642
bigbiffcda15882021-12-30 17:01:44 -05001643 if (!Symlink_Mount_Point.empty()) {
bigbiffbe4f46c2021-04-24 11:48:54 -04001644 if (!Bind_Mount(false))
1645 return false;
1646 }
1647 return true;
1648}
1649
1650bool TWPartition::Bind_Mount(bool Display_Error) {
1651 if (TWFunc::Path_Exists(Symlink_Path)) {
1652 if (mount(Symlink_Path.c_str(), Symlink_Mount_Point.c_str(), "", MS_BIND, NULL) < 0) {
1653 return false;
1654 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001655 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001656 return true;
1657}
1658
1659bool TWPartition::UnMount(bool Display_Error) {
1660 if (Is_Mounted()) {
1661 int never_unmount_system;
1662
1663 DataManager::GetValue(TW_DONT_UNMOUNT_SYSTEM, never_unmount_system);
Captain Throwback9d6feb52018-07-27 10:05:24 -04001664 if (never_unmount_system == 1 && Mount_Point == PartitionManager.Get_Android_Root_Path())
Dees_Troy5bf43922012-09-07 16:07:55 -04001665 return true; // Never unmount system if you're not supposed to unmount it
1666
Matt Mowera8e6d832017-02-14 20:20:59 -06001667 if (Is_Storage && MTP_Storage_ID > 0)
Ethan Yonker726a0202014-12-16 20:01:38 -06001668 PartitionManager.Remove_MTP_Storage(MTP_Storage_ID);
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001669
Dees_Troy38bd7602012-09-14 13:33:53 -04001670 if (!Symlink_Mount_Point.empty())
1671 umount(Symlink_Mount_Point.c_str());
1672
Dees_Troyb05ddee2013-01-28 20:24:50 +00001673 umount(Mount_Point.c_str());
1674 if (Is_Mounted()) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001675 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001676 gui_msg(Msg(msg::kError, "fail_unmount=Failed to unmount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy5bf43922012-09-07 16:07:55 -04001677 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001678 LOGINFO("Unable to unmount '%s'\n", Mount_Point.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001679 return false;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001680 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -04001681 return true;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001682 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001683 } else {
1684 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001685 }
1686}
1687
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05001688bool TWPartition::ReMount(bool Display_Error) {
1689 if (UnMount(Display_Error))
1690 return Mount(Display_Error);
1691 return false;
1692}
1693
1694bool TWPartition::ReMount_RW(bool Display_Error) {
1695 // No need to remount if already mounted rw
1696 if (Is_File_System_Writable())
1697 return true;
1698
1699 bool ro = Mount_Read_Only;
1700 int flags = Mount_Flags;
1701
1702 Mount_Read_Only = false;
1703 Mount_Flags &= ~MS_RDONLY;
1704
1705 bool ret = ReMount(Display_Error);
1706
1707 Mount_Read_Only = ro;
1708 Mount_Flags = flags;
1709
1710 return ret;
1711}
1712
Gary Peck43acadf2012-11-21 21:19:01 -08001713bool TWPartition::Wipe(string New_File_System) {
Ethan Yonker726a0202014-12-16 20:01:38 -06001714 bool wiped = false, update_crypt = false, recreate_media = true;
Dees_Troy16c2b312013-01-15 16:51:18 +00001715 int check;
Dees_Troy16c2b312013-01-15 16:51:18 +00001716
Dees_Troy38bd7602012-09-14 13:33:53 -04001717 if (!Can_Be_Wiped) {
Matt Mower3c366972015-12-25 19:28:31 -06001718 gui_msg(Msg(msg::kError, "cannot_wipe=Partition {1} cannot be wiped.")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04001719 return false;
1720 }
1721
Dees_Troyc51f1f92012-09-20 15:32:13 -04001722 if (Mount_Point == "/cache")
Dees_Troy2673cec2013-04-02 20:22:16 +00001723 Log_Offset = 0;
Dees_Troyc51f1f92012-09-20 15:32:13 -04001724
bigbiff4a60bee2021-01-23 14:08:03 -05001725 if (Mount_Point == PartitionManager.Get_Android_Root_Path()) {
1726 if (tw_get_default_metadata(PartitionManager.Get_Android_Root_Path().c_str()) != 0) {
1727 gui_msg(Msg(msg::kWarning, "restore_system_context=Unable to get default context for {1} -- Android may not boot.")(PartitionManager.Get_Android_Root_Path()));
1728 }
1729 }
1730
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001731 if (Has_Data_Media && Current_File_System == New_File_System) {
Dees_Troy16c2b312013-01-15 16:51:18 +00001732 wiped = Wipe_Data_Without_Wiping_Media();
bigbiff25d25b92020-06-19 16:07:38 -04001733 if (Mount_Point == "/data" && TWFunc::get_log_dir() == DATA_LOGS_DIR) {
1734 bool created = PartitionManager.Recreate_Logs_Dir();
1735 if (!created)
1736 LOGERR("Unable to create log directory for TWRP\n");
bigbiff7ba75002020-04-11 20:47:09 -04001737 }
Ethan Yonker5eac2222014-06-11 12:22:55 -05001738 recreate_media = false;
Dees_Troy16c2b312013-01-15 16:51:18 +00001739 } else {
Dees_Troy16c2b312013-01-15 16:51:18 +00001740 DataManager::GetValue(TW_RM_RF_VAR, check);
Hashcodedabfd492013-08-29 22:45:30 -07001741 if (check || Use_Rm_Rf)
Dees_Troy16c2b312013-01-15 16:51:18 +00001742 wiped = Wipe_RMRF();
1743 else if (New_File_System == "ext4")
1744 wiped = Wipe_EXT4();
1745 else if (New_File_System == "ext2" || New_File_System == "ext3")
dianlujitao4879b372018-12-03 18:45:47 +08001746 wiped = Wipe_EXTFS(New_File_System);
Dees_Troy16c2b312013-01-15 16:51:18 +00001747 else if (New_File_System == "exfat")
1748 wiped = Wipe_EXFAT();
Captain Throwback47bf7202020-10-06 17:39:39 -04001749 else if (New_File_System == "ntfs" || Current_File_System == "tntfs")
1750 wiped = Wipe_NTFS();
Dees_Troy16c2b312013-01-15 16:51:18 +00001751 else if (New_File_System == "yaffs2")
1752 wiped = Wipe_MTD();
Dees_Troye5017042013-08-29 16:38:55 +00001753 else if (New_File_System == "f2fs")
1754 wiped = Wipe_F2FS();
Captain Throwback47bf7202020-10-06 17:39:39 -04001755 else if (New_File_System == "vfat")
1756 wiped = Wipe_FAT();
Dees_Troy16c2b312013-01-15 16:51:18 +00001757 else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001758 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 +00001759 return false;
1760 }
1761 update_crypt = wiped;
bigbiff7ba75002020-04-11 20:47:09 -04001762 update_crypt = false;
Gary Pecke8bc5d72012-12-21 06:45:25 -08001763 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001764
Gary Pecke8bc5d72012-12-21 06:45:25 -08001765 if (wiped) {
Mohd Faraze1d72622020-06-15 00:28:32 +05301766 if (Mount_Point == "/cache" && TWFunc::get_log_dir() != DATA_LOGS_DIR)
1767 DataManager::Output_Version();
1768
bigbiff4a60bee2021-01-23 14:08:03 -05001769 if (Mount_Point == PartitionManager.Get_Android_Root_Path()) {
1770 tw_set_default_metadata(PartitionManager.Get_Android_Root_Path().c_str());
1771 }
Dees_Troy16c2b312013-01-15 16:51:18 +00001772 if (update_crypt) {
1773 Setup_File_System(false);
1774 if (Is_Encrypted && !Is_Decrypted) {
1775 // just wiped an encrypted partition back to its unencrypted state
1776 Is_Encrypted = false;
1777 Is_Decrypted = false;
1778 Decrypted_Block_Device = "";
1779 if (Mount_Point == "/data") {
1780 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
1781 DataManager::SetValue(TW_IS_DECRYPTED, 0);
1782 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08001783 }
1784 }
Ethan Yonker5eac2222014-06-11 12:22:55 -05001785
Captain Throwback63573b52021-10-02 20:47:33 -04001786 if (Is_Storage && Mount(false) && !Is_FBE)
bigbiffbe4f46c2021-04-24 11:48:54 -04001787 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
Gary Pecke8bc5d72012-12-21 06:45:25 -08001788 }
Matt Mower209c9632016-01-20 12:08:35 -06001789
Gary Pecke8bc5d72012-12-21 06:45:25 -08001790 return wiped;
Dees_Troy51a0e822012-09-05 15:24:24 -04001791}
1792
Gary Peck43acadf2012-11-21 21:19:01 -08001793bool TWPartition::Wipe() {
Gary Peck82599a82012-11-21 16:23:12 -08001794 if (Is_File_System(Current_File_System))
1795 return Wipe(Current_File_System);
1796 else
1797 return Wipe(Fstab_File_System);
Gary Peck43acadf2012-11-21 21:19:01 -08001798}
1799
Dees_Troye58d5262012-09-21 12:27:57 -04001800bool TWPartition::Wipe_AndSec(void) {
1801 if (!Has_Android_Secure)
1802 return false;
1803
Dees_Troye58d5262012-09-21 12:27:57 -04001804 if (!Mount(true))
1805 return false;
1806
Ethan Yonker74db1572015-10-28 12:44:49 -05001807 gui_msg(Msg("wiping=Wiping {1}")(Backup_Display_Name));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001808 TWFunc::removeDir(Mount_Point + "/.android_secure/", true);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001809 return true;
Dees_Troye58d5262012-09-21 12:27:57 -04001810}
1811
bigbiffaed1bdf2021-08-03 18:21:39 -04001812bool TWPartition::Wipe_Data_Cache(void) {
1813 if (!Mount(true))
1814 return false;
1815 gui_msg(Msg("wiping=Wiping {1}")(Mount_Point + "/cache/"));
1816 TWFunc::removeDir(Mount_Point + "/cache/", true);
1817 return true;
1818}
1819
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001820bool TWPartition::Can_Repair() {
Ethan Yonkera2719152015-05-28 09:44:41 -05001821 if (Mount_Read_Only)
1822 return false;
bigbiffad58e1b2020-07-06 20:24:34 -04001823 if (Current_File_System == "vfat" && TWFunc::Path_Exists("/system/bin/fsck.fat"))
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001824 return true;
bigbiffad58e1b2020-07-06 20:24:34 -04001825 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 -05001826 return true;
bigbiffad58e1b2020-07-06 20:24:34 -04001827 else if (Current_File_System == "exfat" && TWFunc::Path_Exists("/system/bin/fsck.exfat"))
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001828 return true;
bigbiffad58e1b2020-07-06 20:24:34 -04001829 else if (Current_File_System == "f2fs" && TWFunc::Path_Exists("/system/bin/fsck.f2fs"))
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001830 return true;
Captain Throwback47bf7202020-10-06 17:39:39 -04001831 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 -05001832 return true;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001833 return false;
1834}
1835
1836bool TWPartition::Repair() {
1837 string command;
1838
1839 if (Current_File_System == "vfat") {
bigbiffad58e1b2020-07-06 20:24:34 -04001840 if (!TWFunc::Path_Exists("/system/bin/fsck.fat")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001841 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.fat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001842 return false;
1843 }
1844 if (!UnMount(true))
1845 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001846 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.fat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001847 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001848 command = "/system/bin/fsck.fat -y " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001849 LOGINFO("Repair command: %s\n", command.c_str());
1850 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001851 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001852 return true;
1853 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001854 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001855 return false;
1856 }
1857 }
1858 if (Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") {
bigbiffad58e1b2020-07-06 20:24:34 -04001859 if (!TWFunc::Path_Exists("/system/bin/e2fsck")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001860 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("e2fsck"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001861 return false;
1862 }
1863 if (!UnMount(true))
1864 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001865 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("e2fsck"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001866 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001867 command = "/system/bin/e2fsck -fp " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001868 LOGINFO("Repair command: %s\n", command.c_str());
1869 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001870 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001871 return true;
1872 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001873 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001874 return false;
1875 }
1876 }
1877 if (Current_File_System == "exfat") {
bigbiffad58e1b2020-07-06 20:24:34 -04001878 if (!TWFunc::Path_Exists("/system/bin/fsck.exfat")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001879 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.exfat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001880 return false;
1881 }
1882 if (!UnMount(true))
1883 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001884 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.exfat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001885 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001886 command = "/system/bin/fsck.exfat " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001887 LOGINFO("Repair command: %s\n", command.c_str());
1888 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001889 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001890 return true;
1891 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001892 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001893 return false;
1894 }
1895 }
1896 if (Current_File_System == "f2fs") {
bigbiffad58e1b2020-07-06 20:24:34 -04001897 if (!TWFunc::Path_Exists("/system/bin/fsck.f2fs")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001898 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.f2fs"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001899 return false;
1900 }
1901 if (!UnMount(true))
1902 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001903 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.f2fs"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001904 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001905 command = "/system/bin/fsck.f2fs " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001906 LOGINFO("Repair command: %s\n", command.c_str());
1907 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001908 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001909 return true;
1910 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001911 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001912 return false;
1913 }
1914 }
Captain Throwback47bf7202020-10-06 17:39:39 -04001915 if (Current_File_System == "ntfs" || Current_File_System == "tntfs") {
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001916 string Ntfsfix_Binary;
bigbiffad58e1b2020-07-06 20:24:34 -04001917 if (TWFunc::Path_Exists("/system/bin/ntfsfix"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001918 Ntfsfix_Binary = "ntfsfix";
bigbiffad58e1b2020-07-06 20:24:34 -04001919 else if (TWFunc::Path_Exists("/system/bin/fsck.ntfs"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001920 Ntfsfix_Binary = "fsck.ntfs";
1921 else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001922 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("ntfsfix"));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001923 return false;
1924 }
1925 if (!UnMount(true))
1926 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001927 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)(Ntfsfix_Binary));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001928 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001929 command = "/system/bin/" + Ntfsfix_Binary + " " + Actual_Block_Device;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001930 LOGINFO("Repair command: %s\n", command.c_str());
1931 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001932 gui_msg("done=Done.");
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001933 return true;
1934 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001935 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001936 return false;
1937 }
1938 }
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001939 return false;
1940}
1941
Ethan Yonkera2719152015-05-28 09:44:41 -05001942bool TWPartition::Can_Resize() {
1943 if (Mount_Read_Only)
1944 return false;
bigbiffad58e1b2020-07-06 20:24:34 -04001945 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 -05001946 return true;
1947 return false;
1948}
1949
1950bool TWPartition::Resize() {
1951 string command;
1952
1953 if (Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") {
1954 if (!Can_Repair()) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001955 LOGINFO("Cannot resize %s because %s cannot be repaired before resizing.\n", Display_Name.c_str(), Display_Name.c_str());
1956 gui_msg(Msg(msg::kError, "cannot_resize=Cannot resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001957 return false;
1958 }
bigbiffad58e1b2020-07-06 20:24:34 -04001959 if (!TWFunc::Path_Exists("/system/bin/resize2fs")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001960 LOGINFO("resize2fs does not exist! Cannot resize!\n");
1961 gui_msg(Msg(msg::kError, "cannot_resize=Cannot resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001962 return false;
1963 }
1964 // Repair will unmount so no need to do it twice
Ethan Yonker74db1572015-10-28 12:44:49 -05001965 gui_msg(Msg("repair_resize=Repairing {1} before resizing.")( Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001966 if (!Repair())
1967 return false;
Ethan Yonker74db1572015-10-28 12:44:49 -05001968 gui_msg(Msg("resizing=Resizing {1} using {2}...")(Display_Name)("resize2fs"));
Ethan Yonkera2719152015-05-28 09:44:41 -05001969 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001970 command = "/system/bin/resize2fs " + Actual_Block_Device;
Ethan Yonkera2719152015-05-28 09:44:41 -05001971 if (Length != 0) {
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001972 unsigned long long Actual_Size = IOCTL_Get_Block_Size();
1973 if (Actual_Size == 0)
1974 return false;
Ethan Yonkera2719152015-05-28 09:44:41 -05001975
Ethan Yonkera2719152015-05-28 09:44:41 -05001976 unsigned long long Block_Count;
1977 if (Length < 0) {
1978 // Reduce overall size by this length
1979 Block_Count = (Actual_Size / 1024LLU) - ((unsigned long long)(Length * -1) / 1024LLU);
1980 } else {
1981 // This is the size, not a size reduction
1982 Block_Count = ((unsigned long long)(Length) / 1024LLU);
1983 }
1984 char temp[256];
1985 sprintf(temp, "%llu", Block_Count);
1986 command += " ";
1987 command += temp;
1988 command += "K";
1989 }
1990 LOGINFO("Resize command: %s\n", command.c_str());
1991 if (TWFunc::Exec_Cmd(command) == 0) {
1992 Update_Size(true);
Ethan Yonker74db1572015-10-28 12:44:49 -05001993 gui_msg("done=Done.");
Ethan Yonkera2719152015-05-28 09:44:41 -05001994 return true;
1995 } else {
1996 Update_Size(true);
Ethan Yonker74db1572015-10-28 12:44:49 -05001997 gui_msg(Msg(msg::kError, "unable_resize=Unable to resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001998 return false;
1999 }
2000 }
2001 return false;
2002}
2003
bigbiffce8f83c2015-12-12 18:30:21 -05002004bool TWPartition::Backup(PartitionSettings *part_settings, pid_t *tar_fork_pid) {
2005 if (Backup_Method == BM_FILES)
2006 return Backup_Tar(part_settings, tar_fork_pid);
2007 else if (Backup_Method == BM_DD)
2008 return Backup_Image(part_settings);
2009 else if (Backup_Method == BM_FLASH_UTILS)
2010 return Backup_Dump_Image(part_settings);
Dees_Troy2673cec2013-04-02 20:22:16 +00002011 LOGERR("Unknown backup method for '%s'\n", Mount_Point.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04002012 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04002013}
2014
bigbiffce8f83c2015-12-12 18:30:21 -05002015bool TWPartition::Restore(PartitionSettings *part_settings) {
Matt Mower3c366972015-12-25 19:28:31 -06002016 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Display_Name, gui_parse_text("{@restoring_hdr}"));
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002017 LOGINFO("Restore filename is: %s/%s\n", part_settings->Backup_Folder.c_str(), Backup_FileName.c_str());
Gary Peck43acadf2012-11-21 21:19:01 -08002018
bigbiffce8f83c2015-12-12 18:30:21 -05002019 string Restore_File_System = Get_Restore_File_System(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002020
2021 if (Is_File_System(Restore_File_System))
bigbiffce8f83c2015-12-12 18:30:21 -05002022 return Restore_Tar(part_settings);
2023 else if (Is_Image(Restore_File_System))
2024 return Restore_Image(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002025
2026 LOGERR("Unknown restore method for '%s'\n", Mount_Point.c_str());
2027 return false;
2028}
2029
bigbiffce8f83c2015-12-12 18:30:21 -05002030string TWPartition::Get_Restore_File_System(PartitionSettings *part_settings) {
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002031 size_t first_period, second_period;
2032 string Restore_File_System;
2033
Gary Peck43acadf2012-11-21 21:19:01 -08002034 // Parse backup filename to extract the file system before wiping
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002035 first_period = Backup_FileName.find(".");
Gary Peck43acadf2012-11-21 21:19:01 -08002036 if (first_period == string::npos) {
Dees_Troy2673cec2013-04-02 20:22:16 +00002037 LOGERR("Unable to find file system (first period).\n");
thatd43bf2d2014-09-21 23:13:02 +02002038 return string();
Gary Peck43acadf2012-11-21 21:19:01 -08002039 }
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002040 Restore_File_System = Backup_FileName.substr(first_period + 1, Backup_FileName.size() - first_period - 1);
Gary Peck43acadf2012-11-21 21:19:01 -08002041 second_period = Restore_File_System.find(".");
2042 if (second_period == string::npos) {
Dees_Troy2673cec2013-04-02 20:22:16 +00002043 LOGERR("Unable to find file system (second period).\n");
thatd43bf2d2014-09-21 23:13:02 +02002044 return string();
Gary Peck43acadf2012-11-21 21:19:01 -08002045 }
2046 Restore_File_System.resize(second_period);
Matt Mowera0cd91d2016-12-30 18:21:42 -06002047 LOGINFO("Restore file system is: '%s'.\n", Restore_File_System.c_str());
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002048 return Restore_File_System;
Dees_Troy51a0e822012-09-05 15:24:24 -04002049}
2050
2051string TWPartition::Backup_Method_By_Name() {
bigbiffce8f83c2015-12-12 18:30:21 -05002052 if (Backup_Method == BM_NONE)
Dees_Troy38bd7602012-09-14 13:33:53 -04002053 return "none";
bigbiffce8f83c2015-12-12 18:30:21 -05002054 else if (Backup_Method == BM_FILES)
Dees_Troy38bd7602012-09-14 13:33:53 -04002055 return "files";
bigbiffce8f83c2015-12-12 18:30:21 -05002056 else if (Backup_Method == BM_DD)
Dees_Troy38bd7602012-09-14 13:33:53 -04002057 return "dd";
bigbiffce8f83c2015-12-12 18:30:21 -05002058 else if (Backup_Method == BM_FLASH_UTILS)
Dees_Troy38bd7602012-09-14 13:33:53 -04002059 return "flash_utils";
2060 else
2061 return "undefined";
2062 return "ERROR!";
Dees_Troy51a0e822012-09-05 15:24:24 -04002063}
2064
2065bool TWPartition::Decrypt(string Password) {
Dees_Troy2673cec2013-04-02 20:22:16 +00002066 LOGINFO("STUB TWPartition::Decrypt, password: '%s'\n", Password.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04002067 // Is this needed?
Dees_Troy51a0e822012-09-05 15:24:24 -04002068 return 1;
2069}
2070
2071bool TWPartition::Wipe_Encryption() {
Dees_Troy38bd7602012-09-14 13:33:53 -04002072 bool Save_Data_Media = Has_Data_Media;
Ethan Yonker93382822018-11-01 15:25:31 -05002073 bool ret = false;
2074 BasePartition* base_partition = make_partition();
2075
2076 if (!base_partition->PreWipeEncryption())
2077 goto exit;
Dees_Troy38bd7602012-09-14 13:33:53 -04002078
dianlujitao4879b372018-12-03 18:45:47 +08002079 Find_Actual_Block_Device();
2080 if (!Is_Present) {
2081 LOGINFO("Block device not present, cannot format %s.\n", Display_Name.c_str());
2082 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2083 return false;
2084 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002085
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06002086#ifdef TW_INCLUDE_CRYPTO
bigbiff7ba75002020-04-11 20:47:09 -04002087 if (!UnMount(true))
2088 return false;
Ethan Yonker1b190162016-12-05 15:25:19 -06002089 if (Is_Decrypted && !Decrypted_Block_Device.empty()) {
Matt Mower2b18a532015-02-20 16:58:05 -06002090 if (delete_crypto_blk_dev((char*)("userdata")) != 0) {
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06002091 LOGERR("Error deleting crypto block device, continuing anyway.\n");
2092 }
2093 }
2094#endif
dianlujitao4879b372018-12-03 18:45:47 +08002095 Has_Data_Media = false;
Ethan Yonker93382822018-11-01 15:25:31 -05002096 Decrypted_Block_Device = "";
Dees_Troy74fb2e92013-04-15 14:35:47 +00002097 Is_Decrypted = false;
2098 Is_Encrypted = false;
Gary Pecke8bc5d72012-12-21 06:45:25 -08002099 if (Wipe(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002100 Has_Data_Media = Save_Data_Media;
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06002101 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
Ethan Yonker83e82572014-04-04 10:59:28 -05002102#ifndef TW_OEM_BUILD
bigbiff25d25b92020-06-19 16:07:38 -04002103 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 -05002104#endif
bigbiff2d548672021-07-09 20:08:44 -04002105 if (Is_FBE) {
2106 gui_msg(Msg(msg::kWarning, "data_media_fbe_msg=TWRP will not recreate /data/media on an FBE device. Please reboot into your rom to create /data/media."));
Captain Throwback63573b52021-10-02 20:47:33 -04002107 } else {
2108 if (Has_Data_Media && !Symlink_Mount_Point.empty()) {
2109 if (Mount(false))
2110 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
2111 }
bigbiff2d548672021-07-09 20:08:44 -04002112 }
2113
Ethan Yonker93382822018-11-01 15:25:31 -05002114 ret = true;
2115 if (!Key_Directory.empty())
2116 ret = PartitionManager.Wipe_By_Path(Key_Directory);
2117 if (ret)
2118 ret = base_partition->PostWipeEncryption();
2119 goto exit;
Dees_Troy38bd7602012-09-14 13:33:53 -04002120 } else {
2121 Has_Data_Media = Save_Data_Media;
Ethan Yonker74db1572015-10-28 12:44:49 -05002122 gui_err("format_data_err=Unable to format to remove encryption.");
Ethan Yonker726a0202014-12-16 20:01:38 -06002123 if (Has_Data_Media && Mount(false))
2124 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
Ethan Yonker93382822018-11-01 15:25:31 -05002125 goto exit;
Dees_Troy38bd7602012-09-14 13:33:53 -04002126 }
Ethan Yonker93382822018-11-01 15:25:31 -05002127exit:
2128 delete base_partition;
2129 return ret;
Dees_Troy51a0e822012-09-05 15:24:24 -04002130}
2131
2132void TWPartition::Check_FS_Type() {
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002133 const char* type;
2134 blkid_probe pr;
Dees_Troy5bf43922012-09-07 16:07:55 -04002135
Dees_Troy68cab492012-12-12 19:29:35 +00002136 if (Fstab_File_System == "yaffs2" || Fstab_File_System == "mtd" || Fstab_File_System == "bml" || Ignore_Blkid)
2137 return; // Running blkid on some mtd devices causes a massive crash or needs to be skipped
Dees_Troy5bf43922012-09-07 16:07:55 -04002138
Dees_Troy38bd7602012-09-14 13:33:53 -04002139 Find_Actual_Block_Device();
Dees_Troy8170a922012-09-18 15:40:25 -04002140 if (!Is_Present)
2141 return;
Dees_Troy51127312012-09-08 13:08:49 -04002142
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002143 pr = blkid_new_probe_from_filename(Actual_Block_Device.c_str());
2144 if (blkid_do_fullprobe(pr)) {
2145 blkid_free_probe(pr);
Dees_Troy2673cec2013-04-02 20:22:16 +00002146 LOGINFO("Can't probe device %s\n", Actual_Block_Device.c_str());
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002147 return;
Dees_Troy5bf43922012-09-07 16:07:55 -04002148 }
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02002149
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05002150 if (blkid_probe_lookup_value(pr, "TYPE", &type, NULL) < 0) {
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002151 blkid_free_probe(pr);
Dees_Troy2673cec2013-04-02 20:22:16 +00002152 LOGINFO("can't find filesystem on device %s\n", Actual_Block_Device.c_str());
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002153 return;
2154 }
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02002155
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002156 Current_File_System = type;
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02002157 blkid_free_probe(pr);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002158 if (fs_flags.size() > 1) {
2159 std::vector<partition_fs_flags_struct>::iterator iter;
2160 std::vector<partition_fs_flags_struct>::iterator found = fs_flags.begin();
2161
2162 for (iter = fs_flags.begin(); iter != fs_flags.end(); iter++) {
2163 if (iter->File_System == Current_File_System) {
2164 found = iter;
2165 break;
2166 }
2167 }
2168 // If we don't find a match, we default the flags to the first set of flags that we received from the fstab
2169 if (Mount_Flags != found->Mount_Flags || Mount_Options != found->Mount_Options) {
2170 Mount_Flags = found->Mount_Flags;
2171 Mount_Options = found->Mount_Options;
2172 LOGINFO("Mount_Flags: %i, Mount_Options: %s\n", Mount_Flags, Mount_Options.c_str());
2173 }
2174 }
Dees_Troy51a0e822012-09-05 15:24:24 -04002175}
2176
dianlujitao4879b372018-12-03 18:45:47 +08002177bool TWPartition::Wipe_EXTFS(string File_System) {
bigbiff7ba75002020-04-11 20:47:09 -04002178 if (!UnMount(true))
2179 return false;
2180
dianlujitao4879b372018-12-03 18:45:47 +08002181#if PLATFORM_SDK_VERSION < 28
bigbiffad58e1b2020-07-06 20:24:34 -04002182 if (!TWFunc::Path_Exists("/system/bin/mke2fs"))
dianlujitao4879b372018-12-03 18:45:47 +08002183#else
bigbiffad58e1b2020-07-06 20:24:34 -04002184 if (!TWFunc::Path_Exists("/system/bin/mke2fs") || !TWFunc::Path_Exists("/system/bin/e2fsdroid"))
dianlujitao4879b372018-12-03 18:45:47 +08002185#endif
Dees_Troy38bd7602012-09-14 13:33:53 -04002186 return Wipe_RMRF();
2187
dianlujitao4879b372018-12-03 18:45:47 +08002188 int ret;
2189 bool NeedPreserveFooter = true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002190
Ethan Yonker25f20c12014-10-14 09:04:43 -05002191 Find_Actual_Block_Device();
2192 if (!Is_Present) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002193 LOGINFO("Block device not present, cannot wipe %s.\n", Display_Name.c_str());
2194 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Ethan Yonker25f20c12014-10-14 09:04:43 -05002195 return false;
2196 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002197
dianlujitao4879b372018-12-03 18:45:47 +08002198 /**
2199 * On decrypted devices, IOCTL_Get_Block_Size calculates size on device mapper,
2200 * so there's no need to preserve footer.
2201 */
2202 if ((Is_Decrypted && !Decrypted_Block_Device.empty()) ||
2203 Crypto_Key_Location != "footer") {
2204 NeedPreserveFooter = false;
2205 }
2206
2207 unsigned long long dev_sz = TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
2208 if (!dev_sz)
2209 return false;
2210
2211 if (NeedPreserveFooter)
2212 Length < 0 ? dev_sz += Length : dev_sz -= CRYPT_FOOTER_OFFSET;
2213
Dees Troy9a4d7402019-03-21 14:17:28 -04002214 char dout[16];
2215 sprintf(dout, "%llu", dev_sz / 4096);
2216
2217 //string size_str =to_string(dev_sz / 4096);
2218 string size_str = dout;
dianlujitao4879b372018-12-03 18:45:47 +08002219 string Command;
2220
2221 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mke2fs"));
2222
2223 // Execute mke2fs to create empty ext4 filesystem
2224 Command = "mke2fs -t " + File_System + " -b 4096 " + Actual_Block_Device + " " + size_str;
2225 LOGINFO("mke2fs command: %s\n", Command.c_str());
2226 ret = TWFunc::Exec_Cmd(Command);
2227 if (ret) {
2228 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2229 return false;
2230 }
2231
bigbiffad58e1b2020-07-06 20:24:34 -04002232 if (TWFunc::Path_Exists("/system/bin/e2fsdroid")) {
dianlujitao3cf05a52019-05-15 15:33:27 +08002233 const string& File_Contexts_Entry = (Mount_Point == "/system_root" ? "/" : Mount_Point);
2234 char *secontext = NULL;
2235 if (!selinux_handle || selabel_lookup(selinux_handle, &secontext, File_Contexts_Entry.c_str(), S_IFDIR) < 0) {
2236 LOGINFO("Cannot lookup security context for '%s'\n", Mount_Point.c_str());
2237 } else {
2238 // Execute e2fsdroid to initialize selinux context
bigbiff5b911ca2020-07-18 10:46:09 -04002239 if (Mount_Point == "/persist") {
2240 Mount(true);
2241 TWFunc::removeDir("/persist/lost+found", false);
2242 UnMount(true);
2243 }
dianlujitao3cf05a52019-05-15 15:33:27 +08002244 Command = "e2fsdroid -e -S /file_contexts -a " + File_Contexts_Entry + " " + Actual_Block_Device;
2245 LOGINFO("e2fsdroid command: %s\n", Command.c_str());
2246 ret = TWFunc::Exec_Cmd(Command);
2247 if (ret) {
2248 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2249 return false;
2250 }
dianlujitao4879b372018-12-03 18:45:47 +08002251 }
2252 } else {
2253 LOGINFO("e2fsdroid not present\n");
2254 }
2255
2256 if (NeedPreserveFooter)
2257 Wipe_Crypto_Key();
2258 Current_File_System = File_System;
2259 Recreate_AndSec_Folder();
2260 gui_msg("done=Done.");
2261 return true;
2262}
2263
2264bool TWPartition::Wipe_EXT4() {
2265#ifdef USE_EXT4
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002266 int ret;
dianlujitao4879b372018-12-03 18:45:47 +08002267 bool NeedPreserveFooter = true;
2268
bigbiff7ba75002020-04-11 20:47:09 -04002269 if (!UnMount(true))
2270 return false;
2271
dianlujitao4879b372018-12-03 18:45:47 +08002272 Find_Actual_Block_Device();
2273 if (!Is_Present) {
2274 LOGINFO("Block device not present, cannot wipe %s.\n", Display_Name.c_str());
2275 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2276 return false;
2277 }
dianlujitao4879b372018-12-03 18:45:47 +08002278
2279 /**
2280 * On decrypted devices, IOCTL_Get_Block_Size calculates size on device mapper,
2281 * so there's no need to preserve footer.
2282 */
2283 if ((Is_Decrypted && !Decrypted_Block_Device.empty()) ||
2284 Crypto_Key_Location != "footer") {
2285 NeedPreserveFooter = false;
2286 }
2287
2288 unsigned long long dev_sz = TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
2289 if (!dev_sz)
2290 return false;
2291
2292 if (NeedPreserveFooter)
2293 Length < 0 ? dev_sz += Length : dev_sz -= CRYPT_FOOTER_OFFSET;
2294
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002295 char *secontext = NULL;
2296
Greg Wallace4b44fef2015-12-29 15:33:24 -05002297 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("make_ext4fs"));
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002298
Dees Troy99c8dbf2014-03-10 16:53:58 +00002299 if (!selinux_handle || selabel_lookup(selinux_handle, &secontext, Mount_Point.c_str(), S_IFDIR) < 0) {
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002300 LOGINFO("Cannot lookup security context for '%s'\n", Mount_Point.c_str());
dianlujitao4879b372018-12-03 18:45:47 +08002301 ret = make_ext4fs(Actual_Block_Device.c_str(), dev_sz, Mount_Point.c_str(), NULL);
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002302 } else {
dianlujitao4879b372018-12-03 18:45:47 +08002303 ret = make_ext4fs(Actual_Block_Device.c_str(), dev_sz, Mount_Point.c_str(), selinux_handle);
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002304 }
2305 if (ret != 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002306 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troya95f55c2013-08-17 13:14:43 +00002307 return false;
2308 } else {
dianlujitao4879b372018-12-03 18:45:47 +08002309 if (NeedPreserveFooter)
2310 Wipe_Crypto_Key();
bigbiff bigbiffc49d7062013-10-11 20:28:00 -04002311 string sedir = Mount_Point + "/lost+found";
2312 PartitionManager.Mount_By_Path(sedir.c_str(), true);
2313 rmdir(sedir.c_str());
2314 mkdir(sedir.c_str(), S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP);
Dees_Troya95f55c2013-08-17 13:14:43 +00002315 return true;
2316 }
2317#else
dianlujitao4879b372018-12-03 18:45:47 +08002318 return Wipe_EXTFS("ext4");
Dees_Troya95f55c2013-08-17 13:14:43 +00002319#endif
Dees_Troy51a0e822012-09-05 15:24:24 -04002320}
2321
2322bool TWPartition::Wipe_FAT() {
Vojtech Bocek05534202013-09-11 08:11:56 +02002323 string command;
Dees_Troy38bd7602012-09-14 13:33:53 -04002324
bigbiff7ba75002020-04-11 20:47:09 -04002325 if (!UnMount(true))
2326 return false;
Dees_Troy38bd7602012-09-14 13:33:53 -04002327
bigbiffad58e1b2020-07-06 20:24:34 -04002328 if (TWFunc::Path_Exists("/system/bin/mkfs.fat")) {
Greg Wallace4b44fef2015-12-29 15:33:24 -05002329 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mkfs.fat"));
Dees_Troy38bd7602012-09-14 13:33:53 -04002330 Find_Actual_Block_Device();
Matt Mower18794c82015-11-11 16:22:45 -06002331 command = "mkfs.fat " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02002332 if (TWFunc::Exec_Cmd(command) == 0) {
Gary Pecke8bc5d72012-12-21 06:45:25 -08002333 Current_File_System = "vfat";
Dees_Troye58d5262012-09-21 12:27:57 -04002334 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002335 gui_msg("done=Done.");
Dees_Troy38bd7602012-09-14 13:33:53 -04002336 return true;
2337 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002338 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04002339 return false;
2340 }
2341 return true;
2342 }
2343 else
2344 return Wipe_RMRF();
2345
2346 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04002347}
2348
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002349bool TWPartition::Wipe_EXFAT() {
Vojtech Bocek05534202013-09-11 08:11:56 +02002350 string command;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002351
bigbiff7ba75002020-04-11 20:47:09 -04002352 if (!UnMount(true))
2353 return false;
bigbiffad58e1b2020-07-06 20:24:34 -04002354 if (TWFunc::Path_Exists("/system/bin/mkexfatfs")) {
Greg Wallace4b44fef2015-12-29 15:33:24 -05002355 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mkexfatfs"));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002356 Find_Actual_Block_Device();
2357 command = "mkexfatfs " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02002358 if (TWFunc::Exec_Cmd(command) == 0) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002359 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002360 gui_msg("done=Done.");
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002361 return true;
2362 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002363 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002364 return false;
2365 }
2366 return true;
2367 }
2368 return false;
2369}
2370
Dees_Troy38bd7602012-09-14 13:33:53 -04002371bool TWPartition::Wipe_MTD() {
2372 if (!UnMount(true))
2373 return false;
2374
Greg Wallace4b44fef2015-12-29 15:33:24 -05002375 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("MTD"));
Dees_Troy38bd7602012-09-14 13:33:53 -04002376
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002377 mtd_scan_partitions();
2378 const MtdPartition* mtd = mtd_find_partition_by_name(MTD_Name.c_str());
2379 if (mtd == NULL) {
2380 LOGERR("No mtd partition named '%s'", MTD_Name.c_str());
2381 return false;
2382 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002383
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002384 MtdWriteContext* ctx = mtd_write_partition(mtd);
2385 if (ctx == NULL) {
2386 LOGERR("Can't write '%s', failed to format.", MTD_Name.c_str());
2387 return false;
2388 }
2389 if (mtd_erase_blocks(ctx, -1) == -1) {
2390 mtd_write_close(ctx);
2391 LOGERR("Failed to format '%s'", MTD_Name.c_str());
2392 return false;
2393 }
2394 if (mtd_write_close(ctx) != 0) {
2395 LOGERR("Failed to close '%s'", MTD_Name.c_str());
2396 return false;
2397 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08002398 Current_File_System = "yaffs2";
Dees_Troye58d5262012-09-21 12:27:57 -04002399 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002400 gui_msg("done=Done.");
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002401 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002402}
2403
2404bool TWPartition::Wipe_RMRF() {
Dees_Troy38bd7602012-09-14 13:33:53 -04002405 if (!Mount(true))
2406 return false;
Ethan Yonker726a0202014-12-16 20:01:38 -06002407 // This is the only wipe that leaves the partition mounted, so we
2408 // must manually remove the partition from MTP if it is a storage
2409 // partition.
2410 if (Is_Storage)
2411 PartitionManager.Remove_MTP_Storage(MTP_Storage_ID);
Dees_Troy38bd7602012-09-14 13:33:53 -04002412
Ethan Yonker74db1572015-10-28 12:44:49 -05002413 gui_msg(Msg("remove_all=Removing all files under '{1}'")(Mount_Point));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002414 TWFunc::removeDir(Mount_Point, true);
Dees_Troye58d5262012-09-21 12:27:57 -04002415 Recreate_AndSec_Folder();
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002416 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002417}
2418
Dees_Troye5017042013-08-29 16:38:55 +00002419bool TWPartition::Wipe_F2FS() {
systemaddb475c92021-08-12 20:33:20 +02002420 std::string f2fs_command;
Dees_Troye5017042013-08-29 16:38:55 +00002421
bigbiff7ba75002020-04-11 20:47:09 -04002422 if (!UnMount(true))
2423 return false;
dianlujitao4879b372018-12-03 18:45:47 +08002424
bigbiffad58e1b2020-07-06 20:24:34 -04002425 if (TWFunc::Path_Exists("/system/bin/mkfs.f2fs"))
systemaddb475c92021-08-12 20:33:20 +02002426 f2fs_command = "/system/bin/mkfs.f2fs";
bigbiffad58e1b2020-07-06 20:24:34 -04002427 else if (TWFunc::Path_Exists("/system/bin/make_f2fs"))
systemaddb475c92021-08-12 20:33:20 +02002428 f2fs_command = "/system/bin/make_f2fs -g android";
bigbiff7ba75002020-04-11 20:47:09 -04002429 else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002430 LOGINFO("mkfs.f2fs binary not found, using rm -rf to wipe.\n");
Dees_Troye5017042013-08-29 16:38:55 +00002431 return Wipe_RMRF();
2432 }
bigbiff7ba75002020-04-11 20:47:09 -04002433
2434 bool NeedPreserveFooter = true;
systemaddb475c92021-08-12 20:33:20 +02002435 bool needs_casefold = false;
2436 bool needs_projid = false;
bigbiff7ba75002020-04-11 20:47:09 -04002437
2438 Find_Actual_Block_Device();
2439 if (!Is_Present) {
2440 LOGINFO("Block device not present, cannot wipe %s.\n", Display_Name.c_str());
2441 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2442 return false;
2443 }
systemaddb475c92021-08-12 20:33:20 +02002444
2445 needs_casefold = android::base::GetBoolProperty("external_storage.casefold.enabled", false);
Captain Throwbackd5e2c522022-05-21 10:44:13 -04002446 needs_projid = android::base::GetBoolProperty("external_storage.projid.enabled", false);
bigbiff7ba75002020-04-11 20:47:09 -04002447 unsigned long long dev_sz = TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
2448 if (!dev_sz)
2449 return false;
2450
2451 if (NeedPreserveFooter)
2452 Length < 0 ? dev_sz += Length : dev_sz -= CRYPT_FOOTER_OFFSET;
bigbiff7ba75002020-04-11 20:47:09 -04002453 char dev_sz_str[48];
2454 sprintf(dev_sz_str, "%llu", (dev_sz / 4096));
systemaddb475c92021-08-12 20:33:20 +02002455 if(needs_projid)
2456 f2fs_command += " -O project_quota,extra_attr";
2457
2458 if(needs_casefold)
2459 f2fs_command += " -O casefold -C utf8";
2460
2461 f2fs_command += " " + Actual_Block_Device + " " + dev_sz_str;
2462
Captain Throwbackd5e2c522022-05-21 10:44:13 -04002463 if (TWFunc::Path_Exists("/system/bin/sload_f2fs")) {
2464 f2fs_command += " && sload_f2fs -t /data " + Actual_Block_Device;
bigbiff7ba75002020-04-11 20:47:09 -04002465 }
2466
2467 /**
2468 * On decrypted devices, IOCTL_Get_Block_Size calculates size on device mapper,
2469 * so there's no need to preserve footer.
2470 */
2471 if ((Is_Decrypted && !Decrypted_Block_Device.empty()) ||
2472 Crypto_Key_Location != "footer") {
2473 NeedPreserveFooter = false;
2474 }
systemaddb475c92021-08-12 20:33:20 +02002475 LOGINFO("mkfs.f2fs command: %s\n", f2fs_command.c_str());
2476 if (TWFunc::Exec_Cmd(f2fs_command) == 0) {
bigbiff7ba75002020-04-11 20:47:09 -04002477 if (NeedPreserveFooter)
2478 Wipe_Crypto_Key();
2479 Recreate_AndSec_Folder();
2480 gui_msg("done=Done.");
2481 return true;
2482 } else {
2483 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2484 return false;
2485 }
2486 return true;
Dees_Troye5017042013-08-29 16:38:55 +00002487}
2488
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002489bool TWPartition::Wipe_NTFS() {
2490 string command;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002491 string Ntfsmake_Binary;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002492
bigbiff7ba75002020-04-11 20:47:09 -04002493 if (!UnMount(true))
2494 return false;
2495
bigbiffad58e1b2020-07-06 20:24:34 -04002496 if (TWFunc::Path_Exists("/system/bin/mkntfs"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002497 Ntfsmake_Binary = "mkntfs";
bigbiffad58e1b2020-07-06 20:24:34 -04002498 else if (TWFunc::Path_Exists("/system/bin/mkfs.ntfs"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002499 Ntfsmake_Binary = "mkfs.ntfs";
2500 else
2501 return false;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002502
Greg Wallace4b44fef2015-12-29 15:33:24 -05002503 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)(Ntfsmake_Binary));
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002504 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04002505 command = "/system/bin/" + Ntfsmake_Binary + " " + Actual_Block_Device;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002506 if (TWFunc::Exec_Cmd(command) == 0) {
2507 Recreate_AndSec_Folder();
2508 gui_msg("done=Done.");
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002509 return true;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002510 } else {
2511 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2512 return false;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002513 }
2514 return false;
2515}
2516
Dees_Troy51a0e822012-09-05 15:24:24 -04002517bool TWPartition::Wipe_Data_Without_Wiping_Media() {
Ethan Yonker83e82572014-04-04 10:59:28 -05002518#ifdef TW_OEM_BUILD
2519 // In an OEM Build we want to do a full format
2520 return Wipe_Encryption();
2521#else
Ethan Yonker66a19492015-12-10 10:19:45 -06002522 bool ret = false;
Dees_Troy38bd7602012-09-14 13:33:53 -04002523
Dees_Troy38bd7602012-09-14 13:33:53 -04002524 if (!Mount(true))
2525 return false;
2526
Ethan Yonker74db1572015-10-28 12:44:49 -05002527 gui_msg("wiping_data=Wiping data without wiping /data/media ...");
Ethan Yonker66a19492015-12-10 10:19:45 -06002528 ret = Wipe_Data_Without_Wiping_Media_Func(Mount_Point + "/");
2529 if (ret)
2530 gui_msg("done=Done.");
2531 return ret;
2532#endif // ifdef TW_OEM_BUILD
2533}
2534
2535bool TWPartition::Wipe_Data_Without_Wiping_Media_Func(const string& parent __unused) {
2536 string dir;
Dees_Troy38bd7602012-09-14 13:33:53 -04002537
2538 DIR* d;
Ethan Yonker66a19492015-12-10 10:19:45 -06002539 d = opendir(parent.c_str());
Dees_Troy16b74352012-11-14 22:27:31 +00002540 if (d != NULL) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002541 struct dirent* de;
2542 while ((de = readdir(d)) != NULL) {
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05002543 if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) continue;
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05002544
Ethan Yonker66a19492015-12-10 10:19:45 -06002545 dir = parent;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002546 dir.append(de->d_name);
Ethan Yonker3fdcda42016-11-30 12:29:37 -06002547 if (wipe_exclusions.check_skip_dirs(dir)) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002548 LOGINFO("skipped '%s'\n", dir.c_str());
2549 continue;
2550 }
Dees_Troyce675462013-01-09 19:48:21 +00002551 if (de->d_type == DT_DIR) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002552 dir.append("/");
2553 if (!Wipe_Data_Without_Wiping_Media_Func(dir)) {
2554 closedir(d);
2555 return false;
2556 }
2557 rmdir(dir.c_str());
bigbiff bigbiff98f1f902013-01-19 18:46:13 -05002558 } 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 +03002559 if (unlink(dir.c_str()) != 0)
Ethan Yonker79f88bd2016-12-09 14:52:12 -06002560 LOGINFO("Unable to unlink '%s': %s\n", dir.c_str(), strerror(errno));
Dees_Troyce675462013-01-09 19:48:21 +00002561 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002562 }
2563 closedir(d);
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05002564
Dees_Troy16b74352012-11-14 22:27:31 +00002565 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -04002566 }
Ethan Yonker74db1572015-10-28 12:44:49 -05002567 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy16b74352012-11-14 22:27:31 +00002568 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04002569}
2570
dianlujitao4879b372018-12-03 18:45:47 +08002571void TWPartition::Wipe_Crypto_Key() {
2572 Find_Actual_Block_Device();
2573 if (Crypto_Key_Location.empty())
2574 return;
2575 else if (Crypto_Key_Location == "footer") {
2576 int fd = open(Actual_Block_Device.c_str(), O_RDWR);
2577 if (fd < 0) {
2578 gui_print_color("warning", "Unable to open '%s' to wipe crypto key\n", Actual_Block_Device.c_str());
2579 return;
2580 }
2581
2582 unsigned int block_count;
2583 if ((ioctl(fd, BLKGETSIZE, &block_count)) == -1) {
2584 gui_print_color("warning", "Unable to get block size for wiping crypto footer.\n");
2585 } else {
2586 int newlen = Length < 0 ? -Length : CRYPT_FOOTER_OFFSET;
2587 off64_t offset = ((off64_t)block_count * 512) - newlen;
2588 if (lseek64(fd, offset, SEEK_SET) == -1) {
2589 gui_print_color("warning", "Unable to lseek64 for wiping crypto footer.\n");
2590 } else {
2591 void* buffer = malloc(newlen);
2592 if (!buffer) {
2593 gui_print_color("warning", "Failed to malloc for wiping crypto footer.\n");
2594 } else {
2595 memset(buffer, 0, newlen);
2596 int ret = write(fd, buffer, newlen);
2597 if (ret != newlen) {
2598 gui_print_color("warning", "Failed to wipe crypto footer.\n");
2599 } else {
2600 LOGINFO("Successfully wiped crypto footer.\n");
2601 }
2602 free(buffer);
2603 }
2604 }
2605 }
2606 close(fd);
2607 } else {
2608 if (TWFunc::IOCTL_Get_Block_Size(Crypto_Key_Location.c_str()) >= 16384LLU) {
2609 string Command = "dd of='" + Crypto_Key_Location + "' if=/dev/zero bs=16384 count=1";
2610 TWFunc::Exec_Cmd(Command);
2611 } else {
2612 LOGINFO("Crypto key location reports size < 16K so not wiping crypto footer.\n");
2613 }
2614 }
2615}
2616
bigbiffce8f83c2015-12-12 18:30:21 -05002617bool TWPartition::Backup_Tar(PartitionSettings *part_settings, pid_t *tar_fork_pid) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002618 string Full_FileName;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002619 twrpTar tar;
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -05002620
Dees_Troy43d8b002012-09-17 16:00:01 -04002621 if (!Mount(true))
2622 return false;
2623
Ian Macdonalda3b25a32019-06-16 22:39:14 +02002624 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Backup_Display_Name, gui_parse_text("{@backing}"));
Ethan Yonker74db1572015-10-28 12:44:49 -05002625 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002626
Ethan Yonker472f5062016-02-25 13:47:30 -06002627 DataManager::GetValue(TW_USE_COMPRESSION_VAR, tar.use_compression);
Matt Mowerbb81e5d2014-03-20 18:05:41 -05002628
Dees_Troy83bd4832013-05-04 12:39:56 +00002629#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
Ethan Yonker472f5062016-02-25 13:47:30 -06002630 if (Can_Encrypt_Backup) {
2631 DataManager::GetValue("tw_encrypt_backup", tar.use_encryption);
2632 if (tar.use_encryption) {
2633 if (Use_Userdata_Encryption)
2634 tar.userdata_encryption = tar.use_encryption;
2635 string Password;
2636 DataManager::GetValue("tw_backup_password", Password);
2637 tar.setpassword(Password);
2638 } else {
2639 tar.use_encryption = 0;
2640 }
Dees_Troy83bd4832013-05-04 12:39:56 +00002641 }
2642#endif
Dees_Troy43d8b002012-09-17 16:00:01 -04002643
Ethan Yonker472f5062016-02-25 13:47:30 -06002644 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002645 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Ethan Yonker01f4e032017-02-03 15:30:52 -06002646 if (Has_Data_Media)
2647 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 -04002648 if (Mount_Point == "/data" && DataManager::GetIntValue(TW_IS_FBE)) {
2649 std::vector<users_struct>::iterator iter;
2650 std::vector<users_struct>* userList = PartitionManager.Get_Users_List();
2651 for (iter = userList->begin(); iter != userList->end(); iter++) {
2652 if (!(*iter).isDecrypted && (*iter).userId != "0") {
2653 gui_msg(Msg(msg::kWarning,
2654 "backup_storage_undecrypt_warning=Backup will not include some files from user {1} "
2655 "because the user is not decrypted.")((*iter).userId));
2656 backup_exclusions.add_absolute_dir("/data/system_ce/" + (*iter).userId);
2657 backup_exclusions.add_absolute_dir("/data/misc_ce/" + (*iter).userId);
2658 backup_exclusions.add_absolute_dir("/data/vendor_ce/" + (*iter).userId);
2659 backup_exclusions.add_absolute_dir("/data/media/" + (*iter).userId);
2660 backup_exclusions.add_absolute_dir("/data/user/" + (*iter).userId);
2661 }
2662 }
2663 }
bigbiffce8f83c2015-12-12 18:30:21 -05002664 tar.part_settings = part_settings;
Ethan Yonker3fdcda42016-11-30 12:29:37 -06002665 tar.backup_exclusions = &backup_exclusions;
Dees Troye0a433a2013-12-02 04:10:37 +00002666 tar.setdir(Backup_Path);
2667 tar.setfn(Full_FileName);
2668 tar.setsize(Backup_Size);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002669 tar.partition_name = Backup_Name;
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002670 tar.backup_folder = part_settings->Backup_Folder;
bigbiffce8f83c2015-12-12 18:30:21 -05002671 if (tar.createTarFork(tar_fork_pid) != 0)
Dees Troye0a433a2013-12-02 04:10:37 +00002672 return false;
Dees_Troy43d8b002012-09-17 16:00:01 -04002673 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002674}
2675
bigbiffce8f83c2015-12-12 18:30:21 -05002676bool TWPartition::Backup_Image(PartitionSettings *part_settings) {
2677 string Full_FileName, adb_file_name;
igoriok87e3d932013-01-31 21:03:53 +02002678
Ethan Yonker74db1572015-10-28 12:44:49 -05002679 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, gui_parse_text("{@backing}"));
2680 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002681
Ethan Yonker472f5062016-02-25 13:47:30 -06002682 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
Dees_Troy43d8b002012-09-17 16:00:01 -04002683
bigbiffce8f83c2015-12-12 18:30:21 -05002684 if (part_settings->adbbackup) {
2685 Full_FileName = TW_ADB_BACKUP;
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002686 adb_file_name = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002687 }
2688 else
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002689 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002690
2691 part_settings->total_restore_size = Backup_Size;
2692
2693 if (part_settings->adbbackup) {
2694 if (!twadbbu::Write_TWIMG(adb_file_name, Backup_Size))
2695 return false;
2696 }
2697
2698 if (!Raw_Read_Write(part_settings))
Ethan Yonker472f5062016-02-25 13:47:30 -06002699 return false;
2700
bigbiffce8f83c2015-12-12 18:30:21 -05002701 if (part_settings->adbbackup) {
2702 if (!twadbbu::Write_TWEOF())
2703 return false;
Dees_Troy7c2dec82012-09-26 09:49:14 -04002704 }
Dees_Troy43d8b002012-09-17 16:00:01 -04002705 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002706}
2707
bigbiffce8f83c2015-12-12 18:30:21 -05002708bool TWPartition::Raw_Read_Write(PartitionSettings *part_settings) {
2709 unsigned long long RW_Block_Size, Remain = Backup_Size;
2710 int src_fd = -1, dest_fd = -1;
2711 ssize_t bs;
Ethan Yonker472f5062016-02-25 13:47:30 -06002712 bool ret = false;
2713 void* buffer = NULL;
2714 unsigned long long backedup_size = 0;
bigbiffce8f83c2015-12-12 18:30:21 -05002715 string srcfn, destfn;
Ethan Yonker472f5062016-02-25 13:47:30 -06002716
bigbiffce8f83c2015-12-12 18:30:21 -05002717 if (part_settings->PM_Method == PM_BACKUP) {
2718 srcfn = Actual_Block_Device;
2719 if (part_settings->adbbackup)
2720 destfn = TW_ADB_BACKUP;
bigbiff bigbiff38b83c12017-12-28 19:58:52 -05002721 else {
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002722 destfn = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiff bigbiff38b83c12017-12-28 19:58:52 -05002723 }
bigbiffce8f83c2015-12-12 18:30:21 -05002724 }
2725 else {
2726 destfn = Actual_Block_Device;
2727 if (part_settings->adbbackup) {
2728 srcfn = TW_ADB_RESTORE;
2729 } else {
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002730 srcfn = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002731 Remain = TWFunc::Get_File_Size(srcfn);
2732 }
2733 }
Ethan Yonker472f5062016-02-25 13:47:30 -06002734
bigbiffce8f83c2015-12-12 18:30:21 -05002735 src_fd = open(srcfn.c_str(), O_RDONLY | O_LARGEFILE);
Ethan Yonker472f5062016-02-25 13:47:30 -06002736 if (src_fd < 0) {
bigbiffce8f83c2015-12-12 18:30:21 -05002737 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(srcfn.c_str())(strerror(errno)));
Ethan Yonker472f5062016-02-25 13:47:30 -06002738 return false;
2739 }
bigbiffce8f83c2015-12-12 18:30:21 -05002740
2741 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 -06002742 if (dest_fd < 0) {
bigbiffce8f83c2015-12-12 18:30:21 -05002743 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(destfn.c_str())(strerror(errno)));
Ethan Yonker472f5062016-02-25 13:47:30 -06002744 goto exit;
2745 }
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04002746
bigbiffce8f83c2015-12-12 18:30:21 -05002747 LOGINFO("Reading '%s', writing '%s'\n", srcfn.c_str(), destfn.c_str());
2748
2749 if (part_settings->adbbackup) {
2750 RW_Block_Size = MAX_ADB_READ;
2751 bs = MAX_ADB_READ;
2752 }
2753 else {
2754 RW_Block_Size = 1048576LLU; // 1MB
2755 bs = (ssize_t)(RW_Block_Size);
2756 }
2757
Ethan Yonker472f5062016-02-25 13:47:30 -06002758 buffer = malloc((size_t)bs);
2759 if (!buffer) {
2760 LOGINFO("Raw_Read_Write failed to malloc\n");
2761 goto exit;
2762 }
bigbiffce8f83c2015-12-12 18:30:21 -05002763
2764 if (part_settings->progress)
2765 part_settings->progress->SetPartitionSize(part_settings->total_restore_size);
2766
Ethan Yonker472f5062016-02-25 13:47:30 -06002767 while (Remain > 0) {
2768 if (Remain < RW_Block_Size)
bigbiffce8f83c2015-12-12 18:30:21 -05002769 bs = (ssize_t)(Remain);
Matt Mowera8a89d12016-12-30 18:10:37 -06002770 if (read(src_fd, buffer, bs) != bs) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002771 LOGINFO("Error reading source fd (%s)\n", strerror(errno));
2772 goto exit;
2773 }
2774 if (write(dest_fd, buffer, bs) != bs) {
2775 LOGINFO("Error writing destination fd (%s)\n", strerror(errno));
2776 goto exit;
2777 }
2778 backedup_size += (unsigned long long)(bs);
Matt Mower029a82d2017-01-08 13:12:38 -06002779 Remain -= (unsigned long long)(bs);
bigbiffce8f83c2015-12-12 18:30:21 -05002780 if (part_settings->progress)
2781 part_settings->progress->UpdateSize(backedup_size);
Ethan Yonker472f5062016-02-25 13:47:30 -06002782 if (PartitionManager.Check_Backup_Cancel() != 0)
2783 goto exit;
2784 }
bigbiffce8f83c2015-12-12 18:30:21 -05002785 if (part_settings->progress)
2786 part_settings->progress->UpdateDisplayDetails(true);
Ethan Yonker472f5062016-02-25 13:47:30 -06002787 fsync(dest_fd);
nailyka083dc62016-11-11 21:41:28 +01002788
2789 if (!part_settings->adbbackup && part_settings->PM_Method == PM_BACKUP) {
2790 tw_set_default_metadata(destfn.c_str());
2791 LOGINFO("Restored default metadata for %s\n", destfn.c_str());
2792 }
2793
Ethan Yonker472f5062016-02-25 13:47:30 -06002794 ret = true;
2795exit:
2796 if (src_fd >= 0)
2797 close(src_fd);
2798 if (dest_fd >= 0)
2799 close(dest_fd);
2800 if (buffer)
2801 free(buffer);
2802 return ret;
2803}
2804
bigbiffce8f83c2015-12-12 18:30:21 -05002805bool TWPartition::Backup_Dump_Image(PartitionSettings *part_settings) {
Vojtech Bocek05534202013-09-11 08:11:56 +02002806 string Full_FileName, Command;
Dees_Troy43d8b002012-09-17 16:00:01 -04002807
Ethan Yonker74db1572015-10-28 12:44:49 -05002808 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, gui_parse_text("{@backing}"));
2809 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002810
bigbiffce8f83c2015-12-12 18:30:21 -05002811 if (part_settings->progress)
2812 part_settings->progress->SetPartitionSize(Backup_Size);
Dees_Troy43d8b002012-09-17 16:00:01 -04002813
Ethan Yonker472f5062016-02-25 13:47:30 -06002814 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002815 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Dees_Troy43d8b002012-09-17 16:00:01 -04002816
2817 Command = "dump_image " + MTD_Name + " '" + Full_FileName + "'";
bigbiffce8f83c2015-12-12 18:30:21 -05002818
Dees_Troy2673cec2013-04-02 20:22:16 +00002819 LOGINFO("Backup command: '%s'\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02002820 TWFunc::Exec_Cmd(Command);
Ethan Yonker4b94cfd2014-12-11 10:00:45 -06002821 tw_set_default_metadata(Full_FileName.c_str());
Dees_Troy7c2dec82012-09-26 09:49:14 -04002822 if (TWFunc::Get_File_Size(Full_FileName) == 0) {
2823 // 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 -06002824 gui_msg(Msg(msg::kError, "backup_size=Backup file size for '{1}' is 0 bytes.")(Full_FileName));
Dees_Troy7c2dec82012-09-26 09:49:14 -04002825 return false;
2826 }
bigbiffce8f83c2015-12-12 18:30:21 -05002827 if (part_settings->progress)
2828 part_settings->progress->UpdateSize(Backup_Size);
2829
Dees_Troy43d8b002012-09-17 16:00:01 -04002830 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002831}
2832
bigbiffce8f83c2015-12-12 18:30:21 -05002833unsigned long long TWPartition::Get_Restore_Size(PartitionSettings *part_settings) {
2834 if (!part_settings->adbbackup) {
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002835 InfoManager restore_info(part_settings->Backup_Folder + "/" + Backup_Name + ".info");
bigbiffce8f83c2015-12-12 18:30:21 -05002836 if (restore_info.LoadValues() == 0) {
2837 if (restore_info.GetValue("backup_size", Restore_Size) == 0) {
2838 LOGINFO("Read info file, restore size is %llu\n", Restore_Size);
2839 return Restore_Size;
2840 }
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002841 }
2842 }
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002843
Matt Mower029a82d2017-01-08 13:12:38 -06002844 string Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
2845 string Restore_File_System = Get_Restore_File_System(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002846
2847 if (Is_Image(Restore_File_System)) {
2848 Restore_Size = TWFunc::Get_File_Size(Full_FileName);
2849 return Restore_Size;
2850 }
2851
2852 twrpTar tar;
2853 tar.setdir(Backup_Path);
2854 tar.setfn(Full_FileName);
bigbiffce8f83c2015-12-12 18:30:21 -05002855 tar.backup_name = Full_FileName;
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002856#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
2857 string Password;
2858 DataManager::GetValue("tw_restore_password", Password);
2859 if (!Password.empty())
2860 tar.setpassword(Password);
2861#endif
2862 tar.partition_name = Backup_Name;
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002863 tar.backup_folder = part_settings->Backup_Folder;
bigbiffce8f83c2015-12-12 18:30:21 -05002864 tar.part_settings = part_settings;
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002865 Restore_Size = tar.get_size();
2866 return Restore_Size;
2867}
2868
bigbiffce8f83c2015-12-12 18:30:21 -05002869bool TWPartition::Restore_Tar(PartitionSettings *part_settings) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002870 string Full_FileName;
Dees Troy4159aed2014-02-28 17:24:43 +00002871 bool ret = false;
bigbiffce8f83c2015-12-12 18:30:21 -05002872 string Restore_File_System = Get_Restore_File_System(part_settings);
Dees_Troy43d8b002012-09-17 16:00:01 -04002873
Dees_Troye58d5262012-09-21 12:27:57 -04002874 if (Has_Android_Secure) {
Dees_Troye58d5262012-09-21 12:27:57 -04002875 if (!Wipe_AndSec())
2876 return false;
Gary Peck43acadf2012-11-21 21:19:01 -08002877 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002878 gui_msg(Msg("wiping=Wiping {1}")(Backup_Display_Name));
Ethan Yonker5eac2222014-06-11 12:22:55 -05002879 if (Has_Data_Media && Mount_Point == "/data" && Restore_File_System != Current_File_System) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002880 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 -05002881 if (!Wipe_Data_Without_Wiping_Media())
2882 return false;
2883 } else {
2884 if (!Wipe(Restore_File_System))
2885 return false;
2886 }
Dees_Troye58d5262012-09-21 12:27:57 -04002887 }
Matt Mower3c366972015-12-25 19:28:31 -06002888 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Backup_Display_Name, gui_parse_text("{@restoring_hdr}"));
Ethan Yonker74db1572015-10-28 12:44:49 -05002889 gui_msg(Msg("restoring=Restoring {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002890
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05002891 // Remount as read/write as needed so we can restore the backup
2892 if (!ReMount_RW(true))
Dees_Troy43d8b002012-09-17 16:00:01 -04002893 return false;
2894
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002895 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Ethan Yonker87af5632014-02-10 11:56:35 -06002896 twrpTar tar;
bigbiffce8f83c2015-12-12 18:30:21 -05002897 tar.part_settings = part_settings;
Ethan Yonker87af5632014-02-10 11:56:35 -06002898 tar.setdir(Backup_Path);
2899 tar.setfn(Full_FileName);
2900 tar.backup_name = Backup_Name;
2901#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
2902 string Password;
2903 DataManager::GetValue("tw_restore_password", Password);
2904 if (!Password.empty())
2905 tar.setpassword(Password);
2906#endif
bigbiffce8f83c2015-12-12 18:30:21 -05002907 part_settings->progress->SetPartitionSize(Get_Restore_Size(part_settings));
2908 if (tar.extractTarFork() != 0)
Dees Troy4159aed2014-02-28 17:24:43 +00002909 ret = false;
2910 else
2911 ret = true;
2912#ifdef HAVE_CAPABILITIES
2913 // Restore capabilities to the run-as binary
Captain Throwback9d6feb52018-07-27 10:05:24 -04002914 if (Mount_Point == PartitionManager.Get_Android_Root_Path() && Mount(true) && TWFunc::Path_Exists("/system/bin/run-as")) {
Dees Troy4159aed2014-02-28 17:24:43 +00002915 struct vfs_cap_data cap_data;
2916 uint64_t capabilities = (1 << CAP_SETUID) | (1 << CAP_SETGID);
2917
2918 memset(&cap_data, 0, sizeof(cap_data));
2919 cap_data.magic_etc = VFS_CAP_REVISION | VFS_CAP_FLAGS_EFFECTIVE;
2920 cap_data.data[0].permitted = (uint32_t) (capabilities & 0xffffffff);
2921 cap_data.data[0].inheritable = 0;
2922 cap_data.data[1].permitted = (uint32_t) (capabilities >> 32);
2923 cap_data.data[1].inheritable = 0;
2924 if (setxattr("/system/bin/run-as", XATTR_NAME_CAPS, &cap_data, sizeof(cap_data), 0) < 0) {
2925 LOGINFO("Failed to reset capabilities of /system/bin/run-as binary.\n");
2926 } else {
2927 LOGINFO("Reset capabilities of /system/bin/run-as binary successful.\n");
2928 }
2929 }
2930#endif
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05002931 if (Mount_Read_Only || Mount_Flags & MS_RDONLY)
2932 // Remount as read only when restoration is complete
2933 ReMount(true);
2934
Dees Troy4159aed2014-02-28 17:24:43 +00002935 return ret;
Dees_Troy51a0e822012-09-05 15:24:24 -04002936}
2937
bigbiffce8f83c2015-12-12 18:30:21 -05002938bool TWPartition::Restore_Image(PartitionSettings *part_settings) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06002939 string Full_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002940 string Restore_File_System = Get_Restore_File_System(part_settings);
Dees_Troy43d8b002012-09-17 16:00:01 -04002941
Matt Mower3c366972015-12-25 19:28:31 -06002942 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Backup_Display_Name, gui_parse_text("{@restoring_hdr}"));
Ethan Yonker74db1572015-10-28 12:44:49 -05002943 gui_msg(Msg("restoring=Restoring {1}...")(Backup_Display_Name));
bigbiffce8f83c2015-12-12 18:30:21 -05002944
2945 if (part_settings->adbbackup)
2946 Full_FileName = TW_ADB_RESTORE;
2947 else
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002948 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Gary Peck15e623d2012-11-21 21:07:58 -08002949
Ethan Yonker96af84a2015-01-05 14:58:36 -06002950 if (Restore_File_System == "emmc") {
bigbiffce8f83c2015-12-12 18:30:21 -05002951 if (!part_settings->adbbackup)
2952 part_settings->total_restore_size = (uint64_t)(TWFunc::Get_File_Size(Full_FileName));
2953 if (!Raw_Read_Write(part_settings))
Ethan Yonker96af84a2015-01-05 14:58:36 -06002954 return false;
2955 } else if (Restore_File_System == "mtd" || Restore_File_System == "bml") {
bigbiffce8f83c2015-12-12 18:30:21 -05002956 if (!Flash_Image_FI(Full_FileName, part_settings->progress))
2957 return false;
2958 }
2959
2960 if (part_settings->adbbackup) {
2961 if (!twadbbu::Write_TWEOF())
Ethan Yonker96af84a2015-01-05 14:58:36 -06002962 return false;
Gary Peck15e623d2012-11-21 21:07:58 -08002963 }
Dees_Troy43d8b002012-09-17 16:00:01 -04002964 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002965}
Dees_Troy5bf43922012-09-07 16:07:55 -04002966
2967bool TWPartition::Update_Size(bool Display_Error) {
Dees_Troy0550cfb2012-10-13 11:56:13 -04002968 bool ret = false, Was_Already_Mounted = false;
Dees_Troy51127312012-09-08 13:08:49 -04002969
Ethan Yonker1b190162016-12-05 15:25:19 -06002970 Find_Actual_Block_Device();
2971
bigbiffee7b7ff2020-03-23 15:08:27 -04002972 if (Actual_Block_Device.empty())
2973 return false;
2974
Ethan Yonker1b190162016-12-05 15:25:19 -06002975 if (!Can_Be_Mounted && !Is_Encrypted) {
2976 if (TWFunc::Path_Exists(Actual_Block_Device) && Find_Partition_Size()) {
2977 Used = Size;
2978 Backup_Size = Size;
2979 return true;
2980 }
Dees_Troy5bf43922012-09-07 16:07:55 -04002981 return false;
Ethan Yonker1b190162016-12-05 15:25:19 -06002982 }
Dees_Troy5bf43922012-09-07 16:07:55 -04002983
Dees_Troy0550cfb2012-10-13 11:56:13 -04002984 Was_Already_Mounted = Is_Mounted();
bigbiffee7b7ff2020-03-23 15:08:27 -04002985
Dees_Troy38bd7602012-09-14 13:33:53 -04002986 if (Removable || Is_Encrypted) {
2987 if (!Mount(false))
2988 return true;
2989 } else if (!Mount(Display_Error))
Dees_Troy5bf43922012-09-07 16:07:55 -04002990 return false;
Dees_Troy51127312012-09-08 13:08:49 -04002991
2992 ret = Get_Size_Via_statfs(Display_Error);
Dees_Troy0550cfb2012-10-13 11:56:13 -04002993 if (!ret || Size == 0) {
2994 if (!Get_Size_Via_df(Display_Error)) {
2995 if (!Was_Already_Mounted)
2996 UnMount(false);
Dees_Troy51127312012-09-08 13:08:49 -04002997 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04002998 }
2999 }
Dees_Troy51127312012-09-08 13:08:49 -04003000
Dees_Troy5bf43922012-09-07 16:07:55 -04003001 if (Has_Data_Media) {
3002 if (Mount(Display_Error)) {
Ethan Yonker3fdcda42016-11-30 12:29:37 -06003003 Used = backup_exclusions.Get_Folder_Size(Mount_Point);
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05003004 Backup_Size = Used;
3005 int bak = (int)(Used / 1048576LLU);
Dees_Troy51127312012-09-08 13:08:49 -04003006 int fre = (int)(Free / 1048576LLU);
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05003007 LOGINFO("Data backup size is %iMB, free: %iMB.\n", bak, fre);
Dees_Troy0550cfb2012-10-13 11:56:13 -04003008 } else {
3009 if (!Was_Already_Mounted)
3010 UnMount(false);
Dees_Troy5bf43922012-09-07 16:07:55 -04003011 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04003012 }
Dees_Troye58d5262012-09-21 12:27:57 -04003013 } else if (Has_Android_Secure) {
3014 if (Mount(Display_Error))
Ethan Yonker3fdcda42016-11-30 12:29:37 -06003015 Backup_Size = backup_exclusions.Get_Folder_Size(Backup_Path);
Dees_Troy0550cfb2012-10-13 11:56:13 -04003016 else {
3017 if (!Was_Already_Mounted)
3018 UnMount(false);
Dees_Troye58d5262012-09-21 12:27:57 -04003019 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04003020 }
Dees_Troy5bf43922012-09-07 16:07:55 -04003021 }
Dees_Troy0550cfb2012-10-13 11:56:13 -04003022 if (!Was_Already_Mounted)
3023 UnMount(false);
Dees_Troy5bf43922012-09-07 16:07:55 -04003024 return true;
Dees_Troy51127312012-09-08 13:08:49 -04003025}
Dees_Troy38bd7602012-09-14 13:33:53 -04003026
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06003027bool TWPartition::Find_Wildcard_Block_Devices(const string& Device) {
3028 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
3029 string Path = TWFunc::Get_Path(Device);
3030 string Dev = TWFunc::Get_Filename(Device);
3031 size_t wildcard_index = Dev.find("*");
3032 if (wildcard_index != string::npos)
3033 Dev = Dev.substr(0, wildcard_index);
3034 wildcard_index = Dev.size();
3035 DIR* d = opendir(Path.c_str());
3036 if (d == NULL) {
3037 LOGINFO("Error opening '%s': %s\n", Path.c_str(), strerror(errno));
3038 return false;
3039 }
3040 struct dirent* de;
3041 while ((de = readdir(d)) != NULL) {
3042 if (de->d_type != DT_BLK || strlen(de->d_name) <= wildcard_index || strncmp(de->d_name, Dev.c_str(), wildcard_index) != 0)
3043 continue;
3044
3045 string item = Path + "/";
3046 item.append(de->d_name);
3047 if (PartitionManager.Find_Partition_By_Block_Device(item))
3048 continue;
3049 TWPartition *part = new TWPartition;
3050 char buffer[MAX_FSTAB_LINE_LENGTH];
3051 sprintf(buffer, "%s %s-%i auto defaults defaults", item.c_str(), Mount_Point.c_str(), ++mount_point_index);
bigbiff8da46fa2020-09-08 16:42:34 -04003052 part->Process_Fstab_Line(buffer, false, NULL);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06003053 char display[MAX_FSTAB_LINE_LENGTH];
3054 sprintf(display, "%s %i", Storage_Name.c_str(), mount_point_index);
3055 part->Storage_Name = display;
3056 part->Display_Name = display;
3057 part->Primary_Block_Device = item;
3058 part->Wildcard_Block_Device = false;
3059 part->Is_SubPartition = true;
3060 part->SubPartition_Of = Mount_Point;
3061 part->Is_Storage = Is_Storage;
3062 part->Can_Be_Mounted = true;
3063 part->Removable = true;
3064 part->Can_Be_Wiped = Can_Be_Wiped;
3065 part->Wipe_Available_in_GUI = Wipe_Available_in_GUI;
3066 part->Find_Actual_Block_Device();
3067 part->Update_Size(false);
3068 Has_SubPartition = true;
3069 PartitionManager.Output_Partition(part);
3070 PartitionManager.Add_Partition(part);
3071 }
3072 closedir(d);
3073 return (mount_point_index > 0);
3074}
3075
Dees_Troy38bd7602012-09-14 13:33:53 -04003076void TWPartition::Find_Actual_Block_Device(void) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06003077 if (!Sysfs_Entry.empty() && Primary_Block_Device.empty() && Decrypted_Block_Device.empty()) {
3078 /* Sysfs_Entry.empty() indicates if this is a sysfs entry that begins with /device/
3079 * If we have a syfs entry then we are looking for this device from a uevent add.
3080 * The uevent add will set the primary block device based on the data we receive from
3081 * after checking for adopted storage. If the device ends up being adopted, then the
3082 * decrypted block device will be set instead of the primary block device. */
3083 Is_Present = false;
3084 return;
3085 }
3086 if (Wildcard_Block_Device && !Is_Adopted_Storage) {
3087 Is_Present = false;
3088 Actual_Block_Device = "";
3089 Can_Be_Mounted = false;
3090 if (!Find_Wildcard_Block_Devices(Primary_Block_Device)) {
3091 string Dev = Primary_Block_Device.substr(0, Primary_Block_Device.find("*"));
3092 if (TWFunc::Path_Exists(Dev)) {
3093 Is_Present = true;
3094 Can_Be_Mounted = true;
3095 Actual_Block_Device = Dev;
3096 }
3097 }
3098 return;
3099 } else if (Is_Decrypted && !Decrypted_Block_Device.empty()) {
Dees_Troy38bd7602012-09-14 13:33:53 -04003100 Actual_Block_Device = Decrypted_Block_Device;
Ethan Yonker1b190162016-12-05 15:25:19 -06003101 if (TWFunc::Path_Exists(Decrypted_Block_Device)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04003102 Is_Present = true;
Ethan Yonker1b190162016-12-05 15:25:19 -06003103 return;
3104 }
3105 } else if (SlotSelect && TWFunc::Path_Exists(Primary_Block_Device + PartitionManager.Get_Active_Slot_Suffix())) {
3106 Actual_Block_Device = Primary_Block_Device + PartitionManager.Get_Active_Slot_Suffix();
3107 unlink(Primary_Block_Device.c_str());
3108 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
3109 Is_Present = true;
3110 return;
Dees_Troy43d8b002012-09-17 16:00:01 -04003111 } else if (TWFunc::Path_Exists(Primary_Block_Device)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04003112 Is_Present = true;
3113 Actual_Block_Device = Primary_Block_Device;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003114 return;
3115 }
Ethan Yonker1b190162016-12-05 15:25:19 -06003116 if (!Alternate_Block_Device.empty() && TWFunc::Path_Exists(Alternate_Block_Device)) {
Dees_Troy3f04d032012-10-07 18:20:09 -04003117 Actual_Block_Device = Alternate_Block_Device;
Dees_Troy38bd7602012-09-14 13:33:53 -04003118 Is_Present = true;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003119 } else {
Dees_Troy38bd7602012-09-14 13:33:53 -04003120 Is_Present = false;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003121 }
Dees_Troy38bd7602012-09-14 13:33:53 -04003122}
3123
3124void TWPartition::Recreate_Media_Folder(void) {
3125 string Command;
Ethan Yonker66a19492015-12-10 10:19:45 -06003126 string Media_Path = Mount_Point + "/media";
Dees_Troy38bd7602012-09-14 13:33:53 -04003127
Ethan Yonkerbd7492d2016-12-07 13:55:01 -06003128 if (Is_FBE) {
3129 LOGINFO("Not recreating media folder on FBE\n");
3130 return;
3131 }
Dees_Troy38bd7602012-09-14 13:33:53 -04003132 if (!Mount(true)) {
Ethan Yonker66a19492015-12-10 10:19:45 -06003133 gui_msg(Msg(msg::kError, "recreate_folder_err=Unable to recreate {1} folder.")(Media_Path));
3134 } else if (!TWFunc::Path_Exists(Media_Path)) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003135 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Ethan Yonker66a19492015-12-10 10:19:45 -06003136 LOGINFO("Recreating %s folder.\n", Media_Path.c_str());
3137 mkdir(Media_Path.c_str(), 0770);
xiaolu9416f4f2015-06-04 08:22:23 +08003138 string Internal_path = DataManager::GetStrValue("tw_internal_path");
3139 if (!Internal_path.empty()) {
3140 LOGINFO("Recreating %s folder.\n", Internal_path.c_str());
3141 mkdir(Internal_path.c_str(), 0770);
3142 }
3143#ifdef TW_INTERNAL_STORAGE_PATH
3144 mkdir(EXPAND(TW_INTERNAL_STORAGE_PATH), 0770);
3145#endif
Matt Mower87413642017-01-17 21:14:46 -06003146
thata3d31fb2014-12-21 22:27:40 +01003147 // Afterwards, we will try to set the
3148 // default metadata that we were hopefully able to get during
3149 // early boot.
Ethan Yonker66a19492015-12-10 10:19:45 -06003150 tw_set_default_metadata(Media_Path.c_str());
xiaolu9416f4f2015-06-04 08:22:23 +08003151 if (!Internal_path.empty())
3152 tw_set_default_metadata(Internal_path.c_str());
Matt Mower87413642017-01-17 21:14:46 -06003153
Ethan Yonker5eac2222014-06-11 12:22:55 -05003154 // Toggle mount to ensure that "internal sdcard" gets mounted
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003155 PartitionManager.UnMount_By_Path(Symlink_Mount_Point, true);
Ethan Yonker5eac2222014-06-11 12:22:55 -05003156 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Dees_Troy38bd7602012-09-14 13:33:53 -04003157 }
Dees_Troy43d8b002012-09-17 16:00:01 -04003158}
Dees_Troye58d5262012-09-21 12:27:57 -04003159
3160void TWPartition::Recreate_AndSec_Folder(void) {
Dees_Troye58d5262012-09-21 12:27:57 -04003161 if (!Has_Android_Secure)
3162 return;
Dees_Troy2673cec2013-04-02 20:22:16 +00003163 LOGINFO("Creating %s: %s\n", Backup_Display_Name.c_str(), Symlink_Path.c_str());
Dees_Troye58d5262012-09-21 12:27:57 -04003164 if (!Mount(true)) {
Ethan Yonker74db1572015-10-28 12:44:49 -05003165 gui_msg(Msg(msg::kError, "recreate_folder_err=Unable to recreate {1} folder.")(Backup_Name));
Dees_Troye58d5262012-09-21 12:27:57 -04003166 } else if (!TWFunc::Path_Exists(Symlink_Path)) {
Dees_Troy2673cec2013-04-02 20:22:16 +00003167 LOGINFO("Recreating %s folder.\n", Backup_Name.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003168 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05003169 mkdir(Symlink_Path.c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003170 PartitionManager.UnMount_By_Path(Symlink_Mount_Point, true);
Dees_Troye58d5262012-09-21 12:27:57 -04003171 }
3172}
bigbiff7cb4c332014-11-26 20:36:07 -05003173
3174uint64_t TWPartition::Get_Max_FileSize() {
3175 uint64_t maxFileSize = 0;
3176 const uint64_t constGB = (uint64_t) 1024 * 1024 * 1024;
3177 const uint64_t constTB = (uint64_t) constGB * 1024;
3178 const uint64_t constPB = (uint64_t) constTB * 1024;
bigbiff0c532032014-12-21 13:41:26 -05003179 if (Current_File_System == "ext4")
3180 maxFileSize = 16 * constTB; //16 TB
3181 else if (Current_File_System == "vfat")
3182 maxFileSize = 4 * constGB; //4 GB
Captain Throwback47bf7202020-10-06 17:39:39 -04003183 else if (Current_File_System == "ntfs" || Current_File_System == "tntfs")
bigbiff0c532032014-12-21 13:41:26 -05003184 maxFileSize = 256 * constTB; //256 TB
3185 else if (Current_File_System == "exfat")
3186 maxFileSize = 16 * constPB; //16 PB
3187 else if (Current_File_System == "ext3")
3188 maxFileSize = 2 * constTB; //2 TB
3189 else if (Current_File_System == "f2fs")
3190 maxFileSize = 3.94 * constTB; //3.94 TB
bigbiff7cb4c332014-11-26 20:36:07 -05003191 else
3192 maxFileSize = 100000000L;
3193 return maxFileSize - 1;
3194}
3195
bigbiffce8f83c2015-12-12 18:30:21 -05003196bool TWPartition::Flash_Image(PartitionSettings *part_settings) {
3197 string Restore_File_System, full_filename;
Ethan Yonker96af84a2015-01-05 14:58:36 -06003198
Ethan Yonkere080c1f2016-09-19 13:50:25 -05003199 full_filename = part_settings->Backup_Folder + "/" + Backup_FileName;
Ethan Yonker96af84a2015-01-05 14:58:36 -06003200
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05003201 LOGINFO("Image filename is: %s\n", Backup_FileName.c_str());
bigbiffce8f83c2015-12-12 18:30:21 -05003202
3203 if (Backup_Method == BM_FILES) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06003204 LOGERR("Cannot flash images to file systems\n");
3205 return false;
3206 } else if (!Can_Flash_Img) {
3207 LOGERR("Cannot flash images to partitions %s\n", Display_Name.c_str());
3208 return false;
3209 } else {
3210 if (!Find_Partition_Size()) {
3211 LOGERR("Unable to find partition size for '%s'\n", Mount_Point.c_str());
3212 return false;
3213 }
bigbiffce8f83c2015-12-12 18:30:21 -05003214 unsigned long long image_size = TWFunc::Get_File_Size(full_filename);
Ethan Yonker96af84a2015-01-05 14:58:36 -06003215 if (image_size > Size) {
Ethan Yonker74db1572015-10-28 12:44:49 -05003216 LOGINFO("Size (%llu bytes) of image '%s' is larger than target device '%s' (%llu bytes)\n",
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05003217 image_size, Backup_FileName.c_str(), Actual_Block_Device.c_str(), Size);
Ethan Yonker74db1572015-10-28 12:44:49 -05003218 gui_err("img_size_err=Size of image is larger than target device");
Ethan Yonker96af84a2015-01-05 14:58:36 -06003219 return false;
3220 }
bigbiffce8f83c2015-12-12 18:30:21 -05003221 if (Backup_Method == BM_DD) {
3222 if (!part_settings->adbbackup) {
3223 if (Is_Sparse_Image(full_filename)) {
3224 return Flash_Sparse_Image(full_filename);
3225 }
Ethan Yonker472f5062016-02-25 13:47:30 -06003226 }
bigbiffce8f83c2015-12-12 18:30:21 -05003227 return Raw_Read_Write(part_settings);
3228 } else if (Backup_Method == BM_FLASH_UTILS) {
3229 return Flash_Image_FI(full_filename, NULL);
Ethan Yonker472f5062016-02-25 13:47:30 -06003230 }
Ethan Yonker96af84a2015-01-05 14:58:36 -06003231 }
3232
3233 LOGERR("Unknown flash method for '%s'\n", Mount_Point.c_str());
3234 return false;
3235}
3236
Ethan Yonker472f5062016-02-25 13:47:30 -06003237bool TWPartition::Is_Sparse_Image(const string& Filename) {
HashBanged974bb2016-01-30 14:20:09 -05003238 uint32_t magic = 0;
3239 int fd = open(Filename.c_str(), O_RDONLY);
3240 if (fd < 0) {
3241 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Filename)(strerror(errno)));
3242 return false;
3243 }
bigbiffce8f83c2015-12-12 18:30:21 -05003244
HashBanged974bb2016-01-30 14:20:09 -05003245 if (read(fd, &magic, sizeof(magic)) != sizeof(magic)) {
3246 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Filename)(strerror(errno)));
3247 close(fd);
3248 return false;
3249 }
3250 close(fd);
Ethan Yonker472f5062016-02-25 13:47:30 -06003251 if (magic == SPARSE_HEADER_MAGIC)
3252 return true;
3253 return false;
3254}
3255
3256bool TWPartition::Flash_Sparse_Image(const string& Filename) {
3257 string Command;
3258
3259 gui_msg(Msg("flashing=Flashing {1}...")(Display_Name));
3260
3261 Command = "simg2img '" + Filename + "' '" + Actual_Block_Device + "'";
Ethan Yonker96af84a2015-01-05 14:58:36 -06003262 LOGINFO("Flash command: '%s'\n", Command.c_str());
3263 TWFunc::Exec_Cmd(Command);
3264 return true;
3265}
3266
Ethan Yonker472f5062016-02-25 13:47:30 -06003267bool TWPartition::Flash_Image_FI(const string& Filename, ProgressTracking *progress) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06003268 string Command;
Ethan Yonker472f5062016-02-25 13:47:30 -06003269 unsigned long long file_size;
Ethan Yonker96af84a2015-01-05 14:58:36 -06003270
Ethan Yonker74db1572015-10-28 12:44:49 -05003271 gui_msg(Msg("flashing=Flashing {1}...")(Display_Name));
Ethan Yonker472f5062016-02-25 13:47:30 -06003272 if (progress) {
3273 file_size = (unsigned long long)(TWFunc::Get_File_Size(Filename));
3274 progress->SetPartitionSize(file_size);
3275 }
Ethan Yonker96af84a2015-01-05 14:58:36 -06003276 // Sometimes flash image doesn't like to flash due to the first 2KB matching, so we erase first to ensure that it flashes
3277 Command = "erase_image " + MTD_Name;
3278 LOGINFO("Erase command: '%s'\n", Command.c_str());
3279 TWFunc::Exec_Cmd(Command);
3280 Command = "flash_image " + MTD_Name + " '" + Filename + "'";
3281 LOGINFO("Flash command: '%s'\n", Command.c_str());
3282 TWFunc::Exec_Cmd(Command);
Ethan Yonker472f5062016-02-25 13:47:30 -06003283 if (progress)
3284 progress->UpdateSize(file_size);
Ethan Yonker96af84a2015-01-05 14:58:36 -06003285 return true;
3286}
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05003287
3288void TWPartition::Change_Mount_Read_Only(bool new_value) {
3289 Mount_Read_Only = new_value;
3290}
3291
bigbiffce8f83c2015-12-12 18:30:21 -05003292bool TWPartition::Is_Read_Only() {
3293 return Mount_Read_Only;
3294}
3295
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05003296int TWPartition::Check_Lifetime_Writes() {
3297 bool original_read_only = Mount_Read_Only;
3298 int ret = 1;
3299
3300 Mount_Read_Only = true;
3301 if (Mount(false)) {
3302 Find_Actual_Block_Device();
Ethan Yonker54970bb2019-01-17 16:19:24 -06003303 string temp = Actual_Block_Device;
3304 Find_Real_Block_Device(temp, false);
3305 string block = basename(temp.c_str());
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05003306 string file = "/sys/fs/" + Current_File_System + "/" + block + "/lifetime_write_kbytes";
3307 string result;
3308 if (TWFunc::Path_Exists(file)) {
3309 if (TWFunc::read_file(file, result) != 0) {
3310 LOGINFO("Check_Lifetime_Writes of '%s' failed to read_file\n", file.c_str());
3311 } else {
3312 LOGINFO("Check_Lifetime_Writes result: '%s'\n", result.c_str());
3313 if (result == "0") {
3314 ret = 0;
3315 }
3316 }
3317 } else {
3318 LOGINFO("Check_Lifetime_Writes file does not exist '%s'\n", file.c_str());
3319 }
3320 UnMount(true);
3321 } else {
3322 LOGINFO("Check_Lifetime_Writes failed to mount '%s'\n", Mount_Point.c_str());
3323 }
3324 Mount_Read_Only = original_read_only;
3325 return ret;
3326}
Ethan Yonker66a19492015-12-10 10:19:45 -06003327
3328int TWPartition::Decrypt_Adopted() {
3329#ifdef TW_INCLUDE_CRYPTO
3330 int ret = 1;
3331 Is_Adopted_Storage = false;
3332 string Adopted_Key_File = "";
3333
3334 if (!Removable)
3335 return ret;
3336
3337 int fd = open(Alternate_Block_Device.c_str(), O_RDONLY);
3338 if (fd < 0) {
3339 LOGINFO("failed to open '%s'\n", Alternate_Block_Device.c_str());
3340 return ret;
3341 }
3342 char type_guid[80];
3343 char part_guid[80];
3344
nkk713c1e35f2017-03-24 18:28:03 +02003345 uint32_t p_num;
3346 size_t last_digit = Primary_Block_Device.find_last_not_of("0123456789");
3347 if ((last_digit != string::npos) && (last_digit != Primary_Block_Device.length()-1))
3348 p_num = atoi(Primary_Block_Device.substr(last_digit + 1).c_str()) + 1;
3349 else
3350 p_num = 2;
3351
3352 if (gpt_disk_get_partition_info(fd, p_num, type_guid, part_guid) == 0) {
Ethan Yonker66a19492015-12-10 10:19:45 -06003353 LOGINFO("type: '%s'\n", type_guid);
3354 LOGINFO("part: '%s'\n", part_guid);
3355 Adopted_GUID = part_guid;
3356 LOGINFO("Adopted_GUID '%s'\n", Adopted_GUID.c_str());
3357 if (strcmp(type_guid, TWGptAndroidExpand) == 0) {
3358 LOGINFO("android_expand found\n");
3359 Adopted_Key_File = "/data/misc/vold/expand_";
3360 Adopted_Key_File += part_guid;
3361 Adopted_Key_File += ".key";
3362 if (TWFunc::Path_Exists(Adopted_Key_File)) {
3363 Is_Adopted_Storage = true;
3364 /* Until we find a use case for this, I think it is safe
3365 * to disable USB Mass Storage whenever adopted storage
3366 * is present.
3367 */
nkk713c1e35f2017-03-24 18:28:03 +02003368 if (p_num == 2) {
3369 // TODO: Properly detect mixed vs fully adopted storage. Maybe this
3370 // should be moved to partitionmanager instead, and disable after
3371 // checking all partitions. Also the presence of adopted storage does
3372 // not necessarily mean it's being used as Internal Storage
3373 LOGINFO("Detected adopted storage, disabling USB mass storage mode\n");
3374 DataManager::SetValue("tw_has_usb_storage", 0);
3375 }
Ethan Yonker66a19492015-12-10 10:19:45 -06003376 }
3377 }
3378 }
3379
3380 if (Is_Adopted_Storage) {
nkk713c1e35f2017-03-24 18:28:03 +02003381 string Adopted_Block_Device = Alternate_Block_Device + "p" + TWFunc::to_string(p_num);
Ethan Yonker66a19492015-12-10 10:19:45 -06003382 if (!TWFunc::Path_Exists(Adopted_Block_Device)) {
nkk713c1e35f2017-03-24 18:28:03 +02003383 Adopted_Block_Device = Alternate_Block_Device + TWFunc::to_string(p_num);
Ethan Yonker66a19492015-12-10 10:19:45 -06003384 if (!TWFunc::Path_Exists(Adopted_Block_Device)) {
3385 LOGINFO("Adopted block device does not exist\n");
3386 goto exit;
3387 }
3388 }
3389 LOGINFO("key file is '%s', block device '%s'\n", Adopted_Key_File.c_str(), Adopted_Block_Device.c_str());
3390 char crypto_blkdev[MAXPATHLEN];
3391 std::string thekey;
3392 int fdkey = open(Adopted_Key_File.c_str(), O_RDONLY);
3393 if (fdkey < 0) {
3394 LOGINFO("failed to open key file\n");
3395 goto exit;
3396 }
3397 char buf[512];
3398 ssize_t n;
3399 while ((n = read(fdkey, &buf[0], sizeof(buf))) > 0) {
3400 thekey.append(buf, n);
3401 }
3402 close(fdkey);
3403 unsigned char* key = (unsigned char*) thekey.data();
3404 cryptfs_revert_ext_volume(part_guid);
3405
3406 ret = cryptfs_setup_ext_volume(part_guid, Adopted_Block_Device.c_str(), key, thekey.size(), crypto_blkdev);
3407 if (ret == 0) {
3408 LOGINFO("adopted storage new block device: '%s'\n", crypto_blkdev);
3409 Decrypted_Block_Device = crypto_blkdev;
3410 Is_Decrypted = true;
3411 Is_Encrypted = true;
3412 Find_Actual_Block_Device();
Kjell Braden3126a112016-06-19 16:58:15 +00003413 if (!Mount_Storage_Retry(false)) {
Ethan Yonker66a19492015-12-10 10:19:45 -06003414 LOGERR("Failed to mount decrypted adopted storage device\n");
3415 Is_Decrypted = false;
3416 Is_Encrypted = false;
3417 cryptfs_revert_ext_volume(part_guid);
3418 ret = 1;
3419 } else {
Ethan Yonkerfcf3f242016-02-16 12:30:26 -06003420 UnMount(false);
3421 Has_Android_Secure = false;
3422 Symlink_Path = "";
3423 Symlink_Mount_Point = "";
3424 Backup_Name = Mount_Point.substr(1);
3425 Backup_Path = Mount_Point;
3426 TWPartition* sdext = PartitionManager.Find_Partition_By_Path("/sd-ext");
3427 if (sdext && sdext->Actual_Block_Device == Adopted_Block_Device) {
3428 LOGINFO("Removing /sd-ext from partition list due to adopted storage\n");
3429 PartitionManager.Remove_Partition_By_Path("/sd-ext");
3430 }
Ethan Yonker66a19492015-12-10 10:19:45 -06003431 Setup_Data_Media();
Ethan Yonker66a19492015-12-10 10:19:45 -06003432 Wipe_Available_in_GUI = true;
3433 Wipe_During_Factory_Reset = true;
3434 Can_Be_Backed_Up = true;
3435 Can_Encrypt_Backup = true;
3436 Use_Userdata_Encryption = true;
3437 Is_Storage = true;
3438 Storage_Name = "Adopted Storage";
3439 Is_SubPartition = true;
3440 SubPartition_Of = "/data";
3441 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
3442 DataManager::SetValue("tw_has_adopted_storage", 1);
3443 }
3444 } else {
3445 LOGERR("Failed to setup adopted storage decryption\n");
3446 }
3447 }
3448exit:
Matt Mower06543e32017-01-06 15:25:26 -06003449 close(fd);
Ethan Yonker66a19492015-12-10 10:19:45 -06003450 return ret;
3451#else
3452 LOGINFO("Decrypt_Adopted: no crypto support\n");
3453 return 1;
3454#endif
3455}
3456
3457void TWPartition::Revert_Adopted() {
3458#ifdef TW_INCLUDE_CRYPTO
3459 if (!Adopted_GUID.empty()) {
3460 PartitionManager.Remove_MTP_Storage(Mount_Point);
3461 UnMount(false);
3462 cryptfs_revert_ext_volume(Adopted_GUID.c_str());
3463 Is_Adopted_Storage = false;
3464 Is_Encrypted = false;
3465 Is_Decrypted = false;
3466 Decrypted_Block_Device = "";
3467 Find_Actual_Block_Device();
3468 Wipe_During_Factory_Reset = false;
3469 Can_Be_Backed_Up = false;
3470 Can_Encrypt_Backup = false;
3471 Use_Userdata_Encryption = false;
3472 Is_SubPartition = false;
3473 SubPartition_Of = "";
3474 Has_Data_Media = false;
3475 Storage_Path = Mount_Point;
3476 if (!Symlink_Mount_Point.empty()) {
3477 TWPartition* Dat = PartitionManager.Find_Partition_By_Path("/data");
3478 if (Dat) {
3479 Dat->UnMount(false);
3480 Dat->Symlink_Mount_Point = Symlink_Mount_Point;
3481 }
3482 Symlink_Mount_Point = "";
3483 }
3484 }
3485#else
3486 LOGINFO("Revert_Adopted: no crypto support\n");
3487#endif
3488}
bigbiff bigbiffb5ecaad2017-03-20 18:53:53 -04003489
3490void TWPartition::Set_Backup_FileName(string fname) {
3491 Backup_FileName = fname;
3492}
3493
3494string TWPartition::Get_Backup_Name() {
3495 return Backup_Name;
3496}
bigbiffee7b7ff2020-03-23 15:08:27 -04003497
3498string TWPartition::Get_Mount_Point() {
3499 return Mount_Point;
3500}
3501
3502void TWPartition::Set_Block_Device(std::string block_device) {
3503 Primary_Block_Device = Actual_Block_Device = block_device;
3504}
3505
3506bool TWPartition::Get_Super_Status() {
3507 return Is_Super;
3508}
3509
3510void TWPartition::Set_Can_Be_Backed_Up(bool val) {
3511 Can_Be_Backed_Up = val;
3512}
3513
3514void TWPartition::Set_Can_Be_Wiped(bool val) {
3515 Can_Be_Wiped = val;
3516 Wipe_Available_in_GUI = val;
bigbiffad58e1b2020-07-06 20:24:34 -04003517}
3518
3519std::string TWPartition::Get_Backup_FileName() {
3520 return Backup_FileName;
3521}
3522
3523std::string TWPartition::Get_Display_Name() {
3524 return Display_Name;
3525}
3526
3527bool TWPartition::Is_SlotSelect() {
3528 return SlotSelect;
Mohd Faraz815e2402020-09-19 19:31:52 +05303529}